17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 545916cd2Sjpk * Common Development and Distribution License (the "License"). 645916cd2Sjpk * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22550b6e40SSowmini Varadhan * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 237c478bd9Sstevel@tonic-gate * Copyright (c) 1990 Mentat Inc. 247c478bd9Sstevel@tonic-gate * netstat.c 2.2, last change 9/9/91 257c478bd9Sstevel@tonic-gate * MROUTING Revision 3.5 26d38b7101SDan McDonald * Copyright 2018, Joyent, Inc. 27*a02120c4SAndy Fiddaman * Copyright 2020 OmniOS Community Edition (OmniOSce) Association. 287c478bd9Sstevel@tonic-gate */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate /* 317c478bd9Sstevel@tonic-gate * simple netstat based on snmp/mib-2 interface to the TCP/IP stack 327c478bd9Sstevel@tonic-gate * 337c478bd9Sstevel@tonic-gate * TODO: 347c478bd9Sstevel@tonic-gate * Add ability to request subsets from kernel (with level = MIB2_IP; 357c478bd9Sstevel@tonic-gate * name = 0 meaning everything for compatibility) 367c478bd9Sstevel@tonic-gate */ 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #include <stdio.h> 397c478bd9Sstevel@tonic-gate #include <stdlib.h> 407c478bd9Sstevel@tonic-gate #include <stdarg.h> 417c478bd9Sstevel@tonic-gate #include <unistd.h> 427c478bd9Sstevel@tonic-gate #include <strings.h> 437c478bd9Sstevel@tonic-gate #include <string.h> 447c478bd9Sstevel@tonic-gate #include <errno.h> 457c478bd9Sstevel@tonic-gate #include <ctype.h> 467c478bd9Sstevel@tonic-gate #include <kstat.h> 477c478bd9Sstevel@tonic-gate #include <assert.h> 4826fd7700SKrishnendu Sadhukhan - Sun Microsystems #include <locale.h> 49afee3dc6SRobert Mustacchi #include <synch.h> 50afee3dc6SRobert Mustacchi #include <thread.h> 5178a2e113SAndy Fiddaman #include <pwd.h> 5278a2e113SAndy Fiddaman #include <limits.h> 5378a2e113SAndy Fiddaman #include <sys/ccompile.h> 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate #include <sys/types.h> 5678a2e113SAndy Fiddaman #include <sys/stat.h> 577c478bd9Sstevel@tonic-gate #include <sys/stream.h> 587c478bd9Sstevel@tonic-gate #include <stropts.h> 597c478bd9Sstevel@tonic-gate #include <sys/strstat.h> 607c478bd9Sstevel@tonic-gate #include <sys/tihdr.h> 6178a2e113SAndy Fiddaman #include <procfs.h> 6278a2e113SAndy Fiddaman #include <dirent.h> 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate #include <sys/socket.h> 6578a2e113SAndy Fiddaman #include <sys/socketvar.h> 667c478bd9Sstevel@tonic-gate #include <sys/sockio.h> 677c478bd9Sstevel@tonic-gate #include <netinet/in.h> 687c478bd9Sstevel@tonic-gate #include <net/if.h> 697c478bd9Sstevel@tonic-gate #include <net/route.h> 707c478bd9Sstevel@tonic-gate 717c478bd9Sstevel@tonic-gate #include <inet/mib2.h> 727c478bd9Sstevel@tonic-gate #include <inet/ip.h> 737c478bd9Sstevel@tonic-gate #include <inet/arp.h> 747c478bd9Sstevel@tonic-gate #include <inet/tcp.h> 757c478bd9Sstevel@tonic-gate #include <netinet/igmp_var.h> 767c478bd9Sstevel@tonic-gate #include <netinet/ip_mroute.h> 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 797c478bd9Sstevel@tonic-gate #include <netdb.h> 807c478bd9Sstevel@tonic-gate #include <fcntl.h> 817c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 827c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate #include <netinet/dhcp.h> 857c478bd9Sstevel@tonic-gate #include <dhcpagent_ipc.h> 867c478bd9Sstevel@tonic-gate #include <dhcpagent_util.h> 877c478bd9Sstevel@tonic-gate #include <compat.h> 8878a2e113SAndy Fiddaman #include <sys/mkdev.h> 897c478bd9Sstevel@tonic-gate 9045916cd2Sjpk #include <libtsnet.h> 9145916cd2Sjpk #include <tsol/label.h> 9245916cd2Sjpk 9378a2e113SAndy Fiddaman #include <libproc.h> 9426fd7700SKrishnendu Sadhukhan - Sun Microsystems 9578a2e113SAndy Fiddaman #include "statcommon.h" 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate #define STR_EXPAND 4 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate #define V4MASK_TO_V6(v4, v6) ((v6)._S6_un._S6_u32[0] = 0xfffffffful, \ 1007c478bd9Sstevel@tonic-gate (v6)._S6_un._S6_u32[1] = 0xfffffffful, \ 1017c478bd9Sstevel@tonic-gate (v6)._S6_un._S6_u32[2] = 0xfffffffful, \ 1027c478bd9Sstevel@tonic-gate (v6)._S6_un._S6_u32[3] = (v4)) 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate #define IN6_IS_V4MASK(v6) ((v6)._S6_un._S6_u32[0] == 0xfffffffful && \ 1057c478bd9Sstevel@tonic-gate (v6)._S6_un._S6_u32[1] == 0xfffffffful && \ 1067c478bd9Sstevel@tonic-gate (v6)._S6_un._S6_u32[2] == 0xfffffffful) 1077c478bd9Sstevel@tonic-gate 108d04ccbb3Scarlsonj /* 109d04ccbb3Scarlsonj * This is used as a cushion in the buffer allocation directed by SIOCGLIFNUM. 110d04ccbb3Scarlsonj * Because there's no locking between SIOCGLIFNUM and SIOCGLIFCONF, it's 111d04ccbb3Scarlsonj * possible for an administrator to plumb new interfaces between those two 112d04ccbb3Scarlsonj * calls, resulting in the failure of the latter. This addition makes that 113d04ccbb3Scarlsonj * less likely. 114d04ccbb3Scarlsonj */ 115d04ccbb3Scarlsonj #define LIFN_GUARD_VALUE 10 116d04ccbb3Scarlsonj 1177c478bd9Sstevel@tonic-gate typedef struct mib_item_s { 1187c478bd9Sstevel@tonic-gate struct mib_item_s *next_item; 1197c478bd9Sstevel@tonic-gate int group; 1207c478bd9Sstevel@tonic-gate int mib_id; 1217c478bd9Sstevel@tonic-gate int length; 1227c478bd9Sstevel@tonic-gate void *valp; 1237c478bd9Sstevel@tonic-gate } mib_item_t; 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate struct ifstat { 1267c478bd9Sstevel@tonic-gate uint64_t ipackets; 1277c478bd9Sstevel@tonic-gate uint64_t ierrors; 1287c478bd9Sstevel@tonic-gate uint64_t opackets; 1297c478bd9Sstevel@tonic-gate uint64_t oerrors; 1307c478bd9Sstevel@tonic-gate uint64_t collisions; 1317c478bd9Sstevel@tonic-gate }; 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate struct iflist { 1347c478bd9Sstevel@tonic-gate struct iflist *next_if; 1357c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ]; 1367c478bd9Sstevel@tonic-gate struct ifstat tot; 1377c478bd9Sstevel@tonic-gate }; 1387c478bd9Sstevel@tonic-gate 13978a2e113SAndy Fiddaman static void fatal(int, char *, ...) __NORETURN; 14078a2e113SAndy Fiddaman 1417c478bd9Sstevel@tonic-gate static mib_item_t *mibget(int sd); 1427c478bd9Sstevel@tonic-gate static void mibfree(mib_item_t *firstitem); 1437c478bd9Sstevel@tonic-gate static int mibopen(void); 1447c478bd9Sstevel@tonic-gate static void mib_get_constants(mib_item_t *item); 1457c478bd9Sstevel@tonic-gate static mib_item_t *mib_item_dup(mib_item_t *item); 14678a2e113SAndy Fiddaman static mib_item_t *mib_item_diff(mib_item_t *item1, mib_item_t *item2); 1477c478bd9Sstevel@tonic-gate static void mib_item_destroy(mib_item_t **item); 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate static boolean_t octetstrmatch(const Octet_t *a, const Octet_t *b); 15045916cd2Sjpk static char *octetstr(const Octet_t *op, int code, 1517c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen); 15278a2e113SAndy Fiddaman static char *pr_addr(uint_t addr, char *dst, uint_t dstlen); 1537c478bd9Sstevel@tonic-gate static char *pr_addrnz(ipaddr_t addr, char *dst, uint_t dstlen); 1547c478bd9Sstevel@tonic-gate static char *pr_addr6(const in6_addr_t *addr, 1557c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen); 15678a2e113SAndy Fiddaman static char *pr_mask(uint_t addr, char *dst, uint_t dstlen); 15745916cd2Sjpk static char *pr_prefix6(const struct in6_addr *addr, 15845916cd2Sjpk uint_t prefixlen, char *dst, uint_t dstlen); 1597c478bd9Sstevel@tonic-gate static char *pr_ap(uint_t addr, uint_t port, 1607c478bd9Sstevel@tonic-gate char *proto, char *dst, uint_t dstlen); 1617c478bd9Sstevel@tonic-gate static char *pr_ap6(const in6_addr_t *addr, uint_t port, 1627c478bd9Sstevel@tonic-gate char *proto, char *dst, uint_t dstlen); 1637c478bd9Sstevel@tonic-gate static char *pr_net(uint_t addr, uint_t mask, 1647c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen); 1657c478bd9Sstevel@tonic-gate static char *pr_netaddr(uint_t addr, uint_t mask, 1667c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen); 1677c478bd9Sstevel@tonic-gate static char *fmodestr(uint_t fmode); 1687c478bd9Sstevel@tonic-gate static char *portname(uint_t port, char *proto, 1697c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen); 1707c478bd9Sstevel@tonic-gate 17145916cd2Sjpk static const char *mitcp_state(int code, 17245916cd2Sjpk const mib2_transportMLPEntry_t *attr); 17345916cd2Sjpk static const char *miudp_state(int code, 17445916cd2Sjpk const mib2_transportMLPEntry_t *attr); 1757c478bd9Sstevel@tonic-gate 1767c478bd9Sstevel@tonic-gate static void stat_report(mib_item_t *item); 1777c478bd9Sstevel@tonic-gate static void mrt_stat_report(mib_item_t *item); 1787c478bd9Sstevel@tonic-gate static void arp_report(mib_item_t *item); 1797c478bd9Sstevel@tonic-gate static void ndp_report(mib_item_t *item); 1807c478bd9Sstevel@tonic-gate static void mrt_report(mib_item_t *item); 1817c478bd9Sstevel@tonic-gate static void if_stat_total(struct ifstat *oldstats, 1827c478bd9Sstevel@tonic-gate struct ifstat *newstats, struct ifstat *sumstats); 1837c478bd9Sstevel@tonic-gate static void if_report(mib_item_t *item, char *ifname, 1847c478bd9Sstevel@tonic-gate int Iflag_only, boolean_t once_only); 1857c478bd9Sstevel@tonic-gate static void if_report_ip4(mib2_ipAddrEntry_t *ap, 1867c478bd9Sstevel@tonic-gate char ifname[], char logintname[], 1877c478bd9Sstevel@tonic-gate struct ifstat *statptr, boolean_t ksp_not_null); 1887c478bd9Sstevel@tonic-gate static void if_report_ip6(mib2_ipv6AddrEntry_t *ap6, 1897c478bd9Sstevel@tonic-gate char ifname[], char logintname[], 1907c478bd9Sstevel@tonic-gate struct ifstat *statptr, boolean_t ksp_not_null); 19145916cd2Sjpk static void ire_report(const mib_item_t *item); 19245916cd2Sjpk static void tcp_report(const mib_item_t *item); 19345916cd2Sjpk static void udp_report(const mib_item_t *item); 19478a2e113SAndy Fiddaman static void uds_report(kstat_ctl_t *); 1957c478bd9Sstevel@tonic-gate static void group_report(mib_item_t *item); 196bd670b35SErik Nordmark static void dce_report(mib_item_t *item); 1977c478bd9Sstevel@tonic-gate static void print_ip_stats(mib2_ip_t *ip); 1987c478bd9Sstevel@tonic-gate static void print_icmp_stats(mib2_icmp_t *icmp); 1997c478bd9Sstevel@tonic-gate static void print_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6); 2007c478bd9Sstevel@tonic-gate static void print_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6); 2017c478bd9Sstevel@tonic-gate static void print_sctp_stats(mib2_sctp_t *tcp); 2027c478bd9Sstevel@tonic-gate static void print_tcp_stats(mib2_tcp_t *tcp); 2037c478bd9Sstevel@tonic-gate static void print_udp_stats(mib2_udp_t *udp); 2047c478bd9Sstevel@tonic-gate static void print_rawip_stats(mib2_rawip_t *rawip); 2057c478bd9Sstevel@tonic-gate static void print_igmp_stats(struct igmpstat *igps); 2067c478bd9Sstevel@tonic-gate static void print_mrt_stats(struct mrtstat *mrts); 20745916cd2Sjpk static void sctp_report(const mib_item_t *item); 2087c478bd9Sstevel@tonic-gate static void sum_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6, 2097c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *sum6); 2107c478bd9Sstevel@tonic-gate static void sum_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6, 2117c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *sum6); 2127c478bd9Sstevel@tonic-gate static void m_report(void); 2137c478bd9Sstevel@tonic-gate static void dhcp_report(char *); 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate static uint64_t kstat_named_value(kstat_t *, char *); 2167c478bd9Sstevel@tonic-gate static kid_t safe_kstat_read(kstat_ctl_t *, kstat_t *, void *); 2177c478bd9Sstevel@tonic-gate static int isnum(char *); 2187c478bd9Sstevel@tonic-gate static char *plural(int n); 2197c478bd9Sstevel@tonic-gate static char *pluraly(int n); 2207c478bd9Sstevel@tonic-gate static char *plurales(int n); 2217c478bd9Sstevel@tonic-gate static void process_filter(char *arg); 222e11c3f44Smeem static char *ifindex2str(uint_t, char *); 2237c478bd9Sstevel@tonic-gate static boolean_t family_selected(int family); 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate static void usage(char *); 22678a2e113SAndy Fiddaman static char *get_username(uid_t); 22778a2e113SAndy Fiddaman 22878a2e113SAndy Fiddaman static void process_hash_build(void); 22978a2e113SAndy Fiddaman static void process_hash_free(void); 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate #define PLURAL(n) plural((int)n) 2327c478bd9Sstevel@tonic-gate #define PLURALY(n) pluraly((int)n) 2337c478bd9Sstevel@tonic-gate #define PLURALES(n) plurales((int)n) 2347c478bd9Sstevel@tonic-gate #define IFLAGMOD(flg, val1, val2) if (flg == val1) flg = val2 2357c478bd9Sstevel@tonic-gate #define MDIFF(diff, elem2, elem1, member) (diff)->member = \ 2367c478bd9Sstevel@tonic-gate (elem2)->member - (elem1)->member 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate static boolean_t Aflag = B_FALSE; /* All sockets/ifs/rtng-tbls */ 239d38b7101SDan McDonald static boolean_t CIDRflag = B_FALSE; /* CIDR for IPv4 -i/-r addrs */ 240bd670b35SErik Nordmark static boolean_t Dflag = B_FALSE; /* DCE info */ 2417c478bd9Sstevel@tonic-gate static boolean_t Iflag = B_FALSE; /* IP Traffic Interfaces */ 2427c478bd9Sstevel@tonic-gate static boolean_t Mflag = B_FALSE; /* STREAMS Memory Statistics */ 2437c478bd9Sstevel@tonic-gate static boolean_t Nflag = B_FALSE; /* Numeric Network Addresses */ 2447c478bd9Sstevel@tonic-gate static boolean_t Rflag = B_FALSE; /* Routing Tables */ 24545916cd2Sjpk static boolean_t RSECflag = B_FALSE; /* Security attributes */ 2467c478bd9Sstevel@tonic-gate static boolean_t Sflag = B_FALSE; /* Per-protocol Statistics */ 2477c478bd9Sstevel@tonic-gate static boolean_t Vflag = B_FALSE; /* Verbose */ 24878a2e113SAndy Fiddaman static boolean_t Uflag = B_FALSE; /* Show PID and UID info. */ 2497c478bd9Sstevel@tonic-gate static boolean_t Pflag = B_FALSE; /* Net to Media Tables */ 2507c478bd9Sstevel@tonic-gate static boolean_t Gflag = B_FALSE; /* Multicast group membership */ 2517c478bd9Sstevel@tonic-gate static boolean_t MMflag = B_FALSE; /* Multicast routing table */ 2527c478bd9Sstevel@tonic-gate static boolean_t DHCPflag = B_FALSE; /* DHCP statistics */ 253bd670b35SErik Nordmark static boolean_t Xflag = B_FALSE; /* Debug Info */ 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate static int v4compat = 0; /* Compatible printing format for status */ 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate static int proto = IPPROTO_MAX; /* all protocols */ 2587c478bd9Sstevel@tonic-gate kstat_ctl_t *kc = NULL; 2597c478bd9Sstevel@tonic-gate 260afee3dc6SRobert Mustacchi /* 261afee3dc6SRobert Mustacchi * Name service timeout detection constants. 262afee3dc6SRobert Mustacchi */ 263afee3dc6SRobert Mustacchi static mutex_t ns_lock = ERRORCHECKMUTEX; 264afee3dc6SRobert Mustacchi static boolean_t ns_active = B_FALSE; /* Is a lookup ongoing? */ 265afee3dc6SRobert Mustacchi static hrtime_t ns_starttime; /* Time the lookup started */ 266afee3dc6SRobert Mustacchi static int ns_sleeptime = 2; /* Time in seconds between checks */ 267afee3dc6SRobert Mustacchi static int ns_warntime = 2; /* Time in seconds before warning */ 268afee3dc6SRobert Mustacchi 2697c478bd9Sstevel@tonic-gate /* 2707c478bd9Sstevel@tonic-gate * Sizes of data structures extracted from the base mib. 2717c478bd9Sstevel@tonic-gate * This allows the size of the tables entries to grow while preserving 2727c478bd9Sstevel@tonic-gate * binary compatibility. 2737c478bd9Sstevel@tonic-gate */ 2747c478bd9Sstevel@tonic-gate static int ipAddrEntrySize; 2757c478bd9Sstevel@tonic-gate static int ipRouteEntrySize; 2767c478bd9Sstevel@tonic-gate static int ipNetToMediaEntrySize; 2777c478bd9Sstevel@tonic-gate static int ipMemberEntrySize; 2787c478bd9Sstevel@tonic-gate static int ipGroupSourceEntrySize; 27945916cd2Sjpk static int ipRouteAttributeSize; 2807c478bd9Sstevel@tonic-gate static int vifctlSize; 2817c478bd9Sstevel@tonic-gate static int mfcctlSize; 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate static int ipv6IfStatsEntrySize; 2847c478bd9Sstevel@tonic-gate static int ipv6IfIcmpEntrySize; 2857c478bd9Sstevel@tonic-gate static int ipv6AddrEntrySize; 2867c478bd9Sstevel@tonic-gate static int ipv6RouteEntrySize; 2877c478bd9Sstevel@tonic-gate static int ipv6NetToMediaEntrySize; 2887c478bd9Sstevel@tonic-gate static int ipv6MemberEntrySize; 2897c478bd9Sstevel@tonic-gate static int ipv6GroupSourceEntrySize; 2907c478bd9Sstevel@tonic-gate 291bd670b35SErik Nordmark static int ipDestEntrySize; 292bd670b35SErik Nordmark 29345916cd2Sjpk static int transportMLPSize; 2947c478bd9Sstevel@tonic-gate static int tcpConnEntrySize; 2957c478bd9Sstevel@tonic-gate static int tcp6ConnEntrySize; 2967c478bd9Sstevel@tonic-gate static int udpEntrySize; 2977c478bd9Sstevel@tonic-gate static int udp6EntrySize; 2987c478bd9Sstevel@tonic-gate static int sctpEntrySize; 2997c478bd9Sstevel@tonic-gate static int sctpLocalEntrySize; 3007c478bd9Sstevel@tonic-gate static int sctpRemoteEntrySize; 3017c478bd9Sstevel@tonic-gate 3027c478bd9Sstevel@tonic-gate #define protocol_selected(p) (proto == IPPROTO_MAX || proto == (p)) 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate /* Machinery used for -f (filter) option */ 3055c0b7edeSseb enum { FK_AF = 0, FK_OUTIF, FK_DST, FK_FLAGS, NFILTERKEYS }; 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate static const char *filter_keys[NFILTERKEYS] = { 3085c0b7edeSseb "af", "outif", "dst", "flags" 3097c478bd9Sstevel@tonic-gate }; 3107c478bd9Sstevel@tonic-gate 3115f9878b0Sken Powell - Sun Microsystem static m_label_t *zone_security_label = NULL; 3125f9878b0Sken Powell - Sun Microsystem 3137c478bd9Sstevel@tonic-gate /* Flags on routes */ 3147c478bd9Sstevel@tonic-gate #define FLF_A 0x00000001 315bd670b35SErik Nordmark #define FLF_b 0x00000002 3167c478bd9Sstevel@tonic-gate #define FLF_D 0x00000004 3177c478bd9Sstevel@tonic-gate #define FLF_G 0x00000008 3187c478bd9Sstevel@tonic-gate #define FLF_H 0x00000010 3197c478bd9Sstevel@tonic-gate #define FLF_L 0x00000020 3207c478bd9Sstevel@tonic-gate #define FLF_U 0x00000040 3217c478bd9Sstevel@tonic-gate #define FLF_M 0x00000080 3227c478bd9Sstevel@tonic-gate #define FLF_S 0x00000100 323bd670b35SErik Nordmark #define FLF_C 0x00000200 /* IRE_IF_CLONE */ 324bd670b35SErik Nordmark #define FLF_I 0x00000400 /* RTF_INDIRECT */ 325bd670b35SErik Nordmark #define FLF_R 0x00000800 /* RTF_REJECT */ 326bd670b35SErik Nordmark #define FLF_B 0x00001000 /* RTF_BLACKHOLE */ 327550b6e40SSowmini Varadhan #define FLF_Z 0x00100000 /* RTF_ZONE */ 328bd670b35SErik Nordmark 329550b6e40SSowmini Varadhan static const char flag_list[] = "AbDGHLUMSCIRBZ"; 3307c478bd9Sstevel@tonic-gate 3317c478bd9Sstevel@tonic-gate typedef struct filter_rule filter_t; 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate struct filter_rule { 3347c478bd9Sstevel@tonic-gate filter_t *f_next; 3357c478bd9Sstevel@tonic-gate union { 3367c478bd9Sstevel@tonic-gate int f_family; 3377c478bd9Sstevel@tonic-gate const char *f_ifname; 3387c478bd9Sstevel@tonic-gate struct { 3397c478bd9Sstevel@tonic-gate struct hostent *f_address; 3407c478bd9Sstevel@tonic-gate in6_addr_t f_mask; 3417c478bd9Sstevel@tonic-gate } a; 3427c478bd9Sstevel@tonic-gate struct { 3437c478bd9Sstevel@tonic-gate uint_t f_flagset; 3447c478bd9Sstevel@tonic-gate uint_t f_flagclear; 3457c478bd9Sstevel@tonic-gate } f; 3467c478bd9Sstevel@tonic-gate } u; 3477c478bd9Sstevel@tonic-gate }; 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * The user-specified filters are linked into lists separated by 3517c478bd9Sstevel@tonic-gate * keyword (type of filter). Thus, the matching algorithm is: 3527c478bd9Sstevel@tonic-gate * For each non-empty filter list 3537c478bd9Sstevel@tonic-gate * If no filters in the list match 3547c478bd9Sstevel@tonic-gate * then stop here; route doesn't match 3557c478bd9Sstevel@tonic-gate * If loop above completes, then route does match and will be 3567c478bd9Sstevel@tonic-gate * displayed. 3577c478bd9Sstevel@tonic-gate */ 3587c478bd9Sstevel@tonic-gate static filter_t *filters[NFILTERKEYS]; 3597c478bd9Sstevel@tonic-gate 36026fd7700SKrishnendu Sadhukhan - Sun Microsystems static uint_t timestamp_fmt = NODATE; 36126fd7700SKrishnendu Sadhukhan - Sun Microsystems 36226fd7700SKrishnendu Sadhukhan - Sun Microsystems #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 36326fd7700SKrishnendu Sadhukhan - Sun Microsystems #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't */ 36426fd7700SKrishnendu Sadhukhan - Sun Microsystems #endif 36526fd7700SKrishnendu Sadhukhan - Sun Microsystems 366afee3dc6SRobert Mustacchi static void 367afee3dc6SRobert Mustacchi ns_lookup_start(void) 368afee3dc6SRobert Mustacchi { 369afee3dc6SRobert Mustacchi mutex_enter(&ns_lock); 370afee3dc6SRobert Mustacchi ns_active = B_TRUE; 371afee3dc6SRobert Mustacchi ns_starttime = gethrtime(); 372afee3dc6SRobert Mustacchi mutex_exit(&ns_lock); 373afee3dc6SRobert Mustacchi } 374afee3dc6SRobert Mustacchi 375afee3dc6SRobert Mustacchi static void 376afee3dc6SRobert Mustacchi ns_lookup_end(void) 377afee3dc6SRobert Mustacchi { 378afee3dc6SRobert Mustacchi mutex_enter(&ns_lock); 379afee3dc6SRobert Mustacchi ns_active = B_FALSE; 380afee3dc6SRobert Mustacchi mutex_exit(&ns_lock); 381afee3dc6SRobert Mustacchi } 382afee3dc6SRobert Mustacchi 383afee3dc6SRobert Mustacchi /* 384afee3dc6SRobert Mustacchi * When name services are not functioning, this program appears to hang to the 385afee3dc6SRobert Mustacchi * user. To try and give the user a chance of figuring out that this might be 386afee3dc6SRobert Mustacchi * the case, we end up warning them and suggest that they may want to use the -n 387afee3dc6SRobert Mustacchi * flag. 388afee3dc6SRobert Mustacchi */ 389afee3dc6SRobert Mustacchi /* ARGSUSED */ 390afee3dc6SRobert Mustacchi static void * 391afee3dc6SRobert Mustacchi ns_warning_thr(void *unsued) 392afee3dc6SRobert Mustacchi { 393afee3dc6SRobert Mustacchi for (;;) { 394afee3dc6SRobert Mustacchi hrtime_t now; 395afee3dc6SRobert Mustacchi 396afee3dc6SRobert Mustacchi (void) sleep(ns_sleeptime); 397afee3dc6SRobert Mustacchi now = gethrtime(); 398afee3dc6SRobert Mustacchi mutex_enter(&ns_lock); 399afee3dc6SRobert Mustacchi if (ns_active && now - ns_starttime >= ns_warntime * NANOSEC) { 400afee3dc6SRobert Mustacchi (void) fprintf(stderr, "warning: data " 401afee3dc6SRobert Mustacchi "available, but name service lookups are " 402afee3dc6SRobert Mustacchi "taking a while. Use the -n option to " 403afee3dc6SRobert Mustacchi "disable name service lookups.\n"); 404afee3dc6SRobert Mustacchi mutex_exit(&ns_lock); 405afee3dc6SRobert Mustacchi return (NULL); 406afee3dc6SRobert Mustacchi } 407afee3dc6SRobert Mustacchi mutex_exit(&ns_lock); 408afee3dc6SRobert Mustacchi } 409afee3dc6SRobert Mustacchi 410afee3dc6SRobert Mustacchi return (NULL); 411afee3dc6SRobert Mustacchi } 412afee3dc6SRobert Mustacchi 4137c478bd9Sstevel@tonic-gate int 4147c478bd9Sstevel@tonic-gate main(int argc, char **argv) 4157c478bd9Sstevel@tonic-gate { 4167c478bd9Sstevel@tonic-gate char *name; 4177c478bd9Sstevel@tonic-gate mib_item_t *item = NULL; 4187c478bd9Sstevel@tonic-gate mib_item_t *previtem = NULL; 4197c478bd9Sstevel@tonic-gate int sd = -1; 4207c478bd9Sstevel@tonic-gate char *ifname = NULL; 4217c478bd9Sstevel@tonic-gate int interval = 0; /* Single time by default */ 4227c478bd9Sstevel@tonic-gate int count = -1; /* Forever */ 4237c478bd9Sstevel@tonic-gate int c; 4247c478bd9Sstevel@tonic-gate int d; 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * Possible values of 'Iflag_only': 4277c478bd9Sstevel@tonic-gate * -1, no feature-flags; 4287c478bd9Sstevel@tonic-gate * 0, IFlag and other feature-flags enabled 4297c478bd9Sstevel@tonic-gate * 1, IFlag is the only feature-flag enabled 4307c478bd9Sstevel@tonic-gate * : trinary variable, modified using IFLAGMOD() 4317c478bd9Sstevel@tonic-gate */ 4327c478bd9Sstevel@tonic-gate int Iflag_only = -1; 4337c478bd9Sstevel@tonic-gate boolean_t once_only = B_FALSE; /* '-i' with count > 1 */ 4347c478bd9Sstevel@tonic-gate extern char *optarg; 4357c478bd9Sstevel@tonic-gate extern int optind; 4367c478bd9Sstevel@tonic-gate char *default_ip_str = NULL; 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate name = argv[0]; 4397c478bd9Sstevel@tonic-gate 4407c478bd9Sstevel@tonic-gate v4compat = get_compat_flag(&default_ip_str); 4417c478bd9Sstevel@tonic-gate if (v4compat == DEFAULT_PROT_BAD_VALUE) 4427c478bd9Sstevel@tonic-gate fatal(2, "%s: %s: Bad value for %s in %s\n", name, 4437c478bd9Sstevel@tonic-gate default_ip_str, DEFAULT_IP, INET_DEFAULT_FILE); 4447c478bd9Sstevel@tonic-gate free(default_ip_str); 4457c478bd9Sstevel@tonic-gate 44626fd7700SKrishnendu Sadhukhan - Sun Microsystems (void) setlocale(LC_ALL, ""); 44726fd7700SKrishnendu Sadhukhan - Sun Microsystems (void) textdomain(TEXT_DOMAIN); 44826fd7700SKrishnendu Sadhukhan - Sun Microsystems 44978a2e113SAndy Fiddaman while ((c = getopt(argc, argv, "acdimnrspMguvxf:P:I:DRT:")) != -1) { 4507c478bd9Sstevel@tonic-gate switch ((char)c) { 4517c478bd9Sstevel@tonic-gate case 'a': /* all connections */ 4527c478bd9Sstevel@tonic-gate Aflag = B_TRUE; 4537c478bd9Sstevel@tonic-gate break; 4547c478bd9Sstevel@tonic-gate 455d38b7101SDan McDonald case 'c': 456d38b7101SDan McDonald CIDRflag = B_TRUE; 457d38b7101SDan McDonald break; 458d38b7101SDan McDonald 459bd670b35SErik Nordmark case 'd': /* DCE info */ 4607c478bd9Sstevel@tonic-gate Dflag = B_TRUE; 461bd670b35SErik Nordmark IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 4627c478bd9Sstevel@tonic-gate break; 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate case 'i': /* interface (ill/ipif report) */ 4657c478bd9Sstevel@tonic-gate Iflag = B_TRUE; 4667c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, -1, 1); /* '-i' exists */ 4677c478bd9Sstevel@tonic-gate break; 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate case 'm': /* streams msg report */ 4707c478bd9Sstevel@tonic-gate Mflag = B_TRUE; 4717c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 4727c478bd9Sstevel@tonic-gate break; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate case 'n': /* numeric format */ 4757c478bd9Sstevel@tonic-gate Nflag = B_TRUE; 4767c478bd9Sstevel@tonic-gate break; 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate case 'r': /* route tables */ 4797c478bd9Sstevel@tonic-gate Rflag = B_TRUE; 4807c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 4817c478bd9Sstevel@tonic-gate break; 4827c478bd9Sstevel@tonic-gate 48345916cd2Sjpk case 'R': /* security attributes */ 48445916cd2Sjpk RSECflag = B_TRUE; 48545916cd2Sjpk IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 48645916cd2Sjpk break; 48745916cd2Sjpk 4887c478bd9Sstevel@tonic-gate case 's': /* per-protocol statistics */ 4897c478bd9Sstevel@tonic-gate Sflag = B_TRUE; 4907c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 4917c478bd9Sstevel@tonic-gate break; 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate case 'p': /* arp/ndp table */ 4947c478bd9Sstevel@tonic-gate Pflag = B_TRUE; 4957c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 4967c478bd9Sstevel@tonic-gate break; 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate case 'M': /* multicast routing tables */ 4997c478bd9Sstevel@tonic-gate MMflag = B_TRUE; 5007c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 5017c478bd9Sstevel@tonic-gate break; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate case 'g': /* multicast group membership */ 5047c478bd9Sstevel@tonic-gate Gflag = B_TRUE; 5057c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 5067c478bd9Sstevel@tonic-gate break; 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate case 'v': /* verbose output format */ 5097c478bd9Sstevel@tonic-gate Vflag = B_TRUE; 5107c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 5117c478bd9Sstevel@tonic-gate break; 5127c478bd9Sstevel@tonic-gate 51378a2e113SAndy Fiddaman case 'u': /* show pid and uid information */ 51478a2e113SAndy Fiddaman Uflag = B_TRUE; 51578a2e113SAndy Fiddaman break; 51678a2e113SAndy Fiddaman 517bd670b35SErik Nordmark case 'x': /* turn on debugging */ 518bd670b35SErik Nordmark Xflag = B_TRUE; 519bd670b35SErik Nordmark break; 520bd670b35SErik Nordmark 5217c478bd9Sstevel@tonic-gate case 'f': 5227c478bd9Sstevel@tonic-gate process_filter(optarg); 5237c478bd9Sstevel@tonic-gate break; 5247c478bd9Sstevel@tonic-gate 5257c478bd9Sstevel@tonic-gate case 'P': 5267c478bd9Sstevel@tonic-gate if (strcmp(optarg, "ip") == 0) { 5277c478bd9Sstevel@tonic-gate proto = IPPROTO_IP; 5287c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "ipv6") == 0 || 5297c478bd9Sstevel@tonic-gate strcmp(optarg, "ip6") == 0) { 5307c478bd9Sstevel@tonic-gate v4compat = 0; /* Overridden */ 5317c478bd9Sstevel@tonic-gate proto = IPPROTO_IPV6; 5327c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "icmp") == 0) { 5337c478bd9Sstevel@tonic-gate proto = IPPROTO_ICMP; 5347c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "icmpv6") == 0 || 5357c478bd9Sstevel@tonic-gate strcmp(optarg, "icmp6") == 0) { 5367c478bd9Sstevel@tonic-gate v4compat = 0; /* Overridden */ 5377c478bd9Sstevel@tonic-gate proto = IPPROTO_ICMPV6; 5387c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "igmp") == 0) { 5397c478bd9Sstevel@tonic-gate proto = IPPROTO_IGMP; 5407c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "udp") == 0) { 5417c478bd9Sstevel@tonic-gate proto = IPPROTO_UDP; 5427c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "tcp") == 0) { 5437c478bd9Sstevel@tonic-gate proto = IPPROTO_TCP; 5447c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "sctp") == 0) { 5457c478bd9Sstevel@tonic-gate proto = IPPROTO_SCTP; 5467c478bd9Sstevel@tonic-gate } else if (strcmp(optarg, "raw") == 0 || 5477c478bd9Sstevel@tonic-gate strcmp(optarg, "rawip") == 0) { 5487c478bd9Sstevel@tonic-gate proto = IPPROTO_RAW; 5497c478bd9Sstevel@tonic-gate } else { 5507c478bd9Sstevel@tonic-gate fatal(1, "%s: unknown protocol.\n", optarg); 5517c478bd9Sstevel@tonic-gate } 5527c478bd9Sstevel@tonic-gate break; 5537c478bd9Sstevel@tonic-gate 5547c478bd9Sstevel@tonic-gate case 'I': 5557c478bd9Sstevel@tonic-gate ifname = optarg; 5567c478bd9Sstevel@tonic-gate Iflag = B_TRUE; 5577c478bd9Sstevel@tonic-gate IFLAGMOD(Iflag_only, -1, 1); /* see macro def'n */ 5587c478bd9Sstevel@tonic-gate break; 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate case 'D': 5617c478bd9Sstevel@tonic-gate DHCPflag = B_TRUE; 5627c478bd9Sstevel@tonic-gate Iflag_only = 0; 5637c478bd9Sstevel@tonic-gate break; 5647c478bd9Sstevel@tonic-gate 56526fd7700SKrishnendu Sadhukhan - Sun Microsystems case 'T': 56626fd7700SKrishnendu Sadhukhan - Sun Microsystems if (optarg) { 56726fd7700SKrishnendu Sadhukhan - Sun Microsystems if (*optarg == 'u') 56826fd7700SKrishnendu Sadhukhan - Sun Microsystems timestamp_fmt = UDATE; 56926fd7700SKrishnendu Sadhukhan - Sun Microsystems else if (*optarg == 'd') 57026fd7700SKrishnendu Sadhukhan - Sun Microsystems timestamp_fmt = DDATE; 57126fd7700SKrishnendu Sadhukhan - Sun Microsystems else 57226fd7700SKrishnendu Sadhukhan - Sun Microsystems usage(name); 57326fd7700SKrishnendu Sadhukhan - Sun Microsystems } else { 57426fd7700SKrishnendu Sadhukhan - Sun Microsystems usage(name); 57526fd7700SKrishnendu Sadhukhan - Sun Microsystems } 57626fd7700SKrishnendu Sadhukhan - Sun Microsystems break; 57726fd7700SKrishnendu Sadhukhan - Sun Microsystems 5787c478bd9Sstevel@tonic-gate case '?': 5797c478bd9Sstevel@tonic-gate default: 5807c478bd9Sstevel@tonic-gate usage(name); 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate } 5837c478bd9Sstevel@tonic-gate 58445916cd2Sjpk /* 58545916cd2Sjpk * Make sure -R option is set only on a labeled system. 58645916cd2Sjpk */ 58745916cd2Sjpk if (RSECflag && !is_system_labeled()) { 58845916cd2Sjpk (void) fprintf(stderr, "-R set but labeling is not enabled\n"); 58945916cd2Sjpk usage(name); 59045916cd2Sjpk } 59145916cd2Sjpk 5927c478bd9Sstevel@tonic-gate /* 5937c478bd9Sstevel@tonic-gate * Handle other arguments: find interval, count; the 5947c478bd9Sstevel@tonic-gate * flags that accept 'interval' and 'count' are OR'd 5957c478bd9Sstevel@tonic-gate * in the outermost 'if'; more flags may be added as 5967c478bd9Sstevel@tonic-gate * required 5977c478bd9Sstevel@tonic-gate */ 5987c478bd9Sstevel@tonic-gate if (Iflag || Sflag || Mflag) { 5997c478bd9Sstevel@tonic-gate for (d = optind; d < argc; d++) { 6007c478bd9Sstevel@tonic-gate if (isnum(argv[d])) { 6017c478bd9Sstevel@tonic-gate interval = atoi(argv[d]); 6027c478bd9Sstevel@tonic-gate if (d + 1 < argc && 6037c478bd9Sstevel@tonic-gate isnum(argv[d + 1])) { 6047c478bd9Sstevel@tonic-gate count = atoi(argv[d + 1]); 6057c478bd9Sstevel@tonic-gate optind++; 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate optind++; 6087c478bd9Sstevel@tonic-gate if (interval == 0 || count == 0) 6097c478bd9Sstevel@tonic-gate usage(name); 6107c478bd9Sstevel@tonic-gate break; 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate } 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate if (optind < argc) { 6157c478bd9Sstevel@tonic-gate if (Iflag && isnum(argv[optind])) { 6167c478bd9Sstevel@tonic-gate count = atoi(argv[optind]); 6177c478bd9Sstevel@tonic-gate if (count == 0) 6187c478bd9Sstevel@tonic-gate usage(name); 6197c478bd9Sstevel@tonic-gate optind++; 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate } 6227c478bd9Sstevel@tonic-gate if (optind < argc) { 62378a2e113SAndy Fiddaman (void) fprintf(stderr, "%s: extra arguments\n", name); 6247c478bd9Sstevel@tonic-gate usage(name); 6257c478bd9Sstevel@tonic-gate } 6267c478bd9Sstevel@tonic-gate if (interval) 6277c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 6287c478bd9Sstevel@tonic-gate 629afee3dc6SRobert Mustacchi /* 630afee3dc6SRobert Mustacchi * Start up the thread to check for name services warnings. 631afee3dc6SRobert Mustacchi */ 632afee3dc6SRobert Mustacchi if (thr_create(NULL, 0, ns_warning_thr, NULL, 633afee3dc6SRobert Mustacchi THR_DETACHED | THR_DAEMON, NULL) != 0) { 634afee3dc6SRobert Mustacchi fatal(1, "%s: failed to create name services " 635afee3dc6SRobert Mustacchi "thread: %s\n", name, strerror(errno)); 636afee3dc6SRobert Mustacchi } 637afee3dc6SRobert Mustacchi 6387c478bd9Sstevel@tonic-gate if (DHCPflag) { 6397c478bd9Sstevel@tonic-gate dhcp_report(Iflag ? ifname : NULL); 6407c478bd9Sstevel@tonic-gate exit(0); 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate 64378a2e113SAndy Fiddaman if (Uflag) 64478a2e113SAndy Fiddaman process_hash_build(); 64578a2e113SAndy Fiddaman 6465f9878b0Sken Powell - Sun Microsystem /* 6475f9878b0Sken Powell - Sun Microsystem * Get this process's security label if the -R switch is set. 6485f9878b0Sken Powell - Sun Microsystem * We use this label as the current zone's security label. 6495f9878b0Sken Powell - Sun Microsystem */ 6505f9878b0Sken Powell - Sun Microsystem if (RSECflag) { 6515f9878b0Sken Powell - Sun Microsystem zone_security_label = m_label_alloc(MAC_LABEL); 6525f9878b0Sken Powell - Sun Microsystem if (zone_security_label == NULL) 6535f9878b0Sken Powell - Sun Microsystem fatal(errno, "m_label_alloc() failed"); 6545f9878b0Sken Powell - Sun Microsystem if (getplabel(zone_security_label) < 0) 6555f9878b0Sken Powell - Sun Microsystem fatal(errno, "getplabel() failed"); 6565f9878b0Sken Powell - Sun Microsystem } 6575f9878b0Sken Powell - Sun Microsystem 6587c478bd9Sstevel@tonic-gate /* Get data structures: priming before iteration */ 6597c478bd9Sstevel@tonic-gate if (family_selected(AF_INET) || family_selected(AF_INET6)) { 6607c478bd9Sstevel@tonic-gate sd = mibopen(); 6617c478bd9Sstevel@tonic-gate if (sd == -1) 6627c478bd9Sstevel@tonic-gate fatal(1, "can't open mib stream\n"); 6637c478bd9Sstevel@tonic-gate if ((item = mibget(sd)) == NULL) { 6647c478bd9Sstevel@tonic-gate (void) close(sd); 6657c478bd9Sstevel@tonic-gate fatal(1, "mibget() failed\n"); 6667c478bd9Sstevel@tonic-gate } 6677c478bd9Sstevel@tonic-gate /* Extract constant sizes - need do once only */ 6687c478bd9Sstevel@tonic-gate mib_get_constants(item); 6697c478bd9Sstevel@tonic-gate } 6707c478bd9Sstevel@tonic-gate if ((kc = kstat_open()) == NULL) { 6717c478bd9Sstevel@tonic-gate mibfree(item); 6727c478bd9Sstevel@tonic-gate (void) close(sd); 6737c478bd9Sstevel@tonic-gate fail(1, "kstat_open(): can't open /dev/kstat"); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate if (interval <= 0) { 6777c478bd9Sstevel@tonic-gate count = 1; 6787c478bd9Sstevel@tonic-gate once_only = B_TRUE; 6797c478bd9Sstevel@tonic-gate } 6807c478bd9Sstevel@tonic-gate for (;;) { 6817c478bd9Sstevel@tonic-gate mib_item_t *curritem = NULL; /* only for -[M]s */ 6827c478bd9Sstevel@tonic-gate 68326fd7700SKrishnendu Sadhukhan - Sun Microsystems if (timestamp_fmt != NODATE) 68426fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt); 68526fd7700SKrishnendu Sadhukhan - Sun Microsystems 6867c478bd9Sstevel@tonic-gate /* netstat: AF_INET[6] behaviour */ 6877c478bd9Sstevel@tonic-gate if (family_selected(AF_INET) || family_selected(AF_INET6)) { 6887c478bd9Sstevel@tonic-gate if (Sflag) { 6897c478bd9Sstevel@tonic-gate curritem = mib_item_diff(previtem, item); 6907c478bd9Sstevel@tonic-gate if (curritem == NULL) 6917c478bd9Sstevel@tonic-gate fatal(1, "can't process mib data, " 6927c478bd9Sstevel@tonic-gate "out of memory\n"); 6937c478bd9Sstevel@tonic-gate mib_item_destroy(&previtem); 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate 696bd670b35SErik Nordmark if (!(Dflag || Iflag || Rflag || Sflag || Mflag || 6977c478bd9Sstevel@tonic-gate MMflag || Pflag || Gflag || DHCPflag)) { 6987c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_UDP)) 6997c478bd9Sstevel@tonic-gate udp_report(item); 7007c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_TCP)) 7017c478bd9Sstevel@tonic-gate tcp_report(item); 7027c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_SCTP)) 7037c478bd9Sstevel@tonic-gate sctp_report(item); 7047c478bd9Sstevel@tonic-gate } 7057c478bd9Sstevel@tonic-gate if (Iflag) 7067c478bd9Sstevel@tonic-gate if_report(item, ifname, Iflag_only, once_only); 7077c478bd9Sstevel@tonic-gate if (Mflag) 7087c478bd9Sstevel@tonic-gate m_report(); 7097c478bd9Sstevel@tonic-gate if (Rflag) 7107c478bd9Sstevel@tonic-gate ire_report(item); 7117c478bd9Sstevel@tonic-gate if (Sflag && MMflag) { 7127c478bd9Sstevel@tonic-gate mrt_stat_report(curritem); 7137c478bd9Sstevel@tonic-gate } else { 7147c478bd9Sstevel@tonic-gate if (Sflag) 7157c478bd9Sstevel@tonic-gate stat_report(curritem); 7167c478bd9Sstevel@tonic-gate if (MMflag) 7177c478bd9Sstevel@tonic-gate mrt_report(item); 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate if (Gflag) 7207c478bd9Sstevel@tonic-gate group_report(item); 7217c478bd9Sstevel@tonic-gate if (Pflag) { 7227c478bd9Sstevel@tonic-gate if (family_selected(AF_INET)) 7237c478bd9Sstevel@tonic-gate arp_report(item); 7247c478bd9Sstevel@tonic-gate if (family_selected(AF_INET6)) 7257c478bd9Sstevel@tonic-gate ndp_report(item); 7267c478bd9Sstevel@tonic-gate } 727bd670b35SErik Nordmark if (Dflag) 728bd670b35SErik Nordmark dce_report(item); 7297c478bd9Sstevel@tonic-gate mib_item_destroy(&curritem); 7307c478bd9Sstevel@tonic-gate } 7317c478bd9Sstevel@tonic-gate 7327c478bd9Sstevel@tonic-gate /* netstat: AF_UNIX behaviour */ 7337c478bd9Sstevel@tonic-gate if (family_selected(AF_UNIX) && 734bd670b35SErik Nordmark (!(Dflag || Iflag || Rflag || Sflag || Mflag || 7357c478bd9Sstevel@tonic-gate MMflag || Pflag || Gflag))) 73678a2e113SAndy Fiddaman uds_report(kc); 7377c478bd9Sstevel@tonic-gate (void) kstat_close(kc); 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate /* iteration handling code */ 7407c478bd9Sstevel@tonic-gate if (count > 0 && --count == 0) 7417c478bd9Sstevel@tonic-gate break; 7427c478bd9Sstevel@tonic-gate (void) sleep(interval); 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate /* re-populating of data structures */ 7457c478bd9Sstevel@tonic-gate if (family_selected(AF_INET) || family_selected(AF_INET6)) { 7467c478bd9Sstevel@tonic-gate if (Sflag) { 7477c478bd9Sstevel@tonic-gate /* previtem is a cut-down list */ 7487c478bd9Sstevel@tonic-gate previtem = mib_item_dup(item); 7497c478bd9Sstevel@tonic-gate if (previtem == NULL) 7507c478bd9Sstevel@tonic-gate fatal(1, "can't process mib data, " 7517c478bd9Sstevel@tonic-gate "out of memory\n"); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate mibfree(item); 7547c478bd9Sstevel@tonic-gate (void) close(sd); 7557c478bd9Sstevel@tonic-gate if ((sd = mibopen()) == -1) 7567c478bd9Sstevel@tonic-gate fatal(1, "can't open mib stream anymore\n"); 7577c478bd9Sstevel@tonic-gate if ((item = mibget(sd)) == NULL) { 7587c478bd9Sstevel@tonic-gate (void) close(sd); 7597c478bd9Sstevel@tonic-gate fatal(1, "mibget() failed\n"); 7607c478bd9Sstevel@tonic-gate } 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate if ((kc = kstat_open()) == NULL) 7637c478bd9Sstevel@tonic-gate fail(1, "kstat_open(): can't open /dev/kstat"); 7647c478bd9Sstevel@tonic-gate 76578a2e113SAndy Fiddaman } 7667c478bd9Sstevel@tonic-gate mibfree(item); 7677c478bd9Sstevel@tonic-gate (void) close(sd); 7685f9878b0Sken Powell - Sun Microsystem if (zone_security_label != NULL) 7695f9878b0Sken Powell - Sun Microsystem m_label_free(zone_security_label); 7707c478bd9Sstevel@tonic-gate 77178a2e113SAndy Fiddaman if (Uflag) 77278a2e113SAndy Fiddaman process_hash_free(); 77378a2e113SAndy Fiddaman 7747c478bd9Sstevel@tonic-gate return (0); 7757c478bd9Sstevel@tonic-gate } 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate static int 7787c478bd9Sstevel@tonic-gate isnum(char *p) 7797c478bd9Sstevel@tonic-gate { 7807c478bd9Sstevel@tonic-gate int len; 7817c478bd9Sstevel@tonic-gate int i; 7827c478bd9Sstevel@tonic-gate 7837c478bd9Sstevel@tonic-gate len = strlen(p); 7847c478bd9Sstevel@tonic-gate for (i = 0; i < len; i++) 7857c478bd9Sstevel@tonic-gate if (!isdigit(p[i])) 7867c478bd9Sstevel@tonic-gate return (0); 7877c478bd9Sstevel@tonic-gate return (1); 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate 79078a2e113SAndy Fiddaman /* 79178a2e113SAndy Fiddaman * ------------------------------ Process Hash ----------------------------- 79278a2e113SAndy Fiddaman * 79378a2e113SAndy Fiddaman * When passed the -u option, netstat presents additional information against 79478a2e113SAndy Fiddaman * each socket showing the associated process ID(s), user(s) and command(s). 79578a2e113SAndy Fiddaman * 79678a2e113SAndy Fiddaman * The kernel provides some additional information for each socket, namely: 79778a2e113SAndy Fiddaman * - inode; 79878a2e113SAndy Fiddaman * - address family; 79978a2e113SAndy Fiddaman * - socket type; 80078a2e113SAndy Fiddaman * - major number; 80178a2e113SAndy Fiddaman * - flags. 80278a2e113SAndy Fiddaman * 80378a2e113SAndy Fiddaman * Netstat must correlate this information against processes running on the 80478a2e113SAndy Fiddaman * system and the files which they have open. 80578a2e113SAndy Fiddaman * 80678a2e113SAndy Fiddaman * It does this by traversing /proc and checking each process' open files, 80778a2e113SAndy Fiddaman * looking for BSD sockets or file descriptors relating to TLI/XTI sockets. 80878a2e113SAndy Fiddaman * When it finds one, it retrieves information and records it in the 80978a2e113SAndy Fiddaman * 'process_table' hash table with the entry hashed by its inode. 81078a2e113SAndy Fiddaman * 81178a2e113SAndy Fiddaman * For a BSD socket, libproc is used to grab the process and retrieve 81278a2e113SAndy Fiddaman * further information. This is not necessary for TLI/XTI sockets since the 81378a2e113SAndy Fiddaman * information can be derived directly via stat(). 81478a2e113SAndy Fiddaman * 81578a2e113SAndy Fiddaman * Note that each socket can be associated with more than one process. 81678a2e113SAndy Fiddaman */ 81778a2e113SAndy Fiddaman 81878a2e113SAndy Fiddaman /* 81978a2e113SAndy Fiddaman * The size of the hash table for recording sockets found under /proc. 82078a2e113SAndy Fiddaman * This should be a prime number. The value below was chosen after testing 82178a2e113SAndy Fiddaman * on a busy web server to reduce the number of hash table collisions to 82278a2e113SAndy Fiddaman * fewer than five per slot. 82378a2e113SAndy Fiddaman */ 82478a2e113SAndy Fiddaman #define PROC_HASH_SIZE 2003 82578a2e113SAndy Fiddaman /* Maximum length of a username - anything larger will be truncated */ 82678a2e113SAndy Fiddaman #define PROC_USERNAME_SIZE 128 82778a2e113SAndy Fiddaman /* Maximum length of the string representation of a process ID */ 82878a2e113SAndy Fiddaman #define PROC_PID_SIZE 15 82978a2e113SAndy Fiddaman 83078a2e113SAndy Fiddaman #define PROC_HASH(k) ((k) % PROC_HASH_SIZE) 83178a2e113SAndy Fiddaman 83278a2e113SAndy Fiddaman typedef struct proc_fdinfo { 83378a2e113SAndy Fiddaman uint64_t ph_inode; 83478a2e113SAndy Fiddaman uint64_t ph_fd; 83578a2e113SAndy Fiddaman mode_t ph_mode; 83678a2e113SAndy Fiddaman major_t ph_major; 83778a2e113SAndy Fiddaman int ph_family; 83878a2e113SAndy Fiddaman int ph_type; 83978a2e113SAndy Fiddaman 84078a2e113SAndy Fiddaman char ph_fname[PRFNSZ]; 84178a2e113SAndy Fiddaman char ph_psargs[PRARGSZ]; 84278a2e113SAndy Fiddaman char ph_username[PROC_USERNAME_SIZE]; 84378a2e113SAndy Fiddaman pid_t ph_pid; 84478a2e113SAndy Fiddaman char ph_pidstr[PROC_PID_SIZE]; 84578a2e113SAndy Fiddaman 84678a2e113SAndy Fiddaman struct proc_fdinfo *ph_next; /* Next (for collisions) */ 84778a2e113SAndy Fiddaman struct proc_fdinfo *ph_next_proc; /* Next process with this inode */ 84878a2e113SAndy Fiddaman } proc_fdinfo_t; 84978a2e113SAndy Fiddaman 85078a2e113SAndy Fiddaman static proc_fdinfo_t *process_table[PROC_HASH_SIZE]; 85178a2e113SAndy Fiddaman 85278a2e113SAndy Fiddaman static proc_fdinfo_t unknown_proc = { 85378a2e113SAndy Fiddaman .ph_pid = 0, 85478a2e113SAndy Fiddaman .ph_pidstr = "", 85578a2e113SAndy Fiddaman .ph_username = "", 85678a2e113SAndy Fiddaman .ph_fname = "", 85778a2e113SAndy Fiddaman .ph_psargs = "", 85878a2e113SAndy Fiddaman .ph_next_proc = NULL 85978a2e113SAndy Fiddaman }; 86078a2e113SAndy Fiddaman 86178a2e113SAndy Fiddaman /* 86278a2e113SAndy Fiddaman * Gets username given uid. It doesn't return NULL. 86378a2e113SAndy Fiddaman */ 86478a2e113SAndy Fiddaman static char * 86578a2e113SAndy Fiddaman get_username(uid_t u) 86678a2e113SAndy Fiddaman { 86778a2e113SAndy Fiddaman static uid_t saved_uid = UID_MAX; 86878a2e113SAndy Fiddaman static char saved_username[PROC_USERNAME_SIZE]; 86978a2e113SAndy Fiddaman struct passwd *pw = NULL; 87078a2e113SAndy Fiddaman 87178a2e113SAndy Fiddaman if (u == UID_MAX) 87278a2e113SAndy Fiddaman return ("<unknown>"); 87378a2e113SAndy Fiddaman 87478a2e113SAndy Fiddaman if (u == saved_uid && saved_username[0] != '\0') 87578a2e113SAndy Fiddaman return (saved_username); 87678a2e113SAndy Fiddaman 87778a2e113SAndy Fiddaman setpwent(); 87878a2e113SAndy Fiddaman 87978a2e113SAndy Fiddaman if ((pw = getpwuid(u)) != NULL) { 88078a2e113SAndy Fiddaman (void) strlcpy(saved_username, pw->pw_name, 88178a2e113SAndy Fiddaman sizeof (saved_username)); 88278a2e113SAndy Fiddaman } else { 88378a2e113SAndy Fiddaman (void) snprintf(saved_username, sizeof (saved_username), 88478a2e113SAndy Fiddaman "(%u)", u); 88578a2e113SAndy Fiddaman } 88678a2e113SAndy Fiddaman 88778a2e113SAndy Fiddaman saved_uid = u; 88878a2e113SAndy Fiddaman return (saved_username); 88978a2e113SAndy Fiddaman } 89078a2e113SAndy Fiddaman 89178a2e113SAndy Fiddaman static proc_fdinfo_t * 89278a2e113SAndy Fiddaman process_hash_find(const mib2_socketInfoEntry_t *sie, int type, int family) 89378a2e113SAndy Fiddaman { 89478a2e113SAndy Fiddaman proc_fdinfo_t *ph; 89578a2e113SAndy Fiddaman uint_t idx = PROC_HASH(sie->sie_inode); 89678a2e113SAndy Fiddaman 89778a2e113SAndy Fiddaman for (ph = process_table[idx]; ph != NULL; ph = ph->ph_next) { 89878a2e113SAndy Fiddaman if (ph->ph_inode != sie->sie_inode) 89978a2e113SAndy Fiddaman continue; 90078a2e113SAndy Fiddaman if ((sie->sie_flags & MIB2_SOCKINFO_STREAM)) { 90178a2e113SAndy Fiddaman /* TLI/XTI socket */ 90278a2e113SAndy Fiddaman if (S_ISCHR(ph->ph_mode) && 90378a2e113SAndy Fiddaman major(sie->sie_dev) == ph->ph_major) { 90478a2e113SAndy Fiddaman return (ph); 90578a2e113SAndy Fiddaman } 90678a2e113SAndy Fiddaman } else { 90778a2e113SAndy Fiddaman if (S_ISSOCK(ph->ph_mode) && ph->ph_type == type && 90878a2e113SAndy Fiddaman ph->ph_family == family) { 90978a2e113SAndy Fiddaman return (ph); 91078a2e113SAndy Fiddaman } 91178a2e113SAndy Fiddaman } 91278a2e113SAndy Fiddaman } 91378a2e113SAndy Fiddaman 91478a2e113SAndy Fiddaman return (NULL); 91578a2e113SAndy Fiddaman } 91678a2e113SAndy Fiddaman 91778a2e113SAndy Fiddaman static proc_fdinfo_t * 91878a2e113SAndy Fiddaman process_hash_get(const mib2_socketInfoEntry_t *sie, int type, int family) 91978a2e113SAndy Fiddaman { 92078a2e113SAndy Fiddaman proc_fdinfo_t *ph; 92178a2e113SAndy Fiddaman 92278a2e113SAndy Fiddaman if (sie != NULL && sie->sie_inode > 0 && 92378a2e113SAndy Fiddaman (ph = process_hash_find(sie, type, family)) != NULL) { 92478a2e113SAndy Fiddaman return (ph); 92578a2e113SAndy Fiddaman } 92678a2e113SAndy Fiddaman 92778a2e113SAndy Fiddaman return (&unknown_proc); 92878a2e113SAndy Fiddaman } 92978a2e113SAndy Fiddaman 93078a2e113SAndy Fiddaman static void 93178a2e113SAndy Fiddaman process_hash_insert(proc_fdinfo_t *ph) 93278a2e113SAndy Fiddaman { 93378a2e113SAndy Fiddaman uint_t idx = PROC_HASH(ph->ph_inode); 93478a2e113SAndy Fiddaman proc_fdinfo_t *slotp; 93578a2e113SAndy Fiddaman 93678a2e113SAndy Fiddaman mib2_socketInfoEntry_t sie = { 93778a2e113SAndy Fiddaman .sie_inode = ph->ph_inode, 93878a2e113SAndy Fiddaman .sie_dev = makedev(ph->ph_major, 0), 93978a2e113SAndy Fiddaman .sie_flags = S_ISCHR(ph->ph_mode) ? MIB2_SOCKINFO_STREAM : 0 94078a2e113SAndy Fiddaman }; 94178a2e113SAndy Fiddaman 94278a2e113SAndy Fiddaman slotp = process_hash_find(&sie, ph->ph_type, ph->ph_family); 94378a2e113SAndy Fiddaman 94478a2e113SAndy Fiddaman if (slotp == NULL) { 94578a2e113SAndy Fiddaman ph->ph_next = process_table[idx]; 94678a2e113SAndy Fiddaman process_table[idx] = ph; 94778a2e113SAndy Fiddaman } else { 94878a2e113SAndy Fiddaman ph->ph_next_proc = slotp->ph_next_proc; 94978a2e113SAndy Fiddaman slotp->ph_next_proc = ph; 95078a2e113SAndy Fiddaman } 95178a2e113SAndy Fiddaman } 95278a2e113SAndy Fiddaman 95378a2e113SAndy Fiddaman static void 95478a2e113SAndy Fiddaman process_hash_dump(void) 95578a2e113SAndy Fiddaman { 95678a2e113SAndy Fiddaman unsigned int i; 95778a2e113SAndy Fiddaman 95878a2e113SAndy Fiddaman (void) printf("--- Process hash table\n"); 95978a2e113SAndy Fiddaman for (i = 0; i < PROC_HASH_SIZE; i++) { 96078a2e113SAndy Fiddaman proc_fdinfo_t *ph; 96178a2e113SAndy Fiddaman 96278a2e113SAndy Fiddaman if (process_table[i] == NULL) 96378a2e113SAndy Fiddaman continue; 96478a2e113SAndy Fiddaman 96578a2e113SAndy Fiddaman (void) printf("Slot %d\n", i); 96678a2e113SAndy Fiddaman 96778a2e113SAndy Fiddaman for (ph = process_table[i]; ph != NULL; ph = ph->ph_next) { 96878a2e113SAndy Fiddaman proc_fdinfo_t *ph2; 96978a2e113SAndy Fiddaman 97078a2e113SAndy Fiddaman (void) printf(" -> Inode %" PRIu64 "\n", 97178a2e113SAndy Fiddaman ph->ph_inode); 97278a2e113SAndy Fiddaman 97378a2e113SAndy Fiddaman for (ph2 = ph; ph2 != NULL; ph2 = ph2->ph_next_proc) { 97478a2e113SAndy Fiddaman (void) printf(" -> " 97578a2e113SAndy Fiddaman "/proc/%ld/fd/%" PRIu64 " %s - " 97678a2e113SAndy Fiddaman "fname %s - " 97778a2e113SAndy Fiddaman "psargs %s - " 97878a2e113SAndy Fiddaman "major %" PRIx32 " - " 97978a2e113SAndy Fiddaman "type/fam %d/%d\n", 98078a2e113SAndy Fiddaman ph2->ph_pid, ph2->ph_fd, 98178a2e113SAndy Fiddaman S_ISCHR(ph2->ph_mode) ? "CHR" : "SOCK", 98278a2e113SAndy Fiddaman ph2->ph_fname, ph2->ph_psargs, 98378a2e113SAndy Fiddaman ph2->ph_major, 98478a2e113SAndy Fiddaman ph2->ph_type, ph2->ph_family); 98578a2e113SAndy Fiddaman } 98678a2e113SAndy Fiddaman } 98778a2e113SAndy Fiddaman } 98878a2e113SAndy Fiddaman } 98978a2e113SAndy Fiddaman 99078a2e113SAndy Fiddaman static int 991*a02120c4SAndy Fiddaman process_hash_iter(const psinfo_t *psinfo, const prfdinfo_core_t *pr, 99278a2e113SAndy Fiddaman struct ps_prochandle *Pr) 99378a2e113SAndy Fiddaman { 99478a2e113SAndy Fiddaman proc_fdinfo_t *ph; 99578a2e113SAndy Fiddaman 99678a2e113SAndy Fiddaman /* 99778a2e113SAndy Fiddaman * We are interested both in sockets and in descriptors linked to 99878a2e113SAndy Fiddaman * network STREAMS character devices. 99978a2e113SAndy Fiddaman */ 100078a2e113SAndy Fiddaman if (S_ISCHR(pr->pr_mode)) { 100178a2e113SAndy Fiddaman /* 100278a2e113SAndy Fiddaman * There's no elegant way to determine if a character device 100378a2e113SAndy Fiddaman * supports TLI, so just check a hardcoded list of known TLI 100478a2e113SAndy Fiddaman * devices. 100578a2e113SAndy Fiddaman */ 100678a2e113SAndy Fiddaman const char *tlidevs[] = { 100778a2e113SAndy Fiddaman "tcp", "tcp6", "udp", "udp6", NULL 100878a2e113SAndy Fiddaman }; 100978a2e113SAndy Fiddaman boolean_t istli = B_FALSE; 101078a2e113SAndy Fiddaman char *dev; 101178a2e113SAndy Fiddaman int i; 101278a2e113SAndy Fiddaman 101378a2e113SAndy Fiddaman /* global zone: /devices paths */ 101478a2e113SAndy Fiddaman dev = strrchr(pr->pr_path, ':'); 101578a2e113SAndy Fiddaman /* also check the /dev path for zones */ 101678a2e113SAndy Fiddaman if (dev == NULL) 101778a2e113SAndy Fiddaman dev = strrchr(pr->pr_path, '/'); 101878a2e113SAndy Fiddaman if (dev == NULL) 101978a2e113SAndy Fiddaman return (0); 102078a2e113SAndy Fiddaman dev++; /* skip past the `:' or '/' */ 102178a2e113SAndy Fiddaman 102278a2e113SAndy Fiddaman for (i = 0; tlidevs[i] != NULL; i++) { 102378a2e113SAndy Fiddaman if (strcmp(dev, tlidevs[i]) == 0) { 102478a2e113SAndy Fiddaman istli = B_TRUE; 102578a2e113SAndy Fiddaman break; 102678a2e113SAndy Fiddaman } 102778a2e113SAndy Fiddaman } 102878a2e113SAndy Fiddaman if (!istli) 102978a2e113SAndy Fiddaman return (0); 103078a2e113SAndy Fiddaman } else if (!S_ISSOCK(pr->pr_mode)) { 103178a2e113SAndy Fiddaman return (0); 103278a2e113SAndy Fiddaman } 103378a2e113SAndy Fiddaman 103478a2e113SAndy Fiddaman if ((ph = calloc(1, sizeof (proc_fdinfo_t))) == NULL) 103578a2e113SAndy Fiddaman fatal(1, "out of memory\n"); 103678a2e113SAndy Fiddaman 103778a2e113SAndy Fiddaman ph->ph_pid = psinfo->pr_pid; 103878a2e113SAndy Fiddaman if (ph->ph_pid > 0) 103978a2e113SAndy Fiddaman (void) snprintf(ph->ph_pidstr, PROC_PID_SIZE, "%" PRIu64, 104078a2e113SAndy Fiddaman ph->ph_pid); 104178a2e113SAndy Fiddaman ph->ph_inode = pr->pr_ino; 104278a2e113SAndy Fiddaman ph->ph_fd = pr->pr_fd; 104378a2e113SAndy Fiddaman ph->ph_major = pr->pr_rmajor; 104478a2e113SAndy Fiddaman ph->ph_mode = pr->pr_mode; 104578a2e113SAndy Fiddaman (void) strlcpy(ph->ph_fname, psinfo->pr_fname, sizeof (ph->ph_fname)); 104678a2e113SAndy Fiddaman (void) strlcpy(ph->ph_psargs, psinfo->pr_psargs, 104778a2e113SAndy Fiddaman sizeof (ph->ph_psargs)); 104878a2e113SAndy Fiddaman (void) strlcpy(ph->ph_username, get_username(psinfo->pr_uid), 104978a2e113SAndy Fiddaman sizeof (ph->ph_username)); 105078a2e113SAndy Fiddaman 105178a2e113SAndy Fiddaman if (S_ISSOCK(pr->pr_mode) && Pr != NULL) { 105278a2e113SAndy Fiddaman struct sockaddr sa; 105378a2e113SAndy Fiddaman socklen_t slen; 105478a2e113SAndy Fiddaman int type, tlen; 105578a2e113SAndy Fiddaman 105678a2e113SAndy Fiddaman /* Determine the socket type */ 105778a2e113SAndy Fiddaman tlen = sizeof (type); 105878a2e113SAndy Fiddaman if (pr_getsockopt(Pr, pr->pr_fd, SOL_SOCKET, SO_TYPE, &type, 105978a2e113SAndy Fiddaman &tlen) == 0) 106078a2e113SAndy Fiddaman ph->ph_type = type; 106178a2e113SAndy Fiddaman 106278a2e113SAndy Fiddaman /* Determine the protocol family */ 106378a2e113SAndy Fiddaman slen = sizeof (sa); 106478a2e113SAndy Fiddaman if (pr_getsockname(Pr, pr->pr_fd, &sa, &slen) == 0) 106578a2e113SAndy Fiddaman ph->ph_family = sa.sa_family; 106678a2e113SAndy Fiddaman } 106778a2e113SAndy Fiddaman 106878a2e113SAndy Fiddaman process_hash_insert(ph); 106978a2e113SAndy Fiddaman 107078a2e113SAndy Fiddaman return (0); 107178a2e113SAndy Fiddaman } 107278a2e113SAndy Fiddaman 107378a2e113SAndy Fiddaman static void 107478a2e113SAndy Fiddaman process_hash_iterate(psinfo_t *psinfo) 107578a2e113SAndy Fiddaman { 107678a2e113SAndy Fiddaman char dir_name[PATH_MAX]; 107778a2e113SAndy Fiddaman struct dirent *ent; 107878a2e113SAndy Fiddaman struct ps_prochandle *ph = NULL; 107978a2e113SAndy Fiddaman int err; 108078a2e113SAndy Fiddaman 108178a2e113SAndy Fiddaman DIR *dirp; 108278a2e113SAndy Fiddaman 108378a2e113SAndy Fiddaman if (snprintf(dir_name, sizeof (dir_name), "/proc/%d/path", 108478a2e113SAndy Fiddaman psinfo->pr_pid) >= sizeof (dir_name)) 108578a2e113SAndy Fiddaman return; 108678a2e113SAndy Fiddaman dirp = opendir(dir_name); 108778a2e113SAndy Fiddaman if (dirp == NULL) 108878a2e113SAndy Fiddaman return; 108978a2e113SAndy Fiddaman while ((ent = readdir(dirp)) != NULL) { 109078a2e113SAndy Fiddaman char path[PATH_MAX]; 109178a2e113SAndy Fiddaman struct stat st; 1092*a02120c4SAndy Fiddaman prfdinfo_core_t info; 109378a2e113SAndy Fiddaman int fd, len; 109478a2e113SAndy Fiddaman 109578a2e113SAndy Fiddaman if (!isdigit(ent->d_name[0])) 109678a2e113SAndy Fiddaman continue; 109778a2e113SAndy Fiddaman 109878a2e113SAndy Fiddaman fd = atoi(ent->d_name); 109978a2e113SAndy Fiddaman 110078a2e113SAndy Fiddaman if (snprintf(path, sizeof (path), "/proc/%d/fd/%d", 110178a2e113SAndy Fiddaman psinfo->pr_pid, fd) >= sizeof (path)) 110278a2e113SAndy Fiddaman continue; 110378a2e113SAndy Fiddaman if (stat(path, &st) != 0) 110478a2e113SAndy Fiddaman continue; 110578a2e113SAndy Fiddaman bzero(&info, sizeof (info)); 110678a2e113SAndy Fiddaman info.pr_fd = fd; 110778a2e113SAndy Fiddaman info.pr_mode = st.st_mode; 110878a2e113SAndy Fiddaman info.pr_uid = st.st_uid; 110978a2e113SAndy Fiddaman info.pr_gid = st.st_gid; 111078a2e113SAndy Fiddaman info.pr_major = major(st.st_dev); 111178a2e113SAndy Fiddaman info.pr_minor = minor(st.st_dev); 111278a2e113SAndy Fiddaman info.pr_rmajor = major(st.st_rdev); 111378a2e113SAndy Fiddaman info.pr_rminor = minor(st.st_rdev); 111478a2e113SAndy Fiddaman info.pr_size = st.st_size; 111578a2e113SAndy Fiddaman info.pr_ino = st.st_ino; 111678a2e113SAndy Fiddaman 111778a2e113SAndy Fiddaman len = -1; 111878a2e113SAndy Fiddaman switch (info.pr_mode & S_IFMT) { 111978a2e113SAndy Fiddaman case S_IFDOOR: 112078a2e113SAndy Fiddaman break; 112178a2e113SAndy Fiddaman case S_IFSOCK: 112278a2e113SAndy Fiddaman /* 112378a2e113SAndy Fiddaman * Grab the process so that we can interrogate it 112478a2e113SAndy Fiddaman * for further details on the socket. 112578a2e113SAndy Fiddaman */ 112678a2e113SAndy Fiddaman if (ph == NULL && 112778a2e113SAndy Fiddaman (ph = Pgrab(psinfo->pr_pid, 112878a2e113SAndy Fiddaman PGRAB_RETAIN | PGRAB_NOSTOP, &err)) == NULL) { 112978a2e113SAndy Fiddaman /* unreadable or SYS process */ 113078a2e113SAndy Fiddaman if (Xflag) { 113178a2e113SAndy Fiddaman printf("Could not grab %d - %s\n", 113278a2e113SAndy Fiddaman psinfo->pr_pid, Pgrab_error(err)); 113378a2e113SAndy Fiddaman } 113478a2e113SAndy Fiddaman } 113578a2e113SAndy Fiddaman break; 113678a2e113SAndy Fiddaman default: 113778a2e113SAndy Fiddaman /* attempt to determine the path */ 113878a2e113SAndy Fiddaman if (snprintf(path, sizeof (path), "%s/%d", 113978a2e113SAndy Fiddaman dir_name, fd) < sizeof (path)) { 114078a2e113SAndy Fiddaman len = readlink(path, info.pr_path, 114178a2e113SAndy Fiddaman sizeof (info.pr_path) - 1); 114278a2e113SAndy Fiddaman } 114378a2e113SAndy Fiddaman break; 114478a2e113SAndy Fiddaman } 114578a2e113SAndy Fiddaman 114678a2e113SAndy Fiddaman if (len <= 0) 114778a2e113SAndy Fiddaman len = 0; 114878a2e113SAndy Fiddaman info.pr_path[len] = '\0'; 114978a2e113SAndy Fiddaman 115078a2e113SAndy Fiddaman if (process_hash_iter(psinfo, &info, ph) != 0) 115178a2e113SAndy Fiddaman break; 115278a2e113SAndy Fiddaman } 115378a2e113SAndy Fiddaman (void) closedir(dirp); 115478a2e113SAndy Fiddaman 115578a2e113SAndy Fiddaman if (ph != NULL) 115678a2e113SAndy Fiddaman Prelease(ph, PRELEASE_RETAIN); 115778a2e113SAndy Fiddaman } 115878a2e113SAndy Fiddaman 115978a2e113SAndy Fiddaman static void 116078a2e113SAndy Fiddaman process_hash_build(void) 116178a2e113SAndy Fiddaman { 116278a2e113SAndy Fiddaman struct dirent *proce; 116378a2e113SAndy Fiddaman DIR *proc; 116478a2e113SAndy Fiddaman int err; 116578a2e113SAndy Fiddaman pid_t me = getpid(); 116678a2e113SAndy Fiddaman 116778a2e113SAndy Fiddaman if ((proc = opendir("/proc")) == NULL) 116878a2e113SAndy Fiddaman return; 116978a2e113SAndy Fiddaman 117078a2e113SAndy Fiddaman while ((proce = readdir(proc)) != NULL) { 117178a2e113SAndy Fiddaman psinfo_t psinfo; 117278a2e113SAndy Fiddaman pid_t pid; 117378a2e113SAndy Fiddaman 117478a2e113SAndy Fiddaman if (!isdigit(proce->d_name[0])) 117578a2e113SAndy Fiddaman continue; 117678a2e113SAndy Fiddaman 117778a2e113SAndy Fiddaman pid = proc_arg_psinfo(proce->d_name, PR_ARG_PIDS, &psinfo, 117878a2e113SAndy Fiddaman &err); 117978a2e113SAndy Fiddaman if (pid < 0 || pid == me) 118078a2e113SAndy Fiddaman continue; 118178a2e113SAndy Fiddaman 118278a2e113SAndy Fiddaman /* 118378a2e113SAndy Fiddaman * We do not use libproc's Pfdinfo_iter() here as it requires 118478a2e113SAndy Fiddaman * grabbing the process in read/write mode. Instead, the 118578a2e113SAndy Fiddaman * process is grabbed if (and only if) details about an open 118678a2e113SAndy Fiddaman * socket need to be retrieved. 118778a2e113SAndy Fiddaman */ 118878a2e113SAndy Fiddaman process_hash_iterate(&psinfo); 118978a2e113SAndy Fiddaman } 119078a2e113SAndy Fiddaman (void) closedir(proc); 119178a2e113SAndy Fiddaman 119278a2e113SAndy Fiddaman if (Xflag) 119378a2e113SAndy Fiddaman process_hash_dump(); 119478a2e113SAndy Fiddaman } 119578a2e113SAndy Fiddaman 119678a2e113SAndy Fiddaman static void 119778a2e113SAndy Fiddaman process_hash_free(void) 119878a2e113SAndy Fiddaman { 119978a2e113SAndy Fiddaman unsigned int i; 120078a2e113SAndy Fiddaman 120178a2e113SAndy Fiddaman for (i = 0; i < PROC_HASH_SIZE; i++) { 120278a2e113SAndy Fiddaman proc_fdinfo_t *ph, *ph_next; 120378a2e113SAndy Fiddaman 120478a2e113SAndy Fiddaman for (ph = process_table[i]; ph != NULL; ph = ph_next) { 120578a2e113SAndy Fiddaman ph_next = ph->ph_next; 120678a2e113SAndy Fiddaman free(ph); 120778a2e113SAndy Fiddaman } 120878a2e113SAndy Fiddaman process_table[i] = NULL; 120978a2e113SAndy Fiddaman } 121078a2e113SAndy Fiddaman } 12117c478bd9Sstevel@tonic-gate 12127c478bd9Sstevel@tonic-gate /* --------------------------------- MIBGET -------------------------------- */ 12137c478bd9Sstevel@tonic-gate 12147c478bd9Sstevel@tonic-gate static mib_item_t * 12157c478bd9Sstevel@tonic-gate mibget(int sd) 12167c478bd9Sstevel@tonic-gate { 12177c478bd9Sstevel@tonic-gate /* 12187c478bd9Sstevel@tonic-gate * buf is an automatic for this function, so the 12197c478bd9Sstevel@tonic-gate * compiler has complete control over its alignment; 12207c478bd9Sstevel@tonic-gate * it is assumed this alignment is satisfactory for 12217c478bd9Sstevel@tonic-gate * it to be casted to certain other struct pointers 12227c478bd9Sstevel@tonic-gate * here, such as struct T_optmgmt_ack * . 12237c478bd9Sstevel@tonic-gate */ 12247c478bd9Sstevel@tonic-gate uintptr_t buf[512 / sizeof (uintptr_t)]; 12257c478bd9Sstevel@tonic-gate int flags; 12267c478bd9Sstevel@tonic-gate int i, j, getcode; 12277c478bd9Sstevel@tonic-gate struct strbuf ctlbuf, databuf; 12287c478bd9Sstevel@tonic-gate struct T_optmgmt_req *tor = (struct T_optmgmt_req *)buf; 12297c478bd9Sstevel@tonic-gate struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *)buf; 12307c478bd9Sstevel@tonic-gate struct T_error_ack *tea = (struct T_error_ack *)buf; 12317c478bd9Sstevel@tonic-gate struct opthdr *req; 12327c478bd9Sstevel@tonic-gate mib_item_t *first_item = NULL; 12337c478bd9Sstevel@tonic-gate mib_item_t *last_item = NULL; 12347c478bd9Sstevel@tonic-gate mib_item_t *temp; 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate tor->PRIM_type = T_SVR4_OPTMGMT_REQ; 12377c478bd9Sstevel@tonic-gate tor->OPT_offset = sizeof (struct T_optmgmt_req); 12387c478bd9Sstevel@tonic-gate tor->OPT_length = sizeof (struct opthdr); 12397c478bd9Sstevel@tonic-gate tor->MGMT_flags = T_CURRENT; 1240e11c3f44Smeem 1241e11c3f44Smeem /* 1242e11c3f44Smeem * Note: we use the special level value below so that IP will return 1243e11c3f44Smeem * us information concerning IRE_MARK_TESTHIDDEN routes. 1244e11c3f44Smeem */ 12457c478bd9Sstevel@tonic-gate req = (struct opthdr *)&tor[1]; 1246bd670b35SErik Nordmark req->level = EXPER_IP_AND_ALL_IRES; 12477c478bd9Sstevel@tonic-gate req->name = 0; 12486f773e29SBaban Kenkre req->len = 1; 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate ctlbuf.buf = (char *)buf; 12517c478bd9Sstevel@tonic-gate ctlbuf.len = tor->OPT_length + tor->OPT_offset; 12527c478bd9Sstevel@tonic-gate flags = 0; 12537c478bd9Sstevel@tonic-gate if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) { 12547c478bd9Sstevel@tonic-gate perror("mibget: putmsg(ctl) failed"); 12557c478bd9Sstevel@tonic-gate goto error_exit; 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate /* 12597c478bd9Sstevel@tonic-gate * Each reply consists of a ctl part for one fixed structure 12607c478bd9Sstevel@tonic-gate * or table, as defined in mib2.h. The format is a T_OPTMGMT_ACK, 12617c478bd9Sstevel@tonic-gate * containing an opthdr structure. level/name identify the entry, 12627c478bd9Sstevel@tonic-gate * len is the size of the data part of the message. 12637c478bd9Sstevel@tonic-gate */ 12647c478bd9Sstevel@tonic-gate req = (struct opthdr *)&toa[1]; 12657c478bd9Sstevel@tonic-gate ctlbuf.maxlen = sizeof (buf); 12667c478bd9Sstevel@tonic-gate j = 1; 12677c478bd9Sstevel@tonic-gate for (;;) { 12687c478bd9Sstevel@tonic-gate flags = 0; 12697c478bd9Sstevel@tonic-gate getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags); 12707c478bd9Sstevel@tonic-gate if (getcode == -1) { 12717c478bd9Sstevel@tonic-gate perror("mibget getmsg(ctl) failed"); 1272bd670b35SErik Nordmark if (Xflag) { 12737c478bd9Sstevel@tonic-gate (void) fputs("# level name len\n", 12747c478bd9Sstevel@tonic-gate stderr); 12757c478bd9Sstevel@tonic-gate i = 0; 12767c478bd9Sstevel@tonic-gate for (last_item = first_item; last_item; 1277e11c3f44Smeem last_item = last_item->next_item) 12787c478bd9Sstevel@tonic-gate (void) printf("%d %4d %5d %d\n", 12797c478bd9Sstevel@tonic-gate ++i, 12807c478bd9Sstevel@tonic-gate last_item->group, 12817c478bd9Sstevel@tonic-gate last_item->mib_id, 12827c478bd9Sstevel@tonic-gate last_item->length); 12837c478bd9Sstevel@tonic-gate } 12847c478bd9Sstevel@tonic-gate goto error_exit; 12857c478bd9Sstevel@tonic-gate } 12867c478bd9Sstevel@tonic-gate if (getcode == 0 && 12877c478bd9Sstevel@tonic-gate ctlbuf.len >= sizeof (struct T_optmgmt_ack) && 12887c478bd9Sstevel@tonic-gate toa->PRIM_type == T_OPTMGMT_ACK && 12897c478bd9Sstevel@tonic-gate toa->MGMT_flags == T_SUCCESS && 12907c478bd9Sstevel@tonic-gate req->len == 0) { 1291bd670b35SErik Nordmark if (Xflag) 12927c478bd9Sstevel@tonic-gate (void) printf("mibget getmsg() %d returned " 12937c478bd9Sstevel@tonic-gate "EOD (level %ld, name %ld)\n", 12947c478bd9Sstevel@tonic-gate j, req->level, req->name); 12957c478bd9Sstevel@tonic-gate return (first_item); /* this is EOD msg */ 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate if (ctlbuf.len >= sizeof (struct T_error_ack) && 12997c478bd9Sstevel@tonic-gate tea->PRIM_type == T_ERROR_ACK) { 13007c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13017c478bd9Sstevel@tonic-gate "mibget %d gives T_ERROR_ACK: TLI_error = 0x%lx, " 13027c478bd9Sstevel@tonic-gate "UNIX_error = 0x%lx\n", 13037c478bd9Sstevel@tonic-gate j, tea->TLI_error, tea->UNIX_error); 13047c478bd9Sstevel@tonic-gate 13057c478bd9Sstevel@tonic-gate errno = (tea->TLI_error == TSYSERR) ? 13067c478bd9Sstevel@tonic-gate tea->UNIX_error : EPROTO; 13077c478bd9Sstevel@tonic-gate goto error_exit; 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate if (getcode != MOREDATA || 13117c478bd9Sstevel@tonic-gate ctlbuf.len < sizeof (struct T_optmgmt_ack) || 13127c478bd9Sstevel@tonic-gate toa->PRIM_type != T_OPTMGMT_ACK || 13137c478bd9Sstevel@tonic-gate toa->MGMT_flags != T_SUCCESS) { 13147c478bd9Sstevel@tonic-gate (void) printf("mibget getmsg(ctl) %d returned %d, " 13157c478bd9Sstevel@tonic-gate "ctlbuf.len = %d, PRIM_type = %ld\n", 13167c478bd9Sstevel@tonic-gate j, getcode, ctlbuf.len, toa->PRIM_type); 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate if (toa->PRIM_type == T_OPTMGMT_ACK) 13197c478bd9Sstevel@tonic-gate (void) printf("T_OPTMGMT_ACK: " 13207c478bd9Sstevel@tonic-gate "MGMT_flags = 0x%lx, req->len = %ld\n", 13217c478bd9Sstevel@tonic-gate toa->MGMT_flags, req->len); 13227c478bd9Sstevel@tonic-gate errno = ENOMSG; 13237c478bd9Sstevel@tonic-gate goto error_exit; 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate temp = (mib_item_t *)malloc(sizeof (mib_item_t)); 13277c478bd9Sstevel@tonic-gate if (temp == NULL) { 13287c478bd9Sstevel@tonic-gate perror("mibget malloc failed"); 13297c478bd9Sstevel@tonic-gate goto error_exit; 13307c478bd9Sstevel@tonic-gate } 13317c478bd9Sstevel@tonic-gate if (last_item != NULL) 13327c478bd9Sstevel@tonic-gate last_item->next_item = temp; 13337c478bd9Sstevel@tonic-gate else 13347c478bd9Sstevel@tonic-gate first_item = temp; 13357c478bd9Sstevel@tonic-gate last_item = temp; 13367c478bd9Sstevel@tonic-gate last_item->next_item = NULL; 13377c478bd9Sstevel@tonic-gate last_item->group = req->level; 13387c478bd9Sstevel@tonic-gate last_item->mib_id = req->name; 13397c478bd9Sstevel@tonic-gate last_item->length = req->len; 13407c478bd9Sstevel@tonic-gate last_item->valp = malloc((int)req->len); 13417c478bd9Sstevel@tonic-gate if (last_item->valp == NULL) 13427c478bd9Sstevel@tonic-gate goto error_exit; 1343bd670b35SErik Nordmark if (Xflag) 134478a2e113SAndy Fiddaman (void) printf("msg %4d: group = %-4d mib_id = %-5d " 13457c478bd9Sstevel@tonic-gate "length = %d\n", 13467c478bd9Sstevel@tonic-gate j, last_item->group, last_item->mib_id, 13477c478bd9Sstevel@tonic-gate last_item->length); 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate databuf.maxlen = last_item->length; 13507c478bd9Sstevel@tonic-gate databuf.buf = (char *)last_item->valp; 13517c478bd9Sstevel@tonic-gate databuf.len = 0; 13527c478bd9Sstevel@tonic-gate flags = 0; 13537c478bd9Sstevel@tonic-gate getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags); 13547c478bd9Sstevel@tonic-gate if (getcode == -1) { 13557c478bd9Sstevel@tonic-gate perror("mibget getmsg(data) failed"); 13567c478bd9Sstevel@tonic-gate goto error_exit; 13577c478bd9Sstevel@tonic-gate } else if (getcode != 0) { 13587c478bd9Sstevel@tonic-gate (void) printf("mibget getmsg(data) returned %d, " 13597c478bd9Sstevel@tonic-gate "databuf.maxlen = %d, databuf.len = %d\n", 13607c478bd9Sstevel@tonic-gate getcode, databuf.maxlen, databuf.len); 13617c478bd9Sstevel@tonic-gate goto error_exit; 13627c478bd9Sstevel@tonic-gate } 13637c478bd9Sstevel@tonic-gate j++; 13647c478bd9Sstevel@tonic-gate } 13657c478bd9Sstevel@tonic-gate /* NOTREACHED */ 13667c478bd9Sstevel@tonic-gate 13677c478bd9Sstevel@tonic-gate error_exit:; 13687c478bd9Sstevel@tonic-gate mibfree(first_item); 13697c478bd9Sstevel@tonic-gate return (NULL); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate /* 13737c478bd9Sstevel@tonic-gate * mibfree: frees a linked list of type (mib_item_t *) 13747c478bd9Sstevel@tonic-gate * returned by mibget(); this is NOT THE SAME AS 13757c478bd9Sstevel@tonic-gate * mib_item_destroy(), so should be used for objects 13767c478bd9Sstevel@tonic-gate * returned by mibget() only 13777c478bd9Sstevel@tonic-gate */ 13787c478bd9Sstevel@tonic-gate static void 13797c478bd9Sstevel@tonic-gate mibfree(mib_item_t *firstitem) 13807c478bd9Sstevel@tonic-gate { 13817c478bd9Sstevel@tonic-gate mib_item_t *lastitem; 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate while (firstitem != NULL) { 13847c478bd9Sstevel@tonic-gate lastitem = firstitem; 13857c478bd9Sstevel@tonic-gate firstitem = firstitem->next_item; 13867c478bd9Sstevel@tonic-gate if (lastitem->valp != NULL) 13877c478bd9Sstevel@tonic-gate free(lastitem->valp); 13887c478bd9Sstevel@tonic-gate free(lastitem); 13897c478bd9Sstevel@tonic-gate } 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate static int 13937c478bd9Sstevel@tonic-gate mibopen(void) 13947c478bd9Sstevel@tonic-gate { 13957c478bd9Sstevel@tonic-gate int sd; 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate sd = open("/dev/arp", O_RDWR); 13987c478bd9Sstevel@tonic-gate if (sd == -1) { 13997c478bd9Sstevel@tonic-gate perror("arp open"); 14007c478bd9Sstevel@tonic-gate return (-1); 14017c478bd9Sstevel@tonic-gate } 14027c478bd9Sstevel@tonic-gate if (ioctl(sd, I_PUSH, "tcp") == -1) { 14037c478bd9Sstevel@tonic-gate perror("tcp I_PUSH"); 14047c478bd9Sstevel@tonic-gate (void) close(sd); 14057c478bd9Sstevel@tonic-gate return (-1); 14067c478bd9Sstevel@tonic-gate } 14077c478bd9Sstevel@tonic-gate if (ioctl(sd, I_PUSH, "udp") == -1) { 14087c478bd9Sstevel@tonic-gate perror("udp I_PUSH"); 14097c478bd9Sstevel@tonic-gate (void) close(sd); 14107c478bd9Sstevel@tonic-gate return (-1); 14117c478bd9Sstevel@tonic-gate } 14127c478bd9Sstevel@tonic-gate if (ioctl(sd, I_PUSH, "icmp") == -1) { 14137c478bd9Sstevel@tonic-gate perror("icmp I_PUSH"); 14147c478bd9Sstevel@tonic-gate (void) close(sd); 14157c478bd9Sstevel@tonic-gate return (-1); 14167c478bd9Sstevel@tonic-gate } 14177c478bd9Sstevel@tonic-gate return (sd); 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate 14207c478bd9Sstevel@tonic-gate /* 14217c478bd9Sstevel@tonic-gate * mib_item_dup: returns a clean mib_item_t * linked 14227c478bd9Sstevel@tonic-gate * list, so that for every element item->mib_id is 0; 14237c478bd9Sstevel@tonic-gate * to deallocate this linked list, use mib_item_destroy 14247c478bd9Sstevel@tonic-gate */ 14257c478bd9Sstevel@tonic-gate static mib_item_t * 14267c478bd9Sstevel@tonic-gate mib_item_dup(mib_item_t *item) 14277c478bd9Sstevel@tonic-gate { 14287c478bd9Sstevel@tonic-gate int c = 0; 14297c478bd9Sstevel@tonic-gate mib_item_t *localp; 14307c478bd9Sstevel@tonic-gate mib_item_t *tempp; 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate for (tempp = item; tempp; tempp = tempp->next_item) 14337c478bd9Sstevel@tonic-gate if (tempp->mib_id == 0) 14347c478bd9Sstevel@tonic-gate c++; 14357c478bd9Sstevel@tonic-gate tempp = NULL; 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate localp = (mib_item_t *)malloc(c * sizeof (mib_item_t)); 14387c478bd9Sstevel@tonic-gate if (localp == NULL) 14397c478bd9Sstevel@tonic-gate return (NULL); 14407c478bd9Sstevel@tonic-gate c = 0; 14417c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 14427c478bd9Sstevel@tonic-gate if (item->mib_id == 0) { 14437c478bd9Sstevel@tonic-gate /* Replicate item in localp */ 14447c478bd9Sstevel@tonic-gate (localp[c]).next_item = NULL; 14457c478bd9Sstevel@tonic-gate (localp[c]).group = item->group; 14467c478bd9Sstevel@tonic-gate (localp[c]).mib_id = item->mib_id; 14477c478bd9Sstevel@tonic-gate (localp[c]).length = item->length; 14487c478bd9Sstevel@tonic-gate (localp[c]).valp = (uintptr_t *)malloc( 14497c478bd9Sstevel@tonic-gate item->length); 14507c478bd9Sstevel@tonic-gate if ((localp[c]).valp == NULL) { 14517c478bd9Sstevel@tonic-gate mib_item_destroy(&localp); 14527c478bd9Sstevel@tonic-gate return (NULL); 14537c478bd9Sstevel@tonic-gate } 14547c478bd9Sstevel@tonic-gate (void *) memcpy((localp[c]).valp, 14557c478bd9Sstevel@tonic-gate item->valp, 14567c478bd9Sstevel@tonic-gate item->length); 14577c478bd9Sstevel@tonic-gate tempp = &(localp[c]); 14587c478bd9Sstevel@tonic-gate if (c > 0) 14597c478bd9Sstevel@tonic-gate (localp[c - 1]).next_item = tempp; 14607c478bd9Sstevel@tonic-gate c++; 14617c478bd9Sstevel@tonic-gate } 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate return (localp); 14647c478bd9Sstevel@tonic-gate } 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate /* 14677c478bd9Sstevel@tonic-gate * mib_item_diff: takes two (mib_item_t *) linked lists 14687c478bd9Sstevel@tonic-gate * item1 and item2 and computes the difference between 14697c478bd9Sstevel@tonic-gate * differentiable values in item2 against item1 for every 14707c478bd9Sstevel@tonic-gate * given member of item2; returns an mib_item_t * linked 14717c478bd9Sstevel@tonic-gate * list of diff's, or a copy of item2 if item1 is NULL; 14727c478bd9Sstevel@tonic-gate * will return NULL if system out of memory; works only 14737c478bd9Sstevel@tonic-gate * for item->mib_id == 0 14747c478bd9Sstevel@tonic-gate */ 14757c478bd9Sstevel@tonic-gate static mib_item_t * 1476afee3dc6SRobert Mustacchi mib_item_diff(mib_item_t *item1, mib_item_t *item2) 1477afee3dc6SRobert Mustacchi { 14787c478bd9Sstevel@tonic-gate int nitems = 0; /* no. of items in item2 */ 14797c478bd9Sstevel@tonic-gate mib_item_t *tempp2; /* walking copy of item2 */ 14807c478bd9Sstevel@tonic-gate mib_item_t *tempp1; /* walking copy of item1 */ 14817c478bd9Sstevel@tonic-gate mib_item_t *diffp; 14827c478bd9Sstevel@tonic-gate mib_item_t *diffptr; /* walking copy of diffp */ 14837c478bd9Sstevel@tonic-gate mib_item_t *prevp = NULL; 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate if (item1 == NULL) { 14867c478bd9Sstevel@tonic-gate diffp = mib_item_dup(item2); 14877c478bd9Sstevel@tonic-gate return (diffp); 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate for (tempp2 = item2; 14917c478bd9Sstevel@tonic-gate tempp2; 14927c478bd9Sstevel@tonic-gate tempp2 = tempp2->next_item) { 14937c478bd9Sstevel@tonic-gate if (tempp2->mib_id == 0) 14947c478bd9Sstevel@tonic-gate switch (tempp2->group) { 14957c478bd9Sstevel@tonic-gate /* 14967c478bd9Sstevel@tonic-gate * upon adding a case here, the same 14977c478bd9Sstevel@tonic-gate * must also be added in the next 14987c478bd9Sstevel@tonic-gate * switch statement, alongwith 14997c478bd9Sstevel@tonic-gate * appropriate code 15007c478bd9Sstevel@tonic-gate */ 15017c478bd9Sstevel@tonic-gate case MIB2_IP: 15027c478bd9Sstevel@tonic-gate case MIB2_IP6: 15037c478bd9Sstevel@tonic-gate case EXPER_DVMRP: 15047c478bd9Sstevel@tonic-gate case EXPER_IGMP: 15057c478bd9Sstevel@tonic-gate case MIB2_ICMP: 15067c478bd9Sstevel@tonic-gate case MIB2_ICMP6: 15077c478bd9Sstevel@tonic-gate case MIB2_TCP: 15087c478bd9Sstevel@tonic-gate case MIB2_UDP: 15097c478bd9Sstevel@tonic-gate case MIB2_SCTP: 15107c478bd9Sstevel@tonic-gate case EXPER_RAWIP: 15117c478bd9Sstevel@tonic-gate nitems++; 15127c478bd9Sstevel@tonic-gate } 15137c478bd9Sstevel@tonic-gate } 15147c478bd9Sstevel@tonic-gate tempp2 = NULL; 15157c478bd9Sstevel@tonic-gate if (nitems == 0) { 15167c478bd9Sstevel@tonic-gate diffp = mib_item_dup(item2); 15177c478bd9Sstevel@tonic-gate return (diffp); 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate 152078a2e113SAndy Fiddaman diffp = calloc(nitems, sizeof (mib_item_t)); 15217c478bd9Sstevel@tonic-gate if (diffp == NULL) 15227c478bd9Sstevel@tonic-gate return (NULL); 15237c478bd9Sstevel@tonic-gate diffptr = diffp; 15247c478bd9Sstevel@tonic-gate for (tempp2 = item2; tempp2 != NULL; tempp2 = tempp2->next_item) { 15257c478bd9Sstevel@tonic-gate if (tempp2->mib_id != 0) 152678a2e113SAndy Fiddaman continue; 15277c478bd9Sstevel@tonic-gate for (tempp1 = item1; tempp1 != NULL; 15287c478bd9Sstevel@tonic-gate tempp1 = tempp1->next_item) { 15297c478bd9Sstevel@tonic-gate if (!(tempp1->mib_id == 0 && 15307c478bd9Sstevel@tonic-gate tempp1->group == tempp2->group && 15317c478bd9Sstevel@tonic-gate tempp1->mib_id == tempp2->mib_id)) 153278a2e113SAndy Fiddaman continue; 15337c478bd9Sstevel@tonic-gate /* found comparable data sets */ 15347c478bd9Sstevel@tonic-gate if (prevp != NULL) 15357c478bd9Sstevel@tonic-gate prevp->next_item = diffptr; 15367c478bd9Sstevel@tonic-gate switch (tempp2->group) { 15377c478bd9Sstevel@tonic-gate /* 15387c478bd9Sstevel@tonic-gate * Indenting note: Because of long variable names 15397c478bd9Sstevel@tonic-gate * in cases MIB2_IP6 and MIB2_ICMP6, their contents 15407c478bd9Sstevel@tonic-gate * have been indented by one tab space only 15417c478bd9Sstevel@tonic-gate */ 15427c478bd9Sstevel@tonic-gate case MIB2_IP: { 15437c478bd9Sstevel@tonic-gate mib2_ip_t *i2 = (mib2_ip_t *)tempp2->valp; 15447c478bd9Sstevel@tonic-gate mib2_ip_t *i1 = (mib2_ip_t *)tempp1->valp; 15457c478bd9Sstevel@tonic-gate mib2_ip_t *d; 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 15487c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 15497c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 155078a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 15517c478bd9Sstevel@tonic-gate if (d == NULL) 15527c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 15537c478bd9Sstevel@tonic-gate diffptr->valp = d; 15547c478bd9Sstevel@tonic-gate d->ipForwarding = i2->ipForwarding; 15557c478bd9Sstevel@tonic-gate d->ipDefaultTTL = i2->ipDefaultTTL; 15567c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInReceives); 15577c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInHdrErrors); 15587c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInAddrErrors); 15597c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInCksumErrs); 15607c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipForwDatagrams); 15617c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipForwProhibits); 15627c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInUnknownProtos); 15637c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInDiscards); 15647c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInDelivers); 15657c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipOutRequests); 15667c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipOutDiscards); 15677c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipOutNoRoutes); 15687c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmTimeout); 15697c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmReqds); 15707c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmOKs); 15717c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmFails); 15727c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmDuplicates); 15737c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipReasmPartDups); 15747c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipFragOKs); 15757c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipFragFails); 15767c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipFragCreates); 15777c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipRoutingDiscards); 15787c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, tcpInErrs); 15797c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, udpNoPorts); 15807c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, udpInCksumErrs); 15817c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, udpInOverflows); 15827c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, rawipInOverflows); 15837c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipsecInSucceeded); 15847c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipsecInFailed); 15857c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipInIPv6); 15867c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipOutIPv6); 15877c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipOutSwitchIPv6); 15887c478bd9Sstevel@tonic-gate prevp = diffptr++; 15897c478bd9Sstevel@tonic-gate break; 15907c478bd9Sstevel@tonic-gate } 15917c478bd9Sstevel@tonic-gate case MIB2_IP6: { 15927c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *i2; 15937c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *i1; 15947c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *d; 15957c478bd9Sstevel@tonic-gate 15967c478bd9Sstevel@tonic-gate i2 = (mib2_ipv6IfStatsEntry_t *)tempp2->valp; 15977c478bd9Sstevel@tonic-gate i1 = (mib2_ipv6IfStatsEntry_t *)tempp1->valp; 15987c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 15997c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 16007c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 160178a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 16027c478bd9Sstevel@tonic-gate if (d == NULL) 16037c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 16047c478bd9Sstevel@tonic-gate diffptr->valp = d; 16057c478bd9Sstevel@tonic-gate d->ipv6Forwarding = i2->ipv6Forwarding; 16067c478bd9Sstevel@tonic-gate d->ipv6DefaultHopLimit = 16077c478bd9Sstevel@tonic-gate i2->ipv6DefaultHopLimit; 16087c478bd9Sstevel@tonic-gate 16097c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InReceives); 16107c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InHdrErrors); 16117c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InTooBigErrors); 16127c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InNoRoutes); 16137c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InAddrErrors); 16147c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InUnknownProtos); 16157c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InTruncatedPkts); 16167c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InDiscards); 16177c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InDelivers); 16187c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutForwDatagrams); 16197c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutRequests); 16207c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutDiscards); 16217c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutNoRoutes); 16227c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutFragOKs); 16237c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutFragFails); 16247c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutFragCreates); 16257c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ReasmReqds); 16267c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ReasmOKs); 16277c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ReasmFails); 16287c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InMcastPkts); 16297c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutMcastPkts); 16307c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ReasmDuplicates); 16317c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ReasmPartDups); 16327c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6ForwProhibits); 16337c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, udpInCksumErrs); 16347c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, udpInOverflows); 16357c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, rawipInOverflows); 16367c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6InIPv4); 16377c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutIPv4); 16387c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6OutSwitchIPv4); 16397c478bd9Sstevel@tonic-gate prevp = diffptr++; 16407c478bd9Sstevel@tonic-gate break; 16417c478bd9Sstevel@tonic-gate } 16427c478bd9Sstevel@tonic-gate case EXPER_DVMRP: { 16437c478bd9Sstevel@tonic-gate struct mrtstat *m2; 16447c478bd9Sstevel@tonic-gate struct mrtstat *m1; 16457c478bd9Sstevel@tonic-gate struct mrtstat *d; 16467c478bd9Sstevel@tonic-gate 16477c478bd9Sstevel@tonic-gate m2 = (struct mrtstat *)tempp2->valp; 16487c478bd9Sstevel@tonic-gate m1 = (struct mrtstat *)tempp1->valp; 16497c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 16507c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 16517c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 165278a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 16537c478bd9Sstevel@tonic-gate if (d == NULL) 16547c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 16557c478bd9Sstevel@tonic-gate diffptr->valp = d; 16567c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_mfc_hits); 16577c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_mfc_misses); 16587c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_fwd_in); 16597c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_fwd_out); 16607c478bd9Sstevel@tonic-gate d->mrts_upcalls = m2->mrts_upcalls; 16617c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_fwd_drop); 16627c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_bad_tunnel); 16637c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_cant_tunnel); 16647c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_wrong_if); 16657c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_upq_ovflw); 16667c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_cache_cleanups); 16677c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_drop_sel); 16687c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_q_overflow); 16697c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pkt2large); 16707c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_badversion); 16717c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_rcv_badcsum); 16727c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_badregisters); 16737c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_regforwards); 16747c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_regsend_drops); 16757c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_malformed); 16767c478bd9Sstevel@tonic-gate MDIFF(d, m2, m1, mrts_pim_nomemory); 16777c478bd9Sstevel@tonic-gate prevp = diffptr++; 16787c478bd9Sstevel@tonic-gate break; 16797c478bd9Sstevel@tonic-gate } 16807c478bd9Sstevel@tonic-gate case EXPER_IGMP: { 16817c478bd9Sstevel@tonic-gate struct igmpstat *i2; 16827c478bd9Sstevel@tonic-gate struct igmpstat *i1; 16837c478bd9Sstevel@tonic-gate struct igmpstat *d; 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate i2 = (struct igmpstat *)tempp2->valp; 16867c478bd9Sstevel@tonic-gate i1 = (struct igmpstat *)tempp1->valp; 16877c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 16887c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 16897c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 169078a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 16917c478bd9Sstevel@tonic-gate if (d == NULL) 16927c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 16937c478bd9Sstevel@tonic-gate diffptr->valp = d; 16947c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_total); 16957c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_tooshort); 16967c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_badsum); 16977c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_queries); 16987c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_badqueries); 16997c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_reports); 17007c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_badreports); 17017c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_rcv_ourreports); 17027c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, igps_snd_reports); 17037c478bd9Sstevel@tonic-gate prevp = diffptr++; 17047c478bd9Sstevel@tonic-gate break; 17057c478bd9Sstevel@tonic-gate } 17067c478bd9Sstevel@tonic-gate case MIB2_ICMP: { 17077c478bd9Sstevel@tonic-gate mib2_icmp_t *i2; 17087c478bd9Sstevel@tonic-gate mib2_icmp_t *i1; 17097c478bd9Sstevel@tonic-gate mib2_icmp_t *d; 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate i2 = (mib2_icmp_t *)tempp2->valp; 17127c478bd9Sstevel@tonic-gate i1 = (mib2_icmp_t *)tempp1->valp; 17137c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 17147c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 17157c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 171678a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 17177c478bd9Sstevel@tonic-gate if (d == NULL) 17187c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 17197c478bd9Sstevel@tonic-gate diffptr->valp = d; 17207c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInMsgs); 17217c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInErrors); 17227c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInCksumErrs); 17237c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInUnknowns); 17247c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInDestUnreachs); 17257c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInTimeExcds); 17267c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInParmProbs); 17277c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInSrcQuenchs); 17287c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInRedirects); 17297c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInBadRedirects); 17307c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInEchos); 17317c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInEchoReps); 17327c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInTimestamps); 17337c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInAddrMasks); 17347c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInAddrMaskReps); 17357c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInFragNeeded); 17367c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutMsgs); 17377c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutDrops); 17387c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutErrors); 17397c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutDestUnreachs); 17407c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutTimeExcds); 17417c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutParmProbs); 17427c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutSrcQuenchs); 17437c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutRedirects); 17447c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutEchos); 17457c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutEchoReps); 17467c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutTimestamps); 17477c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutTimestampReps); 17487c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutAddrMasks); 17497c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutAddrMaskReps); 17507c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpOutFragNeeded); 17517c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, icmpInOverflows); 17527c478bd9Sstevel@tonic-gate prevp = diffptr++; 17537c478bd9Sstevel@tonic-gate break; 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate case MIB2_ICMP6: { 17567c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *i2; 17577c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *i1; 17587c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *d; 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate i2 = (mib2_ipv6IfIcmpEntry_t *)tempp2->valp; 17617c478bd9Sstevel@tonic-gate i1 = (mib2_ipv6IfIcmpEntry_t *)tempp1->valp; 17627c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 17637c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 17647c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 176578a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 17667c478bd9Sstevel@tonic-gate if (d == NULL) 17677c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 17687c478bd9Sstevel@tonic-gate diffptr->valp = d; 17697c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInMsgs); 17707c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInErrors); 17717c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInDestUnreachs); 17727c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInAdminProhibs); 17737c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInTimeExcds); 17747c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInParmProblems); 17757c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInPktTooBigs); 17767c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInEchos); 17777c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInEchoReplies); 17787c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInRouterSolicits); 17797c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInRouterAdvertisements); 17807c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInNeighborSolicits); 17817c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInNeighborAdvertisements); 17827c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInRedirects); 17837c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInBadRedirects); 17847c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembQueries); 17857c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembResponses); 17867c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembReductions); 17877c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpInOverflows); 17887c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutMsgs); 17897c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutErrors); 17907c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutDestUnreachs); 17917c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutAdminProhibs); 17927c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutTimeExcds); 17937c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutParmProblems); 17947c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutPktTooBigs); 17957c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutEchos); 17967c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutEchoReplies); 17977c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutRouterSolicits); 17987c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutRouterAdvertisements); 17997c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutNeighborSolicits); 18007c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutNeighborAdvertisements); 18017c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutRedirects); 18027c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembQueries); 18037c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembResponses); 18047c478bd9Sstevel@tonic-gate MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembReductions); 18057c478bd9Sstevel@tonic-gate prevp = diffptr++; 18067c478bd9Sstevel@tonic-gate break; 18077c478bd9Sstevel@tonic-gate } 18087c478bd9Sstevel@tonic-gate case MIB2_TCP: { 18097c478bd9Sstevel@tonic-gate mib2_tcp_t *t2; 18107c478bd9Sstevel@tonic-gate mib2_tcp_t *t1; 18117c478bd9Sstevel@tonic-gate mib2_tcp_t *d; 18127c478bd9Sstevel@tonic-gate 18137c478bd9Sstevel@tonic-gate t2 = (mib2_tcp_t *)tempp2->valp; 18147c478bd9Sstevel@tonic-gate t1 = (mib2_tcp_t *)tempp1->valp; 18157c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 18167c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 18177c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 181878a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 18197c478bd9Sstevel@tonic-gate if (d == NULL) 18207c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 18217c478bd9Sstevel@tonic-gate diffptr->valp = d; 18227c478bd9Sstevel@tonic-gate d->tcpRtoMin = t2->tcpRtoMin; 18237c478bd9Sstevel@tonic-gate d->tcpRtoMax = t2->tcpRtoMax; 18247c478bd9Sstevel@tonic-gate d->tcpMaxConn = t2->tcpMaxConn; 18257c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpActiveOpens); 18267c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpPassiveOpens); 18277c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpAttemptFails); 18287c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpEstabResets); 18297c478bd9Sstevel@tonic-gate d->tcpCurrEstab = t2->tcpCurrEstab; 18303173664eSapersson MDIFF(d, t2, t1, tcpHCOutSegs); 18317c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutDataSegs); 18327c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutDataBytes); 18337c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpRetransSegs); 18347c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpRetransBytes); 18357c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutAck); 18367c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutAckDelayed); 18377c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutUrg); 18387c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutWinUpdate); 18397c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutWinProbe); 18407c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutControl); 18417c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutRsts); 18427c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutFastRetrans); 18433173664eSapersson MDIFF(d, t2, t1, tcpHCInSegs); 18447c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInAckSegs); 18457c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInAckBytes); 18467c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDupAck); 18477c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInAckUnsent); 18487c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataInorderSegs); 18497c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataInorderBytes); 18507c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataUnorderSegs); 18517c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataUnorderBytes); 18527c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataDupSegs); 18537c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataDupBytes); 18547c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataPartDupSegs); 18557c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataPartDupBytes); 18567c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataPastWinSegs); 18577c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInDataPastWinBytes); 18587c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInWinProbe); 18597c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInWinUpdate); 18607c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpInClosed); 18617c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpRttNoUpdate); 18627c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpRttUpdate); 18637c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpTimRetrans); 18647c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpTimRetransDrop); 18657c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpTimKeepalive); 18667c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpTimKeepaliveProbe); 18677c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpTimKeepaliveDrop); 18687c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpListenDrop); 18697c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpListenDropQ0); 18707c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpHalfOpenDrop); 18717c478bd9Sstevel@tonic-gate MDIFF(d, t2, t1, tcpOutSackRetransSegs); 18727c478bd9Sstevel@tonic-gate prevp = diffptr++; 18737c478bd9Sstevel@tonic-gate break; 18747c478bd9Sstevel@tonic-gate } 18757c478bd9Sstevel@tonic-gate case MIB2_UDP: { 18767c478bd9Sstevel@tonic-gate mib2_udp_t *u2; 18777c478bd9Sstevel@tonic-gate mib2_udp_t *u1; 18787c478bd9Sstevel@tonic-gate mib2_udp_t *d; 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate u2 = (mib2_udp_t *)tempp2->valp; 18817c478bd9Sstevel@tonic-gate u1 = (mib2_udp_t *)tempp1->valp; 18827c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 18837c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 18847c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 188578a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 18867c478bd9Sstevel@tonic-gate if (d == NULL) 18877c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 18887c478bd9Sstevel@tonic-gate diffptr->valp = d; 18893173664eSapersson MDIFF(d, u2, u1, udpHCInDatagrams); 18907c478bd9Sstevel@tonic-gate MDIFF(d, u2, u1, udpInErrors); 18913173664eSapersson MDIFF(d, u2, u1, udpHCOutDatagrams); 18927c478bd9Sstevel@tonic-gate MDIFF(d, u2, u1, udpOutErrors); 18937c478bd9Sstevel@tonic-gate prevp = diffptr++; 18947c478bd9Sstevel@tonic-gate break; 18957c478bd9Sstevel@tonic-gate } 18967c478bd9Sstevel@tonic-gate case MIB2_SCTP: { 18977c478bd9Sstevel@tonic-gate mib2_sctp_t *s2; 18987c478bd9Sstevel@tonic-gate mib2_sctp_t *s1; 18997c478bd9Sstevel@tonic-gate mib2_sctp_t *d; 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate s2 = (mib2_sctp_t *)tempp2->valp; 19027c478bd9Sstevel@tonic-gate s1 = (mib2_sctp_t *)tempp1->valp; 19037c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 19047c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 19057c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 190678a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 19077c478bd9Sstevel@tonic-gate if (d == NULL) 19087c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 19097c478bd9Sstevel@tonic-gate diffptr->valp = d; 19107c478bd9Sstevel@tonic-gate d->sctpRtoAlgorithm = s2->sctpRtoAlgorithm; 19117c478bd9Sstevel@tonic-gate d->sctpRtoMin = s2->sctpRtoMin; 19127c478bd9Sstevel@tonic-gate d->sctpRtoMax = s2->sctpRtoMax; 19137c478bd9Sstevel@tonic-gate d->sctpRtoInitial = s2->sctpRtoInitial; 19147c478bd9Sstevel@tonic-gate d->sctpMaxAssocs = s2->sctpMaxAssocs; 19157c478bd9Sstevel@tonic-gate d->sctpValCookieLife = s2->sctpValCookieLife; 19167c478bd9Sstevel@tonic-gate d->sctpMaxInitRetr = s2->sctpMaxInitRetr; 19177c478bd9Sstevel@tonic-gate d->sctpCurrEstab = s2->sctpCurrEstab; 19187c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpActiveEstab); 19197c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpPassiveEstab); 19207c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpAborted); 19217c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpShutdowns); 19227c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutOfBlue); 19237c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpChecksumError); 19247c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutCtrlChunks); 19257c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutOrderChunks); 19267c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutUnorderChunks); 19277c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpRetransChunks); 19287c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutAck); 19297c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutAckDelayed); 19307c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutWinUpdate); 19317c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutFastRetrans); 19327c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutWinProbe); 19337c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInCtrlChunks); 19347c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInOrderChunks); 19357c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInUnorderChunks); 19367c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInAck); 19377c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInDupAck); 19387c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInAckUnsent); 19397c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpFragUsrMsgs); 19407c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpReasmUsrMsgs); 19417c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpOutSCTPPkts); 19427c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInSCTPPkts); 19437c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInInvalidCookie); 19447c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpTimRetrans); 19457c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpTimRetransDrop); 19467c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpTimHeartBeatProbe); 19477c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpTimHeartBeatDrop); 19487c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpListenDrop); 19497c478bd9Sstevel@tonic-gate MDIFF(d, s2, s1, sctpInClosed); 19507c478bd9Sstevel@tonic-gate prevp = diffptr++; 19517c478bd9Sstevel@tonic-gate break; 19527c478bd9Sstevel@tonic-gate } 19537c478bd9Sstevel@tonic-gate case EXPER_RAWIP: { 19547c478bd9Sstevel@tonic-gate mib2_rawip_t *r2; 19557c478bd9Sstevel@tonic-gate mib2_rawip_t *r1; 19567c478bd9Sstevel@tonic-gate mib2_rawip_t *d; 19577c478bd9Sstevel@tonic-gate 19587c478bd9Sstevel@tonic-gate r2 = (mib2_rawip_t *)tempp2->valp; 19597c478bd9Sstevel@tonic-gate r1 = (mib2_rawip_t *)tempp1->valp; 19607c478bd9Sstevel@tonic-gate diffptr->group = tempp2->group; 19617c478bd9Sstevel@tonic-gate diffptr->mib_id = tempp2->mib_id; 19627c478bd9Sstevel@tonic-gate diffptr->length = tempp2->length; 196378a2e113SAndy Fiddaman d = calloc(1, tempp2->length); 19647c478bd9Sstevel@tonic-gate if (d == NULL) 19657c478bd9Sstevel@tonic-gate goto mibdiff_out_of_memory; 19667c478bd9Sstevel@tonic-gate diffptr->valp = d; 19677c478bd9Sstevel@tonic-gate MDIFF(d, r2, r1, rawipInDatagrams); 19687c478bd9Sstevel@tonic-gate MDIFF(d, r2, r1, rawipInErrors); 19697c478bd9Sstevel@tonic-gate MDIFF(d, r2, r1, rawipInCksumErrs); 19707c478bd9Sstevel@tonic-gate MDIFF(d, r2, r1, rawipOutDatagrams); 19717c478bd9Sstevel@tonic-gate MDIFF(d, r2, r1, rawipOutErrors); 19727c478bd9Sstevel@tonic-gate prevp = diffptr++; 19737c478bd9Sstevel@tonic-gate break; 19747c478bd9Sstevel@tonic-gate } 19757c478bd9Sstevel@tonic-gate /* 19767c478bd9Sstevel@tonic-gate * there are more "group" types but they aren't 19777c478bd9Sstevel@tonic-gate * required for the -s and -Ms options 19787c478bd9Sstevel@tonic-gate */ 19797c478bd9Sstevel@tonic-gate } 198078a2e113SAndy Fiddaman } 19817c478bd9Sstevel@tonic-gate tempp1 = NULL; 198278a2e113SAndy Fiddaman } 19837c478bd9Sstevel@tonic-gate tempp2 = NULL; 19847c478bd9Sstevel@tonic-gate diffptr--; 19857c478bd9Sstevel@tonic-gate diffptr->next_item = NULL; 19867c478bd9Sstevel@tonic-gate return (diffp); 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate mibdiff_out_of_memory:; 19897c478bd9Sstevel@tonic-gate mib_item_destroy(&diffp); 19907c478bd9Sstevel@tonic-gate return (NULL); 19917c478bd9Sstevel@tonic-gate } 19927c478bd9Sstevel@tonic-gate 19937c478bd9Sstevel@tonic-gate /* 19947c478bd9Sstevel@tonic-gate * mib_item_destroy: cleans up a mib_item_t * 19957c478bd9Sstevel@tonic-gate * that was created by calling mib_item_dup or 19967c478bd9Sstevel@tonic-gate * mib_item_diff 19977c478bd9Sstevel@tonic-gate */ 19987c478bd9Sstevel@tonic-gate static void 1999afee3dc6SRobert Mustacchi mib_item_destroy(mib_item_t **itemp) 2000afee3dc6SRobert Mustacchi { 20017c478bd9Sstevel@tonic-gate int nitems = 0; 20027c478bd9Sstevel@tonic-gate int c = 0; 20037c478bd9Sstevel@tonic-gate mib_item_t *tempp; 20047c478bd9Sstevel@tonic-gate 20057c478bd9Sstevel@tonic-gate if (itemp == NULL || *itemp == NULL) 20067c478bd9Sstevel@tonic-gate return; 20077c478bd9Sstevel@tonic-gate 20087c478bd9Sstevel@tonic-gate for (tempp = *itemp; tempp != NULL; tempp = tempp->next_item) 20097c478bd9Sstevel@tonic-gate if (tempp->mib_id == 0) 20107c478bd9Sstevel@tonic-gate nitems++; 20117c478bd9Sstevel@tonic-gate else 20127c478bd9Sstevel@tonic-gate return; /* cannot destroy! */ 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate if (nitems == 0) 20157c478bd9Sstevel@tonic-gate return; /* cannot destroy! */ 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate for (c = nitems - 1; c >= 0; c--) { 20187c478bd9Sstevel@tonic-gate if ((itemp[0][c]).valp != NULL) 20197c478bd9Sstevel@tonic-gate free((itemp[0][c]).valp); 20207c478bd9Sstevel@tonic-gate } 20217c478bd9Sstevel@tonic-gate free(*itemp); 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate *itemp = NULL; 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate /* Compare two Octet_ts. Return B_TRUE if they match, B_FALSE if not. */ 20277c478bd9Sstevel@tonic-gate static boolean_t 20287c478bd9Sstevel@tonic-gate octetstrmatch(const Octet_t *a, const Octet_t *b) 20297c478bd9Sstevel@tonic-gate { 20307c478bd9Sstevel@tonic-gate if (a == NULL || b == NULL) 20317c478bd9Sstevel@tonic-gate return (B_FALSE); 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate if (a->o_length != b->o_length) 20347c478bd9Sstevel@tonic-gate return (B_FALSE); 20357c478bd9Sstevel@tonic-gate 20367c478bd9Sstevel@tonic-gate return (memcmp(a->o_bytes, b->o_bytes, a->o_length) == 0); 20377c478bd9Sstevel@tonic-gate } 20387c478bd9Sstevel@tonic-gate 20397c478bd9Sstevel@tonic-gate /* If octetstr() changes make an appropriate change to STR_EXPAND */ 20407c478bd9Sstevel@tonic-gate static char * 204145916cd2Sjpk octetstr(const Octet_t *op, int code, char *dst, uint_t dstlen) 20427c478bd9Sstevel@tonic-gate { 20437c478bd9Sstevel@tonic-gate int i; 20447c478bd9Sstevel@tonic-gate char *cp; 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate cp = dst; 20477c478bd9Sstevel@tonic-gate if (op) { 20487c478bd9Sstevel@tonic-gate for (i = 0; i < op->o_length; i++) { 20497c478bd9Sstevel@tonic-gate switch (code) { 20507c478bd9Sstevel@tonic-gate case 'd': 20517c478bd9Sstevel@tonic-gate if (cp - dst + 4 > dstlen) { 20527c478bd9Sstevel@tonic-gate *cp = '\0'; 20537c478bd9Sstevel@tonic-gate return (dst); 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate (void) snprintf(cp, 5, "%d.", 20567c478bd9Sstevel@tonic-gate 0xff & op->o_bytes[i]); 20577c478bd9Sstevel@tonic-gate cp = strchr(cp, '\0'); 20587c478bd9Sstevel@tonic-gate break; 20597c478bd9Sstevel@tonic-gate case 'a': 20607c478bd9Sstevel@tonic-gate if (cp - dst + 1 > dstlen) { 20617c478bd9Sstevel@tonic-gate *cp = '\0'; 20627c478bd9Sstevel@tonic-gate return (dst); 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate *cp++ = op->o_bytes[i]; 20657c478bd9Sstevel@tonic-gate break; 20667c478bd9Sstevel@tonic-gate case 'h': 20677c478bd9Sstevel@tonic-gate default: 20687c478bd9Sstevel@tonic-gate if (cp - dst + 3 > dstlen) { 20697c478bd9Sstevel@tonic-gate *cp = '\0'; 20707c478bd9Sstevel@tonic-gate return (dst); 20717c478bd9Sstevel@tonic-gate } 20727c478bd9Sstevel@tonic-gate (void) snprintf(cp, 4, "%02x:", 20737c478bd9Sstevel@tonic-gate 0xff & op->o_bytes[i]); 20747c478bd9Sstevel@tonic-gate cp += 3; 20757c478bd9Sstevel@tonic-gate break; 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate } 20797c478bd9Sstevel@tonic-gate if (code != 'a' && cp != dst) 20807c478bd9Sstevel@tonic-gate cp--; 20817c478bd9Sstevel@tonic-gate *cp = '\0'; 20827c478bd9Sstevel@tonic-gate return (dst); 20837c478bd9Sstevel@tonic-gate } 20847c478bd9Sstevel@tonic-gate 208545916cd2Sjpk static const char * 208645916cd2Sjpk mitcp_state(int state, const mib2_transportMLPEntry_t *attr) 20877c478bd9Sstevel@tonic-gate { 208845916cd2Sjpk static char tcpsbuf[50]; 208945916cd2Sjpk const char *cp; 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate switch (state) { 20927c478bd9Sstevel@tonic-gate case TCPS_CLOSED: 20937c478bd9Sstevel@tonic-gate cp = "CLOSED"; 20947c478bd9Sstevel@tonic-gate break; 20957c478bd9Sstevel@tonic-gate case TCPS_IDLE: 20967c478bd9Sstevel@tonic-gate cp = "IDLE"; 20977c478bd9Sstevel@tonic-gate break; 20987c478bd9Sstevel@tonic-gate case TCPS_BOUND: 20997c478bd9Sstevel@tonic-gate cp = "BOUND"; 21007c478bd9Sstevel@tonic-gate break; 21017c478bd9Sstevel@tonic-gate case TCPS_LISTEN: 21027c478bd9Sstevel@tonic-gate cp = "LISTEN"; 21037c478bd9Sstevel@tonic-gate break; 21047c478bd9Sstevel@tonic-gate case TCPS_SYN_SENT: 21057c478bd9Sstevel@tonic-gate cp = "SYN_SENT"; 21067c478bd9Sstevel@tonic-gate break; 21077c478bd9Sstevel@tonic-gate case TCPS_SYN_RCVD: 21087c478bd9Sstevel@tonic-gate cp = "SYN_RCVD"; 21097c478bd9Sstevel@tonic-gate break; 21107c478bd9Sstevel@tonic-gate case TCPS_ESTABLISHED: 21117c478bd9Sstevel@tonic-gate cp = "ESTABLISHED"; 21127c478bd9Sstevel@tonic-gate break; 21137c478bd9Sstevel@tonic-gate case TCPS_CLOSE_WAIT: 21147c478bd9Sstevel@tonic-gate cp = "CLOSE_WAIT"; 21157c478bd9Sstevel@tonic-gate break; 21167c478bd9Sstevel@tonic-gate case TCPS_FIN_WAIT_1: 21177c478bd9Sstevel@tonic-gate cp = "FIN_WAIT_1"; 21187c478bd9Sstevel@tonic-gate break; 21197c478bd9Sstevel@tonic-gate case TCPS_CLOSING: 21207c478bd9Sstevel@tonic-gate cp = "CLOSING"; 21217c478bd9Sstevel@tonic-gate break; 21227c478bd9Sstevel@tonic-gate case TCPS_LAST_ACK: 21237c478bd9Sstevel@tonic-gate cp = "LAST_ACK"; 21247c478bd9Sstevel@tonic-gate break; 21257c478bd9Sstevel@tonic-gate case TCPS_FIN_WAIT_2: 21267c478bd9Sstevel@tonic-gate cp = "FIN_WAIT_2"; 21277c478bd9Sstevel@tonic-gate break; 21287c478bd9Sstevel@tonic-gate case TCPS_TIME_WAIT: 21297c478bd9Sstevel@tonic-gate cp = "TIME_WAIT"; 21307c478bd9Sstevel@tonic-gate break; 21317c478bd9Sstevel@tonic-gate default: 21327c478bd9Sstevel@tonic-gate (void) snprintf(tcpsbuf, sizeof (tcpsbuf), 21337c478bd9Sstevel@tonic-gate "UnknownState(%d)", state); 21347c478bd9Sstevel@tonic-gate cp = tcpsbuf; 21357c478bd9Sstevel@tonic-gate break; 21367c478bd9Sstevel@tonic-gate } 213745916cd2Sjpk 213845916cd2Sjpk if (RSECflag && attr != NULL && attr->tme_flags != 0) { 213945916cd2Sjpk if (cp != tcpsbuf) { 214045916cd2Sjpk (void) strlcpy(tcpsbuf, cp, sizeof (tcpsbuf)); 214145916cd2Sjpk cp = tcpsbuf; 214245916cd2Sjpk } 214345916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_PRIVATE) 214445916cd2Sjpk (void) strlcat(tcpsbuf, " P", sizeof (tcpsbuf)); 214545916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_SHARED) 214645916cd2Sjpk (void) strlcat(tcpsbuf, " S", sizeof (tcpsbuf)); 214745916cd2Sjpk } 214845916cd2Sjpk 214945916cd2Sjpk return (cp); 215045916cd2Sjpk } 215145916cd2Sjpk 215245916cd2Sjpk static const char * 215345916cd2Sjpk miudp_state(int state, const mib2_transportMLPEntry_t *attr) 215445916cd2Sjpk { 215545916cd2Sjpk static char udpsbuf[50]; 215645916cd2Sjpk const char *cp; 215745916cd2Sjpk 215845916cd2Sjpk switch (state) { 215945916cd2Sjpk case MIB2_UDP_unbound: 216045916cd2Sjpk cp = "Unbound"; 216145916cd2Sjpk break; 216245916cd2Sjpk case MIB2_UDP_idle: 216345916cd2Sjpk cp = "Idle"; 216445916cd2Sjpk break; 216545916cd2Sjpk case MIB2_UDP_connected: 216645916cd2Sjpk cp = "Connected"; 216745916cd2Sjpk break; 216845916cd2Sjpk default: 216945916cd2Sjpk (void) snprintf(udpsbuf, sizeof (udpsbuf), 217045916cd2Sjpk "Unknown State(%d)", state); 217145916cd2Sjpk cp = udpsbuf; 217245916cd2Sjpk break; 217345916cd2Sjpk } 217445916cd2Sjpk 217545916cd2Sjpk if (RSECflag && attr != NULL && attr->tme_flags != 0) { 217645916cd2Sjpk if (cp != udpsbuf) { 217745916cd2Sjpk (void) strlcpy(udpsbuf, cp, sizeof (udpsbuf)); 217845916cd2Sjpk cp = udpsbuf; 217945916cd2Sjpk } 218045916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_PRIVATE) 218145916cd2Sjpk (void) strlcat(udpsbuf, " P", sizeof (udpsbuf)); 218245916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_SHARED) 218345916cd2Sjpk (void) strlcat(udpsbuf, " S", sizeof (udpsbuf)); 218445916cd2Sjpk } 218545916cd2Sjpk 21867c478bd9Sstevel@tonic-gate return (cp); 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate static int odd; 21907c478bd9Sstevel@tonic-gate 21917c478bd9Sstevel@tonic-gate static void 21927c478bd9Sstevel@tonic-gate prval_init(void) 21937c478bd9Sstevel@tonic-gate { 21947c478bd9Sstevel@tonic-gate odd = 0; 21957c478bd9Sstevel@tonic-gate } 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate static void 21987c478bd9Sstevel@tonic-gate prval(char *str, Counter val) 21997c478bd9Sstevel@tonic-gate { 22007c478bd9Sstevel@tonic-gate (void) printf("\t%-20s=%6u", str, val); 22017c478bd9Sstevel@tonic-gate if (odd++ & 1) 22027c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22037c478bd9Sstevel@tonic-gate } 22047c478bd9Sstevel@tonic-gate 22057c478bd9Sstevel@tonic-gate static void 22067c478bd9Sstevel@tonic-gate prval64(char *str, Counter64 val) 22077c478bd9Sstevel@tonic-gate { 22087c478bd9Sstevel@tonic-gate (void) printf("\t%-20s=%6llu", str, val); 22097c478bd9Sstevel@tonic-gate if (odd++ & 1) 22107c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22117c478bd9Sstevel@tonic-gate } 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate static void 22147c478bd9Sstevel@tonic-gate pr_int_val(char *str, int val) 22157c478bd9Sstevel@tonic-gate { 22167c478bd9Sstevel@tonic-gate (void) printf("\t%-20s=%6d", str, val); 22177c478bd9Sstevel@tonic-gate if (odd++ & 1) 22187c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22197c478bd9Sstevel@tonic-gate } 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate static void 22227c478bd9Sstevel@tonic-gate pr_sctp_rtoalgo(char *str, int val) 22237c478bd9Sstevel@tonic-gate { 22247c478bd9Sstevel@tonic-gate (void) printf("\t%-20s=", str); 22257c478bd9Sstevel@tonic-gate switch (val) { 22267c478bd9Sstevel@tonic-gate case MIB2_SCTP_RTOALGO_OTHER: 22277c478bd9Sstevel@tonic-gate (void) printf("%6.6s", "other"); 22287c478bd9Sstevel@tonic-gate break; 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate case MIB2_SCTP_RTOALGO_VANJ: 22317c478bd9Sstevel@tonic-gate (void) printf("%6.6s", "vanj"); 22327c478bd9Sstevel@tonic-gate break; 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate default: 22357c478bd9Sstevel@tonic-gate (void) printf("%6d", val); 22367c478bd9Sstevel@tonic-gate break; 22377c478bd9Sstevel@tonic-gate } 22387c478bd9Sstevel@tonic-gate if (odd++ & 1) 22397c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22407c478bd9Sstevel@tonic-gate } 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate static void 22437c478bd9Sstevel@tonic-gate prval_end(void) 22447c478bd9Sstevel@tonic-gate { 22457c478bd9Sstevel@tonic-gate if (odd++ & 1) 22467c478bd9Sstevel@tonic-gate (void) putchar('\n'); 22477c478bd9Sstevel@tonic-gate } 22487c478bd9Sstevel@tonic-gate 22497c478bd9Sstevel@tonic-gate /* Extract constant sizes */ 22507c478bd9Sstevel@tonic-gate static void 22517c478bd9Sstevel@tonic-gate mib_get_constants(mib_item_t *item) 22527c478bd9Sstevel@tonic-gate { 22537c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 22547c478bd9Sstevel@tonic-gate if (item->mib_id != 0) 225578a2e113SAndy Fiddaman continue; 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate switch (item->group) { 22587c478bd9Sstevel@tonic-gate case MIB2_IP: { 22597c478bd9Sstevel@tonic-gate mib2_ip_t *ip = (mib2_ip_t *)item->valp; 22607c478bd9Sstevel@tonic-gate 22617c478bd9Sstevel@tonic-gate ipAddrEntrySize = ip->ipAddrEntrySize; 22627c478bd9Sstevel@tonic-gate ipRouteEntrySize = ip->ipRouteEntrySize; 22637c478bd9Sstevel@tonic-gate ipNetToMediaEntrySize = ip->ipNetToMediaEntrySize; 22647c478bd9Sstevel@tonic-gate ipMemberEntrySize = ip->ipMemberEntrySize; 22657c478bd9Sstevel@tonic-gate ipGroupSourceEntrySize = ip->ipGroupSourceEntrySize; 226645916cd2Sjpk ipRouteAttributeSize = ip->ipRouteAttributeSize; 226745916cd2Sjpk transportMLPSize = ip->transportMLPSize; 2268bd670b35SErik Nordmark ipDestEntrySize = ip->ipDestEntrySize; 22697c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(ipAddrEntrySize, 2270e11c3f44Smeem sizeof (mib2_ipAddrEntry_t *))); 2271e11c3f44Smeem assert(IS_P2ALIGNED(ipRouteEntrySize, 2272e11c3f44Smeem sizeof (mib2_ipRouteEntry_t *))); 2273e11c3f44Smeem assert(IS_P2ALIGNED(ipNetToMediaEntrySize, 2274e11c3f44Smeem sizeof (mib2_ipNetToMediaEntry_t *))); 2275e11c3f44Smeem assert(IS_P2ALIGNED(ipMemberEntrySize, 2276e11c3f44Smeem sizeof (ip_member_t *))); 2277e11c3f44Smeem assert(IS_P2ALIGNED(ipGroupSourceEntrySize, 2278e11c3f44Smeem sizeof (ip_grpsrc_t *))); 2279e11c3f44Smeem assert(IS_P2ALIGNED(ipRouteAttributeSize, 2280e11c3f44Smeem sizeof (mib2_ipAttributeEntry_t *))); 2281e11c3f44Smeem assert(IS_P2ALIGNED(transportMLPSize, 2282e11c3f44Smeem sizeof (mib2_transportMLPEntry_t *))); 22837c478bd9Sstevel@tonic-gate break; 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate case EXPER_DVMRP: { 22867c478bd9Sstevel@tonic-gate struct mrtstat *mrts = (struct mrtstat *)item->valp; 22877c478bd9Sstevel@tonic-gate 22887c478bd9Sstevel@tonic-gate vifctlSize = mrts->mrts_vifctlSize; 22897c478bd9Sstevel@tonic-gate mfcctlSize = mrts->mrts_mfcctlSize; 22907c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(vifctlSize, 2291e11c3f44Smeem sizeof (struct vifclt *))); 2292e11c3f44Smeem assert(IS_P2ALIGNED(mfcctlSize, 2293e11c3f44Smeem sizeof (struct mfcctl *))); 22947c478bd9Sstevel@tonic-gate break; 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate case MIB2_IP6: { 22977c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *ip6; 22987c478bd9Sstevel@tonic-gate /* Just use the first entry */ 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate ip6 = (mib2_ipv6IfStatsEntry_t *)item->valp; 23017c478bd9Sstevel@tonic-gate ipv6IfStatsEntrySize = ip6->ipv6IfStatsEntrySize; 23027c478bd9Sstevel@tonic-gate ipv6AddrEntrySize = ip6->ipv6AddrEntrySize; 23037c478bd9Sstevel@tonic-gate ipv6RouteEntrySize = ip6->ipv6RouteEntrySize; 23047c478bd9Sstevel@tonic-gate ipv6NetToMediaEntrySize = ip6->ipv6NetToMediaEntrySize; 23057c478bd9Sstevel@tonic-gate ipv6MemberEntrySize = ip6->ipv6MemberEntrySize; 23067c478bd9Sstevel@tonic-gate ipv6GroupSourceEntrySize = 23077c478bd9Sstevel@tonic-gate ip6->ipv6GroupSourceEntrySize; 23087c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(ipv6IfStatsEntrySize, 2309e11c3f44Smeem sizeof (mib2_ipv6IfStatsEntry_t *))); 2310e11c3f44Smeem assert(IS_P2ALIGNED(ipv6AddrEntrySize, 2311e11c3f44Smeem sizeof (mib2_ipv6AddrEntry_t *))); 2312e11c3f44Smeem assert(IS_P2ALIGNED(ipv6RouteEntrySize, 2313e11c3f44Smeem sizeof (mib2_ipv6RouteEntry_t *))); 2314e11c3f44Smeem assert(IS_P2ALIGNED(ipv6NetToMediaEntrySize, 2315e11c3f44Smeem sizeof (mib2_ipv6NetToMediaEntry_t *))); 2316e11c3f44Smeem assert(IS_P2ALIGNED(ipv6MemberEntrySize, 2317e11c3f44Smeem sizeof (ipv6_member_t *))); 2318e11c3f44Smeem assert(IS_P2ALIGNED(ipv6GroupSourceEntrySize, 2319e11c3f44Smeem sizeof (ipv6_grpsrc_t *))); 23207c478bd9Sstevel@tonic-gate break; 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate case MIB2_ICMP6: { 23237c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *icmp6; 23247c478bd9Sstevel@tonic-gate /* Just use the first entry */ 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate icmp6 = (mib2_ipv6IfIcmpEntry_t *)item->valp; 23277c478bd9Sstevel@tonic-gate ipv6IfIcmpEntrySize = icmp6->ipv6IfIcmpEntrySize; 23287c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(ipv6IfIcmpEntrySize, 23297c478bd9Sstevel@tonic-gate sizeof (mib2_ipv6IfIcmpEntry_t *))); 23307c478bd9Sstevel@tonic-gate break; 23317c478bd9Sstevel@tonic-gate } 23327c478bd9Sstevel@tonic-gate case MIB2_TCP: { 23337c478bd9Sstevel@tonic-gate mib2_tcp_t *tcp = (mib2_tcp_t *)item->valp; 23347c478bd9Sstevel@tonic-gate 23357c478bd9Sstevel@tonic-gate tcpConnEntrySize = tcp->tcpConnTableSize; 23367c478bd9Sstevel@tonic-gate tcp6ConnEntrySize = tcp->tcp6ConnTableSize; 23377c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(tcpConnEntrySize, 2338e11c3f44Smeem sizeof (mib2_tcpConnEntry_t *))); 2339e11c3f44Smeem assert(IS_P2ALIGNED(tcp6ConnEntrySize, 2340e11c3f44Smeem sizeof (mib2_tcp6ConnEntry_t *))); 23417c478bd9Sstevel@tonic-gate break; 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate case MIB2_UDP: { 23447c478bd9Sstevel@tonic-gate mib2_udp_t *udp = (mib2_udp_t *)item->valp; 23457c478bd9Sstevel@tonic-gate 23467c478bd9Sstevel@tonic-gate udpEntrySize = udp->udpEntrySize; 23477c478bd9Sstevel@tonic-gate udp6EntrySize = udp->udp6EntrySize; 23487c478bd9Sstevel@tonic-gate assert(IS_P2ALIGNED(udpEntrySize, 2349e11c3f44Smeem sizeof (mib2_udpEntry_t *))); 2350e11c3f44Smeem assert(IS_P2ALIGNED(udp6EntrySize, 2351e11c3f44Smeem sizeof (mib2_udp6Entry_t *))); 23527c478bd9Sstevel@tonic-gate break; 23537c478bd9Sstevel@tonic-gate } 23547c478bd9Sstevel@tonic-gate case MIB2_SCTP: { 23557c478bd9Sstevel@tonic-gate mib2_sctp_t *sctp = (mib2_sctp_t *)item->valp; 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate sctpEntrySize = sctp->sctpEntrySize; 23587c478bd9Sstevel@tonic-gate sctpLocalEntrySize = sctp->sctpLocalEntrySize; 23597c478bd9Sstevel@tonic-gate sctpRemoteEntrySize = sctp->sctpRemoteEntrySize; 23607c478bd9Sstevel@tonic-gate break; 23617c478bd9Sstevel@tonic-gate } 23627c478bd9Sstevel@tonic-gate } 236378a2e113SAndy Fiddaman } 23647c478bd9Sstevel@tonic-gate 2365bd670b35SErik Nordmark if (Xflag) { 23667c478bd9Sstevel@tonic-gate (void) puts("mib_get_constants:"); 23677c478bd9Sstevel@tonic-gate (void) printf("\tipv6IfStatsEntrySize %d\n", 23687c478bd9Sstevel@tonic-gate ipv6IfStatsEntrySize); 23697c478bd9Sstevel@tonic-gate (void) printf("\tipAddrEntrySize %d\n", ipAddrEntrySize); 23707c478bd9Sstevel@tonic-gate (void) printf("\tipRouteEntrySize %d\n", ipRouteEntrySize); 23717c478bd9Sstevel@tonic-gate (void) printf("\tipNetToMediaEntrySize %d\n", 23727c478bd9Sstevel@tonic-gate ipNetToMediaEntrySize); 23737c478bd9Sstevel@tonic-gate (void) printf("\tipMemberEntrySize %d\n", ipMemberEntrySize); 237445916cd2Sjpk (void) printf("\tipRouteAttributeSize %d\n", 237545916cd2Sjpk ipRouteAttributeSize); 23767c478bd9Sstevel@tonic-gate (void) printf("\tvifctlSize %d\n", vifctlSize); 23777c478bd9Sstevel@tonic-gate (void) printf("\tmfcctlSize %d\n", mfcctlSize); 23787c478bd9Sstevel@tonic-gate 23797c478bd9Sstevel@tonic-gate (void) printf("\tipv6AddrEntrySize %d\n", ipv6AddrEntrySize); 23807c478bd9Sstevel@tonic-gate (void) printf("\tipv6RouteEntrySize %d\n", ipv6RouteEntrySize); 23817c478bd9Sstevel@tonic-gate (void) printf("\tipv6NetToMediaEntrySize %d\n", 23827c478bd9Sstevel@tonic-gate ipv6NetToMediaEntrySize); 23837c478bd9Sstevel@tonic-gate (void) printf("\tipv6MemberEntrySize %d\n", 23847c478bd9Sstevel@tonic-gate ipv6MemberEntrySize); 23857c478bd9Sstevel@tonic-gate (void) printf("\tipv6IfIcmpEntrySize %d\n", 23867c478bd9Sstevel@tonic-gate ipv6IfIcmpEntrySize); 2387bd670b35SErik Nordmark (void) printf("\tipDestEntrySize %d\n", ipDestEntrySize); 238845916cd2Sjpk (void) printf("\ttransportMLPSize %d\n", transportMLPSize); 23897c478bd9Sstevel@tonic-gate (void) printf("\ttcpConnEntrySize %d\n", tcpConnEntrySize); 23907c478bd9Sstevel@tonic-gate (void) printf("\ttcp6ConnEntrySize %d\n", tcp6ConnEntrySize); 23917c478bd9Sstevel@tonic-gate (void) printf("\tudpEntrySize %d\n", udpEntrySize); 23927c478bd9Sstevel@tonic-gate (void) printf("\tudp6EntrySize %d\n", udp6EntrySize); 23937c478bd9Sstevel@tonic-gate (void) printf("\tsctpEntrySize %d\n", sctpEntrySize); 23947c478bd9Sstevel@tonic-gate (void) printf("\tsctpLocalEntrySize %d\n", sctpLocalEntrySize); 23957c478bd9Sstevel@tonic-gate (void) printf("\tsctpRemoteEntrySize %d\n", 23967c478bd9Sstevel@tonic-gate sctpRemoteEntrySize); 23977c478bd9Sstevel@tonic-gate } 23987c478bd9Sstevel@tonic-gate } 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate /* ----------------------------- STAT_REPORT ------------------------------- */ 24017c478bd9Sstevel@tonic-gate 24027c478bd9Sstevel@tonic-gate static void 24037c478bd9Sstevel@tonic-gate stat_report(mib_item_t *item) 24047c478bd9Sstevel@tonic-gate { 24057c478bd9Sstevel@tonic-gate int jtemp = 0; 24067c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 24077c478bd9Sstevel@tonic-gate 24087c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 2409bd670b35SErik Nordmark if (Xflag) { 241078a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 24117c478bd9Sstevel@tonic-gate "length = %d, valp = 0x%p\n", 241278a2e113SAndy Fiddaman jtemp++, item->group, item->mib_id, 24137c478bd9Sstevel@tonic-gate item->length, item->valp); 24147c478bd9Sstevel@tonic-gate } 24157c478bd9Sstevel@tonic-gate if (item->mib_id != 0) 241678a2e113SAndy Fiddaman continue; 24177c478bd9Sstevel@tonic-gate 24187c478bd9Sstevel@tonic-gate switch (item->group) { 24197c478bd9Sstevel@tonic-gate case MIB2_IP: { 24207c478bd9Sstevel@tonic-gate mib2_ip_t *ip = (mib2_ip_t *)item->valp; 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_IP) && 24237c478bd9Sstevel@tonic-gate family_selected(AF_INET)) { 24247c478bd9Sstevel@tonic-gate (void) fputs(v4compat ? "\nIP" : "\nIPv4", 24257c478bd9Sstevel@tonic-gate stdout); 24267c478bd9Sstevel@tonic-gate print_ip_stats(ip); 24277c478bd9Sstevel@tonic-gate } 24287c478bd9Sstevel@tonic-gate break; 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate case MIB2_ICMP: { 24317c478bd9Sstevel@tonic-gate mib2_icmp_t *icmp = 24327c478bd9Sstevel@tonic-gate (mib2_icmp_t *)item->valp; 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_ICMP) && 24357c478bd9Sstevel@tonic-gate family_selected(AF_INET)) { 24367c478bd9Sstevel@tonic-gate (void) fputs(v4compat ? "\nICMP" : "\nICMPv4", 24377c478bd9Sstevel@tonic-gate stdout); 24387c478bd9Sstevel@tonic-gate print_icmp_stats(icmp); 24397c478bd9Sstevel@tonic-gate } 24407c478bd9Sstevel@tonic-gate break; 24417c478bd9Sstevel@tonic-gate } 24427c478bd9Sstevel@tonic-gate case MIB2_IP6: { 24437c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t *ip6; 24447c478bd9Sstevel@tonic-gate mib2_ipv6IfStatsEntry_t sum6; 24457c478bd9Sstevel@tonic-gate 24467c478bd9Sstevel@tonic-gate if (!(protocol_selected(IPPROTO_IPV6)) || 24477c478bd9Sstevel@tonic-gate !(family_selected(AF_INET6))) 24487c478bd9Sstevel@tonic-gate break; 24497c478bd9Sstevel@tonic-gate bzero(&sum6, sizeof (sum6)); 24507c478bd9Sstevel@tonic-gate for (ip6 = (mib2_ipv6IfStatsEntry_t *)item->valp; 2451e11c3f44Smeem (char *)ip6 < (char *)item->valp + item->length; 24527c478bd9Sstevel@tonic-gate ip6 = (mib2_ipv6IfStatsEntry_t *)((char *)ip6 + 24537c478bd9Sstevel@tonic-gate ipv6IfStatsEntrySize)) { 24547c478bd9Sstevel@tonic-gate if (ip6->ipv6IfIndex == 0) { 24557c478bd9Sstevel@tonic-gate /* 24567c478bd9Sstevel@tonic-gate * The "unknown interface" ip6 24577c478bd9Sstevel@tonic-gate * mib. Just add to the sum. 24587c478bd9Sstevel@tonic-gate */ 24597c478bd9Sstevel@tonic-gate sum_ip6_stats(ip6, &sum6); 246078a2e113SAndy Fiddaman continue; 24617c478bd9Sstevel@tonic-gate } 24627c478bd9Sstevel@tonic-gate if (Aflag) { 24637c478bd9Sstevel@tonic-gate (void) printf("\nIPv6 for %s\n", 2464e11c3f44Smeem ifindex2str(ip6->ipv6IfIndex, 2465e11c3f44Smeem ifname)); 24667c478bd9Sstevel@tonic-gate print_ip6_stats(ip6); 24677c478bd9Sstevel@tonic-gate } 24687c478bd9Sstevel@tonic-gate sum_ip6_stats(ip6, &sum6); 246978a2e113SAndy Fiddaman } 24707c478bd9Sstevel@tonic-gate (void) fputs("\nIPv6", stdout); 24717c478bd9Sstevel@tonic-gate print_ip6_stats(&sum6); 24727c478bd9Sstevel@tonic-gate break; 24737c478bd9Sstevel@tonic-gate } 24747c478bd9Sstevel@tonic-gate case MIB2_ICMP6: { 24757c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t *icmp6; 24767c478bd9Sstevel@tonic-gate mib2_ipv6IfIcmpEntry_t sum6; 24777c478bd9Sstevel@tonic-gate 24787c478bd9Sstevel@tonic-gate if (!(protocol_selected(IPPROTO_ICMPV6)) || 24797c478bd9Sstevel@tonic-gate !(family_selected(AF_INET6))) 24807c478bd9Sstevel@tonic-gate break; 24817c478bd9Sstevel@tonic-gate bzero(&sum6, sizeof (sum6)); 2482e11c3f44Smeem for (icmp6 = (mib2_ipv6IfIcmpEntry_t *)item->valp; 2483e11c3f44Smeem (char *)icmp6 < (char *)item->valp + item->length; 2484e11c3f44Smeem icmp6 = (void *)((char *)icmp6 + 2485e11c3f44Smeem ipv6IfIcmpEntrySize)) { 24867c478bd9Sstevel@tonic-gate if (icmp6->ipv6IfIcmpIfIndex == 0) { 24877c478bd9Sstevel@tonic-gate /* 24887c478bd9Sstevel@tonic-gate * The "unknown interface" icmp6 24897c478bd9Sstevel@tonic-gate * mib. Just add to the sum. 24907c478bd9Sstevel@tonic-gate */ 24917c478bd9Sstevel@tonic-gate sum_icmp6_stats(icmp6, &sum6); 249278a2e113SAndy Fiddaman continue; 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate if (Aflag) { 2495e11c3f44Smeem (void) printf("\nICMPv6 for %s\n", 2496e11c3f44Smeem ifindex2str( 2497e11c3f44Smeem icmp6->ipv6IfIcmpIfIndex, ifname)); 24987c478bd9Sstevel@tonic-gate print_icmp6_stats(icmp6); 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate sum_icmp6_stats(icmp6, &sum6); 250178a2e113SAndy Fiddaman } 25027c478bd9Sstevel@tonic-gate (void) fputs("\nICMPv6", stdout); 25037c478bd9Sstevel@tonic-gate print_icmp6_stats(&sum6); 25047c478bd9Sstevel@tonic-gate break; 25057c478bd9Sstevel@tonic-gate } 25067c478bd9Sstevel@tonic-gate case MIB2_TCP: { 25077c478bd9Sstevel@tonic-gate mib2_tcp_t *tcp = (mib2_tcp_t *)item->valp; 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_TCP) && 25107c478bd9Sstevel@tonic-gate (family_selected(AF_INET) || 25117c478bd9Sstevel@tonic-gate family_selected(AF_INET6))) { 25127c478bd9Sstevel@tonic-gate (void) fputs("\nTCP", stdout); 25137c478bd9Sstevel@tonic-gate print_tcp_stats(tcp); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate break; 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate case MIB2_UDP: { 25187c478bd9Sstevel@tonic-gate mib2_udp_t *udp = (mib2_udp_t *)item->valp; 25197c478bd9Sstevel@tonic-gate 25207c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_UDP) && 25217c478bd9Sstevel@tonic-gate (family_selected(AF_INET) || 25227c478bd9Sstevel@tonic-gate family_selected(AF_INET6))) { 25237c478bd9Sstevel@tonic-gate (void) fputs("\nUDP", stdout); 25247c478bd9Sstevel@tonic-gate print_udp_stats(udp); 25257c478bd9Sstevel@tonic-gate } 25267c478bd9Sstevel@tonic-gate break; 25277c478bd9Sstevel@tonic-gate } 25287c478bd9Sstevel@tonic-gate case MIB2_SCTP: { 25297c478bd9Sstevel@tonic-gate mib2_sctp_t *sctp = (mib2_sctp_t *)item->valp; 25307c478bd9Sstevel@tonic-gate 25317c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_SCTP) && 25327c478bd9Sstevel@tonic-gate (family_selected(AF_INET) || 25337c478bd9Sstevel@tonic-gate family_selected(AF_INET6))) { 25347c478bd9Sstevel@tonic-gate (void) fputs("\nSCTP", stdout); 25357c478bd9Sstevel@tonic-gate print_sctp_stats(sctp); 25367c478bd9Sstevel@tonic-gate } 25377c478bd9Sstevel@tonic-gate break; 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate case EXPER_RAWIP: { 25407c478bd9Sstevel@tonic-gate mib2_rawip_t *rawip = 25417c478bd9Sstevel@tonic-gate (mib2_rawip_t *)item->valp; 25427c478bd9Sstevel@tonic-gate 25437c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_RAW) && 25447c478bd9Sstevel@tonic-gate (family_selected(AF_INET) || 25457c478bd9Sstevel@tonic-gate family_selected(AF_INET6))) { 25467c478bd9Sstevel@tonic-gate (void) fputs("\nRAWIP", stdout); 25477c478bd9Sstevel@tonic-gate print_rawip_stats(rawip); 25487c478bd9Sstevel@tonic-gate } 25497c478bd9Sstevel@tonic-gate break; 25507c478bd9Sstevel@tonic-gate } 25517c478bd9Sstevel@tonic-gate case EXPER_IGMP: { 25527c478bd9Sstevel@tonic-gate struct igmpstat *igps = 25537c478bd9Sstevel@tonic-gate (struct igmpstat *)item->valp; 25547c478bd9Sstevel@tonic-gate 25557c478bd9Sstevel@tonic-gate if (protocol_selected(IPPROTO_IGMP) && 25567c478bd9Sstevel@tonic-gate (family_selected(AF_INET))) { 25577c478bd9Sstevel@tonic-gate (void) fputs("\nIGMP:\n", stdout); 25587c478bd9Sstevel@tonic-gate print_igmp_stats(igps); 25597c478bd9Sstevel@tonic-gate } 25607c478bd9Sstevel@tonic-gate break; 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate } 256378a2e113SAndy Fiddaman } 25647c478bd9Sstevel@tonic-gate (void) putchar('\n'); 25657c478bd9Sstevel@tonic-gate (void) fflush(stdout); 25667c478bd9Sstevel@tonic-gate } 25677c478bd9Sstevel@tonic-gate 25687c478bd9Sstevel@tonic-gate static void 25697c478bd9Sstevel@tonic-gate print_ip_stats(mib2_ip_t *ip) 25707c478bd9Sstevel@tonic-gate { 25717c478bd9Sstevel@tonic-gate prval_init(); 25727c478bd9Sstevel@tonic-gate pr_int_val("ipForwarding", ip->ipForwarding); 25737c478bd9Sstevel@tonic-gate pr_int_val("ipDefaultTTL", ip->ipDefaultTTL); 25747c478bd9Sstevel@tonic-gate prval("ipInReceives", ip->ipInReceives); 25757c478bd9Sstevel@tonic-gate prval("ipInHdrErrors", ip->ipInHdrErrors); 25767c478bd9Sstevel@tonic-gate prval("ipInAddrErrors", ip->ipInAddrErrors); 25777c478bd9Sstevel@tonic-gate prval("ipInCksumErrs", ip->ipInCksumErrs); 25787c478bd9Sstevel@tonic-gate prval("ipForwDatagrams", ip->ipForwDatagrams); 25797c478bd9Sstevel@tonic-gate prval("ipForwProhibits", ip->ipForwProhibits); 25807c478bd9Sstevel@tonic-gate prval("ipInUnknownProtos", ip->ipInUnknownProtos); 25817c478bd9Sstevel@tonic-gate prval("ipInDiscards", ip->ipInDiscards); 25827c478bd9Sstevel@tonic-gate prval("ipInDelivers", ip->ipInDelivers); 25837c478bd9Sstevel@tonic-gate prval("ipOutRequests", ip->ipOutRequests); 25847c478bd9Sstevel@tonic-gate prval("ipOutDiscards", ip->ipOutDiscards); 25857c478bd9Sstevel@tonic-gate prval("ipOutNoRoutes", ip->ipOutNoRoutes); 25867c478bd9Sstevel@tonic-gate pr_int_val("ipReasmTimeout", ip->ipReasmTimeout); 25877c478bd9Sstevel@tonic-gate prval("ipReasmReqds", ip->ipReasmReqds); 25887c478bd9Sstevel@tonic-gate prval("ipReasmOKs", ip->ipReasmOKs); 25897c478bd9Sstevel@tonic-gate prval("ipReasmFails", ip->ipReasmFails); 25907c478bd9Sstevel@tonic-gate prval("ipReasmDuplicates", ip->ipReasmDuplicates); 25917c478bd9Sstevel@tonic-gate prval("ipReasmPartDups", ip->ipReasmPartDups); 25927c478bd9Sstevel@tonic-gate prval("ipFragOKs", ip->ipFragOKs); 25937c478bd9Sstevel@tonic-gate prval("ipFragFails", ip->ipFragFails); 25947c478bd9Sstevel@tonic-gate prval("ipFragCreates", ip->ipFragCreates); 25957c478bd9Sstevel@tonic-gate prval("ipRoutingDiscards", ip->ipRoutingDiscards); 25967c478bd9Sstevel@tonic-gate 25977c478bd9Sstevel@tonic-gate prval("tcpInErrs", ip->tcpInErrs); 25987c478bd9Sstevel@tonic-gate prval("udpNoPorts", ip->udpNoPorts); 25997c478bd9Sstevel@tonic-gate prval("udpInCksumErrs", ip->udpInCksumErrs); 26007c478bd9Sstevel@tonic-gate prval("udpInOverflows", ip->udpInOverflows); 26017c478bd9Sstevel@tonic-gate prval("rawipInOverflows", ip->rawipInOverflows); 26027c478bd9Sstevel@tonic-gate prval("ipsecInSucceeded", ip->ipsecInSucceeded); 26037c478bd9Sstevel@tonic-gate prval("ipsecInFailed", ip->ipsecInFailed); 26047c478bd9Sstevel@tonic-gate prval("ipInIPv6", ip->ipInIPv6); 26057c478bd9Sstevel@tonic-gate prval("ipOutIPv6", ip->ipOutIPv6); 26067c478bd9Sstevel@tonic-gate prval("ipOutSwitchIPv6", ip->ipOutSwitchIPv6); 26077c478bd9Sstevel@tonic-gate prval_end(); 26087c478bd9Sstevel@tonic-gate } 26097c478bd9Sstevel@tonic-gate 26107c478bd9Sstevel@tonic-gate static void 26117c478bd9Sstevel@tonic-gate print_icmp_stats(mib2_icmp_t *icmp) 26127c478bd9Sstevel@tonic-gate { 26137c478bd9Sstevel@tonic-gate prval_init(); 26147c478bd9Sstevel@tonic-gate prval("icmpInMsgs", icmp->icmpInMsgs); 26157c478bd9Sstevel@tonic-gate prval("icmpInErrors", icmp->icmpInErrors); 26167c478bd9Sstevel@tonic-gate prval("icmpInCksumErrs", icmp->icmpInCksumErrs); 26177c478bd9Sstevel@tonic-gate prval("icmpInUnknowns", icmp->icmpInUnknowns); 26187c478bd9Sstevel@tonic-gate prval("icmpInDestUnreachs", icmp->icmpInDestUnreachs); 26197c478bd9Sstevel@tonic-gate prval("icmpInTimeExcds", icmp->icmpInTimeExcds); 26207c478bd9Sstevel@tonic-gate prval("icmpInParmProbs", icmp->icmpInParmProbs); 26217c478bd9Sstevel@tonic-gate prval("icmpInSrcQuenchs", icmp->icmpInSrcQuenchs); 26227c478bd9Sstevel@tonic-gate prval("icmpInRedirects", icmp->icmpInRedirects); 26237c478bd9Sstevel@tonic-gate prval("icmpInBadRedirects", icmp->icmpInBadRedirects); 26247c478bd9Sstevel@tonic-gate prval("icmpInEchos", icmp->icmpInEchos); 26257c478bd9Sstevel@tonic-gate prval("icmpInEchoReps", icmp->icmpInEchoReps); 26267c478bd9Sstevel@tonic-gate prval("icmpInTimestamps", icmp->icmpInTimestamps); 26277c478bd9Sstevel@tonic-gate prval("icmpInTimestampReps", icmp->icmpInTimestampReps); 26287c478bd9Sstevel@tonic-gate prval("icmpInAddrMasks", icmp->icmpInAddrMasks); 26297c478bd9Sstevel@tonic-gate prval("icmpInAddrMaskReps", icmp->icmpInAddrMaskReps); 26307c478bd9Sstevel@tonic-gate prval("icmpInFragNeeded", icmp->icmpInFragNeeded); 26317c478bd9Sstevel@tonic-gate prval("icmpOutMsgs", icmp->icmpOutMsgs); 26327c478bd9Sstevel@tonic-gate prval("icmpOutDrops", icmp->icmpOutDrops); 26337c478bd9Sstevel@tonic-gate prval("icmpOutErrors", icmp->icmpOutErrors); 26347c478bd9Sstevel@tonic-gate prval("icmpOutDestUnreachs", icmp->icmpOutDestUnreachs); 26357c478bd9Sstevel@tonic-gate prval("icmpOutTimeExcds", icmp->icmpOutTimeExcds); 26367c478bd9Sstevel@tonic-gate prval("icmpOutParmProbs", icmp->icmpOutParmProbs); 26377c478bd9Sstevel@tonic-gate prval("icmpOutSrcQuenchs", icmp->icmpOutSrcQuenchs); 26387c478bd9Sstevel@tonic-gate prval("icmpOutRedirects", icmp->icmpOutRedirects); 26397c478bd9Sstevel@tonic-gate prval("icmpOutEchos", icmp->icmpOutEchos); 26407c478bd9Sstevel@tonic-gate prval("icmpOutEchoReps", icmp->icmpOutEchoReps); 26417c478bd9Sstevel@tonic-gate prval("icmpOutTimestamps", icmp->icmpOutTimestamps); 26427c478bd9Sstevel@tonic-gate prval("icmpOutTimestampReps", icmp->icmpOutTimestampReps); 26437c478bd9Sstevel@tonic-gate prval("icmpOutAddrMasks", icmp->icmpOutAddrMasks); 26447c478bd9Sstevel@tonic-gate prval("icmpOutAddrMaskReps", icmp->icmpOutAddrMaskReps); 26457c478bd9Sstevel@tonic-gate prval("icmpOutFragNeeded", icmp->icmpOutFragNeeded); 26467c478bd9Sstevel@tonic-gate prval("icmpInOverflows", icmp->icmpInOverflows); 26477c478bd9Sstevel@tonic-gate prval_end(); 26487c478bd9Sstevel@tonic-gate } 26497c478bd9Sstevel@tonic-gate 26507c478bd9Sstevel@tonic-gate static void 26517c478bd9Sstevel@tonic-gate print_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6) 26527c478bd9Sstevel@tonic-gate { 26537c478bd9Sstevel@tonic-gate prval_init(); 26547c478bd9Sstevel@tonic-gate prval("ipv6Forwarding", ip6->ipv6Forwarding); 26557c478bd9Sstevel@tonic-gate prval("ipv6DefaultHopLimit", ip6->ipv6DefaultHopLimit); 26567c478bd9Sstevel@tonic-gate 26577c478bd9Sstevel@tonic-gate prval("ipv6InReceives", ip6->ipv6InReceives); 26587c478bd9Sstevel@tonic-gate prval("ipv6InHdrErrors", ip6->ipv6InHdrErrors); 26597c478bd9Sstevel@tonic-gate prval("ipv6InTooBigErrors", ip6->ipv6InTooBigErrors); 26607c478bd9Sstevel@tonic-gate prval("ipv6InNoRoutes", ip6->ipv6InNoRoutes); 26617c478bd9Sstevel@tonic-gate prval("ipv6InAddrErrors", ip6->ipv6InAddrErrors); 26627c478bd9Sstevel@tonic-gate prval("ipv6InUnknownProtos", ip6->ipv6InUnknownProtos); 26637c478bd9Sstevel@tonic-gate prval("ipv6InTruncatedPkts", ip6->ipv6InTruncatedPkts); 26647c478bd9Sstevel@tonic-gate prval("ipv6InDiscards", ip6->ipv6InDiscards); 26657c478bd9Sstevel@tonic-gate prval("ipv6InDelivers", ip6->ipv6InDelivers); 26667c478bd9Sstevel@tonic-gate prval("ipv6OutForwDatagrams", ip6->ipv6OutForwDatagrams); 26677c478bd9Sstevel@tonic-gate prval("ipv6OutRequests", ip6->ipv6OutRequests); 26687c478bd9Sstevel@tonic-gate prval("ipv6OutDiscards", ip6->ipv6OutDiscards); 26697c478bd9Sstevel@tonic-gate prval("ipv6OutNoRoutes", ip6->ipv6OutNoRoutes); 26707c478bd9Sstevel@tonic-gate prval("ipv6OutFragOKs", ip6->ipv6OutFragOKs); 26717c478bd9Sstevel@tonic-gate prval("ipv6OutFragFails", ip6->ipv6OutFragFails); 26727c478bd9Sstevel@tonic-gate prval("ipv6OutFragCreates", ip6->ipv6OutFragCreates); 26737c478bd9Sstevel@tonic-gate prval("ipv6ReasmReqds", ip6->ipv6ReasmReqds); 26747c478bd9Sstevel@tonic-gate prval("ipv6ReasmOKs", ip6->ipv6ReasmOKs); 26757c478bd9Sstevel@tonic-gate prval("ipv6ReasmFails", ip6->ipv6ReasmFails); 26767c478bd9Sstevel@tonic-gate prval("ipv6InMcastPkts", ip6->ipv6InMcastPkts); 26777c478bd9Sstevel@tonic-gate prval("ipv6OutMcastPkts", ip6->ipv6OutMcastPkts); 26787c478bd9Sstevel@tonic-gate prval("ipv6ReasmDuplicates", ip6->ipv6ReasmDuplicates); 26797c478bd9Sstevel@tonic-gate prval("ipv6ReasmPartDups", ip6->ipv6ReasmPartDups); 26807c478bd9Sstevel@tonic-gate prval("ipv6ForwProhibits", ip6->ipv6ForwProhibits); 26817c478bd9Sstevel@tonic-gate prval("udpInCksumErrs", ip6->udpInCksumErrs); 26827c478bd9Sstevel@tonic-gate prval("udpInOverflows", ip6->udpInOverflows); 26837c478bd9Sstevel@tonic-gate prval("rawipInOverflows", ip6->rawipInOverflows); 26847c478bd9Sstevel@tonic-gate prval("ipv6InIPv4", ip6->ipv6InIPv4); 26857c478bd9Sstevel@tonic-gate prval("ipv6OutIPv4", ip6->ipv6OutIPv4); 26867c478bd9Sstevel@tonic-gate prval("ipv6OutSwitchIPv4", ip6->ipv6OutSwitchIPv4); 26877c478bd9Sstevel@tonic-gate prval_end(); 26887c478bd9Sstevel@tonic-gate } 26897c478bd9Sstevel@tonic-gate 26907c478bd9Sstevel@tonic-gate static void 26917c478bd9Sstevel@tonic-gate print_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6) 26927c478bd9Sstevel@tonic-gate { 26937c478bd9Sstevel@tonic-gate prval_init(); 26947c478bd9Sstevel@tonic-gate prval("icmp6InMsgs", icmp6->ipv6IfIcmpInMsgs); 26957c478bd9Sstevel@tonic-gate prval("icmp6InErrors", icmp6->ipv6IfIcmpInErrors); 26967c478bd9Sstevel@tonic-gate prval("icmp6InDestUnreachs", icmp6->ipv6IfIcmpInDestUnreachs); 26977c478bd9Sstevel@tonic-gate prval("icmp6InAdminProhibs", icmp6->ipv6IfIcmpInAdminProhibs); 26987c478bd9Sstevel@tonic-gate prval("icmp6InTimeExcds", icmp6->ipv6IfIcmpInTimeExcds); 26997c478bd9Sstevel@tonic-gate prval("icmp6InParmProblems", icmp6->ipv6IfIcmpInParmProblems); 27007c478bd9Sstevel@tonic-gate prval("icmp6InPktTooBigs", icmp6->ipv6IfIcmpInPktTooBigs); 27017c478bd9Sstevel@tonic-gate prval("icmp6InEchos", icmp6->ipv6IfIcmpInEchos); 27027c478bd9Sstevel@tonic-gate prval("icmp6InEchoReplies", icmp6->ipv6IfIcmpInEchoReplies); 27037c478bd9Sstevel@tonic-gate prval("icmp6InRouterSols", icmp6->ipv6IfIcmpInRouterSolicits); 27047c478bd9Sstevel@tonic-gate prval("icmp6InRouterAds", 27057c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInRouterAdvertisements); 27067c478bd9Sstevel@tonic-gate prval("icmp6InNeighborSols", icmp6->ipv6IfIcmpInNeighborSolicits); 27077c478bd9Sstevel@tonic-gate prval("icmp6InNeighborAds", 27087c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInNeighborAdvertisements); 27097c478bd9Sstevel@tonic-gate prval("icmp6InRedirects", icmp6->ipv6IfIcmpInRedirects); 27107c478bd9Sstevel@tonic-gate prval("icmp6InBadRedirects", icmp6->ipv6IfIcmpInBadRedirects); 27117c478bd9Sstevel@tonic-gate prval("icmp6InGroupQueries", icmp6->ipv6IfIcmpInGroupMembQueries); 27127c478bd9Sstevel@tonic-gate prval("icmp6InGroupResps", icmp6->ipv6IfIcmpInGroupMembResponses); 27137c478bd9Sstevel@tonic-gate prval("icmp6InGroupReds", icmp6->ipv6IfIcmpInGroupMembReductions); 27147c478bd9Sstevel@tonic-gate prval("icmp6InOverflows", icmp6->ipv6IfIcmpInOverflows); 27157c478bd9Sstevel@tonic-gate prval_end(); 27167c478bd9Sstevel@tonic-gate prval_init(); 27177c478bd9Sstevel@tonic-gate prval("icmp6OutMsgs", icmp6->ipv6IfIcmpOutMsgs); 27187c478bd9Sstevel@tonic-gate prval("icmp6OutErrors", icmp6->ipv6IfIcmpOutErrors); 27197c478bd9Sstevel@tonic-gate prval("icmp6OutDestUnreachs", icmp6->ipv6IfIcmpOutDestUnreachs); 27207c478bd9Sstevel@tonic-gate prval("icmp6OutAdminProhibs", icmp6->ipv6IfIcmpOutAdminProhibs); 27217c478bd9Sstevel@tonic-gate prval("icmp6OutTimeExcds", icmp6->ipv6IfIcmpOutTimeExcds); 27227c478bd9Sstevel@tonic-gate prval("icmp6OutParmProblems", icmp6->ipv6IfIcmpOutParmProblems); 27237c478bd9Sstevel@tonic-gate prval("icmp6OutPktTooBigs", icmp6->ipv6IfIcmpOutPktTooBigs); 27247c478bd9Sstevel@tonic-gate prval("icmp6OutEchos", icmp6->ipv6IfIcmpOutEchos); 27257c478bd9Sstevel@tonic-gate prval("icmp6OutEchoReplies", icmp6->ipv6IfIcmpOutEchoReplies); 27267c478bd9Sstevel@tonic-gate prval("icmp6OutRouterSols", icmp6->ipv6IfIcmpOutRouterSolicits); 27277c478bd9Sstevel@tonic-gate prval("icmp6OutRouterAds", 27287c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutRouterAdvertisements); 27297c478bd9Sstevel@tonic-gate prval("icmp6OutNeighborSols", icmp6->ipv6IfIcmpOutNeighborSolicits); 27307c478bd9Sstevel@tonic-gate prval("icmp6OutNeighborAds", 27317c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutNeighborAdvertisements); 27327c478bd9Sstevel@tonic-gate prval("icmp6OutRedirects", icmp6->ipv6IfIcmpOutRedirects); 27337c478bd9Sstevel@tonic-gate prval("icmp6OutGroupQueries", icmp6->ipv6IfIcmpOutGroupMembQueries); 27347c478bd9Sstevel@tonic-gate prval("icmp6OutGroupResps", 27357c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutGroupMembResponses); 27367c478bd9Sstevel@tonic-gate prval("icmp6OutGroupReds", 27377c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutGroupMembReductions); 27387c478bd9Sstevel@tonic-gate prval_end(); 27397c478bd9Sstevel@tonic-gate } 27407c478bd9Sstevel@tonic-gate 27417c478bd9Sstevel@tonic-gate static void 27427c478bd9Sstevel@tonic-gate print_sctp_stats(mib2_sctp_t *sctp) 27437c478bd9Sstevel@tonic-gate { 27447c478bd9Sstevel@tonic-gate prval_init(); 27457c478bd9Sstevel@tonic-gate pr_sctp_rtoalgo("sctpRtoAlgorithm", sctp->sctpRtoAlgorithm); 27467c478bd9Sstevel@tonic-gate prval("sctpRtoMin", sctp->sctpRtoMin); 27477c478bd9Sstevel@tonic-gate prval("sctpRtoMax", sctp->sctpRtoMax); 27487c478bd9Sstevel@tonic-gate prval("sctpRtoInitial", sctp->sctpRtoInitial); 27497c478bd9Sstevel@tonic-gate pr_int_val("sctpMaxAssocs", sctp->sctpMaxAssocs); 27507c478bd9Sstevel@tonic-gate prval("sctpValCookieLife", sctp->sctpValCookieLife); 27517c478bd9Sstevel@tonic-gate prval("sctpMaxInitRetr", sctp->sctpMaxInitRetr); 27527c478bd9Sstevel@tonic-gate prval("sctpCurrEstab", sctp->sctpCurrEstab); 27537c478bd9Sstevel@tonic-gate prval("sctpActiveEstab", sctp->sctpActiveEstab); 27547c478bd9Sstevel@tonic-gate prval("sctpPassiveEstab", sctp->sctpPassiveEstab); 27557c478bd9Sstevel@tonic-gate prval("sctpAborted", sctp->sctpAborted); 27567c478bd9Sstevel@tonic-gate prval("sctpShutdowns", sctp->sctpShutdowns); 27577c478bd9Sstevel@tonic-gate prval("sctpOutOfBlue", sctp->sctpOutOfBlue); 27587c478bd9Sstevel@tonic-gate prval("sctpChecksumError", sctp->sctpChecksumError); 27597c478bd9Sstevel@tonic-gate prval64("sctpOutCtrlChunks", sctp->sctpOutCtrlChunks); 27607c478bd9Sstevel@tonic-gate prval64("sctpOutOrderChunks", sctp->sctpOutOrderChunks); 27617c478bd9Sstevel@tonic-gate prval64("sctpOutUnorderChunks", sctp->sctpOutUnorderChunks); 27627c478bd9Sstevel@tonic-gate prval64("sctpRetransChunks", sctp->sctpRetransChunks); 27637c478bd9Sstevel@tonic-gate prval("sctpOutAck", sctp->sctpOutAck); 27647c478bd9Sstevel@tonic-gate prval("sctpOutAckDelayed", sctp->sctpOutAckDelayed); 27657c478bd9Sstevel@tonic-gate prval("sctpOutWinUpdate", sctp->sctpOutWinUpdate); 27667c478bd9Sstevel@tonic-gate prval("sctpOutFastRetrans", sctp->sctpOutFastRetrans); 27677c478bd9Sstevel@tonic-gate prval("sctpOutWinProbe", sctp->sctpOutWinProbe); 27687c478bd9Sstevel@tonic-gate prval64("sctpInCtrlChunks", sctp->sctpInCtrlChunks); 27697c478bd9Sstevel@tonic-gate prval64("sctpInOrderChunks", sctp->sctpInOrderChunks); 27707c478bd9Sstevel@tonic-gate prval64("sctpInUnorderChunks", sctp->sctpInUnorderChunks); 27717c478bd9Sstevel@tonic-gate prval("sctpInAck", sctp->sctpInAck); 27727c478bd9Sstevel@tonic-gate prval("sctpInDupAck", sctp->sctpInDupAck); 27737c478bd9Sstevel@tonic-gate prval("sctpInAckUnsent", sctp->sctpInAckUnsent); 27747c478bd9Sstevel@tonic-gate prval64("sctpFragUsrMsgs", sctp->sctpFragUsrMsgs); 27757c478bd9Sstevel@tonic-gate prval64("sctpReasmUsrMsgs", sctp->sctpReasmUsrMsgs); 27767c478bd9Sstevel@tonic-gate prval64("sctpOutSCTPPkts", sctp->sctpOutSCTPPkts); 27777c478bd9Sstevel@tonic-gate prval64("sctpInSCTPPkts", sctp->sctpInSCTPPkts); 27787c478bd9Sstevel@tonic-gate prval("sctpInInvalidCookie", sctp->sctpInInvalidCookie); 27797c478bd9Sstevel@tonic-gate prval("sctpTimRetrans", sctp->sctpTimRetrans); 27807c478bd9Sstevel@tonic-gate prval("sctpTimRetransDrop", sctp->sctpTimRetransDrop); 27817c478bd9Sstevel@tonic-gate prval("sctpTimHearBeatProbe", sctp->sctpTimHeartBeatProbe); 27827c478bd9Sstevel@tonic-gate prval("sctpTimHearBeatDrop", sctp->sctpTimHeartBeatDrop); 27837c478bd9Sstevel@tonic-gate prval("sctpListenDrop", sctp->sctpListenDrop); 27847c478bd9Sstevel@tonic-gate prval("sctpInClosed", sctp->sctpInClosed); 27857c478bd9Sstevel@tonic-gate prval_end(); 27867c478bd9Sstevel@tonic-gate } 27877c478bd9Sstevel@tonic-gate 27887c478bd9Sstevel@tonic-gate static void 27897c478bd9Sstevel@tonic-gate print_tcp_stats(mib2_tcp_t *tcp) 27907c478bd9Sstevel@tonic-gate { 27917c478bd9Sstevel@tonic-gate prval_init(); 27927c478bd9Sstevel@tonic-gate pr_int_val("tcpRtoAlgorithm", tcp->tcpRtoAlgorithm); 27937c478bd9Sstevel@tonic-gate pr_int_val("tcpRtoMin", tcp->tcpRtoMin); 27947c478bd9Sstevel@tonic-gate pr_int_val("tcpRtoMax", tcp->tcpRtoMax); 27957c478bd9Sstevel@tonic-gate pr_int_val("tcpMaxConn", tcp->tcpMaxConn); 27967c478bd9Sstevel@tonic-gate prval("tcpActiveOpens", tcp->tcpActiveOpens); 27977c478bd9Sstevel@tonic-gate prval("tcpPassiveOpens", tcp->tcpPassiveOpens); 27987c478bd9Sstevel@tonic-gate prval("tcpAttemptFails", tcp->tcpAttemptFails); 27997c478bd9Sstevel@tonic-gate prval("tcpEstabResets", tcp->tcpEstabResets); 28007c478bd9Sstevel@tonic-gate prval("tcpCurrEstab", tcp->tcpCurrEstab); 28013173664eSapersson prval64("tcpOutSegs", tcp->tcpHCOutSegs); 28027c478bd9Sstevel@tonic-gate prval("tcpOutDataSegs", tcp->tcpOutDataSegs); 28037c478bd9Sstevel@tonic-gate prval("tcpOutDataBytes", tcp->tcpOutDataBytes); 28047c478bd9Sstevel@tonic-gate prval("tcpRetransSegs", tcp->tcpRetransSegs); 28057c478bd9Sstevel@tonic-gate prval("tcpRetransBytes", tcp->tcpRetransBytes); 28067c478bd9Sstevel@tonic-gate prval("tcpOutAck", tcp->tcpOutAck); 28077c478bd9Sstevel@tonic-gate prval("tcpOutAckDelayed", tcp->tcpOutAckDelayed); 28087c478bd9Sstevel@tonic-gate prval("tcpOutUrg", tcp->tcpOutUrg); 28097c478bd9Sstevel@tonic-gate prval("tcpOutWinUpdate", tcp->tcpOutWinUpdate); 28107c478bd9Sstevel@tonic-gate prval("tcpOutWinProbe", tcp->tcpOutWinProbe); 28117c478bd9Sstevel@tonic-gate prval("tcpOutControl", tcp->tcpOutControl); 28127c478bd9Sstevel@tonic-gate prval("tcpOutRsts", tcp->tcpOutRsts); 28137c478bd9Sstevel@tonic-gate prval("tcpOutFastRetrans", tcp->tcpOutFastRetrans); 28143173664eSapersson prval64("tcpInSegs", tcp->tcpHCInSegs); 28157c478bd9Sstevel@tonic-gate prval_end(); 28167c478bd9Sstevel@tonic-gate prval("tcpInAckSegs", tcp->tcpInAckSegs); 28177c478bd9Sstevel@tonic-gate prval("tcpInAckBytes", tcp->tcpInAckBytes); 28187c478bd9Sstevel@tonic-gate prval("tcpInDupAck", tcp->tcpInDupAck); 28197c478bd9Sstevel@tonic-gate prval("tcpInAckUnsent", tcp->tcpInAckUnsent); 28207c478bd9Sstevel@tonic-gate prval("tcpInInorderSegs", tcp->tcpInDataInorderSegs); 28217c478bd9Sstevel@tonic-gate prval("tcpInInorderBytes", tcp->tcpInDataInorderBytes); 28227c478bd9Sstevel@tonic-gate prval("tcpInUnorderSegs", tcp->tcpInDataUnorderSegs); 28237c478bd9Sstevel@tonic-gate prval("tcpInUnorderBytes", tcp->tcpInDataUnorderBytes); 28247c478bd9Sstevel@tonic-gate prval("tcpInDupSegs", tcp->tcpInDataDupSegs); 28257c478bd9Sstevel@tonic-gate prval("tcpInDupBytes", tcp->tcpInDataDupBytes); 28267c478bd9Sstevel@tonic-gate prval("tcpInPartDupSegs", tcp->tcpInDataPartDupSegs); 28277c478bd9Sstevel@tonic-gate prval("tcpInPartDupBytes", tcp->tcpInDataPartDupBytes); 28287c478bd9Sstevel@tonic-gate prval("tcpInPastWinSegs", tcp->tcpInDataPastWinSegs); 28297c478bd9Sstevel@tonic-gate prval("tcpInPastWinBytes", tcp->tcpInDataPastWinBytes); 28307c478bd9Sstevel@tonic-gate prval("tcpInWinProbe", tcp->tcpInWinProbe); 28317c478bd9Sstevel@tonic-gate prval("tcpInWinUpdate", tcp->tcpInWinUpdate); 28327c478bd9Sstevel@tonic-gate prval("tcpInClosed", tcp->tcpInClosed); 28337c478bd9Sstevel@tonic-gate prval("tcpRttNoUpdate", tcp->tcpRttNoUpdate); 28347c478bd9Sstevel@tonic-gate prval("tcpRttUpdate", tcp->tcpRttUpdate); 28357c478bd9Sstevel@tonic-gate prval("tcpTimRetrans", tcp->tcpTimRetrans); 28367c478bd9Sstevel@tonic-gate prval("tcpTimRetransDrop", tcp->tcpTimRetransDrop); 28377c478bd9Sstevel@tonic-gate prval("tcpTimKeepalive", tcp->tcpTimKeepalive); 28387c478bd9Sstevel@tonic-gate prval("tcpTimKeepaliveProbe", tcp->tcpTimKeepaliveProbe); 28397c478bd9Sstevel@tonic-gate prval("tcpTimKeepaliveDrop", tcp->tcpTimKeepaliveDrop); 28407c478bd9Sstevel@tonic-gate prval("tcpListenDrop", tcp->tcpListenDrop); 28417c478bd9Sstevel@tonic-gate prval("tcpListenDropQ0", tcp->tcpListenDropQ0); 28427c478bd9Sstevel@tonic-gate prval("tcpHalfOpenDrop", tcp->tcpHalfOpenDrop); 28437c478bd9Sstevel@tonic-gate prval("tcpOutSackRetrans", tcp->tcpOutSackRetransSegs); 28447c478bd9Sstevel@tonic-gate prval_end(); 28457c478bd9Sstevel@tonic-gate 28467c478bd9Sstevel@tonic-gate } 28477c478bd9Sstevel@tonic-gate 28487c478bd9Sstevel@tonic-gate static void 28497c478bd9Sstevel@tonic-gate print_udp_stats(mib2_udp_t *udp) 28507c478bd9Sstevel@tonic-gate { 28517c478bd9Sstevel@tonic-gate prval_init(); 28523173664eSapersson prval64("udpInDatagrams", udp->udpHCInDatagrams); 28537c478bd9Sstevel@tonic-gate prval("udpInErrors", udp->udpInErrors); 28543173664eSapersson prval64("udpOutDatagrams", udp->udpHCOutDatagrams); 28557c478bd9Sstevel@tonic-gate prval("udpOutErrors", udp->udpOutErrors); 28567c478bd9Sstevel@tonic-gate prval_end(); 28577c478bd9Sstevel@tonic-gate } 28587c478bd9Sstevel@tonic-gate 28597c478bd9Sstevel@tonic-gate static void 28607c478bd9Sstevel@tonic-gate print_rawip_stats(mib2_rawip_t *rawip) 28617c478bd9Sstevel@tonic-gate { 28627c478bd9Sstevel@tonic-gate prval_init(); 28637c478bd9Sstevel@tonic-gate prval("rawipInDatagrams", rawip->rawipInDatagrams); 28647c478bd9Sstevel@tonic-gate prval("rawipInErrors", rawip->rawipInErrors); 28657c478bd9Sstevel@tonic-gate prval("rawipInCksumErrs", rawip->rawipInCksumErrs); 28667c478bd9Sstevel@tonic-gate prval("rawipOutDatagrams", rawip->rawipOutDatagrams); 28677c478bd9Sstevel@tonic-gate prval("rawipOutErrors", rawip->rawipOutErrors); 28687c478bd9Sstevel@tonic-gate prval_end(); 28697c478bd9Sstevel@tonic-gate } 28707c478bd9Sstevel@tonic-gate 28717c478bd9Sstevel@tonic-gate void 28727c478bd9Sstevel@tonic-gate print_igmp_stats(struct igmpstat *igps) 28737c478bd9Sstevel@tonic-gate { 28747c478bd9Sstevel@tonic-gate (void) printf(" %10u message%s received\n", 28757c478bd9Sstevel@tonic-gate igps->igps_rcv_total, PLURAL(igps->igps_rcv_total)); 28767c478bd9Sstevel@tonic-gate (void) printf(" %10u message%s received with too few bytes\n", 28777c478bd9Sstevel@tonic-gate igps->igps_rcv_tooshort, PLURAL(igps->igps_rcv_tooshort)); 28787c478bd9Sstevel@tonic-gate (void) printf(" %10u message%s received with bad checksum\n", 28797c478bd9Sstevel@tonic-gate igps->igps_rcv_badsum, PLURAL(igps->igps_rcv_badsum)); 28807c478bd9Sstevel@tonic-gate (void) printf(" %10u membership quer%s received\n", 28817c478bd9Sstevel@tonic-gate igps->igps_rcv_queries, PLURALY(igps->igps_rcv_queries)); 28827c478bd9Sstevel@tonic-gate (void) printf(" %10u membership quer%s received with invalid " 28837c478bd9Sstevel@tonic-gate "field(s)\n", 28847c478bd9Sstevel@tonic-gate igps->igps_rcv_badqueries, PLURALY(igps->igps_rcv_badqueries)); 28857c478bd9Sstevel@tonic-gate (void) printf(" %10u membership report%s received\n", 28867c478bd9Sstevel@tonic-gate igps->igps_rcv_reports, PLURAL(igps->igps_rcv_reports)); 28877c478bd9Sstevel@tonic-gate (void) printf(" %10u membership report%s received with invalid " 28887c478bd9Sstevel@tonic-gate "field(s)\n", 28897c478bd9Sstevel@tonic-gate igps->igps_rcv_badreports, PLURAL(igps->igps_rcv_badreports)); 28907c478bd9Sstevel@tonic-gate (void) printf(" %10u membership report%s received for groups to " 28917c478bd9Sstevel@tonic-gate "which we belong\n", 28927c478bd9Sstevel@tonic-gate igps->igps_rcv_ourreports, PLURAL(igps->igps_rcv_ourreports)); 28937c478bd9Sstevel@tonic-gate (void) printf(" %10u membership report%s sent\n", 28947c478bd9Sstevel@tonic-gate igps->igps_snd_reports, PLURAL(igps->igps_snd_reports)); 28957c478bd9Sstevel@tonic-gate } 28967c478bd9Sstevel@tonic-gate 28977c478bd9Sstevel@tonic-gate static void 28987c478bd9Sstevel@tonic-gate print_mrt_stats(struct mrtstat *mrts) 28997c478bd9Sstevel@tonic-gate { 29007c478bd9Sstevel@tonic-gate (void) puts("DVMRP multicast routing:"); 29017c478bd9Sstevel@tonic-gate (void) printf(" %10u hit%s - kernel forwarding cache hits\n", 2902e11c3f44Smeem mrts->mrts_mfc_hits, PLURAL(mrts->mrts_mfc_hits)); 29037c478bd9Sstevel@tonic-gate (void) printf(" %10u miss%s - kernel forwarding cache misses\n", 2904e11c3f44Smeem mrts->mrts_mfc_misses, PLURALES(mrts->mrts_mfc_misses)); 29057c478bd9Sstevel@tonic-gate (void) printf(" %10u packet%s potentially forwarded\n", 2906e11c3f44Smeem mrts->mrts_fwd_in, PLURAL(mrts->mrts_fwd_in)); 29077c478bd9Sstevel@tonic-gate (void) printf(" %10u packet%s actually sent out\n", 2908e11c3f44Smeem mrts->mrts_fwd_out, PLURAL(mrts->mrts_fwd_out)); 29097c478bd9Sstevel@tonic-gate (void) printf(" %10u upcall%s - upcalls made to mrouted\n", 2910e11c3f44Smeem mrts->mrts_upcalls, PLURAL(mrts->mrts_upcalls)); 29117c478bd9Sstevel@tonic-gate (void) printf(" %10u packet%s not sent out due to lack of resources\n", 2912e11c3f44Smeem mrts->mrts_fwd_drop, PLURAL(mrts->mrts_fwd_drop)); 29137c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s with malformed tunnel options\n", 2914e11c3f44Smeem mrts->mrts_bad_tunnel, PLURAL(mrts->mrts_bad_tunnel)); 29157c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s with no room for tunnel options\n", 2916e11c3f44Smeem mrts->mrts_cant_tunnel, PLURAL(mrts->mrts_cant_tunnel)); 29177c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s arrived on wrong interface\n", 2918e11c3f44Smeem mrts->mrts_wrong_if, PLURAL(mrts->mrts_wrong_if)); 29197c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped due to upcall Q overflow\n", 2920e11c3f44Smeem mrts->mrts_upq_ovflw, PLURAL(mrts->mrts_upq_ovflw)); 29217c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s cleaned up by the cache\n", 2922e11c3f44Smeem mrts->mrts_cache_cleanups, PLURAL(mrts->mrts_cache_cleanups)); 29237c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped selectively by ratelimiter\n", 2924e11c3f44Smeem mrts->mrts_drop_sel, PLURAL(mrts->mrts_drop_sel)); 29257c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - bucket Q overflow\n", 2926e11c3f44Smeem mrts->mrts_q_overflow, PLURAL(mrts->mrts_q_overflow)); 29277c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - larger than bkt size\n", 2928e11c3f44Smeem mrts->mrts_pkt2large, PLURAL(mrts->mrts_pkt2large)); 29297c478bd9Sstevel@tonic-gate (void) printf("\nPIM multicast routing:\n"); 29307c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - bad version number\n", 2931e11c3f44Smeem mrts->mrts_pim_badversion, PLURAL(mrts->mrts_pim_badversion)); 29327c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - bad checksum\n", 2933e11c3f44Smeem mrts->mrts_pim_rcv_badcsum, PLURAL(mrts->mrts_pim_rcv_badcsum)); 29347c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - bad register packets\n", 2935e11c3f44Smeem mrts->mrts_pim_badregisters, PLURAL(mrts->mrts_pim_badregisters)); 29367c478bd9Sstevel@tonic-gate (void) printf( 2937e11c3f44Smeem " %10u datagram%s potentially forwarded - register packets\n", 2938e11c3f44Smeem mrts->mrts_pim_regforwards, PLURAL(mrts->mrts_pim_regforwards)); 29397c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - register send drops\n", 2940e11c3f44Smeem mrts->mrts_pim_regsend_drops, PLURAL(mrts->mrts_pim_regsend_drops)); 29417c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - packet malformed\n", 2942e11c3f44Smeem mrts->mrts_pim_malformed, PLURAL(mrts->mrts_pim_malformed)); 29437c478bd9Sstevel@tonic-gate (void) printf(" %10u datagram%s dropped - no memory to forward\n", 2944e11c3f44Smeem mrts->mrts_pim_nomemory, PLURAL(mrts->mrts_pim_nomemory)); 29457c478bd9Sstevel@tonic-gate } 29467c478bd9Sstevel@tonic-gate 29477c478bd9Sstevel@tonic-gate static void 29487c478bd9Sstevel@tonic-gate sum_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6, mib2_ipv6IfStatsEntry_t *sum6) 29497c478bd9Sstevel@tonic-gate { 29507c478bd9Sstevel@tonic-gate /* First few are not additive */ 29517c478bd9Sstevel@tonic-gate sum6->ipv6Forwarding = ip6->ipv6Forwarding; 29527c478bd9Sstevel@tonic-gate sum6->ipv6DefaultHopLimit = ip6->ipv6DefaultHopLimit; 29537c478bd9Sstevel@tonic-gate 29547c478bd9Sstevel@tonic-gate sum6->ipv6InReceives += ip6->ipv6InReceives; 29557c478bd9Sstevel@tonic-gate sum6->ipv6InHdrErrors += ip6->ipv6InHdrErrors; 29567c478bd9Sstevel@tonic-gate sum6->ipv6InTooBigErrors += ip6->ipv6InTooBigErrors; 29577c478bd9Sstevel@tonic-gate sum6->ipv6InNoRoutes += ip6->ipv6InNoRoutes; 29587c478bd9Sstevel@tonic-gate sum6->ipv6InAddrErrors += ip6->ipv6InAddrErrors; 29597c478bd9Sstevel@tonic-gate sum6->ipv6InUnknownProtos += ip6->ipv6InUnknownProtos; 29607c478bd9Sstevel@tonic-gate sum6->ipv6InTruncatedPkts += ip6->ipv6InTruncatedPkts; 29617c478bd9Sstevel@tonic-gate sum6->ipv6InDiscards += ip6->ipv6InDiscards; 29627c478bd9Sstevel@tonic-gate sum6->ipv6InDelivers += ip6->ipv6InDelivers; 29637c478bd9Sstevel@tonic-gate sum6->ipv6OutForwDatagrams += ip6->ipv6OutForwDatagrams; 29647c478bd9Sstevel@tonic-gate sum6->ipv6OutRequests += ip6->ipv6OutRequests; 29657c478bd9Sstevel@tonic-gate sum6->ipv6OutDiscards += ip6->ipv6OutDiscards; 29667c478bd9Sstevel@tonic-gate sum6->ipv6OutFragOKs += ip6->ipv6OutFragOKs; 29677c478bd9Sstevel@tonic-gate sum6->ipv6OutFragFails += ip6->ipv6OutFragFails; 29687c478bd9Sstevel@tonic-gate sum6->ipv6OutFragCreates += ip6->ipv6OutFragCreates; 29697c478bd9Sstevel@tonic-gate sum6->ipv6ReasmReqds += ip6->ipv6ReasmReqds; 29707c478bd9Sstevel@tonic-gate sum6->ipv6ReasmOKs += ip6->ipv6ReasmOKs; 29717c478bd9Sstevel@tonic-gate sum6->ipv6ReasmFails += ip6->ipv6ReasmFails; 29727c478bd9Sstevel@tonic-gate sum6->ipv6InMcastPkts += ip6->ipv6InMcastPkts; 29737c478bd9Sstevel@tonic-gate sum6->ipv6OutMcastPkts += ip6->ipv6OutMcastPkts; 29747c478bd9Sstevel@tonic-gate sum6->ipv6OutNoRoutes += ip6->ipv6OutNoRoutes; 29757c478bd9Sstevel@tonic-gate sum6->ipv6ReasmDuplicates += ip6->ipv6ReasmDuplicates; 29767c478bd9Sstevel@tonic-gate sum6->ipv6ReasmPartDups += ip6->ipv6ReasmPartDups; 29777c478bd9Sstevel@tonic-gate sum6->ipv6ForwProhibits += ip6->ipv6ForwProhibits; 29787c478bd9Sstevel@tonic-gate sum6->udpInCksumErrs += ip6->udpInCksumErrs; 29797c478bd9Sstevel@tonic-gate sum6->udpInOverflows += ip6->udpInOverflows; 29807c478bd9Sstevel@tonic-gate sum6->rawipInOverflows += ip6->rawipInOverflows; 29817c478bd9Sstevel@tonic-gate } 29827c478bd9Sstevel@tonic-gate 29837c478bd9Sstevel@tonic-gate static void 29847c478bd9Sstevel@tonic-gate sum_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6, mib2_ipv6IfIcmpEntry_t *sum6) 29857c478bd9Sstevel@tonic-gate { 29867c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInMsgs += icmp6->ipv6IfIcmpInMsgs; 29877c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInErrors += icmp6->ipv6IfIcmpInErrors; 29887c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInDestUnreachs += icmp6->ipv6IfIcmpInDestUnreachs; 29897c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInAdminProhibs += icmp6->ipv6IfIcmpInAdminProhibs; 29907c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInTimeExcds += icmp6->ipv6IfIcmpInTimeExcds; 29917c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInParmProblems += icmp6->ipv6IfIcmpInParmProblems; 29927c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInPktTooBigs += icmp6->ipv6IfIcmpInPktTooBigs; 29937c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInEchos += icmp6->ipv6IfIcmpInEchos; 29947c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInEchoReplies += icmp6->ipv6IfIcmpInEchoReplies; 29957c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInRouterSolicits += icmp6->ipv6IfIcmpInRouterSolicits; 29967c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInRouterAdvertisements += 29977c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInRouterAdvertisements; 29987c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInNeighborSolicits += 29997c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInNeighborSolicits; 30007c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInNeighborAdvertisements += 30017c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInNeighborAdvertisements; 30027c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInRedirects += icmp6->ipv6IfIcmpInRedirects; 30037c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInGroupMembQueries += 30047c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInGroupMembQueries; 30057c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInGroupMembResponses += 30067c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInGroupMembResponses; 30077c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInGroupMembReductions += 30087c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpInGroupMembReductions; 30097c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutMsgs += icmp6->ipv6IfIcmpOutMsgs; 30107c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutErrors += icmp6->ipv6IfIcmpOutErrors; 30117c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutDestUnreachs += icmp6->ipv6IfIcmpOutDestUnreachs; 30127c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutAdminProhibs += icmp6->ipv6IfIcmpOutAdminProhibs; 30137c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutTimeExcds += icmp6->ipv6IfIcmpOutTimeExcds; 30147c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutParmProblems += icmp6->ipv6IfIcmpOutParmProblems; 30157c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutPktTooBigs += icmp6->ipv6IfIcmpOutPktTooBigs; 30167c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutEchos += icmp6->ipv6IfIcmpOutEchos; 30177c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutEchoReplies += icmp6->ipv6IfIcmpOutEchoReplies; 30187c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutRouterSolicits += 30197c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutRouterSolicits; 30207c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutRouterAdvertisements += 30217c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutRouterAdvertisements; 30227c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutNeighborSolicits += 30237c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutNeighborSolicits; 30247c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutNeighborAdvertisements += 30257c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutNeighborAdvertisements; 30267c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutRedirects += icmp6->ipv6IfIcmpOutRedirects; 30277c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutGroupMembQueries += 30287c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutGroupMembQueries; 30297c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutGroupMembResponses += 30307c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutGroupMembResponses; 30317c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpOutGroupMembReductions += 30327c478bd9Sstevel@tonic-gate icmp6->ipv6IfIcmpOutGroupMembReductions; 30337c478bd9Sstevel@tonic-gate sum6->ipv6IfIcmpInOverflows += icmp6->ipv6IfIcmpInOverflows; 30347c478bd9Sstevel@tonic-gate } 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate /* ----------------------------- MRT_STAT_REPORT --------------------------- */ 30377c478bd9Sstevel@tonic-gate 30387c478bd9Sstevel@tonic-gate static void 30397c478bd9Sstevel@tonic-gate mrt_stat_report(mib_item_t *curritem) 30407c478bd9Sstevel@tonic-gate { 30417c478bd9Sstevel@tonic-gate int jtemp = 0; 30427c478bd9Sstevel@tonic-gate mib_item_t *tempitem; 30437c478bd9Sstevel@tonic-gate 30447c478bd9Sstevel@tonic-gate if (!(family_selected(AF_INET))) 30457c478bd9Sstevel@tonic-gate return; 30467c478bd9Sstevel@tonic-gate 30477c478bd9Sstevel@tonic-gate (void) putchar('\n'); 30487c478bd9Sstevel@tonic-gate for (tempitem = curritem; 30497c478bd9Sstevel@tonic-gate tempitem; 30507c478bd9Sstevel@tonic-gate tempitem = tempitem->next_item) { 3051bd670b35SErik Nordmark if (Xflag) { 305278a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 30537c478bd9Sstevel@tonic-gate "length = %d, valp = 0x%p\n", 305478a2e113SAndy Fiddaman jtemp++, tempitem->group, tempitem->mib_id, 30557c478bd9Sstevel@tonic-gate tempitem->length, tempitem->valp); 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate if (tempitem->mib_id == 0) { 30597c478bd9Sstevel@tonic-gate switch (tempitem->group) { 30607c478bd9Sstevel@tonic-gate case EXPER_DVMRP: { 30617c478bd9Sstevel@tonic-gate struct mrtstat *mrts; 30627c478bd9Sstevel@tonic-gate mrts = (struct mrtstat *)tempitem->valp; 30637c478bd9Sstevel@tonic-gate 30647c478bd9Sstevel@tonic-gate if (!(family_selected(AF_INET))) 306578a2e113SAndy Fiddaman continue; 30667c478bd9Sstevel@tonic-gate 30677c478bd9Sstevel@tonic-gate print_mrt_stats(mrts); 30687c478bd9Sstevel@tonic-gate break; 30697c478bd9Sstevel@tonic-gate } 30707c478bd9Sstevel@tonic-gate } 30717c478bd9Sstevel@tonic-gate } 307278a2e113SAndy Fiddaman } 30737c478bd9Sstevel@tonic-gate (void) putchar('\n'); 30747c478bd9Sstevel@tonic-gate (void) fflush(stdout); 30757c478bd9Sstevel@tonic-gate } 30767c478bd9Sstevel@tonic-gate 30777c478bd9Sstevel@tonic-gate /* 30787c478bd9Sstevel@tonic-gate * if_stat_total() - Computes totals for interface statistics 30797c478bd9Sstevel@tonic-gate * and returns result by updating sumstats. 30807c478bd9Sstevel@tonic-gate */ 30817c478bd9Sstevel@tonic-gate static void 30827c478bd9Sstevel@tonic-gate if_stat_total(struct ifstat *oldstats, struct ifstat *newstats, 30837c478bd9Sstevel@tonic-gate struct ifstat *sumstats) 30847c478bd9Sstevel@tonic-gate { 30857c478bd9Sstevel@tonic-gate sumstats->ipackets += newstats->ipackets - oldstats->ipackets; 30867c478bd9Sstevel@tonic-gate sumstats->opackets += newstats->opackets - oldstats->opackets; 30877c478bd9Sstevel@tonic-gate sumstats->ierrors += newstats->ierrors - oldstats->ierrors; 30887c478bd9Sstevel@tonic-gate sumstats->oerrors += newstats->oerrors - oldstats->oerrors; 30897c478bd9Sstevel@tonic-gate sumstats->collisions += newstats->collisions - oldstats->collisions; 30907c478bd9Sstevel@tonic-gate } 30917c478bd9Sstevel@tonic-gate 30927c478bd9Sstevel@tonic-gate /* --------------------- IF_REPORT (netstat -i) -------------------------- */ 30937c478bd9Sstevel@tonic-gate 30947c478bd9Sstevel@tonic-gate static struct ifstat zerostat = { 30957c478bd9Sstevel@tonic-gate 0LL, 0LL, 0LL, 0LL, 0LL 30967c478bd9Sstevel@tonic-gate }; 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate static void 30997c478bd9Sstevel@tonic-gate if_report(mib_item_t *item, char *matchname, 31007c478bd9Sstevel@tonic-gate int Iflag_only, boolean_t once_only) 31017c478bd9Sstevel@tonic-gate { 31027c478bd9Sstevel@tonic-gate static boolean_t reentry = B_FALSE; 31037c478bd9Sstevel@tonic-gate boolean_t alreadydone = B_FALSE; 31047c478bd9Sstevel@tonic-gate int jtemp = 0; 31057c478bd9Sstevel@tonic-gate uint32_t ifindex_v4 = 0; 31067c478bd9Sstevel@tonic-gate uint32_t ifindex_v6 = 0; 3107ba753d4aSkeerthi boolean_t first_header = B_TRUE; 31087c478bd9Sstevel@tonic-gate 31097c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 3110bd670b35SErik Nordmark if (Xflag) { 311178a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 311278a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 31137c478bd9Sstevel@tonic-gate item->group, item->mib_id, item->length, 31147c478bd9Sstevel@tonic-gate item->valp); 31157c478bd9Sstevel@tonic-gate } 31167c478bd9Sstevel@tonic-gate 31177c478bd9Sstevel@tonic-gate switch (item->group) { 31187c478bd9Sstevel@tonic-gate case MIB2_IP: 31197c478bd9Sstevel@tonic-gate if (item->mib_id != MIB2_IP_ADDR || 31207c478bd9Sstevel@tonic-gate !family_selected(AF_INET)) 312178a2e113SAndy Fiddaman continue; 31227c478bd9Sstevel@tonic-gate { 31237c478bd9Sstevel@tonic-gate static struct ifstat old = {0L, 0L, 0L, 0L, 0L}; 31247c478bd9Sstevel@tonic-gate static struct ifstat new = {0L, 0L, 0L, 0L, 0L}; 31257c478bd9Sstevel@tonic-gate struct ifstat sum; 31267c478bd9Sstevel@tonic-gate struct iflist *newlist = NULL; 31277c478bd9Sstevel@tonic-gate static struct iflist *oldlist = NULL; 31287c478bd9Sstevel@tonic-gate kstat_t *ksp; 31297c478bd9Sstevel@tonic-gate 31307c478bd9Sstevel@tonic-gate if (once_only) { 31317c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 31327c478bd9Sstevel@tonic-gate char logintname[LIFNAMSIZ + 1]; 31337c478bd9Sstevel@tonic-gate mib2_ipAddrEntry_t *ap; 31347c478bd9Sstevel@tonic-gate struct ifstat stat = {0L, 0L, 0L, 0L, 0L}; 31357c478bd9Sstevel@tonic-gate boolean_t first = B_TRUE; 31367c478bd9Sstevel@tonic-gate uint32_t new_ifindex; 31377c478bd9Sstevel@tonic-gate 3138bd670b35SErik Nordmark if (Xflag) 31397c478bd9Sstevel@tonic-gate (void) printf("if_report: %d items\n", 31407c478bd9Sstevel@tonic-gate (item->length) 31417c478bd9Sstevel@tonic-gate / sizeof (mib2_ipAddrEntry_t)); 31427c478bd9Sstevel@tonic-gate 31437c478bd9Sstevel@tonic-gate for (ap = (mib2_ipAddrEntry_t *)item->valp; 31447c478bd9Sstevel@tonic-gate (char *)ap < (char *)item->valp 31457c478bd9Sstevel@tonic-gate + item->length; 31467c478bd9Sstevel@tonic-gate ap++) { 31477c478bd9Sstevel@tonic-gate (void) octetstr(&ap->ipAdEntIfIndex, 31487c478bd9Sstevel@tonic-gate 'a', logintname, 31497c478bd9Sstevel@tonic-gate sizeof (logintname)); 31507c478bd9Sstevel@tonic-gate (void) strcpy(ifname, logintname); 31517c478bd9Sstevel@tonic-gate (void) strtok(ifname, ":"); 31527c478bd9Sstevel@tonic-gate if (matchname != NULL && 31537c478bd9Sstevel@tonic-gate strcmp(matchname, ifname) != 0 && 31547c478bd9Sstevel@tonic-gate strcmp(matchname, logintname) != 0) 315578a2e113SAndy Fiddaman continue; 31567c478bd9Sstevel@tonic-gate new_ifindex = 31577c478bd9Sstevel@tonic-gate if_nametoindex(logintname); 3158d62bc4baSyz /* 3159d62bc4baSyz * First lookup the "link" kstats in 3160d62bc4baSyz * case the link is renamed. Then 3161d62bc4baSyz * fallback to the legacy kstats for 3162d62bc4baSyz * those non-GLDv3 links. 3163d62bc4baSyz */ 31647c478bd9Sstevel@tonic-gate if (new_ifindex != ifindex_v4 && 3165d62bc4baSyz (((ksp = kstat_lookup(kc, "link", 0, 3166d62bc4baSyz ifname)) != NULL) || 3167d62bc4baSyz ((ksp = kstat_lookup(kc, NULL, -1, 3168d62bc4baSyz ifname)) != NULL))) { 31697c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, ksp, 31707c478bd9Sstevel@tonic-gate NULL); 31717c478bd9Sstevel@tonic-gate stat.ipackets = 31727c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 31737c478bd9Sstevel@tonic-gate "ipackets"); 31747c478bd9Sstevel@tonic-gate stat.ierrors = 31757c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 31767c478bd9Sstevel@tonic-gate "ierrors"); 31777c478bd9Sstevel@tonic-gate stat.opackets = 31787c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 31797c478bd9Sstevel@tonic-gate "opackets"); 31807c478bd9Sstevel@tonic-gate stat.oerrors = 31817c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 31827c478bd9Sstevel@tonic-gate "oerrors"); 31837c478bd9Sstevel@tonic-gate stat.collisions = 31847c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 31857c478bd9Sstevel@tonic-gate "collisions"); 31867c478bd9Sstevel@tonic-gate if (first) { 3187ba753d4aSkeerthi if (!first_header) 318878a2e113SAndy Fiddaman (void) putchar( 318978a2e113SAndy Fiddaman '\n'); 3190ba753d4aSkeerthi first_header = B_FALSE; 319178a2e113SAndy Fiddaman (void) printf( 319278a2e113SAndy Fiddaman "%-5.5s %-5.5s" 319378a2e113SAndy Fiddaman "%-13.13s %-14.14s " 319478a2e113SAndy Fiddaman "%-6.6s %-5.5s " 319578a2e113SAndy Fiddaman "%-6.6s %-5.5s " 319678a2e113SAndy Fiddaman "%-6.6s %-6.6s\n", 319778a2e113SAndy Fiddaman "Name", "Mtu", 319878a2e113SAndy Fiddaman "Net/Dest", 319978a2e113SAndy Fiddaman "Address", "Ipkts", 320078a2e113SAndy Fiddaman "Ierrs", "Opkts", 320178a2e113SAndy Fiddaman "Oerrs", "Collis", 320278a2e113SAndy Fiddaman "Queue"); 320378a2e113SAndy Fiddaman first = B_FALSE; 32047c478bd9Sstevel@tonic-gate } 32057c478bd9Sstevel@tonic-gate if_report_ip4(ap, ifname, 32067c478bd9Sstevel@tonic-gate logintname, &stat, B_TRUE); 32077c478bd9Sstevel@tonic-gate ifindex_v4 = new_ifindex; 32087c478bd9Sstevel@tonic-gate } else { 32097c478bd9Sstevel@tonic-gate if_report_ip4(ap, ifname, 32107c478bd9Sstevel@tonic-gate logintname, &stat, B_FALSE); 32117c478bd9Sstevel@tonic-gate } 321278a2e113SAndy Fiddaman } 32137c478bd9Sstevel@tonic-gate } else if (!alreadydone) { 32147c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 32157c478bd9Sstevel@tonic-gate char buf[LIFNAMSIZ + 1]; 32167c478bd9Sstevel@tonic-gate mib2_ipAddrEntry_t *ap; 32177c478bd9Sstevel@tonic-gate struct ifstat t; 3218aecc8c24Sja struct iflist *tlp = NULL; 32197c478bd9Sstevel@tonic-gate struct iflist **nextnew = &newlist; 32207c478bd9Sstevel@tonic-gate struct iflist *walkold; 32217c478bd9Sstevel@tonic-gate struct iflist *cleanlist; 3222aecc8c24Sja boolean_t found_if = B_FALSE; 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate alreadydone = B_TRUE; /* ignore other case */ 3225aecc8c24Sja 3226aecc8c24Sja /* 3227aecc8c24Sja * Check if there is anything to do. 3228aecc8c24Sja */ 3229aecc8c24Sja if (item->length < 3230aecc8c24Sja sizeof (mib2_ipAddrEntry_t)) { 3231aecc8c24Sja fail(0, "No compatible interfaces"); 3232aecc8c24Sja } 3233aecc8c24Sja 32347c478bd9Sstevel@tonic-gate /* 323578a2e113SAndy Fiddaman * Find the "right" entry: 3236aecc8c24Sja * If an interface name to match has been 3237aecc8c24Sja * supplied then try and find it, otherwise 3238aecc8c24Sja * match the first non-loopback interface found. 3239aecc8c24Sja * Use lo0 if all else fails. 32407c478bd9Sstevel@tonic-gate */ 32417c478bd9Sstevel@tonic-gate for (ap = (mib2_ipAddrEntry_t *)item->valp; 32427c478bd9Sstevel@tonic-gate (char *)ap < (char *)item->valp 32437c478bd9Sstevel@tonic-gate + item->length; 32447c478bd9Sstevel@tonic-gate ap++) { 32457c478bd9Sstevel@tonic-gate (void) octetstr(&ap->ipAdEntIfIndex, 3246e11c3f44Smeem 'a', ifname, sizeof (ifname)); 32477c478bd9Sstevel@tonic-gate (void) strtok(ifname, ":"); 32487c478bd9Sstevel@tonic-gate 32497c478bd9Sstevel@tonic-gate if (matchname) { 32507c478bd9Sstevel@tonic-gate if (strcmp(matchname, 3251aecc8c24Sja ifname) == 0) { 3252aecc8c24Sja found_if = B_TRUE; 32537c478bd9Sstevel@tonic-gate break; 3254aecc8c24Sja } 3255aecc8c24Sja } else if (strcmp(ifname, "lo0") != 0) 325678a2e113SAndy Fiddaman break; 325778a2e113SAndy Fiddaman } 32587c478bd9Sstevel@tonic-gate 3259aecc8c24Sja if (matchname == NULL) { 3260aecc8c24Sja matchname = ifname; 3261aecc8c24Sja } else { 3262aecc8c24Sja if (!found_if) 3263aecc8c24Sja fail(0, "-I: %s no such " 3264aecc8c24Sja "interface.", matchname); 3265aecc8c24Sja } 3266aecc8c24Sja 32677c478bd9Sstevel@tonic-gate if (Iflag_only == 0 || !reentry) { 32687c478bd9Sstevel@tonic-gate (void) printf(" input %-6.6s " 32697c478bd9Sstevel@tonic-gate "output ", 32707c478bd9Sstevel@tonic-gate matchname); 32717c478bd9Sstevel@tonic-gate (void) printf(" input (Total) " 32727c478bd9Sstevel@tonic-gate "output\n"); 32737c478bd9Sstevel@tonic-gate (void) printf("%-7.7s %-5.5s %-7.7s " 32747c478bd9Sstevel@tonic-gate "%-5.5s %-6.6s ", 32757c478bd9Sstevel@tonic-gate "packets", "errs", "packets", 32767c478bd9Sstevel@tonic-gate "errs", "colls"); 32777c478bd9Sstevel@tonic-gate (void) printf("%-7.7s %-5.5s %-7.7s " 32787c478bd9Sstevel@tonic-gate "%-5.5s %-6.6s\n", 32797c478bd9Sstevel@tonic-gate "packets", "errs", "packets", 32807c478bd9Sstevel@tonic-gate "errs", "colls"); 32817c478bd9Sstevel@tonic-gate } 32827c478bd9Sstevel@tonic-gate 32837c478bd9Sstevel@tonic-gate sum = zerostat; 32847c478bd9Sstevel@tonic-gate 32857c478bd9Sstevel@tonic-gate for (ap = (mib2_ipAddrEntry_t *)item->valp; 32867c478bd9Sstevel@tonic-gate (char *)ap < (char *)item->valp 32877c478bd9Sstevel@tonic-gate + item->length; 32887c478bd9Sstevel@tonic-gate ap++) { 32897c478bd9Sstevel@tonic-gate (void) octetstr(&ap->ipAdEntIfIndex, 32907c478bd9Sstevel@tonic-gate 'a', buf, sizeof (buf)); 32917c478bd9Sstevel@tonic-gate (void) strtok(buf, ":"); 3292aecc8c24Sja 3293aecc8c24Sja /* 3294aecc8c24Sja * We have reduced the IP interface 3295aecc8c24Sja * name, which could have been a 3296aecc8c24Sja * logical, down to a name suitable 3297aecc8c24Sja * for use with kstats. 3298aecc8c24Sja * We treat this name as unique and 3299aecc8c24Sja * only collate statistics for it once 3300aecc8c24Sja * per pass. This is to avoid falsely 3301aecc8c24Sja * amplifying these statistics by the 3302aecc8c24Sja * the number of logical instances. 3303aecc8c24Sja */ 3304aecc8c24Sja if ((tlp != NULL) && 3305aecc8c24Sja ((strcmp(buf, tlp->ifname) == 0))) { 3306aecc8c24Sja continue; 3307aecc8c24Sja } 3308aecc8c24Sja 3309d62bc4baSyz /* 3310d62bc4baSyz * First lookup the "link" kstats in 3311d62bc4baSyz * case the link is renamed. Then 3312d62bc4baSyz * fallback to the legacy kstats for 3313d62bc4baSyz * those non-GLDv3 links. 3314d62bc4baSyz */ 3315d62bc4baSyz if (((ksp = kstat_lookup(kc, "link", 3316d62bc4baSyz 0, buf)) != NULL || 3317d62bc4baSyz (ksp = kstat_lookup(kc, NULL, -1, 3318d62bc4baSyz buf)) != NULL) && (ksp->ks_type == 3319d62bc4baSyz KSTAT_TYPE_NAMED)) { 33207c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, ksp, 33217c478bd9Sstevel@tonic-gate NULL); 3322d62bc4baSyz } 33237c478bd9Sstevel@tonic-gate 33247c478bd9Sstevel@tonic-gate t.ipackets = kstat_named_value(ksp, 33257c478bd9Sstevel@tonic-gate "ipackets"); 33267c478bd9Sstevel@tonic-gate t.ierrors = kstat_named_value(ksp, 33277c478bd9Sstevel@tonic-gate "ierrors"); 33287c478bd9Sstevel@tonic-gate t.opackets = kstat_named_value(ksp, 33297c478bd9Sstevel@tonic-gate "opackets"); 33307c478bd9Sstevel@tonic-gate t.oerrors = kstat_named_value(ksp, 33317c478bd9Sstevel@tonic-gate "oerrors"); 33327c478bd9Sstevel@tonic-gate t.collisions = kstat_named_value(ksp, 33337c478bd9Sstevel@tonic-gate "collisions"); 33347c478bd9Sstevel@tonic-gate 33357c478bd9Sstevel@tonic-gate if (strcmp(buf, matchname) == 0) 33367c478bd9Sstevel@tonic-gate new = t; 33377c478bd9Sstevel@tonic-gate 33387c478bd9Sstevel@tonic-gate /* Build the interface list */ 33397c478bd9Sstevel@tonic-gate 33407c478bd9Sstevel@tonic-gate tlp = malloc(sizeof (struct iflist)); 33417c478bd9Sstevel@tonic-gate (void) strlcpy(tlp->ifname, buf, 33427c478bd9Sstevel@tonic-gate sizeof (tlp->ifname)); 33437c478bd9Sstevel@tonic-gate tlp->tot = t; 33447c478bd9Sstevel@tonic-gate *nextnew = tlp; 33457c478bd9Sstevel@tonic-gate nextnew = &tlp->next_if; 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate /* 33487c478bd9Sstevel@tonic-gate * First time through. 33497c478bd9Sstevel@tonic-gate * Just add up the interface stats. 33507c478bd9Sstevel@tonic-gate */ 33517c478bd9Sstevel@tonic-gate 33527c478bd9Sstevel@tonic-gate if (oldlist == NULL) { 33537c478bd9Sstevel@tonic-gate if_stat_total(&zerostat, 33547c478bd9Sstevel@tonic-gate &t, &sum); 33557c478bd9Sstevel@tonic-gate continue; 33567c478bd9Sstevel@tonic-gate } 33577c478bd9Sstevel@tonic-gate 33587c478bd9Sstevel@tonic-gate /* 33597c478bd9Sstevel@tonic-gate * Walk old list for the interface. 33607c478bd9Sstevel@tonic-gate * 33617c478bd9Sstevel@tonic-gate * If found, add difference to total. 33627c478bd9Sstevel@tonic-gate * 33637c478bd9Sstevel@tonic-gate * If not, an interface has been plumbed 33647c478bd9Sstevel@tonic-gate * up. In this case, we will simply 33657c478bd9Sstevel@tonic-gate * ignore the new interface until the 33667c478bd9Sstevel@tonic-gate * next interval; as there's no easy way 33677c478bd9Sstevel@tonic-gate * to acquire statistics between time 33687c478bd9Sstevel@tonic-gate * of the plumb and the next interval 33697c478bd9Sstevel@tonic-gate * boundary. This results in inaccurate 33707c478bd9Sstevel@tonic-gate * total values for current interval. 33717c478bd9Sstevel@tonic-gate * 33727c478bd9Sstevel@tonic-gate * Note the case when an interface is 33737c478bd9Sstevel@tonic-gate * unplumbed; as similar problems exist. 33747c478bd9Sstevel@tonic-gate * The unplumbed interface is not in the 33757c478bd9Sstevel@tonic-gate * current list, and there's no easy way 33767c478bd9Sstevel@tonic-gate * to account for the statistics between 33777c478bd9Sstevel@tonic-gate * the previous interval and time of the 33787c478bd9Sstevel@tonic-gate * unplumb. Therefore, we (in a sense) 33797c478bd9Sstevel@tonic-gate * ignore the removed interface by only 33807c478bd9Sstevel@tonic-gate * involving "current" interfaces when 33817c478bd9Sstevel@tonic-gate * computing the total statistics. 33827c478bd9Sstevel@tonic-gate * Unfortunately, this also results in 33837c478bd9Sstevel@tonic-gate * inaccurate values for interval total. 33847c478bd9Sstevel@tonic-gate */ 33857c478bd9Sstevel@tonic-gate 33867c478bd9Sstevel@tonic-gate for (walkold = oldlist; 33877c478bd9Sstevel@tonic-gate walkold != NULL; 33887c478bd9Sstevel@tonic-gate walkold = walkold->next_if) { 33897c478bd9Sstevel@tonic-gate if (strcmp(walkold->ifname, 33907c478bd9Sstevel@tonic-gate buf) == 0) { 33917c478bd9Sstevel@tonic-gate if_stat_total( 33927c478bd9Sstevel@tonic-gate &walkold->tot, 33937c478bd9Sstevel@tonic-gate &t, &sum); 33947c478bd9Sstevel@tonic-gate break; 33957c478bd9Sstevel@tonic-gate } 33967c478bd9Sstevel@tonic-gate } 33977c478bd9Sstevel@tonic-gate 339878a2e113SAndy Fiddaman } 33997c478bd9Sstevel@tonic-gate 34007c478bd9Sstevel@tonic-gate *nextnew = NULL; 34017c478bd9Sstevel@tonic-gate 34027c478bd9Sstevel@tonic-gate (void) printf("%-7llu %-5llu %-7llu " 34037c478bd9Sstevel@tonic-gate "%-5llu %-6llu ", 34047c478bd9Sstevel@tonic-gate new.ipackets - old.ipackets, 34057c478bd9Sstevel@tonic-gate new.ierrors - old.ierrors, 34067c478bd9Sstevel@tonic-gate new.opackets - old.opackets, 34077c478bd9Sstevel@tonic-gate new.oerrors - old.oerrors, 34087c478bd9Sstevel@tonic-gate new.collisions - old.collisions); 34097c478bd9Sstevel@tonic-gate 34107c478bd9Sstevel@tonic-gate (void) printf("%-7llu %-5llu %-7llu " 34117c478bd9Sstevel@tonic-gate "%-5llu %-6llu\n", sum.ipackets, 34127c478bd9Sstevel@tonic-gate sum.ierrors, sum.opackets, 34137c478bd9Sstevel@tonic-gate sum.oerrors, sum.collisions); 34147c478bd9Sstevel@tonic-gate 34157c478bd9Sstevel@tonic-gate /* 34167c478bd9Sstevel@tonic-gate * Tidy things up once finished. 34177c478bd9Sstevel@tonic-gate */ 34187c478bd9Sstevel@tonic-gate 34197c478bd9Sstevel@tonic-gate old = new; 34207c478bd9Sstevel@tonic-gate cleanlist = oldlist; 34217c478bd9Sstevel@tonic-gate oldlist = newlist; 34227c478bd9Sstevel@tonic-gate while (cleanlist != NULL) { 34237c478bd9Sstevel@tonic-gate tlp = cleanlist->next_if; 34247c478bd9Sstevel@tonic-gate free(cleanlist); 34257c478bd9Sstevel@tonic-gate cleanlist = tlp; 34267c478bd9Sstevel@tonic-gate } 34277c478bd9Sstevel@tonic-gate } 34287c478bd9Sstevel@tonic-gate break; 34297c478bd9Sstevel@tonic-gate } 34307c478bd9Sstevel@tonic-gate case MIB2_IP6: 34317c478bd9Sstevel@tonic-gate if (item->mib_id != MIB2_IP6_ADDR || 34327c478bd9Sstevel@tonic-gate !family_selected(AF_INET6)) 343378a2e113SAndy Fiddaman continue; 34347c478bd9Sstevel@tonic-gate { 34357c478bd9Sstevel@tonic-gate static struct ifstat old6 = {0L, 0L, 0L, 0L, 0L}; 34367c478bd9Sstevel@tonic-gate static struct ifstat new6 = {0L, 0L, 0L, 0L, 0L}; 34377c478bd9Sstevel@tonic-gate struct ifstat sum6; 34387c478bd9Sstevel@tonic-gate struct iflist *newlist6 = NULL; 34397c478bd9Sstevel@tonic-gate static struct iflist *oldlist6 = NULL; 34407c478bd9Sstevel@tonic-gate kstat_t *ksp; 34417c478bd9Sstevel@tonic-gate 34427c478bd9Sstevel@tonic-gate if (once_only) { 34437c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 34447c478bd9Sstevel@tonic-gate char logintname[LIFNAMSIZ + 1]; 34457c478bd9Sstevel@tonic-gate mib2_ipv6AddrEntry_t *ap6; 34467c478bd9Sstevel@tonic-gate struct ifstat stat = {0L, 0L, 0L, 0L, 0L}; 34477c478bd9Sstevel@tonic-gate boolean_t first = B_TRUE; 34487c478bd9Sstevel@tonic-gate uint32_t new_ifindex; 34497c478bd9Sstevel@tonic-gate 3450bd670b35SErik Nordmark if (Xflag) 34517c478bd9Sstevel@tonic-gate (void) printf("if_report: %d items\n", 34527c478bd9Sstevel@tonic-gate (item->length) 34537c478bd9Sstevel@tonic-gate / sizeof (mib2_ipv6AddrEntry_t)); 34547c478bd9Sstevel@tonic-gate for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 34557c478bd9Sstevel@tonic-gate (char *)ap6 < (char *)item->valp 34567c478bd9Sstevel@tonic-gate + item->length; 34577c478bd9Sstevel@tonic-gate ap6++) { 34587c478bd9Sstevel@tonic-gate (void) octetstr(&ap6->ipv6AddrIfIndex, 34597c478bd9Sstevel@tonic-gate 'a', logintname, 34607c478bd9Sstevel@tonic-gate sizeof (logintname)); 34617c478bd9Sstevel@tonic-gate (void) strcpy(ifname, logintname); 34627c478bd9Sstevel@tonic-gate (void) strtok(ifname, ":"); 34637c478bd9Sstevel@tonic-gate if (matchname != NULL && 34647c478bd9Sstevel@tonic-gate strcmp(matchname, ifname) != 0 && 34657c478bd9Sstevel@tonic-gate strcmp(matchname, logintname) != 0) 346678a2e113SAndy Fiddaman continue; 34677c478bd9Sstevel@tonic-gate new_ifindex = 34687c478bd9Sstevel@tonic-gate if_nametoindex(logintname); 3469d62bc4baSyz 3470d62bc4baSyz /* 3471d62bc4baSyz * First lookup the "link" kstats in 3472d62bc4baSyz * case the link is renamed. Then 3473d62bc4baSyz * fallback to the legacy kstats for 3474d62bc4baSyz * those non-GLDv3 links. 3475d62bc4baSyz */ 34767c478bd9Sstevel@tonic-gate if (new_ifindex != ifindex_v6 && 3477d62bc4baSyz ((ksp = kstat_lookup(kc, "link", 0, 3478d62bc4baSyz ifname)) != NULL || 34797c478bd9Sstevel@tonic-gate (ksp = kstat_lookup(kc, NULL, -1, 3480d62bc4baSyz ifname)) != NULL)) { 34817c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, ksp, 34827c478bd9Sstevel@tonic-gate NULL); 34837c478bd9Sstevel@tonic-gate stat.ipackets = 34847c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 34857c478bd9Sstevel@tonic-gate "ipackets"); 34867c478bd9Sstevel@tonic-gate stat.ierrors = 34877c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 34887c478bd9Sstevel@tonic-gate "ierrors"); 34897c478bd9Sstevel@tonic-gate stat.opackets = 34907c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 34917c478bd9Sstevel@tonic-gate "opackets"); 34927c478bd9Sstevel@tonic-gate stat.oerrors = 34937c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 34947c478bd9Sstevel@tonic-gate "oerrors"); 34957c478bd9Sstevel@tonic-gate stat.collisions = 34967c478bd9Sstevel@tonic-gate kstat_named_value(ksp, 34977c478bd9Sstevel@tonic-gate "collisions"); 34987c478bd9Sstevel@tonic-gate if (first) { 3499ba753d4aSkeerthi if (!first_header) 350078a2e113SAndy Fiddaman (void) putchar( 350178a2e113SAndy Fiddaman '\n'); 3502ba753d4aSkeerthi first_header = B_FALSE; 35037c478bd9Sstevel@tonic-gate (void) printf( 35047c478bd9Sstevel@tonic-gate "%-5.5s %-5.5s%" 35057c478bd9Sstevel@tonic-gate "-27.27s %-27.27s " 35067c478bd9Sstevel@tonic-gate "%-6.6s %-5.5s " 35077c478bd9Sstevel@tonic-gate "%-6.6s %-5.5s " 35087c478bd9Sstevel@tonic-gate "%-6.6s\n", 35097c478bd9Sstevel@tonic-gate "Name", "Mtu", 35107c478bd9Sstevel@tonic-gate "Net/Dest", 35117c478bd9Sstevel@tonic-gate "Address", "Ipkts", 35127c478bd9Sstevel@tonic-gate "Ierrs", "Opkts", 35137c478bd9Sstevel@tonic-gate "Oerrs", "Collis"); 35147c478bd9Sstevel@tonic-gate first = B_FALSE; 35157c478bd9Sstevel@tonic-gate } 35167c478bd9Sstevel@tonic-gate if_report_ip6(ap6, ifname, 35177c478bd9Sstevel@tonic-gate logintname, &stat, B_TRUE); 35187c478bd9Sstevel@tonic-gate ifindex_v6 = new_ifindex; 35197c478bd9Sstevel@tonic-gate } else { 35207c478bd9Sstevel@tonic-gate if_report_ip6(ap6, ifname, 35217c478bd9Sstevel@tonic-gate logintname, &stat, B_FALSE); 35227c478bd9Sstevel@tonic-gate } 352378a2e113SAndy Fiddaman } 35247c478bd9Sstevel@tonic-gate } else if (!alreadydone) { 35257c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 35267c478bd9Sstevel@tonic-gate char buf[IFNAMSIZ + 1]; 35277c478bd9Sstevel@tonic-gate mib2_ipv6AddrEntry_t *ap6; 35287c478bd9Sstevel@tonic-gate struct ifstat t; 3529aecc8c24Sja struct iflist *tlp = NULL; 35307c478bd9Sstevel@tonic-gate struct iflist **nextnew = &newlist6; 35317c478bd9Sstevel@tonic-gate struct iflist *walkold; 35327c478bd9Sstevel@tonic-gate struct iflist *cleanlist; 3533aecc8c24Sja boolean_t found_if = B_FALSE; 35347c478bd9Sstevel@tonic-gate 35357c478bd9Sstevel@tonic-gate alreadydone = B_TRUE; /* ignore other case */ 3536aecc8c24Sja 35377c478bd9Sstevel@tonic-gate /* 3538aecc8c24Sja * Check if there is anything to do. 3539aecc8c24Sja */ 3540aecc8c24Sja if (item->length < 3541aecc8c24Sja sizeof (mib2_ipv6AddrEntry_t)) { 3542aecc8c24Sja fail(0, "No compatible interfaces"); 3543aecc8c24Sja } 3544aecc8c24Sja 3545aecc8c24Sja /* 354678a2e113SAndy Fiddaman * Find the "right" entry: 3547aecc8c24Sja * If an interface name to match has been 3548aecc8c24Sja * supplied then try and find it, otherwise 3549aecc8c24Sja * match the first non-loopback interface found. 3550aecc8c24Sja * Use lo0 if all else fails. 35517c478bd9Sstevel@tonic-gate */ 35527c478bd9Sstevel@tonic-gate for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 35537c478bd9Sstevel@tonic-gate (char *)ap6 < (char *)item->valp 35547c478bd9Sstevel@tonic-gate + item->length; 35557c478bd9Sstevel@tonic-gate ap6++) { 35567c478bd9Sstevel@tonic-gate (void) octetstr(&ap6->ipv6AddrIfIndex, 35577c478bd9Sstevel@tonic-gate 'a', ifname, sizeof (ifname)); 35587c478bd9Sstevel@tonic-gate (void) strtok(ifname, ":"); 35597c478bd9Sstevel@tonic-gate 35607c478bd9Sstevel@tonic-gate if (matchname) { 3561aecc8c24Sja if (strcmp(matchname, 3562aecc8c24Sja ifname) == 0) { 3563aecc8c24Sja found_if = B_TRUE; 35647c478bd9Sstevel@tonic-gate break; 3565aecc8c24Sja } 3566aecc8c24Sja } else if (strcmp(ifname, "lo0") != 0) 356778a2e113SAndy Fiddaman break; 356878a2e113SAndy Fiddaman } 35697c478bd9Sstevel@tonic-gate 3570aecc8c24Sja if (matchname == NULL) { 3571aecc8c24Sja matchname = ifname; 3572aecc8c24Sja } else { 3573aecc8c24Sja if (!found_if) 3574aecc8c24Sja fail(0, "-I: %s no such " 3575aecc8c24Sja "interface.", matchname); 3576aecc8c24Sja } 3577aecc8c24Sja 35787c478bd9Sstevel@tonic-gate if (Iflag_only == 0 || !reentry) { 35797c478bd9Sstevel@tonic-gate (void) printf( 35807c478bd9Sstevel@tonic-gate " input %-6.6s" 35817c478bd9Sstevel@tonic-gate " output ", 35827c478bd9Sstevel@tonic-gate matchname); 35837c478bd9Sstevel@tonic-gate (void) printf(" input (Total)" 35847c478bd9Sstevel@tonic-gate " output\n"); 35857c478bd9Sstevel@tonic-gate (void) printf("%-7.7s %-5.5s %-7.7s " 35867c478bd9Sstevel@tonic-gate "%-5.5s %-6.6s ", 35877c478bd9Sstevel@tonic-gate "packets", "errs", "packets", 35887c478bd9Sstevel@tonic-gate "errs", "colls"); 35897c478bd9Sstevel@tonic-gate (void) printf("%-7.7s %-5.5s %-7.7s " 35907c478bd9Sstevel@tonic-gate "%-5.5s %-6.6s\n", 35917c478bd9Sstevel@tonic-gate "packets", "errs", "packets", 35927c478bd9Sstevel@tonic-gate "errs", "colls"); 35937c478bd9Sstevel@tonic-gate } 35947c478bd9Sstevel@tonic-gate 35957c478bd9Sstevel@tonic-gate sum6 = zerostat; 35967c478bd9Sstevel@tonic-gate 35977c478bd9Sstevel@tonic-gate for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 35987c478bd9Sstevel@tonic-gate (char *)ap6 < (char *)item->valp 35997c478bd9Sstevel@tonic-gate + item->length; 36007c478bd9Sstevel@tonic-gate ap6++) { 36017c478bd9Sstevel@tonic-gate (void) octetstr(&ap6->ipv6AddrIfIndex, 36027c478bd9Sstevel@tonic-gate 'a', buf, sizeof (buf)); 36037c478bd9Sstevel@tonic-gate (void) strtok(buf, ":"); 3604aecc8c24Sja 3605aecc8c24Sja /* 3606aecc8c24Sja * We have reduced the IP interface 3607aecc8c24Sja * name, which could have been a 3608aecc8c24Sja * logical, down to a name suitable 3609aecc8c24Sja * for use with kstats. 3610aecc8c24Sja * We treat this name as unique and 3611aecc8c24Sja * only collate statistics for it once 3612aecc8c24Sja * per pass. This is to avoid falsely 3613aecc8c24Sja * amplifying these statistics by the 3614aecc8c24Sja * the number of logical instances. 3615aecc8c24Sja */ 3616aecc8c24Sja 3617aecc8c24Sja if ((tlp != NULL) && 3618aecc8c24Sja ((strcmp(buf, tlp->ifname) == 0))) { 3619aecc8c24Sja continue; 3620aecc8c24Sja } 3621aecc8c24Sja 3622d62bc4baSyz /* 3623d62bc4baSyz * First lookup the "link" kstats in 3624d62bc4baSyz * case the link is renamed. Then 3625d62bc4baSyz * fallback to the legacy kstats for 3626d62bc4baSyz * those non-GLDv3 links. 3627d62bc4baSyz */ 3628d62bc4baSyz if (((ksp = kstat_lookup(kc, "link", 3629d62bc4baSyz 0, buf)) != NULL || 3630d62bc4baSyz (ksp = kstat_lookup(kc, NULL, -1, 3631d62bc4baSyz buf)) != NULL) && (ksp->ks_type == 3632d62bc4baSyz KSTAT_TYPE_NAMED)) { 36337c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, 36347c478bd9Sstevel@tonic-gate ksp, NULL); 3635d62bc4baSyz } 36367c478bd9Sstevel@tonic-gate 36377c478bd9Sstevel@tonic-gate t.ipackets = kstat_named_value(ksp, 36387c478bd9Sstevel@tonic-gate "ipackets"); 36397c478bd9Sstevel@tonic-gate t.ierrors = kstat_named_value(ksp, 36407c478bd9Sstevel@tonic-gate "ierrors"); 36417c478bd9Sstevel@tonic-gate t.opackets = kstat_named_value(ksp, 36427c478bd9Sstevel@tonic-gate "opackets"); 36437c478bd9Sstevel@tonic-gate t.oerrors = kstat_named_value(ksp, 36447c478bd9Sstevel@tonic-gate "oerrors"); 36457c478bd9Sstevel@tonic-gate t.collisions = kstat_named_value(ksp, 36467c478bd9Sstevel@tonic-gate "collisions"); 36477c478bd9Sstevel@tonic-gate 36487c478bd9Sstevel@tonic-gate if (strcmp(buf, matchname) == 0) 36497c478bd9Sstevel@tonic-gate new6 = t; 36507c478bd9Sstevel@tonic-gate 36517c478bd9Sstevel@tonic-gate /* Build the interface list */ 36527c478bd9Sstevel@tonic-gate 36537c478bd9Sstevel@tonic-gate tlp = malloc(sizeof (struct iflist)); 36547c478bd9Sstevel@tonic-gate (void) strlcpy(tlp->ifname, buf, 36557c478bd9Sstevel@tonic-gate sizeof (tlp->ifname)); 36567c478bd9Sstevel@tonic-gate tlp->tot = t; 36577c478bd9Sstevel@tonic-gate *nextnew = tlp; 36587c478bd9Sstevel@tonic-gate nextnew = &tlp->next_if; 36597c478bd9Sstevel@tonic-gate 36607c478bd9Sstevel@tonic-gate /* 36617c478bd9Sstevel@tonic-gate * First time through. 36627c478bd9Sstevel@tonic-gate * Just add up the interface stats. 36637c478bd9Sstevel@tonic-gate */ 36647c478bd9Sstevel@tonic-gate 36657c478bd9Sstevel@tonic-gate if (oldlist6 == NULL) { 36667c478bd9Sstevel@tonic-gate if_stat_total(&zerostat, 36677c478bd9Sstevel@tonic-gate &t, &sum6); 36687c478bd9Sstevel@tonic-gate continue; 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate 36717c478bd9Sstevel@tonic-gate /* 36727c478bd9Sstevel@tonic-gate * Walk old list for the interface. 36737c478bd9Sstevel@tonic-gate * 36747c478bd9Sstevel@tonic-gate * If found, add difference to total. 36757c478bd9Sstevel@tonic-gate * 36767c478bd9Sstevel@tonic-gate * If not, an interface has been plumbed 36777c478bd9Sstevel@tonic-gate * up. In this case, we will simply 36787c478bd9Sstevel@tonic-gate * ignore the new interface until the 36797c478bd9Sstevel@tonic-gate * next interval; as there's no easy way 36807c478bd9Sstevel@tonic-gate * to acquire statistics between time 36817c478bd9Sstevel@tonic-gate * of the plumb and the next interval 36827c478bd9Sstevel@tonic-gate * boundary. This results in inaccurate 36837c478bd9Sstevel@tonic-gate * total values for current interval. 36847c478bd9Sstevel@tonic-gate * 36857c478bd9Sstevel@tonic-gate * Note the case when an interface is 36867c478bd9Sstevel@tonic-gate * unplumbed; as similar problems exist. 36877c478bd9Sstevel@tonic-gate * The unplumbed interface is not in the 36887c478bd9Sstevel@tonic-gate * current list, and there's no easy way 36897c478bd9Sstevel@tonic-gate * to account for the statistics between 36907c478bd9Sstevel@tonic-gate * the previous interval and time of the 36917c478bd9Sstevel@tonic-gate * unplumb. Therefore, we (in a sense) 36927c478bd9Sstevel@tonic-gate * ignore the removed interface by only 36937c478bd9Sstevel@tonic-gate * involving "current" interfaces when 36947c478bd9Sstevel@tonic-gate * computing the total statistics. 36957c478bd9Sstevel@tonic-gate * Unfortunately, this also results in 36967c478bd9Sstevel@tonic-gate * inaccurate values for interval total. 36977c478bd9Sstevel@tonic-gate */ 36987c478bd9Sstevel@tonic-gate 36997c478bd9Sstevel@tonic-gate for (walkold = oldlist6; 37007c478bd9Sstevel@tonic-gate walkold != NULL; 37017c478bd9Sstevel@tonic-gate walkold = walkold->next_if) { 37027c478bd9Sstevel@tonic-gate if (strcmp(walkold->ifname, 37037c478bd9Sstevel@tonic-gate buf) == 0) { 37047c478bd9Sstevel@tonic-gate if_stat_total( 37057c478bd9Sstevel@tonic-gate &walkold->tot, 37067c478bd9Sstevel@tonic-gate &t, &sum6); 37077c478bd9Sstevel@tonic-gate break; 37087c478bd9Sstevel@tonic-gate } 37097c478bd9Sstevel@tonic-gate } 37107c478bd9Sstevel@tonic-gate 371178a2e113SAndy Fiddaman } 37127c478bd9Sstevel@tonic-gate 37137c478bd9Sstevel@tonic-gate *nextnew = NULL; 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate (void) printf("%-7llu %-5llu %-7llu " 37167c478bd9Sstevel@tonic-gate "%-5llu %-6llu ", 37177c478bd9Sstevel@tonic-gate new6.ipackets - old6.ipackets, 37187c478bd9Sstevel@tonic-gate new6.ierrors - old6.ierrors, 37197c478bd9Sstevel@tonic-gate new6.opackets - old6.opackets, 37207c478bd9Sstevel@tonic-gate new6.oerrors - old6.oerrors, 37217c478bd9Sstevel@tonic-gate new6.collisions - old6.collisions); 37227c478bd9Sstevel@tonic-gate 37237c478bd9Sstevel@tonic-gate (void) printf("%-7llu %-5llu %-7llu " 37247c478bd9Sstevel@tonic-gate "%-5llu %-6llu\n", sum6.ipackets, 37257c478bd9Sstevel@tonic-gate sum6.ierrors, sum6.opackets, 37267c478bd9Sstevel@tonic-gate sum6.oerrors, sum6.collisions); 37277c478bd9Sstevel@tonic-gate 37287c478bd9Sstevel@tonic-gate /* 37297c478bd9Sstevel@tonic-gate * Tidy things up once finished. 37307c478bd9Sstevel@tonic-gate */ 37317c478bd9Sstevel@tonic-gate 37327c478bd9Sstevel@tonic-gate old6 = new6; 37337c478bd9Sstevel@tonic-gate cleanlist = oldlist6; 37347c478bd9Sstevel@tonic-gate oldlist6 = newlist6; 37357c478bd9Sstevel@tonic-gate while (cleanlist != NULL) { 37367c478bd9Sstevel@tonic-gate tlp = cleanlist->next_if; 37377c478bd9Sstevel@tonic-gate free(cleanlist); 37387c478bd9Sstevel@tonic-gate cleanlist = tlp; 37397c478bd9Sstevel@tonic-gate } 37407c478bd9Sstevel@tonic-gate } 37417c478bd9Sstevel@tonic-gate break; 37427c478bd9Sstevel@tonic-gate } 37437c478bd9Sstevel@tonic-gate } 37447c478bd9Sstevel@tonic-gate (void) fflush(stdout); 374578a2e113SAndy Fiddaman } 3746ba753d4aSkeerthi if ((Iflag_only == 0) && (!once_only)) 3747ba753d4aSkeerthi (void) putchar('\n'); 37487c478bd9Sstevel@tonic-gate reentry = B_TRUE; 37497c478bd9Sstevel@tonic-gate } 37507c478bd9Sstevel@tonic-gate 37517c478bd9Sstevel@tonic-gate static void 37527c478bd9Sstevel@tonic-gate if_report_ip4(mib2_ipAddrEntry_t *ap, 3753afee3dc6SRobert Mustacchi char ifname[], char logintname[], struct ifstat *statptr, 3754afee3dc6SRobert Mustacchi boolean_t ksp_not_null) 3755afee3dc6SRobert Mustacchi { 37567c478bd9Sstevel@tonic-gate 3757d38b7101SDan McDonald char abuf[MAXHOSTNAMELEN + 4]; /* Include /<num> for CIDR-printing. */ 37587c478bd9Sstevel@tonic-gate char dstbuf[MAXHOSTNAMELEN + 1]; 37597c478bd9Sstevel@tonic-gate 37607c478bd9Sstevel@tonic-gate if (ksp_not_null) { 37619edb2c23SAjaykumar Venkatesulu (void) printf("%-5s %-4u ", 37627c478bd9Sstevel@tonic-gate ifname, ap->ipAdEntInfo.ae_mtu); 37637c478bd9Sstevel@tonic-gate if (ap->ipAdEntInfo.ae_flags & IFF_POINTOPOINT) 37647c478bd9Sstevel@tonic-gate (void) pr_addr(ap->ipAdEntInfo.ae_pp_dst_addr, 37657c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)); 37667c478bd9Sstevel@tonic-gate else 37677c478bd9Sstevel@tonic-gate (void) pr_netaddr(ap->ipAdEntAddr, 37687c478bd9Sstevel@tonic-gate ap->ipAdEntNetMask, abuf, sizeof (abuf)); 37697c478bd9Sstevel@tonic-gate (void) printf("%-13s %-14s %-6llu %-5llu %-6llu %-5llu " 37707c478bd9Sstevel@tonic-gate "%-6llu %-6llu\n", 37717c478bd9Sstevel@tonic-gate abuf, pr_addr(ap->ipAdEntAddr, dstbuf, sizeof (dstbuf)), 37727c478bd9Sstevel@tonic-gate statptr->ipackets, statptr->ierrors, 37737c478bd9Sstevel@tonic-gate statptr->opackets, statptr->oerrors, 37747c478bd9Sstevel@tonic-gate statptr->collisions, 0LL); 37757c478bd9Sstevel@tonic-gate } 37767c478bd9Sstevel@tonic-gate /* 37777c478bd9Sstevel@tonic-gate * Print logical interface info if Aflag set (including logical unit 0) 37787c478bd9Sstevel@tonic-gate */ 37797c478bd9Sstevel@tonic-gate if (Aflag) { 37807c478bd9Sstevel@tonic-gate *statptr = zerostat; 37817c478bd9Sstevel@tonic-gate statptr->ipackets = ap->ipAdEntInfo.ae_ibcnt; 37827c478bd9Sstevel@tonic-gate statptr->opackets = ap->ipAdEntInfo.ae_obcnt; 37837c478bd9Sstevel@tonic-gate 37849edb2c23SAjaykumar Venkatesulu (void) printf("%-5s %-4u ", logintname, ap->ipAdEntInfo.ae_mtu); 37857c478bd9Sstevel@tonic-gate if (ap->ipAdEntInfo.ae_flags & IFF_POINTOPOINT) 37867c478bd9Sstevel@tonic-gate (void) pr_addr(ap->ipAdEntInfo.ae_pp_dst_addr, abuf, 3787afee3dc6SRobert Mustacchi sizeof (abuf)); 37887c478bd9Sstevel@tonic-gate else 37897c478bd9Sstevel@tonic-gate (void) pr_netaddr(ap->ipAdEntAddr, ap->ipAdEntNetMask, 37907c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)); 37917c478bd9Sstevel@tonic-gate 3792bd670b35SErik Nordmark (void) printf("%-13s %-14s %-6llu %-5s %-6s " 37937c478bd9Sstevel@tonic-gate "%-5s %-6s %-6llu\n", abuf, 37947c478bd9Sstevel@tonic-gate pr_addr(ap->ipAdEntAddr, dstbuf, sizeof (dstbuf)), 3795bd670b35SErik Nordmark statptr->ipackets, "N/A", "N/A", "N/A", "N/A", 37967c478bd9Sstevel@tonic-gate 0LL); 37977c478bd9Sstevel@tonic-gate } 37987c478bd9Sstevel@tonic-gate } 37997c478bd9Sstevel@tonic-gate 38007c478bd9Sstevel@tonic-gate static void 38017c478bd9Sstevel@tonic-gate if_report_ip6(mib2_ipv6AddrEntry_t *ap6, 3802afee3dc6SRobert Mustacchi char ifname[], char logintname[], struct ifstat *statptr, 3803afee3dc6SRobert Mustacchi boolean_t ksp_not_null) 3804afee3dc6SRobert Mustacchi { 38057c478bd9Sstevel@tonic-gate 38067c478bd9Sstevel@tonic-gate char abuf[MAXHOSTNAMELEN + 1]; 38077c478bd9Sstevel@tonic-gate char dstbuf[MAXHOSTNAMELEN + 1]; 38087c478bd9Sstevel@tonic-gate 38097c478bd9Sstevel@tonic-gate if (ksp_not_null) { 38109edb2c23SAjaykumar Venkatesulu (void) printf("%-5s %-4u ", ifname, ap6->ipv6AddrInfo.ae_mtu); 38117c478bd9Sstevel@tonic-gate if (ap6->ipv6AddrInfo.ae_flags & 38127c478bd9Sstevel@tonic-gate IFF_POINTOPOINT) { 38137c478bd9Sstevel@tonic-gate (void) pr_addr6(&ap6->ipv6AddrInfo.ae_pp_dst_addr, 38147c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)); 38157c478bd9Sstevel@tonic-gate } else { 38167c478bd9Sstevel@tonic-gate (void) pr_prefix6(&ap6->ipv6AddrAddress, 38177c478bd9Sstevel@tonic-gate ap6->ipv6AddrPfxLength, abuf, 38187c478bd9Sstevel@tonic-gate sizeof (abuf)); 38197c478bd9Sstevel@tonic-gate } 38207c478bd9Sstevel@tonic-gate (void) printf("%-27s %-27s %-6llu %-5llu " 38217c478bd9Sstevel@tonic-gate "%-6llu %-5llu %-6llu\n", 38227c478bd9Sstevel@tonic-gate abuf, pr_addr6(&ap6->ipv6AddrAddress, dstbuf, 38237c478bd9Sstevel@tonic-gate sizeof (dstbuf)), 38247c478bd9Sstevel@tonic-gate statptr->ipackets, statptr->ierrors, statptr->opackets, 38257c478bd9Sstevel@tonic-gate statptr->oerrors, statptr->collisions); 38267c478bd9Sstevel@tonic-gate } 38277c478bd9Sstevel@tonic-gate /* 38287c478bd9Sstevel@tonic-gate * Print logical interface info if Aflag set (including logical unit 0) 38297c478bd9Sstevel@tonic-gate */ 38307c478bd9Sstevel@tonic-gate if (Aflag) { 38317c478bd9Sstevel@tonic-gate *statptr = zerostat; 38327c478bd9Sstevel@tonic-gate statptr->ipackets = ap6->ipv6AddrInfo.ae_ibcnt; 38337c478bd9Sstevel@tonic-gate statptr->opackets = ap6->ipv6AddrInfo.ae_obcnt; 38347c478bd9Sstevel@tonic-gate 38359edb2c23SAjaykumar Venkatesulu (void) printf("%-5s %-4u ", logintname, 38367c478bd9Sstevel@tonic-gate ap6->ipv6AddrInfo.ae_mtu); 38377c478bd9Sstevel@tonic-gate if (ap6->ipv6AddrInfo.ae_flags & IFF_POINTOPOINT) 38387c478bd9Sstevel@tonic-gate (void) pr_addr6(&ap6->ipv6AddrInfo.ae_pp_dst_addr, 38397c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)); 38407c478bd9Sstevel@tonic-gate else 38417c478bd9Sstevel@tonic-gate (void) pr_prefix6(&ap6->ipv6AddrAddress, 38427c478bd9Sstevel@tonic-gate ap6->ipv6AddrPfxLength, abuf, sizeof (abuf)); 3843bd670b35SErik Nordmark (void) printf("%-27s %-27s %-6llu %-5s %-6s %-5s %-6s\n", 38447c478bd9Sstevel@tonic-gate abuf, pr_addr6(&ap6->ipv6AddrAddress, dstbuf, 38457c478bd9Sstevel@tonic-gate sizeof (dstbuf)), 3846bd670b35SErik Nordmark statptr->ipackets, "N/A", "N/A", "N/A", "N/A"); 38477c478bd9Sstevel@tonic-gate } 38487c478bd9Sstevel@tonic-gate } 38497c478bd9Sstevel@tonic-gate 38507c478bd9Sstevel@tonic-gate /* --------------------- DHCP_REPORT (netstat -D) ------------------------- */ 38517c478bd9Sstevel@tonic-gate 3852d04ccbb3Scarlsonj static boolean_t 3853d04ccbb3Scarlsonj dhcp_do_ipc(dhcp_ipc_type_t type, const char *ifname, boolean_t printed_one) 38547c478bd9Sstevel@tonic-gate { 38557c478bd9Sstevel@tonic-gate dhcp_ipc_request_t *request; 38567c478bd9Sstevel@tonic-gate dhcp_ipc_reply_t *reply; 38577c478bd9Sstevel@tonic-gate int error; 38587c478bd9Sstevel@tonic-gate 38597c478bd9Sstevel@tonic-gate request = dhcp_ipc_alloc_request(type, ifname, NULL, 0, DHCP_TYPE_NONE); 38607c478bd9Sstevel@tonic-gate if (request == NULL) 38617c478bd9Sstevel@tonic-gate fail(0, "dhcp_do_ipc: out of memory"); 38627c478bd9Sstevel@tonic-gate 38637c478bd9Sstevel@tonic-gate error = dhcp_ipc_make_request(request, &reply, DHCP_IPC_WAIT_DEFAULT); 38647c478bd9Sstevel@tonic-gate if (error != 0) { 38657c478bd9Sstevel@tonic-gate free(request); 38667c478bd9Sstevel@tonic-gate fail(0, "dhcp_do_ipc: %s", dhcp_ipc_strerror(error)); 38677c478bd9Sstevel@tonic-gate } 38687c478bd9Sstevel@tonic-gate 38697c478bd9Sstevel@tonic-gate free(request); 38707c478bd9Sstevel@tonic-gate error = reply->return_code; 3871d04ccbb3Scarlsonj if (error == DHCP_IPC_E_UNKIF) { 3872d04ccbb3Scarlsonj free(reply); 3873d04ccbb3Scarlsonj return (printed_one); 3874d04ccbb3Scarlsonj } 38757c478bd9Sstevel@tonic-gate if (error != 0) { 38767c478bd9Sstevel@tonic-gate free(reply); 38777c478bd9Sstevel@tonic-gate fail(0, "dhcp_do_ipc: %s", dhcp_ipc_strerror(error)); 38787c478bd9Sstevel@tonic-gate } 38797c478bd9Sstevel@tonic-gate 388026fd7700SKrishnendu Sadhukhan - Sun Microsystems if (timestamp_fmt != NODATE) 388126fd7700SKrishnendu Sadhukhan - Sun Microsystems print_timestamp(timestamp_fmt); 388226fd7700SKrishnendu Sadhukhan - Sun Microsystems 3883d04ccbb3Scarlsonj if (!printed_one) 3884d04ccbb3Scarlsonj (void) printf("%s", dhcp_status_hdr_string()); 3885d04ccbb3Scarlsonj 3886d04ccbb3Scarlsonj (void) printf("%s", dhcp_status_reply_to_string(reply)); 3887d04ccbb3Scarlsonj free(reply); 3888d04ccbb3Scarlsonj return (B_TRUE); 38897c478bd9Sstevel@tonic-gate } 38907c478bd9Sstevel@tonic-gate 38917c478bd9Sstevel@tonic-gate /* 3892dc918d99Smeem * dhcp_walk_interfaces: walk the list of interfaces for a given address 3893dc918d99Smeem * family (af). For each, print out the DHCP status using dhcp_do_ipc. 38947c478bd9Sstevel@tonic-gate */ 3895d04ccbb3Scarlsonj static boolean_t 3896dc918d99Smeem dhcp_walk_interfaces(int af, boolean_t printed_one) 38977c478bd9Sstevel@tonic-gate { 3898d04ccbb3Scarlsonj struct lifnum lifn; 3899d04ccbb3Scarlsonj struct lifconf lifc; 39007c478bd9Sstevel@tonic-gate int n_ifs, i, sock_fd; 39017c478bd9Sstevel@tonic-gate 3902d04ccbb3Scarlsonj sock_fd = socket(af, SOCK_DGRAM, 0); 39037c478bd9Sstevel@tonic-gate if (sock_fd == -1) 3904d04ccbb3Scarlsonj return (printed_one); 39057c478bd9Sstevel@tonic-gate 3906d04ccbb3Scarlsonj /* 3907d04ccbb3Scarlsonj * SIOCGLIFNUM is just an estimate. If the ioctl fails, we don't care; 3908d04ccbb3Scarlsonj * just drive on and use SIOCGLIFCONF with increasing buffer sizes, as 3909d04ccbb3Scarlsonj * is traditional. 3910d04ccbb3Scarlsonj */ 3911d04ccbb3Scarlsonj (void) memset(&lifn, 0, sizeof (lifn)); 3912d04ccbb3Scarlsonj lifn.lifn_family = af; 3913e11c3f44Smeem lifn.lifn_flags = LIFC_ALLZONES | LIFC_NOXMIT | LIFC_UNDER_IPMP; 3914d04ccbb3Scarlsonj if (ioctl(sock_fd, SIOCGLIFNUM, &lifn) == -1) 3915d04ccbb3Scarlsonj n_ifs = LIFN_GUARD_VALUE; 3916d04ccbb3Scarlsonj else 3917d04ccbb3Scarlsonj n_ifs = lifn.lifn_count + LIFN_GUARD_VALUE; 3918d04ccbb3Scarlsonj 3919d04ccbb3Scarlsonj (void) memset(&lifc, 0, sizeof (lifc)); 3920d04ccbb3Scarlsonj lifc.lifc_family = af; 3921d04ccbb3Scarlsonj lifc.lifc_flags = lifn.lifn_flags; 3922d04ccbb3Scarlsonj lifc.lifc_len = n_ifs * sizeof (struct lifreq); 3923d04ccbb3Scarlsonj lifc.lifc_buf = malloc(lifc.lifc_len); 3924d04ccbb3Scarlsonj if (lifc.lifc_buf != NULL) { 3925d04ccbb3Scarlsonj 3926d04ccbb3Scarlsonj if (ioctl(sock_fd, SIOCGLIFCONF, &lifc) == -1) { 39277c478bd9Sstevel@tonic-gate (void) close(sock_fd); 3928d04ccbb3Scarlsonj free(lifc.lifc_buf); 392995c74518SToomas Soome return (B_FALSE); 39307c478bd9Sstevel@tonic-gate } 39317c478bd9Sstevel@tonic-gate 3932d04ccbb3Scarlsonj n_ifs = lifc.lifc_len / sizeof (struct lifreq); 39337c478bd9Sstevel@tonic-gate 3934d04ccbb3Scarlsonj for (i = 0; i < n_ifs; i++) { 3935d04ccbb3Scarlsonj printed_one = dhcp_do_ipc(DHCP_STATUS | 3936d04ccbb3Scarlsonj (af == AF_INET6 ? DHCP_V6 : 0), 3937d04ccbb3Scarlsonj lifc.lifc_req[i].lifr_name, printed_one); 3938d04ccbb3Scarlsonj } 39397c478bd9Sstevel@tonic-gate } 39407c478bd9Sstevel@tonic-gate (void) close(sock_fd); 3941d04ccbb3Scarlsonj free(lifc.lifc_buf); 3942d04ccbb3Scarlsonj return (printed_one); 39437c478bd9Sstevel@tonic-gate } 39447c478bd9Sstevel@tonic-gate 39457c478bd9Sstevel@tonic-gate static void 39467c478bd9Sstevel@tonic-gate dhcp_report(char *ifname) 39477c478bd9Sstevel@tonic-gate { 3948d04ccbb3Scarlsonj boolean_t printed_one; 39497c478bd9Sstevel@tonic-gate 3950d04ccbb3Scarlsonj if (!family_selected(AF_INET) && !family_selected(AF_INET6)) 39517c478bd9Sstevel@tonic-gate return; 39527c478bd9Sstevel@tonic-gate 3953d04ccbb3Scarlsonj printed_one = B_FALSE; 3954d04ccbb3Scarlsonj if (ifname != NULL) { 3955d04ccbb3Scarlsonj if (family_selected(AF_INET)) { 3956d04ccbb3Scarlsonj printed_one = dhcp_do_ipc(DHCP_STATUS, ifname, 3957d04ccbb3Scarlsonj printed_one); 3958d04ccbb3Scarlsonj } 3959d04ccbb3Scarlsonj if (family_selected(AF_INET6)) { 3960d04ccbb3Scarlsonj printed_one = dhcp_do_ipc(DHCP_STATUS | DHCP_V6, 3961d04ccbb3Scarlsonj ifname, printed_one); 3962d04ccbb3Scarlsonj } 3963d04ccbb3Scarlsonj if (!printed_one) { 3964d04ccbb3Scarlsonj fail(0, "%s: %s", ifname, 3965d04ccbb3Scarlsonj dhcp_ipc_strerror(DHCP_IPC_E_UNKIF)); 3966d04ccbb3Scarlsonj } 3967d04ccbb3Scarlsonj } else { 3968d04ccbb3Scarlsonj if (family_selected(AF_INET)) { 3969dc918d99Smeem printed_one = dhcp_walk_interfaces(AF_INET, 3970dc918d99Smeem printed_one); 3971d04ccbb3Scarlsonj } 3972dc918d99Smeem if (family_selected(AF_INET6)) 3973dc918d99Smeem (void) dhcp_walk_interfaces(AF_INET6, printed_one); 39747c478bd9Sstevel@tonic-gate } 39757c478bd9Sstevel@tonic-gate } 39767c478bd9Sstevel@tonic-gate 39777c478bd9Sstevel@tonic-gate /* --------------------- GROUP_REPORT (netstat -g) ------------------------- */ 39787c478bd9Sstevel@tonic-gate 39797c478bd9Sstevel@tonic-gate static void 39807c478bd9Sstevel@tonic-gate group_report(mib_item_t *item) 39817c478bd9Sstevel@tonic-gate { 39827c478bd9Sstevel@tonic-gate mib_item_t *v4grp = NULL, *v4src = NULL; 39837c478bd9Sstevel@tonic-gate mib_item_t *v6grp = NULL, *v6src = NULL; 39847c478bd9Sstevel@tonic-gate int jtemp = 0; 39857c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 39867c478bd9Sstevel@tonic-gate char abuf[MAXHOSTNAMELEN + 1]; 39877c478bd9Sstevel@tonic-gate ip_member_t *ipmp; 39887c478bd9Sstevel@tonic-gate ip_grpsrc_t *ips; 39897c478bd9Sstevel@tonic-gate ipv6_member_t *ipmp6; 39907c478bd9Sstevel@tonic-gate ipv6_grpsrc_t *ips6; 39917c478bd9Sstevel@tonic-gate boolean_t first, first_src; 39927c478bd9Sstevel@tonic-gate 39937c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 3994bd670b35SErik Nordmark if (Xflag) { 399578a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 39967c478bd9Sstevel@tonic-gate "length = %d, valp = 0x%p\n", 399778a2e113SAndy Fiddaman jtemp++, item->group, item->mib_id, item->length, 39987c478bd9Sstevel@tonic-gate item->valp); 39997c478bd9Sstevel@tonic-gate } 40007c478bd9Sstevel@tonic-gate if (item->group == MIB2_IP && family_selected(AF_INET)) { 40017c478bd9Sstevel@tonic-gate switch (item->mib_id) { 40027c478bd9Sstevel@tonic-gate case EXPER_IP_GROUP_MEMBERSHIP: 40037c478bd9Sstevel@tonic-gate v4grp = item; 4004bd670b35SErik Nordmark if (Xflag) 40057c478bd9Sstevel@tonic-gate (void) printf("item is v4grp info\n"); 40067c478bd9Sstevel@tonic-gate break; 40077c478bd9Sstevel@tonic-gate case EXPER_IP_GROUP_SOURCES: 40087c478bd9Sstevel@tonic-gate v4src = item; 4009bd670b35SErik Nordmark if (Xflag) 40107c478bd9Sstevel@tonic-gate (void) printf("item is v4src info\n"); 40117c478bd9Sstevel@tonic-gate break; 40127c478bd9Sstevel@tonic-gate default: 40137c478bd9Sstevel@tonic-gate continue; 40147c478bd9Sstevel@tonic-gate } 40157c478bd9Sstevel@tonic-gate continue; 40167c478bd9Sstevel@tonic-gate } 40177c478bd9Sstevel@tonic-gate if (item->group == MIB2_IP6 && family_selected(AF_INET6)) { 40187c478bd9Sstevel@tonic-gate switch (item->mib_id) { 40197c478bd9Sstevel@tonic-gate case EXPER_IP6_GROUP_MEMBERSHIP: 40207c478bd9Sstevel@tonic-gate v6grp = item; 4021bd670b35SErik Nordmark if (Xflag) 40227c478bd9Sstevel@tonic-gate (void) printf("item is v6grp info\n"); 40237c478bd9Sstevel@tonic-gate break; 40247c478bd9Sstevel@tonic-gate case EXPER_IP6_GROUP_SOURCES: 40257c478bd9Sstevel@tonic-gate v6src = item; 4026bd670b35SErik Nordmark if (Xflag) 40277c478bd9Sstevel@tonic-gate (void) printf("item is v6src info\n"); 40287c478bd9Sstevel@tonic-gate break; 40297c478bd9Sstevel@tonic-gate default: 40307c478bd9Sstevel@tonic-gate continue; 40317c478bd9Sstevel@tonic-gate } 40327c478bd9Sstevel@tonic-gate } 40337c478bd9Sstevel@tonic-gate } 40347c478bd9Sstevel@tonic-gate 40357c478bd9Sstevel@tonic-gate if (family_selected(AF_INET) && v4grp != NULL) { 4036bd670b35SErik Nordmark if (Xflag) 40377c478bd9Sstevel@tonic-gate (void) printf("%u records for ipGroupMember:\n", 40387c478bd9Sstevel@tonic-gate v4grp->length / sizeof (ip_member_t)); 40397c478bd9Sstevel@tonic-gate 40407c478bd9Sstevel@tonic-gate first = B_TRUE; 40417c478bd9Sstevel@tonic-gate for (ipmp = (ip_member_t *)v4grp->valp; 40427c478bd9Sstevel@tonic-gate (char *)ipmp < (char *)v4grp->valp + v4grp->length; 40437c478bd9Sstevel@tonic-gate ipmp = (ip_member_t *)((char *)ipmp + ipMemberEntrySize)) { 40447c478bd9Sstevel@tonic-gate if (first) { 40457c478bd9Sstevel@tonic-gate (void) puts(v4compat ? 40467c478bd9Sstevel@tonic-gate "Group Memberships" : 40477c478bd9Sstevel@tonic-gate "Group Memberships: IPv4"); 40487c478bd9Sstevel@tonic-gate (void) puts("Interface " 40497c478bd9Sstevel@tonic-gate "Group RefCnt"); 40507c478bd9Sstevel@tonic-gate (void) puts("--------- " 40517c478bd9Sstevel@tonic-gate "-------------------- ------"); 40527c478bd9Sstevel@tonic-gate first = B_FALSE; 40537c478bd9Sstevel@tonic-gate } 40547c478bd9Sstevel@tonic-gate 40557c478bd9Sstevel@tonic-gate (void) printf("%-9s %-20s %6u\n", 40567c478bd9Sstevel@tonic-gate octetstr(&ipmp->ipGroupMemberIfIndex, 'a', 40577c478bd9Sstevel@tonic-gate ifname, sizeof (ifname)), 40587c478bd9Sstevel@tonic-gate pr_addr(ipmp->ipGroupMemberAddress, 40597c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)), 40607c478bd9Sstevel@tonic-gate ipmp->ipGroupMemberRefCnt); 40617c478bd9Sstevel@tonic-gate 40627c478bd9Sstevel@tonic-gate if (!Vflag || v4src == NULL) 40637c478bd9Sstevel@tonic-gate continue; 40647c478bd9Sstevel@tonic-gate 4065bd670b35SErik Nordmark if (Xflag) 40667c478bd9Sstevel@tonic-gate (void) printf("scanning %u ipGroupSource " 40677c478bd9Sstevel@tonic-gate "records...\n", 40687c478bd9Sstevel@tonic-gate v4src->length/sizeof (ip_grpsrc_t)); 40697c478bd9Sstevel@tonic-gate 40707c478bd9Sstevel@tonic-gate first_src = B_TRUE; 40717c478bd9Sstevel@tonic-gate for (ips = (ip_grpsrc_t *)v4src->valp; 40727c478bd9Sstevel@tonic-gate (char *)ips < (char *)v4src->valp + v4src->length; 40737c478bd9Sstevel@tonic-gate ips = (ip_grpsrc_t *)((char *)ips + 40747c478bd9Sstevel@tonic-gate ipGroupSourceEntrySize)) { 40757c478bd9Sstevel@tonic-gate /* 40767c478bd9Sstevel@tonic-gate * We assume that all source addrs for a given 40777c478bd9Sstevel@tonic-gate * interface/group pair are contiguous, so on 40787c478bd9Sstevel@tonic-gate * the first non-match after we've found at 40797c478bd9Sstevel@tonic-gate * least one, we bail. 40807c478bd9Sstevel@tonic-gate */ 40817c478bd9Sstevel@tonic-gate if ((ipmp->ipGroupMemberAddress != 40827c478bd9Sstevel@tonic-gate ips->ipGroupSourceGroup) || 40837c478bd9Sstevel@tonic-gate (!octetstrmatch(&ipmp->ipGroupMemberIfIndex, 40847c478bd9Sstevel@tonic-gate &ips->ipGroupSourceIfIndex))) { 40857c478bd9Sstevel@tonic-gate if (first_src) 40867c478bd9Sstevel@tonic-gate continue; 40877c478bd9Sstevel@tonic-gate else 40887c478bd9Sstevel@tonic-gate break; 40897c478bd9Sstevel@tonic-gate } 40907c478bd9Sstevel@tonic-gate if (first_src) { 40917c478bd9Sstevel@tonic-gate (void) printf("\t%s: %s\n", 40927c478bd9Sstevel@tonic-gate fmodestr( 40937c478bd9Sstevel@tonic-gate ipmp->ipGroupMemberFilterMode), 40947c478bd9Sstevel@tonic-gate pr_addr(ips->ipGroupSourceAddress, 40957c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 40967c478bd9Sstevel@tonic-gate first_src = B_FALSE; 40977c478bd9Sstevel@tonic-gate continue; 40987c478bd9Sstevel@tonic-gate } 40997c478bd9Sstevel@tonic-gate 41007c478bd9Sstevel@tonic-gate (void) printf("\t %s\n", 41017c478bd9Sstevel@tonic-gate pr_addr(ips->ipGroupSourceAddress, abuf, 41027c478bd9Sstevel@tonic-gate sizeof (abuf))); 41037c478bd9Sstevel@tonic-gate } 41047c478bd9Sstevel@tonic-gate } 41057c478bd9Sstevel@tonic-gate (void) putchar('\n'); 41067c478bd9Sstevel@tonic-gate } 41077c478bd9Sstevel@tonic-gate 41087c478bd9Sstevel@tonic-gate if (family_selected(AF_INET6) && v6grp != NULL) { 4109bd670b35SErik Nordmark if (Xflag) 41107c478bd9Sstevel@tonic-gate (void) printf("%u records for ipv6GroupMember:\n", 41117c478bd9Sstevel@tonic-gate v6grp->length / sizeof (ipv6_member_t)); 41127c478bd9Sstevel@tonic-gate 41137c478bd9Sstevel@tonic-gate first = B_TRUE; 41147c478bd9Sstevel@tonic-gate for (ipmp6 = (ipv6_member_t *)v6grp->valp; 41157c478bd9Sstevel@tonic-gate (char *)ipmp6 < (char *)v6grp->valp + v6grp->length; 41167c478bd9Sstevel@tonic-gate ipmp6 = (ipv6_member_t *)((char *)ipmp6 + 4117e11c3f44Smeem ipv6MemberEntrySize)) { 41187c478bd9Sstevel@tonic-gate if (first) { 41197c478bd9Sstevel@tonic-gate (void) puts("Group Memberships: " 41207c478bd9Sstevel@tonic-gate "IPv6"); 41217c478bd9Sstevel@tonic-gate (void) puts(" If " 41227c478bd9Sstevel@tonic-gate "Group RefCnt"); 41237c478bd9Sstevel@tonic-gate (void) puts("----- " 41247c478bd9Sstevel@tonic-gate "--------------------------- ------"); 41257c478bd9Sstevel@tonic-gate first = B_FALSE; 41267c478bd9Sstevel@tonic-gate } 41277c478bd9Sstevel@tonic-gate 41287c478bd9Sstevel@tonic-gate (void) printf("%-5s %-27s %5u\n", 4129e11c3f44Smeem ifindex2str(ipmp6->ipv6GroupMemberIfIndex, ifname), 41307c478bd9Sstevel@tonic-gate pr_addr6(&ipmp6->ipv6GroupMemberAddress, 41317c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)), 41327c478bd9Sstevel@tonic-gate ipmp6->ipv6GroupMemberRefCnt); 41337c478bd9Sstevel@tonic-gate 41347c478bd9Sstevel@tonic-gate if (!Vflag || v6src == NULL) 41357c478bd9Sstevel@tonic-gate continue; 41367c478bd9Sstevel@tonic-gate 4137bd670b35SErik Nordmark if (Xflag) 41387c478bd9Sstevel@tonic-gate (void) printf("scanning %u ipv6GroupSource " 41397c478bd9Sstevel@tonic-gate "records...\n", 41407c478bd9Sstevel@tonic-gate v6src->length/sizeof (ipv6_grpsrc_t)); 41417c478bd9Sstevel@tonic-gate 41427c478bd9Sstevel@tonic-gate first_src = B_TRUE; 41437c478bd9Sstevel@tonic-gate for (ips6 = (ipv6_grpsrc_t *)v6src->valp; 41447c478bd9Sstevel@tonic-gate (char *)ips6 < (char *)v6src->valp + v6src->length; 41457c478bd9Sstevel@tonic-gate ips6 = (ipv6_grpsrc_t *)((char *)ips6 + 41467c478bd9Sstevel@tonic-gate ipv6GroupSourceEntrySize)) { 41477c478bd9Sstevel@tonic-gate /* same assumption as in the v4 case above */ 41487c478bd9Sstevel@tonic-gate if ((ipmp6->ipv6GroupMemberIfIndex != 41497c478bd9Sstevel@tonic-gate ips6->ipv6GroupSourceIfIndex) || 41507c478bd9Sstevel@tonic-gate (!IN6_ARE_ADDR_EQUAL( 41517c478bd9Sstevel@tonic-gate &ipmp6->ipv6GroupMemberAddress, 41527c478bd9Sstevel@tonic-gate &ips6->ipv6GroupSourceGroup))) { 41537c478bd9Sstevel@tonic-gate if (first_src) 41547c478bd9Sstevel@tonic-gate continue; 41557c478bd9Sstevel@tonic-gate else 41567c478bd9Sstevel@tonic-gate break; 41577c478bd9Sstevel@tonic-gate } 41587c478bd9Sstevel@tonic-gate if (first_src) { 41597c478bd9Sstevel@tonic-gate (void) printf("\t%s: %s\n", 41607c478bd9Sstevel@tonic-gate fmodestr( 41617c478bd9Sstevel@tonic-gate ipmp6->ipv6GroupMemberFilterMode), 41627c478bd9Sstevel@tonic-gate pr_addr6( 41637c478bd9Sstevel@tonic-gate &ips6->ipv6GroupSourceAddress, 41647c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 41657c478bd9Sstevel@tonic-gate first_src = B_FALSE; 41667c478bd9Sstevel@tonic-gate continue; 41677c478bd9Sstevel@tonic-gate } 41687c478bd9Sstevel@tonic-gate 41697c478bd9Sstevel@tonic-gate (void) printf("\t %s\n", 41707c478bd9Sstevel@tonic-gate pr_addr6(&ips6->ipv6GroupSourceAddress, 41717c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 41727c478bd9Sstevel@tonic-gate } 41737c478bd9Sstevel@tonic-gate } 41747c478bd9Sstevel@tonic-gate (void) putchar('\n'); 41757c478bd9Sstevel@tonic-gate } 41767c478bd9Sstevel@tonic-gate 41777c478bd9Sstevel@tonic-gate (void) putchar('\n'); 41787c478bd9Sstevel@tonic-gate (void) fflush(stdout); 41797c478bd9Sstevel@tonic-gate } 41807c478bd9Sstevel@tonic-gate 4181bd670b35SErik Nordmark /* --------------------- DCE_REPORT (netstat -d) ------------------------- */ 4182bd670b35SErik Nordmark 4183bd670b35SErik Nordmark #define FLBUFSIZE 8 4184bd670b35SErik Nordmark 4185bd670b35SErik Nordmark /* Assumes flbuf is at least 5 characters; callers use FLBUFSIZE */ 4186bd670b35SErik Nordmark static char * 4187bd670b35SErik Nordmark dceflags2str(uint32_t flags, char *flbuf) 4188bd670b35SErik Nordmark { 4189bd670b35SErik Nordmark char *str = flbuf; 4190bd670b35SErik Nordmark 4191bd670b35SErik Nordmark if (flags & DCEF_DEFAULT) 4192bd670b35SErik Nordmark *str++ = 'D'; 4193bd670b35SErik Nordmark if (flags & DCEF_PMTU) 4194bd670b35SErik Nordmark *str++ = 'P'; 4195bd670b35SErik Nordmark if (flags & DCEF_UINFO) 4196bd670b35SErik Nordmark *str++ = 'U'; 4197bd670b35SErik Nordmark if (flags & DCEF_TOO_SMALL_PMTU) 4198bd670b35SErik Nordmark *str++ = 'S'; 4199bd670b35SErik Nordmark *str++ = '\0'; 4200bd670b35SErik Nordmark return (flbuf); 4201bd670b35SErik Nordmark } 4202bd670b35SErik Nordmark 4203bd670b35SErik Nordmark static void 4204bd670b35SErik Nordmark dce_report(mib_item_t *item) 4205bd670b35SErik Nordmark { 4206bd670b35SErik Nordmark mib_item_t *v4dce = NULL; 4207bd670b35SErik Nordmark mib_item_t *v6dce = NULL; 4208bd670b35SErik Nordmark int jtemp = 0; 4209bd670b35SErik Nordmark char ifname[LIFNAMSIZ + 1]; 4210bd670b35SErik Nordmark char abuf[MAXHOSTNAMELEN + 1]; 4211bd670b35SErik Nordmark char flbuf[FLBUFSIZE]; 4212bd670b35SErik Nordmark boolean_t first; 4213bd670b35SErik Nordmark dest_cache_entry_t *dce; 4214bd670b35SErik Nordmark 4215bd670b35SErik Nordmark for (; item; item = item->next_item) { 4216bd670b35SErik Nordmark if (Xflag) { 421778a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 421878a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 4219bd670b35SErik Nordmark item->group, item->mib_id, item->length, 4220bd670b35SErik Nordmark item->valp); 4221bd670b35SErik Nordmark } 4222bd670b35SErik Nordmark if (item->group == MIB2_IP && family_selected(AF_INET) && 4223bd670b35SErik Nordmark item->mib_id == EXPER_IP_DCE) { 4224bd670b35SErik Nordmark v4dce = item; 4225bd670b35SErik Nordmark if (Xflag) 4226bd670b35SErik Nordmark (void) printf("item is v4dce info\n"); 4227bd670b35SErik Nordmark } 4228bd670b35SErik Nordmark if (item->group == MIB2_IP6 && family_selected(AF_INET6) && 4229bd670b35SErik Nordmark item->mib_id == EXPER_IP_DCE) { 4230bd670b35SErik Nordmark v6dce = item; 4231bd670b35SErik Nordmark if (Xflag) 4232bd670b35SErik Nordmark (void) printf("item is v6dce info\n"); 4233bd670b35SErik Nordmark } 4234bd670b35SErik Nordmark } 4235bd670b35SErik Nordmark 4236bd670b35SErik Nordmark if (family_selected(AF_INET) && v4dce != NULL) { 4237bd670b35SErik Nordmark if (Xflag) 4238bd670b35SErik Nordmark (void) printf("%u records for DestCacheEntry:\n", 4239bd670b35SErik Nordmark v4dce->length / ipDestEntrySize); 4240bd670b35SErik Nordmark 4241bd670b35SErik Nordmark first = B_TRUE; 4242bd670b35SErik Nordmark for (dce = (dest_cache_entry_t *)v4dce->valp; 4243bd670b35SErik Nordmark (char *)dce < (char *)v4dce->valp + v4dce->length; 4244bd670b35SErik Nordmark dce = (dest_cache_entry_t *)((char *)dce + 4245bd670b35SErik Nordmark ipDestEntrySize)) { 4246bd670b35SErik Nordmark if (first) { 4247bd670b35SErik Nordmark (void) putchar('\n'); 4248bd670b35SErik Nordmark (void) puts("Destination Cache Entries: IPv4"); 4249bd670b35SErik Nordmark (void) puts( 4250bd670b35SErik Nordmark "Address PMTU Age Flags"); 4251bd670b35SErik Nordmark (void) puts( 4252bd670b35SErik Nordmark "-------------------- ------ ----- -----"); 4253bd670b35SErik Nordmark first = B_FALSE; 4254bd670b35SErik Nordmark } 4255bd670b35SErik Nordmark 4256bd670b35SErik Nordmark (void) printf("%-20s %6u %5u %-5s\n", 4257bd670b35SErik Nordmark pr_addr(dce->DestIpv4Address, abuf, sizeof (abuf)), 4258bd670b35SErik Nordmark dce->DestPmtu, dce->DestAge, 4259bd670b35SErik Nordmark dceflags2str(dce->DestFlags, flbuf)); 4260bd670b35SErik Nordmark } 4261bd670b35SErik Nordmark } 4262bd670b35SErik Nordmark 4263bd670b35SErik Nordmark if (family_selected(AF_INET6) && v6dce != NULL) { 4264bd670b35SErik Nordmark if (Xflag) 4265bd670b35SErik Nordmark (void) printf("%u records for DestCacheEntry:\n", 4266bd670b35SErik Nordmark v6dce->length / ipDestEntrySize); 4267bd670b35SErik Nordmark 4268bd670b35SErik Nordmark first = B_TRUE; 4269bd670b35SErik Nordmark for (dce = (dest_cache_entry_t *)v6dce->valp; 4270bd670b35SErik Nordmark (char *)dce < (char *)v6dce->valp + v6dce->length; 4271bd670b35SErik Nordmark dce = (dest_cache_entry_t *)((char *)dce + 4272bd670b35SErik Nordmark ipDestEntrySize)) { 4273bd670b35SErik Nordmark if (first) { 4274bd670b35SErik Nordmark (void) putchar('\n'); 4275bd670b35SErik Nordmark (void) puts("Destination Cache Entries: IPv6"); 4276bd670b35SErik Nordmark (void) puts( 4277bd670b35SErik Nordmark "Address PMTU " 4278bd670b35SErik Nordmark " Age Flags If "); 4279bd670b35SErik Nordmark (void) puts( 4280bd670b35SErik Nordmark "--------------------------- ------ " 4281bd670b35SErik Nordmark "----- ----- ---"); 4282bd670b35SErik Nordmark first = B_FALSE; 4283bd670b35SErik Nordmark } 4284bd670b35SErik Nordmark 4285bd670b35SErik Nordmark (void) printf("%-27s %6u %5u %-5s %s\n", 4286bd670b35SErik Nordmark pr_addr6(&dce->DestIpv6Address, abuf, 4287bd670b35SErik Nordmark sizeof (abuf)), 4288bd670b35SErik Nordmark dce->DestPmtu, dce->DestAge, 4289bd670b35SErik Nordmark dceflags2str(dce->DestFlags, flbuf), 4290bd670b35SErik Nordmark dce->DestIfindex == 0 ? "" : 4291bd670b35SErik Nordmark ifindex2str(dce->DestIfindex, ifname)); 4292bd670b35SErik Nordmark } 4293bd670b35SErik Nordmark } 4294bd670b35SErik Nordmark (void) fflush(stdout); 4295bd670b35SErik Nordmark } 4296bd670b35SErik Nordmark 42977c478bd9Sstevel@tonic-gate /* --------------------- ARP_REPORT (netstat -p) -------------------------- */ 42987c478bd9Sstevel@tonic-gate 42997c478bd9Sstevel@tonic-gate static void 43007c478bd9Sstevel@tonic-gate arp_report(mib_item_t *item) 43017c478bd9Sstevel@tonic-gate { 43027c478bd9Sstevel@tonic-gate int jtemp = 0; 43037c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 43047c478bd9Sstevel@tonic-gate char abuf[MAXHOSTNAMELEN + 1]; 43057c478bd9Sstevel@tonic-gate char maskbuf[STR_EXPAND * OCTET_LENGTH + 1]; 43067c478bd9Sstevel@tonic-gate char flbuf[32]; /* ACE_F_ flags */ 43077c478bd9Sstevel@tonic-gate char xbuf[STR_EXPAND * OCTET_LENGTH + 1]; 43087c478bd9Sstevel@tonic-gate mib2_ipNetToMediaEntry_t *np; 43097c478bd9Sstevel@tonic-gate int flags; 43107c478bd9Sstevel@tonic-gate boolean_t first; 43117c478bd9Sstevel@tonic-gate 43127c478bd9Sstevel@tonic-gate if (!(family_selected(AF_INET))) 43137c478bd9Sstevel@tonic-gate return; 43147c478bd9Sstevel@tonic-gate 43157c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 4316bd670b35SErik Nordmark if (Xflag) { 431778a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 431878a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 43197c478bd9Sstevel@tonic-gate item->group, item->mib_id, item->length, 43207c478bd9Sstevel@tonic-gate item->valp); 43217c478bd9Sstevel@tonic-gate } 43227c478bd9Sstevel@tonic-gate if (!(item->group == MIB2_IP && item->mib_id == MIB2_IP_MEDIA)) 432378a2e113SAndy Fiddaman continue; 43247c478bd9Sstevel@tonic-gate 4325bd670b35SErik Nordmark if (Xflag) 43267c478bd9Sstevel@tonic-gate (void) printf("%u records for " 43277c478bd9Sstevel@tonic-gate "ipNetToMediaEntryTable:\n", 43287c478bd9Sstevel@tonic-gate item->length/sizeof (mib2_ipNetToMediaEntry_t)); 43297c478bd9Sstevel@tonic-gate 43307c478bd9Sstevel@tonic-gate first = B_TRUE; 43317c478bd9Sstevel@tonic-gate for (np = (mib2_ipNetToMediaEntry_t *)item->valp; 43327c478bd9Sstevel@tonic-gate (char *)np < (char *)item->valp + item->length; 43337c478bd9Sstevel@tonic-gate np = (mib2_ipNetToMediaEntry_t *)((char *)np + 43347c478bd9Sstevel@tonic-gate ipNetToMediaEntrySize)) { 43357c478bd9Sstevel@tonic-gate if (first) { 43367c478bd9Sstevel@tonic-gate (void) puts(v4compat ? 43377c478bd9Sstevel@tonic-gate "Net to Media Table" : 43387c478bd9Sstevel@tonic-gate "Net to Media Table: IPv4"); 433969bb4bb4Scarlsonj (void) puts("Device " 434069bb4bb4Scarlsonj " IP Address Mask " 434169bb4bb4Scarlsonj "Flags Phys Addr"); 434269bb4bb4Scarlsonj (void) puts("------ " 434369bb4bb4Scarlsonj "-------------------- --------------- " 434469bb4bb4Scarlsonj "-------- ---------------"); 43457c478bd9Sstevel@tonic-gate first = B_FALSE; 43467c478bd9Sstevel@tonic-gate } 43477c478bd9Sstevel@tonic-gate 43487c478bd9Sstevel@tonic-gate flbuf[0] = '\0'; 43497c478bd9Sstevel@tonic-gate flags = np->ipNetToMediaInfo.ntm_flags; 435069bb4bb4Scarlsonj /* 435169bb4bb4Scarlsonj * Note that not all flags are possible at the same 435269bb4bb4Scarlsonj * time. Patterns: SPLAy DUo 435369bb4bb4Scarlsonj */ 43547c478bd9Sstevel@tonic-gate if (flags & ACE_F_PERMANENT) 43557c478bd9Sstevel@tonic-gate (void) strcat(flbuf, "S"); 43567c478bd9Sstevel@tonic-gate if (flags & ACE_F_PUBLISH) 43577c478bd9Sstevel@tonic-gate (void) strcat(flbuf, "P"); 43587c478bd9Sstevel@tonic-gate if (flags & ACE_F_DYING) 43597c478bd9Sstevel@tonic-gate (void) strcat(flbuf, "D"); 43607c478bd9Sstevel@tonic-gate if (!(flags & ACE_F_RESOLVED)) 43617c478bd9Sstevel@tonic-gate (void) strcat(flbuf, "U"); 43627c478bd9Sstevel@tonic-gate if (flags & ACE_F_MAPPING) 43637c478bd9Sstevel@tonic-gate (void) strcat(flbuf, "M"); 436469bb4bb4Scarlsonj if (flags & ACE_F_MYADDR) 436569bb4bb4Scarlsonj (void) strcat(flbuf, "L"); 436669bb4bb4Scarlsonj if (flags & ACE_F_UNVERIFIED) 436769bb4bb4Scarlsonj (void) strcat(flbuf, "d"); 436869bb4bb4Scarlsonj if (flags & ACE_F_AUTHORITY) 436969bb4bb4Scarlsonj (void) strcat(flbuf, "A"); 437069bb4bb4Scarlsonj if (flags & ACE_F_OLD) 437169bb4bb4Scarlsonj (void) strcat(flbuf, "o"); 437269bb4bb4Scarlsonj if (flags & ACE_F_DELAYED) 437369bb4bb4Scarlsonj (void) strcat(flbuf, "y"); 437469bb4bb4Scarlsonj (void) printf("%-6s %-20s %-15s %-8s %s\n", 43757c478bd9Sstevel@tonic-gate octetstr(&np->ipNetToMediaIfIndex, 'a', 43767c478bd9Sstevel@tonic-gate ifname, sizeof (ifname)), 43777c478bd9Sstevel@tonic-gate pr_addr(np->ipNetToMediaNetAddress, 43787c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)), 43797c478bd9Sstevel@tonic-gate octetstr(&np->ipNetToMediaInfo.ntm_mask, 'd', 43807c478bd9Sstevel@tonic-gate maskbuf, sizeof (maskbuf)), 43817c478bd9Sstevel@tonic-gate flbuf, 43827c478bd9Sstevel@tonic-gate octetstr(&np->ipNetToMediaPhysAddress, 'h', 43837c478bd9Sstevel@tonic-gate xbuf, sizeof (xbuf))); 438478a2e113SAndy Fiddaman } 438578a2e113SAndy Fiddaman } 43867c478bd9Sstevel@tonic-gate (void) fflush(stdout); 43877c478bd9Sstevel@tonic-gate } 43887c478bd9Sstevel@tonic-gate 43897c478bd9Sstevel@tonic-gate /* --------------------- NDP_REPORT (netstat -p) -------------------------- */ 43907c478bd9Sstevel@tonic-gate 43917c478bd9Sstevel@tonic-gate static void 43927c478bd9Sstevel@tonic-gate ndp_report(mib_item_t *item) 43937c478bd9Sstevel@tonic-gate { 43947c478bd9Sstevel@tonic-gate int jtemp = 0; 43957c478bd9Sstevel@tonic-gate char abuf[MAXHOSTNAMELEN + 1]; 43967c478bd9Sstevel@tonic-gate char *state; 43977c478bd9Sstevel@tonic-gate char *type; 43987c478bd9Sstevel@tonic-gate char xbuf[STR_EXPAND * OCTET_LENGTH + 1]; 43997c478bd9Sstevel@tonic-gate mib2_ipv6NetToMediaEntry_t *np6; 44007c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 44017c478bd9Sstevel@tonic-gate boolean_t first; 44027c478bd9Sstevel@tonic-gate 44037c478bd9Sstevel@tonic-gate if (!(family_selected(AF_INET6))) 44047c478bd9Sstevel@tonic-gate return; 44057c478bd9Sstevel@tonic-gate 44067c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 4407bd670b35SErik Nordmark if (Xflag) { 44087c478bd9Sstevel@tonic-gate (void) printf("\n--- Entry %d ---\n", ++jtemp); 44097c478bd9Sstevel@tonic-gate (void) printf("Group = %d, mib_id = %d, " 44107c478bd9Sstevel@tonic-gate "length = %d, valp = 0x%p\n", 44117c478bd9Sstevel@tonic-gate item->group, item->mib_id, item->length, 44127c478bd9Sstevel@tonic-gate item->valp); 44137c478bd9Sstevel@tonic-gate } 44147c478bd9Sstevel@tonic-gate if (!(item->group == MIB2_IP6 && 44157c478bd9Sstevel@tonic-gate item->mib_id == MIB2_IP6_MEDIA)) 441678a2e113SAndy Fiddaman continue; 44177c478bd9Sstevel@tonic-gate 44187c478bd9Sstevel@tonic-gate first = B_TRUE; 44197c478bd9Sstevel@tonic-gate for (np6 = (mib2_ipv6NetToMediaEntry_t *)item->valp; 44207c478bd9Sstevel@tonic-gate (char *)np6 < (char *)item->valp + item->length; 44217c478bd9Sstevel@tonic-gate np6 = (mib2_ipv6NetToMediaEntry_t *)((char *)np6 + 44227c478bd9Sstevel@tonic-gate ipv6NetToMediaEntrySize)) { 44237c478bd9Sstevel@tonic-gate if (first) { 44247c478bd9Sstevel@tonic-gate (void) puts("\nNet to Media Table: IPv6"); 44257c478bd9Sstevel@tonic-gate (void) puts(" If Physical Address " 44267c478bd9Sstevel@tonic-gate " Type State Destination/Mask"); 44277c478bd9Sstevel@tonic-gate (void) puts("----- ----------------- " 44287c478bd9Sstevel@tonic-gate "------- ------------ " 44297c478bd9Sstevel@tonic-gate "---------------------------"); 44307c478bd9Sstevel@tonic-gate first = B_FALSE; 44317c478bd9Sstevel@tonic-gate } 44327c478bd9Sstevel@tonic-gate 44337c478bd9Sstevel@tonic-gate switch (np6->ipv6NetToMediaState) { 44347c478bd9Sstevel@tonic-gate case ND_INCOMPLETE: 44357c478bd9Sstevel@tonic-gate state = "INCOMPLETE"; 44367c478bd9Sstevel@tonic-gate break; 44377c478bd9Sstevel@tonic-gate case ND_REACHABLE: 44387c478bd9Sstevel@tonic-gate state = "REACHABLE"; 44397c478bd9Sstevel@tonic-gate break; 44407c478bd9Sstevel@tonic-gate case ND_STALE: 44417c478bd9Sstevel@tonic-gate state = "STALE"; 44427c478bd9Sstevel@tonic-gate break; 44437c478bd9Sstevel@tonic-gate case ND_DELAY: 44447c478bd9Sstevel@tonic-gate state = "DELAY"; 44457c478bd9Sstevel@tonic-gate break; 44467c478bd9Sstevel@tonic-gate case ND_PROBE: 44477c478bd9Sstevel@tonic-gate state = "PROBE"; 44487c478bd9Sstevel@tonic-gate break; 44497c478bd9Sstevel@tonic-gate case ND_UNREACHABLE: 44507c478bd9Sstevel@tonic-gate state = "UNREACHABLE"; 44517c478bd9Sstevel@tonic-gate break; 44527c478bd9Sstevel@tonic-gate default: 44537c478bd9Sstevel@tonic-gate state = "UNKNOWN"; 44547c478bd9Sstevel@tonic-gate } 44557c478bd9Sstevel@tonic-gate 44567c478bd9Sstevel@tonic-gate switch (np6->ipv6NetToMediaType) { 44577c478bd9Sstevel@tonic-gate case 1: 44587c478bd9Sstevel@tonic-gate type = "other"; 44597c478bd9Sstevel@tonic-gate break; 44607c478bd9Sstevel@tonic-gate case 2: 44617c478bd9Sstevel@tonic-gate type = "dynamic"; 44627c478bd9Sstevel@tonic-gate break; 44637c478bd9Sstevel@tonic-gate case 3: 44647c478bd9Sstevel@tonic-gate type = "static"; 44657c478bd9Sstevel@tonic-gate break; 44667c478bd9Sstevel@tonic-gate case 4: 44677c478bd9Sstevel@tonic-gate type = "local"; 44687c478bd9Sstevel@tonic-gate break; 446978a2e113SAndy Fiddaman default: 447078a2e113SAndy Fiddaman type = "UNKNOWN"; 44717c478bd9Sstevel@tonic-gate } 44727c478bd9Sstevel@tonic-gate (void) printf("%-5s %-17s %-7s %-12s %-27s\n", 4473e11c3f44Smeem ifindex2str(np6->ipv6NetToMediaIfIndex, ifname), 44747c478bd9Sstevel@tonic-gate octetstr(&np6->ipv6NetToMediaPhysAddress, 'h', 44757c478bd9Sstevel@tonic-gate xbuf, sizeof (xbuf)), 44767c478bd9Sstevel@tonic-gate type, 44777c478bd9Sstevel@tonic-gate state, 44787c478bd9Sstevel@tonic-gate pr_addr6(&np6->ipv6NetToMediaNetAddress, 44797c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 448078a2e113SAndy Fiddaman } 448178a2e113SAndy Fiddaman } 44827c478bd9Sstevel@tonic-gate (void) putchar('\n'); 44837c478bd9Sstevel@tonic-gate (void) fflush(stdout); 44847c478bd9Sstevel@tonic-gate } 44857c478bd9Sstevel@tonic-gate 44867c478bd9Sstevel@tonic-gate /* ------------------------- ire_report (netstat -r) ------------------------ */ 44877c478bd9Sstevel@tonic-gate 448845916cd2Sjpk typedef struct sec_attr_list_s { 448945916cd2Sjpk struct sec_attr_list_s *sal_next; 449045916cd2Sjpk const mib2_ipAttributeEntry_t *sal_attr; 449145916cd2Sjpk } sec_attr_list_t; 449245916cd2Sjpk 449345916cd2Sjpk static boolean_t ire_report_item_v4(const mib2_ipRouteEntry_t *, boolean_t, 449445916cd2Sjpk const sec_attr_list_t *); 449545916cd2Sjpk static boolean_t ire_report_item_v6(const mib2_ipv6RouteEntry_t *, boolean_t, 449645916cd2Sjpk const sec_attr_list_t *); 449745916cd2Sjpk static const char *pr_secattr(const sec_attr_list_t *); 44987c478bd9Sstevel@tonic-gate 44997c478bd9Sstevel@tonic-gate static void 450045916cd2Sjpk ire_report(const mib_item_t *item) 45017c478bd9Sstevel@tonic-gate { 45027c478bd9Sstevel@tonic-gate int jtemp = 0; 45037c478bd9Sstevel@tonic-gate boolean_t print_hdr_once_v4 = B_TRUE; 45047c478bd9Sstevel@tonic-gate boolean_t print_hdr_once_v6 = B_TRUE; 45057c478bd9Sstevel@tonic-gate mib2_ipRouteEntry_t *rp; 45067c478bd9Sstevel@tonic-gate mib2_ipv6RouteEntry_t *rp6; 450745916cd2Sjpk sec_attr_list_t **v4_attrs, **v4a; 450845916cd2Sjpk sec_attr_list_t **v6_attrs, **v6a; 450945916cd2Sjpk sec_attr_list_t *all_attrs, *aptr; 451045916cd2Sjpk const mib_item_t *iptr; 451145916cd2Sjpk int ipv4_route_count, ipv6_route_count; 451245916cd2Sjpk int route_attrs_count; 451345916cd2Sjpk 451445916cd2Sjpk /* 451545916cd2Sjpk * Preparation pass: the kernel returns separate entries for IP routing 451645916cd2Sjpk * table entries and security attributes. We loop through the 451745916cd2Sjpk * attributes first and link them into lists. 451845916cd2Sjpk */ 451945916cd2Sjpk ipv4_route_count = ipv6_route_count = route_attrs_count = 0; 452045916cd2Sjpk for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 452145916cd2Sjpk if (iptr->group == MIB2_IP6 && iptr->mib_id == MIB2_IP6_ROUTE) 452245916cd2Sjpk ipv6_route_count += iptr->length / ipv6RouteEntrySize; 452345916cd2Sjpk if (iptr->group == MIB2_IP && iptr->mib_id == MIB2_IP_ROUTE) 452445916cd2Sjpk ipv4_route_count += iptr->length / ipRouteEntrySize; 452545916cd2Sjpk if ((iptr->group == MIB2_IP || iptr->group == MIB2_IP6) && 452645916cd2Sjpk iptr->mib_id == EXPER_IP_RTATTR) 452745916cd2Sjpk route_attrs_count += iptr->length / 452845916cd2Sjpk ipRouteAttributeSize; 452945916cd2Sjpk } 453045916cd2Sjpk v4_attrs = v6_attrs = NULL; 453145916cd2Sjpk all_attrs = NULL; 453245916cd2Sjpk if (family_selected(AF_INET) && ipv4_route_count > 0) { 453345916cd2Sjpk v4_attrs = calloc(ipv4_route_count, sizeof (*v4_attrs)); 453445916cd2Sjpk if (v4_attrs == NULL) { 453545916cd2Sjpk perror("ire_report calloc v4_attrs failed"); 453645916cd2Sjpk return; 453745916cd2Sjpk } 453845916cd2Sjpk } 453945916cd2Sjpk if (family_selected(AF_INET6) && ipv6_route_count > 0) { 454045916cd2Sjpk v6_attrs = calloc(ipv6_route_count, sizeof (*v6_attrs)); 454145916cd2Sjpk if (v6_attrs == NULL) { 454245916cd2Sjpk perror("ire_report calloc v6_attrs failed"); 454345916cd2Sjpk goto ire_report_done; 454445916cd2Sjpk } 454545916cd2Sjpk } 454645916cd2Sjpk if (route_attrs_count > 0) { 454745916cd2Sjpk all_attrs = malloc(route_attrs_count * sizeof (*all_attrs)); 454845916cd2Sjpk if (all_attrs == NULL) { 454945916cd2Sjpk perror("ire_report malloc all_attrs failed"); 455045916cd2Sjpk goto ire_report_done; 455145916cd2Sjpk } 455245916cd2Sjpk } 455345916cd2Sjpk aptr = all_attrs; 455445916cd2Sjpk for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 455545916cd2Sjpk mib2_ipAttributeEntry_t *iae; 455645916cd2Sjpk sec_attr_list_t **alp; 455745916cd2Sjpk 455845916cd2Sjpk if (v4_attrs != NULL && iptr->group == MIB2_IP && 455945916cd2Sjpk iptr->mib_id == EXPER_IP_RTATTR) { 456045916cd2Sjpk alp = v4_attrs; 456145916cd2Sjpk } else if (v6_attrs != NULL && iptr->group == MIB2_IP6 && 456245916cd2Sjpk iptr->mib_id == EXPER_IP_RTATTR) { 456345916cd2Sjpk alp = v6_attrs; 456445916cd2Sjpk } else { 456545916cd2Sjpk continue; 456645916cd2Sjpk } 456745916cd2Sjpk for (iae = iptr->valp; 456845916cd2Sjpk (char *)iae < (char *)iptr->valp + iptr->length; 456945916cd2Sjpk iae = (mib2_ipAttributeEntry_t *)((char *)iae + 457045916cd2Sjpk ipRouteAttributeSize)) { 457145916cd2Sjpk aptr->sal_next = alp[iae->iae_routeidx]; 457245916cd2Sjpk aptr->sal_attr = iae; 457345916cd2Sjpk alp[iae->iae_routeidx] = aptr++; 457445916cd2Sjpk } 457545916cd2Sjpk } 45767c478bd9Sstevel@tonic-gate 457745916cd2Sjpk v4a = v4_attrs; 457845916cd2Sjpk v6a = v6_attrs; 457945916cd2Sjpk for (; item != NULL; item = item->next_item) { 4580bd670b35SErik Nordmark if (Xflag) { 458178a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 458278a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 45837c478bd9Sstevel@tonic-gate item->group, item->mib_id, 45847c478bd9Sstevel@tonic-gate item->length, item->valp); 45857c478bd9Sstevel@tonic-gate } 45867c478bd9Sstevel@tonic-gate if (!((item->group == MIB2_IP && 45877c478bd9Sstevel@tonic-gate item->mib_id == MIB2_IP_ROUTE) || 45887c478bd9Sstevel@tonic-gate (item->group == MIB2_IP6 && 45897c478bd9Sstevel@tonic-gate item->mib_id == MIB2_IP6_ROUTE))) 459078a2e113SAndy Fiddaman continue; 45917c478bd9Sstevel@tonic-gate 45927c478bd9Sstevel@tonic-gate if (item->group == MIB2_IP && !family_selected(AF_INET)) 459378a2e113SAndy Fiddaman continue; 45947c478bd9Sstevel@tonic-gate else if (item->group == MIB2_IP6 && !family_selected(AF_INET6)) 459578a2e113SAndy Fiddaman continue; 45967c478bd9Sstevel@tonic-gate 4597bd670b35SErik Nordmark if (Xflag) { 45987c478bd9Sstevel@tonic-gate if (item->group == MIB2_IP) { 45997c478bd9Sstevel@tonic-gate (void) printf("%u records for " 46007c478bd9Sstevel@tonic-gate "ipRouteEntryTable:\n", 46017c478bd9Sstevel@tonic-gate item->length/sizeof (mib2_ipRouteEntry_t)); 46027c478bd9Sstevel@tonic-gate } else { 46037c478bd9Sstevel@tonic-gate (void) printf("%u records for " 46047c478bd9Sstevel@tonic-gate "ipv6RouteEntryTable:\n", 46057c478bd9Sstevel@tonic-gate item->length/ 46067c478bd9Sstevel@tonic-gate sizeof (mib2_ipv6RouteEntry_t)); 46077c478bd9Sstevel@tonic-gate } 46087c478bd9Sstevel@tonic-gate } 46097c478bd9Sstevel@tonic-gate 46107c478bd9Sstevel@tonic-gate if (item->group == MIB2_IP) { 46117c478bd9Sstevel@tonic-gate for (rp = (mib2_ipRouteEntry_t *)item->valp; 46127c478bd9Sstevel@tonic-gate (char *)rp < (char *)item->valp + item->length; 46137c478bd9Sstevel@tonic-gate rp = (mib2_ipRouteEntry_t *)((char *)rp + 46147c478bd9Sstevel@tonic-gate ipRouteEntrySize)) { 461545916cd2Sjpk aptr = v4a == NULL ? NULL : *v4a++; 46167c478bd9Sstevel@tonic-gate print_hdr_once_v4 = ire_report_item_v4(rp, 461745916cd2Sjpk print_hdr_once_v4, aptr); 46187c478bd9Sstevel@tonic-gate } 46197c478bd9Sstevel@tonic-gate } else { 46207c478bd9Sstevel@tonic-gate for (rp6 = (mib2_ipv6RouteEntry_t *)item->valp; 46217c478bd9Sstevel@tonic-gate (char *)rp6 < (char *)item->valp + item->length; 46227c478bd9Sstevel@tonic-gate rp6 = (mib2_ipv6RouteEntry_t *)((char *)rp6 + 46237c478bd9Sstevel@tonic-gate ipv6RouteEntrySize)) { 462445916cd2Sjpk aptr = v6a == NULL ? NULL : *v6a++; 46257c478bd9Sstevel@tonic-gate print_hdr_once_v6 = ire_report_item_v6(rp6, 462645916cd2Sjpk print_hdr_once_v6, aptr); 46277c478bd9Sstevel@tonic-gate } 46287c478bd9Sstevel@tonic-gate } 462978a2e113SAndy Fiddaman } 46307c478bd9Sstevel@tonic-gate (void) fflush(stdout); 463145916cd2Sjpk ire_report_done: 463245916cd2Sjpk if (v4_attrs != NULL) 463345916cd2Sjpk free(v4_attrs); 463445916cd2Sjpk if (v6_attrs != NULL) 463545916cd2Sjpk free(v6_attrs); 463645916cd2Sjpk if (all_attrs != NULL) 463745916cd2Sjpk free(all_attrs); 46387c478bd9Sstevel@tonic-gate } 46397c478bd9Sstevel@tonic-gate 46407c478bd9Sstevel@tonic-gate /* 46417c478bd9Sstevel@tonic-gate * Match a user-supplied device name. We do this by string because 46427c478bd9Sstevel@tonic-gate * the MIB2 interface gives us interface name strings rather than 46437c478bd9Sstevel@tonic-gate * ifIndex numbers. The "none" rule matches only routes with no 46447c478bd9Sstevel@tonic-gate * interface. The "any" rule matches routes with any non-blank 46457c478bd9Sstevel@tonic-gate * interface. A base name ("hme0") matches all aliases as well 46467c478bd9Sstevel@tonic-gate * ("hme0:1"). 46477c478bd9Sstevel@tonic-gate */ 46487c478bd9Sstevel@tonic-gate static boolean_t 46497c478bd9Sstevel@tonic-gate dev_name_match(const DeviceName *devnam, const char *ifname) 46507c478bd9Sstevel@tonic-gate { 46517c478bd9Sstevel@tonic-gate int iflen; 46527c478bd9Sstevel@tonic-gate 46537c478bd9Sstevel@tonic-gate if (ifname == NULL) 46547c478bd9Sstevel@tonic-gate return (devnam->o_length == 0); /* "none" */ 46557c478bd9Sstevel@tonic-gate if (*ifname == '\0') 46567c478bd9Sstevel@tonic-gate return (devnam->o_length != 0); /* "any" */ 46577c478bd9Sstevel@tonic-gate iflen = strlen(ifname); 46587c478bd9Sstevel@tonic-gate /* The check for ':' here supports interface aliases. */ 46597c478bd9Sstevel@tonic-gate if (iflen > devnam->o_length || 46607c478bd9Sstevel@tonic-gate (iflen < devnam->o_length && devnam->o_bytes[iflen] != ':')) 46617c478bd9Sstevel@tonic-gate return (B_FALSE); 46627c478bd9Sstevel@tonic-gate return (strncmp(ifname, devnam->o_bytes, iflen) == 0); 46637c478bd9Sstevel@tonic-gate } 46647c478bd9Sstevel@tonic-gate 46657c478bd9Sstevel@tonic-gate /* 46667c478bd9Sstevel@tonic-gate * Match a user-supplied IP address list. The "any" rule matches any 46677c478bd9Sstevel@tonic-gate * non-zero address. The "none" rule matches only the zero address. 46687c478bd9Sstevel@tonic-gate * IPv6 addresses supplied by the user are ignored. If the user 46697c478bd9Sstevel@tonic-gate * supplies a subnet mask, then match routes that are at least that 46707c478bd9Sstevel@tonic-gate * specific (use the user's mask). If the user supplies only an 46717c478bd9Sstevel@tonic-gate * address, then select any routes that would match (use the route's 46727c478bd9Sstevel@tonic-gate * mask). 46737c478bd9Sstevel@tonic-gate */ 46747c478bd9Sstevel@tonic-gate static boolean_t 46757c478bd9Sstevel@tonic-gate v4_addr_match(IpAddress addr, IpAddress mask, const filter_t *fp) 46767c478bd9Sstevel@tonic-gate { 46777c478bd9Sstevel@tonic-gate char **app; 46787c478bd9Sstevel@tonic-gate char *aptr; 46797c478bd9Sstevel@tonic-gate in_addr_t faddr, fmask; 46807c478bd9Sstevel@tonic-gate 46817c478bd9Sstevel@tonic-gate if (fp->u.a.f_address == NULL) { 46827c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(&fp->u.a.f_mask)) 46837c478bd9Sstevel@tonic-gate return (addr != INADDR_ANY); /* "any" */ 46847c478bd9Sstevel@tonic-gate else 46857c478bd9Sstevel@tonic-gate return (addr == INADDR_ANY); /* "none" */ 46867c478bd9Sstevel@tonic-gate } 46877c478bd9Sstevel@tonic-gate if (!IN6_IS_V4MASK(fp->u.a.f_mask)) 46887c478bd9Sstevel@tonic-gate return (B_FALSE); 46897c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_IPADDR(&fp->u.a.f_mask, fmask); 46907c478bd9Sstevel@tonic-gate if (fmask != IP_HOST_MASK) { 46917c478bd9Sstevel@tonic-gate if (fmask > mask) 46927c478bd9Sstevel@tonic-gate return (B_FALSE); 46937c478bd9Sstevel@tonic-gate mask = fmask; 46947c478bd9Sstevel@tonic-gate } 46957c478bd9Sstevel@tonic-gate for (app = fp->u.a.f_address->h_addr_list; (aptr = *app) != NULL; app++) 46967c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_V4MAPPED((in6_addr_t *)aptr)) { 46977c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_IPADDR((in6_addr_t *)aptr, faddr); 46987c478bd9Sstevel@tonic-gate if (((faddr ^ addr) & mask) == 0) 46997c478bd9Sstevel@tonic-gate return (B_TRUE); 47007c478bd9Sstevel@tonic-gate } 47017c478bd9Sstevel@tonic-gate return (B_FALSE); 47027c478bd9Sstevel@tonic-gate } 47037c478bd9Sstevel@tonic-gate 47047c478bd9Sstevel@tonic-gate /* 47057c478bd9Sstevel@tonic-gate * Run through the filter list for an IPv4 MIB2 route entry. If all 47067c478bd9Sstevel@tonic-gate * filters of a given type fail to match, then the route is filtered 47077c478bd9Sstevel@tonic-gate * out (not displayed). If no filter is given or at least one filter 47087c478bd9Sstevel@tonic-gate * of each type matches, then display the route. 47097c478bd9Sstevel@tonic-gate */ 47107c478bd9Sstevel@tonic-gate static boolean_t 471145916cd2Sjpk ire_filter_match_v4(const mib2_ipRouteEntry_t *rp, uint_t flag_b) 47127c478bd9Sstevel@tonic-gate { 47137c478bd9Sstevel@tonic-gate filter_t *fp; 47147c478bd9Sstevel@tonic-gate int idx; 47157c478bd9Sstevel@tonic-gate 47167c478bd9Sstevel@tonic-gate for (idx = 0; idx < NFILTERKEYS; idx++) 47177c478bd9Sstevel@tonic-gate if ((fp = filters[idx]) != NULL) { 47187c478bd9Sstevel@tonic-gate for (; fp != NULL; fp = fp->f_next) { 47197c478bd9Sstevel@tonic-gate switch (idx) { 47207c478bd9Sstevel@tonic-gate case FK_AF: 47217c478bd9Sstevel@tonic-gate if (fp->u.f_family != AF_INET) 472278a2e113SAndy Fiddaman continue; 47237c478bd9Sstevel@tonic-gate break; 47247c478bd9Sstevel@tonic-gate case FK_OUTIF: 47257c478bd9Sstevel@tonic-gate if (!dev_name_match(&rp->ipRouteIfIndex, 47267c478bd9Sstevel@tonic-gate fp->u.f_ifname)) 472778a2e113SAndy Fiddaman continue; 47287c478bd9Sstevel@tonic-gate break; 47297c478bd9Sstevel@tonic-gate case FK_DST: 47307c478bd9Sstevel@tonic-gate if (!v4_addr_match(rp->ipRouteDest, 47317c478bd9Sstevel@tonic-gate rp->ipRouteMask, fp)) 473278a2e113SAndy Fiddaman continue; 47337c478bd9Sstevel@tonic-gate break; 47347c478bd9Sstevel@tonic-gate case FK_FLAGS: 47357c478bd9Sstevel@tonic-gate if ((flag_b & fp->u.f.f_flagset) != 47367c478bd9Sstevel@tonic-gate fp->u.f.f_flagset || 47377c478bd9Sstevel@tonic-gate (flag_b & fp->u.f.f_flagclear)) 473878a2e113SAndy Fiddaman continue; 47397c478bd9Sstevel@tonic-gate break; 47407c478bd9Sstevel@tonic-gate } 47417c478bd9Sstevel@tonic-gate break; 474278a2e113SAndy Fiddaman } 47437c478bd9Sstevel@tonic-gate if (fp == NULL) 47447c478bd9Sstevel@tonic-gate return (B_FALSE); 47457c478bd9Sstevel@tonic-gate } 47467c478bd9Sstevel@tonic-gate return (B_TRUE); 47477c478bd9Sstevel@tonic-gate } 47487c478bd9Sstevel@tonic-gate 47497c478bd9Sstevel@tonic-gate /* 47507c478bd9Sstevel@tonic-gate * Given an IPv4 MIB2 route entry, form the list of flags for the 47517c478bd9Sstevel@tonic-gate * route. 47527c478bd9Sstevel@tonic-gate */ 47537c478bd9Sstevel@tonic-gate static uint_t 475445916cd2Sjpk form_v4_route_flags(const mib2_ipRouteEntry_t *rp, char *flags) 47557c478bd9Sstevel@tonic-gate { 47567c478bd9Sstevel@tonic-gate uint_t flag_b; 47577c478bd9Sstevel@tonic-gate 47587c478bd9Sstevel@tonic-gate flag_b = FLF_U; 47597c478bd9Sstevel@tonic-gate (void) strcpy(flags, "U"); 4760bd670b35SErik Nordmark /* RTF_INDIRECT wins over RTF_GATEWAY - don't display both */ 4761bd670b35SErik Nordmark if (rp->ipRouteInfo.re_flags & RTF_INDIRECT) { 4762bd670b35SErik Nordmark (void) strcat(flags, "I"); 4763bd670b35SErik Nordmark flag_b |= FLF_I; 4764bd670b35SErik Nordmark } else if (rp->ipRouteInfo.re_ire_type & IRE_OFFLINK) { 47657c478bd9Sstevel@tonic-gate (void) strcat(flags, "G"); 47667c478bd9Sstevel@tonic-gate flag_b |= FLF_G; 47677c478bd9Sstevel@tonic-gate } 4768bd670b35SErik Nordmark /* IRE_IF_CLONE wins over RTF_HOST - don't display both */ 4769bd670b35SErik Nordmark if (rp->ipRouteInfo.re_ire_type & IRE_IF_CLONE) { 4770bd670b35SErik Nordmark (void) strcat(flags, "C"); 4771bd670b35SErik Nordmark flag_b |= FLF_C; 4772bd670b35SErik Nordmark } else if (rp->ipRouteMask == IP_HOST_MASK) { 47737c478bd9Sstevel@tonic-gate (void) strcat(flags, "H"); 47747c478bd9Sstevel@tonic-gate flag_b |= FLF_H; 47757c478bd9Sstevel@tonic-gate } 4776bd670b35SErik Nordmark if (rp->ipRouteInfo.re_flags & RTF_DYNAMIC) { 47777c478bd9Sstevel@tonic-gate (void) strcat(flags, "D"); 47787c478bd9Sstevel@tonic-gate flag_b |= FLF_D; 47797c478bd9Sstevel@tonic-gate } 47807c478bd9Sstevel@tonic-gate if (rp->ipRouteInfo.re_ire_type == IRE_BROADCAST) { /* Broadcast */ 4781bd670b35SErik Nordmark (void) strcat(flags, "b"); 4782bd670b35SErik Nordmark flag_b |= FLF_b; 47837c478bd9Sstevel@tonic-gate } 47847c478bd9Sstevel@tonic-gate if (rp->ipRouteInfo.re_ire_type == IRE_LOCAL) { /* Local */ 47857c478bd9Sstevel@tonic-gate (void) strcat(flags, "L"); 47867c478bd9Sstevel@tonic-gate flag_b |= FLF_L; 47877c478bd9Sstevel@tonic-gate } 47887c478bd9Sstevel@tonic-gate if (rp->ipRouteInfo.re_flags & RTF_MULTIRT) { 47897c478bd9Sstevel@tonic-gate (void) strcat(flags, "M"); /* Multiroute */ 47907c478bd9Sstevel@tonic-gate flag_b |= FLF_M; 47917c478bd9Sstevel@tonic-gate } 47927c478bd9Sstevel@tonic-gate if (rp->ipRouteInfo.re_flags & RTF_SETSRC) { 47937c478bd9Sstevel@tonic-gate (void) strcat(flags, "S"); /* Setsrc */ 47947c478bd9Sstevel@tonic-gate flag_b |= FLF_S; 47957c478bd9Sstevel@tonic-gate } 4796bd670b35SErik Nordmark if (rp->ipRouteInfo.re_flags & RTF_REJECT) { 4797bd670b35SErik Nordmark (void) strcat(flags, "R"); 4798bd670b35SErik Nordmark flag_b |= FLF_R; 4799bd670b35SErik Nordmark } 4800bd670b35SErik Nordmark if (rp->ipRouteInfo.re_flags & RTF_BLACKHOLE) { 4801bd670b35SErik Nordmark (void) strcat(flags, "B"); 4802bd670b35SErik Nordmark flag_b |= FLF_B; 4803bd670b35SErik Nordmark } 4804550b6e40SSowmini Varadhan if (rp->ipRouteInfo.re_flags & RTF_ZONE) { 4805550b6e40SSowmini Varadhan (void) strcat(flags, "Z"); 4806550b6e40SSowmini Varadhan flag_b |= FLF_Z; 4807550b6e40SSowmini Varadhan } 48087c478bd9Sstevel@tonic-gate return (flag_b); 48097c478bd9Sstevel@tonic-gate } 48107c478bd9Sstevel@tonic-gate 481178a2e113SAndy Fiddaman /* 481278a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 481378a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 481478a2e113SAndy Fiddaman * the formatted value. 481578a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 481678a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 481778a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 481878a2e113SAndy Fiddaman */ 481978a2e113SAndy Fiddaman #define IRE_V4_DEST " Destination " 482078a2e113SAndy Fiddaman #define IRE_V4_DEST_ "--------------------" 482178a2e113SAndy Fiddaman #define IRE_V4_DEST_F "%-20s" 482278a2e113SAndy Fiddaman #define IRE_V4_MASK " Mask " 482378a2e113SAndy Fiddaman #define IRE_V4_MASK_ "---------------" 482478a2e113SAndy Fiddaman #define IRE_V4_MASK_F "%-15s" 482578a2e113SAndy Fiddaman #define IRE_V4_GATEWAY " Gateway " 482678a2e113SAndy Fiddaman #define IRE_V4_GATEWAY_ "--------------------" 482778a2e113SAndy Fiddaman #define IRE_V4_GATEWAY_F "%-20s" 482878a2e113SAndy Fiddaman #define IRE_V4_DEVICE "Device" 482978a2e113SAndy Fiddaman #define IRE_V4_DEVICE_ "------" 483078a2e113SAndy Fiddaman #define IRE_V4_DEVICE_F "%-6s" 483178a2e113SAndy Fiddaman #define IRE_V4_MTU " MTU " 483278a2e113SAndy Fiddaman #define IRE_V4_MTU_ "-----" 483378a2e113SAndy Fiddaman #define IRE_V4_MTU_F "%5u" 483478a2e113SAndy Fiddaman #define IRE_V4_REF "Ref" 483578a2e113SAndy Fiddaman #define IRE_V4_REF_ "---" 483678a2e113SAndy Fiddaman #define IRE_V4_REF_F "%3u" 483778a2e113SAndy Fiddaman #define IRE_V4_FLAGS "Flg" 483878a2e113SAndy Fiddaman #define IRE_V4_FLAGS_ "---" 483978a2e113SAndy Fiddaman #define IRE_V4_FLAGS_F "%-4s" 484078a2e113SAndy Fiddaman #define IRE_V4_OUT " Out " 484178a2e113SAndy Fiddaman #define IRE_V4_OUT_ "------" 484278a2e113SAndy Fiddaman #define IRE_V4_OUT_F "%-6s" 484378a2e113SAndy Fiddaman #define IRE_V4_INFWD "In/Fwd" 484478a2e113SAndy Fiddaman #define IRE_V4_INFWD_ "------" 484578a2e113SAndy Fiddaman #define IRE_V4_INFWD_F "%6u" 484678a2e113SAndy Fiddaman #define IRE_V4_LFLAGS "Flags" 484778a2e113SAndy Fiddaman #define IRE_V4_LFLAGS_ "-----" 484878a2e113SAndy Fiddaman #define IRE_V4_LFLAGS_F "%-5s" 484978a2e113SAndy Fiddaman #define IRE_V4_LREF " Ref " 485078a2e113SAndy Fiddaman #define IRE_V4_LREF_ "-----" 485178a2e113SAndy Fiddaman #define IRE_V4_LREF_F " %4u" 485278a2e113SAndy Fiddaman #define IRE_V4_USE " Use " 485378a2e113SAndy Fiddaman #define IRE_V4_USE_ "----------" 485478a2e113SAndy Fiddaman #define IRE_V4_USE_F "%10u" 485578a2e113SAndy Fiddaman #define IRE_V4_INTERFACE "Interface" 485678a2e113SAndy Fiddaman #define IRE_V4_INTERFACE_ "---------" 485778a2e113SAndy Fiddaman #define IRE_V4_INTERFACE_F "%-9s" 485878a2e113SAndy Fiddaman 485945916cd2Sjpk static const char ire_hdr_v4[] = 486045916cd2Sjpk "\n%s Table: IPv4\n"; 486145916cd2Sjpk static const char ire_hdr_v4_compat[] = 486245916cd2Sjpk "\n%s Table:\n"; 486378a2e113SAndy Fiddaman 486445916cd2Sjpk static const char ire_hdr_v4_verbose[] = 486578a2e113SAndy Fiddaman IRE_V4_DEST " " IRE_V4_MASK " " IRE_V4_GATEWAY " " IRE_V4_DEVICE " " 486678a2e113SAndy Fiddaman IRE_V4_MTU " " IRE_V4_REF " " IRE_V4_FLAGS " " 486778a2e113SAndy Fiddaman IRE_V4_OUT " " IRE_V4_INFWD " %s\n" 486878a2e113SAndy Fiddaman IRE_V4_DEST_" " IRE_V4_MASK_" " IRE_V4_GATEWAY_" " IRE_V4_DEVICE_" " 486978a2e113SAndy Fiddaman IRE_V4_MTU_" " IRE_V4_REF_" " IRE_V4_FLAGS_" " 487078a2e113SAndy Fiddaman IRE_V4_OUT_" " IRE_V4_INFWD_" %s\n"; 487145916cd2Sjpk 487245916cd2Sjpk static const char ire_hdr_v4_normal[] = 487378a2e113SAndy Fiddaman IRE_V4_DEST " " IRE_V4_GATEWAY " " 487478a2e113SAndy Fiddaman IRE_V4_LFLAGS " " IRE_V4_LREF " " IRE_V4_USE " " 487578a2e113SAndy Fiddaman IRE_V4_INTERFACE " %s\n" 487678a2e113SAndy Fiddaman IRE_V4_DEST_" " IRE_V4_GATEWAY_" " 487778a2e113SAndy Fiddaman IRE_V4_LFLAGS_" " IRE_V4_LREF_" " IRE_V4_USE_" " 487878a2e113SAndy Fiddaman IRE_V4_INTERFACE_" %s\n"; 487945916cd2Sjpk 48807c478bd9Sstevel@tonic-gate static boolean_t 488145916cd2Sjpk ire_report_item_v4(const mib2_ipRouteEntry_t *rp, boolean_t first, 488245916cd2Sjpk const sec_attr_list_t *attrs) 48837c478bd9Sstevel@tonic-gate { 4884d38b7101SDan McDonald char dstbuf[MAXHOSTNAMELEN + 4]; /* + "/<num>" */ 48857c478bd9Sstevel@tonic-gate char maskbuf[MAXHOSTNAMELEN + 1]; 48867c478bd9Sstevel@tonic-gate char gwbuf[MAXHOSTNAMELEN + 1]; 48877c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 48887c478bd9Sstevel@tonic-gate char flags[10]; /* RTF_ flags */ 48897c478bd9Sstevel@tonic-gate uint_t flag_b; 48907c478bd9Sstevel@tonic-gate 4891bd670b35SErik Nordmark if (!(Aflag || (rp->ipRouteInfo.re_ire_type != IRE_IF_CLONE && 48927c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_ire_type != IRE_BROADCAST && 4893bd670b35SErik Nordmark rp->ipRouteInfo.re_ire_type != IRE_MULTICAST && 4894bd670b35SErik Nordmark rp->ipRouteInfo.re_ire_type != IRE_NOROUTE && 48957c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_ire_type != IRE_LOCAL))) { 48967c478bd9Sstevel@tonic-gate return (first); 48977c478bd9Sstevel@tonic-gate } 48987c478bd9Sstevel@tonic-gate 48997c478bd9Sstevel@tonic-gate flag_b = form_v4_route_flags(rp, flags); 49007c478bd9Sstevel@tonic-gate 49017c478bd9Sstevel@tonic-gate if (!ire_filter_match_v4(rp, flag_b)) 49027c478bd9Sstevel@tonic-gate return (first); 49037c478bd9Sstevel@tonic-gate 49047c478bd9Sstevel@tonic-gate if (first) { 490545916cd2Sjpk (void) printf(v4compat ? ire_hdr_v4_compat : ire_hdr_v4, 490645916cd2Sjpk Vflag ? "IRE" : "Routing"); 490745916cd2Sjpk (void) printf(Vflag ? ire_hdr_v4_verbose : ire_hdr_v4_normal, 490845916cd2Sjpk RSECflag ? " Gateway security attributes " : "", 490945916cd2Sjpk RSECflag ? "-------------------------------" : ""); 49107c478bd9Sstevel@tonic-gate first = B_FALSE; 49117c478bd9Sstevel@tonic-gate } 49127c478bd9Sstevel@tonic-gate 49137c478bd9Sstevel@tonic-gate if (flag_b & FLF_H) { 49147c478bd9Sstevel@tonic-gate (void) pr_addr(rp->ipRouteDest, dstbuf, sizeof (dstbuf)); 49157c478bd9Sstevel@tonic-gate } else { 49167c478bd9Sstevel@tonic-gate (void) pr_net(rp->ipRouteDest, rp->ipRouteMask, 49177c478bd9Sstevel@tonic-gate dstbuf, sizeof (dstbuf)); 49187c478bd9Sstevel@tonic-gate } 49197c478bd9Sstevel@tonic-gate if (Vflag) { 492078a2e113SAndy Fiddaman (void) printf( 492178a2e113SAndy Fiddaman IRE_V4_DEST_F " " IRE_V4_MASK_F " " IRE_V4_GATEWAY_F " " 492278a2e113SAndy Fiddaman IRE_V4_DEVICE_F " " IRE_V4_MTU_F " " IRE_V4_REF_F " " 492378a2e113SAndy Fiddaman IRE_V4_FLAGS_F IRE_V4_INFWD_F " " IRE_V4_INFWD_F " %s\n", 49247c478bd9Sstevel@tonic-gate dstbuf, 49257c478bd9Sstevel@tonic-gate pr_mask(rp->ipRouteMask, maskbuf, sizeof (maskbuf)), 49267c478bd9Sstevel@tonic-gate pr_addrnz(rp->ipRouteNextHop, gwbuf, sizeof (gwbuf)), 49277c478bd9Sstevel@tonic-gate octetstr(&rp->ipRouteIfIndex, 'a', ifname, sizeof (ifname)), 49287c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_max_frag, 49297c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_ref, 49307c478bd9Sstevel@tonic-gate flags, 49317c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_obpkt, 493245916cd2Sjpk rp->ipRouteInfo.re_ibpkt, 493345916cd2Sjpk pr_secattr(attrs)); 49347c478bd9Sstevel@tonic-gate } else { 493578a2e113SAndy Fiddaman (void) printf( 493678a2e113SAndy Fiddaman IRE_V4_DEST_F " " IRE_V4_GATEWAY_F " " 493778a2e113SAndy Fiddaman IRE_V4_LFLAGS_F " " IRE_V4_LREF_F " " 493878a2e113SAndy Fiddaman IRE_V4_USE_F " " IRE_V4_INTERFACE_F " %s\n", 49397c478bd9Sstevel@tonic-gate dstbuf, 49407c478bd9Sstevel@tonic-gate pr_addrnz(rp->ipRouteNextHop, gwbuf, sizeof (gwbuf)), 49417c478bd9Sstevel@tonic-gate flags, 49427c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_ref, 49437c478bd9Sstevel@tonic-gate rp->ipRouteInfo.re_obpkt + rp->ipRouteInfo.re_ibpkt, 49447c478bd9Sstevel@tonic-gate octetstr(&rp->ipRouteIfIndex, 'a', 494545916cd2Sjpk ifname, sizeof (ifname)), 494645916cd2Sjpk pr_secattr(attrs)); 49477c478bd9Sstevel@tonic-gate } 49487c478bd9Sstevel@tonic-gate return (first); 49497c478bd9Sstevel@tonic-gate } 49507c478bd9Sstevel@tonic-gate 49517c478bd9Sstevel@tonic-gate /* 49527c478bd9Sstevel@tonic-gate * Match a user-supplied IP address list against an IPv6 route entry. 49537c478bd9Sstevel@tonic-gate * If the user specified "any," then any non-zero address matches. If 49547c478bd9Sstevel@tonic-gate * the user specified "none," then only the zero address matches. If 49557c478bd9Sstevel@tonic-gate * the user specified a subnet mask length, then use that in matching 49567c478bd9Sstevel@tonic-gate * routes (select routes that are at least as specific). If the user 49577c478bd9Sstevel@tonic-gate * specified only an address, then use the route's mask (select routes 49587c478bd9Sstevel@tonic-gate * that would match that address). IPv4 addresses are ignored. 49597c478bd9Sstevel@tonic-gate */ 49607c478bd9Sstevel@tonic-gate static boolean_t 49617c478bd9Sstevel@tonic-gate v6_addr_match(const Ip6Address *addr, int masklen, const filter_t *fp) 49627c478bd9Sstevel@tonic-gate { 49637c478bd9Sstevel@tonic-gate const uint8_t *ucp; 49647c478bd9Sstevel@tonic-gate int fmasklen; 49657c478bd9Sstevel@tonic-gate int i; 49667c478bd9Sstevel@tonic-gate char **app; 4967265f37a1S const uint8_t *aptr; 49687c478bd9Sstevel@tonic-gate 49697c478bd9Sstevel@tonic-gate if (fp->u.a.f_address == NULL) { 49707c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(&fp->u.a.f_mask)) /* any */ 49717c478bd9Sstevel@tonic-gate return (!IN6_IS_ADDR_UNSPECIFIED(addr)); 49727c478bd9Sstevel@tonic-gate return (IN6_IS_ADDR_UNSPECIFIED(addr)); /* "none" */ 49737c478bd9Sstevel@tonic-gate } 49747c478bd9Sstevel@tonic-gate fmasklen = 0; 49757c478bd9Sstevel@tonic-gate for (ucp = fp->u.a.f_mask.s6_addr; 49767c478bd9Sstevel@tonic-gate ucp < fp->u.a.f_mask.s6_addr + sizeof (fp->u.a.f_mask.s6_addr); 49777c478bd9Sstevel@tonic-gate ucp++) { 49787c478bd9Sstevel@tonic-gate if (*ucp != 0xff) { 49797c478bd9Sstevel@tonic-gate if (*ucp != 0) 49807c478bd9Sstevel@tonic-gate fmasklen += 9 - ffs(*ucp); 498178a2e113SAndy Fiddaman break; 49827c478bd9Sstevel@tonic-gate } 49837c478bd9Sstevel@tonic-gate fmasklen += 8; 498478a2e113SAndy Fiddaman } 49857c478bd9Sstevel@tonic-gate if (fmasklen != IPV6_ABITS) { 49867c478bd9Sstevel@tonic-gate if (fmasklen > masklen) 49877c478bd9Sstevel@tonic-gate return (B_FALSE); 49887c478bd9Sstevel@tonic-gate masklen = fmasklen; 49897c478bd9Sstevel@tonic-gate } 4990265f37a1S for (app = fp->u.a.f_address->h_addr_list; 4991265f37a1S (aptr = (uint8_t *)*app) != NULL; app++) { 49927c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_V4MAPPED((in6_addr_t *)aptr)) 499378a2e113SAndy Fiddaman continue; 49947c478bd9Sstevel@tonic-gate ucp = addr->s6_addr; 49957c478bd9Sstevel@tonic-gate for (i = masklen; i >= 8; i -= 8) 49967c478bd9Sstevel@tonic-gate if (*ucp++ != *aptr++) 499778a2e113SAndy Fiddaman break; 49987c478bd9Sstevel@tonic-gate if (i == 0 || 49997c478bd9Sstevel@tonic-gate (i < 8 && ((*ucp ^ *aptr) & ~(0xff >> i)) == 0)) 50007c478bd9Sstevel@tonic-gate return (B_TRUE); 500178a2e113SAndy Fiddaman } 50027c478bd9Sstevel@tonic-gate return (B_FALSE); 50037c478bd9Sstevel@tonic-gate } 50047c478bd9Sstevel@tonic-gate 50057c478bd9Sstevel@tonic-gate /* 50067c478bd9Sstevel@tonic-gate * Run through the filter list for an IPv6 MIB2 IRE. For a given 50077c478bd9Sstevel@tonic-gate * type, if there's at least one filter and all filters of that type 50087c478bd9Sstevel@tonic-gate * fail to match, then the route doesn't match and isn't displayed. 50097c478bd9Sstevel@tonic-gate * If at least one matches, or none are specified, for each of the 50107c478bd9Sstevel@tonic-gate * types, then the route is selected and displayed. 50117c478bd9Sstevel@tonic-gate */ 50127c478bd9Sstevel@tonic-gate static boolean_t 501345916cd2Sjpk ire_filter_match_v6(const mib2_ipv6RouteEntry_t *rp6, uint_t flag_b) 50147c478bd9Sstevel@tonic-gate { 50157c478bd9Sstevel@tonic-gate filter_t *fp; 50167c478bd9Sstevel@tonic-gate int idx; 50177c478bd9Sstevel@tonic-gate 50187c478bd9Sstevel@tonic-gate for (idx = 0; idx < NFILTERKEYS; idx++) 50197c478bd9Sstevel@tonic-gate if ((fp = filters[idx]) != NULL) { 50207c478bd9Sstevel@tonic-gate for (; fp != NULL; fp = fp->f_next) { 50217c478bd9Sstevel@tonic-gate switch (idx) { 50227c478bd9Sstevel@tonic-gate case FK_AF: 50237c478bd9Sstevel@tonic-gate if (fp->u.f_family != AF_INET6) 50247c478bd9Sstevel@tonic-gate continue; 50257c478bd9Sstevel@tonic-gate break; 50267c478bd9Sstevel@tonic-gate case FK_OUTIF: 50277c478bd9Sstevel@tonic-gate if (!dev_name_match(&rp6-> 50287c478bd9Sstevel@tonic-gate ipv6RouteIfIndex, fp->u.f_ifname)) 50297c478bd9Sstevel@tonic-gate continue; 50307c478bd9Sstevel@tonic-gate break; 50317c478bd9Sstevel@tonic-gate case FK_DST: 50327c478bd9Sstevel@tonic-gate if (!v6_addr_match(&rp6->ipv6RouteDest, 50337c478bd9Sstevel@tonic-gate rp6->ipv6RoutePfxLength, fp)) 50347c478bd9Sstevel@tonic-gate continue; 50357c478bd9Sstevel@tonic-gate break; 50367c478bd9Sstevel@tonic-gate case FK_FLAGS: 50377c478bd9Sstevel@tonic-gate if ((flag_b & fp->u.f.f_flagset) != 50387c478bd9Sstevel@tonic-gate fp->u.f.f_flagset || 50397c478bd9Sstevel@tonic-gate (flag_b & fp->u.f.f_flagclear)) 50407c478bd9Sstevel@tonic-gate continue; 50417c478bd9Sstevel@tonic-gate break; 50427c478bd9Sstevel@tonic-gate } 50437c478bd9Sstevel@tonic-gate break; 504478a2e113SAndy Fiddaman } 50457c478bd9Sstevel@tonic-gate if (fp == NULL) 50467c478bd9Sstevel@tonic-gate return (B_FALSE); 50477c478bd9Sstevel@tonic-gate } 50487c478bd9Sstevel@tonic-gate return (B_TRUE); 50497c478bd9Sstevel@tonic-gate } 50507c478bd9Sstevel@tonic-gate 5051bd670b35SErik Nordmark /* 5052bd670b35SErik Nordmark * Given an IPv6 MIB2 route entry, form the list of flags for the 5053bd670b35SErik Nordmark * route. 5054bd670b35SErik Nordmark */ 5055bd670b35SErik Nordmark static uint_t 5056bd670b35SErik Nordmark form_v6_route_flags(const mib2_ipv6RouteEntry_t *rp6, char *flags) 50577c478bd9Sstevel@tonic-gate { 5058bd670b35SErik Nordmark uint_t flag_b; 50597c478bd9Sstevel@tonic-gate 50607c478bd9Sstevel@tonic-gate flag_b = FLF_U; 50617c478bd9Sstevel@tonic-gate (void) strcpy(flags, "U"); 5062bd670b35SErik Nordmark /* RTF_INDIRECT wins over RTF_GATEWAY - don't display both */ 5063bd670b35SErik Nordmark if (rp6->ipv6RouteInfo.re_flags & RTF_INDIRECT) { 5064bd670b35SErik Nordmark (void) strcat(flags, "I"); 5065bd670b35SErik Nordmark flag_b |= FLF_I; 5066bd670b35SErik Nordmark } else if (rp6->ipv6RouteInfo.re_ire_type & IRE_OFFLINK) { 50677c478bd9Sstevel@tonic-gate (void) strcat(flags, "G"); 50687c478bd9Sstevel@tonic-gate flag_b |= FLF_G; 50697c478bd9Sstevel@tonic-gate } 50707c478bd9Sstevel@tonic-gate 5071bd670b35SErik Nordmark /* IRE_IF_CLONE wins over RTF_HOST - don't display both */ 5072bd670b35SErik Nordmark if (rp6->ipv6RouteInfo.re_ire_type & IRE_IF_CLONE) { 5073bd670b35SErik Nordmark (void) strcat(flags, "C"); 5074bd670b35SErik Nordmark flag_b |= FLF_C; 5075bd670b35SErik Nordmark } else if (rp6->ipv6RoutePfxLength == IPV6_ABITS) { 50767c478bd9Sstevel@tonic-gate (void) strcat(flags, "H"); 50777c478bd9Sstevel@tonic-gate flag_b |= FLF_H; 50787c478bd9Sstevel@tonic-gate } 50797c478bd9Sstevel@tonic-gate 5080bd670b35SErik Nordmark if (rp6->ipv6RouteInfo.re_flags & RTF_DYNAMIC) { 50817c478bd9Sstevel@tonic-gate (void) strcat(flags, "D"); 50827c478bd9Sstevel@tonic-gate flag_b |= FLF_D; 50837c478bd9Sstevel@tonic-gate } 50847c478bd9Sstevel@tonic-gate if (rp6->ipv6RouteInfo.re_ire_type == IRE_LOCAL) { /* Local */ 50857c478bd9Sstevel@tonic-gate (void) strcat(flags, "L"); 50867c478bd9Sstevel@tonic-gate flag_b |= FLF_L; 50877c478bd9Sstevel@tonic-gate } 50887c478bd9Sstevel@tonic-gate if (rp6->ipv6RouteInfo.re_flags & RTF_MULTIRT) { 50897c478bd9Sstevel@tonic-gate (void) strcat(flags, "M"); /* Multiroute */ 50907c478bd9Sstevel@tonic-gate flag_b |= FLF_M; 50917c478bd9Sstevel@tonic-gate } 50927c478bd9Sstevel@tonic-gate if (rp6->ipv6RouteInfo.re_flags & RTF_SETSRC) { 50937c478bd9Sstevel@tonic-gate (void) strcat(flags, "S"); /* Setsrc */ 50947c478bd9Sstevel@tonic-gate flag_b |= FLF_S; 50957c478bd9Sstevel@tonic-gate } 5096bd670b35SErik Nordmark if (rp6->ipv6RouteInfo.re_flags & RTF_REJECT) { 5097bd670b35SErik Nordmark (void) strcat(flags, "R"); 5098bd670b35SErik Nordmark flag_b |= FLF_R; 5099bd670b35SErik Nordmark } 5100bd670b35SErik Nordmark if (rp6->ipv6RouteInfo.re_flags & RTF_BLACKHOLE) { 5101bd670b35SErik Nordmark (void) strcat(flags, "B"); 5102bd670b35SErik Nordmark flag_b |= FLF_B; 5103bd670b35SErik Nordmark } 5104550b6e40SSowmini Varadhan if (rp6->ipv6RouteInfo.re_flags & RTF_ZONE) { 5105550b6e40SSowmini Varadhan (void) strcat(flags, "Z"); 5106550b6e40SSowmini Varadhan flag_b |= FLF_Z; 5107550b6e40SSowmini Varadhan } 5108bd670b35SErik Nordmark return (flag_b); 5109bd670b35SErik Nordmark } 5110bd670b35SErik Nordmark 511178a2e113SAndy Fiddaman /* 511278a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 511378a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 511478a2e113SAndy Fiddaman * the formatted value. 511578a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 511678a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 511778a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 511878a2e113SAndy Fiddaman */ 511978a2e113SAndy Fiddaman #define IRE_V6_DEST " Destination/Mask " 512078a2e113SAndy Fiddaman #define IRE_V6_DEST_ "---------------------------" 512178a2e113SAndy Fiddaman #define IRE_V6_DEST_F "%-27s" 512278a2e113SAndy Fiddaman #define IRE_V6_GATEWAY " Gateway " 512378a2e113SAndy Fiddaman #define IRE_V6_GATEWAY_ "---------------------------" 512478a2e113SAndy Fiddaman #define IRE_V6_GATEWAY_F "%-27s" 512578a2e113SAndy Fiddaman #define IRE_V6_IF " If " 512678a2e113SAndy Fiddaman #define IRE_V6_IF_ "-----" 512778a2e113SAndy Fiddaman #define IRE_V6_IF_F "%-5s" 512878a2e113SAndy Fiddaman #define IRE_V6_MTU " MTU " 512978a2e113SAndy Fiddaman #define IRE_V6_MTU_ "-----" 513078a2e113SAndy Fiddaman #define IRE_V6_MTU_F "%5u" 513178a2e113SAndy Fiddaman #define IRE_V6_REF "Ref" 513278a2e113SAndy Fiddaman #define IRE_V6_REF_ "---" 513378a2e113SAndy Fiddaman #define IRE_V6_REF_F "%3u" 513478a2e113SAndy Fiddaman #define IRE_V6_USE " Use " 513578a2e113SAndy Fiddaman #define IRE_V6_USE_ "-------" 513678a2e113SAndy Fiddaman #define IRE_V6_USE_F "%7u" 513778a2e113SAndy Fiddaman #define IRE_V6_FLAGS "Flags" 513878a2e113SAndy Fiddaman #define IRE_V6_FLAGS_ "-----" 513978a2e113SAndy Fiddaman #define IRE_V6_FLAGS_F "%-5s" 514078a2e113SAndy Fiddaman #define IRE_V6_OUT " Out " 514178a2e113SAndy Fiddaman #define IRE_V6_OUT_ "------" 514278a2e113SAndy Fiddaman #define IRE_V6_OUT_F "%6u" 514378a2e113SAndy Fiddaman #define IRE_V6_INFWD "In/Fwd" 514478a2e113SAndy Fiddaman #define IRE_V6_INFWD_ "------" 514578a2e113SAndy Fiddaman #define IRE_V6_INFWD_F "%6u" 514678a2e113SAndy Fiddaman 5147bd670b35SErik Nordmark static const char ire_hdr_v6[] = 5148bd670b35SErik Nordmark "\n%s Table: IPv6\n"; 5149bd670b35SErik Nordmark static const char ire_hdr_v6_verbose[] = 515078a2e113SAndy Fiddaman IRE_V6_DEST " " IRE_V6_GATEWAY " " IRE_V6_IF " " IRE_V6_MTU " " 515178a2e113SAndy Fiddaman IRE_V6_REF " " IRE_V6_FLAGS " " IRE_V6_OUT " " IRE_V6_INFWD " %s\n" 515278a2e113SAndy Fiddaman IRE_V6_DEST_" " IRE_V6_GATEWAY_" " IRE_V6_IF_" " IRE_V6_MTU_" " 515378a2e113SAndy Fiddaman IRE_V6_REF_" " IRE_V6_FLAGS_" " IRE_V6_OUT_" " IRE_V6_INFWD_" %s\n"; 5154bd670b35SErik Nordmark static const char ire_hdr_v6_normal[] = 515578a2e113SAndy Fiddaman IRE_V6_DEST " " IRE_V6_GATEWAY " " 515678a2e113SAndy Fiddaman IRE_V6_FLAGS " " IRE_V6_REF " " IRE_V6_USE " " IRE_V6_IF " %s\n" 515778a2e113SAndy Fiddaman IRE_V6_DEST_" " IRE_V6_GATEWAY_" " 515878a2e113SAndy Fiddaman IRE_V6_FLAGS_" " IRE_V6_REF_" " IRE_V6_USE_" " IRE_V6_IF_" %s\n"; 5159bd670b35SErik Nordmark 5160bd670b35SErik Nordmark static boolean_t 5161bd670b35SErik Nordmark ire_report_item_v6(const mib2_ipv6RouteEntry_t *rp6, boolean_t first, 5162bd670b35SErik Nordmark const sec_attr_list_t *attrs) 5163bd670b35SErik Nordmark { 5164bd670b35SErik Nordmark char dstbuf[MAXHOSTNAMELEN + 1]; 5165bd670b35SErik Nordmark char gwbuf[MAXHOSTNAMELEN + 1]; 5166bd670b35SErik Nordmark char ifname[LIFNAMSIZ + 1]; 5167bd670b35SErik Nordmark char flags[10]; /* RTF_ flags */ 5168bd670b35SErik Nordmark uint_t flag_b; 5169bd670b35SErik Nordmark 5170bd670b35SErik Nordmark if (!(Aflag || (rp6->ipv6RouteInfo.re_ire_type != IRE_IF_CLONE && 5171bd670b35SErik Nordmark rp6->ipv6RouteInfo.re_ire_type != IRE_MULTICAST && 5172bd670b35SErik Nordmark rp6->ipv6RouteInfo.re_ire_type != IRE_NOROUTE && 5173bd670b35SErik Nordmark rp6->ipv6RouteInfo.re_ire_type != IRE_LOCAL))) { 5174bd670b35SErik Nordmark return (first); 5175bd670b35SErik Nordmark } 5176bd670b35SErik Nordmark 5177bd670b35SErik Nordmark flag_b = form_v6_route_flags(rp6, flags); 51787c478bd9Sstevel@tonic-gate 51797c478bd9Sstevel@tonic-gate if (!ire_filter_match_v6(rp6, flag_b)) 51807c478bd9Sstevel@tonic-gate return (first); 51817c478bd9Sstevel@tonic-gate 51827c478bd9Sstevel@tonic-gate if (first) { 518345916cd2Sjpk (void) printf(ire_hdr_v6, Vflag ? "IRE" : "Routing"); 518445916cd2Sjpk (void) printf(Vflag ? ire_hdr_v6_verbose : ire_hdr_v6_normal, 518545916cd2Sjpk RSECflag ? " Gateway security attributes " : "", 518645916cd2Sjpk RSECflag ? "-------------------------------" : ""); 51877c478bd9Sstevel@tonic-gate first = B_FALSE; 51887c478bd9Sstevel@tonic-gate } 51897c478bd9Sstevel@tonic-gate 51907c478bd9Sstevel@tonic-gate if (Vflag) { 519178a2e113SAndy Fiddaman (void) printf( 519278a2e113SAndy Fiddaman IRE_V6_DEST_F " " IRE_V6_GATEWAY_F " " 519378a2e113SAndy Fiddaman IRE_V6_IF_F " " IRE_V6_MTU_F " " IRE_V6_REF_F " " 519478a2e113SAndy Fiddaman IRE_V6_FLAGS_F " " IRE_V6_OUT_F " " IRE_V6_INFWD_F " %s\n", 51957c478bd9Sstevel@tonic-gate pr_prefix6(&rp6->ipv6RouteDest, 5196e11c3f44Smeem rp6->ipv6RoutePfxLength, dstbuf, sizeof (dstbuf)), 51977c478bd9Sstevel@tonic-gate IN6_IS_ADDR_UNSPECIFIED(&rp6->ipv6RouteNextHop) ? 51987c478bd9Sstevel@tonic-gate " --" : 51997c478bd9Sstevel@tonic-gate pr_addr6(&rp6->ipv6RouteNextHop, gwbuf, sizeof (gwbuf)), 52007c478bd9Sstevel@tonic-gate octetstr(&rp6->ipv6RouteIfIndex, 'a', 52017c478bd9Sstevel@tonic-gate ifname, sizeof (ifname)), 52027c478bd9Sstevel@tonic-gate rp6->ipv6RouteInfo.re_max_frag, 52037c478bd9Sstevel@tonic-gate rp6->ipv6RouteInfo.re_ref, 52047c478bd9Sstevel@tonic-gate flags, 52057c478bd9Sstevel@tonic-gate rp6->ipv6RouteInfo.re_obpkt, 520645916cd2Sjpk rp6->ipv6RouteInfo.re_ibpkt, 520745916cd2Sjpk pr_secattr(attrs)); 52087c478bd9Sstevel@tonic-gate } else { 520978a2e113SAndy Fiddaman (void) printf( 521078a2e113SAndy Fiddaman IRE_V6_DEST_F " " IRE_V6_GATEWAY_F " " 521178a2e113SAndy Fiddaman IRE_V6_FLAGS_F " " IRE_V6_REF_F " " 521278a2e113SAndy Fiddaman IRE_V6_USE_F " " IRE_V6_IF_F " %s\n", 52137c478bd9Sstevel@tonic-gate pr_prefix6(&rp6->ipv6RouteDest, 5214e11c3f44Smeem rp6->ipv6RoutePfxLength, dstbuf, sizeof (dstbuf)), 52157c478bd9Sstevel@tonic-gate IN6_IS_ADDR_UNSPECIFIED(&rp6->ipv6RouteNextHop) ? 52167c478bd9Sstevel@tonic-gate " --" : 52177c478bd9Sstevel@tonic-gate pr_addr6(&rp6->ipv6RouteNextHop, gwbuf, sizeof (gwbuf)), 52187c478bd9Sstevel@tonic-gate flags, 52197c478bd9Sstevel@tonic-gate rp6->ipv6RouteInfo.re_ref, 52207c478bd9Sstevel@tonic-gate rp6->ipv6RouteInfo.re_obpkt + rp6->ipv6RouteInfo.re_ibpkt, 52217c478bd9Sstevel@tonic-gate octetstr(&rp6->ipv6RouteIfIndex, 'a', 522245916cd2Sjpk ifname, sizeof (ifname)), 522345916cd2Sjpk pr_secattr(attrs)); 52247c478bd9Sstevel@tonic-gate } 52257c478bd9Sstevel@tonic-gate return (first); 52267c478bd9Sstevel@tonic-gate } 52277c478bd9Sstevel@tonic-gate 522845916cd2Sjpk /* 522945916cd2Sjpk * Common attribute-gathering routine for all transports. 523045916cd2Sjpk */ 523145916cd2Sjpk static mib2_transportMLPEntry_t ** 523245916cd2Sjpk gather_attrs(const mib_item_t *item, int group, int mib_id, int esize) 523345916cd2Sjpk { 523478a2e113SAndy Fiddaman size_t transport_count = 0; 523545916cd2Sjpk const mib_item_t *iptr; 523645916cd2Sjpk mib2_transportMLPEntry_t **attrs, *tme; 523745916cd2Sjpk 523845916cd2Sjpk for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 523978a2e113SAndy Fiddaman if (iptr->group == group && iptr->mib_id == mib_id) { 524078a2e113SAndy Fiddaman size_t els = iptr->length / esize; 524178a2e113SAndy Fiddaman if (transport_count > SIZE_MAX - els) { 524278a2e113SAndy Fiddaman fprintf(stderr, "Connection table too large\n"); 524378a2e113SAndy Fiddaman return (NULL); 524478a2e113SAndy Fiddaman } else { 524578a2e113SAndy Fiddaman transport_count += els; 524678a2e113SAndy Fiddaman } 524778a2e113SAndy Fiddaman } 524845916cd2Sjpk } 524978a2e113SAndy Fiddaman 525078a2e113SAndy Fiddaman if (transport_count == 0) 525145916cd2Sjpk return (NULL); 525278a2e113SAndy Fiddaman 525378a2e113SAndy Fiddaman attrs = recallocarray(NULL, 0, transport_count, sizeof (*attrs)); 525478a2e113SAndy Fiddaman 525545916cd2Sjpk if (attrs == NULL) { 525678a2e113SAndy Fiddaman perror("gather_attrs allocation failed"); 525745916cd2Sjpk return (NULL); 525845916cd2Sjpk } 525978a2e113SAndy Fiddaman 526045916cd2Sjpk for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 526145916cd2Sjpk if (iptr->group == group && iptr->mib_id == EXPER_XPORT_MLP) { 526245916cd2Sjpk for (tme = iptr->valp; 526345916cd2Sjpk (char *)tme < (char *)iptr->valp + iptr->length; 526445916cd2Sjpk tme = (mib2_transportMLPEntry_t *)((char *)tme + 526545916cd2Sjpk transportMLPSize)) { 526645916cd2Sjpk attrs[tme->tme_connidx] = tme; 526745916cd2Sjpk } 526845916cd2Sjpk } 526945916cd2Sjpk } 527045916cd2Sjpk return (attrs); 527145916cd2Sjpk } 527245916cd2Sjpk 527378a2e113SAndy Fiddaman static void 527478a2e113SAndy Fiddaman sie_report(const mib2_socketInfoEntry_t *sie) 527578a2e113SAndy Fiddaman { 527678a2e113SAndy Fiddaman if (sie == NULL) 527778a2e113SAndy Fiddaman return; 527878a2e113SAndy Fiddaman 527978a2e113SAndy Fiddaman (void) printf("INFO[%" PRIu64 "] = " 528078a2e113SAndy Fiddaman "inode %" PRIu64 ", " 528178a2e113SAndy Fiddaman "major %" PRIx32 ", " 528278a2e113SAndy Fiddaman "flags %#" PRIx64 "\n", 528378a2e113SAndy Fiddaman sie->sie_connidx, sie->sie_inode, 528478a2e113SAndy Fiddaman major((dev_t)sie->sie_dev), sie->sie_flags); 528578a2e113SAndy Fiddaman } 528678a2e113SAndy Fiddaman 528778a2e113SAndy Fiddaman /* 528878a2e113SAndy Fiddaman * Common info-gathering routine for all transports. 528978a2e113SAndy Fiddaman * 529078a2e113SAndy Fiddaman * The linked list of MIB data pointed to by item consists of a number of 529178a2e113SAndy Fiddaman * tables covering several protocol families and socket types, one after 529278a2e113SAndy Fiddaman * another. These are generally tables containing information about network 529378a2e113SAndy Fiddaman * connections, such as mib2_tcpConnEntry, as defined in RFC 1213/4022. 529478a2e113SAndy Fiddaman * 529578a2e113SAndy Fiddaman * There are also ancilliary tables which contain optional additional 529678a2e113SAndy Fiddaman * information about each socket. The data in these ancilliary tables is 529778a2e113SAndy Fiddaman * indexed by the table position of the connection to which it relates, and 529878a2e113SAndy Fiddaman * data may not be available for all connections. 529978a2e113SAndy Fiddaman * 530078a2e113SAndy Fiddaman * The code here determines the size of the connection table, allocates an 530178a2e113SAndy Fiddaman * array of that size to hold the ancilliary data and then fills that in 530278a2e113SAndy Fiddaman * if data is present. 530378a2e113SAndy Fiddaman * 530478a2e113SAndy Fiddaman * As an example, if the data contains a mib2_tcpConnEntry table containing 530578a2e113SAndy Fiddaman * three connections, but there is no ancilliary data for the second, then 530678a2e113SAndy Fiddaman * the accompanying mib2_socketInfoEntry table will only contain two entries. 530778a2e113SAndy Fiddaman * However, the first entry is tagged as referring to connection slot 0, and 530878a2e113SAndy Fiddaman * the second is tagged with connection slot 2. 530978a2e113SAndy Fiddaman * This function would return an array with: 531078a2e113SAndy Fiddaman * { <data for conn0>, NULL, <data for conn2> } 531178a2e113SAndy Fiddaman * 531278a2e113SAndy Fiddaman */ 531378a2e113SAndy Fiddaman static mib2_socketInfoEntry_t ** 531478a2e113SAndy Fiddaman gather_info(const mib_item_t *item, int group, int mib_id, int esize) 531578a2e113SAndy Fiddaman { 531678a2e113SAndy Fiddaman size_t transport_count = 0; 531778a2e113SAndy Fiddaman const mib_item_t *iptr; 531878a2e113SAndy Fiddaman mib2_socketInfoEntry_t **info, *sie; 531978a2e113SAndy Fiddaman 532078a2e113SAndy Fiddaman for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 532178a2e113SAndy Fiddaman if (iptr->group == group && iptr->mib_id == mib_id) { 532278a2e113SAndy Fiddaman size_t els = iptr->length / esize; 532378a2e113SAndy Fiddaman if (transport_count > SIZE_MAX - els) { 532478a2e113SAndy Fiddaman fprintf(stderr, "Connection table too large\n"); 532578a2e113SAndy Fiddaman return (NULL); 532678a2e113SAndy Fiddaman } else { 532778a2e113SAndy Fiddaman transport_count += els; 532878a2e113SAndy Fiddaman } 532978a2e113SAndy Fiddaman } 533078a2e113SAndy Fiddaman } 533178a2e113SAndy Fiddaman 533278a2e113SAndy Fiddaman if (transport_count == 0) 533378a2e113SAndy Fiddaman return (NULL); 533478a2e113SAndy Fiddaman 533578a2e113SAndy Fiddaman info = recallocarray(NULL, 0, transport_count, sizeof (*info)); 533678a2e113SAndy Fiddaman 533778a2e113SAndy Fiddaman if (info == NULL) { 533878a2e113SAndy Fiddaman perror("gather_info allocation failed"); 533978a2e113SAndy Fiddaman return (NULL); 534078a2e113SAndy Fiddaman } 534178a2e113SAndy Fiddaman 534278a2e113SAndy Fiddaman for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 534378a2e113SAndy Fiddaman if (iptr->group != group || iptr->mib_id != EXPER_SOCK_INFO) 534478a2e113SAndy Fiddaman continue; 534578a2e113SAndy Fiddaman 534678a2e113SAndy Fiddaman for (sie = (mib2_socketInfoEntry_t *)iptr->valp; 534778a2e113SAndy Fiddaman (uintptr_t)sie < (uintptr_t)iptr->valp + iptr->length; 534878a2e113SAndy Fiddaman sie++) { 534978a2e113SAndy Fiddaman assert(sie->sie_connidx < transport_count); 535078a2e113SAndy Fiddaman info[sie->sie_connidx] = sie; 535178a2e113SAndy Fiddaman } 535278a2e113SAndy Fiddaman } 535378a2e113SAndy Fiddaman return (info); 535478a2e113SAndy Fiddaman } 535578a2e113SAndy Fiddaman 535645916cd2Sjpk static void 535745916cd2Sjpk print_transport_label(const mib2_transportMLPEntry_t *attr) 535845916cd2Sjpk { 53595f9878b0Sken Powell - Sun Microsystem if (!RSECflag || attr == NULL || 53605f9878b0Sken Powell - Sun Microsystem !(attr->tme_flags & MIB2_TMEF_IS_LABELED)) 536145916cd2Sjpk return; 536245916cd2Sjpk 53637b0bedd4SRic Aleshire if (bisinvalid(&attr->tme_label)) { 536445916cd2Sjpk (void) printf(" INVALID\n"); 53657b0bedd4SRic Aleshire } else if (!blequal(&attr->tme_label, zone_security_label)) { 53667b0bedd4SRic Aleshire char *sl_str; 53677b0bedd4SRic Aleshire 53687b0bedd4SRic Aleshire sl_str = sl_to_str(&attr->tme_label); 53697b0bedd4SRic Aleshire (void) printf(" %s\n", sl_str); 53707b0bedd4SRic Aleshire free(sl_str); 53717b0bedd4SRic Aleshire } 537245916cd2Sjpk } 537345916cd2Sjpk 53747c478bd9Sstevel@tonic-gate /* ------------------------------ TCP_REPORT------------------------------- */ 53757c478bd9Sstevel@tonic-gate 53767c478bd9Sstevel@tonic-gate static const char tcp_hdr_v4[] = 53777c478bd9Sstevel@tonic-gate "\nTCP: IPv4\n"; 53787c478bd9Sstevel@tonic-gate static const char tcp_hdr_v4_compat[] = 53797c478bd9Sstevel@tonic-gate "\nTCP\n"; 538078a2e113SAndy Fiddaman 538178a2e113SAndy Fiddaman /* 538278a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 538378a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 538478a2e113SAndy Fiddaman * the formatted value. 538578a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 538678a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 538778a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 538878a2e113SAndy Fiddaman */ 538978a2e113SAndy Fiddaman #define TCP_V4_LOCAL " Local Address " 539078a2e113SAndy Fiddaman #define TCP_V4_LOCAL_ "--------------------" 539178a2e113SAndy Fiddaman #define TCP_V4_LOCAL_F "%-20s" 539278a2e113SAndy Fiddaman #define TCP_V4_REMOTE " Remote Address " 539378a2e113SAndy Fiddaman #define TCP_V4_REMOTE_ "--------------------" 539478a2e113SAndy Fiddaman #define TCP_V4_REMOTE_F "%-20s" 539578a2e113SAndy Fiddaman #define TCP_V4_ADDRESS "Local/Remote Address" 539678a2e113SAndy Fiddaman #define TCP_V4_ADDRESS_ "--------------------" 539778a2e113SAndy Fiddaman #define TCP_V4_ADDRESS_F "%-20s" 539878a2e113SAndy Fiddaman #define TCP_V4_SWIND "Swind " 539978a2e113SAndy Fiddaman #define TCP_V4_SWIND_ "------" 540078a2e113SAndy Fiddaman #define TCP_V4_SWIND_F "%6u" 540178a2e113SAndy Fiddaman #define TCP_V4_SENDQ "Send-Q" 540278a2e113SAndy Fiddaman #define TCP_V4_SENDQ_ "------" 540378a2e113SAndy Fiddaman #define TCP_V4_SENDQ_F "%6" PRId64 540478a2e113SAndy Fiddaman #define TCP_V4_RWIND "Rwind " 540578a2e113SAndy Fiddaman #define TCP_V4_RWIND_ "------" 540678a2e113SAndy Fiddaman #define TCP_V4_RWIND_F "%6u" 540778a2e113SAndy Fiddaman #define TCP_V4_RECVQ "Recv-Q" 540878a2e113SAndy Fiddaman #define TCP_V4_RECVQ_ "------" 540978a2e113SAndy Fiddaman #define TCP_V4_RECVQ_F "%6" PRId64 541078a2e113SAndy Fiddaman #define TCP_V4_SNEXT " Snext " 541178a2e113SAndy Fiddaman #define TCP_V4_SNEXT_ "--------" 541278a2e113SAndy Fiddaman #define TCP_V4_SNEXT_F "%08x" 541378a2e113SAndy Fiddaman #define TCP_V4_SUNA " Suna " 541478a2e113SAndy Fiddaman #define TCP_V4_SUNA_ "--------" 541578a2e113SAndy Fiddaman #define TCP_V4_SUNA_F "%08x" 541678a2e113SAndy Fiddaman #define TCP_V4_RNEXT " Rnext " 541778a2e113SAndy Fiddaman #define TCP_V4_RNEXT_ "--------" 541878a2e113SAndy Fiddaman #define TCP_V4_RNEXT_F "%08x" 541978a2e113SAndy Fiddaman #define TCP_V4_RACK " Rack " 542078a2e113SAndy Fiddaman #define TCP_V4_RACK_ "--------" 542178a2e113SAndy Fiddaman #define TCP_V4_RACK_F "%08x" 542278a2e113SAndy Fiddaman #define TCP_V4_RTO " Rto " 542378a2e113SAndy Fiddaman #define TCP_V4_RTO_ "-----" 542478a2e113SAndy Fiddaman #define TCP_V4_RTO_F "%5u" 542578a2e113SAndy Fiddaman #define TCP_V4_MSS " Mss " 542678a2e113SAndy Fiddaman #define TCP_V4_MSS_ "-----" 542778a2e113SAndy Fiddaman #define TCP_V4_MSS_F "%5u" 542878a2e113SAndy Fiddaman #define TCP_V4_STATE " State " 542978a2e113SAndy Fiddaman #define TCP_V4_STATE_ "-----------" 543078a2e113SAndy Fiddaman #define TCP_V4_STATE_F "%-11s" 543178a2e113SAndy Fiddaman #define TCP_V4_USER " User " 543278a2e113SAndy Fiddaman #define TCP_V4_USER_ "--------" 543378a2e113SAndy Fiddaman #define TCP_V4_USER_F "%-8.8s" 543478a2e113SAndy Fiddaman #define TCP_V4_PID " Pid " 543578a2e113SAndy Fiddaman #define TCP_V4_PID_ "------" 543678a2e113SAndy Fiddaman #define TCP_V4_PID_F "%6s" 543778a2e113SAndy Fiddaman #define TCP_V4_COMMAND " Command " 543878a2e113SAndy Fiddaman #define TCP_V4_COMMAND_ "--------------" 543978a2e113SAndy Fiddaman #define TCP_V4_COMMAND_F "%-14.14s" 544078a2e113SAndy Fiddaman 54417c478bd9Sstevel@tonic-gate static const char tcp_hdr_v4_normal[] = 544278a2e113SAndy Fiddaman TCP_V4_LOCAL " " TCP_V4_REMOTE " " 544378a2e113SAndy Fiddaman TCP_V4_SWIND " " TCP_V4_SENDQ " " TCP_V4_RWIND " " TCP_V4_RECVQ " " 544478a2e113SAndy Fiddaman TCP_V4_STATE "\n" 544578a2e113SAndy Fiddaman TCP_V4_LOCAL_" " TCP_V4_REMOTE_" " 544678a2e113SAndy Fiddaman TCP_V4_SWIND_" " TCP_V4_SENDQ_" " TCP_V4_RWIND_" " TCP_V4_RECVQ_" " 544778a2e113SAndy Fiddaman TCP_V4_STATE_"\n"; 544878a2e113SAndy Fiddaman static const char tcp_hdr_v4_normal_pid[] = 544978a2e113SAndy Fiddaman TCP_V4_LOCAL " " TCP_V4_REMOTE " " 545078a2e113SAndy Fiddaman TCP_V4_USER " " TCP_V4_PID " " TCP_V4_COMMAND " " 545178a2e113SAndy Fiddaman TCP_V4_SWIND " " TCP_V4_SENDQ " " TCP_V4_RWIND " " TCP_V4_RECVQ " " 545278a2e113SAndy Fiddaman TCP_V4_STATE "\n" 545378a2e113SAndy Fiddaman TCP_V4_LOCAL_" " TCP_V4_REMOTE_" " 545478a2e113SAndy Fiddaman TCP_V4_USER_" " TCP_V4_PID_" " TCP_V4_COMMAND_" " 545578a2e113SAndy Fiddaman TCP_V4_SWIND_" " TCP_V4_SENDQ_" " TCP_V4_RWIND_" " TCP_V4_RECVQ_" " 545678a2e113SAndy Fiddaman TCP_V4_STATE_"\n"; 545778a2e113SAndy Fiddaman static const char tcp_hdr_v4_verbose[] = 545878a2e113SAndy Fiddaman TCP_V4_ADDRESS " " 545978a2e113SAndy Fiddaman TCP_V4_SWIND " " TCP_V4_SNEXT " " TCP_V4_SUNA " " 546078a2e113SAndy Fiddaman TCP_V4_RWIND " " TCP_V4_RNEXT " " TCP_V4_RACK " " 546178a2e113SAndy Fiddaman TCP_V4_RTO " " TCP_V4_MSS " " TCP_V4_STATE "\n" 546278a2e113SAndy Fiddaman TCP_V4_ADDRESS_" " 546378a2e113SAndy Fiddaman TCP_V4_SWIND_" " TCP_V4_SNEXT_" " TCP_V4_SUNA_" " 546478a2e113SAndy Fiddaman TCP_V4_RWIND_" " TCP_V4_RNEXT_" " TCP_V4_RACK_" " 546578a2e113SAndy Fiddaman TCP_V4_RTO_" " TCP_V4_MSS_" " TCP_V4_STATE_"\n"; 546678a2e113SAndy Fiddaman static const char tcp_hdr_v4_verbose_pid[] = 546778a2e113SAndy Fiddaman TCP_V4_ADDRESS " " 546878a2e113SAndy Fiddaman TCP_V4_SWIND " " TCP_V4_SNEXT " " TCP_V4_SUNA " " 546978a2e113SAndy Fiddaman TCP_V4_RWIND " " TCP_V4_RNEXT " " TCP_V4_RACK " " 547078a2e113SAndy Fiddaman TCP_V4_RTO " " TCP_V4_MSS " " TCP_V4_STATE " " 547178a2e113SAndy Fiddaman TCP_V4_USER " " TCP_V4_PID " " TCP_V4_COMMAND "\n" 547278a2e113SAndy Fiddaman TCP_V4_ADDRESS_" " 547378a2e113SAndy Fiddaman TCP_V4_SWIND_" " TCP_V4_SNEXT_" " TCP_V4_SUNA_" " 547478a2e113SAndy Fiddaman TCP_V4_RWIND_" " TCP_V4_RNEXT_" " TCP_V4_RACK_" " 547578a2e113SAndy Fiddaman TCP_V4_RTO_" " TCP_V4_MSS_" " TCP_V4_STATE_" " 547678a2e113SAndy Fiddaman TCP_V4_USER_" " TCP_V4_PID_" " TCP_V4_COMMAND_"\n"; 547778a2e113SAndy Fiddaman 547878a2e113SAndy Fiddaman #define TCP_V6_LOCAL " Local Address " 547978a2e113SAndy Fiddaman #define TCP_V6_LOCAL_ "---------------------------------" 548078a2e113SAndy Fiddaman #define TCP_V6_LOCAL_F "%-33s" 548178a2e113SAndy Fiddaman #define TCP_V6_REMOTE " Remote Address " 548278a2e113SAndy Fiddaman #define TCP_V6_REMOTE_ "---------------------------------" 548378a2e113SAndy Fiddaman #define TCP_V6_REMOTE_F "%-33s" 548478a2e113SAndy Fiddaman #define TCP_V6_ADDRESS "Local/Remote Address " 548578a2e113SAndy Fiddaman #define TCP_V6_ADDRESS_ "---------------------------------" 548678a2e113SAndy Fiddaman #define TCP_V6_ADDRESS_F "%-33s" 548778a2e113SAndy Fiddaman #define TCP_V6_IF " If " 548878a2e113SAndy Fiddaman #define TCP_V6_IF_ "-----" 548978a2e113SAndy Fiddaman #define TCP_V6_IF_F "%-5.5s" 549078a2e113SAndy Fiddaman #define TCP_V6_SWIND TCP_V4_SWIND 549178a2e113SAndy Fiddaman #define TCP_V6_SWIND_ TCP_V4_SWIND_ 549278a2e113SAndy Fiddaman #define TCP_V6_SWIND_F TCP_V4_SWIND_F 549378a2e113SAndy Fiddaman #define TCP_V6_SENDQ TCP_V4_SENDQ 549478a2e113SAndy Fiddaman #define TCP_V6_SENDQ_ TCP_V4_SENDQ_ 549578a2e113SAndy Fiddaman #define TCP_V6_SENDQ_F TCP_V4_SENDQ_F 549678a2e113SAndy Fiddaman #define TCP_V6_RWIND TCP_V4_RWIND 549778a2e113SAndy Fiddaman #define TCP_V6_RWIND_ TCP_V4_RWIND_ 549878a2e113SAndy Fiddaman #define TCP_V6_RWIND_F TCP_V4_RWIND_F 549978a2e113SAndy Fiddaman #define TCP_V6_RECVQ TCP_V4_RECVQ 550078a2e113SAndy Fiddaman #define TCP_V6_RECVQ_ TCP_V4_RECVQ_ 550178a2e113SAndy Fiddaman #define TCP_V6_RECVQ_F TCP_V4_RECVQ_F 550278a2e113SAndy Fiddaman #define TCP_V6_SNEXT TCP_V4_SNEXT 550378a2e113SAndy Fiddaman #define TCP_V6_SNEXT_ TCP_V4_SNEXT_ 550478a2e113SAndy Fiddaman #define TCP_V6_SNEXT_F TCP_V4_SNEXT_F 550578a2e113SAndy Fiddaman #define TCP_V6_SUNA TCP_V4_SUNA 550678a2e113SAndy Fiddaman #define TCP_V6_SUNA_ TCP_V4_SUNA_ 550778a2e113SAndy Fiddaman #define TCP_V6_SUNA_F TCP_V4_SUNA_F 550878a2e113SAndy Fiddaman #define TCP_V6_RNEXT TCP_V4_RNEXT 550978a2e113SAndy Fiddaman #define TCP_V6_RNEXT_ TCP_V4_RNEXT_ 551078a2e113SAndy Fiddaman #define TCP_V6_RNEXT_F TCP_V4_RNEXT_F 551178a2e113SAndy Fiddaman #define TCP_V6_RACK TCP_V4_RACK 551278a2e113SAndy Fiddaman #define TCP_V6_RACK_ TCP_V4_RACK_ 551378a2e113SAndy Fiddaman #define TCP_V6_RACK_F TCP_V4_RACK_F 551478a2e113SAndy Fiddaman #define TCP_V6_RTO TCP_V4_RTO 551578a2e113SAndy Fiddaman #define TCP_V6_RTO_ TCP_V4_RTO_ 551678a2e113SAndy Fiddaman #define TCP_V6_RTO_F TCP_V4_RTO_F 551778a2e113SAndy Fiddaman #define TCP_V6_MSS TCP_V4_MSS 551878a2e113SAndy Fiddaman #define TCP_V6_MSS_ TCP_V4_MSS_ 551978a2e113SAndy Fiddaman #define TCP_V6_MSS_F TCP_V4_MSS_F 552078a2e113SAndy Fiddaman #define TCP_V6_STATE TCP_V4_STATE 552178a2e113SAndy Fiddaman #define TCP_V6_STATE_ TCP_V4_STATE_ 552278a2e113SAndy Fiddaman #define TCP_V6_STATE_F TCP_V4_STATE_F 552378a2e113SAndy Fiddaman #define TCP_V6_USER TCP_V4_USER 552478a2e113SAndy Fiddaman #define TCP_V6_USER_ TCP_V4_USER_ 552578a2e113SAndy Fiddaman #define TCP_V6_USER_F TCP_V4_USER_F 552678a2e113SAndy Fiddaman #define TCP_V6_PID TCP_V4_PID 552778a2e113SAndy Fiddaman #define TCP_V6_PID_ TCP_V4_PID_ 552878a2e113SAndy Fiddaman #define TCP_V6_PID_F TCP_V4_PID_F 552978a2e113SAndy Fiddaman #define TCP_V6_COMMAND TCP_V4_COMMAND 553078a2e113SAndy Fiddaman #define TCP_V6_COMMAND_ TCP_V4_COMMAND_ 553178a2e113SAndy Fiddaman #define TCP_V6_COMMAND_F TCP_V4_COMMAND_F 55327c478bd9Sstevel@tonic-gate 55337c478bd9Sstevel@tonic-gate static const char tcp_hdr_v6[] = 55347c478bd9Sstevel@tonic-gate "\nTCP: IPv6\n"; 55357c478bd9Sstevel@tonic-gate static const char tcp_hdr_v6_normal[] = 553678a2e113SAndy Fiddaman TCP_V6_LOCAL " " TCP_V6_REMOTE " " 553778a2e113SAndy Fiddaman TCP_V6_SWIND " " TCP_V6_SENDQ " " TCP_V6_RWIND " " TCP_V6_RECVQ " " 553878a2e113SAndy Fiddaman TCP_V6_STATE " " TCP_V6_IF "\n" 553978a2e113SAndy Fiddaman TCP_V6_LOCAL_" " TCP_V6_REMOTE_" " 554078a2e113SAndy Fiddaman TCP_V6_SWIND_" " TCP_V6_SENDQ_" " TCP_V6_RWIND_" " TCP_V6_RECVQ_" " 554178a2e113SAndy Fiddaman TCP_V6_STATE_" " TCP_V6_IF_"\n"; 554278a2e113SAndy Fiddaman static const char tcp_hdr_v6_normal_pid[] = 554378a2e113SAndy Fiddaman TCP_V6_LOCAL " " TCP_V6_REMOTE " " 554478a2e113SAndy Fiddaman TCP_V6_USER " " TCP_V6_PID " " TCP_V6_COMMAND " " 554578a2e113SAndy Fiddaman TCP_V6_SWIND " " TCP_V6_SENDQ " " TCP_V6_RWIND " " TCP_V6_RECVQ " " 554678a2e113SAndy Fiddaman TCP_V6_STATE " " TCP_V6_IF "\n" 554778a2e113SAndy Fiddaman TCP_V6_LOCAL_" " TCP_V6_REMOTE_" " 554878a2e113SAndy Fiddaman TCP_V6_USER_" " TCP_V6_PID_" " TCP_V6_COMMAND_" " 554978a2e113SAndy Fiddaman TCP_V6_SWIND_" " TCP_V6_SENDQ_" " TCP_V6_RWIND_" " TCP_V6_RECVQ_" " 555078a2e113SAndy Fiddaman TCP_V6_STATE_" " TCP_V6_IF_"\n"; 555178a2e113SAndy Fiddaman static const char tcp_hdr_v6_verbose[] = 555278a2e113SAndy Fiddaman TCP_V6_ADDRESS " " 555378a2e113SAndy Fiddaman TCP_V6_SWIND " " TCP_V6_SNEXT " " TCP_V6_SUNA " " 555478a2e113SAndy Fiddaman TCP_V6_RWIND " " TCP_V6_RNEXT " " TCP_V6_RACK " " 555578a2e113SAndy Fiddaman TCP_V6_RTO " " TCP_V6_MSS " " TCP_V6_STATE " " TCP_V6_IF "\n" 555678a2e113SAndy Fiddaman TCP_V6_ADDRESS_" " 555778a2e113SAndy Fiddaman TCP_V6_SWIND_" " TCP_V6_SNEXT_" " TCP_V6_SUNA_" " 555878a2e113SAndy Fiddaman TCP_V6_RWIND_" " TCP_V6_RNEXT_" " TCP_V6_RACK_" " 555978a2e113SAndy Fiddaman TCP_V6_RTO_" " TCP_V6_MSS_" " TCP_V6_STATE_" " TCP_V6_IF_"\n"; 556078a2e113SAndy Fiddaman static const char tcp_hdr_v6_verbose_pid[] = 556178a2e113SAndy Fiddaman TCP_V6_ADDRESS " " 556278a2e113SAndy Fiddaman TCP_V6_SWIND " " TCP_V6_SNEXT " " TCP_V6_SUNA " " 556378a2e113SAndy Fiddaman TCP_V6_RWIND " " TCP_V6_RNEXT " " TCP_V6_RACK " " 556478a2e113SAndy Fiddaman TCP_V6_RTO " " TCP_V6_MSS " " TCP_V6_STATE " " TCP_V6_IF " " 556578a2e113SAndy Fiddaman TCP_V6_USER " " TCP_V6_PID " " TCP_V6_COMMAND "\n" 556678a2e113SAndy Fiddaman TCP_V6_ADDRESS_" " 556778a2e113SAndy Fiddaman TCP_V6_SWIND_" " TCP_V6_SNEXT_" " TCP_V6_SUNA_" " 556878a2e113SAndy Fiddaman TCP_V6_RWIND_" " TCP_V6_RNEXT_" " TCP_V6_RACK_" " 556978a2e113SAndy Fiddaman TCP_V6_RTO_" " TCP_V6_MSS_" " TCP_V6_STATE_" " TCP_V6_IF_" " 557078a2e113SAndy Fiddaman TCP_V6_USER_" " TCP_V6_PID_" " TCP_V6_COMMAND_"\n"; 55717c478bd9Sstevel@tonic-gate 557245916cd2Sjpk static boolean_t tcp_report_item_v4(const mib2_tcpConnEntry_t *, 557378a2e113SAndy Fiddaman boolean_t first, const mib2_transportMLPEntry_t *, 557478a2e113SAndy Fiddaman const mib2_socketInfoEntry_t *); 557545916cd2Sjpk static boolean_t tcp_report_item_v6(const mib2_tcp6ConnEntry_t *, 557678a2e113SAndy Fiddaman boolean_t first, const mib2_transportMLPEntry_t *, 557778a2e113SAndy Fiddaman const mib2_socketInfoEntry_t *); 55787c478bd9Sstevel@tonic-gate 55797c478bd9Sstevel@tonic-gate static void 558045916cd2Sjpk tcp_report(const mib_item_t *item) 55817c478bd9Sstevel@tonic-gate { 558278a2e113SAndy Fiddaman int jtemp = 0; 558378a2e113SAndy Fiddaman boolean_t print_hdr_once_v4 = B_TRUE; 558478a2e113SAndy Fiddaman boolean_t print_hdr_once_v6 = B_TRUE; 558578a2e113SAndy Fiddaman mib2_tcpConnEntry_t *tp; 558678a2e113SAndy Fiddaman mib2_tcp6ConnEntry_t *tp6; 558778a2e113SAndy Fiddaman mib2_transportMLPEntry_t **v4_attrs, **v6_attrs, **v4a, **v6a; 558878a2e113SAndy Fiddaman mib2_transportMLPEntry_t *aptr; 558978a2e113SAndy Fiddaman mib2_socketInfoEntry_t **v4_info, **v6_info, **v4i, **v6i; 559078a2e113SAndy Fiddaman mib2_socketInfoEntry_t *iptr; 55917c478bd9Sstevel@tonic-gate 55927c478bd9Sstevel@tonic-gate if (!protocol_selected(IPPROTO_TCP)) 55937c478bd9Sstevel@tonic-gate return; 55947c478bd9Sstevel@tonic-gate 559545916cd2Sjpk /* 559645916cd2Sjpk * Preparation pass: the kernel returns separate entries for TCP 559778a2e113SAndy Fiddaman * connection table entries, Multilevel Port attributes and extra 559878a2e113SAndy Fiddaman * socket information. We loop through the attributes first and set up 559978a2e113SAndy Fiddaman * an array for each address family. 560045916cd2Sjpk */ 560145916cd2Sjpk v4_attrs = family_selected(AF_INET) && RSECflag ? 560245916cd2Sjpk gather_attrs(item, MIB2_TCP, MIB2_TCP_CONN, tcpConnEntrySize) : 560345916cd2Sjpk NULL; 560445916cd2Sjpk v6_attrs = family_selected(AF_INET6) && RSECflag ? 560545916cd2Sjpk gather_attrs(item, MIB2_TCP6, MIB2_TCP6_CONN, tcp6ConnEntrySize) : 560645916cd2Sjpk NULL; 560745916cd2Sjpk 560878a2e113SAndy Fiddaman v4_info = Uflag && family_selected(AF_INET) ? 560978a2e113SAndy Fiddaman gather_info(item, MIB2_TCP, MIB2_TCP_CONN, tcpConnEntrySize) : 561078a2e113SAndy Fiddaman NULL; 561178a2e113SAndy Fiddaman v6_info = Uflag && family_selected(AF_INET6) ? 561278a2e113SAndy Fiddaman gather_info(item, MIB2_TCP6, MIB2_TCP6_CONN, tcp6ConnEntrySize) : 561378a2e113SAndy Fiddaman NULL; 561478a2e113SAndy Fiddaman 561545916cd2Sjpk v4a = v4_attrs; 561645916cd2Sjpk v6a = v6_attrs; 561778a2e113SAndy Fiddaman v4i = v4_info; 561878a2e113SAndy Fiddaman v6i = v6_info; 561945916cd2Sjpk for (; item != NULL; item = item->next_item) { 5620bd670b35SErik Nordmark if (Xflag) { 562178a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 562278a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 56237c478bd9Sstevel@tonic-gate item->group, item->mib_id, 56247c478bd9Sstevel@tonic-gate item->length, item->valp); 56257c478bd9Sstevel@tonic-gate } 56267c478bd9Sstevel@tonic-gate 56277c478bd9Sstevel@tonic-gate if (!((item->group == MIB2_TCP && 56287c478bd9Sstevel@tonic-gate item->mib_id == MIB2_TCP_CONN) || 56297c478bd9Sstevel@tonic-gate (item->group == MIB2_TCP6 && 56307c478bd9Sstevel@tonic-gate item->mib_id == MIB2_TCP6_CONN))) 563178a2e113SAndy Fiddaman continue; 56327c478bd9Sstevel@tonic-gate 56337c478bd9Sstevel@tonic-gate if (item->group == MIB2_TCP && !family_selected(AF_INET)) 563478a2e113SAndy Fiddaman continue; 563578a2e113SAndy Fiddaman if (item->group == MIB2_TCP6 && !family_selected(AF_INET6)) 563678a2e113SAndy Fiddaman continue; 56377c478bd9Sstevel@tonic-gate 56387c478bd9Sstevel@tonic-gate if (item->group == MIB2_TCP) { 56397c478bd9Sstevel@tonic-gate for (tp = (mib2_tcpConnEntry_t *)item->valp; 56407c478bd9Sstevel@tonic-gate (char *)tp < (char *)item->valp + item->length; 56417c478bd9Sstevel@tonic-gate tp = (mib2_tcpConnEntry_t *)((char *)tp + 56427c478bd9Sstevel@tonic-gate tcpConnEntrySize)) { 564345916cd2Sjpk aptr = v4a == NULL ? NULL : *v4a++; 564478a2e113SAndy Fiddaman iptr = v4i == NULL ? NULL : *v4i++; 56457c478bd9Sstevel@tonic-gate print_hdr_once_v4 = tcp_report_item_v4(tp, 564678a2e113SAndy Fiddaman print_hdr_once_v4, aptr, iptr); 56477c478bd9Sstevel@tonic-gate } 56487c478bd9Sstevel@tonic-gate } else { 56497c478bd9Sstevel@tonic-gate for (tp6 = (mib2_tcp6ConnEntry_t *)item->valp; 56507c478bd9Sstevel@tonic-gate (char *)tp6 < (char *)item->valp + item->length; 56517c478bd9Sstevel@tonic-gate tp6 = (mib2_tcp6ConnEntry_t *)((char *)tp6 + 56527c478bd9Sstevel@tonic-gate tcp6ConnEntrySize)) { 565345916cd2Sjpk aptr = v6a == NULL ? NULL : *v6a++; 565478a2e113SAndy Fiddaman iptr = v6i == NULL ? NULL : *v6i++; 56557c478bd9Sstevel@tonic-gate print_hdr_once_v6 = tcp_report_item_v6(tp6, 565678a2e113SAndy Fiddaman print_hdr_once_v6, aptr, iptr); 56577c478bd9Sstevel@tonic-gate } 56587c478bd9Sstevel@tonic-gate } 565978a2e113SAndy Fiddaman } 56607c478bd9Sstevel@tonic-gate (void) fflush(stdout); 566145916cd2Sjpk 566278a2e113SAndy Fiddaman free(v4_attrs); 566378a2e113SAndy Fiddaman free(v6_attrs); 566478a2e113SAndy Fiddaman free(v4_info); 566578a2e113SAndy Fiddaman free(v6_info); 56667c478bd9Sstevel@tonic-gate } 56677c478bd9Sstevel@tonic-gate 56687c478bd9Sstevel@tonic-gate static boolean_t 566945916cd2Sjpk tcp_report_item_v4(const mib2_tcpConnEntry_t *tp, boolean_t first, 567078a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *attr, const mib2_socketInfoEntry_t *sie) 56717c478bd9Sstevel@tonic-gate { 56727c478bd9Sstevel@tonic-gate /* 56737c478bd9Sstevel@tonic-gate * lname and fname below are for the hostname as well as the portname 56747c478bd9Sstevel@tonic-gate * There is no limit on portname length so we assume MAXHOSTNAMELEN 56757c478bd9Sstevel@tonic-gate * as the limit 56767c478bd9Sstevel@tonic-gate */ 56777c478bd9Sstevel@tonic-gate char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 56787c478bd9Sstevel@tonic-gate char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 567978a2e113SAndy Fiddaman proc_fdinfo_t *ph; 56807c478bd9Sstevel@tonic-gate 56817c478bd9Sstevel@tonic-gate if (!(Aflag || tp->tcpConnEntryInfo.ce_state >= TCPS_ESTABLISHED)) 56827c478bd9Sstevel@tonic-gate return (first); /* Nothing to print */ 56837c478bd9Sstevel@tonic-gate 56847c478bd9Sstevel@tonic-gate if (first) { 568545916cd2Sjpk (void) printf(v4compat ? tcp_hdr_v4_compat : tcp_hdr_v4); 568678a2e113SAndy Fiddaman if (Vflag) 568778a2e113SAndy Fiddaman (void) printf(Uflag ? tcp_hdr_v4_verbose_pid : 568878a2e113SAndy Fiddaman tcp_hdr_v4_verbose); 568978a2e113SAndy Fiddaman else 569078a2e113SAndy Fiddaman (void) printf(Uflag ? tcp_hdr_v4_normal_pid : 569178a2e113SAndy Fiddaman tcp_hdr_v4_normal); 56927c478bd9Sstevel@tonic-gate } 56937c478bd9Sstevel@tonic-gate 569478a2e113SAndy Fiddaman int64_t sq = (int64_t)tp->tcpConnEntryInfo.ce_snxt - 569578a2e113SAndy Fiddaman (int64_t)tp->tcpConnEntryInfo.ce_suna - 1; 569678a2e113SAndy Fiddaman int64_t rq = (int64_t)tp->tcpConnEntryInfo.ce_rnxt - 569778a2e113SAndy Fiddaman (int64_t)tp->tcpConnEntryInfo.ce_rack; 569878a2e113SAndy Fiddaman 569978a2e113SAndy Fiddaman if (Xflag) 570078a2e113SAndy Fiddaman sie_report(sie); 570178a2e113SAndy Fiddaman 570278a2e113SAndy Fiddaman if (Uflag) { 570378a2e113SAndy Fiddaman ph = process_hash_get(sie, SOCK_STREAM, AF_INET); 570478a2e113SAndy Fiddaman if (ph->ph_pid == 0 && sie != NULL && 570578a2e113SAndy Fiddaman (sie->sie_flags & MIB2_SOCKINFO_IPV6)) { 570678a2e113SAndy Fiddaman ph = process_hash_get(sie, SOCK_STREAM, AF_INET6); 570778a2e113SAndy Fiddaman } 570878a2e113SAndy Fiddaman } 570978a2e113SAndy Fiddaman 571078a2e113SAndy Fiddaman if (!Uflag && Vflag) { 571178a2e113SAndy Fiddaman (void) printf( 571278a2e113SAndy Fiddaman TCP_V4_LOCAL_F "\n" TCP_V4_REMOTE_F " " 571378a2e113SAndy Fiddaman TCP_V4_SWIND_F " " TCP_V4_SNEXT_F " " 571478a2e113SAndy Fiddaman TCP_V4_SUNA_F " " TCP_V4_RWIND_F " " 571578a2e113SAndy Fiddaman TCP_V4_RNEXT_F " " TCP_V4_RACK_F " " 571678a2e113SAndy Fiddaman TCP_V4_RTO_F " " TCP_V4_MSS_F " %s\n", 57177c478bd9Sstevel@tonic-gate pr_ap(tp->tcpConnLocalAddress, 5718e11c3f44Smeem tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 57197c478bd9Sstevel@tonic-gate pr_ap(tp->tcpConnRemAddress, 5720e11c3f44Smeem tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 57217c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_swnd, 57227c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_snxt, 57237c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_suna, 57247c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_rwnd, 57257c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_rnxt, 57267c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_rack, 57277c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_rto, 57287c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_mss, 572945916cd2Sjpk mitcp_state(tp->tcpConnEntryInfo.ce_state, attr)); 573078a2e113SAndy Fiddaman } else if (!Uflag) { 573178a2e113SAndy Fiddaman (void) printf( 573278a2e113SAndy Fiddaman TCP_V4_LOCAL_F " " TCP_V4_REMOTE_F " " 573378a2e113SAndy Fiddaman TCP_V4_SWIND_F " " TCP_V4_SENDQ_F " " 573478a2e113SAndy Fiddaman TCP_V4_RWIND_F " " TCP_V4_RECVQ_F " %s\n", 57357c478bd9Sstevel@tonic-gate pr_ap(tp->tcpConnLocalAddress, 5736e11c3f44Smeem tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 57377c478bd9Sstevel@tonic-gate pr_ap(tp->tcpConnRemAddress, 5738e11c3f44Smeem tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 57397c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_swnd, 57407c478bd9Sstevel@tonic-gate (sq >= 0) ? sq : 0, 57417c478bd9Sstevel@tonic-gate tp->tcpConnEntryInfo.ce_rwnd, 57427c478bd9Sstevel@tonic-gate (rq >= 0) ? rq : 0, 574345916cd2Sjpk mitcp_state(tp->tcpConnEntryInfo.ce_state, attr)); 574478a2e113SAndy Fiddaman } else if (Uflag && Vflag) { 574578a2e113SAndy Fiddaman for (; ph != NULL; ph = ph->ph_next_proc) { 574678a2e113SAndy Fiddaman (void) printf( 574778a2e113SAndy Fiddaman TCP_V4_LOCAL_F "\n" TCP_V4_REMOTE_F " " 574878a2e113SAndy Fiddaman TCP_V4_SWIND_F " " TCP_V4_SNEXT_F " " 574978a2e113SAndy Fiddaman TCP_V4_SUNA_F " " TCP_V4_RWIND_F " " 575078a2e113SAndy Fiddaman TCP_V4_RNEXT_F " " TCP_V4_RACK_F " " 575178a2e113SAndy Fiddaman TCP_V4_RTO_F " " TCP_V4_MSS_F " " 575278a2e113SAndy Fiddaman TCP_V4_STATE_F " " TCP_V4_USER_F " " 575378a2e113SAndy Fiddaman TCP_V4_PID_F " %s\n", 575478a2e113SAndy Fiddaman pr_ap(tp->tcpConnLocalAddress, 575578a2e113SAndy Fiddaman tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 575678a2e113SAndy Fiddaman pr_ap(tp->tcpConnRemAddress, 575778a2e113SAndy Fiddaman tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 575878a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_swnd, 575978a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_snxt, 576078a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_suna, 576178a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_rwnd, 576278a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_rnxt, 576378a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_rack, 576478a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_rto, 576578a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_mss, 576678a2e113SAndy Fiddaman mitcp_state(tp->tcpConnEntryInfo.ce_state, attr), 576778a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, ph->ph_psargs); 576878a2e113SAndy Fiddaman } 576978a2e113SAndy Fiddaman } else if (Uflag) { 577078a2e113SAndy Fiddaman for (; ph != NULL; ph = ph->ph_next_proc) { 577178a2e113SAndy Fiddaman (void) printf( 577278a2e113SAndy Fiddaman TCP_V4_LOCAL_F " " TCP_V4_REMOTE_F " " 577378a2e113SAndy Fiddaman TCP_V4_USER_F " "TCP_V4_PID_F " " 577478a2e113SAndy Fiddaman TCP_V4_COMMAND_F " " 577578a2e113SAndy Fiddaman TCP_V4_SWIND_F " " TCP_V4_SENDQ_F " " 577678a2e113SAndy Fiddaman TCP_V4_RWIND_F " " TCP_V4_RECVQ_F " %s\n", 577778a2e113SAndy Fiddaman pr_ap(tp->tcpConnLocalAddress, 577878a2e113SAndy Fiddaman tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 577978a2e113SAndy Fiddaman pr_ap(tp->tcpConnRemAddress, 578078a2e113SAndy Fiddaman tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 578178a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, ph->ph_fname, 578278a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_swnd, 578378a2e113SAndy Fiddaman (sq >= 0) ? sq : 0, 578478a2e113SAndy Fiddaman tp->tcpConnEntryInfo.ce_rwnd, 578578a2e113SAndy Fiddaman (rq >= 0) ? rq : 0, 578678a2e113SAndy Fiddaman mitcp_state(tp->tcpConnEntryInfo.ce_state, attr)); 578778a2e113SAndy Fiddaman } 57887c478bd9Sstevel@tonic-gate } 578945916cd2Sjpk 579045916cd2Sjpk print_transport_label(attr); 579145916cd2Sjpk 579245916cd2Sjpk return (B_FALSE); 57937c478bd9Sstevel@tonic-gate } 57947c478bd9Sstevel@tonic-gate 57957c478bd9Sstevel@tonic-gate static boolean_t 579645916cd2Sjpk tcp_report_item_v6(const mib2_tcp6ConnEntry_t *tp6, boolean_t first, 579778a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *attr, const mib2_socketInfoEntry_t *sie) 57987c478bd9Sstevel@tonic-gate { 57997c478bd9Sstevel@tonic-gate /* 58007c478bd9Sstevel@tonic-gate * lname and fname below are for the hostname as well as the portname 58017c478bd9Sstevel@tonic-gate * There is no limit on portname length so we assume MAXHOSTNAMELEN 58027c478bd9Sstevel@tonic-gate * as the limit 58037c478bd9Sstevel@tonic-gate */ 58047c478bd9Sstevel@tonic-gate char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 58057c478bd9Sstevel@tonic-gate char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 58067c478bd9Sstevel@tonic-gate char ifname[LIFNAMSIZ + 1]; 58077c478bd9Sstevel@tonic-gate char *ifnamep; 580878a2e113SAndy Fiddaman proc_fdinfo_t *ph; 58097c478bd9Sstevel@tonic-gate 58107c478bd9Sstevel@tonic-gate if (!(Aflag || tp6->tcp6ConnEntryInfo.ce_state >= TCPS_ESTABLISHED)) 58117c478bd9Sstevel@tonic-gate return (first); /* Nothing to print */ 58127c478bd9Sstevel@tonic-gate 58137c478bd9Sstevel@tonic-gate if (first) { 581445916cd2Sjpk (void) printf(tcp_hdr_v6); 581578a2e113SAndy Fiddaman if (Vflag) 581678a2e113SAndy Fiddaman (void) printf(Uflag ? tcp_hdr_v6_verbose_pid : 581778a2e113SAndy Fiddaman tcp_hdr_v6_verbose); 581878a2e113SAndy Fiddaman else 581978a2e113SAndy Fiddaman (void) printf(Uflag ? tcp_hdr_v6_normal_pid : 582078a2e113SAndy Fiddaman tcp_hdr_v6_normal); 58217c478bd9Sstevel@tonic-gate } 58227c478bd9Sstevel@tonic-gate 58237c478bd9Sstevel@tonic-gate ifnamep = (tp6->tcp6ConnIfIndex != 0) ? 58247c478bd9Sstevel@tonic-gate if_indextoname(tp6->tcp6ConnIfIndex, ifname) : NULL; 582545916cd2Sjpk if (ifnamep == NULL) 582645916cd2Sjpk ifnamep = ""; 58277c478bd9Sstevel@tonic-gate 582878a2e113SAndy Fiddaman int64_t sq = (int64_t)tp6->tcp6ConnEntryInfo.ce_snxt - 582978a2e113SAndy Fiddaman (int64_t)tp6->tcp6ConnEntryInfo.ce_suna - 1; 583078a2e113SAndy Fiddaman int64_t rq = (int64_t)tp6->tcp6ConnEntryInfo.ce_rnxt - 583178a2e113SAndy Fiddaman (int64_t)tp6->tcp6ConnEntryInfo.ce_rack; 583278a2e113SAndy Fiddaman 583378a2e113SAndy Fiddaman if (Xflag) 583478a2e113SAndy Fiddaman sie_report(sie); 583578a2e113SAndy Fiddaman 583678a2e113SAndy Fiddaman if (!Uflag && Vflag) { 583778a2e113SAndy Fiddaman (void) printf( 583878a2e113SAndy Fiddaman TCP_V6_LOCAL_F "\n" TCP_V6_REMOTE_F " " 583978a2e113SAndy Fiddaman TCP_V6_SWIND_F " " TCP_V6_SNEXT_F " " 584078a2e113SAndy Fiddaman TCP_V6_SUNA_F " " TCP_V6_RWIND_F " " 584178a2e113SAndy Fiddaman TCP_V6_RNEXT_F " " TCP_V6_RACK_F " " 584278a2e113SAndy Fiddaman TCP_V6_RTO_F " " TCP_V6_MSS_F " " 584378a2e113SAndy Fiddaman TCP_V6_STATE_F " %s\n", 58447c478bd9Sstevel@tonic-gate pr_ap6(&tp6->tcp6ConnLocalAddress, 5845e11c3f44Smeem tp6->tcp6ConnLocalPort, "tcp", lname, sizeof (lname)), 58467c478bd9Sstevel@tonic-gate pr_ap6(&tp6->tcp6ConnRemAddress, 5847e11c3f44Smeem tp6->tcp6ConnRemPort, "tcp", fname, sizeof (fname)), 58487c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_swnd, 58497c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_snxt, 58507c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_suna, 58517c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_rwnd, 58527c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_rnxt, 58537c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_rack, 58547c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_rto, 58557c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_mss, 585645916cd2Sjpk mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 585745916cd2Sjpk ifnamep); 585878a2e113SAndy Fiddaman } else if (!Uflag) { 585978a2e113SAndy Fiddaman (void) printf( 586078a2e113SAndy Fiddaman TCP_V6_LOCAL_F " " TCP_V6_REMOTE_F " " 586178a2e113SAndy Fiddaman TCP_V6_SWIND_F " " TCP_V6_SENDQ_F " " 586278a2e113SAndy Fiddaman TCP_V6_RWIND_F " " TCP_V6_RECVQ_F " " 586378a2e113SAndy Fiddaman TCP_V6_STATE_F " %s\n", 58647c478bd9Sstevel@tonic-gate pr_ap6(&tp6->tcp6ConnLocalAddress, 5865e11c3f44Smeem tp6->tcp6ConnLocalPort, "tcp", lname, sizeof (lname)), 58667c478bd9Sstevel@tonic-gate pr_ap6(&tp6->tcp6ConnRemAddress, 5867e11c3f44Smeem tp6->tcp6ConnRemPort, "tcp", fname, sizeof (fname)), 58687c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_swnd, 58697c478bd9Sstevel@tonic-gate (sq >= 0) ? sq : 0, 58707c478bd9Sstevel@tonic-gate tp6->tcp6ConnEntryInfo.ce_rwnd, 58717c478bd9Sstevel@tonic-gate (rq >= 0) ? rq : 0, 587245916cd2Sjpk mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 587345916cd2Sjpk ifnamep); 587478a2e113SAndy Fiddaman } else if (Uflag && Vflag) { 587578a2e113SAndy Fiddaman for (ph = process_hash_get(sie, SOCK_STREAM, AF_INET6); 587678a2e113SAndy Fiddaman ph != NULL; ph = ph->ph_next_proc) { 587778a2e113SAndy Fiddaman (void) printf( 587878a2e113SAndy Fiddaman TCP_V6_LOCAL_F "\n" TCP_V6_REMOTE_F " " 587978a2e113SAndy Fiddaman TCP_V6_SWIND_F " " TCP_V6_SNEXT_F " " 588078a2e113SAndy Fiddaman TCP_V6_SUNA_F " " TCP_V6_RWIND_F " " 588178a2e113SAndy Fiddaman TCP_V6_RNEXT_F " " TCP_V6_RACK_F " " 588278a2e113SAndy Fiddaman TCP_V6_RTO_F " " TCP_V6_MSS_F " " 588378a2e113SAndy Fiddaman TCP_V6_STATE_F " " TCP_V6_IF_F " " 588478a2e113SAndy Fiddaman TCP_V6_USER_F " " TCP_V6_PID_F " %s\n", 588578a2e113SAndy Fiddaman pr_ap6(&tp6->tcp6ConnLocalAddress, 588678a2e113SAndy Fiddaman tp6->tcp6ConnLocalPort, "tcp", lname, 588778a2e113SAndy Fiddaman sizeof (lname)), 588878a2e113SAndy Fiddaman pr_ap6(&tp6->tcp6ConnRemAddress, 588978a2e113SAndy Fiddaman tp6->tcp6ConnRemPort, "tcp", fname, 589078a2e113SAndy Fiddaman sizeof (fname)), 589178a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_swnd, 589278a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_snxt, 589378a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_suna, 589478a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_rwnd, 589578a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_rnxt, 589678a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_rack, 589778a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_rto, 589878a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_mss, 589978a2e113SAndy Fiddaman mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 590078a2e113SAndy Fiddaman ifnamep, 590178a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, ph->ph_psargs); 590278a2e113SAndy Fiddaman } 590378a2e113SAndy Fiddaman } else if (Uflag) { 590478a2e113SAndy Fiddaman for (ph = process_hash_get(sie, SOCK_STREAM, AF_INET6); 590578a2e113SAndy Fiddaman ph != NULL; ph = ph->ph_next_proc) { 590678a2e113SAndy Fiddaman (void) printf( 590778a2e113SAndy Fiddaman TCP_V6_LOCAL_F " " TCP_V6_REMOTE_F " " 590878a2e113SAndy Fiddaman TCP_V6_USER_F " " TCP_V6_PID_F " " 590978a2e113SAndy Fiddaman TCP_V6_COMMAND_F " " 591078a2e113SAndy Fiddaman TCP_V6_SWIND_F " " TCP_V6_SENDQ_F " " 591178a2e113SAndy Fiddaman TCP_V6_RWIND_F " " TCP_V6_RECVQ_F " " 591278a2e113SAndy Fiddaman TCP_V6_STATE_F " %s\n", 591378a2e113SAndy Fiddaman pr_ap6(&tp6->tcp6ConnLocalAddress, 591478a2e113SAndy Fiddaman tp6->tcp6ConnLocalPort, "tcp", lname, 591578a2e113SAndy Fiddaman sizeof (lname)), 591678a2e113SAndy Fiddaman pr_ap6(&tp6->tcp6ConnRemAddress, 591778a2e113SAndy Fiddaman tp6->tcp6ConnRemPort, "tcp", fname, sizeof (fname)), 591878a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, ph->ph_fname, 591978a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_swnd, 592078a2e113SAndy Fiddaman (sq >= 0) ? sq : 0, 592178a2e113SAndy Fiddaman tp6->tcp6ConnEntryInfo.ce_rwnd, 592278a2e113SAndy Fiddaman (rq >= 0) ? rq : 0, 592378a2e113SAndy Fiddaman mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 592478a2e113SAndy Fiddaman ifnamep); 592578a2e113SAndy Fiddaman } 59267c478bd9Sstevel@tonic-gate } 592745916cd2Sjpk 592845916cd2Sjpk print_transport_label(attr); 592945916cd2Sjpk 593045916cd2Sjpk return (B_FALSE); 59317c478bd9Sstevel@tonic-gate } 59327c478bd9Sstevel@tonic-gate 59337c478bd9Sstevel@tonic-gate /* ------------------------------- UDP_REPORT------------------------------- */ 59347c478bd9Sstevel@tonic-gate 593578a2e113SAndy Fiddaman static boolean_t udp_report_item_v4(const mib2_udpEntry_t *, boolean_t, 593678a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *, const mib2_socketInfoEntry_t *); 593778a2e113SAndy Fiddaman static boolean_t udp_report_item_v6(const mib2_udp6Entry_t *, boolean_t, 593878a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *, const mib2_socketInfoEntry_t *); 593978a2e113SAndy Fiddaman 594078a2e113SAndy Fiddaman /* 594178a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 594278a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 594378a2e113SAndy Fiddaman * the formatted value. 594478a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 594578a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 594678a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 594778a2e113SAndy Fiddaman */ 594878a2e113SAndy Fiddaman #define UDP_V4_LOCAL " Local Address " 594978a2e113SAndy Fiddaman #define UDP_V4_LOCAL_ "--------------------" 595078a2e113SAndy Fiddaman #define UDP_V4_LOCAL_F "%-20s" 595178a2e113SAndy Fiddaman #define UDP_V4_REMOTE " Remote Address " 595278a2e113SAndy Fiddaman #define UDP_V4_REMOTE_ "--------------------" 595378a2e113SAndy Fiddaman #define UDP_V4_REMOTE_F "%-20s" 595478a2e113SAndy Fiddaman #define UDP_V4_STATE " State " 595578a2e113SAndy Fiddaman #define UDP_V4_STATE_ "----------" 595678a2e113SAndy Fiddaman #define UDP_V4_STATE_F "%-10.10s" 595778a2e113SAndy Fiddaman #define UDP_V4_USER " User " 595878a2e113SAndy Fiddaman #define UDP_V4_USER_ "--------" 595978a2e113SAndy Fiddaman #define UDP_V4_USER_F "%-8.8s" 596078a2e113SAndy Fiddaman #define UDP_V4_PID " Pid " 596178a2e113SAndy Fiddaman #define UDP_V4_PID_ "------" 596278a2e113SAndy Fiddaman #define UDP_V4_PID_F "%6s" 596378a2e113SAndy Fiddaman #define UDP_V4_COMMAND " Command " 596478a2e113SAndy Fiddaman #define UDP_V4_COMMAND_ "--------------" 596578a2e113SAndy Fiddaman #define UDP_V4_COMMAND_F "%-14.14s" 596645916cd2Sjpk 596745916cd2Sjpk static const char udp_hdr_v4[] = 596878a2e113SAndy Fiddaman UDP_V4_LOCAL " " UDP_V4_REMOTE " " UDP_V4_STATE "\n" 596978a2e113SAndy Fiddaman UDP_V4_LOCAL_" " UDP_V4_REMOTE_" " UDP_V4_STATE_"\n"; 597078a2e113SAndy Fiddaman 597178a2e113SAndy Fiddaman static const char udp_hdr_v4_pid[] = 597278a2e113SAndy Fiddaman UDP_V4_LOCAL " " UDP_V4_REMOTE " " 597378a2e113SAndy Fiddaman UDP_V4_USER " " UDP_V4_PID " " UDP_V4_COMMAND " " UDP_V4_STATE "\n" 597478a2e113SAndy Fiddaman UDP_V4_LOCAL_" " UDP_V4_REMOTE_" " 597578a2e113SAndy Fiddaman UDP_V4_USER_" " UDP_V4_PID_" " UDP_V4_COMMAND_" " UDP_V4_STATE_"\n"; 597678a2e113SAndy Fiddaman static const char udp_hdr_v4_pid_verbose[] = 597778a2e113SAndy Fiddaman UDP_V4_LOCAL " " UDP_V4_REMOTE " " 597878a2e113SAndy Fiddaman UDP_V4_USER " " UDP_V4_PID " " UDP_V4_STATE " " UDP_V4_COMMAND "\n" 597978a2e113SAndy Fiddaman UDP_V4_LOCAL_" " UDP_V4_REMOTE_" " 598078a2e113SAndy Fiddaman UDP_V4_USER_" " UDP_V4_PID_" " UDP_V4_STATE_" " UDP_V4_COMMAND_"\n"; 598178a2e113SAndy Fiddaman 598278a2e113SAndy Fiddaman #define UDP_V6_LOCAL " Local Address " 598378a2e113SAndy Fiddaman #define UDP_V6_LOCAL_ "---------------------------------" 598478a2e113SAndy Fiddaman #define UDP_V6_LOCAL_F "%-33s" 598578a2e113SAndy Fiddaman #define UDP_V6_REMOTE " Remote Address " 598678a2e113SAndy Fiddaman #define UDP_V6_REMOTE_ "---------------------------------" 598778a2e113SAndy Fiddaman #define UDP_V6_REMOTE_F "%-33s" 598878a2e113SAndy Fiddaman #define UDP_V6_STATE UDP_V4_STATE 598978a2e113SAndy Fiddaman #define UDP_V6_STATE_ UDP_V4_STATE_ 599078a2e113SAndy Fiddaman #define UDP_V6_STATE_F UDP_V4_STATE_F 599178a2e113SAndy Fiddaman #define UDP_V6_USER UDP_V4_USER 599278a2e113SAndy Fiddaman #define UDP_V6_USER_ UDP_V4_USER_ 599378a2e113SAndy Fiddaman #define UDP_V6_USER_F UDP_V4_USER_F 599478a2e113SAndy Fiddaman #define UDP_V6_PID UDP_V4_PID 599578a2e113SAndy Fiddaman #define UDP_V6_PID_ UDP_V4_PID_ 599678a2e113SAndy Fiddaman #define UDP_V6_PID_F UDP_V4_PID_F 599778a2e113SAndy Fiddaman #define UDP_V6_COMMAND UDP_V4_COMMAND 599878a2e113SAndy Fiddaman #define UDP_V6_COMMAND_ UDP_V4_COMMAND_ 599978a2e113SAndy Fiddaman #define UDP_V6_COMMAND_F UDP_V4_COMMAND_F 600078a2e113SAndy Fiddaman #define UDP_V6_IF " If " 600178a2e113SAndy Fiddaman #define UDP_V6_IF_ "-----" 600278a2e113SAndy Fiddaman #define UDP_V6_IF_F "%-5.5s" 60037c478bd9Sstevel@tonic-gate 600445916cd2Sjpk static const char udp_hdr_v6[] = 600578a2e113SAndy Fiddaman UDP_V6_LOCAL " " UDP_V6_REMOTE " " UDP_V6_STATE " " 600678a2e113SAndy Fiddaman UDP_V6_IF "\n" 600778a2e113SAndy Fiddaman UDP_V6_LOCAL_" " UDP_V6_REMOTE_" " UDP_V6_STATE_" " 600878a2e113SAndy Fiddaman UDP_V6_IF_"\n"; 600978a2e113SAndy Fiddaman 601078a2e113SAndy Fiddaman static const char udp_hdr_v6_pid[] = 601178a2e113SAndy Fiddaman UDP_V6_LOCAL " " UDP_V6_REMOTE " " 601278a2e113SAndy Fiddaman UDP_V6_USER " " UDP_V6_PID " " UDP_V6_COMMAND " " 601378a2e113SAndy Fiddaman UDP_V6_STATE " " UDP_V6_IF "\n" 601478a2e113SAndy Fiddaman UDP_V6_LOCAL_" " UDP_V6_REMOTE_" " 601578a2e113SAndy Fiddaman UDP_V6_USER_" " UDP_V6_PID_" " UDP_V6_COMMAND_" " 601678a2e113SAndy Fiddaman UDP_V6_STATE_" " UDP_V6_IF_"\n"; 601778a2e113SAndy Fiddaman 601878a2e113SAndy Fiddaman static const char udp_hdr_v6_pid_verbose[] = 601978a2e113SAndy Fiddaman UDP_V6_LOCAL " " UDP_V6_REMOTE " " 602078a2e113SAndy Fiddaman UDP_V6_USER " " UDP_V6_PID " " UDP_V6_STATE " " 602178a2e113SAndy Fiddaman UDP_V6_IF " " UDP_V6_COMMAND "\n" 602278a2e113SAndy Fiddaman UDP_V6_LOCAL_" " UDP_V6_REMOTE_" " 602378a2e113SAndy Fiddaman UDP_V6_USER_" " UDP_V6_PID_" " UDP_V6_STATE_" " 602478a2e113SAndy Fiddaman UDP_V6_IF_" " UDP_V6_COMMAND_ "\n"; 60257c478bd9Sstevel@tonic-gate 60267c478bd9Sstevel@tonic-gate static void 602745916cd2Sjpk udp_report(const mib_item_t *item) 60287c478bd9Sstevel@tonic-gate { 602978a2e113SAndy Fiddaman int jtemp = 0; 603078a2e113SAndy Fiddaman boolean_t print_hdr_once_v4 = B_TRUE; 603178a2e113SAndy Fiddaman boolean_t print_hdr_once_v6 = B_TRUE; 603278a2e113SAndy Fiddaman mib2_udpEntry_t *ude; 603378a2e113SAndy Fiddaman mib2_udp6Entry_t *ude6; 603478a2e113SAndy Fiddaman mib2_transportMLPEntry_t **v4_attrs, **v6_attrs, **v4a, **v6a; 603578a2e113SAndy Fiddaman mib2_transportMLPEntry_t *aptr; 603678a2e113SAndy Fiddaman mib2_socketInfoEntry_t **v4_info, **v6_info, **v4i, **v6i; 603778a2e113SAndy Fiddaman mib2_socketInfoEntry_t *iptr; 60387c478bd9Sstevel@tonic-gate 60397c478bd9Sstevel@tonic-gate if (!protocol_selected(IPPROTO_UDP)) 60407c478bd9Sstevel@tonic-gate return; 60417c478bd9Sstevel@tonic-gate 604245916cd2Sjpk /* 604345916cd2Sjpk * Preparation pass: the kernel returns separate entries for UDP 604445916cd2Sjpk * connection table entries and Multilevel Port attributes. We loop 604545916cd2Sjpk * through the attributes first and set up an array for each address 604645916cd2Sjpk * family. 604745916cd2Sjpk */ 604845916cd2Sjpk v4_attrs = family_selected(AF_INET) && RSECflag ? 604945916cd2Sjpk gather_attrs(item, MIB2_UDP, MIB2_UDP_ENTRY, udpEntrySize) : NULL; 605045916cd2Sjpk v6_attrs = family_selected(AF_INET6) && RSECflag ? 605145916cd2Sjpk gather_attrs(item, MIB2_UDP6, MIB2_UDP6_ENTRY, udp6EntrySize) : 605245916cd2Sjpk NULL; 605345916cd2Sjpk 605478a2e113SAndy Fiddaman v4_info = Uflag && family_selected(AF_INET) ? 605578a2e113SAndy Fiddaman gather_info(item, MIB2_UDP, MIB2_UDP_ENTRY, udpEntrySize) : 605678a2e113SAndy Fiddaman NULL; 605778a2e113SAndy Fiddaman v6_info = Uflag && family_selected(AF_INET6) ? 605878a2e113SAndy Fiddaman gather_info(item, MIB2_UDP6, MIB2_UDP6_ENTRY, udp6EntrySize) : 605978a2e113SAndy Fiddaman NULL; 606078a2e113SAndy Fiddaman 606145916cd2Sjpk v4a = v4_attrs; 606245916cd2Sjpk v6a = v6_attrs; 606378a2e113SAndy Fiddaman v4i = v4_info; 606478a2e113SAndy Fiddaman v6i = v6_info; 60657c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 6066bd670b35SErik Nordmark if (Xflag) { 606778a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 606878a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 60697c478bd9Sstevel@tonic-gate item->group, item->mib_id, 60707c478bd9Sstevel@tonic-gate item->length, item->valp); 60717c478bd9Sstevel@tonic-gate } 60727c478bd9Sstevel@tonic-gate if (!((item->group == MIB2_UDP && 60737c478bd9Sstevel@tonic-gate item->mib_id == MIB2_UDP_ENTRY) || 60747c478bd9Sstevel@tonic-gate (item->group == MIB2_UDP6 && 60757c478bd9Sstevel@tonic-gate item->mib_id == MIB2_UDP6_ENTRY))) 607678a2e113SAndy Fiddaman continue; 60777c478bd9Sstevel@tonic-gate 60787c478bd9Sstevel@tonic-gate if (item->group == MIB2_UDP && !family_selected(AF_INET)) 607978a2e113SAndy Fiddaman continue; 60807c478bd9Sstevel@tonic-gate else if (item->group == MIB2_UDP6 && !family_selected(AF_INET6)) 608178a2e113SAndy Fiddaman continue; 60827c478bd9Sstevel@tonic-gate 60837c478bd9Sstevel@tonic-gate if (item->group == MIB2_UDP) { 60847c478bd9Sstevel@tonic-gate for (ude = (mib2_udpEntry_t *)item->valp; 60857c478bd9Sstevel@tonic-gate (char *)ude < (char *)item->valp + item->length; 60867c478bd9Sstevel@tonic-gate ude = (mib2_udpEntry_t *)((char *)ude + 60877c478bd9Sstevel@tonic-gate udpEntrySize)) { 608845916cd2Sjpk aptr = v4a == NULL ? NULL : *v4a++; 608978a2e113SAndy Fiddaman iptr = v4i == NULL ? NULL : *v4i++; 60907c478bd9Sstevel@tonic-gate print_hdr_once_v4 = udp_report_item_v4(ude, 609178a2e113SAndy Fiddaman print_hdr_once_v4, aptr, iptr); 60927c478bd9Sstevel@tonic-gate } 60937c478bd9Sstevel@tonic-gate } else { 60947c478bd9Sstevel@tonic-gate for (ude6 = (mib2_udp6Entry_t *)item->valp; 60957c478bd9Sstevel@tonic-gate (char *)ude6 < (char *)item->valp + item->length; 60967c478bd9Sstevel@tonic-gate ude6 = (mib2_udp6Entry_t *)((char *)ude6 + 60977c478bd9Sstevel@tonic-gate udp6EntrySize)) { 609845916cd2Sjpk aptr = v6a == NULL ? NULL : *v6a++; 609978a2e113SAndy Fiddaman iptr = v6i == NULL ? NULL : *v6i++; 61007c478bd9Sstevel@tonic-gate print_hdr_once_v6 = udp_report_item_v6(ude6, 610178a2e113SAndy Fiddaman print_hdr_once_v6, aptr, iptr); 61027c478bd9Sstevel@tonic-gate } 61037c478bd9Sstevel@tonic-gate } 610478a2e113SAndy Fiddaman 610578a2e113SAndy Fiddaman } 61067c478bd9Sstevel@tonic-gate (void) fflush(stdout); 610745916cd2Sjpk 610878a2e113SAndy Fiddaman free(v4_attrs); 610978a2e113SAndy Fiddaman free(v6_attrs); 611078a2e113SAndy Fiddaman free(v4_info); 611178a2e113SAndy Fiddaman free(v6_info); 61127c478bd9Sstevel@tonic-gate } 61137c478bd9Sstevel@tonic-gate 61147c478bd9Sstevel@tonic-gate static boolean_t 611545916cd2Sjpk udp_report_item_v4(const mib2_udpEntry_t *ude, boolean_t first, 611678a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *attr, const mib2_socketInfoEntry_t *sie) 61177c478bd9Sstevel@tonic-gate { 611878a2e113SAndy Fiddaman char *leadin; 61197c478bd9Sstevel@tonic-gate char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 61207c478bd9Sstevel@tonic-gate /* hostname + portname */ 612178a2e113SAndy Fiddaman proc_fdinfo_t *ph; 61227c478bd9Sstevel@tonic-gate 61237c478bd9Sstevel@tonic-gate if (!(Aflag || ude->udpEntryInfo.ue_state >= MIB2_UDP_connected)) 61247c478bd9Sstevel@tonic-gate return (first); /* Nothing to print */ 61257c478bd9Sstevel@tonic-gate 61267c478bd9Sstevel@tonic-gate if (first) { 612745916cd2Sjpk (void) printf(v4compat ? "\nUDP\n" : "\nUDP: IPv4\n"); 612878a2e113SAndy Fiddaman 612978a2e113SAndy Fiddaman if (Uflag) 613078a2e113SAndy Fiddaman (void) printf(Vflag ? udp_hdr_v4_pid_verbose : 613178a2e113SAndy Fiddaman udp_hdr_v4_pid); 613278a2e113SAndy Fiddaman else 613378a2e113SAndy Fiddaman (void) printf(udp_hdr_v4); 613478a2e113SAndy Fiddaman 61357c478bd9Sstevel@tonic-gate first = B_FALSE; 61367c478bd9Sstevel@tonic-gate } 61377c478bd9Sstevel@tonic-gate 613878a2e113SAndy Fiddaman if (Xflag) 613978a2e113SAndy Fiddaman sie_report(sie); 614078a2e113SAndy Fiddaman 614178a2e113SAndy Fiddaman if (asprintf(&leadin, 614278a2e113SAndy Fiddaman UDP_V4_LOCAL_F " " UDP_V4_REMOTE_F " ", 61437c478bd9Sstevel@tonic-gate pr_ap(ude->udpLocalAddress, ude->udpLocalPort, "udp", 614478a2e113SAndy Fiddaman lname, sizeof (lname)), 614545916cd2Sjpk ude->udpEntryInfo.ue_state == MIB2_UDP_connected ? 614645916cd2Sjpk pr_ap(ude->udpEntryInfo.ue_RemoteAddress, 614745916cd2Sjpk ude->udpEntryInfo.ue_RemotePort, "udp", lname, sizeof (lname)) : 614878a2e113SAndy Fiddaman "") == -1) { 614978a2e113SAndy Fiddaman fatal(1, "Out of memory"); 615078a2e113SAndy Fiddaman } 615178a2e113SAndy Fiddaman if (!Uflag) { 615278a2e113SAndy Fiddaman (void) printf("%s%s\n", 615378a2e113SAndy Fiddaman leadin, miudp_state(ude->udpEntryInfo.ue_state, attr)); 615478a2e113SAndy Fiddaman } else { 615578a2e113SAndy Fiddaman ph = process_hash_get(sie, SOCK_DGRAM, AF_INET); 615678a2e113SAndy Fiddaman if (ph->ph_pid == 0 && sie != NULL && 615778a2e113SAndy Fiddaman (sie->sie_flags & MIB2_SOCKINFO_IPV6)) 615878a2e113SAndy Fiddaman ph = process_hash_get(sie, SOCK_DGRAM, AF_INET6); 615978a2e113SAndy Fiddaman for (; ph != NULL; ph = ph->ph_next_proc) { 616078a2e113SAndy Fiddaman (void) printf("%s" UDP_V4_USER_F " " UDP_V4_PID_F " ", 616178a2e113SAndy Fiddaman leadin, ph->ph_username, ph->ph_pidstr); 616278a2e113SAndy Fiddaman if (Vflag) { 616378a2e113SAndy Fiddaman (void) printf(UDP_V4_STATE_F " %s\n", 616478a2e113SAndy Fiddaman miudp_state(ude->udpEntryInfo.ue_state, 616578a2e113SAndy Fiddaman attr), 616678a2e113SAndy Fiddaman ph->ph_psargs); 616778a2e113SAndy Fiddaman } else { 616878a2e113SAndy Fiddaman (void) printf(UDP_V4_COMMAND_F " %s\n", 616978a2e113SAndy Fiddaman ph->ph_fname, 617078a2e113SAndy Fiddaman miudp_state(ude->udpEntryInfo.ue_state, 617178a2e113SAndy Fiddaman attr)); 617278a2e113SAndy Fiddaman } 617378a2e113SAndy Fiddaman } 617478a2e113SAndy Fiddaman } 617545916cd2Sjpk 6176bd670b35SErik Nordmark print_transport_label(attr); 617745916cd2Sjpk 617878a2e113SAndy Fiddaman free(leadin); 617978a2e113SAndy Fiddaman 61807c478bd9Sstevel@tonic-gate return (first); 61817c478bd9Sstevel@tonic-gate } 61827c478bd9Sstevel@tonic-gate 61837c478bd9Sstevel@tonic-gate static boolean_t 618445916cd2Sjpk udp_report_item_v6(const mib2_udp6Entry_t *ude6, boolean_t first, 618578a2e113SAndy Fiddaman const mib2_transportMLPEntry_t *attr, const mib2_socketInfoEntry_t *sie) 61867c478bd9Sstevel@tonic-gate { 618778a2e113SAndy Fiddaman char *leadin; 618878a2e113SAndy Fiddaman char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 61897c478bd9Sstevel@tonic-gate /* hostname + portname */ 619078a2e113SAndy Fiddaman char ifname[LIFNAMSIZ + 1]; 619178a2e113SAndy Fiddaman const char *ifnamep; 619278a2e113SAndy Fiddaman proc_fdinfo_t *ph; 61937c478bd9Sstevel@tonic-gate 61947c478bd9Sstevel@tonic-gate if (!(Aflag || ude6->udp6EntryInfo.ue_state >= MIB2_UDP_connected)) 61957c478bd9Sstevel@tonic-gate return (first); /* Nothing to print */ 61967c478bd9Sstevel@tonic-gate 61977c478bd9Sstevel@tonic-gate if (first) { 619845916cd2Sjpk (void) printf("\nUDP: IPv6\n"); 619978a2e113SAndy Fiddaman 620078a2e113SAndy Fiddaman if (Uflag) 620178a2e113SAndy Fiddaman (void) printf(Vflag ? udp_hdr_v6_pid_verbose : 620278a2e113SAndy Fiddaman udp_hdr_v6_pid); 620378a2e113SAndy Fiddaman else 620478a2e113SAndy Fiddaman (void) printf(udp_hdr_v6); 620578a2e113SAndy Fiddaman 62067c478bd9Sstevel@tonic-gate first = B_FALSE; 62077c478bd9Sstevel@tonic-gate } 62087c478bd9Sstevel@tonic-gate 620945916cd2Sjpk ifnamep = (ude6->udp6IfIndex != 0) ? 621045916cd2Sjpk if_indextoname(ude6->udp6IfIndex, ifname) : NULL; 621145916cd2Sjpk 621278a2e113SAndy Fiddaman if (Xflag) 621378a2e113SAndy Fiddaman sie_report(sie); 621478a2e113SAndy Fiddaman 621578a2e113SAndy Fiddaman if (asprintf(&leadin, 621678a2e113SAndy Fiddaman UDP_V6_LOCAL_F " " UDP_V6_REMOTE_F " ", 62177c478bd9Sstevel@tonic-gate pr_ap6(&ude6->udp6LocalAddress, 621878a2e113SAndy Fiddaman ude6->udp6LocalPort, "udp", lname, sizeof (lname)), 621945916cd2Sjpk ude6->udp6EntryInfo.ue_state == MIB2_UDP_connected ? 622045916cd2Sjpk pr_ap6(&ude6->udp6EntryInfo.ue_RemoteAddress, 622145916cd2Sjpk ude6->udp6EntryInfo.ue_RemotePort, "udp", lname, sizeof (lname)) : 622278a2e113SAndy Fiddaman "") == -1) { 622378a2e113SAndy Fiddaman fatal(1, "Out of memory"); 622478a2e113SAndy Fiddaman } 622578a2e113SAndy Fiddaman if (!Uflag) { 622678a2e113SAndy Fiddaman (void) printf("%s" UDP_V6_STATE_F " %s\n", leadin, 622778a2e113SAndy Fiddaman miudp_state(ude6->udp6EntryInfo.ue_state, attr), 622878a2e113SAndy Fiddaman ifnamep == NULL ? "" : ifnamep); 622978a2e113SAndy Fiddaman } else { 623078a2e113SAndy Fiddaman for (ph = process_hash_get(sie, SOCK_DGRAM, AF_INET6); 623178a2e113SAndy Fiddaman ph != NULL; ph = ph->ph_next_proc) { 623278a2e113SAndy Fiddaman (void) printf("%s" UDP_V6_USER_F " " UDP_V6_PID_F " ", 623378a2e113SAndy Fiddaman leadin, ph->ph_username, ph->ph_pidstr); 623478a2e113SAndy Fiddaman if (Vflag) { 623578a2e113SAndy Fiddaman (void) printf( 623678a2e113SAndy Fiddaman UDP_V6_STATE_F " " UDP_V6_IF_F " %s\n", 623778a2e113SAndy Fiddaman miudp_state(ude6->udp6EntryInfo.ue_state, 623878a2e113SAndy Fiddaman attr), 623978a2e113SAndy Fiddaman ifnamep == NULL ? "" : ifnamep, 624078a2e113SAndy Fiddaman ph->ph_psargs); 624178a2e113SAndy Fiddaman } else { 624278a2e113SAndy Fiddaman (void) printf( 624378a2e113SAndy Fiddaman UDP_V6_COMMAND_F " " UDP_V6_STATE_F " %s\n", 624478a2e113SAndy Fiddaman ph->ph_fname, 624578a2e113SAndy Fiddaman miudp_state(ude6->udp6EntryInfo.ue_state, 624678a2e113SAndy Fiddaman attr), 624778a2e113SAndy Fiddaman ifnamep == NULL ? "" : ifnamep); 624878a2e113SAndy Fiddaman } 624978a2e113SAndy Fiddaman } 625078a2e113SAndy Fiddaman } 625145916cd2Sjpk 6252bd670b35SErik Nordmark print_transport_label(attr); 625345916cd2Sjpk 625478a2e113SAndy Fiddaman free(leadin); 625578a2e113SAndy Fiddaman 62567c478bd9Sstevel@tonic-gate return (first); 62577c478bd9Sstevel@tonic-gate } 62587c478bd9Sstevel@tonic-gate 62597c478bd9Sstevel@tonic-gate /* ------------------------------ SCTP_REPORT------------------------------- */ 62607c478bd9Sstevel@tonic-gate 626178a2e113SAndy Fiddaman /* 626278a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 626378a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 626478a2e113SAndy Fiddaman * the formatted value. 626578a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 626678a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 626778a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 626878a2e113SAndy Fiddaman */ 626978a2e113SAndy Fiddaman #define SCTP_LOCAL " Local Address " 627078a2e113SAndy Fiddaman #define SCTP_LOCAL_ "-------------------------------" 627178a2e113SAndy Fiddaman #define SCTP_LOCAL_F "%-31s" 627278a2e113SAndy Fiddaman #define SCTP_REMOTE " Remote Address " 627378a2e113SAndy Fiddaman #define SCTP_REMOTE_ "-------------------------------" 627478a2e113SAndy Fiddaman #define SCTP_REMOTE_F "%-31s" 627578a2e113SAndy Fiddaman #define SCTP_SWIND "Swind " 627678a2e113SAndy Fiddaman #define SCTP_SWIND_ "------" 627778a2e113SAndy Fiddaman #define SCTP_SWIND_F "%6u" 627878a2e113SAndy Fiddaman #define SCTP_SENDQ "Send-Q" 627978a2e113SAndy Fiddaman #define SCTP_SENDQ_ "------" 628078a2e113SAndy Fiddaman #define SCTP_SENDQ_F "%6d" 628178a2e113SAndy Fiddaman #define SCTP_RWIND "Rwind " 628278a2e113SAndy Fiddaman #define SCTP_RWIND_ "------" 628378a2e113SAndy Fiddaman #define SCTP_RWIND_F "%6d" 628478a2e113SAndy Fiddaman #define SCTP_RECVQ "Recv-Q" 628578a2e113SAndy Fiddaman #define SCTP_RECVQ_ "------" 628678a2e113SAndy Fiddaman #define SCTP_RECVQ_F "%6u" 628778a2e113SAndy Fiddaman #define SCTP_STRS "StrsI/O" 628878a2e113SAndy Fiddaman #define SCTP_STRS_ "-------" 628978a2e113SAndy Fiddaman #define SCTP_STRS_FI "%3d" 629078a2e113SAndy Fiddaman #define SCTP_STRS_FO "%-3d" 629178a2e113SAndy Fiddaman #define SCTP_STATE " State " 629278a2e113SAndy Fiddaman #define SCTP_STATE_ "-----------" 629378a2e113SAndy Fiddaman #define SCTP_STATE_F "%-11.11s" 629478a2e113SAndy Fiddaman #define SCTP_USER " User " 629578a2e113SAndy Fiddaman #define SCTP_USER_ "--------" 629678a2e113SAndy Fiddaman #define SCTP_USER_F "%-8.8s" 629778a2e113SAndy Fiddaman #define SCTP_PID " Pid " 629878a2e113SAndy Fiddaman #define SCTP_PID_ "------" 629978a2e113SAndy Fiddaman #define SCTP_PID_F "%6s" 630078a2e113SAndy Fiddaman #define SCTP_COMMAND " Command " 630178a2e113SAndy Fiddaman #define SCTP_COMMAND_ "--------------" 630278a2e113SAndy Fiddaman #define SCTP_COMMAND_F "%-14.14s" 630378a2e113SAndy Fiddaman 63047c478bd9Sstevel@tonic-gate static const char sctp_hdr[] = 63057c478bd9Sstevel@tonic-gate "\nSCTP:"; 63067c478bd9Sstevel@tonic-gate static const char sctp_hdr_normal[] = 630778a2e113SAndy Fiddaman SCTP_LOCAL " " SCTP_REMOTE " " 630878a2e113SAndy Fiddaman SCTP_SWIND " " SCTP_SENDQ " " SCTP_RWIND " " SCTP_RECVQ " " 630978a2e113SAndy Fiddaman SCTP_STRS " " SCTP_STATE "\n" 631078a2e113SAndy Fiddaman SCTP_LOCAL_" " SCTP_REMOTE_" " 631178a2e113SAndy Fiddaman SCTP_SWIND_" " SCTP_SENDQ_" " SCTP_RWIND_" " SCTP_RECVQ_" " 631278a2e113SAndy Fiddaman SCTP_STRS_" " SCTP_STATE_"\n"; 631378a2e113SAndy Fiddaman 631478a2e113SAndy Fiddaman static const char sctp_hdr_pid[] = 631578a2e113SAndy Fiddaman SCTP_LOCAL " " SCTP_REMOTE " " 631678a2e113SAndy Fiddaman SCTP_SWIND " " SCTP_SENDQ " " SCTP_RWIND " " SCTP_RECVQ " " 631778a2e113SAndy Fiddaman SCTP_STRS " " 631878a2e113SAndy Fiddaman SCTP_USER " " SCTP_PID " " SCTP_COMMAND " " SCTP_STATE "\n" 631978a2e113SAndy Fiddaman SCTP_LOCAL_" " SCTP_REMOTE_" " 632078a2e113SAndy Fiddaman SCTP_SWIND_" " SCTP_SENDQ_" " SCTP_RWIND_" " SCTP_RECVQ_" " 632178a2e113SAndy Fiddaman SCTP_STRS_" " 632278a2e113SAndy Fiddaman SCTP_USER_" " SCTP_PID_" " SCTP_COMMAND_" " SCTP_STATE_"\n"; 632378a2e113SAndy Fiddaman 632478a2e113SAndy Fiddaman static const char sctp_hdr_pid_verbose[] = 632578a2e113SAndy Fiddaman SCTP_LOCAL " " SCTP_REMOTE " " 632678a2e113SAndy Fiddaman SCTP_SWIND " " SCTP_SENDQ " " SCTP_RWIND " " SCTP_RECVQ " " 632778a2e113SAndy Fiddaman SCTP_STRS_" " 632878a2e113SAndy Fiddaman SCTP_USER " " SCTP_PID " " SCTP_STATE " " SCTP_COMMAND "\n" 632978a2e113SAndy Fiddaman SCTP_LOCAL_" " SCTP_REMOTE_" " 633078a2e113SAndy Fiddaman SCTP_SWIND_" " SCTP_SENDQ_" " SCTP_RWIND_" " SCTP_RECVQ_" " 633178a2e113SAndy Fiddaman SCTP_STRS_" " 633278a2e113SAndy Fiddaman SCTP_USER_" " SCTP_PID_" " SCTP_STATE_" " SCTP_COMMAND_"\n"; 63337c478bd9Sstevel@tonic-gate 63347c478bd9Sstevel@tonic-gate static const char * 633545916cd2Sjpk nssctp_state(int state, const mib2_transportMLPEntry_t *attr) 63367c478bd9Sstevel@tonic-gate { 633745916cd2Sjpk static char sctpsbuf[50]; 633845916cd2Sjpk const char *cp; 633945916cd2Sjpk 63407c478bd9Sstevel@tonic-gate switch (state) { 63417c478bd9Sstevel@tonic-gate case MIB2_SCTP_closed: 634245916cd2Sjpk cp = "CLOSED"; 634345916cd2Sjpk break; 63447c478bd9Sstevel@tonic-gate case MIB2_SCTP_cookieWait: 634545916cd2Sjpk cp = "COOKIE_WAIT"; 634645916cd2Sjpk break; 63477c478bd9Sstevel@tonic-gate case MIB2_SCTP_cookieEchoed: 634845916cd2Sjpk cp = "COOKIE_ECHOED"; 634945916cd2Sjpk break; 63507c478bd9Sstevel@tonic-gate case MIB2_SCTP_established: 635145916cd2Sjpk cp = "ESTABLISHED"; 635245916cd2Sjpk break; 63537c478bd9Sstevel@tonic-gate case MIB2_SCTP_shutdownPending: 635445916cd2Sjpk cp = "SHUTDOWN_PENDING"; 635545916cd2Sjpk break; 63567c478bd9Sstevel@tonic-gate case MIB2_SCTP_shutdownSent: 635745916cd2Sjpk cp = "SHUTDOWN_SENT"; 635845916cd2Sjpk break; 63597c478bd9Sstevel@tonic-gate case MIB2_SCTP_shutdownReceived: 636045916cd2Sjpk cp = "SHUTDOWN_RECEIVED"; 636145916cd2Sjpk break; 63627c478bd9Sstevel@tonic-gate case MIB2_SCTP_shutdownAckSent: 636345916cd2Sjpk cp = "SHUTDOWN_ACK_SENT"; 636445916cd2Sjpk break; 63657c478bd9Sstevel@tonic-gate case MIB2_SCTP_listen: 636645916cd2Sjpk cp = "LISTEN"; 636745916cd2Sjpk break; 63687c478bd9Sstevel@tonic-gate default: 636945916cd2Sjpk (void) snprintf(sctpsbuf, sizeof (sctpsbuf), 637045916cd2Sjpk "UNKNOWN STATE(%d)", state); 637145916cd2Sjpk cp = sctpsbuf; 637245916cd2Sjpk break; 637345916cd2Sjpk } 637445916cd2Sjpk 637545916cd2Sjpk if (RSECflag && attr != NULL && attr->tme_flags != 0) { 637645916cd2Sjpk if (cp != sctpsbuf) { 637745916cd2Sjpk (void) strlcpy(sctpsbuf, cp, sizeof (sctpsbuf)); 637845916cd2Sjpk cp = sctpsbuf; 637945916cd2Sjpk } 638045916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_PRIVATE) 638145916cd2Sjpk (void) strlcat(sctpsbuf, " P", sizeof (sctpsbuf)); 638245916cd2Sjpk if (attr->tme_flags & MIB2_TMEF_SHARED) 638345916cd2Sjpk (void) strlcat(sctpsbuf, " S", sizeof (sctpsbuf)); 63847c478bd9Sstevel@tonic-gate } 638545916cd2Sjpk 638645916cd2Sjpk return (cp); 63877c478bd9Sstevel@tonic-gate } 63887c478bd9Sstevel@tonic-gate 638945916cd2Sjpk static const mib2_sctpConnRemoteEntry_t * 639045916cd2Sjpk sctp_getnext_rem(const mib_item_t **itemp, 639145916cd2Sjpk const mib2_sctpConnRemoteEntry_t *current, uint32_t associd) 63927c478bd9Sstevel@tonic-gate { 639345916cd2Sjpk const mib_item_t *item = *itemp; 639445916cd2Sjpk const mib2_sctpConnRemoteEntry_t *sre; 63957c478bd9Sstevel@tonic-gate 63967c478bd9Sstevel@tonic-gate for (; item != NULL; item = item->next_item, current = NULL) { 63977c478bd9Sstevel@tonic-gate if (!(item->group == MIB2_SCTP && 63987c478bd9Sstevel@tonic-gate item->mib_id == MIB2_SCTP_CONN_REMOTE)) { 63997c478bd9Sstevel@tonic-gate continue; 64007c478bd9Sstevel@tonic-gate } 64017c478bd9Sstevel@tonic-gate 64027c478bd9Sstevel@tonic-gate if (current != NULL) { 640345916cd2Sjpk sre = (const mib2_sctpConnRemoteEntry_t *) 640445916cd2Sjpk ((const char *)current + sctpRemoteEntrySize); 64057c478bd9Sstevel@tonic-gate } else { 64067c478bd9Sstevel@tonic-gate sre = item->valp; 64077c478bd9Sstevel@tonic-gate } 64087c478bd9Sstevel@tonic-gate for (; (char *)sre < (char *)item->valp + item->length; 640945916cd2Sjpk sre = (const mib2_sctpConnRemoteEntry_t *) 641045916cd2Sjpk ((const char *)sre + sctpRemoteEntrySize)) { 64117c478bd9Sstevel@tonic-gate if (sre->sctpAssocId != associd) { 64127c478bd9Sstevel@tonic-gate continue; 64137c478bd9Sstevel@tonic-gate } 64147c478bd9Sstevel@tonic-gate *itemp = item; 64157c478bd9Sstevel@tonic-gate return (sre); 64167c478bd9Sstevel@tonic-gate } 64177c478bd9Sstevel@tonic-gate } 64187c478bd9Sstevel@tonic-gate *itemp = NULL; 64197c478bd9Sstevel@tonic-gate return (NULL); 64207c478bd9Sstevel@tonic-gate } 64217c478bd9Sstevel@tonic-gate 642245916cd2Sjpk static const mib2_sctpConnLocalEntry_t * 642345916cd2Sjpk sctp_getnext_local(const mib_item_t **itemp, 642445916cd2Sjpk const mib2_sctpConnLocalEntry_t *current, uint32_t associd) 64257c478bd9Sstevel@tonic-gate { 642645916cd2Sjpk const mib_item_t *item = *itemp; 642745916cd2Sjpk const mib2_sctpConnLocalEntry_t *sle; 64287c478bd9Sstevel@tonic-gate 64297c478bd9Sstevel@tonic-gate for (; item != NULL; item = item->next_item, current = NULL) { 64307c478bd9Sstevel@tonic-gate if (!(item->group == MIB2_SCTP && 64317c478bd9Sstevel@tonic-gate item->mib_id == MIB2_SCTP_CONN_LOCAL)) { 64327c478bd9Sstevel@tonic-gate continue; 64337c478bd9Sstevel@tonic-gate } 64347c478bd9Sstevel@tonic-gate 64357c478bd9Sstevel@tonic-gate if (current != NULL) { 643645916cd2Sjpk sle = (const mib2_sctpConnLocalEntry_t *) 643745916cd2Sjpk ((const char *)current + sctpLocalEntrySize); 64387c478bd9Sstevel@tonic-gate } else { 64397c478bd9Sstevel@tonic-gate sle = item->valp; 64407c478bd9Sstevel@tonic-gate } 64417c478bd9Sstevel@tonic-gate for (; (char *)sle < (char *)item->valp + item->length; 644245916cd2Sjpk sle = (const mib2_sctpConnLocalEntry_t *) 644345916cd2Sjpk ((const char *)sle + sctpLocalEntrySize)) { 64447c478bd9Sstevel@tonic-gate if (sle->sctpAssocId != associd) { 64457c478bd9Sstevel@tonic-gate continue; 64467c478bd9Sstevel@tonic-gate } 64477c478bd9Sstevel@tonic-gate *itemp = item; 64487c478bd9Sstevel@tonic-gate return (sle); 64497c478bd9Sstevel@tonic-gate } 64507c478bd9Sstevel@tonic-gate } 64517c478bd9Sstevel@tonic-gate *itemp = NULL; 64527c478bd9Sstevel@tonic-gate return (NULL); 64537c478bd9Sstevel@tonic-gate } 64547c478bd9Sstevel@tonic-gate 64557c478bd9Sstevel@tonic-gate static void 64567c478bd9Sstevel@tonic-gate sctp_pr_addr(int type, char *name, int namelen, const in6_addr_t *addr, 64577c478bd9Sstevel@tonic-gate int port) 64587c478bd9Sstevel@tonic-gate { 64597c478bd9Sstevel@tonic-gate ipaddr_t v4addr; 64607c478bd9Sstevel@tonic-gate in6_addr_t v6addr; 64617c478bd9Sstevel@tonic-gate 64627c478bd9Sstevel@tonic-gate /* 64637c478bd9Sstevel@tonic-gate * Address is either a v4 mapped or v6 addr. If 64647c478bd9Sstevel@tonic-gate * it's a v4 mapped, convert to v4 before 64657c478bd9Sstevel@tonic-gate * displaying. 64667c478bd9Sstevel@tonic-gate */ 64677c478bd9Sstevel@tonic-gate switch (type) { 6468e11c3f44Smeem case MIB2_SCTP_ADDR_V4: 64697c478bd9Sstevel@tonic-gate /* v4 */ 64707c478bd9Sstevel@tonic-gate v6addr = *addr; 64717c478bd9Sstevel@tonic-gate 64727c478bd9Sstevel@tonic-gate IN6_V4MAPPED_TO_IPADDR(&v6addr, v4addr); 64737c478bd9Sstevel@tonic-gate if (port > 0) { 64747c478bd9Sstevel@tonic-gate (void) pr_ap(v4addr, port, "sctp", name, namelen); 64757c478bd9Sstevel@tonic-gate } else { 64767c478bd9Sstevel@tonic-gate (void) pr_addr(v4addr, name, namelen); 64777c478bd9Sstevel@tonic-gate } 64787c478bd9Sstevel@tonic-gate break; 64797c478bd9Sstevel@tonic-gate 6480e11c3f44Smeem case MIB2_SCTP_ADDR_V6: 64817c478bd9Sstevel@tonic-gate /* v6 */ 64827c478bd9Sstevel@tonic-gate if (port > 0) { 64837c478bd9Sstevel@tonic-gate (void) pr_ap6(addr, port, "sctp", name, namelen); 64847c478bd9Sstevel@tonic-gate } else { 64857c478bd9Sstevel@tonic-gate (void) pr_addr6(addr, name, namelen); 64867c478bd9Sstevel@tonic-gate } 64877c478bd9Sstevel@tonic-gate break; 64887c478bd9Sstevel@tonic-gate 6489e11c3f44Smeem default: 64907c478bd9Sstevel@tonic-gate (void) snprintf(name, namelen, "<unknown addr type>"); 64917c478bd9Sstevel@tonic-gate break; 64927c478bd9Sstevel@tonic-gate } 64937c478bd9Sstevel@tonic-gate } 64947c478bd9Sstevel@tonic-gate 649578a2e113SAndy Fiddaman static boolean_t 649678a2e113SAndy Fiddaman sctp_conn_report_item(const mib_item_t *head, boolean_t print_sctp_hdr, 649778a2e113SAndy Fiddaman const mib2_sctpConnEntry_t *sp, const mib2_transportMLPEntry_t *attr, 649878a2e113SAndy Fiddaman const mib2_socketInfoEntry_t *sie) 64997c478bd9Sstevel@tonic-gate { 65007c478bd9Sstevel@tonic-gate char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 65017c478bd9Sstevel@tonic-gate char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 650245916cd2Sjpk const mib2_sctpConnRemoteEntry_t *sre = NULL; 650345916cd2Sjpk const mib2_sctpConnLocalEntry_t *sle = NULL; 650445916cd2Sjpk const mib_item_t *local = head; 650545916cd2Sjpk const mib_item_t *remote = head; 65067c478bd9Sstevel@tonic-gate uint32_t id = sp->sctpAssocId; 65077c478bd9Sstevel@tonic-gate boolean_t printfirst = B_TRUE; 650878a2e113SAndy Fiddaman proc_fdinfo_t *ph; 650978a2e113SAndy Fiddaman 651078a2e113SAndy Fiddaman if (print_sctp_hdr == B_TRUE) { 651178a2e113SAndy Fiddaman (void) puts(sctp_hdr); 651278a2e113SAndy Fiddaman if (Uflag) 651378a2e113SAndy Fiddaman (void) puts(Vflag ? sctp_hdr_pid_verbose: sctp_hdr_pid); 651478a2e113SAndy Fiddaman else 651578a2e113SAndy Fiddaman (void) puts(sctp_hdr_normal); 651678a2e113SAndy Fiddaman 651778a2e113SAndy Fiddaman print_sctp_hdr = B_FALSE; 651878a2e113SAndy Fiddaman } 65197c478bd9Sstevel@tonic-gate 65207c478bd9Sstevel@tonic-gate sctp_pr_addr(sp->sctpAssocRemPrimAddrType, fname, sizeof (fname), 65217c478bd9Sstevel@tonic-gate &sp->sctpAssocRemPrimAddr, sp->sctpAssocRemPort); 65227c478bd9Sstevel@tonic-gate sctp_pr_addr(sp->sctpAssocRemPrimAddrType, lname, sizeof (lname), 65237c478bd9Sstevel@tonic-gate &sp->sctpAssocLocPrimAddr, sp->sctpAssocLocalPort); 65247c478bd9Sstevel@tonic-gate 652578a2e113SAndy Fiddaman if (Xflag) 652678a2e113SAndy Fiddaman sie_report(sie); 652778a2e113SAndy Fiddaman 652878a2e113SAndy Fiddaman if (Uflag) { 652978a2e113SAndy Fiddaman for (ph = process_hash_get(sie, SOCK_STREAM, AF_INET); 653078a2e113SAndy Fiddaman ph != NULL; ph = ph->ph_next_proc) { 653178a2e113SAndy Fiddaman (void) printf( 653278a2e113SAndy Fiddaman SCTP_LOCAL_F " " SCTP_REMOTE_F " " 653378a2e113SAndy Fiddaman SCTP_SWIND_F " " SCTP_SENDQ_F " " 653478a2e113SAndy Fiddaman SCTP_RWIND_F " " SCTP_RECVQ_F " " 653578a2e113SAndy Fiddaman SCTP_STRS_FI "/" SCTP_STRS_FO " " 653678a2e113SAndy Fiddaman SCTP_USER_F " " SCTP_PID_F " ", 653778a2e113SAndy Fiddaman lname, fname, 653878a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_swnd, 653978a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_sendq, 654078a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_rwnd, 654178a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_recvq, 654278a2e113SAndy Fiddaman sp->sctpAssocInStreams, 654378a2e113SAndy Fiddaman sp->sctpAssocOutStreams, 654478a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr); 654578a2e113SAndy Fiddaman if (Vflag) { 654678a2e113SAndy Fiddaman (void) printf(SCTP_STATE_F " %s\n", 654778a2e113SAndy Fiddaman nssctp_state(sp->sctpAssocState, attr), 654878a2e113SAndy Fiddaman ph->ph_psargs); 654978a2e113SAndy Fiddaman } else { 655078a2e113SAndy Fiddaman (void) printf(SCTP_COMMAND_F " %s\n", 655178a2e113SAndy Fiddaman ph->ph_fname, 655278a2e113SAndy Fiddaman nssctp_state(sp->sctpAssocState, attr)); 655378a2e113SAndy Fiddaman } 655478a2e113SAndy Fiddaman } 655578a2e113SAndy Fiddaman } else { 655678a2e113SAndy Fiddaman (void) printf( 655778a2e113SAndy Fiddaman SCTP_LOCAL_F " " SCTP_REMOTE_F " " 655878a2e113SAndy Fiddaman SCTP_SWIND_F " " SCTP_SENDQ_F " " 655978a2e113SAndy Fiddaman SCTP_RWIND_F " " SCTP_RECVQ_F " " 656078a2e113SAndy Fiddaman SCTP_STRS_FI "/" SCTP_STRS_FO " %s\n", 656178a2e113SAndy Fiddaman lname, fname, 656278a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_swnd, 656378a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_sendq, 656478a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_rwnd, 656578a2e113SAndy Fiddaman sp->sctpConnEntryInfo.ce_recvq, 656678a2e113SAndy Fiddaman sp->sctpAssocInStreams, sp->sctpAssocOutStreams, 656778a2e113SAndy Fiddaman nssctp_state(sp->sctpAssocState, attr)); 656878a2e113SAndy Fiddaman } 656945916cd2Sjpk 657045916cd2Sjpk print_transport_label(attr); 65717c478bd9Sstevel@tonic-gate 657278a2e113SAndy Fiddaman if (!Vflag) 657378a2e113SAndy Fiddaman return (print_sctp_hdr); 65747c478bd9Sstevel@tonic-gate 65757c478bd9Sstevel@tonic-gate /* Print remote addresses/local addresses on following lines */ 65767c478bd9Sstevel@tonic-gate while ((sre = sctp_getnext_rem(&remote, sre, id)) != NULL) { 65777c478bd9Sstevel@tonic-gate if (!IN6_ARE_ADDR_EQUAL(&sre->sctpAssocRemAddr, 65787c478bd9Sstevel@tonic-gate &sp->sctpAssocRemPrimAddr)) { 65797c478bd9Sstevel@tonic-gate if (printfirst == B_TRUE) { 65807c478bd9Sstevel@tonic-gate (void) fputs("\t<Remote: ", stdout); 65817c478bd9Sstevel@tonic-gate printfirst = B_FALSE; 65827c478bd9Sstevel@tonic-gate } else { 65837c478bd9Sstevel@tonic-gate (void) fputs(", ", stdout); 65847c478bd9Sstevel@tonic-gate } 65857c478bd9Sstevel@tonic-gate sctp_pr_addr(sre->sctpAssocRemAddrType, fname, 65867c478bd9Sstevel@tonic-gate sizeof (fname), &sre->sctpAssocRemAddr, -1); 65877c478bd9Sstevel@tonic-gate if (sre->sctpAssocRemAddrActive == MIB2_SCTP_ACTIVE) { 65887c478bd9Sstevel@tonic-gate (void) fputs(fname, stdout); 65897c478bd9Sstevel@tonic-gate } else { 65907c478bd9Sstevel@tonic-gate (void) printf("(%s)", fname); 65917c478bd9Sstevel@tonic-gate } 65927c478bd9Sstevel@tonic-gate } 65937c478bd9Sstevel@tonic-gate } 65947c478bd9Sstevel@tonic-gate if (printfirst == B_FALSE) { 65957c478bd9Sstevel@tonic-gate (void) puts(">"); 65967c478bd9Sstevel@tonic-gate printfirst = B_TRUE; 65977c478bd9Sstevel@tonic-gate } 65987c478bd9Sstevel@tonic-gate while ((sle = sctp_getnext_local(&local, sle, id)) != NULL) { 65997c478bd9Sstevel@tonic-gate if (!IN6_ARE_ADDR_EQUAL(&sle->sctpAssocLocalAddr, 66007c478bd9Sstevel@tonic-gate &sp->sctpAssocLocPrimAddr)) { 66017c478bd9Sstevel@tonic-gate if (printfirst == B_TRUE) { 66027c478bd9Sstevel@tonic-gate (void) fputs("\t<Local: ", stdout); 66037c478bd9Sstevel@tonic-gate printfirst = B_FALSE; 66047c478bd9Sstevel@tonic-gate } else { 66057c478bd9Sstevel@tonic-gate (void) fputs(", ", stdout); 66067c478bd9Sstevel@tonic-gate } 66077c478bd9Sstevel@tonic-gate sctp_pr_addr(sle->sctpAssocLocalAddrType, lname, 66087c478bd9Sstevel@tonic-gate sizeof (lname), &sle->sctpAssocLocalAddr, -1); 66097c478bd9Sstevel@tonic-gate (void) fputs(lname, stdout); 66107c478bd9Sstevel@tonic-gate } 66117c478bd9Sstevel@tonic-gate } 66127c478bd9Sstevel@tonic-gate if (printfirst == B_FALSE) { 66137c478bd9Sstevel@tonic-gate (void) puts(">"); 66147c478bd9Sstevel@tonic-gate } 661578a2e113SAndy Fiddaman 661678a2e113SAndy Fiddaman return (print_sctp_hdr); 66177c478bd9Sstevel@tonic-gate } 66187c478bd9Sstevel@tonic-gate 66197c478bd9Sstevel@tonic-gate static void 662045916cd2Sjpk sctp_report(const mib_item_t *item) 66217c478bd9Sstevel@tonic-gate { 662245916cd2Sjpk const mib2_sctpConnEntry_t *sp; 662378a2e113SAndy Fiddaman boolean_t print_sctp_hdr_once = B_TRUE; 662478a2e113SAndy Fiddaman mib2_transportMLPEntry_t **attrs, **a, *aptr; 662578a2e113SAndy Fiddaman mib2_socketInfoEntry_t **info, **i, *iptr; 66267c478bd9Sstevel@tonic-gate 662745916cd2Sjpk /* 662845916cd2Sjpk * Preparation pass: the kernel returns separate entries for SCTP 662945916cd2Sjpk * connection table entries and Multilevel Port attributes. We loop 663045916cd2Sjpk * through the attributes first and set up an array for each address 663145916cd2Sjpk * family. 663245916cd2Sjpk */ 663345916cd2Sjpk attrs = RSECflag ? 663445916cd2Sjpk gather_attrs(item, MIB2_SCTP, MIB2_SCTP_CONN, sctpEntrySize) : 663545916cd2Sjpk NULL; 663678a2e113SAndy Fiddaman info = Uflag ? 663778a2e113SAndy Fiddaman gather_info(item, MIB2_SCTP, MIB2_SCTP_CONN, sctpEntrySize) : 663878a2e113SAndy Fiddaman NULL; 663945916cd2Sjpk 664078a2e113SAndy Fiddaman a = attrs; 664178a2e113SAndy Fiddaman i = info; 66427c478bd9Sstevel@tonic-gate for (; item != NULL; item = item->next_item) { 66437c478bd9Sstevel@tonic-gate 66447c478bd9Sstevel@tonic-gate if (!(item->group == MIB2_SCTP && 66457c478bd9Sstevel@tonic-gate item->mib_id == MIB2_SCTP_CONN)) 66467c478bd9Sstevel@tonic-gate continue; 66477c478bd9Sstevel@tonic-gate 66487c478bd9Sstevel@tonic-gate for (sp = item->valp; 664945916cd2Sjpk (char *)sp < (char *)item->valp + item->length; 665045916cd2Sjpk sp = (mib2_sctpConnEntry_t *)((char *)sp + sctpEntrySize)) { 665178a2e113SAndy Fiddaman if (!(Aflag || 665278a2e113SAndy Fiddaman sp->sctpAssocState >= MIB2_SCTP_established)) 665378a2e113SAndy Fiddaman continue; 665478a2e113SAndy Fiddaman aptr = a == NULL ? NULL : *a++; 665578a2e113SAndy Fiddaman iptr = i == NULL ? NULL : *i++; 665678a2e113SAndy Fiddaman print_sctp_hdr_once = sctp_conn_report_item( 665778a2e113SAndy Fiddaman item, print_sctp_hdr_once, sp, aptr, iptr); 66587c478bd9Sstevel@tonic-gate } 66597c478bd9Sstevel@tonic-gate } 666078a2e113SAndy Fiddaman free(attrs); 666178a2e113SAndy Fiddaman free(info); 66627c478bd9Sstevel@tonic-gate } 66637c478bd9Sstevel@tonic-gate 66647c478bd9Sstevel@tonic-gate static char * 66657c478bd9Sstevel@tonic-gate plural(int n) 66667c478bd9Sstevel@tonic-gate { 66677c478bd9Sstevel@tonic-gate return (n != 1 ? "s" : ""); 66687c478bd9Sstevel@tonic-gate } 66697c478bd9Sstevel@tonic-gate 66707c478bd9Sstevel@tonic-gate static char * 66717c478bd9Sstevel@tonic-gate pluraly(int n) 66727c478bd9Sstevel@tonic-gate { 66737c478bd9Sstevel@tonic-gate return (n != 1 ? "ies" : "y"); 66747c478bd9Sstevel@tonic-gate } 66757c478bd9Sstevel@tonic-gate 66767c478bd9Sstevel@tonic-gate static char * 66777c478bd9Sstevel@tonic-gate plurales(int n) 66787c478bd9Sstevel@tonic-gate { 66797c478bd9Sstevel@tonic-gate return (n != 1 ? "es" : ""); 66807c478bd9Sstevel@tonic-gate } 66817c478bd9Sstevel@tonic-gate 66827c478bd9Sstevel@tonic-gate static char * 6683afee3dc6SRobert Mustacchi pktscale(int n) 66847c478bd9Sstevel@tonic-gate { 66857c478bd9Sstevel@tonic-gate static char buf[6]; 66867c478bd9Sstevel@tonic-gate char t; 66877c478bd9Sstevel@tonic-gate 66887c478bd9Sstevel@tonic-gate if (n < 1024) { 66897c478bd9Sstevel@tonic-gate t = ' '; 66907c478bd9Sstevel@tonic-gate } else if (n < 1024 * 1024) { 66917c478bd9Sstevel@tonic-gate t = 'k'; 66927c478bd9Sstevel@tonic-gate n /= 1024; 66937c478bd9Sstevel@tonic-gate } else if (n < 1024 * 1024 * 1024) { 66947c478bd9Sstevel@tonic-gate t = 'm'; 66957c478bd9Sstevel@tonic-gate n /= 1024 * 1024; 66967c478bd9Sstevel@tonic-gate } else { 66977c478bd9Sstevel@tonic-gate t = 'g'; 66987c478bd9Sstevel@tonic-gate n /= 1024 * 1024 * 1024; 66997c478bd9Sstevel@tonic-gate } 67007c478bd9Sstevel@tonic-gate 67017c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%4u%c", n, t); 67027c478bd9Sstevel@tonic-gate return (buf); 67037c478bd9Sstevel@tonic-gate } 67047c478bd9Sstevel@tonic-gate 67057c478bd9Sstevel@tonic-gate /* --------------------- mrt_report (netstat -m) -------------------------- */ 67067c478bd9Sstevel@tonic-gate 67077c478bd9Sstevel@tonic-gate static void 67087c478bd9Sstevel@tonic-gate mrt_report(mib_item_t *item) 67097c478bd9Sstevel@tonic-gate { 67107c478bd9Sstevel@tonic-gate int jtemp = 0; 67117c478bd9Sstevel@tonic-gate struct vifctl *vip; 67127c478bd9Sstevel@tonic-gate vifi_t vifi; 67137c478bd9Sstevel@tonic-gate struct mfcctl *mfccp; 67147c478bd9Sstevel@tonic-gate int numvifs = 0; 67157c478bd9Sstevel@tonic-gate int nmfc = 0; 6716d38b7101SDan McDonald char abuf[MAXHOSTNAMELEN + 4]; /* Include CIDR /<num>. */ 67177c478bd9Sstevel@tonic-gate 67187c478bd9Sstevel@tonic-gate if (!(family_selected(AF_INET))) 67197c478bd9Sstevel@tonic-gate return; 67207c478bd9Sstevel@tonic-gate 67217c478bd9Sstevel@tonic-gate for (; item; item = item->next_item) { 6722bd670b35SErik Nordmark if (Xflag) { 672378a2e113SAndy Fiddaman (void) printf("[%4d] Group = %d, mib_id = %d, " 672478a2e113SAndy Fiddaman "length = %d, valp = 0x%p\n", jtemp++, 67257c478bd9Sstevel@tonic-gate item->group, item->mib_id, item->length, 67267c478bd9Sstevel@tonic-gate item->valp); 67277c478bd9Sstevel@tonic-gate } 67287c478bd9Sstevel@tonic-gate if (item->group != EXPER_DVMRP) 672978a2e113SAndy Fiddaman continue; 67307c478bd9Sstevel@tonic-gate 67317c478bd9Sstevel@tonic-gate switch (item->mib_id) { 67327c478bd9Sstevel@tonic-gate 67337c478bd9Sstevel@tonic-gate case EXPER_DVMRP_VIF: 6734bd670b35SErik Nordmark if (Xflag) 67357c478bd9Sstevel@tonic-gate (void) printf("%u records for ipVifTable:\n", 67367c478bd9Sstevel@tonic-gate item->length/sizeof (struct vifctl)); 67377c478bd9Sstevel@tonic-gate if (item->length/sizeof (struct vifctl) == 0) { 67387c478bd9Sstevel@tonic-gate (void) puts("\nVirtual Interface Table is " 67397c478bd9Sstevel@tonic-gate "empty"); 67407c478bd9Sstevel@tonic-gate break; 67417c478bd9Sstevel@tonic-gate } 67427c478bd9Sstevel@tonic-gate 67437c478bd9Sstevel@tonic-gate (void) puts("\nVirtual Interface Table\n" 67447c478bd9Sstevel@tonic-gate " Vif Threshold Rate_Limit Local-Address" 67457c478bd9Sstevel@tonic-gate " Remote-Address Pkt_in Pkt_out"); 67467c478bd9Sstevel@tonic-gate 67477c478bd9Sstevel@tonic-gate for (vip = (struct vifctl *)item->valp; 67487c478bd9Sstevel@tonic-gate (char *)vip < (char *)item->valp + item->length; 67497c478bd9Sstevel@tonic-gate vip = (struct vifctl *)((char *)vip + 67507c478bd9Sstevel@tonic-gate vifctlSize)) { 67517c478bd9Sstevel@tonic-gate if (vip->vifc_lcl_addr.s_addr == 0) 675278a2e113SAndy Fiddaman continue; 67537c478bd9Sstevel@tonic-gate /* numvifs = vip->vifc_vifi; */ 67547c478bd9Sstevel@tonic-gate 67557c478bd9Sstevel@tonic-gate numvifs++; 67567c478bd9Sstevel@tonic-gate (void) printf(" %2u %3u " 67577c478bd9Sstevel@tonic-gate "%4u %-15.15s", 67587c478bd9Sstevel@tonic-gate vip->vifc_vifi, 67597c478bd9Sstevel@tonic-gate vip->vifc_threshold, 67607c478bd9Sstevel@tonic-gate vip->vifc_rate_limit, 67617c478bd9Sstevel@tonic-gate pr_addr(vip->vifc_lcl_addr.s_addr, 67627c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 67637c478bd9Sstevel@tonic-gate (void) printf(" %-15.15s %8u %8u\n", 67647c478bd9Sstevel@tonic-gate (vip->vifc_flags & VIFF_TUNNEL) ? 67657c478bd9Sstevel@tonic-gate pr_addr(vip->vifc_rmt_addr.s_addr, 67667c478bd9Sstevel@tonic-gate abuf, sizeof (abuf)) : "", 67677c478bd9Sstevel@tonic-gate vip->vifc_pkt_in, 67687c478bd9Sstevel@tonic-gate vip->vifc_pkt_out); 676978a2e113SAndy Fiddaman } 67707c478bd9Sstevel@tonic-gate 67717c478bd9Sstevel@tonic-gate (void) printf("Numvifs: %d\n", numvifs); 67727c478bd9Sstevel@tonic-gate break; 67737c478bd9Sstevel@tonic-gate 67747c478bd9Sstevel@tonic-gate case EXPER_DVMRP_MRT: 6775bd670b35SErik Nordmark if (Xflag) 67767c478bd9Sstevel@tonic-gate (void) printf("%u records for ipMfcTable:\n", 6777e11c3f44Smeem item->length/sizeof (struct vifctl)); 67787c478bd9Sstevel@tonic-gate if (item->length/sizeof (struct vifctl) == 0) { 67797c478bd9Sstevel@tonic-gate (void) puts("\nMulticast Forwarding Cache is " 67807c478bd9Sstevel@tonic-gate "empty"); 67817c478bd9Sstevel@tonic-gate break; 67827c478bd9Sstevel@tonic-gate } 67837c478bd9Sstevel@tonic-gate 67847c478bd9Sstevel@tonic-gate (void) puts("\nMulticast Forwarding Cache\n" 67857c478bd9Sstevel@tonic-gate " Origin-Subnet Mcastgroup " 67867c478bd9Sstevel@tonic-gate "# Pkts In-Vif Out-vifs/Forw-ttl"); 67877c478bd9Sstevel@tonic-gate 67887c478bd9Sstevel@tonic-gate for (mfccp = (struct mfcctl *)item->valp; 67897c478bd9Sstevel@tonic-gate (char *)mfccp < (char *)item->valp + item->length; 67907c478bd9Sstevel@tonic-gate mfccp = (struct mfcctl *)((char *)mfccp + 67917c478bd9Sstevel@tonic-gate mfcctlSize)) { 67927c478bd9Sstevel@tonic-gate 67937c478bd9Sstevel@tonic-gate nmfc++; 67947c478bd9Sstevel@tonic-gate (void) printf(" %-30.15s", 67957c478bd9Sstevel@tonic-gate pr_addr(mfccp->mfcc_origin.s_addr, 67967c478bd9Sstevel@tonic-gate abuf, sizeof (abuf))); 67977c478bd9Sstevel@tonic-gate (void) printf("%-15.15s %6s %3u ", 67987c478bd9Sstevel@tonic-gate pr_net(mfccp->mfcc_mcastgrp.s_addr, 6799e11c3f44Smeem mfccp->mfcc_mcastgrp.s_addr, 6800e11c3f44Smeem abuf, sizeof (abuf)), 68017c478bd9Sstevel@tonic-gate pktscale((int)mfccp->mfcc_pkt_cnt), 6802e11c3f44Smeem mfccp->mfcc_parent); 68037c478bd9Sstevel@tonic-gate 68047c478bd9Sstevel@tonic-gate for (vifi = 0; vifi < MAXVIFS; ++vifi) { 68057c478bd9Sstevel@tonic-gate if (mfccp->mfcc_ttls[vifi]) { 68067c478bd9Sstevel@tonic-gate (void) printf(" %u (%u)", 68077c478bd9Sstevel@tonic-gate vifi, 68087c478bd9Sstevel@tonic-gate mfccp->mfcc_ttls[vifi]); 68097c478bd9Sstevel@tonic-gate } 68107c478bd9Sstevel@tonic-gate 68117c478bd9Sstevel@tonic-gate } 68127c478bd9Sstevel@tonic-gate (void) putchar('\n'); 68137c478bd9Sstevel@tonic-gate } 68147c478bd9Sstevel@tonic-gate (void) printf("\nTotal no. of entries in cache: %d\n", 68157c478bd9Sstevel@tonic-gate nmfc); 68167c478bd9Sstevel@tonic-gate break; 68177c478bd9Sstevel@tonic-gate } 681878a2e113SAndy Fiddaman } 68197c478bd9Sstevel@tonic-gate (void) putchar('\n'); 68207c478bd9Sstevel@tonic-gate (void) fflush(stdout); 68217c478bd9Sstevel@tonic-gate } 68227c478bd9Sstevel@tonic-gate 68237c478bd9Sstevel@tonic-gate /* 68247c478bd9Sstevel@tonic-gate * Get the stats for the cache named 'name'. If prefix != 0, then 68257c478bd9Sstevel@tonic-gate * interpret the name as a prefix, and sum up stats for all caches 68267c478bd9Sstevel@tonic-gate * named 'name*'. 68277c478bd9Sstevel@tonic-gate */ 68287c478bd9Sstevel@tonic-gate static void 68297c478bd9Sstevel@tonic-gate kmem_cache_stats(char *title, char *name, int prefix, int64_t *total_bytes) 68307c478bd9Sstevel@tonic-gate { 68317c478bd9Sstevel@tonic-gate int len; 68327c478bd9Sstevel@tonic-gate int alloc; 68337c478bd9Sstevel@tonic-gate int64_t total_alloc = 0; 68347c478bd9Sstevel@tonic-gate int alloc_fail, total_alloc_fail = 0; 68357c478bd9Sstevel@tonic-gate int buf_size = 0; 68367c478bd9Sstevel@tonic-gate int buf_avail; 68377c478bd9Sstevel@tonic-gate int buf_total; 68387c478bd9Sstevel@tonic-gate int buf_max, total_buf_max = 0; 68397c478bd9Sstevel@tonic-gate int buf_inuse, total_buf_inuse = 0; 68407c478bd9Sstevel@tonic-gate kstat_t *ksp; 68417c478bd9Sstevel@tonic-gate char buf[256]; 68427c478bd9Sstevel@tonic-gate 68437c478bd9Sstevel@tonic-gate len = prefix ? strlen(name) : 256; 68447c478bd9Sstevel@tonic-gate 68457c478bd9Sstevel@tonic-gate for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) { 68467c478bd9Sstevel@tonic-gate 68477c478bd9Sstevel@tonic-gate if (strcmp(ksp->ks_class, "kmem_cache") != 0) 684878a2e113SAndy Fiddaman continue; 68497c478bd9Sstevel@tonic-gate 68507c478bd9Sstevel@tonic-gate /* 68517c478bd9Sstevel@tonic-gate * Hack alert: because of the way streams messages are 68527c478bd9Sstevel@tonic-gate * allocated, every constructed free dblk has an associated 68537c478bd9Sstevel@tonic-gate * mblk. From the allocator's viewpoint those mblks are 68547c478bd9Sstevel@tonic-gate * allocated (because they haven't been freed), but from 68557c478bd9Sstevel@tonic-gate * our viewpoint they're actually free (because they're 68567c478bd9Sstevel@tonic-gate * not currently in use). To account for this caching 68577c478bd9Sstevel@tonic-gate * effect we subtract the total constructed free dblks 68587c478bd9Sstevel@tonic-gate * from the total allocated mblks to derive mblks in use. 68597c478bd9Sstevel@tonic-gate */ 68607c478bd9Sstevel@tonic-gate if (strcmp(name, "streams_mblk") == 0 && 68617c478bd9Sstevel@tonic-gate strncmp(ksp->ks_name, "streams_dblk", 12) == 0) { 68627c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, ksp, NULL); 68637c478bd9Sstevel@tonic-gate total_buf_inuse -= 6864e11c3f44Smeem kstat_named_value(ksp, "buf_constructed"); 686578a2e113SAndy Fiddaman continue; 68667c478bd9Sstevel@tonic-gate } 68677c478bd9Sstevel@tonic-gate 68687c478bd9Sstevel@tonic-gate if (strncmp(ksp->ks_name, name, len) != 0) 686978a2e113SAndy Fiddaman continue; 68707c478bd9Sstevel@tonic-gate 68717c478bd9Sstevel@tonic-gate (void) safe_kstat_read(kc, ksp, NULL); 68727c478bd9Sstevel@tonic-gate 68737c478bd9Sstevel@tonic-gate alloc = kstat_named_value(ksp, "alloc"); 68747c478bd9Sstevel@tonic-gate alloc_fail = kstat_named_value(ksp, "alloc_fail"); 68757c478bd9Sstevel@tonic-gate buf_size = kstat_named_value(ksp, "buf_size"); 68767c478bd9Sstevel@tonic-gate buf_avail = kstat_named_value(ksp, "buf_avail"); 68777c478bd9Sstevel@tonic-gate buf_total = kstat_named_value(ksp, "buf_total"); 68787c478bd9Sstevel@tonic-gate buf_max = kstat_named_value(ksp, "buf_max"); 68797c478bd9Sstevel@tonic-gate buf_inuse = buf_total - buf_avail; 68807c478bd9Sstevel@tonic-gate 68817c478bd9Sstevel@tonic-gate if (Vflag && prefix) { 68827c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s%s", title, 68837c478bd9Sstevel@tonic-gate ksp->ks_name + len); 68847c478bd9Sstevel@tonic-gate (void) printf(" %-18s %6u %9u %11u %11u\n", 68857c478bd9Sstevel@tonic-gate buf, buf_inuse, buf_max, alloc, alloc_fail); 68867c478bd9Sstevel@tonic-gate } 68877c478bd9Sstevel@tonic-gate 68887c478bd9Sstevel@tonic-gate total_alloc += alloc; 68897c478bd9Sstevel@tonic-gate total_alloc_fail += alloc_fail; 68907c478bd9Sstevel@tonic-gate total_buf_max += buf_max; 68917c478bd9Sstevel@tonic-gate total_buf_inuse += buf_inuse; 68927c478bd9Sstevel@tonic-gate *total_bytes += (int64_t)buf_inuse * buf_size; 689378a2e113SAndy Fiddaman } 68947c478bd9Sstevel@tonic-gate 68957c478bd9Sstevel@tonic-gate if (buf_size == 0) { 68967c478bd9Sstevel@tonic-gate (void) printf("%-22s [couldn't find statistics for %s]\n", 6897e11c3f44Smeem title, name); 68987c478bd9Sstevel@tonic-gate return; 68997c478bd9Sstevel@tonic-gate } 69007c478bd9Sstevel@tonic-gate 69017c478bd9Sstevel@tonic-gate if (Vflag && prefix) 69027c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s_total", title); 69037c478bd9Sstevel@tonic-gate else 69047c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s", title); 69057c478bd9Sstevel@tonic-gate 69067c478bd9Sstevel@tonic-gate (void) printf("%-22s %6d %9d %11lld %11d\n", buf, 6907e11c3f44Smeem total_buf_inuse, total_buf_max, total_alloc, total_alloc_fail); 69087c478bd9Sstevel@tonic-gate } 69097c478bd9Sstevel@tonic-gate 69107c478bd9Sstevel@tonic-gate static void 69117c478bd9Sstevel@tonic-gate m_report(void) 69127c478bd9Sstevel@tonic-gate { 69137c478bd9Sstevel@tonic-gate int64_t total_bytes = 0; 69147c478bd9Sstevel@tonic-gate 69157c478bd9Sstevel@tonic-gate (void) puts("streams allocation:"); 69167c478bd9Sstevel@tonic-gate (void) printf("%63s\n", "cumulative allocation"); 69177c478bd9Sstevel@tonic-gate (void) printf("%63s\n", 69187c478bd9Sstevel@tonic-gate "current maximum total failures"); 69197c478bd9Sstevel@tonic-gate 69207c478bd9Sstevel@tonic-gate kmem_cache_stats("streams", 69217c478bd9Sstevel@tonic-gate "stream_head_cache", 0, &total_bytes); 69227c478bd9Sstevel@tonic-gate kmem_cache_stats("queues", "queue_cache", 0, &total_bytes); 69237c478bd9Sstevel@tonic-gate kmem_cache_stats("mblk", "streams_mblk", 0, &total_bytes); 69247c478bd9Sstevel@tonic-gate kmem_cache_stats("dblk", "streams_dblk", 1, &total_bytes); 69257c478bd9Sstevel@tonic-gate kmem_cache_stats("linkblk", "linkinfo_cache", 0, &total_bytes); 69267c478bd9Sstevel@tonic-gate kmem_cache_stats("syncq", "syncq_cache", 0, &total_bytes); 69277c478bd9Sstevel@tonic-gate kmem_cache_stats("qband", "qband_cache", 0, &total_bytes); 69287c478bd9Sstevel@tonic-gate 69297c478bd9Sstevel@tonic-gate (void) printf("\n%lld Kbytes allocated for streams data\n", 6930e11c3f44Smeem total_bytes / 1024); 69317c478bd9Sstevel@tonic-gate 69327c478bd9Sstevel@tonic-gate (void) putchar('\n'); 69337c478bd9Sstevel@tonic-gate (void) fflush(stdout); 69347c478bd9Sstevel@tonic-gate } 69357c478bd9Sstevel@tonic-gate 69367c478bd9Sstevel@tonic-gate /* --------------------------------- */ 69377c478bd9Sstevel@tonic-gate 69387c478bd9Sstevel@tonic-gate /* 69397c478bd9Sstevel@tonic-gate * Print an IPv4 address. Remove the matching part of the domain name 69407c478bd9Sstevel@tonic-gate * from the returned name. 69417c478bd9Sstevel@tonic-gate */ 69427c478bd9Sstevel@tonic-gate static char * 69437c478bd9Sstevel@tonic-gate pr_addr(uint_t addr, char *dst, uint_t dstlen) 69447c478bd9Sstevel@tonic-gate { 69457c478bd9Sstevel@tonic-gate char *cp; 69467c478bd9Sstevel@tonic-gate struct hostent *hp = NULL; 69477c478bd9Sstevel@tonic-gate static char domain[MAXHOSTNAMELEN + 1]; 69487c478bd9Sstevel@tonic-gate static boolean_t first = B_TRUE; 69497c478bd9Sstevel@tonic-gate int error_num; 69507c478bd9Sstevel@tonic-gate 69517c478bd9Sstevel@tonic-gate if (first) { 69527c478bd9Sstevel@tonic-gate first = B_FALSE; 69537c478bd9Sstevel@tonic-gate if (sysinfo(SI_HOSTNAME, domain, MAXHOSTNAMELEN) != -1 && 69547c478bd9Sstevel@tonic-gate (cp = strchr(domain, '.'))) { 69557c478bd9Sstevel@tonic-gate (void) strncpy(domain, cp + 1, sizeof (domain)); 69567c478bd9Sstevel@tonic-gate } else 69577c478bd9Sstevel@tonic-gate domain[0] = 0; 69587c478bd9Sstevel@tonic-gate } 69597c478bd9Sstevel@tonic-gate cp = NULL; 69607c478bd9Sstevel@tonic-gate if (!Nflag) { 6961afee3dc6SRobert Mustacchi ns_lookup_start(); 69627c478bd9Sstevel@tonic-gate hp = getipnodebyaddr((char *)&addr, sizeof (uint_t), AF_INET, 69637c478bd9Sstevel@tonic-gate &error_num); 6964afee3dc6SRobert Mustacchi ns_lookup_end(); 69657c478bd9Sstevel@tonic-gate if (hp) { 69667c478bd9Sstevel@tonic-gate if ((cp = strchr(hp->h_name, '.')) != NULL && 69677c478bd9Sstevel@tonic-gate strcasecmp(cp + 1, domain) == 0) 69687c478bd9Sstevel@tonic-gate *cp = 0; 69697c478bd9Sstevel@tonic-gate cp = hp->h_name; 69707c478bd9Sstevel@tonic-gate } 69717c478bd9Sstevel@tonic-gate } 69727c478bd9Sstevel@tonic-gate if (cp != NULL) { 69737c478bd9Sstevel@tonic-gate (void) strncpy(dst, cp, dstlen); 69747c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 69757c478bd9Sstevel@tonic-gate } else { 69767c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET, (char *)&addr, dst, dstlen); 69777c478bd9Sstevel@tonic-gate } 69787c478bd9Sstevel@tonic-gate if (hp != NULL) 69797c478bd9Sstevel@tonic-gate freehostent(hp); 69807c478bd9Sstevel@tonic-gate return (dst); 69817c478bd9Sstevel@tonic-gate } 69827c478bd9Sstevel@tonic-gate 69837c478bd9Sstevel@tonic-gate /* 69847c478bd9Sstevel@tonic-gate * Print a non-zero IPv4 address. Print " --" if the address is zero. 69857c478bd9Sstevel@tonic-gate */ 69867c478bd9Sstevel@tonic-gate static char * 69877c478bd9Sstevel@tonic-gate pr_addrnz(ipaddr_t addr, char *dst, uint_t dstlen) 69887c478bd9Sstevel@tonic-gate { 69897c478bd9Sstevel@tonic-gate if (addr == INADDR_ANY) { 69907c478bd9Sstevel@tonic-gate (void) strlcpy(dst, " --", dstlen); 69917c478bd9Sstevel@tonic-gate return (dst); 69927c478bd9Sstevel@tonic-gate } 69937c478bd9Sstevel@tonic-gate return (pr_addr(addr, dst, dstlen)); 69947c478bd9Sstevel@tonic-gate } 69957c478bd9Sstevel@tonic-gate 69967c478bd9Sstevel@tonic-gate /* 69977c478bd9Sstevel@tonic-gate * Print an IPv6 address. Remove the matching part of the domain name 69987c478bd9Sstevel@tonic-gate * from the returned name. 69997c478bd9Sstevel@tonic-gate */ 70007c478bd9Sstevel@tonic-gate static char * 70017c478bd9Sstevel@tonic-gate pr_addr6(const struct in6_addr *addr, char *dst, uint_t dstlen) 70027c478bd9Sstevel@tonic-gate { 70037c478bd9Sstevel@tonic-gate char *cp; 70047c478bd9Sstevel@tonic-gate struct hostent *hp = NULL; 70057c478bd9Sstevel@tonic-gate static char domain[MAXHOSTNAMELEN + 1]; 70067c478bd9Sstevel@tonic-gate static boolean_t first = B_TRUE; 70077c478bd9Sstevel@tonic-gate int error_num; 70087c478bd9Sstevel@tonic-gate 70097c478bd9Sstevel@tonic-gate if (first) { 70107c478bd9Sstevel@tonic-gate first = B_FALSE; 70117c478bd9Sstevel@tonic-gate if (sysinfo(SI_HOSTNAME, domain, MAXHOSTNAMELEN) != -1 && 70127c478bd9Sstevel@tonic-gate (cp = strchr(domain, '.'))) { 70137c478bd9Sstevel@tonic-gate (void) strncpy(domain, cp + 1, sizeof (domain)); 70147c478bd9Sstevel@tonic-gate } else 70157c478bd9Sstevel@tonic-gate domain[0] = 0; 70167c478bd9Sstevel@tonic-gate } 70177c478bd9Sstevel@tonic-gate cp = NULL; 70187c478bd9Sstevel@tonic-gate if (!Nflag) { 7019afee3dc6SRobert Mustacchi ns_lookup_start(); 70207c478bd9Sstevel@tonic-gate hp = getipnodebyaddr((char *)addr, 70217c478bd9Sstevel@tonic-gate sizeof (struct in6_addr), AF_INET6, &error_num); 7022afee3dc6SRobert Mustacchi ns_lookup_end(); 70237c478bd9Sstevel@tonic-gate if (hp) { 70247c478bd9Sstevel@tonic-gate if ((cp = strchr(hp->h_name, '.')) != NULL && 70257c478bd9Sstevel@tonic-gate strcasecmp(cp + 1, domain) == 0) 70267c478bd9Sstevel@tonic-gate *cp = 0; 70277c478bd9Sstevel@tonic-gate cp = hp->h_name; 70287c478bd9Sstevel@tonic-gate } 70297c478bd9Sstevel@tonic-gate } 70307c478bd9Sstevel@tonic-gate if (cp != NULL) { 70317c478bd9Sstevel@tonic-gate (void) strncpy(dst, cp, dstlen); 70327c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 70337c478bd9Sstevel@tonic-gate } else { 70347c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET6, (void *)addr, dst, dstlen); 70357c478bd9Sstevel@tonic-gate } 70367c478bd9Sstevel@tonic-gate if (hp != NULL) 70377c478bd9Sstevel@tonic-gate freehostent(hp); 70387c478bd9Sstevel@tonic-gate return (dst); 70397c478bd9Sstevel@tonic-gate } 70407c478bd9Sstevel@tonic-gate 70417c478bd9Sstevel@tonic-gate /* For IPv4 masks */ 70427c478bd9Sstevel@tonic-gate static char * 70437c478bd9Sstevel@tonic-gate pr_mask(uint_t addr, char *dst, uint_t dstlen) 70447c478bd9Sstevel@tonic-gate { 70457c478bd9Sstevel@tonic-gate uint8_t *ip_addr = (uint8_t *)&addr; 70467c478bd9Sstevel@tonic-gate 70477c478bd9Sstevel@tonic-gate (void) snprintf(dst, dstlen, "%d.%d.%d.%d", 70487c478bd9Sstevel@tonic-gate ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]); 70497c478bd9Sstevel@tonic-gate return (dst); 70507c478bd9Sstevel@tonic-gate } 70517c478bd9Sstevel@tonic-gate 70527c478bd9Sstevel@tonic-gate /* 70537c478bd9Sstevel@tonic-gate * For ipv6 masks format is : dest/mask 70547c478bd9Sstevel@tonic-gate * Does not print /128 to save space in printout. H flag carries this notion. 70557c478bd9Sstevel@tonic-gate */ 70567c478bd9Sstevel@tonic-gate static char * 705745916cd2Sjpk pr_prefix6(const struct in6_addr *addr, uint_t prefixlen, char *dst, 705845916cd2Sjpk uint_t dstlen) 70597c478bd9Sstevel@tonic-gate { 70607c478bd9Sstevel@tonic-gate char *cp; 70617c478bd9Sstevel@tonic-gate 70627c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(addr) && prefixlen == 0) { 70637c478bd9Sstevel@tonic-gate (void) strncpy(dst, "default", dstlen); 70647c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 70657c478bd9Sstevel@tonic-gate return (dst); 70667c478bd9Sstevel@tonic-gate } 70677c478bd9Sstevel@tonic-gate 70687c478bd9Sstevel@tonic-gate (void) pr_addr6(addr, dst, dstlen); 70697c478bd9Sstevel@tonic-gate if (prefixlen != IPV6_ABITS) { 70707c478bd9Sstevel@tonic-gate /* How much room is left? */ 70717c478bd9Sstevel@tonic-gate cp = strchr(dst, '\0'); 70727c478bd9Sstevel@tonic-gate if (dst + dstlen > cp) { 70737c478bd9Sstevel@tonic-gate dstlen -= (cp - dst); 70747c478bd9Sstevel@tonic-gate (void) snprintf(cp, dstlen, "/%d", prefixlen); 70757c478bd9Sstevel@tonic-gate } 70767c478bd9Sstevel@tonic-gate } 70777c478bd9Sstevel@tonic-gate return (dst); 70787c478bd9Sstevel@tonic-gate } 70797c478bd9Sstevel@tonic-gate 70807c478bd9Sstevel@tonic-gate /* Print IPv4 address and port */ 70817c478bd9Sstevel@tonic-gate static char * 70827c478bd9Sstevel@tonic-gate pr_ap(uint_t addr, uint_t port, char *proto, 70837c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen) 70847c478bd9Sstevel@tonic-gate { 70857c478bd9Sstevel@tonic-gate char *cp; 70867c478bd9Sstevel@tonic-gate 70877c478bd9Sstevel@tonic-gate if (addr == INADDR_ANY) { 70887c478bd9Sstevel@tonic-gate (void) strncpy(dst, " *", dstlen); 70897c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 70907c478bd9Sstevel@tonic-gate } else { 70917c478bd9Sstevel@tonic-gate (void) pr_addr(addr, dst, dstlen); 70927c478bd9Sstevel@tonic-gate } 70937c478bd9Sstevel@tonic-gate /* How much room is left? */ 70947c478bd9Sstevel@tonic-gate cp = strchr(dst, '\0'); 70957c478bd9Sstevel@tonic-gate if (dst + dstlen > cp + 1) { 70967c478bd9Sstevel@tonic-gate *cp++ = '.'; 70977c478bd9Sstevel@tonic-gate dstlen -= (cp - dst); 70987c478bd9Sstevel@tonic-gate dstlen--; 70997c478bd9Sstevel@tonic-gate (void) portname(port, proto, cp, dstlen); 71007c478bd9Sstevel@tonic-gate } 71017c478bd9Sstevel@tonic-gate return (dst); 71027c478bd9Sstevel@tonic-gate } 71037c478bd9Sstevel@tonic-gate 71047c478bd9Sstevel@tonic-gate /* Print IPv6 address and port */ 71057c478bd9Sstevel@tonic-gate static char * 71067c478bd9Sstevel@tonic-gate pr_ap6(const in6_addr_t *addr, uint_t port, char *proto, 71077c478bd9Sstevel@tonic-gate char *dst, uint_t dstlen) 71087c478bd9Sstevel@tonic-gate { 71097c478bd9Sstevel@tonic-gate char *cp; 71107c478bd9Sstevel@tonic-gate 71117c478bd9Sstevel@tonic-gate if (IN6_IS_ADDR_UNSPECIFIED(addr)) { 71127c478bd9Sstevel@tonic-gate (void) strncpy(dst, " *", dstlen); 71137c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 71147c478bd9Sstevel@tonic-gate } else { 71157c478bd9Sstevel@tonic-gate (void) pr_addr6(addr, dst, dstlen); 71167c478bd9Sstevel@tonic-gate } 71177c478bd9Sstevel@tonic-gate /* How much room is left? */ 71187c478bd9Sstevel@tonic-gate cp = strchr(dst, '\0'); 71197c478bd9Sstevel@tonic-gate if (dst + dstlen + 1 > cp) { 71207c478bd9Sstevel@tonic-gate *cp++ = '.'; 71217c478bd9Sstevel@tonic-gate dstlen -= (cp - dst); 71227c478bd9Sstevel@tonic-gate dstlen--; 71237c478bd9Sstevel@tonic-gate (void) portname(port, proto, cp, dstlen); 71247c478bd9Sstevel@tonic-gate } 71257c478bd9Sstevel@tonic-gate return (dst); 71267c478bd9Sstevel@tonic-gate } 71277c478bd9Sstevel@tonic-gate 7128d38b7101SDan McDonald /* 7129d38b7101SDan McDonald * Returns -2 to indicate a discontiguous mask. Otherwise returns between 7130d38b7101SDan McDonald * 0 and 32. 7131d38b7101SDan McDonald */ 7132d38b7101SDan McDonald static int 7133d38b7101SDan McDonald v4_cidr_len(uint_t mask) 7134d38b7101SDan McDonald { 7135d38b7101SDan McDonald int rc = 0; 7136d38b7101SDan McDonald int i; 7137d38b7101SDan McDonald 7138d38b7101SDan McDonald for (i = 0; i < 32; i++) { 7139d38b7101SDan McDonald if (mask & 0x1) 7140d38b7101SDan McDonald rc++; 7141d38b7101SDan McDonald else if (rc > 0) 7142d38b7101SDan McDonald return (-2); /* Discontiguous IPv4 netmask. */ 7143d38b7101SDan McDonald 7144d38b7101SDan McDonald mask >>= 1; 7145d38b7101SDan McDonald } 7146d38b7101SDan McDonald 7147d38b7101SDan McDonald return (rc); 7148d38b7101SDan McDonald } 7149d38b7101SDan McDonald 7150d38b7101SDan McDonald static void 7151d38b7101SDan McDonald append_v4_cidr_len(char *dst, uint_t dstlen, int prefixlen) 7152d38b7101SDan McDonald { 7153d38b7101SDan McDonald char *prefixptr; 7154d38b7101SDan McDonald 7155d38b7101SDan McDonald /* 4 bytes leaves room for '/' 'N' 'N' '\0' */ 7156d38b7101SDan McDonald if (strlen(dst) <= dstlen - 4) { 7157d38b7101SDan McDonald prefixptr = dst + strlen(dst); 7158d38b7101SDan McDonald } else { 7159d38b7101SDan McDonald /* 7160d38b7101SDan McDonald * Cut off last 3 chars of very-long DNS name. All callers 7161d38b7101SDan McDonald * should give us enough room, but name services COULD give us 7162d38b7101SDan McDonald * a way-too-big name (see above). 7163d38b7101SDan McDonald */ 7164d38b7101SDan McDonald prefixptr = dst + strlen(dst) - 3; 7165d38b7101SDan McDonald } 7166d38b7101SDan McDonald /* At this point "prefixptr" is guaranteed to point to 4 bytes. */ 7167d38b7101SDan McDonald 7168d38b7101SDan McDonald if (prefixlen >= 0) { 7169d38b7101SDan McDonald if (prefixlen > 32) /* Shouldn't happen, but... */ 7170d38b7101SDan McDonald prefixlen = 32; 7171d38b7101SDan McDonald (void) snprintf(prefixptr, 4, "/%d", prefixlen); 7172d38b7101SDan McDonald } else if (prefixlen == -2) { 7173d38b7101SDan McDonald /* "/NM" == Noncontiguous Mask. */ 7174d38b7101SDan McDonald (void) strcat(prefixptr, "/NM"); 7175d38b7101SDan McDonald } 7176d38b7101SDan McDonald /* Else print nothing extra. */ 7177d38b7101SDan McDonald } 7178d38b7101SDan McDonald 71797c478bd9Sstevel@tonic-gate /* 71807c478bd9Sstevel@tonic-gate * Return the name of the network whose address is given. The address is 71817c478bd9Sstevel@tonic-gate * assumed to be that of a net or subnet, not a host. 71827c478bd9Sstevel@tonic-gate */ 71837c478bd9Sstevel@tonic-gate static char * 71847c478bd9Sstevel@tonic-gate pr_net(uint_t addr, uint_t mask, char *dst, uint_t dstlen) 71857c478bd9Sstevel@tonic-gate { 71867c478bd9Sstevel@tonic-gate char *cp = NULL; 71877c478bd9Sstevel@tonic-gate struct netent *np = NULL; 71887c478bd9Sstevel@tonic-gate struct hostent *hp = NULL; 71897c478bd9Sstevel@tonic-gate uint_t net; 71907c478bd9Sstevel@tonic-gate int subnetshift; 71917c478bd9Sstevel@tonic-gate int error_num; 7192d38b7101SDan McDonald int prefixlen = -1; /* -1 == Don't print prefix! */ 7193d38b7101SDan McDonald /* -2 == Noncontiguous mask... */ 71947c478bd9Sstevel@tonic-gate 71957c478bd9Sstevel@tonic-gate if (addr == INADDR_ANY && mask == INADDR_ANY) { 7196d38b7101SDan McDonald (void) strlcpy(dst, "default", dstlen); 71977c478bd9Sstevel@tonic-gate return (dst); 71987c478bd9Sstevel@tonic-gate } 71997c478bd9Sstevel@tonic-gate 7200d38b7101SDan McDonald if (CIDRflag) 7201d38b7101SDan McDonald prefixlen = v4_cidr_len(ntohl(mask)); 7202d38b7101SDan McDonald 72037c478bd9Sstevel@tonic-gate if (!Nflag && addr) { 72047c478bd9Sstevel@tonic-gate if (mask == 0) { 72057c478bd9Sstevel@tonic-gate if (IN_CLASSA(addr)) { 72067c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSA_NET; 72077c478bd9Sstevel@tonic-gate subnetshift = 8; 72087c478bd9Sstevel@tonic-gate } else if (IN_CLASSB(addr)) { 72097c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSB_NET; 72107c478bd9Sstevel@tonic-gate subnetshift = 8; 72117c478bd9Sstevel@tonic-gate } else { 72127c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSC_NET; 72137c478bd9Sstevel@tonic-gate subnetshift = 4; 72147c478bd9Sstevel@tonic-gate } 72157c478bd9Sstevel@tonic-gate /* 72167c478bd9Sstevel@tonic-gate * If there are more bits than the standard mask 72177c478bd9Sstevel@tonic-gate * would suggest, subnets must be in use. Guess at 72187c478bd9Sstevel@tonic-gate * the subnet mask, assuming reasonable width subnet 72197c478bd9Sstevel@tonic-gate * fields. 72207c478bd9Sstevel@tonic-gate */ 72217c478bd9Sstevel@tonic-gate while (addr & ~mask) 72227c478bd9Sstevel@tonic-gate /* compiler doesn't sign extend! */ 72237c478bd9Sstevel@tonic-gate mask = (mask | ((int)mask >> subnetshift)); 7224d38b7101SDan McDonald if (CIDRflag) 7225d38b7101SDan McDonald prefixlen = v4_cidr_len(mask); 72267c478bd9Sstevel@tonic-gate } 72277c478bd9Sstevel@tonic-gate net = addr & mask; 72287c478bd9Sstevel@tonic-gate while ((mask & 1) == 0) 72297c478bd9Sstevel@tonic-gate mask >>= 1, net >>= 1; 7230afee3dc6SRobert Mustacchi ns_lookup_start(); 72317c478bd9Sstevel@tonic-gate np = getnetbyaddr(net, AF_INET); 7232afee3dc6SRobert Mustacchi ns_lookup_end(); 72337c478bd9Sstevel@tonic-gate if (np && np->n_net == net) 72347c478bd9Sstevel@tonic-gate cp = np->n_name; 72357c478bd9Sstevel@tonic-gate else { 72367c478bd9Sstevel@tonic-gate /* 72377c478bd9Sstevel@tonic-gate * Look for subnets in hosts map. 72387c478bd9Sstevel@tonic-gate */ 7239afee3dc6SRobert Mustacchi ns_lookup_start(); 72407c478bd9Sstevel@tonic-gate hp = getipnodebyaddr((char *)&addr, sizeof (uint_t), 72417c478bd9Sstevel@tonic-gate AF_INET, &error_num); 7242afee3dc6SRobert Mustacchi ns_lookup_end(); 72437c478bd9Sstevel@tonic-gate if (hp) 72447c478bd9Sstevel@tonic-gate cp = hp->h_name; 72457c478bd9Sstevel@tonic-gate } 72467c478bd9Sstevel@tonic-gate } 72477c478bd9Sstevel@tonic-gate if (cp != NULL) { 7248d38b7101SDan McDonald (void) strlcpy(dst, cp, dstlen); 72497c478bd9Sstevel@tonic-gate } else { 72507c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET, (char *)&addr, dst, dstlen); 72517c478bd9Sstevel@tonic-gate } 7252d38b7101SDan McDonald 7253d38b7101SDan McDonald append_v4_cidr_len(dst, dstlen, prefixlen); 7254d38b7101SDan McDonald 72557c478bd9Sstevel@tonic-gate if (hp != NULL) 72567c478bd9Sstevel@tonic-gate freehostent(hp); 72577c478bd9Sstevel@tonic-gate return (dst); 72587c478bd9Sstevel@tonic-gate } 72597c478bd9Sstevel@tonic-gate 72607c478bd9Sstevel@tonic-gate /* 72617c478bd9Sstevel@tonic-gate * Return the name of the network whose address is given. 72627c478bd9Sstevel@tonic-gate * The address is assumed to be a host address. 72637c478bd9Sstevel@tonic-gate */ 72647c478bd9Sstevel@tonic-gate static char * 72657c478bd9Sstevel@tonic-gate pr_netaddr(uint_t addr, uint_t mask, char *dst, uint_t dstlen) 72667c478bd9Sstevel@tonic-gate { 72677c478bd9Sstevel@tonic-gate char *cp = NULL; 72687c478bd9Sstevel@tonic-gate struct netent *np = NULL; 72697c478bd9Sstevel@tonic-gate struct hostent *hp = NULL; 72707c478bd9Sstevel@tonic-gate uint_t net; 72717c478bd9Sstevel@tonic-gate uint_t netshifted; 72727c478bd9Sstevel@tonic-gate int subnetshift; 72737c478bd9Sstevel@tonic-gate struct in_addr in; 72747c478bd9Sstevel@tonic-gate int error_num; 72757c478bd9Sstevel@tonic-gate uint_t nbo_addr = addr; /* network byte order */ 7276d38b7101SDan McDonald int prefixlen = -1; /* -1 == Don't print prefix! */ 7277d38b7101SDan McDonald /* -2 == Noncontiguous mask... */ 72787c478bd9Sstevel@tonic-gate 72797c478bd9Sstevel@tonic-gate addr = ntohl(addr); 72807c478bd9Sstevel@tonic-gate mask = ntohl(mask); 72817c478bd9Sstevel@tonic-gate if (addr == INADDR_ANY && mask == INADDR_ANY) { 7282d38b7101SDan McDonald (void) strlcpy(dst, "default", dstlen); 72837c478bd9Sstevel@tonic-gate return (dst); 72847c478bd9Sstevel@tonic-gate } 72857c478bd9Sstevel@tonic-gate 7286d38b7101SDan McDonald if (CIDRflag) 7287d38b7101SDan McDonald prefixlen = v4_cidr_len(mask); 7288d38b7101SDan McDonald 72897c478bd9Sstevel@tonic-gate /* Figure out network portion of address (with host portion = 0) */ 72907c478bd9Sstevel@tonic-gate if (addr) { 72917c478bd9Sstevel@tonic-gate /* Try figuring out mask if unknown (all 0s). */ 72927c478bd9Sstevel@tonic-gate if (mask == 0) { 72937c478bd9Sstevel@tonic-gate if (IN_CLASSA(addr)) { 72947c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSA_NET; 72957c478bd9Sstevel@tonic-gate subnetshift = 8; 72967c478bd9Sstevel@tonic-gate } else if (IN_CLASSB(addr)) { 72977c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSB_NET; 72987c478bd9Sstevel@tonic-gate subnetshift = 8; 72997c478bd9Sstevel@tonic-gate } else { 73007c478bd9Sstevel@tonic-gate mask = (uint_t)IN_CLASSC_NET; 73017c478bd9Sstevel@tonic-gate subnetshift = 4; 73027c478bd9Sstevel@tonic-gate } 73037c478bd9Sstevel@tonic-gate /* 73047c478bd9Sstevel@tonic-gate * If there are more bits than the standard mask 73057c478bd9Sstevel@tonic-gate * would suggest, subnets must be in use. Guess at 73067c478bd9Sstevel@tonic-gate * the subnet mask, assuming reasonable width subnet 73077c478bd9Sstevel@tonic-gate * fields. 73087c478bd9Sstevel@tonic-gate */ 73097c478bd9Sstevel@tonic-gate while (addr & ~mask) 73107c478bd9Sstevel@tonic-gate /* compiler doesn't sign extend! */ 73117c478bd9Sstevel@tonic-gate mask = (mask | ((int)mask >> subnetshift)); 7312d38b7101SDan McDonald if (CIDRflag) 7313d38b7101SDan McDonald prefixlen = v4_cidr_len(mask); 73147c478bd9Sstevel@tonic-gate } 73157c478bd9Sstevel@tonic-gate net = netshifted = addr & mask; 73167c478bd9Sstevel@tonic-gate while ((mask & 1) == 0) 73177c478bd9Sstevel@tonic-gate mask >>= 1, netshifted >>= 1; 73187c478bd9Sstevel@tonic-gate } 73197c478bd9Sstevel@tonic-gate else 73207c478bd9Sstevel@tonic-gate net = netshifted = 0; 73217c478bd9Sstevel@tonic-gate 73227c478bd9Sstevel@tonic-gate /* Try looking up name unless -n was specified. */ 73237c478bd9Sstevel@tonic-gate if (!Nflag) { 7324afee3dc6SRobert Mustacchi ns_lookup_start(); 73257c478bd9Sstevel@tonic-gate np = getnetbyaddr(netshifted, AF_INET); 7326afee3dc6SRobert Mustacchi ns_lookup_end(); 73277c478bd9Sstevel@tonic-gate if (np && np->n_net == netshifted) 73287c478bd9Sstevel@tonic-gate cp = np->n_name; 73297c478bd9Sstevel@tonic-gate else { 73307c478bd9Sstevel@tonic-gate /* 73317c478bd9Sstevel@tonic-gate * Look for subnets in hosts map. 73327c478bd9Sstevel@tonic-gate */ 7333afee3dc6SRobert Mustacchi ns_lookup_start(); 73347c478bd9Sstevel@tonic-gate hp = getipnodebyaddr((char *)&nbo_addr, sizeof (uint_t), 73357c478bd9Sstevel@tonic-gate AF_INET, &error_num); 7336afee3dc6SRobert Mustacchi ns_lookup_end(); 73377c478bd9Sstevel@tonic-gate if (hp) 73387c478bd9Sstevel@tonic-gate cp = hp->h_name; 73397c478bd9Sstevel@tonic-gate } 73407c478bd9Sstevel@tonic-gate 73417c478bd9Sstevel@tonic-gate if (cp != NULL) { 7342d38b7101SDan McDonald (void) strlcpy(dst, cp, dstlen); 7343d38b7101SDan McDonald append_v4_cidr_len(dst, dstlen, prefixlen); 73447c478bd9Sstevel@tonic-gate if (hp != NULL) 73457c478bd9Sstevel@tonic-gate freehostent(hp); 73467c478bd9Sstevel@tonic-gate return (dst); 73477c478bd9Sstevel@tonic-gate } 73487c478bd9Sstevel@tonic-gate /* 73497c478bd9Sstevel@tonic-gate * No name found for net: fallthru and return in decimal 73507c478bd9Sstevel@tonic-gate * dot notation. 73517c478bd9Sstevel@tonic-gate */ 73527c478bd9Sstevel@tonic-gate } 73537c478bd9Sstevel@tonic-gate 73547c478bd9Sstevel@tonic-gate in.s_addr = htonl(net); 73557c478bd9Sstevel@tonic-gate (void) inet_ntop(AF_INET, (char *)&in, dst, dstlen); 7356d38b7101SDan McDonald append_v4_cidr_len(dst, dstlen, prefixlen); 73577c478bd9Sstevel@tonic-gate if (hp != NULL) 73587c478bd9Sstevel@tonic-gate freehostent(hp); 73597c478bd9Sstevel@tonic-gate return (dst); 73607c478bd9Sstevel@tonic-gate } 73617c478bd9Sstevel@tonic-gate 73627c478bd9Sstevel@tonic-gate /* 73637c478bd9Sstevel@tonic-gate * Return the filter mode as a string: 73647c478bd9Sstevel@tonic-gate * 1 => "INCLUDE" 73657c478bd9Sstevel@tonic-gate * 2 => "EXCLUDE" 73667c478bd9Sstevel@tonic-gate * otherwise "<unknown>" 73677c478bd9Sstevel@tonic-gate */ 73687c478bd9Sstevel@tonic-gate static char * 73697c478bd9Sstevel@tonic-gate fmodestr(uint_t fmode) 73707c478bd9Sstevel@tonic-gate { 73717c478bd9Sstevel@tonic-gate switch (fmode) { 73727c478bd9Sstevel@tonic-gate case 1: 73737c478bd9Sstevel@tonic-gate return ("INCLUDE"); 73747c478bd9Sstevel@tonic-gate case 2: 73757c478bd9Sstevel@tonic-gate return ("EXCLUDE"); 73767c478bd9Sstevel@tonic-gate default: 73777c478bd9Sstevel@tonic-gate return ("<unknown>"); 73787c478bd9Sstevel@tonic-gate } 73797c478bd9Sstevel@tonic-gate } 73807c478bd9Sstevel@tonic-gate 738145916cd2Sjpk #define MAX_STRING_SIZE 256 738245916cd2Sjpk 738345916cd2Sjpk static const char * 738445916cd2Sjpk pr_secattr(const sec_attr_list_t *attrs) 738545916cd2Sjpk { 738645916cd2Sjpk int i; 738745916cd2Sjpk char buf[MAX_STRING_SIZE + 1], *cp; 738845916cd2Sjpk static char *sbuf; 738945916cd2Sjpk static size_t sbuf_len; 739045916cd2Sjpk struct rtsa_s rtsa; 739145916cd2Sjpk const sec_attr_list_t *aptr; 739245916cd2Sjpk 739345916cd2Sjpk if (!RSECflag || attrs == NULL) 739445916cd2Sjpk return (""); 739545916cd2Sjpk 739645916cd2Sjpk for (aptr = attrs, i = 1; aptr != NULL; aptr = aptr->sal_next) 739745916cd2Sjpk i += MAX_STRING_SIZE; 739845916cd2Sjpk if (i > sbuf_len) { 739945916cd2Sjpk cp = realloc(sbuf, i); 740045916cd2Sjpk if (cp == NULL) { 740145916cd2Sjpk perror("realloc security attribute buffer"); 740245916cd2Sjpk return (""); 740345916cd2Sjpk } 740445916cd2Sjpk sbuf_len = i; 740545916cd2Sjpk sbuf = cp; 740645916cd2Sjpk } 740745916cd2Sjpk 740845916cd2Sjpk cp = sbuf; 740945916cd2Sjpk while (attrs != NULL) { 741045916cd2Sjpk const mib2_ipAttributeEntry_t *iae = attrs->sal_attr; 741145916cd2Sjpk 741245916cd2Sjpk /* note: effectively hard-coded in rtsa_keyword */ 741345916cd2Sjpk rtsa.rtsa_mask = RTSA_CIPSO | RTSA_SLRANGE | RTSA_DOI; 741445916cd2Sjpk rtsa.rtsa_slrange = iae->iae_slrange; 741545916cd2Sjpk rtsa.rtsa_doi = iae->iae_doi; 741645916cd2Sjpk 741745916cd2Sjpk (void) snprintf(cp, MAX_STRING_SIZE, 741845916cd2Sjpk "<%s>%s ", rtsa_to_str(&rtsa, buf, sizeof (buf)), 741945916cd2Sjpk attrs->sal_next == NULL ? "" : ","); 742045916cd2Sjpk cp += strlen(cp); 742145916cd2Sjpk attrs = attrs->sal_next; 742245916cd2Sjpk } 742345916cd2Sjpk *cp = '\0'; 742445916cd2Sjpk 742545916cd2Sjpk return (sbuf); 742645916cd2Sjpk } 742745916cd2Sjpk 74287c478bd9Sstevel@tonic-gate /* 74297c478bd9Sstevel@tonic-gate * Pretty print a port number. If the Nflag was 74307c478bd9Sstevel@tonic-gate * specified, use numbers instead of names. 74317c478bd9Sstevel@tonic-gate */ 74327c478bd9Sstevel@tonic-gate static char * 74337c478bd9Sstevel@tonic-gate portname(uint_t port, char *proto, char *dst, uint_t dstlen) 74347c478bd9Sstevel@tonic-gate { 74357c478bd9Sstevel@tonic-gate struct servent *sp = NULL; 74367c478bd9Sstevel@tonic-gate 7437afee3dc6SRobert Mustacchi if (!Nflag && port) { 7438afee3dc6SRobert Mustacchi ns_lookup_start(); 74397c478bd9Sstevel@tonic-gate sp = getservbyport(htons(port), proto); 7440afee3dc6SRobert Mustacchi ns_lookup_end(); 7441afee3dc6SRobert Mustacchi } 74427c478bd9Sstevel@tonic-gate if (sp || port == 0) 74437c478bd9Sstevel@tonic-gate (void) snprintf(dst, dstlen, "%.*s", MAXHOSTNAMELEN, 7444e11c3f44Smeem sp ? sp->s_name : "*"); 74457c478bd9Sstevel@tonic-gate else 74467c478bd9Sstevel@tonic-gate (void) snprintf(dst, dstlen, "%d", port); 74477c478bd9Sstevel@tonic-gate dst[dstlen - 1] = 0; 74487c478bd9Sstevel@tonic-gate return (dst); 74497c478bd9Sstevel@tonic-gate } 74507c478bd9Sstevel@tonic-gate 74517c478bd9Sstevel@tonic-gate void 74527c478bd9Sstevel@tonic-gate fail(int do_perror, char *message, ...) 74537c478bd9Sstevel@tonic-gate { 74547c478bd9Sstevel@tonic-gate va_list args; 74557c478bd9Sstevel@tonic-gate 74567c478bd9Sstevel@tonic-gate va_start(args, message); 74577c478bd9Sstevel@tonic-gate (void) fputs("netstat: ", stderr); 74587c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, message, args); 74597c478bd9Sstevel@tonic-gate va_end(args); 74607c478bd9Sstevel@tonic-gate if (do_perror) 74617c478bd9Sstevel@tonic-gate (void) fprintf(stderr, ": %s", strerror(errno)); 74627c478bd9Sstevel@tonic-gate (void) fputc('\n', stderr); 74637c478bd9Sstevel@tonic-gate exit(2); 74647c478bd9Sstevel@tonic-gate } 74657c478bd9Sstevel@tonic-gate 746678a2e113SAndy Fiddaman /* 746778a2e113SAndy Fiddaman * fatal: print error message to stderr and 746878a2e113SAndy Fiddaman * call exit(errcode) 746978a2e113SAndy Fiddaman */ 747078a2e113SAndy Fiddaman static void 747178a2e113SAndy Fiddaman fatal(int errcode, char *format, ...) 747278a2e113SAndy Fiddaman { 747378a2e113SAndy Fiddaman if (format != NULL) { 747478a2e113SAndy Fiddaman va_list argp; 747578a2e113SAndy Fiddaman 747678a2e113SAndy Fiddaman va_start(argp, format); 747778a2e113SAndy Fiddaman (void) vfprintf(stderr, format, argp); 747878a2e113SAndy Fiddaman va_end(argp); 747978a2e113SAndy Fiddaman } 748078a2e113SAndy Fiddaman 748178a2e113SAndy Fiddaman exit(errcode); 748278a2e113SAndy Fiddaman } 748378a2e113SAndy Fiddaman 748478a2e113SAndy Fiddaman 74857c478bd9Sstevel@tonic-gate /* 74867c478bd9Sstevel@tonic-gate * Return value of named statistic for given kstat_named kstat; 74877c478bd9Sstevel@tonic-gate * return 0LL if named statistic is not in list (use "ll" as a 74887c478bd9Sstevel@tonic-gate * type qualifier when printing 64-bit int's with printf() ) 74897c478bd9Sstevel@tonic-gate */ 74907c478bd9Sstevel@tonic-gate static uint64_t 74917c478bd9Sstevel@tonic-gate kstat_named_value(kstat_t *ksp, char *name) 74927c478bd9Sstevel@tonic-gate { 74937c478bd9Sstevel@tonic-gate kstat_named_t *knp; 74947c478bd9Sstevel@tonic-gate uint64_t value; 74957c478bd9Sstevel@tonic-gate 74967c478bd9Sstevel@tonic-gate if (ksp == NULL) 74977c478bd9Sstevel@tonic-gate return (0LL); 74987c478bd9Sstevel@tonic-gate 74997c478bd9Sstevel@tonic-gate knp = kstat_data_lookup(ksp, name); 75007c478bd9Sstevel@tonic-gate if (knp == NULL) 75017c478bd9Sstevel@tonic-gate return (0LL); 75027c478bd9Sstevel@tonic-gate 75037c478bd9Sstevel@tonic-gate switch (knp->data_type) { 75047c478bd9Sstevel@tonic-gate case KSTAT_DATA_INT32: 75057c478bd9Sstevel@tonic-gate case KSTAT_DATA_UINT32: 75067c478bd9Sstevel@tonic-gate value = (uint64_t)(knp->value.ui32); 75077c478bd9Sstevel@tonic-gate break; 75087c478bd9Sstevel@tonic-gate case KSTAT_DATA_INT64: 75097c478bd9Sstevel@tonic-gate case KSTAT_DATA_UINT64: 75107c478bd9Sstevel@tonic-gate value = knp->value.ui64; 75117c478bd9Sstevel@tonic-gate break; 75127c478bd9Sstevel@tonic-gate default: 75137c478bd9Sstevel@tonic-gate value = 0LL; 75147c478bd9Sstevel@tonic-gate break; 75157c478bd9Sstevel@tonic-gate } 75167c478bd9Sstevel@tonic-gate 75177c478bd9Sstevel@tonic-gate return (value); 75187c478bd9Sstevel@tonic-gate } 75197c478bd9Sstevel@tonic-gate 75207c478bd9Sstevel@tonic-gate kid_t 75217c478bd9Sstevel@tonic-gate safe_kstat_read(kstat_ctl_t *kc, kstat_t *ksp, void *data) 75227c478bd9Sstevel@tonic-gate { 75237c478bd9Sstevel@tonic-gate kid_t kstat_chain_id = kstat_read(kc, ksp, data); 75247c478bd9Sstevel@tonic-gate 75257c478bd9Sstevel@tonic-gate if (kstat_chain_id == -1) 75267c478bd9Sstevel@tonic-gate fail(1, "kstat_read(%p, '%s') failed", (void *)kc, 75277c478bd9Sstevel@tonic-gate ksp->ks_name); 75287c478bd9Sstevel@tonic-gate return (kstat_chain_id); 75297c478bd9Sstevel@tonic-gate } 75307c478bd9Sstevel@tonic-gate 75317c478bd9Sstevel@tonic-gate /* 75327c478bd9Sstevel@tonic-gate * Parse a list of IRE flag characters into a bit field. 75337c478bd9Sstevel@tonic-gate */ 75347c478bd9Sstevel@tonic-gate static uint_t 75357c478bd9Sstevel@tonic-gate flag_bits(const char *arg) 75367c478bd9Sstevel@tonic-gate { 75377c478bd9Sstevel@tonic-gate const char *cp; 75387c478bd9Sstevel@tonic-gate uint_t val; 75397c478bd9Sstevel@tonic-gate 75407c478bd9Sstevel@tonic-gate if (*arg == '\0') 75417c478bd9Sstevel@tonic-gate fatal(1, "missing flag list\n"); 75427c478bd9Sstevel@tonic-gate 75437c478bd9Sstevel@tonic-gate val = 0; 75447c478bd9Sstevel@tonic-gate while (*arg != '\0') { 75457c478bd9Sstevel@tonic-gate if ((cp = strchr(flag_list, *arg)) == NULL) 75467c478bd9Sstevel@tonic-gate fatal(1, "%c: illegal flag\n", *arg); 75477c478bd9Sstevel@tonic-gate val |= 1 << (cp - flag_list); 75487c478bd9Sstevel@tonic-gate arg++; 75497c478bd9Sstevel@tonic-gate } 75507c478bd9Sstevel@tonic-gate return (val); 75517c478bd9Sstevel@tonic-gate } 75527c478bd9Sstevel@tonic-gate 75537c478bd9Sstevel@tonic-gate /* 75547c478bd9Sstevel@tonic-gate * Handle -f argument. Validate input format, sort by keyword, and 75557c478bd9Sstevel@tonic-gate * save off digested results. 75567c478bd9Sstevel@tonic-gate */ 75577c478bd9Sstevel@tonic-gate static void 75587c478bd9Sstevel@tonic-gate process_filter(char *arg) 75597c478bd9Sstevel@tonic-gate { 75607c478bd9Sstevel@tonic-gate int idx; 75617c478bd9Sstevel@tonic-gate int klen = 0; 75627c478bd9Sstevel@tonic-gate char *cp, *cp2; 75637c478bd9Sstevel@tonic-gate int val; 75647c478bd9Sstevel@tonic-gate filter_t *newf; 75657c478bd9Sstevel@tonic-gate struct hostent *hp; 75667c478bd9Sstevel@tonic-gate int error_num; 75677c478bd9Sstevel@tonic-gate uint8_t *ucp; 75687c478bd9Sstevel@tonic-gate int maxv; 75697c478bd9Sstevel@tonic-gate 75707c478bd9Sstevel@tonic-gate /* Look up the keyword first */ 75717c478bd9Sstevel@tonic-gate if (strchr(arg, ':') == NULL) { 75727c478bd9Sstevel@tonic-gate idx = FK_AF; 75737c478bd9Sstevel@tonic-gate } else { 75747c478bd9Sstevel@tonic-gate for (idx = 0; idx < NFILTERKEYS; idx++) { 75757c478bd9Sstevel@tonic-gate klen = strlen(filter_keys[idx]); 75767c478bd9Sstevel@tonic-gate if (strncmp(filter_keys[idx], arg, klen) == 0 && 75777c478bd9Sstevel@tonic-gate arg[klen] == ':') 75787c478bd9Sstevel@tonic-gate break; 75797c478bd9Sstevel@tonic-gate } 75807c478bd9Sstevel@tonic-gate if (idx >= NFILTERKEYS) 75817c478bd9Sstevel@tonic-gate fatal(1, "%s: unknown filter keyword\n", arg); 75827c478bd9Sstevel@tonic-gate 75837c478bd9Sstevel@tonic-gate /* Advance past keyword and separator. */ 75847c478bd9Sstevel@tonic-gate arg += klen + 1; 75857c478bd9Sstevel@tonic-gate } 75867c478bd9Sstevel@tonic-gate 75877c478bd9Sstevel@tonic-gate if ((newf = malloc(sizeof (*newf))) == NULL) { 75887c478bd9Sstevel@tonic-gate perror("filter"); 75897c478bd9Sstevel@tonic-gate exit(1); 75907c478bd9Sstevel@tonic-gate } 75917c478bd9Sstevel@tonic-gate switch (idx) { 75927c478bd9Sstevel@tonic-gate case FK_AF: 75937c478bd9Sstevel@tonic-gate if (strcmp(arg, "inet") == 0) { 75947c478bd9Sstevel@tonic-gate newf->u.f_family = AF_INET; 75957c478bd9Sstevel@tonic-gate } else if (strcmp(arg, "inet6") == 0) { 75967c478bd9Sstevel@tonic-gate newf->u.f_family = AF_INET6; 75977c478bd9Sstevel@tonic-gate } else if (strcmp(arg, "unix") == 0) { 75987c478bd9Sstevel@tonic-gate newf->u.f_family = AF_UNIX; 75997c478bd9Sstevel@tonic-gate } else { 76007c478bd9Sstevel@tonic-gate newf->u.f_family = strtol(arg, &cp, 0); 76017c478bd9Sstevel@tonic-gate if (arg == cp || *cp != '\0') 76027c478bd9Sstevel@tonic-gate fatal(1, "%s: unknown address family.\n", arg); 76037c478bd9Sstevel@tonic-gate } 76047c478bd9Sstevel@tonic-gate break; 76057c478bd9Sstevel@tonic-gate 76067c478bd9Sstevel@tonic-gate case FK_OUTIF: 76077c478bd9Sstevel@tonic-gate if (strcmp(arg, "none") == 0) { 76087c478bd9Sstevel@tonic-gate newf->u.f_ifname = NULL; 76097c478bd9Sstevel@tonic-gate break; 76107c478bd9Sstevel@tonic-gate } 76117c478bd9Sstevel@tonic-gate if (strcmp(arg, "any") == 0) { 76127c478bd9Sstevel@tonic-gate newf->u.f_ifname = ""; 76137c478bd9Sstevel@tonic-gate break; 76147c478bd9Sstevel@tonic-gate } 76157c478bd9Sstevel@tonic-gate val = strtol(arg, &cp, 0); 76167c478bd9Sstevel@tonic-gate if (val <= 0 || arg == cp || cp[0] != '\0') { 76177c478bd9Sstevel@tonic-gate if ((val = if_nametoindex(arg)) == 0) { 76187c478bd9Sstevel@tonic-gate perror(arg); 76197c478bd9Sstevel@tonic-gate exit(1); 76207c478bd9Sstevel@tonic-gate } 76217c478bd9Sstevel@tonic-gate } 76227c478bd9Sstevel@tonic-gate newf->u.f_ifname = arg; 76237c478bd9Sstevel@tonic-gate break; 76247c478bd9Sstevel@tonic-gate 76257c478bd9Sstevel@tonic-gate case FK_DST: 76267c478bd9Sstevel@tonic-gate V4MASK_TO_V6(IP_HOST_MASK, newf->u.a.f_mask); 76277c478bd9Sstevel@tonic-gate if (strcmp(arg, "any") == 0) { 76287c478bd9Sstevel@tonic-gate /* Special semantics; any address *but* zero */ 76297c478bd9Sstevel@tonic-gate newf->u.a.f_address = NULL; 76307c478bd9Sstevel@tonic-gate (void) memset(&newf->u.a.f_mask, 0, 76317c478bd9Sstevel@tonic-gate sizeof (newf->u.a.f_mask)); 76327c478bd9Sstevel@tonic-gate break; 76337c478bd9Sstevel@tonic-gate } 76347c478bd9Sstevel@tonic-gate if (strcmp(arg, "none") == 0) { 76357c478bd9Sstevel@tonic-gate newf->u.a.f_address = NULL; 76367c478bd9Sstevel@tonic-gate break; 76377c478bd9Sstevel@tonic-gate } 76387c478bd9Sstevel@tonic-gate if ((cp = strrchr(arg, '/')) != NULL) 76397c478bd9Sstevel@tonic-gate *cp++ = '\0'; 76407c478bd9Sstevel@tonic-gate hp = getipnodebyname(arg, AF_INET6, AI_V4MAPPED|AI_ALL, 76417c478bd9Sstevel@tonic-gate &error_num); 76427c478bd9Sstevel@tonic-gate if (hp == NULL) 76437c478bd9Sstevel@tonic-gate fatal(1, "%s: invalid or unknown host address\n", arg); 76447c478bd9Sstevel@tonic-gate newf->u.a.f_address = hp; 76457c478bd9Sstevel@tonic-gate if (cp == NULL) { 76467c478bd9Sstevel@tonic-gate V4MASK_TO_V6(IP_HOST_MASK, newf->u.a.f_mask); 76477c478bd9Sstevel@tonic-gate } else { 76487c478bd9Sstevel@tonic-gate val = strtol(cp, &cp2, 0); 76497c478bd9Sstevel@tonic-gate if (cp != cp2 && cp2[0] == '\0') { 76507c478bd9Sstevel@tonic-gate /* 76517c478bd9Sstevel@tonic-gate * If decode as "/n" works, then translate 76527c478bd9Sstevel@tonic-gate * into a mask. 76537c478bd9Sstevel@tonic-gate */ 76547c478bd9Sstevel@tonic-gate if (hp->h_addr_list[0] != NULL && 7655e11c3f44Smeem IN6_IS_ADDR_V4MAPPED((in6_addr_t *) 7656e11c3f44Smeem hp->h_addr_list[0])) { 76577c478bd9Sstevel@tonic-gate maxv = IP_ABITS; 76587c478bd9Sstevel@tonic-gate } else { 76597c478bd9Sstevel@tonic-gate maxv = IPV6_ABITS; 76607c478bd9Sstevel@tonic-gate } 76617c478bd9Sstevel@tonic-gate if (val < 0 || val >= maxv) 76627c478bd9Sstevel@tonic-gate fatal(1, "%d: not in range 0 to %d\n", 76637c478bd9Sstevel@tonic-gate val, maxv - 1); 76647c478bd9Sstevel@tonic-gate if (maxv == IP_ABITS) 76657c478bd9Sstevel@tonic-gate val += IPV6_ABITS - IP_ABITS; 76667c478bd9Sstevel@tonic-gate ucp = newf->u.a.f_mask.s6_addr; 76677c478bd9Sstevel@tonic-gate while (val >= 8) 76687c478bd9Sstevel@tonic-gate *ucp++ = 0xff, val -= 8; 76697c478bd9Sstevel@tonic-gate *ucp++ = (0xff << (8 - val)) & 0xff; 76707c478bd9Sstevel@tonic-gate while (ucp < newf->u.a.f_mask.s6_addr + 76717c478bd9Sstevel@tonic-gate sizeof (newf->u.a.f_mask.s6_addr)) 76727c478bd9Sstevel@tonic-gate *ucp++ = 0; 76737c478bd9Sstevel@tonic-gate /* Otherwise, try as numeric address */ 76747c478bd9Sstevel@tonic-gate } else if (inet_pton(AF_INET6, 76757c478bd9Sstevel@tonic-gate cp, &newf->u.a.f_mask) <= 0) { 76767c478bd9Sstevel@tonic-gate fatal(1, "%s: illegal mask format\n", cp); 76777c478bd9Sstevel@tonic-gate } 76787c478bd9Sstevel@tonic-gate } 76797c478bd9Sstevel@tonic-gate break; 76807c478bd9Sstevel@tonic-gate 76817c478bd9Sstevel@tonic-gate case FK_FLAGS: 76827c478bd9Sstevel@tonic-gate if (*arg == '+') { 76837c478bd9Sstevel@tonic-gate newf->u.f.f_flagset = flag_bits(arg + 1); 76847c478bd9Sstevel@tonic-gate newf->u.f.f_flagclear = 0; 76857c478bd9Sstevel@tonic-gate } else if (*arg == '-') { 76867c478bd9Sstevel@tonic-gate newf->u.f.f_flagset = 0; 76877c478bd9Sstevel@tonic-gate newf->u.f.f_flagclear = flag_bits(arg + 1); 76887c478bd9Sstevel@tonic-gate } else { 76897c478bd9Sstevel@tonic-gate newf->u.f.f_flagset = flag_bits(arg); 76907c478bd9Sstevel@tonic-gate newf->u.f.f_flagclear = ~newf->u.f.f_flagset; 76917c478bd9Sstevel@tonic-gate } 76927c478bd9Sstevel@tonic-gate break; 76937c478bd9Sstevel@tonic-gate 76947c478bd9Sstevel@tonic-gate default: 76957c478bd9Sstevel@tonic-gate assert(0); 76967c478bd9Sstevel@tonic-gate } 76977c478bd9Sstevel@tonic-gate newf->f_next = filters[idx]; 76987c478bd9Sstevel@tonic-gate filters[idx] = newf; 76997c478bd9Sstevel@tonic-gate } 77007c478bd9Sstevel@tonic-gate 77017c478bd9Sstevel@tonic-gate /* Determine if user wants this address family printed. */ 77027c478bd9Sstevel@tonic-gate static boolean_t 77037c478bd9Sstevel@tonic-gate family_selected(int family) 77047c478bd9Sstevel@tonic-gate { 77057c478bd9Sstevel@tonic-gate const filter_t *fp; 77067c478bd9Sstevel@tonic-gate 77077c478bd9Sstevel@tonic-gate if (v4compat && family == AF_INET6) 77087c478bd9Sstevel@tonic-gate return (B_FALSE); 77097c478bd9Sstevel@tonic-gate if ((fp = filters[FK_AF]) == NULL) 77107c478bd9Sstevel@tonic-gate return (B_TRUE); 77117c478bd9Sstevel@tonic-gate while (fp != NULL) { 77127c478bd9Sstevel@tonic-gate if (fp->u.f_family == family) 77137c478bd9Sstevel@tonic-gate return (B_TRUE); 77147c478bd9Sstevel@tonic-gate fp = fp->f_next; 77157c478bd9Sstevel@tonic-gate } 77167c478bd9Sstevel@tonic-gate return (B_FALSE); 77177c478bd9Sstevel@tonic-gate } 77187c478bd9Sstevel@tonic-gate 7719e11c3f44Smeem /* 7720e11c3f44Smeem * Convert the interface index to a string using the buffer `ifname', which 7721e11c3f44Smeem * must be at least LIFNAMSIZ bytes. We first try to map it to name. If that 7722e11c3f44Smeem * fails (e.g., because we're inside a zone and it does not have access to 7723e11c3f44Smeem * interface for the index in question), just return "if#<num>". 7724e11c3f44Smeem */ 7725e11c3f44Smeem static char * 7726e11c3f44Smeem ifindex2str(uint_t ifindex, char *ifname) 7727e11c3f44Smeem { 7728e11c3f44Smeem if (if_indextoname(ifindex, ifname) == NULL) 7729e11c3f44Smeem (void) snprintf(ifname, LIFNAMSIZ, "if#%d", ifindex); 7730e11c3f44Smeem 7731e11c3f44Smeem return (ifname); 7732e11c3f44Smeem } 7733e11c3f44Smeem 77347c478bd9Sstevel@tonic-gate /* 77357c478bd9Sstevel@tonic-gate * print the usage line 77367c478bd9Sstevel@tonic-gate */ 77377c478bd9Sstevel@tonic-gate static void 77387c478bd9Sstevel@tonic-gate usage(char *cmdname) 77397c478bd9Sstevel@tonic-gate { 774078a2e113SAndy Fiddaman (void) fprintf(stderr, "usage: %s [-anuv] [-f address_family] " 774126fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-T d|u]\n", cmdname); 77427c478bd9Sstevel@tonic-gate (void) fprintf(stderr, " %s [-n] [-f address_family] " 774326fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-P protocol] [-T d|u] [-g | -p | -s [interval [count]]]\n", 774426fd7700SKrishnendu Sadhukhan - Sun Microsystems cmdname); 774526fd7700SKrishnendu Sadhukhan - Sun Microsystems (void) fprintf(stderr, " %s -m [-v] [-T d|u] " 77467c478bd9Sstevel@tonic-gate "[interval [count]]\n", cmdname); 77477c478bd9Sstevel@tonic-gate (void) fprintf(stderr, " %s -i [-I interface] [-an] " 774826fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-f address_family] [-T d|u] [interval [count]]\n", cmdname); 77497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, " %s -r [-anv] " 775026fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-f address_family|filter] [-T d|u]\n", cmdname); 775126fd7700SKrishnendu Sadhukhan - Sun Microsystems (void) fprintf(stderr, " %s -M [-ns] [-f address_family] " 775226fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-T d|u]\n", cmdname); 77537c478bd9Sstevel@tonic-gate (void) fprintf(stderr, " %s -D [-I interface] " 775426fd7700SKrishnendu Sadhukhan - Sun Microsystems "[-f address_family] [-T d|u]\n", cmdname); 77557c478bd9Sstevel@tonic-gate exit(EXIT_FAILURE); 77567c478bd9Sstevel@tonic-gate } 77577c478bd9Sstevel@tonic-gate 775878a2e113SAndy Fiddaman /* -------------------UNIX Domain Sockets Report---------------------------- */ 775978a2e113SAndy Fiddaman 776078a2e113SAndy Fiddaman #define UDS_SO_PAIR "(socketpair)" 776178a2e113SAndy Fiddaman 776278a2e113SAndy Fiddaman static char *typetoname(t_scalar_t); 776378a2e113SAndy Fiddaman static boolean_t uds_report_item(struct sockinfo *, boolean_t); 776478a2e113SAndy Fiddaman 77657c478bd9Sstevel@tonic-gate /* 776678a2e113SAndy Fiddaman * Central definitions for the columns used in the reports. 776778a2e113SAndy Fiddaman * For each column, there's a definition for the heading, the underline and 776878a2e113SAndy Fiddaman * the formatted value. 776978a2e113SAndy Fiddaman * Since most reports select different columns depending on command line 777078a2e113SAndy Fiddaman * options, defining everything here avoids duplication in the report 777178a2e113SAndy Fiddaman * format strings and makes it easy to make changes as necessary. 777278a2e113SAndy Fiddaman */ 777378a2e113SAndy Fiddaman #define UDS_ADDRESS "Address " 777478a2e113SAndy Fiddaman #define UDS_ADDRESS_ "----------------" 777578a2e113SAndy Fiddaman #define UDS_ADDRESS_F "%-16.16s" 777678a2e113SAndy Fiddaman #define UDS_TYPE "Type " 777778a2e113SAndy Fiddaman #define UDS_TYPE_ "----------" 777878a2e113SAndy Fiddaman #define UDS_TYPE_F "%-10.10s" 777978a2e113SAndy Fiddaman #define UDS_VNODE "Vnode " 778078a2e113SAndy Fiddaman #define UDS_VNODE_ "----------------" 778178a2e113SAndy Fiddaman #define UDS_VNODE_F "%-16.16s" 778278a2e113SAndy Fiddaman #define UDS_CONN "Conn " 778378a2e113SAndy Fiddaman #define UDS_CONN_ "----------------" 778478a2e113SAndy Fiddaman #define UDS_CONN_F "%-16.16s" 778578a2e113SAndy Fiddaman #define UDS_LOCAL "Local Address " 778678a2e113SAndy Fiddaman #define UDS_LOCAL_ "---------------------------------------" 778778a2e113SAndy Fiddaman #define UDS_LOCAL_F "%-39.39s" 778878a2e113SAndy Fiddaman #define UDS_REMOTE "Remote Address " 778978a2e113SAndy Fiddaman #define UDS_REMOTE_ "---------------------------------------" 779078a2e113SAndy Fiddaman #define UDS_REMOTE_F "%-39.39s" 779178a2e113SAndy Fiddaman #define UDS_USER "User " 779278a2e113SAndy Fiddaman #define UDS_USER_ "--------" 779378a2e113SAndy Fiddaman #define UDS_USER_F "%-8.8s" 779478a2e113SAndy Fiddaman #define UDS_PID "Pid " 779578a2e113SAndy Fiddaman #define UDS_PID_ "------" 779678a2e113SAndy Fiddaman #define UDS_PID_F "%6s" 779778a2e113SAndy Fiddaman #define UDS_COMMAND "Command " 779878a2e113SAndy Fiddaman #define UDS_COMMAND_ "--------------" 779978a2e113SAndy Fiddaman #define UDS_COMMAND_F "%-14.14s" 780078a2e113SAndy Fiddaman 780178a2e113SAndy Fiddaman static const char uds_hdr[] = "\nActive UNIX domain sockets\n"; 780278a2e113SAndy Fiddaman 780378a2e113SAndy Fiddaman static const char uds_hdr_normal[] = 780478a2e113SAndy Fiddaman UDS_ADDRESS " " UDS_TYPE " " UDS_VNODE " " UDS_CONN " " 780578a2e113SAndy Fiddaman UDS_LOCAL " " UDS_REMOTE "\n" 780678a2e113SAndy Fiddaman UDS_ADDRESS_" " UDS_TYPE_" " UDS_VNODE_" " UDS_CONN_" " 780778a2e113SAndy Fiddaman UDS_LOCAL_" " UDS_REMOTE_"\n"; 780878a2e113SAndy Fiddaman 780978a2e113SAndy Fiddaman static const char uds_hdr_pid[] = 781078a2e113SAndy Fiddaman UDS_ADDRESS " " UDS_TYPE " " UDS_USER " " UDS_PID " " UDS_COMMAND " " 781178a2e113SAndy Fiddaman UDS_LOCAL " " UDS_REMOTE "\n" 781278a2e113SAndy Fiddaman UDS_ADDRESS_ " " UDS_TYPE_" " UDS_USER_" " UDS_PID_" " UDS_COMMAND_" " 781378a2e113SAndy Fiddaman UDS_LOCAL_" " UDS_REMOTE_"\n"; 781478a2e113SAndy Fiddaman 781578a2e113SAndy Fiddaman static const char uds_hdr_pid_verbose[] = 781678a2e113SAndy Fiddaman UDS_ADDRESS " " UDS_TYPE " " UDS_USER " " UDS_PID " " 781778a2e113SAndy Fiddaman UDS_LOCAL " " UDS_REMOTE " " UDS_COMMAND "\n" 781878a2e113SAndy Fiddaman UDS_ADDRESS_ " " UDS_TYPE_" " UDS_USER_" " UDS_PID_" " 781978a2e113SAndy Fiddaman UDS_LOCAL_" " UDS_REMOTE_" " UDS_COMMAND_"\n"; 782078a2e113SAndy Fiddaman 782178a2e113SAndy Fiddaman /* 782278a2e113SAndy Fiddaman * Print a summary of connections related to unix protocols. 78237c478bd9Sstevel@tonic-gate */ 78247c478bd9Sstevel@tonic-gate static void 782578a2e113SAndy Fiddaman uds_report(kstat_ctl_t *kc) 782645916cd2Sjpk { 782778a2e113SAndy Fiddaman uint32_t i; 782878a2e113SAndy Fiddaman kstat_t *ksp; 782978a2e113SAndy Fiddaman struct sockinfo *psi; 783078a2e113SAndy Fiddaman boolean_t print_uds_hdr_once = B_TRUE; 78317c478bd9Sstevel@tonic-gate 783278a2e113SAndy Fiddaman if (kc == NULL) { 783378a2e113SAndy Fiddaman fail(0, "uds_report: No kstat"); 783478a2e113SAndy Fiddaman exit(3); 783578a2e113SAndy Fiddaman } 78367c478bd9Sstevel@tonic-gate 783778a2e113SAndy Fiddaman if ((ksp = kstat_lookup(kc, "sockfs", 0, "sock_unix_list")) == NULL) 783878a2e113SAndy Fiddaman fail(0, "kstat_data_lookup failed\n"); 78397c478bd9Sstevel@tonic-gate 784078a2e113SAndy Fiddaman if (kstat_read(kc, ksp, NULL) == -1) 784178a2e113SAndy Fiddaman fail(0, "kstat_read failed for sock_unix_list\n"); 784278a2e113SAndy Fiddaman 784378a2e113SAndy Fiddaman if (ksp->ks_ndata == 0) 784478a2e113SAndy Fiddaman return; /* no AF_UNIX sockets found */ 784578a2e113SAndy Fiddaman 784678a2e113SAndy Fiddaman /* 784778a2e113SAndy Fiddaman * Having ks_data set with ks_data == NULL shouldn't happen; 784878a2e113SAndy Fiddaman * If it does, the sockfs kstat is seriously broken. 784978a2e113SAndy Fiddaman */ 785078a2e113SAndy Fiddaman if ((psi = ksp->ks_data) == NULL) 785178a2e113SAndy Fiddaman fail(0, "uds_report: no kstat data\n"); 785278a2e113SAndy Fiddaman 785378a2e113SAndy Fiddaman for (i = 0; i < ksp->ks_ndata; i++) { 785478a2e113SAndy Fiddaman 785578a2e113SAndy Fiddaman print_uds_hdr_once = uds_report_item(psi, print_uds_hdr_once); 785678a2e113SAndy Fiddaman 785778a2e113SAndy Fiddaman /* If si_size didn't get filled in, then we're done */ 785878a2e113SAndy Fiddaman if (psi->si_size == 0 || 785978a2e113SAndy Fiddaman !IS_P2ALIGNED(psi->si_size, sizeof (psi))) 786078a2e113SAndy Fiddaman break; 786178a2e113SAndy Fiddaman 786278a2e113SAndy Fiddaman /* Point to the next sockinfo in the array */ 786378a2e113SAndy Fiddaman psi = (struct sockinfo *)(((char *)psi) + psi->si_size); 786478a2e113SAndy Fiddaman } 786578a2e113SAndy Fiddaman } 786678a2e113SAndy Fiddaman 786778a2e113SAndy Fiddaman static boolean_t 786878a2e113SAndy Fiddaman uds_report_item(struct sockinfo *psi, boolean_t first) 786978a2e113SAndy Fiddaman { 787078a2e113SAndy Fiddaman char *laddr, *raddr; 787178a2e113SAndy Fiddaman proc_fdinfo_t *ph; 787278a2e113SAndy Fiddaman 787378a2e113SAndy Fiddaman if (first) { 787478a2e113SAndy Fiddaman (void) printf("%s", uds_hdr); 787578a2e113SAndy Fiddaman if (Uflag) 787678a2e113SAndy Fiddaman (void) printf("%s", 787778a2e113SAndy Fiddaman Vflag ? uds_hdr_pid_verbose : uds_hdr_pid); 787878a2e113SAndy Fiddaman else 787978a2e113SAndy Fiddaman (void) printf("%s", uds_hdr_normal); 788078a2e113SAndy Fiddaman 788178a2e113SAndy Fiddaman first = B_FALSE; 788278a2e113SAndy Fiddaman } 788378a2e113SAndy Fiddaman 788478a2e113SAndy Fiddaman raddr = laddr = ""; 788578a2e113SAndy Fiddaman 788678a2e113SAndy Fiddaman if ((psi->si_state & SS_ISBOUND) && 788778a2e113SAndy Fiddaman strlen(psi->si_laddr_sun_path) != 0 && 788878a2e113SAndy Fiddaman psi->si_laddr_soa_len != 0) { 788978a2e113SAndy Fiddaman if (psi->si_faddr_noxlate) { 789078a2e113SAndy Fiddaman laddr = UDS_SO_PAIR; 789178a2e113SAndy Fiddaman } else { 789278a2e113SAndy Fiddaman if (psi->si_laddr_soa_len > 789378a2e113SAndy Fiddaman sizeof (psi->si_laddr_family)) 789478a2e113SAndy Fiddaman laddr = psi->si_laddr_sun_path; 789578a2e113SAndy Fiddaman } 789678a2e113SAndy Fiddaman } 789778a2e113SAndy Fiddaman 789878a2e113SAndy Fiddaman if ((psi->si_state & SS_ISCONNECTED) && 789978a2e113SAndy Fiddaman strlen(psi->si_faddr_sun_path) != 0 && 790078a2e113SAndy Fiddaman psi->si_faddr_soa_len != 0) { 790178a2e113SAndy Fiddaman if (psi->si_faddr_noxlate) { 790278a2e113SAndy Fiddaman raddr = UDS_SO_PAIR; 790378a2e113SAndy Fiddaman } else { 790478a2e113SAndy Fiddaman if (psi->si_faddr_soa_len > 790578a2e113SAndy Fiddaman sizeof (psi->si_faddr_family)) 790678a2e113SAndy Fiddaman raddr = psi->si_faddr_sun_path; 790778a2e113SAndy Fiddaman } 790878a2e113SAndy Fiddaman } 790978a2e113SAndy Fiddaman 791078a2e113SAndy Fiddaman /* Traditional output */ 791178a2e113SAndy Fiddaman if (!Uflag) { 791278a2e113SAndy Fiddaman (void) printf( 791378a2e113SAndy Fiddaman UDS_ADDRESS_F " " UDS_TYPE_F " " UDS_VNODE_F " " 791478a2e113SAndy Fiddaman UDS_CONN_F " " UDS_LOCAL_F " " UDS_REMOTE_F "\n", 791578a2e113SAndy Fiddaman psi->si_son_straddr, 791678a2e113SAndy Fiddaman typetoname(psi->si_serv_type), 791778a2e113SAndy Fiddaman (psi->si_state & SS_ISBOUND) && 791878a2e113SAndy Fiddaman psi->si_ux_laddr_sou_magic == SOU_MAGIC_EXPLICIT ? 791978a2e113SAndy Fiddaman psi->si_lvn_straddr : "0000000", 792078a2e113SAndy Fiddaman (psi->si_state & SS_ISCONNECTED) && 792178a2e113SAndy Fiddaman psi->si_ux_faddr_sou_magic == SOU_MAGIC_EXPLICIT ? 792278a2e113SAndy Fiddaman psi->si_fvn_straddr : "0000000", 792378a2e113SAndy Fiddaman laddr, raddr); 792478a2e113SAndy Fiddaman return (first); 792578a2e113SAndy Fiddaman } 792678a2e113SAndy Fiddaman 792778a2e113SAndy Fiddaman mib2_socketInfoEntry_t sie = { 792878a2e113SAndy Fiddaman .sie_inode = psi->si_inode, 792978a2e113SAndy Fiddaman .sie_flags = 0 793078a2e113SAndy Fiddaman }; 793178a2e113SAndy Fiddaman 793278a2e113SAndy Fiddaman if (Xflag) 793378a2e113SAndy Fiddaman sie_report(&sie); 793478a2e113SAndy Fiddaman 793578a2e113SAndy Fiddaman for (ph = process_hash_get(&sie, 793678a2e113SAndy Fiddaman psi->si_serv_type == T_CLTS ? SOCK_DGRAM : SOCK_STREAM, AF_UNIX); 793778a2e113SAndy Fiddaman ph != NULL; ph = ph->ph_next_proc) { 793878a2e113SAndy Fiddaman if (Vflag) { 793978a2e113SAndy Fiddaman (void) printf( 794078a2e113SAndy Fiddaman UDS_ADDRESS_F " " UDS_TYPE_F " " 794178a2e113SAndy Fiddaman UDS_USER_F " " UDS_PID_F " " 794278a2e113SAndy Fiddaman UDS_LOCAL_F " " UDS_REMOTE_F " %s\n", 794378a2e113SAndy Fiddaman psi->si_son_straddr, 794478a2e113SAndy Fiddaman typetoname(psi->si_serv_type), 794578a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, 794678a2e113SAndy Fiddaman laddr, raddr, ph->ph_psargs); 794778a2e113SAndy Fiddaman } else { 794878a2e113SAndy Fiddaman (void) printf( 794978a2e113SAndy Fiddaman UDS_ADDRESS_F " " UDS_TYPE_F " " 795078a2e113SAndy Fiddaman UDS_USER_F " " UDS_PID_F " " UDS_COMMAND_F " " 795178a2e113SAndy Fiddaman UDS_LOCAL_F " " UDS_REMOTE_F "\n", 795278a2e113SAndy Fiddaman psi->si_son_straddr, 795378a2e113SAndy Fiddaman typetoname(psi->si_serv_type), 795478a2e113SAndy Fiddaman ph->ph_username, ph->ph_pidstr, ph->ph_fname, 795578a2e113SAndy Fiddaman laddr, raddr); 795678a2e113SAndy Fiddaman } 795778a2e113SAndy Fiddaman 795878a2e113SAndy Fiddaman } 795978a2e113SAndy Fiddaman 796078a2e113SAndy Fiddaman return (first); 796178a2e113SAndy Fiddaman } 796278a2e113SAndy Fiddaman 796378a2e113SAndy Fiddaman static char * 796478a2e113SAndy Fiddaman typetoname(t_scalar_t type) 796578a2e113SAndy Fiddaman { 796678a2e113SAndy Fiddaman switch (type) { 796778a2e113SAndy Fiddaman case T_CLTS: 796878a2e113SAndy Fiddaman return ("dgram"); 796978a2e113SAndy Fiddaman 797078a2e113SAndy Fiddaman case T_COTS: 797178a2e113SAndy Fiddaman return ("stream"); 797278a2e113SAndy Fiddaman 797378a2e113SAndy Fiddaman case T_COTS_ORD: 797478a2e113SAndy Fiddaman return ("stream-ord"); 797578a2e113SAndy Fiddaman 797678a2e113SAndy Fiddaman default: 797778a2e113SAndy Fiddaman return (""); 797878a2e113SAndy Fiddaman } 79797c478bd9Sstevel@tonic-gate } 7980