projects / deliverable / linux.git / blob
? search:


3b26f9586dcb7a30f278c84bb6a98858235cd7be
[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/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 unsigned 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 inline __u32 tcp_v4_init_sequence(struct sk_buff *skb)
112 {
113 return secure_tcp_sequence_number(ip_hdr(skb)->daddr,
114 ip_hdr(skb)->saddr,
115 tcp_hdr(skb)->dest,
116 tcp_hdr(skb)->source);
117 }
118
119 int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp)
120 {
121 const struct tcp_timewait_sock *tcptw = tcp_twsk(sktw);
122 struct tcp_sock *tp = tcp_sk(sk);
123
124 /* With PAWS, it is safe from the viewpoint
125 of data integrity. Even without PAWS it is safe provided sequence
126 spaces do not overlap i.e. at data rates <= 80Mbit/sec.
127
128 Actually, the idea is close to VJ's one, only timestamp cache is
129 held not per host, but per port pair and TW bucket is used as state
130 holder.
131
132 If TW bucket has been already destroyed we fall back to VJ's scheme
133 and use initial timestamp retrieved from peer table.
134 */
135 if (tcptw->tw_ts_recent_stamp &&
136 (twp == NULL || (sysctl_tcp_tw_reuse &&
137 get_seconds() - tcptw->tw_ts_recent_stamp > 1))) {
138 tp->write_seq = tcptw->tw_snd_nxt + 65535 + 2;
139 if (tp->write_seq == 0)
140 tp->write_seq = 1;
141 tp->rx_opt.ts_recent = tcptw->tw_ts_recent;
142 tp->rx_opt.ts_recent_stamp = tcptw->tw_ts_recent_stamp;
143 sock_hold(sktw);
144 return 1;
145 }
146
147 return 0;
148 }
149
150 EXPORT_SYMBOL_GPL(tcp_twsk_unique);
151
152 /* This will initiate an outgoing connection. */
153 int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
154 {
155 struct inet_sock *inet = inet_sk(sk);
156 struct tcp_sock *tp = tcp_sk(sk);
157 struct sockaddr_in *usin = (struct sockaddr_in *)uaddr;
158 struct rtable *rt;
159 __be32 daddr, nexthop;
160 int tmp;
161 int err;
162
163 if (addr_len < sizeof(struct sockaddr_in))
164 return -EINVAL;
165
166 if (usin->sin_family != AF_INET)
167 return -EAFNOSUPPORT;
168
169 nexthop = daddr = usin->sin_addr.s_addr;
170 if (inet->opt && inet->opt->srr) {
171 if (!daddr)
172 return -EINVAL;
173 nexthop = inet->opt->faddr;
174 }
175
176 tmp = ip_route_connect(&rt, nexthop, inet->saddr,
177 RT_CONN_FLAGS(sk), sk->sk_bound_dev_if,
178 IPPROTO_TCP,
179 inet->sport, usin->sin_port, sk, 1);
180 if (tmp < 0) {
181 if (tmp == -ENETUNREACH)
182 IP_INC_STATS_BH(IPSTATS_MIB_OUTNOROUTES);
183 return tmp;
184 }
185
186 if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
187 ip_rt_put(rt);
188 return -ENETUNREACH;
189 }
190
191 if (!inet->opt || !inet->opt->srr)
192 daddr = rt->rt_dst;
193
194 if (!inet->saddr)
195 inet->saddr = rt->rt_src;
196 inet->rcv_saddr = inet->saddr;
197
198 if (tp->rx_opt.ts_recent_stamp && inet->daddr != daddr) {
199 /* Reset inherited state */
200 tp->rx_opt.ts_recent = 0;
201 tp->rx_opt.ts_recent_stamp = 0;
202 tp->write_seq = 0;
203 }
204
205 if (tcp_death_row.sysctl_tw_recycle &&
206 !tp->rx_opt.ts_recent_stamp && rt->rt_dst == daddr) {
207 struct inet_peer *peer = rt_get_peer(rt);
208 /*
209 * VJ's idea. We save last timestamp seen from
210 * the destination in peer table, when entering state
211 * TIME-WAIT * and initialize rx_opt.ts_recent from it,
212 * when trying new connection.
213 */
214 if (peer != NULL &&
215 peer->tcp_ts_stamp + TCP_PAWS_MSL >= get_seconds()) {
216 tp->rx_opt.ts_recent_stamp = peer->tcp_ts_stamp;
217 tp->rx_opt.ts_recent = peer->tcp_ts;
218 }
219 }
220
221 inet->dport = usin->sin_port;
222 inet->daddr = daddr;
223
224 inet_csk(sk)->icsk_ext_hdr_len = 0;
225 if (inet->opt)
226 inet_csk(sk)->icsk_ext_hdr_len = inet->opt->optlen;
227
228 tp->rx_opt.mss_clamp = 536;
229
230 /* Socket identity is still unknown (sport may be zero).
231 * However we set state to SYN-SENT and not releasing socket
232 * lock select source port, enter ourselves into the hash tables and
233 * complete initialization after this.
234 */
235 tcp_set_state(sk, TCP_SYN_SENT);
236 err = inet_hash_connect(&tcp_death_row, sk);
237 if (err)
238 goto failure;
239
240 err = ip_route_newports(&rt, IPPROTO_TCP,
241 inet->sport, inet->dport, sk);
242 if (err)
243 goto failure;
244
245 /* OK, now commit destination to socket. */
246 sk->sk_gso_type = SKB_GSO_TCPV4;
247 sk_setup_caps(sk, &rt->u.dst);
248
249 if (!tp->write_seq)
250 tp->write_seq = secure_tcp_sequence_number(inet->saddr,
251 inet->daddr,
252 inet->sport,
253 usin->sin_port);
254
255 inet->id = tp->write_seq ^ jiffies;
256
257 err = tcp_connect(sk);
258 rt = NULL;
259 if (err)
260 goto failure;
261
262 return 0;
263
264 failure:
265 /*
266 * This unhashes the socket and releases the local port,
267 * if necessary.
268 */
269 tcp_set_state(sk, TCP_CLOSE);
270 ip_rt_put(rt);
271 sk->sk_route_caps = 0;
272 inet->dport = 0;
273 return err;
274 }
275
276 /*
277 * This routine does path mtu discovery as defined in RFC1191.
278 */
279 static void do_pmtu_discovery(struct sock *sk, struct iphdr *iph, u32 mtu)
280 {
281 struct dst_entry *dst;
282 struct inet_sock *inet = inet_sk(sk);
283
284 /* We are not interested in TCP_LISTEN and open_requests (SYN-ACKs
285 * send out by Linux are always <576bytes so they should go through
286 * unfragmented).
287 */
288 if (sk->sk_state == TCP_LISTEN)
289 return;
290
291 /* We don't check in the destentry if pmtu discovery is forbidden
292 * on this route. We just assume that no packet_to_big packets
293 * are send back when pmtu discovery is not active.
294 * There is a small race when the user changes this flag in the
295 * route, but I think that's acceptable.
296 */
297 if ((dst = __sk_dst_check(sk, 0)) == NULL)
298 return;
299
300 dst->ops->update_pmtu(dst, mtu);
301
302 /* Something is about to be wrong... Remember soft error
303 * for the case, if this connection will not able to recover.
304 */
305 if (mtu < dst_mtu(dst) && ip_dont_fragment(sk, dst))
306 sk->sk_err_soft = EMSGSIZE;
307
308 mtu = dst_mtu(dst);
309
310 if (inet->pmtudisc != IP_PMTUDISC_DONT &&
311 inet_csk(sk)->icsk_pmtu_cookie > mtu) {
312 tcp_sync_mss(sk, mtu);
313
314 /* Resend the TCP packet because it's
315 * clear that the old packet has been
316 * dropped. This is the new "fast" path mtu
317 * discovery.
318 */
319 tcp_simple_retransmit(sk);
320 } /* else let the usual retransmit timer handle it */
321 }
322
323 /*
324 * This routine is called by the ICMP module when it gets some
325 * sort of error condition. If err < 0 then the socket should
326 * be closed and the error returned to the user. If err > 0
327 * it's just the icmp type << 8 | icmp code. After adjustment
328 * header points to the first 8 bytes of the tcp header. We need
329 * to find the appropriate port.
330 *
331 * The locking strategy used here is very "optimistic". When
332 * someone else accesses the socket the ICMP is just dropped
333 * and for some paths there is no check at all.
334 * A more general error queue to queue errors for later handling
335 * is probably better.
336 *
337 */
338
339 void tcp_v4_err(struct sk_buff *skb, u32 info)
340 {
341 struct iphdr *iph = (struct iphdr *)skb->data;
342 struct tcphdr *th = (struct tcphdr *)(skb->data + (iph->ihl << 2));
343 struct tcp_sock *tp;
344 struct inet_sock *inet;
345 const int type = icmp_hdr(skb)->type;
346 const int code = icmp_hdr(skb)->code;
347 struct sock *sk;
348 __u32 seq;
349 int err;
350
351 if (skb->len < (iph->ihl << 2) + 8) {
352 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
353 return;
354 }
355
356 sk = inet_lookup(skb->dev->nd_net, &tcp_hashinfo, iph->daddr, th->dest,
357 iph->saddr, th->source, inet_iif(skb));
358 if (!sk) {
359 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
360 return;
361 }
362 if (sk->sk_state == TCP_TIME_WAIT) {
363 inet_twsk_put(inet_twsk(sk));
364 return;
365 }
366
367 bh_lock_sock(sk);
368 /* If too many ICMPs get dropped on busy
369 * servers this needs to be solved differently.
370 */
371 if (sock_owned_by_user(sk))
372 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
373
374 if (sk->sk_state == TCP_CLOSE)
375 goto out;
376
377 tp = tcp_sk(sk);
378 seq = ntohl(th->seq);
379 if (sk->sk_state != TCP_LISTEN &&
380 !between(seq, tp->snd_una, tp->snd_nxt)) {
381 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
382 goto out;
383 }
384
385 switch (type) {
386 case ICMP_SOURCE_QUENCH:
387 /* Just silently ignore these. */
388 goto out;
389 case ICMP_PARAMETERPROB:
390 err = EPROTO;
391 break;
392 case ICMP_DEST_UNREACH:
393 if (code > NR_ICMP_UNREACH)
394 goto out;
395
396 if (code == ICMP_FRAG_NEEDED) { /* PMTU discovery (RFC1191) */
397 if (!sock_owned_by_user(sk))
398 do_pmtu_discovery(sk, iph, info);
399 goto out;
400 }
401
402 err = icmp_err_convert[code].errno;
403 break;
404 case ICMP_TIME_EXCEEDED:
405 err = EHOSTUNREACH;
406 break;
407 default:
408 goto out;
409 }
410
411 switch (sk->sk_state) {
412 struct request_sock *req, **prev;
413 case TCP_LISTEN:
414 if (sock_owned_by_user(sk))
415 goto out;
416
417 req = inet_csk_search_req(sk, &prev, th->dest,
418 iph->daddr, iph->saddr);
419 if (!req)
420 goto out;
421
422 /* ICMPs are not backlogged, hence we cannot get
423 an established socket here.
424 */
425 BUG_TRAP(!req->sk);
426
427 if (seq != tcp_rsk(req)->snt_isn) {
428 NET_INC_STATS_BH(LINUX_MIB_OUTOFWINDOWICMPS);
429 goto out;
430 }
431
432 /*
433 * Still in SYN_RECV, just remove it silently.
434 * There is no good way to pass the error to the newly
435 * created socket, and POSIX does not want network
436 * errors returned from accept().
437 */
438 inet_csk_reqsk_queue_drop(sk, req, prev);
439 goto out;
440
441 case TCP_SYN_SENT:
442 case TCP_SYN_RECV: /* Cannot happen.
443 It can f.e. if SYNs crossed.
444 */
445 if (!sock_owned_by_user(sk)) {
446 sk->sk_err = err;
447
448 sk->sk_error_report(sk);
449
450 tcp_done(sk);
451 } else {
452 sk->sk_err_soft = err;
453 }
454 goto out;
455 }
456
457 /* If we've already connected we will keep trying
458 * until we time out, or the user gives up.
459 *
460 * rfc1122 4.2.3.9 allows to consider as hard errors
461 * only PROTO_UNREACH and PORT_UNREACH (well, FRAG_FAILED too,
462 * but it is obsoleted by pmtu discovery).
463 *
464 * Note, that in modern internet, where routing is unreliable
465 * and in each dark corner broken firewalls sit, sending random
466 * errors ordered by their masters even this two messages finally lose
467 * their original sense (even Linux sends invalid PORT_UNREACHs)
468 *
469 * Now we are in compliance with RFCs.
470 * --ANK (980905)
471 */
472
473 inet = inet_sk(sk);
474 if (!sock_owned_by_user(sk) && inet->recverr) {
475 sk->sk_err = err;
476 sk->sk_error_report(sk);
477 } else { /* Only an error on timeout */
478 sk->sk_err_soft = err;
479 }
480
481 out:
482 bh_unlock_sock(sk);
483 sock_put(sk);
484 }
485
486 /* This routine computes an IPv4 TCP checksum. */
487 void tcp_v4_send_check(struct sock *sk, int len, struct sk_buff *skb)
488 {
489 struct inet_sock *inet = inet_sk(sk);
490 struct tcphdr *th = tcp_hdr(skb);
491
492 if (skb->ip_summed == CHECKSUM_PARTIAL) {
493 th->check = ~tcp_v4_check(len, inet->saddr,
494 inet->daddr, 0);
495 skb->csum_start = skb_transport_header(skb) - skb->head;
496 skb->csum_offset = offsetof(struct tcphdr, check);
497 } else {
498 th->check = tcp_v4_check(len, inet->saddr, inet->daddr,
499 csum_partial((char *)th,
500 th->doff << 2,
501 skb->csum));
502 }
503 }
504
505 int tcp_v4_gso_send_check(struct sk_buff *skb)
506 {
507 const struct iphdr *iph;
508 struct tcphdr *th;
509
510 if (!pskb_may_pull(skb, sizeof(*th)))
511 return -EINVAL;
512
513 iph = ip_hdr(skb);
514 th = tcp_hdr(skb);
515
516 th->check = 0;
517 th->check = ~tcp_v4_check(skb->len, iph->saddr, iph->daddr, 0);
518 skb->csum_start = skb_transport_header(skb) - skb->head;
519 skb->csum_offset = offsetof(struct tcphdr, check);
520 skb->ip_summed = CHECKSUM_PARTIAL;
521 return 0;
522 }
523
524 /*
525 * This routine will send an RST to the other tcp.
526 *
527 * Someone asks: why I NEVER use socket parameters (TOS, TTL etc.)
528 * for reset.
529 * Answer: if a packet caused RST, it is not for a socket
530 * existing in our system, if it is matched to a socket,
531 * it is just duplicate segment or bug in other side's TCP.
532 * So that we build reply only basing on parameters
533 * arrived with segment.
534 * Exception: precedence violation. We do not implement it in any case.
535 */
536
537 static void tcp_v4_send_reset(struct sock *sk, struct sk_buff *skb)
538 {
539 struct tcphdr *th = tcp_hdr(skb);
540 struct {
541 struct tcphdr th;
542 #ifdef CONFIG_TCP_MD5SIG
543 __be32 opt[(TCPOLEN_MD5SIG_ALIGNED >> 2)];
544 #endif
545 } rep;
546 struct ip_reply_arg arg;
547 #ifdef CONFIG_TCP_MD5SIG
548 struct tcp_md5sig_key *key;
549 #endif
550
551 /* Never send a reset in response to a reset. */
552 if (th->rst)
553 return;
554
555 if (((struct rtable *)skb->dst)->rt_type != RTN_LOCAL)
556 return;
557
558 /* Swap the send and the receive. */
559 memset(&rep, 0, sizeof(rep));
560 rep.th.dest = th->source;
561 rep.th.source = th->dest;
562 rep.th.doff = sizeof(struct tcphdr) / 4;
563 rep.th.rst = 1;
564
565 if (th->ack) {
566 rep.th.seq = th->ack_seq;
567 } else {
568 rep.th.ack = 1;
569 rep.th.ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin +
570 skb->len - (th->doff << 2));
571 }
572
573 memset(&arg, 0, sizeof(arg));
574 arg.iov[0].iov_base = (unsigned char *)&rep;
575 arg.iov[0].iov_len = sizeof(rep.th);
576
577 #ifdef CONFIG_TCP_MD5SIG
578 key = sk ? tcp_v4_md5_do_lookup(sk, ip_hdr(skb)->daddr) : NULL;
579 if (key) {
580 rep.opt[0] = htonl((TCPOPT_NOP << 24) |
581 (TCPOPT_NOP << 16) |
582 (TCPOPT_MD5SIG << 8) |
583 TCPOLEN_MD5SIG);
584 /* Update length and the length the header thinks exists */
585 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
586 rep.th.doff = arg.iov[0].iov_len / 4;
587
588 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[1],
589 key,
590 ip_hdr(skb)->daddr,
591 ip_hdr(skb)->saddr,
592 &rep.th, IPPROTO_TCP,
593 arg.iov[0].iov_len);
594 }
595 #endif
596 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
597 ip_hdr(skb)->saddr, /* XXX */
598 sizeof(struct tcphdr), IPPROTO_TCP, 0);
599 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
600
601 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
602
603 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
604 TCP_INC_STATS_BH(TCP_MIB_OUTRSTS);
605 }
606
607 /* The code following below sending ACKs in SYN-RECV and TIME-WAIT states
608 outside socket context is ugly, certainly. What can I do?
609 */
610
611 static void tcp_v4_send_ack(struct tcp_timewait_sock *twsk,
612 struct sk_buff *skb, u32 seq, u32 ack,
613 u32 win, u32 ts)
614 {
615 struct tcphdr *th = tcp_hdr(skb);
616 struct {
617 struct tcphdr th;
618 __be32 opt[(TCPOLEN_TSTAMP_ALIGNED >> 2)
619 #ifdef CONFIG_TCP_MD5SIG
620 + (TCPOLEN_MD5SIG_ALIGNED >> 2)
621 #endif
622 ];
623 } rep;
624 struct ip_reply_arg arg;
625 #ifdef CONFIG_TCP_MD5SIG
626 struct tcp_md5sig_key *key;
627 struct tcp_md5sig_key tw_key;
628 #endif
629
630 memset(&rep.th, 0, sizeof(struct tcphdr));
631 memset(&arg, 0, sizeof(arg));
632
633 arg.iov[0].iov_base = (unsigned char *)&rep;
634 arg.iov[0].iov_len = sizeof(rep.th);
635 if (ts) {
636 rep.opt[0] = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
637 (TCPOPT_TIMESTAMP << 8) |
638 TCPOLEN_TIMESTAMP);
639 rep.opt[1] = htonl(tcp_time_stamp);
640 rep.opt[2] = htonl(ts);
641 arg.iov[0].iov_len += TCPOLEN_TSTAMP_ALIGNED;
642 }
643
644 /* Swap the send and the receive. */
645 rep.th.dest = th->source;
646 rep.th.source = th->dest;
647 rep.th.doff = arg.iov[0].iov_len / 4;
648 rep.th.seq = htonl(seq);
649 rep.th.ack_seq = htonl(ack);
650 rep.th.ack = 1;
651 rep.th.window = htons(win);
652
653 #ifdef CONFIG_TCP_MD5SIG
654 /*
655 * The SKB holds an imcoming packet, but may not have a valid ->sk
656 * pointer. This is especially the case when we're dealing with a
657 * TIME_WAIT ack, because the sk structure is long gone, and only
658 * the tcp_timewait_sock remains. So the md5 key is stashed in that
659 * structure, and we use it in preference. I believe that (twsk ||
660 * skb->sk) holds true, but we program defensively.
661 */
662 if (!twsk && skb->sk) {
663 key = tcp_v4_md5_do_lookup(skb->sk, ip_hdr(skb)->daddr);
664 } else if (twsk && twsk->tw_md5_keylen) {
665 tw_key.key = twsk->tw_md5_key;
666 tw_key.keylen = twsk->tw_md5_keylen;
667 key = &tw_key;
668 } else
669 key = NULL;
670
671 if (key) {
672 int offset = (ts) ? 3 : 0;
673
674 rep.opt[offset++] = htonl((TCPOPT_NOP << 24) |
675 (TCPOPT_NOP << 16) |
676 (TCPOPT_MD5SIG << 8) |
677 TCPOLEN_MD5SIG);
678 arg.iov[0].iov_len += TCPOLEN_MD5SIG_ALIGNED;
679 rep.th.doff = arg.iov[0].iov_len/4;
680
681 tcp_v4_do_calc_md5_hash((__u8 *)&rep.opt[offset],
682 key,
683 ip_hdr(skb)->daddr,
684 ip_hdr(skb)->saddr,
685 &rep.th, IPPROTO_TCP,
686 arg.iov[0].iov_len);
687 }
688 #endif
689 arg.csum = csum_tcpudp_nofold(ip_hdr(skb)->daddr,
690 ip_hdr(skb)->saddr, /* XXX */
691 arg.iov[0].iov_len, IPPROTO_TCP, 0);
692 arg.csumoffset = offsetof(struct tcphdr, check) / 2;
693 if (twsk)
694 arg.bound_dev_if = twsk->tw_sk.tw_bound_dev_if;
695
696 ip_send_reply(tcp_socket->sk, skb, &arg, arg.iov[0].iov_len);
697
698 TCP_INC_STATS_BH(TCP_MIB_OUTSEGS);
699 }
700
701 static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
702 {
703 struct inet_timewait_sock *tw = inet_twsk(sk);
704 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
705
706 tcp_v4_send_ack(tcptw, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
707 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
708 tcptw->tw_ts_recent);
709
710 inet_twsk_put(tw);
711 }
712
713 static void tcp_v4_reqsk_send_ack(struct sk_buff *skb,
714 struct request_sock *req)
715 {
716 tcp_v4_send_ack(NULL, skb, tcp_rsk(req)->snt_isn + 1,
717 tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
718 req->ts_recent);
719 }
720
721 /*
722 * Send a SYN-ACK after having received a SYN.
723 * This still operates on a request_sock only, not on a big
724 * socket.
725 */
726 static int __tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
727 struct dst_entry *dst)
728 {
729 const struct inet_request_sock *ireq = inet_rsk(req);
730 int err = -1;
731 struct sk_buff * skb;
732
733 /* First, grab a route. */
734 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
735 return -1;
736
737 skb = tcp_make_synack(sk, dst, req);
738
739 if (skb) {
740 struct tcphdr *th = tcp_hdr(skb);
741
742 th->check = tcp_v4_check(skb->len,
743 ireq->loc_addr,
744 ireq->rmt_addr,
745 csum_partial((char *)th, skb->len,
746 skb->csum));
747
748 err = ip_build_and_send_pkt(skb, sk, ireq->loc_addr,
749 ireq->rmt_addr,
750 ireq->opt);
751 err = net_xmit_eval(err);
752 }
753
754 dst_release(dst);
755 return err;
756 }
757
758 static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req)
759 {
760 return __tcp_v4_send_synack(sk, req, NULL);
761 }
762
763 /*
764 * IPv4 request_sock destructor.
765 */
766 static void tcp_v4_reqsk_destructor(struct request_sock *req)
767 {
768 kfree(inet_rsk(req)->opt);
769 }
770
771 #ifdef CONFIG_SYN_COOKIES
772 static void syn_flood_warning(struct sk_buff *skb)
773 {
774 static unsigned long warntime;
775
776 if (time_after(jiffies, (warntime + HZ * 60))) {
777 warntime = jiffies;
778 printk(KERN_INFO
779 "possible SYN flooding on port %d. Sending cookies.\n",
780 ntohs(tcp_hdr(skb)->dest));
781 }
782 }
783 #endif
784
785 /*
786 * Save and compile IPv4 options into the request_sock if needed.
787 */
788 static struct ip_options *tcp_v4_save_options(struct sock *sk,
789 struct sk_buff *skb)
790 {
791 struct ip_options *opt = &(IPCB(skb)->opt);
792 struct ip_options *dopt = NULL;
793
794 if (opt && opt->optlen) {
795 int opt_size = optlength(opt);
796 dopt = kmalloc(opt_size, GFP_ATOMIC);
797 if (dopt) {
798 if (ip_options_echo(dopt, skb)) {
799 kfree(dopt);
800 dopt = NULL;
801 }
802 }
803 }
804 return dopt;
805 }
806
807 #ifdef CONFIG_TCP_MD5SIG
808 /*
809 * RFC2385 MD5 checksumming requires a mapping of
810 * IP address->MD5 Key.
811 * We need to maintain these in the sk structure.
812 */
813
814 /* Find the Key structure for an address. */
815 static struct tcp_md5sig_key *
816 tcp_v4_md5_do_lookup(struct sock *sk, __be32 addr)
817 {
818 struct tcp_sock *tp = tcp_sk(sk);
819 int i;
820
821 if (!tp->md5sig_info || !tp->md5sig_info->entries4)
822 return NULL;
823 for (i = 0; i < tp->md5sig_info->entries4; i++) {
824 if (tp->md5sig_info->keys4[i].addr == addr)
825 return &tp->md5sig_info->keys4[i].base;
826 }
827 return NULL;
828 }
829
830 struct tcp_md5sig_key *tcp_v4_md5_lookup(struct sock *sk,
831 struct sock *addr_sk)
832 {
833 return tcp_v4_md5_do_lookup(sk, inet_sk(addr_sk)->daddr);
834 }
835
836 EXPORT_SYMBOL(tcp_v4_md5_lookup);
837
838 static struct tcp_md5sig_key *tcp_v4_reqsk_md5_lookup(struct sock *sk,
839 struct request_sock *req)
840 {
841 return tcp_v4_md5_do_lookup(sk, inet_rsk(req)->rmt_addr);
842 }
843
844 /* This can be called on a newly created socket, from other files */
845 int tcp_v4_md5_do_add(struct sock *sk, __be32 addr,
846 u8 *newkey, u8 newkeylen)
847 {
848 /* Add Key to the list */
849 struct tcp_md5sig_key *key;
850 struct tcp_sock *tp = tcp_sk(sk);
851 struct tcp4_md5sig_key *keys;
852
853 key = tcp_v4_md5_do_lookup(sk, addr);
854 if (key) {
855 /* Pre-existing entry - just update that one. */
856 kfree(key->key);
857 key->key = newkey;
858 key->keylen = newkeylen;
859 } else {
860 struct tcp_md5sig_info *md5sig;
861
862 if (!tp->md5sig_info) {
863 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info),
864 GFP_ATOMIC);
865 if (!tp->md5sig_info) {
866 kfree(newkey);
867 return -ENOMEM;
868 }
869 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
870 }
871 if (tcp_alloc_md5sig_pool() == NULL) {
872 kfree(newkey);
873 return -ENOMEM;
874 }
875 md5sig = tp->md5sig_info;
876
877 if (md5sig->alloced4 == md5sig->entries4) {
878 keys = kmalloc((sizeof(*keys) *
879 (md5sig->entries4 + 1)), GFP_ATOMIC);
880 if (!keys) {
881 kfree(newkey);
882 tcp_free_md5sig_pool();
883 return -ENOMEM;
884 }
885
886 if (md5sig->entries4)
887 memcpy(keys, md5sig->keys4,
888 sizeof(*keys) * md5sig->entries4);
889
890 /* Free old key list, and reference new one */
891 kfree(md5sig->keys4);
892 md5sig->keys4 = keys;
893 md5sig->alloced4++;
894 }
895 md5sig->entries4++;
896 md5sig->keys4[md5sig->entries4 - 1].addr = addr;
897 md5sig->keys4[md5sig->entries4 - 1].base.key = newkey;
898 md5sig->keys4[md5sig->entries4 - 1].base.keylen = newkeylen;
899 }
900 return 0;
901 }
902
903 EXPORT_SYMBOL(tcp_v4_md5_do_add);
904
905 static int tcp_v4_md5_add_func(struct sock *sk, struct sock *addr_sk,
906 u8 *newkey, u8 newkeylen)
907 {
908 return tcp_v4_md5_do_add(sk, inet_sk(addr_sk)->daddr,
909 newkey, newkeylen);
910 }
911
912 int tcp_v4_md5_do_del(struct sock *sk, __be32 addr)
913 {
914 struct tcp_sock *tp = tcp_sk(sk);
915 int i;
916
917 for (i = 0; i < tp->md5sig_info->entries4; i++) {
918 if (tp->md5sig_info->keys4[i].addr == addr) {
919 /* Free the key */
920 kfree(tp->md5sig_info->keys4[i].base.key);
921 tp->md5sig_info->entries4--;
922
923 if (tp->md5sig_info->entries4 == 0) {
924 kfree(tp->md5sig_info->keys4);
925 tp->md5sig_info->keys4 = NULL;
926 tp->md5sig_info->alloced4 = 0;
927 } else if (tp->md5sig_info->entries4 != i) {
928 /* Need to do some manipulation */
929 memmove(&tp->md5sig_info->keys4[i],
930 &tp->md5sig_info->keys4[i+1],
931 (tp->md5sig_info->entries4 - i) *
932 sizeof(struct tcp4_md5sig_key));
933 }
934 tcp_free_md5sig_pool();
935 return 0;
936 }
937 }
938 return -ENOENT;
939 }
940
941 EXPORT_SYMBOL(tcp_v4_md5_do_del);
942
943 static void tcp_v4_clear_md5_list(struct sock *sk)
944 {
945 struct tcp_sock *tp = tcp_sk(sk);
946
947 /* Free each key, then the set of key keys,
948 * the crypto element, and then decrement our
949 * hold on the last resort crypto.
950 */
951 if (tp->md5sig_info->entries4) {
952 int i;
953 for (i = 0; i < tp->md5sig_info->entries4; i++)
954 kfree(tp->md5sig_info->keys4[i].base.key);
955 tp->md5sig_info->entries4 = 0;
956 tcp_free_md5sig_pool();
957 }
958 if (tp->md5sig_info->keys4) {
959 kfree(tp->md5sig_info->keys4);
960 tp->md5sig_info->keys4 = NULL;
961 tp->md5sig_info->alloced4 = 0;
962 }
963 }
964
965 static int tcp_v4_parse_md5_keys(struct sock *sk, char __user *optval,
966 int optlen)
967 {
968 struct tcp_md5sig cmd;
969 struct sockaddr_in *sin = (struct sockaddr_in *)&cmd.tcpm_addr;
970 u8 *newkey;
971
972 if (optlen < sizeof(cmd))
973 return -EINVAL;
974
975 if (copy_from_user(&cmd, optval, sizeof(cmd)))
976 return -EFAULT;
977
978 if (sin->sin_family != AF_INET)
979 return -EINVAL;
980
981 if (!cmd.tcpm_key || !cmd.tcpm_keylen) {
982 if (!tcp_sk(sk)->md5sig_info)
983 return -ENOENT;
984 return tcp_v4_md5_do_del(sk, sin->sin_addr.s_addr);
985 }
986
987 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
988 return -EINVAL;
989
990 if (!tcp_sk(sk)->md5sig_info) {
991 struct tcp_sock *tp = tcp_sk(sk);
992 struct tcp_md5sig_info *p = kzalloc(sizeof(*p), GFP_KERNEL);
993
994 if (!p)
995 return -EINVAL;
996
997 tp->md5sig_info = p;
998 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
999 }
1000
1001 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
1002 if (!newkey)
1003 return -ENOMEM;
1004 return tcp_v4_md5_do_add(sk, sin->sin_addr.s_addr,
1005 newkey, cmd.tcpm_keylen);
1006 }
1007
1008 static int tcp_v4_do_calc_md5_hash(char *md5_hash, struct tcp_md5sig_key *key,
1009 __be32 saddr, __be32 daddr,
1010 struct tcphdr *th, int protocol,
1011 unsigned int tcplen)
1012 {
1013 struct scatterlist sg[4];
1014 __u16 data_len;
1015 int block = 0;
1016 __sum16 old_checksum;
1017 struct tcp_md5sig_pool *hp;
1018 struct tcp4_pseudohdr *bp;
1019 struct hash_desc *desc;
1020 int err;
1021 unsigned int nbytes = 0;
1022
1023 /*
1024 * Okay, so RFC2385 is turned on for this connection,
1025 * so we need to generate the MD5 hash for the packet now.
1026 */
1027
1028 hp = tcp_get_md5sig_pool();
1029 if (!hp)
1030 goto clear_hash_noput;
1031
1032 bp = &hp->md5_blk.ip4;
1033 desc = &hp->md5_desc;
1034
1035 /*
1036 * 1. the TCP pseudo-header (in the order: source IP address,
1037 * destination IP address, zero-padded protocol number, and
1038 * segment length)
1039 */
1040 bp->saddr = saddr;
1041 bp->daddr = daddr;
1042 bp->pad = 0;
1043 bp->protocol = protocol;
1044 bp->len = htons(tcplen);
1045
1046 sg_init_table(sg, 4);
1047
1048 sg_set_buf(&sg[block++], bp, sizeof(*bp));
1049 nbytes += sizeof(*bp);
1050
1051 /* 2. the TCP header, excluding options, and assuming a
1052 * checksum of zero/
1053 */
1054 old_checksum = th->check;
1055 th->check = 0;
1056 sg_set_buf(&sg[block++], th, sizeof(struct tcphdr));
1057 nbytes += sizeof(struct tcphdr);
1058
1059 /* 3. the TCP segment data (if any) */
1060 data_len = tcplen - (th->doff << 2);
1061 if (data_len > 0) {
1062 unsigned char *data = (unsigned char *)th + (th->doff << 2);
1063 sg_set_buf(&sg[block++], data, data_len);
1064 nbytes += data_len;
1065 }
1066
1067 /* 4. an independently-specified key or password, known to both
1068 * TCPs and presumably connection-specific
1069 */
1070 sg_set_buf(&sg[block++], key->key, key->keylen);
1071 nbytes += key->keylen;
1072
1073 sg_mark_end(&sg[block - 1]);
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 unsigned 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 = tcp_hdr(skb);
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, tcp_hdr(skb));
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(tcp_hdr(skb)->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_nolisten(newsk);
1470 __inet_inherit_port(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 = tcp_hdr(skb);
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(sk->sk_net, &tcp_hashinfo, iph->saddr,
1495 th->source, 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, tcp_hdr(skb), skb->len)) {
1560 rsk = sk;
1561 goto reset;
1562 }
1563 TCP_CHECK_TIMER(sk);
1564 return 0;
1565 }
1566
1567 if (skb->len < tcp_hdrlen(skb) || 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, tcp_hdr(skb), 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 = tcp_hdr(skb);
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_csum_unnecessary(skb) && tcp_v4_checksum_init(skb))
1640 goto bad_packet;
1641
1642 th = tcp_hdr(skb);
1643 iph = ip_hdr(skb);
1644 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1645 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1646 skb->len - th->doff * 4);
1647 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1648 TCP_SKB_CB(skb)->when = 0;
1649 TCP_SKB_CB(skb)->flags = iph->tos;
1650 TCP_SKB_CB(skb)->sacked = 0;
1651
1652 sk = __inet_lookup(skb->dev->nd_net, &tcp_hashinfo, iph->saddr,
1653 th->source, iph->daddr, th->dest, inet_iif(skb));
1654 if (!sk)
1655 goto no_tcp_socket;
1656
1657 process:
1658 if (sk->sk_state == TCP_TIME_WAIT)
1659 goto do_time_wait;
1660
1661 if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
1662 goto discard_and_relse;
1663 nf_reset(skb);
1664
1665 if (sk_filter(sk, skb))
1666 goto discard_and_relse;
1667
1668 skb->dev = NULL;
1669
1670 bh_lock_sock_nested(sk);
1671 ret = 0;
1672 if (!sock_owned_by_user(sk)) {
1673 #ifdef CONFIG_NET_DMA
1674 struct tcp_sock *tp = tcp_sk(sk);
1675 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1676 tp->ucopy.dma_chan = get_softnet_dma();
1677 if (tp->ucopy.dma_chan)
1678 ret = tcp_v4_do_rcv(sk, skb);
1679 else
1680 #endif
1681 {
1682 if (!tcp_prequeue(sk, skb))
1683 ret = tcp_v4_do_rcv(sk, skb);
1684 }
1685 } else
1686 sk_add_backlog(sk, skb);
1687 bh_unlock_sock(sk);
1688
1689 sock_put(sk);
1690
1691 return ret;
1692
1693 no_tcp_socket:
1694 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
1695 goto discard_it;
1696
1697 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1698 bad_packet:
1699 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1700 } else {
1701 tcp_v4_send_reset(NULL, skb);
1702 }
1703
1704 discard_it:
1705 /* Discard frame. */
1706 kfree_skb(skb);
1707 return 0;
1708
1709 discard_and_relse:
1710 sock_put(sk);
1711 goto discard_it;
1712
1713 do_time_wait:
1714 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1715 inet_twsk_put(inet_twsk(sk));
1716 goto discard_it;
1717 }
1718
1719 if (skb->len < (th->doff << 2) || tcp_checksum_complete(skb)) {
1720 TCP_INC_STATS_BH(TCP_MIB_INERRS);
1721 inet_twsk_put(inet_twsk(sk));
1722 goto discard_it;
1723 }
1724 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1725 case TCP_TW_SYN: {
1726 struct sock *sk2 = inet_lookup_listener(skb->dev->nd_net,
1727 &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 .bind_conflict = inet_csk_bind_conflict,
1819 #ifdef CONFIG_COMPAT
1820 .compat_setsockopt = compat_ip_setsockopt,
1821 .compat_getsockopt = compat_ip_getsockopt,
1822 #endif
1823 };
1824
1825 #ifdef CONFIG_TCP_MD5SIG
1826 static struct tcp_sock_af_ops tcp_sock_ipv4_specific = {
1827 .md5_lookup = tcp_v4_md5_lookup,
1828 .calc_md5_hash = tcp_v4_calc_md5_hash,
1829 .md5_add = tcp_v4_md5_add_func,
1830 .md5_parse = tcp_v4_parse_md5_keys,
1831 };
1832 #endif
1833
1834 /* NOTE: A lot of things set to zero explicitly by call to
1835 * sk_alloc() so need not be done here.
1836 */
1837 static int tcp_v4_init_sock(struct sock *sk)
1838 {
1839 struct inet_connection_sock *icsk = inet_csk(sk);
1840 struct tcp_sock *tp = tcp_sk(sk);
1841
1842 skb_queue_head_init(&tp->out_of_order_queue);
1843 tcp_init_xmit_timers(sk);
1844 tcp_prequeue_init(tp);
1845
1846 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1847 tp->mdev = TCP_TIMEOUT_INIT;
1848
1849 /* So many TCP implementations out there (incorrectly) count the
1850 * initial SYN frame in their delayed-ACK and congestion control
1851 * algorithms that we must have the following bandaid to talk
1852 * efficiently to them. -DaveM
1853 */
1854 tp->snd_cwnd = 2;
1855
1856 /* See draft-stevens-tcpca-spec-01 for discussion of the
1857 * initialization of these values.
1858 */
1859 tp->snd_ssthresh = 0x7fffffff; /* Infinity */
1860 tp->snd_cwnd_clamp = ~0;
1861 tp->mss_cache = 536;
1862
1863 tp->reordering = sysctl_tcp_reordering;
1864 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
1865
1866 sk->sk_state = TCP_CLOSE;
1867
1868 sk->sk_write_space = sk_stream_write_space;
1869 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1870
1871 icsk->icsk_af_ops = &ipv4_specific;
1872 icsk->icsk_sync_mss = tcp_sync_mss;
1873 #ifdef CONFIG_TCP_MD5SIG
1874 tp->af_specific = &tcp_sock_ipv4_specific;
1875 #endif
1876
1877 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1878 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1879
1880 atomic_inc(&tcp_sockets_allocated);
1881
1882 return 0;
1883 }
1884
1885 int tcp_v4_destroy_sock(struct sock *sk)
1886 {
1887 struct tcp_sock *tp = tcp_sk(sk);
1888
1889 tcp_clear_xmit_timers(sk);
1890
1891 tcp_cleanup_congestion_control(sk);
1892
1893 /* Cleanup up the write buffer. */
1894 tcp_write_queue_purge(sk);
1895
1896 /* Cleans up our, hopefully empty, out_of_order_queue. */
1897 __skb_queue_purge(&tp->out_of_order_queue);
1898
1899 #ifdef CONFIG_TCP_MD5SIG
1900 /* Clean up the MD5 key list, if any */
1901 if (tp->md5sig_info) {
1902 tcp_v4_clear_md5_list(sk);
1903 kfree(tp->md5sig_info);
1904 tp->md5sig_info = NULL;
1905 }
1906 #endif
1907
1908 #ifdef CONFIG_NET_DMA
1909 /* Cleans up our sk_async_wait_queue */
1910 __skb_queue_purge(&sk->sk_async_wait_queue);
1911 #endif
1912
1913 /* Clean prequeue, it must be empty really */
1914 __skb_queue_purge(&tp->ucopy.prequeue);
1915
1916 /* Clean up a referenced TCP bind bucket. */
1917 if (inet_csk(sk)->icsk_bind_hash)
1918 inet_put_port(sk);
1919
1920 /*
1921 * If sendmsg cached page exists, toss it.
1922 */
1923 if (sk->sk_sndmsg_page) {
1924 __free_page(sk->sk_sndmsg_page);
1925 sk->sk_sndmsg_page = NULL;
1926 }
1927
1928 atomic_dec(&tcp_sockets_allocated);
1929
1930 return 0;
1931 }
1932
1933 EXPORT_SYMBOL(tcp_v4_destroy_sock);
1934
1935 #ifdef CONFIG_PROC_FS
1936 /* Proc filesystem TCP sock list dumping. */
1937
1938 static inline struct inet_timewait_sock *tw_head(struct hlist_head *head)
1939 {
1940 return hlist_empty(head) ? NULL :
1941 list_entry(head->first, struct inet_timewait_sock, tw_node);
1942 }
1943
1944 static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1945 {
1946 return tw->tw_node.next ?
1947 hlist_entry(tw->tw_node.next, typeof(*tw), tw_node) : NULL;
1948 }
1949
1950 static void *listening_get_next(struct seq_file *seq, void *cur)
1951 {
1952 struct inet_connection_sock *icsk;
1953 struct hlist_node *node;
1954 struct sock *sk = cur;
1955 struct tcp_iter_state* st = seq->private;
1956
1957 if (!sk) {
1958 st->bucket = 0;
1959 sk = sk_head(&tcp_hashinfo.listening_hash[0]);
1960 goto get_sk;
1961 }
1962
1963 ++st->num;
1964
1965 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1966 struct request_sock *req = cur;
1967
1968 icsk = inet_csk(st->syn_wait_sk);
1969 req = req->dl_next;
1970 while (1) {
1971 while (req) {
1972 if (req->rsk_ops->family == st->family) {
1973 cur = req;
1974 goto out;
1975 }
1976 req = req->dl_next;
1977 }
1978 if (++st->sbucket >= icsk->icsk_accept_queue.listen_opt->nr_table_entries)
1979 break;
1980 get_req:
1981 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1982 }
1983 sk = sk_next(st->syn_wait_sk);
1984 st->state = TCP_SEQ_STATE_LISTENING;
1985 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1986 } else {
1987 icsk = inet_csk(sk);
1988 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1989 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1990 goto start_req;
1991 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1992 sk = sk_next(sk);
1993 }
1994 get_sk:
1995 sk_for_each_from(sk, node) {
1996 if (sk->sk_family == st->family) {
1997 cur = sk;
1998 goto out;
1999 }
2000 icsk = inet_csk(sk);
2001 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2002 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
2003 start_req:
2004 st->uid = sock_i_uid(sk);
2005 st->syn_wait_sk = sk;
2006 st->state = TCP_SEQ_STATE_OPENREQ;
2007 st->sbucket = 0;
2008 goto get_req;
2009 }
2010 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2011 }
2012 if (++st->bucket < INET_LHTABLE_SIZE) {
2013 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
2014 goto get_sk;
2015 }
2016 cur = NULL;
2017 out:
2018 return cur;
2019 }
2020
2021 static void *listening_get_idx(struct seq_file *seq, loff_t *pos)
2022 {
2023 void *rc = listening_get_next(seq, NULL);
2024
2025 while (rc && *pos) {
2026 rc = listening_get_next(seq, rc);
2027 --*pos;
2028 }
2029 return rc;
2030 }
2031
2032 static void *established_get_first(struct seq_file *seq)
2033 {
2034 struct tcp_iter_state* st = seq->private;
2035 void *rc = NULL;
2036
2037 for (st->bucket = 0; st->bucket < tcp_hashinfo.ehash_size; ++st->bucket) {
2038 struct sock *sk;
2039 struct hlist_node *node;
2040 struct inet_timewait_sock *tw;
2041 rwlock_t *lock = inet_ehash_lockp(&tcp_hashinfo, st->bucket);
2042
2043 read_lock_bh(lock);
2044 sk_for_each(sk, node, &tcp_hashinfo.ehash[st->bucket].chain) {
2045 if (sk->sk_family != st->family) {
2046 continue;
2047 }
2048 rc = sk;
2049 goto out;
2050 }
2051 st->state = TCP_SEQ_STATE_TIME_WAIT;
2052 inet_twsk_for_each(tw, node,
2053 &tcp_hashinfo.ehash[st->bucket].twchain) {
2054 if (tw->tw_family != st->family) {
2055 continue;
2056 }
2057 rc = tw;
2058 goto out;
2059 }
2060 read_unlock_bh(lock);
2061 st->state = TCP_SEQ_STATE_ESTABLISHED;
2062 }
2063 out:
2064 return rc;
2065 }
2066
2067 static void *established_get_next(struct seq_file *seq, void *cur)
2068 {
2069 struct sock *sk = cur;
2070 struct inet_timewait_sock *tw;
2071 struct hlist_node *node;
2072 struct tcp_iter_state* st = seq->private;
2073
2074 ++st->num;
2075
2076 if (st->state == TCP_SEQ_STATE_TIME_WAIT) {
2077 tw = cur;
2078 tw = tw_next(tw);
2079 get_tw:
2080 while (tw && tw->tw_family != st->family) {
2081 tw = tw_next(tw);
2082 }
2083 if (tw) {
2084 cur = tw;
2085 goto out;
2086 }
2087 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2088 st->state = TCP_SEQ_STATE_ESTABLISHED;
2089
2090 if (++st->bucket < tcp_hashinfo.ehash_size) {
2091 read_lock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2092 sk = sk_head(&tcp_hashinfo.ehash[st->bucket].chain);
2093 } else {
2094 cur = NULL;
2095 goto out;
2096 }
2097 } else
2098 sk = sk_next(sk);
2099
2100 sk_for_each_from(sk, node) {
2101 if (sk->sk_family == st->family)
2102 goto found;
2103 }
2104
2105 st->state = TCP_SEQ_STATE_TIME_WAIT;
2106 tw = tw_head(&tcp_hashinfo.ehash[st->bucket].twchain);
2107 goto get_tw;
2108 found:
2109 cur = sk;
2110 out:
2111 return cur;
2112 }
2113
2114 static void *established_get_idx(struct seq_file *seq, loff_t pos)
2115 {
2116 void *rc = established_get_first(seq);
2117
2118 while (rc && pos) {
2119 rc = established_get_next(seq, rc);
2120 --pos;
2121 }
2122 return rc;
2123 }
2124
2125 static void *tcp_get_idx(struct seq_file *seq, loff_t pos)
2126 {
2127 void *rc;
2128 struct tcp_iter_state* st = seq->private;
2129
2130 inet_listen_lock(&tcp_hashinfo);
2131 st->state = TCP_SEQ_STATE_LISTENING;
2132 rc = listening_get_idx(seq, &pos);
2133
2134 if (!rc) {
2135 inet_listen_unlock(&tcp_hashinfo);
2136 st->state = TCP_SEQ_STATE_ESTABLISHED;
2137 rc = established_get_idx(seq, pos);
2138 }
2139
2140 return rc;
2141 }
2142
2143 static void *tcp_seq_start(struct seq_file *seq, loff_t *pos)
2144 {
2145 struct tcp_iter_state* st = seq->private;
2146 st->state = TCP_SEQ_STATE_LISTENING;
2147 st->num = 0;
2148 return *pos ? tcp_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2149 }
2150
2151 static void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2152 {
2153 void *rc = NULL;
2154 struct tcp_iter_state* st;
2155
2156 if (v == SEQ_START_TOKEN) {
2157 rc = tcp_get_idx(seq, 0);
2158 goto out;
2159 }
2160 st = seq->private;
2161
2162 switch (st->state) {
2163 case TCP_SEQ_STATE_OPENREQ:
2164 case TCP_SEQ_STATE_LISTENING:
2165 rc = listening_get_next(seq, v);
2166 if (!rc) {
2167 inet_listen_unlock(&tcp_hashinfo);
2168 st->state = TCP_SEQ_STATE_ESTABLISHED;
2169 rc = established_get_first(seq);
2170 }
2171 break;
2172 case TCP_SEQ_STATE_ESTABLISHED:
2173 case TCP_SEQ_STATE_TIME_WAIT:
2174 rc = established_get_next(seq, v);
2175 break;
2176 }
2177 out:
2178 ++*pos;
2179 return rc;
2180 }
2181
2182 static void tcp_seq_stop(struct seq_file *seq, void *v)
2183 {
2184 struct tcp_iter_state* st = seq->private;
2185
2186 switch (st->state) {
2187 case TCP_SEQ_STATE_OPENREQ:
2188 if (v) {
2189 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
2190 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
2191 }
2192 case TCP_SEQ_STATE_LISTENING:
2193 if (v != SEQ_START_TOKEN)
2194 inet_listen_unlock(&tcp_hashinfo);
2195 break;
2196 case TCP_SEQ_STATE_TIME_WAIT:
2197 case TCP_SEQ_STATE_ESTABLISHED:
2198 if (v)
2199 read_unlock_bh(inet_ehash_lockp(&tcp_hashinfo, st->bucket));
2200 break;
2201 }
2202 }
2203
2204 static int tcp_seq_open(struct inode *inode, struct file *file)
2205 {
2206 struct tcp_seq_afinfo *afinfo = PDE(inode)->data;
2207 struct seq_file *seq;
2208 struct tcp_iter_state *s;
2209 int rc;
2210
2211 if (unlikely(afinfo == NULL))
2212 return -EINVAL;
2213
2214 s = kzalloc(sizeof(*s), GFP_KERNEL);
2215 if (!s)
2216 return -ENOMEM;
2217 s->family = afinfo->family;
2218 s->seq_ops.start = tcp_seq_start;
2219 s->seq_ops.next = tcp_seq_next;
2220 s->seq_ops.show = afinfo->seq_show;
2221 s->seq_ops.stop = tcp_seq_stop;
2222
2223 rc = seq_open(file, &s->seq_ops);
2224 if (rc)
2225 goto out_kfree;
2226 seq = file->private_data;
2227 seq->private = s;
2228 out:
2229 return rc;
2230 out_kfree:
2231 kfree(s);
2232 goto out;
2233 }
2234
2235 int tcp_proc_register(struct tcp_seq_afinfo *afinfo)
2236 {
2237 int rc = 0;
2238 struct proc_dir_entry *p;
2239
2240 if (!afinfo)
2241 return -EINVAL;
2242 afinfo->seq_fops->owner = afinfo->owner;
2243 afinfo->seq_fops->open = tcp_seq_open;
2244 afinfo->seq_fops->read = seq_read;
2245 afinfo->seq_fops->llseek = seq_lseek;
2246 afinfo->seq_fops->release = seq_release_private;
2247
2248 p = proc_net_fops_create(&init_net, afinfo->name, S_IRUGO, afinfo->seq_fops);
2249 if (p)
2250 p->data = afinfo;
2251 else
2252 rc = -ENOMEM;
2253 return rc;
2254 }
2255
2256 void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
2257 {
2258 if (!afinfo)
2259 return;
2260 proc_net_remove(&init_net, afinfo->name);
2261 memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops));
2262 }
2263
2264 static void get_openreq4(struct sock *sk, struct request_sock *req,
2265 char *tmpbuf, int i, int uid)
2266 {
2267 const struct inet_request_sock *ireq = inet_rsk(req);
2268 int ttd = req->expires - jiffies;
2269
2270 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2271 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %u %d %p",
2272 i,
2273 ireq->loc_addr,
2274 ntohs(inet_sk(sk)->sport),
2275 ireq->rmt_addr,
2276 ntohs(ireq->rmt_port),
2277 TCP_SYN_RECV,
2278 0, 0, /* could print option size, but that is af dependent. */
2279 1, /* timers active (only the expire timer) */
2280 jiffies_to_clock_t(ttd),
2281 req->retrans,
2282 uid,
2283 0, /* non standard timer */
2284 0, /* open_requests have no inode */
2285 atomic_read(&sk->sk_refcnt),
2286 req);
2287 }
2288
2289 static void get_tcp4_sock(struct sock *sk, char *tmpbuf, int i)
2290 {
2291 int timer_active;
2292 unsigned long timer_expires;
2293 struct tcp_sock *tp = tcp_sk(sk);
2294 const struct inet_connection_sock *icsk = inet_csk(sk);
2295 struct inet_sock *inet = inet_sk(sk);
2296 __be32 dest = inet->daddr;
2297 __be32 src = inet->rcv_saddr;
2298 __u16 destp = ntohs(inet->dport);
2299 __u16 srcp = ntohs(inet->sport);
2300
2301 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2302 timer_active = 1;
2303 timer_expires = icsk->icsk_timeout;
2304 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2305 timer_active = 4;
2306 timer_expires = icsk->icsk_timeout;
2307 } else if (timer_pending(&sk->sk_timer)) {
2308 timer_active = 2;
2309 timer_expires = sk->sk_timer.expires;
2310 } else {
2311 timer_active = 0;
2312 timer_expires = jiffies;
2313 }
2314
2315 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2316 "%08X %5d %8d %lu %d %p %u %u %u %u %d",
2317 i, src, srcp, dest, destp, sk->sk_state,
2318 tp->write_seq - tp->snd_una,
2319 sk->sk_state == TCP_LISTEN ? sk->sk_ack_backlog :
2320 (tp->rcv_nxt - tp->copied_seq),
2321 timer_active,
2322 jiffies_to_clock_t(timer_expires - jiffies),
2323 icsk->icsk_retransmits,
2324 sock_i_uid(sk),
2325 icsk->icsk_probes_out,
2326 sock_i_ino(sk),
2327 atomic_read(&sk->sk_refcnt), sk,
2328 icsk->icsk_rto,
2329 icsk->icsk_ack.ato,
2330 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
2331 tp->snd_cwnd,
2332 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2333 }
2334
2335 static void get_timewait4_sock(struct inet_timewait_sock *tw,
2336 char *tmpbuf, int i)
2337 {
2338 __be32 dest, src;
2339 __u16 destp, srcp;
2340 int ttd = tw->tw_ttd - jiffies;
2341
2342 if (ttd < 0)
2343 ttd = 0;
2344
2345 dest = tw->tw_daddr;
2346 src = tw->tw_rcv_saddr;
2347 destp = ntohs(tw->tw_dport);
2348 srcp = ntohs(tw->tw_sport);
2349
2350 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X"
2351 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p",
2352 i, src, srcp, dest, destp, tw->tw_substate, 0, 0,
2353 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2354 atomic_read(&tw->tw_refcnt), tw);
2355 }
2356
2357 #define TMPSZ 150
2358
2359 static int tcp4_seq_show(struct seq_file *seq, void *v)
2360 {
2361 struct tcp_iter_state* st;
2362 char tmpbuf[TMPSZ + 1];
2363
2364 if (v == SEQ_START_TOKEN) {
2365 seq_printf(seq, "%-*s\n", TMPSZ - 1,
2366 " sl local_address rem_address st tx_queue "
2367 "rx_queue tr tm->when retrnsmt uid timeout "
2368 "inode");
2369 goto out;
2370 }
2371 st = seq->private;
2372
2373 switch (st->state) {
2374 case TCP_SEQ_STATE_LISTENING:
2375 case TCP_SEQ_STATE_ESTABLISHED:
2376 get_tcp4_sock(v, tmpbuf, st->num);
2377 break;
2378 case TCP_SEQ_STATE_OPENREQ:
2379 get_openreq4(st->syn_wait_sk, v, tmpbuf, st->num, st->uid);
2380 break;
2381 case TCP_SEQ_STATE_TIME_WAIT:
2382 get_timewait4_sock(v, tmpbuf, st->num);
2383 break;
2384 }
2385 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
2386 out:
2387 return 0;
2388 }
2389
2390 static struct file_operations tcp4_seq_fops;
2391 static struct tcp_seq_afinfo tcp4_seq_afinfo = {
2392 .owner = THIS_MODULE,
2393 .name = "tcp",
2394 .family = AF_INET,
2395 .seq_show = tcp4_seq_show,
2396 .seq_fops = &tcp4_seq_fops,
2397 };
2398
2399 int __init tcp4_proc_init(void)
2400 {
2401 return tcp_proc_register(&tcp4_seq_afinfo);
2402 }
2403
2404 void tcp4_proc_exit(void)
2405 {
2406 tcp_proc_unregister(&tcp4_seq_afinfo);
2407 }
2408 #endif /* CONFIG_PROC_FS */
2409
2410 DEFINE_PROTO_INUSE(tcp)
2411
2412 struct proto tcp_prot = {
2413 .name = "TCP",
2414 .owner = THIS_MODULE,
2415 .close = tcp_close,
2416 .connect = tcp_v4_connect,
2417 .disconnect = tcp_disconnect,
2418 .accept = inet_csk_accept,
2419 .ioctl = tcp_ioctl,
2420 .init = tcp_v4_init_sock,
2421 .destroy = tcp_v4_destroy_sock,
2422 .shutdown = tcp_shutdown,
2423 .setsockopt = tcp_setsockopt,
2424 .getsockopt = tcp_getsockopt,
2425 .recvmsg = tcp_recvmsg,
2426 .backlog_rcv = tcp_v4_do_rcv,
2427 .hash = inet_hash,
2428 .unhash = inet_unhash,
2429 .get_port = inet_csk_get_port,
2430 .enter_memory_pressure = tcp_enter_memory_pressure,
2431 .sockets_allocated = &tcp_sockets_allocated,
2432 .orphan_count = &tcp_orphan_count,
2433 .memory_allocated = &tcp_memory_allocated,
2434 .memory_pressure = &tcp_memory_pressure,
2435 .sysctl_mem = sysctl_tcp_mem,
2436 .sysctl_wmem = sysctl_tcp_wmem,
2437 .sysctl_rmem = sysctl_tcp_rmem,
2438 .max_header = MAX_TCP_HEADER,
2439 .obj_size = sizeof(struct tcp_sock),
2440 .twsk_prot = &tcp_timewait_sock_ops,
2441 .rsk_prot = &tcp_request_sock_ops,
2442 .hashinfo = &tcp_hashinfo,
2443 #ifdef CONFIG_COMPAT
2444 .compat_setsockopt = compat_tcp_setsockopt,
2445 .compat_getsockopt = compat_tcp_getsockopt,
2446 #endif
2447 REF_PROTO_INUSE(tcp)
2448 };
2449
2450 void __init tcp_v4_init(void)
2451 {
2452 if (inet_csk_ctl_sock_create(&tcp_socket, PF_INET, SOCK_RAW,
2453 IPPROTO_TCP) < 0)
2454 panic("Failed to create the TCP control socket.\n");
2455 }
2456
2457 EXPORT_SYMBOL(ipv4_specific);
2458 EXPORT_SYMBOL(tcp_hashinfo);
2459 EXPORT_SYMBOL(tcp_prot);
2460 EXPORT_SYMBOL(tcp_v4_conn_request);
2461 EXPORT_SYMBOL(tcp_v4_connect);
2462 EXPORT_SYMBOL(tcp_v4_do_rcv);
2463 EXPORT_SYMBOL(tcp_v4_remember_stamp);
2464 EXPORT_SYMBOL(tcp_v4_send_check);
2465 EXPORT_SYMBOL(tcp_v4_syn_recv_sock);
2466
2467 #ifdef CONFIG_PROC_FS
2468 EXPORT_SYMBOL(tcp_proc_register);
2469 EXPORT_SYMBOL(tcp_proc_unregister);
2470 #endif
2471 EXPORT_SYMBOL(sysctl_tcp_low_latency);
2472
Linux kernel - Deliverables
This page took 0.077664 seconds and 4 git commands to generate.