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