1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 1990 Mentat Inc. 24 * netstat.c 2.2, last change 9/9/91 25 * MROUTING Revision 3.5 26 * Copyright (c) 2017, Joyent, Inc. 27 */ 28 29 /* 30 * simple netstat based on snmp/mib-2 interface to the TCP/IP stack 31 * 32 * NOTES: 33 * 1. A comment "LINTED: (note 1)" appears before certain lines where 34 * lint would have complained, "pointer cast may result in improper 35 * alignment". These are lines where lint had suspected potential 36 * improper alignment of a data structure; in each such situation 37 * we have relied on the kernel guaranteeing proper alignment. 38 * 2. Some 'for' loops have been commented as "'for' loop 1", etc 39 * because they have 'continue' or 'break' statements in their 40 * bodies. 'continue' statements have been used inside some loops 41 * where avoiding them would have led to deep levels of indentation. 42 * 43 * TODO: 44 * Add ability to request subsets from kernel (with level = MIB2_IP; 45 * name = 0 meaning everything for compatibility) 46 */ 47 48 #include <stdio.h> 49 #include <stdlib.h> 50 #include <stdarg.h> 51 #include <unistd.h> 52 #include <strings.h> 53 #include <string.h> 54 #include <errno.h> 55 #include <ctype.h> 56 #include <kstat.h> 57 #include <assert.h> 58 #include <locale.h> 59 #include <synch.h> 60 #include <thread.h> 61 62 #include <sys/types.h> 63 #include <sys/stream.h> 64 #include <stropts.h> 65 #include <sys/strstat.h> 66 #include <sys/tihdr.h> 67 68 #include <sys/socket.h> 69 #include <sys/sockio.h> 70 #include <netinet/in.h> 71 #include <net/if.h> 72 #include <net/route.h> 73 74 #include <inet/mib2.h> 75 #include <inet/ip.h> 76 #include <inet/arp.h> 77 #include <inet/tcp.h> 78 #include <netinet/igmp_var.h> 79 #include <netinet/ip_mroute.h> 80 81 #include <arpa/inet.h> 82 #include <netdb.h> 83 #include <fcntl.h> 84 #include <sys/systeminfo.h> 85 #include <arpa/inet.h> 86 87 #include <netinet/dhcp.h> 88 #include <dhcpagent_ipc.h> 89 #include <dhcpagent_util.h> 90 #include <compat.h> 91 92 #include <libtsnet.h> 93 #include <tsol/label.h> 94 95 #include "statcommon.h" 96 97 extern void unixpr(kstat_ctl_t *kc); 98 99 #define STR_EXPAND 4 100 101 #define V4MASK_TO_V6(v4, v6) ((v6)._S6_un._S6_u32[0] = 0xfffffffful, \ 102 (v6)._S6_un._S6_u32[1] = 0xfffffffful, \ 103 (v6)._S6_un._S6_u32[2] = 0xfffffffful, \ 104 (v6)._S6_un._S6_u32[3] = (v4)) 105 106 #define IN6_IS_V4MASK(v6) ((v6)._S6_un._S6_u32[0] == 0xfffffffful && \ 107 (v6)._S6_un._S6_u32[1] == 0xfffffffful && \ 108 (v6)._S6_un._S6_u32[2] == 0xfffffffful) 109 110 /* 111 * This is used as a cushion in the buffer allocation directed by SIOCGLIFNUM. 112 * Because there's no locking between SIOCGLIFNUM and SIOCGLIFCONF, it's 113 * possible for an administrator to plumb new interfaces between those two 114 * calls, resulting in the failure of the latter. This addition makes that 115 * less likely. 116 */ 117 #define LIFN_GUARD_VALUE 10 118 119 typedef struct mib_item_s { 120 struct mib_item_s *next_item; 121 int group; 122 int mib_id; 123 int length; 124 void *valp; 125 } mib_item_t; 126 127 struct ifstat { 128 uint64_t ipackets; 129 uint64_t ierrors; 130 uint64_t opackets; 131 uint64_t oerrors; 132 uint64_t collisions; 133 }; 134 135 struct iflist { 136 struct iflist *next_if; 137 char ifname[LIFNAMSIZ]; 138 struct ifstat tot; 139 }; 140 141 static mib_item_t *mibget(int sd); 142 static void mibfree(mib_item_t *firstitem); 143 static int mibopen(void); 144 static void mib_get_constants(mib_item_t *item); 145 static mib_item_t *mib_item_dup(mib_item_t *item); 146 static mib_item_t *mib_item_diff(mib_item_t *item1, 147 mib_item_t *item2); 148 static void mib_item_destroy(mib_item_t **item); 149 150 static boolean_t octetstrmatch(const Octet_t *a, const Octet_t *b); 151 static char *octetstr(const Octet_t *op, int code, 152 char *dst, uint_t dstlen); 153 static char *pr_addr(uint_t addr, 154 char *dst, uint_t dstlen); 155 static char *pr_addrnz(ipaddr_t addr, char *dst, uint_t dstlen); 156 static char *pr_addr6(const in6_addr_t *addr, 157 char *dst, uint_t dstlen); 158 static char *pr_mask(uint_t addr, 159 char *dst, uint_t dstlen); 160 static char *pr_prefix6(const struct in6_addr *addr, 161 uint_t prefixlen, char *dst, uint_t dstlen); 162 static char *pr_ap(uint_t addr, uint_t port, 163 char *proto, char *dst, uint_t dstlen); 164 static char *pr_ap6(const in6_addr_t *addr, uint_t port, 165 char *proto, char *dst, uint_t dstlen); 166 static char *pr_net(uint_t addr, uint_t mask, 167 char *dst, uint_t dstlen); 168 static char *pr_netaddr(uint_t addr, uint_t mask, 169 char *dst, uint_t dstlen); 170 static char *fmodestr(uint_t fmode); 171 static char *portname(uint_t port, char *proto, 172 char *dst, uint_t dstlen); 173 174 static const char *mitcp_state(int code, 175 const mib2_transportMLPEntry_t *attr); 176 static const char *miudp_state(int code, 177 const mib2_transportMLPEntry_t *attr); 178 179 static void stat_report(mib_item_t *item); 180 static void mrt_stat_report(mib_item_t *item); 181 static void arp_report(mib_item_t *item); 182 static void ndp_report(mib_item_t *item); 183 static void mrt_report(mib_item_t *item); 184 static void if_stat_total(struct ifstat *oldstats, 185 struct ifstat *newstats, struct ifstat *sumstats); 186 static void if_report(mib_item_t *item, char *ifname, 187 int Iflag_only, boolean_t once_only); 188 static void if_report_ip4(mib2_ipAddrEntry_t *ap, 189 char ifname[], char logintname[], 190 struct ifstat *statptr, boolean_t ksp_not_null); 191 static void if_report_ip6(mib2_ipv6AddrEntry_t *ap6, 192 char ifname[], char logintname[], 193 struct ifstat *statptr, boolean_t ksp_not_null); 194 static void ire_report(const mib_item_t *item); 195 static void tcp_report(const mib_item_t *item); 196 static void udp_report(const mib_item_t *item); 197 static void group_report(mib_item_t *item); 198 static void dce_report(mib_item_t *item); 199 static void print_ip_stats(mib2_ip_t *ip); 200 static void print_icmp_stats(mib2_icmp_t *icmp); 201 static void print_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6); 202 static void print_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6); 203 static void print_sctp_stats(mib2_sctp_t *tcp); 204 static void print_tcp_stats(mib2_tcp_t *tcp); 205 static void print_udp_stats(mib2_udp_t *udp); 206 static void print_rawip_stats(mib2_rawip_t *rawip); 207 static void print_igmp_stats(struct igmpstat *igps); 208 static void print_mrt_stats(struct mrtstat *mrts); 209 static void sctp_report(const mib_item_t *item); 210 static void sum_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6, 211 mib2_ipv6IfStatsEntry_t *sum6); 212 static void sum_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6, 213 mib2_ipv6IfIcmpEntry_t *sum6); 214 static void m_report(void); 215 static void dhcp_report(char *); 216 217 static uint64_t kstat_named_value(kstat_t *, char *); 218 static kid_t safe_kstat_read(kstat_ctl_t *, kstat_t *, void *); 219 static int isnum(char *); 220 static char *plural(int n); 221 static char *pluraly(int n); 222 static char *plurales(int n); 223 static void process_filter(char *arg); 224 static char *ifindex2str(uint_t, char *); 225 static boolean_t family_selected(int family); 226 227 static void usage(char *); 228 static void fatal(int errcode, char *str1, ...); 229 230 #define PLURAL(n) plural((int)n) 231 #define PLURALY(n) pluraly((int)n) 232 #define PLURALES(n) plurales((int)n) 233 #define IFLAGMOD(flg, val1, val2) if (flg == val1) flg = val2 234 #define MDIFF(diff, elem2, elem1, member) (diff)->member = \ 235 (elem2)->member - (elem1)->member 236 237 238 static boolean_t Aflag = B_FALSE; /* All sockets/ifs/rtng-tbls */ 239 static boolean_t Dflag = B_FALSE; /* DCE info */ 240 static boolean_t Iflag = B_FALSE; /* IP Traffic Interfaces */ 241 static boolean_t Mflag = B_FALSE; /* STREAMS Memory Statistics */ 242 static boolean_t Nflag = B_FALSE; /* Numeric Network Addresses */ 243 static boolean_t Rflag = B_FALSE; /* Routing Tables */ 244 static boolean_t RSECflag = B_FALSE; /* Security attributes */ 245 static boolean_t Sflag = B_FALSE; /* Per-protocol Statistics */ 246 static boolean_t Vflag = B_FALSE; /* Verbose */ 247 static boolean_t Pflag = B_FALSE; /* Net to Media Tables */ 248 static boolean_t Gflag = B_FALSE; /* Multicast group membership */ 249 static boolean_t MMflag = B_FALSE; /* Multicast routing table */ 250 static boolean_t DHCPflag = B_FALSE; /* DHCP statistics */ 251 static boolean_t Xflag = B_FALSE; /* Debug Info */ 252 253 static int v4compat = 0; /* Compatible printing format for status */ 254 255 static int proto = IPPROTO_MAX; /* all protocols */ 256 kstat_ctl_t *kc = NULL; 257 258 /* 259 * Name service timeout detection constants. 260 */ 261 static mutex_t ns_lock = ERRORCHECKMUTEX; 262 static boolean_t ns_active = B_FALSE; /* Is a lookup ongoing? */ 263 static hrtime_t ns_starttime; /* Time the lookup started */ 264 static int ns_sleeptime = 2; /* Time in seconds between checks */ 265 static int ns_warntime = 2; /* Time in seconds before warning */ 266 267 /* 268 * Sizes of data structures extracted from the base mib. 269 * This allows the size of the tables entries to grow while preserving 270 * binary compatibility. 271 */ 272 static int ipAddrEntrySize; 273 static int ipRouteEntrySize; 274 static int ipNetToMediaEntrySize; 275 static int ipMemberEntrySize; 276 static int ipGroupSourceEntrySize; 277 static int ipRouteAttributeSize; 278 static int vifctlSize; 279 static int mfcctlSize; 280 281 static int ipv6IfStatsEntrySize; 282 static int ipv6IfIcmpEntrySize; 283 static int ipv6AddrEntrySize; 284 static int ipv6RouteEntrySize; 285 static int ipv6NetToMediaEntrySize; 286 static int ipv6MemberEntrySize; 287 static int ipv6GroupSourceEntrySize; 288 289 static int ipDestEntrySize; 290 291 static int transportMLPSize; 292 static int tcpConnEntrySize; 293 static int tcp6ConnEntrySize; 294 static int udpEntrySize; 295 static int udp6EntrySize; 296 static int sctpEntrySize; 297 static int sctpLocalEntrySize; 298 static int sctpRemoteEntrySize; 299 300 #define protocol_selected(p) (proto == IPPROTO_MAX || proto == (p)) 301 302 /* Machinery used for -f (filter) option */ 303 enum { FK_AF = 0, FK_OUTIF, FK_DST, FK_FLAGS, NFILTERKEYS }; 304 305 static const char *filter_keys[NFILTERKEYS] = { 306 "af", "outif", "dst", "flags" 307 }; 308 309 static m_label_t *zone_security_label = NULL; 310 311 /* Flags on routes */ 312 #define FLF_A 0x00000001 313 #define FLF_b 0x00000002 314 #define FLF_D 0x00000004 315 #define FLF_G 0x00000008 316 #define FLF_H 0x00000010 317 #define FLF_L 0x00000020 318 #define FLF_U 0x00000040 319 #define FLF_M 0x00000080 320 #define FLF_S 0x00000100 321 #define FLF_C 0x00000200 /* IRE_IF_CLONE */ 322 #define FLF_I 0x00000400 /* RTF_INDIRECT */ 323 #define FLF_R 0x00000800 /* RTF_REJECT */ 324 #define FLF_B 0x00001000 /* RTF_BLACKHOLE */ 325 #define FLF_Z 0x00100000 /* RTF_ZONE */ 326 327 static const char flag_list[] = "AbDGHLUMSCIRBZ"; 328 329 typedef struct filter_rule filter_t; 330 331 struct filter_rule { 332 filter_t *f_next; 333 union { 334 int f_family; 335 const char *f_ifname; 336 struct { 337 struct hostent *f_address; 338 in6_addr_t f_mask; 339 } a; 340 struct { 341 uint_t f_flagset; 342 uint_t f_flagclear; 343 } f; 344 } u; 345 }; 346 347 /* 348 * The user-specified filters are linked into lists separated by 349 * keyword (type of filter). Thus, the matching algorithm is: 350 * For each non-empty filter list 351 * If no filters in the list match 352 * then stop here; route doesn't match 353 * If loop above completes, then route does match and will be 354 * displayed. 355 */ 356 static filter_t *filters[NFILTERKEYS]; 357 358 static uint_t timestamp_fmt = NODATE; 359 360 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 361 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it isn't */ 362 #endif 363 364 static void 365 ns_lookup_start(void) 366 { 367 mutex_enter(&ns_lock); 368 ns_active = B_TRUE; 369 ns_starttime = gethrtime(); 370 mutex_exit(&ns_lock); 371 } 372 373 static void 374 ns_lookup_end(void) 375 { 376 mutex_enter(&ns_lock); 377 ns_active = B_FALSE; 378 mutex_exit(&ns_lock); 379 } 380 381 /* 382 * When name services are not functioning, this program appears to hang to the 383 * user. To try and give the user a chance of figuring out that this might be 384 * the case, we end up warning them and suggest that they may want to use the -n 385 * flag. 386 */ 387 /* ARGSUSED */ 388 static void * 389 ns_warning_thr(void *unsued) 390 { 391 for (;;) { 392 hrtime_t now; 393 394 (void) sleep(ns_sleeptime); 395 now = gethrtime(); 396 mutex_enter(&ns_lock); 397 if (ns_active && now - ns_starttime >= ns_warntime * NANOSEC) { 398 (void) fprintf(stderr, "warning: data " 399 "available, but name service lookups are " 400 "taking a while. Use the -n option to " 401 "disable name service lookups.\n"); 402 mutex_exit(&ns_lock); 403 return (NULL); 404 } 405 mutex_exit(&ns_lock); 406 } 407 408 /* LINTED: E_STMT_NOT_REACHED */ 409 return (NULL); 410 } 411 412 413 int 414 main(int argc, char **argv) 415 { 416 char *name; 417 mib_item_t *item = NULL; 418 mib_item_t *previtem = NULL; 419 int sd = -1; 420 char *ifname = NULL; 421 int interval = 0; /* Single time by default */ 422 int count = -1; /* Forever */ 423 int c; 424 int d; 425 /* 426 * Possible values of 'Iflag_only': 427 * -1, no feature-flags; 428 * 0, IFlag and other feature-flags enabled 429 * 1, IFlag is the only feature-flag enabled 430 * : trinary variable, modified using IFLAGMOD() 431 */ 432 int Iflag_only = -1; 433 boolean_t once_only = B_FALSE; /* '-i' with count > 1 */ 434 extern char *optarg; 435 extern int optind; 436 char *default_ip_str = NULL; 437 438 name = argv[0]; 439 440 v4compat = get_compat_flag(&default_ip_str); 441 if (v4compat == DEFAULT_PROT_BAD_VALUE) 442 fatal(2, "%s: %s: Bad value for %s in %s\n", name, 443 default_ip_str, DEFAULT_IP, INET_DEFAULT_FILE); 444 free(default_ip_str); 445 446 (void) setlocale(LC_ALL, ""); 447 (void) textdomain(TEXT_DOMAIN); 448 449 while ((c = getopt(argc, argv, "adimnrspMgvxf:P:I:DRT:")) != -1) { 450 switch ((char)c) { 451 case 'a': /* all connections */ 452 Aflag = B_TRUE; 453 break; 454 455 case 'd': /* DCE info */ 456 Dflag = B_TRUE; 457 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 458 break; 459 460 case 'i': /* interface (ill/ipif report) */ 461 Iflag = B_TRUE; 462 IFLAGMOD(Iflag_only, -1, 1); /* '-i' exists */ 463 break; 464 465 case 'm': /* streams msg report */ 466 Mflag = B_TRUE; 467 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 468 break; 469 470 case 'n': /* numeric format */ 471 Nflag = B_TRUE; 472 break; 473 474 case 'r': /* route tables */ 475 Rflag = B_TRUE; 476 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 477 break; 478 479 case 'R': /* security attributes */ 480 RSECflag = B_TRUE; 481 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 482 break; 483 484 case 's': /* per-protocol statistics */ 485 Sflag = B_TRUE; 486 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 487 break; 488 489 case 'p': /* arp/ndp table */ 490 Pflag = B_TRUE; 491 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 492 break; 493 494 case 'M': /* multicast routing tables */ 495 MMflag = B_TRUE; 496 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 497 break; 498 499 case 'g': /* multicast group membership */ 500 Gflag = B_TRUE; 501 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 502 break; 503 504 case 'v': /* verbose output format */ 505 Vflag = B_TRUE; 506 IFLAGMOD(Iflag_only, 1, 0); /* see macro def'n */ 507 break; 508 509 case 'x': /* turn on debugging */ 510 Xflag = B_TRUE; 511 break; 512 513 case 'f': 514 process_filter(optarg); 515 break; 516 517 case 'P': 518 if (strcmp(optarg, "ip") == 0) { 519 proto = IPPROTO_IP; 520 } else if (strcmp(optarg, "ipv6") == 0 || 521 strcmp(optarg, "ip6") == 0) { 522 v4compat = 0; /* Overridden */ 523 proto = IPPROTO_IPV6; 524 } else if (strcmp(optarg, "icmp") == 0) { 525 proto = IPPROTO_ICMP; 526 } else if (strcmp(optarg, "icmpv6") == 0 || 527 strcmp(optarg, "icmp6") == 0) { 528 v4compat = 0; /* Overridden */ 529 proto = IPPROTO_ICMPV6; 530 } else if (strcmp(optarg, "igmp") == 0) { 531 proto = IPPROTO_IGMP; 532 } else if (strcmp(optarg, "udp") == 0) { 533 proto = IPPROTO_UDP; 534 } else if (strcmp(optarg, "tcp") == 0) { 535 proto = IPPROTO_TCP; 536 } else if (strcmp(optarg, "sctp") == 0) { 537 proto = IPPROTO_SCTP; 538 } else if (strcmp(optarg, "raw") == 0 || 539 strcmp(optarg, "rawip") == 0) { 540 proto = IPPROTO_RAW; 541 } else { 542 fatal(1, "%s: unknown protocol.\n", optarg); 543 } 544 break; 545 546 case 'I': 547 ifname = optarg; 548 Iflag = B_TRUE; 549 IFLAGMOD(Iflag_only, -1, 1); /* see macro def'n */ 550 break; 551 552 case 'D': 553 DHCPflag = B_TRUE; 554 Iflag_only = 0; 555 break; 556 557 case 'T': 558 if (optarg) { 559 if (*optarg == 'u') 560 timestamp_fmt = UDATE; 561 else if (*optarg == 'd') 562 timestamp_fmt = DDATE; 563 else 564 usage(name); 565 } else { 566 usage(name); 567 } 568 break; 569 570 case '?': 571 default: 572 usage(name); 573 } 574 } 575 576 /* 577 * Make sure -R option is set only on a labeled system. 578 */ 579 if (RSECflag && !is_system_labeled()) { 580 (void) fprintf(stderr, "-R set but labeling is not enabled\n"); 581 usage(name); 582 } 583 584 /* 585 * Handle other arguments: find interval, count; the 586 * flags that accept 'interval' and 'count' are OR'd 587 * in the outermost 'if'; more flags may be added as 588 * required 589 */ 590 if (Iflag || Sflag || Mflag) { 591 for (d = optind; d < argc; d++) { 592 if (isnum(argv[d])) { 593 interval = atoi(argv[d]); 594 if (d + 1 < argc && 595 isnum(argv[d + 1])) { 596 count = atoi(argv[d + 1]); 597 optind++; 598 } 599 optind++; 600 if (interval == 0 || count == 0) 601 usage(name); 602 break; 603 } 604 } 605 } 606 if (optind < argc) { 607 if (Iflag && isnum(argv[optind])) { 608 count = atoi(argv[optind]); 609 if (count == 0) 610 usage(name); 611 optind++; 612 } 613 } 614 if (optind < argc) { 615 (void) fprintf(stderr, 616 "%s: extra arguments\n", name); 617 usage(name); 618 } 619 if (interval) 620 setbuf(stdout, NULL); 621 622 /* 623 * Start up the thread to check for name services warnings. 624 */ 625 if (thr_create(NULL, 0, ns_warning_thr, NULL, 626 THR_DETACHED | THR_DAEMON, NULL) != 0) { 627 fatal(1, "%s: failed to create name services " 628 "thread: %s\n", name, strerror(errno)); 629 } 630 631 if (DHCPflag) { 632 dhcp_report(Iflag ? ifname : NULL); 633 exit(0); 634 } 635 636 /* 637 * Get this process's security label if the -R switch is set. 638 * We use this label as the current zone's security label. 639 */ 640 if (RSECflag) { 641 zone_security_label = m_label_alloc(MAC_LABEL); 642 if (zone_security_label == NULL) 643 fatal(errno, "m_label_alloc() failed"); 644 if (getplabel(zone_security_label) < 0) 645 fatal(errno, "getplabel() failed"); 646 } 647 648 /* Get data structures: priming before iteration */ 649 if (family_selected(AF_INET) || family_selected(AF_INET6)) { 650 sd = mibopen(); 651 if (sd == -1) 652 fatal(1, "can't open mib stream\n"); 653 if ((item = mibget(sd)) == NULL) { 654 (void) close(sd); 655 fatal(1, "mibget() failed\n"); 656 } 657 /* Extract constant sizes - need do once only */ 658 mib_get_constants(item); 659 } 660 if ((kc = kstat_open()) == NULL) { 661 mibfree(item); 662 (void) close(sd); 663 fail(1, "kstat_open(): can't open /dev/kstat"); 664 } 665 666 if (interval <= 0) { 667 count = 1; 668 once_only = B_TRUE; 669 } 670 /* 'for' loop 1: */ 671 for (;;) { 672 mib_item_t *curritem = NULL; /* only for -[M]s */ 673 674 if (timestamp_fmt != NODATE) 675 print_timestamp(timestamp_fmt); 676 677 /* netstat: AF_INET[6] behaviour */ 678 if (family_selected(AF_INET) || family_selected(AF_INET6)) { 679 if (Sflag) { 680 curritem = mib_item_diff(previtem, item); 681 if (curritem == NULL) 682 fatal(1, "can't process mib data, " 683 "out of memory\n"); 684 mib_item_destroy(&previtem); 685 } 686 687 if (!(Dflag || Iflag || Rflag || Sflag || Mflag || 688 MMflag || Pflag || Gflag || DHCPflag)) { 689 if (protocol_selected(IPPROTO_UDP)) 690 udp_report(item); 691 if (protocol_selected(IPPROTO_TCP)) 692 tcp_report(item); 693 if (protocol_selected(IPPROTO_SCTP)) 694 sctp_report(item); 695 } 696 if (Iflag) 697 if_report(item, ifname, Iflag_only, once_only); 698 if (Mflag) 699 m_report(); 700 if (Rflag) 701 ire_report(item); 702 if (Sflag && MMflag) { 703 mrt_stat_report(curritem); 704 } else { 705 if (Sflag) 706 stat_report(curritem); 707 if (MMflag) 708 mrt_report(item); 709 } 710 if (Gflag) 711 group_report(item); 712 if (Pflag) { 713 if (family_selected(AF_INET)) 714 arp_report(item); 715 if (family_selected(AF_INET6)) 716 ndp_report(item); 717 } 718 if (Dflag) 719 dce_report(item); 720 mib_item_destroy(&curritem); 721 } 722 723 /* netstat: AF_UNIX behaviour */ 724 if (family_selected(AF_UNIX) && 725 (!(Dflag || Iflag || Rflag || Sflag || Mflag || 726 MMflag || Pflag || Gflag))) 727 unixpr(kc); 728 (void) kstat_close(kc); 729 730 /* iteration handling code */ 731 if (count > 0 && --count == 0) 732 break; 733 (void) sleep(interval); 734 735 /* re-populating of data structures */ 736 if (family_selected(AF_INET) || family_selected(AF_INET6)) { 737 if (Sflag) { 738 /* previtem is a cut-down list */ 739 previtem = mib_item_dup(item); 740 if (previtem == NULL) 741 fatal(1, "can't process mib data, " 742 "out of memory\n"); 743 } 744 mibfree(item); 745 (void) close(sd); 746 if ((sd = mibopen()) == -1) 747 fatal(1, "can't open mib stream anymore\n"); 748 if ((item = mibget(sd)) == NULL) { 749 (void) close(sd); 750 fatal(1, "mibget() failed\n"); 751 } 752 } 753 if ((kc = kstat_open()) == NULL) 754 fail(1, "kstat_open(): can't open /dev/kstat"); 755 756 } /* 'for' loop 1 ends */ 757 mibfree(item); 758 (void) close(sd); 759 if (zone_security_label != NULL) 760 m_label_free(zone_security_label); 761 762 return (0); 763 } 764 765 766 static int 767 isnum(char *p) 768 { 769 int len; 770 int i; 771 772 len = strlen(p); 773 for (i = 0; i < len; i++) 774 if (!isdigit(p[i])) 775 return (0); 776 return (1); 777 } 778 779 780 /* --------------------------------- MIBGET -------------------------------- */ 781 782 static mib_item_t * 783 mibget(int sd) 784 { 785 /* 786 * buf is an automatic for this function, so the 787 * compiler has complete control over its alignment; 788 * it is assumed this alignment is satisfactory for 789 * it to be casted to certain other struct pointers 790 * here, such as struct T_optmgmt_ack * . 791 */ 792 uintptr_t buf[512 / sizeof (uintptr_t)]; 793 int flags; 794 int i, j, getcode; 795 struct strbuf ctlbuf, databuf; 796 struct T_optmgmt_req *tor = (struct T_optmgmt_req *)buf; 797 struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *)buf; 798 struct T_error_ack *tea = (struct T_error_ack *)buf; 799 struct opthdr *req; 800 mib_item_t *first_item = NULL; 801 mib_item_t *last_item = NULL; 802 mib_item_t *temp; 803 804 tor->PRIM_type = T_SVR4_OPTMGMT_REQ; 805 tor->OPT_offset = sizeof (struct T_optmgmt_req); 806 tor->OPT_length = sizeof (struct opthdr); 807 tor->MGMT_flags = T_CURRENT; 808 809 810 /* 811 * Note: we use the special level value below so that IP will return 812 * us information concerning IRE_MARK_TESTHIDDEN routes. 813 */ 814 req = (struct opthdr *)&tor[1]; 815 req->level = EXPER_IP_AND_ALL_IRES; 816 req->name = 0; 817 req->len = 1; 818 819 ctlbuf.buf = (char *)buf; 820 ctlbuf.len = tor->OPT_length + tor->OPT_offset; 821 flags = 0; 822 if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) { 823 perror("mibget: putmsg(ctl) failed"); 824 goto error_exit; 825 } 826 827 /* 828 * Each reply consists of a ctl part for one fixed structure 829 * or table, as defined in mib2.h. The format is a T_OPTMGMT_ACK, 830 * containing an opthdr structure. level/name identify the entry, 831 * len is the size of the data part of the message. 832 */ 833 req = (struct opthdr *)&toa[1]; 834 ctlbuf.maxlen = sizeof (buf); 835 j = 1; 836 for (;;) { 837 flags = 0; 838 getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags); 839 if (getcode == -1) { 840 perror("mibget getmsg(ctl) failed"); 841 if (Xflag) { 842 (void) fputs("# level name len\n", 843 stderr); 844 i = 0; 845 for (last_item = first_item; last_item; 846 last_item = last_item->next_item) 847 (void) printf("%d %4d %5d %d\n", 848 ++i, 849 last_item->group, 850 last_item->mib_id, 851 last_item->length); 852 } 853 goto error_exit; 854 } 855 if (getcode == 0 && 856 ctlbuf.len >= sizeof (struct T_optmgmt_ack) && 857 toa->PRIM_type == T_OPTMGMT_ACK && 858 toa->MGMT_flags == T_SUCCESS && 859 req->len == 0) { 860 if (Xflag) 861 (void) printf("mibget getmsg() %d returned " 862 "EOD (level %ld, name %ld)\n", 863 j, req->level, req->name); 864 return (first_item); /* this is EOD msg */ 865 } 866 867 if (ctlbuf.len >= sizeof (struct T_error_ack) && 868 tea->PRIM_type == T_ERROR_ACK) { 869 (void) fprintf(stderr, 870 "mibget %d gives T_ERROR_ACK: TLI_error = 0x%lx, " 871 "UNIX_error = 0x%lx\n", 872 j, tea->TLI_error, tea->UNIX_error); 873 874 errno = (tea->TLI_error == TSYSERR) ? 875 tea->UNIX_error : EPROTO; 876 goto error_exit; 877 } 878 879 if (getcode != MOREDATA || 880 ctlbuf.len < sizeof (struct T_optmgmt_ack) || 881 toa->PRIM_type != T_OPTMGMT_ACK || 882 toa->MGMT_flags != T_SUCCESS) { 883 (void) printf("mibget getmsg(ctl) %d returned %d, " 884 "ctlbuf.len = %d, PRIM_type = %ld\n", 885 j, getcode, ctlbuf.len, toa->PRIM_type); 886 887 if (toa->PRIM_type == T_OPTMGMT_ACK) 888 (void) printf("T_OPTMGMT_ACK: " 889 "MGMT_flags = 0x%lx, req->len = %ld\n", 890 toa->MGMT_flags, req->len); 891 errno = ENOMSG; 892 goto error_exit; 893 } 894 895 temp = (mib_item_t *)malloc(sizeof (mib_item_t)); 896 if (temp == NULL) { 897 perror("mibget malloc failed"); 898 goto error_exit; 899 } 900 if (last_item != NULL) 901 last_item->next_item = temp; 902 else 903 first_item = temp; 904 last_item = temp; 905 last_item->next_item = NULL; 906 last_item->group = req->level; 907 last_item->mib_id = req->name; 908 last_item->length = req->len; 909 last_item->valp = malloc((int)req->len); 910 if (last_item->valp == NULL) 911 goto error_exit; 912 if (Xflag) 913 (void) printf("msg %d: group = %4d mib_id = %5d" 914 "length = %d\n", 915 j, last_item->group, last_item->mib_id, 916 last_item->length); 917 918 databuf.maxlen = last_item->length; 919 databuf.buf = (char *)last_item->valp; 920 databuf.len = 0; 921 flags = 0; 922 getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags); 923 if (getcode == -1) { 924 perror("mibget getmsg(data) failed"); 925 goto error_exit; 926 } else if (getcode != 0) { 927 (void) printf("mibget getmsg(data) returned %d, " 928 "databuf.maxlen = %d, databuf.len = %d\n", 929 getcode, databuf.maxlen, databuf.len); 930 goto error_exit; 931 } 932 j++; 933 } 934 /* NOTREACHED */ 935 936 error_exit:; 937 mibfree(first_item); 938 return (NULL); 939 } 940 941 /* 942 * mibfree: frees a linked list of type (mib_item_t *) 943 * returned by mibget(); this is NOT THE SAME AS 944 * mib_item_destroy(), so should be used for objects 945 * returned by mibget() only 946 */ 947 static void 948 mibfree(mib_item_t *firstitem) 949 { 950 mib_item_t *lastitem; 951 952 while (firstitem != NULL) { 953 lastitem = firstitem; 954 firstitem = firstitem->next_item; 955 if (lastitem->valp != NULL) 956 free(lastitem->valp); 957 free(lastitem); 958 } 959 } 960 961 static int 962 mibopen(void) 963 { 964 int sd; 965 966 sd = open("/dev/arp", O_RDWR); 967 if (sd == -1) { 968 perror("arp open"); 969 return (-1); 970 } 971 if (ioctl(sd, I_PUSH, "tcp") == -1) { 972 perror("tcp I_PUSH"); 973 (void) close(sd); 974 return (-1); 975 } 976 if (ioctl(sd, I_PUSH, "udp") == -1) { 977 perror("udp I_PUSH"); 978 (void) close(sd); 979 return (-1); 980 } 981 if (ioctl(sd, I_PUSH, "icmp") == -1) { 982 perror("icmp I_PUSH"); 983 (void) close(sd); 984 return (-1); 985 } 986 return (sd); 987 } 988 989 /* 990 * mib_item_dup: returns a clean mib_item_t * linked 991 * list, so that for every element item->mib_id is 0; 992 * to deallocate this linked list, use mib_item_destroy 993 */ 994 static mib_item_t * 995 mib_item_dup(mib_item_t *item) 996 { 997 int c = 0; 998 mib_item_t *localp; 999 mib_item_t *tempp; 1000 1001 for (tempp = item; tempp; tempp = tempp->next_item) 1002 if (tempp->mib_id == 0) 1003 c++; 1004 tempp = NULL; 1005 1006 localp = (mib_item_t *)malloc(c * sizeof (mib_item_t)); 1007 if (localp == NULL) 1008 return (NULL); 1009 c = 0; 1010 for (; item; item = item->next_item) { 1011 if (item->mib_id == 0) { 1012 /* Replicate item in localp */ 1013 (localp[c]).next_item = NULL; 1014 (localp[c]).group = item->group; 1015 (localp[c]).mib_id = item->mib_id; 1016 (localp[c]).length = item->length; 1017 (localp[c]).valp = (uintptr_t *)malloc( 1018 item->length); 1019 if ((localp[c]).valp == NULL) { 1020 mib_item_destroy(&localp); 1021 return (NULL); 1022 } 1023 (void *) memcpy((localp[c]).valp, 1024 item->valp, 1025 item->length); 1026 tempp = &(localp[c]); 1027 if (c > 0) 1028 (localp[c - 1]).next_item = tempp; 1029 c++; 1030 } 1031 } 1032 return (localp); 1033 } 1034 1035 /* 1036 * mib_item_diff: takes two (mib_item_t *) linked lists 1037 * item1 and item2 and computes the difference between 1038 * differentiable values in item2 against item1 for every 1039 * given member of item2; returns an mib_item_t * linked 1040 * list of diff's, or a copy of item2 if item1 is NULL; 1041 * will return NULL if system out of memory; works only 1042 * for item->mib_id == 0 1043 */ 1044 static mib_item_t * 1045 mib_item_diff(mib_item_t *item1, mib_item_t *item2) 1046 { 1047 int nitems = 0; /* no. of items in item2 */ 1048 mib_item_t *tempp2; /* walking copy of item2 */ 1049 mib_item_t *tempp1; /* walking copy of item1 */ 1050 mib_item_t *diffp; 1051 mib_item_t *diffptr; /* walking copy of diffp */ 1052 mib_item_t *prevp = NULL; 1053 1054 if (item1 == NULL) { 1055 diffp = mib_item_dup(item2); 1056 return (diffp); 1057 } 1058 1059 for (tempp2 = item2; 1060 tempp2; 1061 tempp2 = tempp2->next_item) { 1062 if (tempp2->mib_id == 0) 1063 switch (tempp2->group) { 1064 /* 1065 * upon adding a case here, the same 1066 * must also be added in the next 1067 * switch statement, alongwith 1068 * appropriate code 1069 */ 1070 case MIB2_IP: 1071 case MIB2_IP6: 1072 case EXPER_DVMRP: 1073 case EXPER_IGMP: 1074 case MIB2_ICMP: 1075 case MIB2_ICMP6: 1076 case MIB2_TCP: 1077 case MIB2_UDP: 1078 case MIB2_SCTP: 1079 case EXPER_RAWIP: 1080 nitems++; 1081 } 1082 } 1083 tempp2 = NULL; 1084 if (nitems == 0) { 1085 diffp = mib_item_dup(item2); 1086 return (diffp); 1087 } 1088 1089 diffp = (mib_item_t *)calloc(nitems, sizeof (mib_item_t)); 1090 if (diffp == NULL) 1091 return (NULL); 1092 diffptr = diffp; 1093 /* 'for' loop 1: */ 1094 for (tempp2 = item2; tempp2 != NULL; tempp2 = tempp2->next_item) { 1095 if (tempp2->mib_id != 0) 1096 continue; /* 'for' loop 1 */ 1097 /* 'for' loop 2: */ 1098 for (tempp1 = item1; tempp1 != NULL; 1099 tempp1 = tempp1->next_item) { 1100 if (!(tempp1->mib_id == 0 && 1101 tempp1->group == tempp2->group && 1102 tempp1->mib_id == tempp2->mib_id)) 1103 continue; /* 'for' loop 2 */ 1104 /* found comparable data sets */ 1105 if (prevp != NULL) 1106 prevp->next_item = diffptr; 1107 switch (tempp2->group) { 1108 /* 1109 * Indenting note: Because of long variable names 1110 * in cases MIB2_IP6 and MIB2_ICMP6, their contents 1111 * have been indented by one tab space only 1112 */ 1113 case MIB2_IP: { 1114 mib2_ip_t *i2 = (mib2_ip_t *)tempp2->valp; 1115 mib2_ip_t *i1 = (mib2_ip_t *)tempp1->valp; 1116 mib2_ip_t *d; 1117 1118 diffptr->group = tempp2->group; 1119 diffptr->mib_id = tempp2->mib_id; 1120 diffptr->length = tempp2->length; 1121 d = (mib2_ip_t *)calloc(tempp2->length, 1); 1122 if (d == NULL) 1123 goto mibdiff_out_of_memory; 1124 diffptr->valp = d; 1125 d->ipForwarding = i2->ipForwarding; 1126 d->ipDefaultTTL = i2->ipDefaultTTL; 1127 MDIFF(d, i2, i1, ipInReceives); 1128 MDIFF(d, i2, i1, ipInHdrErrors); 1129 MDIFF(d, i2, i1, ipInAddrErrors); 1130 MDIFF(d, i2, i1, ipInCksumErrs); 1131 MDIFF(d, i2, i1, ipForwDatagrams); 1132 MDIFF(d, i2, i1, ipForwProhibits); 1133 MDIFF(d, i2, i1, ipInUnknownProtos); 1134 MDIFF(d, i2, i1, ipInDiscards); 1135 MDIFF(d, i2, i1, ipInDelivers); 1136 MDIFF(d, i2, i1, ipOutRequests); 1137 MDIFF(d, i2, i1, ipOutDiscards); 1138 MDIFF(d, i2, i1, ipOutNoRoutes); 1139 MDIFF(d, i2, i1, ipReasmTimeout); 1140 MDIFF(d, i2, i1, ipReasmReqds); 1141 MDIFF(d, i2, i1, ipReasmOKs); 1142 MDIFF(d, i2, i1, ipReasmFails); 1143 MDIFF(d, i2, i1, ipReasmDuplicates); 1144 MDIFF(d, i2, i1, ipReasmPartDups); 1145 MDIFF(d, i2, i1, ipFragOKs); 1146 MDIFF(d, i2, i1, ipFragFails); 1147 MDIFF(d, i2, i1, ipFragCreates); 1148 MDIFF(d, i2, i1, ipRoutingDiscards); 1149 MDIFF(d, i2, i1, tcpInErrs); 1150 MDIFF(d, i2, i1, udpNoPorts); 1151 MDIFF(d, i2, i1, udpInCksumErrs); 1152 MDIFF(d, i2, i1, udpInOverflows); 1153 MDIFF(d, i2, i1, rawipInOverflows); 1154 MDIFF(d, i2, i1, ipsecInSucceeded); 1155 MDIFF(d, i2, i1, ipsecInFailed); 1156 MDIFF(d, i2, i1, ipInIPv6); 1157 MDIFF(d, i2, i1, ipOutIPv6); 1158 MDIFF(d, i2, i1, ipOutSwitchIPv6); 1159 prevp = diffptr++; 1160 break; 1161 } 1162 case MIB2_IP6: { 1163 mib2_ipv6IfStatsEntry_t *i2; 1164 mib2_ipv6IfStatsEntry_t *i1; 1165 mib2_ipv6IfStatsEntry_t *d; 1166 1167 i2 = (mib2_ipv6IfStatsEntry_t *)tempp2->valp; 1168 i1 = (mib2_ipv6IfStatsEntry_t *)tempp1->valp; 1169 diffptr->group = tempp2->group; 1170 diffptr->mib_id = tempp2->mib_id; 1171 diffptr->length = tempp2->length; 1172 d = (mib2_ipv6IfStatsEntry_t *)calloc( 1173 tempp2->length, 1); 1174 if (d == NULL) 1175 goto mibdiff_out_of_memory; 1176 diffptr->valp = d; 1177 d->ipv6Forwarding = i2->ipv6Forwarding; 1178 d->ipv6DefaultHopLimit = 1179 i2->ipv6DefaultHopLimit; 1180 1181 MDIFF(d, i2, i1, ipv6InReceives); 1182 MDIFF(d, i2, i1, ipv6InHdrErrors); 1183 MDIFF(d, i2, i1, ipv6InTooBigErrors); 1184 MDIFF(d, i2, i1, ipv6InNoRoutes); 1185 MDIFF(d, i2, i1, ipv6InAddrErrors); 1186 MDIFF(d, i2, i1, ipv6InUnknownProtos); 1187 MDIFF(d, i2, i1, ipv6InTruncatedPkts); 1188 MDIFF(d, i2, i1, ipv6InDiscards); 1189 MDIFF(d, i2, i1, ipv6InDelivers); 1190 MDIFF(d, i2, i1, ipv6OutForwDatagrams); 1191 MDIFF(d, i2, i1, ipv6OutRequests); 1192 MDIFF(d, i2, i1, ipv6OutDiscards); 1193 MDIFF(d, i2, i1, ipv6OutNoRoutes); 1194 MDIFF(d, i2, i1, ipv6OutFragOKs); 1195 MDIFF(d, i2, i1, ipv6OutFragFails); 1196 MDIFF(d, i2, i1, ipv6OutFragCreates); 1197 MDIFF(d, i2, i1, ipv6ReasmReqds); 1198 MDIFF(d, i2, i1, ipv6ReasmOKs); 1199 MDIFF(d, i2, i1, ipv6ReasmFails); 1200 MDIFF(d, i2, i1, ipv6InMcastPkts); 1201 MDIFF(d, i2, i1, ipv6OutMcastPkts); 1202 MDIFF(d, i2, i1, ipv6ReasmDuplicates); 1203 MDIFF(d, i2, i1, ipv6ReasmPartDups); 1204 MDIFF(d, i2, i1, ipv6ForwProhibits); 1205 MDIFF(d, i2, i1, udpInCksumErrs); 1206 MDIFF(d, i2, i1, udpInOverflows); 1207 MDIFF(d, i2, i1, rawipInOverflows); 1208 MDIFF(d, i2, i1, ipv6InIPv4); 1209 MDIFF(d, i2, i1, ipv6OutIPv4); 1210 MDIFF(d, i2, i1, ipv6OutSwitchIPv4); 1211 prevp = diffptr++; 1212 break; 1213 } 1214 case EXPER_DVMRP: { 1215 struct mrtstat *m2; 1216 struct mrtstat *m1; 1217 struct mrtstat *d; 1218 1219 m2 = (struct mrtstat *)tempp2->valp; 1220 m1 = (struct mrtstat *)tempp1->valp; 1221 diffptr->group = tempp2->group; 1222 diffptr->mib_id = tempp2->mib_id; 1223 diffptr->length = tempp2->length; 1224 d = (struct mrtstat *)calloc(tempp2->length, 1); 1225 if (d == NULL) 1226 goto mibdiff_out_of_memory; 1227 diffptr->valp = d; 1228 MDIFF(d, m2, m1, mrts_mfc_hits); 1229 MDIFF(d, m2, m1, mrts_mfc_misses); 1230 MDIFF(d, m2, m1, mrts_fwd_in); 1231 MDIFF(d, m2, m1, mrts_fwd_out); 1232 d->mrts_upcalls = m2->mrts_upcalls; 1233 MDIFF(d, m2, m1, mrts_fwd_drop); 1234 MDIFF(d, m2, m1, mrts_bad_tunnel); 1235 MDIFF(d, m2, m1, mrts_cant_tunnel); 1236 MDIFF(d, m2, m1, mrts_wrong_if); 1237 MDIFF(d, m2, m1, mrts_upq_ovflw); 1238 MDIFF(d, m2, m1, mrts_cache_cleanups); 1239 MDIFF(d, m2, m1, mrts_drop_sel); 1240 MDIFF(d, m2, m1, mrts_q_overflow); 1241 MDIFF(d, m2, m1, mrts_pkt2large); 1242 MDIFF(d, m2, m1, mrts_pim_badversion); 1243 MDIFF(d, m2, m1, mrts_pim_rcv_badcsum); 1244 MDIFF(d, m2, m1, mrts_pim_badregisters); 1245 MDIFF(d, m2, m1, mrts_pim_regforwards); 1246 MDIFF(d, m2, m1, mrts_pim_regsend_drops); 1247 MDIFF(d, m2, m1, mrts_pim_malformed); 1248 MDIFF(d, m2, m1, mrts_pim_nomemory); 1249 prevp = diffptr++; 1250 break; 1251 } 1252 case EXPER_IGMP: { 1253 struct igmpstat *i2; 1254 struct igmpstat *i1; 1255 struct igmpstat *d; 1256 1257 i2 = (struct igmpstat *)tempp2->valp; 1258 i1 = (struct igmpstat *)tempp1->valp; 1259 diffptr->group = tempp2->group; 1260 diffptr->mib_id = tempp2->mib_id; 1261 diffptr->length = tempp2->length; 1262 d = (struct igmpstat *)calloc( 1263 tempp2->length, 1); 1264 if (d == NULL) 1265 goto mibdiff_out_of_memory; 1266 diffptr->valp = d; 1267 MDIFF(d, i2, i1, igps_rcv_total); 1268 MDIFF(d, i2, i1, igps_rcv_tooshort); 1269 MDIFF(d, i2, i1, igps_rcv_badsum); 1270 MDIFF(d, i2, i1, igps_rcv_queries); 1271 MDIFF(d, i2, i1, igps_rcv_badqueries); 1272 MDIFF(d, i2, i1, igps_rcv_reports); 1273 MDIFF(d, i2, i1, igps_rcv_badreports); 1274 MDIFF(d, i2, i1, igps_rcv_ourreports); 1275 MDIFF(d, i2, i1, igps_snd_reports); 1276 prevp = diffptr++; 1277 break; 1278 } 1279 case MIB2_ICMP: { 1280 mib2_icmp_t *i2; 1281 mib2_icmp_t *i1; 1282 mib2_icmp_t *d; 1283 1284 i2 = (mib2_icmp_t *)tempp2->valp; 1285 i1 = (mib2_icmp_t *)tempp1->valp; 1286 diffptr->group = tempp2->group; 1287 diffptr->mib_id = tempp2->mib_id; 1288 diffptr->length = tempp2->length; 1289 d = (mib2_icmp_t *)calloc(tempp2->length, 1); 1290 if (d == NULL) 1291 goto mibdiff_out_of_memory; 1292 diffptr->valp = d; 1293 MDIFF(d, i2, i1, icmpInMsgs); 1294 MDIFF(d, i2, i1, icmpInErrors); 1295 MDIFF(d, i2, i1, icmpInCksumErrs); 1296 MDIFF(d, i2, i1, icmpInUnknowns); 1297 MDIFF(d, i2, i1, icmpInDestUnreachs); 1298 MDIFF(d, i2, i1, icmpInTimeExcds); 1299 MDIFF(d, i2, i1, icmpInParmProbs); 1300 MDIFF(d, i2, i1, icmpInSrcQuenchs); 1301 MDIFF(d, i2, i1, icmpInRedirects); 1302 MDIFF(d, i2, i1, icmpInBadRedirects); 1303 MDIFF(d, i2, i1, icmpInEchos); 1304 MDIFF(d, i2, i1, icmpInEchoReps); 1305 MDIFF(d, i2, i1, icmpInTimestamps); 1306 MDIFF(d, i2, i1, icmpInAddrMasks); 1307 MDIFF(d, i2, i1, icmpInAddrMaskReps); 1308 MDIFF(d, i2, i1, icmpInFragNeeded); 1309 MDIFF(d, i2, i1, icmpOutMsgs); 1310 MDIFF(d, i2, i1, icmpOutDrops); 1311 MDIFF(d, i2, i1, icmpOutErrors); 1312 MDIFF(d, i2, i1, icmpOutDestUnreachs); 1313 MDIFF(d, i2, i1, icmpOutTimeExcds); 1314 MDIFF(d, i2, i1, icmpOutParmProbs); 1315 MDIFF(d, i2, i1, icmpOutSrcQuenchs); 1316 MDIFF(d, i2, i1, icmpOutRedirects); 1317 MDIFF(d, i2, i1, icmpOutEchos); 1318 MDIFF(d, i2, i1, icmpOutEchoReps); 1319 MDIFF(d, i2, i1, icmpOutTimestamps); 1320 MDIFF(d, i2, i1, icmpOutTimestampReps); 1321 MDIFF(d, i2, i1, icmpOutAddrMasks); 1322 MDIFF(d, i2, i1, icmpOutAddrMaskReps); 1323 MDIFF(d, i2, i1, icmpOutFragNeeded); 1324 MDIFF(d, i2, i1, icmpInOverflows); 1325 prevp = diffptr++; 1326 break; 1327 } 1328 case MIB2_ICMP6: { 1329 mib2_ipv6IfIcmpEntry_t *i2; 1330 mib2_ipv6IfIcmpEntry_t *i1; 1331 mib2_ipv6IfIcmpEntry_t *d; 1332 1333 i2 = (mib2_ipv6IfIcmpEntry_t *)tempp2->valp; 1334 i1 = (mib2_ipv6IfIcmpEntry_t *)tempp1->valp; 1335 diffptr->group = tempp2->group; 1336 diffptr->mib_id = tempp2->mib_id; 1337 diffptr->length = tempp2->length; 1338 d = (mib2_ipv6IfIcmpEntry_t *)calloc(tempp2->length, 1); 1339 if (d == NULL) 1340 goto mibdiff_out_of_memory; 1341 diffptr->valp = d; 1342 MDIFF(d, i2, i1, ipv6IfIcmpInMsgs); 1343 MDIFF(d, i2, i1, ipv6IfIcmpInErrors); 1344 MDIFF(d, i2, i1, ipv6IfIcmpInDestUnreachs); 1345 MDIFF(d, i2, i1, ipv6IfIcmpInAdminProhibs); 1346 MDIFF(d, i2, i1, ipv6IfIcmpInTimeExcds); 1347 MDIFF(d, i2, i1, ipv6IfIcmpInParmProblems); 1348 MDIFF(d, i2, i1, ipv6IfIcmpInPktTooBigs); 1349 MDIFF(d, i2, i1, ipv6IfIcmpInEchos); 1350 MDIFF(d, i2, i1, ipv6IfIcmpInEchoReplies); 1351 MDIFF(d, i2, i1, ipv6IfIcmpInRouterSolicits); 1352 MDIFF(d, i2, i1, ipv6IfIcmpInRouterAdvertisements); 1353 MDIFF(d, i2, i1, ipv6IfIcmpInNeighborSolicits); 1354 MDIFF(d, i2, i1, ipv6IfIcmpInNeighborAdvertisements); 1355 MDIFF(d, i2, i1, ipv6IfIcmpInRedirects); 1356 MDIFF(d, i2, i1, ipv6IfIcmpInBadRedirects); 1357 MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembQueries); 1358 MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembResponses); 1359 MDIFF(d, i2, i1, ipv6IfIcmpInGroupMembReductions); 1360 MDIFF(d, i2, i1, ipv6IfIcmpInOverflows); 1361 MDIFF(d, i2, i1, ipv6IfIcmpOutMsgs); 1362 MDIFF(d, i2, i1, ipv6IfIcmpOutErrors); 1363 MDIFF(d, i2, i1, ipv6IfIcmpOutDestUnreachs); 1364 MDIFF(d, i2, i1, ipv6IfIcmpOutAdminProhibs); 1365 MDIFF(d, i2, i1, ipv6IfIcmpOutTimeExcds); 1366 MDIFF(d, i2, i1, ipv6IfIcmpOutParmProblems); 1367 MDIFF(d, i2, i1, ipv6IfIcmpOutPktTooBigs); 1368 MDIFF(d, i2, i1, ipv6IfIcmpOutEchos); 1369 MDIFF(d, i2, i1, ipv6IfIcmpOutEchoReplies); 1370 MDIFF(d, i2, i1, ipv6IfIcmpOutRouterSolicits); 1371 MDIFF(d, i2, i1, ipv6IfIcmpOutRouterAdvertisements); 1372 MDIFF(d, i2, i1, ipv6IfIcmpOutNeighborSolicits); 1373 MDIFF(d, i2, i1, ipv6IfIcmpOutNeighborAdvertisements); 1374 MDIFF(d, i2, i1, ipv6IfIcmpOutRedirects); 1375 MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembQueries); 1376 MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembResponses); 1377 MDIFF(d, i2, i1, ipv6IfIcmpOutGroupMembReductions); 1378 prevp = diffptr++; 1379 break; 1380 } 1381 case MIB2_TCP: { 1382 mib2_tcp_t *t2; 1383 mib2_tcp_t *t1; 1384 mib2_tcp_t *d; 1385 1386 t2 = (mib2_tcp_t *)tempp2->valp; 1387 t1 = (mib2_tcp_t *)tempp1->valp; 1388 diffptr->group = tempp2->group; 1389 diffptr->mib_id = tempp2->mib_id; 1390 diffptr->length = tempp2->length; 1391 d = (mib2_tcp_t *)calloc(tempp2->length, 1); 1392 if (d == NULL) 1393 goto mibdiff_out_of_memory; 1394 diffptr->valp = d; 1395 d->tcpRtoMin = t2->tcpRtoMin; 1396 d->tcpRtoMax = t2->tcpRtoMax; 1397 d->tcpMaxConn = t2->tcpMaxConn; 1398 MDIFF(d, t2, t1, tcpActiveOpens); 1399 MDIFF(d, t2, t1, tcpPassiveOpens); 1400 MDIFF(d, t2, t1, tcpAttemptFails); 1401 MDIFF(d, t2, t1, tcpEstabResets); 1402 d->tcpCurrEstab = t2->tcpCurrEstab; 1403 MDIFF(d, t2, t1, tcpHCOutSegs); 1404 MDIFF(d, t2, t1, tcpOutDataSegs); 1405 MDIFF(d, t2, t1, tcpOutDataBytes); 1406 MDIFF(d, t2, t1, tcpRetransSegs); 1407 MDIFF(d, t2, t1, tcpRetransBytes); 1408 MDIFF(d, t2, t1, tcpOutAck); 1409 MDIFF(d, t2, t1, tcpOutAckDelayed); 1410 MDIFF(d, t2, t1, tcpOutUrg); 1411 MDIFF(d, t2, t1, tcpOutWinUpdate); 1412 MDIFF(d, t2, t1, tcpOutWinProbe); 1413 MDIFF(d, t2, t1, tcpOutControl); 1414 MDIFF(d, t2, t1, tcpOutRsts); 1415 MDIFF(d, t2, t1, tcpOutFastRetrans); 1416 MDIFF(d, t2, t1, tcpHCInSegs); 1417 MDIFF(d, t2, t1, tcpInAckSegs); 1418 MDIFF(d, t2, t1, tcpInAckBytes); 1419 MDIFF(d, t2, t1, tcpInDupAck); 1420 MDIFF(d, t2, t1, tcpInAckUnsent); 1421 MDIFF(d, t2, t1, tcpInDataInorderSegs); 1422 MDIFF(d, t2, t1, tcpInDataInorderBytes); 1423 MDIFF(d, t2, t1, tcpInDataUnorderSegs); 1424 MDIFF(d, t2, t1, tcpInDataUnorderBytes); 1425 MDIFF(d, t2, t1, tcpInDataDupSegs); 1426 MDIFF(d, t2, t1, tcpInDataDupBytes); 1427 MDIFF(d, t2, t1, tcpInDataPartDupSegs); 1428 MDIFF(d, t2, t1, tcpInDataPartDupBytes); 1429 MDIFF(d, t2, t1, tcpInDataPastWinSegs); 1430 MDIFF(d, t2, t1, tcpInDataPastWinBytes); 1431 MDIFF(d, t2, t1, tcpInWinProbe); 1432 MDIFF(d, t2, t1, tcpInWinUpdate); 1433 MDIFF(d, t2, t1, tcpInClosed); 1434 MDIFF(d, t2, t1, tcpRttNoUpdate); 1435 MDIFF(d, t2, t1, tcpRttUpdate); 1436 MDIFF(d, t2, t1, tcpTimRetrans); 1437 MDIFF(d, t2, t1, tcpTimRetransDrop); 1438 MDIFF(d, t2, t1, tcpTimKeepalive); 1439 MDIFF(d, t2, t1, tcpTimKeepaliveProbe); 1440 MDIFF(d, t2, t1, tcpTimKeepaliveDrop); 1441 MDIFF(d, t2, t1, tcpListenDrop); 1442 MDIFF(d, t2, t1, tcpListenDropQ0); 1443 MDIFF(d, t2, t1, tcpHalfOpenDrop); 1444 MDIFF(d, t2, t1, tcpOutSackRetransSegs); 1445 prevp = diffptr++; 1446 break; 1447 } 1448 case MIB2_UDP: { 1449 mib2_udp_t *u2; 1450 mib2_udp_t *u1; 1451 mib2_udp_t *d; 1452 1453 u2 = (mib2_udp_t *)tempp2->valp; 1454 u1 = (mib2_udp_t *)tempp1->valp; 1455 diffptr->group = tempp2->group; 1456 diffptr->mib_id = tempp2->mib_id; 1457 diffptr->length = tempp2->length; 1458 d = (mib2_udp_t *)calloc(tempp2->length, 1); 1459 if (d == NULL) 1460 goto mibdiff_out_of_memory; 1461 diffptr->valp = d; 1462 MDIFF(d, u2, u1, udpHCInDatagrams); 1463 MDIFF(d, u2, u1, udpInErrors); 1464 MDIFF(d, u2, u1, udpHCOutDatagrams); 1465 MDIFF(d, u2, u1, udpOutErrors); 1466 prevp = diffptr++; 1467 break; 1468 } 1469 case MIB2_SCTP: { 1470 mib2_sctp_t *s2; 1471 mib2_sctp_t *s1; 1472 mib2_sctp_t *d; 1473 1474 s2 = (mib2_sctp_t *)tempp2->valp; 1475 s1 = (mib2_sctp_t *)tempp1->valp; 1476 diffptr->group = tempp2->group; 1477 diffptr->mib_id = tempp2->mib_id; 1478 diffptr->length = tempp2->length; 1479 d = (mib2_sctp_t *)calloc(tempp2->length, 1); 1480 if (d == NULL) 1481 goto mibdiff_out_of_memory; 1482 diffptr->valp = d; 1483 d->sctpRtoAlgorithm = s2->sctpRtoAlgorithm; 1484 d->sctpRtoMin = s2->sctpRtoMin; 1485 d->sctpRtoMax = s2->sctpRtoMax; 1486 d->sctpRtoInitial = s2->sctpRtoInitial; 1487 d->sctpMaxAssocs = s2->sctpMaxAssocs; 1488 d->sctpValCookieLife = s2->sctpValCookieLife; 1489 d->sctpMaxInitRetr = s2->sctpMaxInitRetr; 1490 d->sctpCurrEstab = s2->sctpCurrEstab; 1491 MDIFF(d, s2, s1, sctpActiveEstab); 1492 MDIFF(d, s2, s1, sctpPassiveEstab); 1493 MDIFF(d, s2, s1, sctpAborted); 1494 MDIFF(d, s2, s1, sctpShutdowns); 1495 MDIFF(d, s2, s1, sctpOutOfBlue); 1496 MDIFF(d, s2, s1, sctpChecksumError); 1497 MDIFF(d, s2, s1, sctpOutCtrlChunks); 1498 MDIFF(d, s2, s1, sctpOutOrderChunks); 1499 MDIFF(d, s2, s1, sctpOutUnorderChunks); 1500 MDIFF(d, s2, s1, sctpRetransChunks); 1501 MDIFF(d, s2, s1, sctpOutAck); 1502 MDIFF(d, s2, s1, sctpOutAckDelayed); 1503 MDIFF(d, s2, s1, sctpOutWinUpdate); 1504 MDIFF(d, s2, s1, sctpOutFastRetrans); 1505 MDIFF(d, s2, s1, sctpOutWinProbe); 1506 MDIFF(d, s2, s1, sctpInCtrlChunks); 1507 MDIFF(d, s2, s1, sctpInOrderChunks); 1508 MDIFF(d, s2, s1, sctpInUnorderChunks); 1509 MDIFF(d, s2, s1, sctpInAck); 1510 MDIFF(d, s2, s1, sctpInDupAck); 1511 MDIFF(d, s2, s1, sctpInAckUnsent); 1512 MDIFF(d, s2, s1, sctpFragUsrMsgs); 1513 MDIFF(d, s2, s1, sctpReasmUsrMsgs); 1514 MDIFF(d, s2, s1, sctpOutSCTPPkts); 1515 MDIFF(d, s2, s1, sctpInSCTPPkts); 1516 MDIFF(d, s2, s1, sctpInInvalidCookie); 1517 MDIFF(d, s2, s1, sctpTimRetrans); 1518 MDIFF(d, s2, s1, sctpTimRetransDrop); 1519 MDIFF(d, s2, s1, sctpTimHeartBeatProbe); 1520 MDIFF(d, s2, s1, sctpTimHeartBeatDrop); 1521 MDIFF(d, s2, s1, sctpListenDrop); 1522 MDIFF(d, s2, s1, sctpInClosed); 1523 prevp = diffptr++; 1524 break; 1525 } 1526 case EXPER_RAWIP: { 1527 mib2_rawip_t *r2; 1528 mib2_rawip_t *r1; 1529 mib2_rawip_t *d; 1530 1531 r2 = (mib2_rawip_t *)tempp2->valp; 1532 r1 = (mib2_rawip_t *)tempp1->valp; 1533 diffptr->group = tempp2->group; 1534 diffptr->mib_id = tempp2->mib_id; 1535 diffptr->length = tempp2->length; 1536 d = (mib2_rawip_t *)calloc(tempp2->length, 1); 1537 if (d == NULL) 1538 goto mibdiff_out_of_memory; 1539 diffptr->valp = d; 1540 MDIFF(d, r2, r1, rawipInDatagrams); 1541 MDIFF(d, r2, r1, rawipInErrors); 1542 MDIFF(d, r2, r1, rawipInCksumErrs); 1543 MDIFF(d, r2, r1, rawipOutDatagrams); 1544 MDIFF(d, r2, r1, rawipOutErrors); 1545 prevp = diffptr++; 1546 break; 1547 } 1548 /* 1549 * there are more "group" types but they aren't 1550 * required for the -s and -Ms options 1551 */ 1552 } 1553 } /* 'for' loop 2 ends */ 1554 tempp1 = NULL; 1555 } /* 'for' loop 1 ends */ 1556 tempp2 = NULL; 1557 diffptr--; 1558 diffptr->next_item = NULL; 1559 return (diffp); 1560 1561 mibdiff_out_of_memory:; 1562 mib_item_destroy(&diffp); 1563 return (NULL); 1564 } 1565 1566 /* 1567 * mib_item_destroy: cleans up a mib_item_t * 1568 * that was created by calling mib_item_dup or 1569 * mib_item_diff 1570 */ 1571 static void 1572 mib_item_destroy(mib_item_t **itemp) 1573 { 1574 int nitems = 0; 1575 int c = 0; 1576 mib_item_t *tempp; 1577 1578 if (itemp == NULL || *itemp == NULL) 1579 return; 1580 1581 for (tempp = *itemp; tempp != NULL; tempp = tempp->next_item) 1582 if (tempp->mib_id == 0) 1583 nitems++; 1584 else 1585 return; /* cannot destroy! */ 1586 1587 if (nitems == 0) 1588 return; /* cannot destroy! */ 1589 1590 for (c = nitems - 1; c >= 0; c--) { 1591 if ((itemp[0][c]).valp != NULL) 1592 free((itemp[0][c]).valp); 1593 } 1594 free(*itemp); 1595 1596 *itemp = NULL; 1597 } 1598 1599 /* Compare two Octet_ts. Return B_TRUE if they match, B_FALSE if not. */ 1600 static boolean_t 1601 octetstrmatch(const Octet_t *a, const Octet_t *b) 1602 { 1603 if (a == NULL || b == NULL) 1604 return (B_FALSE); 1605 1606 if (a->o_length != b->o_length) 1607 return (B_FALSE); 1608 1609 return (memcmp(a->o_bytes, b->o_bytes, a->o_length) == 0); 1610 } 1611 1612 /* If octetstr() changes make an appropriate change to STR_EXPAND */ 1613 static char * 1614 octetstr(const Octet_t *op, int code, char *dst, uint_t dstlen) 1615 { 1616 int i; 1617 char *cp; 1618 1619 cp = dst; 1620 if (op) { 1621 for (i = 0; i < op->o_length; i++) { 1622 switch (code) { 1623 case 'd': 1624 if (cp - dst + 4 > dstlen) { 1625 *cp = '\0'; 1626 return (dst); 1627 } 1628 (void) snprintf(cp, 5, "%d.", 1629 0xff & op->o_bytes[i]); 1630 cp = strchr(cp, '\0'); 1631 break; 1632 case 'a': 1633 if (cp - dst + 1 > dstlen) { 1634 *cp = '\0'; 1635 return (dst); 1636 } 1637 *cp++ = op->o_bytes[i]; 1638 break; 1639 case 'h': 1640 default: 1641 if (cp - dst + 3 > dstlen) { 1642 *cp = '\0'; 1643 return (dst); 1644 } 1645 (void) snprintf(cp, 4, "%02x:", 1646 0xff & op->o_bytes[i]); 1647 cp += 3; 1648 break; 1649 } 1650 } 1651 } 1652 if (code != 'a' && cp != dst) 1653 cp--; 1654 *cp = '\0'; 1655 return (dst); 1656 } 1657 1658 static const char * 1659 mitcp_state(int state, const mib2_transportMLPEntry_t *attr) 1660 { 1661 static char tcpsbuf[50]; 1662 const char *cp; 1663 1664 switch (state) { 1665 case TCPS_CLOSED: 1666 cp = "CLOSED"; 1667 break; 1668 case TCPS_IDLE: 1669 cp = "IDLE"; 1670 break; 1671 case TCPS_BOUND: 1672 cp = "BOUND"; 1673 break; 1674 case TCPS_LISTEN: 1675 cp = "LISTEN"; 1676 break; 1677 case TCPS_SYN_SENT: 1678 cp = "SYN_SENT"; 1679 break; 1680 case TCPS_SYN_RCVD: 1681 cp = "SYN_RCVD"; 1682 break; 1683 case TCPS_ESTABLISHED: 1684 cp = "ESTABLISHED"; 1685 break; 1686 case TCPS_CLOSE_WAIT: 1687 cp = "CLOSE_WAIT"; 1688 break; 1689 case TCPS_FIN_WAIT_1: 1690 cp = "FIN_WAIT_1"; 1691 break; 1692 case TCPS_CLOSING: 1693 cp = "CLOSING"; 1694 break; 1695 case TCPS_LAST_ACK: 1696 cp = "LAST_ACK"; 1697 break; 1698 case TCPS_FIN_WAIT_2: 1699 cp = "FIN_WAIT_2"; 1700 break; 1701 case TCPS_TIME_WAIT: 1702 cp = "TIME_WAIT"; 1703 break; 1704 default: 1705 (void) snprintf(tcpsbuf, sizeof (tcpsbuf), 1706 "UnknownState(%d)", state); 1707 cp = tcpsbuf; 1708 break; 1709 } 1710 1711 if (RSECflag && attr != NULL && attr->tme_flags != 0) { 1712 if (cp != tcpsbuf) { 1713 (void) strlcpy(tcpsbuf, cp, sizeof (tcpsbuf)); 1714 cp = tcpsbuf; 1715 } 1716 if (attr->tme_flags & MIB2_TMEF_PRIVATE) 1717 (void) strlcat(tcpsbuf, " P", sizeof (tcpsbuf)); 1718 if (attr->tme_flags & MIB2_TMEF_SHARED) 1719 (void) strlcat(tcpsbuf, " S", sizeof (tcpsbuf)); 1720 } 1721 1722 return (cp); 1723 } 1724 1725 static const char * 1726 miudp_state(int state, const mib2_transportMLPEntry_t *attr) 1727 { 1728 static char udpsbuf[50]; 1729 const char *cp; 1730 1731 switch (state) { 1732 case MIB2_UDP_unbound: 1733 cp = "Unbound"; 1734 break; 1735 case MIB2_UDP_idle: 1736 cp = "Idle"; 1737 break; 1738 case MIB2_UDP_connected: 1739 cp = "Connected"; 1740 break; 1741 default: 1742 (void) snprintf(udpsbuf, sizeof (udpsbuf), 1743 "Unknown State(%d)", state); 1744 cp = udpsbuf; 1745 break; 1746 } 1747 1748 if (RSECflag && attr != NULL && attr->tme_flags != 0) { 1749 if (cp != udpsbuf) { 1750 (void) strlcpy(udpsbuf, cp, sizeof (udpsbuf)); 1751 cp = udpsbuf; 1752 } 1753 if (attr->tme_flags & MIB2_TMEF_PRIVATE) 1754 (void) strlcat(udpsbuf, " P", sizeof (udpsbuf)); 1755 if (attr->tme_flags & MIB2_TMEF_SHARED) 1756 (void) strlcat(udpsbuf, " S", sizeof (udpsbuf)); 1757 } 1758 1759 return (cp); 1760 } 1761 1762 static int odd; 1763 1764 static void 1765 prval_init(void) 1766 { 1767 odd = 0; 1768 } 1769 1770 static void 1771 prval(char *str, Counter val) 1772 { 1773 (void) printf("\t%-20s=%6u", str, val); 1774 if (odd++ & 1) 1775 (void) putchar('\n'); 1776 } 1777 1778 static void 1779 prval64(char *str, Counter64 val) 1780 { 1781 (void) printf("\t%-20s=%6llu", str, val); 1782 if (odd++ & 1) 1783 (void) putchar('\n'); 1784 } 1785 1786 static void 1787 pr_int_val(char *str, int val) 1788 { 1789 (void) printf("\t%-20s=%6d", str, val); 1790 if (odd++ & 1) 1791 (void) putchar('\n'); 1792 } 1793 1794 static void 1795 pr_sctp_rtoalgo(char *str, int val) 1796 { 1797 (void) printf("\t%-20s=", str); 1798 switch (val) { 1799 case MIB2_SCTP_RTOALGO_OTHER: 1800 (void) printf("%6.6s", "other"); 1801 break; 1802 1803 case MIB2_SCTP_RTOALGO_VANJ: 1804 (void) printf("%6.6s", "vanj"); 1805 break; 1806 1807 default: 1808 (void) printf("%6d", val); 1809 break; 1810 } 1811 if (odd++ & 1) 1812 (void) putchar('\n'); 1813 } 1814 1815 static void 1816 prval_end(void) 1817 { 1818 if (odd++ & 1) 1819 (void) putchar('\n'); 1820 } 1821 1822 /* Extract constant sizes */ 1823 static void 1824 mib_get_constants(mib_item_t *item) 1825 { 1826 /* 'for' loop 1: */ 1827 for (; item; item = item->next_item) { 1828 if (item->mib_id != 0) 1829 continue; /* 'for' loop 1 */ 1830 1831 switch (item->group) { 1832 case MIB2_IP: { 1833 mib2_ip_t *ip = (mib2_ip_t *)item->valp; 1834 1835 ipAddrEntrySize = ip->ipAddrEntrySize; 1836 ipRouteEntrySize = ip->ipRouteEntrySize; 1837 ipNetToMediaEntrySize = ip->ipNetToMediaEntrySize; 1838 ipMemberEntrySize = ip->ipMemberEntrySize; 1839 ipGroupSourceEntrySize = ip->ipGroupSourceEntrySize; 1840 ipRouteAttributeSize = ip->ipRouteAttributeSize; 1841 transportMLPSize = ip->transportMLPSize; 1842 ipDestEntrySize = ip->ipDestEntrySize; 1843 assert(IS_P2ALIGNED(ipAddrEntrySize, 1844 sizeof (mib2_ipAddrEntry_t *))); 1845 assert(IS_P2ALIGNED(ipRouteEntrySize, 1846 sizeof (mib2_ipRouteEntry_t *))); 1847 assert(IS_P2ALIGNED(ipNetToMediaEntrySize, 1848 sizeof (mib2_ipNetToMediaEntry_t *))); 1849 assert(IS_P2ALIGNED(ipMemberEntrySize, 1850 sizeof (ip_member_t *))); 1851 assert(IS_P2ALIGNED(ipGroupSourceEntrySize, 1852 sizeof (ip_grpsrc_t *))); 1853 assert(IS_P2ALIGNED(ipRouteAttributeSize, 1854 sizeof (mib2_ipAttributeEntry_t *))); 1855 assert(IS_P2ALIGNED(transportMLPSize, 1856 sizeof (mib2_transportMLPEntry_t *))); 1857 break; 1858 } 1859 case EXPER_DVMRP: { 1860 struct mrtstat *mrts = (struct mrtstat *)item->valp; 1861 1862 vifctlSize = mrts->mrts_vifctlSize; 1863 mfcctlSize = mrts->mrts_mfcctlSize; 1864 assert(IS_P2ALIGNED(vifctlSize, 1865 sizeof (struct vifclt *))); 1866 assert(IS_P2ALIGNED(mfcctlSize, 1867 sizeof (struct mfcctl *))); 1868 break; 1869 } 1870 case MIB2_IP6: { 1871 mib2_ipv6IfStatsEntry_t *ip6; 1872 /* Just use the first entry */ 1873 1874 ip6 = (mib2_ipv6IfStatsEntry_t *)item->valp; 1875 ipv6IfStatsEntrySize = ip6->ipv6IfStatsEntrySize; 1876 ipv6AddrEntrySize = ip6->ipv6AddrEntrySize; 1877 ipv6RouteEntrySize = ip6->ipv6RouteEntrySize; 1878 ipv6NetToMediaEntrySize = ip6->ipv6NetToMediaEntrySize; 1879 ipv6MemberEntrySize = ip6->ipv6MemberEntrySize; 1880 ipv6GroupSourceEntrySize = 1881 ip6->ipv6GroupSourceEntrySize; 1882 assert(IS_P2ALIGNED(ipv6IfStatsEntrySize, 1883 sizeof (mib2_ipv6IfStatsEntry_t *))); 1884 assert(IS_P2ALIGNED(ipv6AddrEntrySize, 1885 sizeof (mib2_ipv6AddrEntry_t *))); 1886 assert(IS_P2ALIGNED(ipv6RouteEntrySize, 1887 sizeof (mib2_ipv6RouteEntry_t *))); 1888 assert(IS_P2ALIGNED(ipv6NetToMediaEntrySize, 1889 sizeof (mib2_ipv6NetToMediaEntry_t *))); 1890 assert(IS_P2ALIGNED(ipv6MemberEntrySize, 1891 sizeof (ipv6_member_t *))); 1892 assert(IS_P2ALIGNED(ipv6GroupSourceEntrySize, 1893 sizeof (ipv6_grpsrc_t *))); 1894 break; 1895 } 1896 case MIB2_ICMP6: { 1897 mib2_ipv6IfIcmpEntry_t *icmp6; 1898 /* Just use the first entry */ 1899 1900 icmp6 = (mib2_ipv6IfIcmpEntry_t *)item->valp; 1901 ipv6IfIcmpEntrySize = icmp6->ipv6IfIcmpEntrySize; 1902 assert(IS_P2ALIGNED(ipv6IfIcmpEntrySize, 1903 sizeof (mib2_ipv6IfIcmpEntry_t *))); 1904 break; 1905 } 1906 case MIB2_TCP: { 1907 mib2_tcp_t *tcp = (mib2_tcp_t *)item->valp; 1908 1909 tcpConnEntrySize = tcp->tcpConnTableSize; 1910 tcp6ConnEntrySize = tcp->tcp6ConnTableSize; 1911 assert(IS_P2ALIGNED(tcpConnEntrySize, 1912 sizeof (mib2_tcpConnEntry_t *))); 1913 assert(IS_P2ALIGNED(tcp6ConnEntrySize, 1914 sizeof (mib2_tcp6ConnEntry_t *))); 1915 break; 1916 } 1917 case MIB2_UDP: { 1918 mib2_udp_t *udp = (mib2_udp_t *)item->valp; 1919 1920 udpEntrySize = udp->udpEntrySize; 1921 udp6EntrySize = udp->udp6EntrySize; 1922 assert(IS_P2ALIGNED(udpEntrySize, 1923 sizeof (mib2_udpEntry_t *))); 1924 assert(IS_P2ALIGNED(udp6EntrySize, 1925 sizeof (mib2_udp6Entry_t *))); 1926 break; 1927 } 1928 case MIB2_SCTP: { 1929 mib2_sctp_t *sctp = (mib2_sctp_t *)item->valp; 1930 1931 sctpEntrySize = sctp->sctpEntrySize; 1932 sctpLocalEntrySize = sctp->sctpLocalEntrySize; 1933 sctpRemoteEntrySize = sctp->sctpRemoteEntrySize; 1934 break; 1935 } 1936 } 1937 } /* 'for' loop 1 ends */ 1938 1939 if (Xflag) { 1940 (void) puts("mib_get_constants:"); 1941 (void) printf("\tipv6IfStatsEntrySize %d\n", 1942 ipv6IfStatsEntrySize); 1943 (void) printf("\tipAddrEntrySize %d\n", ipAddrEntrySize); 1944 (void) printf("\tipRouteEntrySize %d\n", ipRouteEntrySize); 1945 (void) printf("\tipNetToMediaEntrySize %d\n", 1946 ipNetToMediaEntrySize); 1947 (void) printf("\tipMemberEntrySize %d\n", ipMemberEntrySize); 1948 (void) printf("\tipRouteAttributeSize %d\n", 1949 ipRouteAttributeSize); 1950 (void) printf("\tvifctlSize %d\n", vifctlSize); 1951 (void) printf("\tmfcctlSize %d\n", mfcctlSize); 1952 1953 (void) printf("\tipv6AddrEntrySize %d\n", ipv6AddrEntrySize); 1954 (void) printf("\tipv6RouteEntrySize %d\n", ipv6RouteEntrySize); 1955 (void) printf("\tipv6NetToMediaEntrySize %d\n", 1956 ipv6NetToMediaEntrySize); 1957 (void) printf("\tipv6MemberEntrySize %d\n", 1958 ipv6MemberEntrySize); 1959 (void) printf("\tipv6IfIcmpEntrySize %d\n", 1960 ipv6IfIcmpEntrySize); 1961 (void) printf("\tipDestEntrySize %d\n", ipDestEntrySize); 1962 (void) printf("\ttransportMLPSize %d\n", transportMLPSize); 1963 (void) printf("\ttcpConnEntrySize %d\n", tcpConnEntrySize); 1964 (void) printf("\ttcp6ConnEntrySize %d\n", tcp6ConnEntrySize); 1965 (void) printf("\tudpEntrySize %d\n", udpEntrySize); 1966 (void) printf("\tudp6EntrySize %d\n", udp6EntrySize); 1967 (void) printf("\tsctpEntrySize %d\n", sctpEntrySize); 1968 (void) printf("\tsctpLocalEntrySize %d\n", sctpLocalEntrySize); 1969 (void) printf("\tsctpRemoteEntrySize %d\n", 1970 sctpRemoteEntrySize); 1971 } 1972 } 1973 1974 1975 /* ----------------------------- STAT_REPORT ------------------------------- */ 1976 1977 static void 1978 stat_report(mib_item_t *item) 1979 { 1980 int jtemp = 0; 1981 char ifname[LIFNAMSIZ + 1]; 1982 1983 /* 'for' loop 1: */ 1984 for (; item; item = item->next_item) { 1985 if (Xflag) { 1986 (void) printf("\n--- Entry %d ---\n", ++jtemp); 1987 (void) printf("Group = %d, mib_id = %d, " 1988 "length = %d, valp = 0x%p\n", 1989 item->group, item->mib_id, 1990 item->length, item->valp); 1991 } 1992 if (item->mib_id != 0) 1993 continue; /* 'for' loop 1 */ 1994 1995 switch (item->group) { 1996 case MIB2_IP: { 1997 mib2_ip_t *ip = (mib2_ip_t *)item->valp; 1998 1999 if (protocol_selected(IPPROTO_IP) && 2000 family_selected(AF_INET)) { 2001 (void) fputs(v4compat ? "\nIP" : "\nIPv4", 2002 stdout); 2003 print_ip_stats(ip); 2004 } 2005 break; 2006 } 2007 case MIB2_ICMP: { 2008 mib2_icmp_t *icmp = 2009 (mib2_icmp_t *)item->valp; 2010 2011 if (protocol_selected(IPPROTO_ICMP) && 2012 family_selected(AF_INET)) { 2013 (void) fputs(v4compat ? "\nICMP" : "\nICMPv4", 2014 stdout); 2015 print_icmp_stats(icmp); 2016 } 2017 break; 2018 } 2019 case MIB2_IP6: { 2020 mib2_ipv6IfStatsEntry_t *ip6; 2021 mib2_ipv6IfStatsEntry_t sum6; 2022 2023 if (!(protocol_selected(IPPROTO_IPV6)) || 2024 !(family_selected(AF_INET6))) 2025 break; 2026 bzero(&sum6, sizeof (sum6)); 2027 /* 'for' loop 2a: */ 2028 for (ip6 = (mib2_ipv6IfStatsEntry_t *)item->valp; 2029 (char *)ip6 < (char *)item->valp + item->length; 2030 /* LINTED: (note 1) */ 2031 ip6 = (mib2_ipv6IfStatsEntry_t *)((char *)ip6 + 2032 ipv6IfStatsEntrySize)) { 2033 if (ip6->ipv6IfIndex == 0) { 2034 /* 2035 * The "unknown interface" ip6 2036 * mib. Just add to the sum. 2037 */ 2038 sum_ip6_stats(ip6, &sum6); 2039 continue; /* 'for' loop 2a */ 2040 } 2041 if (Aflag) { 2042 (void) printf("\nIPv6 for %s\n", 2043 ifindex2str(ip6->ipv6IfIndex, 2044 ifname)); 2045 print_ip6_stats(ip6); 2046 } 2047 sum_ip6_stats(ip6, &sum6); 2048 } /* 'for' loop 2a ends */ 2049 (void) fputs("\nIPv6", stdout); 2050 print_ip6_stats(&sum6); 2051 break; 2052 } 2053 case MIB2_ICMP6: { 2054 mib2_ipv6IfIcmpEntry_t *icmp6; 2055 mib2_ipv6IfIcmpEntry_t sum6; 2056 2057 if (!(protocol_selected(IPPROTO_ICMPV6)) || 2058 !(family_selected(AF_INET6))) 2059 break; 2060 bzero(&sum6, sizeof (sum6)); 2061 /* 'for' loop 2b: */ 2062 for (icmp6 = (mib2_ipv6IfIcmpEntry_t *)item->valp; 2063 (char *)icmp6 < (char *)item->valp + item->length; 2064 icmp6 = (void *)((char *)icmp6 + 2065 ipv6IfIcmpEntrySize)) { 2066 if (icmp6->ipv6IfIcmpIfIndex == 0) { 2067 /* 2068 * The "unknown interface" icmp6 2069 * mib. Just add to the sum. 2070 */ 2071 sum_icmp6_stats(icmp6, &sum6); 2072 continue; /* 'for' loop 2b: */ 2073 } 2074 if (Aflag) { 2075 (void) printf("\nICMPv6 for %s\n", 2076 ifindex2str( 2077 icmp6->ipv6IfIcmpIfIndex, ifname)); 2078 print_icmp6_stats(icmp6); 2079 } 2080 sum_icmp6_stats(icmp6, &sum6); 2081 } /* 'for' loop 2b ends */ 2082 (void) fputs("\nICMPv6", stdout); 2083 print_icmp6_stats(&sum6); 2084 break; 2085 } 2086 case MIB2_TCP: { 2087 mib2_tcp_t *tcp = (mib2_tcp_t *)item->valp; 2088 2089 if (protocol_selected(IPPROTO_TCP) && 2090 (family_selected(AF_INET) || 2091 family_selected(AF_INET6))) { 2092 (void) fputs("\nTCP", stdout); 2093 print_tcp_stats(tcp); 2094 } 2095 break; 2096 } 2097 case MIB2_UDP: { 2098 mib2_udp_t *udp = (mib2_udp_t *)item->valp; 2099 2100 if (protocol_selected(IPPROTO_UDP) && 2101 (family_selected(AF_INET) || 2102 family_selected(AF_INET6))) { 2103 (void) fputs("\nUDP", stdout); 2104 print_udp_stats(udp); 2105 } 2106 break; 2107 } 2108 case MIB2_SCTP: { 2109 mib2_sctp_t *sctp = (mib2_sctp_t *)item->valp; 2110 2111 if (protocol_selected(IPPROTO_SCTP) && 2112 (family_selected(AF_INET) || 2113 family_selected(AF_INET6))) { 2114 (void) fputs("\nSCTP", stdout); 2115 print_sctp_stats(sctp); 2116 } 2117 break; 2118 } 2119 case EXPER_RAWIP: { 2120 mib2_rawip_t *rawip = 2121 (mib2_rawip_t *)item->valp; 2122 2123 if (protocol_selected(IPPROTO_RAW) && 2124 (family_selected(AF_INET) || 2125 family_selected(AF_INET6))) { 2126 (void) fputs("\nRAWIP", stdout); 2127 print_rawip_stats(rawip); 2128 } 2129 break; 2130 } 2131 case EXPER_IGMP: { 2132 struct igmpstat *igps = 2133 (struct igmpstat *)item->valp; 2134 2135 if (protocol_selected(IPPROTO_IGMP) && 2136 (family_selected(AF_INET))) { 2137 (void) fputs("\nIGMP:\n", stdout); 2138 print_igmp_stats(igps); 2139 } 2140 break; 2141 } 2142 } 2143 } /* 'for' loop 1 ends */ 2144 (void) putchar('\n'); 2145 (void) fflush(stdout); 2146 } 2147 2148 static void 2149 print_ip_stats(mib2_ip_t *ip) 2150 { 2151 prval_init(); 2152 pr_int_val("ipForwarding", ip->ipForwarding); 2153 pr_int_val("ipDefaultTTL", ip->ipDefaultTTL); 2154 prval("ipInReceives", ip->ipInReceives); 2155 prval("ipInHdrErrors", ip->ipInHdrErrors); 2156 prval("ipInAddrErrors", ip->ipInAddrErrors); 2157 prval("ipInCksumErrs", ip->ipInCksumErrs); 2158 prval("ipForwDatagrams", ip->ipForwDatagrams); 2159 prval("ipForwProhibits", ip->ipForwProhibits); 2160 prval("ipInUnknownProtos", ip->ipInUnknownProtos); 2161 prval("ipInDiscards", ip->ipInDiscards); 2162 prval("ipInDelivers", ip->ipInDelivers); 2163 prval("ipOutRequests", ip->ipOutRequests); 2164 prval("ipOutDiscards", ip->ipOutDiscards); 2165 prval("ipOutNoRoutes", ip->ipOutNoRoutes); 2166 pr_int_val("ipReasmTimeout", ip->ipReasmTimeout); 2167 prval("ipReasmReqds", ip->ipReasmReqds); 2168 prval("ipReasmOKs", ip->ipReasmOKs); 2169 prval("ipReasmFails", ip->ipReasmFails); 2170 prval("ipReasmDuplicates", ip->ipReasmDuplicates); 2171 prval("ipReasmPartDups", ip->ipReasmPartDups); 2172 prval("ipFragOKs", ip->ipFragOKs); 2173 prval("ipFragFails", ip->ipFragFails); 2174 prval("ipFragCreates", ip->ipFragCreates); 2175 prval("ipRoutingDiscards", ip->ipRoutingDiscards); 2176 2177 prval("tcpInErrs", ip->tcpInErrs); 2178 prval("udpNoPorts", ip->udpNoPorts); 2179 prval("udpInCksumErrs", ip->udpInCksumErrs); 2180 prval("udpInOverflows", ip->udpInOverflows); 2181 prval("rawipInOverflows", ip->rawipInOverflows); 2182 prval("ipsecInSucceeded", ip->ipsecInSucceeded); 2183 prval("ipsecInFailed", ip->ipsecInFailed); 2184 prval("ipInIPv6", ip->ipInIPv6); 2185 prval("ipOutIPv6", ip->ipOutIPv6); 2186 prval("ipOutSwitchIPv6", ip->ipOutSwitchIPv6); 2187 prval_end(); 2188 } 2189 2190 static void 2191 print_icmp_stats(mib2_icmp_t *icmp) 2192 { 2193 prval_init(); 2194 prval("icmpInMsgs", icmp->icmpInMsgs); 2195 prval("icmpInErrors", icmp->icmpInErrors); 2196 prval("icmpInCksumErrs", icmp->icmpInCksumErrs); 2197 prval("icmpInUnknowns", icmp->icmpInUnknowns); 2198 prval("icmpInDestUnreachs", icmp->icmpInDestUnreachs); 2199 prval("icmpInTimeExcds", icmp->icmpInTimeExcds); 2200 prval("icmpInParmProbs", icmp->icmpInParmProbs); 2201 prval("icmpInSrcQuenchs", icmp->icmpInSrcQuenchs); 2202 prval("icmpInRedirects", icmp->icmpInRedirects); 2203 prval("icmpInBadRedirects", icmp->icmpInBadRedirects); 2204 prval("icmpInEchos", icmp->icmpInEchos); 2205 prval("icmpInEchoReps", icmp->icmpInEchoReps); 2206 prval("icmpInTimestamps", icmp->icmpInTimestamps); 2207 prval("icmpInTimestampReps", icmp->icmpInTimestampReps); 2208 prval("icmpInAddrMasks", icmp->icmpInAddrMasks); 2209 prval("icmpInAddrMaskReps", icmp->icmpInAddrMaskReps); 2210 prval("icmpInFragNeeded", icmp->icmpInFragNeeded); 2211 prval("icmpOutMsgs", icmp->icmpOutMsgs); 2212 prval("icmpOutDrops", icmp->icmpOutDrops); 2213 prval("icmpOutErrors", icmp->icmpOutErrors); 2214 prval("icmpOutDestUnreachs", icmp->icmpOutDestUnreachs); 2215 prval("icmpOutTimeExcds", icmp->icmpOutTimeExcds); 2216 prval("icmpOutParmProbs", icmp->icmpOutParmProbs); 2217 prval("icmpOutSrcQuenchs", icmp->icmpOutSrcQuenchs); 2218 prval("icmpOutRedirects", icmp->icmpOutRedirects); 2219 prval("icmpOutEchos", icmp->icmpOutEchos); 2220 prval("icmpOutEchoReps", icmp->icmpOutEchoReps); 2221 prval("icmpOutTimestamps", icmp->icmpOutTimestamps); 2222 prval("icmpOutTimestampReps", icmp->icmpOutTimestampReps); 2223 prval("icmpOutAddrMasks", icmp->icmpOutAddrMasks); 2224 prval("icmpOutAddrMaskReps", icmp->icmpOutAddrMaskReps); 2225 prval("icmpOutFragNeeded", icmp->icmpOutFragNeeded); 2226 prval("icmpInOverflows", icmp->icmpInOverflows); 2227 prval_end(); 2228 } 2229 2230 static void 2231 print_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6) 2232 { 2233 prval_init(); 2234 prval("ipv6Forwarding", ip6->ipv6Forwarding); 2235 prval("ipv6DefaultHopLimit", ip6->ipv6DefaultHopLimit); 2236 2237 prval("ipv6InReceives", ip6->ipv6InReceives); 2238 prval("ipv6InHdrErrors", ip6->ipv6InHdrErrors); 2239 prval("ipv6InTooBigErrors", ip6->ipv6InTooBigErrors); 2240 prval("ipv6InNoRoutes", ip6->ipv6InNoRoutes); 2241 prval("ipv6InAddrErrors", ip6->ipv6InAddrErrors); 2242 prval("ipv6InUnknownProtos", ip6->ipv6InUnknownProtos); 2243 prval("ipv6InTruncatedPkts", ip6->ipv6InTruncatedPkts); 2244 prval("ipv6InDiscards", ip6->ipv6InDiscards); 2245 prval("ipv6InDelivers", ip6->ipv6InDelivers); 2246 prval("ipv6OutForwDatagrams", ip6->ipv6OutForwDatagrams); 2247 prval("ipv6OutRequests", ip6->ipv6OutRequests); 2248 prval("ipv6OutDiscards", ip6->ipv6OutDiscards); 2249 prval("ipv6OutNoRoutes", ip6->ipv6OutNoRoutes); 2250 prval("ipv6OutFragOKs", ip6->ipv6OutFragOKs); 2251 prval("ipv6OutFragFails", ip6->ipv6OutFragFails); 2252 prval("ipv6OutFragCreates", ip6->ipv6OutFragCreates); 2253 prval("ipv6ReasmReqds", ip6->ipv6ReasmReqds); 2254 prval("ipv6ReasmOKs", ip6->ipv6ReasmOKs); 2255 prval("ipv6ReasmFails", ip6->ipv6ReasmFails); 2256 prval("ipv6InMcastPkts", ip6->ipv6InMcastPkts); 2257 prval("ipv6OutMcastPkts", ip6->ipv6OutMcastPkts); 2258 prval("ipv6ReasmDuplicates", ip6->ipv6ReasmDuplicates); 2259 prval("ipv6ReasmPartDups", ip6->ipv6ReasmPartDups); 2260 prval("ipv6ForwProhibits", ip6->ipv6ForwProhibits); 2261 prval("udpInCksumErrs", ip6->udpInCksumErrs); 2262 prval("udpInOverflows", ip6->udpInOverflows); 2263 prval("rawipInOverflows", ip6->rawipInOverflows); 2264 prval("ipv6InIPv4", ip6->ipv6InIPv4); 2265 prval("ipv6OutIPv4", ip6->ipv6OutIPv4); 2266 prval("ipv6OutSwitchIPv4", ip6->ipv6OutSwitchIPv4); 2267 prval_end(); 2268 } 2269 2270 static void 2271 print_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6) 2272 { 2273 prval_init(); 2274 prval("icmp6InMsgs", icmp6->ipv6IfIcmpInMsgs); 2275 prval("icmp6InErrors", icmp6->ipv6IfIcmpInErrors); 2276 prval("icmp6InDestUnreachs", icmp6->ipv6IfIcmpInDestUnreachs); 2277 prval("icmp6InAdminProhibs", icmp6->ipv6IfIcmpInAdminProhibs); 2278 prval("icmp6InTimeExcds", icmp6->ipv6IfIcmpInTimeExcds); 2279 prval("icmp6InParmProblems", icmp6->ipv6IfIcmpInParmProblems); 2280 prval("icmp6InPktTooBigs", icmp6->ipv6IfIcmpInPktTooBigs); 2281 prval("icmp6InEchos", icmp6->ipv6IfIcmpInEchos); 2282 prval("icmp6InEchoReplies", icmp6->ipv6IfIcmpInEchoReplies); 2283 prval("icmp6InRouterSols", icmp6->ipv6IfIcmpInRouterSolicits); 2284 prval("icmp6InRouterAds", 2285 icmp6->ipv6IfIcmpInRouterAdvertisements); 2286 prval("icmp6InNeighborSols", icmp6->ipv6IfIcmpInNeighborSolicits); 2287 prval("icmp6InNeighborAds", 2288 icmp6->ipv6IfIcmpInNeighborAdvertisements); 2289 prval("icmp6InRedirects", icmp6->ipv6IfIcmpInRedirects); 2290 prval("icmp6InBadRedirects", icmp6->ipv6IfIcmpInBadRedirects); 2291 prval("icmp6InGroupQueries", icmp6->ipv6IfIcmpInGroupMembQueries); 2292 prval("icmp6InGroupResps", icmp6->ipv6IfIcmpInGroupMembResponses); 2293 prval("icmp6InGroupReds", icmp6->ipv6IfIcmpInGroupMembReductions); 2294 prval("icmp6InOverflows", icmp6->ipv6IfIcmpInOverflows); 2295 prval_end(); 2296 prval_init(); 2297 prval("icmp6OutMsgs", icmp6->ipv6IfIcmpOutMsgs); 2298 prval("icmp6OutErrors", icmp6->ipv6IfIcmpOutErrors); 2299 prval("icmp6OutDestUnreachs", icmp6->ipv6IfIcmpOutDestUnreachs); 2300 prval("icmp6OutAdminProhibs", icmp6->ipv6IfIcmpOutAdminProhibs); 2301 prval("icmp6OutTimeExcds", icmp6->ipv6IfIcmpOutTimeExcds); 2302 prval("icmp6OutParmProblems", icmp6->ipv6IfIcmpOutParmProblems); 2303 prval("icmp6OutPktTooBigs", icmp6->ipv6IfIcmpOutPktTooBigs); 2304 prval("icmp6OutEchos", icmp6->ipv6IfIcmpOutEchos); 2305 prval("icmp6OutEchoReplies", icmp6->ipv6IfIcmpOutEchoReplies); 2306 prval("icmp6OutRouterSols", icmp6->ipv6IfIcmpOutRouterSolicits); 2307 prval("icmp6OutRouterAds", 2308 icmp6->ipv6IfIcmpOutRouterAdvertisements); 2309 prval("icmp6OutNeighborSols", icmp6->ipv6IfIcmpOutNeighborSolicits); 2310 prval("icmp6OutNeighborAds", 2311 icmp6->ipv6IfIcmpOutNeighborAdvertisements); 2312 prval("icmp6OutRedirects", icmp6->ipv6IfIcmpOutRedirects); 2313 prval("icmp6OutGroupQueries", icmp6->ipv6IfIcmpOutGroupMembQueries); 2314 prval("icmp6OutGroupResps", 2315 icmp6->ipv6IfIcmpOutGroupMembResponses); 2316 prval("icmp6OutGroupReds", 2317 icmp6->ipv6IfIcmpOutGroupMembReductions); 2318 prval_end(); 2319 } 2320 2321 static void 2322 print_sctp_stats(mib2_sctp_t *sctp) 2323 { 2324 prval_init(); 2325 pr_sctp_rtoalgo("sctpRtoAlgorithm", sctp->sctpRtoAlgorithm); 2326 prval("sctpRtoMin", sctp->sctpRtoMin); 2327 prval("sctpRtoMax", sctp->sctpRtoMax); 2328 prval("sctpRtoInitial", sctp->sctpRtoInitial); 2329 pr_int_val("sctpMaxAssocs", sctp->sctpMaxAssocs); 2330 prval("sctpValCookieLife", sctp->sctpValCookieLife); 2331 prval("sctpMaxInitRetr", sctp->sctpMaxInitRetr); 2332 prval("sctpCurrEstab", sctp->sctpCurrEstab); 2333 prval("sctpActiveEstab", sctp->sctpActiveEstab); 2334 prval("sctpPassiveEstab", sctp->sctpPassiveEstab); 2335 prval("sctpAborted", sctp->sctpAborted); 2336 prval("sctpShutdowns", sctp->sctpShutdowns); 2337 prval("sctpOutOfBlue", sctp->sctpOutOfBlue); 2338 prval("sctpChecksumError", sctp->sctpChecksumError); 2339 prval64("sctpOutCtrlChunks", sctp->sctpOutCtrlChunks); 2340 prval64("sctpOutOrderChunks", sctp->sctpOutOrderChunks); 2341 prval64("sctpOutUnorderChunks", sctp->sctpOutUnorderChunks); 2342 prval64("sctpRetransChunks", sctp->sctpRetransChunks); 2343 prval("sctpOutAck", sctp->sctpOutAck); 2344 prval("sctpOutAckDelayed", sctp->sctpOutAckDelayed); 2345 prval("sctpOutWinUpdate", sctp->sctpOutWinUpdate); 2346 prval("sctpOutFastRetrans", sctp->sctpOutFastRetrans); 2347 prval("sctpOutWinProbe", sctp->sctpOutWinProbe); 2348 prval64("sctpInCtrlChunks", sctp->sctpInCtrlChunks); 2349 prval64("sctpInOrderChunks", sctp->sctpInOrderChunks); 2350 prval64("sctpInUnorderChunks", sctp->sctpInUnorderChunks); 2351 prval("sctpInAck", sctp->sctpInAck); 2352 prval("sctpInDupAck", sctp->sctpInDupAck); 2353 prval("sctpInAckUnsent", sctp->sctpInAckUnsent); 2354 prval64("sctpFragUsrMsgs", sctp->sctpFragUsrMsgs); 2355 prval64("sctpReasmUsrMsgs", sctp->sctpReasmUsrMsgs); 2356 prval64("sctpOutSCTPPkts", sctp->sctpOutSCTPPkts); 2357 prval64("sctpInSCTPPkts", sctp->sctpInSCTPPkts); 2358 prval("sctpInInvalidCookie", sctp->sctpInInvalidCookie); 2359 prval("sctpTimRetrans", sctp->sctpTimRetrans); 2360 prval("sctpTimRetransDrop", sctp->sctpTimRetransDrop); 2361 prval("sctpTimHearBeatProbe", sctp->sctpTimHeartBeatProbe); 2362 prval("sctpTimHearBeatDrop", sctp->sctpTimHeartBeatDrop); 2363 prval("sctpListenDrop", sctp->sctpListenDrop); 2364 prval("sctpInClosed", sctp->sctpInClosed); 2365 prval_end(); 2366 } 2367 2368 static void 2369 print_tcp_stats(mib2_tcp_t *tcp) 2370 { 2371 prval_init(); 2372 pr_int_val("tcpRtoAlgorithm", tcp->tcpRtoAlgorithm); 2373 pr_int_val("tcpRtoMin", tcp->tcpRtoMin); 2374 pr_int_val("tcpRtoMax", tcp->tcpRtoMax); 2375 pr_int_val("tcpMaxConn", tcp->tcpMaxConn); 2376 prval("tcpActiveOpens", tcp->tcpActiveOpens); 2377 prval("tcpPassiveOpens", tcp->tcpPassiveOpens); 2378 prval("tcpAttemptFails", tcp->tcpAttemptFails); 2379 prval("tcpEstabResets", tcp->tcpEstabResets); 2380 prval("tcpCurrEstab", tcp->tcpCurrEstab); 2381 prval64("tcpOutSegs", tcp->tcpHCOutSegs); 2382 prval("tcpOutDataSegs", tcp->tcpOutDataSegs); 2383 prval("tcpOutDataBytes", tcp->tcpOutDataBytes); 2384 prval("tcpRetransSegs", tcp->tcpRetransSegs); 2385 prval("tcpRetransBytes", tcp->tcpRetransBytes); 2386 prval("tcpOutAck", tcp->tcpOutAck); 2387 prval("tcpOutAckDelayed", tcp->tcpOutAckDelayed); 2388 prval("tcpOutUrg", tcp->tcpOutUrg); 2389 prval("tcpOutWinUpdate", tcp->tcpOutWinUpdate); 2390 prval("tcpOutWinProbe", tcp->tcpOutWinProbe); 2391 prval("tcpOutControl", tcp->tcpOutControl); 2392 prval("tcpOutRsts", tcp->tcpOutRsts); 2393 prval("tcpOutFastRetrans", tcp->tcpOutFastRetrans); 2394 prval64("tcpInSegs", tcp->tcpHCInSegs); 2395 prval_end(); 2396 prval("tcpInAckSegs", tcp->tcpInAckSegs); 2397 prval("tcpInAckBytes", tcp->tcpInAckBytes); 2398 prval("tcpInDupAck", tcp->tcpInDupAck); 2399 prval("tcpInAckUnsent", tcp->tcpInAckUnsent); 2400 prval("tcpInInorderSegs", tcp->tcpInDataInorderSegs); 2401 prval("tcpInInorderBytes", tcp->tcpInDataInorderBytes); 2402 prval("tcpInUnorderSegs", tcp->tcpInDataUnorderSegs); 2403 prval("tcpInUnorderBytes", tcp->tcpInDataUnorderBytes); 2404 prval("tcpInDupSegs", tcp->tcpInDataDupSegs); 2405 prval("tcpInDupBytes", tcp->tcpInDataDupBytes); 2406 prval("tcpInPartDupSegs", tcp->tcpInDataPartDupSegs); 2407 prval("tcpInPartDupBytes", tcp->tcpInDataPartDupBytes); 2408 prval("tcpInPastWinSegs", tcp->tcpInDataPastWinSegs); 2409 prval("tcpInPastWinBytes", tcp->tcpInDataPastWinBytes); 2410 prval("tcpInWinProbe", tcp->tcpInWinProbe); 2411 prval("tcpInWinUpdate", tcp->tcpInWinUpdate); 2412 prval("tcpInClosed", tcp->tcpInClosed); 2413 prval("tcpRttNoUpdate", tcp->tcpRttNoUpdate); 2414 prval("tcpRttUpdate", tcp->tcpRttUpdate); 2415 prval("tcpTimRetrans", tcp->tcpTimRetrans); 2416 prval("tcpTimRetransDrop", tcp->tcpTimRetransDrop); 2417 prval("tcpTimKeepalive", tcp->tcpTimKeepalive); 2418 prval("tcpTimKeepaliveProbe", tcp->tcpTimKeepaliveProbe); 2419 prval("tcpTimKeepaliveDrop", tcp->tcpTimKeepaliveDrop); 2420 prval("tcpListenDrop", tcp->tcpListenDrop); 2421 prval("tcpListenDropQ0", tcp->tcpListenDropQ0); 2422 prval("tcpHalfOpenDrop", tcp->tcpHalfOpenDrop); 2423 prval("tcpOutSackRetrans", tcp->tcpOutSackRetransSegs); 2424 prval_end(); 2425 2426 } 2427 2428 static void 2429 print_udp_stats(mib2_udp_t *udp) 2430 { 2431 prval_init(); 2432 prval64("udpInDatagrams", udp->udpHCInDatagrams); 2433 prval("udpInErrors", udp->udpInErrors); 2434 prval64("udpOutDatagrams", udp->udpHCOutDatagrams); 2435 prval("udpOutErrors", udp->udpOutErrors); 2436 prval_end(); 2437 } 2438 2439 static void 2440 print_rawip_stats(mib2_rawip_t *rawip) 2441 { 2442 prval_init(); 2443 prval("rawipInDatagrams", rawip->rawipInDatagrams); 2444 prval("rawipInErrors", rawip->rawipInErrors); 2445 prval("rawipInCksumErrs", rawip->rawipInCksumErrs); 2446 prval("rawipOutDatagrams", rawip->rawipOutDatagrams); 2447 prval("rawipOutErrors", rawip->rawipOutErrors); 2448 prval_end(); 2449 } 2450 2451 void 2452 print_igmp_stats(struct igmpstat *igps) 2453 { 2454 (void) printf(" %10u message%s received\n", 2455 igps->igps_rcv_total, PLURAL(igps->igps_rcv_total)); 2456 (void) printf(" %10u message%s received with too few bytes\n", 2457 igps->igps_rcv_tooshort, PLURAL(igps->igps_rcv_tooshort)); 2458 (void) printf(" %10u message%s received with bad checksum\n", 2459 igps->igps_rcv_badsum, PLURAL(igps->igps_rcv_badsum)); 2460 (void) printf(" %10u membership quer%s received\n", 2461 igps->igps_rcv_queries, PLURALY(igps->igps_rcv_queries)); 2462 (void) printf(" %10u membership quer%s received with invalid " 2463 "field(s)\n", 2464 igps->igps_rcv_badqueries, PLURALY(igps->igps_rcv_badqueries)); 2465 (void) printf(" %10u membership report%s received\n", 2466 igps->igps_rcv_reports, PLURAL(igps->igps_rcv_reports)); 2467 (void) printf(" %10u membership report%s received with invalid " 2468 "field(s)\n", 2469 igps->igps_rcv_badreports, PLURAL(igps->igps_rcv_badreports)); 2470 (void) printf(" %10u membership report%s received for groups to " 2471 "which we belong\n", 2472 igps->igps_rcv_ourreports, PLURAL(igps->igps_rcv_ourreports)); 2473 (void) printf(" %10u membership report%s sent\n", 2474 igps->igps_snd_reports, PLURAL(igps->igps_snd_reports)); 2475 } 2476 2477 static void 2478 print_mrt_stats(struct mrtstat *mrts) 2479 { 2480 (void) puts("DVMRP multicast routing:"); 2481 (void) printf(" %10u hit%s - kernel forwarding cache hits\n", 2482 mrts->mrts_mfc_hits, PLURAL(mrts->mrts_mfc_hits)); 2483 (void) printf(" %10u miss%s - kernel forwarding cache misses\n", 2484 mrts->mrts_mfc_misses, PLURALES(mrts->mrts_mfc_misses)); 2485 (void) printf(" %10u packet%s potentially forwarded\n", 2486 mrts->mrts_fwd_in, PLURAL(mrts->mrts_fwd_in)); 2487 (void) printf(" %10u packet%s actually sent out\n", 2488 mrts->mrts_fwd_out, PLURAL(mrts->mrts_fwd_out)); 2489 (void) printf(" %10u upcall%s - upcalls made to mrouted\n", 2490 mrts->mrts_upcalls, PLURAL(mrts->mrts_upcalls)); 2491 (void) printf(" %10u packet%s not sent out due to lack of resources\n", 2492 mrts->mrts_fwd_drop, PLURAL(mrts->mrts_fwd_drop)); 2493 (void) printf(" %10u datagram%s with malformed tunnel options\n", 2494 mrts->mrts_bad_tunnel, PLURAL(mrts->mrts_bad_tunnel)); 2495 (void) printf(" %10u datagram%s with no room for tunnel options\n", 2496 mrts->mrts_cant_tunnel, PLURAL(mrts->mrts_cant_tunnel)); 2497 (void) printf(" %10u datagram%s arrived on wrong interface\n", 2498 mrts->mrts_wrong_if, PLURAL(mrts->mrts_wrong_if)); 2499 (void) printf(" %10u datagram%s dropped due to upcall Q overflow\n", 2500 mrts->mrts_upq_ovflw, PLURAL(mrts->mrts_upq_ovflw)); 2501 (void) printf(" %10u datagram%s cleaned up by the cache\n", 2502 mrts->mrts_cache_cleanups, PLURAL(mrts->mrts_cache_cleanups)); 2503 (void) printf(" %10u datagram%s dropped selectively by ratelimiter\n", 2504 mrts->mrts_drop_sel, PLURAL(mrts->mrts_drop_sel)); 2505 (void) printf(" %10u datagram%s dropped - bucket Q overflow\n", 2506 mrts->mrts_q_overflow, PLURAL(mrts->mrts_q_overflow)); 2507 (void) printf(" %10u datagram%s dropped - larger than bkt size\n", 2508 mrts->mrts_pkt2large, PLURAL(mrts->mrts_pkt2large)); 2509 (void) printf("\nPIM multicast routing:\n"); 2510 (void) printf(" %10u datagram%s dropped - bad version number\n", 2511 mrts->mrts_pim_badversion, PLURAL(mrts->mrts_pim_badversion)); 2512 (void) printf(" %10u datagram%s dropped - bad checksum\n", 2513 mrts->mrts_pim_rcv_badcsum, PLURAL(mrts->mrts_pim_rcv_badcsum)); 2514 (void) printf(" %10u datagram%s dropped - bad register packets\n", 2515 mrts->mrts_pim_badregisters, PLURAL(mrts->mrts_pim_badregisters)); 2516 (void) printf( 2517 " %10u datagram%s potentially forwarded - register packets\n", 2518 mrts->mrts_pim_regforwards, PLURAL(mrts->mrts_pim_regforwards)); 2519 (void) printf(" %10u datagram%s dropped - register send drops\n", 2520 mrts->mrts_pim_regsend_drops, PLURAL(mrts->mrts_pim_regsend_drops)); 2521 (void) printf(" %10u datagram%s dropped - packet malformed\n", 2522 mrts->mrts_pim_malformed, PLURAL(mrts->mrts_pim_malformed)); 2523 (void) printf(" %10u datagram%s dropped - no memory to forward\n", 2524 mrts->mrts_pim_nomemory, PLURAL(mrts->mrts_pim_nomemory)); 2525 } 2526 2527 static void 2528 sum_ip6_stats(mib2_ipv6IfStatsEntry_t *ip6, mib2_ipv6IfStatsEntry_t *sum6) 2529 { 2530 /* First few are not additive */ 2531 sum6->ipv6Forwarding = ip6->ipv6Forwarding; 2532 sum6->ipv6DefaultHopLimit = ip6->ipv6DefaultHopLimit; 2533 2534 sum6->ipv6InReceives += ip6->ipv6InReceives; 2535 sum6->ipv6InHdrErrors += ip6->ipv6InHdrErrors; 2536 sum6->ipv6InTooBigErrors += ip6->ipv6InTooBigErrors; 2537 sum6->ipv6InNoRoutes += ip6->ipv6InNoRoutes; 2538 sum6->ipv6InAddrErrors += ip6->ipv6InAddrErrors; 2539 sum6->ipv6InUnknownProtos += ip6->ipv6InUnknownProtos; 2540 sum6->ipv6InTruncatedPkts += ip6->ipv6InTruncatedPkts; 2541 sum6->ipv6InDiscards += ip6->ipv6InDiscards; 2542 sum6->ipv6InDelivers += ip6->ipv6InDelivers; 2543 sum6->ipv6OutForwDatagrams += ip6->ipv6OutForwDatagrams; 2544 sum6->ipv6OutRequests += ip6->ipv6OutRequests; 2545 sum6->ipv6OutDiscards += ip6->ipv6OutDiscards; 2546 sum6->ipv6OutFragOKs += ip6->ipv6OutFragOKs; 2547 sum6->ipv6OutFragFails += ip6->ipv6OutFragFails; 2548 sum6->ipv6OutFragCreates += ip6->ipv6OutFragCreates; 2549 sum6->ipv6ReasmReqds += ip6->ipv6ReasmReqds; 2550 sum6->ipv6ReasmOKs += ip6->ipv6ReasmOKs; 2551 sum6->ipv6ReasmFails += ip6->ipv6ReasmFails; 2552 sum6->ipv6InMcastPkts += ip6->ipv6InMcastPkts; 2553 sum6->ipv6OutMcastPkts += ip6->ipv6OutMcastPkts; 2554 sum6->ipv6OutNoRoutes += ip6->ipv6OutNoRoutes; 2555 sum6->ipv6ReasmDuplicates += ip6->ipv6ReasmDuplicates; 2556 sum6->ipv6ReasmPartDups += ip6->ipv6ReasmPartDups; 2557 sum6->ipv6ForwProhibits += ip6->ipv6ForwProhibits; 2558 sum6->udpInCksumErrs += ip6->udpInCksumErrs; 2559 sum6->udpInOverflows += ip6->udpInOverflows; 2560 sum6->rawipInOverflows += ip6->rawipInOverflows; 2561 } 2562 2563 static void 2564 sum_icmp6_stats(mib2_ipv6IfIcmpEntry_t *icmp6, mib2_ipv6IfIcmpEntry_t *sum6) 2565 { 2566 sum6->ipv6IfIcmpInMsgs += icmp6->ipv6IfIcmpInMsgs; 2567 sum6->ipv6IfIcmpInErrors += icmp6->ipv6IfIcmpInErrors; 2568 sum6->ipv6IfIcmpInDestUnreachs += icmp6->ipv6IfIcmpInDestUnreachs; 2569 sum6->ipv6IfIcmpInAdminProhibs += icmp6->ipv6IfIcmpInAdminProhibs; 2570 sum6->ipv6IfIcmpInTimeExcds += icmp6->ipv6IfIcmpInTimeExcds; 2571 sum6->ipv6IfIcmpInParmProblems += icmp6->ipv6IfIcmpInParmProblems; 2572 sum6->ipv6IfIcmpInPktTooBigs += icmp6->ipv6IfIcmpInPktTooBigs; 2573 sum6->ipv6IfIcmpInEchos += icmp6->ipv6IfIcmpInEchos; 2574 sum6->ipv6IfIcmpInEchoReplies += icmp6->ipv6IfIcmpInEchoReplies; 2575 sum6->ipv6IfIcmpInRouterSolicits += icmp6->ipv6IfIcmpInRouterSolicits; 2576 sum6->ipv6IfIcmpInRouterAdvertisements += 2577 icmp6->ipv6IfIcmpInRouterAdvertisements; 2578 sum6->ipv6IfIcmpInNeighborSolicits += 2579 icmp6->ipv6IfIcmpInNeighborSolicits; 2580 sum6->ipv6IfIcmpInNeighborAdvertisements += 2581 icmp6->ipv6IfIcmpInNeighborAdvertisements; 2582 sum6->ipv6IfIcmpInRedirects += icmp6->ipv6IfIcmpInRedirects; 2583 sum6->ipv6IfIcmpInGroupMembQueries += 2584 icmp6->ipv6IfIcmpInGroupMembQueries; 2585 sum6->ipv6IfIcmpInGroupMembResponses += 2586 icmp6->ipv6IfIcmpInGroupMembResponses; 2587 sum6->ipv6IfIcmpInGroupMembReductions += 2588 icmp6->ipv6IfIcmpInGroupMembReductions; 2589 sum6->ipv6IfIcmpOutMsgs += icmp6->ipv6IfIcmpOutMsgs; 2590 sum6->ipv6IfIcmpOutErrors += icmp6->ipv6IfIcmpOutErrors; 2591 sum6->ipv6IfIcmpOutDestUnreachs += icmp6->ipv6IfIcmpOutDestUnreachs; 2592 sum6->ipv6IfIcmpOutAdminProhibs += icmp6->ipv6IfIcmpOutAdminProhibs; 2593 sum6->ipv6IfIcmpOutTimeExcds += icmp6->ipv6IfIcmpOutTimeExcds; 2594 sum6->ipv6IfIcmpOutParmProblems += icmp6->ipv6IfIcmpOutParmProblems; 2595 sum6->ipv6IfIcmpOutPktTooBigs += icmp6->ipv6IfIcmpOutPktTooBigs; 2596 sum6->ipv6IfIcmpOutEchos += icmp6->ipv6IfIcmpOutEchos; 2597 sum6->ipv6IfIcmpOutEchoReplies += icmp6->ipv6IfIcmpOutEchoReplies; 2598 sum6->ipv6IfIcmpOutRouterSolicits += 2599 icmp6->ipv6IfIcmpOutRouterSolicits; 2600 sum6->ipv6IfIcmpOutRouterAdvertisements += 2601 icmp6->ipv6IfIcmpOutRouterAdvertisements; 2602 sum6->ipv6IfIcmpOutNeighborSolicits += 2603 icmp6->ipv6IfIcmpOutNeighborSolicits; 2604 sum6->ipv6IfIcmpOutNeighborAdvertisements += 2605 icmp6->ipv6IfIcmpOutNeighborAdvertisements; 2606 sum6->ipv6IfIcmpOutRedirects += icmp6->ipv6IfIcmpOutRedirects; 2607 sum6->ipv6IfIcmpOutGroupMembQueries += 2608 icmp6->ipv6IfIcmpOutGroupMembQueries; 2609 sum6->ipv6IfIcmpOutGroupMembResponses += 2610 icmp6->ipv6IfIcmpOutGroupMembResponses; 2611 sum6->ipv6IfIcmpOutGroupMembReductions += 2612 icmp6->ipv6IfIcmpOutGroupMembReductions; 2613 sum6->ipv6IfIcmpInOverflows += icmp6->ipv6IfIcmpInOverflows; 2614 } 2615 2616 /* ----------------------------- MRT_STAT_REPORT --------------------------- */ 2617 2618 static void 2619 mrt_stat_report(mib_item_t *curritem) 2620 { 2621 int jtemp = 0; 2622 mib_item_t *tempitem; 2623 2624 if (!(family_selected(AF_INET))) 2625 return; 2626 2627 (void) putchar('\n'); 2628 /* 'for' loop 1: */ 2629 for (tempitem = curritem; 2630 tempitem; 2631 tempitem = tempitem->next_item) { 2632 if (Xflag) { 2633 (void) printf("\n--- Entry %d ---\n", ++jtemp); 2634 (void) printf("Group = %d, mib_id = %d, " 2635 "length = %d, valp = 0x%p\n", 2636 tempitem->group, tempitem->mib_id, 2637 tempitem->length, tempitem->valp); 2638 } 2639 2640 if (tempitem->mib_id == 0) { 2641 switch (tempitem->group) { 2642 case EXPER_DVMRP: { 2643 struct mrtstat *mrts; 2644 mrts = (struct mrtstat *)tempitem->valp; 2645 2646 if (!(family_selected(AF_INET))) 2647 continue; /* 'for' loop 1 */ 2648 2649 print_mrt_stats(mrts); 2650 break; 2651 } 2652 } 2653 } 2654 } /* 'for' loop 1 ends */ 2655 (void) putchar('\n'); 2656 (void) fflush(stdout); 2657 } 2658 2659 /* 2660 * if_stat_total() - Computes totals for interface statistics 2661 * and returns result by updating sumstats. 2662 */ 2663 static void 2664 if_stat_total(struct ifstat *oldstats, struct ifstat *newstats, 2665 struct ifstat *sumstats) 2666 { 2667 sumstats->ipackets += newstats->ipackets - oldstats->ipackets; 2668 sumstats->opackets += newstats->opackets - oldstats->opackets; 2669 sumstats->ierrors += newstats->ierrors - oldstats->ierrors; 2670 sumstats->oerrors += newstats->oerrors - oldstats->oerrors; 2671 sumstats->collisions += newstats->collisions - oldstats->collisions; 2672 } 2673 2674 /* --------------------- IF_REPORT (netstat -i) -------------------------- */ 2675 2676 static struct ifstat zerostat = { 2677 0LL, 0LL, 0LL, 0LL, 0LL 2678 }; 2679 2680 static void 2681 if_report(mib_item_t *item, char *matchname, 2682 int Iflag_only, boolean_t once_only) 2683 { 2684 static boolean_t reentry = B_FALSE; 2685 boolean_t alreadydone = B_FALSE; 2686 int jtemp = 0; 2687 uint32_t ifindex_v4 = 0; 2688 uint32_t ifindex_v6 = 0; 2689 boolean_t first_header = B_TRUE; 2690 2691 /* 'for' loop 1: */ 2692 for (; item; item = item->next_item) { 2693 if (Xflag) { 2694 (void) printf("\n--- Entry %d ---\n", ++jtemp); 2695 (void) printf("Group = %d, mib_id = %d, " 2696 "length = %d, valp = 0x%p\n", 2697 item->group, item->mib_id, item->length, 2698 item->valp); 2699 } 2700 2701 switch (item->group) { 2702 case MIB2_IP: 2703 if (item->mib_id != MIB2_IP_ADDR || 2704 !family_selected(AF_INET)) 2705 continue; /* 'for' loop 1 */ 2706 { 2707 static struct ifstat old = {0L, 0L, 0L, 0L, 0L}; 2708 static struct ifstat new = {0L, 0L, 0L, 0L, 0L}; 2709 struct ifstat sum; 2710 struct iflist *newlist = NULL; 2711 static struct iflist *oldlist = NULL; 2712 kstat_t *ksp; 2713 2714 if (once_only) { 2715 char ifname[LIFNAMSIZ + 1]; 2716 char logintname[LIFNAMSIZ + 1]; 2717 mib2_ipAddrEntry_t *ap; 2718 struct ifstat stat = {0L, 0L, 0L, 0L, 0L}; 2719 boolean_t first = B_TRUE; 2720 uint32_t new_ifindex; 2721 2722 if (Xflag) 2723 (void) printf("if_report: %d items\n", 2724 (item->length) 2725 / sizeof (mib2_ipAddrEntry_t)); 2726 2727 /* 'for' loop 2a: */ 2728 for (ap = (mib2_ipAddrEntry_t *)item->valp; 2729 (char *)ap < (char *)item->valp 2730 + item->length; 2731 ap++) { 2732 (void) octetstr(&ap->ipAdEntIfIndex, 2733 'a', logintname, 2734 sizeof (logintname)); 2735 (void) strcpy(ifname, logintname); 2736 (void) strtok(ifname, ":"); 2737 if (matchname != NULL && 2738 strcmp(matchname, ifname) != 0 && 2739 strcmp(matchname, logintname) != 0) 2740 continue; /* 'for' loop 2a */ 2741 new_ifindex = 2742 if_nametoindex(logintname); 2743 /* 2744 * First lookup the "link" kstats in 2745 * case the link is renamed. Then 2746 * fallback to the legacy kstats for 2747 * those non-GLDv3 links. 2748 */ 2749 if (new_ifindex != ifindex_v4 && 2750 (((ksp = kstat_lookup(kc, "link", 0, 2751 ifname)) != NULL) || 2752 ((ksp = kstat_lookup(kc, NULL, -1, 2753 ifname)) != NULL))) { 2754 (void) safe_kstat_read(kc, ksp, 2755 NULL); 2756 stat.ipackets = 2757 kstat_named_value(ksp, 2758 "ipackets"); 2759 stat.ierrors = 2760 kstat_named_value(ksp, 2761 "ierrors"); 2762 stat.opackets = 2763 kstat_named_value(ksp, 2764 "opackets"); 2765 stat.oerrors = 2766 kstat_named_value(ksp, 2767 "oerrors"); 2768 stat.collisions = 2769 kstat_named_value(ksp, 2770 "collisions"); 2771 if (first) { 2772 if (!first_header) 2773 (void) putchar('\n'); 2774 first_header = B_FALSE; 2775 (void) printf( 2776 "%-5.5s %-5.5s%-13.13s " 2777 "%-14.14s %-6.6s %-5.5s " 2778 "%-6.6s %-5.5s %-6.6s " 2779 "%-6.6s\n", 2780 "Name", "Mtu", "Net/Dest", 2781 "Address", "Ipkts", 2782 "Ierrs", "Opkts", "Oerrs", 2783 "Collis", "Queue"); 2784 2785 first = B_FALSE; 2786 } 2787 if_report_ip4(ap, ifname, 2788 logintname, &stat, B_TRUE); 2789 ifindex_v4 = new_ifindex; 2790 } else { 2791 if_report_ip4(ap, ifname, 2792 logintname, &stat, B_FALSE); 2793 } 2794 } /* 'for' loop 2a ends */ 2795 } else if (!alreadydone) { 2796 char ifname[LIFNAMSIZ + 1]; 2797 char buf[LIFNAMSIZ + 1]; 2798 mib2_ipAddrEntry_t *ap; 2799 struct ifstat t; 2800 struct iflist *tlp = NULL; 2801 struct iflist **nextnew = &newlist; 2802 struct iflist *walkold; 2803 struct iflist *cleanlist; 2804 boolean_t found_if = B_FALSE; 2805 2806 alreadydone = B_TRUE; /* ignore other case */ 2807 2808 /* 2809 * Check if there is anything to do. 2810 */ 2811 if (item->length < 2812 sizeof (mib2_ipAddrEntry_t)) { 2813 fail(0, "No compatible interfaces"); 2814 } 2815 2816 /* 2817 * 'for' loop 2b: find the "right" entry: 2818 * If an interface name to match has been 2819 * supplied then try and find it, otherwise 2820 * match the first non-loopback interface found. 2821 * Use lo0 if all else fails. 2822 */ 2823 for (ap = (mib2_ipAddrEntry_t *)item->valp; 2824 (char *)ap < (char *)item->valp 2825 + item->length; 2826 ap++) { 2827 (void) octetstr(&ap->ipAdEntIfIndex, 2828 'a', ifname, sizeof (ifname)); 2829 (void) strtok(ifname, ":"); 2830 2831 if (matchname) { 2832 if (strcmp(matchname, 2833 ifname) == 0) { 2834 /* 'for' loop 2b */ 2835 found_if = B_TRUE; 2836 break; 2837 } 2838 } else if (strcmp(ifname, "lo0") != 0) 2839 break; /* 'for' loop 2b */ 2840 } /* 'for' loop 2b ends */ 2841 2842 if (matchname == NULL) { 2843 matchname = ifname; 2844 } else { 2845 if (!found_if) 2846 fail(0, "-I: %s no such " 2847 "interface.", matchname); 2848 } 2849 2850 if (Iflag_only == 0 || !reentry) { 2851 (void) printf(" input %-6.6s " 2852 "output ", 2853 matchname); 2854 (void) printf(" input (Total) " 2855 "output\n"); 2856 (void) printf("%-7.7s %-5.5s %-7.7s " 2857 "%-5.5s %-6.6s ", 2858 "packets", "errs", "packets", 2859 "errs", "colls"); 2860 (void) printf("%-7.7s %-5.5s %-7.7s " 2861 "%-5.5s %-6.6s\n", 2862 "packets", "errs", "packets", 2863 "errs", "colls"); 2864 } 2865 2866 sum = zerostat; 2867 2868 /* 'for' loop 2c: */ 2869 for (ap = (mib2_ipAddrEntry_t *)item->valp; 2870 (char *)ap < (char *)item->valp 2871 + item->length; 2872 ap++) { 2873 (void) octetstr(&ap->ipAdEntIfIndex, 2874 'a', buf, sizeof (buf)); 2875 (void) strtok(buf, ":"); 2876 2877 /* 2878 * We have reduced the IP interface 2879 * name, which could have been a 2880 * logical, down to a name suitable 2881 * for use with kstats. 2882 * We treat this name as unique and 2883 * only collate statistics for it once 2884 * per pass. This is to avoid falsely 2885 * amplifying these statistics by the 2886 * the number of logical instances. 2887 */ 2888 if ((tlp != NULL) && 2889 ((strcmp(buf, tlp->ifname) == 0))) { 2890 continue; 2891 } 2892 2893 /* 2894 * First lookup the "link" kstats in 2895 * case the link is renamed. Then 2896 * fallback to the legacy kstats for 2897 * those non-GLDv3 links. 2898 */ 2899 if (((ksp = kstat_lookup(kc, "link", 2900 0, buf)) != NULL || 2901 (ksp = kstat_lookup(kc, NULL, -1, 2902 buf)) != NULL) && (ksp->ks_type == 2903 KSTAT_TYPE_NAMED)) { 2904 (void) safe_kstat_read(kc, ksp, 2905 NULL); 2906 } 2907 2908 t.ipackets = kstat_named_value(ksp, 2909 "ipackets"); 2910 t.ierrors = kstat_named_value(ksp, 2911 "ierrors"); 2912 t.opackets = kstat_named_value(ksp, 2913 "opackets"); 2914 t.oerrors = kstat_named_value(ksp, 2915 "oerrors"); 2916 t.collisions = kstat_named_value(ksp, 2917 "collisions"); 2918 2919 if (strcmp(buf, matchname) == 0) 2920 new = t; 2921 2922 /* Build the interface list */ 2923 2924 tlp = malloc(sizeof (struct iflist)); 2925 (void) strlcpy(tlp->ifname, buf, 2926 sizeof (tlp->ifname)); 2927 tlp->tot = t; 2928 *nextnew = tlp; 2929 nextnew = &tlp->next_if; 2930 2931 /* 2932 * First time through. 2933 * Just add up the interface stats. 2934 */ 2935 2936 if (oldlist == NULL) { 2937 if_stat_total(&zerostat, 2938 &t, &sum); 2939 continue; 2940 } 2941 2942 /* 2943 * Walk old list for the interface. 2944 * 2945 * If found, add difference to total. 2946 * 2947 * If not, an interface has been plumbed 2948 * up. In this case, we will simply 2949 * ignore the new interface until the 2950 * next interval; as there's no easy way 2951 * to acquire statistics between time 2952 * of the plumb and the next interval 2953 * boundary. This results in inaccurate 2954 * total values for current interval. 2955 * 2956 * Note the case when an interface is 2957 * unplumbed; as similar problems exist. 2958 * The unplumbed interface is not in the 2959 * current list, and there's no easy way 2960 * to account for the statistics between 2961 * the previous interval and time of the 2962 * unplumb. Therefore, we (in a sense) 2963 * ignore the removed interface by only 2964 * involving "current" interfaces when 2965 * computing the total statistics. 2966 * Unfortunately, this also results in 2967 * inaccurate values for interval total. 2968 */ 2969 2970 for (walkold = oldlist; 2971 walkold != NULL; 2972 walkold = walkold->next_if) { 2973 if (strcmp(walkold->ifname, 2974 buf) == 0) { 2975 if_stat_total( 2976 &walkold->tot, 2977 &t, &sum); 2978 break; 2979 } 2980 } 2981 2982 } /* 'for' loop 2c ends */ 2983 2984 *nextnew = NULL; 2985 2986 (void) printf("%-7llu %-5llu %-7llu " 2987 "%-5llu %-6llu ", 2988 new.ipackets - old.ipackets, 2989 new.ierrors - old.ierrors, 2990 new.opackets - old.opackets, 2991 new.oerrors - old.oerrors, 2992 new.collisions - old.collisions); 2993 2994 (void) printf("%-7llu %-5llu %-7llu " 2995 "%-5llu %-6llu\n", sum.ipackets, 2996 sum.ierrors, sum.opackets, 2997 sum.oerrors, sum.collisions); 2998 2999 /* 3000 * Tidy things up once finished. 3001 */ 3002 3003 old = new; 3004 cleanlist = oldlist; 3005 oldlist = newlist; 3006 while (cleanlist != NULL) { 3007 tlp = cleanlist->next_if; 3008 free(cleanlist); 3009 cleanlist = tlp; 3010 } 3011 } 3012 break; 3013 } 3014 case MIB2_IP6: 3015 if (item->mib_id != MIB2_IP6_ADDR || 3016 !family_selected(AF_INET6)) 3017 continue; /* 'for' loop 1 */ 3018 { 3019 static struct ifstat old6 = {0L, 0L, 0L, 0L, 0L}; 3020 static struct ifstat new6 = {0L, 0L, 0L, 0L, 0L}; 3021 struct ifstat sum6; 3022 struct iflist *newlist6 = NULL; 3023 static struct iflist *oldlist6 = NULL; 3024 kstat_t *ksp; 3025 3026 if (once_only) { 3027 char ifname[LIFNAMSIZ + 1]; 3028 char logintname[LIFNAMSIZ + 1]; 3029 mib2_ipv6AddrEntry_t *ap6; 3030 struct ifstat stat = {0L, 0L, 0L, 0L, 0L}; 3031 boolean_t first = B_TRUE; 3032 uint32_t new_ifindex; 3033 3034 if (Xflag) 3035 (void) printf("if_report: %d items\n", 3036 (item->length) 3037 / sizeof (mib2_ipv6AddrEntry_t)); 3038 /* 'for' loop 2d: */ 3039 for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 3040 (char *)ap6 < (char *)item->valp 3041 + item->length; 3042 ap6++) { 3043 (void) octetstr(&ap6->ipv6AddrIfIndex, 3044 'a', logintname, 3045 sizeof (logintname)); 3046 (void) strcpy(ifname, logintname); 3047 (void) strtok(ifname, ":"); 3048 if (matchname != NULL && 3049 strcmp(matchname, ifname) != 0 && 3050 strcmp(matchname, logintname) != 0) 3051 continue; /* 'for' loop 2d */ 3052 new_ifindex = 3053 if_nametoindex(logintname); 3054 3055 /* 3056 * First lookup the "link" kstats in 3057 * case the link is renamed. Then 3058 * fallback to the legacy kstats for 3059 * those non-GLDv3 links. 3060 */ 3061 if (new_ifindex != ifindex_v6 && 3062 ((ksp = kstat_lookup(kc, "link", 0, 3063 ifname)) != NULL || 3064 (ksp = kstat_lookup(kc, NULL, -1, 3065 ifname)) != NULL)) { 3066 (void) safe_kstat_read(kc, ksp, 3067 NULL); 3068 stat.ipackets = 3069 kstat_named_value(ksp, 3070 "ipackets"); 3071 stat.ierrors = 3072 kstat_named_value(ksp, 3073 "ierrors"); 3074 stat.opackets = 3075 kstat_named_value(ksp, 3076 "opackets"); 3077 stat.oerrors = 3078 kstat_named_value(ksp, 3079 "oerrors"); 3080 stat.collisions = 3081 kstat_named_value(ksp, 3082 "collisions"); 3083 if (first) { 3084 if (!first_header) 3085 (void) putchar('\n'); 3086 first_header = B_FALSE; 3087 (void) printf( 3088 "%-5.5s %-5.5s%" 3089 "-27.27s %-27.27s " 3090 "%-6.6s %-5.5s " 3091 "%-6.6s %-5.5s " 3092 "%-6.6s\n", 3093 "Name", "Mtu", 3094 "Net/Dest", 3095 "Address", "Ipkts", 3096 "Ierrs", "Opkts", 3097 "Oerrs", "Collis"); 3098 first = B_FALSE; 3099 } 3100 if_report_ip6(ap6, ifname, 3101 logintname, &stat, B_TRUE); 3102 ifindex_v6 = new_ifindex; 3103 } else { 3104 if_report_ip6(ap6, ifname, 3105 logintname, &stat, B_FALSE); 3106 } 3107 } /* 'for' loop 2d ends */ 3108 } else if (!alreadydone) { 3109 char ifname[LIFNAMSIZ + 1]; 3110 char buf[IFNAMSIZ + 1]; 3111 mib2_ipv6AddrEntry_t *ap6; 3112 struct ifstat t; 3113 struct iflist *tlp = NULL; 3114 struct iflist **nextnew = &newlist6; 3115 struct iflist *walkold; 3116 struct iflist *cleanlist; 3117 boolean_t found_if = B_FALSE; 3118 3119 alreadydone = B_TRUE; /* ignore other case */ 3120 3121 /* 3122 * Check if there is anything to do. 3123 */ 3124 if (item->length < 3125 sizeof (mib2_ipv6AddrEntry_t)) { 3126 fail(0, "No compatible interfaces"); 3127 } 3128 3129 /* 3130 * 'for' loop 2e: find the "right" entry: 3131 * If an interface name to match has been 3132 * supplied then try and find it, otherwise 3133 * match the first non-loopback interface found. 3134 * Use lo0 if all else fails. 3135 */ 3136 for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 3137 (char *)ap6 < (char *)item->valp 3138 + item->length; 3139 ap6++) { 3140 (void) octetstr(&ap6->ipv6AddrIfIndex, 3141 'a', ifname, sizeof (ifname)); 3142 (void) strtok(ifname, ":"); 3143 3144 if (matchname) { 3145 if (strcmp(matchname, 3146 ifname) == 0) { 3147 /* 'for' loop 2e */ 3148 found_if = B_TRUE; 3149 break; 3150 } 3151 } else if (strcmp(ifname, "lo0") != 0) 3152 break; /* 'for' loop 2e */ 3153 } /* 'for' loop 2e ends */ 3154 3155 if (matchname == NULL) { 3156 matchname = ifname; 3157 } else { 3158 if (!found_if) 3159 fail(0, "-I: %s no such " 3160 "interface.", matchname); 3161 } 3162 3163 if (Iflag_only == 0 || !reentry) { 3164 (void) printf( 3165 " input %-6.6s" 3166 " output ", 3167 matchname); 3168 (void) printf(" input (Total)" 3169 " output\n"); 3170 (void) printf("%-7.7s %-5.5s %-7.7s " 3171 "%-5.5s %-6.6s ", 3172 "packets", "errs", "packets", 3173 "errs", "colls"); 3174 (void) printf("%-7.7s %-5.5s %-7.7s " 3175 "%-5.5s %-6.6s\n", 3176 "packets", "errs", "packets", 3177 "errs", "colls"); 3178 } 3179 3180 sum6 = zerostat; 3181 3182 /* 'for' loop 2f: */ 3183 for (ap6 = (mib2_ipv6AddrEntry_t *)item->valp; 3184 (char *)ap6 < (char *)item->valp 3185 + item->length; 3186 ap6++) { 3187 (void) octetstr(&ap6->ipv6AddrIfIndex, 3188 'a', buf, sizeof (buf)); 3189 (void) strtok(buf, ":"); 3190 3191 /* 3192 * We have reduced the IP interface 3193 * name, which could have been a 3194 * logical, down to a name suitable 3195 * for use with kstats. 3196 * We treat this name as unique and 3197 * only collate statistics for it once 3198 * per pass. This is to avoid falsely 3199 * amplifying these statistics by the 3200 * the number of logical instances. 3201 */ 3202 3203 if ((tlp != NULL) && 3204 ((strcmp(buf, tlp->ifname) == 0))) { 3205 continue; 3206 } 3207 3208 /* 3209 * First lookup the "link" kstats in 3210 * case the link is renamed. Then 3211 * fallback to the legacy kstats for 3212 * those non-GLDv3 links. 3213 */ 3214 if (((ksp = kstat_lookup(kc, "link", 3215 0, buf)) != NULL || 3216 (ksp = kstat_lookup(kc, NULL, -1, 3217 buf)) != NULL) && (ksp->ks_type == 3218 KSTAT_TYPE_NAMED)) { 3219 (void) safe_kstat_read(kc, 3220 ksp, NULL); 3221 } 3222 3223 t.ipackets = kstat_named_value(ksp, 3224 "ipackets"); 3225 t.ierrors = kstat_named_value(ksp, 3226 "ierrors"); 3227 t.opackets = kstat_named_value(ksp, 3228 "opackets"); 3229 t.oerrors = kstat_named_value(ksp, 3230 "oerrors"); 3231 t.collisions = kstat_named_value(ksp, 3232 "collisions"); 3233 3234 if (strcmp(buf, matchname) == 0) 3235 new6 = t; 3236 3237 /* Build the interface list */ 3238 3239 tlp = malloc(sizeof (struct iflist)); 3240 (void) strlcpy(tlp->ifname, buf, 3241 sizeof (tlp->ifname)); 3242 tlp->tot = t; 3243 *nextnew = tlp; 3244 nextnew = &tlp->next_if; 3245 3246 /* 3247 * First time through. 3248 * Just add up the interface stats. 3249 */ 3250 3251 if (oldlist6 == NULL) { 3252 if_stat_total(&zerostat, 3253 &t, &sum6); 3254 continue; 3255 } 3256 3257 /* 3258 * Walk old list for the interface. 3259 * 3260 * If found, add difference to total. 3261 * 3262 * If not, an interface has been plumbed 3263 * up. In this case, we will simply 3264 * ignore the new interface until the 3265 * next interval; as there's no easy way 3266 * to acquire statistics between time 3267 * of the plumb and the next interval 3268 * boundary. This results in inaccurate 3269 * total values for current interval. 3270 * 3271 * Note the case when an interface is 3272 * unplumbed; as similar problems exist. 3273 * The unplumbed interface is not in the 3274 * current list, and there's no easy way 3275 * to account for the statistics between 3276 * the previous interval and time of the 3277 * unplumb. Therefore, we (in a sense) 3278 * ignore the removed interface by only 3279 * involving "current" interfaces when 3280 * computing the total statistics. 3281 * Unfortunately, this also results in 3282 * inaccurate values for interval total. 3283 */ 3284 3285 for (walkold = oldlist6; 3286 walkold != NULL; 3287 walkold = walkold->next_if) { 3288 if (strcmp(walkold->ifname, 3289 buf) == 0) { 3290 if_stat_total( 3291 &walkold->tot, 3292 &t, &sum6); 3293 break; 3294 } 3295 } 3296 3297 } /* 'for' loop 2f ends */ 3298 3299 *nextnew = NULL; 3300 3301 (void) printf("%-7llu %-5llu %-7llu " 3302 "%-5llu %-6llu ", 3303 new6.ipackets - old6.ipackets, 3304 new6.ierrors - old6.ierrors, 3305 new6.opackets - old6.opackets, 3306 new6.oerrors - old6.oerrors, 3307 new6.collisions - old6.collisions); 3308 3309 (void) printf("%-7llu %-5llu %-7llu " 3310 "%-5llu %-6llu\n", sum6.ipackets, 3311 sum6.ierrors, sum6.opackets, 3312 sum6.oerrors, sum6.collisions); 3313 3314 /* 3315 * Tidy things up once finished. 3316 */ 3317 3318 old6 = new6; 3319 cleanlist = oldlist6; 3320 oldlist6 = newlist6; 3321 while (cleanlist != NULL) { 3322 tlp = cleanlist->next_if; 3323 free(cleanlist); 3324 cleanlist = tlp; 3325 } 3326 } 3327 break; 3328 } 3329 } 3330 (void) fflush(stdout); 3331 } /* 'for' loop 1 ends */ 3332 if ((Iflag_only == 0) && (!once_only)) 3333 (void) putchar('\n'); 3334 reentry = B_TRUE; 3335 } 3336 3337 static void 3338 if_report_ip4(mib2_ipAddrEntry_t *ap, 3339 char ifname[], char logintname[], struct ifstat *statptr, 3340 boolean_t ksp_not_null) 3341 { 3342 3343 char abuf[MAXHOSTNAMELEN + 1]; 3344 char dstbuf[MAXHOSTNAMELEN + 1]; 3345 3346 if (ksp_not_null) { 3347 (void) printf("%-5s %-4u ", 3348 ifname, ap->ipAdEntInfo.ae_mtu); 3349 if (ap->ipAdEntInfo.ae_flags & IFF_POINTOPOINT) 3350 (void) pr_addr(ap->ipAdEntInfo.ae_pp_dst_addr, 3351 abuf, sizeof (abuf)); 3352 else 3353 (void) pr_netaddr(ap->ipAdEntAddr, 3354 ap->ipAdEntNetMask, abuf, sizeof (abuf)); 3355 (void) printf("%-13s %-14s %-6llu %-5llu %-6llu %-5llu " 3356 "%-6llu %-6llu\n", 3357 abuf, pr_addr(ap->ipAdEntAddr, dstbuf, sizeof (dstbuf)), 3358 statptr->ipackets, statptr->ierrors, 3359 statptr->opackets, statptr->oerrors, 3360 statptr->collisions, 0LL); 3361 } 3362 /* 3363 * Print logical interface info if Aflag set (including logical unit 0) 3364 */ 3365 if (Aflag) { 3366 *statptr = zerostat; 3367 statptr->ipackets = ap->ipAdEntInfo.ae_ibcnt; 3368 statptr->opackets = ap->ipAdEntInfo.ae_obcnt; 3369 3370 (void) printf("%-5s %-4u ", logintname, ap->ipAdEntInfo.ae_mtu); 3371 if (ap->ipAdEntInfo.ae_flags & IFF_POINTOPOINT) 3372 (void) pr_addr(ap->ipAdEntInfo.ae_pp_dst_addr, abuf, 3373 sizeof (abuf)); 3374 else 3375 (void) pr_netaddr(ap->ipAdEntAddr, ap->ipAdEntNetMask, 3376 abuf, sizeof (abuf)); 3377 3378 (void) printf("%-13s %-14s %-6llu %-5s %-6s " 3379 "%-5s %-6s %-6llu\n", abuf, 3380 pr_addr(ap->ipAdEntAddr, dstbuf, sizeof (dstbuf)), 3381 statptr->ipackets, "N/A", "N/A", "N/A", "N/A", 3382 0LL); 3383 } 3384 } 3385 3386 static void 3387 if_report_ip6(mib2_ipv6AddrEntry_t *ap6, 3388 char ifname[], char logintname[], struct ifstat *statptr, 3389 boolean_t ksp_not_null) 3390 { 3391 3392 char abuf[MAXHOSTNAMELEN + 1]; 3393 char dstbuf[MAXHOSTNAMELEN + 1]; 3394 3395 if (ksp_not_null) { 3396 (void) printf("%-5s %-4u ", ifname, ap6->ipv6AddrInfo.ae_mtu); 3397 if (ap6->ipv6AddrInfo.ae_flags & 3398 IFF_POINTOPOINT) { 3399 (void) pr_addr6(&ap6->ipv6AddrInfo.ae_pp_dst_addr, 3400 abuf, sizeof (abuf)); 3401 } else { 3402 (void) pr_prefix6(&ap6->ipv6AddrAddress, 3403 ap6->ipv6AddrPfxLength, abuf, 3404 sizeof (abuf)); 3405 } 3406 (void) printf("%-27s %-27s %-6llu %-5llu " 3407 "%-6llu %-5llu %-6llu\n", 3408 abuf, pr_addr6(&ap6->ipv6AddrAddress, dstbuf, 3409 sizeof (dstbuf)), 3410 statptr->ipackets, statptr->ierrors, statptr->opackets, 3411 statptr->oerrors, statptr->collisions); 3412 } 3413 /* 3414 * Print logical interface info if Aflag set (including logical unit 0) 3415 */ 3416 if (Aflag) { 3417 *statptr = zerostat; 3418 statptr->ipackets = ap6->ipv6AddrInfo.ae_ibcnt; 3419 statptr->opackets = ap6->ipv6AddrInfo.ae_obcnt; 3420 3421 (void) printf("%-5s %-4u ", logintname, 3422 ap6->ipv6AddrInfo.ae_mtu); 3423 if (ap6->ipv6AddrInfo.ae_flags & IFF_POINTOPOINT) 3424 (void) pr_addr6(&ap6->ipv6AddrInfo.ae_pp_dst_addr, 3425 abuf, sizeof (abuf)); 3426 else 3427 (void) pr_prefix6(&ap6->ipv6AddrAddress, 3428 ap6->ipv6AddrPfxLength, abuf, sizeof (abuf)); 3429 (void) printf("%-27s %-27s %-6llu %-5s %-6s %-5s %-6s\n", 3430 abuf, pr_addr6(&ap6->ipv6AddrAddress, dstbuf, 3431 sizeof (dstbuf)), 3432 statptr->ipackets, "N/A", "N/A", "N/A", "N/A"); 3433 } 3434 } 3435 3436 /* --------------------- DHCP_REPORT (netstat -D) ------------------------- */ 3437 3438 static boolean_t 3439 dhcp_do_ipc(dhcp_ipc_type_t type, const char *ifname, boolean_t printed_one) 3440 { 3441 dhcp_ipc_request_t *request; 3442 dhcp_ipc_reply_t *reply; 3443 int error; 3444 3445 request = dhcp_ipc_alloc_request(type, ifname, NULL, 0, DHCP_TYPE_NONE); 3446 if (request == NULL) 3447 fail(0, "dhcp_do_ipc: out of memory"); 3448 3449 error = dhcp_ipc_make_request(request, &reply, DHCP_IPC_WAIT_DEFAULT); 3450 if (error != 0) { 3451 free(request); 3452 fail(0, "dhcp_do_ipc: %s", dhcp_ipc_strerror(error)); 3453 } 3454 3455 free(request); 3456 error = reply->return_code; 3457 if (error == DHCP_IPC_E_UNKIF) { 3458 free(reply); 3459 return (printed_one); 3460 } 3461 if (error != 0) { 3462 free(reply); 3463 fail(0, "dhcp_do_ipc: %s", dhcp_ipc_strerror(error)); 3464 } 3465 3466 if (timestamp_fmt != NODATE) 3467 print_timestamp(timestamp_fmt); 3468 3469 if (!printed_one) 3470 (void) printf("%s", dhcp_status_hdr_string()); 3471 3472 (void) printf("%s", dhcp_status_reply_to_string(reply)); 3473 free(reply); 3474 return (B_TRUE); 3475 } 3476 3477 /* 3478 * dhcp_walk_interfaces: walk the list of interfaces for a given address 3479 * family (af). For each, print out the DHCP status using dhcp_do_ipc. 3480 */ 3481 static boolean_t 3482 dhcp_walk_interfaces(int af, boolean_t printed_one) 3483 { 3484 struct lifnum lifn; 3485 struct lifconf lifc; 3486 int n_ifs, i, sock_fd; 3487 3488 sock_fd = socket(af, SOCK_DGRAM, 0); 3489 if (sock_fd == -1) 3490 return (printed_one); 3491 3492 /* 3493 * SIOCGLIFNUM is just an estimate. If the ioctl fails, we don't care; 3494 * just drive on and use SIOCGLIFCONF with increasing buffer sizes, as 3495 * is traditional. 3496 */ 3497 (void) memset(&lifn, 0, sizeof (lifn)); 3498 lifn.lifn_family = af; 3499 lifn.lifn_flags = LIFC_ALLZONES | LIFC_NOXMIT | LIFC_UNDER_IPMP; 3500 if (ioctl(sock_fd, SIOCGLIFNUM, &lifn) == -1) 3501 n_ifs = LIFN_GUARD_VALUE; 3502 else 3503 n_ifs = lifn.lifn_count + LIFN_GUARD_VALUE; 3504 3505 (void) memset(&lifc, 0, sizeof (lifc)); 3506 lifc.lifc_family = af; 3507 lifc.lifc_flags = lifn.lifn_flags; 3508 lifc.lifc_len = n_ifs * sizeof (struct lifreq); 3509 lifc.lifc_buf = malloc(lifc.lifc_len); 3510 if (lifc.lifc_buf != NULL) { 3511 3512 if (ioctl(sock_fd, SIOCGLIFCONF, &lifc) == -1) { 3513 (void) close(sock_fd); 3514 free(lifc.lifc_buf); 3515 return (NULL); 3516 } 3517 3518 n_ifs = lifc.lifc_len / sizeof (struct lifreq); 3519 3520 for (i = 0; i < n_ifs; i++) { 3521 printed_one = dhcp_do_ipc(DHCP_STATUS | 3522 (af == AF_INET6 ? DHCP_V6 : 0), 3523 lifc.lifc_req[i].lifr_name, printed_one); 3524 } 3525 } 3526 (void) close(sock_fd); 3527 free(lifc.lifc_buf); 3528 return (printed_one); 3529 } 3530 3531 static void 3532 dhcp_report(char *ifname) 3533 { 3534 boolean_t printed_one; 3535 3536 if (!family_selected(AF_INET) && !family_selected(AF_INET6)) 3537 return; 3538 3539 printed_one = B_FALSE; 3540 if (ifname != NULL) { 3541 if (family_selected(AF_INET)) { 3542 printed_one = dhcp_do_ipc(DHCP_STATUS, ifname, 3543 printed_one); 3544 } 3545 if (family_selected(AF_INET6)) { 3546 printed_one = dhcp_do_ipc(DHCP_STATUS | DHCP_V6, 3547 ifname, printed_one); 3548 } 3549 if (!printed_one) { 3550 fail(0, "%s: %s", ifname, 3551 dhcp_ipc_strerror(DHCP_IPC_E_UNKIF)); 3552 } 3553 } else { 3554 if (family_selected(AF_INET)) { 3555 printed_one = dhcp_walk_interfaces(AF_INET, 3556 printed_one); 3557 } 3558 if (family_selected(AF_INET6)) 3559 (void) dhcp_walk_interfaces(AF_INET6, printed_one); 3560 } 3561 } 3562 3563 /* --------------------- GROUP_REPORT (netstat -g) ------------------------- */ 3564 3565 static void 3566 group_report(mib_item_t *item) 3567 { 3568 mib_item_t *v4grp = NULL, *v4src = NULL; 3569 mib_item_t *v6grp = NULL, *v6src = NULL; 3570 int jtemp = 0; 3571 char ifname[LIFNAMSIZ + 1]; 3572 char abuf[MAXHOSTNAMELEN + 1]; 3573 ip_member_t *ipmp; 3574 ip_grpsrc_t *ips; 3575 ipv6_member_t *ipmp6; 3576 ipv6_grpsrc_t *ips6; 3577 boolean_t first, first_src; 3578 3579 /* 'for' loop 1: */ 3580 for (; item; item = item->next_item) { 3581 if (Xflag) { 3582 (void) printf("\n--- Entry %d ---\n", ++jtemp); 3583 (void) printf("Group = %d, mib_id = %d, " 3584 "length = %d, valp = 0x%p\n", 3585 item->group, item->mib_id, item->length, 3586 item->valp); 3587 } 3588 if (item->group == MIB2_IP && family_selected(AF_INET)) { 3589 switch (item->mib_id) { 3590 case EXPER_IP_GROUP_MEMBERSHIP: 3591 v4grp = item; 3592 if (Xflag) 3593 (void) printf("item is v4grp info\n"); 3594 break; 3595 case EXPER_IP_GROUP_SOURCES: 3596 v4src = item; 3597 if (Xflag) 3598 (void) printf("item is v4src info\n"); 3599 break; 3600 default: 3601 continue; 3602 } 3603 continue; 3604 } 3605 if (item->group == MIB2_IP6 && family_selected(AF_INET6)) { 3606 switch (item->mib_id) { 3607 case EXPER_IP6_GROUP_MEMBERSHIP: 3608 v6grp = item; 3609 if (Xflag) 3610 (void) printf("item is v6grp info\n"); 3611 break; 3612 case EXPER_IP6_GROUP_SOURCES: 3613 v6src = item; 3614 if (Xflag) 3615 (void) printf("item is v6src info\n"); 3616 break; 3617 default: 3618 continue; 3619 } 3620 } 3621 } 3622 3623 if (family_selected(AF_INET) && v4grp != NULL) { 3624 if (Xflag) 3625 (void) printf("%u records for ipGroupMember:\n", 3626 v4grp->length / sizeof (ip_member_t)); 3627 3628 first = B_TRUE; 3629 for (ipmp = (ip_member_t *)v4grp->valp; 3630 (char *)ipmp < (char *)v4grp->valp + v4grp->length; 3631 /* LINTED: (note 1) */ 3632 ipmp = (ip_member_t *)((char *)ipmp + ipMemberEntrySize)) { 3633 if (first) { 3634 (void) puts(v4compat ? 3635 "Group Memberships" : 3636 "Group Memberships: IPv4"); 3637 (void) puts("Interface " 3638 "Group RefCnt"); 3639 (void) puts("--------- " 3640 "-------------------- ------"); 3641 first = B_FALSE; 3642 } 3643 3644 (void) printf("%-9s %-20s %6u\n", 3645 octetstr(&ipmp->ipGroupMemberIfIndex, 'a', 3646 ifname, sizeof (ifname)), 3647 pr_addr(ipmp->ipGroupMemberAddress, 3648 abuf, sizeof (abuf)), 3649 ipmp->ipGroupMemberRefCnt); 3650 3651 3652 if (!Vflag || v4src == NULL) 3653 continue; 3654 3655 if (Xflag) 3656 (void) printf("scanning %u ipGroupSource " 3657 "records...\n", 3658 v4src->length/sizeof (ip_grpsrc_t)); 3659 3660 first_src = B_TRUE; 3661 for (ips = (ip_grpsrc_t *)v4src->valp; 3662 (char *)ips < (char *)v4src->valp + v4src->length; 3663 /* LINTED: (note 1) */ 3664 ips = (ip_grpsrc_t *)((char *)ips + 3665 ipGroupSourceEntrySize)) { 3666 /* 3667 * We assume that all source addrs for a given 3668 * interface/group pair are contiguous, so on 3669 * the first non-match after we've found at 3670 * least one, we bail. 3671 */ 3672 if ((ipmp->ipGroupMemberAddress != 3673 ips->ipGroupSourceGroup) || 3674 (!octetstrmatch(&ipmp->ipGroupMemberIfIndex, 3675 &ips->ipGroupSourceIfIndex))) { 3676 if (first_src) 3677 continue; 3678 else 3679 break; 3680 } 3681 if (first_src) { 3682 (void) printf("\t%s: %s\n", 3683 fmodestr( 3684 ipmp->ipGroupMemberFilterMode), 3685 pr_addr(ips->ipGroupSourceAddress, 3686 abuf, sizeof (abuf))); 3687 first_src = B_FALSE; 3688 continue; 3689 } 3690 3691 (void) printf("\t %s\n", 3692 pr_addr(ips->ipGroupSourceAddress, abuf, 3693 sizeof (abuf))); 3694 } 3695 } 3696 (void) putchar('\n'); 3697 } 3698 3699 if (family_selected(AF_INET6) && v6grp != NULL) { 3700 if (Xflag) 3701 (void) printf("%u records for ipv6GroupMember:\n", 3702 v6grp->length / sizeof (ipv6_member_t)); 3703 3704 first = B_TRUE; 3705 for (ipmp6 = (ipv6_member_t *)v6grp->valp; 3706 (char *)ipmp6 < (char *)v6grp->valp + v6grp->length; 3707 /* LINTED: (note 1) */ 3708 ipmp6 = (ipv6_member_t *)((char *)ipmp6 + 3709 ipv6MemberEntrySize)) { 3710 if (first) { 3711 (void) puts("Group Memberships: " 3712 "IPv6"); 3713 (void) puts(" If " 3714 "Group RefCnt"); 3715 (void) puts("----- " 3716 "--------------------------- ------"); 3717 first = B_FALSE; 3718 } 3719 3720 (void) printf("%-5s %-27s %5u\n", 3721 ifindex2str(ipmp6->ipv6GroupMemberIfIndex, ifname), 3722 pr_addr6(&ipmp6->ipv6GroupMemberAddress, 3723 abuf, sizeof (abuf)), 3724 ipmp6->ipv6GroupMemberRefCnt); 3725 3726 if (!Vflag || v6src == NULL) 3727 continue; 3728 3729 if (Xflag) 3730 (void) printf("scanning %u ipv6GroupSource " 3731 "records...\n", 3732 v6src->length/sizeof (ipv6_grpsrc_t)); 3733 3734 first_src = B_TRUE; 3735 for (ips6 = (ipv6_grpsrc_t *)v6src->valp; 3736 (char *)ips6 < (char *)v6src->valp + v6src->length; 3737 /* LINTED: (note 1) */ 3738 ips6 = (ipv6_grpsrc_t *)((char *)ips6 + 3739 ipv6GroupSourceEntrySize)) { 3740 /* same assumption as in the v4 case above */ 3741 if ((ipmp6->ipv6GroupMemberIfIndex != 3742 ips6->ipv6GroupSourceIfIndex) || 3743 (!IN6_ARE_ADDR_EQUAL( 3744 &ipmp6->ipv6GroupMemberAddress, 3745 &ips6->ipv6GroupSourceGroup))) { 3746 if (first_src) 3747 continue; 3748 else 3749 break; 3750 } 3751 if (first_src) { 3752 (void) printf("\t%s: %s\n", 3753 fmodestr( 3754 ipmp6->ipv6GroupMemberFilterMode), 3755 pr_addr6( 3756 &ips6->ipv6GroupSourceAddress, 3757 abuf, sizeof (abuf))); 3758 first_src = B_FALSE; 3759 continue; 3760 } 3761 3762 (void) printf("\t %s\n", 3763 pr_addr6(&ips6->ipv6GroupSourceAddress, 3764 abuf, sizeof (abuf))); 3765 } 3766 } 3767 (void) putchar('\n'); 3768 } 3769 3770 (void) putchar('\n'); 3771 (void) fflush(stdout); 3772 } 3773 3774 /* --------------------- DCE_REPORT (netstat -d) ------------------------- */ 3775 3776 #define FLBUFSIZE 8 3777 3778 /* Assumes flbuf is at least 5 characters; callers use FLBUFSIZE */ 3779 static char * 3780 dceflags2str(uint32_t flags, char *flbuf) 3781 { 3782 char *str = flbuf; 3783 3784 if (flags & DCEF_DEFAULT) 3785 *str++ = 'D'; 3786 if (flags & DCEF_PMTU) 3787 *str++ = 'P'; 3788 if (flags & DCEF_UINFO) 3789 *str++ = 'U'; 3790 if (flags & DCEF_TOO_SMALL_PMTU) 3791 *str++ = 'S'; 3792 *str++ = '\0'; 3793 return (flbuf); 3794 } 3795 3796 static void 3797 dce_report(mib_item_t *item) 3798 { 3799 mib_item_t *v4dce = NULL; 3800 mib_item_t *v6dce = NULL; 3801 int jtemp = 0; 3802 char ifname[LIFNAMSIZ + 1]; 3803 char abuf[MAXHOSTNAMELEN + 1]; 3804 char flbuf[FLBUFSIZE]; 3805 boolean_t first; 3806 dest_cache_entry_t *dce; 3807 3808 /* 'for' loop 1: */ 3809 for (; item; item = item->next_item) { 3810 if (Xflag) { 3811 (void) printf("\n--- Entry %d ---\n", ++jtemp); 3812 (void) printf("Group = %d, mib_id = %d, " 3813 "length = %d, valp = 0x%p\n", 3814 item->group, item->mib_id, item->length, 3815 item->valp); 3816 } 3817 if (item->group == MIB2_IP && family_selected(AF_INET) && 3818 item->mib_id == EXPER_IP_DCE) { 3819 v4dce = item; 3820 if (Xflag) 3821 (void) printf("item is v4dce info\n"); 3822 } 3823 if (item->group == MIB2_IP6 && family_selected(AF_INET6) && 3824 item->mib_id == EXPER_IP_DCE) { 3825 v6dce = item; 3826 if (Xflag) 3827 (void) printf("item is v6dce info\n"); 3828 } 3829 } 3830 3831 if (family_selected(AF_INET) && v4dce != NULL) { 3832 if (Xflag) 3833 (void) printf("%u records for DestCacheEntry:\n", 3834 v4dce->length / ipDestEntrySize); 3835 3836 first = B_TRUE; 3837 for (dce = (dest_cache_entry_t *)v4dce->valp; 3838 (char *)dce < (char *)v4dce->valp + v4dce->length; 3839 /* LINTED: (note 1) */ 3840 dce = (dest_cache_entry_t *)((char *)dce + 3841 ipDestEntrySize)) { 3842 if (first) { 3843 (void) putchar('\n'); 3844 (void) puts("Destination Cache Entries: IPv4"); 3845 (void) puts( 3846 "Address PMTU Age Flags"); 3847 (void) puts( 3848 "-------------------- ------ ----- -----"); 3849 first = B_FALSE; 3850 } 3851 3852 (void) printf("%-20s %6u %5u %-5s\n", 3853 pr_addr(dce->DestIpv4Address, abuf, sizeof (abuf)), 3854 dce->DestPmtu, dce->DestAge, 3855 dceflags2str(dce->DestFlags, flbuf)); 3856 } 3857 } 3858 3859 if (family_selected(AF_INET6) && v6dce != NULL) { 3860 if (Xflag) 3861 (void) printf("%u records for DestCacheEntry:\n", 3862 v6dce->length / ipDestEntrySize); 3863 3864 first = B_TRUE; 3865 for (dce = (dest_cache_entry_t *)v6dce->valp; 3866 (char *)dce < (char *)v6dce->valp + v6dce->length; 3867 /* LINTED: (note 1) */ 3868 dce = (dest_cache_entry_t *)((char *)dce + 3869 ipDestEntrySize)) { 3870 if (first) { 3871 (void) putchar('\n'); 3872 (void) puts("Destination Cache Entries: IPv6"); 3873 (void) puts( 3874 "Address PMTU " 3875 " Age Flags If "); 3876 (void) puts( 3877 "--------------------------- ------ " 3878 "----- ----- ---"); 3879 first = B_FALSE; 3880 } 3881 3882 (void) printf("%-27s %6u %5u %-5s %s\n", 3883 pr_addr6(&dce->DestIpv6Address, abuf, 3884 sizeof (abuf)), 3885 dce->DestPmtu, dce->DestAge, 3886 dceflags2str(dce->DestFlags, flbuf), 3887 dce->DestIfindex == 0 ? "" : 3888 ifindex2str(dce->DestIfindex, ifname)); 3889 } 3890 } 3891 (void) fflush(stdout); 3892 } 3893 3894 /* --------------------- ARP_REPORT (netstat -p) -------------------------- */ 3895 3896 static void 3897 arp_report(mib_item_t *item) 3898 { 3899 int jtemp = 0; 3900 char ifname[LIFNAMSIZ + 1]; 3901 char abuf[MAXHOSTNAMELEN + 1]; 3902 char maskbuf[STR_EXPAND * OCTET_LENGTH + 1]; 3903 char flbuf[32]; /* ACE_F_ flags */ 3904 char xbuf[STR_EXPAND * OCTET_LENGTH + 1]; 3905 mib2_ipNetToMediaEntry_t *np; 3906 int flags; 3907 boolean_t first; 3908 3909 if (!(family_selected(AF_INET))) 3910 return; 3911 3912 /* 'for' loop 1: */ 3913 for (; item; item = item->next_item) { 3914 if (Xflag) { 3915 (void) printf("\n--- Entry %d ---\n", ++jtemp); 3916 (void) printf("Group = %d, mib_id = %d, " 3917 "length = %d, valp = 0x%p\n", 3918 item->group, item->mib_id, item->length, 3919 item->valp); 3920 } 3921 if (!(item->group == MIB2_IP && item->mib_id == MIB2_IP_MEDIA)) 3922 continue; /* 'for' loop 1 */ 3923 3924 if (Xflag) 3925 (void) printf("%u records for " 3926 "ipNetToMediaEntryTable:\n", 3927 item->length/sizeof (mib2_ipNetToMediaEntry_t)); 3928 3929 first = B_TRUE; 3930 /* 'for' loop 2: */ 3931 for (np = (mib2_ipNetToMediaEntry_t *)item->valp; 3932 (char *)np < (char *)item->valp + item->length; 3933 /* LINTED: (note 1) */ 3934 np = (mib2_ipNetToMediaEntry_t *)((char *)np + 3935 ipNetToMediaEntrySize)) { 3936 if (first) { 3937 (void) puts(v4compat ? 3938 "Net to Media Table" : 3939 "Net to Media Table: IPv4"); 3940 (void) puts("Device " 3941 " IP Address Mask " 3942 "Flags Phys Addr"); 3943 (void) puts("------ " 3944 "-------------------- --------------- " 3945 "-------- ---------------"); 3946 first = B_FALSE; 3947 } 3948 3949 flbuf[0] = '\0'; 3950 flags = np->ipNetToMediaInfo.ntm_flags; 3951 /* 3952 * Note that not all flags are possible at the same 3953 * time. Patterns: SPLAy DUo 3954 */ 3955 if (flags & ACE_F_PERMANENT) 3956 (void) strcat(flbuf, "S"); 3957 if (flags & ACE_F_PUBLISH) 3958 (void) strcat(flbuf, "P"); 3959 if (flags & ACE_F_DYING) 3960 (void) strcat(flbuf, "D"); 3961 if (!(flags & ACE_F_RESOLVED)) 3962 (void) strcat(flbuf, "U"); 3963 if (flags & ACE_F_MAPPING) 3964 (void) strcat(flbuf, "M"); 3965 if (flags & ACE_F_MYADDR) 3966 (void) strcat(flbuf, "L"); 3967 if (flags & ACE_F_UNVERIFIED) 3968 (void) strcat(flbuf, "d"); 3969 if (flags & ACE_F_AUTHORITY) 3970 (void) strcat(flbuf, "A"); 3971 if (flags & ACE_F_OLD) 3972 (void) strcat(flbuf, "o"); 3973 if (flags & ACE_F_DELAYED) 3974 (void) strcat(flbuf, "y"); 3975 (void) printf("%-6s %-20s %-15s %-8s %s\n", 3976 octetstr(&np->ipNetToMediaIfIndex, 'a', 3977 ifname, sizeof (ifname)), 3978 pr_addr(np->ipNetToMediaNetAddress, 3979 abuf, sizeof (abuf)), 3980 octetstr(&np->ipNetToMediaInfo.ntm_mask, 'd', 3981 maskbuf, sizeof (maskbuf)), 3982 flbuf, 3983 octetstr(&np->ipNetToMediaPhysAddress, 'h', 3984 xbuf, sizeof (xbuf))); 3985 } /* 'for' loop 2 ends */ 3986 } /* 'for' loop 1 ends */ 3987 (void) fflush(stdout); 3988 } 3989 3990 /* --------------------- NDP_REPORT (netstat -p) -------------------------- */ 3991 3992 static void 3993 ndp_report(mib_item_t *item) 3994 { 3995 int jtemp = 0; 3996 char abuf[MAXHOSTNAMELEN + 1]; 3997 char *state; 3998 char *type; 3999 char xbuf[STR_EXPAND * OCTET_LENGTH + 1]; 4000 mib2_ipv6NetToMediaEntry_t *np6; 4001 char ifname[LIFNAMSIZ + 1]; 4002 boolean_t first; 4003 4004 if (!(family_selected(AF_INET6))) 4005 return; 4006 4007 /* 'for' loop 1: */ 4008 for (; item; item = item->next_item) { 4009 if (Xflag) { 4010 (void) printf("\n--- Entry %d ---\n", ++jtemp); 4011 (void) printf("Group = %d, mib_id = %d, " 4012 "length = %d, valp = 0x%p\n", 4013 item->group, item->mib_id, item->length, 4014 item->valp); 4015 } 4016 if (!(item->group == MIB2_IP6 && 4017 item->mib_id == MIB2_IP6_MEDIA)) 4018 continue; /* 'for' loop 1 */ 4019 4020 first = B_TRUE; 4021 /* 'for' loop 2: */ 4022 for (np6 = (mib2_ipv6NetToMediaEntry_t *)item->valp; 4023 (char *)np6 < (char *)item->valp + item->length; 4024 /* LINTED: (note 1) */ 4025 np6 = (mib2_ipv6NetToMediaEntry_t *)((char *)np6 + 4026 ipv6NetToMediaEntrySize)) { 4027 if (first) { 4028 (void) puts("\nNet to Media Table: IPv6"); 4029 (void) puts(" If Physical Address " 4030 " Type State Destination/Mask"); 4031 (void) puts("----- ----------------- " 4032 "------- ------------ " 4033 "---------------------------"); 4034 first = B_FALSE; 4035 } 4036 4037 switch (np6->ipv6NetToMediaState) { 4038 case ND_INCOMPLETE: 4039 state = "INCOMPLETE"; 4040 break; 4041 case ND_REACHABLE: 4042 state = "REACHABLE"; 4043 break; 4044 case ND_STALE: 4045 state = "STALE"; 4046 break; 4047 case ND_DELAY: 4048 state = "DELAY"; 4049 break; 4050 case ND_PROBE: 4051 state = "PROBE"; 4052 break; 4053 case ND_UNREACHABLE: 4054 state = "UNREACHABLE"; 4055 break; 4056 default: 4057 state = "UNKNOWN"; 4058 } 4059 4060 switch (np6->ipv6NetToMediaType) { 4061 case 1: 4062 type = "other"; 4063 break; 4064 case 2: 4065 type = "dynamic"; 4066 break; 4067 case 3: 4068 type = "static"; 4069 break; 4070 case 4: 4071 type = "local"; 4072 break; 4073 } 4074 (void) printf("%-5s %-17s %-7s %-12s %-27s\n", 4075 ifindex2str(np6->ipv6NetToMediaIfIndex, ifname), 4076 octetstr(&np6->ipv6NetToMediaPhysAddress, 'h', 4077 xbuf, sizeof (xbuf)), 4078 type, 4079 state, 4080 pr_addr6(&np6->ipv6NetToMediaNetAddress, 4081 abuf, sizeof (abuf))); 4082 } /* 'for' loop 2 ends */ 4083 } /* 'for' loop 1 ends */ 4084 (void) putchar('\n'); 4085 (void) fflush(stdout); 4086 } 4087 4088 /* ------------------------- ire_report (netstat -r) ------------------------ */ 4089 4090 typedef struct sec_attr_list_s { 4091 struct sec_attr_list_s *sal_next; 4092 const mib2_ipAttributeEntry_t *sal_attr; 4093 } sec_attr_list_t; 4094 4095 static boolean_t ire_report_item_v4(const mib2_ipRouteEntry_t *, boolean_t, 4096 const sec_attr_list_t *); 4097 static boolean_t ire_report_item_v6(const mib2_ipv6RouteEntry_t *, boolean_t, 4098 const sec_attr_list_t *); 4099 static const char *pr_secattr(const sec_attr_list_t *); 4100 4101 static void 4102 ire_report(const mib_item_t *item) 4103 { 4104 int jtemp = 0; 4105 boolean_t print_hdr_once_v4 = B_TRUE; 4106 boolean_t print_hdr_once_v6 = B_TRUE; 4107 mib2_ipRouteEntry_t *rp; 4108 mib2_ipv6RouteEntry_t *rp6; 4109 sec_attr_list_t **v4_attrs, **v4a; 4110 sec_attr_list_t **v6_attrs, **v6a; 4111 sec_attr_list_t *all_attrs, *aptr; 4112 const mib_item_t *iptr; 4113 int ipv4_route_count, ipv6_route_count; 4114 int route_attrs_count; 4115 4116 /* 4117 * Preparation pass: the kernel returns separate entries for IP routing 4118 * table entries and security attributes. We loop through the 4119 * attributes first and link them into lists. 4120 */ 4121 ipv4_route_count = ipv6_route_count = route_attrs_count = 0; 4122 for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 4123 if (iptr->group == MIB2_IP6 && iptr->mib_id == MIB2_IP6_ROUTE) 4124 ipv6_route_count += iptr->length / ipv6RouteEntrySize; 4125 if (iptr->group == MIB2_IP && iptr->mib_id == MIB2_IP_ROUTE) 4126 ipv4_route_count += iptr->length / ipRouteEntrySize; 4127 if ((iptr->group == MIB2_IP || iptr->group == MIB2_IP6) && 4128 iptr->mib_id == EXPER_IP_RTATTR) 4129 route_attrs_count += iptr->length / 4130 ipRouteAttributeSize; 4131 } 4132 v4_attrs = v6_attrs = NULL; 4133 all_attrs = NULL; 4134 if (family_selected(AF_INET) && ipv4_route_count > 0) { 4135 v4_attrs = calloc(ipv4_route_count, sizeof (*v4_attrs)); 4136 if (v4_attrs == NULL) { 4137 perror("ire_report calloc v4_attrs failed"); 4138 return; 4139 } 4140 } 4141 if (family_selected(AF_INET6) && ipv6_route_count > 0) { 4142 v6_attrs = calloc(ipv6_route_count, sizeof (*v6_attrs)); 4143 if (v6_attrs == NULL) { 4144 perror("ire_report calloc v6_attrs failed"); 4145 goto ire_report_done; 4146 } 4147 } 4148 if (route_attrs_count > 0) { 4149 all_attrs = malloc(route_attrs_count * sizeof (*all_attrs)); 4150 if (all_attrs == NULL) { 4151 perror("ire_report malloc all_attrs failed"); 4152 goto ire_report_done; 4153 } 4154 } 4155 aptr = all_attrs; 4156 for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 4157 mib2_ipAttributeEntry_t *iae; 4158 sec_attr_list_t **alp; 4159 4160 if (v4_attrs != NULL && iptr->group == MIB2_IP && 4161 iptr->mib_id == EXPER_IP_RTATTR) { 4162 alp = v4_attrs; 4163 } else if (v6_attrs != NULL && iptr->group == MIB2_IP6 && 4164 iptr->mib_id == EXPER_IP_RTATTR) { 4165 alp = v6_attrs; 4166 } else { 4167 continue; 4168 } 4169 for (iae = iptr->valp; 4170 (char *)iae < (char *)iptr->valp + iptr->length; 4171 /* LINTED: (note 1) */ 4172 iae = (mib2_ipAttributeEntry_t *)((char *)iae + 4173 ipRouteAttributeSize)) { 4174 aptr->sal_next = alp[iae->iae_routeidx]; 4175 aptr->sal_attr = iae; 4176 alp[iae->iae_routeidx] = aptr++; 4177 } 4178 } 4179 4180 /* 'for' loop 1: */ 4181 v4a = v4_attrs; 4182 v6a = v6_attrs; 4183 for (; item != NULL; item = item->next_item) { 4184 if (Xflag) { 4185 (void) printf("\n--- Entry %d ---\n", ++jtemp); 4186 (void) printf("Group = %d, mib_id = %d, " 4187 "length = %d, valp = 0x%p\n", 4188 item->group, item->mib_id, 4189 item->length, item->valp); 4190 } 4191 if (!((item->group == MIB2_IP && 4192 item->mib_id == MIB2_IP_ROUTE) || 4193 (item->group == MIB2_IP6 && 4194 item->mib_id == MIB2_IP6_ROUTE))) 4195 continue; /* 'for' loop 1 */ 4196 4197 if (item->group == MIB2_IP && !family_selected(AF_INET)) 4198 continue; /* 'for' loop 1 */ 4199 else if (item->group == MIB2_IP6 && !family_selected(AF_INET6)) 4200 continue; /* 'for' loop 1 */ 4201 4202 if (Xflag) { 4203 if (item->group == MIB2_IP) { 4204 (void) printf("%u records for " 4205 "ipRouteEntryTable:\n", 4206 item->length/sizeof (mib2_ipRouteEntry_t)); 4207 } else { 4208 (void) printf("%u records for " 4209 "ipv6RouteEntryTable:\n", 4210 item->length/ 4211 sizeof (mib2_ipv6RouteEntry_t)); 4212 } 4213 } 4214 4215 if (item->group == MIB2_IP) { 4216 for (rp = (mib2_ipRouteEntry_t *)item->valp; 4217 (char *)rp < (char *)item->valp + item->length; 4218 /* LINTED: (note 1) */ 4219 rp = (mib2_ipRouteEntry_t *)((char *)rp + 4220 ipRouteEntrySize)) { 4221 aptr = v4a == NULL ? NULL : *v4a++; 4222 print_hdr_once_v4 = ire_report_item_v4(rp, 4223 print_hdr_once_v4, aptr); 4224 } 4225 } else { 4226 for (rp6 = (mib2_ipv6RouteEntry_t *)item->valp; 4227 (char *)rp6 < (char *)item->valp + item->length; 4228 /* LINTED: (note 1) */ 4229 rp6 = (mib2_ipv6RouteEntry_t *)((char *)rp6 + 4230 ipv6RouteEntrySize)) { 4231 aptr = v6a == NULL ? NULL : *v6a++; 4232 print_hdr_once_v6 = ire_report_item_v6(rp6, 4233 print_hdr_once_v6, aptr); 4234 } 4235 } 4236 } /* 'for' loop 1 ends */ 4237 (void) fflush(stdout); 4238 ire_report_done: 4239 if (v4_attrs != NULL) 4240 free(v4_attrs); 4241 if (v6_attrs != NULL) 4242 free(v6_attrs); 4243 if (all_attrs != NULL) 4244 free(all_attrs); 4245 } 4246 4247 /* 4248 * Match a user-supplied device name. We do this by string because 4249 * the MIB2 interface gives us interface name strings rather than 4250 * ifIndex numbers. The "none" rule matches only routes with no 4251 * interface. The "any" rule matches routes with any non-blank 4252 * interface. A base name ("hme0") matches all aliases as well 4253 * ("hme0:1"). 4254 */ 4255 static boolean_t 4256 dev_name_match(const DeviceName *devnam, const char *ifname) 4257 { 4258 int iflen; 4259 4260 if (ifname == NULL) 4261 return (devnam->o_length == 0); /* "none" */ 4262 if (*ifname == '\0') 4263 return (devnam->o_length != 0); /* "any" */ 4264 iflen = strlen(ifname); 4265 /* The check for ':' here supports interface aliases. */ 4266 if (iflen > devnam->o_length || 4267 (iflen < devnam->o_length && devnam->o_bytes[iflen] != ':')) 4268 return (B_FALSE); 4269 return (strncmp(ifname, devnam->o_bytes, iflen) == 0); 4270 } 4271 4272 /* 4273 * Match a user-supplied IP address list. The "any" rule matches any 4274 * non-zero address. The "none" rule matches only the zero address. 4275 * IPv6 addresses supplied by the user are ignored. If the user 4276 * supplies a subnet mask, then match routes that are at least that 4277 * specific (use the user's mask). If the user supplies only an 4278 * address, then select any routes that would match (use the route's 4279 * mask). 4280 */ 4281 static boolean_t 4282 v4_addr_match(IpAddress addr, IpAddress mask, const filter_t *fp) 4283 { 4284 char **app; 4285 char *aptr; 4286 in_addr_t faddr, fmask; 4287 4288 if (fp->u.a.f_address == NULL) { 4289 if (IN6_IS_ADDR_UNSPECIFIED(&fp->u.a.f_mask)) 4290 return (addr != INADDR_ANY); /* "any" */ 4291 else 4292 return (addr == INADDR_ANY); /* "none" */ 4293 } 4294 if (!IN6_IS_V4MASK(fp->u.a.f_mask)) 4295 return (B_FALSE); 4296 IN6_V4MAPPED_TO_IPADDR(&fp->u.a.f_mask, fmask); 4297 if (fmask != IP_HOST_MASK) { 4298 if (fmask > mask) 4299 return (B_FALSE); 4300 mask = fmask; 4301 } 4302 for (app = fp->u.a.f_address->h_addr_list; (aptr = *app) != NULL; app++) 4303 /* LINTED: (note 1) */ 4304 if (IN6_IS_ADDR_V4MAPPED((in6_addr_t *)aptr)) { 4305 /* LINTED: (note 1) */ 4306 IN6_V4MAPPED_TO_IPADDR((in6_addr_t *)aptr, faddr); 4307 if (((faddr ^ addr) & mask) == 0) 4308 return (B_TRUE); 4309 } 4310 return (B_FALSE); 4311 } 4312 4313 /* 4314 * Run through the filter list for an IPv4 MIB2 route entry. If all 4315 * filters of a given type fail to match, then the route is filtered 4316 * out (not displayed). If no filter is given or at least one filter 4317 * of each type matches, then display the route. 4318 */ 4319 static boolean_t 4320 ire_filter_match_v4(const mib2_ipRouteEntry_t *rp, uint_t flag_b) 4321 { 4322 filter_t *fp; 4323 int idx; 4324 4325 /* 'for' loop 1: */ 4326 for (idx = 0; idx < NFILTERKEYS; idx++) 4327 if ((fp = filters[idx]) != NULL) { 4328 /* 'for' loop 2: */ 4329 for (; fp != NULL; fp = fp->f_next) { 4330 switch (idx) { 4331 case FK_AF: 4332 if (fp->u.f_family != AF_INET) 4333 continue; /* 'for' loop 2 */ 4334 break; 4335 case FK_OUTIF: 4336 if (!dev_name_match(&rp->ipRouteIfIndex, 4337 fp->u.f_ifname)) 4338 continue; /* 'for' loop 2 */ 4339 break; 4340 case FK_DST: 4341 if (!v4_addr_match(rp->ipRouteDest, 4342 rp->ipRouteMask, fp)) 4343 continue; /* 'for' loop 2 */ 4344 break; 4345 case FK_FLAGS: 4346 if ((flag_b & fp->u.f.f_flagset) != 4347 fp->u.f.f_flagset || 4348 (flag_b & fp->u.f.f_flagclear)) 4349 continue; /* 'for' loop 2 */ 4350 break; 4351 } 4352 break; 4353 } /* 'for' loop 2 ends */ 4354 if (fp == NULL) 4355 return (B_FALSE); 4356 } 4357 /* 'for' loop 1 ends */ 4358 return (B_TRUE); 4359 } 4360 4361 /* 4362 * Given an IPv4 MIB2 route entry, form the list of flags for the 4363 * route. 4364 */ 4365 static uint_t 4366 form_v4_route_flags(const mib2_ipRouteEntry_t *rp, char *flags) 4367 { 4368 uint_t flag_b; 4369 4370 flag_b = FLF_U; 4371 (void) strcpy(flags, "U"); 4372 /* RTF_INDIRECT wins over RTF_GATEWAY - don't display both */ 4373 if (rp->ipRouteInfo.re_flags & RTF_INDIRECT) { 4374 (void) strcat(flags, "I"); 4375 flag_b |= FLF_I; 4376 } else if (rp->ipRouteInfo.re_ire_type & IRE_OFFLINK) { 4377 (void) strcat(flags, "G"); 4378 flag_b |= FLF_G; 4379 } 4380 /* IRE_IF_CLONE wins over RTF_HOST - don't display both */ 4381 if (rp->ipRouteInfo.re_ire_type & IRE_IF_CLONE) { 4382 (void) strcat(flags, "C"); 4383 flag_b |= FLF_C; 4384 } else if (rp->ipRouteMask == IP_HOST_MASK) { 4385 (void) strcat(flags, "H"); 4386 flag_b |= FLF_H; 4387 } 4388 if (rp->ipRouteInfo.re_flags & RTF_DYNAMIC) { 4389 (void) strcat(flags, "D"); 4390 flag_b |= FLF_D; 4391 } 4392 if (rp->ipRouteInfo.re_ire_type == IRE_BROADCAST) { /* Broadcast */ 4393 (void) strcat(flags, "b"); 4394 flag_b |= FLF_b; 4395 } 4396 if (rp->ipRouteInfo.re_ire_type == IRE_LOCAL) { /* Local */ 4397 (void) strcat(flags, "L"); 4398 flag_b |= FLF_L; 4399 } 4400 if (rp->ipRouteInfo.re_flags & RTF_MULTIRT) { 4401 (void) strcat(flags, "M"); /* Multiroute */ 4402 flag_b |= FLF_M; 4403 } 4404 if (rp->ipRouteInfo.re_flags & RTF_SETSRC) { 4405 (void) strcat(flags, "S"); /* Setsrc */ 4406 flag_b |= FLF_S; 4407 } 4408 if (rp->ipRouteInfo.re_flags & RTF_REJECT) { 4409 (void) strcat(flags, "R"); 4410 flag_b |= FLF_R; 4411 } 4412 if (rp->ipRouteInfo.re_flags & RTF_BLACKHOLE) { 4413 (void) strcat(flags, "B"); 4414 flag_b |= FLF_B; 4415 } 4416 if (rp->ipRouteInfo.re_flags & RTF_ZONE) { 4417 (void) strcat(flags, "Z"); 4418 flag_b |= FLF_Z; 4419 } 4420 return (flag_b); 4421 } 4422 4423 static const char ire_hdr_v4[] = 4424 "\n%s Table: IPv4\n"; 4425 static const char ire_hdr_v4_compat[] = 4426 "\n%s Table:\n"; 4427 static const char ire_hdr_v4_verbose[] = 4428 " Destination Mask Gateway Device " 4429 " MTU Ref Flg Out In/Fwd %s\n" 4430 "-------------------- --------------- -------------------- ------ " 4431 "----- --- --- ----- ------ %s\n"; 4432 4433 static const char ire_hdr_v4_normal[] = 4434 " Destination Gateway Flags Ref Use Interface" 4435 " %s\n-------------------- -------------------- ----- ----- ---------- " 4436 "--------- %s\n"; 4437 4438 static boolean_t 4439 ire_report_item_v4(const mib2_ipRouteEntry_t *rp, boolean_t first, 4440 const sec_attr_list_t *attrs) 4441 { 4442 char dstbuf[MAXHOSTNAMELEN + 1]; 4443 char maskbuf[MAXHOSTNAMELEN + 1]; 4444 char gwbuf[MAXHOSTNAMELEN + 1]; 4445 char ifname[LIFNAMSIZ + 1]; 4446 char flags[10]; /* RTF_ flags */ 4447 uint_t flag_b; 4448 4449 if (!(Aflag || (rp->ipRouteInfo.re_ire_type != IRE_IF_CLONE && 4450 rp->ipRouteInfo.re_ire_type != IRE_BROADCAST && 4451 rp->ipRouteInfo.re_ire_type != IRE_MULTICAST && 4452 rp->ipRouteInfo.re_ire_type != IRE_NOROUTE && 4453 rp->ipRouteInfo.re_ire_type != IRE_LOCAL))) { 4454 return (first); 4455 } 4456 4457 flag_b = form_v4_route_flags(rp, flags); 4458 4459 if (!ire_filter_match_v4(rp, flag_b)) 4460 return (first); 4461 4462 if (first) { 4463 (void) printf(v4compat ? ire_hdr_v4_compat : ire_hdr_v4, 4464 Vflag ? "IRE" : "Routing"); 4465 (void) printf(Vflag ? ire_hdr_v4_verbose : ire_hdr_v4_normal, 4466 RSECflag ? " Gateway security attributes " : "", 4467 RSECflag ? "-------------------------------" : ""); 4468 first = B_FALSE; 4469 } 4470 4471 if (flag_b & FLF_H) { 4472 (void) pr_addr(rp->ipRouteDest, dstbuf, sizeof (dstbuf)); 4473 } else { 4474 (void) pr_net(rp->ipRouteDest, rp->ipRouteMask, 4475 dstbuf, sizeof (dstbuf)); 4476 } 4477 if (Vflag) { 4478 (void) printf("%-20s %-15s %-20s %-6s %5u %3u " 4479 "%-4s%6u %6u %s\n", 4480 dstbuf, 4481 pr_mask(rp->ipRouteMask, maskbuf, sizeof (maskbuf)), 4482 pr_addrnz(rp->ipRouteNextHop, gwbuf, sizeof (gwbuf)), 4483 octetstr(&rp->ipRouteIfIndex, 'a', ifname, sizeof (ifname)), 4484 rp->ipRouteInfo.re_max_frag, 4485 rp->ipRouteInfo.re_ref, 4486 flags, 4487 rp->ipRouteInfo.re_obpkt, 4488 rp->ipRouteInfo.re_ibpkt, 4489 pr_secattr(attrs)); 4490 } else { 4491 (void) printf("%-20s %-20s %-5s %4u %10u %-9s %s\n", 4492 dstbuf, 4493 pr_addrnz(rp->ipRouteNextHop, gwbuf, sizeof (gwbuf)), 4494 flags, 4495 rp->ipRouteInfo.re_ref, 4496 rp->ipRouteInfo.re_obpkt + rp->ipRouteInfo.re_ibpkt, 4497 octetstr(&rp->ipRouteIfIndex, 'a', 4498 ifname, sizeof (ifname)), 4499 pr_secattr(attrs)); 4500 } 4501 return (first); 4502 } 4503 4504 /* 4505 * Match a user-supplied IP address list against an IPv6 route entry. 4506 * If the user specified "any," then any non-zero address matches. If 4507 * the user specified "none," then only the zero address matches. If 4508 * the user specified a subnet mask length, then use that in matching 4509 * routes (select routes that are at least as specific). If the user 4510 * specified only an address, then use the route's mask (select routes 4511 * that would match that address). IPv4 addresses are ignored. 4512 */ 4513 static boolean_t 4514 v6_addr_match(const Ip6Address *addr, int masklen, const filter_t *fp) 4515 { 4516 const uint8_t *ucp; 4517 int fmasklen; 4518 int i; 4519 char **app; 4520 const uint8_t *aptr; 4521 4522 if (fp->u.a.f_address == NULL) { 4523 if (IN6_IS_ADDR_UNSPECIFIED(&fp->u.a.f_mask)) /* any */ 4524 return (!IN6_IS_ADDR_UNSPECIFIED(addr)); 4525 return (IN6_IS_ADDR_UNSPECIFIED(addr)); /* "none" */ 4526 } 4527 fmasklen = 0; 4528 /* 'for' loop 1a: */ 4529 for (ucp = fp->u.a.f_mask.s6_addr; 4530 ucp < fp->u.a.f_mask.s6_addr + sizeof (fp->u.a.f_mask.s6_addr); 4531 ucp++) { 4532 if (*ucp != 0xff) { 4533 if (*ucp != 0) 4534 fmasklen += 9 - ffs(*ucp); 4535 break; /* 'for' loop 1a */ 4536 } 4537 fmasklen += 8; 4538 } /* 'for' loop 1a ends */ 4539 if (fmasklen != IPV6_ABITS) { 4540 if (fmasklen > masklen) 4541 return (B_FALSE); 4542 masklen = fmasklen; 4543 } 4544 /* 'for' loop 1b: */ 4545 for (app = fp->u.a.f_address->h_addr_list; 4546 (aptr = (uint8_t *)*app) != NULL; app++) { 4547 /* LINTED: (note 1) */ 4548 if (IN6_IS_ADDR_V4MAPPED((in6_addr_t *)aptr)) 4549 continue; /* 'for' loop 1b */ 4550 ucp = addr->s6_addr; 4551 for (i = masklen; i >= 8; i -= 8) 4552 if (*ucp++ != *aptr++) 4553 break; /* 'for' loop 1b */ 4554 if (i == 0 || 4555 (i < 8 && ((*ucp ^ *aptr) & ~(0xff >> i)) == 0)) 4556 return (B_TRUE); 4557 } /* 'for' loop 1b ends */ 4558 return (B_FALSE); 4559 } 4560 4561 /* 4562 * Run through the filter list for an IPv6 MIB2 IRE. For a given 4563 * type, if there's at least one filter and all filters of that type 4564 * fail to match, then the route doesn't match and isn't displayed. 4565 * If at least one matches, or none are specified, for each of the 4566 * types, then the route is selected and displayed. 4567 */ 4568 static boolean_t 4569 ire_filter_match_v6(const mib2_ipv6RouteEntry_t *rp6, uint_t flag_b) 4570 { 4571 filter_t *fp; 4572 int idx; 4573 4574 /* 'for' loop 1: */ 4575 for (idx = 0; idx < NFILTERKEYS; idx++) 4576 if ((fp = filters[idx]) != NULL) { 4577 /* 'for' loop 2: */ 4578 for (; fp != NULL; fp = fp->f_next) { 4579 switch (idx) { 4580 case FK_AF: 4581 if (fp->u.f_family != AF_INET6) 4582 /* 'for' loop 2 */ 4583 continue; 4584 break; 4585 case FK_OUTIF: 4586 if (!dev_name_match(&rp6-> 4587 ipv6RouteIfIndex, fp->u.f_ifname)) 4588 /* 'for' loop 2 */ 4589 continue; 4590 break; 4591 case FK_DST: 4592 if (!v6_addr_match(&rp6->ipv6RouteDest, 4593 rp6->ipv6RoutePfxLength, fp)) 4594 /* 'for' loop 2 */ 4595 continue; 4596 break; 4597 case FK_FLAGS: 4598 if ((flag_b & fp->u.f.f_flagset) != 4599 fp->u.f.f_flagset || 4600 (flag_b & fp->u.f.f_flagclear)) 4601 /* 'for' loop 2 */ 4602 continue; 4603 break; 4604 } 4605 break; 4606 } /* 'for' loop 2 ends */ 4607 if (fp == NULL) 4608 return (B_FALSE); 4609 } 4610 /* 'for' loop 1 ends */ 4611 return (B_TRUE); 4612 } 4613 4614 /* 4615 * Given an IPv6 MIB2 route entry, form the list of flags for the 4616 * route. 4617 */ 4618 static uint_t 4619 form_v6_route_flags(const mib2_ipv6RouteEntry_t *rp6, char *flags) 4620 { 4621 uint_t flag_b; 4622 4623 flag_b = FLF_U; 4624 (void) strcpy(flags, "U"); 4625 /* RTF_INDIRECT wins over RTF_GATEWAY - don't display both */ 4626 if (rp6->ipv6RouteInfo.re_flags & RTF_INDIRECT) { 4627 (void) strcat(flags, "I"); 4628 flag_b |= FLF_I; 4629 } else if (rp6->ipv6RouteInfo.re_ire_type & IRE_OFFLINK) { 4630 (void) strcat(flags, "G"); 4631 flag_b |= FLF_G; 4632 } 4633 4634 /* IRE_IF_CLONE wins over RTF_HOST - don't display both */ 4635 if (rp6->ipv6RouteInfo.re_ire_type & IRE_IF_CLONE) { 4636 (void) strcat(flags, "C"); 4637 flag_b |= FLF_C; 4638 } else if (rp6->ipv6RoutePfxLength == IPV6_ABITS) { 4639 (void) strcat(flags, "H"); 4640 flag_b |= FLF_H; 4641 } 4642 4643 if (rp6->ipv6RouteInfo.re_flags & RTF_DYNAMIC) { 4644 (void) strcat(flags, "D"); 4645 flag_b |= FLF_D; 4646 } 4647 if (rp6->ipv6RouteInfo.re_ire_type == IRE_LOCAL) { /* Local */ 4648 (void) strcat(flags, "L"); 4649 flag_b |= FLF_L; 4650 } 4651 if (rp6->ipv6RouteInfo.re_flags & RTF_MULTIRT) { 4652 (void) strcat(flags, "M"); /* Multiroute */ 4653 flag_b |= FLF_M; 4654 } 4655 if (rp6->ipv6RouteInfo.re_flags & RTF_SETSRC) { 4656 (void) strcat(flags, "S"); /* Setsrc */ 4657 flag_b |= FLF_S; 4658 } 4659 if (rp6->ipv6RouteInfo.re_flags & RTF_REJECT) { 4660 (void) strcat(flags, "R"); 4661 flag_b |= FLF_R; 4662 } 4663 if (rp6->ipv6RouteInfo.re_flags & RTF_BLACKHOLE) { 4664 (void) strcat(flags, "B"); 4665 flag_b |= FLF_B; 4666 } 4667 if (rp6->ipv6RouteInfo.re_flags & RTF_ZONE) { 4668 (void) strcat(flags, "Z"); 4669 flag_b |= FLF_Z; 4670 } 4671 return (flag_b); 4672 } 4673 4674 static const char ire_hdr_v6[] = 4675 "\n%s Table: IPv6\n"; 4676 static const char ire_hdr_v6_verbose[] = 4677 " Destination/Mask Gateway If MTU " 4678 "Ref Flags Out In/Fwd %s\n" 4679 "--------------------------- --------------------------- ----- ----- " 4680 "--- ----- ------ ------ %s\n"; 4681 static const char ire_hdr_v6_normal[] = 4682 " Destination/Mask Gateway Flags Ref Use " 4683 " If %s\n" 4684 "--------------------------- --------------------------- ----- --- ------- " 4685 "----- %s\n"; 4686 4687 static boolean_t 4688 ire_report_item_v6(const mib2_ipv6RouteEntry_t *rp6, boolean_t first, 4689 const sec_attr_list_t *attrs) 4690 { 4691 char dstbuf[MAXHOSTNAMELEN + 1]; 4692 char gwbuf[MAXHOSTNAMELEN + 1]; 4693 char ifname[LIFNAMSIZ + 1]; 4694 char flags[10]; /* RTF_ flags */ 4695 uint_t flag_b; 4696 4697 if (!(Aflag || (rp6->ipv6RouteInfo.re_ire_type != IRE_IF_CLONE && 4698 rp6->ipv6RouteInfo.re_ire_type != IRE_MULTICAST && 4699 rp6->ipv6RouteInfo.re_ire_type != IRE_NOROUTE && 4700 rp6->ipv6RouteInfo.re_ire_type != IRE_LOCAL))) { 4701 return (first); 4702 } 4703 4704 flag_b = form_v6_route_flags(rp6, flags); 4705 4706 if (!ire_filter_match_v6(rp6, flag_b)) 4707 return (first); 4708 4709 if (first) { 4710 (void) printf(ire_hdr_v6, Vflag ? "IRE" : "Routing"); 4711 (void) printf(Vflag ? ire_hdr_v6_verbose : ire_hdr_v6_normal, 4712 RSECflag ? " Gateway security attributes " : "", 4713 RSECflag ? "-------------------------------" : ""); 4714 first = B_FALSE; 4715 } 4716 4717 if (Vflag) { 4718 (void) printf("%-27s %-27s %-5s %5u %3u " 4719 "%-5s %6u %6u %s\n", 4720 pr_prefix6(&rp6->ipv6RouteDest, 4721 rp6->ipv6RoutePfxLength, dstbuf, sizeof (dstbuf)), 4722 IN6_IS_ADDR_UNSPECIFIED(&rp6->ipv6RouteNextHop) ? 4723 " --" : 4724 pr_addr6(&rp6->ipv6RouteNextHop, gwbuf, sizeof (gwbuf)), 4725 octetstr(&rp6->ipv6RouteIfIndex, 'a', 4726 ifname, sizeof (ifname)), 4727 rp6->ipv6RouteInfo.re_max_frag, 4728 rp6->ipv6RouteInfo.re_ref, 4729 flags, 4730 rp6->ipv6RouteInfo.re_obpkt, 4731 rp6->ipv6RouteInfo.re_ibpkt, 4732 pr_secattr(attrs)); 4733 } else { 4734 (void) printf("%-27s %-27s %-5s %3u %7u %-5s %s\n", 4735 pr_prefix6(&rp6->ipv6RouteDest, 4736 rp6->ipv6RoutePfxLength, dstbuf, sizeof (dstbuf)), 4737 IN6_IS_ADDR_UNSPECIFIED(&rp6->ipv6RouteNextHop) ? 4738 " --" : 4739 pr_addr6(&rp6->ipv6RouteNextHop, gwbuf, sizeof (gwbuf)), 4740 flags, 4741 rp6->ipv6RouteInfo.re_ref, 4742 rp6->ipv6RouteInfo.re_obpkt + rp6->ipv6RouteInfo.re_ibpkt, 4743 octetstr(&rp6->ipv6RouteIfIndex, 'a', 4744 ifname, sizeof (ifname)), 4745 pr_secattr(attrs)); 4746 } 4747 return (first); 4748 } 4749 4750 /* 4751 * Common attribute-gathering routine for all transports. 4752 */ 4753 static mib2_transportMLPEntry_t ** 4754 gather_attrs(const mib_item_t *item, int group, int mib_id, int esize) 4755 { 4756 int transport_count = 0; 4757 const mib_item_t *iptr; 4758 mib2_transportMLPEntry_t **attrs, *tme; 4759 4760 for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 4761 if (iptr->group == group && iptr->mib_id == mib_id) 4762 transport_count += iptr->length / esize; 4763 } 4764 if (transport_count <= 0) 4765 return (NULL); 4766 attrs = calloc(transport_count, sizeof (*attrs)); 4767 if (attrs == NULL) { 4768 perror("gather_attrs calloc failed"); 4769 return (NULL); 4770 } 4771 for (iptr = item; iptr != NULL; iptr = iptr->next_item) { 4772 if (iptr->group == group && iptr->mib_id == EXPER_XPORT_MLP) { 4773 for (tme = iptr->valp; 4774 (char *)tme < (char *)iptr->valp + iptr->length; 4775 /* LINTED: (note 1) */ 4776 tme = (mib2_transportMLPEntry_t *)((char *)tme + 4777 transportMLPSize)) { 4778 attrs[tme->tme_connidx] = tme; 4779 } 4780 } 4781 } 4782 return (attrs); 4783 } 4784 4785 static void 4786 print_transport_label(const mib2_transportMLPEntry_t *attr) 4787 { 4788 if (!RSECflag || attr == NULL || 4789 !(attr->tme_flags & MIB2_TMEF_IS_LABELED)) 4790 return; 4791 4792 if (bisinvalid(&attr->tme_label)) { 4793 (void) printf(" INVALID\n"); 4794 } else if (!blequal(&attr->tme_label, zone_security_label)) { 4795 char *sl_str; 4796 4797 sl_str = sl_to_str(&attr->tme_label); 4798 (void) printf(" %s\n", sl_str); 4799 free(sl_str); 4800 } 4801 } 4802 4803 /* ------------------------------ TCP_REPORT------------------------------- */ 4804 4805 static const char tcp_hdr_v4[] = 4806 "\nTCP: IPv4\n"; 4807 static const char tcp_hdr_v4_compat[] = 4808 "\nTCP\n"; 4809 static const char tcp_hdr_v4_verbose[] = 4810 "Local/Remote Address Swind Snext Suna Rwind Rnext Rack " 4811 " Rto Mss State\n" 4812 "-------------------- ----- -------- -------- ----- -------- -------- " 4813 "----- ----- -----------\n"; 4814 static const char tcp_hdr_v4_normal[] = 4815 " Local Address Remote Address Swind Send-Q Rwind Recv-Q " 4816 " State\n" 4817 "-------------------- -------------------- ----- ------ ----- ------ " 4818 "-----------\n"; 4819 4820 static const char tcp_hdr_v6[] = 4821 "\nTCP: IPv6\n"; 4822 static const char tcp_hdr_v6_verbose[] = 4823 "Local/Remote Address Swind Snext Suna Rwind Rnext " 4824 " Rack Rto Mss State If\n" 4825 "--------------------------------- ----- -------- -------- ----- -------- " 4826 "-------- ----- ----- ----------- -----\n"; 4827 static const char tcp_hdr_v6_normal[] = 4828 " Local Address Remote Address " 4829 "Swind Send-Q Rwind Recv-Q State If\n" 4830 "--------------------------------- --------------------------------- " 4831 "----- ------ ----- ------ ----------- -----\n"; 4832 4833 static boolean_t tcp_report_item_v4(const mib2_tcpConnEntry_t *, 4834 boolean_t first, const mib2_transportMLPEntry_t *); 4835 static boolean_t tcp_report_item_v6(const mib2_tcp6ConnEntry_t *, 4836 boolean_t first, const mib2_transportMLPEntry_t *); 4837 4838 static void 4839 tcp_report(const mib_item_t *item) 4840 { 4841 int jtemp = 0; 4842 boolean_t print_hdr_once_v4 = B_TRUE; 4843 boolean_t print_hdr_once_v6 = B_TRUE; 4844 mib2_tcpConnEntry_t *tp; 4845 mib2_tcp6ConnEntry_t *tp6; 4846 mib2_transportMLPEntry_t **v4_attrs, **v6_attrs; 4847 mib2_transportMLPEntry_t **v4a, **v6a; 4848 mib2_transportMLPEntry_t *aptr; 4849 4850 if (!protocol_selected(IPPROTO_TCP)) 4851 return; 4852 4853 /* 4854 * Preparation pass: the kernel returns separate entries for TCP 4855 * connection table entries and Multilevel Port attributes. We loop 4856 * through the attributes first and set up an array for each address 4857 * family. 4858 */ 4859 v4_attrs = family_selected(AF_INET) && RSECflag ? 4860 gather_attrs(item, MIB2_TCP, MIB2_TCP_CONN, tcpConnEntrySize) : 4861 NULL; 4862 v6_attrs = family_selected(AF_INET6) && RSECflag ? 4863 gather_attrs(item, MIB2_TCP6, MIB2_TCP6_CONN, tcp6ConnEntrySize) : 4864 NULL; 4865 4866 /* 'for' loop 1: */ 4867 v4a = v4_attrs; 4868 v6a = v6_attrs; 4869 for (; item != NULL; item = item->next_item) { 4870 if (Xflag) { 4871 (void) printf("\n--- Entry %d ---\n", ++jtemp); 4872 (void) printf("Group = %d, mib_id = %d, " 4873 "length = %d, valp = 0x%p\n", 4874 item->group, item->mib_id, 4875 item->length, item->valp); 4876 } 4877 4878 if (!((item->group == MIB2_TCP && 4879 item->mib_id == MIB2_TCP_CONN) || 4880 (item->group == MIB2_TCP6 && 4881 item->mib_id == MIB2_TCP6_CONN))) 4882 continue; /* 'for' loop 1 */ 4883 4884 if (item->group == MIB2_TCP && !family_selected(AF_INET)) 4885 continue; /* 'for' loop 1 */ 4886 else if (item->group == MIB2_TCP6 && !family_selected(AF_INET6)) 4887 continue; /* 'for' loop 1 */ 4888 4889 if (item->group == MIB2_TCP) { 4890 for (tp = (mib2_tcpConnEntry_t *)item->valp; 4891 (char *)tp < (char *)item->valp + item->length; 4892 /* LINTED: (note 1) */ 4893 tp = (mib2_tcpConnEntry_t *)((char *)tp + 4894 tcpConnEntrySize)) { 4895 aptr = v4a == NULL ? NULL : *v4a++; 4896 print_hdr_once_v4 = tcp_report_item_v4(tp, 4897 print_hdr_once_v4, aptr); 4898 } 4899 } else { 4900 for (tp6 = (mib2_tcp6ConnEntry_t *)item->valp; 4901 (char *)tp6 < (char *)item->valp + item->length; 4902 /* LINTED: (note 1) */ 4903 tp6 = (mib2_tcp6ConnEntry_t *)((char *)tp6 + 4904 tcp6ConnEntrySize)) { 4905 aptr = v6a == NULL ? NULL : *v6a++; 4906 print_hdr_once_v6 = tcp_report_item_v6(tp6, 4907 print_hdr_once_v6, aptr); 4908 } 4909 } 4910 } /* 'for' loop 1 ends */ 4911 (void) fflush(stdout); 4912 4913 if (v4_attrs != NULL) 4914 free(v4_attrs); 4915 if (v6_attrs != NULL) 4916 free(v6_attrs); 4917 } 4918 4919 static boolean_t 4920 tcp_report_item_v4(const mib2_tcpConnEntry_t *tp, boolean_t first, 4921 const mib2_transportMLPEntry_t *attr) 4922 { 4923 /* 4924 * lname and fname below are for the hostname as well as the portname 4925 * There is no limit on portname length so we assume MAXHOSTNAMELEN 4926 * as the limit 4927 */ 4928 char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 4929 char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 4930 4931 if (!(Aflag || tp->tcpConnEntryInfo.ce_state >= TCPS_ESTABLISHED)) 4932 return (first); /* Nothing to print */ 4933 4934 if (first) { 4935 (void) printf(v4compat ? tcp_hdr_v4_compat : tcp_hdr_v4); 4936 (void) printf(Vflag ? tcp_hdr_v4_verbose : tcp_hdr_v4_normal); 4937 } 4938 4939 if (Vflag) { 4940 (void) printf("%-20s\n%-20s %5u %08x %08x %5u %08x %08x " 4941 "%5u %5u %s\n", 4942 pr_ap(tp->tcpConnLocalAddress, 4943 tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 4944 pr_ap(tp->tcpConnRemAddress, 4945 tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 4946 tp->tcpConnEntryInfo.ce_swnd, 4947 tp->tcpConnEntryInfo.ce_snxt, 4948 tp->tcpConnEntryInfo.ce_suna, 4949 tp->tcpConnEntryInfo.ce_rwnd, 4950 tp->tcpConnEntryInfo.ce_rnxt, 4951 tp->tcpConnEntryInfo.ce_rack, 4952 tp->tcpConnEntryInfo.ce_rto, 4953 tp->tcpConnEntryInfo.ce_mss, 4954 mitcp_state(tp->tcpConnEntryInfo.ce_state, attr)); 4955 } else { 4956 int sq = (int)tp->tcpConnEntryInfo.ce_snxt - 4957 (int)tp->tcpConnEntryInfo.ce_suna - 1; 4958 int rq = (int)tp->tcpConnEntryInfo.ce_rnxt - 4959 (int)tp->tcpConnEntryInfo.ce_rack; 4960 4961 (void) printf("%-20s %-20s %5u %6d %5u %6d %s\n", 4962 pr_ap(tp->tcpConnLocalAddress, 4963 tp->tcpConnLocalPort, "tcp", lname, sizeof (lname)), 4964 pr_ap(tp->tcpConnRemAddress, 4965 tp->tcpConnRemPort, "tcp", fname, sizeof (fname)), 4966 tp->tcpConnEntryInfo.ce_swnd, 4967 (sq >= 0) ? sq : 0, 4968 tp->tcpConnEntryInfo.ce_rwnd, 4969 (rq >= 0) ? rq : 0, 4970 mitcp_state(tp->tcpConnEntryInfo.ce_state, attr)); 4971 } 4972 4973 print_transport_label(attr); 4974 4975 return (B_FALSE); 4976 } 4977 4978 static boolean_t 4979 tcp_report_item_v6(const mib2_tcp6ConnEntry_t *tp6, boolean_t first, 4980 const mib2_transportMLPEntry_t *attr) 4981 { 4982 /* 4983 * lname and fname below are for the hostname as well as the portname 4984 * There is no limit on portname length so we assume MAXHOSTNAMELEN 4985 * as the limit 4986 */ 4987 char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 4988 char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 4989 char ifname[LIFNAMSIZ + 1]; 4990 char *ifnamep; 4991 4992 if (!(Aflag || tp6->tcp6ConnEntryInfo.ce_state >= TCPS_ESTABLISHED)) 4993 return (first); /* Nothing to print */ 4994 4995 if (first) { 4996 (void) printf(tcp_hdr_v6); 4997 (void) printf(Vflag ? tcp_hdr_v6_verbose : tcp_hdr_v6_normal); 4998 } 4999 5000 ifnamep = (tp6->tcp6ConnIfIndex != 0) ? 5001 if_indextoname(tp6->tcp6ConnIfIndex, ifname) : NULL; 5002 if (ifnamep == NULL) 5003 ifnamep = ""; 5004 5005 if (Vflag) { 5006 (void) printf("%-33s\n%-33s %5u %08x %08x %5u %08x %08x " 5007 "%5u %5u %-11s %s\n", 5008 pr_ap6(&tp6->tcp6ConnLocalAddress, 5009 tp6->tcp6ConnLocalPort, "tcp", lname, sizeof (lname)), 5010 pr_ap6(&tp6->tcp6ConnRemAddress, 5011 tp6->tcp6ConnRemPort, "tcp", fname, sizeof (fname)), 5012 tp6->tcp6ConnEntryInfo.ce_swnd, 5013 tp6->tcp6ConnEntryInfo.ce_snxt, 5014 tp6->tcp6ConnEntryInfo.ce_suna, 5015 tp6->tcp6ConnEntryInfo.ce_rwnd, 5016 tp6->tcp6ConnEntryInfo.ce_rnxt, 5017 tp6->tcp6ConnEntryInfo.ce_rack, 5018 tp6->tcp6ConnEntryInfo.ce_rto, 5019 tp6->tcp6ConnEntryInfo.ce_mss, 5020 mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 5021 ifnamep); 5022 } else { 5023 int sq = (int)tp6->tcp6ConnEntryInfo.ce_snxt - 5024 (int)tp6->tcp6ConnEntryInfo.ce_suna - 1; 5025 int rq = (int)tp6->tcp6ConnEntryInfo.ce_rnxt - 5026 (int)tp6->tcp6ConnEntryInfo.ce_rack; 5027 5028 (void) printf("%-33s %-33s %5u %6d %5u %6d %-11s %s\n", 5029 pr_ap6(&tp6->tcp6ConnLocalAddress, 5030 tp6->tcp6ConnLocalPort, "tcp", lname, sizeof (lname)), 5031 pr_ap6(&tp6->tcp6ConnRemAddress, 5032 tp6->tcp6ConnRemPort, "tcp", fname, sizeof (fname)), 5033 tp6->tcp6ConnEntryInfo.ce_swnd, 5034 (sq >= 0) ? sq : 0, 5035 tp6->tcp6ConnEntryInfo.ce_rwnd, 5036 (rq >= 0) ? rq : 0, 5037 mitcp_state(tp6->tcp6ConnEntryInfo.ce_state, attr), 5038 ifnamep); 5039 } 5040 5041 print_transport_label(attr); 5042 5043 return (B_FALSE); 5044 } 5045 5046 /* ------------------------------- UDP_REPORT------------------------------- */ 5047 5048 static boolean_t udp_report_item_v4(const mib2_udpEntry_t *ude, 5049 boolean_t first, const mib2_transportMLPEntry_t *attr); 5050 static boolean_t udp_report_item_v6(const mib2_udp6Entry_t *ude6, 5051 boolean_t first, const mib2_transportMLPEntry_t *attr); 5052 5053 static const char udp_hdr_v4[] = 5054 " Local Address Remote Address State\n" 5055 "-------------------- -------------------- ----------\n"; 5056 5057 static const char udp_hdr_v6[] = 5058 " Local Address Remote Address " 5059 " State If\n" 5060 "--------------------------------- --------------------------------- " 5061 "---------- -----\n"; 5062 5063 static void 5064 udp_report(const mib_item_t *item) 5065 { 5066 int jtemp = 0; 5067 boolean_t print_hdr_once_v4 = B_TRUE; 5068 boolean_t print_hdr_once_v6 = B_TRUE; 5069 mib2_udpEntry_t *ude; 5070 mib2_udp6Entry_t *ude6; 5071 mib2_transportMLPEntry_t **v4_attrs, **v6_attrs; 5072 mib2_transportMLPEntry_t **v4a, **v6a; 5073 mib2_transportMLPEntry_t *aptr; 5074 5075 if (!protocol_selected(IPPROTO_UDP)) 5076 return; 5077 5078 /* 5079 * Preparation pass: the kernel returns separate entries for UDP 5080 * connection table entries and Multilevel Port attributes. We loop 5081 * through the attributes first and set up an array for each address 5082 * family. 5083 */ 5084 v4_attrs = family_selected(AF_INET) && RSECflag ? 5085 gather_attrs(item, MIB2_UDP, MIB2_UDP_ENTRY, udpEntrySize) : NULL; 5086 v6_attrs = family_selected(AF_INET6) && RSECflag ? 5087 gather_attrs(item, MIB2_UDP6, MIB2_UDP6_ENTRY, udp6EntrySize) : 5088 NULL; 5089 5090 v4a = v4_attrs; 5091 v6a = v6_attrs; 5092 /* 'for' loop 1: */ 5093 for (; item; item = item->next_item) { 5094 if (Xflag) { 5095 (void) printf("\n--- Entry %d ---\n", ++jtemp); 5096 (void) printf("Group = %d, mib_id = %d, " 5097 "length = %d, valp = 0x%p\n", 5098 item->group, item->mib_id, 5099 item->length, item->valp); 5100 } 5101 if (!((item->group == MIB2_UDP && 5102 item->mib_id == MIB2_UDP_ENTRY) || 5103 (item->group == MIB2_UDP6 && 5104 item->mib_id == MIB2_UDP6_ENTRY))) 5105 continue; /* 'for' loop 1 */ 5106 5107 if (item->group == MIB2_UDP && !family_selected(AF_INET)) 5108 continue; /* 'for' loop 1 */ 5109 else if (item->group == MIB2_UDP6 && !family_selected(AF_INET6)) 5110 continue; /* 'for' loop 1 */ 5111 5112 /* xxx.xxx.xxx.xxx,pppp sss... */ 5113 if (item->group == MIB2_UDP) { 5114 for (ude = (mib2_udpEntry_t *)item->valp; 5115 (char *)ude < (char *)item->valp + item->length; 5116 /* LINTED: (note 1) */ 5117 ude = (mib2_udpEntry_t *)((char *)ude + 5118 udpEntrySize)) { 5119 aptr = v4a == NULL ? NULL : *v4a++; 5120 print_hdr_once_v4 = udp_report_item_v4(ude, 5121 print_hdr_once_v4, aptr); 5122 } 5123 } else { 5124 for (ude6 = (mib2_udp6Entry_t *)item->valp; 5125 (char *)ude6 < (char *)item->valp + item->length; 5126 /* LINTED: (note 1) */ 5127 ude6 = (mib2_udp6Entry_t *)((char *)ude6 + 5128 udp6EntrySize)) { 5129 aptr = v6a == NULL ? NULL : *v6a++; 5130 print_hdr_once_v6 = udp_report_item_v6(ude6, 5131 print_hdr_once_v6, aptr); 5132 } 5133 } 5134 } /* 'for' loop 1 ends */ 5135 (void) fflush(stdout); 5136 5137 if (v4_attrs != NULL) 5138 free(v4_attrs); 5139 if (v6_attrs != NULL) 5140 free(v6_attrs); 5141 } 5142 5143 static boolean_t 5144 udp_report_item_v4(const mib2_udpEntry_t *ude, boolean_t first, 5145 const mib2_transportMLPEntry_t *attr) 5146 { 5147 char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 5148 /* hostname + portname */ 5149 5150 if (!(Aflag || ude->udpEntryInfo.ue_state >= MIB2_UDP_connected)) 5151 return (first); /* Nothing to print */ 5152 5153 if (first) { 5154 (void) printf(v4compat ? "\nUDP\n" : "\nUDP: IPv4\n"); 5155 (void) printf(udp_hdr_v4); 5156 first = B_FALSE; 5157 } 5158 5159 (void) printf("%-20s ", 5160 pr_ap(ude->udpLocalAddress, ude->udpLocalPort, "udp", 5161 lname, sizeof (lname))); 5162 (void) printf("%-20s %s\n", 5163 ude->udpEntryInfo.ue_state == MIB2_UDP_connected ? 5164 pr_ap(ude->udpEntryInfo.ue_RemoteAddress, 5165 ude->udpEntryInfo.ue_RemotePort, "udp", lname, sizeof (lname)) : 5166 "", 5167 miudp_state(ude->udpEntryInfo.ue_state, attr)); 5168 5169 print_transport_label(attr); 5170 5171 return (first); 5172 } 5173 5174 static boolean_t 5175 udp_report_item_v6(const mib2_udp6Entry_t *ude6, boolean_t first, 5176 const mib2_transportMLPEntry_t *attr) 5177 { 5178 char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 5179 /* hostname + portname */ 5180 char ifname[LIFNAMSIZ + 1]; 5181 const char *ifnamep; 5182 5183 if (!(Aflag || ude6->udp6EntryInfo.ue_state >= MIB2_UDP_connected)) 5184 return (first); /* Nothing to print */ 5185 5186 if (first) { 5187 (void) printf("\nUDP: IPv6\n"); 5188 (void) printf(udp_hdr_v6); 5189 first = B_FALSE; 5190 } 5191 5192 ifnamep = (ude6->udp6IfIndex != 0) ? 5193 if_indextoname(ude6->udp6IfIndex, ifname) : NULL; 5194 5195 (void) printf("%-33s ", 5196 pr_ap6(&ude6->udp6LocalAddress, 5197 ude6->udp6LocalPort, "udp", lname, sizeof (lname))); 5198 (void) printf("%-33s %-10s %s\n", 5199 ude6->udp6EntryInfo.ue_state == MIB2_UDP_connected ? 5200 pr_ap6(&ude6->udp6EntryInfo.ue_RemoteAddress, 5201 ude6->udp6EntryInfo.ue_RemotePort, "udp", lname, sizeof (lname)) : 5202 "", 5203 miudp_state(ude6->udp6EntryInfo.ue_state, attr), 5204 ifnamep == NULL ? "" : ifnamep); 5205 5206 print_transport_label(attr); 5207 5208 return (first); 5209 } 5210 5211 /* ------------------------------ SCTP_REPORT------------------------------- */ 5212 5213 static const char sctp_hdr[] = 5214 "\nSCTP:"; 5215 static const char sctp_hdr_normal[] = 5216 " Local Address Remote Address " 5217 "Swind Send-Q Rwind Recv-Q StrsI/O State\n" 5218 "------------------------------- ------------------------------- " 5219 "------ ------ ------ ------ ------- -----------"; 5220 5221 static const char * 5222 nssctp_state(int state, const mib2_transportMLPEntry_t *attr) 5223 { 5224 static char sctpsbuf[50]; 5225 const char *cp; 5226 5227 switch (state) { 5228 case MIB2_SCTP_closed: 5229 cp = "CLOSED"; 5230 break; 5231 case MIB2_SCTP_cookieWait: 5232 cp = "COOKIE_WAIT"; 5233 break; 5234 case MIB2_SCTP_cookieEchoed: 5235 cp = "COOKIE_ECHOED"; 5236 break; 5237 case MIB2_SCTP_established: 5238 cp = "ESTABLISHED"; 5239 break; 5240 case MIB2_SCTP_shutdownPending: 5241 cp = "SHUTDOWN_PENDING"; 5242 break; 5243 case MIB2_SCTP_shutdownSent: 5244 cp = "SHUTDOWN_SENT"; 5245 break; 5246 case MIB2_SCTP_shutdownReceived: 5247 cp = "SHUTDOWN_RECEIVED"; 5248 break; 5249 case MIB2_SCTP_shutdownAckSent: 5250 cp = "SHUTDOWN_ACK_SENT"; 5251 break; 5252 case MIB2_SCTP_listen: 5253 cp = "LISTEN"; 5254 break; 5255 default: 5256 (void) snprintf(sctpsbuf, sizeof (sctpsbuf), 5257 "UNKNOWN STATE(%d)", state); 5258 cp = sctpsbuf; 5259 break; 5260 } 5261 5262 if (RSECflag && attr != NULL && attr->tme_flags != 0) { 5263 if (cp != sctpsbuf) { 5264 (void) strlcpy(sctpsbuf, cp, sizeof (sctpsbuf)); 5265 cp = sctpsbuf; 5266 } 5267 if (attr->tme_flags & MIB2_TMEF_PRIVATE) 5268 (void) strlcat(sctpsbuf, " P", sizeof (sctpsbuf)); 5269 if (attr->tme_flags & MIB2_TMEF_SHARED) 5270 (void) strlcat(sctpsbuf, " S", sizeof (sctpsbuf)); 5271 } 5272 5273 return (cp); 5274 } 5275 5276 static const mib2_sctpConnRemoteEntry_t * 5277 sctp_getnext_rem(const mib_item_t **itemp, 5278 const mib2_sctpConnRemoteEntry_t *current, uint32_t associd) 5279 { 5280 const mib_item_t *item = *itemp; 5281 const mib2_sctpConnRemoteEntry_t *sre; 5282 5283 for (; item != NULL; item = item->next_item, current = NULL) { 5284 if (!(item->group == MIB2_SCTP && 5285 item->mib_id == MIB2_SCTP_CONN_REMOTE)) { 5286 continue; 5287 } 5288 5289 if (current != NULL) { 5290 /* LINTED: (note 1) */ 5291 sre = (const mib2_sctpConnRemoteEntry_t *) 5292 ((const char *)current + sctpRemoteEntrySize); 5293 } else { 5294 sre = item->valp; 5295 } 5296 for (; (char *)sre < (char *)item->valp + item->length; 5297 /* LINTED: (note 1) */ 5298 sre = (const mib2_sctpConnRemoteEntry_t *) 5299 ((const char *)sre + sctpRemoteEntrySize)) { 5300 if (sre->sctpAssocId != associd) { 5301 continue; 5302 } 5303 *itemp = item; 5304 return (sre); 5305 } 5306 } 5307 *itemp = NULL; 5308 return (NULL); 5309 } 5310 5311 static const mib2_sctpConnLocalEntry_t * 5312 sctp_getnext_local(const mib_item_t **itemp, 5313 const mib2_sctpConnLocalEntry_t *current, uint32_t associd) 5314 { 5315 const mib_item_t *item = *itemp; 5316 const mib2_sctpConnLocalEntry_t *sle; 5317 5318 for (; item != NULL; item = item->next_item, current = NULL) { 5319 if (!(item->group == MIB2_SCTP && 5320 item->mib_id == MIB2_SCTP_CONN_LOCAL)) { 5321 continue; 5322 } 5323 5324 if (current != NULL) { 5325 /* LINTED: (note 1) */ 5326 sle = (const mib2_sctpConnLocalEntry_t *) 5327 ((const char *)current + sctpLocalEntrySize); 5328 } else { 5329 sle = item->valp; 5330 } 5331 for (; (char *)sle < (char *)item->valp + item->length; 5332 /* LINTED: (note 1) */ 5333 sle = (const mib2_sctpConnLocalEntry_t *) 5334 ((const char *)sle + sctpLocalEntrySize)) { 5335 if (sle->sctpAssocId != associd) { 5336 continue; 5337 } 5338 *itemp = item; 5339 return (sle); 5340 } 5341 } 5342 *itemp = NULL; 5343 return (NULL); 5344 } 5345 5346 static void 5347 sctp_pr_addr(int type, char *name, int namelen, const in6_addr_t *addr, 5348 int port) 5349 { 5350 ipaddr_t v4addr; 5351 in6_addr_t v6addr; 5352 5353 /* 5354 * Address is either a v4 mapped or v6 addr. If 5355 * it's a v4 mapped, convert to v4 before 5356 * displaying. 5357 */ 5358 switch (type) { 5359 case MIB2_SCTP_ADDR_V4: 5360 /* v4 */ 5361 v6addr = *addr; 5362 5363 IN6_V4MAPPED_TO_IPADDR(&v6addr, v4addr); 5364 if (port > 0) { 5365 (void) pr_ap(v4addr, port, "sctp", name, namelen); 5366 } else { 5367 (void) pr_addr(v4addr, name, namelen); 5368 } 5369 break; 5370 5371 case MIB2_SCTP_ADDR_V6: 5372 /* v6 */ 5373 if (port > 0) { 5374 (void) pr_ap6(addr, port, "sctp", name, namelen); 5375 } else { 5376 (void) pr_addr6(addr, name, namelen); 5377 } 5378 break; 5379 5380 default: 5381 (void) snprintf(name, namelen, "<unknown addr type>"); 5382 break; 5383 } 5384 } 5385 5386 static void 5387 sctp_conn_report_item(const mib_item_t *head, const mib2_sctpConnEntry_t *sp, 5388 const mib2_transportMLPEntry_t *attr) 5389 { 5390 char lname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 5391 char fname[MAXHOSTNAMELEN + MAXHOSTNAMELEN + 1]; 5392 const mib2_sctpConnRemoteEntry_t *sre = NULL; 5393 const mib2_sctpConnLocalEntry_t *sle = NULL; 5394 const mib_item_t *local = head; 5395 const mib_item_t *remote = head; 5396 uint32_t id = sp->sctpAssocId; 5397 boolean_t printfirst = B_TRUE; 5398 5399 sctp_pr_addr(sp->sctpAssocRemPrimAddrType, fname, sizeof (fname), 5400 &sp->sctpAssocRemPrimAddr, sp->sctpAssocRemPort); 5401 sctp_pr_addr(sp->sctpAssocRemPrimAddrType, lname, sizeof (lname), 5402 &sp->sctpAssocLocPrimAddr, sp->sctpAssocLocalPort); 5403 5404 (void) printf("%-31s %-31s %6u %6d %6u %6d %3d/%-3d %s\n", 5405 lname, fname, 5406 sp->sctpConnEntryInfo.ce_swnd, 5407 sp->sctpConnEntryInfo.ce_sendq, 5408 sp->sctpConnEntryInfo.ce_rwnd, 5409 sp->sctpConnEntryInfo.ce_recvq, 5410 sp->sctpAssocInStreams, sp->sctpAssocOutStreams, 5411 nssctp_state(sp->sctpAssocState, attr)); 5412 5413 print_transport_label(attr); 5414 5415 if (!Vflag) { 5416 return; 5417 } 5418 5419 /* Print remote addresses/local addresses on following lines */ 5420 while ((sre = sctp_getnext_rem(&remote, sre, id)) != NULL) { 5421 if (!IN6_ARE_ADDR_EQUAL(&sre->sctpAssocRemAddr, 5422 &sp->sctpAssocRemPrimAddr)) { 5423 if (printfirst == B_TRUE) { 5424 (void) fputs("\t<Remote: ", stdout); 5425 printfirst = B_FALSE; 5426 } else { 5427 (void) fputs(", ", stdout); 5428 } 5429 sctp_pr_addr(sre->sctpAssocRemAddrType, fname, 5430 sizeof (fname), &sre->sctpAssocRemAddr, -1); 5431 if (sre->sctpAssocRemAddrActive == MIB2_SCTP_ACTIVE) { 5432 (void) fputs(fname, stdout); 5433 } else { 5434 (void) printf("(%s)", fname); 5435 } 5436 } 5437 } 5438 if (printfirst == B_FALSE) { 5439 (void) puts(">"); 5440 printfirst = B_TRUE; 5441 } 5442 while ((sle = sctp_getnext_local(&local, sle, id)) != NULL) { 5443 if (!IN6_ARE_ADDR_EQUAL(&sle->sctpAssocLocalAddr, 5444 &sp->sctpAssocLocPrimAddr)) { 5445 if (printfirst == B_TRUE) { 5446 (void) fputs("\t<Local: ", stdout); 5447 printfirst = B_FALSE; 5448 } else { 5449 (void) fputs(", ", stdout); 5450 } 5451 sctp_pr_addr(sle->sctpAssocLocalAddrType, lname, 5452 sizeof (lname), &sle->sctpAssocLocalAddr, -1); 5453 (void) fputs(lname, stdout); 5454 } 5455 } 5456 if (printfirst == B_FALSE) { 5457 (void) puts(">"); 5458 } 5459 } 5460 5461 static void 5462 sctp_report(const mib_item_t *item) 5463 { 5464 const mib_item_t *head; 5465 const mib2_sctpConnEntry_t *sp; 5466 boolean_t first = B_TRUE; 5467 mib2_transportMLPEntry_t **attrs, **aptr; 5468 mib2_transportMLPEntry_t *attr; 5469 5470 /* 5471 * Preparation pass: the kernel returns separate entries for SCTP 5472 * connection table entries and Multilevel Port attributes. We loop 5473 * through the attributes first and set up an array for each address 5474 * family. 5475 */ 5476 attrs = RSECflag ? 5477 gather_attrs(item, MIB2_SCTP, MIB2_SCTP_CONN, sctpEntrySize) : 5478 NULL; 5479 5480 aptr = attrs; 5481 head = item; 5482 for (; item != NULL; item = item->next_item) { 5483 5484 if (!(item->group == MIB2_SCTP && 5485 item->mib_id == MIB2_SCTP_CONN)) 5486 continue; 5487 5488 for (sp = item->valp; 5489 (char *)sp < (char *)item->valp + item->length; 5490 /* LINTED: (note 1) */ 5491 sp = (mib2_sctpConnEntry_t *)((char *)sp + sctpEntrySize)) { 5492 attr = aptr == NULL ? NULL : *aptr++; 5493 if (Aflag || 5494 sp->sctpAssocState >= MIB2_SCTP_established) { 5495 if (first == B_TRUE) { 5496 (void) puts(sctp_hdr); 5497 (void) puts(sctp_hdr_normal); 5498 first = B_FALSE; 5499 } 5500 sctp_conn_report_item(head, sp, attr); 5501 } 5502 } 5503 } 5504 if (attrs != NULL) 5505 free(attrs); 5506 } 5507 5508 static char * 5509 plural(int n) 5510 { 5511 return (n != 1 ? "s" : ""); 5512 } 5513 5514 static char * 5515 pluraly(int n) 5516 { 5517 return (n != 1 ? "ies" : "y"); 5518 } 5519 5520 static char * 5521 plurales(int n) 5522 { 5523 return (n != 1 ? "es" : ""); 5524 } 5525 5526 static char * 5527 pktscale(int n) 5528 { 5529 static char buf[6]; 5530 char t; 5531 5532 if (n < 1024) { 5533 t = ' '; 5534 } else if (n < 1024 * 1024) { 5535 t = 'k'; 5536 n /= 1024; 5537 } else if (n < 1024 * 1024 * 1024) { 5538 t = 'm'; 5539 n /= 1024 * 1024; 5540 } else { 5541 t = 'g'; 5542 n /= 1024 * 1024 * 1024; 5543 } 5544 5545 (void) snprintf(buf, sizeof (buf), "%4u%c", n, t); 5546 return (buf); 5547 } 5548 5549 /* --------------------- mrt_report (netstat -m) -------------------------- */ 5550 5551 static void 5552 mrt_report(mib_item_t *item) 5553 { 5554 int jtemp = 0; 5555 struct vifctl *vip; 5556 vifi_t vifi; 5557 struct mfcctl *mfccp; 5558 int numvifs = 0; 5559 int nmfc = 0; 5560 char abuf[MAXHOSTNAMELEN + 1]; 5561 5562 if (!(family_selected(AF_INET))) 5563 return; 5564 5565 /* 'for' loop 1: */ 5566 for (; item; item = item->next_item) { 5567 if (Xflag) { 5568 (void) printf("\n--- Entry %d ---\n", ++jtemp); 5569 (void) printf("Group = %d, mib_id = %d, " 5570 "length = %d, valp = 0x%p\n", 5571 item->group, item->mib_id, item->length, 5572 item->valp); 5573 } 5574 if (item->group != EXPER_DVMRP) 5575 continue; /* 'for' loop 1 */ 5576 5577 switch (item->mib_id) { 5578 5579 case EXPER_DVMRP_VIF: 5580 if (Xflag) 5581 (void) printf("%u records for ipVifTable:\n", 5582 item->length/sizeof (struct vifctl)); 5583 if (item->length/sizeof (struct vifctl) == 0) { 5584 (void) puts("\nVirtual Interface Table is " 5585 "empty"); 5586 break; 5587 } 5588 5589 (void) puts("\nVirtual Interface Table\n" 5590 " Vif Threshold Rate_Limit Local-Address" 5591 " Remote-Address Pkt_in Pkt_out"); 5592 5593 /* 'for' loop 2: */ 5594 for (vip = (struct vifctl *)item->valp; 5595 (char *)vip < (char *)item->valp + item->length; 5596 /* LINTED: (note 1) */ 5597 vip = (struct vifctl *)((char *)vip + 5598 vifctlSize)) { 5599 if (vip->vifc_lcl_addr.s_addr == 0) 5600 continue; /* 'for' loop 2 */ 5601 /* numvifs = vip->vifc_vifi; */ 5602 5603 numvifs++; 5604 (void) printf(" %2u %3u " 5605 "%4u %-15.15s", 5606 vip->vifc_vifi, 5607 vip->vifc_threshold, 5608 vip->vifc_rate_limit, 5609 pr_addr(vip->vifc_lcl_addr.s_addr, 5610 abuf, sizeof (abuf))); 5611 (void) printf(" %-15.15s %8u %8u\n", 5612 (vip->vifc_flags & VIFF_TUNNEL) ? 5613 pr_addr(vip->vifc_rmt_addr.s_addr, 5614 abuf, sizeof (abuf)) : "", 5615 vip->vifc_pkt_in, 5616 vip->vifc_pkt_out); 5617 } /* 'for' loop 2 ends */ 5618 5619 (void) printf("Numvifs: %d\n", numvifs); 5620 break; 5621 5622 case EXPER_DVMRP_MRT: 5623 if (Xflag) 5624 (void) printf("%u records for ipMfcTable:\n", 5625 item->length/sizeof (struct vifctl)); 5626 if (item->length/sizeof (struct vifctl) == 0) { 5627 (void) puts("\nMulticast Forwarding Cache is " 5628 "empty"); 5629 break; 5630 } 5631 5632 (void) puts("\nMulticast Forwarding Cache\n" 5633 " Origin-Subnet Mcastgroup " 5634 "# Pkts In-Vif Out-vifs/Forw-ttl"); 5635 5636 for (mfccp = (struct mfcctl *)item->valp; 5637 (char *)mfccp < (char *)item->valp + item->length; 5638 /* LINTED: (note 1) */ 5639 mfccp = (struct mfcctl *)((char *)mfccp + 5640 mfcctlSize)) { 5641 5642 nmfc++; 5643 (void) printf(" %-30.15s", 5644 pr_addr(mfccp->mfcc_origin.s_addr, 5645 abuf, sizeof (abuf))); 5646 (void) printf("%-15.15s %6s %3u ", 5647 pr_net(mfccp->mfcc_mcastgrp.s_addr, 5648 mfccp->mfcc_mcastgrp.s_addr, 5649 abuf, sizeof (abuf)), 5650 pktscale((int)mfccp->mfcc_pkt_cnt), 5651 mfccp->mfcc_parent); 5652 5653 for (vifi = 0; vifi < MAXVIFS; ++vifi) { 5654 if (mfccp->mfcc_ttls[vifi]) { 5655 (void) printf(" %u (%u)", 5656 vifi, 5657 mfccp->mfcc_ttls[vifi]); 5658 } 5659 5660 } 5661 (void) putchar('\n'); 5662 } 5663 (void) printf("\nTotal no. of entries in cache: %d\n", 5664 nmfc); 5665 break; 5666 } 5667 } /* 'for' loop 1 ends */ 5668 (void) putchar('\n'); 5669 (void) fflush(stdout); 5670 } 5671 5672 /* 5673 * Get the stats for the cache named 'name'. If prefix != 0, then 5674 * interpret the name as a prefix, and sum up stats for all caches 5675 * named 'name*'. 5676 */ 5677 static void 5678 kmem_cache_stats(char *title, char *name, int prefix, int64_t *total_bytes) 5679 { 5680 int len; 5681 int alloc; 5682 int64_t total_alloc = 0; 5683 int alloc_fail, total_alloc_fail = 0; 5684 int buf_size = 0; 5685 int buf_avail; 5686 int buf_total; 5687 int buf_max, total_buf_max = 0; 5688 int buf_inuse, total_buf_inuse = 0; 5689 kstat_t *ksp; 5690 char buf[256]; 5691 5692 len = prefix ? strlen(name) : 256; 5693 5694 /* 'for' loop 1: */ 5695 for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) { 5696 5697 if (strcmp(ksp->ks_class, "kmem_cache") != 0) 5698 continue; /* 'for' loop 1 */ 5699 5700 /* 5701 * Hack alert: because of the way streams messages are 5702 * allocated, every constructed free dblk has an associated 5703 * mblk. From the allocator's viewpoint those mblks are 5704 * allocated (because they haven't been freed), but from 5705 * our viewpoint they're actually free (because they're 5706 * not currently in use). To account for this caching 5707 * effect we subtract the total constructed free dblks 5708 * from the total allocated mblks to derive mblks in use. 5709 */ 5710 if (strcmp(name, "streams_mblk") == 0 && 5711 strncmp(ksp->ks_name, "streams_dblk", 12) == 0) { 5712 (void) safe_kstat_read(kc, ksp, NULL); 5713 total_buf_inuse -= 5714 kstat_named_value(ksp, "buf_constructed"); 5715 continue; /* 'for' loop 1 */ 5716 } 5717 5718 if (strncmp(ksp->ks_name, name, len) != 0) 5719 continue; /* 'for' loop 1 */ 5720 5721 (void) safe_kstat_read(kc, ksp, NULL); 5722 5723 alloc = kstat_named_value(ksp, "alloc"); 5724 alloc_fail = kstat_named_value(ksp, "alloc_fail"); 5725 buf_size = kstat_named_value(ksp, "buf_size"); 5726 buf_avail = kstat_named_value(ksp, "buf_avail"); 5727 buf_total = kstat_named_value(ksp, "buf_total"); 5728 buf_max = kstat_named_value(ksp, "buf_max"); 5729 buf_inuse = buf_total - buf_avail; 5730 5731 if (Vflag && prefix) { 5732 (void) snprintf(buf, sizeof (buf), "%s%s", title, 5733 ksp->ks_name + len); 5734 (void) printf(" %-18s %6u %9u %11u %11u\n", 5735 buf, buf_inuse, buf_max, alloc, alloc_fail); 5736 } 5737 5738 total_alloc += alloc; 5739 total_alloc_fail += alloc_fail; 5740 total_buf_max += buf_max; 5741 total_buf_inuse += buf_inuse; 5742 *total_bytes += (int64_t)buf_inuse * buf_size; 5743 } /* 'for' loop 1 ends */ 5744 5745 if (buf_size == 0) { 5746 (void) printf("%-22s [couldn't find statistics for %s]\n", 5747 title, name); 5748 return; 5749 } 5750 5751 if (Vflag && prefix) 5752 (void) snprintf(buf, sizeof (buf), "%s_total", title); 5753 else 5754 (void) snprintf(buf, sizeof (buf), "%s", title); 5755 5756 (void) printf("%-22s %6d %9d %11lld %11d\n", buf, 5757 total_buf_inuse, total_buf_max, total_alloc, total_alloc_fail); 5758 } 5759 5760 static void 5761 m_report(void) 5762 { 5763 int64_t total_bytes = 0; 5764 5765 (void) puts("streams allocation:"); 5766 (void) printf("%63s\n", "cumulative allocation"); 5767 (void) printf("%63s\n", 5768 "current maximum total failures"); 5769 5770 kmem_cache_stats("streams", 5771 "stream_head_cache", 0, &total_bytes); 5772 kmem_cache_stats("queues", "queue_cache", 0, &total_bytes); 5773 kmem_cache_stats("mblk", "streams_mblk", 0, &total_bytes); 5774 kmem_cache_stats("dblk", "streams_dblk", 1, &total_bytes); 5775 kmem_cache_stats("linkblk", "linkinfo_cache", 0, &total_bytes); 5776 kmem_cache_stats("syncq", "syncq_cache", 0, &total_bytes); 5777 kmem_cache_stats("qband", "qband_cache", 0, &total_bytes); 5778 5779 (void) printf("\n%lld Kbytes allocated for streams data\n", 5780 total_bytes / 1024); 5781 5782 (void) putchar('\n'); 5783 (void) fflush(stdout); 5784 } 5785 5786 /* --------------------------------- */ 5787 5788 /* 5789 * Print an IPv4 address. Remove the matching part of the domain name 5790 * from the returned name. 5791 */ 5792 static char * 5793 pr_addr(uint_t addr, char *dst, uint_t dstlen) 5794 { 5795 char *cp; 5796 struct hostent *hp = NULL; 5797 static char domain[MAXHOSTNAMELEN + 1]; 5798 static boolean_t first = B_TRUE; 5799 int error_num; 5800 5801 if (first) { 5802 first = B_FALSE; 5803 if (sysinfo(SI_HOSTNAME, domain, MAXHOSTNAMELEN) != -1 && 5804 (cp = strchr(domain, '.'))) { 5805 (void) strncpy(domain, cp + 1, sizeof (domain)); 5806 } else 5807 domain[0] = 0; 5808 } 5809 cp = NULL; 5810 if (!Nflag) { 5811 ns_lookup_start(); 5812 hp = getipnodebyaddr((char *)&addr, sizeof (uint_t), AF_INET, 5813 &error_num); 5814 ns_lookup_end(); 5815 if (hp) { 5816 if ((cp = strchr(hp->h_name, '.')) != NULL && 5817 strcasecmp(cp + 1, domain) == 0) 5818 *cp = 0; 5819 cp = hp->h_name; 5820 } 5821 } 5822 if (cp != NULL) { 5823 (void) strncpy(dst, cp, dstlen); 5824 dst[dstlen - 1] = 0; 5825 } else { 5826 (void) inet_ntop(AF_INET, (char *)&addr, dst, dstlen); 5827 } 5828 if (hp != NULL) 5829 freehostent(hp); 5830 return (dst); 5831 } 5832 5833 /* 5834 * Print a non-zero IPv4 address. Print " --" if the address is zero. 5835 */ 5836 static char * 5837 pr_addrnz(ipaddr_t addr, char *dst, uint_t dstlen) 5838 { 5839 if (addr == INADDR_ANY) { 5840 (void) strlcpy(dst, " --", dstlen); 5841 return (dst); 5842 } 5843 return (pr_addr(addr, dst, dstlen)); 5844 } 5845 5846 /* 5847 * Print an IPv6 address. Remove the matching part of the domain name 5848 * from the returned name. 5849 */ 5850 static char * 5851 pr_addr6(const struct in6_addr *addr, char *dst, uint_t dstlen) 5852 { 5853 char *cp; 5854 struct hostent *hp = NULL; 5855 static char domain[MAXHOSTNAMELEN + 1]; 5856 static boolean_t first = B_TRUE; 5857 int error_num; 5858 5859 if (first) { 5860 first = B_FALSE; 5861 if (sysinfo(SI_HOSTNAME, domain, MAXHOSTNAMELEN) != -1 && 5862 (cp = strchr(domain, '.'))) { 5863 (void) strncpy(domain, cp + 1, sizeof (domain)); 5864 } else 5865 domain[0] = 0; 5866 } 5867 cp = NULL; 5868 if (!Nflag) { 5869 ns_lookup_start(); 5870 hp = getipnodebyaddr((char *)addr, 5871 sizeof (struct in6_addr), AF_INET6, &error_num); 5872 ns_lookup_end(); 5873 if (hp) { 5874 if ((cp = strchr(hp->h_name, '.')) != NULL && 5875 strcasecmp(cp + 1, domain) == 0) 5876 *cp = 0; 5877 cp = hp->h_name; 5878 } 5879 } 5880 if (cp != NULL) { 5881 (void) strncpy(dst, cp, dstlen); 5882 dst[dstlen - 1] = 0; 5883 } else { 5884 (void) inet_ntop(AF_INET6, (void *)addr, dst, dstlen); 5885 } 5886 if (hp != NULL) 5887 freehostent(hp); 5888 return (dst); 5889 } 5890 5891 /* For IPv4 masks */ 5892 static char * 5893 pr_mask(uint_t addr, char *dst, uint_t dstlen) 5894 { 5895 uint8_t *ip_addr = (uint8_t *)&addr; 5896 5897 (void) snprintf(dst, dstlen, "%d.%d.%d.%d", 5898 ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]); 5899 return (dst); 5900 } 5901 5902 /* 5903 * For ipv6 masks format is : dest/mask 5904 * Does not print /128 to save space in printout. H flag carries this notion. 5905 */ 5906 static char * 5907 pr_prefix6(const struct in6_addr *addr, uint_t prefixlen, char *dst, 5908 uint_t dstlen) 5909 { 5910 char *cp; 5911 5912 if (IN6_IS_ADDR_UNSPECIFIED(addr) && prefixlen == 0) { 5913 (void) strncpy(dst, "default", dstlen); 5914 dst[dstlen - 1] = 0; 5915 return (dst); 5916 } 5917 5918 (void) pr_addr6(addr, dst, dstlen); 5919 if (prefixlen != IPV6_ABITS) { 5920 /* How much room is left? */ 5921 cp = strchr(dst, '\0'); 5922 if (dst + dstlen > cp) { 5923 dstlen -= (cp - dst); 5924 (void) snprintf(cp, dstlen, "/%d", prefixlen); 5925 } 5926 } 5927 return (dst); 5928 } 5929 5930 /* Print IPv4 address and port */ 5931 static char * 5932 pr_ap(uint_t addr, uint_t port, char *proto, 5933 char *dst, uint_t dstlen) 5934 { 5935 char *cp; 5936 5937 if (addr == INADDR_ANY) { 5938 (void) strncpy(dst, " *", dstlen); 5939 dst[dstlen - 1] = 0; 5940 } else { 5941 (void) pr_addr(addr, dst, dstlen); 5942 } 5943 /* How much room is left? */ 5944 cp = strchr(dst, '\0'); 5945 if (dst + dstlen > cp + 1) { 5946 *cp++ = '.'; 5947 dstlen -= (cp - dst); 5948 dstlen--; 5949 (void) portname(port, proto, cp, dstlen); 5950 } 5951 return (dst); 5952 } 5953 5954 /* Print IPv6 address and port */ 5955 static char * 5956 pr_ap6(const in6_addr_t *addr, uint_t port, char *proto, 5957 char *dst, uint_t dstlen) 5958 { 5959 char *cp; 5960 5961 if (IN6_IS_ADDR_UNSPECIFIED(addr)) { 5962 (void) strncpy(dst, " *", dstlen); 5963 dst[dstlen - 1] = 0; 5964 } else { 5965 (void) pr_addr6(addr, dst, dstlen); 5966 } 5967 /* How much room is left? */ 5968 cp = strchr(dst, '\0'); 5969 if (dst + dstlen + 1 > cp) { 5970 *cp++ = '.'; 5971 dstlen -= (cp - dst); 5972 dstlen--; 5973 (void) portname(port, proto, cp, dstlen); 5974 } 5975 return (dst); 5976 } 5977 5978 /* 5979 * Return the name of the network whose address is given. The address is 5980 * assumed to be that of a net or subnet, not a host. 5981 */ 5982 static char * 5983 pr_net(uint_t addr, uint_t mask, char *dst, uint_t dstlen) 5984 { 5985 char *cp = NULL; 5986 struct netent *np = NULL; 5987 struct hostent *hp = NULL; 5988 uint_t net; 5989 int subnetshift; 5990 int error_num; 5991 5992 if (addr == INADDR_ANY && mask == INADDR_ANY) { 5993 (void) strncpy(dst, "default", dstlen); 5994 dst[dstlen - 1] = 0; 5995 return (dst); 5996 } 5997 5998 if (!Nflag && addr) { 5999 if (mask == 0) { 6000 if (IN_CLASSA(addr)) { 6001 mask = (uint_t)IN_CLASSA_NET; 6002 subnetshift = 8; 6003 } else if (IN_CLASSB(addr)) { 6004 mask = (uint_t)IN_CLASSB_NET; 6005 subnetshift = 8; 6006 } else { 6007 mask = (uint_t)IN_CLASSC_NET; 6008 subnetshift = 4; 6009 } 6010 /* 6011 * If there are more bits than the standard mask 6012 * would suggest, subnets must be in use. Guess at 6013 * the subnet mask, assuming reasonable width subnet 6014 * fields. 6015 */ 6016 while (addr & ~mask) 6017 /* compiler doesn't sign extend! */ 6018 mask = (mask | ((int)mask >> subnetshift)); 6019 } 6020 net = addr & mask; 6021 while ((mask & 1) == 0) 6022 mask >>= 1, net >>= 1; 6023 ns_lookup_start(); 6024 np = getnetbyaddr(net, AF_INET); 6025 ns_lookup_end(); 6026 if (np && np->n_net == net) 6027 cp = np->n_name; 6028 else { 6029 /* 6030 * Look for subnets in hosts map. 6031 */ 6032 ns_lookup_start(); 6033 hp = getipnodebyaddr((char *)&addr, sizeof (uint_t), 6034 AF_INET, &error_num); 6035 ns_lookup_end(); 6036 if (hp) 6037 cp = hp->h_name; 6038 } 6039 } 6040 if (cp != NULL) { 6041 (void) strncpy(dst, cp, dstlen); 6042 dst[dstlen - 1] = 0; 6043 } else { 6044 (void) inet_ntop(AF_INET, (char *)&addr, dst, dstlen); 6045 } 6046 if (hp != NULL) 6047 freehostent(hp); 6048 return (dst); 6049 } 6050 6051 /* 6052 * Return the name of the network whose address is given. 6053 * The address is assumed to be a host address. 6054 */ 6055 static char * 6056 pr_netaddr(uint_t addr, uint_t mask, char *dst, uint_t dstlen) 6057 { 6058 char *cp = NULL; 6059 struct netent *np = NULL; 6060 struct hostent *hp = NULL; 6061 uint_t net; 6062 uint_t netshifted; 6063 int subnetshift; 6064 struct in_addr in; 6065 int error_num; 6066 uint_t nbo_addr = addr; /* network byte order */ 6067 6068 addr = ntohl(addr); 6069 mask = ntohl(mask); 6070 if (addr == INADDR_ANY && mask == INADDR_ANY) { 6071 (void) strncpy(dst, "default", dstlen); 6072 dst[dstlen - 1] = 0; 6073 return (dst); 6074 } 6075 6076 /* Figure out network portion of address (with host portion = 0) */ 6077 if (addr) { 6078 /* Try figuring out mask if unknown (all 0s). */ 6079 if (mask == 0) { 6080 if (IN_CLASSA(addr)) { 6081 mask = (uint_t)IN_CLASSA_NET; 6082 subnetshift = 8; 6083 } else if (IN_CLASSB(addr)) { 6084 mask = (uint_t)IN_CLASSB_NET; 6085 subnetshift = 8; 6086 } else { 6087 mask = (uint_t)IN_CLASSC_NET; 6088 subnetshift = 4; 6089 } 6090 /* 6091 * If there are more bits than the standard mask 6092 * would suggest, subnets must be in use. Guess at 6093 * the subnet mask, assuming reasonable width subnet 6094 * fields. 6095 */ 6096 while (addr & ~mask) 6097 /* compiler doesn't sign extend! */ 6098 mask = (mask | ((int)mask >> subnetshift)); 6099 } 6100 net = netshifted = addr & mask; 6101 while ((mask & 1) == 0) 6102 mask >>= 1, netshifted >>= 1; 6103 } 6104 else 6105 net = netshifted = 0; 6106 6107 /* Try looking up name unless -n was specified. */ 6108 if (!Nflag) { 6109 ns_lookup_start(); 6110 np = getnetbyaddr(netshifted, AF_INET); 6111 ns_lookup_end(); 6112 if (np && np->n_net == netshifted) 6113 cp = np->n_name; 6114 else { 6115 /* 6116 * Look for subnets in hosts map. 6117 */ 6118 ns_lookup_start(); 6119 hp = getipnodebyaddr((char *)&nbo_addr, sizeof (uint_t), 6120 AF_INET, &error_num); 6121 ns_lookup_end(); 6122 if (hp) 6123 cp = hp->h_name; 6124 } 6125 6126 if (cp != NULL) { 6127 (void) strncpy(dst, cp, dstlen); 6128 dst[dstlen - 1] = 0; 6129 if (hp != NULL) 6130 freehostent(hp); 6131 return (dst); 6132 } 6133 /* 6134 * No name found for net: fallthru and return in decimal 6135 * dot notation. 6136 */ 6137 } 6138 6139 in.s_addr = htonl(net); 6140 (void) inet_ntop(AF_INET, (char *)&in, dst, dstlen); 6141 if (hp != NULL) 6142 freehostent(hp); 6143 return (dst); 6144 } 6145 6146 /* 6147 * Return the filter mode as a string: 6148 * 1 => "INCLUDE" 6149 * 2 => "EXCLUDE" 6150 * otherwise "<unknown>" 6151 */ 6152 static char * 6153 fmodestr(uint_t fmode) 6154 { 6155 switch (fmode) { 6156 case 1: 6157 return ("INCLUDE"); 6158 case 2: 6159 return ("EXCLUDE"); 6160 default: 6161 return ("<unknown>"); 6162 } 6163 } 6164 6165 #define MAX_STRING_SIZE 256 6166 6167 static const char * 6168 pr_secattr(const sec_attr_list_t *attrs) 6169 { 6170 int i; 6171 char buf[MAX_STRING_SIZE + 1], *cp; 6172 static char *sbuf; 6173 static size_t sbuf_len; 6174 struct rtsa_s rtsa; 6175 const sec_attr_list_t *aptr; 6176 6177 if (!RSECflag || attrs == NULL) 6178 return (""); 6179 6180 for (aptr = attrs, i = 1; aptr != NULL; aptr = aptr->sal_next) 6181 i += MAX_STRING_SIZE; 6182 if (i > sbuf_len) { 6183 cp = realloc(sbuf, i); 6184 if (cp == NULL) { 6185 perror("realloc security attribute buffer"); 6186 return (""); 6187 } 6188 sbuf_len = i; 6189 sbuf = cp; 6190 } 6191 6192 cp = sbuf; 6193 while (attrs != NULL) { 6194 const mib2_ipAttributeEntry_t *iae = attrs->sal_attr; 6195 6196 /* note: effectively hard-coded in rtsa_keyword */ 6197 rtsa.rtsa_mask = RTSA_CIPSO | RTSA_SLRANGE | RTSA_DOI; 6198 rtsa.rtsa_slrange = iae->iae_slrange; 6199 rtsa.rtsa_doi = iae->iae_doi; 6200 6201 (void) snprintf(cp, MAX_STRING_SIZE, 6202 "<%s>%s ", rtsa_to_str(&rtsa, buf, sizeof (buf)), 6203 attrs->sal_next == NULL ? "" : ","); 6204 cp += strlen(cp); 6205 attrs = attrs->sal_next; 6206 } 6207 *cp = '\0'; 6208 6209 return (sbuf); 6210 } 6211 6212 /* 6213 * Pretty print a port number. If the Nflag was 6214 * specified, use numbers instead of names. 6215 */ 6216 static char * 6217 portname(uint_t port, char *proto, char *dst, uint_t dstlen) 6218 { 6219 struct servent *sp = NULL; 6220 6221 if (!Nflag && port) { 6222 ns_lookup_start(); 6223 sp = getservbyport(htons(port), proto); 6224 ns_lookup_end(); 6225 } 6226 if (sp || port == 0) 6227 (void) snprintf(dst, dstlen, "%.*s", MAXHOSTNAMELEN, 6228 sp ? sp->s_name : "*"); 6229 else 6230 (void) snprintf(dst, dstlen, "%d", port); 6231 dst[dstlen - 1] = 0; 6232 return (dst); 6233 } 6234 6235 /*PRINTFLIKE2*/ 6236 void 6237 fail(int do_perror, char *message, ...) 6238 { 6239 va_list args; 6240 6241 va_start(args, message); 6242 (void) fputs("netstat: ", stderr); 6243 (void) vfprintf(stderr, message, args); 6244 va_end(args); 6245 if (do_perror) 6246 (void) fprintf(stderr, ": %s", strerror(errno)); 6247 (void) fputc('\n', stderr); 6248 exit(2); 6249 } 6250 6251 /* 6252 * Return value of named statistic for given kstat_named kstat; 6253 * return 0LL if named statistic is not in list (use "ll" as a 6254 * type qualifier when printing 64-bit int's with printf() ) 6255 */ 6256 static uint64_t 6257 kstat_named_value(kstat_t *ksp, char *name) 6258 { 6259 kstat_named_t *knp; 6260 uint64_t value; 6261 6262 if (ksp == NULL) 6263 return (0LL); 6264 6265 knp = kstat_data_lookup(ksp, name); 6266 if (knp == NULL) 6267 return (0LL); 6268 6269 switch (knp->data_type) { 6270 case KSTAT_DATA_INT32: 6271 case KSTAT_DATA_UINT32: 6272 value = (uint64_t)(knp->value.ui32); 6273 break; 6274 case KSTAT_DATA_INT64: 6275 case KSTAT_DATA_UINT64: 6276 value = knp->value.ui64; 6277 break; 6278 default: 6279 value = 0LL; 6280 break; 6281 } 6282 6283 return (value); 6284 } 6285 6286 kid_t 6287 safe_kstat_read(kstat_ctl_t *kc, kstat_t *ksp, void *data) 6288 { 6289 kid_t kstat_chain_id = kstat_read(kc, ksp, data); 6290 6291 if (kstat_chain_id == -1) 6292 fail(1, "kstat_read(%p, '%s') failed", (void *)kc, 6293 ksp->ks_name); 6294 return (kstat_chain_id); 6295 } 6296 6297 /* 6298 * Parse a list of IRE flag characters into a bit field. 6299 */ 6300 static uint_t 6301 flag_bits(const char *arg) 6302 { 6303 const char *cp; 6304 uint_t val; 6305 6306 if (*arg == '\0') 6307 fatal(1, "missing flag list\n"); 6308 6309 val = 0; 6310 while (*arg != '\0') { 6311 if ((cp = strchr(flag_list, *arg)) == NULL) 6312 fatal(1, "%c: illegal flag\n", *arg); 6313 val |= 1 << (cp - flag_list); 6314 arg++; 6315 } 6316 return (val); 6317 } 6318 6319 /* 6320 * Handle -f argument. Validate input format, sort by keyword, and 6321 * save off digested results. 6322 */ 6323 static void 6324 process_filter(char *arg) 6325 { 6326 int idx; 6327 int klen = 0; 6328 char *cp, *cp2; 6329 int val; 6330 filter_t *newf; 6331 struct hostent *hp; 6332 int error_num; 6333 uint8_t *ucp; 6334 int maxv; 6335 6336 /* Look up the keyword first */ 6337 if (strchr(arg, ':') == NULL) { 6338 idx = FK_AF; 6339 } else { 6340 for (idx = 0; idx < NFILTERKEYS; idx++) { 6341 klen = strlen(filter_keys[idx]); 6342 if (strncmp(filter_keys[idx], arg, klen) == 0 && 6343 arg[klen] == ':') 6344 break; 6345 } 6346 if (idx >= NFILTERKEYS) 6347 fatal(1, "%s: unknown filter keyword\n", arg); 6348 6349 /* Advance past keyword and separator. */ 6350 arg += klen + 1; 6351 } 6352 6353 if ((newf = malloc(sizeof (*newf))) == NULL) { 6354 perror("filter"); 6355 exit(1); 6356 } 6357 switch (idx) { 6358 case FK_AF: 6359 if (strcmp(arg, "inet") == 0) { 6360 newf->u.f_family = AF_INET; 6361 } else if (strcmp(arg, "inet6") == 0) { 6362 newf->u.f_family = AF_INET6; 6363 } else if (strcmp(arg, "unix") == 0) { 6364 newf->u.f_family = AF_UNIX; 6365 } else { 6366 newf->u.f_family = strtol(arg, &cp, 0); 6367 if (arg == cp || *cp != '\0') 6368 fatal(1, "%s: unknown address family.\n", arg); 6369 } 6370 break; 6371 6372 case FK_OUTIF: 6373 if (strcmp(arg, "none") == 0) { 6374 newf->u.f_ifname = NULL; 6375 break; 6376 } 6377 if (strcmp(arg, "any") == 0) { 6378 newf->u.f_ifname = ""; 6379 break; 6380 } 6381 val = strtol(arg, &cp, 0); 6382 if (val <= 0 || arg == cp || cp[0] != '\0') { 6383 if ((val = if_nametoindex(arg)) == 0) { 6384 perror(arg); 6385 exit(1); 6386 } 6387 } 6388 newf->u.f_ifname = arg; 6389 break; 6390 6391 case FK_DST: 6392 V4MASK_TO_V6(IP_HOST_MASK, newf->u.a.f_mask); 6393 if (strcmp(arg, "any") == 0) { 6394 /* Special semantics; any address *but* zero */ 6395 newf->u.a.f_address = NULL; 6396 (void) memset(&newf->u.a.f_mask, 0, 6397 sizeof (newf->u.a.f_mask)); 6398 break; 6399 } 6400 if (strcmp(arg, "none") == 0) { 6401 newf->u.a.f_address = NULL; 6402 break; 6403 } 6404 if ((cp = strrchr(arg, '/')) != NULL) 6405 *cp++ = '\0'; 6406 hp = getipnodebyname(arg, AF_INET6, AI_V4MAPPED|AI_ALL, 6407 &error_num); 6408 if (hp == NULL) 6409 fatal(1, "%s: invalid or unknown host address\n", arg); 6410 newf->u.a.f_address = hp; 6411 if (cp == NULL) { 6412 V4MASK_TO_V6(IP_HOST_MASK, newf->u.a.f_mask); 6413 } else { 6414 val = strtol(cp, &cp2, 0); 6415 if (cp != cp2 && cp2[0] == '\0') { 6416 /* 6417 * If decode as "/n" works, then translate 6418 * into a mask. 6419 */ 6420 if (hp->h_addr_list[0] != NULL && 6421 /* LINTED: (note 1) */ 6422 IN6_IS_ADDR_V4MAPPED((in6_addr_t *) 6423 hp->h_addr_list[0])) { 6424 maxv = IP_ABITS; 6425 } else { 6426 maxv = IPV6_ABITS; 6427 } 6428 if (val < 0 || val >= maxv) 6429 fatal(1, "%d: not in range 0 to %d\n", 6430 val, maxv - 1); 6431 if (maxv == IP_ABITS) 6432 val += IPV6_ABITS - IP_ABITS; 6433 ucp = newf->u.a.f_mask.s6_addr; 6434 while (val >= 8) 6435 *ucp++ = 0xff, val -= 8; 6436 *ucp++ = (0xff << (8 - val)) & 0xff; 6437 while (ucp < newf->u.a.f_mask.s6_addr + 6438 sizeof (newf->u.a.f_mask.s6_addr)) 6439 *ucp++ = 0; 6440 /* Otherwise, try as numeric address */ 6441 } else if (inet_pton(AF_INET6, 6442 cp, &newf->u.a.f_mask) <= 0) { 6443 fatal(1, "%s: illegal mask format\n", cp); 6444 } 6445 } 6446 break; 6447 6448 case FK_FLAGS: 6449 if (*arg == '+') { 6450 newf->u.f.f_flagset = flag_bits(arg + 1); 6451 newf->u.f.f_flagclear = 0; 6452 } else if (*arg == '-') { 6453 newf->u.f.f_flagset = 0; 6454 newf->u.f.f_flagclear = flag_bits(arg + 1); 6455 } else { 6456 newf->u.f.f_flagset = flag_bits(arg); 6457 newf->u.f.f_flagclear = ~newf->u.f.f_flagset; 6458 } 6459 break; 6460 6461 default: 6462 assert(0); 6463 } 6464 newf->f_next = filters[idx]; 6465 filters[idx] = newf; 6466 } 6467 6468 /* Determine if user wants this address family printed. */ 6469 static boolean_t 6470 family_selected(int family) 6471 { 6472 const filter_t *fp; 6473 6474 if (v4compat && family == AF_INET6) 6475 return (B_FALSE); 6476 if ((fp = filters[FK_AF]) == NULL) 6477 return (B_TRUE); 6478 while (fp != NULL) { 6479 if (fp->u.f_family == family) 6480 return (B_TRUE); 6481 fp = fp->f_next; 6482 } 6483 return (B_FALSE); 6484 } 6485 6486 /* 6487 * Convert the interface index to a string using the buffer `ifname', which 6488 * must be at least LIFNAMSIZ bytes. We first try to map it to name. If that 6489 * fails (e.g., because we're inside a zone and it does not have access to 6490 * interface for the index in question), just return "if#<num>". 6491 */ 6492 static char * 6493 ifindex2str(uint_t ifindex, char *ifname) 6494 { 6495 if (if_indextoname(ifindex, ifname) == NULL) 6496 (void) snprintf(ifname, LIFNAMSIZ, "if#%d", ifindex); 6497 6498 return (ifname); 6499 } 6500 6501 /* 6502 * print the usage line 6503 */ 6504 static void 6505 usage(char *cmdname) 6506 { 6507 (void) fprintf(stderr, "usage: %s [-anv] [-f address_family] " 6508 "[-T d|u]\n", cmdname); 6509 (void) fprintf(stderr, " %s [-n] [-f address_family] " 6510 "[-P protocol] [-T d|u] [-g | -p | -s [interval [count]]]\n", 6511 cmdname); 6512 (void) fprintf(stderr, " %s -m [-v] [-T d|u] " 6513 "[interval [count]]\n", cmdname); 6514 (void) fprintf(stderr, " %s -i [-I interface] [-an] " 6515 "[-f address_family] [-T d|u] [interval [count]]\n", cmdname); 6516 (void) fprintf(stderr, " %s -r [-anv] " 6517 "[-f address_family|filter] [-T d|u]\n", cmdname); 6518 (void) fprintf(stderr, " %s -M [-ns] [-f address_family] " 6519 "[-T d|u]\n", cmdname); 6520 (void) fprintf(stderr, " %s -D [-I interface] " 6521 "[-f address_family] [-T d|u]\n", cmdname); 6522 exit(EXIT_FAILURE); 6523 } 6524 6525 /* 6526 * fatal: print error message to stderr and 6527 * call exit(errcode) 6528 */ 6529 /*PRINTFLIKE2*/ 6530 static void 6531 fatal(int errcode, char *format, ...) 6532 { 6533 va_list argp; 6534 6535 if (format == NULL) 6536 return; 6537 6538 va_start(argp, format); 6539 (void) vfprintf(stderr, format, argp); 6540 va_end(argp); 6541 6542 exit(errcode); 6543 } 6544