1 /* tcp_input.c 1.28 81/11/23 */ 2 3 #include "../h/param.h" 4 #include "../h/systm.h" 5 #include "../h/mbuf.h" 6 #include "../h/socket.h" 7 #include "../h/socketvar.h" 8 #include "../net/inet.h" 9 #include "../net/inet_pcb.h" 10 #include "../net/inet_systm.h" 11 #include "../net/imp.h" 12 #include "../net/ip.h" 13 #include "../net/ip_var.h" 14 #include "../net/tcp.h" 15 #include "../net/tcp_fsm.h" 16 #include "../net/tcp_var.h" 17 #include "/usr/include/errno.h" 18 19 int tcpcksum = 1; 20 21 tcp_drain() 22 { 23 register struct inpcb *ip; 24 25 COUNT(TCP_DRAIN); 26 for (ip = tcb.inp_next; ip != &tcb; ip = ip->inp_next) 27 tcp_drainunack(intotcpcb(ip)); 28 } 29 30 tcp_drainunack(tp) 31 register struct tcpcb *tp; 32 { 33 register struct mbuf *m; 34 35 COUNT(TCP_DRAINUNACK); 36 for (m = tp->seg_unack; m; m = m->m_act) 37 m_freem(m); 38 tp->seg_unack = 0; 39 } 40 41 tcp_ctlinput(m) 42 struct mbuf *m; 43 { 44 45 COUNT(TCP_CTLINPUT); 46 m_freem(m); 47 } 48 49 struct sockaddr_in tcp_sockaddr = { AF_INET }; 50 51 tcp_input(m0) 52 struct mbuf *m0; 53 { 54 register struct tcpiphdr *ti; 55 struct inpcb *inp; 56 register struct mbuf *m; 57 int len, tlen, off; 58 59 register struct tcpcb *tp; 60 register int j; 61 register int tiflags; 62 int nstate; 63 struct socket *so; 64 #ifdef TCPDEBUG 65 struct tcp_debug tdb; 66 #endif 67 68 COUNT(TCP_INPUT); 69 /* 70 * Get ip and tcp header together in first mbuf. 71 */ 72 m = m0; 73 if (m->m_len < sizeof (struct tcpiphdr) && 74 m_pullup(m, sizeof (struct tcpiphdr)) == 0) { 75 tcpstat.tcps_hdrops++; 76 goto bad; 77 } 78 ti = mtod(m, struct tcpiphdr *); 79 if (ti->ti_len > sizeof (struct ip)) 80 ip_stripoptions((struct ip *)ti, (char *)0); 81 82 /* 83 * Checksum extended tcp header and data. 84 */ 85 tlen = ((struct ip *)ti)->ip_len; 86 len = sizeof (struct ip) + tlen; 87 if (tcpcksum) { 88 ti->ti_next = ti->ti_prev = 0; 89 ti->ti_x1 = 0; 90 ti->ti_len = htons((u_short)tlen); 91 if ((ti->ti_sum = inet_cksum(m, len)) != 0xffff) { 92 tcpstat.tcps_badsum++; 93 printf("tcp cksum %x\ti", ti->ti_sum); 94 goto bad; 95 } 96 } 97 98 /* 99 * Check that tcp offset makes sense, 100 * process tcp options and adjust length. 101 */ 102 off = ti->ti_off << 2; 103 if (off < sizeof (struct tcphdr) || off > ti->ti_len) { 104 tcpstat.tcps_badoff++; 105 goto bad; 106 } 107 ti->ti_len = tlen - off; 108 /* PROCESS OPTIONS */ 109 110 /* 111 * Locate pcb for segment. 112 */ 113 inp = in_pcblookup(&tcb, ti->ti_src, ti->ti_sport, ti->ti_dst, ti->ti_dport); 114 if (inp == 0) 115 goto notwanted; 116 tp = intotcpcb(inp); /* ??? */ 117 if (tp == 0) /* ??? */ 118 goto notwanted; /* ??? */ 119 120 /* 121 * Convert tcp protocol specific fields to host format. 122 */ 123 ti->ti_seq = ntohl(ti->ti_seq); 124 ti->ti_ackno = ntohl((n_long)ti->ti_ackno); 125 ti->ti_win = ntohs(ti->ti_win); 126 ti->ti_urp = ntohs(ti->ti_urp); 127 128 /* 129 * Check segment seq # and do rst processing 130 */ 131 tiflags = ti->ti_flags; 132 switch (tp->t_state) { 133 134 case LISTEN: 135 if ((tiflags&TH_ACK) || (tiflags&TH_SYN) == 0) { 136 tcp_sndrst(tp, ti); 137 goto bad; 138 } 139 if (tiflags&TH_RST) 140 goto bad; 141 goto good; 142 143 case SYN_SENT: 144 if (!ack_ok(tp, ti) || (tiflags&TH_SYN) == 0) { 145 tcp_sndrst(tp, ti); /* 71,72,75 */ 146 goto bad; 147 } 148 if (tiflags&TH_RST) { 149 tcp_error(tp, ENETRESET); 150 tcp_detach(tp); /* 70 */ 151 tp->t_state = CLOSED; 152 goto bad; 153 } 154 goto good; 155 156 default: 157 if ((tiflags&TH_RST) == 0) 158 goto common; 159 if (ti->ti_seq < tp->rcv_nxt) /* bad rst */ 160 goto bad; /* 69 */ 161 switch (tp->t_state) { 162 163 case L_SYN_RCVD: 164 if (ack_ok(tp, ti) == 0) 165 goto bad; /* 69 */ 166 tp->t_rexmt = 0; 167 tp->t_rexmttl = 0; 168 tp->t_persist = 0; 169 inp->inp_faddr.s_addr = 0; 170 tp->t_state = LISTEN; 171 goto bad; 172 173 default: 174 tcp_error(tp, ENETRESET); 175 tcp_detach(tp); /* 66 */ 176 tp->t_state = CLOSED; 177 goto bad; 178 } 179 /*NOTREACHED*/ 180 181 case SYN_RCVD: 182 common: 183 if (ack_ok(tp, ti) == 0) { 184 tcp_sndrst(tp, ti); /* 74 */ 185 goto bad; 186 } 187 if ((tiflags&TH_SYN) == 0 && ti->ti_seq != tp->irs) { 188 tcp_sndnull(tp); /* 74 */ 189 goto bad; 190 } 191 goto good; 192 } 193 bad: 194 m_freem(m); 195 return; 196 197 good: 198 /* 199 * Defer processing if no buffer space for this connection. 200 */ 201 so = inp->inp_socket; 202 if (so->so_rcv.sb_cc >= so->so_rcv.sb_hiwat && 203 ti->ti_len != 0 && mbstat.m_bufs < mbstat.m_lowat) { 204 /* 205 m->m_act = (struct mbuf *)0; 206 if ((m = tp->seg_unack) != NULL) { 207 while (m->m_act != NULL) 208 m = m->m_act; 209 m->m_act = m0; 210 } else 211 tp->seg_unack = m0; 212 */ 213 m_freem(m0); 214 return; 215 } 216 217 /* 218 * Discard ip header, and do tcp input processing. 219 */ 220 off += sizeof (struct ip); 221 m->m_off += off; 222 m->m_len -= off; 223 nstate = tp->t_state; 224 tp->tc_flags &= ~TC_NET_KEEP; 225 #ifdef KPROF 226 acounts[tp->t_state][INRECV]++; 227 #endif 228 #ifdef TCPDEBUG 229 if ((tp->t_socket->so_options & SO_DEBUG) || tcpconsdebug) { 230 tdb_setup(tp, ti, INRECV, &tdb); 231 } else 232 tdb.td_tod = 0; 233 #endif 234 switch (tp->t_state) { 235 236 case LISTEN: 237 tcp_sockaddr.sin_addr = ti->ti_src; 238 tcp_sockaddr.sin_port = ti->ti_sport; 239 if ((tiflags&TH_SYN) == 0 || in_pcbsetpeer(inp, &tcp_sockaddr)) { 240 nstate = EFAILEC; 241 goto done; 242 } 243 tp->t_template = tcp_template(tp); 244 tcp_ctldat(tp, ti, 1); 245 if (tp->tc_flags&TC_FIN_RCVD) { 246 tp->t_finack = T_2ML; /* 3 */ 247 tp->tc_flags &= ~TC_WAITED_2_ML; 248 nstate = CLOSE_WAIT; 249 } else { 250 tp->t_init = T_INIT / 2; /* 4 */ 251 nstate = L_SYN_RCVD; 252 } 253 goto done; 254 255 case SYN_SENT: 256 if (!syn_ok(tp, ti)) { 257 nstate = EFAILEC; 258 goto done; 259 } 260 tcp_ctldat(tp, ti, 1); 261 if (tp->tc_flags&TC_FIN_RCVD) { 262 if ((tiflags&TH_ACK) == 0) { 263 tp->t_finack = T_2ML; /* 9 */ 264 tp->tc_flags &= ~TC_WAITED_2_ML; 265 } 266 nstate = CLOSE_WAIT; 267 goto done; 268 } 269 nstate = (tiflags&TH_ACK) ? ESTAB : SYN_RCVD; /* 11:8 */ 270 goto done; 271 272 case SYN_RCVD: 273 case L_SYN_RCVD: 274 if ((tiflags&TH_ACK) == 0 || 275 (tiflags&TH_ACK) && ti->ti_ackno <= tp->iss) { 276 nstate = EFAILEC; 277 goto done; 278 } 279 goto input; 280 281 case ESTAB: 282 case FIN_W1: 283 case FIN_W2: 284 case TIME_WAIT: 285 input: 286 tcp_ctldat(tp, ti, 1); /* 39 */ 287 switch (tp->t_state) { 288 289 case ESTAB: 290 if (tp->tc_flags&TC_FIN_RCVD) 291 nstate = CLOSE_WAIT; 292 break; 293 294 case SYN_RCVD: 295 case L_SYN_RCVD: 296 nstate = (tp->tc_flags&TC_FIN_RCVD) ? 297 CLOSE_WAIT : ESTAB; /* 33:5 */ 298 break; 299 300 case FIN_W1: 301 j = ack_fin(tp, ti); 302 if ((tp->tc_flags & TC_FIN_RCVD) == 0) { 303 if (j) 304 nstate = FIN_W2; /* 27 */ 305 break; 306 } 307 tp->t_finack = T_2ML; 308 tp->tc_flags &= ~TC_WAITED_2_ML; 309 nstate = j ? TIME_WAIT : CLOSING; /* 28:26 */ 310 break; 311 312 case FIN_W2: 313 if (tp->tc_flags&TC_FIN_RCVD) { 314 tp->t_finack = T_2ML; /* 29 */ 315 tp->tc_flags &= ~TC_WAITED_2_ML; 316 nstate = TIME_WAIT; 317 break; 318 } 319 break; 320 } 321 goto done; 322 323 case CLOSE_WAIT: 324 if (tiflags&TH_FIN) { 325 if ((tiflags&TH_ACK) && 326 ti->ti_ackno <= tp->seq_fin) { 327 tcp_ctldat(tp, ti, 0); /* 30 */ 328 tp->t_finack = T_2ML; 329 tp->tc_flags &= ~TC_WAITED_2_ML; 330 } else 331 (void) tcp_sndctl(tp); /* 31 */ 332 goto done; 333 } 334 goto input; 335 336 case CLOSING: 337 j = ack_fin(tp, ti); 338 if (tiflags&TH_FIN) { 339 tcp_ctldat(tp, ti, 0); 340 tp->t_finack = T_2ML; 341 tp->tc_flags &= ~TC_WAITED_2_ML; 342 if (j) 343 nstate = TIME_WAIT; /* 23 */ 344 goto done; 345 } 346 if (j) { 347 if (tp->tc_flags&TC_WAITED_2_ML) 348 if (rcv_empty(tp)) { 349 sorwakeup(inp->inp_socket); 350 nstate = CLOSED; /* 15 */ 351 } else 352 nstate = RCV_WAIT; /* 18 */ 353 else 354 nstate = TIME_WAIT; 355 goto done; 356 } 357 goto input; 358 359 case LAST_ACK: 360 if (ack_fin(tp, ti)) { 361 if (rcv_empty(tp)) { /* 16 */ 362 sorwakeup(inp->inp_socket); 363 nstate = CLOSED; 364 } else 365 nstate = RCV_WAIT; /* 19 */ 366 goto done; 367 } 368 if (tiflags&TH_FIN) { 369 (void) tcp_sndctl(tp); /* 31 */ 370 goto done; 371 } 372 goto input; 373 374 case RCV_WAIT: 375 if ((tiflags&TH_FIN) && (tiflags&TH_ACK) && 376 ti->ti_ackno <= tp->seq_fin) { 377 tcp_ctldat(tp, ti, 0); 378 tp->t_finack = T_2ML; 379 tp->tc_flags &= ~TC_WAITED_2_ML; /* 30 */ 380 } 381 goto done; 382 } 383 panic("tcp_input"); 384 done: 385 386 /* 387 * Done with state*input specific processing. 388 * Form trace records, free input if not needed, 389 * and enter new state. 390 */ 391 #ifdef TCPDEBUG 392 if (tdb.td_tod) 393 tdb_stuff(&tdb, nstate); 394 #endif 395 switch (nstate) { 396 397 case EFAILEC: 398 m_freem(m); 399 return; 400 401 default: 402 tp->t_state = nstate; 403 /* fall into ... */ 404 405 case CLOSED: 406 /* IF CLOSED CANT LOOK AT tc_flags */ 407 if ((tp->tc_flags&TC_NET_KEEP) == 0) { 408 register struct mbuf *n; 409 /* inline expansion of m_freem */ 410 while (m) { 411 MFREE(m, n); 412 m = n; 413 } 414 } 415 return; 416 } 417 /* NOTREACHED */ 418 419 /* 420 * Unwanted packed; free everything 421 * but the header and return an rst. 422 */ 423 notwanted: 424 m_freem(m->m_next); 425 m->m_next = NULL; 426 m->m_len = sizeof(struct tcpiphdr); 427 #define xchg(a,b) j=a; a=b; b=j 428 xchg(ti->ti_dst.s_addr, ti->ti_src.s_addr); 429 xchg(ti->ti_dport, ti->ti_sport); 430 #undef xchg 431 if (tiflags&TH_ACK) 432 ti->ti_seq = ti->ti_ackno; 433 else { 434 ti->ti_ackno = htonl((unsigned)(ntohl(ti->ti_seq) + ti->ti_len)); 435 ti->ti_seq = 0; 436 } 437 ti->ti_flags = ((tiflags & TH_ACK) ? 0 : TH_ACK) | TH_RST; 438 ti->ti_len = htons(TCPSIZE); 439 ti->ti_off = 5; 440 ti->ti_sum = inet_cksum(m, sizeof(struct tcpiphdr)); 441 ((struct ip *)ti)->ip_len = sizeof(struct tcpiphdr); 442 ((struct ip *)ti)->ip_ttl = MAXTTL; 443 ip_output(m); 444 tcpstat.tcps_badsegs++; 445 } 446 447 tcp_ctldat(tp, n0, dataok) 448 register struct tcpcb *tp; 449 struct tcpiphdr *n0; 450 int dataok; 451 { 452 register struct tcpiphdr *ti = n0; 453 register int tiflags = ti->ti_flags; 454 struct socket *so = tp->t_inpcb->inp_socket; 455 seq_t past = ti->ti_seq + ti->ti_len; 456 seq_t urgent; 457 int sent; 458 COUNT(TCP_CTLDAT); 459 460 if (tiflags & TH_URG) 461 urgent = ti->ti_seq + ti->ti_urp; 462 tp->tc_flags &= ~(TC_ACK_DUE|TC_NEW_WINDOW); 463 /* syn */ 464 if ((tp->tc_flags&TC_SYN_RCVD) == 0 && (tiflags&TH_SYN)) { 465 tp->irs = ti->ti_seq; 466 tp->rcv_nxt = ti->ti_seq + 1; 467 tp->snd_wl = tp->rcv_urp = tp->irs; 468 tp->tc_flags |= (TC_SYN_RCVD|TC_ACK_DUE); 469 } 470 /* ack */ 471 if ((tiflags&TH_ACK) && (tp->tc_flags&TC_SYN_RCVD) && 472 ti->ti_ackno > tp->snd_una) { 473 /* 474 * Reflect newly acknowledged data. 475 */ 476 tp->snd_una = ti->ti_ackno; 477 if (tp->snd_una > tp->snd_nxt) 478 tp->snd_nxt = tp->snd_una; 479 480 /* 481 * If timed msg acked, update retransmit time value. 482 */ 483 if ((tp->tc_flags&TC_SYN_ACKED) && 484 tp->snd_una > tp->t_xmt_val) { 485 /* NEED SMOOTHING HERE */ 486 tp->t_xmtime = (tp->t_xmt != 0 ? tp->t_xmt : T_REXMT); 487 if (tp->t_xmtime > T_REMAX) 488 tp->t_xmtime = T_REMAX; 489 } 490 491 /* 492 * Remove acked data from send buf 493 */ 494 sbdrop(&so->so_snd, (int)(tp->snd_una - tp->snd_off)); 495 tp->snd_off = tp->snd_una; 496 if ((tp->tc_flags&TC_SYN_ACKED) == 0 && 497 (tp->snd_una > tp->iss)) { 498 tp->tc_flags |= TC_SYN_ACKED; 499 tp->t_init = 0; 500 } 501 if (tp->seq_fin != tp->iss && tp->snd_una > tp->seq_fin) 502 tp->tc_flags &= ~TC_SND_FIN; 503 tp->t_rexmt = 0; 504 tp->t_rexmttl = 0; 505 tp->tc_flags |= TC_CANCELLED; 506 sowwakeup(tp->t_inpcb->inp_socket); 507 } 508 /* win */ 509 if ((tp->tc_flags & TC_SYN_RCVD) && ti->ti_seq >= tp->snd_wl) { 510 tp->snd_wl = ti->ti_seq; 511 tp->snd_wnd = ti->ti_win; 512 tp->tc_flags |= TC_NEW_WINDOW; 513 tp->t_persist = 0; 514 } 515 /* text */ 516 if (dataok && ti->ti_len) { 517 register struct tcpiphdr *q; 518 int overage; 519 520 /* eol */ 521 if ((tiflags&TH_EOL)) { 522 register struct mbuf *m; 523 for (m = dtom(ti); m->m_next; m = m->m_next) 524 ; 525 m->m_act = (struct mbuf *)(mtod(m, caddr_t) - 1); 526 } 527 528 /* text */ 529 /* 530 * Discard duplicate data already passed to user. 531 */ 532 if (SEQ_LT(ti->ti_seq, tp->rcv_nxt)) { 533 register int i = tp->rcv_nxt - ti->ti_seq; 534 if (i >= ti->ti_len) 535 goto notext; 536 ti->ti_seq += i; 537 ti->ti_len -= i; 538 m_adj(dtom(ti), i); 539 } 540 541 /* 542 * Find a segment which begins after this one does. 543 */ 544 for (q = tp->seg_next; q != (struct tcpiphdr *)tp; 545 q = (struct tcpiphdr *)q->ti_next) 546 if (SEQ_GT(q->ti_seq, ti->ti_seq)) 547 break; 548 549 /* 550 * If there is a preceding segment, it may provide some of 551 * our data already. If so, drop the data from the incoming 552 * segment. If it provides all of our data, drop us. 553 */ 554 if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) { 555 register int i; 556 q = (struct tcpiphdr *)(q->ti_prev); 557 /* conversion to int (in i) handles seq wraparound */ 558 i = q->ti_seq + q->ti_len - ti->ti_seq; 559 if (i > 0) { 560 if (i >= ti->ti_len) 561 goto notext; 562 /* w/o setting TC_NET_KEEP */ 563 m_adj(dtom(tp), i); 564 ti->ti_len -= i; 565 ti->ti_seq += i; 566 } 567 q = (struct tcpiphdr *)(q->ti_next); 568 } 569 570 /* 571 * While we overlap succeeding segments trim them or, 572 * if they are completely covered, dequeue them. 573 */ 574 while (q != (struct tcpiphdr *)tp && 575 SEQ_GT(ti->ti_seq + ti->ti_len, q->ti_seq)) { 576 register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq; 577 if (i < q->ti_len) { 578 q->ti_len -= i; 579 m_adj(dtom(q), i); 580 break; 581 } 582 q = (struct tcpiphdr *)q->ti_next; 583 m_freem(dtom(q->ti_prev)); 584 remque(q->ti_prev); 585 } 586 587 /* 588 * Stick new segment in its place. 589 */ 590 insque(ti, q->ti_prev); 591 tp->seqcnt += ti->ti_len; 592 593 /* 594 * Calculate available space and discard segments for 595 * which there is too much. 596 */ 597 overage = 598 (so->so_rcv.sb_cc /*XXX+tp->rcv_seqcnt*/) - so->so_rcv.sb_hiwat; 599 if (overage > 0) { 600 q = tp->seg_prev; 601 for (;;) { 602 register int i = MIN(q->ti_len, overage); 603 overage -= i; 604 q->ti_len -= i; 605 m_adj(dtom(q), -i); 606 if (q->ti_len) 607 break; 608 if (q == ti) 609 panic("tcp_text dropall"); 610 q = (struct tcpiphdr *)q->ti_prev; 611 remque(q->ti_next); 612 } 613 } 614 615 /* 616 * Advance rcv_next through newly completed sequence space. 617 */ 618 while (ti->ti_seq == tp->rcv_nxt) { 619 tp->rcv_nxt += ti->ti_len; 620 ti = (struct tcpiphdr *)ti->ti_next; 621 if (ti == (struct tcpiphdr *)tp) 622 break; 623 } 624 /* urg */ 625 if (tiflags&TH_URG) { 626 /* ... */ 627 if (SEQ_GT(urgent, tp->rcv_urp)) 628 tp->rcv_urp = urgent; 629 } 630 tp->tc_flags |= (TC_ACK_DUE|TC_NET_KEEP); 631 } 632 notext: 633 /* fin */ 634 if ((tiflags&TH_FIN) && past == tp->rcv_nxt) { 635 if ((tp->tc_flags&TC_FIN_RCVD) == 0) { 636 tp->tc_flags |= TC_FIN_RCVD; 637 sorwakeup(so); 638 tp->rcv_nxt++; 639 } 640 tp->tc_flags |= TC_ACK_DUE; 641 } 642 /* respond */ 643 sent = 0; 644 if (tp->tc_flags&TC_ACK_DUE) 645 sent = tcp_sndctl(tp); 646 else if ((tp->tc_flags&TC_NEW_WINDOW)) 647 if (tp->snd_nxt <= tp->snd_off + so->so_snd.sb_cc || 648 (tp->tc_flags&TC_SND_FIN)) 649 sent = tcp_send(tp); 650 651 /* set for retrans */ 652 if (!sent && tp->snd_una < tp->snd_nxt && 653 (tp->tc_flags&TC_CANCELLED)) { 654 tp->t_rexmt = tp->t_xmtime; 655 tp->t_rexmttl = T_REXMTTL; 656 tp->t_rexmt_val = tp->t_rtl_val = tp->snd_lst; 657 tp->tc_flags &= ~TC_CANCELLED; 658 } 659 /* present data to user */ 660 if ((tp->tc_flags&TC_SYN_ACKED) == 0) 661 return; 662 ti = tp->seg_next; 663 while (ti != (struct tcpiphdr *)tp && ti->ti_seq < tp->rcv_nxt) { 664 remque(ti); 665 sbappend(&so->so_rcv, dtom(ti)); 666 tp->seqcnt -= ti->ti_len; 667 if (tp->seqcnt < 0) 668 panic("tcp_input present"); 669 ti = (struct tcpiphdr *)ti->ti_next; 670 } 671 sorwakeup(so); 672 } 673