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