/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2008-2019 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* 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 <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_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 <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"
static char *sec2str(time_t);
static void llreach_sysctl(uint32_t);
static char *nsec_to_str(unsigned long long);
-static char *qtype2str(classq_type_t);
static char *sched2str(unsigned int);
-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
double avg_packets;
u_int64_t prev_bytes;
u_int64_t prev_packets;
- unsigned int printed;
unsigned int handle;
};
-static void print_cbqstats(int slot, struct cbq_classstats *,
- struct queue_stats *);
-static void print_priqstats(int slot, struct priq_classstats *,
- struct queue_stats *);
-static void print_hfscstats(int slot, struct hfsc_classstats *,
- struct queue_stats *);
-static void print_fairqstats(int slot, struct fairq_classstats *,
- struct queue_stats *);
-static void print_tcqstats(int slot, struct tcq_classstats *,
- struct queue_stats *);
-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];
struct sockaddr *rti_info[RTAX_MAX];
struct sockaddr *sa;
const char *fmt = 0;
-
+
next += ifmam->ifmam_msglen;
if (ifmam->ifmam_type == RTM_IFINFO2)
break;
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;
}
#endif /* INET6 */
case AF_LINK: {
struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;
-
+
switch (sdl->sdl_type) {
case IFT_ETHER:
case IFT_FDDI:
}
if (!pfunc) {
- printf("%-5.5s %-5.5s %-13.13s %-15.15s %8.8s %5.5s",
- "Name", "Mtu", "Network", "Address", "Ipkts", "Ierrs");
+ 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) {
int mibname[6];
size_t miblen = sizeof(struct ifmibdata_supplemental);
- strncpy(name, sdl->sdl_data, sdl->sdl_nlen);
- name[sdl->sdl_nlen] = 0;
if (interface != 0 && if2m->ifm_index != ifindex)
continue;
- cp = index(name, '\0');
+
+ /* The interface name is not a zero-ended string */
+ memcpy(name, sdl->sdl_data, MIN(sizeof(name) - 1, sdl->sdl_nlen));
+ name[MIN(sizeof(name) - 1, sdl->sdl_nlen)] = 0;
if (pfunc) {
(*pfunc)(name);
continue;
}
+ cp = index(name, '\0');
if ((if2m->ifm_flags & IFF_UP) == 0)
*cp++ = '*';
*cp = '\0';
} else {
continue;
}
- printf("%-5.5s %-5u ", name, mtu);
+ if (lflag) {
+ printf("%-10.10s %-5u ", name, mtu);
+ } else {
+ printf("%-5.5s %-5u ", name, mtu);
+ }
if (sa == 0) {
- printf("%-13.13s ", "none");
- printf("%-15.15s ", "none");
+ printf(lflag ? "%-39.39s " : "%-13.13s ", "none");
+ printf(lflag ? "%-39.39s " : "%-15.15s ", "none");
} else {
switch (sa->sa_family) {
case AF_UNSPEC:
- printf("%-13.13s ", "none");
- printf("%-15.15s ", "none");
+ printf(lflag ? "%-39.39s " : "%-13.13s ", "none");
+ printf(lflag ? "%-39.39s " : "%-15.15s ", "none");
break;
case AF_INET: {
((struct sockaddr_in *)
rti_info[RTAX_NETMASK])->sin_len);
- printf("%-13.13s ",
+ printf(lflag ? "%-39.39s " : "%-13.13s ",
netname(sin->sin_addr.s_addr &
mask.sin_addr.s_addr,
ntohl(mask.sin_addr.s_addr)));
- printf("%-15.15s ",
+ printf(lflag ? "%-39.39s " : "%-15.15s ",
routename(sin->sin_addr.s_addr));
network_layer = 1;
struct sockaddr *mask =
(struct sockaddr *)rti_info[RTAX_NETMASK];
- printf("%-11.11s ", netname6(sin6, mask));
- printf("%-17.17s ", (char *)inet_ntop(AF_INET6,
+ 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)));
n = sdl->sdl_alen;
snprintf(linknum, sizeof(linknum),
"<Link#%d>", sdl->sdl_index);
- m = printf("%-11.11s ", linknum);
+ m = printf(lflag ? "%-39.39s " : "%-11.11s ", linknum);
goto hexprint;
}
while (--n >= 0)
m += printf("%02x%c", *cp++ & 0xff,
n > 0 ? ':' : ' ');
- m = 30 - m;
+ m = (lflag ? 80 : 30) - m;
while (m-- > 0)
putchar(' ');
sum->ift_fb - total->ift_fb);
}
*total = *sum;
+
+ free(ifmsuppall);
}
if (!first)
putchar('\n');
struct if_ifclassq_stats *ifcqs;
sigset_t sigset, oldsigset;
u_int32_t scheduler;
- int s, n, tcq = 0;
+ int s, n;
if (cq < -1 || cq >= IFCQ_SC_MAX) {
fprintf(stderr, "Invalid classq index (range is 0-%d)\n",
goto done;
}
scheduler = ifcqs->ifqs_scheduler;
- tcq = (scheduler == PKTSCHEDT_TCQ);
printf("%s:\n"
- "%s [ sched: %9s %sqlength: %3d/%3d ]\n",
- interface, tcq ? " " : "", sched2str(ifcqs->ifqs_scheduler),
- tcq ? "" : " ", ifcqs->ifqs_len, ifcqs->ifqs_maxlen);
- printf("%s [ pkts: %10llu %sbytes: %10llu "
- "%sdropped pkts: %6llu bytes: %6llu ]\n",
- (scheduler != PKTSCHEDT_TCQ) ? "" : " ",
- ifcqs->ifqs_xmitcnt.packets, tcq ? "" : " ",
- ifcqs->ifqs_xmitcnt.bytes, tcq ? "" : " ",
+ " [ 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; n++) {
- qstats[n].printed = 0;
- if (!tcq)
- continue;
- ifqr.ifqr_slot = n;
- if (ioctl(s, SIOCGIFQUEUESTATS, (char *)&ifqr) < 0) {
- perror("Warning: ioctl(SIOCGIFQUEUESTATS)");
- goto done;
- }
- qstats[n].handle = ifcqs->ifqs_tcq_stats.class_handle;
- }
-
for (n = 0; n < IFCQ_SC_MAX && scheduler != PKTSCHEDT_NONE; n++) {
if (cq >= 0 && cq != n)
continue;
update_avg(ifcqs, &qstats[n]);
switch (scheduler) {
- case PKTSCHEDT_CBQ:
- print_cbqstats(n, &ifcqs->ifqs_cbq_stats,
- &qstats[n]);
- break;
- case PKTSCHEDT_HFSC:
- print_hfscstats(n, &ifcqs->ifqs_hfsc_stats,
- &qstats[n]);
- break;
- case PKTSCHEDT_PRIQ:
- print_priqstats(n, &ifcqs->ifqs_priq_stats,
- &qstats[n]);
- break;
- case PKTSCHEDT_FAIRQ:
- print_fairqstats(n, &ifcqs->ifqs_fairq_stats,
- &qstats[n]);
- break;
- case PKTSCHEDT_TCQ:
- print_tcqstats(n, &ifcqs->ifqs_tcq_stats,
- &qstats[n]);
- break;
- case PKTSCHEDT_QFQ:
- print_qfqstats(n, &ifcqs->ifqs_qfq_stats,
+ case PKTSCHEDT_FQ_CODEL:
+ print_fq_codel_stats(n,
+ &ifcqs->ifqs_fq_codel_stats,
&qstats[n]);
break;
case PKTSCHEDT_NONE:
}
static void
-print_cbqstats(int slot, struct cbq_classstats *cs, struct queue_stats *qs)
-{
- printf(" %2d: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", slot,
- (unsigned long long)cs->xmit_cnt.packets,
- (unsigned long long)cs->xmit_cnt.bytes,
- (unsigned long long)cs->drop_cnt.packets,
- (unsigned long long)cs->drop_cnt.bytes);
- printf(" [ qlength: %3d/%3d borrows: %6u "
- "suspends: %6u qalg: %s ]\n", cs->qcnt, cs->qmax,
- cs->borrows, cs->delays, qtype2str(cs->qtype));
- printf(" [ service class: %5s ]\n", qid2str(cs->handle));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
-
- if (qflag < 2)
- return;
-
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_priqstats(int slot, struct priq_classstats *cs, struct queue_stats *qs)
-{
- printf(" %2d: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", slot,
- (unsigned long long)cs->xmitcnt.packets,
- (unsigned long long)cs->xmitcnt.bytes,
- (unsigned long long)cs->dropcnt.packets,
- (unsigned long long)cs->dropcnt.bytes);
- printf(" [ qlength: %3d/%3d qalg: %11s service class: %5s ]\n",
- cs->qlength, cs->qlimit, qtype2str(cs->qtype),
- qid2str(cs->class_handle));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
-
- if (qflag < 2)
- return;
-
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_hfscstats(int slot, struct hfsc_classstats *cs, struct queue_stats *qs)
-{
- printf(" %2d: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", slot,
- (unsigned long long)cs->xmit_cnt.packets,
- (unsigned long long)cs->xmit_cnt.bytes,
- (unsigned long long)cs->drop_cnt.packets,
- (unsigned long long)cs->drop_cnt.bytes);
- printf(" [ qlength: %3d/%3d qalg: %11s service class: %5s ]\n",
- cs->qlength, cs->qlimit, qtype2str(cs->qtype),
- qid2str(cs->class_handle));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
-
- if (qflag < 2)
- return;
-
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_fairqstats(int slot, struct fairq_classstats *cs, struct queue_stats *qs)
-{
- printf(" %2d: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", slot,
- (unsigned long long)cs->xmit_cnt.packets,
- (unsigned long long)cs->xmit_cnt.bytes,
- (unsigned long long)cs->drop_cnt.packets,
- (unsigned long long)cs->drop_cnt.bytes);
- printf(" [ qlength: %3d/%3d qalg: %11s service class: %5s ]]\n",
- cs->qlength, cs->qlimit, qtype2str(cs->qtype),
- qid2str(cs->class_handle));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
-
- if (qflag < 2)
- return;
-
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_tcqstats(int slot, struct tcq_classstats *cs, struct queue_stats *qs)
+print_fq_codel_stats(int pri, struct fq_codel_classstats *fqst,
+ struct queue_stats *qs)
{
- int n;
+ int i = 0;
- if (qs->printed)
+ if (fqst->fcls_service_class == 0 && fqst->fcls_pri == 0)
return;
-
- qs->handle = cs->class_handle;
- qs->printed++;
-
- for (n = 0; n < IFCQ_SC_MAX; n++) {
- if (&qstats[n] != qs && qstats[n].handle == qs->handle)
- qstats[n].printed++;
- }
-
- printf("%5s: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", tcqslot2str(slot),
- (unsigned long long)cs->xmitcnt.packets,
- (unsigned long long)cs->xmitcnt.bytes,
- (unsigned long long)cs->dropcnt.packets,
- (unsigned long long)cs->dropcnt.bytes);
- printf(" [ qlength: %3d/%3d qalg: %11s "
- "svc class: %9s %-13s ]\n", cs->qlength, cs->qlimit,
- qtype2str(cs->qtype), qid2str(cs->class_handle),
- qstate2str(cs->qstate));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
+ 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;
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_qfqstats(int slot, struct qfq_classstats *cs, struct queue_stats *qs)
-{
- printf(" %2d: [ pkts: %10llu bytes: %10llu "
- "dropped pkts: %6llu bytes: %6llu ]\n", slot,
- (unsigned long long)cs->xmitcnt.packets,
- (unsigned long long)cs->xmitcnt.bytes,
- (unsigned long long)cs->dropcnt.packets,
- (unsigned long long)cs->dropcnt.bytes);
- printf(" [ qlength: %3d/%3d index: %10u weight: %12u "
- "lmax: %7u ]\n", cs->qlength, cs->qlimit, cs->index,
- cs->weight, cs->lmax);
- printf(" [ qalg: %10s svc class: %6s %-35s ]\n",
- qtype2str(cs->qtype), qid2str(cs->class_handle),
- qstate2str(cs->qstate));
-
- if (qs->avgn >= 2) {
- printf(" [ measured: %7.1f packets/s, %s/s ]\n",
- qs->avg_packets / interval,
- rate2str((8 * qs->avg_bytes) / interval));
- }
-
- if (qflag < 2)
- return;
-
- switch (cs->qtype) {
- case Q_SFB:
- print_sfbstats(&cs->sfb);
- break;
- default:
- break;
- }
-}
-
-static void
-print_sfbstats(struct sfb_stats *sfb)
-{
- struct sfbstats *sp = &sfb->sfbstats;
- int i, j, cur = sfb->current;
-
- printf("\n");
- printf(" [ early drop: %12llu rlimit drop: %11llu "
- "marked: %11llu ]\n",
- sp->drop_early, sp->drop_pbox, sp->marked_packets);
- printf(" [ penalized: %13llu rehash cnt: %12llu "
- "current: %10u ]\n", sp->pbox_packets, sp->num_rehash, cur);
- printf(" [ deque avg: %13s ", nsec_to_str(sp->dequeue_avg));
- printf("rehash intvl: %11s]\n", nsec_to_str(sp->rehash_intval));
- printf(" [ holdtime: %14s ", nsec_to_str(sp->hold_time));
- printf("pboxtime: %14s ]\n", nsec_to_str(sp->pbox_time));
- printf(" [ allocation: %12u drop thresh: %11u ]\n",
- sfb->allocation, sfb->dropthresh);
- printf(" [ flow controlled: %7llu adv feedback: %10llu ]\n",
- sp->flow_controlled, sp->flow_feedback);
-
- printf("\n\t\t\t\tCurrent bins (set %d)", cur);
- for (i = 0; i < SFB_LEVELS; ++i) {
- unsigned int q;
- double p;
-
- printf("\n\tLevel: %d\n", i);
- for (j = 0; j < SFB_BINS; ++j) {
- if ((j % 4) == 0)
- printf("\t%6d:\t", j + 1);
- p = sfb->binstats[cur].stats[i][j].pmark;
- q = sfb->binstats[cur].stats[i][j].pkts;
- if (p > 0) {
- p /= (1 << SFB_FP_SHIFT);
- printf("[%1.4f %4u]", p, q);
- } else {
- printf("[ ]");
- }
- if (j > 0 && ((j + 1) % 4) == 0)
- printf("\n");
- }
- }
-
- cur ^= 1;
- printf("\n\t\t\t\tWarm up bins (set %d)", cur);
- for (i = 0; i < SFB_LEVELS; ++i) {
- unsigned int q;
- double p;
-
- printf("\n\tLevel: %d\n", i);
- for (j = 0; j < SFB_BINS; ++j) {
- if ((j % 4) == 0)
- printf("\t%6d:\t", j + 1);
- p = sfb->binstats[cur].stats[i][j].pmark;
- q = sfb->binstats[cur].stats[i][j].pkts;
- if (p > 0) {
- p /= (1 << SFB_FP_SHIFT);
- printf("[%1.4f %4u]", p, q);
- } else {
- printf("[ ]");
- }
- if (j > 0 && ((j + 1) % 4) == 0)
- printf("\n");
+ 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");
}
}
- printf("\n");
}
static void
n = qs->avgn;
switch (ifcqs->ifqs_scheduler) {
- case PKTSCHEDT_CBQ:
- b = ifcqs->ifqs_cbq_stats.xmit_cnt.bytes;
- p = ifcqs->ifqs_cbq_stats.xmit_cnt.packets;
- break;
- case PKTSCHEDT_PRIQ:
- b = ifcqs->ifqs_priq_stats.xmitcnt.bytes;
- p = ifcqs->ifqs_priq_stats.xmitcnt.packets;
- break;
- case PKTSCHEDT_HFSC:
- b = ifcqs->ifqs_hfsc_stats.xmit_cnt.bytes;
- p = ifcqs->ifqs_hfsc_stats.xmit_cnt.packets;
- break;
- case PKTSCHEDT_FAIRQ:
- b = ifcqs->ifqs_fairq_stats.xmit_cnt.bytes;
- p = ifcqs->ifqs_fairq_stats.xmit_cnt.packets;
- break;
- case PKTSCHEDT_TCQ:
- b = ifcqs->ifqs_tcq_stats.xmitcnt.bytes;
- p = ifcqs->ifqs_tcq_stats.xmitcnt.packets;
- break;
- case PKTSCHEDT_QFQ:
- b = ifcqs->ifqs_qfq_stats.xmitcnt.bytes;
- p = ifcqs->ifqs_qfq_stats.xmitcnt.packets;
+ 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;
qs->avgn++;
}
-static char *
-qtype2str(classq_type_t t)
-{
- char *c;
-
- switch (t) {
- case Q_DROPHEAD:
- c = "DROPHEAD";
- break;
- case Q_DROPTAIL:
- c = "DROPTAIL";
- break;
- case Q_RED:
- c = "RED";
- break;
- case Q_RIO:
- c = "RIO";
- break;
- case Q_BLUE:
- c = "BLUE";
- break;
- case Q_SFB:
- c = "SFB";
- break;
- default:
- c = "UNKNOWN";
- break;
- }
-
- return (c);
-}
-
#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)
case PKTSCHEDT_NONE:
c = "NONE";
break;
- case PKTSCHEDT_CBQ:
- c = "CBQ";
- break;
- case PKTSCHEDT_HFSC:
- c = "HFSC";
- break;
- case PKTSCHEDT_PRIQ:
- c = "PRIQ";
- break;
- case PKTSCHEDT_FAIRQ:
- c = "FAIRQ";
- break;
- case PKTSCHEDT_TCQ:
- c = "TCQ";
- break;
- case PKTSCHEDT_QFQ:
- c = "QFQ";
+ case PKTSCHEDT_FQ_CODEL:
+ c = "FQ_CODEL";
break;
default:
c = "UNKNOWN";
}
static char *
-qid2str(unsigned int s)
+pri2str(unsigned int i)
{
char *c;
-
- switch (s) {
- case 0:
- c = "BE";
- break;
- case 1:
+ switch (i) {
+ case 9:
c = "BK_SYS";
break;
- case 2:
+ case 8:
c = "BK";
break;
- case 3:
+ case 7:
+ c = "BE";
+ break;
+ case 6:
c = "RD";
break;
- case 4:
+ case 5:
c = "OAM";
break;
- case 5:
+ case 4:
c = "AV";
break;
- case 6:
+ case 3:
c = "RV";
break;
- case 7:
+ case 2:
c = "VI";
break;
- case 8:
+ case 1:
c = "VO";
break;
- case 9:
- c = "CTL";
- break;
- default:
- c = "UNKNOWN";
- break;
- }
-
- return (c);
-}
-
-static char *
-tcqslot2str(unsigned int s)
-{
- char *c;
-
- switch (s) {
case 0:
- case 3:
- case 4:
- c = "0,3,4";
- break;
- case 1:
- case 2:
- c = "1,2";
- break;
- case 5:
- case 6:
- case 7:
- c = "5-7";
- break;
- case 8:
- case 9:
- c = "8,9";
+ c = "CTL";
break;
default:
c = "?";
break;
}
-
- return (c);
-}
-
-static char *
-qstate2str(unsigned int s)
-{
- char *c;
-
- switch (s) {
- case QS_RUNNING:
- c = "(RUNNING)";
- break;
- case QS_SUSPENDED:
- c = "(SUSPENDED)";
- break;
- default:
- c = "(UNKNOWN)";
- break;
- }
-
return (c);
}
-#define R2S_BUFS 8
-#define RATESTR_MAX 16
-
-static char *
-rate2str(long double rate)
-{
- char *buf;
- static char r2sbuf[R2S_BUFS][RATESTR_MAX]; /* ring bufer */
- static int idx = 0;
- int i;
- static const char unit[] = " KMG";
-
- buf = r2sbuf[idx++];
- if (idx == R2S_BUFS)
- idx = 0;
-
- for (i = 0; rate >= 1000 && i <= 3; i++)
- rate /= 1000;
-
- if ((int)(rate * 100) % 100)
- snprintf(buf, RATESTR_MAX, "%.2Lf%cb", rate, unit[i]);
- else
- snprintf(buf, RATESTR_MAX, "%lld%cb", (int64_t)rate, unit[i]);
-
- return (buf);
-}
-
void
rxpollstatpr(void)
{
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];
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 polled bytes: %21llu ]\n",
- sp->ifi_poll_packets, sp->ifi_poll_bytes);
+ 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(" [ wakeups lowat/hiwat threshold: %10u / %10u ]\n",
sp->ifi_poll_wakeups_lowat, sp->ifi_poll_wakeups_hiwat);
+ np = &ifmsupp.ifmd_netif_stats;
+ printf(" [ mit mode: %24U cfg idx: %26u ]\n",
+ np->ifn_rx_mit_mode, np->ifn_rx_mit_cfg_idx);
+ printf(" [ cfg packets lo/hi threshold: %12u / %12u ]\n",
+ np->ifn_rx_mit_cfg_packets_lowat, np->ifn_rx_mit_cfg_packets_hiwat);
+ printf(" [ cfg bytes lo/hi threshold: %12u / %12u ]\n",
+ np->ifn_rx_mit_cfg_bytes_lowat, np->ifn_rx_mit_cfg_bytes_hiwat);
+ printf(" [ cfg interval: %15u nsec ]\n",
+ np->ifn_rx_mit_cfg_interval);
+ printf(" [ mit interval: %15llu nsec ]\n",
+ np->ifn_rx_mit_interval);
+ printf(" [ mit packets avg/min/max: %12u / %12u / %12u ]\n",
+ np->ifn_rx_mit_packets_avg, np->ifn_rx_mit_packets_min,
+ np->ifn_rx_mit_packets_max);
+ printf(" [ mit bytes avg/min/max: %12u / %12u / %12u ]\n",
+ np->ifn_rx_mit_bytes_avg, np->ifn_rx_mit_bytes_min,
+ np->ifn_rx_mit_bytes_max);
+
+ fflush(stdout);
+
+ if (interval > 0) {
+ sigemptyset(&sigset);
+ sigaddset(&sigset, SIGALRM);
+ (void) sigprocmask(SIG_BLOCK, &sigset, &oldsigset);
+ if (!signalled) {
+ sigemptyset(&sigset);
+ sigsuspend(&sigset);
+ }
+ (void) sigprocmask(SIG_SETMASK, &oldsigset, NULL);
+
+ signalled = NO;
+ goto loop;
+ }
+}
+
+static int
+create_control_socket(const char *control_name)
+{
+ struct sockaddr_ctl sc;
+ struct ctl_info ctl;
+ int fd;
+
+ fd = socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL);
+ if (fd == -1) {
+ perror("socket(PF_SYSTEM)");
+ return fd;
+ }
+
+ /* Get the control ID for statistics */
+ bzero(&ctl, sizeof(ctl));
+ strlcpy(ctl.ctl_name, control_name, sizeof(ctl.ctl_name));
+ if (ioctl(fd, CTLIOCGINFO, &ctl) == -1)
+ {
+ perror("ioctl(CTLIOCGINFO)");
+ close(fd);
+ return -1;
+ }
+
+ /* Connect to the statistics control */
+ bzero(&sc, sizeof(sc));
+ sc.sc_len = sizeof(sc);
+ sc.sc_family = AF_SYSTEM;
+ sc.ss_sysaddr = SYSPROTO_CONTROL;
+ sc.sc_id = ctl.ctl_id;
+ sc.sc_unit = 0;
+ if (connect(fd, (struct sockaddr*)&sc, sc.sc_len) != 0)
+ {
+ perror("connect(SYSPROTO_CONTROL)");
+ close(fd);
+ return -1;
+ }
+
+ /* Set socket to non-blocking operation */
+ if (fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK) == -1) {
+ perror("fcnt(F_SETFL,O_NONBLOCK)");
+ close(fd);
+ return -1;
+ }
+ return fd;
+}
+
+static int
+add_nstat_src(int fd, const nstat_ifnet_add_param *ifparam,
+ nstat_src_ref_t *outsrc)
+{
+ nstat_msg_add_src_req *addreq;
+ nstat_msg_src_added *addedmsg;
+ nstat_ifnet_add_param *param;
+ char buffer[sizeof(*addreq) + sizeof(*param)];
+ ssize_t result;
+ const u_int32_t addreqsize =
+ offsetof(struct nstat_msg_add_src, param) + sizeof(*param);
+
+ /* Setup the add source request */
+ addreq = (nstat_msg_add_src_req *)buffer;
+ param = (nstat_ifnet_add_param*)addreq->param;
+ bzero(addreq, addreqsize);
+ addreq->hdr.context = (uintptr_t)&buffer;
+ addreq->hdr.type = NSTAT_MSG_TYPE_ADD_SRC;
+ addreq->provider = NSTAT_PROVIDER_IFNET;
+ bzero(param, sizeof(*param));
+ param->ifindex = ifparam->ifindex;
+ param->threshold = ifparam->threshold;
+
+ /* Send the add source request */
+ result = send(fd, addreq, addreqsize, 0);
+ if (result != addreqsize)
+ {
+ if (result == -1)
+ perror("send(NSTAT_ADD_SRC_REQ)");
+ else
+ fprintf(stderr, "%s: could only sent %ld out of %d\n",
+ __func__, result, addreqsize);
+ return -1;
+ }
+
+ /* Receive the response */
+ addedmsg = (nstat_msg_src_added *)buffer;
+ result = recv(fd, addedmsg, sizeof(buffer), 0);
+ if (result < sizeof(*addedmsg))
+ {
+ if (result == -1)
+ perror("recv(NSTAT_ADD_SRC_RSP)");
+ else
+ fprintf(stderr, "%s: recv too small, received %ld, "
+ "expected %lu\n", __func__, result,
+ sizeof(*addedmsg));
+ return -1;
+ }
+
+ if (addedmsg->hdr.type != NSTAT_MSG_TYPE_SRC_ADDED)
+ {
+ fprintf(stderr, "%s: received wrong message type, received %u "
+ "expected %u\n", __func__, addedmsg->hdr.type,
+ NSTAT_MSG_TYPE_SRC_ADDED);
+ return -1;
+ }
+
+ if (addedmsg->hdr.context != (uintptr_t)&buffer)
+ {
+ fprintf(stderr, "%s: received wrong context, received %llu "
+ "expected %lu\n", __func__, addedmsg->hdr.context,
+ (uintptr_t)&buffer);
+ return -1;
+ }
+ *outsrc = addedmsg->srcref;
+ return 0;
+}
+
+static int
+rem_nstat_src(int fd, nstat_src_ref_t sref)
+{
+ nstat_msg_rem_src_req *remreq;
+ nstat_msg_src_removed *remrsp;
+ char buffer[sizeof(*remreq)];
+ ssize_t result;
+
+ /* Setup the add source request */
+ remreq = (nstat_msg_rem_src_req *)buffer;
+ bzero(remreq, sizeof(*remreq));
+ remreq->hdr.type = NSTAT_MSG_TYPE_REM_SRC;
+ remreq->srcref = sref;
+
+ /* Send the remove source request */
+ result = send(fd, remreq, sizeof(*remreq), 0);
+ if (result != sizeof(*remreq)) {
+ if (result == -1)
+ perror("send(NSTAT_REM_SRC_REQ)");
+ else
+ fprintf(stderr, "%s: could only sent %ld out of %lu\n",
+ __func__, result, sizeof(*remreq));
+ return -1;
+ }
+
+ /* Receive the response */
+ remrsp = (nstat_msg_src_removed *)buffer;
+ result = recv(fd, remrsp, sizeof(buffer), 0);
+ if (result < sizeof(*remrsp)) {
+ if (result == -1)
+ perror("recv(NSTAT_REM_SRC_RSP)");
+ else
+ fprintf(stderr, "%s: recv too small, received %ld, "
+ "expected %lu\n", __func__, result,
+ sizeof(*remrsp));
+ return -1;
+ }
+
+ if (remrsp->hdr.type != NSTAT_MSG_TYPE_SRC_REMOVED) {
+ fprintf(stderr, "%s: received wrong message type, received %u "
+ "expected %u\n", __func__, remrsp->hdr.type,
+ NSTAT_MSG_TYPE_SRC_REMOVED);
+ return -1;
+ }
+
+ if (remrsp->srcref != sref) {
+ fprintf(stderr, "%s: received invalid srcref, received %llu "
+ "expected %llu\n", __func__, remrsp->srcref, sref);
+ }
+ return 0;
+}
+
+static int
+get_src_decsription(int fd, nstat_src_ref_t srcref,
+ struct nstat_ifnet_descriptor *ifdesc)
+{
+ nstat_msg_get_src_description *dreq;
+ nstat_msg_src_description *drsp;
+ char buffer[sizeof(*drsp) + sizeof(*ifdesc)];
+ ssize_t result;
+ const u_int32_t descsize =
+ offsetof(struct nstat_msg_src_description, data) +
+ sizeof(nstat_ifnet_descriptor);
+
+ dreq = (nstat_msg_get_src_description *)buffer;
+ bzero(dreq, sizeof(*dreq));
+ dreq->hdr.type = NSTAT_MSG_TYPE_GET_SRC_DESC;
+ dreq->srcref = srcref;
+ result = send(fd, dreq, sizeof(*dreq), 0);
+ if (result != sizeof(*dreq))
+ {
+ if (result == -1)
+ perror("send(NSTAT_GET_SRC_DESC_REQ)");
+ else
+ fprintf(stderr, "%s: sent %ld out of %lu\n",
+ __func__, result, sizeof(*dreq));
+ return -1;
+ }
+
+ /* Receive the source description response */
+ drsp = (nstat_msg_src_description *)buffer;
+ result = recv(fd, drsp, sizeof(buffer), 0);
+ if (result < descsize)
+ {
+ if (result == -1)
+ perror("recv(NSTAT_GET_SRC_DESC_RSP");
+ else
+ fprintf(stderr, "%s: recv too small, received %ld, "
+ "expected %u\n", __func__, result, descsize);
+ return -1;
+ }
+
+ if (drsp->hdr.type != NSTAT_MSG_TYPE_SRC_DESC)
+ {
+ fprintf(stderr, "%s: received wrong message type, received %u "
+ "expected %u\n", __func__, drsp->hdr.type,
+ NSTAT_MSG_TYPE_SRC_DESC);
+ return -1;
+ }
+
+ if (drsp->srcref != srcref)
+ {
+ fprintf(stderr, "%s: received message for wrong source, "
+ "received 0x%llx expected 0x%llx\n",
+ __func__, drsp->srcref, srcref);
+ return -1;
+ }
+
+ bcopy(drsp->data, ifdesc, sizeof(*ifdesc));
+ return 0;
+}
+
+static void
+print_wifi_status(nstat_ifnet_desc_wifi_status *status)
+{
+ int tmp;
+#define val(x, f) \
+ ((status->valid_bitmask & NSTAT_IFNET_DESC_WIFI_ ## f ## _VALID) ?\
+ status->x : -1)
+#define parg(n, un) #n, val(n, un)
+#define pretxtl(n, un) \
+ (((tmp = val(n, un)) == -1) ? "(not valid)" : \
+ ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_NONE) ? "(none)" : \
+ ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_LOW) ? "(low)" : \
+ ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_MEDIUM) ? "(medium)" : \
+ ((tmp == NSTAT_IFNET_DESC_WIFI_UL_RETXT_LEVEL_HIGH) ? "(high)" : \
+ "(?)")))))
+
+ printf("\nwifi status:\n");
+ printf(
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t\t%d%s\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t\t%d\n",
+ parg(link_quality_metric, LINK_QUALITY_METRIC),
+ parg(ul_effective_bandwidth, UL_EFFECTIVE_BANDWIDTH),
+ parg(ul_max_bandwidth, UL_MAX_BANDWIDTH),
+ parg(ul_min_latency, UL_MIN_LATENCY),
+ parg(ul_effective_latency, UL_EFFECTIVE_LATENCY),
+ parg(ul_max_latency, UL_MAX_LATENCY),
+ parg(ul_retxt_level, UL_RETXT_LEVEL),
+ pretxtl(ul_retxt_level, UL_RETXT_LEVEL),
+ parg(ul_bytes_lost, UL_BYTES_LOST),
+ parg(ul_error_rate, UL_ERROR_RATE),
+ parg(dl_effective_bandwidth, DL_EFFECTIVE_BANDWIDTH),
+ parg(dl_max_bandwidth, DL_MAX_BANDWIDTH),
+ parg(dl_min_latency, DL_MIN_LATENCY),
+ parg(dl_effective_latency, DL_EFFECTIVE_LATENCY),
+ parg(dl_max_latency, DL_MAX_LATENCY),
+ parg(dl_error_rate, DL_ERROR_RATE),
+ parg(config_frequency, CONFIG_FREQUENCY),
+ parg(config_multicast_rate, CONFIG_MULTICAST_RATE),
+ parg(scan_count, CONFIG_SCAN_COUNT),
+ parg(scan_duration, CONFIG_SCAN_DURATION)
+ );
+#undef pretxtl
+#undef parg
+#undef val
+}
+
+static void
+print_cellular_status(nstat_ifnet_desc_cellular_status *status)
+{
+ int tmp, tmp_mss;
+#define val(x, f) \
+ ((status->valid_bitmask & NSTAT_IFNET_DESC_CELL_ ## f ## _VALID) ?\
+ status->x : -1)
+#define parg(n, un) #n, val(n, un)
+#define pretxtl(n, un) \
+ (((tmp = val(n, un)) == -1) ? "(not valid)" : \
+ ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_NONE) ? "(none)" : \
+ ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_LOW) ? "(low)" : \
+ ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_MEDIUM) ? "(medium)" : \
+ ((tmp == NSTAT_IFNET_DESC_CELL_UL_RETXT_LEVEL_HIGH) ? "(high)" : \
+ "(?)")))))
+#define pretxtm(n, un) \
+ (((tmp_mss = val(n,un)) == -1) ? "(not valid)" : \
+ ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_NONE) ? "(none)" : \
+ ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_MEDIUM) ? "(medium)" : \
+ ((tmp_mss == NSTAT_IFNET_DESC_MSS_RECOMMENDED_LOW) ? "(low)" : \
+ "(?)"))))
+
+ printf("\ncellular status:\n");
+ printf(
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t\t%d%s\n"
+ "\t%s:\t\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d\n"
+ "\t%s:\t%d %s\n",
+ parg(link_quality_metric, LINK_QUALITY_METRIC),
+ parg(ul_effective_bandwidth, UL_EFFECTIVE_BANDWIDTH),
+ parg(ul_max_bandwidth, UL_MAX_BANDWIDTH),
+ parg(ul_min_latency, UL_MIN_LATENCY),
+ parg(ul_effective_latency, UL_EFFECTIVE_LATENCY),
+ parg(ul_max_latency, UL_MAX_LATENCY),
+ parg(ul_retxt_level, UL_RETXT_LEVEL),
+ pretxtl(ul_retxt_level, UL_RETXT_LEVEL),
+ parg(ul_bytes_lost, UL_BYTES_LOST),
+ parg(ul_min_queue_size, UL_MIN_QUEUE_SIZE),
+ parg(ul_avg_queue_size, UL_AVG_QUEUE_SIZE),
+ parg(ul_max_queue_size, UL_MAX_QUEUE_SIZE),
+ parg(dl_effective_bandwidth, DL_EFFECTIVE_BANDWIDTH),
+ parg(dl_max_bandwidth, DL_MAX_BANDWIDTH),
+ parg(config_inactivity_time, CONFIG_INACTIVITY_TIME),
+ parg(config_backoff_time, CONFIG_BACKOFF_TIME),
+ parg(mss_recommended, MSS_RECOMMENDED),
+ pretxtm(mss_recommended, MSS_RECOMMENDED)
+ );
+#undef pretxtl
+#undef parg
+#undef val
+}
+
+static int
+get_interface_state(int fd, const char *ifname, struct ifreq *ifr)
+{
+ bzero(ifr, sizeof(*ifr));
+ snprintf(ifr->ifr_name, sizeof(ifr->ifr_name), "%s", ifname);
+
+ if (ioctl(fd, SIOCGIFINTERFACESTATE, ifr) == -1) {
+ perror("ioctl(CTLIOCGINFO)");
+ return -1;
+ }
+ return 0;
+}
+
+static void
+print_interface_state(struct ifreq *ifr)
+{
+ int lqm, rrc, avail;
+
+ printf("\ninterface state:\n");
+
+ if (ifr->ifr_interface_state.valid_bitmask &
+ IF_INTERFACE_STATE_LQM_STATE_VALID) {
+ printf("\tlqm: ");
+ lqm = ifr->ifr_interface_state.lqm_state;
+ if (lqm == IFNET_LQM_THRESH_GOOD)
+ printf("\"good\"");
+ else if (lqm == IFNET_LQM_THRESH_POOR)
+ printf("\"poor\"");
+ else if (lqm == IFNET_LQM_THRESH_BAD)
+ printf("\"bad\"");
+ else if (lqm == IFNET_LQM_THRESH_UNKNOWN)
+ printf("\"unknown\"");
+ else if (lqm == IFNET_LQM_THRESH_OFF)
+ printf("\"off\"");
+ else
+ printf("invalid(%d)", lqm);
+ }
+
+ if (ifr->ifr_interface_state.valid_bitmask &
+ IF_INTERFACE_STATE_RRC_STATE_VALID) {
+ printf("\trrc: ");
+ rrc = ifr->ifr_interface_state.rrc_state;
+ if (rrc == IF_INTERFACE_STATE_RRC_STATE_CONNECTED)
+ printf("\"connected\"");
+ else if (rrc == IF_INTERFACE_STATE_RRC_STATE_IDLE)
+ printf("\"idle\"");
+ else
+ printf("\"invalid(%d)\"", rrc);
+ }
+
+ if (ifr->ifr_interface_state.valid_bitmask &
+ IF_INTERFACE_STATE_INTERFACE_AVAILABILITY_VALID) {
+ printf("\tavailability: ");
+ avail = ifr->ifr_interface_state.interface_availability;
+ if (avail == IF_INTERFACE_STATE_INTERFACE_AVAILABLE)
+ printf("\"true\"");
+ else if (rrc == IF_INTERFACE_STATE_INTERFACE_UNAVAILABLE)
+ printf("\"false\"");
+ else
+ printf("\"invalid(%d)\"", avail);
+ }
+}
+
+void
+print_link_status(const char *ifname)
+{
+ unsigned int ifindex;
+ struct itimerval timer_interval;
+ sigset_t sigset, oldsigset;
+ struct nstat_ifnet_descriptor ifdesc;
+ nstat_ifnet_add_param ifparam;
+ nstat_src_ref_t sref = 0;
+ struct ifreq ifr;
+ int ctl_fd;
+
+ ifindex = if_nametoindex(ifname);
+ if (ifindex == 0) {
+ fprintf(stderr, "Invalid interface name\n");
+ return;
+ }
+
+ if ((ctl_fd = create_control_socket(NET_STAT_CONTROL_NAME)) < 0)
+ return;
+
+ ifparam.ifindex = ifindex;
+ ifparam.threshold = UINT64_MAX;
+ if (add_nstat_src(ctl_fd, &ifparam, &sref))
+ goto done;
+loop:
+ if (interval > 0) {
+ /* create a timer that fires repeatedly every interval
+ * seconds */
+ timer_interval.it_value.tv_sec = interval;
+ timer_interval.it_value.tv_usec = 0;
+ timer_interval.it_interval.tv_sec = interval;
+ timer_interval.it_interval.tv_usec = 0;
+ (void) signal(SIGALRM, catchalarm);
+ signalled = NO;
+ (void) setitimer(ITIMER_REAL, &timer_interval, NULL);
+ }
+
+ /* get interface state */
+ if (get_interface_state(ctl_fd, ifname, &ifr))
+ goto done;
+
+ /* get ntstat interface description */
+ if (get_src_decsription(ctl_fd, sref, &ifdesc))
+ goto done;
+
+ /* print time */
+ printf("\n%s: ", ifname);
+ print_time();
+
+ /* print interface state */
+ print_interface_state(&ifr);
+
+ /* print ntsat interface link status */
+ if (ifdesc.link_status.link_status_type ==
+ NSTAT_IFNET_DESC_LINK_STATUS_TYPE_CELLULAR)
+ print_cellular_status(&ifdesc.link_status.u.cellular);
+ else if (ifdesc.link_status.link_status_type ==
+ NSTAT_IFNET_DESC_LINK_STATUS_TYPE_WIFI)
+ print_wifi_status(&ifdesc.link_status.u.wifi);
+
fflush(stdout);
if (interval > 0) {
signalled = NO;
goto loop;
}
+done:
+ if (sref)
+ rem_nstat_src(ctl_fd, sref);
+ close(ctl_fd);
}
projects / apple / network_cmds.git / blobdiff