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