![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_usrreq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to tcp_usrreq.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1988, 1993, 1995
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)tcp_usrreq.c 8.5 (Berkeley) 6/21/95
59: */
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/kernel.h>
64: #include <sys/malloc.h>
65: #include <sys/mbuf.h>
66: #include <sys/socket.h>
67: #include <sys/socketvar.h>
68: #include <sys/protosw.h>
69: #include <sys/errno.h>
70: #include <sys/stat.h>
71:
72: #include <net/if.h>
73: #include <net/route.h>
74:
75: #include <netinet/in.h>
76: #include <netinet/in_systm.h>
77: #include <netinet/ip.h>
78: #include <netinet/in_pcb.h>
79: #include <netinet/ip_var.h>
80: #include <netinet/tcp.h>
81: #include <netinet/tcp_fsm.h>
82: #include <netinet/tcp_seq.h>
83: #include <netinet/tcp_timer.h>
84: #include <netinet/tcp_var.h>
85: #include <netinet/tcpip.h>
86: #include <netinet/tcp_debug.h>
87:
88:
89:
90: struct inpcb *tcp_hash_array[N_TCP_HASH_ELEMENTS];
91: struct inpcb *tcp_lport_hash_array[N_TCP_LPORT_HASH_ELEMENTS];
92: struct inpcb_hash_str tcp_hash_str = {tcp_hash_array,
93: TCP_HASH_MASK,
94: N_TCP_HASH_ELEMENTS};
95:
96: struct inpcb_hash_str tcp_lport_hash_str = {tcp_lport_hash_array,
97: TCP_LPORT_HASH_MASK,
98: N_TCP_LPORT_HASH_ELEMENTS};
99:
100:
101: /*
102: * TCP protocol interface to socket abstraction.
103: */
104: extern char *tcpstates[];
105:
106: #if DELACK_BITMASK_ON
107: extern u_long current_active_connections;
108: #endif
109:
110:
111: /*
112: * Process a TCP user request for TCP tb. If this is a send request
113: * then m is the mbuf chain of send data. If this is a timer expiration
114: * (called from the software clock routine), then timertype tells which timer.
115: */
116: /*ARGSUSED*/
117: int
118: tcp_usrreq(so, req, m, nam, control)
119: struct socket *so;
120: int req;
121: struct mbuf *m, *nam, *control;
122: {
123: register struct inpcb *inp;
124: register struct tcpcb *tp;
125: int s;
126: int error = 0;
127: int ostate;
128:
129:
130: if (req == PRU_CONTROL)
131: return (in_control(so, (u_long)m, (caddr_t)nam,
132: (struct ifnet *)control));
133: if (control && control->m_len) {
134: m_freem(control);
135: if (m)
136: m_freem(m);
137: return (EINVAL);
138: }
139:
140: s = splnet();
141: inp = sotoinpcb(so);
142: /*
143: * When a TCP is attached to a socket, then there will be
144: * a (struct inpcb) pointed at by the socket, and this
145: * structure will point at a subsidary (struct tcpcb).
146: */
147: if (inp == 0 && req != PRU_ATTACH) {
148: splx(s);
149: #if 0
150: /*
151: * The following corrects an mbuf leak under rare
152: * circumstances, but has not been fully tested.
153: */
154: if (m && req != PRU_SENSE)
155: m_freem(m);
156: #else
157: /* safer version of fix for mbuf leak */
158: if (m && (req == PRU_SEND || req == PRU_SENDOOB))
159: m_freem(m);
160: #endif
161: return (EINVAL); /* XXX */
162: }
163: if (inp) {
164: tp = intotcpcb(inp);
165: /* WHAT IF TP IS 0? */
166: #if KPROF
167: tcp_acounts[tp->t_state][req]++;
168: #endif
169: ostate = tp->t_state;
170: } else
171: ostate = 0;
172: switch (req) {
173:
174: /*
175: * TCP attaches to socket via PRU_ATTACH, reserving space,
176: * and an internet control block.
177: */
178: case PRU_ATTACH:
179: if (inp) {
180: error = EISCONN;
181: break;
182: }
183: error = tcp_attach(so);
184: if (error)
185: break;
186: if ((so->so_options & SO_LINGER) && so->so_linger == 0)
187: so->so_linger = TCP_LINGERTIME;
188: tp = sototcpcb(so);
189: break;
190:
191: /*
192: * PRU_DETACH detaches the TCP protocol from the socket.
193: * If the protocol state is non-embryonic, then can't
194: * do this directly: have to initiate a PRU_DISCONNECT,
195: * which may finish later; embryonic TCB's can just
196: * be discarded here.
197: */
198: case PRU_DETACH:
199: #if TEMPDEBUG
200: printf("PRU_DETACH called for socket %d\n", so);
201: #endif
202: if (tp->t_state > TCPS_LISTEN)
203: tp = tcp_disconnect(tp);
204: else
205: tp = tcp_close(tp);
206: break;
207:
208: /*
209: * Give the socket an address.
210: */
211: case PRU_BIND:
212: error = in_pcbbind(inp, nam);
213: break;
214:
215: /*
216: * Prepare to accept connections.
217: */
218: case PRU_LISTEN:
219: if (inp->inp_lport == 0)
220: error = in_pcbbind(inp, (struct mbuf *)0);
221:
222: if (error == 0) {
223: tp->t_state = TCPS_LISTEN;
224: hash_insert(inp);
225: }
226: break;
227:
228: /*
229: * Initiate connection to peer.
230: * Create a template for use in transmissions on this connection.
231: * Enter SYN_SENT state, and mark socket as connecting.
232: * Start keep-alive timer, and seed output sequence space.
233: * Send initial segment on connection.
234: */
235: case PRU_CONNECT:
236: if (inp->inp_lport == 0) {
237: error = in_pcbbind(inp, (struct mbuf *)0);
238: if (error)
239: break;
240: }
241: error = in_pcbconnect(inp, nam);
242: if (error)
243: break;
244:
245: tp->t_template = tcp_template(tp);
246: if (tp->t_template == 0) {
247: in_pcbdisconnect(inp);
248: error = ENOBUFS;
249: break;
250: }
251: /* Compute window scaling to request. */
252: while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
253: (TCP_MAXWIN << tp->request_r_scale) < so->so_rcv.sb_hiwat)
254: tp->request_r_scale++;
255: soisconnecting(so);
256: tcpstat.tcps_connattempt++;
257: tp->t_state = TCPS_SYN_SENT;
258: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
259: tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/4;
260: tcp_sendseqinit(tp);
261: error = tcp_output(tp);
262: break;
263:
264: /*
265: * Create a TCP connection between two sockets.
266: */
267: case PRU_CONNECT2:
268: error = EOPNOTSUPP;
269: break;
270:
271: /*
272: * Initiate disconnect from peer.
273: * If connection never passed embryonic stage, just drop;
274: * else if don't need to let data drain, then can just drop anyways,
275: * else have to begin TCP shutdown process: mark socket disconnecting,
276: * drain unread data, state switch to reflect user close, and
277: * send segment (e.g. FIN) to peer. Socket will be really disconnected
278: * when peer sends FIN and acks ours.
279: *
280: * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
281: */
282: case PRU_DISCONNECT:
283: tp = tcp_disconnect(tp);
284: break;
285:
286: /*
287: * Accept a connection. Essentially all the work is
288: * done at higher levels; just return the address
289: * of the peer, storing through addr.
290: */
291: case PRU_ACCEPT:
292: in_setpeeraddr(inp, nam);
293: break;
294:
295: /*
296: * Mark the connection as being incapable of further output.
297: */
298: case PRU_SHUTDOWN:
299: socantsendmore(so);
300: tp = tcp_usrclosed(tp);
301: if (tp)
302: error = tcp_output(tp);
303: break;
304:
305: /*
306: * After a receive, possibly send window update to peer.
307: */
308: case PRU_RCVD:
309: (void) tcp_output(tp);
310: break;
311:
312: /*
313: * Do a send by putting data in output queue and updating urgent
314: * marker if URG set. Possibly send more data.
315: */
316: case PRU_SEND:
317: sbappend(&so->so_snd, m);
318: error = tcp_output(tp);
319: break;
320:
321: /*
322: * Abort the TCP.
323: */
324: case PRU_ABORT:
325: tp = tcp_drop(tp, ECONNABORTED);
326: break;
327:
328: case PRU_SENSE:
329: ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
330: (void) splx(s);
331: return (0);
332:
333: case PRU_RCVOOB:
334: if ((so->so_oobmark == 0 &&
335: (so->so_state & SS_RCVATMARK) == 0) ||
336: so->so_options & SO_OOBINLINE ||
337: tp->t_oobflags & TCPOOB_HADDATA) {
338: error = EINVAL;
339: break;
340: }
341: if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
342: error = EWOULDBLOCK;
343: break;
344: }
345: m->m_len = 1;
346: *mtod(m, caddr_t) = tp->t_iobc;
347: if (((int)nam & MSG_PEEK) == 0)
348: tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
349: break;
350:
351: case PRU_SENDOOB:
352: if (sbspace(&so->so_snd) < -512) {
353: m_freem(m);
354: error = ENOBUFS;
355: break;
356: }
357: /*
358: * According to RFC961 (Assigned Protocols),
359: * the urgent pointer points to the last octet
360: * of urgent data. We continue, however,
361: * to consider it to indicate the first octet
362: * of data past the urgent section.
363: * Otherwise, snd_up should be one lower.
364: */
365: sbappend(&so->so_snd, m);
366: tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
367: tp->t_force = 1;
368: error = tcp_output(tp);
369: tp->t_force = 0;
370: break;
371:
372: case PRU_SOCKADDR:
373: in_setsockaddr(inp, nam);
374: break;
375:
376: case PRU_PEERADDR:
377: in_setpeeraddr(inp, nam);
378: break;
379:
380: /*
381: * TCP slow timer went off; going through this
382: * routine for tracing's sake.
383: */
384: case PRU_SLOWTIMO:
385: tp = tcp_timers(tp, (int)nam);
386: req |= (int)nam << 8; /* for debug's sake */
387: break;
388:
389: default:
390: panic("tcp_usrreq");
391: }
392: if (tp && (so->so_options & SO_DEBUG))
393: tcp_trace(TA_USER, ostate, tp, (struct tcpiphdr *)0, req);
394: splx(s);
395: return (error);
396: }
397:
398: int
399: tcp_ctloutput(op, so, level, optname, mp)
400: int op;
401: struct socket *so;
402: int level, optname;
403: struct mbuf **mp;
404: {
405: int error = 0, s;
406: struct inpcb *inp;
407: register struct tcpcb *tp;
408: register struct mbuf *m;
409: register int i;
410:
411: s = splnet();
412: inp = sotoinpcb(so);
413: if (inp == NULL) {
414: splx(s);
415: if (op == PRCO_SETOPT && *mp)
416: (void) m_free(*mp);
417: return (ECONNRESET);
418: }
419: if (level != IPPROTO_TCP) {
420: error = ip_ctloutput(op, so, level, optname, mp);
421: splx(s);
422: return (error);
423: }
424: tp = intotcpcb(inp);
425:
426: switch (op) {
427:
428: case PRCO_SETOPT:
429: m = *mp;
430: switch (optname) {
431:
432: case TCP_NODELAY:
433: if (m == NULL || m->m_len < sizeof (int))
434: error = EINVAL;
435: else if (*mtod(m, int *))
436: tp->t_flags |= TF_NODELAY;
437: else
438: tp->t_flags &= ~TF_NODELAY;
439: break;
440:
441: case TCP_MAXSEG:
442: if (m && (i = *mtod(m, int *)) > 0 && i <= tp->t_maxseg)
443: tp->t_maxseg = i;
444: else
445: error = EINVAL;
446: break;
447:
448: default:
449: error = ENOPROTOOPT;
450: break;
451: }
452: if (m)
453: (void) m_free(m);
454: break;
455:
456: case PRCO_GETOPT:
457: *mp = m = m_get(M_WAIT, MT_SOOPTS);
458: m->m_len = sizeof(int);
459:
460: switch (optname) {
461: case TCP_NODELAY:
462: *mtod(m, int *) = tp->t_flags & TF_NODELAY;
463: break;
464: case TCP_MAXSEG:
465: *mtod(m, int *) = tp->t_maxseg;
466: break;
467: default:
468: error = ENOPROTOOPT;
469: break;
470: }
471: break;
472: }
473: splx(s);
474: return (error);
475: }
476:
477: u_long tcp_sendspace = 1024*8;
478: u_long tcp_recvspace = 1024*8;
479:
480: /*
481: * Attach TCP protocol to socket, allocating
482: * internet protocol control block, tcp control block,
483: * bufer space, and entering LISTEN state if to accept connections.
484: */
485: int
486: tcp_attach(so)
487: struct socket *so;
488: {
489: register struct tcpcb *tp;
490: struct inpcb *inp;
491: int error;
492:
493: if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
494: error = soreserve(so, tcp_sendspace, tcp_recvspace);
495: if (error)
496: return (error);
497: }
498:
499: error = in_pcballoc(so, &tcb, &tcp_hash_str, &tcp_lport_hash_str);
500: if (error)
501: return (error);
502:
503: inp = sotoinpcb(so);
504: tp = tcp_newtcpcb(inp);
505: if (tp == 0) {
506: int nofd = so->so_state & SS_NOFDREF; /* XXX */
507:
508: so->so_state &= ~SS_NOFDREF; /* don't free the socket yet */
509: in_pcbdetach(inp);
510: so->so_state |= nofd;
511: return (ENOBUFS);
512: }
513: tp->t_state = TCPS_CLOSED;
514: return (0);
515: }
516:
517: /*
518: * Initiate (or continue) disconnect.
519: * If embryonic state, just send reset (once).
520: * If in ``let data drain'' option and linger null, just drop.
521: * Otherwise (hard), mark socket disconnecting and drop
522: * current input data; switch states based on user close, and
523: * send segment to peer (with FIN).
524: */
525: struct tcpcb *
526: tcp_disconnect(tp)
527: register struct tcpcb *tp;
528: {
529: struct socket *so = tp->t_inpcb->inp_socket;
530:
531: #if TEMPDEBUG
532: printf("TCP_DISCONNECT called for socket %x\n", so);
533: #endif
534:
535: if (tp->t_state < TCPS_ESTABLISHED)
536: tp = tcp_close(tp);
537: else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
538: tp = tcp_drop(tp, 0);
539: else {
540: soisdisconnecting(so);
541: sbflush(&so->so_rcv);
542: tp = tcp_usrclosed(tp);
543: if (tp)
544: (void) tcp_output(tp);
545: }
546: return (tp);
547: }
548:
549: /*
550: * User issued close, and wish to trail through shutdown states:
551: * if never received SYN, just forget it. If got a SYN from peer,
552: * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
553: * If already got a FIN from peer, then almost done; go to LAST_ACK
554: * state. In all other cases, have already sent FIN to peer (e.g.
555: * after PRU_SHUTDOWN), and just have to play tedious game waiting
556: * for peer to send FIN or not respond to keep-alives, etc.
557: * We can let the user exit from the close as soon as the FIN is acked.
558: */
559: struct tcpcb *
560: tcp_usrclosed(tp)
561: register struct tcpcb *tp;
562: {
563:
564: switch (tp->t_state) {
565:
566: case TCPS_CLOSED:
567: case TCPS_LISTEN:
568: case TCPS_SYN_SENT:
569: tp->t_state = TCPS_CLOSED;
570: #if TEMPDEBUG
571: printf("TCP_USRCLOSED called for embryonic connection for socket %x\n",
572: tp->t_inpcb->inp_socket);
573: #endif
574: tp = tcp_close(tp);
575: break;
576:
577: case TCPS_SYN_RECEIVED:
578: case TCPS_ESTABLISHED:
579: #if DELACK_BITMASK_ON
580: current_active_connections--;
581: #endif
582: tp->t_state = TCPS_FIN_WAIT_1;
583: break;
584:
585: case TCPS_CLOSE_WAIT:
586: tp->t_state = TCPS_LAST_ACK;
587: break;
588: }
589: if (tp && tp->t_state >= TCPS_FIN_WAIT_2)
590: soisdisconnected(tp->t_inpcb->inp_socket);
591: return (tp);
592: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.