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