]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - net/ipv4/tcp_ipv4.c
94d683a61cba45c04eb13c7882cb44bb91d0f96f
[~shefty/rdma-dev.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  *              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 }