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