1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Implementation of the Transmission Control Protocol(TCP). 7 * 8 * Version: @(#)tcp.c 1.0.16 05/25/93 9 * 10 * Authors: Ross Biro, <bir7@leland.Stanford.Edu> 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Mark Evans, <evansmp@uhura.aston.ac.uk> 13 * Corey Minyard <wf-rch!minyard@relay.EU.net> 14 * Florian La Roche, <flla@stud.uni-sb.de> 15 * Charles Hedrick, <hedrick@klinzhai.rutgers.edu> 16 * Linus Torvalds, <torvalds@cs.helsinki.fi> 17 * Alan Cox, <gw4pts@gw4pts.ampr.org> 18 * Matthew Dillon, <dillon@apollo.west.oic.com> 19 * Arnt Gulbrandsen, <agulbra@nvg.unit.no> 20 * Jorge Cwik, <jorge@laser.satlink.net> 21 * 22 * Fixes: 23 * Alan Cox : Numerous verify_area() calls 24 * Alan Cox : Set the ACK bit on a reset 25 * Alan Cox : Stopped it crashing if it closed while 26 * sk->inuse=1 and was trying to connect 27 * (tcp_err()). 28 * Alan Cox : All icmp error handling was broken 29 * pointers passed where wrong and the 30 * socket was looked up backwards. Nobody 31 * tested any icmp error code obviously. 32 * Alan Cox : tcp_err() now handled properly. It 33 * wakes people on errors. select 34 * behaves and the icmp error race 35 * has gone by moving it into sock.c 36 * Alan Cox : tcp_send_reset() fixed to work for 37 * everything not just packets for 38 * unknown sockets. 39 * Alan Cox : tcp option processing. 40 * Alan Cox : Reset tweaked (still not 100%) [Had 41 * syn rule wrong] 42 * Herp Rosmanith : More reset fixes 43 * Alan Cox : No longer acks invalid rst frames. 44 * Acking any kind of RST is right out. 45 * Alan Cox : Sets an ignore me flag on an rst 46 * receive otherwise odd bits of prattle 47 * escape still 48 * Alan Cox : Fixed another acking RST frame bug. 49 * Should stop LAN workplace lockups. 50 * Alan Cox : Some tidyups using the new skb list 51 * facilities 52 * Alan Cox : sk->keepopen now seems to work 53 * Alan Cox : Pulls options out correctly on accepts 54 * Alan Cox : Fixed assorted sk->rqueue->next errors 55 * Alan Cox : PSH doesn't end a TCP read. Switched a 56 * bit to skb ops. 57 * Alan Cox : Tidied tcp_data to avoid a potential 58 * nasty. 59 * Alan Cox : Added some better commenting, as the 60 * tcp is hard to follow 61 * Alan Cox : Removed incorrect check for 20 * psh 62 * Michael O'Reilly : ack < copied bug fix. 63 * Johannes Stille : Misc tcp fixes (not all in yet). 64 * Alan Cox : FIN with no memory -> CRASH 65 * Alan Cox : Added socket option proto entries. 66 * Also added awareness of them to accept. 67 * Alan Cox : Added TCP options (SOL_TCP) 68 * Alan Cox : Switched wakeup calls to callbacks, 69 * so the kernel can layer network 70 * sockets. 71 * Alan Cox : Use ip_tos/ip_ttl settings. 72 * Alan Cox : Handle FIN (more) properly (we hope). 73 * Alan Cox : RST frames sent on unsynchronised 74 * state ack error. 75 * Alan Cox : Put in missing check for SYN bit. 76 * Alan Cox : Added tcp_select_window() aka NET2E 77 * window non shrink trick. 78 * Alan Cox : Added a couple of small NET2E timer 79 * fixes 80 * Charles Hedrick : TCP fixes 81 * Toomas Tamm : TCP window fixes 82 * Alan Cox : Small URG fix to rlogin ^C ack fight 83 * Charles Hedrick : Rewrote most of it to actually work 84 * Linus : Rewrote tcp_read() and URG handling 85 * completely 86 * Gerhard Koerting: Fixed some missing timer handling 87 * Matthew Dillon : Reworked TCP machine states as per RFC 88 * Gerhard Koerting: PC/TCP workarounds 89 * Adam Caldwell : Assorted timer/timing errors 90 * Matthew Dillon : Fixed another RST bug 91 * Alan Cox : Move to kernel side addressing changes. 92 * Alan Cox : Beginning work on TCP fastpathing 93 * (not yet usable) 94 * Arnt Gulbrandsen: Turbocharged tcp_check() routine. 95 * Alan Cox : TCP fast path debugging 96 * Alan Cox : Window clamping 97 * Michael Riepe : Bug in tcp_check() 98 * Matt Dillon : More TCP improvements and RST bug fixes 99 * Matt Dillon : Yet more small nasties remove from the 100 * TCP code (Be very nice to this man if 101 * tcp finally works 100%) 8) 102 * Alan Cox : BSD accept semantics. 103 * Alan Cox : Reset on closedown bug. 104 * Peter De Schrijver : ENOTCONN check missing in tcp_sendto(). 105 * Michael Pall : Handle select() after URG properly in 106 * all cases. 107 * Michael Pall : Undo the last fix in tcp_read_urg() 108 * (multi URG PUSH broke rlogin). 109 * Michael Pall : Fix the multi URG PUSH problem in 110 * tcp_readable(), select() after URG 111 * works now. 112 * Michael Pall : recv(...,MSG_OOB) never blocks in the 113 * BSD api. 114 * Alan Cox : Changed the semantics of sk->socket to 115 * fix a race and a signal problem with 116 * accept() and async I/O. 117 * Alan Cox : Relaxed the rules on tcp_sendto(). 118 * Yury Shevchuk : Really fixed accept() blocking problem. 119 * Craig I. Hagan : Allow for BSD compatible TIME_WAIT for 120 * clients/servers which listen in on 121 * fixed ports. 122 * Alan Cox : Cleaned the above up and shrank it to 123 * a sensible code size. 124 * Alan Cox : Self connect lockup fix. 125 * Alan Cox : No connect to multicast. 126 * Ross Biro : Close unaccepted children on master 127 * socket close. 128 * Alan Cox : Reset tracing code. 129 * Alan Cox : Spurious resets on shutdown. 130 * Alan Cox : Giant 15 minute/60 second timer error 131 * Alan Cox : Small whoops in selecting before an 132 * accept. 133 * Alan Cox : Kept the state trace facility since 134 * it's handy for debugging. 135 * Alan Cox : More reset handler fixes. 136 * Alan Cox : Started rewriting the code based on 137 * the RFC's for other useful protocol 138 * references see: Comer, KA9Q NOS, and 139 * for a reference on the difference 140 * between specifications and how BSD 141 * works see the 4.4lite source. 142 * A.N.Kuznetsov : Don't time wait on completion of tidy 143 * close. 144 * Linus Torvalds : Fin/Shutdown & copied_seq changes. 145 * Linus Torvalds : Fixed BSD port reuse to work first syn 146 * Alan Cox : Reimplemented timers as per the RFC 147 * and using multiple timers for sanity. 148 * Alan Cox : Small bug fixes, and a lot of new 149 * comments. 150 * Alan Cox : Fixed dual reader crash by locking 151 * the buffers (much like datagram.c) 152 * Alan Cox : Fixed stuck sockets in probe. A probe 153 * now gets fed up of retrying without 154 * (even a no space) answer. 155 * Alan Cox : Extracted closing code better 156 * Alan Cox : Fixed the closing state machine to 157 * resemble the RFC. 158 * Alan Cox : More 'per spec' fixes. 159 * Jorge Cwik : Even faster checksumming. 160 * Alan Cox : tcp_data() doesn't ack illegal PSH 161 * only frames. At least one pc tcp stack 162 * generates them. 163 * Alan Cox : Cache last socket. 164 * Alan Cox : Per route irtt. 165 * Matt Day : Select() match BSD precisely on error 166 * Alan Cox : New buffers 167 * Marc Tamsky : Various sk->prot->retransmits and 168 * sk->retransmits misupdating fixed. 169 * Fixed tcp_write_timeout: stuck close, 170 * and TCP syn retries gets used now. 171 * Mark Yarvis : In tcp_read_wakeup(), don't send an 172 * ack if stat is TCP_CLOSED. 173 * Alan Cox : Look up device on a retransmit - routes may 174 * change. Doesn't yet cope with MSS shrink right 175 * but its a start! 176 * Marc Tamsky : Closing in closing fixes. 177 * Mike Shaver : RFC1122 verifications. 178 * Alan Cox : rcv_saddr errors. 179 * Alan Cox : Block double connect(). 180 * Alan Cox : Small hooks for enSKIP. 181 * Alexey Kuznetsov: Path MTU discovery. 182 * Alan Cox : Support soft errors. 183 * Alan Cox : Fix MTU discovery pathalogical case 184 * when the remote claims no mtu! 185 * Marc Tamsky : TCP_CLOSE fix. 186 * Colin (G3TNE) : Send a reset on syn ack replies in 187 * window but wrong (fixes NT lpd problems) 188 * Pedro Roque : Better TCP window handling, delayed ack. 189 * Joerg Reuter : No modification of locked buffers in 190 * tcp_do_retransmit() 191 * 192 * To Fix: 193 * Fast path the code. Two things here - fix the window calculation 194 * so it doesn't iterate over the queue, also spot packets with no funny 195 * options arriving in order and process directly. 196 * 197 * Rewrite output state machine to use a single queue. 198 * Speed up input assembly algorithm. 199 * RFC1323 - PAWS and window scaling. PAWS is required for IPv6 so we 200 * could do with it working on IPv4 201 * User settable/learned rtt/max window/mtu 202 * 203 * Change the fundamental structure to a single send queue maintained 204 * by TCP (removing the bogus ip stuff [thus fixing mtu drops on 205 * active routes too]). Cut the queue off in tcp_retransmit/ 206 * tcp_transmit. 207 * Change the receive queue to assemble as it goes. This lets us 208 * dispose of most of tcp_sequence, half of tcp_ack and chunks of 209 * tcp_data/tcp_read as well as the window shrink crud. 210 * Separate out duplicated code - tcp_alloc_skb, tcp_build_ack 211 * tcp_queue_skb seem obvious routines to extract. 212 * 213 * This program is free software; you can redistribute it and/or 214 * modify it under the terms of the GNU General Public License 215 * as published by the Free Software Foundation; either version 216 * 2 of the License, or(at your option) any later version. 217 * 218 * Description of States: 219 * 220 * TCP_SYN_SENT sent a connection request, waiting for ack 221 * 222 * TCP_SYN_RECV received a connection request, sent ack, 223 * waiting for final ack in three-way handshake. 224 * 225 * TCP_ESTABLISHED connection established 226 * 227 * TCP_FIN_WAIT1 our side has shutdown, waiting to complete 228 * transmission of remaining buffered data 229 * 230 * TCP_FIN_WAIT2 all buffered data sent, waiting for remote 231 * to shutdown 232 * 233 * TCP_CLOSING both sides have shutdown but we still have 234 * data we have to finish sending 235 * 236 * TCP_TIME_WAIT timeout to catch resent junk before entering 237 * closed, can only be entered from FIN_WAIT2 238 * or CLOSING. Required because the other end 239 * may not have gotten our last ACK causing it 240 * to retransmit the data packet (which we ignore) 241 * 242 * TCP_CLOSE_WAIT remote side has shutdown and is waiting for 243 * us to finish writing our data and to shutdown 244 * (we have to close() to move on to LAST_ACK) 245 * 246 * TCP_LAST_ACK out side has shutdown after remote has 247 * shutdown. There may still be data in our 248 * buffer that we have to finish sending 249 * 250 * TCP_CLOSE socket is finished 251 */ 252
253 /* 254 * RFC1122 status: 255 * NOTE: I'm not going to be doing comments in the code for this one except 256 * for violations and the like. tcp.c is just too big... If I say something 257 * "does?" or "doesn't?", it means I'm not sure, and will have to hash it out 258 * with Alan. -- MS 950903 259 * 260 * Use of PSH (4.2.2.2) 261 * MAY aggregate data sent without the PSH flag. (does) 262 * MAY queue data received without the PSH flag. (does) 263 * SHOULD collapse successive PSH flags when it packetizes data. (doesn't) 264 * MAY implement PSH on send calls. (doesn't, thus:) 265 * MUST NOT buffer data indefinitely (doesn't [1 second]) 266 * MUST set PSH on last segment (does) 267 * MAY pass received PSH to application layer (doesn't) 268 * SHOULD send maximum-sized segment whenever possible. (almost always does) 269 * 270 * Window Size (4.2.2.3, 4.2.2.16) 271 * MUST treat window size as an unsigned number (does) 272 * SHOULD treat window size as a 32-bit number (does not) 273 * MUST NOT shrink window once it is offered (does not normally) 274 * 275 * Urgent Pointer (4.2.2.4) 276 * **MUST point urgent pointer to last byte of urgent data (not right 277 * after). (doesn't, to be like BSD) 278 * MUST inform application layer asynchronously of incoming urgent 279 * data. (does) 280 * MUST provide application with means of determining the amount of 281 * urgent data pending. (does) 282 * **MUST support urgent data sequence of arbitrary length. (doesn't, but 283 * it's sort of tricky to fix, as urg_ptr is a 16-bit quantity) 284 * [Follows BSD 1 byte of urgent data] 285 * 286 * TCP Options (4.2.2.5) 287 * MUST be able to receive TCP options in any segment. (does) 288 * MUST ignore unsupported options (does) 289 * 290 * Maximum Segment Size Option (4.2.2.6) 291 * MUST implement both sending and receiving MSS. (does) 292 * SHOULD send an MSS with every SYN where receive MSS != 536 (MAY send 293 * it always). (does, even when MSS == 536, which is legal) 294 * MUST assume MSS == 536 if no MSS received at connection setup (does) 295 * MUST calculate "effective send MSS" correctly: 296 * min(physical_MTU, remote_MSS+20) - sizeof(tcphdr) - sizeof(ipopts) 297 * (does - but allows operator override) 298 * 299 * TCP Checksum (4.2.2.7) 300 * MUST generate and check TCP checksum. (does) 301 * 302 * Initial Sequence Number Selection (4.2.2.8) 303 * MUST use the RFC 793 clock selection mechanism. (doesn't, but it's 304 * OK: RFC 793 specifies a 250KHz clock, while we use 1MHz, which is 305 * necessary for 10Mbps networks - and harder than BSD to spoof!) 306 * 307 * Simultaneous Open Attempts (4.2.2.10) 308 * MUST support simultaneous open attempts (does) 309 * 310 * Recovery from Old Duplicate SYN (4.2.2.11) 311 * MUST keep track of active vs. passive open (does) 312 * 313 * RST segment (4.2.2.12) 314 * SHOULD allow an RST segment to contain data (does, but doesn't do 315 * anything with it, which is standard) 316 * 317 * Closing a Connection (4.2.2.13) 318 * MUST inform application of whether connectin was closed by RST or 319 * normal close. (does) 320 * MAY allow "half-duplex" close (treat connection as closed for the 321 * local app, even before handshake is done). (does) 322 * MUST linger in TIME_WAIT for 2 * MSL (does) 323 * 324 * Retransmission Timeout (4.2.2.15) 325 * MUST implement Jacobson's slow start and congestion avoidance 326 * stuff. (does) 327 * 328 * Probing Zero Windows (4.2.2.17) 329 * MUST support probing of zero windows. (does) 330 * MAY keep offered window closed indefinitely. (does) 331 * MUST allow remote window to stay closed indefinitely. (does) 332 * 333 * Passive Open Calls (4.2.2.18) 334 * MUST NOT let new passive open affect other connections. (doesn't) 335 * MUST support passive opens (LISTENs) concurrently. (does) 336 * 337 * Time to Live (4.2.2.19) 338 * MUST make TCP TTL configurable. (does - IP_TTL option) 339 * 340 * Event Processing (4.2.2.20) 341 * SHOULD queue out-of-order segments. (does) 342 * MUST aggregate ACK segments whenever possible. (does but badly) 343 * 344 * Retransmission Timeout Calculation (4.2.3.1) 345 * MUST implement Karn's algorithm and Jacobson's algorithm for RTO 346 * calculation. (does, or at least explains them in the comments 8*b) 347 * SHOULD initialize RTO to 0 and RTT to 3. (does) 348 * 349 * When to Send an ACK Segment (4.2.3.2) 350 * SHOULD implement delayed ACK. (does) 351 * MUST keep ACK delay < 0.5 sec. (does) 352 * 353 * When to Send a Window Update (4.2.3.3) 354 * MUST implement receiver-side SWS. (does) 355 * 356 * When to Send Data (4.2.3.4) 357 * MUST implement sender-side SWS. (does) 358 * SHOULD implement Nagle algorithm. (does) 359 * 360 * TCP Connection Failures (4.2.3.5) 361 * MUST handle excessive retransmissions "properly" (see the RFC). (does) 362 * SHOULD inform application layer of soft errors. (does) 363 * 364 * TCP Keep-Alives (4.2.3.6) 365 * MAY provide keep-alives. (does) 366 * MUST make keep-alives configurable on a per-connection basis. (does) 367 * MUST default to no keep-alives. (does) 368 * **MUST make keep-alive interval configurable. (doesn't) 369 * **MUST make default keep-alive interval > 2 hours. (doesn't) 370 * MUST NOT interpret failure to ACK keep-alive packet as dead 371 * connection. (doesn't) 372 * SHOULD send keep-alive with no data. (does) 373 * 374 * TCP Multihoming (4.2.3.7) 375 * MUST get source address from IP layer before sending first 376 * SYN. (does) 377 * MUST use same local address for all segments of a connection. (does) 378 * 379 * IP Options (4.2.3.8) 380 * MUST ignore unsupported IP options. (does) 381 * MAY support Time Stamp and Record Route. (does) 382 * MUST allow application to specify a source route. (does) 383 * MUST allow receieved Source Route option to set route for all future 384 * segments on this connection. (does not (security issues)) 385 * 386 * ICMP messages (4.2.3.9) 387 * MUST act on ICMP errors. (does) 388 * MUST slow transmission upon receipt of a Source Quench. (does) 389 * MUST NOT abort connection upon receipt of soft Destination 390 * Unreachables (0, 1, 5), Time Exceededs and Parameter 391 * Problems. (doesn't) 392 * SHOULD report soft Destination Unreachables etc. to the 393 * application. (does) 394 * SHOULD abort connection upon receipt of hard Destination Unreachable 395 * messages (2, 3, 4). (does) 396 * 397 * Remote Address Validation (4.2.3.10) 398 * MUST reject as an error OPEN for invalid remote IP address. (does) 399 * MUST ignore SYN with invalid source address. (does) 400 * MUST silently discard incoming SYN for broadcast/multicast 401 * address. (does) 402 * 403 * Asynchronous Reports (4.2.4.1) 404 * MUST provide mechanism for reporting soft errors to application 405 * layer. (does) 406 * 407 * Type of Service (4.2.4.2) 408 * MUST allow application layer to set Type of Service. (does IP_TOS) 409 * 410 * (Whew. -- MS 950903) 411 **/ 412
413 #include <linux/config.h>
414 #include <linux/types.h>
415 #include <linux/fcntl.h>
416
417 #include <net/icmp.h>
418 #include <net/tcp.h>
419
420 #include <asm/segment.h>
421
422 unsignedlongseq_offset;
423 structtcp_mibtcp_statistics;
424
425 staticvoidtcp_close(structsock *sk, unsignedlongtimeout);
426
427 /* 428 * The less said about this the better, but it works and will do for 1.2 (and 1.4 ;)) 429 */ 430
431 structwait_queue *master_select_wakeup;
432
433 /* 434 * Find someone to 'accept'. Must be called with 435 * the socket locked or with interrupts disabled 436 */ 437
438 staticstructsk_buff *tcp_find_established(structsock *s)
/* */ 439 { 440 structsk_buff *p=skb_peek(&s->receive_queue);
441 if(p==NULL)
442 returnNULL;
443 do 444 { 445 if(p->sk->state == TCP_ESTABLISHED || p->sk->state >= TCP_FIN_WAIT1)
446 returnp;
447 p=p->next;
448 } 449 while(p!=(structsk_buff *)&s->receive_queue);
450 returnNULL;
451 } 452
453 /* 454 * Remove a completed connection and return it. This is used by 455 * tcp_accept() to get connections from the queue. 456 */ 457
458 staticstructsk_buff *tcp_dequeue_established(structsock *s)
/* */ 459 { 460 structsk_buff *skb;
461 unsignedlongflags;
462 save_flags(flags);
463 cli();
464 skb=tcp_find_established(s);
465 if(skb!=NULL)
466 skb_unlink(skb); /* Take it off the queue */ 467 restore_flags(flags);
468 returnskb;
469 } 470
471 /* 472 * This routine closes sockets which have been at least partially 473 * opened, but not yet accepted. Currently it is only called by 474 * tcp_close, and timeout mirrors the value there. 475 */ 476
477 staticvoidtcp_close_pending (structsock *sk)
/* */ 478 { 479 structsk_buff *skb;
480
481 while ((skb = skb_dequeue(&sk->receive_queue)) != NULL)
482 { 483 tcp_close(skb->sk, 0);
484 kfree_skb(skb, FREE_READ);
485 } 486 return;
487 } 488
489 /* 490 * Enter the time wait state. 491 */ 492
493 voidtcp_time_wait(structsock *sk)
/* */ 494 { 495 tcp_set_state(sk,TCP_TIME_WAIT);
496 sk->shutdown = SHUTDOWN_MASK;
497 if (!sk->dead)
498 sk->state_change(sk);
499 tcp_reset_msl_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
500 } 501
502
503 /* 504 * This routine is called by the ICMP module when it gets some 505 * sort of error condition. If err < 0 then the socket should 506 * be closed and the error returned to the user. If err > 0 507 * it's just the icmp type << 8 | icmp code. After adjustment 508 * header points to the first 8 bytes of the tcp header. We need 509 * to find the appropriate port. 510 */ 511
512 voidtcp_err(inttype, intcode, unsignedchar *header, __u32daddr,
/* */ 513 __u32saddr, structinet_protocol *protocol)
514 { 515 structtcphdr *th = (structtcphdr *)header;
516 structsock *sk;
517
518 /* 519 * This one is _WRONG_. FIXME urgently. 520 */ 521 #ifndefCONFIG_NO_PATH_MTU_DISCOVERY 522 structiphdr *iph=(structiphdr *)(header-sizeof(structiphdr));
523 #endif 524 th =(structtcphdr *)header;
525 sk = get_sock(&tcp_prot, th->source, daddr, th->dest, saddr);
526
527 if (sk == NULL)
528 return;
529
530 if (type == ICMP_SOURCE_QUENCH)
531 { 532 /* 533 * FIXME: 534 * For now we will just trigger a linear backoff. 535 * The slow start code should cause a real backoff here. 536 */ 537 if (sk->cong_window > 4)
538 sk->cong_window--;
539 return;
540 } 541
542 if (type == ICMP_PARAMETERPROB)
543 { 544 sk->err=EPROTO;
545 sk->error_report(sk);
546 } 547
548 #ifndefCONFIG_NO_PATH_MTU_DISCOVERY 549 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
550 { 551 structrtable * rt;
552 /* 553 * Ugly trick to pass MTU to protocol layer. 554 * Really we should add argument "info" to error handler. 555 */ 556 unsignedshortnew_mtu = ntohs(iph->id);
557
558 if ((rt = sk->ip_route_cache) != NULL)
559 if (rt->rt_mtu > new_mtu)
560 rt->rt_mtu = new_mtu;
561
562 if (sk->mtu > new_mtu - sizeof(structiphdr) - sizeof(structtcphdr)
563 && new_mtu > sizeof(structiphdr)+sizeof(structtcphdr))
564 sk->mtu = new_mtu - sizeof(structiphdr) - sizeof(structtcphdr);
565
566 return;
567 } 568 #endif 569
570 /* 571 * If we've already connected we will keep trying 572 * until we time out, or the user gives up. 573 */ 574
575 if (code < 13)
576 { 577 if(icmp_err_convert[code].fatal || sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
578 { 579 sk->err = icmp_err_convert[code].errno;
580 if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
581 { 582 tcp_statistics.TcpAttemptFails++;
583 tcp_set_state(sk,TCP_CLOSE);
584 sk->error_report(sk); /* Wake people up to see the error (see connect in sock.c) */ 585 } 586 } 587 else/* Only an error on timeout */ 588 sk->err_soft = icmp_err_convert[code].errno;
589 } 590 } 591
592
593 /* 594 * Walk down the receive queue counting readable data until we hit the end or we find a gap 595 * in the received data queue (ie a frame missing that needs sending to us). Not 596 * sorting using two queues as data arrives makes life so much harder. 597 */ 598
599 staticinttcp_readable(structsock *sk)
/* */ 600 { 601 unsignedlongcounted;
602 unsignedlongamount;
603 structsk_buff *skb;
604 intsum;
605 unsignedlongflags;
606
607 if(sk && sk->debug)
608 printk("tcp_readable: %p - ",sk);
609
610 save_flags(flags);
611 cli();
612 if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
613 { 614 restore_flags(flags);
615 if(sk && sk->debug)
616 printk("empty\n");
617 return(0);
618 } 619
620 counted = sk->copied_seq; /* Where we are at the moment */ 621 amount = 0;
622
623 /* 624 * Do until a push or until we are out of data. 625 */ 626
627 do 628 { 629 if (before(counted, skb->seq)) /* Found a hole so stops here */ 630 break;
631 sum = skb->len - (counted - skb->seq); /* Length - header but start from where we are up to (avoid overlaps) */ 632 if (skb->h.th->syn)
633 sum++;
634 if (sum > 0)
635 {/* Add it up, move on */ 636 amount += sum;
637 if (skb->h.th->syn)
638 amount--;
639 counted += sum;
640 } 641 /* 642 * Don't count urg data ... but do it in the right place! 643 * Consider: "old_data (ptr is here) URG PUSH data" 644 * The old code would stop at the first push because 645 * it counted the urg (amount==1) and then does amount-- 646 * *after* the loop. This means tcp_readable() always 647 * returned zero if any URG PUSH was in the queue, even 648 * though there was normal data available. If we subtract 649 * the urg data right here, we even get it to work for more 650 * than one URG PUSH skb without normal data. 651 * This means that select() finally works now with urg data 652 * in the queue. Note that rlogin was never affected 653 * because it doesn't use select(); it uses two processes 654 * and a blocking read(). And the queue scan in tcp_read() 655 * was correct. Mike <pall@rz.uni-karlsruhe.de> 656 */ 657 if (skb->h.th->urg)
658 amount--; /* don't count urg data */ 659 if (amount && skb->h.th->psh) break;
660 skb = skb->next;
661 } 662 while(skb != (structsk_buff *)&sk->receive_queue);
663
664 restore_flags(flags);
665 if(sk->debug)
666 printk("got %lu bytes.\n",amount);
667 return(amount);
668 } 669
670 /* 671 * LISTEN is a special case for select.. 672 */ 673 staticinttcp_listen_select(structsock *sk, intsel_type, select_table *wait)
/* */ 674 { 675 if (sel_type == SEL_IN) { 676 intretval;
677
678 lock_sock(sk);
679 retval = (tcp_find_established(sk) != NULL);
680 release_sock(sk);
681 if (!retval)
682 select_wait(&master_select_wakeup,wait);
683 returnretval;
684 } 685 return 0;
686 } 687
688
689 /* 690 * Wait for a TCP event. 691 * 692 * Note that we don't need to lock the socket, as the upper select layers 693 * take care of normal races (between the test and the event) and we don't 694 * go look at any of the socket buffers directly. 695 */ 696 staticinttcp_select(structsock *sk, intsel_type, select_table *wait)
/* */ 697 { 698 if (sk->state == TCP_LISTEN)
699 returntcp_listen_select(sk, sel_type, wait);
700
701 switch(sel_type) { 702 caseSEL_IN:
703 if (sk->err)
704 return 1;
705 if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
706 break;
707
708 if (sk->shutdown & RCV_SHUTDOWN)
709 return 1;
710
711 if (sk->acked_seq == sk->copied_seq)
712 break;
713
714 if (sk->urg_seq != sk->copied_seq ||
715 sk->acked_seq != sk->copied_seq+1 ||
716 sk->urginline || !sk->urg_data)
717 return 1;
718 break;
719
720 caseSEL_OUT:
721 if (sk->err)
722 return 1;
723 if (sk->shutdown & SEND_SHUTDOWN)
724 return 0;
725 if (sk->state == TCP_SYN_SENT || sk->state == TCP_SYN_RECV)
726 break;
727 /* 728 * This is now right thanks to a small fix 729 * by Matt Dillon. 730 */ 731
732 if (sock_wspace(sk) < sk->mtu+128+sk->prot->max_header)
733 break;
734 return 1;
735
736 caseSEL_EX:
737 if (sk->urg_data)
738 return 1;
739 break;
740 } 741 select_wait(sk->sleep, wait);
742 return 0;
743 } 744
745 inttcp_ioctl(structsock *sk, intcmd, unsignedlongarg)
/* */ 746 { 747 interr;
748 switch(cmd)
749 { 750
751 caseTIOCINQ:
752 #ifdef FIXME /* FIXME: */ 753 caseFIONREAD:
754 #endif 755 { 756 unsignedlongamount;
757
758 if (sk->state == TCP_LISTEN)
759 return(-EINVAL);
760
761 lock_sock(sk);
762 amount = tcp_readable(sk);
763 release_sock(sk);
764 err=verify_area(VERIFY_WRITE,(void *)arg, sizeof(int));
765 if(err)
766 returnerr;
767 put_user(amount, (int *)arg);
768 return(0);
769 } 770 caseSIOCATMARK:
771 { 772 intansw = sk->urg_data && sk->urg_seq == sk->copied_seq;
773
774 err = verify_area(VERIFY_WRITE,(void *) arg, sizeof(int));
775 if (err)
776 returnerr;
777 put_user(answ,(int *) arg);
778 return(0);
779 } 780 caseTIOCOUTQ:
781 { 782 unsignedlongamount;
783
784 if (sk->state == TCP_LISTEN) return(-EINVAL);
785 amount = sock_wspace(sk);
786 err=verify_area(VERIFY_WRITE,(void *)arg, sizeof(int));
787 if(err)
788 returnerr;
789 put_user(amount, (int *)arg);
790 return(0);
791 } 792 default:
793 return(-EINVAL);
794 } 795 } 796
797
798 /* 799 * This routine computes a TCP checksum. 800 * 801 * Modified January 1995 from a go-faster DOS routine by 802 * Jorge Cwik <jorge@laser.satlink.net> 803 */ 804 #undefDEBUG_TCP_CHECK 805 voidtcp_send_check(structtcphdr *th, unsignedlongsaddr,
/* */ 806 unsignedlongdaddr, intlen, structsk_buff *skb)
807 { 808 #ifdefDEBUG_TCP_CHECK 809 u16check;
810 #endif 811 th->check = 0;
812 th->check = tcp_check(th, len, saddr, daddr,
813 csum_partial((char *)th,sizeof(*th),skb->csum));
814
815 #ifdefDEBUG_TCP_CHECK 816 check = th->check;
817 th->check = 0;
818 th->check = tcp_check(th, len, saddr, daddr,
819 csum_partial((char *)th,len,0));
820 if (check != th->check) { 821 staticintcount = 0;
822 if (++count < 10) { 823 printk("Checksum %x (%x) from %p\n", th->check, check,
824 (&th)[-1]);
825 printk("TCP=<off:%d a:%d s:%d f:%d>\n", th->doff*4, th->ack, th->syn, th->fin);
826 } 827 } 828 #endif 829 } 830
831
832 /* 833 * This routine builds a generic TCP header. 834 */ 835
836 extern__inlineinttcp_build_header(structtcphdr *th, structsock *sk, intpush)
/* */ 837 { 838
839 memcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
840 th->seq = htonl(sk->write_seq);
841 th->psh =(push == 0) ? 1 : 0;
842 sk->ack_backlog = 0;
843 sk->bytes_rcv = 0;
844 sk->ack_timed = 0;
845 th->ack_seq = htonl(sk->acked_seq);
846 sk->window = tcp_select_window(sk);
847 th->window = htons(sk->window);
848
849 return(sizeof(*th));
850 } 851
852 /* 853 * Wait for a socket to get into the connected state 854 */ 855 staticvoidwait_for_tcp_connect(structsock * sk)
/* */ 856 { 857 release_sock(sk);
858 cli();
859 if (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT && sk->err == 0)
860 { 861 interruptible_sleep_on(sk->sleep);
862 } 863 sti();
864 lock_sock(sk);
865 } 866
867 /* 868 * Wait for more memory for a socket 869 */ 870 staticvoidwait_for_tcp_memory(structsock * sk)
/* */ 871 { 872 release_sock(sk);
873 cli();
874 if (sk->wmem_alloc*2 > sk->sndbuf &&
875 (sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
876 && sk->err == 0)
877 { 878 sk->socket->flags &= ~SO_NOSPACE;
879 interruptible_sleep_on(sk->sleep);
880 } 881 sti();
882 lock_sock(sk);
883 } 884
885
886 /* 887 * This routine copies from a user buffer into a socket, 888 * and starts the transmit system. 889 */ 890
891 staticintdo_tcp_sendmsg(structsock *sk, structmsghdr *msg,
/* */ 892 intlen, intnonblock, intflags)
893 { 894 intcopied = 0;
895 intcopy;
896 inttmp;
897 intseglen;
898 intiovct=0;
899 structsk_buff *skb;
900 structsk_buff *send_tmp;
901 structproto *prot;
902 structdevice *dev = NULL;
903 unsignedchar *from;
904
905 /* 906 * Ok commence sending 907 */ 908
909 while(iovct<msg->msg_iovlen)
910 { 911 seglen=msg->msg_iov[iovct].iov_len;
912 from=msg->msg_iov[iovct++].iov_base;
913 prot = sk->prot;
914 while(seglen > 0)
915 { 916 /* 917 * Stop on errors 918 */ 919 if (sk->err)
920 { 921 if (copied)
922 returncopied;
923 returnsock_error(sk);
924 } 925
926 /* 927 * Make sure that we are established. 928 */ 929 if (sk->shutdown & SEND_SHUTDOWN)
930 { 931 if (copied)
932 returncopied;
933 return -EPIPE;
934 } 935
936 /* 937 * Wait for a connection to finish. 938 */ 939 while (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
940 { 941 if (copied)
942 returncopied;
943
944 if (sk->err)
945 returnsock_error(sk);
946
947 if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
948 { 949 if (sk->keepopen)
950 send_sig(SIGPIPE, current, 0);
951 return -EPIPE;
952 } 953
954 if (nonblock)
955 return -EAGAIN;
956
957 if (current->signal & ~current->blocked)
958 return -ERESTARTSYS;
959
960 wait_for_tcp_connect(sk);
961 } 962
963 /* 964 * The following code can result in copy <= if sk->mss is ever 965 * decreased. It shouldn't be. sk->mss is min(sk->mtu, sk->max_window). 966 * sk->mtu is constant once SYN processing is finished. I.e. we 967 * had better not get here until we've seen his SYN and at least one 968 * valid ack. (The SYN sets sk->mtu and the ack sets sk->max_window.) 969 * But ESTABLISHED should guarantee that. sk->max_window is by definition 970 * non-decreasing. Note that any ioctl to set user_mss must be done 971 * before the exchange of SYN's. If the initial ack from the other 972 * end has a window of 0, max_window and thus mss will both be 0. 973 */ 974
975 /* 976 * Now we need to check if we have a half built packet. 977 */ 978 #ifndefCONFIG_NO_PATH_MTU_DISCOVERY 979 /* 980 * FIXME: I'm almost sure that this fragment is BUG, 981 * but it works... I do not know why 8) --ANK 982 * 983 * Really, we should rebuild all the queues... 984 * It's difficult. Temprorary hack is to send all 985 * queued segments with allowed fragmentation. 986 */ 987 { 988 intnew_mss = min(sk->mtu, sk->max_window);
989 if (new_mss < sk->mss)
990 { 991 tcp_send_partial(sk);
992 sk->mss = new_mss;
993 } 994 } 995 #endif 996
997 if ((skb = tcp_dequeue_partial(sk)) != NULL)
998 { 999 inttcp_size;
1000
1001 tcp_size = skb->tail - (unsignedchar *)(skb->h.th + 1);
1002
1003 /* Add more stuff to the end of skb->len */1004 if (!(flags & MSG_OOB))
1005 {1006 copy = min(sk->mss - tcp_size, seglen);
1007 if (copy <= 0)
1008 {1009 printk("TCP: **bug**: \"copy\" <= 0\n");
1010 return -EFAULT;
1011 }1012 tcp_size += copy;
1013 memcpy_fromfs(skb_put(skb,copy), from, copy);
1014 skb->csum = csum_partial(skb->tail - tcp_size, tcp_size, 0);
1015 from += copy;
1016 copied += copy;
1017 len -= copy;
1018 sk->write_seq += copy;
1019 seglen -= copy;
1020 }1021 if (tcp_size >= sk->mss || (flags & MSG_OOB) || !sk->packets_out)
1022 tcp_send_skb(sk, skb);
1023 else1024 tcp_enqueue_partial(skb, sk);
1025 continue;
1026 }1027
1028 /*1029 * We also need to worry about the window.1030 * If window < 1/2 the maximum window we've seen from this1031 * host, don't use it. This is sender side1032 * silly window prevention, as specified in RFC1122.1033 * (Note that this is different than earlier versions of1034 * SWS prevention, e.g. RFC813.). What we actually do is 1035 * use the whole MSS. Since the results in the right1036 * edge of the packet being outside the window, it will1037 * be queued for later rather than sent.1038 */1039
1040 copy = sk->window_seq - sk->write_seq;
1041 if (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
1042 copy = sk->mss;
1043 if (copy > seglen)
1044 copy = seglen;
1045 if (copy <= 0)
1046 {1047 printk("TCP: **bug**: copy=%d, sk->mss=%d\n", copy, sk->mss);
1048 return -EFAULT;
1049 }1050
1051 /*1052 * We should really check the window here also. 1053 */1054
1055 send_tmp = NULL;
1056 if (copy < sk->mss && !(flags & MSG_OOB) && sk->packets_out)
1057 {1058 skb = sock_wmalloc(sk, sk->mtu + 128 + prot->max_header + 15, 0, GFP_KERNEL);
1059 send_tmp = skb;
1060 }1061 else1062 {1063 skb = sock_wmalloc(sk, copy + prot->max_header + 15 , 0, GFP_KERNEL);
1064 }1065
1066 /*1067 * If we didn't get any memory, we need to sleep. 1068 */1069
1070 if (skb == NULL)
1071 {1072 sk->socket->flags |= SO_NOSPACE;
1073 if (nonblock)
1074 {1075 if (copied)
1076 returncopied;
1077 return -EAGAIN;
1078 }1079
1080 if (current->signal & ~current->blocked)
1081 {1082 if (copied)
1083 returncopied;
1084 return -ERESTARTSYS;
1085 }1086
1087 wait_for_tcp_memory(sk);
1088 continue;
1089 }1090
1091 skb->sk = sk;
1092 skb->free = 0;
1093 skb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
1094
1095 /*1096 * FIXME: we need to optimize this.1097 * Perhaps some hints here would be good.1098 */1099
1100 tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
1101 IPPROTO_TCP, sk->opt, skb->truesize,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
1102 if (tmp < 0 )
1103 {1104 sock_wfree(sk, skb);
1105 if (copied)
1106 return(copied);
1107 return(tmp);
1108 }1109 #ifndefCONFIG_NO_PATH_MTU_DISCOVERY1110 skb->ip_hdr->frag_off |= htons(IP_DF);
1111 #endif1112 skb->dev = dev;
1113 skb->h.th =(structtcphdr *)skb_put(skb,sizeof(structtcphdr));
1114 tmp = tcp_build_header(skb->h.th, sk, seglen-copy);
1115 if (tmp < 0)
1116 {1117 sock_wfree(sk, skb);
1118 if (copied)
1119 return(copied);
1120 return(tmp);
1121 }1122
1123 if (flags & MSG_OOB)
1124 {1125 skb->h.th->urg = 1;
1126 skb->h.th->urg_ptr = ntohs(copy);
1127 }1128
1129 skb->csum = csum_partial_copy_fromuser(from,
1130 skb_put(skb,copy), copy, 0);
1131
1132 from += copy;
1133 copied += copy;
1134 len -= copy;
1135 seglen -= copy;
1136 skb->free = 0;
1137 sk->write_seq += copy;
1138
1139 if (send_tmp != NULL)
1140 {1141 tcp_enqueue_partial(send_tmp, sk);
1142 continue;
1143 }1144 tcp_send_skb(sk, skb);
1145 }1146 }1147 sk->err = 0;
1148
1149 returncopied;
1150 }1151
1152
1153 staticinttcp_sendmsg(structsock *sk, structmsghdr *msg,
/* */1154 intlen, intnonblock, intflags)
1155 {1156 intretval = -EINVAL;
1157
1158 /*1159 * Do sanity checking for sendmsg/sendto/send1160 */1161
1162 if (flags & ~(MSG_OOB|MSG_DONTROUTE))
1163 gotoout;
1164 if (msg->msg_name) {1165 structsockaddr_in *addr=(structsockaddr_in *)msg->msg_name;
1166
1167 if (msg->msg_namelen < sizeof(*addr))
1168 gotoout;
1169 if (addr->sin_family && addr->sin_family != AF_INET)
1170 gotoout;
1171 retval = -ENOTCONN;
1172 if(sk->state == TCP_CLOSE)
1173 gotoout;
1174 retval = -EISCONN;
1175 if (addr->sin_port != sk->dummy_th.dest)
1176 gotoout;
1177 if (addr->sin_addr.s_addr != sk->daddr)
1178 gotoout;
1179 }1180
1181 lock_sock(sk);
1182 retval = do_tcp_sendmsg(sk, msg, len, nonblock, flags);
1183
1184 /*1185 * Nagle's rule. Turn Nagle off with TCP_NODELAY for highly1186 * interactive fast network servers. It's meant to be on and1187 * it really improves the throughput though not the echo time1188 * on my slow slip link - Alan1189 *1190 * If not nagling we can send on the before case too..1191 */1192
1193 if (sk->partial) {1194 if (!sk->packets_out ||
1195 (sk->nonagle && before(sk->write_seq , sk->window_seq))) {1196 tcp_send_partial(sk);
1197 }1198 }1199
1200 release_sock(sk);
1201
1202 out:
1203 returnretval;
1204 }1205
1206
1207 /*1208 * Send an ack if one is backlogged at this point. Ought to merge1209 * this with tcp_send_ack().1210 * This is called for delayed acks also.1211 */1212
1213 voidtcp_read_wakeup(structsock *sk)
/* */1214 {1215 inttmp;
1216 structdevice *dev = NULL;
1217 structtcphdr *t1;
1218 structsk_buff *buff;
1219
1220 if (!sk->ack_backlog)
1221 return;
1222
1223 /*1224 * If we're closed, don't send an ack, or we'll get a RST1225 * from the closed destination.1226 */1227 if ((sk->state == TCP_CLOSE) || (sk->state == TCP_TIME_WAIT))
1228 return;
1229
1230 /*1231 * FIXME: we need to put code here to prevent this routine from1232 * being called. Being called once in a while is ok, so only check1233 * if this is the second time in a row.1234 */1235
1236 /*1237 * We need to grab some memory, and put together an ack,1238 * and then put it into the queue to be sent.1239 */1240
1241 buff = sock_wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
1242 if (buff == NULL)
1243 {1244 /* Try again real soon. */1245 tcp_reset_xmit_timer(sk, TIME_WRITE, HZ);
1246 return;
1247 }1248
1249 buff->sk = sk;
1250 buff->localroute = sk->localroute;
1251 buff->csum = 0;
1252
1253 /*1254 * Put in the IP header and routing stuff. 1255 */1256
1257 tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
1258 IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
1259 if (tmp < 0)
1260 {1261 buff->free = 1;
1262 sock_wfree(sk, buff);
1263 return;
1264 }1265
1266 t1 =(structtcphdr *)skb_put(buff,sizeof(structtcphdr));
1267
1268 memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
1269 t1->seq = htonl(sk->sent_seq);
1270
1271 sk->ack_backlog = 0;
1272 sk->bytes_rcv = 0;
1273
1274 sk->window = tcp_select_window(sk);
1275 t1->window = htons(sk->window);
1276 t1->ack_seq = htonl(sk->acked_seq);
1277 t1->doff = sizeof(*t1)/4;
1278 tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), buff);
1279 sk->prot->queue_xmit(sk, dev, buff, 1);
1280 tcp_statistics.TcpOutSegs++;
1281 }1282
1283
1284 /*1285 * Handle reading urgent data. BSD has very simple semantics for1286 * this, no blocking and very strange errors 8)1287 */1288
1289 staticinttcp_recv_urg(structsock * sk, intnonblock,
/* */1290 structmsghdr *msg, intlen, intflags, int *addr_len)
1291 {1292 /*1293 * No URG data to read1294 */1295 if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
1296 return -EINVAL; /* Yes this is right ! */1297
1298 if (sk->err)
1299 returnsock_error(sk);
1300
1301 if (sk->state == TCP_CLOSE || sk->done)
1302 {1303 if (!sk->done)
1304 {1305 sk->done = 1;
1306 return 0;
1307 }1308 return -ENOTCONN;
1309 }1310
1311 if (sk->shutdown & RCV_SHUTDOWN)
1312 {1313 sk->done = 1;
1314 return 0;
1315 }1316 lock_sock(sk);
1317 if (sk->urg_data & URG_VALID)
1318 {1319 charc = sk->urg_data;
1320 if (!(flags & MSG_PEEK))
1321 sk->urg_data = URG_READ;
1322 memcpy_toiovec(msg->msg_iov, &c, 1);
1323 if(msg->msg_name)
1324 {1325 structsockaddr_in *sin=(structsockaddr_in *)msg->msg_name;
1326 sin->sin_family=AF_INET;
1327 sin->sin_addr.s_addr=sk->daddr;
1328 sin->sin_port=sk->dummy_th.dest;
1329 }1330 if(addr_len)
1331 *addr_len=sizeof(structsockaddr_in);
1332 release_sock(sk);
1333 return 1;
1334 }1335 release_sock(sk);
1336
1337 /*1338 * Fixed the recv(..., MSG_OOB) behaviour. BSD docs and1339 * the available implementations agree in this case:1340 * this call should never block, independent of the1341 * blocking state of the socket.1342 * Mike <pall@rz.uni-karlsruhe.de>1343 */1344 return -EAGAIN;
1345 }1346
1347 /*1348 * Release a skb if it is no longer needed. This routine1349 * must be called with interrupts disabled or with the1350 * socket locked so that the sk_buff queue operation is ok.1351 */1352
1353 staticinlinevoidtcp_eat_skb(structsock *sk, structsk_buff * skb)
/* */1354 {1355 skb->sk = sk;
1356 __skb_unlink(skb, &sk->receive_queue);
1357 kfree_skb(skb, FREE_READ);
1358 }1359
1360 /*1361 * FIXME:1362 * This routine frees used buffers.1363 * It should consider sending an ACK to let the1364 * other end know we now have a bigger window.1365 */1366
1367 staticvoidcleanup_rbuf(structsock *sk)
/* */1368 {1369 structsk_buff *skb;
1370
1371 /*1372 * NOTE! The socket must be locked, so that we don't get1373 * a messed-up receive queue.1374 */1375 while ((skb=skb_peek(&sk->receive_queue)) != NULL) {1376 if (!skb->used || skb->users)
1377 break;
1378 tcp_eat_skb(sk, skb);
1379 }1380
1381 /* If we raised the window due to cleaning up, tell the world.. */1382 if (tcp_raise_window(sk)) {1383 sk->ack_backlog++;
1384 tcp_read_wakeup(sk);
1385 }1386 }1387
1388
1389 /*1390 * This routine copies from a sock struct into the user buffer. 1391 */1392
1393 staticinttcp_recvmsg(structsock *sk, structmsghdr *msg,
/* */1394 intlen, intnonblock, intflags, int *addr_len)
1395 {1396 structwait_queuewait = {current, NULL};
1397 intcopied = 0;
1398 u32peek_seq;
1399 volatileu32 *seq; /* So gcc doesn't overoptimise */1400 unsignedlongused;
1401
1402 /* 1403 * This error should be checked. 1404 */1405
1406 if (sk->state == TCP_LISTEN)
1407 return -ENOTCONN;
1408
1409 /*1410 * Urgent data needs to be handled specially. 1411 */1412
1413 if (flags & MSG_OOB)
1414 returntcp_recv_urg(sk, nonblock, msg, len, flags, addr_len);
1415
1416 /*1417 * Copying sequence to update. This is volatile to handle1418 * the multi-reader case neatly (memcpy_to/fromfs might be 1419 * inline and thus not flush cached variables otherwise).1420 */1421
1422 peek_seq = sk->copied_seq;
1423 seq = &sk->copied_seq;
1424 if (flags & MSG_PEEK)
1425 seq = &peek_seq;
1426
1427 add_wait_queue(sk->sleep, &wait);
1428 lock_sock(sk);
1429 while (len > 0)
1430 {1431 structsk_buff * skb;
1432 u32offset;
1433
1434 /*1435 * Are we at urgent data? Stop if we have read anything.1436 */1437
1438 if (copied && sk->urg_data && sk->urg_seq == *seq)
1439 break;
1440
1441 /*1442 * We need to check signals first, to get correct SIGURG1443 * handling.1444 */1445 if (current->signal & ~current->blocked) {1446 if (copied)
1447 break;
1448 copied = -ERESTARTSYS;
1449 break;
1450 }1451
1452 /*1453 * Next get a buffer.1454 */1455
1456 current->state = TASK_INTERRUPTIBLE;
1457
1458 skb = skb_peek(&sk->receive_queue);
1459 do1460 {1461 if (!skb)
1462 break;
1463 if (before(*seq, skb->seq))
1464 break;
1465 offset = *seq - skb->seq;
1466 if (skb->h.th->syn)
1467 offset--;
1468 if (offset < skb->len)
1469 gotofound_ok_skb;
1470 if (skb->h.th->fin)
1471 gotofound_fin_ok;
1472 if (!(flags & MSG_PEEK))
1473 skb->used = 1;
1474 skb = skb->next;
1475 }1476 while (skb != (structsk_buff *)&sk->receive_queue);
1477
1478 if (copied)
1479 break;
1480
1481 if (sk->err)
1482 {1483 copied = sock_error(sk);
1484 break;
1485 }1486
1487 if (sk->state == TCP_CLOSE)
1488 {1489 if (!sk->done)
1490 {1491 sk->done = 1;
1492 break;
1493 }1494 copied = -ENOTCONN;
1495 break;
1496 }1497
1498 if (sk->shutdown & RCV_SHUTDOWN)
1499 {1500 sk->done = 1;
1501 break;
1502 }1503
1504 if (nonblock)
1505 {1506 copied = -EAGAIN;
1507 break;
1508 }1509
1510 cleanup_rbuf(sk);
1511 release_sock(sk);
1512 sk->socket->flags |= SO_WAITDATA;
1513 schedule();
1514 sk->socket->flags &= ~SO_WAITDATA;
1515 lock_sock(sk);
1516 continue;
1517
1518 found_ok_skb:
1519 /*1520 * Lock the buffer. We can be fairly relaxed as1521 * an interrupt will never steal a buffer we are 1522 * using unless I've missed something serious in1523 * tcp_data.1524 */1525
1526 skb->users++;
1527
1528 /*1529 * Ok so how much can we use ? 1530 */1531
1532 used = skb->len - offset;
1533 if (len < used)
1534 used = len;
1535 /*1536 * Do we have urgent data here? 1537 */1538
1539 if (sk->urg_data)
1540 {1541 u32urg_offset = sk->urg_seq - *seq;
1542 if (urg_offset < used)
1543 {1544 if (!urg_offset)
1545 {1546 if (!sk->urginline)
1547 {1548 ++*seq;
1549 offset++;
1550 used--;
1551 }1552 }1553 else1554 used = urg_offset;
1555 }1556 }1557
1558 /*1559 * Copy it - We _MUST_ update *seq first so that we1560 * don't ever double read when we have dual readers1561 */1562
1563 *seq += used;
1564
1565 /*1566 * This memcpy_tofs can sleep. If it sleeps and we1567 * do a second read it relies on the skb->users to avoid1568 * a crash when cleanup_rbuf() gets called.1569 */1570
1571 memcpy_toiovec(msg->msg_iov,((unsignedchar *)skb->h.th) +
1572 skb->h.th->doff*4 + offset, used);
1573 copied += used;
1574 len -= used;
1575
1576 /*1577 * We now will not sleep again until we are finished1578 * with skb. Sorry if you are doing the SMP port1579 * but you'll just have to fix it neatly ;)1580 */1581
1582 skb->users --;
1583
1584 if (after(sk->copied_seq,sk->urg_seq))
1585 sk->urg_data = 0;
1586 if (used + offset < skb->len)
1587 continue;
1588
1589 /*1590 * Process the FIN.1591 */1592
1593 if (skb->h.th->fin)
1594 gotofound_fin_ok;
1595 if (flags & MSG_PEEK)
1596 continue;
1597 skb->used = 1;
1598 if (!skb->users)
1599 tcp_eat_skb(sk, skb);
1600 continue;
1601
1602 found_fin_ok:
1603 ++*seq;
1604 if (flags & MSG_PEEK)
1605 break;
1606
1607 /*1608 * All is done1609 */1610
1611 skb->used = 1;
1612 sk->shutdown |= RCV_SHUTDOWN;
1613 break;
1614
1615 }1616
1617 if(copied>0 && msg->msg_name)
1618 {1619 structsockaddr_in *sin=(structsockaddr_in *)msg->msg_name;
1620 sin->sin_family=AF_INET;
1621 sin->sin_addr.s_addr=sk->daddr;
1622 sin->sin_port=sk->dummy_th.dest;
1623 }1624 if(addr_len)
1625 *addr_len=sizeof(structsockaddr_in);
1626
1627 remove_wait_queue(sk->sleep, &wait);
1628 current->state = TASK_RUNNING;
1629
1630 /* Clean up data we have read: This will do ACK frames */1631 cleanup_rbuf(sk);
1632 release_sock(sk);
1633 returncopied;
1634 }1635
1636
1637
1638 /*1639 * State processing on a close. This implements the state shift for1640 * sending our FIN frame. Note that we only send a FIN for some 1641 * states. A shutdown() may have already sent the FIN, or we may be1642 * closed.1643 */1644
1645 staticinttcp_close_state(structsock *sk, intdead)
/* */1646 {1647 intns=TCP_CLOSE;
1648 intsend_fin=0;
1649 switch(sk->state)
1650 {1651 caseTCP_SYN_SENT: /* No SYN back, no FIN needed */1652 break;
1653 caseTCP_SYN_RECV:
1654 caseTCP_ESTABLISHED: /* Closedown begin */1655 ns=TCP_FIN_WAIT1;
1656 send_fin=1;
1657 break;
1658 caseTCP_FIN_WAIT1: /* Already closing, or FIN sent: no change */1659 caseTCP_FIN_WAIT2:
1660 caseTCP_CLOSING:
1661 ns=sk->state;
1662 break;
1663 caseTCP_CLOSE:
1664 caseTCP_LISTEN:
1665 break;
1666 caseTCP_CLOSE_WAIT: /* They have FIN'd us. We send our FIN and1667 wait only for the ACK */1668 ns=TCP_LAST_ACK;
1669 send_fin=1;
1670 }1671
1672 tcp_set_state(sk,ns);
1673
1674 /*1675 * This is a (useful) BSD violating of the RFC. There is a1676 * problem with TCP as specified in that the other end could1677 * keep a socket open forever with no application left this end.1678 * We use a 3 minute timeout (about the same as BSD) then kill1679 * our end. If they send after that then tough - BUT: long enough1680 * that we won't make the old 4*rto = almost no time - whoops1681 * reset mistake.1682 */1683 if(dead && ns==TCP_FIN_WAIT2)
1684 {1685 inttimer_active=del_timer(&sk->timer);
1686 if(timer_active)
1687 add_timer(&sk->timer);
1688 else1689 tcp_reset_msl_timer(sk, TIME_CLOSE, TCP_FIN_TIMEOUT);
1690 }1691
1692 returnsend_fin;
1693 }1694
1695 /*1696 * Shutdown the sending side of a connection. Much like close except1697 * that we don't receive shut down or set sk->dead.1698 */1699
1700 voidtcp_shutdown(structsock *sk, inthow)
/* */1701 {1702 /*1703 * We need to grab some memory, and put together a FIN,1704 * and then put it into the queue to be sent.1705 * Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.1706 */1707
1708 if (!(how & SEND_SHUTDOWN))
1709 return;
1710
1711 /*1712 * If we've already sent a FIN, or it's a closed state1713 */1714
1715 if (sk->state == TCP_FIN_WAIT1 ||
1716 sk->state == TCP_FIN_WAIT2 ||
1717 sk->state == TCP_CLOSING ||
1718 sk->state == TCP_LAST_ACK ||
1719 sk->state == TCP_TIME_WAIT ||
1720 sk->state == TCP_CLOSE ||
1721 sk->state == TCP_LISTEN1722 )
1723 {1724 return;
1725 }1726 lock_sock(sk);
1727
1728 /*1729 * flag that the sender has shutdown1730 */1731
1732 sk->shutdown |= SEND_SHUTDOWN;
1733
1734 /*1735 * Clear out any half completed packets. 1736 */1737
1738 if (sk->partial)
1739 tcp_send_partial(sk);
1740
1741 /*1742 * FIN if needed1743 */1744
1745 if (tcp_close_state(sk,0))
1746 tcp_send_fin(sk);
1747
1748 release_sock(sk);
1749 }1750
1751
1752 /*1753 * Return 1 if we still have things to send in our buffers.1754 */1755
1756 staticinlineintclosing(structsock * sk)
/* */1757 {1758 switch (sk->state) {1759 caseTCP_FIN_WAIT1:
1760 caseTCP_CLOSING:
1761 caseTCP_LAST_ACK:
1762 return 1;
1763 }1764 return 0;
1765 }1766
1767
1768 staticvoidtcp_close(structsock *sk, unsignedlongtimeout)
/* */1769 {1770 structsk_buff *skb;
1771
1772 /*1773 * We need to grab some memory, and put together a FIN, 1774 * and then put it into the queue to be sent.1775 */1776
1777 lock_sock(sk);
1778
1779 tcp_cache_zap();
1780 if(sk->state == TCP_LISTEN)
1781 {1782 /* Special case */1783 tcp_set_state(sk, TCP_CLOSE);
1784 tcp_close_pending(sk);
1785 release_sock(sk);
1786 sk->dead = 1;
1787 return;
1788 }1789
1790 sk->keepopen = 1;
1791 sk->shutdown = SHUTDOWN_MASK;
1792
1793 if (!sk->dead)
1794 sk->state_change(sk);
1795
1796 /*1797 * We need to flush the recv. buffs. We do this only on the1798 * descriptor close, not protocol-sourced closes, because the1799 * reader process may not have drained the data yet!1800 */1801
1802 while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
1803 kfree_skb(skb, FREE_READ);
1804
1805 /*1806 * Get rid off any half-completed packets. 1807 */1808
1809 if (sk->partial)
1810 tcp_send_partial(sk);
1811
1812 /*1813 * Timeout is not the same thing - however the code likes1814 * to send both the same way (sigh).1815 */1816
1817 if (tcp_close_state(sk,1)==1)
1818 {1819 tcp_send_fin(sk);
1820 }1821
1822 if (timeout) {1823 cli();
1824 release_sock(sk);
1825 current->timeout = timeout;
1826 while(closing(sk) && current->timeout)
1827 {1828 interruptible_sleep_on(sk->sleep);
1829 if (current->signal & ~current->blocked)
1830 {1831 break;
1832 }1833 }1834 current->timeout=0;
1835 lock_sock(sk);
1836 sti();
1837 }1838
1839 /*1840 * This will destroy it. The timers will take care of actually1841 * free'ing up the memory.1842 */1843 tcp_cache_zap(); /* Kill the cache again. */1844 release_sock(sk);
1845 sk->dead = 1;
1846 }1847
1848
1849 /*1850 * This will accept the next outstanding connection. 1851 */1852
1853 staticstructsock *tcp_accept(structsock *sk, intflags)
/* */1854 {1855 structsock *newsk;
1856 structsk_buff *skb;
1857
1858 /*1859 * We need to make sure that this socket is listening,1860 * and that it has something pending.1861 */1862
1863 if (sk->state != TCP_LISTEN)
1864 {1865 sk->err = EINVAL;
1866 return(NULL);
1867 }1868
1869 /* Avoid the race. */1870 cli();
1871 lock_sock(sk);
1872
1873 while((skb = tcp_dequeue_established(sk)) == NULL)
1874 {1875 if (flags & O_NONBLOCK)
1876 {1877 sti();
1878 release_sock(sk);
1879 sk->err = EAGAIN;
1880 return(NULL);
1881 }1882
1883 release_sock(sk);
1884 interruptible_sleep_on(sk->sleep);
1885 if (current->signal & ~current->blocked)
1886 {1887 sti();
1888 sk->err = ERESTARTSYS;
1889 return(NULL);
1890 }1891 lock_sock(sk);
1892 }1893 sti();
1894
1895 /*1896 * Now all we need to do is return skb->sk. 1897 */1898
1899 newsk = skb->sk;
1900
1901 kfree_skb(skb, FREE_READ);
1902 sk->ack_backlog--;
1903 release_sock(sk);
1904 return(newsk);
1905 }1906
1907 /*1908 * This will initiate an outgoing connection. 1909 */1910
1911 staticinttcp_connect(structsock *sk, structsockaddr_in *usin, intaddr_len)
/* */1912 {1913 structsk_buff *buff;
1914 structdevice *dev=NULL;
1915 unsignedchar *ptr;
1916 inttmp;
1917 intatype;
1918 structtcphdr *t1;
1919 structrtable *rt;
1920
1921 if (sk->state != TCP_CLOSE)
1922 return(-EISCONN);
1923
1924 /*1925 * Don't allow a double connect.1926 */1927
1928 if(sk->daddr)
1929 return -EINVAL;
1930
1931 if (addr_len < 8)
1932 return(-EINVAL);
1933
1934 if (usin->sin_family && usin->sin_family != AF_INET)
1935 return(-EAFNOSUPPORT);
1936
1937 /*1938 * connect() to INADDR_ANY means loopback (BSD'ism).1939 */1940
1941 if(usin->sin_addr.s_addr==INADDR_ANY)
1942 usin->sin_addr.s_addr=ip_my_addr();
1943
1944 /*1945 * Don't want a TCP connection going to a broadcast address 1946 */1947
1948 if ((atype=ip_chk_addr(usin->sin_addr.s_addr)) == IS_BROADCAST || atype==IS_MULTICAST)
1949 return -ENETUNREACH;
1950
1951 lock_sock(sk);
1952 sk->daddr = usin->sin_addr.s_addr;
1953 sk->write_seq = tcp_init_seq();
1954 sk->window_seq = sk->write_seq;
1955 sk->rcv_ack_seq = sk->write_seq -1;
1956 sk->err = 0;
1957 sk->dummy_th.dest = usin->sin_port;
1958 release_sock(sk);
1959
1960 buff = sock_wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
1961 if (buff == NULL)
1962 {1963 return(-ENOMEM);
1964 }1965 lock_sock(sk);
1966 buff->sk = sk;
1967 buff->free = 0;
1968 buff->localroute = sk->localroute;
1969
1970
1971 /*1972 * Put in the IP header and routing stuff.1973 */1974
1975 tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
1976 IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
1977 if (tmp < 0)
1978 {1979 sock_wfree(sk, buff);
1980 release_sock(sk);
1981 return(-ENETUNREACH);
1982 }1983 if ((rt = sk->ip_route_cache) != NULL && !sk->saddr)
1984 sk->saddr = rt->rt_src;
1985 sk->rcv_saddr = sk->saddr;
1986
1987 t1 = (structtcphdr *) skb_put(buff,sizeof(structtcphdr));
1988
1989 memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
1990 buff->seq = sk->write_seq++;
1991 t1->seq = htonl(buff->seq);
1992 sk->sent_seq = sk->write_seq;
1993 buff->end_seq = sk->write_seq;
1994 t1->ack = 0;
1995 t1->window = 2;
1996 t1->syn = 1;
1997 t1->doff = 6;
1998 /* use 512 or whatever user asked for */1999
2000 if(rt!=NULL && (rt->rt_flags&RTF_WINDOW))
2001 sk->window_clamp=rt->rt_window;
2002 else2003 sk->window_clamp=0;
2004
2005 if (sk->user_mss)
2006 sk->mtu = sk->user_mss;
2007 elseif (rt)
2008 sk->mtu = rt->rt_mtu - sizeof(structiphdr) - sizeof(structtcphdr);
2009 else2010 sk->mtu = 576 - sizeof(structiphdr) - sizeof(structtcphdr);
2011
2012 /*2013 * but not bigger than device MTU 2014 */2015
2016 if(sk->mtu <32)
2017 sk->mtu = 32; /* Sanity limit */2018
2019 sk->mtu = min(sk->mtu, dev->mtu - sizeof(structiphdr) - sizeof(structtcphdr));
2020
2021 #ifdefCONFIG_SKIP2022
2023 /*2024 * SKIP devices set their MTU to 65535. This is so they can take packets2025 * unfragmented to security process then fragment. They could lie to the2026 * TCP layer about a suitable MTU, but its easier to let skip sort it out2027 * simply because the final package we want unfragmented is going to be2028 *2029 * [IPHDR][IPSP][Security data][Modified TCP data][Security data]2030 */2031
2032 if(skip_pick_mtu!=NULL) /* If SKIP is loaded.. */2033 sk->mtu=skip_pick_mtu(sk->mtu,dev);
2034 #endif2035
2036 /*2037 * Put in the TCP options to say MTU. 2038 */2039
2040 ptr = skb_put(buff,4);
2041 ptr[0] = 2;
2042 ptr[1] = 4;
2043 ptr[2] = (sk->mtu) >> 8;
2044 ptr[3] = (sk->mtu) & 0xff;
2045 buff->csum = csum_partial(ptr, 4, 0);
2046 tcp_send_check(t1, sk->saddr, sk->daddr,
2047 sizeof(structtcphdr) + 4, buff);
2048
2049 /*2050 * This must go first otherwise a really quick response will get reset. 2051 */2052
2053 tcp_cache_zap();
2054 tcp_set_state(sk,TCP_SYN_SENT);
2055 if(rt&&rt->rt_flags&RTF_IRTT)
2056 sk->rto = rt->rt_irtt;
2057 else2058 sk->rto = TCP_TIMEOUT_INIT;
2059 sk->retransmit_timer.function=&tcp_retransmit_timer;
2060 sk->retransmit_timer.data = (unsignedlong)sk;
2061 tcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto); /* Timer for repeating the SYN until an answer */2062 sk->retransmits = 0; /* Now works the right way instead of a hacked 2063 initial setting */2064
2065 sk->prot->queue_xmit(sk, dev, buff, 0);
2066 tcp_reset_xmit_timer(sk, TIME_WRITE, sk->rto);
2067 tcp_statistics.TcpActiveOpens++;
2068 tcp_statistics.TcpOutSegs++;
2069
2070 release_sock(sk);
2071 return(0);
2072 }2073
2074 /*2075 * Socket option code for TCP. 2076 */2077
2078 inttcp_setsockopt(structsock *sk, intlevel, intoptname, char *optval, intoptlen)
/* */2079 {2080 intval,err;
2081
2082 if(level!=SOL_TCP)
2083 returnip_setsockopt(sk,level,optname,optval,optlen);
2084
2085 if (optval == NULL)
2086 return(-EINVAL);
2087
2088 err=verify_area(VERIFY_READ, optval, sizeof(int));
2089 if(err)
2090 returnerr;
2091
2092 val = get_user((int *)optval);
2093
2094 switch(optname)
2095 {2096 caseTCP_MAXSEG:
2097 /*2098 * values greater than interface MTU won't take effect. however at2099 * the point when this call is done we typically don't yet know2100 * which interface is going to be used2101 */2102 if(val<1||val>MAX_WINDOW)
2103 return -EINVAL;
2104 sk->user_mss=val;
2105 return 0;
2106 caseTCP_NODELAY:
2107 sk->nonagle=(val==0)?0:1;
2108 return 0;
2109 default:
2110 return(-ENOPROTOOPT);
2111 }2112 }2113
2114 inttcp_getsockopt(structsock *sk, intlevel, intoptname, char *optval, int *optlen)
/* */2115 {2116 intval,err;
2117
2118 if(level!=SOL_TCP)
2119 returnip_getsockopt(sk,level,optname,optval,optlen);
2120
2121 switch(optname)
2122 {2123 caseTCP_MAXSEG:
2124 val=sk->user_mss;
2125 break;
2126 caseTCP_NODELAY:
2127 val=sk->nonagle;
2128 break;
2129 default:
2130 return(-ENOPROTOOPT);
2131 }2132 err=verify_area(VERIFY_WRITE, optlen, sizeof(int));
2133 if(err)
2134 returnerr;
2135 put_user(sizeof(int),(int *) optlen);
2136
2137 err=verify_area(VERIFY_WRITE, optval, sizeof(int));
2138 if(err)
2139 returnerr;
2140 put_user(val,(int *)optval);
2141
2142 return(0);
2143 }2144
2145
2146 structprototcp_prot = {2147 tcp_close,
2148 ip_build_header,
2149 tcp_connect,
2150 tcp_accept,
2151 ip_queue_xmit,
2152 tcp_retransmit,
2153 tcp_write_wakeup,
2154 tcp_read_wakeup,
2155 tcp_rcv,
2156 tcp_select,
2157 tcp_ioctl,
2158 NULL,
2159 tcp_shutdown,
2160 tcp_setsockopt,
2161 tcp_getsockopt,
2162 tcp_sendmsg,
2163 tcp_recvmsg,
2164 NULL, /* No special bind() */2165 128,
2166 0,
2167 "TCP",
2168 0, 0,
2169 {NULL,}2170 };