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