new stats; change keepalives to use rcv_nxt instead of rcv_nxt-1
[unix-history] / usr / src / sys / netinet / tcp_subr.c
CommitLineData
8ae0e4b4 1/*
0880b18e 2 * Copyright (c) 1982, 1986 Regents of the University of California.
8ae0e4b4
KM
3 * All rights reserved. The Berkeley software License Agreement
4 * specifies the terms and conditions for redistribution.
5 *
35f3fc10 6 * @(#)tcp_subr.c 7.3 (Berkeley) %G%
8ae0e4b4 7 */
ecaa4e6f 8
20666ad3
JB
9#include "param.h"
10#include "systm.h"
11#include "mbuf.h"
12#include "socket.h"
13#include "socketvar.h"
14#include "protosw.h"
15#include "errno.h"
f4d55810 16
c124e997 17#include "../net/route.h"
f4d55810
SL
18#include "../net/if.h"
19
20666ad3
JB
20#include "in.h"
21#include "in_pcb.h"
22#include "in_systm.h"
23#include "ip.h"
24#include "ip_var.h"
25#include "ip_icmp.h"
26#include "tcp.h"
27#include "tcp_fsm.h"
28#include "tcp_seq.h"
29#include "tcp_timer.h"
30#include "tcp_var.h"
31#include "tcpip.h"
ecaa4e6f
BJ
32
33/*
34 * Tcp initialization
35 */
36tcp_init()
37{
38
39 tcp_iss = 1; /* wrong */
40 tcb.inp_next = tcb.inp_prev = &tcb;
405c9168
BJ
41 tcp_alpha = TCP_ALPHA;
42 tcp_beta = TCP_BETA;
ecaa4e6f
BJ
43}
44
45/*
46 * Create template to be used to send tcp packets on a connection.
47 * Call after host entry created, allocates an mbuf and fills
48 * in a skeletal tcp/ip header, minimizing the amount of work
49 * necessary when the connection is used.
50 */
51struct tcpiphdr *
52tcp_template(tp)
53 struct tcpcb *tp;
54{
55 register struct inpcb *inp = tp->t_inpcb;
56 register struct mbuf *m;
57 register struct tcpiphdr *n;
58
ece01391
MK
59 if ((n = tp->t_template) == 0) {
60 m = m_get(M_WAIT, MT_HEADER);
61 if (m == NULL)
62 return (0);
63 m->m_off = MMAXOFF - sizeof (struct tcpiphdr);
64 m->m_len = sizeof (struct tcpiphdr);
65 n = mtod(m, struct tcpiphdr *);
66 }
ecaa4e6f
BJ
67 n->ti_next = n->ti_prev = 0;
68 n->ti_x1 = 0;
69 n->ti_pr = IPPROTO_TCP;
70 n->ti_len = htons(sizeof (struct tcpiphdr) - sizeof (struct ip));
71 n->ti_src = inp->inp_laddr;
72 n->ti_dst = inp->inp_faddr;
73 n->ti_sport = inp->inp_lport;
74 n->ti_dport = inp->inp_fport;
75 n->ti_seq = 0;
0974b45c 76 n->ti_ack = 0;
ecaa4e6f
BJ
77 n->ti_x2 = 0;
78 n->ti_off = 5;
79 n->ti_flags = 0;
80 n->ti_win = 0;
81 n->ti_sum = 0;
82 n->ti_urp = 0;
83 return (n);
84}
85
86/*
405c9168
BJ
87 * Send a single message to the TCP at address specified by
88 * the given TCP/IP header. If flags==0, then we make a copy
89 * of the tcpiphdr at ti and send directly to the addressed host.
90 * This is used to force keep alive messages out using the TCP
91 * template for a connection tp->t_template. If flags are given
92 * then we send a message back to the TCP which originated the
93 * segment ti, and discard the mbuf containing it and any other
94 * attached mbufs.
95 *
96 * In any case the ack and sequence number of the transmitted
97 * segment are as specified by the parameters.
ecaa4e6f 98 */
8e65fd66
BJ
99tcp_respond(tp, ti, ack, seq, flags)
100 struct tcpcb *tp;
ecaa4e6f 101 register struct tcpiphdr *ti;
0974b45c 102 tcp_seq ack, seq;
ecaa4e6f
BJ
103 int flags;
104{
405c9168 105 struct mbuf *m;
1e977657 106 int win = 0, tlen;
c124e997 107 struct route *ro = 0;
ecaa4e6f 108
c124e997 109 if (tp) {
8e65fd66 110 win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);
c124e997
SL
111 ro = &tp->t_inpcb->inp_route;
112 }
405c9168 113 if (flags == 0) {
cce93e4b 114 m = m_get(M_DONTWAIT, MT_HEADER);
5cdc4d65 115 if (m == NULL)
405c9168 116 return;
1e977657 117 m->m_len = sizeof (struct tcpiphdr) + 1;
405c9168
BJ
118 *mtod(m, struct tcpiphdr *) = *ti;
119 ti = mtod(m, struct tcpiphdr *);
120 flags = TH_ACK;
121 } else {
4aed14e3 122 m = dtom(ti);
405c9168
BJ
123 m_freem(m->m_next);
124 m->m_next = 0;
1acff8ec 125 m->m_off = (int)ti - (int)m;
405c9168 126 m->m_len = sizeof (struct tcpiphdr);
0974b45c 127#define xchg(a,b,type) { type t; t=a; a=b; b=t; }
405c9168
BJ
128 xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr, u_long);
129 xchg(ti->ti_dport, ti->ti_sport, u_short);
ecaa4e6f 130#undef xchg
405c9168 131 }
35f3fc10 132 tlen = 0;
0974b45c
BJ
133 ti->ti_next = ti->ti_prev = 0;
134 ti->ti_x1 = 0;
af8f6a21 135 ti->ti_len = htons((u_short)(sizeof (struct tcphdr) + tlen));
2c48b3f8
BJ
136 ti->ti_seq = htonl(seq);
137 ti->ti_ack = htonl(ack);
0974b45c
BJ
138 ti->ti_x2 = 0;
139 ti->ti_off = sizeof (struct tcphdr) >> 2;
ecaa4e6f 140 ti->ti_flags = flags;
af8f6a21 141 ti->ti_win = htons((u_short)win);
8e65fd66 142 ti->ti_urp = 0;
f3cdd721 143 ti->ti_sum = in_cksum(m, sizeof (struct tcpiphdr) + tlen);
1e977657 144 ((struct ip *)ti)->ip_len = sizeof (struct tcpiphdr) + tlen;
0974b45c 145 ((struct ip *)ti)->ip_ttl = TCP_TTL;
c124e997 146 (void) ip_output(m, (struct mbuf *)0, ro, 0);
ecaa4e6f 147}
a6503abf 148
0974b45c
BJ
149/*
150 * Create a new TCP control block, making an
151 * empty reassembly queue and hooking it to the argument
152 * protocol control block.
153 */
a6503abf
BJ
154struct tcpcb *
155tcp_newtcpcb(inp)
156 struct inpcb *inp;
157{
cce93e4b 158 struct mbuf *m = m_getclr(M_DONTWAIT, MT_PCB);
a6503abf 159 register struct tcpcb *tp;
a6503abf 160
5cdc4d65
SL
161 if (m == NULL)
162 return ((struct tcpcb *)0);
a6503abf 163 tp = mtod(m, struct tcpcb *);
a6503abf 164 tp->seg_next = tp->seg_prev = (struct tcpiphdr *)tp;
247c6a81 165 tp->t_maxseg = TCP_MSS;
3e60e1e6 166 tp->t_flags = 0; /* sends options! */
a6503abf 167 tp->t_inpcb = inp;
247c6a81 168 tp->t_srtt = TCPTV_SRTTBASE;
05586739 169 tp->snd_cwnd = sbspace(&inp->inp_socket->so_snd);
a6503abf
BJ
170 inp->inp_ppcb = (caddr_t)tp;
171 return (tp);
172}
173
0974b45c
BJ
174/*
175 * Drop a TCP connection, reporting
176 * the specified error. If connection is synchronized,
177 * then send a RST to peer.
178 */
0e3936fa 179struct tcpcb *
a6503abf 180tcp_drop(tp, errno)
0e3936fa 181 register struct tcpcb *tp;
a6503abf
BJ
182 int errno;
183{
184 struct socket *so = tp->t_inpcb->inp_socket;
185
d3504cc0 186 if (TCPS_HAVERCVDSYN(tp->t_state)) {
a6503abf 187 tp->t_state = TCPS_CLOSED;
39d536e6 188 (void) tcp_output(tp);
35f3fc10
MK
189 tcpstat.tcps_drops++;
190 } else
191 tcpstat.tcps_conndrops++;
a6503abf 192 so->so_error = errno;
0e3936fa 193 return (tcp_close(tp));
a6503abf
BJ
194}
195
0974b45c
BJ
196/*
197 * Close a TCP control block:
198 * discard all space held by the tcp
199 * discard internet protocol block
200 * wake up any sleepers
201 */
0e3936fa 202struct tcpcb *
a6503abf
BJ
203tcp_close(tp)
204 register struct tcpcb *tp;
205{
206 register struct tcpiphdr *t;
364801f5
BJ
207 struct inpcb *inp = tp->t_inpcb;
208 struct socket *so = inp->inp_socket;
13e2480b 209 register struct mbuf *m;
a6503abf 210
a6503abf 211 t = tp->seg_next;
13e2480b
SL
212 while (t != (struct tcpiphdr *)tp) {
213 t = (struct tcpiphdr *)t->ti_next;
214 m = dtom(t->ti_prev);
215 remque(t->ti_prev);
216 m_freem(m);
217 }
0974b45c 218 if (tp->t_template)
a6503abf 219 (void) m_free(dtom(tp->t_template));
0974b45c
BJ
220 if (tp->t_tcpopt)
221 (void) m_free(dtom(tp->t_tcpopt));
a6503abf 222 (void) m_free(dtom(tp));
364801f5 223 inp->inp_ppcb = 0;
4aed14e3 224 soisdisconnected(so);
86676257 225 in_pcbdetach(inp);
35f3fc10 226 tcpstat.tcps_closed++;
0e3936fa 227 return ((struct tcpcb *)0);
a6503abf
BJ
228}
229
a6503abf
BJ
230tcp_drain()
231{
a6503abf 232
a6503abf
BJ
233}
234
be841dc3
MK
235/*
236 * Notify a tcp user of an asynchronous error;
237 * just wake up so that he can collect error status.
238 */
239tcp_notify(inp)
240 register struct inpcb *inp;
241{
242
243 wakeup((caddr_t) &inp->inp_socket->so_timeo);
244 sorwakeup(inp->inp_socket);
245 sowwakeup(inp->inp_socket);
246}
7c626d4d 247tcp_ctlinput(cmd, sa)
72e4f44e 248 int cmd;
7c626d4d 249 struct sockaddr *sa;
a6503abf 250{
39674d5f 251 extern u_char inetctlerrmap[];
7c626d4d 252 struct sockaddr_in *sin;
62a291b2 253 int tcp_quench(), in_rtchange();
39674d5f 254
7c626d4d
MK
255 if ((unsigned)cmd > PRC_NCMDS)
256 return;
257 if (sa->sa_family != AF_INET && sa->sa_family != AF_IMPLINK)
258 return;
259 sin = (struct sockaddr_in *)sa;
260 if (sin->sin_addr.s_addr == INADDR_ANY)
39674d5f 261 return;
39674d5f 262
7c626d4d 263 switch (cmd) {
39674d5f
SL
264
265 case PRC_QUENCH:
7c626d4d 266 in_pcbnotify(&tcb, &sin->sin_addr, 0, tcp_quench);
62a291b2
MK
267 break;
268
7c626d4d 269 case PRC_ROUTEDEAD:
62a291b2
MK
270 case PRC_REDIRECT_NET:
271 case PRC_REDIRECT_HOST:
7c626d4d
MK
272 case PRC_REDIRECT_TOSNET:
273 case PRC_REDIRECT_TOSHOST:
274 in_pcbnotify(&tcb, &sin->sin_addr, 0, in_rtchange);
39674d5f
SL
275 break;
276
39674d5f 277 default:
62a291b2
MK
278 if (inetctlerrmap[cmd] == 0)
279 return; /* XXX */
7c626d4d 280 in_pcbnotify(&tcb, &sin->sin_addr, (int)inetctlerrmap[cmd],
be841dc3 281 tcp_notify);
39674d5f 282 }
a6503abf 283}
05586739
MK
284
285/*
286 * When a source quench is received, close congestion window
287 * to 80% of the outstanding data (but not less than one segment).
288 */
289tcp_quench(inp)
290 struct inpcb *inp;
291{
292 struct tcpcb *tp = intotcpcb(inp);
293
7c626d4d
MK
294 if (tp)
295 tp->snd_cwnd = MAX(8 * (tp->snd_nxt - tp->snd_una) / 10,
296 tp->t_maxseg);
05586739 297}