#include <sys/types.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>
#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
#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];
#endif
static void
show_stat(const char *fmt, int width, u_int64_t value, short showvalue)
{
char newfmt[32];
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
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);
}
}
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; mib[1] = PF_ROUTE; mib[2] = 0; mib[3] = 0; mib[4] = NET_RT_IFLIST2; 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;
u_int64_t ift_itcb = 0;
u_int64_t ift_otcp = 0;
u_int64_t ift_otcb = 0;
u_int64_t ift_ipvp = 0;
u_int64_t ift_ipvb = 0;
u_int64_t ift_opvp = 0;
u_int64_t ift_opvb = 0;
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;
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';
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;
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
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),
"<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;
--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];
u_int64_t ift_ip;
u_int64_t ift_ie;
u_int64_t ift_op;
u_int64_t ift_oe;
u_int64_t ift_co;
u_int64_t ift_dr;
u_int64_t ift_ib;
u_int64_t ift_ob;
u_int64_t ift_itcp;
u_int64_t ift_itcb;
u_int64_t ift_otcp;
u_int64_t ift_otcb;
u_int64_t ift_ipvp;
u_int64_t ift_ipvb;
u_int64_t ift_opvp;
u_int64_t ift_opvb;
u_int64_t ift_fp;
u_int64_t ift_fb;
};
u_char signalled;
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;
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");
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;
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;
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;
}
void
intervalpr(void (*pr)(uint32_t, char *, int), uint32_t off, char *name , int af)
{
struct itimerval timer_interval;
sigset_t sigset, oldsigset;
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;
}
}
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;
mib[1] = PF_ROUTE;
mib[2] = 0;
mib[3] = 0;
mib[4] = NET_RT_IFLIST2;
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) {
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
#define USEC_PER_SEC 1000000
#define MSEC_PER_SEC 1000
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) {
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);
}
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;
}
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;
}
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;
}
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);
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;
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;
}
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;
remreq = (nstat_msg_rem_src_req *)buffer;
bzero(remreq, sizeof(*remreq));
remreq->hdr.type = NSTAT_MSG_TYPE_REM_SRC;
remreq->srcref = sref;
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;
}
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;
}
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) {
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);
}
if (get_interface_state(ctl_fd, ifname, &ifr))
goto done;
if (get_src_decsription(ctl_fd, sref, &ifdesc))
goto done;
printf("\n%s: ", ifname);
print_time();
print_interface_state(&ifr);
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);
}