![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src / slirp|
Return to tcp_input.c CVS log | Up to [Previous NeXT emulator] / previous / src / slirp |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994
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. Neither the name of the University nor the names of its contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: *
29: * @(#)tcp_input.c 8.5 (Berkeley) 4/10/94
30: * tcp_input.c,v 1.10 1994/10/13 18:36:32 wollman Exp
31: */
32:
33: /*
34: * Changes and additions relating to SLiRP
35: * Copyright (c) 1995 Danny Gasparovski.
36: *
37: * Please read the file COPYRIGHT for the
38: * terms and conditions of the copyright.
39: */
40:
41: #include <stdlib.h>
42: #include <slirp.h>
43: #include "ip_icmp.h"
44:
45: struct socket tcb;
46:
47: int tcprexmtthresh = 3;
48: struct socket *tcp_last_so = &tcb;
49:
50: tcp_seq tcp_iss; /* tcp initial send seq # */
51:
52: #define TCP_PAWS_IDLE (24 * 24 * 60 * 60 * PR_SLOWHZ)
53:
54: /* for modulo comparisons of timestamps */
55: #define TSTMP_LT(a,b) ((int)((a)-(b)) < 0)
56: #define TSTMP_GEQ(a,b) ((int)((a)-(b)) >= 0)
57:
58: /*
59: * Insert segment ti into reassembly queue of tcp with
60: * control block tp. Return TH_FIN if reassembly now includes
61: * a segment with FIN. The macro form does the common case inline
62: * (segment is the next to be received on an established connection,
63: * and the queue is empty), avoiding linkage into and removal
64: * from the queue and repetition of various conversions.
65: * Set DELACK for segments received in order, but ack immediately
66: * when segments are out of order (so fast retransmit can work).
67: */
68: #ifdef TCP_ACK_HACK
69: #define TCP_REASS(tp, ti, m, so, flags) {\
70: if ((ti)->ti_seq == (tp)->rcv_nxt && \
71: tcpfrag_list_empty(tp) && \
72: (tp)->t_state == TCPS_ESTABLISHED) {\
73: if (ti->ti_flags & TH_PUSH) \
74: tp->t_flags |= TF_ACKNOW; \
75: else \
76: tp->t_flags |= TF_DELACK; \
77: (tp)->rcv_nxt += (ti)->ti_len; \
78: flags = (ti)->ti_flags & TH_FIN; \
79: tcpstat.tcps_rcvpack++;\
80: tcpstat.tcps_rcvbyte += (ti)->ti_len;\
81: if (so->so_emu) { \
82: if (tcp_emu((so),(m))) sbappend((so), (m)); \
83: } else \
84: sbappend((so), (m)); \
85: /* sorwakeup(so); */ \
86: } else {\
87: (flags) = tcp_reass((tp), (ti), (m)); \
88: tp->t_flags |= TF_ACKNOW; \
89: } \
90: }
91: #else
92: #define TCP_REASS(tp, ti, m, so, flags) { \
93: if ((ti)->ti_seq == (tp)->rcv_nxt && \
94: tcpfrag_list_empty(tp) && \
95: (tp)->t_state == TCPS_ESTABLISHED) { \
96: tp->t_flags |= TF_DELACK; \
97: (tp)->rcv_nxt += (ti)->ti_len; \
98: flags = (ti)->ti_flags & TH_FIN; \
99: tcpstat.tcps_rcvpack++;\
100: tcpstat.tcps_rcvbyte += (ti)->ti_len;\
101: if (so->so_emu) { \
102: if (tcp_emu((so),(m))) sbappend(so, (m)); \
103: } else \
104: sbappend((so), (m)); \
105: /* sorwakeup(so); */ \
106: } else { \
107: (flags) = tcp_reass((tp), (ti), (m)); \
108: tp->t_flags |= TF_ACKNOW; \
109: } \
110: }
111: #endif
112:
113: int
114: tcp_reass(tp, ti, m)
115: register struct tcpcb *tp;
116: register struct tcpiphdr *ti;
117: struct mbuf *m;
118: {
119: register struct tcpiphdr *q;
120: struct socket *so = tp->t_socket;
121: int flags;
122:
123: /*
124: * Call with ti==0 after become established to
125: * force pre-ESTABLISHED data up to user socket.
126: */
127: if (ti == 0)
128: goto present;
129:
130: /*
131: * Find a segment which begins after this one does.
132: */
133: for (q = tcpfrag_list_first(tp); !tcpfrag_list_end(q, tp);
134: q = tcpiphdr_next(q))
135: if (SEQ_GT(q->ti_seq, ti->ti_seq))
136: break;
137:
138: /*
139: * If there is a preceding segment, it may provide some of
140: * our data already. If so, drop the data from the incoming
141: * segment. If it provides all of our data, drop us.
142: */
143: if (!tcpfrag_list_end(tcpiphdr_prev(q), tp)) {
144: register int i;
145: q = tcpiphdr_prev(q);
146: /* conversion to int (in i) handles seq wraparound */
147: i = q->ti_seq + q->ti_len - ti->ti_seq;
148: if (i > 0) {
149: if (i >= ti->ti_len) {
150: tcpstat.tcps_rcvduppack++;
151: tcpstat.tcps_rcvdupbyte += ti->ti_len;
152: m_freem(m);
153: /*
154: * Try to present any queued data
155: * at the left window edge to the user.
156: * This is needed after the 3-WHS
157: * completes.
158: */
159: goto present; /* ??? */
160: }
161: m_adj(m, i);
162: ti->ti_len -= i;
163: ti->ti_seq += i;
164: }
165: q = tcpiphdr_next(q);
166: }
167: tcpstat.tcps_rcvoopack++;
168: tcpstat.tcps_rcvoobyte += ti->ti_len;
169: ti->ti_mbuf = m;
170:
171: /*
172: * While we overlap succeeding segments trim them or,
173: * if they are completely covered, dequeue them.
174: */
175: while (!tcpfrag_list_end(q, tp)) {
176: register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
177: if (i <= 0)
178: break;
179: if (i < q->ti_len) {
180: q->ti_seq += i;
181: q->ti_len -= i;
182: m_adj(q->ti_mbuf, i);
183: break;
184: }
185: q = tcpiphdr_next(q);
186: m = tcpiphdr_prev(q)->ti_mbuf;
187: remque(tcpiphdr2qlink(tcpiphdr_prev(q)));
188: m_freem(m);
189: }
190:
191: /*
192: * Stick new segment in its place.
193: */
194: insque(tcpiphdr2qlink(ti), tcpiphdr2qlink(tcpiphdr_prev(q)));
195: present:
196: /*
197: * Present data to user, advancing rcv_nxt through
198: * completed sequence space.
199: */
200: if (!TCPS_HAVEESTABLISHED(tp->t_state))
201: return (0);
202: ti = tcpfrag_list_first(tp);
203: if (tcpfrag_list_end(ti, tp) || ti->ti_seq != tp->rcv_nxt)
204: return (0);
205: if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
206: return (0);
207: do {
208: tp->rcv_nxt += ti->ti_len;
209: flags = ti->ti_flags & TH_FIN;
210: remque(tcpiphdr2qlink(ti));
211: m = ti->ti_mbuf;
212: ti = tcpiphdr_next(ti);
213: /* if (so->so_state & SS_FCANTRCVMORE) */
214: if (so->so_state & SS_FCANTSENDMORE)
215: m_freem(m);
216: else {
217: if (so->so_emu) {
218: if (tcp_emu(so,m)) sbappend(so, m);
219: } else
220: sbappend(so, m);
221: }
222: } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
223: /* sorwakeup(so); */
224: return (flags);
225: }
226:
227: /*
228: * TCP input routine, follows pages 65-76 of the
229: * protocol specification dated September, 1981 very closely.
230: */
231: void
232: tcp_input(m, iphlen, inso)
233: register struct mbuf *m;
234: int iphlen;
235: struct socket *inso;
236: {
237: struct ip save_ip, *ip;
238: register struct tcpiphdr *ti;
239: caddr_t optp = NULL;
240: int optlen = 0;
241: int len, tlen, off;
242: register struct tcpcb *tp = 0;
243: register int tiflags;
244: struct socket *so = 0;
245: int todrop, acked, ourfinisacked, needoutput = 0;
246: /* int dropsocket = 0; */
247: int iss = 0;
248: u_long tiwin;
249: int ret;
250: /* int ts_present = 0; */
251:
252: DEBUG_CALL("tcp_input");
253: DEBUG_ARGS((dfd," m = %8lx iphlen = %2d inso = %lx\n",
254: (long )m, iphlen, (long )inso ));
255:
256: /*
257: * If called with m == 0, then we're continuing the connect
258: */
259: if (m == NULL) {
260: so = inso;
261:
262: /* Re-set a few variables */
263: tp = sototcpcb(so);
264: m = so->so_m;
265: so->so_m = 0;
266: ti = so->so_ti;
267: tiwin = ti->ti_win;
268: tiflags = ti->ti_flags;
269:
270: goto cont_conn;
271: }
272:
273:
274: tcpstat.tcps_rcvtotal++;
275: /*
276: * Get IP and TCP header together in first mbuf.
277: * Note: IP leaves IP header in first mbuf.
278: */
279: ti = mtod(m, struct tcpiphdr *);
280: if (iphlen > sizeof(struct ip )) {
281: ip_stripoptions(m, (struct mbuf *)0);
282: iphlen=sizeof(struct ip );
283: }
284: /* XXX Check if too short */
285:
286:
287: /*
288: * Save a copy of the IP header in case we want restore it
289: * for sending an ICMP error message in response.
290: */
291: ip=mtod(m, struct ip *);
292: save_ip = *ip;
293: save_ip.ip_len+= iphlen;
294:
295: /*
296: * Checksum extended TCP header and data.
297: */
298: tlen = ((struct ip *)ti)->ip_len;
299: tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = 0;
300: memset(&ti->ti_i.ih_mbuf, 0 , sizeof(struct mbuf_ptr));
301: ti->ti_x1 = 0;
302: ti->ti_len = htons((u_int16_t)tlen);
303: len = sizeof(struct ip ) + tlen;
304: /* keep checksum for ICMP reply
305: * ti->ti_sum = cksum(m, len);
306: * if (ti->ti_sum) { */
307: if(cksum(m, len)) {
308: tcpstat.tcps_rcvbadsum++;
309: goto drop;
310: }
311:
312: /*
313: * Check that TCP offset makes sense,
314: * pull out TCP options and adjust length. XXX
315: */
316: off = ti->ti_off << 2;
317: if (off < sizeof (struct tcphdr) || off > tlen) {
318: tcpstat.tcps_rcvbadoff++;
319: goto drop;
320: }
321: tlen -= off;
322: ti->ti_len = tlen;
323: if (off > sizeof (struct tcphdr)) {
324: optlen = off - sizeof (struct tcphdr);
325: optp = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
326:
327: /*
328: * Do quick retrieval of timestamp options ("options
329: * prediction?"). If timestamp is the only option and it's
330: * formatted as recommended in RFC 1323 appendix A, we
331: * quickly get the values now and not bother calling
332: * tcp_dooptions(), etc.
333: */
334: /* if ((optlen == TCPOLEN_TSTAMP_APPA ||
335: * (optlen > TCPOLEN_TSTAMP_APPA &&
336: * optp[TCPOLEN_TSTAMP_APPA] == TCPOPT_EOL)) &&
337: * *(u_int32_t *)optp == htonl(TCPOPT_TSTAMP_HDR) &&
338: * (ti->ti_flags & TH_SYN) == 0) {
339: * ts_present = 1;
340: * ts_val = ntohl(*(u_int32_t *)(optp + 4));
341: * ts_ecr = ntohl(*(u_int32_t *)(optp + 8));
342: * optp = NULL; / * we've parsed the options * /
343: * }
344: */
345: }
346: tiflags = ti->ti_flags;
347:
348: /*
349: * Convert TCP protocol specific fields to host format.
350: */
351: NTOHL(ti->ti_seq);
352: NTOHL(ti->ti_ack);
353: NTOHS(ti->ti_win);
354: NTOHS(ti->ti_urp);
355:
356: /*
357: * Drop TCP, IP headers and TCP options.
358: */
359: m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
360: m->m_len -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
361:
362: /*
363: * Locate pcb for segment.
364: */
365: findso:
366: so = tcp_last_so;
367: if (so->so_fport != ti->ti_dport ||
368: so->so_lport != ti->ti_sport ||
369: so->so_laddr.s_addr != ti->ti_src.s_addr ||
370: so->so_faddr.s_addr != ti->ti_dst.s_addr) {
371: so = solookup(&tcb, ti->ti_src, ti->ti_sport,
372: ti->ti_dst, ti->ti_dport);
373: if (so)
374: tcp_last_so = so;
375: ++tcpstat.tcps_socachemiss;
376: }
377:
378: /*
379: * If the state is CLOSED (i.e., TCB does not exist) then
380: * all data in the incoming segment is discarded.
381: * If the TCB exists but is in CLOSED state, it is embryonic,
382: * but should either do a listen or a connect soon.
383: *
384: * state == CLOSED means we've done socreate() but haven't
385: * attached it to a protocol yet...
386: *
387: * XXX If a TCB does not exist, and the TH_SYN flag is
388: * the only flag set, then create a session, mark it
389: * as if it was LISTENING, and continue...
390: */
391: if (so == 0) {
392: if ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)
393: goto dropwithreset;
394:
395: if ((so = socreate()) == NULL)
396: goto dropwithreset;
397: if (tcp_attach(so) < 0) {
398: free(so); /* Not sofree (if it failed, it's not insqued) */
399: goto dropwithreset;
400: }
401:
402: sbreserve(&so->so_snd, tcp_sndspace);
403: sbreserve(&so->so_rcv, tcp_rcvspace);
404:
405: /* tcp_last_so = so; */ /* XXX ? */
406: /* tp = sototcpcb(so); */
407:
408: so->so_laddr = ti->ti_src;
409: so->so_lport = ti->ti_sport;
410: so->so_faddr = ti->ti_dst;
411: so->so_fport = ti->ti_dport;
412:
413: if ((so->so_iptos = tcp_tos(so)) == 0)
414: so->so_iptos = ((struct ip *)ti)->ip_tos;
415:
416: tp = sototcpcb(so);
417: tp->t_state = TCPS_LISTEN;
418: }
419:
420: /*
421: * If this is a still-connecting socket, this probably
422: * a retransmit of the SYN. Whether it's a retransmit SYN
423: * or something else, we nuke it.
424: */
425: if (so->so_state & SS_ISFCONNECTING)
426: goto drop;
427:
428: tp = sototcpcb(so);
429:
430: /* XXX Should never fail */
431: if (tp == 0)
432: goto dropwithreset;
433: if (tp->t_state == TCPS_CLOSED)
434: goto drop;
435:
436: /* Unscale the window into a 32-bit value. */
437: /* if ((tiflags & TH_SYN) == 0)
438: * tiwin = ti->ti_win << tp->snd_scale;
439: * else
440: */
441: tiwin = ti->ti_win;
442:
443: /*
444: * Segment received on connection.
445: * Reset idle time and keep-alive timer.
446: */
447: tp->t_idle = 0;
448: if (so_options)
449: tp->t_timer[TCPT_KEEP] = tcp_keepintvl;
450: else
451: tp->t_timer[TCPT_KEEP] = tcp_keepidle;
452:
453: /*
454: * Process options if not in LISTEN state,
455: * else do it below (after getting remote address).
456: */
457: if (optp && tp->t_state != TCPS_LISTEN)
458: tcp_dooptions(tp, (u_char *)optp, optlen, ti);
459: /* , */
460: /* &ts_present, &ts_val, &ts_ecr); */
461:
462: /*
463: * Header prediction: check for the two common cases
464: * of a uni-directional data xfer. If the packet has
465: * no control flags, is in-sequence, the window didn't
466: * change and we're not retransmitting, it's a
467: * candidate. If the length is zero and the ack moved
468: * forward, we're the sender side of the xfer. Just
469: * free the data acked & wake any higher level process
470: * that was blocked waiting for space. If the length
471: * is non-zero and the ack didn't move, we're the
472: * receiver side. If we're getting packets in-order
473: * (the reassembly queue is empty), add the data to
474: * the socket buffer and note that we need a delayed ack.
475: *
476: * XXX Some of these tests are not needed
477: * eg: the tiwin == tp->snd_wnd prevents many more
478: * predictions.. with no *real* advantage..
479: */
480: if (tp->t_state == TCPS_ESTABLISHED &&
481: (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
482: /* (!ts_present || TSTMP_GEQ(ts_val, tp->ts_recent)) && */
483: ti->ti_seq == tp->rcv_nxt &&
484: tiwin && tiwin == tp->snd_wnd &&
485: tp->snd_nxt == tp->snd_max) {
486: /*
487: * If last ACK falls within this segment's sequence numbers,
488: * record the timestamp.
489: */
490: /* if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent) &&
491: * SEQ_LT(tp->last_ack_sent, ti->ti_seq + ti->ti_len)) {
492: * tp->ts_recent_age = tcp_now;
493: * tp->ts_recent = ts_val;
494: * }
495: */
496: if (ti->ti_len == 0) {
497: if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
498: SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
499: tp->snd_cwnd >= tp->snd_wnd) {
500: /*
501: * this is a pure ack for outstanding data.
502: */
503: ++tcpstat.tcps_predack;
504: /* if (ts_present)
505: * tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
506: * else
507: */ if (tp->t_rtt &&
508: SEQ_GT(ti->ti_ack, tp->t_rtseq))
509: tcp_xmit_timer(tp, tp->t_rtt);
510: acked = ti->ti_ack - tp->snd_una;
511: tcpstat.tcps_rcvackpack++;
512: tcpstat.tcps_rcvackbyte += acked;
513: sbdrop(&so->so_snd, acked);
514: tp->snd_una = ti->ti_ack;
515: m_freem(m);
516:
517: /*
518: * If all outstanding data are acked, stop
519: * retransmit timer, otherwise restart timer
520: * using current (possibly backed-off) value.
521: * If process is waiting for space,
522: * wakeup/selwakeup/signal. If data
523: * are ready to send, let tcp_output
524: * decide between more output or persist.
525: */
526: if (tp->snd_una == tp->snd_max)
527: tp->t_timer[TCPT_REXMT] = 0;
528: else if (tp->t_timer[TCPT_PERSIST] == 0)
529: tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
530:
531: /*
532: * There's room in so_snd, sowwakup will read()
533: * from the socket if we can
534: */
535: /* if (so->so_snd.sb_flags & SB_NOTIFY)
536: * sowwakeup(so);
537: */
538: /*
539: * This is called because sowwakeup might have
540: * put data into so_snd. Since we don't so sowwakeup,
541: * we don't need this.. XXX???
542: */
543: if (so->so_snd.sb_cc)
544: (void) tcp_output(tp);
545:
546: return;
547: }
548: } else if (ti->ti_ack == tp->snd_una &&
549: tcpfrag_list_empty(tp) &&
550: ti->ti_len <= sbspace(&so->so_rcv)) {
551: /*
552: * this is a pure, in-sequence data packet
553: * with nothing on the reassembly queue and
554: * we have enough buffer space to take it.
555: */
556: ++tcpstat.tcps_preddat;
557: tp->rcv_nxt += ti->ti_len;
558: tcpstat.tcps_rcvpack++;
559: tcpstat.tcps_rcvbyte += ti->ti_len;
560: /*
561: * Add data to socket buffer.
562: */
563: if (so->so_emu) {
564: if (tcp_emu(so,m)) sbappend(so, m);
565: } else
566: sbappend(so, m);
567:
568: /*
569: * XXX This is called when data arrives. Later, check
570: * if we can actually write() to the socket
571: * XXX Need to check? It's be NON_BLOCKING
572: */
573: /* sorwakeup(so); */
574:
575: /*
576: * If this is a short packet, then ACK now - with Nagel
577: * congestion avoidance sender won't send more until
578: * he gets an ACK.
579: *
580: * It is better to not delay acks at all to maximize
581: * TCP throughput. See RFC 2581.
582: */
583: tp->t_flags |= TF_ACKNOW;
584: tcp_output(tp);
585: return;
586: }
587: } /* header prediction */
588: /*
589: * Calculate amount of space in receive window,
590: * and then do TCP input processing.
591: * Receive window is amount of space in rcv queue,
592: * but not less than advertised window.
593: */
594: { int win;
595: win = sbspace(&so->so_rcv);
596: if (win < 0)
597: win = 0;
598: tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
599: }
600:
601: switch (tp->t_state) {
602:
603: /*
604: * If the state is LISTEN then ignore segment if it contains an RST.
605: * If the segment contains an ACK then it is bad and send a RST.
606: * If it does not contain a SYN then it is not interesting; drop it.
607: * Don't bother responding if the destination was a broadcast.
608: * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
609: * tp->iss, and send a segment:
610: * <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
611: * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
612: * Fill in remote peer address fields if not previously specified.
613: * Enter SYN_RECEIVED state, and process any other fields of this
614: * segment in this state.
615: */
616: case TCPS_LISTEN: {
617:
618: if (tiflags & TH_RST)
619: goto drop;
620: if (tiflags & TH_ACK)
621: goto dropwithreset;
622: if ((tiflags & TH_SYN) == 0)
623: goto drop;
624:
625: /*
626: * This has way too many gotos...
627: * But a bit of spaghetti code never hurt anybody :)
628: */
629:
630: /*
631: * If this is destined for the control address, then flag to
632: * tcp_ctl once connected, otherwise connect
633: */
634: if ((so->so_faddr.s_addr&htonl(0xffffff00)) == special_addr.s_addr) {
635: int lastbyte=ntohl(so->so_faddr.s_addr) & 0xff;
636: if (lastbyte!=CTL_ALIAS && lastbyte!=CTL_DNS) {
637: #if 0
638: if(lastbyte==CTL_CMD || lastbyte==CTL_EXEC) {
639: /* Command or exec adress */
640: so->so_state |= SS_CTL;
641: } else
642: #endif
643: {
644: /* May be an add exec */
645: struct ex_list *ex_ptr;
646: for(ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
647: if(ex_ptr->ex_fport == so->so_fport &&
648: lastbyte == ex_ptr->ex_addr) {
649: so->so_state |= SS_CTL;
650: break;
651: }
652: }
653: }
654: if(so->so_state & SS_CTL) goto cont_input;
655: }
656: /* CTL_ALIAS: Do nothing, tcp_fconnect will be called on it */
657: }
658:
659: if (so->so_emu & EMU_NOCONNECT) {
660: so->so_emu &= ~EMU_NOCONNECT;
661: goto cont_input;
662: }
663:
664: if((tcp_fconnect(so) == -1) && (errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {
665: u_char code=ICMP_UNREACH_NET;
666: DEBUG_MISC((dfd," tcp fconnect errno = %d-%s\n",
667: errno,strerror(errno)));
668: if(errno == ECONNREFUSED) {
669: /* ACK the SYN, send RST to refuse the connection */
670: tcp_respond(tp, ti, m, ti->ti_seq+1, (tcp_seq)0,
671: TH_RST|TH_ACK);
672: } else {
673: if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
674: HTONL(ti->ti_seq); /* restore tcp header */
675: HTONL(ti->ti_ack);
676: HTONS(ti->ti_win);
677: HTONS(ti->ti_urp);
678: m->m_data -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
679: m->m_len += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
680: *ip=save_ip;
681: icmp_error(m, ICMP_UNREACH,code, 0,strerror(errno));
682: }
683: tp = tcp_close(tp);
684: m_free(m);
685: } else {
686: /*
687: * Haven't connected yet, save the current mbuf
688: * and ti, and return
689: * XXX Some OS's don't tell us whether the connect()
690: * succeeded or not. So we must time it out.
691: */
692: so->so_m = m;
693: so->so_ti = ti;
694: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
695: tp->t_state = TCPS_SYN_RECEIVED;
696: }
697: return;
698:
699: cont_conn:
700: /* m==NULL
701: * Check if the connect succeeded
702: */
703: if (so->so_state & SS_NOFDREF) {
704: tp = tcp_close(tp);
705: goto dropwithreset;
706: }
707: cont_input:
708: tcp_template(tp);
709:
710: if (optp)
711: tcp_dooptions(tp, (u_char *)optp, optlen, ti);
712: /* , */
713: /* &ts_present, &ts_val, &ts_ecr); */
714:
715: if (iss)
716: tp->iss = iss;
717: else
718: tp->iss = tcp_iss;
719: tcp_iss += TCP_ISSINCR/2;
720: tp->irs = ti->ti_seq;
721: tcp_sendseqinit(tp);
722: tcp_rcvseqinit(tp);
723: tp->t_flags |= TF_ACKNOW;
724: tp->t_state = TCPS_SYN_RECEIVED;
725: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
726: tcpstat.tcps_accepts++;
727: goto trimthenstep6;
728: } /* case TCPS_LISTEN */
729:
730: /*
731: * If the state is SYN_SENT:
732: * if seg contains an ACK, but not for our SYN, drop the input.
733: * if seg contains a RST, then drop the connection.
734: * if seg does not contain SYN, then drop it.
735: * Otherwise this is an acceptable SYN segment
736: * initialize tp->rcv_nxt and tp->irs
737: * if seg contains ack then advance tp->snd_una
738: * if SYN has been acked change to ESTABLISHED else SYN_RCVD state
739: * arrange for segment to be acked (eventually)
740: * continue processing rest of data/controls, beginning with URG
741: */
742: case TCPS_SYN_SENT:
743: if ((tiflags & TH_ACK) &&
744: (SEQ_LEQ(ti->ti_ack, tp->iss) ||
745: SEQ_GT(ti->ti_ack, tp->snd_max)))
746: goto dropwithreset;
747:
748: if (tiflags & TH_RST) {
749: if (tiflags & TH_ACK)
750: tp = tcp_drop(tp,0); /* XXX Check t_softerror! */
751: goto drop;
752: }
753:
754: if ((tiflags & TH_SYN) == 0)
755: goto drop;
756: if (tiflags & TH_ACK) {
757: tp->snd_una = ti->ti_ack;
758: if (SEQ_LT(tp->snd_nxt, tp->snd_una))
759: tp->snd_nxt = tp->snd_una;
760: }
761:
762: tp->t_timer[TCPT_REXMT] = 0;
763: tp->irs = ti->ti_seq;
764: tcp_rcvseqinit(tp);
765: tp->t_flags |= TF_ACKNOW;
766: if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
767: tcpstat.tcps_connects++;
768: soisfconnected(so);
769: tp->t_state = TCPS_ESTABLISHED;
770:
771: /* Do window scaling on this connection? */
772: /* if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
773: * (TF_RCVD_SCALE|TF_REQ_SCALE)) {
774: * tp->snd_scale = tp->requested_s_scale;
775: * tp->rcv_scale = tp->request_r_scale;
776: * }
777: */
778: (void) tcp_reass(tp, (struct tcpiphdr *)0,
779: (struct mbuf *)0);
780: /*
781: * if we didn't have to retransmit the SYN,
782: * use its rtt as our initial srtt & rtt var.
783: */
784: if (tp->t_rtt)
785: tcp_xmit_timer(tp, tp->t_rtt);
786: } else
787: tp->t_state = TCPS_SYN_RECEIVED;
788:
789: trimthenstep6:
790: /*
791: * Advance ti->ti_seq to correspond to first data byte.
792: * If data, trim to stay within window,
793: * dropping FIN if necessary.
794: */
795: ti->ti_seq++;
796: if (ti->ti_len > tp->rcv_wnd) {
797: todrop = ti->ti_len - tp->rcv_wnd;
798: m_adj(m, -todrop);
799: ti->ti_len = tp->rcv_wnd;
800: tiflags &= ~TH_FIN;
801: tcpstat.tcps_rcvpackafterwin++;
802: tcpstat.tcps_rcvbyteafterwin += todrop;
803: }
804: tp->snd_wl1 = ti->ti_seq - 1;
805: tp->rcv_up = ti->ti_seq;
806: goto step6;
807: } /* switch tp->t_state */
808: /*
809: * States other than LISTEN or SYN_SENT.
810: * First check timestamp, if present.
811: * Then check that at least some bytes of segment are within
812: * receive window. If segment begins before rcv_nxt,
813: * drop leading data (and SYN); if nothing left, just ack.
814: *
815: * RFC 1323 PAWS: If we have a timestamp reply on this segment
816: * and it's less than ts_recent, drop it.
817: */
818: /* if (ts_present && (tiflags & TH_RST) == 0 && tp->ts_recent &&
819: * TSTMP_LT(ts_val, tp->ts_recent)) {
820: *
821: */ /* Check to see if ts_recent is over 24 days old. */
822: /* if ((int)(tcp_now - tp->ts_recent_age) > TCP_PAWS_IDLE) {
823: */ /*
824: * * Invalidate ts_recent. If this segment updates
825: * * ts_recent, the age will be reset later and ts_recent
826: * * will get a valid value. If it does not, setting
827: * * ts_recent to zero will at least satisfy the
828: * * requirement that zero be placed in the timestamp
829: * * echo reply when ts_recent isn't valid. The
830: * * age isn't reset until we get a valid ts_recent
831: * * because we don't want out-of-order segments to be
832: * * dropped when ts_recent is old.
833: * */
834: /* tp->ts_recent = 0;
835: * } else {
836: * tcpstat.tcps_rcvduppack++;
837: * tcpstat.tcps_rcvdupbyte += ti->ti_len;
838: * tcpstat.tcps_pawsdrop++;
839: * goto dropafterack;
840: * }
841: * }
842: */
843:
844: todrop = tp->rcv_nxt - ti->ti_seq;
845: if (todrop > 0) {
846: if (tiflags & TH_SYN) {
847: tiflags &= ~TH_SYN;
848: ti->ti_seq++;
849: if (ti->ti_urp > 1)
850: ti->ti_urp--;
851: else
852: tiflags &= ~TH_URG;
853: todrop--;
854: }
855: /*
856: * Following if statement from Stevens, vol. 2, p. 960.
857: */
858: if (todrop > ti->ti_len
859: || (todrop == ti->ti_len && (tiflags & TH_FIN) == 0)) {
860: /*
861: * Any valid FIN must be to the left of the window.
862: * At this point the FIN must be a duplicate or out
863: * of sequence; drop it.
864: */
865: tiflags &= ~TH_FIN;
866:
867: /*
868: * Send an ACK to resynchronize and drop any data.
869: * But keep on processing for RST or ACK.
870: */
871: tp->t_flags |= TF_ACKNOW;
872: todrop = ti->ti_len;
873: tcpstat.tcps_rcvduppack++;
874: tcpstat.tcps_rcvdupbyte += todrop;
875: } else {
876: tcpstat.tcps_rcvpartduppack++;
877: tcpstat.tcps_rcvpartdupbyte += todrop;
878: }
879: m_adj(m, todrop);
880: ti->ti_seq += todrop;
881: ti->ti_len -= todrop;
882: if (ti->ti_urp > todrop)
883: ti->ti_urp -= todrop;
884: else {
885: tiflags &= ~TH_URG;
886: ti->ti_urp = 0;
887: }
888: }
889: /*
890: * If new data are received on a connection after the
891: * user processes are gone, then RST the other end.
892: */
893: if ((so->so_state & SS_NOFDREF) &&
894: tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
895: tp = tcp_close(tp);
896: tcpstat.tcps_rcvafterclose++;
897: goto dropwithreset;
898: }
899:
900: /*
901: * If segment ends after window, drop trailing data
902: * (and PUSH and FIN); if nothing left, just ACK.
903: */
904: todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
905: if (todrop > 0) {
906: tcpstat.tcps_rcvpackafterwin++;
907: if (todrop >= ti->ti_len) {
908: tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
909: /*
910: * If a new connection request is received
911: * while in TIME_WAIT, drop the old connection
912: * and start over if the sequence numbers
913: * are above the previous ones.
914: */
915: if (tiflags & TH_SYN &&
916: tp->t_state == TCPS_TIME_WAIT &&
917: SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
918: iss = tp->rcv_nxt + TCP_ISSINCR;
919: tp = tcp_close(tp);
920: goto findso;
921: }
922: /*
923: * If window is closed can only take segments at
924: * window edge, and have to drop data and PUSH from
925: * incoming segments. Continue processing, but
926: * remember to ack. Otherwise, drop segment
927: * and ack.
928: */
929: if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
930: tp->t_flags |= TF_ACKNOW;
931: tcpstat.tcps_rcvwinprobe++;
932: } else
933: goto dropafterack;
934: } else
935: tcpstat.tcps_rcvbyteafterwin += todrop;
936: m_adj(m, -todrop);
937: ti->ti_len -= todrop;
938: tiflags &= ~(TH_PUSH|TH_FIN);
939: }
940:
941: /*
942: * If last ACK falls within this segment's sequence numbers,
943: * record its timestamp.
944: */
945: /* if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent) &&
946: * SEQ_LT(tp->last_ack_sent, ti->ti_seq + ti->ti_len +
947: * ((tiflags & (TH_SYN|TH_FIN)) != 0))) {
948: * tp->ts_recent_age = tcp_now;
949: * tp->ts_recent = ts_val;
950: * }
951: */
952:
953: /*
954: * If the RST bit is set examine the state:
955: * SYN_RECEIVED STATE:
956: * If passive open, return to LISTEN state.
957: * If active open, inform user that connection was refused.
958: * ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
959: * Inform user that connection was reset, and close tcb.
960: * CLOSING, LAST_ACK, TIME_WAIT STATES
961: * Close the tcb.
962: */
963: if (tiflags&TH_RST) switch (tp->t_state) {
964:
965: case TCPS_SYN_RECEIVED:
966: /* so->so_error = ECONNREFUSED; */
967: goto close;
968:
969: case TCPS_ESTABLISHED:
970: case TCPS_FIN_WAIT_1:
971: case TCPS_FIN_WAIT_2:
972: case TCPS_CLOSE_WAIT:
973: /* so->so_error = ECONNRESET; */
974: close:
975: tp->t_state = TCPS_CLOSED;
976: tcpstat.tcps_drops++;
977: tp = tcp_close(tp);
978: goto drop;
979:
980: case TCPS_CLOSING:
981: case TCPS_LAST_ACK:
982: case TCPS_TIME_WAIT:
983: tp = tcp_close(tp);
984: goto drop;
985: }
986:
987: /*
988: * If a SYN is in the window, then this is an
989: * error and we send an RST and drop the connection.
990: */
991: if (tiflags & TH_SYN) {
992: tp = tcp_drop(tp,0);
993: goto dropwithreset;
994: }
995:
996: /*
997: * If the ACK bit is off we drop the segment and return.
998: */
999: if ((tiflags & TH_ACK) == 0) goto drop;
1000:
1001: /*
1002: * Ack processing.
1003: */
1004: switch (tp->t_state) {
1005: /*
1006: * In SYN_RECEIVED state if the ack ACKs our SYN then enter
1007: * ESTABLISHED state and continue processing, otherwise
1008: * send an RST. una<=ack<=max
1009: */
1010: case TCPS_SYN_RECEIVED:
1011:
1012: if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
1013: SEQ_GT(ti->ti_ack, tp->snd_max))
1014: goto dropwithreset;
1015: tcpstat.tcps_connects++;
1016: tp->t_state = TCPS_ESTABLISHED;
1017: /*
1018: * The sent SYN is ack'ed with our sequence number +1
1019: * The first data byte already in the buffer will get
1020: * lost if no correction is made. This is only needed for
1021: * SS_CTL since the buffer is empty otherwise.
1022: * tp->snd_una++; or:
1023: */
1024: tp->snd_una=ti->ti_ack;
1025: if (so->so_state & SS_CTL) {
1026: /* So tcp_ctl reports the right state */
1027: ret = tcp_ctl(so);
1028: if (ret == 1) {
1029: soisfconnected(so);
1030: so->so_state &= ~SS_CTL; /* success XXX */
1031: } else if (ret == 2) {
1032: so->so_state = SS_NOFDREF; /* CTL_CMD */
1033: } else {
1034: needoutput = 1;
1035: tp->t_state = TCPS_FIN_WAIT_1;
1036: }
1037: } else {
1038: soisfconnected(so);
1039: }
1040:
1041: /* Do window scaling? */
1042: /* if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
1043: * (TF_RCVD_SCALE|TF_REQ_SCALE)) {
1044: * tp->snd_scale = tp->requested_s_scale;
1045: * tp->rcv_scale = tp->request_r_scale;
1046: * }
1047: */
1048: (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
1049: tp->snd_wl1 = ti->ti_seq - 1;
1050: /* Avoid ack processing; snd_una==ti_ack => dup ack */
1051: goto synrx_to_est;
1052: /* fall into ... */
1053:
1054: /*
1055: * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
1056: * ACKs. If the ack is in the range
1057: * tp->snd_una < ti->ti_ack <= tp->snd_max
1058: * then advance tp->snd_una to ti->ti_ack and drop
1059: * data from the retransmission queue. If this ACK reflects
1060: * more up to date window information we update our window information.
1061: */
1062: case TCPS_ESTABLISHED:
1063: case TCPS_FIN_WAIT_1:
1064: case TCPS_FIN_WAIT_2:
1065: case TCPS_CLOSE_WAIT:
1066: case TCPS_CLOSING:
1067: case TCPS_LAST_ACK:
1068: case TCPS_TIME_WAIT:
1069:
1070: if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
1071: if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
1072: tcpstat.tcps_rcvdupack++;
1073: DEBUG_MISC((dfd," dup ack m = %lx so = %lx \n",
1074: (long )m, (long )so));
1075: /*
1076: * If we have outstanding data (other than
1077: * a window probe), this is a completely
1078: * duplicate ack (ie, window info didn't
1079: * change), the ack is the biggest we've
1080: * seen and we've seen exactly our rexmt
1081: * threshold of them, assume a packet
1082: * has been dropped and retransmit it.
1083: * Kludge snd_nxt & the congestion
1084: * window so we send only this one
1085: * packet.
1086: *
1087: * We know we're losing at the current
1088: * window size so do congestion avoidance
1089: * (set ssthresh to half the current window
1090: * and pull our congestion window back to
1091: * the new ssthresh).
1092: *
1093: * Dup acks mean that packets have left the
1094: * network (they're now cached at the receiver)
1095: * so bump cwnd by the amount in the receiver
1096: * to keep a constant cwnd packets in the
1097: * network.
1098: */
1099: if (tp->t_timer[TCPT_REXMT] == 0 ||
1100: ti->ti_ack != tp->snd_una)
1101: tp->t_dupacks = 0;
1102: else if (++tp->t_dupacks == tcprexmtthresh) {
1103: tcp_seq onxt = tp->snd_nxt;
1104: u_int win =
1105: min(tp->snd_wnd, tp->snd_cwnd) / 2 /
1106: tp->t_maxseg;
1107:
1108: if (win < 2)
1109: win = 2;
1110: tp->snd_ssthresh = win * tp->t_maxseg;
1111: tp->t_timer[TCPT_REXMT] = 0;
1112: tp->t_rtt = 0;
1113: tp->snd_nxt = ti->ti_ack;
1114: tp->snd_cwnd = tp->t_maxseg;
1115: (void) tcp_output(tp);
1116: tp->snd_cwnd = tp->snd_ssthresh +
1117: tp->t_maxseg * tp->t_dupacks;
1118: if (SEQ_GT(onxt, tp->snd_nxt))
1119: tp->snd_nxt = onxt;
1120: goto drop;
1121: } else if (tp->t_dupacks > tcprexmtthresh) {
1122: tp->snd_cwnd += tp->t_maxseg;
1123: (void) tcp_output(tp);
1124: goto drop;
1125: }
1126: } else
1127: tp->t_dupacks = 0;
1128: break;
1129: }
1130: synrx_to_est:
1131: /*
1132: * If the congestion window was inflated to account
1133: * for the other side's cached packets, retract it.
1134: */
1135: if (tp->t_dupacks > tcprexmtthresh &&
1136: tp->snd_cwnd > tp->snd_ssthresh)
1137: tp->snd_cwnd = tp->snd_ssthresh;
1138: tp->t_dupacks = 0;
1139: if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
1140: tcpstat.tcps_rcvacktoomuch++;
1141: goto dropafterack;
1142: }
1143: acked = ti->ti_ack - tp->snd_una;
1144: tcpstat.tcps_rcvackpack++;
1145: tcpstat.tcps_rcvackbyte += acked;
1146:
1147: /*
1148: * If we have a timestamp reply, update smoothed
1149: * round trip time. If no timestamp is present but
1150: * transmit timer is running and timed sequence
1151: * number was acked, update smoothed round trip time.
1152: * Since we now have an rtt measurement, cancel the
1153: * timer backoff (cf., Phil Karn's retransmit alg.).
1154: * Recompute the initial retransmit timer.
1155: */
1156: /* if (ts_present)
1157: * tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
1158: * else
1159: */
1160: if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
1161: tcp_xmit_timer(tp,tp->t_rtt);
1162:
1163: /*
1164: * If all outstanding data is acked, stop retransmit
1165: * timer and remember to restart (more output or persist).
1166: * If there is more data to be acked, restart retransmit
1167: * timer, using current (possibly backed-off) value.
1168: */
1169: if (ti->ti_ack == tp->snd_max) {
1170: tp->t_timer[TCPT_REXMT] = 0;
1171: needoutput = 1;
1172: } else if (tp->t_timer[TCPT_PERSIST] == 0)
1173: tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
1174: /*
1175: * When new data is acked, open the congestion window.
1176: * If the window gives us less than ssthresh packets
1177: * in flight, open exponentially (maxseg per packet).
1178: * Otherwise open linearly: maxseg per window
1179: * (maxseg^2 / cwnd per packet).
1180: */
1181: {
1182: register u_int cw = tp->snd_cwnd;
1183: register u_int incr = tp->t_maxseg;
1184:
1185: if (cw > tp->snd_ssthresh)
1186: incr = incr * incr / cw;
1187: tp->snd_cwnd = min(cw + incr, TCP_MAXWIN<<tp->snd_scale);
1188: }
1189: if (acked > so->so_snd.sb_cc) {
1190: tp->snd_wnd -= so->so_snd.sb_cc;
1191: sbdrop(&so->so_snd, (int )so->so_snd.sb_cc);
1192: ourfinisacked = 1;
1193: } else {
1194: sbdrop(&so->so_snd, acked);
1195: tp->snd_wnd -= acked;
1196: ourfinisacked = 0;
1197: }
1198: /*
1199: * XXX sowwakup is called when data is acked and there's room for
1200: * for more data... it should read() the socket
1201: */
1202: /* if (so->so_snd.sb_flags & SB_NOTIFY)
1203: * sowwakeup(so);
1204: */
1205: tp->snd_una = ti->ti_ack;
1206: if (SEQ_LT(tp->snd_nxt, tp->snd_una))
1207: tp->snd_nxt = tp->snd_una;
1208:
1209: switch (tp->t_state) {
1210:
1211: /*
1212: * In FIN_WAIT_1 STATE in addition to the processing
1213: * for the ESTABLISHED state if our FIN is now acknowledged
1214: * then enter FIN_WAIT_2.
1215: */
1216: case TCPS_FIN_WAIT_1:
1217: if (ourfinisacked) {
1218: /*
1219: * If we can't receive any more
1220: * data, then closing user can proceed.
1221: * Starting the timer is contrary to the
1222: * specification, but if we don't get a FIN
1223: * we'll hang forever.
1224: */
1225: if (so->so_state & SS_FCANTRCVMORE) {
1226: soisfdisconnected(so);
1227: tp->t_timer[TCPT_2MSL] = tcp_maxidle;
1228: }
1229: tp->t_state = TCPS_FIN_WAIT_2;
1230: }
1231: break;
1232:
1233: /*
1234: * In CLOSING STATE in addition to the processing for
1235: * the ESTABLISHED state if the ACK acknowledges our FIN
1236: * then enter the TIME-WAIT state, otherwise ignore
1237: * the segment.
1238: */
1239: case TCPS_CLOSING:
1240: if (ourfinisacked) {
1241: tp->t_state = TCPS_TIME_WAIT;
1242: tcp_canceltimers(tp);
1243: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1244: soisfdisconnected(so);
1245: }
1246: break;
1247:
1248: /*
1249: * In LAST_ACK, we may still be waiting for data to drain
1250: * and/or to be acked, as well as for the ack of our FIN.
1251: * If our FIN is now acknowledged, delete the TCB,
1252: * enter the closed state and return.
1253: */
1254: case TCPS_LAST_ACK:
1255: if (ourfinisacked) {
1256: tp = tcp_close(tp);
1257: goto drop;
1258: }
1259: break;
1260:
1261: /*
1262: * In TIME_WAIT state the only thing that should arrive
1263: * is a retransmission of the remote FIN. Acknowledge
1264: * it and restart the finack timer.
1265: */
1266: case TCPS_TIME_WAIT:
1267: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1268: goto dropafterack;
1269: }
1270: } /* switch(tp->t_state) */
1271:
1272: step6:
1273: /*
1274: * Update window information.
1275: * Don't look at window if no ACK: TAC's send garbage on first SYN.
1276: */
1277: if ((tiflags & TH_ACK) &&
1278: (SEQ_LT(tp->snd_wl1, ti->ti_seq) ||
1279: (tp->snd_wl1 == ti->ti_seq && (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
1280: (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))))) {
1281: /* keep track of pure window updates */
1282: if (ti->ti_len == 0 &&
1283: tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd)
1284: tcpstat.tcps_rcvwinupd++;
1285: tp->snd_wnd = tiwin;
1286: tp->snd_wl1 = ti->ti_seq;
1287: tp->snd_wl2 = ti->ti_ack;
1288: if (tp->snd_wnd > tp->max_sndwnd)
1289: tp->max_sndwnd = tp->snd_wnd;
1290: needoutput = 1;
1291: }
1292:
1293: /*
1294: * Process segments with URG.
1295: */
1296: if ((tiflags & TH_URG) && ti->ti_urp &&
1297: TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1298: /*
1299: * This is a kludge, but if we receive and accept
1300: * random urgent pointers, we'll crash in
1301: * soreceive. It's hard to imagine someone
1302: * actually wanting to send this much urgent data.
1303: */
1304: if (ti->ti_urp + so->so_rcv.sb_cc > so->so_rcv.sb_datalen) {
1305: ti->ti_urp = 0;
1306: tiflags &= ~TH_URG;
1307: goto dodata;
1308: }
1309: /*
1310: * If this segment advances the known urgent pointer,
1311: * then mark the data stream. This should not happen
1312: * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
1313: * a FIN has been received from the remote side.
1314: * In these states we ignore the URG.
1315: *
1316: * According to RFC961 (Assigned Protocols),
1317: * the urgent pointer points to the last octet
1318: * of urgent data. We continue, however,
1319: * to consider it to indicate the first octet
1320: * of data past the urgent section as the original
1321: * spec states (in one of two places).
1322: */
1323: if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
1324: tp->rcv_up = ti->ti_seq + ti->ti_urp;
1325: so->so_urgc = so->so_rcv.sb_cc +
1326: (tp->rcv_up - tp->rcv_nxt); /* -1; */
1327: tp->rcv_up = ti->ti_seq + ti->ti_urp;
1328:
1329: }
1330: } else
1331: /*
1332: * If no out of band data is expected,
1333: * pull receive urgent pointer along
1334: * with the receive window.
1335: */
1336: if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
1337: tp->rcv_up = tp->rcv_nxt;
1338: dodata:
1339:
1340: /*
1341: * Process the segment text, merging it into the TCP sequencing queue,
1342: * and arranging for acknowledgment of receipt if necessary.
1343: * This process logically involves adjusting tp->rcv_wnd as data
1344: * is presented to the user (this happens in tcp_usrreq.c,
1345: * case PRU_RCVD). If a FIN has already been received on this
1346: * connection then we just ignore the text.
1347: */
1348: if ((ti->ti_len || (tiflags&TH_FIN)) &&
1349: TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1350: TCP_REASS(tp, ti, m, so, tiflags);
1351: /*
1352: * Note the amount of data that peer has sent into
1353: * our window, in order to estimate the sender's
1354: * buffer size.
1355: */
1356: len = so->so_rcv.sb_datalen - (tp->rcv_adv - tp->rcv_nxt);
1357: } else {
1358: m_free(m);
1359: tiflags &= ~TH_FIN;
1360: }
1361:
1362: /*
1363: * If FIN is received ACK the FIN and let the user know
1364: * that the connection is closing.
1365: */
1366: if (tiflags & TH_FIN) {
1367: if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1368: /*
1369: * If we receive a FIN we can't send more data,
1370: * set it SS_FDRAIN
1371: * Shutdown the socket if there is no rx data in the
1372: * buffer.
1373: * soread() is called on completion of shutdown() and
1374: * will got to TCPS_LAST_ACK, and use tcp_output()
1375: * to send the FIN.
1376: */
1377: /* sofcantrcvmore(so); */
1378: sofwdrain(so);
1379:
1380: tp->t_flags |= TF_ACKNOW;
1381: tp->rcv_nxt++;
1382: }
1383: switch (tp->t_state) {
1384:
1385: /*
1386: * In SYN_RECEIVED and ESTABLISHED STATES
1387: * enter the CLOSE_WAIT state.
1388: */
1389: case TCPS_SYN_RECEIVED:
1390: case TCPS_ESTABLISHED:
1391: if(so->so_emu == EMU_CTL) /* no shutdown on socket */
1392: tp->t_state = TCPS_LAST_ACK;
1393: else
1394: tp->t_state = TCPS_CLOSE_WAIT;
1395: break;
1396:
1397: /*
1398: * If still in FIN_WAIT_1 STATE FIN has not been acked so
1399: * enter the CLOSING state.
1400: */
1401: case TCPS_FIN_WAIT_1:
1402: tp->t_state = TCPS_CLOSING;
1403: break;
1404:
1405: /*
1406: * In FIN_WAIT_2 state enter the TIME_WAIT state,
1407: * starting the time-wait timer, turning off the other
1408: * standard timers.
1409: */
1410: case TCPS_FIN_WAIT_2:
1411: tp->t_state = TCPS_TIME_WAIT;
1412: tcp_canceltimers(tp);
1413: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1414: soisfdisconnected(so);
1415: break;
1416:
1417: /*
1418: * In TIME_WAIT state restart the 2 MSL time_wait timer.
1419: */
1420: case TCPS_TIME_WAIT:
1421: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1422: break;
1423: }
1424: }
1425:
1426: /*
1427: * If this is a small packet, then ACK now - with Nagel
1428: * congestion avoidance sender won't send more until
1429: * he gets an ACK.
1430: *
1431: * See above.
1432: */
1433: /* if (ti->ti_len && (unsigned)ti->ti_len < tp->t_maxseg) {
1434: */
1435: /* if ((ti->ti_len && (unsigned)ti->ti_len < tp->t_maxseg &&
1436: * (so->so_iptos & IPTOS_LOWDELAY) == 0) ||
1437: * ((so->so_iptos & IPTOS_LOWDELAY) &&
1438: * ((struct tcpiphdr_2 *)ti)->first_char == (char)27)) {
1439: */
1440: if (ti->ti_len && (unsigned)ti->ti_len <= 5 &&
1441: ((struct tcpiphdr_2 *)ti)->first_char == (char)27) {
1442: tp->t_flags |= TF_ACKNOW;
1443: }
1444:
1445: /*
1446: * Return any desired output.
1447: */
1448: if (needoutput || (tp->t_flags & TF_ACKNOW)) {
1449: (void) tcp_output(tp);
1450: }
1451: return;
1452:
1453: dropafterack:
1454: /*
1455: * Generate an ACK dropping incoming segment if it occupies
1456: * sequence space, where the ACK reflects our state.
1457: */
1458: if (tiflags & TH_RST)
1459: goto drop;
1460: m_freem(m);
1461: tp->t_flags |= TF_ACKNOW;
1462: (void) tcp_output(tp);
1463: return;
1464:
1465: dropwithreset:
1466: /* reuses m if m!=NULL, m_free() unnecessary */
1467: if (tiflags & TH_ACK)
1468: tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);
1469: else {
1470: if (tiflags & TH_SYN) ti->ti_len++;
1471: tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,
1472: TH_RST|TH_ACK);
1473: }
1474:
1475: return;
1476:
1477: drop:
1478: /*
1479: * Drop space held by incoming segment and return.
1480: */
1481: m_free(m);
1482:
1483: return;
1484: }
1485:
1486: /* , ts_present, ts_val, ts_ecr) */
1487: /* int *ts_present;
1488: * u_int32_t *ts_val, *ts_ecr;
1489: */
1490: void
1491: tcp_dooptions(tp, cp, cnt, ti)
1492: struct tcpcb *tp;
1493: u_char *cp;
1494: int cnt;
1495: struct tcpiphdr *ti;
1496: {
1497: u_int16_t mss;
1498: int opt, optlen;
1499:
1500: DEBUG_CALL("tcp_dooptions");
1501: DEBUG_ARGS((dfd," tp = %lx cnt=%i \n", (long )tp, cnt));
1502:
1503: for (; cnt > 0; cnt -= optlen, cp += optlen) {
1504: opt = cp[0];
1505: if (opt == TCPOPT_EOL)
1506: break;
1507: if (opt == TCPOPT_NOP)
1508: optlen = 1;
1509: else {
1510: optlen = cp[1];
1511: if (optlen <= 0)
1512: break;
1513: }
1514: switch (opt) {
1515:
1516: default:
1517: continue;
1518:
1519: case TCPOPT_MAXSEG:
1520: if (optlen != TCPOLEN_MAXSEG)
1521: continue;
1522: if (!(ti->ti_flags & TH_SYN))
1523: continue;
1524: memcpy((char *) &mss, (char *) cp + 2, sizeof(mss));
1525: NTOHS(mss);
1526: (void) tcp_mss(tp, mss); /* sets t_maxseg */
1527: break;
1528:
1529: /* case TCPOPT_WINDOW:
1530: * if (optlen != TCPOLEN_WINDOW)
1531: * continue;
1532: * if (!(ti->ti_flags & TH_SYN))
1533: * continue;
1534: * tp->t_flags |= TF_RCVD_SCALE;
1535: * tp->requested_s_scale = min(cp[2], TCP_MAX_WINSHIFT);
1536: * break;
1537: */
1538: /* case TCPOPT_TIMESTAMP:
1539: * if (optlen != TCPOLEN_TIMESTAMP)
1540: * continue;
1541: * *ts_present = 1;
1542: * memcpy((char *) ts_val, (char *)cp + 2, sizeof(*ts_val));
1543: * NTOHL(*ts_val);
1544: * memcpy((char *) ts_ecr, (char *)cp + 6, sizeof(*ts_ecr));
1545: * NTOHL(*ts_ecr);
1546: *
1547: */ /*
1548: * * A timestamp received in a SYN makes
1549: * * it ok to send timestamp requests and replies.
1550: * */
1551: /* if (ti->ti_flags & TH_SYN) {
1552: * tp->t_flags |= TF_RCVD_TSTMP;
1553: * tp->ts_recent = *ts_val;
1554: * tp->ts_recent_age = tcp_now;
1555: * }
1556: */ break;
1557: }
1558: }
1559: }
1560:
1561:
1562: /*
1563: * Pull out of band byte out of a segment so
1564: * it doesn't appear in the user's data queue.
1565: * It is still reflected in the segment length for
1566: * sequencing purposes.
1567: */
1568:
1569: #ifdef notdef
1570:
1571: void
1572: tcp_pulloutofband(so, ti, m)
1573: struct socket *so;
1574: struct tcpiphdr *ti;
1575: register struct mbuf *m;
1576: {
1577: int cnt = ti->ti_urp - 1;
1578:
1579: while (cnt >= 0) {
1580: if (m->m_len > cnt) {
1581: char *cp = mtod(m, caddr_t) + cnt;
1582: struct tcpcb *tp = sototcpcb(so);
1583:
1584: tp->t_iobc = *cp;
1585: tp->t_oobflags |= TCPOOB_HAVEDATA;
1586: memcpy(sp, cp+1, (unsigned)(m->m_len - cnt - 1));
1587: m->m_len--;
1588: return;
1589: }
1590: cnt -= m->m_len;
1591: m = m->m_next; /* XXX WRONG! Fix it! */
1592: if (m == 0)
1593: break;
1594: }
1595: panic("tcp_pulloutofband");
1596: }
1597:
1598: #endif /* notdef */
1599:
1600: /*
1601: * Collect new round-trip time estimate
1602: * and update averages and current timeout.
1603: */
1604:
1605: void
1606: tcp_xmit_timer(tp, rtt)
1607: register struct tcpcb *tp;
1608: int rtt;
1609: {
1610: register short delta;
1611:
1612: DEBUG_CALL("tcp_xmit_timer");
1613: DEBUG_ARG("tp = %lx", (long)tp);
1614: DEBUG_ARG("rtt = %d", rtt);
1615:
1616: tcpstat.tcps_rttupdated++;
1617: if (tp->t_srtt != 0) {
1618: /*
1619: * srtt is stored as fixed point with 3 bits after the
1620: * binary point (i.e., scaled by 8). The following magic
1621: * is equivalent to the smoothing algorithm in rfc793 with
1622: * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed
1623: * point). Adjust rtt to origin 0.
1624: */
1625: delta = rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
1626: if ((tp->t_srtt += delta) <= 0)
1627: tp->t_srtt = 1;
1628: /*
1629: * We accumulate a smoothed rtt variance (actually, a
1630: * smoothed mean difference), then set the retransmit
1631: * timer to smoothed rtt + 4 times the smoothed variance.
1632: * rttvar is stored as fixed point with 2 bits after the
1633: * binary point (scaled by 4). The following is
1634: * equivalent to rfc793 smoothing with an alpha of .75
1635: * (rttvar = rttvar*3/4 + |delta| / 4). This replaces
1636: * rfc793's wired-in beta.
1637: */
1638: if (delta < 0)
1639: delta = -delta;
1640: delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
1641: if ((tp->t_rttvar += delta) <= 0)
1642: tp->t_rttvar = 1;
1643: } else {
1644: /*
1645: * No rtt measurement yet - use the unsmoothed rtt.
1646: * Set the variance to half the rtt (so our first
1647: * retransmit happens at 3*rtt).
1648: */
1649: tp->t_srtt = rtt << TCP_RTT_SHIFT;
1650: tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT - 1);
1651: }
1652: tp->t_rtt = 0;
1653: tp->t_rxtshift = 0;
1654:
1655: /*
1656: * the retransmit should happen at rtt + 4 * rttvar.
1657: * Because of the way we do the smoothing, srtt and rttvar
1658: * will each average +1/2 tick of bias. When we compute
1659: * the retransmit timer, we want 1/2 tick of rounding and
1660: * 1 extra tick because of +-1/2 tick uncertainty in the
1661: * firing of the timer. The bias will give us exactly the
1662: * 1.5 tick we need. But, because the bias is
1663: * statistical, we have to test that we don't drop below
1664: * the minimum feasible timer (which is 2 ticks).
1665: */
1666: TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
1667: (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */
1668:
1669: /*
1670: * We received an ack for a packet that wasn't retransmitted;
1671: * it is probably safe to discard any error indications we've
1672: * received recently. This isn't quite right, but close enough
1673: * for now (a route might have failed after we sent a segment,
1674: * and the return path might not be symmetrical).
1675: */
1676: tp->t_softerror = 0;
1677: }
1678:
1679: /*
1680: * Determine a reasonable value for maxseg size.
1681: * If the route is known, check route for mtu.
1682: * If none, use an mss that can be handled on the outgoing
1683: * interface without forcing IP to fragment; if bigger than
1684: * an mbuf cluster (MCLBYTES), round down to nearest multiple of MCLBYTES
1685: * to utilize large mbufs. If no route is found, route has no mtu,
1686: * or the destination isn't local, use a default, hopefully conservative
1687: * size (usually 512 or the default IP max size, but no more than the mtu
1688: * of the interface), as we can't discover anything about intervening
1689: * gateways or networks. We also initialize the congestion/slow start
1690: * window to be a single segment if the destination isn't local.
1691: * While looking at the routing entry, we also initialize other path-dependent
1692: * parameters from pre-set or cached values in the routing entry.
1693: */
1694:
1695: int
1696: tcp_mss(tp, offer)
1697: register struct tcpcb *tp;
1698: u_int offer;
1699: {
1700: struct socket *so = tp->t_socket;
1701: int mss;
1702:
1703: DEBUG_CALL("tcp_mss");
1704: DEBUG_ARG("tp = %lx", (long)tp);
1705: DEBUG_ARG("offer = %d", offer);
1706:
1707: mss = min(if_mtu, if_mru) - sizeof(struct tcpiphdr);
1708: if (offer)
1709: mss = min(mss, offer);
1710: mss = max(mss, 32);
1711: if (mss < tp->t_maxseg || offer != 0)
1712: tp->t_maxseg = mss;
1713:
1714: tp->snd_cwnd = mss;
1715:
1716: sbreserve(&so->so_snd, tcp_sndspace+((tcp_sndspace%mss)?(mss-(tcp_sndspace%mss)):0));
1717: sbreserve(&so->so_rcv, tcp_rcvspace+((tcp_rcvspace%mss)?(mss-(tcp_rcvspace%mss)):0));
1718:
1719: DEBUG_MISC((dfd, " returning mss = %d\n", mss));
1720:
1721: return mss;
1722: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.