bsd/netinet/in_pcblist.c

   1 /*
   2  * Copyright (c) 2010-2018 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * Copyright (c) 1982, 1986, 1990, 1993
  30  *      The Regents of the University of California.  All rights reserved.
  31  *
  32  * Redistribution and use in source and binary forms, with or without
  33  * modification, are permitted provided that the following conditions
  34  * are met:
  35  * 1. Redistributions of source code must retain the above copyright
  36  *    notice, this list of conditions and the following disclaimer.
  37  * 2. Redistributions in binary form must reproduce the above copyright
  38  *    notice, this list of conditions and the following disclaimer in the
  39  *    documentation and/or other materials provided with the distribution.
  40  * 3. All advertising materials mentioning features or use of this software
  41  *    must display the following acknowledgement:
  42  *      This product includes software developed by the University of
  43  *      California, Berkeley and its contributors.
  44  * 4. Neither the name of the University nor the names of its contributors
  45  *    may be used to endorse or promote products derived from this software
  46  *    without specific prior written permission.
  47  *
  48  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  49  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  50  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  51  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  52  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  53  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  54  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  55  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  56  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  57  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  58  * SUCH DAMAGE.
  59  */
  60
  61 #include <sys/types.h>
  62 #include <sys/malloc.h>
  63 #include <sys/socket.h>
  64 #include <sys/socketvar.h>
  65 #include <sys/protosw.h>
  66 #include <sys/domain.h>
  67 #include <sys/filedesc.h>
  68 #include <sys/file_internal.h>
  69 #include <sys/kernel.h>
  70 #include <sys/sysctl.h>
  71 #include <sys/dtrace.h>
  72 #include <sys/kauth.h>
  73
  74 #include <net/route.h>
  75 #include <net/if_var.h>
  76 #include <net/if_ports_used.h>
  77 #include <net/ntstat.h>
  78
  79 #include <netinet/in.h>
  80 #include <netinet/in_pcb.h>
  81 #include <netinet/in_var.h>
  82 #include <netinet/ip_var.h>
  83
  84 #include <netinet/udp.h>
  85 #include <netinet/udp_var.h>
  86
  87 #include <netinet/tcp.h>
  88 #include <netinet/tcp_fsm.h>
  89 #include <netinet/tcp_seq.h>
  90 #include <netinet/tcp_timer.h>
  91 #include <netinet/tcp_var.h>
  92 #include <netinet6/in6_var.h>
  93
  94 #include <os/log.h>
  95
  96 #ifndef ROUNDUP64
  97 #define ROUNDUP64(x) P2ROUNDUP((x), sizeof (u_int64_t))
  98 #endif
  99
 100 #ifndef ADVANCE64
 101 #define ADVANCE64(p, n) (void*)((char *)(p) + ROUNDUP64(n))
 102 #endif
 103
 104 static void inpcb_to_xinpcb_n(struct inpcb *, struct xinpcb_n *);
 105 static void tcpcb_to_xtcpcb_n(struct tcpcb *, struct xtcpcb_n *);
 106 void shutdown_sockets_on_interface(struct ifnet *ifp);
 107
 108
 109 __private_extern__ void
 110 sotoxsocket_n(struct socket *so, struct xsocket_n *xso)
 111 {
 112         xso->xso_len = sizeof(struct xsocket_n);
 113         xso->xso_kind = XSO_SOCKET;
 114
 115         if (so == NULL) {
 116                 return;
 117         }
 118
 119         xso->xso_so = (uint64_t)VM_KERNEL_ADDRPERM(so);
 120         xso->so_type = so->so_type;
 121         xso->so_options = so->so_options;
 122         xso->so_linger = so->so_linger;
 123         xso->so_state = so->so_state;
 124         xso->so_pcb = (uint64_t)VM_KERNEL_ADDRPERM(so->so_pcb);
 125         if (so->so_proto) {
 126                 xso->xso_protocol = SOCK_PROTO(so);
 127                 xso->xso_family = SOCK_DOM(so);
 128         } else {
 129                 xso->xso_protocol = xso->xso_family = 0;
 130         }
 131         xso->so_qlen = so->so_qlen;
 132         xso->so_incqlen = so->so_incqlen;
 133         xso->so_qlimit = so->so_qlimit;
 134         xso->so_timeo = so->so_timeo;
 135         xso->so_error = so->so_error;
 136         xso->so_pgid = so->so_pgid;
 137         xso->so_oobmark = so->so_oobmark;
 138         xso->so_uid = kauth_cred_getuid(so->so_cred);
 139         xso->so_last_pid = so->last_pid;
 140         xso->so_e_pid = so->e_pid;
 141 }
 142
 143 __private_extern__ void
 144 sbtoxsockbuf_n(struct sockbuf *sb, struct xsockbuf_n *xsb)
 145 {
 146         xsb->xsb_len = sizeof(struct xsockbuf_n);
 147
 148         if (sb == NULL) {
 149                 return;
 150         }
 151
 152         xsb->xsb_kind = (sb->sb_flags & SB_RECV) ? XSO_RCVBUF : XSO_SNDBUF;
 153         xsb->sb_cc = sb->sb_cc;
 154         xsb->sb_hiwat = sb->sb_hiwat;
 155         xsb->sb_mbcnt = sb->sb_mbcnt;
 156         xsb->sb_mbmax = sb->sb_mbmax;
 157         xsb->sb_lowat = sb->sb_lowat;
 158         xsb->sb_flags = sb->sb_flags;
 159         xsb->sb_timeo = (short)(sb->sb_timeo.tv_sec * hz) +
 160             sb->sb_timeo.tv_usec / tick;
 161         if (xsb->sb_timeo == 0 && sb->sb_timeo.tv_usec != 0) {
 162                 xsb->sb_timeo = 1;
 163         }
 164 }
 165
 166 __private_extern__ void
 167 sbtoxsockstat_n(struct socket *so, struct xsockstat_n *xst)
 168 {
 169         int i;
 170
 171         xst->xst_len = sizeof(struct xsockstat_n);
 172         xst->xst_kind = XSO_STATS;
 173
 174         if (so == NULL) {
 175                 return;
 176         }
 177
 178         for (i = 0; i < SO_TC_STATS_MAX; i++) {
 179                 xst->xst_tc_stats[i].rxpackets = so->so_tc_stats[i].rxpackets;
 180                 xst->xst_tc_stats[i].rxbytes = so->so_tc_stats[i].rxbytes;
 181                 xst->xst_tc_stats[i].txpackets = so->so_tc_stats[i].txpackets;
 182                 xst->xst_tc_stats[i].txbytes = so->so_tc_stats[i].txbytes;
 183         }
 184 }
 185
 186 static void
 187 inpcb_to_xinpcb_n(struct inpcb *inp, struct xinpcb_n *xinp)
 188 {
 189         xinp->xi_len = sizeof(struct xinpcb_n);
 190         xinp->xi_kind = XSO_INPCB;
 191         xinp->xi_inpp = (uint64_t)VM_KERNEL_ADDRPERM(inp);
 192         xinp->inp_fport = inp->inp_fport;
 193         xinp->inp_lport = inp->inp_lport;
 194         xinp->inp_ppcb = (uint64_t)VM_KERNEL_ADDRPERM(inp->inp_ppcb);
 195         xinp->inp_gencnt = inp->inp_gencnt;
 196         xinp->inp_flags = inp->inp_flags;
 197         xinp->inp_flow = inp->inp_flow;
 198         xinp->inp_vflag = inp->inp_vflag;
 199         xinp->inp_ip_ttl = inp->inp_ip_ttl;
 200         xinp->inp_ip_p = inp->inp_ip_p;
 201         xinp->inp_dependfaddr.inp6_foreign = inp->inp_dependfaddr.inp6_foreign;
 202         xinp->inp_dependladdr.inp6_local = inp->inp_dependladdr.inp6_local;
 203         xinp->inp_depend4.inp4_ip_tos = inp->inp_depend4.inp4_ip_tos;
 204         xinp->inp_depend6.inp6_hlim = 0;
 205         xinp->inp_depend6.inp6_cksum = inp->inp_depend6.inp6_cksum;
 206         xinp->inp_depend6.inp6_ifindex = 0;
 207         xinp->inp_depend6.inp6_hops = inp->inp_depend6.inp6_hops;
 208         xinp->inp_flowhash = inp->inp_flowhash;
 209         xinp->inp_flags2 = inp->inp_flags2;
 210 }
 211
 212 __private_extern__ void
 213 tcpcb_to_xtcpcb_n(struct tcpcb *tp, struct xtcpcb_n *xt)
 214 {
 215         xt->xt_len = sizeof(struct xtcpcb_n);
 216         xt->xt_kind = XSO_TCPCB;
 217
 218         xt->t_segq = (uint32_t)VM_KERNEL_ADDRPERM(tp->t_segq.lh_first);
 219         xt->t_dupacks = tp->t_dupacks;
 220         xt->t_timer[TCPT_REXMT_EXT] = tp->t_timer[TCPT_REXMT];
 221         xt->t_timer[TCPT_PERSIST_EXT] = tp->t_timer[TCPT_PERSIST];
 222         xt->t_timer[TCPT_KEEP_EXT] = tp->t_timer[TCPT_KEEP];
 223         xt->t_timer[TCPT_2MSL_EXT] = tp->t_timer[TCPT_2MSL];
 224         xt->t_state = tp->t_state;
 225         xt->t_flags = tp->t_flags;
 226         xt->t_force = (tp->t_flagsext & TF_FORCE) ? 1 : 0;
 227         xt->snd_una = tp->snd_una;
 228         xt->snd_max = tp->snd_max;
 229         xt->snd_nxt = tp->snd_nxt;
 230         xt->snd_up = tp->snd_up;
 231         xt->snd_wl1 = tp->snd_wl1;
 232         xt->snd_wl2 = tp->snd_wl2;
 233         xt->iss = tp->iss;
 234         xt->irs = tp->irs;
 235         xt->rcv_nxt = tp->rcv_nxt;
 236         xt->rcv_adv = tp->rcv_adv;
 237         xt->rcv_wnd = tp->rcv_wnd;
 238         xt->rcv_up = tp->rcv_up;
 239         xt->snd_wnd = tp->snd_wnd;
 240         xt->snd_cwnd = tp->snd_cwnd;
 241         xt->snd_ssthresh = tp->snd_ssthresh;
 242         xt->t_maxopd = tp->t_maxopd;
 243         xt->t_rcvtime = tp->t_rcvtime;
 244         xt->t_starttime = tp->t_starttime;
 245         xt->t_rtttime = tp->t_rtttime;
 246         xt->t_rtseq = tp->t_rtseq;
 247         xt->t_rxtcur = tp->t_rxtcur;
 248         xt->t_maxseg = tp->t_maxseg;
 249         xt->t_srtt = tp->t_srtt;
 250         xt->t_rttvar = tp->t_rttvar;
 251         xt->t_rxtshift = tp->t_rxtshift;
 252         xt->t_rttmin = tp->t_rttmin;
 253         xt->t_rttupdated = tp->t_rttupdated;
 254         xt->max_sndwnd = tp->max_sndwnd;
 255         xt->t_softerror = tp->t_softerror;
 256         xt->t_oobflags = tp->t_oobflags;
 257         xt->t_iobc = tp->t_iobc;
 258         xt->snd_scale = tp->snd_scale;
 259         xt->rcv_scale = tp->rcv_scale;
 260         xt->request_r_scale = tp->request_r_scale;
 261         xt->requested_s_scale = tp->requested_s_scale;
 262         xt->ts_recent = tp->ts_recent;
 263         xt->ts_recent_age = tp->ts_recent_age;
 264         xt->last_ack_sent = tp->last_ack_sent;
 265         xt->cc_send = 0;
 266         xt->cc_recv = 0;
 267         xt->snd_recover = tp->snd_recover;
 268         xt->snd_cwnd_prev = tp->snd_cwnd_prev;
 269         xt->snd_ssthresh_prev = tp->snd_ssthresh_prev;
 270 }
 271
 272 __private_extern__ int
 273 get_pcblist_n(short proto, struct sysctl_req *req, struct inpcbinfo *pcbinfo)
 274 {
 275         int error = 0;
 276         int i, n;
 277         struct inpcb *inp, **inp_list = NULL;
 278         inp_gen_t gencnt;
 279         struct xinpgen xig;
 280         void *buf = NULL;
 281         size_t item_size = ROUNDUP64(sizeof(struct xinpcb_n)) +
 282             ROUNDUP64(sizeof(struct xsocket_n)) +
 283             2 * ROUNDUP64(sizeof(struct xsockbuf_n)) +
 284             ROUNDUP64(sizeof(struct xsockstat_n));
 285
 286         if (proto == IPPROTO_TCP) {
 287                 item_size += ROUNDUP64(sizeof(struct xtcpcb_n));
 288         }
 289
 290         if (req->oldptr == USER_ADDR_NULL) {
 291                 n = pcbinfo->ipi_count;
 292                 req->oldidx = 2 * (sizeof(xig)) + (n + n / 8 + 1) * item_size;
 293                 return 0;
 294         }
 295
 296         if (req->newptr != USER_ADDR_NULL) {
 297                 return EPERM;
 298         }
 299
 300
 301         /*
 302          * The process of preparing the PCB list is too time-consuming and
 303          * resource-intensive to repeat twice on every request.
 304          */
 305         lck_rw_lock_exclusive(pcbinfo->ipi_lock);
 306         /*
 307          * OK, now we're committed to doing something.
 308          */
 309         gencnt = pcbinfo->ipi_gencnt;
 310         n = pcbinfo->ipi_count;
 311
 312         bzero(&xig, sizeof(xig));
 313         xig.xig_len = sizeof(xig);
 314         xig.xig_count = n;
 315         xig.xig_gen = gencnt;
 316         xig.xig_sogen = so_gencnt;
 317         error = SYSCTL_OUT(req, &xig, sizeof(xig));
 318         if (error) {
 319                 goto done;
 320         }
 321         /*
 322          * We are done if there is no pcb
 323          */
 324         if (xig.xig_count == 0) {
 325                 goto done;
 326         }
 327
 328         buf = _MALLOC(item_size, M_TEMP, M_WAITOK);
 329         if (buf == NULL) {
 330                 error = ENOMEM;
 331                 goto done;
 332         }
 333
 334         inp_list = _MALLOC(n * sizeof(*inp_list), M_TEMP, M_WAITOK);
 335         if (inp_list == NULL) {
 336                 error = ENOMEM;
 337                 goto done;
 338         }
 339
 340         /*
 341          * Special case TCP to include the connections in time wait
 342          */
 343         if (proto == IPPROTO_TCP) {
 344                 n = get_tcp_inp_list(inp_list, n, gencnt);
 345         } else {
 346                 for (inp = pcbinfo->ipi_listhead->lh_first, i = 0; inp && i < n;
 347                     inp = inp->inp_list.le_next) {
 348                         if (inp->inp_gencnt <= gencnt &&
 349                             inp->inp_state != INPCB_STATE_DEAD) {
 350                                 inp_list[i++] = inp;
 351                         }
 352                 }
 353                 n = i;
 354         }
 355
 356
 357         error = 0;
 358         for (i = 0; i < n; i++) {
 359                 inp = inp_list[i];
 360                 if (inp->inp_gencnt <= gencnt &&
 361                     inp->inp_state != INPCB_STATE_DEAD) {
 362                         struct xinpcb_n *xi = (struct xinpcb_n *)buf;
 363                         struct xsocket_n *xso = (struct xsocket_n *)
 364                             ADVANCE64(xi, sizeof(*xi));
 365                         struct xsockbuf_n *xsbrcv = (struct xsockbuf_n *)
 366                             ADVANCE64(xso, sizeof(*xso));
 367                         struct xsockbuf_n *xsbsnd = (struct xsockbuf_n *)
 368                             ADVANCE64(xsbrcv, sizeof(*xsbrcv));
 369                         struct xsockstat_n *xsostats = (struct xsockstat_n *)
 370                             ADVANCE64(xsbsnd, sizeof(*xsbsnd));
 371
 372                         bzero(buf, item_size);
 373
 374                         inpcb_to_xinpcb_n(inp, xi);
 375                         sotoxsocket_n(inp->inp_socket, xso);
 376                         sbtoxsockbuf_n(inp->inp_socket ?
 377                             &inp->inp_socket->so_rcv : NULL, xsbrcv);
 378                         sbtoxsockbuf_n(inp->inp_socket ?
 379                             &inp->inp_socket->so_snd : NULL, xsbsnd);
 380                         sbtoxsockstat_n(inp->inp_socket, xsostats);
 381                         if (proto == IPPROTO_TCP) {
 382                                 struct  xtcpcb_n *xt = (struct xtcpcb_n *)
 383                                     ADVANCE64(xsostats, sizeof(*xsostats));
 384
 385                                 /*
 386                                  * inp->inp_ppcb, can only be NULL on
 387                                  * an initialization race window.
 388                                  * No need to lock.
 389                                  */
 390                                 if (inp->inp_ppcb == NULL) {
 391                                         continue;
 392                                 }
 393
 394                                 tcpcb_to_xtcpcb_n((struct tcpcb *)
 395                                     inp->inp_ppcb, xt);
 396                         }
 397                         error = SYSCTL_OUT(req, buf, item_size);
 398                         if (error) {
 399                                 break;
 400                         }
 401                 }
 402         }
 403
 404         if (!error) {
 405                 /*
 406                  * Give the user an updated idea of our state.
 407                  * If the generation differs from what we told
 408                  * her before, she knows that something happened
 409                  * while we were processing this request, and it
 410                  * might be necessary to retry.
 411                  */
 412                 bzero(&xig, sizeof(xig));
 413                 xig.xig_len = sizeof(xig);
 414                 xig.xig_gen = pcbinfo->ipi_gencnt;
 415                 xig.xig_sogen = so_gencnt;
 416                 xig.xig_count = pcbinfo->ipi_count;
 417                 error = SYSCTL_OUT(req, &xig, sizeof(xig));
 418         }
 419 done:
 420         lck_rw_done(pcbinfo->ipi_lock);
 421
 422         if (inp_list != NULL) {
 423                 FREE(inp_list, M_TEMP);
 424         }
 425         if (buf != NULL) {
 426                 FREE(buf, M_TEMP);
 427         }
 428         return error;
 429 }
 430
 431 __private_extern__ void
 432 inpcb_get_ports_used(uint32_t ifindex, int protocol, uint32_t flags,
 433     bitstr_t *bitfield, struct inpcbinfo *pcbinfo)
 434 {
 435         struct inpcb *inp;
 436         struct socket *so;
 437         inp_gen_t gencnt;
 438         bool iswildcard, wildcardok, nowakeok;
 439         bool recvanyifonly, extbgidleok;
 440         bool activeonly;
 441
 442         wildcardok = ((flags & INPCB_GET_PORTS_USED_WILDCARDOK) != 0);
 443         nowakeok = ((flags & INPCB_GET_PORTS_USED_NOWAKEUPOK) != 0);
 444         recvanyifonly = ((flags & INPCB_GET_PORTS_USED_RECVANYIFONLY) != 0);
 445         extbgidleok = ((flags & INPCB_GET_PORTS_USED_EXTBGIDLEONLY) != 0);
 446         activeonly = ((flags & INPCB_GET_PORTS_USED_ACTIVEONLY) != 0);
 447
 448         lck_rw_lock_shared(pcbinfo->ipi_lock);
 449         gencnt = pcbinfo->ipi_gencnt;
 450
 451         for (inp = LIST_FIRST(pcbinfo->ipi_listhead); inp;
 452             inp = LIST_NEXT(inp, inp_list)) {
 453                 uint16_t port;
 454
 455                 if (inp->inp_gencnt > gencnt ||
 456                     inp->inp_state == INPCB_STATE_DEAD ||
 457                     inp->inp_wantcnt == WNT_STOPUSING) {
 458                         continue;
 459                 }
 460
 461                 if ((so = inp->inp_socket) == NULL ||
 462                     (so->so_state & SS_DEFUNCT) ||
 463                     (so->so_state & SS_ISDISCONNECTED)) {
 464                         continue;
 465                 }
 466
 467                 /*
 468                  * If protocol is specified, filter out inpcbs that
 469                  * are not relevant to the protocol family of interest.
 470                  */
 471                 if (protocol != PF_UNSPEC) {
 472                         if (protocol == PF_INET) {
 473                                 /*
 474                                  * If protocol of interest is IPv4, skip the inpcb
 475                                  * if the family is not IPv4.
 476                                  * OR
 477                                  * If the family is IPv4, skip if the IPv4 flow is
 478                                  * CLAT46 translated.
 479                                  */
 480                                 if ((inp->inp_vflag & INP_IPV4) == 0 ||
 481                                     (inp->inp_flags2 & INP2_CLAT46_FLOW) != 0) {
 482                                         continue;
 483                                 }
 484                         } else if (protocol == PF_INET6) {
 485                                 /*
 486                                  * If protocol of interest is IPv6, skip the inpcb
 487                                  * if the family is not IPv6.
 488                                  * AND
 489                                  * The flow is not a CLAT46'd flow.
 490                                  */
 491                                 if ((inp->inp_vflag & INP_IPV6) == 0 &&
 492                                     (inp->inp_flags2 & INP2_CLAT46_FLOW) == 0) {
 493                                         continue;
 494                                 }
 495                         } else {
 496                                 /* Protocol family not supported */
 497                                 continue;
 498                         }
 499                 }
 500
 501                 if (SOCK_PROTO(inp->inp_socket) != IPPROTO_UDP &&
 502                     SOCK_PROTO(inp->inp_socket) != IPPROTO_TCP) {
 503                         continue;
 504                 }
 505
 506                 iswildcard = (((inp->inp_vflag & INP_IPV4) &&
 507                     inp->inp_laddr.s_addr == INADDR_ANY) ||
 508                     ((inp->inp_vflag & INP_IPV6) &&
 509                     IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)));
 510
 511                 if (!wildcardok && iswildcard) {
 512                         continue;
 513                 }
 514
 515                 if ((so->so_options & SO_NOWAKEFROMSLEEP) &&
 516                     !nowakeok) {
 517                         continue;
 518                 }
 519
 520                 if (!(inp->inp_flags & INP_RECV_ANYIF) &&
 521                     recvanyifonly) {
 522                         continue;
 523                 }
 524
 525                 if (!(so->so_flags1 & SOF1_EXTEND_BK_IDLE_WANTED) &&
 526                     extbgidleok) {
 527                         continue;
 528                 }
 529
 530                 if (!iswildcard &&
 531                     !(ifindex == 0 || inp->inp_last_outifp == NULL ||
 532                     ifindex == inp->inp_last_outifp->if_index)) {
 533                         continue;
 534                 }
 535
 536                 if (SOCK_PROTO(inp->inp_socket) == IPPROTO_UDP &&
 537                     so->so_state & SS_CANTRCVMORE) {
 538                         continue;
 539                 }
 540
 541                 if (SOCK_PROTO(inp->inp_socket) == IPPROTO_TCP) {
 542                         struct  tcpcb *tp = sototcpcb(inp->inp_socket);
 543
 544                         /*
 545                          * Workaround race where inp_ppcb is NULL during
 546                          * socket initialization
 547                          */
 548                         if (tp == NULL) {
 549                                 continue;
 550                         }
 551
 552                         switch (tp->t_state) {
 553                         case TCPS_CLOSED:
 554                                 continue;
 555                         /* NOT REACHED */
 556                         case TCPS_LISTEN:
 557                         case TCPS_SYN_SENT:
 558                         case TCPS_SYN_RECEIVED:
 559                         case TCPS_ESTABLISHED:
 560                         case TCPS_FIN_WAIT_1:
 561                                 /*
 562                                  * Note: FIN_WAIT_1 is an active state
 563                                  * because we need our FIN to be
 564                                  * acknowledged
 565                                  */
 566                                 break;
 567                         case TCPS_CLOSE_WAIT:
 568                         case TCPS_CLOSING:
 569                         case TCPS_LAST_ACK:
 570                         case TCPS_FIN_WAIT_2:
 571                                 /*
 572                                  * In the closing states, the connection
 573                                  * is not idle when there is outgoing
 574                                  * data having to be acknowledged
 575                                  */
 576                                 if (activeonly && so->so_snd.sb_cc == 0) {
 577                                         continue;
 578                                 }
 579                                 break;
 580                         case TCPS_TIME_WAIT:
 581                                 continue;
 582                                 /* NOT REACHED */
 583                         }
 584                 }
 585                 /*
 586                  * Final safeguard to exclude unspecified local port
 587                  */
 588                 port = ntohs(inp->inp_lport);
 589                 if (port == 0) {
 590                         continue;
 591                 }
 592                 bitstr_set(bitfield, port);
 593
 594                 if_ports_used_add_inpcb(ifindex, inp);
 595         }
 596         lck_rw_done(pcbinfo->ipi_lock);
 597 }
 598
 599 __private_extern__ uint32_t
 600 inpcb_count_opportunistic(unsigned int ifindex, struct inpcbinfo *pcbinfo,
 601     u_int32_t flags)
 602 {
 603         uint32_t opportunistic = 0;
 604         struct inpcb *inp;
 605         inp_gen_t gencnt;
 606
 607         lck_rw_lock_shared(pcbinfo->ipi_lock);
 608         gencnt = pcbinfo->ipi_gencnt;
 609         for (inp = LIST_FIRST(pcbinfo->ipi_listhead);
 610             inp != NULL; inp = LIST_NEXT(inp, inp_list)) {
 611                 if (inp->inp_gencnt <= gencnt &&
 612                     inp->inp_state != INPCB_STATE_DEAD &&
 613                     inp->inp_socket != NULL &&
 614                     so_get_opportunistic(inp->inp_socket) &&
 615                     inp->inp_last_outifp != NULL &&
 616                     ifindex == inp->inp_last_outifp->if_index) {
 617                         opportunistic++;
 618                         struct socket *so = inp->inp_socket;
 619                         if ((flags & INPCB_OPPORTUNISTIC_SETCMD) &&
 620                             (so->so_state & SS_ISCONNECTED)) {
 621                                 socket_lock(so, 1);
 622                                 if (flags & INPCB_OPPORTUNISTIC_THROTTLEON) {
 623                                         so->so_flags |= SOF_SUSPENDED;
 624                                         soevent(so,
 625                                             (SO_FILT_HINT_LOCKED |
 626                                             SO_FILT_HINT_SUSPEND));
 627                                 } else {
 628                                         so->so_flags &= ~(SOF_SUSPENDED);
 629                                         soevent(so,
 630                                             (SO_FILT_HINT_LOCKED |
 631                                             SO_FILT_HINT_RESUME));
 632                                 }
 633                                 SOTHROTTLELOG("throttle[%d]: so 0x%llx "
 634                                     "[%d,%d] %s\n", so->last_pid,
 635                                     (uint64_t)VM_KERNEL_ADDRPERM(so),
 636                                     SOCK_DOM(so), SOCK_TYPE(so),
 637                                     (so->so_flags & SOF_SUSPENDED) ?
 638                                     "SUSPENDED" : "RESUMED");
 639                                 socket_unlock(so, 1);
 640                         }
 641                 }
 642         }
 643
 644         lck_rw_done(pcbinfo->ipi_lock);
 645
 646         return opportunistic;
 647 }
 648
 649 __private_extern__ uint32_t
 650 inpcb_find_anypcb_byaddr(struct ifaddr *ifa, struct inpcbinfo *pcbinfo)
 651 {
 652         struct inpcb *inp;
 653         inp_gen_t gencnt = pcbinfo->ipi_gencnt;
 654         struct socket *so = NULL;
 655         int af;
 656
 657         if ((ifa->ifa_addr->sa_family != AF_INET) &&
 658             (ifa->ifa_addr->sa_family != AF_INET6)) {
 659                 return 0;
 660         }
 661
 662         lck_rw_lock_shared(pcbinfo->ipi_lock);
 663         for (inp = LIST_FIRST(pcbinfo->ipi_listhead);
 664             inp != NULL; inp = LIST_NEXT(inp, inp_list)) {
 665                 if (inp->inp_gencnt <= gencnt &&
 666                     inp->inp_state != INPCB_STATE_DEAD &&
 667                     inp->inp_socket != NULL) {
 668                         so = inp->inp_socket;
 669                         af = SOCK_DOM(so);
 670                         if (af != ifa->ifa_addr->sa_family) {
 671                                 continue;
 672                         }
 673                         if (inp->inp_last_outifp != ifa->ifa_ifp) {
 674                                 continue;
 675                         }
 676
 677                         if (af == AF_INET) {
 678                                 if (inp->inp_laddr.s_addr ==
 679                                     (satosin(ifa->ifa_addr))->sin_addr.s_addr) {
 680                                         lck_rw_done(pcbinfo->ipi_lock);
 681                                         return 1;
 682                                 }
 683                         }
 684                         if (af == AF_INET6) {
 685                                 if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa),
 686                                     &inp->in6p_laddr)) {
 687                                         lck_rw_done(pcbinfo->ipi_lock);
 688                                         return 1;
 689                                 }
 690                         }
 691                 }
 692         }
 693         lck_rw_done(pcbinfo->ipi_lock);
 694         return 0;
 695 }
 696
 697 static int
 698 shutdown_sockets_on_interface_proc_callout(proc_t p, void *arg)
 699 {
 700         struct filedesc *fdp;
 701         int i;
 702         struct ifnet *ifp = (struct ifnet *)arg;
 703
 704         if (ifp == NULL) {
 705                 return PROC_RETURNED;
 706         }
 707
 708         proc_fdlock(p);
 709         fdp = p->p_fd;
 710         for (i = 0; i < fdp->fd_nfiles; i++) {
 711                 struct fileproc *fp = fdp->fd_ofiles[i];
 712                 struct fileglob *fg;
 713                 struct socket *so;
 714                 struct inpcb *inp;
 715                 struct ifnet *inp_ifp;
 716                 int error;
 717
 718                 if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {
 719                         continue;
 720                 }
 721
 722                 fg = fp->f_fglob;
 723                 if (FILEGLOB_DTYPE(fg) != DTYPE_SOCKET) {
 724                         continue;
 725                 }
 726
 727                 so = (struct socket *)fp->f_fglob->fg_data;
 728                 if (SOCK_DOM(so) != PF_INET && SOCK_DOM(so) != PF_INET6) {
 729                         continue;
 730                 }
 731
 732                 inp = (struct inpcb *)so->so_pcb;
 733
 734                 if (in_pcb_checkstate(inp, WNT_ACQUIRE, 0) == WNT_STOPUSING) {
 735                         continue;
 736                 }
 737
 738                 socket_lock(so, 1);
 739
 740                 if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
 741                         socket_unlock(so, 1);
 742                         continue;
 743                 }
 744
 745                 if (inp->inp_boundifp != NULL) {
 746                         inp_ifp = inp->inp_boundifp;
 747                 } else if (inp->inp_last_outifp != NULL) {
 748                         inp_ifp = inp->inp_last_outifp;
 749                 } else {
 750                         socket_unlock(so, 1);
 751                         continue;
 752                 }
 753
 754                 if (inp_ifp != ifp && inp_ifp->if_delegated.ifp != ifp) {
 755                         socket_unlock(so, 1);
 756                         continue;
 757                 }
 758                 error = sosetdefunct(p, so, 0, TRUE);
 759                 if (error != 0) {
 760                         log(LOG_ERR, "%s: sosetdefunct() error %d",
 761                             __func__, error);
 762                 } else {
 763                         error = sodefunct(p, so, 0);
 764                         if (error != 0) {
 765                                 log(LOG_ERR, "%s: sodefunct() error %d",
 766                                     __func__, error);
 767                         }
 768                 }
 769
 770                 socket_unlock(so, 1);
 771         }
 772         proc_fdunlock(p);
 773
 774         return PROC_RETURNED;
 775 }
 776
 777 void
 778 shutdown_sockets_on_interface(struct ifnet *ifp)
 779 {
 780         proc_iterate(PROC_ALLPROCLIST,
 781             shutdown_sockets_on_interface_proc_callout,
 782             ifp, NULL, NULL);
 783 }