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