?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ocfs2: Read support for directories with inline data
[linux-2.6/verdex.git] / net / ipv4 / tcp_ipv4.c
blob38cf73a5673144ed40cab33d07501a972c5299be
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: $Id: tcp_ipv4.c,v 1.240 2002/02/01 22:01:04 davem Exp $
9 *
10 * IPv4 specific functions
11 *
12 *
13 * code split from:
14 * linux/ipv4/tcp.c
15 * linux/ipv4/tcp_input.c
16 * linux/ipv4/tcp_output.c
17 *
18 * See tcp.c for author information
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 */
25
26 /*
27 * Changes:
28 * David S. Miller : New socket lookup architecture.
29 * This code is dedicated to John Dyson.
30 * David S. Miller : Change semantics of established hash,
31 * half is devoted to TIME_WAIT sockets
32 * and the rest go in the other half.
33 * Andi Kleen : Add support for syncookies and fixed
34 * some bugs: ip options weren't passed to
35 * the TCP layer, missed a check for an
36 * ACK bit.
37 * Andi Kleen : Implemented fast path mtu discovery.
38 * Fixed many serious bugs in the
39 * request_sock handling and moved
40 * most of it into the af independent code.
41 * Added tail drop and some other bugfixes.
42 * Added new listen semantics.
43 * Mike McLagan : Routing by source
44 * Juan Jose Ciarlante: ip_dynaddr bits
45 * Andi Kleen: various fixes.
46 * Vitaly E. Lavrov : Transparent proxy revived after year
47 * coma.
48 * Andi Kleen : Fix new listen.
49 * Andi Kleen : Fix accept error reporting.
50 * YOSHIFUJI Hideaki @USAGI and: Support IPV6_V6ONLY socket option, which
51 * Alexey Kuznetsov allow both IPv4 and IPv6 sockets to bind
52 * a single port at the same time.
53 */
54
55
56 #include <linux/types.h>
57 #include <linux/fcntl.h>
58 #include <linux/module.h>
59 #include <linux/random.h>
60 #include <linux/cache.h>
61 #include <linux/jhash.h>
62 #include <linux/init.h>
63 #include <linux/times.h>
64
65 #include <net/net_namespace.h>
66 #include <net/icmp.h>
67 #include <net/inet_hashtables.h>
68 #include <net/tcp.h>
69 #include <net/transp_v6.h>
70 #include <net/ipv6.h>
71 #include <net/inet_common.h>
72 #include <net/timewait_sock.h>
73 #include <net/xfrm.h>
74 #include <net/netdma.h>
75
76 #include <linux/inet.h>
77 #include <linux/ipv6.h>
78 #include <linux/stddef.h>
79 #include <linux/proc_fs.h>
80 #include <linux/seq_file.h>
81
82 #include <linux/crypto.h>
83 #include <linux/scatterlist.h>
84
85 int sysctl_tcp_tw_reuse __read_mostly;
86 int sysctl_tcp_low_latency __read_mostly;
87
88 /* Check TCP sequence numbers in ICMP packets. */
89 #define ICMP_MIN_LENGTH 8
90
91 /* Socket used for sending RSTs */
92 static struct socket *tcp_socket __read_mostly;
93
94 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb);
95
96 #ifdef CONFIG_TCP_MD5SIG
97 static struct tcp_md5sig_key *tcp_v4_md5_do_lookup(struct sock *sk,
98 __be32 addr);
99 static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
100 __be32 saddr, __be32 daddr,
101 struct tcphdr *th, int protocol,
102 int tcplen);
103 #endif
104
105 struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
106 .lhash_lock = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),
107 .lhash_users = ATOMIC_INIT(0),
108 .lhash_wait = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),
109 };
110
111 static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
112 {
113 return inet_csk_get_port(&tcp_hashinfo, sk, snum,
114 inet_csk_bind_conflict);
115 }
116
117 static void tcp_v4_hash(struct sock *sk)
118 {
119 inet_hash(&tcp_hashinfo, sk);
120 }
121
122 void tcp_unhash(struct sock *sk)
123 {
124 inet_unhash(&tcp_hashinfo, sk);
125 }
126
127 static inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
128 {
129 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
130 ip_hdr(skb)->saddr,
131 tcp_hdr(skb)->dest,
132 tcp_hdr(skb)->source);
133 }
134
135 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
136 {
137 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
138 struct tcp_sock *tp = tcp_sk(sk);
139
140 /* With PAWS, it is safe from the viewpoint
141 of data integrity. Even without PAWS it is safe provided sequence
142 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
143
144 Actually, the idea is close to VJ's one, only timestamp cache is
145 held not per host, but per port pair and TW bucket is used as state
146 holder.
147
148 If TW bucket has been already destroyed we fall back to VJ's scheme
149 and use initial timestamp retrieved from peer table.
150 */
151 if (tcptw->tw_ts_recent_stamp &&
152 (twp == NULL || (sysctl_tcp_tw_reuse &&
153 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
154 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
155 if (tp->write_seq == 0)
156 tp->write_seq = 1;
157 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
158 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
159 sock_hold(sktw);
160 return 1;
161 }
162
163 return 0;
164 }
165
166 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
167
168 /* This will initiate an outgoing connection. */
169 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
170 {
171 struct inet_sock *inet = inet_sk(sk);
172 struct tcp_sock *tp = tcp_sk(sk);
173 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
174 struct rtable *rt;
175 __be32 daddr, nexthop;
176 int tmp;
177 int err;
178
179 if (addr_len < sizeof(struct sockaddr_in))
180 return -EINVAL;
181
182 if (usin->sin_family != AF_INET)
183 return -EAFNOSUPPORT;
184
185 nexthop = daddr = usin->sin_addr.s_addr;
186 if (inet->opt && inet->opt->srr) {
187 if (!daddr)
188 return -EINVAL;
189 nexthop = inet->opt->faddr;
190 }
191
192 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
193 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
194 IPPROTO_TCP,
195 inet->sport, usin->sin_port, sk, 1);
196 if (tmp < 0) {
197 if (tmp == -ENETUNREACH)
198 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
199 return tmp;
200 }
201
202 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
203 ip_rt_put(rt);
204 return -ENETUNREACH;
205 }
206
207 if (!inet->opt || !inet->opt->srr)
208 daddr = rt->rt_dst;
209
210 if (!inet->saddr)
211 inet->saddr = rt->rt_src;
212 inet->rcv_saddr = inet->saddr;
213
214 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
215 /* Reset inherited state */
216 tp->rx_opt.ts_recent = 0;
217 tp->rx_opt.ts_recent_stamp = 0;
218 tp->write_seq = 0;
219 }
220
221 if (tcp_death_row.sysctl_tw_recycle &&
222 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
223 struct inet_peer *peer = rt_get_peer(rt);
224 /*
225 * VJ's idea. We save last timestamp seen from
226 * the destination in peer table, when entering state
227 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
228 * when trying new connection.
229 */
230 if (peer != NULL &&
231 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
232 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
233 tp->rx_opt.ts_recent = peer->tcp_ts;
234 }
235 }
236
237 inet->dport = usin->sin_port;
238 inet->daddr = daddr;
239
240 inet_csk(sk)->icsk_ext_hdr_len = 0;
241 if (inet->opt)
242 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
243
244 tp->rx_opt.mss_clamp = 536;
245
246 /* Socket identity is still unknown (sport may be zero).
247 * However we set state to SYN-SENT and not releasing socket
248 * lock select source port, enter ourselves into the hash tables and
249 * complete initialization after this.
250 */
251 tcp_set_state(sk, TCP_SYN_SENT);
252 err = inet_hash_connect(&tcp_death_row, sk);
253 if (err)
254 goto failure;
255
256 err = ip_route_newports(&rt, IPPROTO_TCP,
257 inet->sport, inet->dport, sk);
258 if (err)
259 goto failure;
260
261 /* OK, now commit destination to socket. */
262 sk->sk_gso_type = SKB_GSO_TCPV4;
263 sk_setup_caps(sk, &rt->u.dst);
264
265 if (!tp->write_seq)
266 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
267 inet->daddr,
268 inet->sport,
269 usin->sin_port);
270
271 inet->id = tp->write_seq ^ jiffies;
272
273 err = tcp_connect(sk);
274 rt = NULL;
275 if (err)
276 goto failure;
277
278 return 0;
279
280 failure:
281 /*
282 * This unhashes the socket and releases the local port,
283 * if necessary.
284 */
285 tcp_set_state(sk, TCP_CLOSE);
286 ip_rt_put(rt);
287 sk->sk_route_caps = 0;
288 inet->dport = 0;
289 return err;
290 }
291
292 /*
293 * This routine does path mtu discovery as defined in RFC1191.
294 */
295 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
296 {
297 struct dst_entry *dst;
298 struct inet_sock *inet = inet_sk(sk);
299
300 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
301 * send out by Linux are always <576bytes so they should go through
302 * unfragmented).
303 */
304 if (sk->sk_state == TCP_LISTEN)
305 return;
306
307 /* We don't check in the destentry if pmtu discovery is forbidden
308 * on this route. We just assume that no packet_to_big packets
309 * are send back when pmtu discovery is not active.
310 * There is a small race when the user changes this flag in the
311 * route, but I think that's acceptable.
312 */
313 if ((dst = __sk_dst_check(sk, 0)) == NULL)
314 return;
315
316 dst->ops->update_pmtu(dst, mtu);
317
318 /* Something is about to be wrong... Remember soft error
319 * for the case, if this connection will not able to recover.
320 */
321 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
322 sk->sk_err_soft = EMSGSIZE;
323
324 mtu = dst_mtu(dst);
325
326 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
327 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
328 tcp_sync_mss(sk, mtu);
329
330 /* Resend the TCP packet because it's
331 * clear that the old packet has been
332 * dropped. This is the new "fast" path mtu
333 * discovery.
334 */
335 tcp_simple_retransmit(sk);
336 } /* else let the usual retransmit timer handle it */
337 }
338
339 /*
340 * This routine is called by the ICMP module when it gets some
341 * sort of error condition. If err < 0 then the socket should
342 * be closed and the error returned to the user. If err > 0
343 * it's just the icmp type << 8 | icmp code. After adjustment
344 * header points to the first 8 bytes of the tcp header. We need
345 * to find the appropriate port.
346 *
347 * The locking strategy used here is very "optimistic". When
348 * someone else accesses the socket the ICMP is just dropped
349 * and for some paths there is no check at all.
350 * A more general error queue to queue errors for later handling
351 * is probably better.
352 *
353 */
354
355 void tcp_v4_err(struct sk_buff *skb, u32 info)
356 {
357 struct iphdr *iph = (struct iphdr *)skb->data;
358 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
359 struct tcp_sock *tp;
360 struct inet_sock *inet;
361 const int type = icmp_hdr(skb)->type;
362 const int code = icmp_hdr(skb)->code;
363 struct sock *sk;
364 __u32 seq;
365 int err;
366
367 if (skb->len < (iph->ihl << 2) + 8) {
368 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
369 return;
370 }
371
372 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
373 th->source, inet_iif(skb));
374 if (!sk) {
375 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
376 return;
377 }
378 if (sk->sk_state == TCP_TIME_WAIT) {
379 inet_twsk_put(inet_twsk(sk));
380 return;
381 }
382
383 bh_lock_sock(sk);
384 /* If too many ICMPs get dropped on busy
385 * servers this needs to be solved differently.
386 */
387 if (sock_owned_by_user(sk))
388 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
389
390 if (sk->sk_state == TCP_CLOSE)
391 goto out;
392
393 tp = tcp_sk(sk);
394 seq = ntohl(th->seq);
395 if (sk->sk_state != TCP_LISTEN &&
396 !between(seq, tp->snd_una, tp->snd_nxt)) {
397 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
398 goto out;
399 }
400
401 switch (type) {
402 case ICMP_SOURCE_QUENCH:
403 /* Just silently ignore these. */
404 goto out;
405 case ICMP_PARAMETERPROB:
406 err = EPROTO;
407 break;
408 case ICMP_DEST_UNREACH:
409 if (code > NR_ICMP_UNREACH)
410 goto out;
411
412 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
413 if (!sock_owned_by_user(sk))
414 do_pmtu_discovery(sk, iph, info);
415 goto out;
416 }
417
418 err = icmp_err_convert[code].errno;
419 break;
420 case ICMP_TIME_EXCEEDED:
421 err = EHOSTUNREACH;
422 break;
423 default:
424 goto out;
425 }
426
427 switch (sk->sk_state) {
428 struct request_sock *req, **prev;
429 case TCP_LISTEN:
430 if (sock_owned_by_user(sk))
431 goto out;
432
433 req = inet_csk_search_req(sk, &prev, th->dest,
434 iph->daddr, iph->saddr);
435 if (!req)
436 goto out;
437
438 /* ICMPs are not backlogged, hence we cannot get
439 an established socket here.
440 */
441 BUG_TRAP(!req->sk);
442
443 if (seq != tcp_rsk(req)->snt_isn) {
444 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
445 goto out;
446 }
447
448 /*
449 * Still in SYN_RECV, just remove it silently.
450 * There is no good way to pass the error to the newly
451 * created socket, and POSIX does not want network
452 * errors returned from accept().
453 */
454 inet_csk_reqsk_queue_drop(sk, req, prev);
455 goto out;
456
457 case TCP_SYN_SENT:
458 case TCP_SYN_RECV: /* Cannot happen.
459 It can f.e. if SYNs crossed.
460 */
461 if (!sock_owned_by_user(sk)) {
462 sk->sk_err = err;
463
464 sk->sk_error_report(sk);
465
466 tcp_done(sk);
467 } else {
468 sk->sk_err_soft = err;
469 }
470 goto out;
471 }
472
473 /* If we've already connected we will keep trying
474 * until we time out, or the user gives up.
475 *
476 * rfc1122 4.2.3.9 allows to consider as hard errors
477 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
478 * but it is obsoleted by pmtu discovery).
479 *
480 * Note, that in modern internet, where routing is unreliable
481 * and in each dark corner broken firewalls sit, sending random
482 * errors ordered by their masters even this two messages finally lose
483 * their original sense (even Linux sends invalid PORT_UNREACHs)
484 *
485 * Now we are in compliance with RFCs.
486 * --ANK (980905)
487 */
488
489 inet = inet_sk(sk);
490 if (!sock_owned_by_user(sk) && inet->recverr) {
491 sk->sk_err = err;
492 sk->sk_error_report(sk);
493 } else { /* Only an error on timeout */
494 sk->sk_err_soft = err;
495 }
496
497 out:
498 bh_unlock_sock(sk);
499 sock_put(sk);
500 }
501
502 /* This routine computes an IPv4 TCP checksum. */
503 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
504 {
505 struct inet_sock *inet = inet_sk(sk);
506 struct tcphdr *th = tcp_hdr(skb);
507
508 if (skb->ip_summed == CHECKSUM_PARTIAL) {
509 th->check = ~tcp_v4_check(len, inet->saddr,
510 inet->daddr, 0);
511 skb->csum_start = skb_transport_header(skb) - skb->head;
512 skb->csum_offset = offsetof(struct tcphdr, check);
513 } else {
514 th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
515 csum_partial((char *)th,
516 th->doff << 2,
517 skb->csum));
518 }
519 }
520
521 int tcp_v4_gso_send_check(struct sk_buff *skb)
522 {
523 const struct iphdr *iph;
524 struct tcphdr *th;
525
526 if (!pskb_may_pull(skb, sizeof(*th)))
527 return -EINVAL;
528
529 iph = ip_hdr(skb);
530 th = tcp_hdr(skb);
531
532 th->check = 0;
533 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
534 skb->csum_start = skb_transport_header(skb) - skb->head;
535 skb->csum_offset = offsetof(struct tcphdr, check);
536 skb->ip_summed = CHECKSUM_PARTIAL;
537 return 0;
538 }
539
540 /*
541 * This routine will send an RST to the other tcp.
542 *
543 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
544 * for reset.
545 * Answer: if a packet caused RST, it is not for a socket
546 * existing in our system, if it is matched to a socket,
547 * it is just duplicate segment or bug in other side's TCP.
548 * So that we build reply only basing on parameters
549 * arrived with segment.
550 * Exception: precedence violation. We do not implement it in any case.
551 */
552
553 static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
554 {
555 struct tcphdr *th = tcp_hdr(skb);
556 struct {
557 struct tcphdr th;
558 #ifdef CONFIG_TCP_MD5SIG
559 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
560 #endif
561 } rep;
562 struct ip_reply_arg arg;
563 #ifdef CONFIG_TCP_MD5SIG
564 struct tcp_md5sig_key *key;
565 #endif
566
567 /* Never send a reset in response to a reset. */
568 if (th->rst)
569 return;
570
571 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
572 return;
573
574 /* Swap the send and the receive. */
575 memset(&rep, 0, sizeof(rep));
576 rep.th.dest = th->source;
577 rep.th.source = th->dest;
578 rep.th.doff = sizeof(struct tcphdr) / 4;
579 rep.th.rst = 1;
580
581 if (th->ack) {
582 rep.th.seq = th->ack_seq;
583 } else {
584 rep.th.ack = 1;
585 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
586 skb->len - (th->doff << 2));
587 }
588
589 memset(&arg, 0, sizeof(arg));
590 arg.iov[0].iov_base = (unsigned char *)&rep;
591 arg.iov[0].iov_len = sizeof(rep.th);
592
593 #ifdef CONFIG_TCP_MD5SIG
594 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
595 if (key) {
596 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
597 (TCPOPT_NOP << 16) |
598 (TCPOPT_MD5SIG << 8) |
599 TCPOLEN_MD5SIG);
600 /* Update length and the length the header thinks exists */
601 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
602 rep.th.doff = arg.iov[0].iov_len / 4;
603
604 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[1],
605 key,
606 ip_hdr(skb)->daddr,
607 ip_hdr(skb)->saddr,
608 &rep.th, IPPROTO_TCP,
609 arg.iov[0].iov_len);
610 }
611 #endif
612 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
613 ip_hdr(skb)->saddr, /* XXX */
614 sizeof(struct tcphdr), IPPROTO_TCP, 0);
615 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
616
617 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
618
619 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
620 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
621 }
622
623 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
624 outside socket context is ugly, certainly. What can I do?
625 */
626
627 static void tcp_v4_send_ack(struct tcp_timewait_sock *twsk,
628 struct sk_buff *skb, u32 seq, u32 ack,
629 u32 win, u32 ts)
630 {
631 struct tcphdr *th = tcp_hdr(skb);
632 struct {
633 struct tcphdr th;
634 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
635 #ifdef CONFIG_TCP_MD5SIG
636 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
637 #endif
638 ];
639 } rep;
640 struct ip_reply_arg arg;
641 #ifdef CONFIG_TCP_MD5SIG
642 struct tcp_md5sig_key *key;
643 struct tcp_md5sig_key tw_key;
644 #endif
645
646 memset(&rep.th, 0, sizeof(struct tcphdr));
647 memset(&arg, 0, sizeof(arg));
648
649 arg.iov[0].iov_base = (unsigned char *)&rep;
650 arg.iov[0].iov_len = sizeof(rep.th);
651 if (ts) {
652 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
653 (TCPOPT_TIMESTAMP << 8) |
654 TCPOLEN_TIMESTAMP);
655 rep.opt[1] = htonl(tcp_time_stamp);
656 rep.opt[2] = htonl(ts);
657 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
658 }
659
660 /* Swap the send and the receive. */
661 rep.th.dest = th->source;
662 rep.th.source = th->dest;
663 rep.th.doff = arg.iov[0].iov_len / 4;
664 rep.th.seq = htonl(seq);
665 rep.th.ack_seq = htonl(ack);
666 rep.th.ack = 1;
667 rep.th.window = htons(win);
668
669 #ifdef CONFIG_TCP_MD5SIG
670 /*
671 * The SKB holds an imcoming packet, but may not have a valid ->sk
672 * pointer. This is especially the case when we're dealing with a
673 * TIME_WAIT ack, because the sk structure is long gone, and only
674 * the tcp_timewait_sock remains. So the md5 key is stashed in that
675 * structure, and we use it in preference. I believe that (twsk ||
676 * skb->sk) holds true, but we program defensively.
677 */
678 if (!twsk && skb->sk) {
679 key = tcp_v4_md5_do_lookup(skb->sk, ip_hdr(skb)->daddr);
680 } else if (twsk && twsk->tw_md5_keylen) {
681 tw_key.key = twsk->tw_md5_key;
682 tw_key.keylen = twsk->tw_md5_keylen;
683 key = &tw_key;
684 } else
685 key = NULL;
686
687 if (key) {
688 int offset = (ts) ? 3 : 0;
689
690 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
691 (TCPOPT_NOP << 16) |
692 (TCPOPT_MD5SIG << 8) |
693 TCPOLEN_MD5SIG);
694 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
695 rep.th.doff = arg.iov[0].iov_len/4;
696
697 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[offset],
698 key,
699 ip_hdr(skb)->daddr,
700 ip_hdr(skb)->saddr,
701 &rep.th, IPPROTO_TCP,
702 arg.iov[0].iov_len);
703 }
704 #endif
705 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
706 ip_hdr(skb)->saddr, /* XXX */
707 arg.iov[0].iov_len, IPPROTO_TCP, 0);
708 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
709 if (twsk)
710 arg.bound_dev_if = twsk->tw_sk.tw_bound_dev_if;
711
712 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
713
714 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
715 }
716
717 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
718 {
719 struct inet_timewait_sock *tw = inet_twsk(sk);
720 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
721
722 tcp_v4_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
723 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
724 tcptw->tw_ts_recent);
725
726 inet_twsk_put(tw);
727 }
728
729 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb,
730 struct request_sock *req)
731 {
732 tcp_v4_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1,
733 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
734 req->ts_recent);
735 }
736
737 /*
738 * Send a SYN-ACK after having received an ACK.
739 * This still operates on a request_sock only, not on a big
740 * socket.
741 */
742 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
743 struct dst_entry *dst)
744 {
745 const struct inet_request_sock *ireq = inet_rsk(req);
746 int err = -1;
747 struct sk_buff * skb;
748
749 /* First, grab a route. */
750 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
751 goto out;
752
753 skb = tcp_make_synack(sk, dst, req);
754
755 if (skb) {
756 struct tcphdr *th = tcp_hdr(skb);
757
758 th->check = tcp_v4_check(skb->len,
759 ireq->loc_addr,
760 ireq->rmt_addr,
761 csum_partial((char *)th, skb->len,
762 skb->csum));
763
764 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
765 ireq->rmt_addr,
766 ireq->opt);
767 err = net_xmit_eval(err);
768 }
769
770 out:
771 dst_release(dst);
772 return err;
773 }
774
775 /*
776 * IPv4 request_sock destructor.
777 */
778 static void tcp_v4_reqsk_destructor(struct request_sock *req)
779 {
780 kfree(inet_rsk(req)->opt);
781 }
782
783 #ifdef CONFIG_SYN_COOKIES
784 static void syn_flood_warning(struct sk_buff *skb)
785 {
786 static unsigned long warntime;
787
788 if (time_after(jiffies, (warntime + HZ * 60))) {
789 warntime = jiffies;
790 printk(KERN_INFO
791 "possible SYN flooding on port %d. Sending cookies.\n",
792 ntohs(tcp_hdr(skb)->dest));
793 }
794 }
795 #endif
796
797 /*
798 * Save and compile IPv4 options into the request_sock if needed.
799 */
800 static struct ip_options *tcp_v4_save_options(struct sock *sk,
801 struct sk_buff *skb)
802 {
803 struct ip_options *opt = &(IPCB(skb)->opt);
804 struct ip_options *dopt = NULL;
805
806 if (opt && opt->optlen) {
807 int opt_size = optlength(opt);
808 dopt = kmalloc(opt_size, GFP_ATOMIC);
809 if (dopt) {
810 if (ip_options_echo(dopt, skb)) {
811 kfree(dopt);
812 dopt = NULL;
813 }
814 }
815 }
816 return dopt;
817 }
818
819 #ifdef CONFIG_TCP_MD5SIG
820 /*
821 * RFC2385 MD5 checksumming requires a mapping of
822 * IP address->MD5 Key.
823 * We need to maintain these in the sk structure.
824 */
825
826 /* Find the Key structure for an address. */
827 static struct tcp_md5sig_key *
828 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
829 {
830 struct tcp_sock *tp = tcp_sk(sk);
831 int i;
832
833 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
834 return NULL;
835 for (i = 0; i < tp->md5sig_info->entries4; i++) {
836 if (tp->md5sig_info->keys4[i].addr == addr)
837 return &tp->md5sig_info->keys4[i].base;
838 }
839 return NULL;
840 }
841
842 struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
843 struct sock *addr_sk)
844 {
845 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
846 }
847
848 EXPORT_SYMBOL(tcp_v4_md5_lookup);
849
850 static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
851 struct request_sock *req)
852 {
853 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
854 }
855
856 /* This can be called on a newly created socket, from other files */
857 int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
858 u8 *newkey, u8 newkeylen)
859 {
860 /* Add Key to the list */
861 struct tcp4_md5sig_key *key;
862 struct tcp_sock *tp = tcp_sk(sk);
863 struct tcp4_md5sig_key *keys;
864
865 key = (struct tcp4_md5sig_key *)tcp_v4_md5_do_lookup(sk, addr);
866 if (key) {
867 /* Pre-existing entry - just update that one. */
868 kfree(key->base.key);
869 key->base.key = newkey;
870 key->base.keylen = newkeylen;
871 } else {
872 struct tcp_md5sig_info *md5sig;
873
874 if (!tp->md5sig_info) {
875 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
876 GFP_ATOMIC);
877 if (!tp->md5sig_info) {
878 kfree(newkey);
879 return -ENOMEM;
880 }
881 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
882 }
883 if (tcp_alloc_md5sig_pool() == NULL) {
884 kfree(newkey);
885 return -ENOMEM;
886 }
887 md5sig = tp->md5sig_info;
888
889 if (md5sig->alloced4 == md5sig->entries4) {
890 keys = kmalloc((sizeof(*keys) *
891 (md5sig->entries4 + 1)), GFP_ATOMIC);
892 if (!keys) {
893 kfree(newkey);
894 tcp_free_md5sig_pool();
895 return -ENOMEM;
896 }
897
898 if (md5sig->entries4)
899 memcpy(keys, md5sig->keys4,
900 sizeof(*keys) * md5sig->entries4);
901
902 /* Free old key list, and reference new one */
903 if (md5sig->keys4)
904 kfree(md5sig->keys4);
905 md5sig->keys4 = keys;
906 md5sig->alloced4++;
907 }
908 md5sig->entries4++;
909 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
910 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
911 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
912 }
913 return 0;
914 }
915
916 EXPORT_SYMBOL(tcp_v4_md5_do_add);
917
918 static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
919 u8 *newkey, u8 newkeylen)
920 {
921 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
922 newkey, newkeylen);
923 }
924
925 int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
926 {
927 struct tcp_sock *tp = tcp_sk(sk);
928 int i;
929
930 for (i = 0; i < tp->md5sig_info->entries4; i++) {
931 if (tp->md5sig_info->keys4[i].addr == addr) {
932 /* Free the key */
933 kfree(tp->md5sig_info->keys4[i].base.key);
934 tp->md5sig_info->entries4--;
935
936 if (tp->md5sig_info->entries4 == 0) {
937 kfree(tp->md5sig_info->keys4);
938 tp->md5sig_info->keys4 = NULL;
939 tp->md5sig_info->alloced4 = 0;
940 } else if (tp->md5sig_info->entries4 != i) {
941 /* Need to do some manipulation */
942 memcpy(&tp->md5sig_info->keys4[i],
943 &tp->md5sig_info->keys4[i+1],
944 (tp->md5sig_info->entries4 - i) *
945 sizeof(struct tcp4_md5sig_key));
946 }
947 tcp_free_md5sig_pool();
948 return 0;
949 }
950 }
951 return -ENOENT;
952 }
953
954 EXPORT_SYMBOL(tcp_v4_md5_do_del);
955
956 static void tcp_v4_clear_md5_list(struct sock *sk)
957 {
958 struct tcp_sock *tp = tcp_sk(sk);
959
960 /* Free each key, then the set of key keys,
961 * the crypto element, and then decrement our
962 * hold on the last resort crypto.
963 */
964 if (tp->md5sig_info->entries4) {
965 int i;
966 for (i = 0; i < tp->md5sig_info->entries4; i++)
967 kfree(tp->md5sig_info->keys4[i].base.key);
968 tp->md5sig_info->entries4 = 0;
969 tcp_free_md5sig_pool();
970 }
971 if (tp->md5sig_info->keys4) {
972 kfree(tp->md5sig_info->keys4);
973 tp->md5sig_info->keys4 = NULL;
974 tp->md5sig_info->alloced4 = 0;
975 }
976 }
977
978 static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
979 int optlen)
980 {
981 struct tcp_md5sig cmd;
982 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
983 u8 *newkey;
984
985 if (optlen < sizeof(cmd))
986 return -EINVAL;
987
988 if (copy_from_user(&cmd, optval, sizeof(cmd)))
989 return -EFAULT;
990
991 if (sin->sin_family != AF_INET)
992 return -EINVAL;
993
994 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
995 if (!tcp_sk(sk)->md5sig_info)
996 return -ENOENT;
997 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
998 }
999
1000 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
1001 return -EINVAL;
1002
1003 if (!tcp_sk(sk)->md5sig_info) {
1004 struct tcp_sock *tp = tcp_sk(sk);
1005 struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
1006
1007 if (!p)
1008 return -EINVAL;
1009
1010 tp->md5sig_info = p;
1011 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1012 }
1013
1014 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
1015 if (!newkey)
1016 return -ENOMEM;
1017 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1018 newkey, cmd.tcpm_keylen);
1019 }
1020
1021 static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1022 __be32 saddr, __be32 daddr,
1023 struct tcphdr *th, int protocol,
1024 int tcplen)
1025 {
1026 struct scatterlist sg[4];
1027 __u16 data_len;
1028 int block = 0;
1029 __sum16 old_checksum;
1030 struct tcp_md5sig_pool *hp;
1031 struct tcp4_pseudohdr *bp;
1032 struct hash_desc *desc;
1033 int err;
1034 unsigned int nbytes = 0;
1035
1036 /*
1037 * Okay, so RFC2385 is turned on for this connection,
1038 * so we need to generate the MD5 hash for the packet now.
1039 */
1040
1041 hp = tcp_get_md5sig_pool();
1042 if (!hp)
1043 goto clear_hash_noput;
1044
1045 bp = &hp->md5_blk.ip4;
1046 desc = &hp->md5_desc;
1047
1048 /*
1049 * 1. the TCP pseudo-header (in the order: source IP address,
1050 * destination IP address, zero-padded protocol number, and
1051 * segment length)
1052 */
1053 bp->saddr = saddr;
1054 bp->daddr = daddr;
1055 bp->pad = 0;
1056 bp->protocol = protocol;
1057 bp->len = htons(tcplen);
1058 sg_set_buf(&sg[block++], bp, sizeof(*bp));
1059 nbytes += sizeof(*bp);
1060
1061 /* 2. the TCP header, excluding options, and assuming a
1062 * checksum of zero/
1063 */
1064 old_checksum = th->check;
1065 th->check = 0;
1066 sg_set_buf(&sg[block++], th, sizeof(struct tcphdr));
1067 nbytes += sizeof(struct tcphdr);
1068
1069 /* 3. the TCP segment data (if any) */
1070 data_len = tcplen - (th->doff << 2);
1071 if (data_len > 0) {
1072 unsigned char *data = (unsigned char *)th + (th->doff << 2);
1073 sg_set_buf(&sg[block++], data, data_len);
1074 nbytes += data_len;
1075 }
1076
1077 /* 4. an independently-specified key or password, known to both
1078 * TCPs and presumably connection-specific
1079 */
1080 sg_set_buf(&sg[block++], key->key, key->keylen);
1081 nbytes += key->keylen;
1082
1083 /* Now store the Hash into the packet */
1084 err = crypto_hash_init(desc);
1085 if (err)
1086 goto clear_hash;
1087 err = crypto_hash_update(desc, sg, nbytes);
1088 if (err)
1089 goto clear_hash;
1090 err = crypto_hash_final(desc, md5_hash);
1091 if (err)
1092 goto clear_hash;
1093
1094 /* Reset header, and free up the crypto */
1095 tcp_put_md5sig_pool();
1096 th->check = old_checksum;
1097
1098 out:
1099 return 0;
1100 clear_hash:
1101 tcp_put_md5sig_pool();
1102 clear_hash_noput:
1103 memset(md5_hash, 0, 16);
1104 goto out;
1105 }
1106
1107 int tcp_v4_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1108 struct sock *sk,
1109 struct dst_entry *dst,
1110 struct request_sock *req,
1111 struct tcphdr *th, int protocol,
1112 int tcplen)
1113 {
1114 __be32 saddr, daddr;
1115
1116 if (sk) {
1117 saddr = inet_sk(sk)->saddr;
1118 daddr = inet_sk(sk)->daddr;
1119 } else {
1120 struct rtable *rt = (struct rtable *)dst;
1121 BUG_ON(!rt);
1122 saddr = rt->rt_src;
1123 daddr = rt->rt_dst;
1124 }
1125 return tcp_v4_do_calc_md5_hash(md5_hash, key,
1126 saddr, daddr,
1127 th, protocol, tcplen);
1128 }
1129
1130 EXPORT_SYMBOL(tcp_v4_calc_md5_hash);
1131
1132 static int tcp_v4_inbound_md5_hash(struct sock *sk, struct sk_buff *skb)
1133 {
1134 /*
1135 * This gets called for each TCP segment that arrives
1136 * so we want to be efficient.
1137 * We have 3 drop cases:
1138 * o No MD5 hash and one expected.
1139 * o MD5 hash and we're not expecting one.
1140 * o MD5 hash and its wrong.
1141 */
1142 __u8 *hash_location = NULL;
1143 struct tcp_md5sig_key *hash_expected;
1144 const struct iphdr *iph = ip_hdr(skb);
1145 struct tcphdr *th = tcp_hdr(skb);
1146 int length = (th->doff << 2) - sizeof(struct tcphdr);
1147 int genhash;
1148 unsigned char *ptr;
1149 unsigned char newhash[16];
1150
1151 hash_expected = tcp_v4_md5_do_lookup(sk, iph->saddr);
1152
1153 /*
1154 * If the TCP option length is less than the TCP_MD5SIG
1155 * option length, then we can shortcut
1156 */
1157 if (length < TCPOLEN_MD5SIG) {
1158 if (hash_expected)
1159 return 1;
1160 else
1161 return 0;
1162 }
1163
1164 /* Okay, we can't shortcut - we have to grub through the options */
1165 ptr = (unsigned char *)(th + 1);
1166 while (length > 0) {
1167 int opcode = *ptr++;
1168 int opsize;
1169
1170 switch (opcode) {
1171 case TCPOPT_EOL:
1172 goto done_opts;
1173 case TCPOPT_NOP:
1174 length--;
1175 continue;
1176 default:
1177 opsize = *ptr++;
1178 if (opsize < 2)
1179 goto done_opts;
1180 if (opsize > length)
1181 goto done_opts;
1182
1183 if (opcode == TCPOPT_MD5SIG) {
1184 hash_location = ptr;
1185 goto done_opts;
1186 }
1187 }
1188 ptr += opsize-2;
1189 length -= opsize;
1190 }
1191 done_opts:
1192 /* We've parsed the options - do we have a hash? */
1193 if (!hash_expected && !hash_location)
1194 return 0;
1195
1196 if (hash_expected && !hash_location) {
1197 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash expected but NOT found "
1198 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
1199 NIPQUAD(iph->saddr), ntohs(th->source),
1200 NIPQUAD(iph->daddr), ntohs(th->dest));
1201 return 1;
1202 }
1203
1204 if (!hash_expected && hash_location) {
1205 LIMIT_NETDEBUG(KERN_INFO "MD5 Hash NOT expected but found "
1206 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)\n",
1207 NIPQUAD(iph->saddr), ntohs(th->source),
1208 NIPQUAD(iph->daddr), ntohs(th->dest));
1209 return 1;
1210 }
1211
1212 /* Okay, so this is hash_expected and hash_location -
1213 * so we need to calculate the checksum.
1214 */
1215 genhash = tcp_v4_do_calc_md5_hash(newhash,
1216 hash_expected,
1217 iph->saddr, iph->daddr,
1218 th, sk->sk_protocol,
1219 skb->len);
1220
1221 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
1222 if (net_ratelimit()) {
1223 printk(KERN_INFO "MD5 Hash failed for "
1224 "(" NIPQUAD_FMT ", %d)->(" NIPQUAD_FMT ", %d)%s\n",
1225 NIPQUAD(iph->saddr), ntohs(th->source),
1226 NIPQUAD(iph->daddr), ntohs(th->dest),
1227 genhash ? " tcp_v4_calc_md5_hash failed" : "");
1228 }
1229 return 1;
1230 }
1231 return 0;
1232 }
1233
1234 #endif
1235
1236 struct request_sock_ops tcp_request_sock_ops __read_mostly = {
1237 .family = PF_INET,
1238 .obj_size = sizeof(struct tcp_request_sock),
1239 .rtx_syn_ack = tcp_v4_send_synack,
1240 .send_ack = tcp_v4_reqsk_send_ack,
1241 .destructor = tcp_v4_reqsk_destructor,
1242 .send_reset = tcp_v4_send_reset,
1243 };
1244
1245 #ifdef CONFIG_TCP_MD5SIG
1246 static struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = {
1247 .md5_lookup = tcp_v4_reqsk_md5_lookup,
1248 };
1249 #endif
1250
1251 static struct timewait_sock_ops tcp_timewait_sock_ops = {
1252 .twsk_obj_size = sizeof(struct tcp_timewait_sock),
1253 .twsk_unique = tcp_twsk_unique,
1254 .twsk_destructor= tcp_twsk_destructor,
1255 };
1256
1257 int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1258 {
1259 struct inet_request_sock *ireq;
1260 struct tcp_options_received tmp_opt;
1261 struct request_sock *req;
1262 __be32 saddr = ip_hdr(skb)->saddr;
1263 __be32 daddr = ip_hdr(skb)->daddr;
1264 __u32 isn = TCP_SKB_CB(skb)->when;
1265 struct dst_entry *dst = NULL;
1266 #ifdef CONFIG_SYN_COOKIES
1267 int want_cookie = 0;
1268 #else
1269 #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */
1270 #endif
1271
1272 /* Never answer to SYNs send to broadcast or multicast */
1273 if (((struct rtable *)skb->dst)->rt_flags &
1274 (RTCF_BROADCAST | RTCF_MULTICAST))
1275 goto drop;
1276
1277 /* TW buckets are converted to open requests without
1278 * limitations, they conserve resources and peer is
1279 * evidently real one.
1280 */
1281 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1282 #ifdef CONFIG_SYN_COOKIES
1283 if (sysctl_tcp_syncookies) {
1284 want_cookie = 1;
1285 } else
1286 #endif
1287 goto drop;
1288 }
1289
1290 /* Accept backlog is full. If we have already queued enough
1291 * of warm entries in syn queue, drop request. It is better than
1292 * clogging syn queue with openreqs with exponentially increasing
1293 * timeout.
1294 */
1295 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1296 goto drop;
1297
1298 req = reqsk_alloc(&tcp_request_sock_ops);
1299 if (!req)
1300 goto drop;
1301
1302 #ifdef CONFIG_TCP_MD5SIG
1303 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv4_ops;
1304 #endif
1305
1306 tcp_clear_options(&tmp_opt);
1307 tmp_opt.mss_clamp = 536;
1308 tmp_opt.user_mss = tcp_sk(sk)->rx_opt.user_mss;
1309
1310 tcp_parse_options(skb, &tmp_opt, 0);
1311
1312 if (want_cookie) {
1313 tcp_clear_options(&tmp_opt);
1314 tmp_opt.saw_tstamp = 0;
1315 }
1316
1317 if (tmp_opt.saw_tstamp && !tmp_opt.rcv_tsval) {
1318 /* Some OSes (unknown ones, but I see them on web server, which
1319 * contains information interesting only for windows'
1320 * users) do not send their stamp in SYN. It is easy case.
1321 * We simply do not advertise TS support.
1322 */
1323 tmp_opt.saw_tstamp = 0;
1324 tmp_opt.tstamp_ok = 0;
1325 }
1326 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1327
1328 tcp_openreq_init(req, &tmp_opt, skb);
1329
1330 if (security_inet_conn_request(sk, skb, req))
1331 goto drop_and_free;
1332
1333 ireq = inet_rsk(req);
1334 ireq->loc_addr = daddr;
1335 ireq->rmt_addr = saddr;
1336 ireq->opt = tcp_v4_save_options(sk, skb);
1337 if (!want_cookie)
1338 TCP_ECN_create_request(req, tcp_hdr(skb));
1339
1340 if (want_cookie) {
1341 #ifdef CONFIG_SYN_COOKIES
1342 syn_flood_warning(skb);
1343 #endif
1344 isn = cookie_v4_init_sequence(sk, skb, &req->mss);
1345 } else if (!isn) {
1346 struct inet_peer *peer = NULL;
1347
1348 /* VJ's idea. We save last timestamp seen
1349 * from the destination in peer table, when entering
1350 * state TIME-WAIT, and check against it before
1351 * accepting new connection request.
1352 *
1353 * If "isn" is not zero, this request hit alive
1354 * timewait bucket, so that all the necessary checks
1355 * are made in the function processing timewait state.
1356 */
1357 if (tmp_opt.saw_tstamp &&
1358 tcp_death_row.sysctl_tw_recycle &&
1359 (dst = inet_csk_route_req(sk, req)) != NULL &&
1360 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1361 peer->v4daddr == saddr) {
1362 if (get_seconds() < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
1363 (s32)(peer->tcp_ts - req->ts_recent) >
1364 TCP_PAWS_WINDOW) {
1365 NET_INC_STATS_BH(LINUX_MIB_PAWSPASSIVEREJECTED);
1366 dst_release(dst);
1367 goto drop_and_free;
1368 }
1369 }
1370 /* Kill the following clause, if you dislike this way. */
1371 else if (!sysctl_tcp_syncookies &&
1372 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1373 (sysctl_max_syn_backlog >> 2)) &&
1374 (!peer || !peer->tcp_ts_stamp) &&
1375 (!dst || !dst_metric(dst, RTAX_RTT))) {
1376 /* Without syncookies last quarter of
1377 * backlog is filled with destinations,
1378 * proven to be alive.
1379 * It means that we continue to communicate
1380 * to destinations, already remembered
1381 * to the moment of synflood.
1382 */
1383 LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open "
1384 "request from %u.%u.%u.%u/%u\n",
1385 NIPQUAD(saddr),
1386 ntohs(tcp_hdr(skb)->source));
1387 dst_release(dst);
1388 goto drop_and_free;
1389 }
1390
1391 isn = tcp_v4_init_sequence(skb);
1392 }
1393 tcp_rsk(req)->snt_isn = isn;
1394
1395 if (tcp_v4_send_synack(sk, req, dst))
1396 goto drop_and_free;
1397
1398 if (want_cookie) {
1399 reqsk_free(req);
1400 } else {
1401 inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1402 }
1403 return 0;
1404
1405 drop_and_free:
1406 reqsk_free(req);
1407 drop:
1408 return 0;
1409 }
1410
1411
1412 /*
1413 * The three way handshake has completed - we got a valid synack -
1414 * now create the new socket.
1415 */
1416 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1417 struct request_sock *req,
1418 struct dst_entry *dst)
1419 {
1420 struct inet_request_sock *ireq;
1421 struct inet_sock *newinet;
1422 struct tcp_sock *newtp;
1423 struct sock *newsk;
1424 #ifdef CONFIG_TCP_MD5SIG
1425 struct tcp_md5sig_key *key;
1426 #endif
1427
1428 if (sk_acceptq_is_full(sk))
1429 goto exit_overflow;
1430
1431 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1432 goto exit;
1433
1434 newsk = tcp_create_openreq_child(sk, req, skb);
1435 if (!newsk)
1436 goto exit;
1437
1438 newsk->sk_gso_type = SKB_GSO_TCPV4;
1439 sk_setup_caps(newsk, dst);
1440
1441 newtp = tcp_sk(newsk);
1442 newinet = inet_sk(newsk);
1443 ireq = inet_rsk(req);
1444 newinet->daddr = ireq->rmt_addr;
1445 newinet->rcv_saddr = ireq->loc_addr;
1446 newinet->saddr = ireq->loc_addr;
1447 newinet->opt = ireq->opt;
1448 ireq->opt = NULL;
1449 newinet->mc_index = inet_iif(skb);
1450 newinet->mc_ttl = ip_hdr(skb)->ttl;
1451 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1452 if (newinet->opt)
1453 inet_csk(newsk)->icsk_ext_hdr_len = newinet->opt->optlen;
1454 newinet->id = newtp->write_seq ^ jiffies;
1455
1456 tcp_mtup_init(newsk);
1457 tcp_sync_mss(newsk, dst_mtu(dst));
1458 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1459 tcp_initialize_rcv_mss(newsk);
1460
1461 #ifdef CONFIG_TCP_MD5SIG
1462 /* Copy over the MD5 key from the original socket */
1463 if ((key = tcp_v4_md5_do_lookup(sk, newinet->daddr)) != NULL) {
1464 /*
1465 * We're using one, so create a matching key
1466 * on the newsk structure. If we fail to get
1467 * memory, then we end up not copying the key
1468 * across. Shucks.
1469 */
1470 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1471 if (newkey != NULL)
1472 tcp_v4_md5_do_add(newsk, inet_sk(sk)->daddr,
1473 newkey, key->keylen);
1474 }
1475 #endif
1476
1477 __inet_hash(&tcp_hashinfo, newsk, 0);
1478 __inet_inherit_port(&tcp_hashinfo, sk, newsk);
1479
1480 return newsk;
1481
1482 exit_overflow:
1483 NET_INC_STATS_BH(LINUX_MIB_LISTENOVERFLOWS);
1484 exit:
1485 NET_INC_STATS_BH(LINUX_MIB_LISTENDROPS);
1486 dst_release(dst);
1487 return NULL;
1488 }
1489
1490 static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1491 {
1492 struct tcphdr *th = tcp_hdr(skb);
1493 const struct iphdr *iph = ip_hdr(skb);
1494 struct sock *nsk;
1495 struct request_sock **prev;
1496 /* Find possible connection requests. */
1497 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1498 iph->saddr, iph->daddr);
1499 if (req)
1500 return tcp_check_req(sk, skb, req, prev);
1501
1502 nsk = inet_lookup_established(&tcp_hashinfo, iph->saddr, th->source,
1503 iph->daddr, th->dest, inet_iif(skb));
1504
1505 if (nsk) {
1506 if (nsk->sk_state != TCP_TIME_WAIT) {
1507 bh_lock_sock(nsk);
1508 return nsk;
1509 }
1510 inet_twsk_put(inet_twsk(nsk));
1511 return NULL;
1512 }
1513
1514 #ifdef CONFIG_SYN_COOKIES
1515 if (!th->rst && !th->syn && th->ack)
1516 sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));
1517 #endif
1518 return sk;
1519 }
1520
1521 static __sum16 tcp_v4_checksum_init(struct sk_buff *skb)
1522 {
1523 const struct iphdr *iph = ip_hdr(skb);
1524
1525 if (skb->ip_summed == CHECKSUM_COMPLETE) {
1526 if (!tcp_v4_check(skb->len, iph->saddr,
1527 iph->daddr, skb->csum)) {
1528 skb->ip_summed = CHECKSUM_UNNECESSARY;
1529 return 0;
1530 }
1531 }
1532
1533 skb->csum = csum_tcpudp_nofold(iph->saddr, iph->daddr,
1534 skb->len, IPPROTO_TCP, 0);
1535
1536 if (skb->len <= 76) {
1537 return __skb_checksum_complete(skb);
1538 }
1539 return 0;
1540 }
1541
1542
1543 /* The socket must have it's spinlock held when we get
1544 * here.
1545 *
1546 * We have a potential double-lock case here, so even when
1547 * doing backlog processing we use the BH locking scheme.
1548 * This is because we cannot sleep with the original spinlock
1549 * held.
1550 */
1551 int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)
1552 {
1553 struct sock *rsk;
1554 #ifdef CONFIG_TCP_MD5SIG
1555 /*
1556 * We really want to reject the packet as early as possible
1557 * if:
1558 * o We're expecting an MD5'd packet and this is no MD5 tcp option
1559 * o There is an MD5 option and we're not expecting one
1560 */
1561 if (tcp_v4_inbound_md5_hash(sk, skb))
1562 goto discard;
1563 #endif
1564
1565 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1566 TCP_CHECK_TIMER(sk);
1567 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {
1568 rsk = sk;
1569 goto reset;
1570 }
1571 TCP_CHECK_TIMER(sk);
1572 return 0;
1573 }
1574
1575 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1576 goto csum_err;
1577
1578 if (sk->sk_state == TCP_LISTEN) {
1579 struct sock *nsk = tcp_v4_hnd_req(sk, skb);
1580 if (!nsk)
1581 goto discard;
1582
1583 if (nsk != sk) {
1584 if (tcp_child_process(sk, nsk, skb)) {
1585 rsk = nsk;
1586 goto reset;
1587 }
1588 return 0;
1589 }
1590 }
1591
1592 TCP_CHECK_TIMER(sk);
1593 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {
1594 rsk = sk;
1595 goto reset;
1596 }
1597 TCP_CHECK_TIMER(sk);
1598 return 0;
1599
1600 reset:
1601 tcp_v4_send_reset(rsk, skb);
1602 discard:
1603 kfree_skb(skb);
1604 /* Be careful here. If this function gets more complicated and
1605 * gcc suffers from register pressure on the x86, sk (in %ebx)
1606 * might be destroyed here. This current version compiles correctly,
1607 * but you have been warned.
1608 */
1609 return 0;
1610
1611 csum_err:
1612 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1613 goto discard;
1614 }
1615
1616 /*
1617 * From tcp_input.c
1618 */
1619
1620 int tcp_v4_rcv(struct sk_buff *skb)
1621 {
1622 const struct iphdr *iph;
1623 struct tcphdr *th;
1624 struct sock *sk;
1625 int ret;
1626
1627 if (skb->pkt_type != PACKET_HOST)
1628 goto discard_it;
1629
1630 /* Count it even if it's bad */
1631 TCP_INC_STATS_BH(TCP_MIB_INSEGS);
1632
1633 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1634 goto discard_it;
1635
1636 th = tcp_hdr(skb);
1637
1638 if (th->doff < sizeof(struct tcphdr) / 4)
1639 goto bad_packet;
1640 if (!pskb_may_pull(skb, th->doff * 4))
1641 goto discard_it;
1642
1643 /* An explanation is required here, I think.
1644 * Packet length and doff are validated by header prediction,
1645 * provided case of th->doff==0 is eliminated.
1646 * So, we defer the checks. */
1647 if (!skb_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
1648 goto bad_packet;
1649
1650 th = tcp_hdr(skb);
1651 iph = ip_hdr(skb);
1652 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1653 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1654 skb->len - th->doff * 4);
1655 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1656 TCP_SKB_CB(skb)->when = 0;
1657 TCP_SKB_CB(skb)->flags = iph->tos;
1658 TCP_SKB_CB(skb)->sacked = 0;
1659
1660 sk = __inet_lookup(&tcp_hashinfo, iph->saddr, th->source,
1661 iph->daddr, th->dest, inet_iif(skb));
1662 if (!sk)
1663 goto no_tcp_socket;
1664
1665 process:
1666 if (sk->sk_state == TCP_TIME_WAIT)
1667 goto do_time_wait;
1668
1669 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1670 goto discard_and_relse;
1671 nf_reset(skb);
1672
1673 if (sk_filter(sk, skb))
1674 goto discard_and_relse;
1675
1676 skb->dev = NULL;
1677
1678 bh_lock_sock_nested(sk);
1679 ret = 0;
1680 if (!sock_owned_by_user(sk)) {
1681 #ifdef CONFIG_NET_DMA
1682 struct tcp_sock *tp = tcp_sk(sk);
1683 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1684 tp->ucopy.dma_chan = get_softnet_dma();
1685 if (tp->ucopy.dma_chan)
1686 ret = tcp_v4_do_rcv(sk, skb);
1687 else
1688 #endif
1689 {
1690 if (!tcp_prequeue(sk, skb))
1691 ret = tcp_v4_do_rcv(sk, skb);
1692 }
1693 } else
1694 sk_add_backlog(sk, skb);
1695 bh_unlock_sock(sk);
1696
1697 sock_put(sk);
1698
1699 return ret;
1700
1701 no_tcp_socket:
1702 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1703 goto discard_it;
1704
1705 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1706 bad_packet:
1707 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1708 } else {
1709 tcp_v4_send_reset(NULL, skb);
1710 }
1711
1712 discard_it:
1713 /* Discard frame. */
1714 kfree_skb(skb);
1715 return 0;
1716
1717 discard_and_relse:
1718 sock_put(sk);
1719 goto discard_it;
1720
1721 do_time_wait:
1722 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1723 inet_twsk_put(inet_twsk(sk));
1724 goto discard_it;
1725 }
1726
1727 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1728 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1729 inet_twsk_put(inet_twsk(sk));
1730 goto discard_it;
1731 }
1732 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1733 case TCP_TW_SYN: {
1734 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1735 iph->daddr, th->dest,
1736 inet_iif(skb));
1737 if (sk2) {
1738 inet_twsk_deschedule(inet_twsk(sk), &tcp_death_row);
1739 inet_twsk_put(inet_twsk(sk));
1740 sk = sk2;
1741 goto process;
1742 }
1743 /* Fall through to ACK */
1744 }
1745 case TCP_TW_ACK:
1746 tcp_v4_timewait_ack(sk, skb);
1747 break;
1748 case TCP_TW_RST:
1749 goto no_tcp_socket;
1750 case TCP_TW_SUCCESS:;
1751 }
1752 goto discard_it;
1753 }
1754
1755 /* VJ's idea. Save last timestamp seen from this destination
1756 * and hold it at least for normal timewait interval to use for duplicate
1757 * segment detection in subsequent connections, before they enter synchronized
1758 * state.
1759 */
1760
1761 int tcp_v4_remember_stamp(struct sock *sk)
1762 {
1763 struct inet_sock *inet = inet_sk(sk);
1764 struct tcp_sock *tp = tcp_sk(sk);
1765 struct rtable *rt = (struct rtable *)__sk_dst_get(sk);
1766 struct inet_peer *peer = NULL;
1767 int release_it = 0;
1768
1769 if (!rt || rt->rt_dst != inet->daddr) {
1770 peer = inet_getpeer(inet->daddr, 1);
1771 release_it = 1;
1772 } else {
1773 if (!rt->peer)
1774 rt_bind_peer(rt, 1);
1775 peer = rt->peer;
1776 }
1777
1778 if (peer) {
1779 if ((s32)(peer->tcp_ts - tp->rx_opt.ts_recent) <= 0 ||
1780 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
1781 peer->tcp_ts_stamp <= tp->rx_opt.ts_recent_stamp)) {
1782 peer->tcp_ts_stamp = tp->rx_opt.ts_recent_stamp;
1783 peer->tcp_ts = tp->rx_opt.ts_recent;
1784 }
1785 if (release_it)
1786 inet_putpeer(peer);
1787 return 1;
1788 }
1789
1790 return 0;
1791 }
1792
1793 int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw)
1794 {
1795 struct inet_peer *peer = inet_getpeer(tw->tw_daddr, 1);
1796
1797 if (peer) {
1798 const struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
1799
1800 if ((s32)(peer->tcp_ts - tcptw->tw_ts_recent) <= 0 ||
1801 (peer->tcp_ts_stamp + TCP_PAWS_MSL < get_seconds() &&
1802 peer->tcp_ts_stamp <= tcptw->tw_ts_recent_stamp)) {
1803 peer->tcp_ts_stamp = tcptw->tw_ts_recent_stamp;
1804 peer->tcp_ts = tcptw->tw_ts_recent;
1805 }
1806 inet_putpeer(peer);
1807 return 1;
1808 }
1809
1810 return 0;
1811 }
1812
1813 struct inet_connection_sock_af_ops ipv4_specific = {
1814 .queue_xmit = ip_queue_xmit,
1815 .send_check = tcp_v4_send_check,
1816 .rebuild_header = inet_sk_rebuild_header,
1817 .conn_request = tcp_v4_conn_request,
1818 .syn_recv_sock = tcp_v4_syn_recv_sock,
1819 .remember_stamp = tcp_v4_remember_stamp,
1820 .net_header_len = sizeof(struct iphdr),
1821 .setsockopt = ip_setsockopt,
1822 .getsockopt = ip_getsockopt,
1823 .addr2sockaddr = inet_csk_addr2sockaddr,
1824 .sockaddr_len = sizeof(struct sockaddr_in),
1825 #ifdef CONFIG_COMPAT
1826 .compat_setsockopt = compat_ip_setsockopt,
1827 .compat_getsockopt = compat_ip_getsockopt,
1828 #endif
1829 };
1830
1831 #ifdef CONFIG_TCP_MD5SIG
1832 static struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
1833 .md5_lookup = tcp_v4_md5_lookup,
1834 .calc_md5_hash = tcp_v4_calc_md5_hash,
1835 .md5_add = tcp_v4_md5_add_func,
1836 .md5_parse = tcp_v4_parse_md5_keys,
1837 };
1838 #endif
1839
1840 /* NOTE: A lot of things set to zero explicitly by call to
1841 * sk_alloc() so need not be done here.
1842 */
1843 static int tcp_v4_init_sock(struct sock *sk)
1844 {
1845 struct inet_connection_sock *icsk = inet_csk(sk);
1846 struct tcp_sock *tp = tcp_sk(sk);
1847
1848 skb_queue_head_init(&tp->out_of_order_queue);
1849 tcp_init_xmit_timers(sk);
1850 tcp_prequeue_init(tp);
1851
1852 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1853 tp->mdev = TCP_TIMEOUT_INIT;
1854
1855 /* So many TCP implementations out there (incorrectly) count the
1856 * initial SYN frame in their delayed-ACK and congestion control
1857 * algorithms that we must have the following bandaid to talk
1858 * efficiently to them. -DaveM
1859 */
1860 tp->snd_cwnd = 2;
1861
1862 /* See draft-stevens-tcpca-spec-01 for discussion of the
1863 * initialization of these values.
1864 */
1865 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1866 tp->snd_cwnd_clamp = ~0;
1867 tp->mss_cache = 536;
1868
1869 tp->reordering = sysctl_tcp_reordering;
1870 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1871
1872 sk->sk_state = TCP_CLOSE;
1873
1874 sk->sk_write_space = sk_stream_write_space;
1875 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1876
1877 icsk->icsk_af_ops = &ipv4_specific;
1878 icsk->icsk_sync_mss = tcp_sync_mss;
1879 #ifdef CONFIG_TCP_MD5SIG
1880 tp->af_specific = &tcp_sock_ipv4_specific;
1881 #endif
1882
1883 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1884 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1885
1886 atomic_inc(&tcp_sockets_allocated);
1887
1888 return 0;
1889 }
1890
1891 int tcp_v4_destroy_sock(struct sock *sk)
1892 {
1893 struct tcp_sock *tp = tcp_sk(sk);
1894
1895 tcp_clear_xmit_timers(sk);
1896
1897 tcp_cleanup_congestion_control(sk);
1898
1899 /* Cleanup up the write buffer. */
1900 tcp_write_queue_purge(sk);
1901
1902 /* Cleans up our, hopefully empty, out_of_order_queue. */
1903 __skb_queue_purge(&tp->out_of_order_queue);
1904
1905 #ifdef CONFIG_TCP_MD5SIG
1906 /* Clean up the MD5 key list, if any */
1907 if (tp->md5sig_info) {
1908 tcp_v4_clear_md5_list(sk);
1909 kfree(tp->md5sig_info);
1910 tp->md5sig_info = NULL;
1911 }
1912 #endif
1913
1914 #ifdef CONFIG_NET_DMA
1915 /* Cleans up our sk_async_wait_queue */
1916 __skb_queue_purge(&sk->sk_async_wait_queue);
1917 #endif
1918
1919 /* Clean prequeue, it must be empty really */
1920 __skb_queue_purge(&tp->ucopy.prequeue);
1921
1922 /* Clean up a referenced TCP bind bucket. */
1923 if (inet_csk(sk)->icsk_bind_hash)
1924 inet_put_port(&tcp_hashinfo, sk);
1925
1926 /*
1927 * If sendmsg cached page exists, toss it.
1928 */
1929 if (sk->sk_sndmsg_page) {
1930 __free_page(sk->sk_sndmsg_page);
1931 sk->sk_sndmsg_page = NULL;
1932 }
1933
1934 atomic_dec(&tcp_sockets_allocated);
1935
1936 return 0;
1937 }
1938
1939 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1940
1941 #ifdef CONFIG_PROC_FS
1942 /* Proc filesystem TCP sock list dumping. */
1943
1944 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1945 {
1946 return hlist_empty(head) ? NULL :
1947 list_entry(head->first, struct inet_timewait_sock, tw_node);
1948 }
1949
1950 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1951 {
1952 return tw->tw_node.next ?
1953 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1954 }
1955
1956 static void *listening_get_next(struct seq_file *seq, void *cur)
1957 {
1958 struct inet_connection_sock *icsk;
1959 struct hlist_node *node;
1960 struct sock *sk = cur;
1961 struct tcp_iter_state* st = seq->private;
1962
1963 if (!sk) {
1964 st->bucket = 0;
1965 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1966 goto get_sk;
1967 }
1968
1969 ++st->num;
1970
1971 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1972 struct request_sock *req = cur;
1973
1974 icsk = inet_csk(st->syn_wait_sk);
1975 req = req->dl_next;
1976 while (1) {
1977 while (req) {
1978 if (req->rsk_ops->family == st->family) {
1979 cur = req;
1980 goto out;
1981 }
1982 req = req->dl_next;
1983 }
1984 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
1985 break;
1986 get_req:
1987 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1988 }
1989 sk = sk_next(st->syn_wait_sk);
1990 st->state = TCP_SEQ_STATE_LISTENING;
1991 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1992 } else {
1993 icsk = inet_csk(sk);
1994 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1995 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1996 goto start_req;
1997 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1998 sk = sk_next(sk);
1999 }
2000 get_sk:
2001 sk_for_each_from(sk, node) {
2002 if (sk->sk_family == st->family) {
2003 cur = sk;
2004 goto out;
2005 }
2006 icsk = inet_csk(sk);
2007 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2008 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
2009 start_req:
2010 st->uid = sock_i_uid(sk);
2011 st->syn_wait_sk = sk;
2012 st->state = TCP_SEQ_STATE_OPENREQ;
2013 st->sbucket = 0;
2014 goto get_req;
2015 }
2016 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2017 }
2018 if (++st->bucket < INET_LHTABLE_SIZE) {
2019 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
2020 goto get_sk;
2021 }
2022 cur = NULL;
2023 out:
2024 return cur;
2025 }
2026
2027 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2028 {
2029 void *rc = listening_get_next(seq, NULL);
2030
2031 while (rc && *pos) {
2032 rc = listening_get_next(seq, rc);
2033 --*pos;
2034 }
2035 return rc;
2036 }
2037
2038 static void *established_get_first(struct seq_file *seq)
2039 {
2040 struct tcp_iter_state* st = seq->private;
2041 void *rc = NULL;
2042
2043 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
2044 struct sock *sk;
2045 struct hlist_node *node;
2046 struct inet_timewait_sock *tw;
2047
2048 read_lock_bh(&tcp_hashinfo.ehash[st->bucket].lock);
2049 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
2050 if (sk->sk_family != st->family) {
2051 continue;
2052 }
2053 rc = sk;
2054 goto out;
2055 }
2056 st->state = TCP_SEQ_STATE_TIME_WAIT;
2057 inet_twsk_for_each(tw, node,
2058 &tcp_hashinfo.ehash[st->bucket].twchain) {
2059 if (tw->tw_family != st->family) {
2060 continue;
2061 }
2062 rc = tw;
2063 goto out;
2064 }
2065 read_unlock_bh(&tcp_hashinfo.ehash[st->bucket].lock);
2066 st->state = TCP_SEQ_STATE_ESTABLISHED;
2067 }
2068 out:
2069 return rc;
2070 }
2071
2072 static void *established_get_next(struct seq_file *seq, void *cur)
2073 {
2074 struct sock *sk = cur;
2075 struct inet_timewait_sock *tw;
2076 struct hlist_node *node;
2077 struct tcp_iter_state* st = seq->private;
2078
2079 ++st->num;
2080
2081 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2082 tw = cur;
2083 tw = tw_next(tw);
2084 get_tw:
2085 while (tw && tw->tw_family != st->family) {
2086 tw = tw_next(tw);
2087 }
2088 if (tw) {
2089 cur = tw;
2090 goto out;
2091 }
2092 read_unlock_bh(&tcp_hashinfo.ehash[st->bucket].lock);
2093 st->state = TCP_SEQ_STATE_ESTABLISHED;
2094
2095 if (++st->bucket < tcp_hashinfo.ehash_size) {
2096 read_lock_bh(&tcp_hashinfo.ehash[st->bucket].lock);
2097 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
2098 } else {
2099 cur = NULL;
2100 goto out;
2101 }
2102 } else
2103 sk = sk_next(sk);
2104
2105 sk_for_each_from(sk, node) {
2106 if (sk->sk_family == st->family)
2107 goto found;
2108 }
2109
2110 st->state = TCP_SEQ_STATE_TIME_WAIT;
2111 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
2112 goto get_tw;
2113 found:
2114 cur = sk;
2115 out:
2116 return cur;
2117 }
2118
2119 static void *established_get_idx(struct seq_file *seq, loff_t pos)
2120 {
2121 void *rc = established_get_first(seq);
2122
2123 while (rc && pos) {
2124 rc = established_get_next(seq, rc);
2125 --pos;
2126 }
2127 return rc;
2128 }
2129
2130 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2131 {
2132 void *rc;
2133 struct tcp_iter_state* st = seq->private;
2134
2135 inet_listen_lock(&tcp_hashinfo);
2136 st->state = TCP_SEQ_STATE_LISTENING;
2137 rc = listening_get_idx(seq, &pos);
2138
2139 if (!rc) {
2140 inet_listen_unlock(&tcp_hashinfo);
2141 st->state = TCP_SEQ_STATE_ESTABLISHED;
2142 rc = established_get_idx(seq, pos);
2143 }
2144
2145 return rc;
2146 }
2147
2148 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2149 {
2150 struct tcp_iter_state* st = seq->private;
2151 st->state = TCP_SEQ_STATE_LISTENING;
2152 st->num = 0;
2153 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2154 }
2155
2156 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2157 {
2158 void *rc = NULL;
2159 struct tcp_iter_state* st;
2160
2161 if (v == SEQ_START_TOKEN) {
2162 rc = tcp_get_idx(seq, 0);
2163 goto out;
2164 }
2165 st = seq->private;
2166
2167 switch (st->state) {
2168 case TCP_SEQ_STATE_OPENREQ:
2169 case TCP_SEQ_STATE_LISTENING:
2170 rc = listening_get_next(seq, v);
2171 if (!rc) {
2172 inet_listen_unlock(&tcp_hashinfo);
2173 st->state = TCP_SEQ_STATE_ESTABLISHED;
2174 rc = established_get_first(seq);
2175 }
2176 break;
2177 case TCP_SEQ_STATE_ESTABLISHED:
2178 case TCP_SEQ_STATE_TIME_WAIT:
2179 rc = established_get_next(seq, v);
2180 break;
2181 }
2182 out:
2183 ++*pos;
2184 return rc;
2185 }
2186
2187 static void tcp_seq_stop(struct seq_file *seq, void *v)
2188 {
2189 struct tcp_iter_state* st = seq->private;
2190
2191 switch (st->state) {
2192 case TCP_SEQ_STATE_OPENREQ:
2193 if (v) {
2194 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2195 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2196 }
2197 case TCP_SEQ_STATE_LISTENING:
2198 if (v != SEQ_START_TOKEN)
2199 inet_listen_unlock(&tcp_hashinfo);
2200 break;
2201 case TCP_SEQ_STATE_TIME_WAIT:
2202 case TCP_SEQ_STATE_ESTABLISHED:
2203 if (v)
2204 read_unlock_bh(&tcp_hashinfo.ehash[st->bucket].lock);
2205 break;
2206 }
2207 }
2208
2209 static int tcp_seq_open(struct inode *inode, struct file *file)
2210 {
2211 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2212 struct seq_file *seq;
2213 struct tcp_iter_state *s;
2214 int rc;
2215
2216 if (unlikely(afinfo == NULL))
2217 return -EINVAL;
2218
2219 s = kzalloc(sizeof(*s), GFP_KERNEL);
2220 if (!s)
2221 return -ENOMEM;
2222 s->family = afinfo->family;
2223 s->seq_ops.start = tcp_seq_start;
2224 s->seq_ops.next = tcp_seq_next;
2225 s->seq_ops.show = afinfo->seq_show;
2226 s->seq_ops.stop = tcp_seq_stop;
2227
2228 rc = seq_open(file, &s->seq_ops);
2229 if (rc)
2230 goto out_kfree;
2231 seq = file->private_data;
2232 seq->private = s;
2233 out:
2234 return rc;
2235 out_kfree:
2236 kfree(s);
2237 goto out;
2238 }
2239
2240 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2241 {
2242 int rc = 0;
2243 struct proc_dir_entry *p;
2244
2245 if (!afinfo)
2246 return -EINVAL;
2247 afinfo->seq_fops->owner = afinfo->owner;
2248 afinfo->seq_fops->open = tcp_seq_open;
2249 afinfo->seq_fops->read = seq_read;
2250 afinfo->seq_fops->llseek = seq_lseek;
2251 afinfo->seq_fops->release = seq_release_private;
2252
2253 p = proc_net_fops_create(&init_net, afinfo->name, S_IRUGO, afinfo->seq_fops);
2254 if (p)
2255 p->data = afinfo;
2256 else
2257 rc = -ENOMEM;
2258 return rc;
2259 }
2260
2261 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2262 {
2263 if (!afinfo)
2264 return;
2265 proc_net_remove(&init_net, afinfo->name);
2266 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
2267 }
2268
2269 static void get_openreq4(struct sock *sk, struct request_sock *req,
2270 char *tmpbuf, int i, int uid)
2271 {
2272 const struct inet_request_sock *ireq = inet_rsk(req);
2273 int ttd = req->expires - jiffies;
2274
2275 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2276 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2277 i,
2278 ireq->loc_addr,
2279 ntohs(inet_sk(sk)->sport),
2280 ireq->rmt_addr,
2281 ntohs(ireq->rmt_port),
2282 TCP_SYN_RECV,
2283 0, 0, /* could print option size, but that is af dependent. */
2284 1, /* timers active (only the expire timer) */
2285 jiffies_to_clock_t(ttd),
2286 req->retrans,
2287 uid,
2288 0, /* non standard timer */
2289 0, /* open_requests have no inode */
2290 atomic_read(&sk->sk_refcnt),
2291 req);
2292 }
2293
2294 static void get_tcp4_sock(struct sock *sk, char *tmpbuf, int i)
2295 {
2296 int timer_active;
2297 unsigned long timer_expires;
2298 struct tcp_sock *tp = tcp_sk(sk);
2299 const struct inet_connection_sock *icsk = inet_csk(sk);
2300 struct inet_sock *inet = inet_sk(sk);
2301 __be32 dest = inet->daddr;
2302 __be32 src = inet->rcv_saddr;
2303 __u16 destp = ntohs(inet->dport);
2304 __u16 srcp = ntohs(inet->sport);
2305
2306 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2307 timer_active = 1;
2308 timer_expires = icsk->icsk_timeout;
2309 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2310 timer_active = 4;
2311 timer_expires = icsk->icsk_timeout;
2312 } else if (timer_pending(&sk->sk_timer)) {
2313 timer_active = 2;
2314 timer_expires = sk->sk_timer.expires;
2315 } else {
2316 timer_active = 0;
2317 timer_expires = jiffies;
2318 }
2319
2320 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2321 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2322 i, src, srcp, dest, destp, sk->sk_state,
2323 tp->write_seq - tp->snd_una,
2324 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
2325 (tp->rcv_nxt - tp->copied_seq),
2326 timer_active,
2327 jiffies_to_clock_t(timer_expires - jiffies),
2328 icsk->icsk_retransmits,
2329 sock_i_uid(sk),
2330 icsk->icsk_probes_out,
2331 sock_i_ino(sk),
2332 atomic_read(&sk->sk_refcnt), sk,
2333 icsk->icsk_rto,
2334 icsk->icsk_ack.ato,
2335 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
2336 tp->snd_cwnd,
2337 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2338 }
2339
2340 static void get_timewait4_sock(struct inet_timewait_sock *tw,
2341 char *tmpbuf, int i)
2342 {
2343 __be32 dest, src;
2344 __u16 destp, srcp;
2345 int ttd = tw->tw_ttd - jiffies;
2346
2347 if (ttd < 0)
2348 ttd = 0;
2349
2350 dest = tw->tw_daddr;
2351 src = tw->tw_rcv_saddr;
2352 destp = ntohs(tw->tw_dport);
2353 srcp = ntohs(tw->tw_sport);
2354
2355 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2356 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2357 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2358 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2359 atomic_read(&tw->tw_refcnt), tw);
2360 }
2361
2362 #define TMPSZ 150
2363
2364 static int tcp4_seq_show(struct seq_file *seq, void *v)
2365 {
2366 struct tcp_iter_state* st;
2367 char tmpbuf[TMPSZ + 1];
2368
2369 if (v == SEQ_START_TOKEN) {
2370 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2371 " sl local_address rem_address st tx_queue "
2372 "rx_queue tr tm->when retrnsmt uid timeout "
2373 "inode");
2374 goto out;
2375 }
2376 st = seq->private;
2377
2378 switch (st->state) {
2379 case TCP_SEQ_STATE_LISTENING:
2380 case TCP_SEQ_STATE_ESTABLISHED:
2381 get_tcp4_sock(v, tmpbuf, st->num);
2382 break;
2383 case TCP_SEQ_STATE_OPENREQ:
2384 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2385 break;
2386 case TCP_SEQ_STATE_TIME_WAIT:
2387 get_timewait4_sock(v, tmpbuf, st->num);
2388 break;
2389 }
2390 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2391 out:
2392 return 0;
2393 }
2394
2395 static struct file_operations tcp4_seq_fops;
2396 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2397 .owner = THIS_MODULE,
2398 .name = "tcp",
2399 .family = AF_INET,
2400 .seq_show = tcp4_seq_show,
2401 .seq_fops = &tcp4_seq_fops,
2402 };
2403
2404 int __init tcp4_proc_init(void)
2405 {
2406 return tcp_proc_register(&tcp4_seq_afinfo);
2407 }
2408
2409 void tcp4_proc_exit(void)
2410 {
2411 tcp_proc_unregister(&tcp4_seq_afinfo);
2412 }
2413 #endif /* CONFIG_PROC_FS */
2414
2415 struct proto tcp_prot = {
2416 .name = "TCP",
2417 .owner = THIS_MODULE,
2418 .close = tcp_close,
2419 .connect = tcp_v4_connect,
2420 .disconnect = tcp_disconnect,
2421 .accept = inet_csk_accept,
2422 .ioctl = tcp_ioctl,
2423 .init = tcp_v4_init_sock,
2424 .destroy = tcp_v4_destroy_sock,
2425 .shutdown = tcp_shutdown,
2426 .setsockopt = tcp_setsockopt,
2427 .getsockopt = tcp_getsockopt,
2428 .recvmsg = tcp_recvmsg,
2429 .backlog_rcv = tcp_v4_do_rcv,
2430 .hash = tcp_v4_hash,
2431 .unhash = tcp_unhash,
2432 .get_port = tcp_v4_get_port,
2433 .enter_memory_pressure = tcp_enter_memory_pressure,
2434 .sockets_allocated = &tcp_sockets_allocated,
2435 .orphan_count = &tcp_orphan_count,
2436 .memory_allocated = &tcp_memory_allocated,
2437 .memory_pressure = &tcp_memory_pressure,
2438 .sysctl_mem = sysctl_tcp_mem,
2439 .sysctl_wmem = sysctl_tcp_wmem,
2440 .sysctl_rmem = sysctl_tcp_rmem,
2441 .max_header = MAX_TCP_HEADER,
2442 .obj_size = sizeof(struct tcp_sock),
2443 .twsk_prot = &tcp_timewait_sock_ops,
2444 .rsk_prot = &tcp_request_sock_ops,
2445 #ifdef CONFIG_COMPAT
2446 .compat_setsockopt = compat_tcp_setsockopt,
2447 .compat_getsockopt = compat_tcp_getsockopt,
2448 #endif
2449 };
2450
2451 void __init tcp_v4_init(struct net_proto_family *ops)
2452 {
2453 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW,
2454 IPPROTO_TCP) < 0)
2455 panic("Failed to create the TCP control socket.\n");
2456 }
2457
2458 EXPORT_SYMBOL(ipv4_specific);
2459 EXPORT_SYMBOL(tcp_hashinfo);
2460 EXPORT_SYMBOL(tcp_prot);
2461 EXPORT_SYMBOL(tcp_unhash);
2462 EXPORT_SYMBOL(tcp_v4_conn_request);
2463 EXPORT_SYMBOL(tcp_v4_connect);
2464 EXPORT_SYMBOL(tcp_v4_do_rcv);
2465 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2466 EXPORT_SYMBOL(tcp_v4_send_check);
2467 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2468
2469 #ifdef CONFIG_PROC_FS
2470 EXPORT_SYMBOL(tcp_proc_register);
2471 EXPORT_SYMBOL(tcp_proc_unregister);
2472 #endif
2473 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2474
Verdex Pro support