1 /* $NetBSD: sockstat.c,v 1.16 2011/01/28 18:52:49 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Andrew Brown. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 __RCSID("$NetBSD: sockstat.c,v 1.16 2011/01/28 18:52:49 pooka Exp $"); 35 #endif 36 37 #include <sys/types.h> 38 #include <sys/param.h> 39 #include <sys/sysctl.h> 40 #include <sys/socket.h> 41 #include <sys/socketvar.h> 42 #include <sys/un.h> 43 #include <netinet/in.h> 44 #include <net/route.h> 45 #include <netinet/in_systm.h> 46 #include <netinet/ip.h> 47 #include <netinet/in_pcb.h> 48 #include <netinet/in_pcb_hdr.h> 49 #include <netinet/tcp_fsm.h> 50 51 #define _KERNEL 52 /* want DTYPE_* defines */ 53 #include <sys/file.h> 54 #undef _KERNEL 55 56 #include <arpa/inet.h> 57 58 #include <bitstring.h> 59 #include <ctype.h> 60 #include <err.h> 61 #include <errno.h> 62 #include <netdb.h> 63 #include <pwd.h> 64 #include <stdio.h> 65 #include <strings.h> 66 #include <stdlib.h> 67 #include <unistd.h> 68 #include <util.h> 69 70 #include "prog_ops.h" 71 72 #define satosun(sa) ((struct sockaddr_un *)(sa)) 73 #define satosin(sa) ((struct sockaddr_in *)(sa)) 74 #ifdef INET6 75 #define satosin6(sa) ((struct sockaddr_in6 *)(sa)) 76 #endif 77 78 void parse_ports(const char *); 79 int get_num(const char *, const char **, const char **); 80 void get_sockets(const char *); 81 void get_files(void); 82 int sort_files(const void *, const void *); 83 void sysctl_sucker(int *, u_int, void **, size_t *); 84 void socket_add_hash(struct kinfo_pcb *, int); 85 int isconnected(struct kinfo_pcb *); 86 int islistening(struct kinfo_pcb *); 87 struct kinfo_pcb *pick_socket(struct kinfo_file *); 88 int get_proc(struct kinfo_proc2 *, int); 89 int print_socket(struct kinfo_file *, struct kinfo_pcb *, 90 struct kinfo_proc2 *); 91 void print_addr(int, int, int, struct sockaddr *); 92 93 LIST_HEAD(socklist, sockitem); 94 #define HASHSIZE 1009 95 struct socklist sockhash[HASHSIZE]; 96 struct sockitem { 97 LIST_ENTRY(sockitem) s_list; 98 struct kinfo_pcb *s_sock; 99 }; 100 101 struct kinfo_file *flist; 102 size_t flistc; 103 104 int pf_list, only, nonames; 105 bitstr_t *portmap; 106 107 #define PF_LIST_INET 1 108 #ifdef INET6 109 #define PF_LIST_INET6 2 110 #endif 111 #define PF_LIST_LOCAL 4 112 #define ONLY_CONNECTED 1 113 #define ONLY_LISTEN 2 114 115 int 116 main(int argc, char *argv[]) 117 { 118 struct kinfo_pcb *kp; 119 int ch; 120 size_t i; 121 struct kinfo_proc2 p; 122 123 pf_list = only = 0; 124 125 #ifdef INET6 126 while ((ch = getopt(argc, argv, "46cf:lnp:u")) != - 1) { 127 #else 128 while ((ch = getopt(argc, argv, "4cf:lnp:u")) != - 1) { 129 #endif 130 switch (ch) { 131 case '4': 132 pf_list |= PF_LIST_INET; 133 break; 134 #ifdef INET6 135 case '6': 136 pf_list |= PF_LIST_INET6; 137 break; 138 #endif 139 case 'c': 140 only |= ONLY_CONNECTED; 141 break; 142 case 'f': 143 if (strcasecmp(optarg, "inet") == 0) 144 pf_list |= PF_LIST_INET; 145 #ifdef INET6 146 else if (strcasecmp(optarg, "inet6") == 0) 147 pf_list |= PF_LIST_INET6; 148 #endif 149 else if (strcasecmp(optarg, "local") == 0) 150 pf_list |= PF_LIST_LOCAL; 151 else if (strcasecmp(optarg, "unix") == 0) 152 pf_list |= PF_LIST_LOCAL; 153 else 154 errx(1, "%s: unsupported protocol family", 155 optarg); 156 break; 157 case 'l': 158 only |= ONLY_LISTEN; 159 break; 160 case 'n': 161 nonames++; 162 break; 163 case 'p': 164 parse_ports(optarg); 165 break; 166 case 'u': 167 pf_list |= PF_LIST_LOCAL; 168 break; 169 default: 170 /* usage(); */ 171 exit(1); 172 } 173 } 174 argc -= optind; 175 argv += optind; 176 177 if (prog_init && prog_init() == -1) 178 err(1, "init"); 179 180 if ((portmap != NULL) && (pf_list == 0)) { 181 pf_list = PF_LIST_INET; 182 #ifdef INET6 183 pf_list |= PF_LIST_INET6; 184 #endif 185 } 186 if (pf_list == 0) { 187 pf_list = PF_LIST_INET | PF_LIST_LOCAL; 188 #ifdef INET6 189 pf_list |= PF_LIST_INET6; 190 #endif 191 } 192 if ((portmap != NULL) && (pf_list & PF_LIST_LOCAL)) 193 errx(1, "local domain sockets do not have ports"); 194 195 if (pf_list & PF_LIST_INET) { 196 get_sockets("net.inet.tcp.pcblist"); 197 get_sockets("net.inet.udp.pcblist"); 198 if (portmap == NULL) 199 get_sockets("net.inet.raw.pcblist"); 200 } 201 202 #ifdef INET6 203 if (pf_list & PF_LIST_INET6) { 204 get_sockets("net.inet6.tcp6.pcblist"); 205 get_sockets("net.inet6.udp6.pcblist"); 206 if (portmap == NULL) 207 get_sockets("net.inet6.raw6.pcblist"); 208 } 209 #endif 210 211 if (pf_list & PF_LIST_LOCAL) { 212 get_sockets("net.local.stream.pcblist"); 213 get_sockets("net.local.dgram.pcblist"); 214 } 215 216 get_files(); 217 218 p.p_pid = 0; 219 for (i = 0; i < flistc; i++) 220 if ((kp = pick_socket(&flist[i])) != NULL && 221 get_proc(&p, flist[i].ki_pid) == 0) 222 print_socket(&flist[i], kp, &p); 223 224 return (0); 225 } 226 227 void 228 parse_ports(const char *l) 229 { 230 struct servent *srv; 231 const char *s, *e; 232 long i, j; 233 234 if (portmap == NULL) { 235 portmap = bit_alloc(65536); 236 if (portmap == NULL) 237 err(1, "malloc"); 238 } 239 240 if ((srv = getservbyname(l, NULL)) != NULL) { 241 bit_set(portmap, ntohs(srv->s_port)); 242 return; 243 } 244 245 s = e = l; 246 while (*s != '\0') { 247 i = get_num(l, &s, &e); 248 switch (*e) { 249 case ',': 250 e++; 251 case '\0': 252 bit_set(portmap, i); 253 s = e; 254 continue; 255 case '-': 256 s = ++e; 257 j = get_num(l, &s, &e); 258 for (; i <= j; i++) 259 bit_set(portmap, i); 260 break; 261 default: 262 errno = EINVAL; 263 err(1, "%s", l); 264 } 265 } 266 } 267 268 int 269 get_num(const char *l, const char **s, const char **e) 270 { 271 long x; 272 char *t; 273 274 while (isdigit((u_int)**e)) 275 (*e)++; 276 if (*s != *e) { 277 errno = 0; 278 x = strtol(*s, &t, 0); 279 if (errno == 0 && x >= 0 && x <= 65535 && t == *e) 280 return (x); 281 } 282 283 errno = EINVAL; 284 err(1, "%s", l); 285 } 286 287 void 288 get_sockets(const char *mib) 289 { 290 void *v; 291 size_t sz; 292 int rc, n, name[CTL_MAXNAME]; 293 u_int namelen; 294 295 sz = CTL_MAXNAME; 296 rc = sysctlnametomib(mib, &name[0], &sz); 297 if (rc == -1) { 298 if (errno == ENOENT) 299 return; 300 err(1, "sysctlnametomib: %s", mib); 301 } 302 namelen = sz; 303 304 name[namelen++] = PCB_ALL; 305 name[namelen++] = 0; /* XXX all pids */ 306 name[namelen++] = sizeof(struct kinfo_pcb); 307 name[namelen++] = INT_MAX; /* all of them */ 308 309 sysctl_sucker(&name[0], namelen, &v, &sz); 310 n = sz / sizeof(struct kinfo_pcb); 311 socket_add_hash(v, n); 312 } 313 314 void 315 get_files(void) 316 { 317 void *v; 318 size_t sz; 319 int rc, name[CTL_MAXNAME]; 320 u_int namelen; 321 322 sz = CTL_MAXNAME; 323 rc = sysctlnametomib("kern.file2", &name[0], &sz); 324 if (rc == -1) 325 err(1, "sysctlnametomib"); 326 namelen = sz; 327 328 name[namelen++] = KERN_FILE_BYPID; 329 name[namelen++] = 0; /* XXX all pids */ 330 name[namelen++] = sizeof(struct kinfo_file); 331 name[namelen++] = INT_MAX; /* all of them */ 332 333 sysctl_sucker(&name[0], namelen, &v, &sz); 334 flist = v; 335 flistc = sz / sizeof(struct kinfo_file); 336 337 qsort(flist, flistc, sizeof(*flist), sort_files); 338 } 339 340 int 341 sort_files(const void *a, const void *b) 342 { 343 const struct kinfo_file *ka = a, *kb = b; 344 345 if (ka->ki_pid == kb->ki_pid) 346 return (ka->ki_fd - kb->ki_fd); 347 348 return (ka->ki_pid - kb->ki_pid); 349 } 350 351 void 352 sysctl_sucker(int *name, u_int namelen, void **vp, size_t *szp) 353 { 354 int rc; 355 void *v; 356 size_t sz; 357 358 /* printf("name %p, namelen %u\n", name, namelen); */ 359 360 v = NULL; 361 sz = 0; 362 do { 363 rc = prog_sysctl(&name[0], namelen, v, &sz, NULL, 0); 364 if (rc == -1 && errno != ENOMEM) 365 err(1, "sysctl"); 366 if (rc == -1 && v != NULL) { 367 free(v); 368 v = NULL; 369 } 370 if (v == NULL) { 371 v = malloc(sz); 372 rc = -1; 373 } 374 if (v == NULL) 375 err(1, "malloc"); 376 } while (rc == -1); 377 378 *vp = v; 379 *szp = sz; 380 /* printf("got %zu at %p\n", sz, v); */ 381 } 382 383 void 384 socket_add_hash(struct kinfo_pcb *kp, int n) 385 { 386 struct sockitem *si; 387 int hash, i; 388 389 if (n == 0) 390 return; 391 392 si = malloc(sizeof(*si) * n); 393 if (si== NULL) 394 err(1, "malloc"); 395 396 for (i = 0; i < n; i++) { 397 si[i].s_sock = &kp[i]; 398 hash = (int)(kp[i].ki_sockaddr % HASHSIZE); 399 LIST_INSERT_HEAD(&sockhash[hash], &si[i], s_list); 400 } 401 } 402 403 int 404 isconnected(struct kinfo_pcb *kp) 405 { 406 407 if ((kp->ki_sostate & SS_ISCONNECTED) || 408 (kp->ki_prstate >= INP_CONNECTED) || 409 (kp->ki_tstate > TCPS_LISTEN) || 410 (kp->ki_conn != 0)) 411 return (1); 412 413 return (0); 414 } 415 416 int 417 islistening(struct kinfo_pcb *kp) 418 { 419 420 if (isconnected(kp)) 421 return (0); 422 423 if (kp->ki_tstate == TCPS_LISTEN) 424 return (1); 425 426 switch (kp->ki_family) { 427 case PF_INET: 428 if (kp->ki_type == SOCK_RAW || 429 (kp->ki_type == SOCK_DGRAM && 430 ntohs(satosin(&kp->ki_src)->sin_port) != 0)) 431 return (1); 432 break; 433 #ifdef INET6 434 case PF_INET6: 435 if (kp->ki_type == SOCK_RAW || 436 (kp->ki_type == SOCK_DGRAM && 437 ntohs(satosin6(&kp->ki_src)->sin6_port) != 0)) 438 return (1); 439 break; 440 #endif 441 case PF_LOCAL: 442 if (satosun(&kp->ki_src)->sun_path[0] != '\0') 443 return (1); 444 break; 445 default: 446 break; 447 } 448 449 return (0); 450 } 451 452 struct kinfo_pcb * 453 pick_socket(struct kinfo_file *f) 454 { 455 struct sockitem *si; 456 struct kinfo_pcb *kp; 457 int hash; 458 459 if (f->ki_ftype != DTYPE_SOCKET) 460 return (NULL); 461 462 hash = (int)(f->ki_fdata % HASHSIZE); 463 LIST_FOREACH(si, &sockhash[hash], s_list) { 464 if (si->s_sock->ki_sockaddr == f->ki_fdata) 465 break; 466 } 467 if (si == NULL) 468 return (NULL); 469 470 kp = si->s_sock; 471 472 if (only) { 473 if (isconnected(kp)) { 474 /* 475 * connected but you didn't say you wanted 476 * connected sockets 477 */ 478 if (!(only & ONLY_CONNECTED)) 479 return (NULL); 480 } 481 else if (islistening(kp)) { 482 /* 483 * listening but you didn't ask for listening 484 * sockets 485 */ 486 if (!(only & ONLY_LISTEN)) 487 return (NULL); 488 } 489 else 490 /* 491 * neither connected nor listening, so you 492 * don't get it 493 */ 494 return (NULL); 495 } 496 497 if (portmap) { 498 switch (kp->ki_family) { 499 case AF_INET: 500 if (!bit_test(portmap, 501 ntohs(satosin(&kp->ki_src)->sin_port)) && 502 !bit_test(portmap, 503 ntohs(satosin(&kp->ki_dst)->sin_port))) 504 return (NULL); 505 break; 506 #ifdef INET6 507 case AF_INET6: 508 if (!bit_test(portmap, 509 ntohs(satosin6(&kp->ki_src)->sin6_port)) && 510 !bit_test(portmap, 511 ntohs(satosin6(&kp->ki_dst)->sin6_port))) 512 return (NULL); 513 break; 514 #endif 515 default: 516 return (NULL); 517 } 518 } 519 520 return (kp); 521 } 522 523 int 524 get_proc(struct kinfo_proc2 *p, int pid) 525 { 526 int name[6]; 527 u_int namelen; 528 size_t sz; 529 530 if (p->p_pid == pid) 531 return (0); 532 533 sz = sizeof(*p); 534 namelen = 0; 535 name[namelen++] = CTL_KERN; 536 name[namelen++] = KERN_PROC2; 537 name[namelen++] = KERN_PROC_PID; 538 name[namelen++] = pid; 539 name[namelen++] = sz; 540 name[namelen++] = 1; 541 542 return (prog_sysctl(&name[0], namelen, p, &sz, NULL, 0)); 543 } 544 545 int 546 print_socket(struct kinfo_file *kf, struct kinfo_pcb *kp, struct kinfo_proc2 *p) 547 { 548 static int first = 1; 549 struct passwd *pw; 550 const char *t; 551 char proto[22]; 552 553 if (first) { 554 printf("%-8s " "%-10s " "%-5s " "%-2s " "%-6s " 555 "%-21s " "%s\n", 556 "USER", "COMMAND", "PID", "FD", "PROTO", 557 "LOCAL ADDRESS", "FOREIGN ADDRESS"); 558 first = 0; 559 } 560 561 if ((pw = getpwuid(p->p_uid)) != NULL) 562 printf("%-8s ", pw->pw_name); 563 else 564 printf("%-8d ", (int)p->p_uid); 565 566 printf("%-10.10s ", p->p_comm); 567 printf("%-5d ", (int)kf->ki_pid); 568 printf("%2d ", (int)kf->ki_fd); 569 570 snprintf(proto, sizeof(proto), "%d/%d", kp->ki_family, kp->ki_protocol); 571 572 switch (kp->ki_family) { 573 case PF_INET: 574 switch (kp->ki_protocol) { 575 case IPPROTO_TCP: t = "tcp"; break; 576 case IPPROTO_UDP: t = "udp"; break; 577 case IPPROTO_RAW: t = "raw"; break; 578 default: t = proto; break; 579 } 580 break; 581 #ifdef INET6 582 case PF_INET6: 583 switch (kp->ki_protocol) { 584 case IPPROTO_TCP: t = "tcp6"; break; 585 case IPPROTO_UDP: t = "udp6"; break; 586 case IPPROTO_RAW: t = "raw6"; break; 587 default: t = proto; break; 588 } 589 break; 590 #endif 591 case PF_LOCAL: 592 switch (kp->ki_type) { 593 case SOCK_STREAM: t = "stream"; break; 594 case SOCK_DGRAM: t = "dgram"; break; 595 case SOCK_RAW: t = "raw"; break; 596 case SOCK_RDM: t = "rdm"; break; 597 case SOCK_SEQPACKET: t = "seq"; break; 598 default: t = proto; break; 599 } 600 break; 601 default: 602 snprintf(proto, sizeof(proto), "%d/%d/%d", 603 kp->ki_family, kp->ki_type, kp->ki_protocol); 604 t = proto; 605 break; 606 } 607 608 printf("%-6s ", t); 609 610 /* 611 if (kp->ki_family == PF_LOCAL) { 612 if (kp->ki_src.sa_len > 2) { 613 print_addr(0, kp->ki_type, kp->ki_pflags, &kp->ki_src); 614 if (kp->ki_dst.sa_family == PF_LOCAL) 615 printf(" "); 616 } 617 if (kp->ki_dst.sa_family == PF_LOCAL) 618 printf("-> "); 619 } 620 else */{ 621 print_addr(21, kp->ki_type, kp->ki_pflags, &kp->ki_src); 622 printf(" "); 623 } 624 625 if (isconnected(kp)) 626 print_addr(0, kp->ki_type, kp->ki_pflags, &kp->ki_dst); 627 else if (kp->ki_family == PF_INET 628 #ifdef INET6 629 || kp->ki_family == PF_INET6 630 #endif 631 ) 632 printf("%-*s", 0, "*.*"); 633 /* else if (kp->ki_src.sa_len == 2) 634 printf("%-*s", 0, "-"); */ 635 else 636 printf("-"); 637 638 printf("\n"); 639 640 return (0); 641 } 642 643 void 644 print_addr(int l, int t, int f, struct sockaddr *sa) 645 { 646 char sabuf[256], pbuf[32]; 647 int r = 0; 648 649 if (!(f & INP_ANONPORT)) 650 f = 0; 651 else 652 f = NI_NUMERICSERV; 653 if (t == SOCK_DGRAM) 654 f |= NI_DGRAM; 655 if (nonames) 656 f |= NI_NUMERICHOST|NI_NUMERICSERV; 657 658 getnameinfo(sa, sa->sa_len, sabuf, sizeof(sabuf), 659 pbuf, sizeof(pbuf), f); 660 661 switch (sa->sa_family) { 662 case PF_UNSPEC: 663 r = printf("(PF_UNSPEC)"); 664 break; 665 case PF_INET: { 666 struct sockaddr_in *si = satosin(sa); 667 if (si->sin_addr.s_addr != INADDR_ANY) 668 r = printf("%s.%s", sabuf, pbuf); 669 else if (ntohs(si->sin_port) != 0) 670 r = printf("*.%s", pbuf); 671 else 672 r = printf("*.*"); 673 break; 674 } 675 #ifdef INET6 676 case PF_INET6: { 677 struct sockaddr_in6 *si6 = satosin6(sa); 678 if (!IN6_IS_ADDR_UNSPECIFIED(&si6->sin6_addr)) 679 r = printf("%s.%s", sabuf, pbuf); 680 else if (ntohs(si6->sin6_port) != 0) 681 r = printf("*.%s", pbuf); 682 else 683 r = printf("*.*"); 684 break; 685 } 686 #endif 687 case PF_LOCAL: { 688 struct sockaddr_un *sun = satosun(sa); 689 r = printf("%s", sun->sun_path); 690 if (r == 0) 691 r = printf("-"); 692 break; 693 } 694 default: 695 break; 696 } 697 698 if (r > 0) 699 l -= r; 700 if (l > 0) 701 printf("%*s", l, ""); 702 } 703