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