1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include "qemu/osdep.h"
42#include <slirp.h>
43#include "ip_icmp.h"
44
45#define TCPREXMTTHRESH 3
46
47#define TCP_PAWS_IDLE (24 * 24 * 60 * 60 * PR_SLOWHZ)
48
49
50#define TSTMP_LT(a,b) ((int)((a)-(b)) < 0)
51#define TSTMP_GEQ(a,b) ((int)((a)-(b)) >= 0)
52
53
54
55
56
57
58
59
60
61
62
63#ifdef TCP_ACK_HACK
64#define TCP_REASS(tp, ti, m, so, flags) {\
65 if ((ti)->ti_seq == (tp)->rcv_nxt && \
66 tcpfrag_list_empty(tp) && \
67 (tp)->t_state == TCPS_ESTABLISHED) {\
68 if (ti->ti_flags & TH_PUSH) \
69 tp->t_flags |= TF_ACKNOW; \
70 else \
71 tp->t_flags |= TF_DELACK; \
72 (tp)->rcv_nxt += (ti)->ti_len; \
73 flags = (ti)->ti_flags & TH_FIN; \
74 if (so->so_emu) { \
75 if (tcp_emu((so),(m))) sbappend((so), (m)); \
76 } else \
77 sbappend((so), (m)); \
78 } else {\
79 (flags) = tcp_reass((tp), (ti), (m)); \
80 tp->t_flags |= TF_ACKNOW; \
81 } \
82}
83#else
84#define TCP_REASS(tp, ti, m, so, flags) { \
85 if ((ti)->ti_seq == (tp)->rcv_nxt && \
86 tcpfrag_list_empty(tp) && \
87 (tp)->t_state == TCPS_ESTABLISHED) { \
88 tp->t_flags |= TF_DELACK; \
89 (tp)->rcv_nxt += (ti)->ti_len; \
90 flags = (ti)->ti_flags & TH_FIN; \
91 if (so->so_emu) { \
92 if (tcp_emu((so),(m))) sbappend(so, (m)); \
93 } else \
94 sbappend((so), (m)); \
95 } else { \
96 (flags) = tcp_reass((tp), (ti), (m)); \
97 tp->t_flags |= TF_ACKNOW; \
98 } \
99}
100#endif
101static void tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt,
102 struct tcpiphdr *ti);
103static void tcp_xmit_timer(register struct tcpcb *tp, int rtt);
104
105static int
106tcp_reass(register struct tcpcb *tp, register struct tcpiphdr *ti,
107 struct mbuf *m)
108{
109 register struct tcpiphdr *q;
110 struct socket *so = tp->t_socket;
111 int flags;
112
113
114
115
116
117 if (ti == NULL)
118 goto present;
119
120
121
122
123 for (q = tcpfrag_list_first(tp); !tcpfrag_list_end(q, tp);
124 q = tcpiphdr_next(q))
125 if (SEQ_GT(q->ti_seq, ti->ti_seq))
126 break;
127
128
129
130
131
132
133 if (!tcpfrag_list_end(tcpiphdr_prev(q), tp)) {
134 register int i;
135 q = tcpiphdr_prev(q);
136
137 i = q->ti_seq + q->ti_len - ti->ti_seq;
138 if (i > 0) {
139 if (i >= ti->ti_len) {
140 m_free(m);
141
142
143
144
145
146
147 goto present;
148 }
149 m_adj(m, i);
150 ti->ti_len -= i;
151 ti->ti_seq += i;
152 }
153 q = tcpiphdr_next(q);
154 }
155 ti->ti_mbuf = m;
156
157
158
159
160
161 while (!tcpfrag_list_end(q, tp)) {
162 register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
163 if (i <= 0)
164 break;
165 if (i < q->ti_len) {
166 q->ti_seq += i;
167 q->ti_len -= i;
168 m_adj(q->ti_mbuf, i);
169 break;
170 }
171 q = tcpiphdr_next(q);
172 m = tcpiphdr_prev(q)->ti_mbuf;
173 remque(tcpiphdr2qlink(tcpiphdr_prev(q)));
174 m_free(m);
175 }
176
177
178
179
180 insque(tcpiphdr2qlink(ti), tcpiphdr2qlink(tcpiphdr_prev(q)));
181
182present:
183
184
185
186
187 if (!TCPS_HAVEESTABLISHED(tp->t_state))
188 return (0);
189 ti = tcpfrag_list_first(tp);
190 if (tcpfrag_list_end(ti, tp) || ti->ti_seq != tp->rcv_nxt)
191 return (0);
192 if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
193 return (0);
194 do {
195 tp->rcv_nxt += ti->ti_len;
196 flags = ti->ti_flags & TH_FIN;
197 remque(tcpiphdr2qlink(ti));
198 m = ti->ti_mbuf;
199 ti = tcpiphdr_next(ti);
200 if (so->so_state & SS_FCANTSENDMORE)
201 m_free(m);
202 else {
203 if (so->so_emu) {
204 if (tcp_emu(so,m)) sbappend(so, m);
205 } else
206 sbappend(so, m);
207 }
208 } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
209 return (flags);
210}
211
212
213
214
215
216void
217tcp_input(struct mbuf *m, int iphlen, struct socket *inso, unsigned short af)
218{
219 struct ip save_ip, *ip;
220 struct ip6 save_ip6, *ip6;
221 register struct tcpiphdr *ti;
222 caddr_t optp = NULL;
223 int optlen = 0;
224 int len, tlen, off;
225 register struct tcpcb *tp = NULL;
226 register int tiflags;
227 struct socket *so = NULL;
228 int todrop, acked, ourfinisacked, needoutput = 0;
229 int iss = 0;
230 u_long tiwin;
231 int ret;
232 struct sockaddr_storage lhost, fhost;
233 struct sockaddr_in *lhost4, *fhost4;
234 struct sockaddr_in6 *lhost6, *fhost6;
235 struct ex_list *ex_ptr;
236 Slirp *slirp;
237
238 DEBUG_CALL("tcp_input");
239 DEBUG_ARGS((dfd, " m = %p iphlen = %2d inso = %p\n",
240 m, iphlen, inso));
241
242
243
244
245 if (m == NULL) {
246 so = inso;
247 slirp = so->slirp;
248
249
250 tp = sototcpcb(so);
251 m = so->so_m;
252 so->so_m = NULL;
253 ti = so->so_ti;
254 tiwin = ti->ti_win;
255 tiflags = ti->ti_flags;
256
257 goto cont_conn;
258 }
259 slirp = m->slirp;
260
261 ip = mtod(m, struct ip *);
262 ip6 = mtod(m, struct ip6 *);
263
264 switch (af) {
265 case AF_INET:
266 if (iphlen > sizeof(struct ip)) {
267 ip_stripoptions(m, (struct mbuf *)0);
268 iphlen = sizeof(struct ip);
269 }
270
271
272
273
274
275
276
277 save_ip = *ip;
278 save_ip.ip_len += iphlen;
279
280
281
282
283
284 m->m_data -= sizeof(struct tcpiphdr) - sizeof(struct ip)
285 - sizeof(struct tcphdr);
286 m->m_len += sizeof(struct tcpiphdr) - sizeof(struct ip)
287 - sizeof(struct tcphdr);
288 ti = mtod(m, struct tcpiphdr *);
289
290
291
292
293 tlen = ip->ip_len;
294 tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = NULL;
295 memset(&ti->ih_mbuf, 0 , sizeof(struct mbuf_ptr));
296 memset(&ti->ti, 0, sizeof(ti->ti));
297 ti->ti_x0 = 0;
298 ti->ti_src = save_ip.ip_src;
299 ti->ti_dst = save_ip.ip_dst;
300 ti->ti_pr = save_ip.ip_p;
301 ti->ti_len = htons((uint16_t)tlen);
302 break;
303
304 case AF_INET6:
305
306
307
308
309 save_ip6 = *ip6;
310
311
312
313
314 m->m_data -= sizeof(struct tcpiphdr) - (sizeof(struct ip6)
315 + sizeof(struct tcphdr));
316 m->m_len += sizeof(struct tcpiphdr) - (sizeof(struct ip6)
317 + sizeof(struct tcphdr));
318 ti = mtod(m, struct tcpiphdr *);
319
320 tlen = ip6->ip_pl;
321 tcpiphdr2qlink(ti)->next = tcpiphdr2qlink(ti)->prev = NULL;
322 memset(&ti->ih_mbuf, 0 , sizeof(struct mbuf_ptr));
323 memset(&ti->ti, 0, sizeof(ti->ti));
324 ti->ti_x0 = 0;
325 ti->ti_src6 = save_ip6.ip_src;
326 ti->ti_dst6 = save_ip6.ip_dst;
327 ti->ti_nh6 = save_ip6.ip_nh;
328 ti->ti_len = htons((uint16_t)tlen);
329 break;
330
331 default:
332 g_assert_not_reached();
333 }
334
335 len = ((sizeof(struct tcpiphdr) - sizeof(struct tcphdr)) + tlen);
336 if (cksum(m, len)) {
337 goto drop;
338 }
339
340
341
342
343
344 off = ti->ti_off << 2;
345 if (off < sizeof (struct tcphdr) || off > tlen) {
346 goto drop;
347 }
348 tlen -= off;
349 ti->ti_len = tlen;
350 if (off > sizeof (struct tcphdr)) {
351 optlen = off - sizeof (struct tcphdr);
352 optp = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
353 }
354 tiflags = ti->ti_flags;
355
356
357
358
359 NTOHL(ti->ti_seq);
360 NTOHL(ti->ti_ack);
361 NTOHS(ti->ti_win);
362 NTOHS(ti->ti_urp);
363
364
365
366
367 m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
368 m->m_len -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
369
370
371
372
373findso:
374 lhost.ss_family = af;
375 fhost.ss_family = af;
376 switch (af) {
377 case AF_INET:
378 lhost4 = (struct sockaddr_in *) &lhost;
379 lhost4->sin_addr = ti->ti_src;
380 lhost4->sin_port = ti->ti_sport;
381 fhost4 = (struct sockaddr_in *) &fhost;
382 fhost4->sin_addr = ti->ti_dst;
383 fhost4->sin_port = ti->ti_dport;
384 break;
385 case AF_INET6:
386 lhost6 = (struct sockaddr_in6 *) &lhost;
387 lhost6->sin6_addr = ti->ti_src6;
388 lhost6->sin6_port = ti->ti_sport;
389 fhost6 = (struct sockaddr_in6 *) &fhost;
390 fhost6->sin6_addr = ti->ti_dst6;
391 fhost6->sin6_port = ti->ti_dport;
392 break;
393 default:
394 g_assert_not_reached();
395 }
396
397 so = solookup(&slirp->tcp_last_so, &slirp->tcb, &lhost, &fhost);
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412 if (so == NULL) {
413 if (slirp->restricted) {
414
415
416
417
418 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
419 if (ex_ptr->ex_fport == ti->ti_dport &&
420 ti->ti_dst.s_addr == ex_ptr->ex_addr.s_addr) {
421 break;
422 }
423 }
424 if (!ex_ptr) {
425 goto dropwithreset;
426 }
427 }
428
429 if ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)
430 goto dropwithreset;
431
432 if ((so = socreate(slirp)) == NULL)
433 goto dropwithreset;
434 if (tcp_attach(so) < 0) {
435 free(so);
436 goto dropwithreset;
437 }
438
439 sbreserve(&so->so_snd, TCP_SNDSPACE);
440 sbreserve(&so->so_rcv, TCP_RCVSPACE);
441
442 so->lhost.ss = lhost;
443 so->fhost.ss = fhost;
444
445 so->so_iptos = tcp_tos(so);
446 if (so->so_iptos == 0) {
447 switch (af) {
448 case AF_INET:
449 so->so_iptos = ((struct ip *)ti)->ip_tos;
450 break;
451 case AF_INET6:
452 break;
453 default:
454 g_assert_not_reached();
455 }
456 }
457
458 tp = sototcpcb(so);
459 tp->t_state = TCPS_LISTEN;
460 }
461
462
463
464
465
466
467 if (so->so_state & SS_ISFCONNECTING)
468 goto drop;
469
470 tp = sototcpcb(so);
471
472
473 if (tp == NULL)
474 goto dropwithreset;
475 if (tp->t_state == TCPS_CLOSED)
476 goto drop;
477
478 tiwin = ti->ti_win;
479
480
481
482
483
484 tp->t_idle = 0;
485 if (SO_OPTIONS)
486 tp->t_timer[TCPT_KEEP] = TCPTV_KEEPINTVL;
487 else
488 tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_IDLE;
489
490
491
492
493
494 if (optp && tp->t_state != TCPS_LISTEN)
495 tcp_dooptions(tp, (u_char *)optp, optlen, ti);
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515 if (tp->t_state == TCPS_ESTABLISHED &&
516 (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
517 ti->ti_seq == tp->rcv_nxt &&
518 tiwin && tiwin == tp->snd_wnd &&
519 tp->snd_nxt == tp->snd_max) {
520 if (ti->ti_len == 0) {
521 if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
522 SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
523 tp->snd_cwnd >= tp->snd_wnd) {
524
525
526
527 if (tp->t_rtt &&
528 SEQ_GT(ti->ti_ack, tp->t_rtseq))
529 tcp_xmit_timer(tp, tp->t_rtt);
530 acked = ti->ti_ack - tp->snd_una;
531 sbdrop(&so->so_snd, acked);
532 tp->snd_una = ti->ti_ack;
533 m_free(m);
534
535
536
537
538
539
540
541
542
543
544 if (tp->snd_una == tp->snd_max)
545 tp->t_timer[TCPT_REXMT] = 0;
546 else if (tp->t_timer[TCPT_PERSIST] == 0)
547 tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
548
549
550
551
552
553
554 if (so->so_snd.sb_cc)
555 (void) tcp_output(tp);
556
557 return;
558 }
559 } else if (ti->ti_ack == tp->snd_una &&
560 tcpfrag_list_empty(tp) &&
561 ti->ti_len <= sbspace(&so->so_rcv)) {
562
563
564
565
566
567 tp->rcv_nxt += ti->ti_len;
568
569
570
571 if (so->so_emu) {
572 if (tcp_emu(so,m)) sbappend(so, m);
573 } else
574 sbappend(so, m);
575
576
577
578
579
580
581
582
583
584 tp->t_flags |= TF_ACKNOW;
585 tcp_output(tp);
586 return;
587 }
588 }
589
590
591
592
593
594
595 { int win;
596 win = sbspace(&so->so_rcv);
597 if (win < 0)
598 win = 0;
599 tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
600 }
601
602 switch (tp->t_state) {
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617 case TCPS_LISTEN: {
618
619 if (tiflags & TH_RST)
620 goto drop;
621 if (tiflags & TH_ACK)
622 goto dropwithreset;
623 if ((tiflags & TH_SYN) == 0)
624 goto drop;
625
626
627
628
629
630
631
632
633
634
635 if (af == AF_INET &&
636 (so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) ==
637 slirp->vnetwork_addr.s_addr) {
638 if (so->so_faddr.s_addr != slirp->vhost_addr.s_addr &&
639 so->so_faddr.s_addr != slirp->vnameserver_addr.s_addr) {
640
641 for (ex_ptr = slirp->exec_list; ex_ptr;
642 ex_ptr = ex_ptr->ex_next) {
643 if(ex_ptr->ex_fport == so->so_fport &&
644 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr) {
645 so->so_state |= SS_CTL;
646 break;
647 }
648 }
649 if (so->so_state & SS_CTL) {
650 goto cont_input;
651 }
652 }
653
654 }
655
656 if (so->so_emu & EMU_NOCONNECT) {
657 so->so_emu &= ~EMU_NOCONNECT;
658 goto cont_input;
659 }
660
661 if ((tcp_fconnect(so, so->so_ffamily) == -1) &&
662 (errno != EINPROGRESS) && (errno != EWOULDBLOCK)
663 ) {
664 uint8_t code;
665 DEBUG_MISC((dfd, " tcp fconnect errno = %d-%s\n",
666 errno,strerror(errno)));
667 if(errno == ECONNREFUSED) {
668
669 tcp_respond(tp, ti, m, ti->ti_seq + 1, (tcp_seq) 0,
670 TH_RST | TH_ACK, af);
671 } else {
672 switch (af) {
673 case AF_INET:
674 code = ICMP_UNREACH_NET;
675 if (errno == EHOSTUNREACH) {
676 code = ICMP_UNREACH_HOST;
677 }
678 break;
679 case AF_INET6:
680 code = ICMP6_UNREACH_NO_ROUTE;
681 if (errno == EHOSTUNREACH) {
682 code = ICMP6_UNREACH_ADDRESS;
683 }
684 break;
685 default:
686 g_assert_not_reached();
687 }
688 HTONL(ti->ti_seq);
689 HTONL(ti->ti_ack);
690 HTONS(ti->ti_win);
691 HTONS(ti->ti_urp);
692 m->m_data -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
693 m->m_len += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
694 switch (af) {
695 case AF_INET:
696 m->m_data += sizeof(struct tcpiphdr) - sizeof(struct ip)
697 - sizeof(struct tcphdr);
698 m->m_len -= sizeof(struct tcpiphdr) - sizeof(struct ip)
699 - sizeof(struct tcphdr);
700 *ip = save_ip;
701 icmp_send_error(m, ICMP_UNREACH, code, 0, strerror(errno));
702 break;
703 case AF_INET6:
704 m->m_data += sizeof(struct tcpiphdr) - (sizeof(struct ip6)
705 + sizeof(struct tcphdr));
706 m->m_len -= sizeof(struct tcpiphdr) - (sizeof(struct ip6)
707 + sizeof(struct tcphdr));
708 *ip6 = save_ip6;
709 icmp6_send_error(m, ICMP6_UNREACH, code);
710 break;
711 default:
712 g_assert_not_reached();
713 }
714 }
715 tcp_close(tp);
716 m_free(m);
717 } else {
718
719
720
721
722
723
724 so->so_m = m;
725 so->so_ti = ti;
726 tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
727 tp->t_state = TCPS_SYN_RECEIVED;
728
729
730
731
732 tp->irs = ti->ti_seq;
733 tcp_rcvseqinit(tp);
734 tcp_template(tp);
735 }
736 return;
737
738 cont_conn:
739
740
741
742 if (so->so_state & SS_NOFDREF) {
743 tp = tcp_close(tp);
744 goto dropwithreset;
745 }
746 cont_input:
747 tcp_template(tp);
748
749 if (optp)
750 tcp_dooptions(tp, (u_char *)optp, optlen, ti);
751
752 if (iss)
753 tp->iss = iss;
754 else
755 tp->iss = slirp->tcp_iss;
756 slirp->tcp_iss += TCP_ISSINCR/2;
757 tp->irs = ti->ti_seq;
758 tcp_sendseqinit(tp);
759 tcp_rcvseqinit(tp);
760 tp->t_flags |= TF_ACKNOW;
761 tp->t_state = TCPS_SYN_RECEIVED;
762 tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
763 goto trimthenstep6;
764 }
765
766
767
768
769
770
771
772
773
774
775
776
777
778 case TCPS_SYN_SENT:
779 if ((tiflags & TH_ACK) &&
780 (SEQ_LEQ(ti->ti_ack, tp->iss) ||
781 SEQ_GT(ti->ti_ack, tp->snd_max)))
782 goto dropwithreset;
783
784 if (tiflags & TH_RST) {
785 if (tiflags & TH_ACK) {
786 tcp_drop(tp, 0);
787 }
788 goto drop;
789 }
790
791 if ((tiflags & TH_SYN) == 0)
792 goto drop;
793 if (tiflags & TH_ACK) {
794 tp->snd_una = ti->ti_ack;
795 if (SEQ_LT(tp->snd_nxt, tp->snd_una))
796 tp->snd_nxt = tp->snd_una;
797 }
798
799 tp->t_timer[TCPT_REXMT] = 0;
800 tp->irs = ti->ti_seq;
801 tcp_rcvseqinit(tp);
802 tp->t_flags |= TF_ACKNOW;
803 if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
804 soisfconnected(so);
805 tp->t_state = TCPS_ESTABLISHED;
806
807 (void) tcp_reass(tp, (struct tcpiphdr *)0,
808 (struct mbuf *)0);
809
810
811
812
813 if (tp->t_rtt)
814 tcp_xmit_timer(tp, tp->t_rtt);
815 } else
816 tp->t_state = TCPS_SYN_RECEIVED;
817
818trimthenstep6:
819
820
821
822
823
824 ti->ti_seq++;
825 if (ti->ti_len > tp->rcv_wnd) {
826 todrop = ti->ti_len - tp->rcv_wnd;
827 m_adj(m, -todrop);
828 ti->ti_len = tp->rcv_wnd;
829 tiflags &= ~TH_FIN;
830 }
831 tp->snd_wl1 = ti->ti_seq - 1;
832 tp->rcv_up = ti->ti_seq;
833 goto step6;
834 }
835
836
837
838
839
840
841 todrop = tp->rcv_nxt - ti->ti_seq;
842 if (todrop > 0) {
843 if (tiflags & TH_SYN) {
844 tiflags &= ~TH_SYN;
845 ti->ti_seq++;
846 if (ti->ti_urp > 1)
847 ti->ti_urp--;
848 else
849 tiflags &= ~TH_URG;
850 todrop--;
851 }
852
853
854
855 if (todrop > ti->ti_len
856 || (todrop == ti->ti_len && (tiflags & TH_FIN) == 0)) {
857
858
859
860
861
862 tiflags &= ~TH_FIN;
863
864
865
866
867
868 tp->t_flags |= TF_ACKNOW;
869 todrop = ti->ti_len;
870 }
871 m_adj(m, todrop);
872 ti->ti_seq += todrop;
873 ti->ti_len -= todrop;
874 if (ti->ti_urp > todrop)
875 ti->ti_urp -= todrop;
876 else {
877 tiflags &= ~TH_URG;
878 ti->ti_urp = 0;
879 }
880 }
881
882
883
884
885 if ((so->so_state & SS_NOFDREF) &&
886 tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
887 tp = tcp_close(tp);
888 goto dropwithreset;
889 }
890
891
892
893
894
895 todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
896 if (todrop > 0) {
897 if (todrop >= ti->ti_len) {
898
899
900
901
902
903
904 if (tiflags & TH_SYN &&
905 tp->t_state == TCPS_TIME_WAIT &&
906 SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
907 iss = tp->rcv_nxt + TCP_ISSINCR;
908 tp = tcp_close(tp);
909 goto findso;
910 }
911
912
913
914
915
916
917
918 if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
919 tp->t_flags |= TF_ACKNOW;
920 } else {
921 goto dropafterack;
922 }
923 }
924 m_adj(m, -todrop);
925 ti->ti_len -= todrop;
926 tiflags &= ~(TH_PUSH|TH_FIN);
927 }
928
929
930
931
932
933
934
935
936
937
938
939 if (tiflags&TH_RST) switch (tp->t_state) {
940
941 case TCPS_SYN_RECEIVED:
942 case TCPS_ESTABLISHED:
943 case TCPS_FIN_WAIT_1:
944 case TCPS_FIN_WAIT_2:
945 case TCPS_CLOSE_WAIT:
946 tp->t_state = TCPS_CLOSED;
947 tcp_close(tp);
948 goto drop;
949
950 case TCPS_CLOSING:
951 case TCPS_LAST_ACK:
952 case TCPS_TIME_WAIT:
953 tcp_close(tp);
954 goto drop;
955 }
956
957
958
959
960
961 if (tiflags & TH_SYN) {
962 tp = tcp_drop(tp,0);
963 goto dropwithreset;
964 }
965
966
967
968
969 if ((tiflags & TH_ACK) == 0) goto drop;
970
971
972
973
974 switch (tp->t_state) {
975
976
977
978
979
980 case TCPS_SYN_RECEIVED:
981
982 if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
983 SEQ_GT(ti->ti_ack, tp->snd_max))
984 goto dropwithreset;
985 tp->t_state = TCPS_ESTABLISHED;
986
987
988
989
990
991
992
993 tp->snd_una=ti->ti_ack;
994 if (so->so_state & SS_CTL) {
995
996 ret = tcp_ctl(so);
997 if (ret == 1) {
998 soisfconnected(so);
999 so->so_state &= ~SS_CTL;
1000 } else if (ret == 2) {
1001 so->so_state &= SS_PERSISTENT_MASK;
1002 so->so_state |= SS_NOFDREF;
1003 } else {
1004 needoutput = 1;
1005 tp->t_state = TCPS_FIN_WAIT_1;
1006 }
1007 } else {
1008 soisfconnected(so);
1009 }
1010
1011 (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
1012 tp->snd_wl1 = ti->ti_seq - 1;
1013
1014 goto synrx_to_est;
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025 case TCPS_ESTABLISHED:
1026 case TCPS_FIN_WAIT_1:
1027 case TCPS_FIN_WAIT_2:
1028 case TCPS_CLOSE_WAIT:
1029 case TCPS_CLOSING:
1030 case TCPS_LAST_ACK:
1031 case TCPS_TIME_WAIT:
1032
1033 if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
1034 if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
1035 DEBUG_MISC((dfd, " dup ack m = %p so = %p\n",
1036 m, so));
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061 if (tp->t_timer[TCPT_REXMT] == 0 ||
1062 ti->ti_ack != tp->snd_una)
1063 tp->t_dupacks = 0;
1064 else if (++tp->t_dupacks == TCPREXMTTHRESH) {
1065 tcp_seq onxt = tp->snd_nxt;
1066 u_int win =
1067 min(tp->snd_wnd, tp->snd_cwnd) / 2 /
1068 tp->t_maxseg;
1069
1070 if (win < 2)
1071 win = 2;
1072 tp->snd_ssthresh = win * tp->t_maxseg;
1073 tp->t_timer[TCPT_REXMT] = 0;
1074 tp->t_rtt = 0;
1075 tp->snd_nxt = ti->ti_ack;
1076 tp->snd_cwnd = tp->t_maxseg;
1077 (void) tcp_output(tp);
1078 tp->snd_cwnd = tp->snd_ssthresh +
1079 tp->t_maxseg * tp->t_dupacks;
1080 if (SEQ_GT(onxt, tp->snd_nxt))
1081 tp->snd_nxt = onxt;
1082 goto drop;
1083 } else if (tp->t_dupacks > TCPREXMTTHRESH) {
1084 tp->snd_cwnd += tp->t_maxseg;
1085 (void) tcp_output(tp);
1086 goto drop;
1087 }
1088 } else
1089 tp->t_dupacks = 0;
1090 break;
1091 }
1092 synrx_to_est:
1093
1094
1095
1096
1097 if (tp->t_dupacks > TCPREXMTTHRESH &&
1098 tp->snd_cwnd > tp->snd_ssthresh)
1099 tp->snd_cwnd = tp->snd_ssthresh;
1100 tp->t_dupacks = 0;
1101 if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
1102 goto dropafterack;
1103 }
1104 acked = ti->ti_ack - tp->snd_una;
1105
1106
1107
1108
1109
1110
1111
1112
1113 if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
1114 tcp_xmit_timer(tp,tp->t_rtt);
1115
1116
1117
1118
1119
1120
1121
1122 if (ti->ti_ack == tp->snd_max) {
1123 tp->t_timer[TCPT_REXMT] = 0;
1124 needoutput = 1;
1125 } else if (tp->t_timer[TCPT_PERSIST] == 0)
1126 tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
1127
1128
1129
1130
1131
1132
1133
1134 {
1135 register u_int cw = tp->snd_cwnd;
1136 register u_int incr = tp->t_maxseg;
1137
1138 if (cw > tp->snd_ssthresh)
1139 incr = incr * incr / cw;
1140 tp->snd_cwnd = min(cw + incr, TCP_MAXWIN<<tp->snd_scale);
1141 }
1142 if (acked > so->so_snd.sb_cc) {
1143 tp->snd_wnd -= so->so_snd.sb_cc;
1144 sbdrop(&so->so_snd, (int )so->so_snd.sb_cc);
1145 ourfinisacked = 1;
1146 } else {
1147 sbdrop(&so->so_snd, acked);
1148 tp->snd_wnd -= acked;
1149 ourfinisacked = 0;
1150 }
1151 tp->snd_una = ti->ti_ack;
1152 if (SEQ_LT(tp->snd_nxt, tp->snd_una))
1153 tp->snd_nxt = tp->snd_una;
1154
1155 switch (tp->t_state) {
1156
1157
1158
1159
1160
1161
1162 case TCPS_FIN_WAIT_1:
1163 if (ourfinisacked) {
1164
1165
1166
1167
1168
1169
1170
1171 if (so->so_state & SS_FCANTRCVMORE) {
1172 tp->t_timer[TCPT_2MSL] = TCP_MAXIDLE;
1173 }
1174 tp->t_state = TCPS_FIN_WAIT_2;
1175 }
1176 break;
1177
1178
1179
1180
1181
1182
1183
1184 case TCPS_CLOSING:
1185 if (ourfinisacked) {
1186 tp->t_state = TCPS_TIME_WAIT;
1187 tcp_canceltimers(tp);
1188 tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1189 }
1190 break;
1191
1192
1193
1194
1195
1196
1197
1198 case TCPS_LAST_ACK:
1199 if (ourfinisacked) {
1200 tcp_close(tp);
1201 goto drop;
1202 }
1203 break;
1204
1205
1206
1207
1208
1209
1210 case TCPS_TIME_WAIT:
1211 tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1212 goto dropafterack;
1213 }
1214 }
1215
1216step6:
1217
1218
1219
1220
1221 if ((tiflags & TH_ACK) &&
1222 (SEQ_LT(tp->snd_wl1, ti->ti_seq) ||
1223 (tp->snd_wl1 == ti->ti_seq && (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
1224 (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))))) {
1225 tp->snd_wnd = tiwin;
1226 tp->snd_wl1 = ti->ti_seq;
1227 tp->snd_wl2 = ti->ti_ack;
1228 if (tp->snd_wnd > tp->max_sndwnd)
1229 tp->max_sndwnd = tp->snd_wnd;
1230 needoutput = 1;
1231 }
1232
1233
1234
1235
1236 if ((tiflags & TH_URG) && ti->ti_urp &&
1237 TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1238
1239
1240
1241
1242
1243
1244 if (ti->ti_urp + so->so_rcv.sb_cc > so->so_rcv.sb_datalen) {
1245 ti->ti_urp = 0;
1246 tiflags &= ~TH_URG;
1247 goto dodata;
1248 }
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263 if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
1264 tp->rcv_up = ti->ti_seq + ti->ti_urp;
1265 so->so_urgc = so->so_rcv.sb_cc +
1266 (tp->rcv_up - tp->rcv_nxt);
1267 tp->rcv_up = ti->ti_seq + ti->ti_urp;
1268
1269 }
1270 } else
1271
1272
1273
1274
1275
1276 if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
1277 tp->rcv_up = tp->rcv_nxt;
1278dodata:
1279
1280
1281
1282
1283
1284
1285 if (ti->ti_len && (unsigned)ti->ti_len <= 5 &&
1286 ((struct tcpiphdr_2 *)ti)->first_char == (char)27) {
1287 tp->t_flags |= TF_ACKNOW;
1288 }
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298 if ((ti->ti_len || (tiflags&TH_FIN)) &&
1299 TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1300 TCP_REASS(tp, ti, m, so, tiflags);
1301 } else {
1302 m_free(m);
1303 tiflags &= ~TH_FIN;
1304 }
1305
1306
1307
1308
1309
1310 if (tiflags & TH_FIN) {
1311 if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321 sofwdrain(so);
1322
1323 tp->t_flags |= TF_ACKNOW;
1324 tp->rcv_nxt++;
1325 }
1326 switch (tp->t_state) {
1327
1328
1329
1330
1331
1332 case TCPS_SYN_RECEIVED:
1333 case TCPS_ESTABLISHED:
1334 if(so->so_emu == EMU_CTL)
1335 tp->t_state = TCPS_LAST_ACK;
1336 else
1337 tp->t_state = TCPS_CLOSE_WAIT;
1338 break;
1339
1340
1341
1342
1343
1344 case TCPS_FIN_WAIT_1:
1345 tp->t_state = TCPS_CLOSING;
1346 break;
1347
1348
1349
1350
1351
1352
1353 case TCPS_FIN_WAIT_2:
1354 tp->t_state = TCPS_TIME_WAIT;
1355 tcp_canceltimers(tp);
1356 tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1357 break;
1358
1359
1360
1361
1362 case TCPS_TIME_WAIT:
1363 tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1364 break;
1365 }
1366 }
1367
1368
1369
1370
1371 if (needoutput || (tp->t_flags & TF_ACKNOW)) {
1372 (void) tcp_output(tp);
1373 }
1374 return;
1375
1376dropafterack:
1377
1378
1379
1380
1381 if (tiflags & TH_RST)
1382 goto drop;
1383 m_free(m);
1384 tp->t_flags |= TF_ACKNOW;
1385 (void) tcp_output(tp);
1386 return;
1387
1388dropwithreset:
1389
1390 if (tiflags & TH_ACK)
1391 tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST, af);
1392 else {
1393 if (tiflags & TH_SYN) ti->ti_len++;
1394 tcp_respond(tp, ti, m, ti->ti_seq + ti->ti_len, (tcp_seq) 0,
1395 TH_RST | TH_ACK, af);
1396 }
1397
1398 return;
1399
1400drop:
1401
1402
1403
1404 m_free(m);
1405}
1406
1407static void
1408tcp_dooptions(struct tcpcb *tp, u_char *cp, int cnt, struct tcpiphdr *ti)
1409{
1410 uint16_t mss;
1411 int opt, optlen;
1412
1413 DEBUG_CALL("tcp_dooptions");
1414 DEBUG_ARGS((dfd, " tp = %p cnt=%i\n", tp, cnt));
1415
1416 for (; cnt > 0; cnt -= optlen, cp += optlen) {
1417 opt = cp[0];
1418 if (opt == TCPOPT_EOL)
1419 break;
1420 if (opt == TCPOPT_NOP)
1421 optlen = 1;
1422 else {
1423 optlen = cp[1];
1424 if (optlen <= 0)
1425 break;
1426 }
1427 switch (opt) {
1428
1429 default:
1430 continue;
1431
1432 case TCPOPT_MAXSEG:
1433 if (optlen != TCPOLEN_MAXSEG)
1434 continue;
1435 if (!(ti->ti_flags & TH_SYN))
1436 continue;
1437 memcpy((char *) &mss, (char *) cp + 2, sizeof(mss));
1438 NTOHS(mss);
1439 (void) tcp_mss(tp, mss);
1440 break;
1441 }
1442 }
1443}
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453#ifdef notdef
1454
1455void
1456tcp_pulloutofband(so, ti, m)
1457 struct socket *so;
1458 struct tcpiphdr *ti;
1459 register struct mbuf *m;
1460{
1461 int cnt = ti->ti_urp - 1;
1462
1463 while (cnt >= 0) {
1464 if (m->m_len > cnt) {
1465 char *cp = mtod(m, caddr_t) + cnt;
1466 struct tcpcb *tp = sototcpcb(so);
1467
1468 tp->t_iobc = *cp;
1469 tp->t_oobflags |= TCPOOB_HAVEDATA;
1470 memcpy(sp, cp+1, (unsigned)(m->m_len - cnt - 1));
1471 m->m_len--;
1472 return;
1473 }
1474 cnt -= m->m_len;
1475 m = m->m_next;
1476 if (m == 0)
1477 break;
1478 }
1479 panic("tcp_pulloutofband");
1480}
1481
1482#endif
1483
1484
1485
1486
1487
1488
1489static void
1490tcp_xmit_timer(register struct tcpcb *tp, int rtt)
1491{
1492 register short delta;
1493
1494 DEBUG_CALL("tcp_xmit_timer");
1495 DEBUG_ARG("tp = %p", tp);
1496 DEBUG_ARG("rtt = %d", rtt);
1497
1498 if (tp->t_srtt != 0) {
1499
1500
1501
1502
1503
1504
1505
1506 delta = rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
1507 if ((tp->t_srtt += delta) <= 0)
1508 tp->t_srtt = 1;
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519 if (delta < 0)
1520 delta = -delta;
1521 delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
1522 if ((tp->t_rttvar += delta) <= 0)
1523 tp->t_rttvar = 1;
1524 } else {
1525
1526
1527
1528
1529
1530 tp->t_srtt = rtt << TCP_RTT_SHIFT;
1531 tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT - 1);
1532 }
1533 tp->t_rtt = 0;
1534 tp->t_rxtshift = 0;
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547 TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
1548 (short)tp->t_rttmin, TCPTV_REXMTMAX);
1549
1550
1551
1552
1553
1554
1555
1556
1557 tp->t_softerror = 0;
1558}
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576int
1577tcp_mss(struct tcpcb *tp, u_int offer)
1578{
1579 struct socket *so = tp->t_socket;
1580 int mss;
1581
1582 DEBUG_CALL("tcp_mss");
1583 DEBUG_ARG("tp = %p", tp);
1584 DEBUG_ARG("offer = %d", offer);
1585
1586 switch (so->so_ffamily) {
1587 case AF_INET:
1588 mss = min(IF_MTU, IF_MRU) - sizeof(struct tcphdr)
1589 + sizeof(struct ip);
1590 break;
1591 case AF_INET6:
1592 mss = min(IF_MTU, IF_MRU) - sizeof(struct tcphdr)
1593 + sizeof(struct ip6);
1594 break;
1595 default:
1596 g_assert_not_reached();
1597 }
1598
1599 if (offer)
1600 mss = min(mss, offer);
1601 mss = max(mss, 32);
1602 if (mss < tp->t_maxseg || offer != 0)
1603 tp->t_maxseg = mss;
1604
1605 tp->snd_cwnd = mss;
1606
1607 sbreserve(&so->so_snd, TCP_SNDSPACE + ((TCP_SNDSPACE % mss) ?
1608 (mss - (TCP_SNDSPACE % mss)) :
1609 0));
1610 sbreserve(&so->so_rcv, TCP_RCVSPACE + ((TCP_RCVSPACE % mss) ?
1611 (mss - (TCP_RCVSPACE % mss)) :
1612 0));
1613
1614 DEBUG_MISC((dfd, " returning mss = %d\n", mss));
1615
1616 return mss;
1617}
1618