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

TOMOYO Linux Cross Reference
Linux/net/ipv6/tcp_ipv6.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ 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.85 ] ~ [ 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-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  *      TCP over IPv6
  3  *      Linux INET6 implementation
  4  *
  5  *      Authors:
  6  *      Pedro Roque             <roque@di.fc.ul.pt>
  7  *
  8  *      Based on:
  9  *      linux/net/ipv4/tcp.c
 10  *      linux/net/ipv4/tcp_input.c
 11  *      linux/net/ipv4/tcp_output.c
 12  *
 13  *      Fixes:
 14  *      Hideaki YOSHIFUJI       :       sin6_scope_id support
 15  *      YOSHIFUJI Hideaki @USAGI and:   Support IPV6_V6ONLY socket option, which
 16  *      Alexey Kuznetsov                allow both IPv4 and IPv6 sockets to bind
 17  *                                      a single port at the same time.
 18  *      YOSHIFUJI Hideaki @USAGI:       convert /proc/net/tcp6 to seq_file.
 19  *
 20  *      This program is free software; you can redistribute it and/or
 21  *      modify it under the terms of the GNU General Public License
 22  *      as published by the Free Software Foundation; either version
 23  *      2 of the License, or (at your option) any later version.
 24  */
 25 
 26 #include <linux/bottom_half.h>
 27 #include <linux/module.h>
 28 #include <linux/errno.h>
 29 #include <linux/types.h>
 30 #include <linux/socket.h>
 31 #include <linux/sockios.h>
 32 #include <linux/net.h>
 33 #include <linux/jiffies.h>
 34 #include <linux/in.h>
 35 #include <linux/in6.h>
 36 #include <linux/netdevice.h>
 37 #include <linux/init.h>
 38 #include <linux/jhash.h>
 39 #include <linux/ipsec.h>
 40 #include <linux/times.h>
 41 #include <linux/slab.h>
 42 
 43 #include <linux/ipv6.h>
 44 #include <linux/icmpv6.h>
 45 #include <linux/random.h>
 46 
 47 #include <net/tcp.h>
 48 #include <net/ndisc.h>
 49 #include <net/inet6_hashtables.h>
 50 #include <net/inet6_connection_sock.h>
 51 #include <net/ipv6.h>
 52 #include <net/transp_v6.h>
 53 #include <net/addrconf.h>
 54 #include <net/ip6_route.h>
 55 #include <net/ip6_checksum.h>
 56 #include <net/inet_ecn.h>
 57 #include <net/protocol.h>
 58 #include <net/xfrm.h>
 59 #include <net/snmp.h>
 60 #include <net/dsfield.h>
 61 #include <net/timewait_sock.h>
 62 #include <net/netdma.h>
 63 #include <net/inet_common.h>
 64 #include <net/secure_seq.h>
 65 #include <net/tcp_memcontrol.h>
 66 #include <net/busy_poll.h>
 67 
 68 #include <asm/uaccess.h>
 69 
 70 #include <linux/proc_fs.h>
 71 #include <linux/seq_file.h>
 72 
 73 #include <linux/crypto.h>
 74 #include <linux/scatterlist.h>
 75 
 76 static void     tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
 77 static void     tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
 78                                       struct request_sock *req);
 79 
 80 static int      tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
 81 
 82 static const struct inet_connection_sock_af_ops ipv6_mapped;
 83 static const struct inet_connection_sock_af_ops ipv6_specific;
 84 #ifdef CONFIG_TCP_MD5SIG
 85 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;
 86 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
 87 #else
 88 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
 89                                                    const struct in6_addr *addr)
 90 {
 91         return NULL;
 92 }
 93 #endif
 94 
 95 static void inet6_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb)
 96 {
 97         struct dst_entry *dst = skb_dst(skb);
 98         const struct rt6_info *rt = (const struct rt6_info *)dst;
 99 
100         dst_hold(dst);
101         sk->sk_rx_dst = dst;
102         inet_sk(sk)->rx_dst_ifindex = skb->skb_iif;
103         if (rt->rt6i_node)
104                 inet6_sk(sk)->rx_dst_cookie = rt->rt6i_node->fn_sernum;
105 }
106 
107 static void tcp_v6_hash(struct sock *sk)
108 {
109         if (sk->sk_state != TCP_CLOSE) {
110                 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
111                         tcp_prot.hash(sk);
112                         return;
113                 }
114                 local_bh_disable();
115                 __inet6_hash(sk, NULL);
116                 local_bh_enable();
117         }
118 }
119 
120 static __u32 tcp_v6_init_sequence(const struct sk_buff *skb)
121 {
122         return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
123                                             ipv6_hdr(skb)->saddr.s6_addr32,
124                                             tcp_hdr(skb)->dest,
125                                             tcp_hdr(skb)->source);
126 }
127 
128 static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
129                           int addr_len)
130 {
131         struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
132         struct inet_sock *inet = inet_sk(sk);
133         struct inet_connection_sock *icsk = inet_csk(sk);
134         struct ipv6_pinfo *np = inet6_sk(sk);
135         struct tcp_sock *tp = tcp_sk(sk);
136         struct in6_addr *saddr = NULL, *final_p, final;
137         struct rt6_info *rt;
138         struct flowi6 fl6;
139         struct dst_entry *dst;
140         int addr_type;
141         int err;
142 
143         if (addr_len < SIN6_LEN_RFC2133)
144                 return -EINVAL;
145 
146         if (usin->sin6_family != AF_INET6)
147                 return -EAFNOSUPPORT;
148 
149         memset(&fl6, 0, sizeof(fl6));
150 
151         if (np->sndflow) {
152                 fl6.flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
153                 IP6_ECN_flow_init(fl6.flowlabel);
154                 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
155                         struct ip6_flowlabel *flowlabel;
156                         flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
157                         if (flowlabel == NULL)
158                                 return -EINVAL;
159                         fl6_sock_release(flowlabel);
160                 }
161         }
162 
163         /*
164          *      connect() to INADDR_ANY means loopback (BSD'ism).
165          */
166 
167         if(ipv6_addr_any(&usin->sin6_addr))
168                 usin->sin6_addr.s6_addr[15] = 0x1;
169 
170         addr_type = ipv6_addr_type(&usin->sin6_addr);
171 
172         if(addr_type & IPV6_ADDR_MULTICAST)
173                 return -ENETUNREACH;
174 
175         if (addr_type&IPV6_ADDR_LINKLOCAL) {
176                 if (addr_len >= sizeof(struct sockaddr_in6) &&
177                     usin->sin6_scope_id) {
178                         /* If interface is set while binding, indices
179                          * must coincide.
180                          */
181                         if (sk->sk_bound_dev_if &&
182                             sk->sk_bound_dev_if != usin->sin6_scope_id)
183                                 return -EINVAL;
184 
185                         sk->sk_bound_dev_if = usin->sin6_scope_id;
186                 }
187 
188                 /* Connect to link-local address requires an interface */
189                 if (!sk->sk_bound_dev_if)
190                         return -EINVAL;
191         }
192 
193         if (tp->rx_opt.ts_recent_stamp &&
194             !ipv6_addr_equal(&sk->sk_v6_daddr, &usin->sin6_addr)) {
195                 tp->rx_opt.ts_recent = 0;
196                 tp->rx_opt.ts_recent_stamp = 0;
197                 tp->write_seq = 0;
198         }
199 
200         sk->sk_v6_daddr = usin->sin6_addr;
201         np->flow_label = fl6.flowlabel;
202 
203         /*
204          *      TCP over IPv4
205          */
206 
207         if (addr_type == IPV6_ADDR_MAPPED) {
208                 u32 exthdrlen = icsk->icsk_ext_hdr_len;
209                 struct sockaddr_in sin;
210 
211                 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
212 
213                 if (__ipv6_only_sock(sk))
214                         return -ENETUNREACH;
215 
216                 sin.sin_family = AF_INET;
217                 sin.sin_port = usin->sin6_port;
218                 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
219 
220                 icsk->icsk_af_ops = &ipv6_mapped;
221                 sk->sk_backlog_rcv = tcp_v4_do_rcv;
222 #ifdef CONFIG_TCP_MD5SIG
223                 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
224 #endif
225 
226                 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
227 
228                 if (err) {
229                         icsk->icsk_ext_hdr_len = exthdrlen;
230                         icsk->icsk_af_ops = &ipv6_specific;
231                         sk->sk_backlog_rcv = tcp_v6_do_rcv;
232 #ifdef CONFIG_TCP_MD5SIG
233                         tp->af_specific = &tcp_sock_ipv6_specific;
234 #endif
235                         goto failure;
236                 } else {
237                         ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
238                         ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
239                                                &sk->sk_v6_rcv_saddr);
240                 }
241 
242                 return err;
243         }
244 
245         if (!ipv6_addr_any(&sk->sk_v6_rcv_saddr))
246                 saddr = &sk->sk_v6_rcv_saddr;
247 
248         fl6.flowi6_proto = IPPROTO_TCP;
249         fl6.daddr = sk->sk_v6_daddr;
250         fl6.saddr = saddr ? *saddr : np->saddr;
251         fl6.flowi6_oif = sk->sk_bound_dev_if;
252         fl6.flowi6_mark = sk->sk_mark;
253         fl6.fl6_dport = usin->sin6_port;
254         fl6.fl6_sport = inet->inet_sport;
255 
256         final_p = fl6_update_dst(&fl6, np->opt, &final);
257 
258         security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
259 
260         dst = ip6_dst_lookup_flow(sk, &fl6, final_p, true);
261         if (IS_ERR(dst)) {
262                 err = PTR_ERR(dst);
263                 goto failure;
264         }
265 
266         if (saddr == NULL) {
267                 saddr = &fl6.saddr;
268                 sk->sk_v6_rcv_saddr = *saddr;
269         }
270 
271         /* set the source address */
272         np->saddr = *saddr;
273         inet->inet_rcv_saddr = LOOPBACK4_IPV6;
274 
275         sk->sk_gso_type = SKB_GSO_TCPV6;
276         __ip6_dst_store(sk, dst, NULL, NULL);
277 
278         rt = (struct rt6_info *) dst;
279         if (tcp_death_row.sysctl_tw_recycle &&
280             !tp->rx_opt.ts_recent_stamp &&
281             ipv6_addr_equal(&rt->rt6i_dst.addr, &sk->sk_v6_daddr))
282                 tcp_fetch_timewait_stamp(sk, dst);
283 
284         icsk->icsk_ext_hdr_len = 0;
285         if (np->opt)
286                 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
287                                           np->opt->opt_nflen);
288 
289         tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
290 
291         inet->inet_dport = usin->sin6_port;
292 
293         tcp_set_state(sk, TCP_SYN_SENT);
294         err = inet6_hash_connect(&tcp_death_row, sk);
295         if (err)
296                 goto late_failure;
297 
298         if (!tp->write_seq && likely(!tp->repair))
299                 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
300                                                              sk->sk_v6_daddr.s6_addr32,
301                                                              inet->inet_sport,
302                                                              inet->inet_dport);
303 
304         err = tcp_connect(sk);
305         if (err)
306                 goto late_failure;
307 
308         return 0;
309 
310 late_failure:
311         tcp_set_state(sk, TCP_CLOSE);
312         __sk_dst_reset(sk);
313 failure:
314         inet->inet_dport = 0;
315         sk->sk_route_caps = 0;
316         return err;
317 }
318 
319 static void tcp_v6_mtu_reduced(struct sock *sk)
320 {
321         struct dst_entry *dst;
322 
323         if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
324                 return;
325 
326         dst = inet6_csk_update_pmtu(sk, tcp_sk(sk)->mtu_info);
327         if (!dst)
328                 return;
329 
330         if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
331                 tcp_sync_mss(sk, dst_mtu(dst));
332                 tcp_simple_retransmit(sk);
333         }
334 }
335 
336 static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
337                 u8 type, u8 code, int offset, __be32 info)
338 {
339         const struct ipv6hdr *hdr = (const struct ipv6hdr*)skb->data;
340         const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
341         struct ipv6_pinfo *np;
342         struct sock *sk;
343         int err;
344         struct tcp_sock *tp;
345         __u32 seq;
346         struct net *net = dev_net(skb->dev);
347 
348         sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
349                         th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
350 
351         if (sk == NULL) {
352                 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
353                                    ICMP6_MIB_INERRORS);
354                 return;
355         }
356 
357         if (sk->sk_state == TCP_TIME_WAIT) {
358                 inet_twsk_put(inet_twsk(sk));
359                 return;
360         }
361 
362         bh_lock_sock(sk);
363         if (sock_owned_by_user(sk) && type != ICMPV6_PKT_TOOBIG)
364                 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
365 
366         if (sk->sk_state == TCP_CLOSE)
367                 goto out;
368 
369         if (ipv6_hdr(skb)->hop_limit < inet6_sk(sk)->min_hopcount) {
370                 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
371                 goto out;
372         }
373 
374         tp = tcp_sk(sk);
375         seq = ntohl(th->seq);
376         if (sk->sk_state != TCP_LISTEN &&
377             !between(seq, tp->snd_una, tp->snd_nxt)) {
378                 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
379                 goto out;
380         }
381 
382         np = inet6_sk(sk);
383 
384         if (type == NDISC_REDIRECT) {
385                 struct dst_entry *dst = __sk_dst_check(sk, np->dst_cookie);
386 
387                 if (dst)
388                         dst->ops->redirect(dst, sk, skb);
389                 goto out;
390         }
391 
392         if (type == ICMPV6_PKT_TOOBIG) {
393                 /* We are not interested in TCP_LISTEN and open_requests
394                  * (SYN-ACKs send out by Linux are always <576bytes so
395                  * they should go through unfragmented).
396                  */
397                 if (sk->sk_state == TCP_LISTEN)
398                         goto out;
399 
400                 tp->mtu_info = ntohl(info);
401                 if (!sock_owned_by_user(sk))
402                         tcp_v6_mtu_reduced(sk);
403                 else if (!test_and_set_bit(TCP_MTU_REDUCED_DEFERRED,
404                                            &tp->tsq_flags))
405                         sock_hold(sk);
406                 goto out;
407         }
408 
409         icmpv6_err_convert(type, code, &err);
410 
411         /* Might be for an request_sock */
412         switch (sk->sk_state) {
413                 struct request_sock *req, **prev;
414         case TCP_LISTEN:
415                 if (sock_owned_by_user(sk))
416                         goto out;
417 
418                 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
419                                            &hdr->saddr, inet6_iif(skb));
420                 if (!req)
421                         goto out;
422 
423                 /* ICMPs are not backlogged, hence we cannot get
424                  * an established socket here.
425                  */
426                 WARN_ON(req->sk != NULL);
427 
428                 if (seq != tcp_rsk(req)->snt_isn) {
429                         NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
430                         goto out;
431                 }
432 
433                 inet_csk_reqsk_queue_drop(sk, req, prev);
434                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
435                 goto out;
436 
437         case TCP_SYN_SENT:
438         case TCP_SYN_RECV:  /* Cannot happen.
439                                It can, it SYNs are crossed. --ANK */
440                 if (!sock_owned_by_user(sk)) {
441                         sk->sk_err = err;
442                         sk->sk_error_report(sk);                /* Wake people up to see the error (see connect in sock.c) */
443 
444                         tcp_done(sk);
445                 } else
446                         sk->sk_err_soft = err;
447                 goto out;
448         }
449 
450         if (!sock_owned_by_user(sk) && np->recverr) {
451                 sk->sk_err = err;
452                 sk->sk_error_report(sk);
453         } else
454                 sk->sk_err_soft = err;
455 
456 out:
457         bh_unlock_sock(sk);
458         sock_put(sk);
459 }
460 
461 
462 static int tcp_v6_send_synack(struct sock *sk, struct dst_entry *dst,
463                               struct flowi6 *fl6,
464                               struct request_sock *req,
465                               u16 queue_mapping)
466 {
467         struct inet_request_sock *ireq = inet_rsk(req);
468         struct ipv6_pinfo *np = inet6_sk(sk);
469         struct sk_buff * skb;
470         int err = -ENOMEM;
471 
472         /* First, grab a route. */
473         if (!dst && (dst = inet6_csk_route_req(sk, fl6, req)) == NULL)
474                 goto done;
475 
476         skb = tcp_make_synack(sk, dst, req, NULL);
477 
478         if (skb) {
479                 __tcp_v6_send_check(skb, &ireq->ir_v6_loc_addr,
480                                     &ireq->ir_v6_rmt_addr);
481 
482                 fl6->daddr = ireq->ir_v6_rmt_addr;
483                 skb_set_queue_mapping(skb, queue_mapping);
484                 err = ip6_xmit(sk, skb, fl6, np->opt, np->tclass);
485                 err = net_xmit_eval(err);
486         }
487 
488 done:
489         return err;
490 }
491 
492 static int tcp_v6_rtx_synack(struct sock *sk, struct request_sock *req)
493 {
494         struct flowi6 fl6;
495         int res;
496 
497         res = tcp_v6_send_synack(sk, NULL, &fl6, req, 0);
498         if (!res)
499                 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_RETRANSSEGS);
500         return res;
501 }
502 
503 static void tcp_v6_reqsk_destructor(struct request_sock *req)
504 {
505         kfree_skb(inet_rsk(req)->pktopts);
506 }
507 
508 #ifdef CONFIG_TCP_MD5SIG
509 static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
510                                                    const struct in6_addr *addr)
511 {
512         return tcp_md5_do_lookup(sk, (union tcp_md5_addr *)addr, AF_INET6);
513 }
514 
515 static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
516                                                 struct sock *addr_sk)
517 {
518         return tcp_v6_md5_do_lookup(sk, &addr_sk->sk_v6_daddr);
519 }
520 
521 static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
522                                                       struct request_sock *req)
523 {
524         return tcp_v6_md5_do_lookup(sk, &inet_rsk(req)->ir_v6_rmt_addr);
525 }
526 
527 static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
528                                   int optlen)
529 {
530         struct tcp_md5sig cmd;
531         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
532 
533         if (optlen < sizeof(cmd))
534                 return -EINVAL;
535 
536         if (copy_from_user(&cmd, optval, sizeof(cmd)))
537                 return -EFAULT;
538 
539         if (sin6->sin6_family != AF_INET6)
540                 return -EINVAL;
541 
542         if (!cmd.tcpm_keylen) {
543                 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
544                         return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
545                                               AF_INET);
546                 return tcp_md5_do_del(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
547                                       AF_INET6);
548         }
549 
550         if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
551                 return -EINVAL;
552 
553         if (ipv6_addr_v4mapped(&sin6->sin6_addr))
554                 return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3],
555                                       AF_INET, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
556 
557         return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr,
558                               AF_INET6, cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
559 }
560 
561 static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
562                                         const struct in6_addr *daddr,
563                                         const struct in6_addr *saddr, int nbytes)
564 {
565         struct tcp6_pseudohdr *bp;
566         struct scatterlist sg;
567 
568         bp = &hp->md5_blk.ip6;
569         /* 1. TCP pseudo-header (RFC2460) */
570         bp->saddr = *saddr;
571         bp->daddr = *daddr;
572         bp->protocol = cpu_to_be32(IPPROTO_TCP);
573         bp->len = cpu_to_be32(nbytes);
574 
575         sg_init_one(&sg, bp, sizeof(*bp));
576         return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
577 }
578 
579 static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
580                                const struct in6_addr *daddr, struct in6_addr *saddr,
581                                const struct tcphdr *th)
582 {
583         struct tcp_md5sig_pool *hp;
584         struct hash_desc *desc;
585 
586         hp = tcp_get_md5sig_pool();
587         if (!hp)
588                 goto clear_hash_noput;
589         desc = &hp->md5_desc;
590 
591         if (crypto_hash_init(desc))
592                 goto clear_hash;
593         if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
594                 goto clear_hash;
595         if (tcp_md5_hash_header(hp, th))
596                 goto clear_hash;
597         if (tcp_md5_hash_key(hp, key))
598                 goto clear_hash;
599         if (crypto_hash_final(desc, md5_hash))
600                 goto clear_hash;
601 
602         tcp_put_md5sig_pool();
603         return 0;
604 
605 clear_hash:
606         tcp_put_md5sig_pool();
607 clear_hash_noput:
608         memset(md5_hash, 0, 16);
609         return 1;
610 }
611 
612 static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
613                                const struct sock *sk,
614                                const struct request_sock *req,
615                                const struct sk_buff *skb)
616 {
617         const struct in6_addr *saddr, *daddr;
618         struct tcp_md5sig_pool *hp;
619         struct hash_desc *desc;
620         const struct tcphdr *th = tcp_hdr(skb);
621 
622         if (sk) {
623                 saddr = &inet6_sk(sk)->saddr;
624                 daddr = &sk->sk_v6_daddr;
625         } else if (req) {
626                 saddr = &inet_rsk(req)->ir_v6_loc_addr;
627                 daddr = &inet_rsk(req)->ir_v6_rmt_addr;
628         } else {
629                 const struct ipv6hdr *ip6h = ipv6_hdr(skb);
630                 saddr = &ip6h->saddr;
631                 daddr = &ip6h->daddr;
632         }
633 
634         hp = tcp_get_md5sig_pool();
635         if (!hp)
636                 goto clear_hash_noput;
637         desc = &hp->md5_desc;
638 
639         if (crypto_hash_init(desc))
640                 goto clear_hash;
641 
642         if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
643                 goto clear_hash;
644         if (tcp_md5_hash_header(hp, th))
645                 goto clear_hash;
646         if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
647                 goto clear_hash;
648         if (tcp_md5_hash_key(hp, key))
649                 goto clear_hash;
650         if (crypto_hash_final(desc, md5_hash))
651                 goto clear_hash;
652 
653         tcp_put_md5sig_pool();
654         return 0;
655 
656 clear_hash:
657         tcp_put_md5sig_pool();
658 clear_hash_noput:
659         memset(md5_hash, 0, 16);
660         return 1;
661 }
662 
663 static int tcp_v6_inbound_md5_hash(struct sock *sk, const struct sk_buff *skb)
664 {
665         const __u8 *hash_location = NULL;
666         struct tcp_md5sig_key *hash_expected;
667         const struct ipv6hdr *ip6h = ipv6_hdr(skb);
668         const struct tcphdr *th = tcp_hdr(skb);
669         int genhash;
670         u8 newhash[16];
671 
672         hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
673         hash_location = tcp_parse_md5sig_option(th);
674 
675         /* We've parsed the options - do we have a hash? */
676         if (!hash_expected && !hash_location)
677                 return 0;
678 
679         if (hash_expected && !hash_location) {
680                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
681                 return 1;
682         }
683 
684         if (!hash_expected && hash_location) {
685                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
686                 return 1;
687         }
688 
689         /* check the signature */
690         genhash = tcp_v6_md5_hash_skb(newhash,
691                                       hash_expected,
692                                       NULL, NULL, skb);
693 
694         if (genhash || memcmp(hash_location, newhash, 16) != 0) {
695                 net_info_ratelimited("MD5 Hash %s for [%pI6c]:%u->[%pI6c]:%u\n",
696                                      genhash ? "failed" : "mismatch",
697                                      &ip6h->saddr, ntohs(th->source),
698                                      &ip6h->daddr, ntohs(th->dest));
699                 return 1;
700         }
701         return 0;
702 }
703 #endif
704 
705 struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
706         .family         =       AF_INET6,
707         .obj_size       =       sizeof(struct tcp6_request_sock),
708         .rtx_syn_ack    =       tcp_v6_rtx_synack,
709         .send_ack       =       tcp_v6_reqsk_send_ack,
710         .destructor     =       tcp_v6_reqsk_destructor,
711         .send_reset     =       tcp_v6_send_reset,
712         .syn_ack_timeout =      tcp_syn_ack_timeout,
713 };
714 
715 #ifdef CONFIG_TCP_MD5SIG
716 static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
717         .md5_lookup     =       tcp_v6_reqsk_md5_lookup,
718         .calc_md5_hash  =       tcp_v6_md5_hash_skb,
719 };
720 #endif
721 
722 static void tcp_v6_send_response(struct sk_buff *skb, u32 seq, u32 ack, u32 win,
723                                  u32 tsval, u32 tsecr,
724                                  struct tcp_md5sig_key *key, int rst, u8 tclass)
725 {
726         const struct tcphdr *th = tcp_hdr(skb);
727         struct tcphdr *t1;
728         struct sk_buff *buff;
729         struct flowi6 fl6;
730         struct net *net = dev_net(skb_dst(skb)->dev);
731         struct sock *ctl_sk = net->ipv6.tcp_sk;
732         unsigned int tot_len = sizeof(struct tcphdr);
733         struct dst_entry *dst;
734         __be32 *topt;
735 
736         if (tsecr)
737                 tot_len += TCPOLEN_TSTAMP_ALIGNED;
738 #ifdef CONFIG_TCP_MD5SIG
739         if (key)
740                 tot_len += TCPOLEN_MD5SIG_ALIGNED;
741 #endif
742 
743         buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
744                          GFP_ATOMIC);
745         if (buff == NULL)
746                 return;
747 
748         skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
749 
750         t1 = (struct tcphdr *) skb_push(buff, tot_len);
751         skb_reset_transport_header(buff);
752 
753         /* Swap the send and the receive. */
754         memset(t1, 0, sizeof(*t1));
755         t1->dest = th->source;
756         t1->source = th->dest;
757         t1->doff = tot_len / 4;
758         t1->seq = htonl(seq);
759         t1->ack_seq = htonl(ack);
760         t1->ack = !rst || !th->ack;
761         t1->rst = rst;
762         t1->window = htons(win);
763 
764         topt = (__be32 *)(t1 + 1);
765 
766         if (tsecr) {
767                 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
768                                 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
769                 *topt++ = htonl(tsval);
770                 *topt++ = htonl(tsecr);
771         }
772 
773 #ifdef CONFIG_TCP_MD5SIG
774         if (key) {
775                 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
776                                 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
777                 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
778                                     &ipv6_hdr(skb)->saddr,
779                                     &ipv6_hdr(skb)->daddr, t1);
780         }
781 #endif
782 
783         memset(&fl6, 0, sizeof(fl6));
784         fl6.daddr = ipv6_hdr(skb)->saddr;
785         fl6.saddr = ipv6_hdr(skb)->daddr;
786 
787         buff->ip_summed = CHECKSUM_PARTIAL;
788         buff->csum = 0;
789 
790         __tcp_v6_send_check(buff, &fl6.saddr, &fl6.daddr);
791 
792         fl6.flowi6_proto = IPPROTO_TCP;
793         if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
794                 fl6.flowi6_oif = inet6_iif(skb);
795         fl6.fl6_dport = t1->dest;
796         fl6.fl6_sport = t1->source;
797         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
798 
799         /* Pass a socket to ip6_dst_lookup either it is for RST
800          * Underlying function will use this to retrieve the network
801          * namespace
802          */
803         dst = ip6_dst_lookup_flow(ctl_sk, &fl6, NULL, false);
804         if (!IS_ERR(dst)) {
805                 skb_dst_set(buff, dst);
806                 ip6_xmit(ctl_sk, buff, &fl6, NULL, tclass);
807                 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
808                 if (rst)
809                         TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
810                 return;
811         }
812 
813         kfree_skb(buff);
814 }
815 
816 static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
817 {
818         const struct tcphdr *th = tcp_hdr(skb);
819         u32 seq = 0, ack_seq = 0;
820         struct tcp_md5sig_key *key = NULL;
821 #ifdef CONFIG_TCP_MD5SIG
822         const __u8 *hash_location = NULL;
823         struct ipv6hdr *ipv6h = ipv6_hdr(skb);
824         unsigned char newhash[16];
825         int genhash;
826         struct sock *sk1 = NULL;
827 #endif
828 
829         if (th->rst)
830                 return;
831 
832         if (!ipv6_unicast_destination(skb))
833                 return;
834 
835 #ifdef CONFIG_TCP_MD5SIG
836         hash_location = tcp_parse_md5sig_option(th);
837         if (!sk && hash_location) {
838                 /*
839                  * active side is lost. Try to find listening socket through
840                  * source port, and then find md5 key through listening socket.
841                  * we are not loose security here:
842                  * Incoming packet is checked with md5 hash with finding key,
843                  * no RST generated if md5 hash doesn't match.
844                  */
845                 sk1 = inet6_lookup_listener(dev_net(skb_dst(skb)->dev),
846                                            &tcp_hashinfo, &ipv6h->saddr,
847                                            th->source, &ipv6h->daddr,
848                                            ntohs(th->source), inet6_iif(skb));
849                 if (!sk1)
850                         return;
851 
852                 rcu_read_lock();
853                 key = tcp_v6_md5_do_lookup(sk1, &ipv6h->saddr);
854                 if (!key)
855                         goto release_sk1;
856 
857                 genhash = tcp_v6_md5_hash_skb(newhash, key, NULL, NULL, skb);
858                 if (genhash || memcmp(hash_location, newhash, 16) != 0)
859                         goto release_sk1;
860         } else {
861                 key = sk ? tcp_v6_md5_do_lookup(sk, &ipv6h->saddr) : NULL;
862         }
863 #endif
864 
865         if (th->ack)
866                 seq = ntohl(th->ack_seq);
867         else
868                 ack_seq = ntohl(th->seq) + th->syn + th->fin + skb->len -
869                           (th->doff << 2);
870 
871         tcp_v6_send_response(skb, seq, ack_seq, 0, 0, 0, key, 1, 0);
872 
873 #ifdef CONFIG_TCP_MD5SIG
874 release_sk1:
875         if (sk1) {
876                 rcu_read_unlock();
877                 sock_put(sk1);
878         }
879 #endif
880 }
881 
882 static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack,
883                             u32 win, u32 tsval, u32 tsecr,
884                             struct tcp_md5sig_key *key, u8 tclass)
885 {
886         tcp_v6_send_response(skb, seq, ack, win, tsval, tsecr, key, 0, tclass);
887 }
888 
889 static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
890 {
891         struct inet_timewait_sock *tw = inet_twsk(sk);
892         struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
893 
894         tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
895                         tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
896                         tcp_time_stamp + tcptw->tw_ts_offset,
897                         tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw),
898                         tw->tw_tclass);
899 
900         inet_twsk_put(tw);
901 }
902 
903 static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
904                                   struct request_sock *req)
905 {
906         tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1,
907                         req->rcv_wnd, tcp_time_stamp, req->ts_recent,
908                         tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr), 0);
909 }
910 
911 
912 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
913 {
914         struct request_sock *req, **prev;
915         const struct tcphdr *th = tcp_hdr(skb);
916         struct sock *nsk;
917 
918         /* Find possible connection requests. */
919         req = inet6_csk_search_req(sk, &prev, th->source,
920                                    &ipv6_hdr(skb)->saddr,
921                                    &ipv6_hdr(skb)->daddr, inet6_iif(skb));
922         if (req)
923                 return tcp_check_req(sk, skb, req, prev, false);
924 
925         nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
926                         &ipv6_hdr(skb)->saddr, th->source,
927                         &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
928 
929         if (nsk) {
930                 if (nsk->sk_state != TCP_TIME_WAIT) {
931                         bh_lock_sock(nsk);
932                         return nsk;
933                 }
934                 inet_twsk_put(inet_twsk(nsk));
935                 return NULL;
936         }
937 
938 #ifdef CONFIG_SYN_COOKIES
939         if (!th->syn)
940                 sk = cookie_v6_check(sk, skb);
941 #endif
942         return sk;
943 }
944 
945 /* FIXME: this is substantially similar to the ipv4 code.
946  * Can some kind of merge be done? -- erics
947  */
948 static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
949 {
950         struct tcp_options_received tmp_opt;
951         struct request_sock *req;
952         struct inet_request_sock *ireq;
953         struct ipv6_pinfo *np = inet6_sk(sk);
954         struct tcp_sock *tp = tcp_sk(sk);
955         __u32 isn = TCP_SKB_CB(skb)->when;
956         struct dst_entry *dst = NULL;
957         struct flowi6 fl6;
958         bool want_cookie = false;
959 
960         if (skb->protocol == htons(ETH_P_IP))
961                 return tcp_v4_conn_request(sk, skb);
962 
963         if (!ipv6_unicast_destination(skb))
964                 goto drop;
965 
966         if ((sysctl_tcp_syncookies == 2 ||
967              inet_csk_reqsk_queue_is_full(sk)) && !isn) {
968                 want_cookie = tcp_syn_flood_action(sk, skb, "TCPv6");
969                 if (!want_cookie)
970                         goto drop;
971         }
972 
973         if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1) {
974                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
975                 goto drop;
976         }
977 
978         req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
979         if (req == NULL)
980                 goto drop;
981 
982 #ifdef CONFIG_TCP_MD5SIG
983         tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
984 #endif
985 
986         tcp_clear_options(&tmp_opt);
987         tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
988         tmp_opt.user_mss = tp->rx_opt.user_mss;
989         tcp_parse_options(skb, &tmp_opt, 0, NULL);
990 
991         if (want_cookie && !tmp_opt.saw_tstamp)
992                 tcp_clear_options(&tmp_opt);
993 
994         tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
995         tcp_openreq_init(req, &tmp_opt, skb);
996 
997         ireq = inet_rsk(req);
998         ireq->ir_v6_rmt_addr = ipv6_hdr(skb)->saddr;
999         ireq->ir_v6_loc_addr = ipv6_hdr(skb)->daddr;
1000         if (!want_cookie || tmp_opt.tstamp_ok)
1001                 TCP_ECN_create_request(req, skb, sock_net(sk));
1002 
1003         ireq->ir_iif = sk->sk_bound_dev_if;
1004 
1005         /* So that link locals have meaning */
1006         if (!sk->sk_bound_dev_if &&
1007             ipv6_addr_type(&ireq->ir_v6_rmt_addr) & IPV6_ADDR_LINKLOCAL)
1008                 ireq->ir_iif = inet6_iif(skb);
1009 
1010         if (!isn) {
1011                 if (ipv6_opt_accepted(sk, skb) ||
1012                     np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1013                     np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1014                         atomic_inc(&skb->users);
1015                         ireq->pktopts = skb;
1016                 }
1017 
1018                 if (want_cookie) {
1019                         isn = cookie_v6_init_sequence(sk, skb, &req->mss);
1020                         req->cookie_ts = tmp_opt.tstamp_ok;
1021                         goto have_isn;
1022                 }
1023 
1024                 /* VJ's idea. We save last timestamp seen
1025                  * from the destination in peer table, when entering
1026                  * state TIME-WAIT, and check against it before
1027                  * accepting new connection request.
1028                  *
1029                  * If "isn" is not zero, this request hit alive
1030                  * timewait bucket, so that all the necessary checks
1031                  * are made in the function processing timewait state.
1032                  */
1033                 if (tmp_opt.saw_tstamp &&
1034                     tcp_death_row.sysctl_tw_recycle &&
1035                     (dst = inet6_csk_route_req(sk, &fl6, req)) != NULL) {
1036                         if (!tcp_peer_is_proven(req, dst, true)) {
1037                                 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSPASSIVEREJECTED);
1038                                 goto drop_and_release;
1039                         }
1040                 }
1041                 /* Kill the following clause, if you dislike this way. */
1042                 else if (!sysctl_tcp_syncookies &&
1043                          (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1044                           (sysctl_max_syn_backlog >> 2)) &&
1045                          !tcp_peer_is_proven(req, dst, false)) {
1046                         /* Without syncookies last quarter of
1047                          * backlog is filled with destinations,
1048                          * proven to be alive.
1049                          * It means that we continue to communicate
1050                          * to destinations, already remembered
1051                          * to the moment of synflood.
1052                          */
1053                         LIMIT_NETDEBUG(KERN_DEBUG "TCP: drop open request from %pI6/%u\n",
1054                                        &ireq->ir_v6_rmt_addr, ntohs(tcp_hdr(skb)->source));
1055                         goto drop_and_release;
1056                 }
1057 
1058                 isn = tcp_v6_init_sequence(skb);
1059         }
1060 have_isn:
1061         tcp_rsk(req)->snt_isn = isn;
1062 
1063         if (security_inet_conn_request(sk, skb, req))
1064                 goto drop_and_release;
1065 
1066         if (tcp_v6_send_synack(sk, dst, &fl6, req,
1067                                skb_get_queue_mapping(skb)) ||
1068             want_cookie)
1069                 goto drop_and_free;
1070 
1071         tcp_rsk(req)->snt_synack = tcp_time_stamp;
1072         tcp_rsk(req)->listener = NULL;
1073         inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1074         return 0;
1075 
1076 drop_and_release:
1077         dst_release(dst);
1078 drop_and_free:
1079         reqsk_free(req);
1080 drop:
1081         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1082         return 0; /* don't send reset */
1083 }
1084 
1085 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1086                                           struct request_sock *req,
1087                                           struct dst_entry *dst)
1088 {
1089         struct inet_request_sock *ireq;
1090         struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1091         struct tcp6_sock *newtcp6sk;
1092         struct inet_sock *newinet;
1093         struct tcp_sock *newtp;
1094         struct sock *newsk;
1095 #ifdef CONFIG_TCP_MD5SIG
1096         struct tcp_md5sig_key *key;
1097 #endif
1098         struct flowi6 fl6;
1099 
1100         if (skb->protocol == htons(ETH_P_IP)) {
1101                 /*
1102                  *      v6 mapped
1103                  */
1104 
1105                 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1106 
1107                 if (newsk == NULL)
1108                         return NULL;
1109 
1110                 newtcp6sk = (struct tcp6_sock *)newsk;
1111                 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1112 
1113                 newinet = inet_sk(newsk);
1114                 newnp = inet6_sk(newsk);
1115                 newtp = tcp_sk(newsk);
1116 
1117                 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1118 
1119                 ipv6_addr_set_v4mapped(newinet->inet_daddr, &newsk->sk_v6_daddr);
1120 
1121                 ipv6_addr_set_v4mapped(newinet->inet_saddr, &newnp->saddr);
1122 
1123                 newsk->sk_v6_rcv_saddr = newnp->saddr;
1124 
1125                 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1126                 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
1127 #ifdef CONFIG_TCP_MD5SIG
1128                 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1129 #endif
1130 
1131                 newnp->ipv6_ac_list = NULL;
1132                 newnp->ipv6_fl_list = NULL;
1133                 newnp->pktoptions  = NULL;
1134                 newnp->opt         = NULL;
1135                 newnp->mcast_oif   = inet6_iif(skb);
1136                 newnp->mcast_hops  = ipv6_hdr(skb)->hop_limit;
1137                 newnp->rcv_tclass  = ipv6_get_dsfield(ipv6_hdr(skb));
1138 
1139                 /*
1140                  * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1141                  * here, tcp_create_openreq_child now does this for us, see the comment in
1142                  * that function for the gory details. -acme
1143                  */
1144 
1145                 /* It is tricky place. Until this moment IPv4 tcp
1146                    worked with IPv6 icsk.icsk_af_ops.
1147                    Sync it now.
1148                  */
1149                 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1150 
1151                 return newsk;
1152         }
1153 
1154         ireq = inet_rsk(req);
1155 
1156         if (sk_acceptq_is_full(sk))
1157                 goto out_overflow;
1158 
1159         if (!dst) {
1160                 dst = inet6_csk_route_req(sk, &fl6, req);
1161                 if (!dst)
1162                         goto out;
1163         }
1164 
1165         newsk = tcp_create_openreq_child(sk, req, skb);
1166         if (newsk == NULL)
1167                 goto out_nonewsk;
1168 
1169         /*
1170          * No need to charge this sock to the relevant IPv6 refcnt debug socks
1171          * count here, tcp_create_openreq_child now does this for us, see the
1172          * comment in that function for the gory details. -acme
1173          */
1174 
1175         newsk->sk_gso_type = SKB_GSO_TCPV6;
1176         __ip6_dst_store(newsk, dst, NULL, NULL);
1177         inet6_sk_rx_dst_set(newsk, skb);
1178 
1179         newtcp6sk = (struct tcp6_sock *)newsk;
1180         inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1181 
1182         newtp = tcp_sk(newsk);
1183         newinet = inet_sk(newsk);
1184         newnp = inet6_sk(newsk);
1185 
1186         memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1187 
1188         newsk->sk_v6_daddr = ireq->ir_v6_rmt_addr;
1189         newnp->saddr = ireq->ir_v6_loc_addr;
1190         newsk->sk_v6_rcv_saddr = ireq->ir_v6_loc_addr;
1191         newsk->sk_bound_dev_if = ireq->ir_iif;
1192 
1193         /* Now IPv6 options...
1194 
1195            First: no IPv4 options.
1196          */
1197         newinet->inet_opt = NULL;
1198         newnp->ipv6_ac_list = NULL;
1199         newnp->ipv6_fl_list = NULL;
1200 
1201         /* Clone RX bits */
1202         newnp->rxopt.all = np->rxopt.all;
1203 
1204         /* Clone pktoptions received with SYN */
1205         newnp->pktoptions = NULL;
1206         if (ireq->pktopts != NULL) {
1207                 newnp->pktoptions = skb_clone(ireq->pktopts,
1208                                               sk_gfp_atomic(sk, GFP_ATOMIC));
1209                 consume_skb(ireq->pktopts);
1210                 ireq->pktopts = NULL;
1211                 if (newnp->pktoptions)
1212                         skb_set_owner_r(newnp->pktoptions, newsk);
1213         }
1214         newnp->opt        = NULL;
1215         newnp->mcast_oif  = inet6_iif(skb);
1216         newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1217         newnp->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(skb));
1218 
1219         /* Clone native IPv6 options from listening socket (if any)
1220 
1221            Yes, keeping reference count would be much more clever,
1222            but we make one more one thing there: reattach optmem
1223            to newsk.
1224          */
1225         if (np->opt)
1226                 newnp->opt = ipv6_dup_options(newsk, np->opt);
1227 
1228         inet_csk(newsk)->icsk_ext_hdr_len = 0;
1229         if (newnp->opt)
1230                 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1231                                                      newnp->opt->opt_flen);
1232 
1233         tcp_mtup_init(newsk);
1234         tcp_sync_mss(newsk, dst_mtu(dst));
1235         newtp->advmss = dst_metric_advmss(dst);
1236         if (tcp_sk(sk)->rx_opt.user_mss &&
1237             tcp_sk(sk)->rx_opt.user_mss < newtp->advmss)
1238                 newtp->advmss = tcp_sk(sk)->rx_opt.user_mss;
1239 
1240         tcp_initialize_rcv_mss(newsk);
1241 
1242         newinet->inet_daddr = newinet->inet_saddr = LOOPBACK4_IPV6;
1243         newinet->inet_rcv_saddr = LOOPBACK4_IPV6;
1244 
1245 #ifdef CONFIG_TCP_MD5SIG
1246         /* Copy over the MD5 key from the original socket */
1247         if ((key = tcp_v6_md5_do_lookup(sk, &newsk->sk_v6_daddr)) != NULL) {
1248                 /* We're using one, so create a matching key
1249                  * on the newsk structure. If we fail to get
1250                  * memory, then we end up not copying the key
1251                  * across. Shucks.
1252                  */
1253                 tcp_md5_do_add(newsk, (union tcp_md5_addr *)&newsk->sk_v6_daddr,
1254                                AF_INET6, key->key, key->keylen,
1255                                sk_gfp_atomic(sk, GFP_ATOMIC));
1256         }
1257 #endif
1258 
1259         if (__inet_inherit_port(sk, newsk) < 0) {
1260                 inet_csk_prepare_forced_close(newsk);
1261                 tcp_done(newsk);
1262                 goto out;
1263         }
1264         __inet6_hash(newsk, NULL);
1265 
1266         return newsk;
1267 
1268 out_overflow:
1269         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1270 out_nonewsk:
1271         dst_release(dst);
1272 out:
1273         NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1274         return NULL;
1275 }
1276 
1277 static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1278 {
1279         if (skb->ip_summed == CHECKSUM_COMPLETE) {
1280                 if (!tcp_v6_check(skb->len, &ipv6_hdr(skb)->saddr,
1281                                   &ipv6_hdr(skb)->daddr, skb->csum)) {
1282                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1283                         return 0;
1284                 }
1285         }
1286 
1287         skb->csum = ~csum_unfold(tcp_v6_check(skb->len,
1288                                               &ipv6_hdr(skb)->saddr,
1289                                               &ipv6_hdr(skb)->daddr, 0));
1290 
1291         if (skb->len <= 76) {
1292                 return __skb_checksum_complete(skb);
1293         }
1294         return 0;
1295 }
1296 
1297 /* The socket must have it's spinlock held when we get
1298  * here.
1299  *
1300  * We have a potential double-lock case here, so even when
1301  * doing backlog processing we use the BH locking scheme.
1302  * This is because we cannot sleep with the original spinlock
1303  * held.
1304  */
1305 static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1306 {
1307         struct ipv6_pinfo *np = inet6_sk(sk);
1308         struct tcp_sock *tp;
1309         struct sk_buff *opt_skb = NULL;
1310 
1311         /* Imagine: socket is IPv6. IPv4 packet arrives,
1312            goes to IPv4 receive handler and backlogged.
1313            From backlog it always goes here. Kerboom...
1314            Fortunately, tcp_rcv_established and rcv_established
1315            handle them correctly, but it is not case with
1316            tcp_v6_hnd_req and tcp_v6_send_reset().   --ANK
1317          */
1318 
1319         if (skb->protocol == htons(ETH_P_IP))
1320                 return tcp_v4_do_rcv(sk, skb);
1321 
1322 #ifdef CONFIG_TCP_MD5SIG
1323         if (tcp_v6_inbound_md5_hash (sk, skb))
1324                 goto discard;
1325 #endif
1326 
1327         if (sk_filter(sk, skb))
1328                 goto discard;
1329 
1330         /*
1331          *      socket locking is here for SMP purposes as backlog rcv
1332          *      is currently called with bh processing disabled.
1333          */
1334 
1335         /* Do Stevens' IPV6_PKTOPTIONS.
1336 
1337            Yes, guys, it is the only place in our code, where we
1338            may make it not affecting IPv4.
1339            The rest of code is protocol independent,
1340            and I do not like idea to uglify IPv4.
1341 
1342            Actually, all the idea behind IPV6_PKTOPTIONS
1343            looks not very well thought. For now we latch
1344            options, received in the last packet, enqueued
1345            by tcp. Feel free to propose better solution.
1346                                                --ANK (980728)
1347          */
1348         if (np->rxopt.all)
1349                 opt_skb = skb_clone(skb, sk_gfp_atomic(sk, GFP_ATOMIC));
1350 
1351         if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1352                 struct dst_entry *dst = sk->sk_rx_dst;
1353 
1354                 sock_rps_save_rxhash(sk, skb);
1355                 if (dst) {
1356                         if (inet_sk(sk)->rx_dst_ifindex != skb->skb_iif ||
1357                             dst->ops->check(dst, np->rx_dst_cookie) == NULL) {
1358                                 dst_release(dst);
1359                                 sk->sk_rx_dst = NULL;
1360                         }
1361                 }
1362 
1363                 tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len);
1364                 if (opt_skb)
1365                         goto ipv6_pktoptions;
1366                 return 0;
1367         }
1368 
1369         if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1370                 goto csum_err;
1371 
1372         if (sk->sk_state == TCP_LISTEN) {
1373                 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1374                 if (!nsk)
1375                         goto discard;
1376 
1377                 /*
1378                  * Queue it on the new socket if the new socket is active,
1379                  * otherwise we just shortcircuit this and continue with
1380                  * the new socket..
1381                  */
1382                 if(nsk != sk) {
1383                         sock_rps_save_rxhash(nsk, skb);
1384                         if (tcp_child_process(sk, nsk, skb))
1385                                 goto reset;
1386                         if (opt_skb)
1387                                 __kfree_skb(opt_skb);
1388                         return 0;
1389                 }
1390         } else
1391                 sock_rps_save_rxhash(sk, skb);
1392 
1393         if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1394                 goto reset;
1395         if (opt_skb)
1396                 goto ipv6_pktoptions;
1397         return 0;
1398 
1399 reset:
1400         tcp_v6_send_reset(sk, skb);
1401 discard:
1402         if (opt_skb)
1403                 __kfree_skb(opt_skb);
1404         kfree_skb(skb);
1405         return 0;
1406 csum_err:
1407         TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_CSUMERRORS);
1408         TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1409         goto discard;
1410 
1411 
1412 ipv6_pktoptions:
1413         /* Do you ask, what is it?
1414 
1415            1. skb was enqueued by tcp.
1416            2. skb is added to tail of read queue, rather than out of order.
1417            3. socket is not in passive state.
1418            4. Finally, it really contains options, which user wants to receive.
1419          */
1420         tp = tcp_sk(sk);
1421         if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1422             !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
1423                 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
1424                         np->mcast_oif = inet6_iif(opt_skb);
1425                 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
1426                         np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1427                 if (np->rxopt.bits.rxtclass)
1428                         np->rcv_tclass = ipv6_get_dsfield(ipv6_hdr(opt_skb));
1429                 if (ipv6_opt_accepted(sk, opt_skb)) {
1430                         skb_set_owner_r(opt_skb, sk);
1431                         opt_skb = xchg(&np->pktoptions, opt_skb);
1432                 } else {
1433                         __kfree_skb(opt_skb);
1434                         opt_skb = xchg(&np->pktoptions, NULL);
1435                 }
1436         }
1437 
1438         kfree_skb(opt_skb);
1439         return 0;
1440 }
1441 
1442 static int tcp_v6_rcv(struct sk_buff *skb)
1443 {
1444         const struct tcphdr *th;
1445         const struct ipv6hdr *hdr;
1446         struct sock *sk;
1447         int ret;
1448         struct net *net = dev_net(skb->dev);
1449 
1450         if (skb->pkt_type != PACKET_HOST)
1451                 goto discard_it;
1452 
1453         /*
1454          *      Count it even if it's bad.
1455          */
1456         TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1457 
1458         if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1459                 goto discard_it;
1460 
1461         th = tcp_hdr(skb);
1462 
1463         if (th->doff < sizeof(struct tcphdr)/4)
1464                 goto bad_packet;
1465         if (!pskb_may_pull(skb, th->doff*4))
1466                 goto discard_it;
1467 
1468         if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
1469                 goto csum_error;
1470 
1471         th = tcp_hdr(skb);
1472         hdr = ipv6_hdr(skb);
1473         TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1474         TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1475                                     skb->len - th->doff*4);
1476         TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1477         TCP_SKB_CB(skb)->when = 0;
1478         TCP_SKB_CB(skb)->ip_dsfield = ipv6_get_dsfield(hdr);
1479         TCP_SKB_CB(skb)->sacked = 0;
1480 
1481         sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1482         if (!sk)
1483                 goto no_tcp_socket;
1484 
1485 process:
1486         if (sk->sk_state == TCP_TIME_WAIT)
1487                 goto do_time_wait;
1488 
1489         if (hdr->hop_limit < inet6_sk(sk)->min_hopcount) {
1490                 NET_INC_STATS_BH(net, LINUX_MIB_TCPMINTTLDROP);
1491                 goto discard_and_relse;
1492         }
1493 
1494         if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1495                 goto discard_and_relse;
1496 
1497         if (sk_filter(sk, skb))
1498                 goto discard_and_relse;
1499 
1500         sk_mark_napi_id(sk, skb);
1501         skb->dev = NULL;
1502 
1503         bh_lock_sock_nested(sk);
1504         ret = 0;
1505         if (!sock_owned_by_user(sk)) {
1506 #ifdef CONFIG_NET_DMA
1507                 struct tcp_sock *tp = tcp_sk(sk);
1508                 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1509                         tp->ucopy.dma_chan = net_dma_find_channel();
1510                 if (tp->ucopy.dma_chan)
1511                         ret = tcp_v6_do_rcv(sk, skb);
1512                 else
1513 #endif
1514                 {
1515                         if (!tcp_prequeue(sk, skb))
1516                                 ret = tcp_v6_do_rcv(sk, skb);
1517                 }
1518         } else if (unlikely(sk_add_backlog(sk, skb,
1519                                            sk->sk_rcvbuf + sk->sk_sndbuf))) {
1520                 bh_unlock_sock(sk);
1521                 NET_INC_STATS_BH(net, LINUX_MIB_TCPBACKLOGDROP);
1522                 goto discard_and_relse;
1523         }
1524         bh_unlock_sock(sk);
1525 
1526         sock_put(sk);
1527         return ret ? -1 : 0;
1528 
1529 no_tcp_socket:
1530         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1531                 goto discard_it;
1532 
1533         if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1534 csum_error:
1535                 TCP_INC_STATS_BH(net, TCP_MIB_CSUMERRORS);
1536 bad_packet:
1537                 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1538         } else {
1539                 tcp_v6_send_reset(NULL, skb);
1540         }
1541 
1542 discard_it:
1543         kfree_skb(skb);
1544         return 0;
1545 
1546 discard_and_relse:
1547         sock_put(sk);
1548         goto discard_it;
1549 
1550 do_time_wait:
1551         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1552                 inet_twsk_put(inet_twsk(sk));
1553                 goto discard_it;
1554         }
1555 
1556         if (skb->len < (th->doff<<2)) {
1557                 inet_twsk_put(inet_twsk(sk));
1558                 goto bad_packet;
1559         }
1560         if (tcp_checksum_complete(skb)) {
1561                 inet_twsk_put(inet_twsk(sk));
1562                 goto csum_error;
1563         }
1564 
1565         switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1566         case TCP_TW_SYN:
1567         {
1568                 struct sock *sk2;
1569 
1570                 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
1571                                             &ipv6_hdr(skb)->saddr, th->source,
1572                                             &ipv6_hdr(skb)->daddr,
1573                                             ntohs(th->dest), inet6_iif(skb));
1574                 if (sk2 != NULL) {
1575                         struct inet_timewait_sock *tw = inet_twsk(sk);
1576                         inet_twsk_deschedule(tw, &tcp_death_row);
1577                         inet_twsk_put(tw);
1578                         sk = sk2;
1579                         goto process;
1580                 }
1581                 /* Fall through to ACK */
1582         }
1583         case TCP_TW_ACK:
1584                 tcp_v6_timewait_ack(sk, skb);
1585                 break;
1586         case TCP_TW_RST:
1587                 goto no_tcp_socket;
1588         case TCP_TW_SUCCESS:;
1589         }
1590         goto discard_it;
1591 }
1592 
1593 static void tcp_v6_early_demux(struct sk_buff *skb)
1594 {
1595         const struct ipv6hdr *hdr;
1596         const struct tcphdr *th;
1597         struct sock *sk;
1598 
1599         if (skb->pkt_type != PACKET_HOST)
1600                 return;
1601 
1602         if (!pskb_may_pull(skb, skb_transport_offset(skb) + sizeof(struct tcphdr)))
1603                 return;
1604 
1605         hdr = ipv6_hdr(skb);
1606         th = tcp_hdr(skb);
1607 
1608         if (th->doff < sizeof(struct tcphdr) / 4)
1609                 return;
1610 
1611         sk = __inet6_lookup_established(dev_net(skb->dev), &tcp_hashinfo,
1612                                         &hdr->saddr, th->source,
1613                                         &hdr->daddr, ntohs(th->dest),
1614                                         inet6_iif(skb));
1615         if (sk) {
1616                 skb->sk = sk;
1617                 skb->destructor = sock_edemux;
1618                 if (sk->sk_state != TCP_TIME_WAIT) {
1619                         struct dst_entry *dst = sk->sk_rx_dst;
1620 
1621                         if (dst)
1622                                 dst = dst_check(dst, inet6_sk(sk)->rx_dst_cookie);
1623                         if (dst &&
1624                             inet_sk(sk)->rx_dst_ifindex == skb->skb_iif)
1625                                 skb_dst_set_noref(skb, dst);
1626                 }
1627         }
1628 }
1629 
1630 static struct timewait_sock_ops tcp6_timewait_sock_ops = {
1631         .twsk_obj_size  = sizeof(struct tcp6_timewait_sock),
1632         .twsk_unique    = tcp_twsk_unique,
1633         .twsk_destructor= tcp_twsk_destructor,
1634 };
1635 
1636 static const struct inet_connection_sock_af_ops ipv6_specific = {
1637         .queue_xmit        = inet6_csk_xmit,
1638         .send_check        = tcp_v6_send_check,
1639         .rebuild_header    = inet6_sk_rebuild_header,
1640         .sk_rx_dst_set     = inet6_sk_rx_dst_set,
1641         .conn_request      = tcp_v6_conn_request,
1642         .syn_recv_sock     = tcp_v6_syn_recv_sock,
1643         .net_header_len    = sizeof(struct ipv6hdr),
1644         .net_frag_header_len = sizeof(struct frag_hdr),
1645         .setsockopt        = ipv6_setsockopt,
1646         .getsockopt        = ipv6_getsockopt,
1647         .addr2sockaddr     = inet6_csk_addr2sockaddr,
1648         .sockaddr_len      = sizeof(struct sockaddr_in6),
1649         .bind_conflict     = inet6_csk_bind_conflict,
1650 #ifdef CONFIG_COMPAT
1651         .compat_setsockopt = compat_ipv6_setsockopt,
1652         .compat_getsockopt = compat_ipv6_getsockopt,
1653 #endif
1654 };
1655 
1656 #ifdef CONFIG_TCP_MD5SIG
1657 static const struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
1658         .md5_lookup     =       tcp_v6_md5_lookup,
1659         .calc_md5_hash  =       tcp_v6_md5_hash_skb,
1660         .md5_parse      =       tcp_v6_parse_md5_keys,
1661 };
1662 #endif
1663 
1664 /*
1665  *      TCP over IPv4 via INET6 API
1666  */
1667 
1668 static const struct inet_connection_sock_af_ops ipv6_mapped = {
1669         .queue_xmit        = ip_queue_xmit,
1670         .send_check        = tcp_v4_send_check,
1671         .rebuild_header    = inet_sk_rebuild_header,
1672         .sk_rx_dst_set     = inet_sk_rx_dst_set,
1673         .conn_request      = tcp_v6_conn_request,
1674         .syn_recv_sock     = tcp_v6_syn_recv_sock,
1675         .net_header_len    = sizeof(struct iphdr),
1676         .setsockopt        = ipv6_setsockopt,
1677         .getsockopt        = ipv6_getsockopt,
1678         .addr2sockaddr     = inet6_csk_addr2sockaddr,
1679         .sockaddr_len      = sizeof(struct sockaddr_in6),
1680         .bind_conflict     = inet6_csk_bind_conflict,
1681 #ifdef CONFIG_COMPAT
1682         .compat_setsockopt = compat_ipv6_setsockopt,
1683         .compat_getsockopt = compat_ipv6_getsockopt,
1684 #endif
1685 };
1686 
1687 #ifdef CONFIG_TCP_MD5SIG
1688 static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
1689         .md5_lookup     =       tcp_v4_md5_lookup,
1690         .calc_md5_hash  =       tcp_v4_md5_hash_skb,
1691         .md5_parse      =       tcp_v6_parse_md5_keys,
1692 };
1693 #endif
1694 
1695 /* NOTE: A lot of things set to zero explicitly by call to
1696  *       sk_alloc() so need not be done here.
1697  */
1698 static int tcp_v6_init_sock(struct sock *sk)
1699 {
1700         struct inet_connection_sock *icsk = inet_csk(sk);
1701 
1702         tcp_init_sock(sk);
1703 
1704         icsk->icsk_af_ops = &ipv6_specific;
1705 
1706 #ifdef CONFIG_TCP_MD5SIG
1707         tcp_sk(sk)->af_specific = &tcp_sock_ipv6_specific;
1708 #endif
1709 
1710         return 0;
1711 }
1712 
1713 static void tcp_v6_destroy_sock(struct sock *sk)
1714 {
1715         tcp_v4_destroy_sock(sk);
1716         inet6_destroy_sock(sk);
1717 }
1718 
1719 #ifdef CONFIG_PROC_FS
1720 /* Proc filesystem TCPv6 sock list dumping. */
1721 static void get_openreq6(struct seq_file *seq,
1722                          const struct sock *sk, struct request_sock *req, int i, kuid_t uid)
1723 {
1724         int ttd = req->expires - jiffies;
1725         const struct in6_addr *src = &inet_rsk(req)->ir_v6_loc_addr;
1726         const struct in6_addr *dest = &inet_rsk(req)->ir_v6_rmt_addr;
1727 
1728         if (ttd < 0)
1729                 ttd = 0;
1730 
1731         seq_printf(seq,
1732                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1733                    "%02X %08X:%08X %02X:%08lX %08X %5u %8d %d %d %pK\n",
1734                    i,
1735                    src->s6_addr32[0], src->s6_addr32[1],
1736                    src->s6_addr32[2], src->s6_addr32[3],
1737                    inet_rsk(req)->ir_num,
1738                    dest->s6_addr32[0], dest->s6_addr32[1],
1739                    dest->s6_addr32[2], dest->s6_addr32[3],
1740                    ntohs(inet_rsk(req)->ir_rmt_port),
1741                    TCP_SYN_RECV,
1742                    0,0, /* could print option size, but that is af dependent. */
1743                    1,   /* timers active (only the expire timer) */
1744                    jiffies_to_clock_t(ttd),
1745                    req->num_timeout,
1746                    from_kuid_munged(seq_user_ns(seq), uid),
1747                    0,  /* non standard timer */
1748                    0, /* open_requests have no inode */
1749                    0, req);
1750 }
1751 
1752 static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1753 {
1754         const struct in6_addr *dest, *src;
1755         __u16 destp, srcp;
1756         int timer_active;
1757         unsigned long timer_expires;
1758         const struct inet_sock *inet = inet_sk(sp);
1759         const struct tcp_sock *tp = tcp_sk(sp);
1760         const struct inet_connection_sock *icsk = inet_csk(sp);
1761 
1762         dest  = &sp->sk_v6_daddr;
1763         src   = &sp->sk_v6_rcv_saddr;
1764         destp = ntohs(inet->inet_dport);
1765         srcp  = ntohs(inet->inet_sport);
1766 
1767         if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1768                 timer_active    = 1;
1769                 timer_expires   = icsk->icsk_timeout;
1770         } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1771                 timer_active    = 4;
1772                 timer_expires   = icsk->icsk_timeout;
1773         } else if (timer_pending(&sp->sk_timer)) {
1774                 timer_active    = 2;
1775                 timer_expires   = sp->sk_timer.expires;
1776         } else {
1777                 timer_active    = 0;
1778                 timer_expires = jiffies;
1779         }
1780 
1781         seq_printf(seq,
1782                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1783                    "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
1784                    i,
1785                    src->s6_addr32[0], src->s6_addr32[1],
1786                    src->s6_addr32[2], src->s6_addr32[3], srcp,
1787                    dest->s6_addr32[0], dest->s6_addr32[1],
1788                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
1789                    sp->sk_state,
1790                    tp->write_seq-tp->snd_una,
1791                    (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1792                    timer_active,
1793                    jiffies_delta_to_clock_t(timer_expires - jiffies),
1794                    icsk->icsk_retransmits,
1795                    from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1796                    icsk->icsk_probes_out,
1797                    sock_i_ino(sp),
1798                    atomic_read(&sp->sk_refcnt), sp,
1799                    jiffies_to_clock_t(icsk->icsk_rto),
1800                    jiffies_to_clock_t(icsk->icsk_ack.ato),
1801                    (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
1802                    tp->snd_cwnd,
1803                    tcp_in_initial_slowstart(tp) ? -1 : tp->snd_ssthresh
1804                    );
1805 }
1806 
1807 static void get_timewait6_sock(struct seq_file *seq,
1808                                struct inet_timewait_sock *tw, int i)
1809 {
1810         const struct in6_addr *dest, *src;
1811         __u16 destp, srcp;
1812         s32 delta = tw->tw_ttd - inet_tw_time_stamp();
1813 
1814         dest = &tw->tw_v6_daddr;
1815         src  = &tw->tw_v6_rcv_saddr;
1816         destp = ntohs(tw->tw_dport);
1817         srcp  = ntohs(tw->tw_sport);
1818 
1819         seq_printf(seq,
1820                    "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1821                    "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %pK\n",
1822                    i,
1823                    src->s6_addr32[0], src->s6_addr32[1],
1824                    src->s6_addr32[2], src->s6_addr32[3], srcp,
1825                    dest->s6_addr32[0], dest->s6_addr32[1],
1826                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
1827                    tw->tw_substate, 0, 0,
1828                    3, jiffies_delta_to_clock_t(delta), 0, 0, 0, 0,
1829                    atomic_read(&tw->tw_refcnt), tw);
1830 }
1831 
1832 static int tcp6_seq_show(struct seq_file *seq, void *v)
1833 {
1834         struct tcp_iter_state *st;
1835         struct sock *sk = v;
1836 
1837         if (v == SEQ_START_TOKEN) {
1838                 seq_puts(seq,
1839                          "  sl  "
1840                          "local_address                         "
1841                          "remote_address                        "
1842                          "st tx_queue rx_queue tr tm->when retrnsmt"
1843                          "   uid  timeout inode\n");
1844                 goto out;
1845         }
1846         st = seq->private;
1847 
1848         switch (st->state) {
1849         case TCP_SEQ_STATE_LISTENING:
1850         case TCP_SEQ_STATE_ESTABLISHED:
1851                 if (sk->sk_state == TCP_TIME_WAIT)
1852                         get_timewait6_sock(seq, v, st->num);
1853                 else
1854                         get_tcp6_sock(seq, v, st->num);
1855                 break;
1856         case TCP_SEQ_STATE_OPENREQ:
1857                 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
1858                 break;
1859         }
1860 out:
1861         return 0;
1862 }
1863 
1864 static const struct file_operations tcp6_afinfo_seq_fops = {
1865         .owner   = THIS_MODULE,
1866         .open    = tcp_seq_open,
1867         .read    = seq_read,
1868         .llseek  = seq_lseek,
1869         .release = seq_release_net
1870 };
1871 
1872 static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1873         .name           = "tcp6",
1874         .family         = AF_INET6,
1875         .seq_fops       = &tcp6_afinfo_seq_fops,
1876         .seq_ops        = {
1877                 .show           = tcp6_seq_show,
1878         },
1879 };
1880 
1881 int __net_init tcp6_proc_init(struct net *net)
1882 {
1883         return tcp_proc_register(net, &tcp6_seq_afinfo);
1884 }
1885 
1886 void tcp6_proc_exit(struct net *net)
1887 {
1888         tcp_proc_unregister(net, &tcp6_seq_afinfo);
1889 }
1890 #endif
1891 
1892 static void tcp_v6_clear_sk(struct sock *sk, int size)
1893 {
1894         struct inet_sock *inet = inet_sk(sk);
1895 
1896         /* we do not want to clear pinet6 field, because of RCU lookups */
1897         sk_prot_clear_nulls(sk, offsetof(struct inet_sock, pinet6));
1898 
1899         size -= offsetof(struct inet_sock, pinet6) + sizeof(inet->pinet6);
1900         memset(&inet->pinet6 + 1, 0, size);
1901 }
1902 
1903 struct proto tcpv6_prot = {
1904         .name                   = "TCPv6",
1905         .owner                  = THIS_MODULE,
1906         .close                  = tcp_close,
1907         .connect                = tcp_v6_connect,
1908         .disconnect             = tcp_disconnect,
1909         .accept                 = inet_csk_accept,
1910         .ioctl                  = tcp_ioctl,
1911         .init                   = tcp_v6_init_sock,
1912         .destroy                = tcp_v6_destroy_sock,
1913         .shutdown               = tcp_shutdown,
1914         .setsockopt             = tcp_setsockopt,
1915         .getsockopt             = tcp_getsockopt,
1916         .recvmsg                = tcp_recvmsg,
1917         .sendmsg                = tcp_sendmsg,
1918         .sendpage               = tcp_sendpage,
1919         .backlog_rcv            = tcp_v6_do_rcv,
1920         .release_cb             = tcp_release_cb,
1921         .mtu_reduced            = tcp_v6_mtu_reduced,
1922         .hash                   = tcp_v6_hash,
1923         .unhash                 = inet_unhash,
1924         .get_port               = inet_csk_get_port,
1925         .enter_memory_pressure  = tcp_enter_memory_pressure,
1926         .stream_memory_free     = tcp_stream_memory_free,
1927         .sockets_allocated      = &tcp_sockets_allocated,
1928         .memory_allocated       = &tcp_memory_allocated,
1929         .memory_pressure        = &tcp_memory_pressure,
1930         .orphan_count           = &tcp_orphan_count,
1931         .sysctl_mem             = sysctl_tcp_mem,
1932         .sysctl_wmem            = sysctl_tcp_wmem,
1933         .sysctl_rmem            = sysctl_tcp_rmem,
1934         .max_header             = MAX_TCP_HEADER,
1935         .obj_size               = sizeof(struct tcp6_sock),
1936         .slab_flags             = SLAB_DESTROY_BY_RCU,
1937         .twsk_prot              = &tcp6_timewait_sock_ops,
1938         .rsk_prot               = &tcp6_request_sock_ops,
1939         .h.hashinfo             = &tcp_hashinfo,
1940         .no_autobind            = true,
1941 #ifdef CONFIG_COMPAT
1942         .compat_setsockopt      = compat_tcp_setsockopt,
1943         .compat_getsockopt      = compat_tcp_getsockopt,
1944 #endif
1945 #ifdef CONFIG_MEMCG_KMEM
1946         .proto_cgroup           = tcp_proto_cgroup,
1947 #endif
1948         .clear_sk               = tcp_v6_clear_sk,
1949 };
1950 
1951 static const struct inet6_protocol tcpv6_protocol = {
1952         .early_demux    =       tcp_v6_early_demux,
1953         .handler        =       tcp_v6_rcv,
1954         .err_handler    =       tcp_v6_err,
1955         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
1956 };
1957 
1958 static struct inet_protosw tcpv6_protosw = {
1959         .type           =       SOCK_STREAM,
1960         .protocol       =       IPPROTO_TCP,
1961         .prot           =       &tcpv6_prot,
1962         .ops            =       &inet6_stream_ops,
1963         .no_check       =       0,
1964         .flags          =       INET_PROTOSW_PERMANENT |
1965                                 INET_PROTOSW_ICSK,
1966 };
1967 
1968 static int __net_init tcpv6_net_init(struct net *net)
1969 {
1970         return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
1971                                     SOCK_RAW, IPPROTO_TCP, net);
1972 }
1973 
1974 static void __net_exit tcpv6_net_exit(struct net *net)
1975 {
1976         inet_ctl_sock_destroy(net->ipv6.tcp_sk);
1977 }
1978 
1979 static void __net_exit tcpv6_net_exit_batch(struct list_head *net_exit_list)
1980 {
1981         inet_twsk_purge(&tcp_hashinfo, &tcp_death_row, AF_INET6);
1982 }
1983 
1984 static struct pernet_operations tcpv6_net_ops = {
1985         .init       = tcpv6_net_init,
1986         .exit       = tcpv6_net_exit,
1987         .exit_batch = tcpv6_net_exit_batch,
1988 };
1989 
1990 int __init tcpv6_init(void)
1991 {
1992         int ret;
1993 
1994         ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
1995         if (ret)
1996                 goto out;
1997 
1998         /* register inet6 protocol */
1999         ret = inet6_register_protosw(&tcpv6_protosw);
2000         if (ret)
2001                 goto out_tcpv6_protocol;
2002 
2003         ret = register_pernet_subsys(&tcpv6_net_ops);
2004         if (ret)
2005                 goto out_tcpv6_protosw;
2006 out:
2007         return ret;
2008 
2009 out_tcpv6_protosw:
2010         inet6_unregister_protosw(&tcpv6_protosw);
2011 out_tcpv6_protocol:
2012         inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2013         goto out;
2014 }
2015 
2016 void tcpv6_exit(void)
2017 {
2018         unregister_pernet_subsys(&tcpv6_net_ops);
2019         inet6_unregister_protosw(&tcpv6_protosw);
2020         inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2021 }
2022 

~ [ 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