diff --git a/usr.bin/systat/Makefile b/usr.bin/systat/Makefile index 5a0a05ed3acf..c74c08dc05fa 100644 --- a/usr.bin/systat/Makefile +++ b/usr.bin/systat/Makefile @@ -3,8 +3,10 @@ PROG= systat SRCS= cmds.c cmdtab.c devs.c fetch.c iostat.c keyboard.c main.c \ - mbufs.c netcmds.c netstat.c pigs.c swap.c icmp.c mode.c ip.c tcp.c \ + mbufs.c netcmds.c netstat.c pigs.c swap.c icmp.c icmp6.c \ + mode.c ip.c ip6.c tcp.c \ vmstat.c convtbl.c ifcmds.c ifstat.c +CFLAGS+=-DINET6 DPADD= ${LIBCURSES} ${LIBM} ${LIBKVM} ${LIBDEVSTAT} LDADD= -lcurses -lm -lkvm -ldevstat diff --git a/usr.bin/systat/cmdtab.c b/usr.bin/systat/cmdtab.c index bb174556b1aa..6b4f77ee7cf1 100644 --- a/usr.bin/systat/cmdtab.c +++ b/usr.bin/systat/cmdtab.c @@ -68,6 +68,14 @@ struct cmdtab cmdtab[] = { { "ip", showip, fetchip, labelip, initip, openip, closeip, cmdmode, resetip, CF_LOADAV }, +#ifdef INET6 + { "icmp6", showicmp6, fetchicmp6, labelicmp6, + initicmp6, openicmp6, closeicmp6, cmdmode, + reseticmp6, CF_LOADAV }, + { "ip6", showip6, fetchip6, labelip6, + initip6, openip6, closeip6, cmdmode, + resetip6, CF_LOADAV }, +#endif { "tcp", showtcp, fetchtcp, labeltcp, inittcp, opentcp, closetcp, cmdmode, resettcp, 0 }, diff --git a/usr.bin/systat/extern.h b/usr.bin/systat/extern.h index 48993d9cf559..c8dd62b77a6a 100644 --- a/usr.bin/systat/extern.h +++ b/usr.bin/systat/extern.h @@ -73,9 +73,11 @@ extern struct nlist namelist[]; int checkhost(struct inpcb *); int checkport(struct inpcb *); void closeicmp(WINDOW *); +void closeicmp6(WINDOW *); void closeifstat(WINDOW *); void closeiostat(WINDOW *); void closeip(WINDOW *); +void closeip6(WINDOW *); void closekre(WINDOW *); void closembufs(WINDOW *); void closenetstat(WINDOW *); @@ -94,8 +96,10 @@ int dkinit(void); int dkcmd(char *, char *); void error(const char *fmt, ...) __printflike(1, 2); void fetchicmp(void); +void fetchicmp6(void); void fetchifstat(void); void fetchip(void); +void fetchip6(void); void fetchiostat(void); void fetchkre(void); void fetchmbufs(void); @@ -105,8 +109,10 @@ void fetchswap(void); void fetchtcp(void); void getsysctl(const char *, void *, size_t); int initicmp(void); +int initicmp6(void); int initifstat(void); int initip(void); +int initip6(void); int initiostat(void); int initkre(void); int initmbufs(void); @@ -117,8 +123,10 @@ int inittcp(void); int keyboard(void); int kvm_ckread(void *, void *, int); void labelicmp(void); +void labelicmp6(void); void labelifstat(void); void labelip(void); +void labelip6(void); void labeliostat(void); void labelkre(void); void labelmbufs(void); @@ -131,8 +139,10 @@ void load(void); int netcmd(const char *, const char *); void nlisterr(struct nlist []); WINDOW *openicmp(void); +WINDOW *openicmp6(void); WINDOW *openifstat(void); WINDOW *openip(void); +WINDOW *openip6(void); WINDOW *openiostat(void); WINDOW *openkre(void); WINDOW *openmbufs(void); @@ -142,11 +152,15 @@ WINDOW *openswap(void); WINDOW *opentcp(void); int prefix(const char *, const char *); void reseticmp(void); +void reseticmp6(void); void resetip(void); +void resetip6(void); void resettcp(void); void showicmp(void); +void showicmp6(void); void showifstat(void); void showip(void); +void showip6(void); void showiostat(void); void showkre(void); void showmbufs(void); diff --git a/usr.bin/systat/icmp6.c b/usr.bin/systat/icmp6.c new file mode 100644 index 000000000000..c02819ffdd6d --- /dev/null +++ b/usr.bin/systat/icmp6.c @@ -0,0 +1,283 @@ +/*- + * Copyright (c) 1980, 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include + +__FBSDID("$FreeBSD$"); + +#ifdef lint +static char sccsid[] = "@(#)mbufs.c 8.1 (Berkeley) 6/6/93"; +#endif + +/* From: + "Id: mbufs.c,v 1.5 1997/02/24 20:59:03 wollman Exp" +*/ + +#ifdef INET6 +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include "systat.h" +#include "extern.h" +#include "mode.h" + +static struct icmp6stat icmp6stat, initstat, oldstat; + +/*- +--0 1 2 3 4 5 6 7 +--0123456789012345678901234567890123456789012345678901234567890123456789012345 +01 ICMPv6 Input ICMPv6 Output +02999999999 total messages 999999999 total messages +03999999999 with bad code 999999999 errors generated +04999999999 with bad length 999999999 suppressed - original too short +05999999999 with bad checksum 999999999 suppressed - original was ICMP +06999999999 with insufficient data 999999999 responses sent +07 +08 Input Histogram Output Histogram +09999999999 echo response 999999999 echo response +10999999999 echo request 999999999 echo request +11999999999 destination unreachable 999999999 destination unreachable +12999999999 redirect 999999999 redirect +13999999999 time-to-live exceeded 999999999 time-to-line exceeded +14999999999 parameter problem 999999999 parameter problem +15999999999 neighbor solicitation 999999999 neighbor solicitation +16999999999 neighbor advertisment 999999999 neighbor advertisment +17999999999 router advertisement 999999999 router solicitation +18 +19 +--0123456789012345678901234567890123456789012345678901234567890123456789012345 +--0 1 2 3 4 5 6 7 +*/ + +WINDOW * +openicmp6(void) +{ + return (subwin(stdscr, LINES-5-1, 0, 5, 0)); +} + +void +closeicmp6(w) + WINDOW *w; +{ + if (w == NULL) + return; + wclear(w); + wrefresh(w); + delwin(w); +} + +void +labelicmp6(void) +{ + wmove(wnd, 0, 0); wclrtoeol(wnd); +#define L(row, str) mvwprintw(wnd, row, 10, str) +#define R(row, str) mvwprintw(wnd, row, 45, str); + L(1, "ICMPv6 Input"); R(1, "ICMPv6 Output"); + L(2, "total messages"); R(2, "total messages"); + L(3, "with bad code"); R(3, "errors generated"); + L(4, "with bad length"); R(4, "suppressed - original too short"); + L(5, "with bad checksum"); R(5, "suppressed - original was ICMP"); + L(6, "with insufficient data"); R(6, "responses sent"); + + L(8, "Input Histogram"); R(8, "Output Histogram"); +#define B(row, str) L(row, str); R(row, str) + B(9, "echo response"); + B(10, "echo request"); + B(11, "destination unreachable"); + B(12, "redirect"); + B(13, "time-to-live exceeded"); + B(14, "parameter problem"); + B(15, "neighbor solicitation"); + B(16, "neighbor advertisment"); + L(17, "router advertisement"); R(17, "router solicitation"); +#undef L +#undef R +#undef B +} + +static void +domode(struct icmp6stat *ret) +{ + const struct icmp6stat *sub; + int i, divisor = 1; + + switch(currentmode) { + case display_RATE: + sub = &oldstat; + divisor = naptime; + break; + case display_DELTA: + sub = &oldstat; + break; + case display_SINCE: + sub = &initstat; + break; + default: + *ret = icmp6stat; + return; + } +#define DO(stat) ret->stat = (icmp6stat.stat - sub->stat) / divisor + DO(icp6s_error); + DO(icp6s_tooshort); + DO(icp6s_canterror); + for (i = 0; i <= ICMP6_MAXTYPE; i++) { + DO(icp6s_outhist[i]); + } + DO(icp6s_badcode); + DO(icp6s_tooshort); + DO(icp6s_checksum); + DO(icp6s_badlen); + DO(icp6s_reflect); + for (i = 0; i <= ICMP6_MAXTYPE; i++) { + DO(icp6s_inhist[i]); + } +#undef DO +} + +void +showicmp6(void) +{ + struct icmp6stat stats; + u_long totalin, totalout; + int i; + + memset(&stats, 0, sizeof stats); + domode(&stats); + for (i = totalin = totalout = 0; i <= ICMP6_MAXTYPE; i++) { + totalin += stats.icp6s_inhist[i]; + totalout += stats.icp6s_outhist[i]; + } + totalin += stats.icp6s_badcode + stats.icp6s_badlen + + stats.icp6s_checksum + stats.icp6s_tooshort; + mvwprintw(wnd, 2, 0, "%9lu", totalin); + mvwprintw(wnd, 2, 35, "%9lu", totalout); + +#define DO(stat, row, col) \ + mvwprintw(wnd, row, col, "%9lu", stats.stat) + + DO(icp6s_badcode, 3, 0); + DO(icp6s_badlen, 4, 0); + DO(icp6s_checksum, 5, 0); + DO(icp6s_tooshort, 6, 0); + DO(icp6s_error, 3, 35); + DO(icp6s_tooshort, 4, 35); + DO(icp6s_canterror, 5, 35); + DO(icp6s_reflect, 6, 35); +#define DO2(type, row) DO(icp6s_inhist[type], row, 0); DO(icp6s_outhist[type], \ + row, 35) + DO2(ICMP6_ECHO_REPLY, 9); + DO2(ICMP6_ECHO_REQUEST, 10); + DO2(ICMP6_DST_UNREACH, 11); + DO2(ND_REDIRECT, 12); + DO2(ICMP6_TIME_EXCEEDED, 13); + DO2(ICMP6_PARAM_PROB, 14); + DO2(ND_NEIGHBOR_SOLICIT, 15); + DO2(ND_NEIGHBOR_ADVERT, 16); + DO(icp6s_inhist[ND_ROUTER_SOLICIT], 17, 0); + DO(icp6s_outhist[ND_ROUTER_ADVERT], 17, 35); +#undef DO +#undef DO2 +} + +int +initicmp6(void) +{ + size_t len; + int name[4]; + + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_ICMPV6; + name[3] = ICMPV6CTL_STATS; + + len = 0; + if (sysctl(name, 4, 0, &len, 0, 0) < 0) { + error("sysctl getting icmp6stat size failed"); + return 0; + } + if (len > sizeof icmp6stat) { + error("icmp6stat structure has grown--recompile systat!"); + return 0; + } + if (sysctl(name, 4, &initstat, &len, 0, 0) < 0) { + error("sysctl getting icmp6stat size failed"); + return 0; + } + oldstat = initstat; + return 1; +} + +void +reseticmp6(void) +{ + size_t len; + int name[4]; + + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_ICMPV6; + name[3] = ICMPV6CTL_STATS; + + len = sizeof initstat; + if (sysctl(name, 4, &initstat, &len, 0, 0) < 0) { + error("sysctl getting icmp6stat size failed"); + } + oldstat = initstat; +} + +void +fetchicmp6(void) +{ + int name[4]; + size_t len; + + oldstat = icmp6stat; + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_ICMPV6; + name[3] = ICMPV6CTL_STATS; + len = sizeof icmp6stat; + + if (sysctl(name, 4, &icmp6stat, &len, 0, 0) < 0) + return; +} + +#endif diff --git a/usr.bin/systat/ip6.c b/usr.bin/systat/ip6.c new file mode 100644 index 000000000000..a88c5b48c2e6 --- /dev/null +++ b/usr.bin/systat/ip6.c @@ -0,0 +1,303 @@ +/*- + * Copyright (c) 1980, 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include + +__FBSDID("$FreeBSD$"); + +#ifdef lint +static const char sccsid[] = "@(#)mbufs.c 8.1 (Berkeley) 6/6/93"; +#endif + +/* From: + "Id: mbufs.c,v 1.5 1997/02/24 20:59:03 wollman Exp" +*/ + +#ifdef INET6 +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include + +#include "systat.h" +#include "extern.h" +#include "mode.h" + +static struct ip6stat curstat, initstat, oldstat; + +/*- +--0 1 2 3 4 5 6 7 +--0123456789012345678901234567890123456789012345678901234567890123456789012345 +01 IPv6 Input IPv6 Output +029999999 total packets received 999999999 total packets sent +039999999 - too short for header 999999999 - generated locally +049999999 - too short for data 999999999 - output drops +059999999 - with invalid version 999999999 output fragments generated +069999999 total fragments received 999999999 - fragmentation failed +079999999 - fragments dropped 999999999 destinations unreachable +089999999 - fragments timed out 999999999 packets output via raw IP +099999999 - fragments overflown Input next-header histogram +109999999 - packets reassembled ok 999999999 - destination options +119999999 packets forwarded 999999999 - hop-by-hop options +129999999 - unreachable dests 999999999 - IPv4 +139999999 - redirects generated 999999999 - TCP +149999999 option errors 999999999 - UDP +159999999 unwanted multicasts 999999999 - IPv6 +169999999 delivered to upper layer 999999999 - routing header +17 999999999 - fragmentation header +189999999 bad scope packets 999999999 - ICMP6 +199999999 address selection failed 999999999 - none +--0123456789012345678901234567890123456789012345678901234567890123456789012345 +--0 1 2 3 4 5 6 7 +*/ + +WINDOW * +openip6(void) +{ + return (subwin(stdscr, LINES-4-1, 0, 4, 0)); +} + +void +closeip6(w) + WINDOW *w; +{ + if (w == NULL) + return; + wclear(w); + wrefresh(w); + delwin(w); +} + +void +labelip6(void) +{ + wmove(wnd, 0, 0); wclrtoeol(wnd); +#define L(row, str) mvwprintw(wnd, row, 10, str) +#define R(row, str) mvwprintw(wnd, row, 45, str); + L(1, "IPv6 Input"); R(1, "IPv6 Output"); + L(2, "total packets received"); R(2, "total packets sent"); + L(3, "- too short for header"); R(3, "- generated locally"); + L(4, "- too short for data"); R(4, "- output drops"); + L(5, "- with invalid version"); R(5, "output fragments generated"); + L(6, "total fragments received"); R(6, "- fragmentation failed"); + L(7, "- fragments dropped"); R(7, "destinations unreachable"); + L(8, "- fragments timed out"); R(8, "packets output via raw IP"); + L(9, "- fragments overflown"); R(9, "Input next-header histogram"); + L(10, "- packets reassembled ok"); R(10, " - destination options"); + L(11, "packets forwarded"); R(11, " - hop-by-hop options"); + L(12, "- unreachable dests"); R(12, " - IPv4"); + L(13, "- redirects generated"); R(13, " - TCP"); + L(14, "option errors"); R(14, " - UDP"); + L(15, "unwanted multicasts"); R(15, " - IPv6"); + L(16, "delivered to upper layer"); R(16, " - routing header"); + R(17, " - fragmentation header"); + L(18, "bad scope packets"); R(18, " - ICMP6"); + L(19, "address selection failed"); R(19, " - none"); +#undef L +#undef R +} + +static void +domode(struct ip6stat *ret) +{ + const struct ip6stat *sub; + int divisor = 1, i; + + switch(currentmode) { + case display_RATE: + sub = &oldstat; + divisor = naptime; + break; + case display_DELTA: + sub = &oldstat; + break; + case display_SINCE: + sub = &initstat; + break; + default: + *ret = curstat; + return; + } +#define DO(stat) ret->stat = (curstat.stat - sub->stat) / divisor + DO(ip6s_total); + DO(ip6s_tooshort); + DO(ip6s_toosmall); + DO(ip6s_fragments); + DO(ip6s_fragdropped); + DO(ip6s_fragtimeout); + DO(ip6s_fragoverflow); + DO(ip6s_forward); + DO(ip6s_cantforward); + DO(ip6s_redirectsent); + DO(ip6s_delivered); + DO(ip6s_localout); + DO(ip6s_odropped); + DO(ip6s_reassembled); + DO(ip6s_fragmented); + DO(ip6s_ofragments); + DO(ip6s_cantfrag); + DO(ip6s_badoptions); + DO(ip6s_noroute); + DO(ip6s_badvers); + DO(ip6s_rawout); + DO(ip6s_notmember); + for (i = 0; i < 256; i++) + DO(ip6s_nxthist[i]); + DO(ip6s_badscope); + DO(ip6s_sources_none); +#undef DO +} + +void +showip6(void) +{ + struct ip6stat stats; + u_long totalout; + + domode(&stats); + totalout = stats.ip6s_forward + stats.ip6s_localout; + +#define DO(stat, row, col) \ + mvwprintw(wnd, row, col, "%9lu", stats.stat) + + DO(ip6s_total, 2, 0); + mvwprintw(wnd, 2, 35, "%9lu", totalout); + DO(ip6s_localout, 3, 35); + DO(ip6s_tooshort, 3, 0); + DO(ip6s_odropped, 4, 35); + DO(ip6s_toosmall, 4, 0); + DO(ip6s_ofragments, 5, 35); + DO(ip6s_badvers, 5, 0); + DO(ip6s_cantfrag, 6, 35); + DO(ip6s_fragments, 6, 0); + DO(ip6s_noroute, 7, 35); + DO(ip6s_fragdropped, 7, 0); + DO(ip6s_rawout, 8, 35); + DO(ip6s_fragtimeout, 8, 0); + DO(ip6s_fragoverflow, 9, 0); + DO(ip6s_nxthist[IPPROTO_DSTOPTS], 10, 35); + DO(ip6s_reassembled, 10, 0); + DO(ip6s_nxthist[IPPROTO_HOPOPTS], 11, 35); + DO(ip6s_forward, 11, 0); + DO(ip6s_nxthist[IPPROTO_IPV4], 12, 35); + DO(ip6s_cantforward, 12, 0); + DO(ip6s_nxthist[IPPROTO_TCP], 13, 35); + DO(ip6s_redirectsent, 13, 0); + DO(ip6s_nxthist[IPPROTO_UDP], 14, 35); + DO(ip6s_badoptions, 14, 0); + DO(ip6s_nxthist[IPPROTO_IPV6], 15, 35); + DO(ip6s_notmember, 15, 0); + DO(ip6s_nxthist[IPPROTO_ROUTING], 16, 35); + DO(ip6s_delivered, 16, 0); + DO(ip6s_nxthist[IPPROTO_FRAGMENT], 17, 35); + DO(ip6s_nxthist[IPPROTO_ICMPV6], 18, 35); + DO(ip6s_badscope, 18, 0); + DO(ip6s_nxthist[IPPROTO_NONE], 19, 35); + DO(ip6s_sources_none, 19, 0); +#undef DO +} + +int +initip6(void) +{ + size_t len; + int name[4]; + + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_IPV6; + name[3] = IPV6CTL_STATS; + + len = 0; + if (sysctl(name, 4, 0, &len, 0, 0) < 0) { + error("sysctl getting ip6stat size failed"); + return 0; + } + if (len > sizeof curstat) { + error("ip6stat structure has grown--recompile systat!"); + return 0; + } + if (sysctl(name, 4, &initstat, &len, 0, 0) < 0) { + error("sysctl getting ip6stat failed"); + return 0; + } + oldstat = initstat; + return 1; +} + +void +resetip6(void) +{ + size_t len; + int name[4]; + + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_IPV6; + name[3] = IPV6CTL_STATS; + + len = sizeof initstat; + if (sysctl(name, 4, &initstat, &len, 0, 0) < 0) { + error("sysctl getting ipstat failed"); + } + + oldstat = initstat; +} + +void +fetchip6(void) +{ + int name[4]; + size_t len; + + oldstat = curstat; + name[0] = CTL_NET; + name[1] = PF_INET6; + name[2] = IPPROTO_IPV6; + name[3] = IPV6CTL_STATS; + len = sizeof curstat; + + if (sysctl(name, 4, &curstat, &len, 0, 0) < 0) + return; +} + +#endif diff --git a/usr.bin/systat/netstat.c b/usr.bin/systat/netstat.c index c3b4a3b8a4e7..7a6c1bddccf1 100644 --- a/usr.bin/systat/netstat.c +++ b/usr.bin/systat/netstat.c @@ -53,6 +53,9 @@ static const char sccsid[] = "@(#)netstat.c 8.1 (Berkeley) 6/6/93"; #include #include #include +#ifdef INET6 +#include +#endif #include #include #include diff --git a/usr.bin/systat/systat.1 b/usr.bin/systat/systat.1 index 368c008e9b87..01f3dced3492 100644 --- a/usr.bin/systat/systat.1 +++ b/usr.bin/systat/systat.1 @@ -88,9 +88,11 @@ flag expects .Ar display to be one of: .Ic icmp , +.Ic icmp6 , .Ic ifstat , .Ic iostat , .Ic ip , +.Ic ip6 , .Ic mbufs , .Ic netstat , .Ic pigs , @@ -196,6 +198,11 @@ mode. The .Ic mode command with no argument will display the current mode in the command line. +.It Ic icmp6 +This display is like the +.Ic icmp +display, +but displays statistics for IPv6 ICMP. .It Ic ip Otherwise identical to the .Ic icmp @@ -204,6 +211,15 @@ display, except that it displays and .Tn UDP statistics. +.It Ic ip6 +Like the +.Ic ip +display, +except that it displays +.Tn IPv6 +statics. +It does not display +.Tn UDP statistics. .It Ic tcp Like .Ic icmp , @@ -516,7 +532,9 @@ and all passthrough devices that provide access to CDROM drives. .Xr netstat 1 , .Xr kvm 3 , .Xr icmp 4 , +.Xr icmp6 4 , .Xr ip 4 , +.Xr ip6 4 , .Xr tcp 4 , .Xr udp 4 , .Xr iostat 8 ,