]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - net/ipv6/tcp_ipv6.c
ipv6: remove unused not init_ipv6_mibs/cleanup_ipv6_mibs
[mirror_ubuntu-bionic-kernel.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
26#include <linux/module.h>
1da177e4
LT
27#include <linux/errno.h>
28#include <linux/types.h>
29#include <linux/socket.h>
30#include <linux/sockios.h>
31#include <linux/net.h>
32#include <linux/jiffies.h>
33#include <linux/in.h>
34#include <linux/in6.h>
35#include <linux/netdevice.h>
36#include <linux/init.h>
37#include <linux/jhash.h>
38#include <linux/ipsec.h>
39#include <linux/times.h>
40
41#include <linux/ipv6.h>
42#include <linux/icmpv6.h>
43#include <linux/random.h>
44
45#include <net/tcp.h>
46#include <net/ndisc.h>
5324a040 47#include <net/inet6_hashtables.h>
8129765a 48#include <net/inet6_connection_sock.h>
1da177e4
LT
49#include <net/ipv6.h>
50#include <net/transp_v6.h>
51#include <net/addrconf.h>
52#include <net/ip6_route.h>
53#include <net/ip6_checksum.h>
54#include <net/inet_ecn.h>
55#include <net/protocol.h>
56#include <net/xfrm.h>
1da177e4
LT
57#include <net/snmp.h>
58#include <net/dsfield.h>
6d6ee43e 59#include <net/timewait_sock.h>
18134bed 60#include <net/netdma.h>
3d58b5fa 61#include <net/inet_common.h>
1da177e4
LT
62
63#include <asm/uaccess.h>
64
65#include <linux/proc_fs.h>
66#include <linux/seq_file.h>
67
cfb6eeb4
YH
68#include <linux/crypto.h>
69#include <linux/scatterlist.h>
70
cfb6eeb4 71static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb);
6edafaaf
GJ
72static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
73 struct request_sock *req);
1da177e4
LT
74
75static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb);
1da177e4 76
8292a17a
ACM
77static struct inet_connection_sock_af_ops ipv6_mapped;
78static struct inet_connection_sock_af_ops ipv6_specific;
a928630a 79#ifdef CONFIG_TCP_MD5SIG
cfb6eeb4
YH
80static struct tcp_sock_af_ops tcp_sock_ipv6_specific;
81static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific;
9501f972
YH
82#else
83static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
84 struct in6_addr *addr)
85{
86 return NULL;
87}
a928630a 88#endif
1da177e4 89
1da177e4
LT
90static void tcp_v6_hash(struct sock *sk)
91{
92 if (sk->sk_state != TCP_CLOSE) {
8292a17a 93 if (inet_csk(sk)->icsk_af_ops == &ipv6_mapped) {
1da177e4
LT
94 tcp_prot.hash(sk);
95 return;
96 }
97 local_bh_disable();
ab1e0a13 98 __inet6_hash(sk);
1da177e4
LT
99 local_bh_enable();
100 }
101}
102
868c86bc 103static __inline__ __sum16 tcp_v6_check(struct tcphdr *th, int len,
1ab1457c
YH
104 struct in6_addr *saddr,
105 struct in6_addr *daddr,
868c86bc 106 __wsum base)
1da177e4
LT
107{
108 return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
109}
110
a94f723d 111static __u32 tcp_v6_init_sequence(struct sk_buff *skb)
1da177e4 112{
0660e03f
ACM
113 return secure_tcpv6_sequence_number(ipv6_hdr(skb)->daddr.s6_addr32,
114 ipv6_hdr(skb)->saddr.s6_addr32,
aa8223c7
ACM
115 tcp_hdr(skb)->dest,
116 tcp_hdr(skb)->source);
1da177e4
LT
117}
118
1ab1457c 119static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr,
1da177e4
LT
120 int addr_len)
121{
122 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
1ab1457c 123 struct inet_sock *inet = inet_sk(sk);
d83d8461 124 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT
125 struct ipv6_pinfo *np = inet6_sk(sk);
126 struct tcp_sock *tp = tcp_sk(sk);
127 struct in6_addr *saddr = NULL, *final_p = NULL, final;
128 struct flowi fl;
129 struct dst_entry *dst;
130 int addr_type;
131 int err;
132
1ab1457c 133 if (addr_len < SIN6_LEN_RFC2133)
1da177e4
LT
134 return -EINVAL;
135
1ab1457c 136 if (usin->sin6_family != AF_INET6)
1da177e4
LT
137 return(-EAFNOSUPPORT);
138
139 memset(&fl, 0, sizeof(fl));
140
141 if (np->sndflow) {
142 fl.fl6_flowlabel = usin->sin6_flowinfo&IPV6_FLOWINFO_MASK;
143 IP6_ECN_flow_init(fl.fl6_flowlabel);
144 if (fl.fl6_flowlabel&IPV6_FLOWLABEL_MASK) {
145 struct ip6_flowlabel *flowlabel;
146 flowlabel = fl6_sock_lookup(sk, fl.fl6_flowlabel);
147 if (flowlabel == NULL)
148 return -EINVAL;
149 ipv6_addr_copy(&usin->sin6_addr, &flowlabel->dst);
150 fl6_sock_release(flowlabel);
151 }
152 }
153
154 /*
1ab1457c
YH
155 * connect() to INADDR_ANY means loopback (BSD'ism).
156 */
157
158 if(ipv6_addr_any(&usin->sin6_addr))
159 usin->sin6_addr.s6_addr[15] = 0x1;
1da177e4
LT
160
161 addr_type = ipv6_addr_type(&usin->sin6_addr);
162
163 if(addr_type & IPV6_ADDR_MULTICAST)
164 return -ENETUNREACH;
165
166 if (addr_type&IPV6_ADDR_LINKLOCAL) {
167 if (addr_len >= sizeof(struct sockaddr_in6) &&
168 usin->sin6_scope_id) {
169 /* If interface is set while binding, indices
170 * must coincide.
171 */
172 if (sk->sk_bound_dev_if &&
173 sk->sk_bound_dev_if != usin->sin6_scope_id)
174 return -EINVAL;
175
176 sk->sk_bound_dev_if = usin->sin6_scope_id;
177 }
178
179 /* Connect to link-local address requires an interface */
180 if (!sk->sk_bound_dev_if)
181 return -EINVAL;
182 }
183
184 if (tp->rx_opt.ts_recent_stamp &&
185 !ipv6_addr_equal(&np->daddr, &usin->sin6_addr)) {
186 tp->rx_opt.ts_recent = 0;
187 tp->rx_opt.ts_recent_stamp = 0;
188 tp->write_seq = 0;
189 }
190
191 ipv6_addr_copy(&np->daddr, &usin->sin6_addr);
192 np->flow_label = fl.fl6_flowlabel;
193
194 /*
195 * TCP over IPv4
196 */
197
198 if (addr_type == IPV6_ADDR_MAPPED) {
d83d8461 199 u32 exthdrlen = icsk->icsk_ext_hdr_len;
1da177e4
LT
200 struct sockaddr_in sin;
201
202 SOCK_DEBUG(sk, "connect: ipv4 mapped\n");
203
204 if (__ipv6_only_sock(sk))
205 return -ENETUNREACH;
206
207 sin.sin_family = AF_INET;
208 sin.sin_port = usin->sin6_port;
209 sin.sin_addr.s_addr = usin->sin6_addr.s6_addr32[3];
210
d83d8461 211 icsk->icsk_af_ops = &ipv6_mapped;
1da177e4 212 sk->sk_backlog_rcv = tcp_v4_do_rcv;
cfb6eeb4
YH
213#ifdef CONFIG_TCP_MD5SIG
214 tp->af_specific = &tcp_sock_ipv6_mapped_specific;
215#endif
1da177e4
LT
216
217 err = tcp_v4_connect(sk, (struct sockaddr *)&sin, sizeof(sin));
218
219 if (err) {
d83d8461
ACM
220 icsk->icsk_ext_hdr_len = exthdrlen;
221 icsk->icsk_af_ops = &ipv6_specific;
1da177e4 222 sk->sk_backlog_rcv = tcp_v6_do_rcv;
cfb6eeb4
YH
223#ifdef CONFIG_TCP_MD5SIG
224 tp->af_specific = &tcp_sock_ipv6_specific;
225#endif
1da177e4
LT
226 goto failure;
227 } else {
228 ipv6_addr_set(&np->saddr, 0, 0, htonl(0x0000FFFF),
229 inet->saddr);
230 ipv6_addr_set(&np->rcv_saddr, 0, 0, htonl(0x0000FFFF),
231 inet->rcv_saddr);
232 }
233
234 return err;
235 }
236
237 if (!ipv6_addr_any(&np->rcv_saddr))
238 saddr = &np->rcv_saddr;
239
240 fl.proto = IPPROTO_TCP;
241 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
242 ipv6_addr_copy(&fl.fl6_src,
243 (saddr ? saddr : &np->saddr));
244 fl.oif = sk->sk_bound_dev_if;
245 fl.fl_ip_dport = usin->sin6_port;
246 fl.fl_ip_sport = inet->sport;
247
248 if (np->opt && np->opt->srcrt) {
249 struct rt0_hdr *rt0 = (struct rt0_hdr *)np->opt->srcrt;
250 ipv6_addr_copy(&final, &fl.fl6_dst);
251 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
252 final_p = &final;
253 }
254
beb8d13b
VY
255 security_sk_classify_flow(sk, &fl);
256
1da177e4
LT
257 err = ip6_dst_lookup(sk, &dst, &fl);
258 if (err)
259 goto failure;
260 if (final_p)
261 ipv6_addr_copy(&fl.fl6_dst, final_p);
262
bb72845e 263 if ((err = __xfrm_lookup(&dst, &fl, sk, XFRM_LOOKUP_WAIT)) < 0) {
14e50e57
DM
264 if (err == -EREMOTE)
265 err = ip6_dst_blackhole(sk, &dst, &fl);
266 if (err < 0)
267 goto failure;
268 }
1da177e4
LT
269
270 if (saddr == NULL) {
271 saddr = &fl.fl6_src;
272 ipv6_addr_copy(&np->rcv_saddr, saddr);
273 }
274
275 /* set the source address */
276 ipv6_addr_copy(&np->saddr, saddr);
277 inet->rcv_saddr = LOOPBACK4_IPV6;
278
f83ef8c0 279 sk->sk_gso_type = SKB_GSO_TCPV6;
8e1ef0a9 280 __ip6_dst_store(sk, dst, NULL, NULL);
1da177e4 281
d83d8461 282 icsk->icsk_ext_hdr_len = 0;
1da177e4 283 if (np->opt)
d83d8461
ACM
284 icsk->icsk_ext_hdr_len = (np->opt->opt_flen +
285 np->opt->opt_nflen);
1da177e4
LT
286
287 tp->rx_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
288
289 inet->dport = usin->sin6_port;
290
291 tcp_set_state(sk, TCP_SYN_SENT);
d8313f5c 292 err = inet6_hash_connect(&tcp_death_row, sk);
1da177e4
LT
293 if (err)
294 goto late_failure;
295
296 if (!tp->write_seq)
297 tp->write_seq = secure_tcpv6_sequence_number(np->saddr.s6_addr32,
298 np->daddr.s6_addr32,
299 inet->sport,
300 inet->dport);
301
302 err = tcp_connect(sk);
303 if (err)
304 goto late_failure;
305
306 return 0;
307
308late_failure:
309 tcp_set_state(sk, TCP_CLOSE);
310 __sk_dst_reset(sk);
311failure:
312 inet->dport = 0;
313 sk->sk_route_caps = 0;
314 return err;
315}
316
317static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
04ce6909 318 int type, int code, int offset, __be32 info)
1da177e4
LT
319{
320 struct ipv6hdr *hdr = (struct ipv6hdr*)skb->data;
505cbfc5 321 const struct tcphdr *th = (struct tcphdr *)(skb->data+offset);
1da177e4
LT
322 struct ipv6_pinfo *np;
323 struct sock *sk;
324 int err;
1ab1457c 325 struct tcp_sock *tp;
1da177e4 326 __u32 seq;
ca12a1a4 327 struct net *net = dev_net(skb->dev);
1da177e4 328
ca12a1a4 329 sk = inet6_lookup(net, &tcp_hashinfo, &hdr->daddr,
d86e0dac 330 th->dest, &hdr->saddr, th->source, skb->dev->ifindex);
1da177e4
LT
331
332 if (sk == NULL) {
e41b5368
DL
333 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev),
334 ICMP6_MIB_INERRORS);
1da177e4
LT
335 return;
336 }
337
338 if (sk->sk_state == TCP_TIME_WAIT) {
9469c7b4 339 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
340 return;
341 }
342
343 bh_lock_sock(sk);
344 if (sock_owned_by_user(sk))
de0744af 345 NET_INC_STATS_BH(net, LINUX_MIB_LOCKDROPPEDICMPS);
1da177e4
LT
346
347 if (sk->sk_state == TCP_CLOSE)
348 goto out;
349
350 tp = tcp_sk(sk);
1ab1457c 351 seq = ntohl(th->seq);
1da177e4
LT
352 if (sk->sk_state != TCP_LISTEN &&
353 !between(seq, tp->snd_una, tp->snd_nxt)) {
de0744af 354 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
1da177e4
LT
355 goto out;
356 }
357
358 np = inet6_sk(sk);
359
360 if (type == ICMPV6_PKT_TOOBIG) {
361 struct dst_entry *dst = NULL;
362
363 if (sock_owned_by_user(sk))
364 goto out;
365 if ((1 << sk->sk_state) & (TCPF_LISTEN | TCPF_CLOSE))
366 goto out;
367
368 /* icmp should have updated the destination cache entry */
369 dst = __sk_dst_check(sk, np->dst_cookie);
370
371 if (dst == NULL) {
372 struct inet_sock *inet = inet_sk(sk);
373 struct flowi fl;
374
375 /* BUGGG_FUTURE: Again, it is not clear how
376 to handle rthdr case. Ignore this complexity
377 for now.
378 */
379 memset(&fl, 0, sizeof(fl));
380 fl.proto = IPPROTO_TCP;
381 ipv6_addr_copy(&fl.fl6_dst, &np->daddr);
382 ipv6_addr_copy(&fl.fl6_src, &np->saddr);
383 fl.oif = sk->sk_bound_dev_if;
384 fl.fl_ip_dport = inet->dport;
385 fl.fl_ip_sport = inet->sport;
beb8d13b 386 security_skb_classify_flow(skb, &fl);
1da177e4
LT
387
388 if ((err = ip6_dst_lookup(sk, &dst, &fl))) {
389 sk->sk_err_soft = -err;
390 goto out;
391 }
392
393 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) {
394 sk->sk_err_soft = -err;
395 goto out;
396 }
397
398 } else
399 dst_hold(dst);
400
d83d8461 401 if (inet_csk(sk)->icsk_pmtu_cookie > dst_mtu(dst)) {
1da177e4
LT
402 tcp_sync_mss(sk, dst_mtu(dst));
403 tcp_simple_retransmit(sk);
404 } /* else let the usual retransmit timer handle it */
405 dst_release(dst);
406 goto out;
407 }
408
409 icmpv6_err_convert(type, code, &err);
410
60236fdd 411 /* Might be for an request_sock */
1da177e4 412 switch (sk->sk_state) {
60236fdd 413 struct request_sock *req, **prev;
1da177e4
LT
414 case TCP_LISTEN:
415 if (sock_owned_by_user(sk))
416 goto out;
417
8129765a
ACM
418 req = inet6_csk_search_req(sk, &prev, th->dest, &hdr->daddr,
419 &hdr->saddr, inet6_iif(skb));
1da177e4
LT
420 if (!req)
421 goto out;
422
423 /* ICMPs are not backlogged, hence we cannot get
424 * an established socket here.
425 */
547b792c 426 WARN_ON(req->sk != NULL);
1da177e4 427
2e6599cb 428 if (seq != tcp_rsk(req)->snt_isn) {
de0744af 429 NET_INC_STATS_BH(net, LINUX_MIB_OUTOFWINDOWICMPS);
1da177e4
LT
430 goto out;
431 }
432
463c84b9 433 inet_csk_reqsk_queue_drop(sk, req, prev);
1da177e4
LT
434 goto out;
435
436 case TCP_SYN_SENT:
437 case TCP_SYN_RECV: /* Cannot happen.
1ab1457c 438 It can, it SYNs are crossed. --ANK */
1da177e4 439 if (!sock_owned_by_user(sk)) {
1da177e4
LT
440 sk->sk_err = err;
441 sk->sk_error_report(sk); /* Wake people up to see the error (see connect in sock.c) */
442
443 tcp_done(sk);
444 } else
445 sk->sk_err_soft = err;
446 goto out;
447 }
448
449 if (!sock_owned_by_user(sk) && np->recverr) {
450 sk->sk_err = err;
451 sk->sk_error_report(sk);
452 } else
453 sk->sk_err_soft = err;
454
455out:
456 bh_unlock_sock(sk);
457 sock_put(sk);
458}
459
460
fd80eb94 461static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req)
1da177e4 462{
ca304b61 463 struct inet6_request_sock *treq = inet6_rsk(req);
1da177e4
LT
464 struct ipv6_pinfo *np = inet6_sk(sk);
465 struct sk_buff * skb;
466 struct ipv6_txoptions *opt = NULL;
467 struct in6_addr * final_p = NULL, final;
468 struct flowi fl;
fd80eb94 469 struct dst_entry *dst;
1da177e4
LT
470 int err = -1;
471
472 memset(&fl, 0, sizeof(fl));
473 fl.proto = IPPROTO_TCP;
2e6599cb
ACM
474 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
475 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 476 fl.fl6_flowlabel = 0;
2e6599cb
ACM
477 fl.oif = treq->iif;
478 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4 479 fl.fl_ip_sport = inet_sk(sk)->sport;
4237c75c 480 security_req_classify_flow(req, &fl);
1da177e4 481
fd80eb94
DL
482 opt = np->opt;
483 if (opt && opt->srcrt) {
484 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
485 ipv6_addr_copy(&final, &fl.fl6_dst);
486 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
487 final_p = &final;
1da177e4
LT
488 }
489
fd80eb94
DL
490 err = ip6_dst_lookup(sk, &dst, &fl);
491 if (err)
492 goto done;
493 if (final_p)
494 ipv6_addr_copy(&fl.fl6_dst, final_p);
495 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
496 goto done;
497
1da177e4
LT
498 skb = tcp_make_synack(sk, dst, req);
499 if (skb) {
aa8223c7 500 struct tcphdr *th = tcp_hdr(skb);
1da177e4
LT
501
502 th->check = tcp_v6_check(th, skb->len,
2e6599cb 503 &treq->loc_addr, &treq->rmt_addr,
1da177e4
LT
504 csum_partial((char *)th, skb->len, skb->csum));
505
2e6599cb 506 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4 507 err = ip6_xmit(sk, skb, &fl, opt, 0);
b9df3cb8 508 err = net_xmit_eval(err);
1da177e4
LT
509 }
510
511done:
1ab1457c 512 if (opt && opt != np->opt)
1da177e4 513 sock_kfree_s(sk, opt, opt->tot_len);
78b91042 514 dst_release(dst);
1da177e4
LT
515 return err;
516}
517
c6aefafb
GG
518static inline void syn_flood_warning(struct sk_buff *skb)
519{
520#ifdef CONFIG_SYN_COOKIES
521 if (sysctl_tcp_syncookies)
522 printk(KERN_INFO
523 "TCPv6: Possible SYN flooding on port %d. "
524 "Sending cookies.\n", ntohs(tcp_hdr(skb)->dest));
525 else
526#endif
527 printk(KERN_INFO
528 "TCPv6: Possible SYN flooding on port %d. "
529 "Dropping request.\n", ntohs(tcp_hdr(skb)->dest));
530}
531
60236fdd 532static void tcp_v6_reqsk_destructor(struct request_sock *req)
1da177e4 533{
ca304b61
ACM
534 if (inet6_rsk(req)->pktopts)
535 kfree_skb(inet6_rsk(req)->pktopts);
1da177e4
LT
536}
537
cfb6eeb4
YH
538#ifdef CONFIG_TCP_MD5SIG
539static struct tcp_md5sig_key *tcp_v6_md5_do_lookup(struct sock *sk,
540 struct in6_addr *addr)
541{
542 struct tcp_sock *tp = tcp_sk(sk);
543 int i;
544
545 BUG_ON(tp == NULL);
546
547 if (!tp->md5sig_info || !tp->md5sig_info->entries6)
548 return NULL;
549
550 for (i = 0; i < tp->md5sig_info->entries6; i++) {
caad295f 551 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, addr))
f8ab18d2 552 return &tp->md5sig_info->keys6[i].base;
cfb6eeb4
YH
553 }
554 return NULL;
555}
556
557static struct tcp_md5sig_key *tcp_v6_md5_lookup(struct sock *sk,
558 struct sock *addr_sk)
559{
560 return tcp_v6_md5_do_lookup(sk, &inet6_sk(addr_sk)->daddr);
561}
562
563static struct tcp_md5sig_key *tcp_v6_reqsk_md5_lookup(struct sock *sk,
564 struct request_sock *req)
565{
566 return tcp_v6_md5_do_lookup(sk, &inet6_rsk(req)->rmt_addr);
567}
568
569static int tcp_v6_md5_do_add(struct sock *sk, struct in6_addr *peer,
570 char *newkey, u8 newkeylen)
571{
572 /* Add key to the list */
b0a713e9 573 struct tcp_md5sig_key *key;
cfb6eeb4
YH
574 struct tcp_sock *tp = tcp_sk(sk);
575 struct tcp6_md5sig_key *keys;
576
b0a713e9 577 key = tcp_v6_md5_do_lookup(sk, peer);
cfb6eeb4
YH
578 if (key) {
579 /* modify existing entry - just update that one */
b0a713e9
MD
580 kfree(key->key);
581 key->key = newkey;
582 key->keylen = newkeylen;
cfb6eeb4
YH
583 } else {
584 /* reallocate new list if current one is full. */
585 if (!tp->md5sig_info) {
586 tp->md5sig_info = kzalloc(sizeof(*tp->md5sig_info), GFP_ATOMIC);
587 if (!tp->md5sig_info) {
588 kfree(newkey);
589 return -ENOMEM;
590 }
3d7dbeac 591 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
cfb6eeb4 592 }
aacbe8c8
YH
593 if (tcp_alloc_md5sig_pool() == NULL) {
594 kfree(newkey);
595 return -ENOMEM;
596 }
cfb6eeb4
YH
597 if (tp->md5sig_info->alloced6 == tp->md5sig_info->entries6) {
598 keys = kmalloc((sizeof (tp->md5sig_info->keys6[0]) *
599 (tp->md5sig_info->entries6 + 1)), GFP_ATOMIC);
600
601 if (!keys) {
602 tcp_free_md5sig_pool();
603 kfree(newkey);
604 return -ENOMEM;
605 }
606
607 if (tp->md5sig_info->entries6)
608 memmove(keys, tp->md5sig_info->keys6,
609 (sizeof (tp->md5sig_info->keys6[0]) *
610 tp->md5sig_info->entries6));
611
612 kfree(tp->md5sig_info->keys6);
613 tp->md5sig_info->keys6 = keys;
614 tp->md5sig_info->alloced6++;
615 }
616
617 ipv6_addr_copy(&tp->md5sig_info->keys6[tp->md5sig_info->entries6].addr,
618 peer);
f8ab18d2
DM
619 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.key = newkey;
620 tp->md5sig_info->keys6[tp->md5sig_info->entries6].base.keylen = newkeylen;
cfb6eeb4
YH
621
622 tp->md5sig_info->entries6++;
623 }
624 return 0;
625}
626
627static int tcp_v6_md5_add_func(struct sock *sk, struct sock *addr_sk,
628 u8 *newkey, __u8 newkeylen)
629{
630 return tcp_v6_md5_do_add(sk, &inet6_sk(addr_sk)->daddr,
631 newkey, newkeylen);
632}
633
634static int tcp_v6_md5_do_del(struct sock *sk, struct in6_addr *peer)
635{
636 struct tcp_sock *tp = tcp_sk(sk);
637 int i;
638
639 for (i = 0; i < tp->md5sig_info->entries6; i++) {
caad295f 640 if (ipv6_addr_equal(&tp->md5sig_info->keys6[i].addr, peer)) {
cfb6eeb4 641 /* Free the key */
f8ab18d2 642 kfree(tp->md5sig_info->keys6[i].base.key);
cfb6eeb4
YH
643 tp->md5sig_info->entries6--;
644
645 if (tp->md5sig_info->entries6 == 0) {
646 kfree(tp->md5sig_info->keys6);
647 tp->md5sig_info->keys6 = NULL;
ca983cef 648 tp->md5sig_info->alloced6 = 0;
cfb6eeb4
YH
649 } else {
650 /* shrink the database */
651 if (tp->md5sig_info->entries6 != i)
652 memmove(&tp->md5sig_info->keys6[i],
653 &tp->md5sig_info->keys6[i+1],
654 (tp->md5sig_info->entries6 - i)
655 * sizeof (tp->md5sig_info->keys6[0]));
656 }
77adefdc
YH
657 tcp_free_md5sig_pool();
658 return 0;
cfb6eeb4
YH
659 }
660 }
661 return -ENOENT;
662}
663
664static void tcp_v6_clear_md5_list (struct sock *sk)
665{
666 struct tcp_sock *tp = tcp_sk(sk);
667 int i;
668
669 if (tp->md5sig_info->entries6) {
670 for (i = 0; i < tp->md5sig_info->entries6; i++)
f8ab18d2 671 kfree(tp->md5sig_info->keys6[i].base.key);
cfb6eeb4
YH
672 tp->md5sig_info->entries6 = 0;
673 tcp_free_md5sig_pool();
674 }
675
676 kfree(tp->md5sig_info->keys6);
677 tp->md5sig_info->keys6 = NULL;
678 tp->md5sig_info->alloced6 = 0;
679
680 if (tp->md5sig_info->entries4) {
681 for (i = 0; i < tp->md5sig_info->entries4; i++)
f8ab18d2 682 kfree(tp->md5sig_info->keys4[i].base.key);
cfb6eeb4
YH
683 tp->md5sig_info->entries4 = 0;
684 tcp_free_md5sig_pool();
685 }
686
687 kfree(tp->md5sig_info->keys4);
688 tp->md5sig_info->keys4 = NULL;
689 tp->md5sig_info->alloced4 = 0;
690}
691
692static int tcp_v6_parse_md5_keys (struct sock *sk, char __user *optval,
693 int optlen)
694{
695 struct tcp_md5sig cmd;
696 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&cmd.tcpm_addr;
697 u8 *newkey;
698
699 if (optlen < sizeof(cmd))
700 return -EINVAL;
701
702 if (copy_from_user(&cmd, optval, sizeof(cmd)))
703 return -EFAULT;
704
705 if (sin6->sin6_family != AF_INET6)
706 return -EINVAL;
707
708 if (!cmd.tcpm_keylen) {
709 if (!tcp_sk(sk)->md5sig_info)
710 return -ENOENT;
e773e4fa 711 if (ipv6_addr_v4mapped(&sin6->sin6_addr))
cfb6eeb4
YH
712 return tcp_v4_md5_do_del(sk, sin6->sin6_addr.s6_addr32[3]);
713 return tcp_v6_md5_do_del(sk, &sin6->sin6_addr);
714 }
715
716 if (cmd.tcpm_keylen > TCP_MD5SIG_MAXKEYLEN)
717 return -EINVAL;
718
719 if (!tcp_sk(sk)->md5sig_info) {
720 struct tcp_sock *tp = tcp_sk(sk);
721 struct tcp_md5sig_info *p;
722
723 p = kzalloc(sizeof(struct tcp_md5sig_info), GFP_KERNEL);
724 if (!p)
725 return -ENOMEM;
726
727 tp->md5sig_info = p;
3d7dbeac 728 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
cfb6eeb4
YH
729 }
730
af879cc7 731 newkey = kmemdup(cmd.tcpm_key, cmd.tcpm_keylen, GFP_KERNEL);
cfb6eeb4
YH
732 if (!newkey)
733 return -ENOMEM;
e773e4fa 734 if (ipv6_addr_v4mapped(&sin6->sin6_addr)) {
cfb6eeb4
YH
735 return tcp_v4_md5_do_add(sk, sin6->sin6_addr.s6_addr32[3],
736 newkey, cmd.tcpm_keylen);
737 }
738 return tcp_v6_md5_do_add(sk, &sin6->sin6_addr, newkey, cmd.tcpm_keylen);
739}
740
49a72dfb
AL
741static int tcp_v6_md5_hash_pseudoheader(struct tcp_md5sig_pool *hp,
742 struct in6_addr *daddr,
743 struct in6_addr *saddr, int nbytes)
cfb6eeb4 744{
cfb6eeb4 745 struct tcp6_pseudohdr *bp;
49a72dfb 746 struct scatterlist sg;
8d26d76d 747
cfb6eeb4 748 bp = &hp->md5_blk.ip6;
cfb6eeb4
YH
749 /* 1. TCP pseudo-header (RFC2460) */
750 ipv6_addr_copy(&bp->saddr, saddr);
751 ipv6_addr_copy(&bp->daddr, daddr);
49a72dfb 752 bp->protocol = cpu_to_be32(IPPROTO_TCP);
00b1304c 753 bp->len = cpu_to_be32(nbytes);
cfb6eeb4 754
49a72dfb
AL
755 sg_init_one(&sg, bp, sizeof(*bp));
756 return crypto_hash_update(&hp->md5_desc, &sg, sizeof(*bp));
757}
c7da57a1 758
49a72dfb
AL
759static int tcp_v6_md5_hash_hdr(char *md5_hash, struct tcp_md5sig_key *key,
760 struct in6_addr *daddr, struct in6_addr *saddr,
761 struct tcphdr *th)
762{
763 struct tcp_md5sig_pool *hp;
764 struct hash_desc *desc;
765
766 hp = tcp_get_md5sig_pool();
767 if (!hp)
768 goto clear_hash_noput;
769 desc = &hp->md5_desc;
770
771 if (crypto_hash_init(desc))
772 goto clear_hash;
773 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, th->doff << 2))
774 goto clear_hash;
775 if (tcp_md5_hash_header(hp, th))
776 goto clear_hash;
777 if (tcp_md5_hash_key(hp, key))
778 goto clear_hash;
779 if (crypto_hash_final(desc, md5_hash))
cfb6eeb4 780 goto clear_hash;
cfb6eeb4 781
cfb6eeb4 782 tcp_put_md5sig_pool();
cfb6eeb4 783 return 0;
49a72dfb 784
cfb6eeb4
YH
785clear_hash:
786 tcp_put_md5sig_pool();
787clear_hash_noput:
788 memset(md5_hash, 0, 16);
49a72dfb 789 return 1;
cfb6eeb4
YH
790}
791
49a72dfb
AL
792static int tcp_v6_md5_hash_skb(char *md5_hash, struct tcp_md5sig_key *key,
793 struct sock *sk, struct request_sock *req,
794 struct sk_buff *skb)
cfb6eeb4
YH
795{
796 struct in6_addr *saddr, *daddr;
49a72dfb
AL
797 struct tcp_md5sig_pool *hp;
798 struct hash_desc *desc;
799 struct tcphdr *th = tcp_hdr(skb);
cfb6eeb4
YH
800
801 if (sk) {
802 saddr = &inet6_sk(sk)->saddr;
803 daddr = &inet6_sk(sk)->daddr;
49a72dfb 804 } else if (req) {
cfb6eeb4
YH
805 saddr = &inet6_rsk(req)->loc_addr;
806 daddr = &inet6_rsk(req)->rmt_addr;
49a72dfb
AL
807 } else {
808 struct ipv6hdr *ip6h = ipv6_hdr(skb);
809 saddr = &ip6h->saddr;
810 daddr = &ip6h->daddr;
cfb6eeb4 811 }
49a72dfb
AL
812
813 hp = tcp_get_md5sig_pool();
814 if (!hp)
815 goto clear_hash_noput;
816 desc = &hp->md5_desc;
817
818 if (crypto_hash_init(desc))
819 goto clear_hash;
820
821 if (tcp_v6_md5_hash_pseudoheader(hp, daddr, saddr, skb->len))
822 goto clear_hash;
823 if (tcp_md5_hash_header(hp, th))
824 goto clear_hash;
825 if (tcp_md5_hash_skb_data(hp, skb, th->doff << 2))
826 goto clear_hash;
827 if (tcp_md5_hash_key(hp, key))
828 goto clear_hash;
829 if (crypto_hash_final(desc, md5_hash))
830 goto clear_hash;
831
832 tcp_put_md5sig_pool();
833 return 0;
834
835clear_hash:
836 tcp_put_md5sig_pool();
837clear_hash_noput:
838 memset(md5_hash, 0, 16);
839 return 1;
cfb6eeb4
YH
840}
841
842static int tcp_v6_inbound_md5_hash (struct sock *sk, struct sk_buff *skb)
843{
844 __u8 *hash_location = NULL;
845 struct tcp_md5sig_key *hash_expected;
0660e03f 846 struct ipv6hdr *ip6h = ipv6_hdr(skb);
aa8223c7 847 struct tcphdr *th = tcp_hdr(skb);
cfb6eeb4 848 int genhash;
cfb6eeb4
YH
849 u8 newhash[16];
850
851 hash_expected = tcp_v6_md5_do_lookup(sk, &ip6h->saddr);
7d5d5525 852 hash_location = tcp_parse_md5sig_option(th);
cfb6eeb4 853
785957d3
DM
854 /* We've parsed the options - do we have a hash? */
855 if (!hash_expected && !hash_location)
856 return 0;
857
858 if (hash_expected && !hash_location) {
859 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5NOTFOUND);
cfb6eeb4
YH
860 return 1;
861 }
862
785957d3
DM
863 if (!hash_expected && hash_location) {
864 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPMD5UNEXPECTED);
cfb6eeb4
YH
865 return 1;
866 }
867
868 /* check the signature */
49a72dfb
AL
869 genhash = tcp_v6_md5_hash_skb(newhash,
870 hash_expected,
871 NULL, NULL, skb);
872
cfb6eeb4
YH
873 if (genhash || memcmp(hash_location, newhash, 16) != 0) {
874 if (net_ratelimit()) {
875 printk(KERN_INFO "MD5 Hash %s for "
876 "(" NIP6_FMT ", %u)->"
877 "(" NIP6_FMT ", %u)\n",
878 genhash ? "failed" : "mismatch",
879 NIP6(ip6h->saddr), ntohs(th->source),
880 NIP6(ip6h->daddr), ntohs(th->dest));
881 }
882 return 1;
883 }
884 return 0;
885}
886#endif
887
c6aefafb 888struct request_sock_ops tcp6_request_sock_ops __read_mostly = {
1da177e4 889 .family = AF_INET6,
2e6599cb 890 .obj_size = sizeof(struct tcp6_request_sock),
1da177e4 891 .rtx_syn_ack = tcp_v6_send_synack,
60236fdd
ACM
892 .send_ack = tcp_v6_reqsk_send_ack,
893 .destructor = tcp_v6_reqsk_destructor,
1da177e4
LT
894 .send_reset = tcp_v6_send_reset
895};
896
cfb6eeb4 897#ifdef CONFIG_TCP_MD5SIG
b6332e6c 898static struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {
cfb6eeb4 899 .md5_lookup = tcp_v6_reqsk_md5_lookup,
cfb6eeb4 900};
b6332e6c 901#endif
cfb6eeb4 902
6d6ee43e
ACM
903static struct timewait_sock_ops tcp6_timewait_sock_ops = {
904 .twsk_obj_size = sizeof(struct tcp6_timewait_sock),
905 .twsk_unique = tcp_twsk_unique,
cfb6eeb4 906 .twsk_destructor= tcp_twsk_destructor,
6d6ee43e
ACM
907};
908
8292a17a 909static void tcp_v6_send_check(struct sock *sk, int len, struct sk_buff *skb)
1da177e4
LT
910{
911 struct ipv6_pinfo *np = inet6_sk(sk);
aa8223c7 912 struct tcphdr *th = tcp_hdr(skb);
1da177e4 913
84fa7933 914 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1da177e4 915 th->check = ~csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP, 0);
663ead3b 916 skb->csum_start = skb_transport_header(skb) - skb->head;
ff1dcadb 917 skb->csum_offset = offsetof(struct tcphdr, check);
1da177e4 918 } else {
1ab1457c
YH
919 th->check = csum_ipv6_magic(&np->saddr, &np->daddr, len, IPPROTO_TCP,
920 csum_partial((char *)th, th->doff<<2,
1da177e4
LT
921 skb->csum));
922 }
923}
924
a430a43d
HX
925static int tcp_v6_gso_send_check(struct sk_buff *skb)
926{
927 struct ipv6hdr *ipv6h;
928 struct tcphdr *th;
929
930 if (!pskb_may_pull(skb, sizeof(*th)))
931 return -EINVAL;
932
0660e03f 933 ipv6h = ipv6_hdr(skb);
aa8223c7 934 th = tcp_hdr(skb);
a430a43d
HX
935
936 th->check = 0;
937 th->check = ~csum_ipv6_magic(&ipv6h->saddr, &ipv6h->daddr, skb->len,
938 IPPROTO_TCP, 0);
663ead3b 939 skb->csum_start = skb_transport_header(skb) - skb->head;
ff1dcadb 940 skb->csum_offset = offsetof(struct tcphdr, check);
84fa7933 941 skb->ip_summed = CHECKSUM_PARTIAL;
a430a43d
HX
942 return 0;
943}
1da177e4 944
cfb6eeb4 945static void tcp_v6_send_reset(struct sock *sk, struct sk_buff *skb)
1da177e4 946{
aa8223c7 947 struct tcphdr *th = tcp_hdr(skb), *t1;
1da177e4
LT
948 struct sk_buff *buff;
949 struct flowi fl;
c346dca1 950 struct net *net = dev_net(skb->dst->dev);
e5047992 951 struct sock *ctl_sk = net->ipv6.tcp_sk;
9cb5734e 952 unsigned int tot_len = sizeof(*th);
cfb6eeb4
YH
953#ifdef CONFIG_TCP_MD5SIG
954 struct tcp_md5sig_key *key;
955#endif
1da177e4
LT
956
957 if (th->rst)
958 return;
959
960 if (!ipv6_unicast_destination(skb))
1ab1457c 961 return;
1da177e4 962
cfb6eeb4
YH
963#ifdef CONFIG_TCP_MD5SIG
964 if (sk)
0660e03f 965 key = tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr);
cfb6eeb4
YH
966 else
967 key = NULL;
968
969 if (key)
970 tot_len += TCPOLEN_MD5SIG_ALIGNED;
971#endif
972
1da177e4
LT
973 /*
974 * We need to grab some memory, and put together an RST,
975 * and then put it into the queue to be sent.
976 */
977
cfb6eeb4 978 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1da177e4 979 GFP_ATOMIC);
1ab1457c
YH
980 if (buff == NULL)
981 return;
1da177e4 982
cfb6eeb4 983 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1da177e4 984
cfb6eeb4 985 t1 = (struct tcphdr *) skb_push(buff, tot_len);
1da177e4
LT
986
987 /* Swap the send and the receive. */
988 memset(t1, 0, sizeof(*t1));
989 t1->dest = th->source;
990 t1->source = th->dest;
cfb6eeb4 991 t1->doff = tot_len / 4;
1da177e4 992 t1->rst = 1;
1ab1457c 993
1da177e4 994 if(th->ack) {
1ab1457c 995 t1->seq = th->ack_seq;
1da177e4
LT
996 } else {
997 t1->ack = 1;
998 t1->ack_seq = htonl(ntohl(th->seq) + th->syn + th->fin
999 + skb->len - (th->doff<<2));
1000 }
1001
cfb6eeb4
YH
1002#ifdef CONFIG_TCP_MD5SIG
1003 if (key) {
8e5200f5 1004 __be32 *opt = (__be32*)(t1 + 1);
cfb6eeb4
YH
1005 opt[0] = htonl((TCPOPT_NOP << 24) |
1006 (TCPOPT_NOP << 16) |
1007 (TCPOPT_MD5SIG << 8) |
1008 TCPOLEN_MD5SIG);
49a72dfb
AL
1009 tcp_v6_md5_hash_hdr((__u8 *)&opt[1], key,
1010 &ipv6_hdr(skb)->daddr,
1011 &ipv6_hdr(skb)->saddr, t1);
cfb6eeb4
YH
1012 }
1013#endif
1014
1da177e4
LT
1015 buff->csum = csum_partial((char *)t1, sizeof(*t1), 0);
1016
1017 memset(&fl, 0, sizeof(fl));
0660e03f
ACM
1018 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1019 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
1da177e4
LT
1020
1021 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1022 sizeof(*t1), IPPROTO_TCP,
1023 buff->csum);
1024
1025 fl.proto = IPPROTO_TCP;
505cbfc5 1026 fl.oif = inet6_iif(skb);
1da177e4
LT
1027 fl.fl_ip_dport = t1->dest;
1028 fl.fl_ip_sport = t1->source;
beb8d13b 1029 security_skb_classify_flow(skb, &fl);
1da177e4 1030
c20121ae
DL
1031 /* Pass a socket to ip6_dst_lookup either it is for RST
1032 * Underlying function will use this to retrieve the network
1033 * namespace
1034 */
e5047992 1035 if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
1da177e4 1036
ecc51b6d 1037 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
e5047992 1038 ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
63231bdd
PE
1039 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1040 TCP_INC_STATS_BH(net, TCP_MIB_OUTRSTS);
1da177e4 1041 return;
ecc51b6d 1042 }
1da177e4
LT
1043 }
1044
1045 kfree_skb(buff);
1046}
1047
9501f972
YH
1048static void tcp_v6_send_ack(struct sk_buff *skb, u32 seq, u32 ack, u32 win, u32 ts,
1049 struct tcp_md5sig_key *key)
1da177e4 1050{
aa8223c7 1051 struct tcphdr *th = tcp_hdr(skb), *t1;
1da177e4
LT
1052 struct sk_buff *buff;
1053 struct flowi fl;
2a5b8275 1054 struct net *net = dev_net(skb->dst->dev);
e5047992 1055 struct sock *ctl_sk = net->ipv6.tcp_sk;
9cb5734e 1056 unsigned int tot_len = sizeof(struct tcphdr);
e69a4adc 1057 __be32 *topt;
1da177e4
LT
1058
1059 if (ts)
4244f8a9 1060 tot_len += TCPOLEN_TSTAMP_ALIGNED;
cfb6eeb4
YH
1061#ifdef CONFIG_TCP_MD5SIG
1062 if (key)
1063 tot_len += TCPOLEN_MD5SIG_ALIGNED;
1064#endif
1da177e4
LT
1065
1066 buff = alloc_skb(MAX_HEADER + sizeof(struct ipv6hdr) + tot_len,
1067 GFP_ATOMIC);
1068 if (buff == NULL)
1069 return;
1070
1071 skb_reserve(buff, MAX_HEADER + sizeof(struct ipv6hdr) + tot_len);
1072
1073 t1 = (struct tcphdr *) skb_push(buff,tot_len);
1074
1075 /* Swap the send and the receive. */
1076 memset(t1, 0, sizeof(*t1));
1077 t1->dest = th->source;
1078 t1->source = th->dest;
1079 t1->doff = tot_len/4;
1080 t1->seq = htonl(seq);
1081 t1->ack_seq = htonl(ack);
1082 t1->ack = 1;
1083 t1->window = htons(win);
cfb6eeb4 1084
e69a4adc 1085 topt = (__be32 *)(t1 + 1);
1ab1457c 1086
1da177e4 1087 if (ts) {
cfb6eeb4
YH
1088 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1089 (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP);
1090 *topt++ = htonl(tcp_time_stamp);
1091 *topt = htonl(ts);
1da177e4
LT
1092 }
1093
cfb6eeb4
YH
1094#ifdef CONFIG_TCP_MD5SIG
1095 if (key) {
1096 *topt++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
1097 (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
49a72dfb 1098 tcp_v6_md5_hash_hdr((__u8 *)topt, key,
90b7e112
AL
1099 &ipv6_hdr(skb)->saddr,
1100 &ipv6_hdr(skb)->daddr, t1);
cfb6eeb4
YH
1101 }
1102#endif
1103
1da177e4
LT
1104 buff->csum = csum_partial((char *)t1, tot_len, 0);
1105
1106 memset(&fl, 0, sizeof(fl));
0660e03f
ACM
1107 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
1108 ipv6_addr_copy(&fl.fl6_src, &ipv6_hdr(skb)->daddr);
1da177e4
LT
1109
1110 t1->check = csum_ipv6_magic(&fl.fl6_src, &fl.fl6_dst,
1111 tot_len, IPPROTO_TCP,
1112 buff->csum);
1113
1114 fl.proto = IPPROTO_TCP;
505cbfc5 1115 fl.oif = inet6_iif(skb);
1da177e4
LT
1116 fl.fl_ip_dport = t1->dest;
1117 fl.fl_ip_sport = t1->source;
beb8d13b 1118 security_skb_classify_flow(skb, &fl);
1da177e4 1119
e5047992 1120 if (!ip6_dst_lookup(ctl_sk, &buff->dst, &fl)) {
ecc51b6d 1121 if (xfrm_lookup(&buff->dst, &fl, NULL, 0) >= 0) {
e5047992 1122 ip6_xmit(ctl_sk, buff, &fl, NULL, 0);
63231bdd 1123 TCP_INC_STATS_BH(net, TCP_MIB_OUTSEGS);
1da177e4 1124 return;
ecc51b6d 1125 }
1da177e4
LT
1126 }
1127
1128 kfree_skb(buff);
1129}
1130
1131static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
1132{
8feaf0c0 1133 struct inet_timewait_sock *tw = inet_twsk(sk);
cfb6eeb4 1134 struct tcp_timewait_sock *tcptw = tcp_twsk(sk);
1da177e4 1135
9501f972 1136 tcp_v6_send_ack(skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt,
8feaf0c0 1137 tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,
9501f972 1138 tcptw->tw_ts_recent, tcp_twsk_md5_key(tcptw));
1da177e4 1139
8feaf0c0 1140 inet_twsk_put(tw);
1da177e4
LT
1141}
1142
6edafaaf
GJ
1143static void tcp_v6_reqsk_send_ack(struct sock *sk, struct sk_buff *skb,
1144 struct request_sock *req)
1da177e4 1145{
9501f972 1146 tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent,
6edafaaf 1147 tcp_v6_md5_do_lookup(sk, &ipv6_hdr(skb)->daddr));
1da177e4
LT
1148}
1149
1150
1151static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
1152{
60236fdd 1153 struct request_sock *req, **prev;
aa8223c7 1154 const struct tcphdr *th = tcp_hdr(skb);
1da177e4
LT
1155 struct sock *nsk;
1156
1157 /* Find possible connection requests. */
8129765a 1158 req = inet6_csk_search_req(sk, &prev, th->source,
0660e03f
ACM
1159 &ipv6_hdr(skb)->saddr,
1160 &ipv6_hdr(skb)->daddr, inet6_iif(skb));
1da177e4
LT
1161 if (req)
1162 return tcp_check_req(sk, skb, req, prev);
1163
3b1e0a65 1164 nsk = __inet6_lookup_established(sock_net(sk), &tcp_hashinfo,
d86e0dac
PE
1165 &ipv6_hdr(skb)->saddr, th->source,
1166 &ipv6_hdr(skb)->daddr, ntohs(th->dest), inet6_iif(skb));
1da177e4
LT
1167
1168 if (nsk) {
1169 if (nsk->sk_state != TCP_TIME_WAIT) {
1170 bh_lock_sock(nsk);
1171 return nsk;
1172 }
9469c7b4 1173 inet_twsk_put(inet_twsk(nsk));
1da177e4
LT
1174 return NULL;
1175 }
1176
c6aefafb 1177#ifdef CONFIG_SYN_COOKIES
1da177e4 1178 if (!th->rst && !th->syn && th->ack)
c6aefafb 1179 sk = cookie_v6_check(sk, skb);
1da177e4
LT
1180#endif
1181 return sk;
1182}
1183
1da177e4
LT
1184/* FIXME: this is substantially similar to the ipv4 code.
1185 * Can some kind of merge be done? -- erics
1186 */
1187static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
1188{
ca304b61 1189 struct inet6_request_sock *treq;
1da177e4
LT
1190 struct ipv6_pinfo *np = inet6_sk(sk);
1191 struct tcp_options_received tmp_opt;
1192 struct tcp_sock *tp = tcp_sk(sk);
60236fdd 1193 struct request_sock *req = NULL;
1da177e4 1194 __u32 isn = TCP_SKB_CB(skb)->when;
c6aefafb
GG
1195#ifdef CONFIG_SYN_COOKIES
1196 int want_cookie = 0;
1197#else
1198#define want_cookie 0
1199#endif
1da177e4
LT
1200
1201 if (skb->protocol == htons(ETH_P_IP))
1202 return tcp_v4_conn_request(sk, skb);
1203
1204 if (!ipv6_unicast_destination(skb))
1ab1457c 1205 goto drop;
1da177e4 1206
463c84b9 1207 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1da177e4 1208 if (net_ratelimit())
c6aefafb
GG
1209 syn_flood_warning(skb);
1210#ifdef CONFIG_SYN_COOKIES
1211 if (sysctl_tcp_syncookies)
1212 want_cookie = 1;
1213 else
1214#endif
1ab1457c 1215 goto drop;
1da177e4
LT
1216 }
1217
463c84b9 1218 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1da177e4
LT
1219 goto drop;
1220
ca304b61 1221 req = inet6_reqsk_alloc(&tcp6_request_sock_ops);
1da177e4
LT
1222 if (req == NULL)
1223 goto drop;
1224
cfb6eeb4
YH
1225#ifdef CONFIG_TCP_MD5SIG
1226 tcp_rsk(req)->af_specific = &tcp_request_sock_ipv6_ops;
1227#endif
1228
1da177e4
LT
1229 tcp_clear_options(&tmp_opt);
1230 tmp_opt.mss_clamp = IPV6_MIN_MTU - sizeof(struct tcphdr) - sizeof(struct ipv6hdr);
1231 tmp_opt.user_mss = tp->rx_opt.user_mss;
1232
1233 tcp_parse_options(skb, &tmp_opt, 0);
1234
4dfc2817 1235 if (want_cookie && !tmp_opt.saw_tstamp)
c6aefafb 1236 tcp_clear_options(&tmp_opt);
c6aefafb 1237
1da177e4
LT
1238 tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
1239 tcp_openreq_init(req, &tmp_opt, skb);
1240
ca304b61 1241 treq = inet6_rsk(req);
0660e03f
ACM
1242 ipv6_addr_copy(&treq->rmt_addr, &ipv6_hdr(skb)->saddr);
1243 ipv6_addr_copy(&treq->loc_addr, &ipv6_hdr(skb)->daddr);
c6aefafb
GG
1244 if (!want_cookie)
1245 TCP_ECN_create_request(req, tcp_hdr(skb));
1246
1247 if (want_cookie) {
1248 isn = cookie_v6_init_sequence(sk, skb, &req->mss);
4dfc2817 1249 req->cookie_ts = tmp_opt.tstamp_ok;
c6aefafb
GG
1250 } else if (!isn) {
1251 if (ipv6_opt_accepted(sk, skb) ||
1252 np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo ||
1253 np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim) {
1254 atomic_inc(&skb->users);
1255 treq->pktopts = skb;
1256 }
1257 treq->iif = sk->sk_bound_dev_if;
1da177e4 1258
c6aefafb
GG
1259 /* So that link locals have meaning */
1260 if (!sk->sk_bound_dev_if &&
1261 ipv6_addr_type(&treq->rmt_addr) & IPV6_ADDR_LINKLOCAL)
1262 treq->iif = inet6_iif(skb);
1da177e4 1263
a94f723d 1264 isn = tcp_v6_init_sequence(skb);
c6aefafb 1265 }
1da177e4 1266
2e6599cb 1267 tcp_rsk(req)->snt_isn = isn;
1da177e4 1268
4237c75c
VY
1269 security_inet_conn_request(sk, skb, req);
1270
fd80eb94 1271 if (tcp_v6_send_synack(sk, req))
1da177e4
LT
1272 goto drop;
1273
c6aefafb
GG
1274 if (!want_cookie) {
1275 inet6_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
1276 return 0;
1277 }
1da177e4
LT
1278
1279drop:
1280 if (req)
60236fdd 1281 reqsk_free(req);
1da177e4 1282
1da177e4
LT
1283 return 0; /* don't send reset */
1284}
1285
1286static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
60236fdd 1287 struct request_sock *req,
1da177e4
LT
1288 struct dst_entry *dst)
1289{
78d15e82 1290 struct inet6_request_sock *treq;
1da177e4
LT
1291 struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
1292 struct tcp6_sock *newtcp6sk;
1293 struct inet_sock *newinet;
1294 struct tcp_sock *newtp;
1295 struct sock *newsk;
1296 struct ipv6_txoptions *opt;
cfb6eeb4
YH
1297#ifdef CONFIG_TCP_MD5SIG
1298 struct tcp_md5sig_key *key;
1299#endif
1da177e4
LT
1300
1301 if (skb->protocol == htons(ETH_P_IP)) {
1302 /*
1303 * v6 mapped
1304 */
1305
1306 newsk = tcp_v4_syn_recv_sock(sk, skb, req, dst);
1307
1ab1457c 1308 if (newsk == NULL)
1da177e4
LT
1309 return NULL;
1310
1311 newtcp6sk = (struct tcp6_sock *)newsk;
1312 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1313
1314 newinet = inet_sk(newsk);
1315 newnp = inet6_sk(newsk);
1316 newtp = tcp_sk(newsk);
1317
1318 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1319
1320 ipv6_addr_set(&newnp->daddr, 0, 0, htonl(0x0000FFFF),
1321 newinet->daddr);
1322
1323 ipv6_addr_set(&newnp->saddr, 0, 0, htonl(0x0000FFFF),
1324 newinet->saddr);
1325
1326 ipv6_addr_copy(&newnp->rcv_saddr, &newnp->saddr);
1327
8292a17a 1328 inet_csk(newsk)->icsk_af_ops = &ipv6_mapped;
1da177e4 1329 newsk->sk_backlog_rcv = tcp_v4_do_rcv;
cfb6eeb4
YH
1330#ifdef CONFIG_TCP_MD5SIG
1331 newtp->af_specific = &tcp_sock_ipv6_mapped_specific;
1332#endif
1333
1da177e4
LT
1334 newnp->pktoptions = NULL;
1335 newnp->opt = NULL;
505cbfc5 1336 newnp->mcast_oif = inet6_iif(skb);
0660e03f 1337 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1da177e4 1338
e6848976
ACM
1339 /*
1340 * No need to charge this sock to the relevant IPv6 refcnt debug socks count
1341 * here, tcp_create_openreq_child now does this for us, see the comment in
1342 * that function for the gory details. -acme
1da177e4 1343 */
1da177e4
LT
1344
1345 /* It is tricky place. Until this moment IPv4 tcp
8292a17a 1346 worked with IPv6 icsk.icsk_af_ops.
1da177e4
LT
1347 Sync it now.
1348 */
d83d8461 1349 tcp_sync_mss(newsk, inet_csk(newsk)->icsk_pmtu_cookie);
1da177e4
LT
1350
1351 return newsk;
1352 }
1353
78d15e82 1354 treq = inet6_rsk(req);
1da177e4
LT
1355 opt = np->opt;
1356
1357 if (sk_acceptq_is_full(sk))
1358 goto out_overflow;
1359
1da177e4
LT
1360 if (dst == NULL) {
1361 struct in6_addr *final_p = NULL, final;
1362 struct flowi fl;
1363
1364 memset(&fl, 0, sizeof(fl));
1365 fl.proto = IPPROTO_TCP;
2e6599cb 1366 ipv6_addr_copy(&fl.fl6_dst, &treq->rmt_addr);
1da177e4
LT
1367 if (opt && opt->srcrt) {
1368 struct rt0_hdr *rt0 = (struct rt0_hdr *) opt->srcrt;
1369 ipv6_addr_copy(&final, &fl.fl6_dst);
1370 ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
1371 final_p = &final;
1372 }
2e6599cb 1373 ipv6_addr_copy(&fl.fl6_src, &treq->loc_addr);
1da177e4 1374 fl.oif = sk->sk_bound_dev_if;
2e6599cb 1375 fl.fl_ip_dport = inet_rsk(req)->rmt_port;
1da177e4 1376 fl.fl_ip_sport = inet_sk(sk)->sport;
4237c75c 1377 security_req_classify_flow(req, &fl);
1da177e4
LT
1378
1379 if (ip6_dst_lookup(sk, &dst, &fl))
1380 goto out;
1381
1382 if (final_p)
1383 ipv6_addr_copy(&fl.fl6_dst, final_p);
1384
1385 if ((xfrm_lookup(&dst, &fl, sk, 0)) < 0)
1386 goto out;
1ab1457c 1387 }
1da177e4
LT
1388
1389 newsk = tcp_create_openreq_child(sk, req, skb);
1390 if (newsk == NULL)
1391 goto out;
1392
e6848976
ACM
1393 /*
1394 * No need to charge this sock to the relevant IPv6 refcnt debug socks
1395 * count here, tcp_create_openreq_child now does this for us, see the
1396 * comment in that function for the gory details. -acme
1397 */
1da177e4 1398
59eed279 1399 newsk->sk_gso_type = SKB_GSO_TCPV6;
8e1ef0a9 1400 __ip6_dst_store(newsk, dst, NULL, NULL);
1da177e4
LT
1401
1402 newtcp6sk = (struct tcp6_sock *)newsk;
1403 inet_sk(newsk)->pinet6 = &newtcp6sk->inet6;
1404
1405 newtp = tcp_sk(newsk);
1406 newinet = inet_sk(newsk);
1407 newnp = inet6_sk(newsk);
1408
1409 memcpy(newnp, np, sizeof(struct ipv6_pinfo));
1410
2e6599cb
ACM
1411 ipv6_addr_copy(&newnp->daddr, &treq->rmt_addr);
1412 ipv6_addr_copy(&newnp->saddr, &treq->loc_addr);
1413 ipv6_addr_copy(&newnp->rcv_saddr, &treq->loc_addr);
1414 newsk->sk_bound_dev_if = treq->iif;
1da177e4 1415
1ab1457c 1416 /* Now IPv6 options...
1da177e4
LT
1417
1418 First: no IPv4 options.
1419 */
1420 newinet->opt = NULL;
d35690be 1421 newnp->ipv6_fl_list = NULL;
1da177e4
LT
1422
1423 /* Clone RX bits */
1424 newnp->rxopt.all = np->rxopt.all;
1425
1426 /* Clone pktoptions received with SYN */
1427 newnp->pktoptions = NULL;
2e6599cb
ACM
1428 if (treq->pktopts != NULL) {
1429 newnp->pktoptions = skb_clone(treq->pktopts, GFP_ATOMIC);
1430 kfree_skb(treq->pktopts);
1431 treq->pktopts = NULL;
1da177e4
LT
1432 if (newnp->pktoptions)
1433 skb_set_owner_r(newnp->pktoptions, newsk);
1434 }
1435 newnp->opt = NULL;
505cbfc5 1436 newnp->mcast_oif = inet6_iif(skb);
0660e03f 1437 newnp->mcast_hops = ipv6_hdr(skb)->hop_limit;
1da177e4
LT
1438
1439 /* Clone native IPv6 options from listening socket (if any)
1440
1441 Yes, keeping reference count would be much more clever,
1442 but we make one more one thing there: reattach optmem
1443 to newsk.
1444 */
1445 if (opt) {
1446 newnp->opt = ipv6_dup_options(newsk, opt);
1447 if (opt != np->opt)
1448 sock_kfree_s(sk, opt, opt->tot_len);
1449 }
1450
d83d8461 1451 inet_csk(newsk)->icsk_ext_hdr_len = 0;
1da177e4 1452 if (newnp->opt)
d83d8461
ACM
1453 inet_csk(newsk)->icsk_ext_hdr_len = (newnp->opt->opt_nflen +
1454 newnp->opt->opt_flen);
1da177e4 1455
5d424d5a 1456 tcp_mtup_init(newsk);
1da177e4
LT
1457 tcp_sync_mss(newsk, dst_mtu(dst));
1458 newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
1459 tcp_initialize_rcv_mss(newsk);
1460
1461 newinet->daddr = newinet->saddr = newinet->rcv_saddr = LOOPBACK4_IPV6;
1462
cfb6eeb4
YH
1463#ifdef CONFIG_TCP_MD5SIG
1464 /* Copy over the MD5 key from the original socket */
1465 if ((key = tcp_v6_md5_do_lookup(sk, &newnp->daddr)) != NULL) {
1466 /* We're using one, so create a matching key
1467 * on the newsk structure. If we fail to get
1468 * memory, then we end up not copying the key
1469 * across. Shucks.
1470 */
af879cc7
ACM
1471 char *newkey = kmemdup(key->key, key->keylen, GFP_ATOMIC);
1472 if (newkey != NULL)
cfb6eeb4
YH
1473 tcp_v6_md5_do_add(newsk, &inet6_sk(sk)->daddr,
1474 newkey, key->keylen);
cfb6eeb4
YH
1475 }
1476#endif
1477
ab1e0a13 1478 __inet6_hash(newsk);
e56d8b8a 1479 __inet_inherit_port(sk, newsk);
1da177e4
LT
1480
1481 return newsk;
1482
1483out_overflow:
de0744af 1484 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
1da177e4 1485out:
de0744af 1486 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_LISTENDROPS);
1da177e4
LT
1487 if (opt && opt != np->opt)
1488 sock_kfree_s(sk, opt, opt->tot_len);
1489 dst_release(dst);
1490 return NULL;
1491}
1492
b51655b9 1493static __sum16 tcp_v6_checksum_init(struct sk_buff *skb)
1da177e4 1494{
84fa7933 1495 if (skb->ip_summed == CHECKSUM_COMPLETE) {
aa8223c7 1496 if (!tcp_v6_check(tcp_hdr(skb), skb->len, &ipv6_hdr(skb)->saddr,
0660e03f 1497 &ipv6_hdr(skb)->daddr, skb->csum)) {
fb286bb2 1498 skb->ip_summed = CHECKSUM_UNNECESSARY;
1da177e4 1499 return 0;
fb286bb2 1500 }
1da177e4 1501 }
fb286bb2 1502
aa8223c7 1503 skb->csum = ~csum_unfold(tcp_v6_check(tcp_hdr(skb), skb->len,
0660e03f
ACM
1504 &ipv6_hdr(skb)->saddr,
1505 &ipv6_hdr(skb)->daddr, 0));
fb286bb2 1506
1da177e4 1507 if (skb->len <= 76) {
fb286bb2 1508 return __skb_checksum_complete(skb);
1da177e4
LT
1509 }
1510 return 0;
1511}
1512
1513/* The socket must have it's spinlock held when we get
1514 * here.
1515 *
1516 * We have a potential double-lock case here, so even when
1517 * doing backlog processing we use the BH locking scheme.
1518 * This is because we cannot sleep with the original spinlock
1519 * held.
1520 */
1521static int tcp_v6_do_rcv(struct sock *sk, struct sk_buff *skb)
1522{
1523 struct ipv6_pinfo *np = inet6_sk(sk);
1524 struct tcp_sock *tp;
1525 struct sk_buff *opt_skb = NULL;
1526
1527 /* Imagine: socket is IPv6. IPv4 packet arrives,
1528 goes to IPv4 receive handler and backlogged.
1529 From backlog it always goes here. Kerboom...
1530 Fortunately, tcp_rcv_established and rcv_established
1531 handle them correctly, but it is not case with
1532 tcp_v6_hnd_req and tcp_v6_send_reset(). --ANK
1533 */
1534
1535 if (skb->protocol == htons(ETH_P_IP))
1536 return tcp_v4_do_rcv(sk, skb);
1537
cfb6eeb4
YH
1538#ifdef CONFIG_TCP_MD5SIG
1539 if (tcp_v6_inbound_md5_hash (sk, skb))
1540 goto discard;
1541#endif
1542
fda9ef5d 1543 if (sk_filter(sk, skb))
1da177e4
LT
1544 goto discard;
1545
1546 /*
1547 * socket locking is here for SMP purposes as backlog rcv
1548 * is currently called with bh processing disabled.
1549 */
1550
1551 /* Do Stevens' IPV6_PKTOPTIONS.
1552
1553 Yes, guys, it is the only place in our code, where we
1554 may make it not affecting IPv4.
1555 The rest of code is protocol independent,
1556 and I do not like idea to uglify IPv4.
1557
1558 Actually, all the idea behind IPV6_PKTOPTIONS
1559 looks not very well thought. For now we latch
1560 options, received in the last packet, enqueued
1561 by tcp. Feel free to propose better solution.
1ab1457c 1562 --ANK (980728)
1da177e4
LT
1563 */
1564 if (np->rxopt.all)
1565 opt_skb = skb_clone(skb, GFP_ATOMIC);
1566
1567 if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */
1568 TCP_CHECK_TIMER(sk);
aa8223c7 1569 if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len))
1da177e4
LT
1570 goto reset;
1571 TCP_CHECK_TIMER(sk);
1572 if (opt_skb)
1573 goto ipv6_pktoptions;
1574 return 0;
1575 }
1576
ab6a5bb6 1577 if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))
1da177e4
LT
1578 goto csum_err;
1579
1ab1457c 1580 if (sk->sk_state == TCP_LISTEN) {
1da177e4
LT
1581 struct sock *nsk = tcp_v6_hnd_req(sk, skb);
1582 if (!nsk)
1583 goto discard;
1584
1585 /*
1586 * Queue it on the new socket if the new socket is active,
1587 * otherwise we just shortcircuit this and continue with
1588 * the new socket..
1589 */
1ab1457c 1590 if(nsk != sk) {
1da177e4
LT
1591 if (tcp_child_process(sk, nsk, skb))
1592 goto reset;
1593 if (opt_skb)
1594 __kfree_skb(opt_skb);
1595 return 0;
1596 }
1597 }
1598
1599 TCP_CHECK_TIMER(sk);
aa8223c7 1600 if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len))
1da177e4
LT
1601 goto reset;
1602 TCP_CHECK_TIMER(sk);
1603 if (opt_skb)
1604 goto ipv6_pktoptions;
1605 return 0;
1606
1607reset:
cfb6eeb4 1608 tcp_v6_send_reset(sk, skb);
1da177e4
LT
1609discard:
1610 if (opt_skb)
1611 __kfree_skb(opt_skb);
1612 kfree_skb(skb);
1613 return 0;
1614csum_err:
63231bdd 1615 TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
1da177e4
LT
1616 goto discard;
1617
1618
1619ipv6_pktoptions:
1620 /* Do you ask, what is it?
1621
1622 1. skb was enqueued by tcp.
1623 2. skb is added to tail of read queue, rather than out of order.
1624 3. socket is not in passive state.
1625 4. Finally, it really contains options, which user wants to receive.
1626 */
1627 tp = tcp_sk(sk);
1628 if (TCP_SKB_CB(opt_skb)->end_seq == tp->rcv_nxt &&
1629 !((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN))) {
333fad53 1630 if (np->rxopt.bits.rxinfo || np->rxopt.bits.rxoinfo)
505cbfc5 1631 np->mcast_oif = inet6_iif(opt_skb);
333fad53 1632 if (np->rxopt.bits.rxhlim || np->rxopt.bits.rxohlim)
0660e03f 1633 np->mcast_hops = ipv6_hdr(opt_skb)->hop_limit;
1da177e4
LT
1634 if (ipv6_opt_accepted(sk, opt_skb)) {
1635 skb_set_owner_r(opt_skb, sk);
1636 opt_skb = xchg(&np->pktoptions, opt_skb);
1637 } else {
1638 __kfree_skb(opt_skb);
1639 opt_skb = xchg(&np->pktoptions, NULL);
1640 }
1641 }
1642
1643 if (opt_skb)
1644 kfree_skb(opt_skb);
1645 return 0;
1646}
1647
e5bbef20 1648static int tcp_v6_rcv(struct sk_buff *skb)
1da177e4 1649{
1ab1457c 1650 struct tcphdr *th;
1da177e4
LT
1651 struct sock *sk;
1652 int ret;
a86b1e30 1653 struct net *net = dev_net(skb->dev);
1da177e4
LT
1654
1655 if (skb->pkt_type != PACKET_HOST)
1656 goto discard_it;
1657
1658 /*
1659 * Count it even if it's bad.
1660 */
63231bdd 1661 TCP_INC_STATS_BH(net, TCP_MIB_INSEGS);
1da177e4
LT
1662
1663 if (!pskb_may_pull(skb, sizeof(struct tcphdr)))
1664 goto discard_it;
1665
aa8223c7 1666 th = tcp_hdr(skb);
1da177e4
LT
1667
1668 if (th->doff < sizeof(struct tcphdr)/4)
1669 goto bad_packet;
1670 if (!pskb_may_pull(skb, th->doff*4))
1671 goto discard_it;
1672
60476372 1673 if (!skb_csum_unnecessary(skb) && tcp_v6_checksum_init(skb))
1da177e4
LT
1674 goto bad_packet;
1675
aa8223c7 1676 th = tcp_hdr(skb);
1da177e4
LT
1677 TCP_SKB_CB(skb)->seq = ntohl(th->seq);
1678 TCP_SKB_CB(skb)->end_seq = (TCP_SKB_CB(skb)->seq + th->syn + th->fin +
1679 skb->len - th->doff*4);
1680 TCP_SKB_CB(skb)->ack_seq = ntohl(th->ack_seq);
1681 TCP_SKB_CB(skb)->when = 0;
0660e03f 1682 TCP_SKB_CB(skb)->flags = ipv6_get_dsfield(ipv6_hdr(skb));
1da177e4
LT
1683 TCP_SKB_CB(skb)->sacked = 0;
1684
9a1f27c4 1685 sk = __inet6_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);
1da177e4
LT
1686 if (!sk)
1687 goto no_tcp_socket;
1688
1689process:
1690 if (sk->sk_state == TCP_TIME_WAIT)
1691 goto do_time_wait;
1692
1693 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
1694 goto discard_and_relse;
1695
fda9ef5d 1696 if (sk_filter(sk, skb))
1da177e4
LT
1697 goto discard_and_relse;
1698
1699 skb->dev = NULL;
1700
293b9c42 1701 bh_lock_sock_nested(sk);
1da177e4
LT
1702 ret = 0;
1703 if (!sock_owned_by_user(sk)) {
1a2449a8 1704#ifdef CONFIG_NET_DMA
1ab1457c 1705 struct tcp_sock *tp = tcp_sk(sk);
b4caea8a
DM
1706 if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
1707 tp->ucopy.dma_chan = get_softnet_dma();
1ab1457c
YH
1708 if (tp->ucopy.dma_chan)
1709 ret = tcp_v6_do_rcv(sk, skb);
1710 else
1a2449a8
CL
1711#endif
1712 {
1713 if (!tcp_prequeue(sk, skb))
1714 ret = tcp_v6_do_rcv(sk, skb);
1715 }
1da177e4
LT
1716 } else
1717 sk_add_backlog(sk, skb);
1718 bh_unlock_sock(sk);
1719
1720 sock_put(sk);
1721 return ret ? -1 : 0;
1722
1723no_tcp_socket:
1724 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb))
1725 goto discard_it;
1726
1727 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
1728bad_packet:
63231bdd 1729 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
1da177e4 1730 } else {
cfb6eeb4 1731 tcp_v6_send_reset(NULL, skb);
1da177e4
LT
1732 }
1733
1734discard_it:
1735
1736 /*
1737 * Discard frame
1738 */
1739
1740 kfree_skb(skb);
1741 return 0;
1742
1743discard_and_relse:
1744 sock_put(sk);
1745 goto discard_it;
1746
1747do_time_wait:
1748 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
9469c7b4 1749 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
1750 goto discard_it;
1751 }
1752
1753 if (skb->len < (th->doff<<2) || tcp_checksum_complete(skb)) {
63231bdd 1754 TCP_INC_STATS_BH(net, TCP_MIB_INERRS);
9469c7b4 1755 inet_twsk_put(inet_twsk(sk));
1da177e4
LT
1756 goto discard_it;
1757 }
1758
9469c7b4 1759 switch (tcp_timewait_state_process(inet_twsk(sk), skb, th)) {
1da177e4
LT
1760 case TCP_TW_SYN:
1761 {
1762 struct sock *sk2;
1763
c346dca1 1764 sk2 = inet6_lookup_listener(dev_net(skb->dev), &tcp_hashinfo,
0660e03f 1765 &ipv6_hdr(skb)->daddr,
505cbfc5 1766 ntohs(th->dest), inet6_iif(skb));
1da177e4 1767 if (sk2 != NULL) {
295ff7ed
ACM
1768 struct inet_timewait_sock *tw = inet_twsk(sk);
1769 inet_twsk_deschedule(tw, &tcp_death_row);
1770 inet_twsk_put(tw);
1da177e4
LT
1771 sk = sk2;
1772 goto process;
1773 }
1774 /* Fall through to ACK */
1775 }
1776 case TCP_TW_ACK:
1777 tcp_v6_timewait_ack(sk, skb);
1778 break;
1779 case TCP_TW_RST:
1780 goto no_tcp_socket;
1781 case TCP_TW_SUCCESS:;
1782 }
1783 goto discard_it;
1784}
1785
1da177e4
LT
1786static int tcp_v6_remember_stamp(struct sock *sk)
1787{
1788 /* Alas, not yet... */
1789 return 0;
1790}
1791
8292a17a 1792static struct inet_connection_sock_af_ops ipv6_specific = {
543d9cfe
ACM
1793 .queue_xmit = inet6_csk_xmit,
1794 .send_check = tcp_v6_send_check,
1795 .rebuild_header = inet6_sk_rebuild_header,
1796 .conn_request = tcp_v6_conn_request,
1797 .syn_recv_sock = tcp_v6_syn_recv_sock,
1798 .remember_stamp = tcp_v6_remember_stamp,
1799 .net_header_len = sizeof(struct ipv6hdr),
1800 .setsockopt = ipv6_setsockopt,
1801 .getsockopt = ipv6_getsockopt,
1802 .addr2sockaddr = inet6_csk_addr2sockaddr,
1803 .sockaddr_len = sizeof(struct sockaddr_in6),
ab1e0a13 1804 .bind_conflict = inet6_csk_bind_conflict,
3fdadf7d 1805#ifdef CONFIG_COMPAT
543d9cfe
ACM
1806 .compat_setsockopt = compat_ipv6_setsockopt,
1807 .compat_getsockopt = compat_ipv6_getsockopt,
3fdadf7d 1808#endif
1da177e4
LT
1809};
1810
cfb6eeb4 1811#ifdef CONFIG_TCP_MD5SIG
a928630a 1812static struct tcp_sock_af_ops tcp_sock_ipv6_specific = {
cfb6eeb4 1813 .md5_lookup = tcp_v6_md5_lookup,
49a72dfb 1814 .calc_md5_hash = tcp_v6_md5_hash_skb,
cfb6eeb4
YH
1815 .md5_add = tcp_v6_md5_add_func,
1816 .md5_parse = tcp_v6_parse_md5_keys,
cfb6eeb4 1817};
a928630a 1818#endif
cfb6eeb4 1819
1da177e4
LT
1820/*
1821 * TCP over IPv4 via INET6 API
1822 */
1823
8292a17a 1824static struct inet_connection_sock_af_ops ipv6_mapped = {
543d9cfe
ACM
1825 .queue_xmit = ip_queue_xmit,
1826 .send_check = tcp_v4_send_check,
1827 .rebuild_header = inet_sk_rebuild_header,
1828 .conn_request = tcp_v6_conn_request,
1829 .syn_recv_sock = tcp_v6_syn_recv_sock,
1830 .remember_stamp = tcp_v4_remember_stamp,
1831 .net_header_len = sizeof(struct iphdr),
1832 .setsockopt = ipv6_setsockopt,
1833 .getsockopt = ipv6_getsockopt,
1834 .addr2sockaddr = inet6_csk_addr2sockaddr,
1835 .sockaddr_len = sizeof(struct sockaddr_in6),
ab1e0a13 1836 .bind_conflict = inet6_csk_bind_conflict,
3fdadf7d 1837#ifdef CONFIG_COMPAT
543d9cfe
ACM
1838 .compat_setsockopt = compat_ipv6_setsockopt,
1839 .compat_getsockopt = compat_ipv6_getsockopt,
3fdadf7d 1840#endif
1da177e4
LT
1841};
1842
cfb6eeb4 1843#ifdef CONFIG_TCP_MD5SIG
a928630a 1844static struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific = {
cfb6eeb4 1845 .md5_lookup = tcp_v4_md5_lookup,
49a72dfb 1846 .calc_md5_hash = tcp_v4_md5_hash_skb,
cfb6eeb4
YH
1847 .md5_add = tcp_v6_md5_add_func,
1848 .md5_parse = tcp_v6_parse_md5_keys,
cfb6eeb4 1849};
a928630a 1850#endif
cfb6eeb4 1851
1da177e4
LT
1852/* NOTE: A lot of things set to zero explicitly by call to
1853 * sk_alloc() so need not be done here.
1854 */
1855static int tcp_v6_init_sock(struct sock *sk)
1856{
6687e988 1857 struct inet_connection_sock *icsk = inet_csk(sk);
1da177e4
LT
1858 struct tcp_sock *tp = tcp_sk(sk);
1859
1860 skb_queue_head_init(&tp->out_of_order_queue);
1861 tcp_init_xmit_timers(sk);
1862 tcp_prequeue_init(tp);
1863
6687e988 1864 icsk->icsk_rto = TCP_TIMEOUT_INIT;
1da177e4
LT
1865 tp->mdev = TCP_TIMEOUT_INIT;
1866
1867 /* So many TCP implementations out there (incorrectly) count the
1868 * initial SYN frame in their delayed-ACK and congestion control
1869 * algorithms that we must have the following bandaid to talk
1870 * efficiently to them. -DaveM
1871 */
1872 tp->snd_cwnd = 2;
1873
1874 /* See draft-stevens-tcpca-spec-01 for discussion of the
1875 * initialization of these values.
1876 */
1877 tp->snd_ssthresh = 0x7fffffff;
1878 tp->snd_cwnd_clamp = ~0;
c1b4a7e6 1879 tp->mss_cache = 536;
1da177e4
LT
1880
1881 tp->reordering = sysctl_tcp_reordering;
1882
1883 sk->sk_state = TCP_CLOSE;
1884
8292a17a 1885 icsk->icsk_af_ops = &ipv6_specific;
6687e988 1886 icsk->icsk_ca_ops = &tcp_init_congestion_ops;
d83d8461 1887 icsk->icsk_sync_mss = tcp_sync_mss;
1da177e4
LT
1888 sk->sk_write_space = sk_stream_write_space;
1889 sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1890
cfb6eeb4
YH
1891#ifdef CONFIG_TCP_MD5SIG
1892 tp->af_specific = &tcp_sock_ipv6_specific;
1893#endif
1894
1da177e4
LT
1895 sk->sk_sndbuf = sysctl_tcp_wmem[1];
1896 sk->sk_rcvbuf = sysctl_tcp_rmem[1];
1897
1898 atomic_inc(&tcp_sockets_allocated);
1899
1900 return 0;
1901}
1902
7d06b2e0 1903static void tcp_v6_destroy_sock(struct sock *sk)
1da177e4 1904{
cfb6eeb4
YH
1905#ifdef CONFIG_TCP_MD5SIG
1906 /* Clean up the MD5 key list */
1907 if (tcp_sk(sk)->md5sig_info)
1908 tcp_v6_clear_md5_list(sk);
1909#endif
1da177e4 1910 tcp_v4_destroy_sock(sk);
7d06b2e0 1911 inet6_destroy_sock(sk);
1da177e4
LT
1912}
1913
952a10be 1914#ifdef CONFIG_PROC_FS
1da177e4 1915/* Proc filesystem TCPv6 sock list dumping. */
1ab1457c 1916static void get_openreq6(struct seq_file *seq,
60236fdd 1917 struct sock *sk, struct request_sock *req, int i, int uid)
1da177e4 1918{
1da177e4 1919 int ttd = req->expires - jiffies;
ca304b61
ACM
1920 struct in6_addr *src = &inet6_rsk(req)->loc_addr;
1921 struct in6_addr *dest = &inet6_rsk(req)->rmt_addr;
1da177e4
LT
1922
1923 if (ttd < 0)
1924 ttd = 0;
1925
1da177e4
LT
1926 seq_printf(seq,
1927 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1928 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
1929 i,
1930 src->s6_addr32[0], src->s6_addr32[1],
1931 src->s6_addr32[2], src->s6_addr32[3],
1932 ntohs(inet_sk(sk)->sport),
1933 dest->s6_addr32[0], dest->s6_addr32[1],
1934 dest->s6_addr32[2], dest->s6_addr32[3],
2e6599cb 1935 ntohs(inet_rsk(req)->rmt_port),
1da177e4
LT
1936 TCP_SYN_RECV,
1937 0,0, /* could print option size, but that is af dependent. */
1ab1457c
YH
1938 1, /* timers active (only the expire timer) */
1939 jiffies_to_clock_t(ttd),
1da177e4
LT
1940 req->retrans,
1941 uid,
1ab1457c 1942 0, /* non standard timer */
1da177e4
LT
1943 0, /* open_requests have no inode */
1944 0, req);
1945}
1946
1947static void get_tcp6_sock(struct seq_file *seq, struct sock *sp, int i)
1948{
1949 struct in6_addr *dest, *src;
1950 __u16 destp, srcp;
1951 int timer_active;
1952 unsigned long timer_expires;
1953 struct inet_sock *inet = inet_sk(sp);
1954 struct tcp_sock *tp = tcp_sk(sp);
463c84b9 1955 const struct inet_connection_sock *icsk = inet_csk(sp);
1da177e4
LT
1956 struct ipv6_pinfo *np = inet6_sk(sp);
1957
1958 dest = &np->daddr;
1959 src = &np->rcv_saddr;
1960 destp = ntohs(inet->dport);
1961 srcp = ntohs(inet->sport);
463c84b9
ACM
1962
1963 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
1da177e4 1964 timer_active = 1;
463c84b9
ACM
1965 timer_expires = icsk->icsk_timeout;
1966 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
1da177e4 1967 timer_active = 4;
463c84b9 1968 timer_expires = icsk->icsk_timeout;
1da177e4
LT
1969 } else if (timer_pending(&sp->sk_timer)) {
1970 timer_active = 2;
1971 timer_expires = sp->sk_timer.expires;
1972 } else {
1973 timer_active = 0;
1974 timer_expires = jiffies;
1975 }
1976
1977 seq_printf(seq,
1978 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
7be87351 1979 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %lu %lu %u %u %d\n",
1da177e4
LT
1980 i,
1981 src->s6_addr32[0], src->s6_addr32[1],
1982 src->s6_addr32[2], src->s6_addr32[3], srcp,
1983 dest->s6_addr32[0], dest->s6_addr32[1],
1984 dest->s6_addr32[2], dest->s6_addr32[3], destp,
1ab1457c 1985 sp->sk_state,
47da8ee6
SS
1986 tp->write_seq-tp->snd_una,
1987 (sp->sk_state == TCP_LISTEN) ? sp->sk_ack_backlog : (tp->rcv_nxt - tp->copied_seq),
1da177e4
LT
1988 timer_active,
1989 jiffies_to_clock_t(timer_expires - jiffies),
463c84b9 1990 icsk->icsk_retransmits,
1da177e4 1991 sock_i_uid(sp),
6687e988 1992 icsk->icsk_probes_out,
1da177e4
LT
1993 sock_i_ino(sp),
1994 atomic_read(&sp->sk_refcnt), sp,
7be87351
SH
1995 jiffies_to_clock_t(icsk->icsk_rto),
1996 jiffies_to_clock_t(icsk->icsk_ack.ato),
463c84b9 1997 (icsk->icsk_ack.quick << 1 ) | icsk->icsk_ack.pingpong,
1da177e4
LT
1998 tp->snd_cwnd, tp->snd_ssthresh>=0xFFFF?-1:tp->snd_ssthresh
1999 );
2000}
2001
1ab1457c 2002static void get_timewait6_sock(struct seq_file *seq,
8feaf0c0 2003 struct inet_timewait_sock *tw, int i)
1da177e4
LT
2004{
2005 struct in6_addr *dest, *src;
2006 __u16 destp, srcp;
0fa1a53e 2007 struct inet6_timewait_sock *tw6 = inet6_twsk((struct sock *)tw);
1da177e4
LT
2008 int ttd = tw->tw_ttd - jiffies;
2009
2010 if (ttd < 0)
2011 ttd = 0;
2012
0fa1a53e
ACM
2013 dest = &tw6->tw_v6_daddr;
2014 src = &tw6->tw_v6_rcv_saddr;
1da177e4
LT
2015 destp = ntohs(tw->tw_dport);
2016 srcp = ntohs(tw->tw_sport);
2017
2018 seq_printf(seq,
2019 "%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2020 "%02X %08X:%08X %02X:%08lX %08X %5d %8d %d %d %p\n",
2021 i,
2022 src->s6_addr32[0], src->s6_addr32[1],
2023 src->s6_addr32[2], src->s6_addr32[3], srcp,
2024 dest->s6_addr32[0], dest->s6_addr32[1],
2025 dest->s6_addr32[2], dest->s6_addr32[3], destp,
2026 tw->tw_substate, 0, 0,
2027 3, jiffies_to_clock_t(ttd), 0, 0, 0, 0,
2028 atomic_read(&tw->tw_refcnt), tw);
2029}
2030
1da177e4
LT
2031static int tcp6_seq_show(struct seq_file *seq, void *v)
2032{
2033 struct tcp_iter_state *st;
2034
2035 if (v == SEQ_START_TOKEN) {
2036 seq_puts(seq,
2037 " sl "
2038 "local_address "
2039 "remote_address "
2040 "st tx_queue rx_queue tr tm->when retrnsmt"
2041 " uid timeout inode\n");
2042 goto out;
2043 }
2044 st = seq->private;
2045
2046 switch (st->state) {
2047 case TCP_SEQ_STATE_LISTENING:
2048 case TCP_SEQ_STATE_ESTABLISHED:
2049 get_tcp6_sock(seq, v, st->num);
2050 break;
2051 case TCP_SEQ_STATE_OPENREQ:
2052 get_openreq6(seq, st->syn_wait_sk, v, st->num, st->uid);
2053 break;
2054 case TCP_SEQ_STATE_TIME_WAIT:
2055 get_timewait6_sock(seq, v, st->num);
2056 break;
2057 }
2058out:
2059 return 0;
2060}
2061
1da177e4 2062static struct tcp_seq_afinfo tcp6_seq_afinfo = {
1da177e4
LT
2063 .name = "tcp6",
2064 .family = AF_INET6,
5f4472c5
DL
2065 .seq_fops = {
2066 .owner = THIS_MODULE,
2067 },
9427c4b3
DL
2068 .seq_ops = {
2069 .show = tcp6_seq_show,
2070 },
1da177e4
LT
2071};
2072
6f8b13bc 2073int tcp6_proc_init(struct net *net)
1da177e4 2074{
6f8b13bc 2075 return tcp_proc_register(net, &tcp6_seq_afinfo);
1da177e4
LT
2076}
2077
6f8b13bc 2078void tcp6_proc_exit(struct net *net)
1da177e4 2079{
6f8b13bc 2080 tcp_proc_unregister(net, &tcp6_seq_afinfo);
1da177e4
LT
2081}
2082#endif
2083
2084struct proto tcpv6_prot = {
2085 .name = "TCPv6",
2086 .owner = THIS_MODULE,
2087 .close = tcp_close,
2088 .connect = tcp_v6_connect,
2089 .disconnect = tcp_disconnect,
463c84b9 2090 .accept = inet_csk_accept,
1da177e4
LT
2091 .ioctl = tcp_ioctl,
2092 .init = tcp_v6_init_sock,
2093 .destroy = tcp_v6_destroy_sock,
2094 .shutdown = tcp_shutdown,
2095 .setsockopt = tcp_setsockopt,
2096 .getsockopt = tcp_getsockopt,
1da177e4
LT
2097 .recvmsg = tcp_recvmsg,
2098 .backlog_rcv = tcp_v6_do_rcv,
2099 .hash = tcp_v6_hash,
ab1e0a13
ACM
2100 .unhash = inet_unhash,
2101 .get_port = inet_csk_get_port,
1da177e4
LT
2102 .enter_memory_pressure = tcp_enter_memory_pressure,
2103 .sockets_allocated = &tcp_sockets_allocated,
2104 .memory_allocated = &tcp_memory_allocated,
2105 .memory_pressure = &tcp_memory_pressure,
0a5578cf 2106 .orphan_count = &tcp_orphan_count,
1da177e4
LT
2107 .sysctl_mem = sysctl_tcp_mem,
2108 .sysctl_wmem = sysctl_tcp_wmem,
2109 .sysctl_rmem = sysctl_tcp_rmem,
2110 .max_header = MAX_TCP_HEADER,
2111 .obj_size = sizeof(struct tcp6_sock),
6d6ee43e 2112 .twsk_prot = &tcp6_timewait_sock_ops,
60236fdd 2113 .rsk_prot = &tcp6_request_sock_ops,
39d8cda7 2114 .h.hashinfo = &tcp_hashinfo,
543d9cfe
ACM
2115#ifdef CONFIG_COMPAT
2116 .compat_setsockopt = compat_tcp_setsockopt,
2117 .compat_getsockopt = compat_tcp_getsockopt,
2118#endif
1da177e4
LT
2119};
2120
2121static struct inet6_protocol tcpv6_protocol = {
2122 .handler = tcp_v6_rcv,
2123 .err_handler = tcp_v6_err,
a430a43d 2124 .gso_send_check = tcp_v6_gso_send_check,
adcfc7d0 2125 .gso_segment = tcp_tso_segment,
1da177e4
LT
2126 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
2127};
2128
1da177e4
LT
2129static struct inet_protosw tcpv6_protosw = {
2130 .type = SOCK_STREAM,
2131 .protocol = IPPROTO_TCP,
2132 .prot = &tcpv6_prot,
2133 .ops = &inet6_stream_ops,
2134 .capability = -1,
2135 .no_check = 0,
d83d8461
ACM
2136 .flags = INET_PROTOSW_PERMANENT |
2137 INET_PROTOSW_ICSK,
1da177e4
LT
2138};
2139
93ec926b
DL
2140static int tcpv6_net_init(struct net *net)
2141{
5677242f
DL
2142 return inet_ctl_sock_create(&net->ipv6.tcp_sk, PF_INET6,
2143 SOCK_RAW, IPPROTO_TCP, net);
93ec926b
DL
2144}
2145
2146static void tcpv6_net_exit(struct net *net)
2147{
5677242f 2148 inet_ctl_sock_destroy(net->ipv6.tcp_sk);
d315492b 2149 inet_twsk_purge(net, &tcp_hashinfo, &tcp_death_row, AF_INET6);
93ec926b
DL
2150}
2151
2152static struct pernet_operations tcpv6_net_ops = {
2153 .init = tcpv6_net_init,
2154 .exit = tcpv6_net_exit,
2155};
2156
7f4e4868 2157int __init tcpv6_init(void)
1da177e4 2158{
7f4e4868
DL
2159 int ret;
2160
2161 ret = inet6_add_protocol(&tcpv6_protocol, IPPROTO_TCP);
2162 if (ret)
2163 goto out;
2164
1da177e4 2165 /* register inet6 protocol */
7f4e4868
DL
2166 ret = inet6_register_protosw(&tcpv6_protosw);
2167 if (ret)
2168 goto out_tcpv6_protocol;
2169
93ec926b 2170 ret = register_pernet_subsys(&tcpv6_net_ops);
7f4e4868
DL
2171 if (ret)
2172 goto out_tcpv6_protosw;
2173out:
2174 return ret;
ae0f7d5f 2175
7f4e4868
DL
2176out_tcpv6_protocol:
2177 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
2178out_tcpv6_protosw:
2179 inet6_unregister_protosw(&tcpv6_protosw);
2180 goto out;
2181}
2182
09f7709f 2183void tcpv6_exit(void)
7f4e4868 2184{
93ec926b 2185 unregister_pernet_subsys(&tcpv6_net_ops);
7f4e4868
DL
2186 inet6_unregister_protosw(&tcpv6_protosw);
2187 inet6_del_protocol(&tcpv6_protocol, IPPROTO_TCP);
1da177e4 2188}