Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * IPv6 output functions
4 : : * Linux INET6 implementation
5 : : *
6 : : * Authors:
7 : : * Pedro Roque <roque@di.fc.ul.pt>
8 : : *
9 : : * Based on linux/net/ipv4/ip_output.c
10 : : *
11 : : * Changes:
12 : : * A.N.Kuznetsov : airthmetics in fragmentation.
13 : : * extension headers are implemented.
14 : : * route changes now work.
15 : : * ip6_forward does not confuse sniffers.
16 : : * etc.
17 : : *
18 : : * H. von Brand : Added missing #include <linux/string.h>
19 : : * Imran Patel : frag id should be in NBO
20 : : * Kazunori MIYAZAWA @USAGI
21 : : * : add ip6_append_data and related functions
22 : : * for datagram xmit
23 : : */
24 : :
25 : : #include <linux/errno.h>
26 : : #include <linux/kernel.h>
27 : : #include <linux/string.h>
28 : : #include <linux/socket.h>
29 : : #include <linux/net.h>
30 : : #include <linux/netdevice.h>
31 : : #include <linux/if_arp.h>
32 : : #include <linux/in6.h>
33 : : #include <linux/tcp.h>
34 : : #include <linux/route.h>
35 : : #include <linux/module.h>
36 : : #include <linux/slab.h>
37 : :
38 : : #include <linux/bpf-cgroup.h>
39 : : #include <linux/netfilter.h>
40 : : #include <linux/netfilter_ipv6.h>
41 : :
42 : : #include <net/sock.h>
43 : : #include <net/snmp.h>
44 : :
45 : : #include <net/ipv6.h>
46 : : #include <net/ndisc.h>
47 : : #include <net/protocol.h>
48 : : #include <net/ip6_route.h>
49 : : #include <net/addrconf.h>
50 : : #include <net/rawv6.h>
51 : : #include <net/icmp.h>
52 : : #include <net/xfrm.h>
53 : : #include <net/checksum.h>
54 : : #include <linux/mroute6.h>
55 : : #include <net/l3mdev.h>
56 : : #include <net/lwtunnel.h>
57 : :
58 : 3220 : static int ip6_finish_output2(struct net *net, struct sock *sk, struct sk_buff *skb)
59 : : {
60 : : struct dst_entry *dst = skb_dst(skb);
61 : 3220 : struct net_device *dev = dst->dev;
62 : : const struct in6_addr *nexthop;
63 : : struct neighbour *neigh;
64 : : int ret;
65 : :
66 [ + - ]: 3220 : if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr)) {
67 : : struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
68 : :
69 [ + - + + : 6048 : if (!(dev->flags & IFF_LOOPBACK) && sk_mc_loop(sk) &&
- + ]
70 [ # # ]: 2828 : ((mroute6_is_socket(net, skb) &&
71 [ + + ]: 2828 : !(IP6CB(skb)->flags & IP6SKB_FORWARDED)) ||
72 : 5656 : ipv6_chk_mcast_addr(dev, &ipv6_hdr(skb)->daddr,
73 : 2828 : &ipv6_hdr(skb)->saddr))) {
74 : 388 : struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
75 : :
76 : : /* Do not check for IFF_ALLMULTI; multicast routing
77 : : is not supported in any case.
78 : : */
79 [ + - ]: 388 : if (newskb)
80 : 388 : NF_HOOK(NFPROTO_IPV6, NF_INET_POST_ROUTING,
81 : : net, sk, newskb, NULL, newskb->dev,
82 : : dev_loopback_xmit);
83 : :
84 [ - + ]: 388 : if (ipv6_hdr(skb)->hop_limit == 0) {
85 [ # # ]: 0 : IP6_INC_STATS(net, idev,
86 : : IPSTATS_MIB_OUTDISCARDS);
87 : 0 : kfree_skb(skb);
88 : 0 : return 0;
89 : : }
90 : : }
91 : :
92 [ + - ]: 32200 : IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUTMCAST, skb->len);
93 : :
94 [ - + ]: 3220 : if (IPV6_ADDR_MC_SCOPE(&ipv6_hdr(skb)->daddr) <=
95 [ # # ]: 0 : IPV6_ADDR_SCOPE_NODELOCAL &&
96 : 0 : !(dev->flags & IFF_LOOPBACK)) {
97 : 0 : kfree_skb(skb);
98 : 0 : return 0;
99 : : }
100 : : }
101 : :
102 : : if (lwtunnel_xmit_redirect(dst->lwtstate)) {
103 : : int res = lwtunnel_xmit(skb);
104 : :
105 : : if (res < 0 || res == LWTUNNEL_XMIT_DONE)
106 : : return res;
107 : : }
108 : :
109 : : rcu_read_lock_bh();
110 : 3220 : nexthop = rt6_nexthop((struct rt6_info *)dst, &ipv6_hdr(skb)->daddr);
111 : 3220 : neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop);
112 [ + + ]: 3220 : if (unlikely(!neigh))
113 : 1210 : neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false);
114 [ + - ]: 3220 : if (!IS_ERR(neigh)) {
115 : : sock_confirm_neigh(skb, neigh);
116 : 3220 : ret = neigh_output(neigh, skb, false);
117 : : rcu_read_unlock_bh();
118 : 3220 : return ret;
119 : : }
120 : : rcu_read_unlock_bh();
121 : :
122 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
123 : 0 : kfree_skb(skb);
124 : 0 : return -EINVAL;
125 : : }
126 : :
127 : 3220 : static int __ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
128 : : {
129 : : #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
130 : : /* Policy lookup after SNAT yielded a new policy */
131 [ - + ]: 3220 : if (skb_dst(skb)->xfrm) {
132 : 0 : IPCB(skb)->flags |= IPSKB_REROUTED;
133 : 0 : return dst_output(net, sk, skb);
134 : : }
135 : : #endif
136 : :
137 [ - + # # : 6440 : if ((skb->len > ip6_skb_dst_mtu(skb) && !skb_is_gso(skb)) ||
+ - ]
138 [ - + ]: 3220 : dst_allfrag(skb_dst(skb)) ||
139 [ # # ]: 3220 : (IP6CB(skb)->frag_max_size && skb->len > IP6CB(skb)->frag_max_size))
140 : 0 : return ip6_fragment(net, sk, skb, ip6_finish_output2);
141 : : else
142 : 3220 : return ip6_finish_output2(net, sk, skb);
143 : : }
144 : :
145 : 3220 : static int ip6_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
146 : : {
147 : : int ret;
148 : :
149 [ + - + - : 6440 : ret = BPF_CGROUP_RUN_PROG_INET_EGRESS(sk, skb);
+ - + - ]
150 [ + - - ]: 3220 : switch (ret) {
151 : : case NET_XMIT_SUCCESS:
152 : 3220 : return __ip6_finish_output(net, sk, skb);
153 : : case NET_XMIT_CN:
154 [ # # ]: 0 : return __ip6_finish_output(net, sk, skb) ? : ret;
155 : : default:
156 : 0 : kfree_skb(skb);
157 : 0 : return ret;
158 : : }
159 : : }
160 : :
161 : 3220 : int ip6_output(struct net *net, struct sock *sk, struct sk_buff *skb)
162 : : {
163 : 3220 : struct net_device *dev = skb_dst(skb)->dev;
164 : : struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
165 : :
166 : 3220 : skb->protocol = htons(ETH_P_IPV6);
167 : 3220 : skb->dev = dev;
168 : :
169 [ - + ]: 3220 : if (unlikely(idev->cnf.disable_ipv6)) {
170 [ # # ]: 0 : IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTDISCARDS);
171 : 0 : kfree_skb(skb);
172 : 0 : return 0;
173 : : }
174 : :
175 : 3220 : return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING,
176 : : net, sk, skb, NULL, dev,
177 : : ip6_finish_output,
178 : 3220 : !(IP6CB(skb)->flags & IP6SKB_REROUTED));
179 : : }
180 : :
181 : 0 : bool ip6_autoflowlabel(struct net *net, const struct ipv6_pinfo *np)
182 : : {
183 [ + - # # : 1219 : if (!np->autoflowlabel_set)
# # ]
184 : 1219 : return ip6_default_np_autolabel(net);
185 : : else
186 : 0 : return np->autoflowlabel;
187 : : }
188 : :
189 : : /*
190 : : * xmit an sk_buff (used by TCP, SCTP and DCCP)
191 : : * Note : socket lock is not held for SYNACK packets, but might be modified
192 : : * by calls to skb_set_owner_w() and ipv6_local_error(),
193 : : * which are using proper atomic operations or spinlocks.
194 : : */
195 : 0 : int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6,
196 : : __u32 mark, struct ipv6_txoptions *opt, int tclass, u32 priority)
197 : : {
198 : : struct net *net = sock_net(sk);
199 : : const struct ipv6_pinfo *np = inet6_sk(sk);
200 : 0 : struct in6_addr *first_hop = &fl6->daddr;
201 : : struct dst_entry *dst = skb_dst(skb);
202 : : unsigned int head_room;
203 : : struct ipv6hdr *hdr;
204 : 0 : u8 proto = fl6->flowi6_proto;
205 : 0 : int seg_len = skb->len;
206 : : int hlimit = -1;
207 : : u32 mtu;
208 : :
209 : 0 : head_room = sizeof(struct ipv6hdr) + LL_RESERVED_SPACE(dst->dev);
210 [ # # ]: 0 : if (opt)
211 : 0 : head_room += opt->opt_nflen + opt->opt_flen;
212 : :
213 [ # # ]: 0 : if (unlikely(skb_headroom(skb) < head_room)) {
214 : 0 : struct sk_buff *skb2 = skb_realloc_headroom(skb, head_room);
215 [ # # ]: 0 : if (!skb2) {
216 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
217 : : IPSTATS_MIB_OUTDISCARDS);
218 : 0 : kfree_skb(skb);
219 : 0 : return -ENOBUFS;
220 : : }
221 [ # # ]: 0 : if (skb->sk)
222 : 0 : skb_set_owner_w(skb2, skb->sk);
223 : 0 : consume_skb(skb);
224 : : skb = skb2;
225 : : }
226 : :
227 [ # # ]: 0 : if (opt) {
228 : 0 : seg_len += opt->opt_nflen + opt->opt_flen;
229 : :
230 [ # # ]: 0 : if (opt->opt_flen)
231 : 0 : ipv6_push_frag_opts(skb, opt, &proto);
232 : :
233 [ # # ]: 0 : if (opt->opt_nflen)
234 : 0 : ipv6_push_nfrag_opts(skb, opt, &proto, &first_hop,
235 : : &fl6->saddr);
236 : : }
237 : :
238 : 0 : skb_push(skb, sizeof(struct ipv6hdr));
239 : : skb_reset_network_header(skb);
240 : : hdr = ipv6_hdr(skb);
241 : :
242 : : /*
243 : : * Fill in the IPv6 header
244 : : */
245 [ # # ]: 0 : if (np)
246 : 0 : hlimit = np->hop_limit;
247 [ # # ]: 0 : if (hlimit < 0)
248 : 0 : hlimit = ip6_dst_hoplimit(dst);
249 : :
250 : 0 : ip6_flow_hdr(hdr, tclass, ip6_make_flowlabel(net, skb, fl6->flowlabel,
251 : : ip6_autoflowlabel(net, np), fl6));
252 : :
253 : 0 : hdr->payload_len = htons(seg_len);
254 : 0 : hdr->nexthdr = proto;
255 : 0 : hdr->hop_limit = hlimit;
256 : :
257 : 0 : hdr->saddr = fl6->saddr;
258 : 0 : hdr->daddr = *first_hop;
259 : :
260 : 0 : skb->protocol = htons(ETH_P_IPV6);
261 : 0 : skb->priority = priority;
262 : 0 : skb->mark = mark;
263 : :
264 : : mtu = dst_mtu(dst);
265 [ # # # # : 0 : if ((skb->len <= mtu) || skb->ignore_df || skb_is_gso(skb)) {
# # ]
266 [ # # ]: 0 : IP6_UPD_PO_STATS(net, ip6_dst_idev(skb_dst(skb)),
267 : : IPSTATS_MIB_OUT, skb->len);
268 : :
269 : : /* if egress device is enslaved to an L3 master device pass the
270 : : * skb to its handler for processing
271 : : */
272 : : skb = l3mdev_ip6_out((struct sock *)sk, skb);
273 [ # # ]: 0 : if (unlikely(!skb))
274 : : return 0;
275 : :
276 : : /* hooks should never assume socket lock is held.
277 : : * we promote our socket to non const
278 : : */
279 : 0 : return NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT,
280 : : net, (struct sock *)sk, skb, NULL, dst->dev,
281 : : dst_output);
282 : : }
283 : :
284 : 0 : skb->dev = dst->dev;
285 : : /* ipv6_local_error() does not require socket lock,
286 : : * we promote our socket to non const
287 : : */
288 : 0 : ipv6_local_error((struct sock *)sk, EMSGSIZE, fl6, mtu);
289 : :
290 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)), IPSTATS_MIB_FRAGFAILS);
291 : 0 : kfree_skb(skb);
292 : 0 : return -EMSGSIZE;
293 : : }
294 : : EXPORT_SYMBOL(ip6_xmit);
295 : :
296 : 0 : static int ip6_call_ra_chain(struct sk_buff *skb, int sel)
297 : : {
298 : : struct ip6_ra_chain *ra;
299 : : struct sock *last = NULL;
300 : :
301 : 0 : read_lock(&ip6_ra_lock);
302 [ # # ]: 0 : for (ra = ip6_ra_chain; ra; ra = ra->next) {
303 : 0 : struct sock *sk = ra->sk;
304 [ # # # # : 0 : if (sk && ra->sel == sel &&
# # ]
305 [ # # ]: 0 : (!sk->sk_bound_dev_if ||
306 : 0 : sk->sk_bound_dev_if == skb->dev->ifindex)) {
307 : : struct ipv6_pinfo *np = inet6_sk(sk);
308 : :
309 [ # # # # : 0 : if (np && np->rtalert_isolate &&
# # ]
310 : 0 : !net_eq(sock_net(sk), dev_net(skb->dev))) {
311 : 0 : continue;
312 : : }
313 [ # # ]: 0 : if (last) {
314 : 0 : struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
315 [ # # ]: 0 : if (skb2)
316 : 0 : rawv6_rcv(last, skb2);
317 : : }
318 : : last = sk;
319 : : }
320 : : }
321 : :
322 [ # # ]: 0 : if (last) {
323 : 0 : rawv6_rcv(last, skb);
324 : : read_unlock(&ip6_ra_lock);
325 : 0 : return 1;
326 : : }
327 : : read_unlock(&ip6_ra_lock);
328 : 0 : return 0;
329 : : }
330 : :
331 : 0 : static int ip6_forward_proxy_check(struct sk_buff *skb)
332 : : {
333 : : struct ipv6hdr *hdr = ipv6_hdr(skb);
334 : 0 : u8 nexthdr = hdr->nexthdr;
335 : : __be16 frag_off;
336 : : int offset;
337 : :
338 [ # # ]: 0 : if (ipv6_ext_hdr(nexthdr)) {
339 : 0 : offset = ipv6_skip_exthdr(skb, sizeof(*hdr), &nexthdr, &frag_off);
340 [ # # ]: 0 : if (offset < 0)
341 : : return 0;
342 : : } else
343 : : offset = sizeof(struct ipv6hdr);
344 : :
345 [ # # ]: 0 : if (nexthdr == IPPROTO_ICMPV6) {
346 : : struct icmp6hdr *icmp6;
347 : :
348 [ # # ]: 0 : if (!pskb_may_pull(skb, (skb_network_header(skb) +
349 : 0 : offset + 1 - skb->data)))
350 : : return 0;
351 : :
352 : 0 : icmp6 = (struct icmp6hdr *)(skb_network_header(skb) + offset);
353 : :
354 [ # # ]: 0 : switch (icmp6->icmp6_type) {
355 : : case NDISC_ROUTER_SOLICITATION:
356 : : case NDISC_ROUTER_ADVERTISEMENT:
357 : : case NDISC_NEIGHBOUR_SOLICITATION:
358 : : case NDISC_NEIGHBOUR_ADVERTISEMENT:
359 : : case NDISC_REDIRECT:
360 : : /* For reaction involving unicast neighbor discovery
361 : : * message destined to the proxied address, pass it to
362 : : * input function.
363 : : */
364 : : return 1;
365 : : default:
366 : : break;
367 : : }
368 : : }
369 : :
370 : : /*
371 : : * The proxying router can't forward traffic sent to a link-local
372 : : * address, so signal the sender and discard the packet. This
373 : : * behavior is clarified by the MIPv6 specification.
374 : : */
375 [ # # ]: 0 : if (ipv6_addr_type(&hdr->daddr) & IPV6_ADDR_LINKLOCAL) {
376 : 0 : dst_link_failure(skb);
377 : 0 : return -1;
378 : : }
379 : :
380 : : return 0;
381 : : }
382 : :
383 : 0 : static inline int ip6_forward_finish(struct net *net, struct sock *sk,
384 : : struct sk_buff *skb)
385 : : {
386 : : struct dst_entry *dst = skb_dst(skb);
387 : :
388 [ # # ]: 0 : __IP6_INC_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTFORWDATAGRAMS);
389 [ # # ]: 0 : __IP6_ADD_STATS(net, ip6_dst_idev(dst), IPSTATS_MIB_OUTOCTETS, skb->len);
390 : :
391 : : #ifdef CONFIG_NET_SWITCHDEV
392 : : if (skb->offload_l3_fwd_mark) {
393 : : consume_skb(skb);
394 : : return 0;
395 : : }
396 : : #endif
397 : :
398 : 0 : skb->tstamp = 0;
399 : 0 : return dst_output(net, sk, skb);
400 : : }
401 : :
402 : 0 : static bool ip6_pkt_too_big(const struct sk_buff *skb, unsigned int mtu)
403 : : {
404 [ # # ]: 0 : if (skb->len <= mtu)
405 : : return false;
406 : :
407 : : /* ipv6 conntrack defrag sets max_frag_size + ignore_df */
408 [ # # # # ]: 0 : if (IP6CB(skb)->frag_max_size && IP6CB(skb)->frag_max_size > mtu)
409 : : return true;
410 : :
411 [ # # ]: 0 : if (skb->ignore_df)
412 : : return false;
413 : :
414 [ # # # # ]: 0 : if (skb_is_gso(skb) && skb_gso_validate_network_len(skb, mtu))
415 : : return false;
416 : :
417 : : return true;
418 : : }
419 : :
420 : 0 : int ip6_forward(struct sk_buff *skb)
421 : : {
422 : 0 : struct inet6_dev *idev = __in6_dev_get_safely(skb->dev);
423 : : struct dst_entry *dst = skb_dst(skb);
424 : : struct ipv6hdr *hdr = ipv6_hdr(skb);
425 : : struct inet6_skb_parm *opt = IP6CB(skb);
426 : 0 : struct net *net = dev_net(dst->dev);
427 : : u32 mtu;
428 : :
429 [ # # ]: 0 : if (net->ipv6.devconf_all->forwarding == 0)
430 : : goto error;
431 : :
432 [ # # ]: 0 : if (skb->pkt_type != PACKET_HOST)
433 : : goto drop;
434 : :
435 [ # # ]: 0 : if (unlikely(skb->sk))
436 : : goto drop;
437 : :
438 [ # # ]: 0 : if (skb_warn_if_lro(skb))
439 : : goto drop;
440 : :
441 [ # # ]: 0 : if (!xfrm6_policy_check(NULL, XFRM_POLICY_FWD, skb)) {
442 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INDISCARDS);
443 : : goto drop;
444 : : }
445 : :
446 : : skb_forward_csum(skb);
447 : :
448 : : /*
449 : : * We DO NOT make any processing on
450 : : * RA packets, pushing them to user level AS IS
451 : : * without ane WARRANTY that application will be able
452 : : * to interpret them. The reason is that we
453 : : * cannot make anything clever here.
454 : : *
455 : : * We are not end-node, so that if packet contains
456 : : * AH/ESP, we cannot make anything.
457 : : * Defragmentation also would be mistake, RA packets
458 : : * cannot be fragmented, because there is no warranty
459 : : * that different fragments will go along one path. --ANK
460 : : */
461 [ # # ]: 0 : if (unlikely(opt->flags & IP6SKB_ROUTERALERT)) {
462 [ # # ]: 0 : if (ip6_call_ra_chain(skb, ntohs(opt->ra)))
463 : : return 0;
464 : : }
465 : :
466 : : /*
467 : : * check and decrement ttl
468 : : */
469 [ # # ]: 0 : if (hdr->hop_limit <= 1) {
470 : : /* Force OUTPUT device used as source address */
471 : 0 : skb->dev = dst->dev;
472 : 0 : icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT, 0);
473 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INHDRERRORS);
474 : :
475 : 0 : kfree_skb(skb);
476 : 0 : return -ETIMEDOUT;
477 : : }
478 : :
479 : : /* XXX: idev->cnf.proxy_ndp? */
480 [ # # # # ]: 0 : if (net->ipv6.devconf_all->proxy_ndp &&
481 : 0 : pneigh_lookup(&nd_tbl, net, &hdr->daddr, skb->dev, 0)) {
482 : 0 : int proxied = ip6_forward_proxy_check(skb);
483 [ # # ]: 0 : if (proxied > 0)
484 : 0 : return ip6_input(skb);
485 [ # # ]: 0 : else if (proxied < 0) {
486 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INDISCARDS);
487 : : goto drop;
488 : : }
489 : : }
490 : :
491 [ # # ]: 0 : if (!xfrm6_route_forward(skb)) {
492 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INDISCARDS);
493 : : goto drop;
494 : : }
495 : : dst = skb_dst(skb);
496 : :
497 : : /* IPv6 specs say nothing about it, but it is clear that we cannot
498 : : send redirects to source routed frames.
499 : : We don't send redirects to frames decapsulated from IPsec.
500 : : */
501 [ # # # # ]: 0 : if (IP6CB(skb)->iif == dst->dev->ifindex &&
502 [ # # ]: 0 : opt->srcrt == 0 && !skb_sec_path(skb)) {
503 : : struct in6_addr *target = NULL;
504 : : struct inet_peer *peer;
505 : : struct rt6_info *rt;
506 : :
507 : : /*
508 : : * incoming and outgoing devices are the same
509 : : * send a redirect.
510 : : */
511 : :
512 : : rt = (struct rt6_info *) dst;
513 [ # # ]: 0 : if (rt->rt6i_flags & RTF_GATEWAY)
514 : 0 : target = &rt->rt6i_gateway;
515 : : else
516 : 0 : target = &hdr->daddr;
517 : :
518 : 0 : peer = inet_getpeer_v6(net->ipv6.peers, &hdr->daddr, 1);
519 : :
520 : : /* Limit redirects both by destination (here)
521 : : and by source (inside ndisc_send_redirect)
522 : : */
523 [ # # ]: 0 : if (inet_peer_xrlim_allow(peer, 1*HZ))
524 : 0 : ndisc_send_redirect(skb, target);
525 [ # # ]: 0 : if (peer)
526 : 0 : inet_putpeer(peer);
527 : : } else {
528 : 0 : int addrtype = ipv6_addr_type(&hdr->saddr);
529 : :
530 : : /* This check is security critical. */
531 [ # # # # ]: 0 : if (addrtype == IPV6_ADDR_ANY ||
532 : 0 : addrtype & (IPV6_ADDR_MULTICAST | IPV6_ADDR_LOOPBACK))
533 : : goto error;
534 [ # # ]: 0 : if (addrtype & IPV6_ADDR_LINKLOCAL) {
535 : 0 : icmpv6_send(skb, ICMPV6_DEST_UNREACH,
536 : : ICMPV6_NOT_NEIGHBOUR, 0);
537 : 0 : goto error;
538 : : }
539 : : }
540 : :
541 : 0 : mtu = ip6_dst_mtu_forward(dst);
542 [ # # ]: 0 : if (mtu < IPV6_MIN_MTU)
543 : : mtu = IPV6_MIN_MTU;
544 : :
545 [ # # ]: 0 : if (ip6_pkt_too_big(skb, mtu)) {
546 : : /* Again, force OUTPUT device used as source address */
547 : 0 : skb->dev = dst->dev;
548 : 0 : icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
549 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INTOOBIGERRORS);
550 [ # # ]: 0 : __IP6_INC_STATS(net, ip6_dst_idev(dst),
551 : : IPSTATS_MIB_FRAGFAILS);
552 : 0 : kfree_skb(skb);
553 : 0 : return -EMSGSIZE;
554 : : }
555 : :
556 [ # # ]: 0 : if (skb_cow(skb, dst->dev->hard_header_len)) {
557 [ # # ]: 0 : __IP6_INC_STATS(net, ip6_dst_idev(dst),
558 : : IPSTATS_MIB_OUTDISCARDS);
559 : : goto drop;
560 : : }
561 : :
562 : : hdr = ipv6_hdr(skb);
563 : :
564 : : /* Mangling hops number delayed to point after skb COW */
565 : :
566 : 0 : hdr->hop_limit--;
567 : :
568 : 0 : return NF_HOOK(NFPROTO_IPV6, NF_INET_FORWARD,
569 : : net, NULL, skb, skb->dev, dst->dev,
570 : : ip6_forward_finish);
571 : :
572 : : error:
573 [ # # ]: 0 : __IP6_INC_STATS(net, idev, IPSTATS_MIB_INADDRERRORS);
574 : : drop:
575 : 0 : kfree_skb(skb);
576 : 0 : return -EINVAL;
577 : : }
578 : :
579 : 0 : static void ip6_copy_metadata(struct sk_buff *to, struct sk_buff *from)
580 : : {
581 : 0 : to->pkt_type = from->pkt_type;
582 : 0 : to->priority = from->priority;
583 : 0 : to->protocol = from->protocol;
584 : 0 : skb_dst_drop(to);
585 : : skb_dst_set(to, dst_clone(skb_dst(from)));
586 : 0 : to->dev = from->dev;
587 : 0 : to->mark = from->mark;
588 : :
589 : : skb_copy_hash(to, from);
590 : :
591 : : #ifdef CONFIG_NET_SCHED
592 : 0 : to->tc_index = from->tc_index;
593 : : #endif
594 : 0 : nf_copy(to, from);
595 : 0 : skb_ext_copy(to, from);
596 : : skb_copy_secmark(to, from);
597 : 0 : }
598 : :
599 : 0 : int ip6_fraglist_init(struct sk_buff *skb, unsigned int hlen, u8 *prevhdr,
600 : : u8 nexthdr, __be32 frag_id,
601 : : struct ip6_fraglist_iter *iter)
602 : : {
603 : : unsigned int first_len;
604 : : struct frag_hdr *fh;
605 : :
606 : : /* BUILD HEADER */
607 : 0 : *prevhdr = NEXTHDR_FRAGMENT;
608 : 0 : iter->tmp_hdr = kmemdup(skb_network_header(skb), hlen, GFP_ATOMIC);
609 [ # # ]: 0 : if (!iter->tmp_hdr)
610 : : return -ENOMEM;
611 : :
612 : 0 : iter->frag = skb_shinfo(skb)->frag_list;
613 : : skb_frag_list_init(skb);
614 : :
615 : 0 : iter->offset = 0;
616 : 0 : iter->hlen = hlen;
617 : 0 : iter->frag_id = frag_id;
618 : 0 : iter->nexthdr = nexthdr;
619 : :
620 : 0 : __skb_pull(skb, hlen);
621 : : fh = __skb_push(skb, sizeof(struct frag_hdr));
622 : : __skb_push(skb, hlen);
623 : : skb_reset_network_header(skb);
624 : 0 : memcpy(skb_network_header(skb), iter->tmp_hdr, hlen);
625 : :
626 : 0 : fh->nexthdr = nexthdr;
627 : 0 : fh->reserved = 0;
628 : 0 : fh->frag_off = htons(IP6_MF);
629 : 0 : fh->identification = frag_id;
630 : :
631 : : first_len = skb_pagelen(skb);
632 : 0 : skb->data_len = first_len - skb_headlen(skb);
633 : 0 : skb->len = first_len;
634 : 0 : ipv6_hdr(skb)->payload_len = htons(first_len - sizeof(struct ipv6hdr));
635 : :
636 : 0 : return 0;
637 : : }
638 : : EXPORT_SYMBOL(ip6_fraglist_init);
639 : :
640 : 0 : void ip6_fraglist_prepare(struct sk_buff *skb,
641 : : struct ip6_fraglist_iter *iter)
642 : : {
643 : 0 : struct sk_buff *frag = iter->frag;
644 : 0 : unsigned int hlen = iter->hlen;
645 : : struct frag_hdr *fh;
646 : :
647 : 0 : frag->ip_summed = CHECKSUM_NONE;
648 : : skb_reset_transport_header(frag);
649 : : fh = __skb_push(frag, sizeof(struct frag_hdr));
650 : : __skb_push(frag, hlen);
651 : : skb_reset_network_header(frag);
652 : 0 : memcpy(skb_network_header(frag), iter->tmp_hdr, hlen);
653 : 0 : iter->offset += skb->len - hlen - sizeof(struct frag_hdr);
654 : 0 : fh->nexthdr = iter->nexthdr;
655 : 0 : fh->reserved = 0;
656 : 0 : fh->frag_off = htons(iter->offset);
657 [ # # ]: 0 : if (frag->next)
658 : 0 : fh->frag_off |= htons(IP6_MF);
659 : 0 : fh->identification = iter->frag_id;
660 : 0 : ipv6_hdr(frag)->payload_len = htons(frag->len - sizeof(struct ipv6hdr));
661 : 0 : ip6_copy_metadata(frag, skb);
662 : 0 : }
663 : : EXPORT_SYMBOL(ip6_fraglist_prepare);
664 : :
665 : 0 : void ip6_frag_init(struct sk_buff *skb, unsigned int hlen, unsigned int mtu,
666 : : unsigned short needed_tailroom, int hdr_room, u8 *prevhdr,
667 : : u8 nexthdr, __be32 frag_id, struct ip6_frag_state *state)
668 : : {
669 : 0 : state->prevhdr = prevhdr;
670 : 0 : state->nexthdr = nexthdr;
671 : 0 : state->frag_id = frag_id;
672 : :
673 : 0 : state->hlen = hlen;
674 : 0 : state->mtu = mtu;
675 : :
676 : 0 : state->left = skb->len - hlen; /* Space per frame */
677 : 0 : state->ptr = hlen; /* Where to start from */
678 : :
679 : 0 : state->hroom = hdr_room;
680 : 0 : state->troom = needed_tailroom;
681 : :
682 : 0 : state->offset = 0;
683 : 0 : }
684 : : EXPORT_SYMBOL(ip6_frag_init);
685 : :
686 : 0 : struct sk_buff *ip6_frag_next(struct sk_buff *skb, struct ip6_frag_state *state)
687 : : {
688 : 0 : u8 *prevhdr = state->prevhdr, *fragnexthdr_offset;
689 : : struct sk_buff *frag;
690 : : struct frag_hdr *fh;
691 : : unsigned int len;
692 : :
693 : 0 : len = state->left;
694 : : /* IF: it doesn't fit, use 'mtu' - the data space left */
695 [ # # ]: 0 : if (len > state->mtu)
696 : : len = state->mtu;
697 : : /* IF: we are not sending up to and including the packet end
698 : : then align the next start on an eight byte boundary */
699 [ # # ]: 0 : if (len < state->left)
700 : 0 : len &= ~7;
701 : :
702 : : /* Allocate buffer */
703 : 0 : frag = alloc_skb(len + state->hlen + sizeof(struct frag_hdr) +
704 : 0 : state->hroom + state->troom, GFP_ATOMIC);
705 [ # # ]: 0 : if (!frag)
706 : : return ERR_PTR(-ENOMEM);
707 : :
708 : : /*
709 : : * Set up data on packet
710 : : */
711 : :
712 : 0 : ip6_copy_metadata(frag, skb);
713 : 0 : skb_reserve(frag, state->hroom);
714 : 0 : skb_put(frag, len + state->hlen + sizeof(struct frag_hdr));
715 : : skb_reset_network_header(frag);
716 : 0 : fh = (struct frag_hdr *)(skb_network_header(frag) + state->hlen);
717 : 0 : frag->transport_header = (frag->network_header + state->hlen +
718 : : sizeof(struct frag_hdr));
719 : :
720 : : /*
721 : : * Charge the memory for the fragment to any owner
722 : : * it might possess
723 : : */
724 [ # # ]: 0 : if (skb->sk)
725 : 0 : skb_set_owner_w(frag, skb->sk);
726 : :
727 : : /*
728 : : * Copy the packet header into the new buffer.
729 : : */
730 : 0 : skb_copy_from_linear_data(skb, skb_network_header(frag), state->hlen);
731 : :
732 : : fragnexthdr_offset = skb_network_header(frag);
733 : 0 : fragnexthdr_offset += prevhdr - skb_network_header(skb);
734 : 0 : *fragnexthdr_offset = NEXTHDR_FRAGMENT;
735 : :
736 : : /*
737 : : * Build fragment header.
738 : : */
739 : 0 : fh->nexthdr = state->nexthdr;
740 : 0 : fh->reserved = 0;
741 : 0 : fh->identification = state->frag_id;
742 : :
743 : : /*
744 : : * Copy a block of the IP datagram.
745 : : */
746 [ # # ]: 0 : BUG_ON(skb_copy_bits(skb, state->ptr, skb_transport_header(frag),
747 : : len));
748 : 0 : state->left -= len;
749 : :
750 : 0 : fh->frag_off = htons(state->offset);
751 [ # # ]: 0 : if (state->left > 0)
752 : 0 : fh->frag_off |= htons(IP6_MF);
753 : 0 : ipv6_hdr(frag)->payload_len = htons(frag->len - sizeof(struct ipv6hdr));
754 : :
755 : 0 : state->ptr += len;
756 : 0 : state->offset += len;
757 : :
758 : 0 : return frag;
759 : : }
760 : : EXPORT_SYMBOL(ip6_frag_next);
761 : :
762 : 0 : int ip6_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
763 : : int (*output)(struct net *, struct sock *, struct sk_buff *))
764 : : {
765 : : struct sk_buff *frag;
766 : : struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
767 [ # # ]: 0 : struct ipv6_pinfo *np = skb->sk && !dev_recursion_level() ?
768 [ # # ]: 0 : inet6_sk(skb->sk) : NULL;
769 : : struct ip6_frag_state state;
770 : : unsigned int mtu, hlen, nexthdr_offset;
771 : 0 : ktime_t tstamp = skb->tstamp;
772 : : int hroom, err = 0;
773 : : __be32 frag_id;
774 : : u8 *prevhdr, nexthdr = 0;
775 : :
776 : 0 : err = ip6_find_1stfragopt(skb, &prevhdr);
777 [ # # ]: 0 : if (err < 0)
778 : : goto fail;
779 : 0 : hlen = err;
780 : 0 : nexthdr = *prevhdr;
781 : 0 : nexthdr_offset = prevhdr - skb_network_header(skb);
782 : :
783 : 0 : mtu = ip6_skb_dst_mtu(skb);
784 : :
785 : : /* We must not fragment if the socket is set to force MTU discovery
786 : : * or if the skb it not generated by a local socket.
787 : : */
788 [ # # # # ]: 0 : if (unlikely(!skb->ignore_df && skb->len > mtu))
789 : : goto fail_toobig;
790 : :
791 [ # # ]: 0 : if (IP6CB(skb)->frag_max_size) {
792 [ # # ]: 0 : if (IP6CB(skb)->frag_max_size > mtu)
793 : : goto fail_toobig;
794 : :
795 : : /* don't send fragments larger than what we received */
796 : : mtu = IP6CB(skb)->frag_max_size;
797 [ # # ]: 0 : if (mtu < IPV6_MIN_MTU)
798 : : mtu = IPV6_MIN_MTU;
799 : : }
800 : :
801 [ # # # # ]: 0 : if (np && np->frag_size < mtu) {
802 [ # # ]: 0 : if (np->frag_size)
803 : : mtu = np->frag_size;
804 : : }
805 [ # # ]: 0 : if (mtu < hlen + sizeof(struct frag_hdr) + 8)
806 : : goto fail_toobig;
807 : 0 : mtu -= hlen + sizeof(struct frag_hdr);
808 : :
809 : 0 : frag_id = ipv6_select_ident(net, &ipv6_hdr(skb)->daddr,
810 : 0 : &ipv6_hdr(skb)->saddr);
811 : :
812 [ # # # # ]: 0 : if (skb->ip_summed == CHECKSUM_PARTIAL &&
813 : : (err = skb_checksum_help(skb)))
814 : : goto fail;
815 : :
816 : 0 : prevhdr = skb_network_header(skb) + nexthdr_offset;
817 : 0 : hroom = LL_RESERVED_SPACE(rt->dst.dev);
818 [ # # ]: 0 : if (skb_has_frag_list(skb)) {
819 : : unsigned int first_len = skb_pagelen(skb);
820 : : struct ip6_fraglist_iter iter;
821 : : struct sk_buff *frag2;
822 : :
823 [ # # # # ]: 0 : if (first_len - hlen > mtu ||
824 [ # # ]: 0 : ((first_len - hlen) & 7) ||
825 [ # # ]: 0 : skb_cloned(skb) ||
826 : 0 : skb_headroom(skb) < (hroom + sizeof(struct frag_hdr)))
827 : : goto slow_path;
828 : :
829 [ # # ]: 0 : skb_walk_frags(skb, frag) {
830 : : /* Correct geometry. */
831 [ # # # # ]: 0 : if (frag->len > mtu ||
832 [ # # # # ]: 0 : ((frag->len & 7) && frag->next) ||
833 : 0 : skb_headroom(frag) < (hlen + hroom + sizeof(struct frag_hdr)))
834 : : goto slow_path_clean;
835 : :
836 : : /* Partially cloned skb? */
837 [ # # ]: 0 : if (skb_shared(frag))
838 : : goto slow_path_clean;
839 : :
840 [ # # ]: 0 : BUG_ON(frag->sk);
841 [ # # ]: 0 : if (skb->sk) {
842 : 0 : frag->sk = skb->sk;
843 : 0 : frag->destructor = sock_wfree;
844 : : }
845 : 0 : skb->truesize -= frag->truesize;
846 : : }
847 : :
848 : 0 : err = ip6_fraglist_init(skb, hlen, prevhdr, nexthdr, frag_id,
849 : : &iter);
850 [ # # ]: 0 : if (err < 0)
851 : : goto fail;
852 : :
853 : : for (;;) {
854 : : /* Prepare header of the next frame,
855 : : * before previous one went down. */
856 [ # # ]: 0 : if (iter.frag)
857 : 0 : ip6_fraglist_prepare(skb, &iter);
858 : :
859 : 0 : skb->tstamp = tstamp;
860 : 0 : err = output(net, sk, skb);
861 [ # # ]: 0 : if (!err)
862 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
863 : : IPSTATS_MIB_FRAGCREATES);
864 : :
865 [ # # # # ]: 0 : if (err || !iter.frag)
866 : : break;
867 : :
868 : : skb = ip6_fraglist_next(&iter);
869 : : }
870 : :
871 : 0 : kfree(iter.tmp_hdr);
872 : :
873 [ # # ]: 0 : if (err == 0) {
874 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
875 : : IPSTATS_MIB_FRAGOKS);
876 : 0 : return 0;
877 : : }
878 : :
879 : 0 : kfree_skb_list(iter.frag);
880 : :
881 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(&rt->dst),
882 : : IPSTATS_MIB_FRAGFAILS);
883 : 0 : return err;
884 : :
885 : : slow_path_clean:
886 [ # # ]: 0 : skb_walk_frags(skb, frag2) {
887 [ # # ]: 0 : if (frag2 == frag)
888 : : break;
889 : 0 : frag2->sk = NULL;
890 : 0 : frag2->destructor = NULL;
891 : 0 : skb->truesize += frag2->truesize;
892 : : }
893 : : }
894 : :
895 : : slow_path:
896 : : /*
897 : : * Fragment the datagram.
898 : : */
899 : :
900 : 0 : ip6_frag_init(skb, hlen, mtu, rt->dst.dev->needed_tailroom,
901 : 0 : LL_RESERVED_SPACE(rt->dst.dev), prevhdr, nexthdr, frag_id,
902 : : &state);
903 : :
904 : : /*
905 : : * Keep copying data until we run out.
906 : : */
907 : :
908 [ # # ]: 0 : while (state.left > 0) {
909 : 0 : frag = ip6_frag_next(skb, &state);
910 [ # # ]: 0 : if (IS_ERR(frag)) {
911 : : err = PTR_ERR(frag);
912 : 0 : goto fail;
913 : : }
914 : :
915 : : /*
916 : : * Put this fragment into the sending queue.
917 : : */
918 : 0 : frag->tstamp = tstamp;
919 : 0 : err = output(net, sk, frag);
920 [ # # ]: 0 : if (err)
921 : : goto fail;
922 : :
923 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
924 : : IPSTATS_MIB_FRAGCREATES);
925 : : }
926 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
927 : : IPSTATS_MIB_FRAGOKS);
928 : 0 : consume_skb(skb);
929 : 0 : return err;
930 : :
931 : : fail_toobig:
932 [ # # # # ]: 0 : if (skb->sk && dst_allfrag(skb_dst(skb)))
933 : 0 : sk_nocaps_add(skb->sk, NETIF_F_GSO_MASK);
934 : :
935 : 0 : icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
936 : : err = -EMSGSIZE;
937 : :
938 : : fail:
939 [ # # ]: 0 : IP6_INC_STATS(net, ip6_dst_idev(skb_dst(skb)),
940 : : IPSTATS_MIB_FRAGFAILS);
941 : 0 : kfree_skb(skb);
942 : 0 : return err;
943 : : }
944 : :
945 : 0 : static inline int ip6_rt_check(const struct rt6key *rt_key,
946 : : const struct in6_addr *fl_addr,
947 : : const struct in6_addr *addr_cache)
948 : : {
949 [ # # # # : 0 : return (rt_key->plen != 128 || !ipv6_addr_equal(fl_addr, &rt_key->addr)) &&
# # ]
950 [ # # ]: 0 : (!addr_cache || !ipv6_addr_equal(fl_addr, addr_cache));
951 : : }
952 : :
953 : 388 : static struct dst_entry *ip6_sk_dst_check(struct sock *sk,
954 : : struct dst_entry *dst,
955 : : const struct flowi6 *fl6)
956 : : {
957 : : struct ipv6_pinfo *np = inet6_sk(sk);
958 : : struct rt6_info *rt;
959 : :
960 [ - + ]: 388 : if (!dst)
961 : : goto out;
962 : :
963 [ # # ]: 0 : if (dst->ops->family != AF_INET6) {
964 : 0 : dst_release(dst);
965 : 0 : return NULL;
966 : : }
967 : :
968 : : rt = (struct rt6_info *)dst;
969 : : /* Yes, checking route validity in not connected
970 : : * case is not very simple. Take into account,
971 : : * that we do not support routing by source, TOS,
972 : : * and MSG_DONTROUTE --ANK (980726)
973 : : *
974 : : * 1. ip6_rt_check(): If route was host route,
975 : : * check that cached destination is current.
976 : : * If it is network route, we still may
977 : : * check its validity using saved pointer
978 : : * to the last used address: daddr_cache.
979 : : * We do not want to save whole address now,
980 : : * (because main consumer of this service
981 : : * is tcp, which has not this problem),
982 : : * so that the last trick works only on connected
983 : : * sockets.
984 : : * 2. oif also should be the same.
985 : : */
986 [ # # # # ]: 0 : if (ip6_rt_check(&rt->rt6i_dst, &fl6->daddr, np->daddr_cache) ||
987 : : #ifdef CONFIG_IPV6_SUBTREES
988 [ # # ]: 0 : ip6_rt_check(&rt->rt6i_src, &fl6->saddr, np->saddr_cache) ||
989 : : #endif
990 [ # # ]: 0 : (!(fl6->flowi6_flags & FLOWI_FLAG_SKIP_NH_OIF) &&
991 [ # # ]: 0 : (fl6->flowi6_oif && fl6->flowi6_oif != dst->dev->ifindex))) {
992 : 0 : dst_release(dst);
993 : : dst = NULL;
994 : : }
995 : :
996 : : out:
997 : 388 : return dst;
998 : : }
999 : :
1000 : 2047 : static int ip6_dst_lookup_tail(struct net *net, const struct sock *sk,
1001 : : struct dst_entry **dst, struct flowi6 *fl6)
1002 : : {
1003 : : #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1004 : : struct neighbour *n;
1005 : : struct rt6_info *rt;
1006 : : #endif
1007 : : int err;
1008 : : int flags = 0;
1009 : :
1010 : : /* The correct way to handle this would be to do
1011 : : * ip6_route_get_saddr, and then ip6_route_output; however,
1012 : : * the route-specific preferred source forces the
1013 : : * ip6_route_output call _before_ ip6_route_get_saddr.
1014 : : *
1015 : : * In source specific routing (no src=any default route),
1016 : : * ip6_route_output will fail given src=any saddr, though, so
1017 : : * that's why we try it again later.
1018 : : */
1019 [ + + - + : 2047 : if (ipv6_addr_any(&fl6->saddr) && (!*dst || !(*dst)->error)) {
# # ]
1020 : : struct fib6_info *from;
1021 : : struct rt6_info *rt;
1022 : 1659 : bool had_dst = *dst != NULL;
1023 : :
1024 [ + - ]: 1659 : if (!had_dst)
1025 : 1659 : *dst = ip6_route_output(net, sk, fl6);
1026 [ + + ]: 1659 : rt = (*dst)->error ? NULL : (struct rt6_info *)*dst;
1027 : :
1028 : : rcu_read_lock();
1029 [ + + ]: 2490 : from = rt ? rcu_dereference(rt->from) : NULL;
1030 [ + - ]: 3318 : err = ip6_route_get_saddr(net, from, &fl6->daddr,
1031 : 1659 : sk ? inet6_sk(sk)->srcprefs : 0,
1032 : : &fl6->saddr);
1033 : : rcu_read_unlock();
1034 : :
1035 [ + - ]: 1659 : if (err)
1036 : : goto out_err_release;
1037 : :
1038 : : /* If we had an erroneous initial result, pretend it
1039 : : * never existed and let the SA-enabled version take
1040 : : * over.
1041 : : */
1042 [ + - + + ]: 1659 : if (!had_dst && (*dst)->error) {
1043 : 828 : dst_release(*dst);
1044 : 828 : *dst = NULL;
1045 : : }
1046 : :
1047 [ + + ]: 1659 : if (fl6->flowi6_oif)
1048 : : flags |= RT6_LOOKUP_F_IFACE;
1049 : : }
1050 : :
1051 [ + + ]: 2047 : if (!*dst)
1052 : 1216 : *dst = ip6_route_output_flags(net, sk, fl6, flags);
1053 : :
1054 : 2047 : err = (*dst)->error;
1055 [ + + ]: 2047 : if (err)
1056 : : goto out_err_release;
1057 : :
1058 : : #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1059 : : /*
1060 : : * Here if the dst entry we've looked up
1061 : : * has a neighbour entry that is in the INCOMPLETE
1062 : : * state and the src address from the flow is
1063 : : * marked as OPTIMISTIC, we release the found
1064 : : * dst entry and replace it instead with the
1065 : : * dst entry of the nexthop router
1066 : : */
1067 : : rt = (struct rt6_info *) *dst;
1068 : : rcu_read_lock_bh();
1069 : : n = __ipv6_neigh_lookup_noref(rt->dst.dev,
1070 : : rt6_nexthop(rt, &fl6->daddr));
1071 : : err = n && !(n->nud_state & NUD_VALID) ? -EINVAL : 0;
1072 : : rcu_read_unlock_bh();
1073 : :
1074 : : if (err) {
1075 : : struct inet6_ifaddr *ifp;
1076 : : struct flowi6 fl_gw6;
1077 : : int redirect;
1078 : :
1079 : : ifp = ipv6_get_ifaddr(net, &fl6->saddr,
1080 : : (*dst)->dev, 1);
1081 : :
1082 : : redirect = (ifp && ifp->flags & IFA_F_OPTIMISTIC);
1083 : : if (ifp)
1084 : : in6_ifa_put(ifp);
1085 : :
1086 : : if (redirect) {
1087 : : /*
1088 : : * We need to get the dst entry for the
1089 : : * default router instead
1090 : : */
1091 : : dst_release(*dst);
1092 : : memcpy(&fl_gw6, fl6, sizeof(struct flowi6));
1093 : : memset(&fl_gw6.daddr, 0, sizeof(struct in6_addr));
1094 : : *dst = ip6_route_output(net, sk, &fl_gw6);
1095 : : err = (*dst)->error;
1096 : : if (err)
1097 : : goto out_err_release;
1098 : : }
1099 : : }
1100 : : #endif
1101 [ - + # # ]: 1219 : if (ipv6_addr_v4mapped(&fl6->saddr) &&
1102 [ # # ]: 0 : !(ipv6_addr_v4mapped(&fl6->daddr) || ipv6_addr_any(&fl6->daddr))) {
1103 : : err = -EAFNOSUPPORT;
1104 : : goto out_err_release;
1105 : : }
1106 : :
1107 : : return 0;
1108 : :
1109 : : out_err_release:
1110 : 828 : dst_release(*dst);
1111 : 828 : *dst = NULL;
1112 : :
1113 [ + - ]: 828 : if (err == -ENETUNREACH)
1114 : 2484 : IP6_INC_STATS(net, NULL, IPSTATS_MIB_OUTNOROUTES);
1115 : 828 : return err;
1116 : : }
1117 : :
1118 : : /**
1119 : : * ip6_dst_lookup - perform route lookup on flow
1120 : : * @sk: socket which provides route info
1121 : : * @dst: pointer to dst_entry * for result
1122 : : * @fl6: flow to lookup
1123 : : *
1124 : : * This function performs a route lookup on the given flow.
1125 : : *
1126 : : * It returns zero on success, or a standard errno code on error.
1127 : : */
1128 : 0 : int ip6_dst_lookup(struct net *net, struct sock *sk, struct dst_entry **dst,
1129 : : struct flowi6 *fl6)
1130 : : {
1131 : 0 : *dst = NULL;
1132 : 0 : return ip6_dst_lookup_tail(net, sk, dst, fl6);
1133 : : }
1134 : : EXPORT_SYMBOL_GPL(ip6_dst_lookup);
1135 : :
1136 : : /**
1137 : : * ip6_dst_lookup_flow - perform route lookup on flow with ipsec
1138 : : * @sk: socket which provides route info
1139 : : * @fl6: flow to lookup
1140 : : * @final_dst: final destination address for ipsec lookup
1141 : : *
1142 : : * This function performs a route lookup on the given flow.
1143 : : *
1144 : : * It returns a valid dst pointer on success, or a pointer encoded
1145 : : * error code.
1146 : : */
1147 : 2047 : struct dst_entry *ip6_dst_lookup_flow(struct net *net, const struct sock *sk, struct flowi6 *fl6,
1148 : : const struct in6_addr *final_dst)
1149 : : {
1150 : 2047 : struct dst_entry *dst = NULL;
1151 : : int err;
1152 : :
1153 : 2047 : err = ip6_dst_lookup_tail(net, sk, &dst, fl6);
1154 [ + + ]: 2047 : if (err)
1155 : 828 : return ERR_PTR(err);
1156 [ - + ]: 1219 : if (final_dst)
1157 : 0 : fl6->daddr = *final_dst;
1158 : :
1159 : 1219 : return xfrm_lookup_route(net, dst, flowi6_to_flowi(fl6), sk, 0);
1160 : : }
1161 : : EXPORT_SYMBOL_GPL(ip6_dst_lookup_flow);
1162 : :
1163 : : /**
1164 : : * ip6_sk_dst_lookup_flow - perform socket cached route lookup on flow
1165 : : * @sk: socket which provides the dst cache and route info
1166 : : * @fl6: flow to lookup
1167 : : * @final_dst: final destination address for ipsec lookup
1168 : : * @connected: whether @sk is connected or not
1169 : : *
1170 : : * This function performs a route lookup on the given flow with the
1171 : : * possibility of using the cached route in the socket if it is valid.
1172 : : * It will take the socket dst lock when operating on the dst cache.
1173 : : * As a result, this function can only be used in process context.
1174 : : *
1175 : : * In addition, for a connected socket, cache the dst in the socket
1176 : : * if the current cache is not valid.
1177 : : *
1178 : : * It returns a valid dst pointer on success, or a pointer encoded
1179 : : * error code.
1180 : : */
1181 : 388 : struct dst_entry *ip6_sk_dst_lookup_flow(struct sock *sk, struct flowi6 *fl6,
1182 : : const struct in6_addr *final_dst,
1183 : : bool connected)
1184 : : {
1185 : 388 : struct dst_entry *dst = sk_dst_check(sk, inet6_sk(sk)->dst_cookie);
1186 : :
1187 : 388 : dst = ip6_sk_dst_check(sk, dst, fl6);
1188 [ + - ]: 388 : if (dst)
1189 : : return dst;
1190 : :
1191 : 388 : dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, final_dst);
1192 [ - + # # ]: 388 : if (connected && !IS_ERR(dst))
1193 : 0 : ip6_sk_dst_store_flow(sk, dst_clone(dst), fl6);
1194 : :
1195 : 388 : return dst;
1196 : : }
1197 : : EXPORT_SYMBOL_GPL(ip6_sk_dst_lookup_flow);
1198 : :
1199 : 0 : static inline struct ipv6_opt_hdr *ip6_opt_dup(struct ipv6_opt_hdr *src,
1200 : : gfp_t gfp)
1201 : : {
1202 [ # # ]: 0 : return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1203 : : }
1204 : :
1205 : 0 : static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src,
1206 : : gfp_t gfp)
1207 : : {
1208 [ # # ]: 0 : return src ? kmemdup(src, (src->hdrlen + 1) * 8, gfp) : NULL;
1209 : : }
1210 : :
1211 : : static void ip6_append_data_mtu(unsigned int *mtu,
1212 : : int *maxfraglen,
1213 : : unsigned int fragheaderlen,
1214 : : struct sk_buff *skb,
1215 : : struct rt6_info *rt,
1216 : : unsigned int orig_mtu)
1217 : : {
1218 [ + - ]: 1219 : if (!(rt->dst.flags & DST_XFRM_TUNNEL)) {
1219 [ + - ]: 1219 : if (!skb) {
1220 : : /* first fragment, reserve header_len */
1221 : 1219 : *mtu = orig_mtu - rt->dst.header_len;
1222 : :
1223 : : } else {
1224 : : /*
1225 : : * this fragment is not first, the headers
1226 : : * space is regarded as data space.
1227 : : */
1228 : : *mtu = orig_mtu;
1229 : : }
1230 : 1219 : *maxfraglen = ((*mtu - fragheaderlen) & ~7)
1231 : 1219 : + fragheaderlen - sizeof(struct frag_hdr);
1232 : : }
1233 : : }
1234 : :
1235 : 1219 : static int ip6_setup_cork(struct sock *sk, struct inet_cork_full *cork,
1236 : : struct inet6_cork *v6_cork, struct ipcm6_cookie *ipc6,
1237 : : struct rt6_info *rt, struct flowi6 *fl6)
1238 : : {
1239 : : struct ipv6_pinfo *np = inet6_sk(sk);
1240 : : unsigned int mtu;
1241 : 1219 : struct ipv6_txoptions *opt = ipc6->opt;
1242 : :
1243 : : /*
1244 : : * setup for corking
1245 : : */
1246 [ - + ]: 1219 : if (opt) {
1247 [ # # # # ]: 0 : if (WARN_ON(v6_cork->opt))
1248 : : return -EINVAL;
1249 : :
1250 : 0 : v6_cork->opt = kzalloc(sizeof(*opt), sk->sk_allocation);
1251 [ # # ]: 0 : if (unlikely(!v6_cork->opt))
1252 : : return -ENOBUFS;
1253 : :
1254 : 0 : v6_cork->opt->tot_len = sizeof(*opt);
1255 : 0 : v6_cork->opt->opt_flen = opt->opt_flen;
1256 : 0 : v6_cork->opt->opt_nflen = opt->opt_nflen;
1257 : :
1258 : 0 : v6_cork->opt->dst0opt = ip6_opt_dup(opt->dst0opt,
1259 : : sk->sk_allocation);
1260 [ # # # # ]: 0 : if (opt->dst0opt && !v6_cork->opt->dst0opt)
1261 : : return -ENOBUFS;
1262 : :
1263 : 0 : v6_cork->opt->dst1opt = ip6_opt_dup(opt->dst1opt,
1264 : : sk->sk_allocation);
1265 [ # # # # ]: 0 : if (opt->dst1opt && !v6_cork->opt->dst1opt)
1266 : : return -ENOBUFS;
1267 : :
1268 : 0 : v6_cork->opt->hopopt = ip6_opt_dup(opt->hopopt,
1269 : : sk->sk_allocation);
1270 [ # # # # ]: 0 : if (opt->hopopt && !v6_cork->opt->hopopt)
1271 : : return -ENOBUFS;
1272 : :
1273 : 0 : v6_cork->opt->srcrt = ip6_rthdr_dup(opt->srcrt,
1274 : : sk->sk_allocation);
1275 [ # # # # ]: 0 : if (opt->srcrt && !v6_cork->opt->srcrt)
1276 : : return -ENOBUFS;
1277 : :
1278 : : /* need source address above miyazawa*/
1279 : : }
1280 : 1219 : dst_hold(&rt->dst);
1281 : 1219 : cork->base.dst = &rt->dst;
1282 : 1219 : cork->fl.u.ip6 = *fl6;
1283 : 1219 : v6_cork->hop_limit = ipc6->hlimit;
1284 : 1219 : v6_cork->tclass = ipc6->tclass;
1285 [ - + ]: 1219 : if (rt->dst.flags & DST_XFRM_TUNNEL)
1286 : 0 : mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1287 [ # # ]: 0 : READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst);
1288 : : else
1289 : 1219 : mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ?
1290 [ - + ]: 1219 : READ_ONCE(rt->dst.dev->mtu) : dst_mtu(xfrm_dst_path(&rt->dst));
1291 [ + - ]: 1219 : if (np->frag_size < mtu) {
1292 [ - + ]: 1219 : if (np->frag_size)
1293 : : mtu = np->frag_size;
1294 : : }
1295 [ + - ]: 1219 : if (mtu < IPV6_MIN_MTU)
1296 : : return -EINVAL;
1297 : 1219 : cork->base.fragsize = mtu;
1298 : 1219 : cork->base.gso_size = ipc6->gso_size;
1299 : 1219 : cork->base.tx_flags = 0;
1300 : 1219 : cork->base.mark = ipc6->sockc.mark;
1301 : 1219 : sock_tx_timestamp(sk, ipc6->sockc.tsflags, &cork->base.tx_flags);
1302 : :
1303 [ - + ]: 1219 : if (dst_allfrag(xfrm_dst_path(&rt->dst)))
1304 : 0 : cork->base.flags |= IPCORK_ALLFRAG;
1305 : 1219 : cork->base.length = 0;
1306 : :
1307 : 1219 : cork->base.transmit_time = ipc6->sockc.transmit_time;
1308 : :
1309 : 1219 : return 0;
1310 : : }
1311 : :
1312 : 1219 : static int __ip6_append_data(struct sock *sk,
1313 : : struct flowi6 *fl6,
1314 : : struct sk_buff_head *queue,
1315 : : struct inet_cork *cork,
1316 : : struct inet6_cork *v6_cork,
1317 : : struct page_frag *pfrag,
1318 : : int getfrag(void *from, char *to, int offset,
1319 : : int len, int odd, struct sk_buff *skb),
1320 : : void *from, int length, int transhdrlen,
1321 : : unsigned int flags, struct ipcm6_cookie *ipc6)
1322 : : {
1323 : : struct sk_buff *skb, *skb_prev = NULL;
1324 : : unsigned int maxfraglen, fragheaderlen, mtu, orig_mtu, pmtu;
1325 : : struct ubuf_info *uarg = NULL;
1326 : : int exthdrlen = 0;
1327 : : int dst_exthdrlen = 0;
1328 : : int hh_len;
1329 : : int copy;
1330 : : int err;
1331 : : int offset = 0;
1332 : : u32 tskey = 0;
1333 : 1219 : struct rt6_info *rt = (struct rt6_info *)cork->dst;
1334 : 1219 : struct ipv6_txoptions *opt = v6_cork->opt;
1335 : : int csummode = CHECKSUM_NONE;
1336 : : unsigned int maxnonfragsize, headersize;
1337 : : unsigned int wmem_alloc_delta = 0;
1338 : 1219 : bool paged, extra_uref = false;
1339 : :
1340 : : skb = skb_peek_tail(queue);
1341 [ + - ]: 1219 : if (!skb) {
1342 [ - + ]: 1219 : exthdrlen = opt ? opt->opt_flen : 0;
1343 : 1219 : dst_exthdrlen = rt->dst.header_len - rt->rt6i_nfheader_len;
1344 : : }
1345 : :
1346 : 1219 : paged = !!cork->gso_size;
1347 [ + - ]: 1219 : mtu = cork->gso_size ? IP6_MAX_MTU : cork->fragsize;
1348 : : orig_mtu = mtu;
1349 : :
1350 [ - + # # ]: 1219 : if (cork->tx_flags & SKBTX_ANY_SW_TSTAMP &&
1351 : 0 : sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)
1352 : 0 : tskey = sk->sk_tskey++;
1353 : :
1354 : 1219 : hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1355 : :
1356 [ - + ]: 1219 : fragheaderlen = sizeof(struct ipv6hdr) + rt->rt6i_nfheader_len +
1357 : 0 : (opt ? opt->opt_nflen : 0);
1358 : 1219 : maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen -
1359 : : sizeof(struct frag_hdr);
1360 : :
1361 [ - + ]: 2438 : headersize = sizeof(struct ipv6hdr) +
1362 : 1219 : (opt ? opt->opt_flen + opt->opt_nflen : 0) +
1363 : 1219 : (dst_allfrag(&rt->dst) ?
1364 [ + - ]: 2438 : sizeof(struct frag_hdr) : 0) +
1365 : 1219 : rt->rt6i_nfheader_len;
1366 : :
1367 : : /* as per RFC 7112 section 5, the entire IPv6 Header Chain must fit
1368 : : * the first fragment
1369 : : */
1370 [ + - ]: 1219 : if (headersize + transhdrlen > mtu)
1371 : : goto emsgsize;
1372 : :
1373 [ - + # # : 1219 : if (cork->length + length > mtu - headersize && ipc6->dontfrag &&
# # ]
1374 : 0 : (sk->sk_protocol == IPPROTO_UDP ||
1375 : : sk->sk_protocol == IPPROTO_RAW)) {
1376 : 0 : ipv6_local_rxpmtu(sk, fl6, mtu - headersize +
1377 : : sizeof(struct ipv6hdr));
1378 : 0 : goto emsgsize;
1379 : : }
1380 : :
1381 [ - + ]: 1219 : if (ip6_sk_ignore_df(sk))
1382 : : maxnonfragsize = sizeof(struct ipv6hdr) + IPV6_MAXPLEN;
1383 : : else
1384 : : maxnonfragsize = mtu;
1385 : :
1386 [ - + ]: 1219 : if (cork->length + length > maxnonfragsize - headersize) {
1387 : : emsgsize:
1388 : 0 : pmtu = max_t(int, mtu - headersize + sizeof(struct ipv6hdr), 0);
1389 : 0 : ipv6_local_error(sk, EMSGSIZE, fl6, pmtu);
1390 : 0 : return -EMSGSIZE;
1391 : : }
1392 : :
1393 : : /* CHECKSUM_PARTIAL only with no extension headers and when
1394 : : * we are not going to fragment
1395 : : */
1396 [ + + + - : 1219 : if (transhdrlen && sk->sk_protocol == IPPROTO_UDP &&
+ - ]
1397 [ + - ]: 388 : headersize == sizeof(struct ipv6hdr) &&
1398 [ - + ]: 776 : length <= mtu - headersize &&
1399 [ # # - + ]: 776 : (!(flags & MSG_MORE) || cork->gso_size) &&
1400 : 388 : rt->dst.dev->features & (NETIF_F_IPV6_CSUM | NETIF_F_HW_CSUM))
1401 : : csummode = CHECKSUM_PARTIAL;
1402 : :
1403 [ - + # # : 1219 : if (flags & MSG_ZEROCOPY && length && sock_flag(sk, SOCK_ZEROCOPY)) {
# # ]
1404 : 0 : uarg = sock_zerocopy_realloc(sk, length, skb_zcopy(skb));
1405 [ # # ]: 0 : if (!uarg)
1406 : : return -ENOBUFS;
1407 : 0 : extra_uref = !skb_zcopy(skb); /* only ref on new uarg */
1408 [ # # # # ]: 0 : if (rt->dst.dev->features & NETIF_F_SG &&
1409 : : csummode == CHECKSUM_PARTIAL) {
1410 : : paged = true;
1411 : : } else {
1412 : 0 : uarg->zerocopy = 0;
1413 : 0 : skb_zcopy_set(skb, uarg, &extra_uref);
1414 : : }
1415 : : }
1416 : :
1417 : : /*
1418 : : * Let's try using as much space as possible.
1419 : : * Use MTU if total length of the message fits into the MTU.
1420 : : * Otherwise, we need to reserve fragment header and
1421 : : * fragment alignment (= 8-15 octects, in total).
1422 : : *
1423 : : * Note that we may need to "move" the data from the tail of
1424 : : * of the buffer to the new fragment when we split
1425 : : * the message.
1426 : : *
1427 : : * FIXME: It may be fragmented into multiple chunks
1428 : : * at once if non-fragmentable extension headers
1429 : : * are too large.
1430 : : * --yoshfuji
1431 : : */
1432 : :
1433 : 1219 : cork->length += length;
1434 [ + - ]: 1219 : if (!skb)
1435 : : goto alloc_new_skb;
1436 : :
1437 [ - + ]: 1219 : while (length > 0) {
1438 : : /* Check if the remaining data fits into current packet. */
1439 [ # # # # ]: 0 : copy = (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - skb->len;
1440 [ # # ]: 0 : if (copy < length)
1441 : 0 : copy = maxfraglen - skb->len;
1442 : :
1443 [ # # ]: 0 : if (copy <= 0) {
1444 : : char *data;
1445 : : unsigned int datalen;
1446 : : unsigned int fraglen;
1447 : : unsigned int fraggap;
1448 : : unsigned int alloclen;
1449 : : unsigned int pagedlen;
1450 : : alloc_new_skb:
1451 : : /* There's no room in the current skb */
1452 [ - + ]: 1219 : if (skb)
1453 : 0 : fraggap = skb->len - maxfraglen;
1454 : : else
1455 : : fraggap = 0;
1456 : : /* update mtu and maxfraglen if necessary */
1457 [ + - ]: 1219 : if (!skb || !skb_prev)
1458 : : ip6_append_data_mtu(&mtu, &maxfraglen,
1459 : : fragheaderlen, skb, rt,
1460 : : orig_mtu);
1461 : :
1462 : : skb_prev = skb;
1463 : :
1464 : : /*
1465 : : * If remaining data exceeds the mtu,
1466 : : * we know we need more fragment(s).
1467 : : */
1468 : 1219 : datalen = length + fraggap;
1469 : :
1470 [ + - - + : 1219 : if (datalen > (cork->length <= mtu && !(cork->flags & IPCORK_ALLFRAG) ? mtu : maxfraglen) - fragheaderlen)
- + ]
1471 : 0 : datalen = maxfraglen - fragheaderlen - rt->dst.trailer_len;
1472 : 1219 : fraglen = datalen + fragheaderlen;
1473 : : pagedlen = 0;
1474 : :
1475 [ - + # # ]: 1219 : if ((flags & MSG_MORE) &&
1476 : 0 : !(rt->dst.dev->features&NETIF_F_SG))
1477 : : alloclen = mtu;
1478 [ - + ]: 1219 : else if (!paged)
1479 : : alloclen = fraglen;
1480 : : else {
1481 : 0 : alloclen = min_t(int, fraglen, MAX_HEADER);
1482 : 0 : pagedlen = fraglen - alloclen;
1483 : : }
1484 : :
1485 : 1219 : alloclen += dst_exthdrlen;
1486 : :
1487 [ - + ]: 1219 : if (datalen != length + fraggap) {
1488 : : /*
1489 : : * this is not the last fragment, the trailer
1490 : : * space is regarded as data space.
1491 : : */
1492 : 0 : datalen += rt->dst.trailer_len;
1493 : : }
1494 : :
1495 : 1219 : alloclen += rt->dst.trailer_len;
1496 : 1219 : fraglen = datalen + fragheaderlen;
1497 : :
1498 : : /*
1499 : : * We just reserve space for fragment header.
1500 : : * Note: this may be overallocation if the message
1501 : : * (without MSG_MORE) fits into the MTU.
1502 : : */
1503 : 1219 : alloclen += sizeof(struct frag_hdr);
1504 : :
1505 : 1219 : copy = datalen - transhdrlen - fraggap - pagedlen;
1506 [ - + ]: 1219 : if (copy < 0) {
1507 : 0 : err = -EINVAL;
1508 : 0 : goto error;
1509 : : }
1510 [ + + ]: 1219 : if (transhdrlen) {
1511 : 776 : skb = sock_alloc_send_skb(sk,
1512 : 388 : alloclen + hh_len,
1513 : : (flags & MSG_DONTWAIT), &err);
1514 : : } else {
1515 : : skb = NULL;
1516 [ + - ]: 1662 : if (refcount_read(&sk->sk_wmem_alloc) + wmem_alloc_delta <=
1517 : 831 : 2 * sk->sk_sndbuf)
1518 : 831 : skb = alloc_skb(alloclen + hh_len,
1519 : : sk->sk_allocation);
1520 [ - + ]: 831 : if (unlikely(!skb))
1521 : 0 : err = -ENOBUFS;
1522 : : }
1523 [ + - ]: 1219 : if (!skb)
1524 : : goto error;
1525 : : /*
1526 : : * Fill in the control structures
1527 : : */
1528 : 1219 : skb->protocol = htons(ETH_P_IPV6);
1529 : 1219 : skb->ip_summed = csummode;
1530 : 1219 : skb->csum = 0;
1531 : : /* reserve for fragmentation and ipsec header */
1532 : 1219 : skb_reserve(skb, hh_len + sizeof(struct frag_hdr) +
1533 : : dst_exthdrlen);
1534 : :
1535 : : /*
1536 : : * Find where to start putting bytes
1537 : : */
1538 : 1219 : data = skb_put(skb, fraglen - pagedlen);
1539 : : skb_set_network_header(skb, exthdrlen);
1540 : 1219 : data += fragheaderlen;
1541 : 1219 : skb->transport_header = (skb->network_header +
1542 : : fragheaderlen);
1543 [ - + ]: 1219 : if (fraggap) {
1544 : 0 : skb->csum = skb_copy_and_csum_bits(
1545 : : skb_prev, maxfraglen,
1546 : : data + transhdrlen, fraggap, 0);
1547 : 0 : skb_prev->csum = csum_sub(skb_prev->csum,
1548 : : skb->csum);
1549 : 0 : data += fraggap;
1550 : 0 : pskb_trim_unique(skb_prev, maxfraglen);
1551 : : }
1552 [ + - - + ]: 2438 : if (copy > 0 &&
1553 : 1219 : getfrag(from, data + transhdrlen, offset,
1554 : : copy, fraggap, skb) < 0) {
1555 : 0 : err = -EFAULT;
1556 : 0 : kfree_skb(skb);
1557 : 0 : goto error;
1558 : : }
1559 : :
1560 : 1219 : offset += copy;
1561 : 1219 : length -= copy + transhdrlen;
1562 : : transhdrlen = 0;
1563 : : exthdrlen = 0;
1564 : : dst_exthdrlen = 0;
1565 : :
1566 : : /* Only the initial fragment is time stamped */
1567 : 1219 : skb_shinfo(skb)->tx_flags = cork->tx_flags;
1568 : 1219 : cork->tx_flags = 0;
1569 : 1219 : skb_shinfo(skb)->tskey = tskey;
1570 : : tskey = 0;
1571 : 1219 : skb_zcopy_set(skb, uarg, &extra_uref);
1572 : :
1573 [ - + # # ]: 1219 : if ((flags & MSG_CONFIRM) && !skb_prev)
1574 : : skb_set_dst_pending_confirm(skb, 1);
1575 : :
1576 : : /*
1577 : : * Put the packet on the pending queue
1578 : : */
1579 [ + + ]: 1219 : if (!skb->destructor) {
1580 : 831 : skb->destructor = sock_wfree;
1581 : 831 : skb->sk = sk;
1582 : 831 : wmem_alloc_delta += skb->truesize;
1583 : : }
1584 : : __skb_queue_tail(queue, skb);
1585 : 1219 : continue;
1586 : : }
1587 : :
1588 [ # # ]: 0 : if (copy > length)
1589 : : copy = length;
1590 : :
1591 [ # # # # ]: 0 : if (!(rt->dst.dev->features&NETIF_F_SG) &&
1592 : : skb_tailroom(skb) >= copy) {
1593 : : unsigned int off;
1594 : :
1595 : : off = skb->len;
1596 [ # # ]: 0 : if (getfrag(from, skb_put(skb, copy),
1597 : : offset, copy, off, skb) < 0) {
1598 : : __skb_trim(skb, off);
1599 : 0 : err = -EFAULT;
1600 : 0 : goto error;
1601 : : }
1602 [ # # # # ]: 0 : } else if (!uarg || !uarg->zerocopy) {
1603 : 0 : int i = skb_shinfo(skb)->nr_frags;
1604 : :
1605 : 0 : err = -ENOMEM;
1606 [ # # ]: 0 : if (!sk_page_frag_refill(sk, pfrag))
1607 : : goto error;
1608 : :
1609 [ # # ]: 0 : if (!skb_can_coalesce(skb, i, pfrag->page,
1610 : 0 : pfrag->offset)) {
1611 : 0 : err = -EMSGSIZE;
1612 [ # # ]: 0 : if (i == MAX_SKB_FRAGS)
1613 : : goto error;
1614 : :
1615 : : __skb_fill_page_desc(skb, i, pfrag->page,
1616 : : pfrag->offset, 0);
1617 : 0 : skb_shinfo(skb)->nr_frags = ++i;
1618 : 0 : get_page(pfrag->page);
1619 : : }
1620 : 0 : copy = min_t(int, copy, pfrag->size - pfrag->offset);
1621 [ # # ]: 0 : if (getfrag(from,
1622 : 0 : page_address(pfrag->page) + pfrag->offset,
1623 : 0 : offset, copy, skb->len, skb) < 0)
1624 : : goto error_efault;
1625 : :
1626 : 0 : pfrag->offset += copy;
1627 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1628 : 0 : skb->len += copy;
1629 : 0 : skb->data_len += copy;
1630 : 0 : skb->truesize += copy;
1631 : 0 : wmem_alloc_delta += copy;
1632 : : } else {
1633 : 0 : err = skb_zerocopy_iter_dgram(skb, from, copy);
1634 [ # # ]: 0 : if (err < 0)
1635 : : goto error;
1636 : : }
1637 : 0 : offset += copy;
1638 : 0 : length -= copy;
1639 : : }
1640 : :
1641 [ + + ]: 1219 : if (wmem_alloc_delta)
1642 : 831 : refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
1643 : : return 0;
1644 : :
1645 : : error_efault:
1646 : 0 : err = -EFAULT;
1647 : : error:
1648 [ # # ]: 0 : if (uarg)
1649 : 0 : sock_zerocopy_put_abort(uarg, extra_uref);
1650 : 0 : cork->length -= length;
1651 [ # # ]: 0 : IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS);
1652 : 0 : refcount_add(wmem_alloc_delta, &sk->sk_wmem_alloc);
1653 : 0 : return err;
1654 : : }
1655 : :
1656 : 831 : int ip6_append_data(struct sock *sk,
1657 : : int getfrag(void *from, char *to, int offset, int len,
1658 : : int odd, struct sk_buff *skb),
1659 : : void *from, int length, int transhdrlen,
1660 : : struct ipcm6_cookie *ipc6, struct flowi6 *fl6,
1661 : : struct rt6_info *rt, unsigned int flags)
1662 : : {
1663 : : struct inet_sock *inet = inet_sk(sk);
1664 : : struct ipv6_pinfo *np = inet6_sk(sk);
1665 : : int exthdrlen;
1666 : : int err;
1667 : :
1668 [ + - ]: 831 : if (flags&MSG_PROBE)
1669 : : return 0;
1670 [ + - ]: 1662 : if (skb_queue_empty(&sk->sk_write_queue)) {
1671 : : /*
1672 : : * setup for corking
1673 : : */
1674 : 831 : err = ip6_setup_cork(sk, &inet->cork, &np->cork,
1675 : : ipc6, rt, fl6);
1676 [ + - ]: 831 : if (err)
1677 : : return err;
1678 : :
1679 [ - + ]: 831 : exthdrlen = (ipc6->opt ? ipc6->opt->opt_flen : 0);
1680 : 831 : length += exthdrlen;
1681 : 831 : transhdrlen += exthdrlen;
1682 : : } else {
1683 : 0 : fl6 = &inet->cork.fl.u.ip6;
1684 : : transhdrlen = 0;
1685 : : }
1686 : :
1687 : 1662 : return __ip6_append_data(sk, fl6, &sk->sk_write_queue, &inet->cork.base,
1688 : : &np->cork, sk_page_frag(sk), getfrag,
1689 : : from, length, transhdrlen, flags, ipc6);
1690 : : }
1691 : : EXPORT_SYMBOL_GPL(ip6_append_data);
1692 : :
1693 : 1219 : static void ip6_cork_release(struct inet_cork_full *cork,
1694 : : struct inet6_cork *v6_cork)
1695 : : {
1696 [ - + ]: 1219 : if (v6_cork->opt) {
1697 : 0 : kfree(v6_cork->opt->dst0opt);
1698 : 0 : kfree(v6_cork->opt->dst1opt);
1699 : 0 : kfree(v6_cork->opt->hopopt);
1700 : 0 : kfree(v6_cork->opt->srcrt);
1701 : 0 : kfree(v6_cork->opt);
1702 : 0 : v6_cork->opt = NULL;
1703 : : }
1704 : :
1705 [ + - ]: 1219 : if (cork->base.dst) {
1706 : 1219 : dst_release(cork->base.dst);
1707 : 1219 : cork->base.dst = NULL;
1708 : 1219 : cork->base.flags &= ~IPCORK_ALLFRAG;
1709 : : }
1710 : 1219 : memset(&cork->fl, 0, sizeof(cork->fl));
1711 : 1219 : }
1712 : :
1713 : 1219 : struct sk_buff *__ip6_make_skb(struct sock *sk,
1714 : : struct sk_buff_head *queue,
1715 : : struct inet_cork_full *cork,
1716 : : struct inet6_cork *v6_cork)
1717 : : {
1718 : : struct sk_buff *skb, *tmp_skb;
1719 : : struct sk_buff **tail_skb;
1720 : 1219 : struct in6_addr final_dst_buf, *final_dst = &final_dst_buf;
1721 : : struct ipv6_pinfo *np = inet6_sk(sk);
1722 : : struct net *net = sock_net(sk);
1723 : : struct ipv6hdr *hdr;
1724 : 1219 : struct ipv6_txoptions *opt = v6_cork->opt;
1725 : 1219 : struct rt6_info *rt = (struct rt6_info *)cork->base.dst;
1726 : 1219 : struct flowi6 *fl6 = &cork->fl.u.ip6;
1727 : 1219 : unsigned char proto = fl6->flowi6_proto;
1728 : :
1729 : : skb = __skb_dequeue(queue);
1730 [ + - ]: 1219 : if (!skb)
1731 : : goto out;
1732 : 1219 : tail_skb = &(skb_shinfo(skb)->frag_list);
1733 : :
1734 : : /* move skb->data to ip header from ext header */
1735 [ - + ]: 2438 : if (skb->data < skb_network_header(skb))
1736 : 0 : __skb_pull(skb, skb_network_offset(skb));
1737 [ - + ]: 1219 : while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
1738 : 0 : __skb_pull(tmp_skb, skb_network_header_len(skb));
1739 : 0 : *tail_skb = tmp_skb;
1740 : 0 : tail_skb = &(tmp_skb->next);
1741 : 0 : skb->len += tmp_skb->len;
1742 : 0 : skb->data_len += tmp_skb->len;
1743 : 0 : skb->truesize += tmp_skb->truesize;
1744 : 0 : tmp_skb->destructor = NULL;
1745 : 0 : tmp_skb->sk = NULL;
1746 : : }
1747 : :
1748 : : /* Allow local fragmentation. */
1749 : 1219 : skb->ignore_df = ip6_sk_ignore_df(sk);
1750 : :
1751 : 1219 : *final_dst = fl6->daddr;
1752 : 1219 : __skb_pull(skb, skb_network_header_len(skb));
1753 [ - + # # ]: 1219 : if (opt && opt->opt_flen)
1754 : 0 : ipv6_push_frag_opts(skb, opt, &proto);
1755 [ - + # # ]: 1219 : if (opt && opt->opt_nflen)
1756 : 0 : ipv6_push_nfrag_opts(skb, opt, &proto, &final_dst, &fl6->saddr);
1757 : :
1758 : 1219 : skb_push(skb, sizeof(struct ipv6hdr));
1759 : : skb_reset_network_header(skb);
1760 : : hdr = ipv6_hdr(skb);
1761 : :
1762 : 2438 : ip6_flow_hdr(hdr, v6_cork->tclass,
1763 : : ip6_make_flowlabel(net, skb, fl6->flowlabel,
1764 : : ip6_autoflowlabel(net, np), fl6));
1765 : 1219 : hdr->hop_limit = v6_cork->hop_limit;
1766 : 1219 : hdr->nexthdr = proto;
1767 : 1219 : hdr->saddr = fl6->saddr;
1768 : 1219 : hdr->daddr = *final_dst;
1769 : :
1770 : 1219 : skb->priority = sk->sk_priority;
1771 : 1219 : skb->mark = cork->base.mark;
1772 : :
1773 : 1219 : skb->tstamp = cork->base.transmit_time;
1774 : :
1775 : 1219 : skb_dst_set(skb, dst_clone(&rt->dst));
1776 [ + - ]: 12190 : IP6_UPD_PO_STATS(net, rt->rt6i_idev, IPSTATS_MIB_OUT, skb->len);
1777 [ + + ]: 1219 : if (proto == IPPROTO_ICMPV6) {
1778 : : struct inet6_dev *idev = ip6_dst_idev(skb_dst(skb));
1779 : :
1780 [ + - ]: 3324 : ICMP6MSGOUT_INC_STATS(net, idev, icmp6_hdr(skb)->icmp6_type);
1781 [ + - ]: 2493 : ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1782 : : }
1783 : :
1784 : 1219 : ip6_cork_release(cork, v6_cork);
1785 : : out:
1786 : 1219 : return skb;
1787 : : }
1788 : :
1789 : 1219 : int ip6_send_skb(struct sk_buff *skb)
1790 : : {
1791 : 1219 : struct net *net = sock_net(skb->sk);
1792 : : struct rt6_info *rt = (struct rt6_info *)skb_dst(skb);
1793 : : int err;
1794 : :
1795 : 1219 : err = ip6_local_out(net, skb->sk, skb);
1796 [ + + ]: 1219 : if (err) {
1797 [ + - ]: 1 : if (err > 0)
1798 [ + - ]: 1 : err = net_xmit_errno(err);
1799 [ - + ]: 1 : if (err)
1800 [ # # ]: 0 : IP6_INC_STATS(net, rt->rt6i_idev,
1801 : : IPSTATS_MIB_OUTDISCARDS);
1802 : : }
1803 : :
1804 : 1219 : return err;
1805 : : }
1806 : :
1807 : 831 : int ip6_push_pending_frames(struct sock *sk)
1808 : : {
1809 : : struct sk_buff *skb;
1810 : :
1811 : 831 : skb = ip6_finish_skb(sk);
1812 [ + - ]: 831 : if (!skb)
1813 : : return 0;
1814 : :
1815 : 831 : return ip6_send_skb(skb);
1816 : : }
1817 : : EXPORT_SYMBOL_GPL(ip6_push_pending_frames);
1818 : :
1819 : 0 : static void __ip6_flush_pending_frames(struct sock *sk,
1820 : : struct sk_buff_head *queue,
1821 : : struct inet_cork_full *cork,
1822 : : struct inet6_cork *v6_cork)
1823 : : {
1824 : : struct sk_buff *skb;
1825 : :
1826 [ # # ]: 0 : while ((skb = __skb_dequeue_tail(queue)) != NULL) {
1827 [ # # ]: 0 : if (skb_dst(skb))
1828 [ # # ]: 0 : IP6_INC_STATS(sock_net(sk), ip6_dst_idev(skb_dst(skb)),
1829 : : IPSTATS_MIB_OUTDISCARDS);
1830 : 0 : kfree_skb(skb);
1831 : : }
1832 : :
1833 : 0 : ip6_cork_release(cork, v6_cork);
1834 : 0 : }
1835 : :
1836 : 0 : void ip6_flush_pending_frames(struct sock *sk)
1837 : : {
1838 : 0 : __ip6_flush_pending_frames(sk, &sk->sk_write_queue,
1839 : : &inet_sk(sk)->cork, &inet6_sk(sk)->cork);
1840 : 0 : }
1841 : : EXPORT_SYMBOL_GPL(ip6_flush_pending_frames);
1842 : :
1843 : 388 : struct sk_buff *ip6_make_skb(struct sock *sk,
1844 : : int getfrag(void *from, char *to, int offset,
1845 : : int len, int odd, struct sk_buff *skb),
1846 : : void *from, int length, int transhdrlen,
1847 : : struct ipcm6_cookie *ipc6, struct flowi6 *fl6,
1848 : : struct rt6_info *rt, unsigned int flags,
1849 : : struct inet_cork_full *cork)
1850 : : {
1851 : : struct inet6_cork v6_cork;
1852 : : struct sk_buff_head queue;
1853 [ - + ]: 388 : int exthdrlen = (ipc6->opt ? ipc6->opt->opt_flen : 0);
1854 : : int err;
1855 : :
1856 [ + - ]: 388 : if (flags & MSG_PROBE)
1857 : : return NULL;
1858 : :
1859 : : __skb_queue_head_init(&queue);
1860 : :
1861 : 388 : cork->base.flags = 0;
1862 : 388 : cork->base.addr = 0;
1863 : 388 : cork->base.opt = NULL;
1864 : 388 : cork->base.dst = NULL;
1865 : 388 : v6_cork.opt = NULL;
1866 : 388 : err = ip6_setup_cork(sk, cork, &v6_cork, ipc6, rt, fl6);
1867 [ - + ]: 388 : if (err) {
1868 : 0 : ip6_cork_release(cork, &v6_cork);
1869 : 0 : return ERR_PTR(err);
1870 : : }
1871 [ + - ]: 388 : if (ipc6->dontfrag < 0)
1872 : 388 : ipc6->dontfrag = inet6_sk(sk)->dontfrag;
1873 : :
1874 : 776 : err = __ip6_append_data(sk, fl6, &queue, &cork->base, &v6_cork,
1875 : 388 : ¤t->task_frag, getfrag, from,
1876 : : length + exthdrlen, transhdrlen + exthdrlen,
1877 : : flags, ipc6);
1878 [ - + ]: 388 : if (err) {
1879 : 0 : __ip6_flush_pending_frames(sk, &queue, cork, &v6_cork);
1880 : 0 : return ERR_PTR(err);
1881 : : }
1882 : :
1883 : 388 : return __ip6_make_skb(sk, &queue, cork, &v6_cork);
1884 : : }
|
