diff options
Diffstat (limited to 'usr/src/cmd/cmd-inet/usr.sbin')
77 files changed, 50960 insertions, 0 deletions
diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/Makefile b/usr/src/cmd/cmd-inet/usr.sbin/snoop/Makefile new file mode 100644 index 0000000..1d408bc --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/Makefile @@ -0,0 +1,80 @@ +# +# CDDL HEADER START +# +# The contents of this file are subject to the terms of the +# Common Development and Distribution License (the "License"). +# You may not use this file except in compliance with the License. +# +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE +# or http://www.opensolaris.org/os/licensing. +# See the License for the specific language governing permissions +# and limitations under the License. +# +# When distributing Covered Code, include this CDDL HEADER in each +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. +# If applicable, add the following below this CDDL HEADER, with the +# fields enclosed by brackets "[]" replaced with your own identifying +# information: Portions Copyright [yyyy] [name of copyright owner] +# +# CDDL HEADER END + + +# +# Copyright 2009 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# + +PROG= snoop +OBJS= nfs4_xdr.o snoop.o snoop_aarp.o snoop_adsp.o snoop_aecho.o \ + snoop_apple.o snoop_arp.o snoop_atp.o snoop_bparam.o \ + snoop_bpdu.o \ + snoop_capture.o snoop_dhcp.o snoop_dhcpv6.o snoop_display.o \ + snoop_dns.o snoop_ether.o \ + snoop_filter.o snoop_http.o snoop_icmp.o snoop_igmp.o snoop_ip.o \ + snoop_ipaddr.o snoop_ipsec.o snoop_isis.o \ + snoop_ldap.o snoop_mip.o snoop_mount.o \ + snoop_nbp.o snoop_netbios.o snoop_nfs.o snoop_nfs3.o snoop_nfs4.o \ + snoop_nfs_acl.o snoop_nis.o snoop_nlm.o snoop_ntp.o \ + snoop_pf.o snoop_ospf.o snoop_ospf6.o snoop_pmap.o snoop_ppp.o \ + snoop_pppoe.o snoop_rip.o snoop_rip6.o snoop_rpc.o snoop_rpcprint.o \ + snoop_rpcsec.o snoop_rport.o snoop_rquota.o snoop_rstat.o snoop_rtmp.o \ + snoop_sctp.o snoop_slp.o snoop_smb.o snoop_socks.o snoop_solarnet.o \ + snoop_tcp.o snoop_tftp.o snoop_trill.o snoop_udp.o snoop_zip.o + +SRCS= $(OBJS:.o=.c) +HDRS= snoop.h snoop_mip.h at.h snoop_ospf.h snoop_ospf6.h + +include ../../../Makefile.cmd + +CPPFLAGS += -I. -I$(SRC)/common/net/dhcp \ + -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 +LDLIBS += -ldhcputil -ldlpi -lsocket -lnsl -ltsol +LDFLAGS += $(MAPFILE.NGB:%=-M%) +CERRWARN += -_gcc=-Wno-switch +CERRWARN += -_gcc=-Wno-implicit-function-declaration +CERRWARN += -_gcc=-Wno-uninitialized +CERRWARN += -_gcc=-Wno-clobbered +CERRWARN += -_gcc=-Wno-unused-value +CERRWARN += -_gcc=-Wno-parentheses +CERRWARN += -_gcc=-Wno-unused-variable +CERRWARN += -_gcc=-Wno-unused-label +CERRWARN += -_gcc=-Wno-unused-function + +.KEEP_STATE: + +.PARALLEL: $(OBJS) + +all: $(PROG) + +$(PROG): $(OBJS) $(MAPFILE.NGB) + $(LINK.c) -o $@ $(OBJS) $(LDLIBS) + $(POST_PROCESS) + +install: all $(ROOTUSRSBINPROG) + +clean: + $(RM) $(OBJS) + +lint: lint_SRCS + +include ../../../Makefile.targ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/at.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/at.h new file mode 100644 index 0000000..e98072f --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/at.h @@ -0,0 +1,206 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + * + */ + +#ifndef _AT_H +#define _AT_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * There is a lot of alignment problems in AppleTalk packets. + * This is the reason some of the headers use uint8_t arrays instead of the + * natural datatype. + */ + +/* AARP */ + +#define AARP_REQ 1 +#define AARP_RESP 2 +#define AARP_PROBE 3 + + +/* DDP */ + +struct ddp_hdr { + uint8_t ddp_hop_len; + uint8_t ddp_len_lo; + uint16_t ddp_cksum; + uint16_t ddp_dest_net; + uint16_t ddp_src_net; + uint8_t ddp_dest_id; + uint8_t ddp_src_id; + uint8_t ddp_dest_sock; + uint8_t ddp_src_sock; + uint8_t ddp_type; +}; + +#define ddp_pad(x) ((x)->ddp_hop_len & 0xc0) +#define ddp_hop(x) (((x)->ddp_hop_len >> 2) & 0xf) +#define ddp_len(x) ((((x)->ddp_hop_len & 0x3) << 8) + (x)->ddp_len_lo) + +#define DDPHDR_SIZE 13 + +#define DDP_TYPE_RTMPRQ 5 +#define DDP_TYPE_RTMPRESP 1 +#define DDP_TYPE_NBP 2 +#define DDP_TYPE_ATP 3 +#define DDP_TYPE_AEP 4 +#define DDP_TYPE_ZIP 6 +#define DDP_TYPE_ADSP 7 + + +/* AECHO */ + +#define AEP_REQ 1 +#define AEP_REPLY 2 + +/* NBP */ + +struct nbp_hdr { + uint8_t ddphdr[DDPHDR_SIZE]; + uint8_t nbp_fun_cnt; + uint8_t nbp_id; +}; + +#define NBP_BRRQ 1 +#define NBP_LKUP 2 +#define NBP_LKUP_REPLY 3 +#define NBP_FWDREQ 4 + + +/* ZIP */ + +struct zip_hdr { + uint8_t ddphdr[DDPHDR_SIZE]; + uint8_t zip_func; + uint8_t zip_netcnt; +}; + +#define ZIP_QUERY 1 +#define ZIP_REPLY 2 +#define ZIP_GET_NET_INFO 5 +#define ZIP_GET_NET_INFO_REPLY 6 +#define ZIP_NOTIFY 7 +#define ZIP_EXT_REPLY 8 + +#define ZIP_ATP_GETMYZONE 7 +#define ZIP_ATP_GETZONELIST 8 +#define ZIP_ATP_GETLOCALZONES 9 + +#define ZIP_FLG_ONEZ 0x20 +#define ZIP_FLG_USEBRC 0x40 +#define ZIP_FLG_ZINV 0x80 + + +/* ATP */ + +struct atp_hdr { + uint8_t ddphdr[DDPHDR_SIZE]; + uint8_t atp_ctrl; + uint8_t atp_seq; + uint8_t atp_tid[2]; + uint8_t atp_user[4]; +}; + +#define ATPHDR_SIZE 8 + +#define atp_fun(x) (((x) >> 6) & 0x3) +#define atp_tmo(x) ((x) & 0x7) + +#define ATP_TREQ 1 +#define ATP_TRESP 2 +#define ATP_TREL 3 +#define ATP_FLG_STS 0x08 +#define ATP_FLG_EOM 0x10 +#define ATP_FLG_XO 0x20 + + +#define NODE_ID_BROADCAST 0xff + +struct ddp_adsphdr { + uint8_t ddphdr[DDPHDR_SIZE]; + uint8_t ad_connid[2]; /* short */ + uint8_t ad_fbseq[4]; /* long */ + uint8_t ad_nrseq[4]; /* long */ + uint8_t ad_rcvwin[2]; /* short */ + uint8_t ad_desc; +}; + +#define AD_CTRL 0x80 +#define AD_ACKREQ 0x40 +#define AD_EOM 0x20 +#define AD_ATT 0x10 +#define AD_CTRL_MASK 0x0f + +#define AD_CREQ 0x81 /* Open Conn Request */ +#define AD_CACK 0x82 /* Open Conn Ack */ +#define AD_CREQ_ACK 0x83 /* Open Conn Req+Ack */ +#define AD_CDENY 0x84 /* Open Conn Denial */ + +struct ddp_adsp_att { + struct ddp_adsphdr ad; + uint8_t ad_att_code[2]; /* short */ +}; + +struct ddp_adsp_open { + struct ddp_adsphdr ad; + uint8_t ad_version[2]; /* short */ + uint8_t ad_dconnid[2]; /* short */ + uint8_t ad_attseq[4]; /* long */ +}; + +#define RTMP_REQ 1 +#define RTMP_RDR_SH 2 /* Route Data Request, split horizon */ +#define RTMP_RDR_NSH 3 /* Route Data Request, no split horizon */ + +#define RTMP_DIST_MASK 0x1f +#define RTMP_EXTEND 0x80 +#define RTMP_FILLER 0x82 + + +uint16_t get_short(uint8_t *); +uint32_t get_long(uint8_t *); + +extern void interpret_aarp(int, char *, int); +extern void interpret_at(int, struct ddp_hdr *, int); +extern void interpret_nbp(int, struct nbp_hdr *, int); +extern void interpret_rtmp(int, struct ddp_hdr *, int); +extern void interpret_aecho(int, struct ddp_hdr *, int); +extern void interpret_atp(int, struct ddp_hdr *, int); +extern void interpret_adsp(int, struct ddp_adsphdr *, int); +extern void interpret_ddp_zip(int, struct zip_hdr *, int); +extern void interpret_atp_zip(int, struct atp_hdr *, int); + +#ifdef __cplusplus +} +#endif + +#endif /* _AT_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/fakewin.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fakewin.h new file mode 100644 index 0000000..d075e0b --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fakewin.h @@ -0,0 +1,71 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1993 by Sun Microsystems, Inc. + */ + +#ifndef _FAKEWIN_H +#define _FAKEWIN_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * This file defines appropriate macros so that + * we can use the same codebase for Unix, DOS, and Windows. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _WINDOWS +#include <tklib.h> + +#define malloc _fmalloc +#define calloc _fcalloc +#define free _ffree +#define strdup _fstrdup +#define strcpy _fstrcpy +#define strcmp _fstrcmp +#define strchr _fstrchr +#define sprintf wsprintf +#define vsprintf wvsprintf +#define memcpy _fmemcpy +#define strlen _fstrlen +#else +#define LPSTR char * +#endif + +#if !defined(_WINDOWS) && !defined(_MSDOS) +#define _TKFAR +#endif + +#ifndef _WINDOWS +#define _TKPASCAL +#define __export +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !_FAKEWIN_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw.h new file mode 100644 index 0000000..3274623 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw.h @@ -0,0 +1,147 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1993 by Sun Microsystems, Inc. + */ + +#ifndef _FW_H +#define _FW_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <rpc/rpc.h> +#include "fakewin.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Header file for the framework. + */ +#define CTXTLEN 1024 + +struct Op_arg_item { + char _TKFAR *name; + char _TKFAR *value; + struct Op_arg_item _TKFAR *next; +}; +typedef struct Op_arg_item Op_arg_item; + +struct Op_row_link { + Op_arg_item _TKFAR *first; + Op_arg_item _TKFAR *last; + struct Op_row_link _TKFAR *next; +}; +typedef struct Op_row_link Op_row_link; + +struct Op_arg { + Op_row_link _TKFAR *first; + Op_row_link _TKFAR *last; + Op_row_link _TKFAR *curr; + Op_arg_item _TKFAR *cura; + u_long rows; + bool_t xdr_flag; +}; +typedef struct Op_arg Op_arg; + +enum Fw_err { + FW_ERR_NONE = 0, + FW_ERR_FW = 1, + FW_ERR_OP = 2 +}; +typedef enum Fw_err Fw_err; + +struct Op_err { + Fw_err type; + u_long code; + bool_t xdr_flag; + char _TKFAR *message; +}; +typedef struct Op_err Op_err; + +typedef char invk_context[CTXTLEN]; + +struct invk_result { + Op_err _TKFAR *err; + Op_arg _TKFAR *arg; + bool_t eof; +}; +typedef struct invk_result invk_result; + +struct invk_request { + char _TKFAR *category; + char _TKFAR *op; + char _TKFAR *vers; + char _TKFAR *locale; + u_long threshold; + invk_context context; + Op_arg _TKFAR *arg; +}; +typedef struct invk_request invk_request; + +struct more_request { + invk_context context; + u_long threshold; +}; +typedef struct more_request more_request; + +struct kill_request { + invk_context context; +}; +typedef struct kill_request kill_request; + +#define FW_KV_DELIM "=" +#define FW_KV_DELIM_CH '=' +#define FW_VK_DELIM "\n" +#define FW_VK_DELIM_CH '\n'; +#define FW_INPUT_VERS_VAL 1 +#define FW_INPUT_VERS_STR "1" +#define FW_OUTPUT_VERS_VAL 1 +#define FW_OUTPUT_VERS_STR "1" +#define FW_INPUT_VERS_KEY "_SUNW_AO_INPUT_VERS" +#define FW_OUTPUT_VERS_KEY "_SUNW_AO_OUTPUT_VERS" +#define FW_ROW_MARKER_KEY "_SUNW_AO_BEGIN_ROW" +#define FW_ROW_MARKER FW_ROW_MARKER_KEY FW_KV_DELIM FW_OUTPUT_VERS_STR \ + FW_VK_DELIM +#define FW_INPUT_VERS FW_INPUT_VERS_KEY FW_KV_DELIM FW_INPUT_VERS_STR \ + FW_VK_DELIM +#define FW_OUTPUT_VERS FW_OUTPUT_VERS_KEY FW_KV_DELIM FW_OUTPUT_VERS_STR \ + FW_VK_DELIM +#define FW_ERR_MSG_MAX 2047 +#define FW_UNIX_USER "UU" + +#define FW_SUCCESS 0 +#define FW_ERROR -1 +#define FW_TIMEOUT -2 + +#define SN_LOCALE_PATH_VAR "_SN_LOCALE_PATH" +#define SN_UNAME_VAR "_SN_UNAME" +#define SN_UID_VAR "_SN_UID" + +#include "fw_lib.h" + +#ifdef __cplusplus +} +#endif + +#endif /* !_FW_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_lib.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_lib.h new file mode 100644 index 0000000..36e7e40 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_lib.h @@ -0,0 +1,96 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1993 by Sun Microsystems, Inc. + */ + +#ifndef _FW_LIB_H +#define _FW_LIB_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __STDC__ + +extern short net_invoke(char _TKFAR *, char _TKFAR *, char _TKFAR *, + char _TKFAR *, u_long, u_long, char _TKFAR *, + invk_context, Op_arg _TKFAR * _TKFAR *, Op_err _TKFAR * _TKFAR *, ...); +extern short net_more(u_long, u_long, invk_context, Op_arg _TKFAR * _TKFAR *, + Op_err _TKFAR * _TKFAR *); +extern short net_end(u_long, invk_context, Op_err _TKFAR * _TKFAR *); +extern Op_arg _TKFAR *net_arg_init(void); +extern short net_arg_set(char _TKFAR *, ...); +extern short net_arg_markrow(void); +extern short net_arg_get(Op_arg _TKFAR *, char _TKFAR *, + char _TKFAR * _TKFAR *); +extern short net_arg_getnext(Op_arg _TKFAR *, char _TKFAR * _TKFAR *, + char _TKFAR * _TKFAR *); +extern short net_arg_nextrow(Op_arg _TKFAR *); +extern short net_arg_rowstart(Op_arg _TKFAR *); +extern short net_arg_reset(Op_arg _TKFAR *); +extern void net_arg_free(Op_arg _TKFAR *); +extern void net_err_free(Op_err _TKFAR *); +extern Op_arg _TKFAR *new_Op_arg(void); +extern void free_Op_arg(Op_arg _TKFAR *); +extern void free_Op_err(Op_err _TKFAR *); +extern short append_Op_arg(Op_arg _TKFAR *, char _TKFAR *, char _TKFAR *); +extern void fw_err_set(Op_err _TKFAR * _TKFAR *, Fw_err, u_long, ...); + +#ifdef _WINDOWS +extern void net_cleanup(void); +#endif + +#else + +extern short net_invoke(); +extern short net_more(); +extern short net_end(); +extern Op_arg _TKFAR *net_arg_init(); +extern short net_arg_set(); +extern short net_arg_markrow(); +extern short net_arg_get(); +extern short net_arg_getnext(); +extern short net_arg_nextrow(); +extern short net_arg_rowstart(); +extern short net_arg_reset(); +extern void net_arg_free(); +extern void net_err_free(); +extern Op_arg _TKFAR *new_Op_arg(); +extern void free_Op_arg(); +extern void free_Op_err(); +extern short append_Op_arg(); +extern void fw_err_set(); + +#ifdef _WINDOWS +extern void net_cleanup(); +#endif + +#endif /* __STDC__ */ + +#ifdef __cplusplus +} +#endif + +#endif /* !_FW_LIB_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_rpc.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_rpc.h new file mode 100644 index 0000000..b44f3cd --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/fw_rpc.h @@ -0,0 +1,78 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1993 by Sun Microsystems, Inc. + */ + +/* + * This file contains definitions which are only of interest to the actual + * service daemon and client stubs. Normal framework users will not include + * this file. + */ + +#ifndef _FW_RPC_H +#define _FW_RPC_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#ifdef __cplusplus +extern "C" { +#endif + +#define FW_NO_CONTEXT "Plead no context" + +#define FW_PROG ((unsigned long)(150006)) +#define FW_VERSION ((unsigned long)(1)) + +#define FW_INVOKE ((unsigned long)(1)) +#define FW_MORE ((unsigned long)(2)) +#define FW_KILL ((unsigned long)(3)) + + +/* the xdr functions */ + +extern bool_t _TKFAR _TKPASCAL xdr_Op_arg(XDR _TKFAR *, Op_arg _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_Fw_err(XDR _TKFAR *, Fw_err _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_Op_err(XDR _TKFAR *, Op_err _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_invk_context(XDR _TKFAR *, invk_context); +extern bool_t _TKFAR _TKPASCAL xdr_invk_result(XDR _TKFAR *, + invk_result _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_invk_request(XDR _TKFAR *, + invk_request _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_more_request(XDR _TKFAR *, + more_request _TKFAR *); +extern bool_t _TKFAR _TKPASCAL xdr_kill_request(XDR _TKFAR *, + kill_request _TKFAR *); + +#ifdef _WINDOWS +extern void thunk_xdrs(void); +extern void unthunk_xdrs(void); +extern FARPROC lp_xdr_invk_request, lp_xdr_invk_result; +extern FARPROC lp_xdr_more_request, lp_xdr_kill_request; +extern FARPROC lp_xdr_Op_err, lp_xdr_Op_arg; +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !_FW_RPC_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/inc.flg b/usr/src/cmd/cmd-inet/usr.sbin/snoop/inc.flg new file mode 100644 index 0000000..d7246ea --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/inc.flg @@ -0,0 +1,30 @@ +#!/bin/sh +# +# CDDL HEADER START +# +# The contents of this file are subject to the terms of the +# Common Development and Distribution License, Version 1.0 only +# (the "License"). You may not use this file except in compliance +# with the License. +# +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE +# or http://www.opensolaris.org/os/licensing. +# See the License for the specific language governing permissions +# and limitations under the License. +# +# When distributing Covered Code, include this CDDL HEADER in each +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. +# If applicable, add the following below this CDDL HEADER, with the +# fields enclosed by brackets "[]" replaced with your own identifying +# information: Portions Copyright [yyyy] [name of copyright owner] +# +# CDDL HEADER END +# +# +# Copyright 2003 Sun Microsystems, Inc. All rights reserved. +# Use is subject to license terms. +# +# ident "%Z%%M% %I% %E% SMI" +# + +find_files "s.*" usr/src/common/net/dhcp diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/nfs4_xdr.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/nfs4_xdr.c new file mode 100644 index 0000000..0ee7a6c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/nfs4_xdr.c @@ -0,0 +1,2972 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * This file was initially generated using rpcgen. The rpcgen-erated + * code used tail recursion to implement linked lists which resulted + * in various crashes due to blown stacks. If the NFS4 protocol changes + * be sure to either use the NFS4-friendly rpcgen (doesn't use tail + * recursion) or do the xdr by hand. + * + * CAUTION: This file is kept in sync with it's uts counterpart: + * + * usr/src/uts/common/fs/nfs/nfs4_xdr.c + * + * However, it is not an exact copy. NEVER copy uts's nfs4_xdr.c + * directly over this file. Changes from the uts version must be + * integrated by hand into this file. + */ + +#include <rpcsvc/nfs4_prot.h> +#include <nfs/nfs4.h> +#include <malloc.h> + +#define IGNORE_RDWR_DATA + +extern int nfs4_skip_bytes; + +bool_t +xdr_nfs_ftype4(register XDR *xdrs, nfs_ftype4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfsstat4(register XDR *xdrs, nfsstat4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_bitmap4(register XDR *xdrs, bitmap4 *objp) +{ + + if (!xdr_array(xdrs, (char **)&objp->bitmap4_val, + (uint_t *)&objp->bitmap4_len, ~0, + sizeof (uint32_t), (xdrproc_t)xdr_uint32_t)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_offset4(register XDR *xdrs, offset4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_count4(register XDR *xdrs, count4 *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_length4(register XDR *xdrs, length4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_clientid4(register XDR *xdrs, clientid4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_seqid4(register XDR *xdrs, seqid4 *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_utf8string(register XDR *xdrs, utf8string *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->utf8string_val, + (uint_t *)&objp->utf8string_len, NFS4_MAX_UTF8STRING)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_component4(register XDR *xdrs, component4 *objp) +{ + + if (!xdr_utf8string(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_pathname4(register XDR *xdrs, pathname4 *objp) +{ + + if (!xdr_array(xdrs, (char **)&objp->pathname4_val, + (uint_t *)&objp->pathname4_len, NFS4_MAX_PATHNAME4, + sizeof (component4), (xdrproc_t)xdr_component4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_lockid4(register XDR *xdrs, nfs_lockid4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_cookie4(register XDR *xdrs, nfs_cookie4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_linktext4(register XDR *xdrs, linktext4 *objp) +{ + + if (!xdr_utf8string(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_sec_oid4(register XDR *xdrs, sec_oid4 *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->sec_oid4_val, + (uint_t *)&objp->sec_oid4_len, NFS4_MAX_SECOID4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_qop4(register XDR *xdrs, qop4 *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_mode4(register XDR *xdrs, mode4 *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_changeid4(register XDR *xdrs, changeid4 *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_verifier4(register XDR *xdrs, verifier4 objp) +{ + + if (!xdr_opaque(xdrs, objp, NFS4_VERIFIER_SIZE)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfstime4(register XDR *xdrs, nfstime4 *objp) +{ + + if (!xdr_int64_t(xdrs, &objp->seconds)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->nseconds)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_time_how4(register XDR *xdrs, time_how4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_settime4(register XDR *xdrs, settime4 *objp) +{ + + if (!xdr_time_how4(xdrs, &objp->set_it)) + return (FALSE); + switch (objp->set_it) { + case SET_TO_CLIENT_TIME4: + if (!xdr_nfstime4(xdrs, &objp->settime4_u.time)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_nfs_fh4(register XDR *xdrs, nfs_fh4 *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->nfs_fh4_val, + (uint_t *)&objp->nfs_fh4_len, NFS4_FHSIZE)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fsid4(register XDR *xdrs, fsid4 *objp) +{ + + if (!xdr_uint64_t(xdrs, &objp->major)) + return (FALSE); + if (!xdr_uint64_t(xdrs, &objp->minor)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fs_location4(register XDR *xdrs, fs_location4 *objp) +{ + + if (!xdr_array(xdrs, (char **)&objp->server.server_val, + (uint_t *)&objp->server.server_len, ~0, + sizeof (utf8string), (xdrproc_t)xdr_utf8string)) + return (FALSE); + if (!xdr_pathname4(xdrs, &objp->rootpath)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fs_locations4(register XDR *xdrs, fs_locations4 *objp) +{ + + if (!xdr_pathname4(xdrs, &objp->fs_root)) + return (FALSE); + if (!xdr_array(xdrs, (char **)&objp->locations.locations_val, + (uint_t *)&objp->locations.locations_len, ~0, + sizeof (fs_location4), (xdrproc_t)xdr_fs_location4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_acetype4(register XDR *xdrs, acetype4 *objp) +{ + + if (!xdr_u_int(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_aceflag4(register XDR *xdrs, aceflag4 *objp) +{ + + if (!xdr_u_int(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_acemask4(register XDR *xdrs, acemask4 *objp) +{ + + if (!xdr_u_int(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfsace4(register XDR *xdrs, nfsace4 *objp) +{ + if (!xdr_acetype4(xdrs, &objp->type)) + return (FALSE); + if (!xdr_aceflag4(xdrs, &objp->flag)) + return (FALSE); + if (!xdr_acemask4(xdrs, &objp->access_mask)) + return (FALSE); + if (xdrs->x_op == XDR_DECODE) { + objp->who.utf8string_val = NULL; + objp->who.utf8string_len = 0; + } + return (xdr_bytes(xdrs, (char **)&objp->who.utf8string_val, + (uint_t *)&objp->who.utf8string_len, + NFS4_MAX_UTF8STRING)); +} + +bool_t +xdr_specdata4(register XDR *xdrs, specdata4 *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->specdata1)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->specdata2)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_supported_attrs(register XDR *xdrs, fattr4_supported_attrs *objp) +{ + + if (!xdr_bitmap4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_type(register XDR *xdrs, fattr4_type *objp) +{ + + if (!xdr_nfs_ftype4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_fh_expire_type(register XDR *xdrs, fattr4_fh_expire_type *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_change(register XDR *xdrs, fattr4_change *objp) +{ + + if (!xdr_changeid4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_size(register XDR *xdrs, fattr4_size *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_link_support(register XDR *xdrs, fattr4_link_support *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_symlink_support(register XDR *xdrs, fattr4_symlink_support *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_named_attr(register XDR *xdrs, fattr4_named_attr *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_fsid(register XDR *xdrs, fattr4_fsid *objp) +{ + + if (!xdr_fsid4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_unique_handles(register XDR *xdrs, fattr4_unique_handles *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_lease_time(register XDR *xdrs, fattr4_lease_time *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_rdattr_error(register XDR *xdrs, fattr4_rdattr_error *objp) +{ + + if (!xdr_nfsstat4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_acl(register XDR *xdrs, fattr4_acl *objp) +{ + + if (!xdr_array(xdrs, (char **)&objp->fattr4_acl_val, + (uint_t *)&objp->fattr4_acl_len, ~0, + sizeof (nfsace4), (xdrproc_t)xdr_nfsace4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_aclsupport(register XDR *xdrs, fattr4_aclsupport *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_archive(register XDR *xdrs, fattr4_archive *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_cansettime(register XDR *xdrs, fattr4_cansettime *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_case_insensitive(register XDR *xdrs, fattr4_case_insensitive *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_case_preserving(register XDR *xdrs, fattr4_case_preserving *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_chown_restricted(register XDR *xdrs, fattr4_chown_restricted *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_fileid(register XDR *xdrs, fattr4_fileid *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_files_avail(register XDR *xdrs, fattr4_files_avail *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_filehandle(register XDR *xdrs, fattr4_filehandle *objp) +{ + + if (!xdr_nfs_fh4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_files_free(register XDR *xdrs, fattr4_files_free *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_files_total(register XDR *xdrs, fattr4_files_total *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_fs_locations(register XDR *xdrs, fattr4_fs_locations *objp) +{ + + if (!xdr_fs_locations4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_hidden(register XDR *xdrs, fattr4_hidden *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_homogeneous(register XDR *xdrs, fattr4_homogeneous *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_maxfilesize(register XDR *xdrs, fattr4_maxfilesize *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_maxlink(register XDR *xdrs, fattr4_maxlink *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_maxname(register XDR *xdrs, fattr4_maxname *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_maxread(register XDR *xdrs, fattr4_maxread *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_maxwrite(register XDR *xdrs, fattr4_maxwrite *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_mimetype(register XDR *xdrs, fattr4_mimetype *objp) +{ + + if (!xdr_utf8string(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_mode(register XDR *xdrs, fattr4_mode *objp) +{ + + if (!xdr_mode4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_mounted_on_fileid(register XDR *xdrs, fattr4_mounted_on_fileid *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_no_trunc(register XDR *xdrs, fattr4_no_trunc *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_numlinks(register XDR *xdrs, fattr4_numlinks *objp) +{ + + if (!xdr_uint32_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_owner(register XDR *xdrs, fattr4_owner *objp) +{ + + if (!xdr_utf8string(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_owner_group(register XDR *xdrs, fattr4_owner_group *objp) +{ + + if (!xdr_utf8string(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_quota_avail_hard(register XDR *xdrs, fattr4_quota_avail_hard *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_quota_avail_soft(register XDR *xdrs, fattr4_quota_avail_soft *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_quota_used(register XDR *xdrs, fattr4_quota_used *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_rawdev(register XDR *xdrs, fattr4_rawdev *objp) +{ + + if (!xdr_specdata4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_space_avail(register XDR *xdrs, fattr4_space_avail *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_space_free(register XDR *xdrs, fattr4_space_free *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_space_total(register XDR *xdrs, fattr4_space_total *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_space_used(register XDR *xdrs, fattr4_space_used *objp) +{ + + if (!xdr_uint64_t(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_system(register XDR *xdrs, fattr4_system *objp) +{ + + if (!xdr_bool(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_access(register XDR *xdrs, fattr4_time_access *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_access_set(register XDR *xdrs, fattr4_time_access_set *objp) +{ + + if (!xdr_settime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_backup(register XDR *xdrs, fattr4_time_backup *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_create(register XDR *xdrs, fattr4_time_create *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_delta(register XDR *xdrs, fattr4_time_delta *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_metadata(register XDR *xdrs, fattr4_time_metadata *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_modify(register XDR *xdrs, fattr4_time_modify *objp) +{ + + if (!xdr_nfstime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4_time_modify_set(register XDR *xdrs, fattr4_time_modify_set *objp) +{ + + if (!xdr_settime4(xdrs, objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_attrlist4(register XDR *xdrs, attrlist4 *objp) +{ + + if (!xdr_bytes(xdrs, (char **)&objp->attrlist4_val, + (uint_t *)&objp->attrlist4_len, ~0)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_fattr4(register XDR *xdrs, fattr4 *objp) +{ + + if (!xdr_bitmap4(xdrs, &objp->attrmask)) + return (FALSE); + if (!xdr_attrlist4(xdrs, &objp->attr_vals)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_change_info4(register XDR *xdrs, change_info4 *objp) +{ + + if (!xdr_bool(xdrs, &objp->atomic)) + return (FALSE); + if (!xdr_changeid4(xdrs, &objp->before)) + return (FALSE); + if (!xdr_changeid4(xdrs, &objp->after)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_clientaddr4(register XDR *xdrs, clientaddr4 *objp) +{ + + if (!xdr_string(xdrs, &objp->r_netid, ~0)) + return (FALSE); + if (!xdr_string(xdrs, &objp->r_addr, ~0)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_cb_client4(register XDR *xdrs, cb_client4 *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->cb_program)) + return (FALSE); + if (!xdr_clientaddr4(xdrs, &objp->cb_location)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_stateid4(register XDR *xdrs, stateid4 *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->seqid)) + return (FALSE); + if (!xdr_opaque(xdrs, objp->other, 12)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_client_id4(register XDR *xdrs, nfs_client_id4 *objp) +{ + + if (!xdr_verifier4(xdrs, objp->verifier)) + return (FALSE); + if (!xdr_bytes(xdrs, (char **)&objp->id.id_val, + (uint_t *)&objp->id.id_len, NFS4_OPAQUE_LIMIT)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_owner4(register XDR *xdrs, open_owner4 *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val, + (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_lock_owner4(register XDR *xdrs, lock_owner4 *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + if (!xdr_bytes(xdrs, (char **)&objp->owner.owner_val, + (uint_t *)&objp->owner.owner_len, NFS4_OPAQUE_LIMIT)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_lock_type4(register XDR *xdrs, nfs_lock_type4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_ACCESS4args(register XDR *xdrs, ACCESS4args *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->access)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_ACCESS4resok(register XDR *xdrs, ACCESS4resok *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->supported)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->access)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_ACCESS4res(register XDR *xdrs, ACCESS4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_ACCESS4resok(xdrs, &objp->ACCESS4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_CLOSE4args(register XDR *xdrs, CLOSE4args *objp) +{ + + if (!xdr_seqid4(xdrs, &objp->seqid)) + return (FALSE); + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CLOSE4res(register XDR *xdrs, CLOSE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_stateid4(xdrs, &objp->CLOSE4res_u.open_stateid)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_COMMIT4args(register XDR *xdrs, COMMIT4args *objp) +{ + + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_count4(xdrs, &objp->count)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_COMMIT4resok(register XDR *xdrs, COMMIT4resok *objp) +{ + + if (!xdr_verifier4(xdrs, objp->writeverf)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_COMMIT4res(register XDR *xdrs, COMMIT4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_COMMIT4resok(xdrs, &objp->COMMIT4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_createtype4(register XDR *xdrs, createtype4 *objp) +{ + + if (!xdr_nfs_ftype4(xdrs, &objp->type)) + return (FALSE); + switch (objp->type) { + case NF4LNK: + if (!xdr_linktext4(xdrs, &objp->createtype4_u.linkdata)) + return (FALSE); + break; + case NF4BLK: + case NF4CHR: + if (!xdr_specdata4(xdrs, &objp->createtype4_u.devdata)) + return (FALSE); + break; + case NF4SOCK: + case NF4FIFO: + case NF4DIR: + break; + } + return (TRUE); +} + +bool_t +xdr_CREATE4args(register XDR *xdrs, CREATE4args *objp) +{ + + if (!xdr_createtype4(xdrs, &objp->objtype)) + return (FALSE); + if (!xdr_component4(xdrs, &objp->objname)) + return (FALSE); + if (!xdr_fattr4(xdrs, &objp->createattrs)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CREATE4resok(register XDR *xdrs, CREATE4resok *objp) +{ + + if (!xdr_change_info4(xdrs, &objp->cinfo)) + return (FALSE); + if (!xdr_bitmap4(xdrs, &objp->attrset)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CREATE4res(register XDR *xdrs, CREATE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_CREATE4resok(xdrs, &objp->CREATE4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_DELEGPURGE4args(register XDR *xdrs, DELEGPURGE4args *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_DELEGPURGE4res(register XDR *xdrs, DELEGPURGE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_DELEGRETURN4args(register XDR *xdrs, DELEGRETURN4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->deleg_stateid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_DELEGRETURN4res(register XDR *xdrs, DELEGRETURN4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_GETATTR4args(register XDR *xdrs, GETATTR4args *objp) +{ + + if (!xdr_bitmap4(xdrs, &objp->attr_request)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_GETATTR4resok(register XDR *xdrs, GETATTR4resok *objp) +{ + + if (!xdr_fattr4(xdrs, &objp->obj_attributes)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_GETATTR4res(register XDR *xdrs, GETATTR4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_GETATTR4resok(xdrs, &objp->GETATTR4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_GETFH4resok(register XDR *xdrs, GETFH4resok *objp) +{ + + if (!xdr_nfs_fh4(xdrs, &objp->object)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_GETFH4res(register XDR *xdrs, GETFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_GETFH4resok(xdrs, &objp->GETFH4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_LINK4args(register XDR *xdrs, LINK4args *objp) +{ + + if (!xdr_component4(xdrs, &objp->newname)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LINK4resok(register XDR *xdrs, LINK4resok *objp) +{ + + if (!xdr_change_info4(xdrs, &objp->cinfo)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LINK4res(register XDR *xdrs, LINK4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_LINK4resok(xdrs, &objp->LINK4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_open_to_lock_owner4(register XDR *xdrs, open_to_lock_owner4 *objp) +{ + + if (!xdr_seqid4(xdrs, &objp->open_seqid)) + return (FALSE); + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + if (!xdr_seqid4(xdrs, &objp->lock_seqid)) + return (FALSE); + if (!xdr_lock_owner4(xdrs, &objp->lock_owner)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_exist_lock_owner4(register XDR *xdrs, exist_lock_owner4 *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->lock_stateid)) + return (FALSE); + if (!xdr_seqid4(xdrs, &objp->lock_seqid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_locker4(register XDR *xdrs, locker4 *objp) +{ + + if (!xdr_bool(xdrs, &objp->new_lock_owner)) + return (FALSE); + switch (objp->new_lock_owner) { + case TRUE: + if (!xdr_open_to_lock_owner4(xdrs, &objp->locker4_u.open_owner)) + return (FALSE); + break; + case FALSE: + if (!xdr_exist_lock_owner4(xdrs, &objp->locker4_u.lock_owner)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_LOCK4args(register XDR *xdrs, LOCK4args *objp) +{ + + if (!xdr_nfs_lock_type4(xdrs, &objp->locktype)) + return (FALSE); + if (!xdr_bool(xdrs, &objp->reclaim)) + return (FALSE); + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_length4(xdrs, &objp->length)) + return (FALSE); + if (!xdr_locker4(xdrs, &objp->locker)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOCK4denied(register XDR *xdrs, LOCK4denied *objp) +{ + + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_length4(xdrs, &objp->length)) + return (FALSE); + if (!xdr_nfs_lock_type4(xdrs, &objp->locktype)) + return (FALSE); + if (!xdr_lock_owner4(xdrs, &objp->owner)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOCK4resok(register XDR *xdrs, LOCK4resok *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->lock_stateid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOCK4res(register XDR *xdrs, LOCK4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_LOCK4resok(xdrs, &objp->LOCK4res_u.resok4)) + return (FALSE); + break; + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied(xdrs, &objp->LOCK4res_u.denied)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_LOCKT4args(register XDR *xdrs, LOCKT4args *objp) +{ + + if (!xdr_nfs_lock_type4(xdrs, &objp->locktype)) + return (FALSE); + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_length4(xdrs, &objp->length)) + return (FALSE); + if (!xdr_lock_owner4(xdrs, &objp->owner)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOCKT4res(register XDR *xdrs, LOCKT4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4ERR_DENIED: + if (!xdr_LOCK4denied(xdrs, &objp->LOCKT4res_u.denied)) + return (FALSE); + break; + case NFS4_OK: + break; + } + return (TRUE); +} + +bool_t +xdr_LOCKU4args(register XDR *xdrs, LOCKU4args *objp) +{ + + if (!xdr_nfs_lock_type4(xdrs, &objp->locktype)) + return (FALSE); + if (!xdr_seqid4(xdrs, &objp->seqid)) + return (FALSE); + if (!xdr_stateid4(xdrs, &objp->lock_stateid)) + return (FALSE); + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_length4(xdrs, &objp->length)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOCKU4res(register XDR *xdrs, LOCKU4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_stateid4(xdrs, &objp->LOCKU4res_u.lock_stateid)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_LOOKUP4args(register XDR *xdrs, LOOKUP4args *objp) +{ + + if (!xdr_component4(xdrs, &objp->objname)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOOKUP4res(register XDR *xdrs, LOOKUP4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_LOOKUPP4res(register XDR *xdrs, LOOKUPP4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_NVERIFY4args(register XDR *xdrs, NVERIFY4args *objp) +{ + + if (!xdr_fattr4(xdrs, &objp->obj_attributes)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_NVERIFY4res(register XDR *xdrs, NVERIFY4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_createmode4(register XDR *xdrs, createmode4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_createhow4(register XDR *xdrs, createhow4 *objp) +{ + + if (!xdr_createmode4(xdrs, &objp->mode)) + return (FALSE); + switch (objp->mode) { + case UNCHECKED4: + case GUARDED4: + if (!xdr_fattr4(xdrs, &objp->createhow4_u.createattrs)) + return (FALSE); + break; + case EXCLUSIVE4: + if (!xdr_verifier4(xdrs, objp->createhow4_u.createverf)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_opentype4(register XDR *xdrs, opentype4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_openflag4(register XDR *xdrs, openflag4 *objp) +{ + + if (!xdr_opentype4(xdrs, &objp->opentype)) + return (FALSE); + switch (objp->opentype) { + case OPEN4_CREATE: + if (!xdr_createhow4(xdrs, &objp->openflag4_u.how)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_limit_by4(register XDR *xdrs, limit_by4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_modified_limit4(register XDR *xdrs, nfs_modified_limit4 *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->num_blocks)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->bytes_per_block)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_space_limit4(register XDR *xdrs, nfs_space_limit4 *objp) +{ + + if (!xdr_limit_by4(xdrs, &objp->limitby)) + return (FALSE); + switch (objp->limitby) { + case NFS_LIMIT_SIZE: + if (!xdr_uint64_t(xdrs, &objp->nfs_space_limit4_u.filesize)) + return (FALSE); + break; + case NFS_LIMIT_BLOCKS: + if (!xdr_nfs_modified_limit4(xdrs, &objp->nfs_space_limit4_u. + mod_blocks)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_open_delegation_type4(register XDR *xdrs, open_delegation_type4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_claim_type4(register XDR *xdrs, open_claim_type4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_claim_delegate_cur4(register XDR *xdrs, open_claim_delegate_cur4 *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->delegate_stateid)) + return (FALSE); + if (!xdr_component4(xdrs, &objp->file)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_claim4(register XDR *xdrs, open_claim4 *objp) +{ + + if (!xdr_open_claim_type4(xdrs, &objp->claim)) + return (FALSE); + switch (objp->claim) { + case CLAIM_NULL: + if (!xdr_component4(xdrs, &objp->open_claim4_u.file)) + return (FALSE); + break; + case CLAIM_PREVIOUS: + if (!xdr_open_delegation_type4(xdrs, &objp->open_claim4_u. + delegate_type)) + return (FALSE); + break; + case CLAIM_DELEGATE_CUR: + if (!xdr_open_claim_delegate_cur4(xdrs, &objp->open_claim4_u. + delegate_cur_info)) + return (FALSE); + break; + case CLAIM_DELEGATE_PREV: + if (!xdr_component4(xdrs, &objp->open_claim4_u. + file_delegate_prev)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_OPEN4args(register XDR *xdrs, OPEN4args *objp) +{ + + if (!xdr_seqid4(xdrs, &objp->seqid)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->share_access)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->share_deny)) + return (FALSE); + if (!xdr_open_owner4(xdrs, &objp->owner)) + return (FALSE); + if (!xdr_openflag4(xdrs, &objp->openhow)) + return (FALSE); + if (!xdr_open_claim4(xdrs, &objp->claim)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_read_delegation4(register XDR *xdrs, open_read_delegation4 *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_bool(xdrs, &objp->recall)) + return (FALSE); + if (!xdr_nfsace4(xdrs, &objp->permissions)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_write_delegation4(register XDR *xdrs, open_write_delegation4 *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_bool(xdrs, &objp->recall)) + return (FALSE); + if (!xdr_nfs_space_limit4(xdrs, &objp->space_limit)) + return (FALSE); + if (!xdr_nfsace4(xdrs, &objp->permissions)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_open_delegation4(register XDR *xdrs, open_delegation4 *objp) +{ + + if (!xdr_open_delegation_type4(xdrs, &objp->delegation_type)) + return (FALSE); + switch (objp->delegation_type) { + case OPEN_DELEGATE_NONE: + break; + case OPEN_DELEGATE_READ: + if (!xdr_open_read_delegation4(xdrs, &objp->open_delegation4_u. + read)) + return (FALSE); + break; + case OPEN_DELEGATE_WRITE: + if (!xdr_open_write_delegation4(xdrs, &objp->open_delegation4_u. + write)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_OPEN4resok(register XDR *xdrs, OPEN4resok *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_change_info4(xdrs, &objp->cinfo)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->rflags)) + return (FALSE); + if (!xdr_bitmap4(xdrs, &objp->attrset)) + return (FALSE); + if (!xdr_open_delegation4(xdrs, &objp->delegation)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN4res(register XDR *xdrs, OPEN4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_OPEN4resok(xdrs, &objp->OPEN4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_OPENATTR4args(register XDR *xdrs, OPENATTR4args *objp) +{ + + if (!xdr_bool(xdrs, &objp->createdir)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPENATTR4res(register XDR *xdrs, OPENATTR4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN_CONFIRM4args(register XDR *xdrs, OPEN_CONFIRM4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + if (!xdr_seqid4(xdrs, &objp->seqid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN_CONFIRM4resok(register XDR *xdrs, OPEN_CONFIRM4resok *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN_CONFIRM4res(register XDR *xdrs, OPEN_CONFIRM4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_OPEN_CONFIRM4resok(xdrs, &objp->OPEN_CONFIRM4res_u. + resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_OPEN_DOWNGRADE4args(register XDR *xdrs, OPEN_DOWNGRADE4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + if (!xdr_seqid4(xdrs, &objp->seqid)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->share_access)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->share_deny)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN_DOWNGRADE4resok(register XDR *xdrs, OPEN_DOWNGRADE4resok *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->open_stateid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_OPEN_DOWNGRADE4res(register XDR *xdrs, OPEN_DOWNGRADE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_OPEN_DOWNGRADE4resok(xdrs, &objp->OPEN_DOWNGRADE4res_u. + resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_PUTFH4args(register XDR *xdrs, PUTFH4args *objp) +{ + + if (!xdr_nfs_fh4(xdrs, &objp->object)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_PUTFH4res(register XDR *xdrs, PUTFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_PUTPUBFH4res(register XDR *xdrs, PUTPUBFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_PUTROOTFH4res(register XDR *xdrs, PUTROOTFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_READ4args(register XDR *xdrs, READ4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_count4(xdrs, &objp->count)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_READ4resok(register XDR *xdrs, READ4resok *objp) +{ + + if (!xdr_bool(xdrs, &objp->eof)) + return (FALSE); + +#ifdef IGNORE_RDWR_DATA + /* + * Try to get length of read, and if that + * fails, default to 0. Don't return FALSE + * because the other read info will not be + * displayed. + */ + objp->data.data_val = NULL; + if (!xdr_u_int(xdrs, &objp->data.data_len)) + objp->data.data_len = 0; + nfs4_skip_bytes = objp->data.data_len; +#else + if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, + (uint_t *)&objp->data.data_len, ~0)) + return (FALSE); +#endif + return (TRUE); +} + +bool_t +xdr_READ4res(register XDR *xdrs, READ4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_READ4resok(xdrs, &objp->READ4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_READDIR4args(register XDR *xdrs, READDIR4args *objp) +{ + + if (!xdr_nfs_cookie4(xdrs, &objp->cookie)) + return (FALSE); + if (!xdr_verifier4(xdrs, objp->cookieverf)) + return (FALSE); + if (!xdr_count4(xdrs, &objp->dircount)) + return (FALSE); + if (!xdr_count4(xdrs, &objp->maxcount)) + return (FALSE); + if (!xdr_bitmap4(xdrs, &objp->attr_request)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_entry4(register XDR *xdrs, entry4 *objp) +{ + + entry4 *tmp_entry4; + bool_t more_data = TRUE; + bool_t first_objp = TRUE; + + while (more_data) { + + if (!xdr_nfs_cookie4(xdrs, &objp->cookie)) + return (FALSE); + if (!xdr_component4(xdrs, &objp->name)) + return (FALSE); + if (!xdr_fattr4(xdrs, &objp->attrs)) + return (FALSE); + + if (xdrs->x_op == XDR_DECODE) { + + void bzero(); + + if (!xdr_bool(xdrs, &more_data)) + return (FALSE); + + if (!more_data) { + objp->nextentry = NULL; + break; + } + + objp->nextentry = (entry4 *) + mem_alloc(sizeof (entry4)); + if (objp->nextentry == NULL) + return (NULL); + bzero(objp->nextentry, sizeof (entry4)); + objp = objp->nextentry; + + } else if (xdrs->x_op == XDR_ENCODE) { + objp = objp->nextentry; + if (!objp) + more_data = FALSE; + + if (!xdr_bool(xdrs, &more_data)) + return (FALSE); + } else { + tmp_entry4 = objp; + objp = objp->nextentry; + if (!objp) + more_data = FALSE; + if (!xdr_bool(xdrs, &more_data)) + return (FALSE); + if (!first_objp) + mem_free(tmp_entry4, sizeof (entry4)); + else + first_objp = FALSE; + } + } + return (TRUE); +} + +bool_t +xdr_dirlist4(register XDR *xdrs, dirlist4 *objp) +{ + + if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof (entry4), + (xdrproc_t)xdr_entry4)) + return (FALSE); + if (!xdr_bool(xdrs, &objp->eof)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_READDIR4resok(register XDR *xdrs, READDIR4resok *objp) +{ + + if (!xdr_verifier4(xdrs, objp->cookieverf)) + return (FALSE); + if (!xdr_dirlist4(xdrs, &objp->reply)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_READDIR4res(register XDR *xdrs, READDIR4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_READDIR4resok(xdrs, &objp->READDIR4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_READLINK4resok(register XDR *xdrs, READLINK4resok *objp) +{ + + if (!xdr_linktext4(xdrs, &objp->link)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_READLINK4res(register XDR *xdrs, READLINK4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_READLINK4resok(xdrs, &objp->READLINK4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_REMOVE4args(register XDR *xdrs, REMOVE4args *objp) +{ + + if (!xdr_component4(xdrs, &objp->target)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_REMOVE4resok(register XDR *xdrs, REMOVE4resok *objp) +{ + + if (!xdr_change_info4(xdrs, &objp->cinfo)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_REMOVE4res(register XDR *xdrs, REMOVE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_REMOVE4resok(xdrs, &objp->REMOVE4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_RENAME4args(register XDR *xdrs, RENAME4args *objp) +{ + + if (!xdr_component4(xdrs, &objp->oldname)) + return (FALSE); + if (!xdr_component4(xdrs, &objp->newname)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_RENAME4resok(register XDR *xdrs, RENAME4resok *objp) +{ + + if (!xdr_change_info4(xdrs, &objp->source_cinfo)) + return (FALSE); + if (!xdr_change_info4(xdrs, &objp->target_cinfo)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_RENAME4res(register XDR *xdrs, RENAME4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_RENAME4resok(xdrs, &objp->RENAME4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_RENEW4args(register XDR *xdrs, RENEW4args *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_RENEW4res(register XDR *xdrs, RENEW4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_RESTOREFH4res(register XDR *xdrs, RESTOREFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SAVEFH4res(register XDR *xdrs, SAVEFH4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SECINFO4args(register XDR *xdrs, SECINFO4args *objp) +{ + + if (!xdr_component4(xdrs, &objp->name)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_rpc_gss_svc_t(register XDR *xdrs, rpc_gss_svc_t *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_rpcsec_gss_info(register XDR *xdrs, rpcsec_gss_info *objp) +{ + + if (!xdr_sec_oid4(xdrs, &objp->oid)) + return (FALSE); + if (!xdr_qop4(xdrs, &objp->qop)) + return (FALSE); + if (!xdr_rpc_gss_svc_t(xdrs, &objp->service)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_secinfo4(register XDR *xdrs, secinfo4 *objp) +{ + + if (!xdr_uint32_t(xdrs, &objp->flavor)) + return (FALSE); + switch (objp->flavor) { + case RPCSEC_GSS: + if (!xdr_rpcsec_gss_info(xdrs, &objp->secinfo4_u.flavor_info)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_SECINFO4resok(register XDR *xdrs, SECINFO4resok *objp) +{ + + if (!xdr_array(xdrs, (char **)&objp->SECINFO4resok_val, + (uint_t *)&objp->SECINFO4resok_len, ~0, + sizeof (secinfo4), (xdrproc_t)xdr_secinfo4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SECINFO4res(register XDR *xdrs, SECINFO4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_SECINFO4resok(xdrs, &objp->SECINFO4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_SETATTR4args(register XDR *xdrs, SETATTR4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_fattr4(xdrs, &objp->obj_attributes)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SETATTR4res(register XDR *xdrs, SETATTR4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + if (!xdr_bitmap4(xdrs, &objp->attrsset)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SETCLIENTID4args(register XDR *xdrs, SETCLIENTID4args *objp) +{ + + if (!xdr_nfs_client_id4(xdrs, &objp->client)) + return (FALSE); + if (!xdr_cb_client4(xdrs, &objp->callback)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->callback_ident)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SETCLIENTID4resok(register XDR *xdrs, SETCLIENTID4resok *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + if (!xdr_verifier4(xdrs, objp->setclientid_confirm)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SETCLIENTID4res(register XDR *xdrs, SETCLIENTID4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_SETCLIENTID4resok(xdrs, &objp->SETCLIENTID4res_u. + resok4)) + return (FALSE); + break; + case NFS4ERR_CLID_INUSE: + if (!xdr_clientaddr4(xdrs, &objp->SETCLIENTID4res_u. + client_using)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_SETCLIENTID_CONFIRM4args(register XDR *xdrs, SETCLIENTID_CONFIRM4args *objp) +{ + + if (!xdr_clientid4(xdrs, &objp->clientid)) + return (FALSE); + if (!xdr_verifier4(xdrs, objp->setclientid_confirm)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_SETCLIENTID_CONFIRM4res(register XDR *xdrs, SETCLIENTID_CONFIRM4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_VERIFY4args(register XDR *xdrs, VERIFY4args *objp) +{ + + if (!xdr_fattr4(xdrs, &objp->obj_attributes)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_VERIFY4res(register XDR *xdrs, VERIFY4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_stable_how4(register XDR *xdrs, stable_how4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_WRITE4args(register XDR *xdrs, WRITE4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_offset4(xdrs, &objp->offset)) + return (FALSE); + if (!xdr_stable_how4(xdrs, &objp->stable)) + return (FALSE); + +#ifdef IGNORE_RDWR_DATA + /* + * try to get length of write, and if that + * fails, default to 0. Don't return FALSE + * because the other write info will not be + * displayed (write stateid). + */ + objp->data.data_val = NULL; + if (!xdr_u_int(xdrs, &objp->data.data_len)) + objp->data.data_len = 0; + nfs4_skip_bytes = objp->data.data_len; +#else + if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, + (uint_t *)&objp->data.data_len, ~0)) + return (FALSE); +#endif + return (TRUE); +} + +bool_t +xdr_WRITE4resok(register XDR *xdrs, WRITE4resok *objp) +{ + + if (!xdr_count4(xdrs, &objp->count)) + return (FALSE); + if (!xdr_stable_how4(xdrs, &objp->committed)) + return (FALSE); + if (!xdr_verifier4(xdrs, objp->writeverf)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_WRITE4res(register XDR *xdrs, WRITE4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_WRITE4resok(xdrs, &objp->WRITE4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_RELEASE_LOCKOWNER4args(register XDR *xdrs, RELEASE_LOCKOWNER4args *objp) +{ + + if (!xdr_lock_owner4(xdrs, &objp->lock_owner)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_RELEASE_LOCKOWNER4res(register XDR *xdrs, RELEASE_LOCKOWNER4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_ILLEGAL4res(register XDR *xdrs, ILLEGAL4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_opnum4(register XDR *xdrs, nfs_opnum4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_argop4(register XDR *xdrs, nfs_argop4 *objp) +{ + nfs4_skip_bytes = 0; + if (!xdr_nfs_opnum4(xdrs, &objp->argop)) + return (FALSE); + switch (objp->argop) { + case OP_ACCESS: + if (!xdr_ACCESS4args(xdrs, &objp->nfs_argop4_u.opaccess)) + return (FALSE); + break; + case OP_CLOSE: + if (!xdr_CLOSE4args(xdrs, &objp->nfs_argop4_u.opclose)) + return (FALSE); + break; + case OP_COMMIT: + if (!xdr_COMMIT4args(xdrs, &objp->nfs_argop4_u.opcommit)) + return (FALSE); + break; + case OP_CREATE: + if (!xdr_CREATE4args(xdrs, &objp->nfs_argop4_u.opcreate)) + return (FALSE); + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4args(xdrs, &objp->nfs_argop4_u. + opdelegpurge)) + return (FALSE); + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4args(xdrs, &objp->nfs_argop4_u. + opdelegreturn)) + return (FALSE); + break; + case OP_GETATTR: + if (!xdr_GETATTR4args(xdrs, &objp->nfs_argop4_u. + opgetattr)) + return (FALSE); + break; + case OP_GETFH: + break; + case OP_LINK: + if (!xdr_LINK4args(xdrs, &objp->nfs_argop4_u.oplink)) + return (FALSE); + break; + case OP_LOCK: + if (!xdr_LOCK4args(xdrs, &objp->nfs_argop4_u.oplock)) + return (FALSE); + break; + case OP_LOCKT: + if (!xdr_LOCKT4args(xdrs, &objp->nfs_argop4_u.oplockt)) + return (FALSE); + break; + case OP_LOCKU: + if (!xdr_LOCKU4args(xdrs, &objp->nfs_argop4_u.oplocku)) + return (FALSE); + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4args(xdrs, &objp->nfs_argop4_u.oplookup)) + return (FALSE); + break; + case OP_LOOKUPP: + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4args(xdrs, &objp->nfs_argop4_u.opnverify)) + return (FALSE); + break; + case OP_OPEN: + if (!xdr_OPEN4args(xdrs, &objp->nfs_argop4_u.opopen)) + return (FALSE); + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4args(xdrs, &objp->nfs_argop4_u.opopenattr)) + return (FALSE); + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4args(xdrs, &objp->nfs_argop4_u. + opopen_confirm)) + return (FALSE); + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4args(xdrs, &objp->nfs_argop4_u. + opopen_downgrade)) + return (FALSE); + break; + case OP_PUTFH: + if (!xdr_PUTFH4args(xdrs, &objp->nfs_argop4_u.opputfh)) + return (FALSE); + break; + case OP_PUTPUBFH: + break; + case OP_PUTROOTFH: + break; + case OP_READ: + if (!xdr_READ4args(xdrs, &objp->nfs_argop4_u.opread)) + return (FALSE); + break; + case OP_READDIR: + if (!xdr_READDIR4args(xdrs, &objp->nfs_argop4_u.opreaddir)) + return (FALSE); + break; + case OP_READLINK: + break; + case OP_REMOVE: + if (!xdr_REMOVE4args(xdrs, &objp->nfs_argop4_u.opremove)) + return (FALSE); + break; + case OP_RENAME: + if (!xdr_RENAME4args(xdrs, &objp->nfs_argop4_u.oprename)) + return (FALSE); + break; + case OP_RENEW: + if (!xdr_RENEW4args(xdrs, &objp->nfs_argop4_u.oprenew)) + return (FALSE); + break; + case OP_RESTOREFH: + break; + case OP_SAVEFH: + break; + case OP_SECINFO: + if (!xdr_SECINFO4args(xdrs, &objp->nfs_argop4_u.opsecinfo)) + return (FALSE); + break; + case OP_SETATTR: + if (!xdr_SETATTR4args(xdrs, &objp->nfs_argop4_u.opsetattr)) + return (FALSE); + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4args(xdrs, &objp->nfs_argop4_u. + opsetclientid)) + return (FALSE); + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4args(xdrs, &objp->nfs_argop4_u. + opsetclientid_confirm)) + return (FALSE); + break; + case OP_VERIFY: + if (!xdr_VERIFY4args(xdrs, &objp->nfs_argop4_u.opverify)) + return (FALSE); + break; + case OP_WRITE: + if (!xdr_WRITE4args(xdrs, &objp->nfs_argop4_u.opwrite)) + return (FALSE); + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4args(xdrs, + &objp->nfs_argop4_u.oprelease_lockowner)) + return (FALSE); + break; + case OP_ILLEGAL: + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_nfs_resop4(register XDR *xdrs, nfs_resop4 *objp) +{ + nfs4_skip_bytes = 0; + if (!xdr_nfs_opnum4(xdrs, &objp->resop)) + return (FALSE); + switch (objp->resop) { + case OP_ACCESS: + if (!xdr_ACCESS4res(xdrs, &objp->nfs_resop4_u.opaccess)) + return (FALSE); + break; + case OP_CLOSE: + if (!xdr_CLOSE4res(xdrs, &objp->nfs_resop4_u.opclose)) + return (FALSE); + break; + case OP_COMMIT: + if (!xdr_COMMIT4res(xdrs, &objp->nfs_resop4_u.opcommit)) + return (FALSE); + break; + case OP_CREATE: + if (!xdr_CREATE4res(xdrs, &objp->nfs_resop4_u.opcreate)) + return (FALSE); + break; + case OP_DELEGPURGE: + if (!xdr_DELEGPURGE4res(xdrs, &objp->nfs_resop4_u.opdelegpurge)) + return (FALSE); + break; + case OP_DELEGRETURN: + if (!xdr_DELEGRETURN4res(xdrs, &objp->nfs_resop4_u. + opdelegreturn)) + return (FALSE); + break; + case OP_GETATTR: + if (!xdr_GETATTR4res(xdrs, &objp->nfs_resop4_u.opgetattr)) + return (FALSE); + break; + case OP_GETFH: + if (!xdr_GETFH4res(xdrs, &objp->nfs_resop4_u.opgetfh)) + return (FALSE); + break; + case OP_LINK: + if (!xdr_LINK4res(xdrs, &objp->nfs_resop4_u.oplink)) + return (FALSE); + break; + case OP_LOCK: + if (!xdr_LOCK4res(xdrs, &objp->nfs_resop4_u.oplock)) + return (FALSE); + break; + case OP_LOCKT: + if (!xdr_LOCKT4res(xdrs, &objp->nfs_resop4_u.oplockt)) + return (FALSE); + break; + case OP_LOCKU: + if (!xdr_LOCKU4res(xdrs, &objp->nfs_resop4_u.oplocku)) + return (FALSE); + break; + case OP_LOOKUP: + if (!xdr_LOOKUP4res(xdrs, &objp->nfs_resop4_u.oplookup)) + return (FALSE); + break; + case OP_LOOKUPP: + if (!xdr_LOOKUPP4res(xdrs, &objp->nfs_resop4_u.oplookupp)) + return (FALSE); + break; + case OP_NVERIFY: + if (!xdr_NVERIFY4res(xdrs, &objp->nfs_resop4_u.opnverify)) + return (FALSE); + break; + case OP_OPEN: + if (!xdr_OPEN4res(xdrs, &objp->nfs_resop4_u.opopen)) + return (FALSE); + break; + case OP_OPENATTR: + if (!xdr_OPENATTR4res(xdrs, &objp->nfs_resop4_u.opopenattr)) + return (FALSE); + break; + case OP_OPEN_CONFIRM: + if (!xdr_OPEN_CONFIRM4res(xdrs, &objp->nfs_resop4_u. + opopen_confirm)) + return (FALSE); + break; + case OP_OPEN_DOWNGRADE: + if (!xdr_OPEN_DOWNGRADE4res(xdrs, &objp->nfs_resop4_u. + opopen_downgrade)) + return (FALSE); + break; + case OP_PUTFH: + if (!xdr_PUTFH4res(xdrs, &objp->nfs_resop4_u.opputfh)) + return (FALSE); + break; + case OP_PUTPUBFH: + if (!xdr_PUTPUBFH4res(xdrs, &objp->nfs_resop4_u.opputpubfh)) + return (FALSE); + break; + case OP_PUTROOTFH: + if (!xdr_PUTROOTFH4res(xdrs, &objp->nfs_resop4_u.opputrootfh)) + return (FALSE); + break; + case OP_READ: + if (!xdr_READ4res(xdrs, &objp->nfs_resop4_u.opread)) + return (FALSE); + break; + case OP_READDIR: + if (!xdr_READDIR4res(xdrs, &objp->nfs_resop4_u.opreaddir)) + return (FALSE); + break; + case OP_READLINK: + if (!xdr_READLINK4res(xdrs, &objp->nfs_resop4_u.opreadlink)) + return (FALSE); + break; + case OP_REMOVE: + if (!xdr_REMOVE4res(xdrs, &objp->nfs_resop4_u.opremove)) + return (FALSE); + break; + case OP_RENAME: + if (!xdr_RENAME4res(xdrs, &objp->nfs_resop4_u.oprename)) + return (FALSE); + break; + case OP_RENEW: + if (!xdr_RENEW4res(xdrs, &objp->nfs_resop4_u.oprenew)) + return (FALSE); + break; + case OP_RESTOREFH: + if (!xdr_RESTOREFH4res(xdrs, &objp->nfs_resop4_u.oprestorefh)) + return (FALSE); + break; + case OP_SAVEFH: + if (!xdr_SAVEFH4res(xdrs, &objp->nfs_resop4_u.opsavefh)) + return (FALSE); + break; + case OP_SECINFO: + if (!xdr_SECINFO4res(xdrs, &objp->nfs_resop4_u.opsecinfo)) + return (FALSE); + break; + case OP_SETATTR: + if (!xdr_SETATTR4res(xdrs, &objp->nfs_resop4_u.opsetattr)) + return (FALSE); + break; + case OP_SETCLIENTID: + if (!xdr_SETCLIENTID4res(xdrs, &objp->nfs_resop4_u. + opsetclientid)) + return (FALSE); + break; + case OP_SETCLIENTID_CONFIRM: + if (!xdr_SETCLIENTID_CONFIRM4res(xdrs, &objp->nfs_resop4_u. + opsetclientid_confirm)) + return (FALSE); + break; + case OP_VERIFY: + if (!xdr_VERIFY4res(xdrs, &objp->nfs_resop4_u.opverify)) + return (FALSE); + break; + case OP_WRITE: + if (!xdr_WRITE4res(xdrs, &objp->nfs_resop4_u.opwrite)) + return (FALSE); + break; + case OP_RELEASE_LOCKOWNER: + if (!xdr_RELEASE_LOCKOWNER4res(xdrs, + &objp->nfs_resop4_u.oprelease_lockowner)) + return (FALSE); + break; + case OP_ILLEGAL: + if (!xdr_ILLEGAL4res(xdrs, &objp->nfs_resop4_u.opillegal)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_COMPOUND4args(register XDR *xdrs, COMPOUND4args *objp) +{ + + if (!xdr_utf8string(xdrs, &objp->tag)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->minorversion)) + return (FALSE); + if (!xdr_array(xdrs, (char **)&objp->argarray.argarray_val, + (uint_t *)&objp->argarray.argarray_len, ~0, + sizeof (nfs_argop4), (xdrproc_t)xdr_nfs_argop4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_COMPOUND4res(register XDR *xdrs, COMPOUND4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + if (!xdr_utf8string(xdrs, &objp->tag)) + return (FALSE); + if (!xdr_array(xdrs, (char **)&objp->resarray.resarray_val, + (uint_t *)&objp->resarray.resarray_len, ~0, + sizeof (nfs_resop4), (xdrproc_t)xdr_nfs_resop4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_GETATTR4args(register XDR *xdrs, CB_GETATTR4args *objp) +{ + + if (!xdr_nfs_fh4(xdrs, &objp->fh)) + return (FALSE); + if (!xdr_bitmap4(xdrs, &objp->attr_request)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_GETATTR4resok(register XDR *xdrs, CB_GETATTR4resok *objp) +{ + + if (!xdr_fattr4(xdrs, &objp->obj_attributes)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_GETATTR4res(register XDR *xdrs, CB_GETATTR4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + switch (objp->status) { + case NFS4_OK: + if (!xdr_CB_GETATTR4resok(xdrs, &objp->CB_GETATTR4res_u.resok4)) + return (FALSE); + break; + } + return (TRUE); +} + +bool_t +xdr_CB_RECALL4args(register XDR *xdrs, CB_RECALL4args *objp) +{ + + if (!xdr_stateid4(xdrs, &objp->stateid)) + return (FALSE); + if (!xdr_bool(xdrs, &objp->truncate)) + return (FALSE); + if (!xdr_nfs_fh4(xdrs, &objp->fh)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_RECALL4res(register XDR *xdrs, CB_RECALL4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_ILLEGAL4res(register XDR *xdrs, CB_ILLEGAL4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_cb_opnum4(register XDR *xdrs, nfs_cb_opnum4 *objp) +{ + + if (!xdr_enum(xdrs, (enum_t *)objp)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_nfs_cb_argop4(register XDR *xdrs, nfs_cb_argop4 *objp) +{ + + if (!xdr_u_int(xdrs, &objp->argop)) + return (FALSE); + switch (objp->argop) { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4args(xdrs, &objp->nfs_cb_argop4_u. + opcbgetattr)) + return (FALSE); + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4args(xdrs, &objp->nfs_cb_argop4_u. + opcbrecall)) + return (FALSE); + break; + case OP_CB_ILLEGAL: + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_nfs_cb_resop4(register XDR *xdrs, nfs_cb_resop4 *objp) +{ + + if (!xdr_u_int(xdrs, &objp->resop)) + return (FALSE); + switch (objp->resop) { + case OP_CB_GETATTR: + if (!xdr_CB_GETATTR4res(xdrs, &objp->nfs_cb_resop4_u. + opcbgetattr)) + return (FALSE); + break; + case OP_CB_RECALL: + if (!xdr_CB_RECALL4res(xdrs, &objp->nfs_cb_resop4_u.opcbrecall)) + return (FALSE); + break; + case OP_CB_ILLEGAL: + if (!xdr_CB_ILLEGAL4res(xdrs, + &objp->nfs_cb_resop4_u.opcbillegal)) + return (FALSE); + break; + default: + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_CB_COMPOUND4args(register XDR *xdrs, CB_COMPOUND4args *objp) +{ + + if (!xdr_utf8string(xdrs, &objp->tag)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->minorversion)) + return (FALSE); + if (!xdr_uint32_t(xdrs, &objp->callback_ident)) + return (FALSE); + if (!xdr_array(xdrs, (char **)&objp->argarray.argarray_val, + (uint_t *)&objp->argarray.argarray_len, ~0, + sizeof (nfs_cb_argop4), (xdrproc_t)xdr_nfs_cb_argop4)) + return (FALSE); + return (TRUE); +} + +bool_t +xdr_CB_COMPOUND4res(register XDR *xdrs, CB_COMPOUND4res *objp) +{ + + if (!xdr_nfsstat4(xdrs, &objp->status)) + return (FALSE); + if (!xdr_utf8string(xdrs, &objp->tag)) + return (FALSE); + if (!xdr_array(xdrs, (char **)&objp->resarray.resarray_val, + (uint_t *)&objp->resarray.resarray_len, ~0, + sizeof (nfs_cb_resop4), (xdrproc_t)xdr_nfs_cb_resop4)) + return (FALSE); + return (TRUE); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/ntp.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/ntp.h new file mode 100644 index 0000000..71809d4 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/ntp.h @@ -0,0 +1,533 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +/* + * University Copyright- Copyright (c) 1982, 1986, 1988 + * The Regents of the University of California + * All Rights Reserved + * + * University Acknowledgment- Portions of this document are derived from + * software developed by the University of California, Berkeley, and its + * contributors. + */ + +#ifndef _NTP_H +#define _NTP_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#ifdef __cplusplus +extern "C" { +#endif + +/* $Source: /usr/users/louie/ntp/RCS/ntp.h,v $ */ +/* $Revision: 3.4.1.5 $ $Date: 89/04/10 15:55:42 $ */ + +/* + * $Log: ntp.h,v $ + * Revision 3.4.1.5 89/04/10 15:55:42 louie + * Provide default value for number of bits/byte if not defined. Compute the + * Window shift mask inside of conditional code on XTAL so we get the correct + * value if configured without a crystal controled clock (!!) + * + * Revision 3.4.1.4 89/03/31 16:34:50 louie + * Add bit in flags which allow a peer to be synced to. Changed a char to a bit + * field so that it is always signed. + * + * Revision 3.4.1.3 89/03/29 12:26:18 louie + * Removed some unused #defines. Replaced MAXSTRATUM with NTP_INFIN per new + * spec. The variable 'mode' in the peer structure has been renamed 'hmode' + * per the new spec. + * + * Revision 3.4.1.2 89/03/22 18:28:18 louie + * patch3: Use new RCS headers. + * + * Revision 3.4.1.1 89/03/20 00:02:53 louie + * 1 + * + * Revision 3.4 89/03/17 18:37:00 louie + * Latest test release. + * + * Revision 3.3.1.1 89/03/17 18:23:49 louie + * Change CLOCK_FACTOR to be a power of 2. + * + * Revision 3.3 89/03/15 14:19:36 louie + * New baseline for next release. + * + * Revision 3.2.1.2 89/03/15 13:46:52 louie + * The version number for that particular flavor of ntpd <--> ntpdc interaction + * is now defined by NTPDC_VERSION. The packet format for the ntpdc program + * has changed slightly to improve robustness when dealing with multiple packets + * of status data. + * + * Revision 3.2.1.1 89/03/09 17:11:24 louie + * patch1: Updated constants, which were previously in incorrect units. + * + * Revision 3.2 89/03/07 18:21:45 louie + * New version of UNIX NTP daemon and software based on the 6 March 1989 + * draft of the new NTP protocol specification. This version doesn't + * implement authentication, and accepts and send only NTP Version 1 + * packets. + * + * Revision 3.1.1.1 89/02/15 08:54:42 louie + * *** empty log message *** + * + * + * Revision 3.1 89/01/30 14:43:07 louie + * Second UNIX NTP test release. + * + * Revision 3.0 88/12/12 16:01:07 louie + * Test release of new UNIX NTP software. This version should conform to the + * revised NTP protocol specification. + * + */ + +#ifndef FD_SET +#define NFDBITS 32 +#define FD_SETSIZE 32 +#define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS))) +#define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS))) +#define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS))) +#define FD_ZERO(p) bzero((char *)(p), sizeof (*(p))) +#endif + +#ifndef NBBY +#define NBBY 8 /* number of bits per byte */ +#endif + +#define MAXNETIF 10 + +struct intf { + int fd; + char *name; + struct sockaddr_in sin; + struct sockaddr_in bcast; + struct sockaddr_in mask; + int uses; + int if_flags; +}; +extern struct intf addrs[]; +extern int nintf; + +/* + * Definitions for the masses + */ +#define JAN_1970 2208988800U /* 1970 - 1900 in seconds */ + +/* + * Daemon specific (ntpd.c) + */ +#define SHIFT_MASK 0xff /* number of intervals to wait */ + +#ifndef WAYTOOBIG +#define WAYTOOBIG 1000.0 /* Too many seconds to correct, something is */ + /* really wrong */ +#endif + +#ifndef XTAL +#define XTAL 1 /* crystal controlled clock by default */ +#endif + +#ifndef NTPINITFILE +#define NTPINITFILE "/etc/ntp.conf" +#endif + +struct list { + struct ntp_peer *head; + struct ntp_peer *tail; + int members; +}; + +#define STRMCMP(a, cond, b) \ + (((a) == UNSPECIFIED ? NTP_INFIN+1 : a) cond \ + ((b) == UNSPECIFIED ? NTP_INFIN+1 : (b))) + + +/* + * Definitions outlined in the NTP spec + */ +#define NTP_VERSION 1 +#define NTP_PORT 123 /* for ref only (see /etc/services) */ +#define NTP_INFIN 15 +#define NTP_MAXAGE 86400 +#define NTP_MAXSKW 0.01 /* seconds */ +#define NTP_MINDIST 0.02 /* seconds */ +#define NTP_MINPOLL 6 /* (64) seconds between messages */ +#define NTP_MAXPOLL 10 /* (1024) secs to poll */ +#define NTP_WINDOW 8 /* size of shift register */ +#define NTP_MAXWGT 8 /* maximum allowable dispersion */ +#define NTP_MAXLIST 5 /* max size of selection list */ +#define NTP_MAXSTRA 2 /* max number of strata in selection list */ +#define X_NTP_CANDIDATES 64 /* number of peers to consider when doing */ + /* clock selection */ +#define NTP_SELECT 0.75 /* weight used to compute dispersion */ + +#define PEER_MAXDISP 64.0 /* Maximum dispersion */ +#define PEER_THRESHOLD 0.5 /* dispersion threshold */ +#define PEER_FILTER 0.5 /* filter weight */ + +#if XTAL == 0 +#define PEER_SHIFT 4 +#define NTP_WINDOW_SHIFT_MASK 0x0f +#else +#define PEER_SHIFT 8 +#define NTP_WINDOW_SHIFT_MASK 0xff +#endif + + +/* + * 5.1 Uniform Phase Adjustments + * Clock parameters + */ +#define CLOCK_UPDATE 8 /* update interval (1<<CLOCK_UPDATE secs) */ +#if XTAL +#define CLOCK_ADJ 2 /* adjustment interval (1<<CLOCK_ADJ secs) */ +#define CLOCK_PHASE 8 /* phase shift */ +#define CLOCK_MAX 0.128 /* maximum aperture (milliseconds) */ +#else +#define CLOCK_ADJ 0 +#define CLOCK_PHASE 6 /* phase shift */ +#define CLOCK_MAX 0.512 /* maximum aperture (milliseconds) */ +#endif +#define CLOCK_FREQ 10 /* frequency shift */ +#define CLOCK_TRACK 8 +#define CLOCK_COMP 4 +#define CLOCK_FACTOR 18 + +/* + * Structure definitions for NTP fixed point values + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Integer Part | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Fraction Part | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Integer Part | Fraction Part | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +struct l_fixedpt { + ulong_t int_part; + ulong_t fraction; +}; + +struct s_fixedpt { + ushort_t int_part; + ushort_t fraction; +}; + +/* + * ================= Table 3.3. Packet Variables ================= + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * |LI | VN | Mode| Stratum | Poll | Precision | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Synchronizing Distance | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Synchronizing Dispersion | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Reference Clock Identifier | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * | Reference Timestamp (64 bits) | + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * | Originate Timestamp (64 bits) | + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * | Receive Timestamp (64 bits) | + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * | Transmit Timestamp (64 bits) | + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Encryption Keyid (32 bits, when A bit set) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * | Message Authentication Code/MAC (when A bit set) | + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ + +#define MAC_OCTETS_DES 8 +#define MAC_OCTETS_MD5 16 +#define MAC_OCTETS_MIN MAC_OCTETS_DES +#define MAC_OCTETS_MAX MAC_OCTETS_MD5 +#define AUTH_OCTETS_V3 (MAC_OCTETS_MAX + sizeof (uint32_t)) + +struct ntpdata { + uchar_t li_vn_mode; /* contains leap indicator, version and mode */ + uchar_t stratum; /* Stratum level */ + uchar_t ppoll; /* poll value */ + int precision:8; + struct s_fixedpt distance; + struct s_fixedpt dispersion; + ulong_t refid; + struct l_fixedpt reftime; + struct l_fixedpt org; + struct l_fixedpt rec; + struct l_fixedpt xmt; + uint32_t keyid; + uchar_t mac[MAC_OCTETS_MAX]; +}; + +#define LEN_PKT_NOMAC (sizeof (struct ntpdata) - AUTH_OCTETS_V3) + +/* + * Leap Second Codes (high order two bits) + */ +#define NO_WARNING 0x00 /* no warning */ +#define PLUS_SEC 0x40 /* add a second (61 seconds) */ +#define MINUS_SEC 0x80 /* minus a second (59 seconds) */ +#define ALARM 0xc0 /* alarm condition (clock unsynchronized) */ + +/* + * Clock Status Bits that Encode Version + */ +#define NTPVERSION_1 0x08 +#define VERSIONMASK 0x38 +#define LEAPMASK 0xc0 +#define NTPMODEMASK 0x07 + +/* + * Code values + */ +#define MODE_UNSPEC 0 /* unspecified */ +#define MODE_SYM_ACT 1 /* symmetric active */ +#define MODE_SYM_PAS 2 /* symmetric passive */ +#define MODE_CLIENT 3 /* client */ +#define MODE_SERVER 4 /* server */ +#define MODE_BROADCAST 5 /* broadcast */ +#define MODE_CONTROL 6 /* control */ +#define MODE_PRIVATE 7 /* private */ + +/* + * Stratum Definitions + */ +#define UNSPECIFIED 0 +#define PRIM_REF 1 /* radio clock */ +#define INFO_QUERY 62 /* **** THIS implementation dependent **** */ +#define INFO_REPLY 63 /* **** THIS implementation dependent **** */ + + +/* ================= table 3.2 Peer Variables ================= */ +struct ntp_peer { + struct ntp_peer *next, *prev; + struct sockaddr_in src; /* both peer.srcadr and peer.srcport */ + int flags; /* local flags */ +#define PEER_FL_CONFIG 1 +#define PEER_FL_AUTHENABLE 2 +#define PEER_FL_SYNC 0x1000 /* peer can bet sync'd to */ +#define PEER_FL_BCAST 0x2000 /* broadcast peer */ +#define PEER_FL_SELECTED 0x8000 /* actually used by query routine */ + + int sock; /* index into sockets to derive */ + /* peer.dstadr and peer.dstport */ + uchar_t leap; /* receive */ + uchar_t hmode; /* receive */ + uchar_t stratum; /* receive */ + uchar_t ppoll; /* receive */ + uchar_t hpoll; /* poll update */ + short precision; /* receive */ + struct s_fixedpt distance; /* receive */ + struct s_fixedpt dispersion; /* receive */ + ulong_t refid; /* receive */ + struct l_fixedpt reftime; /* receive */ + struct l_fixedpt org; /* receive, clear */ + struct l_fixedpt rec; /* receive, clear */ + struct l_fixedpt xmt; /* transmit, clear */ + ulong_t reach; /* receive, transmit, clear */ + ulong_t valid; /* packet, transmit, clear */ + ulong_t timer; /* receive, transmit, poll update */ + long stopwatch; /* <<local>> for timing */ + /* + * first order offsets + */ + struct filter { + short samples; /* <<local>> */ + double offset[PEER_SHIFT]; + double delay[PEER_SHIFT]; + } filter; /* filter, clear */ + + double estdelay; /* filter */ + double estoffset; /* filter */ + double estdisp; /* filter */ + + ulong_t pkt_sent; /* <<local>> */ + ulong_t pkt_rcvd; /* <<local>> */ + ulong_t pkt_dropped; /* <<local>> */ +}; + +/* ================= table 3.1: System Variables ================= */ + +struct sysdata { /* procedure */ + uchar_t leap; /* clock update */ + uchar_t stratum; /* clock update */ + short precision; /* system */ + struct s_fixedpt distance; /* clock update */ + struct s_fixedpt dispersion; /* clock update */ + ulong_t refid; /* clock update */ + struct l_fixedpt reftime; /* clock update */ + int hold; /* clock update */ + struct ntp_peer *peer; /* selection */ + int maxpeers; /* <<local>> */ + uchar_t filler; /* put here for %&*%$$ SUNs */ +}; + +#define NTPDC_VERSION 2 + +/* + * These structures are used to pass information to the ntpdc (control) + * program. They are unique to this implementation and not part of the + * NTP specification. + */ +struct clockinfo { + ulong_t net_address; + ulong_t my_address; + ushort_t port; + ushort_t flags; + ulong_t pkt_sent; + ulong_t pkt_rcvd; + ulong_t pkt_dropped; + ulong_t timer; + uchar_t leap; + uchar_t stratum; + uchar_t ppoll; + int precision:8; + + uchar_t hpoll; + uchar_t filler1; + ushort_t reach; + + long estdisp; /* scaled by 1000 */ + long estdelay; /* in milliseconds */ + long estoffset; /* in milliseconds */ + ulong_t refid; + struct l_fixedpt reftime; + struct info_filter { + short index; + short filler; + long offset[PEER_SHIFT]; /* in milliseconds */ + long delay[PEER_SHIFT]; /* in milliseconds */ + } info_filter; +}; + +struct ntpinfo { + uchar_t version; + uchar_t type; /* request type (stratum in ntp packets) */ + uchar_t count; /* number of entries in this packet */ + uchar_t seq; /* sequence number of this packet */ + + uchar_t npkts; /* total number of packets */ + uchar_t peers; + uchar_t fill3; + uchar_t fill4; +}; + +/* + * From usr/src/cmd/xntpd/include/ntp_control.h: + * Definition of a mode 6 packet. + */ +struct ntp_control { + uchar_t li_vn_mode; /* leap, version, mode */ + uchar_t r_m_e_op; /* response, more, error, opcode */ + ushort_t sequence; /* sequence number of request */ + ushort_t status; /* status word for association */ + ushort_t associd; /* association ID */ + ushort_t offset; /* offset of this batch of data */ + ushort_t count; /* count of data in this packet */ + uchar_t data[1]; /* data + auth */ +}; + +#define NTPC_DATA_MAXLEN (480 + AUTH_OCTETS_V3) + +/* + * Decoding for the r_m_e_op field + */ +#define CTL_RESPONSE 0x80 +#define CTL_ERROR 0x40 +#define CTL_MORE 0x20 +#define CTL_OP_MASK 0x1f + +/* + * Opcodes + */ +#define CTL_OP_UNSPEC 0 +#define CTL_OP_READSTAT 1 +#define CTL_OP_READVAR 2 +#define CTL_OP_WRITEVAR 3 +#define CTL_OP_READCLOCK 4 +#define CTL_OP_WRITECLOCK 5 +#define CTL_OP_SETTRAP 6 +#define CTL_OP_ASYNCMSG 7 +#define CTL_OP_UNSETTRAP 31 + +/* + * From usr/src/cmd/xntpd/include/ntp_request.h: + * A mode 7 packet is used exchanging data between an NTP server + * and a client for purposes other than time synchronization, e.g. + * monitoring, statistics gathering and configuration. A mode 7 + * packet has the following format: + */ + +struct ntp_private { + uchar_t rm_vn_mode; /* response, more, version, mode */ + uchar_t auth_seq; /* key, sequence number */ + uchar_t implementation; /* implementation number */ + uchar_t request; /* request number */ + ushort_t err_nitems; /* error code/number of data items */ + ushort_t mbz_itemsize; /* item size */ + char data[1]; /* data area */ +}; + +#define RESP_BIT 0x80 +#define MORE_BIT 0x40 +#define INFO_VERSION(rm_vn_mode) ((uchar_t)(((rm_vn_mode)>>3) & 0x7)) +#define INFO_MODE(rm_vn_mode) ((rm_vn_mode) & 0x7) + +#define AUTH_BIT 0x80 +#define INFO_SEQ(auth_seq) ((auth_seq) & 0x7f) + +#define INFO_ERR(err_nitems) ((ushort_t)((ntohs(err_nitems) >> 12) & 0xf)) +#define INFO_NITEMS(err_nitems) ((ushort_t)(ntohs(err_nitems) & 0xfff)) + +#define INFO_ITEMSIZE(mbz_itemsize) (ntohs(mbz_itemsize) & 0xfff) + +#ifdef __cplusplus +} +#endif + +#endif /* _NTP_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/slp.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/slp.h new file mode 100644 index 0000000..b01c5ea --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/slp.h @@ -0,0 +1,146 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1998 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ifndef _SNOOP_SLP_H +#define _SNOOP_SLP_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Structs and definitions for the snoop SLP interpreter only + * (This code is not used by the SLP library). + */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct slpv1_hdr { + unsigned char vers; + unsigned char function; + unsigned short length; + unsigned char flags; + unsigned char dialect; + unsigned char language[2]; + unsigned short charset; + unsigned short xid; +}; + +struct slpv2_hdr { + unsigned char vers; + unsigned char function; + unsigned char l1, l2, l3; + unsigned char flags; + unsigned char reserved; + unsigned char o1, o2, o3; + unsigned short xid; +}; + +/* + * flags + */ +#define V1_OVERFLOW 0x80 +#define V1_MONOLINGUAL 0x40 +#define V1_URL_AUTH 0x20 +#define V1_ATTR_AUTH 0x10 +#define V1_FRESH_REG 0x08 + +#define V2_OVERFLOW 0x80 +#define V2_FRESH 0x40 +#define V2_MCAST 0x20 + +/* + * packet types + */ + +#define V1_SRVREQ 1 +#define V1_SRVRPLY 2 +#define V1_SRVREG 3 +#define V1_SRVDEREG 4 +#define V1_SRVACK 5 +#define V1_ATTRRQST 6 +#define V1_ATTRRPLY 7 +#define V1_DAADVERT 8 +#define V1_SRVTYPERQST 9 +#define V1_SRVTYPERPLY 10 + +#define V2_SRVRQST 1 +#define V2_SRVRPLY 2 +#define V2_SRVREG 3 +#define V2_SRVDEREG 4 +#define V2_SRVACK 5 +#define V2_ATTRRQST 6 +#define V2_ATTRRPLY 7 +#define V2_DAADVERT 8 +#define V2_SRVTYPERQST 9 +#define V2_SRVTYPERPLY 10 +#define V2_SAADVERT 11 + +/* + * extended packet types + */ +#define SCOPERQST 65 +#define SCOPERPLY 66 +#define DARQST 67 +#define DARPLY 68 +#define DASTRIKE 69 + + +/* + * error codes + */ + +#define OK 0x0000 +#define LANG_NOT_SUPPORTED 0x0001 +#define PROTOCOL_PARSE_ERR 0x0002 +#define INVALID_REGISTRATION 0x0003 +#define SCOPE_NOT_SUPPORTED 0x0004 +#define CHARSET_NOT_UNDERSTOOD 0x0005 +#define AUTHENTICATION_UNKNOWN 0x0005 +#define AUTHENTICATION_INVALID 0x0006 +#define V2_AUTHENTICATION_ABSENT 0x0006 +#define V2_AUTHENTICATION_FAILED 0x0007 +#define V2_VER_NOT_SUPPORTED 0x0009 +#define NOT_SUPPORTED_YET 0x000a +#define V2_INTERNAL_ERROR 0x000a +#define REQUEST_TIMED_OUT 0x000b +#define V2_DA_BUSY_NOW 0x000b +#define COULD_NOT_INIT_NET_RESOURCES 0x000c +#define V2_OPTION_NOT_UNDERSTOOD 0x000c +#define COULD_NOT_ALLOCATE_MEMORY 0x000d +#define V2_INVALID_UPDATE 0x000d +#define PARAMETER_BAD 0x000e +#define V2_RQST_NOT_SUPPORTED 0x000e +#define INVALID_LIFETIME 0x000f + +#define INTERNAL_NET_ERROR 0x000f +#define INTERNAL_SYSTEM_ERROR 0x0010 + +#ifdef __cplusplus +} +#endif + +#endif /* _SNOOP_SLP_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.c new file mode 100644 index 0000000..097dd6e --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.c @@ -0,0 +1,1127 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <unistd.h> +#include <stropts.h> +#include <string.h> +#include <stdlib.h> +#include <fcntl.h> +#include <stdarg.h> +#include <setjmp.h> +#include <string.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/time.h> +#include <signal.h> +#include <sys/mman.h> +#include <assert.h> +#include <sys/sysmacros.h> + +#include <sys/socket.h> +#include <sys/pfmod.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/if_ether.h> +#include <netdb.h> + +#include "snoop.h" + +static int snaplen; + +/* Global error recovery variables */ +sigjmp_buf jmp_env, ojmp_env; /* error recovery jmp buf */ +int snoop_nrecover; /* number of recoveries on curr pkt */ +int quitting; /* user termination flag */ + +static struct snoop_handler *snoop_hp; /* global alarm handler head */ +static struct snoop_handler *snoop_tp; /* global alarm handler tail */ +static time_t snoop_nalarm; /* time of next alarm */ + +/* protected interpreter output areas */ +#define MAXSUM 8 +#define REDZONE 64 +static char *sumline[MAXSUM]; +static char *detail_line; +static char *line; +static char *encap; + +static int audio; +int maxcount; /* maximum no of packets to capture */ +int count; /* count of packets captured */ +static int sumcount; +int x_offset = -1; +int x_length = 0x7fffffff; +FILE *namefile; +boolean_t Pflg; +boolean_t Iflg; +boolean_t qflg; +boolean_t rflg; +#ifdef DEBUG +boolean_t zflg; +#endif +struct Pf_ext_packetfilt pf; + +static int vlanid = 0; + +static void usage(void); +static void snoop_sigrecover(int sig, siginfo_t *info, void *p); +static char *protmalloc(size_t); +static void resetperm(void); + +int +main(int argc, char **argv) +{ + int c; + int filter = 0; + int flags = F_SUM; + struct Pf_ext_packetfilt *fp = NULL; + char *icapfile = NULL; + char *ocapfile = NULL; + boolean_t nflg = B_FALSE; + boolean_t Nflg = B_FALSE; + int Cflg = 0; + boolean_t Uflg = B_FALSE; + int first = 1; + int last = 0x7fffffff; + boolean_t use_kern_pf; + char *p, *p2; + char names[MAXPATHLEN + 1]; + char self[MAXHOSTNAMELEN + 1]; + char *argstr = NULL; + void (*proc)(); + char *audiodev; + int ret; + struct sigaction sigact; + stack_t sigstk; + char *output_area; + int nbytes; + char *datalink = NULL; + dlpi_handle_t dh; + + names[0] = '\0'; + /* + * Global error recovery: Prepare for interpreter failures + * with corrupted packets or confused interpreters. + * Allocate protected output and stack areas, with generous + * red-zones. + */ + nbytes = (MAXSUM + 3) * (MAXLINE + REDZONE); + output_area = protmalloc(nbytes); + if (output_area == NULL) { + perror("Warning: mmap"); + exit(1); + } + + /* Allocate protected output areas */ + for (ret = 0; ret < MAXSUM; ret++) { + sumline[ret] = (char *)output_area; + output_area += (MAXLINE + REDZONE); + } + detail_line = output_area; + output_area += MAXLINE + REDZONE; + line = output_area; + output_area += MAXLINE + REDZONE; + encap = output_area; + output_area += MAXLINE + REDZONE; + + /* Initialize an alternate signal stack to increase robustness */ + if ((sigstk.ss_sp = (char *)malloc(SIGSTKSZ+REDZONE)) == NULL) { + perror("Warning: malloc"); + exit(1); + } + sigstk.ss_size = SIGSTKSZ; + sigstk.ss_flags = 0; + if (sigaltstack(&sigstk, (stack_t *)NULL) < 0) { + perror("Warning: sigaltstack"); + exit(1); + } + + /* Initialize a master signal handler */ + sigact.sa_handler = NULL; + sigact.sa_sigaction = snoop_sigrecover; + (void) sigemptyset(&sigact.sa_mask); + sigact.sa_flags = SA_ONSTACK|SA_SIGINFO; + + /* Register master signal handler */ + if (sigaction(SIGHUP, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGINT, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGQUIT, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGILL, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGTRAP, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGIOT, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGEMT, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGFPE, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGBUS, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGSEGV, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGSYS, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGALRM, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + if (sigaction(SIGTERM, &sigact, (struct sigaction *)NULL) < 0) { + perror("Warning: sigaction"); + exit(1); + } + + /* Prepare for failure during program initialization/exit */ + if (sigsetjmp(jmp_env, 1)) { + exit(1); + } + (void) setvbuf(stdout, NULL, _IOLBF, BUFSIZ); + + while ((c = getopt(argc, argv, "at:CPDSi:o:Nn:s:d:I:vVp:f:c:x:U?rqz")) + != EOF) { + switch (c) { + case 'a': + audiodev = getenv("AUDIODEV"); + if (audiodev == NULL) + audiodev = "/dev/audio"; + audio = open(audiodev, O_WRONLY); + if (audio < 0) { + pr_err("Audio device %s: %m", + audiodev); + exit(1); + } + break; + case 't': + flags |= F_TIME; + switch (*optarg) { + case 'r': flags |= F_RTIME; break; + case 'a': flags |= F_ATIME; break; + case 'd': break; + default: usage(); + } + break; + case 'I': + if (datalink != NULL) + usage(); + Iflg = B_TRUE; + datalink = optarg; + break; + case 'P': + Pflg = B_TRUE; + break; + case 'D': + flags |= F_DROPS; + break; + case 'S': + flags |= F_LEN; + break; + case 'i': + icapfile = optarg; + break; + case 'o': + ocapfile = optarg; + break; + case 'N': + Nflg = B_TRUE; + break; + case 'n': + nflg = B_TRUE; + (void) strlcpy(names, optarg, MAXPATHLEN); + break; + case 's': + snaplen = atoi(optarg); + break; + case 'd': + if (Iflg) + usage(); + datalink = optarg; + break; + case 'v': + flags &= ~(F_SUM); + flags |= F_DTAIL; + break; + case 'V': + flags |= F_ALLSUM; + break; + case 'p': + p = optarg; + p2 = strpbrk(p, ",:-"); + if (p2 == NULL) { + first = last = atoi(p); + } else { + *p2++ = '\0'; + first = atoi(p); + last = atoi(p2); + } + break; + case 'f': + (void) gethostname(self, MAXHOSTNAMELEN); + p = strchr(optarg, ':'); + if (p) { + *p = '\0'; + if (strcmp(optarg, self) == 0 || + strcmp(p+1, self) == 0) + (void) fprintf(stderr, + "Warning: cannot capture packets from %s\n", + self); + *p = ' '; + } else if (strcmp(optarg, self) == 0) + (void) fprintf(stderr, + "Warning: cannot capture packets from %s\n", + self); + argstr = optarg; + break; + case 'x': + p = optarg; + p2 = strpbrk(p, ",:-"); + if (p2 == NULL) { + x_offset = atoi(p); + x_length = -1; + } else { + *p2++ = '\0'; + x_offset = atoi(p); + x_length = atoi(p2); + } + break; + case 'c': + maxcount = atoi(optarg); + break; + case 'C': + Cflg = B_TRUE; + break; + case 'q': + qflg = B_TRUE; + break; + case 'r': + rflg = B_TRUE; + break; + case 'U': + Uflg = B_TRUE; + break; +#ifdef DEBUG + case 'z': + zflg = B_TRUE; + break; +#endif /* DEBUG */ + case '?': + default: + usage(); + } + } + + if (argc > optind) + argstr = (char *)concat_args(&argv[optind], argc - optind); + + /* + * Need to know before we decide on filtering method some things + * about the interface. So, go ahead and do part of the initialization + * now so we have that data. Note that if no datalink is specified, + * open_datalink() selects one and returns it. In an ideal world, + * it might be nice if the "correct" interface for the filter + * requested was chosen, but that's too hard. + */ + if (!icapfile) { + use_kern_pf = open_datalink(&dh, datalink); + } else { + use_kern_pf = B_FALSE; + cap_open_read(icapfile); + + if (!nflg) { + names[0] = '\0'; + (void) strlcpy(names, icapfile, MAXPATHLEN); + (void) strlcat(names, ".names", MAXPATHLEN); + } + } + + if (Uflg) + use_kern_pf = B_FALSE; + + /* attempt to read .names file if it exists before filtering */ + if ((!Nflg) && names[0] != '\0') { + if (access(names, F_OK) == 0) { + load_names(names); + } else if (nflg) { + (void) fprintf(stderr, "%s not found\n", names); + exit(1); + } + } + + if (argstr) { + if (use_kern_pf) { + ret = pf_compile(argstr, Cflg); + switch (ret) { + case 0: + filter++; + compile(argstr, Cflg); + break; + case 1: + fp = &pf; + break; + case 2: + fp = &pf; + filter++; + break; + } + } else { + filter++; + compile(argstr, Cflg); + } + + if (Cflg) + exit(0); + } + + if (flags & F_SUM) + flags |= F_WHO; + + /* + * If the -o flag is set then capture packets + * directly to a file. Don't attempt to + * interpret them on the fly (F_NOW). + * Note: capture to file is much less likely + * to drop packets since we don't spend cpu + * cycles running through the interpreters + * and possibly hanging in address-to-name + * mappings through the name service. + */ + if (ocapfile) { + cap_open_write(ocapfile); + proc = cap_write; + } else { + flags |= F_NOW; + proc = process_pkt; + } + + + /* + * If the -i flag is set then get packets from + * the log file which has been previously captured + * with the -o option. + */ + if (icapfile) { + names[0] = '\0'; + (void) strlcpy(names, icapfile, MAXPATHLEN); + (void) strlcat(names, ".names", MAXPATHLEN); + + if (Nflg) { + namefile = fopen(names, "w"); + if (namefile == NULL) { + perror(names); + exit(1); + } + flags = 0; + (void) fprintf(stderr, + "Creating name file %s\n", names); + } + + if (flags & F_DTAIL) + flags = F_DTAIL; + else + flags |= F_NUM | F_TIME; + + resetperm(); + cap_read(first, last, filter, proc, flags); + + if (Nflg) + (void) fclose(namefile); + + } else { + const int chunksize = 8 * 8192; + struct timeval timeout; + + /* + * If listening to packets on audio + * then set the buffer timeout down + * to 1/10 sec. A higher value + * makes the audio "bursty". + */ + if (audio) { + timeout.tv_sec = 0; + timeout.tv_usec = 100000; + } else { + timeout.tv_sec = 1; + timeout.tv_usec = 0; + } + + init_datalink(dh, snaplen, chunksize, &timeout, fp); + if (! qflg && ocapfile) + show_count(); + resetperm(); + net_read(dh, chunksize, filter, proc, flags); + dlpi_close(dh); + + if (!(flags & F_NOW)) + (void) printf("\n"); + } + + if (ocapfile) + cap_close(); + + return (0); +} + +static int tone[] = { +0x076113, 0x153333, 0x147317, 0x144311, 0x147315, 0x050353, 0x037103, 0x051106, +0x157155, 0x142723, 0x133273, 0x134664, 0x051712, 0x024465, 0x026447, 0x072473, +0x136715, 0x126257, 0x135256, 0x047344, 0x034476, 0x027464, 0x036062, 0x133334, +0x127256, 0x130660, 0x136262, 0x040724, 0x016446, 0x025437, 0x137171, 0x127672, +0x124655, 0x134654, 0x032741, 0x021447, 0x037450, 0x125675, 0x127650, 0x077277, +0x046514, 0x036077, 0x035471, 0x147131, 0x136272, 0x162720, 0x166151, 0x037527, +}; + +/* + * Make a sound on /dev/audio according to the length of the packet. The + * tone data was ripped from /usr/share/audio/samples/au/bark.au. The + * amount of waveform used is a function of packet length e.g. a series + * of small packets is heard as clicks, whereas a series of NFS packets in + * an 8k read sounds like a "WHAAAARP". + */ +void +click(len) + int len; +{ + len /= 8; + len = len ? len : 4; + + if (audio) { + (void) write(audio, tone, len); + } +} + +/* Display a count of packets */ +void +show_count() +{ + static int prev = -1; + + if (count == prev) + return; + + prev = count; + (void) fprintf(stderr, "\r%d ", count); +} + +#define ENCAP_LEN 16 /* Hold "(NN encap)" */ + +/* + * Display data that's external to the packet. + * This constitutes the first half of the summary + * line display. + */ +void +show_pktinfo(flags, num, src, dst, ptvp, tvp, drops, len) + int flags, num, drops, len; + char *src, *dst; + struct timeval *ptvp, *tvp; +{ + struct tm *tm; + static struct timeval tvp0; + int sec, usec; + char *lp = line; + int i, start; + + if (flags & F_NUM) { + (void) sprintf(lp, "%3d ", num); + lp += strlen(lp); + } + tm = localtime(&tvp->tv_sec); + + if (flags & F_TIME) { + if (flags & F_ATIME) { + (void) sprintf(lp, "%d:%02d:%d.%05d ", + tm->tm_hour, tm->tm_min, tm->tm_sec, + (int)tvp->tv_usec / 10); + lp += strlen(lp); + } else { + if (flags & F_RTIME) { + if (tvp0.tv_sec == 0) { + tvp0.tv_sec = tvp->tv_sec; + tvp0.tv_usec = tvp->tv_usec; + } + ptvp = &tvp0; + } + sec = tvp->tv_sec - ptvp->tv_sec; + usec = tvp->tv_usec - ptvp->tv_usec; + if (usec < 0) { + usec += 1000000; + sec -= 1; + } + (void) sprintf(lp, "%3d.%05d ", sec, usec / 10); + lp += strlen(lp); + } + } + + if ((flags & F_SUM) && !(flags & F_ALLSUM) && (vlanid != 0)) { + (void) snprintf(lp, MAXLINE, "VLAN#%i: ", vlanid); + lp += strlen(lp); + } + + if (flags & F_WHO) { + (void) sprintf(lp, "%12s -> %-12s ", src, dst); + lp += strlen(lp); + } + + if (flags & F_DROPS) { + (void) sprintf(lp, "drops: %d ", drops); + lp += strlen(lp); + } + + if (flags & F_LEN) { + (void) sprintf(lp, "length: %4d ", len); + lp += strlen(lp); + } + + if (flags & F_SUM) { + if (flags & F_ALLSUM) + (void) printf("________________________________\n"); + + start = flags & F_ALLSUM ? 0 : sumcount - 1; + (void) sprintf(encap, " (%d encap)", total_encap_levels - 1); + (void) printf("%s%s%s\n", line, sumline[start], + ((flags & F_ALLSUM) || (total_encap_levels == 1)) ? "" : + encap); + + for (i = start + 1; i < sumcount; i++) + (void) printf("%s%s\n", line, sumline[i]); + + sumcount = 0; + } + + if (flags & F_DTAIL) { + (void) printf("%s\n\n", detail_line); + detail_line[0] = '\0'; + } +} + +/* + * The following three routines are called back + * from the interpreters to display their stuff. + * The theory is that when snoop becomes a window + * based tool we can just supply a new version of + * get_sum_line and get_detail_line and not have + * to touch the interpreters at all. + */ +char * +get_sum_line() +{ + int tsumcount = sumcount; + + if (sumcount >= MAXSUM) { + sumcount = 0; /* error recovery */ + pr_err( + "get_sum_line: sumline overflow (sumcount=%d, MAXSUM=%d)\n", + tsumcount, MAXSUM); + } + + sumline[sumcount][0] = '\0'; + return (sumline[sumcount++]); +} + +/*ARGSUSED*/ +char * +get_detail_line(off, len) + int off, len; +{ + if (detail_line[0]) { + (void) printf("%s\n", detail_line); + detail_line[0] = '\0'; + } + return (detail_line); +} + +/* + * This function exists to make sure that VLAN information is + * prepended to summary lines displayed. The problem this function + * solves is how to display VLAN information while in summary mode. + * Each interpretor uses the get_sum_line and get_detail_line functions + * to get a character buffer to display information to the user. + * get_sum_line is the important one here. Each call to get_sum_line + * gets a buffer which stores one line of information. In summary mode, + * the last line generated is the line printed. Instead of changing each + * interpreter to add VLAN information to the summary line, the ethernet + * interpreter changes to call this function and set an ID. If the ID is not + * zero and snoop is in default summary mode, snoop displays the + * VLAN information at the beginning of the output line. Otherwise, + * no VLAN information is displayed. + */ +void +set_vlan_id(int id) +{ + vlanid = id; +} + +/* + * Print an error. + * Works like printf (fmt string and variable args) + * except that it will substitute an error message + * for a "%m" string (like syslog) and it calls + * long_jump - it doesn't return to where it was + * called from - it goes to the last setjmp(). + */ +/* VARARGS1 */ +void +pr_err(const char *fmt, ...) +{ + va_list ap; + char buf[1024], *p2; + const char *p1; + + (void) strcpy(buf, "snoop: "); + p2 = buf + strlen(buf); + + /* + * Note that we terminate the buffer with '\n' and '\0'. + */ + for (p1 = fmt; *p1 != '\0' && p2 < buf + sizeof (buf) - 2; p1++) { + if (*p1 == '%' && *(p1+1) == 'm') { + const char *errstr; + + if ((errstr = strerror(errno)) != NULL) { + *p2 = '\0'; + (void) strlcat(buf, errstr, sizeof (buf)); + p2 += strlen(p2); + } + p1++; + } else { + *p2++ = *p1; + } + } + if (p2 > buf && *(p2-1) != '\n') + *p2++ = '\n'; + *p2 = '\0'; + + va_start(ap, fmt); + /* LINTED: E_SEC_PRINTF_VAR_FMT */ + (void) vfprintf(stderr, buf, ap); + va_end(ap); + snoop_sigrecover(-1, NULL, NULL); /* global error recovery */ +} + +/* + * Store a copy of linkname associated with the DLPI handle. + * Save errno before closing the dlpi handle so that the + * correct error value is used if 'err' is a system error. + */ +void +pr_errdlpi(dlpi_handle_t dh, const char *cmd, int err) +{ + int save_errno = errno; + char linkname[DLPI_LINKNAME_MAX]; + + (void) strlcpy(linkname, dlpi_linkname(dh), sizeof (linkname)); + + dlpi_close(dh); + errno = save_errno; + + pr_err("%s on \"%s\": %s", cmd, linkname, dlpi_strerror(err)); +} + +/* + * Ye olde usage proc + * PLEASE keep this up to date! + * Naive users *love* this stuff. + */ +static void +usage(void) +{ + (void) fprintf(stderr, "\nUsage: snoop\n"); + (void) fprintf(stderr, + "\t[ -a ] # Listen to packets on audio\n"); + (void) fprintf(stderr, + "\t[ -d link ] # Listen on named link\n"); + (void) fprintf(stderr, + "\t[ -s snaplen ] # Truncate packets\n"); + (void) fprintf(stderr, + "\t[ -I IP interface ] # Listen on named IP interface\n"); + (void) fprintf(stderr, + "\t[ -c count ] # Quit after count packets\n"); + (void) fprintf(stderr, + "\t[ -P ] # Turn OFF promiscuous mode\n"); + (void) fprintf(stderr, + "\t[ -D ] # Report dropped packets\n"); + (void) fprintf(stderr, + "\t[ -S ] # Report packet size\n"); + (void) fprintf(stderr, + "\t[ -i file ] # Read previously captured packets\n"); + (void) fprintf(stderr, + "\t[ -o file ] # Capture packets in file\n"); + (void) fprintf(stderr, + "\t[ -n file ] # Load addr-to-name table from file\n"); + (void) fprintf(stderr, + "\t[ -N ] # Create addr-to-name table\n"); + (void) fprintf(stderr, + "\t[ -t r|a|d ] # Time: Relative, Absolute or Delta\n"); + (void) fprintf(stderr, + "\t[ -v ] # Verbose packet display\n"); + (void) fprintf(stderr, + "\t[ -V ] # Show all summary lines\n"); + (void) fprintf(stderr, + "\t[ -p first[,last] ] # Select packet(s) to display\n"); + (void) fprintf(stderr, + "\t[ -x offset[,length] ] # Hex dump from offset for length\n"); + (void) fprintf(stderr, + "\t[ -C ] # Print packet filter code\n"); + (void) fprintf(stderr, + "\t[ -q ] # Suppress printing packet count\n"); + (void) fprintf(stderr, + "\t[ -r ] # Do not resolve address to name\n"); + (void) fprintf(stderr, + "\n\t[ filter expression ]\n"); + (void) fprintf(stderr, "\nExample:\n"); + (void) fprintf(stderr, "\tsnoop -o saved host fred\n\n"); + (void) fprintf(stderr, "\tsnoop -i saved -tr -v -p19\n"); + exit(1); +} + +/* + * sdefault: default global alarm handler. Causes the current packet + * to be skipped. + */ +static void +sdefault(void) +{ + snoop_nrecover = SNOOP_MAXRECOVER; +} + +/* + * snoop_alarm: register or unregister an alarm handler to be called after + * s_sec seconds. Because snoop wasn't written to tolerate random signal + * delivery, periodic SIGALRM delivery (or SA_RESTART) cannot be used. + * + * s_sec argument of 0 seconds unregisters the handler. + * s_handler argument of NULL registers default handler sdefault(), or + * unregisters all signal handlers (for error recovery). + * + * Variables must be volatile to force the compiler to not optimize + * out the signal blocking. + */ +/*ARGSUSED*/ +int +snoop_alarm(int s_sec, void (*s_handler)()) +{ + volatile time_t now; + volatile time_t nalarm = 0; + volatile struct snoop_handler *sh = NULL; + volatile struct snoop_handler *hp, *tp, *next; + volatile sigset_t s_mask; + volatile int ret = -1; + + (void) sigemptyset((sigset_t *)&s_mask); + (void) sigaddset((sigset_t *)&s_mask, SIGALRM); + if (s_sec < 0) + return (-1); + + /* register an alarm handler */ + now = time(NULL); + if (s_sec) { + sh = malloc(sizeof (struct snoop_handler)); + sh->s_time = now + s_sec; + if (s_handler == NULL) + s_handler = sdefault; + sh->s_handler = s_handler; + sh->s_next = NULL; + (void) sigprocmask(SIG_BLOCK, (sigset_t *)&s_mask, NULL); + if (snoop_hp == NULL) { + snoop_hp = snoop_tp = (struct snoop_handler *)sh; + + snoop_nalarm = sh->s_time; + (void) alarm(sh->s_time - now); + } else { + snoop_tp->s_next = (struct snoop_handler *)sh; + snoop_tp = (struct snoop_handler *)sh; + + if (sh->s_time < snoop_nalarm) { + snoop_nalarm = sh->s_time; + (void) alarm(sh->s_time - now); + } + } + (void) sigprocmask(SIG_UNBLOCK, (sigset_t *)&s_mask, NULL); + + return (0); + } + + /* unregister an alarm handler */ + (void) sigprocmask(SIG_BLOCK, (sigset_t *)&s_mask, NULL); + tp = (struct snoop_handler *)&snoop_hp; + for (hp = snoop_hp; hp; hp = next) { + next = hp->s_next; + if (s_handler == NULL || hp->s_handler == s_handler) { + ret = 0; + tp->s_next = hp->s_next; + if (snoop_tp == hp) { + if (tp == (struct snoop_handler *)&snoop_hp) + snoop_tp = NULL; + else + snoop_tp = (struct snoop_handler *)tp; + } + free((void *)hp); + } else { + if (nalarm == 0 || nalarm > hp->s_time) + nalarm = now < hp->s_time ? hp->s_time : + now + 1; + tp = hp; + } + } + /* + * Stop or adjust timer + */ + if (snoop_hp == NULL) { + snoop_nalarm = 0; + (void) alarm(0); + } else if (nalarm > 0 && nalarm < snoop_nalarm) { + snoop_nalarm = nalarm; + (void) alarm(nalarm - now); + } + + (void) sigprocmask(SIG_UNBLOCK, (sigset_t *)&s_mask, NULL); + return (ret); +} + +/* + * snoop_recover: reset snoop's output area, and any internal variables, + * to allow continuation. + * XXX: make this an interface such that each interpreter can + * register a reset routine. + */ +void +snoop_recover(void) +{ + int i; + + /* Error recovery: reset output_area and associated variables */ + for (i = 0; i < MAXSUM; i++) + sumline[i][0] = '\0'; + detail_line[0] = '\0'; + line[0] = '\0'; + encap[0] = '\0'; + sumcount = 0; + + /* stacking/unstacking cannot be relied upon */ + encap_levels = 0; + total_encap_levels = 1; + + /* remove any pending timeouts */ + (void) snoop_alarm(0, NULL); +} + +/* + * snoop_sigrecover: global sigaction routine to manage recovery + * from catastrophic interpreter failures while interpreting + * corrupt trace files/packets. SIGALRM timeouts, program errors, + * and user termination are all handled. In the case of a corrupt + * packet or confused interpreter, the packet will be skipped, and + * execution will continue in scan(). + * + * Global alarm handling (see snoop_alarm()) is managed here. + * + * Variables must be volatile to force the compiler to not optimize + * out the signal blocking. + */ +/*ARGSUSED*/ +static void +snoop_sigrecover(int sig, siginfo_t *info, void *p) +{ + volatile time_t now; + volatile time_t nalarm = 0; + volatile struct snoop_handler *hp; + + /* + * Invoke any registered alarms. This involves first calculating + * the time for the next alarm, setting it up, then progressing + * through handler invocations. Note that since handlers may + * use siglongjmp(), in the worst case handlers may be serviced + * at a later time. + */ + if (sig == SIGALRM) { + now = time(NULL); + /* Calculate next alarm time */ + for (hp = snoop_hp; hp; hp = hp->s_next) { + if (hp->s_time) { + if ((hp->s_time - now) > 0) { + if (nalarm == 0 || nalarm > hp->s_time) + nalarm = now < hp->s_time ? + hp->s_time : now + 1; + } + } + } + /* Setup next alarm */ + if (nalarm) { + snoop_nalarm = nalarm; + (void) alarm(nalarm - now); + } else { + snoop_nalarm = 0; + } + + /* Invoke alarm handlers (may not return) */ + for (hp = snoop_hp; hp; hp = hp->s_next) { + if (hp->s_time) { + if ((now - hp->s_time) >= 0) { + hp->s_time = 0; /* only invoke once */ + if (hp->s_handler) + hp->s_handler(); + } + } + } + } else { + snoop_nrecover++; + } + + /* + * Exit if a signal has occurred after snoop has begun the process + * of quitting. + */ + if (quitting) + exit(1); + + /* + * If an alarm handler has timed out, and snoop_nrecover has + * reached SNOOP_MAXRECOVER, skip to the next packet. + * + * If any other signal has occurred, and snoop_nrecover has + * reached SNOOP_MAXRECOVER, give up. + */ + if (sig == SIGALRM) { + if (ioctl(STDOUT_FILENO, I_CANPUT, 0) == 0) { + /* + * We've stalled on output, which is not a critical + * failure. Reset the recovery counter so we do not + * consider this a persistent failure, and return so + * we do not skip this packet. + */ + snoop_nrecover = 0; + return; + } + if (snoop_nrecover >= SNOOP_MAXRECOVER) { + (void) fprintf(stderr, + "snoop: WARNING: skipping from packet %d\n", + count); + snoop_nrecover = 0; + } else { + /* continue trying */ + return; + } + } else if (snoop_nrecover >= SNOOP_MAXRECOVER) { + (void) fprintf(stderr, + "snoop: ERROR: cannot recover from packet %d\n", count); + exit(1); + } + +#ifdef DEBUG + (void) fprintf(stderr, "snoop_sigrecover(%d, %p, %p)\n", sig, info, p); +#endif /* DEBUG */ + + /* + * Prepare to quit. This allows final processing to occur + * after first terminal interruption. + */ + if (sig == SIGTERM || sig == SIGHUP || sig == SIGINT) { + quitting = 1; + return; + } else if (sig != -1 && sig != SIGALRM) { + /* Inform user that snoop has taken a fault */ + (void) fprintf(stderr, + "WARNING: received signal %d from packet %d\n", + sig, count); + } + + /* Reset interpreter variables */ + snoop_recover(); + + /* Continue in scan() with the next packet */ + siglongjmp(jmp_env, 1); + /*NOTREACHED*/ +} + +/* + * Protected malloc for global error recovery: prepare for interpreter + * failures with corrupted packets or confused interpreters. Dynamically + * allocate `nbytes' bytes, and sandwich it between two PROT_NONE pages to + * catch writes outside of the allocated region. + */ +static char * +protmalloc(size_t nbytes) +{ + caddr_t start; + int psz = sysconf(_SC_PAGESIZE); + + nbytes = P2ROUNDUP(nbytes, psz); + start = mmap(NULL, nbytes + psz * 2, PROT_READ|PROT_WRITE, + MAP_PRIVATE|MAP_ANON, -1, 0); + if (start == MAP_FAILED) { + perror("Error: protmalloc: mmap"); + return (NULL); + } + assert(IS_P2ALIGNED(start, psz)); + if (mprotect(start, 1, PROT_NONE) == -1) + perror("Warning: mprotect"); + + start += psz; + if (mprotect(start + nbytes, 1, PROT_NONE) == -1) + perror("Warning: mprotect"); + + return (start); +} + +/* + * resetperm - reduce security vulnerabilities by resetting + * owner/group/permissions. Always attempt setuid() - if we have + * permission to drop our privilege level, do so. + */ +void +resetperm(void) +{ + if (geteuid() == 0) { + (void) setgid(GID_NOBODY); + (void) setuid(UID_NOBODY); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.h new file mode 100644 index 0000000..e4f1825 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop.h @@ -0,0 +1,355 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * + * Copyright 2011 Nexenta Systems, Inc. All rights reserved. + */ + +#ifndef _SNOOP_H +#define _SNOOP_H + +#include <rpc/types.h> +#include <sys/pfmod.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/bufmod.h> +#include <net/if.h> +#include <netinet/in.h> +#include <netinet/if_ether.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> +#include <netinet/ip6.h> +#include <netinet/ip_icmp.h> +#include <netinet/icmp6.h> +#include <net/pppoe.h> +#include <libdlpi.h> +#include <note.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Flags to control packet info display + */ +#define F_NOW 0x00000001 /* display in realtime */ +#define F_SUM 0x00000002 /* display summary line */ +#define F_ALLSUM 0x00000004 /* display all summary lines */ +#define F_DTAIL 0x00000008 /* display detail lines */ +#define F_TIME 0x00000010 /* display time */ +#define F_ATIME 0x00000020 /* display absolute time */ +#define F_RTIME 0x00000040 /* display relative time */ +#define F_DROPS 0x00000080 /* display drops */ +#define F_LEN 0x00000100 /* display pkt length */ +#define F_NUM 0x00000200 /* display pkt number */ +#define F_WHO 0x00000400 /* display src/dst */ + +#define MAXLINE (1088) /* max len of detail line */ + +/* + * The RPC XID cache structure. + * When analyzing RPC protocols we + * have to cache the xid of the RPC + * request together with the program + * number, proc, version etc since this + * information is missing in the reply + * packet. Using the xid in the reply + * we can lookup this previously stashed + * information in the cache. + * + * For RPCSEC_GSS flavor, some special processing is + * needed for the argument interpretation based on its + * control procedure and service type. This information + * is stored in the cache table during interpretation of + * the rpc header and will be referenced later when the rpc + * argument is interpreted. + */ +#define XID_CACHE_SIZE 256 +struct cache_struct { + int xid_num; /* RPC transaction id */ + int xid_frame; /* Packet number */ + int xid_prog; /* RPC program number */ + int xid_vers; /* RPC version number */ + int xid_proc; /* RPC procedure number */ + unsigned int xid_gss_proc; /* control procedure */ + int xid_gss_service; /* none, integ, priv */ +} xid_cache[XID_CACHE_SIZE]; + + +/* + * The following macros advance the pointer passed to them. They + * assume they are given a char *. + */ +#define GETINT8(v, ptr) { \ + (v) = (*(ptr)++); \ +} + +#define GETINT16(v, ptr) { \ + (v) = *(ptr)++ << 8; \ + (v) |= *(ptr)++; \ +} + +#define GETINT32(v, ptr) { \ + (v) = *(ptr)++ << 8; \ + (v) |= *(ptr)++; (v) <<= 8; \ + (v) |= *(ptr)++; (v) <<= 8; \ + (v) |= *(ptr)++; \ +} + +/* + * Used to print nested protocol layers. For example, an ip datagram included + * in an icmp error, or a PPP packet included in an LCP protocol reject.. + */ +extern char *prot_nest_prefix; + +extern char *get_sum_line(void); +extern char *get_detail_line(int, int); +extern int want_packet(uchar_t *, int, int); +extern void set_vlan_id(int); +extern struct timeval prev_time; +extern void process_pkt(struct sb_hdr *, char *, int, int); +extern char *getflag(int, int, char *, char *); +extern void show_header(char *, char *, int); +extern void show_count(void); +extern void xdr_init(char *, int); +extern char *get_line(int, int); +extern int get_line_remain(void); +extern char getxdr_char(void); +extern char showxdr_char(char *); +extern uchar_t getxdr_u_char(void); +extern uchar_t showxdr_u_char(char *); +extern short getxdr_short(void); +extern short showxdr_short(char *); +extern ushort_t getxdr_u_short(void); +extern ushort_t showxdr_u_short(char *); +extern long getxdr_long(void); +extern long showxdr_long(char *); +extern ulong_t getxdr_u_long(void); +extern ulong_t showxdr_u_long(char *); +extern longlong_t getxdr_longlong(void); +extern longlong_t showxdr_longlong(char *); +extern u_longlong_t getxdr_u_longlong(void); +extern u_longlong_t showxdr_u_longlong(char *); +extern char *getxdr_opaque(char *, int); +extern char *getxdr_string(char *, int); +extern char *showxdr_string(int, char *); +extern char *getxdr_bytes(uint_t *); +extern void xdr_skip(int); +extern int getxdr_pos(void); +extern void setxdr_pos(int); +extern char *getxdr_context(char *, int); +extern char *showxdr_context(char *); +extern enum_t getxdr_enum(void); +extern void show_space(void); +extern void show_trailer(void); +extern char *getxdr_date(void); +extern char *showxdr_date(char *); +extern char *getxdr_date_ns(void); +char *format_time(int64_t sec, uint32_t nsec); +extern char *showxdr_date_ns(char *); +extern char *getxdr_hex(int); +extern char *showxdr_hex(int, char *); +extern bool_t getxdr_bool(void); +extern bool_t showxdr_bool(char *); +extern char *concat_args(char **, int); +extern int pf_compile(char *, int); +extern void compile(char *, int); +extern void load_names(char *); +extern void cap_write(struct sb_hdr *, char *, int, int); +extern void cap_open_read(const char *); +extern void cap_open_write(const char *); +extern void cap_read(int, int, int, void (*)(), int); +extern void cap_close(void); +extern boolean_t open_datalink(dlpi_handle_t *, const char *); +extern void init_datalink(dlpi_handle_t, ulong_t, ulong_t, struct timeval *, + struct Pf_ext_packetfilt *); +extern void net_read(dlpi_handle_t, size_t, int, void (*)(), int); +extern void click(int); +extern void show_pktinfo(int, int, char *, char *, struct timeval *, + struct timeval *, int, int); +extern void show_line(char *); +/*PRINTFLIKE1*/ +extern void show_printf(char *fmt, ...) + __PRINTFLIKE(1); +extern char *getxdr_time(void); +extern char *showxdr_time(char *); +extern char *addrtoname(int, const void *); +extern char *show_string(const char *, int, int); +extern void pr_err(const char *, ...); +extern void pr_errdlpi(dlpi_handle_t, const char *, int); +extern void check_retransmit(char *, ulong_t); +extern char *nameof_prog(int); +extern char *getproto(int); +extern uint8_t print_ipv6_extensions(int, uint8_t **, uint8_t *, int *, int *); +extern void protoprint(int, int, ulong_t, int, int, int, char *, int); +extern char *getportname(int, in_port_t); + +extern void interpret_arp(int, struct arphdr *, int); +extern void interpret_bparam(int, int, int, int, int, char *, int); +extern void interpret_dns(int, int, const uchar_t *, int, int); +extern void interpret_mount(int, int, int, int, int, char *, int); +extern void interpret_nfs(int, int, int, int, int, char *, int); +extern void interpret_nfs3(int, int, int, int, int, char *, int); +extern void interpret_nfs4(int, int, int, int, int, char *, int); +extern void interpret_nfs4_cb(int, int, int, int, int, char *, int); +extern void interpret_nfs_acl(int, int, int, int, int, char *, int); +extern void interpret_nis(int, int, int, int, int, char *, int); +extern void interpret_nisbind(int, int, int, int, int, char *, int); +extern void interpret_nlm(int, int, int, int, int, char *, int); +extern void interpret_pmap(int, int, int, int, int, char *, int); +extern int interpret_reserved(int, int, in_port_t, in_port_t, char *, int); +extern void interpret_rquota(int, int, int, int, int, char *, int); +extern void interpret_rstat(int, int, int, int, int, char *, int); +extern void interpret_solarnet_fw(int, int, int, int, int, char *, int); +extern void interpret_ldap(int, char *, int, int, int); +extern void interpret_icmp(int, struct icmp *, int, int); +extern void interpret_icmpv6(int, icmp6_t *, int, int); +extern int interpret_ip(int, const struct ip *, int); +extern int interpret_ipv6(int, const ip6_t *, int); +extern int interpret_ppp(int, uchar_t *, int); +extern int interpret_pppoe(int, poep_t *, int); +struct tcphdr; +extern int interpret_tcp(int, struct tcphdr *, int, int); +struct udphdr; +extern int interpret_udp(int, struct udphdr *, int, int); +extern int interpret_esp(int, uint8_t *, int, int); +extern int interpret_ah(int, uint8_t *, int, int); +struct sctp_hdr; +extern void interpret_sctp(int, struct sctp_hdr *, int, int); +extern void interpret_mip_cntrlmsg(int, uchar_t *, int); +struct dhcp; +extern int interpret_dhcp(int, struct dhcp *, int); +extern int interpret_dhcpv6(int, const uint8_t *, int); +struct tftphdr; +extern int interpret_tftp(int, struct tftphdr *, int); +extern int interpret_http(int, char *, int); +struct ntpdata; +extern int interpret_ntp(int, struct ntpdata *, int); +extern void interpret_netbios_ns(int, uchar_t *, int); +extern void interpret_netbios_datagram(int, uchar_t *, int); +extern void interpret_netbios_ses(int, uchar_t *, int); +extern void interpret_slp(int, char *, int); +struct rip; +extern int interpret_rip(int, struct rip *, int); +struct rip6; +extern int interpret_rip6(int, struct rip6 *, int); +extern int interpret_socks_call(int, char *, int); +extern int interpret_socks_reply(int, char *, int); +extern int interpret_trill(int, struct ether_header **, char *, int *); +extern int interpret_isis(int, char *, int, boolean_t); +extern int interpret_bpdu(int, char *, int); +extern void init_ldap(void); +extern boolean_t arp_for_ether(char *, struct ether_addr *); +extern char *ether_ouiname(uint32_t); +extern char *tohex(char *p, int len); +extern char *printether(struct ether_addr *); +extern char *print_ethertype(int); +extern const char *arp_htype(int); +extern int valid_rpc(char *, int); + +/* + * Describes characteristics of the Media Access Layer. + * The mac_type is one of the supported DLPI media + * types (see <sys/dlpi.h>). + * The mtu_size is the size of the largest frame. + * network_type_offset is where the network type + * is located in the link layer header. + * The header length is returned by a function to + * allow for variable header size - for ethernet it's + * just a constant 14 octets. + * The interpreter is the function that "knows" how + * to interpret the frame. + * try_kernel_filter tells snoop to first try a kernel + * filter (because the header size is fixed, or if it could + * be of variable size where the variable size is easy for a kernel + * filter to handle, for example, Ethernet and VLAN tags) + * and only use a user space filter if the filter expression + * cannot be expressed in kernel space. + */ +typedef uint_t (interpreter_fn_t)(int, char *, int, int); +typedef uint_t (headerlen_fn_t)(char *, size_t); +typedef struct interface { + uint_t mac_type; + uint_t mtu_size; + uint_t network_type_offset; + size_t network_type_len; + uint_t network_type_ip; + uint_t network_type_ipv6; + headerlen_fn_t *header_len; + interpreter_fn_t *interpreter; + boolean_t try_kernel_filter; +} interface_t; + +extern interface_t INTERFACES[], *interface; +extern char *dlc_header; +extern char *src_name, *dst_name; +extern char *prot_prefix; +extern char *prot_nest_prefix; +extern char *prot_title; + +/* Keep track of how many nested IP headers we have. */ +extern unsigned int encap_levels, total_encap_levels; + +extern int quitting; +extern boolean_t Iflg, Pflg, rflg; + +/* + * Global error recovery routine: used to reset snoop variables after + * catastrophic failure. + */ +void snoop_recover(void); + +/* + * Global alarm handler structure for managing multiple alarms within + * snoop. + */ +typedef struct snoop_handler { + struct snoop_handler *s_next; /* next alarm handler */ + time_t s_time; /* time to fire */ + void (*s_handler)(); /* alarm handler */ +} snoop_handler_t; + +#define SNOOP_MAXRECOVER 20 /* maxium number of recoveries */ +#define SNOOP_ALARM_GRAN 3 /* alarm() timeout multiplier */ + +/* + * Global alarm handler management routine. + */ +extern int snoop_alarm(int s_sec, void (*s_handler)()); + +/* + * The next two definitions do not take into account the length + * of the underlying link header. In order to use them, you must + * add link_header_len to them. The reason it is not done here is + * that later these macros are used to initialize a table. + */ +#define IPV4_TYPE_HEADER_OFFSET 9 +#define IPV6_TYPE_HEADER_OFFSET 6 + +#ifdef __cplusplus +} +#endif + +#endif /* _SNOOP_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aarp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aarp.c new file mode 100644 index 0000000..32133ee --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aarp.c @@ -0,0 +1,143 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991-2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <net/if.h> +#include <net/if_arp.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/if_ether.h> + +#include <at.h> +#include <snoop.h> + +static char *printat(uint8_t *); + +static char *aarp_opname[] = { + "", + "AARP Request", + "AARP Reply", + "AARP Probe", +}; + +void +interpret_aarp(int flags, char *data, int alen) +{ + /* LINTED */ + struct ether_arp *ap = (struct ether_arp *)data; + + extern char *dst_name; + + if (flags & F_SUM) { + if (alen < sizeof (struct ether_arp)) { + (void) snprintf(get_sum_line(), MAXLINE, + "AARP (short packet)"); + return; + } + + switch (ntohs(ap->arp_op)) { + case AARP_REQ: + (void) snprintf(get_sum_line(), MAXLINE, + "AARP C Who is %s ?", + printat(ap->arp_tpa)); + break; + case AARP_RESP: + (void) snprintf(get_sum_line(), MAXLINE, + "AARP R %s is %s", + printat(ap->arp_spa), + printether((struct ether_addr *)&ap->arp_sha)); + dst_name = printat(ap->arp_tpa); + break; + case AARP_PROBE: + (void) snprintf(get_sum_line(), MAXLINE, + "AARP Probe %s ?", + printat(ap->arp_tpa)); + break; + } + } + + if (flags & F_DTAIL) { + show_header("AARP: ", "AARP Frame", alen); + show_space(); + + if (alen < sizeof (struct ether_arp)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "AARP (short packet)"); + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hardware type = %d", + ntohs(ap->arp_hrd)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Protocol type = %04X (%s)", + ntohs(ap->arp_pro), + print_ethertype(ntohs(ap->arp_pro))); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length of hardware address = %d bytes", + ap->arp_hln); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length of protocol address = %d bytes", + ap->arp_pln); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Opcode %d (%s)", + ntohs(ap->arp_op), + aarp_opname[ntohs(ap->arp_op)]); + + if (ntohs(ap->arp_hrd) == ARPHRD_ETHER && + ntohs(ap->arp_pro) == ETHERTYPE_AT) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sender's hardware address = %s", + printether((struct ether_addr *)&ap->arp_sha)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sender's protocol address = %s", + printat(ap->arp_spa)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Target hardware address = %s", + (ntohs(ap->arp_op) == AARP_REQ || + ntohs(ap->arp_op) == AARP_PROBE) ? "?" : + printether((struct ether_addr *)&ap->arp_tha)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Target protocol address = %s", + ntohs(ap->arp_op) == REVARP_REQUEST ? "?" : + printat(ap->arp_tpa)); + } + show_trailer(); + } +} + +static char * +printat(uint8_t *p) +{ + static char buf[16]; + + (void) snprintf(buf, sizeof (buf), "%d.%d", get_short(&p[1]), p[3]); + return (buf); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_adsp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_adsp.c new file mode 100644 index 0000000..e771837 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_adsp.c @@ -0,0 +1,142 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991-2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +static char *adsp_ctrl(uint8_t); + +void +interpret_adsp(int flags, struct ddp_adsphdr *adp, int len) +{ + struct ddp_adsp_open *apo; + + if (flags & F_SUM) { + if (len < sizeof (struct ddp_adsphdr)) { + (void) snprintf(get_sum_line(), MAXLINE, + "ADSP (short packet)"); + return; + } + (void) snprintf(get_sum_line(), MAXLINE, + "ADSP ConnID=%u (%s)", + get_short(adp->ad_connid), + adsp_ctrl(adp->ad_desc)); + } + + if (flags & F_DTAIL) { + show_header("ADSP: ", "ADSP Header", + len - sizeof (struct ddp_adsphdr)); + show_space(); + + if (len < sizeof (struct ddp_adsphdr)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "(short packet)"); + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), + "ConnID = %u, ByteSeq = %u, RecvSeq = %u", + get_short(adp->ad_connid), + get_long(adp->ad_fbseq), + get_long(adp->ad_nrseq)); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "RcvWin = %u, Ctrl = 0x%x (%s)", + get_short(adp->ad_rcvwin), + adp->ad_desc, + adsp_ctrl(adp->ad_desc)); + + switch (adp->ad_desc) { + case AD_CREQ: /* open requests */ + case AD_CACK: + case AD_CREQ_ACK: + case AD_CDENY: + apo = (struct ddp_adsp_open *)adp; + if (len < sizeof (struct ddp_adsp_open)) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "(short packet)"); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Dest ConnID = %u, AttRcvSeq = %u", + get_short(apo->ad_dconnid), + get_long(apo->ad_attseq)); + break; + } + + if (adp->ad_desc & AD_ATT) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "AttCode = 0x%x", + get_short(((struct ddp_adsp_att *)adp)-> + ad_att_code)); + } + } +} + +static char *adsp_ctrl_msg[] = { + "Probe/Ack", + "OpenConnReq", + "OpenConnAck", + "OpenConnReq+Ack", + "OpenConnDeny", + "CloseConnAdv", + "ForwReset", + "ForwReset Ack", + "RetransAdv", + "9", "10", "11", "12", "13", "14", "15", +}; + +static char * +adsp_ctrl(uint8_t ctrl) +{ + static char buf[50]; + char *p = buf; + char *tail = &buf[sizeof (buf)]; + + if (ctrl & AD_ACKREQ) + p += snprintf(p, tail-p, "AckReq"); + + if (ctrl & AD_EOM) { + p += snprintf(p, tail-p, p == buf ? "EOM" : " EOM"); + } + + if (ctrl & AD_ATT) { + p += snprintf(p, tail-p, p == buf ? "Att" : " Att"); + } + + if (ctrl & AD_CTRL) { + (void) snprintf(p, tail-p, "%s%s", p == buf ? "" : " ", + adsp_ctrl_msg[ctrl & AD_CTRL_MASK]); + } + + return (buf); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aecho.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aecho.c new file mode 100644 index 0000000..348f6a9 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_aecho.c @@ -0,0 +1,72 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +void +interpret_aecho(int flags, struct ddp_hdr *ddp, int len) +{ + char *data; + + data = (char *)ddp + DDPHDR_SIZE; + + if (flags & F_SUM) { + if (len < DDPHDR_SIZE + 1) { + (void) snprintf(get_sum_line(), MAXLINE, + "AECHO (short packet)"); + return; + } + + (void) snprintf(get_sum_line(), MAXLINE, + "AECHO F=%s LEN=%d", + *data == AEP_REQ ? "Request" : "Reply", + len); + } + + if (flags & F_DTAIL) { + if (len < DDPHDR_SIZE + 1) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "AECHO (short packet)"); + return; + } + + show_header("AECHO: ", "AECHO Header", len); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Func = %d (%s)", + data[0], + data[0] == AEP_REQ ? "Request" : "Reply"); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length = %d", len); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_apple.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_apple.c new file mode 100644 index 0000000..bf6a6b4 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_apple.c @@ -0,0 +1,210 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> +#include <netinet/in.h> +#include <at.h> +#include <snoop.h> + +extern char *src_name, *dst_name; + +struct socktable { + int pt_num; + char *pt_short; +}; + +static struct socktable pt_ddp[] = { + {1, "RTMP"}, + {2, "NIS"}, + {4, "Echoer"}, + {6, "ZIS"}, + {0, NULL}, +}; + +static struct socktable pt_ddp_types[] = { + {1, "RTMP Resp"}, + {2, "NBP"}, + {3, "ATP"}, + {4, "AEP"}, + {5, "RTMP Req"}, + {6, "ZIP"}, + {7, "ADSP"}, + {0, NULL}, +}; + +static char * +apple_ddp_type(struct socktable *p, uint16_t port) +{ + for (; p->pt_num != 0; p++) { + if (port == p->pt_num) + return (p->pt_short); + } + return (NULL); +} + +/* + * return the short at p, regardless of alignment + */ + +uint16_t +get_short(uint8_t *p) +{ + return (p[0] << 8 | p[1]); +} + +/* + * return the long at p, regardless of alignment + */ +uint32_t +get_long(uint8_t *p) +{ + return (p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]); +} + +/* + * format a MAC address + */ + +char * +print_macaddr(uint8_t *ha, int len) +{ + static char buf[128]; + char *p = buf; + + while (len-- != 0) { + p += snprintf(p, sizeof (buf) - (p - buf), + len > 0 ? "%x:" : "%x", *ha++); + } + return (buf); +} + +/* ARGSUSED */ +void +interpret_at(int flags, struct ddp_hdr *ddp, int len) +{ + int ddplen; + char *pname; + char buff [32]; + static char src_buf[16]; + static char dst_buf[16]; + + if (ddp_pad(ddp) != 0) + return; /* unknown AppleTalk proto */ + + ddplen = ddp_len(ddp); + + (void) snprintf(src_buf, sizeof (src_buf), + "%u.%u", ntohs(ddp->ddp_src_net), ddp->ddp_src_id); + src_name = src_buf; + + (void) snprintf(dst_buf, sizeof (dst_buf), + "%u.%u", ntohs(ddp->ddp_dest_net), ddp->ddp_dest_id); + if (ddp->ddp_dest_id == NODE_ID_BROADCAST) + dst_name = "(broadcast)"; + else + dst_name = dst_buf; + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "DDP S=%u.%u:%u D=%u.%u:%u LEN=%d", + ntohs(ddp->ddp_src_net), + ddp->ddp_src_id, + ddp->ddp_src_sock, + ntohs(ddp->ddp_dest_net), + ddp->ddp_dest_id, + ddp->ddp_dest_sock, + ddp_len(ddp)); + } + + if (flags & F_DTAIL) { + show_header("DDP: ", "DDP Header", ddplen - DDPHDR_SIZE); + show_space(); + pname = apple_ddp_type(pt_ddp, ddp->ddp_src_sock); + if (pname == NULL) { + pname = ""; + } else { + (void) snprintf(buff, sizeof (buff), "(%s)", pname); + pname = buff; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Source = %s, Socket = %u %s", + src_name, ddp->ddp_src_sock, pname); + pname = apple_ddp_type(pt_ddp, ddp->ddp_dest_sock); + if (pname == NULL) { + pname = ""; + } else { + (void) snprintf(buff, sizeof (buff), "(%s)", pname); + pname = buff; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination = %s, Socket = %u %s", + dst_name, ddp->ddp_dest_sock, pname); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hop count = %d", + ddp_hop(ddp)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length = %d", + ddp_len(ddp)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Checksum = %04x %s", + ntohs(ddp->ddp_cksum), + ddp->ddp_cksum == 0 ? "(no checksum)" : ""); + (void) snprintf(get_line(0, 0), get_line_remain(), + "DDP type = %d (%s)", + ddp->ddp_type, + apple_ddp_type(pt_ddp_types, ddp->ddp_type)); + show_space(); + } + + + /* go to the next protocol layer */ + + switch (ddp->ddp_type) { + case DDP_TYPE_NBP: + interpret_nbp(flags, (struct nbp_hdr *)ddp, ddplen); + break; + case DDP_TYPE_AEP: + interpret_aecho(flags, ddp, ddplen); + break; + case DDP_TYPE_ATP: + interpret_atp(flags, ddp, ddplen); + break; + case DDP_TYPE_ZIP: + interpret_ddp_zip(flags, (struct zip_hdr *)ddp, ddplen); + break; + case DDP_TYPE_ADSP: + interpret_adsp(flags, (struct ddp_adsphdr *)ddp, ddplen); + break; + case DDP_TYPE_RTMPRQ: + case DDP_TYPE_RTMPRESP: + interpret_rtmp(flags, ddp, ddplen); + break; + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_arp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_arp.c new file mode 100644 index 0000000..c41507c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_arp.c @@ -0,0 +1,263 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <sys/socket.h> +#include <net/if.h> +#include <net/if_arp.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <netdb.h> +#include <net/if_types.h> + +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static char *printip(unsigned char *); +static char *addrtoname_align(unsigned char *); + +static char unarp_addr[] = "Unknown"; +char *opname[] = { + "", + "ARP Request", + "ARP Reply", + "REVARP Request", + "REVARP Reply", +}; + +void +interpret_arp(int flags, struct arphdr *ap, int alen) +{ + char *line; + extern char *src_name, *dst_name; + unsigned char *sip, *tip, *sha, *tha; + char *smacbuf = NULL, *dmacbuf = NULL; + int maclen; + ushort_t arpop; + boolean_t is_ip = B_FALSE; + + /* + * Check that at least the generic ARP header was received. + */ + if (sizeof (struct arphdr) > alen) + goto short_packet; + + arpop = ntohs(ap->ar_op); + maclen = ap->ar_hln; + if (ntohs(ap->ar_pro) == ETHERTYPE_IP) + is_ip = B_TRUE; + + sha = (unsigned char *)(ap + 1); + sip = sha + maclen; + tha = sip + ap->ar_pln; + tip = tha + maclen; + + /* + * Check that the protocol/hardware addresses were received. + */ + if ((tip + ap->ar_pln) > ((unsigned char *)ap + alen)) + goto short_packet; + + if (maclen == 0) { + smacbuf = dmacbuf = unarp_addr; + } else { + if (((flags & F_DTAIL) && is_ip) || (arpop == ARPOP_REPLY)) { + smacbuf = _link_ntoa(sha, NULL, maclen, IFT_OTHER); + if (smacbuf == NULL) + pr_err("Warning: malloc failure"); + } + + if (((flags & F_DTAIL) && is_ip) || (arpop == + REVARP_REQUEST) || (arpop == REVARP_REPLY)) { + dmacbuf = _link_ntoa(tha, NULL, maclen, IFT_OTHER); + if (dmacbuf == NULL) + pr_err("Warning: malloc failure"); + } + } + + src_name = addrtoname_align(sip); + + if (flags & F_SUM) { + + line = get_sum_line(); + + switch (arpop) { + case ARPOP_REQUEST: + (void) snprintf(line, MAXLINE, "ARP C Who is %s ?", + printip(tip)); + break; + case ARPOP_REPLY: + (void) snprintf(line, MAXLINE, "ARP R %s is %s", + printip(sip), smacbuf); + dst_name = addrtoname_align(tip); + break; + case REVARP_REQUEST: + (void) snprintf(line, MAXLINE, "RARP C Who is %s ?", + dmacbuf); + break; + case REVARP_REPLY: + (void) snprintf(line, MAXLINE, "RARP R %s is %s", + dmacbuf, printip(tip)); + dst_name = addrtoname_align(tip); + break; + } + } + + if (flags & F_DTAIL) { + show_header("ARP: ", "ARP/RARP Frame", alen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hardware type = %d (%s)", ntohs(ap->ar_hrd), + arp_htype(ntohs(ap->ar_hrd))); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Protocol type = %04x (%s)", ntohs(ap->ar_pro), + print_ethertype(ntohs(ap->ar_pro))); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length of hardware address = %d bytes", ap->ar_hln); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length of protocol address = %d bytes", ap->ar_pln); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Opcode %d (%s)", arpop, + (arpop > REVARP_REPLY) ? opname[0] : opname[arpop]); + + if (is_ip) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sender's hardware address = %s", smacbuf); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sender's protocol address = %s", + printip(sip)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Target hardware address = %s", + arpop == ARPOP_REQUEST ? "?" : dmacbuf); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Target protocol address = %s", + arpop == REVARP_REQUEST ? "?" : + printip(tip)); + } + show_trailer(); + } + + if (maclen != 0) { + free(smacbuf); + free(dmacbuf); + } + return; + +short_packet: + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "ARP (short packet)"); + } else if (flags & F_DTAIL) { + show_header("ARP: ", "ARP/RARP Frame", alen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "ARP (short packet)"); + } +} + +char * +printip(unsigned char *p) +{ + static char buff[MAXHOSTNAMELEN + 32]; + char *ap, *np; + struct in_addr a; + + memcpy(&a, p, 4); + ap = (char *)inet_ntoa(a); + np = (char *)addrtoname(AF_INET, &a); + (void) snprintf(buff, MAXHOSTNAMELEN, "%s, %s", ap, np); + return (buff); +} + +char * +addrtoname_align(unsigned char *p) +{ + struct in_addr a; + + memcpy(&a, p, 4); + return ((char *)addrtoname(AF_INET, &a)); +} + +/* + * These numbers are assigned by the IANA. See the arp-parameters registry. + * Only those values that are used within Solaris have #defines. + */ +const char * +arp_htype(int t) +{ + switch (t) { + case ARPHRD_ETHER: + return ("Ethernet (10Mb)"); + case 2: + return ("Experimental Ethernet (3MB)"); + case 3: + return ("Amateur Radio AX.25"); + case 4: + return ("Proteon ProNET Token Ring"); + case 5: + return ("Chaos"); + case ARPHRD_IEEE802: + return ("IEEE 802"); + case 7: + return ("ARCNET"); + case 8: + return ("Hyperchannel"); + case 9: + return ("Lanstar"); + case 10: + return ("Autonet"); + case 11: + return ("LocalTalk"); + case 12: + return ("LocalNet"); + case 13: + return ("Ultra Link"); + case 14: + return ("SMDS"); + case ARPHRD_FRAME: + return ("Frame Relay"); + case ARPHRD_ATM: + return ("ATM"); + case ARPHRD_HDLC: + return ("HDLC"); + case ARPHRD_FC: + return ("Fibre Channel"); + case ARPHRD_IPATM: + return ("IP-ATM"); + case ARPHRD_TUNNEL: + return ("Tunnel"); + case ARPHRD_IB: + return ("IPIB"); + }; + return ("UNKNOWN"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_atp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_atp.c new file mode 100644 index 0000000..31808ec --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_atp.c @@ -0,0 +1,128 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +static char *atp_ci(uint8_t); + +static char *atp_trel[8] = { + "30s", + "1m", + "2m", + "4m", + "8m", + "(undef 5)", + "(undef 6)", + "(undef 7)" +}; + +void +interpret_atp(int flags, struct ddp_hdr *ddp, int len) +{ + struct atp_hdr *atp = (struct atp_hdr *)ddp; + int atplen = len - (DDPHDR_SIZE + ATPHDR_SIZE); + + if (flags & F_SUM) { + if (atplen < 0) { + (void) snprintf(get_sum_line(), MAXLINE, + "ATP (short packet)"); + return; + } + (void) snprintf(get_sum_line(), MAXLINE, + "ATP (%s), TID=%d, L=%d", + atp_ci(atp->atp_ctrl), + get_short((uint8_t *)&atp->atp_tid), + len); + } + + if (flags & F_DTAIL) { + show_header("ATP: ", "ATP Header", 8); + show_space(); + + if (atplen < 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "ATP (short packet)"); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length = %d", len); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Ctrl = 0x%x (%s), bitmap/seq = 0x%x", + atp->atp_ctrl, + atp_ci(atp->atp_ctrl), + atp->atp_seq); + (void) snprintf(get_line(0, 0), get_line_remain(), + "TID = %d, user bytes 0x%x 0x%x 0x%x 0x%x", + get_short((uint8_t *)&atp->atp_tid), + atp->atp_user[0], atp->atp_user[1], + atp->atp_user[2], atp->atp_user[3]); + show_space(); + } + + if (ddp->ddp_dest_sock == DDP_TYPE_ZIP || + ddp->ddp_src_sock == DDP_TYPE_ZIP) + interpret_atp_zip(flags, atp, atplen); +} + +static char * +atp_ci(uint8_t ci) +{ + static char buf[50]; + char *p = buf; + char *to = NULL; + char *tail = &buf[sizeof (buf)]; + + switch (atp_fun(ci)) { + case ATP_TREQ: + p += snprintf(p, tail-p, "TReq"); + to = atp_trel[atp_tmo(ci)]; + break; + case ATP_TRESP: + p += snprintf(p, tail-p, "TResp"); + break; + case ATP_TREL: + p += snprintf(p, tail-p, "TRel"); + break; + } + + p += snprintf(p, tail-p, ci & ATP_FLG_XO ? " XO" : " ALO"); + + if (ci & ATP_FLG_EOM) + p += snprintf(p, tail-p, " EOM"); + + if (ci & ATP_FLG_STS) + p += snprintf(p, tail-p, " STS"); + + if (to != NULL) + (void) snprintf(p, tail-p, " %s", to); + return (buf); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bparam.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bparam.c new file mode 100644 index 0000000..5d1be71 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bparam.c @@ -0,0 +1,220 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <string.h> + +#include <netinet/in.h> +#include <rpc/types.h> +#include <rpc/rpc.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpcsvc/bootparam_prot.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static void show_address(char *); +static char *sum_address(void); + +static char *procnames_short[] = { + "Null", /* 0 */ + "WHOAMI?", /* 1 */ + "GETFILE", /* 2 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Who am I?", /* 1 */ + "Get file name", /* 2 */ +}; + +#define MAXPROC 2 + +void +interpret_bparam(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[MAX_PATH_LEN + 1]; + char buff2[MAX_MACHINE_NAME + 1]; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "BPARAM C %s", + procnames_short[proc]); + line += strlen(line); + + switch (proc) { + case BOOTPARAMPROC_WHOAMI: + (void) sprintf(line, " %s", + sum_address()); + break; + case BOOTPARAMPROC_GETFILE: + (void) getxdr_string(buff, + MAX_MACHINE_NAME); + (void) sprintf(line, " %s", + getxdr_string(buff, + MAX_FILEID)); + break; + } + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "BPARAM R %s ", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case BOOTPARAMPROC_WHOAMI: + (void) getxdr_string(buff, + MAX_MACHINE_NAME); + (void) getxdr_string(buff2, + MAX_MACHINE_NAME); + (void) sprintf(line, "%s in %s", + buff, buff2); + break; + case BOOTPARAMPROC_GETFILE: + (void) getxdr_string(buff, + MAX_MACHINE_NAME); + (void) sum_address(); + (void) sprintf(line, "File=%s", + getxdr_string(buff, + MAX_PATH_LEN)); + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("BPARAM: ", "Boot Parameters", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long[proc]); + + if (type == CALL) { + switch (proc) { + case BOOTPARAMPROC_WHOAMI: + show_address("Client address"); + break; + + case BOOTPARAMPROC_GETFILE: + (void) showxdr_string(MAX_MACHINE_NAME, + "Hostname = %s"); + (void) showxdr_string(MAX_FILEID, + "File = %s"); + break; + } + } else { + switch (proc) { + case BOOTPARAMPROC_WHOAMI: + (void) showxdr_string(MAX_MACHINE_NAME, + "Client name = %s"); + (void) showxdr_string(MAX_MACHINE_NAME, + "Domain name = %s"); + show_address("Router addr"); + break; + + case BOOTPARAMPROC_GETFILE: + (void) showxdr_string(MAX_MACHINE_NAME, + "Server name = %s"); + show_address("Server addr"); + (void) showxdr_string(MAX_PATH_LEN, + "Server file = %s"); + break; + } + } + + show_trailer(); + } +} + +static char * +sum_address() +{ + struct in_addr host; + extern char *inet_ntoa(); + int atype; + + atype = getxdr_u_long(); + if (atype != IP_ADDR_TYPE) + return ("?"); + + host.S_un.S_un_b.s_b1 = getxdr_char(); + host.S_un.S_un_b.s_b2 = getxdr_char(); + host.S_un.S_un_b.s_b3 = getxdr_char(); + host.S_un.S_un_b.s_b4 = getxdr_char(); + + return (inet_ntoa(host)); +} + +static void +show_address(label) + char *label; +{ + struct in_addr host; + extern char *inet_ntoa(); + int atype; + + atype = getxdr_u_long(); + if (atype == IP_ADDR_TYPE) { + host.S_un.S_un_b.s_b1 = getxdr_char(); + host.S_un.S_un_b.s_b2 = getxdr_char(); + host.S_un.S_un_b.s_b3 = getxdr_char(); + host.S_un.S_un_b.s_b4 = getxdr_char(); + + (void) sprintf(get_line(0, 0), + "%s = %s (%s)", + label, + inet_ntoa(host), + addrtoname(AF_INET, &host)); + } else { + (void) sprintf(get_line(0, 0), + "Router addr = ? (type not known)"); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bpdu.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bpdu.c new file mode 100644 index 0000000..89aa775 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_bpdu.c @@ -0,0 +1,95 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ethernet.h> + +#include <snoop.h> + +struct conf_bpdu { + uchar_t cb_protid[2]; /* Protocol Identifier */ + uchar_t cb_protvers; /* Protocol Version Identifier */ + uchar_t cb_type; /* BPDU Type */ + uchar_t cb_flags; /* BPDU Flags */ + uchar_t cb_rootid[8]; /* Root Identifier */ + uchar_t cb_rootcost[4]; /* Root Path Cost */ + uchar_t cb_bridgeid[8]; /* Bridge Identifier */ + uchar_t cb_portid[2]; /* Port Identifier */ + uchar_t cb_messageage[2]; /* Message Age */ + uchar_t cb_maxage[2]; /* Max Age */ + uchar_t cb_hello[2]; /* Hello Time */ + uchar_t cb_fwddelay[2]; /* Forward Delay */ +}; + +#define BPDU_TYPE_CONF 0 +#define BPDU_TYPE_RCONF 2 +#define BPDU_TYPE_TCNOTIF 0x80 + +int +interpret_bpdu(int flags, char *data, int dlen) +{ + struct conf_bpdu *cb; + const char *pdutype; + + if (dlen < 4) { + (void) snprintf(get_sum_line(), MAXLINE, + "BPDU (short packet)"); + return (0); + } + + cb = (struct conf_bpdu *)data; + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "Bridge PDU T:%d L:%d", cb->cb_type, dlen); + } + + if (flags & F_DTAIL) { + show_header("Bridge-PDU: ", + "Bridge PDU Frame", dlen); + show_space(); + switch (cb->cb_type) { + case BPDU_TYPE_CONF: + pdutype = "Configuration"; + break; + case BPDU_TYPE_RCONF: + pdutype = "Rapid Configuration"; + break; + case BPDU_TYPE_TCNOTIF: + pdutype = "TC Notification"; + break; + default: + pdutype = "?"; + break; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "PDU type = %d (%s)", cb->cb_type, pdutype); + show_trailer(); + } + return (0); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_capture.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_capture.c new file mode 100644 index 0000000..ab6bc29 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_capture.c @@ -0,0 +1,766 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * Copyright 2012 Milan Jurik. All rights reserved. + */ + +#include <stdio.h> +#include <string.h> +#include <strings.h> +#include <errno.h> +#include <fcntl.h> +#include <setjmp.h> +#include <sys/types.h> +#include <sys/signal.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <sys/pfmod.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <sys/bufmod.h> + +#include <unistd.h> +#include <stropts.h> +#include <stdlib.h> +#include <ctype.h> +#include <values.h> +#include <libdlpi.h> + +#include "snoop.h" + +/* + * Old header format. + * Actually two concatenated structs: nit_bufhdr + nit_head + */ +struct ohdr { + /* nit_bufhdr */ + int o_msglen; + int o_totlen; + /* nit_head */ + struct timeval o_time; + int o_drops; + int o_len; +}; + +static void scan(char *, int, int, int, int, void (*)(), int, int, int); +void convert_to_network(); +void convert_from_network(); +static void convert_old(struct ohdr *); +extern sigjmp_buf jmp_env, ojmp_env; +static char *bufp; /* pointer to read buffer */ + +static int strioctl(int, int, int, int, void *); + +enum { DWA_NONE, DWA_EXISTS, DWA_PLUMBED }; + +typedef struct dlpi_walk_arg { + char dwa_linkname[MAXLINKNAMELEN]; + int dwa_type; /* preference type above */ + int dwa_s4; /* IPv4 socket */ + int dwa_s6; /* IPv6 socket */ +} dlpi_walk_arg_t; + +static boolean_t +select_datalink(const char *linkname, void *arg) +{ + struct lifreq lifr; + dlpi_walk_arg_t *dwap = arg; + int s4 = dwap->dwa_s4; + int s6 = dwap->dwa_s6; + + (void) strlcpy(dwap->dwa_linkname, linkname, MAXLINKNAMELEN); + dwap->dwa_type = DWA_EXISTS; + + /* + * See if it's plumbed by IP. We prefer such links because they're + * more likely to have interesting traffic. + */ + bzero(&lifr, sizeof (lifr)); + (void) strlcpy(lifr.lifr_name, linkname, LIFNAMSIZ); + if ((s4 != -1 && ioctl(s4, SIOCGLIFFLAGS, &lifr) != -1) || + (s6 != -1 && ioctl(s6, SIOCGLIFFLAGS, &lifr) != -1)) { + dwap->dwa_type = DWA_PLUMBED; + return (B_TRUE); + } + return (B_FALSE); +} + +/* + * Open `linkname' in raw/passive mode (see dlpi_open(3DLPI)). If `linkname' + * is NULL, pick a datalink as per snoop(1M). Also gather some information + * about the datalink useful for building the proper packet filters. + */ +boolean_t +open_datalink(dlpi_handle_t *dhp, const char *linkname) +{ + int retval; + int flags = DLPI_PASSIVE | DLPI_RAW; + dlpi_walk_arg_t dwa; + dlpi_info_t dlinfo; + + if (linkname == NULL) { + /* + * Select a datalink to use by default. Prefer datalinks that + * are plumbed by IP. + */ + bzero(&dwa, sizeof (dwa)); + dwa.dwa_s4 = socket(AF_INET, SOCK_DGRAM, 0); + dwa.dwa_s6 = socket(AF_INET6, SOCK_DGRAM, 0); + dlpi_walk(select_datalink, &dwa, 0); + (void) close(dwa.dwa_s4); + (void) close(dwa.dwa_s6); + + if (dwa.dwa_type == DWA_NONE) + pr_err("no datalinks found"); + if (dwa.dwa_type == DWA_EXISTS) { + (void) fprintf(stderr, "snoop: WARNING: " + "no datalinks plumbed for IP traffic\n"); + } + linkname = dwa.dwa_linkname; + } + if (Iflg) + flags |= DLPI_DEVIPNET; + if (Iflg || strcmp(linkname, "lo0") == 0) + flags |= DLPI_IPNETINFO; + if ((retval = dlpi_open(linkname, dhp, flags)) != DLPI_SUCCESS) { + pr_err("cannot open \"%s\": %s", linkname, + dlpi_strerror(retval)); + } + + if ((retval = dlpi_info(*dhp, &dlinfo, 0)) != DLPI_SUCCESS) + pr_errdlpi(*dhp, "dlpi_info failed", retval); + + for (interface = &INTERFACES[0]; interface->mac_type != -1; interface++) + if (interface->mac_type == dlinfo.di_mactype) + break; + + /* allow limited functionality even if interface isn't known */ + if (interface->mac_type == -1) { + (void) fprintf(stderr, "snoop: WARNING: Mac Type = %x " + "not supported\n", dlinfo.di_mactype); + } + + return (interface->try_kernel_filter); +} + +/* + * Initialize `dh' for packet capture using the provided arguments. + */ +void +init_datalink(dlpi_handle_t dh, ulong_t snaplen, ulong_t chunksize, + struct timeval *timeout, struct Pf_ext_packetfilt *fp) +{ + int retv; + int netfd; + + retv = dlpi_bind(dh, DLPI_ANY_SAP, NULL); + if (retv != DLPI_SUCCESS) + pr_errdlpi(dh, "cannot bind on", retv); + + if (Iflg) { + (void) fprintf(stderr, "Using device ipnet/%s ", + dlpi_linkname(dh)); + } else { + (void) fprintf(stderr, "Using device %s ", dlpi_linkname(dh)); + } + + /* + * If Pflg not set - use physical level + * promiscuous mode. Otherwise - just SAP level. + */ + if (!Pflg) { + (void) fprintf(stderr, "(promiscuous mode)\n"); + retv = dlpi_promiscon(dh, DL_PROMISC_PHYS); + if (retv != DLPI_SUCCESS) { + pr_errdlpi(dh, "promiscuous mode(physical) failed", + retv); + } + } else { + (void) fprintf(stderr, "(non promiscuous)\n"); + retv = dlpi_promiscon(dh, DL_PROMISC_MULTI); + if (retv != DLPI_SUCCESS) { + pr_errdlpi(dh, "promiscuous mode(multicast) failed", + retv); + } + } + + retv = dlpi_promiscon(dh, DL_PROMISC_SAP); + if (retv != DLPI_SUCCESS) + pr_errdlpi(dh, "promiscuous mode(SAP) failed", retv); + + netfd = dlpi_fd(dh); + + if (fp) { + /* + * push and configure the packet filtering module + */ + if (ioctl(netfd, I_PUSH, "pfmod") < 0) + pr_errdlpi(dh, "cannot push \"pfmod\"", DL_SYSERR); + + if (strioctl(netfd, PFIOCSETF, -1, sizeof (*fp), + (char *)fp) < 0) + pr_errdlpi(dh, "PFIOCSETF", DL_SYSERR); + } + + if (ioctl(netfd, I_PUSH, "bufmod") < 0) + pr_errdlpi(dh, "cannot push \"bufmod\"", DL_SYSERR); + + if (strioctl(netfd, SBIOCSTIME, -1, sizeof (struct timeval), + (char *)timeout) < 0) + pr_errdlpi(dh, "SBIOCSTIME", DL_SYSERR); + + if (strioctl(netfd, SBIOCSCHUNK, -1, sizeof (uint_t), + (char *)&chunksize) < 0) + pr_errdlpi(dh, "SBIOCGCHUNK", DL_SYSERR); + + if (strioctl(netfd, SBIOCSSNAP, -1, sizeof (uint_t), + (char *)&snaplen) < 0) + pr_errdlpi(dh, "SBIOCSSNAP", DL_SYSERR); + + /* + * Flush the read queue, to get rid of anything that + * accumulated before the device reached its final configuration. + */ + if (ioctl(netfd, I_FLUSH, FLUSHR) < 0) + pr_errdlpi(dh, "cannot flush \"I_FLUSH\"", DL_SYSERR); +} + +/* + * Read packets from the network. init_datalink() is called in + * here to set up the network interface for reading of + * raw ethernet packets in promiscuous mode into a buffer. + * Packets are read and either written directly to a file + * or interpreted for display on the fly. + */ +void +net_read(dlpi_handle_t dh, size_t chunksize, int filter, void (*proc)(), + int flags) +{ + int retval; + extern int count; + size_t msglen; + + count = 0; + + /* allocate a read buffer */ + bufp = malloc(chunksize); + if (bufp == NULL) + pr_err("no memory for %d buffer", chunksize); + + /* + * read frames + */ + for (;;) { + msglen = chunksize; + retval = dlpi_recv(dh, NULL, NULL, bufp, &msglen, -1, NULL); + + if (retval != DLPI_SUCCESS || quitting) + break; + + if (msglen != 0) + scan(bufp, msglen, filter, 0, 0, proc, 0, 0, flags); + } + + free(bufp); + + if (!quitting) + pr_errdlpi(dh, "network read failed", retval); +} + +#ifdef DEBUG +/* + * corrupt: simulate packet corruption for debugging interpreters + */ +void +corrupt(volatile char *pktp, volatile char *pstop, char *buf, + volatile char *bufstop) +{ + int c; + int i; + int p; + int li = rand() % (pstop - pktp - 1) + 1; + volatile char *pp = pktp; + volatile char *pe = bufstop < pstop ? bufstop : pstop; + + if (pktp < buf || pktp > bufstop) + return; + + for (pp = pktp; pp < pe; pp += li) { + c = ((pe - pp) < li ? pe - pp : li); + i = (rand() % c)>>1; + while (--i > 0) { + p = (rand() % c); + pp[p] = (unsigned char)(rand() & 0xFF); + } + } +} +#endif /* DEBUG */ + +static void +scan(char *buf, int len, int filter, int cap, int old, void (*proc)(), + int first, int last, int flags) +{ + volatile char *bp, *bufstop; + volatile struct sb_hdr *hdrp; + volatile struct sb_hdr nhdr, *nhdrp; + volatile char *pktp; + volatile struct timeval last_timestamp; + volatile int header_okay; + extern int count, maxcount; + extern int snoop_nrecover; +#ifdef DEBUG + extern int zflg; +#endif /* DEBUG */ + + proc(0, 0, 0); + bufstop = buf + len; + + /* + * + * Loop through each packet in the buffer + */ + last_timestamp.tv_sec = 0; + (void) memcpy((char *)ojmp_env, (char *)jmp_env, sizeof (jmp_env)); + for (bp = buf; bp < bufstop; bp += nhdrp->sbh_totlen) { + /* + * Gracefully exit if user terminates + */ + if (quitting) + break; + /* + * Global error recocery: Prepare to continue when a corrupt + * packet or header is encountered. + */ + if (sigsetjmp(jmp_env, 1)) { + goto err; + } + + header_okay = 0; + hdrp = (struct sb_hdr *)bp; + nhdrp = hdrp; + pktp = (char *)hdrp + sizeof (*hdrp); + + /* + * If reading a capture file + * convert the headers from network + * byte order (for little-endians like X86) + */ + if (cap) { + /* + * If the packets come from an old + * capture file, convert the header. + */ + if (old) { + convert_old((struct ohdr *)hdrp); + } + + nhdrp = &nhdr; + + nhdrp->sbh_origlen = ntohl(hdrp->sbh_origlen); + nhdrp->sbh_msglen = ntohl(hdrp->sbh_msglen); + nhdrp->sbh_totlen = ntohl(hdrp->sbh_totlen); + nhdrp->sbh_drops = ntohl(hdrp->sbh_drops); + nhdrp->sbh_timestamp.tv_sec = + ntohl(hdrp->sbh_timestamp.tv_sec); + nhdrp->sbh_timestamp.tv_usec = + ntohl(hdrp->sbh_timestamp.tv_usec); + } + + /* Enhanced check for valid header */ + + if ((nhdrp->sbh_totlen == 0) || + (bp + nhdrp->sbh_totlen) < bp || + (bp + nhdrp->sbh_totlen) > bufstop || + (nhdrp->sbh_origlen == 0) || + (bp + nhdrp->sbh_origlen) < bp || + (nhdrp->sbh_msglen == 0) || + (bp + nhdrp->sbh_msglen) < bp || + (bp + nhdrp->sbh_msglen) > bufstop || + (nhdrp->sbh_msglen > nhdrp->sbh_origlen) || + (nhdrp->sbh_totlen < nhdrp->sbh_msglen) || + (nhdrp->sbh_timestamp.tv_sec == 0)) { + if (cap) { + (void) fprintf(stderr, "(warning) bad packet " + "header in capture file"); + } else { + (void) fprintf(stderr, "(warning) bad packet " + "header in buffer"); + } + (void) fprintf(stderr, " offset %d: length=%d\n", + bp - buf, nhdrp->sbh_totlen); + goto err; + } + + /* + * Check for incomplete packet. We are conservative here, + * since we don't know how good the checking is in other + * parts of the code. We pass a partial packet, with + * a warning. + */ + if (pktp + nhdrp->sbh_msglen > bufstop) { + (void) fprintf(stderr, "truncated packet buffer\n"); + nhdrp->sbh_msglen = bufstop - pktp; + } + +#ifdef DEBUG + if (zflg) + corrupt(pktp, pktp + nhdrp->sbh_msglen, buf, bufstop); +#endif /* DEBUG */ + + header_okay = 1; + if (!filter || + want_packet((uchar_t *)pktp, + nhdrp->sbh_msglen, + nhdrp->sbh_origlen)) { + count++; + + /* + * Start deadman timer for interpreter processing + */ + (void) snoop_alarm(SNOOP_ALARM_GRAN*SNOOP_MAXRECOVER, + NULL); + + encap_levels = 0; + if (!cap || count >= first) + proc(nhdrp, pktp, count, flags); + + if (cap && count >= last) { + (void) snoop_alarm(0, NULL); + break; + } + + if (maxcount && count >= maxcount) { + (void) fprintf(stderr, "%d packets captured\n", + count); + exit(0); + } + + snoop_nrecover = 0; /* success */ + (void) snoop_alarm(0, NULL); + last_timestamp = hdrp->sbh_timestamp; /* save stamp */ + } + continue; +err: + /* + * Corruption has been detected. Reset errors. + */ + snoop_recover(); + + /* + * packet header was apparently okay. Continue. + */ + if (header_okay) + continue; + + /* + * Otherwise try to scan forward to the next packet, using + * the last known timestamp if it is available. + */ + nhdrp = &nhdr; + nhdrp->sbh_totlen = 0; + if (last_timestamp.tv_sec == 0) { + bp += sizeof (int); + } else { + for (bp += sizeof (int); bp <= bufstop; + bp += sizeof (int)) { + hdrp = (struct sb_hdr *)bp; + /* An approximate timestamp located */ + if ((hdrp->sbh_timestamp.tv_sec >> 8) == + (last_timestamp.tv_sec >> 8)) + break; + } + } + } + /* reset jmp_env for program exit */ + (void) memcpy((char *)jmp_env, (char *)ojmp_env, sizeof (jmp_env)); + proc(0, -1, 0); +} + +/* + * Called if nwrite() encounters write problems. + */ +static void +cap_write_error(const char *msgtype) +{ + (void) fprintf(stderr, + "snoop: cannot write %s to capture file: %s\n", + msgtype, strerror(errno)); + exit(1); +} + +/* + * Writes target buffer to the open file descriptor. Upon detection of a short + * write, an attempt to process the remaining bytes occurs until all anticipated + * bytes are written. An error status is returned to indicate any serious write + * failures. + */ +static int +nwrite(int fd, const void *buffer, size_t buflen) +{ + size_t nwritten; + ssize_t nbytes = 0; + const char *buf = buffer; + + for (nwritten = 0; nwritten < buflen; nwritten += nbytes) { + nbytes = write(fd, &buf[nwritten], buflen - nwritten); + if (nbytes == -1) + return (-1); + if (nbytes == 0) { + errno = EIO; + return (-1); + } + } + return (0); +} + +/* + * Routines for opening, closing, reading and writing + * a capture file of packets saved with the -o option. + */ +static int capfile_out; + +/* + * The snoop capture file has a header to identify + * it as a capture file and record its version. + * A file without this header is assumed to be an + * old format snoop file. + * + * A version 1 header looks like this: + * + * 0 1 2 3 4 5 6 7 8 9 10 11 + * +---+---+---+---+---+---+---+---+---+---+---+---+---+ + * | s | n | o | o | p | \0| \0| \0| version | data + * +---+---+---+---+---+---+---+---+---+---+---+---+---+ + * | word 0 | word 1 | word 2 | + * + * + * A version 2 header adds a word that identifies the MAC type. + * This allows for capture files from FDDI etc. + * + * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 + * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ + * | s | n | o | o | p | \0| \0| \0| version | MAC type | data + * +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ + * | word 0 | word 1 | word 2 | word 3 + * + */ +static const char *snoop_id = "snoop\0\0\0"; +static const int snoop_idlen = 8; +static const int snoop_version = 2; + +void +cap_open_write(const char *name) +{ + int vers; + + capfile_out = open(name, O_CREAT | O_TRUNC | O_RDWR, 0666); + if (capfile_out < 0) + pr_err("%s: %m", name); + + vers = htonl(snoop_version); + if (nwrite(capfile_out, snoop_id, snoop_idlen) == -1) + cap_write_error("snoop_id"); + + if (nwrite(capfile_out, &vers, sizeof (int)) == -1) + cap_write_error("version"); +} + + +void +cap_close(void) +{ + (void) close(capfile_out); +} + +static char *cap_buffp = NULL; +static int cap_len = 0; +static int cap_new; + +void +cap_open_read(const char *name) +{ + struct stat st; + int cap_vers; + int *word; + int device_mac_type = -1; + int capfile_in; + + capfile_in = open(name, O_RDONLY); + if (capfile_in < 0) + pr_err("couldn't open %s: %m", name); + + if (fstat(capfile_in, &st) < 0) + pr_err("couldn't stat %s: %m", name); + cap_len = st.st_size; + + cap_buffp = mmap(0, cap_len, PROT_READ, MAP_PRIVATE, capfile_in, 0); + (void) close(capfile_in); + if ((int)cap_buffp == -1) + pr_err("couldn't mmap %s: %m", name); + + /* Check if new snoop capture file format */ + + cap_new = bcmp(cap_buffp, snoop_id, snoop_idlen) == 0; + + /* + * If new file - check version and + * set buffer pointer to point at first packet + */ + if (cap_new) { + cap_vers = ntohl(*(int *)(cap_buffp + snoop_idlen)); + cap_buffp += snoop_idlen + sizeof (int); + cap_len -= snoop_idlen + sizeof (int); + + switch (cap_vers) { + case 1: + device_mac_type = DL_ETHER; + break; + + case 2: + device_mac_type = ntohl(*((int *)cap_buffp)); + cap_buffp += sizeof (int); + cap_len -= sizeof (int); + break; + + default: + pr_err("capture file: %s: Version %d unrecognized\n", + name, cap_vers); + } + + for (interface = &INTERFACES[0]; interface->mac_type != -1; + interface++) + if (interface->mac_type == device_mac_type) + break; + + if (interface->mac_type == -1) + pr_err("Mac Type = %x is not supported\n", + device_mac_type); + } else { + /* Use heuristic to check if it's an old-style file */ + + device_mac_type = DL_ETHER; + word = (int *)cap_buffp; + + if (!((word[0] < 1600 && word[1] < 1600) && + (word[0] < word[1]) && + (word[2] > 610000000 && word[2] < 770000000))) + pr_err("not a capture file: %s", name); + + /* Change protection so's we can fix the headers */ + + if (mprotect(cap_buffp, cap_len, PROT_READ | PROT_WRITE) < 0) + pr_err("mprotect: %s: %m", name); + } +} + +void +cap_read(int first, int last, int filter, void (*proc)(), int flags) +{ + extern int count; + + count = 0; + + scan(cap_buffp, cap_len, filter, 1, !cap_new, proc, first, last, flags); + + (void) munmap(cap_buffp, cap_len); +} + +/* ARGSUSED */ +void +cap_write(struct sb_hdr *hdrp, char *pktp, int num, int flags) +{ + int pktlen, mac; + static int first = 1; + struct sb_hdr nhdr; + extern boolean_t qflg; + + if (hdrp == NULL) + return; + + if (first) { + first = 0; + mac = htonl(interface->mac_type); + if (nwrite(capfile_out, &mac, sizeof (int)) == -1) + cap_write_error("mac_type"); + } + + pktlen = hdrp->sbh_totlen - sizeof (*hdrp); + + /* + * Convert sb_hdr to network byte order + */ + nhdr.sbh_origlen = htonl(hdrp->sbh_origlen); + nhdr.sbh_msglen = htonl(hdrp->sbh_msglen); + nhdr.sbh_totlen = htonl(hdrp->sbh_totlen); + nhdr.sbh_drops = htonl(hdrp->sbh_drops); + nhdr.sbh_timestamp.tv_sec = htonl(hdrp->sbh_timestamp.tv_sec); + nhdr.sbh_timestamp.tv_usec = htonl(hdrp->sbh_timestamp.tv_usec); + + if (nwrite(capfile_out, &nhdr, sizeof (nhdr)) == -1) + cap_write_error("packet header"); + + if (nwrite(capfile_out, pktp, pktlen) == -1) + cap_write_error("packet"); + + if (! qflg) + show_count(); +} + +/* + * Convert a packet header from + * old to new format. + */ +static void +convert_old(struct ohdr *ohdrp) +{ + struct sb_hdr nhdr; + + nhdr.sbh_origlen = ohdrp->o_len; + nhdr.sbh_msglen = ohdrp->o_msglen; + nhdr.sbh_totlen = ohdrp->o_totlen; + nhdr.sbh_drops = ohdrp->o_drops; + nhdr.sbh_timestamp = ohdrp->o_time; + + *(struct sb_hdr *)ohdrp = nhdr; +} + +static int +strioctl(int fd, int cmd, int timout, int len, void *dp) +{ + struct strioctl sioc; + int rc; + + sioc.ic_cmd = cmd; + sioc.ic_timout = timout; + sioc.ic_len = len; + sioc.ic_dp = dp; + rc = ioctl(fd, I_STR, &sioc); + + if (rc < 0) + return (rc); + else + return (sioc.ic_len); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcp.c new file mode 100644 index 0000000..7857da7 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcp.c @@ -0,0 +1,746 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysmacros.h> +#include <netinet/in.h> +#include <netinet/dhcp.h> +#include <arpa/inet.h> +#include <dhcp_inittab.h> +#include <dhcp_symbol.h> +#include "snoop.h" + +static const char *show_msgtype(unsigned char); +static int show_options(unsigned char *, int); +static void display_ip(int, char *, char *, unsigned char **); +static void display_ascii(char *, char *, unsigned char **); +static void display_number(char *, char *, unsigned char **); +static void display_ascii_hex(char *, unsigned char **); +static unsigned char bootmagic[] = BOOTMAGIC; /* rfc 1048 */ + +static char *option_types[] = { +"", /* 0 */ +"Subnet Mask", /* 1 */ +"UTC Time Offset", /* 2 */ +"Router", /* 3 */ +"RFC868 Time Servers", /* 4 */ +"IEN 116 Name Servers", /* 5 */ +"DNS Servers", /* 6 */ +"UDP LOG Servers", /* 7 */ +"RFC 865 Cookie Servers", /* 8 */ +"RFC 1179 Line Printer Servers (LPR)", /* 9 */ +"Impress Servers", /* 10 */ +"RFC 887 Resource Location Servers", /* 11 */ +"Client Hostname", /* 12 */ +"Boot File size in 512 byte Blocks", /* 13 */ +"Merit Dump File", /* 14 */ +"DNS Domain Name", /* 15 */ +"SWAP Server", /* 16 */ +"Client Root Path", /* 17 */ +"BOOTP options extensions path", /* 18 */ +"IP Forwarding Flag", /* 19 */ +"NonLocal Source Routing Flag", /* 20 */ +"Policy Filters for NonLocal Routing", /* 21 */ +"Maximum Datagram Reassembly Size", /* 22 */ +"Default IP Time To Live", /* 23 */ +"Path MTU Aging Timeout", /* 24 */ +"Path MTU Size Plateau Table", /* 25 */ +"Interface MTU Size", /* 26 */ +"All Subnets are Local Flag", /* 27 */ +"Broadcast Address", /* 28 */ +"Perform Mask Discovery Flag", /* 29 */ +"Mask Supplier Flag", /* 30 */ +"Perform Router Discovery Flag", /* 31 */ +"Router Solicitation Address", /* 32 */ +"Static Routes", /* 33 */ +"Trailer Encapsulation Flag", /* 34 */ +"ARP Cache Timeout Seconds", /* 35 */ +"Ethernet Encapsulation Flag", /* 36 */ +"TCP Default Time To Live", /* 37 */ +"TCP Keepalive Interval Seconds", /* 38 */ +"TCP Keepalive Garbage Flag", /* 39 */ +"NIS Domainname", /* 40 */ +"NIS Servers", /* 41 */ +"Network Time Protocol Servers", /* 42 */ +"Vendor Specific Options", /* 43 */ +"NetBIOS RFC 1001/1002 Name Servers", /* 44 */ +"NetBIOS Datagram Dist. Servers", /* 45 */ +"NetBIOS Node Type", /* 46 */ +"NetBIOS Scope", /* 47 */ +"X Window Font Servers", /* 48 */ +"X Window Display Manager Servers", /* 49 */ +"Requested IP Address", /* 50 */ +"IP Address Lease Time", /* 51 */ +"Option Field Overload Flag", /* 52 */ +"DHCP Message Type", /* 53 */ +"DHCP Server Identifier", /* 54 */ +"Option Request List", /* 55 */ +"Error Message", /* 56 */ +"Maximum DHCP Message Size", /* 57 */ +"Renewal (T1) Time Value", /* 58 */ +"Rebinding (T2) Time Value", /* 59 */ +"Client Class Identifier =", /* 60 */ +"Client Identifier =", /* 61 */ +"Netware IP Domain =", /* 62 */ +"Netware IP Options =", /* 63 */ +"TFTP Server Name", /* 66 */ +"Option BootFile Name", /* 67 */ +"Mobile IP Agents", /* 68 */ +"Simple Mail (SMTP) Servers", /* 69 */ +"Post Office (POP3) Servers", /* 70 */ +"Net News (NNTP) Servers", /* 71 */ +"WorldWideWeb Servers", /* 72 */ +"Finger Servers", /* 73 */ +"Internet Relay Chat (IRC) Servers", /* 74 */ +"StreetTalk Servers", /* 75 */ +"StreetTalk Directory Assist. Servers", /* 76 */ +"User Class Identifier", /* 77 */ +}; + +#define OPTIONS_ARRAY_SIZE 78 + +int +interpret_dhcp(int flags, struct dhcp *dp, int len) +{ + if (flags & F_SUM) { + if ((memcmp(dp->cookie, bootmagic, sizeof (bootmagic)) == 0) && + (len >= BASE_PKT_SIZE + 3) && + dp->options[0] == CD_DHCP_TYPE) { + (void) sprintf(get_sum_line(), + "DHCP/BOOTP %s", show_msgtype(dp->options[2])); + } else { + switch (ntohs(dp->op)) { + case BOOTREQUEST: + (void) sprintf(get_sum_line(), + "DHCP/BOOTP BOOTREQUEST"); + break; + case BOOTREPLY: + (void) sprintf(get_sum_line(), + "DHCP/BOOTP BOOTREPLY"); + break; + } + } + } + if (flags & F_DTAIL) { + show_header("DHCP: ", "Dynamic Host Configuration Protocol", + len); + show_space(); + (void) sprintf(get_line((char *)(uintptr_t)dp->htype - + dlc_header, 1), + "Hardware address type (htype) = %d (%s)", dp->htype, + arp_htype(dp->htype)); + (void) sprintf(get_line((char *)(uintptr_t)dp->hlen - + dlc_header, 1), + "Hardware address length (hlen) = %d octets", dp->hlen); + (void) sprintf(get_line((char *)(uintptr_t)dp->hops - + dlc_header, 1), + "Relay agent hops = %d", dp->hops); + (void) sprintf(get_line((char *)(uintptr_t)dp->xid - + dlc_header, 4), + "Transaction ID = 0x%x", ntohl(dp->xid)); + (void) sprintf(get_line((char *)(uintptr_t)dp->secs - + dlc_header, 2), + "Time since boot = %d seconds", ntohs(dp->secs)); + (void) sprintf(get_line((char *)(uintptr_t)dp->flags - + dlc_header, 2), + "Flags = 0x%.4x", ntohs(dp->flags)); + (void) sprintf(get_line((char *)&dp->ciaddr - dlc_header, 4), + "Client address (ciaddr) = %s", inet_ntoa(dp->ciaddr)); + (void) sprintf(get_line((char *)&dp->yiaddr - dlc_header, 4), + "Your client address (yiaddr) = %s", + inet_ntoa(dp->yiaddr)); + (void) sprintf(get_line((char *)&dp->siaddr - dlc_header, 4), + "Next server address (siaddr) = %s", + inet_ntoa(dp->siaddr)); + (void) sprintf(get_line((char *)&dp->giaddr - dlc_header, 4), + "Relay agent address (giaddr) = %s", + inet_ntoa(dp->giaddr)); + if (dp->htype == 1) { + (void) sprintf(get_line((char *)dp->chaddr - + dlc_header, dp->hlen), + "Client hardware address (chaddr) = %.2X:%.2X:%.2X:%.2X:%.2X:%.2X", + dp->chaddr[0], + dp->chaddr[1], + dp->chaddr[2], + dp->chaddr[3], + dp->chaddr[4], + dp->chaddr[5]); + } + /* + * Check cookie, process options + */ + if (memcmp(dp->cookie, bootmagic, sizeof (bootmagic)) != 0) { + (void) sprintf(get_line(0, 0), + "Unrecognized cookie: 0x%.2X%.2X%.2X%.2X\n", + dp->cookie[0], + dp->cookie[1], + dp->cookie[2], + dp->cookie[3]); + return (0); + } + show_space(); + show_header("DHCP: ", "(Options) field options", len); + show_space(); + switch (show_options(dp->options, (len - BASE_PKT_SIZE))) { + case 0: + /* No option overloading */ + if (*(unsigned char *)(dp->sname) != '\0') { + (void) sprintf(get_line(0, 0), + "Server Name = %s", dp->sname); + } + if (*(unsigned char *)(dp->file) != '\0') { + (void) sprintf(get_line(0, 0), + "Boot File Name = %s", dp->file); + } + break; + case 1: + /* file field used */ + if (*(unsigned char *)(dp->sname) != '\0') { + (void) sprintf(get_line(0, 0), + "Server Name = %s", dp->sname); + } + show_space(); + show_header("DHCP: ", "(File) field options", len); + show_space(); + (void) show_options(dp->file, 128); + break; + case 2: + /* sname field used for options */ + if (*(unsigned char *)(dp->file) != '\0') { + (void) sprintf(get_line(0, 0), + "Boot File Name = %s", dp->file); + } + show_space(); + show_header("DHCP: ", "(Sname) field options", len); + show_space(); + (void) show_options(dp->sname, 64); + break; + case 3: + show_space(); + show_header("DHCP: ", "(File) field options", len); + show_space(); + (void) show_options(dp->file, 128); + show_space(); + show_header("DHCP: ", "(Sname) field options", len); + show_space(); + (void) show_options(dp->sname, 64); + break; + }; + } + return (len); +} + +static int +show_options(unsigned char *cp, int len) +{ + char *prmpt; + unsigned char *end, *vend; + unsigned char *start, save; + int items, i; + int nooverload = 0; + ushort_t s_buf; + struct in_addr tmp; + char scratch[128]; + dhcp_symbol_t *entry; + char *decoded_opt; + int opt_len; + + start = cp; + end = (unsigned char *)cp + len; + + while (start < end) { + if (*start == CD_PAD) { + start++; + continue; + } + if (*start == CD_END) + break; /* done */ + + save = *start++; + switch (save) { + /* Network order IP address(es) */ + case CD_SUBNETMASK: + case CD_ROUTER_SOLICIT_SERV: + case CD_BROADCASTADDR: + case CD_REQUESTED_IP_ADDR: + case CD_SERVER_ID: + /* Single IP address */ + if (*start != 4) { + (void) sprintf(get_line(0, 0), + "Error: Bad %s", option_types[save]); + } else { + start++; + display_ip(1, "%s = %s", option_types[save], + &start); + } + break; + case CD_ROUTER: + case CD_TIMESERV: + case CD_IEN116_NAME_SERV: + case CD_DNSSERV: + case CD_LOG_SERV: + case CD_COOKIE_SERV: + case CD_LPR_SERV: + case CD_IMPRESS_SERV: + case CD_RESOURCE_SERV: + case CD_SWAP_SERV: + case CD_NIS_SERV: + case CD_NTP_SERV: + case CD_NETBIOS_NAME_SERV: + case CD_NETBIOS_DIST_SERV: + case CD_XWIN_FONT_SERV: + case CD_XWIN_DISP_SERV: + case CD_MOBILE_IP_AGENT: + case CD_SMTP_SERVS: + case CD_POP3_SERVS: + case CD_NNTP_SERVS: + case CD_WWW_SERVS: + case CD_FINGER_SERVS: + case CD_IRC_SERVS: + case CD_STREETTALK_SERVS: + case CD_STREETTALK_DA_SERVS: + /* Multiple IP addresses */ + if ((*start % 4) != 0) { + (void) sprintf(get_line(0, 0), + "Error: Bad %s address", + option_types[save]); + } else { + items = *start++ / 4; + display_ip(items, "%s at = %s", + option_types[save], &start); + } + break; + case CD_TFTP_SERV_NAME: + case CD_HOSTNAME: + case CD_DUMP_FILE: + case CD_DNSDOMAIN: + case CD_ROOT_PATH: + case CD_NIS_DOMAIN: + case CD_NETBIOS_SCOPE: + case CD_MESSAGE: + case CD_OPT_BOOTFILE_NAME: + case CD_USER_CLASS_ID: + /* Ascii strings */ + display_ascii("%s = %s", option_types[save], &start); + break; + case CD_TIMEOFFSET: + case CD_IPTTL: + case CD_PATH_MTU_TIMEOUT: + case CD_ARP_TIMEOUT: + case CD_TCP_TTL: + case CD_TCP_KALIVE_INTVL: + case CD_T1_TIME: + case CD_T2_TIME: + case CD_LEASE_TIME: + /* Number: seconds */ + display_number("%s = %d seconds", option_types[save], + &start); + break; + case CD_IP_FORWARDING_ON: + case CD_NON_LCL_ROUTE_ON: + case CD_ALL_SUBNETS_LCL_ON: + case CD_MASK_DISCVRY_ON: + case CD_MASK_SUPPLIER_ON: + case CD_ROUTER_DISCVRY_ON: + case CD_TRAILER_ENCAPS_ON: + case CD_ETHERNET_ENCAPS_ON: + case CD_TCP_KALIVE_GRBG_ON: + /* Number: hex flag */ + display_number("%s flag = 0x%x", option_types[save], + &start); + break; + case CD_MAXIPSIZE: + case CD_MTU: + case CD_MAX_DHCP_SIZE: + /* Number: bytes */ + display_number("%s = %d bytes", option_types[save], + &start); + break; + case CD_CLASS_ID: + case CD_CLIENT_ID: + case CD_NW_IP_DOMAIN: + case CD_NW_IP_OPTIONS: + /* Hex ascii strings */ + display_ascii_hex(option_types[save], &start); + break; + case CD_BOOT_SIZE: + display_number("%s = %d 512 byte blocks", + "Boot file size", &start); + break; + case CD_POLICY_FILTER: + if ((*start % 8) != 0) { + (void) sprintf(get_line(0, 0), + "Error: Bad Policy Filter option"); + } else { + items = *start++ / 8; + for (i = 0; i < items; i++) { + display_ip(1, + "%s = %s", + "Policy Destination", + &start); + display_ip(1, "%s = %s", "Mask", + &start); + } + } + break; + case CD_PATH_MTU_TABLE_SZ: + if (*start % 2 != 0) { + (void) sprintf(get_line(0, 0), + "Error: Bad Path MTU Table"); + } else { + (void) sprintf(get_line(0, 0), + "\tPath MTU Plateau Table:"); + (void) sprintf(get_line(0, 0), + "\t======================="); + items = *start / sizeof (ushort_t); + ++start; + for (i = 0; i < items; i++) { + if (IS_P2ALIGNED(start, + sizeof (ushort_t))) { + /* LINTED: improper alignment */ + s_buf = *(ushort_t *)start; + } else { + memcpy((char *)&s_buf, + start, sizeof (short)); + } + (void) sprintf(get_line(0, 0), + "\t\tEntry %d:\t\t%d", i, + ntohs(s_buf)); + start += sizeof (ushort_t); + } + } + break; + case CD_STATIC_ROUTE: + if ((*start % 8) != 0) { + (void) sprintf(get_line(0, 0), + "Error: Bad Static Route option: %d", + *start); + } else { + items = *start++ / 8; + for (i = 0; i < items; i++) { + memcpy((char *)&tmp, start, + sizeof (struct in_addr)); + (void) strcpy(scratch, inet_ntoa(tmp)); + start += sizeof (ulong_t); + memcpy((char *)&tmp, start, + sizeof (struct in_addr)); + (void) sprintf(get_line(0, 0), + "Static route from %s to %s", + scratch, inet_ntoa(tmp)); + start += sizeof (ulong_t); + } + } + break; + case CD_VENDOR_SPEC: + i = *start++; + (void) sprintf(get_line(0, 0), + "Vendor-specific Options (%d total octets):", i); + /* + * We don't know what these things are, so just + * display the option number, length, and value + * (hex). + */ + vend = (uchar_t *)((uchar_t *)start + i); + while (start < vend && *start != CD_END) { + if (*start == CD_PAD) { + start++; + continue; + } + (void) sprintf(scratch, + "\t(%.2d) %.2d octets", *start, + *(uchar_t *)((uchar_t *)start + 1)); + start++; + display_ascii_hex(scratch, &start); + } + start = vend; /* in case CD_END found */ + break; + case CD_NETBIOS_NODE_TYPE: + if (*start != 1) { + (void) sprintf(get_line(0, 0), + "Error: Bad '%s' parameter", + option_types[CD_NETBIOS_NODE_TYPE]); + } else { + char *type; + start++; + switch (*start) { + case 0x1: + type = "Broadcast Node"; + break; + case 0x2: + type = "Point To Point Node"; + break; + case 0x4: + type = "Mixed Mode Node"; + break; + case 0x8: + type = "Hybrid Node"; + break; + default: + type = "??? Node"; + break; + }; + (void) sprintf(get_line(0, 0), + "%s = %s (%d)", + option_types[CD_NETBIOS_NODE_TYPE], + type, *start); + start++; + } + break; + case CD_OPTION_OVERLOAD: + if (*start != 1) { + (void) sprintf(get_line(0, 0), + "Bad Option Overload value."); + } else { + start++; + nooverload = *start++; + } + break; + case CD_DHCP_TYPE: + if (*start < 1 || *start > 7) { + (void) sprintf(get_line(0, 0), + "Bad DHCP Message Type."); + } else { + start++; + (void) sprintf(get_line(0, 0), + "Message type = %s", + show_msgtype(*start)); + start++; + } + break; + case CD_REQUEST_LIST: + opt_len = *start++; + (void) sprintf(get_line(0, 0), + "Requested Options:"); + for (i = 0; i < opt_len; i++) { + entry = NULL; + if (*start < OPTIONS_ARRAY_SIZE) { + prmpt = option_types[*start]; + } else { + entry = inittab_getbycode( + ITAB_CAT_STANDARD|ITAB_CAT_SITE, + ITAB_CONS_SNOOP, *start); + if (entry == NULL) { + if (*start >= DHCP_SITE_OPT && + *start <= DHCP_END_SITE) { + prmpt = "Site Option"; + } else { + prmpt = "Unrecognized " + "Option"; + } + } else { + prmpt = entry->ds_name; + } + } + (void) sprintf(get_line(0, 0), + "\t%2d (%s)", *start, prmpt); + start++; + free(entry); + } + break; + default: + opt_len = *start++; + entry = inittab_getbycode( + ITAB_CAT_STANDARD|ITAB_CAT_SITE, + ITAB_CONS_SNOOP, save); + if (entry == NULL) { + if (save >= DHCP_SITE_OPT && + save <= DHCP_END_SITE) + prmpt = "Site"; + else + prmpt = "Unrecognized"; + decoded_opt = NULL; + } else { + if (save < OPTIONS_ARRAY_SIZE) { + prmpt = option_types[save]; + } else { + prmpt = entry->ds_name; + } + decoded_opt = inittab_decode(entry, start, + opt_len, B_TRUE); + } + if (decoded_opt == NULL) { + (void) sprintf(get_line(0, 0), + "%s Option = %d, length = %d octets", + prmpt, save, opt_len); + start--; + display_ascii_hex("\tValue =", &start); + } else { + (void) sprintf(get_line(0, 0), "%s = %s", prmpt, + decoded_opt); + start += opt_len; + free(decoded_opt); + } + free(entry); + break; + }; + } + return (nooverload); +} + +static const char * +show_msgtype(unsigned char type) +{ + /* + * note: the ordering here allows direct indexing of the table + * based on the RFC2131 packet type value passed in. + */ + + static const char *types[] = { + "BOOTP", + "DHCPDISCOVER", "DHCPOFFER", "DHCPREQUEST", "DHCPDECLINE", + "DHCPACK", "DHCPNAK", "DHCPRELEASE", "DHCPINFORM" + }; + + if (type >= (sizeof (types) / sizeof (*types)) || types[type] == NULL) + return ("UNKNOWN"); + + return (types[type]); +} + +static void +display_ip(int items, char *fmt, char *msg, unsigned char **opt) +{ + struct in_addr tmp; + int i; + + for (i = 0; i < items; i++) { + memcpy((char *)&tmp, *opt, sizeof (struct in_addr)); + (void) sprintf(get_line(0, 0), fmt, msg, inet_ntoa(tmp)); + *opt += 4; + } +} + +static void +display_ascii(char *fmt, char *msg, unsigned char **opt) +{ + static unsigned char buf[256]; + int len = **opt; + unsigned char slen = len; + + if (len >= sizeof (buf)) + len = sizeof (buf) - 1; + (*opt)++; + memcpy(buf, *opt, len); + *(unsigned char *)(buf + len) = '\0'; + (void) sprintf(get_line(0, 0), fmt, msg, buf); + (*opt) += slen; +} + +static void +display_number(char *fmt, char *msg, unsigned char **opt) +{ + int len = **opt; + unsigned long l_buf = 0; + unsigned short s_buf = 0; + + if (len > 4) { + (*opt)++; + (void) sprintf(get_line(0, 0), fmt, msg, 0xdeadbeef); + return; + } + switch (len) { + case sizeof (uchar_t): + (*opt)++; + (void) sprintf(get_line(0, 0), fmt, msg, **opt); + break; + case sizeof (ushort_t): + (*opt)++; + if (IS_P2ALIGNED(*opt, sizeof (ushort_t))) + /* LINTED: improper alignment */ + s_buf = *(unsigned short *)*opt; + else + memcpy((char *)&s_buf, *opt, len); + (void) sprintf(get_line(0, 0), fmt, msg, ntohs(s_buf)); + break; + case sizeof (ulong_t): + (*opt)++; + if (IS_P2ALIGNED(*opt, sizeof (ulong_t))) + /* LINTED: improper alignment */ + l_buf = *(unsigned long *)*opt; + else + memcpy((char *)&l_buf, *opt, len); + (void) sprintf(get_line(0, 0), fmt, msg, ntohl(l_buf)); + break; + } + (*opt) += len; +} + +static void +display_ascii_hex(char *msg, unsigned char **opt) +{ + int printable; + char buffer[512]; + char *line, *tmp, *ap, *fmt; + int i, len = **opt; + + line = get_line(0, 0); + + (*opt)++; + + if (len >= 255) { + (void) sprintf(line, "\t%s <TOO LONG>", msg); + return; + } + + for (printable = 1, tmp = (char *)(*opt), ap = buffer; + tmp < (char *)&((*opt)[len]); tmp++) { + if (isprint(*tmp)) + *ap++ = *tmp; + else { + *ap++ = '.'; + printable = 0; + } + } + *ap = '\0'; + + if (!printable) { + for (tmp = (char *)(*opt), ap = buffer; + (tmp < (char *)&((*opt)[len])) && ((ap + 5) < &buffer[512]); + tmp++) { + ap += sprintf(ap, "0x%02X ", *(uchar_t *)(tmp)); + } + /* Truncate the trailing space */ + *(--ap) = '\0'; + /* More bytes to print in hex but no space in buffer */ + if (tmp < (char *)&((*opt)[len])) { + i = ap - buffer; + buffer[i - 1] = '.'; + buffer[i - 2] = '.'; + buffer[i - 3] = '.'; + } + fmt = "%s\t%s (unprintable)"; + } else { + fmt = "%s\t\"%s\""; + } + (*opt) += len; + (void) sprintf(line, fmt, msg, buffer); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcpv6.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcpv6.c new file mode 100644 index 0000000..0e7c1be --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dhcpv6.c @@ -0,0 +1,1051 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +/* + * Dynamic Host Configuration Protocol version 6, for IPv6. Supports + * RFCs 3315, 3319, 3646, 3898, 4075, 4242, 4280, 4580, 4649, and 4704. + */ + +#include <ctype.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <netinet/dhcp6.h> +#include <arpa/inet.h> +#include <dhcp_impl.h> +#include <dhcp_inittab.h> + +#include "snoop.h" + +static const char *mtype_to_str(uint8_t); +static const char *option_to_str(uint8_t); +static const char *duidtype_to_str(uint16_t); +static const char *status_to_str(uint16_t); +static const char *entr_to_str(uint32_t); +static const char *reconf_to_str(uint8_t); +static const char *authproto_to_str(uint8_t); +static const char *authalg_to_str(uint8_t, uint8_t); +static const char *authrdm_to_str(uint8_t); +static const char *cwhat_to_str(uint8_t); +static const char *catype_to_str(uint8_t); +static void show_hex(const uint8_t *, int, const char *); +static void show_ascii(const uint8_t *, int, const char *); +static void show_address(const char *, const void *); +static void show_options(const uint8_t *, int); + +int +interpret_dhcpv6(int flags, const uint8_t *data, int len) +{ + int olen = len; + char *line, *lstart; + dhcpv6_relay_t d6r; + dhcpv6_message_t d6m; + uint_t optlen; + uint16_t statuscode; + + if (len <= 0) { + (void) strlcpy(get_sum_line(), "DHCPv6?", MAXLINE); + return (0); + } + if (flags & F_SUM) { + uint_t ias; + dhcpv6_option_t *d6o; + in6_addr_t link, peer; + char linkstr[INET6_ADDRSTRLEN]; + char peerstr[INET6_ADDRSTRLEN]; + + line = lstart = get_sum_line(); + line += snprintf(line, MAXLINE, "DHCPv6 %s", + mtype_to_str(data[0])); + if (data[0] == DHCPV6_MSG_RELAY_FORW || + data[0] == DHCPV6_MSG_RELAY_REPL) { + if (len < sizeof (d6r)) { + (void) strlcpy(line, "?", + MAXLINE - (line - lstart)); + return (olen); + } + /* Not much in DHCPv6 is aligned. */ + (void) memcpy(&d6r, data, sizeof (d6r)); + (void) memcpy(&link, d6r.d6r_linkaddr, sizeof (link)); + (void) memcpy(&peer, d6r.d6r_peeraddr, sizeof (peer)); + line += snprintf(line, MAXLINE - (line - lstart), + " HC=%d link=%s peer=%s", d6r.d6r_hop_count, + inet_ntop(AF_INET6, &link, linkstr, + sizeof (linkstr)), + inet_ntop(AF_INET6, &peer, peerstr, + sizeof (peerstr))); + data += sizeof (d6r); + len -= sizeof (d6r); + } else { + if (len < sizeof (d6m)) { + (void) strlcpy(line, "?", + MAXLINE - (line - lstart)); + return (olen); + } + (void) memcpy(&d6m, data, sizeof (d6m)); + line += snprintf(line, MAXLINE - (line - lstart), + " xid=%x", DHCPV6_GET_TRANSID(&d6m)); + data += sizeof (d6m); + len -= sizeof (d6m); + } + ias = 0; + d6o = NULL; + while ((d6o = dhcpv6_find_option(data, len, d6o, + DHCPV6_OPT_IA_NA, NULL)) != NULL) + ias++; + if (ias > 0) + line += snprintf(line, MAXLINE - (line - lstart), + " IAs=%u", ias); + d6o = dhcpv6_find_option(data, len, NULL, + DHCPV6_OPT_STATUS_CODE, &optlen); + optlen -= sizeof (*d6o); + if (d6o != NULL && optlen >= sizeof (statuscode)) { + (void) memcpy(&statuscode, d6o + 1, + sizeof (statuscode)); + line += snprintf(line, MAXLINE - (line - lstart), + " status=%u", ntohs(statuscode)); + optlen -= sizeof (statuscode); + if (optlen > 0) { + line += snprintf(line, + MAXLINE - (line - lstart), " \"%.*s\"", + optlen, (char *)(d6o + 1) + 2); + } + } + d6o = dhcpv6_find_option(data, len, NULL, + DHCPV6_OPT_RELAY_MSG, &optlen); + optlen -= sizeof (*d6o); + if (d6o != NULL && optlen >= 1) { + line += snprintf(line, MAXLINE - (line - lstart), + " relay=%s", mtype_to_str(*(uint8_t *)(d6o + 1))); + } + } else if (flags & F_DTAIL) { + show_header("DHCPv6: ", + "Dynamic Host Configuration Protocol Version 6", len); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Message type (msg-type) = %u (%s)", data[0], + mtype_to_str(data[0])); + if (data[0] == DHCPV6_MSG_RELAY_FORW || + data[0] == DHCPV6_MSG_RELAY_REPL) { + if (len < sizeof (d6r)) { + (void) strlcpy(get_line(0, 0), "Truncated", + get_line_remain()); + return (olen); + } + (void) memcpy(&d6r, data, sizeof (d6r)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hop count = %u", d6r.d6r_hop_count); + show_address("Link address", d6r.d6r_linkaddr); + show_address("Peer address", d6r.d6r_peeraddr); + data += sizeof (d6r); + len -= sizeof (d6r); + } else { + if (len < sizeof (d6m)) { + (void) strlcpy(get_line(0, 0), "Truncated", + get_line_remain()); + return (olen); + } + (void) memcpy(&d6m, data, sizeof (d6m)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Transaction ID = %x", DHCPV6_GET_TRANSID(&d6m)); + data += sizeof (d6m); + len -= sizeof (d6m); + } + show_space(); + show_options(data, len); + show_space(); + } + return (olen); +} + +static const char * +mtype_to_str(uint8_t mtype) +{ + switch (mtype) { + case DHCPV6_MSG_SOLICIT: + return ("Solicit"); + case DHCPV6_MSG_ADVERTISE: + return ("Advertise"); + case DHCPV6_MSG_REQUEST: + return ("Request"); + case DHCPV6_MSG_CONFIRM: + return ("Confirm"); + case DHCPV6_MSG_RENEW: + return ("Renew"); + case DHCPV6_MSG_REBIND: + return ("Rebind"); + case DHCPV6_MSG_REPLY: + return ("Reply"); + case DHCPV6_MSG_RELEASE: + return ("Release"); + case DHCPV6_MSG_DECLINE: + return ("Decline"); + case DHCPV6_MSG_RECONFIGURE: + return ("Reconfigure"); + case DHCPV6_MSG_INFO_REQ: + return ("Information-Request"); + case DHCPV6_MSG_RELAY_FORW: + return ("Relay-Forward"); + case DHCPV6_MSG_RELAY_REPL: + return ("Relay-Reply"); + default: + return ("Unknown"); + } +} + +static const char * +option_to_str(uint8_t mtype) +{ + switch (mtype) { + case DHCPV6_OPT_CLIENTID: + return ("Client Identifier"); + case DHCPV6_OPT_SERVERID: + return ("Server Identifier"); + case DHCPV6_OPT_IA_NA: + return ("Identity Association for Non-temporary Addresses"); + case DHCPV6_OPT_IA_TA: + return ("Identity Association for Temporary Addresses"); + case DHCPV6_OPT_IAADDR: + return ("IA Address"); + case DHCPV6_OPT_ORO: + return ("Option Request"); + case DHCPV6_OPT_PREFERENCE: + return ("Preference"); + case DHCPV6_OPT_ELAPSED_TIME: + return ("Elapsed Time"); + case DHCPV6_OPT_RELAY_MSG: + return ("Relay Message"); + case DHCPV6_OPT_AUTH: + return ("Authentication"); + case DHCPV6_OPT_UNICAST: + return ("Server Unicast"); + case DHCPV6_OPT_STATUS_CODE: + return ("Status Code"); + case DHCPV6_OPT_RAPID_COMMIT: + return ("Rapid Commit"); + case DHCPV6_OPT_USER_CLASS: + return ("User Class"); + case DHCPV6_OPT_VENDOR_CLASS: + return ("Vendor Class"); + case DHCPV6_OPT_VENDOR_OPT: + return ("Vendor-specific Information"); + case DHCPV6_OPT_INTERFACE_ID: + return ("Interface-Id"); + case DHCPV6_OPT_RECONF_MSG: + return ("Reconfigure Message"); + case DHCPV6_OPT_RECONF_ACC: + return ("Reconfigure Accept"); + case DHCPV6_OPT_SIP_NAMES: + return ("SIP Servers Domain Name List"); + case DHCPV6_OPT_SIP_ADDR: + return ("SIP Servers IPv6 Address List"); + case DHCPV6_OPT_DNS_ADDR: + return ("DNS Recursive Name Server"); + case DHCPV6_OPT_DNS_SEARCH: + return ("Domain Search List"); + case DHCPV6_OPT_IA_PD: + return ("Identity Association for Prefix Delegation"); + case DHCPV6_OPT_IAPREFIX: + return ("IA_PD Prefix"); + case DHCPV6_OPT_NIS_SERVERS: + return ("Network Information Service Servers"); + case DHCPV6_OPT_NIS_DOMAIN: + return ("Network Information Service Domain Name"); + case DHCPV6_OPT_SNTP_SERVERS: + return ("Simple Network Time Protocol Servers"); + case DHCPV6_OPT_INFO_REFTIME: + return ("Information Refresh Time"); + case DHCPV6_OPT_BCMCS_SRV_D: + return ("BCMCS Controller Domain Name List"); + case DHCPV6_OPT_BCMCS_SRV_A: + return ("BCMCS Controller IPv6 Address"); + case DHCPV6_OPT_GEOCONF_CVC: + return ("Civic Location"); + case DHCPV6_OPT_REMOTE_ID: + return ("Relay Agent Remote-ID"); + case DHCPV6_OPT_SUBSCRIBER: + return ("Relay Agent Subscriber-ID"); + case DHCPV6_OPT_CLIENT_FQDN: + return ("Client FQDN"); + default: + return ("Unknown"); + } +} + +static const char * +duidtype_to_str(uint16_t dtype) +{ + switch (dtype) { + case DHCPV6_DUID_LLT: + return ("Link-layer Address Plus Time"); + case DHCPV6_DUID_EN: + return ("Enterprise Number"); + case DHCPV6_DUID_LL: + return ("Link-layer Address"); + default: + return ("Unknown"); + } +} + +static const char * +status_to_str(uint16_t status) +{ + switch (status) { + case DHCPV6_STAT_SUCCESS: + return ("Success"); + case DHCPV6_STAT_UNSPECFAIL: + return ("Failure, reason unspecified"); + case DHCPV6_STAT_NOADDRS: + return ("No addresses for IAs"); + case DHCPV6_STAT_NOBINDING: + return ("Client binding unavailable"); + case DHCPV6_STAT_NOTONLINK: + return ("Prefix not on link"); + case DHCPV6_STAT_USEMCAST: + return ("Use multicast"); + case DHCPV6_STAT_NOPREFIX: + return ("No prefix available"); + default: + return ("Unknown"); + } +} + +static const char * +entr_to_str(uint32_t entr) +{ + switch (entr) { + case DHCPV6_SUN_ENT: + return ("Sun Microsystems"); + default: + return ("Unknown"); + } +} + +static const char * +reconf_to_str(uint8_t msgtype) +{ + switch (msgtype) { + case DHCPV6_RECONF_RENEW: + return ("Renew"); + case DHCPV6_RECONF_INFO: + return ("Information-request"); + default: + return ("Unknown"); + } +} + +static const char * +authproto_to_str(uint8_t aproto) +{ + switch (aproto) { + case DHCPV6_PROTO_DELAYED: + return ("Delayed"); + case DHCPV6_PROTO_RECONFIG: + return ("Reconfigure Key"); + default: + return ("Unknown"); + } +} + +static const char * +authalg_to_str(uint8_t aproto, uint8_t aalg) +{ + switch (aproto) { + case DHCPV6_PROTO_DELAYED: + case DHCPV6_PROTO_RECONFIG: + switch (aalg) { + case DHCPV6_ALG_HMAC_MD5: + return ("HMAC-MD5 Signature"); + default: + return ("Unknown"); + } + break; + default: + return ("Unknown"); + } +} + +static const char * +authrdm_to_str(uint8_t ardm) +{ + switch (ardm) { + case DHCPV6_RDM_MONOCNT: + return ("Monotonic Counter"); + default: + return ("Unknown"); + } +} + +static const char * +cwhat_to_str(uint8_t what) +{ + switch (what) { + case DHCPV6_CWHAT_SERVER: + return ("Server"); + case DHCPV6_CWHAT_NETWORK: + return ("Network"); + case DHCPV6_CWHAT_CLIENT: + return ("Client"); + default: + return ("Unknown"); + } +} + +static const char * +catype_to_str(uint8_t catype) +{ + switch (catype) { + case CIVICADDR_LANG: + return ("Language; RFC 2277"); + case CIVICADDR_A1: + return ("National division (state)"); + case CIVICADDR_A2: + return ("County"); + case CIVICADDR_A3: + return ("City"); + case CIVICADDR_A4: + return ("City division"); + case CIVICADDR_A5: + return ("Neighborhood"); + case CIVICADDR_A6: + return ("Street group"); + case CIVICADDR_PRD: + return ("Leading street direction"); + case CIVICADDR_POD: + return ("Trailing street suffix"); + case CIVICADDR_STS: + return ("Street suffix or type"); + case CIVICADDR_HNO: + return ("House number"); + case CIVICADDR_HNS: + return ("House number suffix"); + case CIVICADDR_LMK: + return ("Landmark"); + case CIVICADDR_LOC: + return ("Additional location information"); + case CIVICADDR_NAM: + return ("Name/occupant"); + case CIVICADDR_PC: + return ("Postal Code/ZIP"); + case CIVICADDR_BLD: + return ("Building"); + case CIVICADDR_UNIT: + return ("Unit/apt/suite"); + case CIVICADDR_FLR: + return ("Floor"); + case CIVICADDR_ROOM: + return ("Room number"); + case CIVICADDR_TYPE: + return ("Place type"); + case CIVICADDR_PCN: + return ("Postal community name"); + case CIVICADDR_POBOX: + return ("Post office box"); + case CIVICADDR_ADDL: + return ("Additional code"); + case CIVICADDR_SEAT: + return ("Seat/desk"); + case CIVICADDR_ROAD: + return ("Primary road or street"); + case CIVICADDR_RSEC: + return ("Road section"); + case CIVICADDR_RBRA: + return ("Road branch"); + case CIVICADDR_RSBR: + return ("Road sub-branch"); + case CIVICADDR_SPRE: + return ("Street name pre-modifier"); + case CIVICADDR_SPOST: + return ("Street name post-modifier"); + case CIVICADDR_SCRIPT: + return ("Script"); + default: + return ("Unknown"); + } +} + +static void +show_hex(const uint8_t *data, int len, const char *name) +{ + char buffer[16 * 3 + 1]; + int nlen; + int i; + char sep; + + nlen = strlen(name); + sep = '='; + while (len > 0) { + for (i = 0; i < 16 && i < len; i++) + (void) snprintf(buffer + 3 * i, 4, " %02x", *data++); + (void) snprintf(get_line(0, 0), get_line_remain(), "%*s %c%s", + nlen, name, sep, buffer); + name = ""; + sep = ' '; + len -= i; + } +} + +static void +show_ascii(const uint8_t *data, int len, const char *name) +{ + char buffer[64], *bp; + int nlen; + int i; + char sep; + + nlen = strlen(name); + sep = '='; + while (len > 0) { + bp = buffer; + for (i = 0; i < sizeof (buffer) - 4 && len > 0; len--) { + if (!isascii(*data) || !isprint(*data)) + bp += snprintf(bp, 5, "\\%03o", *data++); + else + *bp++; + } + *bp = '\0'; + (void) snprintf(get_line(0, 0), get_line_remain(), + "%*s %c \"%s\"", nlen, name, sep, buffer); + sep = ' '; + name = ""; + } +} + +static void +show_address(const char *addrname, const void *aptr) +{ + char *hname; + char addrstr[INET6_ADDRSTRLEN]; + in6_addr_t addr; + + (void) memcpy(&addr, aptr, sizeof (in6_addr_t)); + (void) inet_ntop(AF_INET6, &addr, addrstr, sizeof (addrstr)); + hname = addrtoname(AF_INET6, &addr); + if (strcmp(hname, addrstr) == 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), "%s = %s", + addrname, addrstr); + } else { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s = %s (%s)", addrname, addrstr, hname); + } +} + +static void +nest_options(const uint8_t *data, uint_t olen, char *prefix, char *title) +{ + char *str, *oldnest, *oldprefix; + + if (olen <= 0) + return; + oldprefix = prot_prefix; + oldnest = prot_nest_prefix; + str = malloc(strlen(prot_nest_prefix) + strlen(prot_prefix) + 1); + if (str == NULL) { + prot_nest_prefix = prot_prefix; + } else { + (void) sprintf(str, "%s%s", prot_nest_prefix, prot_prefix); + prot_nest_prefix = str; + } + show_header(prefix, title, 0); + show_options(data, olen); + free(str); + prot_prefix = oldprefix; + prot_nest_prefix = oldnest; +} + +static void +show_options(const uint8_t *data, int len) +{ + dhcpv6_option_t d6o; + uint_t olen, retlen; + uint16_t val16; + uint16_t type; + uint32_t val32; + const uint8_t *ostart; + char *str, *sp; + char *oldnest; + + /* + * Be very careful with negative numbers; ANSI signed/unsigned + * comparison doesn't work as expected. + */ + while (len >= (signed)sizeof (d6o)) { + (void) memcpy(&d6o, data, sizeof (d6o)); + d6o.d6o_code = ntohs(d6o.d6o_code); + d6o.d6o_len = olen = ntohs(d6o.d6o_len); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Option Code = %u (%s)", d6o.d6o_code, + option_to_str(d6o.d6o_code)); + ostart = data += sizeof (d6o); + len -= sizeof (d6o); + if (olen > len) { + (void) strlcpy(get_line(0, 0), "Option truncated", + get_line_remain()); + olen = len; + } + switch (d6o.d6o_code) { + case DHCPV6_OPT_CLIENTID: + case DHCPV6_OPT_SERVERID: + if (olen < sizeof (val16)) + break; + (void) memcpy(&val16, data, sizeof (val16)); + data += sizeof (val16); + olen -= sizeof (val16); + type = ntohs(val16); + (void) snprintf(get_line(0, 0), get_line_remain(), + " DUID Type = %u (%s)", type, + duidtype_to_str(type)); + if (type == DHCPV6_DUID_LLT || type == DHCPV6_DUID_LL) { + if (olen < sizeof (val16)) + break; + (void) memcpy(&val16, data, sizeof (val16)); + data += sizeof (val16); + olen -= sizeof (val16); + val16 = ntohs(val16); + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Hardware Type = %u (%s)", val16, + arp_htype(val16)); + } + if (type == DHCPV6_DUID_LLT) { + time_t timevalue; + + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + data += sizeof (val32); + olen -= sizeof (val32); + timevalue = ntohl(val32) + DUID_TIME_BASE; + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Time = %lu (%.24s)", ntohl(val32), + ctime(&timevalue)); + } + if (type == DHCPV6_DUID_EN) { + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + data += sizeof (val32); + olen -= sizeof (val32); + val32 = ntohl(val32); + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Enterprise Number = %lu (%s)", val32, + entr_to_str(val32)); + } + if (olen == 0) + break; + if ((str = malloc(olen * 3)) == NULL) + pr_err("interpret_dhcpv6: no mem"); + sp = str + snprintf(str, 3, "%02x", *data++); + while (--olen > 0) { + *sp++ = (type == DHCPV6_DUID_LLT || + type == DHCPV6_DUID_LL) ? ':' : ' '; + sp = sp + snprintf(sp, 3, "%02x", *data++); + } + (void) snprintf(get_line(0, 0), get_line_remain(), + (type == DHCPV6_DUID_LLT || + type == DHCPV6_DUID_LL) ? + " Link Layer Address = %s" : + " Identifier = %s", str); + free(str); + break; + case DHCPV6_OPT_IA_NA: + case DHCPV6_OPT_IA_PD: { + dhcpv6_ia_na_t d6in; + + if (olen < sizeof (d6in) - sizeof (d6o)) + break; + (void) memcpy(&d6in, data - sizeof (d6o), + sizeof (d6in)); + data += sizeof (d6in) - sizeof (d6o); + olen -= sizeof (d6in) - sizeof (d6o); + (void) snprintf(get_line(0, 0), get_line_remain(), + " IAID = %u", ntohl(d6in.d6in_iaid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " T1 (renew) = %u seconds", ntohl(d6in.d6in_t1)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " T2 (rebind) = %u seconds", ntohl(d6in.d6in_t2)); + nest_options(data, olen, "IA: ", + "Identity Association"); + break; + } + case DHCPV6_OPT_IA_TA: { + dhcpv6_ia_ta_t d6it; + + if (olen < sizeof (d6it) - sizeof (d6o)) + break; + (void) memcpy(&d6it, data - sizeof (d6o), + sizeof (d6it)); + data += sizeof (d6it) - sizeof (d6o); + olen -= sizeof (d6it) - sizeof (d6o); + (void) snprintf(get_line(0, 0), get_line_remain(), + " IAID = %u", ntohl(d6it.d6it_iaid)); + nest_options(data, olen, "IA: ", + "Identity Association"); + break; + } + case DHCPV6_OPT_IAADDR: { + dhcpv6_iaaddr_t d6ia; + + if (olen < sizeof (d6ia) - sizeof (d6o)) + break; + (void) memcpy(&d6ia, data - sizeof (d6o), + sizeof (d6ia)); + data += sizeof (d6ia) - sizeof (d6o); + olen -= sizeof (d6ia) - sizeof (d6o); + show_address(" Address", &d6ia.d6ia_addr); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Preferred lifetime = %u seconds", + ntohl(d6ia.d6ia_preflife)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Valid lifetime = %u seconds", + ntohl(d6ia.d6ia_vallife)); + nest_options(data, olen, "ADDR: ", "Address"); + break; + } + case DHCPV6_OPT_ORO: + while (olen >= sizeof (val16)) { + (void) memcpy(&val16, data, sizeof (val16)); + val16 = ntohs(val16); + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Requested Option Code = %u (%s)", val16, + option_to_str(val16)); + data += sizeof (val16); + olen -= sizeof (val16); + } + break; + case DHCPV6_OPT_PREFERENCE: + if (olen > 0) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + *data == 255 ? + " Preference = %u (immediate)" : + " Preference = %u", *data); + } + break; + case DHCPV6_OPT_ELAPSED_TIME: + if (olen == sizeof (val16)) { + (void) memcpy(&val16, data, sizeof (val16)); + val16 = ntohs(val16); + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Elapsed Time = %u.%02u seconds", + val16 / 100, val16 % 100); + } + break; + case DHCPV6_OPT_RELAY_MSG: + if (olen > 0) { + oldnest = prot_nest_prefix; + prot_nest_prefix = prot_prefix; + retlen = interpret_dhcpv6(F_DTAIL, data, olen); + prot_prefix = prot_nest_prefix; + prot_nest_prefix = oldnest; + } + break; + case DHCPV6_OPT_AUTH: { + dhcpv6_auth_t d6a; + + if (olen < DHCPV6_AUTH_SIZE - sizeof (d6o)) + break; + (void) memcpy(&d6a, data - sizeof (d6o), + DHCPV6_AUTH_SIZE); + data += DHCPV6_AUTH_SIZE - sizeof (d6o); + olen += DHCPV6_AUTH_SIZE - sizeof (d6o); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Protocol = %u (%s)", d6a.d6a_proto, + authproto_to_str(d6a.d6a_proto)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Algorithm = %u (%s)", d6a.d6a_alg, + authalg_to_str(d6a.d6a_proto, d6a.d6a_alg)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Replay Detection Method = %u (%s)", d6a.d6a_rdm, + authrdm_to_str(d6a.d6a_rdm)); + show_hex(d6a.d6a_replay, sizeof (d6a.d6a_replay), + " RDM Data"); + if (olen > 0) + show_hex(data, olen, " Auth Info"); + break; + } + case DHCPV6_OPT_UNICAST: + if (olen >= sizeof (in6_addr_t)) + show_address(" Server Address", data); + break; + case DHCPV6_OPT_STATUS_CODE: + if (olen < sizeof (val16)) + break; + (void) memcpy(&val16, data, sizeof (val16)); + val16 = ntohs(val16); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Status Code = %u (%s)", val16, + status_to_str(val16)); + data += sizeof (val16); + olen -= sizeof (val16); + if (olen > 0) + (void) snprintf(get_line(0, 0), + get_line_remain(), " Text = \"%.*s\"", + olen, data); + break; + case DHCPV6_OPT_VENDOR_CLASS: + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + data += sizeof (val32); + olen -= sizeof (val32); + val32 = ntohl(val32); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Enterprise Number = %lu (%s)", val32, + entr_to_str(val32)); + /* FALLTHROUGH */ + case DHCPV6_OPT_USER_CLASS: + while (olen >= sizeof (val16)) { + (void) memcpy(&val16, data, sizeof (val16)); + data += sizeof (val16); + olen -= sizeof (val16); + val16 = ntohs(val16); + if (val16 > olen) { + (void) strlcpy(get_line(0, 0), + " Truncated class", + get_line_remain()); + val16 = olen; + } + show_hex(data, olen, " Class"); + data += val16; + olen -= val16; + } + break; + case DHCPV6_OPT_VENDOR_OPT: { + dhcpv6_option_t sd6o; + + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + data += sizeof (val32); + olen -= sizeof (val32); + val32 = ntohl(val32); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Enterprise Number = %lu (%s)", val32, + entr_to_str(val32)); + while (olen >= sizeof (sd6o)) { + (void) memcpy(&sd6o, data, sizeof (sd6o)); + sd6o.d6o_code = ntohs(sd6o.d6o_code); + sd6o.d6o_len = ntohs(sd6o.d6o_len); + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Vendor Option Code = %u", d6o.d6o_code); + data += sizeof (d6o); + olen -= sizeof (d6o); + if (sd6o.d6o_len > olen) { + (void) strlcpy(get_line(0, 0), + " Vendor Option truncated", + get_line_remain()); + sd6o.d6o_len = olen; + } + if (sd6o.d6o_len > 0) { + show_hex(data, sd6o.d6o_len, + " Data"); + data += sd6o.d6o_len; + olen -= sd6o.d6o_len; + } + } + break; + } + case DHCPV6_OPT_REMOTE_ID: + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + data += sizeof (val32); + olen -= sizeof (val32); + val32 = ntohl(val32); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Enterprise Number = %lu (%s)", val32, + entr_to_str(val32)); + /* FALLTHROUGH */ + case DHCPV6_OPT_INTERFACE_ID: + case DHCPV6_OPT_SUBSCRIBER: + if (olen > 0) + show_hex(data, olen, " ID"); + break; + case DHCPV6_OPT_RECONF_MSG: + if (olen > 0) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Message Type = %u (%s)", *data, + reconf_to_str(*data)); + } + break; + case DHCPV6_OPT_SIP_NAMES: + case DHCPV6_OPT_DNS_SEARCH: + case DHCPV6_OPT_NIS_DOMAIN: + case DHCPV6_OPT_BCMCS_SRV_D: { + dhcp_symbol_t *symp; + char *sp2; + + symp = inittab_getbycode( + ITAB_CAT_STANDARD | ITAB_CAT_V6, ITAB_CONS_SNOOP, + d6o.d6o_code); + if (symp != NULL) { + str = inittab_decode(symp, data, olen, B_TRUE); + if (str != NULL) { + sp = str; + do { + sp2 = strchr(sp, ' '); + if (sp2 != NULL) + *sp2++ = '\0'; + (void) snprintf(get_line(0, 0), + get_line_remain(), + " Name = %s", sp); + } while ((sp = sp2) != NULL); + free(str); + } + free(symp); + } + break; + } + case DHCPV6_OPT_SIP_ADDR: + case DHCPV6_OPT_DNS_ADDR: + case DHCPV6_OPT_NIS_SERVERS: + case DHCPV6_OPT_SNTP_SERVERS: + case DHCPV6_OPT_BCMCS_SRV_A: + while (olen >= sizeof (in6_addr_t)) { + show_address(" Address", data); + data += sizeof (in6_addr_t); + olen -= sizeof (in6_addr_t); + } + break; + case DHCPV6_OPT_IAPREFIX: { + dhcpv6_iaprefix_t d6ip; + + if (olen < DHCPV6_IAPREFIX_SIZE - sizeof (d6o)) + break; + (void) memcpy(&d6ip, data - sizeof (d6o), + DHCPV6_IAPREFIX_SIZE); + data += DHCPV6_IAPREFIX_SIZE - sizeof (d6o); + olen -= DHCPV6_IAPREFIX_SIZE - sizeof (d6o); + show_address(" Prefix", d6ip.d6ip_addr); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Preferred lifetime = %u seconds", + ntohl(d6ip.d6ip_preflife)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Valid lifetime = %u seconds", + ntohl(d6ip.d6ip_vallife)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Prefix length = %u", d6ip.d6ip_preflen); + nest_options(data, olen, "ADDR: ", "Address"); + break; + } + case DHCPV6_OPT_INFO_REFTIME: + if (olen < sizeof (val32)) + break; + (void) memcpy(&val32, data, sizeof (val32)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Refresh Time = %lu seconds", ntohl(val32)); + break; + case DHCPV6_OPT_GEOCONF_CVC: { + dhcpv6_civic_t d6c; + int solen; + + if (olen < DHCPV6_CIVIC_SIZE - sizeof (d6o)) + break; + (void) memcpy(&d6c, data - sizeof (d6o), + DHCPV6_CIVIC_SIZE); + data += DHCPV6_CIVIC_SIZE - sizeof (d6o); + olen -= DHCPV6_CIVIC_SIZE - sizeof (d6o); + (void) snprintf(get_line(0, 0), get_line_remain(), + " What Location = %u (%s)", d6c.d6c_what, + cwhat_to_str(d6c.d6c_what)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Country Code = %.*s", sizeof (d6c.d6c_cc), + d6c.d6c_cc); + while (olen >= 2) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " CA Element = %u (%s)", *data, + catype_to_str(*data)); + solen = data[1]; + data += 2; + olen -= 2; + if (solen > olen) { + (void) strlcpy(get_line(0, 0), + " CA Element truncated", + get_line_remain()); + solen = olen; + } + if (solen > 0) { + show_ascii(data, solen, " CA Data"); + data += solen; + olen -= solen; + } + } + break; + } + case DHCPV6_OPT_CLIENT_FQDN: { + dhcp_symbol_t *symp; + + if (olen == 0) + break; + (void) snprintf(get_line(0, 0), get_line_remain(), + " Flags = %02x", *data); + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", getflag(*data, DHCPV6_FQDNF_S, + "Perform AAAA RR updates", "No AAAA RR updates")); + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", getflag(*data, DHCPV6_FQDNF_O, + "Server override updates", + "No server override updates")); + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", getflag(*data, DHCPV6_FQDNF_N, + "Server performs no updates", + "Server performs updates")); + symp = inittab_getbycode( + ITAB_CAT_STANDARD | ITAB_CAT_V6, ITAB_CONS_SNOOP, + d6o.d6o_code); + if (symp != NULL) { + str = inittab_decode(symp, data, olen, B_TRUE); + if (str != NULL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " FQDN = %s", str); + free(str); + } + free(symp); + } + break; + } + } + data = ostart + d6o.d6o_len; + len -= d6o.d6o_len; + } + if (len != 0) { + (void) strlcpy(get_line(0, 0), "Option entry truncated", + get_line_remain()); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_display.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_display.c new file mode 100644 index 0000000..9bc4eb5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_display.c @@ -0,0 +1,836 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * + * Copyright 2011 Nexenta Systems, Inc. All rights reserved. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <time.h> +#include <sys/time.h> +#include <sys/bufmod.h> +#include <setjmp.h> +#include <stdarg.h> +#include <sys/socket.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <inttypes.h> + +#include "snoop.h" + +char *dlc_header; +char *src_name, *dst_name; +int pi_frame; +int pi_time_hour; +int pi_time_min; +int pi_time_sec; +int pi_time_usec; + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +static void hexdump(char *, int); + +/* + * This routine invokes the packet interpreters + * on a packet. There's some messing around + * setting up a few packet-externals before + * starting with the ethernet interpreter. + * Yes, we assume here that all packets will + * be ethernet packets. + */ +void +process_pkt(struct sb_hdr *hdrp, char *pktp, int num, int flags) +{ + int drops, pktlen; + struct timeval *tvp; + struct tm *tm; + extern int x_offset; + extern int x_length; + int offset, length; + static struct timeval ptv; + + if (hdrp == NULL) + return; + + tvp = &hdrp->sbh_timestamp; + if (ptv.tv_sec == 0) + ptv = *tvp; + drops = hdrp->sbh_drops; + pktlen = hdrp->sbh_msglen; + if (pktlen <= 0) + return; + + /* set up externals */ + dlc_header = pktp; + pi_frame = num; + tm = localtime(&tvp->tv_sec); + pi_time_hour = tm->tm_hour; + pi_time_min = tm->tm_min; + pi_time_sec = tm->tm_sec; + pi_time_usec = tvp->tv_usec; + + src_name = "?"; + dst_name = "*"; + + click(hdrp->sbh_origlen); + + (*interface->interpreter)(flags, dlc_header, hdrp->sbh_msglen, + hdrp->sbh_origlen); + + show_pktinfo(flags, num, src_name, dst_name, &ptv, tvp, drops, + hdrp->sbh_origlen); + + if (x_offset >= 0) { + offset = MIN(x_offset, hdrp->sbh_msglen); + offset -= (offset % 2); /* round down */ + length = MIN(hdrp->sbh_msglen - offset, x_length); + + hexdump(dlc_header + offset, length); + } + + ptv = *tvp; +} + + +/* + * ************************************************************* + * The following routines constitute a library + * used by the packet interpreters to facilitate + * the display of packet data. This library + * of routines helps provide a consistent + * "look and feel". + */ + + +/* + * Display the value of a flag bit in + * a byte together with some text that + * corresponds to its value - whether + * true or false. + */ +char * +getflag(int val, int mask, char *s_true, char *s_false) +{ + static char buff[80]; + char *p; + int set; + + (void) strcpy(buff, ".... .... = "); + if (s_false == NULL) + s_false = s_true; + + for (p = &buff[8]; p >= buff; p--) { + if (*p == ' ') + p--; + if (mask & 0x1) { + set = val & mask & 0x1; + *p = set ? '1':'0'; + (void) strcat(buff, set ? s_true: s_false); + break; + } + mask >>= 1; + val >>= 1; + } + return (buff); +} + +XDR xdrm; +jmp_buf xdr_err; +int xdr_totlen; +char *prot_prefix; +char *prot_nest_prefix = ""; +char *prot_title; + +void +show_header(char *pref, char *str, int len) +{ + prot_prefix = pref; + prot_title = str; + (void) sprintf(get_detail_line(0, len), "%s%s----- %s -----", + prot_nest_prefix, pref, str); +} + +void +xdr_init(char *addr, int len) +{ + xdr_totlen = len; + xdrmem_create(&xdrm, addr, len, XDR_DECODE); +} + +/* Note: begin+end are ignored in get_detail_line */ +char * +get_line(int begin, int end) +{ + char *line; + + line = get_detail_line(begin, end); + (void) strcpy(line, prot_nest_prefix); + (void) strcat(line, prot_prefix); + return (line + strlen(line)); +} + +int +get_line_remain(void) +{ + return (MAXLINE - strlen(prot_nest_prefix) - strlen(prot_prefix)); +} + +void +show_line(char *str) +{ + (void) strlcpy(get_line(0, 0), str, get_line_remain()); +} + +void +show_printf(char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + (void) vsnprintf(get_line(0, 0), get_line_remain(), fmt, ap); + va_end(ap); +} + +char +getxdr_char() +{ + char s; + + if (xdr_char(&xdrm, &s)) + return (s); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +char +showxdr_char(char *fmt) +{ + int pos; char val; + + pos = getxdr_pos(); + val = getxdr_char(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +uchar_t +getxdr_u_char() +{ + uchar_t s; + + if (xdr_u_char(&xdrm, &s)) + return (s); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +uchar_t +showxdr_u_char(char *fmt) +{ + int pos; + uchar_t val; + + pos = getxdr_pos(); + val = getxdr_u_char(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +short +getxdr_short() +{ + short s; + + if (xdr_short(&xdrm, &s)) + return (s); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +short +showxdr_short(char *fmt) +{ + int pos; short val; + + pos = getxdr_pos(); + val = getxdr_short(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +ushort_t +getxdr_u_short() +{ + ushort_t s; + + if (xdr_u_short(&xdrm, &s)) + return (s); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +ushort_t +showxdr_u_short(char *fmt) +{ + int pos; + ushort_t val; + + pos = getxdr_pos(); + val = getxdr_u_short(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +long +getxdr_long() +{ + long l; + + if (xdr_long(&xdrm, &l)) + return (l); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +long +showxdr_long(char *fmt) +{ + int pos; long val; + + pos = getxdr_pos(); + val = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +ulong_t +getxdr_u_long() +{ + ulong_t l; + + if (xdr_u_long(&xdrm, &l)) + return (l); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +ulong_t +showxdr_u_long(char *fmt) +{ + int pos; + ulong_t val; + + pos = getxdr_pos(); + val = getxdr_u_long(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +longlong_t +getxdr_longlong() +{ + longlong_t l; + + if (xdr_longlong_t(&xdrm, &l)) + return (l); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +longlong_t +showxdr_longlong(char *fmt) +{ + int pos; longlong_t val; + + pos = getxdr_pos(); + val = getxdr_longlong(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +u_longlong_t +getxdr_u_longlong() +{ + u_longlong_t l; + + if (xdr_u_longlong_t(&xdrm, &l)) + return (l); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +u_longlong_t +showxdr_u_longlong(char *fmt) +{ + int pos; u_longlong_t val; + + pos = getxdr_pos(); + val = getxdr_u_longlong(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, val); + return (val); +} + +bool_t +getxdr_bool() +{ + bool_t b; + + if (xdr_bool(&xdrm, &b)) + return (b); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +bool_t +showxdr_bool(char *fmt) +{ + int pos; bool_t val; + + pos = getxdr_pos(); + val = getxdr_bool(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, + val ? "True" : "False"); + return (val); +} + +char * +getxdr_opaque(char *p, int len) +{ + if (xdr_opaque(&xdrm, p, len)) + return (p); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +char * +getxdr_string(char *p, /* len+1 bytes or longer */ + int len) +{ + if (xdr_string(&xdrm, &p, len)) + return (p); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +char * +showxdr_string(int len, /* XDR length */ + char *fmt) +{ + static int buff_len = 0; + static char *buff = NULL; + int pos; + + /* + * XDR strings don't necessarily have a trailing null over the + * wire. However, the XDR code will put one in for us. Make sure + * we have allocated room for it. + */ + len++; + + if ((len > buff_len) || (buff_len == 0)) { + if (buff) + free(buff); + if ((buff = (char *)malloc(len)) == NULL) + pr_err("showxdr_string: no mem"); + buff_len = len; + } + pos = getxdr_pos(); + getxdr_string(buff, len); + (void) strcpy(buff+60, "..."); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, buff); + return (buff); +} + +char * +getxdr_bytes(uint_t *lenp) +{ + static char buff[1024]; + char *p = buff; + + if (xdr_bytes(&xdrm, &p, lenp, 1024)) + return (buff); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +char * +getxdr_context(char *p, int len) +{ + ushort_t size; + + size = getxdr_u_short(); + if (((int)size > 0) && ((int)size < len) && getxdr_opaque(p, size)) + return (p); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +char * +showxdr_context(char *fmt) +{ + ushort_t size; + static char buff[1024]; + int pos; + + pos = getxdr_pos(); + size = getxdr_u_short(); + if (((int)size > 0) && ((int)size < 1024) && + getxdr_opaque(buff, size)) { + (void) sprintf(get_line(pos, getxdr_pos()), fmt, buff); + return (buff); + } + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +enum_t +getxdr_enum() +{ + enum_t e; + + if (xdr_enum(&xdrm, &e)) + return (e); + longjmp(xdr_err, 1); + /* NOTREACHED */ +} + +void +xdr_skip(int delta) +{ + uint_t pos; + if (delta % 4 != 0 || delta < 0) + longjmp(xdr_err, 1); + /* Check for overflow */ + pos = xdr_getpos(&xdrm); + if ((pos + delta) < pos) + longjmp(xdr_err, 1); + /* xdr_setpos() checks for buffer overrun */ + if (xdr_setpos(&xdrm, pos + delta) == FALSE) + longjmp(xdr_err, 1); +} + +int +getxdr_pos() +{ + return (xdr_getpos(&xdrm)); +} + +void +setxdr_pos(int pos) +{ + xdr_setpos(&xdrm, pos); +} + +void +show_space() +{ + (void) get_line(0, 0); +} + +void +show_trailer() +{ + show_space(); +} + +char * +getxdr_date() +{ + time_t sec; + int usec; + static char buff[64]; + char *p; + struct tm my_time; /* private buffer to avoid collision */ + /* between gmtime and strftime */ + struct tm *tmp; + + sec = getxdr_long(); + usec = getxdr_long(); + if (sec == -1) + return ("-1 "); + + if (sec < 3600 * 24 * 365) { /* assume not a date */ + (void) sprintf(buff, "%d.%06d", sec, usec); + } else { + tmp = gmtime(&sec); + (void) memcpy(&my_time, tmp, sizeof (struct tm)); + strftime(buff, sizeof (buff), "%d-%h-%y %T.", &my_time); + p = buff + strlen(buff); + (void) sprintf(p, "%06d GMT", usec); + } + return (buff); +} + +char * +showxdr_date(char *fmt) +{ + int pos; + char *p; + + pos = getxdr_pos(); + p = getxdr_date(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, p); + return (p); +} + +char * +getxdr_date_ns(void) +{ + time_t sec, nsec; + + sec = getxdr_long(); + nsec = getxdr_long(); + if (sec == -1) + return ("-1 "); + else + return (format_time(sec, nsec)); +} + +/* + * Format the given time. + */ +char * +format_time(int64_t sec, uint32_t nsec) +{ + static char buff[64]; + char *p; + struct tm my_time; /* private buffer to avoid collision */ + /* between gmtime and strftime */ + struct tm *tmp; + + if (sec < 3600 * 24 * 365) { + /* assume not a date; includes negative times */ + (void) sprintf(buff, "%lld.%06d", sec, nsec); + } else if (sec > INT32_MAX) { + /* + * XXX No routines are available yet for formatting 64-bit + * times. + */ + (void) sprintf(buff, "%lld.%06d", sec, nsec); + } else { + time_t sec32 = (time_t)sec; + + tmp = gmtime(&sec32); + memcpy(&my_time, tmp, sizeof (struct tm)); + strftime(buff, sizeof (buff), "%d-%h-%y %T.", &my_time); + p = buff + strlen(buff); + (void) sprintf(p, "%09d GMT", nsec); + } + return (buff); +} + +char * +showxdr_date_ns(char *fmt) +{ + int pos; + char *p; + + pos = getxdr_pos(); + p = getxdr_date_ns(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, p); + return (p); +} + +char * +getxdr_time() +{ + time_t sec; + static char buff[64]; + struct tm my_time; /* private buffer to avoid collision */ + /* between gmtime and strftime */ + struct tm *tmp; + + sec = getxdr_long(); + if (sec == -1) + return ("-1 "); + + if (sec < 3600 * 24 * 365) { /* assume not a date */ + (void) sprintf(buff, "%d", sec); + } else { + tmp = gmtime(&sec); + memcpy(&my_time, tmp, sizeof (struct tm)); + strftime(buff, sizeof (buff), "%d-%h-%y %T", &my_time); + } + return (buff); +} + +char * +showxdr_time(char *fmt) +{ + int pos; + char *p; + + pos = getxdr_pos(); + p = getxdr_time(); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, p); + return (p); +} + +char * +getxdr_hex(int len) +{ + int i, j; + static char hbuff[1024]; + char rbuff[1024]; + static char *hexstr = "0123456789ABCDEF"; + char toobig = 0; + + if (len == 0) { + hbuff[0] = '\0'; + return (hbuff); + } + if (len > 1024) + len = 1024; + if (len < 0 || xdr_opaque(&xdrm, rbuff, len) == FALSE) { + longjmp(xdr_err, 1); + } + + if (len * 2 > sizeof (hbuff)) { + toobig++; + len = sizeof (hbuff) / 2; + } + + j = 0; + for (i = 0; i < len; i++) { + hbuff[j++] = hexstr[rbuff[i] >> 4 & 0x0f]; + hbuff[j++] = hexstr[rbuff[i] & 0x0f]; + } + + if (toobig) { + hbuff[len * 2 - strlen("<Too Long>")] = '\0'; + strcat(hbuff, "<Too Long>"); + } else + hbuff[j] = '\0'; + + return (hbuff); +} + +char * +showxdr_hex(int len, char *fmt) +{ + int pos; + char *p; + + pos = getxdr_pos(); + p = getxdr_hex(len); + (void) sprintf(get_line(pos, getxdr_pos()), fmt, p); + return (p); +} + +static void +hexdump(char *data, int datalen) +{ + char *p; + ushort_t *p16 = (ushort_t *)data; + char *p8 = data; + int i, left, len; + int chunk = 16; /* 16 bytes per line */ + + printf("\n"); + + for (p = data; p < data + datalen; p += chunk) { + printf("\t%4d: ", p - data); + left = (data + datalen) - p; + len = MIN(chunk, left); + for (i = 0; i < (len / 2); i++) + printf("%04x ", ntohs(*p16++) & 0xffff); + if (len % 2) { + printf("%02x ", *((unsigned char *)p16)); + } + for (i = 0; i < (chunk - left) / 2; i++) + printf(" "); + + printf(" "); + for (i = 0; i < len; i++, p8++) + printf("%c", isprint(*p8) ? *p8 : '.'); + printf("\n"); + } + + printf("\n"); +} + +char * +show_string(const char *str, int dlen, int maxlen) +/* + * Prints len bytes from str enclosed in quotes. + * If len is negative, length is taken from strlen(str). + * No more than maxlen bytes will be printed. Longer + * strings are flagged with ".." after the closing quote. + * Non-printing characters are converted to C-style escape + * codes or octal digits. + */ +{ +#define TBSIZE 256 + static char tbuff[TBSIZE]; + const char *p; + char *pp; + int printable = 0; + int c, len; + + len = dlen > maxlen ? maxlen : dlen; + dlen = len; + + for (p = str, pp = tbuff; len; p++, len--) { + switch (c = *p & 0xFF) { + case '\n': (void) strcpy(pp, "\\n"); pp += 2; break; + case '\b': (void) strcpy(pp, "\\b"); pp += 2; break; + case '\t': (void) strcpy(pp, "\\t"); pp += 2; break; + case '\r': (void) strcpy(pp, "\\r"); pp += 2; break; + case '\f': (void) strcpy(pp, "\\f"); pp += 2; break; + default: + if (isascii(c) && isprint(c)) { + *pp++ = c; + printable++; + } else { + (void) snprintf(pp, TBSIZE - (pp - tbuff), + isdigit(*(p + 1)) ? + "\\%03o" : "\\%o", c); + pp += strlen(pp); + } + break; + } + *pp = '\0'; + /* + * Check for overflow of temporary buffer. Allow for + * the next character to be a \nnn followed by a trailing + * null. If not, then just bail with what we have. + */ + if (pp + 5 >= &tbuff[TBSIZE]) { + break; + } + } + return (printable > dlen / 2 ? tbuff : ""); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dns.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dns.c new file mode 100644 index 0000000..309d24a --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_dns.c @@ -0,0 +1,917 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <string.h> +#include <limits.h> +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <arpa/nameser.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include "snoop.h" + +/* The string used to indent detail lines */ +#define DNS_INDENT " " +/* + * From RFC1035, the maximum size of a character-string is limited by the + * one octet length field. We add one character to that to make sure the + * result is terminated. + */ +#define MAX_CHAR_STRING_SIZE UCHAR_MAX + 1 + +/* private functions */ +static char *dns_opcode_string(uint_t opcode); +static char *dns_rcode_string(uint_t rcode); +static char *dns_type_string(uint_t type, int detail); +static char *dns_class_string(uint_t cls, int detail); +static size_t skip_question(const uchar_t *header, const uchar_t *data, + const uchar_t *data_end); +static size_t print_question(char *line, const uchar_t *header, + const uchar_t *data, const uchar_t *data_end, int detail); +static size_t print_answer(char *line, const uchar_t *header, + const uchar_t *data, const uchar_t *data_end, int detail); +static char *binary_string(char data); +static void print_ip(int af, char *line, const uchar_t *data, uint16_t len); +static const uchar_t *get_char_string(const uchar_t *data, char *charbuf, + uint16_t datalen); +static size_t print_char_string(char *line, const uchar_t *data, uint16_t len); +static const uchar_t *get_domain_name(const uchar_t *header, + const uchar_t *data, const uchar_t *data_end, char *namebuf, char *namend); +static size_t print_domain_name(char *line, const uchar_t *header, + const uchar_t *data, const uchar_t *data_end); + +void +interpret_dns(int flags, int proto, const uchar_t *data, int len, int port) +{ + typedef HEADER dns_header; + dns_header header; + char *line; + ushort_t id, qdcount, ancount, nscount, arcount; + ushort_t count; + const uchar_t *rrp; /* Resource Record Pointer. */ + const uchar_t *data_end; + const char *protostr; + char *protopfxstr; + char *protohdrstr; + + if (proto == IPPROTO_TCP) { + /* not supported now */ + return; + } + + if (port == IPPORT_DOMAIN) { + protostr = "DNS"; + protopfxstr = "DNS: "; + protohdrstr = "DNS Header"; + } else { + protostr = "MDNS"; + protopfxstr = "MDNS: "; + protohdrstr = "MDNS Header"; + } + + /* We need at least the header in order to parse a packet. */ + if (sizeof (dns_header) > len) { + return; + } + data_end = data + len; + /* + * Copy the header into a local structure for aligned access to + * each field. + */ + (void) memcpy(&header, data, sizeof (header)); + id = ntohs(header.id); + qdcount = ntohs(header.qdcount); + ancount = ntohs(header.ancount); + nscount = ntohs(header.nscount); + arcount = ntohs(header.arcount); + + if (flags & F_SUM) { + line = get_sum_line(); + line += sprintf(line, "%s %c ", + protostr, header.qr ? 'R' : 'C'); + + if (header.qr) { + /* answer */ + if (header.rcode == 0) { + /* reply is OK */ + rrp = data + sizeof (dns_header); + while (qdcount--) { + if (rrp >= data_end) { + return; + } + rrp += skip_question(data, + rrp, data_end); + } + /* the answers follow the questions */ + if (ancount > 0) { + (void) print_answer(line, + data, rrp, data_end, FALSE); + } + } else { + (void) sprintf(line, " Error: %d(%s)", + header.rcode, + dns_rcode_string(header.rcode)); + } + } else { + /* question */ + rrp = data + sizeof (dns_header); + if (rrp >= data_end) { + return; + } + (void) print_question(line, data, rrp, data_end, + FALSE); + } + } + if (flags & F_DTAIL) { + show_header(protopfxstr, protohdrstr, sizeof (dns_header)); + show_space(); + if (header.qr) { + /* answer */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Response ID = %d", id); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s%s%s", + header.aa ? "AA (Authoritative Answer) " : "", + header.tc ? "TC (TrunCation) " : "", + header.ra ? "RA (Recursion Available) ": ""); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Response Code: %d (%s)", + header.rcode, dns_rcode_string(header.rcode)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Reply to %d question(s)", qdcount); + } else { + /* question */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Query ID = %d", id); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Opcode: %s", dns_opcode_string(header.opcode)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s%s", + header.tc ? "TC (TrunCation) " : "", + header.rd ? "RD (Recursion Desired) " : ""); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d question(s)", qdcount); + } + rrp = data + sizeof (dns_header); + count = 0; + while (qdcount--) { + if (rrp >= data_end) { + return; + } + count++; + rrp += print_question(get_line(0, 0), + data, rrp, data_end, TRUE); + show_space(); + } + /* Only answers should hold answers, but just in case */ + if (header.qr || ancount > 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d answer(s)", ancount); + count = 0; + while (ancount--) { + if (rrp >= data_end) { + return; + } + count++; + rrp += print_answer(get_line(0, 0), + data, rrp, data_end, TRUE); + show_space(); + } + } + /* Likewise only answers should hold NS records */ + if (header.qr || nscount > 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d name server resource(s)", nscount); + count = 0; + while (nscount--) { + if (rrp >= data_end) { + return; + } + count++; + rrp += print_answer(get_line(0, 0), data, + rrp, data_end, TRUE); + show_space(); + } + } + /* Additional section may hold an EDNS0 record. */ + if (header.qr || arcount > 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d additional record(s)", arcount); + count = 0; + while (arcount-- && rrp < data_end) { + count++; + rrp += print_answer(get_line(0, 0), data, + rrp, data_end, TRUE); + show_space(); + } + } + } +} + + +static char * +dns_opcode_string(uint_t opcode) +{ + static char buffer[64]; + switch (opcode) { + case ns_o_query: return ("Query"); + case ns_o_iquery: return ("Inverse Query"); + case ns_o_status: return ("Status"); + default: + (void) snprintf(buffer, sizeof (buffer), "Unknown (%u)", + opcode); + return (buffer); + } +} + +static char * +dns_rcode_string(uint_t rcode) +{ + static char buffer[64]; + switch (rcode) { + case ns_r_noerror: return ("OK"); + case ns_r_formerr: return ("Format Error"); + case ns_r_servfail: return ("Server Fail"); + case ns_r_nxdomain: return ("Name Error"); + case ns_r_notimpl: return ("Unimplemented"); + case ns_r_refused: return ("Refused"); + case ns_r_badvers: return ("Bad Version"); /* EDNS rcode */ + default: + (void) snprintf(buffer, sizeof (buffer), "Unknown (%u)", rcode); + return (buffer); + } +} + +static char * +dns_type_string(uint_t type, int detail) +{ + static char buffer[64]; + switch (type) { + case ns_t_a: return (detail ? "Address" : "Addr"); + case ns_t_ns: return (detail ? "Authoritative Name Server" : "NS"); + case ns_t_cname: return (detail ? "Canonical Name" : "CNAME"); + case ns_t_soa: return (detail ? "Start Of a zone Authority" : "SOA"); + case ns_t_mb: return (detail ? "Mailbox domain name" : "MB"); + case ns_t_mg: return (detail ? "Mailbox Group member" : "MG"); + case ns_t_mr: return (detail ? "Mail Rename domain name" : "MR"); + case ns_t_null: return ("NULL"); + case ns_t_wks: return (detail ? "Well Known Service" : "WKS"); + case ns_t_ptr: return (detail ? "Domain Name Pointer" : "PTR"); + case ns_t_hinfo: return (detail ? "Host Information": "HINFO"); + case ns_t_minfo: + return (detail ? "Mailbox or maillist Info" : "MINFO"); + case ns_t_mx: return (detail ? "Mail Exchange" : "MX"); + case ns_t_txt: return (detail ? "Text strings" : "TXT"); + case ns_t_aaaa: return (detail ? "IPv6 Address" : "AAAA"); + case ns_t_opt: return (detail ? "EDNS0 option" : "OPT"); + case ns_t_axfr: return (detail ? "Transfer of entire zone" : "AXFR"); + case ns_t_mailb: + return (detail ? "Mailbox related records" : "MAILB"); + case ns_t_maila: return (detail ? "Mail agent RRs" : "MAILA"); + case ns_t_any: return (detail ? "All records" : "*"); + default: + (void) snprintf(buffer, sizeof (buffer), "Unknown (%u)", type); + return (buffer); + } +} + +static char * +dns_class_string(uint_t cls, int detail) +{ + static char buffer[64]; + switch (cls) { + case ns_c_in: return (detail ? "Internet" : "Internet"); + case ns_c_chaos: return (detail ? "CHAOS" : "CH"); + case ns_c_hs: return (detail ? "Hesiod" : "HS"); + case ns_c_any: return (detail ? "* (Any class)" : "*"); + default: + (void) snprintf(buffer, sizeof (buffer), "Unknown (%u)", cls); + return (buffer); + } +} + +static size_t +skip_question(const uchar_t *header, const uchar_t *data, + const uchar_t *data_end) +{ + const uchar_t *data_bak = data; + char dummy_buffer[NS_MAXDNAME]; + + data = get_domain_name(header, data, data_end, dummy_buffer, + dummy_buffer + sizeof (dummy_buffer)); + /* Skip the 32 bits of class and type that follow the domain name */ + data += sizeof (uint32_t); + return (data - data_bak); +} + +static size_t +print_question(char *line, const uchar_t *header, const uchar_t *data, + const uchar_t *data_end, int detail) +{ + const uchar_t *data_bak = data; + uint16_t type; + uint16_t cls; + + if (detail) { + line += snprintf(line, get_line_remain(), + DNS_INDENT "Domain Name: "); + } + data += print_domain_name(line, header, data, data_end); + + /* + * Make sure we don't run off the end of the packet by reading the + * type and class. + * + * The pointer subtraction on the left side of the following + * expression has a signed result of type ptrdiff_t, and the right + * side has an unsigned result of type size_t. We therefore need + * to cast the right side of the expression to be of the same + * signed type to keep the result of the pointer arithmetic to be + * automatically cast to an unsigned value. We do a similar cast + * in other similar expressions throughout this file. + */ + if ((data_end - data) < (ptrdiff_t)(2 * sizeof (uint16_t))) + return (data_end - data_bak); + + GETINT16(type, data); + GETINT16(cls, data); + + /* + * Multicast DNS re-uses the top bit of the class field + * in the question and answer sections. Unicast DNS only + * uses 1 (Internet), 3 and 4. Hence it is safe. The top + * order bit is always cleared here to display the rrclass in case + * of Multicast DNS packets. + */ + cls = cls & 0x7fff; + + if (detail) { + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Class: %u (%s)", + cls, dns_class_string(cls, detail)); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Type: %u (%s)", type, + dns_type_string(type, detail)); + } else { + (void) sprintf(line + strlen(line), " %s %s \?", + dns_class_string(cls, detail), + dns_type_string(type, detail)); + } + return (data - data_bak); +} + +/* + * print_answer() is used to display the contents of a single resource + * record (RR) from either the answer, name server or additional + * section of the DNS packet. + * + * Input: + * *line: snoops output buffer. + * *header: start of the DNS packet, required for names and rcode. + * *data: location within header from where the RR starts. + * *data_end: where DNS data ends. + * detail: simple or verbose output. + * + * Returns: + * Pointer to next RR or data_end. + * + * Most RRs have the same top level format as defined in RFC 1035: + * + * 1 1 1 1 1 1 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | | + * / NAME / + * | | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | TYPE | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | CLASS | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | TTL | + * | | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | RDLENGTH | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--| + * / RDATA / + * / / + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * + * However RFC 2671 introduced an exception to this rule + * with the "Extension Mechanisms for DNS" (EDNS0). + * When the type is 41 the remaining resource record format + * is: + * + * 1 1 1 1 1 1 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | TYPE = 41 | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | Sender's UDP payload size | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | Extended-rcode | Version | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | Zero | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * | RDLENGTH | + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--| + * / RDATA / + * / / + * +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ + * + */ +static size_t +print_answer(char *line, const uchar_t *header, const uchar_t *data, + const uchar_t *data_end, int detail) +{ + const uchar_t *data_bak = data; + const uchar_t *data_next; + uint16_t type; + uint16_t cls; + int32_t ttl; + uint16_t rdlen; + uint32_t serial, refresh, retry, expire, minimum; + uint8_t protocol; + int linepos; + uint16_t preference; + /* declarations for EDNS follow */ + uint16_t size; /* Sender's UDP payload size */ + uint8_t xrcode; /* Extended-rcode */ + uint8_t ver; /* Version */ + uint16_t rcode; /* Extracted from the DNS header */ + union { /* DNS header overlay used for extraction */ + HEADER *head; + const uchar_t *raw; + } headptr; + + if (detail) { + line += snprintf(line, get_line_remain(), + DNS_INDENT "Domain Name: "); + } + data += print_domain_name(line, header, data, data_end); + + /* + * Next, get the record type, being careful to make sure we + * don't run off the end of the packet. + */ + if ((data_end - data) < (ptrdiff_t)(sizeof (type))) { + return (data_end - data_bak); + } + + GETINT16(type, data); + + if (type == ns_t_opt) { + /* + * Make sure we won't run off the end reading size, + * xrcode, version, zero and rdlen. + */ + if ((data_end - data) < + ((ptrdiff_t)(sizeof (size) + + sizeof (xrcode) + + sizeof (ver) + + sizeof (cls) /* zero */ + + sizeof (rdlen)))) { + return (data_end - data_bak); + } + + GETINT16(size, data); + GETINT8(xrcode, data); + /* + * The extended rcode represents the top half of the + * rcode which must be added to the rcode in the header. + */ + rcode = 0xff & (xrcode << 4); + headptr.raw = header; /* Overlay the header... */ + rcode += headptr.head->rcode; /* And pluck out the rcode. */ + + GETINT8(ver, data); + GETINT16(cls, data); /* zero */ + GETINT16(rdlen, data); + + if (detail) { + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Type: %u (%s)", type, + dns_type_string(type, detail)); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "UDP payload size: %u (0x%.4x)", + size, size); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Extended rcode: %u " + "(translates to %u (%s))", + xrcode, rcode, dns_rcode_string(rcode)); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "EDNS0 Version: %u", ver); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "zero: %u", cls); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Data length: %u", rdlen); + } else { + line += strlen(line); + line += sprintf(line, " %s UDP %u rc %d ver %u len %u", + dns_type_string(type, detail), size, rcode, ver, + rdlen); + } + + /* + * Make sure that rdlen is within data boundary. + */ + if (rdlen > data_end - data) + return (data_end - data_bak); + + /* Future OPT decode code goes here. */ + + data += rdlen; + return (data - data_bak); + } + + /* + * Make sure we don't run off the end of the packet by reading the + * class, ttl, and length. + */ + if ((data_end - data) < + ((ptrdiff_t)(sizeof (cls) + + sizeof (ttl) + + sizeof (rdlen)))) { + return (data_end - data_bak); + } + + GETINT16(cls, data); + + /* + * Multicast DNS re-uses the top bit of the class field + * in the question and answer sections. Unicast DNS only + * uses 1 (Internet), 3 and 4. Hence it is safe. The top + * order bit is always cleared here to display the rrclass in case + * of Multicast DNS packets. + */ + cls = cls & 0x7fff; + + if (detail) { + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Class: %d (%s)", cls, + dns_class_string(cls, detail)); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Type: %d (%s)", type, + dns_type_string(type, detail)); + } else { + line += strlen(line); + line += sprintf(line, " %s %s ", + dns_class_string(cls, detail), + dns_type_string(type, detail)); + } + + GETINT32(ttl, data); + if (detail) { + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "TTL (Time To Live): %d", ttl); + } + + GETINT16(rdlen, data); + if (detail) { + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), DNS_INDENT "%s: ", + dns_type_string(type, detail)); + } + + if (rdlen > data_end - data) + return (data_end - data_bak); + + switch (type) { + case ns_t_a: + print_ip(AF_INET, line, data, rdlen); + break; + case ns_t_aaaa: + print_ip(AF_INET6, line, data, rdlen); + break; + case ns_t_hinfo: + line += sprintf(line, "CPU: "); + data_next = data + print_char_string(line, data, rdlen); + if (data_next >= data_end) + break; + line += strlen(line); + line += sprintf(line, "OS: "); + (void) print_char_string(line, data_next, + rdlen - (data_next - data)); + break; + case ns_t_ns: + case ns_t_cname: + case ns_t_mb: + case ns_t_mg: + case ns_t_mr: + case ns_t_ptr: + (void) print_domain_name(line, header, data, data_end); + break; + case ns_t_mx: + data_next = data; + if (rdlen < sizeof (uint16_t)) + break; + GETINT16(preference, data_next); + if (detail) { + (void) print_domain_name(line, header, data_next, + data_end); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Preference: %u", preference); + } else { + (void) print_domain_name(line, header, data_next, + data_end); + } + break; + case ns_t_soa: + if (!detail) + break; + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT "MNAME (Server name): "); + data_next = data + print_domain_name(line, header, data, + data_end); + if (data_next >= data_end) + break; + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT "RNAME (Resposible mailbox): "); + data_next = data_next + + print_domain_name(line, header, data_next, data_end); + if ((data_end - data_next) < (ptrdiff_t)(5 * sizeof (uint32_t))) + break; + GETINT32(serial, data_next); + GETINT32(refresh, data_next); + GETINT32(retry, data_next); + GETINT32(expire, data_next); + GETINT32(minimum, data_next); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Serial: %u", serial); + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Refresh: %u Retry: %u " + "Expire: %u Minimum: %u", + refresh, retry, expire, minimum); + break; + case ns_t_wks: + print_ip(AF_INET, line, data, rdlen); + if (!detail) + break; + data_next = data + sizeof (in_addr_t); + if (data_next >= data_end) + break; + GETINT8(protocol, data_next); + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT "Protocol: %u ", protocol); + switch (protocol) { + case IPPROTO_UDP: + (void) snprintf(line, get_line_remain(), "(UDP)"); + break; + case IPPROTO_TCP: + (void) snprintf(line, get_line_remain(), "(TCP)"); + break; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + DNS_INDENT "Service bitmap:"); + (void) snprintf(line, get_line_remain(), + DNS_INDENT "0 8 16 24"); + linepos = 4; + while (data_next < data + rdlen) { + if (linepos == 4) { + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT); + linepos = 0; + } + line += snprintf(line, get_line_remain(), "%s", + binary_string(*data_next)); + linepos++; + data_next++; + } + break; + case ns_t_minfo: + if (!detail) + break; + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT "RMAILBX (Resposible mailbox): "); + data_next = data + print_domain_name(line, header, data, + data_end); + line = get_line(0, 0); + line += snprintf(line, get_line_remain(), + DNS_INDENT "EMAILBX (mailbox to receive err message): "); + data_next = data_next + print_domain_name(line, header, + data_next, data_end); + break; + } + data += rdlen; + return (data - data_bak); +} + +static char * +binary_string(char data) +{ + static char bstring[8 + 1]; + char *ptr; + int i; + ptr = bstring; + for (i = 0; i < 8; i++) { + *ptr++ = (data & 0x80) ? '1' : '0'; + data = data << 1; + } + *ptr = (char)0; + return (bstring); +} + +static void +print_ip(int af, char *line, const uchar_t *data, uint16_t len) +{ + in6_addr_t addr6; + in_addr_t addr4; + void *addr; + + switch (af) { + case AF_INET: + if (len != sizeof (in_addr_t)) + return; + addr = memcpy(&addr4, data, sizeof (addr4)); + break; + case AF_INET6: + if (len != sizeof (in6_addr_t)) + return; + addr = memcpy(&addr6, data, sizeof (addr6)); + break; + } + + (void) inet_ntop(af, addr, line, INET6_ADDRSTRLEN); +} + +/* + * charbuf is assumed to be of size MAX_CHAR_STRING_SIZE. + */ +static const uchar_t * +get_char_string(const uchar_t *data, char *charbuf, uint16_t datalen) +{ + int len; + char *name = charbuf; + int i = 0; + + /* + * From RFC1035, a character-string is a single length octet followed + * by that number of characters. + */ + if (datalen > 1) { + len = *data; + data++; + if (len > 0 && len < MAX_CHAR_STRING_SIZE) { + for (i = 0; i < len; i++, data++) + name[i] = *data; + } + } + name[i] = '\0'; + return (data); +} + +static size_t +print_char_string(char *line, const uchar_t *data, uint16_t len) +{ + char charbuf[MAX_CHAR_STRING_SIZE]; + const uchar_t *data_bak = data; + + data = get_char_string(data, charbuf, len); + (void) sprintf(line, "%s", charbuf); + return (data - data_bak); +} + +/* + * header: the entire message header, this is where we start to + * count the offset of the compression scheme + * data: the start of the domain name + * namebuf: user supplied buffer + * return: the next byte after what we have parsed + */ +static const uchar_t * +get_domain_name(const uchar_t *header, const uchar_t *data, + const uchar_t *data_end, char *namebuf, char *namend) +{ + uint8_t len; + char *name = namebuf; + + /* + * From RFC1035, a domain name is a sequence of labels, where each + * label consists of a length octet followed by that number of + * octets. The domain name terminates with the zero length octet + * for the null label of the root. + */ + + while (name < (namend - 1)) { + if ((data_end - data) < (ptrdiff_t)(sizeof (uint8_t))) { + /* The length octet is off the end of the packet. */ + break; + } + GETINT8(len, data); + if (len == 0) { + /* + * Domain names end with a length byte of zero, + * which represents the null label of the root. + */ + break; + } + /* + * test if we are using the compression scheme + */ + if ((len & 0xc0) == 0xc0) { + uint16_t offset; + const uchar_t *label_ptr; + + /* + * From RFC1035, message compression allows a + * domain name or a list of labels at the end of a + * domain name to be replaced with a pointer to a + * prior occurance of the same name. In this + * scheme, the pointer is a two octet sequence + * where the most significant two bits are set, and + * the remaining 14 bits are the offset from the + * start of the message of the next label. + */ + data--; + if ((data_end - data) < + (ptrdiff_t)(sizeof (uint16_t))) { + /* + * The offset octets aren't entirely + * contained within this pakcet. + */ + data = data_end; + break; + } + GETINT16(offset, data); + label_ptr = header + (offset & 0x3fff); + /* + * We must verify that the offset is valid by + * checking that it is less than the current data + * pointer and that it isn't off the end of the + * packet. + */ + if (label_ptr > data || label_ptr >= data_end) + break; + (void) get_domain_name(header, label_ptr, data_end, + name, namend); + return (data); + } else { + if (len > (data_end - data)) { + /* + * The label isn't entirely contained + * within the packet. Don't read it. The + * caller checks that the data pointer is + * not beyond the end after we've + * incremented it. + */ + data = data_end; + break; + } + while (len > 0 && name < (namend - 2)) { + *name = *data; + name++; + data++; + len--; + } + *name = '.'; + name++; + } + } + *name = '\0'; + return (data); +} + +static size_t +print_domain_name(char *line, const uchar_t *header, const uchar_t *data, + const uchar_t *data_end) +{ + char name[NS_MAXDNAME]; + const uchar_t *new_data; + + new_data = get_domain_name(header, data, data_end, name, + name + sizeof (name)); + + (void) sprintf(line, "%s", name); + return (new_data - data); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ether.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ether.c new file mode 100644 index 0000000..5c6bde0 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ether.c @@ -0,0 +1,1802 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stddef.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/sysmacros.h> +#include <sys/socket.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <sys/ib/clients/ibd/ibd.h> +#include <sys/ethernet.h> +#include <sys/vlan.h> +#include <sys/zone.h> +#include <inet/iptun.h> +#include <sys/byteorder.h> +#include <limits.h> +#include <inet/ip.h> +#include <inet/ip6.h> +#include <net/trill.h> + +#include "at.h" +#include "snoop.h" + +static headerlen_fn_t ether_header_len, fddi_header_len, tr_header_len, + ib_header_len, ipnet_header_len, ipv4_header_len, ipv6_header_len; +static interpreter_fn_t interpret_ether, interpret_fddi, interpret_tr, + interpret_ib, interpret_ipnet, interpret_iptun; +static void addr_copy_swap(struct ether_addr *, struct ether_addr *); +static int tr_machdr_len(char *, int *, int *); + +interface_t *interface; +interface_t INTERFACES[] = { + + /* IEEE 802.3 CSMA/CD network */ + { DL_CSMACD, 1550, 12, 2, ETHERTYPE_IP, ETHERTYPE_IPV6, + ether_header_len, interpret_ether, B_TRUE }, + + /* Ethernet Bus */ + { DL_ETHER, 1550, 12, 2, ETHERTYPE_IP, ETHERTYPE_IPV6, + ether_header_len, interpret_ether, B_TRUE }, + + /* Fiber Distributed data interface */ + { DL_FDDI, 4500, 19, 2, ETHERTYPE_IP, ETHERTYPE_IPV6, + fddi_header_len, interpret_fddi, B_FALSE }, + + /* Token Ring interface */ + { DL_TPR, 17800, 0, 2, ETHERTYPE_IP, ETHERTYPE_IPV6, + tr_header_len, interpret_tr, B_FALSE }, + + /* Infiniband */ + { DL_IB, 4096, 0, 2, ETHERTYPE_IP, ETHERTYPE_IPV6, + ib_header_len, interpret_ib, B_TRUE }, + + /* ipnet */ + { DL_IPNET, INT_MAX, 1, 1, IPV4_VERSION, IPV6_VERSION, + ipnet_header_len, interpret_ipnet, B_TRUE }, + + /* IPv4 tunnel */ + { DL_IPV4, 0, 9, 1, IPPROTO_ENCAP, IPPROTO_IPV6, + ipv4_header_len, interpret_iptun, B_FALSE }, + + /* IPv6 tunnel */ + { DL_IPV6, 0, 40, 1, IPPROTO_ENCAP, IPPROTO_IPV6, + ipv6_header_len, interpret_iptun, B_FALSE }, + + /* 6to4 tunnel */ + { DL_6TO4, 0, 9, 1, IPPROTO_ENCAP, IPPROTO_IPV6, + ipv4_header_len, interpret_iptun, B_FALSE }, + + { (uint_t)-1, 0, 0, 0, 0, NULL, NULL, B_FALSE } +}; + +/* externals */ +extern char *dlc_header; +extern int pi_frame; +extern int pi_time_hour; +extern int pi_time_min; +extern int pi_time_sec; +extern int pi_time_usec; + +char *printether(); +char *print_ethertype(); +static char *print_etherinfo(); + +char *print_fc(); +char *print_smttype(); +char *print_smtclass(); + +struct ether_addr ether_broadcast = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; +static char *data; /* current data buffer */ +static int datalen; /* current data buffer length */ +static const struct ether_addr all_isis_rbridges = ALL_ISIS_RBRIDGES; + +uint_t +interpret_ether(int flags, char *header, int elen, int origlen) +{ + struct ether_header *e = (struct ether_header *)header; + uchar_t *off, *ieeestart; + int len; + int ieee8023 = 0; + extern char *dst_name; + int ethertype; + struct ether_vlan_extinfo *evx = NULL; + int blen = MAX(origlen, ETHERMTU); + boolean_t trillpkt = B_FALSE; + uint16_t tci = 0; + + if (data != NULL && datalen != 0 && datalen < blen) { + free(data); + data = NULL; + datalen = 0; + } + if (!data) { + data = (char *)malloc(blen); + if (!data) + pr_err("Warning: malloc failure"); + datalen = blen; + } +inner_pkt: + if (origlen < 14) { + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "RUNT (short packet - %d bytes)", + origlen); + } + if (flags & F_DTAIL) + show_header("RUNT: ", "Short packet", origlen); + return (elen); + } + if (elen < 14) + return (elen); + + if (memcmp(&e->ether_dhost, ðer_broadcast, + sizeof (struct ether_addr)) == 0) + dst_name = "(broadcast)"; + else if (e->ether_dhost.ether_addr_octet[0] & 1) + dst_name = "(multicast)"; + + ethertype = ntohs(e->ether_type); + + /* + * The 14 byte ether header screws up alignment + * of the rest of the packet for 32 bit aligned + * architectures like SPARC. Alas, we have to copy + * the rest of the packet in order to align it. + */ + len = elen - sizeof (struct ether_header); + off = (uchar_t *)(e + 1); + + if (ethertype == ETHERTYPE_VLAN) { + if (origlen < sizeof (struct ether_vlan_header)) { + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "RUNT (short VLAN packet - %d bytes)", + origlen); + } + if (flags & F_DTAIL) { + show_header("RUNT: ", "Short VLAN packet", + origlen); + } + return (elen); + } + if (len < sizeof (struct ether_vlan_extinfo)) + return (elen); + + evx = (struct ether_vlan_extinfo *)off; + off += sizeof (struct ether_vlan_extinfo); + len -= sizeof (struct ether_vlan_extinfo); + + ethertype = ntohs(evx->ether_type); + tci = ntohs(evx->ether_tci); + } + + if (ethertype <= 1514) { + /* + * Fake out the IEEE 802.3 packets. + * Should be DSAP=0xAA, SSAP=0xAA, control=0x03 + * then three padding bytes of zero (OUI), + * followed by a normal ethernet-type packet. + */ + ieee8023 = ethertype; + ieeestart = off; + if (off[0] == 0xAA && off[1] == 0xAA) { + ethertype = ntohs(*(ushort_t *)(off + 6)); + off += 8; + len -= 8; + } else { + ethertype = 0; + off += 3; + len -= 3; + } + } + + if (flags & F_SUM) { + /* + * Set the flag that says don't display VLAN information. + * If it needs to change, that will be done later if the + * packet is VLAN tagged and if snoop is in its default + * summary mode. + */ + set_vlan_id(0); + if (evx == NULL) { + if (ethertype == 0 && ieee8023 > 0) { + (void) sprintf(get_sum_line(), + "ETHER 802.3 SSAP %02X DSAP %02X, " + "size=%d bytes", ieeestart[0], ieeestart[1], + origlen); + } else { + (void) sprintf(get_sum_line(), + "ETHER Type=%04X (%s), size=%d bytes", + ethertype, print_ethertype(ethertype), + origlen); + } + } else { + if (ethertype == 0 && ieee8023 > 0) { + (void) sprintf(get_sum_line(), + "ETHER 802.3 SSAP %02X DSAP %02X, " + "VLAN ID=%hu, size=%d bytes", ieeestart[0], + ieeestart[1], VLAN_ID(tci), origlen); + } else { + (void) sprintf(get_sum_line(), + "ETHER Type=%04X (%s), VLAN ID=%hu, " + "size=%d bytes", ethertype, + print_ethertype(ethertype), VLAN_ID(tci), + origlen); + } + + if (!(flags & F_ALLSUM)) + set_vlan_id(VLAN_ID(tci)); + } + } + + if (flags & F_DTAIL) { + show_header("ETHER: ", "Ether Header", elen); + show_space(); + if (!trillpkt) { + (void) sprintf(get_line(0, 0), + "Packet %d arrived at %d:%02d:%d.%05d", + pi_frame, + pi_time_hour, pi_time_min, pi_time_sec, + pi_time_usec / 10); + (void) sprintf(get_line(0, 0), + "Packet size = %d bytes", + elen, elen); + } + (void) sprintf(get_line(0, 6), + "Destination = %s, %s", + printether(&e->ether_dhost), + print_etherinfo(&e->ether_dhost)); + (void) sprintf(get_line(6, 6), + "Source = %s, %s", + printether(&e->ether_shost), + print_etherinfo(&e->ether_shost)); + if (evx != NULL) { + (void) sprintf(get_line(0, 0), + "VLAN ID = %hu", VLAN_ID(tci)); + (void) sprintf(get_line(0, 0), + "VLAN Priority = %hu", VLAN_PRI(tci)); + } + if (ieee8023 > 0) { + (void) sprintf(get_line(12, 2), + "IEEE 802.3 length = %d bytes", ieee8023); + /* Print LLC only for non-TCP/IP packets */ + if (ethertype == 0) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "SSAP = %02X, DSAP = %02X, CTRL = %02X", + ieeestart[0], ieeestart[1], ieeestart[2]); + } + } + if (ethertype != 0 || ieee8023 == 0) + (void) sprintf(get_line(12, 2), + "Ethertype = %04X (%s)", + ethertype, print_ethertype(ethertype)); + show_space(); + } + + /* + * We cannot trust the length field in the header to be correct. + * But we should continue to process the packet. Then user can + * notice something funny in the header. + * Go to the next protocol layer only if data have been + * copied. + */ + if (len > 0 && (off + len <= (uchar_t *)e + elen)) { + (void) memmove(data, off, len); + + if (!trillpkt && ethertype == ETHERTYPE_TRILL) { + ethertype = interpret_trill(flags, &e, data, &len); + /* Decode inner Ethernet frame */ + if (ethertype != 0) { + evx = NULL; + trillpkt = B_TRUE; + (void) memmove(data, e, len); + e = (struct ether_header *)data; + origlen = len; + elen = len; + goto inner_pkt; + } + } + + switch (ethertype) { + case ETHERTYPE_IP: + (void) interpret_ip(flags, (struct ip *)data, len); + break; + /* Just in case it is decided to add this type */ + case ETHERTYPE_IPV6: + (void) interpret_ipv6(flags, (ip6_t *)data, len); + break; + case ETHERTYPE_ARP: + case ETHERTYPE_REVARP: + interpret_arp(flags, (struct arphdr *)data, len); + break; + case ETHERTYPE_PPPOED: + case ETHERTYPE_PPPOES: + (void) interpret_pppoe(flags, (poep_t *)data, len); + break; + case ETHERTYPE_AARP: /* AppleTalk */ + interpret_aarp(flags, data, len); + break; + case ETHERTYPE_AT: + interpret_at(flags, (struct ddp_hdr *)data, len); + break; + case 0: + if (ieee8023 == 0) + break; + switch (ieeestart[0]) { + case 0xFE: + interpret_isis(flags, data, len, + memcmp(&e->ether_dhost, &all_isis_rbridges, + sizeof (struct ether_addr)) == 0); + break; + case 0x42: + interpret_bpdu(flags, data, len); + break; + } + break; + } + } + + return (elen); +} + +/* + * Return the length of the ethernet header. In the case + * where we have a VLAN tagged packet, return the length of + * the ethernet header plus the length of the VLAN tag. + * + * INPUTS: e - A buffer pointer. Passing a NULL pointer + * is not allowed, e must be non-NULL. + * OUTPUTS: Return the size of an untagged ethernet header + * if the packet is not VLAN tagged, and the size + * of an untagged ethernet header plus the size of + * a VLAN header otherwise. + */ +uint_t +ether_header_len(char *e, size_t msgsize) +{ + uint16_t ether_type = 0; + + if (msgsize < sizeof (struct ether_header)) + return (0); + + e += (offsetof(struct ether_header, ether_type)); + + GETINT16(ether_type, e); + + if (ether_type == (uint16_t)ETHERTYPE_VLAN) { + return (sizeof (struct ether_vlan_header)); + } else { + return (sizeof (struct ether_header)); + } +} + + +/* + * Table of Ethertypes. + * Some of the more popular entries + * are at the beginning of the table + * to reduce search time. + */ +struct ether_type { + int e_type; + char *e_name; +} ether_type [] = { +ETHERTYPE_IP, "IP", +ETHERTYPE_ARP, "ARP", +ETHERTYPE_REVARP, "RARP", +ETHERTYPE_IPV6, "IPv6", +ETHERTYPE_PPPOED, "PPPoE Discovery", +ETHERTYPE_PPPOES, "PPPoE Session", +ETHERTYPE_TRILL, "TRILL", +/* end of popular entries */ +ETHERTYPE_PUP, "Xerox PUP", +0x0201, "Xerox PUP", +0x0400, "Nixdorf", +0x0600, "Xerox NS IDP", +0x0601, "XNS Translation", +0x0801, "X.75 Internet", +0x0802, "NBS Internet", +0x0803, "ECMA Internet", +0x0804, "CHAOSnet", +0x0805, "X.25 Level 3", +0x0807, "XNS Compatibility", +0x081C, "Symbolics Private", +0x0888, "Xyplex", +0x0889, "Xyplex", +0x088A, "Xyplex", +0x0900, "Ungermann-Bass network debugger", +0x0A00, "Xerox IEEE802.3 PUP", +0x0A01, "Xerox IEEE802.3 PUP Address Translation", +0x0BAD, "Banyan Systems", +0x0BAF, "Banyon VINES Echo", +0x1000, "Berkeley Trailer negotiation", +0x1000, "IP trailer (0)", +0x1001, "IP trailer (1)", +0x1002, "IP trailer (2)", +0x1003, "IP trailer (3)", +0x1004, "IP trailer (4)", +0x1005, "IP trailer (5)", +0x1006, "IP trailer (6)", +0x1007, "IP trailer (7)", +0x1008, "IP trailer (8)", +0x1009, "IP trailer (9)", +0x100a, "IP trailer (10)", +0x100b, "IP trailer (11)", +0x100c, "IP trailer (12)", +0x100d, "IP trailer (13)", +0x100e, "IP trailer (14)", +0x100f, "IP trailer (15)", +0x1234, "DCA - Multicast", +0x1600, "VALID system protocol", +0x1989, "Aviator", +0x3C00, "3Com NBP virtual circuit datagram", +0x3C01, "3Com NBP System control datagram", +0x3C02, "3Com NBP Connect request (virtual cct)", +0x3C03, "3Com NBP Connect response", +0x3C04, "3Com NBP Connect complete", +0x3C05, "3Com NBP Close request (virtual cct)", +0x3C06, "3Com NBP Close response", +0x3C07, "3Com NBP Datagram (like XNS IDP)", +0x3C08, "3Com NBP Datagram broadcast", +0x3C09, "3Com NBP Claim NetBIOS name", +0x3C0A, "3Com NBP Delete Netbios name", +0x3C0B, "3Com NBP Remote adaptor status request", +0x3C0C, "3Com NBP Remote adaptor response", +0x3C0D, "3Com NBP Reset", +0x4242, "PCS Basic Block Protocol", +0x4321, "THD - Diddle", +0x5208, "BBN Simnet Private", +0x6000, "DEC unass, experimental", +0x6001, "DEC Dump/Load", +0x6002, "DEC Remote Console", +0x6003, "DECNET Phase IV, DNA Routing", +0x6004, "DEC LAT", +0x6005, "DEC Diagnostic", +0x6006, "DEC customer protocol", +0x6007, "DEC Local Area VAX Cluster (LAVC)", +0x6008, "DEC unass (AMBER?)", +0x6009, "DEC unass (MUMPS?)", +0x6010, "3Com", +0x6011, "3Com", +0x6012, "3Com", +0x6013, "3Com", +0x6014, "3Com", +0x7000, "Ungermann-Bass download", +0x7001, "Ungermann-Bass NIUs", +0x7002, "Ungermann-Bass diagnostic/loopback", +0x7003, "Ungermann-Bass ? (NMC to/from UB Bridge)", +0x7005, "Ungermann-Bass Bridge Spanning Tree", +0x7007, "OS/9 Microware", +0x7009, "OS/9 Net?", +0x7020, "Sintrom", +0x7021, "Sintrom", +0x7022, "Sintrom", +0x7023, "Sintrom", +0x7024, "Sintrom", +0x7025, "Sintrom", +0x7026, "Sintrom", +0x7027, "Sintrom", +0x7028, "Sintrom", +0x7029, "Sintrom", +0x8003, "Cronus VLN", +0x8004, "Cronus Direct", +0x8005, "HP Probe protocol", +0x8006, "Nestar", +0x8008, "AT&T/Stanford Univ", +0x8010, "Excelan", +0x8013, "SGI diagnostic", +0x8014, "SGI network games", +0x8015, "SGI reserved", +0x8016, "SGI XNS NameServer, bounce server", +0x8019, "Apollo DOMAIN", +0x802E, "Tymshare", +0x802F, "Tigan,", +0x8036, "Aeonic Systems", +0x8037, "IPX (Novell Netware)", +0x8038, "DEC LanBridge Management", +0x8039, "DEC unass (DSM/DTP?)", +0x803A, "DEC unass (Argonaut Console?)", +0x803B, "DEC unass (VAXELN?)", +0x803C, "DEC unass (NMSV? DNA Naming Service?)", +0x803D, "DEC Ethernet CSMA/CD Encryption Protocol", +0x803E, "DEC unass (DNA Time Service?)", +0x803F, "DEC LAN Traffic Monitor Protocol", +0x8040, "DEC unass (NetBios Emulator?)", +0x8041, "DEC unass (MS/DOS?, Local Area System Transport?)", +0x8042, "DEC unass", +0x8044, "Planning Research Corp.", +0x8046, "AT&T", +0x8047, "AT&T", +0x8049, "ExperData", +0x805B, "VMTP", +0x805C, "Stanford V Kernel, version 6.0", +0x805D, "Evans & Sutherland", +0x8060, "Little Machines", +0x8062, "Counterpoint", +0x8065, "University of Mass. at Amherst", +0x8066, "University of Mass. at Amherst", +0x8067, "Veeco Integrated Automation", +0x8068, "General Dynamics", +0x8069, "AT&T", +0x806A, "Autophon", +0x806C, "ComDesign", +0x806D, "Compugraphic Corp", +0x806E, "Landmark", +0x806F, "Landmark", +0x8070, "Landmark", +0x8071, "Landmark", +0x8072, "Landmark", +0x8073, "Landmark", +0x8074, "Landmark", +0x8075, "Landmark", +0x8076, "Landmark", +0x8077, "Landmark", +0x807A, "Matra", +0x807B, "Dansk Data Elektronik", +0x807C, "Merit Internodal", +0x807D, "Vitalink", +0x807E, "Vitalink", +0x807F, "Vitalink", +0x8080, "Vitalink TransLAN III Management", +0x8081, "Counterpoint", +0x8082, "Counterpoint", +0x8083, "Counterpoint", +0x8088, "Xyplex", +0x8089, "Xyplex", +0x808A, "Xyplex", +0x809B, "EtherTalk (AppleTalk over Ethernet)", +0x809C, "Datability", +0x809D, "Datability", +0x809E, "Datability", +0x809F, "Spider Systems", +0x80A3, "Nixdorf", +0x80A4, "Siemens Gammasonics", +0x80C0, "DCA Data Exchange Cluster", +0x80C6, "Pacer Software", +0x80C7, "Applitek Corp", +0x80C8, "Intergraph", +0x80C9, "Intergraph", +0x80CB, "Intergraph", +0x80CC, "Intergraph", +0x80CA, "Intergraph", +0x80CD, "Harris Corp", +0x80CE, "Harris Corp", +0x80CF, "Taylor Instrument", +0x80D0, "Taylor Instrument", +0x80D1, "Taylor Instrument", +0x80D2, "Taylor Instrument", +0x80D3, "Rosemount Corp", +0x80D4, "Rosemount Corp", +0x80D5, "IBM SNA Services over Ethernet", +0x80DD, "Varian Associates", +0x80DE, "TRFS", +0x80DF, "TRFS", +0x80E0, "Allen-Bradley", +0x80E1, "Allen-Bradley", +0x80E2, "Allen-Bradley", +0x80E3, "Allen-Bradley", +0x80E4, "Datability", +0x80F2, "Retix", +0x80F3, "AARP (Appletalk)", +0x80F4, "Kinetics", +0x80F5, "Kinetics", +0x80F7, "Apollo", +0x80FF, "Wellfleet Communications", +0x8102, "Wellfleet Communications", +0x8107, "Symbolics Private", +0x8108, "Symbolics Private", +0x8109, "Symbolics Private", +0x812B, "Talaris", +0x8130, "Waterloo", +0x8131, "VG Lab", +0x8137, "Novell (old) NetWare IPX", +0x8138, "Novell", +0x814C, "SNMP over Ethernet", +0x817D, "XTP", +0x81D6, "Lantastic", +0x8888, "HP LanProbe test?", +0x9000, "Loopback", +0x9001, "3Com, XNS Systems Management", +0x9002, "3Com, TCP/IP Systems Management", +0x9003, "3Com, loopback detection", +0xAAAA, "DECNET (VAX 6220 DEBNI)", +0xFF00, "BBN VITAL-LanBridge cache wakeups", +0, "", +}; + +char * +print_fc(uint_t type) +{ + + switch (type) { + case 0x50: return ("LLC"); + case 0x4f: return ("SMT NSA"); + case 0x41: return ("SMT Info"); + default: return ("Unknown"); + } +} + +char * +print_smtclass(uint_t type) +{ + switch (type) { + case 0x01: return ("NIF"); + case 0x02: return ("SIF Conf"); + case 0x03: return ("SIF Oper"); + case 0x04: return ("ECF"); + case 0x05: return ("RAF"); + case 0x06: return ("RDF"); + case 0x07: return ("SRF"); + case 0x08: return ("PMF Get"); + case 0x09: return ("PMF Change"); + case 0x0a: return ("PMF Add"); + case 0x0b: return ("PMF Remove"); + case 0xff: return ("ESF"); + default: return ("Unknown"); + } + +} +char * +print_smttype(uint_t type) +{ + switch (type) { + case 0x01: return ("Announce"); + case 0x02: return ("Request"); + case 0x03: return ("Response"); + default: return ("Unknown"); + } + +} +char * +print_ethertype(int type) +{ + int i; + + for (i = 0; ether_type[i].e_type; i++) + if (type == ether_type[i].e_type) + return (ether_type[i].e_name); + if (type < 1500) + return ("LLC/802.3"); + + return ("Unknown"); +} + +#define MAX_RDFLDS 14 /* changed to 14 from 8 as per IEEE */ +#define TR_FN_ADDR 0x80 /* dest addr is functional */ +#define TR_SR_ADDR 0x80 /* MAC utilizes source route */ +#define ACFCDASA_LEN 14 /* length of AC|FC|DA|SA */ +#define TR_MAC_MASK 0xc0 +#define TR_AC 0x00 /* Token Ring access control */ +#define TR_LLC_FC 0x40 /* Token Ring llc frame control */ +#define LSAP_SNAP 0xaa +#define LLC_SNAP_HDR_LEN 8 +#define LLC_HDR1_LEN 3 /* DON'T use sizeof(struct llc_hdr1) */ +#define CNTL_LLC_UI 0x03 /* un-numbered information packet */ + +/* + * Source Routing Route Information field. + */ +struct tr_ri { +#if defined(_BIT_FIELDS_HTOL) + uchar_t rt:3; /* routing type */ + uchar_t len:5; /* length */ + uchar_t dir:1; /* direction bit */ + uchar_t mtu:3; /* largest frame */ + uchar_t res:4; /* reserved */ +#elif defined(_BIT_FIELDS_LTOH) + uchar_t len:5; /* length */ + uchar_t rt:3; /* routing type */ + uchar_t res:4; /* reserved */ + uchar_t mtu:3; /* largest frame */ + uchar_t dir:1; /* direction bit */ +#endif +/* + * In little endian machine, the ring field has to be stored in a + * ushort_t type. This implies that it is not possible to have a + * layout of bit field to represent bridge and ring. + * + * If the compiler uses _BIT_FIELDS_HTOL and it is a big endian + * machine, the following bit field definition will work. + * + * struct tr_rd { + * ushort_t bridge:4; + * ushort_t ring:12; + * } rd[MAX_RDFLDS]; + * + * If the compiler uses _BIT_FIELDS_LTOH and it is a big endian + * machine, the definition can be changed to + * + * struct tr_rd { + * ushort_t bridge:4; + * ushort_t ring:12; + * } rd[MAX_RDFLDS]; + * + * With little endian machine, we need to use 2 macroes. For + * simplicity, since the macroes work for both big and little + * endian machines, we will not use bit fields for the + * definition. + */ +#define bridge(route) (ntohs((ushort_t)(route)) & 0x0F) +#define ring(route) (ntohs((ushort_t)(route)) >> 4) + + ushort_t rd[MAX_RDFLDS]; /* route designator fields */ +}; + +struct tr_header { + uchar_t ac; + uchar_t fc; + struct ether_addr dhost; + struct ether_addr shost; + struct tr_ri ri; +}; + +struct llc_snap_hdr { + uchar_t d_lsap; /* destination service access point */ + uchar_t s_lsap; /* source link service access point */ + uchar_t control; /* short control field */ + uchar_t org[3]; /* Ethernet style organization field */ + ushort_t type; /* Ethernet style type field */ +}; + +struct ether_addr tokenbroadcastaddr2 = { + 0xc0, 0x00, 0xff, 0xff, 0xff, 0xff +}; + +int Mtutab[] = {516, 1470, 2052, 4472, 8144, 11407, 17800}; + +char * +print_sr(struct tr_ri *rh) +{ + int hops, ii; + static char line[512]; + + sprintf(line, "TR Source Route dir=%d, mtu=%d", + rh->dir, Mtutab[rh->mtu]); + + hops = (int)(rh->len - 2) / (int)2; + + if (hops) { + sprintf(line+strlen(line), ", Route: "); + for (ii = 0; ii < hops; ii++) { + if (! bridge(rh->rd[ii])) { + sprintf(line+strlen(line), "(%d)", + ring(rh->rd[ii])); + } else { + sprintf(line+strlen(line), "(%d)%d", + ring(rh->rd[ii]), bridge(rh->rd[ii])); + } + } + } + return (&line[0]); +} + +uint_t +interpret_tr(int flags, caddr_t e, int elen, int origlen) +{ + struct tr_header *mh; + struct tr_ri *rh; + uchar_t fc; + struct llc_snap_hdr *snaphdr; + char *off; + int maclen, len; + boolean_t data_copied = B_FALSE; + extern char *dst_name, *src_name; + int ethertype; + int is_llc = 0, is_snap = 0, source_routing = 0; + int blen = MAX(origlen, 17800); + + if (data != NULL && datalen != 0 && datalen < blen) { + free(data); + data = NULL; + datalen = 0; + } + if (!data) { + data = (char *)malloc(blen); + if (!data) + pr_err("Warning: malloc failure"); + datalen = blen; + } + + if (origlen < ACFCDASA_LEN) { + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "RUNT (short packet - %d bytes)", + origlen); + } + if (flags & F_DTAIL) + show_header("RUNT: ", "Short packet", origlen); + return (elen); + } + if (elen < ACFCDASA_LEN) + return (elen); + + mh = (struct tr_header *)e; + rh = (struct tr_ri *)&mh->ri; + fc = mh->fc; + + if (is_llc = tr_machdr_len(e, &maclen, &source_routing)) { + snaphdr = (struct llc_snap_hdr *)(e + maclen); + if (snaphdr->d_lsap == LSAP_SNAP && + snaphdr->s_lsap == LSAP_SNAP && + snaphdr->control == CNTL_LLC_UI) { + is_snap = 1; + } + } + + if (memcmp(&mh->dhost, ðer_broadcast, + sizeof (struct ether_addr)) == 0) + dst_name = "(broadcast)"; + else if (memcmp(&mh->dhost, &tokenbroadcastaddr2, + sizeof (struct ether_addr)) == 0) + dst_name = "(mac broadcast)"; + else if (mh->dhost.ether_addr_octet[0] & TR_FN_ADDR) + dst_name = "(functional)"; + + if (is_snap) + ethertype = ntohs(snaphdr->type); + else { + src_name = print_etherinfo(&mh->shost); + dst_name = print_etherinfo(&mh->dhost); + } + + /* + * The 14 byte ether header screws up alignment + * of the rest of the packet for 32 bit aligned + * architectures like SPARC. Alas, we have to copy + * the rest of the packet in order to align it. + */ + if (is_llc) { + if (is_snap) { + len = elen - (maclen + LLC_SNAP_HDR_LEN); + off = (char *)(e + maclen + LLC_SNAP_HDR_LEN); + } else { + len = elen - (maclen + LLC_HDR1_LEN); + off = (char *)(e + maclen + LLC_HDR1_LEN); + } + } else { + len = elen - maclen; + off = (char *)(e + maclen); + } + + if (len > 0 && (off + len <= (char *)e + elen)) { + (void) memcpy(data, off, len); + data_copied = B_TRUE; + } + + if (flags & F_SUM) { + if (source_routing) + sprintf(get_sum_line(), print_sr(rh)); + + if (is_llc) { + if (is_snap) { + (void) sprintf(get_sum_line(), "TR LLC w/SNAP " + "Type=%04X (%s), size=%d bytes", + ethertype, + print_ethertype(ethertype), + origlen); + } else { + (void) sprintf(get_sum_line(), "TR LLC, but no " + "SNAP encoding, size = %d bytes", + origlen); + } + } else { + (void) sprintf(get_sum_line(), + "TR MAC FC=%02X (%s), size = %d bytes", + fc, print_fc(fc), origlen); + } + } + + if (flags & F_DTAIL) { + show_header("TR: ", "TR Header", elen); + show_space(); + (void) sprintf(get_line(0, 0), + "Packet %d arrived at %d:%02d:%d.%05d", + pi_frame, + pi_time_hour, pi_time_min, pi_time_sec, + pi_time_usec / 10); + (void) sprintf(get_line(0, 0), + "Packet size = %d bytes", + elen); + (void) sprintf(get_line(0, 1), + "Frame Control = %02x (%s)", + fc, print_fc(fc)); + (void) sprintf(get_line(2, 6), + "Destination = %s, %s", + printether(&mh->dhost), + print_etherinfo(&mh->dhost)); + (void) sprintf(get_line(8, 6), + "Source = %s, %s", + printether(&mh->shost), + print_etherinfo(&mh->shost)); + + if (source_routing) + sprintf(get_line(ACFCDASA_LEN, rh->len), print_sr(rh)); + + if (is_llc) { + (void) sprintf(get_line(maclen, 1), + "Dest Service Access Point = %02x", + snaphdr->d_lsap); + (void) sprintf(get_line(maclen+1, 1), + "Source Service Access Point = %02x", + snaphdr->s_lsap); + (void) sprintf(get_line(maclen+2, 1), + "Control = %02x", + snaphdr->control); + if (is_snap) { + (void) sprintf(get_line(maclen+3, 3), + "SNAP Protocol Id = %02x%02x%02x", + snaphdr->org[0], snaphdr->org[1], + snaphdr->org[2]); + } + } + + if (is_snap) { + (void) sprintf(get_line(maclen+6, 2), + "SNAP Type = %04X (%s)", + ethertype, print_ethertype(ethertype)); + } + + show_space(); + } + + /* go to the next protocol layer */ + if (is_snap && data_copied) { + switch (ethertype) { + case ETHERTYPE_IP: + (void) interpret_ip(flags, (struct ip *)data, len); + break; + /* Just in case it is decided to add this type */ + case ETHERTYPE_IPV6: + (void) interpret_ipv6(flags, (ip6_t *)data, len); + break; + case ETHERTYPE_ARP: + case ETHERTYPE_REVARP: + interpret_arp(flags, (struct arphdr *)data, len); + break; + case ETHERTYPE_AARP: /* AppleTalk */ + interpret_aarp(flags, data, len); + break; + case ETHERTYPE_AT: + interpret_at(flags, (struct ddp_hdr *)data, len); + break; + default: + break; + } + } + + return (elen); +} + + +/* + * stuffs length of mac and ri fields into *lenp + * returns: + * 0: mac frame + * 1: llc frame + */ +static int +tr_machdr_len(char *e, int *lenp, int *source_routing) +{ + struct tr_header *mh; + struct tr_ri *rh; + uchar_t fc; + + mh = (struct tr_header *)e; + rh = (struct tr_ri *)&mh->ri; + fc = mh->fc; + + if (mh->shost.ether_addr_octet[0] & TR_SR_ADDR) { + *lenp = ACFCDASA_LEN + rh->len; + *source_routing = 1; + } else { + *lenp = ACFCDASA_LEN; + *source_routing = 0; + } + + if ((fc & TR_MAC_MASK) == 0) + return (0); /* it's a MAC frame */ + else + return (1); /* it's an LLC frame */ +} + +uint_t +tr_header_len(char *e, size_t msgsize) +{ + struct llc_snap_hdr *snaphdr; + int len = 0, source_routing; + + if (tr_machdr_len(e, &len, &source_routing) == 0) + return (len); /* it's a MAC frame */ + + if (msgsize < sizeof (struct llc_snap_hdr)) + return (0); + + snaphdr = (struct llc_snap_hdr *)(e + len); + if (snaphdr->d_lsap == LSAP_SNAP && + snaphdr->s_lsap == LSAP_SNAP && + snaphdr->control == CNTL_LLC_UI) + len += LLC_SNAP_HDR_LEN; /* it's a SNAP frame */ + else + len += LLC_HDR1_LEN; + + return (len); +} + +struct fddi_header { + uchar_t fc; + struct ether_addr dhost, shost; + uchar_t dsap, ssap, ctl, proto_id[3]; + ushort_t type; +}; + +uint_t +interpret_fddi(int flags, caddr_t e, int elen, int origlen) +{ + struct fddi_header fhdr, *f = &fhdr; + char *off; + int len; + boolean_t data_copied = B_FALSE; + extern char *dst_name, *src_name; + int ethertype; + int is_llc = 0, is_smt = 0, is_snap = 0; + int blen = MAX(origlen, 4500); + + if (data != NULL && datalen != 0 && datalen < blen) { + free(data); + data = NULL; + datalen = 0; + } + if (!data) { + data = (char *)malloc(blen); + if (!data) + pr_err("Warning: malloc failure"); + datalen = blen; + } + + if (origlen < 13) { + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "RUNT (short packet - %d bytes)", + origlen); + } + if (flags & F_DTAIL) + show_header("RUNT: ", "Short packet", origlen); + return (elen); + } + if (elen < 13) + return (elen); + + (void) memcpy(&f->fc, e, sizeof (f->fc)); + addr_copy_swap(&f->dhost, (struct ether_addr *)(e+1)); + addr_copy_swap(&f->shost, (struct ether_addr *)(e+7)); + + if ((f->fc&0x50) == 0x50) { + is_llc = 1; + (void) memcpy(&f->dsap, e+13, sizeof (f->dsap)); + (void) memcpy(&f->ssap, e+14, sizeof (f->ssap)); + (void) memcpy(&f->ctl, e+15, sizeof (f->ctl)); + if (f->dsap == 0xaa && f->ssap == 0xaa) { + is_snap = 1; + (void) memcpy(&f->proto_id, e+16, sizeof (f->proto_id)); + (void) memcpy(&f->type, e+19, sizeof (f->type)); + } + } else { + if ((f->fc&0x41) == 0x41 || (f->fc&0x4f) == 0x4f) { + is_smt = 1; + } + } + + + if (memcmp(&f->dhost, ðer_broadcast, + sizeof (struct ether_addr)) == 0) + dst_name = "(broadcast)"; + else if (f->dhost.ether_addr_octet[0] & 0x01) + dst_name = "(multicast)"; + + if (is_snap) + ethertype = ntohs(f->type); + else { + src_name = print_etherinfo(&f->shost); + dst_name = print_etherinfo(&f->dhost); + } + + /* + * The 14 byte ether header screws up alignment + * of the rest of the packet for 32 bit aligned + * architectures like SPARC. Alas, we have to copy + * the rest of the packet in order to align it. + */ + if (is_llc) { + if (is_snap) { + len = elen - 21; + off = (char *)(e + 21); + } else { + len = elen - 16; + off = (char *)(e + 16); + } + } else { + len = elen - 13; + off = (char *)(e + 13); + } + + if (len > 0 && (off + len <= (char *)e + elen)) { + (void) memcpy(data, off, len); + data_copied = B_TRUE; + } + + if (flags & F_SUM) { + if (is_llc) { + if (is_snap) { + (void) sprintf(get_sum_line(), + "FDDI LLC Type=%04X (%s), size = %d bytes", + ethertype, + print_ethertype(ethertype), + origlen); + } else { + (void) sprintf(get_sum_line(), "LLC, but no " + "SNAP encoding, size = %d bytes", + origlen); + } + } else if (is_smt) { + (void) sprintf(get_sum_line(), "SMT Type=%02X (%s), " + "Class = %02X (%s), size = %d bytes", + *(uchar_t *)(data+1), print_smttype(*(data+1)), + *data, print_smtclass(*data), origlen); + } else { + (void) sprintf(get_sum_line(), + "FC=%02X (%s), size = %d bytes", + f->fc, print_fc(f->fc), origlen); + } + } + + if (flags & F_DTAIL) { + show_header("FDDI: ", "FDDI Header", elen); + show_space(); + (void) sprintf(get_line(0, 0), + "Packet %d arrived at %d:%02d:%d.%05d", + pi_frame, + pi_time_hour, pi_time_min, pi_time_sec, + pi_time_usec / 10); + (void) sprintf(get_line(0, 0), + "Packet size = %d bytes", + elen, elen); + (void) sprintf(get_line(0, 6), + "Destination = %s, %s", + printether(&f->dhost), + print_etherinfo(&f->dhost)); + (void) sprintf(get_line(6, 6), + "Source = %s, %s", + printether(&f->shost), + print_etherinfo(&f->shost)); + + if (is_llc) { + (void) sprintf(get_line(12, 2), + "Frame Control = %02x (%s)", + f->fc, print_fc(f->fc)); + (void) sprintf(get_line(12, 2), + "Dest Service Access Point = %02x", + f->dsap); + (void) sprintf(get_line(12, 2), + "Source Service Access Point = %02x", + f->ssap); + (void) sprintf(get_line(12, 2), + "Control = %02x", + f->ctl); + if (is_snap) { + (void) sprintf(get_line(12, 2), + "Protocol Id = %02x%02x%02x", + f->proto_id[0], f->proto_id[1], + f->proto_id[2]); + } + } else if (is_smt) { + (void) sprintf(get_line(12, 2), + "Frame Control = %02x (%s)", + f->fc, print_fc(f->fc)); + (void) sprintf(get_line(12, 2), + "Class = %02x (%s)", + (uchar_t)*data, print_smtclass(*data)); + (void) sprintf(get_line(12, 2), + "Type = %02x (%s)", + *(uchar_t *)(data+1), print_smttype(*(data+1))); + } else { + (void) sprintf(get_line(12, 2), + "FC=%02X (%s), size = %d bytes", + f->fc, print_fc(f->fc), origlen); + } + + if (is_snap) { + (void) sprintf(get_line(12, 2), + "LLC Type = %04X (%s)", + ethertype, print_ethertype(ethertype)); + } + + show_space(); + } + + /* go to the next protocol layer */ + if (is_llc && is_snap && f->ctl == 0x03 && data_copied) { + switch (ethertype) { + case ETHERTYPE_IP: + (void) interpret_ip(flags, (struct ip *)data, len); + break; + /* Just in case it is decided to add this type */ + case ETHERTYPE_IPV6: + (void) interpret_ipv6(flags, (ip6_t *)data, len); + break; + case ETHERTYPE_ARP: + case ETHERTYPE_REVARP: + interpret_arp(flags, (struct arphdr *)data, len); + break; + default: + break; + } + + } + + return (elen); +} + +uint_t +fddi_header_len(char *e, size_t msgsize) +{ + struct fddi_header fhdr, *f = &fhdr; + + if (msgsize < sizeof (struct fddi_header)) + return (0); + + (void) memcpy(&f->fc, e, sizeof (f->fc)); + (void) memcpy(&f->dhost, e+1, sizeof (struct ether_addr)); + (void) memcpy(&f->shost, e+7, sizeof (struct ether_addr)); + + if ((f->fc&0x50) == 0x50) { + (void) memcpy(&f->dsap, e+13, sizeof (f->dsap)); + (void) memcpy(&f->ssap, e+14, sizeof (f->ssap)); + (void) memcpy(&f->ctl, e+15, sizeof (f->ctl)); + if (f->dsap == 0xaa && f->ssap == 0xaa) { + return (21); + } + return (16); + } else { + if ((f->fc&0x41) == 0x41 || (f->fc&0x4f) == 0x4f) { + return (13); + } + } + /* Return the default FDDI header length. */ + return (13); +} + +/* + * Print the given Ethernet address + */ +char * +printether(struct ether_addr *p) +{ + static char buf[256]; + + sprintf(buf, "%x:%x:%x:%x:%x:%x", + p->ether_addr_octet[0], + p->ether_addr_octet[1], + p->ether_addr_octet[2], + p->ether_addr_octet[3], + p->ether_addr_octet[4], + p->ether_addr_octet[5]); + + return (buf); +} + +/* + * Table of Ethernet Address Assignments + * Some of the more popular entries + * are at the beginning of the table + * to reduce search time. Note that the + * e-block's are stored in host byte-order. + */ +struct block_type { + int e_block; + char *e_name; +} ether_block [] = { +0x080020, "Sun", +0x0000C6, "HP", +0x08002B, "DEC", +0x00000F, "NeXT", +0x00000C, "Cisco", +0x080069, "Silicon Graphics", +0x000069, "Silicon Graphics", +0x0000A7, "Network Computing Devices (NCD X-terminal)", +0x08005A, "IBM", +0x0000AC, "Apollo", +0x0180C2, "Standard MAC Group Address", +/* end of popular entries */ +0x000002, "BBN", +0x000010, "Sytek", +0x000011, "Tektronix", +0x000018, "Webster (?)", +0x00001B, "Novell", +0x00001D, "Cabletron", +0x000020, "DIAB (Data Industrier AB)", +0x000021, "SC&C", +0x000022, "Visual Technology", +0x000029, "IMC", +0x00002A, "TRW", +0x00003D, "AT&T", +0x000049, "Apricot Ltd.", +0x000055, "AT&T", +0x00005A, "S & Koch", +0x00005A, "Xerox 806 (unregistered)", +0x00005E, "U.S. Department of Defense (IANA)", +0x000065, "Network General", +0x00006B, "MIPS", +0x000077, "MIPS", +0x000079, "NetWare (?)", +0x00007A, "Ardent", +0x00007B, "Research Machines", +0x00007D, "Harris (3M) (old)", +0x000080, "Imagen(?)", +0x000081, "Synoptics", +0x000084, "Aquila (?)", +0x000086, "Gateway (?)", +0x000089, "Cayman Systems Gatorbox", +0x000093, "Proteon", +0x000094, "Asante", +0x000098, "Cross Com", +0x00009F, "Ameristar Technology", +0x0000A2, "Wellfleet", +0x0000A3, "Network Application Technology", +0x0000A4, "Acorn", +0x0000A6, "Network General", +0x0000A7, "Network Computing Devices (NCD X-terminal)", +0x0000A9, "Network Systems", +0x0000AA, "Xerox", +0x0000B3, "CIMLinc", +0x0000B5, "Datability Terminal Server", +0x0000B7, "Dove Fastnet", +0x0000BC, "Allen-Bradley", +0x0000C0, "Western Digital", +0x0000C8, "Altos", +0x0000C9, "Emulex Terminal Server", +0x0000D0, "Develcon Electronics, Ltd.", +0x0000D1, "Adaptec Inc. Nodem product", +0x0000D7, "Dartmouth College (NED Router)", +0x0000DD, "Gould", +0x0000DE, "Unigraph", +0x0000E2, "Acer Counterpoint", +0x0000E8, "Accton Technology Corporation", +0x0000EE, "Network Designers Limited(?)", +0x0000EF, "Alantec", +0x0000F3, "Gandalf", +0x0000FD, "High Level Hardware (Orion, UK)", +0x000143, "IEEE 802", +0x001700, "Kabel", +0x004010, "Sonic", +0x00608C, "3Com", +0x00800F, "SMC", +0x008019, "Dayna Communications Etherprint product", +0x00802D, "Xylogics, Inc. Annex terminal servers", +0x008035, "Technology Works", +0x008087, "Okidata", +0x00808C, "Frontier Software Development", +0x0080C7, "Xircom Inc.", +0x0080D0, "Computer Products International", +0x0080D3, "Shiva Appletalk-Ethernet interface", +0x0080D4, "Chase Limited", +0x0080F1, "Opus", +0x00AA00, "Intel", +0x00B0D0, "Computer Products International", +0x00DD00, "Ungermann-Bass", +0x00DD01, "Ungermann-Bass", +0x00EFE5, "IBM (3Com card)", +0x020406, "BBN", +0x026060, "3Com", +0x026086, "Satelcom MegaPac (UK)", +0x02E6D3, "Bus-Tech, Inc. (BTI)", +0x080001, "Computer Vision", +0x080002, "3Com (Formerly Bridge)", +0x080003, "ACC (Advanced Computer Communications)", +0x080005, "Symbolics", +0x080007, "Apple", +0x080008, "BBN", +0x080009, "Hewlett-Packard", +0x08000A, "Nestar Systems", +0x08000B, "Unisys", +0x08000D, "ICL", +0x08000E, "NCR", +0x080010, "AT&T", +0x080011, "Tektronix, Inc.", +0x080017, "NSC", +0x08001A, "Data General", +0x08001B, "Data General", +0x08001E, "Apollo", +0x080022, "NBI", +0x080025, "CDC", +0x080026, "Norsk Data (Nord)", +0x080027, "PCS Computer Systems GmbH", +0x080028, "TI Explorer", +0x08002E, "Metaphor", +0x08002F, "Prime Computer", +0x080036, "Intergraph CAE stations", +0x080037, "Fujitsu-Xerox", +0x080038, "Bull", +0x080039, "Spider Systems", +0x08003B, "Torus Systems", +0x08003E, "Motorola VME bus processor module", +0x080041, "DCA Digital Comm. Assoc.", +0x080046, "Sony", +0x080047, "Sequent", +0x080049, "Univation", +0x08004C, "Encore", +0x08004E, "BICC", +0x080056, "Stanford University", +0x080057, "Evans & Sutherland (?)", +0x080067, "Comdesign", +0x080068, "Ridge", +0x08006A, "ATTst (?)", +0x08006E, "Excelan", +0x080075, "DDE (Danish Data Elektronik A/S)", +0x080077, "TSL (now Retix)", +0x08007C, "Vitalink TransLAN III", +0x080080, "XIOS", +0x080081, "Crosfield Electronics", +0x080086, "Imagen/QMS", +0x080087, "Xyplex terminal server", +0x080089, "Kinetics AppleTalk-Ethernet interface", +0x08008B, "Pyramid", +0x08008D, "XyVision", +0x080090, "Retix Inc Bridge", +0x10005A, "IBM", +0x1000D4, "DEC", +0x400003, "NetWare", +0x800010, "AT&T", +0xAA0004, "DEC (DECNET)", +0xC00000, "SMC", +0, "", +}; + +/* + * The oui argument should be in host byte-order to conform with + * the above array's values. + */ +char * +ether_ouiname(uint32_t oui) +{ + uint_t i; + + for (i = 0; ether_block[i].e_block != 0; i++) + if (oui == ether_block[i].e_block) + return (ether_block[i].e_name); + + return (NULL); +} + +/* + * Print the additional Ethernet address info + */ +static char * +print_etherinfo(struct ether_addr *eaddr) +{ + uint_t addr = 0; + char *p = (char *)&addr + 1; + char *ename; + + (void) memcpy(p, eaddr, 3); + + if (memcmp(eaddr, ðer_broadcast, sizeof (struct ether_addr)) == 0) + return ("(broadcast)"); + + addr = ntohl(addr); /* make it right for little-endians */ + ename = ether_ouiname(addr); + + if (ename != NULL) + return (ename); + else + return ((eaddr->ether_addr_octet[0] & 1) ? "(multicast)" : ""); +} + +static uchar_t endianswap[] = { + 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, + 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, + 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, + 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, + 0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, + 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, + 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, + 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, + 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, + 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, + 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, + 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, + 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, + 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, + 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, + 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, + 0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, + 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, + 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, + 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, + 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, + 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, + 0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, + 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd, + 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, + 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, + 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, + 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, + 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, + 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, + 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, + 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff, +}; + +static void +addr_copy_swap(struct ether_addr *pd, struct ether_addr *ps) +{ + pd->ether_addr_octet[0] = endianswap[ps->ether_addr_octet[0]]; + pd->ether_addr_octet[1] = endianswap[ps->ether_addr_octet[1]]; + pd->ether_addr_octet[2] = endianswap[ps->ether_addr_octet[2]]; + pd->ether_addr_octet[3] = endianswap[ps->ether_addr_octet[3]]; + pd->ether_addr_octet[4] = endianswap[ps->ether_addr_octet[4]]; + pd->ether_addr_octet[5] = endianswap[ps->ether_addr_octet[5]]; +} + +/* ARGSUSED */ +uint_t +ib_header_len(char *hdr, size_t msgsize) +{ + return (IPOIB_HDRSIZE); +} + +static uint_t +interpret_ib(int flags, char *header, int elen, int origlen) +{ + struct ipoib_header *hdr = (struct ipoib_header *)header; + char *off; + int len; + unsigned short ethertype; + int blen = MAX(origlen, 4096); + + if (data != NULL && datalen != 0 && datalen < blen) { + free(data); + data = NULL; + datalen = 0; + } + if (data == NULL) { + data = malloc(blen); + if (data == NULL) + pr_err("Warning: malloc failure"); + datalen = blen; + } + if (origlen < IPOIB_HDRSIZE) { + if (flags & F_SUM) + (void) snprintf(get_sum_line(), MAXLINE, + "RUNT (short packet - %d bytes)", origlen); + if (flags & F_DTAIL) + show_header("RUNT: ", "Short packet", origlen); + return (elen); + } + if (elen < IPOIB_HDRSIZE) + return (elen); + + /* + * It is not possible to understand just by looking + * at the header whether this was a broad/multi cast + * packet; thus dst_name is not updated. + */ + ethertype = ntohs(hdr->ipoib_type); + len = elen - IPOIB_HDRSIZE; + off = (char *)(hdr + 1); + (void) memcpy(data, off, len); + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "IPIB Type=%04X (%s), size = %d bytes", + ethertype, + print_ethertype(ethertype), + origlen); + } + + if (flags & F_DTAIL) { + show_header("IPIB: ", "IPIB Header", elen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Packet %d arrived at %d:%02d:%d.%02d", + pi_frame, pi_time_hour, pi_time_min, + pi_time_sec, pi_time_usec / 10000); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Packet size = %d bytes", elen, elen); + (void) snprintf(get_line(0, 2), get_line_remain(), + "Ethertype = %04X (%s)", ethertype, + print_ethertype(ethertype)); + show_space(); + } + + /* Go to the next protocol layer */ + switch (ethertype) { + case ETHERTYPE_IP: + (void) interpret_ip(flags, (struct ip *)data, len); + break; + case ETHERTYPE_IPV6: + (void) interpret_ipv6(flags, (ip6_t *)data, len); + break; + case ETHERTYPE_ARP: + case ETHERTYPE_REVARP: + interpret_arp(flags, (struct arphdr *)data, len); + break; + } + + return (elen); +} + +/* ARGSUSED */ +uint_t +ipnet_header_len(char *hdr, size_t msgsize) +{ + return (sizeof (dl_ipnetinfo_t)); +} + +#define MAX_UINT64_STR 22 +static uint_t +interpret_ipnet(int flags, char *header, int elen, int origlen) +{ + dl_ipnetinfo_t dl; + size_t len = elen - sizeof (dl_ipnetinfo_t); + char *off = (char *)header + sizeof (dl_ipnetinfo_t); + int blen = MAX(origlen, 8252); + char szone[MAX_UINT64_STR]; + char dzone[MAX_UINT64_STR]; + + (void) memcpy(&dl, header, sizeof (dl)); + if (data != NULL && datalen != 0 && datalen < blen) { + free(data); + data = NULL; + datalen = 0; + } + if (data == NULL) { + data = (char *)malloc(blen); + if (!data) + pr_err("Warning: malloc failure"); + datalen = blen; + } + + if (dl.dli_zsrc == ALL_ZONES) + sprintf(szone, "Unknown"); + else + sprintf(szone, "%lu", BE_32(dl.dli_zsrc)); + + if (dl.dli_zdst == ALL_ZONES) + sprintf(dzone, "Unknown"); + else + sprintf(dzone, "%lu", BE_32(dl.dli_zdst)); + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "IPNET src zone %s dst zone %s", szone, dzone); + } + + if (flags & F_DTAIL) { + show_header("IPNET: ", "IPNET Header", elen); + show_space(); + (void) sprintf(get_line(0, 0), + "Packet %d arrived at %d:%02d:%d.%05d", + pi_frame, + pi_time_hour, pi_time_min, pi_time_sec, + pi_time_usec / 10); + (void) sprintf(get_line(0, 0), + "Packet size = %d bytes", + elen); + (void) snprintf(get_line(0, 0), get_line_remain(), + "dli_version = %d", dl.dli_version); + (void) snprintf(get_line(0, 0), get_line_remain(), + "dli_family = %d", dl.dli_family); + (void) snprintf(get_line(0, 2), get_line_remain(), + "dli_zsrc = %s", szone); + (void) snprintf(get_line(0, 2), get_line_remain(), + "dli_zdst = %s", dzone); + show_space(); + } + memcpy(data, off, len); + + switch (dl.dli_family) { + case AF_INET: + (void) interpret_ip(flags, (struct ip *)data, len); + break; + case AF_INET6: + (void) interpret_ipv6(flags, (ip6_t *)data, len); + break; + default: + break; + } + + return (0); +} + +uint_t +ipv4_header_len(char *hdr, size_t msgsize) +{ + return (msgsize < sizeof (ipha_t) ? 0 : IPH_HDR_LENGTH((ipha_t *)hdr)); +} + +/* + * The header length needs to include all potential extension headers, as the + * caller expects to use this length as an offset to the inner network layer + * header to be used as a filter offset. IPsec headers aren't passed up here, + * and neither are fragmentation headers. + */ +uint_t +ipv6_header_len(char *hdr, size_t msgsize) +{ + ip6_t *ip6hdr = (ip6_t *)hdr; + ip6_hbh_t *exthdr; + uint_t hdrlen = sizeof (ip6_t), exthdrlen; + char *pptr; + uint8_t nxt; + + if (msgsize < sizeof (ip6_t)) + return (0); + + nxt = ip6hdr->ip6_nxt; + pptr = (char *)(ip6hdr + 1); + + while (nxt != IPPROTO_ENCAP && nxt != IPPROTO_IPV6) { + switch (nxt) { + case IPPROTO_HOPOPTS: + case IPPROTO_DSTOPTS: + case IPPROTO_ROUTING: + if (msgsize < hdrlen + sizeof (ip6_hbh_t)) + return (0); + exthdr = (ip6_hbh_t *)pptr; + exthdrlen = 8 + exthdr->ip6h_len * 8; + hdrlen += exthdrlen; + pptr += exthdrlen; + nxt = exthdr->ip6h_nxt; + break; + default: + /* + * This is garbage, there's no way to know where the + * inner IP header is. + */ + return (0); + } + } + + return (hdrlen); +} + +/* ARGSUSED */ +uint_t +interpret_iptun(int flags, char *header, int elen, int origlen) +{ + (void) interpret_ip(flags, (struct ip *)header, elen); + return (elen); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_filter.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_filter.c new file mode 100644 index 0000000..16ea65e --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_filter.c @@ -0,0 +1,2845 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * Copyright 2012 Milan Jurik. All rights reserved. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <stddef.h> +#include <unistd.h> +#include <stropts.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <sys/vlan.h> +#include <net/if.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <inet/ip6.h> +#include <inet/ip.h> +#include <netinet/if_ether.h> +#include <netinet/tcp.h> +#include <netinet/udp.h> +#include <netdb.h> +#include <arpa/inet.h> +#include <rpc/rpc.h> +#include <rpc/rpcent.h> +#include <sys/dlpi.h> + +#include <snoop.h> +#include "snoop_vlan.h" + +#define IPV4_ONLY 0 +#define IPV6_ONLY 1 +#define IPV4_AND_IPV6 2 + +/* + * The following constants represent the offsets in bytes from the beginning + * of the IP(v6) header of the source and destination IP(v6) addresses. + * These are useful when generating filter code. + */ +#define IPV4_SRCADDR_OFFSET 12 +#define IPV4_DSTADDR_OFFSET 16 +#define IPV6_SRCADDR_OFFSET 8 +#define IPV6_DSTADDR_OFFSET 24 +#define IP_VERS(p) (((*(uchar_t *)p) & 0xf0) >> 4) +#define MASKED_IPV4_VERS 0x40 +#define MASKED_IPV6_VERS 0x60 +#define IP_HDR_LEN(p) (((*(uchar_t *)p) & 0xf) * 4) +#define TCP_HDR_LEN(p) ((((*((uchar_t *)p+12)) >> 4) & 0xf) * 4) + +/* + * Coding the constant below is tacky, but the compiler won't let us + * be more clever. E.g., &((struct ip *)0)->ip_xxx + */ +#define IP_PROTO_OF(p) (((uchar_t *)p)[9]) + +/* + * AppleTalk uses 802.2 Ethernet encapsulation with LLC/SNAP headers, + * for 8 octets of overhead, and the common AppleTalk DDP Ethernet + * header is another 4 octets. + * + * The following constants represents the offsets in bytes from the beginning + * of the Ethernet payload to various parts of the DDP header. + */ + +#define AT_DST_NET_OFFSET 12 +#define AT_SRC_NET_OFFSET 14 +#define AT_DST_NODE_OFFSET 16 +#define AT_SRC_NODE_OFFSET 17 + +/* + * Offset for the source and destination zoneid in the ipnet header. + */ +#define IPNET_SRCZONE_OFFSET 16 +#define IPNET_DSTZONE_OFFSET 20 + +int eaddr; /* need ethernet addr */ + +int opstack; /* operand stack depth */ + +/* + * These are the operators of the user-level filter. + * STOP ends execution of the filter expression and + * returns the truth value at the top of the stack. + * OP_LOAD_OCTET, OP_LOAD_SHORT and OP_LOAD_LONG pop + * an offset value from the stack and load a value of + * an appropriate size from the packet (octet, short or + * long). The offset is computed from a base value that + * may be set via the OP_OFFSET operators. + * OP_EQ, OP_NE, OP_GT, OP_GE, OP_LT, OP_LE pop two values + * from the stack and return the result of their comparison. + * OP_AND, OP_OR, OP_XOR pop two values from the stack and + * do perform a bitwise operation on them - returning a result + * to the stack. OP_NOT inverts the bits of the value on the + * stack. + * OP_BRFL and OP_BRTR branch to an offset in the code array + * depending on the value at the top of the stack: true (not 0) + * or false (0). + * OP_ADD, OP_SUB, OP_MUL, OP_DIV and OP_REM pop two values + * from the stack and perform arithmetic. + * The OP_OFFSET operators change the base from which the + * OP_LOAD operators compute their offsets. + * OP_OFFSET_ZERO sets the offset to zero - beginning of packet. + * OP_OFFSET_LINK sets the base to the first octet after + * the link (DLC) header. OP_OFFSET_IP, OP_OFFSET_TCP, + * and OP_OFFSET_UDP do the same for those headers - they + * set the offset base to the *end* of the header - not the + * beginning. The OP_OFFSET_RPC operator is a bit unusual. + * It points the base at the cached RPC header. For the + * purposes of selection, RPC reply headers look like call + * headers except for the direction value. + * OP_OFFSET_ETHERTYPE sets base according to the following + * algorithm: + * if the packet is not VLAN tagged, then set base to + * the ethertype field in the ethernet header + * else set base to the ethertype field of the VLAN header + * OP_OFFSET_POP restores the offset base to the value prior + * to the most recent OP_OFFSET call. + */ +enum optype { + OP_STOP = 0, + OP_LOAD_OCTET, + OP_LOAD_SHORT, + OP_LOAD_LONG, + OP_LOAD_CONST, + OP_LOAD_LENGTH, + OP_EQ, + OP_NE, + OP_GT, + OP_GE, + OP_LT, + OP_LE, + OP_AND, + OP_OR, + OP_XOR, + OP_NOT, + OP_BRFL, + OP_BRTR, + OP_ADD, + OP_SUB, + OP_MUL, + OP_DIV, + OP_REM, + OP_OFFSET_POP, + OP_OFFSET_ZERO, + OP_OFFSET_LINK, + OP_OFFSET_IP, + OP_OFFSET_TCP, + OP_OFFSET_UDP, + OP_OFFSET_RPC, + OP_OFFSET_SLP, + OP_OFFSET_ETHERTYPE, + OP_LAST +}; + +static char *opnames[] = { + "STOP", + "LOAD_OCTET", + "LOAD_SHORT", + "LOAD_LONG", + "LOAD_CONST", + "LOAD_LENGTH", + "EQ", + "NE", + "GT", + "GE", + "LT", + "LE", + "AND", + "OR", + "XOR", + "NOT", + "BRFL", + "BRTR", + "ADD", + "SUB", + "MUL", + "DIV", + "REM", + "OFFSET_POP", + "OFFSET_ZERO", + "OFFSET_ETHER", + "OFFSET_IP", + "OFFSET_TCP", + "OFFSET_UDP", + "OFFSET_RPC", + "OP_OFFSET_SLP", + "OFFSET_ETHERTYPE", + "" +}; + +#define MAXOPS 1024 +#define MAXSS 64 +static uint_t oplist[MAXOPS]; /* array of operators */ +static uint_t *curr_op; /* last op generated */ + +extern int valid_slp(uchar_t *, int); /* decides if a SLP msg is valid */ +extern struct hostent *lgetipnodebyname(const char *, int, int, int *); + +static void alternation(); +static uint_t chain(); +static void codeprint(); +static void emitop(); +static void emitval(); +static void expression(); +static struct xid_entry *find_rpc(); +static void optimize(); +static void ethertype_match(); + +/* + * Get a ushort from a possibly unaligned character buffer. + * + * INPUTS: buffer - where the data is. Must be at least + * sizeof(uint16_t) bytes long. + * OUPUTS: An unsigned short that contains the data at buffer. + * No calls to ntohs or htons are done on the data. + */ +static uint16_t +get_u16(uchar_t *buffer) +{ + uint8_t *bufraw = buffer; + + /* + * ntohs is used only as a cheap way to flip the bits + * around on a little endian platform. The value will + * still be in host order or network order, depending on + * the order it was in when it was passed in. + */ + return (ntohs(bufraw[0] << 8 | bufraw[1])); +} + +/* + * Returns the ULP for an IPv4 or IPv6 packet + * Assumes that the packet has already been checked to verify + * that it's either IPv4 or IPv6 + * + * XXX Will need to be updated for AH and ESP + * XXX when IPsec is supported for v6. + */ +static uchar_t +ip_proto_of(uchar_t *ip) +{ + uchar_t nxt; + boolean_t not_done = B_TRUE; + uchar_t *ptr = ip; + + switch (IP_VERS(ip)) { + case IPV4_VERSION: + return (IP_PROTO_OF(ip)); + case IPV6_VERSION: + + nxt = ip[6]; + ptr += 40; /* size of ip6 header */ + do { + switch (nxt) { + /* + * XXX Add IPsec headers here when supported for v6 + * XXX (the AH will have a different size...) + */ + case IPPROTO_HOPOPTS: + case IPPROTO_ROUTING: + case IPPROTO_FRAGMENT: + case IPPROTO_DSTOPTS: + ptr += (8 * (ptr[1] + 1)); + nxt = *ptr; + break; + + default: + not_done = B_FALSE; + break; + } + } while (not_done); + return (nxt); + default: + break; /* shouldn't get here... */ + } + return (0); +} + +/* + * Returns the total IP header length. + * For v4, this includes any options present. + * For v6, this is the length of the IPv6 header plus + * any extension headers present. + * + * XXX Will need to be updated for AH and ESP + * XXX when IPsec is supported for v6. + */ +static int +ip_hdr_len(uchar_t *ip) +{ + uchar_t nxt; + int hdr_len; + boolean_t not_done = B_TRUE; + int len = 40; /* IPv6 header size */ + uchar_t *ptr = ip; + + switch (IP_VERS(ip)) { + case IPV4_VERSION: + return (IP_HDR_LEN(ip)); + case IPV6_VERSION: + nxt = ip[6]; + ptr += len; + do { + switch (nxt) { + /* + * XXX Add IPsec headers here when supported for v6 + * XXX (the AH will have a different size...) + */ + case IPPROTO_HOPOPTS: + case IPPROTO_ROUTING: + case IPPROTO_FRAGMENT: + case IPPROTO_DSTOPTS: + hdr_len = (8 * (ptr[1] + 1)); + len += hdr_len; + ptr += hdr_len; + nxt = *ptr; + break; + + default: + not_done = B_FALSE; + break; + } + } while (not_done); + return (len); + default: + break; + } + return (0); /* not IP */ +} + +static void +codeprint() +{ + uint_t *op; + + printf("User filter:\n"); + + for (op = oplist; *op; op++) { + if (*op <= OP_LAST) + printf("\t%2d: %s\n", op - oplist, opnames[*op]); + else + printf("\t%2d: (%d)\n", op - oplist, *op); + + switch (*op) { + case OP_LOAD_CONST: + case OP_BRTR: + case OP_BRFL: + op++; + if ((int)*op < 0) + printf("\t%2d: 0x%08x (%d)\n", + op - oplist, *op, *op); + else + printf("\t%2d: %d (0x%08x)\n", + op - oplist, *op, *op); + } + } + printf("\t%2d: STOP\n", op - oplist); + printf("\n"); +} + + +/* + * Take a pass through the generated code and optimize + * branches. A branch true (BRTR) that has another BRTR + * at its destination can use the address of the destination + * BRTR. A BRTR that points to a BRFL (branch false) should + * point to the address following the BRFL. + * A similar optimization applies to BRFL operators. + */ +static void +optimize(uint_t *oplistp) +{ + uint_t *op; + + for (op = oplistp; *op; op++) { + switch (*op) { + case OP_LOAD_CONST: + op++; + break; + case OP_BRTR: + op++; + optimize(&oplist[*op]); + if (oplist[*op] == OP_BRFL) + *op += 2; + else if (oplist[*op] == OP_BRTR) + *op = oplist[*op + 1]; + break; + case OP_BRFL: + op++; + optimize(&oplist[*op]); + if (oplist[*op] == OP_BRTR) + *op += 2; + else if (oplist[*op] == OP_BRFL) + *op = oplist[*op + 1]; + break; + } + } +} + +/* + * RPC packets are tough to filter. + * While the call packet has all the interesting + * info: program number, version, procedure etc, + * the reply packet has none of this information. + * If we want to do useful filtering based on this + * information then we have to stash the information + * from the call packet, and use the XID in the reply + * to find the stashed info. The stashed info is + * kept in a circular lifo, assuming that a call packet + * will be followed quickly by its reply. + */ + +struct xid_entry { + unsigned x_xid; /* The XID (32 bits) */ + unsigned x_dir; /* CALL or REPLY */ + unsigned x_rpcvers; /* Protocol version (2) */ + unsigned x_prog; /* RPC program number */ + unsigned x_vers; /* RPC version number */ + unsigned x_proc; /* RPC procedure number */ +}; +static struct xid_entry xe_table[XID_CACHE_SIZE]; +static struct xid_entry *xe_first = &xe_table[0]; +static struct xid_entry *xe = &xe_table[0]; +static struct xid_entry *xe_last = &xe_table[XID_CACHE_SIZE - 1]; + +static struct xid_entry * +find_rpc(struct rpc_msg *rpc) +{ + struct xid_entry *x; + + for (x = xe; x >= xe_first; x--) + if (x->x_xid == rpc->rm_xid) + return (x); + for (x = xe_last; x > xe; x--) + if (x->x_xid == rpc->rm_xid) + return (x); + return (NULL); +} + +static void +stash_rpc(struct rpc_msg *rpc) +{ + struct xid_entry *x; + + if (find_rpc(rpc)) + return; + + x = xe++; + if (xe > xe_last) + xe = xe_first; + x->x_xid = rpc->rm_xid; + x->x_dir = htonl(REPLY); + x->x_prog = rpc->rm_call.cb_prog; + x->x_vers = rpc->rm_call.cb_vers; + x->x_proc = rpc->rm_call.cb_proc; +} + +/* + * SLP can multicast requests, and recieve unicast replies in which + * neither the source nor destination port is identifiable as a SLP + * port. Hence, we need to do as RPC does, and keep track of packets we + * are interested in. For SLP, however, we use ports, not XIDs, and + * a smaller cache size is more efficient since every incoming packet + * needs to be checked. + */ + +#define SLP_CACHE_SIZE 64 +static uint_t slp_table[SLP_CACHE_SIZE]; +static int slp_index = 0; + +/* + * Returns the index of dport in the table if found, otherwise -1. + */ +static int +find_slp(uint_t dport) { + int i; + + if (!dport) + return (0); + + for (i = slp_index; i >= 0; i--) + if (slp_table[i] == dport) { + return (i); + } + for (i = SLP_CACHE_SIZE - 1; i > slp_index; i--) + if (slp_table[i] == dport) { + return (i); + } + return (-1); +} + +static void stash_slp(uint_t sport) { + if (slp_table[slp_index - 1] == sport) + /* avoid redundancy due to multicast retransmissions */ + return; + + slp_table[slp_index++] = sport; + if (slp_index == SLP_CACHE_SIZE) + slp_index = 0; +} + +/* + * This routine takes a packet and returns true or false + * according to whether the filter expression selects it + * or not. + * We assume here that offsets for short and long values + * are even - we may die with an alignment error if the + * CPU doesn't support odd addresses. Note that long + * values are loaded as two shorts so that 32 bit word + * alignment isn't important. + * + * IPv6 is a bit stickier to handle than IPv4... + */ + +int +want_packet(uchar_t *pkt, int len, int origlen) +{ + uint_t stack[MAXSS]; /* operand stack */ + uint_t *op; /* current operator */ + uint_t *sp; /* top of operand stack */ + uchar_t *base; /* base for offsets into packet */ + uchar_t *ip; /* addr of IP header, unaligned */ + uchar_t *tcp; /* addr of TCP header, unaligned */ + uchar_t *udp; /* addr of UDP header, unaligned */ + struct rpc_msg rpcmsg; /* addr of RPC header */ + struct rpc_msg *rpc; + int newrpc = 0; + uchar_t *slphdr; /* beginning of SLP header */ + uint_t slp_sport, slp_dport; + int off, header_size; + uchar_t *offstack[MAXSS]; /* offset stack */ + uchar_t **offp; /* current offset */ + uchar_t *opkt = NULL; + uint_t olen; + + sp = stack; + *sp = 1; + base = pkt; + offp = offstack; + + header_size = (*interface->header_len)((char *)pkt, len); + + for (op = oplist; *op; op++) { + switch ((enum optype) *op) { + case OP_LOAD_OCTET: + if ((base + *sp) > (pkt + len)) + return (0); /* packet too short */ + + *sp = *((uchar_t *)(base + *sp)); + break; + case OP_LOAD_SHORT: + off = *sp; + + if ((base + off + sizeof (uint16_t) - 1) > (pkt + len)) + return (0); /* packet too short */ + + *sp = ntohs(get_u16((uchar_t *)(base + off))); + break; + case OP_LOAD_LONG: + off = *sp; + + if ((base + off + sizeof (uint32_t) - 1) > (pkt + len)) + return (0); /* packet too short */ + + /* + * Handle 3 possible alignments + */ + switch ((((unsigned)base) + off) % sizeof (uint_t)) { + case 0: + *sp = *(uint_t *)(base + off); + break; + + case 2: + *((ushort_t *)(sp)) = + *((ushort_t *)(base + off)); + *(((ushort_t *)sp) + 1) = + *((ushort_t *)(base + off) + 1); + break; + + case 1: + case 3: + *((uchar_t *)(sp)) = + *((uchar_t *)(base + off)); + *(((uchar_t *)sp) + 1) = + *((uchar_t *)(base + off) + 1); + *(((uchar_t *)sp) + 2) = + *((uchar_t *)(base + off) + 2); + *(((uchar_t *)sp) + 3) = + *((uchar_t *)(base + off) + 3); + break; + } + *sp = ntohl(*sp); + break; + case OP_LOAD_CONST: + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = *(++op); + break; + case OP_LOAD_LENGTH: + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = origlen; + break; + case OP_EQ: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp == *(sp + 1); + break; + case OP_NE: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp != *(sp + 1); + break; + case OP_GT: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp > *(sp + 1); + break; + case OP_GE: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp >= *(sp + 1); + break; + case OP_LT: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp < *(sp + 1); + break; + case OP_LE: + if (sp < &stack[1]) + return (0); + sp--; + *sp = *sp <= *(sp + 1); + break; + case OP_AND: + if (sp < &stack[1]) + return (0); + sp--; + *sp &= *(sp + 1); + break; + case OP_OR: + if (sp < &stack[1]) + return (0); + sp--; + *sp |= *(sp + 1); + break; + case OP_XOR: + if (sp < &stack[1]) + return (0); + sp--; + *sp ^= *(sp + 1); + break; + case OP_NOT: + *sp = !*sp; + break; + case OP_BRFL: + op++; + if (!*sp) + op = &oplist[*op] - 1; + break; + case OP_BRTR: + op++; + if (*sp) + op = &oplist[*op] - 1; + break; + case OP_ADD: + if (sp < &stack[1]) + return (0); + sp--; + *sp += *(sp + 1); + break; + case OP_SUB: + if (sp < &stack[1]) + return (0); + sp--; + *sp -= *(sp + 1); + break; + case OP_MUL: + if (sp < &stack[1]) + return (0); + sp--; + *sp *= *(sp + 1); + break; + case OP_DIV: + if (sp < &stack[1]) + return (0); + sp--; + *sp /= *(sp + 1); + break; + case OP_REM: + if (sp < &stack[1]) + return (0); + sp--; + *sp %= *(sp + 1); + break; + case OP_OFFSET_POP: + if (offp < &offstack[0]) + return (0); + base = *offp--; + if (opkt != NULL) { + pkt = opkt; + len = olen; + opkt = NULL; + } + break; + case OP_OFFSET_ZERO: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + base = pkt; + break; + case OP_OFFSET_LINK: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + base = pkt + header_size; + /* + * If the offset exceeds the packet length, + * we should not be interested in this packet... + * Just return 0. + */ + if (base > pkt + len) { + return (0); + } + break; + case OP_OFFSET_IP: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + ip = pkt + header_size; + base = ip + ip_hdr_len(ip); + if (base == ip) { + return (0); /* not IP */ + } + if (base > pkt + len) { + return (0); /* bad pkt */ + } + break; + case OP_OFFSET_TCP: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + ip = pkt + header_size; + tcp = ip + ip_hdr_len(ip); + if (tcp == ip) { + return (0); /* not IP */ + } + base = tcp + TCP_HDR_LEN(tcp); + if (base > pkt + len) { + return (0); + } + break; + case OP_OFFSET_UDP: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + ip = pkt + header_size; + udp = ip + ip_hdr_len(ip); + if (udp == ip) { + return (0); /* not IP */ + } + base = udp + sizeof (struct udphdr); + if (base > pkt + len) { + return (0); + } + break; + case OP_OFFSET_RPC: + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + ip = pkt + header_size; + rpc = NULL; + + if (IP_VERS(ip) != IPV4_VERSION && + IP_VERS(ip) != IPV6_VERSION) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + } + + switch (ip_proto_of(ip)) { + case IPPROTO_UDP: + udp = ip + ip_hdr_len(ip); + rpc = (struct rpc_msg *)(udp + + sizeof (struct udphdr)); + break; + case IPPROTO_TCP: + tcp = ip + ip_hdr_len(ip); + /* + * Need to skip an extra 4 for the xdr_rec + * field. + */ + rpc = (struct rpc_msg *)(tcp + + TCP_HDR_LEN(tcp) + 4); + break; + } + /* + * We need to have at least 24 bytes of a RPC + * packet to look at to determine the validity + * of it. + */ + if (rpc == NULL || (uchar_t *)rpc + 24 > pkt + len) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + } + /* align */ + (void) memcpy(&rpcmsg, rpc, 24); + if (!valid_rpc((char *)&rpcmsg, 24)) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + } + if (ntohl(rpcmsg.rm_direction) == CALL) { + base = (uchar_t *)rpc; + newrpc = 1; + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 1; + } else { + opkt = pkt; + olen = len; + + pkt = base = (uchar_t *)find_rpc(&rpcmsg); + len = sizeof (struct xid_entry); + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = base != NULL; + } + break; + case OP_OFFSET_SLP: + slphdr = NULL; + ip = pkt + header_size; + + if (IP_VERS(ip) != IPV4_VERSION && + IP_VERS(ip) != IPV6_VERSION) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + } + + switch (ip_proto_of(ip)) { + struct udphdr udp_h; + struct tcphdr tcp_h; + case IPPROTO_UDP: + udp = ip + ip_hdr_len(ip); + /* align */ + memcpy(&udp_h, udp, sizeof (udp_h)); + slp_sport = ntohs(udp_h.uh_sport); + slp_dport = ntohs(udp_h.uh_dport); + slphdr = udp + sizeof (struct udphdr); + break; + case IPPROTO_TCP: + tcp = ip + ip_hdr_len(ip); + /* align */ + memcpy(&tcp_h, tcp, sizeof (tcp_h)); + slp_sport = ntohs(tcp_h.th_sport); + slp_dport = ntohs(tcp_h.th_dport); + slphdr = tcp + TCP_HDR_LEN(tcp); + break; + } + if (slphdr == NULL || slphdr > pkt + len) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + } + if (slp_sport == 427 || slp_dport == 427) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 1; + if (slp_sport != 427 && slp_dport == 427) + stash_slp(slp_sport); + break; + } else if (find_slp(slp_dport) != -1) { + if (valid_slp(slphdr, len)) { + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 1; + break; + } + /* else fallthrough to reject */ + } + if (sp >= &stack[MAXSS]) + return (0); + *(++sp) = 0; + break; + case OP_OFFSET_ETHERTYPE: + /* + * Set base to the location of the ethertype as + * appropriate for this link type. Note that it's + * not called "ethertype" for every link type, but + * we need to call it something. + */ + if (offp >= &offstack[MAXSS]) + return (0); + *++offp = base; + base = pkt + interface->network_type_offset; + + /* + * Below, we adjust the offset for unusual + * link-layer headers that may have the protocol + * type in a variable location beyond what was set + * above. + */ + switch (interface->mac_type) { + case DL_ETHER: + case DL_CSMACD: + /* + * If this is a VLAN-tagged packet, we need + * to point to the ethertype field in the + * VLAN header. Move past the ethertype + * field in the ethernet header. + */ + if (ntohs(get_u16(base)) == ETHERTYPE_VLAN) + base += (ENCAP_ETHERTYPE_OFF); + break; + } + if (base > pkt + len) { + /* Went too far, drop the packet */ + return (0); + } + break; + } + } + + if (*sp && newrpc) + stash_rpc(&rpcmsg); + + return (*sp); +} + +static void +load_const(uint_t constval) +{ + emitop(OP_LOAD_CONST); + emitval(constval); +} + +static void +load_value(int offset, int len) +{ + if (offset >= 0) + load_const(offset); + + switch (len) { + case 1: + emitop(OP_LOAD_OCTET); + break; + case 2: + emitop(OP_LOAD_SHORT); + break; + case 4: + emitop(OP_LOAD_LONG); + break; + } +} + +/* + * Emit code to compare a field in + * the packet against a constant value. + */ +static void +compare_value(uint_t offset, uint_t len, uint_t val) +{ + load_const(val); + load_value(offset, len); + emitop(OP_EQ); +} + +static void +compare_addr_v4(uint_t offset, uint_t len, uint_t val) +{ + load_const(ntohl(val)); + load_value(offset, len); + emitop(OP_EQ); +} + +static void +compare_addr_v6(uint_t offset, uint_t len, struct in6_addr val) +{ + int i; + uint32_t value; + + for (i = 0; i < len; i += 4) { + value = ntohl(*(uint32_t *)&val.s6_addr[i]); + load_const(value); + load_value(offset + i, 4); + emitop(OP_EQ); + if (i != 0) + emitop(OP_AND); + } +} + +/* + * Same as above except do the comparison + * after and'ing a mask value. Useful + * for comparing IP network numbers + */ +static void +compare_value_mask(uint_t offset, uint_t len, uint_t val, int mask) +{ + load_value(offset, len); + load_const(mask); + emitop(OP_AND); + load_const(val); + emitop(OP_EQ); +} + +/* + * Compare two zoneid's. The arg val passed in is stored in network + * byte order. + */ +static void +compare_value_zone(uint_t offset, uint32_t val) +{ + load_const(ntohl(val)); + load_value(offset, 4); + emitop(OP_EQ); +} + +/* Emit an operator into the code array */ +static void +emitop(enum optype opcode) +{ + if (curr_op >= &oplist[MAXOPS]) + pr_err("expression too long"); + *curr_op++ = opcode; +} + +/* + * Remove n operators recently emitted into + * the code array. Used by alternation(). + */ +static void +unemit(int numops) +{ + curr_op -= numops; +} + + +/* + * Same as emitop except that we're emitting + * a value that's not an operator. + */ +static void +emitval(uint_t val) +{ + if (curr_op >= &oplist[MAXOPS]) + pr_err("expression too long"); + *curr_op++ = val; +} + +/* + * Used to chain forward branches together + * for later resolution by resolve_chain(). + */ +static uint_t +chain(int p) +{ + uint_t pos = curr_op - oplist; + + emitval(p); + return (pos); +} + +/* + * Proceed backward through the code array + * following a chain of forward references. + * At each reference install the destination + * branch offset. + */ +static void +resolve_chain(uint_t p) +{ + uint_t n; + uint_t pos = curr_op - oplist; + + while (p) { + n = oplist[p]; + oplist[p] = pos; + p = n; + } +} + +#define EQ(val) (strcmp(token, val) == 0) + +char *tkp, *sav_tkp; +char *token; +enum { EOL, ALPHA, NUMBER, FIELD, ADDR_IP, ADDR_ETHER, SPECIAL, + ADDR_IP6, ADDR_AT } tokentype; +uint_t tokenval; + +/* + * This is the scanner. Each call returns the next + * token in the filter expression. A token is either: + * EOL: The end of the line - no more tokens. + * ALPHA: A name that begins with a letter and contains + * letters or digits, hyphens or underscores. + * NUMBER: A number. The value can be represented as + * a decimal value (1234) or an octal value + * that begins with zero (066) or a hex value + * that begins with 0x or 0X (0xff). + * FIELD: A name followed by a left square bracket. + * ADDR_IP: An IP address. Any sequence of digits + * separated by dots e.g. 109.104.40.13 + * ADDR_ETHER: An ethernet address. Any sequence of hex + * digits separated by colons e.g. 8:0:20:0:76:39 + * SPECIAL: A special character e.g. ">" or "(". The scanner + * correctly handles digraphs - two special characters + * that constitute a single token e.g. "==" or ">=". + * ADDR_IP6: An IPv6 address. + * + * ADDR_AT: An AppleTalk Phase II address. A sequence of two numbers + * separated by a dot. + * + * The current token is maintained in "token" and and its + * type in "tokentype". If tokentype is NUMBER then the + * value is held in "tokenval". + */ + +static const char *namechars = + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-."; +static const char *numchars = "0123456789abcdefABCDEFXx:."; + +void +next() +{ + static int savechar; + char *p; + int size, size1; + int base, colons, dots, alphas, double_colon; + + colons = 0; + double_colon = 0; + + if (*tkp == '\0') { + token = tkp; + *tkp = savechar; + } + + sav_tkp = tkp; + + while (isspace(*tkp)) tkp++; + token = tkp; + if (*token == '\0') { + tokentype = EOL; + return; + } + + /* A token containing ':' cannot be ALPHA type */ + tkp = token + strspn(token, numchars); + for (p = token; p < tkp; p++) { + if (*p == ':') { + colons++; + if (*(p+1) == ':') + double_colon++; + } + } + + tkp = token; + if (isalpha(*tkp) && !colons) { + tokentype = ALPHA; + tkp += strspn(tkp, namechars); + if (*tkp == '[') { + tokentype = FIELD; + *tkp++ = '\0'; + } + } else + + /* + * RFC1123 states that host names may now start with digits. Need + * to change parser to account for this. Also, need to distinguish + * between 1.2.3.4 and 1.2.3.a where the first case is an IP address + * and the second is a domain name. 333aaa needs to be distinguished + * from 0x333aaa. The first is a host name and the second is a number. + * + * The (colons > 1) conditional differentiates between ethernet + * and IPv6 addresses, and an expression of the form base[expr:size], + * which can only contain one ':' character. + */ + if (isdigit(*tkp) || colons > 1) { + tkp = token + strspn(token, numchars); + dots = alphas = 0; + for (p = token; p < tkp; p++) { + if (*p == '.') + dots++; + else if (isalpha(*p)) + alphas = 1; + } + if (colons > 1) { + if (colons == 5 && double_colon == 0) { + tokentype = ADDR_ETHER; + } else { + tokentype = ADDR_IP6; + } + } else if (dots) { + size = tkp - token; + size1 = strspn(token, "0123456789."); + if (dots == 1 && size == size1) { + tokentype = ADDR_AT; + } else + if (dots != 3 || size != size1) { + tokentype = ALPHA; + if (*tkp != '\0' && !isspace(*tkp)) { + tkp += strspn(tkp, namechars); + if (*tkp == '[') { + tokentype = FIELD; + *tkp++ = '\0'; + } + } + } else + tokentype = ADDR_IP; + } else if (token + strspn(token, namechars) <= tkp) { + /* + * With the above check, if there are more + * characters after the last digit, assume + * that it is not a number. + */ + tokentype = NUMBER; + p = tkp; + tkp = token; + base = 10; + if (*tkp == '0') { + base = 8; + tkp++; + if (*tkp == 'x' || *tkp == 'X') + base = 16; + } + if ((base == 10 || base == 8) && alphas) { + tokentype = ALPHA; + tkp = p; + } else if (base == 16) { + size = 2 + strspn(token+2, + "0123456789abcdefABCDEF"); + size1 = p - token; + if (size != size1) { + tokentype = ALPHA; + tkp = p; + } else + /* + * handles the case of 0x so an error message + * is not printed. Treats 0x as 0. + */ + if (size == 2) { + tokenval = 0; + tkp = token +2; + } else { + tokenval = strtoul(token, &tkp, base); + } + } else { + tokenval = strtoul(token, &tkp, base); + } + } else { + tokentype = ALPHA; + tkp += strspn(tkp, namechars); + if (*tkp == '[') { + tokentype = FIELD; + *tkp++ = '\0'; + } + } + } else { + tokentype = SPECIAL; + tkp++; + if ((*token == '=' && *tkp == '=') || + (*token == '>' && *tkp == '=') || + (*token == '<' && *tkp == '=') || + (*token == '!' && *tkp == '=')) + tkp++; + } + + savechar = *tkp; + *tkp = '\0'; +} + +typedef struct match_type { + char *m_name; + int m_offset; + int m_size; + int m_value; + int m_depend; + enum optype m_optype; +} match_type_t; + +static match_type_t ether_match_types[] = { + /* + * Table initialized assuming Ethernet data link headers. + * m_offset is an offset beyond the offset op, which is why + * the offset is zero for when snoop needs to check an ethertype. + */ + "ip", 0, 2, ETHERTYPE_IP, -1, OP_OFFSET_ETHERTYPE, + "ip6", 0, 2, ETHERTYPE_IPV6, -1, OP_OFFSET_ETHERTYPE, + "arp", 0, 2, ETHERTYPE_ARP, -1, OP_OFFSET_ETHERTYPE, + "rarp", 0, 2, ETHERTYPE_REVARP, -1, OP_OFFSET_ETHERTYPE, + "pppoed", 0, 2, ETHERTYPE_PPPOED, -1, OP_OFFSET_ETHERTYPE, + "pppoes", 0, 2, ETHERTYPE_PPPOES, -1, OP_OFFSET_ETHERTYPE, + "tcp", 9, 1, IPPROTO_TCP, 0, OP_OFFSET_LINK, + "tcp", 6, 1, IPPROTO_TCP, 1, OP_OFFSET_LINK, + "udp", 9, 1, IPPROTO_UDP, 0, OP_OFFSET_LINK, + "udp", 6, 1, IPPROTO_UDP, 1, OP_OFFSET_LINK, + "icmp", 9, 1, IPPROTO_ICMP, 0, OP_OFFSET_LINK, + "icmp6", 6, 1, IPPROTO_ICMPV6, 1, OP_OFFSET_LINK, + "ospf", 9, 1, IPPROTO_OSPF, 0, OP_OFFSET_LINK, + "ospf", 6, 1, IPPROTO_OSPF, 1, OP_OFFSET_LINK, + "ip-in-ip", 9, 1, IPPROTO_ENCAP, 0, OP_OFFSET_LINK, + "esp", 9, 1, IPPROTO_ESP, 0, OP_OFFSET_LINK, + "esp", 6, 1, IPPROTO_ESP, 1, OP_OFFSET_LINK, + "ah", 9, 1, IPPROTO_AH, 0, OP_OFFSET_LINK, + "ah", 6, 1, IPPROTO_AH, 1, OP_OFFSET_LINK, + "sctp", 9, 1, IPPROTO_SCTP, 0, OP_OFFSET_LINK, + "sctp", 6, 1, IPPROTO_SCTP, 1, OP_OFFSET_LINK, + 0, 0, 0, 0, 0, 0 +}; + +static match_type_t ipnet_match_types[] = { + /* + * Table initialized assuming Ethernet data link headers. + * m_offset is an offset beyond the offset op, which is why + * the offset is zero for when snoop needs to check an ethertype. + */ + "ip", 0, 1, IPV4_VERSION, -1, OP_OFFSET_ETHERTYPE, + "ip6", 0, 1, IPV6_VERSION, -1, OP_OFFSET_ETHERTYPE, + "tcp", 9, 1, IPPROTO_TCP, 0, OP_OFFSET_LINK, + "tcp", 6, 1, IPPROTO_TCP, 1, OP_OFFSET_LINK, + "udp", 9, 1, IPPROTO_UDP, 0, OP_OFFSET_LINK, + "udp", 6, 1, IPPROTO_UDP, 1, OP_OFFSET_LINK, + "icmp", 9, 1, IPPROTO_ICMP, 0, OP_OFFSET_LINK, + "icmp6", 6, 1, IPPROTO_ICMPV6, 1, OP_OFFSET_LINK, + "ospf", 9, 1, IPPROTO_OSPF, 0, OP_OFFSET_LINK, + "ospf", 6, 1, IPPROTO_OSPF, 1, OP_OFFSET_LINK, + "ip-in-ip", 9, 1, IPPROTO_ENCAP, 0, OP_OFFSET_LINK, + "esp", 9, 1, IPPROTO_ESP, 0, OP_OFFSET_LINK, + "esp", 6, 1, IPPROTO_ESP, 1, OP_OFFSET_LINK, + "ah", 9, 1, IPPROTO_AH, 0, OP_OFFSET_LINK, + "ah", 6, 1, IPPROTO_AH, 1, OP_OFFSET_LINK, + "sctp", 9, 1, IPPROTO_SCTP, 0, OP_OFFSET_LINK, + "sctp", 6, 1, IPPROTO_SCTP, 1, OP_OFFSET_LINK, + 0, 0, 0, 0, 0, 0 +}; + +static match_type_t iptun_match_types[] = { + "ip", 0, 1, IPPROTO_ENCAP, -1, OP_OFFSET_ETHERTYPE, + "ip6", 0, 1, IPPROTO_IPV6, -1, OP_OFFSET_ETHERTYPE, + "tcp", 9, 1, IPPROTO_TCP, 0, OP_OFFSET_LINK, + "tcp", 6, 1, IPPROTO_TCP, 1, OP_OFFSET_LINK, + "udp", 9, 1, IPPROTO_UDP, 0, OP_OFFSET_LINK, + "udp", 6, 1, IPPROTO_UDP, 1, OP_OFFSET_LINK, + "icmp", 9, 1, IPPROTO_ICMP, 0, OP_OFFSET_LINK, + "icmp6", 6, 1, IPPROTO_ICMPV6, 1, OP_OFFSET_LINK, + "ospf", 9, 1, IPPROTO_OSPF, 0, OP_OFFSET_LINK, + "ospf", 6, 1, IPPROTO_OSPF, 1, OP_OFFSET_LINK, + "ip-in-ip", 9, 1, IPPROTO_ENCAP, 0, OP_OFFSET_LINK, + "esp", 9, 1, IPPROTO_ESP, 0, OP_OFFSET_LINK, + "esp", 6, 1, IPPROTO_ESP, 1, OP_OFFSET_LINK, + "ah", 9, 1, IPPROTO_AH, 0, OP_OFFSET_LINK, + "ah", 6, 1, IPPROTO_AH, 1, OP_OFFSET_LINK, + "sctp", 9, 1, IPPROTO_SCTP, 0, OP_OFFSET_LINK, + "sctp", 6, 1, IPPROTO_SCTP, 1, OP_OFFSET_LINK, + 0, 0, 0, 0, 0, 0 +}; + +static void +generate_check(match_type_t match_types[], int index, int type) +{ + match_type_t *mtp = &match_types[index]; + /* + * Note: this code assumes the above dependencies are + * not cyclic. This *should* always be true. + */ + if (mtp->m_depend != -1) + generate_check(match_types, mtp->m_depend, type); + + emitop(mtp->m_optype); + load_value(mtp->m_offset, mtp->m_size); + load_const(mtp->m_value); + emitop(OP_OFFSET_POP); + + emitop(OP_EQ); + + if (mtp->m_depend != -1) + emitop(OP_AND); +} + +/* + * Generate code based on the keyword argument. + * This word is looked up in the match_types table + * and checks a field within the packet for a given + * value e.g. ether or ip type field. The match + * can also have a dependency on another entry e.g. + * "tcp" requires that the packet also be "ip". + */ +static int +comparison(char *s) +{ + unsigned int i, n_checks = 0; + match_type_t *match_types; + + switch (interface->mac_type) { + case DL_ETHER: + match_types = ether_match_types; + break; + case DL_IPNET: + match_types = ipnet_match_types; + break; + case DL_IPV4: + case DL_IPV6: + case DL_6TO4: + match_types = iptun_match_types; + break; + default: + return (0); + } + + for (i = 0; match_types[i].m_name != NULL; i++) { + if (strcmp(s, match_types[i].m_name) != 0) + continue; + + n_checks++; + generate_check(match_types, i, interface->mac_type); + if (n_checks > 1) + emitop(OP_OR); + } + + return (n_checks > 0); +} + +enum direction { ANY, TO, FROM }; +enum direction dir; + +/* + * Generate code to match an IP address. The address + * may be supplied either as a hostname or in dotted format. + * For source packets both the IP source address and ARP + * src are checked. + * Note: we don't check packet type here - whether IP or ARP. + * It's possible that we'll do an improper match. + */ +static void +ipaddr_match(enum direction which, char *hostname, int inet_type) +{ + bool_t found_host; + int m = 0, n = 0; + uint_t *addr4ptr; + uint_t addr4; + struct in6_addr *addr6ptr; + int h_addr_index; + struct hostent *hp = NULL; + int error_num = 0; + boolean_t freehp = B_FALSE; + boolean_t first = B_TRUE; + + /* + * The addr4offset and addr6offset variables simplify the code which + * generates the address comparison filter. With these two variables, + * duplicate code need not exist for the TO and FROM case. + * A value of -1 describes the ANY case (TO and FROM). + */ + int addr4offset; + int addr6offset; + + found_host = 0; + + if (tokentype == ADDR_IP) { + hp = lgetipnodebyname(hostname, AF_INET, 0, &error_num); + if (hp == NULL) { + hp = getipnodebyname(hostname, AF_INET, 0, &error_num); + freehp = 1; + } + if (hp == NULL) { + if (error_num == TRY_AGAIN) { + pr_err("couldn't resolve %s (try again later)", + hostname); + } else { + pr_err("couldn't resolve %s", hostname); + } + } + inet_type = IPV4_ONLY; + } else if (tokentype == ADDR_IP6) { + hp = lgetipnodebyname(hostname, AF_INET6, 0, &error_num); + if (hp == NULL) { + hp = getipnodebyname(hostname, AF_INET6, 0, &error_num); + freehp = 1; + } + if (hp == NULL) { + if (error_num == TRY_AGAIN) { + pr_err("couldn't resolve %s (try again later)", + hostname); + } else { + pr_err("couldn't resolve %s", hostname); + } + } + inet_type = IPV6_ONLY; + } else { + /* Some hostname i.e. tokentype is ALPHA */ + switch (inet_type) { + case IPV4_ONLY: + /* Only IPv4 address is needed */ + hp = lgetipnodebyname(hostname, AF_INET, 0, &error_num); + if (hp == NULL) { + hp = getipnodebyname(hostname, AF_INET, 0, + &error_num); + freehp = 1; + } + if (hp != NULL) { + found_host = 1; + } + break; + case IPV6_ONLY: + /* Only IPv6 address is needed */ + hp = lgetipnodebyname(hostname, AF_INET6, 0, + &error_num); + if (hp == NULL) { + hp = getipnodebyname(hostname, AF_INET6, 0, + &error_num); + freehp = 1; + } + if (hp != NULL) { + found_host = 1; + } + break; + case IPV4_AND_IPV6: + /* Both IPv4 and IPv6 are needed */ + hp = lgetipnodebyname(hostname, AF_INET6, + AI_ALL | AI_V4MAPPED, &error_num); + if (hp == NULL) { + hp = getipnodebyname(hostname, AF_INET6, + AI_ALL | AI_V4MAPPED, &error_num); + freehp = 1; + } + if (hp != NULL) { + found_host = 1; + } + break; + default: + found_host = 0; + } + + if (!found_host) { + if (error_num == TRY_AGAIN) { + pr_err("could not resolve %s (try again later)", + hostname); + } else { + pr_err("could not resolve %s", hostname); + } + } + } + + if (hp == NULL) + return; + + switch (which) { + case TO: + addr4offset = IPV4_DSTADDR_OFFSET; + addr6offset = IPV6_DSTADDR_OFFSET; + break; + case FROM: + addr4offset = IPV4_SRCADDR_OFFSET; + addr6offset = IPV6_SRCADDR_OFFSET; + break; + case ANY: + addr4offset = -1; + addr6offset = -1; + break; + } + + /* + * The code below generates the filter. + */ + if (hp->h_addrtype == AF_INET) { + ethertype_match(interface->network_type_ip); + emitop(OP_BRFL); + n = chain(n); + emitop(OP_OFFSET_LINK); + h_addr_index = 0; + addr4ptr = (uint_t *)hp->h_addr_list[h_addr_index]; + while (addr4ptr != NULL) { + if (addr4offset == -1) { + compare_addr_v4(IPV4_SRCADDR_OFFSET, 4, + *addr4ptr); + emitop(OP_BRTR); + m = chain(m); + compare_addr_v4(IPV4_DSTADDR_OFFSET, 4, + *addr4ptr); + } else { + compare_addr_v4(addr4offset, 4, *addr4ptr); + } + addr4ptr = (uint_t *)hp->h_addr_list[++h_addr_index]; + if (addr4ptr != NULL) { + emitop(OP_BRTR); + m = chain(m); + } + } + if (m != 0) { + resolve_chain(m); + } + emitop(OP_OFFSET_POP); + resolve_chain(n); + } else { + /* first pass: IPv4 addresses */ + h_addr_index = 0; + addr6ptr = (struct in6_addr *)hp->h_addr_list[h_addr_index]; + first = B_TRUE; + while (addr6ptr != NULL) { + if (IN6_IS_ADDR_V4MAPPED(addr6ptr)) { + if (first) { + ethertype_match( + interface->network_type_ip); + emitop(OP_BRFL); + n = chain(n); + emitop(OP_OFFSET_LINK); + first = B_FALSE; + } else { + emitop(OP_BRTR); + m = chain(m); + } + IN6_V4MAPPED_TO_INADDR(addr6ptr, + (struct in_addr *)&addr4); + if (addr4offset == -1) { + compare_addr_v4(IPV4_SRCADDR_OFFSET, 4, + addr4); + emitop(OP_BRTR); + m = chain(m); + compare_addr_v4(IPV4_DSTADDR_OFFSET, 4, + addr4); + } else { + compare_addr_v4(addr4offset, 4, addr4); + } + } + addr6ptr = (struct in6_addr *) + hp->h_addr_list[++h_addr_index]; + } + /* second pass: IPv6 addresses */ + h_addr_index = 0; + addr6ptr = (struct in6_addr *)hp->h_addr_list[h_addr_index]; + first = B_TRUE; + while (addr6ptr != NULL) { + if (!IN6_IS_ADDR_V4MAPPED(addr6ptr)) { + if (first) { + /* + * bypass check for IPv6 addresses + * when we have an IPv4 packet + */ + if (n != 0) { + emitop(OP_BRTR); + m = chain(m); + emitop(OP_BRFL); + m = chain(m); + resolve_chain(n); + n = 0; + } + ethertype_match( + interface->network_type_ipv6); + emitop(OP_BRFL); + n = chain(n); + emitop(OP_OFFSET_LINK); + first = B_FALSE; + } else { + emitop(OP_BRTR); + m = chain(m); + } + if (addr6offset == -1) { + compare_addr_v6(IPV6_SRCADDR_OFFSET, + 16, *addr6ptr); + emitop(OP_BRTR); + m = chain(m); + compare_addr_v6(IPV6_DSTADDR_OFFSET, + 16, *addr6ptr); + } else { + compare_addr_v6(addr6offset, 16, + *addr6ptr); + } + } + addr6ptr = (struct in6_addr *) + hp->h_addr_list[++h_addr_index]; + } + if (m != 0) { + resolve_chain(m); + } + emitop(OP_OFFSET_POP); + resolve_chain(n); + } + + /* only free struct hostent returned by getipnodebyname() */ + if (freehp) { + freehostent(hp); + } +} + +/* + * Match on zoneid. The arg zone passed in is in network byte order. + */ +static void +zone_match(enum direction which, uint32_t zone) +{ + + switch (which) { + case TO: + compare_value_zone(IPNET_DSTZONE_OFFSET, zone); + break; + case FROM: + compare_value_zone(IPNET_SRCZONE_OFFSET, zone); + break; + case ANY: + compare_value_zone(IPNET_SRCZONE_OFFSET, zone); + compare_value_zone(IPNET_DSTZONE_OFFSET, zone); + emitop(OP_OR); + } +} + +/* + * Generate code to match an AppleTalk address. The address + * must be given as two numbers with a dot between + * + */ +static void +ataddr_match(enum direction which, char *hostname) +{ + uint_t net; + uint_t node; + uint_t m, n; + + sscanf(hostname, "%u.%u", &net, &node); + + emitop(OP_OFFSET_LINK); + switch (which) { + case TO: + compare_value(AT_DST_NET_OFFSET, 2, net); + emitop(OP_BRFL); + m = chain(0); + compare_value(AT_DST_NODE_OFFSET, 1, node); + resolve_chain(m); + break; + case FROM: + compare_value(AT_SRC_NET_OFFSET, 2, net); + emitop(OP_BRFL); + m = chain(0); + compare_value(AT_SRC_NODE_OFFSET, 1, node); + resolve_chain(m); + break; + case ANY: + compare_value(AT_DST_NET_OFFSET, 2, net); + emitop(OP_BRFL); + m = chain(0); + compare_value(AT_DST_NODE_OFFSET, 1, node); + resolve_chain(m); + emitop(OP_BRTR); + n = chain(0); + compare_value(AT_SRC_NET_OFFSET, 2, net); + emitop(OP_BRFL); + m = chain(0); + compare_value(AT_SRC_NODE_OFFSET, 1, node); + resolve_chain(m); + resolve_chain(n); + break; + } + emitop(OP_OFFSET_POP); +} + +/* + * Compare ethernet addresses. The address may + * be provided either as a hostname or as a + * 6 octet colon-separated address. + */ +static void +etheraddr_match(enum direction which, char *hostname) +{ + uint_t addr; + ushort_t *addrp; + int to_offset, from_offset; + struct ether_addr e, *ep = NULL; + int m; + + /* + * First, check the interface type for whether src/dest address + * is determinable; if not, retreat early. + */ + switch (interface->mac_type) { + case DL_ETHER: + from_offset = ETHERADDRL; + to_offset = 0; + break; + + case DL_IB: + /* + * If an ethernet address is attempted to be used + * on an IPoIB interface, flag error. Link address + * based filtering is unsupported on IPoIB, so there + * is no ipibaddr_match() or parsing support for IPoIB + * 20 byte link addresses. + */ + pr_err("filter option unsupported on media"); + break; + + case DL_FDDI: + from_offset = 7; + to_offset = 1; + break; + + default: + /* + * Where do we find "ether" address for FDDI & TR? + * XXX can improve? ~sparker + */ + load_const(1); + return; + } + + if (isxdigit(*hostname)) + ep = ether_aton(hostname); + if (ep == NULL) { + if (ether_hostton(hostname, &e)) + if (!arp_for_ether(hostname, &e)) + pr_err("cannot obtain ether addr for %s", + hostname); + ep = &e; + } + memcpy(&addr, (ushort_t *)ep, 4); + addrp = (ushort_t *)ep + 2; + + emitop(OP_OFFSET_ZERO); + switch (which) { + case TO: + compare_value(to_offset, 4, ntohl(addr)); + emitop(OP_BRFL); + m = chain(0); + compare_value(to_offset + 4, 2, ntohs(*addrp)); + resolve_chain(m); + break; + case FROM: + compare_value(from_offset, 4, ntohl(addr)); + emitop(OP_BRFL); + m = chain(0); + compare_value(from_offset + 4, 2, ntohs(*addrp)); + resolve_chain(m); + break; + case ANY: + compare_value(to_offset, 4, ntohl(addr)); + compare_value(to_offset + 4, 2, ntohs(*addrp)); + emitop(OP_AND); + emitop(OP_BRTR); + m = chain(0); + + compare_value(from_offset, 4, ntohl(addr)); + compare_value(from_offset + 4, 2, ntohs(*addrp)); + emitop(OP_AND); + resolve_chain(m); + break; + } + emitop(OP_OFFSET_POP); +} + +static void +ethertype_match(int val) +{ + int ether_offset = interface->network_type_offset; + + /* + * If the user is interested in ethertype VLAN, + * then we need to set the offset to the beginning of the packet. + * But if the user is interested in another ethertype, + * such as IPv4, then we need to take into consideration + * the fact that the packet might be VLAN tagged. + */ + if (interface->mac_type == DL_ETHER || + interface->mac_type == DL_CSMACD) { + if (val != ETHERTYPE_VLAN) { + /* + * OP_OFFSET_ETHERTYPE puts us at the ethertype + * field whether or not there is a VLAN tag, + * so ether_offset goes to zero if we get here. + */ + emitop(OP_OFFSET_ETHERTYPE); + ether_offset = 0; + } else { + emitop(OP_OFFSET_ZERO); + } + } + compare_value(ether_offset, interface->network_type_len, val); + if (interface->mac_type == DL_ETHER || + interface->mac_type == DL_CSMACD) { + emitop(OP_OFFSET_POP); + } +} + +/* + * Match a network address. The host part + * is masked out. The network address may + * be supplied either as a netname or in + * IP dotted format. The mask to be used + * for the comparison is assumed from the + * address format (see comment below). + */ +static void +netaddr_match(enum direction which, char *netname) +{ + uint_t addr; + uint_t mask = 0xff000000; + uint_t m; + struct netent *np; + + if (isdigit(*netname)) { + addr = inet_network(netname); + } else { + np = getnetbyname(netname); + if (np == NULL) + pr_err("net %s not known", netname); + addr = np->n_net; + } + + /* + * Left justify the address and figure + * out a mask based on the supplied address. + * Set the mask according to the number of zero + * low-order bytes. + * Note: this works only for whole octet masks. + */ + if (addr) { + while ((addr & ~mask) != 0) { + mask |= (mask >> 8); + } + } + + emitop(OP_OFFSET_LINK); + switch (which) { + case TO: + compare_value_mask(16, 4, addr, mask); + break; + case FROM: + compare_value_mask(12, 4, addr, mask); + break; + case ANY: + compare_value_mask(12, 4, addr, mask); + emitop(OP_BRTR); + m = chain(0); + compare_value_mask(16, 4, addr, mask); + resolve_chain(m); + break; + } + emitop(OP_OFFSET_POP); +} + +/* + * Match either a UDP or TCP port number. + * The port number may be provided either as + * port name as listed in /etc/services ("nntp") or as + * the port number itself (2049). + */ +static void +port_match(enum direction which, char *portname) +{ + struct servent *sp; + uint_t m, port; + + if (isdigit(*portname)) { + port = atoi(portname); + } else { + sp = getservbyname(portname, NULL); + if (sp == NULL) + pr_err("invalid port number or name: %s", portname); + port = ntohs(sp->s_port); + } + + emitop(OP_OFFSET_IP); + + switch (which) { + case TO: + compare_value(2, 2, port); + break; + case FROM: + compare_value(0, 2, port); + break; + case ANY: + compare_value(2, 2, port); + emitop(OP_BRTR); + m = chain(0); + compare_value(0, 2, port); + resolve_chain(m); + break; + } + emitop(OP_OFFSET_POP); +} + +/* + * Generate code to match packets with a specific + * RPC program number. If the progname is a name + * it is converted to a number via /etc/rpc. + * The program version and/or procedure may be provided + * as extra qualifiers. + */ +static void +rpc_match_prog(enum direction which, char *progname, int vers, int proc) +{ + struct rpcent *rpc; + uint_t prog; + uint_t m, n; + + if (isdigit(*progname)) { + prog = atoi(progname); + } else { + rpc = (struct rpcent *)getrpcbyname(progname); + if (rpc == NULL) + pr_err("invalid program name: %s", progname); + prog = rpc->r_number; + } + + emitop(OP_OFFSET_RPC); + emitop(OP_BRFL); + n = chain(0); + + compare_value(12, 4, prog); + emitop(OP_BRFL); + m = chain(0); + if (vers >= 0) { + compare_value(16, 4, vers); + emitop(OP_BRFL); + m = chain(m); + } + if (proc >= 0) { + compare_value(20, 4, proc); + emitop(OP_BRFL); + m = chain(m); + } + + switch (which) { + case TO: + compare_value(4, 4, CALL); + emitop(OP_BRFL); + m = chain(m); + break; + case FROM: + compare_value(4, 4, REPLY); + emitop(OP_BRFL); + m = chain(m); + break; + } + resolve_chain(m); + resolve_chain(n); + emitop(OP_OFFSET_POP); +} + +/* + * Generate code to parse a field specification + * and load the value of the field from the packet + * onto the operand stack. + * The field offset may be specified relative to the + * beginning of the ether header, IP header, UDP header, + * or TCP header. An optional size specification may + * be provided following a colon. If no size is given + * one byte is assumed e.g. + * + * ether[0] The first byte of the ether header + * ip[2:2] The second 16 bit field of the IP header + */ +static void +load_field() +{ + int size = 1; + int s; + + + if (EQ("ether")) + emitop(OP_OFFSET_ZERO); + else if (EQ("ip") || EQ("ip6") || EQ("pppoed") || EQ("pppoes")) + emitop(OP_OFFSET_LINK); + else if (EQ("udp") || EQ("tcp") || EQ("icmp") || EQ("ip-in-ip") || + EQ("ah") || EQ("esp")) + emitop(OP_OFFSET_IP); + else + pr_err("invalid field type"); + next(); + s = opstack; + expression(); + if (opstack != s + 1) + pr_err("invalid field offset"); + opstack--; + if (*token == ':') { + next(); + if (tokentype != NUMBER) + pr_err("field size expected"); + size = tokenval; + if (size != 1 && size != 2 && size != 4) + pr_err("field size invalid"); + next(); + } + if (*token != ']') + pr_err("right bracket expected"); + + load_value(-1, size); + emitop(OP_OFFSET_POP); +} + +/* + * Check that the operand stack + * contains n arguments + */ +static void +checkstack(int numargs) +{ + if (opstack != numargs) + pr_err("invalid expression at \"%s\".", token); +} + +static void +primary() +{ + int m, m2, s; + + for (;;) { + if (tokentype == FIELD) { + load_field(); + opstack++; + next(); + break; + } + + if (comparison(token)) { + opstack++; + next(); + break; + } + + if (EQ("not") || EQ("!")) { + next(); + s = opstack; + primary(); + checkstack(s + 1); + emitop(OP_NOT); + break; + } + + if (EQ("(")) { + next(); + s = opstack; + expression(); + checkstack(s + 1); + if (!EQ(")")) + pr_err("right paren expected"); + next(); + } + + if (EQ("to") || EQ("dst")) { + dir = TO; + next(); + continue; + } + + if (EQ("from") || EQ("src")) { + dir = FROM; + next(); + continue; + } + + if (EQ("ether")) { + eaddr = 1; + next(); + continue; + } + + if (EQ("proto")) { + next(); + if (tokentype != NUMBER) + pr_err("IP proto type expected"); + emitop(OP_OFFSET_LINK); + compare_value(IPV4_TYPE_HEADER_OFFSET, 1, tokenval); + emitop(OP_OFFSET_POP); + opstack++; + next(); + continue; + } + + if (EQ("broadcast")) { + /* + * Be tricky: FDDI ether dst address begins at + * byte one. Since the address is really six + * bytes long, this works for FDDI & ethernet. + * XXX - Token ring? + */ + emitop(OP_OFFSET_ZERO); + if (interface->mac_type == DL_IB) + pr_err("filter option unsupported on media"); + compare_value(1, 4, 0xffffffff); + emitop(OP_OFFSET_POP); + opstack++; + next(); + break; + } + + if (EQ("multicast")) { + /* XXX Token ring? */ + emitop(OP_OFFSET_ZERO); + if (interface->mac_type == DL_FDDI) { + compare_value_mask(1, 1, 0x01, 0x01); + } else if (interface->mac_type == DL_IB) { + pr_err("filter option unsupported on media"); + } else { + compare_value_mask(0, 1, 0x01, 0x01); + } + emitop(OP_OFFSET_POP); + opstack++; + next(); + break; + } + + if (EQ("decnet")) { + /* XXX Token ring? */ + if (interface->mac_type == DL_FDDI) { + load_value(19, 2); /* ether type */ + load_const(0x6000); + emitop(OP_GE); + emitop(OP_BRFL); + m = chain(0); + load_value(19, 2); /* ether type */ + load_const(0x6009); + emitop(OP_LE); + resolve_chain(m); + } else { + emitop(OP_OFFSET_ETHERTYPE); + load_value(0, 2); /* ether type */ + load_const(0x6000); + emitop(OP_GE); + emitop(OP_BRFL); + m = chain(0); + load_value(0, 2); /* ether type */ + load_const(0x6009); + emitop(OP_LE); + resolve_chain(m); + emitop(OP_OFFSET_POP); + } + opstack++; + next(); + break; + } + + if (EQ("vlan-id")) { + next(); + if (tokentype != NUMBER) + pr_err("vlan id expected"); + emitop(OP_OFFSET_ZERO); + ethertype_match(ETHERTYPE_VLAN); + emitop(OP_BRFL); + m = chain(0); + compare_value_mask(VLAN_ID_OFFSET, 2, tokenval, + VLAN_ID_MASK); + resolve_chain(m); + emitop(OP_OFFSET_POP); + opstack++; + next(); + break; + } + + if (EQ("apple")) { + /* + * Appletalk also appears in 802.2 + * packets, so check for the ethertypes + * at offset 12 and 20 in the MAC header. + */ + ethertype_match(ETHERTYPE_AT); + emitop(OP_BRTR); + m = chain(0); + ethertype_match(ETHERTYPE_AARP); + emitop(OP_BRTR); + m = chain(m); + compare_value(20, 2, ETHERTYPE_AT); /* 802.2 */ + emitop(OP_BRTR); + m = chain(m); + compare_value(20, 2, ETHERTYPE_AARP); /* 802.2 */ + resolve_chain(m); + opstack++; + next(); + break; + } + + if (EQ("vlan")) { + ethertype_match(ETHERTYPE_VLAN); + compare_value_mask(VLAN_ID_OFFSET, 2, 0, VLAN_ID_MASK); + emitop(OP_NOT); + emitop(OP_AND); + opstack++; + next(); + break; + } + + if (EQ("bootp") || EQ("dhcp")) { + ethertype_match(interface->network_type_ip); + emitop(OP_BRFL); + m = chain(0); + emitop(OP_OFFSET_LINK); + compare_value(9, 1, IPPROTO_UDP); + emitop(OP_OFFSET_POP); + emitop(OP_BRFL); + m = chain(m); + emitop(OP_OFFSET_IP); + compare_value(0, 4, + (IPPORT_BOOTPS << 16) | IPPORT_BOOTPC); + emitop(OP_BRTR); + m2 = chain(0); + compare_value(0, 4, + (IPPORT_BOOTPC << 16) | IPPORT_BOOTPS); + resolve_chain(m2); + emitop(OP_OFFSET_POP); + resolve_chain(m); + opstack++; + dir = ANY; + next(); + break; + } + + if (EQ("dhcp6")) { + ethertype_match(interface->network_type_ipv6); + emitop(OP_BRFL); + m = chain(0); + emitop(OP_OFFSET_LINK); + compare_value(6, 1, IPPROTO_UDP); + emitop(OP_OFFSET_POP); + emitop(OP_BRFL); + m = chain(m); + emitop(OP_OFFSET_IP); + compare_value(2, 2, IPPORT_DHCPV6S); + emitop(OP_BRTR); + m2 = chain(0); + compare_value(2, 2, IPPORT_DHCPV6C); + resolve_chain(m2); + emitop(OP_OFFSET_POP); + resolve_chain(m); + opstack++; + dir = ANY; + next(); + break; + } + + if (EQ("ethertype")) { + next(); + if (tokentype != NUMBER) + pr_err("ether type expected"); + ethertype_match(tokenval); + opstack++; + next(); + break; + } + + if (EQ("pppoe")) { + ethertype_match(ETHERTYPE_PPPOED); + ethertype_match(ETHERTYPE_PPPOES); + emitop(OP_OR); + opstack++; + next(); + break; + } + + if (EQ("inet")) { + next(); + if (EQ("host")) + next(); + if (tokentype != ALPHA && tokentype != ADDR_IP) + pr_err("host/IPv4 addr expected after inet"); + ipaddr_match(dir, token, IPV4_ONLY); + opstack++; + next(); + break; + } + + if (EQ("inet6")) { + next(); + if (EQ("host")) + next(); + if (tokentype != ALPHA && tokentype != ADDR_IP6) + pr_err("host/IPv6 addr expected after inet6"); + ipaddr_match(dir, token, IPV6_ONLY); + opstack++; + next(); + break; + } + + if (EQ("length")) { + emitop(OP_LOAD_LENGTH); + opstack++; + next(); + break; + } + + if (EQ("less")) { + next(); + if (tokentype != NUMBER) + pr_err("packet length expected"); + emitop(OP_LOAD_LENGTH); + load_const(tokenval); + emitop(OP_LT); + opstack++; + next(); + break; + } + + if (EQ("greater")) { + next(); + if (tokentype != NUMBER) + pr_err("packet length expected"); + emitop(OP_LOAD_LENGTH); + load_const(tokenval); + emitop(OP_GT); + opstack++; + next(); + break; + } + + if (EQ("nofrag")) { + emitop(OP_OFFSET_LINK); + compare_value_mask(6, 2, 0, 0x1fff); + emitop(OP_OFFSET_POP); + emitop(OP_BRFL); + m = chain(0); + ethertype_match(interface->network_type_ip); + resolve_chain(m); + opstack++; + next(); + break; + } + + if (EQ("net") || EQ("dstnet") || EQ("srcnet")) { + if (EQ("dstnet")) + dir = TO; + else if (EQ("srcnet")) + dir = FROM; + next(); + netaddr_match(dir, token); + dir = ANY; + opstack++; + next(); + break; + } + + if (EQ("port") || EQ("srcport") || EQ("dstport")) { + if (EQ("dstport")) + dir = TO; + else if (EQ("srcport")) + dir = FROM; + next(); + port_match(dir, token); + dir = ANY; + opstack++; + next(); + break; + } + + if (EQ("rpc")) { + uint_t vers, proc; + char savetoken[32]; + + vers = proc = -1; + next(); + (void) strlcpy(savetoken, token, sizeof (savetoken)); + next(); + if (*token == ',') { + next(); + if (tokentype != NUMBER) + pr_err("version number expected"); + vers = tokenval; + next(); + } + if (*token == ',') { + next(); + if (tokentype != NUMBER) + pr_err("proc number expected"); + proc = tokenval; + next(); + } + rpc_match_prog(dir, savetoken, vers, proc); + dir = ANY; + opstack++; + break; + } + + if (EQ("slp")) { + /* filter out TCP handshakes */ + emitop(OP_OFFSET_LINK); + compare_value(9, 1, IPPROTO_TCP); + emitop(OP_LOAD_CONST); + emitval(52); + emitop(OP_LOAD_CONST); + emitval(2); + emitop(OP_LOAD_SHORT); + emitop(OP_GE); + emitop(OP_AND); /* proto == TCP && len < 52 */ + emitop(OP_NOT); + emitop(OP_BRFL); /* pkt too short to be a SLP call */ + m = chain(0); + + emitop(OP_OFFSET_POP); + emitop(OP_OFFSET_SLP); + resolve_chain(m); + opstack++; + next(); + break; + } + + if (EQ("ldap")) { + dir = ANY; + port_match(dir, "ldap"); + opstack++; + next(); + break; + } + + if (EQ("and") || EQ("or")) { + break; + } + + if (EQ("zone")) { + next(); + if (tokentype != NUMBER) + pr_err("zoneid expected"); + zone_match(dir, BE_32((uint32_t)(tokenval))); + opstack++; + next(); + break; + } + + if (EQ("gateway")) { + next(); + if (eaddr || tokentype != ALPHA) + pr_err("hostname required: %s", token); + etheraddr_match(dir, token); + dir = ANY; + emitop(OP_BRFL); + m = chain(0); + ipaddr_match(dir, token, IPV4_AND_IPV6); + emitop(OP_NOT); + resolve_chain(m); + opstack++; + next(); + } + + if (EQ("host") || EQ("between") || + tokentype == ALPHA || /* assume its a hostname */ + tokentype == ADDR_IP || + tokentype == ADDR_IP6 || + tokentype == ADDR_AT || + tokentype == ADDR_ETHER) { + if (EQ("host") || EQ("between")) + next(); + if (eaddr || tokentype == ADDR_ETHER) { + etheraddr_match(dir, token); + } else if (tokentype == ALPHA) { + ipaddr_match(dir, token, IPV4_AND_IPV6); + } else if (tokentype == ADDR_AT) { + ataddr_match(dir, token); + } else if (tokentype == ADDR_IP) { + ipaddr_match(dir, token, IPV4_ONLY); + } else { + ipaddr_match(dir, token, IPV6_ONLY); + } + dir = ANY; + eaddr = 0; + opstack++; + next(); + break; + } + + if (tokentype == NUMBER) { + load_const(tokenval); + opstack++; + next(); + break; + } + + break; /* unknown token */ + } +} + +struct optable { + char *op_tok; + enum optype op_type; +}; + +static struct optable +mulops[] = { + "*", OP_MUL, + "/", OP_DIV, + "%", OP_REM, + "&", OP_AND, + "", OP_STOP, +}; + +static struct optable +addops[] = { + "+", OP_ADD, + "-", OP_SUB, + "|", OP_OR, + "^", OP_XOR, + "", OP_STOP, +}; + +static struct optable +compareops[] = { + "==", OP_EQ, + "=", OP_EQ, + "!=", OP_NE, + ">", OP_GT, + ">=", OP_GE, + "<", OP_LT, + "<=", OP_LE, + "", OP_STOP, +}; + +/* + * Using the table, find the operator + * that corresponds to the token. + * Return 0 if not found. + */ +static int +find_op(char *tok, struct optable *table) +{ + struct optable *op; + + for (op = table; *op->op_tok; op++) { + if (strcmp(tok, op->op_tok) == 0) + return (op->op_type); + } + + return (0); +} + +static void +expr_mul() +{ + int op; + int s = opstack; + + primary(); + while (op = find_op(token, mulops)) { + next(); + primary(); + checkstack(s + 2); + emitop(op); + opstack--; + } +} + +static void +expr_add() +{ + int op, s = opstack; + + expr_mul(); + while (op = find_op(token, addops)) { + next(); + expr_mul(); + checkstack(s + 2); + emitop(op); + opstack--; + } +} + +static void +expr_compare() +{ + int op, s = opstack; + + expr_add(); + while (op = find_op(token, compareops)) { + next(); + expr_add(); + checkstack(s + 2); + emitop(op); + opstack--; + } +} + +/* + * Alternation ("and") is difficult because + * an implied "and" is acknowledge between + * two adjacent primaries. Just keep calling + * the lower-level expression routine until + * no value is added to the opstack. + */ +static void +alternation() +{ + int m = 0; + int s = opstack; + + expr_compare(); + checkstack(s + 1); + for (;;) { + if (EQ("and")) + next(); + emitop(OP_BRFL); + m = chain(m); + expr_compare(); + if (opstack != s + 2) + break; + opstack--; + } + unemit(2); + resolve_chain(m); +} + +static void +expression() +{ + int m = 0; + int s = opstack; + + alternation(); + while (EQ("or") || EQ(",")) { + emitop(OP_BRTR); + m = chain(m); + next(); + alternation(); + checkstack(s + 2); + opstack--; + } + resolve_chain(m); +} + +/* + * Take n args from the argv list + * and concatenate them into a single string. + */ +char * +concat_args(char **argv, int argc) +{ + int i, len; + char *str, *p; + + /* First add the lengths of all the strings */ + len = 0; + for (i = 0; i < argc; i++) + len += strlen(argv[i]) + 1; + + /* allocate the big string */ + str = (char *)malloc(len); + if (str == NULL) + pr_err("no mem"); + + p = str; + + /* + * Concat the strings into the big + * string using a space as separator + */ + for (i = 0; i < argc; i++) { + strcpy(p, argv[i]); + p += strlen(p); + *p++ = ' '; + } + *--p = '\0'; + + return (str); +} + +/* + * Take the expression in the string "expr" + * and compile it into the code array. + * Print the generated code if the print + * arg is set. + */ +void +compile(char *expr, int print) +{ + expr = strdup(expr); + if (expr == NULL) + pr_err("no mem"); + curr_op = oplist; + tkp = expr; + dir = ANY; + + next(); + if (tokentype != EOL) + expression(); + emitop(OP_STOP); + if (tokentype != EOL) + pr_err("invalid expression"); + optimize(oplist); + if (print) + codeprint(); +} + +/* + * Lookup hostname in the arp cache. + */ +boolean_t +arp_for_ether(char *hostname, struct ether_addr *ep) +{ + struct arpreq ar; + struct hostent *hp; + struct sockaddr_in *sin; + int error_num; + int s; + + memset(&ar, 0, sizeof (ar)); + sin = (struct sockaddr_in *)&ar.arp_pa; + sin->sin_family = AF_INET; + hp = getipnodebyname(hostname, AF_INET, 0, &error_num); + if (hp == NULL) { + return (B_FALSE); + } + memcpy(&sin->sin_addr, hp->h_addr, sizeof (sin->sin_addr)); + s = socket(AF_INET, SOCK_DGRAM, 0); + if (s < 0) { + return (B_FALSE); + } + if (ioctl(s, SIOCGARP, &ar) < 0) { + close(s); + return (B_FALSE); + } + close(s); + memcpy(ep->ether_addr_octet, ar.arp_ha.sa_data, sizeof (*ep)); + return (B_TRUE); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_http.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_http.c new file mode 100644 index 0000000..b6e6b9d --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_http.c @@ -0,0 +1,141 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1996-1998,2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Protocol interpreter for the Hypertext Transfer Protocol (HTTP) + * + * Relevant standards: + * Berners-Lee, T., et al: Hypertext Transfer Protocol -- HTTP/1.0. + * RFC 1945, May 1996 + * Fielding, R., et al: Hypertext Transfer Protocol -- HTTP/1.1. + * RFC 2068, June 1999 + */ + +#include <netinet/in.h> +#include <stdio.h> +#include <string.h> +#include <ctype.h> +#include "snoop.h" + +#define CR 13 /* "carriage return" character */ +#define LF 10 /* "line feed" character */ + +/* + * Summary lines: packet contents starting with less than MINCHARS + * printable characters will not be printed. MAXCHARS is the maximum + * number of characters printed. + * Detail lines: NLINES is the maximum number of content lines to print + */ +#define MINCHARS 10 +#define MAXCHARS 80 +#define NLINES 5 + +#define MIN(a, b) (((a) < (b)) ? (a) : (b)) + +static int printable(const char *line, const char *endp); + +int +interpret_http(int flags, char *line, int fraglen) +{ + char *p, *q, *endp; + int c; + int lineno; + + endp = line + fraglen; + + if (flags & F_SUM) { + c = printable(line, endp - 1); + if (c < MINCHARS) { + (void) snprintf(get_sum_line(), MAXLINE, + "HTTP (body)"); + } else { + (void) snprintf(get_sum_line(), MAXLINE, + "HTTP %.*s", MIN(c, MAXCHARS), line); + } + } + + if (flags & F_DTAIL) { + show_header("HTTP: ", "HyperText Transfer Protocol", fraglen); + show_space(); + + lineno = 0; + for (p = line; p < endp && lineno < NLINES; p = q + 1) { + c = printable(p, endp - 1); + + /* stop if no printables, except if at line end */ + if (c == 0 && *p != CR && *p != LF) + break; + + /* + * A line may be terminated either by an CR LF sequence + * (DOS, Mac), or by LF alone + */ + + q = memchr(p, CR, (endp - p)); + if (q != NULL) { + if (q < endp - 1 && q[1] == LF) + ++q; /* ignore subsequent LF character */ + } else { + q = memchr(p, LF, (endp - p)); + /* no CR/LF: use end of buffer */ + if (q == NULL) + q = endp - 1; + } + + /* truncate lines containing non-printable characters */ + (void) snprintf(get_line(0, c), get_line_remain(), + "%.*s", c, p); + ++lineno; + } + + if (p < endp) /* there was more data to be printed */ + (void) snprintf(get_line(0, 5), get_line_remain(), + "[...]"); + + show_space(); + } + + return (fraglen); +} + +/* + * Return the length of the initial string starting with "startp" and + * ending with "endp" (inclusively) consisting only of printable + * characters. + */ + +static int +printable(const char *startp, const char *endp) +{ + const char *p = startp; + + while (p <= endp && (isprint(*p) || *p == '\t')) + p++; + + return (p - startp); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_icmp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_icmp.c new file mode 100644 index 0000000..4f6fa8a --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_icmp.c @@ -0,0 +1,1003 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <net/if.h> +#include <sys/stropts.h> +#include <sys/sysmacros.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/ip_icmp.h> +#include <netinet/udp.h> +#include <netinet/tcp.h> +#include <netinet/icmp6.h> +#include <netinet/ip6.h> +#include <inet/ip.h> +#include <inet/ip6.h> +#include <arpa/inet.h> +#include <netdb.h> +#include "snoop.h" +#include "snoop_mip.h" + +static void interpret_options(char *, int); +static void interpret_mldv2qry(icmp6_t *, int); +static void interpret_mldv2rpt(icmp6_t *, int); + + +/* Mobile-IP routines from snoop_mip.c */ +extern void interpret_icmp_mip_ext(uchar_t *, int); +extern const char *get_mip_adv_desc(uint8_t); + +/* Router advertisement message structure. */ +struct icmp_ra_addr { + uint32_t addr; + uint32_t preference; +}; + +/*ARGSUSED*/ +void +interpret_icmp(int flags, struct icmp *icmp, int iplen, int ilen) +{ + char *pt, *pc, *px; + char *line; + char buff[67627]; /* Router adv. can have 256 routers .... */ + /* Each router has a name 256 char long .. */ + char extbuff[MAXHOSTNAMELEN + 1]; + struct udphdr *orig_uhdr; + int num_rtr_addrs = 0; + extern char *prot_nest_prefix; + + if (ilen < ICMP_MINLEN) + return; /* incomplete header */ + + pt = "Unknown"; + pc = ""; + px = ""; + + switch (icmp->icmp_type) { + case ICMP_ECHOREPLY: + pt = "Echo reply"; + (void) sprintf(buff, "ID: %d Sequence number: %d", + ntohs(icmp->icmp_id), ntohs(icmp->icmp_seq)); + pc = buff; + break; + case ICMP_UNREACH: + pt = "Destination unreachable"; + switch (icmp->icmp_code) { + case ICMP_UNREACH_NET: + if (ilen >= ICMP_ADVLENMIN) { + (void) sprintf(buff, "Net %s unreachable", + addrtoname(AF_INET, + &icmp->icmp_ip.ip_dst)); + pc = buff; + } else { + pc = "Bad net"; + } + break; + case ICMP_UNREACH_HOST: + if (ilen >= ICMP_ADVLENMIN) { + (void) sprintf(buff, "Host %s unreachable", + addrtoname(AF_INET, + &icmp->icmp_ip.ip_dst)); + pc = buff; + } else { + pc = "Bad host"; + } + break; + case ICMP_UNREACH_PROTOCOL: + if (ilen >= ICMP_ADVLENMIN) { + (void) sprintf(buff, "Bad protocol %d", + icmp->icmp_ip.ip_p); + pc = buff; + } else { + pc = "Bad protocol"; + } + break; + case ICMP_UNREACH_PORT: + if (ilen >= ICMP_ADVLENMIN) { + orig_uhdr = (struct udphdr *)((uchar_t *)icmp + + ICMP_MINLEN + icmp->icmp_ip.ip_hl * 4); + switch (icmp->icmp_ip.ip_p) { + case IPPROTO_TCP: + (void) sprintf(buff, "TCP port %d" + " unreachable", + ntohs(orig_uhdr->uh_dport)); + pc = buff; + break; + case IPPROTO_UDP: + (void) sprintf(buff, "UDP port %d" + " unreachable", + ntohs(orig_uhdr->uh_dport)); + pc = buff; + break; + default: + pc = "Port unreachable"; + break; + } + } else { + pc = "Bad port"; + } + break; + case ICMP_UNREACH_NEEDFRAG: + if (ntohs(icmp->icmp_nextmtu) != 0) { + (void) sprintf(buff, "Needed to fragment:" + " next hop MTU = %d", + ntohs(icmp->icmp_nextmtu)); + pc = buff; + } else { + pc = "Needed to fragment"; + } + break; + case ICMP_UNREACH_SRCFAIL: + pc = "Source route failed"; + break; + case ICMP_UNREACH_NET_UNKNOWN: + pc = "Unknown network"; + break; + case ICMP_UNREACH_HOST_UNKNOWN: + pc = "Unknown host"; + break; + case ICMP_UNREACH_ISOLATED: + pc = "Source host isolated"; + break; + case ICMP_UNREACH_NET_PROHIB: + pc = "Net administratively prohibited"; + break; + case ICMP_UNREACH_HOST_PROHIB: + pc = "Host administratively prohibited"; + break; + case ICMP_UNREACH_TOSNET: + pc = "Net unreachable for this TOS"; + break; + case ICMP_UNREACH_TOSHOST: + pc = "Host unreachable for this TOS"; + break; + case ICMP_UNREACH_FILTER_PROHIB: + pc = "Communication administratively prohibited"; + break; + case ICMP_UNREACH_HOST_PRECEDENCE: + pc = "Host precedence violation"; + break; + case ICMP_UNREACH_PRECEDENCE_CUTOFF: + pc = "Precedence cutoff in effect"; + break; + default: + break; + } + break; + case ICMP_SOURCEQUENCH: + pt = "Packet lost, slow down"; + break; + case ICMP_REDIRECT: + pt = "Redirect"; + switch (icmp->icmp_code) { + case ICMP_REDIRECT_NET: + pc = "for network"; + break; + case ICMP_REDIRECT_HOST: + pc = "for host"; + break; + case ICMP_REDIRECT_TOSNET: + pc = "for tos and net"; + break; + case ICMP_REDIRECT_TOSHOST: + pc = "for tos and host"; + break; + default: + break; + } + (void) sprintf(buff, "%s %s to %s", + pc, addrtoname(AF_INET, &icmp->icmp_ip.ip_dst), + addrtoname(AF_INET, &icmp->icmp_gwaddr)); + pc = buff; + break; + case ICMP_ECHO: + pt = "Echo request"; + (void) sprintf(buff, "ID: %d Sequence number: %d", + ntohs(icmp->icmp_id), ntohs(icmp->icmp_seq)); + pc = buff; + break; + case ICMP_ROUTERADVERT: + +#define icmp_num_addrs icmp_hun.ih_rtradv.irt_num_addrs +#define icmp_wpa icmp_hun.ih_rtradv.irt_wpa +#define icmp_lifetime icmp_hun.ih_rtradv.irt_lifetime + + pt = "Router advertisement"; + (void) sprintf(buff, "Lifetime %ds [%d]:", + ntohs(icmp->icmp_lifetime), icmp->icmp_num_addrs); + if (icmp->icmp_wpa == 2) { + struct icmp_ra_addr *ra; + char ra_buf[MAXHOSTNAMELEN + 32]; + char ra_ext_buf[50]; + struct in_addr sin; + int icmp_ra_len; + int i; + + /* Cannot trust anything from the network... */ + num_rtr_addrs = MIN((ilen - ICMP_MINLEN) / 8, + icmp->icmp_num_addrs); + + ra = (struct icmp_ra_addr *)icmp->icmp_data; + for (i = 0; i < num_rtr_addrs; i++) { + sin.s_addr = ra->addr; + (void) snprintf(ra_buf, sizeof (ra_buf), + " {%s %u}", + addrtoname(AF_INET, &sin), + ntohl(ra->preference)); + if (strlcat(buff, ra_buf, sizeof (buff)) >= + sizeof (buff)) { + buff[sizeof (buff) - + strlen("<Too Long>)")] = '\0'; + (void) strlcat(buff, "<Too Long>", + sizeof (buff)); + break; + } + ra++; + } + + icmp_ra_len = ICMP_MINLEN + num_rtr_addrs * + sizeof (struct icmp_ra_addr); + if (ilen > icmp_ra_len) { + int curr_len = ilen - icmp_ra_len; + int ocurr_len; + exthdr_t *exthdr = (exthdr_t *)ra; + + extbuff[0] = '\0'; + + while (curr_len > 0) { + /* Append Mobile-IP description */ + (void) snprintf(ra_ext_buf, + sizeof (ra_ext_buf), ", %s", + get_mip_adv_desc(exthdr->type)); + (void) strlcat(extbuff, ra_ext_buf, + sizeof (extbuff)); + + /* Special case for padding */ + if (exthdr->type == + ICMP_ADV_MSG_PADDING_EXT) { + + curr_len--; + exthdr = (exthdr_t *) + ((char *)exthdr + 1); + continue; + } + + /* else normal extension */ + ocurr_len = curr_len; + curr_len -= sizeof (*exthdr) + + exthdr->length; + /* detect bad length */ + if (ocurr_len < curr_len) + break; + exthdr = (exthdr_t *) + ((char *)exthdr + + sizeof (*exthdr) + + exthdr->length); + } + px = extbuff; + } + pc = buff; + } + break; + case ICMP_ROUTERSOLICIT: + pt = "Router solicitation"; + break; + case ICMP_TIMXCEED: + pt = "Time exceeded"; + switch (icmp->icmp_code) { + case ICMP_TIMXCEED_INTRANS: + pc = "in transit"; + break; + case ICMP_TIMXCEED_REASS: + pc = "in reassembly"; + break; + default: + break; + } + break; + case ICMP_PARAMPROB: + pt = "IP parameter problem"; + switch (icmp->icmp_code) { + case ICMP_PARAMPROB_OPTABSENT: + pc = "Required option missing"; + break; + case ICMP_PARAMPROB_BADLENGTH: + pc = "Bad length"; + break; + case 0: /* Should this be the default? */ + (void) sprintf(buff, "Problem at octet %d\n", + icmp->icmp_pptr); + pc = buff; + default: + break; + } + break; + case ICMP_TSTAMP: + pt = "Timestamp request"; + break; + case ICMP_TSTAMPREPLY: + pt = "Timestamp reply"; + break; + case ICMP_IREQ: + pt = "Information request"; + break; + case ICMP_IREQREPLY: + pt = "Information reply"; + break; + case ICMP_MASKREQ: + pt = "Address mask request"; + break; + case ICMP_MASKREPLY: + pt = "Address mask reply"; + (void) sprintf(buff, "Mask = 0x%x", ntohl(icmp->icmp_mask)); + pc = buff; + break; + default: + break; + } + + if (flags & F_SUM) { + line = get_sum_line(); + if (*pc) { + if (*px) { + (void) sprintf(line, "ICMP %s (%s)%s", + pt, pc, px); + } else { + (void) sprintf(line, "ICMP %s (%s)", pt, pc); + } + } else { + (void) sprintf(line, "ICMP %s", pt); + } + } + + if (flags & F_DTAIL) { + show_header("ICMP: ", "ICMP Header", ilen); + show_space(); + (void) sprintf(get_line(0, 0), "Type = %d (%s)", + icmp->icmp_type, pt); + if (*pc) { + (void) sprintf(get_line(0, 0), "Code = %d (%s)", + icmp->icmp_code, pc); + } else { + (void) sprintf(get_line(0, 0), "Code = %d", + icmp->icmp_code); + } + (void) sprintf(get_line(0, 0), "Checksum = %x", + ntohs(icmp->icmp_cksum)); + + if (icmp->icmp_type == ICMP_UNREACH || + icmp->icmp_type == ICMP_REDIRECT) { + if (ilen > 28) { + show_space(); + (void) sprintf(get_line(0, 0), + "[ subject header follows ]"); + show_space(); + prot_nest_prefix = "ICMP:"; + (void) interpret_ip(flags, + (struct ip *)icmp->icmp_data, 28); + prot_nest_prefix = ""; + } + } else if (icmp->icmp_type == ICMP_PARAMPROB) { + if (ilen > 28) { + show_space(); + (void) sprintf(get_line(0, 0), + "[ subject header follows ]"); + show_space(); + prot_nest_prefix = "ICMP:"; + (void) interpret_ip(flags, + (struct ip *)icmp->icmp_data, 28); + prot_nest_prefix = ""; + } + } else if (icmp->icmp_type == ICMP_ROUTERADVERT) { + if (icmp->icmp_wpa == 2) { + int icmp_ra_len; + + show_space(); + icmp_ra_len = ICMP_MINLEN + + num_rtr_addrs * + sizeof (struct icmp_ra_addr); + prot_nest_prefix = ""; + if (ilen > icmp_ra_len) { + interpret_icmp_mip_ext( + (uchar_t *)icmp + icmp_ra_len, + ilen - icmp_ra_len); + } + } + } + show_space(); + } +} + +/*ARGSUSED*/ +void +interpret_icmpv6(flags, icmp6, iplen, ilen) + int flags; + icmp6_t *icmp6; + int iplen, ilen; +{ + char *pt, *pc; + char *line; + extern char *prot_nest_prefix; + char addrstr[INET6_ADDRSTRLEN]; + char buff[2048]; + + if (ilen < ICMP6_MINLEN) + return; /* incomplete header */ + + pt = "Unknown"; + pc = ""; + + switch (icmp6->icmp6_type) { + case ICMP6_DST_UNREACH: + pt = "Destination unreachable"; + switch (icmp6->icmp6_code) { + case ICMP6_DST_UNREACH_NOROUTE: + pc = "No route to destination"; + break; + case ICMP6_DST_UNREACH_ADMIN: + pc = "Communication administratively prohibited"; + break; + case ICMP6_DST_UNREACH_ADDR: + pc = "Address unreachable"; + break; + case ICMP6_DST_UNREACH_NOPORT: + if (ilen >= ICMP6_MINLEN + IPV6_HDR_LEN + + sizeof (struct udphdr)) { + + ip6_t *orig_ip6hdr = (ip6_t *)&icmp6[1]; + + switch (orig_ip6hdr->ip6_nxt) { + case IPPROTO_TCP: { + struct tcphdr *orig_thdr = + (struct tcphdr *)&orig_ip6hdr[1]; + + (void) sprintf(buff, "TCP port %hu" + " unreachable", + ntohs(orig_thdr->th_dport)); + pc = buff; + break; + } + case IPPROTO_UDP: { + struct udphdr *orig_uhdr = + (struct udphdr *)&orig_ip6hdr[1]; + + (void) sprintf(buff, "UDP port %hu" + " unreachable", + ntohs(orig_uhdr->uh_dport)); + pc = buff; + break; + } + default: + pc = "Port unreachable"; + break; + } + } else { + pc = "Bad port"; + } + break; + default: + break; + } + break; + case ICMP6_PACKET_TOO_BIG: + pt = "Packet too big"; + break; + case ND_REDIRECT: + pt = "Redirect"; + break; + case ICMP6_TIME_EXCEEDED: + pt = "Time exceeded"; + switch (icmp6->icmp6_code) { + case ICMP6_TIME_EXCEED_TRANSIT: + pc = "Hop limit exceeded in transit"; + break; + case ICMP6_TIME_EXCEED_REASSEMBLY: + pc = "Fragment reassembly time exceeded"; + break; + default: + break; + } + break; + case ICMP6_PARAM_PROB: + pt = "Parameter problem"; + switch (icmp6->icmp6_code) { + case ICMP6_PARAMPROB_HEADER: + pc = "Erroneous header field"; + break; + case ICMP6_PARAMPROB_NEXTHEADER: + pc = "Unrecognized next header type"; + break; + case ICMP6_PARAMPROB_OPTION: + pc = "Unrecognized IPv6 option"; + break; + } + break; + case ICMP6_ECHO_REQUEST: + pt = "Echo request"; + (void) sprintf(buff, "ID: %d Sequence number: %d", + ntohs(icmp6->icmp6_id), ntohs(icmp6->icmp6_seq)); + pc = buff; + break; + case ICMP6_ECHO_REPLY: + pt = "Echo reply"; + (void) sprintf(buff, "ID: %d Sequence number: %d", + ntohs(icmp6->icmp6_id), ntohs(icmp6->icmp6_seq)); + pc = buff; + break; + case MLD_LISTENER_QUERY: + if (ilen == MLD_MINLEN) + pt = "Group membership query - MLDv1"; + else if (ilen >= MLD_V2_QUERY_MINLEN) + pt = "Group membership query - MLDv2"; + else + pt = "Unknown membership query"; + break; + case MLD_LISTENER_REPORT: + pt = "Group membership report - MLDv1"; + break; + case MLD_LISTENER_REDUCTION: + pt = "Group membership termination - MLDv1"; + break; + case MLD_V2_LISTENER_REPORT: + pt = "Group membership report - MLDv2"; + break; + case ND_ROUTER_SOLICIT: + pt = "Router solicitation"; + break; + case ND_ROUTER_ADVERT: + pt = "Router advertisement"; + break; + case ND_NEIGHBOR_SOLICIT: + pt = "Neighbor solicitation"; + break; + case ND_NEIGHBOR_ADVERT: + pt = "Neighbor advertisement"; + break; + default: + break; + } + + if (flags & F_SUM) { + line = get_sum_line(); + if (*pc) + (void) sprintf(line, "ICMPv6 %s (%s)", pt, pc); + else + (void) sprintf(line, "ICMPv6 %s", pt); + } + + if (flags & F_DTAIL) { + show_header("ICMPv6: ", "ICMPv6 Header", ilen); + show_space(); + (void) sprintf(get_line(0, 0), "Type = %d (%s)", + icmp6->icmp6_type, pt); + if (*pc) + (void) sprintf(get_line(0, 0), "Code = %d (%s)", + icmp6->icmp6_code, pc); + else + (void) sprintf(get_line(0, 0), "Code = %d", + icmp6->icmp6_code); + (void) sprintf(get_line(0, 0), "Checksum = %x", + ntohs(icmp6->icmp6_cksum)); + + switch (icmp6->icmp6_type) { + case ICMP6_DST_UNREACH: + if (ilen > ICMP6_MINLEN + IPV6_HDR_LEN) { + show_space(); + (void) sprintf(get_line(0, 0), + "[ subject header follows ]"); + show_space(); + prot_nest_prefix = "ICMPv6:"; + (void) interpret_ipv6(flags, (ip6_t *)&icmp6[1], + ICMP6_MINLEN + IPV6_HDR_LEN); + prot_nest_prefix = ""; + } + break; + case ICMP6_PACKET_TOO_BIG: + show_space(); + (void) sprintf(get_line(0, 0), + " Packet too big MTU = %d", + ntohl(icmp6->icmp6_mtu)); + show_space(); + break; + case ND_REDIRECT: { + nd_redirect_t *rd = (nd_redirect_t *)icmp6; + + (void) sprintf(get_line(0, 0), "Target address= %s", + inet_ntop(AF_INET6, (char *)&rd->nd_rd_target, + addrstr, INET6_ADDRSTRLEN)); + + (void) sprintf(get_line(0, 0), + "Destination address= %s", + inet_ntop(AF_INET6, (char *)&rd->nd_rd_dst, + addrstr, INET6_ADDRSTRLEN)); + show_space(); + interpret_options((char *)icmp6 + sizeof (*rd), + ilen - sizeof (*rd)); + break; + } + case ND_NEIGHBOR_SOLICIT: { + struct nd_neighbor_solicit *ns; + if (ilen < sizeof (*ns)) + break; + ns = (struct nd_neighbor_solicit *)icmp6; + (void) sprintf(get_line(0, 0), "Target node = %s, %s", + inet_ntop(AF_INET6, (char *)&ns->nd_ns_target, + addrstr, INET6_ADDRSTRLEN), + addrtoname(AF_INET6, &ns->nd_ns_target)); + show_space(); + interpret_options((char *)icmp6 + sizeof (*ns), + ilen - sizeof (*ns)); + break; + } + + case ND_NEIGHBOR_ADVERT: { + struct nd_neighbor_advert *na; + + if (ilen < sizeof (*na)) + break; + na = (struct nd_neighbor_advert *)icmp6; + (void) sprintf(get_line(0, 0), "Target node = %s, %s", + inet_ntop(AF_INET6, (char *)&na->nd_na_target, + addrstr, INET6_ADDRSTRLEN), + addrtoname(AF_INET6, &na->nd_na_target)); + (void) sprintf(get_line(0, 0), + "Router flag: %s, Solicited flag: %s, " + "Override flag: %s", + na->nd_na_flags_reserved & ND_NA_FLAG_ROUTER ? + "SET" : "NOT SET", + na->nd_na_flags_reserved & ND_NA_FLAG_SOLICITED ? + "SET" : "NOT SET", + na->nd_na_flags_reserved & ND_NA_FLAG_OVERRIDE ? + "SET" : "NOT SET"); + + show_space(); + interpret_options((char *)icmp6 + sizeof (*na), + ilen - sizeof (*na)); + } + break; + + case ND_ROUTER_SOLICIT: { + if (ilen < sizeof (struct nd_router_solicit)) + break; + interpret_options( + (char *)icmp6 + sizeof (struct nd_router_solicit), + ilen - sizeof (struct nd_router_solicit)); + break; + } + + case ND_ROUTER_ADVERT: { + struct nd_router_advert *ra; + + if (ilen < sizeof (*ra)) + break; + ra = (struct nd_router_advert *)icmp6; + (void) sprintf(get_line(0, 0), + "Max hops= %d, Router lifetime= %d", + ra->nd_ra_curhoplimit, + ntohs(ra->nd_ra_router_lifetime)); + + (void) sprintf(get_line(0, 0), + "Managed addr conf flag: %s, Other conf flag: %s", + ra->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED ? + "SET" : "NOT SET", + ra->nd_ra_flags_reserved & ND_RA_FLAG_OTHER ? + "SET" : "NOT SET"); + + (void) sprintf(get_line(0, 0), + "Reachable time: %u, Reachable retrans time %u", + ntohl(ra->nd_ra_reachable), + ntohl(ra->nd_ra_retransmit)); + show_space(); + + interpret_options((char *)icmp6 + sizeof (*ra), + ilen - sizeof (*ra)); + break; + } + case ICMP6_PARAM_PROB: + if (ilen < sizeof (*icmp6)) + break; + (void) sprintf(get_line(0, 0), "Ptr = %u", + ntohl(icmp6->icmp6_pptr)); + show_space(); + break; + + case MLD_LISTENER_QUERY: { + struct mld_hdr *mldg = (struct mld_hdr *)icmp6; + + if (ilen < MLD_MINLEN) + break; + + if (ilen >= MLD_V2_QUERY_MINLEN) { + interpret_mldv2qry(icmp6, ilen); + } else { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Multicast address= %s", + inet_ntop(AF_INET6, mldg->mld_addr.s6_addr, + addrstr, INET6_ADDRSTRLEN)); + } + show_space(); + break; + } + + case MLD_LISTENER_REPORT: + case MLD_LISTENER_REDUCTION: { + struct mld_hdr *mldg; + + if (ilen < sizeof (*mldg)) + break; + mldg = (struct mld_hdr *)icmp6; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Multicast address= %s", inet_ntop(AF_INET6, + mldg->mld_addr.s6_addr, addrstr, INET6_ADDRSTRLEN)); + show_space(); + break; + } + + case MLD_V2_LISTENER_REPORT: { + interpret_mldv2rpt(icmp6, ilen); + show_space(); + break; + } + + default: + break; + } + } +} + +static void +interpret_options(optc, ilen) + char *optc; + int ilen; +{ +#define PREFIX_OPTION_LENGTH 4 +#define MTU_OPTION_LENGTH 1 + +#define PREFIX_INFINITY 0xffffffffUL + + struct nd_opt_hdr *opt; + + for (; ilen >= sizeof (*opt); ) { + opt = (struct nd_opt_hdr *)optc; + if (opt->nd_opt_len == 0) + return; + switch (opt->nd_opt_type) { + case ND_OPT_SOURCE_LINKADDR: + case ND_OPT_TARGET_LINKADDR: + { + struct nd_opt_lla *lopt; + char *buf, chbuf[128]; + uint_t addr_len; + int i; + + if (ilen < (int)opt->nd_opt_len * 8) + break; + + buf = chbuf; + + lopt = (struct nd_opt_lla *)opt; + if (lopt->nd_opt_lla_type == ND_OPT_SOURCE_LINKADDR) { + (void) sprintf(get_line(0, 0), + "+++ ICMPv6 Source LL Addr option +++"); + } else { + (void) sprintf(get_line(0, 0), + "+++ ICMPv6 Target LL Addr option +++"); + } + + /* + * The option length is in 8 octet units, and + * includes the first two bytes (the type and + * lenght fields) of the option. + */ + addr_len = lopt->nd_opt_lla_len * 8 - 2; + for (i = 0; i < addr_len; i++) { + snprintf(buf, sizeof (chbuf) - (buf - chbuf), + "%x:", lopt->nd_opt_lla_hdw_addr[i]); + buf += strlen(buf); + if (buf >= &chbuf[sizeof (chbuf)]) { + buf = NULL; + chbuf[sizeof (chbuf) - + strlen("<Too Long>)")] = '\0'; + (void) strlcat(chbuf, "<Too Long>", + sizeof (chbuf)); + break; + } + } + if (buf) + *(buf - 1) = '\0'; /* Erase last colon */ + (void) sprintf(get_line(0, 0), + "Link Layer address: %s", chbuf); + show_space(); + break; + } + case ND_OPT_MTU: { + struct nd_opt_mtu *mopt; + if (opt->nd_opt_len != MTU_OPTION_LENGTH || + ilen < sizeof (struct nd_opt_mtu)) + break; + (void) sprintf(get_line(0, 0), + "+++ ICMPv6 MTU option +++"); + mopt = (struct nd_opt_mtu *)opt; + (void) sprintf(get_line(0, 0), + "MTU = %u ", ntohl(mopt->nd_opt_mtu_mtu)); + show_space(); + break; + } + case ND_OPT_PREFIX_INFORMATION: { + struct nd_opt_prefix_info *popt; + char validstr[30]; + char preferredstr[30]; + char prefixstr[INET6_ADDRSTRLEN]; + + if (opt->nd_opt_len != PREFIX_OPTION_LENGTH || + ilen < sizeof (struct nd_opt_prefix_info)) + break; + popt = (struct nd_opt_prefix_info *)opt; + (void) sprintf(get_line(0, 0), + "+++ ICMPv6 Prefix option +++"); + (void) sprintf(get_line(0, 0), + "Prefix length = %d ", popt->nd_opt_pi_prefix_len); + (void) sprintf(get_line(0, 0), + "Onlink flag: %s, Autonomous addr conf flag: %s", + popt->nd_opt_pi_flags_reserved & + ND_OPT_PI_FLAG_ONLINK ? "SET" : "NOT SET", + popt->nd_opt_pi_flags_reserved & + ND_OPT_PI_FLAG_AUTO ? "SET" : "NOT SET"); + + if (ntohl(popt->nd_opt_pi_valid_time) == + PREFIX_INFINITY) + sprintf(validstr, "INFINITY"); + else + sprintf(validstr, "%lu", + ntohl(popt->nd_opt_pi_valid_time)); + + if (ntohl(popt->nd_opt_pi_preferred_time) == + PREFIX_INFINITY) + sprintf(preferredstr, "INFINITY"); + else + sprintf(preferredstr, "%lu", + ntohl(popt->nd_opt_pi_preferred_time)); + + (void) sprintf(get_line(0, 0), + "Valid Lifetime %s, Preferred Lifetime %s", + validstr, preferredstr); + (void) sprintf(get_line(0, 0), "Prefix %s", + inet_ntop(AF_INET6, + (char *)&popt->nd_opt_pi_prefix, prefixstr, + INET6_ADDRSTRLEN)); + show_space(); + } + default: + break; + } + optc += opt->nd_opt_len * 8; + ilen -= opt->nd_opt_len * 8; + } +} + +static void +interpret_mldv2qry(icmp6_t *icmp6, int ilen) +{ + mld2q_t *qry; + in6_addr_t *src; + int rem = ilen; + int srccnt; + char addrstr[INET6_ADDRSTRLEN]; + + if (ilen < sizeof (*qry)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Malformed MLD Query"); + return; + } + qry = (mld2q_t *)icmp6; + rem -= sizeof (*qry); + srccnt = ntohs(qry->mld2q_numsrc); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Multicast address= %s", inet_ntop(AF_INET6, + &qry->mld2q_addr.s6_addr, addrstr, INET6_ADDRSTRLEN)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Source Address%s:", srccnt, (srccnt == 1) ? "" : "es"); + + src = (in6_addr_t *)&qry[1]; + while (srccnt > 0 && rem >= sizeof (*src)) { + rem -= sizeof (*src); + + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + inet_ntop(AF_INET6, src, addrstr, INET6_ADDRSTRLEN)); + + srccnt--; + src++; + } +} + +#define MAX_MLDV2_REPORT_TYPE 6 + +const char *mldv2rpt_types[] = { + "<unknown>", + "MODE_IS_INCLUDE", + "MODE_IS_EXCLUDE", + "CHANGE_TO_INCLUDE", + "CHANGE_TO_EXCLUDE", + "ALLOW_NEW_SOURCES", + "BLOCK_OLD_SOURCES", +}; + +static void +interpret_mldv2rpt(icmp6_t *icmp6, int ilen) +{ + mld2r_t *rpt; + mld2mar_t *mar; + in6_addr_t *src; + int rem = ilen, auxlen; + uint16_t marcnt, srccnt; + char addrstr[INET6_ADDRSTRLEN]; + + if (ilen < sizeof (*rpt)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Malformed MLDv2 Report"); + return; + } + rpt = (mld2r_t *)icmp6; + mar = (mld2mar_t *)&rpt[1]; + marcnt = ntohs(rpt->mld2r_nummar); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Multicast Address Record%s:", marcnt, (marcnt == 1) ? "" : "s"); + rem -= sizeof (*rpt); + while (marcnt > 0 && rem >= sizeof (*mar)) { + rem -= sizeof (*mar); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Multicast address= %s type = %s", inet_ntop(AF_INET6, + &mar->mld2mar_group.s6_addr, addrstr, INET6_ADDRSTRLEN), + (mar->mld2mar_type > MAX_MLDV2_REPORT_TYPE) ? + "<unknown>" : mldv2rpt_types[mar->mld2mar_type]); + srccnt = ntohs(mar->mld2mar_numsrc); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Source Address%s:", srccnt, (srccnt == 1) ? "" : "es"); + + src = (in6_addr_t *)&mar[1]; + while (srccnt > 0 && rem >= sizeof (*src)) { + rem -= sizeof (*src); + + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", inet_ntop(AF_INET6, src, addrstr, + INET6_ADDRSTRLEN)); + + srccnt--; + src++; + } + + marcnt--; + auxlen = mar->mld2mar_auxlen * 4; + rem -= auxlen; + mar = (mld2mar_t *)((uint8_t *)src + auxlen); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_igmp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_igmp.c new file mode 100644 index 0000000..b683c81 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_igmp.c @@ -0,0 +1,226 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <net/if.h> +#include <sys/stropts.h> +#include <sys/sysmacros.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/igmp.h> +#include <inet/ip.h> +#include <arpa/inet.h> +#include <netdb.h> +#include "snoop.h" + +static void interpret_igmpv3qry(struct igmp *, int); +static void interpret_igmpv3rpt(struct igmp *, int); + + +/*ARGSUSED*/ +void +interpret_igmp(int flags, char *data, int iplen, int ilen) +{ + const char *pt; + char *line; + struct igmp *igmp = (struct igmp *)data; + char addrstr[INET_ADDRSTRLEN]; + + if (ilen < IGMP_MINLEN) { + /* incomplete header */ + line = get_sum_line(); + (void) snprintf(line, MAXLINE, "Malformed IGMP packet"); + return; + } + + switch (igmp->igmp_type) { + case IGMP_MEMBERSHIP_QUERY: + if (ilen == IGMP_MINLEN) { + if (igmp->igmp_code == 0) + pt = "v1 membership query"; + else + pt = "v2 membership query"; + } else if (ilen >= IGMP_V3_QUERY_MINLEN) { + pt = "v3 membership query"; + } else { + pt = "Unknown membership query"; + } + break; + case IGMP_V1_MEMBERSHIP_REPORT: + pt = "v1 membership report"; + break; + case IGMP_V2_MEMBERSHIP_REPORT: + pt = "v2 membership report"; + break; + case IGMP_V3_MEMBERSHIP_REPORT: + pt = "v3 membership report"; + break; + case IGMP_V2_LEAVE_GROUP: + pt = "v2 leave group"; + break; + + default: + pt = "Unknown"; + break; + } + + if (flags & F_SUM) { + line = get_sum_line(); + (void) snprintf(line, MAXLINE, "IGMP %s", pt); + } + + if (flags & F_DTAIL) { + show_header("IGMP: ", "IGMP Header", ilen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type = %d (%s)", igmp->igmp_type, pt); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Max Response Time = %d", igmp->igmp_code); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Checksum = %x", ntohs(igmp->igmp_cksum)); + + if (igmp->igmp_type == IGMP_MEMBERSHIP_QUERY && + ilen >= IGMP_V3_QUERY_MINLEN) { + interpret_igmpv3qry(igmp, ilen); + } else if (igmp->igmp_type == IGMP_V3_MEMBERSHIP_REPORT) { + interpret_igmpv3rpt(igmp, ilen); + } else { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Group = %s", + inet_ntop(AF_INET, &igmp->igmp_group.s_addr, + addrstr, INET_ADDRSTRLEN)); + } + + show_space(); + } +} + +static void +interpret_igmpv3qry(struct igmp *igmp, int ilen) +{ + struct igmp3q *qry; + struct in_addr *src; + int rem = ilen; + int srccnt; + char addrstr[INET_ADDRSTRLEN]; + + if (ilen < sizeof (*qry)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Malformed IGMP Query"); + return; + } + + qry = (struct igmp3q *)igmp; + rem -= sizeof (*qry); + srccnt = ntohs(qry->igmp3q_numsrc); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Group = %s", inet_ntop(AF_INET, &qry->igmp3q_group, addrstr, + INET_ADDRSTRLEN)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Source Address%s:", srccnt, (srccnt == 1) ? "" : "es"); + + src = (struct in_addr *)&qry[1]; + while (srccnt > 0 && rem >= sizeof (*src)) { + rem -= sizeof (*src); + + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + inet_ntop(AF_INET, &src->s_addr, addrstr, INET_ADDRSTRLEN)); + + srccnt--; + src++; + } +} + +#define MAX_IGMPV3_REPORT_TYPE 6 + +const char *igmpv3rpt_types[] = { + "<unknown>", + "MODE_IS_INCLUDE", + "MODE_IS_EXCLUDE", + "CHANGE_TO_INCLUDE", + "CHANGE_TO_EXCLUDE", + "ALLOW_NEW_SOURCES", + "BLOCK_OLD_SOURCES", +}; + +static void +interpret_igmpv3rpt(struct igmp *igmp, int ilen) +{ + struct igmp3r *rpt; + struct grphdr *grh; + struct in_addr *src; + int rem = ilen, auxlen; + uint16_t grhcnt, srccnt; + char addrstr[INET_ADDRSTRLEN]; + + if (ilen < sizeof (*rpt)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Malformed IGMPv3 Report"); + return; + } + + rpt = (struct igmp3r *)igmp; + grh = (struct grphdr *)&rpt[1]; + grhcnt = ntohs(rpt->igmp3r_numrec); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Group Record%s:", grhcnt, (grhcnt == 1) ? "" : "s"); + rem -= sizeof (*rpt); + while (grhcnt > 0 && rem >= sizeof (*grh)) { + rem -= sizeof (*grh); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Group = %s type = %s", inet_ntop(AF_INET, + &grh->grphdr_group.s_addr, addrstr, INET_ADDRSTRLEN), + (grh->grphdr_type > MAX_IGMPV3_REPORT_TYPE) ? + "<unknown>" : igmpv3rpt_types[grh->grphdr_type]); + srccnt = ntohs(grh->grphdr_numsrc); + (void) snprintf(get_line(0, 0), get_line_remain(), + "%d Source Address%s:", srccnt, (srccnt == 1) ? "" : "es"); + + src = (struct in_addr *)&grh[1]; + while (srccnt > 0 && rem >= sizeof (*src)) { + rem -= sizeof (*src); + + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", inet_ntop(AF_INET, &src->s_addr, addrstr, + INET_ADDRSTRLEN)); + + srccnt--; + src++; + } + + grhcnt--; + auxlen = grh->grphdr_auxlen * 4; + rem -= auxlen; + grh = (struct grphdr *)((uint8_t *)src + auxlen); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ip.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ip.c new file mode 100644 index 0000000..af37d85 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ip.c @@ -0,0 +1,1490 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * Copyright 2012 Milan Jurik. All rights reserved. + */ + +#include <stdio.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> + +#include <sys/stropts.h> +#include <sys/socket.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/ip6.h> +#include <netinet/ip_icmp.h> +#include <netinet/icmp6.h> +#include <netinet/if_ether.h> +#include <inet/ip.h> +#include <inet/ip6.h> +#include <arpa/inet.h> +#include <netdb.h> +#include <tsol/label.h> +#include <sys/tsol/tndb.h> +#include <sys/tsol/label_macro.h> + +#include "snoop.h" + + +/* + * IPv6 extension header masks. These are used by the print_ipv6_extensions() + * function to return information to the caller about which extension headers + * were processed. This can be useful if the caller wants to know if the + * packet is an IPv6 fragment, for example. + */ +#define SNOOP_HOPOPTS 0x01U +#define SNOOP_ROUTING 0x02U +#define SNOOP_DSTOPTS 0x04U +#define SNOOP_FRAGMENT 0x08U +#define SNOOP_AH 0x10U +#define SNOOP_ESP 0x20U +#define SNOOP_IPV6 0x40U + +static void prt_routing_hdr(int, const struct ip6_rthdr *); +static void prt_fragment_hdr(int, const struct ip6_frag *); +static void prt_hbh_options(int, const struct ip6_hbh *); +static void prt_dest_options(int, const struct ip6_dest *); +static void print_route(const uchar_t *); +static void print_ipoptions(const uchar_t *, int); +static void print_ripso(const uchar_t *); +static void print_cipso(const uchar_t *); + +/* Keep track of how many nested IP headers we have. */ +unsigned int encap_levels; +unsigned int total_encap_levels = 1; + +int +interpret_ip(int flags, const struct ip *ip, int fraglen) +{ + uchar_t *data; + char buff[24]; + boolean_t isfrag = B_FALSE; + boolean_t morefrag; + uint16_t fragoffset; + int hdrlen; + uint16_t iplen, uitmp; + + if (ip->ip_v == IPV6_VERSION) { + iplen = interpret_ipv6(flags, (ip6_t *)ip, fraglen); + return (iplen); + } + + if (encap_levels == 0) + total_encap_levels = 0; + encap_levels++; + total_encap_levels++; + + hdrlen = ip->ip_hl * 4; + data = ((uchar_t *)ip) + hdrlen; + iplen = ntohs(ip->ip_len) - hdrlen; + fraglen -= hdrlen; + if (fraglen > iplen) + fraglen = iplen; + if (fraglen < 0) { + (void) snprintf(get_sum_line(), MAXLINE, + "IP truncated: header missing %d bytes", -fraglen); + encap_levels--; + return (fraglen + iplen); + } + /* + * We flag this as a fragment if the more fragments bit is set, or + * if the fragment offset is non-zero. + */ + morefrag = (ntohs(ip->ip_off) & IP_MF) == 0 ? B_FALSE : B_TRUE; + fragoffset = (ntohs(ip->ip_off) & 0x1FFF) * 8; + if (morefrag || fragoffset != 0) + isfrag = B_TRUE; + + src_name = addrtoname(AF_INET, &ip->ip_src); + dst_name = addrtoname(AF_INET, &ip->ip_dst); + + if (flags & F_SUM) { + if (isfrag) { + (void) snprintf(get_sum_line(), MAXLINE, + "%s IP fragment ID=%d Offset=%-4d MF=%d TOS=0x%x " + "TTL=%d", + getproto(ip->ip_p), + ntohs(ip->ip_id), + fragoffset, + morefrag, + ip->ip_tos, + ip->ip_ttl); + } else { + (void) strlcpy(buff, inet_ntoa(ip->ip_dst), + sizeof (buff)); + uitmp = ntohs(ip->ip_len); + (void) snprintf(get_sum_line(), MAXLINE, + "IP D=%s S=%s LEN=%u%s, ID=%d, TOS=0x%x, TTL=%d", + buff, + inet_ntoa(ip->ip_src), + uitmp, + iplen > fraglen ? "?" : "", + ntohs(ip->ip_id), + ip->ip_tos, + ip->ip_ttl); + } + } + + if (flags & F_DTAIL) { + show_header("IP: ", "IP Header", iplen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Version = %d", ip->ip_v); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Header length = %d bytes", hdrlen); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type of service = 0x%02x", ip->ip_tos); + (void) snprintf(get_line(0, 0), get_line_remain(), + " xxx. .... = %d (precedence)", + ip->ip_tos >> 5); + (void) snprintf(get_line(0, 0), get_line_remain(), + " %s", getflag(ip->ip_tos, IPTOS_LOWDELAY, + "low delay", "normal delay")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(ip->ip_tos, IPTOS_THROUGHPUT, + "high throughput", "normal throughput")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(ip->ip_tos, IPTOS_RELIABILITY, + "high reliability", "normal reliability")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(ip->ip_tos, IPTOS_ECT, + "ECN capable transport", "not ECN capable transport")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(ip->ip_tos, IPTOS_CE, + "ECN congestion experienced", + "no ECN congestion experienced")); + /* warning: ip_len is signed in netinet/ip.h */ + uitmp = ntohs(ip->ip_len); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Total length = %u bytes%s", uitmp, + iplen > fraglen ? " -- truncated" : ""); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Identification = %d", ntohs(ip->ip_id)); + /* warning: ip_off is signed in netinet/ip.h */ + uitmp = ntohs(ip->ip_off); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Flags = 0x%x", uitmp >> 12); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(uitmp >> 8, IP_DF >> 8, + "do not fragment", "may fragment")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(uitmp >> 8, IP_MF >> 8, + "more fragments", "last fragment")); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Fragment offset = %u bytes", + fragoffset); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Time to live = %d seconds/hops", + ip->ip_ttl); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Protocol = %d (%s)", ip->ip_p, + getproto(ip->ip_p)); + /* + * XXX need to compute checksum and print whether it's correct + */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Header checksum = %04x", + ntohs(ip->ip_sum)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Source address = %s, %s", + inet_ntoa(ip->ip_src), addrtoname(AF_INET, &ip->ip_src)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination address = %s, %s", + inet_ntoa(ip->ip_dst), addrtoname(AF_INET, &ip->ip_dst)); + + /* Print IP options - if any */ + + print_ipoptions((const uchar_t *)(ip + 1), + hdrlen - sizeof (struct ip)); + show_space(); + } + + /* + * If we are in detail mode, and this is not the first fragment of + * a fragmented packet, print out a little line stating this. + * Otherwise, go to the next protocol layer only if this is not a + * fragment, or we are in detail mode and this is the first fragment + * of a fragmented packet. + */ + if (flags & F_DTAIL && fragoffset != 0) { + (void) snprintf(get_detail_line(0, 0), MAXLINE, + "%s: [%d byte(s) of data, continuation of IP ident=%d]", + getproto(ip->ip_p), + iplen, + ntohs(ip->ip_id)); + } else if (!isfrag || (flags & F_DTAIL) && isfrag && fragoffset == 0) { + /* go to the next protocol layer */ + + if (fraglen > 0) { + switch (ip->ip_p) { + case IPPROTO_IP: + break; + case IPPROTO_ENCAP: + (void) interpret_ip(flags, + /* LINTED: alignment */ + (const struct ip *)data, fraglen); + break; + case IPPROTO_ICMP: + (void) interpret_icmp(flags, + /* LINTED: alignment */ + (struct icmp *)data, iplen, fraglen); + break; + case IPPROTO_IGMP: + interpret_igmp(flags, data, iplen, fraglen); + break; + case IPPROTO_GGP: + break; + case IPPROTO_TCP: + (void) interpret_tcp(flags, + (struct tcphdr *)data, iplen, fraglen); + break; + + case IPPROTO_ESP: + (void) interpret_esp(flags, data, iplen, + fraglen); + break; + case IPPROTO_AH: + (void) interpret_ah(flags, data, iplen, + fraglen); + break; + + case IPPROTO_OSPF: + interpret_ospf(flags, data, iplen, fraglen); + break; + + case IPPROTO_EGP: + case IPPROTO_PUP: + break; + case IPPROTO_UDP: + (void) interpret_udp(flags, + (struct udphdr *)data, iplen, fraglen); + break; + + case IPPROTO_IDP: + case IPPROTO_HELLO: + case IPPROTO_ND: + case IPPROTO_RAW: + break; + case IPPROTO_IPV6: /* IPV6 encap */ + /* LINTED: alignment */ + (void) interpret_ipv6(flags, (ip6_t *)data, + iplen); + break; + case IPPROTO_SCTP: + (void) interpret_sctp(flags, + (struct sctp_hdr *)data, iplen, fraglen); + break; + } + } + } + + encap_levels--; + return (iplen); +} + +int +interpret_ipv6(int flags, const ip6_t *ip6h, int fraglen) +{ + uint8_t *data; + int hdrlen, iplen; + int version, flow, class; + uchar_t proto; + boolean_t isfrag = B_FALSE; + uint8_t extmask; + /* + * The print_srcname and print_dstname strings are the hostname + * parts of the verbose IPv6 header output, including the comma + * and the space after the litteral address strings. + */ + char print_srcname[MAXHOSTNAMELEN + 2]; + char print_dstname[MAXHOSTNAMELEN + 2]; + char src_addrstr[INET6_ADDRSTRLEN]; + char dst_addrstr[INET6_ADDRSTRLEN]; + + iplen = ntohs(ip6h->ip6_plen); + hdrlen = IPV6_HDR_LEN; + fraglen -= hdrlen; + if (fraglen < 0) + return (fraglen + hdrlen); + data = ((uint8_t *)ip6h) + hdrlen; + + proto = ip6h->ip6_nxt; + + src_name = addrtoname(AF_INET6, &ip6h->ip6_src); + dst_name = addrtoname(AF_INET6, &ip6h->ip6_dst); + + /* + * Use endian-aware masks to extract traffic class and + * flowinfo. Also, flowinfo is now 20 bits and class 8 + * rather than 24 and 4. + */ + class = ntohl((ip6h->ip6_vcf & IPV6_FLOWINFO_TCLASS) >> 20); + flow = ntohl(ip6h->ip6_vcf & IPV6_FLOWINFO_FLOWLABEL); + + /* + * NOTE: the F_SUM and F_DTAIL flags are mutually exclusive, + * so the code within the first part of the following if statement + * will not affect the detailed printing of the packet. + */ + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "IPv6 S=%s D=%s LEN=%d HOPS=%d CLASS=0x%x FLOW=0x%x", + src_name, dst_name, iplen, ip6h->ip6_hops, class, flow); + } else if (flags & F_DTAIL) { + + (void) inet_ntop(AF_INET6, &ip6h->ip6_src, src_addrstr, + INET6_ADDRSTRLEN); + (void) inet_ntop(AF_INET6, &ip6h->ip6_dst, dst_addrstr, + INET6_ADDRSTRLEN); + + version = ntohl(ip6h->ip6_vcf) >> 28; + + if (strcmp(src_name, src_addrstr) == 0) { + print_srcname[0] = '\0'; + } else { + snprintf(print_srcname, sizeof (print_srcname), + ", %s", src_name); + } + + if (strcmp(dst_name, dst_addrstr) == 0) { + print_dstname[0] = '\0'; + } else { + snprintf(print_dstname, sizeof (print_dstname), + ", %s", dst_name); + } + + show_header("IPv6: ", "IPv6 Header", iplen); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Version = %d", version); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Traffic Class = %d", class); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Flow label = 0x%x", flow); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Payload length = %d", iplen); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Next Header = %d (%s)", proto, + getproto(proto)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hop Limit = %d", ip6h->ip6_hops); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Source address = %s%s", src_addrstr, print_srcname); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination address = %s%s", dst_addrstr, print_dstname); + + show_space(); + } + + /* + * Print IPv6 Extension Headers, or skip them in the summary case. + * Set isfrag to true if one of the extension headers encounterred + * was a fragment header. + */ + if (proto == IPPROTO_HOPOPTS || proto == IPPROTO_DSTOPTS || + proto == IPPROTO_ROUTING || proto == IPPROTO_FRAGMENT) { + extmask = print_ipv6_extensions(flags, &data, &proto, &iplen, + &fraglen); + if ((extmask & SNOOP_FRAGMENT) != 0) { + isfrag = B_TRUE; + } + } + + /* + * We only want to print upper layer information if this is not + * a fragment, or if we're printing in detail. Note that the + * proto variable will be set to IPPROTO_NONE if this is a fragment + * with a non-zero fragment offset. + */ + if (!isfrag || flags & F_DTAIL) { + /* go to the next protocol layer */ + + switch (proto) { + case IPPROTO_IP: + break; + case IPPROTO_ENCAP: + /* LINTED: alignment */ + (void) interpret_ip(flags, (const struct ip *)data, + fraglen); + break; + case IPPROTO_ICMPV6: + /* LINTED: alignment */ + (void) interpret_icmpv6(flags, (icmp6_t *)data, iplen, + fraglen); + break; + case IPPROTO_IGMP: + interpret_igmp(flags, data, iplen, fraglen); + break; + case IPPROTO_GGP: + break; + case IPPROTO_TCP: + (void) interpret_tcp(flags, (struct tcphdr *)data, + iplen, fraglen); + break; + case IPPROTO_ESP: + (void) interpret_esp(flags, data, iplen, fraglen); + break; + case IPPROTO_AH: + (void) interpret_ah(flags, data, iplen, fraglen); + break; + case IPPROTO_EGP: + case IPPROTO_PUP: + break; + case IPPROTO_UDP: + (void) interpret_udp(flags, (struct udphdr *)data, + iplen, fraglen); + break; + case IPPROTO_IDP: + case IPPROTO_HELLO: + case IPPROTO_ND: + case IPPROTO_RAW: + break; + case IPPROTO_IPV6: + /* LINTED: alignment */ + (void) interpret_ipv6(flags, (const ip6_t *)data, + iplen); + break; + case IPPROTO_SCTP: + (void) interpret_sctp(flags, (struct sctp_hdr *)data, + iplen, fraglen); + break; + case IPPROTO_OSPF: + interpret_ospf6(flags, data, iplen, fraglen); + break; + } + } + + return (iplen); +} + +/* + * ip_ext: data including the extension header. + * iplen: length of the data remaining in the packet. + * Returns a mask of IPv6 extension headers it processed. + */ +uint8_t +print_ipv6_extensions(int flags, uint8_t **hdr, uint8_t *next, int *iplen, + int *fraglen) +{ + uint8_t *data_ptr; + uchar_t proto = *next; + boolean_t is_extension_header; + struct ip6_hbh *ipv6ext_hbh; + struct ip6_dest *ipv6ext_dest; + struct ip6_rthdr *ipv6ext_rthdr; + struct ip6_frag *ipv6ext_frag; + uint32_t exthdrlen; + uint8_t extmask = 0; + + if ((hdr == NULL) || (*hdr == NULL) || (next == NULL) || (iplen == 0)) + return (0); + + data_ptr = *hdr; + is_extension_header = B_TRUE; + while (is_extension_header) { + + /* + * There must be at least enough data left to read the + * next header and header length fields from the next + * header. + */ + if (*fraglen < 2) { + return (extmask); + } + + switch (proto) { + case IPPROTO_HOPOPTS: + ipv6ext_hbh = (struct ip6_hbh *)data_ptr; + exthdrlen = 8 + ipv6ext_hbh->ip6h_len * 8; + if (*fraglen <= exthdrlen) { + return (extmask); + } + prt_hbh_options(flags, ipv6ext_hbh); + extmask |= SNOOP_HOPOPTS; + proto = ipv6ext_hbh->ip6h_nxt; + break; + case IPPROTO_DSTOPTS: + ipv6ext_dest = (struct ip6_dest *)data_ptr; + exthdrlen = 8 + ipv6ext_dest->ip6d_len * 8; + if (*fraglen <= exthdrlen) { + return (extmask); + } + prt_dest_options(flags, ipv6ext_dest); + extmask |= SNOOP_DSTOPTS; + proto = ipv6ext_dest->ip6d_nxt; + break; + case IPPROTO_ROUTING: + ipv6ext_rthdr = (struct ip6_rthdr *)data_ptr; + exthdrlen = 8 + ipv6ext_rthdr->ip6r_len * 8; + if (*fraglen <= exthdrlen) { + return (extmask); + } + prt_routing_hdr(flags, ipv6ext_rthdr); + extmask |= SNOOP_ROUTING; + proto = ipv6ext_rthdr->ip6r_nxt; + break; + case IPPROTO_FRAGMENT: + /* LINTED: alignment */ + ipv6ext_frag = (struct ip6_frag *)data_ptr; + exthdrlen = sizeof (struct ip6_frag); + if (*fraglen <= exthdrlen) { + return (extmask); + } + prt_fragment_hdr(flags, ipv6ext_frag); + extmask |= SNOOP_FRAGMENT; + /* + * If this is not the first fragment, forget about + * the rest of the packet, snoop decoding is + * stateless. + */ + if ((ipv6ext_frag->ip6f_offlg & IP6F_OFF_MASK) != 0) + proto = IPPROTO_NONE; + else + proto = ipv6ext_frag->ip6f_nxt; + break; + default: + is_extension_header = B_FALSE; + break; + } + + if (is_extension_header) { + *iplen -= exthdrlen; + *fraglen -= exthdrlen; + data_ptr += exthdrlen; + } + } + + *next = proto; + *hdr = data_ptr; + return (extmask); +} + +static void +print_ipoptions(const uchar_t *opt, int optlen) +{ + int len; + int remain; + char *line; + const char *truncstr; + + if (optlen <= 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "No options"); + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Options: (%d bytes)", optlen); + + while (optlen > 0) { + line = get_line(0, 0); + remain = get_line_remain(); + len = opt[1]; + truncstr = len > optlen ? "?" : ""; + switch (opt[0]) { + case IPOPT_EOL: + (void) strlcpy(line, " - End of option list", remain); + return; + case IPOPT_NOP: + (void) strlcpy(line, " - No op", remain); + len = 1; + break; + case IPOPT_RR: + (void) snprintf(line, remain, + " - Record route (%d bytes%s)", len, truncstr); + print_route(opt); + break; + case IPOPT_TS: + (void) snprintf(line, remain, + " - Time stamp (%d bytes%s)", len, truncstr); + break; + case IPOPT_SECURITY: + (void) snprintf(line, remain, " - RIPSO (%d bytes%s)", + len, truncstr); + print_ripso(opt); + break; + case IPOPT_COMSEC: + (void) snprintf(line, remain, " - CIPSO (%d bytes%s)", + len, truncstr); + print_cipso(opt); + break; + case IPOPT_LSRR: + (void) snprintf(line, remain, + " - Loose source route (%d bytes%s)", len, + truncstr); + print_route(opt); + break; + case IPOPT_SATID: + (void) snprintf(line, remain, + " - SATNET Stream id (%d bytes%s)", + len, truncstr); + break; + case IPOPT_SSRR: + (void) snprintf(line, remain, + " - Strict source route, (%d bytes%s)", len, + truncstr); + print_route(opt); + break; + default: + (void) snprintf(line, remain, + " - Option %d (unknown - %d bytes%s) %s", + opt[0], len, truncstr, + tohex((char *)&opt[2], len - 2)); + break; + } + if (len <= 0) { + (void) snprintf(line, remain, + " - Incomplete option len %d", len); + break; + } + opt += len; + optlen -= len; + } +} + +static void +print_route(const uchar_t *opt) +{ + int len, pointer, remain; + struct in_addr addr; + char *line; + + len = opt[1]; + pointer = opt[2]; + + (void) snprintf(get_line(0, 0), get_line_remain(), + " Pointer = %d", pointer); + + pointer -= IPOPT_MINOFF; + opt += (IPOPT_OFFSET + 1); + len -= (IPOPT_OFFSET + 1); + + while (len > 0) { + line = get_line(0, 0); + remain = get_line_remain(); + memcpy((char *)&addr, opt, sizeof (addr)); + if (addr.s_addr == INADDR_ANY) + (void) strlcpy(line, " -", remain); + else + (void) snprintf(line, remain, " %s", + addrtoname(AF_INET, &addr)); + if (pointer == 0) + (void) strlcat(line, " <-- (current)", remain); + + opt += sizeof (addr); + len -= sizeof (addr); + pointer -= sizeof (addr); + } +} + +char * +getproto(int p) +{ + switch (p) { + case IPPROTO_HOPOPTS: return ("IPv6-HopOpts"); + case IPPROTO_IPV6: return ("IPv6"); + case IPPROTO_ROUTING: return ("IPv6-Route"); + case IPPROTO_FRAGMENT: return ("IPv6-Frag"); + case IPPROTO_RSVP: return ("RSVP"); + case IPPROTO_ENCAP: return ("IP-in-IP"); + case IPPROTO_AH: return ("AH"); + case IPPROTO_ESP: return ("ESP"); + case IPPROTO_ICMP: return ("ICMP"); + case IPPROTO_ICMPV6: return ("ICMPv6"); + case IPPROTO_DSTOPTS: return ("IPv6-DstOpts"); + case IPPROTO_IGMP: return ("IGMP"); + case IPPROTO_GGP: return ("GGP"); + case IPPROTO_TCP: return ("TCP"); + case IPPROTO_EGP: return ("EGP"); + case IPPROTO_PUP: return ("PUP"); + case IPPROTO_UDP: return ("UDP"); + case IPPROTO_IDP: return ("IDP"); + case IPPROTO_HELLO: return ("HELLO"); + case IPPROTO_ND: return ("ND"); + case IPPROTO_EON: return ("EON"); + case IPPROTO_RAW: return ("RAW"); + case IPPROTO_OSPF: return ("OSPF"); + default: return (""); + } +} + +static void +prt_routing_hdr(int flags, const struct ip6_rthdr *ipv6ext_rthdr) +{ + uint8_t nxt_hdr; + uint8_t type; + uint32_t len; + uint8_t segleft; + uint32_t numaddrs; + int i; + struct ip6_rthdr0 *ipv6ext_rthdr0; + struct in6_addr *addrs; + char addr[INET6_ADDRSTRLEN]; + + /* in summary mode, we don't do anything. */ + if (flags & F_SUM) { + return; + } + + nxt_hdr = ipv6ext_rthdr->ip6r_nxt; + type = ipv6ext_rthdr->ip6r_type; + len = 8 * (ipv6ext_rthdr->ip6r_len + 1); + segleft = ipv6ext_rthdr->ip6r_segleft; + + show_header("IPv6-Route: ", "IPv6 Routing Header", 0); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Next header = %d (%s)", nxt_hdr, getproto(nxt_hdr)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Header length = %d", len); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Routing type = %d", type); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Segments left = %d", segleft); + + if (type == IPV6_RTHDR_TYPE_0) { + /* + * XXX This loop will print all addresses in the routing header, + * XXX not just the segments left. + * XXX (The header length field is twice the number of + * XXX addresses) + * XXX At some future time, we may want to change this + * XXX to differentiate between the hops yet to do + * XXX and the hops already taken. + */ + /* LINTED: alignment */ + ipv6ext_rthdr0 = (struct ip6_rthdr0 *)ipv6ext_rthdr; + numaddrs = ipv6ext_rthdr0->ip6r0_len / 2; + addrs = (struct in6_addr *)(ipv6ext_rthdr0 + 1); + for (i = 0; i < numaddrs; i++) { + (void) inet_ntop(AF_INET6, &addrs[i], addr, + INET6_ADDRSTRLEN); + (void) snprintf(get_line(0, 0), get_line_remain(), + "address[%d]=%s", i, addr); + } + } + + show_space(); +} + +static void +prt_fragment_hdr(int flags, const struct ip6_frag *ipv6ext_frag) +{ + boolean_t morefrag; + uint16_t fragoffset; + uint8_t nxt_hdr; + uint32_t fragident; + + /* extract the various fields from the fragment header */ + nxt_hdr = ipv6ext_frag->ip6f_nxt; + morefrag = (ipv6ext_frag->ip6f_offlg & IP6F_MORE_FRAG) == 0 + ? B_FALSE : B_TRUE; + fragoffset = ntohs(ipv6ext_frag->ip6f_offlg & IP6F_OFF_MASK); + fragident = ntohl(ipv6ext_frag->ip6f_ident); + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "IPv6 fragment ID=%u Offset=%-4d MF=%d", + fragident, + fragoffset, + morefrag); + } else { /* F_DTAIL */ + show_header("IPv6-Frag: ", "IPv6 Fragment Header", 0); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Next Header = %d (%s)", nxt_hdr, getproto(nxt_hdr)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Fragment Offset = %d", fragoffset); + (void) snprintf(get_line(0, 0), get_line_remain(), + "More Fragments Flag = %s", morefrag ? "true" : "false"); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Identification = %u", fragident); + + show_space(); + } +} + +static void +print_ip6opt_ls(const uchar_t *data, unsigned int op_len) +{ + uint32_t doi; + uint8_t sotype, solen; + uint16_t value, value2; + char *cp; + int remlen; + boolean_t printed; + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Labeled Security Option len = %u bytes%s", op_len, + op_len < sizeof (uint32_t) || (op_len & 1) != 0 ? "?" : ""); + if (op_len < sizeof (uint32_t)) + return; + GETINT32(doi, data); + (void) snprintf(get_line(0, 0), get_line_remain(), + " DOI = %d (%s)", doi, doi == IP6LS_DOI_V4 ? "IPv4" : "???"); + op_len -= sizeof (uint32_t); + while (op_len > 0) { + GETINT8(sotype, data); + if (op_len < 2) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " truncated %u suboption (no len)", sotype); + break; + } + GETINT8(solen, data); + if (solen < 2 || solen > op_len) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " bad %u suboption (len 2 <= %u <= %u)", + sotype, solen, op_len); + if (solen < 2) + solen = 2; + if (solen > op_len) + solen = op_len; + } + op_len -= solen; + solen -= 2; + cp = get_line(0, 0); + remlen = get_line_remain(); + (void) strlcpy(cp, " ", remlen); + cp += 4; + remlen -= 4; + printed = B_TRUE; + switch (sotype) { + case IP6LS_TT_LEVEL: + if (solen != 2) { + printed = B_FALSE; + break; + } + GETINT16(value, data); + (void) snprintf(cp, remlen, "Level %u", value); + solen = 0; + break; + case IP6LS_TT_VECTOR: + (void) strlcpy(cp, "Bit-Vector: ", remlen); + remlen -= strlen(cp); + cp += strlen(cp); + while (solen > 1) { + GETINT16(value, data); + solen -= 2; + (void) snprintf(cp, remlen, "%04x", value); + remlen -= strlen(cp); + cp += strlen(cp); + } + break; + case IP6LS_TT_ENUM: + (void) strlcpy(cp, "Enumeration:", remlen); + remlen -= strlen(cp); + cp += strlen(cp); + while (solen > 1) { + GETINT16(value, data); + solen -= 2; + (void) snprintf(cp, remlen, " %u", value); + remlen -= strlen(cp); + cp += strlen(cp); + } + break; + case IP6LS_TT_RANGES: + (void) strlcpy(cp, "Ranges:", remlen); + remlen -= strlen(cp); + cp += strlen(cp); + while (solen > 3) { + GETINT16(value, data); + GETINT16(value2, data); + solen -= 4; + (void) snprintf(cp, remlen, " %u-%u", value, + value2); + remlen -= strlen(cp); + cp += strlen(cp); + } + break; + case IP6LS_TT_V4: + (void) strlcpy(cp, "IPv4 Option", remlen); + print_ipoptions(data, solen); + solen = 0; + break; + case IP6LS_TT_DEST: + (void) snprintf(cp, remlen, + "Destination-Only Data length %u", solen); + solen = 0; + break; + default: + (void) snprintf(cp, remlen, + " unknown %u suboption (len %u)", sotype, solen); + solen = 0; + break; + } + if (solen != 0) { + if (printed) { + cp = get_line(0, 0); + remlen = get_line_remain(); + } + (void) snprintf(cp, remlen, + " malformed %u suboption (remaining %u)", + sotype, solen); + data += solen; + } + } +} + +static void +prt_hbh_options(int flags, const struct ip6_hbh *ipv6ext_hbh) +{ + const uint8_t *data, *ndata; + uint32_t len; + uint8_t op_type; + uint8_t op_len; + uint8_t nxt_hdr; + + /* in summary mode, we don't do anything. */ + if (flags & F_SUM) { + return; + } + + show_header("IPv6-HopOpts: ", "IPv6 Hop-by-Hop Options Header", 0); + show_space(); + + /* + * Store the lengh of this ext hdr in bytes. The caller has + * ensured that there is at least len bytes of data left. + */ + len = ipv6ext_hbh->ip6h_len * 8 + 8; + + ndata = (const uint8_t *)ipv6ext_hbh + 2; + len -= 2; + + nxt_hdr = ipv6ext_hbh->ip6h_nxt; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Next Header = %u (%s)", nxt_hdr, getproto(nxt_hdr)); + + while (len > 0) { + data = ndata; + GETINT8(op_type, data); + /* This is the only one-octet IPv6 option */ + if (op_type == IP6OPT_PAD1) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "pad1 option "); + len--; + ndata = data; + continue; + } + GETINT8(op_len, data); + if (len < 2 || op_len + 2 > len) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Error: option %u truncated (%u + 2 > %u)", + op_type, op_len, len); + op_len = len - 2; + /* + * Continue processing the malformed option so that we + * can display as much as possible. + */ + } + + /* advance pointers to the next option */ + len -= op_len + 2; + ndata = data + op_len; + + /* process this option */ + switch (op_type) { + case IP6OPT_PADN: + (void) snprintf(get_line(0, 0), get_line_remain(), + "padN option len = %u", op_len); + break; + case IP6OPT_JUMBO: { + uint32_t payload_len; + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Jumbo Payload Option len = %u bytes%s", op_len, + op_len == sizeof (uint32_t) ? "" : "?"); + if (op_len == sizeof (uint32_t)) { + GETINT32(payload_len, data); + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Jumbo Payload Length = %u bytes", + payload_len); + } + break; + } + case IP6OPT_ROUTER_ALERT: { + uint16_t value; + const char *label[] = {"MLD", "RSVP", "AN"}; + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Router Alert Option len = %u bytes%s", op_len, + op_len == sizeof (uint16_t) ? "" : "?"); + if (op_len == sizeof (uint16_t)) { + GETINT16(value, data); + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Alert Type = %d (%s)", value, + value < sizeof (label) / sizeof (label[0]) ? + label[value] : "???"); + } + break; + } + case IP6OPT_LS: + print_ip6opt_ls(data, op_len); + break; + default: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Option type = %u, len = %u", op_type, op_len); + break; + } + } + + show_space(); +} + +static void +prt_dest_options(int flags, const struct ip6_dest *ipv6ext_dest) +{ + const uint8_t *data, *ndata; + uint32_t len; + uint8_t op_type; + uint32_t op_len; + uint8_t nxt_hdr; + uint8_t value; + + /* in summary mode, we don't do anything. */ + if (flags & F_SUM) { + return; + } + + show_header("IPv6-DstOpts: ", "IPv6 Destination Options Header", 0); + show_space(); + + /* + * Store the length of this ext hdr in bytes. The caller has + * ensured that there is at least len bytes of data left. + */ + len = ipv6ext_dest->ip6d_len * 8 + 8; + + ndata = (const uint8_t *)ipv6ext_dest + 2; /* skip hdr/len */ + len -= 2; + + nxt_hdr = ipv6ext_dest->ip6d_nxt; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Next Header = %u (%s)", nxt_hdr, getproto(nxt_hdr)); + + while (len > 0) { + data = ndata; + GETINT8(op_type, data); + if (op_type == IP6OPT_PAD1) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "pad1 option "); + len--; + ndata = data; + continue; + } + GETINT8(op_len, data); + if (len < 2 || op_len + 2 > len) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Error: option %u truncated (%u + 2 > %u)", + op_type, op_len, len); + op_len = len - 2; + /* + * Continue processing the malformed option so that we + * can display as much as possible. + */ + } + + /* advance pointers to the next option */ + len -= op_len + 2; + ndata = data + op_len; + + /* process this option */ + switch (op_type) { + case IP6OPT_PADN: + (void) snprintf(get_line(0, 0), get_line_remain(), + "padN option len = %u", op_len); + break; + case IP6OPT_TUNNEL_LIMIT: + GETINT8(value, data); + (void) snprintf(get_line(0, 0), get_line_remain(), + "tunnel encapsulation limit len = %d, value = %d", + op_len, value); + break; + case IP6OPT_LS: + print_ip6opt_ls(data, op_len); + break; + default: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Option type = %u, len = %u", op_type, op_len); + break; + } + } + + show_space(); +} + +#define ALABEL_MAXLEN 256 + +static char ascii_label[ALABEL_MAXLEN]; +static char *plabel = ascii_label; + +struct snoop_pair { + int val; + const char *name; +}; + +static struct snoop_pair ripso_class_tbl[] = { + TSOL_CL_TOP_SECRET, "TOP SECRET", + TSOL_CL_SECRET, "SECRET", + TSOL_CL_CONFIDENTIAL, "CONFIDENTIAL", + TSOL_CL_UNCLASSIFIED, "UNCLASSIFIED", + -1, NULL +}; + +static struct snoop_pair ripso_prot_tbl[] = { + TSOL_PA_GENSER, "GENSER", + TSOL_PA_SIOP_ESI, "SIOP-ESI", + TSOL_PA_SCI, "SCI", + TSOL_PA_NSA, "NSA", + TSOL_PA_DOE, "DOE", + 0x04, "UNASSIGNED", + 0x02, "UNASSIGNED", + -1, NULL +}; + +static struct snoop_pair * +get_pair_byval(struct snoop_pair pairlist[], int val) +{ + int i; + + for (i = 0; pairlist[i].name != NULL; i++) + if (pairlist[i].val == val) + return (&pairlist[i]); + return (NULL); +} + +static void +print_ripso(const uchar_t *opt) +{ + struct snoop_pair *ripso_class; + int i, index, prot_len; + boolean_t first_prot; + char line[100], *ptr; + + prot_len = opt[1] - 3; + if (prot_len < 0) + return; + + show_header("RIPSO: ", "Revised IP Security Option", 0); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type = Basic Security Option (%d), Length = %d", opt[0], opt[1]); + + /* + * Display Classification Level + */ + ripso_class = get_pair_byval(ripso_class_tbl, (int)opt[2]); + if (ripso_class == NULL) + (void) snprintf(get_line(0, 0), get_line_remain(), + "Classification = Unknown (0x%02x)", opt[2]); + else + (void) snprintf(get_line(0, 0), get_line_remain(), + "Classification = %s (0x%02x)", + ripso_class->name, ripso_class->val); + + /* + * Display Protection Authority Flags + */ + (void) snprintf(line, sizeof (line), "Protection Authority = "); + ptr = line; + first_prot = B_TRUE; + for (i = 0; i < prot_len; i++) { + index = 0; + while (ripso_prot_tbl[index].name != NULL) { + if (opt[3 + i] & ripso_prot_tbl[index].val) { + ptr = strchr(ptr, 0); + if (!first_prot) { + (void) strlcpy(ptr, ", ", + sizeof (line) - (ptr - line)); + ptr = strchr(ptr, 0); + } + (void) snprintf(ptr, + sizeof (line) - (ptr - line), + "%s (0x%02x)", + ripso_prot_tbl[index].name, + ripso_prot_tbl[index].val); + } + index++; + } + if ((opt[3 + i] & 1) == 0) + break; + } + if (!first_prot) + (void) snprintf(get_line(0, 0), get_line_remain(), "%s", line); + else + (void) snprintf(get_line(0, 0), get_line_remain(), "%sNone", + line); +} + +#define CIPSO_GENERIC_ARRAY_LEN 200 + +/* + * Return 1 if CIPSO SL and Categories are all 1's; 0 otherwise. + * + * Note: opt starts with "Tag Type": + * + * |tag_type(1)|tag_length(1)|align(1)|sl(1)|categories(variable)| + * + */ +static boolean_t +cipso_high(const uchar_t *opt) +{ + int i; + + if (((int)opt[1] + 6) < IP_MAX_OPT_LENGTH) + return (B_FALSE); + for (i = 0; i < ((int)opt[1] - 3); i++) + if (opt[3 + i] != 0xff) + return (B_FALSE); + return (B_TRUE); +} + +/* + * Converts CIPSO label to SL. + * + * Note: opt starts with "Tag Type": + * + * |tag_type(1)|tag_length(1)|align(1)|sl(1)|categories(variable)| + * + */ +static void +cipso2sl(const uchar_t *opt, bslabel_t *sl, int *high) +{ + int i, taglen; + uchar_t *q = (uchar_t *)&((_bslabel_impl_t *)sl)->compartments; + + *high = 0; + taglen = opt[1]; + memset((caddr_t)sl, 0, sizeof (bslabel_t)); + + if (cipso_high(opt)) { + BSLHIGH(sl); + *high = 1; + } else { + LCLASS_SET((_bslabel_impl_t *)sl, opt[3]); + for (i = 0; i < taglen - TSOL_TT1_MIN_LENGTH; i++) + q[i] = opt[TSOL_TT1_MIN_LENGTH + i]; + } + SETBLTYPE(sl, SUN_SL_ID); +} + +static int +interpret_cipso_tagtype1(const uchar_t *opt) +{ + int i, taglen, ishigh; + bslabel_t sl; + char line[CIPSO_GENERIC_ARRAY_LEN], *ptr; + + taglen = opt[1]; + if (taglen < TSOL_TT1_MIN_LENGTH || + taglen > TSOL_TT1_MAX_LENGTH) + return (taglen); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Tag Type = %d, Tag Length = %d", opt[0], opt[1]); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sensitivity Level = 0x%02x", opt[3]); + ptr = line; + for (i = 0; i < taglen - TSOL_TT1_MIN_LENGTH; i++) { + (void) snprintf(ptr, sizeof (line) - (ptr - line), "%02x", + opt[TSOL_TT1_MIN_LENGTH + i]); + ptr = strchr(ptr, 0); + } + if (i != 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Categories = "); + (void) snprintf(get_line(0, 0), get_line_remain(), "\t%s", + line); + } else { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Categories = None"); + } + cipso2sl(opt, &sl, &ishigh); + if (is_system_labeled()) { + if (bsltos(&sl, &plabel, ALABEL_MAXLEN, + LONG_CLASSIFICATION|LONG_WORDS|VIEW_INTERNAL) < 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "The Sensitivity Level and Categories can't be " + "mapped to a valid SL"); + } else { + (void) snprintf(get_line(0, 0), get_line_remain(), + "The Sensitivity Level and Categories are mapped " + "to the SL:"); + (void) snprintf(get_line(0, 0), get_line_remain(), + "\t%s", ascii_label); + } + } + return (taglen); +} + +/* + * The following struct definition #define's are copied from TS1.x. They are + * not used here (except TTYPE_3_MAX_TOKENS), but included as a reference for + * the tag type 3 packet format. + */ +#define TTYPE_3_MAX_TOKENS 7 + +/* + * Display CIPSO tag type 3 which is defined by MAXSIX. + */ +static int +interpret_cipso_tagtype3(const uchar_t *opt) +{ + uchar_t tagtype; + int index, numtokens, taglen; + uint16_t mask; + uint32_t token; + static const char *name[] = { + "SL", + "NCAV", + "INTEG", + "SID", + "undefined", + "undefined", + "IL", + "PRIVS", + "LUID", + "PID", + "IDS", + "ACL" + }; + + tagtype = *opt++; + (void) memcpy(&mask, opt + 3, sizeof (mask)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Tag Type = %d (MAXSIX)", tagtype); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Generation = 0x%02x%02x%02x, Mask = 0x%04x", opt[0], opt[1], + opt[2], mask); + opt += 3 + sizeof (mask); + + /* + * Display tokens + */ + numtokens = 0; + index = 0; + while (mask != 0 && numtokens < TTYPE_3_MAX_TOKENS) { + if (mask & 0x0001) { + (void) memcpy(&token, opt, sizeof (token)); + opt += sizeof (token); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Attribute = %s, Token = 0x%08x", + index < sizeof (name) / sizeof (*name) ? + name[index] : "unknown", token); + numtokens++; + } + mask = mask >> 1; + index++; + } + + taglen = 6 + numtokens * 4; + return (taglen); +} + +static void +print_cipso(const uchar_t *opt) +{ + int optlen, taglen, tagnum; + uint32_t doi; + char line[CIPSO_GENERIC_ARRAY_LEN]; + char *oldnest; + + optlen = opt[1]; + if (optlen < TSOL_CIPSO_MIN_LENGTH || optlen > TSOL_CIPSO_MAX_LENGTH) + return; + + oldnest = prot_nest_prefix; + prot_nest_prefix = prot_prefix; + show_header("CIPSO: ", "Common IP Security Option", 0); + show_space(); + + /* + * Display CIPSO Header + */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type = CIPSO (%d), Length = %d", opt[0], opt[1]); + (void) memcpy(&doi, opt + 2, sizeof (doi)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Domain of Interpretation = %u", (unsigned)ntohl(doi)); + + if (opt[1] == TSOL_CIPSO_MIN_LENGTH) { /* no tags */ + show_space(); + prot_prefix = prot_nest_prefix; + prot_nest_prefix = oldnest; + return; + } + optlen -= TSOL_CIPSO_MIN_LENGTH; + opt += TSOL_CIPSO_MIN_LENGTH; + + /* + * Display Each Tag + */ + tagnum = 1; + while (optlen >= TSOL_TT1_MIN_LENGTH) { + (void) snprintf(line, sizeof (line), "Tag# %d", tagnum); + show_header("CIPSO: ", line, 0); + /* + * We handle tag type 1 and 3 only. Note, tag type 3 + * is MAXSIX defined. + */ + switch (opt[0]) { + case 1: + taglen = interpret_cipso_tagtype1(opt); + break; + case 3: + taglen = interpret_cipso_tagtype3(opt); + break; + default: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown Tag Type %d", opt[0]); + show_space(); + prot_prefix = prot_nest_prefix; + prot_nest_prefix = oldnest; + return; + } + + /* + * Move to the next tag + */ + if (taglen <= 0) + break; + optlen -= taglen; + opt += taglen; + tagnum++; + } + show_space(); + prot_prefix = prot_nest_prefix; + prot_nest_prefix = oldnest; +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipaddr.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipaddr.c new file mode 100644 index 0000000..c42c55d --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipaddr.c @@ -0,0 +1,425 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/if_ether.h> +#include <netinet/ip.h> +#include <netdb.h> +#include <string.h> +#include <signal.h> +#include <setjmp.h> +#include <arpa/inet.h> +#include "snoop.h" + +static sigjmp_buf nisjmp; + +#define MAXHASH 1024 /* must be a power of 2 */ + +#define SEPARATORS " \t\n" + +struct hostdata { + struct hostdata *h_next; + char *h_hostname; + int h_pktsout; + int h_pktsin; +}; + +struct hostdata4 { + struct hostdata4 *h4_next; + char *h4_hostname; + int h4_pktsout; + int h4_pktsin; + struct in_addr h4_addr; +}; + +struct hostdata6 { + struct hostdata6 *h6_next; + char *h6_hostname; + int h6_pktsout; + int h6_pktsin; + struct in6_addr h6_addr; +}; + +static struct hostdata *addhost(int, const void *, const char *, char **); + +static struct hostdata4 *h_table4[MAXHASH]; +static struct hostdata6 *h_table6[MAXHASH]; + +#define iphash(e) ((e) & (MAXHASH-1)) + +/* ARGSUSED */ +static void +wakeup(int n) +{ + siglongjmp(nisjmp, 1); +} + +extern char *inet_ntoa(); + +static struct hostdata * +iplookup(struct in_addr ipaddr) +{ + register struct hostdata4 *h; + struct hostent *hp = NULL; + struct netent *np; + int error_num; + struct hostdata *retval; + + for (h = h_table4[iphash(ipaddr.s_addr)]; h; h = h->h4_next) { + if (h->h4_addr.s_addr == ipaddr.s_addr) + return ((struct hostdata *)h); + } + + /* not found. Put it in */ + + if (ipaddr.s_addr == htonl(INADDR_BROADCAST)) + return (addhost(AF_INET, &ipaddr, "BROADCAST", NULL)); + if (ipaddr.s_addr == htonl(INADDR_ANY)) + return (addhost(AF_INET, &ipaddr, "OLD-BROADCAST", NULL)); + + /* + * Set an alarm here so we don't get held up by + * an unresponsive name server. + * Give it 3 sec to do its work. + */ + if (! rflg && sigsetjmp(nisjmp, 1) == 0) { + (void) snoop_alarm(3, wakeup); + hp = getipnodebyaddr((char *)&ipaddr, sizeof (int), + AF_INET, &error_num); + if (hp == NULL && inet_lnaof(ipaddr) == 0) { + np = getnetbyaddr(inet_netof(ipaddr), AF_INET); + if (np) + return (addhost(AF_INET, &ipaddr, np->n_name, + np->n_aliases)); + } + (void) snoop_alarm(0, wakeup); + } + + retval = addhost(AF_INET, &ipaddr, + hp ? hp->h_name : inet_ntoa(ipaddr), + hp ? hp->h_aliases : NULL); + if (hp != NULL) + freehostent(hp); + return (retval); +} + +static struct hostdata * +ip6lookup(const struct in6_addr *ip6addr) +{ + struct hostdata6 *h; + struct hostent *hp = NULL; + int error_num; + char addrstr[INET6_ADDRSTRLEN]; + char *addname; + struct hostdata *retval; + + for (h = h_table6[iphash(((uint32_t *)ip6addr)[3])]; h; + h = h->h6_next) { + if (IN6_ARE_ADDR_EQUAL(&h->h6_addr, ip6addr)) + return ((struct hostdata *)h); + } + + /* not in the hash table, put it in */ + if (IN6_IS_ADDR_UNSPECIFIED(ip6addr)) + return (addhost(AF_INET6, ip6addr, "UNSPECIFIED", NULL)); + + /* + * Set an alarm here so we don't get held up by + * an unresponsive name server. + * Give it 3 sec to do its work. + */ + if (! rflg && sigsetjmp(nisjmp, 1) == 0) { + (void) snoop_alarm(3, wakeup); + hp = getipnodebyaddr(ip6addr, sizeof (struct in6_addr), + AF_INET6, &error_num); + (void) snoop_alarm(0, wakeup); + } else { + hp = NULL; + } + + if (hp != NULL) + addname = hp->h_name; + else { + (void) inet_ntop(AF_INET6, ip6addr, addrstr, INET6_ADDRSTRLEN); + addname = addrstr; + } + + retval = addhost(AF_INET6, ip6addr, addname, hp ? hp->h_aliases : NULL); + if (hp != NULL) + freehostent(hp); + return (retval); +} + +static struct hostdata * +addhost(int family, const void *ipaddr, const char *name, char **aliases) +{ + struct hostdata **hp, *n = NULL; + extern FILE *namefile; + int hashval; + static char aname[128]; + char *np; + static struct hostdata h; + int ind; + + switch (family) { + case AF_INET: + n = (struct hostdata *)malloc(sizeof (struct hostdata4)); + if (n == NULL) + goto alloc_failed; + + memset(n, 0, sizeof (struct hostdata4)); + n->h_hostname = strdup(name); + if (n->h_hostname == NULL) + goto alloc_failed; + + ((struct hostdata4 *)n)->h4_addr = + *(const struct in_addr *)ipaddr; + hashval = ((struct in_addr *)ipaddr)->s_addr; + hp = (struct hostdata **)&h_table4[iphash(hashval)]; + break; + case AF_INET6: + n = (struct hostdata *)malloc(sizeof (struct hostdata6)); + if (n == NULL) + goto alloc_failed; + + memset(n, 0, sizeof (struct hostdata6)); + n->h_hostname = strdup(name); + if (n->h_hostname == NULL) + goto alloc_failed; + + memcpy(&((struct hostdata6 *)n)->h6_addr, ipaddr, + sizeof (struct in6_addr)); + hashval = ((const int *)ipaddr)[3]; + hp = (struct hostdata **)&h_table6[iphash(hashval)]; + break; + default: + fprintf(stderr, "snoop: ERROR: Unknown address family: %d", + family); + exit(1); + } + + n->h_next = *hp; + *hp = n; + + if (namefile != NULL) { + if (family == AF_INET) { + np = inet_ntoa(*(const struct in_addr *)ipaddr); + if (np) { + (void) fprintf(namefile, "%s\t%s", np, name); + if (aliases) { + for (ind = 0; + aliases[ind] != NULL; + ind++) { + (void) fprintf(namefile, " %s", + aliases[ind]); + } + } + (void) fprintf(namefile, "\n"); + } + } else if (family == AF_INET6) { + np = (char *)inet_ntop(AF_INET6, (void *)ipaddr, aname, + sizeof (aname)); + if (np) { + (void) fprintf(namefile, "%s\t%s", np, name); + if (aliases) { + for (ind = 0; + aliases[ind] != NULL; + ind++) { + (void) fprintf(namefile, " %s", + aliases[ind]); + } + } + (void) fprintf(namefile, "\n"); + } + } else { + (void) fprintf(stderr, "addhost: unknown family %d\n", + family); + } + } + return (n); + +alloc_failed: + if (n) + free(n); + (void) fprintf(stderr, "addhost: no mem\n"); + + aname[0] = '\0'; + memset(&h, 0, sizeof (struct hostdata)); + h.h_hostname = aname; + return (&h); +} + +char * +addrtoname(int family, const void *ipaddr) +{ + switch (family) { + case AF_INET: + return (iplookup(*(const struct in_addr *)ipaddr)->h_hostname); + case AF_INET6: + return (ip6lookup((const struct in6_addr *)ipaddr)->h_hostname); + } + (void) fprintf(stderr, "snoop: ERROR: unknown address family: %d\n", + family); + exit(1); + /* NOTREACHED */ +} + +void +load_names(fname) + char *fname; +{ + char buf[1024]; + char *addr, *name, *alias; + FILE *f; + unsigned int addrv4; + struct in6_addr addrv6; + int family; + void *naddr; + + (void) fprintf(stderr, "Loading name file %s\n", fname); + f = fopen(fname, "r"); + if (f == NULL) { + perror(fname); + return; + } + + while (fgets(buf, 1024, f) != NULL) { + addr = strtok(buf, SEPARATORS); + if (addr == NULL || *addr == '#') + continue; + if (inet_pton(AF_INET6, addr, (void *)&addrv6) == 1) { + family = AF_INET6; + naddr = (void *)&addrv6; + } else if ((addrv4 = inet_addr(addr)) != (ulong_t)-1) { + family = AF_INET; + naddr = (void *)&addrv4; + } + name = strtok(NULL, SEPARATORS); + if (name == NULL) + continue; + while ((alias = strtok(NULL, SEPARATORS)) != NULL && + (*alias != '#')) { + (void) addhost(family, naddr, alias, NULL); + } + (void) addhost(family, naddr, name, NULL); + /* Note: certain addresses such as broadcast are skipped */ + } + + (void) fclose(f); +} + +/* + * lgetipnodebyname: looks up hostname in cached address data. This allows + * filtering on hostnames from the .names file to work properly, and + * avoids name clashes between domains. Note that only the first of the + * ipv4, ipv6, or v4mapped address will be returned, because the + * cache does not contain information on multi-homed hosts. + */ +/*ARGSUSED*/ +struct hostent * +lgetipnodebyname(const char *name, int af, int flags, int *error_num) +{ + int i; + struct hostdata4 *h; + struct hostdata6 *h6; + static struct hostent he; /* host entry */ + static struct in6_addr h46_addr[MAXADDRS]; /* v4mapped address */ + static char h_name[MAXHOSTNAMELEN]; /* hostname */ + static char *list[MAXADDRS]; /* addr_list array */ + struct hostent *hp = &he; + int ind; + + (void) memset((char *)hp, 0, sizeof (struct hostent)); + hp->h_name = h_name; + h_name[0] = '\0'; + strcpy(h_name, name); + + hp->h_addrtype = AF_INET6; + + hp->h_addr_list = list; + for (i = 0; i < MAXADDRS; i++) + hp->h_addr_list[i] = NULL; + ind = 0; + + /* ipv6 lookup */ + if (af == AF_INET6) { + hp->h_length = sizeof (struct in6_addr); + for (i = 0; i < MAXHASH; i++) { + for (h6 = h_table6[i]; h6; h6 = h6->h6_next) { + if (strcmp(name, h6->h6_hostname) == 0) { + if (ind >= MAXADDRS - 1) { + /* too many addresses */ + return (hp); + } + /* found ipv6 addr */ + hp->h_addr_list[ind] = + (char *)&h6->h6_addr; + ind++; + } + } + } + } + /* ipv4 or v4mapped lookup */ + if (af == AF_INET || (flags & AI_ALL)) { + for (i = 0; i < MAXHASH; i++) { + for (h = h_table4[i]; h; h = h->h4_next) { + if (strcmp(name, h->h4_hostname) == 0) { + if (ind >= MAXADDRS - 1) { + /* too many addresses */ + return (hp); + } + if (af == AF_INET) { + /* found ipv4 addr */ + hp->h_addrtype = AF_INET; + hp->h_length = + sizeof (struct in_addr); + hp->h_addr_list[ind] = + (char *)&h->h4_addr; + ind++; + } else { + /* found v4mapped addr */ + hp->h_length = + sizeof (struct in6_addr); + hp->h_addr_list[ind] = + (char *)&h46_addr[ind]; + IN6_INADDR_TO_V4MAPPED( + &h->h4_addr, + &h46_addr[ind]); + ind++; + } + } + } + } + } + return (ind > 0 ? hp : NULL); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipsec.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipsec.c new file mode 100644 index 0000000..9212cbc --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ipsec.c @@ -0,0 +1,243 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <strings.h> +#include <sys/types.h> +#include <sys/sysmacros.h> +#include <sys/time.h> + +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/ip_icmp.h> +#include <netinet/icmp6.h> +#include <netinet/if_ether.h> +#include <inet/ipsecesp.h> +#include <inet/ipsecah.h> +#include "snoop.h" + +/* ARGSUSED */ +int +interpret_esp(int flags, uint8_t *hdr, int iplen, int fraglen) +{ + /* LINTED: alignment */ + esph_t *esph = (esph_t *)hdr; + esph_t *aligned_esph; + esph_t storage; /* In case hdr isn't aligned. */ + char *line; + + if (fraglen < sizeof (esph_t)) + return (fraglen); /* incomplete header */ + + if (!IS_P2ALIGNED(hdr, 4)) { + aligned_esph = &storage; + bcopy(hdr, aligned_esph, sizeof (esph_t)); + } else { + aligned_esph = esph; + } + + if (flags & F_SUM) { + line = (char *)get_sum_line(); + /* + * sprintf() is safe because line guarantees us 80 columns, + * and SPI and replay certainly won't exceed that. + */ + (void) sprintf(line, "ESP SPI=0x%x Replay=%u", + ntohl(aligned_esph->esph_spi), + ntohl(aligned_esph->esph_replay)); + line += strlen(line); + } + + if (flags & F_DTAIL) { + show_header("ESP: ", "Encapsulating Security Payload", + sizeof (esph_t)); + show_space(); + /* + * sprintf() is safe because get_line guarantees us 80 columns, + * and SPI and replay certainly won't exceed that. + */ + (void) sprintf(get_line((char *)&esph->esph_spi - dlc_header, + 4), "SPI = 0x%x", ntohl(aligned_esph->esph_spi)); + (void) sprintf(get_line((char *)&esph->esph_replay - + dlc_header, 4), "Replay = %u", + ntohl(aligned_esph->esph_replay)); + (void) sprintf(get_line((char *)(esph + 1) - dlc_header, + 4), " ....ENCRYPTED DATA...."); + } + + return (sizeof (esph_t)); +} + +int +interpret_ah(int flags, uint8_t *hdr, int iplen, int fraglen) +{ + /* LINTED: alignment */ + ah_t *ah = (ah_t *)hdr; + ah_t *aligned_ah; + ah_t storage; /* In case hdr isn't aligned. */ + char *line, *buff; + uint_t ahlen, auth_data_len; + uint8_t *auth_data, *data; + int new_iplen; + uint8_t proto; + + if (fraglen < sizeof (ah_t)) + return (fraglen); /* incomplete header */ + + if (!IS_P2ALIGNED(hdr, 4)) { + aligned_ah = (ah_t *)&storage; + bcopy(hdr, &storage, sizeof (ah_t)); + } else { + aligned_ah = ah; + } + + /* + * "+ 8" is for the "constant" part that's not included in the AH + * length. + * + * The AH RFC specifies the length field in "length in 4-byte units, + * not counting the first 8 bytes". So if an AH is 24 bytes long, + * the length field will contain "4". (4 * 4 + 8 == 24). + */ + ahlen = (aligned_ah->ah_length << 2) + 8; + fraglen -= ahlen; + if (fraglen < 0) + return (fraglen + ahlen); /* incomplete header */ + + auth_data_len = ahlen - sizeof (ah_t); + auth_data = (uint8_t *)(ah + 1); + data = auth_data + auth_data_len; + + if (flags & F_SUM) { + line = (char *)get_sum_line(); + (void) sprintf(line, "AH SPI=0x%x Replay=%u", + ntohl(aligned_ah->ah_spi), ntohl(aligned_ah->ah_replay)); + line += strlen(line); + } + + if (flags & F_DTAIL) { + show_header("AH: ", "Authentication Header", ahlen); + show_space(); + (void) sprintf(get_line((char *)&ah->ah_nexthdr - dlc_header, + 1), "Next header = %d (%s)", aligned_ah->ah_nexthdr, + getproto(aligned_ah->ah_nexthdr)); + (void) sprintf(get_line((char *)&ah->ah_length - dlc_header, 1), + "AH length = %d (%d bytes)", aligned_ah->ah_length, ahlen); + (void) sprintf(get_line((char *)&ah->ah_reserved - dlc_header, + 2), "<Reserved field = 0x%x>", + ntohs(aligned_ah->ah_reserved)); + (void) sprintf(get_line((char *)&ah->ah_spi - dlc_header, 4), + "SPI = 0x%x", ntohl(aligned_ah->ah_spi)); + (void) sprintf(get_line((char *)&ah->ah_replay - dlc_header, 4), + "Replay = %u", ntohl(aligned_ah->ah_replay)); + + /* + * 2 for two hex digits per auth_data byte + * plus one byte for trailing null byte. + */ + buff = malloc(auth_data_len * 2 + 1); + if (buff != NULL) { + int i; + + for (i = 0; i < auth_data_len; i++) + sprintf(buff + i * 2, "%02x", auth_data[i]); + } + + (void) sprintf(get_line((char *)auth_data - dlc_header, + auth_data_len), "ICV = %s", + (buff == NULL) ? "<out of memory>" : buff); + + /* malloc(3c) says I can call free even if buff == NULL */ + free(buff); + + show_space(); + } + + new_iplen = iplen - ahlen; + proto = aligned_ah->ah_nexthdr; + + /* + * Print IPv6 Extension Headers, or skip them in the summary case. + */ + if (proto == IPPROTO_HOPOPTS || proto == IPPROTO_DSTOPTS || + proto == IPPROTO_ROUTING || proto == IPPROTO_FRAGMENT) { + (void) print_ipv6_extensions(flags, &data, &proto, &iplen, + &fraglen); + } + + if (fraglen > 0) + switch (proto) { + case IPPROTO_ENCAP: + /* LINTED: alignment */ + (void) interpret_ip(flags, (struct ip *)data, + new_iplen); + break; + case IPPROTO_IPV6: + (void) interpret_ipv6(flags, (ip6_t *)data, + new_iplen); + break; + case IPPROTO_ICMP: + (void) interpret_icmp(flags, + /* LINTED: alignment */ + (struct icmp *)data, new_iplen, fraglen); + break; + case IPPROTO_ICMPV6: + /* LINTED: alignment */ + (void) interpret_icmpv6(flags, (icmp6_t *)data, + new_iplen, fraglen); + break; + case IPPROTO_TCP: + (void) interpret_tcp(flags, + (struct tcphdr *)data, new_iplen, fraglen); + break; + + case IPPROTO_ESP: + (void) interpret_esp(flags, data, new_iplen, + fraglen); + break; + + case IPPROTO_AH: + (void) interpret_ah(flags, data, new_iplen, + fraglen); + break; + + case IPPROTO_UDP: + (void) interpret_udp(flags, + (struct udphdr *)data, new_iplen, fraglen); + break; + /* default case is to not print anything else */ + } + + return (ahlen); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_isis.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_isis.c new file mode 100644 index 0000000..be7cae5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_isis.c @@ -0,0 +1,99 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ethernet.h> +#include <sys/vlan.h> +#include <net/trill.h> + +#include <snoop.h> + +#define PDUTYPE_OFFSET 4 +#define PDUTYPE_HELLO1 15 +#define PDUTYPE_HELLO2 16 +#define PDUTYPE_HELLOP2P 17 +#define PDUTYPE_LSP1 18 +#define PDUTYPE_LSP2 20 +#define PDUTYPE_CSN1 24 +#define PDUTYPE_CSN2 25 +#define PDUTYPE_PSN1 26 +#define PDUTYPE_PSN2 27 + +int +interpret_isis(int flags, char *data, int dlen, boolean_t istrill) +{ + uint8_t pdutypenum; + char *pdutype; + + pdutypenum = *(data+ PDUTYPE_OFFSET); + switch (pdutypenum) { + case PDUTYPE_HELLO1: + case PDUTYPE_HELLO2: + pdutype = "Hello"; + break; + case PDUTYPE_HELLOP2P: + pdutype = "P2P Hello"; + break; + case PDUTYPE_LSP1: + case PDUTYPE_LSP2: + pdutype = "Link State"; + break; + case PDUTYPE_CSN1: + case PDUTYPE_CSN2: + pdutype = "CSN"; + break; + case PDUTYPE_PSN1: + case PDUTYPE_PSN2: + pdutype = "PSN"; + break; + default: + pdutype = "Unknown"; + break; + } + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "%s %s L:%d", istrill ? "Core TRILL IS-IS" : "IS-IS", + pdutype, dlen); + } + + if (flags & F_DTAIL) { + if (istrill) { + show_header("TRILL-IS-IS: ", + "Core TRILL IS-IS Frame", dlen); + } else { + show_header("IS-IS: ", + "IS-IS Frame", dlen); + } + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Frame type = %02X (%s)", pdutypenum, pdutype); + show_trailer(); + } + return (0); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ldap.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ldap.c new file mode 100644 index 0000000..2877ad7 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ldap.c @@ -0,0 +1,1470 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2006 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/stat.h> +#include <sys/uio.h> +#include <unistd.h> +#include <signal.h> +#include <errno.h> +#include <stdlib.h> +#include <sys/wait.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <netinet/udp.h> +#include "snoop.h" + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +extern char *src_name; +extern char *dst_name; +#define MAX_CTX (10) +#define LINE_LEN (255) +#define BUF_SIZE (16000) +static int ldap = 0; /* flag to control initialization */ +struct ctx { + int src; + int dst; + char *src_name; + char *dst_name; +}; +char *osibuff = NULL; +int osilen = 0; +char scrbuffer[BUF_SIZE]; /* buffer to accumulate data until a */ + /* complete LDAPmessage is received */ +char resultcode[LINE_LEN]; /* These are used */ +char operation[LINE_LEN]; /* by -V option. */ +char bb[LINE_LEN]; + +int gi_osibuf[MAX_CTX]; +int otyp[MAX_CTX]; +int olen[MAX_CTX]; +int level[MAX_CTX]; + +void decode_ldap(char *buf, int len); + +#define X unsigned char +typedef X * A; +#define INT(a) ((int)(a)) +#define SCRUB (void) strcat(scrbuffer, bb); + +static X hex; /* input hex octet */ +static A *PTRaclass; /* application tag table pointer */ + +/* + * ASN.1 Message Printing Macros + */ + +#define asnshw1(a) {(void)sprintf(bb, a); SCRUB } +#define asnshw2(a, b) {(void)sprintf(bb, a, b); SCRUB } +#define asnshw3(a, b, c) {(void)sprintf(bb, a, b, c); SCRUB } +#define asnshw4(a, b, c, d) {(void)sprintf(bb, a, b, c, d); SCRUB } +#define asnshw5(a, b, c, d, e) {(void)sprintf(bb, a, b, c, d, e); SCRUB } + +/* + * Local Types And Variables + */ + +/* + * Object identifier oid to name mapping description type + */ + +typedef struct { + A oidname; /* object identifier string name */ + X oidcode[16]; /* object identifier hexa code */ +} oidelmT; +typedef oidelmT *oidelmTp; + +/* + * Snoop's entry point to ldap decoding + */ + +void +interpret_ldap(flags, data, fraglen, src, dst) +int flags; +char *data; +int fraglen; +int src; +int dst; +{ + + if (!ldap) { + init_ldap(); + ldap = 1; + } + + (void) decode_ldap(data, fraglen); + + if (flags & F_DTAIL) { + /* i.e. when snoop is run with -v (verbose) */ + show_header("LDAP: ", + "Lightweight Directory Access Protocol Header", fraglen); + show_space(); + printf("%s", scrbuffer); + } + + if (flags & F_SUM) { + /* i.e. when snoop is run with -V (summary) */ + (void) strcpy(data, ""); + + if (strlen(operation) != 0) { + (void) strcat(data, " "); + (void) strncat(data, operation, 30); + (void) strcpy(operation, ""); + } + + if (strlen(resultcode) != 0) { + (void) strcat(data, " "); + (void) strncat(data, resultcode, 30); + (void) strcpy(resultcode, ""); + } + + if (dst == 389) { + (void) sprintf(get_sum_line(), + "LDAP C port=%d%s", src, data); + } + if (src == 389) { + (void) sprintf(get_sum_line(), + "LDAP R port=%d%s", dst, data); + } + } + + (void) strcpy(scrbuffer, ""); +} + +/* + * Known object identifiers: customize to add your own oids + */ + +static oidelmT OidTab[] = { +/* + * X.500 Standardized Attribute Types + */ +{(A)"ObjectClass", { 0x03, 0x55, 0x04, 0x00 }}, +{(A)"AliasObjectName", { 0x03, 0x55, 0x04, 0x01 }}, +{(A)"KnowledgeInfo", { 0x03, 0x55, 0x04, 0x02 }}, +{(A)"CommonName", { 0x03, 0x55, 0x04, 0x03 }}, +{(A)"Surname", { 0x03, 0x55, 0x04, 0x04 }}, +{(A)"SerialNumber", { 0x03, 0x55, 0x04, 0x05 }}, +{(A)"CountryName", { 0x03, 0x55, 0x04, 0x06 }}, +{(A)"LocalityName", { 0x03, 0x55, 0x04, 0x07 }}, +{(A)"StateOrProvinceName", { 0x03, 0x55, 0x04, 0x08 }}, +{(A)"StreetAddress", { 0x03, 0x55, 0x04, 0x09 }}, +{(A)"OrganizationName", { 0x03, 0x55, 0x04, 0x0a }}, +{(A)"OrganizationUnitName", { 0x03, 0x55, 0x04, 0x0b }}, +{(A)"Title", { 0x03, 0x55, 0x04, 0x0c }}, +{(A)"Description", { 0x03, 0x55, 0x04, 0x0d }}, +{(A)"SearchGuide", { 0x03, 0x55, 0x04, 0x0e }}, +{(A)"BusinessCategory", { 0x03, 0x55, 0x04, 0x0f }}, +{(A)"PostalAddress", { 0x03, 0x55, 0x04, 0x10 }}, +{(A)"PostalCode", { 0x03, 0x55, 0x04, 0x11 }}, +{(A)"PostOfficeBox", { 0x03, 0x55, 0x04, 0x12 }}, +{(A)"PhysicalDeliveryOffice", { 0x03, 0x55, 0x04, 0x13 }}, +{(A)"TelephoneNUmber", { 0x03, 0x55, 0x04, 0x14 }}, +{(A)"TelexNumber", { 0x03, 0x55, 0x04, 0x15 }}, +{(A)"TeletexTerminalId", { 0x03, 0x55, 0x04, 0x16 }}, +{(A)"FaxTelephoneNumber", { 0x03, 0x55, 0x04, 0x17 }}, +{(A)"X121Address", { 0x03, 0x55, 0x04, 0x18 }}, +{(A)"IsdnAddress", { 0x03, 0x55, 0x04, 0x19 }}, +{(A)"RegisteredAddress", { 0x03, 0x55, 0x04, 0x1a }}, +{(A)"DestinationIndicator", { 0x03, 0x55, 0x04, 0x1b }}, +{(A)"PreferDeliveryMethod", { 0x03, 0x55, 0x04, 0x1c }}, +{(A)"PresentationAddress", { 0x03, 0x55, 0x04, 0x1d }}, +{(A)"SupportedApplContext", { 0x03, 0x55, 0x04, 0x1e }}, +{(A)"Member", { 0x03, 0x55, 0x04, 0x1f }}, +{(A)"Owner", { 0x03, 0x55, 0x04, 0x20 }}, +{(A)"RoleOccupant", { 0x03, 0x55, 0x04, 0x21 }}, +{(A)"SeeAlso", { 0x03, 0x55, 0x04, 0x22 }}, +{(A)"Password", { 0x03, 0x55, 0x04, 0x23 }}, +{(A)"UserCertificate", { 0x03, 0x55, 0x04, 0x24 }}, +{(A)"CaCertificate", { 0x03, 0x55, 0x04, 0x25 }}, +{(A)"AuthorityRevList", { 0x03, 0x55, 0x04, 0x26 }}, +{(A)"CertificateRevList", { 0x03, 0x55, 0x04, 0x27 }}, +{(A)"CrossCertificatePair", { 0x03, 0x55, 0x04, 0x28 }}, + +/* + * X.500 Standardized Object Classes + */ +{(A)"Top", { 0x03, 0x55, 0x06, 0x00 }}, +{(A)"Alias", { 0x03, 0x55, 0x06, 0x01 }}, +{(A)"Country", { 0x03, 0x55, 0x06, 0x02 }}, +{(A)"Locality", { 0x03, 0x55, 0x06, 0x03 }}, +{(A)"Organization", { 0x03, 0x55, 0x06, 0x04 }}, +{(A)"OrganizationUnit", { 0x03, 0x55, 0x06, 0x05 }}, +{(A)"Person", { 0x03, 0x55, 0x06, 0x06 }}, +{(A)"OrganizationPersion", { 0x03, 0x55, 0x06, 0x07 }}, +{(A)"OrganizationRole", { 0x03, 0x55, 0x06, 0x08 }}, +{(A)"Group", { 0x03, 0x55, 0x06, 0x09 }}, +{(A)"ResidentialPerson", { 0x03, 0x55, 0x06, 0x0A }}, +{(A)"ApplicationProcess", { 0x03, 0x55, 0x06, 0x0B }}, +{(A)"ApplicationEntity", { 0x03, 0x55, 0x06, 0x0C }}, +{(A)"Dsa", { 0x03, 0x55, 0x06, 0x0D }}, +{(A)"Device", { 0x03, 0x55, 0x06, 0x0E }}, +{(A)"StrongAuthenticUser", { 0x03, 0x55, 0x06, 0x0F }}, +{(A)"CaAuthority", { 0x03, 0x55, 0x06, 0x10 }}, + +/* + * ACSE Protocol Object Identifiers + */ +{(A)"Asn1BER-TS", { 0x02, 0x51, 0x01 }}, +{(A)"Private-TS", { 0x06, 0x2b, 0xce, 0x06, 0x01, 0x04, 0x06 }}, +{(A)"ACSE-AS", { 0x04, 0x52, 0x01, 0x00, 0x01 }}, + +/* + * Directory Protocol Oids + */ +{(A)"DirAccess-AC", { 0x03, 0x55, 0x03, 0x01 }}, +{(A)"DirSystem-AC", { 0x03, 0x55, 0x03, 0x02 }}, + +{(A)"DirAccess-AS", { 0x03, 0x55, 0x09, 0x01 }}, +{(A)"DirSystem-AS", { 0x03, 0x55, 0x09, 0x02 }}, + +/* + * and add your private object identifiers here ... + */ +}; + +#define OIDNB (sizeof (OidTab) / sizeof (oidelmT)) /* total oid nb */ + +/* + * asn.1 tag class definition + */ + +static A class[] = { /* tag class */ + (A)"UNIV ", + (A)"APPL ", + (A)"CTXs ", + (A)"PRIV " +}; + +/* + * universal tag definition + */ + +static A uclass[] = { /* universal tag assignment */ +(A)"EndOfContents", /* 0 */ +(A)"Boolean", /* 1 */ +(A)"Integer", /* 2 */ +(A)"BitString", /* 3 */ +(A)"OctetString", /* 4 */ +(A)"Null", /* 5 */ +(A)"Oid", /* 6 */ +(A)"ObjDescriptor", /* 7 */ +(A)"External", /* 8 */ +(A)"Real", /* 9 */ +(A)"Enumerated", /* 10 */ +(A)"Reserved", /* 11 */ +(A)"Reserved", /* 12 */ +(A)"Reserved", /* 13 */ +(A)"Reserved", /* 14 */ +(A)"Reserved", /* 15 */ +(A)"Sequence", /* 16 */ +(A)"Set", /* 17 */ +(A)"NumericString", /* 18 */ +(A)"PrintableString", /* 19 */ +(A)"T.61String", /* 20 */ +(A)"VideotexString", /* 21 */ +(A)"IA5String", /* 22 */ +(A)"UTCTime", /* 23 */ +(A)"GeneralizedTime", /* 24 */ +(A)"GraphicString", /* 25 */ +(A)"VisibleString", /* 26 */ +(A)"GeneralString", /* 27 */ +(A)"Reserved", /* 28 */ +(A)"Reserved", /* 29 */ +(A)"Reserved", /* 30 */ +(A)"Reserved" /* 31 */ +}; + +static A MHSaclass[] = { /* mhs application tag assignment */ +(A)"Bind Request", /* 0 */ +(A)"Bind Response", +(A)"Unbind Request", +(A)"Search Request", +(A)"Search ResEntry", +(A)"Search ResDone", /* 5 */ +(A)"Modify Request", +(A)"Modify Response", +(A)"Add Request", +(A)"Add Response", /* 9 */ +(A)"Del Request", +(A)"Del Response", +(A)"ModDN Request", +(A)"ModDN Response", +(A)"Compare Request", /* 14 */ +(A)"Compare Response", +(A)"Abandon Request", +(A)"", /* 17 */ +(A)"", /* 18 */ +(A)"Search ResRef", /* 19 */ +(A)"", /* 20 */ +(A)"", /* 21 */ +(A)"", /* 22 */ +(A)"Extended Request", +(A)"Extended Response", +(A)"", /* 25 */ +(A)"", /* 26 */ +(A)"", /* 27 */ +(A)"", /* 28 */ +(A)"", /* 29 */ +(A)"", /* 30 */ +(A)"" /* 31 */ +}; + + +static A DFTaclass[] = { /* Default Application Tag Assignment */ +(A)"", /* 0 */ +(A)"", /* 1 */ +(A)"", /* 2 */ +(A)"", /* 3 */ +(A)"", /* 4 */ +(A)"", /* 5 */ +(A)"", /* 6 */ +(A)"", /* 7 */ +(A)"", /* 8 */ +(A)"", /* 9 */ +(A)"", /* 10 */ +(A)"", /* 11 */ +(A)"", /* 12 */ +(A)"", /* 13 */ +(A)"", /* 14 */ +(A)"", /* 15 */ +(A)"", /* 16 */ +(A)"", /* 17 */ +(A)"", /* 18 */ +(A)"", /* 19 */ +(A)"", /* 20 */ +(A)"", /* 21 */ +(A)"", /* 22 */ +(A)"", /* 23 */ +(A)"", /* 24 */ +(A)"", /* 25 */ +(A)"", /* 26 */ +(A)"", /* 27 */ +(A)"", /* 28 */ +(A)"", /* 29 */ +(A)"", /* 30 */ +(A)"" /* 31 */ +}; + +typedef struct asndefS { +char *name; +int type; +int application; +int nbson; +struct { + char *sonname; + struct asndefS *sondef; + long tag; + } son[50]; +} asndefT, * asndefTp; + +#define SEQUENCE 0x0002 +#define SEQUENCEOF 0x0003 +#define SET 0x0004 +#define PRINTABLE 0x0008 +#define ENUM 0x0010 +#define BITSTRING 0x0020 +#define EXTENSION 0x0040 +#define CONTENTTYPE 0x0080 +#define CONTENT 0x0100 +#define CHOICE 0x0200 + +static asndefT RTSpasswd = { "RTS Authentification data", SET, -1, 2, { + {"MTA Name", 0, 0}, + {"MTA Password", 0, 1}}}; +static asndefT RTSudata = { "RTS User data", SET, -1, 1, { + {0, &RTSpasswd, 1}}}; + +static asndefT baseObject = {"Base Object", PRINTABLE, -1, 0, {0}}; + +static asndefT scope = {"Scope", ENUM, -1, 3, { + {"BaseObject", 0, 0}, + {"singleLevel", 0, 1}, + {"wholeSubtree", 0, 2}}}; + +static asndefT derefAliases = {"DerefAliases", ENUM, -1, 4, { + {"neverDerefAliases", 0, 0}, + {"derefInSearching", 0, 1}, + {"derefFindingBaseObj", 0, 2}, + {"derefAlways", 0, 3}}}; + +static asndefT filter; +static asndefT and = {"And", SET, -1, 1, { + {0, &filter, -1}}}; +static asndefT or = {"Or", SET, -1, 1, { + {0, &filter, -1}}}; +static asndefT not = {"Not", SET, -1, 1, { + {0, &filter, -1}}}; +static asndefT equalityMatch = {"Equality Match", SEQUENCE, -1, 2, { + {"Attr Descr", 0, -1}, + {"Value", 0, -1}}}; +static asndefT substrings = {"Substring", SEQUENCE, -1, 2, { + {"Type", 0, -1}, + {"Substrings (initial)", 0, 0}, + {"Substrings (any)", 0, 1}, + {"Substring (final)", 0, 2}}}; +static asndefT greaterOrEqual = {"Greater Or Equal", SEQUENCE, -1, 2, { + {"Attr Descr", 0, -1}, + {"Value", 0, -1}}}; +static asndefT lessOrEqual = {"Less Or Equal", SEQUENCE, -1, 2, { + {"Attr Descr", 0, -1}, + {"Value", 0, -1}}}; +static asndefT approxMatch = {"Approx Match", SEQUENCE, -1, 2, { + {"Attr Descr", 0, -1}, + {"Value", 0, -1}}}; +static asndefT extensibleMatch = {"Extensible Match", SEQUENCE, -1, 4, { + {"MatchingRule", 0, 1}, + {"Type", 0, 2}, + {"MatchValue", 0, 3}, + {"dnAttributes", 0, 4}}}; + +static asndefT filter = {"Filter", CHOICE, -1, 10, { + {0, &and, 0}, + {0, &or, 1}, + {0, ¬, 2}, + {0, &equalityMatch, 3}, + {0, &substrings, 4}, + {0, &greaterOrEqual, 5}, + {0, &lessOrEqual, 6}, + {"Filter: Present", 0, 7}, + {0, &approxMatch, 8}, + {0, &extensibleMatch, 9}}}; + +static asndefT attributedescription = \ + {"Attribute Description", PRINTABLE, -1, 0, {0}}; +static asndefT attributes = {"Attribute List", SEQUENCEOF, -1, 1, { + {0, &attributedescription, -1}}}; + +static asndefT searchRequest = {"Operation", SEQUENCE, 3, 8, { + {0, &baseObject, -1}, + {0, &scope, -1}, + {0, &derefAliases, -1}, + {"SizeLimit", 0, -1}, + {"TimeLimit", 0, -1}, + {"TypesOnly", 0, -1}, + {0, &filter, -1}, + {0, &attributes, -1}}}; + +static asndefT objectName = {"Object Name", PRINTABLE, -1, 0, {0}}; + +static asndefT ldapEntry = {"Entry", PRINTABLE, -1, 0, {0}}; +static asndefT relativeLdapEntry = \ + {"Relative LDAP Entry", PRINTABLE, -1, 0, {0}}; +static asndefT newSuperior = {"New Superior", PRINTABLE, -1, 0, {0}}; + +static asndefT vals = {"Vals", SET, -1, 1, { + {"Value", 0, -1}}}; + +static asndefT attribute = {"Attribute", SEQUENCE, -1, 2, { + {"Type", 0, -1}, + {0, &vals, -1}}}; + +static asndefT partialAttributes = {"Partial Attributes", SEQUENCEOF, -1, 1, { + {0, &attribute, -1}}}; + +static asndefT searchResEntry = {"Operation", SEQUENCE, 4, 2, { + {0, &objectName, -1}, + {0, &partialAttributes, -1}}}; + +static asndefT authChoice = {"Authentication Choice", CHOICE, -1, 2, { + {"Authentication: Simple", 0, 0}, + {"Authentication: SASL", 0, 3}}}; + +static asndefT bindRequest = {"Operation", SEQUENCE, 0, 3, { + {"Version", 0, -1}, + {0, &objectName, -1}, + {0, &authChoice, -1}}}; + +static asndefT resultCode = {"Result Code", ENUM, -1, 39, { + {"Success", 0, 0}, + {"Operation Error", 0, 1}, + {"Protocol Error", 0, 2}, + {"Time Limit Exceeded", 0, 3}, + {"Size Limit Exceeded", 0, 4}, + {"Compare False", 0, 5}, + {"Compare True", 0, 6}, + {"Auth Method Not supported", 0, 7}, + {"Strong Auth Required", 0, 8}, + {"Referral", 0, 10}, + {"Admin Limit Exceeded", 0, 11}, + {"Unavailable Critical Extension", 0, 12}, + {"Confidentiality required", 0, 13}, + {"SASL Bind In Progress", 0, 14}, + {"No Such Attribute", 0, 16}, + {"Undefined Attribute Type", 0, 17}, + {"Inappropriate Matching", 0, 18}, + {"Constraint violation", 0, 19}, + {"Attribute or Value Exists", 0, 20}, + {"Invalid Attribute Syntax", 0, 21}, + {"No Such Object", 0, 32}, + {"Alias Problem", 0, 33}, + {"Invalid DN Syntax", 0, 34}, + {"Alias Dereferencing Problem", 0, 36}, + {"Inappropriate Authentication", 0, 48}, + {"Invalid Credentials", 0, 49}, + {"Insufficient Access Rights", 0, 50}, + {"Busy", 0, 51}, + {"Unavailable", 0, 52}, + {"Unwilling To Perform", 0, 53}, + {"Loop Detect", 0, 54}, + {"Naming Violation", 0, 64}, + {"ObjectClass violation", 0, 65}, + {"Not Allowed On Non Leaf", 0, 66}, + {"Not Allowed On RDN", 0, 67}, + {"Entry Already Exists", 0, 68}, + {"ObjectClass Mods Prohibited", 0, 69}, + {"Affects Multiple DSAs", 0, 71}, + {"Other", 0, 80}}}; + + +static asndefT referral = {"Referral", SEQUENCEOF, -1, 1, { + {"LDAP URL", 0, -1}}}; + +static asndefT ldapResult = {"LDAP Result", SEQUENCE, -1, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT bindResponse = {"Operation", SEQUENCE, 1, 5, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}, + {"SASL Credentials", 0, 7}}}; + +static asndefT unbindRequest = {"Operation", SEQUENCE, 2, 0, {0}}; + +static asndefT searchResDone = {"Operation", SEQUENCE, 5, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT seqModOperation = {"Operation", ENUM, -1, 4, { + {"Add", 0, 0}, + {"Delete", 0, 1}, + {"Replace", 0, 2}}}; + +static asndefT seqModModification = {"Modification", SEQUENCE, -1, 1, { + {0, &attribute, -1}}}; + +static asndefT seqModification = {"", SEQUENCE, -1, 2, { + {0, &seqModOperation, -1}, + {0, &seqModModification, -1}}}; + +static asndefT modification = {"Modification", SEQUENCEOF, -1, 1, { + {0, &seqModification, -1}}}; + +static asndefT modifyRequest = {"Operation", SEQUENCE, 6, 2, { + {0, &objectName, -1}, + {0, &modification, -1}}}; + +static asndefT modifyResponse = {"Operation", SEQUENCE, 7, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT addAttributes = {"Attributes", SEQUENCEOF, -1, 1, { + {0, &attribute, -1}}}; + +static asndefT addRequest = {"Operation", SEQUENCE, 8, 2, { + {0, &ldapEntry, -1}, + {0, &addAttributes, -1}}}; + +static asndefT addResponse = {"Operation", SEQUENCE, 9, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT delRequest = {"Operation", SEQUENCE, 10, 1, { + {0, &ldapEntry, -1}}}; + +static asndefT delResponse = {"Operation", SEQUENCE, 11, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT modifyDNRequest = {"Operation", SEQUENCE, 12, 4, { + {0, &ldapEntry, -1}, + {0, &relativeLdapEntry, -1}, + {"Delete Old RDN", 0, -1}, + {0, &newSuperior, 0}}}; + +static asndefT modifyDNResponse = {"Operation", SEQUENCE, 13, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT ava = {"Ava", SEQUENCE, -1, 2, { + {"Attr Descr", 0, -1}, + {"Value", 0, -1}}}; + +static asndefT compareRequest = {"Operation", SEQUENCE, 14, 2, { + {0, &ldapEntry, -1}, + {0, &ava, 0}}}; + +static asndefT compareResponse = {"Operation", SEQUENCE, 15, 4, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}}}; + +static asndefT abandonRequest = {"Operation", SEQUENCE, 16, 1, { + {"Message ID", 0, -1}}}; + +static asndefT searchResRef = {"Operation", SEQUENCEOF, 19, 1, { + {"LDAP URL", 0, -1}}}; + +static asndefT extendedRequest = {"Operation", SEQUENCE, 14, 2, { + {"Request Name", 0, 0}, + {"Request Value", 0, 1}}}; + +static asndefT extendedResponse = {"Operation", SEQUENCE, 24, 6, { + {0, &resultCode, -1}, + {"Matched DN", 0, -1}, + {"Error Message", 0, -1}, + {0, &referral, 3}, + {"Response Name", 0, 10}, + {"Response", 0, 11}}}; + +static asndefT protocolOp = {"Protocol Op", CHOICE, -1, 20, { + {0, &bindRequest, 0}, + {0, &bindResponse, 1}, + {0, &unbindRequest, 2}, + {0, &searchRequest, 3}, + {0, &searchResEntry, 4}, + {0, &searchResDone, 5}, + {0, &modifyRequest, 6}, + {0, &modifyResponse, 7}, + {0, &addRequest, 8}, + {0, &addResponse, 9}, + {0, &delRequest, 10}, + {0, &delResponse, 11}, + {0, &modifyDNRequest, 12}, + {0, &modifyDNResponse, 13}, + {0, &compareRequest, 14}, + {0, &compareResponse, 15}, + {0, &abandonRequest, 16}, + {0, &searchResRef, 19}, + {0, &extendedRequest, 23}, + {0, &extendedResponse, 24}}}; + +static asndefT control = {"Control", SEQUENCE, -1, 3, { + {"LDAP OID", 0, -1}, + {"Criticality", 0, -1}, + {"Control value", 0, -1}}}; + +static asndefT controls = {"Controls List", SEQUENCEOF, -1, 1, { + {0, &control, -1}}}; + +static asndefT LDAPMessage = { "LDAPMessage", SEQUENCE, -1, 3, { + {"Message ID", 0, -1}, + {0, &protocolOp, -1}, + {0, &controls, 0}}}; + +static asndefT MPDU = { "MPDU", SET, -1, 1, + {{0, &LDAPMessage, 0}}}; + +static int mytype[] = { +0, /* EndOfContents */ +0, /* Boolean */ +0, /* Integer */ +BITSTRING, /* BitString */ +0, /* OctetString */ +0, /* Null */ +0, /* Oid */ +0, /* ObjDescriptor */ +0, /* External */ +0, /* Real */ +ENUM, /* Enumerated */ +0, /* Reserved */ +0, /* Reserved */ +0, /* Reserved */ +0, /* Reserved */ +0, /* Reserved */ +SEQUENCE, /* Sequence */ +SET, /* Set */ +0, /* NumericString */ +0, /* PrintableString */ +0, /* T.61String */ +0, /* VideotexString */ +0, /* IA5String */ +0, /* UTCTime */ +0, /* GeneralizedTime */ +0, /* GraphicString */ +0, /* VisibleString */ +0, /* GeneralString */ +0, /* Reserved */ +0, /* Reserved */ +0, /* Reserved */ +0, /* Reserved */ +}; + +/* + * Find object identifier in known oid table + * A oid - oid hexa string + * int olg - oid length + */ +static int +oidmap(A oid, int olg) +{ + register int ix, goon; + register A oidptr, tabptr, tabend; + +/* returns (oid table size) if not found */ + + for (ix = 0; ix < OIDNB; ix++) { + oidptr = oid; tabptr = (&(OidTab[ix].oidcode[0])); + if (olg == INT(*tabptr++)) { + tabend = tabptr + olg; + goon = 1; + while (goon != 0 && tabptr < tabend) { + if (*tabptr++ != *oidptr++) + goon = 0; + } + if (goon != 0) + return (ix); + } + } + return (OIDNB); +} + +/* + * Read an hexacode and convert it into ASCII + */ +static int getnext(int ctxnum) +{ + static X c[3]; /* c[0-3] will contain ascii values on exit */ + hex = 0; + if (gi_osibuf[ctxnum] == osilen) + return (-1); + hex = osibuff[gi_osibuf[ctxnum]++]; + (void) sprintf((char *)c, "%02x", (hex&0x00FF)); + return (0); +} + +/* + * Skip everything that is not an LDAPMessage + */ +static char *skipjunk(len, pdu) +int len; +char *pdu; +{ + int tag; + char *buf = pdu; + int offset = 0; + while (len > 0) { + /* size minumum for a sequence + integer = 5 */ + /* LDAPMessage::= SEQUENCE */ + if ((len > 5) && (buf[0] == 0x30)) { + tag = buf[1]&0x00ff; + if (tag < 0x80) { + /* length is one one octet */ + offset = 1; + } else { + /* length is multiple octet. */ + offset = 1+ tag&0x007f; + } + /* Make sure we don't read past the end */ + /* of the buffer */ + if (len - (1+offset) > 0) { + /* skip after the length */ + tag = buf[1+offset]&0x00ff; + if (tag == 0x02) { /* INTEGER */ + /* looks like a valid PDU */ + return (buf); + } + } + } + len --; + buf++; + } + return (buf); +} + + +#define GETNEXT(a) (void)getnext(a); + +/* + * main routine: decode a TLV; to be called recursively + * + * pdulen: current pdu's length + */ +static int +decpdu(int pdulen, asndefTp ASNDESC, int ctxnum) +{ + X scrlin[99]; /* screen line */ + X oidstr[80]; /* oid hexa string */ + int slen; /* screen line length */ + int stlv; /* sub-tlv length */ + int oix; /* oid table index */ + int effnb; /* effectively traced octet nb */ + int i = 0, j = 0; + int ai = -2; + asndefTp SASNDESC = 0; + asndefTp TMPDESC = 0; + asndefTp GR_TMPDESC = 0; + int tmpai = 0; + int gr_tmpai = 0; + int dontprint = 0; + int already = 0; + static int rlen = 0; /* tlv's real length */ + + ++level[ctxnum]; /* level indicator */ + effnb = 0; + + /* + * Decode the current TLV segment + */ + while (pdulen > 1) { + + if (getnext(ctxnum)) { + break; + } + if (strlen(scrbuffer)) asnshw2("%s ", "LDAP:"); + /* screen printing according to level indicator */ + for (i = 1; i < level[ctxnum]; ++i) asnshw1(" "); + + /* get tag */ + otyp[ctxnum] = INT(hex); /* single octet type only */ + --pdulen; + ++effnb; + + /* get length */ + GETNEXT(ctxnum); + olen[ctxnum] = INT(hex); /* tlv length */ + --pdulen; + ++effnb; + + /* Continuing decoding of current TLV... */ + /* + * Snoop's lower layers do not allow us + * to know the true length for + * datastream protocols like LDAP. + */ + + /* + * if length is less than 128, we + * already have the real TLV length. + */ + if (olen[ctxnum] < 128) { /* short length form */ + rlen = olen[ctxnum]; + } else { /* long and any form length */ + /* else we do more getnext()'s */ + for (rlen = 0, olen[ctxnum] &= 0x0F; + (olen[ctxnum]) && (pdulen > 0); + --olen[ctxnum], --pdulen, ++effnb) { + GETNEXT(ctxnum); + rlen = (rlen << 8) | INT(hex); + } + if (!rlen) { + pdulen = 0x7fffffff; + } + } + + /* + * print the tag class and number + */ + i = otyp[ctxnum]&0x1F; + switch (otyp[ctxnum] >> 6) { /* class */ + case 0: /* universal */ + if (ASNDESC && i != 0) { + int dobreak = 0; + switch (ASNDESC->type) { + case CONTENT: + SASNDESC = ASNDESC; + break; + case SET: + for (ai = 0; + ai < ASNDESC->nbson && i < 32 && + ASNDESC->son[ai].sondef && + /* + * For this test SEQUENCE & SEQUENCE OF + * are same, so suppress the last bit + */ + (ASNDESC->son[ai].sondef + ->type&0xFE) + != mytype[i]; ++ai); + if (ai < ASNDESC->nbson) { + SASNDESC = + ASNDESC->son[ai].sondef; + if (ASNDESC->son[ai].sonname != NULL) { + + if (ASNDESC->son[ai].sondef != NULL && + ASNDESC->son[ai].sondef->name != + NULL) { + asnshw2("%s ", "LDAP:"); + asnshw4(" %c[%s %s]", + ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname, + ASNDESC->son[ai].sondef->name); + } else { + asnshw2("%s ", ""); + asnshw3(" %c[%s]", + ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname); + } /* end if */ + + dobreak = 1; + + } else if (ASNDESC->son[ai].sondef != + NULL && + ASNDESC->son[ai].sondef->name != + NULL) { + asnshw2("%s ", "LDAP:"); + asnshw3(" %c[%s]", + ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sondef->name); + dobreak = 1; + } /* end if */ + } /* end if */ + break; + case CHOICE: + if (GR_TMPDESC) { + ASNDESC = TMPDESC; + TMPDESC = GR_TMPDESC; + GR_TMPDESC = 0; + } else if (TMPDESC) { + ASNDESC = TMPDESC; + TMPDESC = 0; + } + if (gr_tmpai) { + ai = tmpai; + tmpai = gr_tmpai; + gr_tmpai = 0; + } else if (tmpai) { + ai = tmpai; + tmpai = 0; + } + break; + + case SEQUENCE: + if (ai == -2) { + ai = 0; + } else { + do { + ai++; + } while \ + (ai < ASNDESC->nbson && i < 32 && mytype[i] && \ + ASNDESC->son[ai].sondef && + /* + * For this test SEQUENCE & SEQUENCE OF + * are the same, so suppress last bit + */ + (ASNDESC->son[ai].sondef->type&0xFE) != mytype[i]); + } /* end if */ + if (ai < ASNDESC->nbson) { + SASNDESC = \ + ASNDESC->son[ai].sondef; + if (ASNDESC->son[ai].sonname) { + if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->name) { + asnshw4 \ + (" %c[%s %s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname, + ASNDESC->son[ai].sondef->name); + } else { + asnshw3 \ + (" %c[%s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname); + } /* end if */ + dobreak = 1; + } else if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->name) { + asnshw3 \ + (" %c[%s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sondef->name); + dobreak = 1; + } /* end if */ + } /* end if */ + break; + case SEQUENCEOF: + ai = 0; + SASNDESC = ASNDESC->son[ai].sondef; + if (ASNDESC->son[ai].sonname) { + if (ASNDESC->son[ai].sondef && \ + ASNDESC->son[ai].sondef->name) { + asnshw4 \ + (" %c[%s %s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname, + ASNDESC->son[ai].sondef->name); + } else { + asnshw3 \ + (" %c[%s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sonname); + } /* end if */ + dobreak = 1; + } else if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->name) { + asnshw3 \ + (" %c[%s]", ((otyp[ctxnum]&0x20)?'*':' '), + ASNDESC->son[ai].sondef->name); + dobreak = 1; + } /* end if */ + } /* end switch */ + if (dobreak) { + break; + } /* end if */ + } /* end if */ + if (uclass[i]) { + asnshw3 \ + (" %c[%s]", ((otyp[ctxnum]&0x20)?'*':' '), uclass[i]); + } else { + asnshw4 \ + (" %c[%s%d]", ((otyp[ctxnum]&0x20)?'*':' '), + class[0], i); + } + break; + case 1: /* application */ + + if (ASNDESC) { + + for (ai = 0; ai < ASNDESC->nbson; ++ai) { + int i2 = 0; + + if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->type == CHOICE) { + while \ + (i2 < ASNDESC->son[ai].sondef->nbson && + ASNDESC->son[ai].sondef->son[i2].sondef && \ + ASNDESC->son[ai].sondef->son[i2].sondef->application != i) { + i2++; + continue; + } + if \ + (i2 == ASNDESC->son[ai].sondef->nbson) { + ai = ASNDESC->nbson; + break; + } + if (TMPDESC) { + GR_TMPDESC = TMPDESC; + gr_tmpai = tmpai; + } + TMPDESC = ASNDESC; + ASNDESC = ASNDESC->son[ai].sondef; + tmpai = ai; + ai = i2; + } + + if (ASNDESC->son[ai].sondef && \ + ASNDESC->son[ai].sondef->application == i) { + SASNDESC = \ + ASNDESC->son[ai].sondef; + if (ASNDESC->son[ai].sonname) { + if \ + (ASNDESC->son[ai].sondef->name) { + asnshw3 \ + (" %s %s", ASNDESC->son[ai].sonname, + ASNDESC->son[ai].sondef->name); + } else { + asnshw2 \ + (" %s", ASNDESC->son[ai].sonname); + } /* end if */ + } else if \ + (ASNDESC->son[ai].sondef->name) { + asnshw2 \ + (" %s", ASNDESC->son[ai].sondef->name); + } /* end if */ + break; + } /* end if */ + } /* end for */ + if (ai >= ASNDESC->nbson) { + ai = -1; /* not found */ + } /* end if */ + } /* end if */ + if (PTRaclass[i]) { + asnshw5 \ + (" %c[%s%d: %s]", ((otyp[ctxnum]&0x20)?'*':' '), + class[1], i, PTRaclass[i]); + (void) strcpy(operation, (char *)PTRaclass[i]); + } else { + asnshw4 \ + (" %c[%s%d]", ((otyp[ctxnum]&0x20)?'*':' '), \ + class[1], i); + } + break; + + case 2: /* context-specific */ + + if (TMPDESC) { + ASNDESC = TMPDESC; + TMPDESC = GR_TMPDESC; + already = 1; + } + if (ASNDESC) { + + for (ai = 0; ai < ASNDESC->nbson; ++ai) { + if \ + (!already && ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->type == CHOICE) { + int i2 = 0; + while \ + (i2 < ASNDESC->son[ai].sondef->nbson && + ASNDESC->son[ai].sondef->son[i2].tag != i) { + i2++; + continue; + } + if (i2 == \ + ASNDESC->son[ai].sondef->nbson) { + ai = ASNDESC->nbson; + break; + } + if (TMPDESC) { + GR_TMPDESC = TMPDESC; + gr_tmpai = tmpai; + } + TMPDESC = ASNDESC; + ASNDESC = \ + ASNDESC->son[ai].sondef; + tmpai = ai; + ai = i2; + } + + if \ + (ASNDESC->son[ai].tag == i) { + SASNDESC = \ + ASNDESC->son[ai].sondef; + if (ASNDESC->son[ai].sonname) { + if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->name) { + asnshw3 \ + (" %s %s", ASNDESC->son[ai].sonname, + ASNDESC->son[ai].sondef->name); + } else { + asnshw2 \ + (" %s", ASNDESC->son[ai].sonname); + } /* end if */ + } else if \ + (ASNDESC->son[ai].sondef && + ASNDESC->son[ai].sondef->name) { + asnshw2 \ + (" %s", ASNDESC->son[ai].sondef->name); + } /* end if */ + break; + } /* end if */ + } /* end for */ + if (ai >= ASNDESC->nbson) { + ai = -1; /* not found */ + } /* end if */ + } /* end if */ + asnshw3 \ + (" %c[%d]", ((otyp[ctxnum]&0x20)?'*':' '), i); + break; + + case 3: /* private */ + asnshw4 \ + (" %c[%s%d]", ((otyp[ctxnum]&0x20)?'*':' '), \ + class[3], i); + } /* esac: tag */ + + /* + * print the length - as a debug tool only. + */ + /* asnshw2(" Length=%d ",rlen); */ + asnshw1("\n"); + if (rlen > pdulen) { + asnshw1("*** Decode length error,"); + asnshw2(" PDU length = %d ***\n", pdulen); + rlen = pdulen; + } + + /* + * recursive interpretation of the value if constructor + */ + if (otyp[ctxnum]&0x20) { /* constructor */ + + stlv = decpdu((rlen?rlen:pdulen), \ + ASNDESC && ai != -1 ?(ai == -2 ? ASNDESC: + ASNDESC->son[ai].sondef):0, ctxnum); + /* recursive decoding */ + pdulen -= stlv; + effnb += stlv; + } else if (otyp[ctxnum] == 0x06) { + /* + * interpretation of the object identifier + */ + for (j = 0; (rlen) && (pdulen > 0); \ + --rlen, --pdulen, ++effnb) { + GETNEXT(ctxnum); + oidstr[j++] = hex; + } + + /* interpret the object identifier */ + oidstr[j++] = '\0'; + oix = oidmap(oidstr, j-1); + asnshw1("\n"); + if (oix >= 0 && oix < OIDNB) { /* recognized obj id */ + asnshw2("%s\n", OidTab[oix].oidname); + } else { + asnshw1("Unknown Oid\n"); + } + } else { + /* + * interpretation of other primitive tags + */ + if (!otyp[ctxnum] && !rlen) { + /* end of contents: any form length */ + pdulen = 0; + } else { + X hexstr[5]; + int k = 0; + int klen = rlen; + if (SASNDESC && SASNDESC->type == CONTENT && \ + SASNDESC->nbson && SASNDESC->son[0].sondef) { + (void) + decpdu(rlen, SASNDESC->son[0].sondef, ctxnum); + } else { + if (rlen < 200) { + for (j = 0, slen = 0; \ + (rlen) && (pdulen > 0); + --rlen, --pdulen, ++effnb) { + if (!slen) { + (void) \ + strcpy((char *)scrlin, "LDAP: "); j += 7; + for \ + (i = 0; i < level[ctxnum]; ++i) { + scrlin[j++] = ' '; + scrlin[j++] = ' '; + scrlin[j++] = ' '; + scrlin[j++] = ' '; + } + } + + GETNEXT(ctxnum); + if (k < 5) { + hexstr[k++] = hex; + } /* end if */ + if (!isprint(hex)) { + hex = '_'; + dontprint = 1; + } + scrlin[j++] = hex; + if ((slen += 2) >= \ + (72 - (level[ctxnum] * 3))) { + slen = 0; + scrlin[j] = 0; + if (!dontprint) { + asnshw2 \ + ("%s\n", scrlin); + } + j = 0; + } + } /* rof: primitive values */ + if (slen) { + scrlin[j] = 0; + if (!dontprint) { + asnshw2("%s\n", scrlin); + } + } + dontprint = 0; + } else { + asnshw2("%s ", "LDAP:"); + for (i = 0; i < level[ctxnum]; ++i) { + asnshw1(" "); + scrlin[j++] = ' '; + scrlin[j++] = ' '; + scrlin[j++] = ' '; + } + + for (j = 0; (rlen) && (pdulen > 0); \ + --rlen, --pdulen, ++effnb) { + GETNEXT(ctxnum); + if (k < 5) { + hexstr[k++] = hex; + } + } + (void) strcpy \ + ((char *)scrlin, \ + "*** NOT PRINTED - Too long value ***"); + asnshw2("%s\n", scrlin); + } + + if \ + (SASNDESC && SASNDESC->type == BITSTRING &&\ + klen <= 5) { + unsigned long bitstr = 0; + for (i = 1; i < 5; ++i) { + bitstr = \ + ((bitstr) << 8) + ((i < klen)?hexstr[i]:0); + } /* end for */ + for \ + (i = 0; i < SASNDESC->nbson; ++i) { + if ((bitstr & \ + ((unsigned long)SASNDESC->son[i].sondef)) == + ((unsigned long)SASNDESC->son[i].tag)) { + if \ + (SASNDESC->son[i].sonname) { + int k; + asnshw2 \ + ("%s ", "LDAP:"); + for \ + (k = 0; k < level[ctxnum]; ++k) { + asnshw1(" "); + } + asnshw2 \ + ("%s", SASNDESC->son[i].sonname); + } /* end if */ + } /* end if */ + } /* end for */ + } /* end if */ + if (SASNDESC && \ + (SASNDESC->type == ENUM || + SASNDESC->type == CONTENTTYPE) && klen <= 5) { + unsigned long value = 0; + for (i = 0; i < klen; ++i) { + value = \ + ((value) << 8) + hexstr[i]; + } /* end for */ + for \ + (i = 0; i < SASNDESC->nbson; ++i) { + if \ + (value == ((unsigned long)SASNDESC->son[i].tag)) { + if \ + (SASNDESC->son[i].sonname) { + int k; + asnshw2 \ + ("%s ", "LDAP:"); + for \ + (k = 0; k < level[ctxnum]; ++k) { + asnshw1(" "); + } + asnshw2 \ + ("%s\n", SASNDESC->son[i].sonname); + (void) \ + strcpy(resultcode, SASNDESC->son[i].sonname); + } /* end if */ + break; + } /* end if */ + } /* end for */ + } /* end if */ + + } /* end if */ + } /* fi: constructor/obj-id/primitive */ + } /* fi: tag analysis */ + } /* elihw: len>1 */ + --level[ctxnum]; + return (effnb); +} + + +/* init_ldap initializes various buffers and variables */ +/* it is called one-time (in snoop_filter.c) only. */ + +void +init_ldap() +{ + int i; + + for (i = 0; i < MAX_CTX; i++) { + gi_osibuf[i] = 0; + level[i] = 0; + } +} +static void +ldapdump(char *data, int datalen) +{ + char *p; + ushort_t *p16 = (ushort_t *)data; + char *p8 = data; + int i, left, len; + int chunk = 16; /* 16 bytes per line */ + + asnshw1("LDAP: Skipping until next full LDAPMessage\n"); + + for (p = data; p < data + datalen; p += chunk) { + asnshw2("LDAP:\t%4d: ", p - data); + left = (data + datalen) - p; + len = MIN(chunk, left); + for (i = 0; i < (len / 2); i++) + asnshw2("%04x ", ntohs(*p16++) & 0xffff); + if (len % 2) { + asnshw2("%02x ", *((unsigned char *)p16)); + } + for (i = 0; i < (chunk - left) / 2; i++) + asnshw1(" "); + + asnshw1(" "); + for (i = 0; i < len; i++, p8++) + asnshw2("%c", isprint(*p8) ? *p8 : '.'); + asnshw1("\n"); + } + + asnshw1("LDAP:\n"); +} + +/* decode_ldap is the entry point for the main decoding function */ +/* decpdu(). decode_ldap() is only called by interpret_ldap. */ + +void +decode_ldap(char *buf, int len) +{ + asndefTp ASNDESC = 0; + char *newbuf; + int skipped = 0; + + PTRaclass = MHSaclass; + ASNDESC = &MPDU; + + + newbuf = skipjunk(len, buf); + if (newbuf > buf) { + skipped = newbuf-buf; + ldapdump(buf, newbuf-buf); + } + buf = newbuf; + len = len-skipped; + osibuff = buf; /* Undecoded buf is passed by interpret_ldap */ + osilen = len; /* length of tcp data is also passed */ + + (void) decpdu(len, ASNDESC, 0); + gi_osibuf[0] = 0; +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.c new file mode 100644 index 0000000..84155b2 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.c @@ -0,0 +1,869 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <fcntl.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <protocols/routed.h> +#include <string.h> +#include <arpa/inet.h> +#include "snoop.h" +#include "snoop_mip.h" + +/* + * This defines the length of internal, unbounded buffers. We set + * this to be MAXLINE (the maximum verbose display line length) - + * 64, which should be enough for all necessary descriptions. + */ +#define BUFLEN MAXLINE - 64 + +extern char *dlc_header; +extern char *addrtoname(); + +enum EXT_TYPE { ADV, REG }; + +/* + * This defines the interface for all extention interpreter + * functions. The function will be called with following + * parameters: + * + * type: IN The type code for this extention + * len IN The length of the payload (i.e. the + * length field in an extension header) + * payload IN A pointer to the beginning of the + * extension payload + */ +typedef void interpreter_f(uint8_t type, uint8_t len, uchar_t *payload); + +struct ext_dispatch { + uint8_t type; + interpreter_f *pfunc; +}; + +/* Description structure -- maps type to description */ +struct ext_desc { + uint8_t type; + const char *desc; +}; + +/* + * Interpreter function prototypes for both adv and reg. These + * all must implement the interpret_f interface defined above. + */ +static void spi_ext(uint8_t, uint8_t, uchar_t *); +static void key_ext(uint8_t, uint8_t, uchar_t *); +static void trav_ext(uint8_t, uint8_t, uchar_t *); +static void empty_ext(uint8_t, uint8_t, uchar_t *); +static void nai_ext(uint8_t, uint8_t, uchar_t *); +static void chall_ext(uint8_t, uint8_t, uchar_t *); +static void ma_ext(uint8_t, uint8_t, uchar_t *); +static void prefix_ext(uint8_t, uint8_t, uchar_t *); +static void unk_ext(uint8_t, uint8_t, uchar_t *); + +/* R E G I S T R A T I O N */ + +#define REG_TBL_LEN 10 /* update this when adding to the table */ + +/* Reg: type to description mapping table */ +static struct ext_desc reg_desc[] = { + MN_HA_AUTH, "(Mobile-Home Authentication Extension)", + MN_FA_AUTH, "(Mobile-Foreign Authentication Extension", + FA_HA_AUTH, "(Foreign-Home Authentication Extension)", + GEN_AUTH, "(Generalized Authentication Extension)", + MN_HA_KEY, "(Mobile-Home Key Extension)", + MN_FA_KEY, "(Mobile-Foreign Key Extension)", + MN_HA_TRAVERSE, "(Firewall Traversal Extension)", + ENCAP_DELIV, "(Encapsulating Delivery Style Extension)", + MN_NAI, "(Mobile Node Network Access Identifier)", + FA_CHALLENGE, "(Mobile-Foreign Agent Challenge)", + 0, "(Unrecognized Extension)" +}; + +#define GENAUTH_TBL_LEN 1 /* update this when adding to the table */ + +/* Subtypes for Generic Authentication Extension type (type 36) */ +static struct ext_desc genauth_desc[] = { + GEN_AUTH_MN_AAA, "(MN-AAA Authentication Subtype)", + 0, "(Unrecognized Subtype)" +}; + +/* Reg: type to function mapping table */ +static struct ext_dispatch reg_dispatch[] = { + MN_HA_AUTH, spi_ext, + MN_FA_AUTH, spi_ext, + FA_HA_AUTH, spi_ext, + GEN_AUTH, spi_ext, + MN_HA_KEY, key_ext, + MN_FA_KEY, key_ext, + MN_HA_TRAVERSE, trav_ext, + ENCAP_DELIV, empty_ext, + MN_NAI, nai_ext, + FA_CHALLENGE, chall_ext, + 0, unk_ext +}; + +/* A D V E R T I S E M E N T */ + +#define ADV_TBL_LEN 5 /* update this when adding to the table */ + +/* Adv: type to description mapping table */ +static struct ext_desc adv_desc[] = { + ICMP_ADV_MSG_PADDING_EXT, "(Padding)", + ICMP_ADV_MSG_MOBILITY_AGT_EXT, "(Mobility Agent Extension)", + ICMP_ADV_MSG_PREFIX_LENGTH_EXT, "(Prefix Lengths)", + ICMP_ADV_MSG_FA_CHALLENGE, "(Foreign Agent Challenge)", + ICMP_ADV_MSG_FA_NAI, "(Foreign Agent NAI)", + 0, "(Unrecognized Extension)" +}; + +/* Adv: type to function mapping table */ +static struct ext_dispatch adv_dispatch[] = { + ICMP_ADV_MSG_PADDING_EXT, NULL, /* never called */ + ICMP_ADV_MSG_MOBILITY_AGT_EXT, ma_ext, + ICMP_ADV_MSG_PREFIX_LENGTH_EXT, prefix_ext, + ICMP_ADV_MSG_FA_CHALLENGE, chall_ext, + ICMP_ADV_MSG_FA_NAI, nai_ext, + 0, unk_ext +}; + +#define GETSPI(payload, hi, low) \ + (void) memcpy(&hi, payload, sizeof (hi)); \ + (void) memcpy(&low, payload + sizeof (hi), sizeof (low)) + +static void dumphex(uchar_t *payload, int payload_len, char *buf, char *msg) { + int index; + + for (index = 0; index < payload_len; index++) { + (void) sprintf(&buf[index * 3], " %.2x", payload[index]); + } + + (void) sprintf(get_line((char *)payload-dlc_header, 1), msg, buf); +} + +static const char *get_desc(struct ext_desc table[], uint8_t type, int max) { + int i; + + for (i = 0; i < max && table[i].type != type; i++) + /* NO_OP */; + + return (table[i].desc); +} + +/* + * The following is an accessor for the description table, used by + * snoop_icmp.c. This maintains the encapsulation of the internal + * description table. + */ +const char *get_mip_adv_desc(uint8_t type) { + return (get_desc(adv_desc, type, ADV_TBL_LEN)); +} + +static interpreter_f *get_interpreter(struct ext_dispatch table[], + uint8_t type, + int max) { + int i; + + for (i = 0; i < max && table[i].type != type; i++) + /* NO_OP */; + + return (table[i].pfunc); +} + +static int +interpret_extensions(uchar_t *ext, + int regext_size, + enum EXT_TYPE etype) { + + int curr_size = regext_size; /* remaining total for all exts */ + exthdr_t *exthdr; + gen_exthdr_t *gen_exthdr; + const char *st; + uchar_t *p; + interpreter_f *f; + uint8_t ext_type; + uint16_t ext_len; + uint_t ext_hdrlen; + + show_space(); + exthdr = (exthdr_t *)ALIGN(ext); + + + do { + ext_type = exthdr->type; + if (ext_type == GEN_AUTH) { + gen_exthdr = (gen_exthdr_t *)exthdr; + ext_hdrlen = sizeof (gen_exthdr_t); + ext_len = ntohs(gen_exthdr->length); + } else { + ext_hdrlen = sizeof (exthdr_t); + ext_len = exthdr->length; + } + + if (!((etype == ADV && ext_type == ICMP_ADV_MSG_PADDING_EXT && + curr_size >= 1) || + curr_size >= ext_hdrlen + ext_len)) + break; + + /* Print description for this extension */ + if (etype == ADV) { + st = get_desc(adv_desc, ext_type, ADV_TBL_LEN); + } else /* REG */ { + st = get_desc(reg_desc, ext_type, REG_TBL_LEN); + } + + (void) sprintf(get_line((char *)exthdr-dlc_header, 1), + "Extension header type = %d %s", ext_type, st); + + if (ext_type == GEN_AUTH) { + st = get_desc(genauth_desc, gen_exthdr->subtype, + GENAUTH_TBL_LEN); + (void) sprintf(get_line((char *)exthdr-dlc_header, 1), + "Subtype = %d %s", gen_exthdr->subtype, st); + } + + /* Special case for 1-byte padding */ + if (etype == ADV && ext_type == ICMP_ADV_MSG_PADDING_EXT) { + exthdr = (exthdr_t *)((uchar_t *)exthdr + 1); + curr_size--; + continue; + } + + (void) sprintf(get_line((char *)&exthdr->length-dlc_header, 1), + "Length = %d", ext_len); + + /* Parse out the extension's payload */ + p = (uchar_t *)exthdr + ext_hdrlen; + curr_size -= (ext_hdrlen + ext_len); + + if (etype == ADV) { + f = get_interpreter(adv_dispatch, ext_type, ADV_TBL_LEN); + } else /* REG */ { + f = get_interpreter(reg_dispatch, ext_type, REG_TBL_LEN); + } + + f(ext_type, ext_len, p); + + show_space(); + exthdr = (exthdr_t *)(p + ext_len); + } while (B_TRUE); + + return (0); +} + +void interpret_icmp_mip_ext(uchar_t *p, int len) { + show_space(); + show_header("ICMP: ", " MIP Advertisement Extensions ", len); + show_space(); + + interpret_extensions(p, len, ADV); +} + +void +interpret_mip_cntrlmsg(int flags, uchar_t *msg, int fraglen) { + char *pt, *pc = NULL; + char *line; + regreq_t rreq[1]; + regrep_t rrep[1]; + int regext_size; + uchar_t *regext_data; + struct in_addr addr_temp; + + + /* First byte of the message should be the type */ + switch (*msg) { + case REG_TYPE_REQ: + if (fraglen < sizeof (regreq_t)) + return; + pt = (flags & F_DTAIL ? "registration request ":"reg rqst "); + + (void) memcpy(rreq, msg, sizeof (*rreq)); + regext_size = fraglen - sizeof (regreq_t); + regext_data = msg + sizeof (*rreq); + break; + case REG_TYPE_REP: + if (fraglen < sizeof (regrep_t)) + return; + pt = (flags & F_DTAIL ? "registration reply ":"reg reply "); + + (void) memcpy(rrep, msg, sizeof (*rrep)); + regext_size = fraglen - sizeof (regrep_t); + regext_data = msg + sizeof (*rrep); + + switch (rrep->code) { + case REPLY_CODE_ACK: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL)) ? + "OK" : "OK code 0"; + break; + case REPLY_CODE_ACK_NO_SIMULTANEOUS: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "OK simultaneous bindings" : "OK code 1"; + break; + case REPLY_CODE_FA_NACK_UNSPECIFIED: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: unspecified":"FA denial: code 64"; + break; + case REPLY_CODE_FA_NACK_PROHIBITED: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: prohibited":"FA denial: code 65"; + break; + case REPLY_CODE_FA_NACK_RESOURCES: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: no resources":"FA denial: code 66"; + break; + case REPLY_CODE_FA_NACK_MN_AUTH: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: MN auth failed":"FA denial: code 67"; + break; + case REPLY_CODE_FA_NACK_HA_AUTH: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: HA auth failed": + "FA denial: code 68"; + break; + case REPLY_CODE_FA_NACK_LIFETIME: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: lifetime":"FA denial: code 69"; + break; + case REPLY_CODE_FA_NACK_BAD_REQUEST: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: bad request": "FA: code 70"; + break; + case REPLY_CODE_FA_NACK_BAD_REPLY: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: bad Reply":"FA denial: code 71"; + break; + case REPLY_CODE_FA_NACK_ENCAP_UNAVAILABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: encapsulation":"FA denial: code 72"; + break; + case REPLY_CODE_FA_NACK_VJ_UNAVAILABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: VJ compression":"FA denial: code 73"; + break; + case REPLY_CODE_FA_NACK_BIDIR_TUNNEL_UNAVAILABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: reverse tunnel unavailable": + "FA denial: code 74"; + break; + case REPLY_CODE_FA_NACK_BIDIR_TUNNEL_NO_TBIT: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: reverse tunnel: missing T-bit": + "FA denial: code 75"; + break; + case REPLY_CODE_FA_NACK_BIDIR_TUNNEL_TOO_DISTANT: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: reverse tunnel: too distant": + "FA denial: code 76"; + break; + case REPLY_CODE_FA_NACK_ICMP_HA_NET_UNREACHABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: home network unreachable": + "FA denial: code 80"; + break; + case REPLY_CODE_FA_NACK_ICMP_HA_HOST_UNREACHABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: HA host unreachable": + "FA denial: code 81"; + break; + case REPLY_CODE_FA_NACK_ICMP_HA_PORT_UNREACHABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: HA port unreachable": + "FA denial: code 82"; + break; + case REPLY_CODE_FA_NACK_ICMP_HA_UNREACHABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: HA unreachable":"FA denial: code 88"; + break; + case REPLY_CODE_FA_NACK_UNIQUE_HOMEADDR_REQD: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Unique Home Addr Required": + "FA denial: code 96"; + break; + case REPLY_CODE_FA_NACK_MISSING_NAI: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Missing NAI": + "FA denial: code 97"; + break; + case REPLY_CODE_FA_NACK_MISSING_HOME_AGENT: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Missing Home Agent": + "FA denial: code 98"; + break; + case REPLY_CODE_FA_NACK_UNKNOWN_CHALLENGE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Unknown Challenge": + "FA denial: code 104"; + break; + case REPLY_CODE_FA_NACK_MISSING_CHALLENGE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Missing Challenge": + "FA denial: code 105"; + break; + case REPLY_CODE_FA_NACK_MISSING_MN_FA: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "FA denial: Missing Mobile-Foreign Key Extension": + "FA denial: code 106"; + break; + case REPLY_CODE_HA_NACK_UNSPECIFIED: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: unspecified":"HA denial: code 128"; + break; + case REPLY_CODE_HA_NACK_PROHIBITED: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: prohibited":"HA denial: code 129"; + break; + case REPLY_CODE_HA_NACK_RESOURCES: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: no resources":"HA denial: code 130"; + break; + case REPLY_CODE_HA_NACK_MN_AUTH: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: MN auth failed":"HA denial: code 131"; + break; + case REPLY_CODE_HA_NACK_FA_AUTH: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: FA auth failed":"HA denial: code 132"; + break; + case REPLY_CODE_HA_NACK_ID_MISMATCH: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: ID mismatch":"HA denial: code 133"; + break; + case REPLY_CODE_HA_NACK_BAD_REQUEST: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: bad request":"HA denial: code 134"; + break; + case REPLY_CODE_HA_NACK_TOO_MANY_BINDINGS: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: too many bindings": + "HA denial: code 135"; + break; + case REPLY_CODE_HA_NACK_BAD_HA_ADDRESS: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: bad HA address":"HA denial: code 136"; + break; + case REPLY_CODE_HA_NACK_BIDIR_TUNNEL_UNAVAILABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: no reverse tunnel": + "HA denial: code 137"; + break; + case REPLY_CODE_HA_NACK_BIDIR_TUNNEL_NO_TBIT: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: reverse tunnel: no T-bit": + "HA denial: code 138"; + break; + case REPLY_CODE_HA_NACK_BIDIR_ENCAP_UNAVAILABLE: + pc = ((flags & F_ALLSUM) || (flags & F_DTAIL))? + "HA denial: encapsulation unavailable": + "HA denial: code 139"; + break; + default: + pc = "?"; + break; + } + break; + + default : + break; + } + if (flags & F_SUM) { + line = get_sum_line(); + + if (pc != NULL) + (void) sprintf(line, "Mobile IP %s(%s)", pt, pc); + else + (void) sprintf(line, "Mobile IP %s", pt); + } + + if (flags & F_DTAIL) { + show_header("MIP: ", "Mobile IP Header", fraglen); + show_space(); + + if (*msg == REG_TYPE_REQ) { + (void) sprintf(get_line((char *)&rreq - + dlc_header, 1), "Registration header type = %s", + pt); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + "%d... .... = %s simultaneous bindings ", + (rreq->Simultaneous_registration == 1)? 1 : 0, + (rreq->Simultaneous_registration == 1)? "":"no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + ".%d.. .... = %s broadcast datagrams ", + (rreq->Broadcasts_desired == 1) ? 1 : 0, + (rreq->Broadcasts_desired == 1) ? "":"no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + "..%d. .... = %s decapsulation by MN", + (rreq->Decapsulation_done_locally == 1) ? 1 : 0, + (rreq->Decapsulation_done_locally == 1) ? + "" : "no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + "...%d .... = %s minimum encapsulation ", + (rreq->Minimal_encap_desired == 1) ? 1 : 0, + (rreq->Minimal_encap_desired == 1) ? "" : "no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + ".... %d... = %s GRE encapsulation ", + (rreq->GRE_encap_desired == 1) ? 1 : 0, + (rreq->GRE_encap_desired == 1) ? "" : "no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + ".... .%d.. = %s VJ hdr Compression ", + (rreq->VJ_compression_desired == 1) ? 1 : 0, + (rreq->VJ_compression_desired == 1) ? "" : "no"); + (void) sprintf(get_line( + (char *)(((uchar_t *)&rreq) + 1) - dlc_header, 1), + ".... ..%d. = %s reverse tunnel", + (rreq->BiDirectional_Tunnel_desired == 1) ? 1 : 0, + (rreq->BiDirectional_Tunnel_desired == 1) ? + "" : "no"); + if (ntohs(rreq->lifetime) == 0xffff) { + (void) sprintf(get_line( + (char *)&rreq->lifetime - dlc_header, 1), + "Life Time = 0xFFFF (infinity)"); + } else if (ntohs(rreq->lifetime) == 0) { + (void) sprintf(get_line( + (char *)&rreq->lifetime - dlc_header, 1), + "Life Time = 0 " + "(request for de-registration)"); + } else { + (void) sprintf(get_line( + (char *)&rreq->lifetime - dlc_header, 1), + "Life time = %d seconds", + ntohs(rreq->lifetime)); + } + addr_temp.s_addr = rreq->home_addr; + (void) sprintf(get_line( + (char *)&rreq->home_addr - dlc_header, 1), + "Home address = %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + addr_temp.s_addr = rreq->home_agent_addr; + (void) sprintf(get_line( + (char *)&rreq->home_agent_addr - dlc_header, 1), + "Home Agent address = %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + addr_temp.s_addr = rreq->care_of_addr; + (void) sprintf(get_line( + (char *)&rreq->care_of_addr - dlc_header, 1), + "Care of address = %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + (void) sprintf(get_line( + (char *)&rreq->identification - dlc_header, 1), + "Identification = 0x%x-%x", + ntohl(rreq->identification.high_bits), + ntohl(rreq->identification.low_bits)); + } else if (*msg == REG_TYPE_REP) { + (void) sprintf( + get_line((char *)&rrep->type - dlc_header, 1), + "Registration header type = %d (%s)", + (int)rrep->type, pt); + (void) sprintf(get_line((char *)&rrep - dlc_header, 1), + "Code = %d %s", (int)rrep->code, pc); + if (ntohs(rrep->lifetime) == 0xffff) { + (void) sprintf(get_line( + (char *)&rrep->lifetime - dlc_header, 1), + "Life time = 0xFFFF (infinity)"); + } else if (ntohs(rrep->lifetime) == 0) { + (void) sprintf(get_line( + (char *)&rrep->lifetime - dlc_header, 1), + ((rrep->code == REPLY_CODE_ACK) || + (rrep->code == + REPLY_CODE_ACK_NO_SIMULTANEOUS))? + "Life time = 0 (de-registeration success)" : + "Life time = 0 (de-registration failed)"); + } else { + (void) sprintf(get_line( + (char *)&rrep->lifetime - dlc_header, 1), + "Life time = %d seconds", + ntohs(rrep->lifetime)); + } + addr_temp.s_addr = rrep->home_addr; + (void) sprintf( + get_line((char *)&rrep->home_addr - dlc_header, 1), + "Home address = %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + addr_temp.s_addr = rrep->home_agent_addr; + (void) sprintf(get_line( + (char *)&rrep->home_agent_addr - dlc_header, 1), + "Home Agent address = %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + (void) sprintf(get_line( + (char *)&rrep->identification - dlc_header, 1), + "Identification = 0x%x-%x", + ntohl(rrep->identification.high_bits), + ntohl(rrep->identification.low_bits)); + } + fraglen = interpret_extensions(regext_data, regext_size, REG); + } +} + +/*ARGSUSED*/ +static void spi_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + uint16_t spi_hi, spi_low; + char auth_prn_str[BUFLEN]; + + /* SPI */ + GETSPI(p, spi_hi, spi_low); + (void) sprintf(get_line((char *)p - dlc_header, 1), + "Security Parameter Index = 0x%x%x", + ntohs(spi_hi), ntohs(spi_low)); + p += sizeof (spi_hi) + sizeof (spi_low); + this_ext_len -= sizeof (spi_hi) + sizeof (spi_low); + + /* The rest is the authenticator; dump it in hex */ + dumphex(p, + /* don't write past our string buffer ... */ + (this_ext_len*3 > BUFLEN ? BUFLEN : this_ext_len), + auth_prn_str, + "Authenticator = %s"); +} + +static void key_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + uint16_t alg, spi_hi, spi_low; + char *alg_string; + char *hafa = (type == MN_HA_KEY ? "HA" : "FA"); + char sec_msg[32]; + char auth_prn_str[BUFLEN]; + + /* Algorithm Type */ + (void) memcpy(&alg, p, sizeof (alg)); + alg = ntohs(alg); + switch (alg) { + case KEY_ALG_NONE: + alg_string = "None"; + break; + case SA_MD5_MODE_PREF_SUF: + alg_string = "MD5/prefix+suffix"; + break; + case SA_HMAC_MD5: + alg_string = "HMAC MD5"; + break; + default: + alg_string = "Unknown"; + break; + } + (void) sprintf(get_line((char *)p-dlc_header, 1), + "Algorithm = 0x%x: %s", alg, alg_string); + p += sizeof (alg); + this_ext_len -= sizeof (alg); + + /* AAA SPI */ + GETSPI(p, spi_hi, spi_low); + (void) sprintf(get_line((char *)p - dlc_header, 1), + "AAA Security Parameter Index = 0x%x%x", + ntohs(spi_hi), ntohs(spi_low)); + p += sizeof (spi_hi) + sizeof (spi_low); + this_ext_len -= sizeof (spi_hi) + sizeof (spi_low); + + /* HA / FA SPI */ + GETSPI(p, spi_hi, spi_low); + (void) sprintf(get_line((char *)p - dlc_header, 1), + "%s Security Parameter Index = 0x%x%x", + hafa, ntohs(spi_hi), ntohs(spi_low)); + p += sizeof (spi_hi) + sizeof (spi_low); + this_ext_len -= sizeof (spi_hi) + sizeof (spi_low); + + /* The rest is the security info; dump it in hex */ + sprintf(sec_msg, "%s Security Info = %%s", hafa); + dumphex(p, + /* don't write past our string buffer ... */ + (this_ext_len*3 > BUFLEN ? BUFLEN : this_ext_len), + auth_prn_str, + sec_msg); +} + +/*ARGSUSED*/ +static void trav_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + struct in_addr addr_temp; + + /* skip reserved */ + p += 2; + this_ext_len -= 2; + + /* Mobile-Home Traversal Address */ + (void) memcpy(&(addr_temp.s_addr), p, sizeof (addr_temp.s_addr)); + (void) sprintf(get_line((char *)p-dlc_header, 1), + "Mobile-Home Traversal Address= %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); + p += sizeof (addr_temp.s_addr); + this_ext_len -= sizeof (addr_temp.s_addr); + + /* Home-Mobile Traversal Address */ + (void) memcpy(&(addr_temp.s_addr), p, sizeof (addr_temp.s_addr)); + (void) sprintf(get_line((char *)p-dlc_header, 1), + "Home-Mobile Traversal Address= %s, %s", + inet_ntoa(addr_temp), + addrtoname(AF_INET, &addr_temp)); +} + +/*ARGSUSED*/ +static void empty_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + /* no payload */ +} + +/*ARGSUSED*/ +static void nai_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + /* payload points to the NAI */ + char *desc = "Network Access Identifier = "; + size_t desclen = strlen(desc) + 1 + this_ext_len; + + (void) snprintf(get_line((char *)p-dlc_header, 1), + desclen > MAXLINE ? MAXLINE : desclen, + "%s%s", desc, p); +} + +/*ARGSUSED*/ +static void chall_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + char auth_prn_str[BUFLEN]; + + /* payload points to the challenge */ + dumphex(p, + /* don't write past our string buffer ... */ + (this_ext_len*3 > BUFLEN ? BUFLEN / 3 : this_ext_len), + auth_prn_str, + "Challenge = %s"); +} + +/*ARGSUSED*/ +static void ma_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + mobagtadvext_t adv_ext[1]; + int i, len; + struct in_addr temp_addr; + + (void) memcpy(adv_ext, p - sizeof (exthdr_t), sizeof (*adv_ext)); + (void) sprintf(get_line(0, 0), "Sequence number = %d", + ntohs(adv_ext->sequence_num)); + (void) sprintf(get_line(0, 0), + "Registration lifetime = %d seconds", + ntohs(adv_ext->reg_lifetime)); + if (adv_ext->reg_bit) { + (void) sprintf(get_line(0, 0), + "1... .... = registration required " + "through FA"); + } else { + (void) sprintf(get_line(0, 0), + "0... .... = registration not required " + "through FA"); + } + if (adv_ext->busy_bit) { + (void) sprintf(get_line(0, 0), ".1.. .... = FA busy"); + } else { + (void) sprintf(get_line(0, 0), ".0.. .... = FA not busy"); + } + if (adv_ext->ha_bit) { + (void) sprintf(get_line(0, 0), "..1. .... = node is HA"); + } else { + (void) sprintf(get_line(0, 0), "..0. .... = node not HA"); + } + if (adv_ext->fa_bit) { + (void) sprintf(get_line(0, 0), "...1 .... = node is FA "); + } else { + (void) sprintf(get_line(0, 0), "...0 .... = node not FA "); + } + if (adv_ext->minencap_bit) { + (void) sprintf(get_line(0, 0), ".... 1... = minimal encapsulation " + "supported"); + } else { + (void) sprintf(get_line(0, 0), + ".... 0... = no minimal encapsulation"); + } + if (adv_ext->greencap_bit) { + (void) sprintf(get_line(0, 0), + ".... .1.. = GRE encapsulation supported"); + } else { + (void) sprintf(get_line(0, 0), + ".... .0.. = no GRE encapsulation"); + } + if (adv_ext->vanjacob_hdr_comp_bit) { + (void) sprintf(get_line(0, 0), + ".... ..1. = VJ header compression"); + } else { + (void) sprintf(get_line(0, 0), + ".... ..0. = no VJ header compression"); + } + if (adv_ext->reverse_tunnel_bit) { + (void) sprintf(get_line(0, 0), + ".... ...1 = reverse tunneling supported"); + } else { + (void) sprintf(get_line(0, 0), + ".... ...0 = no reverse tunneling"); + } + (void) sprintf(get_line(0, 0), + "Reserved Byte = 0x%x", adv_ext->reserved); + + /* Parse out COA's */ + p += sizeof (*adv_ext); + len = this_ext_len + sizeof (exthdr_t); + /* this_ext_len is unsigned, and here we need a signed number */ + len -= sizeof (*adv_ext); + + for (i = 0; len >= sizeof (temp_addr.s_addr); i++) { + memcpy(&(temp_addr.s_addr), p - sizeof (exthdr_t), + sizeof (temp_addr.s_addr)); + + (void) sprintf(get_line(0, 0), + "Care of address-%d = %s, %s", i, + inet_ntoa(temp_addr), + addrtoname(AF_INET, &temp_addr)); + + p += sizeof (temp_addr); + len -= sizeof (temp_addr); + } +} + +/*ARGSUSED*/ +static void prefix_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + int i; + + for (i = 0; i < this_ext_len; i++) { + (void) sprintf(get_line(0, 0), + "Prefix length of router address[%d] " + "= %d bits", + i, p[i]); + } +} + +/*ARGSUSED*/ +static void unk_ext(uint8_t type, uint8_t this_ext_len, uchar_t *p) { + char auth_prn_str[BUFLEN]; + + /* Unknown extension; just dump the rest of the payload */ + dumphex(p, + /* don't write past our string buffer ... */ + (this_ext_len*3 > BUFLEN ? BUFLEN : this_ext_len), + auth_prn_str, + "Payload = %s"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.h new file mode 100644 index 0000000..ca40f53 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mip.h @@ -0,0 +1,327 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ifndef _SNOOP_MIP_H +#define _SNOOP_MIP_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ALIGN(ptr) (ptr) + +/* + * E X T E N S I O N S + */ + +typedef struct { + uchar_t type; + uchar_t length; +} exthdr_t; + +/* This header is used for Generalized MIP Authentication Extensions */ +typedef struct { + uint8_t type; + uint8_t subtype; + uint16_t length; +} gen_exthdr_t; + +#define MN_HA_AUTH 32 +#define MN_FA_AUTH 33 +#define FA_HA_AUTH 34 +#define GEN_AUTH 36 +#define MN_HA_KEY 126 +#define MN_HA_TRAVERSE 129 +#define ENCAP_DELIV 130 +#define MN_NAI 131 +#define FA_CHALLENGE 132 +#define MN_FA_KEY 133 + +/* Subtypes for Generalized MIP Authentication Extension (GEN_AUTH) */ +#define GEN_AUTH_MN_AAA 1 + +#define KEY_ALG_NONE 0 +#define SA_MD5_MODE_PREF_SUF 2 /* ...in prefix+suffix */ +#define SA_HMAC_MD5 3 + +/* + * R E G I S T R A T I O N P R O T O C O L + */ + +#define REG_TYPE_REQ 1 +#define REG_TYPE_REP 3 + +typedef struct ident_str { + uint32_t high_bits; /* generated by the HA */ + uint32_t low_bits; /* generated by the MN */ +} ident_t; + +#ifdef __sparc +#ifdef _BIT_FIELDS_HTOL +typedef struct registration_request_str { + uchar_t type; /* must be REG_TYPE_REQ */ + uchar_t + Simultaneous_registration : 1, + Broadcasts_desired : 1, + Decapsulation_done_locally : 1, /* ...by the popup MN */ + Minimal_encap_desired : 1, + GRE_encap_desired : 1, + VJ_compression_desired : 1, + BiDirectional_Tunnel_desired : 1, + reserved : 1; + ushort_t lifetime; /* 0 = dereg; 0xffff = infinity */ + in_addr_t home_addr; /* address of the MN */ + in_addr_t home_agent_addr; /* address of a HA */ + in_addr_t care_of_addr; /* address of decap endpoint */ + ident_t identification; /* for replay protection */ +} regreq_t; +#endif /* _BIT_FIELDS_HTOL */ +#endif /* __sparc */ + +#ifdef __i386 +#ifdef _BIT_FIELDS_LTOH +typedef struct registration_request_str { + uchar_t type; /* must be REG_TYPE_REQ */ + uchar_t + reserved : 1, + BiDirectional_Tunnel_desired : 1, + VJ_compression_desired : 1, + GRE_encap_desired : 1, + Minimal_encap_desired : 1, + Decapsulation_done_locally : 1, /* ...by the popup MN */ + Broadcasts_desired : 1, + Simultaneous_registration : 1; + ushort_t lifetime; /* 0 = dereg; 0xffff = infinity */ + in_addr_t home_addr; /* address of the MN */ + in_addr_t home_agent_addr; /* address of a HA */ + in_addr_t care_of_addr; /* address of decap endpoint */ + ident_t identification; /* for replay protection */ +} regreq_t; +#endif /* _BIT_FIELDS_LTOH */ +#endif /* __i386 */ + +/* + * Registration Reply sent by a home agent to a mobile node in + * response to a registration request. + */ +typedef struct registration_reply_str { + uchar_t type; /* must be REG_TYPE_REP */ + uchar_t code; /* refer to draft document */ + ushort_t lifetime; /* 0 = dereg; 0xffff = infinity */ + in_addr_t home_addr; /* address of the mobile node */ + in_addr_t home_agent_addr; /* address of the home agent */ + ident_t identification; /* derived from request's field */ +} regrep_t; + +/* service ok */ +#define REPLY_CODE_ACK 0 +#define REPLY_CODE_ACK_NO_SIMULTANEOUS 1 + +/* denied by FA */ +#define REPLY_CODE_FA_NACK_UNSPECIFIED 64 +#define REPLY_CODE_FA_NACK_PROHIBITED 65 +#define REPLY_CODE_FA_NACK_RESOURCES 66 +#define REPLY_CODE_FA_NACK_MN_AUTH 67 +#define REPLY_CODE_FA_NACK_HA_AUTH 68 +#define REPLY_CODE_FA_NACK_LIFETIME 69 +#define REPLY_CODE_FA_NACK_BAD_REQUEST 70 +#define REPLY_CODE_FA_NACK_BAD_REPLY 71 +#define REPLY_CODE_FA_NACK_ENCAP_UNAVAILABLE 72 +#define REPLY_CODE_FA_NACK_VJ_UNAVAILABLE 73 +#define REPLY_CODE_FA_NACK_BIDIR_TUNNEL_UNAVAILABLE 74 +#define REPLY_CODE_FA_NACK_BIDIR_TUNNEL_NO_TBIT 75 +#define REPLY_CODE_FA_NACK_BIDIR_TUNNEL_TOO_DISTANT 76 +#define REPLY_CODE_FA_NACK_ICMP_HA_NET_UNREACHABLE 80 +#define REPLY_CODE_FA_NACK_ICMP_HA_HOST_UNREACHABLE 81 +#define REPLY_CODE_FA_NACK_ICMP_HA_PORT_UNREACHABLE 82 +#define REPLY_CODE_FA_NACK_ICMP_HA_UNREACHABLE 88 +#define REPLY_CODE_FA_NACK_UNIQUE_HOMEADDR_REQD 96 +#define REPLY_CODE_FA_NACK_MISSING_NAI 97 +#define REPLY_CODE_FA_NACK_MISSING_HOME_AGENT 98 +#define REPLY_CODE_FA_NACK_MISSING_HOMEADDR 99 +#define REPLY_CODE_FA_NACK_UNKNOWN_CHALLENGE 104 +#define REPLY_CODE_FA_NACK_MISSING_CHALLENGE 105 +#define REPLY_CODE_FA_NACK_MISSING_MN_FA 106 + +/* denied by HA */ +#define REPLY_CODE_HA_NACK_UNSPECIFIED 128 +#define REPLY_CODE_HA_NACK_PROHIBITED 129 +#define REPLY_CODE_HA_NACK_RESOURCES 130 +#define REPLY_CODE_HA_NACK_MN_AUTH 131 +#define REPLY_CODE_HA_NACK_FA_AUTH 132 +#define REPLY_CODE_HA_NACK_ID_MISMATCH 133 +#define REPLY_CODE_HA_NACK_BAD_REQUEST 134 +#define REPLY_CODE_HA_NACK_TOO_MANY_BINDINGS 135 +#define REPLY_CODE_HA_NACK_BAD_HA_ADDRESS 136 +#define REPLY_CODE_HA_NACK_BIDIR_TUNNEL_UNAVAILABLE 137 +#define REPLY_CODE_HA_NACK_BIDIR_TUNNEL_NO_TBIT 138 +#define REPLY_CODE_HA_NACK_BIDIR_ENCAP_UNAVAILABLE 139 + +/* + * OTHER EXTENSIONS + */ + +/* + * The second set consists of those extensions which may appear only + * in ICMP Router Discovery messages [4]. Currently, Mobile IP + * defines the following Types for Extensions appearing in ICMP + * Router Discovery messages: + * + * 0 One-byte PaddingOne-byte Padding (encoded with no Length nor + * Data field) + * 16 Mobility Agent Advertisement + * 19 Prefix-Lengths + */ +#define ICMP_ADV_MSG_PADDING_EXT 0 +#define ICMP_ADV_MSG_MOBILITY_AGT_EXT 16 +#define ICMP_ADV_MSG_PREFIX_LENGTH_EXT 19 +#define ICMP_ADV_MSG_FA_CHALLENGE 24 +#define ICMP_ADV_MSG_FA_NAI 25 + + +/* + * Mobility Agent Advertisement Extension + * The Mobility Agent Adv Extension follows the ICMP Router + * Advertisement fields.It is used to indicate that an ICMP Router + * Advertisement message is also an Agent Advertisement being sent + * by a mobility agent. + * + * Type 16 + * Length (6 + 4*N), where N is the number of care-of addresses + * advertised. + * + * Sequence Number + * The count of Agent Advertisement messages sent since the + * agent was initialized (Section 2.3.2). + * + * Registration Lifetime + * The longest lifetime (measured in seconds) that this + * agent is willing to accept in any Registration Request. + * A value of 0xffff indicates infinity. This field has no + * relation to the "Lifetime" field within the ICMP Router + * Advertisement portion of the Agent Advertisement. + * + * R Registration required. Registration with this foreign + * agent (or another foreign agent on this link) is required + * rather than using a co-located care-of address. + * + * B Busy. The foreign agent will not accept registrations + * from additional mobile nodes. + * + * H Home agent. This agent offers service as a home agent + * on the link on which this Agent Advertisement message is + * sent. + * + * F Foreign agent. This agent offers service as a foreign + * agent on the link on which this Agent Advertisement + * message is sent. + * + * M Minimal encapsulation. This agent implements receiving + * tunneled datagrams that use minimal encapsulation [15]. + * + * G GRE encapsulation. This agent implements receiving + * tunneled datagrams that use GRE encapsulation [8]. + * + * V Van Jacobson header compression. This agent supports use + * of Van Jacobson header compression [10] over the link + * with any registered mobile node. + * + * reserved sent as zero; ignored on reception. + * + * Care-of Address(es) + * The advertised foreign agent care-of address(es) provided + * by this foreign agent. An Agent Advertisement MUST + * include at least one care-of address if the 'F' bit + * is set. The number of care-of addresses present is + * determined by the Length field in the Extension. + * + * A HA must always be prepared to serve the mobile nodes for + * which it is the home agent. A FA may at times be too busy + * to serve additional MNs; even so, it must continue to send + * Agent Advertisements, so that any mobile nodes already registered + * with it will know that they have not moved out of range of the + * foreign agent and that the has not failed. A foreign + * agent may indicate that it is "too busy" to allow new MNs to + * register with it, by setting the 'B' bit in its Agent Adv. + * An Agent Adv message MUST NOT have the 'B' bit set if the + * 'F' bit is not also set, and at least one of the 'F' bit and the + * 'H' bit MUST be set in any Agent Advertisement message sent. + * + * When a FA wishes to require registration even from those + * mobile nodes which have acquired a co-located care-of address, it + * sets the 'R' bit to one. Because this bit applies only to foreign + * agents, an agent MUST NOT set the 'R' bit to one unless the 'F' + * bit is also set to one. + */ +#ifdef __sparc +#ifdef _BIT_FIELDS_HTOL +typedef struct mobility_agt_adv_extension { + uchar_t type; + uchar_t length; + ushort_t sequence_num; + ushort_t reg_lifetime; + ushort_t reg_bit:1, + busy_bit:1, + ha_bit:1, + fa_bit:1, + minencap_bit:1, + greencap_bit:1, + vanjacob_hdr_comp_bit:1, + reverse_tunnel_bit:1, + reserved:8; +} mobagtadvext_t; + +#endif /* _BIT_FIELDS_HTOL */ +#endif /* __sparc */ + +#ifdef __i386 +#ifdef _BIT_FIELDS_LTOH +typedef struct mobility_agt_adv_extension { + uchar_t type; + uchar_t length; + ushort_t sequence_num; + ushort_t reg_lifetime; + uchar_t + reverse_tunnel_bit:1, + vanjacob_hdr_comp_bit:1, + greencap_bit:1, + minencap_bit:1, + fa_bit:1, + ha_bit:1, + busy_bit:1, + reg_bit:1; + uchar_t reserved; +} mobagtadvext_t; +#endif /* _BIT_FIELDS_LTOH */ +#endif /* __i386 */ + +#ifdef __cplusplus +} +#endif + +#endif /* _SNOOP_MIP_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mount.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mount.c new file mode 100644 index 0000000..ce2df1f --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_mount.c @@ -0,0 +1,563 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999-2000 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <sys/tiuser.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <nfs/nfs.h> +#include <rpcsvc/mount.h> +#include <string.h> +#include "snoop.h" +#include "snoop_nfs.h" + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static void mountcall(int, int); +static void mountreply(int, int); + +static void sum_mountstat(char *); +static void sum_mountstat3(char *); +static char *sum_mountfh(void); +static char *sum_mountfh3(void); +static char *sum_exports(void); +static char *sum_mounts(void); + +static int detail_mountstat(void); +static void detail_mountstat3(void); +static void detail_mountfh(void); +static void detail_mountfh3(void); +static void detail_exports(void); +static void detail_mounts(void); + +static char *statusmsg3(ulong_t); + +static char *procnames_short[] = { + "Null", /* 0 */ + "Mount", /* 1 */ + "Get mount list", /* 2 */ + "Unmount", /* 3 */ + "Unmountall", /* 4 */ + "Get export list", /* 5 */ + "Get export list", /* 6 */ + "PATHCONF", /* 7 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Add mount entry", /* 1 */ + "Return mount entries", /* 2 */ + "Remove mount entry", /* 3 */ + "Remove all mount entries", /* 4 */ + "Return export list", /* 5 */ + "Return export list", /* 6 */ + "Get POSIX Pathconf info", /* 7 */ +}; + +#define MAXPROC 7 + +void +interpret_mount(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[MNTPATHLEN + 1]; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "MOUNT%d C %s", + vers, procnames_short[proc]); + line += strlen(line); + switch (proc) { + case MOUNTPROC_MNT: + case MOUNTPROC_UMNT: + (void) sprintf(line, " %s", + getxdr_string(buff, MNTPATHLEN)); + break; + case MOUNTPROC_DUMP: + case MOUNTPROC_UMNTALL: + case MOUNTPROC_EXPORT: + case MOUNTPROC_EXPORTALL: +#ifdef MOUNTPROC_PATHCONF + case MOUNTPROC_PATHCONF: + if (vers != 3) + (void) sprintf(line, " %s", + getxdr_string(buff, + MNTPATHLEN)); +#endif + break; + default: + break; + } + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "MOUNT%d R %s ", + vers, procnames_short[proc]); + line += strlen(line); + switch (proc) { + case MOUNTPROC_MNT: + if (vers == 3) + sum_mountstat3(line); + else + sum_mountstat(line); + break; + case MOUNTPROC_DUMP: + (void) sprintf(line, sum_mounts()); + break; + case MOUNTPROC_UMNT: + case MOUNTPROC_UMNTALL: + (void) sprintf(line, "reply"); + break; + case MOUNTPROC_EXPORTALL: + /* + * EXPORTALL is the same as EXPORT in v1 + * and v2, and it doesn't exist in v3. + */ + if (vers == 3) + break; + /*FALLTHROUGH*/ + case MOUNTPROC_EXPORT: + (void) sprintf(line, sum_exports()); + break; +#ifdef MOUNTPROC_PATHCONF + case MOUNTPROC_PATHCONF: + if (vers != 2) + break; +#ifdef notyet + (void) sprintf(line, sum_ppathcnf()); +#endif + break; +#endif + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("MOUNT:", "NFS MOUNT", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long[proc]); + if (type == CALL) + mountcall(proc, vers); + else + mountreply(proc, vers); + show_trailer(); + } +} + +/* + * Interpret call packets in detail + */ + +static void +mountcall(proc, vers) + int proc, vers; +{ + + switch (proc) { + case MOUNTPROC_MNT: + case MOUNTPROC_UMNT: + (void) showxdr_string(MNTPATHLEN, "Directory = %s"); + break; + case MOUNTPROC_DUMP: + break; + case MOUNTPROC_UMNTALL: + break; + case MOUNTPROC_EXPORTALL: + if (vers == 3) + break; + break; + case MOUNTPROC_EXPORT: + break; +#ifdef MOUNTPROC_PATHCONF + case MOUNTPROC_PATHCONF: + if (vers != 2) + break; + (void) showxdr_string(MNTPATHLEN, "File = %s"); +#endif + break; + default: + break; + } +} + +/* + * Interpret reply packets in detail + */ + +static void +mountreply(proc, vers) + int proc, vers; +{ + + switch (proc) { + case MOUNTPROC_MNT: + if (vers == 3) { + detail_mountstat3(); + } else { + if (detail_mountstat() == 0) { + detail_mountfh(); + } + } + break; + case MOUNTPROC_DUMP: + detail_mounts(); + break; + case MOUNTPROC_UMNT: + case MOUNTPROC_UMNTALL: + (void) detail_mountstat(); + break; + case MOUNTPROC_EXPORTALL: + if (vers == 3) + break; + /*FALLTHROUGH*/ + case MOUNTPROC_EXPORT: + detail_exports(); + break; +#ifdef MOUNTPROC_PATHCONF + case MOUNTPROC_PATHCONF: +#ifdef notyet + (void) detail_ppathcnf(); +#endif + break; +#endif + default: + break; + } +} + +static void +sum_mountstat(line) + char *line; +{ + ulong_t status; + char *str; + + status = getxdr_u_long(); + if (status == 0) + str = "OK"; + else if ((str = strerror(status)) == (char *)NULL) + str = ""; + (void) strcpy(line, str); + if (status == 0) { + (void) strcat(line, sum_mountfh()); + } +} + +static int +detail_mountstat() +{ + ulong_t status; + char *str; + + status = getxdr_u_long(); + if (status == 0) + str = "OK"; + else if ((str = strerror(status)) == (char *)NULL) + str = ""; + + (void) sprintf(get_line(0, 0), "Status = %d (%s)", status, str); + + return ((int)status); +} + +char * +sum_mountfh() +{ + int fh; + static char buff[8]; + + fh = sum_filehandle(NFS_FHSIZE); + (void) sprintf(buff, " FH=%04X", fh & 0xFFFF); + return (buff); +} + +static void +detail_mountfh() +{ + int pos; + int fh; + + pos = getxdr_pos(); + fh = sum_filehandle(NFS_FHSIZE); + setxdr_pos(pos); + (void) sprintf(get_line(0, 0), "File handle = [%04X]", fh & 0xFFFF); + (void) showxdr_hex(NFS_FHSIZE, " %s"); +} + +static char * +print_auth() +{ + int i, auth, flavors; + char *p; + static char buff[64]; + + buff[0] = '\0'; + flavors = getxdr_long(); + for (i = 0; i < flavors; i++) { + if (i > 0) + (void) strlcat(buff, ",", sizeof (buff)); + switch (auth = getxdr_u_long()) { + case AUTH_NONE: + (void) strlcat(buff, "none", sizeof (buff)); + break; + case AUTH_UNIX: + (void) strlcat(buff, "unix", sizeof (buff)); + break; + case AUTH_SHORT: + (void) strlcat(buff, "short", sizeof (buff)); + break; + case AUTH_DES: + (void) strlcat(buff, "des", sizeof (buff)); + break; + default: + p = buff + strlen(buff); + if (p < &buff[sizeof (buff)]) + (void) snprintf(p, sizeof (buff) - strlen(buff), + "%d", auth); + break; + } + } + return (buff); +} + +static void +sum_mountstat3(line) + char *line; +{ + ulong_t status; + + status = getxdr_u_long(); + (void) strcpy(line, statusmsg3(status)); + if (status == 0) { + (void) strcat(line, sum_mountfh3()); + (void) strcat(line, " Auth="); + (void) strcat(line, print_auth()); + } +} + +static void +detail_mountstat3() +{ + ulong_t status; + + status = getxdr_u_long(); + (void) sprintf(get_line(0, 0), "Status = %d (%s)", status, + statusmsg3(status)); + if (status == 0) { + detail_mountfh3(); + (void) sprintf(get_line(0, 0), "Authentication flavor = %s", + print_auth()); + } +} + +char * +sum_mountfh3() +{ + int len; + int fh; + static char buff[8]; + + len = getxdr_long(); + fh = sum_filehandle(len); + (void) sprintf(buff, " FH=%04X", fh & 0xFFFF); + return (buff); +} + +static void +detail_mountfh3() +{ + int pos; + int i, l, len; + int fh; + + len = getxdr_long(); + pos = getxdr_pos(); + fh = sum_filehandle(len); + setxdr_pos(pos); + (void) sprintf(get_line(0, 0), "File handle = [%04X]", fh & 0xFFFF); + i = 0; + while (i < len) { + l = MIN(len - i, 32); + (void) showxdr_hex(l, " %s"); + i += l; + } +} + +static char * +sum_exports() +{ + static char buff[MNTPATHLEN + 1]; + int entries = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ entries", entries); + return (buff); + } + + while (getxdr_long()) { + (void) getxdr_string(buff, MNTPATHLEN); + while (getxdr_long()) { + (void) getxdr_string(buff, MNTNAMLEN); + } + entries++; + } + + (void) sprintf(buff, "%d entries", entries); + return (buff); +} + +static void +detail_exports() +{ + int entries = 0; + char *dirpath, *grpname; + char buff[MNTPATHLEN + 1]; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ entries. (Frame is incomplete)", + entries); + return; + } + + while (getxdr_long()) { + dirpath = (char *)getxdr_string(buff, MNTPATHLEN); + (void) sprintf(get_line(0, 0), "Directory = %s", dirpath); + entries++; + while (getxdr_long()) { + grpname = (char *)getxdr_string(buff, MNTNAMLEN); + (void) sprintf(get_line(0, 0), " Group = %s", grpname); + } + } +} + +static char * +sum_mounts() +{ + int entries = 0; + static char buff[MNTPATHLEN + 1]; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ entries", entries); + return (buff); + } + + while (getxdr_long()) { + (void) getxdr_string(buff, MNTNAMLEN); + (void) getxdr_string(buff, MNTPATHLEN); + entries++; + } + + (void) sprintf(buff, "%d entries", entries); + return (buff); +} + +static void +detail_mounts() +{ + int entries = 0; + char *hostname, *directory; + char buff1[MNTNAMLEN + 1], buff2[MNTPATHLEN + 1]; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ entries. (Frame is incomplete)", + entries); + return; + } + + (void) sprintf(get_line(0, 0), "Mount list"); + + while (getxdr_long()) { + hostname = (char *)getxdr_string(buff1, MNTNAMLEN); + directory = (char *)getxdr_string(buff2, MNTPATHLEN); + (void) sprintf(get_line(0, 0), " %s:%s", hostname, directory); + entries++; + } +} + +char * +statusmsg3(status) + ulong_t status; +{ + + switch (status) { + case MNT_OK: + return ("OK"); + case MNT3ERR_PERM: + return ("Not owner"); + case MNT3ERR_NOENT: + return ("No such file or directory"); + case MNT3ERR_IO: + return ("I/O error"); + case MNT3ERR_ACCES: + return ("Permission denied"); + case MNT3ERR_NOTDIR: + return ("Not a directory"); + case MNT3ERR_INVAL: + return ("Invalid argument"); + case MNT3ERR_NAMETOOLONG: + return ("File name too long"); + case MNT3ERR_NOTSUPP: + return ("Operation not supported"); + case MNT3ERR_SERVERFAULT: + return ("Server error"); + default: + return ("(unknown error)"); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nbp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nbp.c new file mode 100644 index 0000000..fbdaa94 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nbp.c @@ -0,0 +1,145 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +static void show_nbp_tuples(uint8_t *, int, uint8_t *); + +static char *nbp_short[] = { + "0", /* 0 */ + "BRRQ ", /* 1 */ + "LKUP C ", /* 2 */ + "LKUP R ", /* 3 */ + "FWD ", /* 4 */ + "5 ", + "6 ", + "7 ", + "8 ", + "9 ", + "10 ", + "11 ", + "RGSTR ", /* 12 */ + "UNRGSTR", /* 13 */ + "OK ", /* 14 */ + "ERROR ", /* 15 */ +}; + +void +interpret_nbp(int flags, struct nbp_hdr *nbp, int len) +{ + uint8_t *data; + int nbp_cnt = nbp->nbp_fun_cnt & 0xf; /* lower four bits */ + int nbp_op = (nbp->nbp_fun_cnt >> 4) & 0xf; /* upper four bits */ + + data = (uint8_t *)(nbp + 1); + + if (flags & F_SUM) { + if (len < sizeof (struct nbp_hdr)) { + (void) snprintf(get_sum_line(), MAXLINE, + "NBP (short packet)"); + return; + } + (void) snprintf(get_sum_line(), MAXLINE, + "NBP F=%s CNT=%d ID=%d", nbp_short[nbp_op], + nbp_cnt, nbp->nbp_id); + } + + if (flags & F_DTAIL) { + show_header("NBP: ", "NBP Header", len); + show_space(); + + if (len < sizeof (struct nbp_hdr)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "NBP (short packet)"); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length = %d", len); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Func = %d (%s)", nbp_op, nbp_short[nbp_op]); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Tuple count = %d", nbp_cnt); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Id = %d", nbp->nbp_id); + show_nbp_tuples(data, nbp_cnt, ((uint8_t *)nbp) + len); + } +} + +static void +show_nbp_tuples(uint8_t *p, int tuples, uint8_t *tail) +{ + uint16_t net; + uint8_t node; + uint8_t sock; + uint8_t enumer; + char obj[100]; + char *op; + char *otail = &obj[sizeof (obj)]; + + while (tuples--) { + op = obj; + if ((p + 5) > tail) + goto out; + net = get_short(p); + p += 2; + node = *p++; + sock = *p++; + enumer = *p++; + + if (p > tail || &p[1]+p[0] > tail) + goto out; + op += snprintf(op, otail-op, "%.*s", p[0], &p[1]); + + p = &p[1]+p[0]; + if (p > tail || &p[1]+p[0] > tail) + goto out; + op += snprintf(op, otail-op, ":%.*s", p[0], &p[1]); + + p = &p[1]+p[0]; + if (p > tail || &p[1]+p[0] > tail) + goto out; + (void) snprintf(op, otail-op, "@%.*s", p[0], &p[1]); + p = &p[1]+p[0]; + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Name = \"%s\"", obj); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Net = %d, node = %d, sock = %d, enum = %d", + net, node, sock, enumer); + } + return; +out: + (void) snprintf(get_line(0, 0), get_line_remain(), + "NBP (short tuple)"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_netbios.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_netbios.c new file mode 100644 index 0000000..2e8f8a9 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_netbios.c @@ -0,0 +1,555 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2008 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * References used throughout this code: + * + * [RFC1001] : PROTOCOL STANDARD FOR A NetBIOS SERVICE + * ON A TCP/UDP TRANSPORT: + * CONCEPTS AND METHODS + * NetBIOS Working Group, March 1987 + * + * [RFC1002] : PROTOCOL STANDARD FOR A NetBIOS SERVICE + * ON A TCP/UDP TRANSPORT: + * DETAILED SPECIFICATIONS + * NetBIOS Working Group, March 1987 + */ + +#include <fcntl.h> +#include "snoop.h" +#include <stdio.h> +#include <ctype.h> +#include "snoop.h" + +extern char *dlc_header; +char *show_type(); + +/* See snoop_smb.c */ +extern void interpret_smb(int flags, uchar_t *data, int len); + +/* + * NBT Session Packet Header + * [RFC 1002, Sec. 4.3.1] + */ +struct nbt_ss { + uchar_t type; + uchar_t flags; + ushort_t length; +}; + +/* + * NBT Session Request Packet trailer + * [RFC 1002, Sec. 4.3.2] + */ +struct callnames { + uchar_t space; /* padding */ + uchar_t calledname[32]; + uchar_t nullchar; /* padding */ + uchar_t space2; /* padding */ + uchar_t callingname[32]; + uchar_t nullchar2; /* padding */ +}; + + +static void interpret_netbios_names(int flags, uchar_t *data, int len, + char *xtra); +static void netbiosname2ascii(char *asciiname, uchar_t *netbiosname); + +/* + * Helpers to read network-order values, + * with NO alignment assumed. + */ +static ushort_t +getshort(uchar_t *p) { + return (p[1] + (p[0]<<8)); +} +static uint_t +getlong(uchar_t *p) +{ + return (p[3] + (p[2]<<8) + (p[1]<<16) + (p[0]<<24)); +} + +/* + * NM_FLAGS fields in the NetBIOS Name Service Packet header. + * [RFC 1002, Sec. 4.2.1.1] + */ +static void +print_flag_details(int headerflags) +{ + if (headerflags & 1<<4) + sprintf(get_line(0, 0), " - Broadcast"); + if (headerflags & 1<<7) + sprintf(get_line(0, 0), " - Recursion Available"); + if (headerflags & 1<<8) + sprintf(get_line(0, 0), " - Recursion Desired"); + if (headerflags & 1<<9) + sprintf(get_line(0, 0), " - Truncation Flag"); + if (headerflags & 1<<10) + sprintf(get_line(0, 0), " - Authoritative Answer"); +} + +/* + * Possible errors in NetBIOS name service packets. + * [RFC 1002, Sec. 4.2.6, 4.2.11, 4.2.14] + */ +static void +getrcodeerr(int headerflags, char *errortype) +{ + int error = (headerflags & 0xf); + + switch (error) { + case 0: + sprintf(errortype, "Success"); + break; + case 1: + sprintf(errortype, "Format Error"); + break; + case 2: + sprintf(errortype, "Server Failure"); + break; + case 3: + sprintf(errortype, "Name Error"); + break; + case 4: + sprintf(errortype, "Unsupported Request Error"); + break; + case 5: + sprintf(errortype, "Refused Error"); + break; + case 6: + sprintf(errortype, "Active Error"); + break; + case 7: + sprintf(errortype, "Name in Conflict Error"); + break; + default: + sprintf(errortype, "Unknown Error"); + break; + } +} + +/* + * OPCODE fields in the NetBIOS Name Service Packet header. + * [RFC 1002, Sec. 4.2.1.1] + */ +static void +print_ns_type(int flags, int headerflags, char *xtra) +{ + int opcode = (headerflags & 0x7800)>>11; + int response = (headerflags & 1<<15); + char *resptype = response ? "Response" : "Request"; + char *optype; + + switch (opcode) { + case 0: + optype = "Query"; + break; + case 5: + optype = "Registration"; + break; + case 6: + optype = "Release"; + break; + case 7: + optype = "WACK"; + break; + case 8: + optype = "Refresh"; + break; + default: + optype = "Unknown"; + break; + } + + if (flags & F_DTAIL) + sprintf(get_line(0, 0), "Type = %s %s", optype, resptype); + else + sprintf(xtra, "%s %s", optype, resptype); +} + + +/* + * Interpret Datagram Packets + * [RFC 1002, Sec. 4.4] + */ +void +interpret_netbios_datagram(int flags, uchar_t *data, int len) +{ + char name[24]; + int packettype = data[0]; + int packetlen; + data++; + + if (packettype < 0x10 || packettype > 0x11) + return; + + if (flags & F_SUM) { + data += 14; + netbiosname2ascii(name, data); + sprintf(get_sum_line(), + "NBT Datagram Service Type=%d Source=%s", + packettype, name); + } + + if (flags & F_DTAIL) { + show_header("NBT: ", "Netbios Datagram Service Header", len); + show_space(); + sprintf(get_line(0, 0), "Datagram Packet Type = 0x%.2x", + packettype); + sprintf(get_line(0, 0), "Datagram Flags = 0x%.2x", + data[0]); + data++; + sprintf(get_line(0, 0), "Datagram ID = 0x%.4x", + getshort(data)); + data += 2; + sprintf(get_line(0, 0), "Source IP = %d.%d.%d.%d", + data[0], data[1], data[2], data[3]); + data += 4; + sprintf(get_line(0, 0), "Source Port = %d", + getshort(data)); + data += 2; + packetlen = getshort(data); + sprintf(get_line(0, 0), "Datagram Length = 0x%.4x", + packetlen); + data += 2; + sprintf(get_line(0, 0), "Packet Offset = 0x%.4x", + getshort(data)); + data += 3; + netbiosname2ascii(name, data); + sprintf(get_line(0, 0), "Source Name = %s", name); + data += 34; + netbiosname2ascii(name, data); + sprintf(get_line(0, 0), "Destination Name = %s", name); + sprintf(get_line(0, 0), "Number of data bytes remaining = %d", + packetlen - 68); + show_trailer(); + } +} + +/* + * Interpret NetBIOS Name Service packets. + * [RFC 1002, Sec. 4.2] + */ +void +interpret_netbios_ns(int flags, uchar_t *data, int len) +{ + int headerflags, qcount, acount, nscount, arcount; + int transid; + char name[24]; + char extra[256]; + char errortype[50]; + int rdatalen; + int rrflags; + int nameptr; + int nodecode; + char *nodetype; + uchar_t *data0 = data; + + transid = getshort(data); data += 2; + headerflags = getshort(data); data += 2; + qcount = getshort(data); data += 2; + acount = getshort(data); data += 2; + nscount = getshort(data); data += 2; + arcount = getshort(data); data += 2; + getrcodeerr(headerflags, errortype); + + if (flags & F_SUM) { + print_ns_type(flags, headerflags, extra); + data++; + netbiosname2ascii(name, data); + sprintf(get_sum_line(), "NBT NS %s for %s, %s", + extra, name, errortype); + + } + + + if (flags & F_DTAIL) { + show_header("NBT: ", "Netbios Name Service Header", len); + show_space(); + print_ns_type(flags, headerflags, 0); + sprintf(get_line(0, 0), "Status = %s", errortype); + sprintf(get_line(0, 0), "Transaction ID = 0x%.4x", transid); + sprintf(get_line(0, 0), "Flags Summary = 0x%.4x", + headerflags); + print_flag_details(headerflags); + sprintf(get_line(0, 0), "Question count = %d", qcount); + sprintf(get_line(0, 0), "Answer Count = %d", acount); + sprintf(get_line(0, 0), "Name Service Count = %d", nscount); + sprintf(get_line(0, 0), + "Additional Record Count = %d", arcount); + + /* + * Question Section Packet Description from + * [RFC 1002, Sec. 4.2.1.2] + */ + + if (qcount) { + data++; + netbiosname2ascii(name, data); + sprintf(get_line(0, 0), "Question Name = %s", name); + data += 33; + sprintf(get_line(0, 0), "Question Type = 0x%.4x", + getshort(data)); + data += 2; + sprintf(get_line(0, 0), "Question Class = 0x%.4x", + getshort(data)); + data += 2; + } + + /* + * Resrouce Record Packet Description from + * [RFC 1002, Sec. 4.2.1.3] + */ + + if ((acount || nscount || arcount) || + (qcount+acount+nscount+arcount == 0)) { + /* Second level encoding from RFC883 (p.31, 32) */ + if (data[0] & 0xc0) { + nameptr = getshort(data)&0x3fff; + netbiosname2ascii(name, (data0+nameptr+1)); + sprintf(get_line(0, 0), + "Resource Record Name = %s", name); + data += 2; + } else { + data++; + netbiosname2ascii(name, data); + sprintf(get_line(0, 0), + "Resource Record Name = %s", name); + data += 33; + } + sprintf(get_line(0, 0), + "Resource Record Type = 0x%.4x", + getshort(data)); + data += 2; + sprintf(get_line(0, 0), + "Resource Record Class = 0x%.4x", + getshort(data)); + data += 2; + sprintf(get_line(0, 0), + "Time to Live (Milliseconds) = %d", + getlong(data)); + data += 4; + rdatalen = getshort(data); + sprintf(get_line(0, 0), "RDATA Length = 0x%.4x", + rdatalen); + data += 2; + /* 15.4.2.1.3 */ + if (rdatalen == 6) { + rrflags = getshort(data); + data += 2; + sprintf(get_line(0, 0), + "Resource Record Flags = 0x%.4x", + rrflags); + nodecode = (rrflags>>13)& 0x11; + if (nodecode == 0) nodetype = "B"; + if (nodecode == 1) nodetype = "P"; + if (nodecode == 2) nodetype = "M"; + sprintf(get_line(0, 0), " - %s, %s node", + (rrflags & 1<<15) ? + "Group NetBIOS Name": + "Unique NetBIOS Name", nodetype); + sprintf(get_line(0, 0), + "Owner IP Address = %d.%d.%d.%d", + data[0], data[1], data[2], data[3]); + } + } + show_trailer(); + + } +} + +/* + * Interpret NetBIOS session packets. + * [RFC 1002, Sec. 4.3] + */ +void +interpret_netbios_ses(int flags, uchar_t *data, int len) +{ + struct nbt_ss *ss; + uchar_t *trailer; + int length = len - 4; /* NBT packet length without header */ + char *type; + char extrainfo[300]; + + if (len < sizeof (struct nbt_ss)) + return; + + /* + * Packets that are fragments of a large NetBIOS session + * message will have no NetBIOS header. (Only the first + * TCP segment will have a NetBIOS header.) It turns out + * that very often, such fragments start with SMB data, so + * we should try to recognize and decode them. + */ + if (data[0] == 0xff && + data[1] == 'S' && + data[2] == 'M' && + data[3] == 'B') { + interpret_smb(flags, data, len); + return; + } + + /* LINTED PTRALIGN */ + ss = (struct nbt_ss *)data; + trailer = data + sizeof (*ss); + extrainfo[0] = '\0'; + + if (flags & F_SUM) { + switch (ss->type) { + case 0x00: + type = "SESSION MESSAGE"; + break; + case 0x81: + type = "SESSION REQUEST"; + interpret_netbios_names(flags, trailer, + length, extrainfo); + break; + case 0x82: + type = "POSITIVE SESSION RESPONSE"; + break; + case 0x83: + type = "NEGATIVE SESSION RESPONSE"; + break; + case 0x84: + type = "RETARGET SESSION RESPONSE"; + break; + case 0x85: + type = "SESSION KEEP ALIVE"; + break; + default: + type = "Unknown"; + break; + } + (void) sprintf(get_sum_line(), + "NBT Type=%s %sLength=%d", type, extrainfo, length); + } + + if (flags & F_DTAIL) { + show_header("NBT: ", "NBT Header", len); + show_space(); + + switch (ss->type) { + case 0x00: + (void) sprintf(get_line(0, 0), + "Type = SESSION MESSAGE"); + break; + case 0x81: + (void) sprintf(get_line(0, 0), + "Type = SESSION REQUEST"); + interpret_netbios_names(flags, trailer, length, 0); + break; + case 0x82: + (void) sprintf(get_line(0, 0), + "Type = POSITIVE SESSION RESPONSE"); + break; + case 0x83: + (void) sprintf(get_line(0, 0), + "Type = NEGATIVE SESSION RESPONSE"); + break; + case 0x84: + (void) sprintf(get_line(0, 0), + "Type = RETARGET SESSION RESPONSE"); + break; + case 0x85: + (void) sprintf(get_line(0, 0), + "Type = SESSION KEEP ALIVE"); + break; + default: + (void) sprintf(get_line(0, 0), + "Type = Unknown"); + break; + } + + (void) sprintf(get_line(0, 0), "Length = %d bytes", length); + show_trailer(); + } + + /* + * SMB packets have { 0xff, 'S', 'M', 'B' } + * in the first four bytes. If we find that, + * let snoop_smb.c have a look at it. + */ + if (ss->type == 0x00 && + length > 0 && + trailer[0] == 0xff && + trailer[1] == 'S' && + trailer[2] == 'M' && + trailer[3] == 'B') + interpret_smb(flags, trailer, length); +} + +/* + * NetBIOS name encoding (First Level Encoding) + * [RFC 1001, Sec. 4.1] + */ +static void +netbiosname2ascii(char *aname, uchar_t *nbname) +{ + int c, i, j; + + i = j = 0; + for (;;) { + c = nbname[i++] - 'A'; + c = (c << 4) + + nbname[i++] - 'A'; + /* 16th char is the "type" */ + if (i >= 32) + break; + if (iscntrl(c)) + c = '.'; + if (c != ' ') + aname[j++] = c; + } + sprintf(&aname[j], "[%x]", c); +} + +/* + * Interpret the names in a Session Request packet. + * [RFC 1002, Sec. 4.3.2] + */ +static void +interpret_netbios_names(int flags, uchar_t *data, int len, char *xtra) +{ + char calledname[24]; + char callingname[24]; + struct callnames *names = (struct callnames *)data; + + if (len < sizeof (*names)) + return; + + netbiosname2ascii(calledname, names->calledname); + netbiosname2ascii(callingname, names->callingname); + + if (flags & F_SUM) { + sprintf(xtra, "Dest=%s Source=%s ", calledname, callingname); + } + + if (flags & F_DTAIL) { + sprintf(get_line(0, 0), "Destination = %s", calledname); + sprintf(get_line(0, 0), "Source = %s", callingname); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.c new file mode 100644 index 0000000..6f52c35 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.c @@ -0,0 +1,691 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 1991-2003 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <setjmp.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <string.h> +#include "snoop.h" +#include "snoop_nfs.h" + +#include <sys/stat.h> +#include <rpcsvc/nfs_prot.h> + +static char *perms(int); +static char *filetype(int); +static char *sum_readdirres(void); +static void detail_readdirres(void); +static void detail_diroparg(void); +static void nfscall2(int); +static void nfsreply2(int); +static void detail_mode(int); +static void detail_sattr(void); +static void interpret_nfs2(int, int, int, int, int, char *, int); + +extern jmp_buf xdr_err; + +static char *procnames_short[] = { + "NULL2", /* 0 */ + "GETATTR2", /* 1 */ + "SETATTR2", /* 2 */ + "ROOT2", /* 3 */ + "LOOKUP2", /* 4 */ + "READLINK2", /* 5 */ + "READ2", /* 6 */ + "WRITECACHE2", /* 7 */ + "WRITE2", /* 8 */ + "CREATE2", /* 9 */ + "REMOVE2", /* 10 */ + "RENAME2", /* 11 */ + "LINK2", /* 12 */ + "SYMLINK2", /* 13 */ + "MKDIR2", /* 14 */ + "RMDIR2", /* 15 */ + "READDIR2", /* 16 */ + "STATFS2", /* 17 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Get file attributes", /* 1 */ + "Set file attributes", /* 2 */ + "Get root filehandle", /* 3 */ + "Look up file name", /* 4 */ + "Read from symbolic link", /* 5 */ + "Read from file", /* 6 */ + "Write to cache", /* 7 */ + "Write to file", /* 8 */ + "Create file", /* 9 */ + "Remove file", /* 10 */ + "Rename", /* 11 */ + "Link", /* 12 */ + "Make symbolic link", /* 13 */ + "Make directory", /* 14 */ + "Remove directory", /* 15 */ + "Read from directory", /* 16 */ + "Get filesystem attributes", /* 17 */ +}; + +#define MAXPROC 17 + +/* ARGSUSED */ +void +interpret_nfs(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + + if (vers == 2) { + interpret_nfs2(flags, type, xid, vers, proc, data, len); + return; + } + + if (vers == 3) { + interpret_nfs3(flags, type, xid, vers, proc, data, len); + return; + } + + if (vers == 4) { + interpret_nfs4(flags, type, xid, vers, proc, data, len); + return; + } +} + +static void +interpret_nfs2(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[NFS_MAXPATHLEN + 1]; + int off, sz; + char *fh; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "NFS C %s", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case NFSPROC_GETATTR: + case NFSPROC_READLINK: + case NFSPROC_STATFS: + case NFSPROC_SETATTR: + (void) sprintf(line, sum_nfsfh()); + break; + case NFSPROC_LOOKUP: + case NFSPROC_REMOVE: + case NFSPROC_RMDIR: + case NFSPROC_CREATE: + case NFSPROC_MKDIR: + fh = sum_nfsfh(); + (void) sprintf(line, "%s %s", + fh, + getxdr_string(buff, NFS_MAXNAMLEN)); + break; + case NFSPROC_WRITE: + fh = sum_nfsfh(); + (void) getxdr_long(); /* beginoff */ + off = getxdr_long(); + (void) getxdr_long(); /* totalcount */ + sz = getxdr_long(); + (void) sprintf(line, "%s at %d for %d", + fh, off, sz); + break; + case NFSPROC_RENAME: + fh = sum_nfsfh(); + (void) sprintf(line, "%s %s", + fh, + getxdr_string(buff, NFS_MAXNAMLEN)); + line += strlen(line); + fh = sum_nfsfh(); + (void) sprintf(line, " to%s %s", + fh, + getxdr_string(buff, NFS_MAXNAMLEN)); + break; + case NFSPROC_LINK: + fh = sum_nfsfh(); + (void) sprintf(line, "%s", fh); + line += strlen(line); + fh = sum_nfsfh(); + (void) sprintf(line, " to%s %s", + fh, + getxdr_string(buff, NFS_MAXNAMLEN)); + break; + case NFSPROC_SYMLINK: + fh = sum_nfsfh(); + (void) sprintf(line, "%s %s", + fh, + getxdr_string(buff, NFS_MAXNAMLEN)); + line += strlen(line); + (void) sprintf(line, " to %s", + getxdr_string(buff, NFS_MAXPATHLEN)); + break; + case NFSPROC_READDIR: + fh = sum_nfsfh(); + (void) sprintf(line, "%s Cookie=%lu", + fh, getxdr_u_long()); + break; + case NFSPROC_READ: + fh = sum_nfsfh(); + off = getxdr_long(); + sz = getxdr_long(); + (void) sprintf(line, "%s at %d for %d", + fh, off, sz); + break; + default: + break; + } + + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NFS R %s ", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case NFSPROC_CREATE: + case NFSPROC_MKDIR: + case NFSPROC_LOOKUP: + if (sum_nfsstat(line) == 0) { + line += strlen(line); + (void) sprintf(line, sum_nfsfh()); + } + break; + case NFSPROC_READLINK: + if (sum_nfsstat(line) == 0) { + line += strlen(line); + (void) sprintf(line, " (Path=%s)", + getxdr_string(buff, + NFS_MAXPATHLEN)); + } + break; + case NFSPROC_GETATTR: + case NFSPROC_SYMLINK: + case NFSPROC_STATFS: + case NFSPROC_SETATTR: + case NFSPROC_REMOVE: + case NFSPROC_RMDIR: + case NFSPROC_WRITE: + case NFSPROC_RENAME: + case NFSPROC_LINK: + (void) sum_nfsstat(line); + break; + case NFSPROC_READDIR: + if (sum_nfsstat(line) == 0) { + line += strlen(line); + (void) strcat(line, sum_readdirres()); + } + break; + case NFSPROC_READ: + if (sum_nfsstat(line) == 0) { + line += strlen(line); + xdr_skip(68); /* fattrs */ + (void) sprintf(line, " (%ld bytes)", + getxdr_long()); + } + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NFS: ", "Sun NFS", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long[proc]); + if (type == CALL) + nfscall2(proc); + else + nfsreply2(proc); + show_trailer(); + } +} + +/* + * Print out version 2 NFS call packets + */ +static void +nfscall2(proc) + int proc; +{ + switch (proc) { + case NFSPROC_GETATTR: + case NFSPROC_READLINK: + case NFSPROC_STATFS: + detail_nfsfh(); + break; + case NFSPROC_SETATTR: + detail_nfsfh(); + detail_sattr(); + break; + case NFSPROC_LOOKUP: + case NFSPROC_REMOVE: + case NFSPROC_RMDIR: + detail_diroparg(); + break; + case NFSPROC_MKDIR: + case NFSPROC_CREATE: + detail_diroparg(); + detail_sattr(); + break; + case NFSPROC_WRITE: + detail_nfsfh(); + (void) getxdr_long(); /* begoff */ + (void) showxdr_long("Offset = %d"); + (void) getxdr_long(); /* totalcount */ + (void) showxdr_long("(%d bytes(s) of data)"); + break; + case NFSPROC_RENAME: + detail_diroparg(); + detail_diroparg(); + break; + case NFSPROC_LINK: + detail_nfsfh(); + detail_diroparg(); + break; + case NFSPROC_SYMLINK: + detail_diroparg(); + (void) showxdr_string(NFS_MAXPATHLEN, "Path = %s"); + detail_sattr(); + break; + case NFSPROC_READDIR: + detail_nfsfh(); + (void) showxdr_u_long("Cookie = %lu"); + (void) showxdr_long("Count = %d"); + break; + case NFSPROC_READ: + detail_nfsfh(); + (void) showxdr_long("Offset = %d"); + (void) showxdr_long("Count = %d"); + break; + default: + break; + } +} + +/* + * Print out version 2 NFS reply packets + */ +static void +nfsreply2(proc) + int proc; +{ + switch (proc) { + case NFSPROC_GETATTR: + case NFSPROC_SETATTR: + case NFSPROC_WRITE: + /* attrstat */ + if (detail_nfsstat() == 0) { + detail_fattr(); + } + break; + case NFSPROC_LOOKUP: + case NFSPROC_CREATE: + case NFSPROC_MKDIR: + /* diropres */ + if (detail_nfsstat() == 0) { + detail_nfsfh(); + detail_fattr(); + } + break; + case NFSPROC_READLINK: + /* readlinkres */ + if (detail_nfsstat() == 0) { + (void) showxdr_string(NFS_MAXPATHLEN, "Path = %s"); + } + break; + case NFSPROC_READ: + /* readres */ + if (detail_nfsstat() == 0) { + detail_fattr(); + (void) showxdr_long("(%d byte(s) of data)"); + } + break; + case NFSPROC_REMOVE: + case NFSPROC_RENAME: + case NFSPROC_LINK: + case NFSPROC_SYMLINK: + case NFSPROC_RMDIR: + /* stat */ + detail_nfsstat(); + break; + case NFSPROC_READDIR: + /* readdirres */ + if (detail_nfsstat() == 0) + detail_readdirres(); + break; + case NFSPROC_STATFS: + /* statfsres */ + if (detail_nfsstat() == 0) { + (void) showxdr_long("Transfer size = %d"); + (void) showxdr_long("Block size = %d"); + (void) showxdr_long("Total blocks = %d"); + (void) showxdr_long("Free blocks = %d"); + (void) showxdr_long("Available blocks = %d"); + } + break; + default: + break; + } +} + +static void +detail_diroparg() +{ + detail_nfsfh(); + (void) showxdr_string(NFS_MAXPATHLEN, "File name = %s"); +} + +/* + * V2 NFS protocol was implicitly linked with SunOS errnos. + * Some of the errno values changed in SVr4. + * Need to map errno value so that SVr4 snoop will interpret + * them correctly. + */ +static char * +statusmsg(status) + ulong_t status; +{ + switch (status) { + case NFS_OK: return ("OK"); + case NFSERR_PERM: return ("Not owner"); + case NFSERR_NOENT: return ("No such file or directory"); + case NFSERR_IO: return ("I/O error"); + case NFSERR_NXIO: return ("No such device or address"); + case NFSERR_ACCES: return ("Permission denied"); + case NFSERR_EXIST: return ("File exists"); + case NFSERR_XDEV: return ("Cross-device link"); + case NFSERR_NODEV: return ("No such device"); + case NFSERR_NOTDIR: return ("Not a directory"); + case NFSERR_ISDIR: return ("Is a directory"); + case NFSERR_INVAL: return ("Invalid argument"); + case NFSERR_FBIG: return ("File too large"); + case NFSERR_NOSPC: return ("No space left on device"); + case NFSERR_ROFS: return ("Read-only file system"); + case NFSERR_OPNOTSUPP: return ("Operation not supported"); + case NFSERR_NAMETOOLONG: return ("File name too long"); + case NFSERR_NOTEMPTY: return ("Directory not empty"); + case NFSERR_DQUOT: return ("Disc quota exceeded"); + case NFSERR_STALE: return ("Stale NFS file handle"); + case NFSERR_REMOTE: return ("Object is remote"); + case NFSERR_WFLUSH: return ("write cache flushed"); + default: return ("(unknown error)"); + } + /* NOTREACHED */ +} + +int +sum_nfsstat(line) + char *line; +{ + ulong_t status; + + status = getxdr_long(); + (void) strcpy(line, statusmsg(status)); + return (status); +} + +int +detail_nfsstat() +{ + ulong_t status; + int pos; + + pos = getxdr_pos(); + status = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Status = %lu (%s)", + status, statusmsg(status)); + + return ((int)status); +} + +int +sum_filehandle(len) + int len; +{ + int i, l; + int fh = 0; + + for (i = 0; i < len; i += 4) { + l = getxdr_long(); + fh ^= (l >> 16) ^ l; + } + + return (fh); +} + +char * +sum_nfsfh() +{ + int fh; + static char buff[16]; + + fh = sum_filehandle(NFS_FHSIZE); + (void) sprintf(buff, " FH=%04X", fh & 0xFFFF); + return (buff); +} + +void +detail_nfsfh() +{ + int pos; + int fh; + + pos = getxdr_pos(); + fh = sum_filehandle(NFS_FHSIZE); + setxdr_pos(pos); + (void) sprintf(get_line(0, 0), "File handle = [%04X]", fh & 0xFFFF); + (void) showxdr_hex(NFS_FHSIZE, " %s"); +} + +static void +detail_mode(mode) + int mode; +{ + char *str; + + switch (mode & S_IFMT) { + case S_IFDIR: str = "Directory"; break; + case S_IFCHR: str = "Character"; break; + case S_IFBLK: str = "Block"; break; + case S_IFREG: str = "Regular file"; break; + case S_IFLNK: str = "Link"; break; + case S_IFSOCK: str = "Socket"; break; + case S_IFIFO: str = "Fifo"; break; + default: str = "?"; break; + } + + (void) sprintf(get_line(0, 0), "Mode = 0%o", mode); + (void) sprintf(get_line(0, 0), " Type = %s", str); + (void) sprintf(get_line(0, 0), + " Setuid = %d, Setgid = %d, Sticky = %d", + (mode & S_ISUID) != 0, + (mode & S_ISGID) != 0, + (mode & S_ISVTX) != 0); + (void) sprintf(get_line(0, 0), " Owner's permissions = %s", + perms(mode >> 6 & 0x7)); + (void) sprintf(get_line(0, 0), " Group's permissions = %s", + perms(mode >> 3 & 0x7)); + (void) sprintf(get_line(0, 0), " Other's permissions = %s", + perms(mode & 0x7)); +} + +void +detail_fattr() +{ + int fltype, mode, nlinks, uid, gid, size, blksz; + int rdev, blocks, fsid, fileid; + + fltype = getxdr_long(); + mode = getxdr_long(); + nlinks = getxdr_long(); + uid = getxdr_long(); + gid = getxdr_long(); + size = getxdr_long(); + blksz = getxdr_long(); + rdev = getxdr_long(); + blocks = getxdr_long(); + fsid = getxdr_long(); + fileid = getxdr_long(); + + (void) sprintf(get_line(0, 0), + "File type = %d (%s)", + fltype, filetype(fltype)); + detail_mode(mode); + (void) sprintf(get_line(0, 0), + "Link count = %d, UID = %d, GID = %d, Rdev = 0x%x", + nlinks, uid, gid, rdev); + (void) sprintf(get_line(0, 0), + "File size = %d, Block size = %d, No. of blocks = %d", + size, blksz, blocks); + (void) sprintf(get_line(0, 0), + "File system id = %d, File id = %d", + fsid, fileid); + (void) showxdr_date("Access time = %s"); + (void) showxdr_date("Modification time = %s"); + (void) showxdr_date("Inode change time = %s"); +} + +static void +detail_sattr() +{ + int mode; + + mode = getxdr_long(); + detail_mode(mode); + (void) showxdr_long("UID = %d"); + (void) showxdr_long("GID = %d"); + (void) showxdr_long("Size = %d"); + (void) showxdr_date("Access time = %s"); + (void) showxdr_date("Modification time = %s"); +} + +static char * +filetype(n) + int n; +{ + switch (n) { + case NFREG: return ("Regular File"); + case NFDIR: return ("Directory"); + case NFBLK: return ("Block special"); + case NFCHR: return ("Character special"); + case NFLNK: return ("Symbolic Link"); + default: return ("?"); + } +} + +static char * +perms(n) + int n; +{ + static char buff[4]; + + buff[0] = n & 4 ? 'r' : '-'; + buff[1] = n & 2 ? 'w' : '-'; + buff[2] = n & 1 ? 'x' : '-'; + buff[3] = '\0'; + return (buff); +} + +static char * +sum_readdirres() +{ + static char buff[NFS_MAXNAMLEN + 1]; + int entries = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, " %d+ entries (incomplete)", entries); + return (buff); + } + while (getxdr_long()) { + entries++; + (void) getxdr_long(); /* fileid */ + (void) getxdr_string(buff, NFS_MAXNAMLEN); /* name */ + (void) getxdr_u_long(); /* cookie */ + } + + (void) sprintf(buff, " %d entries (%s)", + entries, + getxdr_long() ? "No more" : "More"); + return (buff); +} + +static void +detail_readdirres() +{ + ulong_t fileid, cookie; + int entries = 0; + char *name; + char buff[NFS_MAXNAMLEN + 1]; + + (void) sprintf(get_line(0, 0), " File id Cookie Name"); + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ entries. (Frame is incomplete)", + entries); + return; + } + while (getxdr_long()) { + entries++; + fileid = getxdr_long(); + name = (char *)getxdr_string(buff, NFS_MAXNAMLEN); + cookie = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + " %7lu %7lu %s", + fileid, cookie, name); + } + + (void) sprintf(get_line(0, 0), " %d entries", entries); + (void) showxdr_long("EOF = %d"); +} + +void +skip_fattr() +{ + + xdr_skip(17 * 4); /* XDR sizeof nfsfattr */ +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.h new file mode 100644 index 0000000..576590a --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs.h @@ -0,0 +1,58 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ifndef _SNOOP_NFS_H +#define _SNOOP_NFS_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Definitions that are shared among the NFS-related interpreters. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +extern char *sum_nfsfh(void); +extern void detail_nfsfh(void); +extern int sum_nfsstat(char *); +extern int detail_nfsstat(void); +extern void detail_fattr(void); +extern void skip_fattr(void); +extern int sum_filehandle(int); + +extern char *sum_nfsfh3(void); +extern void detail_nfsfh3(void); +extern int sum_nfsstat3(char *); +extern void detail_post_op_attr(char *); +extern int detail_nfsstat3(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _SNOOP_NFS_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs3.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs3.c new file mode 100644 index 0000000..6355a03 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs3.c @@ -0,0 +1,1214 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <setjmp.h> +#include <string.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include "snoop.h" +#include "snoop_nfs.h" + +#include <sys/stat.h> +#include <sys/param.h> +#include <rpcsvc/nfs_prot.h> + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +extern jmp_buf xdr_err; + +static void nfscall3(int); +static void nfsreply3(int); +static char *perms(int); +static char *filetype(int); +static char *sum_access(void); +static char *sum_readdirres(void); +static char *sum_readdirplusres(void); +static char *sum_createhow(void); +static char *sum_stablehow(void); +static void detail_sattr3(void); +static void detail_diropargs3(void); +static void detail_readdirres(void); +static void detail_readdirplusres(void); +static void detail_fattr3(void); +static void detail_access(void); +static void detail_mode(int); +static void detail_wcc_attr(void); +static void detail_pre_op_attr(char *); +static void detail_wcc_data(char *); +static void skip_postop(void); +static void skip_wcc_data(void); +static void skip_sattr3(void); + +#define DONT_CHANGE 0 +#define SET_TO_SERVER_TIME 1 +#define SET_TO_CLIENT_TIME 2 + +#define UNCHECKED 0 +#define GUARDED 1 +#define EXCLUSIVE 2 + +#define ACCESS3_READ 0x0001 +#define ACCESS3_LOOKUP 0x0002 +#define ACCESS3_MODIFY 0x0004 +#define ACCESS3_EXTEND 0x0008 +#define ACCESS3_DELETE 0x0010 +#define ACCESS3_EXECUTE 0x0020 + +#define UNSTABLE 0 +#define DATA_SYNC 1 +#define FILE_SYNC 2 + +#define NF3REG 1 /* regular file */ +#define NF3DIR 2 /* directory */ +#define NF3BLK 3 /* block special */ +#define NF3CHR 4 /* character special */ +#define NF3LNK 5 /* symbolic link */ +#define NF3SOCK 6 /* unix domain socket */ +#define NF3FIFO 7 /* named pipe */ + +#define NFS3_FHSIZE 64 + +static char *procnames_short[] = { + "NULL3", /* 0 */ + "GETATTR3", /* 1 */ + "SETATTR3", /* 2 */ + "LOOKUP3", /* 3 */ + "ACCESS3", /* 4 */ + "READLINK3", /* 5 */ + "READ3", /* 6 */ + "WRITE3", /* 7 */ + "CREATE3", /* 8 */ + "MKDIR3", /* 9 */ + "SYMLINK3", /* 10 */ + "MKNOD3", /* 11 */ + "REMOVE3", /* 12 */ + "RMDIR3", /* 13 */ + "RENAME3", /* 14 */ + "LINK3", /* 15 */ + "READDIR3", /* 16 */ + "READDIRPLUS3", /* 17 */ + "FSSTAT3", /* 18 */ + "FSINFO3", /* 19 */ + "PATHCONF3", /* 20 */ + "COMMIT3", /* 21 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Get file attributes", /* 1 */ + "Set file attributes", /* 2 */ + "Look up file name", /* 3 */ + "Check access permission", /* 4 */ + "Read from symbolic link", /* 5 */ + "Read from file", /* 6 */ + "Write to file", /* 7 */ + "Create file", /* 8 */ + "Make directory", /* 9 */ + "Make symbolic link", /* 10 */ + "Make special file", /* 11 */ + "Remove file", /* 12 */ + "Remove directory", /* 13 */ + "Rename", /* 14 */ + "Link", /* 15 */ + "Read from directory", /* 16 */ + "Read from directory - plus", /* 17 */ + "Get filesystem statistics", /* 18 */ + "Get filesystem information", /* 19 */ + "Get POSIX information", /* 20 */ + "Commit to stable storage", /* 21 */ +}; + +#define MAXPROC 21 + +void +interpret_nfs3(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[NFS_MAXPATHLEN + 1]; /* protocol allows longer */ + u_longlong_t off; + int sz, how; + char *fh, *name; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS C %s", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case NFSPROC3_GETATTR: + case NFSPROC3_READLINK: + case NFSPROC3_FSSTAT: + case NFSPROC3_FSINFO: + case NFSPROC3_PATHCONF: + (void) sprintf(line, sum_nfsfh3()); + break; + case NFSPROC3_SETATTR: + (void) sprintf(line, sum_nfsfh3()); + break; + case NFSPROC3_READDIR: + fh = sum_nfsfh3(); + off = getxdr_u_longlong(); + (void) getxdr_u_longlong(); + sz = getxdr_u_long(); + (void) sprintf(line, "%s Cookie=%llu for %lu", + fh, off, sz); + break; + case NFSPROC3_READDIRPLUS: + fh = sum_nfsfh3(); + off = getxdr_u_longlong(); + (void) getxdr_u_longlong(); + sz = getxdr_u_long(); + (void) sprintf(line, + "%s Cookie=%llu for %lu/%lu", + fh, off, sz, getxdr_u_long()); + break; + case NFSPROC3_ACCESS: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s (%s)", + fh, sum_access()); + break; + case NFSPROC3_LOOKUP: + case NFSPROC3_REMOVE: + case NFSPROC3_RMDIR: + case NFSPROC3_MKDIR: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s %s", + fh, getxdr_string(buff, + NFS_MAXPATHLEN)); + break; + case NFSPROC3_CREATE: + fh = sum_nfsfh3(); + name = getxdr_string(buff, NFS_MAXPATHLEN); + (void) sprintf(line, "%s (%s) %s", + fh, sum_createhow(), name); + break; + case NFSPROC3_MKNOD: + fh = sum_nfsfh3(); + name = getxdr_string(buff, NFS_MAXPATHLEN); + how = getxdr_long(); + (void) sprintf(line, "%s (%s) %s", + fh, filetype(how), name); + break; + case NFSPROC3_READ: + fh = sum_nfsfh3(); + off = getxdr_u_longlong(); + sz = getxdr_u_long(); + (void) sprintf(line, "%s at %llu for %lu", + fh, off, sz); + break; + case NFSPROC3_WRITE: + fh = sum_nfsfh3(); + off = getxdr_u_longlong(); + sz = getxdr_u_long(); + (void) sprintf(line, "%s at %llu for %lu (%s)", + fh, off, sz, sum_stablehow()); + break; + case NFSPROC3_SYMLINK: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s %s", + fh, getxdr_string(buff, + NFS_MAXPATHLEN)); + skip_sattr3(); + line += strlen(line); + (void) sprintf(line, " to %s", + getxdr_string(buff, NFS_MAXPATHLEN)); + break; + case NFSPROC3_RENAME: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s %s", + fh, getxdr_string(buff, + NFS_MAXPATHLEN)); + line += strlen(line); + fh = sum_nfsfh3(); + (void) sprintf(line, " to%s %s", + fh, getxdr_string(buff, + NFS_MAXPATHLEN)); + break; + case NFSPROC3_LINK: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s", fh); + line += strlen(line); + fh = sum_nfsfh3(); + (void) sprintf(line, " to%s %s", + fh, getxdr_string(buff, + NFS_MAXPATHLEN)); + break; + case NFSPROC3_COMMIT: + fh = sum_nfsfh3(); + off = getxdr_u_longlong(); + sz = getxdr_u_long(); + (void) sprintf(line, "%s at %llu for %lu", + fh, off, sz); + break; + default: + break; + } + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "NFS R %s ", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case NFSPROC3_LOOKUP: + if (sum_nfsstat3(line) == NFS3_OK) + (void) strcat(line, sum_nfsfh3()); + break; + case NFSPROC3_CREATE: + case NFSPROC3_MKDIR: + case NFSPROC3_SYMLINK: + case NFSPROC3_MKNOD: + if (sum_nfsstat3(line) == NFS3_OK) { + if (getxdr_bool()) + (void) strcat(line, + sum_nfsfh3()); + } + break; + case NFSPROC3_READLINK: + if (sum_nfsstat3(line) == NFS3_OK) { + line += strlen(line); + skip_postop(); + (void) sprintf(line, " (Path=%s)", + getxdr_string(buff, + NFS_MAXPATHLEN)); + } + break; + case NFSPROC3_GETATTR: + case NFSPROC3_SETATTR: + case NFSPROC3_REMOVE: + case NFSPROC3_RMDIR: + case NFSPROC3_RENAME: + case NFSPROC3_LINK: + case NFSPROC3_FSSTAT: + case NFSPROC3_FSINFO: + case NFSPROC3_PATHCONF: + (void) sum_nfsstat3(line); + break; + case NFSPROC3_ACCESS: + if (sum_nfsstat3(line) == NFS3_OK) { + line += strlen(line); + skip_postop(); + (void) sprintf(line, " (%s)", + sum_access()); + } + break; + case NFSPROC3_WRITE: + if (sum_nfsstat3(line) == NFS3_OK) { + line += strlen(line); + skip_wcc_data(); + sz = getxdr_u_long(); + (void) sprintf(line, " %d (%s)", + sz, sum_stablehow()); + } + break; + case NFSPROC3_READDIR: + if (sum_nfsstat3(line) == NFS3_OK) + (void) strcat(line, sum_readdirres()); + break; + case NFSPROC3_READ: + if (sum_nfsstat3(line) == NFS3_OK) { + line += strlen(line); + skip_postop(); + (void) sprintf(line, " (%lu bytes)", + getxdr_u_long()); + if (getxdr_bool()) + (void) strcat(line, " EOF"); + } + break; + case NFSPROC3_READDIRPLUS: + if (sum_nfsstat3(line) == NFS3_OK) + (void) strcat(line, + sum_readdirplusres()); + break; + case NFSPROC3_COMMIT: + (void) sum_nfsstat3(line); + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NFS: ", "Sun NFS", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long[proc]); + if (type == CALL) + nfscall3(proc); + else + nfsreply3(proc); + show_trailer(); + } +} + +/* + * Print out version 3 NFS call packets + */ +static void +nfscall3(proc) + int proc; +{ + int h; + + switch (proc) { + case NFSPROC3_GETATTR: + case NFSPROC3_READLINK: + case NFSPROC3_FSINFO: + case NFSPROC3_FSSTAT: + case NFSPROC3_PATHCONF: + detail_nfsfh3(); + break; + case NFSPROC3_SETATTR: + detail_nfsfh3(); + detail_sattr3(); + if (getxdr_bool()) + (void) showxdr_date_ns("Guard = %s"); + break; + case NFSPROC3_LOOKUP: + case NFSPROC3_REMOVE: + case NFSPROC3_RMDIR: + detail_diropargs3(); + break; + case NFSPROC3_ACCESS: + detail_nfsfh3(); + detail_access(); + break; + case NFSPROC3_MKDIR: + detail_diropargs3(); + detail_sattr3(); + break; + case NFSPROC3_CREATE: + detail_diropargs3(); + h = getxdr_u_long(); + if (h == EXCLUSIVE) + showxdr_hex(8, "Guard = %s"); + else { + (void) sprintf(get_line(0, 0), "Method = %s", + h == UNCHECKED ? "Unchecked" : "Guarded"); + detail_sattr3(); + } + break; + case NFSPROC3_MKNOD: + detail_diropargs3(); + h = getxdr_u_long(); + (void) sprintf(get_line(0, 0), "File type = %s", + filetype(h)); + switch (h) { + case NF3CHR: + case NF3BLK: + detail_sattr3(); + showxdr_u_long("Major = %lu"); + showxdr_u_long("Minor = %lu"); + break; + case NF3SOCK: + case NF3FIFO: + detail_sattr3(); + break; + } + break; + case NFSPROC3_WRITE: + detail_nfsfh3(); + (void) showxdr_u_longlong("Offset = %llu"); + (void) showxdr_u_long("Size = %lu"); + (void) sprintf(get_line(0, 0), "Stable = %s", + sum_stablehow()); + break; + case NFSPROC3_RENAME: + detail_diropargs3(); + detail_diropargs3(); + break; + case NFSPROC3_LINK: + detail_nfsfh3(); + detail_diropargs3(); + break; + case NFSPROC3_SYMLINK: + detail_diropargs3(); + detail_sattr3(); + (void) showxdr_string(MAXPATHLEN, "Path = %s"); + break; + case NFSPROC3_READDIR: + detail_nfsfh3(); + (void) showxdr_u_longlong("Cookie = %llu"); + (void) showxdr_hex(8, "Verifier = %s"); + (void) showxdr_u_long("Count = %lu"); + break; + case NFSPROC3_READDIRPLUS: + detail_nfsfh3(); + (void) showxdr_u_longlong("Cookie = %llu"); + (void) showxdr_hex(8, "Verifier = %s"); + (void) showxdr_u_long("Dircount = %lu"); + (void) showxdr_u_long("Maxcount = %lu"); + break; + case NFSPROC3_READ: + case NFSPROC3_COMMIT: + detail_nfsfh3(); + (void) showxdr_u_longlong("Offset = %llu"); + (void) showxdr_long("Count = %lu"); + break; + default: + break; + } +} + +/* + * Print out version 3 NFS reply packets + */ +static void +nfsreply3(proc) + int proc; +{ + int bits; + + switch (proc) { + case NFSPROC3_GETATTR: + if (detail_nfsstat3() == NFS3_OK) { + detail_fattr3(); + } + break; + case NFSPROC3_SETATTR: + (void) detail_nfsstat3(); + detail_wcc_data(""); + break; + case NFSPROC3_WRITE: + if (detail_nfsstat3() == NFS3_OK) { + detail_wcc_data(""); + (void) showxdr_u_long("Count = %lu bytes written"); + (void) sprintf(get_line(0, 0), "Stable = %s", + sum_stablehow()); + (void) showxdr_hex(8, "Verifier = %s"); + } else + detail_wcc_data(""); + break; + case NFSPROC3_LOOKUP: + if (detail_nfsstat3() == NFS3_OK) { + detail_nfsfh3(); + detail_post_op_attr("(object)"); + } + detail_post_op_attr("(directory)"); + break; + case NFSPROC3_CREATE: + case NFSPROC3_MKDIR: + case NFSPROC3_SYMLINK: + case NFSPROC3_MKNOD: + if (detail_nfsstat3() == NFS3_OK) { + if (getxdr_bool()) + detail_nfsfh3(); + else + (void) sprintf(get_line(0, 0), + "(No file handle available)"); + detail_post_op_attr(""); + } + detail_wcc_data(""); + break; + case NFSPROC3_READLINK: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) showxdr_string(MAXPATHLEN, "Path = %s"); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_READ: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) showxdr_u_long("Count = %lu bytes read"); + (void) showxdr_bool("End of file = %s"); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_ACCESS: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) sprintf(get_line(0, 0), "Access = %s", + sum_access()); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_REMOVE: + case NFSPROC3_RMDIR: + (void) detail_nfsstat3(); + detail_wcc_data(""); + break; + case NFSPROC3_RENAME: + (void) detail_nfsstat3(); + detail_wcc_data("(from directory)"); + detail_wcc_data("(to directory)"); + break; + case NFSPROC3_LINK: + (void) detail_nfsstat3(); + detail_post_op_attr(""); + detail_wcc_data(""); + break; + case NFSPROC3_READDIR: + if (detail_nfsstat3() == NFS3_OK) { + detail_readdirres(); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_READDIRPLUS: + if (detail_nfsstat3() == NFS3_OK) { + detail_readdirplusres(); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_FSSTAT: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) showxdr_u_longlong( + "Total space = %llu bytes"); + (void) showxdr_u_longlong( + "Available space = %llu bytes"); + (void) showxdr_u_longlong( + "Available space - this user = %llu bytes"); + (void) showxdr_u_longlong( + "Total file slots = %llu"); + (void) showxdr_u_longlong( + "Available file slots = %llu"); + (void) showxdr_u_longlong( + "Available file slots - this user = %llu"); + (void) showxdr_u_long("Invariant time = %lu sec"); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_FSINFO: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) show_line("Read transfer sizes:"); + (void) showxdr_u_long(" Maximum = %lu bytes"); + (void) showxdr_u_long(" Preferred = %lu bytes"); + (void) showxdr_u_long( + " Suggested multiple = %lu bytes"); + (void) show_line("Write transfer sizes:"); + (void) showxdr_u_long(" Maximum = %lu bytes"); + (void) showxdr_u_long(" Preferred = %lu bytes"); + (void) showxdr_u_long( + " Suggested multiple = %lu bytes"); + (void) show_line("Directory read size:"); + (void) showxdr_u_long(" Preferred = %lu bytes"); + (void) show_line("File system limits:"); + (void) showxdr_u_longlong( + " Max file size = %llu bytes"); + (void) showxdr_date_ns( + " Server minimum time discrimination = %s sec"); + bits = showxdr_u_long("Properties = 0x%02x"); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, FSF3_LINK, + "Hard links supported", + "(hard links not supported)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, FSF3_SYMLINK, + "Symbolic links supported", + "(symbolic links not supported)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, FSF3_HOMOGENEOUS, + "Pathconf cannot vary per file", + "(pathconf can vary per file)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, FSF3_CANSETTIME, + "Server can always set file times", + "(server cannot always set file times)")); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_PATHCONF: + if (detail_nfsstat3() == NFS3_OK) { + detail_post_op_attr(""); + (void) showxdr_u_long("Link max = %lu"); + (void) showxdr_u_long("Name max = %lu"); + (void) showxdr_bool("No trunc = %s"); + (void) showxdr_bool("Chown restricted = %s"); + (void) showxdr_bool("Case insensitive = %s"); + (void) showxdr_bool("Case preserving = %s"); + } else + detail_post_op_attr(""); + break; + case NFSPROC3_COMMIT: + if (detail_nfsstat3() == NFS3_OK) { + detail_wcc_data(""); + (void) showxdr_hex(8, "Verifier = %s"); + } else + detail_wcc_data(""); + break; + default: + break; + } +} + +static void +detail_diropargs3() +{ + + detail_nfsfh3(); + (void) showxdr_string(MAXPATHLEN, "File name = %s"); +} + +int +sum_nfsstat3(line) + char *line; +{ + ulong_t status; + char *p; + + status = getxdr_long(); + switch (status) { + case NFS3_OK: p = "OK"; break; + case NFS3ERR_PERM: p = "Not owner"; break; + case NFS3ERR_NOENT: p = "No such file or directory"; break; + case NFS3ERR_IO: p = "I/O error"; break; + case NFS3ERR_NXIO: p = "No such device or address"; break; + case NFS3ERR_ACCES: p = "Permission denied"; break; + case NFS3ERR_EXIST: p = "File exists"; break; + case NFS3ERR_XDEV: p = "Attempted cross-device link"; break; + case NFS3ERR_NODEV: p = "No such device"; break; + case NFS3ERR_NOTDIR: p = "Not a directory"; break; + case NFS3ERR_ISDIR: p = "Is a directory"; break; + case NFS3ERR_INVAL: p = "Invalid argument"; break; + case NFS3ERR_FBIG: p = "File too large"; break; + case NFS3ERR_NOSPC: p = "No space left on device"; break; + case NFS3ERR_ROFS: p = "Read-only file system"; break; + case NFS3ERR_MLINK: p = "Too many links"; break; + case NFS3ERR_NAMETOOLONG:p = "File name too long"; break; + case NFS3ERR_NOTEMPTY: p = "Directory not empty"; break; + case NFS3ERR_DQUOT: p = "Disc quota exceeded"; break; + case NFS3ERR_STALE: p = "Stale NFS file handle"; break; + case NFS3ERR_REMOTE: p = "Too many levels of remote in path"; break; + case NFS3ERR_BADHANDLE: p = "Illegal NFS file handle"; break; + case NFS3ERR_NOT_SYNC: p = "Update synch mismatch"; break; + case NFS3ERR_BAD_COOKIE:p = "Readdir cookie is stale"; break; + case NFS3ERR_NOTSUPP: p = "Operation not supported"; break; + case NFS3ERR_TOOSMALL: p = "Buffer/request too small"; break; + case NFS3ERR_SERVERFAULT:p = "Server fault"; break; + case NFS3ERR_BADTYPE: p = "Bad type"; break; + case NFS3ERR_JUKEBOX: p = "File is temporarily unavailable"; break; + default: p = "(unknown error)"; break; + } + + (void) strcpy(line, p); + return (status); +} + +int +detail_nfsstat3() +{ + ulong_t status; + char buff[64]; + int pos; + + pos = getxdr_pos(); + status = sum_nfsstat3(buff); + + (void) sprintf(get_line(pos, getxdr_pos()), "Status = %d (%s)", + status, buff); + + return ((int)status); +} + +static void +skip_postop() +{ + + if (getxdr_bool()) + xdr_skip(21 * 4); /* XDR size of fattr3 */ +} + +static void +skip_wcc_data() +{ + + if (getxdr_bool() > 0) + xdr_skip(3 * 8); + skip_postop(); +} + +static void +skip_sattr3() +{ + + if (getxdr_bool() > 0) + xdr_skip(4); /* mode */ + if (getxdr_bool() > 0) + xdr_skip(4); /* uid */ + if (getxdr_bool() > 0) + xdr_skip(4); /* gid */ + if (getxdr_bool() > 0) + xdr_skip(8); /* size */ + if (getxdr_bool() > 0) + xdr_skip(8); /* atime */ + if (getxdr_bool() > 0) + xdr_skip(8); /* mtime */ +} + +char * +sum_nfsfh3() +{ + int len; + int fh; + static char buff[16]; + + len = getxdr_long(); + fh = sum_filehandle(len); + (void) sprintf(buff, " FH=%04X", fh & 0xFFFF); + return (buff); +} + +void +detail_nfsfh3() +{ + int pos; + int i, l, len; + int fh; + + len = getxdr_long(); + pos = getxdr_pos(); + fh = sum_filehandle(len); + setxdr_pos(pos); + (void) sprintf(get_line(0, 0), "File handle = [%04X]", fh & 0xFFFF); + i = 0; + while (i < len) { + l = MIN(len - i, 32); + (void) showxdr_hex(l, " %s"); + i += l; + } +} + +static char * +sum_access() +{ + int bits; + static char buff[64]; + + bits = getxdr_u_long(); + buff[0] = '\0'; + + if (bits & ACCESS3_READ) + (void) strcat(buff, "read,"); + if (bits & ACCESS3_LOOKUP) + (void) strcat(buff, "lookup,"); + if (bits & ACCESS3_MODIFY) + (void) strcat(buff, "modify,"); + if (bits & ACCESS3_EXTEND) + (void) strcat(buff, "extend,"); + if (bits & ACCESS3_DELETE) + (void) strcat(buff, "delete,"); + if (bits & ACCESS3_EXECUTE) + (void) strcat(buff, "execute,"); + if (buff[0] != '\0') + buff[strlen(buff) - 1] = '\0'; + + return (buff); +} + +static void +detail_access() +{ + uint_t bits; + + bits = showxdr_u_long("Access bits = 0x%08x"); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_READ, "Read", "(no read)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_LOOKUP, "Lookup", "(no lookup)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_MODIFY, "Modify", "(no modify)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_EXTEND, "Extend", "(no extend)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_DELETE, "Delete", "(no delete)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS3_EXECUTE, "Execute", "(no execute)")); +} + +static void +detail_mode(mode) + int mode; +{ + + (void) sprintf(get_line(0, 0), " Mode = 0%o", mode); + (void) sprintf(get_line(0, 0), + " Setuid = %d, Setgid = %d, Sticky = %d", + (mode & S_ISUID) != 0, + (mode & S_ISGID) != 0, + (mode & S_ISVTX) != 0); + (void) sprintf(get_line(0, 0), " Owner's permissions = %s", + perms(mode >> 6 & 0x7)); + (void) sprintf(get_line(0, 0), " Group's permissions = %s", + perms(mode >> 3 & 0x7)); + (void) sprintf(get_line(0, 0), " Other's permissions = %s", + perms(mode & 0x7)); +} + +static void +detail_fattr3() +{ + uint_t fltype, mode, nlinks, uid, gid; + uint_t major, minor; + u_longlong_t size, used, fsid, fileid; + + fltype = getxdr_u_long(); + mode = getxdr_u_long(); + nlinks = getxdr_u_long(); + uid = getxdr_u_long(); + gid = getxdr_u_long(); + size = getxdr_u_longlong(); + used = getxdr_u_longlong(); + major = getxdr_u_long(); + minor = getxdr_u_long(); + fsid = getxdr_u_longlong(); + fileid = getxdr_u_longlong(); + + (void) sprintf(get_line(0, 0), + " File type = %d (%s)", + fltype, filetype(fltype)); + detail_mode(mode); + (void) sprintf(get_line(0, 0), + " Link count = %u, User ID = %u, Group ID = %u", + nlinks, uid, gid); + (void) sprintf(get_line(0, 0), + " File size = %llu, Used = %llu", + size, used); + (void) sprintf(get_line(0, 0), + " Special: Major = %u, Minor = %u", + major, minor); + (void) sprintf(get_line(0, 0), + " File system id = %llu, File id = %llu", + fsid, fileid); + (void) showxdr_date_ns(" Last access time = %s"); + (void) showxdr_date_ns(" Modification time = %s"); + (void) showxdr_date_ns(" Attribute change time = %s"); + (void) show_line(""); +} + +static void +detail_sattr3() +{ + int t; + + if (getxdr_bool()) + detail_mode(getxdr_u_long()); + else + (void) sprintf(get_line(0, 0), "Mode = (not set)"); + if (getxdr_bool()) + (void) showxdr_long("User ID = %d"); + else + (void) sprintf(get_line(0, 0), "User ID = (not set)"); + if (getxdr_bool()) + (void) showxdr_long("Group ID = %d"); + else + (void) sprintf(get_line(0, 0), "Group ID = (not set)"); + if (getxdr_bool()) + (void) showxdr_u_longlong("Size = %llu"); + else + (void) sprintf(get_line(0, 0), "Size = (not set)"); + + if ((t = getxdr_u_long()) == SET_TO_CLIENT_TIME) + (void) showxdr_date("Access time = %s (set to client time)"); + else if (t == SET_TO_SERVER_TIME) + (void) sprintf(get_line(0, 0), + "Access time = (set to server time)"); + else + (void) sprintf(get_line(0, 0), "Access time = (do not set)"); + + if ((t = getxdr_u_long()) == SET_TO_CLIENT_TIME) { + (void) showxdr_date( + "Modification time = %s (set to client time)"); + } else if (t == SET_TO_SERVER_TIME) + (void) sprintf(get_line(0, 0), + "Modification time = (set to server time)"); + else + (void) sprintf(get_line(0, 0), + "Modification time = (do not set)"); + (void) show_line(""); +} + +static char * +filetype(n) + int n; +{ + + switch (n) { + case NF3REG: + return ("Regular File"); + case NF3DIR: + return ("Directory"); + case NF3BLK: + return ("Block special"); + case NF3CHR: + return ("Character special"); + case NF3LNK: + return ("Symbolic Link"); + case NF3SOCK: + return ("Unix domain socket"); + case NF3FIFO: + return ("Named pipe"); + default: + return ("?"); + } + /* NOTREACHED */ +} + +static char * +perms(n) + int n; +{ + static char buff[4]; + + buff[0] = n & 4 ? 'r' : '-'; + buff[1] = n & 2 ? 'w' : '-'; + buff[2] = n & 1 ? 'x' : '-'; + buff[3] = '\0'; + return (buff); +} + +static void +detail_wcc_attr() +{ + + (void) showxdr_u_longlong(" Size = %llu bytes"); + (void) showxdr_date_ns(" Modification time = %s"); + (void) showxdr_date_ns(" Attribute change time = %s"); + (void) show_line(""); +} + +static void +detail_pre_op_attr(str) + char *str; +{ + + if (getxdr_bool()) { + (void) sprintf(get_line(0, 0), + "Pre-operation attributes: %s", str); + detail_wcc_attr(); + } else + (void) sprintf(get_line(0, 0), + "Pre-operation attributes: %s (not available)", str); +} + +void +detail_post_op_attr(str) + char *str; +{ + + if (getxdr_bool()) { + (void) sprintf(get_line(0, 0), + "Post-operation attributes: %s", str); + detail_fattr3(); + } else + (void) sprintf(get_line(0, 0), + "Post-operation attributes: %s (not available)", str); +} + +static void +detail_wcc_data(str) + char *str; +{ + + detail_pre_op_attr(str); + detail_post_op_attr(str); +} + +static char * +sum_readdirres() +{ + static char buff[NFS_MAXNAMLEN + 1]; /* protocol allows longer names */ + static int entries; + + entries = 0; + if (setjmp(xdr_err)) { + (void) sprintf(buff, " %d+ entries (incomplete)", entries); + return (buff); + } + skip_postop(); + xdr_skip(8); /* cookieverf */ + while (getxdr_bool()) { + entries++; + xdr_skip(8); /* fileid */ + (void) getxdr_string(buff, NFS_MAXNAMLEN); /* name */ + xdr_skip(8); /* cookie */ + } + + (void) sprintf(buff, " %d entries (%s)", + entries, getxdr_bool() ? "No more" : "More"); + return (buff); +} + +static char * +sum_readdirplusres() +{ + static char buff[NFS_MAXNAMLEN + 1]; /* protocol allows longer */ + static int entries; + int skip; + + entries = 0; + if (setjmp(xdr_err)) { + (void) sprintf(buff, " %d+ entries (incomplete)", entries); + return (buff); + } + skip_postop(); + xdr_skip(8); /* cookieverf */ + while (getxdr_bool()) { + entries++; + xdr_skip(8); /* fileid */ + (void) getxdr_string(buff, NFS_MAXNAMLEN); /* name */ + xdr_skip(8); /* cookie */ + skip_postop(); /* post-op */ + if (getxdr_bool()) { + skip = getxdr_long(); + xdr_skip(RNDUP(skip)); /* fhandle */ + } + } + + (void) sprintf(buff, " %d entries (%s)", + entries, getxdr_bool() ? "No more" : "More"); + return (buff); +} + +static void +detail_readdirres() +{ + static int entries; + u_longlong_t fileid, cookie; + char *name; + char buff[NFS_MAXNAMLEN + 1]; /* protocol allows longer names */ + + entries = 0; + detail_post_op_attr(""); + (void) showxdr_hex(8, "Cookie verifier = %s"); + (void) show_line(""); + (void) sprintf(get_line(0, 0), " File id Cookie Name"); + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ entries. (Frame is incomplete)", + entries); + return; + } + while (getxdr_bool()) { + entries++; + fileid = getxdr_u_longlong(); + name = (char *)getxdr_string(buff, NFS_MAXNAMLEN); + cookie = getxdr_u_longlong(); + (void) sprintf(get_line(0, 0), + " %10llu %10llu %s", + fileid, cookie, name); + } + + (void) sprintf(get_line(0, 0), " %d entries", entries); + (void) showxdr_bool("EOF = %s"); +} + +static void +detail_readdirplusres() +{ + static int entries; + + entries = 0; + detail_post_op_attr(""); + (void) showxdr_hex(8, "Cookie verifier = %s"); + (void) show_line(""); + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ entries. (Frame is incomplete)", + entries); + return; + } + while (getxdr_bool()) { + entries++; + (void) sprintf(get_line(0, 0), + "------------------ entry #%d", + entries); + (void) showxdr_u_longlong("File ID = %llu"); + (void) showxdr_string(NFS_MAXNAMLEN, "Name = %s"); + (void) showxdr_u_longlong("Cookie = %llu"); + detail_post_op_attr(""); + if (getxdr_bool()) + detail_nfsfh3(); + else + (void) sprintf(get_line(0, 0), + "(No file handle available)"); + } + + (void) show_line(""); + (void) sprintf(get_line(0, 0), " %d entries", entries); + (void) showxdr_bool("EOF = %s"); +} + +static char * +sum_createhow() +{ + long how; + + how = getxdr_long(); + switch (how) { + case UNCHECKED: + return ("UNCHECKED"); + case GUARDED: + return ("GUARDED"); + case EXCLUSIVE: + return ("EXCLUSIVE"); + default: + return ("?"); + } + /* NOTREACHED */ +} + +static char * +sum_stablehow() +{ + long stable; + + stable = getxdr_long(); + switch (stable) { + case UNSTABLE: + return ("ASYNC"); + case DATA_SYNC: + return ("DSYNC"); + case FILE_SYNC: + return ("FSYNC"); + default: + return ("?"); + } + /* NOTREACHED */ +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs4.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs4.c new file mode 100644 index 0000000..bb1db5c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs4.c @@ -0,0 +1,4900 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <ctype.h> +#include <string.h> +#include <strings.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <setjmp.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include "snoop.h" + +#include <sys/stat.h> +#include <sys/param.h> +#include <rpcsvc/nfs_prot.h> +/* use the same nfs4_prot.h as the xdr code */ +#include "rpcsvc/nfs4_prot.h" + +/* + * XXX With NFS v2 and v3, we only need to xdr the pieces that we care + * about. Anything else we can ignore and just skip to the next packet. + * So all the stuff that deals directly with XDR lives in snoop_display.c + * With v4, we need to XDR entire structures so that we can skip over + * uninteresting bits in a compound array, so we call XDR directly from + * here. We need to rethink how we're going to structure XDR access. Do + * we continue to hide it all in snoop_display.c, or do we expose it to all + * the protocol modules? + */ +extern XDR xdrm; + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +/* + * Maximum number of characters to display in compound4 summary line. + */ +#define SUM_COMPND_MAX 100 + +/* + * Maximum number of recognized attributes. + */ +#define MAX_ATTRIBUTES 56 + +/* + * This data structure provides a more convenient way to access an + * attribute bitmask. map[N] = value of bit N in a bitmap4. + * It's defined as a struct so as to step around all the weird rules in C + * about arrays, pointers, passing them as arguments, etc. + */ + +typedef struct { + char map[MAX_ATTRIBUTES]; +} unpkd_attrmap_t; + + +static void sumarg_cb_getattr(char *buf, size_t buflen, void *obj); +static void dtlarg_cb_getattr(void *obj); +static void sumarg_cb_recall(char *buf, size_t buflen, void *obj); +static void dtlarg_cb_recall(void *obj); + + +static void sumarg_access(char *buf, size_t buflen, void *obj); +static void dtlarg_access(void *obj); +static void sumarg_close(char *buf, size_t buflen, void *obj); +static void dtlarg_close(void *obj); +static void sumarg_commit(char *buf, size_t buflen, void *obj); +static void dtlarg_commit(void *obj); +static void sumarg_compnt(char *buf, size_t buflen, void *obj); +static void dtlarg_compnt(void *obj); +static void sumarg_create(char *buf, size_t buflen, void *obj); +static void dtlarg_create(void *obj); +static void sumarg_delprge(char *buf, size_t buflen, void *obj); +static void dtlarg_delprge(void *obj); +static void sumarg_delret(char *buf, size_t buflen, void *obj); +static void dtlarg_delret(void *obj); +static void sumarg_getattr(char *buf, size_t buflen, void *obj); +static void dtlarg_getattr(void *obj); +static void sumarg_link(char *buf, size_t buflen, void *obj); +static void dtlarg_link(void *obj); +static void sum_open_to_lock_owner(char *buf, int buflen, + open_to_lock_owner4 *own); +static void sum_exist_lock_owner(char *buf, int buflen, + exist_lock_owner4 *own); +static void sum_locker(char *buf, size_t buflen, locker4 *lk); +static void sumarg_lock(char *buf, size_t buflen, void *obj); +static void detail_open_to_lock_owner(open_to_lock_owner4 *own); +static void detail_exist_lock_owner(exist_lock_owner4 *own); +static void detail_locker(locker4 *lk); +static void dtlarg_lock(void *obj); +static void sumarg_lockt(char *buf, size_t buflen, void *obj); +static void dtlarg_lockt(void *obj); +static void sumarg_locku(char *buf, size_t buflen, void *obj); +static void dtlarg_locku(void *obj); +static void sumarg_lookup(char *buf, size_t buflen, void *obj); +static void dtlarg_lookup(void *obj); +static void sumarg_open(char *buf, size_t buflen, void *obj); +static void dtlarg_open(void *obj); +static void sumarg_openattr(char *buf, size_t buflen, void *obj); +static void dtlarg_openattr(void *obj); +static void sumarg_open_confirm(char *buf, size_t buflen, void *obj); +static void dtlarg_open_confirm(void *obj); +static void sumarg_open_downgrd(char *buf, size_t buflen, void *obj); +static void dtlarg_open_downgrd(void *obj); +static void sumarg_putfh(char *buf, size_t buflen, void *obj); +static void dtlarg_putfh(void *obj); +static void sumarg_read(char *buf, size_t buflen, void *obj); +static void dtlarg_read(void *obj); +static void sumarg_readdir(char *buf, size_t buflen, void *obj); +static void dtlarg_readdir(void *obj); +static void sumarg_release_lkown(char *buf, size_t buflen, void *obj); +static void dtlarg_release_lkown(void *obj); +static void sumarg_rename(char *buf, size_t buflen, void *obj); +static void dtlarg_rename(void *obj); +static void sumarg_renew(char *buf, size_t buflen, void *obj); +static void dtlarg_renew(void *buf); +static void sumarg_secinfo(char *buf, size_t buflen, void *obj); +static void dtlarg_secinfo(void *obj); +static void sumarg_setattr(char *buf, size_t buflen, void *obj); +static void dtlarg_setattr(void *obj); +static void sumarg_setclid(char *buf, size_t buflen, void *obj); +static void dtlarg_setclid(void *obj); +static void sumarg_setclid_cfm(char *buf, size_t buflen, void *obj); +static void dtlarg_setclid_cfm(void *obj); +static void dtlarg_verify(void *obj); +static void sumarg_write(char *buf, size_t buflen, void *obj); +static void dtlarg_write(void *obj); + +static void sumres_cb_getattr(char *buf, size_t buflen, void *obj); +static void dtlres_cb_getattr(void *obj); + +static void sumres_access(char *buf, size_t buflen, void *obj); +static void dtlres_access(void *obj); +static void sumres_close(char *buf, size_t buflen, void *obj); +static void dtlres_close(void *obj); +static void sumres_commit(char *buf, size_t buflen, void *obj); +static void dtlres_commit(void *obj); +static void dtlres_create(void *obj); +static void sumres_getattr(char *buf, size_t buflen, void *obj); +static void dtlres_getattr(void *obj); +static void sumres_getfh(char *buf, size_t buflen, void *obj); +static void dtlres_getfh(void *obj); +static void dtlres_link(void *obj); +static void sumres_lock(char *buf, size_t buflen, void *obj); +static void dtlres_lock(void *obj); +static void sumres_lockt(char *buf, size_t buflen, void *obj); +static void dtlres_lockt(void *obj); +static void sumres_locku(char *buf, size_t buflen, void *obj); +static void dtlres_locku(void *obj); +static void sumres_open(char *buf, size_t buflen, void *obj); +static void dtlres_open(void *obj); +static void sumres_open_confirm(char *buf, size_t buflen, void *obj); +static void dtlres_open_confirm(void *obj); +static void sumres_open_downgrd(char *buf, size_t buflen, void *obj); +static void dtlres_open_downgrd(void *obj); +static void sumres_read(char *buf, size_t buflen, void *obj); +static void dtlres_read(void *obj); +static void sumres_readdir(char *buf, size_t buflen, void *obj); +static void dtlres_readdir(void *obj); +static void sumres_readlnk(char *buf, size_t buflen, void *obj); +static void dtlres_readlnk(void *obj); +static void dtlres_remove(void *obj); +static void dtlres_rename(void *obj); +static void sumres_secinfo(char *buf, size_t buflen, void *obj); +static void dtlres_secinfo(void *obj); +static void sumres_setattr(char *buf, size_t buflen, void *obj); +static void dtlres_setattr(void *obj); +static void sumres_setclid(char *buf, size_t buflen, void *obj); +static void dtlres_setclid(void *obj); +static void sumres_write(char *buf, size_t buflen, void *obj); +static void dtlres_write(void *obj); +static void sum_nfsstat4(char *buf, size_t buflen, void *obj); +static void dtl_nfsstat4(void *obj); +static uint32_t adler16(void *, int); +static void nfs4_xdr_skip(int nbytes); +static char *sum_lock_type_name(enum nfs_lock_type4 type); + +int nfs4_pkt_start; +int nfs4_pkt_len; +int nfs4_skip_bytes; +int nfs4_fragged_rpc; +char *nfs4err_fragrpc = "<Fragmented RPC>"; +char *nfs4err_xdrfrag = "<XDR Error or Fragmented RPC>"; + +/* + * need a way to enable this if current testcases are parsing snoop + * error text. -- maybe an env var would do as temp workaround until + * testcases changed to grep for new error text. + */ +int nfs4_use_old_error_text = 0; + +/* + * Information about each operation that can appear in a compound call. + * The function pointers are to formatting functions for summary arguments + * and results, and detail arguments & results. + */ + +typedef struct { + char *name; + void (*sumarg)(char *, size_t, void *); + void (*sumres)(char *, size_t, void *); + void (*dtlarg)(void *); + void (*dtlres)(void *); +} op_info_t; + +static op_info_t cb_opcode_info[] = { + {"OP_ZERO", NULL, NULL, NULL, NULL}, /* 0 */ + {"OP_ONE", NULL, NULL, NULL, NULL}, + {"OP_TWO", NULL, NULL, NULL, NULL}, /* minor vers */ + {"CB_GETATTR", + sumarg_cb_getattr, sumres_cb_getattr, + dtlarg_cb_getattr, dtlres_cb_getattr}, + {"CB_RECALL", + sumarg_cb_recall, sum_nfsstat4, + dtlarg_cb_recall, dtl_nfsstat4}, +}; +static uint_t cb_num_opcodes = sizeof (cb_opcode_info) / sizeof (op_info_t *); + +static op_info_t opcode_info[] = { + {"OP_ZERO", NULL, NULL, NULL, NULL}, /* 0 */ + {"OP_ONE", NULL, NULL, NULL, NULL}, + {"OP_TWO", NULL, NULL, NULL, NULL}, /* minor vers */ + {"ACCESS", + sumarg_access, sumres_access, dtlarg_access, dtlres_access}, + {"CLOSE", + sumarg_close, sumres_close, dtlarg_close, dtlres_close}, + {"COMMIT", + sumarg_commit, sumres_commit, dtlarg_commit, dtlres_commit}, + {"CREATE", /* 5 */ + sumarg_create, sum_nfsstat4, dtlarg_create, dtlres_create}, + {"DELEGPURGE", + sumarg_delprge, sum_nfsstat4, dtlarg_delprge, dtl_nfsstat4}, + {"DELEGRETURN", + sumarg_delret, sum_nfsstat4, dtlarg_delret, dtl_nfsstat4}, + {"GETATTR", + sumarg_getattr, sumres_getattr, dtlarg_getattr, dtlres_getattr}, + {"GETFH", + NULL, sumres_getfh, NULL, dtlres_getfh}, + {"LINK", /* 10 */ + sumarg_link, sum_nfsstat4, dtlarg_link, dtlres_link}, + {"LOCK", + sumarg_lock, sumres_lock, dtlarg_lock, dtlres_lock}, + {"LOCKT", + sumarg_lockt, sumres_lockt, dtlarg_lockt, dtlres_lockt}, + {"LOCKU", + sumarg_locku, sumres_locku, dtlarg_locku, dtlres_locku}, + {"LOOKUP", + sumarg_lookup, sum_nfsstat4, dtlarg_lookup, dtl_nfsstat4}, + {"LOOKUPP", /* 15 */ + NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, + {"NVERIFY", + NULL, sum_nfsstat4, dtlarg_verify, dtl_nfsstat4}, + {"OPEN", + sumarg_open, sumres_open, dtlarg_open, dtlres_open}, + {"OPENATTR", + sumarg_openattr, sum_nfsstat4, dtlarg_openattr, dtl_nfsstat4}, + {"OPEN_CONFIRM", + sumarg_open_confirm, + sumres_open_confirm, + dtlarg_open_confirm, + dtlres_open_confirm}, + {"OPEN_DOWNGRADE", + sumarg_open_downgrd, + sumres_open_downgrd, + dtlarg_open_downgrd, + dtlres_open_downgrd}, + {"PUTFH", + sumarg_putfh, sum_nfsstat4, dtlarg_putfh, dtl_nfsstat4}, + {"PUTPUBFH", /* 20 */ + NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, + {"PUTROOTFH", + NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, + {"READ", + sumarg_read, sumres_read, dtlarg_read, dtlres_read}, + {"READDIR", + sumarg_readdir, sumres_readdir, dtlarg_readdir, dtlres_readdir}, + {"READLINK", + NULL, sumres_readlnk, NULL, dtlres_readlnk}, + {"REMOVE", /* 25 */ + sumarg_compnt, sum_nfsstat4, dtlarg_compnt, dtlres_remove}, + {"RENAME", + sumarg_rename, sum_nfsstat4, dtlarg_rename, dtlres_rename}, + {"RENEW", + sumarg_renew, sum_nfsstat4, dtlarg_renew, dtl_nfsstat4}, + {"RESTOREFH", + NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, + {"SAVEFH", + NULL, sum_nfsstat4, NULL, dtl_nfsstat4}, + {"SECINFO", /* 30 */ + sumarg_secinfo, sumres_secinfo, dtlarg_secinfo, dtlres_secinfo}, + {"SETATTR", + sumarg_setattr, sumres_setattr, dtlarg_setattr, dtlres_setattr}, + {"SETCLIENTID", + sumarg_setclid, sumres_setclid, dtlarg_setclid, dtlres_setclid}, + {"SETCLIENTID_CONFIRM", + sumarg_setclid_cfm, + sum_nfsstat4, + dtlarg_setclid_cfm, + dtl_nfsstat4}, + {"VERIFY", + NULL, sum_nfsstat4, dtlarg_verify, dtl_nfsstat4}, + {"WRITE", + sumarg_write, sumres_write, dtlarg_write, dtlres_write}, + {"RELEASE_LOCKOWNER", + sumarg_release_lkown, sum_nfsstat4, + dtlarg_release_lkown, dtl_nfsstat4}, +}; +static uint_t num_opcodes = sizeof (opcode_info) / sizeof (op_info_t *); + +/* + * File types. + */ + +typedef struct { + char *short_name; /* for summary output */ + char *long_name; /* for detail output */ +} ftype_names_t; + +static ftype_names_t ftype_names[] = { + {"Type 0", "Type 0"}, + {"REG", "Regular File"}, + {"DIR", "Directory"}, + {"BLK", "Block Device"}, + {"CHR", "Character Device"}, + {"LNK", "Symbolic Link"}, /* 5 */ + {"SOCK", "Socket"}, + {"FIFO", "FIFO"}, + {"ATTRDIR", "Attribute Directory"}, + {"NAMEDATTR", "Named Attribute"}, +}; +static uint_t num_ftypes = sizeof (ftype_names) / sizeof (ftype_names_t); + +static ftype_names_t open_rflags[] = { + {"?", "UNKNOWN"}, /* 0 */ + {"CF", "CONFIRM"}, /* 1 */ + {"PL", "POSIX LOCK"}, /* 2 */ + {"?", "UNKNOWN"}, +}; +static uint_t num_open_rflags = + sizeof (open_rflags) / sizeof (ftype_names_t) - 1; + +static char *get_flags(uint_t, ftype_names_t *, uint_t, int, char *); + +#define sum_open_rflags(flag) \ + get_flags((flag), open_rflags, num_open_rflags, 1, " RF=") + +#define detail_open_rflags(flag) \ + get_flags((flag), open_rflags, num_open_rflags, 0, NULL) + +static void prt_supported_attrs(XDR *); +static void prt_type(XDR *); +static void prt_fh_expire_type(XDR *); +static void prt_change(XDR *); +static void prt_size(XDR *); +static void prt_link_support(XDR *); +static void prt_symlink_support(XDR *); +static void prt_named_attr(XDR *); +static void prt_fsid(XDR *); +static void prt_unique_handles(XDR *); +static void prt_lease_time(XDR *); +static void prt_rdattr_error(XDR *); +static void prt_acl(XDR *); +static void prt_aclsupport(XDR *); +static void prt_archive(XDR *); +static void prt_cansettime(XDR *); +static void prt_case_insensitive(XDR *); +static void prt_case_preserving(XDR *); +static void prt_chown_restricted(XDR *); +static void prt_filehandle(XDR *); +static void prt_fileid(XDR *); +static void prt_mounted_on_fileid(XDR *); +static void prt_files_avail(XDR *); +static void prt_files_free(XDR *); +static void prt_files_total(XDR *); +static void prt_fs_locations(XDR *); +static void prt_hidden(XDR *); +static void prt_homogeneous(XDR *); +static void prt_maxfilesize(XDR *); +static void prt_maxlink(XDR *); +static void prt_maxname(XDR *); +static void prt_maxread(XDR *); +static void prt_maxwrite(XDR *); +static void prt_mimetype(XDR *); +static void prt_mode(XDR *); +static void prt_no_trunc(XDR *); +static void prt_numlinks(XDR *); +static void prt_owner(XDR *); +static void prt_owner_group(XDR *); +static void prt_quota_avail_hard(XDR *); +static void prt_quota_avail_soft(XDR *); +static void prt_quota_used(XDR *); +static void prt_rawdev(XDR *); +static void prt_space_avail(XDR *); +static void prt_space_free(XDR *); +static void prt_space_total(XDR *); +static void prt_space_used(XDR *); +static void prt_system(XDR *); +static void prt_time_access(XDR *); +static void prt_time_access_set(XDR *); +static void prt_time_backup(XDR *); +static void prt_time_create(XDR *); +static void prt_time_delta(XDR *); +static void prt_time_metadata(XDR *); +static void prt_time_modify(XDR *); +static void prt_time_modify_set(XDR *); + + + +/* + * Information for attributes. + * name name of the attribute. + * prt_details function to XDR decode the attribute and print it. + * + * XXX If this table ever gets extensively changed (including + * reorganization to track changes to the spec), it would probably be a + * good idea to change to a scheme where the table is mechanically + * generated. Look at $SRC/uts/common/rpcsvc for how this is done in the + * kernel. + */ + +typedef struct { + char *name; + void (*prt_details)(XDR *); +} attr_info_t; + +static attr_info_t attr_info[MAX_ATTRIBUTES] = { + {"SUPPORTED_ATTRS", prt_supported_attrs}, + {"TYPE", prt_type}, + {"FH_EXPIRE_TYPE", prt_fh_expire_type}, + {"CHANGE", prt_change}, + {"SIZE", prt_size}, + {"LINK_SUPPORT", prt_link_support}, /* 5 */ + {"SYMLINK_SUPPORT", prt_symlink_support}, + {"NAMED_ATTR", prt_named_attr}, + {"FSID", prt_fsid}, + {"UNIQUE_HANDLES", prt_unique_handles}, + {"LEASE_TIME", prt_lease_time}, /* 10 */ + {"RDATTR_ERROR", prt_rdattr_error}, + {"ACL", prt_acl}, + {"ACLSUPPORT", prt_aclsupport}, + {"ARCHIVE", prt_archive}, + {"CANSETTIME", prt_cansettime}, /* 15 */ + {"CASE_INSENSITIVE", prt_case_insensitive}, + {"CASE_PRESERVING", prt_case_preserving}, + {"CHOWN_RESTRICTED", prt_chown_restricted}, + {"FILEHANDLE", prt_filehandle}, + {"FILEID", prt_fileid}, /* 20 */ + {"FILES_AVAIL", prt_files_avail}, + {"FILES_FREE", prt_files_free}, + {"FILES_TOTAL", prt_files_total}, + {"FS_LOCATIONS", prt_fs_locations}, + {"HIDDEN", prt_hidden}, /* 25 */ + {"HOMOGENEOUS", prt_homogeneous}, + {"MAXFILESIZE", prt_maxfilesize}, + {"MAXLINK", prt_maxlink}, + {"MAXNAME", prt_maxname}, + {"MAXREAD", prt_maxread}, /* 30 */ + {"MAXWRITE", prt_maxwrite}, + {"MIMETYPE", prt_mimetype}, + {"MODE", prt_mode}, + {"NO_TRUNC", prt_no_trunc}, + {"NUMLINKS", prt_numlinks}, /* 35 */ + {"OWNER", prt_owner}, + {"OWNER_GROUP", prt_owner_group}, + {"QUOTA_AVAIL_HARD", prt_quota_avail_hard}, + {"QUOTA_AVAIL_SOFT", prt_quota_avail_soft}, + {"QUOTA_USED", prt_quota_used}, /* 40 */ + {"RAWDEV", prt_rawdev}, + {"SPACE_AVAIL", prt_space_avail}, + {"SPACE_FREE", prt_space_free}, + {"SPACE_TOTAL", prt_space_total}, + {"SPACE_USED", prt_space_used}, /* 45 */ + {"SYSTEM", prt_system}, + {"TIME_ACCESS", prt_time_access}, + {"TIME_ACCESS_SET", prt_time_access_set}, + {"TIME_BACKUP", prt_time_backup}, + {"TIME_CREATE", prt_time_create}, /* 50 */ + {"TIME_DELTA", prt_time_delta}, + {"TIME_METADATA", prt_time_metadata}, + {"TIME_MODIFY", prt_time_modify}, + {"TIME_MODIFY_SET", prt_time_modify_set}, + {"MOUNTED_ON_FILEID", prt_mounted_on_fileid}, +}; + +extern char *get_sum_line(); + +extern jmp_buf xdr_err; + +static void sum_comp4res(char *, char *(*)(void)); +static char *sum_compound4args(void); +static char *sum_compound4res(void); +static char *sum_operand(nfs_argop4 *opp); +static char *sum_result(nfs_resop4 *resp); + +static char *sum_cb_compound4args(void); +static char *sum_cb_compound4res(void); +static char *sum_cb_operand(nfs_cb_argop4 *opp); +static char *sum_cb_result(nfs_cb_resop4 *resp); + +static void detail_acetype4(acetype4); +static void detail_uint32_bitmap(uint32_t, char *[], int); +static void detail_aceflag4(aceflag4); +static void detail_acemask4(acemask4); +static void detail_nfs_argop4(void); +static void detail_nfs_resop4(void); +static void detail_cb_argop4(void); +static void detail_cb_resop4(void); + +static char *attr_name(uint_t); +static char *claim_name(enum open_claim_type4 claim_type); +static char *delegation_type_name(enum open_delegation_type4 type); +static char *flavor_name(uint_t flavor); +static char *gss_svc_name(rpc_gss_svc_t svc); +static char *limitby_name(enum limit_by4 limitby); +static char *lock_type_name(enum nfs_lock_type4); +static char *opcode_name(uint_t); +static char *cb_opcode_name(uint_t opnum); +static char *status_name(int); +static char *status_name_compat(int); +static char *status_name_pcol(int); +static char *sum_type_name(nfs_ftype4); +static void sum_access4(char *buf, size_t buflen, uint32_t bits); +static void detail_access4(char *, uint32_t); +static void sum_claim(char *buf, size_t buflen, open_claim4 *claim); +static void detail_claim(open_claim4 *claim); +static char *sum_clientid(clientid4 client); +static void detail_clientid(clientid4 client); +static char *_sum_stateid(stateid4 *, char *prefix); +static void sum_delegation(char *buf, size_t buflen, open_delegation4 *delp); +static void detail_delegation(open_delegation4 *delp); +static void detail_lock_owner(lock_owner4 *owner); +static void detail_open_owner(open_owner4 *owner); +static void sum_openflag(char *bufp, int buflen, openflag4 *flagp); +static char *get_deleg_typestr(open_delegation_type4 dt); +static void detail_openflag(openflag4 *flagp); +static void sum_name(char *buf, size_t buflen, open_claim4 *claim); +static void detail_rpcsec_gss(rpcsec_gss_info *); +static void detail_secinfo4(secinfo4 *infop); +static char *sum_space_limit(nfs_space_limit4 *limitp); +static void detail_space_limit(nfs_space_limit4 *limitp); +static char *detail_type_name(nfs_ftype4); +static char *createhow4_name(createhow4 *crtp); + + +static void showxdr_utf8string(char *); +static char *utf8localize(utf8string *); +static void utf8free(void); +static void sum_pathname4(char *, size_t, pathname4 *); +static void detail_pathname4(pathname4 *pathp, char *); +static void sum_compname4(char *buf, size_t buflen, component4 *comp); +static void detail_compname4(component4 *comp); + +static void detail_fattr4(fattr4 *attrp); +static void detail_attr_bitmap(char *, bitmap4 *, unpkd_attrmap_t *); +static void sum_attr_bitmap(char *buf, size_t buflen, bitmap4 *mapp); +static void detail_fattr4_change(char *msg, fattr4_change chg); +static char *sum_fh4(nfs_fh4 *fhp); +static void detail_fh4(nfs_fh4 *fh); + +#define fh4_hash(fh) adler16((fh)->nfs_fh4_val, (fh)->nfs_fh4_len) +#define stateid_hash(st) adler16((st)->other, sizeof ((st)->other)) +#define owner_hash(own) adler16((own)->owner_val, (own)->owner_len) + +#define sum_deleg_stateid(st) _sum_stateid((st), "DST=") +#define sum_open_stateid(st) _sum_stateid((st), "OST=") +#define sum_lock_stateid(st) _sum_stateid((st), "LST=") +#define sum_stateid(st) _sum_stateid((st), "ST=") + +#define detail_deleg_stateid(st) _detail_stateid((st), "Delegation ") +#define detail_open_stateid(st) _detail_stateid((st), "Open ") +#define detail_lock_stateid(st) _detail_stateid((st), "Lock ") +#define detail_stateid(st) _detail_stateid((st), "") + +#define SPECIAL_STATEID0 "SPC0" +#define SPECIAL_STATEID1 "SPC1" + +#define DONT_CHANGE 0 +#define SET_TO_SERVER_TIME 1 +#define SET_TO_CLIENT_TIME 2 + +static stateid4 spec_stateid_0 = + {0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}; +static stateid4 spec_stateid_1 = + {0xFFFFFFFF, {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}; + +static char *procnames_short[] = { + "NULL4", /* 0 */ + "COMPOUND4" /* 1 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Compound", /* 1 */ +}; + +static char *cb_procnames_short[] = { + "CB_NULL", /* 0 */ + "CB_COMPOUND" /* 1 */ +}; + +static char *cb_procnames_long[] = { + "Null CallBack procedure", /* 0 */ + "CallBack compound", /* 1 */ +}; + +static char *acetype4_names[] = { + "ACE4_ACCESS_ALLOWED_ACE_TYPE", + "ACE4_ACCESS_DENIED_ACE_TYPE", + "ACE4_SYSTEM_AUDIT_ACE_TYPE", + "ACE4_SYSTEM_ALARM_ACE_TYPE" +}; +#define ACETYPE4_NAMES_MAX (sizeof (acetype4_names) / sizeof (char *)) + +static char *aceflag4_names[] = { + "ACE4_FILE_INHERIT_ACE", + "ACE4_DIRECTORY_INHERIT_ACE", + "ACE4_NO_PROPAGATE_INHERIT_ACE", + "ACE4_INHERIT_ONLY_ACE", + "ACE4_SUCCESSFUL_ACCESS_ACE_FLAG", + "ACE4_FAILED_ACCESS_ACE_FLAG", + "ACE4_IDENTIFIER_GROUP" +}; +#define ACEFLAG4_NAMES_MAX (sizeof (aceflag4_names) / sizeof (char *)) + +static char *acemask4_names[] = { + "ACE4_READ_DATA/ACE4_LIST_DIRECTORY", + "ACE4_WRITE_DATA/ACE4_ADD_FILE", + "ACE4_APPEND_DATA/ACE4_ADD_SUBDIRECTORY", + "ACE4_READ_NAMED_ATTRS", + "ACE4_WRITE_NAMED_ATTRS", + "ACE4_EXECUTE", + "ACE4_DELETE_CHILD", + "ACE4_READ_ATTRIBUTES", + "ACE4_WRITE_ATTRIBUTES", + "UNDEFINED", /* 0x00000200 */ + "UNDEFINED", /* 0x00000400 */ + "UNDEFINED", /* 0x00000800 */ + "UNDEFINED", /* 0x00001000 */ + "UNDEFINED", /* 0x00002000 */ + "UNDEFINED", /* 0x00004000 */ + "UNDEFINED", /* 0x00008000 */ + "ACE4_DELETE", + "ACE4_READ_ACL", + "ACE4_WRITE_ACL", + "ACE4_WRITE_OWNER", + "ACE4_SYNCHRONIZE" +}; +#define ACEMASK4_NAMES_MAX (sizeof (acemask4_names) / sizeof (char *)) + +#define MAXPROC 1 + +/*ARGSUSED*/ +void +interpret_nfs4_cb(int flags, int type, int xid, int vers, int proc, + char *data, int len) +{ + char *line = NULL; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS C %s", + proc == CB_COMPOUND ? "CB4" : + cb_procnames_short[proc]); + line += strlen(line); + + if (proc == CB_COMPOUND) { + static utf8string tag; + + if (!xdr_utf8string(&xdrm, &tag)) + longjmp(xdr_err, 1); + sprintf(line, " (%.20s) %s", + utf8localize(&tag), + sum_cb_compound4args()); + xdr_free(xdr_utf8string, (char *)&tag); + } + check_retransmit(line, xid); + } else { + (void) sprintf(line, "NFS R %s ", + proc == CB_COMPOUND ? "CB4" : + cb_procnames_short[proc]); + line += strlen(line); + if (proc == CB_COMPOUND) + sum_comp4res(line, sum_cb_compound4res); + } + } + + if (flags & F_DTAIL) { + show_header("NFS: ", "Sun NFS4 CallBack", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, cb_procnames_long[proc]); + if (proc == CB_COMPOUND) { + if (type == CALL) { + showxdr_utf8string("Tag = %s"); + detail_cb_argop4(); + } else { + nfsstat4 status; + + status = getxdr_long(); + showxdr_utf8string("Tag = %s"); + sprintf(get_line(0, 0), "Status = %d (%s)", + status, status_name(status)); + detail_cb_resop4(); + } + } + show_trailer(); + } + + utf8free(); /* cf. utf8localize() */ +} + + +/*ARGSUSED*/ +void +interpret_nfs4(int flags, int type, int xid, int vers, int proc, + char *data, int len) +{ + char *line = NULL; + + if (proc < 0 || proc > MAXPROC) + return; + + nfs4_fragged_rpc = 0; + nfs4_pkt_len = len; + nfs4_pkt_start = xdr_getpos(&xdrm); + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS C %s", + proc == NFSPROC4_COMPOUND ? "4" : + procnames_short[proc]); + line += strlen(line); + + if (proc == NFSPROC4_COMPOUND) { + static utf8string tag; + + if (!xdr_utf8string(&xdrm, &tag)) + longjmp(xdr_err, 1); + sprintf(line, " (%.20s) %s", + utf8localize(&tag), + sum_compound4args()); + xdr_free(xdr_utf8string, (char *)&tag); + } + check_retransmit(line, xid); + } else { + (void) sprintf(line, "NFS R %s ", + proc == NFSPROC4_COMPOUND ? "4" : + procnames_short[proc]); + line += strlen(line); + + if (proc == NFSPROC4_COMPOUND) + sum_comp4res(line, sum_compound4res); + } + } + + if (flags & F_DTAIL) { + show_header("NFS: ", "Sun NFS", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long[proc]); + if (proc == NFSPROC4_COMPOUND) { + if (type == CALL) { + showxdr_utf8string("Tag = %s"); + detail_nfs_argop4(); + } else { + nfsstat4 status; + + status = getxdr_long(); + showxdr_utf8string("Tag = %s"); + sprintf(get_line(0, 0), "Status = %d (%s)", + status, status_name(status)); + detail_nfs_resop4(); + } + } + show_trailer(); + } + + utf8free(); /* cf. utf8localize() */ +} + + + +/* + * Return the names and arguments of the oplist elements, up to + * SUM_COMPND_MAX characters. If the elements don't fit, include a "..." + * at the end of the string. + */ + +static char * +sum_compound4args(void) +{ + static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ + int numops; + const size_t buflen = sizeof (buf); + char *bp; + nfs_argop4 one_op; + uint32_t minor_version; + + buf[0] = '\0'; + + if (setjmp(xdr_err)) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), + nfs4_fragged_rpc ? nfs4err_fragrpc : nfs4err_xdrfrag); + return (buf); + } + + /* + * might be nice to print minor version, but doesn't + * seem like very useful info for summary mode + */ + if (!xdr_uint32_t(&xdrm, &minor_version)) + longjmp(xdr_err, 1); + + numops = getxdr_long(); + bp = buf; + while (numops-- > 0) { + char *operand; + + bzero(&one_op, sizeof (one_op)); + + if (!xdr_nfs_argop4(&xdrm, &one_op)) { + xdr_free(xdr_nfs_argop4, (char *)&one_op); + longjmp(xdr_err, 1); + } + snprintf(bp, buflen - (bp - buf), "%s ", + opcode_name(one_op.argop)); + bp += strlen(bp); + + operand = sum_operand(&one_op); + if (strlen(operand) > 0) { + snprintf(bp, buflen - (bp - buf), "%s ", operand); + bp += strlen(bp); + } + + /* nfs4_skip_bytes set by xdr_nfs4_argop4 */ + if (nfs4_skip_bytes != 0) + nfs4_xdr_skip(nfs4_skip_bytes); + + xdr_free(xdr_nfs_argop4, (char *)&one_op); + + /* add "..." if past the "end" of the buffer */ + if (bp - buf > SUM_COMPND_MAX) { + strcpy(buf + SUM_COMPND_MAX - strlen("..."), + "..."); + break; + } + } + + return (buf); +} + +static void +nfs4_xdr_skip(int nbytes) +{ + int resid, off, len, cur_pos, new_pos; + + len = RNDUP(nbytes); + cur_pos = xdr_getpos(&xdrm); + + /* + * Time to skip over the rd/wr data. If the + * rd/wr data is completely contained in the first + * frag, we must skip over it to process the rest of + * the packet. + * + * nfs4_pkt_start: XDR position of start of NFS4 compound + * nfs4_pkt_len: number of bytes in pkt relative to + * nfs4_pkt_start + * + * cur_pos: current XDR position + * off: current XDR position relative to nfs4_pkt_start + * resid: number of unprocessed bytes in current pkt + * (relative to cur_pos/off) + * + * If nbytes <= resid, then we must skip over the rd/wr + * bytes so we can read the next op/compound in this + * packet. Otherwise, set the fragged flag so we can + * display the fragged_rpc message. + */ + off = cur_pos - nfs4_pkt_start; + resid = nfs4_pkt_len - off; + + /* + * set nfs4_fragged_rpc if the requested number of "skip" + * bytes is larger than the bytes remaining in the XDR + * stream/current packet. The global is reset to 0 at + * start of interpret_nfs4. + */ + new_pos = cur_pos + ((nfs4_fragged_rpc = len > resid) ? resid : len); + + /* there's nothing to do for error case (if it fails pkt is doomed) */ + xdr_setpos(&xdrm, new_pos); +} + + +/* + * Return the names and arguments of the oplist elements, up to + * SUM_COMPND_MAX characters. If the elements don't fit, include a "..." + * at the end of the string. + */ +static char * +sum_cb_compound4args(void) +{ + static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ + int numops; + const size_t buflen = sizeof (buf); + char *bp; + nfs_cb_argop4 one_op; + uint32_t minor_version, callback_ident; + + buf[0] = '\0'; + if (setjmp(xdr_err)) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), "<XDR Error or Fragmented" + " RPC>"); + return (buf); + } + + /* + * might be nice to print minor version, but doesn't + * seem like very useful info for summary mode + */ + if (!xdr_uint32_t(&xdrm, &minor_version)) + longjmp(xdr_err, 1); + + /* print callback_ident */ + if (!xdr_uint32_t(&xdrm, &callback_ident)) + longjmp(xdr_err, 1); + snprintf(buf, buflen, "CBID=%u ", callback_ident); + + bp = buf + strlen(buf); + numops = getxdr_long(); + + while (numops-- > 0) { + char *operand; + + bzero(&one_op, sizeof (one_op)); + if (!xdr_nfs_cb_argop4(&xdrm, &one_op)) { + xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); + longjmp(xdr_err, 1); + } + + snprintf(bp, buflen - (bp - buf), "%s ", + cb_opcode_name(one_op.argop)); + bp += strlen(bp); + operand = sum_cb_operand(&one_op); + if (strlen(operand) > 0) { + snprintf(bp, buflen - (bp - buf), "%s ", operand); + bp += strlen(bp); + } + + xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); + + /* add "..." if past the "end" of the buffer */ + if (bp - buf > SUM_COMPND_MAX) { + strcpy(buf + SUM_COMPND_MAX - strlen("..."), + "..."); + break; + } + } + + return (buf); +} + +/* + * Return the summarized argument list for the given nfs_argop4. + */ + +static char * +sum_operand(nfs_argop4 *opp) +{ + static char buf[1024]; + void (*fmtproc)(char *, size_t, void *); + + buf[0] = '\0'; + if (opp->argop < num_opcodes) { + fmtproc = opcode_info[opp->argop].sumarg; + if (fmtproc != NULL) + fmtproc(buf, sizeof (buf), &opp->nfs_argop4_u); + } + + return (buf); +} + +/* + * Return the summarized argument list for the given nfs_argop4. + */ + +static char * +sum_cb_operand(nfs_cb_argop4 *opp) +{ + static char buf[1024]; + void (*fmtproc)(char *, size_t, void *); + + buf[0] = '\0'; + if (opp->argop < cb_num_opcodes) { + fmtproc = cb_opcode_info[opp->argop].sumarg; + if (fmtproc != NULL) + fmtproc(buf, sizeof (buf), &opp->nfs_cb_argop4_u); + } + + return (buf); +} + +/* + * Print details about the nfs_argop4 that is next in the XDR stream. + */ + +static void +detail_nfs_argop4(void) +{ + int numops; + nfs_argop4 one_op; + void (*fmtproc)(void *); + uint32_t minor_version; + + if (!xdr_uint32_t(&xdrm, &minor_version)) + longjmp(xdr_err, 1); + + (void) sprintf(get_line(0, 0), "Minor version = %u", + minor_version); + + numops = getxdr_long(); + (void) sprintf(get_line(0, 0), "Number of operations = %d", + numops); + + while (numops-- > 0) { + bzero(&one_op, sizeof (one_op)); + + if (!xdr_nfs_argop4(&xdrm, &one_op)) { + xdr_free(xdr_nfs_argop4, (char *)&one_op); + longjmp(xdr_err, 1); + } + + get_line(0, 0); /* blank line to separate ops */ + sprintf(get_line(0, 0), "Op = %d (%s)", + one_op.argop, opcode_name(one_op.argop)); + if (one_op.argop < num_opcodes) { + fmtproc = opcode_info[one_op.argop].dtlarg; + if (fmtproc != NULL) + fmtproc(&one_op.nfs_argop4_u); + } + + /* nfs4_skip_bytes set by xdr_nfs_argop4() */ + if (nfs4_skip_bytes) + nfs4_xdr_skip(nfs4_skip_bytes); + + xdr_free(xdr_nfs_argop4, (char *)&one_op); + } +} + + +/* + * Print details about the nfs_argop4 that is next in the XDR stream. + */ +static void +detail_cb_argop4(void) +{ + int numops; + nfs_cb_argop4 one_op; + void (*fmtproc)(void *); + uint32_t minor_version, callback_ident; + + if (!xdr_uint32_t(&xdrm, &minor_version)) + longjmp(xdr_err, 1); + (void) sprintf(get_line(0, 0), "Minor version = %u", + minor_version); + + if (!xdr_uint32_t(&xdrm, &callback_ident)) + longjmp(xdr_err, 1); + (void) sprintf(get_line(0, 0), "Callback Ident = %u", + callback_ident); + + numops = getxdr_long(); + (void) sprintf(get_line(0, 0), "Number of operations = %d", + numops); + + while (numops-- > 0) { + bzero(&one_op, sizeof (one_op)); + if (!xdr_nfs_cb_argop4(&xdrm, &one_op)) { + xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); + longjmp(xdr_err, 1); + } + + get_line(0, 0); /* blank line to separate ops */ + sprintf(get_line(0, 0), "Op = %d (%s)", + one_op.argop, cb_opcode_name(one_op.argop)); + if (one_op.argop < cb_num_opcodes) { + fmtproc = cb_opcode_info[one_op.argop].dtlarg; + if (fmtproc != NULL) + fmtproc(&one_op.nfs_cb_argop4_u); + } + + xdr_free(xdr_nfs_cb_argop4, (char *)&one_op); + } +} + +/* + * component_name: return a printable string for the given component4. I'm + * leaving this as a separate function (as opposed to having the callers + * call utf8localize() directly) in case the definition of component4 + * changes. + */ + +static char * +component_name(component4 *cp) +{ + return (utf8localize(cp)); +} + +/* + * linktext_name. cf. component_name(). + */ + +static char * +linktext_name(linktext4 *lp) +{ + return (utf8localize(lp)); +} + +/* + * stable_how4_name: return a string for "how". + */ + +static char * +stable_how4_name(stable_how4 how) +{ + char *result; + + switch (how) { + case UNSTABLE4: + result = "ASYNC"; + break; + case DATA_SYNC4: + result = "DSYNC"; + break; + case FILE_SYNC4: + result = "FSYNC"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * sum_open_share_access: return a string corresponding to the + * given OPEN share access bitmask. + */ + +static char * +sum_open_share_access(int32_t mask) +{ + char *result; + + switch (mask) { + case 0: + result = "N"; + break; + case OPEN4_SHARE_ACCESS_READ: + result = "R"; + break; + case OPEN4_SHARE_ACCESS_WRITE: + result = "W"; + break; + case OPEN4_SHARE_ACCESS_BOTH: + result = "RW"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * sum_open_share_deny: return a string corresponding to the + * given OPEN share deny bitmask. + */ + +static char * +sum_open_share_deny(int32_t mask) +{ + char *result; + + switch (mask) { + case OPEN4_SHARE_DENY_NONE: + result = "N"; + break; + case OPEN4_SHARE_DENY_READ: + result = "R"; + break; + case OPEN4_SHARE_DENY_WRITE: + result = "W"; + break; + case OPEN4_SHARE_DENY_BOTH: + result = "RW"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +static int +special_stateid(stateid4 *stateid) +{ + + if (! memcmp(stateid, &spec_stateid_0, sizeof (*stateid))) + return (0); + + if (! memcmp(stateid, &spec_stateid_1, sizeof (*stateid))) + return (1); + + return (-1); +} + +static char * +_sum_stateid(stateid4 *stateid, char *prefix) +{ + static char buf[32]; + int spec; + + if ((spec = special_stateid(stateid)) < 0) + snprintf(buf, sizeof (buf), "%s%04X:%u", prefix, + stateid_hash(stateid), stateid->seqid); + else + snprintf(buf, sizeof (buf), "%s%s", prefix, + spec == 0 ? "SPC0" : (spec == 1 ? "SPC1" : "SPC?")); + return (buf); +} + +static void +_detail_stateid(stateid4 *stateid, char *prefix) +{ + int spec; + char seqstr[32] = {0}; + + spec = special_stateid(stateid); + + if (spec < 0) + sprintf(get_line(0, 0), "%sState ID hash = %04X", + prefix, stateid_hash(stateid)); + else + sprintf(get_line(0, 0), "%sState ID hash = %s", prefix, + spec == 0 ? "SPECIAL_0" : + (spec == 1 ? "SPECIAL_1" : "SPECIAL_?")); + + sprintf(get_line(0, 0), " len = %u val = %s", + sizeof (stateid->other), + tohex(stateid->other, sizeof (stateid->other))); + + /* + * If spec 0/1 stateid, print seqid in hex; otherwise, + * use decimal. This makes it more clear how spec stateids + * are constructed [obvious that either all bits are 0, or all + * bits are 1]. + */ + if (spec == -1) + sprintf(seqstr, "%d", stateid->seqid); + else + sprintf(seqstr, "%08X", stateid->seqid); + + sprintf(get_line(0, 0), " %sState ID Sequence ID = %s", + prefix, seqstr); +} + + +static char * +sum_lock_denied(LOCK4denied *denied) +{ + static char buf[64]; + + sprintf(buf, "%s %llu %llu LO=%04X", + sum_lock_type_name(denied->locktype), + denied->offset, denied->length, + owner_hash(&denied->owner.owner)); + + return (buf); +} + +static void +detail_lock_denied(LOCK4denied *denied) +{ + sprintf(get_line(0, 0), "Type = %s", lock_type_name(denied->locktype)); + detail_lock_owner(&denied->owner); + sprintf(get_line(0, 0), "Offset = %llu", denied->offset); + sprintf(get_line(0, 0), "Length = %llu", denied->length); +} + +/* + * sum_createhow4: return the string name of "how". + */ + +static char * +createhow4_name(createhow4 *crtp) +{ + char *result; + + switch (crtp->mode) { + case UNCHECKED4: + result = "UNCHECKED"; + break; + case GUARDED4: + result = "GUARDED"; + break; + case EXCLUSIVE4: + result = "EXCLUSIVE"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * detail_createhow4: print detail information about "how". + */ + +static void +detail_createhow4(createhow4 *crtp) +{ + sprintf(get_line(0, 0), "Method = %s", + createhow4_name(crtp)); + + switch (crtp->mode) { + case UNCHECKED4: + case GUARDED4: + detail_fattr4(&crtp->createhow4_u.createattrs); + break; + case EXCLUSIVE4: + sprintf(get_line(0, 0), " Verifier = %s", + tohex(crtp->createhow4_u.createverf, + NFS4_VERIFIER_SIZE)); + break; + } +} + +static void +detail_createtype4(createtype4 *crtp) +{ + sprintf(get_line(0, 0), "Type = %s", + detail_type_name(crtp->type)); + switch (crtp->type) { + case NF4LNK: + sprintf(get_line(0, 0), "Linkdata = %s", + utf8localize(&crtp->createtype4_u.linkdata)); + break; + case NF4BLK: + case NF4CHR: + sprintf(get_line(0, 0), "Specdata1 = %04x Specdata2 = %04x", + crtp->createtype4_u.devdata.specdata1, + crtp->createtype4_u.devdata.specdata2); + break; + default: + break; + } +} + +static void +sumarg_access(char *buf, size_t buflen, void *obj) +{ + ACCESS4args *args = (ACCESS4args *)obj; + + sum_access4(buf, buflen, args->access); +} + +static void +dtlarg_access(void *obj) +{ + ACCESS4args *args = (ACCESS4args *)obj; + + detail_access4("Access bits", args->access); +} + +static void +sumarg_close(char *buf, size_t buflen, void *obj) +{ + CLOSE4args *args = (CLOSE4args *)obj; + + snprintf(buf, buflen, "SQ=%u %s", + args->seqid, sum_open_stateid(&args->open_stateid)); +} + +static void +dtlarg_close(void *obj) +{ + CLOSE4args *args = (CLOSE4args *)obj; + + detail_open_stateid(&args->open_stateid); + sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); +} + +static void +sumarg_commit(char *buf, size_t buflen, void *obj) +{ + COMMIT4args *args = (COMMIT4args *)obj; + + snprintf(buf, buflen, "at %llu for %u ", args->offset, + args->count); +} + +static void +dtlarg_commit(void *obj) +{ + COMMIT4args *args = (COMMIT4args *)obj; + + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Count = %u", args->count); +} + +static void +sumarg_compnt(char *buf, size_t buflen, void *obj) +{ + component4 *comp = (component4 *)obj; + + snprintf(buf, buflen, "%s", component_name(comp)); +} + +static void +dtlarg_compnt(void *obj) +{ + component4 *comp = (component4 *)obj; + + sprintf(get_line(0, 0), "Name = %s", component_name(comp)); +} + +static void +sumarg_create(char *buf, size_t buflen, void *obj) +{ + CREATE4args *args = (CREATE4args *)obj; + + snprintf(buf, buflen, "%s %s ", component_name(&args->objname), + sum_type_name(args->objtype.type)); +} + +static void +dtlarg_create(void *obj) +{ + CREATE4args *args = (CREATE4args *)obj; + + sprintf(get_line(0, 0), "Name = %s", component_name(&args->objname)); + detail_createtype4(&args->objtype); + detail_fattr4(&args->createattrs); +} + +static void +sumarg_delprge(char *buf, size_t buflen, void *obj) +{ + DELEGPURGE4args *args = (DELEGPURGE4args *)obj; + + snprintf(buf, buflen, "%s", sum_clientid(args->clientid)); +} + +static void +dtlarg_delprge(void *obj) +{ + DELEGPURGE4args *args = (DELEGPURGE4args *)obj; + + detail_clientid(args->clientid); +} + +static void +sumarg_delret(char *buf, size_t buflen, void *obj) +{ + DELEGRETURN4args *args = (DELEGRETURN4args *)obj; + + snprintf(buf, buflen, "%s", sum_deleg_stateid(&args->deleg_stateid)); +} + +static void +dtlarg_delret(void *obj) +{ + DELEGRETURN4args *args = (DELEGRETURN4args *)obj; + + detail_deleg_stateid(&args->deleg_stateid); +} + +static void +sumarg_getattr(char *buf, size_t buflen, void *obj) +{ + GETATTR4args *args = (GETATTR4args *)obj; + + sum_attr_bitmap(buf, buflen, &args->attr_request); +} + +static void +dtlarg_getattr(void *obj) +{ + GETATTR4args *args = (GETATTR4args *)obj; + + detail_attr_bitmap("", &args->attr_request, NULL); +} + +static void +sumarg_cb_getattr(char *buf, size_t buflen, void *obj) +{ + CB_GETATTR4args *args = (CB_GETATTR4args *)obj; + char *bp = buf; + + snprintf(bp, buflen, "%s ", sum_fh4(&args->fh)); + bp += strlen(bp); + sum_attr_bitmap(bp, buflen - (bp - buf), &args->attr_request); +} + +static void +dtlarg_cb_getattr(void *obj) +{ + CB_GETATTR4args *args = (CB_GETATTR4args *)obj; + + detail_fh4(&args->fh); + detail_attr_bitmap("", &args->attr_request, NULL); +} + +static void +sumarg_cb_recall(char *buf, size_t buflen, void *obj) +{ + CB_RECALL4args *args = (CB_RECALL4args *)obj; + char *bp = buf; + + snprintf(bp, buflen, "%s %s TR=%s", sum_fh4(&args->fh), + sum_stateid(&args->stateid), args->truncate ? "T" : "F"); +} + +static void +dtlarg_cb_recall(void *obj) +{ + CB_RECALL4args *args = (CB_RECALL4args *)obj; + + detail_fh4(&args->fh); + detail_stateid(&args->stateid); + sprintf(get_line(0, 0), "Truncate = %s", + args->truncate ? "True" : "False"); +} + + +/* + * name openhow seqid claim access deny owner + */ +static void +sumarg_open(char *buf, size_t buflen, void *obj) +{ + OPEN4args *args = (OPEN4args *)obj; + char *bp = buf; + int blen = buflen, len; + + sum_name(bp, buflen, &args->claim); + bp += (len = strlen(bp)); + blen -= len; + + sum_openflag(bp, blen, &args->openhow); + bp += (len = strlen(bp)); + blen -= len; + + snprintf(bp, blen, " SQ=%u", args->seqid); + bp += (len = strlen(bp)); + blen -= len; + + sum_claim(bp, blen, &args->claim); + bp += (len = strlen(bp)); + blen -= len; + + snprintf(bp, blen, " AC=%s DN=%s OO=%04X", + sum_open_share_access(args->share_access), + sum_open_share_deny(args->share_deny), + owner_hash(&args->owner.owner)); +} + +static void +dtlarg_open(void *obj) +{ + OPEN4args *args = (OPEN4args *)obj; + + detail_claim(&args->claim); + detail_openflag(&args->openhow); + detail_open_owner(&args->owner); + sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); + sprintf(get_line(0, 0), "Access = 0x%x (%s)", + args->share_access, sum_open_share_access(args->share_access)); + sprintf(get_line(0, 0), "Deny = 0x%x (%s)", + args->share_deny, sum_open_share_access(args->share_deny)); +} + +static void +sumarg_openattr(char *buf, size_t buflen, void *obj) +{ + OPENATTR4args *args = (OPENATTR4args *)obj; + + snprintf(buf, buflen, "CD=%s", + args->createdir ? "T" : "F"); +} + +static void +dtlarg_openattr(void *obj) +{ + OPENATTR4args *args = (OPENATTR4args *)obj; + + sprintf(get_line(0, 0), "CreateDir = %s", + args->createdir ? "True" : "False"); +} + +static void +sumarg_open_confirm(char *buf, size_t buflen, void *obj) +{ + char *bp = buf; + OPEN_CONFIRM4args *args = (OPEN_CONFIRM4args *)obj; + + snprintf(bp, buflen, "SQ=%u %s", args->seqid, + sum_open_stateid(&args->open_stateid)); +} + +static void +dtlarg_open_confirm(void *obj) +{ + OPEN_CONFIRM4args *args = (OPEN_CONFIRM4args *)obj; + + sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); + detail_open_stateid(&args->open_stateid); +} + +static void +sumarg_open_downgrd(char *buf, size_t buflen, void *obj) +{ + OPEN_DOWNGRADE4args *args = (OPEN_DOWNGRADE4args *)obj; + + snprintf(buf, buflen, "SQ=%u %s AC=%s DN=%s", + args->seqid, sum_open_stateid(&args->open_stateid), + sum_open_share_access(args->share_access), + sum_open_share_deny(args->share_deny)); +} + +static void +dtlarg_open_downgrd(void *obj) +{ + OPEN_DOWNGRADE4args *args = (OPEN_DOWNGRADE4args *)obj; + + sprintf(get_line(0, 0), "Open Sequence ID = %u", args->seqid); + detail_open_stateid(&args->open_stateid); + sprintf(get_line(0, 0), "Access = 0x%x (%s)", + args->share_access, sum_open_share_access(args->share_access)); + sprintf(get_line(0, 0), "Deny = 0x%x (%s)", + args->share_deny, sum_open_share_access(args->share_deny)); +} + +static void +sumarg_putfh(char *buf, size_t buflen, void *obj) +{ + PUTFH4args *args = (PUTFH4args *)obj; + + snprintf(buf, buflen, "%s", sum_fh4(&args->object)); +} + +static void +dtlarg_putfh(void *obj) +{ + PUTFH4args *args = (PUTFH4args *)obj; + + detail_fh4(&args->object); +} + +static void +sumarg_link(char *buf, size_t buflen, void *obj) +{ + LINK4args *args = (LINK4args *)obj; + + snprintf(buf, buflen, "%s", component_name(&args->newname)); +} + +static void +dtlarg_link(void *obj) +{ + LINK4args *args = (LINK4args *)obj; + + sprintf(get_line(0, 0), "New name = %s", + component_name(&args->newname)); +} + +static void +sum_open_to_lock_owner(char *buf, int buflen, open_to_lock_owner4 *own) +{ + snprintf(buf, buflen, " OSQ=%u %s LSQ=%u LO=%04X", own->open_seqid, + sum_open_stateid(&own->open_stateid), own->lock_seqid, + owner_hash(&own->lock_owner.owner)); +} + +static void +sum_exist_lock_owner(char *buf, int buflen, exist_lock_owner4 *own) +{ + snprintf(buf, buflen, " LSQ=%u %s", own->lock_seqid, + sum_lock_stateid(&own->lock_stateid)); +} + +static void +sum_locker(char *buf, size_t len, locker4 *lk) +{ + if (lk->new_lock_owner == TRUE) + sum_open_to_lock_owner(buf, len, &lk->locker4_u.open_owner); + else + sum_exist_lock_owner(buf, len, &lk->locker4_u.lock_owner); +} + +static char * +sum_lock_type_name(enum nfs_lock_type4 type) +{ + char *result; + + switch (type) { + case READ_LT: + result = "RD"; + break; + case WRITE_LT: + result = "WR"; + break; + case READW_LT: + result = "RDW"; + break; + case WRITEW_LT: + result = "WRW"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +static void +sumarg_lock(char *buf, size_t buflen, void *obj) +{ + LOCK4args *args = (LOCK4args *)obj; + char *bp = buf; + + snprintf(buf, buflen, "%s%s%llu:%llu", + sum_lock_type_name(args->locktype), + args->reclaim ? " reclaim " : " ", + args->offset, args->length); + + bp += strlen(buf); + sum_locker(bp, buflen - (bp - buf), &args->locker); +} + +static void +detail_open_to_lock_owner(open_to_lock_owner4 *own) +{ + sprintf(get_line(0, 0), "Open Sequence ID = %u", own->open_seqid); + detail_open_stateid(&own->open_stateid); + sprintf(get_line(0, 0), "Lock Sequence ID = %u", own->lock_seqid); + detail_lock_owner(&own->lock_owner); +} + +static void +detail_exist_lock_owner(exist_lock_owner4 *own) +{ + detail_lock_stateid(&own->lock_stateid); + sprintf(get_line(0, 0), "Lock Sequence ID = %u", own->lock_seqid); +} + +static void +detail_locker(locker4 *lk) +{ + if (lk->new_lock_owner == TRUE) + detail_open_to_lock_owner(&lk->locker4_u.open_owner); + else + detail_exist_lock_owner(&lk->locker4_u.lock_owner); +} + +static void +dtlarg_lock(void *obj) +{ + LOCK4args *args = (LOCK4args *)obj; + + sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); + sprintf(get_line(0, 0), "Reclaim = %s", + args->reclaim ? "TRUE" : "FALSE"); + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Length = %llu", args->length); + detail_locker(&args->locker); +} + +static void +sumarg_lockt(char *buf, size_t buflen, void *obj) +{ + LOCKT4args *args = (LOCKT4args *)obj; + + snprintf(buf, buflen, "R=%llu:%llu", + args->offset, args->length); +} + +static void +dtlarg_lockt(void *obj) +{ + LOCKT4args *args = (LOCKT4args *)obj; + + sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); + detail_lock_owner(&args->owner); + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Length = %llu", args->length); +} + +static void +sumarg_locku(char *buf, size_t buflen, void *obj) +{ + LOCKU4args *args = (LOCKU4args *)obj; + + snprintf(buf, buflen, "R=%llu:%llu LSQ=%u %s", + args->offset, args->length, args->seqid, + sum_lock_stateid(&args->lock_stateid)); +} + + +static void +dtlarg_locku(void *obj) +{ + LOCKU4args *args = (LOCKU4args *)obj; + + sprintf(get_line(0, 0), "Type = %s", lock_type_name(args->locktype)); + sprintf(get_line(0, 0), "Sequence ID = %u", args->seqid); + detail_lock_stateid(&args->lock_stateid); + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Length = %llu", args->length); +} + +static void +sumarg_lookup(char *buf, size_t buflen, void *obj) +{ + LOOKUP4args *args = (LOOKUP4args *)obj; + + sum_compname4(buf, buflen, &args->objname); +} + +static void +dtlarg_lookup(void *obj) +{ + LOOKUP4args *args = (LOOKUP4args *)obj; + + detail_compname4(&args->objname); +} + +static void +sumarg_read(char *buf, size_t buflen, void *obj) +{ + READ4args *args = (READ4args *)obj; + + snprintf(buf, buflen, "%s at %llu for %u", + sum_stateid(&args->stateid), args->offset, args->count); +} + +static void +dtlarg_read(void *obj) +{ + READ4args *args = (READ4args *)obj; + + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Count = %u", args->count); + detail_stateid(&args->stateid); +} + +static void +sumarg_readdir(char *buf, size_t buflen, void *obj) +{ + READDIR4args *args = (READDIR4args *)obj; + + snprintf(buf, buflen, "Cookie=%llu (%s) for %u/%u", + args->cookie, tohex(args->cookieverf, NFS4_VERIFIER_SIZE), + args->dircount, args->maxcount); +} + +static void +dtlarg_readdir(void *obj) +{ + READDIR4args *args = (READDIR4args *)obj; + + sprintf(get_line(0, 0), "Cookie = %llu", args->cookie); + sprintf(get_line(0, 0), "Verifier = %s", + tohex(args->cookieverf, NFS4_VERIFIER_SIZE)); + sprintf(get_line(0, 0), "Dircount = %u", args->dircount); + sprintf(get_line(0, 0), "Maxcount = %u", args->maxcount); + detail_attr_bitmap("", &args->attr_request, NULL); +} + +static void +dtlarg_release_lkown(void *obj) +{ + RELEASE_LOCKOWNER4args *args = (RELEASE_LOCKOWNER4args *)obj; + + detail_lock_owner(&args->lock_owner); +} + +static void +sumarg_release_lkown(char *buf, size_t buflen, void *obj) + +{ + RELEASE_LOCKOWNER4args *args = (RELEASE_LOCKOWNER4args *)obj; + + snprintf(buf, buflen, "LO=%04X", owner_hash(&args->lock_owner.owner)); +} + +static void +sumarg_rename(char *buf, size_t buflen, void *obj) +{ + RENAME4args *args = (RENAME4args *)obj; + + snprintf(buf, buflen, "%s to %s", + component_name(&args->oldname), + component_name(&args->newname)); +} + +static void +dtlarg_rename(void *obj) +{ + RENAME4args *args = (RENAME4args *)obj; + + sprintf(get_line(0, 0), "Old name = %s", + component_name(&args->oldname)); + sprintf(get_line(0, 0), "New name = %s", + component_name(&args->newname)); +} + +static void +sumarg_renew(char *buf, size_t buflen, void *obj) +{ + RENEW4args *args = (RENEW4args *)obj; + + snprintf(buf, buflen, "%s", sum_clientid(args->clientid)); +} +static void +dtlarg_renew(void *obj) +{ + RENEW4args *args = (RENEW4args *)obj; + + detail_clientid(args->clientid); +} + +static void +sumarg_secinfo(char *buf, size_t buflen, void *obj) +{ + SECINFO4args *args = (SECINFO4args *)obj; + + snprintf(buf, buflen, "%s", + component_name(&args->name)); +} + +static void +dtlarg_secinfo(void *obj) +{ + SECINFO4args *args = (SECINFO4args *)obj; + + sprintf(get_line(0, 0), "Name = %s", + component_name(&args->name)); +} + +static void +sumarg_setattr(char *buf, size_t buflen, void *obj) +{ + SETATTR4args *args = (SETATTR4args *)obj; + + snprintf(buf, buflen, "%s", sum_stateid(&args->stateid)); +} + +static void +dtlarg_setattr(void *obj) +{ + SETATTR4args *args = (SETATTR4args *)obj; + + detail_stateid(&args->stateid); + detail_fattr4(&args->obj_attributes); +} + +static void +sumarg_setclid(char *buf, size_t buflen, void *obj) +{ + SETCLIENTID4args *args = (SETCLIENTID4args *)obj; + + snprintf(buf, buflen, "Prog=%u ID=%s Addr=%s CBID=%u", + args->callback.cb_program, + args->callback.cb_location.r_netid, + args->callback.cb_location.r_addr, args->callback_ident); +} + +static void +dtlarg_setclid(void *obj) +{ + SETCLIENTID4args *args = (SETCLIENTID4args *)obj; + + sprintf(get_line(0, 0), "Verifier=%s", + tohex(args->client.verifier, NFS4_VERIFIER_SIZE)); + sprintf(get_line(0, 0), "ID = (%d) %s", + args->client.id.id_len, + tohex(args->client.id.id_val, args->client.id.id_len)); + + sprintf(get_line(0, 0), "Callback Program = %u", + args->callback.cb_program); + sprintf(get_line(0, 0), "Callback Net ID = %s", + args->callback.cb_location.r_netid); + sprintf(get_line(0, 0), "Callback Addr = %s", + args->callback.cb_location.r_addr); + sprintf(get_line(0, 0), "Callback Ident = %u", args->callback_ident); +} + +static void +sumarg_setclid_cfm(char *buf, size_t buflen, void *obj) +{ + SETCLIENTID_CONFIRM4args *args = (SETCLIENTID_CONFIRM4args *)obj; + + snprintf(buf, buflen, "%s CFV=%s", sum_clientid(args->clientid), + tohex(args->setclientid_confirm, NFS4_VERIFIER_SIZE)); +} + +static void +dtlarg_setclid_cfm(void *obj) +{ + SETCLIENTID_CONFIRM4args *args = (SETCLIENTID_CONFIRM4args *)obj; + + detail_clientid(args->clientid); + sprintf(get_line(0, 0), "Set Client ID Confirm Verifier = %s", + tohex(args->setclientid_confirm, NFS4_VERIFIER_SIZE)); +} + + +static void +dtlarg_verify(void *obj) +{ + NVERIFY4args *args = (NVERIFY4args *)obj; + + detail_fattr4(&args->obj_attributes); +} + +static void +sumarg_write(char *buf, size_t buflen, void *obj) +{ + WRITE4args *args = (WRITE4args *)obj; + + snprintf(buf, buflen, "%s at %llu for %u", + sum_stateid(&args->stateid), args->offset, args->data.data_len); +} + +static void +dtlarg_write(void *obj) +{ + WRITE4args *args = (WRITE4args *)obj; + + sprintf(get_line(0, 0), "Offset = %llu", args->offset); + sprintf(get_line(0, 0), "Count = %u", args->data.data_len); + sprintf(get_line(0, 0), "Stable = %s", stable_how4_name(args->stable)); + detail_stateid(&args->stateid); +} + +static char * +sum_fh4(nfs_fh4 *fh) +{ + static char buf[20]; + + sprintf(buf, "FH=%04X", fh4_hash(fh)); + + return (buf); +} + +static void +detail_fh4(nfs_fh4 *fh) +{ + int i; + uchar_t *cp; + char *bufp; + + sprintf(get_line(0, 0), "File handle = [%04X]", fh4_hash(fh)); + bufp = get_line(0, 0); + sprintf(bufp, "(%d) ", fh->nfs_fh4_len); + bufp += strlen(bufp); + /* XXX use tohex()? */ + for (i = 0, cp = (uchar_t *)fh->nfs_fh4_val; + i < fh->nfs_fh4_len; + i++, cp++) { + if (i != 0 && i % 32 == 0) + bufp = get_line(0, 0); + sprintf(bufp, "%02x", *cp); + bufp += strlen(bufp); + } +} + +static void +detail_fattr4(fattr4 *attrp) +{ + unpkd_attrmap_t provided; + uint_t attrnum; + XDR attrxdr; + jmp_buf old_errbuf; + + xdrmem_create(&attrxdr, attrp->attr_vals.attrlist4_val, + attrp->attr_vals.attrlist4_len, XDR_DECODE); + + bcopy(xdr_err, old_errbuf, sizeof (old_errbuf)); + if (setjmp(xdr_err)) { + sprintf(get_line(0, 0), "<attr_vals too short>"); + goto done; + } + + detail_attr_bitmap("", &attrp->attrmask, &provided); + for (attrnum = 0; attrnum < MAX_ATTRIBUTES; attrnum++) { + if (provided.map[attrnum]) { + attr_info[attrnum].prt_details(&attrxdr); + } + } + +done: + bcopy(old_errbuf, xdr_err, sizeof (old_errbuf)); +} + +static void +sum_attr_bitmap(char *buf, size_t buflen, bitmap4 *mapp) +{ + uint_t num_words; + char *bp; + size_t curlen, remaining; + + buf[0] = '\0'; + for (num_words = 0; num_words < mapp->bitmap4_len; num_words++) { + curlen = strlen(buf); + if (curlen + sizeof ("<Too Long>") >= buflen) { + strcpy(buf + buflen - sizeof ("<Too Long>"), + "<Too Long>"); + return; + } + bp = buf + curlen; + remaining = buflen - curlen; + snprintf(bp, remaining, + num_words == 0 ? "%x" : " %x", + mapp->bitmap4_val[num_words]); + } +} + +/* + * Print detail information for the given attribute bitmap, and fill in the + * unpacked version of the map if "unpacked" is non-null. Returns the + * number of bytes in the bitmap. "prefix" is an initial string that is + * printed at the front of each line. + */ + +static void +detail_attr_bitmap(char *prefix, bitmap4 *bitp, unpkd_attrmap_t *unpacked) +{ + uint_t num_words; + uint32_t *wp; + uint_t byte_num; + + if (unpacked != NULL) + memset(unpacked, 0, sizeof (unpkd_attrmap_t)); + + /* + * Break the bitmap into octets, then print in hex and + * symbolically. + */ + + for (num_words = 0, wp = bitp->bitmap4_val; + num_words < bitp->bitmap4_len; + num_words++, wp++) { + for (byte_num = 0; byte_num < 4; byte_num++) { + uchar_t val = (*wp) >> (byte_num * 8); + char *buf = get_line(0, 0); + uint_t attrnum; + int bit; + + sprintf(buf, "%s 0x%02x ", prefix, val); + attrnum = num_words * 32 + byte_num * 8; + for (bit = 7; bit >= 0; bit--) { + if (val & (1 << bit)) { + strcat(buf, " "); + strcat(buf, + attr_name(attrnum + bit)); + if (unpacked != NULL) + unpacked->map[attrnum + bit] = + 1; + } + } + } + } +} + +/* + * Format the summary line results from a COMPOUND4 call. + */ + +static void +sum_comp4res(char *line, char *(*sumres_fn)(void)) +{ + nfsstat4 status; + static utf8string tag; + + status = getxdr_long(); + if (!xdr_utf8string(&xdrm, &tag)) + longjmp(xdr_err, 1); + + sprintf(line, "(%.20s) %s %s", utf8localize(&tag), + status_name(status), sumres_fn()); + + xdr_free(xdr_utf8string, (char *)&tag); +} + + +/* + * Return a set of summary strings for the result data that's next in the + * XDR stream, up to SUM_COMPND_MAX characters. If the strings don't fit, + * include a "..." at the end of the string. + */ + +static char * +sum_compound4res(void) +{ + static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ + int numres; + const size_t buflen = sizeof (buf); + char *bp; + nfs_resop4 one_res; + + buf[0] = '\0'; + if (setjmp(xdr_err)) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), + nfs4_fragged_rpc ? nfs4err_fragrpc : nfs4err_xdrfrag); + return (buf); + } + + numres = getxdr_long(); + bp = buf; + while (numres-- > 0) { + char *result; + + bzero(&one_res, sizeof (one_res)); + + if (!xdr_nfs_resop4(&xdrm, &one_res)) { + xdr_free(xdr_nfs_resop4, (char *)&one_res); + longjmp(xdr_err, 1); + } + + snprintf(bp, buflen - (bp - buf), "%s ", + opcode_name(one_res.resop)); + bp += strlen(bp); + + result = sum_result(&one_res); + if (strlen(result) > 0) { + snprintf(bp, buflen - (bp - buf), "%s ", result); + bp += strlen(bp); + } + + /* nfs4_skip_bytes set by xdr_nfs4_argop4() */ + if (nfs4_skip_bytes != 0) + nfs4_xdr_skip(nfs4_skip_bytes); + + xdr_free(xdr_nfs_resop4, (char *)&one_res); + /* add "..." if past the "end" of the buffer */ + if (bp - buf > SUM_COMPND_MAX) { + strcpy(buf + SUM_COMPND_MAX - strlen("..."), + "..."); + break; + } + } + + return (buf); +} + + +/* + * Return a set of summary strings for the result data that's next in the + * XDR stream, up to SUM_COMPND_MAX characters. If the strings don't fit, + * include a "..." at the end of the string. + */ + +static char * +sum_cb_compound4res(void) +{ + static char buf[SUM_COMPND_MAX + 2]; /* 1 for null, 1 for overflow */ + int numres; + const size_t buflen = sizeof (buf); + char *bp; + nfs_cb_resop4 one_res; + + buf[0] = '\0'; + if (setjmp(xdr_err)) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), "<XDR Error or Fragmented" + " RPC>"); + return (buf); + } + + numres = getxdr_long(); + bp = buf; + while (numres-- > 0) { + bzero(&one_res, sizeof (one_res)); + if (!xdr_nfs_cb_resop4(&xdrm, &one_res)) { + xdr_free(xdr_nfs_cb_resop4, (char *)&one_res); + longjmp(xdr_err, 1); + } + snprintf(bp, buflen - (bp - buf), "%s %s ", + cb_opcode_name(one_res.resop), + sum_cb_result(&one_res)); + bp += strlen(bp); + + xdr_free(xdr_nfs_cb_resop4, (char *)&one_res); + + /* add "..." if past the "end" of the buffer */ + if (bp - buf > SUM_COMPND_MAX) { + strcpy(buf + SUM_COMPND_MAX - strlen("..."), + "..."); + break; + } + } + + return (buf); +} + + +/* + * Return the summarized results for the given resultdata. + */ + +static char * +sum_result(nfs_resop4 *resp) +{ + static char buf[1024]; + void (*fmtproc)(char *, size_t, void *); + + buf[0] = '\0'; + if (resp->resop < num_opcodes) + fmtproc = opcode_info[resp->resop].sumres; + else if (resp->resop == OP_ILLEGAL) + fmtproc = sum_nfsstat4; + else + fmtproc = NULL; + + if (fmtproc != NULL) + fmtproc(buf, sizeof (buf), &resp->nfs_resop4_u); + + return (buf); +} + +/* + * Return the summarized results for the given resultdata. + */ + +static char * +sum_cb_result(nfs_cb_resop4 *resp) +{ + static char buf[1024]; + void (*fmtproc)(char *, size_t, void *); + + buf[0] = '\0'; + if (resp->resop < cb_num_opcodes) + fmtproc = cb_opcode_info[resp->resop].sumres; + else if (resp->resop == OP_CB_ILLEGAL) + fmtproc = sum_nfsstat4; + else + fmtproc = NULL; + + if (fmtproc != NULL) + fmtproc(buf, sizeof (buf), &resp->nfs_cb_resop4_u); + + return (buf); +} + + +static void +dtl_change_info(char *msg, change_info4 *infop) +{ + sprintf(get_line(0, 0), "%s:", msg); + sprintf(get_line(0, 0), " Atomic = %s", + infop->atomic ? "TRUE" : "FALSE"); + detail_fattr4_change(" Before", infop->before); + detail_fattr4_change(" After", infop->after); +} + +static void +detail_fattr4_change(char *msg, fattr4_change chg) +{ + sprintf(get_line(0, 0), "%s: 0x%llx", msg, chg); + /* XXX print as time_t, too? */ +} + +static void +sum_nfsstat4(char *buf, size_t buflen, void *obj) +{ + nfsstat4 status = *(nfsstat4 *)obj; + + strncpy(buf, status_name(status), buflen); +} + +static void +dtl_nfsstat4(void *obj) +{ + nfsstat4 status = *(nfsstat4 *)obj; + + sprintf(get_line(0, 0), "Status = %d (%s)", status, + status_name(status)); +} + +static void +sumres_access(char *buf, size_t buflen, void *obj) +{ + ACCESS4res *res = (ACCESS4res *)obj; + char *bp = buf; + int len, blen = buflen; + + strcpy(bp, status_name(res->status)); + if (res->status == NFS4_OK) { + bp += (len = strlen(bp)); + blen -= len; + + snprintf(bp, blen, " Supp="); + bp += (len = strlen(bp)); + blen -= len; + + sum_access4(bp, blen, res->ACCESS4res_u.resok4.supported); + bp += (len = strlen(bp)); + blen -= len; + + snprintf(bp, blen, " Allow="); + bp += (len = strlen(bp)); + blen -= len; + + sum_access4(bp, blen, res->ACCESS4res_u.resok4.access); + } +} + +static void +dtlres_access(void *obj) +{ + ACCESS4res *res = (ACCESS4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_access4("Supported Attributes", + res->ACCESS4res_u.resok4.supported); + detail_access4("Allowed Attributes", + res->ACCESS4res_u.resok4.access); + } +} + +static void +sumres_close(char *buf, size_t buflen, void *obj) +{ + CLOSE4res *res = (CLOSE4res *)obj; + + if (res->status == NFS4_OK) + snprintf(buf, buflen, "%s", + sum_open_stateid(&res->CLOSE4res_u.open_stateid)); +} + +static void +dtlres_close(void *obj) +{ + CLOSE4res *res = (CLOSE4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_open_stateid(&res->CLOSE4res_u.open_stateid); + } +} + +static void +sumres_commit(char *buf, size_t buflen, void *obj) +{ + COMMIT4res *res = (COMMIT4res *)obj; + + if (res->status == NFS4_OK) + snprintf(buf, buflen, "Verf=%s", + tohex(res->COMMIT4res_u.resok4.writeverf, + NFS4_VERIFIER_SIZE)); +} + +static void +dtlres_commit(void *obj) +{ + COMMIT4res *res = (COMMIT4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + sprintf(get_line(0, 0), "Verifier = %s", + tohex(res->COMMIT4res_u.resok4.writeverf, + NFS4_VERIFIER_SIZE)); + } +} + +static void +dtlres_create(void *obj) +{ + CREATE4res *res = (CREATE4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + dtl_change_info("Change Information", + &res->CREATE4res_u.resok4.cinfo); + detail_attr_bitmap("", &res->CREATE4res_u.resok4.attrset, + NULL); + } +} + +static void +sumres_getattr(char *buf, size_t buflen, void *obj) +{ + GETATTR4res *res = (GETATTR4res *)obj; + + strncpy(buf, status_name(res->status), buflen); +} + +static void +dtlres_getattr(void *obj) +{ + GETATTR4res *res = (GETATTR4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_fattr4(&res->GETATTR4res_u.resok4.obj_attributes); + } +} + +static void +sumres_cb_getattr(char *buf, size_t buflen, void *obj) +{ + CB_GETATTR4res *res = (CB_GETATTR4res *)obj; + + strncpy(buf, status_name(res->status), buflen); +} + +static void +dtlres_cb_getattr(void *obj) +{ + CB_GETATTR4res *res = (CB_GETATTR4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_fattr4(&res->CB_GETATTR4res_u.resok4.obj_attributes); + } +} + + +static void +sumres_getfh(char *buf, size_t buflen, void *obj) +{ + char *bp; + GETFH4res *res = (GETFH4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_fh4(&res->GETFH4res_u.resok4.object)); + } +} + +static void +dtlres_getfh(void *obj) +{ + GETFH4res *res = (GETFH4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_fh4(&res->GETFH4res_u.resok4.object); + } +} + +static void +dtlres_link(void *obj) +{ + LINK4res *res = (LINK4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + dtl_change_info("Change Information", + &res->LINK4res_u.resok4.cinfo); + } +} + +static void +sumres_lock(char *buf, size_t buflen, void *obj) +{ + char *bp; + LOCK4res *res = (LOCK4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_lock_stateid(&res->LOCK4res_u.resok4.lock_stateid)); + } + if (res->status == NFS4ERR_DENIED) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_lock_denied(&res->LOCK4res_u.denied)); + } +} + +static void +dtlres_lock(void *obj) +{ + LOCK4res *res = (LOCK4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_lock_stateid(&res->LOCK4res_u.resok4.lock_stateid); + } + if (res->status == NFS4ERR_DENIED) { + detail_lock_denied(&res->LOCK4res_u.denied); + } +} + +static void +sumres_lockt(char *buf, size_t buflen, void *obj) +{ + char *bp; + LOCKT4res *res = (LOCKT4res *)obj; + + strcpy(buf, status_name(res->status)); + if (res->status == NFS4ERR_DENIED) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_lock_denied(&res->LOCKT4res_u.denied)); + } +} + +static void +dtlres_lockt(void *obj) +{ + LOCKT4res *res = (LOCKT4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4ERR_DENIED) { + detail_lock_denied(&res->LOCKT4res_u.denied); + } +} + +static void +sumres_locku(char *buf, size_t buflen, void *obj) +{ + char *bp; + LOCKU4res *res = (LOCKU4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + bp = buf + strlen(buf); + if (res->status == NFS4_OK) + snprintf(bp, buflen - (bp - buf), " %s", + sum_lock_stateid(&res->LOCKU4res_u.lock_stateid)); +} + +static void +dtlres_locku(void *obj) +{ + LOCKU4res *res = (LOCKU4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) + detail_lock_stateid(&res->LOCKU4res_u.lock_stateid); +} + +static void +sumres_open(char *buf, size_t buflen, void *obj) +{ + char *bp = buf; + OPEN4res *res = (OPEN4res *)obj; + uint_t rflags; + int len, blen = buflen; + + strncpy(bp, status_name(res->status), blen); + + if (res->status == NFS4_OK) { + bp += (len = strlen(bp)); + blen -= len; + + snprintf(bp, blen, " %s", + sum_stateid(&res->OPEN4res_u.resok4.stateid)); + bp += (len = strlen(bp)); + blen -= len; + + if ((rflags = res->OPEN4res_u.resok4.rflags) != 0) { + snprintf(bp, blen, "%s", sum_open_rflags(rflags)); + bp += (len = strlen(bp)); + blen -= len; + } + + sum_delegation(bp, blen, &res->OPEN4res_u.resok4.delegation); + } +} + +static void +dtlres_open(void *obj) +{ + OPEN4res *res = (OPEN4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_stateid(&res->OPEN4res_u.resok4.stateid); + dtl_change_info("Change Information", + &res->OPEN4res_u.resok4.cinfo); + sprintf(get_line(0, 0), "Flags = 0x%x (%s)", + res->OPEN4res_u.resok4.rflags, + detail_open_rflags(res->OPEN4res_u.resok4.rflags)); + detail_attr_bitmap("", &res->OPEN4res_u.resok4.attrset, + NULL); + detail_delegation(&res->OPEN4res_u.resok4.delegation); + } +} + +static void +sumres_open_confirm(char *buf, size_t buflen, void *obj) +{ + char *bp; + OPEN_CONFIRM4res *res = (OPEN_CONFIRM4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_open_stateid(&res->OPEN_CONFIRM4res_u.resok4. + open_stateid)); + } +} + +static void +dtlres_open_confirm(void *obj) +{ + OPEN_CONFIRM4res *res = (OPEN_CONFIRM4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_open_stateid(&res->OPEN_CONFIRM4res_u.resok4. + open_stateid); + } +} + +static void +sumres_open_downgrd(char *buf, size_t buflen, void *obj) +{ + char *bp; + OPEN_DOWNGRADE4res *res = (OPEN_DOWNGRADE4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + sum_open_stateid(&res->OPEN_DOWNGRADE4res_u.resok4. + open_stateid)); + } +} + +static void +dtlres_open_downgrd(void *obj) +{ + OPEN_DOWNGRADE4res *res = (OPEN_DOWNGRADE4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + detail_open_stateid(&res->OPEN_DOWNGRADE4res_u.resok4. + open_stateid); + } +} + +static void +sumres_read(char *buf, size_t buflen, void *obj) +{ + char *bp; + READ4res *res = (READ4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " (%u bytes) %s", + res->READ4res_u.resok4.data.data_len, + res->READ4res_u.resok4.eof ? "EOF" : ""); + } +} + +static void +dtlres_read(void *obj) +{ + READ4res *res = (READ4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + sprintf(get_line(0, 0), "Count = %u bytes read", + res->READ4res_u.resok4.data.data_len); + sprintf(get_line(0, 0), "End of file = %s", + res->READ4res_u.resok4.eof ? "TRUE" : "FALSE"); + } +} + +static void +sumres_readdir(char *buf, size_t buflen, void *obj) +{ + char *bp; + READDIR4res *res = (READDIR4res *)obj; + int num_entries = 0; + entry4 *ep; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + for (ep = res->READDIR4res_u.resok4.reply.entries; + ep != NULL; + ep = ep->nextentry) + num_entries++; + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %d entries (%s)", + num_entries, + res->READDIR4res_u.resok4.reply.eof + ? "No more" : "More"); + } +} + +static void +dtlres_readdir(void *obj) +{ + READDIR4res *res = (READDIR4res *)obj; + int num_entries = 0; + entry4 *ep; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + for (ep = res->READDIR4res_u.resok4.reply.entries; + ep != NULL; + ep = ep->nextentry) { + num_entries++; + sprintf(get_line(0, 0), + "------------------ entry #%d", + num_entries); + sprintf(get_line(0, 0), "Cookie = %llu", + ep->cookie); + sprintf(get_line(0, 0), "Name = %s", + component_name(&ep->name)); + detail_fattr4(&ep->attrs); + } + if (num_entries == 0) + sprintf(get_line(0, 0), "(No entries)"); + sprintf(get_line(0, 0), "EOF = %s", + res->READDIR4res_u.resok4.reply.eof ? "TRUE" : "FALSE"); + sprintf(get_line(0, 0), "Verifer = %s", + tohex(res->READDIR4res_u.resok4.cookieverf, + NFS4_VERIFIER_SIZE)); + } +} + +static void +sumres_readlnk(char *buf, size_t buflen, void *obj) +{ + char *bp; + READLINK4res *res = (READLINK4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s", + linktext_name(&res->READLINK4res_u.resok4.link)); + } +} + +static void +dtlres_readlnk(void *obj) +{ + READLINK4res *res = (READLINK4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + sprintf(get_line(0, 0), "Link = %s", + linktext_name(&res->READLINK4res_u.resok4.link)); + } +} + +static void +dtlres_remove(void *obj) +{ + REMOVE4res *res = (REMOVE4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + dtl_change_info("Change Information", + &res->REMOVE4res_u.resok4.cinfo); + } +} + +static void +dtlres_rename(void *obj) +{ + RENAME4res *res = (RENAME4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + dtl_change_info("Source Change Information", + &res->RENAME4res_u.resok4.source_cinfo); + dtl_change_info("Target Change Information", + &res->RENAME4res_u.resok4.target_cinfo); + } +} + +static void +sumres_secinfo(char *buf, size_t buflen, void *obj) +{ + char *bp; + SECINFO4res *res = (SECINFO4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + bp = buf + strlen(buf); + if (res->status == NFS4_OK) { + uint_t numinfo = res->SECINFO4res_u.resok4.SECINFO4resok_len; + secinfo4 *infop; + + for (infop = res->SECINFO4res_u.resok4.SECINFO4resok_val; + numinfo != 0; + infop++, numinfo--) { + snprintf(bp, buflen - (bp - buf), " %s", + flavor_name(infop->flavor)); + bp += strlen(bp); + } + } +} + +static void +dtlres_secinfo(void *obj) +{ + SECINFO4res *res = (SECINFO4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + uint_t numinfo = + res->SECINFO4res_u.resok4.SECINFO4resok_len; + secinfo4 *infop; + + for (infop = res->SECINFO4res_u.resok4.SECINFO4resok_val; + numinfo != 0; + infop++, numinfo--) { + detail_secinfo4(infop); + } + } +} + +static void +sumres_setattr(char *buf, size_t buflen, void *obj) +{ + SETATTR4res *res = (SETATTR4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + sum_attr_bitmap(buf, buflen, &res->attrsset); +} + +static void +dtlres_setattr(void *obj) +{ + SETATTR4res *res = (SETATTR4res *)obj; + + dtl_nfsstat4(obj); + detail_attr_bitmap("", &res->attrsset, NULL); +} + +static void +sumres_setclid(char *buf, size_t buflen, void *obj) +{ + char *bp; + SETCLIENTID4res *res = (SETCLIENTID4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + switch (res->status) { + case NFS_OK: + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %s CFV=%s", + sum_clientid(res->SETCLIENTID4res_u.resok4.clientid), + tohex(res->SETCLIENTID4res_u.resok4.setclientid_confirm, + NFS4_VERIFIER_SIZE)); + break; + case NFS4ERR_CLID_INUSE: + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " ID=%s Addr=%s", + res->SETCLIENTID4res_u.client_using.r_netid, + res->SETCLIENTID4res_u.client_using.r_addr); + break; + } +} + +static void +dtlres_setclid(void *obj) +{ + SETCLIENTID4res *res = (SETCLIENTID4res *)obj; + + dtl_nfsstat4(obj); + switch (res->status) { + case NFS_OK: + detail_clientid(res->SETCLIENTID4res_u.resok4.clientid); + sprintf(get_line(0, 0), "Set Client ID Confirm Verifier = %s", + tohex(res->SETCLIENTID4res_u.resok4.setclientid_confirm, + NFS4_VERIFIER_SIZE)); + break; + case NFS4ERR_CLID_INUSE: + sprintf(get_line(0, 0), "Used by Net ID = %s", + res->SETCLIENTID4res_u.client_using.r_netid); + sprintf(get_line(0, 0), "Used by Addr = %s", + res->SETCLIENTID4res_u.client_using.r_addr); + break; + } +} + +static void +sumres_write(char *buf, size_t buflen, void *obj) +{ + char *bp; + WRITE4res *res = (WRITE4res *)obj; + + strncpy(buf, status_name(res->status), buflen); + if (res->status == NFS4_OK) { + bp = buf + strlen(buf); + snprintf(bp, buflen - (bp - buf), " %u (%s)", + res->WRITE4res_u.resok4.count, + stable_how4_name(res->WRITE4res_u.resok4.committed)); + } +} + +static void +dtlres_write(void *obj) +{ + WRITE4res *res = (WRITE4res *)obj; + + dtl_nfsstat4(obj); + if (res->status == NFS4_OK) { + sprintf(get_line(0, 0), "Count = %u bytes written", + res->WRITE4res_u.resok4.count); + sprintf(get_line(0, 0), "Stable = %s", + stable_how4_name(res->WRITE4res_u.resok4.committed)); + sprintf(get_line(0, 0), "Verifier = %s", + tohex(res->WRITE4res_u.resok4.writeverf, + NFS4_VERIFIER_SIZE)); + } +} + +/* + * Print details about the nfs_resop4 that is next in the XDR stream. + */ + +static void +detail_nfs_resop4(void) +{ + int numres; + nfs_resop4 one_res; + void (*fmtproc)(void *); + + numres = getxdr_long(); + (void) sprintf(get_line(0, 0), "Number of results = %d", + numres); + + while (numres-- > 0) { + bzero(&one_res, sizeof (one_res)); + + if (!xdr_nfs_resop4(&xdrm, &one_res)) { + xdr_free(xdr_nfs_resop4, (char *)&one_res); + longjmp(xdr_err, 1); + } + + get_line(0, 0); /* blank line to separate ops */ + sprintf(get_line(0, 0), "Op = %d (%s)", + one_res.resop, opcode_name(one_res.resop)); + if (one_res.resop < num_opcodes) + fmtproc = opcode_info[one_res.resop].dtlres; + else if (one_res.resop == OP_ILLEGAL) + fmtproc = dtl_nfsstat4; + else + fmtproc = NULL; + + if (fmtproc != NULL) + fmtproc(&one_res.nfs_resop4_u); + + /* nfs4_skip_bytes set by xdr_nfs_resop4()() */ + if (nfs4_skip_bytes) + nfs4_xdr_skip(nfs4_skip_bytes); + + xdr_free(xdr_nfs_resop4, (char *)&one_res); + } +} + + +/* + * Print details about the nfs_cb_resop4 that is next in the XDR stream. + */ + +static void +detail_cb_resop4(void) +{ + int numres; + nfs_cb_resop4 one_res; + void (*fmtproc)(void *); + + numres = getxdr_long(); + (void) sprintf(get_line(0, 0), "Number of results = %d", + numres); + + while (numres-- > 0) { + bzero(&one_res, sizeof (one_res)); + if (!xdr_nfs_cb_resop4(&xdrm, &one_res)) + longjmp(xdr_err, 1); + + get_line(0, 0); /* blank line to separate ops */ + sprintf(get_line(0, 0), "Op = %d (%s)", + one_res.resop, cb_opcode_name(one_res.resop)); + if (one_res.resop < cb_num_opcodes) + fmtproc = cb_opcode_info[one_res.resop].dtlres; + else if (one_res.resop == OP_CB_ILLEGAL) + fmtproc = dtl_nfsstat4; + else + fmtproc = NULL; + + if (fmtproc != NULL) + fmtproc(&one_res.nfs_cb_resop4_u); + + xdr_free(xdr_nfs_cb_resop4, (char *)&one_res); + } +} + + +/* + * Return the name of a lock type. + */ +static char * +lock_type_name(enum nfs_lock_type4 type) +{ + char *result; + + switch (type) { + case READ_LT: + result = "READ"; + break; + case WRITE_LT: + result = "WRITE"; + break; + case READW_LT: + result = "READW"; + break; + case WRITEW_LT: + result = "WRITEW"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * Return the name of an opcode. + */ + +static char * +opcode_name(uint_t opnum) +{ + static char buf[20]; + + if (opnum < num_opcodes) + return (opcode_info[opnum].name); + + if (opnum == OP_ILLEGAL) + return ("ILLEGAL"); + + sprintf(buf, "op %d", opnum); + return (buf); +} + +/* + * Return the name of an opcode. + */ +static char * +cb_opcode_name(uint_t opnum) +{ + static char buf[20]; + + if (opnum < cb_num_opcodes) + return (cb_opcode_info[opnum].name); + + if (opnum == OP_CB_ILLEGAL) + return ("CB_ILLEGAL"); + + sprintf(buf, "op %d", opnum); + return (buf); +} + + +/* + * Fill in a summary string for the given access bitmask. + */ + +static void +sum_access4(char *buf, size_t buflen, uint32_t bits) +{ + buf[0] = '\0'; + + if (bits & ACCESS4_READ) + (void) strncat(buf, "rd,", buflen); + if (bits & ACCESS4_LOOKUP) + (void) strncat(buf, "lk,", buflen); + if (bits & ACCESS4_MODIFY) + (void) strncat(buf, "mo,", buflen); + if (bits & ACCESS4_EXTEND) + (void) strncat(buf, "ext,", buflen); + if (bits & ACCESS4_DELETE) + (void) strncat(buf, "dl,", buflen); + if (bits & ACCESS4_EXECUTE) + (void) strncat(buf, "exc,", buflen); + if (buf[0] != '\0') + buf[strlen(buf) - 1] = '\0'; +} + +/* + * Print detail information about the given access bitmask. + */ + +static void +detail_access4(char *descrip, uint32_t bits) +{ + sprintf(get_line(0, 0), "%s = 0x%08x", descrip, bits); + + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_READ, "Read", "(no read)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_LOOKUP, "Lookup", "(no lookup)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_MODIFY, "Modify", "(no modify)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_EXTEND, "Extend", "(no extend)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_DELETE, "Delete", "(no delete)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS4_EXECUTE, "Execute", "(no execute)")); +} + + +/* + * Fill in a summary string for the given open_claim4. + */ +static void +sum_name(char *buf, size_t buflen, open_claim4 *claim) +{ + char *bp = buf; + + switch (claim->claim) { + case CLAIM_NULL: + snprintf(bp, buflen, "%s ", + component_name(&claim->open_claim4_u.file)); + break; + case CLAIM_PREVIOUS: + break; + case CLAIM_DELEGATE_CUR: + snprintf(bp, buflen, "%s ", + component_name(&claim->open_claim4_u. + delegate_cur_info.file)); + break; + case CLAIM_DELEGATE_PREV: + snprintf(bp, buflen, "%s ", + component_name(&claim->open_claim4_u. + file_delegate_prev)); + break; + } +} + +/* + * Fill in a summary string for the given open_claim4. + */ +static void +sum_claim(char *buf, size_t buflen, open_claim4 *claim) +{ + char *bp = buf; + + switch (claim->claim) { + case CLAIM_NULL: + snprintf(bp, buflen, " CT=N"); + break; + case CLAIM_PREVIOUS: + snprintf(bp, buflen, " CT=P DT=%s", + get_deleg_typestr(claim->open_claim4_u.delegate_type)); + break; + case CLAIM_DELEGATE_CUR: + snprintf(bp, buflen, " CT=DC %s", + sum_deleg_stateid(&claim->open_claim4_u. + delegate_cur_info.delegate_stateid)); + break; + case CLAIM_DELEGATE_PREV: + snprintf(bp, buflen, " CT=DP"); + break; + default: + snprintf(bp, buflen, " CT=?"); + break; + } +} + +static char * +get_deleg_typestr(open_delegation_type4 dt) +{ + char *str = ""; + + switch (dt) { + case OPEN_DELEGATE_NONE: + str = "N"; + break; + case OPEN_DELEGATE_READ: + str = "R"; + break; + case OPEN_DELEGATE_WRITE: + str = "W"; + break; + default: + str = "?"; + } + + return (str); +} + +/* + * Print detail information for the given open_claim4. + */ + +static void +detail_claim(open_claim4 *claim) +{ + sprintf(get_line(0, 0), "Claim Type = %d (%s)", + claim->claim, claim_name(claim->claim)); + + switch (claim->claim) { + case CLAIM_NULL: + detail_compname4(&claim->open_claim4_u.file); + break; + case CLAIM_PREVIOUS: + sprintf(get_line(0, 0), "Delegate Type = %s (val = %d)", + get_deleg_typestr(claim->open_claim4_u.delegate_type), + claim->open_claim4_u.delegate_type); + break; + case CLAIM_DELEGATE_CUR: + detail_compname4(&claim->open_claim4_u.delegate_cur_info.file); + detail_deleg_stateid(&claim->open_claim4_u.delegate_cur_info. + delegate_stateid); + break; + case CLAIM_DELEGATE_PREV: + detail_compname4(&claim->open_claim4_u.file_delegate_prev); + break; + } +} + +/* + * Return a summary string for the given clientid4. + */ +static char * +sum_clientid(clientid4 client) +{ + static char buf[50]; + + snprintf(buf, sizeof (buf), "CL=%llx", client); + + return (buf); +} + +/* + * Print a detail string for the given clientid4. + */ +static void +detail_clientid(clientid4 client) +{ + sprintf(get_line(0, 0), "Client ID = %llx", client); +} + +/* + * Write a summary string for the given delegation into buf. + */ + +static void +sum_delegation(char *buf, size_t buflen, open_delegation4 *delp) +{ + switch (delp->delegation_type) { + case OPEN_DELEGATE_NONE: + snprintf(buf, buflen, " DT=N"); + break; + case OPEN_DELEGATE_READ: + snprintf(buf, buflen, " DT=R %s", + sum_deleg_stateid(&delp->open_delegation4_u.write. + stateid)); + break; + case OPEN_DELEGATE_WRITE: + snprintf(buf, buflen, " DT=W %s %s", + sum_deleg_stateid(&delp->open_delegation4_u.write. + stateid), + sum_space_limit(&delp->open_delegation4_u.write. + space_limit)); + break; + default: + snprintf(buf, buflen, " DT=?"); + break; + } +} + +static void +detail_delegation(open_delegation4 *delp) +{ + sprintf(get_line(0, 0), "Delegation Type = %d (%s)", + delp->delegation_type, + delegation_type_name(delp->delegation_type)); + + switch (delp->delegation_type) { + case OPEN_DELEGATE_NONE: + /* no-op */ + break; + case OPEN_DELEGATE_READ: + detail_deleg_stateid(&delp->open_delegation4_u.read.stateid); + sprintf(get_line(0, 0), "Recall = %s", + delp->open_delegation4_u.read.recall ? + "TRUE" : "FALSE"); + sprintf(get_line(0, 0), "[nfsacl4]"); + break; + case OPEN_DELEGATE_WRITE: + detail_deleg_stateid(&delp->open_delegation4_u.write.stateid); + sprintf(get_line(0, 0), "Recall = %s", + delp->open_delegation4_u.write.recall ? + "TRUE" : "FALSE"); + detail_space_limit(&delp->open_delegation4_u.write. + space_limit); + sprintf(get_line(0, 0), "[nfsacl4]"); + break; + } +} + + +static void +detail_open_owner(open_owner4 *owner) +{ + sprintf(get_line(0, 0), "Open Owner hash = [%04X] ", + owner_hash(&owner->owner)); + sprintf(get_line(0, 0), " len = %u val = %s ", + owner->owner.owner_len, + tohex(owner->owner.owner_val, owner->owner.owner_len)); + detail_clientid(owner->clientid); +} + +static void +detail_lock_owner(lock_owner4 *owner) +{ + sprintf(get_line(0, 0), "Lock Owner hash = [%04X] ", + owner_hash(&owner->owner)); + sprintf(get_line(0, 0), " len = %u val = %s ", + owner->owner.owner_len, + tohex(owner->owner.owner_val, owner->owner.owner_len)); + detail_clientid(owner->clientid); +} + +static void +sum_openflag(char *bufp, int buflen, openflag4 *flagp) +{ + if (flagp->opentype == OPEN4_CREATE) { + switch (flagp->openflag4_u.how.mode) { + case UNCHECKED4: + snprintf(bufp, buflen, "OT=CR(U)"); + break; + case GUARDED4: + snprintf(bufp, buflen, "OT=CR(G)"); + break; + case EXCLUSIVE4: + snprintf(bufp, buflen, "OT=CR(E)"); + break; + default: + snprintf(bufp, buflen, "OT=CR(?:%d)", + flagp->openflag4_u.how.mode); + break; + } + } else + snprintf(bufp, buflen, "OT=NC"); +} + +static void +detail_openflag(openflag4 *flagp) +{ + sprintf(get_line(0, 0), "Open Type = %s", + flagp->opentype == OPEN4_CREATE ? "CREATE" : "NOCREATE"); + if (flagp->opentype == OPEN4_CREATE) + detail_createhow4(&flagp->openflag4_u.how); +} + +/* + * Fill in buf with the given path. + */ +static void +sum_pathname4(char *buf, size_t buflen, pathname4 *pathp) +{ + char *bp = buf; + uint_t component; + + for (component = 0; component < pathp->pathname4_len; + component++) { + snprintf(bp, buflen - (bp - buf), + component == 0 ? "%s" : "/%s", + component_name(&pathp->pathname4_val[component])); + bp += strlen(bp); + } +} + +static void +sum_compname4(char *buf, size_t buflen, component4 *comp) +{ + snprintf(buf, buflen, "%s", component_name(comp)); +} + +static void +detail_compname4(component4 *comp) +{ + sprintf(get_line(0, 0), "%s", component_name(comp)); +} + +static void +detail_pathname4(pathname4 *pathp, char *what) +{ + char *bp = get_line(0, 0); + uint_t component; + + sprintf(bp, what); + bp += strlen(bp); + + for (component = 0; component < pathp->pathname4_len; component++) { + sprintf(bp, component == 0 ? "%s" : "/%s", + component_name(&pathp->pathname4_val[component])); + bp += strlen(bp); + } +} + +/* + * Print detail information about the rpcsec_gss_info that is XDR-encoded + * at mem. + */ + +static void +detail_rpcsec_gss(rpcsec_gss_info *info) +{ + sprintf(get_line(0, 0), "OID = %s", + tohex(info->oid.sec_oid4_val, info->oid.sec_oid4_len)); + sprintf(get_line(0, 0), "QOP = %u", info->qop); + sprintf(get_line(0, 0), "Service = %d (%s)", + info->service, gss_svc_name(info->service)); +} + +/* + * Print detail information about the given secinfo4. + */ + +static void +detail_secinfo4(secinfo4 *infop) +{ + sprintf(get_line(0, 0), "Flavor = %d (%s)", + infop->flavor, flavor_name(infop->flavor)); + switch (infop->flavor) { + case RPCSEC_GSS: + detail_rpcsec_gss(&infop->secinfo4_u.flavor_info); + break; + } +} + + +/* + * Return a summary string corresponding to the given nfs_space_limit4. + */ + +static char * +sum_space_limit(nfs_space_limit4 *limitp) +{ + static char buf[64]; + int buflen = sizeof (buf); + + buf[0] = '\0'; + switch (limitp->limitby) { + case NFS_LIMIT_SIZE: + snprintf(buf, buflen, "LB=SZ(%llu)", + limitp->nfs_space_limit4_u.filesize); + break; + case NFS_LIMIT_BLOCKS: + snprintf(buf, buflen, "LB=BL(%u*%u)", + limitp->nfs_space_limit4_u.mod_blocks.num_blocks, + limitp->nfs_space_limit4_u.mod_blocks.bytes_per_block); + break; + default: + snprintf(buf, buflen, "LB=?(%d)", limitp->limitby); + break; + } + + return (buf); +} + +/* + * Print detail information about the given nfs_space_limit4. + */ + +static void +detail_space_limit(nfs_space_limit4 *limitp) +{ + sprintf(get_line(0, 0), "LimitBy = %d (%s)", + limitp->limitby, + limitby_name(limitp->limitby)); + + switch (limitp->limitby) { + case NFS_LIMIT_SIZE: + sprintf(get_line(0, 0), "Bytes = %llu", + limitp->nfs_space_limit4_u.filesize); + break; + case NFS_LIMIT_BLOCKS: + sprintf(get_line(0, 0), "Blocks = %u", + limitp->nfs_space_limit4_u.mod_blocks.num_blocks); + sprintf(get_line(0, 0), "Bytes Per Block = %u", + limitp->nfs_space_limit4_u.mod_blocks.bytes_per_block); + break; + } +} + + +/* + * Return the short name of a file type. + */ + +static char * +sum_type_name(nfs_ftype4 type) +{ + static char buf[20]; + + if (type < num_ftypes) + return (ftype_names[type].short_name); + else { + sprintf(buf, "type %d", type); + return (buf); + } +} + + +/* + * Return string with long/short flag names + */ + +static char * +get_flags(uint_t flag, ftype_names_t *names, uint_t num_flags, int shortname, + char *prefix) +{ + static char buf[200]; + char *bp = buf, *str; + int i, len, blen = sizeof (buf); + ftype_names_t *fn = NULL; + + *bp = '\0'; + + if (prefix) { + snprintf(bp, blen, "%s", prefix); + bp += (len = sizeof (bp)); + blen -= len; + } + + for (i = 0; i < 32; i++) + if (flag & (1 << i)) { + fn = names + (i < num_flags ? i : num_flags); + str = (shortname ? fn->short_name : fn->long_name); + + snprintf(bp, blen, "%s,", str); + bp += (len = strlen(bp)); + blen -= len; + } + + if (fn) + *(bp - 1) = '\0'; + else + *buf = '\0'; + + return (buf); +} + + +/* + * Return the long name of a file type. + */ + +static char * +detail_type_name(nfs_ftype4 type) +{ + static char buf[20]; + + if (type < num_ftypes) + return (ftype_names[type].long_name); + else { + sprintf(buf, "type %d", type); + return (buf); + } +} + +/* + * Return the name of an attribute. + */ + +static char * +attr_name(uint_t attrnum) +{ + static char buf[20]; + + if (attrnum < MAX_ATTRIBUTES) + return (attr_info[attrnum].name); + else { + sprintf(buf, "attr #%d", attrnum); + return (buf); + } +} + +/* + * Return the name of the given open_claim_type4. + */ + +static char * +claim_name(enum open_claim_type4 claim_type) +{ + char *result; + + switch (claim_type) { + case CLAIM_NULL: + result = "NULL"; + break; + case CLAIM_PREVIOUS: + result = "PREVIOUS"; + break; + case CLAIM_DELEGATE_CUR: + result = "DELEGATE CURRENT"; + break; + case CLAIM_DELEGATE_PREV: + result = "DELEGATE PREVIOUS"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * Return a string naming the given delegation. + */ + +static char * +delegation_type_name(enum open_delegation_type4 type) +{ + char *result; + + switch (type) { + case OPEN_DELEGATE_NONE: + result = "NONE"; + break; + case OPEN_DELEGATE_READ: + result = "READ"; + break; + case OPEN_DELEGATE_WRITE: + result = "WRITE"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +/* + * Return the name of the given authentication flavor. + */ + +static char * +flavor_name(uint_t flavor) +{ + char *result; + static char buf[50]; + + switch (flavor) { + case AUTH_SYS: + result = "AUTH_SYS"; + break; + case AUTH_NONE: + result = "AUTH_NONE"; + break; + case AUTH_DH: + result = "AUTH_DH"; + break; + case RPCSEC_GSS: + result = "RPCSEC_GSS"; + break; + default: + sprintf(buf, "[flavor %d]", flavor); + result = buf; + break; + } + + return (result); +} + +/* + * Return the name of the given rpc_gss_svc_t. + */ + +static char * +gss_svc_name(rpc_gss_svc_t svc) +{ + char *result; + static char buf[50]; + + switch (svc) { + case RPC_GSS_SVC_NONE: + result = "NONE"; + break; + case RPC_GSS_SVC_INTEGRITY: + result = "INTEGRITY"; + break; + case RPC_GSS_SVC_PRIVACY: + result = "PRIVACY"; + break; + default: + sprintf(buf, "Service %d", svc); + result = buf; + break; + } + + return (result); +} + +/* + * Return a string name for the given limit_by4. + */ + +static char * +limitby_name(enum limit_by4 limitby) +{ + char *result; + + switch (limitby) { + case NFS_LIMIT_SIZE: + result = "SIZE"; + break; + case NFS_LIMIT_BLOCKS: + result = "BLOCKS"; + break; + default: + result = "?"; + break; + } + + return (result); +} + +static char * +status_name(int status) +{ + char *p; + + switch (status) { + case NFS4_OK: p = "NFS4_OK"; break; + case NFS4ERR_PERM: p = "NFS4ERR_PERM"; break; + case NFS4ERR_NOENT: p = "NFS4ERR_NOENT"; break; + case NFS4ERR_IO: p = "NFS4ERR_IO"; break; + case NFS4ERR_NXIO: p = "NFS4ERR_NXIO"; break; + case NFS4ERR_ACCESS: p = "NFS4ERR_ACCESS"; break; + case NFS4ERR_EXIST: p = "NFS4ERR_EXIST"; break; + case NFS4ERR_XDEV: p = "NFS4ERR_XDEV"; break; + case NFS4ERR_NOTDIR: p = "NFS4ERR_NOTDIR"; break; + case NFS4ERR_ISDIR: p = "NFS4ERR_ISDIR"; break; + case NFS4ERR_INVAL: p = "NFS4ERR_INVAL"; break; + case NFS4ERR_FBIG: p = "NFS4ERR_FBIG"; break; + case NFS4ERR_NOSPC: p = "NFS4ERR_NOSPC"; break; + case NFS4ERR_ROFS: p = "NFS4ERR_ROFS"; break; + case NFS4ERR_MLINK: p = "NFS4ERR_MLINK"; break; + case NFS4ERR_NAMETOOLONG:p = "NFS4ERR_NAMETOOLONG"; break; + case NFS4ERR_NOTEMPTY: p = "NFS4ERR_NOTEMPTY"; break; + case NFS4ERR_DQUOT: p = "NFS4ERR_DQUOT"; break; + case NFS4ERR_STALE: p = "NFS4ERR_STALE"; break; + case NFS4ERR_BADHANDLE: p = "NFS4ERR_BADHANDLE"; break; + case NFS4ERR_BAD_COOKIE:p = "NFS4ERR_BAD_COOKIE"; break; + case NFS4ERR_NOTSUPP: p = "NFS4ERR_NOTSUPP"; break; + case NFS4ERR_TOOSMALL: p = "NFS4ERR_TOOSMALL"; break; + case NFS4ERR_SERVERFAULT:p = "NFS4ERR_SERVERFAULT"; break; + case NFS4ERR_BADTYPE: p = "NFS4ERR_BADTYPE"; break; + case NFS4ERR_DELAY: p = "NFS4ERR_DELAY"; break; + case NFS4ERR_SAME: p = "NFS4ERR_SAME"; break; + case NFS4ERR_DENIED: p = "NFS4ERR_DENIED"; break; + case NFS4ERR_EXPIRED: p = "NFS4ERR_EXPIRED"; break; + case NFS4ERR_LOCKED: p = "NFS4ERR_LOCKED"; break; + case NFS4ERR_GRACE: p = "NFS4ERR_GRACE"; break; + case NFS4ERR_FHEXPIRED: p = "NFS4ERR_FHEXPIRED"; break; + case NFS4ERR_SHARE_DENIED: p = "NFS4ERR_SHARE_DENIED"; break; + case NFS4ERR_WRONGSEC: p = "NFS4ERR_WRONGSEC"; break; + case NFS4ERR_CLID_INUSE: p = "NFS4ERR_CLID_INUSE"; break; + case NFS4ERR_RESOURCE: p = "NFS4ERR_RESOURCE"; break; + case NFS4ERR_MOVED: p = "NFS4ERR_MOVED"; break; + case NFS4ERR_NOFILEHANDLE: p = "NFS4ERR_NOFILEHANDLE"; break; + case NFS4ERR_MINOR_VERS_MISMATCH: p = "NFS4ERR_MINOR_VERS_MISMATCH"; + break; + case NFS4ERR_STALE_CLIENTID: p = "NFS4ERR_STALE_CLIENTID"; break; + case NFS4ERR_STALE_STATEID: p = "NFS4ERR_STALE_STATEID"; break; + case NFS4ERR_OLD_STATEID: p = "NFS4ERR_OLD_STATEID"; break; + case NFS4ERR_BAD_STATEID: p = "NFS4ERR_BAD_STATEID"; break; + case NFS4ERR_BAD_SEQID: p = "NFS4ERR_BAD_SEQID"; break; + case NFS4ERR_NOT_SAME: p = "NFS4ERR_NOT_SAME"; break; + case NFS4ERR_LOCK_RANGE: p = "NFS4ERR_LOCK_RANGE"; break; + case NFS4ERR_SYMLINK: p = "NFS4ERR_SYMLINK"; break; + case NFS4ERR_RESTOREFH: p = "NFS4ERR_RESTOREFH"; break; + case NFS4ERR_LEASE_MOVED: p = "NFS4ERR_LEASE_MOVED"; break; + case NFS4ERR_ATTRNOTSUPP: p = "NFS4ERR_ATTRNOTSUPP"; break; + case NFS4ERR_NO_GRACE: p = "NFS4ERR_NO_GRACE"; break; + case NFS4ERR_RECLAIM_BAD: p = "NFS4ERR_RECLAIM_BAD"; break; + case NFS4ERR_RECLAIM_CONFLICT: p = "NFS4ERR_RECLAIM_CONFLICT"; break; + case NFS4ERR_BADXDR: p = "NFS4ERR_BADXDR"; break; + case NFS4ERR_LOCKS_HELD: p = "NFS4ERR_LOCKS_HELD"; break; + case NFS4ERR_OPENMODE: p = "NFS4ERR_OPENMODE"; break; + case NFS4ERR_BADOWNER: p = "NFS4ERR_BADOWNER"; break; + case NFS4ERR_BADCHAR: p = "NFS4ERR_BADCHAR"; break; + case NFS4ERR_BADNAME: p = "NFS4ERR_BADNAME"; break; + case NFS4ERR_BAD_RANGE: p = "NFS4ERR_BAD_RANGE"; break; + case NFS4ERR_LOCK_NOTSUPP: p = "NFS4ERR_LOCK_NOTSUPP"; break; + case NFS4ERR_OP_ILLEGAL: p = "NFS4ERR_OP_ILLEGAL"; break; + case NFS4ERR_DEADLOCK: p = "NFS4ERR_DEADLOCK"; break; + case NFS4ERR_FILE_OPEN: p = "NFS4ERR_FILE_OPEN"; break; + case NFS4ERR_ADMIN_REVOKED: p = "NFS4ERR_ADMIN_REVOKED"; break; + case NFS4ERR_CB_PATH_DOWN: p = "NFS4ERR_CB_PATH_DOWN"; break; + default: p = "(unknown error)"; break; + } + + return (p); +} + +char * +nfsstat4_to_name(int status) +{ + return (status_name(status)); +} + +/* + * Attribute print functions. See attr_info_t. + */ + +static void +prt_supported_attrs(XDR *xdr) +{ + static bitmap4 val; + + if (!xdr_bitmap4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Supported Attributes:"); + detail_attr_bitmap("\t", &val, NULL); + xdr_free(xdr_bitmap4, (char *)&val); +} + +static void +prt_type(XDR *xdr) +{ + nfs_ftype4 val; + + if (!xdr_nfs_ftype4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Type = %s", sum_type_name(val)); +} + +static void +prt_fh_expire_type(XDR *xdr) +{ + fattr4_fh_expire_type val; + char *buf; + bool_t first = TRUE; + + if (!xdr_fattr4_fh_expire_type(xdr, &val)) + longjmp(xdr_err, 1); + buf = get_line(0, 0); + + sprintf(buf, "Filehandle expire type = "); + if ((val & (FH4_NOEXPIRE_WITH_OPEN | FH4_VOLATILE_ANY | + FH4_VOL_MIGRATION | FH4_VOL_RENAME)) == 0) { + strcat(buf, "Persistent"); + return; + } + if (val & FH4_NOEXPIRE_WITH_OPEN) { + strcat(buf, "No Expire With OPEN"); + first = FALSE; + } + if (val & FH4_VOLATILE_ANY) { + if (first) + first = FALSE; + else + strcat(buf, ", "); + strcat(buf, "Volatile at any time"); + } + if (val & FH4_VOL_MIGRATION) { + if (first) + first = FALSE; + else + strcat(buf, ", "); + strcat(buf, "Volatile at Migration"); + } + if (val & FH4_VOL_RENAME) { + if (first) + first = FALSE; + else + strcat(buf, ", "); + strcat(buf, "Volatile at Rename"); + } +} + +static void +prt_change(XDR *xdr) +{ + changeid4 val; + + if (!xdr_changeid4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Change ID = 0x%llx", val); + /* XXX print as time_t, too? */ +} + +static void +prt_size(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Size = %llu", val); +} + +static void +prt_link_support(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Link Support = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_symlink_support(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Symlink Support = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_named_attr(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Has Named Attributes = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_fsid(XDR *xdr) +{ + fsid4 val; + + if (!xdr_fsid4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "FS ID: Major = %llx, Minor = %llx", + val.major, val.minor); +} + +static void +prt_unique_handles(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Unique Handles = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_lease_time(XDR *xdr) +{ + uint32_t val; + + if (!xdr_uint32_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Lease Time = %u", val); +} + +static void +prt_rdattr_error(XDR *xdr) +{ + nfsstat4 val; + + if (!xdr_nfsstat4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Rdattr Error = %u (%s)", + val, status_name(val)); +} + +static void +prt_acl(XDR *xdr) +{ + static fattr4_acl val; + char buffy[NFS4_OPAQUE_LIMIT]; + int i, len; + + if (!xdr_fattr4_acl(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "ACL of %d entries", val.fattr4_acl_len); + for (i = 0; i < val.fattr4_acl_len; i++) { + sprintf(get_line(0, 0), "nfsace4[%d]", i); + + sprintf(get_line(0, 0), " type = %x", + val.fattr4_acl_val[i].type); + detail_acetype4(val.fattr4_acl_val[i].type); + + sprintf(get_line(0, 0), " flags = %x", + val.fattr4_acl_val[i].flag); + detail_aceflag4(val.fattr4_acl_val[i].flag); + + sprintf(get_line(0, 0), " mask = %x", + val.fattr4_acl_val[i].access_mask); + detail_acemask4(val.fattr4_acl_val[i].access_mask); + + len = val.fattr4_acl_val[i].who.utf8string_len; + if (len >= NFS4_OPAQUE_LIMIT) + len = NFS4_OPAQUE_LIMIT - 1; + (void) strncpy(buffy, val.fattr4_acl_val[i].who.utf8string_val, + len); + buffy[len] = '\0'; + sprintf(get_line(0, 0), " who = %s", buffy); + } + xdr_free(xdr_fattr4_acl, (char *)&val); +} + +static void +detail_acetype4(acetype4 type) +{ + if (type >= ACETYPE4_NAMES_MAX) { + sprintf(get_line(0, 0), " unknown type"); + } else { + sprintf(get_line(0, 0), " %s", acetype4_names[type]); + } +} + +static void +detail_uint32_bitmap(uint32_t mask, char *mask_names[], int names_max) +{ + char buffy[BUFSIZ], *name; + char *indent = " "; + char *spacer = " "; + int pending = 0; + int bit; + int len, namelen, spacelen; + + strcpy(buffy, indent); + len = strlen(buffy); + spacelen = strlen(spacer); + + for (bit = 0; bit < names_max; bit++) { + if (mask & (1 << bit)) { + name = mask_names[bit]; + namelen = strlen(name); + /* 80 - 6 for "NFS: " = 74 */ + if ((len + spacelen + namelen) >= 74) { + sprintf(get_line(0, 0), "%s", buffy); + strcpy(buffy, indent); + len = strlen(buffy); + pending = 0; + } + (void) strlcat(buffy, spacer, sizeof (buffy)); + (void) strlcat(buffy, name, sizeof (buffy)); + pending = 1; + len += spacelen + namelen; + } + } + if (pending) + sprintf(get_line(0, 0), "%s", buffy); +} + +static void +detail_aceflag4(aceflag4 flag) +{ + detail_uint32_bitmap(flag, aceflag4_names, ACEFLAG4_NAMES_MAX); +} + +static void +detail_acemask4(acemask4 mask) +{ + detail_uint32_bitmap(mask, acemask4_names, ACEMASK4_NAMES_MAX); +} + +static void +prt_aclsupport(XDR *xdr) +{ + fattr4_aclsupport val; + + if (!xdr_fattr4_aclsupport(xdr, &val)) + longjmp(xdr_err, 1); + if (val & ACL4_SUPPORT_ALLOW_ACL) + sprintf(get_line(0, 0), "ALLOW ACL Supported"); + if (val & ACL4_SUPPORT_DENY_ACL) + sprintf(get_line(0, 0), "DENY ACL Supported"); + if (val & ACL4_SUPPORT_AUDIT_ACL) + sprintf(get_line(0, 0), "AUDIT ACL Supported"); + if (val & ACL4_SUPPORT_ALARM_ACL) + sprintf(get_line(0, 0), "ALARM ACL Supported"); +} + +static void +prt_archive(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Archived = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_cansettime(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Server Can Set Time = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_case_insensitive(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Case Insensitive Lookups = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_case_preserving(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Case Preserving = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_chown_restricted(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Chown Is Restricted = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_filehandle(XDR *xdr) +{ + static nfs_fh4 val; + + if (!xdr_nfs_fh4(xdr, &val)) + longjmp(xdr_err, 1); + detail_fh4(&val); + xdr_free(xdr_nfs_fh4, (char *)&val); +} + +static void +prt_fileid(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "File ID = %llu", val); +} + +static void +prt_mounted_on_fileid(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Mounted On File ID = %llu", val); +} + +static void +prt_files_avail(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Files Available = %llu", val); +} + +static void +prt_files_free(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Files Free = %llu", val); +} + +static void +prt_files_total(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Files Total = %llu", val); +} + +static void +prt_fs_location(fs_location4 *fsl) +{ + int i; + + for (i = 0; i < fsl->server.server_len; i++) + sprintf(get_line(0, 0), "server: %s", + utf8localize(&fsl->server.server_val[i])); + + detail_pathname4(&fsl->rootpath, "rootpath: "); +} + +static void +prt_fs_locations(XDR *xdr) +{ + static fs_locations4 val; + int i; + + if (!xdr_fs_locations4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "[fs_locations]"); + detail_pathname4(&val.fs_root, "fs_root: "); + for (i = 0; i < val.locations.locations_len; i++) + prt_fs_location(&val.locations.locations_val[i]); + xdr_free(xdr_fs_locations4, (char *)&val); +} + +static void +prt_hidden(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Hidden = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_homogeneous(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "FS Is Homogeneous = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_maxfilesize(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Maximum File Size = %llu", val); +} + +static void +prt_maxlink(XDR *xdr) +{ + uint32_t val; + + if (!xdr_uint32_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Maximum Number of Links = %u", val); +} + +static void +prt_maxname(XDR *xdr) +{ + uint32_t val; + + if (!xdr_uint32_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Maximum File Name Length = %u", val); +} + +static void +prt_maxread(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Maximum Read Size = %llu", val); +} + +static void +prt_maxwrite(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + + sprintf(get_line(0, 0), "Maximum Write Size = %llu", val); +} + +static void +prt_mimetype(XDR *xdr) +{ + static utf8string val; + + if (!xdr_utf8string(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "MIME Type = %s", utf8localize(&val)); + xdr_free(xdr_utf8string, (char *)&val); +} + +static void +prt_mode(XDR *xdr) +{ + mode4 val; + + if (!xdr_mode4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Mode = 0%03o", val); +} + +static void +prt_no_trunc(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Long Names Are Error (no_trunc) = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_numlinks(XDR *xdr) +{ + uint32_t val; + + if (!xdr_uint32_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Number of Links = %u", val); +} + +static void +prt_owner(XDR *xdr) +{ + static utf8string val; + + if (!xdr_utf8string(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Owner = %s", utf8localize(&val)); + xdr_free(xdr_utf8string, (char *)&val); +} + +static void +prt_owner_group(XDR *xdr) +{ + static utf8string val; + + if (!xdr_utf8string(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Group = %s", utf8localize(&val)); + xdr_free(xdr_utf8string, (char *)&val); +} + +static void +prt_quota_avail_hard(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Quota Hard Limit = %llu", val); +} + +static void +prt_quota_avail_soft(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Quota Soft Limit = %llu", val); +} + +static void +prt_quota_used(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Quota Used = %llu", val); +} + +static void +prt_rawdev(XDR *xdr) +{ + specdata4 val; + + if (!xdr_specdata4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Raw Device ID = %u, %u", + val.specdata1, val.specdata2); +} + +static void +prt_space_avail(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Space Available = %llu", val); +} + +static void +prt_space_free(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Space Free = %llu", val); +} + +static void +prt_space_total(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Total Disk Space = %llu", val); +} + +static void +prt_space_used(XDR *xdr) +{ + uint64_t val; + + if (!xdr_uint64_t(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Space Used (this object) = %llu", val); +} + +static void +prt_system(XDR *xdr) +{ + bool_t val; + + if (!xdr_bool(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "System File = %s", + val ? "TRUE" : "FALSE"); +} + +static void +prt_time_access(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Last Access Time = %s", + format_time(val.seconds, val.nseconds)); +} + +static void +prt_time_access_set(XDR *xdr) +{ + settime4 val; + + if (!xdr_settime4(xdr, &val)) + longjmp(xdr_err, 1); + if (val.set_it == SET_TO_CLIENT_TIME4) { + sprintf(get_line(0, 0), "Access Time = %s (set to client time)", + format_time(val.settime4_u.time.seconds, + val.settime4_u.time.nseconds)); + } else if (val.set_it == SET_TO_SERVER_TIME4) { + sprintf(get_line(0, 0), "Access Time (set to server time)"); + } else + longjmp(xdr_err, 1); +} + +static void +prt_time_backup(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Last Backup Time = %s", + format_time(val.seconds, val.nseconds)); +} + +static void +prt_time_create(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Creation Time = %s", + format_time(val.seconds, val.nseconds)); +} + +static void +prt_time_delta(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Server Time Granularity = %lld.%09d sec", + val.seconds, val.nseconds); +} + +static void +prt_time_metadata(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Last Metadata Change Time = %s", + format_time(val.seconds, val.nseconds)); +} + +static void +prt_time_modify(XDR *xdr) +{ + nfstime4 val; + + if (!xdr_nfstime4(xdr, &val)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), "Last Modification Time = %s", + format_time(val.seconds, val.nseconds)); +} + +static void +prt_time_modify_set(XDR *xdr) +{ + settime4 val; + + if (!xdr_settime4(xdr, &val)) + longjmp(xdr_err, 1); + if (val.set_it == SET_TO_CLIENT_TIME4) { + sprintf(get_line(0, 0), + "Modification Time = %s (set to client time)", + format_time(val.settime4_u.time.seconds, + val.settime4_u.time.nseconds)); + } else if (val.set_it == SET_TO_SERVER_TIME4) { + sprintf(get_line(0, 0), + "Modification Time (set to server time)"); + } else + longjmp(xdr_err, 1); +} + +/* + * Display the UTF8 string that is next in the XDR stream. + */ + +static void +showxdr_utf8string(char *fmt) +{ + static utf8string string; + + if (!xdr_utf8string(&xdrm, &string)) + longjmp(xdr_err, 1); + sprintf(get_line(0, 0), fmt, utf8localize(&string)); + xdr_free(xdr_utf8string, (char *)&string); +} + +/* + * utf8string is defined in nfs4_prot.x as an opaque array, which means + * when it is decoded into a string, the string might not have a trailing + * null. Also, the string will still be encoded in UTF-8, rather than + * whatever character encoding is associated with the current locale. This + * routine converts a utf8string into a (null-terminated) C string. One day + * it will convert into the current character encoding, too. To avoid + * dealing with storage management issues, it allocates storage for each + * new string, then this storage is "freed" when the packet has been + * processed. + */ + +#define MAX_UTF8_STRINGS 512 + +static char *utf_buf[MAX_UTF8_STRINGS]; +static size_t utf_buflen[MAX_UTF8_STRINGS]; +static uint_t cur_utf_buf = 0; + +static char * +utf8localize(utf8string *utf8str) +{ + size_t newsize, oldsize, len; + char *result, *cp; + + len = utf8str->utf8string_len; + if (len == 0) + return (""); + if (cur_utf_buf >= MAX_UTF8_STRINGS) + return ("[Too Many UTF-8 Strings]"); + + newsize = oldsize = utf_buflen[cur_utf_buf]; + + + if (oldsize < len + 1) { + /* truncate opaques at NFS4_OPAQUE_LIMIT */ + if (len > NFS4_OPAQUE_LIMIT) + len = NFS4_OPAQUE_LIMIT; + newsize = len + 1; + } + if (newsize != oldsize) { + utf_buf[cur_utf_buf] = realloc(utf_buf[cur_utf_buf], + newsize); + if (utf_buf[cur_utf_buf] == NULL) { + pr_err("out of memory\n"); + utf_buflen[cur_utf_buf] = 0; + return (""); + } + utf_buflen[cur_utf_buf] = newsize; + } + + result = utf_buf[cur_utf_buf]; + strncpy(result, utf8str->utf8string_val, len); + result[len] = '\0'; + for (cp = result; cp < result + len; cp++) { + if (!isprint(*cp)) { + *cp = '.'; + } + } + + cur_utf_buf++; + + return (result); +} + +static void +utf8free() +{ + cur_utf_buf = 0; +} + + +/* + * adler16(): adler32 hash code shamelessly copied and mutiliated from + * usr/src/uts/common/io/ppp/spppcomp/zlib.[ch] + * + * The alg was originally created to provide a running + * checksum, but we don't need that -- we just want to + * chksum data described by buf,len; therefore, the first + * parameter was removed (held the running checksum), + * and s1/s2 are always set to their required initial + * values (1 and 0). I also ripped out code which only + * applied to large data sets (bufs larger than 5k). All + * I wanted was their core checksum alg (which is supposed + * to do really well). The v2/v3 hash alg didn't work well + * at all for v4 stuff -- it produced too many collisions. + * + * The copyright info from uts/common/io/ppp/spppcomp/zlib.[ch] + * is included below. + */ + +/* -----zlib.c copyright info below */ +/* + * Copyright 2000 Sun Microsystems, Inc. + * All rights reserved. + * + * Updated from zlib-1.0.4 to zlib-1.1.3 by James Carlson. + * + * This file is derived from various .h and .c files from the zlib-1.0.4 + * distribution by Jean-loup Gailly and Mark Adler, with some additions + * by Paul Mackerras to aid in implementing Deflate compression and + * decompression for PPP packets. See zlib.h for conditions of + * distribution and use. + * + * Changes that have been made include: + * - added Z_PACKET_FLUSH (see zlib.h for details) + * - added inflateIncomp and deflateOutputPending + * - allow strm->next_out to be NULL, meaning discard the output + * + * $Id: zlib.c,v 1.11 1998/09/13 23:37:12 paulus Exp $ + */ +/* +++ adler32.c */ +/* + * adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-1998 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ +/* From: adler32.c,v 1.10 1996/05/22 11:52:18 me Exp $ */ +/* -----zlib.c copyright info above */ + +/* -----zlib.h copyright info below */ +/* + * Copyright 2000 Sun Microsystems, Inc. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and + * its documentation is hereby granted, provided that the above + * copyright notice appears in all copies. + * + * SUN MAKES NO REPRESENTATION OR WARRANTIES ABOUT THE SUITABILITY OF + * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED + * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE + * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, + * MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES + * + * This file has been altered from its original by Sun Microsystems to + * fit local coding style. + */ +/* -----zlib.h copyright info above */ + +#define DO1(buf, i) {s1 += buf[i]; s2 += s1; } +#define DO2(buf, i) DO1(buf, i); DO1(buf, i+1); +#define DO4(buf, i) DO2(buf, i); DO2(buf, i+2); +#define DO8(buf, i) DO4(buf, i); DO4(buf, i+4); +#define DO16(buf) DO8(buf, 0); DO8(buf, 8); + +static uint32_t +adler16(void *p, int len) +{ + uint32_t s1 = 1; + uint32_t s2 = 0; + uchar_t *buf = p; + + while (len >= 16) { + DO16(buf); + buf += 16; + len -= 16; + } + + while (len > 0) { + s1 += *buf++; + s2 += s1; + len--; + } + + return ((uint32_t)(s2 ^ s1) & 0xFFFFU); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs_acl.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs_acl.c new file mode 100644 index 0000000..4883ed5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nfs_acl.c @@ -0,0 +1,797 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ +/* + * Copyright 2014 Nexenta Systems, Inc. All rights reserved. + */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <setjmp.h> +#include <pwd.h> +#include <grp.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <string.h> +#include "snoop.h" + +#include <sys/stat.h> + +extern char *get_sum_line(); +extern void check_retransmit(); +extern char *sum_nfsfh(); +extern int sum_nfsstat(); +extern int detail_nfsstat(); +extern void detail_nfsfh(); +extern void detail_fattr(); +extern void skip_fattr(); +extern char *sum_nfsfh3(); +extern int sum_nfsstat3(); +extern int detail_nfsstat3(); +extern void detail_post_op_attr(); +extern void detail_nfsfh3(); +extern int sum_nfsstat4(); +extern int detail_nfsstat4(); + +extern jmp_buf xdr_err; + +static void aclcall2(); +static void aclreply2(); +static void aclcall3(); +static void aclreply3(); +static void aclcall4(); +static void aclreply4(); +static void detail_access2(); +static char *sum_access2(); +static void detail_mask(); +static void detail_secattr(); +static void detail_aclent(); +static char *detail_uname(); +static char *detail_gname(); +static char *detail_perm(ushort_t); +static void interpret_nfs_acl2(int, int, int, int, int, char *, int); +static void interpret_nfs_acl3(int, int, int, int, int, char *, int); +static void interpret_nfs_acl4(int, int, int, int, int, char *, int); + +#define ACLPROC2_NULL ((unsigned long)(0)) +#define ACLPROC2_GETACL ((unsigned long)(1)) +#define ACLPROC2_SETACL ((unsigned long)(2)) +#define ACLPROC2_GETATTR ((unsigned long)(3)) +#define ACLPROC2_ACCESS ((unsigned long)(4)) +#define ACLPROC2_GETXATTRDIR ((unsigned long)(5)) + +#define ACLPROC3_NULL ((unsigned long)(0)) +#define ACLPROC3_GETACL ((unsigned long)(1)) +#define ACLPROC3_SETACL ((unsigned long)(2)) +#define ACLPROC3_GETXATTRDIR ((unsigned long)(3)) + +#define ACLPROC4_NULL ((unsigned long)(0)) +#define ACLPROC4_GETACL ((unsigned long)(1)) +#define ACLPROC4_SETACL ((unsigned long)(2)) + +#define NA_USER_OBJ 0x1 +#define NA_USER 0x2 +#define NA_GROUP_OBJ 0x4 +#define NA_GROUP 0x8 +#define NA_CLASS_OBJ 0x10 +#define NA_OTHER_OBJ 0x20 +#define NA_ACL_DEFAULT 0x1000 + +#define NA_DEF_USER_OBJ (NA_USER_OBJ | NA_ACL_DEFAULT) +#define NA_DEF_USER (NA_USER | NA_ACL_DEFAULT) +#define NA_DEF_GROUP_OBJ (NA_GROUP_OBJ | NA_ACL_DEFAULT) +#define NA_DEF_GROUP (NA_GROUP | NA_ACL_DEFAULT) +#define NA_DEF_CLASS_OBJ (NA_CLASS_OBJ | NA_ACL_DEFAULT) +#define NA_DEF_OTHER_OBJ (NA_OTHER_OBJ | NA_ACL_DEFAULT) + +#define NA_ACL 0x1 +#define NA_ACLCNT 0x2 +#define NA_DFACL 0x4 +#define NA_DFACLCNT 0x8 + +#define ACCESS2_READ 0x0001 +#define ACCESS2_LOOKUP 0x0002 +#define ACCESS2_MODIFY 0x0004 +#define ACCESS2_EXTEND 0x0008 +#define ACCESS2_DELETE 0x0010 +#define ACCESS2_EXECUTE 0x0020 + +static char *procnames_short_v2[] = { + "NULL2", /* 0 */ + "GETACL2", /* 1 */ + "SETACL2", /* 2 */ + "GETATTR2", /* 3 */ + "ACCESS2", /* 4 */ + "GETXATTRDIR2", /* 5 */ +}; +static char *procnames_short_v3[] = { + "NULL3", /* 0 */ + "GETACL3", /* 1 */ + "SETACL3", /* 2 */ + "GETXATTRDIR3", /* 3 */ +}; +static char *procnames_short_v4[] = { + "NULL4", /* 0 */ + "GETACL4", /* 1 */ + "SETACL4", /* 2 */ +}; + +static char *procnames_long_v2[] = { + "Null procedure", /* 0 */ + "Get file access control list", /* 1 */ + "Set file access control list", /* 2 */ + "Get file attributes", /* 3 */ + "Check access permission", /* 4 */ + "Get extended attribute directory", /* 5 */ +}; +static char *procnames_long_v3[] = { + "Null procedure", /* 0 */ + "Get file access control list", /* 1 */ + "Set file access control list", /* 2 */ + "Get extended attribute directory", /* 3 */ +}; +static char *procnames_long_v4[] = { + "Null procedure", /* 0 */ + "Get file access control list", /* 1 */ + "Set file access control list", /* 2 */ +}; + +#define MAXPROC_V2 5 +#define MAXPROC_V3 3 +#define MAXPROC_V4 2 + +/* ARGSUSED */ +void +interpret_nfs_acl(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + + if (vers == 2) { + interpret_nfs_acl2(flags, type, xid, vers, proc, data, len); + return; + } + + if (vers == 3) { + interpret_nfs_acl3(flags, type, xid, vers, proc, data, len); + return; + } + + if (vers == 4) { + interpret_nfs_acl4(flags, type, xid, vers, proc, data, len); + return; + } +} + +static void +interpret_nfs_acl2(int flags, int type, int xid, int vers, int proc, + char *data, int len) +{ + char *line; + char buff[2048]; + int off, sz; + char *fh; + ulong_t mask; + + if (proc < 0 || proc > MAXPROC_V2) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS_ACL C %s", + procnames_short_v2[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC2_GETACL: + fh = sum_nfsfh(); + mask = getxdr_u_long(); + (void) sprintf(line, "%s mask=0x%lx", fh, mask); + break; + case ACLPROC2_SETACL: + (void) sprintf(line, sum_nfsfh()); + break; + case ACLPROC2_GETATTR: + (void) sprintf(line, sum_nfsfh()); + break; + case ACLPROC2_ACCESS: + fh = sum_nfsfh(); + (void) sprintf(line, "%s (%s)", fh, + sum_access2()); + break; + case ACLPROC2_GETXATTRDIR: + fh = sum_nfsfh(); + (void) sprintf(line, "%s create=%s", fh, + getxdr_bool() ? "true" : "false"); + break; + default: + break; + } + + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NFS_ACL R %s ", + procnames_short_v2[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC2_GETACL: + (void) sum_nfsstat(line); + break; + case ACLPROC2_SETACL: + (void) sum_nfsstat(line); + break; + case ACLPROC2_GETATTR: + (void) sum_nfsstat(line); + break; + case ACLPROC2_ACCESS: + if (sum_nfsstat(line) == 0) { + skip_fattr(); + line += strlen(line); + (void) sprintf(line, " (%s)", + sum_access2()); + } + break; + case ACLPROC2_GETXATTRDIR: + if (sum_nfsstat(line) == 0) { + line += strlen(line); + (void) sprintf(line, sum_nfsfh()); + } + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NFS_ACL: ", "Sun NFS_ACL", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long_v2[proc]); + if (type == CALL) + aclcall2(proc); + else + aclreply2(proc); + show_trailer(); + } +} + +static void +interpret_nfs_acl3(int flags, int type, int xid, int vers, int proc, + char *data, int len) +{ + char *line; + char buff[2048]; + int off, sz; + char *fh; + ulong_t mask; + + if (proc < 0 || proc > MAXPROC_V3) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS_ACL C %s", + procnames_short_v3[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC3_GETACL: + fh = sum_nfsfh3(); + mask = getxdr_u_long(); + (void) sprintf(line, "%s mask=0x%lx", fh, mask); + break; + case ACLPROC3_SETACL: + (void) sprintf(line, sum_nfsfh3()); + break; + case ACLPROC3_GETXATTRDIR: + fh = sum_nfsfh3(); + (void) sprintf(line, "%s create=%s", fh, + getxdr_bool() ? "true" : "false"); + break; + default: + break; + } + + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NFS_ACL R %s ", + procnames_short_v3[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC3_GETACL: + (void) sum_nfsstat3(line); + break; + case ACLPROC3_SETACL: + (void) sum_nfsstat3(line); + break; + case ACLPROC3_GETXATTRDIR: + if (sum_nfsstat3(line) == 0) { + line += strlen(line); + (void) sprintf(line, sum_nfsfh3()); + } + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NFS_ACL: ", "Sun NFS_ACL", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long_v3[proc]); + if (type == CALL) + aclcall3(proc); + else + aclreply3(proc); + show_trailer(); + } +} + +static void +interpret_nfs_acl4(int flags, int type, int xid, int vers, int proc, + char *data, int len) +{ + char *line; + char buff[2048]; + int off, sz; + char *fh; + ulong_t mask; + + if (proc < 0 || proc > MAXPROC_V4) + return; + + if (flags & F_SUM) { + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "NFS_ACL C %s", + procnames_short_v4[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC4_GETACL: + fh = sum_nfsfh3(); + mask = getxdr_u_long(); + (void) sprintf(line, "%s mask=0x%lx", fh, mask); + break; + case ACLPROC4_SETACL: + (void) sprintf(line, sum_nfsfh3()); + break; + default: + break; + } + + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NFS_ACL R %s ", + procnames_short_v4[proc]); + line += strlen(line); + switch (proc) { + case ACLPROC4_GETACL: + (void) sum_nfsstat4(line); + break; + case ACLPROC4_SETACL: + (void) sum_nfsstat4(line); + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NFS_ACL: ", "Sun NFS_ACL", len); + show_space(); + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", + proc, procnames_long_v4[proc]); + if (type == CALL) + aclcall4(proc); + else + aclreply4(proc); + show_trailer(); + } +} + +int +sum_nfsstat4(char *line) +{ + ulong_t status; + char *p, *nfsstat4_to_name(int); + + status = getxdr_long(); + p = nfsstat4_to_name(status); + (void) strcpy(line, p); + return (status); +} + +int +detail_nfsstat4() +{ + ulong_t status; + char buff[64]; + int pos; + + pos = getxdr_pos(); + status = sum_nfsstat4(buff); + + (void) sprintf(get_line(pos, getxdr_pos()), "Status = %d (%s)", + status, buff); + + return ((int)status); +} + +/* + * Print out version 2 NFS_ACL call packets + */ +static void +aclcall2(proc) + int proc; +{ + + switch (proc) { + case ACLPROC2_GETACL: + detail_nfsfh(); + detail_mask(); + break; + case ACLPROC2_SETACL: + detail_nfsfh(); + detail_secattr(); + break; + case ACLPROC2_GETATTR: + detail_nfsfh(); + break; + case ACLPROC2_ACCESS: + detail_nfsfh(); + detail_access2(); + break; + default: + break; + } +} + +/* + * Print out version 2 NFS_ACL reply packets + */ +static void +aclreply2(proc) + int proc; +{ + + switch (proc) { + case ACLPROC2_GETACL: + if (detail_nfsstat() == 0) { + detail_fattr(); + detail_secattr(); + } + break; + case ACLPROC2_SETACL: + if (detail_nfsstat() == 0) + detail_fattr(); + break; + case ACLPROC2_GETATTR: + if (detail_nfsstat() == 0) + detail_fattr(); + break; + case ACLPROC2_ACCESS: + if (detail_nfsstat() == 0) { + detail_fattr(); + detail_access2(); + } + break; + default: + break; + } +} + +/* + * Print out version 3 NFS_ACL call packets + */ +static void +aclcall3(proc) + int proc; +{ + + switch (proc) { + case ACLPROC3_GETACL: + detail_nfsfh3(); + detail_mask(); + break; + case ACLPROC3_SETACL: + detail_nfsfh3(); + detail_secattr(); + break; + default: + break; + } +} + +/* + * Print out version 3 NFS_ACL reply packets + */ +static void +aclreply3(proc) + int proc; +{ + + switch (proc) { + case ACLPROC3_GETACL: + if (detail_nfsstat3() == 0) { + detail_post_op_attr(""); + detail_secattr(); + } + break; + case ACLPROC3_SETACL: + if (detail_nfsstat3() == 0) + detail_post_op_attr(""); + break; + default: + break; + } +} + +/* + * Print out version 4 NFS_ACL call packets + */ +static void +aclcall4(proc) + int proc; +{ + + switch (proc) { + case ACLPROC4_GETACL: + detail_nfsfh3(); + detail_mask(); + break; + case ACLPROC4_SETACL: + detail_nfsfh3(); + detail_secattr(); + break; + default: + break; + } +} + +/* + * Print out version 4 NFS_ACL reply packets + */ +static void +aclreply4(proc) + int proc; +{ + + switch (proc) { + case ACLPROC4_GETACL: + if (detail_nfsstat4() == 0) { + detail_post_op_attr(""); + detail_secattr(); + } + break; + case ACLPROC4_SETACL: + if (detail_nfsstat4() == 0) + detail_post_op_attr(""); + break; + default: + break; + } +} + +static void +detail_access2() +{ + uint_t bits; + + bits = showxdr_u_long("Access bits = 0x%08x"); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_READ, "Read", "(no read)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_LOOKUP, "Lookup", "(no lookup)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_MODIFY, "Modify", "(no modify)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_EXTEND, "Extend", "(no extend)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_DELETE, "Delete", "(no delete)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(bits, ACCESS2_EXECUTE, "Execute", "(no execute)")); +} + +static char * +sum_access2() +{ + int bits; + static char buff[22]; + + bits = getxdr_u_long(); + buff[0] = '\0'; + + if (bits & ACCESS2_READ) + (void) strcat(buff, "read,"); + if (bits & ACCESS2_LOOKUP) + (void) strcat(buff, "lookup,"); + if (bits & ACCESS2_MODIFY) + (void) strcat(buff, "modify,"); + if (bits & ACCESS2_EXTEND) + (void) strcat(buff, "extend,"); + if (bits & ACCESS2_DELETE) + (void) strcat(buff, "delete,"); + if (bits & ACCESS2_EXECUTE) + (void) strcat(buff, "execute,"); + if (buff[0] != '\0') + buff[strlen(buff) - 1] = '\0'; + + return (buff); +} + +static void +detail_mask() +{ + ulong_t mask; + + mask = showxdr_u_long("Mask = 0x%lx"); + (void) sprintf(get_line(0, 0), " %s", + getflag(mask, NA_ACL, "aclent", "(no aclent)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(mask, NA_ACLCNT, "aclcnt", "(no aclcnt)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(mask, NA_DFACL, "dfaclent", "(no dfaclent)")); + (void) sprintf(get_line(0, 0), " %s", + getflag(mask, NA_DFACLCNT, "dfaclcnt", "(no dfaclcnt)")); +} + +static void +detail_secattr() +{ + + detail_mask(); + showxdr_long("Aclcnt = %d"); + detail_aclent(); + showxdr_long("Dfaclcnt = %d"); + detail_aclent(); +} + +static void +detail_aclent() +{ + int count; + int type; + int id; + ushort_t perm; + + count = getxdr_long(); + while (count-- > 0) { + type = getxdr_long(); + id = getxdr_long(); + perm = getxdr_u_short(); + switch (type) { + case NA_USER: + (void) sprintf(get_line(0, 0), "\tuser:%s:%s", + detail_uname(id), detail_perm(perm)); + break; + case NA_USER_OBJ: + (void) sprintf(get_line(0, 0), "\tuser::%s", + detail_perm(perm)); + break; + case NA_GROUP: + (void) sprintf(get_line(0, 0), "\tgroup:%s:%s", + detail_gname(id), detail_perm(perm)); + break; + case NA_GROUP_OBJ: + (void) sprintf(get_line(0, 0), "\tgroup::%s", + detail_perm(perm)); + break; + case NA_CLASS_OBJ: + (void) sprintf(get_line(0, 0), "\tmask:%s", + detail_perm(perm)); + break; + case NA_OTHER_OBJ: + (void) sprintf(get_line(0, 0), "\tother:%s", + detail_perm(perm)); + break; + case NA_DEF_USER: + (void) sprintf(get_line(0, 0), "\tdefault:user:%s:%s", + detail_uname(id), detail_perm(perm)); + break; + case NA_DEF_USER_OBJ: + (void) sprintf(get_line(0, 0), "\tdefault:user::%s", + detail_perm(perm)); + break; + case NA_DEF_GROUP: + (void) sprintf(get_line(0, 0), "\tdefault:group:%s:%s", + detail_gname(id), detail_perm(perm)); + break; + case NA_DEF_GROUP_OBJ: + (void) sprintf(get_line(0, 0), "\tdefault:group::%s", + detail_perm(perm)); + break; + case NA_DEF_CLASS_OBJ: + (void) sprintf(get_line(0, 0), "\tdefault:mask:%s", + detail_perm(perm)); + break; + case NA_DEF_OTHER_OBJ: + (void) sprintf(get_line(0, 0), "\tdefault:other:%s", + detail_perm(perm)); + break; + default: + (void) sprintf(get_line(0, 0), "\tunrecognized entry"); + break; + } + } +} + +static char * +detail_uname(uid_t uid) +{ + struct passwd *pwd; + static char uidp[10]; + + pwd = getpwuid(uid); + if (pwd == NULL) { + sprintf(uidp, "%d", uid); + return (uidp); + } + return (pwd->pw_name); +} + +static char * +detail_gname(gid_t gid) +{ + struct group *grp; + static char gidp[10]; + + grp = getgrgid(gid); + if (grp == NULL) { + sprintf(gidp, "%d", gid); + return (gidp); + } + return (grp->gr_name); +} + +static char *perms[] = { + "---", + "--x", + "-w-", + "-wx", + "r--", + "r-x", + "rw-", + "rwx" +}; +static char * +detail_perm(ushort_t perm) +{ + + if (perm >= sizeof (perms) / sizeof (perms[0])) + return ("?"); + return (perms[perm]); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nis.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nis.c new file mode 100644 index 0000000..a78c418 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nis.c @@ -0,0 +1,676 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <string.h> + +#include <sys/socket.h> +#include <sys/sockio.h> +#include <sys/tiuser.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpcsvc/yp_prot.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; +char *ypbind_error(); +char *sum_ypxfrstat(); +char *sum_ypmaplist(); +void detail_ypmaplist(); + +static void niscall(int); +static void nisreply(int); +static int detail_ypstat(void); +static int sum_ypstat(char *); + +/* + * Defines missing from 5.0 yp_prot.h + */ +#define YPBINDPROG ((ulong_t)100007) +#define YPBINDVERS ((ulong_t)2) +#define YPBINDVERS_ORIG ((ulong_t)1) + +/* Procedure symbols */ + +#define YPBINDPROC_NULL ((ulong_t)0) +#define YPBINDPROC_DOMAIN ((ulong_t)1) +#define YPBINDPROC_SETDOM ((ulong_t)2) + +#define YPBIND_ERR_ERR 1 /* Internal error */ +#define YPBIND_ERR_NOSERV 2 /* No bound server for passed domain */ +#define YPBIND_ERR_RESC 3 /* System resource allocation failure */ + + +static char *procnames_bind_short[] = { + "NULL", /* 0 */ + "DOMAIN", /* 1 */ + "SETDOMAIN", /* 2 */ +}; + +static char *procnames_bind_long[] = { + "Null procedure", /* 0 */ + "Get domain name", /* 1 */ + "Set domain name", /* 2 */ +}; + +static char *procnames_short[] = { + "NULL", /* 0 */ + "DOMAIN", /* 1 */ + "DOMAIN_NONACK", /* 2 */ + "MATCH", /* 3 */ + "FIRST", /* 4 */ + "NEXT", /* 5 */ + "XFR", /* 6 */ + "CLEAR", /* 7 */ + "ALL", /* 8 */ + "MASTER", /* 9 */ + "ORDER", /* 10 */ + "MAPLIST", /* 11 */ + "NEWXFR", /* 12 */ +}; + +#define MAXPROC_BIND 2 +#define MAXPROC 12 + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Verify domain support", /* 1 */ + "Verify domain support (broadcast)", /* 2 */ + "Return value of a key", /* 3 */ + "Return first key-value pair in map", /* 4 */ + "Return next key-value pair in map", /* 5 */ + "Request map update (old)", /* 6 */ + "Close current map on server", /* 7 */ + "Get all key-value pairs in map", /* 8 */ + "Get master server", /* 9 */ + "Get order", /* 10 */ + "Return list of supported maps", /* 11 */ + "Request map update", /* 12 */ +}; + +void +interpret_nisbind(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[YPMAXDOMAIN + 1]; + unsigned int status; + + if (proc < 0 || proc > MAXPROC_BIND) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "NISBIND C %s", + procnames_bind_short[proc]); + line += strlen(line); + switch (proc) { + case YPBINDPROC_NULL: + break; + case YPBINDPROC_DOMAIN: + (void) sprintf(line, " %s", + getxdr_string(buff, YPMAXDOMAIN)); + break; + case YPBINDPROC_SETDOM: + (void) sprintf(line, " %s", + getxdr_string(buff, YPMAXDOMAIN)); + break; + default: + break; + } + check_retransmit(line, xid); + } else { + (void) sprintf(line, "NISBIND R %s ", + procnames_bind_short[proc]); + line += strlen(line); + switch (proc) { + case YPBINDPROC_NULL: + break; + case YPBINDPROC_DOMAIN: + status = getxdr_long(); + if (status == 1) { /* success */ + (void) strcat(line, "OK"); + } else { /* failure */ + status = getxdr_long(); + (void) sprintf(line, "ERROR=%s", + ypbind_error(status)); + } + break; + case YPBINDPROC_SETDOM: + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NISBIND:", + "Network Information Service Bind", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_bind_long[proc]); + if (type == CALL) { + switch (proc) { + case YPBINDPROC_NULL: + break; + case YPBINDPROC_DOMAIN: + (void) showxdr_string(YPMAXDOMAIN, + "Domain = %s"); + break; + case YPBINDPROC_SETDOM: + (void) showxdr_string(YPMAXDOMAIN, + "Domain = %s"); + (void) showxdr_hex(4, "Address=%s"); + (void) showxdr_hex(2, "Port=%s"); + (void) showxdr_u_long("Version=%lu"); + break; + default: + break; + } + } else { + switch (proc) { + case YPBINDPROC_NULL: + break; + case YPBINDPROC_DOMAIN: + status = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Status = %lu (%s)", + status, + status == 1 ? "OK":"Fail"); + if (status == 1) { + (void) showxdr_hex(4, + "Address=%s"); + (void) showxdr_hex(2, + "Port=%s"); + } else { + status = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Error = %lu (%s)", + status, + ypbind_error(status)); + } + break; + case YPBINDPROC_SETDOM: + break; + default: + break; + } + } + show_trailer(); + } +} + +void +interpret_nis(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char *dom, *map, *key; + int transid, status; + /* buffers are all the same size so we don't have to keep track */ + char buff1[YPMAXRECORD + 1], buff2[YPMAXRECORD + 1]; + char buff3[YPMAXRECORD + 1]; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + if (proc > MAXPROC) + (void) sprintf(line, "NIS C %d", proc); + else + (void) sprintf(line, + "NIS C %s", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case YPPROC_NULL: + break; + case YPPROC_DOMAIN: + case YPPROC_DOMAIN_NONACK: + case YPPROC_MAPLIST: + /* YPMAXDOMAIN > YPMAXMAP */ + (void) sprintf(line, " %s", + getxdr_string(buff1, YPMAXDOMAIN)); + break; + case YPPROC_FIRST: + dom = getxdr_string(buff1, YPMAXDOMAIN); + map = getxdr_string(buff2, YPMAXMAP); + (void) sprintf(line, " %s", map); + break; + case YPPROC_MATCH: + case YPPROC_NEXT: + dom = getxdr_string(buff1, YPMAXDOMAIN); + map = getxdr_string(buff2, YPMAXMAP); + key = getxdr_string(buff3, YPMAXRECORD); + (void) sprintf(line, + " %s in %s", + key, map); + break; + case YPPROC_NEWXFR: + case YPPROC_XFR: + dom = getxdr_string(buff1, YPMAXDOMAIN); + map = getxdr_string(buff2, YPMAXMAP); + (void) sprintf(line, + " map %s in %s", + map, dom); + break; + case YPPROC_CLEAR: + break; + case YPPROC_ALL: + case YPPROC_MASTER: + case YPPROC_ORDER: + dom = getxdr_string(buff1, YPMAXDOMAIN); + map = getxdr_string(buff2, YPMAXMAP); + (void) sprintf(line, + " map %s in %s", + map, dom); + break; + default: + break; + } + check_retransmit(line, xid); + } else { + if (proc > MAXPROC) + (void) sprintf(line, "NIS R %d ", proc); + else + (void) sprintf(line, "NIS R %s ", + procnames_short[proc]); + line += strlen(line); + switch (proc) { + case YPPROC_NULL: + break; + case YPPROC_DOMAIN: + case YPPROC_DOMAIN_NONACK: + (void) sprintf(line, "%s", + getxdr_long() ? "OK":"Fail"); + break; + case YPPROC_MATCH: + (void) sum_ypstat(line); + break; + case YPPROC_FIRST: + case YPPROC_NEXT: + if (sum_ypstat(line) == YP_TRUE) { + line += strlen(line); + (void) getxdr_string(buff1, + YPMAXRECORD); + (void) sprintf(line, " key=%s", + getxdr_string(buff1, + YPMAXRECORD)); + } + break; + case YPPROC_NEWXFR: + case YPPROC_XFR: + transid = getxdr_u_long(); + status = getxdr_long(); + (void) sprintf(line, "transid=%lu %s", + transid, + sum_ypxfrstat(status)); + break; + case YPPROC_CLEAR: + break; + case YPPROC_ALL: + if (getxdr_u_long()) { + (void) sum_ypstat(line); + line += strlen(line); + (void) sprintf(line, " key=%s", + getxdr_string(buff1, YPMAXRECORD)); + } else { + (void) sprintf(line, + "No more"); + } + break; + case YPPROC_MASTER: + if (sum_ypstat(line) == YP_TRUE) { + line += strlen(line); + (void) sprintf(line, " peer=%s", + getxdr_string(buff1, + YPMAXPEER)); + } + break; + case YPPROC_ORDER: + if (sum_ypstat(line) == YP_TRUE) { + line += strlen(line); + (void) sprintf(line, " order=%lu", + getxdr_u_long()); + } + break; + case YPPROC_MAPLIST: + if (sum_ypstat(line) == YP_TRUE) { + line += strlen(line); + (void) sprintf(line, " %s", + sum_ypmaplist()); + } + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NIS: ", "Network Information Service", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, + proc > MAXPROC ? "unknown" : procnames_long[proc]); + if (type == CALL) + niscall(proc); + else + nisreply(proc); + show_trailer(); + } +} + +/* + * Print out version 2 NIS call packets + */ + +static void +niscall(proc) + int proc; +{ + switch (proc) { + case YPPROC_NULL: + break; + case YPPROC_DOMAIN: + case YPPROC_DOMAIN_NONACK: + case YPPROC_MAPLIST: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + break; + case YPPROC_FIRST: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + (void) showxdr_string(YPMAXMAP, "Map = %s"); + break; + case YPPROC_MATCH: + case YPPROC_NEXT: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + (void) showxdr_string(YPMAXMAP, "Map = %s"); + (void) showxdr_string(YPMAXRECORD, "Key = %s"); + break; + case YPPROC_NEWXFR: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + (void) showxdr_string(YPMAXMAP, "Map = %s"); + (void) showxdr_u_long("Order = %lu"); + (void) showxdr_string(YPMAXPEER, "Peer = %s"); + (void) showxdr_u_long("Transid = %lu"); + (void) showxdr_u_long("Prog = %lu"); + (void) showxdr_string(YPMAXPEER, "Name = %s"); + break; + case YPPROC_XFR: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + (void) showxdr_string(YPMAXMAP, "Map = %s"); + (void) showxdr_u_long("Order = %lu"); + (void) showxdr_string(YPMAXPEER, "Peer = %s"); + (void) showxdr_u_long("Transid = %lu"); + (void) showxdr_u_long("Prog = %lu"); + (void) showxdr_u_long("Port = %lu"); + break; + case YPPROC_CLEAR: + break; + case YPPROC_ALL: + case YPPROC_MASTER: + case YPPROC_ORDER: + (void) showxdr_string(YPMAXDOMAIN, "Domain = %s"); + (void) showxdr_string(YPMAXMAP, "Map = %s"); + break; + default: + break; + } +} + +/* + * Print out version 2 NIS reply packets + */ + +void +nisreply(proc) + int proc; +{ + unsigned int xfrstat, more; + + switch (proc) { + case YPPROC_NULL: + break; + case YPPROC_DOMAIN: + case YPPROC_DOMAIN_NONACK: + (void) sprintf(get_line(0, 0), + "Result=%s", + getxdr_u_long() ? "OK":"Fail"); + break; + case YPPROC_MATCH: + (void) detail_ypstat(); + (void) showxdr_string(YPMAXRECORD, "Value = %s"); + break; + case YPPROC_FIRST: + case YPPROC_NEXT: + (void) detail_ypstat(); + (void) showxdr_string(YPMAXRECORD, "Value = %s"); + (void) showxdr_string(YPMAXRECORD, "Key = %s"); + break; + case YPPROC_NEWXFR: + case YPPROC_XFR: + (void) showxdr_u_long("Transid = %lu"); + xfrstat = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Transfer status = %lu (%s)", + xfrstat, sum_ypxfrstat(xfrstat)); + break; + case YPPROC_CLEAR: + break; + case YPPROC_ALL: + more = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "More = %s", + more ? "true" : "false"); + if (more) { + (void) detail_ypstat(); + (void) showxdr_string(YPMAXRECORD, "Value = %s"); + (void) showxdr_string(YPMAXRECORD, "Key = %s"); + } + break; + case YPPROC_MASTER: + (void) detail_ypstat(); + (void) showxdr_string(YPMAXPEER, "Peer = %s"); + case YPPROC_ORDER: + (void) detail_ypstat(); + (void) showxdr_u_long("Order=%lu"); + break; + case YPPROC_MAPLIST: + (void) detail_ypstat(); + detail_ypmaplist(); + break; + default: + break; + } +} + +char * +sum_ypxfrstat(status) + int status; +{ + static char buff [16]; + + switch (status) { + case 1: return ("Success"); + case 2: return ("Master's version not newer"); + case -1: return ("Can't find server for map"); + case -2: return ("No such domain"); + case -3: return ("Resource allocation failure"); + case -4: return ("RPC failure talking to server"); + case -5: return ("Can't get master address"); + case -6: return ("NIS server/map db error"); + case -7: return ("Bad arguments"); + case -8: return ("Local dbm operation failed"); + case -9: return ("Local file I/O operation failed"); + case -10: return ("Map version skew during transfer"); + case -11: return ("Can't send clear req to local ypserv"); + case -12: return ("No local order number in map"); + case -13: return ("Transfer error"); + case -14: return ("Transfer request refused"); + default: + (void) sprintf(buff, "(%d)", status); + return (buff); + } + /* NOTREACHED */ +} + +static int +sum_ypstat(line) + char *line; +{ + ulong_t status; + char *str; + char buff[16]; + + status = getxdr_u_long(); + switch (status) { + case YP_TRUE: str = "OK"; break; + case YP_NOMORE: str = "No more entries"; break; + case YP_FALSE: str = "Fail"; break; + case YP_NOMAP: str = "No such map"; break; + case YP_NODOM: str = "No such domain"; break; + case YP_NOKEY: str = "No such key"; break; + case YP_BADOP: str = "Invalid operation"; break; + case YP_BADDB: str = "Bad database"; break; + case YP_YPERR: str = "Server error"; break; + case YP_BADARGS:str = "Bad args"; break; + case YP_VERS: str = "Version mismatch"; break; + default: (void) sprintf(buff, "(%lu)", status); + str = buff; + break; + } + (void) strcpy(line, str); + return ((int)status); +} + +static int +detail_ypstat() +{ + ulong_t status; + char buff[32]; + + + status = sum_ypstat(buff); + (void) sprintf(get_line(0, 0), + "Status = %d (%s)", + status, buff); + + return ((int)status); +} + +char * +sum_ypmaplist() +{ + static char buff[YPMAXMAP + 1]; + int maps = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ maps", maps); + return (buff); + } + + while (getxdr_long()) { + (void) getxdr_string(buff, YPMAXMAP); + maps++; + } + + (void) sprintf(buff, "%d maps", maps); + return (buff); +} + +void +detail_ypmaplist() +{ + int maps = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ maps. (Frame is incomplete)", + maps); + return; + } + + (void) sprintf(get_line(0, 0), "Map list"); + + while (getxdr_long()) { + (void) showxdr_string(YPMAXMAP, " %s"); + maps++; + } + + (void) sprintf(get_line(0, 0), "%d maps", maps); +} + +char * +ypbind_error(err) + int err; +{ + static char buff[16]; + + switch (err) { + case YPBIND_ERR_ERR: return ("Internal error"); + case YPBIND_ERR_NOSERV: return ("Internal error"); + case YPBIND_ERR_RESC: return ("Resource allocation fail"); + default: + (void) sprintf(buff, "(%d)", err); + return (buff); + } + /* NOTREACHED */ +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nlm.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nlm.c new file mode 100644 index 0000000..45c23ee --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_nlm.c @@ -0,0 +1,1136 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1998, 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +/* + * Copyright 2011 Nexenta Systems, Inc. All rights reserved. + * Copyright (c) 2012 by Delphix. All rights reserved. + */ + +#include <sys/types.h> +#include <setjmp.h> +#include <string.h> + +#ifdef notdef +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/rpc_msg.h> +#endif /* notdef */ +#include <rpcsvc/nlm_prot.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +extern void check_retransmit(); +static void interpret_nlm_1(); +static void interpret_nlm_3(); +static void interpret_nlm_4(); +static char *nameof_access(); +static char *nameof_mode(); +static char *nameof_stat(); +static char *nameof_stat4(); +static void show_cancargs(); +static void show_cancargs4(); +static void show_lock(); +static void show_lock4(); +static void show_lockargs(); +static void show_lockargs4(); +static void show_netobj(); +static void show_nlm_access(); +static void show_nlm_mode(); +static void show_notify(); +static void show_res(); +static void show_res4(); +static void show_share(); +static void show_shareargs(); +static void show_shareres(); +static void show_shareres4(); +static enum nlm_stats show_stat(); +static enum nlm4_stats show_stat4(); +static void show_testargs(); +static void show_testargs4(); +static void show_testres(); +static void show_testres4(); +static void show_unlockargs(); +static void show_unlockargs4(); +static void skip_netobj(); +static char *sum_lock(); +static char *sum_lock4(); +static char *sum_netobj(); +static char *sum_notify(); +static char *sum_share(); + +void +interpret_nlm(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + switch (vers) { + case 1: interpret_nlm_1(flags, type, xid, vers, proc, data, len); + break; + case 3: interpret_nlm_3(flags, type, xid, vers, proc, data, len); + break; + case 4: interpret_nlm_4(flags, type, xid, vers, proc, data, len); + break; + } +} + + +/* ------------ V E R S I O N 1 ---------------------------------- */ + +static char *procnames_short_1[] = { + "Null1", /* 0 */ + "TEST1", /* 1 */ + "LOCK1", /* 2 */ + "CANCEL1", /* 3 */ + "UNLOCK1", /* 4 */ + "GRANTED1", /* 5 */ + "TEST MSG1", /* 6 */ + "LOCK MSG1", /* 7 */ + "CANCEL MSG1", /* 8 */ + "UNLOCK MSG1", /* 9 */ + "GRANTED MSG1", /* 10 */ + "TEST RES1", /* 11 */ + "LOCK RES1", /* 12 */ + "CANCEL RES1", /* 13 */ + "UNLOCK RES1", /* 14 */ + "GRANTED RES1", /* 15 */ +}; + +static char *procnames_long_1[] = { + "Null procedure", /* 0 */ + "Test", /* 1 */ + "Lock", /* 2 */ + "Cancel", /* 3 */ + "Unlock", /* 4 */ + "Granted", /* 5 */ + "Test message", /* 6 */ + "Lock message", /* 7 */ + "Cancel message", /* 8 */ + "Unlock message", /* 9 */ + "Granted message", /* 10 */ + "Test result", /* 11 */ + "Lock result", /* 12 */ + "Cancel result", /* 13 */ + "Unlock result", /* 14 */ + "Granted result", /* 15 */ +}; + +/* Highest procedure number that officially belongs to version 1. */ +#define MAXPROC_1 15 + +/* ARGSUSED */ +static void +interpret_nlm_1(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + + if (proc < 0 || proc > MAXPROC_1) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "NLM C %s", + procnames_short_1[proc]); + line += strlen(line); + switch (proc) { + case NLM_TEST: + case NLM_GRANTED: + case NLM_TEST_MSG: + case NLM_GRANTED_MSG: + /* testargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock()); + break; + case NLM_LOCK: + case NLM_LOCK_MSG: + /* lockargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Block */ + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock()); + break; + case NLM_CANCEL: + case NLM_CANCEL_MSG: + /* cancargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Block */ + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock()); + break; + case NLM_UNLOCK: + case NLM_UNLOCK_MSG: + /* unlockargs */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, sum_lock()); + break; + case NLM_TEST_RES: + /* testres */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat(getxdr_u_long())); + break; + case NLM_LOCK_RES: + case NLM_CANCEL_RES: + case NLM_UNLOCK_RES: + case NLM_GRANTED_RES: + /* res */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat(getxdr_u_long())); + break; + } + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NLM R %s", + procnames_short_1[proc]); + line += strlen(line); + switch (proc) { + case NLM_TEST: + /* testres */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat(getxdr_u_long())); + break; + case NLM_LOCK: + case NLM_CANCEL: + case NLM_UNLOCK: + case NLM_GRANTED: + /* res */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat(getxdr_u_long())); + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NLM: ", "Network Lock Manager", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long_1[proc]); + if (type == CALL) { + switch (proc) { + case NLM_TEST: + case NLM_GRANTED: + case NLM_TEST_MSG: + case NLM_GRANTED_MSG: + show_testargs(); + break; + case NLM_LOCK: + case NLM_LOCK_MSG: + show_lockargs(); + break; + case NLM_CANCEL: + case NLM_CANCEL_MSG: + show_cancargs(); + break; + case NLM_UNLOCK: + case NLM_UNLOCK_MSG: + show_unlockargs(); + break; + case NLM_TEST_RES: + show_testres(); + break; + case NLM_LOCK_RES: + case NLM_CANCEL_RES: + case NLM_UNLOCK_RES: + case NLM_GRANTED_RES: + show_res(); + break; + } + } else { + switch (proc) { + case NLM_TEST: + show_testres(); + break; + case NLM_LOCK: + case NLM_CANCEL: + case NLM_UNLOCK: + case NLM_GRANTED: + show_res(); + break; + case NLM_TEST_MSG: + case NLM_LOCK_MSG: + case NLM_CANCEL_MSG: + case NLM_UNLOCK_MSG: + case NLM_GRANTED_MSG: + case NLM_TEST_RES: + case NLM_LOCK_RES: + case NLM_CANCEL_RES: + case NLM_UNLOCK_RES: + case NLM_GRANTED_RES: + break; + } + } + show_trailer(); + } +} + +#define roundup(sz) ((sz / 4 + (sz % 4 > 0)) * 4) + +/* + * Skip a netobj. + * Make sure an integral number of words + * are skipped. + */ +static void +skip_netobj() +{ + int sz = getxdr_u_long(); + + xdr_skip(roundup(sz)); +} + +static char * +sum_netobj(handle) + char *handle; +{ + int i, l, sz; + int sum = 0; + static char buff[32]; + + sz = getxdr_u_long(); + for (i = 0; i < sz; i += 4) { + l = getxdr_long(); + sum ^= (l >> 16) ^ l; + } + (void) sprintf(buff, " %s=%04X", handle, sum & 0xFFFF); + return (buff); +} + +static void +show_netobj(fmt) + char *fmt; +{ + int sz, chunk; + char *p; + char buff[64]; + int needspace; + + sz = getxdr_u_long(); /* size of the netobj */ + + if (sz == 0) { + (void) sprintf(get_line(0, 0), fmt, "<null>"); + } else { + needspace = sz > 16; + (void) strcpy(buff, fmt); + while (sz > 0) { + chunk = sz > 16 ? 16 : sz; + sz -= 16; + (void) showxdr_hex(chunk, buff); + /* + * For every line after the first, blank out + * everything in the format string before the "%s". + */ + for (p = buff; *p != '%'; p++) + *p = ' '; + } + if (needspace) + show_space(); + } +} + +static char * +sum_lock() +{ + static char buff[LM_MAXSTRLEN + 1]; + char *cp = buff; + long id; + ulong_t off, len; + + (void) getxdr_string(buff, LM_MAXSTRLEN); /* Caller */ + (void) strcpy(buff, sum_netobj("FH")); /* Fh */ + cp += strlen(buff); + skip_netobj(); /* Owner */ + id = getxdr_long(); + off = getxdr_u_long(); + len = getxdr_u_long(); + (void) sprintf(cp, " PID=%ld Region=%lu:%lu", id, off, len); + return (buff); +} + +static void +show_lock() +{ + showxdr_string(LM_MAXSTRLEN, "Caller = %s"); + show_netobj("Filehandle = %s"); + show_netobj("Lock owner = %s"); + showxdr_long("Svid = %ld (process id)"); + showxdr_u_long("Offset = %lu bytes"); + showxdr_u_long("Length = %lu bytes"); +} + +static void +show_cancargs() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Block = %s"); + showxdr_bool("Exclusive = %s"); + show_lock(); +} + +static void +show_lockargs() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Block = %s"); + showxdr_bool("Exclusive = %s"); + show_lock(); + showxdr_bool("Reclaim = %s"); + showxdr_long("State = %ld"); +} + +static void +show_unlockargs() +{ + show_netobj("Cookie = %s"); + show_lock(); +} + +static void +show_testargs() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Exclusive = %s"); + show_lock(); +} + +static void +show_res() +{ + show_netobj("Cookie = %s"); + (void) show_stat(); +} + +static char * +nameof_stat(s) + ulong_t s; +{ + switch ((enum nlm_stats) s) { + case nlm_granted: return ("granted"); + case nlm_denied: return ("denied"); + case nlm_denied_nolocks:return ("denied (no locks)"); + case nlm_blocked: return ("blocked"); + case nlm_denied_grace_period: return ("denied (grace period)"); + case nlm_deadlck: return ("deadlock"); + default: return ("?"); + } +} + +static enum nlm_stats +show_stat() +{ + enum nlm_stats s; + + s = (enum nlm_stats) getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Status = %d (%s)", + s, nameof_stat((ulong_t)s)); + + return (s); +} + +static void +show_testres() +{ + show_netobj("Cookie = %s"); + if (show_stat() == nlm_denied) { + showxdr_bool("Exclusive = %s"); + showxdr_long("Svid = %ld (process id)"); + show_netobj("Owner handle = %s"); + showxdr_u_long("Offset = %lu bytes"); + showxdr_u_long("Length = %lu bytes"); + } +} + + +/* ------------ V E R S I O N 3 ---------------------------------- */ + +static char *procnames_short_3[] = { + "SHARE3", /* 20 */ + "UNSHARE3", /* 21 */ + "NM_LOCK3", /* 22 */ + "FREEALL3", /* 23 */ +}; + +static char *procnames_long_3[] = { + "Share", /* 20 */ + "Unshare", /* 21 */ + "Unmonitored lock", /* 22 */ + "Free all", /* 23 */ +}; + +/* Maximum procedure number for version 3. */ +#define MAXPROC_3 23 + +static void +interpret_nlm_3(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line, *pl; + ulong_t i; + + if (proc < 0 || proc > MAXPROC_3) + return; + + /* + * Version 3 is a superset of version 1 + */ + if (proc >= 0 && proc <= MAXPROC_1) { + interpret_nlm_1(flags, type, xid, vers, proc, data, len); + return; + } + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "NLM C %s", + procnames_short_3[proc-20]); + line += strlen(line); + switch (proc) { + case NLM_SHARE: + case NLM_UNSHARE: + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, sum_share()); + break; + case NLM_NM_LOCK: + /* lockargs */ + skip_netobj(); + (void) getxdr_u_long(); /* Block */ + (void) getxdr_u_long(); /* Excl */ + (void) strcat(line, sum_lock()); + break; + case NLM_FREE_ALL: + (void) sprintf(line, + " %s", sum_notify()); + break; + } + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NLM R %s", + procnames_short_3[proc-20]); + line += strlen(line); + switch (proc) { + case NLM_SHARE: + case NLM_UNSHARE: + pl = sum_netobj("OH"); + i = getxdr_u_long(); + sprintf(line, "%s %s %ld", + pl, nameof_stat(i), getxdr_long()); + break; + case NLM_NM_LOCK: + /* res */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat(getxdr_u_long())); + break; + case NLM_FREE_ALL: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NLM: ", "Network Lock Manager", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long_3[proc-20]); + if (type == CALL) { + switch (proc) { + case NLM_SHARE: + case NLM_UNSHARE: + show_shareargs(); + break; + case NLM_NM_LOCK: + show_lockargs(); + break; + case NLM_FREE_ALL: + show_notify(); + break; + } + } else { + switch (proc) { + case NLM_SHARE: + case NLM_UNSHARE: + show_shareres(); + break; + case NLM_NM_LOCK: + show_res(); + break; + case NLM_FREE_ALL: + break; + } + } + show_trailer(); + } +} + +static char * +nameof_mode(m) + uint_t m; +{ + switch ((enum fsh_mode) m) { + case fsm_DN: return ("deny none"); + case fsm_DR: return ("deny read"); + case fsm_DW: return ("deny write"); + case fsm_DRW: return ("deny read/write"); + default: return ("?"); + } +} + +static char * +nameof_access(a) + uint_t a; +{ + switch ((enum fsh_access) a) { + case fsa_NONE: return ("?"); + case fsa_R: return ("read only"); + case fsa_W: return ("write only"); + case fsa_RW: return ("read/write"); + default: return ("?"); + } +} + +static void +show_nlm_mode() +{ + enum fsh_mode m; + + m = (enum fsh_mode) getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Mode = %d (%s)", + m, nameof_mode((uint_t)m)); +} + +static void +show_nlm_access() +{ + enum fsh_access a; + + a = (enum fsh_access) getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Access = %d (%s)", + a, nameof_access((uint_t)a)); +} + +static char * +sum_share() +{ + static char buff[LM_MAXSTRLEN + 1]; + char *cp = buff; + ulong_t mode, access; + + (void) getxdr_string(buff, LM_MAXSTRLEN); /* Caller */ + (void) strcpy(buff, sum_netobj("FH")); /* Fh */ + cp += strlen(buff); + skip_netobj(); /* Owner */ + mode = getxdr_u_long(); + access = getxdr_u_long(); + (void) sprintf(cp, " Mode=%lu Access=%lu", mode, access); + return (buff); +} + +static void +show_share() +{ + showxdr_string(LM_MAXSTRLEN, "Caller = %s"); + show_netobj("Filehandle = %s"); + show_netobj("Lock owner = %s"); + show_nlm_mode(); + show_nlm_access(); +} + +static void +show_shareargs() +{ + show_netobj("Cookie = %s"); + show_share(); + showxdr_bool("Reclaim = %s"); +} + +static void +show_shareres() +{ + show_netobj("Cookie = %s"); + (void) show_stat(); + showxdr_long("Sequence = %d"); +} + +static void +show_notify() +{ + showxdr_string(LM_MAXNAMELEN, "Name = %s"); + showxdr_long("State = %d"); +} + +#define NOTIFY_PAD (sizeof (" State=-2147483648") + 1) + +static char * +sum_notify() +{ + static char buff[LM_MAXNAMELEN + NOTIFY_PAD]; + char *cp = buff; + long state; + + (void) getxdr_string(buff, LM_MAXNAMELEN); + cp += strlen(buff); + state = getxdr_long(); + (void) sprintf(cp, " State=%ld", state); + return (buff); +} + +/* ------------ V E R S I O N 4 ---------------------------------- */ + +static char *procnames_short_4[] = { + "Null4", /* 0 */ + "TEST4", /* 1 */ + "LOCK4", /* 2 */ + "CANCEL4", /* 3 */ + "UNLOCK4", /* 4 */ + "GRANTED4", /* 5 */ + "TEST MSG4", /* 6 */ + "LOCK MSG4", /* 7 */ + "CANCEL MSG4", /* 8 */ + "UNLOCK MSG4", /* 9 */ + "GRANTED MSG4", /* 10 */ + "TEST RES4", /* 11 */ + "LOCK RES4", /* 12 */ + "CANCEL RES4", /* 13 */ + "UNLOCK RES4", /* 14 */ + "GRANTED RES4", /* 15 */ + "PROC 16 v4", /* 16 */ + "PROC 17 v4", /* 17 */ + "PROC 18 v4", /* 18 */ + "PROC 19 v4", /* 19 */ + "SHARE4", /* 20 */ + "UNSHARE4", /* 21 */ + "NM_LOCK4", /* 22 */ + "FREEALL4", /* 23 */ +}; + +static char *procnames_long_4[] = { + "Null procedure", /* 0 */ + "Test", /* 1 */ + "Lock", /* 2 */ + "Cancel", /* 3 */ + "Unlock", /* 4 */ + "Granted", /* 5 */ + "Test message", /* 6 */ + "Lock message", /* 7 */ + "Cancel message", /* 8 */ + "Unlock message", /* 9 */ + "Granted message", /* 10 */ + "Test result", /* 11 */ + "Lock result", /* 12 */ + "Cancel result", /* 13 */ + "Unlock result", /* 14 */ + "Granted result", /* 15 */ + "Procedure 16", /* 16 */ + "Procedure 17", /* 17 */ + "Procedure 18", /* 18 */ + "Procedure 19", /* 19 */ + "Share", /* 20 */ + "Unshare", /* 21 */ + "Unmonitored lock", /* 22 */ + "Free all", /* 23 */ +}; + +/* Maximum procedure number for version 4. */ +#define MAXPROC_4 23 + +/* ARGSUSED */ +static void +interpret_nlm_4(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char *pl; + ulong_t i; + + if (proc < 0 || proc > MAXPROC_4) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "NLM C %s", + procnames_short_4[proc]); + line += strlen(line); + switch (proc) { + case NLM4_TEST: + case NLM4_GRANTED: + case NLM4_TEST_MSG: + case NLM4_GRANTED_MSG: + /* testargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock4()); + break; + case NLM4_LOCK: + case NLM4_LOCK_MSG: + /* lockargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Block */ + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock4()); + /* ignore reclaim, state fields */ + break; + case NLM4_CANCEL: + case NLM4_CANCEL_MSG: + /* cancargs */ + (void) strcat(line, sum_netobj("OH")); + (void) getxdr_bool(); /* Block */ + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock4()); + break; + case NLM4_UNLOCK: + case NLM4_UNLOCK_MSG: + /* unlockargs */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, sum_lock4()); + break; + case NLM4_TEST_RES: + /* testres */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat4(getxdr_u_long())); + break; + case NLM4_LOCK_RES: + case NLM4_CANCEL_RES: + case NLM4_UNLOCK_RES: + case NLM4_GRANTED_RES: + /* res */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat4(getxdr_u_long())); + break; + case NLM4_SHARE: + case NLM4_UNSHARE: + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, sum_share()); + break; + case NLM4_NM_LOCK: + /* lockargs */ + skip_netobj(); /* Cookie */ + (void) getxdr_bool(); /* Block */ + (void) getxdr_bool(); /* Excl */ + (void) strcat(line, sum_lock4()); + /* skip reclaim & state fields */ + break; + case NLM4_FREE_ALL: + (void) sprintf(line, + " %s", sum_notify()); + break; + } + check_retransmit(line, (ulong_t)xid); + } else { + (void) sprintf(line, "NLM R %s", + procnames_short_4[proc]); + line += strlen(line); + switch (proc) { + case NLM4_TEST: + /* testres */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat4(getxdr_u_long())); + break; + case NLM4_LOCK: + case NLM4_CANCEL: + case NLM4_UNLOCK: + case NLM4_GRANTED: + case NLM4_NM_LOCK: + /* res */ + (void) strcat(line, sum_netobj("OH")); + (void) strcat(line, " "); + (void) strcat(line, + nameof_stat4(getxdr_u_long())); + break; + case NLM4_SHARE: + case NLM4_UNSHARE: + /* shareres */ + pl = sum_netobj("OH"); + i = getxdr_u_long(); + sprintf(line, "%s %s %ld", + pl, nameof_stat4(i), getxdr_long()); + break; + case NLM4_FREE_ALL: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("NLM: ", "Network Lock Manager", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long_4[proc]); + if (type == CALL) { + switch (proc) { + case NLM4_TEST: + case NLM4_GRANTED: + case NLM4_TEST_MSG: + case NLM4_GRANTED_MSG: + show_testargs4(); + break; + case NLM4_LOCK: + case NLM4_LOCK_MSG: + case NLM4_NM_LOCK: + show_lockargs4(); + break; + case NLM4_CANCEL: + case NLM4_CANCEL_MSG: + show_cancargs4(); + break; + case NLM4_UNLOCK: + case NLM4_UNLOCK_MSG: + show_unlockargs4(); + break; + case NLM4_TEST_RES: + show_testres4(); + break; + case NLM4_LOCK_RES: + case NLM4_CANCEL_RES: + case NLM4_UNLOCK_RES: + case NLM4_GRANTED_RES: + show_res4(); + break; + case NLM4_SHARE: + case NLM4_UNSHARE: + show_shareargs(); + break; + case NLM4_FREE_ALL: + show_notify(); + break; + } + } else { + switch (proc) { + case NLM4_TEST: + show_testres4(); + break; + case NLM4_LOCK: + case NLM4_CANCEL: + case NLM4_UNLOCK: + case NLM4_GRANTED: + case NLM_NM_LOCK: + show_res4(); + break; + case NLM4_TEST_MSG: + case NLM4_LOCK_MSG: + case NLM4_CANCEL_MSG: + case NLM4_UNLOCK_MSG: + case NLM4_GRANTED_MSG: + case NLM4_TEST_RES: + case NLM4_LOCK_RES: + case NLM4_CANCEL_RES: + case NLM4_UNLOCK_RES: + case NLM4_GRANTED_RES: + break; + case NLM_SHARE: + case NLM_UNSHARE: + show_shareres4(); + break; + case NLM_FREE_ALL: + break; + } + } + show_trailer(); + } +} + +static char * +sum_lock4() +{ + static char buff[LM_MAXSTRLEN + 1]; + char *cp = buff; + long id; + u_longlong_t off, len; + + (void) getxdr_string(buff, LM_MAXSTRLEN); /* Caller */ + (void) strcpy(buff, sum_netobj("FH")); /* Fh */ + cp += strlen(buff); + skip_netobj(); /* Owner */ + id = getxdr_long(); + off = getxdr_u_longlong(); + len = getxdr_u_longlong(); + (void) sprintf(cp, " PID=%ld Region=%llu:%llu", id, off, len); + return (buff); +} + +static void +show_lock4() +{ + showxdr_string(LM_MAXSTRLEN, "Caller = %s"); + show_netobj("Filehandle = %s"); + show_netobj("Lock owner = %s"); + showxdr_long("Svid = %ld (process id)"); + showxdr_u_longlong("Offset = %llu bytes"); + showxdr_u_longlong("Length = %llu bytes"); +} + +static void +show_cancargs4() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Block = %s"); + showxdr_bool("Exclusive = %s"); + show_lock4(); +} + +static void +show_lockargs4() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Block = %s"); + showxdr_bool("Exclusive = %s"); + show_lock4(); + showxdr_bool("Reclaim = %s"); + showxdr_long("State = %ld"); +} + +static void +show_unlockargs4() +{ + show_netobj("Cookie = %s"); + show_lock4(); +} + +static void +show_testargs4() +{ + show_netobj("Cookie = %s"); + showxdr_bool("Exclusive = %s"); + show_lock4(); +} + +static void +show_res4() +{ + show_netobj("Cookie = %s"); + (void) show_stat4(); +} + +static char * +nameof_stat4(s) + ulong_t s; +{ + switch ((enum nlm4_stats) s) { + case nlm4_granted: return ("granted"); + case nlm4_denied: return ("denied"); + case nlm4_denied_nolocks:return ("denied (no locks)"); + case nlm4_blocked: return ("blocked"); + case nlm4_denied_grace_period: return ("denied (grace period)"); + case nlm4_deadlck: return ("deadlock"); + case nlm4_rofs: return ("read-only fs"); + case nlm4_stale_fh: return ("stale fh"); + case nlm4_fbig: return ("file too big"); + case nlm4_failed: return ("failed"); + default: return ("?"); + } +} + +static enum nlm4_stats +show_stat4() +{ + enum nlm4_stats s; + + s = (enum nlm4_stats) getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Status = %d (%s)", + s, nameof_stat4((ulong_t)s)); + + return (s); +} + +static void +show_testres4() +{ + show_netobj("Cookie = %s"); + if (show_stat() == nlm_denied) { + showxdr_bool("Exclusive = %s"); + showxdr_long("Svid = %ld (process id)"); + show_netobj("Owner handle = %s"); + showxdr_u_longlong("Offset = %llu bytes"); + showxdr_u_longlong("Length = %llu bytes"); + } +} + +static void +show_shareres4() +{ + show_netobj("Cookie = %s"); + (void) show_stat4(); + showxdr_long("Sequence = %d"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ntp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ntp.c new file mode 100644 index 0000000..4f6fae3 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ntp.c @@ -0,0 +1,505 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <fcntl.h> +#include <sys/socket.h> +#include <sys/sysmacros.h> +#include <netinet/in.h> +#include <netdb.h> +#include <stdio.h> +#include <string.h> +#include <tzfile.h> +#include "snoop.h" +#include "ntp.h" + +/* + * In verbose mode, how many octets of the control-mode data payload + * are displayed per line of output. The value 64 fits well on an + * 80-column screen and, as a power of 2, is easily correlated to + * hexadecimal output. + */ +#define OCTETS_PER_LINE 64 + +extern char *dlc_header; + +static char *show_leap(int); +static char *show_mode(int); +static char *show_ref(int, ulong_t); +static char *show_time(struct l_fixedpt); +static double s_fixed_to_double(struct s_fixedpt *); +static char *iso_date_time(time_t); +static char *show_operation(int); + +int +interpret_ntp(int flags, struct ntpdata *ntp_pkt, int fraglen) +{ + unsigned int i, j, macbytes; + unsigned int proto_version; + unsigned int datalen; + unsigned int linelen = OCTETS_PER_LINE; + unsigned int sofar = 0; + + char *datap; + char hbuf[2 * MAC_OCTETS_MAX + 1]; + static char *hexstr = "0123456789ABCDEF"; + + union ntp_pkt_buf { + struct ntpdata ntp_msg; + union ntpc_buf { + struct ntp_control chdr; + uchar_t data2[NTPC_DATA_MAXLEN - 1]; + } ntpc_msg; + union ntpp_buf { + struct ntp_private phdr; + uchar_t data2[1]; + } ntpp_msg; + } fragbuf; + + struct ntpdata *ntp = &fragbuf.ntp_msg; + struct ntp_control *ntpc = (struct ntp_control *)&fragbuf.ntpc_msg; + struct ntp_private *ntpp = (struct ntp_private *)&fragbuf.ntpp_msg; + + /* + * Copying packet contents into a local buffer avoids + * problems of interpretation if the packet is truncated. + */ + (void) memcpy(&fragbuf, ntp_pkt, MIN(sizeof (fragbuf), fraglen)); + + if (flags & F_SUM) { + switch (ntp->li_vn_mode & NTPMODEMASK) { + case MODE_SYM_ACT: + case MODE_SYM_PAS: + case MODE_CLIENT: + case MODE_SERVER: + case MODE_BROADCAST: + (void) sprintf(get_sum_line(), + "NTP %s [st=%hd] (%s)", + show_mode(ntp->li_vn_mode & NTPMODEMASK), + ntp->stratum, + show_time(ntp->xmt)); + break; + case MODE_CONTROL: + (void) sprintf(get_sum_line(), + "NTP %s " + "(Flags/op=0x%02x Seq=%hu Status=0x%04hx Assoc=%hu)", + show_mode(ntpc->li_vn_mode & NTPMODEMASK), + ntpc->r_m_e_op, + ntohs(ntpc->sequence), + ntohs(ntpc->status), + ntohs(ntpc->associd)); + break; + default: + (void) sprintf(get_sum_line(), + "NTP %s", + show_mode(ntpp->rm_vn_mode & NTPMODEMASK)); + break; + } + } + + proto_version = (ntp->li_vn_mode & VERSIONMASK) >> 3; + + if (flags & F_DTAIL) { + show_header("NTP: ", "Network Time Protocol", fraglen); + show_space(); + switch (ntp->li_vn_mode & NTPMODEMASK) { + case MODE_SYM_ACT: + case MODE_SYM_PAS: + case MODE_CLIENT: + case MODE_SERVER: + case MODE_BROADCAST: + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Leap = 0x%x (%s)", + (int)(ntp->li_vn_mode & LEAPMASK) >> 6, + show_leap(ntp->li_vn_mode & LEAPMASK)); + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Version = %lu", proto_version); + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Mode = %hu (%s)", + ntp->li_vn_mode & NTPMODEMASK, + show_mode(ntp->li_vn_mode & NTPMODEMASK)); + (void) sprintf(get_line((char *)(uintptr_t)ntp->stratum - + dlc_header, 1), + "Stratum = %d (%s)", + ntp->stratum, + ntp->stratum == 0 ? "unspecified" : + ntp->stratum == 1 ? "primary reference" : + "secondary reference"); + (void) sprintf(get_line((char *)(uintptr_t)ntp->ppoll - + dlc_header, 1), "Poll = %hu", ntp->ppoll); + (void) sprintf(get_line((char *)(uintptr_t)ntp->precision - + dlc_header, 1), + "Precision = %d seconds", + ntp->precision); + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->distance.int_part - + dlc_header, 1), + "Synchronizing distance = 0x%04x.%04x (%f)", + ntohs(ntp->distance.int_part), + ntohs(ntp->distance.fraction), + s_fixed_to_double(&ntp->distance)); + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->dispersion.int_part - + dlc_header, 1), + "Synchronizing dispersion = 0x%04x.%04x (%f)", + ntohs(ntp->dispersion.int_part), + ntohs(ntp->dispersion.fraction), + s_fixed_to_double(&ntp->dispersion)); + (void) sprintf(get_line((char *)(uintptr_t)ntp->refid - + dlc_header, 1), "Reference clock = %s", + show_ref(ntp->stratum, ntp->refid)); + + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->reftime.int_part - dlc_header, + 1), "Reference time = 0x%08lx.%08lx (%s)", + ntohl(ntp->reftime.int_part), + ntohl(ntp->reftime.fraction), + show_time(ntp->reftime)); + + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->org.int_part - dlc_header, 1), + "Originate time = 0x%08lx.%08lx (%s)", + ntohl(ntp->org.int_part), + ntohl(ntp->org.fraction), + show_time(ntp->org)); + + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->rec.int_part - dlc_header, 1), + "Receive time = 0x%08lx.%08lx (%s)", + ntohl(ntp->rec.int_part), + ntohl(ntp->rec.fraction), + show_time(ntp->rec)); + + (void) sprintf(get_line( + (char *)(uintptr_t)ntp->xmt.int_part - dlc_header, 1), + "Transmit time = 0x%08lx.%08lx (%s)", + ntohl(ntp->xmt.int_part), + ntohl(ntp->xmt.fraction), + show_time(ntp->xmt)); + + if (proto_version > 3 || + fraglen < (LEN_PKT_NOMAC + MAC_OCTETS_MIN)) { + /* + * A newer protocol version we can't parse, + * or v3 packet with no valid authentication. + */ + break; + } + (void) sprintf(get_line((char *)ntp->keyid - + dlc_header, 1), + "Key ID = %8lu", ntohl(ntp->keyid)); + + macbytes = fraglen - (LEN_PKT_NOMAC + sizeof (uint32_t)); + + for (i = 0, j = 0; i < macbytes; i++) { + hbuf[j++] = hexstr[ntp->mac[i] >> 4 & 0x0f]; + hbuf[j++] = hexstr[ntp->mac[i] & 0x0f]; + } + hbuf[j] = '\0'; + (void) sprintf(get_line((char *)ntp->mac - + dlc_header, 1), + "Authentication code = %s", hbuf); + break; + + case MODE_CONTROL: + /* NTP Control Message, mode 6 */ + + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Leap = 0x%x (%s)", + (int)(ntp->li_vn_mode & LEAPMASK) >> 6, + show_leap(ntp->li_vn_mode & LEAPMASK)); + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Version = %lu", proto_version); + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), + "Mode = %hu (%s)", + ntp->li_vn_mode & NTPMODEMASK, + show_mode(ntp->li_vn_mode & NTPMODEMASK)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op - + dlc_header, 1), + "Flags and operation code = 0x%02x", + ntpc->r_m_e_op); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op - + dlc_header, 1), + " %s", + getflag(ntpc->r_m_e_op, CTL_RESPONSE, "response", + "request")); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op - + dlc_header, 1), + " %s", + getflag(ntpc->r_m_e_op, CTL_ERROR, "error", + "success")); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op - + dlc_header, 1), + " %s", + getflag(ntpc->r_m_e_op, CTL_MORE, "more", + "no more")); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->r_m_e_op - + dlc_header, 1), + " ...x xxxx = %hd (%s)", + ntpc->r_m_e_op & CTL_OP_MASK, + show_operation(ntpc->r_m_e_op & CTL_OP_MASK)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->sequence - + dlc_header, 1), + "Sequence = %hu", + ntohs(ntpc->sequence)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->status - + dlc_header, 1), + "Status = 0x%04hx", + ntohs(ntpc->status)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->associd - + dlc_header, 1), + "Assoc ID = %hu", + ntohs(ntpc->associd)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->offset - + dlc_header, 1), + "Data offset = %hu", + ntohs(ntpc->offset)); + (void) sprintf(get_line((char *)(uintptr_t)ntpc->count - + dlc_header, 1), + "Data bytes = %hu", + ntohs(ntpc->count)); + datalen = ntohs(ntpc->count); + if (datalen == 0) { + break; + } else if (datalen > NTPC_DATA_MAXLEN) { + datalen = NTPC_DATA_MAXLEN; + } + show_space(); + datap = (char *)ntpc->data; + do { + (void) sprintf(get_line(datap - + dlc_header, 1), + "\"%s\"", + show_string(datap, linelen, datalen)); + sofar += linelen; + datap += linelen; + if ((sofar + linelen) > datalen) { + linelen = datalen - sofar; + } + } while (sofar < datalen); + show_trailer(); + break; + + case MODE_PRIVATE: + /* NTP Private Message, mode 7 */ + + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1), + "Version = %hu", INFO_VERSION(ntpp->rm_vn_mode)); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1), + "Mode = %hu (%s)", INFO_MODE(ntpp->rm_vn_mode), + show_mode(INFO_MODE(ntpp->rm_vn_mode))); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1), + "Flags = 0x%02hx", ntpp->rm_vn_mode); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1), + " %s", + getflag(ntpp->rm_vn_mode, RESP_BIT, "response", + "request")); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->rm_vn_mode - dlc_header, 1), + " %s", + getflag(ntpp->rm_vn_mode, MORE_BIT, "more", "no more")); + (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq - + dlc_header, 1), + "Authentication and sequence = 0x%02x", ntpp->auth_seq); + (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq - + dlc_header, 1), + " %s", + getflag(ntpp->auth_seq, AUTH_BIT, "authenticated", + "unauthenticated")); + (void) sprintf(get_line((char *)(uintptr_t)ntpp->auth_seq - + dlc_header, 1), + " .xxx xxxx = %hu (sequence number)", + INFO_SEQ(ntpp->auth_seq)); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->implementation - dlc_header, + 1), "Implementation = %hu", ntpp->implementation); + (void) sprintf(get_line((char *)(uintptr_t)ntpp->request - + dlc_header, 1), "Request = %hu", ntpp->request); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->err_nitems - dlc_header, 1), + "Error = %hu", INFO_ERR(ntpp->err_nitems)); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->err_nitems - dlc_header, 1), + "Items = %hu", INFO_NITEMS(ntpp->err_nitems)); + (void) sprintf(get_line( + (char *)(uintptr_t)ntpp->mbz_itemsize - dlc_header, 1), + "Item size = %hu", INFO_ITEMSIZE(ntpp->mbz_itemsize)); + break; + + default: + /* Unknown mode */ + (void) sprintf(get_line((char *)(uintptr_t)ntp->li_vn_mode - + dlc_header, 1), "Mode = %hu (%s)", + ntp->li_vn_mode & NTPMODEMASK, + show_mode(ntp->li_vn_mode & NTPMODEMASK)); + break; + } + } + + return (fraglen); +} + +char * +show_leap(int leap) +{ + switch (leap) { + case NO_WARNING: return ("OK"); + case PLUS_SEC: return ("add a second (61 seconds)"); + case MINUS_SEC: return ("minus a second (59 seconds)"); + case ALARM: return ("alarm condition (clock unsynchronized)"); + default: return ("unknown"); + } +} + +char * +show_mode(int mode) +{ + switch (mode) { + case MODE_UNSPEC: return ("unspecified"); + case MODE_SYM_ACT: return ("symmetric active"); + case MODE_SYM_PAS: return ("symmetric passive"); + case MODE_CLIENT: return ("client"); + case MODE_SERVER: return ("server"); + case MODE_BROADCAST: return ("broadcast"); + case MODE_CONTROL: return ("control"); + case MODE_PRIVATE: return ("private"); + default: return ("unknown"); + } +} + +char * +show_ref(int mode, ulong_t refid) +{ + static char buff[MAXHOSTNAMELEN + 32]; + struct in_addr host; + extern char *inet_ntoa(); + + switch (mode) { + case 0: + case 1: + (void) strncpy(buff, (char *)&refid, 4); + buff[4] = '\0'; + break; + + default: + host.s_addr = refid; + (void) sprintf(buff, "%s (%s)", + inet_ntoa(host), + addrtoname(AF_INET, &host)); + break; + } + + return (buff); +} + +/* + * Here we have to worry about the high order bit being signed + */ +double +s_fixed_to_double(struct s_fixedpt *t) +{ + double a; + + if (ntohs(t->int_part) & 0x8000) { + a = ntohs((int)(~t->fraction) & 0xFFFF); + a = a / 65536.0; /* shift dec point over by 16 bits */ + a += ntohs((int)(~t->int_part) & 0xFFFF); + a = -a; + } else { + a = ntohs(t->fraction); + a = a / 65536.0; /* shift dec point over by 16 bits */ + a += ntohs(t->int_part); + } + return (a); +} + +/* + * Consistent with RFC-3339, ISO 8601. + */ +char * +iso_date_time(time_t input_time) +{ + struct tm *time_parts; + static char tbuf[sizeof ("yyyy-mm-dd hh:mm:ss")]; + + time_parts = localtime(&input_time); + (void) strftime(tbuf, sizeof (tbuf), "%Y-%m-%d %H:%M:%S", time_parts); + return (tbuf); +} + +/* + * The base of NTP timestamps is 1900-01-01 00:00:00.00000 + */ +char * +show_time(struct l_fixedpt pkt_time) +{ + struct l_fixedpt net_time; + unsigned long fracsec; + static char buff[32]; + + if (pkt_time.int_part == 0) { + buff[0] = '\0'; + return (buff); + } + + net_time.int_part = ntohl(pkt_time.int_part) - JAN_1970; + net_time.fraction = ntohl(pkt_time.fraction); + + fracsec = net_time.fraction / 42949; /* fract / (2**32/10**6) */ + + (void) strlcpy(buff, iso_date_time(net_time.int_part), sizeof (buff)); + (void) snprintf(buff, sizeof (buff), "%s.%05lu", buff, fracsec); + + return (buff); +} + +char * +show_operation(int op) +{ + switch (op) { + case CTL_OP_UNSPEC: return ("unspecified"); + case CTL_OP_READSTAT: return ("read stats"); + case CTL_OP_READVAR: return ("read var"); + case CTL_OP_WRITEVAR: return ("write var"); + case CTL_OP_READCLOCK: return ("read clock"); + case CTL_OP_WRITECLOCK: return ("write clock"); + case CTL_OP_SETTRAP: return ("set trap"); + case CTL_OP_ASYNCMSG: return ("async msg"); + case CTL_OP_UNSETTRAP: return ("unset trap"); + default: return ("unknown"); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.c new file mode 100644 index 0000000..84234dd --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.c @@ -0,0 +1,772 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <arpa/inet.h> +#include "snoop.h" +#include "snoop_ospf.h" +#include "snoop_ospf6.h" + +extern char *dlc_header; +static char *sum_line; + +char *ospf_types[] = { + "umd", /* 0 */ + "Hello", /* 1 */ + "DD", /* 2 */ + "LSReq", /* 3 */ + "LSUpd", /* 4 */ + "LSAck", /* 5 */ +}; + +static char *ospf_authtypes[] = { + "None", /* 0 */ + "simple", /* 1 */ + "md5", /* 2 */ +}; + +const struct bits ospf_rla_flag_bits[] = { + { RLA_FLAG_B, "B" }, + { RLA_FLAG_E, "E" }, + { RLA_FLAG_V, "V" }, + { RLA_FLAG_W, "W" }, + { 0, NULL } +}; + +const struct bits ospf_db_flags_bits[] = { + { OSPF_DB_INIT, "I" }, + { OSPF_DB_MORE, "M" }, + { OSPF_DB_MASTER, "MS" }, + { 0, NULL } +}; + +const struct bits ospf_option_bits[] = { + { OSPF_OPTION_T, "T" }, + { OSPF_OPTION_E, "E" }, + { OSPF_OPTION_MC, "MC" }, + { 0, NULL } +}; + +static int interpret_ospf_hello(int, struct ospfhdr *, int); +static void ospf_print_ls_type(int, uint32_t, struct in_addr, struct in_addr); +static void interpret_ospf_lsa_hdr(int, struct lsa_hdr *); +static int interpret_ospf_lsa(int flags, struct lsa *lsa, uchar_t *); + +char * +ospf_print_bits(const struct bits *bp, uchar_t options) +{ + static char bitstring[32]; + + bitstring[0] = '\0'; + do { + if (options & bp->bit) { + strcat(bitstring, bp->str); + strcat(bitstring, "/"); + } + } while ((++bp)->bit); + + /* wipe out the trailing "/" */ + bitstring[strlen(bitstring) - 1] = '\0'; + return (bitstring); +} + +char * +ospf_print_lsa_age(long age) +{ + long sec, mins, hour; + static char lsa_age[16]; + + sec = age % 60; + mins = (age / 60) % 60; + hour = age / 3600; + if (hour != 0) + snprintf(lsa_age, sizeof (lsa_age), "%u:%02u:%02u", + hour, mins, sec); + else if (mins != 0) + snprintf(lsa_age, sizeof (lsa_age), "%u:%02u", mins, sec); + else + snprintf(lsa_age, sizeof (lsa_age), "%u", sec); + return (lsa_age); +} + +static int +interpret_ospf_hello(int flags, struct ospfhdr *op, int fraglen) +{ + struct in_addr *nbr; + int j; + + if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_HELLO_HEADER_SIZE) + return (-1); /* truncated packet */ + + if (flags & F_SUM) { + if (op->ospf_hello.hello_dr.s_addr != 0) { + (void) sprintf(sum_line, "DR=%s ", + inet_ntoa(op->ospf_hello.hello_dr)); + } + sum_line += strlen(sum_line); + if (op->ospf_hello.hello_bdr.s_addr != 0) { + (void) sprintf(sum_line, "BDR=%s ", + inet_ntoa(op->ospf_hello.hello_bdr)); + } + sum_line += strlen(sum_line); + nbr = op->ospf_hello.hello_neighbor; + j = 0; + while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) { + if ((uchar_t *)nbr + sizeof (struct in_addr) > + ((uchar_t *)op + fraglen)) + return (-1); /* truncated */ + j++; + ++nbr; + } + (void) sprintf(sum_line, "%d nbrs", j); + sum_line += strlen(sum_line); + + } + if (flags & F_DTAIL) { + show_header("OSPF HELLO: ", "Hello Packet", + ntohs(op->ospf_len)); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Options = %s", ospf_print_bits(ospf_option_bits, + op->ospf_hello.hello_options)); + (void) snprintf(get_line(0, 0), get_line_remain(), "Mask = %s", + inet_ntoa(op->ospf_hello.hello_mask)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hello interval = %d", + ntohs(op->ospf_hello.hello_helloint)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Priority = %d", op->ospf_hello.hello_priority); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Dead interval = %u", ntohl(op->ospf_hello.hello_deadint)); + if (op->ospf_hello.hello_dr.s_addr != 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Designated Router = %s", + inet_ntoa(op->ospf_hello.hello_dr)); + } + if (op->ospf_hello.hello_bdr.s_addr != 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Backup Designated Router = %s", + inet_ntoa(op->ospf_hello.hello_bdr)); + } + nbr = op->ospf_hello.hello_neighbor; + while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) { + if ((uchar_t *)nbr + sizeof (struct in_addr) > + ((uchar_t *)op + fraglen)) + return (-1); /* truncated */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Neighbor: %s", inet_ntoa(*nbr)); + ++nbr; + } + } + return (fraglen); +} + +static void +ospf_print_ls_type(int flags, uint32_t ls_type, struct in_addr ls_stateid, + struct in_addr ls_router) +{ + switch (ls_type) { + case LS_TYPE_ROUTER: + if (flags & F_SUM) { + sprintf(sum_line, " rtr %s ", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Router LSA; Router = %s ", inet_ntoa(ls_router)); + } + break; + case LS_TYPE_NETWORK: + if (flags & F_SUM) { + sprintf(sum_line, " net dr %s ", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + sprintf(sum_line, "if %s ", inet_ntoa(ls_stateid)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Network LSA Router = %s ", inet_ntoa(ls_router)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Interface = %s ", + inet_ntoa(ls_stateid)); + } + break; + case LS_TYPE_SUM_IP: + if (flags & F_SUM) { + sprintf(sum_line, " sum %s ", inet_ntoa(ls_stateid)); + sum_line += strlen(sum_line); + sprintf(sum_line, "abr %s ", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Summary LSA IP = %s ", inet_ntoa(ls_stateid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Area Border Router = %s ", + inet_ntoa(ls_router)); + } + break; + case LS_TYPE_SUM_ABR: + if (flags & F_SUM) { + sprintf(sum_line, "abr %s ", inet_ntoa(ls_stateid)); + sum_line += strlen(sum_line); + sprintf(sum_line, "asbr %s ", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "ASBR Summary abr = %s ", inet_ntoa(ls_stateid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " asbr = %s ", inet_ntoa(ls_router)); + } + break; + case LS_TYPE_ASE: + if (flags & F_SUM) { + sprintf(sum_line, " ase %s", inet_ntoa(ls_stateid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " asbr %s", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "AS External LSA ase = %s ", inet_ntoa(ls_stateid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " asbr = %s ", inet_ntoa(ls_router)); + } + + break; + case LS_TYPE_GROUP: + if (flags & F_SUM) { + sprintf(sum_line, " group %s", inet_ntoa(ls_stateid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " rtr %s", inet_ntoa(ls_router)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Group LSA %s ", inet_ntoa(ls_stateid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + " rtr = %s ", inet_ntoa(ls_router)); + } + break; + default: + if (flags & F_SUM) { + sprintf(sum_line, " unknown LSA type %d", ls_type); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown LSA type %d", ls_type); + } + break; + } +} + +static void +interpret_ospf_lsa_hdr(int flags, struct lsa_hdr *lsah) +{ + if (flags & F_SUM) + return; + + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Options = %s", + ospf_print_bits(ospf_option_bits, lsah->ls_options)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sequence = %X ", ntohl(lsah->ls_seq)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Age = %X ", ospf_print_lsa_age(ntohs(lsah->ls_age))); + } + + ospf_print_ls_type(flags, lsah->ls_type, lsah->ls_stateid, + lsah->ls_router); + +} + +#define TRUNC(addr) ((uchar_t *)(addr) > fragend) +static int +interpret_ospf_lsa(int flags, struct lsa *lsa, uchar_t *fragend) +{ + uchar_t *ls_end; + int rla_count, k; + struct rlalink *rl; + struct tos_metric *tosp; + struct in_addr *addr; + uint32_t *tosmetric; + struct aslametric *am; + uint32_t tm; + int tos, metric; + + interpret_ospf_lsa_hdr(flags, &lsa->ls_hdr); + + ls_end = (uchar_t *)lsa + ntohs(lsa->ls_hdr.ls_length); + + if (TRUNC(ls_end)) + return (-1); + + switch (lsa->ls_hdr.ls_type) { + + case LS_TYPE_ROUTER: + if (TRUNC(&lsa->lsa_un.un_rla.rla_flags)) + return (-1); + + if (flags & F_DTAIL) { + (void) ospf_print_bits(ospf_rla_flag_bits, + lsa->lsa_un.un_rla.rla_flags); + } + + if (TRUNC(&lsa->lsa_un.un_rla.rla_count)) + return (-1); + rla_count = ntohs(lsa->lsa_un.un_rla.rla_count); + + rl = lsa->lsa_un.un_rla.rla_link; + if (TRUNC(rl)) + return (-1); + + while (rla_count-- != 0) { + if (TRUNC((uchar_t *)rl + sizeof (*rl))) + return (-1); + switch (rl->link_type) { + case RLA_TYPE_VIRTUAL: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "Virtual Link"); + } + /* fall through */ + case RLA_TYPE_ROUTER: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "Neighbor = %s", + inet_ntoa(rl->link_id)); + (void) snprintf(get_line(0, 0), + get_line_remain(), "Interface = %s", + inet_ntoa(rl->link_data)); + } + break; + case RLA_TYPE_TRANSIT: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Designated Router = %s", + inet_ntoa(rl->link_id)); + (void) snprintf(get_line(0, 0), + get_line_remain(), "Interface = %s", + inet_ntoa(rl->link_data)); + } + break; + case RLA_TYPE_STUB: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "Network = %s", + inet_ntoa(rl->link_id)); + (void) snprintf(get_line(0, 0), + get_line_remain(), "Mask = %s", + inet_ntoa(rl->link_data)); + } + break; + default: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Unknown link type %d", + rl->link_type); + } + + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "TOS 0 metric = %d", + ntohs(rl->link_tos0metric)); + } + tosp = (struct tos_metric *)( + (uchar_t *)rl + sizeof (rl->link_tos0metric)); + for (k = 0; k > (int)rl->link_toscount; ++k, ++tosp) { + if (TRUNC(tosp)) + return (-1); + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "TOS %d metric = %d", + tosp->tos_type, + ntohs(tosp->tos_metric)); + } + + } + rl = (struct rlalink *)((uchar_t *)(rl + 1) + + ((rl->link_toscount) * sizeof (*tosp))); + if (TRUNC(rl)) + return (-1); /* truncated */ + } + break; + case LS_TYPE_NETWORK: + + if (TRUNC(&lsa->lsa_un.un_nla.nla_mask)) + return (-1); + + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "Mask = %s", + inet_ntoa(lsa->lsa_un.un_nla.nla_mask)); + snprintf(get_line(0, 0), get_line_remain(), + "Routers:"); + } + addr = lsa->lsa_un.un_nla.nla_router; + while ((uchar_t *)addr < ls_end) { + if ((uchar_t *)addr + sizeof (struct in_addr) > ls_end) + return (-1); /* truncated */ + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "\t%s", inet_ntoa(*addr)); + } + ++addr; + } + break; + case LS_TYPE_SUM_IP: + + if (TRUNC((uchar_t *)&lsa->lsa_un.un_sla.sla_mask + + sizeof (struct in_addr))) + return (-1); + + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), "Mask = %s", + inet_ntoa(lsa->lsa_un.un_sla.sla_mask)); + } + /* FALLTHROUGH */ + case LS_TYPE_SUM_ABR: + if (TRUNC(&lsa->lsa_un.un_sla.sla_tosmetric)) + return (-1); + tosmetric = lsa->lsa_un.un_sla.sla_tosmetric; + while ((uchar_t *)tosmetric < ls_end) { + if ((uchar_t *)tosmetric + sizeof (tm) > fragend) + return (-1); /* truncated */ + tm = ntohl(*tosmetric); + tos = (tm & SLA_MASK_TOS) >> SLA_SHIFT_TOS; + metric = tm & SLA_MASK_METRIC; + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + " tos %d metric %d", tos, metric); + } + ++tosmetric; + } + break; + case LS_TYPE_ASE: + if (TRUNC(&lsa->lsa_un.un_asla.asla_mask)) + return (-1); + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), "Mask = %s", + inet_ntoa(lsa->lsa_un.un_asla.asla_mask)); + } + am = lsa->lsa_un.un_asla.asla_metric; + while ((uchar_t *)am < ls_end) { + if ((uchar_t *)am + sizeof (tm) > fragend) + return (-1); /* truncated */ + tm = ntohl(am->asla_tosmetric); + tos = (tm & ASLA_MASK_TOS) >> ASLA_SHIFT_TOS; + metric = tm & ASLA_MASK_METRIC; + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + " type %d tos %d metric %d", + (tm & ASLA_FLAG_EXTERNAL) ? 2 : 1, + tos, metric); + } + if (am->asla_forward.s_addr != 0) { + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), + get_line_remain(), " Forward %s", + inet_ntoa(am->asla_forward)); + } + } + if (am->asla_tag.s_addr != 0) { + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), + get_line_remain(), " Tag %s", + inet_ntoa(am->asla_tag)); + } + } + ++am; + } + break; + default: + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + " Unknown LSA type %d", lsa->ls_hdr.ls_type); + + } + break; + } + return (0); +} +#undef TRUNC + +int +interpret_ospf(int flags, struct ospfhdr *ospf, int iplen, int fraglen) +{ + int nlsa, nlsah = 0; + struct lsa_hdr *lsah; + struct lsr *lsr; + struct lsa *lsa; + boolean_t trunc = B_FALSE; + + if ((fraglen < OSPF_MIN_HEADER_SIZE) || + (fraglen < ntohs(ospf->ospf_len))) + return (fraglen); /* incomplete header */ + + if (fraglen > ntohs(ospf->ospf_len)) + fraglen = ntohs(ospf->ospf_len); + + + if (ospf->ospf_type > OSPF_TYPE_MAX) { + if (flags & F_SUM) { + (void) sprintf(sum_line, "Unknown OSPF TYPE %d \n", + ospf->ospf_type); + sum_line += strlen(sum_line); + } + if (flags & F_SUM) { + show_header("OSPF: ", "OSPF Header", fraglen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown OSPF Type = %d", ospf->ospf_type); + } + return (fraglen); + } + + if (flags & F_SUM) { + sum_line = (char *)get_sum_line(); + (void) sprintf(sum_line, "OSPF %s RTRID=%s ", + ospf_types[ospf->ospf_type], + inet_ntoa(ospf->ospf_routerid)); + sum_line += strlen(sum_line); + (void) sprintf(sum_line, "AREA=%s LEN=%d ", + inet_ntoa(ospf->ospf_areaid), + ntohs((ushort_t)ospf->ospf_len)); + sum_line += strlen(sum_line); + } + + if (flags & F_DTAIL) { + show_header("OSPF: ", "OSPF Header", fraglen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Version = %d", ospf->ospf_version); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type = %s", ospf_types[ospf->ospf_type]); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Router ID = %s", inet_ntoa(ospf->ospf_routerid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Area ID = %s", inet_ntoa(ospf->ospf_areaid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Checksum = 0x%x", ospf->ospf_chksum); + + if (ospf->ospf_authtype > OSPF_AUTH_TYPE_MAX) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Auth = %d (unknown auth type)", + ospf->ospf_authtype); + } else { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Auth = %s", ospf_authtypes[ospf->ospf_authtype]); + } + } + + if (ospf->ospf_version != 2) { + if (ospf->ospf_version == 3) { + if (flags & F_DTAIL) + snprintf(get_line(0, 0), get_line_remain(), + "ospfv3 packet in ipv4 header"); + return (interpret_ospf6(flags, ospf, iplen, fraglen)); + } else { + return (fraglen); + } + } + + switch (ospf->ospf_type) { + case OSPF_TYPE_HELLO: + if (interpret_ospf_hello(flags, ospf, fraglen) < 0) + trunc = B_TRUE; + break; + + case OSPF_TYPE_DB: + if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_DB_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_SUM) { + sprintf(sum_line, " %s %s S %X", ospf_print_bits( + ospf_option_bits, ospf->ospf_db.db_options), + ospf_print_bits(ospf_db_flags_bits, + ospf->ospf_db.db_flags), + ntohl(ospf->ospf_db.db_seq)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + show_header("OSPF DB: ", "Database Description Packet", + fraglen); + show_space(); + snprintf(get_line(0, 0), get_line_remain(), + "Options = %s", ospf_print_bits( + ospf_option_bits, ospf->ospf_db.db_options)); + snprintf(get_line(0, 0), get_line_remain(), + "Flags = %s", ospf_print_bits( + ospf_db_flags_bits, ospf->ospf_db.db_flags)); + snprintf(get_line(0, 0), get_line_remain(), + "Sequence = 0x%X", ntohl(ospf->ospf_db.db_seq)); + /* Print all the LS advs */ + lsah = ospf->ospf_db.db_lshdr; + while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsah + sizeof (struct lsa_hdr) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + interpret_ospf_lsa_hdr(flags, lsah); + ++lsah; + } + } + break; + + case OSPF_TYPE_LSR: + if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_LSR_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "Link State Request Packet"); + } + lsr = ospf->ospf_lsr; + while ((uchar_t *)lsr < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsr + sizeof (struct lsr) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + if (flags & F_SUM) { + nlsah++; + } + if (flags & F_DTAIL) { + ospf_print_ls_type(flags, ntohl(lsr->ls_type), + lsr->ls_stateid, lsr->ls_router); + } + ++lsr; + } + if (flags & F_SUM) { + sprintf(sum_line, " %d LSAs", nlsah); + sum_line += strlen(sum_line); + } + break; + + case OSPF_TYPE_LSU: + if (fraglen < OSPF_MIN_HEADER_SIZE + OSPF_MIN_LSU_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_DTAIL) { + show_header("OSPF LSU: ", "Link State Update Packet", + fraglen); + show_space(); + } + lsa = ospf->ospf_lsu.lsu_lsa; + nlsa = ntohl(ospf->ospf_lsu.lsu_count); + if (flags & F_SUM) { + sprintf(sum_line, "%d LSAs", nlsa); + sum_line += strlen(sum_line); + break; + } + while (nlsa-- != 0) { + uchar_t *fragend = (uchar_t *)ospf + fraglen; + if (((uchar_t *)lsa >= fragend) || + ((uchar_t *)lsa + sizeof (struct lsa_hdr) > + fragend) || + ((uchar_t *)lsa + ntohs(lsa->ls_hdr.ls_length) > + fragend)) { + trunc = B_TRUE; + break; + } + + if (interpret_ospf_lsa(flags, lsa, fragend) < 0) { + trunc = B_TRUE; + break; + } + lsa = (struct lsa *)((uchar_t *)lsa + + ntohs(lsa->ls_hdr.ls_length)); + } + + break; + + case OSPF_TYPE_LSA: + if (flags & F_DTAIL) { + show_header("OSPF LSA: ", "Link State Ack Packet", + fraglen); + show_space(); + } + lsah = ospf->ospf_lsa.lsa_lshdr; + nlsah = 0; + while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsah + sizeof (struct lsa_hdr) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + nlsah++; + if (flags & F_DTAIL) + interpret_ospf_lsa_hdr(flags, lsah); + ++lsah; + } + if (flags & F_SUM) { + sprintf(sum_line, "%d LSAs", nlsah); + sum_line += strlen(sum_line); + } + break; + + default: + /* NOTREACHED */ + break; + } + if (trunc) { + if (flags & F_SUM) { + sprintf(sum_line, "--truncated"); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) + snprintf(get_line(0, 0), get_line_remain(), + "--truncated"); + } + + return (fraglen); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.h new file mode 100644 index 0000000..8bf4d3d --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf.h @@ -0,0 +1,280 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _OSPF_H +#define _OSPF_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Definitions for parsing OSPF packets (RFC 2328 and RFC 2740) + */ + +#ifdef __cplusplus +extern "C" { +#endif + +#define OSPF_TYPE_UMD 0 /* UMD's special monitoring packets */ +#define OSPF_TYPE_HELLO 1 /* Hello */ +#define OSPF_TYPE_DB 2 /* Database Description */ +#define OSPF_TYPE_LSR 3 /* Link State Request */ +#define OSPF_TYPE_LSU 4 /* Link State Update */ +#define OSPF_TYPE_LSA 5 /* Link State Ack */ +#define OSPF_TYPE_MAX 6 + +extern char *ospf_types[]; +struct bits { + uint32_t bit; + const char *str; +}; +char *ospf_print_bits(const struct bits *, uchar_t); +char *ospf_print_lsa_age(long); + +/* Options *_options */ +#define OSPF_OPTION_T 0x01 /* RFC 2328 T bit: TOS support */ +#define OSPF_OPTION_E 0x02 /* E bit: External routes advertised */ +#define OSPF_OPTION_MC 0x04 /* MC bit: Multicast capable */ +#define OSPF_OPTION_N 0x08 /* N bit: For type-7 LSA */ +#define OSPF_OPTION_R 0x10 /* R bit: Router bit */ +#define OSPF_OPTION_DC 0x20 /* DC bit: Demand circuits */ + +#define OSPF_OPTION_V6 0x01 /* RFC 2740 V6 bit */ + +/* ospf_authtype */ +#define OSPF_AUTH_NONE 0 /* No auth-data */ +#define OSPF_AUTH_SIMPLE 1 /* Simple password */ +#define OSPF_AUTH_MD5 2 /* MD5 authentication */ +#define OSPF_AUTH_MD5_LEN 16 /* length of MD5 authentication */ + +#define OSPF_AUTH_TYPE_MAX 3 + +/* db_flags */ +#define OSPF_DB_INIT 0x04 /* "I" */ +#define OSPF_DB_MORE 0x02 /* "M" */ +#define OSPF_DB_MASTER 0x01 /* "MS" */ + + +/* ls_type */ +#define LS_TYPE_ROUTER 1 /* router link */ +#define LS_TYPE_NETWORK 2 /* network link */ +#define LS_TYPE_SUM_IP 3 /* summary link */ +#define LS_TYPE_SUM_ABR 4 /* summary area link */ +#define LS_TYPE_ASE 5 /* ASE */ +#define LS_TYPE_GROUP 6 /* Group membership (multicast */ + /* extensions 23 July 1991) */ +#define LS_TYPE_TYPE7 7 /* Type 7 LSA */ +#define LS_TYPE_LINK 8 /* Link LSA */ +#define LS_TYPE_INTRA_AP 9 /* Intra-Area-Prefix */ +#define LS_TYPE_MAX 10 +#define LS_TYPE_MASK 0x1fff + +#define LS_TYPE_INTER_AP 3 /* RFC 2740 Inter-Area-Prefix */ +#define LS_TYPE_INTER_AR 4 /* RFC 2740 Inter-Area-Router */ + +#define LS6_SCOPE_LINKLOCAL 0x0000 +#define LS6_SCOPE_AREA 0x2000 +#define LS6_SCOPE_AS 0x4000 +#define LS6_SCOPE_MASK 0x6000 + +/* rla_link.link_type */ +#define RLA_TYPE_ROUTER 1 /* point-to-point to another router */ +#define RLA_TYPE_TRANSIT 2 /* connection to transit network */ +#define RLA_TYPE_STUB 3 /* connection to stub network */ +#define RLA_TYPE_VIRTUAL 4 /* virtual link */ + +/* rla_flags */ +#define RLA_FLAG_B 0x01 +#define RLA_FLAG_E 0x02 +#define RLA_FLAG_V 0x04 +#define RLA_FLAG_W 0x08 + + +/* sla_tosmetric breakdown */ +#define SLA_MASK_TOS 0x7f000000 +#define SLA_MASK_METRIC 0x00ffffff +#define SLA_SHIFT_TOS 24 + +/* asla_tosmetric breakdown */ +#define ASLA_FLAG_EXTERNAL 0x80000000 +#define ASLA_MASK_TOS 0x7f000000 +#define ASLA_SHIFT_TOS 24 +#define ASLA_MASK_METRIC 0x00ffffff + +/* multicast vertex type */ +#define MCLA_VERTEX_ROUTER 1 +#define MCLA_VERTEX_NETWORK 2 + +/* link state advertisement header */ +struct lsa_hdr { + ushort_t ls_age; + uchar_t ls_options; + uchar_t ls_type; + struct in_addr ls_stateid; + struct in_addr ls_router; + uint32_t ls_seq; + ushort_t ls_chksum; + ushort_t ls_length; +}; + +/* link state advertisement */ +struct lsa { + struct lsa_hdr ls_hdr; + + /* Link state types */ + union { + /* Router links advertisements */ + struct { + uchar_t rla_flags; + uchar_t rla_zero[1]; + ushort_t rla_count; + struct rlalink { + struct in_addr link_id; + struct in_addr link_data; + uchar_t link_type; + uchar_t link_toscount; + ushort_t link_tos0metric; + } rla_link[1]; /* may repeat */ + } un_rla; + + /* Network links advertisements */ + struct { + struct in_addr nla_mask; + struct in_addr nla_router[1]; /* may repeat */ + } un_nla; + + /* Summary links advertisements */ + struct { + struct in_addr sla_mask; + uint32_t sla_tosmetric[1]; /* may repeat */ + } un_sla; + + /* AS external links advertisements */ + struct { + struct in_addr asla_mask; + struct aslametric { + uint32_t asla_tosmetric; + struct in_addr asla_forward; + struct in_addr asla_tag; + } asla_metric[1]; /* may repeat */ + } un_asla; + + /* Multicast group membership */ + struct mcla { + uint32_t mcla_vtype; + struct in_addr mcla_vid; + } un_mcla[1]; + } lsa_un; +}; + +/* + * TOS metric struct (will be 0 or more in router links update) + */ +struct tos_metric { + uchar_t tos_type; + uchar_t tos_zero; + ushort_t tos_metric; +}; + +/* + * OSPF minimum header sizes + */ +#define OSPF_AUTH_SIZE 8 +#define OSPF_MIN_HEADER_SIZE 24 +#define OSPF6_MIN_HEADER_SIZE 16 +#define OSPF_MIN_HELLO_HEADER_SIZE 20 +#define OSPF_MIN_DB_HEADER_SIZE 8 +#define OSPF6_MIN_DB_HEADER_SIZE 12 +#define OSPF_MIN_LSR_HEADER_SIZE 12 +#define OSPF_MIN_LSU_HEADER_SIZE 4 + +/* + * ospf packet header + */ +struct ospfhdr { + uchar_t ospf_version; + uchar_t ospf_type; + ushort_t ospf_len; + struct in_addr ospf_routerid; + struct in_addr ospf_areaid; + ushort_t ospf_chksum; + ushort_t ospf_authtype; + uchar_t ospf_authdata[OSPF_AUTH_SIZE]; + union { + + /* Hello packet */ + struct { + struct in_addr hello_mask; + ushort_t hello_helloint; + uchar_t hello_options; + uchar_t hello_priority; + uint32_t hello_deadint; + struct in_addr hello_dr; + struct in_addr hello_bdr; + struct in_addr hello_neighbor[1]; /* may repeat */ + } un_hello; + + /* Database Description packet */ + struct { + uchar_t db_zero[2]; + uchar_t db_options; + uchar_t db_flags; + uint32_t db_seq; + struct lsa_hdr db_lshdr[1]; /* may repeat */ + } un_db; + + /* Link State Request */ + struct lsr { + uint32_t ls_type; + struct in_addr ls_stateid; + struct in_addr ls_router; + } un_lsr[1]; /* may repeat */ + + /* Link State Update */ + struct { + uint32_t lsu_count; + struct lsa lsu_lsa[1]; /* may repeat */ + } un_lsu; + + /* Link State Acknowledgement */ + struct { + struct lsa_hdr lsa_lshdr[1]; /* may repeat */ + } un_lsa; + } ospf_un; +}; + +#define ospf_hello ospf_un.un_hello +#define ospf_db ospf_un.un_db +#define ospf_lsr ospf_un.un_lsr +#define ospf_lsu ospf_un.un_lsu +#define ospf_lsa ospf_un.un_lsa + + + +#ifdef __cplusplus +} +#endif + +#endif /* _OSPF_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.c new file mode 100644 index 0000000..6394c8e --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.c @@ -0,0 +1,815 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <arpa/inet.h> +#include "snoop.h" +#include "snoop_ospf.h" +#include "snoop_ospf6.h" + +extern char *dlc_header; +static char *sum_line; +extern const struct bits ospf_db_flags_bits[]; +extern const struct bits ospf_rla_flag_bits[]; +extern const struct bits ospf_option_bits[]; + +const struct bits ospf6_option_bits[] = { + { OSPF_OPTION_V6, "V6" }, + { OSPF_OPTION_E, "E" }, + { OSPF_OPTION_MC, "MC" }, + { OSPF_OPTION_N, "N" }, + { OSPF_OPTION_R, "R" }, + { OSPF_OPTION_DC, "DC" }, + { 0, NULL } +}; + +/* + * return a printable string in dotted-decimal notation + * for id. + */ +static char * +print_ipaddr(uint32_t id) +{ + struct in_addr tmp; + + tmp.s_addr = id; + return (inet_ntoa(tmp)); +} + +static int +interpret_ospf6_hello(int flags, struct ospf6hdr *op, int fraglen) +{ + uint32_t *nbr; + int j; + + if (fraglen < OSPF6_MIN_HEADER_SIZE + OSPF_MIN_HELLO_HEADER_SIZE) + return (-1); /* truncated packet */ + + if (flags & F_SUM) { + if (op->ospf6_hello.hello_dr != 0) { + (void) sprintf(sum_line, "DR=%s ", + print_ipaddr(op->ospf6_hello.hello_dr)); + } + sum_line += strlen(sum_line); + if (op->ospf6_hello.hello_bdr != 0) { + (void) sprintf(sum_line, "BDR=%s ", + print_ipaddr(op->ospf6_hello.hello_bdr)); + } + sum_line += strlen(sum_line); + j = 0; + nbr = op->ospf6_hello.hello_neighbor; + while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) { + if ((uchar_t *)nbr + sizeof (struct in_addr) > + ((uchar_t *)op + fraglen)) + return (-1); /* truncated */ + ++nbr; + j++; + } + (void) sprintf(sum_line, "%d nbrs", j); + sum_line += strlen(sum_line); + + } + if (flags & F_DTAIL) { + show_header("OSPF HELLO: ", "Hello Packet", + ntohs(op->ospf6_len)); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Options = %s", ospf_print_bits(ospf6_option_bits, + op->ospf6_hello.hello6_options)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Interface ID = %s", + print_ipaddr(op->ospf6_hello.hello_ifid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hello interval = %d", + ntohs(op->ospf6_hello.hello_helloint)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Priority = %d", op->ospf6_hello.hello6_priority); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Dead interval = %u", ntohl(op->ospf6_hello.hello_deadint)); + if (op->ospf6_hello.hello_dr != 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Designated Router = %s", + print_ipaddr(op->ospf6_hello.hello_dr)); + } + if (op->ospf6_hello.hello_bdr != 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Backup Designated Router = %s", + print_ipaddr(op->ospf6_hello.hello_bdr)); + } + nbr = op->ospf6_hello.hello_neighbor; + while ((uchar_t *)nbr < ((uchar_t *)op + fraglen)) { + if ((uchar_t *)nbr + sizeof (struct in_addr) > + ((uchar_t *)op + fraglen)) + return (-1); /* truncated */ + (void) snprintf(get_line(0, 0), get_line_remain(), + "Neigbor: %s", print_ipaddr(*nbr)); + ++nbr; + } + } + return (fraglen); +} + +static void +ospf6_print_ls_type(int flags, uint_t ls6_type, uint32_t ls6_stateid, + uint32_t ls6_router) +{ + char scope[15]; + + if (flags & F_SUM) + return; + + switch (ls6_type & LS6_SCOPE_MASK) { + case LS6_SCOPE_LINKLOCAL: + snprintf(scope, sizeof (scope), "linklocal"); + break; + case LS6_SCOPE_AREA: + snprintf(scope, sizeof (scope), "area"); + break; + case LS6_SCOPE_AS: + snprintf(scope, sizeof (scope), "AS"); + break; + default: + snprintf(scope, sizeof (scope), ""); + break; + } + switch (ls6_type & LS_TYPE_MASK) { + case LS_TYPE_ROUTER: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Router = %s", scope, print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_NETWORK: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Net DR %s IF %s", scope, + print_ipaddr(ls6_router), + print_ipaddr(ls6_stateid)); + } + break; + case LS_TYPE_INTER_AP: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Inter-area-prefix = %s ABR %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_INTER_AR: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Inter-area-router = %s Router %s", scope, + print_ipaddr(ls6_router), + print_ipaddr(ls6_stateid)); + } + break; + case LS_TYPE_ASE: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s ASE = %s ASBR %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_GROUP: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s group = %s Router %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_TYPE7: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Type 7 = %s Router %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_LINK: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s link = %s Router %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + case LS_TYPE_INTRA_AP: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Inter-area-prefix = %s Router %s", scope, + print_ipaddr(ls6_stateid), + print_ipaddr(ls6_router)); + } + break; + default: + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s Unknown type = 0x%x", ls6_type); + } + break; + } +} + +static int +ospf6_print_lsaprefix(int flags, struct lsa6_prefix *lpfx) +{ + int k; + struct in6_addr prefix; + char prefixstr[INET6_ADDRSTRLEN]; + + k = (lpfx->lsa6_plen + 31)/32; + if (k * 4 > sizeof (struct in6_addr)) { + if (flags & F_SUM) { + sprintf(sum_line, "Unknown prefix len %d", + lpfx->lsa6_plen); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown prefix len %d", lpfx->lsa6_plen); + } + } + memset((void *)&prefix, 0, sizeof (prefix)); + memcpy((void *)&prefix, lpfx->lsa6_pfx, k * 4); + (void) inet_ntop(AF_INET6, (char *)&prefix, prefixstr, + INET6_ADDRSTRLEN); + if (flags & F_SUM) { + sprintf(sum_line, "%s/%d", prefixstr, lpfx->lsa6_plen); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "%s/%d", prefixstr, lpfx->lsa6_plen); + } + if (lpfx->lsa6_popt != 0) { + if (flags & F_SUM) { + sprintf(sum_line, "(opt = %x)", lpfx->lsa6_popt); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "(opt = %x)", lpfx->lsa6_popt); + } + } + return (sizeof (*lpfx) - 4 + k * 4); +} + +static void +interpret_ospf6_lsa_hdr(int flags, struct lsa6_hdr *lsah) +{ + if (flags & F_SUM) + return; + + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Sequence = %X ", ntohl(lsah->ls6_seq)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Age = %X ", ospf_print_lsa_age(ntohl(lsah->ls6_age))); + } + + ospf6_print_ls_type(flags, lsah->ls6_type, lsah->ls6_stateid, + lsah->ls6_router); + +} + +#define TRUNC(addr) ((uchar_t *)(addr) > fragend) +static int +interpret_ospf6_lsa(int flags, struct lsa6 *lsa, uchar_t *fragend) +{ + uchar_t *ls_end; + int k, j; + struct rla6link *rl; + uint32_t *addr; + struct lsa6_prefix *lpfx; + struct llsa *llsa; + char addrstr[INET6_ADDRSTRLEN]; + + interpret_ospf6_lsa_hdr(flags, &lsa->ls6_hdr); + + ls_end = (uchar_t *)lsa + ntohs(lsa->ls6_hdr.ls6_length); + + if (TRUNC(ls_end)) + return (-1); + + switch (ntohs(lsa->ls6_hdr.ls6_type)) { + + case LS_TYPE_ROUTER|LS6_SCOPE_AREA: + if (TRUNC(&lsa->lsa_un.un_rla.rla6_flags)) + return (-1); + + (void) ospf_print_bits(ospf_rla_flag_bits, + lsa->lsa_un.un_rla.rla6_flags); + + if (TRUNC(&lsa->lsa_un.un_rla.rla6_options)) + return (-1); + (void) ospf_print_bits(ospf_option_bits, + ntohl(lsa->lsa_un.un_rla.rla6_options)); + + rl = lsa->lsa_un.un_rla.rla_link; + if (TRUNC(rl)) + return (-1); + + while (rl + sizeof (*rl) <= (struct rla6link *)ls_end) { + if (TRUNC((uchar_t *)rl + sizeof (*rl))) + return (-1); + if (flags & F_SUM) { + sprintf(sum_line, "{"); /* } (ctags) */ + sum_line += strlen(sum_line); + } + switch (rl->link_type) { + case RLA_TYPE_VIRTUAL: + if (flags & F_SUM) { + sprintf(sum_line, "virt "); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "Virtual Link"); + } + /* FALLTHROUGH */ + case RLA_TYPE_ROUTER: + if (flags & F_SUM) { + sprintf(sum_line, "nbrid %s", + print_ipaddr(rl->link_nrtid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " nbrif %s", + print_ipaddr(rl->link_nifid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " if %s", + print_ipaddr(rl->link_ifid)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "Neighbor = %s", + print_ipaddr(rl->link_nrtid)); + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Interface = %s id %s", + print_ipaddr(rl->link_nifid), + print_ipaddr(rl->link_ifid)); + } + break; + case RLA_TYPE_TRANSIT: + if (flags & F_SUM) { + sprintf(sum_line, "dr %s", + print_ipaddr(rl->link_nrtid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " drif %s", + print_ipaddr(rl->link_nifid)); + sum_line += strlen(sum_line); + sprintf(sum_line, " if %s", + print_ipaddr(rl->link_ifid)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Designated Router = %s", + print_ipaddr(rl->link_nrtid)); + (void) snprintf(get_line(0, 0), + get_line_remain(), + "DR Interface = %s id %s", + print_ipaddr(rl->link_nifid), + print_ipaddr(rl->link_ifid)); + } + break; + default: + if (flags & F_SUM) { + sprintf(sum_line, + "Unknown link type %d", + rl->link_type); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Unknown link type %d", + rl->link_type); + } + + } + if (flags & F_SUM) { + sprintf(sum_line, " metric %d", + ntohs(rl->link_metric)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), " metric = %d", + ntohs(rl->link_metric)); + } + if (flags & F_SUM) { /* { (ctags) */ + sprintf(sum_line, " }"); + sum_line += strlen(sum_line); + } + rl++; + if ((uchar_t *)rl > fragend) + return (-1); /* truncated */ + } + break; + case LS_TYPE_NETWORK | LS6_SCOPE_AREA: + + if (TRUNC(&lsa->lsa_un.un_nla.nla_options)) + return (-1); + + (void) ospf_print_bits(ospf6_option_bits, + ntohl(lsa->lsa_un.un_nla.nla_options)); + + if (flags & F_SUM) { + sprintf(sum_line, " rtrs"); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "Routers:"); + } + addr = lsa->lsa_un.un_nla.nla_router; + while ((uchar_t *)addr < ls_end) { + if ((uchar_t *)addr + sizeof (struct in_addr) > ls_end) + return (-1); /* truncated */ + if (flags & F_SUM) { + sprintf(sum_line, " %s", print_ipaddr(*addr)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "\t%s", print_ipaddr(*addr)); + } + ++addr; + } + break; + case LS_TYPE_INTER_AP | LS6_SCOPE_AREA: + + if (TRUNC(&lsa->lsa_un.un_inter_ap.inter_ap_metric)) + return (-1); + + if (flags & F_SUM) { + sprintf(sum_line, " metric %s", + ntohl(lsa->lsa_un.un_inter_ap.inter_ap_metric) & + SLA_MASK_METRIC); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "Metric = %s", + ntohl(lsa->lsa_un.un_inter_ap.inter_ap_metric) & + SLA_MASK_METRIC); + } + lpfx = lsa->lsa_un.un_inter_ap.inter_ap_prefix; + if (lpfx > (struct lsa6_prefix *)ls_end) + return (-1); + while (lpfx + sizeof (*lpfx) <= (struct lsa6_prefix *)ls_end) { + k = ospf6_print_lsaprefix(flags, lpfx); + lpfx = (struct lsa6_prefix *)(((uchar_t *)lpfx) + k); + if (lpfx > (struct lsa6_prefix *)ls_end) + return (-1); + } + break; + case LS_TYPE_LINK: + llsa = &lsa->lsa_un.un_llsa; + if (TRUNC(llsa->llsa_options)) + return (-1); + ospf_print_bits(ospf6_option_bits, ntohl(llsa->llsa_options)); + if (TRUNC(llsa->llsa_nprefix)) + return (-1); + (void) inet_ntop(AF_INET6, &llsa->llsa_lladdr, + addrstr, INET6_ADDRSTRLEN); + if (flags & F_SUM) { + sprintf(sum_line, " pri %d lladdr %s npref %d", + ntohl(llsa->llsa_priority), addrstr, + ntohl(llsa->llsa_nprefix)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + "Priority %d", ntohl(llsa->llsa_priority)); + snprintf(get_line(0, 0), get_line_remain(), + "Link Local addr %d", addrstr); + snprintf(get_line(0, 0), get_line_remain(), + "npref %d", ntohl(llsa->llsa_nprefix)); + } + lpfx = llsa->llsa_prefix; + for (j = 0; j < ntohl(llsa->llsa_nprefix); j++) { + if (TRUNC(lpfx)) + return (-1); + k = ospf6_print_lsaprefix(flags, lpfx); + lpfx = (struct lsa6_prefix *)(((uchar_t *)lpfx) + k); + } + break; + + case LS_TYPE_INTRA_AP | LS6_SCOPE_AREA: + if (TRUNC(&lsa->lsa_un.un_intra_ap.intra_ap_rtid)) + return (-1); + ospf6_print_ls_type(flags, + ntohs(lsa->lsa_un.un_intra_ap.intra_ap_lstype), + lsa->lsa_un.un_intra_ap.intra_ap_lsid, + lsa->lsa_un.un_intra_ap.intra_ap_rtid); + if (TRUNC(&lsa->lsa_un.un_intra_ap.intra_ap_nprefix)) + return (-1); + if (flags & F_SUM) { + sprintf(sum_line, " npref %d", + ntohs(lsa->lsa_un.un_intra_ap.intra_ap_nprefix)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), "NPref %d", + ntohs(lsa->lsa_un.un_intra_ap.intra_ap_nprefix)); + } + + lpfx = lsa->lsa_un.un_intra_ap.intra_ap_prefix; + for (j = 0; + j < ntohs(lsa->lsa_un.un_intra_ap.intra_ap_nprefix); j++) { + if (TRUNC(lpfx)) + return (-1); + k = ospf6_print_lsaprefix(flags, lpfx); + lpfx = (struct lsa6_prefix *)(((uchar_t *)lpfx) + k); + } + break; + + default: + if (flags & F_SUM) { + sprintf(sum_line, " Unknown LSA type (%d)", + lsa->ls6_hdr.ls6_type); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + snprintf(get_line(0, 0), get_line_remain(), + " Unknown LSA type %d", lsa->ls6_hdr.ls6_type); + + } + break; + } + return (0); +} +#undef TRUNC +int +interpret_ospf6(int flags, struct ospf6hdr *ospf, int iplen, int fraglen) +{ + boolean_t trunc = B_FALSE; + struct lsa6_hdr *lsah; + struct lsr6 *lsr; + struct lsa6 *lsa; + int nlsa, nlsah; + + if ((fraglen < OSPF6_MIN_HEADER_SIZE) || + (fraglen < ntohs(ospf->ospf6_len))) + return (fraglen); /* incomplete header */ + + if (ospf->ospf6_version != 3) { + if (ospf->ospf6_version == 2) { + if (flags & F_DTAIL) + snprintf(get_line(0, 0), get_line_remain(), + "ospfv2 packet in ipv6 header"); + return (interpret_ospf(flags, ospf, iplen, fraglen)); + } else { + return (fraglen); + } + } + + if (fraglen > ntohs(ospf->ospf6_len)) + fraglen = ntohs(ospf->ospf6_len); + + if (ospf->ospf6_type > OSPF_TYPE_MAX) { + if (flags & F_SUM) { + (void) sprintf(sum_line, "Unknown OSPF TYPE %d \n", + ospf->ospf6_type); + sum_line += strlen(sum_line); + } + if (flags & F_SUM) { + show_header("OSPFv3: ", "OSPFv3 Header", fraglen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown OSPF Type = %d", ospf->ospf6_type); + } + return (fraglen); + } + + if (flags & F_SUM) { + sum_line = (char *)get_sum_line(); + (void) sprintf(sum_line, "OSPFv3 %s RTRID=%s ", + ospf_types[ospf->ospf6_type], + print_ipaddr(ospf->ospf6_routerid)); + sum_line += strlen(sum_line); + (void) sprintf(sum_line, "AREA=%s LEN=%d instance %u ", + print_ipaddr(ospf->ospf6_areaid), + ntohs((ushort_t)ospf->ospf6_len), ospf->ospf6_instanceid); + sum_line += strlen(sum_line); + } + + if (flags & F_DTAIL) { + show_header("OSPFv3: ", "OSPF Header", fraglen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Version = %d", ospf->ospf6_version); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Type = %s", ospf_types[ospf->ospf6_type]); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Router ID = %s", print_ipaddr(ospf->ospf6_routerid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Area ID = %s", print_ipaddr(ospf->ospf6_areaid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Checksum = 0x%x", ospf->ospf6_chksum); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Instance = %u", ospf->ospf6_instanceid); + } + + switch (ospf->ospf6_type) { + case OSPF_TYPE_HELLO: + if (interpret_ospf6_hello(flags, ospf, fraglen) < 0) + trunc = B_TRUE; + break; + + case OSPF_TYPE_DB: + if (fraglen < OSPF6_MIN_HEADER_SIZE + + OSPF6_MIN_DB_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_SUM) { + sprintf(sum_line, " %s %s mtu %u S %X", ospf_print_bits( + ospf6_option_bits, + ntohl(ospf->ospf6_db.db_options)), + ospf_print_bits(ospf_db_flags_bits, + ospf->ospf6_db.db_flags), + ntohs(ospf->ospf6_db.db_mtu), + ntohl(ospf->ospf6_db.db_seq)); + sum_line += strlen(sum_line); + } + if (flags & F_DTAIL) { + show_header("OSPF DB: ", "Database Description Packet", + fraglen); + show_space(); + snprintf(get_line(0, 0), get_line_remain(), + "Options = %s", ospf_print_bits( + ospf6_option_bits, ospf->ospf6_db.db_options)); + snprintf(get_line(0, 0), get_line_remain(), + "Flags = %s", ospf_print_bits( + ospf_db_flags_bits, ospf->ospf6_db.db_flags)); + snprintf(get_line(0, 0), get_line_remain(), + "MTU = %u", ntohl(ospf->ospf6_db.db_seq)); + snprintf(get_line(0, 0), get_line_remain(), + "Sequence = 0x%X", ntohl(ospf->ospf6_db.db_seq)); + /* Print all the LS advs */ + lsah = ospf->ospf6_db.db_lshdr; + while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsah + sizeof (struct lsa6_hdr) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + interpret_ospf6_lsa_hdr(flags, lsah); + ++lsah; + } + } + break; + + case OSPF_TYPE_LSR: + if (fraglen < OSPF6_MIN_HEADER_SIZE + + OSPF_MIN_LSR_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_DTAIL) { + show_header("OSPF LSR: ", "Link State Request Packet", + fraglen); + show_space(); + } + lsr = ospf->ospf6_lsr; + nlsah = 0; + while ((uchar_t *)lsr < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsr + sizeof (struct lsr6) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + nlsah++; + if (flags & F_DTAIL) { + ospf6_print_ls_type(flags, ntohl(lsr->ls_type), + lsr->ls_stateid, lsr->ls_router); + } + ++lsr; + } + if (flags & F_SUM) { + sprintf(sum_line, "%d LSAs", nlsah); + sum_line += strlen(sum_line); + } + break; + + case OSPF_TYPE_LSU: + if (fraglen < OSPF6_MIN_HEADER_SIZE + + OSPF_MIN_LSU_HEADER_SIZE) { + trunc = B_TRUE; + break; + } + if (flags & F_DTAIL) { + show_header("OSPF LSU: ", "Link State Update Packet", + fraglen); + show_space(); + } + lsa = ospf->ospf6_lsu.lsu_lsa; + nlsa = ntohl(ospf->ospf6_lsu.lsu_count); + if (flags & F_SUM) { + sprintf(sum_line, "%d LSAs", nlsa); + sum_line += strlen(sum_line); + break; + } + while (nlsa-- != 0) { + uchar_t *fragend = (uchar_t *)ospf + fraglen; + if (((uchar_t *)lsa >= fragend) || + ((uchar_t *)lsa + sizeof (struct lsa_hdr) > + fragend) || + ((uchar_t *)lsa + ntohs(lsa->ls6_hdr.ls6_length) > + fragend)) { + trunc = B_TRUE; + break; + } + + if (interpret_ospf6_lsa(flags, lsa, fragend) < 0) { + trunc = B_TRUE; + break; + } + lsa = (struct lsa6 *)((uchar_t *)lsa + + ntohs(lsa->ls6_hdr.ls6_length)); + } + break; + + case OSPF_TYPE_LSA: + if (flags & F_DTAIL) { + show_header("OSPF LSA: ", "Link State Ack Packet", + fraglen); + show_space(); + } + lsah = ospf->ospf6_lsa.lsa_lshdr; + nlsah = 0; + while ((uchar_t *)lsah < ((uchar_t *)ospf + fraglen)) { + if ((uchar_t *)lsah + sizeof (struct lsa6_hdr) > + ((uchar_t *)ospf + fraglen)) { + trunc = B_TRUE; + break; + } + nlsah++; + if (flags & F_DTAIL) + interpret_ospf6_lsa_hdr(flags, lsah); + ++lsah; + } + if (flags & F_SUM) { + sprintf(sum_line, "%d LSAs", nlsah); + sum_line += strlen(sum_line); + } + break; + + default: + /* NOTREACHED */ + break; + } + if (trunc) { + if (flags & F_SUM) + sprintf(sum_line, "--truncated"); + if (flags & F_DTAIL) + snprintf(get_line(0, 0), get_line_remain(), + "--truncated"); + } + + return (fraglen); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.h new file mode 100644 index 0000000..2c71fca --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ospf6.h @@ -0,0 +1,185 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _OSPF6_H +#define _OSPF6_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Definitions for parsing OSPF packets (RFC 2328) + */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct lsa6_hdr { + uint16_t ls6_age; + uint16_t ls6_type; + uint32_t ls6_stateid; + uint32_t ls6_router; + uint32_t ls6_seq; + uint16_t ls6_chksum; + uint16_t ls6_length; +}; + +struct lsa6_prefix { + uint8_t lsa6_plen; + uint8_t lsa6_popt; + uint16_t lsa6_pmbz; + uint8_t lsa6_pfx[4]; +}; + +/* link state advertisement */ +struct lsa6 { + struct lsa6_hdr ls6_hdr; + + /* Link state types */ + union { + /* Router links advertisements */ + struct { + union { + uint8_t rla_flg; + uint32_t rla_opt; + } un_rla_flgopt; +#define rla6_flags un_rla_flgopt.rla_flg +#define rla6_options un_rla_flgopt.rla_opt + struct rla6link { + uint8_t link_type; + uint8_t link_zero[1]; + uint16_t link_metric; + uint32_t link_ifid; + uint32_t link_nifid; + uint32_t link_nrtid; + } rla_link[1]; /* may repeat */ + } un_rla; + + /* Network links advertisements */ + struct { + uint32_t nla_options; + uint32_t nla_router[1]; /* may repeat */ + } un_nla; + + /* Inter Area Prefix LSA */ + struct { + uint32_t inter_ap_metric; + struct lsa6_prefix inter_ap_prefix[1]; + } un_inter_ap; + + /* Link LSA */ + struct llsa { + union { + uint8_t pri; + uint32_t opt; + } llsa_priandopt; +#define llsa_priority llsa_priandopt.pri +#define llsa_options llsa_priandopt.opt + struct in6_addr llsa_lladdr; + uint32_t llsa_nprefix; + struct lsa6_prefix llsa_prefix[1]; + } un_llsa; + + /* Intra-Area-Prefix */ + struct { + uint16_t intra_ap_nprefix; + uint16_t intra_ap_lstype; + uint32_t intra_ap_lsid; + uint32_t intra_ap_rtid; + struct lsa6_prefix intra_ap_prefix[1]; + } un_intra_ap; + } lsa_un; +}; + +struct ospf6hdr { + uint8_t ospf6_version; + uint8_t ospf6_type; + uint16_t ospf6_len; + uint32_t ospf6_routerid; + uint32_t ospf6_areaid; + uint16_t ospf6_chksum; + uint8_t ospf6_instanceid; + uint8_t ospf6_rsvd; + union { + + /* Hello packet */ + struct { + uint32_t hello_ifid; + union { + uint8_t pri; + uint32_t opt; + } hello_priandopt; +#define hello6_priority hello_priandopt.pri +#define hello6_options hello_priandopt.opt + uint16_t hello_helloint; + uint16_t hello_deadint; + uint32_t hello_dr; + uint32_t hello_bdr; + uint32_t hello_neighbor[1]; /* may repeat */ + } un_hello; + + /* Database Description packet */ + struct { + uint32_t db_options; + uint16_t db_mtu; + uint8_t db_mbz; + uint8_t db_flags; + uint32_t db_seq; + struct lsa6_hdr db_lshdr[1]; /* may repeat */ + } un_db; + + /* Link State Request */ + struct lsr6 { + uint16_t ls_mbz; + uint16_t ls_type; + uint32_t ls_stateid; + uint32_t ls_router; + } un_lsr[1]; /* may repeat */ + + /* Link State Update */ + struct { + uint32_t lsu_count; + struct lsa6 lsu_lsa[1]; /* may repeat */ + } un_lsu; + + /* Link State Acknowledgement */ + struct { + struct lsa6_hdr lsa_lshdr[1]; /* may repeat */ + } un_lsa; + } ospf6_un; +}; + +#define ospf6_hello ospf6_un.un_hello +#define ospf6_db ospf6_un.un_db +#define ospf6_lsr ospf6_un.un_lsr +#define ospf6_lsu ospf6_un.un_lsu +#define ospf6_lsa ospf6_un.un_lsa + +#ifdef __cplusplus +} +#endif + +#endif /* _OSPF6_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pf.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pf.c new file mode 100644 index 0000000..40faeb5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pf.c @@ -0,0 +1,1664 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * Copyright 2012 Milan Jurik. All rights reserved. + */ + +#include <stdio.h> +#include <stddef.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/isa_defs.h> + +#include <sys/socket.h> +#include <sys/vlan.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <netinet/tcp.h> +#include <netinet/udp.h> +#include <inet/ip.h> +#include <inet/ip6.h> +#include <netdb.h> +#include <rpc/rpc.h> +#include <setjmp.h> + +#include <sys/pfmod.h> +#include "snoop.h" +#include "snoop_vlan.h" + +/* + * This module generates code for the kernel packet filter. + * The kernel packet filter is more efficient since it + * operates without context switching or moving data into + * the capture buffer. On the other hand, it is limited + * in its filtering ability i.e. can't cope with variable + * length headers, can't compare the packet size, 1 and 4 octet + * comparisons are awkward, code space is limited to ENMAXFILTERS + * halfwords, etc. + * The parser is the same for the user-level packet filter though + * more limited in the variety of expressions it can generate + * code for. If the pf compiler finds an expression it can't + * handle, it tries to set up a split filter in kernel and do the + * remaining filtering in userland. If that also fails, it resorts + * to userland filter. (See additional comment in pf_compile) + */ + +extern struct Pf_ext_packetfilt pf; +static ushort_t *pfp; +jmp_buf env; + +int eaddr; /* need ethernet addr */ + +int opstack; /* operand stack depth */ + +#define EQ(val) (strcmp(token, val) == 0) +#define IPV4_ONLY 0 +#define IPV6_ONLY 1 +#define IPV4_AND_IPV6 2 + +typedef struct { + int transport_protocol; + int network_protocol; + /* + * offset is the offset in bytes from the beginning + * of the network protocol header to where the transport + * protocol type is. + */ + int offset; +} transport_table_t; + +typedef struct network_table { + char *nmt_name; + int nmt_val; +} network_table_t; + +static network_table_t ether_network_mapping_table[] = { + { "pup", ETHERTYPE_PUP }, + { "ip", ETHERTYPE_IP }, + { "arp", ETHERTYPE_ARP }, + { "revarp", ETHERTYPE_REVARP }, + { "at", ETHERTYPE_AT }, + { "aarp", ETHERTYPE_AARP }, + { "vlan", ETHERTYPE_VLAN }, + { "ip6", ETHERTYPE_IPV6 }, + { "slow", ETHERTYPE_SLOW }, + { "ppoed", ETHERTYPE_PPPOED }, + { "ppoes", ETHERTYPE_PPPOES }, + { "NULL", -1 } + +}; + +static network_table_t ib_network_mapping_table[] = { + { "pup", ETHERTYPE_PUP }, + { "ip", ETHERTYPE_IP }, + { "arp", ETHERTYPE_ARP }, + { "revarp", ETHERTYPE_REVARP }, + { "at", ETHERTYPE_AT }, + { "aarp", ETHERTYPE_AARP }, + { "vlan", ETHERTYPE_VLAN }, + { "ip6", ETHERTYPE_IPV6 }, + { "slow", ETHERTYPE_SLOW }, + { "ppoed", ETHERTYPE_PPPOED }, + { "ppoes", ETHERTYPE_PPPOES }, + { "NULL", -1 } + +}; + +static network_table_t ipnet_network_mapping_table[] = { + { "ip", (DL_IPNETINFO_VERSION << 8 | AF_INET) }, + { "ip6", (DL_IPNETINFO_VERSION << 8 | AF_INET6) }, + { "NULL", -1 } + +}; + +static transport_table_t ether_transport_mapping_table[] = { + {IPPROTO_TCP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_TCP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMPV6, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ENCAP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {-1, 0, 0} /* must be the final entry */ +}; + +static transport_table_t ipnet_transport_mapping_table[] = { + {IPPROTO_TCP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_TCP, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMPV6, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ENCAP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, (DL_IPNETINFO_VERSION << 8 | AF_INET), + IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, (DL_IPNETINFO_VERSION << 8 | AF_INET6), + IPV6_TYPE_HEADER_OFFSET}, + {-1, 0, 0} /* must be the final entry */ +}; + +static transport_table_t ib_transport_mapping_table[] = { + {IPPROTO_TCP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_TCP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_UDP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_OSPF, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_SCTP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ICMPV6, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_ENCAP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_ESP, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, ETHERTYPE_IP, IPV4_TYPE_HEADER_OFFSET}, + {IPPROTO_AH, ETHERTYPE_IPV6, IPV6_TYPE_HEADER_OFFSET}, + {-1, 0, 0} /* must be the final entry */ +}; + +typedef struct datalink { + uint_t dl_type; + void (*dl_match_fn)(uint_t datatype); + transport_table_t *dl_trans_map_tbl; + network_table_t *dl_net_map_tbl; + int dl_link_header_len; + int dl_link_type_offset; + int dl_link_dest_offset; + int dl_link_src_offset; + int dl_link_addr_len; +} datalink_t; + +datalink_t dl; + +#define IPV4_SRCADDR_OFFSET (dl.dl_link_header_len + 12) +#define IPV4_DSTADDR_OFFSET (dl.dl_link_header_len + 16) +#define IPV6_SRCADDR_OFFSET (dl.dl_link_header_len + 8) +#define IPV6_DSTADDR_OFFSET (dl.dl_link_header_len + 24) + +#define IPNET_SRCZONE_OFFSET 16 +#define IPNET_DSTZONE_OFFSET 20 + +static int inBrace = 0, inBraceOR = 0; +static int foundOR = 0; +char *tkp, *sav_tkp; +char *token; +enum { EOL, ALPHA, NUMBER, FIELD, ADDR_IP, ADDR_ETHER, SPECIAL, + ADDR_IP6 } tokentype; +uint_t tokenval; + +enum direction { ANY, TO, FROM }; +enum direction dir; + +extern void next(); + +static void pf_expression(); +static void pf_check_vlan_tag(uint_t offset); +static void pf_clear_offset_register(); +static void pf_emit_load_offset(uint_t offset); +static void pf_match_ethertype(uint_t ethertype); +static void pf_match_ipnettype(uint_t type); +static void pf_match_ibtype(uint_t type); +static void pf_check_transport_protocol(uint_t transport_protocol); +static void pf_compare_value_mask_generic(int offset, uint_t len, + uint_t val, int mask, uint_t op); +static void pf_matchfn(const char *name); + +/* + * This pointer points to the function that last generated + * instructions to change the offset register. It's used + * for comparisons to see if we need to issue more instructions + * to change the register. + * + * It's initialized to pf_clear_offset_register because the offset + * register in pfmod is initialized to zero, similar to the state + * it would be in after executing the instructions issued by + * pf_clear_offset_register. + */ +static void *last_offset_operation = (void*)pf_clear_offset_register; + +static void +pf_emit(x) + ushort_t x; +{ + if (pfp > &pf.Pf_Filter[PF_MAXFILTERS - 1]) + longjmp(env, 1); + *pfp++ = x; +} + +static void +pf_codeprint(code, len) + ushort_t *code; + int len; +{ + ushort_t *pc; + ushort_t *plast = code + len; + int op, action; + + if (len > 0) { + printf("Kernel Filter:\n"); + } + + for (pc = code; pc < plast; pc++) { + printf("\t%3d: ", pc - code); + + op = *pc & 0xfc00; /* high 10 bits */ + action = *pc & 0x3ff; /* low 6 bits */ + + switch (action) { + case ENF_PUSHLIT: + printf("PUSHLIT "); + break; + case ENF_PUSHZERO: + printf("PUSHZERO "); + break; +#ifdef ENF_PUSHONE + case ENF_PUSHONE: + printf("PUSHONE "); + break; +#endif +#ifdef ENF_PUSHFFFF + case ENF_PUSHFFFF: + printf("PUSHFFFF "); + break; +#endif +#ifdef ENF_PUSHFF00 + case ENF_PUSHFF00: + printf("PUSHFF00 "); + break; +#endif +#ifdef ENF_PUSH00FF + case ENF_PUSH00FF: + printf("PUSH00FF "); + break; +#endif + case ENF_LOAD_OFFSET: + printf("LOAD_OFFSET "); + break; + case ENF_BRTR: + printf("BRTR "); + break; + case ENF_BRFL: + printf("BRFL "); + break; + case ENF_POP: + printf("POP "); + break; + } + + if (action >= ENF_PUSHWORD) + printf("PUSHWORD %d ", action - ENF_PUSHWORD); + + switch (op) { + case ENF_EQ: + printf("EQ "); + break; + case ENF_LT: + printf("LT "); + break; + case ENF_LE: + printf("LE "); + break; + case ENF_GT: + printf("GT "); + break; + case ENF_GE: + printf("GE "); + break; + case ENF_AND: + printf("AND "); + break; + case ENF_OR: + printf("OR "); + break; + case ENF_XOR: + printf("XOR "); + break; + case ENF_COR: + printf("COR "); + break; + case ENF_CAND: + printf("CAND "); + break; + case ENF_CNOR: + printf("CNOR "); + break; + case ENF_CNAND: + printf("CNAND "); + break; + case ENF_NEQ: + printf("NEQ "); + break; + } + + if (action == ENF_PUSHLIT || + action == ENF_LOAD_OFFSET || + action == ENF_BRTR || + action == ENF_BRFL) { + pc++; + printf("\n\t%3d: %d (0x%04x)", pc - code, *pc, *pc); + } + + printf("\n"); + } +} + +/* + * Emit packet filter code to check a + * field in the packet for a particular value. + * Need different code for each field size. + * Since the pf can only compare 16 bit quantities + * we have to use masking to compare byte values. + * Long word (32 bit) quantities have to be done + * as two 16 bit comparisons. + */ +static void +pf_compare_value(int offset, uint_t len, uint_t val) +{ + /* + * If the property being filtered on is absent in the media + * packet, error out. + */ + if (offset == -1) + pr_err("filter option unsupported on media"); + + switch (len) { + case 1: + pf_emit(ENF_PUSHWORD + offset / 2); +#if defined(_BIG_ENDIAN) + if (offset % 2) +#else + if (!(offset % 2)) +#endif + { +#ifdef ENF_PUSH00FF + pf_emit(ENF_PUSH00FF | ENF_AND); +#else + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(0x00FF); +#endif + pf_emit(ENF_PUSHLIT | ENF_EQ); + pf_emit(val); + } else { +#ifdef ENF_PUSHFF00 + pf_emit(ENF_PUSHFF00 | ENF_AND); +#else + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(0xFF00); +#endif + pf_emit(ENF_PUSHLIT | ENF_EQ); + pf_emit(val << 8); + } + break; + + case 2: + pf_emit(ENF_PUSHWORD + offset / 2); + pf_emit(ENF_PUSHLIT | ENF_EQ); + pf_emit((ushort_t)val); + break; + + case 4: + pf_emit(ENF_PUSHWORD + offset / 2); + pf_emit(ENF_PUSHLIT | ENF_EQ); +#if defined(_BIG_ENDIAN) + pf_emit(val >> 16); +#elif defined(_LITTLE_ENDIAN) + pf_emit(val & 0xffff); +#else +#error One of _BIG_ENDIAN and _LITTLE_ENDIAN must be defined +#endif + pf_emit(ENF_PUSHWORD + (offset / 2) + 1); + pf_emit(ENF_PUSHLIT | ENF_EQ); +#if defined(_BIG_ENDIAN) + pf_emit(val & 0xffff); +#else + pf_emit(val >> 16); +#endif + pf_emit(ENF_AND); + break; + } +} + +/* + * same as pf_compare_value, but only for emiting code to + * compare ipv6 addresses. + */ +static void +pf_compare_value_v6(int offset, uint_t len, struct in6_addr val) +{ + int i; + + for (i = 0; i < len; i += 2) { + pf_emit(ENF_PUSHWORD + offset / 2 + i / 2); + pf_emit(ENF_PUSHLIT | ENF_EQ); + pf_emit(*(uint16_t *)&val.s6_addr[i]); + if (i != 0) + pf_emit(ENF_AND); + } +} + + +/* + * Same as above except mask the field value + * before doing the comparison. The comparison checks + * to make sure the values are equal. + */ +static void +pf_compare_value_mask(int offset, uint_t len, uint_t val, int mask) +{ + pf_compare_value_mask_generic(offset, len, val, mask, ENF_EQ); +} + +/* + * Same as above except the values are compared to see if they are not + * equal. + */ +static void +pf_compare_value_mask_neq(int offset, uint_t len, uint_t val, int mask) +{ + pf_compare_value_mask_generic(offset, len, val, mask, ENF_NEQ); +} + +/* + * Similar to pf_compare_value. + * + * This is the utility function that does the actual work to compare + * two values using a mask. The comparison operation is passed into + * the function. + */ +static void +pf_compare_value_mask_generic(int offset, uint_t len, uint_t val, int mask, + uint_t op) +{ + /* + * If the property being filtered on is absent in the media + * packet, error out. + */ + if (offset == -1) + pr_err("filter option unsupported on media"); + + switch (len) { + case 1: + pf_emit(ENF_PUSHWORD + offset / 2); +#if defined(_BIG_ENDIAN) + if (offset % 2) +#else + if (!offset % 2) +#endif + { + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(mask & 0x00ff); + pf_emit(ENF_PUSHLIT | op); + pf_emit(val); + } else { + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit((mask << 8) & 0xff00); + pf_emit(ENF_PUSHLIT | op); + pf_emit(val << 8); + } + break; + + case 2: + pf_emit(ENF_PUSHWORD + offset / 2); + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(htons((ushort_t)mask)); + pf_emit(ENF_PUSHLIT | op); + pf_emit(htons((ushort_t)val)); + break; + + case 4: + pf_emit(ENF_PUSHWORD + offset / 2); + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(htons((ushort_t)((mask >> 16) & 0xffff))); + pf_emit(ENF_PUSHLIT | op); + pf_emit(htons((ushort_t)((val >> 16) & 0xffff))); + + pf_emit(ENF_PUSHWORD + (offset / 2) + 1); + pf_emit(ENF_PUSHLIT | ENF_AND); + pf_emit(htons((ushort_t)(mask & 0xffff))); + pf_emit(ENF_PUSHLIT | op); + pf_emit(htons((ushort_t)(val & 0xffff))); + + pf_emit(ENF_AND); + break; + } +} + +/* + * Like pf_compare_value() but compare on a 32-bit zoneid value. + * The argument val passed in is in network byte order. + */ +static void +pf_compare_zoneid(int offset, uint32_t val) +{ + int i; + + for (i = 0; i < sizeof (uint32_t) / 2; i ++) { + pf_emit(ENF_PUSHWORD + offset / 2 + i); + pf_emit(ENF_PUSHLIT | ENF_EQ); + pf_emit(((uint16_t *)&val)[i]); + if (i != 0) + pf_emit(ENF_AND); + } +} + +/* + * Generate pf code to match an IPv4 or IPv6 address. + */ +static void +pf_ipaddr_match(which, hostname, inet_type) + enum direction which; + char *hostname; + int inet_type; +{ + bool_t found_host; + uint_t *addr4ptr; + uint_t addr4; + struct in6_addr *addr6ptr; + int h_addr_index; + struct hostent *hp = NULL; + int error_num = 0; + boolean_t first = B_TRUE; + int pass = 0; + int i; + + /* + * The addr4offset and addr6offset variables simplify the code which + * generates the address comparison filter. With these two variables, + * duplicate code need not exist for the TO and FROM case. + * A value of -1 describes the ANY case (TO and FROM). + */ + int addr4offset; + int addr6offset; + + found_host = 0; + + if (tokentype == ADDR_IP) { + hp = getipnodebyname(hostname, AF_INET, 0, &error_num); + if (hp == NULL) { + if (error_num == TRY_AGAIN) { + pr_err("could not resolve %s (try again later)", + hostname); + } else { + pr_err("could not resolve %s", hostname); + } + } + inet_type = IPV4_ONLY; + } else if (tokentype == ADDR_IP6) { + hp = getipnodebyname(hostname, AF_INET6, 0, &error_num); + if (hp == NULL) { + if (error_num == TRY_AGAIN) { + pr_err("could not resolve %s (try again later)", + hostname); + } else { + pr_err("could not resolve %s", hostname); + } + } + inet_type = IPV6_ONLY; + } else if (tokentype == ALPHA) { + /* Some hostname i.e. tokentype is ALPHA */ + switch (inet_type) { + case IPV4_ONLY: + /* Only IPv4 address is needed */ + hp = getipnodebyname(hostname, AF_INET, 0, &error_num); + if (hp != NULL) { + found_host = 1; + } + break; + case IPV6_ONLY: + /* Only IPv6 address is needed */ + hp = getipnodebyname(hostname, AF_INET6, 0, &error_num); + if (hp != NULL) { + found_host = 1; + } + break; + case IPV4_AND_IPV6: + /* Both IPv4 and IPv6 are needed */ + hp = getipnodebyname(hostname, AF_INET6, + AI_ALL | AI_V4MAPPED, &error_num); + if (hp != NULL) { + found_host = 1; + } + break; + default: + found_host = 0; + } + + if (!found_host) { + if (error_num == TRY_AGAIN) { + pr_err("could not resolve %s (try again later)", + hostname); + } else { + pr_err("could not resolve %s", hostname); + } + } + } else { + pr_err("unknown token type: %s", hostname); + } + + if (hp == NULL) + return; + + switch (which) { + case TO: + addr4offset = IPV4_DSTADDR_OFFSET; + addr6offset = IPV6_DSTADDR_OFFSET; + break; + case FROM: + addr4offset = IPV4_SRCADDR_OFFSET; + addr6offset = IPV6_SRCADDR_OFFSET; + break; + case ANY: + addr4offset = -1; + addr6offset = -1; + break; + } + + if (hp->h_addrtype == AF_INET) { + pf_matchfn("ip"); + if (dl.dl_type == DL_ETHER) + pf_check_vlan_tag(ENCAP_ETHERTYPE_OFF/2); + h_addr_index = 0; + addr4ptr = (uint_t *)hp->h_addr_list[h_addr_index]; + while (addr4ptr != NULL) { + if (addr4offset == -1) { + pf_compare_value(IPV4_SRCADDR_OFFSET, 4, + *addr4ptr); + if (h_addr_index != 0) + pf_emit(ENF_OR); + pf_compare_value(IPV4_DSTADDR_OFFSET, 4, + *addr4ptr); + pf_emit(ENF_OR); + } else { + pf_compare_value(addr4offset, 4, + *addr4ptr); + if (h_addr_index != 0) + pf_emit(ENF_OR); + } + addr4ptr = (uint_t *)hp->h_addr_list[++h_addr_index]; + } + pf_emit(ENF_AND); + } else { + /* first pass: IPv4 addresses */ + h_addr_index = 0; + addr6ptr = (struct in6_addr *)hp->h_addr_list[h_addr_index]; + first = B_TRUE; + while (addr6ptr != NULL) { + if (IN6_IS_ADDR_V4MAPPED(addr6ptr)) { + if (first) { + pf_matchfn("ip"); + if (dl.dl_type == DL_ETHER) { + pf_check_vlan_tag( + ENCAP_ETHERTYPE_OFF/2); + } + pass++; + } + IN6_V4MAPPED_TO_INADDR(addr6ptr, + (struct in_addr *)&addr4); + if (addr4offset == -1) { + pf_compare_value(IPV4_SRCADDR_OFFSET, 4, + addr4); + if (!first) + pf_emit(ENF_OR); + pf_compare_value(IPV4_DSTADDR_OFFSET, 4, + addr4); + pf_emit(ENF_OR); + } else { + pf_compare_value(addr4offset, 4, + addr4); + if (!first) + pf_emit(ENF_OR); + } + if (first) + first = B_FALSE; + } + addr6ptr = (struct in6_addr *) + hp->h_addr_list[++h_addr_index]; + } + if (!first) { + pf_emit(ENF_AND); + } + /* second pass: IPv6 addresses */ + h_addr_index = 0; + addr6ptr = (struct in6_addr *)hp->h_addr_list[h_addr_index]; + first = B_TRUE; + while (addr6ptr != NULL) { + if (!IN6_IS_ADDR_V4MAPPED(addr6ptr)) { + if (first) { + pf_matchfn("ip6"); + if (dl.dl_type == DL_ETHER) { + pf_check_vlan_tag( + ENCAP_ETHERTYPE_OFF/2); + } + pass++; + } + if (addr6offset == -1) { + pf_compare_value_v6(IPV6_SRCADDR_OFFSET, + 16, *addr6ptr); + if (!first) + pf_emit(ENF_OR); + pf_compare_value_v6(IPV6_DSTADDR_OFFSET, + 16, *addr6ptr); + pf_emit(ENF_OR); + } else { + pf_compare_value_v6(addr6offset, 16, + *addr6ptr); + if (!first) + pf_emit(ENF_OR); + } + if (first) + first = B_FALSE; + } + addr6ptr = (struct in6_addr *) + hp->h_addr_list[++h_addr_index]; + } + if (!first) { + pf_emit(ENF_AND); + } + if (pass == 2) { + pf_emit(ENF_OR); + } + } + + freehostent(hp); +} + + +static void +pf_compare_address(int offset, uint_t len, uchar_t *addr) +{ + uint32_t val; + uint16_t sval; + boolean_t didone = B_FALSE; + + /* + * If the property being filtered on is absent in the media + * packet, error out. + */ + if (offset == -1) + pr_err("filter option unsupported on media"); + + while (len > 0) { + if (len >= 4) { + (void) memcpy(&val, addr, 4); + pf_compare_value(offset, 4, val); + addr += 4; + offset += 4; + len -= 4; + } else if (len >= 2) { + (void) memcpy(&sval, addr, 2); + pf_compare_value(offset, 2, sval); + addr += 2; + offset += 2; + len -= 2; + } else { + pf_compare_value(offset++, 1, *addr++); + len--; + } + if (didone) + pf_emit(ENF_AND); + didone = B_TRUE; + } +} + +/* + * Compare ethernet addresses. + */ +static void +pf_etheraddr_match(which, hostname) + enum direction which; + char *hostname; +{ + struct ether_addr e, *ep = NULL; + + if (isxdigit(*hostname)) + ep = ether_aton(hostname); + if (ep == NULL) { + if (ether_hostton(hostname, &e)) + if (!arp_for_ether(hostname, &e)) + pr_err("cannot obtain ether addr for %s", + hostname); + ep = &e; + } + + pf_clear_offset_register(); + + switch (which) { + case TO: + pf_compare_address(dl.dl_link_dest_offset, dl.dl_link_addr_len, + (uchar_t *)ep); + break; + case FROM: + pf_compare_address(dl.dl_link_src_offset, dl.dl_link_addr_len, + (uchar_t *)ep); + break; + case ANY: + pf_compare_address(dl.dl_link_dest_offset, dl.dl_link_addr_len, + (uchar_t *)ep); + pf_compare_address(dl.dl_link_src_offset, dl.dl_link_addr_len, + (uchar_t *)ep); + pf_emit(ENF_OR); + break; + } +} + +/* + * Emit code to compare the network part of + * an IP address. + */ +static void +pf_netaddr_match(which, netname) + enum direction which; + char *netname; +{ + uint_t addr; + uint_t mask = 0xff000000; + struct netent *np; + + if (isdigit(*netname)) { + addr = inet_network(netname); + } else { + np = getnetbyname(netname); + if (np == NULL) + pr_err("net %s not known", netname); + addr = np->n_net; + } + + /* + * Left justify the address and figure + * out a mask based on the supplied address. + * Set the mask according to the number of zero + * low-order bytes. + * Note: this works only for whole octet masks. + */ + if (addr) { + while ((addr & ~mask) != 0) { + mask |= (mask >> 8); + } + } + + pf_check_vlan_tag(ENCAP_ETHERTYPE_OFF/2); + + switch (which) { + case TO: + pf_compare_value_mask(IPV4_DSTADDR_OFFSET, 4, addr, mask); + break; + case FROM: + pf_compare_value_mask(IPV4_SRCADDR_OFFSET, 4, addr, mask); + break; + case ANY: + pf_compare_value_mask(IPV4_SRCADDR_OFFSET, 4, addr, mask); + pf_compare_value_mask(IPV4_DSTADDR_OFFSET, 4, addr, mask); + pf_emit(ENF_OR); + break; + } +} + +/* + * Emit code to match on src or destination zoneid. + * The zoneid passed in is in network byte order. + */ +static void +pf_match_zone(enum direction which, uint32_t zoneid) +{ + if (dl.dl_type != DL_IPNET) + pr_err("zone filter option unsupported on media"); + + switch (which) { + case TO: + pf_compare_zoneid(IPNET_DSTZONE_OFFSET, zoneid); + break; + case FROM: + pf_compare_zoneid(IPNET_SRCZONE_OFFSET, zoneid); + break; + case ANY: + pf_compare_zoneid(IPNET_SRCZONE_OFFSET, zoneid); + pf_compare_zoneid(IPNET_DSTZONE_OFFSET, zoneid); + pf_emit(ENF_OR); + break; + } +} + +/* + * A helper function to keep the code to emit instructions + * to change the offset register in one place. + * + * INPUTS: offset - An value representing an offset in 16-bit + * words. + * OUTPUTS: If there is enough room in the storage for the + * packet filtering program, instructions to load + * a constant to the offset register. Otherwise, + * nothing. + */ +static void +pf_emit_load_offset(uint_t offset) +{ + pf_emit(ENF_LOAD_OFFSET | ENF_NOP); + pf_emit(offset); +} + +/* + * Clear pfmod's offset register. + * + * INPUTS: none + * OUTPUTS: Instructions to clear the offset register if + * there is enough space remaining in the packet + * filtering program structure's storage, and + * the last thing done to the offset register was + * not clearing the offset register. Otherwise, + * nothing. + */ +static void +pf_clear_offset_register() +{ + if (last_offset_operation != (void*)pf_clear_offset_register) { + pf_emit_load_offset(0); + last_offset_operation = (void*)pf_clear_offset_register; + } +} + +/* + * This function will issue opcodes to check if a packet + * is VLAN tagged, and if so, update the offset register + * with the appropriate offset. + * + * Note that if the packet is not VLAN tagged, then the offset + * register will be cleared. + * + * If the interface type is not an ethernet type, then this + * function returns without doing anything. + * + * If the last attempt to change the offset register occured because + * of a call to this function that was called with the same offset, + * then we don't issue packet filtering instructions. + * + * INPUTS: offset - an offset in 16 bit words. The function + * will set the offset register to this + * value if the packet is VLAN tagged. + * OUTPUTS: If the conditions are met, packet filtering instructions. + */ +static void +pf_check_vlan_tag(uint_t offset) +{ + static uint_t last_offset = 0; + + if ((interface->mac_type == DL_ETHER || + interface->mac_type == DL_CSMACD) && + (last_offset_operation != (void*)pf_check_vlan_tag || + last_offset != offset)) { + /* + * First thing is to clear the offset register. + * We don't know what state it is in, and if it + * is not zero, then we have no idea what we load + * when we execute ENF_PUSHWORD. + */ + pf_clear_offset_register(); + + /* + * Check the ethertype. + */ + pf_compare_value(dl.dl_link_type_offset, 2, + htons(ETHERTYPE_VLAN)); + + /* + * And if it's not VLAN, don't load offset to the offset + * register. + */ + pf_emit(ENF_BRFL | ENF_NOP); + pf_emit(3); + + /* + * Otherwise, load offset to the offset register. + */ + pf_emit_load_offset(offset); + + /* + * Now get rid of the results of the comparison, + * we don't want the results of the comparison to affect + * other logic in the packet filtering program. + */ + pf_emit(ENF_POP | ENF_NOP); + + /* + * Set the last operation at the end, or any time + * after the call to pf_clear_offset because + * pf_clear_offset uses it. + */ + last_offset_operation = (void*)pf_check_vlan_tag; + last_offset = offset; + } +} + +/* + * Utility function used to emit packet filtering code + * to match an ethertype. + * + * INPUTS: ethertype - The ethertype we want to check for. + * Don't call htons on the ethertype before + * calling this function. + * OUTPUTS: If there is sufficient storage available, packet + * filtering code to check an ethertype. Otherwise, + * nothing. + */ +static void +pf_match_ethertype(uint_t ethertype) +{ + /* + * If the user wants to filter on ethertype VLAN, + * then clear the offset register so that the offset + * for ENF_PUSHWORD points to the right place in the + * packet. + * + * Otherwise, call pf_check_vlan_tag to set the offset + * register such that the contents of the offset register + * plus the argument for ENF_PUSHWORD point to the right + * part of the packet, whether or not the packet is VLAN + * tagged. We call pf_check_vlan_tag with an offset of + * two words because if the packet is VLAN tagged, we have + * to move past the ethertype in the ethernet header, and + * past the lower two octets of the VLAN header to get to + * the ethertype in the VLAN header. + */ + if (ethertype == ETHERTYPE_VLAN) + pf_clear_offset_register(); + else + pf_check_vlan_tag(2); + + pf_compare_value(dl.dl_link_type_offset, 2, htons(ethertype)); +} + +static void +pf_match_ipnettype(uint_t type) +{ + pf_compare_value(dl.dl_link_type_offset, 2, htons(type)); +} + +static void +pf_match_ibtype(uint_t type) +{ + pf_compare_value(dl.dl_link_type_offset, 2, htons(type)); +} + +/* + * This function uses the table above to generate a + * piece of a packet filtering program to check a transport + * protocol type. + * + * INPUTS: tranport_protocol - the transport protocol we're + * interested in. + * OUTPUTS: If there is sufficient storage, then packet filtering + * code to check a transport protocol type. Otherwise, + * nothing. + */ +static void +pf_check_transport_protocol(uint_t transport_protocol) +{ + int i; + uint_t number_of_matches = 0; + + for (i = 0; dl.dl_trans_map_tbl[i].transport_protocol != -1; i++) { + if (transport_protocol == + (uint_t)dl.dl_trans_map_tbl[i].transport_protocol) { + number_of_matches++; + dl.dl_match_fn(dl.dl_trans_map_tbl[i].network_protocol); + pf_check_vlan_tag(ENCAP_ETHERTYPE_OFF/2); + pf_compare_value(dl.dl_trans_map_tbl[i].offset + + dl.dl_link_header_len, 1, + transport_protocol); + pf_emit(ENF_AND); + if (number_of_matches > 1) { + /* + * Since we have two or more matches, in + * order to have a correct and complete + * program we need to OR the result of + * each block of comparisons together. + */ + pf_emit(ENF_OR); + } + } + } +} + +static void +pf_matchfn(const char *proto) +{ + int i; + + for (i = 0; dl.dl_net_map_tbl[i].nmt_val != -1; i++) { + if (strcmp(proto, dl.dl_net_map_tbl[i].nmt_name) == 0) { + dl.dl_match_fn(dl.dl_net_map_tbl[i].nmt_val); + break; + } + } +} + +static void +pf_primary() +{ + for (;;) { + if (tokentype == FIELD) + break; + + if (EQ("ip")) { + pf_matchfn("ip"); + opstack++; + next(); + break; + } + + if (EQ("ip6")) { + pf_matchfn("ip6"); + opstack++; + next(); + break; + } + + if (EQ("pppoe")) { + pf_matchfn("pppoe"); + pf_match_ethertype(ETHERTYPE_PPPOES); + pf_emit(ENF_OR); + opstack++; + next(); + break; + } + + if (EQ("pppoed")) { + pf_matchfn("pppoed"); + opstack++; + next(); + break; + } + + if (EQ("pppoes")) { + pf_matchfn("pppoes"); + opstack++; + next(); + break; + } + + if (EQ("arp")) { + pf_matchfn("arp"); + opstack++; + next(); + break; + } + + if (EQ("vlan")) { + pf_matchfn("vlan"); + pf_compare_value_mask_neq(VLAN_ID_OFFSET, 2, + 0, VLAN_ID_MASK); + pf_emit(ENF_AND); + opstack++; + next(); + break; + } + + if (EQ("vlan-id")) { + next(); + if (tokentype != NUMBER) + pr_err("VLAN ID expected"); + pf_matchfn("vlan-id"); + pf_compare_value_mask(VLAN_ID_OFFSET, 2, tokenval, + VLAN_ID_MASK); + pf_emit(ENF_AND); + opstack++; + next(); + break; + } + + if (EQ("rarp")) { + pf_matchfn("rarp"); + opstack++; + next(); + break; + } + + if (EQ("tcp")) { + pf_check_transport_protocol(IPPROTO_TCP); + opstack++; + next(); + break; + } + + if (EQ("udp")) { + pf_check_transport_protocol(IPPROTO_UDP); + opstack++; + next(); + break; + } + + if (EQ("ospf")) { + pf_check_transport_protocol(IPPROTO_OSPF); + opstack++; + next(); + break; + } + + + if (EQ("sctp")) { + pf_check_transport_protocol(IPPROTO_SCTP); + opstack++; + next(); + break; + } + + if (EQ("icmp")) { + pf_check_transport_protocol(IPPROTO_ICMP); + opstack++; + next(); + break; + } + + if (EQ("icmp6")) { + pf_check_transport_protocol(IPPROTO_ICMPV6); + opstack++; + next(); + break; + } + + if (EQ("ip-in-ip")) { + pf_check_transport_protocol(IPPROTO_ENCAP); + opstack++; + next(); + break; + } + + if (EQ("esp")) { + pf_check_transport_protocol(IPPROTO_ESP); + opstack++; + next(); + break; + } + + if (EQ("ah")) { + pf_check_transport_protocol(IPPROTO_AH); + opstack++; + next(); + break; + } + + if (EQ("(")) { + inBrace++; + next(); + pf_expression(); + if (EQ(")")) { + if (inBrace) + inBraceOR--; + inBrace--; + next(); + } + break; + } + + if (EQ("to") || EQ("dst")) { + dir = TO; + next(); + continue; + } + + if (EQ("from") || EQ("src")) { + dir = FROM; + next(); + continue; + } + + if (EQ("ether")) { + eaddr = 1; + next(); + continue; + } + + if (EQ("inet")) { + next(); + if (EQ("host")) + next(); + if (tokentype != ALPHA && tokentype != ADDR_IP) + pr_err("host/IPv4 addr expected after inet"); + pf_ipaddr_match(dir, token, IPV4_ONLY); + opstack++; + next(); + break; + } + + if (EQ("inet6")) { + next(); + if (EQ("host")) + next(); + if (tokentype != ALPHA && tokentype != ADDR_IP6) + pr_err("host/IPv6 addr expected after inet6"); + pf_ipaddr_match(dir, token, IPV6_ONLY); + opstack++; + next(); + break; + } + + if (EQ("proto")) { + next(); + if (tokentype != NUMBER) + pr_err("IP proto type expected"); + pf_check_vlan_tag(ENCAP_ETHERTYPE_OFF/2); + pf_compare_value( + IPV4_TYPE_HEADER_OFFSET + dl.dl_link_header_len, 1, + tokenval); + opstack++; + next(); + break; + } + + if (EQ("broadcast")) { + pf_clear_offset_register(); + pf_compare_value(dl.dl_link_dest_offset, 4, 0xffffffff); + opstack++; + next(); + break; + } + + if (EQ("multicast")) { + pf_clear_offset_register(); + pf_compare_value_mask( + dl.dl_link_dest_offset, 1, 0x01, 0x01); + opstack++; + next(); + break; + } + + if (EQ("ethertype")) { + next(); + if (tokentype != NUMBER) + pr_err("ether type expected"); + pf_match_ethertype(tokenval); + opstack++; + next(); + break; + } + + if (EQ("net") || EQ("dstnet") || EQ("srcnet")) { + if (EQ("dstnet")) + dir = TO; + else if (EQ("srcnet")) + dir = FROM; + next(); + pf_netaddr_match(dir, token); + dir = ANY; + opstack++; + next(); + break; + } + + if (EQ("zone")) { + next(); + if (tokentype != NUMBER) + pr_err("zoneid expected after inet"); + pf_match_zone(dir, BE_32((uint32_t)(tokenval))); + opstack++; + next(); + break; + } + + /* + * Give up on anything that's obviously + * not a primary. + */ + if (EQ("and") || EQ("or") || + EQ("not") || EQ("decnet") || EQ("apple") || + EQ("length") || EQ("less") || EQ("greater") || + EQ("port") || EQ("srcport") || EQ("dstport") || + EQ("rpc") || EQ("gateway") || EQ("nofrag") || + EQ("bootp") || EQ("dhcp") || EQ("dhcp6") || + EQ("slp") || EQ("ldap")) { + break; + } + + if (EQ("host") || EQ("between") || + tokentype == ALPHA || /* assume its a hostname */ + tokentype == ADDR_IP || + tokentype == ADDR_IP6 || + tokentype == ADDR_ETHER) { + if (EQ("host") || EQ("between")) + next(); + if (eaddr || tokentype == ADDR_ETHER) { + pf_etheraddr_match(dir, token); + } else if (tokentype == ALPHA) { + pf_ipaddr_match(dir, token, IPV4_AND_IPV6); + } else if (tokentype == ADDR_IP) { + pf_ipaddr_match(dir, token, IPV4_ONLY); + } else { + pf_ipaddr_match(dir, token, IPV6_ONLY); + } + dir = ANY; + eaddr = 0; + opstack++; + next(); + break; + } + + break; /* unknown token */ + } +} + +static void +pf_alternation() +{ + int s = opstack; + + pf_primary(); + for (;;) { + if (EQ("and")) + next(); + pf_primary(); + if (opstack != s + 2) + break; + pf_emit(ENF_AND); + opstack--; + } +} + +static void +pf_expression() +{ + pf_alternation(); + while (EQ("or") || EQ(",")) { + if (inBrace) + inBraceOR++; + else + foundOR++; + next(); + pf_alternation(); + pf_emit(ENF_OR); + opstack--; + } +} + +/* + * Attempt to compile the expression + * in the string "e". If we can generate + * pf code for it then return 1 - otherwise + * return 0 and leave it up to the user-level + * filter. + */ +int +pf_compile(e, print) + char *e; + int print; +{ + char *argstr; + char *sav_str, *ptr, *sav_ptr; + int inBr = 0, aheadOR = 0; + + argstr = strdup(e); + sav_str = e; + tkp = argstr; + dir = ANY; + + pfp = &pf.Pf_Filter[0]; + if (setjmp(env)) { + return (0); + } + + /* + * Set media specific packet offsets that this code uses. + */ + if (interface->mac_type == DL_ETHER) { + dl.dl_type = DL_ETHER; + dl.dl_match_fn = pf_match_ethertype; + dl.dl_trans_map_tbl = ether_transport_mapping_table; + dl.dl_net_map_tbl = ether_network_mapping_table; + dl.dl_link_header_len = 14; + dl.dl_link_type_offset = 12; + dl.dl_link_dest_offset = 0; + dl.dl_link_src_offset = 6; + dl.dl_link_addr_len = 6; + } + + if (interface->mac_type == DL_IB) { + dl.dl_type = DL_IB; + dl.dl_link_header_len = 4; + dl.dl_link_type_offset = 0; + dl.dl_link_dest_offset = dl.dl_link_src_offset = -1; + dl.dl_link_addr_len = 20; + dl.dl_match_fn = pf_match_ibtype; + dl.dl_trans_map_tbl = ib_transport_mapping_table; + dl.dl_net_map_tbl = ib_network_mapping_table; + } + + if (interface->mac_type == DL_IPNET) { + dl.dl_type = DL_IPNET; + dl.dl_link_header_len = 24; + dl.dl_link_type_offset = 0; + dl.dl_link_dest_offset = dl.dl_link_src_offset = -1; + dl.dl_link_addr_len = -1; + dl.dl_match_fn = pf_match_ipnettype; + dl.dl_trans_map_tbl = ipnet_transport_mapping_table; + dl.dl_net_map_tbl = ipnet_network_mapping_table; + } + + next(); + pf_expression(); + + if (tokentype != EOL) { + /* + * The idea here is to do as much filtering as possible in + * the kernel. So even if we find a token we don't understand, + * we try to see if we can still set up a portion of the filter + * in the kernel and use the userland filter to filter the + * remaining stuff. Obviously, if our filter expression is of + * type A AND B, we can filter A in kernel and then apply B + * to the packets that got through. The same is not true for + * a filter of type A OR B. We can't apply A first and then B + * on the packets filtered through A. + * + * (We need to keep track of the fact when we find an OR, + * and the fact that we are inside brackets when we find OR. + * The variable 'foundOR' tells us if there was an OR behind, + * 'inBraceOR' tells us if we found an OR before we could find + * the end brace i.e. ')', and variable 'aheadOR' checks if + * there is an OR in the expression ahead. if either of these + * cases become true, we can't split the filtering) + */ + + if (foundOR || inBraceOR) { + /* FORGET IN KERNEL FILTERING */ + return (0); + } else { + + /* CHECK IF NO OR AHEAD */ + sav_ptr = (char *)((uintptr_t)sav_str + + (uintptr_t)sav_tkp - + (uintptr_t)argstr); + ptr = sav_ptr; + while (*ptr != '\0') { + switch (*ptr) { + case '(': + inBr++; + break; + case ')': + inBr--; + break; + case 'o': + case 'O': + if ((*(ptr + 1) == 'R' || + *(ptr + 1) == 'r') && !inBr) + aheadOR = 1; + break; + case ',': + if (!inBr) + aheadOR = 1; + break; + } + ptr++; + } + if (!aheadOR) { + /* NO OR AHEAD, SPLIT UP THE FILTERING */ + pf.Pf_FilterLen = pfp - &pf.Pf_Filter[0]; + pf.Pf_Priority = 5; + if (print) { + pf_codeprint(&pf.Pf_Filter[0], + pf.Pf_FilterLen); + } + compile(sav_ptr, print); + return (2); + } else + return (0); + } + } + + pf.Pf_FilterLen = pfp - &pf.Pf_Filter[0]; + pf.Pf_Priority = 5; /* unimportant, so long as > 2 */ + if (print) { + pf_codeprint(&pf.Pf_Filter[0], pf.Pf_FilterLen); + } + return (1); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pmap.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pmap.c new file mode 100644 index 0000000..f31fb4c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pmap.c @@ -0,0 +1,772 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ +/* + * Copyright 2014 Nexenta Systems, Inc. All rights reserved. + */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <sys/tiuser.h> +#include <string.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpc/pmap_prot.h> +#include "snoop.h" + +/* + * Number of bytes to display from a string (address, netid, etc.). + */ +#define MAXSTRINGLEN 64 + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static void interpret_pmap_2(int, int, int, int, int, char *, int); +static void interpret_pmap_4(int, int, int, int, int, char *, int); +static void stash_callit(ulong_t, int, int, int, int); + +void +interpret_pmap(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + switch (vers) { + case 2: interpret_pmap_2(flags, type, xid, vers, proc, data, len); + break; + + /* Version 3 is a subset of version 4 */ + case 3: + case 4: interpret_pmap_4(flags, type, xid, vers, proc, data, len); + break; + } +} + +void show_pmap(); +char *sum_pmaplist(); +void show_pmaplist(); + +static char *procnames_short_2[] = { + "Null", /* 0 */ + "SET", /* 1 */ + "UNSET", /* 2 */ + "GETPORT", /* 3 */ + "DUMP", /* 4 */ + "CALLIT", /* 5 */ +}; + +static char *procnames_long_2[] = { + "Null procedure", /* 0 */ + "Set port", /* 1 */ + "Unset port", /* 2 */ + "Get port number", /* 3 */ + "Dump the mappings", /* 4 */ + "Indirect call", /* 5 */ +}; + +#define MAXPROC_2 5 + +void +interpret_pmap_2(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + unsigned port, proto; + unsigned iprog, ivers, iproc, ilen; + extern int pi_frame; + struct cache_struct *x, *find_callit(); + int trailer_done = 0; + + if (proc < 0 || proc > MAXPROC_2) + return; + + if (proc == PMAPPROC_CALLIT) { + if (type == CALL) { + iprog = getxdr_u_long(); + ivers = getxdr_u_long(); + iproc = getxdr_u_long(); + stash_callit(xid, pi_frame, iprog, ivers, iproc); + } else { + x = find_callit(xid); + } + } + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, "PORTMAP C %s", + procnames_short_2[proc]); + line += strlen(line); + switch (proc) { + case PMAPPROC_GETPORT: + iprog = getxdr_u_long(); + ivers = getxdr_u_long(); + proto = getxdr_u_long(); + (void) sprintf(line, + " prog=%d (%s) vers=%d proto=%s", + iprog, nameof_prog(iprog), + ivers, + getproto(proto)); + break; + case PMAPPROC_CALLIT: + (void) sprintf(line, + " prog=%s vers=%d proc=%d", + nameof_prog(iprog), + ivers, iproc); + if (flags & F_ALLSUM) { + (void) getxdr_u_long(); /* length */ + data += 16; /* prog+ver+proc+len */ + len -= 16; + protoprint(flags, type, xid, + iprog, ivers, iproc, + data, len); + } + break; + default: + break; + } + check_retransmit(line, xid); + } else { + (void) sprintf(line, "PORTMAP R %s ", + procnames_short_2[proc]); + line += strlen(line); + switch (proc) { + case PMAPPROC_GETPORT: + port = getxdr_u_long(); + (void) sprintf(line, "port=%d", port); + break; + case PMAPPROC_DUMP: + (void) sprintf(line, "%s", sum_pmaplist()); + break; + case PMAPPROC_CALLIT: + port = getxdr_u_long(); + ilen = getxdr_u_long(); + (void) sprintf(line, "port=%d len=%d", + port, ilen); + if (flags & F_ALLSUM && x != NULL) { + data += 8; /* port+len */ + len -= 8; + protoprint(flags, type, xid, + x->xid_prog, + x->xid_vers, + x->xid_proc, + data, len); + } + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("PMAP: ", "Portmapper", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long_2[proc]); + if (type == CALL) { + switch (proc) { + case PMAPPROC_NULL: + case PMAPPROC_SET: + case PMAPPROC_UNSET: + break; + case PMAPPROC_GETPORT: + iprog = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Program = %d (%s)", + iprog, nameof_prog(iprog)); + (void) showxdr_u_long("Version = %d"); + proto = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Protocol = %d (%s)", + proto, getproto(proto)); + break; + case PMAPPROC_DUMP: + break; + case PMAPPROC_CALLIT: + (void) sprintf(get_line(0, 0), + "Program = %d (%s)", + iprog, nameof_prog(iprog)); + (void) sprintf(get_line(0, 0), + "Version = %d", ivers); + (void) sprintf(get_line(0, 0), + "Proc = %d", iproc); + (void) showxdr_u_long("Callit data = %d bytes"); + show_trailer(); + trailer_done = 1; + data += 16; /* prog+ver+proc+len */ + len -= 16; + protoprint(flags, type, xid, + iprog, ivers, iproc, + data, len); + break; + } + } else { + switch (proc) { + case PMAPPROC_NULL: + case PMAPPROC_SET: + case PMAPPROC_UNSET: + break; + case PMAPPROC_GETPORT: + (void) showxdr_u_long("Port = %d"); + break; + case PMAPPROC_DUMP: + show_pmaplist(); + break; + case PMAPPROC_CALLIT: + (void) showxdr_u_long("Port = %d"); + (void) showxdr_u_long("Length = %d bytes"); + show_trailer(); + trailer_done = 1; + if (x != NULL) { + protoprint(flags, type, xid, + x->xid_prog, + x->xid_vers, + x->xid_proc, + data, len); + } + break; + } + } + if (!trailer_done) + show_trailer(); + } +} + +char * +sum_pmaplist() +{ + int maps = 0; + static char buff[16]; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ map(s) found", maps); + return (buff); + } + + while (getxdr_u_long()) { + (void) getxdr_u_long(); /* program */ + (void) getxdr_u_long(); /* version */ + (void) getxdr_u_long(); /* protocol */ + (void) getxdr_u_long(); /* port */ + maps++; + } + + (void) sprintf(buff, "%d map(s) found", maps); + return (buff); +} + +void +show_pmaplist() +{ + unsigned prog, vers, proto, port; + int maps = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ maps. (Frame is incomplete)", + maps); + return; + } + + (void) sprintf(get_line(0, 0), " Program Version Protocol Port"); + + while (getxdr_u_long()) { + prog = getxdr_u_long(); + vers = getxdr_u_long(); + proto = getxdr_u_long(); + port = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "%8d%8d%9d%7d %s", + prog, vers, proto, port, nameof_prog(prog)); + maps++; + } + + (void) sprintf(get_line(0, 0), " %d maps", maps); +} + +/* + * ****************************************** + */ +char *sum_rpcblist(); +void show_rpcblist(); +char *sum_rpcb_entry_list(); +void show_rpcb_entry_list(); + +static char *procnames_short_4[] = { + /* + * version 3 and 4 procs + */ + "Null", /* 0 */ + "SET", /* 1 */ + "UNSET", /* 2 */ + "GETADDR", /* 3 */ + "DUMP", /* 4 */ + "BCAST", /* 5 */ + "GETTIME", /* 6 */ + "UADDR2TADDR", /* 7 */ + "TADDR2UADDR", /* 8 */ + /* + * version 4 procs only + */ + "GETVERSADDR", /* 9 */ + "INDIRECT", /* 10 */ + "GETADDRLIST", /* 11 */ + "GETSTAT", /* 12 */ +}; + +static char *procnames_long_4[] = { + /* + * version 3 and 4 procs + */ + "Null procedure", /* 0 */ + "Set address", /* 1 */ + "Unset address", /* 2 */ + "Get address", /* 3 */ + "Dump the mappings", /* 4 */ + "Broadcast call (no error)", /* 5 */ + "Get the time", /* 6 */ + "Universal to transport address", /* 7 */ + "Transport to universal address", /* 8 */ + /* + * version 4 procs only + */ + "Get address of specific version", /* 9 */ + "Indirect call (return error)", /* 10 */ + "Return addresses of prog/vers", /* 11 */ + "Get statistics", /* 12 */ +}; + +#define MAXPROC_3 8 +#define MAXPROC_4 12 +#define RPCBPROC_NULL 0 + +void +interpret_pmap_4(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + unsigned prog, ver; + char buff1[MAXSTRINGLEN + 1]; + int iprog, ivers, iproc, ilen; + extern int pi_frame; + struct cache_struct *x, *find_callit(); + int trailer_done = 0; + + if (proc < 0 || proc > MAXPROC_4 || (vers == 3 && proc > MAXPROC_3)) + return; + + if (proc == RPCBPROC_BCAST || proc == RPCBPROC_INDIRECT) { + if (type == CALL) { + iprog = getxdr_u_long(); + ivers = getxdr_u_long(); + iproc = getxdr_u_long(); + stash_callit(xid, pi_frame, + iprog, ivers, iproc); + } else { + x = find_callit(xid); + } + } + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "RPCBIND C %s", + procnames_short_4[proc]); + line += strlen(line); + switch (proc) { + case RPCBPROC_SET: + case RPCBPROC_UNSET: + case RPCBPROC_GETADDR: + case RPCBPROC_GETVERSADDR: + case RPCBPROC_GETADDRLIST: + prog = getxdr_u_long(); + ver = getxdr_u_long(); + (void) sprintf(line, + " prog=%d (%s) vers=%d", + prog, nameof_prog(prog), + ver); + break; + case RPCBPROC_BCAST: + case RPCBPROC_INDIRECT: + (void) sprintf(line, + " prog=%s vers=%d proc=%d", + nameof_prog(iprog), + ivers, iproc); + if (flags & F_ALLSUM) { + (void) getxdr_u_long(); /* length */ + data += 16; /* prog+ver+proc+len */ + len -= 16; + protoprint(flags, type, xid, + iprog, ivers, iproc, + data, len); + } + break; + default: + break; + } + + check_retransmit(line, xid); + } else { + int pos; + + (void) sprintf(line, "RPCBIND R %s ", + procnames_short_4[proc]); + line += strlen(line); + switch (proc) { + case RPCBPROC_GETADDR: + case RPCBPROC_TADDR2UADDR: + case RPCBPROC_GETVERSADDR: + (void) getxdr_string(buff1, MAXSTRINGLEN); + (void) sprintf(line, + " Uaddr=%s", + buff1); + break; + case RPCBPROC_BCAST: + case RPCBPROC_INDIRECT: + pos = getxdr_pos(); + (void) getxdr_string(buff1, MAXSTRINGLEN); + ilen = getxdr_u_long(); + (void) sprintf(line, "Uaddr=%s len=%d", + buff1, ilen); + if (flags & F_ALLSUM && x != NULL) { + pos = getxdr_pos() - pos; + data += pos; /* uaddr+len */ + len -= pos; + protoprint(flags, type, xid, + x->xid_prog, + x->xid_vers, + x->xid_proc, + data, len); + } + break; + case RPCBPROC_DUMP: + (void) sprintf(line, "%s", + sum_rpcblist()); + break; + case RPCBPROC_GETTIME: + { + time_t sec = getxdr_long(); + struct tm *tmp = gmtime(&sec); + (void) strftime(line, MAXLINE, + "%d-%h-%y %T GMT", tmp); + } + break; + case RPCBPROC_GETADDRLIST: + (void) sprintf(line, "%s", + sum_rpcb_entry_list()); + break; + default: + break; + } + } + } + + if (flags & F_DTAIL) { + show_header("RPCB: ", "RPC Bind", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long_4[proc]); + if (type == CALL) { + switch (proc) { + case RPCBPROC_NULL: + break; + case RPCBPROC_SET: + case RPCBPROC_UNSET: + case RPCBPROC_GETADDR: + case RPCBPROC_GETVERSADDR: + case RPCBPROC_GETADDRLIST: + (void) showxdr_u_long("Program = %d"); + (void) showxdr_u_long("Version = %d"); + (void) showxdr_string(64, "Netid = %s"); + break; + case RPCBPROC_DUMP: + break; + case RPCBPROC_BCAST: + case RPCBPROC_INDIRECT: + (void) sprintf(get_line(0, 0), + "Program = %d (%s)", + iprog, nameof_prog(iprog)); + (void) sprintf(get_line(0, 0), + "Version = %d", ivers); + (void) sprintf(get_line(0, 0), + "Proc = %d", iproc); + (void) showxdr_u_long( + "Callit data = %d bytes"); + show_trailer(); + trailer_done = 1; + data += 16; /* prog+ver+proc+len */ + len -= 16; + protoprint(flags, type, xid, + iprog, ivers, iproc, + data, len); + break; + case RPCBPROC_GETTIME: + break; + case RPCBPROC_UADDR2TADDR: + case RPCBPROC_TADDR2UADDR: + break; + } + } else { + switch (proc) { + case RPCBPROC_NULL: + case RPCBPROC_SET: + case RPCBPROC_UNSET: + break; + case RPCBPROC_GETADDR: + case RPCBPROC_TADDR2UADDR: + case RPCBPROC_GETVERSADDR: + (void) showxdr_string(64, "Uaddr = %s"); + break; + case RPCBPROC_DUMP: + show_rpcblist(); + break; + case RPCBPROC_BCAST: + case RPCBPROC_INDIRECT: + (void) showxdr_string(64, "Uaddr = %s"); + (void) showxdr_u_long("Length = %d bytes"); + show_trailer(); + trailer_done = 1; + if (x != NULL) { + protoprint(flags, type, xid, + x->xid_prog, + x->xid_vers, + x->xid_proc, + data, len); + } + break; + case RPCBPROC_GETTIME: + { + int pos = getxdr_pos(); + time_t sec = getxdr_long(); + struct tm *tmp = gmtime(&sec); + (void) strftime(get_line(pos, + getxdr_pos()), MAXLINE, + "Time = %d-%h-%y %T GMT", tmp); + } + break; + case RPCBPROC_UADDR2TADDR: + break; + case RPCBPROC_GETADDRLIST: + show_rpcb_entry_list(); + break; + } + } + if (!trailer_done) + show_trailer(); + } +} + +char * +sum_rpcblist() +{ + int maps = 0; + static char buff[MAXSTRINGLEN + 1]; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ map(s) found", maps); + return (buff); + } + + while (getxdr_u_long()) { + (void) getxdr_u_long(); /* program */ + (void) getxdr_u_long(); /* version */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* netid */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* uaddr */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* owner */ + maps++; + } + + (void) sprintf(buff, "%d map(s) found", maps); + return (buff); +} + +void +show_rpcblist() +{ + unsigned prog, vers; + char netid[MAXSTRINGLEN + 1], uaddr[MAXSTRINGLEN + 1]; + char owner[MAXSTRINGLEN + 1]; + int maps = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ maps. (Frame is incomplete)", + maps); + return; + } + + show_space(); + (void) sprintf(get_line(0, 0), + " Program Vers Netid Uaddr Owner"); + + while (getxdr_u_long()) { + prog = getxdr_u_long(); + vers = getxdr_u_long(); + (void) getxdr_string(netid, MAXSTRINGLEN); + (void) getxdr_string(uaddr, MAXSTRINGLEN); + (void) getxdr_string(owner, MAXSTRINGLEN); + (void) sprintf(get_line(0, 0), + "%8d%5d %-12s %-18s %-10s (%s)", + prog, vers, + netid, uaddr, owner, + nameof_prog(prog)); + maps++; + } + + (void) sprintf(get_line(0, 0), " (%d maps)", maps); +} + +char * +sum_rpcb_entry_list() +{ + int maps = 0; + static char buff[MAXSTRINGLEN + 1]; + + if (setjmp(xdr_err)) { + (void) sprintf(buff, "%d+ map(s) found", maps); + return (buff); + } + + while (getxdr_u_long()) { + (void) getxdr_string(buff, MAXSTRINGLEN); /* maddr */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* nc_netid */ + (void) getxdr_u_long(); /* nc_semantics */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* nc_protofmly */ + (void) getxdr_string(buff, MAXSTRINGLEN); /* nc_proto */ + maps++; + } + + (void) sprintf(buff, "%d map(s) found", maps); + return (buff); +} + +char *semantics_strs[] = {"", "CLTS", "COTS", "COTS-ORD", "RAW"}; + +void +show_rpcb_entry_list() +{ + char maddr[MAXSTRINGLEN + 1], netid[MAXSTRINGLEN + 1]; + char protofmly[MAXSTRINGLEN + 1], proto[MAXSTRINGLEN + 1]; + unsigned sem; + int maps = 0; + + if (setjmp(xdr_err)) { + (void) sprintf(get_line(0, 0), + " %d+ maps. (Frame is incomplete)", + maps); + return; + } + + show_space(); + (void) sprintf(get_line(0, 0), + " Maddr Netid Semantics Protofmly Proto"); + + while (getxdr_u_long()) { + (void) getxdr_string(maddr, MAXSTRINGLEN); + (void) getxdr_string(netid, MAXSTRINGLEN); + sem = getxdr_u_long(); + (void) getxdr_string(protofmly, MAXSTRINGLEN); + (void) getxdr_string(proto, MAXSTRINGLEN); + (void) sprintf(get_line(0, 0), + "%-12s %-12s %-8s %-8s %-8s", + maddr, netid, + semantics_strs[sem], + protofmly, proto); + maps++; + } + + (void) sprintf(get_line(0, 0), " (%d maps)", maps); +} + +#define CXID_CACHE_SIZE 16 +struct cache_struct cxid_cache[CXID_CACHE_SIZE]; +struct cache_struct *cxcpfirst = &cxid_cache[0]; +struct cache_struct *cxcp = &cxid_cache[0]; +struct cache_struct *cxcplast = &cxid_cache[CXID_CACHE_SIZE - 1]; + +struct cache_struct * +find_callit(xid) + ulong_t xid; +{ + struct cache_struct *x; + + for (x = cxcp; x >= cxcpfirst; x--) + if (x->xid_num == xid) + return (x); + for (x = cxcplast; x > cxcp; x--) + if (x->xid_num == xid) + return (x); + return (NULL); +} + +static void +stash_callit(xid, frame, prog, vers, proc) + ulong_t xid; + int frame, prog, vers, proc; +{ + struct cache_struct *x; + + x = find_callit(xid); + if (x == NULL) { + x = cxcp++; + if (cxcp > cxcplast) + cxcp = cxcpfirst; + x->xid_num = xid; + x->xid_frame = frame; + } + x->xid_prog = prog; + x->xid_vers = vers; + x->xid_proc = proc; +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.c new file mode 100644 index 0000000..a056abd --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.c @@ -0,0 +1,1946 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2001-2002 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysmacros.h> +#include <net/ppp_defs.h> +#include <net/ppp-comp.h> +#include <net/if.h> +#include <netinet/in.h> +#include <netinet/if_ether.h> +#include <arpa/inet.h> +#include "snoop.h" +#include "snoop_ppp.h" + +static int interpret_ppp_cp(int, uchar_t *, int, ppp_protoinfo_t *); +static int interpret_cp_options(uchar_t *, int, ppp_protoinfo_t *); +static int interpret_ppp_chap(int, uchar_t *, int, ppp_protoinfo_t *); +static int interpret_ppp_pap(int, uchar_t *, int, ppp_protoinfo_t *); +static int interpret_ppp_lqr(int, uchar_t *, int, ppp_protoinfo_t *); +static ppp_protoinfo_t *ppp_getprotoinfo(uint16_t); +static cp_optinfo_t *ppp_getoptinfo(cp_optinfo_t *, uint16_t); +static optformat_func_t opt_format_vendor; +static optformat_func_t opt_format_mru; +static optformat_func_t opt_format_accm; +static optformat_func_t opt_format_authproto; +static optformat_func_t opt_format_qualproto; +static optformat_func_t opt_format_magicnum; +static optformat_func_t opt_format_fcs; +static optformat_func_t opt_format_sdp; +static optformat_func_t opt_format_nummode; +static optformat_func_t opt_format_callback; +static optformat_func_t opt_format_mrru; +static optformat_func_t opt_format_epdisc; +static optformat_func_t opt_format_dce; +static optformat_func_t opt_format_linkdisc; +static optformat_func_t opt_format_i18n; +static optformat_func_t opt_format_ipaddresses; +static optformat_func_t opt_format_ipcompproto; +static optformat_func_t opt_format_ipaddress; +static optformat_func_t opt_format_mobileipv4; +static optformat_func_t opt_format_ifaceid; +static optformat_func_t opt_format_ipv6compproto; +static optformat_func_t opt_format_compoui; +static optformat_func_t opt_format_bsdcomp; +static optformat_func_t opt_format_staclzs; +static optformat_func_t opt_format_mppc; +static optformat_func_t opt_format_gandalf; +static optformat_func_t opt_format_lzsdcp; +static optformat_func_t opt_format_magnalink; +static optformat_func_t opt_format_deflate; +static optformat_func_t opt_format_encroui; +static optformat_func_t opt_format_dese; +static optformat_func_t opt_format_muxpid; + +/* + * Many strings below are initialized with "Unknown". + */ +static char unknown_string[] = "Unknown"; + +/* + * Each known PPP protocol has an associated ppp_protoinfo_t in this array. + * Even if we can't decode the protocol (interpret_proto() == NULL), + * interpret_ppp() will at least print the protocol's name. There is no + * dependency on the ordering of the entries in this array. They have been + * ordered such that the most commonly used protocols are near the front. + * The array is delimited by a last entry of protocol of type + * PPP_PROTO_UNKNOWN. + */ +static ppp_protoinfo_t protoinfo_array[] = { + { PPP_IP, "IP", interpret_ip, NULL, NULL }, + { PPP_IPV6, "IPv6", interpret_ipv6, NULL, NULL }, + { PPP_COMP, "Compressed Data", NULL, NULL, NULL }, + { PPP_OSI, "OSI", NULL, NULL, NULL }, + { PPP_AT, "AppleTalk", NULL, NULL, NULL }, + { PPP_IPX, "IPX", NULL, NULL, NULL }, + { PPP_VJC_COMP, "VJ Compressed TCP", NULL, NULL, NULL }, + { PPP_VJC_UNCOMP, "VJ Uncompressed TCP", NULL, NULL, NULL }, + { PPP_BRIDGE, "Bridging", NULL, NULL, NULL }, + { PPP_802HELLO, "802.1d Hello", NULL, NULL, NULL }, + { PPP_MP, "MP", NULL, NULL, NULL }, + { PPP_ENCRYPT, "Encryption", NULL, NULL, NULL }, + { PPP_ENCRYPTFRAG, "Individual Link Encryption", NULL, NULL, NULL }, + { PPP_MUX, "PPP Muxing", NULL, NULL, NULL }, + { PPP_COMPFRAG, "Single Link Compressed Data", NULL, NULL, NULL }, + { PPP_FULLHDR, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPTCP, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPNONTCP, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPUDP8, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPRTP8, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPTCPND, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPSTATE, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPUDP16, "IP Compression", NULL, NULL, NULL }, + { PPP_COMPRTP16, "IP Compression", NULL, NULL, NULL }, + { PPP_MPLS, "MPLS", NULL, NULL, NULL }, + { PPP_MPLSMC, "MPLS M/C", NULL, NULL, NULL }, + { PPP_LQR, "LQR", interpret_ppp_lqr, "PPP-LQR: ", + "Link Quality Report" }, + { PPP_LCP, "LCP", interpret_ppp_cp, "PPP-LCP: ", + "Link Control Protocol" }, + { PPP_IPCP, "IPCP", interpret_ppp_cp, "PPP-IPCP: ", + "IP Control Protocol" }, + { PPP_IPV6CP, "IPV6CP", interpret_ppp_cp, "PPP-IPV6CP: ", + "IPv6 Control Protocol" }, + { PPP_CCP, "CCP", interpret_ppp_cp, "PPP-CCP: ", + "Compression Control Protocol" }, + { PPP_CCPFRAG, "CCP-Link", interpret_ppp_cp, "PPP-CCP-Link: ", + "Per-Link Compression Control Protocol" }, + { PPP_ECP, "ECP", interpret_ppp_cp, "PPP-ECP: ", + "Encryption Control Protocol" }, + { PPP_ECPFRAG, "ECP-Link", interpret_ppp_cp, "PPP-ECP-Link: ", + "Per-Link Encryption Control Protocol" }, + { PPP_MPLSCP, "MPLSCP", NULL, NULL, NULL }, + { PPP_OSINLCP, "OSINLCP", NULL, NULL, NULL }, + { PPP_ATCP, "ATCP", NULL, NULL, NULL }, + { PPP_IPXCP, "IPXCP", NULL, NULL, NULL }, + { PPP_BACP, "BACP", NULL, NULL, NULL }, + { PPP_BCP, "BCP", NULL, NULL, NULL }, + { PPP_CBCP, "CBCP", NULL, NULL, NULL }, + { PPP_BAP, "BAP", NULL, NULL, NULL }, + { PPP_CHAP, "CHAP", interpret_ppp_chap, "CHAP: ", + "Challenge Handshake Authentication Protocl" }, + { PPP_PAP, "PAP", interpret_ppp_pap, "PAP: ", + "Password Authentication Protocol" }, + { PPP_EAP, "EAP", NULL, NULL, NULL }, + { 0, unknown_string, NULL, NULL, NULL } +}; + +static cp_optinfo_t lcp_optinfo[] = { + { OPT_LCP_VENDOR, "Vendor-Specific", 6, + opt_format_vendor }, + { OPT_LCP_MRU, "Maximum-Receive-Unit", 4, + opt_format_mru }, + { OPT_LCP_ASYNCMAP, "Async-Control-Character-Map", 6, + opt_format_accm }, + { OPT_LCP_AUTHTYPE, "Authentication-Protocol", 4, + opt_format_authproto }, + { OPT_LCP_QUALITY, "Quality-Protocol", 4, + opt_format_qualproto }, + { OPT_LCP_MAGICNUMBER, "Magic-Number", 6, + opt_format_magicnum }, + { OPT_LCP_PCOMPRESSION, "Protocol-Field-Compression", 2, NULL }, + { OPT_LCP_ACCOMPRESSION, "Address-and-Control-Field-Compression", 2, + NULL }, + { OPT_LCP_FCSALTERN, "FCS-Alternative", 3, + opt_format_fcs }, + { OPT_LCP_SELFDESCPAD, "Self-Describing-Padding", 3, + opt_format_sdp }, + { OPT_LCP_NUMBERED, "Numbered-Mode", 3, + opt_format_nummode }, + { OPT_LCP_MULTILINKPROC, "Multi-Link-Procedure", 2, NULL }, + { OPT_LCP_CALLBACK, "Callback", 3, + opt_format_callback }, + { OPT_LCP_CONNECTTIME, "Connect-Time", 2, NULL }, + { OPT_LCP_COMPOUNDFRAMES, "Compound-Frames", 2, NULL }, + { OPT_LCP_DATAENCAP, "Nominal-Data-Encapsulation", 2, NULL }, + { OPT_LCP_MRRU, "Multilink-MRRU", 4, + opt_format_mrru }, + { OPT_LCP_SSNHF, "Multilink-Short-Sequence-Number-Header-Format", + 2, NULL }, + { OPT_LCP_EPDISC, "Multilink-Endpoint-Discriminator", 3, + opt_format_epdisc }, + { OPT_LCP_DCEIDENT, "DCE-Identifier", 3, + opt_format_dce }, + { OPT_LCP_MLPLUSPROC, "Multi-Link-Plus-Procedure", 2, NULL }, + { OPT_LCP_LINKDISC, "Link Discriminator for BACP", 4, + opt_format_linkdisc }, + { OPT_LCP_AUTH, "LCP-Authentication-Option", 2, NULL }, + { OPT_LCP_COBS, "COBS", 2, NULL }, + { OPT_LCP_PFXELISION, "Prefix elision", 2, NULL }, + { OPT_LCP_MPHDRFMT, "Multilink header format", 2, NULL }, + { OPT_LCP_I18N, "Internationalization", 6, + opt_format_i18n }, + { OPT_LCP_SDL, "Simple Data Link on SONET/SDH", 2, NULL }, + { OPT_LCP_MUXING, "Old PPP Multiplexing", 2, NULL }, + { 0, unknown_string, 0, NULL } +}; + +static cp_optinfo_t ipcp_optinfo[] = { + { OPT_IPCP_ADDRS, "IP-Addresses", 10, + opt_format_ipaddresses }, + { OPT_IPCP_COMPRESSTYPE, "IP-Compression-Protocol", 4, + opt_format_ipcompproto }, + { OPT_IPCP_ADDR, "IP-Address", 6, + opt_format_ipaddress }, + { OPT_IPCP_MOBILEIPV4, "Mobile-IPv4", 6, + opt_format_mobileipv4 }, + { OPT_IPCP_DNS1, "Primary DNS Address", 6, + opt_format_ipaddress }, + { OPT_IPCP_NBNS1, "Primary NBNS Address", 6, + opt_format_ipaddress }, + { OPT_IPCP_DNS2, "Secondary DNS Address", 6, + opt_format_ipaddress }, + { OPT_IPCP_NBNS2, "Secondary NBNS Address", 6, + opt_format_ipaddress }, + { OPT_IPCP_SUBNET, "IP-Subnet", 6, + opt_format_ipaddress }, + { 0, unknown_string, 0, NULL } +}; + +static cp_optinfo_t ipv6cp_optinfo[] = { + { OPT_IPV6CP_IFACEID, "Interface-Identifier", 10, + opt_format_ifaceid }, + { OPT_IPV6CP_COMPRESSTYPE, "IPv6-Compression-Protocol", 4, + opt_format_ipv6compproto }, + { 0, unknown_string, 0, NULL } +}; + +static cp_optinfo_t ccp_optinfo[] = { + { OPT_CCP_PROPRIETARY, "Proprietary Compression OUI", 6, + opt_format_compoui }, + { OPT_CCP_PREDICTOR1, "Predictor type 1", 2, NULL }, + { OPT_CCP_PREDICTOR2, "Predictor type 2", 2, NULL }, + { OPT_CCP_PUDDLEJUMP, "Puddle Jumper", 2, NULL }, + { OPT_CCP_HPPPC, "Hewlett-Packard PPC", 2, NULL }, + { OPT_CCP_STACLZS, "Stac Electronics LZS", 5, + opt_format_staclzs }, + { OPT_CCP_MPPC, "Microsoft PPC", 6, + opt_format_mppc }, + { OPT_CCP_GANDALFFZA, "Gandalf FZA", 3, + opt_format_gandalf }, + { OPT_CCP_V42BIS, "V.42bis compression", 2, + NULL }, + { OPT_CCP_BSDCOMP, "BSD LZW Compress", 3, + opt_format_bsdcomp }, + { OPT_CCP_LZSDCP, "LZS-DCP", 6, + opt_format_lzsdcp }, + { OPT_CCP_MAGNALINK, "Magnalink", 4, + opt_format_magnalink }, + { OPT_CCP_DEFLATE, "Deflate", 4, + opt_format_deflate }, + { 0, unknown_string, 0, NULL } +}; + +static cp_optinfo_t ecp_optinfo[] = { + { OPT_ECP_PROPRIETARY, "Proprietary Encryption OUI", 6, + opt_format_encroui }, + { OPT_ECP_DESE, "DESE", 10, + opt_format_dese }, + { OPT_ECP_3DESE, "3DESE", 10, + opt_format_dese }, + { OPT_ECP_DESEBIS, "DESE-bis", 10, + opt_format_dese }, + { 0, unknown_string, 0, NULL } +}; + +static cp_optinfo_t muxcp_optinfo[] = { + { OPT_MUXCP_DEFAULTPID, "Default PID", 4, + opt_format_muxpid }, + { 0, unknown_string, 0, NULL } +}; + +static char *cp_codearray[] = { + "(Vendor Specific)", + "(Configure-Request)", + "(Configure-Ack)", + "(Configure-Nak)", + "(Configure-Reject)", + "(Terminate-Request)", + "(Terminate-Ack)", + "(Code-Reject)", + "(Protocol-Reject)", + "(Echo-Request)", + "(Echo-Reply)", + "(Discard-Request)", + "(Identification)", + "(Time-Remaining)", + "(Reset-Request)", + "(Reset-Ack)" +}; +#define MAX_CPCODE ((sizeof (cp_codearray) / sizeof (char *)) - 1) + +static char *pap_codearray[] = { + "(Unknown)", + "(Authenticate-Request)", + "(Authenticate-Ack)", + "(Authenticate-Nak)" +}; +#define MAX_PAPCODE ((sizeof (pap_codearray) / sizeof (char *)) - 1) + +static char *chap_codearray[] = { + "(Unknown)", + "(Challenge)", + "(Response)", + "(Success)", + "(Failure)" +}; +#define MAX_CHAPCODE ((sizeof (chap_codearray) / sizeof (char *)) - 1) + + +int +interpret_ppp(int flags, uchar_t *data, int len) +{ + uint16_t protocol; + ppp_protoinfo_t *protoinfo; + uchar_t *payload = data; + + if (len < 2) + return (len); + + GETINT16(protocol, payload); + len -= sizeof (uint16_t); + + protoinfo = ppp_getprotoinfo(protocol); + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "PPP Protocol=0x%x (%s)", protocol, protoinfo->name); + } else { /* F_DTAIL */ + show_header("PPP: ", "Point-to-Point Protocol", len); + show_space(); + (void) sprintf(get_line(0, 0), "Protocol = 0x%x (%s)", + protocol, protoinfo->name); + show_space(); + } + + if (protoinfo->interpret_proto != NULL) { + len = protoinfo->interpret_proto(flags, payload, len, + protoinfo); + } + + return (len); +} + +/* + * interpret_ppp_cp() - Interpret PPP control protocols. It is convenient + * to do some of the decoding of these protocols in a common function since + * they share packet formats. This function expects to receive data + * starting with the code field. + */ +static int +interpret_ppp_cp(int flags, uchar_t *data, int len, ppp_protoinfo_t *protoinfo) +{ + uint8_t code; + uint8_t id; + char *codestr; + uint16_t length; + uchar_t *datap = data; + + if (len < sizeof (ppp_pkt_t)) + return (len); + + GETINT8(code, datap); + GETINT8(id, datap); + GETINT16(length, datap); + + len -= sizeof (ppp_pkt_t); + + if (code <= MAX_CPCODE) + codestr = cp_codearray[code]; + else + codestr = ""; + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "%s%s", protoinfo->prefix, codestr); + } else { /* (flags & F_DTAIL) */ + show_header(protoinfo->prefix, protoinfo->description, len); + show_space(); + + (void) sprintf(get_line(0, 0), "Code = %d %s", code, codestr); + (void) sprintf(get_line(0, 0), "Identifier = %d", id); + (void) sprintf(get_line(0, 0), "Length = %d", length); + + show_space(); + + len = MIN(len, length - sizeof (ppp_pkt_t)); + if (len == 0) + return (len); + + switch (code) { + case CODE_VENDOR: { + uint32_t magicnum; + uint32_t oui; + char *ouistr; + uint8_t kind; + + if (len < sizeof (magicnum) + sizeof (oui)) + return (len); + + GETINT32(magicnum, datap); + (void) sprintf(get_line(0, 0), "Magic-Number = 0x%08x", + magicnum); + + GETINT32(oui, datap); + kind = oui & 0x000000ff; + oui >>= 8; + + ouistr = ether_ouiname(oui); + if (ouistr == NULL) + ouistr = unknown_string; + + (void) sprintf(get_line(0, 0), "OUI = 0x%06x (%s)", + oui, ouistr); + (void) sprintf(get_line(0, 0), "Kind = %d", kind); + show_space(); + break; + } + + case CODE_CONFREQ: + case CODE_CONFACK: + case CODE_CONFNAK: + case CODE_CONFREJ: + /* + * The above all contain protocol specific + * configuration options. Parse these options. + */ + interpret_cp_options(datap, len, protoinfo); + break; + + case CODE_TERMREQ: + case CODE_TERMACK: + /* + * The arbitrary data in these two packet types + * is almost always plain text. Print it as such. + */ + (void) sprintf(get_line(0, 0), "Data = %.*s", + length - sizeof (ppp_pkt_t), datap); + show_space(); + break; + + case CODE_CODEREJ: + /* + * What follows is the rejected control protocol + * packet, starting with the code field. + * Conveniently, we can call interpret_ppp_cp() to + * decode this. + */ + prot_nest_prefix = protoinfo->prefix; + interpret_ppp_cp(flags, datap, len, protoinfo); + prot_nest_prefix = ""; + break; + + case CODE_PROTREJ: + /* + * We don't print the rejected-protocol field + * explicitely. Instead, we cheat and pretend that + * the rejected-protocol field is actually the + * protocol field in the included PPP packet. This + * way, we can invoke interpret_ppp() and have it + * treat the included packet normally. + */ + prot_nest_prefix = protoinfo->prefix; + interpret_ppp(flags, datap, len); + prot_nest_prefix = ""; + break; + + case CODE_ECHOREQ: + case CODE_ECHOREP: + case CODE_DISCREQ: + case CODE_IDENT: + case CODE_TIMEREMAIN: { + uint32_t magicnum; + char *message_label = "Identification = %.*s"; + + if (len < sizeof (uint32_t)) + break; + + GETINT32(magicnum, datap); + len -= sizeof (uint32_t); + (void) sprintf(get_line(0, 0), "Magic-Number = 0x%08x", + magicnum); + /* + * Unless this is an identification or + * time-remaining packet, arbitrary data follows + * the magic number field. The user can take a + * look at the hex dump for enlightenment. + */ + if (code == CODE_TIMEREMAIN) { + uint32_t timeremaining; + + if (len < sizeof (uint32_t)) + break; + + message_label = "Message = %.*s"; + + GETINT32(timeremaining, datap); + len -= sizeof (uint32_t); + (void) sprintf(get_line(0, 0), + "Seconds Remaining = %d", timeremaining); + } + + if (code == CODE_IDENT || code == CODE_TIMEREMAIN) { + if (len == 0) + break; + + (void) sprintf(get_line(0, 0), message_label, + len, datap); + } + show_space(); + break; + } + + /* + * Reset-Request and Reset-Ack contain arbitrary data which + * the user can sift through using the -x option. + */ + case CODE_RESETREQ: + case CODE_RESETACK: + default: + break; + } + } + return (len); +} + + +/* + * interpret_cp_options() decodes control protocol configuration options. + * Since each control protocol has a different set of options whose type + * numbers overlap, the protoinfo parameter is used to get a handle on + * which option set to use for decoding. + */ +static int +interpret_cp_options(uchar_t *optptr, int len, ppp_protoinfo_t *protoinfo) +{ + cp_optinfo_t *optinfo; + cp_optinfo_t *optinfo_ptr; + uint8_t optlen; + uint8_t opttype; + + switch (protoinfo->proto) { + case PPP_LCP: + optinfo = lcp_optinfo; + break; + case PPP_IPCP: + optinfo = ipcp_optinfo; + break; + case PPP_IPV6CP: + optinfo = ipv6cp_optinfo; + break; + case PPP_CCP: + optinfo = ccp_optinfo; + break; + case PPP_ECP: + optinfo = ecp_optinfo; + break; + case PPP_MUXCP: + optinfo = muxcp_optinfo; + break; + default: + return (len); + break; + } + + if (len >= 2) { + (void) sprintf(get_line(0, 0), "%s Configuration Options", + protoinfo->name); + show_space(); + } + + while (len >= 2) { + GETINT8(opttype, optptr); + GETINT8(optlen, optptr); + + optinfo_ptr = ppp_getoptinfo(optinfo, opttype); + + (void) sprintf(get_line(0, 0), "Option Type = %d (%s)", opttype, + optinfo_ptr->opt_name); + (void) sprintf(get_line(0, 0), "Option Length = %d", optlen); + + /* + * Don't continue if there isn't enough data to + * contain this option, or if this type of option + * should contain more data than the length field + * claims there is. + */ + if (optlen > len || optlen < optinfo_ptr->opt_minsize) { + (void) sprintf(get_line(0, 0), + "Warning: Incomplete Option"); + show_space(); + break; + } + + if (optinfo_ptr->opt_formatdata != NULL) { + optinfo_ptr->opt_formatdata(optptr, + MIN(optlen - 2, len - 2)); + } + + len -= optlen; + optptr += optlen - 2; + + show_space(); + } + + return (len); +} + +static int +interpret_ppp_chap(int flags, uchar_t *data, int len, + ppp_protoinfo_t *protoinfo) +{ + uint8_t code; + uint8_t id; + char *codestr; + uint16_t length; + int lengthleft; + uchar_t *datap = data; + + + if (len < sizeof (ppp_pkt_t)) + return (len); + + GETINT8(code, datap); + GETINT8(id, datap); + GETINT8(length, datap); + + if (code <= MAX_CHAPCODE) + codestr = chap_codearray[code]; + else + codestr = ""; + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "%s%s", protoinfo->prefix, codestr); + } else { /* (flags & F_DTAIL) */ + show_header(protoinfo->prefix, protoinfo->description, len); + show_space(); + + (void) sprintf(get_line(0, 0), "Code = %d %s", code, codestr); + (void) sprintf(get_line(0, 0), "Identifier = %d", id); + (void) sprintf(get_line(0, 0), "Length = %d", length); + + show_space(); + + if (len < length) + return (len); + + lengthleft = len - sizeof (ppp_pkt_t); + + switch (code) { + case CODE_CHALLENGE: + case CODE_RESPONSE: { + uint8_t value_size; + uint16_t peername_size; + + if (lengthleft < sizeof (value_size)) + break; + + GETINT8(value_size, datap); + lengthleft -= sizeof (value_size); + (void) sprintf(get_line(0, 0), "Value-Size = %d", + value_size); + + if (lengthleft < sizeof (peername_size)) + break; + peername_size = MIN(length - sizeof (ppp_pkt_t) - + value_size, lengthleft); + (void) sprintf(get_line(0, 0), "Name = %.*s", + peername_size, datap + value_size); + + break; + } + case CODE_SUCCESS: + case CODE_FAILURE: { + uint16_t message_size = MIN(length - sizeof (ppp_pkt_t), + lengthleft); + + (void) sprintf(get_line(0, 0), "Message = %.*s", + message_size, datap); + break; + } + default: + break; + } + } + + show_space(); + len -= length; + return (len); +} + +static int +interpret_ppp_pap(int flags, uchar_t *data, int len, + ppp_protoinfo_t *protoinfo) +{ + uint8_t code; + uint8_t id; + char *codestr; + uint16_t length; + int lengthleft; + uchar_t *datap = data; + + if (len < sizeof (ppp_pkt_t)) + return (len); + + GETINT8(code, datap); + GETINT8(id, datap); + GETINT16(length, datap); + + lengthleft = len - sizeof (ppp_pkt_t); + + if (code <= MAX_PAPCODE) + codestr = pap_codearray[code]; + else + codestr = ""; + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "%s%s", protoinfo->prefix, codestr); + } else { /* (flags & F_DTAIL) */ + show_header(protoinfo->prefix, protoinfo->description, len); + show_space(); + + (void) sprintf(get_line(0, 0), "Code = %d %s", code, codestr); + (void) sprintf(get_line(0, 0), "Identifier = %d", id); + (void) sprintf(get_line(0, 0), "Length = %d", length); + + show_space(); + + if (len < length) + return (len); + + switch (code) { + case CODE_AUTHREQ: { + uint8_t fieldlen; + + if (lengthleft < sizeof (fieldlen)) + break; + GETINT8(fieldlen, datap); + (void) sprintf(get_line(0, 0), "Peer-Id Length = %d", + fieldlen); + lengthleft -= sizeof (fieldlen); + + if (lengthleft < fieldlen) + break; + (void) sprintf(get_line(0, 0), "Peer-Id = %.*s", + fieldlen, datap); + lengthleft -= fieldlen; + + datap += fieldlen; + + if (lengthleft < sizeof (fieldlen)) + break; + GETINT8(fieldlen, datap); + (void) sprintf(get_line(0, 0), "Password Length = %d", + fieldlen); + lengthleft -= sizeof (fieldlen); + + if (lengthleft < fieldlen) + break; + (void) sprintf(get_line(0, 0), "Password = %.*s", + fieldlen, datap); + + break; + } + case CODE_AUTHACK: + case CODE_AUTHNAK: { + uint8_t msglen; + + if (lengthleft < sizeof (msglen)) + break; + GETINT8(msglen, datap); + (void) sprintf(get_line(0, 0), "Msg-Length = %d", + msglen); + lengthleft -= sizeof (msglen); + + if (lengthleft < msglen) + break; + (void) sprintf(get_line(0, 0), "Message = %.*s", + msglen, datap); + + break; + } + default: + break; + } + } + + show_space(); + len -= length; + return (len); +} + + +static int +interpret_ppp_lqr(int flags, uchar_t *data, int len, + ppp_protoinfo_t *protoinfo) +{ + lqr_pkt_t lqr_pkt; + if (len < sizeof (lqr_pkt_t)) + return (len); + + (void) memcpy(&lqr_pkt, data, sizeof (lqr_pkt_t)); + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), protoinfo->prefix); + } else { /* (flags & F_DTAIL) */ + show_header(protoinfo->prefix, protoinfo->description, len); + show_space(); + + (void) sprintf(get_line(0, 0), "Magic-Number = 0x%08x", + ntohl(lqr_pkt.lqr_magic)); + (void) sprintf(get_line(0, 0), "LastOutLQRs = %d", + ntohl(lqr_pkt.lqr_lastoutlqrs)); + (void) sprintf(get_line(0, 0), "LastOutPackets = %d", + ntohl(lqr_pkt.lqr_lastoutpackets)); + (void) sprintf(get_line(0, 0), "LastOutOctets = %d", + ntohl(lqr_pkt.lqr_lastoutoctets)); + (void) sprintf(get_line(0, 0), "PeerInLQRs = %d", + ntohl(lqr_pkt.lqr_peerinlqrs)); + (void) sprintf(get_line(0, 0), "PeerInPackets = %d", + ntohl(lqr_pkt.lqr_peerinpackets)); + (void) sprintf(get_line(0, 0), "PeerInDiscards = %d", + ntohl(lqr_pkt.lqr_peerindiscards)); + (void) sprintf(get_line(0, 0), "PeerInErrors = %d", + ntohl(lqr_pkt.lqr_peerinerrors)); + (void) sprintf(get_line(0, 0), "PeerInOctets = %d", + ntohl(lqr_pkt.lqr_peerinoctets)); + (void) sprintf(get_line(0, 0), "PeerOutLQRs = %d", + ntohl(lqr_pkt.lqr_peeroutlqrs)); + (void) sprintf(get_line(0, 0), "PeerOutPackets = %d", + ntohl(lqr_pkt.lqr_peeroutpackets)); + (void) sprintf(get_line(0, 0), "PeerOutOctets = %d", + ntohl(lqr_pkt.lqr_peeroutoctets)); + + show_space(); + } + + len -= sizeof (lqr_pkt_t); + return (len); +} + +static ppp_protoinfo_t * +ppp_getprotoinfo(uint16_t proto) +{ + ppp_protoinfo_t *protoinfo_ptr = &protoinfo_array[0]; + + while (protoinfo_ptr->proto != proto && protoinfo_ptr->proto != 0) { + protoinfo_ptr++; + } + + return (protoinfo_ptr); +} + + +static cp_optinfo_t * +ppp_getoptinfo(cp_optinfo_t optinfo_list[], uint16_t opt_type) +{ + cp_optinfo_t *optinfo_ptr = &optinfo_list[0]; + + while (optinfo_ptr->opt_type != opt_type && + optinfo_ptr->opt_name != unknown_string) { + optinfo_ptr++; + } + + return (optinfo_ptr); +} + + +/* + * Below are the functions which parse control protocol configuration + * options. The first argument to these functions (optdata) points to the + * first byte of the option after the length field. The second argument + * (size) is the number of bytes in the option after the length field + * (length - 2). + */ + +/* + * The format of the Vendor-Specific option (rfc2153) is: + * + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | OUI + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * ... | Kind | Value(s) ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- + */ +/*ARGSUSED1*/ +static void +opt_format_vendor(uchar_t *optdata, uint8_t size) +{ + uint32_t oui; + char *ouistr; + uint8_t kind; + + GETINT32(oui, optdata); + kind = oui & 0x000000ff; + oui >>= 8; + + ouistr = ether_ouiname(oui); + if (ouistr == NULL) + ouistr = unknown_string; + + (void) sprintf(get_line(0, 0), "OUI = 0x%06x (%s)", oui, ouistr); + (void) sprintf(get_line(0, 0), "Kind = %d", kind); +} + +/* + * The format of the MRU option (rfc1661) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Maximum-Receive-Unit | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_mru(uchar_t *optdata, uint8_t size) +{ + uint16_t mru; + + GETINT16(mru, optdata); + (void) sprintf(get_line(0, 0), "MRU = %d", mru); +} + +/* + * The format of the accm option (rfc1662) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | ACCM + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * ACCM (cont) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_accm(uchar_t *optdata, uint8_t size) +{ + uint32_t accm; + + GETINT32(accm, optdata); + (void) sprintf(get_line(0, 0), "ACCM = 0x%08x", accm); +} + +/* + * The format of the Authentication-Protocol option (rfc1661) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Authentication-Protocol | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Data ... + * +-+-+-+-+ + * + * For PAP (rfc1334), there is no data. For CHAP (rfc1994), there is one + * byte of data representing the algorithm. + */ +static void +opt_format_authproto(uchar_t *optdata, uint8_t size) +{ + uint16_t proto; + ppp_protoinfo_t *auth_protoinfo; + + GETINT16(proto, optdata); + + auth_protoinfo = ppp_getprotoinfo(proto); + + (void) sprintf(get_line(0, 0), "Protocol = 0x%x (%s)", proto, + auth_protoinfo->name); + + switch (proto) { + case PPP_CHAP: { + uint8_t algo; + char *algostr; + + if (size < sizeof (proto) + sizeof (algo)) + return; + + GETINT8(algo, optdata); + switch (algo) { + case 5: + algostr = "CHAP with MD5"; + break; + case 128: + algostr = "MS-CHAP"; + break; + case 129: + algostr = "MS-CHAP-2"; + break; + default: + algostr = unknown_string; + break; + } + (void) sprintf(get_line(0, 0), "Algorithm = %d (%s)", algo, + algostr); + break; + } + default: + break; + } +} + +/* + * The format of the Quality Protocol option (rfc1661) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Quality-Protocol | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Data ... + * +-+-+-+-+ + * + * For LQR, the data consists of a 4 byte reporting period. + */ +static void +opt_format_qualproto(uchar_t *optdata, uint8_t size) +{ + uint16_t proto; + ppp_protoinfo_t *qual_protoinfo; + + GETINT16(proto, optdata); + + qual_protoinfo = ppp_getprotoinfo(proto); + + (void) sprintf(get_line(0, 0), "Protocol = 0x%x (%s)", proto, + qual_protoinfo->name); + + switch (proto) { + case PPP_LQR: { + uint32_t reporting_period; + + if (size < sizeof (proto) + sizeof (reporting_period)) + return; + + GETINT32(reporting_period, optdata); + (void) sprintf(get_line(0, 0), "Reporting-Period = %d", + reporting_period); + break; + } + default: + break; + } +} + +/* + * The format of the Magic Number option (rfc1661) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Magic-Number + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * Magic-Number (cont) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_magicnum(uchar_t *optdata, uint8_t size) +{ + uint32_t magicnum; + + GETINT32(magicnum, optdata); + (void) sprintf(get_line(0, 0), "Magic Number = 0x%08x", magicnum); +} + +/* + * The format of the FCS-Alternatives option (rfc1570) is: + * + * 0 1 2 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Options | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_fcs(uchar_t *optdata, uint8_t size) +{ + uint8_t options; + + GETINT8(options, optdata); + + (void) sprintf(get_line(0, 0), "Options = 0x%02x", options); + (void) sprintf(get_line(0, 0), " %s", + getflag(options, 0x01, "NULL FCS", "")); + (void) sprintf(get_line(0, 0), " %s", + getflag(options, 0x02, "CCITT 16-bit FCS", "")); + (void) sprintf(get_line(0, 0), " %s", + getflag(options, 0x04, "CCITT 32-bit FCS", "")); +} + +/* + * The format of the Self-Describing-Padding option (rfc1570) is: + * + * 0 1 2 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Maximum | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_sdp(uchar_t *optdata, uint8_t size) +{ + uint8_t max; + + GETINT8(max, optdata); + + (void) sprintf(get_line(0, 0), "Maximum = %d", max); +} + +/* + * The format of the Numbered-Mode option (rfc1663) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Window | Address... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_nummode(uchar_t *optdata, uint8_t size) +{ + uint8_t window; + + GETINT8(window, optdata); + (void) sprintf(get_line(0, 0), "Window = %d", window); +} + +/* + * The format of the Callback option (rfc1570) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Operation | Message ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +static void +opt_format_callback(uchar_t *optdata, uint8_t size) +{ + uint8_t operation; + char *opstr; + + GETINT8(operation, optdata); + switch (operation) { + case 0: + opstr = "User Authentication"; + break; + case 1: + opstr = "Dialing String"; + break; + case 2: + opstr = "Location Identifier"; + break; + case 3: + opstr = "E.164 Number"; + break; + case 4: + opstr = "X.500 Distinguished Name"; + break; + case 6: + opstr = "CBCP Negotiation"; + break; + default: + opstr = unknown_string; + break; + } + + (void) sprintf(get_line(0, 0), "Operation = %d (%s)", operation, opstr); + + if (size > sizeof (operation)) { + (void) sprintf(get_line(0, 0), "Message = %.*s", + size - sizeof (operation), optdata); + } +} + +/* + * The format of the Multilink-MRRU option (rfc1990) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type = 17 | Length = 4 | Max-Receive-Reconstructed-Unit| + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_mrru(uchar_t *optdata, uint8_t size) +{ + uint16_t mrru; + + GETINT16(mrru, optdata); + (void) sprintf(get_line(0, 0), "MRRU = %d", mrru); +} + +/* + * The format of the Endpoint Discriminator option (rfc1990) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type = 19 | Length | Class | Address ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +static void +opt_format_epdisc(uchar_t *optdata, uint8_t size) +{ + uint8_t class; + char *classstr; + uint8_t addrlen = size - sizeof (class); + char *addr; + + GETINT8(class, optdata); + + switch (class) { + case 0: + classstr = "Null Class"; + break; + case 1: + classstr = "Locally Assigned Address"; + break; + case 2: + classstr = "IPv4 Address"; + break; + case 3: + classstr = "IEE 802.1 Global MAC Address"; + break; + case 4: + classstr = "PPP Magic-Number Block"; + break; + case 5: + classstr = "Public Switched Network Directory Number"; + break; + default: + classstr = unknown_string; + break; + } + + (void) sprintf(get_line(0, 0), "Address Class = %d (%s)", class, + classstr); + + if (addrlen == 0) + return; + + addr = (char *)malloc(addrlen); + (void) memcpy(addr, optdata, addrlen); + switch (class) { + case 2: { + char addrstr[INET_ADDRSTRLEN]; + + if (addrlen != sizeof (in_addr_t)) + break; + if (inet_ntop(AF_INET, addr, addrstr, INET_ADDRSTRLEN) != + NULL) { + (void) sprintf(get_line(0, 0), "Address = %s", addrstr); + } + break; + } + case 3: { + char *addrstr; + + if (addrlen != sizeof (struct ether_addr)) + break; + if ((addrstr = ether_ntoa((struct ether_addr *)addr)) != NULL) { + (void) sprintf(get_line(0, 0), "Address = %s", addrstr); + } + break; + } + case 5: { + /* + * For this case, the address is supposed to be a plain + * text telephone number. + */ + (void) sprintf(get_line(0, 0), "Address = %.*s", addrlen, + addr); + } + default: + break; + } + + free(addr); +} + +/* + * The DCE identifier option has the following format (from rfc1976): + * + * 0 1 2 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Mode | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_dce(uchar_t *optdata, uint8_t size) +{ + uint8_t mode; + char *modestr; + + GETINT8(mode, optdata); + switch (mode) { + case 1: + modestr = "No Additional Negotiation"; + break; + case 2: + modestr = "Full PPP Negotiation and State Machine"; + break; + default: + modestr = unknown_string; + break; + } + (void) sprintf(get_line(0, 0), "Mode = %d (%s)", mode, modestr); +} + +/* + * The format of the Link Discriminator option (rfc2125) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Link Discriminator | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_linkdisc(uchar_t *optdata, uint8_t size) +{ + uint16_t discrim; + + GETINT16(discrim, optdata); + + (void) sprintf(get_line(0, 0), "Link Discriminator = %d", discrim); +} + + +/* + * The format of the Internationalization option (rfc2484) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | MIBenum + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * MIBenum (cont) | Language-Tag... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +static void +opt_format_i18n(uchar_t *optdata, uint8_t size) +{ + uint32_t mibenum; + uint8_t taglen; + + taglen = size - sizeof (mibenum); + + GETINT32(mibenum, optdata); + (void) sprintf(get_line(0, 0), "MIBenum = %d", mibenum); + + if (taglen > 0) { + (void) sprintf(get_line(0, 0), "Language Tag = %.*s", taglen, + optdata); + } +} + +/* + * The format of the obsolete IP-Addresses option (rfc1172) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Source-IP-Address + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * Source-IP-Address (cont) | Destination-IP-Address + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * Destination-IP-Address (cont) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_ipaddresses(uchar_t *optdata, uint8_t size) +{ + in_addr_t addr; + char addrstr[INET_ADDRSTRLEN]; + + (void) memcpy(&addr, optdata, sizeof (in_addr_t)); + if (inet_ntop(AF_INET, &addr, addrstr, INET_ADDRSTRLEN) != NULL) { + (void) sprintf(get_line(0, 0), "Source Address = %s", + addrstr); + } + + optdata += sizeof (in_addr_t); + + (void) memcpy(&addr, optdata, sizeof (in_addr_t)); + if (inet_ntop(AF_INET, &addr, addrstr, INET_ADDRSTRLEN) != NULL) { + (void) sprintf(get_line(0, 0), "Destination Address = %s", + addrstr); + } +} + +/* + * The format of the IP-Compression-Protocol option (rfc1332) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | IP-Compression-Protocol | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Data ... + * +-+-+-+-+ + * + * For VJ Compressed TCP/IP, data consists of: + * + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Max-Slot-Id | Comp-Slot-Id | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * For IPHC (rfc2509), data consists of: + * + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | TCP_SPACE | NON_TCP_SPACE | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | F_MAX_PERIOD | F_MAX_TIME | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | MAX_HEADER | suboptions... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +static void +opt_format_ipcompproto(uchar_t *optdata, uint8_t size) +{ + uint16_t proto; + ppp_protoinfo_t *comp_protoinfo; + + GETINT16(proto, optdata); + + comp_protoinfo = ppp_getprotoinfo(proto); + + (void) sprintf(get_line(0, 0), "Protocol = 0x%x (%s)", proto, + comp_protoinfo->name); + + switch (proto) { + case PPP_VJC_COMP: { + uint8_t maxslotid; + uint8_t compslotid; + + if (size < sizeof (proto) + sizeof (maxslotid) + + sizeof (compslotid)) + break; + + GETINT8(maxslotid, optdata); + GETINT8(compslotid, optdata); + (void) sprintf(get_line(0, 0), "Max-Slot-Id = %d", maxslotid); + (void) sprintf(get_line(0, 0), "Comp-Slot Flag = 0x%x", + compslotid); + break; + } + case PPP_FULLHDR: { + uint16_t tcp_space; + uint16_t non_tcp_space; + uint16_t f_max_period; + uint16_t f_max_time; + uint16_t max_header; + + if (size < sizeof (proto) + sizeof (tcp_space) + + sizeof (non_tcp_space) + sizeof (f_max_period) + + sizeof (f_max_time) + sizeof (max_header)) + break; + + GETINT16(tcp_space, optdata); + GETINT16(non_tcp_space, optdata); + GETINT16(f_max_period, optdata); + GETINT16(f_max_time, optdata); + GETINT16(max_header, optdata); + + (void) sprintf(get_line(0, 0), "TCP_SPACE = %d", tcp_space); + (void) sprintf(get_line(0, 0), "NON_TCP_SPACE = %d", + non_tcp_space); + (void) sprintf(get_line(0, 0), "F_MAX_PERIOD = %d", + f_max_period); + (void) sprintf(get_line(0, 0), "F_MAX_TIME = %d", f_max_time); + (void) sprintf(get_line(0, 0), "MAX_HEADER = %d octets", + max_header); + } + default: + break; + } +} + +/* + * The format of the IP-Address option (rfc1332) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | IP-Address + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * IP-Address (cont) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_ipaddress(uchar_t *optdata, uint8_t size) +{ + in_addr_t ipaddr; + char addrstr[INET_ADDRSTRLEN]; + + (void) memcpy(&ipaddr, optdata, sizeof (in_addr_t)); + if (inet_ntop(AF_INET, &ipaddr, addrstr, INET_ADDRSTRLEN) != NULL) { + (void) sprintf(get_line(0, 0), "Address = %s", addrstr); + } +} + +/* + * The format of the Mobile-IPv4 option (rfc2290) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Mobile Node's ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * ... Home Address | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_mobileipv4(uchar_t *optdata, uint8_t size) +{ + in_addr_t ipaddr; + char addrstr[INET_ADDRSTRLEN]; + + (void) memcpy(&ipaddr, optdata, sizeof (in_addr_t)); + if (inet_ntop(AF_INET, &ipaddr, addrstr, INET_ADDRSTRLEN) != NULL) { + (void) sprintf(get_line(0, 0), + "Mobile Node's Home Address = %s", addrstr); + } +} + +/* + * The format of the Interface-Identifier option (rfc2472) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Interface-Identifier (MS Bytes) + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * Interface-Identifier (cont) + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * Interface-Identifier (LS Bytes) | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_ifaceid(uchar_t *optdata, uint8_t size) +{ + in6_addr_t id; + char idstr[INET6_ADDRSTRLEN]; + + (void) memset(&id, 0, sizeof (in6_addr_t)); + (void) memcpy(&id.s6_addr[8], optdata, 8); + + if (inet_ntop(AF_INET6, &id, idstr, INET6_ADDRSTRLEN) != NULL) { + (void) sprintf(get_line(0, 0), "Interface ID = %s", idstr); + } +} + +/* + * The format of the IPv6-Compression-Protocol option (rfc2472) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | IPv6-Compression-Protocol | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Data ... + * +-+-+-+-+ + */ +static void +opt_format_ipv6compproto(uchar_t *optdata, uint8_t size) +{ + uint16_t proto; + ppp_protoinfo_t *comp_protoinfo; + + GETINT16(proto, optdata); + + comp_protoinfo = ppp_getprotoinfo(proto); + + (void) sprintf(get_line(0, 0), "Protocol = 0x%x (%s)", proto, + comp_protoinfo->name); + + switch (proto) { + case PPP_FULLHDR: { + uint16_t tcp_space; + uint16_t non_tcp_space; + uint16_t f_max_period; + uint16_t f_max_time; + uint16_t max_header; + + if (size < sizeof (proto) + sizeof (tcp_space) + + sizeof (non_tcp_space) + sizeof (f_max_period) + + sizeof (f_max_time) + sizeof (max_header)) + return; + + GETINT16(tcp_space, optdata); + GETINT16(non_tcp_space, optdata); + GETINT16(f_max_period, optdata); + GETINT16(f_max_time, optdata); + GETINT16(max_header, optdata); + + (void) sprintf(get_line(0, 0), "TCP_SPACE = %d", tcp_space); + (void) sprintf(get_line(0, 0), "NON_TCP_SPACE = %d", + non_tcp_space); + (void) sprintf(get_line(0, 0), "F_MAX_PERIOD = %d", + f_max_period); + (void) sprintf(get_line(0, 0), "F_MAX_TIME = %d", f_max_time); + (void) sprintf(get_line(0, 0), "MAX_HEADER = %d octets", + max_header); + } + default: + break; + } +} + +/* + * The format of the Proprietary Compression OUI option (rfc1962) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | OUI ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * OUI | Subtype | Values... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- + */ +/*ARGSUSED1*/ +static void +opt_format_compoui(uchar_t *optdata, uint8_t size) +{ + uint32_t oui; + uint8_t subtype; + char *ouistr; + + GETINT32(oui, optdata); + subtype = oui & 0x000000ff; + oui >>= 8; + + ouistr = ether_ouiname(oui); + if (ouistr == NULL) + ouistr = unknown_string; + (void) sprintf(get_line(0, 0), "OUI = 0x%06x (%s)", oui, ouistr); + (void) sprintf(get_line(0, 0), "Subtype = 0x%x", subtype); +} + +/* + * The format of the Stac LZS configuration option (rfc1974) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | History Count | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Check Mode | + * +-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_staclzs(uchar_t *optdata, uint8_t size) +{ + uint16_t hcount; + uint8_t cmode; + + GETINT16(hcount, optdata); + GETINT8(cmode, optdata); + + cmode &= 0x07; + + (void) sprintf(get_line(0, 0), "History Count = %d", hcount); + (void) sprintf(get_line(0, 0), "Check Mode = %d", cmode); +} + +/* + * The format of MPPC configuration option (rfc2118) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Supported Bits | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Supported Bits | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_mppc(uchar_t *optdata, uint8_t size) +{ + uint32_t sb; + + GETINT32(sb, optdata); + + (void) sprintf(get_line(0, 0), "Supported Bits = 0x%x", sb); +} + +/* + * The format of the Gandalf FZA configuration option (rfc1993) is: + * + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | History | Version ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_gandalf(uchar_t *optdata, uint8_t size) +{ + uint8_t history; + + GETINT8(history, optdata); + (void) sprintf(get_line(0, 0), "Maximum History Size = %d bits", + history); +} + +/* + * The format of the BSD Compress configuration option (rfc1977) is: + * + * 0 1 2 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | Vers| Dict | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_bsdcomp(uchar_t *optdata, uint8_t size) +{ + uint8_t version; + uint8_t codesize; + + GETINT8(codesize, optdata); + + version = codesize >> 5; + codesize &= 0x1f; + + (void) sprintf(get_line(0, 0), "Version = 0x%x", version); + (void) sprintf(get_line(0, 0), "Maximum Code Size = %d bits", codesize); +} + +/* + * The format of the LZS-DCP configuration option (rfc1967) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | History Count | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Check Mode | Process Mode | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_lzsdcp(uchar_t *optdata, uint8_t size) +{ + uint16_t history; + uint8_t mode; + char *modestr; + + GETINT16(history, optdata); + (void) sprintf(get_line(0, 0), "History Count = %d", history); + + /* check mode */ + GETINT8(mode, optdata); + switch (mode) { + case 0: + modestr = "None"; + break; + case 1: + modestr = "LCB"; + break; + case 2: + modestr = "Sequence Number"; + break; + case 3: + modestr = "Sequence Number + LCB (default)"; + break; + default: + modestr = unknown_string; + break; + } + (void) sprintf(get_line(0, 0), "Check Mode = %d (%s)", mode, modestr); + + /* process mode */ + GETINT8(mode, optdata); + switch (mode) { + case 0: + modestr = "None (default)"; + break; + case 1: + modestr = "Process-Uncompressed"; + break; + default: + modestr = unknown_string; + break; + } + (void) sprintf(get_line(0, 0), "Process Mode = %d (%s)", mode, modestr); + +} + +/* + * The format of the Magnalink configuration option (rfc1975) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length |FE |P| History | # Contexts | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_magnalink(uchar_t *optdata, uint8_t size) +{ + uint8_t features; + uint8_t pflag; + uint8_t history; + uint8_t contexts; + + GETINT8(history, optdata); + GETINT8(contexts, optdata); + + features = history >> 6; + pflag = (history >> 5) & 0x01; + history &= 0x1f; + + (void) sprintf(get_line(0, 0), "Features = 0x%d", features); + (void) sprintf(get_line(0, 0), "Packet Flag = %d", pflag); + (void) sprintf(get_line(0, 0), "History Size = %d", history); + (void) sprintf(get_line(0, 0), "Contexts = %d", contexts); +} + +/* + * The format of the Deflate configuration option (rfc1979) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length |Window | Method| MBZ |Chk| + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_deflate(uchar_t *optdata, uint8_t size) +{ + uint8_t window; + uint8_t method; + uint8_t chk; + + GETINT8(method, optdata); + window = method >> 4; + method &= 0x0f; + + GETINT8(chk, optdata); + chk &= 0x03; + + (void) sprintf(get_line(0, 0), "Maximum Window Size = %d", window); + (void) sprintf(get_line(0, 0), "Compression Method = 0x%x", method); + (void) sprintf(get_line(0, 0), "Check Method = 0x%x", chk); +} + +/* + * The format of the Proprietary Encryption OUI option (rfc1968) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type | Length | OUI ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * OUI | Subtype | Values... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- + */ +/*ARGSUSED1*/ +static void +opt_format_encroui(uchar_t *optdata, uint8_t size) +{ + uint32_t oui; + uint8_t subtype; + char *ouistr; + + GETINT32(oui, optdata); + subtype = oui & 0x000000ff; + oui >>= 8; + + ouistr = ether_ouiname(oui); + if (ouistr == NULL) + ouistr = unknown_string; + (void) sprintf(get_line(0, 0), "OUI = 0x%06x (%s)", oui, ouistr); + (void) sprintf(get_line(0, 0), "Subtype = 0x%x", subtype); +} + +/* + * The format of the DESE, DESE-bis, and 3DESE configuration options + * (rfc1969, rfc2419, and rfc2420) are: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type = 3 | Length | Initial Nonce ... + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_dese(uchar_t *optdata, uint8_t size) +{ + (void) sprintf(get_line(0, 0), + "Initial Nonce = 0x%02x%02x%02x%02x%02x%02x%02x%02x", + optdata[0], optdata[1], optdata[2], optdata[3], optdata[4], + optdata[5], optdata[6], optdata[7]); +} + +/* + * The format of the PPPMux Default Protocol Id option + * (draft-ietf-pppext-pppmux-02.txt) is: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type = 1 | Length = 4 | Default PID | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +/*ARGSUSED1*/ +static void +opt_format_muxpid(uchar_t *optdata, uint8_t size) +{ + uint16_t defpid; + + GETINT16(defpid, optdata); + (void) sprintf(get_line(0, 0), "Default PID = %d", defpid); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.h new file mode 100644 index 0000000..0f158c5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_ppp.h @@ -0,0 +1,192 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ifndef _SNOOP_PPP_H +#define _SNOOP_PPP_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +/* + * Control Protocol (LCP, IPCP, etc.) message code numbers. + */ +#define CODE_VENDOR 0 /* Vendor Specif Code */ +#define CODE_CONFREQ 1 /* Configuration Request */ +#define CODE_CONFACK 2 /* Configuration Ack */ +#define CODE_CONFNAK 3 /* Configuration Nak */ +#define CODE_CONFREJ 4 /* Configuration Reject */ +#define CODE_TERMREQ 5 /* Termination Request */ +#define CODE_TERMACK 6 /* Termination Ack */ +#define CODE_CODEREJ 7 /* Code Reject */ +/* + * LCP specific codes. + */ +#define CODE_PROTREJ 8 /* Protocol Reject */ +#define CODE_ECHOREQ 9 /* Echo Request */ +#define CODE_ECHOREP 10 /* Echo Reply */ +#define CODE_DISCREQ 11 /* Discard Request */ +#define CODE_IDENT 12 /* Identification */ +#define CODE_TIMEREMAIN 13 /* Time Remaining */ +/* + * CCP and ECP specific codes. + */ +#define CODE_RESETREQ 14 +#define CODE_RESETACK 15 + +/* + * CHAP codes. + */ +#define CODE_CHALLENGE 1 +#define CODE_RESPONSE 2 +#define CODE_SUCCESS 3 +#define CODE_FAILURE 4 + +/* + * PAP codes. + */ +#define CODE_AUTHREQ 1 +#define CODE_AUTHACK 2 +#define CODE_AUTHNAK 3 + +/* + * Option types for various control protocols. + */ +#define OPT_LCP_VENDOR 0 +#define OPT_LCP_MRU 1 +#define OPT_LCP_ASYNCMAP 2 +#define OPT_LCP_AUTHTYPE 3 +#define OPT_LCP_QUALITY 4 +#define OPT_LCP_MAGICNUMBER 5 +#define OPT_LCP_PCOMPRESSION 7 +#define OPT_LCP_ACCOMPRESSION 8 +#define OPT_LCP_FCSALTERN 9 +#define OPT_LCP_SELFDESCPAD 10 +#define OPT_LCP_NUMBERED 11 +#define OPT_LCP_MULTILINKPROC 12 +#define OPT_LCP_CALLBACK 13 +#define OPT_LCP_CONNECTTIME 14 +#define OPT_LCP_COMPOUNDFRAMES 15 +#define OPT_LCP_DATAENCAP 16 +#define OPT_LCP_MRRU 17 +#define OPT_LCP_SSNHF 18 +#define OPT_LCP_EPDISC 19 +#define OPT_LCP_DCEIDENT 21 +#define OPT_LCP_MLPLUSPROC 22 +#define OPT_LCP_LINKDISC 23 +#define OPT_LCP_AUTH 24 +#define OPT_LCP_COBS 25 +#define OPT_LCP_PFXELISION 26 +#define OPT_LCP_MPHDRFMT 27 +#define OPT_LCP_I18N 28 +#define OPT_LCP_SDL 29 +#define OPT_LCP_MUXING 30 + +#define OPT_IPCP_ADDRS 1 +#define OPT_IPCP_COMPRESSTYPE 2 +#define OPT_IPCP_ADDR 3 +#define OPT_IPCP_MOBILEIPV4 4 +#define OPT_IPCP_DNS1 129 +#define OPT_IPCP_NBNS1 130 +#define OPT_IPCP_DNS2 131 +#define OPT_IPCP_NBNS2 132 +#define OPT_IPCP_SUBNET 144 + +#define OPT_IPV6CP_IFACEID 1 +#define OPT_IPV6CP_COMPRESSTYPE 2 + +#define OPT_CCP_PROPRIETARY 0 +#define OPT_CCP_PREDICTOR1 1 +#define OPT_CCP_PREDICTOR2 2 +#define OPT_CCP_PUDDLEJUMP 3 +#define OPT_CCP_HPPPC 16 +#define OPT_CCP_STACLZS 17 +#define OPT_CCP_MPPC 18 +#define OPT_CCP_GANDALFFZA 19 +#define OPT_CCP_V42BIS 20 +#define OPT_CCP_BSDCOMP 21 +#define OPT_CCP_LZSDCP 23 +#define OPT_CCP_MAGNALINK 24 +#define OPT_CCP_DEFLATE 26 + +#define OPT_ECP_PROPRIETARY 0 +#define OPT_ECP_DESE 1 +#define OPT_ECP_3DESE 2 +#define OPT_ECP_DESEBIS 3 + +#define OPT_MUXCP_DEFAULTPID 1 + +/* + * ppp_protoinfo_t's contain properties of PPP protocols which + * interpret_ppp() needs in order to properly decode the protocol data. + */ +typedef struct ppp_protoinfo { + uint16_t proto; /* protocol number */ + char *name; /* protocol name */ + int (*interpret_proto)(); /* interpret function */ + char *prefix; /* string printed on detail lines */ + char *description; /* string printed in detail header */ +} ppp_protoinfo_t; + + +/* + * cp_optinfo contains information on control protocol options. + */ +typedef void optformat_func_t(uchar_t *, uint8_t); +typedef struct cp_optinfo { + uint8_t opt_type; + char *opt_name; + uint8_t opt_minsize; /* min size of option, including type and len */ + optformat_func_t *opt_formatdata; +} cp_optinfo_t; + + +/* + * Packet format for PPP control and authentication protocols. + */ +typedef struct ppp_pkt { + uint8_t code; + uint8_t id; + uint16_t length; +} ppp_pkt_t; + +/* + * Structure of an LQR packet. + */ +typedef struct lqr_pkt { + uint32_t lqr_magic; + uint32_t lqr_lastoutlqrs; + uint32_t lqr_lastoutpackets; + uint32_t lqr_lastoutoctets; + uint32_t lqr_peerinlqrs; + uint32_t lqr_peerinpackets; + uint32_t lqr_peerindiscards; + uint32_t lqr_peerinerrors; + uint32_t lqr_peerinoctets; + uint32_t lqr_peeroutlqrs; + uint32_t lqr_peeroutpackets; + uint32_t lqr_peeroutoctets; +} lqr_pkt_t; + +#endif /* _SNOOP_PPP_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pppoe.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pppoe.c new file mode 100644 index 0000000..0939271 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_pppoe.c @@ -0,0 +1,399 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysmacros.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <net/pppoe.h> +#include "snoop.h" + +/* + * These two macros extract the version and type fields respectively from + * the first byte of the PPPoE header. + */ +#define POE_VERS(x) (((x) >> 4) & 0x0f) +#define POE_TYPE(x) ((x) & 0x0f) + +typedef void interpret_func_t(uint8_t *, uint16_t); + +typedef struct taginfo { + char *tag_name; + uint16_t tag_type; + interpret_func_t *interpret_tagvalue; +} taginfo_t; + + +static char *pppoe_codetoname(int, boolean_t); +static taginfo_t *pppoe_gettaginfo(uint16_t); +static void print_hexdata(char *, uint8_t *, uint16_t); +static void print_utf8string(char *, char *, uint16_t); +static char *print_linetag(char *); +static interpret_func_t interpret_tags; +static interpret_func_t interpret_hexdata; +static interpret_func_t interpret_service; +static interpret_func_t interpret_access; +static interpret_func_t interpret_cookie; +static interpret_func_t interpret_vendor; +static interpret_func_t interpret_relay; +static interpret_func_t interpret_error; +static interpret_func_t interpret_hurl; +static interpret_func_t interpret_motm; +static interpret_func_t interpret_rteadd; + + +static taginfo_t taginfo_array[] = { + { "End-Of-List", POETT_END, interpret_hexdata }, + { "Service-Name", POETT_SERVICE, interpret_service }, + { "AC-Name", POETT_ACCESS, interpret_access }, + { "Host-Uniq", POETT_UNIQ, interpret_hexdata }, + { "AC-Cookie", POETT_COOKIE, interpret_cookie }, + { "Vendor-Specific", POETT_VENDOR, interpret_vendor }, + { "Relay-Session-Id", POETT_RELAY, interpret_relay }, + { "Service-Name-Error", POETT_NAMERR, interpret_error }, + { "AC-System-Error", POETT_SYSERR, interpret_error }, + { "Generic-Error", POETT_GENERR, interpret_error }, + { "Multicast-Capable", POETT_MULTI, interpret_hexdata }, + { "Host-URL", POETT_HURL, interpret_hurl }, + { "Message-Of-The-Minute", POETT_MOTM, interpret_motm }, + { "IP-Route-Add", POETT_RTEADD, interpret_rteadd }, + { "Unknown TAG", 0, NULL } +}; + + +int +interpret_pppoe(int flags, poep_t *poep, int len) +{ + uint8_t code = poep->poep_code; + uint8_t *payload; + + if (len < sizeof (poep_t)) + return (len); + + payload = (uint8_t *)poep + sizeof (poep_t); + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), "PPPoE %s", + pppoe_codetoname(code, B_FALSE)); + } else { /* flags & F_DTAIL */ + show_header("PPPoE: ", "PPP Over Ethernet", len); + show_space(); + + (void) sprintf(get_line(0, 0), + "Version = %d", POE_VERS(poep->poep_version_type)); + + (void) sprintf(get_line(0, 0), + "Type = %d", POE_TYPE(poep->poep_version_type)); + + (void) sprintf(get_line(0, 0), + "Code = %d (%s)", code, pppoe_codetoname(code, B_TRUE)); + + (void) sprintf(get_line(0, 0), + "Session Id = %d", ntohs(poep->poep_session_id)); + + (void) sprintf(get_line(0, 0), + "Length = %d bytes", ntohs(poep->poep_length)); + + show_space(); + + len -= sizeof (poep_t); + len = MIN(len, ntohs(poep->poep_length)); + + if (poep->poep_code != 0 && poep->poep_length > 0) { + interpret_tags(payload, len); + } + } + + if (poep->poep_code == 0) { + return (interpret_ppp(flags, payload, len)); + } + return (len); +} + + +/* + * interpret_tags() prints PPPoE Discovery Stage TAGs in detail. + */ +static void +interpret_tags(uint8_t *payload, uint16_t length) +{ + uint8_t *tagptr = payload; + uint16_t tag_length; + uint16_t tag_type; + uint8_t *tag_value; + taginfo_t *tinfo; + + while (length >= POET_HDRLEN) { + tag_type = POET_GET_TYPE(tagptr); + tag_length = POET_GET_LENG(tagptr); + + tinfo = pppoe_gettaginfo(tag_type); + + show_header("PPPoE: ", tinfo->tag_name, + tag_length + POET_HDRLEN); + + (void) sprintf(get_line(0, 0), + "Tag Type = %d", tag_type); + + (void) sprintf(get_line(0, 0), + "Tag Length = %d bytes", tag_length); + + length -= POET_HDRLEN; + if (tag_length > length) { + (void) sprintf(get_line(0, 0), + "Warning: Truncated Packet"); + show_space(); + break; + } + + /* + * unknown tags or tags which should always have 0 length + * are not interpreted any further. + */ + tag_value = POET_DATA(tagptr); + if (tag_length != 0 && tinfo->interpret_tagvalue != NULL) + tinfo->interpret_tagvalue(tag_value, tag_length); + + show_space(); + length -= tag_length; + tagptr = POET_NEXT(tagptr); + } +} + +static char * +pppoe_codetoname(int code, boolean_t verbose) +{ + char *name; + + switch (code) { + case POECODE_DATA: + name = "Session"; + break; + case POECODE_PADO: + if (verbose) + name = "Active Discovery Offer"; + else + name = "PADO"; + break; + case POECODE_PADI: + if (verbose) + name = "Active Discovery Initiation"; + else + name = "PADI"; + break; + case POECODE_PADR: + if (verbose) + name = "Active Discovery Request"; + else + name = "PADR"; + break; + case POECODE_PADS: + if (verbose) + name = "Active Discovery Session-Confirmation"; + else + name = "PADS"; + break; + case POECODE_PADT: + if (verbose) + name = "Active Discovery Terminate"; + else + name = "PADT"; + break; + case POECODE_PADM: + if (verbose) + name = "Active Discovery Message"; + else + name = "PADM"; + break; + case POECODE_PADN: + if (verbose) + name = "Active Discovery Network"; + else + name = "PADN"; + break; + default: + name = "Unknown Code"; + } + + return (name); +} + +static taginfo_t * +pppoe_gettaginfo(uint16_t type) +{ + taginfo_t *taginfo_ptr = &taginfo_array[0]; + int i = 0; + + while (taginfo_ptr->tag_type != type && + taginfo_ptr->interpret_tagvalue != NULL) { + taginfo_ptr = &taginfo_array[++i]; + } + + return (taginfo_ptr); +} + +static void +interpret_hexdata(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("Data = "); + print_hexdata(endofline, tag_value, tag_length); +} + +static void +interpret_service(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("Service Name = "); + print_utf8string(endofline, (char *)tag_value, tag_length); +} + +static void +interpret_access(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("AC Name = "); + print_utf8string(endofline, (char *)tag_value, tag_length); +} + +static void +interpret_cookie(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("Cookie = "); + print_hexdata(endofline, tag_value, tag_length); +} + +static void +interpret_vendor(uint8_t *tag_value, uint16_t tag_length) +{ + uint8_t *vendor_data; + uint32_t vendorid; + char *endofline; + + vendorid = ntohl(*(uint32_t *)tag_value); + (void) sprintf(get_line(0, 0), + "Vendor ID = %d", vendorid); + + if (tag_length > 4) { + vendor_data = tag_value + 4; + endofline = print_linetag("Vendor Data = "); + print_hexdata(endofline, vendor_data, tag_length - 4); + } +} + +static void +interpret_relay(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("ID = "); + print_hexdata(endofline, tag_value, tag_length); +} + +static void +interpret_error(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("Error = "); + print_utf8string(endofline, (char *)tag_value, tag_length); +} + +static void +interpret_hurl(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("URL = "); + print_utf8string(endofline, (char *)tag_value, tag_length); +} + +static void +interpret_motm(uint8_t *tag_value, uint16_t tag_length) +{ + char *endofline; + + endofline = print_linetag("Message = "); + print_utf8string(endofline, (char *)tag_value, tag_length); +} + +static void +interpret_rteadd(uint8_t *tag_value, uint16_t tag_length) +{ + char dest[INET_ADDRSTRLEN]; + char mask[INET_ADDRSTRLEN]; + char gateway[INET_ADDRSTRLEN]; + uint32_t metric; + + if (tag_length == 16) { + (void) inet_ntop(AF_INET, tag_value, dest, + INET_ADDRSTRLEN); + (void) inet_ntop(AF_INET, &tag_value[4], mask, + INET_ADDRSTRLEN); + (void) inet_ntop(AF_INET, &tag_value[8], gateway, + INET_ADDRSTRLEN); + metric = ntohl(*(uint32_t *)&tag_value[12]); + sprintf(get_line(0, 0), + "Destination\tNetmask\tGateway\tMetric"); + sprintf(get_line(0, 0), + "%s\t%s\t%s\t%d", dest, mask, gateway, metric); + } +} + +static void +print_hexdata(char *line, uint8_t *data, uint16_t length) +{ + uint16_t index = 0; + + line += sprintf(line, "0x"); + + while (index < length) { + line += sprintf(line, "%02x", data[index++]); + } +} + +static void +print_utf8string(char *firstline, char *string, uint16_t length) +{ + (void) sprintf(firstline, "%.*s", length, string); +} + +static char * +print_linetag(char *string) +{ + char *line = get_line(0, 0); + return (line + sprintf(line, string)); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip.c new file mode 100644 index 0000000..c8a897c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip.c @@ -0,0 +1,440 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2006 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <string.h> +#include <strings.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#define RIPVERSION RIPv2 +#include <protocols/routed.h> +#include "snoop.h" + +static const char *show_cmd(int); +static int get_numtokens(unsigned int); +static const struct rip_sec_entry *rip_next_sec_entry( + const struct rip_sec_entry *, int); + +int +interpret_rip(int flags, struct rip *rip, int fraglen) +{ + const struct netinfo *nip; + const struct entryinfo *ep; + const struct netauth *nap; + const struct rip_sec_entry *rsep, *rsn; + const struct rip_emetric *rep; + const uint32_t *tokp; + int len, count; + const char *cmdstr, *auth; + struct in_addr dst; + uint32_t mval; + const struct sockaddr_in *sin; + /* Room for IP destination + "/" + IP mask */ + char addrstr[15+1+15+1]; + /* Room for "RIPv" + uint8_t as %d */ + char ripvers[4+3+1]; + + /* RIP header is 4 octets long */ + if ((len = fraglen - 4) < 0) + return (0); + + if (flags & F_SUM) { + switch (rip->rip_cmd) { + case RIPCMD_REQUEST: cmdstr = "C"; break; + case RIPCMD_RESPONSE: cmdstr = "R"; break; + case RIPCMD_TRACEON: cmdstr = "Traceon"; break; + case RIPCMD_TRACEOFF: cmdstr = "Traceoff"; break; + case RIPCMD_POLL: cmdstr = "Poll"; break; + case RIPCMD_POLLENTRY: cmdstr = "Poll entry"; break; + case RIPCMD_SEC_RESPONSE: cmdstr = "R - SEC"; break; + case RIPCMD_SEC_T_RESPONSE: cmdstr = "R - SEC_T"; break; + default: cmdstr = "?"; break; + } + + if (rip->rip_vers == RIPv1) + (void) strlcpy(ripvers, "RIP", sizeof (ripvers)); + else + (void) snprintf(ripvers, sizeof (ripvers), "RIPv%d", + rip->rip_vers); + + switch (rip->rip_cmd) { + case RIPCMD_REQUEST: + case RIPCMD_RESPONSE: + case RIPCMD_POLL: + nip = rip->rip_nets; + auth = ""; + if (len >= sizeof (*nip) && + nip->n_family == RIP_AF_AUTH) { + nap = (struct netauth *)nip; + len -= sizeof (*nip); + if (nap->a_type == RIP_AUTH_MD5 && + len >= ntohs(nap->au.a_md5.md5_auth_len)) + len -= ntohs(nap->au.a_md5. + md5_auth_len); + auth = " +Auth"; + } + count = len / sizeof (*nip); + len %= sizeof (*nip); + (void) snprintf(get_sum_line(), MAXLINE, + "%s %s (%d destinations%s%s)", ripvers, cmdstr, + count, (len != 0 ? "?" : ""), auth); + break; + + case RIPCMD_TRACEON: + case RIPCMD_TRACEOFF: + (void) snprintf(get_sum_line(), MAXLINE, + "%s %s File=\"%.*s\"", ripvers, cmdstr, len, + rip->rip_tracefile); + len = 0; + break; + + case RIPCMD_SEC_RESPONSE: + case RIPCMD_SEC_T_RESPONSE: + if (len < sizeof (rip->rip_tsol.rip_generation)) + break; + len -= sizeof (rip->rip_tsol.rip_generation); + count = 0; + rsep = rip->rip_tsol.rip_sec_entry; + while (len > 0) { + rsn = rip_next_sec_entry(rsep, len); + if (rsn == NULL) + break; + len -= (const char *)rsn - (const char *)rsep; + rsep = rsn; + count++; + } + (void) snprintf(get_sum_line(), MAXLINE, + "%s %s (%d destinations%s)", ripvers, cmdstr, + count, (len != 0 ? "?" : "")); + break; + + default: + (void) snprintf(get_sum_line(), MAXLINE, + "%s %d (%s)", ripvers, rip->rip_cmd, cmdstr); + len = 0; + break; + } + } + + if (flags & F_DTAIL) { + + len = fraglen - 4; + show_header("RIP: ", "Routing Information Protocol", fraglen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Opcode = %d (%s)", rip->rip_cmd, + show_cmd(rip->rip_cmd)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Version = %d", rip->rip_vers); + + switch (rip->rip_cmd) { + case RIPCMD_REQUEST: + case RIPCMD_RESPONSE: + case RIPCMD_POLL: + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination Next Hop " + "Tag Metric"); + for (nip = rip->rip_nets; len >= sizeof (*nip); nip++, + len -= sizeof (*nip)) { + if (nip->n_family == RIP_AF_AUTH) { + nap = (const struct netauth *)nip; + if (nap->a_type == RIP_AUTH_NONE) { + (void) snprintf(get_line + ((char *)nip - dlc_header, + sizeof (*nip)), + get_line_remain(), + " *** Auth None"); + } else if (nap->a_type == RIP_AUTH_PW) { + (void) snprintf(get_line + ((char *)nip - dlc_header, + sizeof (*nip)), + get_line_remain(), + " *** Auth PW \"%.*s\"", + RIP_AUTH_PW_LEN, + nap->au.au_pw); + } else if (nap->a_type == + RIP_AUTH_MD5) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " *** Auth MD5 pkt len %d, " + "keyid %d, sequence %08lX, " + "authlen %d", + ntohs(nap->au.a_md5. + md5_pkt_len), + nap->au.a_md5.md5_keyid, + (long)ntohl(nap->au.a_md5. + md5_seqno), + ntohs(nap->au.a_md5. + md5_auth_len)); + if (len - sizeof (*nip) >= + ntohs(nap->au.a_md5. + md5_auth_len)) + len -= ntohs(nap->au. + a_md5.md5_auth_len); + else + len = sizeof (*nip); + } else { + (void) snprintf(get_line + ((char *)nip - dlc_header, + sizeof (*nip)), + get_line_remain(), + " *** Auth Type %d?", + ntohs(nap->a_type)); + } + continue; + } + if (nip->n_family == RIP_AF_UNSPEC && + rip->rip_cmd == RIPCMD_REQUEST) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " *** All routes"); + continue; + } + if (nip->n_family != RIP_AF_INET) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + " *** Address Family %d?", + ntohs(nip->n_family)); + continue; + } + if (nip->n_dst == htonl(RIP_DEFAULT)) { + (void) strcpy(addrstr, "default"); + } else { + dst.s_addr = nip->n_dst; + (void) strlcpy(addrstr, inet_ntoa(dst), + sizeof (addrstr)); + } + if (nip->n_dst != htonl(RIP_DEFAULT) && + rip->rip_vers >= RIPv2) { + count = strlen(addrstr); + mval = ntohl(nip->n_mask); + /* LINTED */ + if (mval == INADDR_ANY) { + /* No mask */; + } else if ((mval + (mval & -mval)) == + 0) { + (void) snprintf(addrstr + count, + sizeof (addrstr) - count, + "/%d", 33 - ffs(mval)); + } else { + dst.s_addr = nip->n_mask; + (void) snprintf(addrstr + count, + sizeof (addrstr) - count, + "/%s", inet_ntoa(dst)); + } + } + dst.s_addr = nip->n_nhop; + mval = ntohl(nip->n_metric); + (void) snprintf(get_line(0, 0), + get_line_remain(), + "%-31s %-15s %-6d %d%s", + addrstr, + dst.s_addr == htonl(INADDR_ANY) ? + "--" : addrtoname(AF_INET, &dst), + ntohs(nip->n_tag), + mval, + (mval == HOPCNT_INFINITY ? + " (not reachable)" : "")); + } + break; + + case RIPCMD_POLLENTRY: + if (len < sizeof (*ep)) + break; + len -= sizeof (*ep); + ep = (const struct entryinfo *)rip->rip_nets; + /* LINTED */ + sin = (const struct sockaddr_in *)&ep->rtu_dst; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination = %s %s", + inet_ntoa(sin->sin_addr), + addrtoname(AF_INET, (void *)&sin->sin_addr)); + /* LINTED */ + sin = (const struct sockaddr_in *)&ep->rtu_router; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Router = %s %s", + inet_ntoa(sin->sin_addr), + addrtoname(AF_INET, (void *)&sin->sin_addr)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Flags = %4x", (unsigned)ep->rtu_flags); + (void) snprintf(get_line(0, 0), get_line_remain(), + "State = %d", ep->rtu_state); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Timer = %d", ep->rtu_timer); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Metric = %d", ep->rtu_metric); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Int flags = %8x", ep->int_flags); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Int name = \"%.*s\"", sizeof (ep->int_name), + ep->int_name); + break; + + case RIPCMD_SEC_RESPONSE: + case RIPCMD_SEC_T_RESPONSE: + if (len < sizeof (rip->rip_tsol.rip_generation)) + break; + len -= sizeof (rip->rip_tsol.rip_generation); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Generation = %u", + (unsigned)ntohl(rip->rip_tsol.rip_generation)); + rsep = rip->rip_tsol.rip_sec_entry; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Address E-METRIC"); + rsep = rip->rip_tsol.rip_sec_entry; + while (len > 0) { + char *cp; + int blen, num; + + rsn = rip_next_sec_entry(rsep, len); + if (rsn == NULL) + break; + dst.s_addr = rsep->rip_dst; + cp = get_line(0, 0); + blen = get_line_remain(); + (void) snprintf(cp, blen, "%-16s ", + inet_ntoa(dst)); + cp += 17; + blen -= 17; + rep = rsep->rip_emetric; + for (count = ntohl(rsep->rip_count); count > 0; + count--) { + (void) snprintf(cp, blen, "metric=%d", + ntohs(rep->rip_metric)); + blen -= strlen(cp); + cp += strlen(cp); + tokp = rep->rip_token; + num = get_numtokens( + ntohs(rep->rip_mask)); + /* advance to the next emetric */ + rep = (const struct rip_emetric *) + &rep->rip_token[num]; + if (num > 0) { + (void) snprintf(cp, blen, + ",tokens=%lx", + (long)ntohl(*tokp)); + tokp++; + num--; + } else { + (void) strlcpy(cp, ",no tokens", + blen); + } + while (num > 0) { + blen -= strlen(cp); + cp += strlen(cp); + (void) snprintf(cp, blen, + ",%lx", + (long)ntohl(*tokp)); + tokp++; + num--; + } + blen -= strlen(cp); + cp += strlen(cp); + } + if (rsep->rip_count == 0) { + (void) strlcpy(cp, + "NULL (not reachable)", blen); + } + len -= (const char *)rsn - (const char *)rsep; + rsep = rsn; + } + break; + + case RIPCMD_TRACEON: + case RIPCMD_TRACEOFF: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Trace file = %.*s", len, rip->rip_tracefile); + len = 0; + break; + } + } + + return (fraglen - len); +} + +static const char * +show_cmd(int c) +{ + switch (c) { + case RIPCMD_REQUEST: + return ("route request"); + case RIPCMD_RESPONSE: + return ("route response"); + case RIPCMD_TRACEON: + return ("route trace on"); + case RIPCMD_TRACEOFF: + return ("route trace off"); + case RIPCMD_POLL: + return ("route poll"); + case RIPCMD_POLLENTRY: + return ("route poll entry"); + case RIPCMD_SEC_RESPONSE: + return ("route sec response"); + case RIPCMD_SEC_T_RESPONSE: + return ("route sec_t response"); + } + return ("?"); +} + +static int +get_numtokens(unsigned int mask) +{ + int num = 0; + + while (mask != 0) { + num++; + mask &= mask - 1; + } + return (num); +} + +static const struct rip_sec_entry * +rip_next_sec_entry(const struct rip_sec_entry *rsep, int len) +{ + const struct rip_emetric *rep; + const char *limit = (const char *)rsep + len; + long count; + + if ((const char *)(rep = rsep->rip_emetric) > limit) + return (NULL); + count = ntohl(rsep->rip_count); + while (count > 0) { + if ((const char *)rep->rip_token > limit) + return (NULL); + rep = (struct rip_emetric *) + &rep->rip_token[get_numtokens(ntohs(rep->rip_mask))]; + if ((const char *)rep > limit) + return (NULL); + count--; + } + return ((const struct rip_sec_entry *)rep); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip6.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip6.c new file mode 100644 index 0000000..9f7b10e --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rip6.c @@ -0,0 +1,140 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <ctype.h> +#include <fcntl.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <inet/led.h> +#include <inet/ip6.h> +#include <arpa/inet.h> +#include <protocols/routed.h> +#include <protocols/ripngd.h> +#include "snoop.h" + +extern char *dlc_header; +static char *show_cmd6(); + +static struct in6_addr all_zeroes_addr = { { 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0 } }; + +int +interpret_rip6(int flags, struct rip6 *rip6, int fraglen) +{ + char *p; + struct netinfo6 *n; + int len, count; + struct in6_addr *dst; + int notdefault = 0; + char dststr[INET6_ADDRSTRLEN]; + + if (flags & F_SUM) { + switch (rip6->rip6_cmd) { + case RIPCMD6_REQUEST: p = "C"; break; + case RIPCMD6_RESPONSE: p = "R"; break; + default: p = "?"; break; + } + + switch (rip6->rip6_cmd) { + case RIPCMD6_REQUEST: + case RIPCMD6_RESPONSE: + len = fraglen - 4; + count = 0; + for (n = rip6->rip6_nets; + len >= sizeof (struct netinfo6); n++) { + count++; + len -= sizeof (struct netinfo6); + } + (void) sprintf(get_sum_line(), + "RIPng %s (%d destinations)", p, count); + break; + default: + (void) sprintf(get_sum_line(), "RIPng %s", p); + break; + } + } + + if (flags & F_DTAIL) { + + show_header("RIPng: ", "Routing Information Protocol for IPv6", + fraglen); + show_space(); + (void) sprintf(get_line((char *)(uintptr_t)rip6->rip6_cmd - + dlc_header, 1), "Opcode = %d (%s)", rip6->rip6_cmd, + show_cmd6(rip6->rip6_cmd)); + (void) sprintf(get_line((char *)(uintptr_t)rip6->rip6_vers - + dlc_header, 1), "Version = %d", rip6->rip6_vers); + + switch (rip6->rip6_cmd) { + case RIPCMD6_REQUEST: + case RIPCMD6_RESPONSE: + show_space(); + (void) sprintf(get_line(0, 0), "Address" + " Prefix Metric"); + len = fraglen - 4; + for (n = rip6->rip6_nets; + len >= sizeof (struct netinfo6); n++) { + if (rip6->rip6_vers > 0) { + n->rip6_metric = n->rip6_metric; + } + dst = &n->rip6_prefix; + notdefault = bcmp((caddr_t *)dst, + (caddr_t *)&all_zeroes_addr, sizeof (*dst)); + (void) inet_ntop(AF_INET6, (char *)dst, dststr, + INET6_ADDRSTRLEN); + (void) sprintf(get_line((char *)n - dlc_header, + sizeof (struct netinfo6)), + "%-30s %-10d %-5d %s", + notdefault ? dststr : + " (default)", n->rip6_prefix_length, + n->rip6_metric, n->rip6_metric == 16 ? + " (not reachable)":""); + len -= sizeof (struct netinfo); + } + break; + } + } + return (fraglen); +} + +static char * +show_cmd6(c) + int c; +{ + switch (c) { + case RIPCMD6_REQUEST: return ("route request"); + case RIPCMD6_RESPONSE: return ("route response"); + } + return ("?"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpc.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpc.c new file mode 100644 index 0000000..be39961 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpc.c @@ -0,0 +1,771 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> + +#include <netinet/in.h> +#include <netdb.h> + +#include <sys/tiuser.h> +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/auth_unix.h> +#include <rpc/auth_des.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpc/pmap_clnt.h> +#include <rpc/svc.h> +#include <rpcsvc/yp_prot.h> +#include <rpc/pmap_prot.h> +#include "snoop.h" + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +int pos; +struct cache_struct *find_xid(); +extern jmp_buf xdr_err; +void protoprint(); +void print_rpcsec_gss_cred(int xid, int authlen); +char *nameof_prog(); +char *nameof_astat(); +char *nameof_why(); +static void rpc_detail_call(int, int, int, int, int, int, char *, int); +static void rpc_detail_reply(int, int, struct cache_struct *, char *, int len); +static void print_creds(int); +static void print_verif(int); +static void stash_xid(ulong_t, int, int, int, int); + +#define LAST_FRAG ((ulong_t)1 << 31) + +int +interpret_rpc(int flags, char *rpc, int fraglen, int type) +{ + ulong_t xid; + int direction; + struct cache_struct *x; + int rpcvers, prog, vers, proc; + int status, astat, rstat, why; + char *lp; + unsigned recmark; + int markpos; + extern int pi_frame; + int lo, hi; + + xdr_init(rpc, fraglen); + + if (setjmp(xdr_err)) { + if (flags & F_DTAIL) + (void) sprintf(get_line(0, 0), + "---- short frame ---"); + return (fraglen); + } + + if (type == IPPROTO_TCP) { /* record mark */ + markpos = getxdr_pos(); + recmark = getxdr_long(); + } + + xid = getxdr_u_long(); + direction = getxdr_long(); + + if (direction == CALL) { + rpcvers = getxdr_long(); + pos = getxdr_pos(); + prog = getxdr_long(); + vers = getxdr_long(); + proc = getxdr_long(); + stash_xid(xid, pi_frame, prog, vers, proc); + if (!(flags & (F_SUM | F_DTAIL))) { + protoprint(flags, CALL, xid, prog, vers, proc, + rpc, fraglen); + } + } else { + x = find_xid(xid); + } + + if (flags & F_SUM) { + switch (direction) { + case CALL: + (void) sprintf(get_sum_line(), + "RPC C XID=%lu PROG=%d (%s) VERS=%d PROC=%d", + xid, + prog, nameof_prog(prog), + vers, proc); + if (getxdr_long() == RPCSEC_GSS) { /* Cred auth type */ + extract_rpcsec_gss_cred_info(xid); + /* RPCSEC_GSS cred auth data */ + } else { + xdr_skip(getxdr_long()); + /* non RPCSEC_GSS cred auth data */ + } + xdr_skip(4); /* Verf auth type */ + xdr_skip(RNDUP(getxdr_long())); /* Verf auth data */ + + protoprint(flags, CALL, xid, prog, vers, proc, + rpc, fraglen); + break; + + case REPLY: + lp = get_sum_line(); + if (x == NULL) + (void) sprintf(lp, "RPC R XID=%lu", xid); + else + (void) sprintf(lp, "RPC R (#%d) XID=%lu", + x->xid_frame, xid); + + lp += strlen(lp); + status = getxdr_long(); + switch (status) { + case MSG_ACCEPTED: + /* eat flavor and verifier */ + (void) getxdr_long(); + xdr_skip(RNDUP(getxdr_long())); + astat = getxdr_long(); + (void) sprintf(lp, " %s", + nameof_astat(astat)); + lp += strlen(lp); + + switch (astat) { + case SUCCESS: + if (x) { + protoprint(flags, REPLY, + xid, + x->xid_prog, + x->xid_vers, + x->xid_proc, + rpc, fraglen); + } + break; + + case PROG_UNAVAIL : + case PROG_MISMATCH: + case PROC_UNAVAIL : + lo = getxdr_long(); + hi = getxdr_long(); + (void) sprintf(lp, + " (low=%d, high=%d)", + lo, hi); + break; + + case GARBAGE_ARGS: + case SYSTEM_ERR: + default: + ; + } + break; + + case MSG_DENIED: + rstat = getxdr_long(); + + switch (rstat) { + case RPC_MISMATCH: + lo = getxdr_long(); + hi = getxdr_long(); + (void) sprintf(lp, + " Vers mismatch (low=%d, high=%d)", + lo, hi); + break; + + case AUTH_ERROR: + why = getxdr_u_long(); + (void) sprintf(lp, + " Can't authenticate (%s)", + nameof_why(why)); + break; + } + } + break; + } + } + + if (flags & F_DTAIL) { + show_header("RPC: ", "SUN RPC Header", fraglen); + show_space(); + if (type == IPPROTO_TCP) { /* record mark */ + (void) sprintf(get_line(markpos, markpos+4), + "Record Mark: %s fragment, length = %d", + recmark & LAST_FRAG ? "last" : "", + recmark & ~LAST_FRAG); + } + + (void) sprintf(get_line(0, 0), + "Transaction id = %lu", + xid); + (void) sprintf(get_line(0, 0), + "Type = %d (%s)", + direction, + direction == CALL ? "Call":"Reply"); + + switch (direction) { + case CALL: + rpc_detail_call(flags, xid, rpcvers, + prog, vers, proc, rpc, fraglen); + break; + case REPLY: + rpc_detail_reply(flags, xid, x, rpc, fraglen); + break; + } + } + + return (fraglen); +} + +static void +rpc_detail_call(int flags, int xid, int rpcvers, int prog, int vers, int proc, + char *data, int len) +{ + char *nameof_flavor(); + char *nameof_prog(); + + (void) sprintf(get_line(pos, getxdr_pos()), + "RPC version = %d", + rpcvers); + (void) sprintf(get_line(pos, getxdr_pos()), + "Program = %d (%s), version = %d, procedure = %d", + prog, nameof_prog(prog), vers, proc); + print_creds(xid); + print_verif(CALL); + show_trailer(); + protoprint(flags, CALL, xid, prog, vers, proc, data, len); +} + +char * +nameof_flavor(flavor) + int flavor; +{ + switch (flavor) { + case AUTH_NONE : return ("None"); + case AUTH_UNIX : return ("Unix"); + case AUTH_SHORT: return ("Unix short"); + case AUTH_DES : return ("DES"); + case RPCSEC_GSS: return ("RPCSEC_GSS"); + default: return ("unknown"); + } +} + +char * +tohex(char *p, int len) +{ + int i, j; + static char hbuff[1024]; + static char *hexstr = "0123456789ABCDEF"; + char toobig = 0; + + if (len * 2 > sizeof (hbuff)) { + toobig++; + len = sizeof (hbuff) / 2; + } + + j = 0; + for (i = 0; i < len; i++) { + hbuff[j++] = hexstr[p[i] >> 4 & 0x0f]; + hbuff[j++] = hexstr[p[i] & 0x0f]; + } + + if (toobig) { + hbuff[len * 2 - strlen("<Too Long>")] = '\0'; + strcat(hbuff, "<Too Long>"); + } else + hbuff[j] = '\0'; + + return (hbuff); +} + +static void +print_creds(int xid) +{ + int pos, flavor, authlen; + int uid, gid, len; + int tlen, idlen; + int i, namekind; + char *p, *line; + + pos = getxdr_pos(); + flavor = getxdr_long(); + authlen = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Credentials: Flavor = %d (%s), len = %d bytes", + flavor, nameof_flavor(flavor), authlen); + if (authlen <= 0) + return; + + switch (flavor) { + case AUTH_UNIX: + (void) showxdr_time(" Time = %s"); + (void) showxdr_string(MAX_MACHINE_NAME, " Hostname = %s"); + pos = getxdr_pos(); + uid = getxdr_u_long(); + gid = getxdr_u_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + " Uid = %d, Gid = %d", + uid, gid); + len = getxdr_u_long(); + line = get_line(pos, len * 4); + if (len == 0) + (void) sprintf(line, " Groups = (none)"); + else { + (void) sprintf(line, " Groups = "); + line += strlen(line); + while (len--) { + gid = getxdr_u_long(); + (void) sprintf(line, "%d ", gid); + line += strlen(line); + } + } + break; + + case AUTH_DES: + namekind = getxdr_u_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + " Name kind = %d (%s)", + namekind, + namekind == ADN_FULLNAME ? + "fullname" : "nickname"); + switch (namekind) { + case ADN_FULLNAME: + (void) showxdr_string(64, + " Network name = %s"); + (void) showxdr_hex(8, + " Conversation key = 0x%s (DES encrypted)"); + (void) showxdr_hex(4, + " Window = 0x%s (DES encrypted)"); + break; + + case ADN_NICKNAME: + (void) showxdr_hex(4, " Nickname = 0x%s"); + break; + }; + break; + + case RPCSEC_GSS: + print_rpcsec_gss_cred(xid, authlen); + break; + + default: + (void) showxdr_hex(authlen, "[%s]"); + break; + } +} + +static void +print_verif(int direction) +{ + int pos, flavor, verlen; + + pos = getxdr_pos(); + flavor = getxdr_long(); + verlen = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Verifier : Flavor = %d (%s), len = %d bytes", + flavor, nameof_flavor(flavor), verlen); + if (verlen == 0) + return; + + switch (flavor) { + case AUTH_DES: + (void) showxdr_hex(8, " Timestamp = 0x%s (DES encrypted)"); + if (direction == CALL) + (void) showxdr_hex(4, + " Window = 0x%s (DES encrypted)"); + else + (void) showxdr_hex(4, " Nickname = 0x%s"); + break; + + /* For other flavors like AUTH_NONE, AUTH_UNIX, RPCSEC_GSS etc. */ + default: + (void) showxdr_hex(verlen, "[%s]"); + break; + } +} + +struct rpcnames { + int rp_prog; + char *rp_name; +} rpcnames[] = { +100000, "PMAP", /* Portmapper */ +100001, "RSTAT", /* Remote stats */ +100002, "RUSERS", /* Remote users */ +100003, "NFS", /* Nfs */ +100004, "NIS", /* Network Information Service */ +100005, "MOUNT", /* Mount demon */ +100006, "DBX", /* Remote dbx */ +100007, "NISBIND", /* NIS binder */ +100008, "WALL", /* Shutdown msg */ +100009, "NISPASSWD", /* Yppasswd server */ +100010, "ETHERSTAT", /* Ether stats */ +100011, "RQUOTA", /* Disk quotas */ +100012, "SPRAY", /* Spray packets */ +100013, "IBM3270", /* 3270 mapper */ +100014, "IBMRJE", /* RJE mapper */ +100015, "SELNSVC", /* Selection service */ +100016, "RDATABASE", /* Remote database access */ +100017, "REX", /* Remote execution */ +100018, "ALICE", /* Alice Office Automation */ +100019, "SCHED", /* Scheduling service */ +100020, "LLM", /* Local lock manager */ +100021, "NLM", /* Network lock manager */ +100022, "X25INR", /* X.25 inr protocol */ +100023, "STATMON1", /* Status monitor 1 */ +100024, "STATMON2", /* Status monitor 2 */ +100025, "SELNLIB", /* Selection library */ +100026, "BOOTPARAM", /* Boot parameters service */ +100027, "MAZEPROG", /* Mazewars game */ +100028, "NISUPDATE", /* NIS update */ +100029, "KEYSERVE", /* Key server */ +100030, "SECURECMD", /* Secure login */ +100031, "NETFWDI", /* NFS net forwarder init */ +100032, "NETFWDT", /* NFS net forwarder trans */ +100033, "SUNLINKMAP", /* Sunlink MAP */ +100034, "NETMON", /* Network monitor */ +100035, "DBASE", /* Lightweight database */ +100036, "PWDAUTH", /* Password authorization */ +100037, "TFS", /* Translucent file svc */ +100038, "NSE", /* NSE server */ +100039, "NSE_ACTIVATE", /* NSE activate daemon */ +100040, "SUNVIEW_HELP", /* Sunview help */ +100041, "PNP", /* PNP install */ +100042, "IPADDR_ALLOC", /* IP addr allocator */ +100043, "FILEHANDLE", /* Show filehandle */ +100044, "MVSNFS", /* MVS NFS mount */ +100045, "REM_FILEOP_USER", /* Remote user file operations */ +100046, "BATCH_NISUPDATE", /* Batched ypupdate */ +100047, "NEM", /* Network execution mgr */ +100048, "RAYTRACE_RD", /* Raytrace/mandelbrot remote daemon */ +100049, "RAYTRACE_LD", /* Raytrace/mandelbrot local daemon */ +100050, "REM_FILEOP_GROUP", /* Remote group file operations */ +100051, "REM_FILEOP_SYSTEM", /* Remote system file operations */ +100052, "REM_SYSTEM_ROLE", /* Remote system role operations */ +100055, "IOADMD", /* Ioadmd */ +100056, "FILEMERGE", /* Filemerge */ +100057, "NAMEBIND", /* Name Binding Program */ +100058, "NJE", /* Sunlink NJE */ +100059, "MVSATTR", /* MVSNFS get attribute service */ +100060, "RMGR", /* SunAccess/SunLink resource manager */ +100061, "UIDALLOC", /* UID allocation service */ +100062, "LBSERVER", /* License broker */ +100063, "LBBINDER", /* NETlicense client binder */ +100064, "GIDALLOC", /* GID allocation service */ +100065, "SUNISAM", /* SunIsam */ +100066, "RDBSRV", /* Remote Debug Server */ +100067, "NETDIR", /* Network directory daemon */ +100068, "CMSD", /* Network calendar program */ +100069, "NISXFR", /* NIS transfer */ +100070, "TIMED", /* RPC.timed */ +100071, "BUGTRAQ", /* Bugtraqd */ +100072, "NeFS", /* Internal use only */ +100073, "BILLBOARD", /* Connectathon Billboard - NFS */ +100074, "BILLBOARD", /* Connectathon Billboard - X */ +100075, "SCHEDROOM", /* Sun meeting room scheduler */ +100076, "AUTHNEGOTIATE", /* Authentication negotiation */ +100077, "ATTRPROG", /* Database manipulation */ +100080, "AUTODUMP", /* Sun consulting special */ +100081, "EVENT_SVC", /* Event protocol */ +100085, "ARM_PSD", /* ARM policy */ +100086, "ARMTOD", /* ARM TOD */ +100087, "NA.ADMIN", /* Sun (SNAG) administration agent */ +100099, "PLD", /* Genesil 8.1 hot plot */ +100101, "NA.EVENT", /* SNM (SunNet Manager) event dispatcher */ +100102, "NA.LOGGER", /* SNM report logger */ +100103, "NA.DISCOVER", /* SNM network discovery agent */ +100104, "NA.SYNC", /* SNM sync interface agent */ +100105, "NA.DISKINFO", /* SNM disk info agent */ +100106, "NA.IOSTAT", /* SNM iostat agent */ +100107, "NA.HOSTPERF", /* SNM rstat proxy agent */ +100108, "NA.CONFIG", /* SNM host configuration agent */ +100109, "NA.ACTIVITY", /* SNM activity daemon */ +100111, "NA.LPSTAT", /* SNM printer agent */ +100112, "NA.HOSTMEM", /* SNM host network memory agent */ +100113, "NA.SAMPLE", /* SNM sample agent */ +100114, "NA.X25", /* SNM X.25 agent */ +100115, "NA.PING", /* SNM ping proxy agent */ +100116, "NA.RPCNFS", /* SNM rpc and nfs agent */ +100117, "NA.HOSTIF", /* SNM host interface agent */ +100118, "NA.ETHERIF", /* SNM ethernet interface agent */ +100119, "NA.IPPATH", /* SNM traceroute proxy agent */ +100120, "NA.IPROUTES", /* SNM routing table agent */ +100121, "NA.LAYERS", /* SNM protocol layers gent */ +100122, "NA.SNMP", /* SNM SNMP proxy agent */ +100123, "NA.TRAFFIC", /* SNM network traffic agent */ +100124, "NA.DNI", /* DNI (DECnet) proxy agent */ +100125, "NA.CHAT", /* IBM Channel attach proxy agent */ +100126, "NA.FDDI", /* FDDI agent */ +100127, "NA.FDDISMT", /* FDDI SMT proxy agent */ +100128, "NA.MHS", /* MHS agent */ +100130, "SNM_GRAPHER", /* SNM 3D grapher */ +100132, "NA.TR", /* Token Ring agent */ +100134, "NA.TOKENRING", /* Token Ring agent */ +100136, "NA.FRAMERELAY", /* Frame Relay agent */ +100175, "NA.SNMPTRAP", /* SNM SNMP trap daemon */ +100180, "NA.MIPROUTES", /* SNM multicast routing table agent */ +100201, "MVSNFSSTAT", /* MVS/NFS Memory usage statistic server */ +100227, "NFS_ACL", /* NFS ACL support */ +101002, "NSELINKTOOL", /* NSE link daemon */ +101003, "NSELINKAPP", /* NSE link application */ +110001, "GOLABEL", /* SunOS MLS */ +110002, "PUC", /* SunOS MLS */ +150001, "PCNFSD", /* PC passwd authorization */ +150002, "TOPS", /* TOPS name mapping */ +150003, "TOPS", /* TOPS external attribute storage */ +150004, "TOPS", /* TOPS hierarchical file system */ +150005, "TOPS", /* TOPS NFS transparency extensions */ +150006, "SOLARNET_FW", /* SolarNet Framework protocol */ +160001, "CM", /* Nihon Sun - Japanese Input system */ +300004, "FRAME 1", /* Frame program 1 */ +300009, "FRAME 2", /* Frame program 2 */ +390101, "RAP", /* Legato RAP protocol */ +390102, "RAPRD", /* Legato RAP resource dir protocol */ +500021, "ZNS", /* Zeus Network Service */ +}; + +int +compare(a, b) + register struct rpcnames *a, *b; +{ + return (a->rp_prog - b->rp_prog); +} + +char * +nameof_prog(prog) + int prog; +{ + struct rpcnames *r; + struct rpcnames *bsearch(); + int elems = sizeof (rpcnames) / sizeof (*r); + + r = bsearch(&prog, rpcnames, elems, sizeof (*r), compare); + if (r) + return (r->rp_name); + + if (prog >= 0x40000000 && prog <= 0x5fffffff) + return ("transient"); + + return ("?"); +} + +char * +nameof_astat(status) + int status; +{ + switch (status) { + case SUCCESS : return ("Success"); + case PROG_UNAVAIL : return ("Program unavailable"); + case PROG_MISMATCH: return ("Program number mismatch"); + case PROC_UNAVAIL : return ("Procedure unavailable"); + case GARBAGE_ARGS : return ("Garbage arguments"); + case SYSTEM_ERR : return ("System error"); + default: return ("unknown"); + } +} + +char * +nameof_why(why) + int why; +{ + switch (why) { + case AUTH_BADCRED: return ("bogus credentials (seal broken)"); + case AUTH_REJECTEDCRED: return ("client should begin new session"); + case AUTH_BADVERF: return ("bogus verifier (seal broken)"); + case AUTH_REJECTEDVERF: return ("verifier expired or was replayed"); + case AUTH_TOOWEAK: return ("too weak"); + case AUTH_INVALIDRESP: return ("bogus response verifier"); + case AUTH_TIMEEXPIRE: return ("time of credential expired"); + case AUTH_TKT_FILE: return ("something wrong with ticket file"); + case AUTH_DECODE: return ("can't decode authenticator"); + case AUTH_NET_ADDR: return ("net address in ticket wrong"); + case RPCSEC_GSS_NOCRED: return ("no credentials for user"); + case RPCSEC_GSS_FAILED: return ("GSS failure, credentials deleted"); + case AUTH_FAILED: + default: + return ("unknown reason"); + } +} + +static void +rpc_detail_reply(int flags, int xid, struct cache_struct *x, char *data, + int len) +{ + int status; + int astat, rstat, why; + int pos; + + if (x) { + (void) sprintf(get_line(0, 0), + "This is a reply to frame %d", + x->xid_frame); + } + pos = getxdr_pos(); + status = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Status = %d (%s)", + status, status ? "Denied" : "Accepted"); + + switch (status) { + case MSG_ACCEPTED: + print_verif(REPLY); + pos = getxdr_pos(); + astat = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Accept status = %d (%s)", + astat, nameof_astat(astat)); + + switch (astat) { + case SUCCESS: + if (x) { + show_trailer(); + protoprint(flags, REPLY, xid, + x->xid_prog, x->xid_vers, x->xid_proc, + data, len); + } + break; + case PROG_UNAVAIL : + break; + case PROG_MISMATCH: + case PROC_UNAVAIL : + showxdr_long(" Low = %d"); + showxdr_long(" High = %d"); + break; + case GARBAGE_ARGS: + case SYSTEM_ERR: + default: + ; + } + + break; + + case MSG_DENIED: + pos = getxdr_pos(); + rstat = getxdr_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + "Reject status = %d (%s)", + rstat, + rstat ? "can't authenticate" + : "version mismatch"); + + switch (rstat) { + case RPC_MISMATCH: + showxdr_long(" Low = %d"); + showxdr_long(" High = %d"); + break; + case AUTH_ERROR: + why = getxdr_u_long(); + (void) sprintf(get_line(pos, getxdr_pos()), + " Why = %d (%s)", + why, nameof_why(why)); + break; + } + break; + } +} + +/* + * Return true if this is a valid RPC packet + */ +int +valid_rpc(char *rpc, int rpclen) +{ + XDR xdrm; + struct rpc_msg msg; + + if (rpclen < 12) + return (0); + + xdrmem_create(&xdrm, rpc, rpclen, XDR_DECODE); + if (xdr_u_int(&xdrm, &msg.rm_xid) && + xdr_u_int(&xdrm, (uint_t *)&msg.rm_direction)) { + switch (msg.rm_direction) { + case CALL: + if (xdr_rpcvers(&xdrm, &msg.rm_call.cb_rpcvers) && + msg.rm_call.cb_rpcvers == 2) + return (1); + break; + case REPLY: + if (xdr_u_int(&xdrm, + (uint_t *)&msg.rm_reply.rp_stat) && + (msg.rm_reply.rp_stat == MSG_ACCEPTED || + msg.rm_reply.rp_stat == MSG_DENIED)) + return (1); + break; + } + } + + return (0); +} + +struct cache_struct *xcpfirst = &xid_cache[0]; +struct cache_struct *xcp = &xid_cache[0]; +struct cache_struct *xcplast = &xid_cache[XID_CACHE_SIZE - 1]; + +struct cache_struct * +find_xid(xid) + ulong_t xid; +{ + struct cache_struct *x; + + for (x = xcp; x >= xcpfirst; x--) + if (x->xid_num == xid) + return (x); + for (x = xcplast; x > xcp; x--) + if (x->xid_num == xid) + return (x); + return (NULL); +} + +static void +stash_xid(ulong_t xid, int frame, int prog, int vers, int proc) +{ + struct cache_struct *x; + + x = find_xid(xid); + if (x == NULL) { + x = xcp++; + if (xcp > xcplast) + xcp = xcpfirst; + x->xid_num = xid; + x->xid_frame = frame; + } + x->xid_prog = prog; + x->xid_vers = vers; + x->xid_proc = proc; + x->xid_gss_proc = RPCSEC_GSS_DATA; + x->xid_gss_service = rpc_gss_svc_default; +} + +void +check_retransmit(line, xid) + char *line; + ulong_t xid; +{ + struct cache_struct *x; + extern int pi_frame; + + x = find_xid(xid); + if (x && x->xid_frame != pi_frame) + (void) strcat(line, " (retransmit)"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcprint.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcprint.c new file mode 100644 index 0000000..8d61536 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcprint.c @@ -0,0 +1,106 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <string.h> +#include <sys/types.h> +#include <sys/tiuser.h> +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include "snoop.h" + +#define RPC_TRANSIENT_START 0x40000000 +#define RPC_TRANSIENT_END 0x5fffffff + +int rpcsec_gss_control_proc(int type, int flags, int xid); + +int rpcsec_gss_pre_proto(int type, int flags, int xid, + int prog, int vers, int proc); + +void rpcsec_gss_post_proto(int flags, int xid); + +void +protoprint(flags, type, xid, prog, vers, proc, data, len) + ulong_t xid; + int flags, type, prog, vers, proc; + char *data; + int len; +{ + char *name; + void (*interpreter)(int, int, int, int, int, char *, int); + + switch (prog) { + case 100000: interpreter = interpret_pmap; break; + case 100001: interpreter = interpret_rstat; break; + case 100003: interpreter = interpret_nfs; break; + case 100004: interpreter = interpret_nis; break; + case 100005: interpreter = interpret_mount; break; + case 100007: interpreter = interpret_nisbind; break; + case 100011: interpreter = interpret_rquota; break; + case 100021: interpreter = interpret_nlm; break; + case 100026: interpreter = interpret_bparam; break; + case 100227: interpreter = interpret_nfs_acl; break; + case 150006: interpreter = interpret_solarnet_fw; break; + default: interpreter = NULL; + } + + /* + * if rpc in transient range and proc is 0 or 1, then + * guess that it is the nfsv4 callback protocol + */ + if (prog >= RPC_TRANSIENT_START && prog <= RPC_TRANSIENT_END && + (proc == 0 || proc == 1)) + interpreter = interpret_nfs4_cb; + + /* + * If the RPC header indicates it's using the RPCSEC_GSS_* + * control procedure, print it. + */ + if (rpcsec_gss_control_proc(type, flags, xid)) { + return; + } + + if (interpreter == NULL) { + if (!(flags & F_SUM)) + return; + name = nameof_prog(prog); + if (*name == '?' || strcmp(name, "transient") == 0) + return; + (void) sprintf(get_sum_line(), "%s %c", + name, + type == CALL ? 'C' : 'R'); + } else { + /* Pre-processing based on different RPCSEC_GSS services. */ + if (rpcsec_gss_pre_proto(type, flags, xid, prog, vers, proc)) + return; + + (*interpreter) (flags, type, xid, vers, proc, data, len); + + /* Post-processing based on different RPCSEC_GSS services. */ + rpcsec_gss_post_proto(flags, xid); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcsec.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcsec.c new file mode 100644 index 0000000..e3579dc --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rpcsec.c @@ -0,0 +1,403 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * Copyright 2012 Milan Jurik. All rights reserved. + */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <sys/tiuser.h> +#include <setjmp.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpc/rpcsec_gss.h> +#include <string.h> +#include "snoop.h" + +extern jmp_buf xdr_err; + +struct cache_struct *find_xid(); +char *nameof_prog(int prog); +static void print_rpc_gss_init_arg(int, struct cache_struct *); +static void print_rpc_gss_init_res(int); + +char * +rpcsec_gss_proc_to_string(unsigned int proc) +{ + switch (proc) { + case RPCSEC_GSS_DATA: return "RPCSEC_GSS_DATA"; break; + case RPCSEC_GSS_INIT: return "RPCSEC_GSS_INIT"; break; + case RPCSEC_GSS_CONTINUE_INIT: + return ("RPCSEC_GSS_CONTINUE_INIT"); + case RPCSEC_GSS_DESTROY: + return ("RPCSEC_GSS_DESTROY"); + default: return ("unknown"); + + } +} + + +char * +rpcsec_gss_service_to_string(rpc_gss_service_t service) +{ + switch (service) { + case rpc_gss_svc_none: return "none"; break; + case rpc_gss_svc_integrity: return "integrity"; break; + case rpc_gss_svc_privacy: return "privacy"; break; + default: return "unknown"; break; + + } +} + +/* + * Print detailed RPCSEC_GSS cred data. + */ +void +print_rpcsec_gss_cred(int xid, int authlen) +{ + unsigned int seq_num; + unsigned int handle_len; + unsigned int rpcsec_gss_ver; + rpc_gss_service_t rpcsec_gss_service; + unsigned int rpcsec_gss_proc; + char *handle, *line; + struct cache_struct *x; + int pos; + + pos = getxdr_pos(); + rpcsec_gss_ver = getxdr_u_long(); + + /* see if we know this version or not */ + + if (rpcsec_gss_ver != 1) { + (void) showxdr_hex(authlen, "[%s]"); + return; + } + + rpcsec_gss_proc = getxdr_u_long(); + seq_num = getxdr_u_long(); + rpcsec_gss_service = getxdr_enum(); + + (void) sprintf(get_line(pos, getxdr_pos()), + " version = %u", rpcsec_gss_ver); + + (void) sprintf(get_line(pos, getxdr_pos()), + " gss control procedure = %u (%s)", + rpcsec_gss_proc, + rpcsec_gss_proc_to_string(rpcsec_gss_proc)); + + (void) sprintf(get_line(pos, getxdr_pos()), + " sequence num = %u", seq_num); + + (void) sprintf(get_line(pos, getxdr_pos()), + " service = %d (%s)", rpcsec_gss_service, + rpcsec_gss_service_to_string(rpcsec_gss_service)); + pos = getxdr_pos(); + handle_len = getxdr_u_long(); + handle = getxdr_hex(handle_len); + line = get_line(pos, getxdr_pos()); + sprintf(line, " handle: length = %d, data = [%s]", + handle_len, handle); + x = find_xid(xid); + if (x) { + x->xid_gss_proc = rpcsec_gss_proc; + x->xid_gss_service = rpcsec_gss_service; + } +} + +/* + * Based on different RPCSEC_GSS services supported, maybe a + * special handling is needed before printing the arguments. + * + * For integrity service : print the sequence number. + * For privacy service : do not print the arguments. + */ +int +rpcsec_gss_pre_proto(int type, int flags, int xid, + int prog, int vers, int proc) +{ + int seq; + struct cache_struct *x; + + if (! (x = find_xid(xid))) + return (0); + + switch (x->xid_gss_service) { + case rpc_gss_svc_default: + case rpc_gss_svc_none: + break; /* standard call args */ + case rpc_gss_svc_integrity: + /* length of rpc_gss_data_t encoded in the databody_integ */ + getxdr_u_long(); + /* read the seq number */ + seq = getxdr_u_long(); + if (flags & F_ALLSUM) { + (void) sprintf(get_sum_line(), "%s %c seq_num = %u", + "RPC RPCSEC_GSS", type == CALL ? 'C' : 'R', + seq); + } else if (flags & F_DTAIL) { + sprintf(get_line(0, 0), + "RPCSEC_GSS data seq_num = %u", seq); + show_space(); + } + /* call args follow */ + break; + case rpc_gss_svc_privacy: { + char *progname = nameof_prog(prog); + char prognum[32]; + + if (*progname == '?') { + sprintf(prognum, "%d", prog); + progname = prognum; + } + + if (flags & F_SUM || flags & F_ALLSUM) { + (void) sprintf(get_sum_line(), + "%s %c %s ver(%d) proc(%d) (data encrypted) ", + "RPC RPCSEC_GSS", type == CALL ? 'C' : 'R', + progname, vers, proc); + } else if (flags & F_DTAIL) { + unsigned int args_len; + + args_len = getxdr_u_long(); + sprintf(get_line(0, 0), + "RPCSEC_GSS %s ver(%d) proc(%d)", + progname, vers, proc); + sprintf(get_line(0, 0), + "(%s args encrypted, len = %d bytes)", + type == CALL ? "CALL" : "REPLY", args_len); + show_space(); + } + } + return (1); + + default: + break; + } + return (0); +} + +/* + * Based on different RPCSEC_GSS services supported, maybe a + * special handling is needed after printing the arguments. + * + * For integrity service : print the checksum. + */ +void +rpcsec_gss_post_proto(int flags, int xid) +{ + char *line; + + struct cache_struct *x; + + if (! (x = find_xid(xid))) + return; + + switch (x->xid_gss_service) { + case rpc_gss_svc_default: + case rpc_gss_svc_none: + case rpc_gss_svc_privacy: + /* nothing left */ + break; + case rpc_gss_svc_integrity: + if (flags & F_ALLSUM) { + line = get_sum_line(); + sprintf(line, "RPC RPCSEC_GSS C (checksum)"); + } else if (flags & F_DTAIL) { + unsigned int checksum_len; + char *checksum; + + show_header("RPC: ", "RPCSEC_GSS", 0); + show_space(); + checksum_len = getxdr_u_long(); + checksum = getxdr_hex(checksum_len); + sprintf(get_line(0, 0), + "checksum: len = %d", checksum_len); + sprintf(get_line(0, 0), "[%s]", checksum); + show_trailer(); + } + break; + default: + break; + } +} + +/* + * Print RPCSEC_GSS control procedures protocol data, + * No-op for RPCSEC_GSS_DATA. + */ +int +rpcsec_gss_control_proc(int type, int flags, int xid) +{ + int seq; + + struct cache_struct *x; + + if (! (x = find_xid(xid))) + return (0); + + if (x->xid_gss_proc != RPCSEC_GSS_DATA) { + if (flags & F_SUM) { + if (type == CALL) { + (void) sprintf(get_sum_line(), "%s %c %u (%s)", + "RPC RPCSEC_GSS", + type == CALL ? 'C' : 'R', + x->xid_gss_proc, + rpcsec_gss_proc_to_string(x->xid_gss_proc)); + } + } else if (flags & F_DTAIL) { + if (x->xid_gss_proc == RPCSEC_GSS_INIT || + x->xid_gss_proc == RPCSEC_GSS_CONTINUE_INIT) { + if (type == CALL) { + print_rpc_gss_init_arg(flags, x); + } else { + print_rpc_gss_init_res(flags); + } + } + } + return (1); + } + + return (0); +} + +/* + * Skip the header RPCSEC_GSS cred data and + * put service and control type in the xid cache. + */ +void +extract_rpcsec_gss_cred_info(int xid) +{ + unsigned int seq_num; + unsigned int handle_len; + unsigned int flavor_len; + unsigned int rpcsec_gss_ver; + rpc_gss_service_t rpcsec_gss_service; + unsigned int rpcsec_gss_proc; + struct cache_struct *x; + + flavor_len = getxdr_u_long(); + rpcsec_gss_ver = getxdr_u_long(); + /* see if we know this version or not */ + if (rpcsec_gss_ver != 1) { + longjmp(xdr_err, 1); + } + rpcsec_gss_proc = getxdr_u_long(); + seq_num = getxdr_u_long(); + rpcsec_gss_service = getxdr_enum(); + /* skip the handle */ + xdr_skip(RNDUP(getxdr_u_long())); + + if (x = find_xid(xid)) { + x->xid_gss_service = rpcsec_gss_service; + x->xid_gss_proc = rpcsec_gss_proc; + } + +} + +/* + * Print the argument data for the RPCSEC_GSS_INIT control procedure. + */ +static void +print_rpc_gss_init_arg(int flags, struct cache_struct *x) +{ + + char *token, *line; + unsigned int token_len; + int pos = 0; + + /* + * see if we need to print out the rpc_gss_init_arg structure + * or not. + */ + + if (x->xid_gss_proc != RPCSEC_GSS_INIT && + x->xid_gss_proc != RPCSEC_GSS_CONTINUE_INIT) { + return; + } + + /* print it */ + + (void) sprintf(get_line(pos, getxdr_pos()), + "RPCSEC_GSS_INIT args:"); + + pos = getxdr_pos(); + token_len = getxdr_u_long(); + token = getxdr_hex(token_len); + line = get_line(pos, getxdr_pos()); + sprintf(line, " gss token: length = %d, data = [%d bytes]", + token_len, token_len); + + show_trailer(); +} + +/* + * Print the results data for the RPCSEC_GSS_INIT control procedure. + */ +void +print_rpc_gss_init_res(int flags) +{ + + char *handle, *token, *line; + unsigned int token_len, handle_len; + unsigned int major, minor, seq_window; + + int pos = 0; + struct cache_struct *x; + + /* print it */ + + (void) sprintf(get_line(pos, getxdr_pos()), "RPCSEC_GSS_INIT result:"); + + pos = getxdr_pos(); + handle_len = getxdr_u_long(); + handle = getxdr_hex(handle_len); + line = get_line(pos, getxdr_pos()); + sprintf(line, " handle: length = %d, data = [%s]", + handle_len, handle); + pos = getxdr_pos(); + major = getxdr_u_long(); + minor = getxdr_u_long(); + seq_window = getxdr_u_long(); + + (void) sprintf(get_line(pos, getxdr_pos()), + " gss_major status = %u", major); + + (void) sprintf(get_line(pos, getxdr_pos()), + " gss_minor status = %u", minor); + + (void) sprintf(get_line(pos, getxdr_pos()), + " sequence window = %u", seq_window); + pos = getxdr_pos(); + token_len = getxdr_u_long(); + token = getxdr_hex(token_len); + line = get_line(pos, getxdr_pos()); + sprintf(line, " gss token: length = %d, data = [%d bytes]", + token_len, token_len); + show_trailer(); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rport.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rport.c new file mode 100644 index 0000000..b84ee3c --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rport.c @@ -0,0 +1,452 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <strings.h> +#include <sys/sysmacros.h> +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <sys/socket.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include "snoop.h" + +struct porttable { + int pt_num; + char *pt_short; +}; + +static const struct porttable pt_udp[] = { + { IPPORT_ECHO, "ECHO" }, + { IPPORT_DISCARD, "DISCARD" }, + { IPPORT_DAYTIME, "DAYTIME" }, + { IPPORT_CHARGEN, "CHARGEN" }, + { IPPORT_TIMESERVER, "TIME" }, + { IPPORT_NAMESERVER, "NAME" }, + { IPPORT_DOMAIN, "DNS" }, + { IPPORT_MDNS, "MDNS" }, + { IPPORT_BOOTPS, "BOOTPS" }, + { IPPORT_BOOTPC, "BOOTPC" }, + { IPPORT_TFTP, "TFTP" }, + { IPPORT_FINGER, "FINGER" }, +/* { 111, "PORTMAP" }, Just Sun RPC */ + { IPPORT_NTP, "NTP" }, + { IPPORT_NETBIOS_NS, "NBNS" }, + { IPPORT_NETBIOS_DGM, "NBDG" }, + { IPPORT_LDAP, "LDAP" }, + { IPPORT_SLP, "SLP" }, +/* Mobile IP defines a set of new control messages sent over UDP port 434 */ + { IPPORT_MIP, "Mobile IP" }, + { IPPORT_BIFFUDP, "BIFF" }, + { IPPORT_WHOSERVER, "WHO" }, + { IPPORT_SYSLOG, "SYSLOG" }, + { IPPORT_TALK, "TALK" }, + { IPPORT_ROUTESERVER, "RIP" }, + { IPPORT_RIPNG, "RIPng" }, + { IPPORT_DHCPV6C, "DHCPv6C" }, + { IPPORT_DHCPV6S, "DHCPv6S" }, + { 550, "NEW-RWHO" }, + { 560, "RMONITOR" }, + { 561, "MONITOR" }, + { IPPORT_SOCKS, "SOCKS" }, + { 0, NULL } +}; + +static struct porttable pt_tcp[] = { + { 1, "TCPMUX" }, + { IPPORT_ECHO, "ECHO" }, + { IPPORT_DISCARD, "DISCARD" }, + { IPPORT_SYSTAT, "SYSTAT" }, + { IPPORT_DAYTIME, "DAYTIME" }, + { IPPORT_NETSTAT, "NETSTAT" }, + { IPPORT_CHARGEN, "CHARGEN" }, + { 20, "FTP-DATA" }, + { IPPORT_FTP, "FTP" }, + { IPPORT_TELNET, "TELNET" }, + { IPPORT_SMTP, "SMTP" }, + { IPPORT_TIMESERVER, "TIME" }, + { 39, "RLP" }, + { IPPORT_NAMESERVER, "NAMESERVER" }, + { IPPORT_WHOIS, "NICNAME" }, + { IPPORT_DOMAIN, "DNS" }, + { 70, "GOPHER" }, + { IPPORT_RJE, "RJE" }, + { IPPORT_FINGER, "FINGER" }, + { IPPORT_HTTP, "HTTP" }, + { IPPORT_TTYLINK, "LINK" }, + { IPPORT_SUPDUP, "SUPDUP" }, + { 101, "HOSTNAME" }, + { 102, "ISO-TSAP" }, + { 103, "X400" }, + { 104, "X400-SND" }, + { 105, "CSNET-NS" }, + { 109, "POP-2" }, +/* { 111, "PORTMAP" }, Just Sun RPC */ + { 113, "AUTH" }, + { 117, "UUCP-PATH" }, + { 119, "NNTP" }, + { IPPORT_NTP, "NTP" }, + { IPPORT_NETBIOS_SSN, "NBT" }, + { 143, "IMAP" }, + { 144, "NeWS" }, + { IPPORT_LDAP, "LDAP" }, + { IPPORT_SLP, "SLP" }, + { 443, "HTTPS" }, + { 445, "SMB" }, + { IPPORT_EXECSERVER, "EXEC" }, + { IPPORT_LOGINSERVER, "RLOGIN" }, + { IPPORT_CMDSERVER, "RSHELL" }, + { IPPORT_PRINTER, "PRINTER" }, + { 530, "COURIER" }, + { 540, "UUCP" }, + { 600, "PCSERVER" }, + { IPPORT_SOCKS, "SOCKS" }, + { 1524, "INGRESLOCK" }, + { 2904, "M2UA" }, + { 2905, "M3UA" }, + { 6000, "XWIN" }, + { IPPORT_HTTP_ALT, "HTTP (proxy)" }, + { 9900, "IUA" }, + { 0, NULL }, +}; + +char * +getportname(int proto, in_port_t port) +{ + const struct porttable *p, *pt; + + switch (proto) { + case IPPROTO_SCTP: /* fallthru */ + case IPPROTO_TCP: pt = pt_tcp; break; + case IPPROTO_UDP: pt = pt_udp; break; + default: return (NULL); + } + + for (p = pt; p->pt_num; p++) { + if (port == p->pt_num) + return (p->pt_short); + } + return (NULL); +} + +int +reservedport(int proto, int port) +{ + const struct porttable *p, *pt; + + switch (proto) { + case IPPROTO_TCP: pt = pt_tcp; break; + case IPPROTO_UDP: pt = pt_udp; break; + default: return (NULL); + } + for (p = pt; p->pt_num; p++) { + if (port == p->pt_num) + return (1); + } + return (0); +} + +/* + * Need to be able to register an + * interpreter for transient ports. + * See TFTP interpreter. + */ +#define MAXTRANS 64 +static struct ttable { + int t_port; + int (*t_proc)(int, char *, int); +} transients [MAXTRANS]; + +int +add_transient(int port, int (*proc)(int, char *, int)) +{ + static struct ttable *next = transients; + + next->t_port = port; + next->t_proc = proc; + + if (++next >= &transients[MAXTRANS]) + next = transients; + + return (1); +} + +static struct ttable * +is_transient(int port) +{ + struct ttable *p; + + for (p = transients; p->t_port && p < &transients[MAXTRANS]; p++) { + if (port == p->t_port) + return (p); + } + + return (NULL); +} + +void +del_transient(int port) +{ + struct ttable *p; + + for (p = transients; p->t_port && p < &transients[MAXTRANS]; p++) { + if (port == p->t_port) + p->t_port = -1; + } +} + +static void +interpret_syslog(int flags, char dir, int port, const char *syslogstr, + int dlen) +{ + static const char *pris[] = { + "emerg", "alert", "crit", "error", "warn", "notice", "info", "debug" + }; + static const char *facs[] = { + "kern", "user", "mail", "daemon", "auth", "syslog", "lpr", "news", + "uucp", NULL, NULL, NULL, NULL, "audit", NULL, "cron", "local0", + "local1", "local2", "local3", "local4", "local5", "local6", "local7" + }; + + int composit; + int pri = -1; + int facil = -1; + boolean_t bogus = B_TRUE; + int priostrlen = 0; + int datalen = dlen; + char unknown[4]; /* for unrecognized ones */ + const char *facilstr = "BAD"; + const char *pristr = "FMT"; + const char *data = syslogstr; + + /* + * Is there enough data to interpret (left bracket + at least 3 chars + * which could be digits, right bracket, or space)? + */ + if (datalen >= 4 && data != NULL) { + if (*data == '<') { + const int FACS_LEN = sizeof (facs) / sizeof (facs[0]); + char buffer[4]; + char *end; + + data++; + datalen--; + + (void) strlcpy(buffer, data, sizeof (buffer)); + composit = strtoul(buffer, &end, 0); + data += end - buffer; + if (*data == '>') { + data++; + datalen -= end - buffer + 1; + + pri = composit & 0x7; + facil = (composit & 0xF8) >> 3; + + if ((facil >= FACS_LEN) || + (facs[facil] == NULL)) { + snprintf(unknown, sizeof (unknown), + "%d", facil); + facilstr = unknown; + } else { + facilstr = facs[facil]; + } + pristr = pris[pri]; + priostrlen = dlen - datalen; + bogus = B_FALSE; + } else { + data = syslogstr; + datalen = dlen; + } + } + } + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "SYSLOG %c port=%d %s.%s: %s", + dir, port, facilstr, pristr, + show_string(syslogstr, dlen, 20)); + + } + + if (flags & F_DTAIL) { + static char syslog[] = "SYSLOG: "; + show_header(syslog, syslog, dlen); + show_space(); + (void) snprintf(get_detail_line(0, 0), MAXLINE, + "%s%sPriority: %.*s%s(%s.%s)", prot_nest_prefix, syslog, + priostrlen, syslogstr, bogus ? "" : " ", + facilstr, pristr); + (void) snprintf(get_line(0, 0), get_line_remain(), + "\"%s\"", + show_string(syslogstr, dlen, 60)); + show_trailer(); + } +} + +int src_port, dst_port, curr_proto; + +int +interpret_reserved(int flags, int proto, in_port_t src, in_port_t dst, + char *data, int dlen) +{ + const char *pn; + int dir, port, which; + char pbuff[16], hbuff[32]; + struct ttable *ttabp; + + src_port = src; + dst_port = dst; + curr_proto = proto; + + pn = getportname(proto, src); + if (pn != NULL) { + dir = 'R'; + port = dst; + which = src; + } else { + pn = getportname(proto, dst); + if (pn == NULL) { + ttabp = is_transient(src); + if (ttabp) { + (ttabp->t_proc)(flags, data, dlen); + return (1); + } + ttabp = is_transient(dst); + if (ttabp) { + (ttabp->t_proc)(flags, data, dlen); + return (1); + } + return (0); + } + + dir = 'C'; + port = src; + which = dst; + } + + if ((dst == IPPORT_DOMAIN || src == IPPORT_DOMAIN || + dst == IPPORT_MDNS || src == IPPORT_MDNS) && + proto != IPPROTO_TCP) { + interpret_dns(flags, proto, (uchar_t *)data, dlen, which); + return (1); + } + + if (dst == IPPORT_SYSLOG && proto != IPPROTO_TCP) { + /* + * TCP port 514 is rshell. UDP port 514 is syslog. + */ + interpret_syslog(flags, dir, port, (const char *)data, dlen); + return (1); + } + + if (dlen > 0) { + switch (which) { + case IPPORT_BOOTPS: + case IPPORT_BOOTPC: + (void) interpret_dhcp(flags, (struct dhcp *)data, + dlen); + return (1); + case IPPORT_DHCPV6S: + case IPPORT_DHCPV6C: + (void) interpret_dhcpv6(flags, (uint8_t *)data, dlen); + return (1); + case IPPORT_TFTP: + (void) interpret_tftp(flags, (struct tftphdr *)data, + dlen); + return (1); + case IPPORT_HTTP: + case IPPORT_HTTP_ALT: + (void) interpret_http(flags, data, dlen); + return (1); + case IPPORT_NTP: + (void) interpret_ntp(flags, (struct ntpdata *)data, + dlen); + return (1); + case IPPORT_NETBIOS_NS: + interpret_netbios_ns(flags, (uchar_t *)data, dlen); + return (1); + case IPPORT_NETBIOS_DGM: + interpret_netbios_datagram(flags, (uchar_t *)data, + dlen); + return (1); + case IPPORT_NETBIOS_SSN: + case 445: + /* + * SMB on port 445 is a subset of NetBIOS SMB + * on port 139. The same interpreter can be used + * for both. + */ + interpret_netbios_ses(flags, (uchar_t *)data, dlen); + return (1); + case IPPORT_LDAP: + interpret_ldap(flags, data, dlen, src, dst); + return (1); + case IPPORT_SLP: + interpret_slp(flags, data, dlen); + return (1); + case IPPORT_MIP: + interpret_mip_cntrlmsg(flags, (uchar_t *)data, dlen); + return (1); + case IPPORT_ROUTESERVER: + (void) interpret_rip(flags, (struct rip *)data, dlen); + return (1); + case IPPORT_RIPNG: + (void) interpret_rip6(flags, (struct rip6 *)data, + dlen); + return (1); + case IPPORT_SOCKS: + if (dir == 'C') + (void) interpret_socks_call(flags, data, dlen); + else + (void) interpret_socks_reply(flags, data, + dlen); + return (1); + } + } + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "%s %c port=%d %s", + pn, dir, port, + show_string(data, dlen, 20)); + } + + if (flags & F_DTAIL) { + (void) snprintf(pbuff, sizeof (pbuff), "%s: ", pn); + (void) snprintf(hbuff, sizeof (hbuff), "%s: ", pn); + show_header(pbuff, hbuff, dlen); + show_space(); + (void) snprintf(get_line(0, 0), get_line_remain(), + "\"%s\"", + show_string(data, dlen, 60)); + show_trailer(); + } + return (1); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rquota.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rquota.c new file mode 100644 index 0000000..13f5dc6 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rquota.c @@ -0,0 +1,164 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <string.h> + +#include <netinet/in.h> +#include <rpc/types.h> +#include <rpc/rpc.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <rpcsvc/rquota.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static char *procnames_short[] = { + "Null", /* 0 */ + "GETQUOTA", /* 1 */ + "GETACTIVE", /* 2 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Get quotas", /* 1 */ + "Get active quotas", /* 2 */ +}; + +#define MAXPROC 2 + +static void show_quota(void); + +void +interpret_rquota(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + char buff[RQ_PATHLEN + 1]; + int status; + int uid; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) getxdr_string(buff, RQ_PATHLEN); + uid = getxdr_long(); + (void) sprintf(line, + "RQUOTA C %s Uid=%d Path=%s", + procnames_short[proc], + uid, buff); + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "RQUOTA R %s ", + procnames_short[proc]); + line += strlen(line); + status = getxdr_u_long(); + if (status == Q_OK) + (void) sprintf(line, "OK"); + else if (status == Q_NOQUOTA) + (void) sprintf(line, "No quota"); + else if (status == Q_EPERM) + (void) sprintf(line, "No permission"); + } + } + + if (flags & F_DTAIL) { + show_header("RQUOTA: ", "Remote Quota Check", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long[proc]); + + if (type == CALL) { + switch (proc) { + case RQUOTAPROC_GETQUOTA: + case RQUOTAPROC_GETACTIVEQUOTA: + (void) showxdr_string(RQ_PATHLEN, + "Path = %s"); + (void) showxdr_long("User id = %d"); + break; + } + } else { + status = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + "Status = %lu (%s)", + status, + status == Q_OK ? "OK" : + status == Q_NOQUOTA ? "No quota" : + status == Q_EPERM ? "No permission":""); + + if (status == Q_OK) + show_quota(); + } + + show_trailer(); + } +} + +static void +show_quota() +{ + int active; + + (void) showxdr_u_long("Block size = %lu"); + active = getxdr_u_long(); + (void) sprintf(get_line(0, 0), + " Quota checking = %lu (%s)", + active, + active ? "on" : "off"); + (void) showxdr_u_long(" Blocks hard limit = %lu"); + (void) showxdr_u_long(" Blocks soft limit = %lu"); + (void) showxdr_u_long(" Current block count = %lu"); + (void) show_space(); + (void) showxdr_u_long(" File hard limit = %lu"); + (void) showxdr_u_long(" File soft limit = %lu"); + (void) showxdr_u_long(" Current file count = %lu"); + (void) show_space(); + (void) showxdr_u_long("Excessive blocks limit = %lu sec"); + (void) showxdr_u_long("Excessive files limit = %lu sec"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rstat.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rstat.c new file mode 100644 index 0000000..e45205a --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rstat.c @@ -0,0 +1,272 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1991, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#ident "%Z%%M% %I% %E% SMI" /* SunOS */ + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <sys/tiuser.h> + +#include <rpc/types.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +void detail_stats(); /* Version 1 */ +void detail_statsswtch(); /* Version 2 */ +void detail_statstime(); /* Version 3 */ +void detail_statsvar(); /* Version 4 */ + +static char *procnames_short[] = { + "Null", /* 0 */ + "Get Statistics", /* 1 */ + "Have Disk", /* 2 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Get Statistics", /* 1 */ + "Have Disk", /* 2 */ +}; + +#define MAXPROC 2 + +void +interpret_rstat(flags, type, xid, vers, proc, data, len) + int flags, type, xid, vers, proc; + char *data; + int len; +{ + char *line; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "RSTAT C %s", + procnames_short[proc]); + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "RSTAT R %s ", + procnames_short[proc]); + } + } + + if (flags & F_DTAIL) { + show_header("RSTAT: ", "RSTAT Get Statistics", len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), + "Proc = %d (%s)", + proc, procnames_long[proc]); + + if (type == REPLY) { + switch (proc) { + case 1: + switch (vers) { + case 1: + detail_stats(); + break; + case 2: + detail_statsswtch(); + break; + case 3: + detail_statstime(); + break; + case 4: + detail_statsvar(); + break; + } + break; + case 2: + (void) showxdr_u_long( + "Result = %lu"); + break; + } + } + show_trailer(); + } +} + +void +detail_stats() +{ + show_space(); + (void) sprintf(get_line(0, 0), "CPU Times:"); + (void) showxdr_long(" Time (1) = %d"); + (void) showxdr_long(" Time (2) = %d"); + (void) showxdr_long(" Time (3) = %d"); + (void) showxdr_long(" Time (4) = %d"); + show_space(); + (void) sprintf(get_line(0, 0), "Disk Transfers:"); + (void) showxdr_long(" Transfers(1) = %d"); + (void) showxdr_long(" Transfers(2) = %d"); + (void) showxdr_long(" Transfers(3) = %d"); + (void) showxdr_long(" Transfers(4) = %d"); + show_space(); + (void) showxdr_u_long("Pages in = %lu"); + (void) showxdr_u_long("Pages out = %lu"); + (void) showxdr_u_long("Swaps in = %lu"); + (void) showxdr_u_long("Swaps out = %lu"); + (void) showxdr_u_long("Interrupts = %lu"); + show_space(); + (void) showxdr_long("Receive packets = %d"); + (void) showxdr_long("Receive errors = %d"); + (void) showxdr_long("Transmit packets = %d"); + (void) showxdr_long("Transmit errors = %d"); + (void) showxdr_long("Collisions = %d"); +} + +void +detail_statsswtch() +{ + show_space(); + (void) sprintf(get_line(0, 0), "CPU Times:"); + (void) showxdr_long(" Time (1) = %d"); + (void) showxdr_long(" Time (2) = %d"); + (void) showxdr_long(" Time (3) = %d"); + (void) showxdr_long(" Time (4) = %d"); + show_space(); + (void) sprintf(get_line(0, 0), "Disk Transfers:"); + (void) showxdr_long(" Transfers(1) = %d"); + (void) showxdr_long(" Transfers(2) = %d"); + (void) showxdr_long(" Transfers(3) = %d"); + (void) showxdr_long(" Transfers(4) = %d"); + show_space(); + (void) showxdr_u_long("Pages in = %lu"); + (void) showxdr_u_long("Pages out = %lu"); + (void) showxdr_u_long("Swaps in = %lu"); + (void) showxdr_u_long("Swaps out = %lu"); + (void) showxdr_u_long("Interrupts = %lu"); + show_space(); + (void) showxdr_long("Receive packets = %d"); + (void) showxdr_long("Receive errors = %d"); + (void) showxdr_long("Transmit packets = %d"); + (void) showxdr_long("Transmit errors = %d"); + (void) showxdr_long("Collisions = %d"); + show_space(); + (void) showxdr_u_long("V switch = %lu"); + (void) showxdr_long("Average run 0 = %d"); + (void) showxdr_long("Average run 1 = %d"); + (void) showxdr_long("Average run 2 = %d"); + show_space(); + (void) showxdr_date("Boot time: = %s"); +} + +void +detail_statstime() +{ + show_space(); + (void) sprintf(get_line(0, 0), "CPU Times:"); + (void) showxdr_long(" Time (1) = %d"); + (void) showxdr_long(" Time (2) = %d"); + (void) showxdr_long(" Time (3) = %d"); + (void) showxdr_long(" Time (4) = %d"); + show_space(); + (void) sprintf(get_line(0, 0), "Disk Transfers:"); + (void) showxdr_long(" Transfers(1) = %d"); + (void) showxdr_long(" Transfers(2) = %d"); + (void) showxdr_long(" Transfers(3) = %d"); + (void) showxdr_long(" Transfers(4) = %d"); + show_space(); + (void) showxdr_u_long("Pages in = %lu"); + (void) showxdr_u_long("Pages out = %lu"); + (void) showxdr_u_long("Swaps in = %lu"); + (void) showxdr_u_long("Swaps out = %lu"); + (void) showxdr_u_long("Interrupts = %lu"); + show_space(); + (void) showxdr_long("Receive packets = %d"); + (void) showxdr_long("Receive errors = %d"); + (void) showxdr_long("Transmit packets = %d"); + (void) showxdr_long("Transmit errors = %d"); + (void) showxdr_long("Collisions = %d"); + show_space(); + (void) showxdr_u_long("V switch = %lu"); + (void) showxdr_long("Average run 0 = %d"); + (void) showxdr_long("Average run 1 = %d"); + (void) showxdr_long("Average run 2 = %d"); + show_space(); + (void) showxdr_date("Boot time: = %s"); + (void) showxdr_date("Current time = %s"); +} + +void +detail_statsvar() +{ + int i, n; + + show_space(); + (void) sprintf(get_line(0, 0), "CPU Times:"); + n = getxdr_u_long(); + for (i = 1; i <= n; i++) { + (void) sprintf(get_line(0, 0), + " Time (%2d) = %d", i, getxdr_long()); + } + show_space(); + (void) sprintf(get_line(0, 0), "Disk Transfers:"); + n = getxdr_u_long(); + for (i = 1; i <= n; i++) { + (void) sprintf(get_line(0, 0), + " Transfers (%2d) = %d", i, getxdr_long()); + } + show_space(); + (void) showxdr_u_long("Pages in = %lu"); + (void) showxdr_u_long("Pages out = %lu"); + (void) showxdr_u_long("Swaps in = %lu"); + (void) showxdr_u_long("Swaps out = %lu"); + (void) showxdr_u_long("Interrupts = %lu"); + show_space(); + (void) showxdr_long("Receive packets = %d"); + (void) showxdr_long("Receive errors = %d"); + (void) showxdr_long("Transmit packets = %d"); + (void) showxdr_long("Transmit errors = %d"); + (void) showxdr_long("Collisions = %d"); + show_space(); + (void) showxdr_u_long("V switch = %lu"); + (void) showxdr_long("Average run 0 = %d"); + (void) showxdr_long("Average run 1 = %d"); + (void) showxdr_long("Average run 2 = %d"); + show_space(); + (void) showxdr_date("Boot time: = %s"); + (void) showxdr_date("Current time = %s"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rtmp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rtmp.c new file mode 100644 index 0000000..db3054a --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_rtmp.c @@ -0,0 +1,181 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +static void show_rtmp_tuples(uint8_t *, int); + +static char * +rtmp_func_long(uint8_t fun) +{ + switch (fun) { + case RTMP_REQ: + return ("Request"); + case RTMP_RDR_SH: + return ("Route Data Request, split horizon"); + case RTMP_RDR_NSH: + return ("Route Data Request, no split horizon"); + default: + return ("unknown"); + } +} + +static char * +rtmp_func_short(uint8_t fun) +{ + switch (fun) { + case RTMP_REQ: + return ("Req"); + case RTMP_RDR_SH: + return ("RDR, sh"); + case RTMP_RDR_NSH: + return ("RDR, no sh"); + default: + return ("unknown"); + } +} + +void +interpret_rtmp(int flags, struct ddp_hdr *ddp, int len) +{ + uint8_t *data; + uint16_t snet; + uint8_t node; + int tuples; + int runt; + char extended; + + len -= DDPHDR_SIZE; + if (len < 0) + goto out; + + data = (uint8_t *)ddp + DDPHDR_SIZE; + + switch (ddp->ddp_type) { + case DDP_TYPE_RTMPRQ: /* simple rtmp */ + if (len < 1) + goto out; + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "RTMP F=%s", + rtmp_func_short(data[0])); + } + + if (flags & F_DTAIL) { + show_header("RTMP: ", "RTMP Header", len); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Func = %d (%s)", + data[0], rtmp_func_long(data[0])); + } + break; + case DDP_TYPE_RTMPRESP: /* RTMP data */ + if (len < 3) + goto out; + + snet = get_short(data); + if (data[2] != 8) /* ID length is always 8 */ + return; + node = data[3]; /* assume id_len == 8 */ + extended = (data[6] != RTMP_FILLER) && + (get_short(&data[4]) != 0); + + tuples = (len - 4) / 3; + runt = (len - 4) % 3; /* integral length? */ + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "RTMP Data Snet=%d, Snode=%d%s", + snet, node, runt != 0 ? " (short)" : ""); + } + + if (flags & F_DTAIL) { + show_header("RTMP: ", "RTMP Header", len); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "RTMP Data, Length = %d%s", + len, runt != 0 ? " (short packet)" : ""); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Senders Net = %d, Sender Node %d", + snet, node); + if (extended) + show_rtmp_tuples(&data[4], tuples); + else + show_rtmp_tuples(&data[7], tuples-1); + } + + break; + } + return; +out: + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "RTMP (short packet)"); + } + + if (flags & F_DTAIL) { + show_header("RTMP: ", "RTMP Header", len); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "(short packet)"); + } +} + +static void +show_rtmp_tuples(uint8_t *p, int tuples) +{ + while (tuples > 0) { + + if (p[2] & RTMP_EXTEND) { /* extended tuple? */ + + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Network = %d-%d, Distance = %d", + get_short(p), get_short(&p[3]), + p[2] & RTMP_DIST_MASK); + p += 6; + tuples -= 2; + } else { + + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Network = %d, Distance = %d", + get_short(p), p[2]); + p += 3; + tuples--; + } + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_sctp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_sctp.c new file mode 100644 index 0000000..8aec695 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_sctp.c @@ -0,0 +1,1208 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2006 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <stdlib.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysmacros.h> +#include <inet/common.h> +#include <netinet/in.h> +#include <netinet/sctp.h> +#include <arpa/inet.h> +#include <string.h> +#include "snoop.h" + +/* + * Snoop interpreter for SCTP (rfc2960). + * + * To add support for an upper-layer protocol, modify either + * the port-dispatcher in snoop_rport.c, or the protocol ID + * dispatcher at the bottom of this file (or both). + */ + +static void interpret_protoid(int, uint32_t, char *, int); +extern char *prot_prefix; + +/* + * This defines the length of internal, unbounded buffers. We set + * this to be MAXLINE (the maximum verbose display line length) - + * 64, which should be enough for all necessary descriptions. 64 + * bytes seems like a reasonably conservative estimate of the + * maximum prefix length snoop may add to any text buffer it hands out. + */ +#define BUFLEN MAXLINE - 64 + +/* + * Common structure to hold descriptions and parsers for all + * chunks, parameters, and errors. Each parser should implement + * this interface: + * + * void parse(int flags, uint8_t cflags, void *data, int datalen); + * + * Where flags is the snoop flags, cflags are the chunk flags, data + * is the chunk or parameter data (not including the chunk or + * parameter header), and datalen is the length of the chunk or + * parameter data (again not including any headers). + */ +typedef void parse_func_t(int, uint8_t, const void *, int); + +typedef struct { + uint16_t id; + const char *sdesc; /* short description */ + const char *vdesc; /* verbose description */ + parse_func_t *parse; /* parser function */ +} dispatch_t; + +static void interpret_params(const void *, int, char *, const dispatch_t *, + int, int); + +/* + * Chunk parsers + */ +static parse_func_t parse_abort_chunk, parse_data_chunk, parse_error_chunk, + parse_init_chunk, parse_opaque_chunk, parse_sack_chunk, + parse_shutdone_chunk, parse_shutdown_chunk, parse_asconf_chunk, + parse_ftsn_chunk; + + +/* + * Chunk parser dispatch table. There are few enough chunks defined + * in the core protocol, and they are sequential, so the chunk code + * can be used as the index into this array for the common case. + * It is still necessary to check that the code and index match, + * since optional extensions will not follow sequentially the + * core chunks. + */ +static const dispatch_t chunk_dispatch_table[] = { +/* code F_SUM desc F_DTAIL desc parser function */ + { CHUNK_DATA, "Data", "Data Chunk", + parse_data_chunk }, + { CHUNK_INIT, "Init", "Init Chunk", + parse_init_chunk }, + { CHUNK_INIT_ACK, "Init ACK", "Init ACK Chunk", + parse_init_chunk }, + { CHUNK_SACK, "SACK", "SACK Chunk", + parse_sack_chunk }, + { CHUNK_HEARTBEAT, "Heartbeat", "Heartbeat Chunk", + parse_opaque_chunk }, + { CHUNK_HEARTBEAT_ACK, "Heartbeat ACK", "Heartbeat ACK Chunk", + parse_opaque_chunk }, + { CHUNK_ABORT, "Abort", "Abort Chunk", + parse_abort_chunk }, + { CHUNK_SHUTDOWN, "Shutdown", "Shutdown Chunk", + parse_shutdown_chunk }, + { CHUNK_SHUTDOWN_ACK, "Shutdown ACK", "Shutdown ACK Chunk", + NULL }, + { CHUNK_ERROR, "Err", "Error Chunk", + parse_error_chunk }, + { CHUNK_COOKIE, "Cookie", "Cookie Chunk", + parse_opaque_chunk }, + { CHUNK_COOKIE_ACK, "Cookie ACK", "Cookie ACK Chunk", + parse_opaque_chunk }, + { CHUNK_ECNE, "ECN Echo", "ECN Echo Chunk", + parse_opaque_chunk }, + { CHUNK_CWR, "CWR", "CWR Chunk", + parse_opaque_chunk }, + { CHUNK_SHUTDOWN_COMPLETE, "Shutdown Done", "Shutdown Done", + parse_shutdone_chunk }, + { CHUNK_FORWARD_TSN, "FORWARD TSN", "Forward TSN Chunk", + parse_ftsn_chunk }, + { CHUNK_ASCONF_ACK, "ASCONF ACK", "ASCONF ACK Chunk", + parse_asconf_chunk }, + { CHUNK_ASCONF, "ASCONF", "ASCONF Chunk", + parse_asconf_chunk } +}; + +/* + * Parameter Parsers + */ +static parse_func_t parse_encap_param, parse_int32_param, parse_ip4_param, + parse_ip6_param, parse_opaque_param, parse_suppaddr_param, + parse_unrec_chunk, parse_addip_param, parse_asconferr_param, + parse_asconfok_param, parse_addiperr_param; + +/* + * Parameter parser dispatch table. The summary description is not + * used here. Strictly speaking, parameter types are defined within + * the context of a chunk type. However, thus far the IETF WG has + * agreed to follow the convention that parameter types are globally + * unique (and why not, with a 16-bit namespace). However, if this + * ever changes, there will need to be different parameter dispatch + * tables for each chunk type. + */ +static const dispatch_t parm_dispatch_table[] = { +/* code F_SUM desc F_DTAIL desc parser function */ + { PARM_UNKNOWN, "", "Unknown Parameter", + parse_opaque_param }, + { PARM_HBINFO, "", "Heartbeat Info", + parse_opaque_param }, + { PARM_ADDR4, "", "IPv4 Address", + parse_ip4_param }, + { PARM_ADDR6, "", "IPv6 Address", + parse_ip6_param }, + { PARM_COOKIE, "", "Cookie", + parse_opaque_param }, + { PARM_UNRECOGNIZED, "", "Unrecognized Param", + parse_encap_param }, + { PARM_COOKIE_PRESERVE, "", "Cookie Preservative", + parse_opaque_param }, + { 10, "", "Reserved for ECN", + parse_opaque_param }, + { PARM_ADDR_HOST_NAME, "", "Host Name Parameter", + parse_opaque_param }, + { PARM_SUPP_ADDRS, "", "Supported Addresses", + parse_suppaddr_param }, + { PARM_ECN_CAPABLE, "", "ECN Capable", + parse_opaque_param }, + { PARM_ADD_IP, "", "Add IP", + parse_addip_param }, + { PARM_DEL_IP, "", "Del IP", + parse_addip_param }, + { PARM_ASCONF_ERROR, "", "ASCONF Error Ind", + parse_asconferr_param }, + { PARM_PRIMARY_ADDR, "", "Set Primary Address", + parse_addip_param }, + { PARM_FORWARD_TSN, "", "Forward TSN", + NULL }, + { PARM_ASCONF_SUCCESS, "", "ASCONF Success Ind", + parse_asconfok_param } +}; + +/* + * Errors have the same wire format at parameters. + */ +static const dispatch_t err_dispatch_table[] = { +/* code F_SUM desc F_DTAIL desc parser function */ + { SCTP_ERR_UNKNOWN, "", "Unknown Error", + parse_opaque_param }, + { SCTP_ERR_BAD_SID, "", "Invalid Stream ID", + parse_opaque_param }, + { SCTP_ERR_MISSING_PARM, "", "Missing Parameter", + parse_opaque_param }, + { SCTP_ERR_STALE_COOKIE, "", "Stale Cookie", + parse_int32_param }, + { SCTP_ERR_NO_RESOURCES, "", "Out Of Resources", + parse_opaque_param }, + { SCTP_ERR_BAD_ADDR, "", "Unresolvable Address", + parse_opaque_param }, + { SCTP_ERR_UNREC_CHUNK, "", "Unrecognized Chunk", + parse_unrec_chunk }, + { SCTP_ERR_BAD_MANDPARM, "", "Bad Mandatory Parameter", + parse_opaque_param }, + { SCTP_ERR_UNREC_PARM, "", "Unrecognized Parameter", + parse_opaque_param }, + { SCTP_ERR_NO_USR_DATA, "", "No User Data", + parse_int32_param }, + { SCTP_ERR_COOKIE_SHUT, "", "Cookie During Shutdown", + parse_opaque_param }, + { SCTP_ERR_DELETE_LASTADDR, "", "Delete Last Remaining Address", + parse_addiperr_param }, + { SCTP_ERR_RESOURCE_SHORTAGE, "", "Resource Shortage", + parse_addiperr_param }, + { SCTP_ERR_DELETE_SRCADDR, "", "Delete Source IP Address", + parse_addiperr_param }, + { SCTP_ERR_AUTH_ERR, "", "Not authorized", + parse_addiperr_param } +}; + +/* + * These are global because the data chunk parser needs them to dispatch + * to ULPs. The alternative is to add source and dest port arguments + * to every parser, which seems even messier (since *only* the data + * chunk parser needs it)... + */ +static in_port_t sport, dport; + +/* Summary line miscellany */ +static int sumlen; +static char scratch[MAXLINE]; +static char *sumline; + +#define SUMAPPEND(fmt) \ + sumlen -= snprintf fmt; \ + (void) strlcat(sumline, scratch, sumlen) + +#define DUMPHEX_MAX 16 + +static const dispatch_t * +lookup_dispatch(int id, const dispatch_t *tbl, int tblsz) +{ + int i; + + /* + * Try fast lookup first. The common chunks defined in RFC2960 + * will have indices aligned with their IDs, so this works for + * the common case. + */ + if (id < (tblsz - 1)) { + if (id == tbl[id].id) { + return (tbl + id); + } + } + + /* + * Nope - probably an extension. Search the whole table, + * starting from the end, since extensions are at the end. + */ + for (i = tblsz - 1; i >= 0; i--) { + if (id == tbl[i].id) { + return (tbl + i); + } + } + + return (NULL); +} + +/* + * Dumps no more than the first DUMPHEX_MAX bytes in hex. If + * the user wants more, they can use the -x option to snoop. + */ +static void +dumphex(const uchar_t *payload, int payload_len, char *msg) +{ + int index; + int end; + char buf[BUFLEN]; + + if (payload_len == 0) { + return; + } + + end = payload_len > DUMPHEX_MAX ? DUMPHEX_MAX : payload_len; + + for (index = 0; index < end; index++) { + (void) snprintf(&buf[index * 3], 4, " %.2x", payload[index]); + } + + if (payload_len > DUMPHEX_MAX) { + (void) strlcat(buf, " ...", BUFLEN); + } + + (void) snprintf(get_line(0, 0), BUFLEN, msg, buf); +} + +/* + * Present perscribed action for unknowns according to rfc2960. Works + * for chunks and parameters as well if the parameter type is + * shifted 8 bits right. + */ +static const char * +get_action_desc(uint8_t id) +{ + if ((id & 0xc0) == 0xc0) { + return (": skip on unknown, return error"); + } else if ((id & 0x80) == 0x80) { + return (": skip on unknown, no error"); + } else if ((id & 0x40) == 0x40) { + return (": stop on unknown, return error"); + } + + /* Top two bits are clear */ + return (": stop on unknown, no error"); +} + +/* ARGSUSED */ +static void +parse_asconfok_param(int flags, uint8_t notused, const void *data, int dlen) +{ + uint32_t *cid; + + if (dlen < sizeof (*cid)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete ASCONF Success Ind parameter"); + return; + } + cid = (uint32_t *)data; + (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u", + ntohl(*cid)); +} + +/* ARGSUSED */ +static void +parse_asconferr_param(int flags, uint8_t notused, const void *data, int dlen) +{ + uint32_t *cid; + + if (dlen < sizeof (*cid)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete ASCONF Error Ind parameter"); + return; + } + cid = (uint32_t *)data; + (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u", + ntohl(*cid)); + + interpret_params(cid + 1, dlen - sizeof (*cid), "Error", + err_dispatch_table, A_CNT(err_dispatch_table), flags); +} + +/* ARGSUSED */ +static void +parse_addiperr_param(int flags, uint8_t notused, const void *data, int dlen) +{ + + interpret_params(data, dlen, "Parameter", + parm_dispatch_table, A_CNT(parm_dispatch_table), flags); +} + +/* ARGSUSED */ +static void +parse_addip_param(int flags, uint8_t notused, const void *data, int dlen) +{ + + uint32_t *cid; + + if (dlen < sizeof (*cid)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete ASCONF Error Ind parameter"); + return; + } + cid = (uint32_t *)data; + (void) snprintf(get_line(0, 0), get_line_remain(), " ASCONF CID = %u", + ntohl(*cid)); + + interpret_params(cid + 1, dlen - sizeof (*cid), "Parameter", + parm_dispatch_table, A_CNT(parm_dispatch_table), flags); +} + +/* ARGSUSED */ +static void +parse_ip4_param(int flags, uint8_t notused, const void *data, int datalen) +{ + char abuf[INET_ADDRSTRLEN]; + char *ap; + + if (datalen < sizeof (in_addr_t)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete IPv4 Addr parameter"); + return; + } + + ap = (char *)inet_ntop(AF_INET, data, abuf, INET_ADDRSTRLEN); + if (ap == NULL) { + ap = "<Bad Address>"; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), " Addr = %s", ap); +} + +/* ARGSUSED */ +static void +parse_ip6_param(int flags, uint8_t notused, const void *data, int datalen) +{ + char abuf[INET6_ADDRSTRLEN]; + char *ap; + + if (datalen < sizeof (in6_addr_t)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete IPv6 Addr parameter"); + return; + } + + ap = (char *)inet_ntop(AF_INET6, data, abuf, INET6_ADDRSTRLEN); + if (ap == NULL) { + ap = "<Bad Address>"; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), " Addr = %s", ap); +} + +/* ARGSUSED */ +static void +parse_int32_param(int flags, uint8_t notused, const void *data, int datalen) +{ + if (datalen < 4) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete INT32 parameter"); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), " INT32 = %u", + ntohl(*(uint32_t *)data)); +} + +/* ARGSUSED */ +static void +parse_suppaddr_param(int flags, uint8_t notused, const void *data, int dlen) +{ + const uint16_t *type; + + if (dlen < 2) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete Supported Addr parameter"); + return; + } + + type = data; + while (dlen > 0) { + switch (ntohs(*type)) { + case PARM_ADDR4: + (void) snprintf(get_line(0, 0), get_line_remain(), + " IPv4"); + break; + case PARM_ADDR6: + (void) snprintf(get_line(0, 0), get_line_remain(), + " IPv6"); + break; + case PARM_ADDR_HOST_NAME: + (void) snprintf(get_line(0, 0), get_line_remain(), + " Host Name"); + break; + default: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Unknown Type (%hu)", ntohs(*type)); + break; + } + dlen -= sizeof (*type); + type++; + } +} + +/*ARGSUSED*/ +static void +parse_encap_param(int flags, uint8_t notused, const void *data, int dlen) +{ + if (dlen < sizeof (sctp_parm_hdr_t)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete Parameter"); + return; + } + + interpret_params(data, dlen, "Parameter", + parm_dispatch_table, A_CNT(parm_dispatch_table), flags); +} + +/* ARGSUSED */ +static void +parse_unrec_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + const sctp_chunk_hdr_t *cp = data; + const dispatch_t *dp; + const char *actstr; + + if (datalen < sizeof (*cp)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete Unrecognized Chunk Error"); + return; + } + + /* Maybe snoop knows about this chunk? */ + dp = lookup_dispatch(cp->sch_id, chunk_dispatch_table, + A_CNT(chunk_dispatch_table)); + if (dp != NULL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " Chunk Type = %u (%s)", cp->sch_id, dp->vdesc); + } else { + actstr = get_action_desc(cp->sch_id); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Chunk Type = %u%s", cp->sch_id, actstr); + } +} + +/* + * Same as parse_opaque_chunk except for the indentation. + */ +/* ARGSUSED */ +static void +parse_opaque_param(int flags, uint8_t cflags, const void *data, int datalen) +{ + dumphex(data, datalen, " Data = %s"); +} + +/* + * Loops through all parameters (or errors) until it has read + * datalen bytes of information, finding a parser for each. + * The tbl argument allows the caller to specify which dispatch + * table to use, making this function useful for both parameters + * and errors. The type argument is used to denote whether this + * is an error or parameter in detailed mode. + */ +static void +interpret_params(const void *data, int datalen, char *type, + const dispatch_t *tbl, int tbl_size, int flags) +{ + const sctp_parm_hdr_t *hdr = data; + uint16_t plen; + uint16_t ptype; + const char *desc; + parse_func_t *parse; + int pad; + const dispatch_t *dp; + const char *actstr; + + for (;;) { + /* + * Adjust for padding: if the address isn't aligned, there + * should be some padding. So skip over the padding and + * adjust hdr accordingly. RFC2960 mandates that all + * parameters must be 32-bit aligned WRT the enclosing chunk, + * which ensures that this parameter header will + * be 32-bit aligned in memory. We must, of course, bounds + * check fraglen before actually trying to use hdr, in + * case the packet has been mangled or is the product + * of a buggy implementation. + */ + if ((pad = (uintptr_t)hdr % SCTP_ALIGN) != 0) { + pad = SCTP_ALIGN - pad; + datalen -= pad; + /* LINTED pointer cast may result in improper alignment */ + hdr = (sctp_parm_hdr_t *)((char *)hdr + pad); + } + + /* Need to compare against 0 1st, since sizeof is unsigned */ + if (datalen < 0 || datalen < sizeof (*hdr)) { + if (datalen > 0) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "==> Extra data after last parameter"); + } + return; + } + plen = ntohs(hdr->sph_len); + if (datalen < plen || plen < sizeof (*hdr)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Incomplete %s", type); + return; + } + + /* Get description and parser */ + ptype = ntohs(hdr->sph_type); + desc = "Unknown Parameter Type"; + parse = parse_opaque_param; + dp = lookup_dispatch(ptype, tbl, tbl_size); + if (dp != NULL) { + desc = dp->vdesc; + parse = dp->parse; + } + + show_space(); + if (dp != NULL) { + actstr = ""; + } else { + actstr = get_action_desc((uint8_t)(ptype >> 8)); + } + (void) snprintf(get_line(0, 0), get_line_remain(), + " ------- SCTP %s Type = %s (%u%s)", type, desc, ptype, + actstr); + (void) snprintf(get_line(0, 0), get_line_remain(), + " Data length = %hu", plen - sizeof (*hdr)); + + if (parse != NULL) { + parse(flags, 0, (char *)(hdr + 1), + plen - sizeof (*hdr)); + } + datalen -= plen; + /* LINTED pointer cast may result in improper alignment */ + hdr = (sctp_parm_hdr_t *)((char *)hdr + plen); + } +} + +/* ARGSUSED */ +static void +parse_ftsn_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + uint32_t *ftsn; + ftsn_entry_t *ftsn_entry; + + if (datalen < (sizeof (*ftsn) + sizeof (*ftsn_entry))) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete FORWARD-TSN chunk"); + } + return; + } + + ftsn = (uint32_t *)data; + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "CTSN %x ", ntohl(*ftsn))); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), "Cum TSN= %x", + ntohl(*ftsn)); + + datalen -= sizeof (*ftsn); + ftsn_entry = (ftsn_entry_t *)(ftsn + 1); + while (datalen >= sizeof (*ftsn_entry)) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "SID = %u : SSN = %u", ntohs(ftsn_entry->ftsn_sid), + ntohs(ftsn_entry->ftsn_ssn)); + datalen -= sizeof (*ftsn_entry); + ftsn_entry++; + } +} + +/* ARGSUSED */ +static void +parse_asconf_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + uint32_t *sn; + + if (datalen < sizeof (*sn)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete ASCONF chunk"); + } + return; + } + + sn = (uint32_t *)data; + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "sn %x ", ntohl(*sn))); + return; + } + (void) snprintf(get_line(0, 0), get_line_remain(), "Serial Number= %x", + ntohl(*sn)); + interpret_params(sn + 1, datalen - sizeof (*sn), "Parameter", + parm_dispatch_table, A_CNT(parm_dispatch_table), flags); +} + +static void +parse_init_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + const sctp_init_chunk_t *icp = data; + + if (datalen < sizeof (*icp)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete INIT chunk"); + } + return; + } + + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "tsn %x str %hu/%hu win %u ", + ntohl(icp->sic_inittsn), ntohs(icp->sic_outstr), + ntohs(icp->sic_instr), ntohl(icp->sic_a_rwnd))); + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), "Flags = 0x%.2x", + cflags); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Initiate tag = 0x%.8x", ntohl(icp->sic_inittag)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Advertised receiver window credit = %u", ntohl(icp->sic_a_rwnd)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Outbound streams = %hu", ntohs(icp->sic_outstr)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Inbound streams = %hu", ntohs(icp->sic_instr)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Initial TSN = 0x%.8x", ntohl(icp->sic_inittsn)); + + if (datalen > sizeof (*icp)) { + interpret_params(icp + 1, datalen - sizeof (*icp), + "Parameter", parm_dispatch_table, + A_CNT(parm_dispatch_table), flags); + } +} + +static void +parse_data_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + const sctp_data_chunk_t *dcp = data; + char *payload; + uint32_t ppid; + + if (datalen < sizeof (*dcp)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete DATA chunk %d (%d)", datalen, + sizeof (*dcp)); + } + return; + } + + ppid = ntohl(dcp->sdc_payload_id); + /* This is the actual data len, excluding the data chunk header. */ + datalen -= sizeof (*dcp); + + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "flags = 0x%.2x", cflags); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(cflags, SCTP_DATA_UBIT, "unordered", "ordered")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(cflags, SCTP_DATA_BBIT, + "beginning", "(beginning unset)")); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(cflags, SCTP_DATA_EBIT, "end", "(end unset)")); + (void) snprintf(get_line(0, 0), get_line_remain(), + "TSN = 0x%.8x", ntohl(dcp->sdc_tsn)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Stream ID = %hu", ntohs(dcp->sdc_sid)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Stream Sequence Number = %hu", ntohs(dcp->sdc_ssn)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Payload Protocol ID = 0x%.8x", ppid); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Data Length = %d", datalen); + show_space(); + } + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "len %d tsn %x str %hu/%hu " + "ppid %x ", datalen, ntohl(dcp->sdc_tsn), + ntohs(dcp->sdc_sid), ntohs(dcp->sdc_ssn), ppid)); + } + + /* + * Go to the next protocol layer, but not if we are in + * summary mode only. In summary mode, each ULP parse would + * create a new line, and if there were several data chunks + * bundled together in the packet, this would confuse snoop's + * packet numbering and timestamping. + * + * SCTP carries two ways to determine an ULP: ports and the + * payload protocol identifier (ppid). Since ports are the + * better entrenched convention, we first try interpret_reserved(). + * If that fails to find a parser, we try by the PPID. + */ + if (!(flags & F_ALLSUM) && !(flags & F_DTAIL)) { + return; + } + + payload = (char *)(dcp + 1); + if (!interpret_reserved(flags, IPPROTO_SCTP, sport, dport, payload, + datalen) && ppid != 0) { + + interpret_protoid(flags, ppid, payload, datalen); + } + + /* + * Reset the protocol prefix, since it may have been changed + * by a ULP interpreter. + */ + prot_prefix = "SCTP: "; +} + +/* ARGSUSED */ +static void +parse_sack_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + const sctp_sack_chunk_t *scp = data; + uint16_t numfrags, numdups; + sctp_sack_frag_t *frag; + int i; + uint32_t *tsn; + + if (datalen < sizeof (*scp)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete SACK chunk"); + } + return; + } + + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Cumulative TSN ACK = 0x%.8x", ntohl(scp->ssc_cumtsn)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Advertised Receiver Window Credit = %u", + ntohl(scp->ssc_a_rwnd)); + numfrags = ntohs(scp->ssc_numfrags); + numdups = ntohs(scp->ssc_numdups); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Number of Fragments = %hu", numfrags); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Number of Duplicates = %hu", numdups); + + /* Display any gap reports */ + datalen -= sizeof (*scp); + if (datalen < (numfrags * sizeof (*frag))) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Malformed gap report listing"); + return; + } + frag = (sctp_sack_frag_t *)(scp + 1); + for (i = 0; i < numfrags; i++) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " Fragment #%d: Start = %hu, end = %hu", i, + ntohs(frag->ssf_start), ntohs(frag->ssf_end)); + frag += 1; + } + + /* Display any duplicate reports */ + datalen -= numfrags * sizeof (*frag); + if (datalen < (numdups * sizeof (*tsn))) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " ==> Malformed duplicate report listing"); + return; + } + /* LINTED pointer cast may result in improper alignment */ + tsn = (uint32_t *)frag; + for (i = 0; i < numdups; i++) { + (void) snprintf(get_line(0, 0), get_line_remain(), + " Duplicate #%d: TSN = %x", i, *tsn); + tsn++; + } + } + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, + "tsn %x win %u gaps/dups %hu/%hu ", ntohl(scp->ssc_cumtsn), + ntohl(scp->ssc_a_rwnd), ntohs(scp->ssc_numfrags), + ntohs(scp->ssc_numdups))); + } +} + +/* ARGSUSED */ +static void +parse_shutdown_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + const uint32_t *cumtsn = data; + + if (datalen < sizeof (*cumtsn)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete Shutdown chunk"); + } + return; + } + + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "Cumulative TSN = 0x%.8x", ntohl(*cumtsn)); + } + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "tsn %x", ntohl(*cumtsn))); + } +} + +/* ARGSUSED */ +static void +parse_error_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + if (!(flags & F_DTAIL)) { + return; + } + + interpret_params(data, datalen, "Error", err_dispatch_table, + A_CNT(err_dispatch_table), flags); +} + +static void +parse_abort_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + if (!(flags & F_DTAIL)) { + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), "flags = 0x%.2x", + cflags); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(cflags, SCTP_TBIT, "TCB not destroyed", "TCB destroyed")); + + interpret_params(data, datalen, "Error", err_dispatch_table, + A_CNT(err_dispatch_table), flags); +} + +/* ARGSUSED2 */ +static void +parse_shutdone_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + if (!(flags & F_DTAIL)) { + return; + } + + (void) snprintf(get_line(0, 0), get_line_remain(), "flags = 0x%.2x", + cflags); + (void) snprintf(get_line(0, 0), get_line_remain(), " %s", + getflag(cflags, SCTP_TBIT, "TCB not destroyed", "TCB destroyed")); +} + +/* ARGSUSED */ +static void +parse_opaque_chunk(int flags, uint8_t cflags, const void *data, int datalen) +{ + if (!(flags & F_DTAIL)) { + return; + } + if (datalen == 0) { + return; + } + + dumphex(data, datalen, "Data = %s"); +} + +/* + * Loops through all chunks until it has read fraglen bytes of + * information, finding a parser for each. If any parameters are + * present, interpret_params() is then called. Returns the remaining + * fraglen. + */ +static int +interpret_chunks(int flags, sctp_chunk_hdr_t *cp, int fraglen) +{ + uint16_t clen; + int signed_len; + int pad; + const char *desc; + parse_func_t *parse; + const dispatch_t *dp; + const char *actstr; + + for (;;) { + /* + * Adjust for padding: if the address isn't aligned, there + * should be some padding. So skip over the padding and + * adjust hdr accordingly. RFC2960 mandates that all + * chunks must be 32-bit aligned WRT the SCTP common hdr, + * which ensures that this chunk header will + * be 32-bit aligned in memory. We must, of course, bounds + * check fraglen before actually trying to use hdr, in + * case the packet has been mangled or is the product + * of a buggy implementation. + */ + if ((pad = (uintptr_t)cp % SCTP_ALIGN) != 0) { + pad = SCTP_ALIGN - pad; + fraglen -= pad; + /* LINTED pointer cast may result in improper alignment */ + cp = (sctp_chunk_hdr_t *)((char *)cp + pad); + } + + /* Need to compare against 0 1st, since sizeof is unsigned */ + if (fraglen < 0 || fraglen < sizeof (*cp)) { + if (fraglen > 0 && flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "==> Extra data after last chunk"); + } + return (fraglen); + } + + clen = ntohs(cp->sch_len); + if (fraglen < clen) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), "==> Corrupted chunk"); + } + return (fraglen); + } + + signed_len = clen - sizeof (*cp); + if (signed_len < 0) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "==> Incomplete or corrupted chunk"); + } + return (0); + } + + /* Get description and parser */ + dp = lookup_dispatch(cp->sch_id, chunk_dispatch_table, + A_CNT(chunk_dispatch_table)); + if (dp != NULL) { + if (flags & F_SUM) { + desc = dp->sdesc; + } else if (flags & F_DTAIL) { + desc = dp->vdesc; + } + parse = dp->parse; + } else { + if (flags & F_SUM) { + desc = "UNK"; + } else if (flags & F_DTAIL) { + desc = "Unknown Chunk Type"; + } + parse = parse_opaque_chunk; + } + + if (flags & F_SUM) { + SUMAPPEND((scratch, MAXLINE, "%s ", desc)); + } + if (flags & F_DTAIL) { + show_space(); + + if (dp != NULL) { + actstr = ""; + } else { + actstr = get_action_desc(cp->sch_id); + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "------- SCTP Chunk Type = %s (%u%s)", desc, + cp->sch_id, actstr); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Chunk length = %hu", clen); + } + + if (parse != NULL) { + parse(flags, cp->sch_flags, (char *)(cp + 1), + signed_len); + } + + fraglen -= clen; + + /* LINTED pointer cast may result in improper alignment */ + cp = (sctp_chunk_hdr_t *)((char *)cp + clen); + } +} + +void +interpret_sctp(int flags, sctp_hdr_t *sctp, int iplen, int fraglen) +{ + int len_from_iphdr; + sctp_chunk_hdr_t *cp; + char *pn; + char buff[32]; + + /* + * Alignment check. If the header is 32-bit aligned, all other + * protocol units will also be aligned, as mandated by rfc2960. + * Buggy packets will be caught and flagged by chunk and + * parameter bounds checking. + * If the header is not aligned, however, we drop the packet. + */ + if (!IS_P2ALIGNED(sctp, SCTP_ALIGN)) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> SCTP header not aligned, dropping"); + } + return; + } + + fraglen -= sizeof (*sctp); + if (fraglen < 0) { + if (flags & F_DTAIL) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "==> Incomplete sctp header"); + } + return; + } + /* If fraglen is somehow longer than the IP payload, adjust it */ + len_from_iphdr = iplen - sizeof (*sctp); + if (fraglen > len_from_iphdr) { + fraglen = len_from_iphdr; + } + + /* Keep track of the ports */ + sport = ntohs(sctp->sh_sport); + dport = ntohs(sctp->sh_dport); + + /* Set pointer to first chunk */ + cp = (sctp_chunk_hdr_t *)(sctp + 1); + + if (flags & F_SUM) { + sumline = get_sum_line(); + *sumline = '\0'; + sumlen = MAXLINE; + + SUMAPPEND((scratch, MAXLINE, "SCTP D=%d S=%d ", dport, sport)); + } + + if (flags & F_DTAIL) { + show_header("SCTP: ", "SCTP Header", fraglen); + show_space(); + + pn = getportname(IPPROTO_SCTP, (ushort_t)sport); + if (pn == NULL) { + pn = ""; + } else { + (void) snprintf(buff, sizeof (buff), "(%s)", pn); + pn = buff; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Source port = %hu %s", sport, pn); + + pn = getportname(IPPROTO_SCTP, (ushort_t)dport); + if (pn == NULL) { + pn = ""; + } else { + (void) snprintf(buff, sizeof (buff), "(%s)", pn); + pn = buff; + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "Destination port = %hu %s", dport, pn); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Verification tag = 0x%.8x", ntohl(sctp->sh_verf)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "CRC-32c = 0x%.8x", ntohl(sctp->sh_chksum)); + } + + (void) interpret_chunks(flags, cp, fraglen); + + if (flags & F_DTAIL) { + show_space(); + } +} + +/* + * Payload protocol ID table. Add new ULP information and parsers + * here. + */ + +struct protoid_table { + int pid_num; + char *pid_short; + char *pid_long; +}; + +static struct protoid_table pid_sctp[] = { + 1, "IUA", "ISDN Q.921 User Adaption Layer", + 2, "M2UA", "SS7 MTP2 User Adaption Layer", + 3, "M3UA", "SS7 MTP3 User Adaption Layer", + 4, "SUA", "SS7 SCCP User Adaption Layer", + 5, "M2PA", "SS7 MTP2-User Peer-to-Peer Adaption Layer", + 6, "V5UA", "V5UA", + 0, NULL, "", +}; + +static void +interpret_protoid(int flags, uint32_t ppid, char *data, int dlen) +{ + struct protoid_table *p; + char pbuf[16]; + + /* + * Branch to a ULP interpreter here, or continue on to + * the default parser, which just tries to display + * printable characters from the payload. + */ + + for (p = pid_sctp; p->pid_num; p++) { + if (ppid == p->pid_num) { + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "D=%d S=%d %s %s", dport, sport, + p->pid_short, show_string(data, dlen, 20)); + } + + if (flags & F_DTAIL) { + (void) snprintf(pbuf, MAXLINE, "%s: ", + p->pid_short); + show_header(pbuf, p->pid_long, dlen); + show_space(); + (void) snprintf(get_line(0, 0), + get_line_remain(), "\"%s\"", + show_string(data, dlen, 60)); + show_trailer(); + } + + return; + } + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_slp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_slp.c new file mode 100644 index 0000000..9feb3e9 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_slp.c @@ -0,0 +1,1963 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1998,2000 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <arpa/inet.h> +#include <stdlib.h> +#include <string.h> +#include <sys/time.h> +#include <iconv.h> +#include "snoop.h" +#include "slp.h" + +#define MAXSUMLEN 30 + +/* define VERIFYSLP to enable full message checking in summary mode */ +#define VERIFYSLP + +/* Globals -- ugly, yes, but fast and easy in macros */ +static int msglength; +static int retlength; +static char *msgend; /* the end of the summary message buffer */ +static char *p; /* current position in the packet */ +static char *msgbuf; /* message buffer for summary mode */ +static boolean_t url_auth = B_FALSE; +static boolean_t attr_auth = B_FALSE; +static boolean_t fresh = B_FALSE; +static boolean_t overflow = B_FALSE; +static int v1_charset = 0; /* character set; only in V1 */ + +/* Entry points for parsing the protocol */ +static int interpret_slp_v1(int, struct slpv1_hdr *, int); +static int interpret_slp_v2(int, struct slpv2_hdr *, int); + +/* header parsing */ +static int v1_header(int, struct slpv1_hdr *, int); +static int v2_header(int, struct slpv2_hdr *, int *, int); +static int v2_finish(struct slpv2_hdr *, int); + +/* V2 auth blocks */ +static int slpv2_authblock(int); + +/* From snoop_rport: */ +extern int add_transient(int, int (*)()); + +/* + * Functions for parsing each protocol message + * Each function takes the interpreter's flags argument as its input + * parameter, and returns 1 on success, or 0 on message corruption. + * retlength is set as a side-effect in summary mode. + */ +static int v2_srv_rqst(int); +static int v2_srv_rply(int); +static int v2_srv_reg(int); +static int v2_srv_dereg(int); +static int v2_srv_ack(int); +static int v2_attr_rqst(int); +static int v2_attr_rply(int); +static int v2_daadvert(int); +static int v2_srv_type_rqst(int); +static int v2_srv_type_rply(int); +static int v2_saadvert(int); + +static int v1_srv_rqst(int); +static int v1_srv_rply(int); +static int v1_srv_reg(int); +static int v1_srv_dereg(int); +static int v1_srv_ack(int); +static int v1_attr_rqst(int); +static int v1_attr_rply(int); +static int v1_daadvert(int); +static int v1_srv_type_rqst(int); +static int v1_srv_type_rply(int); + +/* + * The dispatch tables for handling individual messages, keyed by + * function number. + */ +typedef int function_handler(); + +#define V2_MAX_FUNCTION 11 + +static function_handler *v2_functions[V2_MAX_FUNCTION + 1] = { + (function_handler *) NULL, + (function_handler *) v2_srv_rqst, + (function_handler *) v2_srv_rply, + (function_handler *) v2_srv_reg, + (function_handler *) v2_srv_dereg, + (function_handler *) v2_srv_ack, + (function_handler *) v2_attr_rqst, + (function_handler *) v2_attr_rply, + (function_handler *) v2_daadvert, + (function_handler *) v2_srv_type_rqst, + (function_handler *) v2_srv_type_rply, + (function_handler *) v2_saadvert }; + +#define V1_MAX_FUNCTION 10 + +static function_handler *v1_functions[V1_MAX_FUNCTION + 1] = { + (function_handler *) NULL, + (function_handler *) v1_srv_rqst, + (function_handler *) v1_srv_rply, + (function_handler *) v1_srv_reg, + (function_handler *) v1_srv_dereg, + (function_handler *) v1_srv_ack, + (function_handler *) v1_attr_rqst, + (function_handler *) v1_attr_rply, + (function_handler *) v1_daadvert, + (function_handler *) v1_srv_type_rqst, + (function_handler *) v1_srv_type_rply }; + +/* TCP continuation handling */ +static boolean_t tcp_continuation = B_FALSE; + +#define MAX_TCPCONT 16 + +static struct tcp_cont { + int dst_port; + char *msg; + int totallen; + int curr_offset; +} *tcp_cont[MAX_TCPCONT]; + +static int current_tcp_cont; + +static void reg_tcp_cont(char *, int, int, int); +static int add_tcp_cont(struct tcp_cont *, char *, int); +static struct tcp_cont *find_tcp_cont(int); +static void remove_tcp_cont(int); + +/* Conversions from numbers to strings */ +static char *slpv2_func(int, boolean_t); +static char *slpv2_error(unsigned short); +static char *slpv1_func(int, boolean_t); +static char *slpv1_error(unsigned short); +static char *slpv1_charset(unsigned short); + +/* + * The only external entry point to the SLP interpreter. This function + * simply dispatches the packet based on the version. + */ +void interpret_slp(int flags, char *slp, int fraglen) { + extern int dst_port, curr_proto; + struct tcp_cont *tce = NULL; + + msglength = fraglen; + retlength = 0; + p = slp; + + /* check if this is a TCP continuation */ + if (flags & F_DTAIL && curr_proto == IPPROTO_TCP) { + tce = find_tcp_cont(dst_port); + if (tce) { + if (add_tcp_cont(tce, slp, fraglen)) { + slp = tce->msg; + fraglen = tce->curr_offset; + tcp_continuation = B_TRUE; + } + } + } + if (*slp == 2 || tce) + interpret_slp_v2(flags, (void *)slp, fraglen); + else + interpret_slp_v1(flags, (void *)slp, fraglen); + + tcp_continuation = B_FALSE; +} + +/* + * Primitives. These are implemented as much as possible as macros for + * speed. + */ + +#define FIELD_DEFAULT 0 +#define FIELD_PREVRESP 1 +#define FIELD_TYPENA 2 + +static long long netval = 0; /* need signed 64 bit quantity */ + +/* gets two bytes from p and leaves the result in netval */ +#define nbtohs() \ + netval = ((int)(p[0] & 0xff)) << 8; \ + netval += ((int)(p[1] & 0xff)) + +/* gets four bytes from p and leaves the result in netval */ +#define nbtohl() \ + netval = ((int)(p[0] & 0xff)) << 24; \ + netval += ((int)(p[1] & 0xff)) << 16; \ + netval += ((int)(p[2] & 0xff)) << 8; \ + netval += ((int)(p[3] & 0xff)) + +#define get_byte() \ + if (msglength >= 1) { \ + netval = *p; \ + p++; \ + msglength--; \ + } else \ + netval = -1 + +#define GETBYTE(x) \ + get_byte(); \ + if ((retlength = netval) < 0) \ + return (0); \ + x = netval + +#define SKIPBYTE \ + get_byte(); \ + if ((retlength = netval) < 0) \ + return (0); \ + +/* + * gets two bytes from p, leaves the result in netval, and updates + * msglength and p. + */ +#define get_short() \ + if (msglength >= sizeof (unsigned short)) { \ + nbtohs(); \ + p += sizeof (unsigned short); \ + msglength -= sizeof (unsigned short); \ + } else \ + netval = -1 + +#define GETSHORT(x) \ + get_short(); \ + if ((retlength = netval) < 0) \ + return (0); \ + x = netval + +#define SKIPSHORT \ + get_short(); \ + if ((retlength = netval) < 0) \ + return (0) + +#define get_int24(pp) \ + netval = ((int)((pp)[0] & 0xff)) << 16; \ + netval += ((int)((pp)[1] & 0xff)) << 8; \ + netval += ((int)((pp)[2] & 0xff)) + +static void slp_prevresp(char *p) { + char *p2; + + /* cycle through all entries */ + for (; p != NULL; p = p2) { + p2 = strchr(p, ','); + if (p2 != NULL) + *p2++ = '\0'; + + /* print entry at p */ + sprintf(get_line(0, 0), " \"%s\"", p); + } +} + +static int skip_field(int type) { + unsigned short stringlen; + + get_short(); + if (netval < 0) { + return (-1); + } + stringlen = netval; + + /* special case for NA field in SrvTypeRqst */ + if (type == FIELD_TYPENA && stringlen == 0xffff) { + stringlen = 0; + } + + if (stringlen > msglength) { + return (-1); + } + + msglength -= stringlen; + p += stringlen; + + return (stringlen); +} + +#define SKIPFIELD(type) \ + if ((retlength = skip_field(type)) < 0) \ + return (0) + +#define GETFIELD \ + get_short(); \ + if ((retlength = netval) < 0) \ + return (0); \ + strncat(msgbuf, p, (retlength > MAXSUMLEN ? MAXSUMLEN : retlength)); \ + p += retlength; \ + msglength -= retlength + +/* + * Determines from the first five bytes of a potential SLP header + * if the following message is really an SLP message. Returns 1 if + * it is a real SLP message, 0 if not. + */ +int valid_slp(unsigned char *slphdr, int len) { + struct slpv1_hdr slp1; + struct slpv2_hdr slp2; + + len -= (8 /* udp */ + 20 /* IP */ + 14 /* ether */); + /* a valid version will be 1 or 2 */ + switch (*slphdr) { + case 1: + memcpy(&slp1, slphdr, 5); + /* valid function? */ + if (slp1.function > V1_MAX_FUNCTION) { + return (0); + } + /* valid length heuristic */ + if (slp1.length > len) { + return (0); + } + return (1); + case 2: + memcpy(&slp2, slphdr, 5); + /* valid function? */ + if (slp2.function > V2_MAX_FUNCTION) { + return (0); + } + /* valid length heuristic */ + get_int24(&(slp2.l1)); + if (netval > len) { + return (0); + } + return (1); + default: + return (0); + } +} + +/* + * Converts a V1 char encoding to UTF8. If this fails, returns 0, + * otherwise, 1. This function is the union of iconv UTF-8 + * modules and character sets registered with IANA. + */ +static int make_utf8(char *outbuf, size_t outlen, + const char *inbuf, size_t inlen) { + iconv_t cd; + size_t converted; + + switch (v1_charset) { + case 4: + case 1004: + cd = iconv_open("UTF-8", "8859-1"); + break; + case 5: + cd = iconv_open("UTF-8", "8859-2"); + break; + case 6: + cd = iconv_open("UTF-8", "8859-3"); + break; + case 7: + cd = iconv_open("UTF-8", "8859-4"); + break; + case 8: + cd = iconv_open("UTF-8", "8859-5"); + break; + case 9: + cd = iconv_open("UTF-8", "8859-6"); + break; + case 10: + cd = iconv_open("UTF-8", "8859-7"); + break; + case 11: + cd = iconv_open("UTF-8", "8859-8"); + break; + case 12: + cd = iconv_open("UTF-8", "8859-9"); + break; + case 13: + cd = iconv_open("UTF-8", "8859-10"); + break; + case 37: + cd = iconv_open("UTF-8", "ko_KR-iso2022-7"); + break; + case 104: + cd = iconv_open("UTF-8", "iso2022"); + break; + case 1000: + cd = iconv_open("UTF-8", "UCS-2"); + break; + case 1001: + cd = iconv_open("UTF-8", "UCS-4"); + break; + default: + /* + * charset not set, or reserved, or not supported, so + * just copy it and hope for the best. + */ + converted = outlen < inlen ? outlen : inlen; + memcpy(outbuf, inbuf, converted); + outbuf[converted] = 0; + return (1); + } + + if (cd == (iconv_t)-1) { + return (0); + } + + if ((converted = iconv(cd, &inbuf, &inlen, &outbuf, &outlen)) + == (size_t)-1) { + return (0); + } + + outbuf[converted] = 0; + iconv_close(cd); + + return (1); +} + +static int slp_field(char *tag, int type) { + int length; + + get_short(); + if (netval < 0) { + return (-1); + } + length = netval; + + /* special case for NA field in SrvTypeRqst */ + if (type == FIELD_TYPENA && length == 0xffff) { + sprintf(get_line(0, 0), "%s: length = -1: Use all NAs", tag); + return (0); + } + + sprintf(get_line(0, 0), "%s: length = %d", tag, length); + if (length > msglength) { + /* framing error: message is not long enough to contain data */ + sprintf(get_line(0, 0), + " [Framing error: remaining pkt length = %u]", + msglength); + return (-1); + } + + if (length > 0) { + char *buf = malloc(length + 1); + if (buf != NULL) { + if (v1_charset) { + if (!make_utf8(buf, length, p, length)) { + strcpy(buf, "[Invalid Character Encoding]"); + } + } else { + memcpy(buf, p, length); + buf[length] = '\0'; /* ensure null-terminated */ + } + + switch (type) { + case FIELD_PREVRESP: + slp_prevresp(buf); + break; + + default: + sprintf(get_line(0, 0), " \"%s\"", buf); + break; + } + free(buf); + } + + p += length; + msglength -= length; + } + + /* return ok */ + return (0); +} + +static int slpv2_url(int cnt) { + time_t exp; + int lifetime, length, n; + + /* reserved */ + get_byte(); + if (netval < 0) + return (-1); + + /* lifetime */ + get_short(); + if ((lifetime = netval) < 0) + return (-1); + + /* length */ + get_short(); + if ((length = netval) < 0) + return (-1); + + /* time */ + exp = time(0) + lifetime; + if (cnt == -1) + sprintf(get_line(0, 0), + "URL: length = %u, lifetime = %d (%24.24s)", + length, lifetime, ctime(&exp)); + else + /* number the URLs to make it easier to parse them */ + sprintf(get_line(0, 0), + "URL %d: length = %u, lifetime = %d (%24.24s)", + cnt, length, lifetime, ctime(&exp)); + + if (length > msglength) { + if (!tcp_continuation) + /* framing error: message is not long enough to contain data */ + sprintf(get_line(0, 0), + " [Framing error: remaining pkt length = %u]", + msglength); + return (-1); + } + + if (length > 0) { + char *buf = malloc(length + 1); + if (buf != NULL) { + memcpy(buf, p, length); + buf[length] = '\0'; /* ensure null-terminated */ + sprintf(get_line(0, 0), " \"%s\"", buf); + free(buf); + } + } + msglength -= length; + p += length; + + get_byte(); + if ((n = netval) < 0) + return (-1); + + if (n > 0) { + int i; + sprintf(get_line(0, 0), "%d Authentication Blocks", n); + for (i = 0; i < n; i++) + if ((length = slpv2_authblock(i)) < 0) + return (-1); + } + return (0); +} + +#define DOFIELD(tag, type) \ + if (slp_field(tag, type) < 0) \ + return (0) + +#define V2_DOURL(x) \ + if (slpv2_url(x) < 0) \ + return (0) + +#define V2_DOERRCODE \ + if (msglength < sizeof (unsigned short)) \ + return (0); \ + nbtohs(); \ + errcode = netval; \ + sprintf(get_line(0, 0), "Error code = %d, %s", \ + errcode, slpv2_error(errcode)); \ + p += sizeof (unsigned short); \ + msglength -= sizeof (unsigned short); \ + if (errcode != OK) \ + msglength = 0; /* skip rest of message */ \ + if (errcode != OK) \ + return (0) + +#define V2_DOAUTH(cnt) \ + if (slpv2_authblock(cnt) < 0) \ + return (0) + +#define V2_DOTIMESTAMP \ + if (msglength < 4) \ + return (0); \ + nbtohl(); \ + timestamp = netval; \ + sprintf(get_line(0, 0), "Timestamp = %u, %s", \ + timestamp, (timestamp ? convert_ts(timestamp) : "0")); \ + p += 4; \ + msglength -= 4 + +/* some V1 macros */ +#define SKIPAUTH(auth) \ + if (auth && ((retlength = skip_v1authblock()) < 0)) \ + return (0) + +#define DOERRCODE \ + if (msglength < sizeof (unsigned short)) \ + return (0); \ + nbtohs(); \ + errcode = netval; \ + sprintf(get_line(0, 0), "Error code = %d, %s", errcode, \ + slpv1_error(errcode)); \ + p += sizeof (unsigned short); \ + msglength -= sizeof (unsigned short); \ + if (errcode != OK) \ + return (0) + +#define DOURL \ + if (slpv1_url(url_auth) < 0) \ + return (0) + +#define DOAUTH(auth) \ + if (auth && slpv1_authblock() < 0) \ + return (0) + +/* + * TCP Continuation handling + * We keep track of continuations in a fixed size cache, so as to prevent + * memory leaks if some continuations are never finished. The continuations + * are indexed by their destination ports. + */ +static void reg_tcp_cont(char *msg, int totallen, + int fraglen, int dst_port) { + struct tcp_cont *tce = malloc(sizeof (*tce)); + + /* always overwrite the entry at current_tcp_cont */ + if (tcp_cont[current_tcp_cont]) { + free(tcp_cont[current_tcp_cont]->msg); + free(tcp_cont[current_tcp_cont]); + } + + tce->dst_port = dst_port; + tce->msg = malloc(totallen); + memcpy(tce->msg, msg, fraglen); + tce->totallen = totallen; + tce->curr_offset = fraglen; + + tcp_cont[current_tcp_cont++] = tce; + if (current_tcp_cont == MAX_TCPCONT) + current_tcp_cont = 0; +} + +/* returns 0 if there is a mismatch error, 1 on success */ +static int add_tcp_cont(struct tcp_cont *tce, char *msg, int fraglen) { + if ((fraglen + tce->curr_offset) > tce->totallen) + return (0); + + memcpy(tce->msg + tce->curr_offset, msg, fraglen); + tce->curr_offset += fraglen; + return (1); +} + +static struct tcp_cont *find_tcp_cont(int dst_port) { + int i; + for (i = current_tcp_cont; i >= 0; i--) + if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) + return (tcp_cont[i]); + + for (i = MAX_TCPCONT -1; i > current_tcp_cont; i--) + if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) + return (tcp_cont[i]); + + return (NULL); +} + +static void remove_tcp_cont(int dst_port) { + int i; + for (i = current_tcp_cont; i >= 0; i--) + if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) { + free(tcp_cont[i]->msg); + free(tcp_cont[i]); + tcp_cont[i] = NULL; + return; + } + + for (i = MAX_TCPCONT -1; i > current_tcp_cont; i--) + if (tcp_cont[i] && tcp_cont[i]->dst_port == dst_port) { + free(tcp_cont[i]->msg); + free(tcp_cont[i]); + tcp_cont[i] = NULL; + return; + } +} + +/* + * V2 interpreter + */ + +static int interpret_slp_v2(int flags, struct slpv2_hdr *slp, int fraglen) { + extern int src_port, dst_port, curr_proto; + char msgbuf_real[256]; + int totallen = 0; + + msgbuf = msgbuf_real; + + /* + * Somewhat of a hack to decode traffic from a server that does + * not send udp replies from its SLP src port. + */ + + if (curr_proto == IPPROTO_UDP && + dst_port == 427 && + src_port != 427) { + add_transient(src_port, (int (*)())interpret_slp); + } + + /* parse the header */ + if (v2_header(flags, slp, &totallen, fraglen)) { + + if (slp->function <= V2_MAX_FUNCTION && slp->function > 0) { + + /* Parse the message body */ + if ((v2_functions[slp->function])(flags)) { + + /* finish any remaining tasks */ + v2_finish(slp, flags); + + } + + } + + } + + /* summary error check */ + if (flags & F_SUM) { + if (retlength < 0) { + if (curr_proto == IPPROTO_TCP) + sprintf(get_sum_line(), + "%s [partial TCP message]", msgbuf); + else if (overflow) + sprintf(get_sum_line(), "%s [OVERFLOW]", msgbuf); + else + sprintf(get_sum_line(), "%s [CORRUPTED MESSAGE]", msgbuf); + } +#ifdef VERIFYSLP + else if (msglength > 0) + sprintf(get_sum_line(), "%s +%d", msgbuf, msglength); +#endif + else + sprintf(get_sum_line(), "%s", msgbuf); + } else if (flags & F_DTAIL) { + /* detailed error check */ + if (msglength > 0) { + if (tcp_continuation) { + sprintf(get_line(0, 0), + "[TCP Continuation, %d bytes remaining]", + totallen - fraglen); + } else + sprintf(get_line(0, 0), + "[%d extra bytes at end of SLP message]", msglength); + } + + show_trailer(); + + if (tcp_continuation && msglength == 0) + remove_tcp_cont(dst_port); + } + + return (0); +} + +static int v2_header(int flags, + struct slpv2_hdr *slp, + int *totallen, + int fraglen) { + extern int curr_proto, dst_port; + char *prototag = (curr_proto == IPPROTO_TCP ? "/tcp" : ""); + + if ((slp->flags & V2_OVERFLOW) == V2_OVERFLOW) + overflow = B_TRUE; + + /* summary mode header parsing */ + if (flags & F_SUM) { + + /* make sure we have at least a header */ + if (msglength < sizeof (*slp)) { + sprintf(get_sum_line(), "SLP V2 [Incomplete Header]"); + return (0); + } + + sprintf(msgbuf, "SLP V2 %s [%d%s] ", + slpv2_func(slp->function, B_TRUE), + ntohs(slp->xid), prototag); + + /* skip to end of header */ + msgend = msgbuf + strlen(msgbuf); + msglength -= sizeof (*slp); + p += sizeof (*slp); + + /* skip language tag */ + SKIPFIELD(FIELD_DEFAULT); + } else if (flags & F_DTAIL) { + char *lang; + int len; + + /* detailed mode header parsing */ + show_header("SLP: ", "Service Location Protocol (v2)", fraglen); + show_space(); + + if (msglength < sizeof (*slp)) { + sprintf(get_line(0, 0), "==> Incomplete SLP header"); + return (0); + } + + sprintf(get_line(0, 0), "Version = %d", slp->vers); + sprintf(get_line(0, 0), "Function = %d, %s", + slp->function, slpv2_func(slp->function, B_FALSE)); + get_int24(&(slp->l1)); + *totallen = netval; + sprintf(get_line(0, 0), "Message length = %u", *totallen); + /* check for TCP continuation */ + if (curr_proto == IPPROTO_TCP && + *totallen > msglength && + !tcp_continuation) { + tcp_continuation = B_TRUE; + reg_tcp_cont((char *)slp, *totallen, msglength, dst_port); + } + + if (!tcp_continuation && *totallen != msglength) { + sprintf(get_line(0, 0), + " (Stated and on-the-wire lengths differ)"); + } + /* flags */ + sprintf(get_line(0, 0), "Flags = 0x%02x", slp->flags); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V2_OVERFLOW, + "overflow", "no overflow")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V2_FRESH, + "fresh registration", "no fresh registration")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V2_MCAST, + "request multicast / broadcast", "unicast")); + /* check reserved flags that must be zero */ + if ((slp->flags & 7) != 0) { + sprintf(get_line(0, 0), + " .... .xxx = %d (reserved flags nonzero)", + slp->flags & 7); + } + /* end of flags */ + + /* language tag */ + p = (char *)slp + sizeof (*slp); + msglength -= sizeof (*slp); + GETSHORT(len); + if (len > msglength) { + sprintf(get_line(0, 0), + "Language Tag Length = %u [CORRUPT MESSAGE]", + len); + return (0); + } + + lang = get_line(0, 0); + strcpy(lang, "Language Tag = "); + strncat(lang, p, len); + sprintf(get_line(0, 0), "XID = %u", ntohs(slp->xid)); + + /* set msglength to remaining length of SLP message */ + p += len; + msglength -= len; + } + + return (1); +} + +static int v2_finish(struct slpv2_hdr *slp, int flags) { + unsigned int firstop; + + if (!(flags & F_DTAIL)) + return (1); + + /* check for options */ + get_int24(&(slp->o1)); + firstop = netval; + + if (firstop) { + unsigned short op_id; + unsigned short nextop; + char *op_class; + + for (;;) { + unsigned short real_oplen; + + if (msglength < 4) { + sprintf(get_line(0, 0), + "Option expected but not present"); + return (0); + } + + nbtohs(); + op_id = netval; + p += sizeof (unsigned short); + msglength -= sizeof (unsigned short); + nbtohs(); + nextop = netval; + p += sizeof (unsigned short); + msglength -= sizeof (unsigned short); + + real_oplen = nextop ? nextop : msglength; + + /* known options */ + switch (op_id) { + case 1: + sprintf(get_line(0, 0), + "Option: Required Attribute Missing"); + DOFIELD("Template IDVer", FIELD_DEFAULT); + DOFIELD("Required Attrs", FIELD_DEFAULT); + break; + default: + sprintf(get_line(0, 0), "Option: Unknown"); + p += (real_oplen - 4); + msglength -= (real_oplen - 4); + break; + } + + if (op_id < 0x3fff) + op_class = "Standardized, optional"; + else if (op_id < 0x7fff) + op_class = "Standardized, mandatory"; + else if (op_id < 0x8fff) + op_class = "Not standardized, private"; + else if (op_id < 0xffff) + op_class = "Reserved"; + sprintf(get_line(0, 0), "Option ID = 0x%04x, %s", + op_id, op_class); + if (nextop && + ((nextop - 4) > msglength) && + !tcp_continuation) { + sprintf(get_line(0, 0), + "[Framing error: remaining pkt length = %u]", + msglength); + return (0); + } + + sprintf(get_line(0, 0), "Option Length = %u", real_oplen); + + if (!nextop) + break; + } + } + + return (1); +} + +#ifdef VERIFYSLP +static int skip_v2authblock() { + unsigned short length, slen; + + /* auth header */ + if (msglength < 10) + return (-1); + + /* block descriptor: 2 bytes */ + p += sizeof (unsigned short); + /* length */ + nbtohs(); + length = netval; + p += sizeof (unsigned short); + /* timestamp */ + p += 4; + /* SPI String length */ + nbtohs(); + slen = netval; + p += sizeof (unsigned short); + + msglength -= 10; + if (slen > msglength || length > (msglength + 10)) + return (-1); + + p += slen; + msglength -= slen; + + /* structured auth block */ + p += (length - 10 - slen); + msglength -= (length - 10 - slen); + return (0); +} +#endif + +static char *display_bsd(unsigned short bsd) { + switch (bsd) { + case 1: return ("MD5 with RSA"); + case 2: return ("DSA with SHA-1"); + case 3: return ("Keyed HMAC with MD5"); + default: return ("Unknown BSD"); + } +} + +static char *slpv2_func(int t, boolean_t s) { + static char buf[128]; + + switch (t) { + case V2_SRVRQST: return s? "SrvRqst" : "Service Request"; + case V2_SRVRPLY: return s? "SrvRply" : "Service Reply"; + case V2_SRVREG: return s? "SrvReg" : "Service Registration"; + case V2_SRVDEREG: + return (s ? "SrvDereg" : "Service Deregistration"); + case V2_SRVACK: return s? "SrvAck" : "Service Acknowledge"; + case V2_ATTRRQST: return s? "AttrRqst" : "Attribute Request"; + case V2_ATTRRPLY: return s? "AttrRply" : "Attribute Reply"; + case V2_DAADVERT: return s? "DAAdvert" : "DA advertisement"; + case V2_SRVTYPERQST: + return (s ? "SrvTypeRqst" : "Service Type Request"); + case V2_SRVTYPERPLY: + return (s ? "SrvTypeRply" : "Service Type Reply"); + case V2_SAADVERT: return s? "SAAdvert" : "SA advertisement"; + } + sprintf(buf, "(func %d)", t); + return (s ? buf : "unknown function"); +} + +static char *slpv2_error(unsigned short code) { + static char buf[128]; + + switch (code) { + case OK: return "ok"; + case LANG_NOT_SUPPORTED: return "language not supported"; + case PROTOCOL_PARSE_ERR: return "protocol parse error"; + case INVALID_REGISTRATION: return "invalid registration"; + case SCOPE_NOT_SUPPORTED: return "scope not supported"; + case AUTHENTICATION_UNKNOWN: return "authentication unknown"; + case V2_AUTHENTICATION_ABSENT: return "authentication absent"; + case V2_AUTHENTICATION_FAILED: return "authentication failed"; + case V2_VER_NOT_SUPPORTED: return "version not supported"; + case V2_INTERNAL_ERROR: return "internal error"; + case V2_DA_BUSY_NOW: return "DA busy"; + case V2_OPTION_NOT_UNDERSTOOD: return "option not understood"; + case V2_INVALID_UPDATE: return "invalid update"; + case V2_RQST_NOT_SUPPORTED: return "request not supported"; + case INVALID_LIFETIME: return "invalid lifetime"; + } + sprintf(buf, "error %d", code); + return (buf); +} + +static char *convert_ts(unsigned int timestamp) { + /* timestamp is in UNIX time */ + static char buff[128]; + + strcpy(buff, ctime((time_t *)×tamp)); + buff[strlen(buff) - 1] = '\0'; + return (buff); +} + +static int slpv2_authblock(int cnt) { + unsigned short bsd, length, slen; + char *pp, *scopes; + unsigned int timestamp; + + if (msglength < 10) { + sprintf(get_line(0, 0), + " [no room for auth block header: remaining msg length = %u]", + msglength); + return (-1); + } + + /* bsd */ + nbtohs(); + bsd = netval; + p += sizeof (unsigned short); + + /* length */ + nbtohs(); + length = netval; + p += sizeof (unsigned short); + + /* timestamp */ + nbtohl(); + timestamp = netval; + p += 4; + + /* SPI String length */ + nbtohs(); + slen = netval; + p += sizeof (unsigned short); + + msglength -= 10; + if (slen > msglength) { + sprintf(get_line(0, 0), + " [no room for auth block scopes: remaining msg length = %u]", + msglength); + return (-1); + } + + if (length > (msglength + 10)) { + if (!tcp_continuation) + /* framing error: message is not long enough to contain data */ + sprintf(get_line(0, 0), + " [Framing error: remaining pkt length = %u]", + msglength); + return (-1); + } + + scopes = p; + p += slen; + msglength -= slen; + + sprintf(get_line(0, 0), + "Auth block %d: timestamp = %s", cnt, + (timestamp) ? convert_ts(timestamp) : "0"); + + pp = get_line(0, 0); + strcpy(pp, " SPI = "); + strncat(pp, scopes, slen); + + sprintf(get_line(0, 0), + " block desc = 0x%04x: %s", bsd, display_bsd(bsd)); + + sprintf(get_line(0, 0), " length = %u", length); + + p += (length - 10 - slen); + msglength -= (length - 10 - slen); + return (0); +} + +static int v2_srv_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_DEFAULT); /* PR list */ + GETFIELD; /* service type */ + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + strcat(msgend, " ["); + GETFIELD; /* predicate */ + strcat(msgend, "]"); + SKIPFIELD(FIELD_DEFAULT); /* SPI */ + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_DEFAULT); + DOFIELD("Service type", FIELD_DEFAULT); + DOFIELD("Scopes", FIELD_DEFAULT); + DOFIELD("Predicate string", FIELD_DEFAULT); + DOFIELD("Requested SPI", FIELD_DEFAULT); + } + + return (1); +} + +static int v2_srv_rply(int flags) { + unsigned short itemcnt, errcode; + int n; + + if (flags & F_SUM) { + int i, auth_cnt; + + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv2_error(errcode)); + msglength = 0; /* skip rest of message */ + return (0); + } else { + GETSHORT(itemcnt); + sprintf(msgend, "%d URL entries", itemcnt); +#ifdef VERIFYSLP + for (n = 0; n < itemcnt; n++) { + SKIPBYTE; /* reserved */ + SKIPSHORT; /* lifetime */ + SKIPFIELD(FIELD_DEFAULT); /* URL */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; auth_cnt++) + if (skip_v2authblock() < 0) + return (0); + } +#endif + } + } else if (flags & F_DTAIL) { + V2_DOERRCODE; + GETSHORT(itemcnt); + sprintf(get_line(0, 0), "URL entry count = %d", itemcnt); + for (n = 0; n < itemcnt; n++) { + V2_DOURL(n); + } + } + + return (1); +} + +static int v2_srv_reg(int flags) { + int i, auth_cnt; + + if (flags & F_SUM) { + SKIPBYTE; /* reserved */ + SKIPSHORT; /* lifetime */ + GETFIELD; /* URL */ +#ifdef VERIFYSLP + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); + SKIPFIELD(FIELD_DEFAULT); /* type */ + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + SKIPFIELD(FIELD_DEFAULT); /* attrs */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); +#endif + } if (flags & F_DTAIL) { + V2_DOURL(-1); + DOFIELD("Service type", FIELD_DEFAULT); + DOFIELD("Scopes", FIELD_DEFAULT); + DOFIELD("Attribute list", FIELD_DEFAULT); + /* auth */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + V2_DOAUTH(i); + } + + return (1); +} + +static int v2_srv_dereg(int flags) { + if (flags & F_SUM) { + int i, auth_cnt; + + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + SKIPBYTE; /* reserved */ + SKIPSHORT; /* lifetime */ + GETFIELD; /* URL */ + +#ifdef VERIFYSLP + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); + SKIPFIELD(FIELD_DEFAULT); /* attrs */ +#endif + } else if (flags & F_DTAIL) { + DOFIELD("Scopes", FIELD_DEFAULT); + V2_DOURL(-1); + DOFIELD("Tag list", FIELD_DEFAULT); + } + + return (1); +} + +static int v2_srv_ack(int flags) { + unsigned short errcode; + if (flags & F_SUM) { + GETSHORT(errcode); + strcat(msgbuf, slpv2_error(errcode)); + } else if (flags & F_DTAIL) { + V2_DOERRCODE; + } + + return (1); +} + +static int v2_attr_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_DEFAULT); /* PR list */ + GETFIELD; /* URL */ + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + strcat(msgend, " ["); + GETFIELD; /* attrs */ + strcat(msgend, "]"); + +#ifdef VERIFYSLP + SKIPFIELD(FIELD_DEFAULT); /* SPI */ +#endif + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_DEFAULT); + DOFIELD("URL", FIELD_DEFAULT); + DOFIELD("Scopes", FIELD_DEFAULT); + DOFIELD("Tag list", FIELD_DEFAULT); + DOFIELD("Requested SPI", FIELD_DEFAULT); + } + + return (1); +} + +static int v2_attr_rply(int flags) { + int auth_cnt, i; + unsigned short errcode; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv2_error(errcode)); + msglength = 0; /* skip rest of message */ + return (0); + } else { + GETFIELD; /* attr list */ + +#ifdef VERIFYSLP + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); +#endif + } + } else if (flags & F_DTAIL) { + V2_DOERRCODE; + DOFIELD("Attribute list", FIELD_DEFAULT); + /* auth */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + V2_DOAUTH(i); + } + + return (1); +} + +static int v2_daadvert(int flags) { + int auth_cnt, i; + unsigned short errcode; + unsigned int timestamp; + + if (flags & F_SUM) { + SKIPSHORT; /* error code */ + SKIPSHORT; SKIPSHORT; /* timestamp */ + GETFIELD; /* URL */ + +#ifdef VERIFYSLP + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + SKIPFIELD(FIELD_DEFAULT); /* attrs */ + SKIPFIELD(FIELD_DEFAULT); /* SPIs */ + + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); +#endif + } else if (flags & F_DTAIL) { + V2_DOERRCODE; + V2_DOTIMESTAMP; + DOFIELD("URL", FIELD_DEFAULT); + DOFIELD("Scope list", FIELD_DEFAULT); + DOFIELD("Attribute list", FIELD_DEFAULT); + DOFIELD("Configured SPIs", FIELD_DEFAULT); + /* auth */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + V2_DOAUTH(i); + } + + return (1); +} + +static int v2_srv_type_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_DEFAULT); /* prev responders */ + SKIPFIELD(FIELD_TYPENA); /* naming authority */ + GETFIELD; /* scope */ + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_DEFAULT); + DOFIELD("Naming authority", FIELD_TYPENA); + DOFIELD("Scopes", FIELD_DEFAULT); + } + + return (1); +} + +static int v2_srv_type_rply(int flags) { + unsigned short errcode; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) + strcat(msgbuf, slpv2_error(errcode)); + else + GETFIELD; + } else if (flags & F_DTAIL) { + V2_DOERRCODE; + DOFIELD("Service types", FIELD_DEFAULT); + } + + return (1); +} + +static int v2_saadvert(int flags) { + int auth_cnt, i; + + if (flags & F_SUM) { + GETFIELD; /* URL */ + +#ifdef VERIFYSLP + SKIPFIELD(FIELD_DEFAULT); /* scopes */ + SKIPFIELD(FIELD_DEFAULT); /* attrs */ + + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + if (skip_v2authblock() < 0) + return (0); +#endif + } else if (flags & F_DTAIL) { + DOFIELD("URL", FIELD_DEFAULT); + DOFIELD("Scopes", FIELD_DEFAULT); + DOFIELD("Attribute list", FIELD_DEFAULT); + /* auth */ + GETBYTE(auth_cnt); + for (i = 0; i < auth_cnt; i++) + V2_DOAUTH(i); + } + + return (1); +} + +/* + * V1 Interpreter + */ + +static int interpret_slp_v1(int flags, struct slpv1_hdr *slp, int fraglen) { + char msgbuf_real[256]; + extern int src_port, dst_port, curr_proto; + boolean_t overflow = B_FALSE; + + msgbuf = msgbuf_real; + + if (msglength >= sizeof (*slp)) { + if ((slp->flags & V1_URL_AUTH) == V1_URL_AUTH) + url_auth = B_TRUE; + if ((slp->flags & V1_ATTR_AUTH) == V1_ATTR_AUTH) + attr_auth = B_TRUE; + if ((slp->flags & V1_FRESH_REG) == V1_FRESH_REG) + fresh = B_TRUE; + if ((slp->flags & V1_OVERFLOW) == V1_OVERFLOW) + overflow = B_TRUE; + } + + /* + * Somewhat of a hack to decode traffic from a server that does + * not send udp replies from its SLP src port. + */ + if (curr_proto == IPPROTO_UDP && + dst_port == 427 && + src_port != 427) + add_transient(src_port, (int (*)())interpret_slp); + + /* parse the header */ + if (v1_header(flags, slp, fraglen)) { + + if (slp->function <= V1_MAX_FUNCTION && slp->function > 0) { + + /* Parse the message body */ + (v1_functions[slp->function])(flags); + + } + + } + + /* summary error check */ + if (flags & F_SUM) { + if (retlength < 0) { + if (curr_proto == IPPROTO_TCP) + sprintf(get_sum_line(), + "%s [partial TCP message]", + msgbuf); + else if (overflow) + sprintf(get_sum_line(), "%s [OVERFLOW]", msgbuf); + else + sprintf(get_sum_line(), "%s [CORRUPTED MESSAGE]", msgbuf); + } +#ifdef VERIFYSLP + else if (msglength > 0) + sprintf(get_sum_line(), "%s +%d", msgbuf, msglength); +#endif + else + sprintf(get_sum_line(), "%s", msgbuf); + } else if (flags & F_DTAIL) { + /* detail error check */ + if (msglength > 0) { + sprintf(get_line(0, 0), + "[%d extra bytes at end of SLP message]", msglength); + } + + show_trailer(); + + } + + v1_charset = 0; + + return (0); +} + +static int v1_header(int flags, + struct slpv1_hdr *slp, + int fraglen) { + extern int src_port, dst_port, curr_proto; + char *prototag = (curr_proto == IPPROTO_TCP? "/tcp" : ""); + + if (flags & F_SUM) { + char portflag = ' '; + + if (msglength < sizeof (*slp)) { + sprintf(msgbuf, "SLP V1 [incomplete header]"); + return (0); + } + + if (slp->vers != 1) { + if (curr_proto == IPPROTO_TCP) + sprintf(msgbuf, "SLP [TCP Continuation]"); + else + sprintf(msgbuf, "SLP [unknown version %d]", slp->vers); + return (0); + } + + if (src_port != 427 && dst_port != 427) + portflag = '-'; + + sprintf(msgbuf, "SLP V1%c%s [%d%s] ", portflag, + slpv1_func(slp->function, B_TRUE), + ntohs(slp->xid), prototag); + msgend = msgbuf + strlen(msgbuf); + msglength -= sizeof (*slp); + p += sizeof (*slp); + } else if (flags & F_DTAIL) { + show_header("SLP: ", "Service Location Protocol (v1)", fraglen); + show_space(); + + if (msglength < sizeof (*slp)) { + sprintf(get_line(0, 0), "==> Incomplete SLP header"); + return (0); + } + + sprintf(get_line(0, 0), "Version = %d", slp->vers); + if (slp->vers != 1) { + if (curr_proto == IPPROTO_TCP) + sprintf(get_line(0, 0), "==> TCP continuation"); + else + sprintf(get_line(0, 0), "==> Unexpected version number"); + return (0); + } + sprintf(get_line(0, 0), "Function = %d, %s", + slp->function, slpv1_func(slp->function, B_FALSE)); + sprintf(get_line(0, 0), "Message length = %u", ntohs(slp->length)); + + /* flags */ + sprintf(get_line(0, 0), "Flags = 0x%02x", slp->flags); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V1_OVERFLOW, + "overflow", "no overflow")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V1_MONOLINGUAL, + "monolingual", "not monolingual")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V1_URL_AUTH, + "url authentication", "no url authentication")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V1_ATTR_AUTH, + "attribute authentication", "no attribute authentication")); + sprintf(get_line(0, 0), " %s", + getflag(slp->flags, V1_FRESH_REG, + "fresh registration", "no fresh registration")); + /* check reserved flags that must be zero */ + if ((slp->flags & 7) != 0) { + sprintf(get_line(0, 0), + " .... .xxx = %d (reserved flags nonzero)", + slp->flags & 7); + } + /* end of flags */ + + sprintf(get_line(0, 0), "Dialect = %u", slp->dialect); + sprintf(get_line(0, 0), "Language = 0x%02x%02x, %c%c", + slp->language[0], slp->language[1], + slp->language[0], slp->language[1]); + v1_charset = ntohs(slp->charset); + sprintf(get_line(0, 0), "Character encoding = %u, %s", + v1_charset, + slpv1_charset(v1_charset)); + sprintf(get_line(0, 0), "XID = %u", ntohs(slp->xid)); + + /* set msglength to remaining length of SLP message */ + msglength -= sizeof (*slp); + p += sizeof (*slp); + } + + return (1); +} + +static char *slpv1_func(int t, boolean_t s) { + static char buf[128]; + switch (t) { + case V1_SRVREQ: return s? "SrvRqst" : "Service Request"; + case V1_SRVRPLY: return s? "SrvRply" : "Service Reply"; + case V1_SRVREG: return s? "SrvReg" : "Service Registration"; + case V1_SRVDEREG: return s? + "SrvDereg" : "Service Deregistration"; + case V1_SRVACK: return s? "SrvAck" : "Service Acknowledge"; + case V1_ATTRRQST: return s? "AttrRqst" : "Attribute Request"; + case V1_ATTRRPLY: return s? "AttrRply" : "Attribute Reply"; + case V1_DAADVERT: return s? "DAAdvert" : "DA advertisement"; + case V1_SRVTYPERQST:return s? "SrvTypeRqst" : "Service Type Request"; + case V1_SRVTYPERPLY:return s? "SrvTypeRply" : "Service Type Reply"; + } + sprintf(buf, "(func %d)", t); + return (s ? buf : "unknown function"); +} + +static char *slpv1_error(unsigned short code) { + static char buf[128]; + + switch (code) { + case OK: return "ok"; + case LANG_NOT_SUPPORTED: return "language not supported"; + case PROTOCOL_PARSE_ERR: return "protocol parse error"; + case INVALID_REGISTRATION: return "invalid registration"; + case SCOPE_NOT_SUPPORTED: return "scope not supported"; + case CHARSET_NOT_UNDERSTOOD:return "character set not understood"; + case AUTHENTICATION_INVALID:return "invalid authentication"; + case NOT_SUPPORTED_YET: return "not yet supported"; + case REQUEST_TIMED_OUT: return "request timed out"; + case COULD_NOT_INIT_NET_RESOURCES: + return ("could not initialize net resources"); + case COULD_NOT_ALLOCATE_MEMORY: + return ("could not allocate memory"); + case PARAMETER_BAD: return "bad parameter"; + case INTERNAL_NET_ERROR: return "internal network error"; + case INTERNAL_SYSTEM_ERROR: return "internal system error"; + } + sprintf(buf, "error %d", code); + return (buf); +} + +/* + * Character set info from + * www.isi.edu/in-notes/iana/assignments/character-sets + * + * Assigned MIB enum Numbers + * ------------------------- + * 0 Reserved + * 1 Reserved + * 3-106 Set By Standards Organizations + * 1000-1010 Unicode / 10646 + * 2000-2087 Vendor + * 2250-2258 Vendor + * + * MIBenum: 3 + * Alias: US-ASCII (preferred MIME name) + * Source: ECMA registry [RFC1345] + * + * MIBenum: 106 + * Name: UTF-8 + * Source: RFC 2044 + */ + +static char *slpv1_charset(unsigned short code) { + if (code <= 1) + return ("Reserved"); + if (code == 3) + return ("US-ASCII"); + if (code == 4) + return ("latin1"); + if (code == 106) + return ("UTF-8"); + if (code >= 3 && code <= 106) + return ("set by standards organization"); + if (code >= 1000 && code <= 1010) + return ("Unicode variant"); + if ((code >= 2000 && code <= 2087) || + (code >= 2250 && code <= 2258)) + return ("Vendor assigned"); + + return ("unknown"); +} + +#ifdef VERIFYSLP +static int skip_v1authblock() { + unsigned short length; + + /* auth header: 12 bytes total */ + if (msglength < 12) + return (-1); + + /* timestamp: 8 bytes */ + p += 8; /* timestamp: 8 bytes */ + p += sizeof (short); /* block descriptor: 2 bytes */ + nbtohs(); + length = netval; + p += sizeof (short); + msglength -= 12; + + if (length > msglength) { + /* framing error: message is not long enough to contain data */ + return (-1); + } + + p += length; + msglength -= length; + return (0); +} +#endif + +static int slpv1_authblock() { + unsigned short bsd, length; + char msgbuf[128]; + int n; + + if (msglength < 12) { + sprintf(get_line(0, 0), + " [no room for auth block: remaining msg length = %u]", + msglength); + return (-1); + } + + /* timestamp: 8 bytes */ + *msgbuf = '\0'; + for (n = 0; n < 8; n++, p += 1) { + char tmp[16]; + sprintf(tmp, "%02x", (unsigned char)(*p)); + strcat(msgbuf, tmp); + } + + nbtohs(); + bsd = netval; + p += sizeof (short); + nbtohs(); + length = netval; + p += sizeof (short); + msglength -= 12; + + sprintf(get_line(0, 0), + " Auth block: timestamp = %s", + msgbuf); + sprintf(get_line(0, 0), + " block desc = 0x%04x, length = %u", + bsd, length); + if (length > msglength) { + /* framing error: message is not long enough to contain data */ + sprintf(get_line(0, 0), + " [Framing error: remaining pkt length = %u]", msglength); + return (-1); + } + + p += length; + msglength -= length; + return (0); +} + +static int slpv1_url(boolean_t auth_present) { + time_t exp; + int lifetime, length; + + get_short(); + if ((lifetime = netval) < 0) + return (-1); + get_short(); + if ((length = netval) < 0) + return (-1); + + exp = time(0) + lifetime; + sprintf(get_line(0, 0), "URL: length = %u, lifetime = %d (%24.24s)", + length, lifetime, ctime(&exp)); + if (length > msglength) { + /* framing error: message is not long enough to contain data */ + sprintf(get_line(0, 0), + " [Framing error: remaining pkt length = %u]", msglength); + return (-1); + } + + if (length > 0) { + char *buf = malloc(length + 1); + if (buf != NULL) { + if (!make_utf8(buf, length, p, length)) { + strcpy(buf, "[Invalid Character Encoding]"); + } + sprintf(get_line(0, 0), " \"%s\"", buf); + free(buf); + } + } + msglength -= length; + p += length; + + if (auth_present) + return (slpv1_authblock()); + + return (0); +} + +static int v1_srv_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_PREVRESP); /* prev responders */ + GETFIELD; /* predicate */ + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_PREVRESP); + DOFIELD("predicate string", FIELD_DEFAULT); + } + + return (1); +} + +static int v1_srv_rply(int flags) { + unsigned short errcode, itemcnt; + int n; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv1_error(errcode)); + } else { + GETSHORT(itemcnt); + sprintf(msgend, "%d URL entries", itemcnt); +#ifdef VERIFYSLP + for (n = 0; n < itemcnt; n++) { + SKIPSHORT; /* lifetime */ + SKIPFIELD(FIELD_DEFAULT); /* URL */ + SKIPAUTH(url_auth); /* URL auth */ + } +#endif + } + } else if (flags & F_DTAIL) { + DOERRCODE; + GETSHORT(itemcnt); + sprintf(get_line(0, 0), "URL entry count = %d", itemcnt); + for (n = 0; n < itemcnt; n++) { + DOURL; + } + } + + return (1); +} + +static int v1_srv_reg(int flags) { + if (flags & F_SUM) { + SKIPSHORT; /* lifetime */ + GETFIELD; /* URL */ +#ifdef VERIFYSLP + SKIPAUTH(url_auth); /* URL auth */ + SKIPFIELD(FIELD_DEFAULT); /* attribute list */ + SKIPAUTH(attr_auth); /* attr auth */ +#endif + } else if (flags & F_DTAIL) { + DOURL; + DOFIELD("Attribute list", FIELD_DEFAULT); + DOAUTH(attr_auth); + } + + return (1); +} + +static int v1_srv_ack(int flags) { + unsigned short errcode; + + if (flags & F_SUM) { + GETSHORT(errcode); + strcat(msgbuf, slpv1_error(errcode)); + if (errcode == OK && fresh) { + strcat(msgbuf, " [Fresh]"); + } + } else if (flags & F_DTAIL) { + DOERRCODE; + } + + return (1); +} + +static int v1_srv_dereg(int flags) { + if (flags & F_SUM) { + GETFIELD; /* URL */ +#ifdef VERIFYSLP + SKIPAUTH(url_auth); + SKIPFIELD(FIELD_DEFAULT); /* tag spec */ +#endif + } else if (flags & F_DTAIL) { + DOFIELD("URL", FIELD_DEFAULT); + DOAUTH(url_auth); + DOFIELD("Tag spec", FIELD_DEFAULT); + } + + return (1); +} + +static int v1_attr_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_PREVRESP); /* prev responders */ + GETFIELD; /* URL */ +#ifdef VERIFYSLP + SKIPFIELD(FIELD_DEFAULT); /* scope */ + SKIPFIELD(FIELD_DEFAULT); /* select list */ +#endif + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_PREVRESP); + DOFIELD("URL", FIELD_DEFAULT); + DOFIELD("Scope", FIELD_DEFAULT); + DOFIELD("Select list", FIELD_DEFAULT); + } + + return (1); +} + +static int v1_attr_rply(int flags) { + unsigned short errcode; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv1_error(errcode)); + } else { + GETFIELD; /* attr list */ +#ifdef VERIFYSLP + SKIPAUTH(attr_auth); +#endif + } + } else if (flags & F_DTAIL) { + DOERRCODE; + DOFIELD("Attribute list", FIELD_DEFAULT); + DOAUTH(attr_auth); + } + + return (1); +} + +static int v1_daadvert(int flags) { + unsigned short errcode; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv1_error(errcode)); + } else { + GETFIELD; /* URL */ +#ifdef VERIFYSLP + SKIPFIELD(FIELD_DEFAULT); /* scope list */ +#endif + } + } else if (flags & F_DTAIL) { + DOERRCODE; + DOFIELD("URL", FIELD_DEFAULT); + DOFIELD("Scope list", FIELD_DEFAULT); + } + + return (1); +} + +static int v1_srv_type_rqst(int flags) { + if (flags & F_SUM) { + SKIPFIELD(FIELD_PREVRESP); /* prev responders */ + SKIPFIELD(FIELD_TYPENA); /* naming authority */ + GETFIELD; /* scope */ + } else if (flags & F_DTAIL) { + DOFIELD("Previous responders", FIELD_PREVRESP); + DOFIELD("Naming authority", FIELD_TYPENA); + DOFIELD("Scope string", FIELD_DEFAULT); + } + + return (1); +} + +static int v1_srv_type_rply(int flags) { + unsigned short errcode, itemcnt; + int n; + + if (flags & F_SUM) { + GETSHORT(errcode); + if (errcode != OK) { + strcat(msgbuf, slpv1_error(errcode)); + } else { + GETSHORT(itemcnt); + sprintf(msgend, "%d type entries", itemcnt); +#ifdef VERIFYSLP + for (n = 0; n < itemcnt; n++) { + SKIPFIELD(FIELD_DEFAULT); /* Service type item */ + } +#endif + } + } else if (flags & F_DTAIL) { + DOERRCODE; + GETSHORT(itemcnt); + sprintf(get_line(0, 0), "Service type count = %d", itemcnt); + for (n = 0; n < itemcnt; n++) { + DOFIELD(" Service type item", FIELD_DEFAULT); + } + } + + return (1); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_smb.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_smb.c new file mode 100644 index 0000000..cfad4b3 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_smb.c @@ -0,0 +1,2136 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + * + * Copyright 2011 Nexenta Systems, Inc. All rights reserved. + */ + +/* + * References used throughout this code: + * + * [CIFS/1.0] : A Common Internet File System (CIFS/1.0) Protocol + * Internet Engineering Task Force (IETF) draft + * Paul J. Leach, Microsoft, Dec. 1997 + * + * [X/Open-SMB] : X/Open CAE Specification; + * Protocols for X/Open PC Interworking: SMB, Version 2 + * X/Open Document Number: C209 + */ + +#include <fcntl.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "snoop.h" + +/* + * SMB Format (header) + * [X/Open-SMB, Sec. 5.1] + */ +struct smb { + uchar_t idf[4]; /* identifier, contains 0xff, 'SMB' */ + uchar_t com; /* command code */ + uchar_t err[4]; /* NT Status, or error class+code */ + uchar_t flags; + uchar_t flags2[2]; + uchar_t re[12]; + uchar_t tid[2]; + uchar_t pid[2]; + uchar_t uid[2]; + uchar_t mid[2]; + /* + * immediately after the above 32 byte header: + * unsigned char WordCount; + * unsigned short ParameterWords[ WordCount ]; + * unsigned short ByteCount; + * unsigned char ParameterBytes[ ByteCount ]; + */ +}; + +/* smb flags */ +#define SERVER_RESPONSE 0x80 + +/* smb flags2 */ +#define FLAGS2_EXT_SEC 0x0800 /* Extended security */ +#define FLAGS2_NT_STATUS 0x4000 /* NT status codes */ +#define FLAGS2_UNICODE 0x8000 /* String are Unicode */ + +static void interpret_sesssetupX(int, uchar_t *, int, char *, int); +static void interpret_tconX(int, uchar_t *, int, char *, int); +static void interpret_trans(int, uchar_t *, int, char *, int); +static void interpret_trans2(int, uchar_t *, int, char *, int); +static void interpret_negprot(int, uchar_t *, int, char *, int); +static void interpret_default(int, uchar_t *, int, char *, int); + +/* + * Trans2 subcommand codes + * [X/Open-SMB, Sec. 16.1.7] + */ +#define TRANS2_OPEN 0x00 +#define TRANS2_FIND_FIRST 0x01 +#define TRANS2_FIND_NEXT2 0x02 +#define TRANS2_QUERY_FS_INFORMATION 0x03 +#define TRANS2_QUERY_PATH_INFORMATION 0x05 +#define TRANS2_SET_PATH_INFORMATION 0x06 +#define TRANS2_QUERY_FILE_INFORMATION 0x07 +#define TRANS2_SET_FILE_INFORMATION 0x08 +#define TRANS2_CREATE_DIRECTORY 0x0D + + +struct decode { + char *name; + void (*func)(int, uchar_t *, int, char *, int); + char *callfmt; + char *replyfmt; +}; + +/* + * SMB command codes (function names) + * [X/Open-SMB, Sec. 5.2] + */ +static struct decode SMBtable[256] = { + /* 0x00 */ + { "mkdir", 0, 0, 0 }, + { "rmdir", 0, 0, 0 }, + { "open", 0, 0, 0 }, + { "create", 0, 0, 0 }, + + { + "close", 0, + /* [X/Open-SMB, Sec. 7.10] */ + "WFileID\0" + "lLastModTime\0" + "dByteCount\0\0", + "dByteCount\0\0" + }, + + { "flush", 0, 0, 0 }, + { "unlink", 0, 0, 0 }, + + { + "move", 0, + /* [X/Open-SMB, Sec. 7.11] */ + "wFileAttributes\0" + "dByteCount\0r\0" + "UFileName\0r\0" + "UNewPath\0\0", + "dByteCount\0\0" + }, + + { + "getatr", 0, + /* [X/Open-SMB, Sec. 8.4] */ + "dBytecount\0r\0" + "UFileName\0\0", + "wFileAttributes\0" + "lTime\0" + "lSize\0" + "R\0R\0R\0R\0R\0" + "dByteCount\0\0" + }, + + { "setatr", 0, 0, 0 }, + + { + "read", 0, + /* [X/Open-SMB, Sec. 7.4] */ + "WFileID\0" + "wI/0 Bytes\0" + "LFileOffset\0" + "WBytesLeft\0" + "dByteCount\0\0", + "WDataLength\0" + "R\0R\0R\0R\0" + "dByteCount\0\0" + }, + + { + "write", 0, + /* [X/Open-SMB, Sec. 7.5] */ + "WFileID\0" + "wI/0 Bytes\0" + "LFileOffset\0" + "WBytesLeft\0" + "dByteCount\0\0", + "WDataLength\0" + "dByteCount\0\0" + }, + + { "lock", 0, 0, 0 }, + { "unlock", 0, 0, 0 }, + { "ctemp", 0, 0, 0 }, + { "mknew", 0, 0, 0 }, + + /* 0x10 */ + { + "chkpth", 0, + /* [X/Open-SMB, Sec. 8.7] */ + "dByteCount\0r\0" + "UFile\0\0", + "dByteCount\0\0" + }, + + { "exit", 0, 0, 0 }, + { "lseek", 0, 0, 0 }, + { "lockread", 0, 0, 0 }, + { "writeunlock", 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + { + "readbraw", 0, + /* [X/Open-SMB, Sec. 10.1] */ + "WFileID\0" + "LFileOffset\0" + "wMaxCount\0" + "wMinCount\0" + "lTimeout\0R\0" + "dByteCount\0\0", 0 + }, + + { "readbmpx", 0, 0, 0 }, + { "readbs", 0, 0, 0 }, + { "writebraw", 0, 0, 0 }, + { "writebmpx", 0, 0, 0 }, + { "writebs", 0, 0, 0 }, + + /* 0x20 */ + { "writec", 0, 0, 0 }, + { "qrysrv", 0, 0, 0 }, + { "setattrE", 0, 0, 0 }, + { "getattrE", 0, 0, 0 }, + + { + "lockingX", 0, + /* [X/Open-SMB, Sec. 12.2] */ + "wChainedCommand\0" + "wNextOffset\0" + "WFileID\0" + "wLockType\0" + "lOpenTimeout\0" + "W#Unlocks\0" + "W#Locks\0" + "dByteCount\0\0", 0 + }, + + { "trans", interpret_trans, 0, 0 }, + { "transs", 0, 0, 0 }, + { "ioctl", 0, 0, 0 }, + { "ioctls", 0, 0, 0 }, + { "copy", 0, 0, 0 }, + { "move", 0, 0, 0 }, + { "echo", 0, 0, 0 }, + { "writeclose", 0, 0, 0 }, + + { + /* [X/Open-SMB, Sec. 12.1] */ + "openX", 0, + /* call */ + "wChainedCommand\0" + "wNextOffset\0" + "wFlags\0" + "wMode\0" + "wSearchAttributes\0" + "wFileAttributes\0" + "lTime\0" + "wOpenFunction\0" + "lFileSize\0" + "lOpenTimeout\0R\0R\0" + "dByteCount\0r\0" + "UFileName\0\0", + /* reply */ + "wChainedCommand\0" + "wNextOffset\0" + "WFileID\0" + "wAttributes\0" + "lTime\0" + "LSize\0" + "wOpenMode\0" + "wFileType\0" + "wDeviceState\0" + "wActionTaken\0" + "lUniqueFileID\0R\0" + "wBytecount\0\0" + }, + + { + /* [CIFS 4.2.4] */ + "readX", 0, + /* call */ + "wChainedCommand\0" + "wNextOffset\0" + "WFileID\0" + "LOffset\0" + "DMaxCount\0" + "dMinCount\0" + "dMaxCountHigh\0" + "R\0" + "wRemaining\0" + "lOffsetHigh\0" + "dByteCount\0\0", + /* reply */ + "wChainedCommand\0" + "wNextOffset\0" + "dRemaining\0R\0R\0" + "DCount\0" + "dDataOffset\0" + "dCountHigh\0" + "R\0R\0R\0R\0" + "dByteCount\0\0" + }, + + { + /* [CIFS 4.2.5] */ + "writeX", 0, + /* call */ + "wChainedCommand\0" + "wNextOffset\0" + "WFileID\0" + "LOffset\0R\0R\0" + "wWriteMode\0" + "wRemaining\0" + "dDataLenHigh\0" + "DDataLen\0" + "dDataOffset\0" + "lOffsetHigh\0\0", + /* reply */ + "wChainedCommand\0" + "wNextOffset\0" + "DCount\0" + "wRemaining\0" + "wCountHigh\0\0" + }, + + /* 0x30 */ + { 0, 0, 0, 0 }, + { "closeTD", 0, 0, 0 }, + { "trans2", interpret_trans2, 0, 0 }, + { "trans2s", 0, 0, 0 }, + { + "findclose", 0, + /* [X/Open-SMB, Sec. 15.4 ] */ + "WFileID\0" + "dByteCount\0\0", + "dByteCount\0\0" + }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x40 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x50 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x60 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x70 */ + { "tcon", 0, 0, 0 }, + { + "tdis", 0, + /* [X/Open-SMB, Sec. 6.3] */ + "dByteCount\0\0", + "dByteCount\0\0" + }, + { "negprot", interpret_negprot, 0, 0 }, + { "sesssetupX", interpret_sesssetupX, 0, 0 }, + { + "uloggoffX", 0, + /* [X/Open-SMB, Sec. 15.5] */ + "wChainedCommand\0" + "wNextOffset\0\0", + "wChainedCommnad\0" + "wNextOffset\0\0" }, + { "tconX", interpret_tconX, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x80 */ + { "dskattr", 0, 0, 0 }, + { "search", 0, 0, 0 }, + { "ffirst", 0, 0, 0 }, + { "funique", 0, 0, 0 }, + { "fclose", 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0x90 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xa0 */ + /* + * Command codes 0xa0 to 0xa7 are from + * [CIFS/1.0, Sec. 5.1] + */ + { "_NT_Trans", 0, 0, 0 }, + { "_NT_Trans2", 0, 0, 0 }, + { + /* [CIFS/1.0, Sec. 4.2.1] */ + "_NT_CreateX", 0, + /* Call */ + "wChainedCommand\0" + "wNextOffset\0r\0" + "dNameLength\0" + "lCreateFlags\0" + "lRootDirFID\0" + "lDesiredAccess\0" + "lAllocSizeLow\0" + "lAllocSizeHigh\0" + "lNTFileAttributes\0" + "lShareAccess\0" + "lOpenDisposition\0" + "lCreateOption\0" + "lImpersonationLevel\0" + "bSecurityFlags\0" + "dByteCount\0r\0" + "UFileName\0\0", + /* Reply */ + "wChainedCommand\0" + "wNextOffset\0" + "bOplockLevel\0" + "WFileID\0" + "lCreateAction\0\0" + }, + { 0, 0, 0, 0 }, + { + "_NT_Cancel", 0, + /* [CIFS/1.0, Sec. 4.1.8] */ + "dByteCount\0", 0 + }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xb0 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xc0 */ + { "splopen", 0, 0, 0 }, + { "splwr", 0, 0, 0 }, + { "splclose", 0, 0, 0 }, + { "splretq", 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xd0 */ + { "sends", 0, 0, 0 }, + { "sendb", 0, 0, 0 }, + { "fwdname", 0, 0, 0 }, + { "cancelf", 0, 0, 0 }, + { "getmac", 0, 0, 0 }, + { "sendstrt", 0, 0, 0 }, + { "sendend", 0, 0, 0 }, + { "sendtxt", 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xe0 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + + /* 0xf0 */ + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 } +}; + +/* Helpers to get values in Intel order (often mis-aligned). */ +static uint16_t +get2(uchar_t *p) { + return (p[0] + (p[1]<<8)); +} +static uint32_t +get4(uchar_t *p) { + return (p[0] + (p[1]<<8) + (p[2]<<16) + (p[3]<<24)); +} +static uint64_t +get8(uchar_t *p) { + return (get4(p) | ((uint64_t)get4(p+4) << 32)); +} + +/* + * Support displaying NT times. + * Number of seconds between 1970 and 1601 year + * (134774 days) + */ +static const uint64_t DIFF1970TO1601 = 11644473600ULL; +static const uint32_t TEN_MIL = 10000000UL; +static char * +format_nttime(uint64_t nt_time) +{ + uint64_t nt_sec; /* seconds */ + uint64_t nt_tus; /* tenths of uSec. */ + uint32_t ux_nsec; + int64_t ux_sec; + + /* Optimize time zero. */ + if (nt_time == 0) { + ux_sec = 0; + ux_nsec = 0; + goto out; + } + + nt_sec = nt_time / TEN_MIL; + nt_tus = nt_time % TEN_MIL; + + if (nt_sec <= DIFF1970TO1601) { + ux_sec = 0; + ux_nsec = 0; + goto out; + } + ux_sec = nt_sec - DIFF1970TO1601; + ux_nsec = nt_tus * 100; + +out: + return (format_time(ux_sec, ux_nsec)); +} + +/* + * This is called by snoop_netbios.c. + * This is the external entry point. + */ +void +interpret_smb(int flags, uchar_t *data, int len) +{ + struct smb *smb; + struct decode *decoder; + char xtra[MAXLINE]; + ushort_t smb_flags2; + void (*func)(int, uchar_t *, int, char *, int); + + if (len < sizeof (struct smb)) + return; + + smb = (struct smb *)data; + decoder = &SMBtable[smb->com & 255]; + smb_flags2 = get2(smb->flags2); + xtra[0] = '\0'; + + /* + * SMB Header description + * [X/Open-SMB, Sec. 5.1] + */ + if (flags & F_DTAIL) { + show_header("SMB: ", "SMB Header", len); + show_space(); + + if (smb->flags & SERVER_RESPONSE) + show_line("SERVER RESPONSE"); + else + show_line("CLIENT REQUEST"); + + if (decoder->name) + show_printf("Command code = 0x%x (SMB%s)", + smb->com, decoder->name); + else + show_printf("Command code = 0x%x", smb->com); + + /* + * NT status or error class/code + * [X/Open-SMB, Sec. 5.6] + */ + if (smb_flags2 & FLAGS2_NT_STATUS) { + show_printf("NT Status = %x", get4(smb->err)); + } else { + /* Error classes [X/Open-SMB, Sec. 5.6] */ + show_printf("Error class/code = %d/%d", + smb->err[0], get2(&smb->err[2])); + } + + show_printf("Flags summary = 0x%.2x", smb->flags); + show_printf("Flags2 summary = 0x%.4x", smb_flags2); + show_printf("Tree ID (TID) = 0x%.4x", get2(smb->tid)); + show_printf("Proc. ID (PID) = 0x%.4x", get2(smb->pid)); + show_printf("User ID (UID) = 0x%.4x", get2(smb->uid)); + show_printf("Mux. ID (MID) = 0x%.4x", get2(smb->mid)); + show_space(); + } + + if ((func = decoder->func) == NULL) + func = interpret_default; + (*func)(flags, (uchar_t *)data, len, xtra, sizeof (xtra)); + + if (flags & F_SUM) { + char *p; + int sz, tl; + + /* Will advance p and decr. sz */ + p = get_sum_line(); + sz = MAXLINE; + + /* Call or Reply */ + if (smb->flags & SERVER_RESPONSE) + tl = snprintf(p, sz, "SMB R"); + else + tl = snprintf(p, sz, "SMB C"); + p += tl; + sz -= tl; + + /* The name, if known, else the cmd code */ + if (decoder->name) { + tl = snprintf(p, sz, " Cmd=SMB%s", decoder->name); + } else { + tl = snprintf(p, sz, " Cmd=0x%02X", smb->com); + } + p += tl; + sz -= tl; + + /* + * The "extra" (cmd-specific summary). + * If non-null, has leading blank. + */ + if (xtra[0] != '\0') { + tl = snprintf(p, sz, "%s", xtra); + p += tl; + sz -= tl; + } + + /* + * NT status or error class/code + * [X/Open-SMB, Sec. 5.6] + * + * Only show for response, not call. + */ + if (smb->flags & SERVER_RESPONSE) { + if (smb_flags2 & FLAGS2_NT_STATUS) { + uint_t status = get4(smb->err); + snprintf(p, sz, " Status=0x%x", status); + } else { + uchar_t errcl = smb->err[0]; + ushort_t code = get2(&smb->err[2]); + snprintf(p, sz, " Error=%d/%d", errcl, code); + } + } + } + + if (flags & F_DTAIL) + show_trailer(); +} + +static void +output_bytes(uchar_t *data, int bytecount) +{ + int i; + char buff[80]; + char word[10]; + + (void) strlcpy(buff, " ", sizeof (buff)); + for (i = 0; i < bytecount; i++) { + snprintf(word, sizeof (word), "%.2x ", data[i]); + (void) strlcat(buff, word, sizeof (buff)); + if ((i+1)%16 == 0 || i == (bytecount-1)) { + show_line(buff); + (void) strlcpy(buff, " ", sizeof (buff)); + } + } +} + +/* + * Based on the Unicode Standard, http://www.unicode.org/ + * "The Unicode Standard: A Technical Introduction", June 1998 + */ +static int +unicode2ascii(char *outstr, int outlen, uchar_t *instr, int inlen) +{ + int i = 0, j = 0; + char c; + + while (i < inlen && j < (outlen-1)) { + /* Show unicode chars >= 256 as '?' */ + if (instr[i+1]) + c = '?'; + else + c = instr[i]; + if (c == '\0') + break; + outstr[j] = c; + i += 2; + j++; + } + outstr[j] = '\0'; + return (j); +} + +/* + * Convenience macro to copy a string from the data, + * either in UCS-2 or ASCII as indicated by UCS. + * OBUF must be an array type (see sizeof) and + * DP must be an L-value (this increments it). + */ +#define GET_STRING(OBUF, DP, UCS) \ +{ \ + int _len, _sz = sizeof (OBUF); \ + if (UCS) { \ + if (((uintptr_t)DP) & 1) \ + DP++; \ + _len = unicode2ascii(OBUF, _sz, DP, 2 * _sz); \ + DP += 2 * (_len + 1); \ + } else { \ + _len = strlcpy(OBUF, (char *)DP, _sz); \ + DP += (_len + 1); \ + } \ +} + +/* + * TRANS2 information levels + * [X/Open-SMB, Sec. 16.1.6] + */ +static void +get_info_level(char *outstr, int outsz, int value) +{ + + switch (value) { + case 1: + snprintf(outstr, outsz, "Standard"); + break; + case 2: + snprintf(outstr, outsz, "Query EA Size"); + break; + case 3: + snprintf(outstr, outsz, "Query EAS from List"); + break; + case 0x101: + snprintf(outstr, outsz, "Directory Info"); + break; + case 0x102: + snprintf(outstr, outsz, "Full Directory Info"); + break; + case 0x103: + snprintf(outstr, outsz, "Names Info"); + break; + case 0x104: + snprintf(outstr, outsz, "Both Directory Info"); + break; + default: + snprintf(outstr, outsz, "Unknown"); + break; + } +} + +/* + * Interpret TRANS2_QUERY_PATH subcommand + * [X/Open-SMB, Sec. 16.7] + */ +/* ARGSUSED */ +static void +output_trans2_querypath(int flags, uchar_t *data, char *xtra, int xsz) +{ + int length; + char filename[256]; + + if (flags & F_SUM) { + length = snprintf(xtra, xsz, " QueryPathInfo"); + xtra += length; + xsz -= length; + data += 6; + (void) unicode2ascii(filename, 256, data, 512); + snprintf(xtra, xsz, " File=%s", filename); + } + + if (flags & F_DTAIL) { + show_line("FunctionName = QueryPathInfo"); + show_printf("InfoLevel = 0x%.4x", get2(data)); + data += 6; + (void) unicode2ascii(filename, 256, data, 512); + show_printf("FileName = %s", filename); + } +} + +/* + * Interpret TRANS2_QUERY_FILE subcommand + * [X/Open-SMB, Sec. 16.9] + */ +/* ARGSUSED */ +static void +output_trans2_queryfile(int flags, uchar_t *data, char *xtra, int xsz) +{ + int length; + + if (flags & F_SUM) { + length = snprintf(xtra, xsz, " QueryFileInfo"); + xtra += length; + xsz -= length; + snprintf(xtra, xsz, " FileID=0x%x", get2(data)); + } + + if (flags & F_DTAIL) { + show_line("FunctionName = QueryFileInfo"); + show_printf("FileID = 0x%.4x", get2(data)); + data += 2; + show_printf("InfoLevel = 0x%.4x", get2(data)); + } +} + +/* + * Interpret TRANS2_SET_FILE subcommand + * [X/Open-SMB, Sec. 16.10] + */ +/* ARGSUSED */ +static void +output_trans2_setfile(int flags, uchar_t *data, char *xtra, int xsz) +{ + int length; + + if (flags & F_SUM) { + length = snprintf(xtra, xsz, " SetFileInfo"); + xtra += length; + xsz -= length; + snprintf(xtra, xsz, " FileID=0x%x", get2(data)); + } + + if (flags & F_DTAIL) { + show_line("FunctionName = SetFileInfo"); + show_printf("FileID = 0x%.4x", get2(data)); + data += 2; + show_printf("InfoLevel = 0x%.4x", get2(data)); + } +} + +/* + * Interpret TRANS2_FIND_FIRST subcommand + * [X/Open-SMB, Sec. 16.3] + */ +/* ARGSUSED */ +static void +output_trans2_findfirst(int flags, uchar_t *data, char *xtra, int xsz) +{ + int length; + char filename[256]; + char infolevel[100]; + + if (flags & F_SUM) { + length = snprintf(xtra, xsz, " Findfirst"); + xtra += length; + xsz -= length; + data += 12; + (void) unicode2ascii(filename, 256, data, 512); + snprintf(xtra, xsz, " File=%s", filename); + } + + if (flags & F_DTAIL) { + show_line("FunctionName = Findfirst"); + show_printf("SearchAttributes = 0x%.4x", get2(data)); + data += 2; + show_printf("FindCount = 0x%.4x", get2(data)); + data += 2; + show_printf("FindFlags = 0x%.4x", get2(data)); + data += 2; + get_info_level(infolevel, sizeof (infolevel), get2(data)); + show_printf("InfoLevel = %s", infolevel); + data += 6; + (void) unicode2ascii(filename, 256, data, 512); + show_printf("FileName = %s", filename); + } +} + + +/* + * Interpret TRANS2_FIND_NEXT subcommand + * [X/Open-SMB, Sec. 16.4] + */ +/* ARGSUSED */ +static void +output_trans2_findnext(int flags, uchar_t *data, char *xtra, int xsz) +{ + int length; + char filename[256]; + char infolevel[100]; + + if (flags & F_SUM) { + length = snprintf(xtra, xsz, " Findnext"); + xtra += length; + xsz -= length; + data += 12; + (void) unicode2ascii(filename, 256, data, 512); + snprintf(xtra, xsz, " File=%s", filename); + } + + if (flags & F_DTAIL) { + show_line("FunctionName = Findnext"); + show_printf("FileID = 0x%.4x", get2(data)); + data += 2; + show_printf("FindCount = 0x%.4x", get2(data)); + data += 2; + get_info_level(infolevel, sizeof (infolevel), get2(data)); + show_printf("InfoLevel = %s", infolevel); + data += 2; + show_printf("FindKey = 0x%.8x", get4(data)); + data += 4; + show_printf("FindFlags = 0x%.4x", get2(data)); + data += 2; + (void) unicode2ascii(filename, 256, data, 512); + show_printf("FileName = %s", filename); + } +} + +/* + * Interpret a "Negprot" SMB + * [X/Open-SMB, Sec. 6.1] + */ +/* ARGSUSED */ +static void +interpret_negprot(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + int i, last, length; + int bytecount; + int key_len; + int wordcount; + char tbuf[256]; + struct smb *smbdata; + uchar_t *protodata; + uchar_t *byte0; + uint64_t nttime; + uint32_t caps; + ushort_t smb_flags2; + + smbdata = (struct smb *)data; + smb_flags2 = get2(smbdata->flags2); + protodata = (uchar_t *)data + sizeof (struct smb); + wordcount = *protodata++; + + if ((smbdata->flags & SERVER_RESPONSE) == 0) { + /* + * request packet: + * short bytecount; + * struct { char fmt; char name[]; } dialects + */ + bytecount = get2(protodata); + protodata += 2; + byte0 = protodata; + + if (flags & F_DTAIL) + show_printf("ByteCount = %d", bytecount); + if (bytecount > len) + bytecount = len; + + /* Walk the list of dialects. */ + i = last = 0; + tbuf[0] = '\0'; + while (protodata < (byte0 + bytecount - 2)) { + if (*protodata++ != 2) /* format code */ + break; + length = strlcpy(tbuf, (char *)protodata, + sizeof (tbuf)); + protodata += (length + 1); + if (flags & F_DTAIL) { + show_printf("Dialect[%d] = %s", + i, tbuf); + } + last = i++; + } + if (flags & F_SUM) { + /* + * Just print the last dialect, which is + * normally the interesting one. + */ + snprintf(xtra, xsz, " Dialect[%d]=%s", last, tbuf); + } + } else { + /* Parse reply */ + if (flags & F_SUM) { + snprintf(xtra, xsz, " Dialect#=%d", protodata[0]); + } + if ((flags & F_DTAIL) == 0) + return; + if (wordcount < 13) + return; + show_printf("WordCount = %d", wordcount); + show_printf("Dialect Index = %d", protodata[0]); + protodata += 2; + show_printf("Security Mode = 0x%x", protodata[0]); + protodata++; + show_printf("MaxMPXRequests = %d", get2(protodata)); + protodata += 2; + show_printf("MaxVCs = %d", get2(protodata)); + protodata += 2; + show_printf("MaxBufferSize = %d", get4(protodata)); + protodata += 4; + show_printf("MaxRawBuffer = %d", get4(protodata)); + protodata += 4; + show_printf("SessionKey = 0x%.8x", get4(protodata)); + protodata += 4; + + caps = get4(protodata); + protodata += 4; + show_printf("Capabilities = 0x%.8x", caps); + + /* Server Time */ + nttime = get8(protodata); + protodata += 8; + show_printf("Server Time = %s", format_nttime(nttime)); + + show_printf("Server TZ = %d", get2(protodata)); + protodata += 2; + + key_len = *protodata++; + show_printf("KeyLength = %d", key_len); + bytecount = get2(protodata); + protodata += 2; + show_printf("ByteCount = %d", bytecount); + + if (smb_flags2 & FLAGS2_EXT_SEC) { + show_printf("Server GUID (16)"); + output_bytes(protodata, 16); + protodata += 16; + show_printf("Security Blob (SPNEGO)"); + output_bytes(protodata, bytecount - 16); + } else { + show_printf("NTLM Challenge: (%d)", key_len); + output_bytes(protodata, key_len); + protodata += key_len; + /* + * Get Unicode from capabilities here, + * as flags2 typically doesn't have it. + * Also, this one is NOT aligned! + */ + tbuf[0] = '\0'; + if (caps & 4) { + (void) unicode2ascii(tbuf, sizeof (tbuf), + protodata, 2 * sizeof (tbuf)); + } else { + (void) strlcpy(tbuf, (char *)protodata, + sizeof (tbuf)); + } + show_printf("Server Domain = %s", tbuf); + } + } +} + +/* + * LAN Manager remote admin function names. + * [X/Open-SMB, Appendix B.8] + */ +static const char *apiname_table[] = { + "RNetShareEnum", + "RNetShareGetInfo", + "NetShareSetInfo", + "NetShareAdd", + "NetShareDel", + "NetShareCheck", + "NetSessionEnum", + "NetSessionGetInfo", + "NetSessionDel", + "NetConnectionEnum", + "NetFileEnum", + "NetFileGetInfo", + "NetFileClose", + "RNetServerGetInfo", + "NetServerSetInfo", + "NetServerDiskEnum", + "NetServerAdminCommand", + "NetAuditOpen", + "NetAuditClear", + "NetErrorLogOpen", + "NetErrorLogClear", + "NetCharDevEnum", + "NetCharDevGetInfo", + "NetCharDevControl", + "NetCharDevQEnum", + "NetCharDevQGetInfo", + "NetCharDevQSetInfo", + "NetCharDevQPurge", + "RNetCharDevQPurgeSelf", + "NetMessageNameEnum", + "NetMessageNameGetInfo", + "NetMessageNameAdd", + "NetMessageNameDel", + "NetMessageNameFwd", + "NetMessageNameUnFwd", + "NetMessageBufferSend", + "NetMessageFileSend", + "NetMessageLogFileSet", + "NetMessageLogFileGet", + "NetServiceEnum", + "RNetServiceInstall", + "RNetServiceControl", + "RNetAccessEnum", + "RNetAccessGetInfo", + "RNetAccessSetInfo", + "RNetAccessAdd", + "RNetAccessDel", + "NetGroupEnum", + "NetGroupAdd", + "NetGroupDel", + "NetGroupAddUser", + "NetGroupDelUser", + "NetGroupGetUsers", + "NetUserEnum", + "RNetUserAdd", + "NetUserDel", + "NetUserGetInfo", + "RNetUserSetInfo", + "RNetUserPasswordSet", + "NetUserGetGroups", + "NetWkstaLogon", + "NetWkstaLogoff", + "NetWkstaSetUID", + "NetWkstaGetInfo", + "NetWkstaSetInfo", + "NetUseEnum", + "NetUseAdd", + "NetUseDel", + "NetUseGetInfo", + "DosPrintQEnum", + "DosPrintQGetInfo", + "DosPrintQSetInfo", + "DosPrintQAdd", + "DosPrintQDel", + "DosPrintQPause", + "DosPrintQContinue", + "DosPrintJobEnum", + "DosPrintJobGetInfo", + "RDosPrintJobSetInfo", + "DosPrintJobAdd", + "DosPrintJobSchedule", + "RDosPrintJobDel", + "RDosPrintJobPause", + "RDosPrintJobContinue", + "DosPrintDestEnum", + "DosPrintDestGetInfo", + "DosPrintDestControl", + "NetProfileSave", + "NetProfileLoad", + "NetStatisticsGet", + "NetStatisticsClear", + "NetRemoteTOD", + "NetBiosEnum", + "NetBiosGetInfo", + "NetServerEnum", + "I_NetServerEnum", + "NetServiceGetInfo", + "NetSplQmAbort", + "NetSplQmClose", + "NetSplQmEndDoc", + "NetSplQmOpen", + "NetSplQmStartDoc", + "NetSplQmWrite", + "DosPrintQPurge", + "NetServerEnum2" +}; +static const int apinum_max = ( + sizeof (apiname_table) / + sizeof (apiname_table[0])); + +static const char * +pipeapi_name(int code) +{ + char *name; + + switch (code) { + case 0x01: + name = "SetNmPipeState"; + break; + case 0x11: + name = "RawReadNmPipe"; + break; + case 0x21: + name = "QueryNmPipeState"; + break; + case 0x22: + name = "QueryNmPipeInfo"; + break; + case 0x23: + name = "PeekNmPipe"; + break; + case 0x26: + name = "XactNmPipe"; + break; + case 0x31: + name = "RawWriteNmPipe"; + break; + case 0x36: + name = "ReadNmPipe"; + break; + case 0x37: + name = "WriteNmPipe"; + break; + case 0x53: + name = "WaitNmPipe"; + break; + case 0x54: + name = "CallNmPipe"; + break; + default: + name = "?"; + break; + } + return (name); +} + +/* + * Interpret a "trans" SMB + * [X/Open-SMB, Appendix B] + * + * This is very much like "trans2" below. + */ +/* ARGSUSED */ +static void +interpret_trans(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + struct smb *smb; + uchar_t *vwv; /* word parameters */ + int wordcount; + uchar_t *byteparms; + int bytecount; + int parambytes; + int paramoffset; + int setupcount; + int subcode; + uchar_t *setupdata; + uchar_t *params; + int apinum; + int isunicode; + char filename[256]; + const char *apiname; + const char *subcname; + ushort_t smb_flags2; + + smb = (struct smb *)data; + smb_flags2 = get2(smb->flags2); + vwv = (uchar_t *)data + sizeof (struct smb); + wordcount = *vwv++; + + /* Is the pathname in unicode? */ + isunicode = smb_flags2 & FLAGS2_UNICODE; + + byteparms = vwv + (2 * wordcount); + bytecount = get2(byteparms); + byteparms += 2; + + /* + * Print the lengths before we (potentially) bail out + * due to lack of data (so the user knows why we did). + */ + if (flags & F_DTAIL) + show_printf("WordCount = %d", wordcount); + + /* Get length and location of params and setup data. */ + if (!(smb->flags & SERVER_RESPONSE)) { + /* CALL */ + if (wordcount < 14) + return; + parambytes = get2(vwv + (2 * 9)); + paramoffset = get2(vwv + (2 * 10)); + setupcount = *(vwv + (2 * 13)); + setupdata = vwv + (2 * 14); + } else { + /* REPLY */ + if (wordcount < 10) + return; + parambytes = get2(vwv + (2 * 3)); + paramoffset = get2(vwv + (2 * 4)); + setupcount = *(vwv + (2 * 9)); + setupdata = vwv + (2 * 10); + } + + /* The parameters are offset from the SMB header. */ + params = data + paramoffset; + + if ((smb->flags & SERVER_RESPONSE) == 0) { + /* This is a CALL. */ + + if (setupcount > 0) + subcode = get2(setupdata); + else + subcode = -1; /* invalid */ + subcname = pipeapi_name(subcode); + + if (parambytes > 0) + apinum = params[0]; + else + apinum = -1; /* invalid */ + if (0 <= apinum && apinum < apinum_max) + apiname = apiname_table[apinum]; + else + apiname = "?"; + + if (flags & F_SUM) { + int tl; + /* Only get one or the other */ + if (*subcname != '?') { + tl = snprintf(xtra, xsz, + " Func=%s", subcname); + xtra += tl; + xsz -= tl; + } + if (*apiname != '?') + snprintf(xtra, xsz, + " Func=%s", apiname); + return; + } + if ((flags & F_DTAIL) == 0) + return; + + /* print the word parameters */ + show_printf("TotalParamBytes = %d", get2(vwv)); + show_printf("TotalDataBytes = %d", get2(vwv+2)); + show_printf("MaxParamBytes = %d", get2(vwv+4)); + show_printf("MaxDataBytes = %d", get2(vwv+6)); + show_printf("MaxSetupWords = %d", vwv[8]); + show_printf("TransFlags = 0x%.4x", get2(vwv+10)); + show_printf("Timeout = 0x%.8x", get4(vwv+12)); + /* skip Reserved2 */ + show_printf("ParamBytes = %d", parambytes); + show_printf("ParamOffset = %d", paramoffset); + show_printf("DataBytes = %d", get2(vwv+22)); + show_printf("DataOffset = %d", get2(vwv+24)); + show_printf("SetupWords = %d", setupcount); + show_printf("ByteCount = %d", bytecount); + + /* That finishes the VWV, now the misc. stuff. */ + if (setupcount > 0) + show_printf("NmPipeFunc = 0x%x (%s)", + subcode, subcname); + if (parambytes > 0) + show_printf("RAP_Func = %d (%s)", + apinum, apiname); + + /* Finally, print the byte parameters. */ + GET_STRING(filename, byteparms, isunicode); + show_printf("FileName = %s", filename); + } else { + /* This is a REPLY. */ + if (flags & F_SUM) + return; + if ((flags & F_DTAIL) == 0) + return; + /* print the word parameters */ + show_printf("TotalParamBytes = %d", get2(vwv)); + show_printf("TotalDataBytes = %d", get2(vwv+2)); + /* skip Reserved */ + show_printf("ParamBytes = 0x%.4x", parambytes); + show_printf("ParamOffset = 0x%.4x", paramoffset); + show_printf("ParamDispl. = 0x%.4x", get2(vwv+10)); + show_printf("DataBytes = 0x%.4x", get2(vwv+12)); + show_printf("DataOffset = 0x%.4x", get2(vwv+14)); + show_printf("DataDispl. = 0x%.4x", get2(vwv+16)); + show_printf("SetupWords = %d", setupcount); + show_printf("ByteCount = %d", bytecount); + + show_printf("ParamVec (%d)", parambytes); + output_bytes(params, parambytes); + } +} + +/* + * Interpret a "TconX" SMB + * [X/Open-SMB, Sec. 11.4] + */ +/* ARGSUSED */ +static void +interpret_tconX(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + int length; + int isunicode; + int bytecount; + int wordcount; + int andxcmd; + int andxoffset; + int tconflags; + int pw_len; + char path[256]; + char tbuf[256]; + char svc[8]; + struct smb *smbdata; + uchar_t *tcondata; + ushort_t smb_flags2; + + smbdata = (struct smb *)data; + smb_flags2 = get2(smbdata->flags2); + tcondata = (uchar_t *)data + sizeof (struct smb); + wordcount = *tcondata++; + + isunicode = smb_flags2 & FLAGS2_UNICODE; + + if ((smbdata->flags & SERVER_RESPONSE) == 0) { + /* Request */ + if (wordcount < 4) + return; + andxcmd = get2(tcondata); + tcondata += 2; + andxoffset = get2(tcondata); + tcondata += 2; + tconflags = get2(tcondata); + tcondata += 2; + pw_len = get2(tcondata); + tcondata += 2; + bytecount = get2(tcondata); + tcondata += 2; + + /* skip password */ + if (pw_len > len) + pw_len = len; + tcondata += pw_len; + + GET_STRING(path, tcondata, isunicode); + (void) strlcpy(svc, (char *)tcondata, sizeof (svc)); + + if (flags & F_SUM) { + snprintf(xtra, xsz, " Share=%s", path); + return; + } + + if ((flags & F_DTAIL) == 0) + return; + + show_printf("WordCount = %d", wordcount); + show_printf("ChainedCommand = 0x%.2x", andxcmd); + show_printf("NextOffset = 0x%.4x", andxoffset); + show_printf("TconFlags = 0x%.4x", tconflags); + show_printf("PasswordLength = 0x%.4x", pw_len); + show_printf("ByteCount = %d", bytecount); + show_printf("SharePath = %s", path); + show_printf("ServiceType = %s", svc); + } else { + /* response */ + if (wordcount < 3) + return; + andxcmd = get2(tcondata); + tcondata += 2; + andxoffset = get2(tcondata); + tcondata += 2; + tconflags = get2(tcondata); + tcondata += 2; + bytecount = get2(tcondata); + tcondata += 2; + + length = strlcpy(svc, (char *)tcondata, sizeof (svc)); + tcondata += (length + 1); + + if (flags & F_SUM) { + snprintf(xtra, xsz, " Type=%s", svc); + return; + } + if ((flags & F_DTAIL) == 0) + return; + + show_printf("WordCount = %d", wordcount); + show_printf("ChainedCommand = 0x%.2x", andxcmd); + show_printf("NextOffset = 0x%.4x", andxoffset); + show_printf("OptionalSupport = 0x%.4x", tconflags); + show_printf("ByteCount = %d", bytecount); + show_printf("ServiceType = %s", svc); + GET_STRING(tbuf, tcondata, isunicode); + show_printf("NativeFS = %s", tbuf); + } +} + +/* + * Interpret a "SesssetupX" SMB + * [X/Open-SMB, Sec. 11.3] + */ +/* ARGSUSED */ +static void +interpret_sesssetupX(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + int bytecount; + int lm_pw_len; + int ext_security; + int sec_blob_len; + int isunicode; + int nt_pw_len; + int wordcount; + int cap; + char tbuf[256]; + struct smb *smbdata; + uchar_t *setupdata; + ushort_t smb_flags2; + + smbdata = (struct smb *)data; + smb_flags2 = get2(smbdata->flags2); + setupdata = (uchar_t *)data + sizeof (struct smb); + wordcount = *setupdata++; + + isunicode = smb_flags2 & FLAGS2_UNICODE; + ext_security = smb_flags2 & FLAGS2_EXT_SEC; + + if ((smbdata->flags & SERVER_RESPONSE) == 0) { + /* request summary */ + if (flags & F_SUM) { + if (ext_security) { + /* No decoder for SPNEGO */ + snprintf(xtra, xsz, " (SPNEGO)"); + return; + } + if (wordcount != 13) + return; + setupdata += 14; + lm_pw_len = get2(setupdata); + setupdata += 2; + nt_pw_len = get2(setupdata); + setupdata += 6; + cap = get4(setupdata); + setupdata += 6 + lm_pw_len + nt_pw_len; + + GET_STRING(tbuf, setupdata, isunicode); + snprintf(xtra, xsz, " Username=%s", tbuf); + } + + if ((flags & F_DTAIL) == 0) + return; + + /* request detail */ + show_printf("WordCount = %d", wordcount); + if (wordcount < 7) + return; + /* words 0 - 6 */ + show_printf("ChainedCommand = 0x%.2x", setupdata[0]); + setupdata += 2; + show_printf("NextOffset = 0x%.4x", get2(setupdata)); + setupdata += 2; + show_printf("MaxBufferSize = %d", get2(setupdata)); + setupdata += 2; + show_printf("MaxMPXRequests = %d", get2(setupdata)); + setupdata += 2; + show_printf("VCNumber = %d", get2(setupdata)); + setupdata += 2; + show_printf("SessionKey = 0x%.8x", get4(setupdata)); + setupdata += 4; + + if (ext_security) { + if (wordcount != 12) + return; + /* word 7 */ + sec_blob_len = get2(setupdata); + setupdata += 2; + show_printf("Sec. blob len = %d", sec_blob_len); + /* words 8, 9 (reserved) */ + setupdata += 4; + } else { + if (wordcount != 13) + return; + /* word 7 */ + lm_pw_len = get2(setupdata); + setupdata += 2; + show_printf("LM_Hash_Len = %d", lm_pw_len); + /* word 8 */ + nt_pw_len = get2(setupdata); + setupdata += 2; + show_printf("NT_Hash_Len = %d", nt_pw_len); + /* words 9, 10 (reserved) */ + setupdata += 4; + } + + cap = get4(setupdata); + show_printf("Capabilities = 0x%.8x", cap); + setupdata += 4; + + bytecount = get2(setupdata); + setupdata += 2; + show_printf("ByteCount = %d", bytecount); + + if (ext_security) { + /* No decoder for SPNEGO. Just dump hex. */ + show_printf("Security blob: (SPNEGO)"); + output_bytes(setupdata, sec_blob_len); + setupdata += sec_blob_len; + } else { + /* Dump password hashes */ + if (lm_pw_len > 0) { + show_printf("LM Hash (%d bytes)", lm_pw_len); + output_bytes(setupdata, lm_pw_len); + setupdata += lm_pw_len; + } + if (nt_pw_len > 0) { + show_printf("NT Hash (%d bytes)", nt_pw_len); + output_bytes(setupdata, nt_pw_len); + setupdata += nt_pw_len; + } + + /* User */ + GET_STRING(tbuf, setupdata, isunicode); + show_printf("AccountName = %s", tbuf); + + /* Domain */ + GET_STRING(tbuf, setupdata, isunicode); + show_printf("DomainName = %s", tbuf); + } + + /* + * Remainder is the same for etc. sec. or not + * Native OS, Native LanMan + */ + GET_STRING(tbuf, setupdata, isunicode); + show_printf("NativeOS = %s", tbuf); + + GET_STRING(tbuf, setupdata, isunicode); + show_printf("NativeLanman = %s", tbuf); + } else { + /* response summary */ + if (flags & F_SUM) { + if (ext_security) { + /* No decoder for SPNEGO */ + snprintf(xtra, xsz, " (SPNEGO)"); + } + return; + } + + if ((flags & F_DTAIL) == 0) + return; + + /* response detail */ + show_printf("WordCount = %d", wordcount); + if (wordcount < 3) + return; + + show_printf("ChainedCommand = 0x%.2x", setupdata[0]); + setupdata += 2; + show_printf("NextOffset = 0x%.4x", get2(setupdata)); + setupdata += 2; + show_printf("SetupAction = 0x%.4x", get2(setupdata)); + setupdata += 2; + + if (ext_security) { + if (wordcount != 4) + return; + sec_blob_len = get2(setupdata); + setupdata += 2; + show_printf("Sec. blob len = %d", sec_blob_len); + } else { + if (wordcount != 3) + return; + } + + bytecount = get2(setupdata); + setupdata += 2; + show_printf("ByteCount = %d", bytecount); + + if (ext_security) { + /* No decoder for SPNEGO. Just dump hex. */ + show_line("Security blob: (SPNEGO)"); + output_bytes(setupdata, sec_blob_len); + setupdata += sec_blob_len; + } + + /* + * Native OS, Native LanMan + */ + GET_STRING(tbuf, setupdata, isunicode); + show_printf("NativeOS = %s", tbuf); + + GET_STRING(tbuf, setupdata, isunicode); + show_printf("NativeLanman = %s", tbuf); + + if (ext_security == 0) { + GET_STRING(tbuf, setupdata, isunicode); + show_printf("DomainName = %s", tbuf); + } + } +} + +/* + * Interpret "Trans2" SMB + * [X/Open-SMB, Sec. 16] + * + * This is very much like "trans" above. + */ +/* ARGSUSED */ +static void +interpret_trans2(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + struct smb *smb; + uchar_t *vwv; /* word parameters */ + int wordcount; + uchar_t *byteparms; + int bytecount; + int parambytes; + int paramoffset; + int setupcount; + int subcode; + uchar_t *setupdata; + uchar_t *params; + char *name; + + smb = (struct smb *)data; + vwv = (uchar_t *)data + sizeof (struct smb); + wordcount = *vwv++; + + byteparms = vwv + (2 * wordcount); + bytecount = get2(byteparms); + byteparms += 2; + + /* + * Print the lengths before we (potentially) bail out + * due to lack of data (so the user knows why we did). + */ + if (flags & F_DTAIL) { + show_printf("WordCount = %d", wordcount); + show_printf("ByteCount = %d", bytecount); + } + + /* Get length and location of params and setup data. */ + if (!(smb->flags & SERVER_RESPONSE)) { + /* CALL */ + if (wordcount < 14) + return; + parambytes = get2(vwv + (2 * 9)); + paramoffset = get2(vwv + (2 * 10)); + setupcount = *(vwv + (2 * 13)); + setupdata = vwv + (2 * 14); + } else { + /* REPLY */ + if (wordcount < 10) + return; + parambytes = get2(vwv + (2 * 3)); + paramoffset = get2(vwv + (2 * 4)); + setupcount = *(vwv + (2 * 9)); + setupdata = vwv + (2 * 10); + } + if (setupcount > 0) + subcode = get2(setupdata); + else + subcode = -1; /* invalid */ + + /* The parameters are offset from the SMB header. */ + params = data + paramoffset; + + if (flags & F_DTAIL && !(smb->flags & SERVER_RESPONSE)) { + /* This is a CALL. */ + /* print the word parameters */ + show_printf("TotalParamBytes = %d", get2(vwv)); + show_printf("TotalDataBytes = %d", get2(vwv+2)); + show_printf("MaxParamBytes = %d", get2(vwv+4)); + show_printf("MaxDataBytes = %d", get2(vwv+6)); + show_printf("MaxSetupWords = %d", vwv[8]); + show_printf("TransFlags = 0x%.4x", get2(vwv+10)); + show_printf("Timeout = 0x%.8x", get4(vwv+12)); + /* skip Reserved2 */ + show_printf("ParamBytes = 0x%.4x", parambytes); + show_printf("ParamOffset = 0x%.4x", paramoffset); + show_printf("DataBytes = 0x%.4x", get2(vwv+22)); + show_printf("DataOffset = 0x%.4x", get2(vwv+24)); + show_printf("SetupWords = %d", setupcount); + + /* That finishes the VWV, now the misc. stuff. */ + show_printf("FunctionCode = %d", subcode); + } + + if (!(smb->flags & SERVER_RESPONSE)) { + /* This is a CALL. Do sub-function. */ + switch (subcode) { + case TRANS2_OPEN: + name = "Open"; + goto name_only; + case TRANS2_FIND_FIRST: + output_trans2_findfirst(flags, params, xtra, xsz); + break; + case TRANS2_FIND_NEXT2: + output_trans2_findnext(flags, params, xtra, xsz); + break; + case TRANS2_QUERY_FS_INFORMATION: + name = "QueryFSInfo"; + goto name_only; + case TRANS2_QUERY_PATH_INFORMATION: + output_trans2_querypath(flags, params, xtra, xsz); + break; + case TRANS2_SET_PATH_INFORMATION: + name = "SetPathInfo"; + goto name_only; + case TRANS2_QUERY_FILE_INFORMATION: + output_trans2_queryfile(flags, params, xtra, xsz); + break; + case TRANS2_SET_FILE_INFORMATION: + output_trans2_setfile(flags, params, xtra, xsz); + break; + case TRANS2_CREATE_DIRECTORY: + name = "CreateDir"; + goto name_only; + + default: + name = "Unknown"; + /* fall through */ + name_only: + if (flags & F_SUM) + snprintf(xtra, xsz, " %s", name); + if (flags & F_DTAIL) + show_printf("FunctionName = %s", name); + break; + } + } + + if (flags & F_DTAIL && smb->flags & SERVER_RESPONSE) { + /* This is a REPLY. */ + /* print the word parameters */ + show_printf("TotalParamBytes = %d", get2(vwv)); + show_printf("TotalDataBytes = %d", get2(vwv+2)); + /* skip Reserved */ + show_printf("ParamBytes = 0x%.4x", parambytes); + show_printf("ParamOffset = 0x%.4x", paramoffset); + show_printf("ParamDispl. = 0x%.4x", get2(vwv+10)); + show_printf("DataBytes = 0x%.4x", get2(vwv+12)); + show_printf("DataOffset = 0x%.4x", get2(vwv+14)); + show_printf("DataDispl. = 0x%.4x", get2(vwv+16)); + show_printf("SetupWords = %d", setupcount); + + output_bytes(byteparms, bytecount); + } +} + + +static void +interpret_default(int flags, uchar_t *data, int len, char *xtra, int xsz) +{ + int slength; + int i, tl; + int isunicode; + int printit; + int wordcount; + int outsz; + char *outstr; + char *format; + char valuetype; + char word[10]; + char *label; + char tempstr[256]; + uchar_t *comdata, *limit; + char buff[80]; + struct smb *smbdata; + struct decode *decoder; + uchar_t bval; + ushort_t wval; + ushort_t smb_flags2; + uint_t lval; + + smbdata = (struct smb *)data; + smb_flags2 = get2(smbdata->flags2); + comdata = (uchar_t *)data + sizeof (struct smb); + wordcount = *comdata++; + limit = data + len; + + isunicode = smb_flags2 & FLAGS2_UNICODE; + decoder = &SMBtable[smbdata->com & 255]; + + if (smbdata->flags & SERVER_RESPONSE) + format = decoder->replyfmt; + else + format = decoder->callfmt; + + if (!format || strlen(format) == 0) { + if (flags & F_SUM) + return; + show_printf("WordCount = %d", wordcount); + if (wordcount == 0) + return; + show_line("Word values (in hex):"); + buff[0] = '\0'; + for (i = 0; i < wordcount; i++) { + snprintf(word, sizeof (word), "%.4x ", get2(comdata)); + comdata += 2; + if (comdata >= limit) + wordcount = i+1; /* terminate */ + (void) strlcat(buff, word, sizeof (buff)); + if (((i+1) & 7) == 0 || i == (wordcount-1)) { + show_line(buff); + strcpy(buff, ""); + } + } + return; + } + + if (flags & F_DTAIL) + show_printf("WordCount = %d", wordcount); + + outstr = xtra; + outsz = xsz; + + valuetype = format[0]; + while (valuetype != '\0') { + if (comdata >= limit) + break; + label = format+1; + printit = (flags & F_DTAIL) || (valuetype <= 'Z'); + + switch (valuetype) { + case 'W': + case 'w': + wval = get2(comdata); + comdata += 2; + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = 0x%.4x", label, wval); + else { + tl = snprintf(outstr, outsz, + " %s=0x%x", label, wval); + outstr += tl; + outsz -= tl; + } + break; + + case 'D': + case 'd': + wval = get2(comdata); + comdata += 2; + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = %d", label, wval); + else { + tl = snprintf(outstr, outsz, + " %s=%d", label, wval); + outstr += tl; + outsz -= tl; + } + break; + + case 'L': + case 'l': + lval = get4(comdata); + comdata += 4; + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = 0x%.8x", label, lval); + else { + tl = snprintf(outstr, outsz, + " %s=0x%x", label, lval); + outstr += tl; + outsz -= tl; + } + break; + + case 'B': + case 'b': + bval = comdata[0]; + comdata += 1; + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = 0x%.2x", label, bval); + else { + tl = snprintf(outstr, outsz, + " %s=0x%x", label, bval); + outstr += tl; + outsz -= tl; + } + break; + + case 'r': + comdata++; + break; + + case 'R': + comdata += 2; + break; + + case 'U': + case 'u': + /* Unicode or ASCII string. */ + GET_STRING(tempstr, comdata, isunicode); + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = %s", label, tempstr); + else { + tl = snprintf(outstr, outsz, + " %s=%s", label, tempstr); + outstr += tl; + outsz -= tl; + } + break; + + case 'S': + case 's': + slength = strlcpy(tempstr, (char *)comdata, + sizeof (tempstr)); + comdata += (slength+1); + if (!printit) + break; + if (flags & F_DTAIL) + show_printf( + "%s = %s", label, tempstr); + else { + tl = snprintf(outstr, outsz, + " %s=%s", label, tempstr); + outstr += tl; + outsz -= tl; + } + break; + } + format += (strlen(format) + 1); + valuetype = format[0]; + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_socks.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_socks.c new file mode 100644 index 0000000..59cd38e --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_socks.c @@ -0,0 +1,472 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1998-1999,2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <string.h> +#include "snoop.h" + +static void put_method(char *cp, int method); +static void put_socks5_addr(char *cp, const unsigned char *buf, int fraglen); +static void put_socks4_res(char *cp, int code); +static void put_socks5_res(char *cp, int code); + +int +interpret_socks_call(flags, line, fraglen) + int flags; + char *line; + int fraglen; +{ + unsigned char *buf = (unsigned char *)line; + char *cp; + struct in_addr ipaddr; + int i, n; + + if (flags & F_SUM) { + cp = get_sum_line(); + if (fraglen >= 2) { + switch (buf[0]) { + case 4: /* SOCKS4 */ + n = buf[1]; + switch (n) { + case 1: + case 2: + if (fraglen >= 8) { + (void) memcpy(&ipaddr, &buf[4], + sizeof (ipaddr)); + (void) sprintf(cp, + "SOCKS4 %s %s:%u", + addrtoname(AF_INET, &ipaddr), + (n == 1)? "CONNECT": "BIND", + (buf[2] << 8) | buf[3]); + cp += strlen(cp); + if (fraglen > 8) { + (void) sprintf(cp, " User="); + cp += strlen(cp); + for (i = 8; + i < 40 && i < fraglen; + ++i) { + if (buf[i] == '\0') + break; + *cp++ = buf[i]; + } + if (i == 40) { + *cp++ = '.'; + *cp++ = '.'; + *cp++ = '.'; + } + *cp = '\0'; + } + } + break; + default: + (void) sprintf(cp, "SOCKS4 OP=%u", n); + } + break; + case 5: /* SOCKS5 */ + n = buf[1]; + if (2 + n == fraglen) { + (void) sprintf(cp, + "SOCKS5 CONTACT NMETHODS=%d:", n); + cp += strlen(cp); + for (i = 0; i < n && 2 + i < fraglen; ++i) { + put_method(cp, buf[2 + i]); + cp += strlen(cp); + } + } else if (fraglen >= 6 && buf[2] == 0) { + const char *cmd; + + if (n < 1 || n > 3) { + (void) sprintf(cp, + "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } else { + switch (n) { + case 1: + cmd = "CONNECT"; + break; + case 2: + cmd = "BIND"; + break; + case 3: + cmd = "ASSOCIATE_UDP"; + break; + } + (void) sprintf(cp, "SOCKS5 %s ", cmd); + cp += strlen(cp); + put_socks5_addr(cp, &buf[3], + fraglen - 3); + } + } else { + (void) sprintf(cp, "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } + break; + default: + (void) sprintf(cp, "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } + } else { + (void) sprintf(cp, "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } + + } /* if (flags & F_SUM) */ + + if (flags & F_DTAIL) { + show_header("SOCKS: ", "SOCKS Header", fraglen); + show_space(); + cp = get_line(0, 0); + if (fraglen >= 2) { + switch (buf[0]) { + case 4: + (void) sprintf(cp, "Version = 4"); + n = buf[1]; + switch (n) { + case 1: + case 2: + (void) sprintf(get_line(0, 0), + "Operation = %s", + (n == 1)? "CONNECT": "BIND"); + if (fraglen >= 8) { + (void) memcpy(&ipaddr, &buf[4], + sizeof (ipaddr)); + (void) sprintf(get_line(0, 0), + "Destination = %s:%u", + addrtoname(AF_INET, + &ipaddr), + (buf[2] << 8) | buf[3]); + if (fraglen > 8) { + cp = get_line(0, 0); + (void) sprintf(cp, + "User = "); + cp += strlen(cp); + for (i = 8; + i < 40; ++i) { + if + (buf[i] == '\0') + break; + *cp++ = buf[i]; + } + if (i == 40) { + *cp++ = '.'; + *cp++ = '.'; + *cp++ = '.'; + } + *cp = '\0'; + } + } + break; + default: + (void) sprintf(get_line(0, 0), + "Operation = %u (unknown)", n); + } + break; + case 5: /* SOCKS5 */ + (void) sprintf(cp, "Version = 5"); + n = buf[1]; + if (2 + n == fraglen) { + (void) sprintf(get_line(0, 0), + "Number of methods = %u", n); + for (i = 0; + i < n && 2 + i < fraglen; ++i) { + cp = get_line(0, 0); + (void) sprintf(cp, + "Method %3u =", i); + cp += strlen(cp); + put_method(cp, buf[2 + i]); + } + } else if (fraglen >= 6 && buf[2] == 0) { + const char *cmd; + if (n < 1 || n > 3) { + (void) sprintf(cp, + "SOCKS (send data): %s", + show_string(line, + fraglen, 20)); + } else { + switch (n) { + case 1: + cmd = "CONNECT"; + break; + case 2: + cmd = "BIND"; + break; + case 3: + cmd = "ASSOCIATE_UDP"; + break; + } + (void) sprintf(get_line(0, 0), + "Operation = %s ", cmd); + put_socks5_addr(get_line(0, 0), + &buf[3], fraglen - 3); + break; + } + } else + (void) sprintf(cp, + " SOCKS (send data): %s", + show_string(line, fraglen, + 20)); + break; + default: + (void) sprintf(cp, + "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } + show_space(); + } else + (void) sprintf(cp, + "SOCKS (send data): %s", + show_string(line, fraglen, 20)); + } + +out: + return (fraglen); +} + +int +interpret_socks_reply(flags, line, fraglen) + int flags; + char *line; + int fraglen; +{ + unsigned char *buf = (unsigned char *)line; + char *cp; + struct in_addr ipaddr; + + if (flags & F_SUM) { + cp = get_sum_line(); + if (fraglen >= 2) { + switch (buf[0]) { + case 0: + (void) sprintf(cp, "SOCKS4 "); + cp += strlen(cp); + if (fraglen >= 8) { + (void) memcpy(&ipaddr, &buf[4], + sizeof (ipaddr)); + (void) sprintf(cp, "%s:%u ", + addrtoname(AF_INET, &ipaddr), + (buf[2] << 8) | buf[3]); + cp += strlen(cp); + } + /* reply version, no SOCKS version in v4 */ + put_socks4_res(cp, buf[1]); + break; + case 5: + (void) sprintf(cp, "SOCKS5 method accepted:"); + cp += strlen(cp); + put_method(cp, buf[1]); + break; + default: + (void) sprintf(cp, "SOCKS (recv data)"); + } + } else + (void) sprintf(cp, "SOCKS (recv data)"); + } + + if (flags & F_DTAIL) { + show_header("SOCKS: ", "SOCKS Header", fraglen); + show_space(); + cp = get_line(0, 0); + if (fraglen >= 2) { + switch (buf[0]) { + case 0: + /* reply version, no SOCKS version in v4 */ + (void) sprintf(cp, + "Reply version = 0 (SOCKS version 4)"); + if (fraglen >= 8) { + (void) memcpy(&ipaddr, &buf[4], + sizeof (ipaddr)); + (void) sprintf(get_line(0, 0), + "Destination %s:%u ", + addrtoname(AF_INET, &ipaddr), + (buf[2] << 8) | buf[3]); + } + cp = get_line(0, 0); + (void) sprintf(cp, "Result code = %u ", buf[1]); + cp += strlen(cp); + put_socks4_res(cp, buf[1]); + break; + case 5: + (void) sprintf(cp, "Reply version = 5"); + if (fraglen == 2) { + cp = get_line(0, 0); + (void) sprintf(cp, "Method accepted ="); + cp += strlen(cp); + put_method(cp, buf[1]); + } else if (fraglen >= 6 && buf[2] == 0x00) { + cp = get_line(0, 0); + (void) sprintf(cp, "Status = "); + cp += strlen(cp); + put_socks5_res(cp, buf[1]); + put_socks5_addr(get_line(0, 0), + &buf[3], fraglen - 3); + } + break; + default: + (void) sprintf(cp, "(recv data)"); + } + } else + (void) sprintf(cp, "(recv data)"); + show_space(); + } + +out: + return (fraglen); +} + +static void +put_method(char *cp, int method) +{ + switch (method) { + case 0: + (void) sprintf(cp, " NOAUTH"); + break; + case 1: + (void) sprintf(cp, " GSSAPI"); + break; + case 2: + (void) sprintf(cp, " USERNAME/PASSWD"); + break; + case 255: + (void) sprintf(cp, " NONE"); + break; + default: + (void) sprintf(cp, " 0x%02x (unknown)", method); + } +} + +static void +put_socks5_addr(char *cp, const unsigned char *buf, int fraglen) +{ + struct in_addr ipaddr; + int i; + + switch (buf[0]) { + case 1: + /* IPv4 */ + (void) sprintf(cp, "Address = "); + cp += strlen(cp); + if (1 + 4 + 2 <= fraglen) { + (void) memcpy(&ipaddr, &buf[1], sizeof (ipaddr)); + (void) sprintf(cp, "%s:%u", + addrtoname(AF_INET, &ipaddr), + (buf[5] << 8) | buf[5 + 1]); + } else + (void) strcat(cp, "(IPv4)"); + break; + case 3: + /* domain name */ + (void) sprintf(cp, "Domain name = "); + cp += strlen(cp); + for (i = 0; i <= buf[1] && 1 + i < fraglen; ++i) + *cp++ = buf[1 + i]; + if (1 + i + 2 <= fraglen) + (void) sprintf(cp, ":%u", + (buf[1 + i] << 8) | buf[1 + i + 1]); + else + *cp = '\0'; + break; + case 4: + /* IPv6 */ + (void) sprintf(cp, "Address = "); + if (1 + 16 <= fraglen) { + for (i = 0; i < 16; ++i) { + if (i > 0) + *cp++ = '.'; + (void) sprintf(cp, "%u", buf[1 + i]); + cp += strlen(cp); + } + if (1 + 16 + 2 <= fraglen) { + (void) sprintf(cp, ":%u", + (buf[1 + 16] << 8) | buf[1 + 16 + 1]); + } + } else + (void) strcat(cp, "(IPv6)"); + break; + default: + (void) sprintf(cp, "Address type = 0x%02x (unknown)", buf[0]); + } +} + +static void +put_socks4_res(char *cp, int code) +{ + switch (code) { + case 90: + (void) sprintf(cp, "request granted"); + break; + case 91: + (void) sprintf(cp, "request rejected or failed"); + break; + case 92: + (void) sprintf(cp, "socksd can't connect to client's identd"); + break; + case 93: + (void) sprintf(cp, "identity mismatch"); + break; + default: + (void) sprintf(cp, "0x%02x (unknown)", code); + } +} + +static void +put_socks5_res(char *cp, int code) +{ + switch (code) { + case 0: + (void) strcpy(cp, "succeeded"); + break; + case 1: + (void) strcpy(cp, "general SOCKS server failure"); + break; + case 2: + (void) strcpy(cp, "connection not allowed by ruleset"); + break; + case 3: + (void) strcpy(cp, "network unreachable"); + break; + case 4: + (void) strcpy(cp, "host unreachable"); + break; + case 5: + (void) strcpy(cp, "connection refused"); + break; + case 6: + (void) strcpy(cp, "TTL expired"); + break; + case 7: + (void) strcpy(cp, "command not supported"); + break; + case 8: + (void) strcpy(cp, "address type not supported"); + break; + default: + (void) sprintf(cp, "code 0x%02x", code); + } +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_solarnet.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_solarnet.c new file mode 100644 index 0000000..9e2e74b --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_solarnet.c @@ -0,0 +1,299 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 1993, 1999 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%W% %E% SMI" + +#include <sys/types.h> +#include <sys/errno.h> +#include <setjmp.h> +#include <limits.h> +#include <netinet/in.h> +#include <string.h> + +#include <rpc/types.h> +#include <rpc/rpc.h> +#include <rpc/xdr.h> +#include <rpc/auth.h> +#include <rpc/clnt.h> +#include <rpc/rpc_msg.h> +#include <fw.h> +#include <fw_rpc.h> +#include "snoop.h" + +extern char *dlc_header; +extern jmp_buf xdr_err; + +static char *procnames_short[] = { + "Null", /* 0 */ + "INVOKE", /* 1 */ + "MORE", /* 2 */ + "KILL", /* 3 */ +}; + +static char *procnames_long[] = { + "Null procedure", /* 0 */ + "Invoke operation", /* 1 */ + "More data", /* 2 */ + "Kill operation", /* 3 */ +}; + +#define MAXPROC 3 + +enum Rec_type { + REC_TYPE_NORM = 0, + REC_TYPE_EOR = 1, + REC_TYPE_EOF = 2 +}; +typedef enum Rec_type Rec_type; + +void +interpret_solarnet_fw( + int flags, + int type, + int xid, + int vers, + int proc, + char *data, + int len) +{ + char *line; + char buff[CTXTLEN + 1]; + ulong_t thresh; + char op[CTXTLEN + 1]; + bool_t b; + Fw_err e; + Rec_type rt; + int new_row = 1, row = 0; + + if (proc < 0 || proc > MAXPROC) + return; + + if (flags & F_SUM) { + if (setjmp(xdr_err)) { + return; + } + + line = get_sum_line(); + + if (type == CALL) { + (void) sprintf(line, + "SOLARNET C %s", + procnames_short[proc]); + line += strlen(line); + + switch (proc) { + case FW_INVOKE: + (void) sprintf(line, " %s", + getxdr_string(buff, CTXTLEN)); + line += strlen(line); + (void) sprintf(line, "/%s", + getxdr_string(buff, CTXTLEN)); + line += strlen(line); + getxdr_string(buff, CTXTLEN); + if (strlen(buff) != 0) { + (void) sprintf(line, ".%s", buff); + line += strlen(line); + } + (void) getxdr_string(buff, CTXTLEN); + thresh = getxdr_u_long(); + if (thresh == ULONG_MAX) + (void) sprintf(line, " (all)"); + else + (void) sprintf(line, " %lu", thresh); + line += strlen(line); + (void) getxdr_context(buff, CTXTLEN); + break; + case FW_MORE: + (void) getxdr_context(buff, CTXTLEN); + sscanf(buff, "%*s %*s %s.%*s", op); + op[strlen(op)-1] = '\0'; + (void) sprintf(line, " %s", op); + line += strlen(line); + thresh = getxdr_u_long(); + if (thresh == ULONG_MAX) + (void) sprintf(line, " (all)"); + else + (void) sprintf(line, " %lu", thresh); + line += strlen(line); + break; + case FW_KILL: + (void) getxdr_context(buff, CTXTLEN); + sscanf(buff, "%*s %*s %s.%*s", op); + op[strlen(op)-1] = '\0'; + (void) sprintf(line, " %s", op); + line += strlen(line); + break; + default: + break; + } + + check_retransmit(line, xid); + } else { + (void) sprintf(line, "SOLARNET R %s", + procnames_short[proc]); + line += strlen(line); + b = getxdr_bool(); + if (b) { + e = getxdr_enum(); + if (e == FW_ERR_FW) + sprintf(line, " FW"); + else if (e == FW_ERR_OP) + sprintf(line, " OP"); + else + sprintf(line, " NOERR"); + line += strlen(line); + if (e != FW_ERR_NONE) { + sprintf(line, " %lu", getxdr_u_long()); + line += strlen(line); + (void) getxdr_bool(); + sprintf(line, " %s", + getxdr_string(buff, CTXTLEN)); + line += strlen(line); + } + } else { + sprintf(line, " Success"); + line += strlen(line); + } + b = getxdr_bool(); + if (b) { + sprintf(line, " %lu rows", getxdr_u_long()); + line += strlen(line); + } else { + sprintf(line, " (No output)"); + line += strlen(line); + } + } + } + + if ((flags & F_DTAIL)) { + show_header("SOLARNET: ", "Solarnet Administration Service", + len); + show_space(); + if (setjmp(xdr_err)) { + return; + } + (void) sprintf(get_line(0, 0), "Proc = %d (%s)", proc, + procnames_long[proc]); + if (type == CALL) { + switch (proc) { + case FW_INVOKE: + (void) showxdr_string(CTXTLEN, "Category: %s"); + (void) showxdr_string(CTXTLEN, "Operation: %s"); + (void) showxdr_string(CTXTLEN, "Version: %s"); + (void) showxdr_string(CTXTLEN, "Locale: %s"); + (void) showxdr_u_long("Threshold: %lu rows"); + (void) showxdr_context("Context: %s"); + b = getxdr_bool(); + if (!b) { + sprintf(get_line(0, 0), + "No input arguments"); + break; + } + thresh = showxdr_u_long("Input rows = %lu"); + (void) getxdr_bool(); + do { + rt = getxdr_enum(); + if (rt == REC_TYPE_NORM) { + if (new_row) { + sprintf(get_line(0, 0), + "Row %d", ++row); + new_row = 0; + } + (void) getxdr_string(buff, + CTXTLEN); + (void) getxdr_string(op, + CTXTLEN); + sprintf(get_line(0, 0), + "\t%s = %s", buff, op); + } else if (rt == REC_TYPE_EOR) { + new_row = 1; + } + } while (rt != REC_TYPE_EOF); + break; + case FW_MORE: + (void) showxdr_context("Context: %s"); + (void) showxdr_u_long("Threshold: %lu rows"); + break; + case FW_KILL: + (void) showxdr_context("Context: %s"); + break; + default: + break; + } + } else { + b = getxdr_bool(); + if (b) { + e = getxdr_enum(); + if (e == FW_ERR_FW) { + showxdr_u_long( + "Framework error code %lu"); + } else if (e == FW_ERR_OP) { + showxdr_u_long( + "Operation error code %lu"); + } else { + showxdr_u_long("No error %*lu"); + } + (void) getxdr_bool(); + (void) getxdr_string(buff, CTXTLEN); + if (e != FW_ERR_NONE) { + sprintf(get_line(0, 0), + "Error message: %s", buff); + } else { + } + } else { + sprintf(get_line(0, 0), + "Operation was successful"); + } + b = getxdr_bool(); + if (b) { + showxdr_u_long("Output rows: %lu"); + (void) getxdr_bool(); + do { + rt = getxdr_enum(); + if (rt == REC_TYPE_NORM) { + if (new_row) { + sprintf(get_line(0, 0), + "Row %d", ++row); + new_row = 0; + } + (void) getxdr_string(buff, + CTXTLEN); + (void) getxdr_string(op, + CTXTLEN); + sprintf(get_line(0, 0), + "\t%s = %s", buff, op); + } else if (rt == REC_TYPE_EOR) { + new_row = 1; + } + } while (rt != REC_TYPE_EOF); + } else { + sprintf(get_line(0, 0), "No output"); + } + } + show_trailer(); + } + +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tcp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tcp.c new file mode 100644 index 0000000..b0e918f --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tcp.c @@ -0,0 +1,435 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> + +#include <sys/socket.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <netinet/tcp.h> +#include "snoop.h" + +extern char *dlc_header; + +#define TCPOPT_HEADER_LEN 2 +#define TCPOPT_TSTAMP_LEN 10 +#define TCPOPT_SACK_LEN 8 + +/* + * Convert a network byte order 32 bit integer to a host order integer. + * ntohl() cannot be used because option values may not be aligned properly. + */ +#define GET_UINT32(opt) (((uint_t)*((uchar_t *)(opt) + 0) << 24) | \ + ((uint_t)*((uchar_t *)(opt) + 1) << 16) | \ + ((uint_t)*((uchar_t *)(opt) + 2) << 8) | \ + ((uint_t)*((uchar_t *)(opt) + 3))) + +static void print_tcpoptions_summary(uchar_t *, int, char *); +static void print_tcpoptions(uchar_t *, int); + +static const struct { + unsigned int tf_flag; + const char *tf_name; +} tcp_flags[] = { + { TH_SYN, "Syn" }, + { TH_FIN, "Fin" }, + { TH_RST, "Rst" }, + { TH_PUSH, "Push" }, + { TH_ECE, "ECE" }, + { TH_CWR, "CWR" }, + { 0, NULL } +}; + +int +interpret_tcp(int flags, struct tcphdr *tcp, int iplen, int fraglen) +{ + char *data; + int hdrlen, tcplen; + int sunrpc = 0; + char *pname; + char buff[32]; + char *line, *endline; + unsigned int i; + + hdrlen = tcp->th_off * 4; + data = (char *)tcp + hdrlen; + tcplen = iplen - hdrlen; + fraglen -= hdrlen; + if (fraglen < 0) + return (fraglen + hdrlen); /* incomplete header */ + if (fraglen > tcplen) + fraglen = tcplen; + + if (flags & F_SUM) { + line = get_sum_line(); + endline = line + MAXLINE; + (void) snprintf(line, endline - line, "TCP D=%d S=%d", + ntohs(tcp->th_dport), ntohs(tcp->th_sport)); + line += strlen(line); + + for (i = 0; tcp_flags[i].tf_name != NULL; i++) { + if (tcp->th_flags & tcp_flags[i].tf_flag) { + (void) snprintf(line, endline - line, " %s", + tcp_flags[i].tf_name); + line += strlen(line); + } + } + + if (tcp->th_flags & TH_URG) { + (void) snprintf(line, endline - line, " Urg=%u", + ntohs(tcp->th_urp)); + line += strlen(line); + } + if (tcp->th_flags & TH_ACK) { + (void) snprintf(line, endline - line, " Ack=%u", + ntohl(tcp->th_ack)); + line += strlen(line); + } + if (ntohl(tcp->th_seq)) { + (void) snprintf(line, endline - line, " Seq=%u Len=%d", + ntohl(tcp->th_seq), tcplen); + line += strlen(line); + } + (void) snprintf(line, endline - line, " Win=%d", + ntohs(tcp->th_win)); + print_tcpoptions_summary((uchar_t *)(tcp + 1), + (int)(tcp->th_off * 4 - sizeof (struct tcphdr)), line); + } + + sunrpc = !reservedport(IPPROTO_TCP, ntohs(tcp->th_dport)) && + !reservedport(IPPROTO_TCP, ntohs(tcp->th_sport)) && + valid_rpc(data + 4, fraglen - 4); + + if (flags & F_DTAIL) { + + show_header("TCP: ", "TCP Header", tcplen); + show_space(); + (void) sprintf(get_line((char *)(uintptr_t)tcp->th_sport - + dlc_header, 2), "Source port = %d", ntohs(tcp->th_sport)); + + if (sunrpc) { + pname = "(Sun RPC)"; + } else { + pname = getportname(IPPROTO_TCP, ntohs(tcp->th_dport)); + if (pname == NULL) { + pname = ""; + } else { + (void) sprintf(buff, "(%s)", pname); + pname = buff; + } + } + (void) sprintf(get_line((char *)(uintptr_t)tcp->th_dport - + dlc_header, 2), "Destination port = %d %s", + ntohs(tcp->th_dport), pname); + (void) sprintf(get_line((char *)(uintptr_t)tcp->th_seq - + dlc_header, 4), "Sequence number = %u", + ntohl(tcp->th_seq)); + (void) sprintf(get_line((char *)(uintptr_t)tcp->th_ack - dlc_header, 4), + "Acknowledgement number = %u", + ntohl(tcp->th_ack)); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_ack - dlc_header) + + 4, 1), "Data offset = %d bytes", tcp->th_off * 4); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), "Flags = 0x%02x", tcp->th_flags); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_CWR, + "ECN congestion window reduced", + "No ECN congestion window reduced")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_ECE, + "ECN echo", "No ECN echo")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", + getflag(tcp->th_flags, TH_URG, + "Urgent pointer", "No urgent pointer")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_ACK, + "Acknowledgement", "No acknowledgement")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_PUSH, + "Push", "No push")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_RST, + "Reset", "No reset")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_SYN, + "Syn", "No Syn")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags - + dlc_header) + 4, 1), " %s", getflag(tcp->th_flags, TH_FIN, + "Fin", "No Fin")); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_win - dlc_header) + + 4, 1), "Window = %d", ntohs(tcp->th_win)); + /* XXX need to compute checksum and print whether correct */ + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_sum - dlc_header) + + 4, 1), "Checksum = 0x%04x", ntohs(tcp->th_sum)); + (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_urp - dlc_header) + + 4, 1), "Urgent pointer = %d", ntohs(tcp->th_urp)); + + /* Print TCP options - if any */ + + print_tcpoptions((uchar_t *)(tcp + 1), + tcp->th_off * 4 - sizeof (struct tcphdr)); + + show_space(); + } + + /* go to the next protocol layer */ + + if (!interpret_reserved(flags, IPPROTO_TCP, + ntohs(tcp->th_sport), + ntohs(tcp->th_dport), + data, fraglen)) { + if (sunrpc && fraglen > 0) + interpret_rpc(flags, data, fraglen, IPPROTO_TCP); + } + + return (tcplen); +} + +static void +print_tcpoptions(opt, optlen) + uchar_t *opt; + int optlen; +{ + int len; + char *line; + uchar_t *sack_opt; + uchar_t *end_opt; + int sack_len; + + if (optlen <= 0) { + (void) sprintf(get_line((char *)&opt - dlc_header, 1), + "No options"); + return; + } + + (void) sprintf(get_line((char *)&opt - dlc_header, 1), + "Options: (%d bytes)", optlen); + + while (optlen > 0) { + line = get_line((char *)&opt - dlc_header, 1); + len = opt[1]; + switch (opt[0]) { + case TCPOPT_EOL: + (void) strcpy(line, " - End of option list"); + return; + case TCPOPT_NOP: + (void) strcpy(line, " - No operation"); + len = 1; + break; + case TCPOPT_MAXSEG: + (void) sprintf(line, + " - Maximum segment size = %d bytes", + (opt[2] << 8) + opt[3]); + break; + case TCPOPT_WSCALE: + (void) sprintf(line, " - Window scale = %d", opt[2]); + break; + case TCPOPT_TSTAMP: + /* Sanity check. */ + if (optlen < TCPOPT_TSTAMP_LEN) { + (void) sprintf(line, + " - Incomplete TS option"); + } else { + (void) sprintf(line, + " - TS Val = %u, TS Echo = %u", + GET_UINT32(opt + 2), + GET_UINT32(opt + 6)); + } + break; + case TCPOPT_SACK_PERMITTED: + (void) sprintf(line, " - SACK permitted option"); + break; + case TCPOPT_SACK: + /* + * Sanity check. Total length should be greater + * than just the option header length. + */ + if (len <= TCPOPT_HEADER_LEN || + opt[1] <= TCPOPT_HEADER_LEN || len < opt[1]) { + (void) sprintf(line, + " - Incomplete SACK option"); + break; + } + sack_len = opt[1] - TCPOPT_HEADER_LEN; + sack_opt = opt + TCPOPT_HEADER_LEN; + end_opt = opt + optlen; + + (void) sprintf(line, " - SACK blocks:"); + line = get_line((char *)&opt - dlc_header, 1); + (void) sprintf(line, " "); + while (sack_len > 0) { + char sack_blk[MAXLINE + 1]; + + /* + * sack_len may not tell us the truth about + * the real length... Need to be careful + * not to step beyond the option buffer. + */ + if (sack_opt + TCPOPT_SACK_LEN > end_opt) { + (void) strcat(line, + "...incomplete SACK block"); + break; + } + (void) sprintf(sack_blk, "(%u-%u) ", + GET_UINT32(sack_opt), + GET_UINT32(sack_opt + 4)); + (void) strcat(line, sack_blk); + sack_opt += TCPOPT_SACK_LEN; + sack_len -= TCPOPT_SACK_LEN; + } + break; + default: + (void) sprintf(line, + " - Option %d (unknown - %d bytes) %s", + opt[0], + len - 2, + tohex((char *)&opt[2], len - 2)); + break; + } + if (len <= 0) { + (void) sprintf(line, " - Incomplete option len %d", + len); + break; + } + opt += len; + optlen -= len; + } +} + +/* + * This function is basically the same as print_tcpoptions() except that + * all options are printed on the same line. + */ +static void +print_tcpoptions_summary(uchar_t *opt, int optlen, char *line) +{ + int len; + uchar_t *sack_opt; + uchar_t *end_opt; + int sack_len; + char options[MAXLINE + 1]; + + if (optlen <= 0) { + return; + } + + (void) strcat(line, " Options=<"); + while (optlen > 0) { + len = opt[1]; + switch (opt[0]) { + case TCPOPT_EOL: + (void) strcat(line, "eol>"); + return; + case TCPOPT_NOP: + (void) strcat(line, "nop"); + len = 1; + break; + case TCPOPT_MAXSEG: + (void) sprintf(options, "mss %d", + (opt[2] << 8) + opt[3]); + (void) strcat(line, options); + break; + case TCPOPT_WSCALE: + (void) sprintf(options, "wscale %d", opt[2]); + (void) strcat(line, options); + break; + case TCPOPT_TSTAMP: + /* Sanity check. */ + if (optlen < TCPOPT_TSTAMP_LEN) { + (void) strcat(line, "tstamp|"); + } else { + (void) sprintf(options, + "tstamp %u %u", GET_UINT32(opt + 2), + GET_UINT32(opt + 6)); + (void) strcat(line, options); + } + break; + case TCPOPT_SACK_PERMITTED: + (void) strcat(line, "sackOK"); + break; + case TCPOPT_SACK: + /* + * Sanity check. Total length should be greater + * than just the option header length. + */ + if (len <= TCPOPT_HEADER_LEN || + opt[1] <= TCPOPT_HEADER_LEN || len < opt[1]) { + (void) strcat(line, "sack|"); + break; + } + sack_len = opt[1] - TCPOPT_HEADER_LEN; + sack_opt = opt + TCPOPT_HEADER_LEN; + end_opt = opt + optlen; + + (void) strcat(line, "sack"); + while (sack_len > 0) { + /* + * sack_len may not tell us the truth about + * the real length... Need to be careful + * not to step beyond the option buffer. + */ + if (sack_opt + TCPOPT_SACK_LEN > end_opt) { + (void) strcat(line, "|"); + break; + } + (void) sprintf(options, " %u-%u", + GET_UINT32(sack_opt), + GET_UINT32(sack_opt + 4)); + (void) strcat(line, options); + sack_opt += TCPOPT_SACK_LEN; + sack_len -= TCPOPT_SACK_LEN; + } + break; + default: + (void) sprintf(options, "unknown %d", opt[0]); + (void) strcat(line, options); + break; + } + if (len <= 0) { + (void) sprintf(options, "optlen %d", len); + (void) strcat(line, options); + break; + } + opt += len; + optlen -= len; + if (optlen > 0) { + (void) strcat(line, ","); + } + } + (void) strcat(line, ">"); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tftp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tftp.c new file mode 100644 index 0000000..2196454 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_tftp.c @@ -0,0 +1,178 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <fcntl.h> +#include <arpa/tftp.h> +#include "snoop.h" + +extern char *dlc_header; +char *tftperror(); +char *show_type(); + +int +interpret_tftp(int flags, struct tftphdr *tftp, int fraglen) +{ + char *name, *mode; + extern int src_port, dst_port; + int blocksize = fraglen - 4; + + switch (ntohs(tftp->th_opcode)) { + case RRQ: + case WRQ: + add_transient(src_port, interpret_tftp); + break; + case ERROR: + del_transient(src_port); + break; + } + + if (flags & F_SUM) { + switch (ntohs(tftp->th_opcode)) { + case RRQ: + name = (char *)&tftp->th_stuff; + mode = name + (strlen(name) + 1); + (void) sprintf(get_sum_line(), + "TFTP Read \"%s\" (%s)", name, mode); + break; + case WRQ: + name = (char *)&tftp->th_stuff; + mode = name + (strlen(name) + 1); + (void) sprintf(get_sum_line(), + "TFTP Write \"%s\" (%s)", name, mode); + break; + case DATA: + (void) sprintf(get_sum_line(), + "TFTP Data block %d (%d bytes)%s", + ntohs(tftp->th_block), + blocksize, + blocksize < 512 ? " (last block)":""); + break; + case ACK: + (void) sprintf(get_sum_line(), + "TFTP Ack block %d", + ntohs(tftp->th_block)); + break; + case ERROR: + (void) sprintf(get_sum_line(), + "TFTP Error: %s", + tftperror(ntohs(tftp->th_code))); + break; + } + } + + if (flags & F_DTAIL) { + + show_header("TFTP: ", "Trivial File Transfer Protocol", fraglen); + show_space(); + (void) sprintf(get_line((char *)(uintptr_t)tftp->th_opcode - + dlc_header, 2), + "Opcode = %d (%s)", + ntohs(tftp->th_opcode), + show_type(ntohs(tftp->th_opcode))); + + switch (ntohs(tftp->th_opcode)) { + case RRQ: + case WRQ: + name = (char *)&tftp->th_stuff; + mode = name + (strlen(name) + 1); + (void) sprintf( + get_line(name - dlc_header, strlen(name) + 1), + "File name = \"%s\"", + name); + (void) sprintf( + get_line(mode - dlc_header, strlen(mode) + 1), + "Transfer mode = %s", + mode); + break; + + case DATA: + (void) sprintf( + get_line((char *)(uintptr_t)tftp->th_block - + dlc_header, 2), "Data block = %d%s", + ntohs(tftp->th_block), + blocksize < 512 ? " (last block)":""); + (void) sprintf(get_line((char *)(uintptr_t)tftp->th_data - + dlc_header, blocksize), + "[ %d bytes of data ]", + blocksize); + break; + + case ACK: + (void) sprintf(get_line((char *)(uintptr_t)tftp->th_block - + dlc_header, 2), "Acknowledge block = %d", + ntohs(tftp->th_block)); + break; + + case ERROR: + (void) sprintf(get_line((char *)(uintptr_t)tftp->th_code - + dlc_header, 2), "Error = %d (%s)", + ntohs(tftp->th_code), + tftperror(ntohs(tftp->th_code))); + (void) sprintf(get_line((char *)(uintptr_t)tftp->th_data - + dlc_header, strlen(tftp->th_data) + 1), + "Error string = \"%s\"", tftp->th_data); + } + } + + return (fraglen); +} + +char * +show_type(t) + int t; +{ + switch (t) { + case RRQ: return ("read request"); + case WRQ: return ("write request"); + case DATA: return ("data packet"); + case ACK: return ("acknowledgement"); + case ERROR: return ("error"); + } + return ("?"); +} + +char * +tftperror(code) + unsigned short code; +{ + static char buf[128]; + + switch (code) { + case EUNDEF: return ("not defined"); + case ENOTFOUND: return ("file not found"); + case EACCESS: return ("access violation"); + case ENOSPACE: return ("disk full or allocation exceeded"); + case EBADOP: return ("illegal TFTP operation"); + case EBADID: return ("unknown transfer ID"); + case EEXISTS: return ("file already exists"); + case ENOUSER: return ("no such user"); + } + (void) sprintf(buf, "%d", code); + + return (buf); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_trill.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_trill.c new file mode 100644 index 0000000..51876bc --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_trill.c @@ -0,0 +1,117 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ethernet.h> +#include <sys/vlan.h> +#include <net/trill.h> + +#include <snoop.h> + +int +interpret_trill(int flags, struct ether_header **e, char *data, int *alen) +{ + trill_header_t *trillhdr; + struct ether_header *inner_ethhdr; + struct ether_vlan_header *inner_ethvlanhdr; + uint16_t ethertype; + int dlen = *alen; + size_t optslen; + size_t trillhdrlen; + + if (dlen < sizeof (trill_header_t)) { + (void) snprintf(get_sum_line(), MAXLINE, + "TRILL (short packet)"); + return (0); + } + + trillhdr = (trill_header_t *)data; + optslen = GET_TRILL_OPTS_LEN(trillhdr) * sizeof (uint32_t); + + if (flags & F_DTAIL) { + show_header("TRILL: ", "TRILL Data Frame", dlen); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Egress nickname = %d", + ntohs(trillhdr->th_egressnick)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Ingress nickname = %d", + ntohs(trillhdr->th_ingressnick)); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Hop count = %d", trillhdr->th_hopcount); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Multi-destination = %d", trillhdr->th_multidest); + (void) snprintf(get_line(0, 0), get_line_remain(), + "Options Len = %d bytes", optslen); + show_trailer(); + } + + trillhdrlen = sizeof (trill_header_t) + optslen; + + if (dlen < trillhdrlen) { + (void) snprintf(get_sum_line(), MAXLINE, + "TRILL (options truncated)"); + return (0); + } + + dlen -= trillhdrlen; + + if (dlen < sizeof (struct ether_header)) { + (void) snprintf(get_sum_line(), MAXLINE, + "TRILL (missing required inner MAC)"); + return (0); + } + + inner_ethhdr = (struct ether_header *)(data + trillhdrlen); + if (inner_ethhdr->ether_type != htons(ETHERTYPE_VLAN)) { + (void) snprintf(get_sum_line(), MAXLINE, + "TRILL (inner VLAN missing; ethertype %X)", + ntohs(inner_ethhdr->ether_type)); + return (0); + } + + inner_ethvlanhdr = (struct ether_vlan_header *)inner_ethhdr; + ethertype = ntohs(inner_ethvlanhdr->ether_type); + + if (flags & F_SUM) { + (void) snprintf(get_sum_line(), MAXLINE, + "TRILL D:%d S:%d HC:%d M:%d O:%d L:%d VLAN:%d %s", + ntohs(trillhdr->th_egressnick), + ntohs(trillhdr->th_ingressnick), + trillhdr->th_hopcount, + trillhdr->th_multidest, + optslen, + dlen, VLAN_ID(inner_ethvlanhdr->ether_tci), + print_ethertype(ethertype)); + } + + *alen = dlen; + *e = inner_ethhdr; + return (ethertype); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_udp.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_udp.c new file mode 100644 index 0000000..e4ee824 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_udp.c @@ -0,0 +1,124 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2005 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <ctype.h> +#include <string.h> +#include <fcntl.h> +#include <string.h> +#include <sys/types.h> +#include <sys/time.h> + +#include <sys/socket.h> +#include <sys/sockio.h> +#include <net/if.h> +#include <netinet/in_systm.h> +#include <netinet/in.h> +#include <netinet/ip.h> +#include <netinet/if_ether.h> +#include <netinet/udp.h> +#include "snoop.h" + +extern char *dlc_header; + +int +interpret_udp(int flags, struct udphdr *udp, int iplen, int fraglen) +{ + char *data; + int udplen; + int sunrpc; + char *pname; + char buff [32]; + + if (fraglen < sizeof (struct udphdr)) + return (fraglen); /* incomplete header */ + + data = (char *)udp + sizeof (struct udphdr); + udplen = ntohs((ushort_t)udp->uh_ulen) - sizeof (struct udphdr); + fraglen -= sizeof (struct udphdr); + if (fraglen > udplen) + fraglen = udplen; + + if (flags & F_SUM) { + (void) sprintf(get_sum_line(), + "UDP D=%d S=%d LEN=%d", + ntohs(udp->uh_dport), + ntohs(udp->uh_sport), + ntohs((ushort_t)udp->uh_ulen)); + } + + sunrpc = !reservedport(IPPROTO_UDP, ntohs(udp->uh_dport)) && + !reservedport(IPPROTO_UDP, ntohs(udp->uh_sport)) && + valid_rpc(data, udplen); + + if (flags & F_DTAIL) { + show_header("UDP: ", "UDP Header", udplen); + show_space(); + (void) sprintf(get_line((char *)(uintptr_t)udp->uh_sport - + dlc_header, 1), "Source port = %d", ntohs(udp->uh_sport)); + + if (sunrpc) { + pname = "(Sun RPC)"; + } else { + pname = getportname(IPPROTO_UDP, ntohs(udp->uh_dport)); + if (pname == NULL) { + pname = ""; + } else { + (void) sprintf(buff, "(%s)", pname); + pname = buff; + } + } + (void) sprintf(get_line((char *)(uintptr_t)udp->uh_dport - + dlc_header, 1), "Destination port = %d %s", + ntohs(udp->uh_dport), pname); + (void) sprintf(get_line((char *)(uintptr_t)udp->uh_ulen - + dlc_header, 1), "Length = %d %s", + ntohs((ushort_t)udp->uh_ulen), + udplen > fraglen ? + "(Not all data contained in this fragment)" + : ""); + (void) sprintf(get_line((char *)(uintptr_t)udp->uh_sum - + dlc_header, 1), "Checksum = %04X %s", + ntohs(udp->uh_sum), + udp->uh_sum == 0 ? "(no checksum)" : ""); + show_space(); + } + + + /* go to the next protocol layer */ + + if (!interpret_reserved(flags, IPPROTO_UDP, + ntohs(udp->uh_sport), + ntohs(udp->uh_dport), + data, fraglen)) { + if (fraglen > 0 && sunrpc) + interpret_rpc(flags, data, fraglen, IPPROTO_UDP); + } + + return (fraglen); +} diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_vlan.h b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_vlan.h new file mode 100644 index 0000000..068bcb5 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_vlan.h @@ -0,0 +1,57 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ + +/* + * Copyright 2006 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SNOOP_VLAN_H +#define _SNOOP_VLAN_H + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <sys/ethernet.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The offset in bytes, in a VLAN tagged packet, from the + * ethernet header ethertype (which is ETHERTYPE_VLAN) to + * the encapsulated ethertype. + */ +#define ENCAP_ETHERTYPE_OFF (offsetof(struct ether_vlan_header, ether_type) -\ + offsetof(struct ether_vlan_header, ether_tpid)) + +/* + * The offset in bytes, from the beginning of an ethernet header, + * to the VLAN ID. + */ +#define VLAN_ID_OFFSET (offsetof(struct ether_vlan_header, ether_tci) -\ + offsetof(struct ether_vlan_header, ether_dhost)) + +#ifdef __cplusplus +} +#endif + +#endif /* _SNOOP_VLAN_H */ diff --git a/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_zip.c b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_zip.c new file mode 100644 index 0000000..b1093b0 --- /dev/null +++ b/usr/src/cmd/cmd-inet/usr.sbin/snoop/snoop_zip.c @@ -0,0 +1,407 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + */ + +#pragma ident "%Z%%M% %I% %E% SMI" + +#include <stdio.h> +#include <sys/types.h> + +#include <at.h> +#include <snoop.h> + +char *print_macaddr(uint8_t *, int); + +static char *zip_flags(char); +static char *zip_flags_long(char); + +void +interpret_ddp_zip(int flags, struct zip_hdr *zip, int len) +{ + int cnt; + uint16_t net; + uint16_t range; + uint8_t *p; + char zone[33]; + char defzone[60] = ""; + char mcast[50] = ""; + uint8_t gniflags; + uint8_t *tail = (uint8_t *)zip + len; + + if (flags & F_SUM) { + if (len < sizeof (struct zip_hdr)) + goto out; + + switch (zip->zip_func) { + case ZIP_QUERY: + cnt = zip->zip_netcnt; + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP Query CNT = %d", cnt); + break; + case ZIP_REPLY: + case ZIP_EXT_REPLY: + cnt = zip->zip_netcnt; + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP Reply CNT = %d", cnt); + break; + case ZIP_GET_NET_INFO: + p = &zip->zip_func; + + if ((p+6 > tail) || (p+7+p[6] > tail)) + goto out; + + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP GNI Zone = \"%.*s\"", p[6], &p[7]); + break; + case ZIP_GET_NET_INFO_REPLY: + p = &zip->zip_func; + + gniflags = p[1]; + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP GNI Rep Flags 0x%x (%s)", + gniflags, zip_flags(gniflags)); + break; + default: + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP CMD = %d", zip->zip_func); + break; + } + } + + if (flags & F_DTAIL) { + show_header("ZIP: ", "ZIP Header", len); + show_space(); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Length = %d", len); + + if (len < sizeof (struct zip_hdr)) + goto out; + + switch (zip->zip_func) { + case ZIP_QUERY: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Query, Network count = %d", zip->zip_netcnt); + cnt = zip->zip_netcnt; + p = (uint8_t *)(zip + 1); + while (cnt--) { + if (p+2 > tail) + goto out; + net = get_short(p); + p += 2; + (void) snprintf(get_line(0, 0), + get_line_remain(), "Net = %d", net); + } + break; + case ZIP_REPLY: + case ZIP_EXT_REPLY: + cnt = zip->zip_netcnt; + (void) snprintf(get_line(0, 0), get_line_remain(), + "Reply, Network count = %d", cnt); + + p = (uint8_t *)(zip + 1); + while (cnt--) { + if (p+2 > tail) + goto out; + net = get_short(p); + p += 2; + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Network = %d, Zone = \"%.*s\"", + net, p[0], &p[1]); + p += p[0] + 1; + } + break; + case ZIP_GET_NET_INFO: + p = &zip->zip_func; + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + (void) snprintf(get_line(0, 0), get_line_remain(), + "GetNetInfo Zone = \"%.*s\"", p[0], &p[1]); + break; + case ZIP_GET_NET_INFO_REPLY: + p = &zip->zip_func; + if (p+5 > tail) + goto out; + gniflags = p[1]; + net = get_short(&p[2]); + range = get_short(&p[4]); + + if (p+7 > tail || (&p[7] + p[6]) > tail) + goto out; + (void) snprintf(zone, sizeof (zone), + "%.*s", p[6], &p[7]); + p = &p[7] + p[6]; + + if ((gniflags & ZIP_FLG_USEBRC) == 0) { + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + (void) snprintf(mcast, sizeof (mcast), + "Multicast address = %s", + print_macaddr(&p[1], p[0])); + } + + if (gniflags & ZIP_FLG_ZINV) { + p = &p[1] + p[0]; + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + (void) snprintf(defzone, sizeof (defzone), + "Default Zone = \"%.*s\"", + p[0], &p[1]); + } + (void) snprintf(get_line(0, 0), get_line_remain(), + "GetNetInfo Reply, Flags 0x%x (%s)", + gniflags, zip_flags_long(gniflags)); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Network number = %d-%d", net, range); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Zone = \"%s\"", zone); + + if (mcast[0]) + (void) snprintf(get_line(0, 0), + get_line_remain(), + "%s", mcast); + + if (defzone[0]) + (void) snprintf(get_line(0, 0), + get_line_remain(), + "%s", defzone); + + break; + case ZIP_NOTIFY: + p = &zip->zip_func; + if (p+5 > tail) + goto out; + + gniflags = p[1]; + net = get_short(&p[2]); + range = get_short(&p[4]); + + if (p+7 > tail || (&p[7] + p[6]) > tail) + goto out; + (void) snprintf(zone, sizeof (zone), + "%.*s", p[6], &p[7]); + p = &p[7] + p[6]; + + if ((gniflags & ZIP_FLG_USEBRC) == 0) { + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + (void) snprintf(mcast, sizeof (mcast), + "New Multicast address = %s", + print_macaddr(&p[1], p[0])); + } + + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + + p = &p[1] + p[0]; + + if (p+1 > tail || (&p[1] + p[0]) > tail) + goto out; + + (void) snprintf(defzone, sizeof (defzone), + "New Default Zone = \"%.*s\"", + p[0], &p[1]); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Notify, Flags 0x%x (%s)", + gniflags, zip_flags_long(gniflags)); + + (void) snprintf(get_line(0, 0), get_line_remain(), + "Old Zone = \"%s\"", zone); + + if (mcast[0]) + (void) snprintf(get_line(0, 0), + get_line_remain(), "%s", mcast); + + if (defzone[0]) + (void) snprintf(get_line(0, 0), + get_line_remain(), "%s", defzone); + + break; + default: + (void) snprintf(get_line(0, 0), get_line_remain(), + "Op = %d", zip->zip_func); + break; + } + } + return; +out: + if (flags & F_SUM) + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP (short packet)"); + if (flags & F_DTAIL) + (void) snprintf(get_line(0, 0), get_line_remain(), + "ZIP (short packet)"); +} + +static char * +zip_flags(char flags) +{ + static char buf[50]; + char *p = buf; + char *tail = &buf[sizeof (buf)]; + + buf[0] = '\0'; + + if (flags & ZIP_FLG_ZINV) + p += snprintf(p, tail-p, "IZ"); + + if (flags & ZIP_FLG_USEBRC) + p += snprintf(p, tail-p, p == buf ? "UB" : " UB"); + + if (flags & ZIP_FLG_ONEZ) + (void) snprintf(p, tail-p, p == buf ? "OOZ" : " OOZ"); + + return (buf); +} + +static char * +zip_flags_long(char flags) +{ + static char buf[50]; + char *p = buf; + char *tail = &buf[sizeof (buf)]; + + buf[0] = '\0'; + + if (flags & ZIP_FLG_ZINV) + p += snprintf(p, tail-p, "ZoneInvalid"); + + if (flags & ZIP_FLG_USEBRC) + p += snprintf(p, tail-p, + p == buf ? "UseBroadcast" : " UseBroadcast"); + + if (flags & ZIP_FLG_ONEZ) + (void) snprintf(p, tail-p, + p == buf ? "OnlyOneZone" : " OnlyOneZone"); + + return (buf); +} + +void +interpret_atp_zip(int flags, struct atp_hdr *atp, int len) +{ + int cnt; + uint8_t *data; + uint8_t *tail = (uint8_t *)(atp+1) + len; + + if (flags & F_SUM) { + if (len < 0) { + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP (short packet)"); + return; + } + + switch (atp_fun(atp->atp_ctrl)) { + case ATP_TREQ: + switch (atp->atp_user[0]) { + case ZIP_ATP_GETMYZONE: + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP GetMyZone"); + break; + + case ZIP_ATP_GETZONELIST: + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP GetZoneList"); + break; + + case ZIP_ATP_GETLOCALZONES: + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP GetLocalZones"); + break; + } + break; + case ATP_TRESP: + cnt = get_short(&atp->atp_user[2]); + (void) snprintf(get_sum_line(), MAXLINE, + "ZIP ZoneReply, Cnt = %d", cnt); + + break; + } + } + + if (flags & F_DTAIL) { + show_header("ZIP: ", "ZIP Header", len); + show_space(); + + if (len < 0) { + (void) snprintf(get_line(0, 0), get_line_remain(), + "ZIP (short packet)"); + return; + } + + switch (atp_fun(atp->atp_ctrl)) { + case ATP_TREQ: + switch (atp->atp_user[0]) { + case ZIP_ATP_GETMYZONE: + (void) snprintf(get_line(0, 0), + get_line_remain(), + "GetMyZone, Start Index = %d", + get_short(&atp->atp_user[2])); + break; + case ZIP_ATP_GETZONELIST: + (void) snprintf(get_line(0, 0), + get_line_remain(), + "GetZoneList, Start Index = %d", + get_short(&atp->atp_user[2])); + break; + case ZIP_ATP_GETLOCALZONES: + (void) snprintf(get_line(0, 0), + get_line_remain(), + "GetLocalZones, Start Index = %d", + get_short(&atp->atp_user[2])); + break; + } + break; + case ATP_TRESP: + cnt = get_short(&atp->atp_user[2]); + (void) snprintf(get_line(0, 0), get_line_remain(), + "ZoneReply, Number of Zones = %d, Length = %d", + cnt, len); + + data = (uint8_t *)atp + DDPHDR_SIZE + ATPHDR_SIZE; + + while (cnt--) { + if (data > tail || + (&data[1] + data[0]) > tail) { + (void) snprintf(get_line(0, 0), + get_line_remain(), + "ZoneReply (short packet)"); + return; + } + (void) snprintf(get_line(0, 0), + get_line_remain(), + "Zone = \"%.*s\"", data[0], &data[1]); + data += data[0] + 1; + } + break; + } + } +} |