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