![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
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@no.unit.nvg>
20 *
21 * Fixes:
22 * Alan Cox : Numerous verify_area() calls
23 * Alan Cox : Set the ACK bit on a reset
24 * Alan Cox : Stopped it crashing if it closed while sk->inuse=1
25 * and was trying to connect (tcp_err()).
26 * Alan Cox : All icmp error handling was broken
27 * pointers passed where wrong and the
28 * socket was looked up backwards. Nobody
29 * tested any icmp error code obviously.
30 * Alan Cox : tcp_err() now handled properly. It wakes people
31 * on errors. select behaves and the icmp error race
32 * has gone by moving it into sock.c
33 * Alan Cox : tcp_reset() fixed to work for everything not just
34 * packets for unknown sockets.
35 * Alan Cox : tcp option processing.
36 * Alan Cox : Reset tweaked (still not 100%) [Had syn rule wrong]
37 * Herp Rosmanith : More reset fixes
38 * Alan Cox : No longer acks invalid rst frames. Acking
39 * any kind of RST is right out.
40 * Alan Cox : Sets an ignore me flag on an rst receive
41 * otherwise odd bits of prattle escape still
42 * Alan Cox : Fixed another acking RST frame bug. Should stop
43 * LAN workplace lockups.
44 * Alan Cox : Some tidyups using the new skb list facilities
45 * Alan Cox : sk->keepopen now seems to work
46 * Alan Cox : Pulls options out correctly on accepts
47 * Alan Cox : Fixed assorted sk->rqueue->next errors
48 * Alan Cox : PSH doesn't end a TCP read. Switched a bit to skb ops.
49 * Alan Cox : Tidied tcp_data to avoid a potential nasty.
50 * Alan Cox : Added some beter commenting, as the tcp is hard to follow
51 * Alan Cox : Removed incorrect check for 20 * psh
52 * Michael O'Reilly : ack < copied bug fix.
53 * Johannes Stille : Misc tcp fixes (not all in yet).
54 * Alan Cox : FIN with no memory -> CRASH
55 * Alan Cox : Added socket option proto entries. Also added awareness of them to accept.
56 * Alan Cox : Added TCP options (SOL_TCP)
57 * Alan Cox : Switched wakeup calls to callbacks, so the kernel can layer network sockets.
58 * Alan Cox : Use ip_tos/ip_ttl settings.
59 * Alan Cox : Handle FIN (more) properly (we hope).
60 * Alan Cox : RST frames sent on unsynchronised state ack error/
61 * Alan Cox : Put in missing check for SYN bit.
62 * Alan Cox : Added tcp_select_window() aka NET2E
63 * window non shrink trick.
64 * Alan Cox : Added a couple of small NET2E timer fixes
65 * Charles Hedrick : TCP fixes
66 * Toomas Tamm : TCP window fixes
67 * Alan Cox : Small URG fix to rlogin ^C ack fight
68 * Charles Hedrick : Rewrote most of it to actually work
69 * Linus : Rewrote tcp_read() and URG handling
70 * completely
71 * Gerhard Koerting: Fixed some missing timer handling
72 * Matthew Dillon : Reworked TCP machine states as per RFC
73 * Gerhard Koerting: PC/TCP workarounds
74 * Adam Caldwell : Assorted timer/timing errors
75 * Matthew Dillon : Fixed another RST bug
76 * Alan Cox : Move to kernel side addressing changes.
77 * Alan Cox : Beginning work on TCP fastpathing (not yet usable)
78 * Arnt Gulbrandsen: Turbocharged tcp_check() routine.
79 * Alan Cox : TCP fast path debugging
80 * Alan Cox : Window clamping
81 * Michael Riepe : Bug in tcp_check()
82 * Matt Dillon : More TCP improvements and RST bug fixes
83 *
84 *
85 * To Fix:
86 * Possibly a problem with accept(). BSD accept never fails after
87 * it causes a select. Linux can - given the official select semantics I
88 * feel that _really_ its the BSD network programs that are bust (notably
89 * inetd, which hangs occasionally because of this).
90 *
91 * Fast path the code. Two things here - fix the window calculation
92 * so it doesn't iterate over the queue, also spot packets with no funny
93 * options arriving in order and process directly.
94 *
95 * This program is free software; you can redistribute it and/or
96 * modify it under the terms of the GNU General Public License
97 * as published by the Free Software Foundation; either version
98 * 2 of the License, or(at your option) any later version.
99 *
100 * Description of States:
101 *
102 * TCP_SYN_SENT sent a connection request, waiting for ack
103 *
104 * TCP_SYN_RECV received a connection request, sent ack,
105 * waiting for final ack in three-way handshake.
106 *
107 * TCP_ESTABLISHED connection established
108 *
109 * TCP_FIN_WAIT1 our side has shutdown, waiting to complete
110 * transmission of remaining buffered data
111 *
112 * TCP_FIN_WAIT2 all buffered data sent, waiting for remote
113 * to shutdown
114 *
115 * TCP_CLOSING both sides have shutdown but we still have
116 * data we have to finish sending
117 *
118 * TCP_TIME_WAIT timeout to catch resent junk before entering
119 * closed, can only be entered from FIN_WAIT2
120 * or CLOSING. Required because the other end
121 * may not have gotten our last ACK causing it
122 * to retransmit the data packet (which we ignore)
123 *
124 * TCP_CLOSE_WAIT remote side has shutdown and is waiting for
125 * us to finish writing our data and to shutdown
126 * (we have to close() to move on to LAST_ACK)
127 *
128 * TCP_LAST_ACK out side has shutdown after remote has
129 * shutdown. There may still be data in our
130 * buffer that we have to finish sending
131 *
132 * TCP_CLOSE socket is finished
133 */
134 #include <linux/types.h>
135 #include <linux/sched.h>
136 #include <linux/mm.h>
137 #include <linux/string.h>
138 #include <linux/socket.h>
139 #include <linux/sockios.h>
140 #include <linux/termios.h>
141 #include <linux/in.h>
142 #include <linux/fcntl.h>
143 #include <linux/inet.h>
144 #include <linux/netdevice.h>
145 #include "snmp.h"
146 #include "ip.h"
147 #include "protocol.h"
148 #include "icmp.h"
149 #include "tcp.h"
150 #include <linux/skbuff.h>
151 #include "sock.h"
152 #include "route.h"
153 #include <linux/errno.h>
154 #include <linux/timer.h>
155 #include <asm/system.h>
156 #include <asm/segment.h>
157 #include <linux/mm.h>
158
159 #undef TCP_FASTPATH
160
161 #define SEQ_TICK 3
162 unsigned long seq_offset;
163 struct tcp_mib tcp_statistics;
164
165 #ifdef TCP_FASTPATH
166 unsigned long tcp_rx_miss=0, tcp_rx_hit1=0, tcp_rx_hit2=0;
167 #endif
168
169
170 static __inline__ int min(unsigned int a, unsigned int b)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
171 {
172 if (a < b)
173 return(a);
174 return(b);
175 }
176
177 #undef STATE_TRACE
178
179 static __inline__ void tcp_set_state(struct sock *sk, int state)
/* ![[previous]](../icons/left.png)
*/
180 {
181 if(sk->state==TCP_ESTABLISHED)
182 tcp_statistics.TcpCurrEstab--;
183 #ifdef STATE_TRACE
184 if(sk->debug)
185 printk("TCP sk=%s, State %d -> %d\n",sk, sk->state,state);
186 #endif
187 sk->state=state;
188 if(state==TCP_ESTABLISHED)
189 tcp_statistics.TcpCurrEstab++;
190 }
191
192 /* This routine picks a TCP windows for a socket based on
193 the following constraints
194
195 1. The window can never be shrunk once it is offered (RFC 793)
196 2. We limit memory per socket
197
198 For now we use NET2E3's heuristic of offering half the memory
199 we have handy. All is not as bad as this seems however because
200 of two things. Firstly we will bin packets even within the window
201 in order to get the data we are waiting for into the memory limit.
202 Secondly we bin common duplicate forms at receive time
203
204 Better heuristics welcome
205 */
206
207 int tcp_select_window(struct sock *sk)
/* */
208 {
209 int new_window = sk->prot->rspace(sk);
210
211 if(sk->window_clamp)
212 new_window=min(sk->window_clamp,new_window);
213 /*
214 * two things are going on here. First, we don't ever offer a
215 * window less than min(sk->mss, MAX_WINDOW/2). This is the
216 * receiver side of SWS as specified in RFC1122.
217 * Second, we always give them at least the window they
218 * had before, in order to avoid retracting window. This
219 * is technically allowed, but RFC1122 advises against it and
220 * in practice it causes trouble.
221 */
222 if (new_window < min(sk->mss, MAX_WINDOW/2) || new_window < sk->window)
223 return(sk->window);
224 return(new_window);
225 }
226
227 /*
228 * Enter the time wait state.
229 */
230
231 static void tcp_time_wait(struct sock *sk)
/* */
232 {
233 tcp_set_state(sk,TCP_TIME_WAIT);
234 sk->shutdown = SHUTDOWN_MASK;
235 if (!sk->dead)
236 sk->state_change(sk);
237 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
238 }
239
240 /*
241 * A timer event has trigger a tcp retransmit timeout. The
242 * socket xmit queue is ready and set up to send. Because
243 * the ack receive code keeps the queue straight we do
244 * nothing clever here.
245 */
246
247 static void tcp_retransmit(struct sock *sk, int all)
/* */
248 {
249 if (all)
250 {
251 ip_retransmit(sk, all);
252 return;
253 }
254
255 sk->ssthresh = sk->cong_window >> 1; /* remember window where we lost */
256 /* sk->ssthresh in theory can be zero. I guess that's OK */
257 sk->cong_count = 0;
258
259 sk->cong_window = 1;
260
261 /* Do the actual retransmit. */
262 ip_retransmit(sk, all);
263 }
264
265
266 /*
267 * This routine is called by the ICMP module when it gets some
268 * sort of error condition. If err < 0 then the socket should
269 * be closed and the error returned to the user. If err > 0
270 * it's just the icmp type << 8 | icmp code. After adjustment
271 * header points to the first 8 bytes of the tcp header. We need
272 * to find the appropriate port.
273 */
274
275 void tcp_err(int err, unsigned char *header, unsigned long daddr,
/* */
276 unsigned long saddr, struct inet_protocol *protocol)
277 {
278 struct tcphdr *th;
279 struct sock *sk;
280 struct iphdr *iph=(struct iphdr *)header;
281
282 header+=4*iph->ihl;
283
284
285 th =(struct tcphdr *)header;
286 sk = get_sock(&tcp_prot, th->source/*dest*/, daddr, th->dest/*source*/, saddr);
287
288 if (sk == NULL)
289 return;
290
291 if(err<0)
292 {
293 sk->err = -err;
294 sk->error_report(sk);
295 return;
296 }
297
298 if ((err & 0xff00) == (ICMP_SOURCE_QUENCH << 8))
299 {
300 /*
301 * FIXME:
302 * For now we will just trigger a linear backoff.
303 * The slow start code should cause a real backoff here.
304 */
305 if (sk->cong_window > 4)
306 sk->cong_window--;
307 return;
308 }
309
310 /* sk->err = icmp_err_convert[err & 0xff].errno; -- moved as TCP should hide non fatals internally (and does) */
311
312 /*
313 * If we've already connected we will keep trying
314 * until we time out, or the user gives up.
315 */
316
317 if (icmp_err_convert[err & 0xff].fatal || sk->state == TCP_SYN_SENT)
318 {
319 if (sk->state == TCP_SYN_SENT)
320 {
321 tcp_statistics.TcpAttemptFails++;
322 tcp_set_state(sk,TCP_CLOSE);
323 sk->error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
324 }
325 sk->err = icmp_err_convert[err & 0xff].errno;
326 }
327 return;
328 }
329
330
331 /*
332 * Walk down the receive queue counting readable data until we hit the end or we find a gap
333 * in the received data queue (ie a frame missing that needs sending to us)
334 */
335
336 static int tcp_readable(struct sock *sk)
/* */
337 {
338 unsigned long counted;
339 unsigned long amount;
340 struct sk_buff *skb;
341 int sum;
342 unsigned long flags;
343
344 if(sk && sk->debug)
345 printk("tcp_readable: %p - ",sk);
346
347 save_flags(flags);
348 cli();
349 if (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
350 {
351 restore_flags(flags);
352 if(sk && sk->debug)
353 printk("empty\n");
354 return(0);
355 }
356
357 counted = sk->copied_seq+1; /* Where we are at the moment */
358 amount = 0;
359
360 /* Do until a push or until we are out of data. */
361 do
362 {
363 if (before(counted, skb->h.th->seq)) /* Found a hole so stops here */
364 break;
365 sum = skb->len -(counted - skb->h.th->seq); /* Length - header but start from where we are up to (avoid overlaps) */
366 if (skb->h.th->syn)
367 sum++;
368 if (sum > 0)
369 { /* Add it up, move on */
370 amount += sum;
371 if (skb->h.th->syn)
372 amount--;
373 counted += sum;
374 }
375 if (amount && skb->h.th->psh) break;
376 skb = skb->next;
377 }
378 while(skb != (struct sk_buff *)&sk->receive_queue);
379
380 if (amount && !sk->urginline && sk->urg_data &&
381 (sk->urg_seq - sk->copied_seq) <= (counted - sk->copied_seq))
382 amount--; /* don't count urg data */
383 restore_flags(flags);
384 if(sk->debug)
385 printk("got %lu bytes.\n",amount);
386 return(amount);
387 }
388
389
390 /*
391 * Wait for a TCP event. Note the oddity with SEL_IN and reading. The
392 * listening socket has a receive queue of sockets to accept.
393 */
394
395 static int tcp_select(struct sock *sk, int sel_type, select_table *wait)
/* */
396 {
397 sk->inuse = 1;
398
399 switch(sel_type)
400 {
401 case SEL_IN:
402 if(sk->debug)
403 printk("select in");
404 select_wait(sk->sleep, wait);
405 if(sk->debug)
406 printk("-select out");
407 if (skb_peek(&sk->receive_queue) != NULL)
408 {
409 if (sk->state == TCP_LISTEN || tcp_readable(sk))
410 {
411 release_sock(sk);
412 if(sk->debug)
413 printk("-select ok data\n");
414 return(1);
415 }
416 }
417 if (sk->err != 0) /* Receiver error */
418 {
419 release_sock(sk);
420 if(sk->debug)
421 printk("-select ok error");
422 return(1);
423 }
424 if (sk->shutdown & RCV_SHUTDOWN)
425 {
426 release_sock(sk);
427 if(sk->debug)
428 printk("-select ok down\n");
429 return(1);
430 }
431 else
432 {
433 release_sock(sk);
434 if(sk->debug)
435 printk("-select fail\n");
436 return(0);
437 }
438 case SEL_OUT:
439 select_wait(sk->sleep, wait);
440 if (sk->shutdown & SEND_SHUTDOWN)
441 {
442 /* FIXME: should this return an error? */
443 release_sock(sk);
444 return(0);
445 }
446
447 /*
448 * FIXME:
449 * Hack so it will probably be able to write
450 * something if it says it's ok to write.
451 */
452
453 if (sk->prot->wspace(sk) >= sk->mss)
454 {
455 release_sock(sk);
456 /* This should cause connect to work ok. */
457 if (sk->state == TCP_SYN_RECV ||
458 sk->state == TCP_SYN_SENT) return(0);
459 return(1);
460 }
461 release_sock(sk);
462 return(0);
463 case SEL_EX:
464 select_wait(sk->sleep,wait);
465 if (sk->err || sk->urg_data)
466 {
467 release_sock(sk);
468 return(1);
469 }
470 release_sock(sk);
471 return(0);
472 }
473
474 release_sock(sk);
475 return(0);
476 }
477
478
479 int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
/* */
480 {
481 int err;
482 switch(cmd)
483 {
484
485 case TIOCINQ:
486 #ifdef FIXME /* FIXME: */
487 case FIONREAD:
488 #endif
489 {
490 unsigned long amount;
491
492 if (sk->state == TCP_LISTEN)
493 return(-EINVAL);
494
495 sk->inuse = 1;
496 amount = tcp_readable(sk);
497 release_sock(sk);
498 err=verify_area(VERIFY_WRITE,(void *)arg,
499 sizeof(unsigned long));
500 if(err)
501 return err;
502 put_fs_long(amount,(unsigned long *)arg);
503 return(0);
504 }
505 case SIOCATMARK:
506 {
507 int answ = sk->urg_data && sk->urg_seq == sk->copied_seq+1;
508
509 err = verify_area(VERIFY_WRITE,(void *) arg,
510 sizeof(unsigned long));
511 if (err)
512 return err;
513 put_fs_long(answ,(int *) arg);
514 return(0);
515 }
516 case TIOCOUTQ:
517 {
518 unsigned long amount;
519
520 if (sk->state == TCP_LISTEN) return(-EINVAL);
521 amount = sk->prot->wspace(sk);
522 err=verify_area(VERIFY_WRITE,(void *)arg,
523 sizeof(unsigned long));
524 if(err)
525 return err;
526 put_fs_long(amount,(unsigned long *)arg);
527 return(0);
528 }
529 default:
530 return(-EINVAL);
531 }
532 }
533
534
535 /*
536 * This routine computes a TCP checksum.
537 */
538
539 unsigned short tcp_check(struct tcphdr *th, int len,
/* */
540 unsigned long saddr, unsigned long daddr)
541 {
542 unsigned long sum;
543
544 if (saddr == 0) saddr = ip_my_addr();
545
546 /*
547 * stupid, gcc complains when I use just one __asm__ block,
548 * something about too many reloads, but this is just two
549 * instructions longer than what I want
550 */
551 __asm__("
552 addl %%ecx, %%ebx
553 adcl %%edx, %%ebx
554 adcl $0, %%ebx
555 "
556 : "=b"(sum)
557 : "0"(daddr), "c"(saddr), "d"((ntohs(len) << 16) + IPPROTO_TCP*256)
558 : "bx", "cx", "dx" );
559 __asm__("
560 movl %%ecx, %%edx
561 cld
562 cmpl $32, %%ecx
563 jb 2f
564 shrl $5, %%ecx
565 clc
566 1: lodsl
567 adcl %%eax, %%ebx
568 lodsl
569 adcl %%eax, %%ebx
570 lodsl
571 adcl %%eax, %%ebx
572 lodsl
573 adcl %%eax, %%ebx
574 lodsl
575 adcl %%eax, %%ebx
576 lodsl
577 adcl %%eax, %%ebx
578 lodsl
579 adcl %%eax, %%ebx
580 lodsl
581 adcl %%eax, %%ebx
582 loop 1b
583 adcl $0, %%ebx
584 movl %%edx, %%ecx
585 2: andl $28, %%ecx
586 je 4f
587 shrl $2, %%ecx
588 clc
589 3: lodsl
590 adcl %%eax, %%ebx
591 loop 3b
592 adcl $0, %%ebx
593 4: movl $0, %%eax
594 testw $2, %%dx
595 je 5f
596 lodsw
597 addl %%eax, %%ebx
598 adcl $0, %%ebx
599 movw $0, %%ax
600 5: test $1, %%edx
601 je 6f
602 lodsb
603 addl %%eax, %%ebx
604 adcl $0, %%ebx
605 6: movl %%ebx, %%eax
606 shrl $16, %%eax
607 addw %%ax, %%bx
608 adcw $0, %%bx
609 "
610 : "=b"(sum)
611 : "0"(sum), "c"(len), "S"(th)
612 : "ax", "bx", "cx", "dx", "si" );
613
614 /* We only want the bottom 16 bits, but we never cleared the top 16. */
615
616 return((~sum) & 0xffff);
617 }
618
619
620
621 void tcp_send_check(struct tcphdr *th, unsigned long saddr,
/* */
622 unsigned long daddr, int len, struct sock *sk)
623 {
624 th->check = 0;
625 th->check = tcp_check(th, len, saddr, daddr);
626 return;
627 }
628
629 static void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
/* */
630 {
631 int size;
632 struct tcphdr * th = skb->h.th;
633
634 /* length of packet (not counting length of pre-tcp headers) */
635 size = skb->len - ((unsigned char *) th - skb->data);
636
637 /* sanity check it.. */
638 if (size < sizeof(struct tcphdr) || size > skb->len)
639 {
640 printk("tcp_send_skb: bad skb (skb = %p, data = %p, th = %p, len = %lu)\n",
641 skb, skb->data, th, skb->len);
642 kfree_skb(skb, FREE_WRITE);
643 return;
644 }
645
646 /* If we have queued a header size packet.. */
647 if (size == sizeof(struct tcphdr))
648 {
649 /* If its got a syn or fin its notionally included in the size..*/
650 if(!th->syn && !th->fin)
651 {
652 printk("tcp_send_skb: attempt to queue a bogon.\n");
653 kfree_skb(skb,FREE_WRITE);
654 return;
655 }
656 }
657
658 tcp_statistics.TcpOutSegs++;
659
660 skb->h.seq = ntohl(th->seq) + size - 4*th->doff;
661 if (after(skb->h.seq, sk->window_seq) ||
662 (sk->retransmits && sk->timeout == TIME_WRITE) ||
663 sk->packets_out >= sk->cong_window)
664 {
665 /* checksum will be supplied by tcp_write_xmit. So
666 * we shouldn't need to set it at all. I'm being paranoid */
667 th->check = 0;
668 if (skb->next != NULL)
669 {
670 printk("tcp_send_partial: next != NULL\n");
671 skb_unlink(skb);
672 }
673 skb_queue_tail(&sk->write_queue, skb);
674 if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
675 sk->send_head == NULL &&
676 sk->ack_backlog == 0)
677 reset_timer(sk, TIME_PROBE0, sk->rto);
678 }
679 else
680 {
681 th->ack_seq = ntohl(sk->acked_seq);
682 th->window = ntohs(tcp_select_window(sk));
683
684 tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
685
686 sk->sent_seq = sk->write_seq;
687 sk->prot->queue_xmit(sk, skb->dev, skb, 0);
688 }
689 }
690
691 struct sk_buff * tcp_dequeue_partial(struct sock * sk)
/* */
692 {
693 struct sk_buff * skb;
694 unsigned long flags;
695
696 save_flags(flags);
697 cli();
698 skb = sk->partial;
699 if (skb) {
700 sk->partial = NULL;
701 del_timer(&sk->partial_timer);
702 }
703 restore_flags(flags);
704 return skb;
705 }
706
707 static void tcp_send_partial(struct sock *sk)
/* */
708 {
709 struct sk_buff *skb;
710
711 if (sk == NULL)
712 return;
713 while ((skb = tcp_dequeue_partial(sk)) != NULL)
714 tcp_send_skb(sk, skb);
715 }
716
717 void tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
/* */
718 {
719 struct sk_buff * tmp;
720 unsigned long flags;
721
722 save_flags(flags);
723 cli();
724 tmp = sk->partial;
725 if (tmp)
726 del_timer(&sk->partial_timer);
727 sk->partial = skb;
728 init_timer(&sk->partial_timer);
729 sk->partial_timer.expires = HZ;
730 sk->partial_timer.function = (void (*)(unsigned long)) tcp_send_partial;
731 sk->partial_timer.data = (unsigned long) sk;
732 add_timer(&sk->partial_timer);
733 restore_flags(flags);
734 if (tmp)
735 tcp_send_skb(sk, tmp);
736 }
737
738
739 /*
740 * This routine sends an ack and also updates the window.
741 */
742
743 static void tcp_send_ack(unsigned long sequence, unsigned long ack,
/* */
744 struct sock *sk,
745 struct tcphdr *th, unsigned long daddr)
746 {
747 struct sk_buff *buff;
748 struct tcphdr *t1;
749 struct device *dev = NULL;
750 int tmp;
751
752 if(sk->zapped)
753 return; /* We have been reset, we may not send again */
754 /*
755 * We need to grab some memory, and put together an ack,
756 * and then put it into the queue to be sent.
757 */
758
759 buff = sk->prot->wmalloc(sk, MAX_ACK_SIZE, 1, GFP_ATOMIC);
760 if (buff == NULL)
761 {
762 /* Force it to send an ack. */
763 sk->ack_backlog++;
764 if (sk->timeout != TIME_WRITE && tcp_connected(sk->state))
765 {
766 reset_timer(sk, TIME_WRITE, 10);
767 }
768 return;
769 }
770
771 buff->len = sizeof(struct tcphdr);
772 buff->sk = sk;
773 buff->localroute = sk->localroute;
774 t1 =(struct tcphdr *) buff->data;
775
776 /* Put in the IP header and routing stuff. */
777 tmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
778 IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
779 if (tmp < 0)
780 {
781 buff->free=1;
782 sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
783 return;
784 }
785 buff->len += tmp;
786 t1 =(struct tcphdr *)((char *)t1 +tmp);
787
788 /* FIXME: */
789 memcpy(t1, th, sizeof(*t1)); /* this should probably be removed */
790
791 /*
792 * Swap the send and the receive.
793 */
794
795 t1->dest = th->source;
796 t1->source = th->dest;
797 t1->seq = ntohl(sequence);
798 t1->ack = 1;
799 sk->window = tcp_select_window(sk);
800 t1->window = ntohs(sk->window);
801 t1->res1 = 0;
802 t1->res2 = 0;
803 t1->rst = 0;
804 t1->urg = 0;
805 t1->syn = 0;
806 t1->psh = 0;
807 t1->fin = 0;
808 if (ack == sk->acked_seq)
809 {
810 sk->ack_backlog = 0;
811 sk->bytes_rcv = 0;
812 sk->ack_timed = 0;
813 if (sk->send_head == NULL && skb_peek(&sk->write_queue) == NULL
814 && sk->timeout == TIME_WRITE)
815 {
816 if(sk->keepopen) {
817 reset_timer(sk,TIME_KEEPOPEN,TCP_TIMEOUT_LEN);
818 } else {
819 delete_timer(sk);
820 }
821 }
822 }
823 t1->ack_seq = ntohl(ack);
824 t1->doff = sizeof(*t1)/4;
825 tcp_send_check(t1, sk->saddr, daddr, sizeof(*t1), sk);
826 if (sk->debug)
827 printk("\rtcp_ack: seq %lx ack %lx\n", sequence, ack);
828 tcp_statistics.TcpOutSegs++;
829 sk->prot->queue_xmit(sk, dev, buff, 1);
830 }
831
832
833 /*
834 * This routine builds a generic TCP header.
835 */
836
837 static int tcp_build_header(struct tcphdr *th, struct sock *sk, int push)
/* */
838 {
839
840 /* FIXME: want to get rid of this. */
841 memcpy(th,(void *) &(sk->dummy_th), sizeof(*th));
842 th->seq = htonl(sk->write_seq);
843 th->psh =(push == 0) ? 1 : 0;
844 th->doff = sizeof(*th)/4;
845 th->ack = 1;
846 th->fin = 0;
847 sk->ack_backlog = 0;
848 sk->bytes_rcv = 0;
849 sk->ack_timed = 0;
850 th->ack_seq = htonl(sk->acked_seq);
851 sk->window = tcp_select_window(sk)/*sk->prot->rspace(sk)*/;
852 th->window = htons(sk->window);
853
854 return(sizeof(*th));
855 }
856
857 /*
858 * This routine copies from a user buffer into a socket,
859 * and starts the transmit system.
860 */
861
862 static int tcp_write(struct sock *sk, unsigned char *from,
/* */
863 int len, int nonblock, unsigned flags)
864 {
865 int copied = 0;
866 int copy;
867 int tmp;
868 struct sk_buff *skb;
869 struct sk_buff *send_tmp;
870 unsigned char *buff;
871 struct proto *prot;
872 struct device *dev = NULL;
873
874 sk->inuse=1;
875 prot = sk->prot;
876 while(len > 0)
877 {
878 if (sk->err)
879 { /* Stop on an error */
880 release_sock(sk);
881 if (copied)
882 return(copied);
883 tmp = -sk->err;
884 sk->err = 0;
885 return(tmp);
886 }
887
888 /*
889 * First thing we do is make sure that we are established.
890 */
891
892 if (sk->shutdown & SEND_SHUTDOWN)
893 {
894 release_sock(sk);
895 sk->err = EPIPE;
896 if (copied)
897 return(copied);
898 sk->err = 0;
899 return(-EPIPE);
900 }
901
902
903 /*
904 * Wait for a connection to finish.
905 */
906
907 while(sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT)
908 {
909 if (sk->err)
910 {
911 release_sock(sk);
912 if (copied)
913 return(copied);
914 tmp = -sk->err;
915 sk->err = 0;
916 return(tmp);
917 }
918
919 if (sk->state != TCP_SYN_SENT && sk->state != TCP_SYN_RECV)
920 {
921 release_sock(sk);
922 if (copied)
923 return(copied);
924
925 if (sk->err)
926 {
927 tmp = -sk->err;
928 sk->err = 0;
929 return(tmp);
930 }
931
932 if (sk->keepopen)
933 {
934 send_sig(SIGPIPE, current, 0);
935 }
936 return(-EPIPE);
937 }
938
939 if (nonblock || copied)
940 {
941 release_sock(sk);
942 if (copied)
943 return(copied);
944 return(-EAGAIN);
945 }
946
947 release_sock(sk);
948 cli();
949
950 if (sk->state != TCP_ESTABLISHED &&
951 sk->state != TCP_CLOSE_WAIT && sk->err == 0)
952 {
953 interruptible_sleep_on(sk->sleep);
954 if (current->signal & ~current->blocked)
955 {
956 sti();
957 if (copied)
958 return(copied);
959 return(-ERESTARTSYS);
960 }
961 }
962 sk->inuse = 1;
963 sti();
964 }
965
966 /*
967 * The following code can result in copy <= if sk->mss is ever
968 * decreased. It shouldn't be. sk->mss is min(sk->mtu, sk->max_window).
969 * sk->mtu is constant once SYN processing is finished. I.e. we
970 * had better not get here until we've seen his SYN and at least one
971 * valid ack. (The SYN sets sk->mtu and the ack sets sk->max_window.)
972 * But ESTABLISHED should guarantee that. sk->max_window is by definition
973 * non-decreasing. Note that any ioctl to set user_mss must be done
974 * before the exchange of SYN's. If the initial ack from the other
975 * end has a window of 0, max_window and thus mss will both be 0.
976 */
977
978 /*
979 * Now we need to check if we have a half built packet.
980 */
981
982 if ((skb = tcp_dequeue_partial(sk)) != NULL)
983 {
984 int hdrlen;
985
986 /* IP header + TCP header */
987 hdrlen = ((unsigned long)skb->h.th - (unsigned long)skb->data)
988 + sizeof(struct tcphdr);
989
990 /* Add more stuff to the end of skb->len */
991 if (!(flags & MSG_OOB))
992 {
993 copy = min(sk->mss - (skb->len - hdrlen), len);
994 /* FIXME: this is really a bug. */
995 if (copy <= 0)
996 {
997 printk("TCP: **bug**: \"copy\" <= 0!!\n");
998 copy = 0;
999 }
1000
1001 memcpy_fromfs(skb->data + skb->len, from, copy);
1002 skb->len += copy;
1003 from += copy;
1004 copied += copy;
1005 len -= copy;
1006 sk->write_seq += copy;
1007 }
1008 if ((skb->len - hdrlen) >= sk->mss ||
1009 (flags & MSG_OOB) || !sk->packets_out)
1010 tcp_send_skb(sk, skb);
1011 else
1012 tcp_enqueue_partial(skb, sk);
1013 continue;
1014 }
1015
1016 /*
1017 * We also need to worry about the window.
1018 * If window < 1/2 the maximum window we've seen from this
1019 * host, don't use it. This is sender side
1020 * silly window prevention, as specified in RFC1122.
1021 * (Note that this is different than earlier versions of
1022 * SWS prevention, e.g. RFC813.). What we actually do is
1023 * use the whole MSS. Since the results in the right
1024 * edge of the packet being outside the window, it will
1025 * be queued for later rather than sent.
1026 */
1027
1028 copy = sk->window_seq - sk->write_seq;
1029 if (copy <= 0 || copy < (sk->max_window >> 1) || copy > sk->mss)
1030 copy = sk->mss;
1031 if (copy > len)
1032 copy = len;
1033
1034 /*
1035 * We should really check the window here also.
1036 */
1037
1038 send_tmp = NULL;
1039 if (copy < sk->mss && !(flags & MSG_OOB))
1040 {
1041 /*
1042 * We will release the socket incase we sleep here.
1043 */
1044 release_sock(sk);
1045 /*
1046 * NB: following must be mtu, because mss can be increased.
1047 * mss is always <= mtu
1048 */
1049 skb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
1050 sk->inuse = 1;
1051 send_tmp = skb;
1052 }
1053 else
1054 {
1055 /*
1056 * We will release the socket incase we sleep here.
1057 */
1058 release_sock(sk);
1059 skb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
1060 sk->inuse = 1;
1061 }
1062
1063 /*
1064 * If we didn't get any memory, we need to sleep.
1065 */
1066
1067 if (skb == NULL)
1068 {
1069 if (nonblock /* || copied */)
1070 {
1071 release_sock(sk);
1072 if (copied)
1073 return(copied);
1074 return(-EAGAIN);
1075 }
1076
1077 /*
1078 * FIXME: here is another race condition.
1079 */
1080
1081 tmp = sk->wmem_alloc;
1082 release_sock(sk);
1083 cli();
1084 /*
1085 * Again we will try to avoid it.
1086 */
1087 if (tmp <= sk->wmem_alloc &&
1088 (sk->state == TCP_ESTABLISHED||sk->state == TCP_CLOSE_WAIT)
1089 && sk->err == 0)
1090 {
1091 interruptible_sleep_on(sk->sleep);
1092 if (current->signal & ~current->blocked)
1093 {
1094 sti();
1095 if (copied)
1096 return(copied);
1097 return(-ERESTARTSYS);
1098 }
1099 }
1100 sk->inuse = 1;
1101 sti();
1102 continue;
1103 }
1104
1105 skb->len = 0;
1106 skb->sk = sk;
1107 skb->free = 0;
1108 skb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
1109
1110 buff = skb->data;
1111
1112 /*
1113 * FIXME: we need to optimize this.
1114 * Perhaps some hints here would be good.
1115 */
1116
1117 tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
1118 IPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
1119 if (tmp < 0 )
1120 {
1121 prot->wfree(sk, skb->mem_addr, skb->mem_len);
1122 release_sock(sk);
1123 if (copied)
1124 return(copied);
1125 return(tmp);
1126 }
1127 skb->len += tmp;
1128 skb->dev = dev;
1129 buff += tmp;
1130 skb->h.th =(struct tcphdr *) buff;
1131 tmp = tcp_build_header((struct tcphdr *)buff, sk, len-copy);
1132 if (tmp < 0)
1133 {
1134 prot->wfree(sk, skb->mem_addr, skb->mem_len);
1135 release_sock(sk);
1136 if (copied)
1137 return(copied);
1138 return(tmp);
1139 }
1140
1141 if (flags & MSG_OOB)
1142 {
1143 ((struct tcphdr *)buff)->urg = 1;
1144 ((struct tcphdr *)buff)->urg_ptr = ntohs(copy);
1145 }
1146 skb->len += tmp;
1147 memcpy_fromfs(buff+tmp, from, copy);
1148
1149 from += copy;
1150 copied += copy;
1151 len -= copy;
1152 skb->len += copy;
1153 skb->free = 0;
1154 sk->write_seq += copy;
1155
1156 if (send_tmp != NULL && sk->packets_out)
1157 {
1158 tcp_enqueue_partial(send_tmp, sk);
1159 continue;
1160 }
1161 tcp_send_skb(sk, skb);
1162 }
1163 sk->err = 0;
1164
1165 /*
1166 * Nagle's rule. Turn Nagle off with TCP_NODELAY for highly
1167 * interactive fast network servers. It's meant to be on and
1168 * it really improves the throughput though not the echo time
1169 * on my slow slip link - Alan
1170 */
1171
1172 /*
1173 * Avoid possible race on send_tmp - c/o Johannes Stille
1174 */
1175
1176 if(sk->partial && ((!sk->packets_out)
1177 /* If not nagling we can send on the before case too.. */
1178 || (sk->nonagle && before(sk->write_seq , sk->window_seq))
1179 ))
1180 tcp_send_partial(sk);
1181
1182 release_sock(sk);
1183 return(copied);
1184 }
1185
1186
1187 static int tcp_sendto(struct sock *sk, unsigned char *from,
/* */
1188 int len, int nonblock, unsigned flags,
1189 struct sockaddr_in *addr, int addr_len)
1190 {
1191 if (flags & ~(MSG_OOB|MSG_DONTROUTE))
1192 return -EINVAL;
1193 if (addr_len < sizeof(*addr))
1194 return(-EINVAL);
1195 if (addr->sin_family && addr->sin_family != AF_INET)
1196 return(-EINVAL);
1197 if (addr->sin_port != sk->dummy_th.dest)
1198 return(-EISCONN);
1199 if (addr->sin_addr.s_addr != sk->daddr)
1200 return(-EISCONN);
1201 return(tcp_write(sk, from, len, nonblock, flags));
1202 }
1203
1204
1205 static void tcp_read_wakeup(struct sock *sk)
/* */
1206 {
1207 int tmp;
1208 struct device *dev = NULL;
1209 struct tcphdr *t1;
1210 struct sk_buff *buff;
1211
1212 if (!sk->ack_backlog)
1213 return;
1214
1215 /*
1216 * FIXME: we need to put code here to prevent this routine from
1217 * being called. Being called once in a while is ok, so only check
1218 * if this is the second time in a row.
1219 */
1220
1221 /*
1222 * We need to grab some memory, and put together an ack,
1223 * and then put it into the queue to be sent.
1224 */
1225
1226 buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
1227 if (buff == NULL)
1228 {
1229 /* Try again real soon. */
1230 reset_timer(sk, TIME_WRITE, 10);
1231 return;
1232 }
1233
1234 buff->len = sizeof(struct tcphdr);
1235 buff->sk = sk;
1236 buff->localroute = sk->localroute;
1237
1238 /*
1239 * Put in the IP header and routing stuff.
1240 */
1241
1242 tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
1243 IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
1244 if (tmp < 0)
1245 {
1246 buff->free=1;
1247 sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
1248 return;
1249 }
1250
1251 buff->len += tmp;
1252 t1 =(struct tcphdr *)(buff->data +tmp);
1253
1254 memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
1255 t1->seq = htonl(sk->sent_seq);
1256 t1->ack = 1;
1257 t1->res1 = 0;
1258 t1->res2 = 0;
1259 t1->rst = 0;
1260 t1->urg = 0;
1261 t1->syn = 0;
1262 t1->psh = 0;
1263 sk->ack_backlog = 0;
1264 sk->bytes_rcv = 0;
1265 sk->window = tcp_select_window(sk);/*sk->prot->rspace(sk);*/
1266 t1->window = ntohs(sk->window);
1267 t1->ack_seq = ntohl(sk->acked_seq);
1268 t1->doff = sizeof(*t1)/4;
1269 tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
1270 sk->prot->queue_xmit(sk, dev, buff, 1);
1271 tcp_statistics.TcpOutSegs++;
1272 }
1273
1274
1275 /*
1276 * FIXME:
1277 * This routine frees used buffers.
1278 * It should consider sending an ACK to let the
1279 * other end know we now have a bigger window.
1280 */
1281
1282 static void cleanup_rbuf(struct sock *sk)
/* */
1283 {
1284 unsigned long flags;
1285 unsigned long left;
1286 struct sk_buff *skb;
1287 unsigned long rspace;
1288
1289 if(sk->debug)
1290 printk("cleaning rbuf for sk=%p\n", sk);
1291
1292 save_flags(flags);
1293 cli();
1294
1295 left = sk->prot->rspace(sk);
1296
1297 /*
1298 * We have to loop through all the buffer headers,
1299 * and try to free up all the space we can.
1300 */
1301
1302 while((skb=skb_peek(&sk->receive_queue)) != NULL)
1303 {
1304 if (!skb->used)
1305 break;
1306 skb_unlink(skb);
1307 skb->sk = sk;
1308 kfree_skb(skb, FREE_READ);
1309 }
1310
1311 restore_flags(flags);
1312
1313 /*
1314 * FIXME:
1315 * At this point we should send an ack if the difference
1316 * in the window, and the amount of space is bigger than
1317 * TCP_WINDOW_DIFF.
1318 */
1319
1320 if(sk->debug)
1321 printk("sk->rspace = %lu, was %lu\n", sk->prot->rspace(sk),
1322 left);
1323 if ((rspace=sk->prot->rspace(sk)) != left)
1324 {
1325 /*
1326 * This area has caused the most trouble. The current strategy
1327 * is to simply do nothing if the other end has room to send at
1328 * least 3 full packets, because the ack from those will auto-
1329 * matically update the window. If the other end doesn't think
1330 * we have much space left, but we have room for at least 1 more
1331 * complete packet than it thinks we do, we will send an ack
1332 * immediately. Otherwise we will wait up to .5 seconds in case
1333 * the user reads some more.
1334 */
1335 sk->ack_backlog++;
1336 /*
1337 * It's unclear whether to use sk->mtu or sk->mss here. They differ only
1338 * if the other end is offering a window smaller than the agreed on MSS
1339 * (called sk->mtu here). In theory there's no connection between send
1340 * and receive, and so no reason to think that they're going to send
1341 * small packets. For the moment I'm using the hack of reducing the mss
1342 * only on the send side, so I'm putting mtu here.
1343 */
1344
1345 if (rspace > (sk->window - sk->bytes_rcv + sk->mtu))
1346 {
1347 /* Send an ack right now. */
1348 tcp_read_wakeup(sk);
1349 }
1350 else
1351 {
1352 /* Force it to send an ack soon. */
1353 int was_active = del_timer(&sk->timer);
1354 if (!was_active || TCP_ACK_TIME < sk->timer.expires)
1355 {
1356 reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
1357 }
1358 else
1359 add_timer(&sk->timer);
1360 }
1361 }
1362 }
1363
1364
1365 /*
1366 * Handle reading urgent data.
1367 */
1368
1369 static int tcp_read_urg(struct sock * sk, int nonblock,
/* */
1370 unsigned char *to, int len, unsigned flags)
1371 {
1372 struct wait_queue wait = { current, NULL };
1373
1374 while (len > 0)
1375 {
1376 if (sk->urginline || !sk->urg_data || sk->urg_data == URG_READ)
1377 return -EINVAL;
1378 if (sk->urg_data & URG_VALID)
1379 {
1380 char c = sk->urg_data;
1381 if (!(flags & MSG_PEEK))
1382 sk->urg_data = URG_READ;
1383 put_fs_byte(c, to);
1384 return 1;
1385 }
1386
1387 if (sk->err)
1388 {
1389 int tmp = -sk->err;
1390 sk->err = 0;
1391 return tmp;
1392 }
1393
1394 if (sk->state == TCP_CLOSE || sk->done)
1395 {
1396 if (!sk->done) {
1397 sk->done = 1;
1398 return 0;
1399 }
1400 return -ENOTCONN;
1401 }
1402
1403 if (sk->shutdown & RCV_SHUTDOWN)
1404 {
1405 sk->done = 1;
1406 return 0;
1407 }
1408
1409 if (nonblock)
1410 return -EAGAIN;
1411
1412 if (current->signal & ~current->blocked)
1413 return -ERESTARTSYS;
1414
1415 current->state = TASK_INTERRUPTIBLE;
1416 add_wait_queue(sk->sleep, &wait);
1417 if ((sk->urg_data & URG_NOTYET) && sk->err == 0 &&
1418 !(sk->shutdown & RCV_SHUTDOWN))
1419 schedule();
1420 remove_wait_queue(sk->sleep, &wait);
1421 current->state = TASK_RUNNING;
1422 }
1423 return 0;
1424 }
1425
1426
1427 /*
1428 * This routine copies from a sock struct into the user buffer.
1429 */
1430
1431 static int tcp_read(struct sock *sk, unsigned char *to,
/* */
1432 int len, int nonblock, unsigned flags)
1433 {
1434 struct wait_queue wait = { current, NULL };
1435 int copied = 0;
1436 unsigned long peek_seq;
1437 unsigned long *seq;
1438 unsigned long used;
1439
1440 /* This error should be checked. */
1441 if (sk->state == TCP_LISTEN)
1442 return -ENOTCONN;
1443
1444 /* Urgent data needs to be handled specially. */
1445 if (flags & MSG_OOB)
1446 return tcp_read_urg(sk, nonblock, to, len, flags);
1447
1448 peek_seq = sk->copied_seq;
1449 seq = &sk->copied_seq;
1450 if (flags & MSG_PEEK)
1451 seq = &peek_seq;
1452
1453 add_wait_queue(sk->sleep, &wait);
1454 sk->inuse = 1;
1455 while (len > 0)
1456 {
1457 struct sk_buff * skb;
1458 unsigned long offset;
1459
1460 /*
1461 * are we at urgent data? Stop if we have read anything.
1462 */
1463 if (copied && sk->urg_data && sk->urg_seq == 1+*seq)
1464 break;
1465
1466 current->state = TASK_INTERRUPTIBLE;
1467
1468 skb = skb_peek(&sk->receive_queue);
1469 do
1470 {
1471 if (!skb)
1472 break;
1473 if (before(1+*seq, skb->h.th->seq))
1474 break;
1475 offset = 1 + *seq - skb->h.th->seq;
1476 if (skb->h.th->syn)
1477 offset--;
1478 if (offset < skb->len)
1479 goto found_ok_skb;
1480 if (!(flags & MSG_PEEK))
1481 skb->used = 1;
1482 skb = skb->next;
1483 }
1484 while (skb != (struct sk_buff *)&sk->receive_queue);
1485
1486 if (copied)
1487 break;
1488
1489 if (sk->err)
1490 {
1491 copied = -sk->err;
1492 sk->err = 0;
1493 break;
1494 }
1495
1496 if (sk->state == TCP_CLOSE)
1497 {
1498 if (!sk->done)
1499 {
1500 sk->done = 1;
1501 break;
1502 }
1503 copied = -ENOTCONN;
1504 break;
1505 }
1506
1507 if (sk->shutdown & RCV_SHUTDOWN)
1508 {
1509 sk->done = 1;
1510 break;
1511 }
1512
1513 if (nonblock)
1514 {
1515 copied = -EAGAIN;
1516 break;
1517 }
1518
1519 cleanup_rbuf(sk);
1520 release_sock(sk);
1521 schedule();
1522 sk->inuse = 1;
1523
1524 if (current->signal & ~current->blocked)
1525 {
1526 copied = -ERESTARTSYS;
1527 break;
1528 }
1529 continue;
1530
1531 found_ok_skb:
1532 /* Ok so how much can we use ? */
1533 used = skb->len - offset;
1534 if (len < used)
1535 used = len;
1536 /* do we have urgent data here? */
1537 if (sk->urg_data)
1538 {
1539 unsigned long urg_offset = sk->urg_seq - (1 + *seq);
1540 if (urg_offset < used)
1541 {
1542 if (!urg_offset)
1543 {
1544 if (!sk->urginline)
1545 {
1546 ++*seq;
1547 offset++;
1548 used--;
1549 }
1550 }
1551 else
1552 used = urg_offset;
1553 }
1554 }
1555 /* Copy it */
1556 memcpy_tofs(to,((unsigned char *)skb->h.th) +
1557 skb->h.th->doff*4 + offset, used);
1558 copied += used;
1559 len -= used;
1560 to += used;
1561 *seq += used;
1562 if (after(sk->copied_seq+1,sk->urg_seq))
1563 sk->urg_data = 0;
1564 if (!(flags & MSG_PEEK) && (used + offset >= skb->len))
1565 skb->used = 1;
1566 }
1567 remove_wait_queue(sk->sleep, &wait);
1568 current->state = TASK_RUNNING;
1569
1570 /* Clean up data we have read: This will do ACK frames */
1571 cleanup_rbuf(sk);
1572 release_sock(sk);
1573 return copied;
1574 }
1575
1576
1577 /*
1578 * Shutdown the sending side of a connection.
1579 */
1580
1581 void tcp_shutdown(struct sock *sk, int how)
/* */
1582 {
1583 struct sk_buff *buff;
1584 struct tcphdr *t1, *th;
1585 struct proto *prot;
1586 int tmp;
1587 struct device *dev = NULL;
1588
1589 /*
1590 * We need to grab some memory, and put together a FIN,
1591 * and then put it into the queue to be sent.
1592 * FIXME:
1593 *
1594 * Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
1595 * Most of this is guesswork, so maybe it will work...
1596 */
1597
1598 if (!(how & SEND_SHUTDOWN))
1599 return;
1600
1601 /*
1602 * If we've already sent a FIN, return.
1603 */
1604
1605 if (sk->state == TCP_FIN_WAIT1 ||
1606 sk->state == TCP_FIN_WAIT2 ||
1607 sk->state == TCP_CLOSING ||
1608 sk->state == TCP_LAST_ACK ||
1609 sk->state == TCP_TIME_WAIT
1610 )
1611 {
1612 return;
1613 }
1614 sk->inuse = 1;
1615
1616 /*
1617 * flag that the sender has shutdown
1618 */
1619
1620 sk->shutdown |= SEND_SHUTDOWN;
1621
1622 /*
1623 * Clear out any half completed packets.
1624 */
1625
1626 if (sk->partial)
1627 tcp_send_partial(sk);
1628
1629 prot =(struct proto *)sk->prot;
1630 th =(struct tcphdr *)&sk->dummy_th;
1631 release_sock(sk); /* incase the malloc sleeps. */
1632 buff = prot->wmalloc(sk, MAX_RESET_SIZE,1 , GFP_KERNEL);
1633 if (buff == NULL)
1634 return;
1635 sk->inuse = 1;
1636
1637 buff->sk = sk;
1638 buff->len = sizeof(*t1);
1639 buff->localroute = sk->localroute;
1640 t1 =(struct tcphdr *) buff->data;
1641
1642 /*
1643 * Put in the IP header and routing stuff.
1644 */
1645
1646 tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
1647 IPPROTO_TCP, sk->opt,
1648 sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
1649 if (tmp < 0)
1650 {
1651 /*
1652 * Finish anyway, treat this as a send that got lost.
1653 *
1654 * Enter FIN_WAIT1 on normal shutdown, which waits for
1655 * written data to be completely acknowledged along
1656 * with an acknowledge to our FIN.
1657 *
1658 * Enter FIN_WAIT2 on abnormal shutdown -- close before
1659 * connection established.
1660 */
1661 buff->free=1;
1662 prot->wfree(sk,buff->mem_addr, buff->mem_len);
1663
1664 if (sk->state == TCP_ESTABLISHED)
1665 tcp_set_state(sk,TCP_FIN_WAIT1);
1666 else if(sk->state == TCP_CLOSE_WAIT)
1667 tcp_set_state(sk,TCP_LAST_ACK);
1668 else
1669 tcp_set_state(sk,TCP_FIN_WAIT2);
1670
1671 release_sock(sk);
1672 return;
1673 }
1674
1675 t1 =(struct tcphdr *)((char *)t1 +tmp);
1676 buff->len += tmp;
1677 buff->dev = dev;
1678 memcpy(t1, th, sizeof(*t1));
1679 t1->seq = ntohl(sk->write_seq);
1680 sk->write_seq++;
1681 buff->h.seq = sk->write_seq;
1682 t1->ack = 1;
1683 t1->ack_seq = ntohl(sk->acked_seq);
1684 t1->window = ntohs(sk->window=tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
1685 t1->fin = 1;
1686 t1->rst = 0;
1687 t1->doff = sizeof(*t1)/4;
1688 tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
1689
1690 /*
1691 * If there is data in the write queue, the fin must be appended to
1692 * the write queue.
1693 */
1694
1695 if (skb_peek(&sk->write_queue) != NULL)
1696 {
1697 buff->free=0;
1698 if (buff->next != NULL)
1699 {
1700 printk("tcp_shutdown: next != NULL\n");
1701 skb_unlink(buff);
1702 }
1703 skb_queue_tail(&sk->write_queue, buff);
1704 }
1705 else
1706 {
1707 sk->sent_seq = sk->write_seq;
1708 sk->prot->queue_xmit(sk, dev, buff, 0);
1709 }
1710
1711 if (sk->state == TCP_ESTABLISHED)
1712 tcp_set_state(sk,TCP_FIN_WAIT1);
1713 else if (sk->state == TCP_CLOSE_WAIT)
1714 tcp_set_state(sk,TCP_LAST_ACK);
1715 else
1716 tcp_set_state(sk,TCP_FIN_WAIT2);
1717
1718 release_sock(sk);
1719 }
1720
1721
1722 static int
1723 tcp_recvfrom(struct sock *sk, unsigned char *to,
/* */
1724 int to_len, int nonblock, unsigned flags,
1725 struct sockaddr_in *addr, int *addr_len)
1726 {
1727 int result;
1728
1729 /*
1730 * Have to check these first unlike the old code. If
1731 * we check them after we lose data on an error
1732 * which is wrong
1733 */
1734
1735 if(addr_len)
1736 *addr_len = sizeof(*addr);
1737 result=tcp_read(sk, to, to_len, nonblock, flags);
1738
1739 if (result < 0)
1740 return(result);
1741
1742 if(addr)
1743 {
1744 addr->sin_family = AF_INET;
1745 addr->sin_port = sk->dummy_th.dest;
1746 addr->sin_addr.s_addr = sk->daddr;
1747 }
1748 return(result);
1749 }
1750
1751
1752 /*
1753 * This routine will send an RST to the other tcp.
1754 */
1755
1756 static void tcp_reset(unsigned long saddr, unsigned long daddr, struct tcphdr *th,
/* */
1757 struct proto *prot, struct options *opt, struct device *dev, int tos, int ttl)
1758 {
1759 struct sk_buff *buff;
1760 struct tcphdr *t1;
1761 int tmp;
1762 struct device *ndev=NULL;
1763
1764 /*
1765 * We need to grab some memory, and put together an RST,
1766 * and then put it into the queue to be sent.
1767 */
1768
1769 buff = prot->wmalloc(NULL, MAX_RESET_SIZE, 1, GFP_ATOMIC);
1770 if (buff == NULL)
1771 return;
1772
1773 buff->len = sizeof(*t1);
1774 buff->sk = NULL;
1775 buff->dev = dev;
1776 buff->localroute = 0;
1777
1778 t1 =(struct tcphdr *) buff->data;
1779
1780 /*
1781 * Put in the IP header and routing stuff.
1782 */
1783
1784 tmp = prot->build_header(buff, saddr, daddr, &ndev, IPPROTO_TCP, opt,
1785 sizeof(struct tcphdr),tos,ttl);
1786 if (tmp < 0)
1787 {
1788 buff->free = 1;
1789 prot->wfree(NULL, buff->mem_addr, buff->mem_len);
1790 return;
1791 }
1792
1793 t1 =(struct tcphdr *)((char *)t1 +tmp);
1794 buff->len += tmp;
1795 memcpy(t1, th, sizeof(*t1));
1796
1797 /*
1798 * Swap the send and the receive.
1799 */
1800
1801 t1->dest = th->source;
1802 t1->source = th->dest;
1803 t1->rst = 1;
1804 t1->window = 0;
1805
1806 if(th->ack)
1807 {
1808 t1->ack = 0;
1809 t1->seq = th->ack_seq;
1810 t1->ack_seq = 0;
1811 }
1812 else
1813 {
1814 t1->ack = 1;
1815 if(!th->syn)
1816 t1->ack_seq=htonl(th->seq);
1817 else
1818 t1->ack_seq=htonl(th->seq+1);
1819 t1->seq=0;
1820 }
1821
1822 t1->syn = 0;
1823 t1->urg = 0;
1824 t1->fin = 0;
1825 t1->psh = 0;
1826 t1->doff = sizeof(*t1)/4;
1827 tcp_send_check(t1, saddr, daddr, sizeof(*t1), NULL);
1828 prot->queue_xmit(NULL, dev, buff, 1);
1829 tcp_statistics.TcpOutSegs++;
1830 }
1831
1832
1833 /*
1834 * Look for tcp options. Parses everything but only knows about MSS.
1835 * This routine is always called with the packet containing the SYN.
1836 * However it may also be called with the ack to the SYN. So you
1837 * can't assume this is always the SYN. It's always called after
1838 * we have set up sk->mtu to our own MTU.
1839 */
1840
1841 static void tcp_options(struct sock *sk, struct tcphdr *th)
/* */
1842 {
1843 unsigned char *ptr;
1844 int length=(th->doff*4)-sizeof(struct tcphdr);
1845 int mss_seen = 0;
1846
1847 ptr = (unsigned char *)(th + 1);
1848
1849 while(length>0)
1850 {
1851 int opcode=*ptr++;
1852 int opsize=*ptr++;
1853 switch(opcode)
1854 {
1855 case TCPOPT_EOL:
1856 return;
1857 case TCPOPT_NOP:
1858 length-=2;
1859 continue;
1860
1861 default:
1862 if(opsize<=2) /* Avoid silly options looping forever */
1863 return;
1864 switch(opcode)
1865 {
1866 case TCPOPT_MSS:
1867 if(opsize==4 && th->syn)
1868 {
1869 sk->mtu=min(sk->mtu,ntohs(*(unsigned short *)ptr));
1870 mss_seen = 1;
1871 }
1872 break;
1873 /* Add other options here as people feel the urge to implement stuff like large windows */
1874 }
1875 ptr+=opsize-2;
1876 length-=opsize;
1877 }
1878 }
1879 if (th->syn)
1880 {
1881 if (! mss_seen)
1882 sk->mtu=min(sk->mtu, 536); /* default MSS if none sent */
1883 }
1884 #ifdef CONFIG_INET_PCTCP
1885 sk->mss = min(sk->max_window >> 1, sk->mtu);
1886 #else
1887 sk->mss = min(sk->max_window, sk->mtu);
1888 #endif
1889 }
1890
1891 static inline unsigned long default_mask(unsigned long dst)
/* */
1892 {
1893 dst = ntohl(dst);
1894 if (IN_CLASSA(dst))
1895 return htonl(IN_CLASSA_NET);
1896 if (IN_CLASSB(dst))
1897 return htonl(IN_CLASSB_NET);
1898 return htonl(IN_CLASSC_NET);
1899 }
1900
1901 /*
1902 * This routine handles a connection request.
1903 * It should make sure we haven't already responded.
1904 * Because of the way BSD works, we have to send a syn/ack now.
1905 * This also means it will be harder to close a socket which is
1906 * listening.
1907 */
1908
1909 static void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
/* */
1910 unsigned long daddr, unsigned long saddr,
1911 struct options *opt, struct device *dev)
1912 {
1913 struct sk_buff *buff;
1914 struct tcphdr *t1;
1915 unsigned char *ptr;
1916 struct sock *newsk;
1917 struct tcphdr *th;
1918 struct device *ndev=NULL;
1919 int tmp;
1920 struct rtable *rt;
1921
1922 th = skb->h.th;
1923
1924 /* If the socket is dead, don't accept the connection. */
1925 if (!sk->dead)
1926 {
1927 sk->data_ready(sk,0);
1928 }
1929 else
1930 {
1931 tcp_reset(daddr, saddr, th, sk->prot, opt, dev, sk->ip_tos,sk->ip_ttl);
1932 tcp_statistics.TcpAttemptFails++;
1933 kfree_skb(skb, FREE_READ);
1934 return;
1935 }
1936
1937 /*
1938 * Make sure we can accept more. This will prevent a
1939 * flurry of syns from eating up all our memory.
1940 */
1941
1942 if (sk->ack_backlog >= sk->max_ack_backlog)
1943 {
1944 tcp_statistics.TcpAttemptFails++;
1945 kfree_skb(skb, FREE_READ);
1946 return;
1947 }
1948
1949 /*
1950 * We need to build a new sock struct.
1951 * It is sort of bad to have a socket without an inode attached
1952 * to it, but the wake_up's will just wake up the listening socket,
1953 * and if the listening socket is destroyed before this is taken
1954 * off of the queue, this will take care of it.
1955 */
1956
1957 newsk = (struct sock *) kmalloc(sizeof(struct sock), GFP_ATOMIC);
1958 if (newsk == NULL)
1959 {
1960 /* just ignore the syn. It will get retransmitted. */
1961 tcp_statistics.TcpAttemptFails++;
1962 kfree_skb(skb, FREE_READ);
1963 return;
1964 }
1965
1966 memcpy(newsk, sk, sizeof(*newsk));
1967 skb_queue_head_init(&newsk->write_queue);
1968 skb_queue_head_init(&newsk->receive_queue);
1969 newsk->send_head = NULL;
1970 newsk->send_tail = NULL;
1971 skb_queue_head_init(&newsk->back_log);
1972 newsk->rtt = 0; /*TCP_CONNECT_TIME<<3*/
1973 newsk->rto = TCP_TIMEOUT_INIT;
1974 newsk->mdev = 0;
1975 newsk->max_window = 0;
1976 newsk->cong_window = 1;
1977 newsk->cong_count = 0;
1978 newsk->ssthresh = 0;
1979 newsk->backoff = 0;
1980 newsk->blog = 0;
1981 newsk->intr = 0;
1982 newsk->proc = 0;
1983 newsk->done = 0;
1984 newsk->partial = NULL;
1985 newsk->pair = NULL;
1986 newsk->wmem_alloc = 0;
1987 newsk->rmem_alloc = 0;
1988 newsk->localroute = sk->localroute;
1989
1990 newsk->max_unacked = MAX_WINDOW - TCP_WINDOW_DIFF;
1991
1992 newsk->err = 0;
1993 newsk->shutdown = 0;
1994 newsk->ack_backlog = 0;
1995 newsk->acked_seq = skb->h.th->seq+1;
1996 newsk->fin_seq = skb->h.th->seq;
1997 newsk->copied_seq = skb->h.th->seq;
1998 newsk->state = TCP_SYN_RECV;
1999 newsk->timeout = 0;
2000 newsk->write_seq = jiffies * SEQ_TICK - seq_offset;
2001 newsk->window_seq = newsk->write_seq;
2002 newsk->rcv_ack_seq = newsk->write_seq;
2003 newsk->urg_data = 0;
2004 newsk->retransmits = 0;
2005 newsk->destroy = 0;
2006 init_timer(&newsk->timer);
2007 newsk->timer.data = (unsigned long)newsk;
2008 newsk->timer.function = &net_timer;
2009 newsk->dummy_th.source = skb->h.th->dest;
2010 newsk->dummy_th.dest = skb->h.th->source;
2011
2012 /*
2013 * Swap these two, they are from our point of view.
2014 */
2015
2016 newsk->daddr = saddr;
2017 newsk->saddr = daddr;
2018
2019 put_sock(newsk->num,newsk);
2020 newsk->dummy_th.res1 = 0;
2021 newsk->dummy_th.doff = 6;
2022 newsk->dummy_th.fin = 0;
2023 newsk->dummy_th.syn = 0;
2024 newsk->dummy_th.rst = 0;
2025 newsk->dummy_th.psh = 0;
2026 newsk->dummy_th.ack = 0;
2027 newsk->dummy_th.urg = 0;
2028 newsk->dummy_th.res2 = 0;
2029 newsk->acked_seq = skb->h.th->seq + 1;
2030 newsk->copied_seq = skb->h.th->seq;
2031
2032 /*
2033 * Grab the ttl and tos values and use them
2034 */
2035
2036 newsk->ip_ttl=sk->ip_ttl;
2037 newsk->ip_tos=skb->ip_hdr->tos;
2038
2039 /*
2040 * Use 512 or whatever user asked for
2041 */
2042
2043 /*
2044 * Note use of sk->user_mss, since user has no direct access to newsk
2045 */
2046
2047 rt=ip_rt_route(saddr, NULL,NULL);
2048
2049 if(rt!=NULL && (rt->rt_flags&RTF_WINDOW))
2050 newsk->window_clamp = rt->rt_window;
2051 else
2052 newsk->window_clamp = 0;
2053
2054 if (sk->user_mss)
2055 newsk->mtu = sk->user_mss;
2056 else if(rt!=NULL && (rt->rt_flags&RTF_MSS))
2057 newsk->mtu = rt->rt_mss - HEADER_SIZE;
2058 else
2059 {
2060 #ifdef CONFIG_INET_SNARL /* Sub Nets Are Local */
2061 if ((saddr ^ daddr) & default_mask(saddr))
2062 #else
2063 if ((saddr ^ daddr) & dev->pa_mask)
2064 #endif
2065 newsk->mtu = 576 - HEADER_SIZE;
2066 else
2067 newsk->mtu = MAX_WINDOW;
2068 }
2069
2070 /*
2071 * But not bigger than device MTU
2072 */
2073
2074 newsk->mtu = min(newsk->mtu, dev->mtu - HEADER_SIZE);
2075
2076 /*
2077 * This will min with what arrived in the packet
2078 */
2079
2080 tcp_options(newsk,skb->h.th);
2081
2082 buff = newsk->prot->wmalloc(newsk, MAX_SYN_SIZE, 1, GFP_ATOMIC);
2083 if (buff == NULL)
2084 {
2085 sk->err = -ENOMEM;
2086 newsk->dead = 1;
2087 release_sock(newsk);
2088 kfree_skb(skb, FREE_READ);
2089 tcp_statistics.TcpAttemptFails++;
2090 return;
2091 }
2092
2093 buff->len = sizeof(struct tcphdr)+4;
2094 buff->sk = newsk;
2095 buff->localroute = newsk->localroute;
2096
2097 t1 =(struct tcphdr *) buff->data;
2098
2099 /*
2100 * Put in the IP header and routing stuff.
2101 */
2102
2103 tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &ndev,
2104 IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
2105
2106 /*
2107 * Something went wrong.
2108 */
2109
2110 if (tmp < 0)
2111 {
2112 sk->err = tmp;
2113 buff->free=1;
2114 kfree_skb(buff,FREE_WRITE);
2115 newsk->dead = 1;
2116 release_sock(newsk);
2117 skb->sk = sk;
2118 kfree_skb(skb, FREE_READ);
2119 tcp_statistics.TcpAttemptFails++;
2120 return;
2121 }
2122
2123 buff->len += tmp;
2124 t1 =(struct tcphdr *)((char *)t1 +tmp);
2125
2126 memcpy(t1, skb->h.th, sizeof(*t1));
2127 buff->h.seq = newsk->write_seq;
2128 /*
2129 * Swap the send and the receive.
2130 */
2131 t1->dest = skb->h.th->source;
2132 t1->source = newsk->dummy_th.source;
2133 t1->seq = ntohl(newsk->write_seq++);
2134 t1->ack = 1;
2135 newsk->window = tcp_select_window(newsk);/*newsk->prot->rspace(newsk);*/
2136 newsk->sent_seq = newsk->write_seq;
2137 t1->window = ntohs(newsk->window);
2138 t1->res1 = 0;
2139 t1->res2 = 0;
2140 t1->rst = 0;
2141 t1->urg = 0;
2142 t1->psh = 0;
2143 t1->syn = 1;
2144 t1->ack_seq = ntohl(skb->h.th->seq+1);
2145 t1->doff = sizeof(*t1)/4+1;
2146 ptr =(unsigned char *)(t1+1);
2147 ptr[0] = 2;
2148 ptr[1] = 4;
2149 ptr[2] = ((newsk->mtu) >> 8) & 0xff;
2150 ptr[3] =(newsk->mtu) & 0xff;
2151
2152 tcp_send_check(t1, daddr, saddr, sizeof(*t1)+4, newsk);
2153 newsk->prot->queue_xmit(newsk, dev, buff, 0);
2154
2155 reset_timer(newsk, TIME_WRITE /* -1 ? FIXME ??? */, TCP_TIMEOUT_INIT);
2156 skb->sk = newsk;
2157
2158 /*
2159 * Charge the sock_buff to newsk.
2160 */
2161
2162 sk->rmem_alloc -= skb->mem_len;
2163 newsk->rmem_alloc += skb->mem_len;
2164
2165 skb_queue_tail(&sk->receive_queue,skb);
2166 sk->ack_backlog++;
2167 release_sock(newsk);
2168 tcp_statistics.TcpOutSegs++;
2169 }
2170
2171
2172 static void tcp_close(struct sock *sk, int timeout)
/* */
2173 {
2174 struct sk_buff *buff;
2175 int need_reset = 0;
2176 struct tcphdr *t1, *th;
2177 struct proto *prot;
2178 struct device *dev=NULL;
2179 int tmp;
2180
2181 /*
2182 * We need to grab some memory, and put together a FIN,
2183 * and then put it into the queue to be sent.
2184 */
2185 sk->inuse = 1;
2186 sk->keepopen = 1;
2187 sk->shutdown = SHUTDOWN_MASK;
2188
2189 if (!sk->dead)
2190 sk->state_change(sk);
2191
2192 if (timeout == 0)
2193 {
2194 /*
2195 * We need to flush the recv. buffs. We do this only on the
2196 * descriptor close, not protocol-sourced closes, because the
2197 * reader process may not have drained the data yet!
2198 */
2199
2200 if (skb_peek(&sk->receive_queue) != NULL)
2201 {
2202 struct sk_buff *skb;
2203 if(sk->debug)
2204 printk("Clean rcv queue\n");
2205 while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
2206 {
2207 /* The +1 is not needed because the FIN takes up seq
2208 is not read!!! */
2209 if(skb->len > 0 && after(skb->h.th->seq + skb->len , sk->copied_seq))
2210 need_reset = 1;
2211 kfree_skb(skb, FREE_READ);
2212 }
2213 if(sk->debug)
2214 printk("Cleaned.\n");
2215 }
2216 }
2217
2218 /*
2219 * Get rid off any half-completed packets.
2220 */
2221
2222 if (sk->partial)
2223 {
2224 tcp_send_partial(sk);
2225 }
2226
2227 switch(sk->state)
2228 {
2229 case TCP_FIN_WAIT1:
2230 case TCP_FIN_WAIT2:
2231 case TCP_CLOSING:
2232 /*
2233 * These states occur when we have already closed out
2234 * our end. If there is no timeout, we do not do
2235 * anything. We may still be in the middle of sending
2236 * the remainder of our buffer, for example...
2237 * resetting the timer would be inappropriate.
2238 *
2239 * XXX if retransmit count reaches limit, is tcp_close()
2240 * called with timeout == 1 ? if not, we need to fix that.
2241 */
2242 if (!timeout) {
2243 int timer_active;
2244
2245 timer_active = del_timer(&sk->timer);
2246 if (timer_active)
2247 add_timer(&sk->timer);
2248 else
2249 reset_timer(sk, TIME_CLOSE, 4 * sk->rto);
2250 }
2251 #ifdef NOTDEF
2252 /*
2253 * Start a timer.
2254 * original code was 4 * sk->rtt. In converting to the
2255 * new rtt representation, we can't quite use that.
2256 * it seems to make most sense to use the backed off value
2257 */
2258 reset_timer(sk, TIME_CLOSE, 4 * sk->rto);
2259 #endif
2260 if (timeout)
2261 tcp_time_wait(sk);
2262 release_sock(sk);
2263 return; /* break causes a double release - messy */
2264 case TCP_TIME_WAIT:
2265 case TCP_LAST_ACK:
2266 /*
2267 * A timeout from these states terminates the TCB.
2268 */
2269 if (timeout)
2270 {
2271 tcp_set_state(sk,TCP_CLOSE);
2272 }
2273 release_sock(sk);
2274 return;
2275 case TCP_LISTEN:
2276 tcp_set_state(sk,TCP_CLOSE);
2277 release_sock(sk);
2278 return;
2279 case TCP_CLOSE:
2280 release_sock(sk);
2281 return;
2282 case TCP_CLOSE_WAIT:
2283 case TCP_ESTABLISHED:
2284 case TCP_SYN_SENT:
2285 case TCP_SYN_RECV:
2286 prot =(struct proto *)sk->prot;
2287 th =(struct tcphdr *)&sk->dummy_th;
2288 buff = prot->wmalloc(sk, MAX_FIN_SIZE, 1, GFP_ATOMIC);
2289 if (buff == NULL)
2290 {
2291 /* This will force it to try again later. */
2292 /* Or it would have if someone released the socket
2293 first. Anyway it might work now */
2294 release_sock(sk);
2295 if (sk->state != TCP_CLOSE_WAIT)
2296 tcp_set_state(sk,TCP_ESTABLISHED);
2297 reset_timer(sk, TIME_CLOSE, 100);
2298 return;
2299 }
2300 buff->sk = sk;
2301 buff->free = 1;
2302 buff->len = sizeof(*t1);
2303 buff->localroute = sk->localroute;
2304 t1 =(struct tcphdr *) buff->data;
2305
2306 /*
2307 * Put in the IP header and routing stuff.
2308 */
2309 tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
2310 IPPROTO_TCP, sk->opt,
2311 sizeof(struct tcphdr),sk->ip_tos,sk->ip_ttl);
2312 if (tmp < 0)
2313 {
2314 sk->write_seq++; /* Very important 8) */
2315 kfree_skb(buff,FREE_WRITE);
2316
2317 /*
2318 * Enter FIN_WAIT1 to await completion of
2319 * written out data and ACK to our FIN.
2320 */
2321
2322 if(sk->state==TCP_ESTABLISHED)
2323 tcp_set_state(sk,TCP_FIN_WAIT1);
2324 else
2325 tcp_set_state(sk,TCP_FIN_WAIT2);
2326 reset_timer(sk, TIME_CLOSE,4*sk->rto);
2327 if(timeout)
2328 tcp_time_wait(sk);
2329
2330 release_sock(sk);
2331 return;
2332 }
2333
2334 t1 =(struct tcphdr *)((char *)t1 +tmp);
2335 buff->len += tmp;
2336 buff->dev = dev;
2337 memcpy(t1, th, sizeof(*t1));
2338 t1->seq = ntohl(sk->write_seq);
2339 sk->write_seq++;
2340 buff->h.seq = sk->write_seq;
2341 t1->ack = 1;
2342
2343 /*
2344 * Ack everything immediately from now on.
2345 */
2346
2347 sk->delay_acks = 0;
2348 t1->ack_seq = ntohl(sk->acked_seq);
2349 t1->window = ntohs(sk->window=tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
2350 t1->fin = 1;
2351 t1->rst = need_reset;
2352 t1->doff = sizeof(*t1)/4;
2353 tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
2354
2355 tcp_statistics.TcpOutSegs++;
2356
2357 if (skb_peek(&sk->write_queue) == NULL)
2358 {
2359 sk->sent_seq = sk->write_seq;
2360 prot->queue_xmit(sk, dev, buff, 0);
2361 }
2362 else
2363 {
2364 reset_timer(sk, TIME_WRITE, sk->rto);
2365 if (buff->next != NULL)
2366 {
2367 printk("tcp_close: next != NULL\n");
2368 skb_unlink(buff);
2369 }
2370 skb_queue_tail(&sk->write_queue, buff);
2371 }
2372
2373 /*
2374 * If established (normal close), enter FIN_WAIT1.
2375 * If in CLOSE_WAIT, enter LAST_ACK
2376 * If in CLOSING, remain in CLOSING
2377 * otherwise enter FIN_WAIT2
2378 */
2379
2380 if (sk->state == TCP_ESTABLISHED)
2381 tcp_set_state(sk,TCP_FIN_WAIT1);
2382 else if (sk->state == TCP_CLOSE_WAIT)
2383 tcp_set_state(sk,TCP_LAST_ACK);
2384 else if (sk->state != TCP_CLOSING)
2385 tcp_set_state(sk,TCP_FIN_WAIT2);
2386 }
2387 release_sock(sk);
2388 }
2389
2390
2391 /*
2392 * This routine takes stuff off of the write queue,
2393 * and puts it in the xmit queue.
2394 */
2395 static void
2396 tcp_write_xmit(struct sock *sk)
/* */
2397 {
2398 struct sk_buff *skb;
2399
2400 /*
2401 * The bytes will have to remain here. In time closedown will
2402 * empty the write queue and all will be happy
2403 */
2404
2405 if(sk->zapped)
2406 return;
2407
2408 while((skb = skb_peek(&sk->write_queue)) != NULL &&
2409 before(skb->h.seq, sk->window_seq + 1) &&
2410 (sk->retransmits == 0 ||
2411 sk->timeout != TIME_WRITE ||
2412 before(skb->h.seq, sk->rcv_ack_seq + 1))
2413 && sk->packets_out < sk->cong_window)
2414 {
2415 IS_SKB(skb);
2416 skb_unlink(skb);
2417 /* See if we really need to send the packet. */
2418 if (before(skb->h.seq, sk->rcv_ack_seq +1))
2419 {
2420 sk->retransmits = 0;
2421 kfree_skb(skb, FREE_WRITE);
2422 if (!sk->dead)
2423 sk->write_space(sk);
2424 }
2425 else
2426 {
2427 struct tcphdr *th;
2428 struct iphdr *iph;
2429 int size;
2430 /*
2431 * put in the ack seq and window at this point rather than earlier,
2432 * in order to keep them monotonic. We really want to avoid taking
2433 * back window allocations. That's legal, but RFC1122 says it's frowned on.
2434 * Ack and window will in general have changed since this packet was put
2435 * on the write queue.
2436 */
2437 iph = (struct iphdr *)(skb->data +
2438 skb->dev->hard_header_len);
2439 th = (struct tcphdr *)(((char *)iph) +(iph->ihl << 2));
2440 size = skb->len - (((unsigned char *) th) - skb->data);
2441
2442 th->ack_seq = ntohl(sk->acked_seq);
2443 th->window = ntohs(tcp_select_window(sk));
2444
2445 tcp_send_check(th, sk->saddr, sk->daddr, size, sk);
2446
2447 sk->sent_seq = skb->h.seq;
2448 sk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
2449 }
2450 }
2451 }
2452
2453
2454 /*
2455 * This routine sorts the send list, and resets the
2456 * sk->send_head and sk->send_tail pointers.
2457 */
2458
2459 static void sort_send(struct sock *sk)
/* */
2460 {
2461 struct sk_buff *list = NULL;
2462 struct sk_buff *skb,*skb2,*skb3;
2463
2464 for (skb = sk->send_head; skb != NULL; skb = skb2)
2465 {
2466 skb2 = skb->link3;
2467 if (list == NULL || before (skb2->h.seq, list->h.seq))
2468 {
2469 skb->link3 = list;
2470 sk->send_tail = skb;
2471 list = skb;
2472 }
2473 else
2474 {
2475 for (skb3 = list; ; skb3 = skb3->link3)
2476 {
2477 if (skb3->link3 == NULL ||
2478 before(skb->h.seq, skb3->link3->h.seq))
2479 {
2480 skb->link3 = skb3->link3;
2481 skb3->link3 = skb;
2482 if (skb->link3 == NULL)
2483 sk->send_tail = skb;
2484 break;
2485 }
2486 }
2487 }
2488 }
2489 sk->send_head = list;
2490 }
2491
2492
2493 /*
2494 * This routine deals with incoming acks, but not outgoing ones.
2495 */
2496
2497 static int tcp_ack(struct sock *sk, struct tcphdr *th, unsigned long saddr, int len)
/* */
2498 {
2499 unsigned long ack;
2500 int flag = 0;
2501
2502 /*
2503 * 1 - there was data in packet as well as ack or new data is sent or
2504 * in shutdown state
2505 * 2 - data from retransmit queue was acked and removed
2506 * 4 - window shrunk or data from retransmit queue was acked and removed
2507 */
2508
2509 if(sk->zapped)
2510 return(1); /* Dead, cant ack any more so why bother */
2511
2512 ack = ntohl(th->ack_seq);
2513 if (ntohs(th->window) > sk->max_window)
2514 {
2515 sk->max_window = ntohs(th->window);
2516 #ifdef CONFIG_INET_PCTCP
2517 sk->mss = min(sk->max_window>>1, sk->mtu);
2518 #else
2519 sk->mss = min(sk->max_window, sk->mtu);
2520 #endif
2521 }
2522
2523 if (sk->retransmits && sk->timeout == TIME_KEEPOPEN)
2524 sk->retransmits = 0;
2525
2526 #if 0
2527 /*
2528 * Not quite clear why the +1 and -1 here, and why not +1 in next line
2529 */
2530
2531 if (after(ack, sk->sent_seq+1) || before(ack, sk->rcv_ack_seq-1))
2532 #else
2533 if (after(ack, sk->sent_seq) || before(ack, sk->rcv_ack_seq))
2534 #endif
2535 {
2536 if(sk->debug)
2537 printk("Ack ignored %lu %lu\n",ack,sk->sent_seq);
2538
2539 /*
2540 * Keepalive processing.
2541 */
2542
2543 if (after(ack, sk->sent_seq) || (sk->state != TCP_ESTABLISHED && sk->state != TCP_CLOSE_WAIT))
2544 {
2545 return(0);
2546 }
2547 if (sk->keepopen)
2548 {
2549 if(sk->timeout==TIME_KEEPOPEN)
2550 reset_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
2551 }
2552 return(1);
2553 }
2554
2555 if (len != th->doff*4)
2556 flag |= 1;
2557
2558 /* See if our window has been shrunk. */
2559
2560 if (after(sk->window_seq, ack+ntohs(th->window)))
2561 {
2562 /*
2563 * We may need to move packets from the send queue
2564 * to the write queue, if the window has been shrunk on us.
2565 * The RFC says you are not allowed to shrink your window
2566 * like this, but if the other end does, you must be able
2567 * to deal with it.
2568 */
2569 struct sk_buff *skb;
2570 struct sk_buff *skb2;
2571 struct sk_buff *wskb = NULL;
2572
2573 skb2 = sk->send_head;
2574 sk->send_head = NULL;
2575 sk->send_tail = NULL;
2576
2577 flag |= 4;
2578
2579 sk->window_seq = ack + ntohs(th->window);
2580 cli();
2581 while (skb2 != NULL)
2582 {
2583 skb = skb2;
2584 skb2 = skb->link3;
2585 skb->link3 = NULL;
2586 if (after(skb->h.seq, sk->window_seq))
2587 {
2588 if (sk->packets_out > 0)
2589 sk->packets_out--;
2590 /* We may need to remove this from the dev send list. */
2591 if (skb->next != NULL)
2592 {
2593 skb_unlink(skb);
2594 }
2595 /* Now add it to the write_queue. */
2596 if (wskb == NULL)
2597 skb_queue_head(&sk->write_queue,skb);
2598 else
2599 skb_append(wskb,skb);
2600 wskb = skb;
2601 }
2602 else
2603 {
2604 if (sk->send_head == NULL)
2605 {
2606 sk->send_head = skb;
2607 sk->send_tail = skb;
2608 }
2609 else
2610 {
2611 sk->send_tail->link3 = skb;
2612 sk->send_tail = skb;
2613 }
2614 skb->link3 = NULL;
2615 }
2616 }
2617 sti();
2618 }
2619
2620 if (sk->send_tail == NULL || sk->send_head == NULL)
2621 {
2622 sk->send_head = NULL;
2623 sk->send_tail = NULL;
2624 sk->packets_out= 0;
2625 }
2626
2627 sk->window_seq = ack + ntohs(th->window);
2628
2629 /* We don't want too many packets out there. */
2630 if (sk->timeout == TIME_WRITE &&
2631 sk->cong_window < 2048 && after(ack, sk->rcv_ack_seq))
2632 {
2633 /*
2634 * This is Jacobson's slow start and congestion avoidance.
2635 * SIGCOMM '88, p. 328. Because we keep cong_window in integral
2636 * mss's, we can't do cwnd += 1 / cwnd. Instead, maintain a
2637 * counter and increment it once every cwnd times. It's possible
2638 * that this should be done only if sk->retransmits == 0. I'm
2639 * interpreting "new data is acked" as including data that has
2640 * been retransmitted but is just now being acked.
2641 */
2642 if (sk->cong_window < sk->ssthresh)
2643 /*
2644 * In "safe" area, increase
2645 */
2646 sk->cong_window++;
2647 else
2648 {
2649 /*
2650 * In dangerous area, increase slowly. In theory this is
2651 * sk->cong_window += 1 / sk->cong_window
2652 */
2653 if (sk->cong_count >= sk->cong_window)
2654 {
2655 sk->cong_window++;
2656 sk->cong_count = 0;
2657 }
2658 else
2659 sk->cong_count++;
2660 }
2661 }
2662
2663 sk->rcv_ack_seq = ack;
2664
2665 /*
2666 * if this ack opens up a zero window, clear backoff. It was
2667 * being used to time the probes, and is probably far higher than
2668 * it needs to be for normal retransmission.
2669 */
2670
2671 if (sk->timeout == TIME_PROBE0)
2672 {
2673 if (skb_peek(&sk->write_queue) != NULL && /* should always be non-null */
2674 ! before (sk->window_seq, sk->write_queue.next->h.seq))
2675 {
2676 sk->retransmits = 0;
2677 sk->backoff = 0;
2678 /*
2679 * Recompute rto from rtt. this eliminates any backoff.
2680 */
2681
2682 sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
2683 if (sk->rto > 120*HZ)
2684 sk->rto = 120*HZ;
2685 if (sk->rto < 20) /* Was 1*HZ, then 1 - turns out we must allow about
2686 .2 of a second because of BSD delayed acks - on a 100Mb/sec link
2687 .2 of a second is going to need huge windows (SIGH) */
2688 sk->rto = 20;
2689 }
2690 }
2691
2692 /*
2693 * See if we can take anything off of the retransmit queue.
2694 */
2695
2696 while(sk->send_head != NULL)
2697 {
2698 /* Check for a bug. */
2699 if (sk->send_head->link3 &&
2700 after(sk->send_head->h.seq, sk->send_head->link3->h.seq))
2701 {
2702 printk("INET: tcp.c: *** bug send_list out of order.\n");
2703 sort_send(sk);
2704 }
2705
2706 if (before(sk->send_head->h.seq, ack+1))
2707 {
2708 struct sk_buff *oskb;
2709 if (sk->retransmits)
2710 {
2711 /*
2712 * We were retransmitting. don't count this in RTT est
2713 */
2714 flag |= 2;
2715
2716 /*
2717 * even though we've gotten an ack, we're still
2718 * retransmitting as long as we're sending from
2719 * the retransmit queue. Keeping retransmits non-zero
2720 * prevents us from getting new data interspersed with
2721 * retransmissions.
2722 */
2723
2724 if (sk->send_head->link3)
2725 sk->retransmits = 1;
2726 else
2727 sk->retransmits = 0;
2728 }
2729 /*
2730 * Note that we only reset backoff and rto in the
2731 * rtt recomputation code. And that doesn't happen
2732 * if there were retransmissions in effect. So the
2733 * first new packet after the retransmissions is
2734 * sent with the backoff still in effect. Not until
2735 * we get an ack from a non-retransmitted packet do
2736 * we reset the backoff and rto. This allows us to deal
2737 * with a situation where the network delay has increased
2738 * suddenly. I.e. Karn's algorithm. (SIGCOMM '87, p5.)
2739 */
2740
2741 /*
2742 * We have one less packet out there.
2743 */
2744
2745 if (sk->packets_out > 0)
2746 sk->packets_out --;
2747 /*
2748 * Wake up the process, it can probably write more.
2749 */
2750 if (!sk->dead)
2751 sk->write_space(sk);
2752 oskb = sk->send_head;
2753
2754 if (!(flag&2))
2755 {
2756 long m;
2757
2758 /*
2759 * The following amusing code comes from Jacobson's
2760 * article in SIGCOMM '88. Note that rtt and mdev
2761 * are scaled versions of rtt and mean deviation.
2762 * This is designed to be as fast as possible
2763 * m stands for "measurement".
2764 */
2765
2766 m = jiffies - oskb->when; /* RTT */
2767 if(m<=0)
2768 m=1; /* IS THIS RIGHT FOR <0 ??? */
2769 m -= (sk->rtt >> 3); /* m is now error in rtt est */
2770 sk->rtt += m; /* rtt = 7/8 rtt + 1/8 new */
2771 if (m < 0)
2772 m = -m; /* m is now abs(error) */
2773 m -= (sk->mdev >> 2); /* similar update on mdev */
2774 sk->mdev += m; /* mdev = 3/4 mdev + 1/4 new */
2775
2776 /*
2777 * Now update timeout. Note that this removes any backoff.
2778 */
2779
2780 sk->rto = ((sk->rtt >> 2) + sk->mdev) >> 1;
2781 if (sk->rto > 120*HZ)
2782 sk->rto = 120*HZ;
2783 if (sk->rto < 20) /* Was 1*HZ - keep .2 as minimum cos of the BSD delayed acks */
2784 sk->rto = 20;
2785 sk->backoff = 0;
2786 }
2787 flag |= (2|4);
2788 cli();
2789 oskb = sk->send_head;
2790 IS_SKB(oskb);
2791 sk->send_head = oskb->link3;
2792 if (sk->send_head == NULL)
2793 {
2794 sk->send_tail = NULL;
2795 }
2796
2797 /*
2798 * We may need to remove this from the dev send list.
2799 */
2800
2801 if (oskb->next)
2802 skb_unlink(oskb);
2803 sti();
2804 kfree_skb(oskb, FREE_WRITE); /* write. */
2805 if (!sk->dead)
2806 sk->write_space(sk);
2807 }
2808 else
2809 {
2810 break;
2811 }
2812 }
2813
2814 /*
2815 * XXX someone ought to look at this too.. at the moment, if skb_peek()
2816 * returns non-NULL, we complete ignore the timer stuff in the else
2817 * clause. We ought to organize the code so that else clause can
2818 * (should) be executed regardless, possibly moving the PROBE timer
2819 * reset over. The skb_peek() thing should only move stuff to the
2820 * write queue, NOT also manage the timer functions.
2821 */
2822
2823 /*
2824 * Maybe we can take some stuff off of the write queue,
2825 * and put it onto the xmit queue.
2826 */
2827 if (skb_peek(&sk->write_queue) != NULL)
2828 {
2829 if (after (sk->window_seq+1, sk->write_queue.next->h.seq) &&
2830 (sk->retransmits == 0 ||
2831 sk->timeout != TIME_WRITE ||
2832 before(sk->write_queue.next->h.seq, sk->rcv_ack_seq + 1))
2833 && sk->packets_out < sk->cong_window)
2834 {
2835 flag |= 1;
2836 tcp_write_xmit(sk);
2837 }
2838 else if (before(sk->window_seq, sk->write_queue.next->h.seq) &&
2839 sk->send_head == NULL &&
2840 sk->ack_backlog == 0 &&
2841 sk->state != TCP_TIME_WAIT)
2842 {
2843 reset_timer(sk, TIME_PROBE0, sk->rto);
2844 }
2845 }
2846 else
2847 {
2848 /*
2849 * from TIME_WAIT we stay in TIME_WAIT as long as we rx packets
2850 * from TCP_CLOSE we don't do anything
2851 *
2852 * from anything else, if there is write data (or fin) pending,
2853 * we use a TIME_WRITE timeout, else if keepalive we reset to
2854 * a KEEPALIVE timeout, else we delete the timer.
2855 *
2856 * We do not set flag for nominal write data, otherwise we may
2857 * force a state where we start to write itsy bitsy tidbits
2858 * of data.
2859 */
2860
2861 switch(sk->state) {
2862 case TCP_TIME_WAIT:
2863 /*
2864 * keep us in TIME_WAIT until we stop getting packets,
2865 * reset the timeout.
2866 */
2867 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
2868 break;
2869 case TCP_CLOSE:
2870 /*
2871 * don't touch the timer.
2872 */
2873 break;
2874 default:
2875 /*
2876 * must check send_head, write_queue, and ack_backlog
2877 * to determine which timeout to use.
2878 */
2879 if (sk->send_head || skb_peek(&sk->write_queue) != NULL || sk->ack_backlog) {
2880 reset_timer(sk, TIME_WRITE, sk->rto);
2881 } else if (sk->keepopen) {
2882 reset_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
2883 } else {
2884 delete_timer(sk);
2885 }
2886 break;
2887 }
2888 #ifdef NOTDEF
2889 if (sk->send_head == NULL && sk->ack_backlog == 0 &&
2890 sk->state != TCP_TIME_WAIT && !sk->keepopen)
2891 {
2892 if (!sk->dead)
2893 sk->write_space(sk);
2894 if (sk->keepopen) {
2895 reset_timer(sk, TIME_KEEPOPEN, TCP_TIMEOUT_LEN);
2896 } else {
2897 delete_timer(sk);
2898 }
2899 }
2900 else
2901 {
2902 if (sk->state != (unsigned char) sk->keepopen)
2903 {
2904 reset_timer(sk, TIME_WRITE, sk->rto);
2905 }
2906 if (sk->state == TCP_TIME_WAIT)
2907 {
2908 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
2909 }
2910 }
2911 #endif
2912 }
2913
2914 if (sk->packets_out == 0 && sk->partial != NULL &&
2915 skb_peek(&sk->write_queue) == NULL && sk->send_head == NULL)
2916 {
2917 flag |= 1;
2918 tcp_send_partial(sk);
2919 }
2920
2921 /*
2922 * In the LAST_ACK case, the other end FIN'd us. We then FIN'd them, and
2923 * we are now waiting for an acknowledge to our FIN. The other end is
2924 * already in TIME_WAIT.
2925 *
2926 * Move to TCP_CLOSE on success.
2927 */
2928
2929 if (sk->state == TCP_LAST_ACK)
2930 {
2931 if (!sk->dead)
2932 sk->state_change(sk);
2933 if (sk->rcv_ack_seq == sk->write_seq && sk->acked_seq == sk->fin_seq)
2934 {
2935 flag |= 1;
2936 tcp_set_state(sk,TCP_CLOSE);
2937 sk->shutdown = SHUTDOWN_MASK;
2938 }
2939 }
2940
2941 /*
2942 * Incoming ACK to a FIN we sent in the case of our initiating the close.
2943 *
2944 * Move to FIN_WAIT2 to await a FIN from the other end.
2945 */
2946
2947 if (sk->state == TCP_FIN_WAIT1)
2948 {
2949
2950 if (!sk->dead)
2951 sk->state_change(sk);
2952 if (sk->rcv_ack_seq == sk->write_seq)
2953 {
2954 flag |= 1;
2955 if (sk->acked_seq != sk->fin_seq)
2956 {
2957 tcp_time_wait(sk);
2958 }
2959 else
2960 {
2961 sk->shutdown = SHUTDOWN_MASK;
2962 tcp_set_state(sk,TCP_FIN_WAIT2);
2963 }
2964 }
2965 }
2966
2967 /*
2968 * Incoming ACK to a FIN we sent in the case of a simultaneous close.
2969 *
2970 * Move to TIME_WAIT
2971 */
2972
2973 if (sk->state == TCP_CLOSING)
2974 {
2975
2976 if (!sk->dead)
2977 sk->state_change(sk);
2978 if (sk->rcv_ack_seq == sk->write_seq)
2979 {
2980 flag |= 1;
2981 tcp_time_wait(sk);
2982 }
2983 }
2984
2985 /*
2986 * I make no guarantees about the first clause in the following
2987 * test, i.e. "(!flag) || (flag&4)". I'm not entirely sure under
2988 * what conditions "!flag" would be true. However I think the rest
2989 * of the conditions would prevent that from causing any
2990 * unnecessary retransmission.
2991 * Clearly if the first packet has expired it should be
2992 * retransmitted. The other alternative, "flag&2 && retransmits", is
2993 * harder to explain: You have to look carefully at how and when the
2994 * timer is set and with what timeout. The most recent transmission always
2995 * sets the timer. So in general if the most recent thing has timed
2996 * out, everything before it has as well. So we want to go ahead and
2997 * retransmit some more. If we didn't explicitly test for this
2998 * condition with "flag&2 && retransmits", chances are "when + rto < jiffies"
2999 * would not be true. If you look at the pattern of timing, you can
3000 * show that rto is increased fast enough that the next packet would
3001 * almost never be retransmitted immediately. Then you'd end up
3002 * waiting for a timeout to send each packet on the retransmission
3003 * queue. With my implementation of the Karn sampling algorithm,
3004 * the timeout would double each time. The net result is that it would
3005 * take a hideous amount of time to recover from a single dropped packet.
3006 * It's possible that there should also be a test for TIME_WRITE, but
3007 * I think as long as "send_head != NULL" and "retransmit" is on, we've
3008 * got to be in real retransmission mode.
3009 * Note that ip_do_retransmit is called with all==1. Setting cong_window
3010 * back to 1 at the timeout will cause us to send 1, then 2, etc. packets.
3011 * As long as no further losses occur, this seems reasonable.
3012 */
3013
3014 if (((!flag) || (flag&4)) && sk->send_head != NULL &&
3015 (((flag&2) && sk->retransmits) ||
3016 (sk->send_head->when + sk->rto < jiffies)))
3017 {
3018 ip_do_retransmit(sk, 1);
3019 reset_timer(sk, TIME_WRITE, sk->rto);
3020 }
3021
3022 return(1);
3023 }
3024
3025
3026 /*
3027 * This routine handles the data. If there is room in the buffer,
3028 * it will be have already been moved into it. If there is no
3029 * room, then we will just have to discard the packet.
3030 */
3031
3032 static int tcp_data(struct sk_buff *skb, struct sock *sk,
/* */
3033 unsigned long saddr, unsigned short len)
3034 {
3035 struct sk_buff *skb1, *skb2;
3036 struct tcphdr *th;
3037 int dup_dumped=0;
3038 unsigned long new_seq;
3039
3040 th = skb->h.th;
3041 skb->len = len -(th->doff*4);
3042
3043 /* The bytes in the receive read/assembly queue has increased. Needed for the
3044 low memory discard algorithm */
3045
3046 sk->bytes_rcv += skb->len;
3047
3048 if (skb->len == 0 && !th->fin && !th->urg && !th->psh)
3049 {
3050 /*
3051 * Don't want to keep passing ack's back and forth.
3052 * (someone sent us dataless, boring frame)
3053 */
3054 if (!th->ack)
3055 tcp_send_ack(sk->sent_seq, sk->acked_seq,sk, th, saddr);
3056 kfree_skb(skb, FREE_READ);
3057 return(0);
3058 }
3059
3060 /*
3061 * We no longer have anyone receiving data on this connection.
3062 */
3063
3064 if(sk->shutdown & RCV_SHUTDOWN)
3065 {
3066 new_seq= th->seq + skb->len + th->syn; /* Right edge of _data_ part of frame */
3067
3068 if(after(new_seq,sk->copied_seq+1)) /* If the right edge of this frame is after the last copied byte
3069 then it contains data we will never touch. We send an RST to
3070 ensure the far end knows it never got to the application */
3071 {
3072 sk->acked_seq = new_seq + th->fin;
3073 tcp_reset(sk->saddr, sk->daddr, skb->h.th,
3074 sk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
3075 tcp_statistics.TcpEstabResets++;
3076 tcp_set_state(sk,TCP_CLOSE);
3077 sk->err = EPIPE;
3078 sk->shutdown = SHUTDOWN_MASK;
3079 kfree_skb(skb, FREE_READ);
3080 if (!sk->dead)
3081 sk->state_change(sk);
3082 return(0);
3083 }
3084 #if 0
3085 /* Discard the frame here - we've already proved its a duplicate */
3086
3087 kfree_skb(skb, FREE_READ);
3088 return(0);
3089 #endif
3090 }
3091 /*
3092 * Now we have to walk the chain, and figure out where this one
3093 * goes into it. This is set up so that the last packet we received
3094 * will be the first one we look at, that way if everything comes
3095 * in order, there will be no performance loss, and if they come
3096 * out of order we will be able to fit things in nicely.
3097 */
3098
3099 /*
3100 * This should start at the last one, and then go around forwards.
3101 */
3102
3103 if (skb_peek(&sk->receive_queue) == NULL) /* Empty queue is easy case */
3104 {
3105 skb_queue_head(&sk->receive_queue,skb);
3106 skb1= NULL;
3107 }
3108 else
3109 {
3110 for(skb1=sk->receive_queue.prev; ; skb1 = skb1->prev)
3111 {
3112 if(sk->debug)
3113 {
3114 printk("skb1=%p :", skb1);
3115 printk("skb1->h.th->seq = %ld: ", skb1->h.th->seq);
3116 printk("skb->h.th->seq = %ld\n",skb->h.th->seq);
3117 printk("copied_seq = %ld acked_seq = %ld\n", sk->copied_seq,
3118 sk->acked_seq);
3119 }
3120
3121 /*
3122 * Optimisation: Duplicate frame or extension of previous frame from
3123 * same sequence point (lost ack case).
3124 * The frame contains duplicate data or replaces a previous frame
3125 * discard the previous frame (safe as sk->inuse is set) and put
3126 * the new one in its place.
3127 */
3128
3129 if (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
3130 {
3131 skb_append(skb1,skb);
3132 skb_unlink(skb1);
3133 kfree_skb(skb1,FREE_READ);
3134 dup_dumped=1;
3135 skb1=NULL;
3136 break;
3137 }
3138
3139 /*
3140 * Found where it fits
3141 */
3142
3143 if (after(th->seq+1, skb1->h.th->seq))
3144 {
3145 skb_append(skb1,skb);
3146 break;
3147 }
3148
3149 /*
3150 * See if we've hit the start. If so insert.
3151 */
3152 if (skb1 == skb_peek(&sk->receive_queue))
3153 {
3154 skb_queue_head(&sk->receive_queue, skb);
3155 break;
3156 }
3157 }
3158 }
3159
3160 /*
3161 * Figure out what the ack value for this frame is
3162 */
3163
3164 th->ack_seq = th->seq + skb->len;
3165 if (th->syn)
3166 th->ack_seq++;
3167 if (th->fin)
3168 th->ack_seq++;
3169
3170 if (before(sk->acked_seq, sk->copied_seq))
3171 {
3172 printk("*** tcp.c:tcp_data bug acked < copied\n");
3173 sk->acked_seq = sk->copied_seq;
3174 }
3175
3176 /*
3177 * Now figure out if we can ack anything.
3178 */
3179
3180 if ((!dup_dumped && (skb1 == NULL || skb1->acked)) || before(th->seq, sk->acked_seq+1))
3181 {
3182 if (before(th->seq, sk->acked_seq+1))
3183 {
3184 int newwindow;
3185
3186 if (after(th->ack_seq, sk->acked_seq))
3187 {
3188 newwindow = sk->window-(th->ack_seq - sk->acked_seq);
3189 if (newwindow < 0)
3190 newwindow = 0;
3191 sk->window = newwindow;
3192 sk->acked_seq = th->ack_seq;
3193 }
3194 skb->acked = 1;
3195
3196 /*
3197 * When we ack the fin, we turn on the RCV_SHUTDOWN flag.
3198 */
3199
3200 if (skb->h.th->fin)
3201 {
3202 if (!sk->dead)
3203 sk->state_change(sk);
3204 sk->shutdown |= RCV_SHUTDOWN;
3205 }
3206
3207 for(skb2 = skb->next;
3208 skb2 != (struct sk_buff *)&sk->receive_queue;
3209 skb2 = skb2->next)
3210 {
3211 if (before(skb2->h.th->seq, sk->acked_seq+1))
3212 {
3213 if (after(skb2->h.th->ack_seq, sk->acked_seq))
3214 {
3215 newwindow = sk->window -
3216 (skb2->h.th->ack_seq - sk->acked_seq);
3217 if (newwindow < 0)
3218 newwindow = 0;
3219 sk->window = newwindow;
3220 sk->acked_seq = skb2->h.th->ack_seq;
3221 }
3222 skb2->acked = 1;
3223 /*
3224 * When we ack the fin, we turn on
3225 * the RCV_SHUTDOWN flag.
3226 */
3227 if (skb2->h.th->fin)
3228 {
3229 sk->shutdown |= RCV_SHUTDOWN;
3230 if (!sk->dead)
3231 sk->state_change(sk);
3232 }
3233
3234 /*
3235 * Force an immediate ack.
3236 */
3237
3238 sk->ack_backlog = sk->max_ack_backlog;
3239 }
3240 else
3241 {
3242 break;
3243 }
3244 }
3245
3246 /*
3247 * This also takes care of updating the window.
3248 * This if statement needs to be simplified.
3249 */
3250 if (!sk->delay_acks ||
3251 sk->ack_backlog >= sk->max_ack_backlog ||
3252 sk->bytes_rcv > sk->max_unacked || th->fin) {
3253 /* tcp_send_ack(sk->sent_seq, sk->acked_seq,sk,th, saddr); */
3254 }
3255 else
3256 {
3257 sk->ack_backlog++;
3258 if(sk->debug)
3259 printk("Ack queued.\n");
3260 reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
3261 }
3262 }
3263 }
3264
3265 /*
3266 * If we've missed a packet, send an ack.
3267 * Also start a timer to send another.
3268 */
3269
3270 if (!skb->acked)
3271 {
3272
3273 /*
3274 * This is important. If we don't have much room left,
3275 * we need to throw out a few packets so we have a good
3276 * window. Note that mtu is used, not mss, because mss is really
3277 * for the send side. He could be sending us stuff as large as mtu.
3278 */
3279
3280 while (sk->prot->rspace(sk) < sk->mtu)
3281 {
3282 skb1 = skb_peek(&sk->receive_queue);
3283 if (skb1 == NULL)
3284 {
3285 printk("INET: tcp.c:tcp_data memory leak detected.\n");
3286 break;
3287 }
3288
3289 /*
3290 * Don't throw out something that has been acked.
3291 */
3292
3293 if (skb1->acked)
3294 {
3295 break;
3296 }
3297
3298 skb_unlink(skb1);
3299 kfree_skb(skb1, FREE_READ);
3300 }
3301 tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
3302 sk->ack_backlog++;
3303 reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
3304 }
3305 else
3306 {
3307 /* We missed a packet. Send an ack to try to resync things. */
3308 tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
3309 }
3310
3311 /*
3312 * Now tell the user we may have some data.
3313 */
3314
3315 if (!sk->dead)
3316 {
3317 if(sk->debug)
3318 printk("Data wakeup.\n");
3319 sk->data_ready(sk,0);
3320 }
3321 return(0);
3322 }
3323
3324
3325 static void tcp_check_urg(struct sock * sk, struct tcphdr * th)
/* */
3326 {
3327 unsigned long ptr = ntohs(th->urg_ptr);
3328
3329 if (ptr)
3330 ptr--;
3331 ptr += th->seq;
3332
3333 /* ignore urgent data that we've already seen and read */
3334 if (after(sk->copied_seq+1, ptr))
3335 return;
3336
3337 /* do we already have a newer (or duplicate) urgent pointer? */
3338 if (sk->urg_data && !after(ptr, sk->urg_seq))
3339 return;
3340
3341 /* tell the world about our new urgent pointer */
3342 if (sk->proc != 0) {
3343 if (sk->proc > 0) {
3344 kill_proc(sk->proc, SIGURG, 1);
3345 } else {
3346 kill_pg(-sk->proc, SIGURG, 1);
3347 }
3348 }
3349 sk->urg_data = URG_NOTYET;
3350 sk->urg_seq = ptr;
3351 }
3352
3353 static inline int tcp_urg(struct sock *sk, struct tcphdr *th,
/* */
3354 unsigned long saddr, unsigned long len)
3355 {
3356 unsigned long ptr;
3357
3358 /* check if we get a new urgent pointer */
3359 if (th->urg)
3360 tcp_check_urg(sk,th);
3361
3362 /* do we wait for any urgent data? */
3363 if (sk->urg_data != URG_NOTYET)
3364 return 0;
3365
3366 /* is the urgent pointer pointing into this packet? */
3367 ptr = sk->urg_seq - th->seq + th->doff*4;
3368 if (ptr >= len)
3369 return 0;
3370
3371 /* ok, got the correct packet, update info */
3372 sk->urg_data = URG_VALID | *(ptr + (unsigned char *) th);
3373 if (!sk->dead)
3374 sk->data_ready(sk,0);
3375 return 0;
3376 }
3377
3378
3379 /*
3380 * This deals with incoming fins. 'Linus at 9 O'clock' 8-)
3381 *
3382 * If we are ESTABLISHED, a received fin moves us to CLOSE-WAIT
3383 * (and thence onto LAST-ACK and finally, CLOSE, we never enter
3384 * TIME-WAIT)
3385 *
3386 * If we are in FINWAIT-1, a received FIN indicates simultaneous
3387 * close and we go into CLOSING (and later onto TIME-WAIT)
3388 *
3389 * If we are in FINWAIT-2, a received FIN moves us to TIME-WAIT.
3390 *
3391 */
3392 static int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th,
/* */
3393 unsigned long saddr, struct device *dev)
3394 {
3395 sk->fin_seq = th->seq + skb->len + th->syn + th->fin;
3396
3397 if (!sk->dead)
3398 {
3399 sk->state_change(sk);
3400 }
3401
3402 switch(sk->state)
3403 {
3404 case TCP_SYN_RECV:
3405 case TCP_SYN_SENT:
3406 case TCP_ESTABLISHED:
3407 /*
3408 * move to CLOSE_WAIT, tcp_data() already handled
3409 * sending the ack.
3410 */
3411 reset_timer(sk, TIME_CLOSE, TCP_TIMEOUT_LEN);
3412 /*sk->fin_seq = th->seq+1;*/
3413 tcp_set_state(sk,TCP_CLOSE_WAIT);
3414 if (th->rst)
3415 sk->shutdown = SHUTDOWN_MASK;
3416 break;
3417
3418 case TCP_CLOSE_WAIT:
3419 case TCP_CLOSING:
3420 /*
3421 * received a retransmission of the FIN, do
3422 * nothing.
3423 */
3424 break;
3425 case TCP_TIME_WAIT:
3426 /*
3427 * received a retransmission of the FIN,
3428 * restart the TIME_WAIT timer.
3429 */
3430 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
3431 return(0);
3432 case TCP_FIN_WAIT1:
3433 /*
3434 * This case occurs when a simultaneous close
3435 * happens, we must ack the received FIN and
3436 * enter the CLOSING state.
3437 *
3438 * XXX timeout not set properly
3439 */
3440
3441 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
3442 /*sk->fin_seq = th->seq+1;*/
3443 tcp_set_state(sk,TCP_CLOSING);
3444 break;
3445 case TCP_FIN_WAIT2:
3446 /*
3447 * received a FIN -- send ACK and enter TIME_WAIT
3448 */
3449 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
3450 /*sk->fin_seq = th->seq+1;*/
3451 tcp_set_state(sk,TCP_TIME_WAIT);
3452 break;
3453 case TCP_CLOSE:
3454 /*
3455 * already in CLOSE
3456 */
3457 break;
3458 default:
3459 tcp_set_state(sk,TCP_LAST_ACK);
3460
3461 /* Start the timers. */
3462 reset_timer(sk, TIME_CLOSE, TCP_TIMEWAIT_LEN);
3463 return(0);
3464 }
3465 sk->ack_backlog++;
3466
3467 return(0);
3468 }
3469
3470
3471 /* This will accept the next outstanding connection. */
3472 static struct sock *
3473 tcp_accept(struct sock *sk, int flags)
/* */
3474 {
3475 struct sock *newsk;
3476 struct sk_buff *skb;
3477
3478 /*
3479 * We need to make sure that this socket is listening,
3480 * and that it has something pending.
3481 */
3482
3483 if (sk->state != TCP_LISTEN)
3484 {
3485 sk->err = EINVAL;
3486 return(NULL);
3487 }
3488
3489 /* Avoid the race. */
3490 cli();
3491 sk->inuse = 1;
3492
3493 while((skb = skb_dequeue(&sk->receive_queue)) == NULL)
3494 {
3495 if (flags & O_NONBLOCK)
3496 {
3497 sti();
3498 release_sock(sk);
3499 sk->err = EAGAIN;
3500 return(NULL);
3501 }
3502
3503 release_sock(sk);
3504 interruptible_sleep_on(sk->sleep);
3505 if (current->signal & ~current->blocked)
3506 {
3507 sti();
3508 sk->err = ERESTARTSYS;
3509 return(NULL);
3510 }
3511 sk->inuse = 1;
3512 }
3513 sti();
3514
3515 /*
3516 * Now all we need to do is return skb->sk.
3517 */
3518
3519 newsk = skb->sk;
3520
3521 kfree_skb(skb, FREE_READ);
3522 sk->ack_backlog--;
3523 release_sock(sk);
3524 return(newsk);
3525 }
3526
3527
3528 /*
3529 * This will initiate an outgoing connection.
3530 */
3531
3532 static int tcp_connect(struct sock *sk, struct sockaddr_in *usin, int addr_len)
/* */
3533 {
3534 struct sk_buff *buff;
3535 struct device *dev=NULL;
3536 unsigned char *ptr;
3537 int tmp;
3538 struct tcphdr *t1;
3539 struct rtable *rt;
3540
3541 if (sk->state != TCP_CLOSE)
3542 return(-EISCONN);
3543
3544 if (addr_len < 8)
3545 return(-EINVAL);
3546
3547 if (usin->sin_family && usin->sin_family != AF_INET)
3548 return(-EAFNOSUPPORT);
3549
3550 /*
3551 * connect() to INADDR_ANY means loopback (BSD'ism).
3552 */
3553
3554 if(usin->sin_addr.s_addr==INADDR_ANY)
3555 usin->sin_addr.s_addr=ip_my_addr();
3556
3557 /*
3558 * Don't want a TCP connection going to a broadcast address
3559 */
3560
3561 if (ip_chk_addr(usin->sin_addr.s_addr) == IS_BROADCAST)
3562 {
3563 return -ENETUNREACH;
3564 }
3565
3566 /*
3567 * Connect back to the same socket: Blows up so disallow it
3568 */
3569
3570 if(sk->saddr == usin->sin_addr.s_addr && sk->num==ntohs(usin->sin_port))
3571 return -EBUSY;
3572
3573 sk->inuse = 1;
3574 sk->daddr = usin->sin_addr.s_addr;
3575 sk->write_seq = jiffies * SEQ_TICK - seq_offset;
3576 sk->window_seq = sk->write_seq;
3577 sk->rcv_ack_seq = sk->write_seq -1;
3578 sk->err = 0;
3579 sk->dummy_th.dest = usin->sin_port;
3580 release_sock(sk);
3581
3582 buff = sk->prot->wmalloc(sk,MAX_SYN_SIZE,0, GFP_KERNEL);
3583 if (buff == NULL)
3584 {
3585 return(-ENOMEM);
3586 }
3587 sk->inuse = 1;
3588 buff->len = 24;
3589 buff->sk = sk;
3590 buff->free = 1;
3591 buff->localroute = sk->localroute;
3592
3593 t1 = (struct tcphdr *) buff->data;
3594
3595 /*
3596 * Put in the IP header and routing stuff.
3597 */
3598
3599 rt=ip_rt_route(sk->daddr, NULL, NULL);
3600
3601
3602 /*
3603 * We need to build the routing stuff from the things saved in skb.
3604 */
3605
3606 tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
3607 IPPROTO_TCP, NULL, MAX_SYN_SIZE,sk->ip_tos,sk->ip_ttl);
3608 if (tmp < 0)
3609 {
3610 sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
3611 release_sock(sk);
3612 return(-ENETUNREACH);
3613 }
3614
3615 buff->len += tmp;
3616 t1 = (struct tcphdr *)((char *)t1 +tmp);
3617
3618 memcpy(t1,(void *)&(sk->dummy_th), sizeof(*t1));
3619 t1->seq = ntohl(sk->write_seq++);
3620 sk->sent_seq = sk->write_seq;
3621 buff->h.seq = sk->write_seq;
3622 t1->ack = 0;
3623 t1->window = 2;
3624 t1->res1=0;
3625 t1->res2=0;
3626 t1->rst = 0;
3627 t1->urg = 0;
3628 t1->psh = 0;
3629 t1->syn = 1;
3630 t1->urg_ptr = 0;
3631 t1->doff = 6;
3632 /* use 512 or whatever user asked for */
3633
3634 if(rt!=NULL && (rt->rt_flags&RTF_WINDOW))
3635 sk->window_clamp=rt->rt_window;
3636 else
3637 sk->window_clamp=0;
3638
3639 if (sk->user_mss)
3640 sk->mtu = sk->user_mss;
3641 else if(rt!=NULL && (rt->rt_flags&RTF_MTU))
3642 sk->mtu = rt->rt_mss;
3643 else
3644 {
3645 #ifdef CONFIG_INET_SNARL
3646 if ((sk->saddr ^ sk->daddr) & default_mask(sk->saddr))
3647 #else
3648 if ((sk->saddr ^ sk->daddr) & dev->pa_mask)
3649 #endif
3650 sk->mtu = 576 - HEADER_SIZE;
3651 else
3652 sk->mtu = MAX_WINDOW;
3653 }
3654 /*
3655 * but not bigger than device MTU
3656 */
3657
3658 if(sk->mtu <32)
3659 sk->mtu = 32; /* Sanity limit */
3660
3661 sk->mtu = min(sk->mtu, dev->mtu - HEADER_SIZE);
3662
3663 /*
3664 * Put in the TCP options to say MTU.
3665 */
3666
3667 ptr = (unsigned char *)(t1+1);
3668 ptr[0] = 2;
3669 ptr[1] = 4;
3670 ptr[2] = (sk->mtu) >> 8;
3671 ptr[3] = (sk->mtu) & 0xff;
3672 tcp_send_check(t1, sk->saddr, sk->daddr,
3673 sizeof(struct tcphdr) + 4, sk);
3674
3675 /*
3676 * This must go first otherwise a really quick response will get reset.
3677 */
3678
3679 tcp_set_state(sk,TCP_SYN_SENT);
3680 /* sk->rtt = TCP_CONNECT_TIME;*/
3681 sk->rto = TCP_TIMEOUT_INIT;
3682 reset_timer(sk, TIME_WRITE, sk->rto); /* Timer for repeating the SYN until an answer */
3683 sk->retransmits = TCP_RETR2 - TCP_SYN_RETRIES;
3684
3685 sk->prot->queue_xmit(sk, dev, buff, 0);
3686 tcp_statistics.TcpActiveOpens++;
3687 tcp_statistics.TcpOutSegs++;
3688
3689 release_sock(sk);
3690 return(0);
3691 }
3692
3693
3694 /* This functions checks to see if the tcp header is actually acceptable. */
3695 static int
3696 tcp_sequence(struct sock *sk, struct tcphdr *th, short len,
/* */
3697 struct options *opt, unsigned long saddr, struct device *dev)
3698 {
3699 unsigned long next_seq;
3700
3701 next_seq = len - 4*th->doff;
3702 if (th->fin)
3703 next_seq++;
3704 /* if we have a zero window, we can't have any data in the packet.. */
3705 if (next_seq && !sk->window)
3706 goto ignore_it;
3707 next_seq += th->seq;
3708
3709 /*
3710 * This isn't quite right. sk->acked_seq could be more recent
3711 * than sk->window. This is however close enough. We will accept
3712 * slightly more packets than we should, but it should not cause
3713 * problems unless someone is trying to forge packets.
3714 */
3715
3716 /* have we already seen all of this packet? */
3717 if (!after(next_seq+1, sk->acked_seq))
3718 goto ignore_it;
3719 /* or does it start beyond the window? */
3720 if (!before(th->seq, sk->acked_seq + sk->window + 1))
3721 goto ignore_it;
3722
3723 /* ok, at least part of this packet would seem interesting.. */
3724 return 1;
3725
3726 ignore_it:
3727 if (th->rst)
3728 return 0;
3729
3730 /*
3731 * Send a reset if we get something not ours and we are
3732 * unsynchronized. Note: We don't do anything to our end. We
3733 * are just killing the bogus remote connection then we will
3734 * connect again and it will work (with luck).
3735 */
3736
3737 if (sk->state==TCP_SYN_SENT || sk->state==TCP_SYN_RECV) {
3738 tcp_reset(sk->saddr,sk->daddr,th,sk->prot,NULL,dev, sk->ip_tos,sk->ip_ttl);
3739 return 1;
3740 }
3741
3742 /* Try to resync things. */
3743 tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th, saddr);
3744 return 0;
3745 }
3746
3747
3748 #ifdef TCP_FASTPATH
3749 /*
3750 * Is the end of the queue clear of fragments as yet unmerged into the data stream
3751 * Yes if
3752 * a) The queue is empty
3753 * b) The last frame on the queue has the acked flag set
3754 */
3755
3756 static inline int tcp_clean_end(struct sock *sk)
/* */
3757 {
3758 struct sk_buff *skb=skb_peek(&sk->receive_queue);
3759 if(skb==NULL || sk->receive_queue.prev->acked)
3760 return 1;
3761 }
3762
3763 #endif
3764
3765 int
3766 tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
/* */
3767 unsigned long daddr, unsigned short len,
3768 unsigned long saddr, int redo, struct inet_protocol * protocol)
3769 {
3770 struct tcphdr *th;
3771 struct sock *sk;
3772
3773 if (!skb)
3774 {
3775 return(0);
3776 }
3777
3778 if (!dev)
3779 {
3780 return(0);
3781 }
3782
3783 tcp_statistics.TcpInSegs++;
3784
3785 if(skb->pkt_type!=PACKET_HOST)
3786 {
3787 kfree_skb(skb,FREE_READ);
3788 return(0);
3789 }
3790
3791 th = skb->h.th;
3792
3793 /*
3794 * Find the socket.
3795 */
3796
3797 sk = get_sock(&tcp_prot, th->dest, saddr, th->source, daddr);
3798
3799 /*
3800 * If this socket has got a reset its to all intents and purposes
3801 * really dead
3802 */
3803
3804 if (sk!=NULL && sk->zapped)
3805 sk=NULL;
3806
3807 if (!redo)
3808 {
3809 if (tcp_check(th, len, saddr, daddr ))
3810 {
3811 skb->sk = NULL;
3812 kfree_skb(skb,FREE_READ);
3813 /*
3814 * We don't release the socket because it was
3815 * never marked in use.
3816 */
3817 return(0);
3818 }
3819 th->seq = ntohl(th->seq);
3820
3821 /* See if we know about the socket. */
3822 if (sk == NULL)
3823 {
3824 if (!th->rst)
3825 tcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
3826 skb->sk = NULL;
3827 kfree_skb(skb, FREE_READ);
3828 return(0);
3829 }
3830
3831 skb->len = len;
3832 skb->sk = sk;
3833 skb->acked = 0;
3834 skb->used = 0;
3835 skb->free = 0;
3836 skb->saddr = daddr;
3837 skb->daddr = saddr;
3838
3839 /* We may need to add it to the backlog here. */
3840 cli();
3841 if (sk->inuse)
3842 {
3843 skb_queue_head(&sk->back_log, skb);
3844 sti();
3845 return(0);
3846 }
3847 sk->inuse = 1;
3848 sti();
3849 }
3850 else
3851 {
3852 if (!sk)
3853 {
3854 return(0);
3855 }
3856 }
3857
3858
3859 if (!sk->prot)
3860 {
3861 return(0);
3862 }
3863
3864
3865 /*
3866 * Charge the memory to the socket.
3867 */
3868
3869 if (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
3870 {
3871 skb->sk = NULL;
3872 kfree_skb(skb, FREE_READ);
3873 release_sock(sk);
3874 return(0);
3875 }
3876
3877 sk->rmem_alloc += skb->mem_len;
3878
3879 #ifdef TCP_FASTPATH
3880 /*
3881 * Incoming data stream fastpath.
3882 *
3883 * We try to optimise two things.
3884 * 1) Spot general data arriving without funny options and skip extra checks and the switch.
3885 * 2) Spot the common case in raw data receive streams of a packet that has no funny options,
3886 * fits exactly on the end of the current queue and may or may not have the ack bit set.
3887 *
3888 * Case two especially is done inline in this routine so there are no long jumps causing heavy
3889 * cache thrashing, no function call overhead (except for the ack sending if needed) and for
3890 * speed although further optimizing here is possible.
3891 */
3892
3893 /* I'm trusting gcc to optimise this sensibly... might need judicious application of a software mallet */
3894 if(!(sk->shutdown & RCV_SHUTDOWN) && sk->state==TCP_ESTABLISHED && !th->urg && !th->syn && !th->fin && !th->rst)
3895 {
3896 /* Packets in order. Fits window */
3897 if(th->seq == sk->acked_seq+1 && sk->window && tcp_clean_end(sk))
3898 {
3899 /* Ack is harder */
3900 if(th->ack && !tcp_ack(sk, th, saddr, len))
3901 {
3902 kfree_skb(skb, FREE_READ);
3903 release_sock(sk);
3904 return 0;
3905 }
3906 /*
3907 * Set up variables
3908 */
3909 skb->len -= (th->doff *4);
3910 sk->bytes_rcv += skb->len;
3911 tcp_rx_hit2++;
3912 if(skb->len)
3913 {
3914 skb_queue_tail(&sk->receive_queue,skb); /* We already know where to put it */
3915 if(sk->window >= skb->len)
3916 sk->window-=skb->len; /* We know its effect on the window */
3917 else
3918 sk->window=0;
3919 sk->acked_seq = th->seq+skb->len; /* Easy */
3920 skb->acked=1; /* Guaranteed true */
3921 if(!sk->delay_acks || sk->ack_backlog >= sk->max_ack_backlog ||
3922 sk->bytes_rcv > sk->max_unacked)
3923 {
3924 tcp_send_ack(sk->sent_seq, sk->acked_seq, sk, th , saddr);
3925 }
3926 else
3927 {
3928 sk->ack_backlog++;
3929 reset_timer(sk, TIME_WRITE, TCP_ACK_TIME);
3930 }
3931 if(!sk->dead)
3932 sk->data_ready(sk,0);
3933 release_sock(sk);
3934 return 0;
3935 }
3936 }
3937 /*
3938 * More generic case of arriving data stream in ESTABLISHED
3939 */
3940 tcp_rx_hit1++;
3941 if(!tcp_sequence(sk, th, len, opt, saddr, dev))
3942 {
3943 kfree_skb(skb, FREE_READ);
3944 release_sock(sk);
3945 return 0;
3946 }
3947 if(th->ack && !tcp_ack(sk, th, saddr, len))
3948 {
3949 kfree_skb(skb, FREE_READ);
3950 release_sock(sk);
3951 return 0;
3952 }
3953 if(tcp_data(skb, sk, saddr, len))
3954 kfree_skb(skb, FREE_READ);
3955 release_sock(sk);
3956 return 0;
3957 }
3958 tcp_rx_miss++;
3959 #endif
3960
3961 /*
3962 * Now deal with all cases.
3963 */
3964
3965 switch(sk->state)
3966 {
3967
3968 /*
3969 * This should close the system down if it's waiting
3970 * for an ack that is never going to be sent.
3971 */
3972 case TCP_LAST_ACK:
3973 if (th->rst)
3974 {
3975 sk->zapped=1;
3976 sk->err = ECONNRESET;
3977 tcp_set_state(sk,TCP_CLOSE);
3978 sk->shutdown = SHUTDOWN_MASK;
3979 if (!sk->dead)
3980 {
3981 sk->state_change(sk);
3982 }
3983 kfree_skb(skb, FREE_READ);
3984 release_sock(sk);
3985 return(0);
3986 }
3987
3988 case TCP_ESTABLISHED:
3989 case TCP_CLOSE_WAIT:
3990 case TCP_CLOSING:
3991 case TCP_FIN_WAIT1:
3992 case TCP_FIN_WAIT2:
3993 case TCP_TIME_WAIT:
3994 if (!tcp_sequence(sk, th, len, opt, saddr,dev))
3995 {
3996 kfree_skb(skb, FREE_READ);
3997 release_sock(sk);
3998 return(0);
3999 }
4000
4001 if (th->rst)
4002 {
4003 tcp_statistics.TcpEstabResets++;
4004 sk->zapped=1;
4005 /* This means the thing should really be closed. */
4006 sk->err = ECONNRESET;
4007 if (sk->state == TCP_CLOSE_WAIT)
4008 {
4009 sk->err = EPIPE;
4010 }
4011
4012 /*
4013 * A reset with a fin just means that
4014 * the data was not all read.
4015 */
4016 tcp_set_state(sk,TCP_CLOSE);
4017 sk->shutdown = SHUTDOWN_MASK;
4018 if (!sk->dead)
4019 {
4020 sk->state_change(sk);
4021 }
4022 kfree_skb(skb, FREE_READ);
4023 release_sock(sk);
4024 return(0);
4025 }
4026 if (th->syn)
4027 {
4028 tcp_statistics.TcpEstabResets++;
4029 sk->err = ECONNRESET;
4030 tcp_set_state(sk,TCP_CLOSE);
4031 sk->shutdown = SHUTDOWN_MASK;
4032 tcp_reset(daddr, saddr, th, sk->prot, opt,dev, sk->ip_tos,sk->ip_ttl);
4033 if (!sk->dead) {
4034 sk->state_change(sk);
4035 }
4036 kfree_skb(skb, FREE_READ);
4037 release_sock(sk);
4038 return(0);
4039 }
4040
4041 if (th->ack && !tcp_ack(sk, th, saddr, len)) {
4042 kfree_skb(skb, FREE_READ);
4043 release_sock(sk);
4044 return(0);
4045 }
4046
4047 if (tcp_urg(sk, th, saddr, len)) {
4048 kfree_skb(skb, FREE_READ);
4049 release_sock(sk);
4050 return(0);
4051 }
4052
4053
4054 if (tcp_data(skb, sk, saddr, len)) {
4055 kfree_skb(skb, FREE_READ);
4056 release_sock(sk);
4057 return(0);
4058 }
4059
4060 if (th->fin && tcp_fin(skb, sk, th, saddr, dev)) {
4061 kfree_skb(skb, FREE_READ);
4062 release_sock(sk);
4063 return(0);
4064 }
4065
4066 release_sock(sk);
4067 return(0);
4068
4069 case TCP_CLOSE:
4070 if (sk->dead || sk->daddr) {
4071 kfree_skb(skb, FREE_READ);
4072 release_sock(sk);
4073 return(0);
4074 }
4075
4076 if (!th->rst) {
4077 if (!th->ack)
4078 th->ack_seq = 0;
4079 tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
4080 }
4081 kfree_skb(skb, FREE_READ);
4082 release_sock(sk);
4083 return(0);
4084
4085 case TCP_LISTEN:
4086 if (th->rst) {
4087 kfree_skb(skb, FREE_READ);
4088 release_sock(sk);
4089 return(0);
4090 }
4091 if (th->ack) {
4092 tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
4093 kfree_skb(skb, FREE_READ);
4094 release_sock(sk);
4095 return(0);
4096 }
4097
4098 if (th->syn)
4099 {
4100 /*
4101 * Now we just put the whole thing including
4102 * the header and saddr, and protocol pointer
4103 * into the buffer. We can't respond until the
4104 * user tells us to accept the connection.
4105 */
4106 tcp_conn_request(sk, skb, daddr, saddr, opt, dev);
4107 release_sock(sk);
4108 return(0);
4109 }
4110
4111 kfree_skb(skb, FREE_READ);
4112 release_sock(sk);
4113 return(0);
4114
4115 case TCP_SYN_RECV:
4116 if (th->syn) {
4117 /* Probably a retransmitted syn */
4118 kfree_skb(skb, FREE_READ);
4119 release_sock(sk);
4120 return(0);
4121 }
4122
4123
4124 default:
4125 if (!tcp_sequence(sk, th, len, opt, saddr,dev))
4126 {
4127 kfree_skb(skb, FREE_READ);
4128 release_sock(sk);
4129 return(0);
4130 }
4131
4132 case TCP_SYN_SENT:
4133 if (th->rst)
4134 {
4135 tcp_statistics.TcpAttemptFails++;
4136 sk->err = ECONNREFUSED;
4137 tcp_set_state(sk,TCP_CLOSE);
4138 sk->shutdown = SHUTDOWN_MASK;
4139 sk->zapped = 1;
4140 if (!sk->dead)
4141 {
4142 sk->state_change(sk);
4143 }
4144 kfree_skb(skb, FREE_READ);
4145 release_sock(sk);
4146 return(0);
4147 }
4148 if (!th->ack)
4149 {
4150 if (th->syn)
4151 {
4152 tcp_set_state(sk,TCP_SYN_RECV);
4153 }
4154 kfree_skb(skb, FREE_READ);
4155 release_sock(sk);
4156 return(0);
4157 }
4158
4159 switch(sk->state)
4160 {
4161 case TCP_SYN_SENT:
4162 if (!tcp_ack(sk, th, saddr, len))
4163 {
4164 tcp_statistics.TcpAttemptFails++;
4165 tcp_reset(daddr, saddr, th,
4166 sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
4167 kfree_skb(skb, FREE_READ);
4168 release_sock(sk);
4169 return(0);
4170 }
4171
4172 /*
4173 * If the syn bit is also set, switch to
4174 * tcp_syn_recv, and then to established.
4175 */
4176 if (!th->syn)
4177 {
4178 kfree_skb(skb, FREE_READ);
4179 release_sock(sk);
4180 return(0);
4181 }
4182
4183 /* Ack the syn and fall through. */
4184 sk->acked_seq = th->seq+1;
4185 sk->fin_seq = th->seq;
4186 tcp_send_ack(sk->sent_seq, th->seq+1,
4187 sk, th, sk->daddr);
4188
4189 case TCP_SYN_RECV:
4190 if (!tcp_ack(sk, th, saddr, len))
4191 {
4192 tcp_statistics.TcpAttemptFails++;
4193 tcp_reset(daddr, saddr, th,
4194 sk->prot, opt, dev,sk->ip_tos,sk->ip_ttl);
4195 kfree_skb(skb, FREE_READ);
4196 release_sock(sk);
4197 return(0);
4198 }
4199
4200 tcp_set_state(sk,TCP_ESTABLISHED);
4201
4202 /*
4203 * Now we need to finish filling out
4204 * some of the tcp header.
4205 *
4206 * We need to check for mtu info.
4207 */
4208 tcp_options(sk, th);
4209 sk->dummy_th.dest = th->source;
4210 sk->copied_seq = sk->acked_seq-1;
4211 if (!sk->dead)
4212 {
4213 sk->state_change(sk);
4214 }
4215
4216 /*
4217 * We've already processed his first
4218 * ack. In just about all cases that
4219 * will have set max_window. This is
4220 * to protect us against the possibility
4221 * that the initial window he sent was 0.
4222 * This must occur after tcp_options, which
4223 * sets sk->mtu.
4224 */
4225 if (sk->max_window == 0)
4226 {
4227 sk->max_window = 32;
4228 sk->mss = min(sk->max_window, sk->mtu);
4229 }
4230
4231 /*
4232 * Now process the rest like we were
4233 * already in the established state.
4234 */
4235 if (th->urg)
4236 {
4237 if (tcp_urg(sk, th, saddr, len))
4238 {
4239 kfree_skb(skb, FREE_READ);
4240 release_sock(sk);
4241 return(0);
4242 }
4243 }
4244 if (tcp_data(skb, sk, saddr, len))
4245 kfree_skb(skb, FREE_READ);
4246
4247 if (th->fin)
4248 tcp_fin(skb, sk, th, saddr, dev);
4249 release_sock(sk);
4250 return(0);
4251 }
4252
4253 if (th->urg)
4254 {
4255 if (tcp_urg(sk, th, saddr, len))
4256 {
4257 kfree_skb(skb, FREE_READ);
4258 release_sock(sk);
4259 return(0);
4260 }
4261 }
4262 if (tcp_data(skb, sk, saddr, len))
4263 {
4264 kfree_skb(skb, FREE_READ);
4265 release_sock(sk);
4266 return(0);
4267 }
4268
4269 if (!th->fin)
4270 {
4271 release_sock(sk);
4272 return(0);
4273 }
4274 tcp_fin(skb, sk, th, saddr, dev);
4275 release_sock(sk);
4276 return(0);
4277 }
4278 }
4279
4280
4281 /*
4282 * This routine sends a packet with an out of date sequence
4283 * number. It assumes the other end will try to ack it.
4284 */
4285
4286 static void tcp_write_wakeup(struct sock *sk)
/* */
4287 {
4288 struct sk_buff *buff;
4289 struct tcphdr *t1;
4290 struct device *dev=NULL;
4291 int tmp;
4292
4293 if (sk->zapped)
4294 return; /* After a valid reset we can send no more */
4295
4296 /*
4297 * Write data can still be transmitted/retransmitted in the
4298 * following states. If any other state is encountered, return.
4299 */
4300
4301 if (sk->state != TCP_ESTABLISHED &&
4302 sk->state != TCP_CLOSE_WAIT &&
4303 sk->state != TCP_FIN_WAIT1 &&
4304 sk->state != TCP_LAST_ACK &&
4305 sk->state != TCP_CLOSING
4306 ) {
4307 return;
4308 }
4309
4310 buff = sk->prot->wmalloc(sk,MAX_ACK_SIZE,1, GFP_ATOMIC);
4311 if (buff == NULL)
4312 return;
4313
4314 buff->len = sizeof(struct tcphdr);
4315 buff->free = 1;
4316 buff->sk = sk;
4317 buff->localroute = sk->localroute;
4318
4319 t1 = (struct tcphdr *) buff->data;
4320
4321 /* Put in the IP header and routing stuff. */
4322 tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
4323 IPPROTO_TCP, sk->opt, MAX_ACK_SIZE,sk->ip_tos,sk->ip_ttl);
4324 if (tmp < 0)
4325 {
4326 sk->prot->wfree(sk, buff->mem_addr, buff->mem_len);
4327 return;
4328 }
4329
4330 buff->len += tmp;
4331 t1 = (struct tcphdr *)((char *)t1 +tmp);
4332
4333 memcpy(t1,(void *) &sk->dummy_th, sizeof(*t1));
4334
4335 /*
4336 * Use a previous sequence.
4337 * This should cause the other end to send an ack.
4338 */
4339 t1->seq = htonl(sk->sent_seq-1);
4340 t1->ack = 1;
4341 t1->res1= 0;
4342 t1->res2= 0;
4343 t1->rst = 0;
4344 t1->urg = 0;
4345 t1->psh = 0;
4346 t1->fin = 0;
4347 t1->syn = 0;
4348 t1->ack_seq = ntohl(sk->acked_seq);
4349 t1->window = ntohs(tcp_select_window(sk)/*sk->prot->rspace(sk)*/);
4350 t1->doff = sizeof(*t1)/4;
4351 tcp_send_check(t1, sk->saddr, sk->daddr, sizeof(*t1), sk);
4352
4353 /* Send it and free it.
4354 * This will prevent the timer from automatically being restarted.
4355 */
4356 sk->prot->queue_xmit(sk, dev, buff, 1);
4357 tcp_statistics.TcpOutSegs++;
4358 }
4359
4360 void
4361 tcp_send_probe0(struct sock *sk)
/* */
4362 {
4363 if (sk->zapped)
4364 return; /* After a valid reset we can send no more */
4365
4366 tcp_write_wakeup(sk);
4367
4368 sk->backoff++;
4369 sk->rto = min(sk->rto << 1, 120*HZ);
4370 reset_timer (sk, TIME_PROBE0, sk->rto);
4371 sk->retransmits++;
4372 sk->prot->retransmits ++;
4373 }
4374
4375 /*
4376 * Socket option code for TCP.
4377 */
4378
4379 int tcp_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen)
/* */
4380 {
4381 int val,err;
4382
4383 if(level!=SOL_TCP)
4384 return ip_setsockopt(sk,level,optname,optval,optlen);
4385
4386 if (optval == NULL)
4387 return(-EINVAL);
4388
4389 err=verify_area(VERIFY_READ, optval, sizeof(int));
4390 if(err)
4391 return err;
4392
4393 val = get_fs_long((unsigned long *)optval);
4394
4395 switch(optname)
4396 {
4397 case TCP_MAXSEG:
4398 /* if(val<200||val>2048 || val>sk->mtu) */
4399 /*
4400 * values greater than interface MTU won't take effect. however at
4401 * the point when this call is done we typically don't yet know
4402 * which interface is going to be used
4403 */
4404 if(val<1||val>MAX_WINDOW)
4405 return -EINVAL;
4406 sk->user_mss=val;
4407 return 0;
4408 case TCP_NODELAY:
4409 sk->nonagle=(val==0)?0:1;
4410 return 0;
4411 default:
4412 return(-ENOPROTOOPT);
4413 }
4414 }
4415
4416 int tcp_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen)
/* ![[last]](../icons/n_last.png)
*/
4417 {
4418 int val,err;
4419
4420 if(level!=SOL_TCP)
4421 return ip_getsockopt(sk,level,optname,optval,optlen);
4422
4423 switch(optname)
4424 {
4425 case TCP_MAXSEG:
4426 val=sk->user_mss;
4427 break;
4428 case TCP_NODELAY:
4429 val=sk->nonagle; /* Until Johannes stuff is in */
4430 break;
4431 default:
4432 return(-ENOPROTOOPT);
4433 }
4434 err=verify_area(VERIFY_WRITE, optlen, sizeof(int));
4435 if(err)
4436 return err;
4437 put_fs_long(sizeof(int),(unsigned long *) optlen);
4438
4439 err=verify_area(VERIFY_WRITE, optval, sizeof(int));
4440 if(err)
4441 return err;
4442 put_fs_long(val,(unsigned long *)optval);
4443
4444 return(0);
4445 }
4446
4447
4448 struct proto tcp_prot = {
4449 sock_wmalloc,
4450 sock_rmalloc,
4451 sock_wfree,
4452 sock_rfree,
4453 sock_rspace,
4454 sock_wspace,
4455 tcp_close,
4456 tcp_read,
4457 tcp_write,
4458 tcp_sendto,
4459 tcp_recvfrom,
4460 ip_build_header,
4461 tcp_connect,
4462 tcp_accept,
4463 ip_queue_xmit,
4464 tcp_retransmit,
4465 tcp_write_wakeup,
4466 tcp_read_wakeup,
4467 tcp_rcv,
4468 tcp_select,
4469 tcp_ioctl,
4470 NULL,
4471 tcp_shutdown,
4472 tcp_setsockopt,
4473 tcp_getsockopt,
4474 128,
4475 0,
4476 {NULL,},
4477 "TCP"
4478 };
![[bottom]](../icons/n_bottom.png){kind=icon}
*/