]> git.saurik.com Git - apple/network_cmds.git/blobdiff - netstat.tproj/if.c
network_cmds-606.100.3.tar.gz
[apple/network_cmds.git] / netstat.tproj / if.c
index 0be2dc8136b02844f28e8beeabf07f5e2190f371..2fe6182a68908c6596fb3d0217fc9b288b2180e9 100644 (file)
@@ -1,3 +1,30 @@
+/*
+ * Copyright (c) 2008-2019 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
 /*
  * Copyright (c) 1983, 1988, 1993
  *     The Regents of the University of California.  All rights reserved.
  * SUCH DAMAGE.
  */
 
-#ifndef lint
-/*
-static char sccsid[] = "@(#)if.c       8.3 (Berkeley) 4/28/95";
-*/
-static const char rcsid[] =
-       "$Id: if.c,v 1.2 2002/03/05 20:35:13 lindak Exp $";
-#endif /* not lint */
-
 #include <sys/types.h>
-#include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/sysctl.h>
+#include <sys/ioctl.h>
 #include <sys/time.h>
+#include <sys/kern_control.h>
 
 #include <net/if.h>
 #include <net/if_var.h>
 #include <net/if_dl.h>
 #include <net/if_types.h>
+#include <net/if_mib.h>
+#include <net/if_llreach.h>
 #include <net/ethernet.h>
+#include <net/route.h>
+#include <net/ntstat.h>
+
+#include <net/pktsched/pktsched.h>
+#include <net/classq/if_classq.h>
+
 #include <netinet/in.h>
 #include <netinet/in_var.h>
 
-#ifdef IPX
-#include <netipx/ipx.h>
-#include <netipx/ipx_if.h>
-#endif
-
-#ifdef NS
-#include <netns/ns.h>
-#include <netns/ns_if.h>
-#endif
 #include <arpa/inet.h>
 
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <assert.h>
 
 #include "netstat.h"
 
 #define        YES     1
 #define        NO      0
 
-static void sidewaysintpr (u_int, u_long);
+#define ROUNDUP(a, size) (((a) & ((size) - 1)) ? (1 + ((a)|(size - 1))) : (a))
+
+#define NEXT_SA(p) (struct sockaddr *) \
+    ((caddr_t)p + (p->sa_len ? ROUNDUP(p->sa_len, sizeof(uint32_t)) : \
+    sizeof(uint32_t)))
+
+static void sidewaysintpr ();
 static void catchalarm (int);
+static char *sec2str(time_t);
+static void llreach_sysctl(uint32_t);
+static char *nsec_to_str(unsigned long long);
+static char *sched2str(unsigned int);
+static char *pri2str(unsigned int i);
 
-#ifdef INET6
-char *netname6 (struct sockaddr_in6 *, struct in6_addr *);
-static char ntop_buf[INET6_ADDRSTRLEN];                /* for inet_ntop() */
-static int bdg_done;
-#endif
+#define AVGN_MAX       8
 
-#if 0
-/* print bridge statistics */
-void
-bdg_stats(u_long dummy , char *name, int af )
-{
-    int i;
-    size_t slen ;
-    struct bdg_stats s ;
-    int mib[4] ;
-
-    slen = sizeof(s);
-
-    mib[0] = CTL_NET ;
-    mib[1] = PF_LINK ;
-    mib[2] = IFT_ETHER ;
-    if (sysctl(mib,4, &s,&slen,NULL,0)==-1)
-       return ; /* no bridging */
-#ifdef INET6
-    if (bdg_done != 0)
-       return;
-    else
-       bdg_done = 1;
-#endif
-    printf("-- Bridging statistics (%s) --\n", name) ;
-    printf(
-"Name          In      Out  Forward     Drop    Bcast    Mcast    Local  Unknown\n");
-    for (i = 0 ; i < 16 ; i++) {
-       if (s.s[i].name[0])
-       printf("%-6s %9ld%9ld%9ld%9ld%9ld%9ld%9ld%9ld\n",
-         s.s[i].name,
-         s.s[i].p_in[(int)BDG_IN],
-         s.s[i].p_in[(int)BDG_OUT],
-         s.s[i].p_in[(int)BDG_FORWARD],
-         s.s[i].p_in[(int)BDG_DROP],
-         s.s[i].p_in[(int)BDG_BCAST],
-         s.s[i].p_in[(int)BDG_MCAST],
-         s.s[i].p_in[(int)BDG_LOCAL],
-         s.s[i].p_in[(int)BDG_UNKNOWN] );
-    }
-}
+struct queue_stats {
+       int                      avgn;
+       double                   avg_bytes;
+       double                   avg_packets;
+       u_int64_t                prev_bytes;
+       u_int64_t                prev_packets;
+       unsigned int             handle;
+};
 
-#endif
+static void update_avg(struct if_ifclassq_stats *, struct queue_stats *);
+static void print_fq_codel_stats(int slot, struct fq_codel_classstats *,
+    struct queue_stats *);
 
+struct queue_stats qstats[IFCQ_SC_MAX];
+
+#ifdef INET6
+char *netname6 (struct sockaddr_in6 *, struct sockaddr *);
+static char ntop_buf[INET6_ADDRSTRLEN];                /* for inet_ntop() */
+#endif
 
 /*
  * Display a formatted value, or a '-' in the same space.
  */
 static void
-show_stat(const char *fmt, int width, u_long value, short showvalue)
+show_stat(const char *fmt, int width, u_int64_t value, short showvalue)
 {
        char newfmt[32];
 
        /* Construct the format string */
        if (showvalue) {
-               sprintf(newfmt, "%%%d%s", width, fmt);
+               snprintf(newfmt, sizeof(newfmt), "%%%d%s", width, fmt);
                printf(newfmt, value);
        } else {
-               sprintf(newfmt, "%%%ds", width);
+               snprintf(newfmt, sizeof(newfmt), "%%%ds", width);
                printf(newfmt, "-");
        }
 }
 
+size_t
+get_rti_info(int addrs, struct sockaddr *sa, struct sockaddr **rti_info)
+{
+    int                        i;
+    size_t             len = 0;
+
+    for (i = 0; i < RTAX_MAX; i++) {
+        if (addrs & (1 << i)) {
+            rti_info[i] = sa;
+            if (sa->sa_len < sizeof(struct sockaddr))
+                len += sizeof(struct sockaddr);
+            else
+                len += sa->sa_len;
+            sa = NEXT_SA(sa);
+        } else {
+            rti_info[i] = NULL;
+        }
+    }
+    return len;
+}
+
+static void
+multipr(int family, char *buf, char *lim)
+{
+    char  *next;
+
+    for (next = buf; next < lim; ) {
+               struct ifma_msghdr2     *ifmam = (struct ifma_msghdr2 *)next;
+               struct sockaddr *rti_info[RTAX_MAX];
+               struct sockaddr *sa;
+               const char *fmt = 0;
 
+               next += ifmam->ifmam_msglen;
+               if (ifmam->ifmam_type == RTM_IFINFO2)
+                       break;
+               else if (ifmam->ifmam_type != RTM_NEWMADDR2)
+                       continue;
+               get_rti_info(ifmam->ifmam_addrs, (struct sockaddr*)(ifmam + 1), rti_info);
+               sa = rti_info[RTAX_IFA];
+
+               if (sa->sa_family != family)
+                       continue;
+               switch (sa->sa_family) {
+                       case AF_INET: {
+                               struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+
+                               fmt = routename(sin->sin_addr.s_addr);
+                               break;
+                       }
+       #ifdef INET6
+                       case AF_INET6: {
+                               struct sockaddr_in6 sin6;
+
+                               memcpy(&sin6, sa, sizeof(struct sockaddr_in6));
+
+                               if (IN6_IS_ADDR_LINKLOCAL(&sin6.sin6_addr) ||
+                                       IN6_IS_ADDR_MC_NODELOCAL(&sin6.sin6_addr) ||
+                                       IN6_IS_ADDR_MC_LINKLOCAL(&sin6.sin6_addr)) {
+                                       sin6.sin6_scope_id = ntohs(*(u_int16_t *)&sin6.sin6_addr.s6_addr[2]);
+                                       sin6.sin6_addr.s6_addr[2] = 0;
+                                       sin6.sin6_addr.s6_addr[3] = 0;
+                               }
+
+                               printf("%23s %-19.19s(refs: %d)\n", "",
+                                   inet_ntop(AF_INET6, &sin6.sin6_addr,
+                                   ntop_buf, sizeof(ntop_buf)),
+                                               ifmam->ifmam_refcount);
+                               break;
+                       }
+       #endif /* INET6 */
+                       case AF_LINK: {
+                               struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
+
+                               switch (sdl->sdl_type) {
+                               case IFT_ETHER:
+                               case IFT_FDDI:
+                                       fmt = ether_ntoa((struct ether_addr *)
+                                               LLADDR(sdl));
+                                       break;
+                               }
+                               break;
+                       }
+               }
+               if (fmt)
+                       printf("%23s %s\n", "", fmt);
+       }
+}
 
 /*
  * Print a description of the network interfaces.
  */
 void
-intpr(int interval, u_long ifnetaddr, void (*pfunc)(char *))
+intpr(void (*pfunc)(char *))
 {
-       struct ifnet ifnet;
-       struct ifnethead ifnethead;
-       union {
-               struct ifaddr ifa;
-               struct in_ifaddr in;
-#ifdef INET6
-               struct in6_ifaddr in6;
-#endif
-#if 0
-               struct ipx_ifaddr ipx;
-#endif
-#ifdef NS
-               struct ns_ifaddr ns;
-#endif
-#ifdef ISO
-               struct iso_ifaddr iso;
-#endif
-       } ifaddr;
-       u_long ifaddraddr;
-       u_long ifaddrfound;
-       u_long ifnetfound;
-       u_long opackets;
-       u_long ipackets;
-       u_long obytes;
-       u_long ibytes;
-       u_long oerrors;
-       u_long ierrors;
-       u_long collisions;
-       short timer;
-       int drops;
+       u_int64_t opackets = 0;
+       u_int64_t ipackets = 0;
+       u_int64_t obytes = 0;
+       u_int64_t ibytes = 0;
+       u_int64_t oerrors = 0;
+       u_int64_t ierrors = 0;
+       u_int64_t collisions = 0;
+       u_int64_t fpackets = 0;
+       u_int64_t fbytes = 0;
+       uint32_t mtu = 0;
+       int timer = 0;
+       int drops = 0;
        struct sockaddr *sa = NULL;
-       char name[32], tname[16];
+       char name[32];
        short network_layer;
        short link_layer;
+       int mib[6];
+       char *buf = NULL, *lim, *next;
+       size_t len;
+       struct if_msghdr *ifm;
+       struct sockaddr *rti_info[RTAX_MAX];
+       unsigned int ifindex = 0;
 
-       if (ifnetaddr == 0) {
-               printf("ifnet: symbol not defined\n");
-               return;
-       }
        if (interval) {
-               sidewaysintpr((unsigned)interval, ifnetaddr);
+               sidewaysintpr();
                return;
        }
-       if (kread(ifnetaddr, (char *)&ifnethead, sizeof ifnethead))
+
+       if (interface != 0)
+               ifindex = if_nametoindex(interface);
+
+       mib[0]  = CTL_NET;                      // networking subsystem
+       mib[1]  = PF_ROUTE;                     // type of information
+       mib[2]  = 0;                            // protocol (IPPROTO_xxx)
+       mib[3]  = 0;                            // address family
+       mib[4]  = NET_RT_IFLIST2;       // operation
+       mib[5]  = 0;
+       if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
                return;
-       ifnetaddr = (u_long)TAILQ_FIRST(&ifnethead);
-       if (kread(ifnetaddr, (char *)&ifnet, sizeof ifnet))
+       if ((buf = malloc(len)) == NULL) {
+               printf("malloc failed\n");
+               exit(1);
+       }
+       if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
+               if (buf)
+                       free(buf);
                return;
+       }
 
        if (!pfunc) {
-               printf("%-5.5s %-5.5s %-13.13s %-15.15s %8.8s %5.5s",
-                      "Name", "Mtu", "Network", "Address", "Ipkts", "Ierrs");
-               if (bflag)
+               if (lflag) {
+                       printf("%-10.10s %-5.5s %-39.39s %-39.39s %8.8s %5.5s",
+                                  "Name", "Mtu", "Network", "Address", "Ipkts", "Ierrs");
+               } else {
+                       printf("%-10.10s %-5.5s %-13.13s %-15.15s %8.8s %5.5s",
+                                  "Name", "Mtu", "Network", "Address", "Ipkts", "Ierrs");
+               }
+               if (prioflag >= 0)
+                       printf(" %8.8s %8.8s", "Itcpkts", "Ipvpkts");
+               if (bflag) {
                        printf(" %10.10s","Ibytes");
+                       if (prioflag >= 0)
+                               printf(" %8.8s %8.8s", "Itcbytes", "Ipvbytes");
+               }
                printf(" %8.8s %5.5s", "Opkts", "Oerrs");
-               if (bflag)
+               if (prioflag >= 0)
+                       printf(" %8.8s %8.8s", "Otcpkts", "Opvpkts");
+               if (bflag) {
                        printf(" %10.10s","Obytes");
+                       if (prioflag >= 0)
+                               printf(" %8.8s %8.8s", "Otcbytes", "Opvbytes");
+               }
                printf(" %5s", "Coll");
                if (tflag)
                        printf(" %s", "Time");
                if (dflag)
                        printf(" %s", "Drop");
+               if (Fflag) {
+                       printf(" %8.8s", "Fpkts");
+                       if (bflag)
+                               printf(" %10.10s", "Fbytes");
+               }
                putchar('\n');
        }
-       ifaddraddr = 0;
-       while (ifnetaddr || ifaddraddr) {
-               struct sockaddr_in *sin;
-#ifdef INET6
-               struct sockaddr_in6 *sin6;
-#endif
-               register char *cp;
+       lim = buf + len;
+       for (next = buf; next < lim; ) {
+               char *cp;
                int n, m;
+               struct ifmibdata_supplemental ifmsupp;
+               u_int64_t       ift_itcp = 0;   /* input tc packets */
+               u_int64_t       ift_itcb = 0;   /* input tc bytes */
+               u_int64_t       ift_otcp = 0;   /* output tc packets */
+               u_int64_t       ift_otcb = 0;   /* output tc bytes */
+               u_int64_t       ift_ipvp = 0;   /* input priv tc packets */
+               u_int64_t       ift_ipvb = 0;   /* input priv tc bytes */
+               u_int64_t       ift_opvp = 0;   /* output priv tc packets */
+               u_int64_t       ift_opvb = 0;   /* output priv tc bytes */
+
+               bzero(&ifmsupp, sizeof(struct ifmibdata_supplemental));
 
                network_layer = 0;
                link_layer = 0;
+               ifm = (struct if_msghdr *)next;
+               next += ifm->ifm_msglen;
+
+               if (ifm->ifm_type == RTM_IFINFO2) {
+                       struct if_msghdr2 *if2m = (struct if_msghdr2 *)ifm;
+                       struct sockaddr_dl *sdl =
+                           (struct sockaddr_dl *)(if2m + 1);
+                       int mibname[6];
+                       size_t miblen = sizeof(struct ifmibdata_supplemental);
 
-               if (ifaddraddr == 0) {
-                       ifnetfound = ifnetaddr;
-                       if (kread(ifnetaddr, (char *)&ifnet, sizeof ifnet) ||
-                           kread((u_long)ifnet.if_name, tname, 16))
-                               return;
-                       tname[15] = '\0';
-                       ifnetaddr = (u_long)TAILQ_NEXT(&ifnet, if_link);
-                       snprintf(name, 32, "%s%d", tname, ifnet.if_unit);
-                       if (interface != 0 && (strcmp(name, interface) != 0))
+                       if (interface != 0 && if2m->ifm_index != ifindex)
                                continue;
-                       cp = index(name, '\0');
+
+                       /* The interface name is not a zero-ended string */
+                       memcpy(name, sdl->sdl_data, MIN(sizeof(name) - 1, sdl->sdl_nlen));
+                       name[MIN(sizeof(name) - 1, sdl->sdl_nlen)] = 0;
 
                        if (pfunc) {
                                (*pfunc)(name);
                                continue;
                        }
 
-                       if ((ifnet.if_flags&IFF_UP) == 0)
+                       cp = index(name, '\0');
+                       if ((if2m->ifm_flags & IFF_UP) == 0)
                                *cp++ = '*';
                        *cp = '\0';
-                       ifaddraddr = (u_long)TAILQ_FIRST(&ifnet.if_addrhead);
-               }
-               printf("%-5.5s %-5lu ", name, ifnet.if_mtu);
-               ifaddrfound = ifaddraddr;
-
-               /*
-                * Get the interface stats.  These may get
-                * overriden below on a per-interface basis.
-                */
-               opackets = ifnet.if_opackets;
-               ipackets = ifnet.if_ipackets;
-               obytes = ifnet.if_obytes;
-               ibytes = ifnet.if_ibytes;
-               oerrors = ifnet.if_oerrors;
-               ierrors = ifnet.if_ierrors;
-               collisions = ifnet.if_collisions;
-               timer = ifnet.if_timer;
-               drops = ifnet.if_snd.ifq_drops;
-
-               if (ifaddraddr == 0) {
-                       printf("%-13.13s ", "none");
-                       printf("%-15.15s ", "none");
-               } else {
-                       if (kread(ifaddraddr, (char *)&ifaddr, sizeof ifaddr)) {
-                               ifaddraddr = 0;
-                               continue;
+
+                       /*
+                        * Get the interface stats.  These may get
+                        * overriden below on a per-interface basis.
+                        */
+                       opackets = if2m->ifm_data.ifi_opackets;
+                       ipackets = if2m->ifm_data.ifi_ipackets;
+                       obytes = if2m->ifm_data.ifi_obytes;
+                       ibytes = if2m->ifm_data.ifi_ibytes;
+                       oerrors =if2m->ifm_data.ifi_oerrors;
+                       ierrors = if2m->ifm_data.ifi_ierrors;
+                       collisions = if2m->ifm_data.ifi_collisions;
+                       timer = if2m->ifm_timer;
+                       drops = if2m->ifm_snd_drops;
+                       mtu = if2m->ifm_data.ifi_mtu;
+
+                       /* Common OID prefix */
+                       mibname[0] = CTL_NET;
+                       mibname[1] = PF_LINK;
+                       mibname[2] = NETLINK_GENERIC;
+                       mibname[3] = IFMIB_IFDATA;
+                       mibname[4] = if2m->ifm_index;
+                       mibname[5] = IFDATA_SUPPLEMENTAL;
+                       if (sysctl(mibname, 6, &ifmsupp, &miblen, NULL, 0) == -1)
+                               err(1, "sysctl IFDATA_SUPPLEMENTAL");
+
+                       fpackets = ifmsupp.ifmd_data_extended.ifi_fpackets;
+                       fbytes = ifmsupp.ifmd_data_extended.ifi_fbytes;
+
+                       if (prioflag >= 0) {
+                               switch (prioflag) {
+                               case SO_TC_BE:
+                                       ift_itcp = ifmsupp.ifmd_traffic_class.ifi_ibepackets;
+                                       ift_itcb = ifmsupp.ifmd_traffic_class.ifi_ibebytes;
+                                       ift_otcp = ifmsupp.ifmd_traffic_class.ifi_obepackets;
+                                       ift_otcb = ifmsupp.ifmd_traffic_class.ifi_obebytes;
+                                       break;
+                               case SO_TC_BK:
+                                       ift_itcp = ifmsupp.ifmd_traffic_class.ifi_ibkpackets;
+                                       ift_itcb = ifmsupp.ifmd_traffic_class.ifi_ibkbytes;
+                                       ift_otcp = ifmsupp.ifmd_traffic_class.ifi_obkpackets;
+                                       ift_otcb = ifmsupp.ifmd_traffic_class.ifi_obkbytes;
+                                       break;
+                               case SO_TC_VI:
+                                       ift_itcp = ifmsupp.ifmd_traffic_class.ifi_ivipackets;
+                                       ift_itcb = ifmsupp.ifmd_traffic_class.ifi_ivibytes;
+                                       ift_otcp = ifmsupp.ifmd_traffic_class.ifi_ovipackets;
+                                       ift_otcb = ifmsupp.ifmd_traffic_class.ifi_ovibytes;
+                                       break;
+                               case SO_TC_VO:
+                                       ift_itcp = ifmsupp.ifmd_traffic_class.ifi_ivopackets;
+                                       ift_itcb = ifmsupp.ifmd_traffic_class.ifi_ivobytes;
+                                       ift_otcp = ifmsupp.ifmd_traffic_class.ifi_ovopackets;
+                                       ift_otcb = ifmsupp.ifmd_traffic_class.ifi_ovobytes;
+                                       break;
+                               default:
+                                       ift_itcp = 0;
+                                       ift_itcb = 0;
+                                       ift_otcp = 0;
+                                       ift_otcb = 0;
+                                       ift_ipvp = 0;
+                                       ift_ipvb = 0;
+                                       ift_opvp = 0;
+                                       ift_opvb = 0;
+                                       break;
+                               }
+                               ift_ipvp = ifmsupp.ifmd_traffic_class.ifi_ipvpackets;
+                               ift_ipvb = ifmsupp.ifmd_traffic_class.ifi_ipvbytes;
+                               ift_opvp = ifmsupp.ifmd_traffic_class.ifi_opvpackets;
+                               ift_opvb = ifmsupp.ifmd_traffic_class.ifi_opvbytes;
                        }
-#define CP(x) ((char *)(x))
-                       cp = (CP(ifaddr.ifa.ifa_addr) - CP(ifaddraddr)) +
-                               CP(&ifaddr);
-                       sa = (struct sockaddr *)cp;
+
+                       get_rti_info(if2m->ifm_addrs,
+                           (struct sockaddr*)(if2m + 1), rti_info);
+                       sa = rti_info[RTAX_IFP];
+               } else if (ifm->ifm_type == RTM_NEWADDR) {
+                       struct ifa_msghdr *ifam = (struct ifa_msghdr *)ifm;
+
+                       if (interface != 0 && ifam->ifam_index != ifindex)
+                               continue;
+                       get_rti_info(ifam->ifam_addrs,
+                           (struct sockaddr*)(ifam + 1), rti_info);
+                       sa = rti_info[RTAX_IFA];
+               } else {
+                       continue;
+               }
+               if (lflag) {
+                       printf("%-10.10s %-5u ", name, mtu);
+               } else {
+                       printf("%-5.5s %-5u ", name, mtu);
+               }
+
+               if (sa == 0) {
+                       printf(lflag ? "%-39.39s " : "%-13.13s ", "none");
+                       printf(lflag ? "%-39.39s " : "%-15.15s ", "none");
+               } else {
                        switch (sa->sa_family) {
                        case AF_UNSPEC:
-                               printf("%-13.13s ", "none");
-                               printf("%-15.15s ", "none");
+                               printf(lflag ? "%-39.39s " : "%-13.13s ", "none");
+                               printf(lflag ? "%-39.39s " : "%-15.15s ", "none");
                                break;
-                       case AF_INET:
-                               sin = (struct sockaddr_in *)sa;
-#ifdef notdef
-                               /* can't use inet_makeaddr because kernel
-                                * keeps nets unshifted.
-                                */
-                               in = inet_makeaddr(ifaddr.in.ia_subnet,
-                                       INADDR_ANY);
-                               printf("%-13.13s ", netname(in.s_addr,
-                                   ifaddr.in.ia_subnetmask));
-#else
-                               printf("%-13.13s ",
-                                   netname(htonl(ifaddr.in.ia_subnet),
-                                   ifaddr.in.ia_subnetmask));
-#endif
-                               printf("%-15.15s ",
+
+                       case AF_INET: {
+                               struct sockaddr_in *sin =
+                                   (struct sockaddr_in *)sa;
+                               struct sockaddr_in mask;
+
+                               mask.sin_addr.s_addr = 0;
+                               memcpy(&mask, rti_info[RTAX_NETMASK],
+                                   ((struct sockaddr_in *)
+                                   rti_info[RTAX_NETMASK])->sin_len);
+
+                               printf(lflag ? "%-39.39s " : "%-13.13s ",
+                                   netname(sin->sin_addr.s_addr &
+                                   mask.sin_addr.s_addr,
+                                   ntohl(mask.sin_addr.s_addr)));
+
+                               printf(lflag ? "%-39.39s " : "%-15.15s ",
                                    routename(sin->sin_addr.s_addr));
 
                                network_layer = 1;
                                break;
+                       }
 #ifdef INET6
-                       case AF_INET6:
-                               sin6 = (struct sockaddr_in6 *)sa;
-                               printf("%-11.11s ",
-                                      netname6(&ifaddr.in6.ia_addr,
-                                               &ifaddr.in6.ia_prefixmask.sin6_addr));
-                               printf("%-17.17s ",
-                                   (char *)inet_ntop(AF_INET6,
-                                       &sin6->sin6_addr,
-                                       ntop_buf, sizeof(ntop_buf)));
+                       case AF_INET6: {
+                               struct sockaddr_in6 *sin6 =
+                                   (struct sockaddr_in6 *)sa;
+                               struct sockaddr *mask =
+                                   (struct sockaddr *)rti_info[RTAX_NETMASK];
+
+                               printf(lflag ? "%-39.39s " : "%-11.11s ", netname6(sin6, mask));
+                               printf(lflag ? "%-39.39s " : "%-17.17s ", (char *)inet_ntop(AF_INET6,
+                                   &sin6->sin6_addr, ntop_buf,
+                                   sizeof(ntop_buf)));
 
                                network_layer = 1;
                                break;
+                       }
 #endif /*INET6*/
-#if 0
-                       case AF_IPX:
-                               {
-                               struct sockaddr_ipx *sipx =
-                                       (struct sockaddr_ipx *)sa;
-                               u_long net;
-                               char netnum[10];
-
-                               *(union ipx_net *) &net = sipx->sipx_addr.x_net;
-                               sprintf(netnum, "%lx", (u_long)ntohl(net));
-                               printf("ipx:%-8s  ", netnum);
-/*                             printf("ipx:%-8s ", netname(net, 0L)); */
-                               printf("%-15s ",
-                                   ipx_phost((struct sockaddr *)sipx));
-                               }
-                               break;
-
-                       case AF_APPLETALK:
-                               printf("atalk:%-12.12s ",atalk_print(sa,0x10) );
-                               printf("%-9.9s  ",atalk_print(sa,0x0b) );
-                               break;
-#endif
-#ifdef NS
-                       case AF_NS:
-                               {
-                               struct sockaddr_ns *sns =
-                                       (struct sockaddr_ns *)sa;
-                               u_long net;
-                               char netnum[10];
-
-                               *(union ns_net *) &net = sns->sns_addr.x_net;
-                               sprintf(netnum, "%lxH", ntohl(net));
-                               upHex(netnum);
-                               printf("ns:%-8s ", netnum);
-                               printf("%-15s ",
-                                   ns_phost((struct sockaddr *)sns));
-                               }
-                               break;
-#endif
-                       case AF_LINK:
-                               {
+                       case AF_LINK: {
                                struct sockaddr_dl *sdl =
-                                       (struct sockaddr_dl *)sa;
+                                   (struct sockaddr_dl *)sa;
                                char linknum[10];
                                cp = (char *)LLADDR(sdl);
                                n = sdl->sdl_alen;
-                               sprintf(linknum, "<Link#%d>", sdl->sdl_index);
-                               m = printf("%-11.11s ", linknum);
-                               }
+                               snprintf(linknum, sizeof(linknum),
+                                   "<Link#%d>", sdl->sdl_index);
+                               m = printf(lflag ? "%-39.39s " : "%-11.11s ", linknum);
                                goto hexprint;
+                       }
+
                        default:
                                m = printf("(%d)", sa->sa_family);
                                for (cp = sa->sa_len + (char *)sa;
@@ -379,45 +537,56 @@ intpr(int interval, u_long ifnetaddr, void (*pfunc)(char *))
                                while (--n >= 0)
                                        m += printf("%02x%c", *cp++ & 0xff,
                                                    n > 0 ? ':' : ' ');
-                               m = 30 - m;
+                               m = (lflag ? 80 : 30) - m;
                                while (m-- > 0)
                                        putchar(' ');
 
                                link_layer = 1;
                                break;
                        }
-#ifndef __APPLE__
-                       /*
-                        * Fixup the statistics for interfaces that
-                        * update stats for their network addresses
-                        */
-                       if (network_layer) {
-                               opackets = ifaddr.in.ia_ifa.if_opackets;
-                               ipackets = ifaddr.in.ia_ifa.if_ipackets;
-                               obytes = ifaddr.in.ia_ifa.if_obytes;
-                               ibytes = ifaddr.in.ia_ifa.if_ibytes;
-                       }
-#endif
-                       ifaddraddr = (u_long)TAILQ_NEXT(&ifaddr.ifa, ifa_link);
                }
 
-               show_stat("lu", 8, ipackets, link_layer|network_layer);
+               show_stat("llu", 8, ipackets, link_layer|network_layer);
                printf(" ");
-               show_stat("lu", 5, ierrors, link_layer);
+               show_stat("llu", 5, ierrors, link_layer);
                printf(" ");
+               if (prioflag >= 0) {
+                       show_stat("llu", 8, ift_itcp, link_layer|network_layer);
+                       printf(" ");
+                       show_stat("llu", 8, ift_ipvp, link_layer|network_layer);
+                       printf(" ");
+               }
                if (bflag) {
-                       show_stat("lu", 10, ibytes, link_layer|network_layer);
+                       show_stat("llu", 10, ibytes, link_layer|network_layer);
                        printf(" ");
+                       if (prioflag >= 0) {
+                               show_stat("llu", 8, ift_itcb, link_layer|network_layer);
+                               printf(" ");
+                               show_stat("llu", 8, ift_ipvb, link_layer|network_layer);
+                               printf(" ");
+                       }
                }
-               show_stat("lu", 8, opackets, link_layer|network_layer);
+               show_stat("llu", 8, opackets, link_layer|network_layer);
                printf(" ");
-               show_stat("lu", 5, oerrors, link_layer);
+               show_stat("llu", 5, oerrors, link_layer);
                printf(" ");
+               if (prioflag >= 0) {
+                       show_stat("llu", 8, ift_otcp, link_layer|network_layer);
+                       printf(" ");
+                       show_stat("llu", 8, ift_opvp, link_layer|network_layer);
+                       printf(" ");
+               }
                if (bflag) {
-                       show_stat("lu", 10, obytes, link_layer|network_layer);
+                       show_stat("llu", 10, obytes, link_layer|network_layer);
                        printf(" ");
+                       if (prioflag >= 0) {
+                               show_stat("llu", 8, ift_otcb, link_layer|network_layer);
+                               printf(" ");
+                               show_stat("llu", 8, ift_opvb, link_layer|network_layer);
+                               printf(" ");
+                       }
                }
-               show_stat("lu", 5, collisions, link_layer);
+               show_stat("llu", 5, collisions, link_layer);
                if (tflag) {
                        printf(" ");
                        show_stat("d", 3, timer, link_layer);
@@ -426,79 +595,44 @@ intpr(int interval, u_long ifnetaddr, void (*pfunc)(char *))
                        printf(" ");
                        show_stat("d", 3, drops, link_layer);
                }
-               putchar('\n');
-               if (aflag && ifaddrfound) {
-                       /*
-                        * Print family's multicast addresses
-                        */
-                       u_long multiaddr;
-                       struct ifmultiaddr ifma;
-                       union {
-                               struct sockaddr sa;
-                               struct sockaddr_in in;
-#ifdef INET6
-                               struct sockaddr_in6 in6;
-#endif /* INET6 */
-                               struct sockaddr_dl dl;
-                       } msa;
-                       const char *fmt;
-
-                       for(multiaddr = (u_long)ifnet.if_multiaddrs.lh_first;
-                           multiaddr;
-                           multiaddr = (u_long)ifma.ifma_link.le_next) {
-                               if (kread(multiaddr, (char *)&ifma,
-                                         sizeof ifma))
-                                       break;
-                               if (kread((u_long)ifma.ifma_addr, (char *)&msa,
-                                         sizeof msa))
-                                       break;
-                               if (msa.sa.sa_family != sa->sa_family)
-                                       continue;
-                               
-                               fmt = 0;
-                               switch (msa.sa.sa_family) {
-                               case AF_INET:
-                                       fmt = routename(msa.in.sin_addr.s_addr);
-                                       break;
-#ifdef INET6
-                               case AF_INET6:
-                                       printf("%23s %-19.19s(refs: %d)\n", "",
-                                              inet_ntop(AF_INET6,
-                                                        &msa.in6.sin6_addr,
-                                                        ntop_buf,
-                                                        sizeof(ntop_buf)),
-                                              ifma.ifma_refcount);
-                                       break;
-#endif /* INET6 */
-                               case AF_LINK:
-                                       switch (msa.dl.sdl_type) {
-                                       case IFT_ETHER:
-                                       case IFT_FDDI:
-                                               fmt = ether_ntoa(
-                                                       (struct ether_addr *)
-                                                       LLADDR(&msa.dl));
-                                               break;
-                                       }
-                                       break;
-                               }
-                               if (fmt)
-                                       printf("%23s %s\n", "", fmt);
+               if (Fflag) {
+                       printf(" ");
+                       show_stat("llu", 8, fpackets, link_layer|network_layer);
+                       if (bflag) {
+                               printf(" ");
+                               show_stat("llu", 10, fbytes,
+                                   link_layer|network_layer);
                        }
                }
+               putchar('\n');
+
+               if (aflag)
+                       multipr(sa->sa_family, next, lim);
        }
+       free(buf);
 }
 
 struct iftot {
        SLIST_ENTRY(iftot) chain;
-       char    ift_name[16];           /* interface name */
-       u_long  ift_ip;                 /* input packets */
-       u_long  ift_ie;                 /* input errors */
-       u_long  ift_op;                 /* output packets */
-       u_long  ift_oe;                 /* output errors */
-       u_long  ift_co;                 /* collisions */
-       u_int   ift_dr;                 /* drops */
-       u_long  ift_ib;                 /* input bytes */
-       u_long  ift_ob;                 /* output bytes */
+       char            ift_name[16];   /* interface name */
+       u_int64_t       ift_ip;         /* input packets */
+       u_int64_t       ift_ie;         /* input errors */
+       u_int64_t       ift_op;         /* output packets */
+       u_int64_t       ift_oe;         /* output errors */
+       u_int64_t       ift_co;         /* collisions */
+       u_int64_t       ift_dr;         /* drops */
+       u_int64_t       ift_ib;         /* input bytes */
+       u_int64_t       ift_ob;         /* output bytes */
+       u_int64_t       ift_itcp;       /* input tc packets */
+       u_int64_t       ift_itcb;       /* input tc bytes */
+       u_int64_t       ift_otcp;       /* output tc packets */
+       u_int64_t       ift_otcb;       /* output tc bytes */
+       u_int64_t       ift_ipvp;       /* input priv tc packets */
+       u_int64_t       ift_ipvb;       /* input priv tc bytes */
+       u_int64_t       ift_opvp;       /* output priv tc packets */
+       u_int64_t       ift_opvb;       /* output priv tc bytes */
+       u_int64_t       ift_fp;         /* forwarded packets */
+       u_int64_t       ift_fb;         /* forwarded bytes */
 };
 
 u_char signalled;                      /* set if alarm goes off "early" */
@@ -511,106 +645,324 @@ u_char  signalled;                      /* set if alarm goes off "early" */
  * XXX - should be rewritten to use ifmib(4).
  */
 static void
-sidewaysintpr(unsigned interval, u_long off)
+sidewaysintpr()
 {
-       struct ifnet ifnet;
-       u_long firstifnet;
-       struct ifnethead ifnethead;
-       struct iftot *iftot, *ip, *ipn, *total, *sum, *interesting;
+       struct iftot *total, *sum, *interesting;
        register int line;
-       int oldmask, first;
-       u_long interesting_off;
+       int first;
+       int name[6];
+       size_t len;
+       unsigned int ifcount, i;
+       struct ifmibdata *ifmdall = 0;
+       int interesting_row;
+       sigset_t sigset, oldsigset;
+       struct itimerval timer_interval;
 
-       if (kread(off, (char *)&ifnethead, sizeof ifnethead))
-               return;
-       firstifnet = (u_long)TAILQ_FIRST(&ifnethead);
+       /* Common OID prefix */
+       name[0] = CTL_NET;
+       name[1] = PF_LINK;
+       name[2] = NETLINK_GENERIC;
 
-       if ((iftot = malloc(sizeof(struct iftot))) == NULL) {
-               printf("malloc failed\n");
-               exit(1);
-       }
-       memset(iftot, 0, sizeof(struct iftot));
+       len = sizeof(int);
+       name[3] = IFMIB_SYSTEM;
+       name[4] = IFMIB_IFCOUNT;
+       if (sysctl(name, 5, &ifcount, &len, 0, 0) == 1)
+               err(1, "sysctl IFMIB_IFCOUNT");
+
+       len = ifcount * sizeof(struct ifmibdata);
+       ifmdall = malloc(len);
+       if (ifmdall == 0)
+               err(1, "malloc failed");
+       name[3] = IFMIB_IFALLDATA;
+       name[4] = 0;
+       name[5] = IFDATA_GENERAL;
+       if (sysctl(name, 6, ifmdall, &len, (void *)0, 0) == -1)
+               err(1, "sysctl IFMIB_IFALLDATA");
 
        interesting = NULL;
-       interesting_off = 0;
-       for (off = firstifnet, ip = iftot; off;) {
-               char name[16], tname[16];
+       interesting_row = 0;
+       for (i = 0; i < ifcount; i++) {
+               struct ifmibdata *ifmd = ifmdall + i;
 
-               if (kread(off, (char *)&ifnet, sizeof ifnet))
-                       break;
-               if (kread((u_long)ifnet.if_name, tname, 16))
-                       break;
-               tname[15] = '\0';
-               snprintf(name, 16, "%s%d", tname, ifnet.if_unit);
-               if (interface && strcmp(name, interface) == 0) {
-                       interesting = ip;
-                       interesting_off = off;
-               }
-               snprintf(ip->ift_name, 16, "(%s)", name);;
-               if ((ipn = malloc(sizeof(struct iftot))) == NULL) {
-                       printf("malloc failed\n");
-                       exit(1);
+               if (interface && strcmp(ifmd->ifmd_name, interface) == 0) {
+                       if ((interesting = calloc(ifcount,
+                           sizeof(struct iftot))) == NULL)
+                               err(1, "malloc failed");
+                       interesting_row = if_nametoindex(interface);
+                       snprintf(interesting->ift_name, 16, "(%s)",
+                           ifmd->ifmd_name);;
                }
-               memset(ipn, 0, sizeof(struct iftot));
-               SLIST_NEXT(ip, chain) = ipn;
-               ip = ipn;
-               off = (u_long)TAILQ_NEXT(&ifnet, if_link);
-       }
-       if ((total = malloc(sizeof(struct iftot))) == NULL) {
-               printf("malloc failed\n");
-               exit(1);
-       }
-       memset(total, 0, sizeof(struct iftot));
-       if ((sum = malloc(sizeof(struct iftot))) == NULL) {
-               printf("malloc failed\n");
-               exit(1);
        }
-       memset(sum, 0, sizeof(struct iftot));
+       if ((total = calloc(1, sizeof(struct iftot))) == NULL)
+               err(1, "malloc failed");
 
+       if ((sum = calloc(1, sizeof(struct iftot))) == NULL)
+               err(1, "malloc failed");
 
+       /* create a timer that fires repeatedly every interval seconds */
+       timer_interval.it_value.tv_sec = interval;
+       timer_interval.it_value.tv_usec = 0;
+       timer_interval.it_interval.tv_sec = interval;
+       timer_interval.it_interval.tv_usec = 0;
        (void)signal(SIGALRM, catchalarm);
        signalled = NO;
-       (void)alarm(interval);
+       (void)setitimer(ITIMER_REAL, &timer_interval, NULL);
        first = 1;
 banner:
-       printf("%17s %14s %16s", "input",
-           interesting ? interesting->ift_name : "(Total)", "output");
+       if (vflag > 0)
+               printf("%9s", " ");
+
+       if (prioflag >= 0)
+               printf("%39s %39s %36s", "input",
+                   interesting ? interesting->ift_name : "(Total)", "output");
+       else
+               printf("%17s %14s %16s", "input",
+                   interesting ? interesting->ift_name : "(Total)", "output");
        putchar('\n');
-       printf("%10s %5s %10s %10s %5s %10s %5s",
-           "packets", "errs", "bytes", "packets", "errs", "bytes", "colls");
+
+       if (vflag > 0)
+               printf("%9s", " ");
+
+       printf("%10s %5s %10s ", "packets", "errs", "bytes");
+       if (prioflag >= 0)
+               printf(" %10s %10s %10s %10s",
+                   "tcpkts", "tcbytes", "pvpkts", "pvbytes");
+       printf("%10s %5s %10s %5s", "packets", "errs", "bytes", "colls");
        if (dflag)
                printf(" %5.5s", "drops");
+       if (prioflag >= 0)
+               printf(" %10s %10s %10s %10s",
+                   "tcpkts", "tcbytes", "pvpkts", "pvbytes");
+       if (Fflag)
+               printf(" %10s %10s", "fpackets", "fbytes");
        putchar('\n');
        fflush(stdout);
        line = 0;
 loop:
+       if (vflag && !first)
+               print_time();
+
        if (interesting != NULL) {
-               ip = interesting;
-               if (kread(interesting_off, (char *)&ifnet, sizeof ifnet)) {
-                       printf("???\n");
-                       exit(1);
-               };
+               struct ifmibdata ifmd;
+               struct ifmibdata_supplemental ifmsupp;
+
+               len = sizeof(struct ifmibdata);
+               name[3] = IFMIB_IFDATA;
+               name[4] = interesting_row;
+               name[5] = IFDATA_GENERAL;
+               if (sysctl(name, 6, &ifmd, &len, (void *)0, 0) == -1)
+                       err(1, "sysctl IFDATA_GENERAL %d", interesting_row);
+
+               len = sizeof(struct ifmibdata_supplemental);
+               name[3] = IFMIB_IFDATA;
+               name[4] = interesting_row;
+               name[5] = IFDATA_SUPPLEMENTAL;
+               if (sysctl(name, 6, &ifmsupp, &len, (void *)0, 0) == -1)
+                       err(1, "sysctl IFDATA_SUPPLEMENTAL %d",
+                           interesting_row);
+
                if (!first) {
-                       printf("%10lu %5lu %10lu %10lu %5lu %10lu %5lu",
-                               ifnet.if_ipackets - ip->ift_ip,
-                               ifnet.if_ierrors - ip->ift_ie,
-                               ifnet.if_ibytes - ip->ift_ib,
-                               ifnet.if_opackets - ip->ift_op,
-                               ifnet.if_oerrors - ip->ift_oe,
-                               ifnet.if_obytes - ip->ift_ob,
-                               ifnet.if_collisions - ip->ift_co);
+                       printf("%10llu %5llu %10llu ",
+                           ifmd.ifmd_data.ifi_ipackets - interesting->ift_ip,
+                           ifmd.ifmd_data.ifi_ierrors - interesting->ift_ie,
+                           ifmd.ifmd_data.ifi_ibytes - interesting->ift_ib);
+                       switch (prioflag) {
+                       case SO_TC_BE:
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_ibepackets -
+                                   interesting->ift_itcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ibebytes -
+                                   interesting->ift_itcb);
+                               break;
+                       case SO_TC_BK:
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_ibkpackets -
+                                   interesting->ift_itcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ibkbytes -
+                                   interesting->ift_itcb);
+                               break;
+                       case SO_TC_VI:
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_ivipackets -
+                                   interesting->ift_itcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ivibytes -
+                                   interesting->ift_itcb);
+                               break;
+                       case SO_TC_VO:
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_ivopackets -
+                                   interesting->ift_itcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ivobytes -
+                                   interesting->ift_itcb);
+                               break;
+                       default:
+                               break;
+                       }
+                       if (prioflag >= 0) {
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_ipvpackets -
+                                   interesting->ift_ipvp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ipvbytes -
+                                   interesting->ift_ipvb);
+                       }
+                       printf("%10llu %5llu %10llu %5llu",
+                           ifmd.ifmd_data.ifi_opackets - interesting->ift_op,
+                           ifmd.ifmd_data.ifi_oerrors - interesting->ift_oe,
+                           ifmd.ifmd_data.ifi_obytes - interesting->ift_ob,
+                           ifmd.ifmd_data.ifi_collisions - interesting->ift_co);
                        if (dflag)
-                               printf(" %5u", ifnet.if_snd.ifq_drops - ip->ift_dr);
-               }
-               ip->ift_ip = ifnet.if_ipackets;
-               ip->ift_ie = ifnet.if_ierrors;
-               ip->ift_ib = ifnet.if_ibytes;
-               ip->ift_op = ifnet.if_opackets;
-               ip->ift_oe = ifnet.if_oerrors;
-               ip->ift_ob = ifnet.if_obytes;
-               ip->ift_co = ifnet.if_collisions;
-               ip->ift_dr = ifnet.if_snd.ifq_drops;
+                               printf(" %5llu",
+                                   ifmd.ifmd_snd_drops - interesting->ift_dr);
+                       switch (prioflag) {
+                       case SO_TC_BE:
+                               printf(" %10llu %10llu",
+                                   ifmsupp.ifmd_traffic_class.ifi_obepackets -
+                                   interesting->ift_otcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_obebytes -
+                                   interesting->ift_otcb);
+                               break;
+                       case SO_TC_BK:
+                               printf(" %10llu %10llu",
+                                   ifmsupp.ifmd_traffic_class.ifi_obkpackets -
+                                   interesting->ift_otcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_obkbytes -
+                                   interesting->ift_otcb);
+                               break;
+                       case SO_TC_VI:
+                               printf(" %10llu %10llu",
+                                   ifmsupp.ifmd_traffic_class.ifi_ovipackets -
+                                   interesting->ift_otcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ovibytes -
+                                   interesting->ift_otcb);
+                               break;
+                       case SO_TC_VO:
+                               printf(" %10llu %10llu",
+                                   ifmsupp.ifmd_traffic_class.ifi_ovopackets -
+                                   interesting->ift_otcp,
+                                   ifmsupp.ifmd_traffic_class.ifi_ovobytes -
+                                   interesting->ift_otcb);
+                               break;
+                       default:
+                               break;
+                       }
+                       if (prioflag >= 0) {
+                               printf("%10llu %10llu ",
+                                   ifmsupp.ifmd_traffic_class.ifi_opvpackets -
+                                   interesting->ift_opvp,
+                                   ifmsupp.ifmd_traffic_class.ifi_opvbytes -
+                                   interesting->ift_opvb);
+                       }
+                       if (Fflag) {
+                               printf("%10llu %10llu",
+                                   ifmsupp.ifmd_data_extended.ifi_fpackets -
+                                   interesting->ift_fp,
+                                   ifmsupp.ifmd_data_extended.ifi_fbytes -
+                                   interesting->ift_fb);
+                       }
+               }
+               interesting->ift_ip = ifmd.ifmd_data.ifi_ipackets;
+               interesting->ift_ie = ifmd.ifmd_data.ifi_ierrors;
+               interesting->ift_ib = ifmd.ifmd_data.ifi_ibytes;
+               interesting->ift_op = ifmd.ifmd_data.ifi_opackets;
+               interesting->ift_oe = ifmd.ifmd_data.ifi_oerrors;
+               interesting->ift_ob = ifmd.ifmd_data.ifi_obytes;
+               interesting->ift_co = ifmd.ifmd_data.ifi_collisions;
+               interesting->ift_dr = ifmd.ifmd_snd_drops;
+
+               /* private counters */
+               switch (prioflag) {
+               case SO_TC_BE:
+                       interesting->ift_itcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ibepackets;
+                       interesting->ift_itcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ibebytes;
+                       interesting->ift_otcp =
+                           ifmsupp.ifmd_traffic_class.ifi_obepackets;
+                       interesting->ift_otcb =
+                           ifmsupp.ifmd_traffic_class.ifi_obebytes;
+                       break;
+               case SO_TC_BK:
+                       interesting->ift_itcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ibkpackets;
+                       interesting->ift_itcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ibkbytes;
+                       interesting->ift_otcp =
+                           ifmsupp.ifmd_traffic_class.ifi_obkpackets;
+                       interesting->ift_otcb =
+                           ifmsupp.ifmd_traffic_class.ifi_obkbytes;
+                       break;
+               case SO_TC_VI:
+                       interesting->ift_itcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ivipackets;
+                       interesting->ift_itcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ivibytes;
+                       interesting->ift_otcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ovipackets;
+                       interesting->ift_otcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ovibytes;
+                       break;
+               case SO_TC_VO:
+                       interesting->ift_itcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ivopackets;
+                       interesting->ift_itcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ivobytes;
+                       interesting->ift_otcp =
+                           ifmsupp.ifmd_traffic_class.ifi_ovopackets;
+                       interesting->ift_otcb =
+                           ifmsupp.ifmd_traffic_class.ifi_ovobytes;
+                       break;
+               default:
+                       break;
+               }
+               if (prioflag >= 0) {
+                       interesting->ift_ipvp =
+                           ifmsupp.ifmd_traffic_class.ifi_ipvpackets;
+                       interesting->ift_ipvb =
+                           ifmsupp.ifmd_traffic_class.ifi_ipvbytes;
+                       interesting->ift_opvp =
+                           ifmsupp.ifmd_traffic_class.ifi_opvpackets;
+                       interesting->ift_opvb =
+                           ifmsupp.ifmd_traffic_class.ifi_opvbytes;
+               }
+               interesting->ift_fp = ifmsupp.ifmd_data_extended.ifi_fpackets;
+               interesting->ift_fb = ifmsupp.ifmd_data_extended.ifi_fbytes;
        } else {
+               unsigned int latest_ifcount;
+               struct ifmibdata_supplemental *ifmsuppall = NULL;
+
+               len = sizeof(int);
+               name[3] = IFMIB_SYSTEM;
+               name[4] = IFMIB_IFCOUNT;
+               if (sysctl(name, 5, &latest_ifcount, &len, 0, 0) == 1)
+                       err(1, "sysctl IFMIB_IFCOUNT");
+               if (latest_ifcount > ifcount) {
+                       ifcount = latest_ifcount;
+                       len = ifcount * sizeof(struct ifmibdata);
+                       free(ifmdall);
+                       ifmdall = malloc(len);
+                       if (ifmdall == 0)
+                               err(1, "malloc ifmdall failed");
+               } else if (latest_ifcount > ifcount) {
+                       ifcount = latest_ifcount;
+                       len = ifcount * sizeof(struct ifmibdata);
+               }
+               len = ifcount * sizeof(struct ifmibdata);
+               name[3] = IFMIB_IFALLDATA;
+               name[4] = 0;
+               name[5] = IFDATA_GENERAL;
+               if (sysctl(name, 6, ifmdall, &len, (void *)0, 0) == -1)
+                       err(1, "sysctl IFMIB_IFALLDATA");
+
+               len = ifcount * sizeof(struct ifmibdata_supplemental);
+               ifmsuppall = malloc(len);
+               if (ifmsuppall == NULL)
+                       err(1, "malloc ifmsuppall failed");
+               name[3] = IFMIB_IFALLDATA;
+               name[4] = 0;
+               name[5] = IFDATA_SUPPLEMENTAL;
+               if (sysctl(name, 6, ifmsuppall, &len, (void *)0, 0) == -1)
+                       err(1, "sysctl IFMIB_IFALLDATA SUPPLEMENTAL");
+
                sum->ift_ip = 0;
                sum->ift_ie = 0;
                sum->ift_ib = 0;
@@ -619,47 +971,112 @@ loop:
                sum->ift_ob = 0;
                sum->ift_co = 0;
                sum->ift_dr = 0;
-               for (off = firstifnet, ip = iftot;
-                    off && SLIST_NEXT(ip, chain) != NULL;
-                    ip = SLIST_NEXT(ip, chain)) {
-                       if (kread(off, (char *)&ifnet, sizeof ifnet)) {
-                               off = 0;
-                               continue;
+               sum->ift_itcp = 0;
+               sum->ift_itcb = 0;
+               sum->ift_otcp = 0;
+               sum->ift_otcb = 0;
+               sum->ift_ipvp = 0;
+               sum->ift_ipvb = 0;
+               sum->ift_opvp = 0;
+               sum->ift_opvb = 0;
+               sum->ift_fp = 0;
+               sum->ift_fb = 0;
+               for (i = 0; i < ifcount; i++) {
+                       struct ifmibdata *ifmd = ifmdall + i;
+                       struct ifmibdata_supplemental *ifmsupp = ifmsuppall + i;
+
+                       sum->ift_ip += ifmd->ifmd_data.ifi_ipackets;
+                       sum->ift_ie += ifmd->ifmd_data.ifi_ierrors;
+                       sum->ift_ib += ifmd->ifmd_data.ifi_ibytes;
+                       sum->ift_op += ifmd->ifmd_data.ifi_opackets;
+                       sum->ift_oe += ifmd->ifmd_data.ifi_oerrors;
+                       sum->ift_ob += ifmd->ifmd_data.ifi_obytes;
+                       sum->ift_co += ifmd->ifmd_data.ifi_collisions;
+                       sum->ift_dr += ifmd->ifmd_snd_drops;
+                       /* private counters */
+                       if (prioflag >= 0) {
+                               switch (prioflag) {
+                               case SO_TC_BE:
+                                       sum->ift_itcp += ifmsupp->ifmd_traffic_class.ifi_ibepackets;
+                                       sum->ift_itcb += ifmsupp->ifmd_traffic_class.ifi_ibebytes;
+                                       sum->ift_otcp += ifmsupp->ifmd_traffic_class.ifi_obepackets;
+                                       sum->ift_otcb += ifmsupp->ifmd_traffic_class.ifi_obebytes;
+                                       break;
+                               case SO_TC_BK:
+                                       sum->ift_itcp += ifmsupp->ifmd_traffic_class.ifi_ibkpackets;
+                                       sum->ift_itcb += ifmsupp->ifmd_traffic_class.ifi_ibkbytes;
+                                       sum->ift_otcp += ifmsupp->ifmd_traffic_class.ifi_obkpackets;
+                                       sum->ift_otcb += ifmsupp->ifmd_traffic_class.ifi_obkbytes;
+                                       break;
+                               case SO_TC_VI:
+                                       sum->ift_itcp += ifmsupp->ifmd_traffic_class.ifi_ivipackets;
+                                       sum->ift_itcb += ifmsupp->ifmd_traffic_class.ifi_ivibytes;
+                                       sum->ift_otcp += ifmsupp->ifmd_traffic_class.ifi_ovipackets;
+                                       sum->ift_otcb += ifmsupp->ifmd_traffic_class.ifi_ovibytes;
+                                       break;
+                               case SO_TC_VO:
+                                       sum->ift_itcp += ifmsupp->ifmd_traffic_class.ifi_ivopackets;
+                                       sum->ift_itcb += ifmsupp->ifmd_traffic_class.ifi_ivobytes;
+                                       sum->ift_otcp += ifmsupp->ifmd_traffic_class.ifi_ovopackets;
+                                       sum->ift_otcb += ifmsupp->ifmd_traffic_class.ifi_ovobytes;
+                                       break;
+                               default:
+                                       break;
+                               }
+                               sum->ift_ipvp += ifmsupp->ifmd_traffic_class.ifi_ipvpackets;
+                               sum->ift_ipvb += ifmsupp->ifmd_traffic_class.ifi_ipvbytes;
+                               sum->ift_opvp += ifmsupp->ifmd_traffic_class.ifi_opvpackets;
+                               sum->ift_opvb += ifmsupp->ifmd_traffic_class.ifi_opvbytes;
                        }
-                       sum->ift_ip += ifnet.if_ipackets;
-                       sum->ift_ie += ifnet.if_ierrors;
-                       sum->ift_ib += ifnet.if_ibytes;
-                       sum->ift_op += ifnet.if_opackets;
-                       sum->ift_oe += ifnet.if_oerrors;
-                       sum->ift_ob += ifnet.if_obytes;
-                       sum->ift_co += ifnet.if_collisions;
-                       sum->ift_dr += ifnet.if_snd.ifq_drops;
-                       off = (u_long)TAILQ_NEXT(&ifnet, if_link);
+                       sum->ift_fp += ifmsupp->ifmd_data_extended.ifi_fpackets;
+                       sum->ift_fb += ifmsupp->ifmd_data_extended.ifi_fbytes;
                }
                if (!first) {
-                       printf("%10lu %5lu %10lu %10lu %5lu %10lu %5lu",
+                       printf("%10llu %5llu %10llu ",
                                sum->ift_ip - total->ift_ip,
                                sum->ift_ie - total->ift_ie,
-                               sum->ift_ib - total->ift_ib,
+                               sum->ift_ib - total->ift_ib);
+                       if (prioflag >= 0)
+                               printf(" %10llu %10llu %10llu %10llu",
+                                   sum->ift_itcp - total->ift_itcp,
+                                   sum->ift_itcb - total->ift_itcb,
+                                   sum->ift_ipvp - total->ift_ipvp,
+                                   sum->ift_ipvb - total->ift_ipvb);
+                       printf("%10llu %5llu %10llu %5llu",
                                sum->ift_op - total->ift_op,
                                sum->ift_oe - total->ift_oe,
                                sum->ift_ob - total->ift_ob,
                                sum->ift_co - total->ift_co);
                        if (dflag)
-                               printf(" %5u", sum->ift_dr - total->ift_dr);
+                               printf(" %5llu", sum->ift_dr - total->ift_dr);
+                       if (prioflag >= 0)
+                               printf(" %10llu %10llu %10llu %10llu",
+                                   sum->ift_otcp - total->ift_otcp,
+                                   sum->ift_otcb - total->ift_otcb,
+                                   sum->ift_opvp - total->ift_opvp,
+                                   sum->ift_opvb - total->ift_opvb);
+                       if (Fflag)
+                               printf(" %10llu %10llu",
+                                   sum->ift_fp - total->ift_fp,
+                                   sum->ift_fb - total->ift_fb);
                }
                *total = *sum;
+
+               free(ifmsuppall);
        }
        if (!first)
                putchar('\n');
        fflush(stdout);
-       oldmask = sigblock(sigmask(SIGALRM));
-       if (! signalled) {
-               sigpause(0);
+       sigemptyset(&sigset);
+       sigaddset(&sigset, SIGALRM);
+       (void)sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+       if (!signalled) {
+           sigemptyset(&sigset);
+           sigsuspend(&sigset);
        }
-       sigsetmask(oldmask);
+       (void)sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+
        signalled = NO;
-       (void)alarm(interval);
        line++;
        first = 0;
        if (line == 21)
@@ -669,6 +1086,37 @@ loop:
        /*NOTREACHED*/
 }
 
+void
+intervalpr(void (*pr)(uint32_t, char *, int), uint32_t off, char *name , int af)
+{
+       struct itimerval timer_interval;
+       sigset_t sigset, oldsigset;
+
+       /* create a timer that fires repeatedly every interval seconds */
+       timer_interval.it_value.tv_sec = interval;
+       timer_interval.it_value.tv_usec = 0;
+       timer_interval.it_interval.tv_sec = interval;
+       timer_interval.it_interval.tv_usec = 0;
+       (void) signal(SIGALRM, catchalarm);
+       signalled = NO;
+       (void) setitimer(ITIMER_REAL, &timer_interval, NULL);
+
+       for (;;) {
+               pr(off, name, af);
+
+               fflush(stdout);
+               sigemptyset(&sigset);
+               sigaddset(&sigset, SIGALRM);
+               (void) sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+               if (!signalled) {
+                       sigemptyset(&sigset);
+                       sigsuspend(&sigset);
+               }
+               (void) sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+               signalled = NO;
+       }
+}
+
 /*
  * Called if an interval expires before sidewaysintpr has completed a loop.
  * Sets a flag to not wait for the alarm.
@@ -678,3 +1126,1134 @@ catchalarm(int signo )
 {
        signalled = YES;
 }
+
+static char *
+sec2str(total)
+       time_t total;
+{
+       static char result[256];
+       int days, hours, mins, secs;
+       int first = 1;
+       char *p = result;
+
+       days = total / 3600 / 24;
+       hours = (total / 3600) % 24;
+       mins = (total / 60) % 60;
+       secs = total % 60;
+
+       if (days) {
+               first = 0;
+               p += snprintf(p, sizeof(result) - (p - result), "%dd", days);
+       }
+       if (!first || hours) {
+               first = 0;
+               p += snprintf(p, sizeof(result) - (p - result), "%dh", hours);
+       }
+       if (!first || mins) {
+               first = 0;
+               p += snprintf(p, sizeof(result) - (p - result), "%dm", mins);
+       }
+       snprintf(p, sizeof(result) - (p - result), "%ds", secs);
+
+       return(result);
+}
+
+void
+intpr_ri(void (*pfunc)(char *))
+{
+       int mib[6];
+       char *buf = NULL, *lim, *next;
+       size_t len;
+       unsigned int ifindex = 0;
+       struct if_msghdr2 *if2m;
+
+       if (interface != 0) {
+               ifindex = if_nametoindex(interface);
+               if (ifindex == 0) {
+                       printf("interface name is not valid: %s\n", interface);
+                       exit(1);
+               }
+       }
+
+       mib[0]  = CTL_NET;              /* networking subsystem */
+       mib[1]  = PF_ROUTE;             /* type of information */
+       mib[2]  = 0;                    /* protocol (IPPROTO_xxx) */
+       mib[3]  = 0;                    /* address family */
+       mib[4]  = NET_RT_IFLIST2;       /* operation */
+       mib[5]  = 0;
+       if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
+               return;
+       if ((buf = malloc(len)) == NULL) {
+               printf("malloc failed\n");
+               exit(1);
+       }
+       if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
+               free(buf);
+               return;
+       }
+
+       printf("%-6s %-17s %8.8s %-9.9s %4s %4s",
+              "Proto", "Linklayer Address", "Netif", "Expire", "Refs",
+              "Prbs");
+       if (xflag)
+               printf(" %7s %7s %7s", "RSSI", "LQM", "NPM");
+       printf("\n");
+
+       lim = buf + len;
+       if2m = (struct if_msghdr2 *)buf;
+
+       for (next = buf; next < lim; ) {
+               if2m = (struct if_msghdr2 *)next;
+               next += if2m->ifm_msglen;
+
+               if (if2m->ifm_type != RTM_IFINFO2)
+                       continue;
+               else if (interface != 0 && if2m->ifm_index != ifindex)
+                       continue;
+
+               llreach_sysctl(if2m->ifm_index);
+       }
+       free(buf);
+}
+
+static void
+llreach_sysctl(uint32_t ifindex)
+{
+#define        MAX_SYSCTL_TRY  5
+       int mib[6], i, ntry = 0;
+       size_t mibsize, len, needed, cnt;
+       struct if_llreach_info *lri;
+       struct timeval time;
+       char *buf;
+       char ifname[IF_NAMESIZE];
+
+       bzero(&mib, sizeof (mib));
+       mibsize = sizeof (mib) / sizeof (mib[0]);
+       if (sysctlnametomib("net.link.generic.system.llreach_info", mib,
+           &mibsize) == -1) {
+               perror("sysctlnametomib");
+               return;
+       }
+
+       needed = 0;
+       mib[5] = ifindex;
+
+       mibsize = sizeof (mib) / sizeof (mib[0]);
+       do {
+               if (sysctl(mib, mibsize, NULL, &needed, NULL, 0) == -1) {
+                       perror("sysctl net.link.generic.system.llreach_info");
+                       return;
+               }
+               if ((buf = malloc(needed)) == NULL) {
+                       perror("malloc");
+                       return;
+               }
+               if (sysctl(mib, mibsize, buf, &needed, NULL, 0) == -1) {
+                       if (errno != ENOMEM || ++ntry >= MAX_SYSCTL_TRY) {
+                               perror("sysctl");
+                               goto out_free;
+                       }
+                       free(buf);
+                       buf = NULL;
+               }
+       } while (buf == NULL);
+
+       len = needed;
+       cnt = len / sizeof (*lri);
+       lri = (struct if_llreach_info *)buf;
+
+       gettimeofday(&time, 0);
+       if (if_indextoname(ifindex, ifname) == NULL)
+               snprintf(ifname, sizeof (ifname), "%s", "?");
+
+       for (i = 0; i < cnt; i++, lri++) {
+               printf("0x%-4x %-17s %8.8s ", lri->lri_proto,
+                   ether_ntoa((struct ether_addr *)lri->lri_addr), ifname);
+
+               if (lri->lri_expire > time.tv_sec)
+                       printf("%-9.9s", sec2str(lri->lri_expire - time.tv_sec));
+               else if (lri->lri_expire == 0)
+                       printf("%-9.9s", "permanent");
+               else
+                       printf("%-9.9s", "expired");
+
+               printf(" %4d", lri->lri_refcnt);
+               if (lri->lri_probes)
+                       printf(" %4d", lri->lri_probes);
+
+               if (xflag) {
+                       if (!lri->lri_probes)
+                               printf(" %-4.4s", "none");
+
+                       if (lri->lri_rssi != IFNET_RSSI_UNKNOWN)
+                               printf(" %7d", lri->lri_rssi);
+                       else
+                               printf(" %-7.7s", "unknown");
+
+                       switch (lri->lri_lqm)
+                       {
+                       case IFNET_LQM_THRESH_OFF:
+                               printf(" %-7.7s", "off");
+                               break;
+                       case IFNET_LQM_THRESH_UNKNOWN:
+                               printf(" %-7.7s", "unknown");
+                               break;
+                       case IFNET_LQM_THRESH_POOR:
+                               printf(" %-7.7s", "poor");
+                               break;
+                       case IFNET_LQM_THRESH_GOOD:
+                               printf(" %-7.7s", "good");
+                               break;
+                       default:
+                               printf(" %7d", lri->lri_lqm);
+                               break;
+                       }
+
+                       switch (lri->lri_npm)
+                       {
+                       case IFNET_NPM_THRESH_UNKNOWN:
+                               printf(" %-7.7s", "unknown");
+                               break;
+                       case IFNET_NPM_THRESH_NEAR:
+                               printf(" %-7.7s", "near");
+                               break;
+                       case IFNET_NPM_THRESH_GENERAL:
+                               printf(" %-7.7s", "general");
+                               break;
+                       case IFNET_NPM_THRESH_FAR:
+                               printf(" %-7.7s", "far");
+                               break;
+                       default:
+                               printf(" %7d", lri->lri_npm);
+                               break;
+                       }
+               }
+
+               printf("\n");
+               len -= sizeof (*lri);
+       }
+
+       if (len > 0) {
+               fprintf(stderr, "warning: %u trailing bytes from %s\n",
+                   (unsigned int)len, "net.link.generic.system.llreach_info");
+       }
+
+out_free:
+       free(buf);
+#undef MAX_SYSCTL_TRY
+}
+
+void
+aqstatpr(void)
+{
+       unsigned int ifindex;
+       struct itimerval timer_interval;
+       struct if_qstatsreq ifqr;
+       struct if_ifclassq_stats *ifcqs;
+       sigset_t sigset, oldsigset;
+       u_int32_t scheduler;
+       int s, n;
+
+       if (cq < -1 || cq >= IFCQ_SC_MAX) {
+               fprintf(stderr, "Invalid classq index (range is 0-%d)\n",
+                    IFCQ_SC_MAX-1);
+               return;
+       }
+       ifindex = if_nametoindex(interface);
+       if (ifindex == 0) {
+               fprintf(stderr, "Invalid interface name\n");
+               return;
+       }
+
+       ifcqs = malloc(sizeof (*ifcqs));
+       if (ifcqs == NULL) {
+               fprintf(stderr, "Unable to allocate memory\n");
+               return;
+       }
+
+       if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+               perror("Warning: socket(AF_INET)");
+               free(ifcqs);
+               return;
+       }
+
+       bzero(&ifqr, sizeof (ifqr));
+       strlcpy(ifqr.ifqr_name, interface, sizeof (ifqr.ifqr_name));
+       ifqr.ifqr_buf = ifcqs;
+       ifqr.ifqr_len = sizeof (*ifcqs);
+
+loop:
+       if (interval > 0) {
+               /* create a timer that fires repeatedly every interval seconds */
+               timer_interval.it_value.tv_sec = interval;
+               timer_interval.it_value.tv_usec = 0;
+               timer_interval.it_interval.tv_sec = interval;
+               timer_interval.it_interval.tv_usec = 0;
+               (void) signal(SIGALRM, catchalarm);
+               signalled = NO;
+               (void) setitimer(ITIMER_REAL, &timer_interval, NULL);
+       }
+
+       ifqr.ifqr_slot = 0;
+       if (ioctl(s, SIOCGIFQUEUESTATS, (char *)&ifqr) < 0) {
+               if (errno == ENXIO) {
+                       printf("Queue statistics are not available on %s\n",
+                           interface);
+               } else {
+                       perror("Warning: ioctl(SIOCGIFQUEUESTATS)");
+               }
+               goto done;
+       }
+       scheduler = ifcqs->ifqs_scheduler;
+
+       printf("%s:\n"
+           "     [ sched: %9s  qlength:  %3d/%3d ]\n",
+           interface, sched2str(ifcqs->ifqs_scheduler),
+           ifcqs->ifqs_len, ifcqs->ifqs_maxlen);
+       printf("     [ pkts: %10llu  bytes: %10llu "
+           " dropped pkts: %6llu bytes: %6llu ]\n",
+           ifcqs->ifqs_xmitcnt.packets, ifcqs->ifqs_xmitcnt.bytes,
+           ifcqs->ifqs_dropcnt.packets, ifcqs->ifqs_dropcnt.bytes);
+
+       for (n = 0; n < IFCQ_SC_MAX && scheduler != PKTSCHEDT_NONE; n++) {
+               if (cq >= 0 && cq != n)
+                       continue;
+
+               ifqr.ifqr_slot = n;
+               if (ioctl(s, SIOCGIFQUEUESTATS, (char *)&ifqr) < 0) {
+                       perror("Warning: ioctl(SIOCGIFQUEUESTATS)");
+                       goto done;
+               }
+
+               update_avg(ifcqs, &qstats[n]);
+
+               switch (scheduler) {
+                       case PKTSCHEDT_FQ_CODEL:
+                               print_fq_codel_stats(n,
+                                   &ifcqs->ifqs_fq_codel_stats,
+                                   &qstats[n]);
+                               break;
+                       case PKTSCHEDT_NONE:
+                       default:
+                               break;
+               }
+       }
+
+       fflush(stdout);
+
+       if (interval > 0) {
+               sigemptyset(&sigset);
+               sigaddset(&sigset, SIGALRM);
+               (void) sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+               if (!signalled) {
+                       sigemptyset(&sigset);
+                       sigsuspend(&sigset);
+               }
+               (void) sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+
+               signalled = NO;
+               goto loop;
+       }
+
+done:
+       free(ifcqs);
+       close(s);
+}
+
+static void
+print_fq_codel_stats(int pri, struct fq_codel_classstats *fqst,
+    struct queue_stats *qs)
+{
+       int i = 0;
+
+       if (fqst->fcls_service_class == 0 && fqst->fcls_pri == 0)
+               return;
+       printf("=====================================================\n");
+       printf("     [ pri: %s (%d)\tsrv_cl: 0x%x\tquantum: %d\tdrr_max: %d ]\n",
+           pri2str(fqst->fcls_pri), fqst->fcls_pri,
+           fqst->fcls_service_class, fqst->fcls_quantum,
+           fqst->fcls_drr_max);
+       printf("     [ queued pkts: %llu\tbytes: %llu ]\n",
+           fqst->fcls_pkt_cnt, fqst->fcls_byte_cnt);
+       printf("     [ dequeued pkts: %llu\tbytes: %llu ]\n",
+           fqst->fcls_dequeue, fqst->fcls_dequeue_bytes);
+       printf("     [ budget: %lld\ttarget qdelay: %10s\t",
+           fqst->fcls_budget, nsec_to_str(fqst->fcls_target_qdelay));
+       printf("update interval:%10s ]\n",
+           nsec_to_str(fqst->fcls_update_interval));
+       printf("     [ flow control: %u\tfeedback: %u\tstalls: %u\tfailed: %u ]\n",
+           fqst->fcls_flow_control, fqst->fcls_flow_feedback,
+           fqst->fcls_dequeue_stall, fqst->fcls_flow_control_fail);
+       printf("     [ drop overflow: %llu\tearly: %llu\tmemfail: %u\tduprexmt:%u ]\n",
+           fqst->fcls_drop_overflow, fqst->fcls_drop_early,
+           fqst->fcls_drop_memfailure, fqst->fcls_dup_rexmts);
+       printf("     [ flows total: %u\tnew: %u\told: %u ]\n",
+           fqst->fcls_flows_cnt,
+           fqst->fcls_newflows_cnt, fqst->fcls_oldflows_cnt);
+       printf("     [ throttle on: %u\toff: %u\tdrop: %u ]\n",
+           fqst->fcls_throttle_on, fqst->fcls_throttle_off,
+           fqst->fcls_throttle_drops);
+       printf("     [ compressible pkts: %u compressed pkts: %u]\n",
+           fqst->fcls_pkts_compressible, fqst->fcls_pkts_compressed);
+
+       if (qflag < 2)
+               return;
+
+       if (fqst->fcls_flowstats_cnt > 0) {
+               printf("Flowhash\tBytes\tMin qdelay\tFlags\t\n");
+               for (i = 0; i < fqst->fcls_flowstats_cnt; i++) {
+                       printf("%u\t%u\t%14s\t",
+                           fqst->fcls_flowstats[i].fqst_flowhash,
+                           fqst->fcls_flowstats[i].fqst_bytes,
+                           nsec_to_str(fqst->fcls_flowstats[i].fqst_min_qdelay));
+                       if (fqst->fcls_flowstats[i].fqst_flags &
+                           FQ_FLOWSTATS_OLD_FLOW)
+                               printf("O");
+                       if (fqst->fcls_flowstats[i].fqst_flags &
+                           FQ_FLOWSTATS_NEW_FLOW)
+                               printf("N");
+                       if (fqst->fcls_flowstats[i].fqst_flags &
+                           FQ_FLOWSTATS_LARGE_FLOW)
+                               printf("L");
+                       if (fqst->fcls_flowstats[i].fqst_flags &
+                           FQ_FLOWSTATS_DELAY_HIGH)
+                               printf("D");
+                       if (fqst->fcls_flowstats[i].fqst_flags &
+                           FQ_FLOWSTATS_FLOWCTL_ON)
+                               printf("F");
+                       printf("\n");
+               }
+       }
+}
+
+static void
+update_avg(struct if_ifclassq_stats *ifcqs, struct queue_stats *qs)
+{
+       u_int64_t                b, p;
+       int                      n;
+
+       n = qs->avgn;
+
+       switch (ifcqs->ifqs_scheduler) {
+       case PKTSCHEDT_FQ_CODEL:
+               b = ifcqs->ifqs_fq_codel_stats.fcls_dequeue_bytes;
+               p = ifcqs->ifqs_fq_codel_stats.fcls_dequeue;
+               break;
+       default:
+               b = 0;
+               p = 0;
+               break;
+       }
+
+       if (n == 0) {
+               qs->prev_bytes = b;
+               qs->prev_packets = p;
+               qs->avgn++;
+               return;
+       }
+
+       if (b >= qs->prev_bytes)
+               qs->avg_bytes = ((qs->avg_bytes * (n - 1)) +
+                   (b - qs->prev_bytes)) / n;
+
+       if (p >= qs->prev_packets)
+               qs->avg_packets = ((qs->avg_packets * (n - 1)) +
+                   (p - qs->prev_packets)) / n;
+
+       qs->prev_bytes = b;
+       qs->prev_packets = p;
+       if (n < AVGN_MAX)
+               qs->avgn++;
+}
+
+#define NSEC_PER_SEC    1000000000      /* nanoseconds per second */
+#define USEC_PER_SEC    1000000                /* microseconds per second */
+#define MSEC_PER_SEC    1000           /* milliseconds per second */
+
+static char *
+nsec_to_str(unsigned long long nsec)
+{
+       static char buf[32];
+       const char *u;
+       long double n = nsec, t;
+
+       if (nsec >= NSEC_PER_SEC) {
+               t = n / NSEC_PER_SEC;
+               u = "sec ";
+       } else if (n >= USEC_PER_SEC) {
+               t = n / USEC_PER_SEC;
+               u = "msec";
+       } else if (n >= MSEC_PER_SEC) {
+               t = n / MSEC_PER_SEC;
+               u = "usec";
+       } else {
+               t = n;
+               u = "nsec";
+       }
+
+       snprintf(buf, sizeof (buf), "%-4.2Lf %4s", t, u);
+       return (buf);
+}
+
+static char *
+sched2str(unsigned int s)
+{
+       char *c;
+
+       switch (s) {
+       case PKTSCHEDT_NONE:
+               c = "NONE";
+               break;
+       case PKTSCHEDT_FQ_CODEL:
+               c = "FQ_CODEL";
+               break;
+       default:
+               c = "UNKNOWN";
+               break;
+       }
+
+       return (c);
+}
+
+static char *
+pri2str(unsigned int i)
+{
+       char *c;
+       switch (i) {
+       case 9:
+               c = "BK_SYS";
+               break;
+       case 8:
+               c = "BK";
+               break;
+       case 7:
+               c = "BE";
+               break;
+       case 6:
+               c = "RD";
+               break;
+       case 5:
+               c = "OAM";
+               break;
+       case 4:
+               c = "AV";
+               break;
+       case 3:
+               c = "RV";
+               break;
+       case 2:
+               c = "VI";
+               break;
+       case 1:
+               c = "VO";
+               break;
+       case 0:
+               c = "CTL";
+               break;
+       default:
+               c = "?";
+               break;
+       }
+       return (c);
+}
+
+void
+rxpollstatpr(void)
+{
+       struct ifmibdata_supplemental ifmsupp;
+       size_t miblen = sizeof (ifmsupp);
+       struct itimerval timer_interval;
+       struct if_rxpoll_stats *sp;
+       struct if_netif_stats *np;
+       sigset_t sigset, oldsigset;
+       unsigned int ifindex;
+       int name[6];
+
+       ifindex = if_nametoindex(interface);
+       if (ifindex == 0) {
+               fprintf(stderr, "Invalid interface name\n");
+               return;
+       }
+
+       bzero(&ifmsupp, sizeof (struct ifmibdata_supplemental));
+
+loop:
+       if (interval > 0) {
+               /* create a timer that fires repeatedly every interval seconds */
+               timer_interval.it_value.tv_sec = interval;
+               timer_interval.it_value.tv_usec = 0;
+               timer_interval.it_interval.tv_sec = interval;
+               timer_interval.it_interval.tv_usec = 0;
+               (void) signal(SIGALRM, catchalarm);
+               signalled = NO;
+               (void) setitimer(ITIMER_REAL, &timer_interval, NULL);
+       }
+
+       /* Common OID prefix */
+       name[0] = CTL_NET;
+       name[1] = PF_LINK;
+       name[2] = NETLINK_GENERIC;
+       name[3] = IFMIB_IFDATA;
+       name[4] = ifindex;
+       name[5] = IFDATA_SUPPLEMENTAL;
+       if (sysctl(name, 6, &ifmsupp, &miblen, NULL, 0) == -1)
+               err(1, "sysctl IFDATA_SUPPLEMENTAL");
+
+       sp = &ifmsupp.ifmd_rxpoll_stats;
+
+       printf("%-4s [ poll on requests:  %15u  errors: %27u ]\n",
+           interface, sp->ifi_poll_on_req, sp->ifi_poll_on_err);
+       printf("     [ poll off requests: %15u  errors: %27u ]\n",
+           sp->ifi_poll_off_req, sp->ifi_poll_off_err);
+       printf("     [ polled packets: %18llu  per poll limit: %19u ]\n",
+           sp->ifi_poll_packets, sp->ifi_poll_packets_limit);
+       printf("     [ polled bytes: %20llu ]\n", sp->ifi_poll_bytes);
+       printf("     [ poll interval: %14llu nsec ]\n",
+           sp->ifi_poll_interval_time);
+       printf("     [ sampled packets avg/min/max: %12u / %12u / %12u ]\n",
+           sp->ifi_poll_packets_avg, sp->ifi_poll_packets_min,
+           sp->ifi_poll_packets_max);
+       printf("     [ sampled bytes avg/min/max:   %12u / %12u / %12u ]\n",
+           sp->ifi_poll_bytes_avg, sp->ifi_poll_bytes_min,
+           sp->ifi_poll_bytes_max);
+       printf("     [ sampled wakeups avg:         %12u ]\n",
+           sp->ifi_poll_wakeups_avg);
+       printf("     [ packets lowat/hiwat threshold: %10u / %10u ]\n",
+           sp->ifi_poll_packets_lowat, sp->ifi_poll_packets_hiwat);
+       printf("     [ bytes lowat/hiwat threshold:   %10u / %10u ]\n",
+           sp->ifi_poll_bytes_lowat, sp->ifi_poll_bytes_hiwat);
+       printf("     [ wakeups lowat/hiwat threshold: %10u / %10u ]\n",
+           sp->ifi_poll_wakeups_lowat, sp->ifi_poll_wakeups_hiwat);
+
+       np = &ifmsupp.ifmd_netif_stats;
+       printf("     [ mit mode: %24U  cfg idx: %26u ]\n",
+           np->ifn_rx_mit_mode, np->ifn_rx_mit_cfg_idx);
+       printf("     [ cfg packets lo/hi threshold: %12u / %12u ]\n",
+           np->ifn_rx_mit_cfg_packets_lowat, np->ifn_rx_mit_cfg_packets_hiwat);
+       printf("     [ cfg bytes lo/hi threshold:   %12u / %12u ]\n",
+           np->ifn_rx_mit_cfg_bytes_lowat, np->ifn_rx_mit_cfg_bytes_hiwat);
+       printf("     [ cfg interval: %15u nsec ]\n",
+           np->ifn_rx_mit_cfg_interval);
+       printf("     [ mit interval: %15llu nsec ]\n",
+           np->ifn_rx_mit_interval);
+       printf("     [ mit packets avg/min/max:    %12u / %12u / %12u ]\n",
+           np->ifn_rx_mit_packets_avg, np->ifn_rx_mit_packets_min,
+           np->ifn_rx_mit_packets_max);
+       printf("     [ mit bytes avg/min/max:      %12u / %12u / %12u ]\n",
+           np->ifn_rx_mit_bytes_avg, np->ifn_rx_mit_bytes_min,
+           np->ifn_rx_mit_bytes_max);
+
+       fflush(stdout);
+
+       if (interval > 0) {
+               sigemptyset(&sigset);
+               sigaddset(&sigset, SIGALRM);
+               (void) sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+               if (!signalled) {
+                       sigemptyset(&sigset);
+                       sigsuspend(&sigset);
+               }
+               (void) sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+
+               signalled = NO;
+               goto loop;
+       }
+}
+
+static int
+create_control_socket(const char *control_name)
+{
+       struct sockaddr_ctl sc;
+       struct ctl_info ctl;
+       int fd;
+
+       fd = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
+       if (fd == -1) {
+               perror("socket(PF_SYSTEM)");
+               return fd;
+       }
+
+       /* Get the control ID for statistics */
+       bzero(&ctl, sizeof(ctl));
+       strlcpy(ctl.ctl_name, control_name, sizeof(ctl.ctl_name));
+       if (ioctl(fd, CTLIOCGINFO, &ctl) == -1)
+       {
+               perror("ioctl(CTLIOCGINFO)");
+               close(fd);
+               return -1;
+       }
+
+       /* Connect to the statistics control */
+       bzero(&sc, sizeof(sc));
+       sc.sc_len = sizeof(sc);
+       sc.sc_family = AF_SYSTEM;
+       sc.ss_sysaddr = SYSPROTO_CONTROL;
+       sc.sc_id = ctl.ctl_id;
+       sc.sc_unit = 0;
+       if (connect(fd, (struct sockaddr*)&sc, sc.sc_len) != 0)
+       {
+               perror("connect(SYSPROTO_CONTROL)");
+               close(fd);
+               return -1;
+       }
+
+       /* Set socket to non-blocking operation */
+       if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1) {
+               perror("fcnt(F_SETFL,O_NONBLOCK)");
+               close(fd);
+               return -1;
+       }
+       return fd;
+}
+
+static int
+add_nstat_src(int fd, const nstat_ifnet_add_param *ifparam,
+               nstat_src_ref_t *outsrc)
+{
+       nstat_msg_add_src_req *addreq;
+       nstat_msg_src_added *addedmsg;
+       nstat_ifnet_add_param *param;
+       char buffer[sizeof(*addreq) + sizeof(*param)];
+       ssize_t result;
+       const u_int32_t addreqsize =
+               offsetof(struct nstat_msg_add_src, param) + sizeof(*param);
+
+       /* Setup the add source request */
+       addreq = (nstat_msg_add_src_req *)buffer;
+       param = (nstat_ifnet_add_param*)addreq->param;
+       bzero(addreq, addreqsize);
+       addreq->hdr.context = (uintptr_t)&buffer;
+       addreq->hdr.type = NSTAT_MSG_TYPE_ADD_SRC;
+       addreq->provider = NSTAT_PROVIDER_IFNET;
+       bzero(param, sizeof(*param));
+       param->ifindex = ifparam->ifindex;
+       param->threshold = ifparam->threshold;
+
+       /* Send the add source request */
+       result = send(fd, addreq, addreqsize, 0);
+       if (result != addreqsize)
+       {
+               if (result == -1)
+                       perror("send(NSTAT_ADD_SRC_REQ)");
+               else
+                       fprintf(stderr, "%s: could only sent %ld out of %d\n",
+                               __func__, result, addreqsize);
+               return -1;
+       }
+
+       /* Receive the response */
+       addedmsg = (nstat_msg_src_added *)buffer;
+       result = recv(fd, addedmsg, sizeof(buffer), 0);
+       if (result < sizeof(*addedmsg))
+       {
+               if (result == -1)
+                       perror("recv(NSTAT_ADD_SRC_RSP)");
+               else
+                       fprintf(stderr, "%s: recv too small, received %ld, "
+                               "expected %lu\n", __func__, result,
+                               sizeof(*addedmsg));
+               return -1;
+       }
+
+       if (addedmsg->hdr.type != NSTAT_MSG_TYPE_SRC_ADDED)
+       {
+               fprintf(stderr, "%s: received wrong message type, received %u "
+                       "expected %u\n", __func__, addedmsg->hdr.type,
+                       NSTAT_MSG_TYPE_SRC_ADDED);
+               return -1;
+       }
+
+       if (addedmsg->hdr.context != (uintptr_t)&buffer)
+       {
+               fprintf(stderr, "%s: received wrong context, received %llu "
+                       "expected %lu\n", __func__, addedmsg->hdr.context,
+                       (uintptr_t)&buffer);
+               return -1;
+       }
+       *outsrc = addedmsg->srcref;
+       return 0;
+}
+
+static int
+rem_nstat_src(int fd, nstat_src_ref_t sref)
+{
+       nstat_msg_rem_src_req *remreq;
+       nstat_msg_src_removed *remrsp;
+       char buffer[sizeof(*remreq)];
+       ssize_t result;
+
+       /* Setup the add source request */
+       remreq = (nstat_msg_rem_src_req *)buffer;
+       bzero(remreq, sizeof(*remreq));
+       remreq->hdr.type = NSTAT_MSG_TYPE_REM_SRC;
+       remreq->srcref = sref;
+
+       /* Send the remove source request */
+       result = send(fd, remreq, sizeof(*remreq), 0);
+       if (result != sizeof(*remreq)) {
+               if (result == -1)
+                       perror("send(NSTAT_REM_SRC_REQ)");
+               else
+                       fprintf(stderr, "%s: could only sent %ld out of %lu\n",
+                               __func__, result, sizeof(*remreq));
+               return -1;
+       }
+
+       /* Receive the response */
+       remrsp = (nstat_msg_src_removed *)buffer;
+       result = recv(fd, remrsp, sizeof(buffer), 0);
+       if (result < sizeof(*remrsp)) {
+               if (result == -1)
+                       perror("recv(NSTAT_REM_SRC_RSP)");
+               else
+                       fprintf(stderr, "%s: recv too small, received %ld, "
+                               "expected %lu\n", __func__, result,
+                               sizeof(*remrsp));
+               return -1;
+       }
+
+       if (remrsp->hdr.type != NSTAT_MSG_TYPE_SRC_REMOVED) {
+               fprintf(stderr, "%s: received wrong message type, received %u "
+                       "expected %u\n", __func__, remrsp->hdr.type,
+                       NSTAT_MSG_TYPE_SRC_REMOVED);
+               return -1;
+       }
+
+       if (remrsp->srcref != sref) {
+               fprintf(stderr, "%s: received invalid srcref, received %llu "
+                       "expected %llu\n", __func__, remrsp->srcref, sref);
+       }
+       return 0;
+}
+
+static int
+get_src_decsription(int fd, nstat_src_ref_t srcref,
+                       struct nstat_ifnet_descriptor *ifdesc)
+{
+       nstat_msg_get_src_description *dreq;
+       nstat_msg_src_description *drsp;
+       char buffer[sizeof(*drsp) + sizeof(*ifdesc)];
+       ssize_t result;
+       const u_int32_t descsize =
+               offsetof(struct nstat_msg_src_description, data) +
+               sizeof(nstat_ifnet_descriptor);
+
+       dreq = (nstat_msg_get_src_description *)buffer;
+       bzero(dreq, sizeof(*dreq));
+       dreq->hdr.type = NSTAT_MSG_TYPE_GET_SRC_DESC;
+       dreq->srcref = srcref;
+       result = send(fd, dreq, sizeof(*dreq), 0);
+       if (result != sizeof(*dreq))
+       {
+               if (result == -1)
+                       perror("send(NSTAT_GET_SRC_DESC_REQ)");
+               else
+                       fprintf(stderr, "%s: sent %ld out of %lu\n",
+                               __func__, result, sizeof(*dreq));
+               return -1;
+       }
+
+       /* Receive the source description response */
+       drsp = (nstat_msg_src_description *)buffer;
+       result = recv(fd, drsp, sizeof(buffer), 0);
+       if (result < descsize)
+       {
+               if (result == -1)
+                       perror("recv(NSTAT_GET_SRC_DESC_RSP");
+               else
+                       fprintf(stderr, "%s: recv too small, received %ld, "
+                               "expected %u\n", __func__, result, descsize);
+               return -1;
+       }
+
+       if (drsp->hdr.type != NSTAT_MSG_TYPE_SRC_DESC)
+       {
+               fprintf(stderr, "%s: received wrong message type, received %u "
+                       "expected %u\n", __func__, drsp->hdr.type,
+                       NSTAT_MSG_TYPE_SRC_DESC);
+               return -1;
+       }
+
+       if (drsp->srcref != srcref)
+       {
+               fprintf(stderr, "%s: received message for wrong source, "
+                       "received 0x%llx expected 0x%llx\n",
+                       __func__, drsp->srcref, srcref);
+               return -1;
+       }
+
+       bcopy(drsp->data, ifdesc, sizeof(*ifdesc));
+       return 0;
+}
+
+static void
+print_wifi_status(nstat_ifnet_desc_wifi_status *status)
+{
+       int tmp;
+#define val(x, f)      \
+       ((status->valid_bitmask & NSTAT_IFNET_DESC_WIFI_ ## f ## _VALID) ?\
+        status->x : -1)
+#define parg(n, un) #n, val(n, un)
+#define pretxtl(n, un) \
+       (((tmp = val(n, un)) == -1) ? "(not valid)" : \
+       ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_NONE) ? "(none)" : \
+       ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_LOW) ? "(low)" : \
+       ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_MEDIUM) ? "(medium)" : \
+       ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_HIGH) ? "(high)" : \
+       "(?)")))))
+
+       printf("\nwifi status:\n");
+       printf(
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t\t%d%s\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t\t%d\n",
+           parg(link_quality_metric, LINK_QUALITY_METRIC),
+           parg(ul_effective_bandwidth, UL_EFFECTIVE_BANDWIDTH),
+           parg(ul_max_bandwidth, UL_MAX_BANDWIDTH),
+           parg(ul_min_latency, UL_MIN_LATENCY),
+           parg(ul_effective_latency, UL_EFFECTIVE_LATENCY),
+           parg(ul_max_latency, UL_MAX_LATENCY),
+           parg(ul_retxt_level, UL_RETXT_LEVEL),
+           pretxtl(ul_retxt_level, UL_RETXT_LEVEL),
+           parg(ul_bytes_lost, UL_BYTES_LOST),
+           parg(ul_error_rate, UL_ERROR_RATE),
+           parg(dl_effective_bandwidth, DL_EFFECTIVE_BANDWIDTH),
+           parg(dl_max_bandwidth, DL_MAX_BANDWIDTH),
+           parg(dl_min_latency, DL_MIN_LATENCY),
+           parg(dl_effective_latency, DL_EFFECTIVE_LATENCY),
+           parg(dl_max_latency, DL_MAX_LATENCY),
+           parg(dl_error_rate, DL_ERROR_RATE),
+           parg(config_frequency, CONFIG_FREQUENCY),
+           parg(config_multicast_rate, CONFIG_MULTICAST_RATE),
+           parg(scan_count, CONFIG_SCAN_COUNT),
+           parg(scan_duration, CONFIG_SCAN_DURATION)
+           );
+#undef pretxtl
+#undef parg
+#undef val
+}
+
+static void
+print_cellular_status(nstat_ifnet_desc_cellular_status *status)
+{
+       int tmp, tmp_mss;
+#define val(x, f)      \
+       ((status->valid_bitmask & NSTAT_IFNET_DESC_CELL_ ## f ## _VALID) ?\
+        status->x : -1)
+#define parg(n, un) #n, val(n, un)
+#define pretxtl(n, un) \
+       (((tmp = val(n, un)) == -1) ? "(not valid)" : \
+       ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_NONE) ? "(none)" : \
+       ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_LOW) ? "(low)" : \
+       ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_MEDIUM) ? "(medium)" : \
+       ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_HIGH) ? "(high)" : \
+       "(?)")))))
+#define pretxtm(n, un) \
+       (((tmp_mss = val(n,un)) == -1) ? "(not valid)" : \
+       ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_NONE) ? "(none)" : \
+       ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_MEDIUM) ? "(medium)" : \
+       ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_LOW) ? "(low)" : \
+       "(?)"))))
+
+       printf("\ncellular status:\n");
+       printf(
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t\t%d%s\n"
+           "\t%s:\t\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d\n"
+           "\t%s:\t%d %s\n",
+           parg(link_quality_metric, LINK_QUALITY_METRIC),
+           parg(ul_effective_bandwidth, UL_EFFECTIVE_BANDWIDTH),
+           parg(ul_max_bandwidth, UL_MAX_BANDWIDTH),
+           parg(ul_min_latency, UL_MIN_LATENCY),
+           parg(ul_effective_latency, UL_EFFECTIVE_LATENCY),
+           parg(ul_max_latency, UL_MAX_LATENCY),
+           parg(ul_retxt_level, UL_RETXT_LEVEL),
+           pretxtl(ul_retxt_level, UL_RETXT_LEVEL),
+           parg(ul_bytes_lost, UL_BYTES_LOST),
+           parg(ul_min_queue_size, UL_MIN_QUEUE_SIZE),
+           parg(ul_avg_queue_size, UL_AVG_QUEUE_SIZE),
+           parg(ul_max_queue_size, UL_MAX_QUEUE_SIZE),
+           parg(dl_effective_bandwidth, DL_EFFECTIVE_BANDWIDTH),
+           parg(dl_max_bandwidth, DL_MAX_BANDWIDTH),
+           parg(config_inactivity_time, CONFIG_INACTIVITY_TIME),
+           parg(config_backoff_time, CONFIG_BACKOFF_TIME),
+           parg(mss_recommended, MSS_RECOMMENDED),
+           pretxtm(mss_recommended, MSS_RECOMMENDED)
+           );
+#undef pretxtl
+#undef parg
+#undef val
+}
+
+static int
+get_interface_state(int fd, const char *ifname, struct ifreq *ifr)
+{
+       bzero(ifr, sizeof(*ifr));
+       snprintf(ifr->ifr_name, sizeof(ifr->ifr_name), "%s", ifname);
+
+       if (ioctl(fd, SIOCGIFINTERFACESTATE, ifr) == -1) {
+               perror("ioctl(CTLIOCGINFO)");
+               return -1;
+       }
+       return 0;
+}
+
+static void
+print_interface_state(struct ifreq *ifr)
+{
+       int lqm, rrc, avail;
+
+       printf("\ninterface state:\n");
+
+       if (ifr->ifr_interface_state.valid_bitmask &
+           IF_INTERFACE_STATE_LQM_STATE_VALID) {
+               printf("\tlqm: ");
+               lqm = ifr->ifr_interface_state.lqm_state;
+               if (lqm == IFNET_LQM_THRESH_GOOD)
+                       printf("\"good\"");
+               else if (lqm == IFNET_LQM_THRESH_POOR)
+                       printf("\"poor\"");
+               else if (lqm == IFNET_LQM_THRESH_BAD)
+                       printf("\"bad\"");
+               else if (lqm == IFNET_LQM_THRESH_UNKNOWN)
+                       printf("\"unknown\"");
+               else if (lqm == IFNET_LQM_THRESH_OFF)
+                       printf("\"off\"");
+               else
+                       printf("invalid(%d)", lqm);
+       }
+
+       if (ifr->ifr_interface_state.valid_bitmask &
+           IF_INTERFACE_STATE_RRC_STATE_VALID) {
+               printf("\trrc: ");
+               rrc = ifr->ifr_interface_state.rrc_state;
+               if (rrc == IF_INTERFACE_STATE_RRC_STATE_CONNECTED)
+                       printf("\"connected\"");
+               else if (rrc == IF_INTERFACE_STATE_RRC_STATE_IDLE)
+                       printf("\"idle\"");
+               else
+                       printf("\"invalid(%d)\"", rrc);
+       }
+
+       if (ifr->ifr_interface_state.valid_bitmask &
+           IF_INTERFACE_STATE_INTERFACE_AVAILABILITY_VALID) {
+               printf("\tavailability: ");
+               avail = ifr->ifr_interface_state.interface_availability;
+               if (avail == IF_INTERFACE_STATE_INTERFACE_AVAILABLE)
+                       printf("\"true\"");
+               else if (rrc == IF_INTERFACE_STATE_INTERFACE_UNAVAILABLE)
+                       printf("\"false\"");
+               else
+                       printf("\"invalid(%d)\"", avail);
+       }
+}
+
+void
+print_link_status(const char *ifname)
+{
+       unsigned int ifindex;
+       struct itimerval timer_interval;
+       sigset_t sigset, oldsigset;
+       struct nstat_ifnet_descriptor ifdesc;
+       nstat_ifnet_add_param ifparam;
+       nstat_src_ref_t sref = 0;
+       struct ifreq ifr;
+       int ctl_fd;
+
+       ifindex = if_nametoindex(ifname);
+       if (ifindex == 0) {
+               fprintf(stderr, "Invalid interface name\n");
+               return;
+       }
+
+       if ((ctl_fd = create_control_socket(NET_STAT_CONTROL_NAME)) < 0)
+               return;
+
+       ifparam.ifindex = ifindex;
+       ifparam.threshold = UINT64_MAX;
+       if (add_nstat_src(ctl_fd, &ifparam, &sref))
+               goto done;
+loop:
+       if (interval > 0) {
+               /* create a timer that fires repeatedly every interval
+                * seconds */
+               timer_interval.it_value.tv_sec = interval;
+               timer_interval.it_value.tv_usec = 0;
+               timer_interval.it_interval.tv_sec = interval;
+               timer_interval.it_interval.tv_usec = 0;
+               (void) signal(SIGALRM, catchalarm);
+               signalled = NO;
+               (void) setitimer(ITIMER_REAL, &timer_interval, NULL);
+       }
+
+       /* get interface state */
+       if (get_interface_state(ctl_fd, ifname, &ifr))
+               goto done;
+
+       /* get ntstat interface description */
+       if (get_src_decsription(ctl_fd, sref, &ifdesc))
+               goto done;
+
+       /* print time */
+       printf("\n%s: ", ifname);
+       print_time();
+
+       /* print interface state */
+       print_interface_state(&ifr);
+
+       /* print ntsat interface link status */
+       if (ifdesc.link_status.link_status_type ==
+           NSTAT_IFNET_DESC_LINK_STATUS_TYPE_CELLULAR)
+               print_cellular_status(&ifdesc.link_status.u.cellular);
+       else if (ifdesc.link_status.link_status_type ==
+                NSTAT_IFNET_DESC_LINK_STATUS_TYPE_WIFI)
+               print_wifi_status(&ifdesc.link_status.u.wifi);
+
+       fflush(stdout);
+
+       if (interval > 0) {
+               sigemptyset(&sigset);
+               sigaddset(&sigset, SIGALRM);
+               (void) sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+               if (!signalled) {
+                       sigemptyset(&sigset);
+                       sigsuspend(&sigset);
+               }
+               (void) sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+
+               signalled = NO;
+               goto loop;
+       }
+done:
+       if (sref)
+               rem_nstat_src(ctl_fd, sref);
+       close(ctl_fd);
+}