![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netinet|
Return to tcp_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / netinet |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * ! 26: * Redistribution and use in source and binary forms, with or without ! 27: * modification, are permitted provided that the following conditions ! 28: * are met: ! 29: * 1. Redistributions of source code must retain the above copyright ! 30: * notice, this list of conditions and the following disclaimer. ! 31: * 2. Redistributions in binary form must reproduce the above copyright ! 32: * notice, this list of conditions and the following disclaimer in the ! 33: * documentation and/or other materials provided with the distribution. ! 34: * 3. All advertising materials mentioning features or use of this software ! 35: * must display the following acknowledgement: ! 36: * This product includes software developed by the University of ! 37: * California, Berkeley and its contributors. ! 38: * 4. Neither the name of the University nor the names of its contributors ! 39: * may be used to endorse or promote products derived from this software ! 40: * without specific prior written permission. ! 41: * ! 42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 52: * SUCH DAMAGE. ! 53: * ! 54: * @(#)tcp_subr.c 8.2 (Berkeley) 5/24/95 ! 55: */ ! 56: ! 57: #if ISFB31 ! 58: #include "opt_compat.h" ! 59: #include "opt_tcpdebug.h" ! 60: #endif ! 61: ! 62: #include <sys/param.h> ! 63: #include <sys/systm.h> ! 64: #include <sys/kernel.h> ! 65: #include <sys/sysctl.h> ! 66: #include <sys/malloc.h> ! 67: #include <sys/mbuf.h> ! 68: #include <sys/socket.h> ! 69: #include <sys/socketvar.h> ! 70: #include <sys/protosw.h> ! 71: ! 72: #if ISFB31 ! 73: #include <vm/vm_zone.h> ! 74: #endif ! 75: ! 76: #include <net/route.h> ! 77: #include <net/if.h> ! 78: ! 79: #define _IP_VHL ! 80: #include <netinet/in.h> ! 81: #include <netinet/in_systm.h> ! 82: #include <netinet/ip.h> ! 83: #include <netinet/in_pcb.h> ! 84: #include <netinet/in_var.h> ! 85: #include <netinet/ip_var.h> ! 86: #include <netinet/tcp.h> ! 87: #include <netinet/tcp_fsm.h> ! 88: #include <netinet/tcp_seq.h> ! 89: #include <netinet/tcp_timer.h> ! 90: #include <netinet/tcp_var.h> ! 91: #include <netinet/tcpip.h> ! 92: #if TCPDEBUG ! 93: #include <netinet/tcp_debug.h> ! 94: #endif ! 95: ! 96: int tcp_mssdflt = TCP_MSS; ! 97: SYSCTL_INT(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt, ! 98: CTLFLAG_RW, &tcp_mssdflt , 0, ""); ! 99: ! 100: static int tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ; ! 101: SYSCTL_INT(_net_inet_tcp, TCPCTL_RTTDFLT, rttdflt, ! 102: CTLFLAG_RW, &tcp_rttdflt , 0, ""); ! 103: ! 104: static int tcp_do_rfc1323 = 1; ! 105: SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, ! 106: CTLFLAG_RW, &tcp_do_rfc1323 , 0, ""); ! 107: ! 108: static int tcp_do_rfc1644 = 0; ! 109: SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1644, rfc1644, ! 110: CTLFLAG_RW, &tcp_do_rfc1644 , 0, ""); ! 111: ! 112: SYSCTL_INT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_RD, &tcbinfo.ipi_count, ! 113: 0, "Number of active PCBs"); ! 114: ! 115: static void tcp_cleartaocache __P((void)); ! 116: static void tcp_notify __P((struct inpcb *, int)); ! 117: ! 118: /* ! 119: * Target size of TCP PCB hash tables. Must be a power of two. ! 120: * ! 121: * Note that this can be overridden by the kernel environment ! 122: * variable net.inet.tcp.tcbhashsize ! 123: */ ! 124: #ifndef TCBHASHSIZE ! 125: #define TCBHASHSIZE 4096 ! 126: #endif ! 127: ! 128: /* ! 129: * This is the actual shape of what we allocate using the zone ! 130: * allocator. Doing it this way allows us to protect both structures ! 131: * using the same generation count, and also eliminates the overhead ! 132: * of allocating tcpcbs separately. By hiding the structure here, ! 133: * we avoid changing most of the rest of the code (although it needs ! 134: * to be changed, eventually, for greater efficiency). ! 135: */ ! 136: #define ALIGNMENT 32 ! 137: #define ALIGNM1 (ALIGNMENT - 1) ! 138: struct inp_tp { ! 139: union { ! 140: struct inpcb inp; ! 141: char align[(sizeof(struct inpcb) + ALIGNM1) & ~ALIGNM1]; ! 142: } inp_tp_u; ! 143: struct tcpcb tcb; ! 144: }; ! 145: #undef ALIGNMENT ! 146: #undef ALIGNM1 ! 147: ! 148: static struct tcpcb dummy_tcb; ! 149: ! 150: /* ! 151: * Tcp initialization ! 152: */ ! 153: void ! 154: tcp_init() ! 155: { ! 156: int hashsize; ! 157: vm_size_t str_size; ! 158: ! 159: ! 160: tcp_iss = random(); /* wrong, but better than a constant */ ! 161: tcp_ccgen = 1; ! 162: tcp_cleartaocache(); ! 163: LIST_INIT(&tcb); ! 164: tcbinfo.listhead = &tcb; ! 165: if (!(getenv_int("net.inet.tcp.tcbhashsize", &hashsize))) ! 166: hashsize = TCBHASHSIZE; ! 167: if (!powerof2(hashsize)) { ! 168: printf("WARNING: TCB hash size not a power of 2\n"); ! 169: hashsize = 512; /* safe default */ ! 170: } ! 171: tcbinfo.hashbase = hashinit(hashsize, M_PCB, &tcbinfo.hashmask); ! 172: tcbinfo.porthashbase = hashinit(hashsize, M_PCB, ! 173: &tcbinfo.porthashmask); ! 174: #if ISFB31 ! 175: tcbinfo.ipi_zone = (void *) zinit("tcpcb", sizeof(struct inp_tp), maxsockets, ! 176: ZONE_INTERRUPT, 0); ! 177: #else ! 178: str_size = (vm_size_t) sizeof(struct inp_tp); ! 179: tcbinfo.ipi_zone = (void *) zinit(str_size, 120000*str_size, 8192, "inpcb_zone"); ! 180: #endif ! 181: ! 182: ! 183: if (max_protohdr < sizeof(struct tcpiphdr)) ! 184: max_protohdr = sizeof(struct tcpiphdr); ! 185: if (max_linkhdr + sizeof(struct tcpiphdr) > MHLEN) ! 186: panic("tcp_init"); ! 187: ! 188: tcbinfo.last_pcb = 0; ! 189: dummy_tcb.t_state = TCP_NSTATES; ! 190: dummy_tcb.t_flags = 0; ! 191: tcbinfo.dummy_cb = (caddr_t) &dummy_tcb; ! 192: in_pcb_nat_init(&tcbinfo, AF_INET, IPPROTO_TCP, SOCK_STREAM); ! 193: } ! 194: ! 195: /* ! 196: * Create template to be used to send tcp packets on a connection. ! 197: * Call after host entry created, allocates an mbuf and fills ! 198: * in a skeletal tcp/ip header, minimizing the amount of work ! 199: * necessary when the connection is used. ! 200: */ ! 201: struct tcpiphdr * ! 202: tcp_template(tp) ! 203: struct tcpcb *tp; ! 204: { ! 205: register struct inpcb *inp = tp->t_inpcb; ! 206: register struct mbuf *m; ! 207: register struct tcpiphdr *n; ! 208: ! 209: if ((n = tp->t_template) == 0) { ! 210: m = m_get(M_DONTWAIT, MT_HEADER); ! 211: if (m == NULL) ! 212: return (0); ! 213: m->m_len = sizeof (struct tcpiphdr); ! 214: n = mtod(m, struct tcpiphdr *); ! 215: } ! 216: bzero(n->ti_x1, sizeof(n->ti_x1)); ! 217: n->ti_pr = IPPROTO_TCP; ! 218: n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip)); ! 219: n->ti_src = inp->inp_laddr; ! 220: n->ti_dst = inp->inp_faddr; ! 221: n->ti_sport = inp->inp_lport; ! 222: n->ti_dport = inp->inp_fport; ! 223: n->ti_seq = 0; ! 224: n->ti_ack = 0; ! 225: n->ti_x2 = 0; ! 226: n->ti_off = 5; ! 227: n->ti_flags = 0; ! 228: n->ti_win = 0; ! 229: n->ti_sum = 0; ! 230: n->ti_urp = 0; ! 231: return (n); ! 232: } ! 233: ! 234: /* ! 235: * Send a single message to the TCP at address specified by ! 236: * the given TCP/IP header. If m == 0, then we make a copy ! 237: * of the tcpiphdr at ti and send directly to the addressed host. ! 238: * This is used to force keep alive messages out using the TCP ! 239: * template for a connection tp->t_template. If flags are given ! 240: * then we send a message back to the TCP which originated the ! 241: * segment ti, and discard the mbuf containing it and any other ! 242: * attached mbufs. ! 243: * ! 244: * In any case the ack and sequence number of the transmitted ! 245: * segment are as specified by the parameters. ! 246: * ! 247: * NOTE: If m != NULL, then ti must point to *inside* the mbuf. ! 248: */ ! 249: void ! 250: tcp_respond(tp, ti, m, ack, seq, flags) ! 251: struct tcpcb *tp; ! 252: register struct tcpiphdr *ti; ! 253: register struct mbuf *m; ! 254: tcp_seq ack, seq; ! 255: int flags; ! 256: { ! 257: register int tlen; ! 258: int win = 0; ! 259: struct route *ro = 0; ! 260: struct route sro; ! 261: ! 262: if (tp) { ! 263: if (!(flags & TH_RST)) ! 264: win = sbspace(&tp->t_inpcb->inp_socket->so_rcv); ! 265: ro = &tp->t_inpcb->inp_route; ! 266: } else { ! 267: ro = &sro; ! 268: bzero(ro, sizeof *ro); ! 269: } ! 270: if (m == 0) { ! 271: m = m_gethdr(M_DONTWAIT, MT_HEADER); ! 272: if (m == NULL) ! 273: return; ! 274: #if TCP_COMPAT_42 ! 275: tlen = 1; ! 276: #else ! 277: tlen = 0; ! 278: #endif ! 279: m->m_data += max_linkhdr; ! 280: *mtod(m, struct tcpiphdr *) = *ti; ! 281: ti = mtod(m, struct tcpiphdr *); ! 282: flags = TH_ACK; ! 283: } else { ! 284: m_freem(m->m_next); ! 285: m->m_next = 0; ! 286: m->m_data = (caddr_t)ti; ! 287: m->m_len = sizeof (struct tcpiphdr); ! 288: tlen = 0; ! 289: #define xchg(a,b,type) { type t; t=a; a=b; b=t; } ! 290: xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, n_long); ! 291: xchg(ti->ti_dport, ti->ti_sport, n_short); ! 292: #undef xchg ! 293: } ! 294: ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen)); ! 295: tlen += sizeof (struct tcpiphdr); ! 296: m->m_len = tlen; ! 297: m->m_pkthdr.len = tlen; ! 298: m->m_pkthdr.rcvif = (struct ifnet *) 0; ! 299: bzero(ti->ti_x1, sizeof(ti->ti_x1)); ! 300: ti->ti_seq = htonl(seq); ! 301: ti->ti_ack = htonl(ack); ! 302: ti->ti_x2 = 0; ! 303: ti->ti_off = sizeof (struct tcphdr) >> 2; ! 304: ti->ti_flags = flags; ! 305: if (tp) ! 306: ti->ti_win = htons((u_short) (win >> tp->rcv_scale)); ! 307: else ! 308: ti->ti_win = htons((u_short)win); ! 309: ti->ti_urp = 0; ! 310: ti->ti_sum = 0; ! 311: ti->ti_sum = in_cksum(m, tlen); ! 312: ((struct ip *)ti)->ip_len = tlen; ! 313: ((struct ip *)ti)->ip_ttl = ip_defttl; ! 314: #if TCPDEBUG ! 315: if (tp == NULL || (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)) ! 316: tcp_trace(TA_OUTPUT, 0, tp, ti, 0); ! 317: #endif ! 318: (void) ip_output(m, NULL, ro, 0, NULL); ! 319: if (ro == &sro && ro->ro_rt) { ! 320: RTFREE(ro->ro_rt); ! 321: } ! 322: } ! 323: ! 324: /* ! 325: * Create a new TCP control block, making an ! 326: * empty reassembly queue and hooking it to the argument ! 327: * protocol control block. The `inp' parameter must have ! 328: * come from the zone allocator set up in tcp_init(). ! 329: */ ! 330: struct tcpcb * ! 331: tcp_newtcpcb(inp) ! 332: struct inpcb *inp; ! 333: { ! 334: struct inp_tp *it; ! 335: register struct tcpcb *tp; ! 336: ! 337: it = (struct inp_tp *)inp; ! 338: tp = &it->tcb; ! 339: bzero((char *) tp, sizeof(struct tcpcb)); ! 340: tp->t_segq = NULL; ! 341: tp->t_maxseg = tp->t_maxopd = tcp_mssdflt; ! 342: ! 343: if (tcp_do_rfc1323) ! 344: tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP); ! 345: if (tcp_do_rfc1644) ! 346: tp->t_flags |= TF_REQ_CC; ! 347: tp->t_inpcb = inp; /* XXX */ ! 348: /* ! 349: * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no ! 350: * rtt estimate. Set rttvar so that srtt + 4 * rttvar gives ! 351: * reasonable initial retransmit time. ! 352: */ ! 353: tp->t_srtt = TCPTV_SRTTBASE; ! 354: tp->t_rttvar = ((TCPTV_RTOBASE - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4; ! 355: tp->t_rttmin = TCPTV_MIN; ! 356: tp->t_rxtcur = TCPTV_RTOBASE; ! 357: tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT; ! 358: tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT; ! 359: inp->inp_ip_ttl = ip_defttl; ! 360: inp->inp_ppcb = (caddr_t)tp; ! 361: return (tp); /* XXX */ ! 362: } ! 363: ! 364: /* ! 365: * Drop a TCP connection, reporting ! 366: * the specified error. If connection is synchronized, ! 367: * then send a RST to peer. ! 368: */ ! 369: struct tcpcb * ! 370: tcp_drop(tp, errno) ! 371: register struct tcpcb *tp; ! 372: int errno; ! 373: { ! 374: struct socket *so = tp->t_inpcb->inp_socket; ! 375: ! 376: if (TCPS_HAVERCVDSYN(tp->t_state)) { ! 377: tp->t_state = TCPS_CLOSED; ! 378: (void) tcp_output(tp); ! 379: tcpstat.tcps_drops++; ! 380: } else ! 381: tcpstat.tcps_conndrops++; ! 382: if (errno == ETIMEDOUT && tp->t_softerror) ! 383: errno = tp->t_softerror; ! 384: so->so_error = errno; ! 385: return (tcp_close(tp)); ! 386: } ! 387: ! 388: /* ! 389: * Close a TCP control block: ! 390: * discard all space held by the tcp ! 391: * discard internet protocol block ! 392: * wake up any sleepers ! 393: */ ! 394: struct tcpcb * ! 395: tcp_close(tp) ! 396: register struct tcpcb *tp; ! 397: { ! 398: register struct mbuf *q; ! 399: register struct mbuf *nq; ! 400: struct inpcb *inp = tp->t_inpcb; ! 401: struct socket *so = inp->inp_socket; ! 402: register struct rtentry *rt; ! 403: int dosavessthresh; ! 404: ! 405: /* ! 406: * If we got enough samples through the srtt filter, ! 407: * save the rtt and rttvar in the routing entry. ! 408: * 'Enough' is arbitrarily defined as the 16 samples. ! 409: * 16 samples is enough for the srtt filter to converge ! 410: * to within 5% of the correct value; fewer samples and ! 411: * we could save a very bogus rtt. ! 412: * ! 413: * Don't update the default route's characteristics and don't ! 414: * update anything that the user "locked". ! 415: */ ! 416: if (tp->t_rttupdated >= 16 && ! 417: (rt = inp->inp_route.ro_rt) && ! 418: ((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr != INADDR_ANY) { ! 419: register u_long i = 0; ! 420: ! 421: if ((rt->rt_rmx.rmx_locks & RTV_RTT) == 0) { ! 422: i = tp->t_srtt * ! 423: (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE)); ! 424: if (rt->rt_rmx.rmx_rtt && i) ! 425: /* ! 426: * filter this update to half the old & half ! 427: * the new values, converting scale. ! 428: * See route.h and tcp_var.h for a ! 429: * description of the scaling constants. ! 430: */ ! 431: rt->rt_rmx.rmx_rtt = ! 432: (rt->rt_rmx.rmx_rtt + i) / 2; ! 433: else ! 434: rt->rt_rmx.rmx_rtt = i; ! 435: tcpstat.tcps_cachedrtt++; ! 436: } ! 437: if ((rt->rt_rmx.rmx_locks & RTV_RTTVAR) == 0) { ! 438: i = tp->t_rttvar * ! 439: (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE)); ! 440: if (rt->rt_rmx.rmx_rttvar && i) ! 441: rt->rt_rmx.rmx_rttvar = ! 442: (rt->rt_rmx.rmx_rttvar + i) / 2; ! 443: else ! 444: rt->rt_rmx.rmx_rttvar = i; ! 445: tcpstat.tcps_cachedrttvar++; ! 446: } ! 447: /* ! 448: * The old comment here said: ! 449: * update the pipelimit (ssthresh) if it has been updated ! 450: * already or if a pipesize was specified & the threshhold ! 451: * got below half the pipesize. I.e., wait for bad news ! 452: * before we start updating, then update on both good ! 453: * and bad news. ! 454: * ! 455: * But we want to save the ssthresh even if no pipesize is ! 456: * specified explicitly in the route, because such ! 457: * connections still have an implicit pipesize specified ! 458: * by the global tcp_sendspace. In the absence of a reliable ! 459: * way to calculate the pipesize, it will have to do. ! 460: */ ! 461: i = tp->snd_ssthresh; ! 462: if (rt->rt_rmx.rmx_sendpipe != 0) ! 463: dosavessthresh = (i < rt->rt_rmx.rmx_sendpipe / 2); ! 464: else ! 465: dosavessthresh = (i < so->so_snd.sb_hiwat / 2); ! 466: if (((rt->rt_rmx.rmx_locks & RTV_SSTHRESH) == 0 && ! 467: i != 0 && rt->rt_rmx.rmx_ssthresh != 0) ! 468: || dosavessthresh) { ! 469: /* ! 470: * convert the limit from user data bytes to ! 471: * packets then to packet data bytes. ! 472: */ ! 473: i = (i + tp->t_maxseg / 2) / tp->t_maxseg; ! 474: if (i < 2) ! 475: i = 2; ! 476: i *= (u_long)(tp->t_maxseg + sizeof (struct tcpiphdr)); ! 477: if (rt->rt_rmx.rmx_ssthresh) ! 478: rt->rt_rmx.rmx_ssthresh = ! 479: (rt->rt_rmx.rmx_ssthresh + i) / 2; ! 480: else ! 481: rt->rt_rmx.rmx_ssthresh = i; ! 482: tcpstat.tcps_cachedssthresh++; ! 483: } ! 484: } ! 485: /* free the reassembly queue, if any */ ! 486: for (q = tp->t_segq; q; q = nq) { ! 487: nq = q->m_nextpkt; ! 488: tp->t_segq = nq; ! 489: m_freem(q); ! 490: } ! 491: if (tp->t_template) ! 492: (void) m_free(dtom(tp->t_template)); ! 493: inp->inp_ppcb = NULL; ! 494: soisdisconnected(so); ! 495: in_pcbdetach(inp); ! 496: tcpstat.tcps_closed++; ! 497: return ((struct tcpcb *)0); ! 498: } ! 499: ! 500: void ! 501: tcp_drain() ! 502: { ! 503: ! 504: } ! 505: ! 506: /* ! 507: * Notify a tcp user of an asynchronous error; ! 508: * store error as soft error, but wake up user ! 509: * (for now, won't do anything until can select for soft error). ! 510: */ ! 511: static void ! 512: tcp_notify(inp, error) ! 513: struct inpcb *inp; ! 514: int error; ! 515: { ! 516: register struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb; ! 517: register struct socket *so = inp->inp_socket; ! 518: ! 519: /* ! 520: * Ignore some errors if we are hooked up. ! 521: * If connection hasn't completed, has retransmitted several times, ! 522: * and receives a second error, give up now. This is better ! 523: * than waiting a long time to establish a connection that ! 524: * can never complete. ! 525: */ ! 526: if (tp->t_state == TCPS_ESTABLISHED && ! 527: (error == EHOSTUNREACH || error == ENETUNREACH || ! 528: error == EHOSTDOWN)) { ! 529: return; ! 530: } else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 && ! 531: tp->t_softerror) ! 532: so->so_error = error; ! 533: else ! 534: tp->t_softerror = error; ! 535: wakeup((caddr_t) &so->so_timeo); ! 536: sorwakeup(so); ! 537: sowwakeup(so); ! 538: } ! 539: ! 540: ! 541: static int ! 542: tcp_pcblist SYSCTL_HANDLER_ARGS ! 543: { ! 544: int error, i, n, s; ! 545: struct inpcb *inp, **inp_list; ! 546: inp_gen_t gencnt; ! 547: struct xinpgen xig; ! 548: ! 549: /* ! 550: * The process of preparing the TCB list is too time-consuming and ! 551: * resource-intensive to repeat twice on every request. ! 552: */ ! 553: if (req->oldptr == 0) { ! 554: n = tcbinfo.ipi_count; ! 555: req->oldidx = 2 * (sizeof xig) ! 556: + (n + n/8) * sizeof(struct xtcpcb); ! 557: return 0; ! 558: } ! 559: ! 560: if (req->newptr != 0) ! 561: return EPERM; ! 562: ! 563: /* ! 564: * OK, now we're committed to doing something. ! 565: */ ! 566: s = splnet(); ! 567: gencnt = tcbinfo.ipi_gencnt; ! 568: n = tcbinfo.ipi_count; ! 569: splx(s); ! 570: ! 571: xig.xig_len = sizeof xig; ! 572: xig.xig_count = n; ! 573: xig.xig_gen = gencnt; ! 574: xig.xig_sogen = so_gencnt; ! 575: error = SYSCTL_OUT(req, &xig, sizeof xig); ! 576: if (error) ! 577: return error; ! 578: ! 579: inp_list = _MALLOC(n * sizeof *inp_list, M_TEMP, M_WAITOK); ! 580: if (inp_list == 0) ! 581: return ENOMEM; ! 582: ! 583: s = splnet(); ! 584: for (inp = tcbinfo.listhead->lh_first, i = 0; inp && i < n; ! 585: inp = inp->inp_list.le_next) { ! 586: if (inp->inp_gencnt <= gencnt) ! 587: inp_list[i++] = inp; ! 588: } ! 589: splx(s); ! 590: n = i; ! 591: ! 592: error = 0; ! 593: for (i = 0; i < n; i++) { ! 594: inp = inp_list[i]; ! 595: if (inp->inp_gencnt <= gencnt) { ! 596: struct xtcpcb xt; ! 597: xt.xt_len = sizeof xt; ! 598: /* XXX should avoid extra copy */ ! 599: bcopy(inp, &xt.xt_inp, sizeof *inp); ! 600: bcopy(inp->inp_ppcb, &xt.xt_tp, sizeof xt.xt_tp); ! 601: if (inp->inp_socket) ! 602: sotoxsocket(inp->inp_socket, &xt.xt_socket); ! 603: error = SYSCTL_OUT(req, &xt, sizeof xt); ! 604: } ! 605: } ! 606: if (!error) { ! 607: /* ! 608: * Give the user an updated idea of our state. ! 609: * If the generation differs from what we told ! 610: * her before, she knows that something happened ! 611: * while we were processing this request, and it ! 612: * might be necessary to retry. ! 613: */ ! 614: s = splnet(); ! 615: xig.xig_gen = tcbinfo.ipi_gencnt; ! 616: xig.xig_sogen = so_gencnt; ! 617: xig.xig_count = tcbinfo.ipi_count; ! 618: splx(s); ! 619: error = SYSCTL_OUT(req, &xig, sizeof xig); ! 620: } ! 621: FREE(inp_list, M_TEMP); ! 622: return error; ! 623: } ! 624: ! 625: ! 626: SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist, CTLFLAG_RD, 0, 0, ! 627: tcp_pcblist, "S,xtcpcb", "List of active TCP connections"); ! 628: ! 629: void ! 630: tcp_ctlinput(cmd, sa, vip) ! 631: int cmd; ! 632: struct sockaddr *sa; ! 633: void *vip; ! 634: { ! 635: register struct ip *ip = vip; ! 636: register struct tcphdr *th; ! 637: void (*notify) __P((struct inpcb *, int)) = tcp_notify; ! 638: ! 639: if (cmd == PRC_QUENCH) ! 640: notify = tcp_quench; ! 641: else if (cmd == PRC_MSGSIZE) ! 642: notify = tcp_mtudisc; ! 643: else if (!PRC_IS_REDIRECT(cmd) && ! 644: ((unsigned)cmd > PRC_NCMDS || inetctlerrmap[cmd] == 0)) ! 645: return; ! 646: if (ip) { ! 647: th = (struct tcphdr *)((caddr_t)ip ! 648: + (IP_VHL_HL(ip->ip_vhl) << 2)); ! 649: in_pcbnotify(&tcb, sa, th->th_dport, ip->ip_src, th->th_sport, ! 650: cmd, notify); ! 651: } else ! 652: in_pcbnotify(&tcb, sa, 0, zeroin_addr, 0, cmd, notify); ! 653: } ! 654: ! 655: /* ! 656: * When a source quench is received, close congestion window ! 657: * to one segment. We will gradually open it again as we proceed. ! 658: */ ! 659: void ! 660: tcp_quench(inp, errno) ! 661: struct inpcb *inp; ! 662: int errno; ! 663: { ! 664: struct tcpcb *tp = intotcpcb(inp); ! 665: ! 666: if (tp) ! 667: tp->snd_cwnd = tp->t_maxseg; ! 668: } ! 669: ! 670: /* ! 671: * When `need fragmentation' ICMP is received, update our idea of the MSS ! 672: * based on the new value in the route. Also nudge TCP to send something, ! 673: * since we know the packet we just sent was dropped. ! 674: * This duplicates some code in the tcp_mss() function in tcp_input.c. ! 675: */ ! 676: void ! 677: tcp_mtudisc(inp, errno) ! 678: struct inpcb *inp; ! 679: int errno; ! 680: { ! 681: struct tcpcb *tp = intotcpcb(inp); ! 682: struct rtentry *rt; ! 683: struct rmxp_tao *taop; ! 684: struct socket *so = inp->inp_socket; ! 685: int offered; ! 686: int mss; ! 687: ! 688: if (tp) { ! 689: rt = tcp_rtlookup(inp); ! 690: if (!rt || !rt->rt_rmx.rmx_mtu) { ! 691: tp->t_maxopd = tp->t_maxseg = tcp_mssdflt; ! 692: return; ! 693: } ! 694: taop = rmx_taop(rt->rt_rmx); ! 695: offered = taop->tao_mssopt; ! 696: mss = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr); ! 697: if (offered) ! 698: mss = min(mss, offered); ! 699: /* ! 700: * XXX - The above conditional probably violates the TCP ! 701: * spec. The problem is that, since we don't know the ! 702: * other end's MSS, we are supposed to use a conservative ! 703: * default. But, if we do that, then MTU discovery will ! 704: * never actually take place, because the conservative ! 705: * default is much less than the MTUs typically seen ! 706: * on the Internet today. For the moment, we'll sweep ! 707: * this under the carpet. ! 708: * ! 709: * The conservative default might not actually be a problem ! 710: * if the only case this occurs is when sending an initial ! 711: * SYN with options and data to a host we've never talked ! 712: * to before. Then, they will reply with an MSS value which ! 713: * will get recorded and the new parameters should get ! 714: * recomputed. For Further Study. ! 715: */ ! 716: if (tp->t_maxopd <= mss) ! 717: return; ! 718: tp->t_maxopd = mss; ! 719: ! 720: if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP && ! 721: (tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP) ! 722: mss -= TCPOLEN_TSTAMP_APPA; ! 723: if ((tp->t_flags & (TF_REQ_CC|TF_NOOPT)) == TF_REQ_CC && ! 724: (tp->t_flags & TF_RCVD_CC) == TF_RCVD_CC) ! 725: mss -= TCPOLEN_CC_APPA; ! 726: #if (MCLBYTES & (MCLBYTES - 1)) == 0 ! 727: if (mss > MCLBYTES) ! 728: mss &= ~(MCLBYTES-1); ! 729: #else ! 730: if (mss > MCLBYTES) ! 731: mss = mss / MCLBYTES * MCLBYTES; ! 732: #endif ! 733: if (so->so_snd.sb_hiwat < mss) ! 734: mss = so->so_snd.sb_hiwat; ! 735: ! 736: tp->t_maxseg = mss; ! 737: ! 738: tcpstat.tcps_mturesent++; ! 739: tp->t_rtt = 0; ! 740: tp->snd_nxt = tp->snd_una; ! 741: tcp_output(tp); ! 742: } ! 743: } ! 744: ! 745: /* ! 746: * Look-up the routing entry to the peer of this inpcb. If no route ! 747: * is found and it cannot be allocated the return NULL. This routine ! 748: * is called by TCP routines that access the rmx structure and by tcp_mss ! 749: * to get the interface MTU. ! 750: */ ! 751: struct rtentry * ! 752: tcp_rtlookup(inp) ! 753: struct inpcb *inp; ! 754: { ! 755: struct route *ro; ! 756: struct rtentry *rt; ! 757: ! 758: ro = &inp->inp_route; ! 759: rt = ro->ro_rt; ! 760: if (rt == NULL || !(rt->rt_flags & RTF_UP)) { ! 761: /* No route yet, so try to acquire one */ ! 762: if (inp->inp_faddr.s_addr != INADDR_ANY) { ! 763: ro->ro_dst.sa_family = AF_INET; ! 764: ro->ro_dst.sa_len = sizeof(ro->ro_dst); ! 765: ((struct sockaddr_in *) &ro->ro_dst)->sin_addr = ! 766: inp->inp_faddr; ! 767: rtalloc(ro); ! 768: rt = ro->ro_rt; ! 769: } ! 770: } ! 771: return rt; ! 772: } ! 773: ! 774: /* ! 775: * Return a pointer to the cached information about the remote host. ! 776: * The cached information is stored in the protocol specific part of ! 777: * the route metrics. ! 778: */ ! 779: struct rmxp_tao * ! 780: tcp_gettaocache(inp) ! 781: struct inpcb *inp; ! 782: { ! 783: struct rtentry *rt = tcp_rtlookup(inp); ! 784: ! 785: /* Make sure this is a host route and is up. */ ! 786: if (rt == NULL || ! 787: (rt->rt_flags & (RTF_UP|RTF_HOST)) != (RTF_UP|RTF_HOST)) ! 788: return NULL; ! 789: ! 790: return rmx_taop(rt->rt_rmx); ! 791: } ! 792: ! 793: /* ! 794: * Clear all the TAO cache entries, called from tcp_init. ! 795: * ! 796: * XXX ! 797: * This routine is just an empty one, because we assume that the routing ! 798: * routing tables are initialized at the same time when TCP, so there is ! 799: * nothing in the cache left over. ! 800: */ ! 801: static void ! 802: tcp_cleartaocache() ! 803: { ! 804: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.