tcp_usrreq.c revision 1.8 1 /*
2 * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
3 * 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 * from: @(#)tcp_usrreq.c 7.15 (Berkeley) 6/28/90
34 * $Id: tcp_usrreq.c,v 1.8 1994/01/10 23:27:45 mycroft Exp $
35 */
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/malloc.h>
40 #include <sys/mbuf.h>
41 #include <sys/socket.h>
42 #include <sys/socketvar.h>
43 #include <sys/protosw.h>
44 #include <sys/errno.h>
45 #include <sys/stat.h>
46
47 #include <net/if.h>
48 #include <net/route.h>
49
50 #include <netinet/in.h>
51 #include <netinet/in_systm.h>
52 #include <netinet/ip.h>
53 #include <netinet/in_pcb.h>
54 #include <netinet/ip_var.h>
55 #include <netinet/tcp.h>
56 #include <netinet/tcp_fsm.h>
57 #include <netinet/tcp_seq.h>
58 #include <netinet/tcp_timer.h>
59 #include <netinet/tcp_var.h>
60 #include <netinet/tcpip.h>
61 #include <netinet/tcp_debug.h>
62
63 /*
64 * TCP protocol interface to socket abstraction.
65 */
66 extern char *tcpstates[];
67
68 /*
69 * Process a TCP user request for TCP tb. If this is a send request
70 * then m is the mbuf chain of send data. If this is a timer expiration
71 * (called from the software clock routine), then timertype tells which timer.
72 */
73 /*ARGSUSED*/
74 int
75 tcp_usrreq(so, req, m, nam, control)
76 struct socket *so;
77 int req;
78 struct mbuf *m, *nam, *control;
79 {
80 register struct inpcb *inp;
81 register struct tcpcb *tp;
82 int s;
83 int error = 0;
84 int ostate;
85
86 if (req == PRU_CONTROL)
87 return (in_control(so, (int)m, (caddr_t)nam,
88 (struct ifnet *)control));
89 if (control && control->m_len) {
90 m_freem(control);
91 if (m)
92 m_freem(m);
93 return (EINVAL);
94 }
95
96 s = splnet();
97 inp = sotoinpcb(so);
98 /*
99 * When a TCP is attached to a socket, then there will be
100 * a (struct inpcb) pointed at by the socket, and this
101 * structure will point at a subsidary (struct tcpcb).
102 */
103 if (inp == 0 && req != PRU_ATTACH) {
104 splx(s);
105 return (EINVAL); /* XXX */
106 }
107 if (inp) {
108 tp = intotcpcb(inp);
109 /* WHAT IF TP IS 0? */
110 #ifdef KPROF
111 tcp_acounts[tp->t_state][req]++;
112 #endif
113 ostate = tp->t_state;
114 } else
115 ostate = 0;
116 switch (req) {
117
118 /*
119 * TCP attaches to socket via PRU_ATTACH, reserving space,
120 * and an internet control block.
121 */
122 case PRU_ATTACH:
123 if (inp) {
124 error = EISCONN;
125 break;
126 }
127 error = tcp_attach(so);
128 if (error)
129 break;
130 if ((so->so_options & SO_LINGER) && so->so_linger == 0)
131 so->so_linger = TCP_LINGERTIME;
132 tp = sototcpcb(so);
133 break;
134
135 /*
136 * PRU_DETACH detaches the TCP protocol from the socket.
137 * If the protocol state is non-embryonic, then can't
138 * do this directly: have to initiate a PRU_DISCONNECT,
139 * which may finish later; embryonic TCB's can just
140 * be discarded here.
141 */
142 case PRU_DETACH:
143 if (tp->t_state > TCPS_LISTEN)
144 tp = tcp_disconnect(tp);
145 else
146 tp = tcp_close(tp);
147 break;
148
149 /*
150 * Give the socket an address.
151 */
152 case PRU_BIND:
153 error = in_pcbbind(inp, nam);
154 if (error)
155 break;
156 break;
157
158 /*
159 * Prepare to accept connections.
160 */
161 case PRU_LISTEN:
162 if (inp->inp_lport == 0)
163 error = in_pcbbind(inp, (struct mbuf *)0);
164 if (error == 0)
165 tp->t_state = TCPS_LISTEN;
166 break;
167
168 /*
169 * Initiate connection to peer.
170 * Create a template for use in transmissions on this connection.
171 * Enter SYN_SENT state, and mark socket as connecting.
172 * Start keep-alive timer, and seed output sequence space.
173 * Send initial segment on connection.
174 */
175 case PRU_CONNECT:
176 if (inp->inp_lport == 0) {
177 error = in_pcbbind(inp, (struct mbuf *)0);
178 if (error)
179 break;
180 }
181 error = in_pcbconnect(inp, nam);
182 if (error)
183 break;
184 tp->t_template = tcp_template(tp);
185 if (tp->t_template == 0) {
186 in_pcbdisconnect(inp);
187 error = ENOBUFS;
188 break;
189 }
190 soisconnecting(so);
191 tcpstat.tcps_connattempt++;
192 tp->t_state = TCPS_SYN_SENT;
193 tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
194 tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
195 tcp_sendseqinit(tp);
196 error = tcp_output(tp);
197 break;
198
199 /*
200 * Create a TCP connection between two sockets.
201 */
202 case PRU_CONNECT2:
203 error = EOPNOTSUPP;
204 break;
205
206 /*
207 * Initiate disconnect from peer.
208 * If connection never passed embryonic stage, just drop;
209 * else if don't need to let data drain, then can just drop anyways,
210 * else have to begin TCP shutdown process: mark socket disconnecting,
211 * drain unread data, state switch to reflect user close, and
212 * send segment (e.g. FIN) to peer. Socket will be really disconnected
213 * when peer sends FIN and acks ours.
214 *
215 * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
216 */
217 case PRU_DISCONNECT:
218 tp = tcp_disconnect(tp);
219 break;
220
221 /*
222 * Accept a connection. Essentially all the work is
223 * done at higher levels; just return the address
224 * of the peer, storing through addr.
225 */
226 case PRU_ACCEPT:
227 in_setpeeraddr(inp, nam);
228 break;
229
230 /*
231 * Mark the connection as being incapable of further output.
232 */
233 case PRU_SHUTDOWN:
234 socantsendmore(so);
235 tp = tcp_usrclosed(tp);
236 if (tp)
237 error = tcp_output(tp);
238 break;
239
240 /*
241 * After a receive, possibly send window update to peer.
242 */
243 case PRU_RCVD:
244 (void) tcp_output(tp);
245 break;
246
247 /*
248 * Do a send by putting data in output queue and updating urgent
249 * marker if URG set. Possibly send more data.
250 */
251 case PRU_SEND:
252 sbappend(&so->so_snd, m);
253 error = tcp_output(tp);
254 break;
255
256 /*
257 * Abort the TCP.
258 */
259 case PRU_ABORT:
260 tp = tcp_drop(tp, ECONNABORTED);
261 break;
262
263 case PRU_SENSE:
264 ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
265 (void) splx(s);
266 return (0);
267
268 case PRU_RCVOOB:
269 if ((so->so_oobmark == 0 &&
270 (so->so_state & SS_RCVATMARK) == 0) ||
271 so->so_options & SO_OOBINLINE ||
272 tp->t_oobflags & TCPOOB_HADDATA) {
273 error = EINVAL;
274 break;
275 }
276 if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
277 error = EWOULDBLOCK;
278 break;
279 }
280 m->m_len = 1;
281 *mtod(m, caddr_t) = tp->t_iobc;
282 if (((int)nam & MSG_PEEK) == 0)
283 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
284 break;
285
286 case PRU_SENDOOB:
287 if (sbspace(&so->so_snd) < -512) {
288 m_freem(m);
289 error = ENOBUFS;
290 break;
291 }
292 /*
293 * According to RFC961 (Assigned Protocols),
294 * the urgent pointer points to the last octet
295 * of urgent data. We continue, however,
296 * to consider it to indicate the first octet
297 * of data past the urgent section.
298 * Otherwise, snd_up should be one lower.
299 */
300 sbappend(&so->so_snd, m);
301 tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
302 tp->t_force = 1;
303 error = tcp_output(tp);
304 tp->t_force = 0;
305 break;
306
307 case PRU_SOCKADDR:
308 in_setsockaddr(inp, nam);
309 break;
310
311 case PRU_PEERADDR:
312 in_setpeeraddr(inp, nam);
313 break;
314
315 /*
316 * TCP slow timer went off; going through this
317 * routine for tracing's sake.
318 */
319 case PRU_SLOWTIMO:
320 tp = tcp_timers(tp, (int)nam);
321 req |= (int)nam << 8; /* for debug's sake */
322 break;
323
324 default:
325 panic("tcp_usrreq");
326 }
327 if (tp && (so->so_options & SO_DEBUG))
328 tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, req);
329 splx(s);
330 return (error);
331 }
332
333 int
334 tcp_ctloutput(op, so, level, optname, mp)
335 int op;
336 struct socket *so;
337 int level, optname;
338 struct mbuf **mp;
339 {
340 int error = 0;
341 struct inpcb *inp = sotoinpcb(so);
342 register struct tcpcb *tp = intotcpcb(inp);
343 register struct mbuf *m;
344
345 if (level != IPPROTO_TCP)
346 return (ip_ctloutput(op, so, level, optname, mp));
347
348 switch (op) {
349
350 case PRCO_SETOPT:
351 m = *mp;
352 switch (optname) {
353
354 case TCP_NODELAY:
355 if (m == NULL || m->m_len < sizeof (int))
356 error = EINVAL;
357 else if (*mtod(m, int *))
358 tp->t_flags |= TF_NODELAY;
359 else
360 tp->t_flags &= ~TF_NODELAY;
361 break;
362
363 case TCP_MAXSEG: /* not yet */
364 default:
365 error = EINVAL;
366 break;
367 }
368 if (m)
369 (void) m_free(m);
370 break;
371
372 case PRCO_GETOPT:
373 *mp = m = m_get(M_WAIT, MT_SOOPTS);
374 m->m_len = sizeof(int);
375
376 switch (optname) {
377 case TCP_NODELAY:
378 *mtod(m, int *) = tp->t_flags & TF_NODELAY;
379 break;
380 case TCP_MAXSEG:
381 *mtod(m, int *) = tp->t_maxseg;
382 break;
383 default:
384 error = EINVAL;
385 break;
386 }
387 break;
388 }
389 return (error);
390 }
391
392 u_long tcp_sendspace = 1024*8;
393 u_long tcp_recvspace = 1024*8;
394
395 /*
396 * Attach TCP protocol to socket, allocating
397 * internet protocol control block, tcp control block,
398 * bufer space, and entering LISTEN state if to accept connections.
399 */
400 int
401 tcp_attach(so)
402 struct socket *so;
403 {
404 register struct tcpcb *tp;
405 struct inpcb *inp;
406 int error;
407
408 if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
409 error = soreserve(so, tcp_sendspace, tcp_recvspace);
410 if (error)
411 return (error);
412 }
413 error = in_pcballoc(so, &tcb);
414 if (error)
415 return (error);
416 inp = sotoinpcb(so);
417 tp = tcp_newtcpcb(inp);
418 if (tp == 0) {
419 int nofd = so->so_state & SS_NOFDREF; /* XXX */
420
421 so->so_state &= ~SS_NOFDREF; /* don't free the socket yet */
422 in_pcbdetach(inp);
423 so->so_state |= nofd;
424 return (ENOBUFS);
425 }
426 tp->t_state = TCPS_CLOSED;
427 return (0);
428 }
429
430 /*
431 * Initiate (or continue) disconnect.
432 * If embryonic state, just send reset (once).
433 * If in ``let data drain'' option and linger null, just drop.
434 * Otherwise (hard), mark socket disconnecting and drop
435 * current input data; switch states based on user close, and
436 * send segment to peer (with FIN).
437 */
438 struct tcpcb *
439 tcp_disconnect(tp)
440 register struct tcpcb *tp;
441 {
442 struct socket *so = tp->t_inpcb->inp_socket;
443
444 if (tp->t_state < TCPS_ESTABLISHED)
445 tp = tcp_close(tp);
446 else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
447 tp = tcp_drop(tp, 0);
448 else {
449 soisdisconnecting(so);
450 sbflush(&so->so_rcv);
451 tp = tcp_usrclosed(tp);
452 if (tp)
453 (void) tcp_output(tp);
454 }
455 return (tp);
456 }
457
458 /*
459 * User issued close, and wish to trail through shutdown states:
460 * if never received SYN, just forget it. If got a SYN from peer,
461 * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
462 * If already got a FIN from peer, then almost done; go to LAST_ACK
463 * state. In all other cases, have already sent FIN to peer (e.g.
464 * after PRU_SHUTDOWN), and just have to play tedious game waiting
465 * for peer to send FIN or not respond to keep-alives, etc.
466 * We can let the user exit from the close as soon as the FIN is acked.
467 */
468 struct tcpcb *
469 tcp_usrclosed(tp)
470 register struct tcpcb *tp;
471 {
472
473 switch (tp->t_state) {
474
475 case TCPS_CLOSED:
476 case TCPS_LISTEN:
477 case TCPS_SYN_SENT:
478 tp->t_state = TCPS_CLOSED;
479 tp = tcp_close(tp);
480 break;
481
482 case TCPS_SYN_RECEIVED:
483 case TCPS_ESTABLISHED:
484 tp->t_state = TCPS_FIN_WAIT_1;
485 break;
486
487 case TCPS_CLOSE_WAIT:
488 tp->t_state = TCPS_LAST_ACK;
489 break;
490 }
491 if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
492 soisdisconnected(tp->t_inpcb->inp_socket);
493 return (tp);
494 }
495