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