xref: /freebsd/sys/netinet/tcp_timewait.c (revision 70fe064ad7cab6c0444b91622f60ec6a462f308a)
1 /*
2  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *	This product includes software developed by the University of
16  *	California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *	@(#)tcp_subr.c	8.2 (Berkeley) 5/24/95
34  * $FreeBSD$
35  */
36 
37 #include "opt_compat.h"
38 #include "opt_inet6.h"
39 #include "opt_ipsec.h"
40 #include "opt_tcpdebug.h"
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/callout.h>
45 #include <sys/kernel.h>
46 #include <sys/sysctl.h>
47 #include <sys/malloc.h>
48 #include <sys/mbuf.h>
49 #ifdef INET6
50 #include <sys/domain.h>
51 #endif
52 #include <sys/proc.h>
53 #include <sys/socket.h>
54 #include <sys/socketvar.h>
55 #include <sys/protosw.h>
56 #include <sys/random.h>
57 
58 #include <vm/vm_zone.h>
59 
60 #include <net/route.h>
61 #include <net/if.h>
62 
63 #define _IP_VHL
64 #include <netinet/in.h>
65 #include <netinet/in_systm.h>
66 #include <netinet/ip.h>
67 #ifdef INET6
68 #include <netinet/ip6.h>
69 #endif
70 #include <netinet/in_pcb.h>
71 #ifdef INET6
72 #include <netinet6/in6_pcb.h>
73 #endif
74 #include <netinet/in_var.h>
75 #include <netinet/ip_var.h>
76 #ifdef INET6
77 #include <netinet6/ip6_var.h>
78 #endif
79 #include <netinet/tcp.h>
80 #include <netinet/tcp_fsm.h>
81 #include <netinet/tcp_seq.h>
82 #include <netinet/tcp_timer.h>
83 #include <netinet/tcp_var.h>
84 #ifdef INET6
85 #include <netinet6/tcp6_var.h>
86 #endif
87 #include <netinet/tcpip.h>
88 #ifdef TCPDEBUG
89 #include <netinet/tcp_debug.h>
90 #endif
91 #include <netinet6/ip6protosw.h>
92 
93 #ifdef IPSEC
94 #include <netinet6/ipsec.h>
95 #ifdef INET6
96 #include <netinet6/ipsec6.h>
97 #endif
98 #endif /*IPSEC*/
99 
100 #include <machine/in_cksum.h>
101 #include <sys/md5.h>
102 
103 int 	tcp_mssdflt = TCP_MSS;
104 SYSCTL_INT(_net_inet_tcp, TCPCTL_MSSDFLT, mssdflt, CTLFLAG_RW,
105     &tcp_mssdflt , 0, "Default TCP Maximum Segment Size");
106 
107 #ifdef INET6
108 int	tcp_v6mssdflt = TCP6_MSS;
109 SYSCTL_INT(_net_inet_tcp, TCPCTL_V6MSSDFLT, v6mssdflt,
110 	CTLFLAG_RW, &tcp_v6mssdflt , 0,
111 	"Default TCP Maximum Segment Size for IPv6");
112 #endif
113 
114 #if 0
115 static int 	tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;
116 SYSCTL_INT(_net_inet_tcp, TCPCTL_RTTDFLT, rttdflt, CTLFLAG_RW,
117     &tcp_rttdflt , 0, "Default maximum TCP Round Trip Time");
118 #endif
119 
120 int	tcp_do_rfc1323 = 1;
121 SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1323, rfc1323, CTLFLAG_RW,
122     &tcp_do_rfc1323 , 0, "Enable rfc1323 (high performance TCP) extensions");
123 
124 int	tcp_do_rfc1644 = 0;
125 SYSCTL_INT(_net_inet_tcp, TCPCTL_DO_RFC1644, rfc1644, CTLFLAG_RW,
126     &tcp_do_rfc1644 , 0, "Enable rfc1644 (TTCP) extensions");
127 
128 static int	tcp_tcbhashsize = 0;
129 SYSCTL_INT(_net_inet_tcp, OID_AUTO, tcbhashsize, CTLFLAG_RD,
130      &tcp_tcbhashsize, 0, "Size of TCP control-block hashtable");
131 
132 static int	do_tcpdrain = 1;
133 SYSCTL_INT(_net_inet_tcp, OID_AUTO, do_tcpdrain, CTLFLAG_RW, &do_tcpdrain, 0,
134      "Enable tcp_drain routine for extra help when low on mbufs");
135 
136 SYSCTL_INT(_net_inet_tcp, OID_AUTO, pcbcount, CTLFLAG_RD,
137     &tcbinfo.ipi_count, 0, "Number of active PCBs");
138 
139 static int	icmp_may_rst = 1;
140 SYSCTL_INT(_net_inet_tcp, OID_AUTO, icmp_may_rst, CTLFLAG_RW, &icmp_may_rst, 0,
141     "Certain ICMP unreachable messages may abort connections in SYN_SENT");
142 
143 static int	tcp_strict_rfc1948 = 0;
144 SYSCTL_INT(_net_inet_tcp, OID_AUTO, strict_rfc1948, CTLFLAG_RW,
145     &tcp_strict_rfc1948, 0, "Determines if RFC1948 is followed exactly");
146 
147 static int	tcp_isn_reseed_interval = 0;
148 SYSCTL_INT(_net_inet_tcp, OID_AUTO, isn_reseed_interval, CTLFLAG_RW,
149     &tcp_isn_reseed_interval, 0, "Seconds between reseeding of ISN secret");
150 
151 static void	tcp_cleartaocache __P((void));
152 static void	tcp_notify __P((struct inpcb *, int));
153 
154 /*
155  * Target size of TCP PCB hash tables. Must be a power of two.
156  *
157  * Note that this can be overridden by the kernel environment
158  * variable net.inet.tcp.tcbhashsize
159  */
160 #ifndef TCBHASHSIZE
161 #define TCBHASHSIZE	512
162 #endif
163 
164 /*
165  * This is the actual shape of what we allocate using the zone
166  * allocator.  Doing it this way allows us to protect both structures
167  * using the same generation count, and also eliminates the overhead
168  * of allocating tcpcbs separately.  By hiding the structure here,
169  * we avoid changing most of the rest of the code (although it needs
170  * to be changed, eventually, for greater efficiency).
171  */
172 #define	ALIGNMENT	32
173 #define	ALIGNM1		(ALIGNMENT - 1)
174 struct	inp_tp {
175 	union {
176 		struct	inpcb inp;
177 		char	align[(sizeof(struct inpcb) + ALIGNM1) & ~ALIGNM1];
178 	} inp_tp_u;
179 	struct	tcpcb tcb;
180 	struct	callout inp_tp_rexmt, inp_tp_persist, inp_tp_keep, inp_tp_2msl;
181 	struct	callout inp_tp_delack;
182 };
183 #undef ALIGNMENT
184 #undef ALIGNM1
185 
186 /*
187  * Tcp initialization
188  */
189 void
190 tcp_init()
191 {
192 	int hashsize = TCBHASHSIZE;
193 
194 	tcp_ccgen = 1;
195 	tcp_cleartaocache();
196 
197 	tcp_delacktime = TCPTV_DELACK;
198 	tcp_keepinit = TCPTV_KEEP_INIT;
199 	tcp_keepidle = TCPTV_KEEP_IDLE;
200 	tcp_keepintvl = TCPTV_KEEPINTVL;
201 	tcp_maxpersistidle = TCPTV_KEEP_IDLE;
202 	tcp_msl = TCPTV_MSL;
203 
204 	LIST_INIT(&tcb);
205 	tcbinfo.listhead = &tcb;
206 	TUNABLE_INT_FETCH("net.inet.tcp.tcbhashsize", &hashsize);
207 	if (!powerof2(hashsize)) {
208 		printf("WARNING: TCB hash size not a power of 2\n");
209 		hashsize = 512; /* safe default */
210 	}
211 	tcp_tcbhashsize = hashsize;
212 	tcbinfo.hashbase = hashinit(hashsize, M_PCB, &tcbinfo.hashmask);
213 	tcbinfo.porthashbase = hashinit(hashsize, M_PCB,
214 					&tcbinfo.porthashmask);
215 	tcbinfo.ipi_zone = zinit("tcpcb", sizeof(struct inp_tp), maxsockets,
216 				 ZONE_INTERRUPT, 0);
217 #ifdef INET6
218 #define TCP_MINPROTOHDR (sizeof(struct ip6_hdr) + sizeof(struct tcphdr))
219 #else /* INET6 */
220 #define TCP_MINPROTOHDR (sizeof(struct tcpiphdr))
221 #endif /* INET6 */
222 	if (max_protohdr < TCP_MINPROTOHDR)
223 		max_protohdr = TCP_MINPROTOHDR;
224 	if (max_linkhdr + TCP_MINPROTOHDR > MHLEN)
225 		panic("tcp_init");
226 #undef TCP_MINPROTOHDR
227 
228 	syncache_init();
229 }
230 
231 /*
232  * Fill in the IP and TCP headers for an outgoing packet, given the tcpcb.
233  * tcp_template used to store this data in mbufs, but we now recopy it out
234  * of the tcpcb each time to conserve mbufs.
235  */
236 void
237 tcp_fillheaders(tp, ip_ptr, tcp_ptr)
238 	struct tcpcb *tp;
239 	void *ip_ptr;
240 	void *tcp_ptr;
241 {
242 	struct inpcb *inp = tp->t_inpcb;
243 	struct tcphdr *tcp_hdr = (struct tcphdr *)tcp_ptr;
244 
245 #ifdef INET6
246 	if ((inp->inp_vflag & INP_IPV6) != 0) {
247 		struct ip6_hdr *ip6;
248 
249 		ip6 = (struct ip6_hdr *)ip_ptr;
250 		ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |
251 			(inp->in6p_flowinfo & IPV6_FLOWINFO_MASK);
252 		ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |
253 			(IPV6_VERSION & IPV6_VERSION_MASK);
254 		ip6->ip6_nxt = IPPROTO_TCP;
255 		ip6->ip6_plen = sizeof(struct tcphdr);
256 		ip6->ip6_src = inp->in6p_laddr;
257 		ip6->ip6_dst = inp->in6p_faddr;
258 		tcp_hdr->th_sum = 0;
259 	} else
260 #endif
261 	{
262 	struct ip *ip = (struct ip *) ip_ptr;
263 
264 	ip->ip_vhl = IP_VHL_BORING;
265 	ip->ip_tos = 0;
266 	ip->ip_len = 0;
267 	ip->ip_id = 0;
268 	ip->ip_off = 0;
269 	ip->ip_ttl = 0;
270 	ip->ip_sum = 0;
271 	ip->ip_p = IPPROTO_TCP;
272 	ip->ip_src = inp->inp_laddr;
273 	ip->ip_dst = inp->inp_faddr;
274 	tcp_hdr->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
275 		htons(sizeof(struct tcphdr) + IPPROTO_TCP));
276 	}
277 
278 	tcp_hdr->th_sport = inp->inp_lport;
279 	tcp_hdr->th_dport = inp->inp_fport;
280 	tcp_hdr->th_seq = 0;
281 	tcp_hdr->th_ack = 0;
282 	tcp_hdr->th_x2 = 0;
283 	tcp_hdr->th_off = 5;
284 	tcp_hdr->th_flags = 0;
285 	tcp_hdr->th_win = 0;
286 	tcp_hdr->th_urp = 0;
287 }
288 
289 /*
290  * Create template to be used to send tcp packets on a connection.
291  * Allocates an mbuf and fills in a skeletal tcp/ip header.  The only
292  * use for this function is in keepalives, which use tcp_respond.
293  */
294 struct tcptemp *
295 tcp_maketemplate(tp)
296 	struct tcpcb *tp;
297 {
298 	struct mbuf *m;
299 	struct tcptemp *n;
300 
301 	m = m_get(M_DONTWAIT, MT_HEADER);
302 	if (m == NULL)
303 		return (0);
304 	m->m_len = sizeof(struct tcptemp);
305 	n = mtod(m, struct tcptemp *);
306 
307 	tcp_fillheaders(tp, (void *)&n->tt_ipgen, (void *)&n->tt_t);
308 	return (n);
309 }
310 
311 /*
312  * Send a single message to the TCP at address specified by
313  * the given TCP/IP header.  If m == 0, then we make a copy
314  * of the tcpiphdr at ti and send directly to the addressed host.
315  * This is used to force keep alive messages out using the TCP
316  * template for a connection.  If flags are given then we send
317  * a message back to the TCP which originated the * segment ti,
318  * and discard the mbuf containing it and any other attached mbufs.
319  *
320  * In any case the ack and sequence number of the transmitted
321  * segment are as specified by the parameters.
322  *
323  * NOTE: If m != NULL, then ti must point to *inside* the mbuf.
324  */
325 void
326 tcp_respond(tp, ipgen, th, m, ack, seq, flags)
327 	struct tcpcb *tp;
328 	void *ipgen;
329 	register struct tcphdr *th;
330 	register struct mbuf *m;
331 	tcp_seq ack, seq;
332 	int flags;
333 {
334 	register int tlen;
335 	int win = 0;
336 	struct route *ro = 0;
337 	struct route sro;
338 	struct ip *ip;
339 	struct tcphdr *nth;
340 #ifdef INET6
341 	struct route_in6 *ro6 = 0;
342 	struct route_in6 sro6;
343 	struct ip6_hdr *ip6;
344 	int isipv6;
345 #endif /* INET6 */
346 	int ipflags = 0;
347 
348 #ifdef INET6
349 	isipv6 = IP_VHL_V(((struct ip *)ipgen)->ip_vhl) == 6;
350 	ip6 = ipgen;
351 #endif /* INET6 */
352 	ip = ipgen;
353 
354 	if (tp) {
355 		if (!(flags & TH_RST)) {
356 			win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
357 			if (win > (long)TCP_MAXWIN << tp->rcv_scale)
358 				win = (long)TCP_MAXWIN << tp->rcv_scale;
359 		}
360 #ifdef INET6
361 		if (isipv6)
362 			ro6 = &tp->t_inpcb->in6p_route;
363 		else
364 #endif /* INET6 */
365 		ro = &tp->t_inpcb->inp_route;
366 	} else {
367 #ifdef INET6
368 		if (isipv6) {
369 			ro6 = &sro6;
370 			bzero(ro6, sizeof *ro6);
371 		} else
372 #endif /* INET6 */
373 	      {
374 		ro = &sro;
375 		bzero(ro, sizeof *ro);
376 	      }
377 	}
378 	if (m == 0) {
379 		m = m_gethdr(M_DONTWAIT, MT_HEADER);
380 		if (m == NULL)
381 			return;
382 		tlen = 0;
383 		m->m_data += max_linkhdr;
384 #ifdef INET6
385 		if (isipv6) {
386 			bcopy((caddr_t)ip6, mtod(m, caddr_t),
387 			      sizeof(struct ip6_hdr));
388 			ip6 = mtod(m, struct ip6_hdr *);
389 			nth = (struct tcphdr *)(ip6 + 1);
390 		} else
391 #endif /* INET6 */
392 	      {
393 		bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));
394 		ip = mtod(m, struct ip *);
395 		nth = (struct tcphdr *)(ip + 1);
396 	      }
397 		bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));
398 		flags = TH_ACK;
399 	} else {
400 		m_freem(m->m_next);
401 		m->m_next = 0;
402 		m->m_data = (caddr_t)ipgen;
403 		/* m_len is set later */
404 		tlen = 0;
405 #define xchg(a,b,type) { type t; t=a; a=b; b=t; }
406 #ifdef INET6
407 		if (isipv6) {
408 			xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);
409 			nth = (struct tcphdr *)(ip6 + 1);
410 		} else
411 #endif /* INET6 */
412 	      {
413 		xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, n_long);
414 		nth = (struct tcphdr *)(ip + 1);
415 	      }
416 		if (th != nth) {
417 			/*
418 			 * this is usually a case when an extension header
419 			 * exists between the IPv6 header and the
420 			 * TCP header.
421 			 */
422 			nth->th_sport = th->th_sport;
423 			nth->th_dport = th->th_dport;
424 		}
425 		xchg(nth->th_dport, nth->th_sport, n_short);
426 #undef xchg
427 	}
428 #ifdef INET6
429 	if (isipv6) {
430 		ip6->ip6_plen = htons((u_short)(sizeof (struct tcphdr) +
431 						tlen));
432 		tlen += sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
433 	} else
434 #endif
435       {
436 	tlen += sizeof (struct tcpiphdr);
437 	ip->ip_len = tlen;
438 	ip->ip_ttl = ip_defttl;
439       }
440 	m->m_len = tlen;
441 	m->m_pkthdr.len = tlen;
442 	m->m_pkthdr.rcvif = (struct ifnet *) 0;
443 	nth->th_seq = htonl(seq);
444 	nth->th_ack = htonl(ack);
445 	nth->th_x2 = 0;
446 	nth->th_off = sizeof (struct tcphdr) >> 2;
447 	nth->th_flags = flags;
448 	if (tp)
449 		nth->th_win = htons((u_short) (win >> tp->rcv_scale));
450 	else
451 		nth->th_win = htons((u_short)win);
452 	nth->th_urp = 0;
453 #ifdef INET6
454 	if (isipv6) {
455 		nth->th_sum = 0;
456 		nth->th_sum = in6_cksum(m, IPPROTO_TCP,
457 					sizeof(struct ip6_hdr),
458 					tlen - sizeof(struct ip6_hdr));
459 		ip6->ip6_hlim = in6_selecthlim(tp ? tp->t_inpcb : NULL,
460 					       ro6 && ro6->ro_rt ?
461 					       ro6->ro_rt->rt_ifp :
462 					       NULL);
463 	} else
464 #endif /* INET6 */
465       {
466         nth->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,
467 	    htons((u_short)(tlen - sizeof(struct ip) + ip->ip_p)));
468         m->m_pkthdr.csum_flags = CSUM_TCP;
469         m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
470       }
471 #ifdef TCPDEBUG
472 	if (tp == NULL || (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
473 		tcp_trace(TA_OUTPUT, 0, tp, mtod(m, void *), th, 0);
474 #endif
475 #ifdef IPSEC
476 	if (ipsec_setsocket(m, tp ? tp->t_inpcb->inp_socket : NULL) != 0) {
477 		m_freem(m);
478 		return;
479 	}
480 #endif
481 #ifdef INET6
482 	if (isipv6) {
483 		(void)ip6_output(m, NULL, ro6, ipflags, NULL, NULL);
484 		if (ro6 == &sro6 && ro6->ro_rt) {
485 			RTFREE(ro6->ro_rt);
486 			ro6->ro_rt = NULL;
487 		}
488 	} else
489 #endif /* INET6 */
490       {
491 	(void) ip_output(m, NULL, ro, ipflags, NULL);
492 	if (ro == &sro && ro->ro_rt) {
493 		RTFREE(ro->ro_rt);
494 		ro->ro_rt = NULL;
495 	}
496       }
497 }
498 
499 /*
500  * Create a new TCP control block, making an
501  * empty reassembly queue and hooking it to the argument
502  * protocol control block.  The `inp' parameter must have
503  * come from the zone allocator set up in tcp_init().
504  */
505 struct tcpcb *
506 tcp_newtcpcb(inp)
507 	struct inpcb *inp;
508 {
509 	struct inp_tp *it;
510 	register struct tcpcb *tp;
511 #ifdef INET6
512 	int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
513 #endif /* INET6 */
514 
515 	it = (struct inp_tp *)inp;
516 	tp = &it->tcb;
517 	bzero((char *) tp, sizeof(struct tcpcb));
518 	LIST_INIT(&tp->t_segq);
519 	tp->t_maxseg = tp->t_maxopd =
520 #ifdef INET6
521 		isipv6 ? tcp_v6mssdflt :
522 #endif /* INET6 */
523 		tcp_mssdflt;
524 
525 	/* Set up our timeouts. */
526 	callout_init(tp->tt_rexmt = &it->inp_tp_rexmt, 0);
527 	callout_init(tp->tt_persist = &it->inp_tp_persist, 0);
528 	callout_init(tp->tt_keep = &it->inp_tp_keep, 0);
529 	callout_init(tp->tt_2msl = &it->inp_tp_2msl, 0);
530 	callout_init(tp->tt_delack = &it->inp_tp_delack, 0);
531 
532 	if (tcp_do_rfc1323)
533 		tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP);
534 	if (tcp_do_rfc1644)
535 		tp->t_flags |= TF_REQ_CC;
536 	tp->t_inpcb = inp;	/* XXX */
537 	/*
538 	 * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no
539 	 * rtt estimate.  Set rttvar so that srtt + 4 * rttvar gives
540 	 * reasonable initial retransmit time.
541 	 */
542 	tp->t_srtt = TCPTV_SRTTBASE;
543 	tp->t_rttvar = ((TCPTV_RTOBASE - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4;
544 	tp->t_rttmin = TCPTV_MIN;
545 	tp->t_rxtcur = TCPTV_RTOBASE;
546 	tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;
547 	tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;
548 	tp->t_rcvtime = ticks;
549         /*
550 	 * IPv4 TTL initialization is necessary for an IPv6 socket as well,
551 	 * because the socket may be bound to an IPv6 wildcard address,
552 	 * which may match an IPv4-mapped IPv6 address.
553 	 */
554 	inp->inp_ip_ttl = ip_defttl;
555 	inp->inp_ppcb = (caddr_t)tp;
556 	return (tp);		/* XXX */
557 }
558 
559 /*
560  * Drop a TCP connection, reporting
561  * the specified error.  If connection is synchronized,
562  * then send a RST to peer.
563  */
564 struct tcpcb *
565 tcp_drop(tp, errno)
566 	register struct tcpcb *tp;
567 	int errno;
568 {
569 	struct socket *so = tp->t_inpcb->inp_socket;
570 
571 	if (TCPS_HAVERCVDSYN(tp->t_state)) {
572 		tp->t_state = TCPS_CLOSED;
573 		(void) tcp_output(tp);
574 		tcpstat.tcps_drops++;
575 	} else
576 		tcpstat.tcps_conndrops++;
577 	if (errno == ETIMEDOUT && tp->t_softerror)
578 		errno = tp->t_softerror;
579 	so->so_error = errno;
580 	return (tcp_close(tp));
581 }
582 
583 /*
584  * Close a TCP control block:
585  *	discard all space held by the tcp
586  *	discard internet protocol block
587  *	wake up any sleepers
588  */
589 struct tcpcb *
590 tcp_close(tp)
591 	register struct tcpcb *tp;
592 {
593 	register struct tseg_qent *q;
594 	struct inpcb *inp = tp->t_inpcb;
595 	struct socket *so = inp->inp_socket;
596 #ifdef INET6
597 	int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;
598 #endif /* INET6 */
599 	register struct rtentry *rt;
600 	int dosavessthresh;
601 
602 	/*
603 	 * Make sure that all of our timers are stopped before we
604 	 * delete the PCB.
605 	 */
606 	callout_stop(tp->tt_rexmt);
607 	callout_stop(tp->tt_persist);
608 	callout_stop(tp->tt_keep);
609 	callout_stop(tp->tt_2msl);
610 	callout_stop(tp->tt_delack);
611 
612 	/*
613 	 * If we got enough samples through the srtt filter,
614 	 * save the rtt and rttvar in the routing entry.
615 	 * 'Enough' is arbitrarily defined as the 16 samples.
616 	 * 16 samples is enough for the srtt filter to converge
617 	 * to within 5% of the correct value; fewer samples and
618 	 * we could save a very bogus rtt.
619 	 *
620 	 * Don't update the default route's characteristics and don't
621 	 * update anything that the user "locked".
622 	 */
623 	if (tp->t_rttupdated >= 16) {
624 		register u_long i = 0;
625 #ifdef INET6
626 		if (isipv6) {
627 			struct sockaddr_in6 *sin6;
628 
629 			if ((rt = inp->in6p_route.ro_rt) == NULL)
630 				goto no_valid_rt;
631 			sin6 = (struct sockaddr_in6 *)rt_key(rt);
632 			if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
633 				goto no_valid_rt;
634 		}
635 		else
636 #endif /* INET6 */
637 		if ((rt = inp->inp_route.ro_rt) == NULL ||
638 		    ((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr
639 		    == INADDR_ANY)
640 			goto no_valid_rt;
641 
642 		if ((rt->rt_rmx.rmx_locks & RTV_RTT) == 0) {
643 			i = tp->t_srtt *
644 			    (RTM_RTTUNIT / (hz * TCP_RTT_SCALE));
645 			if (rt->rt_rmx.rmx_rtt && i)
646 				/*
647 				 * filter this update to half the old & half
648 				 * the new values, converting scale.
649 				 * See route.h and tcp_var.h for a
650 				 * description of the scaling constants.
651 				 */
652 				rt->rt_rmx.rmx_rtt =
653 				    (rt->rt_rmx.rmx_rtt + i) / 2;
654 			else
655 				rt->rt_rmx.rmx_rtt = i;
656 			tcpstat.tcps_cachedrtt++;
657 		}
658 		if ((rt->rt_rmx.rmx_locks & RTV_RTTVAR) == 0) {
659 			i = tp->t_rttvar *
660 			    (RTM_RTTUNIT / (hz * TCP_RTTVAR_SCALE));
661 			if (rt->rt_rmx.rmx_rttvar && i)
662 				rt->rt_rmx.rmx_rttvar =
663 				    (rt->rt_rmx.rmx_rttvar + i) / 2;
664 			else
665 				rt->rt_rmx.rmx_rttvar = i;
666 			tcpstat.tcps_cachedrttvar++;
667 		}
668 		/*
669 		 * The old comment here said:
670 		 * update the pipelimit (ssthresh) if it has been updated
671 		 * already or if a pipesize was specified & the threshhold
672 		 * got below half the pipesize.  I.e., wait for bad news
673 		 * before we start updating, then update on both good
674 		 * and bad news.
675 		 *
676 		 * But we want to save the ssthresh even if no pipesize is
677 		 * specified explicitly in the route, because such
678 		 * connections still have an implicit pipesize specified
679 		 * by the global tcp_sendspace.  In the absence of a reliable
680 		 * way to calculate the pipesize, it will have to do.
681 		 */
682 		i = tp->snd_ssthresh;
683 		if (rt->rt_rmx.rmx_sendpipe != 0)
684 			dosavessthresh = (i < rt->rt_rmx.rmx_sendpipe / 2);
685 		else
686 			dosavessthresh = (i < so->so_snd.sb_hiwat / 2);
687 		if (((rt->rt_rmx.rmx_locks & RTV_SSTHRESH) == 0 &&
688 		     i != 0 && rt->rt_rmx.rmx_ssthresh != 0)
689 		    || dosavessthresh) {
690 			/*
691 			 * convert the limit from user data bytes to
692 			 * packets then to packet data bytes.
693 			 */
694 			i = (i + tp->t_maxseg / 2) / tp->t_maxseg;
695 			if (i < 2)
696 				i = 2;
697 			i *= (u_long)(tp->t_maxseg +
698 #ifdef INET6
699 				      (isipv6 ? sizeof (struct ip6_hdr) +
700 					       sizeof (struct tcphdr) :
701 #endif
702 				       sizeof (struct tcpiphdr)
703 #ifdef INET6
704 				       )
705 #endif
706 				      );
707 			if (rt->rt_rmx.rmx_ssthresh)
708 				rt->rt_rmx.rmx_ssthresh =
709 				    (rt->rt_rmx.rmx_ssthresh + i) / 2;
710 			else
711 				rt->rt_rmx.rmx_ssthresh = i;
712 			tcpstat.tcps_cachedssthresh++;
713 		}
714 	}
715     no_valid_rt:
716 	/* free the reassembly queue, if any */
717 	while((q = LIST_FIRST(&tp->t_segq)) != NULL) {
718 		LIST_REMOVE(q, tqe_q);
719 		m_freem(q->tqe_m);
720 		FREE(q, M_TSEGQ);
721 	}
722 	inp->inp_ppcb = NULL;
723 	soisdisconnected(so);
724 #ifdef INET6
725 	if (INP_CHECK_SOCKAF(so, AF_INET6))
726 		in6_pcbdetach(inp);
727 	else
728 #endif /* INET6 */
729 	in_pcbdetach(inp);
730 	tcpstat.tcps_closed++;
731 	return ((struct tcpcb *)0);
732 }
733 
734 void
735 tcp_drain()
736 {
737 	if (do_tcpdrain)
738 	{
739 		struct inpcb *inpb;
740 		struct tcpcb *tcpb;
741 		struct tseg_qent *te;
742 
743 	/*
744 	 * Walk the tcpbs, if existing, and flush the reassembly queue,
745 	 * if there is one...
746 	 * XXX: The "Net/3" implementation doesn't imply that the TCP
747 	 *      reassembly queue should be flushed, but in a situation
748 	 * 	where we're really low on mbufs, this is potentially
749 	 *  	usefull.
750 	 */
751 		LIST_FOREACH(inpb, tcbinfo.listhead, inp_list) {
752 			if ((tcpb = intotcpcb(inpb))) {
753 				while ((te = LIST_FIRST(&tcpb->t_segq))
754 			            != NULL) {
755 					LIST_REMOVE(te, tqe_q);
756 					m_freem(te->tqe_m);
757 					FREE(te, M_TSEGQ);
758 				}
759 			}
760 		}
761 	}
762 }
763 
764 /*
765  * Notify a tcp user of an asynchronous error;
766  * store error as soft error, but wake up user
767  * (for now, won't do anything until can select for soft error).
768  *
769  * Do not wake up user since there currently is no mechanism for
770  * reporting soft errors (yet - a kqueue filter may be added).
771  */
772 static void
773 tcp_notify(inp, error)
774 	struct inpcb *inp;
775 	int error;
776 {
777 	struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
778 
779 	/*
780 	 * Ignore some errors if we are hooked up.
781 	 * If connection hasn't completed, has retransmitted several times,
782 	 * and receives a second error, give up now.  This is better
783 	 * than waiting a long time to establish a connection that
784 	 * can never complete.
785 	 */
786 	if (tp->t_state == TCPS_ESTABLISHED &&
787 	     (error == EHOSTUNREACH || error == ENETUNREACH ||
788 	      error == EHOSTDOWN)) {
789 		return;
790 	} else if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift > 3 &&
791 	    tp->t_softerror)
792 		tcp_drop(tp, error);
793 	else
794 		tp->t_softerror = error;
795 #if 0
796 	wakeup((caddr_t) &so->so_timeo);
797 	sorwakeup(so);
798 	sowwakeup(so);
799 #endif
800 }
801 
802 static int
803 tcp_pcblist(SYSCTL_HANDLER_ARGS)
804 {
805 	int error, i, n, s;
806 	struct inpcb *inp, **inp_list;
807 	inp_gen_t gencnt;
808 	struct xinpgen xig;
809 
810 	/*
811 	 * The process of preparing the TCB list is too time-consuming and
812 	 * resource-intensive to repeat twice on every request.
813 	 */
814 	if (req->oldptr == 0) {
815 		n = tcbinfo.ipi_count;
816 		req->oldidx = 2 * (sizeof xig)
817 			+ (n + n/8) * sizeof(struct xtcpcb);
818 		return 0;
819 	}
820 
821 	if (req->newptr != 0)
822 		return EPERM;
823 
824 	/*
825 	 * OK, now we're committed to doing something.
826 	 */
827 	s = splnet();
828 	gencnt = tcbinfo.ipi_gencnt;
829 	n = tcbinfo.ipi_count;
830 	splx(s);
831 
832 	xig.xig_len = sizeof xig;
833 	xig.xig_count = n;
834 	xig.xig_gen = gencnt;
835 	xig.xig_sogen = so_gencnt;
836 	error = SYSCTL_OUT(req, &xig, sizeof xig);
837 	if (error)
838 		return error;
839 
840 	inp_list = malloc(n * sizeof *inp_list, M_TEMP, M_WAITOK);
841 	if (inp_list == 0)
842 		return ENOMEM;
843 
844 	s = splnet();
845 	for (inp = LIST_FIRST(tcbinfo.listhead), i = 0; inp && i < n;
846 	     inp = LIST_NEXT(inp, inp_list)) {
847 		if (inp->inp_gencnt <= gencnt) {
848 			if (cr_cansee(req->td->td_proc->p_ucred,
849 			    inp->inp_socket->so_cred))
850 				continue;
851 			inp_list[i++] = inp;
852 		}
853 	}
854 	splx(s);
855 	n = i;
856 
857 	error = 0;
858 	for (i = 0; i < n; i++) {
859 		inp = inp_list[i];
860 		if (inp->inp_gencnt <= gencnt) {
861 			struct xtcpcb xt;
862 			caddr_t inp_ppcb;
863 			xt.xt_len = sizeof xt;
864 			/* XXX should avoid extra copy */
865 			bcopy(inp, &xt.xt_inp, sizeof *inp);
866 			inp_ppcb = inp->inp_ppcb;
867 			if (inp_ppcb != NULL)
868 				bcopy(inp_ppcb, &xt.xt_tp, sizeof xt.xt_tp);
869 			else
870 				bzero((char *) &xt.xt_tp, sizeof xt.xt_tp);
871 			if (inp->inp_socket)
872 				sotoxsocket(inp->inp_socket, &xt.xt_socket);
873 			error = SYSCTL_OUT(req, &xt, sizeof xt);
874 		}
875 	}
876 	if (!error) {
877 		/*
878 		 * Give the user an updated idea of our state.
879 		 * If the generation differs from what we told
880 		 * her before, she knows that something happened
881 		 * while we were processing this request, and it
882 		 * might be necessary to retry.
883 		 */
884 		s = splnet();
885 		xig.xig_gen = tcbinfo.ipi_gencnt;
886 		xig.xig_sogen = so_gencnt;
887 		xig.xig_count = tcbinfo.ipi_count;
888 		splx(s);
889 		error = SYSCTL_OUT(req, &xig, sizeof xig);
890 	}
891 	free(inp_list, M_TEMP);
892 	return error;
893 }
894 
895 SYSCTL_PROC(_net_inet_tcp, TCPCTL_PCBLIST, pcblist, CTLFLAG_RD, 0, 0,
896 	    tcp_pcblist, "S,xtcpcb", "List of active TCP connections");
897 
898 static int
899 tcp_getcred(SYSCTL_HANDLER_ARGS)
900 {
901 	struct xucred xuc;
902 	struct sockaddr_in addrs[2];
903 	struct inpcb *inp;
904 	int error, s;
905 
906 	error = suser_xxx(0, req->td->td_proc, PRISON_ROOT);
907 	if (error)
908 		return (error);
909 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
910 	if (error)
911 		return (error);
912 	s = splnet();
913 	inp = in_pcblookup_hash(&tcbinfo, addrs[1].sin_addr, addrs[1].sin_port,
914 	    addrs[0].sin_addr, addrs[0].sin_port, 0, NULL);
915 	if (inp == NULL || inp->inp_socket == NULL) {
916 		error = ENOENT;
917 		goto out;
918 	}
919 	error = cr_cansee(req->td->td_proc->p_ucred, inp->inp_socket->so_cred);
920 	if (error)
921 		goto out;
922 	bzero(&xuc, sizeof(xuc));
923 	xuc.cr_uid = inp->inp_socket->so_cred->cr_uid;
924 	xuc.cr_ngroups = inp->inp_socket->so_cred->cr_ngroups;
925 	bcopy(inp->inp_socket->so_cred->cr_groups, xuc.cr_groups,
926 	    sizeof(xuc.cr_groups));
927 	error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
928 out:
929 	splx(s);
930 	return (error);
931 }
932 
933 SYSCTL_PROC(_net_inet_tcp, OID_AUTO, getcred,
934     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
935     tcp_getcred, "S,xucred", "Get the xucred of a TCP connection");
936 
937 #ifdef INET6
938 static int
939 tcp6_getcred(SYSCTL_HANDLER_ARGS)
940 {
941 	struct xucred xuc;
942 	struct sockaddr_in6 addrs[2];
943 	struct inpcb *inp;
944 	int error, s, mapped = 0;
945 
946 	error = suser_xxx(0, req->td->td_proc, PRISON_ROOT);
947 	if (error)
948 		return (error);
949 	error = SYSCTL_IN(req, addrs, sizeof(addrs));
950 	if (error)
951 		return (error);
952 	if (IN6_IS_ADDR_V4MAPPED(&addrs[0].sin6_addr)) {
953 		if (IN6_IS_ADDR_V4MAPPED(&addrs[1].sin6_addr))
954 			mapped = 1;
955 		else
956 			return (EINVAL);
957 	}
958 	s = splnet();
959 	if (mapped == 1)
960 		inp = in_pcblookup_hash(&tcbinfo,
961 			*(struct in_addr *)&addrs[1].sin6_addr.s6_addr[12],
962 			addrs[1].sin6_port,
963 			*(struct in_addr *)&addrs[0].sin6_addr.s6_addr[12],
964 			addrs[0].sin6_port,
965 			0, NULL);
966 	else
967 		inp = in6_pcblookup_hash(&tcbinfo, &addrs[1].sin6_addr,
968 				 addrs[1].sin6_port,
969 				 &addrs[0].sin6_addr, addrs[0].sin6_port,
970 				 0, NULL);
971 	if (inp == NULL || inp->inp_socket == NULL) {
972 		error = ENOENT;
973 		goto out;
974 	}
975 	error = cr_cansee(req->td->td_proc->p_ucred, inp->inp_socket->so_cred);
976 	if (error)
977 		goto out;
978 	bzero(&xuc, sizeof(xuc));
979 	xuc.cr_uid = inp->inp_socket->so_cred->cr_uid;
980 	xuc.cr_ngroups = inp->inp_socket->so_cred->cr_ngroups;
981 	bcopy(inp->inp_socket->so_cred->cr_groups, xuc.cr_groups,
982 	    sizeof(xuc.cr_groups));
983 	error = SYSCTL_OUT(req, &xuc, sizeof(struct xucred));
984 out:
985 	splx(s);
986 	return (error);
987 }
988 
989 SYSCTL_PROC(_net_inet6_tcp6, OID_AUTO, getcred,
990     CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_PRISON, 0, 0,
991     tcp6_getcred, "S,xucred", "Get the xucred of a TCP6 connection");
992 #endif
993 
994 
995 void
996 tcp_ctlinput(cmd, sa, vip)
997 	int cmd;
998 	struct sockaddr *sa;
999 	void *vip;
1000 {
1001 	struct ip *ip = vip;
1002 	struct tcphdr *th;
1003 	struct in_addr faddr;
1004 	struct inpcb *inp;
1005 	struct tcpcb *tp;
1006 	void (*notify) __P((struct inpcb *, int)) = tcp_notify;
1007 	tcp_seq icmp_seq;
1008 	int s;
1009 
1010 	faddr = ((struct sockaddr_in *)sa)->sin_addr;
1011 	if (sa->sa_family != AF_INET || faddr.s_addr == INADDR_ANY)
1012 		return;
1013 
1014 	if (cmd == PRC_QUENCH)
1015 		notify = tcp_quench;
1016 	else if (icmp_may_rst && (cmd == PRC_UNREACH_ADMIN_PROHIB ||
1017 		cmd == PRC_UNREACH_PORT) && ip)
1018 		notify = tcp_drop_syn_sent;
1019 	else if (cmd == PRC_MSGSIZE)
1020 		notify = tcp_mtudisc;
1021 	else if (PRC_IS_REDIRECT(cmd)) {
1022 		ip = 0;
1023 		notify = in_rtchange;
1024 	} else if (cmd == PRC_HOSTDEAD)
1025 		ip = 0;
1026 	else if ((unsigned)cmd > PRC_NCMDS || inetctlerrmap[cmd] == 0)
1027 		return;
1028 	if (ip) {
1029 		s = splnet();
1030 		th = (struct tcphdr *)((caddr_t)ip
1031 				       + (IP_VHL_HL(ip->ip_vhl) << 2));
1032 		inp = in_pcblookup_hash(&tcbinfo, faddr, th->th_dport,
1033 		    ip->ip_src, th->th_sport, 0, NULL);
1034 		if (inp != NULL && inp->inp_socket != NULL) {
1035 			icmp_seq = htonl(th->th_seq);
1036 			tp = intotcpcb(inp);
1037 			if (SEQ_GEQ(icmp_seq, tp->snd_una) &&
1038 			    SEQ_LT(icmp_seq, tp->snd_max))
1039 				(*notify)(inp, inetctlerrmap[cmd]);
1040 		} else {
1041 			struct in_conninfo inc;
1042 
1043 			inc.inc_fport = th->th_dport;
1044 			inc.inc_lport = th->th_sport;
1045 			inc.inc_faddr = faddr;
1046 			inc.inc_laddr = ip->ip_src;
1047 #ifdef INET6
1048 			inc.inc_isipv6 = 0;
1049 #endif
1050 			syncache_unreach(&inc, th);
1051 		}
1052 		splx(s);
1053 	} else
1054 		in_pcbnotifyall(&tcb, faddr, inetctlerrmap[cmd], notify);
1055 }
1056 
1057 #ifdef INET6
1058 void
1059 tcp6_ctlinput(cmd, sa, d)
1060 	int cmd;
1061 	struct sockaddr *sa;
1062 	void *d;
1063 {
1064 	struct tcphdr th;
1065 	void (*notify) __P((struct inpcb *, int)) = tcp_notify;
1066 	struct ip6_hdr *ip6;
1067 	struct mbuf *m;
1068 	struct ip6ctlparam *ip6cp = NULL;
1069 	const struct sockaddr_in6 *sa6_src = NULL;
1070 	int off;
1071 	struct tcp_portonly {
1072 		u_int16_t th_sport;
1073 		u_int16_t th_dport;
1074 	} *thp;
1075 
1076 	if (sa->sa_family != AF_INET6 ||
1077 	    sa->sa_len != sizeof(struct sockaddr_in6))
1078 		return;
1079 
1080 	if (cmd == PRC_QUENCH)
1081 		notify = tcp_quench;
1082 	else if (cmd == PRC_MSGSIZE)
1083 		notify = tcp_mtudisc;
1084 	else if (!PRC_IS_REDIRECT(cmd) &&
1085 		 ((unsigned)cmd > PRC_NCMDS || inet6ctlerrmap[cmd] == 0))
1086 		return;
1087 
1088 	/* if the parameter is from icmp6, decode it. */
1089 	if (d != NULL) {
1090 		ip6cp = (struct ip6ctlparam *)d;
1091 		m = ip6cp->ip6c_m;
1092 		ip6 = ip6cp->ip6c_ip6;
1093 		off = ip6cp->ip6c_off;
1094 		sa6_src = ip6cp->ip6c_src;
1095 	} else {
1096 		m = NULL;
1097 		ip6 = NULL;
1098 		off = 0;	/* fool gcc */
1099 		sa6_src = &sa6_any;
1100 	}
1101 
1102 	if (ip6) {
1103 		struct in_conninfo inc;
1104 		/*
1105 		 * XXX: We assume that when IPV6 is non NULL,
1106 		 * M and OFF are valid.
1107 		 */
1108 
1109 		/* check if we can safely examine src and dst ports */
1110 		if (m->m_pkthdr.len < off + sizeof(*thp))
1111 			return;
1112 
1113 		bzero(&th, sizeof(th));
1114 		m_copydata(m, off, sizeof(*thp), (caddr_t)&th);
1115 
1116 		in6_pcbnotify(&tcb, sa, th.th_dport,
1117 		    (struct sockaddr *)ip6cp->ip6c_src,
1118 		    th.th_sport, cmd, notify);
1119 
1120 		inc.inc_fport = th.th_dport;
1121 		inc.inc_lport = th.th_sport;
1122 		inc.inc6_faddr = ((struct sockaddr_in6 *)sa)->sin6_addr;
1123 		inc.inc6_laddr = ip6cp->ip6c_src->sin6_addr;
1124 		inc.inc_isipv6 = 1;
1125 		syncache_unreach(&inc, &th);
1126 	} else
1127 		in6_pcbnotify(&tcb, sa, 0, (struct sockaddr *)sa6_src,
1128 			      0, cmd, notify);
1129 }
1130 #endif /* INET6 */
1131 
1132 
1133 /*
1134  * Following is where TCP initial sequence number generation occurs.
1135  *
1136  * There are two places where we must use initial sequence numbers:
1137  * 1.  In SYN-ACK packets.
1138  * 2.  In SYN packets.
1139  *
1140  * The ISNs in SYN-ACK packets have no monotonicity requirement,
1141  * and should be as unpredictable as possible to avoid the possibility
1142  * of spoofing and/or connection hijacking.  To satisfy this
1143  * requirement, SYN-ACK ISNs are generated via the arc4random()
1144  * function.  If exact RFC 1948 compliance is requested via sysctl,
1145  * these ISNs will be generated just like those in SYN packets.
1146  *
1147  * The ISNs in SYN packets must be monotonic; TIME_WAIT recycling
1148  * depends on this property.  In addition, these ISNs should be
1149  * unguessable so as to prevent connection hijacking.  To satisfy
1150  * the requirements of this situation, the algorithm outlined in
1151  * RFC 1948 is used to generate sequence numbers.
1152  *
1153  * For more information on the theory of operation, please see
1154  * RFC 1948.
1155  *
1156  * Implementation details:
1157  *
1158  * Time is based off the system timer, and is corrected so that it
1159  * increases by one megabyte per second.  This allows for proper
1160  * recycling on high speed LANs while still leaving over an hour
1161  * before rollover.
1162  *
1163  * Two sysctls control the generation of ISNs:
1164  *
1165  * net.inet.tcp.isn_reseed_interval controls the number of seconds
1166  * between seeding of isn_secret.  This is normally set to zero,
1167  * as reseeding should not be necessary.
1168  *
1169  * net.inet.tcp.strict_rfc1948 controls whether RFC 1948 is followed
1170  * strictly.  When strict compliance is requested, reseeding is
1171  * disabled and SYN-ACKs will be generated in the same manner as
1172  * SYNs.  Strict mode is disabled by default.
1173  *
1174  */
1175 
1176 #define ISN_BYTES_PER_SECOND 1048576
1177 
1178 u_char isn_secret[32];
1179 int isn_last_reseed;
1180 MD5_CTX isn_ctx;
1181 
1182 tcp_seq
1183 tcp_new_isn(tp)
1184 	struct tcpcb *tp;
1185 {
1186 	u_int32_t md5_buffer[4];
1187 	tcp_seq new_isn;
1188 
1189 	/* Use arc4random for SYN-ACKs when not in exact RFC1948 mode. */
1190 	if (((tp->t_state == TCPS_LISTEN) || (tp->t_state == TCPS_TIME_WAIT))
1191 	   && tcp_strict_rfc1948 == 0)
1192 		return arc4random();
1193 
1194 	/* Seed if this is the first use, reseed if requested. */
1195 	if ((isn_last_reseed == 0) ||
1196 	    ((tcp_strict_rfc1948 == 0) && (tcp_isn_reseed_interval > 0) &&
1197 	     (((u_int)isn_last_reseed + (u_int)tcp_isn_reseed_interval*hz)
1198 		< (u_int)ticks))) {
1199 		read_random(&isn_secret, sizeof(isn_secret));
1200 		isn_last_reseed = ticks;
1201 	}
1202 
1203 	/* Compute the md5 hash and return the ISN. */
1204 	MD5Init(&isn_ctx);
1205 	MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->inp_fport, sizeof(u_short));
1206 	MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->inp_lport, sizeof(u_short));
1207 #ifdef INET6
1208 	if ((tp->t_inpcb->inp_vflag & INP_IPV6) != 0) {
1209 		MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->in6p_faddr,
1210 			  sizeof(struct in6_addr));
1211 		MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->in6p_laddr,
1212 			  sizeof(struct in6_addr));
1213 	} else
1214 #endif
1215 	{
1216 		MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->inp_faddr,
1217 			  sizeof(struct in_addr));
1218 		MD5Update(&isn_ctx, (u_char *) &tp->t_inpcb->inp_laddr,
1219 			  sizeof(struct in_addr));
1220 	}
1221 	MD5Update(&isn_ctx, (u_char *) &isn_secret, sizeof(isn_secret));
1222 	MD5Final((u_char *) &md5_buffer, &isn_ctx);
1223 	new_isn = (tcp_seq) md5_buffer[0];
1224 	new_isn += ticks * (ISN_BYTES_PER_SECOND / hz);
1225 	return new_isn;
1226 }
1227 
1228 /*
1229  * When a source quench is received, close congestion window
1230  * to one segment.  We will gradually open it again as we proceed.
1231  */
1232 void
1233 tcp_quench(inp, errno)
1234 	struct inpcb *inp;
1235 	int errno;
1236 {
1237 	struct tcpcb *tp = intotcpcb(inp);
1238 
1239 	if (tp)
1240 		tp->snd_cwnd = tp->t_maxseg;
1241 }
1242 
1243 /*
1244  * When a specific ICMP unreachable message is received and the
1245  * connection state is SYN-SENT, drop the connection.  This behavior
1246  * is controlled by the icmp_may_rst sysctl.
1247  */
1248 void
1249 tcp_drop_syn_sent(inp, errno)
1250 	struct inpcb *inp;
1251 	int errno;
1252 {
1253 	struct tcpcb *tp = intotcpcb(inp);
1254 
1255 	if (tp && tp->t_state == TCPS_SYN_SENT)
1256 		tcp_drop(tp, errno);
1257 }
1258 
1259 /*
1260  * When `need fragmentation' ICMP is received, update our idea of the MSS
1261  * based on the new value in the route.  Also nudge TCP to send something,
1262  * since we know the packet we just sent was dropped.
1263  * This duplicates some code in the tcp_mss() function in tcp_input.c.
1264  */
1265 void
1266 tcp_mtudisc(inp, errno)
1267 	struct inpcb *inp;
1268 	int errno;
1269 {
1270 	struct tcpcb *tp = intotcpcb(inp);
1271 	struct rtentry *rt;
1272 	struct rmxp_tao *taop;
1273 	struct socket *so = inp->inp_socket;
1274 	int offered;
1275 	int mss;
1276 #ifdef INET6
1277 	int isipv6 = (tp->t_inpcb->inp_vflag & INP_IPV6) != 0;
1278 #endif /* INET6 */
1279 
1280 	if (tp) {
1281 #ifdef INET6
1282 		if (isipv6)
1283 			rt = tcp_rtlookup6(&inp->inp_inc);
1284 		else
1285 #endif /* INET6 */
1286 		rt = tcp_rtlookup(&inp->inp_inc);
1287 		if (!rt || !rt->rt_rmx.rmx_mtu) {
1288 			tp->t_maxopd = tp->t_maxseg =
1289 #ifdef INET6
1290 				isipv6 ? tcp_v6mssdflt :
1291 #endif /* INET6 */
1292 				tcp_mssdflt;
1293 			return;
1294 		}
1295 		taop = rmx_taop(rt->rt_rmx);
1296 		offered = taop->tao_mssopt;
1297 		mss = rt->rt_rmx.rmx_mtu -
1298 #ifdef INET6
1299 			(isipv6 ?
1300 			 sizeof(struct ip6_hdr) + sizeof(struct tcphdr) :
1301 #endif /* INET6 */
1302 			 sizeof(struct tcpiphdr)
1303 #ifdef INET6
1304 			 )
1305 #endif /* INET6 */
1306 			;
1307 
1308 		if (offered)
1309 			mss = min(mss, offered);
1310 		/*
1311 		 * XXX - The above conditional probably violates the TCP
1312 		 * spec.  The problem is that, since we don't know the
1313 		 * other end's MSS, we are supposed to use a conservative
1314 		 * default.  But, if we do that, then MTU discovery will
1315 		 * never actually take place, because the conservative
1316 		 * default is much less than the MTUs typically seen
1317 		 * on the Internet today.  For the moment, we'll sweep
1318 		 * this under the carpet.
1319 		 *
1320 		 * The conservative default might not actually be a problem
1321 		 * if the only case this occurs is when sending an initial
1322 		 * SYN with options and data to a host we've never talked
1323 		 * to before.  Then, they will reply with an MSS value which
1324 		 * will get recorded and the new parameters should get
1325 		 * recomputed.  For Further Study.
1326 		 */
1327 		if (tp->t_maxopd <= mss)
1328 			return;
1329 		tp->t_maxopd = mss;
1330 
1331 		if ((tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP &&
1332 		    (tp->t_flags & TF_RCVD_TSTMP) == TF_RCVD_TSTMP)
1333 			mss -= TCPOLEN_TSTAMP_APPA;
1334 		if ((tp->t_flags & (TF_REQ_CC|TF_NOOPT)) == TF_REQ_CC &&
1335 		    (tp->t_flags & TF_RCVD_CC) == TF_RCVD_CC)
1336 			mss -= TCPOLEN_CC_APPA;
1337 #if	(MCLBYTES & (MCLBYTES - 1)) == 0
1338 		if (mss > MCLBYTES)
1339 			mss &= ~(MCLBYTES-1);
1340 #else
1341 		if (mss > MCLBYTES)
1342 			mss = mss / MCLBYTES * MCLBYTES;
1343 #endif
1344 		if (so->so_snd.sb_hiwat < mss)
1345 			mss = so->so_snd.sb_hiwat;
1346 
1347 		tp->t_maxseg = mss;
1348 
1349 		tcpstat.tcps_mturesent++;
1350 		tp->t_rtttime = 0;
1351 		tp->snd_nxt = tp->snd_una;
1352 		tcp_output(tp);
1353 	}
1354 }
1355 
1356 /*
1357  * Look-up the routing entry to the peer of this inpcb.  If no route
1358  * is found and it cannot be allocated the return NULL.  This routine
1359  * is called by TCP routines that access the rmx structure and by tcp_mss
1360  * to get the interface MTU.
1361  */
1362 struct rtentry *
1363 tcp_rtlookup(inc)
1364 	struct in_conninfo *inc;
1365 {
1366 	struct route *ro;
1367 	struct rtentry *rt;
1368 
1369 	ro = &inc->inc_route;
1370 	rt = ro->ro_rt;
1371 	if (rt == NULL || !(rt->rt_flags & RTF_UP)) {
1372 		/* No route yet, so try to acquire one */
1373 		if (inc->inc_faddr.s_addr != INADDR_ANY) {
1374 			ro->ro_dst.sa_family = AF_INET;
1375 			ro->ro_dst.sa_len = sizeof(struct sockaddr_in);
1376 			((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
1377 			    inc->inc_faddr;
1378 			rtalloc(ro);
1379 			rt = ro->ro_rt;
1380 		}
1381 	}
1382 	return rt;
1383 }
1384 
1385 #ifdef INET6
1386 struct rtentry *
1387 tcp_rtlookup6(inc)
1388 	struct in_conninfo *inc;
1389 {
1390 	struct route_in6 *ro6;
1391 	struct rtentry *rt;
1392 
1393 	ro6 = &inc->inc6_route;
1394 	rt = ro6->ro_rt;
1395 	if (rt == NULL || !(rt->rt_flags & RTF_UP)) {
1396 		/* No route yet, so try to acquire one */
1397 		if (!IN6_IS_ADDR_UNSPECIFIED(&inc->inc6_faddr)) {
1398 			ro6->ro_dst.sin6_family = AF_INET6;
1399 			ro6->ro_dst.sin6_len = sizeof(struct sockaddr_in6);
1400 			ro6->ro_dst.sin6_addr = inc->inc6_faddr;
1401 			rtalloc((struct route *)ro6);
1402 			rt = ro6->ro_rt;
1403 		}
1404 	}
1405 	return rt;
1406 }
1407 #endif /* INET6 */
1408 
1409 #ifdef IPSEC
1410 /* compute ESP/AH header size for TCP, including outer IP header. */
1411 size_t
1412 ipsec_hdrsiz_tcp(tp)
1413 	struct tcpcb *tp;
1414 {
1415 	struct inpcb *inp;
1416 	struct mbuf *m;
1417 	size_t hdrsiz;
1418 	struct ip *ip;
1419 #ifdef INET6
1420 	struct ip6_hdr *ip6;
1421 #endif /* INET6 */
1422 	struct tcphdr *th;
1423 
1424 	if ((tp == NULL) || ((inp = tp->t_inpcb) == NULL))
1425 		return 0;
1426 	MGETHDR(m, M_DONTWAIT, MT_DATA);
1427 	if (!m)
1428 		return 0;
1429 
1430 #ifdef INET6
1431 	if ((inp->inp_vflag & INP_IPV6) != 0) {
1432 		ip6 = mtod(m, struct ip6_hdr *);
1433 		th = (struct tcphdr *)(ip6 + 1);
1434 		m->m_pkthdr.len = m->m_len =
1435 			sizeof(struct ip6_hdr) + sizeof(struct tcphdr);
1436 		tcp_fillheaders(tp, ip6, th);
1437 		hdrsiz = ipsec6_hdrsiz(m, IPSEC_DIR_OUTBOUND, inp);
1438 	} else
1439 #endif /* INET6 */
1440       {
1441 	ip = mtod(m, struct ip *);
1442 	th = (struct tcphdr *)(ip + 1);
1443 	m->m_pkthdr.len = m->m_len = sizeof(struct tcpiphdr);
1444 	tcp_fillheaders(tp, ip, th);
1445 	hdrsiz = ipsec4_hdrsiz(m, IPSEC_DIR_OUTBOUND, inp);
1446       }
1447 
1448 	m_free(m);
1449 	return hdrsiz;
1450 }
1451 #endif /*IPSEC*/
1452 
1453 /*
1454  * Return a pointer to the cached information about the remote host.
1455  * The cached information is stored in the protocol specific part of
1456  * the route metrics.
1457  */
1458 struct rmxp_tao *
1459 tcp_gettaocache(inc)
1460 	struct in_conninfo *inc;
1461 {
1462 	struct rtentry *rt;
1463 
1464 #ifdef INET6
1465 	if (inc->inc_isipv6)
1466 		rt = tcp_rtlookup6(inc);
1467 	else
1468 #endif /* INET6 */
1469 	rt = tcp_rtlookup(inc);
1470 
1471 	/* Make sure this is a host route and is up. */
1472 	if (rt == NULL ||
1473 	    (rt->rt_flags & (RTF_UP|RTF_HOST)) != (RTF_UP|RTF_HOST))
1474 		return NULL;
1475 
1476 	return rmx_taop(rt->rt_rmx);
1477 }
1478 
1479 /*
1480  * Clear all the TAO cache entries, called from tcp_init.
1481  *
1482  * XXX
1483  * This routine is just an empty one, because we assume that the routing
1484  * routing tables are initialized at the same time when TCP, so there is
1485  * nothing in the cache left over.
1486  */
1487 static void
1488 tcp_cleartaocache()
1489 {
1490 }
1491