Annotation of sys/netinet/tcp_subr.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: tcp_subr.c,v 1.98 2007/06/25 12:17:43 markus Exp $ */
2: /* $NetBSD: tcp_subr.c,v 1.22 1996/02/13 23:44:00 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1988, 1990, 1993
6: * The Regents of the University of California. All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
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. Neither the name of the University nor the names of its contributors
17: * may be used to endorse or promote products derived from this software
18: * without specific prior written permission.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30: * SUCH DAMAGE.
31: *
32: * @(#)COPYRIGHT 1.1 (NRL) 17 January 1995
33: *
34: * NRL grants permission for redistribution and use in source and binary
35: * forms, with or without modification, of the software and documentation
36: * created at NRL provided that the following conditions are met:
37: *
38: * 1. Redistributions of source code must retain the above copyright
39: * notice, this list of conditions and the following disclaimer.
40: * 2. Redistributions in binary form must reproduce the above copyright
41: * notice, this list of conditions and the following disclaimer in the
42: * documentation and/or other materials provided with the distribution.
43: * 3. All advertising materials mentioning features or use of this software
44: * must display the following acknowledgements:
45: * This product includes software developed by the University of
46: * California, Berkeley and its contributors.
47: * This product includes software developed at the Information
48: * Technology Division, US Naval Research Laboratory.
49: * 4. Neither the name of the NRL nor the names of its contributors
50: * may be used to endorse or promote products derived from this software
51: * without specific prior written permission.
52: *
53: * THE SOFTWARE PROVIDED BY NRL IS PROVIDED BY NRL AND CONTRIBUTORS ``AS
54: * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
55: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
56: * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NRL OR
57: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
58: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
59: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
60: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
61: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
62: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
63: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64: *
65: * The views and conclusions contained in the software and documentation
66: * are those of the authors and should not be interpreted as representing
67: * official policies, either expressed or implied, of the US Naval
68: * Research Laboratory (NRL).
69: */
70:
71: #include <sys/param.h>
72: #include <sys/systm.h>
73: #include <sys/proc.h>
74: #include <sys/mbuf.h>
75: #include <sys/socket.h>
76: #include <sys/socketvar.h>
77: #include <sys/protosw.h>
78: #include <sys/kernel.h>
79:
80: #include <net/route.h>
81: #include <net/if.h>
82:
83: #include <netinet/in.h>
84: #include <netinet/in_systm.h>
85: #include <netinet/ip.h>
86: #include <netinet/in_pcb.h>
87: #include <netinet/ip_var.h>
88: #include <netinet/ip_icmp.h>
89: #include <netinet/tcp.h>
90: #include <netinet/tcp_fsm.h>
91: #include <netinet/tcp_seq.h>
92: #include <netinet/tcp_timer.h>
93: #include <netinet/tcp_var.h>
94: #include <netinet/tcpip.h>
95: #include <dev/rndvar.h>
96:
97: #ifdef INET6
98: #include <netinet6/in6_var.h>
99: #include <netinet6/ip6protosw.h>
100: #endif /* INET6 */
101:
102: #include <crypto/md5.h>
103:
104: /* patchable/settable parameters for tcp */
105: int tcp_mssdflt = TCP_MSS;
106: int tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
107:
108: /* values controllable via sysctl */
109: int tcp_do_rfc1323 = 1;
110: #ifdef TCP_SACK
111: int tcp_do_sack = 1; /* RFC 2018 selective ACKs */
112: #endif
113: int tcp_ack_on_push = 0; /* set to enable immediate ACK-on-PUSH */
114: #ifdef TCP_ECN
115: int tcp_do_ecn = 0; /* RFC3168 ECN enabled/disabled? */
116: #endif
117: int tcp_do_rfc3390 = 1; /* RFC3390 Increasing TCP's Initial Window */
118:
119: u_int32_t tcp_now = 1;
120:
121: #ifndef TCBHASHSIZE
122: #define TCBHASHSIZE 128
123: #endif
124: int tcbhashsize = TCBHASHSIZE;
125:
126: /* syn hash parameters */
127: #define TCP_SYN_HASH_SIZE 293
128: #define TCP_SYN_BUCKET_SIZE 35
129: int tcp_syn_cache_size = TCP_SYN_HASH_SIZE;
130: int tcp_syn_cache_limit = TCP_SYN_HASH_SIZE*TCP_SYN_BUCKET_SIZE;
131: int tcp_syn_bucket_limit = 3*TCP_SYN_BUCKET_SIZE;
132: struct syn_cache_head tcp_syn_cache[TCP_SYN_HASH_SIZE];
133:
134: int tcp_reass_limit = NMBCLUSTERS / 2; /* hardlimit for tcpqe_pool */
135: #ifdef TCP_SACK
136: int tcp_sackhole_limit = 32*1024; /* hardlimit for sackhl_pool */
137: #endif
138:
139: #ifdef INET6
140: extern int ip6_defhlim;
141: #endif /* INET6 */
142:
143: struct pool tcpcb_pool;
144: struct pool tcpqe_pool;
145: #ifdef TCP_SACK
146: struct pool sackhl_pool;
147: #endif
148:
149: struct tcpstat tcpstat; /* tcp statistics */
150: tcp_seq tcp_iss;
151:
152: /*
153: * Tcp initialization
154: */
155: void
156: tcp_init()
157: {
158: tcp_iss = 1; /* wrong */
159: pool_init(&tcpcb_pool, sizeof(struct tcpcb), 0, 0, 0, "tcpcbpl",
160: NULL);
161: pool_init(&tcpqe_pool, sizeof(struct tcpqent), 0, 0, 0, "tcpqepl",
162: NULL);
163: pool_sethardlimit(&tcpqe_pool, tcp_reass_limit, NULL, 0);
164: #ifdef TCP_SACK
165: pool_init(&sackhl_pool, sizeof(struct sackhole), 0, 0, 0, "sackhlpl",
166: NULL);
167: pool_sethardlimit(&sackhl_pool, tcp_sackhole_limit, NULL, 0);
168: #endif /* TCP_SACK */
169: in_pcbinit(&tcbtable, tcbhashsize);
170:
171: #ifdef INET6
172: /*
173: * Since sizeof(struct ip6_hdr) > sizeof(struct ip), we
174: * do max length checks/computations only on the former.
175: */
176: if (max_protohdr < (sizeof(struct ip6_hdr) + sizeof(struct tcphdr)))
177: max_protohdr = (sizeof(struct ip6_hdr) + sizeof(struct tcphdr));
178: if ((max_linkhdr + sizeof(struct ip6_hdr) + sizeof(struct tcphdr)) >
179: MHLEN)
180: panic("tcp_init");
181:
182: icmp6_mtudisc_callback_register(tcp6_mtudisc_callback);
183: #endif /* INET6 */
184:
185: /* Initialize the compressed state engine. */
186: syn_cache_init();
187:
188: /* Initialize timer state. */
189: tcp_timer_init();
190: }
191:
192: /*
193: * Create template to be used to send tcp packets on a connection.
194: * Call after host entry created, allocates an mbuf and fills
195: * in a skeletal tcp/ip header, minimizing the amount of work
196: * necessary when the connection is used.
197: *
198: * To support IPv6 in addition to IPv4 and considering that the sizes of
199: * the IPv4 and IPv6 headers are not the same, we now use a separate pointer
200: * for the TCP header. Also, we made the former tcpiphdr header pointer
201: * into just an IP overlay pointer, with casting as appropriate for v6. rja
202: */
203: struct mbuf *
204: tcp_template(tp)
205: struct tcpcb *tp;
206: {
207: struct inpcb *inp = tp->t_inpcb;
208: struct mbuf *m;
209: struct tcphdr *th;
210:
211: if ((m = tp->t_template) == 0) {
212: m = m_get(M_DONTWAIT, MT_HEADER);
213: if (m == NULL)
214: return (0);
215:
216: switch (tp->pf) {
217: case 0: /*default to PF_INET*/
218: #ifdef INET
219: case AF_INET:
220: m->m_len = sizeof(struct ip);
221: break;
222: #endif /* INET */
223: #ifdef INET6
224: case AF_INET6:
225: m->m_len = sizeof(struct ip6_hdr);
226: break;
227: #endif /* INET6 */
228: }
229: m->m_len += sizeof (struct tcphdr);
230:
231: /*
232: * The link header, network header, TCP header, and TCP options
233: * all must fit in this mbuf. For now, assume the worst case of
234: * TCP options size. Eventually, compute this from tp flags.
235: */
236: if (m->m_len + MAX_TCPOPTLEN + max_linkhdr >= MHLEN) {
237: MCLGET(m, M_DONTWAIT);
238: if ((m->m_flags & M_EXT) == 0) {
239: m_free(m);
240: return (0);
241: }
242: }
243: }
244:
245: switch(tp->pf) {
246: #ifdef INET
247: case AF_INET:
248: {
249: struct ipovly *ipovly;
250:
251: ipovly = mtod(m, struct ipovly *);
252:
253: bzero(ipovly->ih_x1, sizeof ipovly->ih_x1);
254: ipovly->ih_pr = IPPROTO_TCP;
255: ipovly->ih_len = htons(sizeof (struct tcphdr));
256: ipovly->ih_src = inp->inp_laddr;
257: ipovly->ih_dst = inp->inp_faddr;
258:
259: th = (struct tcphdr *)(mtod(m, caddr_t) +
260: sizeof(struct ip));
261: th->th_sum = in_cksum_phdr(ipovly->ih_src.s_addr,
262: ipovly->ih_dst.s_addr,
263: htons(sizeof (struct tcphdr) + IPPROTO_TCP));
264: }
265: break;
266: #endif /* INET */
267: #ifdef INET6
268: case AF_INET6:
269: {
270: struct ip6_hdr *ip6;
271:
272: ip6 = mtod(m, struct ip6_hdr *);
273:
274: ip6->ip6_src = inp->inp_laddr6;
275: ip6->ip6_dst = inp->inp_faddr6;
276: ip6->ip6_flow = htonl(0x60000000) |
277: (inp->inp_flowinfo & IPV6_FLOWLABEL_MASK);
278:
279: ip6->ip6_nxt = IPPROTO_TCP;
280: ip6->ip6_plen = htons(sizeof(struct tcphdr)); /*XXX*/
281: ip6->ip6_hlim = in6_selecthlim(inp, NULL); /*XXX*/
282:
283: th = (struct tcphdr *)(mtod(m, caddr_t) +
284: sizeof(struct ip6_hdr));
285: th->th_sum = 0;
286: }
287: break;
288: #endif /* INET6 */
289: }
290:
291: th->th_sport = inp->inp_lport;
292: th->th_dport = inp->inp_fport;
293: th->th_seq = 0;
294: th->th_ack = 0;
295: th->th_x2 = 0;
296: th->th_off = 5;
297: th->th_flags = 0;
298: th->th_win = 0;
299: th->th_urp = 0;
300: return (m);
301: }
302:
303: /*
304: * Send a single message to the TCP at address specified by
305: * the given TCP/IP header. If m == 0, then we make a copy
306: * of the tcpiphdr at ti and send directly to the addressed host.
307: * This is used to force keep alive messages out using the TCP
308: * template for a connection tp->t_template. If flags are given
309: * then we send a message back to the TCP which originated the
310: * segment ti, and discard the mbuf containing it and any other
311: * attached mbufs.
312: *
313: * In any case the ack and sequence number of the transmitted
314: * segment are as specified by the parameters.
315: */
316: #ifdef INET6
317: /* This function looks hairy, because it was so IPv4-dependent. */
318: #endif /* INET6 */
319: void
320: tcp_respond(tp, template, m, ack, seq, flags)
321: struct tcpcb *tp;
322: caddr_t template;
323: struct mbuf *m;
324: tcp_seq ack, seq;
325: int flags;
326: {
327: int tlen;
328: int win = 0;
329: struct route *ro = 0;
330: struct tcphdr *th;
331: struct tcpiphdr *ti = (struct tcpiphdr *)template;
332: int af; /* af on wire */
333:
334: if (tp) {
335: win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
336: /*
337: * If this is called with an unconnected
338: * socket/tp/pcb (tp->pf is 0), we lose.
339: */
340: af = tp->pf;
341:
342: /*
343: * The route/route6 distinction is meaningless
344: * unless you're allocating space or passing parameters.
345: */
346: ro = &tp->t_inpcb->inp_route;
347: } else
348: af = (((struct ip *)ti)->ip_v == 6) ? AF_INET6 : AF_INET;
349: if (m == 0) {
350: m = m_gethdr(M_DONTWAIT, MT_HEADER);
351: if (m == NULL)
352: return;
353: #ifdef TCP_COMPAT_42
354: tlen = 1;
355: #else
356: tlen = 0;
357: #endif
358: m->m_data += max_linkhdr;
359: switch (af) {
360: #ifdef INET6
361: case AF_INET6:
362: bcopy(ti, mtod(m, caddr_t), sizeof(struct tcphdr) +
363: sizeof(struct ip6_hdr));
364: break;
365: #endif /* INET6 */
366: case AF_INET:
367: bcopy(ti, mtod(m, caddr_t), sizeof(struct tcphdr) +
368: sizeof(struct ip));
369: break;
370: }
371:
372: ti = mtod(m, struct tcpiphdr *);
373: flags = TH_ACK;
374: } else {
375: m_freem(m->m_next);
376: m->m_next = 0;
377: m->m_data = (caddr_t)ti;
378: tlen = 0;
379: #define xchg(a,b,type) do { type t; t=a; a=b; b=t; } while (0)
380: switch (af) {
381: #ifdef INET6
382: case AF_INET6:
383: m->m_len = sizeof(struct tcphdr) + sizeof(struct ip6_hdr);
384: xchg(((struct ip6_hdr *)ti)->ip6_dst,
385: ((struct ip6_hdr *)ti)->ip6_src, struct in6_addr);
386: th = (void *)((caddr_t)ti + sizeof(struct ip6_hdr));
387: break;
388: #endif /* INET6 */
389: case AF_INET:
390: m->m_len = sizeof (struct tcpiphdr);
391: xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_int32_t);
392: th = (void *)((caddr_t)ti + sizeof(struct ip));
393: break;
394: }
395: xchg(th->th_dport, th->th_sport, u_int16_t);
396: #undef xchg
397: }
398: switch (af) {
399: #ifdef INET6
400: case AF_INET6:
401: tlen += sizeof(struct tcphdr) + sizeof(struct ip6_hdr);
402: th = (struct tcphdr *)((caddr_t)ti + sizeof(struct ip6_hdr));
403: break;
404: #endif /* INET6 */
405: case AF_INET:
406: ti->ti_len = htons((u_int16_t)(sizeof (struct tcphdr) + tlen));
407: tlen += sizeof (struct tcpiphdr);
408: th = (struct tcphdr *)((caddr_t)ti + sizeof(struct ip));
409: break;
410: }
411:
412: m->m_len = tlen;
413: m->m_pkthdr.len = tlen;
414: m->m_pkthdr.rcvif = (struct ifnet *) 0;
415: th->th_seq = htonl(seq);
416: th->th_ack = htonl(ack);
417: th->th_x2 = 0;
418: th->th_off = sizeof (struct tcphdr) >> 2;
419: th->th_flags = flags;
420: if (tp)
421: win >>= tp->rcv_scale;
422: if (win > TCP_MAXWIN)
423: win = TCP_MAXWIN;
424: th->th_win = htons((u_int16_t)win);
425: th->th_urp = 0;
426:
427: switch (af) {
428: #ifdef INET6
429: case AF_INET6:
430: ((struct ip6_hdr *)ti)->ip6_flow = htonl(0x60000000);
431: ((struct ip6_hdr *)ti)->ip6_nxt = IPPROTO_TCP;
432: ((struct ip6_hdr *)ti)->ip6_hlim =
433: in6_selecthlim(tp ? tp->t_inpcb : NULL, NULL); /*XXX*/
434: ((struct ip6_hdr *)ti)->ip6_plen = tlen - sizeof(struct ip6_hdr);
435: th->th_sum = 0;
436: th->th_sum = in6_cksum(m, IPPROTO_TCP,
437: sizeof(struct ip6_hdr), ((struct ip6_hdr *)ti)->ip6_plen);
438: HTONS(((struct ip6_hdr *)ti)->ip6_plen);
439: ip6_output(m, tp ? tp->t_inpcb->inp_outputopts6 : NULL,
440: (struct route_in6 *)ro, 0, NULL, NULL,
441: tp ? tp->t_inpcb : NULL);
442: break;
443: #endif /* INET6 */
444: case AF_INET:
445: bzero(ti->ti_x1, sizeof ti->ti_x1);
446: ti->ti_len = htons((u_short)tlen - sizeof(struct ip));
447:
448: /*
449: * There's no point deferring to hardware checksum processing
450: * here, as we only send a minimal TCP packet whose checksum
451: * we need to compute in any case.
452: */
453: th->th_sum = 0;
454: th->th_sum = in_cksum(m, tlen);
455: ((struct ip *)ti)->ip_len = htons(tlen);
456: ((struct ip *)ti)->ip_ttl = ip_defttl;
457: ip_output(m, (void *)NULL, ro, ip_mtudisc ? IP_MTUDISC : 0,
458: (void *)NULL, tp ? tp->t_inpcb : (void *)NULL);
459: }
460: }
461:
462: /*
463: * Create a new TCP control block, making an
464: * empty reassembly queue and hooking it to the argument
465: * protocol control block.
466: */
467: struct tcpcb *
468: tcp_newtcpcb(struct inpcb *inp)
469: {
470: struct tcpcb *tp;
471: int i;
472:
473: tp = pool_get(&tcpcb_pool, PR_NOWAIT);
474: if (tp == NULL)
475: return ((struct tcpcb *)0);
476: bzero((char *) tp, sizeof(struct tcpcb));
477: TAILQ_INIT(&tp->t_segq);
478: tp->t_maxseg = tcp_mssdflt;
479: tp->t_maxopd = 0;
480:
481: TCP_INIT_DELACK(tp);
482: for (i = 0; i < TCPT_NTIMERS; i++)
483: TCP_TIMER_INIT(tp, i);
484: timeout_set(&tp->t_reap_to, tcp_reaper, tp);
485:
486: #ifdef TCP_SACK
487: tp->sack_enable = tcp_do_sack;
488: #endif
489: tp->t_flags = tcp_do_rfc1323 ? (TF_REQ_SCALE|TF_REQ_TSTMP) : 0;
490: tp->t_inpcb = inp;
491: /*
492: * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
493: * rtt estimate. Set rttvar so that srtt + 2 * rttvar gives
494: * reasonable initial retransmit time.
495: */
496: tp->t_srtt = TCPTV_SRTTBASE;
497: tp->t_rttvar = tcp_rttdflt * PR_SLOWHZ <<
498: (TCP_RTTVAR_SHIFT + TCP_RTT_BASE_SHIFT - 1);
499: tp->t_rttmin = TCPTV_MIN;
500: TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
501: TCPTV_MIN, TCPTV_REXMTMAX);
502: tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
503: tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
504:
505: tp->t_pmtud_mtu_sent = 0;
506: tp->t_pmtud_mss_acked = 0;
507:
508: #ifdef INET6
509: /* we disallow IPv4 mapped address completely. */
510: if ((inp->inp_flags & INP_IPV6) == 0)
511: tp->pf = PF_INET;
512: else
513: tp->pf = PF_INET6;
514: #else
515: tp->pf = PF_INET;
516: #endif
517:
518: #ifdef INET6
519: if (inp->inp_flags & INP_IPV6)
520: inp->inp_ipv6.ip6_hlim = ip6_defhlim;
521: else
522: #endif /* INET6 */
523: inp->inp_ip.ip_ttl = ip_defttl;
524:
525: inp->inp_ppcb = (caddr_t)tp;
526: return (tp);
527: }
528:
529: /*
530: * Drop a TCP connection, reporting
531: * the specified error. If connection is synchronized,
532: * then send a RST to peer.
533: */
534: struct tcpcb *
535: tcp_drop(tp, errno)
536: struct tcpcb *tp;
537: int errno;
538: {
539: struct socket *so = tp->t_inpcb->inp_socket;
540:
541: if (TCPS_HAVERCVDSYN(tp->t_state)) {
542: tp->t_state = TCPS_CLOSED;
543: (void) tcp_output(tp);
544: tcpstat.tcps_drops++;
545: } else
546: tcpstat.tcps_conndrops++;
547: if (errno == ETIMEDOUT && tp->t_softerror)
548: errno = tp->t_softerror;
549: so->so_error = errno;
550: return (tcp_close(tp));
551: }
552:
553: /*
554: * Close a TCP control block:
555: * discard all space held by the tcp
556: * discard internet protocol block
557: * wake up any sleepers
558: */
559: struct tcpcb *
560: tcp_close(struct tcpcb *tp)
561: {
562: struct inpcb *inp = tp->t_inpcb;
563: struct socket *so = inp->inp_socket;
564: #ifdef TCP_SACK
565: struct sackhole *p, *q;
566: #endif
567:
568: /* free the reassembly queue, if any */
569: tcp_reass_lock(tp);
570: tcp_freeq(tp);
571: tcp_reass_unlock(tp);
572:
573: tcp_canceltimers(tp);
574: TCP_CLEAR_DELACK(tp);
575: syn_cache_cleanup(tp);
576:
577: #ifdef TCP_SACK
578: /* Free SACK holes. */
579: q = p = tp->snd_holes;
580: while (p != 0) {
581: q = p->next;
582: pool_put(&sackhl_pool, p);
583: p = q;
584: }
585: #endif
586: if (tp->t_template)
587: (void) m_free(tp->t_template);
588:
589: tp->t_flags |= TF_DEAD;
590: timeout_add(&tp->t_reap_to, 0);
591:
592: inp->inp_ppcb = 0;
593: soisdisconnected(so);
594: in_pcbdetach(inp);
595: return ((struct tcpcb *)0);
596: }
597:
598: void
599: tcp_reaper(void *arg)
600: {
601: struct tcpcb *tp = arg;
602: int s;
603:
604: s = splsoftnet();
605: pool_put(&tcpcb_pool, tp);
606: splx(s);
607: tcpstat.tcps_closed++;
608: }
609:
610: int
611: tcp_freeq(struct tcpcb *tp)
612: {
613: struct tcpqent *qe;
614: int rv = 0;
615:
616: while ((qe = TAILQ_FIRST(&tp->t_segq)) != NULL) {
617: TAILQ_REMOVE(&tp->t_segq, qe, tcpqe_q);
618: m_freem(qe->tcpqe_m);
619: pool_put(&tcpqe_pool, qe);
620: rv = 1;
621: }
622: return (rv);
623: }
624:
625: void
626: tcp_drain()
627: {
628: struct inpcb *inp;
629:
630: /* called at splnet() */
631: CIRCLEQ_FOREACH(inp, &tcbtable.inpt_queue, inp_queue) {
632: struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
633:
634: if (tp != NULL) {
635: if (tcp_reass_lock_try(tp) == 0)
636: continue;
637: if (tcp_freeq(tp))
638: tcpstat.tcps_conndrained++;
639: tcp_reass_unlock(tp);
640: }
641: }
642: }
643:
644: /*
645: * Compute proper scaling value for receiver window from buffer space
646: */
647:
648: void
649: tcp_rscale(struct tcpcb *tp, u_long hiwat)
650: {
651: tp->request_r_scale = 0;
652: while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
653: TCP_MAXWIN << tp->request_r_scale < hiwat)
654: tp->request_r_scale++;
655: }
656:
657: /*
658: * Notify a tcp user of an asynchronous error;
659: * store error as soft error, but wake up user
660: * (for now, won't do anything until can select for soft error).
661: */
662: void
663: tcp_notify(inp, error)
664: struct inpcb *inp;
665: int error;
666: {
667: struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
668: struct socket *so = inp->inp_socket;
669:
670: /*
671: * Ignore some errors if we are hooked up.
672: * If connection hasn't completed, has retransmitted several times,
673: * and receives a second error, give up now. This is better
674: * than waiting a long time to establish a connection that
675: * can never complete.
676: */
677: if (tp->t_state == TCPS_ESTABLISHED &&
678: (error == EHOSTUNREACH || error == ENETUNREACH ||
679: error == EHOSTDOWN)) {
680: return;
681: } else if (TCPS_HAVEESTABLISHED(tp->t_state) == 0 &&
682: tp->t_rxtshift > 3 && tp->t_softerror)
683: so->so_error = error;
684: else
685: tp->t_softerror = error;
686: wakeup((caddr_t) &so->so_timeo);
687: sorwakeup(so);
688: sowwakeup(so);
689: }
690:
691: #ifdef INET6
692: void
693: tcp6_ctlinput(cmd, sa, d)
694: int cmd;
695: struct sockaddr *sa;
696: void *d;
697: {
698: struct tcphdr th;
699: struct tcpcb *tp;
700: void (*notify)(struct inpcb *, int) = tcp_notify;
701: struct ip6_hdr *ip6;
702: const struct sockaddr_in6 *sa6_src = NULL;
703: struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
704: struct inpcb *inp;
705: struct mbuf *m;
706: tcp_seq seq;
707: int off;
708: struct {
709: u_int16_t th_sport;
710: u_int16_t th_dport;
711: u_int32_t th_seq;
712: } *thp;
713:
714: if (sa->sa_family != AF_INET6 ||
715: sa->sa_len != sizeof(struct sockaddr_in6) ||
716: IN6_IS_ADDR_UNSPECIFIED(&sa6->sin6_addr) ||
717: IN6_IS_ADDR_V4MAPPED(&sa6->sin6_addr))
718: return;
719: if ((unsigned)cmd >= PRC_NCMDS)
720: return;
721: else if (cmd == PRC_QUENCH) {
722: /*
723: * Don't honor ICMP Source Quench messages meant for
724: * TCP connections.
725: */
726: /* XXX there's no PRC_QUENCH in IPv6 */
727: return;
728: } else if (PRC_IS_REDIRECT(cmd))
729: notify = in_rtchange, d = NULL;
730: else if (cmd == PRC_MSGSIZE)
731: ; /* special code is present, see below */
732: else if (cmd == PRC_HOSTDEAD)
733: d = NULL;
734: else if (inet6ctlerrmap[cmd] == 0)
735: return;
736:
737: /* if the parameter is from icmp6, decode it. */
738: if (d != NULL) {
739: struct ip6ctlparam *ip6cp = (struct ip6ctlparam *)d;
740: m = ip6cp->ip6c_m;
741: ip6 = ip6cp->ip6c_ip6;
742: off = ip6cp->ip6c_off;
743: sa6_src = ip6cp->ip6c_src;
744: } else {
745: m = NULL;
746: ip6 = NULL;
747: sa6_src = &sa6_any;
748: }
749:
750: if (ip6) {
751: /*
752: * XXX: We assume that when ip6 is non NULL,
753: * M and OFF are valid.
754: */
755:
756: /* check if we can safely examine src and dst ports */
757: if (m->m_pkthdr.len < off + sizeof(*thp))
758: return;
759:
760: bzero(&th, sizeof(th));
761: #ifdef DIAGNOSTIC
762: if (sizeof(*thp) > sizeof(th))
763: panic("assumption failed in tcp6_ctlinput");
764: #endif
765: m_copydata(m, off, sizeof(*thp), (caddr_t)&th);
766:
767: /*
768: * Check to see if we have a valid TCP connection
769: * corresponding to the address in the ICMPv6 message
770: * payload.
771: */
772: inp = in6_pcbhashlookup(&tcbtable, &sa6->sin6_addr,
773: th.th_dport, (struct in6_addr *)&sa6_src->sin6_addr,
774: th.th_sport);
775: if (cmd == PRC_MSGSIZE) {
776: /*
777: * Depending on the value of "valid" and routing table
778: * size (mtudisc_{hi,lo}wat), we will:
779: * - recalcurate the new MTU and create the
780: * corresponding routing entry, or
781: * - ignore the MTU change notification.
782: */
783: icmp6_mtudisc_update((struct ip6ctlparam *)d, inp != NULL);
784: return;
785: }
786: if (inp) {
787: seq = ntohl(th.th_seq);
788: if (inp->inp_socket &&
789: (tp = intotcpcb(inp)) &&
790: SEQ_GEQ(seq, tp->snd_una) &&
791: SEQ_LT(seq, tp->snd_max))
792: notify(inp, inet6ctlerrmap[cmd]);
793: } else if (syn_cache_count &&
794: (inet6ctlerrmap[cmd] == EHOSTUNREACH ||
795: inet6ctlerrmap[cmd] == ENETUNREACH ||
796: inet6ctlerrmap[cmd] == EHOSTDOWN))
797: syn_cache_unreach((struct sockaddr *)sa6_src,
798: sa, &th);
799: } else {
800: (void) in6_pcbnotify(&tcbtable, sa, 0,
801: (struct sockaddr *)sa6_src, 0, cmd, NULL, notify);
802: }
803: }
804: #endif
805:
806: void *
807: tcp_ctlinput(cmd, sa, v)
808: int cmd;
809: struct sockaddr *sa;
810: void *v;
811: {
812: struct ip *ip = v;
813: struct tcphdr *th;
814: struct tcpcb *tp;
815: struct inpcb *inp;
816: struct in_addr faddr;
817: tcp_seq seq;
818: u_int mtu;
819: extern int inetctlerrmap[];
820: void (*notify)(struct inpcb *, int) = tcp_notify;
821: int errno;
822:
823: if (sa->sa_family != AF_INET)
824: return NULL;
825: faddr = satosin(sa)->sin_addr;
826: if (faddr.s_addr == INADDR_ANY)
827: return NULL;
828:
829: if ((unsigned)cmd >= PRC_NCMDS)
830: return NULL;
831: errno = inetctlerrmap[cmd];
832: if (cmd == PRC_QUENCH)
833: /*
834: * Don't honor ICMP Source Quench messages meant for
835: * TCP connections.
836: */
837: return NULL;
838: else if (PRC_IS_REDIRECT(cmd))
839: notify = in_rtchange, ip = 0;
840: else if (cmd == PRC_MSGSIZE && ip_mtudisc && ip) {
841: /*
842: * Verify that the packet in the icmp payload refers
843: * to an existing TCP connection.
844: */
845: th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
846: seq = ntohl(th->th_seq);
847: inp = in_pcbhashlookup(&tcbtable,
848: ip->ip_dst, th->th_dport, ip->ip_src, th->th_sport);
849: if (inp && (tp = intotcpcb(inp)) &&
850: SEQ_GEQ(seq, tp->snd_una) &&
851: SEQ_LT(seq, tp->snd_max)) {
852: struct icmp *icp;
853: icp = (struct icmp *)((caddr_t)ip -
854: offsetof(struct icmp, icmp_ip));
855:
856: /*
857: * If the ICMP message advertises a Next-Hop MTU
858: * equal or larger than the maximum packet size we have
859: * ever sent, drop the message.
860: */
861: mtu = (u_int)ntohs(icp->icmp_nextmtu);
862: if (mtu >= tp->t_pmtud_mtu_sent)
863: return NULL;
864: if (mtu >= tcp_hdrsz(tp) + tp->t_pmtud_mss_acked) {
865: /*
866: * Calculate new MTU, and create corresponding
867: * route (traditional PMTUD).
868: */
869: tp->t_flags &= ~TF_PMTUD_PEND;
870: icmp_mtudisc(icp);
871: } else {
872: /*
873: * Record the information got in the ICMP
874: * message; act on it later.
875: * If we had already recorded an ICMP message,
876: * replace the old one only if the new message
877: * refers to an older TCP segment
878: */
879: if (tp->t_flags & TF_PMTUD_PEND) {
880: if (SEQ_LT(tp->t_pmtud_th_seq, seq))
881: return NULL;
882: } else
883: tp->t_flags |= TF_PMTUD_PEND;
884: tp->t_pmtud_th_seq = seq;
885: tp->t_pmtud_nextmtu = icp->icmp_nextmtu;
886: tp->t_pmtud_ip_len = icp->icmp_ip.ip_len;
887: tp->t_pmtud_ip_hl = icp->icmp_ip.ip_hl;
888: return NULL;
889: }
890: } else {
891: /* ignore if we don't have a matching connection */
892: return NULL;
893: }
894: notify = tcp_mtudisc, ip = 0;
895: } else if (cmd == PRC_MTUINC)
896: notify = tcp_mtudisc_increase, ip = 0;
897: else if (cmd == PRC_HOSTDEAD)
898: ip = 0;
899: else if (errno == 0)
900: return NULL;
901:
902: if (ip) {
903: th = (struct tcphdr *)((caddr_t)ip + (ip->ip_hl << 2));
904: inp = in_pcbhashlookup(&tcbtable,
905: ip->ip_dst, th->th_dport, ip->ip_src, th->th_sport);
906: if (inp) {
907: seq = ntohl(th->th_seq);
908: if (inp->inp_socket &&
909: (tp = intotcpcb(inp)) &&
910: SEQ_GEQ(seq, tp->snd_una) &&
911: SEQ_LT(seq, tp->snd_max))
912: notify(inp, errno);
913: } else if (syn_cache_count &&
914: (inetctlerrmap[cmd] == EHOSTUNREACH ||
915: inetctlerrmap[cmd] == ENETUNREACH ||
916: inetctlerrmap[cmd] == EHOSTDOWN)) {
917: struct sockaddr_in sin;
918:
919: bzero(&sin, sizeof(sin));
920: sin.sin_len = sizeof(sin);
921: sin.sin_family = AF_INET;
922: sin.sin_port = th->th_sport;
923: sin.sin_addr = ip->ip_src;
924: syn_cache_unreach((struct sockaddr *)&sin,
925: sa, th);
926: }
927: } else
928: in_pcbnotifyall(&tcbtable, sa, errno, notify);
929:
930: return NULL;
931: }
932:
933:
934: #ifdef INET6
935: /*
936: * Path MTU Discovery handlers.
937: */
938: void
939: tcp6_mtudisc_callback(faddr)
940: struct in6_addr *faddr;
941: {
942: struct sockaddr_in6 sin6;
943:
944: bzero(&sin6, sizeof(sin6));
945: sin6.sin6_family = AF_INET6;
946: sin6.sin6_len = sizeof(struct sockaddr_in6);
947: sin6.sin6_addr = *faddr;
948: (void) in6_pcbnotify(&tcbtable, (struct sockaddr *)&sin6, 0,
949: (struct sockaddr *)&sa6_any, 0, PRC_MSGSIZE, NULL, tcp_mtudisc);
950: }
951: #endif /* INET6 */
952:
953: /*
954: * On receipt of path MTU corrections, flush old route and replace it
955: * with the new one. Retransmit all unacknowledged packets, to ensure
956: * that all packets will be received.
957: */
958: void
959: tcp_mtudisc(inp, errno)
960: struct inpcb *inp;
961: int errno;
962: {
963: struct tcpcb *tp = intotcpcb(inp);
964: struct rtentry *rt = in_pcbrtentry(inp);
965: int change = 0;
966:
967: if (tp != 0) {
968: int orig_maxseg = tp->t_maxseg;
969: if (rt != 0) {
970: /*
971: * If this was not a host route, remove and realloc.
972: */
973: if ((rt->rt_flags & RTF_HOST) == 0) {
974: in_rtchange(inp, errno);
975: if ((rt = in_pcbrtentry(inp)) == 0)
976: return;
977: }
978: if (orig_maxseg != tp->t_maxseg ||
979: (rt->rt_rmx.rmx_locks & RTV_MTU))
980: change = 1;
981: }
982: tcp_mss(tp, -1);
983:
984: /*
985: * Resend unacknowledged packets
986: */
987: tp->snd_nxt = tp->snd_una;
988: if (change || errno > 0)
989: tcp_output(tp);
990: }
991: }
992:
993: void
994: tcp_mtudisc_increase(inp, errno)
995: struct inpcb *inp;
996: int errno;
997: {
998: struct tcpcb *tp = intotcpcb(inp);
999: struct rtentry *rt = in_pcbrtentry(inp);
1000:
1001: if (tp != 0 && rt != 0) {
1002: /*
1003: * If this was a host route, remove and realloc.
1004: */
1005: if (rt->rt_flags & RTF_HOST)
1006: in_rtchange(inp, errno);
1007:
1008: /* also takes care of congestion window */
1009: tcp_mss(tp, -1);
1010: }
1011: }
1012:
1013: #define TCP_ISS_CONN_INC 4096
1014: int tcp_secret_init;
1015: u_char tcp_secret[16];
1016: MD5_CTX tcp_secret_ctx;
1017:
1018: void
1019: tcp_set_iss_tsm(struct tcpcb *tp)
1020: {
1021: MD5_CTX ctx;
1022: u_int32_t digest[4];
1023:
1024: if (tcp_secret_init == 0) {
1025: arc4random_bytes(tcp_secret, sizeof(tcp_secret));
1026: MD5Init(&tcp_secret_ctx);
1027: MD5Update(&tcp_secret_ctx, tcp_secret, sizeof(tcp_secret));
1028: tcp_secret_init = 1;
1029: }
1030: ctx = tcp_secret_ctx;
1031: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_lport, sizeof(u_short));
1032: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_fport, sizeof(u_short));
1033: if (tp->pf == AF_INET6) {
1034: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_laddr6,
1035: sizeof(struct in6_addr));
1036: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_faddr6,
1037: sizeof(struct in6_addr));
1038: } else {
1039: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_laddr,
1040: sizeof(struct in_addr));
1041: MD5Update(&ctx, (char *)&tp->t_inpcb->inp_faddr,
1042: sizeof(struct in_addr));
1043: }
1044: MD5Final((u_char *)digest, &ctx);
1045: tcp_iss += TCP_ISS_CONN_INC;
1046: tp->iss = digest[0] + tcp_iss;
1047: tp->ts_modulate = digest[1];
1048: }
1049:
1050: #ifdef TCP_SIGNATURE
1051: int
1052: tcp_signature_tdb_attach()
1053: {
1054: return (0);
1055: }
1056:
1057: int
1058: tcp_signature_tdb_init(tdbp, xsp, ii)
1059: struct tdb *tdbp;
1060: struct xformsw *xsp;
1061: struct ipsecinit *ii;
1062: {
1063: if ((ii->ii_authkeylen < 1) || (ii->ii_authkeylen > 80))
1064: return (EINVAL);
1065:
1066: tdbp->tdb_amxkey = malloc(ii->ii_authkeylen, M_XDATA, M_DONTWAIT);
1067: if (tdbp->tdb_amxkey == NULL)
1068: return (ENOMEM);
1069: bcopy(ii->ii_authkey, tdbp->tdb_amxkey, ii->ii_authkeylen);
1070: tdbp->tdb_amxkeylen = ii->ii_authkeylen;
1071:
1072: return (0);
1073: }
1074:
1075: int
1076: tcp_signature_tdb_zeroize(tdbp)
1077: struct tdb *tdbp;
1078: {
1079: if (tdbp->tdb_amxkey) {
1080: bzero(tdbp->tdb_amxkey, tdbp->tdb_amxkeylen);
1081: free(tdbp->tdb_amxkey, M_XDATA);
1082: tdbp->tdb_amxkey = NULL;
1083: }
1084:
1085: return (0);
1086: }
1087:
1088: int
1089: tcp_signature_tdb_input(m, tdbp, skip, protoff)
1090: struct mbuf *m;
1091: struct tdb *tdbp;
1092: int skip, protoff;
1093: {
1094: return (0);
1095: }
1096:
1097: int
1098: tcp_signature_tdb_output(m, tdbp, mp, skip, protoff)
1099: struct mbuf *m;
1100: struct tdb *tdbp;
1101: struct mbuf **mp;
1102: int skip, protoff;
1103: {
1104: return (EINVAL);
1105: }
1106:
1107: int
1108: tcp_signature_apply(fstate, data, len)
1109: caddr_t fstate;
1110: caddr_t data;
1111: unsigned int len;
1112: {
1113: MD5Update((MD5_CTX *)fstate, (char *)data, len);
1114: return 0;
1115: }
1116:
1117: int
1118: tcp_signature(struct tdb *tdb, int af, struct mbuf *m, struct tcphdr *th,
1119: int iphlen, int doswap, char *sig)
1120: {
1121: MD5_CTX ctx;
1122: int len;
1123: struct tcphdr th0;
1124:
1125: MD5Init(&ctx);
1126:
1127: switch(af) {
1128: case 0:
1129: #ifdef INET
1130: case AF_INET: {
1131: struct ippseudo ippseudo;
1132: struct ip *ip;
1133:
1134: ip = mtod(m, struct ip *);
1135:
1136: ippseudo.ippseudo_src = ip->ip_src;
1137: ippseudo.ippseudo_dst = ip->ip_dst;
1138: ippseudo.ippseudo_pad = 0;
1139: ippseudo.ippseudo_p = IPPROTO_TCP;
1140: ippseudo.ippseudo_len = htons(m->m_pkthdr.len - iphlen);
1141:
1142: MD5Update(&ctx, (char *)&ippseudo,
1143: sizeof(struct ippseudo));
1144: break;
1145: }
1146: #endif
1147: #ifdef INET6
1148: case AF_INET6: {
1149: struct ip6_hdr_pseudo ip6pseudo;
1150: struct ip6_hdr *ip6;
1151:
1152: ip6 = mtod(m, struct ip6_hdr *);
1153: bzero(&ip6pseudo, sizeof(ip6pseudo));
1154: ip6pseudo.ip6ph_src = ip6->ip6_src;
1155: ip6pseudo.ip6ph_dst = ip6->ip6_dst;
1156: in6_clearscope(&ip6pseudo.ip6ph_src);
1157: in6_clearscope(&ip6pseudo.ip6ph_dst);
1158: ip6pseudo.ip6ph_nxt = IPPROTO_TCP;
1159: ip6pseudo.ip6ph_len = htonl(m->m_pkthdr.len - iphlen);
1160:
1161: MD5Update(&ctx, (char *)&ip6pseudo,
1162: sizeof(ip6pseudo));
1163: break;
1164: }
1165: #endif
1166: }
1167:
1168: th0 = *th;
1169: th0.th_sum = 0;
1170:
1171: if (doswap) {
1172: HTONL(th0.th_seq);
1173: HTONL(th0.th_ack);
1174: HTONS(th0.th_win);
1175: HTONS(th0.th_urp);
1176: }
1177: MD5Update(&ctx, (char *)&th0, sizeof(th0));
1178:
1179: len = m->m_pkthdr.len - iphlen - th->th_off * sizeof(uint32_t);
1180:
1181: if (len > 0 &&
1182: m_apply(m, iphlen + th->th_off * sizeof(uint32_t), len,
1183: tcp_signature_apply, (caddr_t)&ctx))
1184: return (-1);
1185:
1186: MD5Update(&ctx, tdb->tdb_amxkey, tdb->tdb_amxkeylen);
1187: MD5Final(sig, &ctx);
1188:
1189: return (0);
1190: }
1191: #endif /* TCP_SIGNATURE */
1192:
1193: #define TCP_RNDISS_ROUNDS 16
1194: #define TCP_RNDISS_OUT 7200
1195: #define TCP_RNDISS_MAX 30000
1196:
1197: u_int8_t tcp_rndiss_sbox[128];
1198: u_int16_t tcp_rndiss_msb;
1199: u_int16_t tcp_rndiss_cnt;
1200: long tcp_rndiss_reseed;
1201:
1202: u_int16_t
1203: tcp_rndiss_encrypt(val)
1204: u_int16_t val;
1205: {
1206: u_int16_t sum = 0, i;
1207:
1208: for (i = 0; i < TCP_RNDISS_ROUNDS; i++) {
1209: sum += 0x79b9;
1210: val ^= ((u_int16_t)tcp_rndiss_sbox[(val^sum) & 0x7f]) << 7;
1211: val = ((val & 0xff) << 7) | (val >> 8);
1212: }
1213:
1214: return val;
1215: }
1216:
1217: void
1218: tcp_rndiss_init()
1219: {
1220: get_random_bytes(tcp_rndiss_sbox, sizeof(tcp_rndiss_sbox));
1221:
1222: tcp_rndiss_reseed = time_second + TCP_RNDISS_OUT;
1223: tcp_rndiss_msb = tcp_rndiss_msb == 0x8000 ? 0 : 0x8000;
1224: tcp_rndiss_cnt = 0;
1225: }
1226:
1227: tcp_seq
1228: tcp_rndiss_next()
1229: {
1230: if (tcp_rndiss_cnt >= TCP_RNDISS_MAX ||
1231: time_second > tcp_rndiss_reseed)
1232: tcp_rndiss_init();
1233:
1234: /* (arc4random() & 0x7fff) ensures a 32768 byte gap between ISS */
1235: return ((tcp_rndiss_encrypt(tcp_rndiss_cnt++) | tcp_rndiss_msb) <<16) |
1236: (arc4random() & 0x7fff);
1237: }
1238:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to tcp_subr.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / netinet