1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2002 Dag-Erling Coïdan Smørgrav 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer 12 * in this position and unchanged. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 #include <sys/file.h> 36 #include <sys/socket.h> 37 #include <sys/socketvar.h> 38 #include <sys/sysctl.h> 39 #include <sys/jail.h> 40 #include <sys/user.h> 41 42 #include <sys/un.h> 43 #define _WANT_UNPCB 44 #include <sys/unpcb.h> 45 46 #include <net/route.h> 47 48 #include <netinet/in.h> 49 #include <netinet/in_pcb.h> 50 #include <netinet/sctp.h> 51 #include <netinet/tcp.h> 52 #define TCPSTATES /* load state names */ 53 #include <netinet/tcp_fsm.h> 54 #include <netinet/tcp_seq.h> 55 #include <netinet/tcp_var.h> 56 #include <arpa/inet.h> 57 58 #include <ctype.h> 59 #include <err.h> 60 #include <errno.h> 61 #include <jail.h> 62 #include <netdb.h> 63 #include <pwd.h> 64 #include <stdarg.h> 65 #include <stdio.h> 66 #include <stdlib.h> 67 #include <string.h> 68 #include <unistd.h> 69 70 #define sstosin(ss) ((struct sockaddr_in *)(ss)) 71 #define sstosin6(ss) ((struct sockaddr_in6 *)(ss)) 72 #define sstosun(ss) ((struct sockaddr_un *)(ss)) 73 #define sstosa(ss) ((struct sockaddr *)(ss)) 74 75 static int opt_4; /* Show IPv4 sockets */ 76 static int opt_6; /* Show IPv6 sockets */ 77 static int opt_C; /* Show congestion control */ 78 static int opt_c; /* Show connected sockets */ 79 static int opt_j; /* Show specified jail */ 80 static int opt_L; /* Don't show IPv4 or IPv6 loopback sockets */ 81 static int opt_l; /* Show listening sockets */ 82 static int opt_n; /* Don't resolve UIDs to user names */ 83 static int opt_q; /* Don't show header */ 84 static int opt_S; /* Show protocol stack if applicable */ 85 static int opt_s; /* Show protocol state if applicable */ 86 static int opt_U; /* Show remote UDP encapsulation port number */ 87 static int opt_u; /* Show Unix domain sockets */ 88 static int opt_v; /* Verbose mode */ 89 static int opt_w; /* Wide print area for addresses */ 90 91 /* 92 * Default protocols to use if no -P was defined. 93 */ 94 static const char *default_protos[] = {"sctp", "tcp", "udp", "divert" }; 95 static size_t default_numprotos = nitems(default_protos); 96 97 static int *protos; /* protocols to use */ 98 static size_t numprotos; /* allocated size of protos[] */ 99 100 static int *ports; 101 102 #define INT_BIT (sizeof(int)*CHAR_BIT) 103 #define SET_PORT(p) do { ports[p / INT_BIT] |= 1 << (p % INT_BIT); } while (0) 104 #define CHK_PORT(p) (ports[p / INT_BIT] & (1 << (p % INT_BIT))) 105 106 struct addr { 107 struct sockaddr_storage address; 108 unsigned int encaps_port; 109 int state; 110 struct addr *next; 111 }; 112 113 struct sock { 114 kvaddr_t socket; 115 kvaddr_t pcb; 116 int shown; 117 int vflag; 118 int family; 119 int proto; 120 int state; 121 const char *protoname; 122 char stack[TCP_FUNCTION_NAME_LEN_MAX]; 123 char cc[TCP_CA_NAME_MAX]; 124 struct addr *laddr; 125 struct addr *faddr; 126 struct sock *next; 127 }; 128 129 #define HASHSIZE 1009 130 static struct sock *sockhash[HASHSIZE]; 131 132 static struct xfile *xfiles; 133 static int nxfiles; 134 135 static int 136 xprintf(const char *fmt, ...) 137 { 138 va_list ap; 139 int len; 140 141 va_start(ap, fmt); 142 len = vprintf(fmt, ap); 143 va_end(ap); 144 if (len < 0) 145 err(1, "printf()"); 146 return (len); 147 } 148 149 static int 150 get_proto_type(const char *proto) 151 { 152 struct protoent *pent; 153 154 if (strlen(proto) == 0) 155 return (0); 156 pent = getprotobyname(proto); 157 if (pent == NULL) { 158 warn("getprotobyname"); 159 return (-1); 160 } 161 return (pent->p_proto); 162 } 163 164 static void 165 init_protos(int num) 166 { 167 int proto_count = 0; 168 169 if (num > 0) { 170 proto_count = num; 171 } else { 172 /* Find the maximum number of possible protocols. */ 173 while (getprotoent() != NULL) 174 proto_count++; 175 endprotoent(); 176 } 177 178 if ((protos = malloc(sizeof(int) * proto_count)) == NULL) 179 err(1, "malloc"); 180 numprotos = proto_count; 181 } 182 183 static int 184 parse_protos(char *protospec) 185 { 186 char *prot; 187 int proto_type, proto_index; 188 189 if (protospec == NULL) 190 return (-1); 191 192 init_protos(0); 193 proto_index = 0; 194 while ((prot = strsep(&protospec, ",")) != NULL) { 195 if (strlen(prot) == 0) 196 continue; 197 proto_type = get_proto_type(prot); 198 if (proto_type != -1) 199 protos[proto_index++] = proto_type; 200 } 201 numprotos = proto_index; 202 return (proto_index); 203 } 204 205 static void 206 parse_ports(const char *portspec) 207 { 208 const char *p, *q; 209 int port, end; 210 211 if (ports == NULL) 212 if ((ports = calloc(65536 / INT_BIT, sizeof(int))) == NULL) 213 err(1, "calloc()"); 214 p = portspec; 215 while (*p != '\0') { 216 if (!isdigit(*p)) 217 errx(1, "syntax error in port range"); 218 for (q = p; *q != '\0' && isdigit(*q); ++q) 219 /* nothing */ ; 220 for (port = 0; p < q; ++p) 221 port = port * 10 + digittoint(*p); 222 if (port < 0 || port > 65535) 223 errx(1, "invalid port number"); 224 SET_PORT(port); 225 switch (*p) { 226 case '-': 227 ++p; 228 break; 229 case ',': 230 ++p; 231 /* fall through */ 232 case '\0': 233 default: 234 continue; 235 } 236 for (q = p; *q != '\0' && isdigit(*q); ++q) 237 /* nothing */ ; 238 for (end = 0; p < q; ++p) 239 end = end * 10 + digittoint(*p); 240 if (end < port || end > 65535) 241 errx(1, "invalid port number"); 242 while (port++ < end) 243 SET_PORT(port); 244 if (*p == ',') 245 ++p; 246 } 247 } 248 249 static void 250 sockaddr(struct sockaddr_storage *ss, int af, void *addr, int port) 251 { 252 struct sockaddr_in *sin4; 253 struct sockaddr_in6 *sin6; 254 255 bzero(ss, sizeof(*ss)); 256 switch (af) { 257 case AF_INET: 258 sin4 = sstosin(ss); 259 sin4->sin_len = sizeof(*sin4); 260 sin4->sin_family = af; 261 sin4->sin_port = port; 262 sin4->sin_addr = *(struct in_addr *)addr; 263 break; 264 case AF_INET6: 265 sin6 = sstosin6(ss); 266 sin6->sin6_len = sizeof(*sin6); 267 sin6->sin6_family = af; 268 sin6->sin6_port = port; 269 sin6->sin6_addr = *(struct in6_addr *)addr; 270 #define s6_addr16 __u6_addr.__u6_addr16 271 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { 272 sin6->sin6_scope_id = 273 ntohs(sin6->sin6_addr.s6_addr16[1]); 274 sin6->sin6_addr.s6_addr16[1] = 0; 275 } 276 break; 277 default: 278 abort(); 279 } 280 } 281 282 static void 283 free_socket(struct sock *sock) 284 { 285 struct addr *cur, *next; 286 287 cur = sock->laddr; 288 while (cur != NULL) { 289 next = cur->next; 290 free(cur); 291 cur = next; 292 } 293 cur = sock->faddr; 294 while (cur != NULL) { 295 next = cur->next; 296 free(cur); 297 cur = next; 298 } 299 free(sock); 300 } 301 302 static void 303 gather_sctp(void) 304 { 305 struct sock *sock; 306 struct addr *laddr, *prev_laddr, *faddr, *prev_faddr; 307 struct xsctp_inpcb *xinpcb; 308 struct xsctp_tcb *xstcb; 309 struct xsctp_raddr *xraddr; 310 struct xsctp_laddr *xladdr; 311 const char *varname; 312 size_t len, offset; 313 char *buf; 314 int hash, vflag; 315 int no_stcb, local_all_loopback, foreign_all_loopback; 316 317 vflag = 0; 318 if (opt_4) 319 vflag |= INP_IPV4; 320 if (opt_6) 321 vflag |= INP_IPV6; 322 323 varname = "net.inet.sctp.assoclist"; 324 if (sysctlbyname(varname, 0, &len, 0, 0) < 0) { 325 if (errno != ENOENT) 326 err(1, "sysctlbyname()"); 327 return; 328 } 329 if ((buf = (char *)malloc(len)) == NULL) { 330 err(1, "malloc()"); 331 return; 332 } 333 if (sysctlbyname(varname, buf, &len, 0, 0) < 0) { 334 err(1, "sysctlbyname()"); 335 free(buf); 336 return; 337 } 338 xinpcb = (struct xsctp_inpcb *)(void *)buf; 339 offset = sizeof(struct xsctp_inpcb); 340 while ((offset < len) && (xinpcb->last == 0)) { 341 if ((sock = calloc(1, sizeof *sock)) == NULL) 342 err(1, "malloc()"); 343 sock->socket = xinpcb->socket; 344 sock->proto = IPPROTO_SCTP; 345 sock->protoname = "sctp"; 346 if (xinpcb->maxqlen == 0) 347 sock->state = SCTP_CLOSED; 348 else 349 sock->state = SCTP_LISTEN; 350 if (xinpcb->flags & SCTP_PCB_FLAGS_BOUND_V6) { 351 sock->family = AF_INET6; 352 /* 353 * Currently there is no way to distinguish between 354 * IPv6 only sockets or dual family sockets. 355 * So mark it as dual socket. 356 */ 357 sock->vflag = INP_IPV6 | INP_IPV4; 358 } else { 359 sock->family = AF_INET; 360 sock->vflag = INP_IPV4; 361 } 362 prev_laddr = NULL; 363 local_all_loopback = 1; 364 while (offset < len) { 365 xladdr = (struct xsctp_laddr *)(void *)(buf + offset); 366 offset += sizeof(struct xsctp_laddr); 367 if (xladdr->last == 1) 368 break; 369 if ((laddr = calloc(1, sizeof(struct addr))) == NULL) 370 err(1, "malloc()"); 371 switch (xladdr->address.sa.sa_family) { 372 case AF_INET: 373 #define __IN_IS_ADDR_LOOPBACK(pina) \ 374 ((ntohl((pina)->s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) 375 if (!__IN_IS_ADDR_LOOPBACK( 376 &xladdr->address.sin.sin_addr)) 377 local_all_loopback = 0; 378 #undef __IN_IS_ADDR_LOOPBACK 379 sockaddr(&laddr->address, AF_INET, 380 &xladdr->address.sin.sin_addr, 381 htons(xinpcb->local_port)); 382 break; 383 case AF_INET6: 384 if (!IN6_IS_ADDR_LOOPBACK( 385 &xladdr->address.sin6.sin6_addr)) 386 local_all_loopback = 0; 387 sockaddr(&laddr->address, AF_INET6, 388 &xladdr->address.sin6.sin6_addr, 389 htons(xinpcb->local_port)); 390 break; 391 default: 392 errx(1, "address family %d not supported", 393 xladdr->address.sa.sa_family); 394 } 395 laddr->next = NULL; 396 if (prev_laddr == NULL) 397 sock->laddr = laddr; 398 else 399 prev_laddr->next = laddr; 400 prev_laddr = laddr; 401 } 402 if (sock->laddr == NULL) { 403 if ((sock->laddr = 404 calloc(1, sizeof(struct addr))) == NULL) 405 err(1, "malloc()"); 406 sock->laddr->address.ss_family = sock->family; 407 if (sock->family == AF_INET) 408 sock->laddr->address.ss_len = 409 sizeof(struct sockaddr_in); 410 else 411 sock->laddr->address.ss_len = 412 sizeof(struct sockaddr_in6); 413 local_all_loopback = 0; 414 } 415 if ((sock->faddr = calloc(1, sizeof(struct addr))) == NULL) 416 err(1, "malloc()"); 417 sock->faddr->address.ss_family = sock->family; 418 if (sock->family == AF_INET) 419 sock->faddr->address.ss_len = 420 sizeof(struct sockaddr_in); 421 else 422 sock->faddr->address.ss_len = 423 sizeof(struct sockaddr_in6); 424 no_stcb = 1; 425 while (offset < len) { 426 xstcb = (struct xsctp_tcb *)(void *)(buf + offset); 427 offset += sizeof(struct xsctp_tcb); 428 if (no_stcb) { 429 if (opt_l && (sock->vflag & vflag) && 430 (!opt_L || !local_all_loopback) && 431 ((xinpcb->flags & SCTP_PCB_FLAGS_UDPTYPE) || 432 (xstcb->last == 1))) { 433 hash = (int)((uintptr_t)sock->socket % 434 HASHSIZE); 435 sock->next = sockhash[hash]; 436 sockhash[hash] = sock; 437 } else { 438 free_socket(sock); 439 } 440 } 441 if (xstcb->last == 1) 442 break; 443 no_stcb = 0; 444 if (opt_c) { 445 if ((sock = calloc(1, sizeof *sock)) == NULL) 446 err(1, "malloc()"); 447 sock->socket = xinpcb->socket; 448 sock->proto = IPPROTO_SCTP; 449 sock->protoname = "sctp"; 450 sock->state = (int)xstcb->state; 451 if (xinpcb->flags & SCTP_PCB_FLAGS_BOUND_V6) { 452 sock->family = AF_INET6; 453 /* 454 * Currently there is no way to distinguish 455 * between IPv6 only sockets or dual family 456 * sockets. So mark it as dual socket. 457 */ 458 sock->vflag = INP_IPV6 | INP_IPV4; 459 } else { 460 sock->family = AF_INET; 461 sock->vflag = INP_IPV4; 462 } 463 } 464 prev_laddr = NULL; 465 local_all_loopback = 1; 466 while (offset < len) { 467 xladdr = (struct xsctp_laddr *)(void *)(buf + 468 offset); 469 offset += sizeof(struct xsctp_laddr); 470 if (xladdr->last == 1) 471 break; 472 if (!opt_c) 473 continue; 474 laddr = calloc(1, sizeof(struct addr)); 475 if (laddr == NULL) 476 err(1, "malloc()"); 477 switch (xladdr->address.sa.sa_family) { 478 case AF_INET: 479 #define __IN_IS_ADDR_LOOPBACK(pina) \ 480 ((ntohl((pina)->s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) 481 if (!__IN_IS_ADDR_LOOPBACK( 482 &xladdr->address.sin.sin_addr)) 483 local_all_loopback = 0; 484 #undef __IN_IS_ADDR_LOOPBACK 485 sockaddr(&laddr->address, AF_INET, 486 &xladdr->address.sin.sin_addr, 487 htons(xstcb->local_port)); 488 break; 489 case AF_INET6: 490 if (!IN6_IS_ADDR_LOOPBACK( 491 &xladdr->address.sin6.sin6_addr)) 492 local_all_loopback = 0; 493 sockaddr(&laddr->address, AF_INET6, 494 &xladdr->address.sin6.sin6_addr, 495 htons(xstcb->local_port)); 496 break; 497 default: 498 errx(1, 499 "address family %d not supported", 500 xladdr->address.sa.sa_family); 501 } 502 laddr->next = NULL; 503 if (prev_laddr == NULL) 504 sock->laddr = laddr; 505 else 506 prev_laddr->next = laddr; 507 prev_laddr = laddr; 508 } 509 prev_faddr = NULL; 510 foreign_all_loopback = 1; 511 while (offset < len) { 512 xraddr = (struct xsctp_raddr *)(void *)(buf + 513 offset); 514 offset += sizeof(struct xsctp_raddr); 515 if (xraddr->last == 1) 516 break; 517 if (!opt_c) 518 continue; 519 faddr = calloc(1, sizeof(struct addr)); 520 if (faddr == NULL) 521 err(1, "malloc()"); 522 switch (xraddr->address.sa.sa_family) { 523 case AF_INET: 524 #define __IN_IS_ADDR_LOOPBACK(pina) \ 525 ((ntohl((pina)->s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) 526 if (!__IN_IS_ADDR_LOOPBACK( 527 &xraddr->address.sin.sin_addr)) 528 foreign_all_loopback = 0; 529 #undef __IN_IS_ADDR_LOOPBACK 530 sockaddr(&faddr->address, AF_INET, 531 &xraddr->address.sin.sin_addr, 532 htons(xstcb->remote_port)); 533 break; 534 case AF_INET6: 535 if (!IN6_IS_ADDR_LOOPBACK( 536 &xraddr->address.sin6.sin6_addr)) 537 foreign_all_loopback = 0; 538 sockaddr(&faddr->address, AF_INET6, 539 &xraddr->address.sin6.sin6_addr, 540 htons(xstcb->remote_port)); 541 break; 542 default: 543 errx(1, 544 "address family %d not supported", 545 xraddr->address.sa.sa_family); 546 } 547 faddr->encaps_port = xraddr->encaps_port; 548 faddr->state = xraddr->state; 549 faddr->next = NULL; 550 if (prev_faddr == NULL) 551 sock->faddr = faddr; 552 else 553 prev_faddr->next = faddr; 554 prev_faddr = faddr; 555 } 556 if (opt_c) { 557 if ((sock->vflag & vflag) && 558 (!opt_L || 559 !(local_all_loopback || 560 foreign_all_loopback))) { 561 hash = (int)((uintptr_t)sock->socket % 562 HASHSIZE); 563 sock->next = sockhash[hash]; 564 sockhash[hash] = sock; 565 } else { 566 free_socket(sock); 567 } 568 } 569 } 570 xinpcb = (struct xsctp_inpcb *)(void *)(buf + offset); 571 offset += sizeof(struct xsctp_inpcb); 572 } 573 free(buf); 574 } 575 576 static void 577 gather_inet(int proto) 578 { 579 struct xinpgen *xig, *exig; 580 struct xinpcb *xip; 581 struct xtcpcb *xtp = NULL; 582 struct xsocket *so; 583 struct sock *sock; 584 struct addr *laddr, *faddr; 585 const char *varname, *protoname; 586 size_t len, bufsize; 587 void *buf; 588 int hash, retry, vflag; 589 590 vflag = 0; 591 if (opt_4) 592 vflag |= INP_IPV4; 593 if (opt_6) 594 vflag |= INP_IPV6; 595 596 switch (proto) { 597 case IPPROTO_TCP: 598 varname = "net.inet.tcp.pcblist"; 599 protoname = "tcp"; 600 break; 601 case IPPROTO_UDP: 602 varname = "net.inet.udp.pcblist"; 603 protoname = "udp"; 604 break; 605 case IPPROTO_DIVERT: 606 varname = "net.inet.divert.pcblist"; 607 protoname = "div"; 608 break; 609 default: 610 errx(1, "protocol %d not supported", proto); 611 } 612 613 buf = NULL; 614 bufsize = 8192; 615 retry = 5; 616 do { 617 for (;;) { 618 if ((buf = realloc(buf, bufsize)) == NULL) 619 err(1, "realloc()"); 620 len = bufsize; 621 if (sysctlbyname(varname, buf, &len, NULL, 0) == 0) 622 break; 623 if (errno == ENOENT) 624 goto out; 625 if (errno != ENOMEM || len != bufsize) 626 err(1, "sysctlbyname()"); 627 bufsize *= 2; 628 } 629 xig = (struct xinpgen *)buf; 630 exig = (struct xinpgen *)(void *) 631 ((char *)buf + len - sizeof *exig); 632 if (xig->xig_len != sizeof *xig || 633 exig->xig_len != sizeof *exig) 634 errx(1, "struct xinpgen size mismatch"); 635 } while (xig->xig_gen != exig->xig_gen && retry--); 636 637 if (xig->xig_gen != exig->xig_gen && opt_v) 638 warnx("warning: data may be inconsistent"); 639 640 for (;;) { 641 xig = (struct xinpgen *)(void *)((char *)xig + xig->xig_len); 642 if (xig >= exig) 643 break; 644 switch (proto) { 645 case IPPROTO_TCP: 646 xtp = (struct xtcpcb *)xig; 647 xip = &xtp->xt_inp; 648 if (xtp->xt_len != sizeof(*xtp)) { 649 warnx("struct xtcpcb size mismatch"); 650 goto out; 651 } 652 protoname = xtp->t_flags & TF_TOE ? "toe" : "tcp"; 653 break; 654 case IPPROTO_UDP: 655 case IPPROTO_DIVERT: 656 xip = (struct xinpcb *)xig; 657 if (xip->xi_len != sizeof(*xip)) { 658 warnx("struct xinpcb size mismatch"); 659 goto out; 660 } 661 break; 662 default: 663 errx(1, "protocol %d not supported", proto); 664 } 665 so = &xip->xi_socket; 666 if ((xip->inp_vflag & vflag) == 0) 667 continue; 668 if (xip->inp_vflag & INP_IPV4) { 669 if ((xip->inp_fport == 0 && !opt_l) || 670 (xip->inp_fport != 0 && !opt_c)) 671 continue; 672 #define __IN_IS_ADDR_LOOPBACK(pina) \ 673 ((ntohl((pina)->s_addr) >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) 674 if (opt_L && 675 (__IN_IS_ADDR_LOOPBACK(&xip->inp_faddr) || 676 __IN_IS_ADDR_LOOPBACK(&xip->inp_laddr))) 677 continue; 678 #undef __IN_IS_ADDR_LOOPBACK 679 } else if (xip->inp_vflag & INP_IPV6) { 680 if ((xip->inp_fport == 0 && !opt_l) || 681 (xip->inp_fport != 0 && !opt_c)) 682 continue; 683 if (opt_L && 684 (IN6_IS_ADDR_LOOPBACK(&xip->in6p_faddr) || 685 IN6_IS_ADDR_LOOPBACK(&xip->in6p_laddr))) 686 continue; 687 } else { 688 if (opt_v) 689 warnx("invalid vflag 0x%x", xip->inp_vflag); 690 continue; 691 } 692 if ((sock = calloc(1, sizeof(*sock))) == NULL) 693 err(1, "malloc()"); 694 if ((laddr = calloc(1, sizeof *laddr)) == NULL) 695 err(1, "malloc()"); 696 if ((faddr = calloc(1, sizeof *faddr)) == NULL) 697 err(1, "malloc()"); 698 sock->socket = so->xso_so; 699 sock->proto = proto; 700 if (xip->inp_vflag & INP_IPV4) { 701 sock->family = AF_INET; 702 sockaddr(&laddr->address, sock->family, 703 &xip->inp_laddr, xip->inp_lport); 704 sockaddr(&faddr->address, sock->family, 705 &xip->inp_faddr, xip->inp_fport); 706 } else if (xip->inp_vflag & INP_IPV6) { 707 sock->family = AF_INET6; 708 sockaddr(&laddr->address, sock->family, 709 &xip->in6p_laddr, xip->inp_lport); 710 sockaddr(&faddr->address, sock->family, 711 &xip->in6p_faddr, xip->inp_fport); 712 } 713 if (proto == IPPROTO_TCP) 714 faddr->encaps_port = xtp->xt_encaps_port; 715 laddr->next = NULL; 716 faddr->next = NULL; 717 sock->laddr = laddr; 718 sock->faddr = faddr; 719 sock->vflag = xip->inp_vflag; 720 if (proto == IPPROTO_TCP) { 721 sock->state = xtp->t_state; 722 memcpy(sock->stack, xtp->xt_stack, 723 TCP_FUNCTION_NAME_LEN_MAX); 724 memcpy(sock->cc, xtp->xt_cc, TCP_CA_NAME_MAX); 725 } 726 sock->protoname = protoname; 727 hash = (int)((uintptr_t)sock->socket % HASHSIZE); 728 sock->next = sockhash[hash]; 729 sockhash[hash] = sock; 730 } 731 out: 732 free(buf); 733 } 734 735 static void 736 gather_unix(int proto) 737 { 738 struct xunpgen *xug, *exug; 739 struct xunpcb *xup; 740 struct sock *sock; 741 struct addr *laddr, *faddr; 742 const char *varname, *protoname; 743 size_t len, bufsize; 744 void *buf; 745 int hash, retry; 746 747 switch (proto) { 748 case SOCK_STREAM: 749 varname = "net.local.stream.pcblist"; 750 protoname = "stream"; 751 break; 752 case SOCK_DGRAM: 753 varname = "net.local.dgram.pcblist"; 754 protoname = "dgram"; 755 break; 756 case SOCK_SEQPACKET: 757 varname = "net.local.seqpacket.pcblist"; 758 protoname = "seqpac"; 759 break; 760 default: 761 abort(); 762 } 763 buf = NULL; 764 bufsize = 8192; 765 retry = 5; 766 do { 767 for (;;) { 768 if ((buf = realloc(buf, bufsize)) == NULL) 769 err(1, "realloc()"); 770 len = bufsize; 771 if (sysctlbyname(varname, buf, &len, NULL, 0) == 0) 772 break; 773 if (errno != ENOMEM || len != bufsize) 774 err(1, "sysctlbyname()"); 775 bufsize *= 2; 776 } 777 xug = (struct xunpgen *)buf; 778 exug = (struct xunpgen *)(void *) 779 ((char *)buf + len - sizeof(*exug)); 780 if (xug->xug_len != sizeof(*xug) || 781 exug->xug_len != sizeof(*exug)) { 782 warnx("struct xinpgen size mismatch"); 783 goto out; 784 } 785 } while (xug->xug_gen != exug->xug_gen && retry--); 786 787 if (xug->xug_gen != exug->xug_gen && opt_v) 788 warnx("warning: data may be inconsistent"); 789 790 for (;;) { 791 xug = (struct xunpgen *)(void *)((char *)xug + xug->xug_len); 792 if (xug >= exug) 793 break; 794 xup = (struct xunpcb *)xug; 795 if (xup->xu_len != sizeof(*xup)) { 796 warnx("struct xunpcb size mismatch"); 797 goto out; 798 } 799 if ((xup->unp_conn == 0 && !opt_l) || 800 (xup->unp_conn != 0 && !opt_c)) 801 continue; 802 if ((sock = calloc(1, sizeof(*sock))) == NULL) 803 err(1, "malloc()"); 804 if ((laddr = calloc(1, sizeof *laddr)) == NULL) 805 err(1, "malloc()"); 806 if ((faddr = calloc(1, sizeof *faddr)) == NULL) 807 err(1, "malloc()"); 808 sock->socket = xup->xu_socket.xso_so; 809 sock->pcb = xup->xu_unpp; 810 sock->proto = proto; 811 sock->family = AF_UNIX; 812 sock->protoname = protoname; 813 if (xup->xu_addr.sun_family == AF_UNIX) 814 laddr->address = 815 *(struct sockaddr_storage *)(void *)&xup->xu_addr; 816 else if (xup->unp_conn != 0) 817 *(kvaddr_t*)&(faddr->address) = xup->unp_conn; 818 laddr->next = NULL; 819 faddr->next = NULL; 820 sock->laddr = laddr; 821 sock->faddr = faddr; 822 hash = (int)((uintptr_t)sock->socket % HASHSIZE); 823 sock->next = sockhash[hash]; 824 sockhash[hash] = sock; 825 } 826 out: 827 free(buf); 828 } 829 830 static void 831 getfiles(void) 832 { 833 size_t len, olen; 834 835 olen = len = sizeof(*xfiles); 836 if ((xfiles = malloc(len)) == NULL) 837 err(1, "malloc()"); 838 while (sysctlbyname("kern.file", xfiles, &len, 0, 0) == -1) { 839 if (errno != ENOMEM || len != olen) 840 err(1, "sysctlbyname()"); 841 olen = len *= 2; 842 if ((xfiles = realloc(xfiles, len)) == NULL) 843 err(1, "realloc()"); 844 } 845 if (len > 0 && xfiles->xf_size != sizeof(*xfiles)) 846 errx(1, "struct xfile size mismatch"); 847 nxfiles = len / sizeof(*xfiles); 848 } 849 850 static int 851 printaddr(struct sockaddr_storage *ss) 852 { 853 struct sockaddr_un *sun; 854 char addrstr[NI_MAXHOST] = { '\0', '\0' }; 855 int error, off, port = 0; 856 857 switch (ss->ss_family) { 858 case AF_INET: 859 if (inet_lnaof(sstosin(ss)->sin_addr) == INADDR_ANY) 860 addrstr[0] = '*'; 861 port = ntohs(sstosin(ss)->sin_port); 862 break; 863 case AF_INET6: 864 if (IN6_IS_ADDR_UNSPECIFIED(&sstosin6(ss)->sin6_addr)) 865 addrstr[0] = '*'; 866 port = ntohs(sstosin6(ss)->sin6_port); 867 break; 868 case AF_UNIX: 869 sun = sstosun(ss); 870 off = (int)((char *)&sun->sun_path - (char *)sun); 871 return (xprintf("%.*s", sun->sun_len - off, sun->sun_path)); 872 } 873 if (addrstr[0] == '\0') { 874 error = getnameinfo(sstosa(ss), ss->ss_len, addrstr, 875 sizeof(addrstr), NULL, 0, NI_NUMERICHOST); 876 if (error) 877 errx(1, "getnameinfo()"); 878 } 879 if (port == 0) 880 return xprintf("%s:*", addrstr); 881 else 882 return xprintf("%s:%d", addrstr, port); 883 } 884 885 static const char * 886 getprocname(pid_t pid) 887 { 888 static struct kinfo_proc proc; 889 size_t len; 890 int mib[4]; 891 892 mib[0] = CTL_KERN; 893 mib[1] = KERN_PROC; 894 mib[2] = KERN_PROC_PID; 895 mib[3] = (int)pid; 896 len = sizeof(proc); 897 if (sysctl(mib, nitems(mib), &proc, &len, NULL, 0) == -1) { 898 /* Do not warn if the process exits before we get its name. */ 899 if (errno != ESRCH) 900 warn("sysctl()"); 901 return ("??"); 902 } 903 return (proc.ki_comm); 904 } 905 906 static int 907 getprocjid(pid_t pid) 908 { 909 static struct kinfo_proc proc; 910 size_t len; 911 int mib[4]; 912 913 mib[0] = CTL_KERN; 914 mib[1] = KERN_PROC; 915 mib[2] = KERN_PROC_PID; 916 mib[3] = (int)pid; 917 len = sizeof(proc); 918 if (sysctl(mib, nitems(mib), &proc, &len, NULL, 0) == -1) { 919 /* Do not warn if the process exits before we get its jid. */ 920 if (errno != ESRCH) 921 warn("sysctl()"); 922 return (-1); 923 } 924 return (proc.ki_jid); 925 } 926 927 static int 928 check_ports(struct sock *s) 929 { 930 int port; 931 struct addr *addr; 932 933 if (ports == NULL) 934 return (1); 935 if ((s->family != AF_INET) && (s->family != AF_INET6)) 936 return (1); 937 for (addr = s->laddr; addr != NULL; addr = addr->next) { 938 if (s->family == AF_INET) 939 port = ntohs(sstosin(&addr->address)->sin_port); 940 else 941 port = ntohs(sstosin6(&addr->address)->sin6_port); 942 if (CHK_PORT(port)) 943 return (1); 944 } 945 for (addr = s->faddr; addr != NULL; addr = addr->next) { 946 if (s->family == AF_INET) 947 port = ntohs(sstosin(&addr->address)->sin_port); 948 else 949 port = ntohs(sstosin6(&addr->address)->sin6_port); 950 if (CHK_PORT(port)) 951 return (1); 952 } 953 return (0); 954 } 955 956 static const char * 957 sctp_conn_state(int state) 958 { 959 switch (state) { 960 case SCTP_CLOSED: 961 return "CLOSED"; 962 break; 963 case SCTP_BOUND: 964 return "BOUND"; 965 break; 966 case SCTP_LISTEN: 967 return "LISTEN"; 968 break; 969 case SCTP_COOKIE_WAIT: 970 return "COOKIE_WAIT"; 971 break; 972 case SCTP_COOKIE_ECHOED: 973 return "COOKIE_ECHOED"; 974 break; 975 case SCTP_ESTABLISHED: 976 return "ESTABLISHED"; 977 break; 978 case SCTP_SHUTDOWN_SENT: 979 return "SHUTDOWN_SENT"; 980 break; 981 case SCTP_SHUTDOWN_RECEIVED: 982 return "SHUTDOWN_RECEIVED"; 983 break; 984 case SCTP_SHUTDOWN_ACK_SENT: 985 return "SHUTDOWN_ACK_SENT"; 986 break; 987 case SCTP_SHUTDOWN_PENDING: 988 return "SHUTDOWN_PENDING"; 989 break; 990 default: 991 return "UNKNOWN"; 992 break; 993 } 994 } 995 996 static const char * 997 sctp_path_state(int state) 998 { 999 switch (state) { 1000 case SCTP_UNCONFIRMED: 1001 return "UNCONFIRMED"; 1002 break; 1003 case SCTP_ACTIVE: 1004 return "ACTIVE"; 1005 break; 1006 case SCTP_INACTIVE: 1007 return "INACTIVE"; 1008 break; 1009 default: 1010 return "UNKNOWN"; 1011 break; 1012 } 1013 } 1014 1015 static void 1016 displaysock(struct sock *s, int pos) 1017 { 1018 kvaddr_t p; 1019 int hash, first, offset; 1020 struct addr *laddr, *faddr; 1021 struct sock *s_tmp; 1022 1023 while (pos < 29) 1024 pos += xprintf(" "); 1025 pos += xprintf("%s", s->protoname); 1026 if (s->vflag & INP_IPV4) 1027 pos += xprintf("4"); 1028 if (s->vflag & INP_IPV6) 1029 pos += xprintf("6"); 1030 if (s->vflag & (INP_IPV4 | INP_IPV6)) 1031 pos += xprintf(" "); 1032 laddr = s->laddr; 1033 faddr = s->faddr; 1034 first = 1; 1035 while (laddr != NULL || faddr != NULL) { 1036 offset = 36; 1037 while (pos < offset) 1038 pos += xprintf(" "); 1039 switch (s->family) { 1040 case AF_INET: 1041 case AF_INET6: 1042 if (laddr != NULL) { 1043 pos += printaddr(&laddr->address); 1044 if (s->family == AF_INET6 && pos >= 58) 1045 pos += xprintf(" "); 1046 } 1047 offset += opt_w ? 46 : 22; 1048 while (pos < offset) 1049 pos += xprintf(" "); 1050 if (faddr != NULL) 1051 pos += printaddr(&faddr->address); 1052 offset += opt_w ? 46 : 22; 1053 break; 1054 case AF_UNIX: 1055 if ((laddr == NULL) || (faddr == NULL)) 1056 errx(1, "laddr = %p or faddr = %p is NULL", 1057 (void *)laddr, (void *)faddr); 1058 /* server */ 1059 if (laddr->address.ss_len > 0) { 1060 pos += printaddr(&laddr->address); 1061 break; 1062 } 1063 /* client */ 1064 p = *(kvaddr_t*)&(faddr->address); 1065 if (p == 0) { 1066 pos += xprintf("(not connected)"); 1067 offset += opt_w ? 92 : 44; 1068 break; 1069 } 1070 pos += xprintf("-> "); 1071 for (hash = 0; hash < HASHSIZE; ++hash) { 1072 for (s_tmp = sockhash[hash]; 1073 s_tmp != NULL; 1074 s_tmp = s_tmp->next) 1075 if (s_tmp->pcb == p) 1076 break; 1077 if (s_tmp != NULL) 1078 break; 1079 } 1080 if (s_tmp == NULL || s_tmp->laddr == NULL || 1081 s_tmp->laddr->address.ss_len == 0) 1082 pos += xprintf("??"); 1083 else 1084 pos += printaddr(&s_tmp->laddr->address); 1085 offset += opt_w ? 92 : 44; 1086 break; 1087 default: 1088 abort(); 1089 } 1090 if (opt_U) { 1091 if (faddr != NULL && 1092 ((s->proto == IPPROTO_SCTP && 1093 s->state != SCTP_CLOSED && 1094 s->state != SCTP_BOUND && 1095 s->state != SCTP_LISTEN) || 1096 (s->proto == IPPROTO_TCP && 1097 s->state != TCPS_CLOSED && 1098 s->state != TCPS_LISTEN))) { 1099 while (pos < offset) 1100 pos += xprintf(" "); 1101 pos += xprintf("%u", 1102 ntohs(faddr->encaps_port)); 1103 } 1104 offset += 7; 1105 } 1106 if (opt_s) { 1107 if (faddr != NULL && 1108 s->proto == IPPROTO_SCTP && 1109 s->state != SCTP_CLOSED && 1110 s->state != SCTP_BOUND && 1111 s->state != SCTP_LISTEN) { 1112 while (pos < offset) 1113 pos += xprintf(" "); 1114 pos += xprintf("%s", 1115 sctp_path_state(faddr->state)); 1116 } 1117 offset += 13; 1118 } 1119 if (first) { 1120 if (opt_s) { 1121 if (s->proto == IPPROTO_SCTP || 1122 s->proto == IPPROTO_TCP) { 1123 while (pos < offset) 1124 pos += xprintf(" "); 1125 switch (s->proto) { 1126 case IPPROTO_SCTP: 1127 pos += xprintf("%s", 1128 sctp_conn_state(s->state)); 1129 break; 1130 case IPPROTO_TCP: 1131 if (s->state >= 0 && 1132 s->state < TCP_NSTATES) 1133 pos += xprintf("%s", 1134 tcpstates[s->state]); 1135 else 1136 pos += xprintf("?"); 1137 break; 1138 } 1139 } 1140 offset += 13; 1141 } 1142 if (opt_S) { 1143 if (s->proto == IPPROTO_TCP) { 1144 while (pos < offset) 1145 pos += xprintf(" "); 1146 pos += xprintf("%.*s", 1147 TCP_FUNCTION_NAME_LEN_MAX, 1148 s->stack); 1149 } 1150 offset += TCP_FUNCTION_NAME_LEN_MAX + 1; 1151 } 1152 if (opt_C) { 1153 if (s->proto == IPPROTO_TCP) { 1154 while (pos < offset) 1155 pos += xprintf(" "); 1156 xprintf("%.*s", TCP_CA_NAME_MAX, s->cc); 1157 } 1158 offset += TCP_CA_NAME_MAX + 1; 1159 } 1160 } 1161 if (laddr != NULL) 1162 laddr = laddr->next; 1163 if (faddr != NULL) 1164 faddr = faddr->next; 1165 if ((laddr != NULL) || (faddr != NULL)) { 1166 xprintf("\n"); 1167 pos = 0; 1168 } 1169 first = 0; 1170 } 1171 xprintf("\n"); 1172 } 1173 1174 static void 1175 display(void) 1176 { 1177 struct passwd *pwd; 1178 struct xfile *xf; 1179 struct sock *s; 1180 int hash, n, pos; 1181 1182 if (opt_q != 1) { 1183 printf("%-8s %-10s %-5s %-2s %-6s %-*s %-*s", 1184 "USER", "COMMAND", "PID", "FD", "PROTO", 1185 opt_w ? 45 : 21, "LOCAL ADDRESS", 1186 opt_w ? 45 : 21, "FOREIGN ADDRESS"); 1187 if (opt_U) 1188 printf(" %-6s", "ENCAPS"); 1189 if (opt_s) { 1190 printf(" %-12s", "PATH STATE"); 1191 printf(" %-12s", "CONN STATE"); 1192 } 1193 if (opt_S) 1194 printf(" %-*.*s", TCP_FUNCTION_NAME_LEN_MAX, 1195 TCP_FUNCTION_NAME_LEN_MAX, "STACK"); 1196 if (opt_C) 1197 printf(" %-.*s", TCP_CA_NAME_MAX, "CC"); 1198 printf("\n"); 1199 } 1200 setpassent(1); 1201 for (xf = xfiles, n = 0; n < nxfiles; ++n, ++xf) { 1202 if (xf->xf_data == 0) 1203 continue; 1204 if (opt_j >= 0 && opt_j != getprocjid(xf->xf_pid)) 1205 continue; 1206 hash = (int)((uintptr_t)xf->xf_data % HASHSIZE); 1207 for (s = sockhash[hash]; s != NULL; s = s->next) { 1208 if (s->socket != xf->xf_data) 1209 continue; 1210 if (!check_ports(s)) 1211 continue; 1212 s->shown = 1; 1213 pos = 0; 1214 if (opt_n || (pwd = getpwuid(xf->xf_uid)) == NULL) 1215 pos += xprintf("%lu ", (u_long)xf->xf_uid); 1216 else 1217 pos += xprintf("%s ", pwd->pw_name); 1218 while (pos < 9) 1219 pos += xprintf(" "); 1220 pos += xprintf("%.10s", getprocname(xf->xf_pid)); 1221 while (pos < 20) 1222 pos += xprintf(" "); 1223 pos += xprintf("%lu ", (u_long)xf->xf_pid); 1224 while (pos < 26) 1225 pos += xprintf(" "); 1226 pos += xprintf("%d ", xf->xf_fd); 1227 displaysock(s, pos); 1228 } 1229 } 1230 if (opt_j >= 0) 1231 return; 1232 for (hash = 0; hash < HASHSIZE; hash++) { 1233 for (s = sockhash[hash]; s != NULL; s = s->next) { 1234 if (s->shown) 1235 continue; 1236 if (!check_ports(s)) 1237 continue; 1238 pos = 0; 1239 pos += xprintf("%-8s %-10s %-5s %-2s ", 1240 "?", "?", "?", "?"); 1241 displaysock(s, pos); 1242 } 1243 } 1244 } 1245 1246 static int 1247 set_default_protos(void) 1248 { 1249 struct protoent *prot; 1250 const char *pname; 1251 size_t pindex; 1252 1253 init_protos(default_numprotos); 1254 1255 for (pindex = 0; pindex < default_numprotos; pindex++) { 1256 pname = default_protos[pindex]; 1257 prot = getprotobyname(pname); 1258 if (prot == NULL) 1259 err(1, "getprotobyname: %s", pname); 1260 protos[pindex] = prot->p_proto; 1261 } 1262 numprotos = pindex; 1263 return (pindex); 1264 } 1265 1266 /* 1267 * Return the vnet property of the jail, or -1 on error. 1268 */ 1269 static int 1270 jail_getvnet(int jid) 1271 { 1272 struct iovec jiov[6]; 1273 int vnet; 1274 1275 vnet = -1; 1276 jiov[0].iov_base = __DECONST(char *, "jid"); 1277 jiov[0].iov_len = sizeof("jid"); 1278 jiov[1].iov_base = &jid; 1279 jiov[1].iov_len = sizeof(jid); 1280 jiov[2].iov_base = __DECONST(char *, "vnet"); 1281 jiov[2].iov_len = sizeof("vnet"); 1282 jiov[3].iov_base = &vnet; 1283 jiov[3].iov_len = sizeof(vnet); 1284 jiov[4].iov_base = __DECONST(char *, "errmsg"); 1285 jiov[4].iov_len = sizeof("errmsg"); 1286 jiov[5].iov_base = jail_errmsg; 1287 jiov[5].iov_len = JAIL_ERRMSGLEN; 1288 jail_errmsg[0] = '\0'; 1289 if (jail_get(jiov, nitems(jiov), 0) < 0) { 1290 if (!jail_errmsg[0]) 1291 snprintf(jail_errmsg, JAIL_ERRMSGLEN, 1292 "jail_get: %s", strerror(errno)); 1293 return (-1); 1294 } 1295 return (vnet); 1296 } 1297 1298 static void 1299 usage(void) 1300 { 1301 fprintf(stderr, 1302 "usage: sockstat [-46cLlSsUuvw] [-j jid] [-p ports] [-P protocols]\n"); 1303 exit(1); 1304 } 1305 1306 int 1307 main(int argc, char *argv[]) 1308 { 1309 int protos_defined = -1; 1310 int o, i; 1311 1312 opt_j = -1; 1313 while ((o = getopt(argc, argv, "46Ccj:Llnp:P:qSsUuvw")) != -1) 1314 switch (o) { 1315 case '4': 1316 opt_4 = 1; 1317 break; 1318 case '6': 1319 opt_6 = 1; 1320 break; 1321 case 'C': 1322 opt_C = 1; 1323 break; 1324 case 'c': 1325 opt_c = 1; 1326 break; 1327 case 'j': 1328 opt_j = jail_getid(optarg); 1329 if (opt_j < 0) 1330 errx(1, "%s", jail_errmsg); 1331 break; 1332 case 'L': 1333 opt_L = 1; 1334 break; 1335 case 'l': 1336 opt_l = 1; 1337 break; 1338 case 'n': 1339 opt_n = 1; 1340 break; 1341 case 'p': 1342 parse_ports(optarg); 1343 break; 1344 case 'P': 1345 protos_defined = parse_protos(optarg); 1346 break; 1347 case 'q': 1348 opt_q = 1; 1349 break; 1350 case 'S': 1351 opt_S = 1; 1352 break; 1353 case 's': 1354 opt_s = 1; 1355 break; 1356 case 'U': 1357 opt_U = 1; 1358 break; 1359 case 'u': 1360 opt_u = 1; 1361 break; 1362 case 'v': 1363 ++opt_v; 1364 break; 1365 case 'w': 1366 opt_w = 1; 1367 break; 1368 default: 1369 usage(); 1370 } 1371 1372 argc -= optind; 1373 argv += optind; 1374 1375 if (argc > 0) 1376 usage(); 1377 1378 if (opt_j > 0) { 1379 switch (jail_getvnet(opt_j)) { 1380 case -1: 1381 errx(2, "%s", jail_errmsg); 1382 case JAIL_SYS_NEW: 1383 if (jail_attach(opt_j) < 0) 1384 err(3, "jail_attach()"); 1385 /* Set back to -1 for normal output in vnet jail. */ 1386 opt_j = -1; 1387 break; 1388 default: 1389 break; 1390 } 1391 } 1392 1393 if ((!opt_4 && !opt_6) && protos_defined != -1) 1394 opt_4 = opt_6 = 1; 1395 if (!opt_4 && !opt_6 && !opt_u) 1396 opt_4 = opt_6 = opt_u = 1; 1397 if ((opt_4 || opt_6) && protos_defined == -1) 1398 protos_defined = set_default_protos(); 1399 if (!opt_c && !opt_l) 1400 opt_c = opt_l = 1; 1401 1402 if (opt_4 || opt_6) { 1403 for (i = 0; i < protos_defined; i++) 1404 if (protos[i] == IPPROTO_SCTP) 1405 gather_sctp(); 1406 else 1407 gather_inet(protos[i]); 1408 } 1409 1410 if (opt_u || (protos_defined == -1 && !opt_4 && !opt_6)) { 1411 gather_unix(SOCK_STREAM); 1412 gather_unix(SOCK_DGRAM); 1413 gather_unix(SOCK_SEQPACKET); 1414 } 1415 getfiles(); 1416 display(); 1417 exit(0); 1418 } 1419