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