socsvn commit: r269723 - soc2014/zkorchev/freebsd_head/usr.bin/netstat
zkorchev at FreeBSD.org
zkorchev at FreeBSD.org
Wed Jun 18 16:03:59 UTC 2014
Author: zkorchev
Date: Wed Jun 18 16:03:58 2014
New Revision: 269723
URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=269723
Log:
uncommited netstat changes
Modified:
soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet.c
soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet6.c
soc2014/zkorchev/freebsd_head/usr.bin/netstat/main.c
Modified: soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet.c
==============================================================================
--- soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet.c Wed Jun 18 13:41:20 2014 (r269722)
+++ soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet.c Wed Jun 18 16:03:58 2014 (r269723)
@@ -349,11 +349,7 @@
}
#if defined(SOL_ON)
- if (Oflag) {
- SOL_MAP_KEYL(&sol_stream, "internet");
- sol_array_start(&sol_stream);
- first = 0;
- }
+ if (Oflag) first = 0;
#endif
oxig = xig = (struct xinpgen *)buf;
@@ -550,55 +546,97 @@
}
if (numeric_port) {
if (inp->inp_vflag & INP_IPV4) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inetprint(&inp->inp_laddr, (int)inp->inp_lport,
name, 1);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inetprint(&inp->inp_faddr,
(int)inp->inp_fport, name, 1);
+ }
}
#ifdef INET6
else if (inp->inp_vflag & INP_IPV6) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inet6print(&inp->in6p_laddr,
(int)inp->inp_lport, name, 1);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inet6print(&inp->in6p_faddr,
(int)inp->inp_fport, name, 1);
+ }
} /* else nothing printed now */
#endif /* INET6 */
} else if (inp->inp_flags & INP_ANONPORT) {
if (inp->inp_vflag & INP_IPV4) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inetprint(&inp->inp_laddr, (int)inp->inp_lport,
name, 1);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inetprint(&inp->inp_faddr,
(int)inp->inp_fport, name, 0);
+ }
}
#ifdef INET6
else if (inp->inp_vflag & INP_IPV6) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inet6print(&inp->in6p_laddr,
(int)inp->inp_lport, name, 1);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inet6print(&inp->in6p_faddr,
(int)inp->inp_fport, name, 0);
+ }
} /* else nothing printed now */
#endif /* INET6 */
} else {
if (inp->inp_vflag & INP_IPV4) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inetprint(&inp->inp_laddr, (int)inp->inp_lport,
name, 0);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inetprint(&inp->inp_faddr,
(int)inp->inp_fport, name,
inp->inp_lport != inp->inp_fport);
+ }
}
#ifdef INET6
else if (inp->inp_vflag & INP_IPV6) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "local address");
+#endif
inet6print(&inp->in6p_laddr,
(int)inp->inp_lport, name, 0);
- if (!Lflag)
+ if (!Lflag) {
+#if defined(SOL_ON)
+ if (Oflag) SOL_MAP_KEYL(&sol_stream, "foreign address");
+#endif
inet6print(&inp->in6p_faddr,
(int)inp->inp_fport, name,
inp->inp_lport != inp->inp_fport);
+ }
} /* else nothing printed now */
#endif /* INET6 */
}
@@ -722,6 +760,7 @@
#if defined(SOL_ON)
if (Oflag)
{
+ sol_map_start(&sol_stream);
if (xig != oxig && xig->xig_gen != oxig->xig_gen) {
if (oxig->xig_count > xig->xig_count)
SOL_MAP_KEYL(&sol_stream, "maybe deleted");
@@ -731,8 +770,7 @@
SOL_MAP_KEYL(&sol_stream, "maybe created/deleted");
sol_string(&sol_stream, name, strlen(name));
}
-
- sol_array_end(&sol_stream);
+ sol_map_end(&sol_stream);
}
else
#endif
@@ -781,6 +819,150 @@
} else
kread_counters(off, &tcpstat, len);
+#if defined(SOL_ON)
+# define p(f, m) if (tcpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t )tcpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "sent");
+ sol_map_start(&sol_stream);
+ p(tcps_sndtotal, "total");
+ p(tcps_sndpack, "data");
+ p(tcps_sndbyte, "data B");
+ p(tcps_sndrexmitpack, "data retransmitted");
+ p(tcps_sndrexmitbyte, "data retransmitted B");
+ p(tcps_sndrexmitbad, "data unnecessarily retransmitted");
+ p(tcps_mturesent, "resends by MTU discovery");
+ p(tcps_sndacks, "ack-only");
+ p(tcps_delack, "ack-only delayed");
+ p(tcps_sndurg, "URG only");
+ p(tcps_sndprobe, "window probe");
+ p(tcps_sndwinup, "window update");
+ p(tcps_sndctrl, "control");
+ sol_map_end(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "recv");
+ sol_map_start(&sol_stream);
+ p(tcps_rcvtotal, "total");
+ p(tcps_rcvackpack, "acks");
+ p(tcps_rcvackbyte, "acks B");
+ p(tcps_rcvdupack, "duplicate acks");
+ p(tcps_rcvacktoomuch, "acks for unsent data");
+ p(tcps_rcvpack, "in-sequence");
+ p(tcps_rcvbyte, "in-sequence B");
+ p(tcps_rcvduppack, "complete duplicates");
+ p(tcps_rcvdupbyte, "complete duplicates B");
+ p(tcps_pawsdrop, "old duplicates");
+ p(tcps_rcvpartduppack, "partial duplicates");
+ p(tcps_rcvpartdupbyte, "partial duplicates B");
+ p(tcps_rcvoopack, "out-of-order");
+ p(tcps_rcvoobyte, "out-of-order B");
+ p(tcps_rcvpackafterwin, "data after window");
+ p(tcps_rcvbyteafterwin, "data after window B");
+ p(tcps_rcvwinprobe, "window probes");
+ p(tcps_rcvwinupd, "window updates");
+ p(tcps_rcvafterclose, "after close");
+ p(tcps_rcvbadsum, "discarded bad checksums");
+ p(tcps_rcvbadoff, "discarded bad header offset");
+ p(tcps_rcvshort, "discarded too short");
+ p(tcps_rcvreassfull, "discarded no space in queue");
+ sol_map_end(&sol_stream);
+
+ p(tcps_connattempt, "connection requests");
+ p(tcps_accepts, "connection accepts");
+ p(tcps_badsyn, "bad connection attempts");
+ p(tcps_listendrop, "listen queue overflows");
+ p(tcps_badrst, "ignored RSTs in the windows");
+ p(tcps_connects, "connections established");
+
+ SOL_MAP_KEYL(&sol_stream, "connections closed");
+ sol_map_start(&sol_stream);
+ p(tcps_closed, "total");
+ p(tcps_drops, "drops");
+ p(tcps_cachedrtt, "updated cached RTT");
+ p(tcps_cachedrttvar, "updated cached RTT variance");
+ p(tcps_cachedssthresh, "updated cached ssthresh");
+ sol_map_end(&sol_stream);
+
+ p(tcps_conndrops, "embryonic connections dropped");
+ p(tcps_rttupdated, "segments updated RTT");
+ p(tcps_segstimed, "segments attempted RTT");
+
+ p(tcps_rexmttimeo, "retransmit timeout");
+ p(tcps_timeoutdrop, "dropped by rexmit timeout");
+
+ p(tcps_persisttimeo, "persist timeouts");
+ p(tcps_persistdrop, "dropped by persist timeout");
+
+ p(tcps_finwait2_drops, "(fin_wait_2 dropped because of timeout");
+
+ p(tcps_keeptimeo, "keepalive timeout");
+ p(tcps_keepprobe, "keepalive probes sent");
+ p(tcps_keepdrops, "dropped by keepalive");
+
+ p(tcps_predack, "correct ACK header predictions");
+ p(tcps_preddat, "correct data packet header predictions");
+
+ SOL_MAP_KEYL(&sol_stream, "syncache");
+ sol_map_start(&sol_stream);
+ p(tcps_sc_added, "added");
+ p(tcps_sc_retransmitted, "retransmitted");
+ p(tcps_sc_dupsyn, "dupsyn");
+ p(tcps_sc_dropped, "dropped");
+ p(tcps_sc_completed, "completed");
+ p(tcps_sc_bucketoverflow, "bucket overflow");
+ p(tcps_sc_cacheoverflow, "cache overflow");
+ p(tcps_sc_reset, "reset");
+ p(tcps_sc_stale, "stale");
+ p(tcps_sc_aborted, "aborted");
+ p(tcps_sc_badack, "badack");
+ p(tcps_sc_unreach, "unreach");
+ p(tcps_sc_zonefail, "zone failures");
+ sol_map_end(&sol_stream);
+
+ p(tcps_sc_sendcookie, "cookies sent");
+ p(tcps_sc_recvcookie, "cookies received");
+
+ p(tcps_hc_added, "hostcache added");
+ p(tcps_hc_bucketoverflow, "bucket overflow");
+
+ SOL_MAP_KEYL(&sol_stream, "SACK");
+ sol_map_start(&sol_stream);
+ p(tcps_sack_recovery_episode, "recovery episodes");
+ p(tcps_sack_rexmits, "segment rexmits in recovery episodes");
+ p(tcps_sack_rexmit_bytes, "byte rexmits in recovery episodes");
+ p(tcps_sack_rcv_blocks, "options received");
+ p(tcps_sack_send_blocks, "options sent");
+ p(tcps_sack_sboverflow, "scoreboard overflow");
+ sol_map_end(&sol_stream);
+
+ p(tcps_ecn_ce, "ECN CE packets");
+ p(tcps_ecn_ect0, "ECN ECT(0) packets");
+ p(tcps_ecn_ect1, "ECN ECT(1) packets");
+ p(tcps_ecn_shs, "successful ECN handshakes");
+ p(tcps_ecn_rcwnd, "ECN congestion window reductions");
+
+ SOL_MAP_KEYL(&sol_stream, "tcp-md5 signature");
+ sol_map_start(&sol_stream);
+ p(tcps_sig_rcvgoodsig, "valid");
+ p(tcps_sig_rcvbadsig, "invalid");
+ p(tcps_sig_err_buildsig, "mismatch");
+ p(tcps_sig_err_sigopt, "unexpected");
+ p(tcps_sig_err_nosigopt, "not expected");
+ sol_map_end(&sol_stream);
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf ("%s:\n", name);
#define p(f, m) if (tcpstat.f || sflag <= 1) \
@@ -945,6 +1127,55 @@
} else
kread_counters(off, &udpstat, len);
+ delivered = udpstat.udps_ipackets -
+ udpstat.udps_hdrops -
+ udpstat.udps_badlen -
+ udpstat.udps_badsum -
+ udpstat.udps_noport -
+ udpstat.udps_noportbcast -
+ udpstat.udps_fullsock;
+
+#if defined(SOL_ON)
+# define p(f, m) if (udpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)udpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "recv");
+ sol_map_start(&sol_stream);
+ p(udps_ipackets, "total");
+ p(udps_hdrops, "with incomplete header");
+ p(udps_badlen, "with bad data length field");
+ p(udps_badsum, "with bad checksum");
+ p(udps_nosum, "with no checksum");
+ p(udps_noport, "dropped due to no socket");
+ p(udps_noportbcast, "broadcast/multicast undelivered");
+ p(udps_fullsock, "dropped due to full socket buffers");
+ p(udpps_pcbhashmiss, "not for hashed pcb");
+ sol_map_end(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "delivered");
+ sol_map_start(&sol_stream);
+ if (delivered || sflag <= 1) {
+ SOL_MAP_KEYL(&sol_stream, "total");
+ sol_integer(&sol_stream, (uintmax_t)delivered);
+ }
+ p(udps_opackets, "output");
+ /* the next statistic is cumulative in udps_noportbcast */
+ p(udps_filtermcast, "multicast source filter matched");
+ sol_map_end(&sol_stream);
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (udpstat.f || sflag <= 1) \
printf("\t%ju " m, (uintmax_t)udpstat.f, plural(udpstat.f))
@@ -960,13 +1191,6 @@
"broadcast/multicast datagram%s undelivered\n");
p1a(udps_fullsock, "dropped due to full socket buffers\n");
p1a(udpps_pcbhashmiss, "not for hashed pcb\n");
- delivered = udpstat.udps_ipackets -
- udpstat.udps_hdrops -
- udpstat.udps_badlen -
- udpstat.udps_badsum -
- udpstat.udps_noport -
- udpstat.udps_noportbcast -
- udpstat.udps_fullsock;
if (delivered || sflag <= 1)
printf("\t%ju delivered\n", (uint64_t)delivered);
p(udps_opackets, "datagram%s output\n");
@@ -1001,6 +1225,53 @@
kread_counters(off, &carpstat, len);
}
+#if defined(SOL_ON)
+# define p(f, m) if (carpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)carpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "recv");
+ sol_map_start(&sol_stream);
+ p(carps_ipackets, "IPv4");
+ p(carps_ipackets6, "IPv6");
+ sol_map_end(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "discarded");
+ sol_map_start(&sol_stream);
+ p(carps_badttl, "wrong TTL");
+ p(carps_hdrops, "shorter than header");
+ p(carps_badsum, "bad checksums");
+ p(carps_badver, "bad version");
+ p(carps_badlen, "too short");
+ p(carps_badauth, "bad authentication");
+ p(carps_badvhid, "bad vhid");
+ p(carps_badaddrs, "bad address list");
+ sol_map_end(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "sent");
+ sol_map_start(&sol_stream);
+ p(carps_opackets, "IPv4");
+ p(carps_opackets6, "IPv6");
+ sol_map_end(&sol_stream);
+
+ p(carps_onomem, "send failed due to mbuf memory error");
+# if notyet
+ SOL_MAP_KEYL(&sol_stream, "state updates sent");
+ sol_string(&sol_stream, carpstat.carps_ostates, strlen(carpstat.carps_ostates));
+# endif
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (carpstat.f || sflag <= 1) \
@@ -1048,6 +1319,53 @@
} else
kread_counters(off, &ipstat, len);
+#if defined(SOL_ON)
+# define p(f, m) if (ipstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)ipstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ p(ips_total, "total received");
+ p(ips_badsum, "bad header checksums");
+ p(ips_toosmall, "size smaller than minimum");
+ p(ips_tooshort, "data size < data length");
+ p(ips_toolong, "ip length > max ip packet size");
+ p(ips_badhlen, "header length < data size");
+ p(ips_badlen, "data length < header length");
+ p(ips_badoptions, "bad options");
+ p(ips_badvers, "incorrect version number");
+ p(ips_fragments, "fragments received");
+ p(ips_fragdropped, "fragments dropped (dup or out of space)");
+ p(ips_fragtimeout, "fragments dropped after timeout");
+ p(ips_reassembled, "reassembled ok");
+ p(ips_delivered, "for this host");
+ p(ips_noproto, "for unknown/unsupported protocol");
+ p(ips_forward, "forwarded");
+ p(ips_fastforward, "fast forwarded");
+ p(ips_cantforward, "not forwardable");
+ p(ips_notmember, "received for unknown multicast group");
+ p(ips_redirectsent, "redirects sent");
+ p(ips_localout, "sent from this host");
+ p(ips_rawout, "sent with fabricated ip header");
+ p(ips_odropped, "output packets dropped due to no bufs, etc.");
+ p(ips_noroute, "output packets discarded due to no route");
+ p(ips_fragmented, "output datagrams fragmented");
+ p(ips_ofragments, "fragments created");
+ p(ips_cantfrag, "datagrams that can't be fragmented");
+ p(ips_nogif, "tunneling packets that can't find gif");
+ p(ips_badaddr, "datagrams with bad address in header");
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (ipstat.f || sflag <= 1) \
@@ -1112,6 +1430,32 @@
} else
kread_counters(off, &arpstat, len);
+#if defined(SOL_ON)
+# define p(f, m) if (arpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)arpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ p(txrequests, "ARP requests sent");
+ p(txreplies, "ARP replies sent");
+ p(rxrequests, "ARP requests received");
+ p(rxreplies, "ARP replies received");
+ p(received, "ARP packets received");
+ p(dropped, "total packets dropped due to no ARP entry");
+ p(timeouts, "ARP entries timed out");
+ p(dupips, "Duplicate IPs seen");
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (arpstat.f || sflag <= 1) \
@@ -1199,6 +1543,86 @@
} else
kread_counters(off, &icmpstat, len);
+#if defined(SOL_ON)
+# define p(f, m) if (icmpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)icmpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ p(icps_error, "calls to icmp_error");
+ p(icps_oldicmp, "errors not generated in response to an icmp message");
+
+ for (first = 1, i = 0; i < ICMP_MAXTYPE + 1; i++)
+ if (icmpstat.icps_outhist[i] != 0) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "output histogram");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ sol_map_start(&sol_stream);
+ if (icmpnames[i] != NULL)
+ sol_map_key(&sol_stream, icmpnames[i], strlen(icmpnames[i]));
+ else {
+ SOL_MAP_KEYL(&sol_stream, "#");
+ sol_integer(&sol_stream, i);
+ SOL_MAP_KEYL(&sol_stream, "unknown ICMP");
+ }
+ sol_integer(&sol_stream, icmpstat.icps_outhist[i]);
+ sol_map_end(&sol_stream);
+ }
+ if (!first) sol_array_end(&sol_stream);
+
+ p(icps_badcode, "messages with bad code fields");
+ p(icps_tooshort, "messages less than the minimum length");
+ p(icps_checksum, "messages with bad checksum");
+ p(icps_badlen, "messages with bad length");
+ p(icps_bmcastecho, "multicast echo requests ignored");
+ p(icps_bmcasttstamp, "multicast timestamp requests ignored");
+
+ for (first = 1, i = 0; i < ICMP_MAXTYPE + 1; i++)
+ if (icmpstat.icps_inhist[i] != 0) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "input histogram");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ sol_map_start(&sol_stream);
+ if (icmpnames[i] != NULL)
+ sol_map_key(&sol_stream, icmpnames[i], strlen(icmpnames[i]));
+ else {
+ SOL_MAP_KEYL(&sol_stream, "#");
+ sol_integer(&sol_stream, i);
+ SOL_MAP_KEYL(&sol_stream, "unknown ICMP");
+ }
+ sol_integer(&sol_stream, icmpstat.icps_inhist[i]);
+ sol_map_end(&sol_stream);
+ }
+ if (!first) sol_array_end(&sol_stream);
+
+ p(icps_reflect, "message responses generated");
+ p(icps_badaddr, "invalid return addresses");
+ p(icps_noroute, "no return routes");
+
+ if (live) {
+ len = sizeof i;
+ if (sysctlbyname("net.inet.icmp.maskrepl", &i, &len, NULL, 0) <
+ 0)
+ return;
+ SOL_MAP_KEYL(&sol_stream, "ICMP address mask responses enabled");
+ sol_boolean(&sol_stream, i);
+ }
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (icmpstat.f || sflag <= 1) \
@@ -1277,6 +1701,42 @@
return;
}
+#if defined(SOL_ON)
+# define p(f, m) if (oigmpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, oigmpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "messages received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_total, "total");
+ p(igps_rcv_tooshort, "too few bytes");
+ p(igps_rcv_badsum, "bad checksum");
+ sol_map_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "membership queries received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_queries, "total");
+ p(igps_rcv_badqueries, "invalid fields");
+ sol_map_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "membership reports received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_reports, "total");
+ p(igps_rcv_badreports, "invalid fields");
+ p(igps_rcv_ourreports, "for groups to which we belong");
+ sol_map_end(&sol_stream);
+ p(igps_snd_reports, "membership reports sent");
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (oigmpstat.f || sflag <= 1) \
@@ -1353,6 +1813,49 @@
igmpstat.igps_len, IGPS_VERSION3_LEN);
}
+#if defined(SOL_ON)
+# define p(f, m) if (igmpstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)igmpstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "messages received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_total, "total");
+ p(igps_rcv_tooshort, "too few bytes");
+ p(igps_rcv_badttl, "wrong TTL");
+ p(igps_rcv_badsum, "bad checksum");
+ sol_map_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "membership queries received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_v1v2_queries, "V1/V2");
+ p(igps_rcv_v3_queries, "V3");
+ p(igps_rcv_badqueries, "invalid fields");
+ sol_map_end(&sol_stream);
+ p(igps_rcv_gen_queries, "general queries received");
+ p(igps_rcv_group_queries, "group queries received");
+ p(igps_rcv_gsr_queries, "group-source queries received");
+ p(igps_drop_gsr_queries, "group-source queries dropped");
+ SOL_MAP_KEYL(&sol_stream, "membership reports received");
+ sol_map_start(&sol_stream);
+ p(igps_rcv_reports, "total");
+ p(igps_rcv_badreports, "invalid fields");
+ p(igps_rcv_ourreports, "for groups to which we belong");
+ sol_map_end(&sol_stream);
+ p(igps_rcv_nora, "V3 reports received without Router Alert");
+ p(igps_snd_reports, "membership reports sent");
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p64(f, m) if (igmpstat.f || sflag <= 1) \
@@ -1407,6 +1910,41 @@
kread_counters(off, &pimstat, len);
}
+#if defined(SOL_ON)
+# define p(f, m) if (pimstat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)pimstat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "recv");
+ sol_map_start(&sol_stream);
+ p(pims_rcv_total_msgs, "messages");
+ p(pims_rcv_total_bytes, "bytes");
+ p(pims_rcv_tooshort, "messages with too few bytes");
+ p(pims_rcv_badsum, "messages with bad checksum");
+ p(pims_rcv_badversion, "messages with bad version");
+ p(pims_rcv_registers_msgs, "data register messages");
+ p(pims_rcv_registers_bytes, "data register bytes");
+ p(pims_rcv_registers_wrongiif, "data register messages on wrong iif");
+ p(pims_rcv_badregisters, "bad registers");
+ sol_map_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "send");
+ sol_map_start(&sol_stream);
+ p(pims_snd_registers_msgs, "data register messages");
+ p(pims_snd_registers_bytes, "data register bytes");
+ sol_map_end(&sol_stream);
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (pimstat.f || sflag <= 1) \
@@ -1451,10 +1989,17 @@
else
sprintf(cp, "%d ", ntohs((u_short)port));
width = (Aflag && !Wflag) ? 18 : 22;
- if (Wflag)
- printf("%-*s ", width, line);
+#if defined(SOL_ON)
+ if (Oflag)
+ sol_string(&sol_stream, line, strlen(line));
else
- printf("%-*.*s ", width, width, line);
+#endif
+ {
+ if (Wflag)
+ printf("%-*s ", width, line);
+ else
+ printf("%-*.*s ", width, width, line);
+ }
}
/*
Modified: soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet6.c
==============================================================================
--- soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet6.c Wed Jun 18 13:41:20 2014 (r269722)
+++ soc2014/zkorchev/freebsd_head/usr.bin/netstat/inet6.c Wed Jun 18 16:03:58 2014 (r269723)
@@ -68,8 +68,16 @@
#include <errno.h>
#include <string.h>
#include <unistd.h>
+#include <sol.h>
#include "netstat.h"
+/*
+ * Upward approximation of the maximum number of characters needed to
+ * represent a value of integral type t as a string, excluding the
+ * NUL terminator.
+ */
+#define STRBUF_SIZEOF(t) (CHAR_BIT * sizeof(t) / 3 + 1)
+
struct socket sockb;
char *inet6name(struct in6_addr *);
@@ -378,6 +386,188 @@
} else
kread_counters(off, &ip6stat, len);
+#if defined(SOL_ON)
+# define p(f, m) if (ip6stat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.f); \
+ } while (0)
+
+ if (Oflag) {
+ char key[STRBUF_SIZEOF(uintmax_t) + 1];
+ size_t len;
+
+ sol_map_key(&sol_stream, name, strlen(name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "packets received");
+ sol_map_start(&sol_stream);
+ p(ip6s_total, "total");
+ p(ip6s_toosmall, "smaller than minimum");
+ p(ip6s_tooshort, "data size < data length");
+ p(ip6s_badoptions, "bad options");
+ p(ip6s_badvers, "incorrect version number");
+ sol_map_end(&sol_stream);
+ p(ip6s_fragments, "fragments received");
+ p(ip6s_fragdropped, "fragments dropped (dup or out of space)");
+ p(ip6s_fragtimeout, "fragments dropped after timeout");
+ p(ip6s_fragoverflow, "fragments that exceeded limit");
+ p(ip6s_reassembled, "packets reassembled ok");
+ p(ip6s_delivered, "packets for this host");
+ p(ip6s_forward, "packets forwarded");
+ p(ip6s_cantforward, "packets not forwardable");
+ p(ip6s_redirectsent, "redirects sent");
+ p(ip6s_localout, "packets sent from this host");
+ p(ip6s_rawout, "packets sent with fabricated ip header");
+ p(ip6s_odropped, "output packets dropped due to no bufs, etc.");
+ p(ip6s_noroute, "output packets discarded due to no route");
+ p(ip6s_fragmented, "output datagrams fragmented");
+ p(ip6s_ofragments, "fragments created");
+ p(ip6s_cantfrag, "datagrams that can't be fragmented");
+ p(ip6s_badscope, "packets that violated scope rules");
+ p(ip6s_notmember, "multicast packets which we don't join");
+
+ for (first = 1, i = 0; i < IP6S_HDRCNT; i++)
+ if (ip6stat.ip6s_nxthist[i] != 0) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "input histogram");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ sol_map_key(&sol_stream, ip6nh[i], strlen(ip6nh[i]));
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.ip6s_nxthist[i]);
+ }
+ if (!first) sol_array_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "mbuf");
+ sol_map_start(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "one");
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.ip6s_m1);
+ for (first = 1, i = 0; i < IP6S_M2MMAX; i++) {
+ char ifbuf[IFNAMSIZ];
+ const char *key;
+ if (ip6stat.ip6s_m2m[i] != 0) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "two or more");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ key = if_indextoname(i, ifbuf);
+ sol_map_key(&sol_stream, key, strlen(key));
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.ip6s_m2m[i]);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+ SOL_MAP_KEYL(&sol_stream, "one ext");
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.ip6s_mext1);
+ SOL_MAP_KEYL(&sol_stream, "two or more ext");
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.ip6s_mext2m);
+ sol_map_end(&sol_stream);
+ p(ip6s_exthdrtoolong, "packets whose headers are not contiguous");
+ p(ip6s_nogif, "tunneling packets that can't find gif");
+ p(ip6s_toomanyhdr, "packets discarded because of too many headers");
+
+ /* for debugging source address selection */
+#define PRINT_SCOPESTAT(s,i) do {\
+ sol_map_start(&sol_stream);\
+ switch(i) { /* XXX hardcoding in each case */\
+ case 1:\
+ p(s, "interface-local");\
+ break;\
+ case 2:\
+ p(s, "link-local");\
+ break;\
+ case 5:\
+ p(s, "site-local");\
+ break;\
+ case 14:\
+ p(s, "global");\
+ break;\
+ default:\
+ SOL_MAP_KEYL(&sol_stream, "other");\
+ sol_integer(&sol_stream, (uintmax_t)ip6stat.s);\
+ SOL_MAP_KEYL(&sol_stream, "addresses scope");\
+ sol_integer(&sol_stream, i); /* TODO hex? */\
+ }\
+ sol_map_end(&sol_stream);\
+ } while (0)
+
+ p(ip6s_sources_none, "failures of source address selection");
+ for (first = 1, i = 0; i < IP6S_SCOPECNT; i++) {
+ if (ip6stat.ip6s_sources_sameif[i]) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "source addresses on an outgoing I/F");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ PRINT_SCOPESTAT(ip6s_sources_sameif[i], i);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+ for (first = 1, i = 0; i < IP6S_SCOPECNT; i++) {
+ if (ip6stat.ip6s_sources_otherif[i]) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "source addresses on a non-outgoing I/F");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ PRINT_SCOPESTAT(ip6s_sources_otherif[i], i);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+ for (first = 1, i = 0; i < IP6S_SCOPECNT; i++) {
+ if (ip6stat.ip6s_sources_samescope[i]) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "source addresses of same scope");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ PRINT_SCOPESTAT(ip6s_sources_samescope[i], i);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+ for (first = 1, i = 0; i < IP6S_SCOPECNT; i++) {
+ if (ip6stat.ip6s_sources_otherscope[i]) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "source addresses of a different scope");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ PRINT_SCOPESTAT(ip6s_sources_otherscope[i], i);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+ for (first = 1, i = 0; i < IP6S_SCOPECNT; i++) {
+ if (ip6stat.ip6s_sources_deprecated[i]) {
+ if (first) {
+ SOL_MAP_KEYL(&sol_stream, "deprecated source addresses");
+ sol_array_start(&sol_stream);
+ first = 0;
+ }
+ PRINT_SCOPESTAT(ip6s_sources_deprecated[i], i);
+ }
+ }
+ if (!first) sol_array_end(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "source addresses selection rule applied");
+ sol_array_start(&sol_stream);
+ for (i = 0; i < IP6S_RULESMAX; i++) {
+ if (ip6stat.ip6s_sources_rule[i]) {
+ sol_map_start(&sol_stream);
+ len = snprintf(key, sizeof(key), "%ju", (uintmax_t)ip6stat.ip6s_sources_rule[i]);
+ sol_map_key(&sol_stream, key, len);
+ sol_string(&sol_stream, srcrule_str[i], strlen(srcrule_str[i]));
+ sol_map_end(&sol_stream);
+ }
+ }
+ sol_array_end(&sol_stream);
+
+ sol_map_end(&sol_stream);
+ return;
+ }
+
+# undef PRINT_SCOPESTAT
+# undef p
+#endif
+
printf("%s:\n", name);
#define p(f, m) if (ip6stat.f || sflag <= 1) \
@@ -460,7 +650,7 @@
printf("\t\t%ju addresses scope=%x\n",\
(uintmax_t)ip6stat.s, i);\
}\
- } while (0);
+ } while (0)
p(ip6s_sources_none,
"\t%ju failure%s of source address selection\n");
@@ -529,10 +719,6 @@
{
struct in6_ifreq ifr;
int s;
-#define p(f, m) if (ifr.ifr_ifru.ifru_stat.f || sflag <= 1) \
- printf(m, (uintmax_t)ifr.ifr_ifru.ifru_stat.f, plural(ifr.ifr_ifru.ifru_stat.f))
-#define p_5(f, m) if (ifr.ifr_ifru.ifru_stat.f || sflag <= 1) \
- printf(m, (uintmax_t)ip6stat.f)
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
perror("Warning: socket(AF_INET6)");
@@ -540,13 +726,64 @@
}
strcpy(ifr.ifr_name, ifname);
- printf("ip6 on %s:\n", ifr.ifr_name);
-
if (ioctl(s, SIOCGIFSTAT_IN6, (char *)&ifr) < 0) {
perror("Warning: ioctl(SIOCGIFSTAT_IN6)");
goto end;
}
+#if defined(SOL_ON)
+# define p(f, m) if (ifr.ifr_ifru.ifru_stat.f || sflag <= 1) do { \
+ SOL_MAP_KEYL(&sol_stream, m); \
+ sol_integer(&sol_stream, (uintmax_t)ifr.ifr_ifru.ifru_stat.f); \
+ } while (0)
+
+ if (Oflag) {
+ sol_map_key(&sol_stream, ifr.ifr_name, strlen(ifr.ifr_name));
+ sol_map_start(&sol_stream);
+
+ SOL_MAP_KEYL(&sol_stream, "input datagrams");
+ sol_map_start(&sol_stream);
+ p(ifs6_in_receive, "total");
+ p(ifs6_in_hdrerr, "invalid header");
+ p(ifs6_in_toobig, "exceeded MTU");
+ p(ifs6_in_noroute, "no route");
+ p(ifs6_in_addrerr, "invalid dst");
+ p(ifs6_in_protounknown, "unknown proto");
+ p(ifs6_in_truncated, "truncated");
*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
More information about the svn-soc-all
mailing list