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