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