~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ipv4/tcp_ipv4.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp