Date: Wed, 18 Jun 2014 16:03:58 GMT From: zkorchev@FreeBSD.org To: svn-soc-all@FreeBSD.org Subject: socsvn commit: r269723 - soc2014/zkorchev/freebsd_head/usr.bin/netstat Message-ID: <201406181603.s5IG3w3Y029387@socsvn.freebsd.org>
next in thread | raw e-mail | index | archive | help
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 ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201406181603.s5IG3w3Y029387>