X-Git-Url: https://git.saurik.com/apple/network_cmds.git/blobdiff_plain/7af5ce03cf81eb8cf0c6e1bfd903b52fcc7c224a..26c66ce99fcafd17b96b2fc4815ddf9fc3d85feb:/netstat.tproj/if.c?ds=inline diff --git a/netstat.tproj/if.c b/netstat.tproj/if.c index 70e5705..a0ef208 100644 --- a/netstat.tproj/if.c +++ b/netstat.tproj/if.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008-2012 Apple Inc. All rights reserved. + * Copyright (c) 2008-2015 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * @@ -58,19 +58,12 @@ * SUCH DAMAGE. */ -#ifndef lint -/* -static char sccsid[] = "@(#)if.c 8.3 (Berkeley) 4/28/95"; -*/ -static const char rcsid[] = - "$Id: if.c,v 1.7 2006/01/16 04:53:59 lindak Exp $"; -#endif /* not lint */ - #include #include #include #include #include +#include #include #include @@ -80,6 +73,7 @@ static const char rcsid[] = #include #include #include +#include #include #include @@ -94,8 +88,10 @@ static const char rcsid[] = #include #include #include +#include #include #include +#include #include "netstat.h" @@ -119,6 +115,7 @@ static char *qid2str(unsigned int); static char *qstate2str(unsigned int); static char *tcqslot2str(unsigned int); static char *rate2str(long double); +static char *pri2str(unsigned int i); #define AVGN_MAX 8 @@ -146,6 +143,8 @@ static void print_qfqstats(int slot, struct qfq_classstats *, struct queue_stats *); static void print_sfbstats(struct sfb_stats *); 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]; @@ -273,28 +272,30 @@ intpr(void (*pfunc)(char *)) 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; - short timer = 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; + 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) @@ -336,32 +337,40 @@ intpr(void (*pfunc)(char *)) 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; ) { + 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_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; + ifm = (struct if_msghdr *)next; next += ifm->ifm_msglen; - if (ifm->ifm_type == RTM_IFINFO2) { + if (ifm->ifm_type == RTM_IFINFO2) { struct if_msghdr2 *if2m = (struct if_msghdr2 *)ifm; - struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1); + struct sockaddr_dl *sdl = + (struct sockaddr_dl *)(if2m + 1); + int mibname[6]; + size_t miblen = sizeof(struct ifmibdata_supplemental); strncpy(name, sdl->sdl_data, sdl->sdl_nlen); name[sdl->sdl_nlen] = 0; @@ -393,55 +402,55 @@ intpr(void (*pfunc)(char *)) drops = if2m->ifm_snd_drops; mtu = if2m->ifm_data.ifi_mtu; - if (prioflag >= 0) { - int name[6]; - size_t miblen = sizeof(struct ifmibdata_supplemental); - - /* Common OID prefix */ - name[0] = CTL_NET; - name[1] = PF_LINK; - name[2] = NETLINK_GENERIC; - name[3] = IFMIB_IFDATA; - name[4] = if2m->ifm_index; - name[5] = IFDATA_SUPPLEMENTAL; - if (sysctl(name, 6, &ifmsupp, &miblen, (void *)0, 0) == -1) - err(1, "sysctl IFDATA_SUPPLEMENTAL"); + /* 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; + 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; @@ -449,14 +458,16 @@ intpr(void (*pfunc)(char *)) ift_opvb = ifmsupp.ifmd_traffic_class.ifi_opvbytes; } - get_rti_info(if2m->ifm_addrs, (struct sockaddr*)(if2m + 1), rti_info); + 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; - + } 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); + get_rti_info(ifam->ifam_addrs, + (struct sockaddr*)(ifam + 1), rti_info); sa = rti_info[RTAX_IFA]; } else { continue; @@ -474,16 +485,18 @@ intpr(void (*pfunc)(char *)) break; case AF_INET: { - struct sockaddr_in *sin = (struct sockaddr_in *)sa; + 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); - + memcpy(&mask, rti_info[RTAX_NETMASK], + ((struct sockaddr_in *) + rti_info[RTAX_NETMASK])->sin_len); + printf("%-13.13s ", - netname(sin->sin_addr.s_addr & mask.sin_addr.s_addr, + netname(sin->sin_addr.s_addr & + mask.sin_addr.s_addr, ntohl(mask.sin_addr.s_addr))); printf("%-15.15s ", @@ -494,16 +507,15 @@ intpr(void (*pfunc)(char *)) } #ifdef INET6 case AF_INET6: { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; - struct sockaddr *mask = (struct sockaddr *)rti_info[RTAX_NETMASK]; + struct sockaddr_in6 *sin6 = + (struct sockaddr_in6 *)sa; + struct sockaddr *mask = + (struct sockaddr *)rti_info[RTAX_NETMASK]; - printf("%-11.11s ", - netname6(sin6, - mask)); - printf("%-17.17s ", - (char *)inet_ntop(AF_INET6, - &sin6->sin6_addr, - ntop_buf, sizeof(ntop_buf))); + printf("%-11.11s ", netname6(sin6, mask)); + printf("%-17.17s ", (char *)inet_ntop(AF_INET6, + &sin6->sin6_addr, ntop_buf, + sizeof(ntop_buf))); network_layer = 1; break; @@ -511,11 +523,12 @@ intpr(void (*pfunc)(char *)) #endif /*INET6*/ case AF_LINK: { struct sockaddr_dl *sdl = - (struct sockaddr_dl *)sa; + (struct sockaddr_dl *)sa; char linknum[10]; cp = (char *)LLADDR(sdl); n = sdl->sdl_alen; - snprintf(linknum, sizeof(linknum), "", sdl->sdl_index); + snprintf(linknum, sizeof(linknum), + "", sdl->sdl_index); m = printf("%-11.11s ", linknum); goto hexprint; } @@ -537,7 +550,7 @@ intpr(void (*pfunc)(char *)) link_layer = 1; break; } - } + } show_stat("llu", 8, ipackets, link_layer|network_layer); printf(" "); @@ -582,15 +595,24 @@ intpr(void (*pfunc)(char *)) show_stat("llu", 5, collisions, link_layer); if (tflag) { printf(" "); - show_stat("ll", 3, timer, link_layer); + show_stat("d", 3, timer, link_layer); } if (dflag) { printf(" "); - show_stat("ll", 3, drops, link_layer); + 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) + if (aflag) multipr(sa->sa_family, next, lim); } free(buf); @@ -599,22 +621,24 @@ intpr(void (*pfunc)(char *)) 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_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" */ @@ -660,17 +684,19 @@ sidewaysintpr() 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) + 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);; + snprintf(interesting->ift_name, 16, "(%s)", + ifmd->ifmd_name);; } } if ((total = calloc(1, sizeof(struct iftot))) == NULL) @@ -689,6 +715,9 @@ sidewaysintpr() (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"); @@ -696,24 +725,33 @@ banner: printf("%17s %14s %16s", "input", interesting ? interesting->ift_name : "(Total)", "output"); putchar('\n'); - printf("%10s %5s %10s ", - "packets", "errs", "bytes"); + + 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"); + 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"); + 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; @@ -721,84 +759,111 @@ loop: if (sysctl(name, 6, &ifmd, &len, (void *)0, 0) == -1) err(1, "sysctl IFDATA_GENERAL %d", interesting_row); - if (prioflag >= 0) { - 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); - } + 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); + 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; + 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); + 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); + 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); + 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; + 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); + 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; @@ -809,45 +874,68 @@ loop: 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; + 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_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; @@ -870,17 +958,17 @@ loop: name[5] = IFDATA_GENERAL; if (sysctl(name, 6, ifmdall, &len, (void *)0, 0) == -1) err(1, "sysctl IFMIB_IFALLDATA"); - if (prioflag >= 0) { - 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"); - } + + 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; @@ -897,9 +985,12 @@ loop: 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; @@ -910,40 +1001,41 @@ loop: sum->ift_dr += ifmd->ifmd_snd_drops; /* private counters */ if (prioflag >= 0) { - struct ifmibdata_supplemental *ifmsupp = ifmsuppall + i; 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; + 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 ", @@ -969,8 +1061,14 @@ loop: 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'); @@ -1375,6 +1473,11 @@ loop: print_qfqstats(n, &ifcqs->ifqs_qfq_stats, &qstats[n]); break; + case PKTSCHEDT_FQ_CODEL: + print_fq_codel_stats(n, + &ifcqs->ifqs_fq_codel_stats, + &qstats[n]); + break; case PKTSCHEDT_NONE: default: break; @@ -1606,6 +1709,35 @@ print_qfqstats(int slot, struct qfq_classstats *cs, struct queue_stats *qs) } } +static void +print_fq_codel_stats(int pri, struct fq_codel_classstats *fqst, + struct queue_stats *qs) +{ + 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(" [ budget: %lld\t\ttarget qdelay: %14s ]\n", + fqst->fcls_budget, nsec_to_str(fqst->fcls_target_qdelay)); + 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(" [ 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(" [ throttle on: %u\toff: %u\tdrop: %u ]\n", + fqst->fcls_throttle_on, fqst->fcls_throttle_off, + fqst->fcls_throttle_drops); + printf("=====================================================\n"); +} + static void print_sfbstats(struct sfb_stats *sfb) { @@ -1613,6 +1745,10 @@ print_sfbstats(struct sfb_stats *sfb) int i, j, cur = sfb->current; printf("\n"); + printf(" [target delay: %14s ", + nsec_to_str(sfb->target_qdelay)); + printf("update interval: %14s]\n", + nsec_to_str(sfb->update_interval)); printf(" [ early drop: %12llu rlimit drop: %11llu " "marked: %11llu ]\n", sp->drop_early, sp->drop_pbox, sp->marked_packets); @@ -1626,6 +1762,10 @@ print_sfbstats(struct sfb_stats *sfb) sfb->allocation, sfb->dropthresh); printf(" [ flow controlled: %7llu adv feedback: %10llu ]\n", sp->flow_controlled, sp->flow_feedback); + printf(" [ min queue delay: %10s delay_fcthreshold: %12u]\n " + " [stalls: %12llu]\n", + nsec_to_str(sfb->min_estdelay), sfb->delay_fcthreshold, + sp->dequeue_stall); printf("\n\t\t\t\tCurrent bins (set %d)", cur); for (i = 0; i < SFB_LEVELS; ++i) { @@ -1707,6 +1847,10 @@ update_avg(struct if_ifclassq_stats *ifcqs, struct queue_stats *qs) b = ifcqs->ifqs_qfq_stats.xmitcnt.bytes; p = ifcqs->ifqs_qfq_stats.xmitcnt.packets; break; + 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; @@ -1767,8 +1911,8 @@ qtype2str(classq_type_t t) } #define NSEC_PER_SEC 1000000000 /* nanoseconds per second */ -#define USEC_PER_SEC 1000000 /* nanoseconds per second */ -#define MSEC_PER_SEC 1000 /* 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) @@ -1822,6 +1966,9 @@ sched2str(unsigned int s) case PKTSCHEDT_QFQ: c = "QFQ"; break; + case PKTSCHEDT_FQ_CODEL: + c = "FQ_CODEL"; + break; default: c = "UNKNOWN"; break; @@ -1906,6 +2053,48 @@ tcqslot2str(unsigned int s) 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); +} + static char * qstate2str(unsigned int s) { @@ -2033,3 +2222,501 @@ loop: 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); +}