usr.bin/netstat/inet.c

   1 /*
   2  * Copyright (c) 1983, 1988, 1993, 1995
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#)inet.c   8.5 (Berkeley) 5/24/95
  34  * $FreeBSD: src/usr.bin/netstat/inet.c,v 1.37.2.11 2003/11/27 14:46:49 ru Exp $
  35  * $DragonFly: src/usr.bin/netstat/inet.c,v 1.21 2007/12/29 22:15:06 hasso Exp $
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/queue.h>
  40 #include <sys/socket.h>
  41 #include <sys/socketvar.h>
  42 #include <sys/sysctl.h>
  43 #include <sys/protosw.h>
  44 #include <sys/time.h>
  45
  46 #include <net/route.h>
  47 #include <netinet/in.h>
  48 #include <netinet/in_systm.h>
  49 #include <netinet/ip.h>
  50 #include <netinet/ip_carp.h>
  51 #ifdef INET6
  52 #include <netinet/ip6.h>
  53 #endif /* INET6 */
  54 #include <netinet/in_pcb.h>
  55 #include <netinet/ip_icmp.h>
  56 #include <netinet/icmp_var.h>
  57 #include <netinet/igmp_var.h>
  58 #include <netinet/ip_var.h>
  59 #include <netinet/pim_var.h>
  60 #include <netinet/tcp.h>
  61 #include <netinet/tcpip.h>
  62 #include <netinet/tcp_seq.h>
  63 #define TCPSTATES
  64 #include <netinet/tcp_fsm.h>
  65 #include <netinet/tcp_timer.h>
  66 #include <netinet/tcp_var.h>
  67 #include <netinet/tcp_debug.h>
  68 #include <netinet/udp.h>
  69 #include <netinet/udp_var.h>
  70
  71 #include <arpa/inet.h>
  72 #include <err.h>
  73 #include <errno.h>
  74 #include <libutil.h>
  75 #include <netdb.h>
  76 #include <stdio.h>
  77 #include <stdlib.h>
  78 #include <string.h>
  79 #include <unistd.h>
  80 #include "netstat.h"
  81
  82 char    *inetname (struct in_addr *);
  83 void    inetprint (struct in_addr *, int, const char *, int);
  84 #ifdef INET6
  85 extern void     inet6print (struct in6_addr *, int, const char *, int);
  86 static int udp_done, tcp_done;
  87 #endif /* INET6 */
  88
  89 /*
  90  * Print a summary of connections related to an Internet
  91  * protocol.  For TCP, also give state of connection.
  92  * Listening processes (aflag) are suppressed unless the
  93  * -a (all) flag is specified.
  94  */
  95
  96 static int ppr_first = 1;
  97 static void outputpcb(int proto, const char *name, struct inpcb *inp, struct xsocket *so, struct tcpcb *tp);
  98
  99 void
 100 protopr(u_long proto, const char *name, int af1 __unused)
 101 {
 102         int istcp;
 103         void *buf;
 104         const char *mibvar;
 105         size_t i, len;
 106
 107         istcp = 0;
 108         switch (proto) {
 109         case IPPROTO_TCP:
 110 #ifdef INET6
 111                 if (tcp_done != 0)
 112                         return;
 113                 else
 114                         tcp_done = 1;
 115 #endif
 116                 istcp = 1;
 117                 mibvar = "net.inet.tcp.pcblist";
 118                 break;
 119         case IPPROTO_UDP:
 120 #ifdef INET6
 121                 if (udp_done != 0)
 122                         return;
 123                 else
 124                         udp_done = 1;
 125 #endif
 126                 mibvar = "net.inet.udp.pcblist";
 127                 break;
 128         case IPPROTO_DIVERT:
 129                 mibvar = "net.inet.divert.pcblist";
 130                 break;
 131         default:
 132                 mibvar = "net.inet.raw.pcblist";
 133                 break;
 134         }
 135         len = 0;
 136         if (sysctlbyname(mibvar, 0, &len, 0, 0) < 0) {
 137                 if (errno != ENOENT)
 138                         warn("sysctl: %s", mibvar);
 139                 return;
 140         }
 141         if (len == 0)
 142                 return;
 143         if ((buf = malloc(len)) == 0) {
 144                 warn("malloc %lu bytes", (u_long)len);
 145                 return;
 146         }
 147         if (sysctlbyname(mibvar, buf, &len, 0, 0) < 0) {
 148                 warn("sysctl: %s", mibvar);
 149                 free(buf);
 150                 return;
 151         }
 152
 153         if (istcp) {
 154                 struct xtcpcb *tcp = buf;
 155                 len /= sizeof(*tcp);
 156                 for (i = 0; i < len; i++) {
 157                         if (tcp[i].xt_len != sizeof(*tcp))
 158                                 break;
 159                         outputpcb(proto, name, &tcp[i].xt_inp,
 160                                   &tcp[i].xt_socket, &tcp[i].xt_tp);
 161                 }
 162         } else {
 163                 struct xinpcb *in = buf;
 164                 len /= sizeof(*in);
 165                 for (i = 0; i < len; i++) {
 166                         if (in[i].xi_len != sizeof(*in))
 167                                 break;
 168                         outputpcb(proto, name, &in[i].xi_inp,
 169                                   &in[i].xi_socket, NULL);
 170                 }
 171         }
 172         free(buf);
 173 }
 174
 175 static void
 176 outputpcb(int proto, const char *name, struct inpcb *inp, struct xsocket *so, struct tcpcb *tp)
 177 {
 178         const char *vchar;
 179         static struct clockinfo clockinfo;
 180
 181         if (clockinfo.hz == 0) {
 182                 size_t size = sizeof(clockinfo);
 183                 sysctlbyname("kern.clockrate", &clockinfo, &size, NULL, 0);
 184                 if (clockinfo.hz == 0)
 185                         clockinfo.hz = 100;
 186         }
 187
 188         /* Ignore sockets for protocols other than the desired one. */
 189         if (so->xso_protocol != (int)proto)
 190                 return;
 191
 192         if ((af == AF_INET && (inp->inp_vflag & INP_IPV4) == 0)
 193 #ifdef INET6
 194             || (af == AF_INET6 && (inp->inp_vflag & INP_IPV6) == 0)
 195 #endif /* INET6 */
 196             || (af == AF_UNSPEC && ((inp->inp_vflag & INP_IPV4) == 0
 197 #ifdef INET6
 198                 && (inp->inp_vflag & INP_IPV6) == 0
 199 #endif /* INET6 */
 200                 ))
 201             ) {
 202                 return;
 203         }
 204         if (!aflag && (
 205                 (proto == IPPROTO_TCP && tp->t_state == TCPS_LISTEN) ||
 206                 (af == AF_INET && inet_lnaof(inp->inp_laddr) == INADDR_ANY)
 207 #ifdef INET6
 208             || (af == AF_INET6 && IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
 209 #endif /* INET6 */
 210             || (af == AF_UNSPEC && (((inp->inp_vflag & INP_IPV4) != 0 &&
 211                 inet_lnaof(inp->inp_laddr) == INADDR_ANY)
 212 #ifdef INET6
 213             || ((inp->inp_vflag & INP_IPV6) != 0 &&
 214                 IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr))
 215 #endif
 216                   ))
 217              )) {
 218                 return;
 219         }
 220
 221         if (ppr_first) {
 222                 if (!Lflag) {
 223                         printf("Active Internet connections");
 224                         if (aflag)
 225                                 printf(" (including servers)");
 226                 } else {
 227                         printf("Current listen queue sizes "
 228                                 "(qlen/incqlen/maxqlen)");
 229                 }
 230                 putchar('\n');
 231                 if (Aflag)
 232                         printf("%-8.8s ", "Socket");
 233                 if (Pflag)
 234                         printf("%8.8s %8.8s %8.8s ", "TxWin", "Unacked", "RTT/ms");
 235                 if (Lflag) {
 236                         printf("%-5.5s %-14.14s %-22.22s\n",
 237                                 "Proto", "Listen", "Local Address");
 238                 } else {
 239                         printf((Aflag && !Wflag) ?
 240                             "%-5.5s %-6.6s %-6.6s %-17.17s %-17.17s %s\n" :
 241                             "%-5.5s %-6.6s %-6.6s %-21.21s %-21.21s %s\n",
 242                             "Proto", "Recv-Q", "Send-Q",
 243                             "Local Address", "Foreign Address",
 244                             "(state)");
 245                 }
 246                 ppr_first = 0;
 247         }
 248         if (Lflag && so->so_qlimit == 0)
 249                 return;
 250         if (Aflag) {
 251                 if (tp)
 252                         printf("%8lx ", (u_long)inp->inp_ppcb);
 253                 else
 254                         printf("%8lx ", (u_long)so->so_pcb);
 255         }
 256         if (Pflag) {
 257                 if (tp) {
 258                         int window = MIN(tp->snd_cwnd, tp->snd_bwnd);
 259                         if (window == 1073725440)
 260                                 printf("%8s ", "max");
 261                         else
 262                                 printf("%8d ", (int)MIN(tp->snd_cwnd, tp->snd_bwnd));
 263                         printf("%8d ", (int)(tp->snd_max - tp->snd_una));
 264                         if (tp->t_srtt == 0)
 265                             printf("%8s ", "-");
 266                         else
 267                             printf("%8.3f ", (double)tp->t_srtt * 1000.0 / TCP_RTT_SCALE / clockinfo.hz);
 268                 } else {
 269                         printf("%8s %8s %8s ", "-", "-", "-");
 270                 }
 271         }
 272 #ifdef INET6
 273         if ((inp->inp_vflag & INP_IPV6) != 0)
 274                 vchar = ((inp->inp_vflag & INP_IPV4) != 0) ? "46" : "6 ";
 275         else
 276 #endif
 277                 vchar = ((inp->inp_vflag & INP_IPV4) != 0) ? "4 " : "  ";
 278
 279         printf("%-3.3s%-2.2s ", name, vchar);
 280         if (Lflag) {
 281                 char buf[15];
 282
 283                 snprintf(buf, sizeof(buf), "%d/%d/%d", so->so_qlen,
 284                          so->so_incqlen, so->so_qlimit);
 285                 printf("%-13.13s ", buf);
 286         } else if (Bflag) {
 287                 printf("%6ld %6ld ",
 288                        so->so_rcv.sb_hiwat,
 289                        so->so_snd.sb_hiwat);
 290         } else {
 291                 printf("%6ld %6ld ",
 292                        so->so_rcv.sb_cc,
 293                        so->so_snd.sb_cc);
 294         }
 295         if (numeric_port) {
 296                 if (inp->inp_vflag & INP_IPV4) {
 297                         inetprint(&inp->inp_laddr, (int)inp->inp_lport,
 298                                   name, 1);
 299                         if (!Lflag)
 300                                 inetprint(&inp->inp_faddr,
 301                                           (int)inp->inp_fport, name, 1);
 302                 }
 303 #ifdef INET6
 304                 else if (inp->inp_vflag & INP_IPV6) {
 305                         inet6print(&inp->in6p_laddr,
 306                                    (int)inp->inp_lport, name, 1);
 307                         if (!Lflag)
 308                                 inet6print(&inp->in6p_faddr,
 309                                            (int)inp->inp_fport, name, 1);
 310                 } /* else nothing printed now */
 311 #endif /* INET6 */
 312         } else if (inp->inp_flags & INP_ANONPORT) {
 313                 if (inp->inp_vflag & INP_IPV4) {
 314                         inetprint(&inp->inp_laddr, (int)inp->inp_lport,
 315                                   name, 1);
 316                         if (!Lflag)
 317                                 inetprint(&inp->inp_faddr,
 318                                           (int)inp->inp_fport, name, 0);
 319                 }
 320 #ifdef INET6
 321                 else if (inp->inp_vflag & INP_IPV6) {
 322                         inet6print(&inp->in6p_laddr,
 323                                    (int)inp->inp_lport, name, 1);
 324                         if (!Lflag)
 325                                 inet6print(&inp->in6p_faddr,
 326                                            (int)inp->inp_fport, name, 0);
 327                 } /* else nothing printed now */
 328 #endif /* INET6 */
 329         } else {
 330                 if (inp->inp_vflag & INP_IPV4) {
 331                         inetprint(&inp->inp_laddr, (int)inp->inp_lport,
 332                                   name, 0);
 333                         if (!Lflag)
 334                                 inetprint(&inp->inp_faddr,
 335                                           (int)inp->inp_fport, name,
 336                                           inp->inp_lport !=
 337                                                 inp->inp_fport);
 338                 }
 339 #ifdef INET6
 340                 else if (inp->inp_vflag & INP_IPV6) {
 341                         inet6print(&inp->in6p_laddr,
 342                                    (int)inp->inp_lport, name, 0);
 343                         if (!Lflag)
 344                                 inet6print(&inp->in6p_faddr,
 345                                            (int)inp->inp_fport, name,
 346                                            inp->inp_lport !=
 347                                                 inp->inp_fport);
 348                 } /* else nothing printed now */
 349 #endif /* INET6 */
 350         }
 351         if (tp && !Lflag) {
 352                 if (tp->t_state < 0 || tp->t_state >= TCP_NSTATES)
 353                         printf("%d", tp->t_state);
 354               else {
 355                         printf("%s", tcpstates[tp->t_state]);
 356 #if defined(TF_NEEDSYN) && defined(TF_NEEDFIN)
 357                       /* Show T/TCP `hidden state' */
 358                       if (tp->t_flags & (TF_NEEDSYN|TF_NEEDFIN))
 359                               putchar('*');
 360 #endif /* defined(TF_NEEDSYN) && defined(TF_NEEDFIN) */
 361               }
 362         }
 363         putchar('\n');
 364 }
 365
 366
 367
 368 #define CPU_STATS_FUNC(proto,type)                            \
 369 static void                                                   \
 370 proto ##_stats_agg(type *ary, type *ttl, int cpucnt)          \
 371 {                                                             \
 372     int i, off, siz;                                          \
 373     siz = sizeof(type);                                       \
 374                                                               \
 375     if (!ary && !ttl)                                         \
 376         return;                                               \
 377                                                               \
 378     bzero(ttl, siz);                                          \
 379     if (cpucnt == 1) {                                        \
 380         *ttl = ary[0];                                        \
 381     } else {                                                  \
 382         for (i = 0; i < cpucnt; ++i) {                        \
 383             for (off = 0; off < siz; off += sizeof(u_long)) { \
 384                 *(u_long *)((char *)(*(&ttl)) + off) +=       \
 385                 *(u_long *)((char *)&ary[i] + off);           \
 386             }                                                 \
 387         }                                                     \
 388     }                                                         \
 389 }
 390 CPU_STATS_FUNC(tcp, struct tcp_stats);
 391 CPU_STATS_FUNC(ip, struct ip_stats);
 392
 393 /*
 394  * Dump TCP statistics structure.
 395  */
 396 void
 397 tcp_stats(u_long off __unused, const char *name, int af1 __unused)
 398 {
 399         struct tcp_stats tcpstat, *stattmp;
 400         struct tcp_stats zerostat[SMP_MAXCPU];
 401         size_t len = sizeof(struct tcp_stats) * SMP_MAXCPU;
 402         int cpucnt;
 403
 404         if (zflag)
 405                 memset(zerostat, 0, len);
 406
 407         if ((stattmp = malloc(len)) == NULL) {
 408                 return;
 409         } else {
 410                 if (sysctlbyname("net.inet.tcp.stats", stattmp, &len,
 411                         zflag ? zerostat : NULL, zflag ? len : 0) < 0) {
 412                         warn("sysctl: net.inet.tcp.stats");
 413                         free(stattmp);
 414                         return;
 415                 } else {
 416                         if ((stattmp = realloc(stattmp, len)) == NULL) {
 417                                 warn("tcp_stats");
 418                                 return;
 419                         }
 420                 }
 421         }
 422         cpucnt = len / sizeof(struct tcp_stats);
 423         tcp_stats_agg(stattmp, &tcpstat, cpucnt);
 424
 425 #ifdef INET6
 426         if (tcp_done != 0)
 427                 return;
 428         else
 429                 tcp_done = 1;
 430 #endif
 431
 432         printf ("%s:\n", name);
 433
 434 #define p(f, m) if (tcpstat.f || sflag <= 1) \
 435     printf(m, tcpstat.f, plural(tcpstat.f))
 436 #define p1a(f, m) if (tcpstat.f || sflag <= 1) \
 437     printf(m, tcpstat.f)
 438 #define p2(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
 439     printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2, plural(tcpstat.f2))
 440 #define p2a(f1, f2, m) if (tcpstat.f1 || tcpstat.f2 || sflag <= 1) \
 441     printf(m, tcpstat.f1, plural(tcpstat.f1), tcpstat.f2)
 442 #define p3(f, m) if (tcpstat.f || sflag <= 1) \
 443     printf(m, tcpstat.f, plurales(tcpstat.f))
 444
 445         p(tcps_sndtotal, "\t%lu packet%s sent\n");
 446         p2(tcps_sndpack,tcps_sndbyte,
 447                 "\t\t%lu data packet%s (%lu byte%s)\n");
 448         p2(tcps_sndrexmitpack, tcps_sndrexmitbyte,
 449                 "\t\t%lu data packet%s (%lu byte%s) retransmitted\n");
 450         p2a(tcps_sndfastrexmit, tcps_sndearlyrexmit,
 451                 "\t\t%lu Fast Retransmit%s (%lu early)\n");
 452         p(tcps_sndlimited, "\t\t%lu packet%s sent by Limited Transmit\n");
 453         p(tcps_sndrtobad, "\t\t%lu spurious RTO retransmit%s\n");
 454         p2a(tcps_sndfastrexmitbad, tcps_sndearlyrexmitbad,
 455                 "\t\t%lu spurious Fast Retransmit%s (%lu early)\n");
 456         p(tcps_eifeldetected, "\t\t%lu Eifel-detected spurious retransmit%s\n");
 457         p(tcps_rttdetected, "\t\t%lu RTT-detected spurious retransmit%s\n");
 458         p(tcps_mturesent, "\t\t%lu resend%s initiated by MTU discovery\n");
 459         p2a(tcps_sndacks, tcps_delack,
 460                 "\t\t%lu ack-only packet%s (%lu delayed)\n");
 461         p(tcps_sndurg, "\t\t%lu URG only packet%s\n");
 462         p(tcps_sndprobe, "\t\t%lu window probe packet%s\n");
 463         p(tcps_sndwinup, "\t\t%lu window update packet%s\n");
 464         p(tcps_sndctrl, "\t\t%lu control packet%s\n");
 465         p(tcps_rcvtotal, "\t%lu packet%s received\n");
 466         p2(tcps_rcvackpack, tcps_rcvackbyte, "\t\t%lu ack%s (for %lu byte%s)\n");
 467         p(tcps_rcvdupack, "\t\t%lu duplicate ack%s\n");
 468         p(tcps_rcvacktoomuch, "\t\t%lu ack%s for unsent data\n");
 469         p2(tcps_rcvpack, tcps_rcvbyte,
 470                 "\t\t%lu packet%s (%lu byte%s) received in-sequence\n");
 471         p2(tcps_rcvduppack, tcps_rcvdupbyte,
 472                 "\t\t%lu completely duplicate packet%s (%lu byte%s)\n");
 473         p(tcps_pawsdrop, "\t\t%lu old duplicate packet%s\n");
 474         p2(tcps_rcvpartduppack, tcps_rcvpartdupbyte,
 475                 "\t\t%lu packet%s with some dup. data (%lu byte%s duped)\n");
 476         p2(tcps_rcvoopack, tcps_rcvoobyte,
 477                 "\t\t%lu out-of-order packet%s (%lu byte%s)\n");
 478         p2(tcps_rcvpackafterwin, tcps_rcvbyteafterwin,
 479                 "\t\t%lu packet%s (%lu byte%s) of data after window\n");
 480         p(tcps_rcvwinprobe, "\t\t%lu window probe%s\n");
 481         p(tcps_rcvwinupd, "\t\t%lu window update packet%s\n");
 482         p(tcps_rcvafterclose, "\t\t%lu packet%s received after close\n");
 483         p(tcps_rcvbadsum, "\t\t%lu discarded for bad checksum%s\n");
 484         p(tcps_rcvbadoff, "\t\t%lu discarded for bad header offset field%s\n");
 485         p1a(tcps_rcvshort, "\t\t%lu discarded because packet too short\n");
 486         p(tcps_connattempt, "\t%lu connection request%s\n");
 487         p(tcps_accepts, "\t%lu connection accept%s\n");
 488         p(tcps_badsyn, "\t%lu bad connection attempt%s\n");
 489         p(tcps_listendrop, "\t%lu listen queue overflow%s\n");
 490         p(tcps_connects, "\t%lu connection%s established (including accepts)\n");
 491         p2(tcps_closed, tcps_drops,
 492                 "\t%lu connection%s closed (including %lu drop%s)\n");
 493         p(tcps_cachedrtt, "\t\t%lu connection%s updated cached RTT on close\n");
 494         p(tcps_cachedrttvar,
 495           "\t\t%lu connection%s updated cached RTT variance on close\n");
 496         p(tcps_cachedssthresh,
 497           "\t\t%lu connection%s updated cached ssthresh on close\n");
 498         p(tcps_conndrops, "\t%lu embryonic connection%s dropped\n");
 499         p2(tcps_rttupdated, tcps_segstimed,
 500                 "\t%lu segment%s updated rtt (of %lu attempt%s)\n");
 501         p(tcps_rexmttimeo, "\t%lu retransmit timeout%s\n");
 502         p(tcps_timeoutdrop, "\t\t%lu connection%s dropped by rexmit timeout\n");
 503         p(tcps_persisttimeo, "\t%lu persist timeout%s\n");
 504         p(tcps_persistdrop, "\t\t%lu connection%s dropped by persist timeout\n");
 505         p(tcps_keeptimeo, "\t%lu keepalive timeout%s\n");
 506         p(tcps_keepprobe, "\t\t%lu keepalive probe%s sent\n");
 507         p(tcps_keepdrops, "\t\t%lu connection%s dropped by keepalive\n");
 508         p(tcps_predack, "\t%lu correct ACK header prediction%s\n");
 509         p(tcps_preddat, "\t%lu correct data packet header prediction%s\n");
 510
 511         p1a(tcps_sc_added, "\t%lu syncache entries added\n");
 512         p1a(tcps_sc_retransmitted, "\t\t%lu retransmitted\n");
 513         p1a(tcps_sc_dupsyn, "\t\t%lu dupsyn\n");
 514         p1a(tcps_sc_dropped, "\t\t%lu dropped\n");
 515         p1a(tcps_sc_completed, "\t\t%lu completed\n");
 516         p1a(tcps_sc_bucketoverflow, "\t\t%lu bucket overflow\n");
 517         p1a(tcps_sc_cacheoverflow, "\t\t%lu cache overflow\n");
 518         p1a(tcps_sc_reset, "\t\t%lu reset\n");
 519         p1a(tcps_sc_stale, "\t\t%lu stale\n");
 520         p1a(tcps_sc_aborted, "\t\t%lu aborted\n");
 521         p1a(tcps_sc_badack, "\t\t%lu badack\n");
 522         p1a(tcps_sc_unreach, "\t\t%lu unreach\n");
 523         p1a(tcps_sc_zonefail, "\t\t%lu zone failures\n");
 524         p1a(tcps_sc_sendcookie, "\t%lu cookies sent\n");
 525         p1a(tcps_sc_recvcookie, "\t%lu cookies received\n");
 526         free(stattmp);
 527 #undef p
 528 #undef p1a
 529 #undef p2
 530 #undef p2a
 531 #undef p3
 532 }
 533
 534 /*
 535  * Dump UDP statistics structure.
 536  */
 537 void
 538 udp_stats(u_long off __unused, const char *name, int af1 __unused)
 539 {
 540         struct udpstat udpstat, zerostat;
 541         size_t len = sizeof udpstat;
 542         u_long delivered;
 543
 544         if (zflag)
 545                 memset(&zerostat, 0, len);
 546         if (sysctlbyname("net.inet.udp.stats", &udpstat, &len,
 547             zflag ? &zerostat : NULL, zflag ? len : 0) < 0) {
 548                 warn("sysctl: net.inet.udp.stats");
 549                 return;
 550         }
 551
 552 #ifdef INET6
 553         if (udp_done != 0)
 554                 return;
 555         else
 556                 udp_done = 1;
 557 #endif
 558
 559         printf("%s:\n", name);
 560 #define p(f, m) if (udpstat.f || sflag <= 1) \
 561     printf(m, udpstat.f, plural(udpstat.f))
 562 #define p1a(f, m) if (udpstat.f || sflag <= 1) \
 563     printf(m, udpstat.f)
 564         p(udps_ipackets, "\t%lu datagram%s received\n");
 565         p1a(udps_hdrops, "\t%lu with incomplete header\n");
 566         p1a(udps_badlen, "\t%lu with bad data length field\n");
 567         p1a(udps_badsum, "\t%lu with bad checksum\n");
 568         p1a(udps_nosum, "\t%lu with no checksum\n");
 569         p1a(udps_noport, "\t%lu dropped due to no socket\n");
 570         p(udps_noportbcast,
 571             "\t%lu broadcast/multicast datagram%s dropped due to no socket\n");
 572         p1a(udps_fullsock, "\t%lu dropped due to full socket buffers\n");
 573         p1a(udpps_pcbhashmiss, "\t%lu not for hashed pcb\n");
 574         delivered = udpstat.udps_ipackets -
 575                     udpstat.udps_hdrops -
 576                     udpstat.udps_badlen -
 577                     udpstat.udps_badsum -
 578                     udpstat.udps_noport -
 579                     udpstat.udps_noportbcast -
 580                     udpstat.udps_fullsock;
 581         if (delivered || sflag <= 1)
 582                 printf("\t%lu delivered\n", delivered);
 583         p(udps_opackets, "\t%lu datagram%s output\n");
 584 #undef p
 585 #undef p1a
 586 }
 587
 588 /*
 589  * Dump CARP statistics structure.
 590  */
 591 void
 592 carp_stats(u_long off __unused, const char *name, int af1 __unused)
 593 {
 594        struct carpstats carpstat, zerostat;
 595        size_t len = sizeof(struct carpstats);
 596
 597        if (zflag)
 598                memset(&zerostat, 0, len);
 599        if (sysctlbyname("net.inet.carp.stats", &carpstat, &len,
 600            zflag ? &zerostat : NULL, zflag ? len : 0) < 0) {
 601                warn("sysctl: net.inet.carp.stats");
 602                return;
 603        }
 604
 605        printf("%s:\n", name);
 606
 607 #define p(f, m) if (carpstat.f || sflag <= 1) \
 608        printf(m, (uintmax_t)carpstat.f, plural((int)carpstat.f))
 609 #define p2(f, m) if (carpstat.f || sflag <= 1) \
 610        printf(m, (uintmax_t)carpstat.f)
 611
 612        p(carps_ipackets, "\t%ju packet%s received (IPv4)\n");
 613        p(carps_ipackets6, "\t%ju packet%s received (IPv6)\n");
 614        p(carps_badttl, "\t\t%ju packet%s discarded for wrong TTL\n");
 615        p(carps_hdrops, "\t\t%ju packet%s shorter than header\n");
 616        p(carps_badsum, "\t\t%ju discarded for bad checksum%s\n");
 617        p(carps_badver, "\t\t%ju discarded packet%s with a bad version\n");
 618        p2(carps_badlen, "\t\t%ju discarded because packet too short\n");
 619        p2(carps_badauth, "\t\t%ju discarded for bad authentication\n");
 620        p2(carps_badvhid, "\t\t%ju discarded for bad vhid\n");
 621        p2(carps_badaddrs, "\t\t%ju discarded because of a bad address list\n");
 622        p(carps_opackets, "\t%ju packet%s sent (IPv4)\n");
 623        p(carps_opackets6, "\t%ju packet%s sent (IPv6)\n");
 624        p2(carps_onomem, "\t\t%ju send failed due to mbuf memory error\n");
 625 #if notyet
 626        p(carps_ostates, "\t\t%s state update%s sent\n");
 627 #endif
 628 #undef p
 629 #undef p2
 630 }
 631
 632 /*
 633  * Dump IP statistics structure.
 634  */
 635 void
 636 ip_stats(u_long off __unused, const char *name, int af1 __unused)
 637 {
 638         struct ip_stats ipstat, *stattmp;
 639         struct ip_stats zerostat[SMP_MAXCPU];
 640         size_t len = sizeof(struct ip_stats) * SMP_MAXCPU;
 641         int cpucnt;
 642
 643         if (zflag)
 644                 memset(zerostat, 0, len);
 645         if ((stattmp = malloc(len)) == NULL) {
 646                 return;
 647         } else {
 648                 if (sysctlbyname("net.inet.ip.stats", stattmp, &len,
 649                         zflag ? zerostat : NULL, zflag ? len : 0) < 0) {
 650                                 warn("sysctl: net.inet.ip.stats");
 651                                 free(stattmp);
 652                                 return;
 653                 } else {
 654                         if ((stattmp = realloc(stattmp, len)) == NULL) {
 655                                 warn("ip_stats");
 656                                 return;
 657                         }
 658                 }
 659         }
 660         cpucnt = len / sizeof(struct ip_stats);
 661         ip_stats_agg(stattmp, &ipstat, cpucnt);
 662
 663         printf("%s:\n", name);
 664
 665 #define p(f, m) if (ipstat.f || sflag <= 1) \
 666     printf(m, ipstat.f, plural(ipstat.f))
 667 #define p1a(f, m) if (ipstat.f || sflag <= 1) \
 668     printf(m, ipstat.f)
 669
 670         p(ips_total, "\t%lu total packet%s received\n");
 671         p(ips_badsum, "\t%lu bad header checksum%s\n");
 672         p1a(ips_toosmall, "\t%lu with size smaller than minimum\n");
 673         p1a(ips_tooshort, "\t%lu with data size < data length\n");
 674         p1a(ips_toolong, "\t%lu with ip length > max ip packet size\n");
 675         p1a(ips_badhlen, "\t%lu with header length < data size\n");
 676         p1a(ips_badlen, "\t%lu with data length < header length\n");
 677         p1a(ips_badoptions, "\t%lu with bad options\n");
 678         p1a(ips_badvers, "\t%lu with incorrect version number\n");
 679         p(ips_fragments, "\t%lu fragment%s received\n");
 680         p(ips_fragdropped, "\t%lu fragment%s dropped (dup or out of space)\n");
 681         p(ips_fragtimeout, "\t%lu fragment%s dropped after timeout\n");
 682         p(ips_reassembled, "\t%lu packet%s reassembled ok\n");
 683         p(ips_delivered, "\t%lu packet%s for this host\n");
 684         p(ips_noproto, "\t%lu packet%s for unknown/unsupported protocol\n");
 685         p(ips_forward, "\t%lu packet%s forwarded");
 686         p(ips_fastforward, " (%lu packet%s fast forwarded)");
 687         if (ipstat.ips_forward || sflag <= 1)
 688                 putchar('\n');
 689         p(ips_cantforward, "\t%lu packet%s not forwardable\n");
 690         p(ips_notmember,
 691           "\t%lu packet%s received for unknown multicast group\n");
 692         p(ips_redirectsent, "\t%lu redirect%s sent\n");
 693         p(ips_localout, "\t%lu packet%s sent from this host\n");
 694         p(ips_rawout, "\t%lu packet%s sent with fabricated ip header\n");
 695         p(ips_odropped,
 696           "\t%lu output packet%s dropped due to no bufs, etc.\n");
 697         p(ips_noroute, "\t%lu output packet%s discarded due to no route\n");
 698         p(ips_fragmented, "\t%lu output datagram%s fragmented\n");
 699         p(ips_ofragments, "\t%lu fragment%s created\n");
 700         p(ips_cantfrag, "\t%lu datagram%s that can't be fragmented\n");
 701         p(ips_nogif, "\t%lu tunneling packet%s that can't find gif\n");
 702         p(ips_badaddr, "\t%lu datagram%s with bad address in header\n");
 703         free(stattmp);
 704 #undef p
 705 #undef p1a
 706 }
 707
 708 static  const char *icmpnames[] = {
 709         "echo reply",
 710         "#1",
 711         "#2",
 712         "destination unreachable",
 713         "source quench",
 714         "routing redirect",
 715         "#6",
 716         "#7",
 717         "echo",
 718         "router advertisement",
 719         "router solicitation",
 720         "time exceeded",
 721         "parameter problem",
 722         "time stamp",
 723         "time stamp reply",
 724         "information request",
 725         "information request reply",
 726         "address mask request",
 727         "address mask reply",
 728 };
 729
 730 /*
 731  * Dump ICMP statistics.
 732  */
 733 void
 734 icmp_stats(u_long off __unused, const char *name, int af1 __unused)
 735 {
 736         struct icmpstat icmpstat, zerostat;
 737         int i, first;
 738         int mib[4];             /* CTL_NET + PF_INET + IPPROTO_ICMP + req */
 739         size_t len;
 740
 741         mib[0] = CTL_NET;
 742         mib[1] = PF_INET;
 743         mib[2] = IPPROTO_ICMP;
 744         mib[3] = ICMPCTL_STATS;
 745
 746         len = sizeof icmpstat;
 747         if (zflag)
 748                 memset(&zerostat, 0, len);
 749         if (sysctl(mib, 4, &icmpstat, &len,
 750             zflag ? &zerostat : NULL, zflag ? len : 0) < 0) {
 751                 warn("sysctl: net.inet.icmp.stats");
 752                 return;
 753         }
 754
 755         printf("%s:\n", name);
 756
 757 #define p(f, m) if (icmpstat.f || sflag <= 1) \
 758     printf(m, icmpstat.f, plural(icmpstat.f))
 759 #define p1a(f, m) if (icmpstat.f || sflag <= 1) \
 760     printf(m, icmpstat.f)
 761 #define p2(f, m) if (icmpstat.f || sflag <= 1) \
 762     printf(m, icmpstat.f, plurales(icmpstat.f))
 763
 764         p(icps_error, "\t%lu call%s to icmp_error\n");
 765         p(icps_oldicmp,
 766             "\t%lu error%s not generated 'cuz old message was icmp\n");
 767         for (first = 1, i = 0; i < ICMP_MAXTYPE + 1; i++)
 768                 if (icmpstat.icps_outhist[i] != 0) {
 769                         if (first) {
 770                                 printf("\tOutput histogram:\n");
 771                                 first = 0;
 772                         }
 773                         printf("\t\t%s: %lu\n", icmpnames[i],
 774                                 icmpstat.icps_outhist[i]);
 775                 }
 776         p(icps_badcode, "\t%lu message%s with bad code fields\n");
 777         p(icps_tooshort, "\t%lu message%s < minimum length\n");
 778         p(icps_checksum, "\t%lu bad checksum%s\n");
 779         p(icps_badlen, "\t%lu message%s with bad length\n");
 780         p1a(icps_bmcastecho, "\t%lu multicast echo requests ignored\n");
 781         p1a(icps_bmcasttstamp, "\t%lu multicast timestamp requests ignored\n");
 782         for (first = 1, i = 0; i < ICMP_MAXTYPE + 1; i++)
 783                 if (icmpstat.icps_inhist[i] != 0) {
 784                         if (first) {
 785                                 printf("\tInput histogram:\n");
 786                                 first = 0;
 787                         }
 788                         printf("\t\t%s: %lu\n", icmpnames[i],
 789                                 icmpstat.icps_inhist[i]);
 790                 }
 791         p(icps_reflect, "\t%lu message response%s generated\n");
 792         p2(icps_badaddr, "\t%lu invalid return address%s\n");
 793         p(icps_noroute, "\t%lu no return route%s\n");
 794 #undef p
 795 #undef p1a
 796 #undef p2
 797         mib[3] = ICMPCTL_MASKREPL;
 798         len = sizeof i;
 799         if (sysctl(mib, 4, &i, &len, NULL, 0) < 0)
 800                 return;
 801         printf("\tICMP address mask responses are %sabled\n",
 802                i ? "en" : "dis");
 803 }
 804
 805 /*
 806  * Dump IGMP statistics structure.
 807  */
 808 void
 809 igmp_stats(u_long off __unused, const char *name, int af1 __unused)
 810 {
 811         struct igmpstat igmpstat, zerostat;
 812         size_t len = sizeof igmpstat;
 813
 814         if (zflag)
 815                 memset(&zerostat, 0, len);
 816         if (sysctlbyname("net.inet.igmp.stats", &igmpstat, &len,
 817             zflag ? &zerostat : NULL, zflag ? len : 0) < 0) {
 818                 warn("sysctl: net.inet.igmp.stats");
 819                 return;
 820         }
 821
 822         printf("%s:\n", name);
 823
 824 #define p(f, m) if (igmpstat.f || sflag <= 1) \
 825     printf(m, igmpstat.f, plural(igmpstat.f))
 826 #define py(f, m) if (igmpstat.f || sflag <= 1) \
 827     printf(m, igmpstat.f, igmpstat.f != 1 ? "ies" : "y")
 828         p(igps_rcv_total, "\t%u message%s received\n");
 829         p(igps_rcv_tooshort, "\t%u message%s received with too few bytes\n");
 830         p(igps_rcv_badsum, "\t%u message%s received with bad checksum\n");
 831         py(igps_rcv_queries, "\t%u membership quer%s received\n");
 832         py(igps_rcv_badqueries, "\t%u membership quer%s received with invalid field(s)\n");
 833         p(igps_rcv_reports, "\t%u membership report%s received\n");
 834         p(igps_rcv_badreports, "\t%u membership report%s received with invalid field(s)\n");
 835         p(igps_rcv_ourreports, "\t%u membership report%s received for groups to which we belong\n");
 836         p(igps_snd_reports, "\t%u membership report%s sent\n");
 837 #undef p
 838 #undef py
 839 }
 840
 841 /*
 842  * Dump PIM statistics structure.
 843  */
 844 void
 845 pim_stats(u_long off __unused, const char *name, int af1 __unused)
 846 {
 847         struct pimstat pimstat, zerostat;
 848         size_t len = sizeof pimstat;
 849
 850         if (zflag)
 851                 memset(&zerostat, 0, len);
 852         if (sysctlbyname("net.inet.pim.stats", &pimstat, &len,
 853             zflag ? &zerostat : NULL, zflag ? len : 0) < 0) {
 854                 if (errno != ENOENT)
 855                         warn("sysctl: net.inet.pim.stats");
 856                 return;
 857         }
 858
 859         printf("%s:\n", name);
 860
 861 #define p(f, m) if (pimstat.f || sflag <= 1) \
 862     printf(m, (uintmax_t)pimstat.f, plural(pimstat.f))
 863 #define py(f, m) if (pimstat.f || sflag <= 1) \
 864     printf(m, (uintmax_t)pimstat.f, pimstat.f != 1 ? "ies" : "y")
 865         p(pims_rcv_total_msgs, "\t%ju message%s received\n");
 866         p(pims_rcv_total_bytes, "\t%ju byte%s received\n");
 867         p(pims_rcv_tooshort, "\t%ju message%s received with too few bytes\n");
 868         p(pims_rcv_badsum, "\t%ju message%s received with bad checksum\n");
 869         p(pims_rcv_badversion, "\t%ju message%s received with bad version\n");
 870         p(pims_rcv_registers_msgs, "\t%ju data register message%s received\n");
 871         p(pims_rcv_registers_bytes, "\t%ju data register byte%s received\n");
 872         p(pims_rcv_registers_wrongiif, "\t%ju data register message%s received on wrong iif\n");
 873         p(pims_rcv_badregisters, "\t%ju bad register%s received\n");
 874         p(pims_snd_registers_msgs, "\t%ju data register message%s sent\n");
 875         p(pims_snd_registers_bytes, "\t%ju data register byte%s sent\n");
 876 #undef p
 877 #undef py
 878 }
 879
 880 /*
 881  * Pretty print an Internet address (net address + port).
 882  */
 883 void
 884 inetprint(struct in_addr *in, int port, const char *proto, int num_port)
 885 {
 886         struct servent *sp = 0;
 887         char line[80], *cp;
 888         int width;
 889
 890         if (Wflag)
 891             sprintf(line, "%s.", inetname(in));
 892         else
 893             sprintf(line, "%.*s.", (Aflag && !num_port) ? 12 : 16, inetname(in));
 894         cp = strchr(line, '\0');
 895         if (!num_port && port)
 896                 sp = getservbyport((int)port, proto);
 897         if (sp || port == 0)
 898                 sprintf(cp, "%.15s ", sp ? sp->s_name : "*");
 899         else
 900                 sprintf(cp, "%d ", ntohs((u_short)port));
 901         width = (Aflag && !Wflag) ? 17 : 21;
 902         if (Wflag)
 903             printf("%-*s ", width, line);
 904         else
 905             printf("%-*.*s ", width, width, line);
 906 }
 907
 908 /*
 909  * Construct an Internet address representation.
 910  * If numeric_addr has been supplied, give
 911  * numeric value, otherwise try for symbolic name.
 912  */
 913 char *
 914 inetname(struct in_addr *inp)
 915 {
 916         char *cp;
 917         static char line[MAXHOSTNAMELEN];
 918         struct hostent *hp;
 919         struct netent *np;
 920
 921         cp = 0;
 922         if (!numeric_addr && inp->s_addr != INADDR_ANY) {
 923                 int net = inet_netof(*inp);
 924                 int lna = inet_lnaof(*inp);
 925
 926                 if (lna == INADDR_ANY) {
 927                         np = getnetbyaddr(net, AF_INET);
 928                         if (np)
 929                                 cp = np->n_name;
 930                 }
 931                 if (cp == 0) {
 932                         hp = gethostbyaddr(inp, sizeof (*inp), AF_INET);
 933                         if (hp) {
 934                                 cp = hp->h_name;
 935                                 trimdomain(cp, strlen(cp));
 936                         }
 937                 }
 938         }
 939         if (inp->s_addr == INADDR_ANY)
 940                 strcpy(line, "*");
 941         else if (cp) {
 942                 strncpy(line, cp, sizeof(line) - 1);
 943                 line[sizeof(line) - 1] = '\0';
 944         } else {
 945                 inp->s_addr = ntohl(inp->s_addr);
 946 #define C(x)    ((u_int)((x) & 0xff))
 947                 sprintf(line, "%u.%u.%u.%u", C(inp->s_addr >> 24),
 948                     C(inp->s_addr >> 16), C(inp->s_addr >> 8), C(inp->s_addr));
 949         }
 950         return (line);
 951 }