/* * 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. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "netstat.h" #define YES 1 #define NO 0 #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); #define AVGN_MAX 8 struct queue_stats { int avgn; double avg_bytes; double avg_packets; u_int64_t prev_bytes; u_int64_t prev_packets; unsigned int handle; }; 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_int64_t value, short showvalue) { char newfmt[32]; /* Construct the format string */ if (showvalue) { snprintf(newfmt, sizeof(newfmt), "%%%d%s", width, fmt); printf(newfmt, value); } else { 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(void (*pfunc)(char *)) { 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]; 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 (interval) { sidewaysintpr(); return; } 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; 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) { 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 (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'); } 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 (interface != 0 && if2m->ifm_index != ifindex) continue; /* 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; } cp = index(name, '\0'); if ((if2m->ifm_flags & IFF_UP) == 0) *cp++ = '*'; *cp = '\0'; /* * 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; } 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(lflag ? "%-39.39s " : "%-13.13s ", "none"); printf(lflag ? "%-39.39s " : "%-15.15s ", "none"); break; 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: { 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*/ case AF_LINK: { struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa; char linknum[10]; cp = (char *)LLADDR(sdl); n = sdl->sdl_alen; snprintf(linknum, sizeof(linknum), "", 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; --cp > sa->sa_data && (*cp == 0);) {} n = cp - sa->sa_data + 1; cp = sa->sa_data; hexprint: while (--n >= 0) m += printf("%02x%c", *cp++ & 0xff, n > 0 ? ':' : ' '); m = (lflag ? 80 : 30) - m; while (m-- > 0) putchar(' '); link_layer = 1; break; } } show_stat("llu", 8, ipackets, link_layer|network_layer); printf(" "); 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("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("llu", 8, opackets, link_layer|network_layer); printf(" "); 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("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("llu", 5, collisions, link_layer); if (tflag) { printf(" "); show_stat("d", 3, timer, link_layer); } if (dflag) { printf(" "); show_stat("d", 3, drops, link_layer); } 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_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" */ /* * Print a running summary of interface statistics. * Repeat display every interval seconds, showing statistics * collected over that interval. Assumes that interval is non-zero. * First line printed at top of screen is always cumulative. * XXX - should be rewritten to use ifmib(4). */ static void sidewaysintpr() { struct iftot *total, *sum, *interesting; register int line; 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; /* Common OID prefix */ name[0] = CTL_NET; name[1] = PF_LINK; name[2] = NETLINK_GENERIC; 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_row = 0; for (i = 0; i < ifcount; i++) { struct ifmibdata *ifmd = ifmdall + i; 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);; } } 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)setitimer(ITIMER_REAL, &timer_interval, NULL); first = 1; banner: 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'); 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) { 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("%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(" %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; sum->ift_op = 0; sum->ift_oe = 0; sum->ift_ob = 0; sum->ift_co = 0; sum->ift_dr = 0; 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_fp += ifmsupp->ifmd_data_extended.ifi_fpackets; sum->ift_fb += ifmsupp->ifmd_data_extended.ifi_fbytes; } if (!first) { printf("%10llu %5llu %10llu ", sum->ift_ip - total->ift_ip, sum->ift_ie - total->ift_ie, 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(" %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); 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; line++; first = 0; if (line == 21) goto banner; else goto 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. */ static void 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); }