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