Branch data Line data Source code
1 : : /*
2 : : * INET An implementation of the TCP/IP protocol suite for the LINUX
3 : : * operating system. INET is implemented using the BSD Socket
4 : : * interface as the means of communication with the user level.
5 : : *
6 : : * The Internet Protocol (IP) output module.
7 : : *
8 : : * Authors: Ross Biro
9 : : * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10 : : * Donald Becker, <becker@super.org>
11 : : * Alan Cox, <Alan.Cox@linux.org>
12 : : * Richard Underwood
13 : : * Stefan Becker, <stefanb@yello.ping.de>
14 : : * Jorge Cwik, <jorge@laser.satlink.net>
15 : : * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
16 : : * Hirokazu Takahashi, <taka@valinux.co.jp>
17 : : *
18 : : * See ip_input.c for original log
19 : : *
20 : : * Fixes:
21 : : * Alan Cox : Missing nonblock feature in ip_build_xmit.
22 : : * Mike Kilburn : htons() missing in ip_build_xmit.
23 : : * Bradford Johnson: Fix faulty handling of some frames when
24 : : * no route is found.
25 : : * Alexander Demenshin: Missing sk/skb free in ip_queue_xmit
26 : : * (in case if packet not accepted by
27 : : * output firewall rules)
28 : : * Mike McLagan : Routing by source
29 : : * Alexey Kuznetsov: use new route cache
30 : : * Andi Kleen: Fix broken PMTU recovery and remove
31 : : * some redundant tests.
32 : : * Vitaly E. Lavrov : Transparent proxy revived after year coma.
33 : : * Andi Kleen : Replace ip_reply with ip_send_reply.
34 : : * Andi Kleen : Split fast and slow ip_build_xmit path
35 : : * for decreased register pressure on x86
36 : : * and more readibility.
37 : : * Marc Boucher : When call_out_firewall returns FW_QUEUE,
38 : : * silently drop skb instead of failing with -EPERM.
39 : : * Detlev Wengorz : Copy protocol for fragments.
40 : : * Hirokazu Takahashi: HW checksumming for outgoing UDP
41 : : * datagrams.
42 : : * Hirokazu Takahashi: sendfile() on UDP works now.
43 : : */
44 : :
45 : : #include <asm/uaccess.h>
46 : : #include <linux/module.h>
47 : : #include <linux/types.h>
48 : : #include <linux/kernel.h>
49 : : #include <linux/mm.h>
50 : : #include <linux/string.h>
51 : : #include <linux/errno.h>
52 : : #include <linux/highmem.h>
53 : : #include <linux/slab.h>
54 : :
55 : : #include <linux/socket.h>
56 : : #include <linux/sockios.h>
57 : : #include <linux/in.h>
58 : : #include <linux/inet.h>
59 : : #include <linux/netdevice.h>
60 : : #include <linux/etherdevice.h>
61 : : #include <linux/proc_fs.h>
62 : : #include <linux/stat.h>
63 : : #include <linux/init.h>
64 : :
65 : : #include <net/snmp.h>
66 : : #include <net/ip.h>
67 : : #include <net/protocol.h>
68 : : #include <net/route.h>
69 : : #include <net/xfrm.h>
70 : : #include <linux/skbuff.h>
71 : : #include <net/sock.h>
72 : : #include <net/arp.h>
73 : : #include <net/icmp.h>
74 : : #include <net/checksum.h>
75 : : #include <net/inetpeer.h>
76 : : #include <linux/igmp.h>
77 : : #include <linux/netfilter_ipv4.h>
78 : : #include <linux/netfilter_bridge.h>
79 : : #include <linux/mroute.h>
80 : : #include <linux/netlink.h>
81 : : #include <linux/tcp.h>
82 : :
83 : : int sysctl_ip_default_ttl __read_mostly = IPDEFTTL;
84 : : EXPORT_SYMBOL(sysctl_ip_default_ttl);
85 : :
86 : : /* Generate a checksum for an outgoing IP datagram. */
87 : 0 : void ip_send_check(struct iphdr *iph)
88 : : {
89 : 54528 : iph->check = 0;
90 : 109054 : iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
91 : 54526 : }
92 : : EXPORT_SYMBOL(ip_send_check);
93 : :
94 : 0 : int __ip_local_out(struct sk_buff *skb)
95 : : {
96 : : struct iphdr *iph = ip_hdr(skb);
97 : :
98 [ - + ]: 54527 : iph->tot_len = htons(skb->len);
99 : 54527 : ip_send_check(iph);
100 : 54525 : return nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT, skb, NULL,
101 : : skb_dst(skb)->dev, dst_output);
102 : : }
103 : :
104 : 0 : int ip_local_out(struct sk_buff *skb)
105 : : {
106 : : int err;
107 : :
108 : 54527 : err = __ip_local_out(skb);
109 [ + + ]: 54528 : if (likely(err == 1))
110 : : err = dst_output(skb);
111 : :
112 : 2 : return err;
113 : : }
114 : : EXPORT_SYMBOL_GPL(ip_local_out);
115 : :
116 : : static inline int ip_select_ttl(struct inet_sock *inet, struct dst_entry *dst)
117 : : {
118 : 54526 : int ttl = inet->uc_ttl;
119 : :
120 [ + - ][ + ]: 54526 : if (ttl < 0)
[ + - ]
121 : : ttl = ip4_dst_hoplimit(dst);
122 : : return ttl;
123 : : }
124 : :
125 : : /*
126 : : * Add an ip header to a skbuff and send it out.
127 : : *
128 : : */
129 : 0 : int ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk,
130 : : __be32 saddr, __be32 daddr, struct ip_options_rcu *opt)
131 : : {
132 : : struct inet_sock *inet = inet_sk(sk);
133 : : struct rtable *rt = skb_rtable(skb);
134 : : struct iphdr *iph;
135 : :
136 : : /* Build the IP header. */
137 [ - + ]: 28 : skb_push(skb, sizeof(struct iphdr) + (opt ? opt->opt.optlen : 0));
138 : : skb_reset_network_header(skb);
139 : : iph = ip_hdr(skb);
140 : 28 : iph->version = 4;
141 : 28 : iph->ihl = 5;
142 : 28 : iph->tos = inet->tos;
143 [ + - ]: 28 : if (ip_dont_fragment(sk, &rt->dst))
144 : 28 : iph->frag_off = htons(IP_DF);
145 : : else
146 : 0 : iph->frag_off = 0;
147 : 28 : iph->ttl = ip_select_ttl(inet, &rt->dst);
148 [ - + ][ # # ]: 28 : iph->daddr = (opt && opt->opt.srr ? opt->opt.faddr : daddr);
149 : 28 : iph->saddr = saddr;
150 : 28 : iph->protocol = sk->sk_protocol;
151 : 28 : ip_select_ident(skb, &rt->dst, sk);
152 : :
153 [ - + ][ # # ]: 28 : if (opt && opt->opt.optlen) {
154 : 0 : iph->ihl += opt->opt.optlen>>2;
155 : 0 : ip_options_build(skb, &opt->opt, daddr, rt, 0);
156 : : }
157 : :
158 : 28 : skb->priority = sk->sk_priority;
159 : 28 : skb->mark = sk->sk_mark;
160 : :
161 : : /* Send it out. */
162 : 28 : return ip_local_out(skb);
163 : : }
164 : : EXPORT_SYMBOL_GPL(ip_build_and_send_pkt);
165 : :
166 : 0 : static inline int ip_finish_output2(struct sk_buff *skb)
167 : : {
168 : : struct dst_entry *dst = skb_dst(skb);
169 : 54526 : struct rtable *rt = (struct rtable *)dst;
170 : 54527 : struct net_device *dev = dst->dev;
171 : 54527 : unsigned int hh_len = LL_RESERVED_SPACE(dev);
172 : : struct neighbour *neigh;
173 : : u32 nexthop;
174 : :
175 [ - + ][ # # ]: 54527 : if (rt->rt_type == RTN_MULTICAST) {
176 : 0 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUTMCAST, skb->len);
177 [ - + ][ # # ]: 54527 : } else if (rt->rt_type == RTN_BROADCAST)
178 : 0 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUTBCAST, skb->len);
179 : :
180 : : /* Be paranoid, rather than too clever. */
181 [ - + ][ # # ]: 54528 : if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
[ # # ][ # # ]
182 : : struct sk_buff *skb2;
183 : :
184 : 0 : skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
185 [ # # # # ]: 0 : if (skb2 == NULL) {
186 : 0 : kfree_skb(skb);
187 : 0 : return -ENOMEM;
188 : : }
189 [ # # ][ # # ]: 0 : if (skb->sk)
190 : : skb_set_owner_w(skb2, skb->sk);
191 : 0 : consume_skb(skb);
192 : : skb = skb2;
193 : : }
194 : :
195 : : rcu_read_lock_bh();
196 : 109052 : nexthop = (__force u32) rt_nexthop(rt, ip_hdr(skb)->daddr);
197 : : neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
198 [ + + ][ # # ]: 54526 : if (unlikely(!neigh))
199 : 1 : neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
200 [ + - ][ # # ]: 54526 : if (!IS_ERR(neigh)) {
201 : : int res = dst_neigh_output(dst, neigh, skb);
202 : :
203 : : rcu_read_unlock_bh();
204 : 0 : return res;
205 : : }
206 : : rcu_read_unlock_bh();
207 : :
208 : 0 : net_dbg_ratelimited("%s: No header cache and no neighbour!\n",
209 : : __func__);
210 : 0 : kfree_skb(skb);
211 : 0 : return -EINVAL;
212 : : }
213 : :
214 : 0 : static int ip_finish_output(struct sk_buff *skb)
215 : : {
216 : : #if defined(CONFIG_NETFILTER) && defined(CONFIG_XFRM)
217 : : /* Policy lookup after SNAT yielded a new policy */
218 [ - + ]: 54528 : if (skb_dst(skb)->xfrm != NULL) {
219 : 0 : IPCB(skb)->flags |= IPSKB_REROUTED;
220 : 0 : return dst_output(skb);
221 : : }
222 : : #endif
223 [ - + ][ # # ]: 54527 : if (skb->len > ip_skb_dst_mtu(skb) && !skb_is_gso(skb))
224 : 0 : return ip_fragment(skb, ip_finish_output2);
225 : : else
226 : 54528 : return ip_finish_output2(skb);
227 : : }
228 : :
229 : 0 : int ip_mc_output(struct sk_buff *skb)
230 : : {
231 : 0 : struct sock *sk = skb->sk;
232 : : struct rtable *rt = skb_rtable(skb);
233 : 0 : struct net_device *dev = rt->dst.dev;
234 : :
235 : : /*
236 : : * If the indicated interface is up and running, send the packet.
237 : : */
238 : 0 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUT, skb->len);
239 : :
240 : 0 : skb->dev = dev;
241 : 0 : skb->protocol = htons(ETH_P_IP);
242 : :
243 : : /*
244 : : * Multicasts are looped back for other local users
245 : : */
246 : :
247 [ # # ]: 0 : if (rt->rt_flags&RTCF_MULTICAST) {
248 [ # # ]: 0 : if (sk_mc_loop(sk)
249 : : #ifdef CONFIG_IP_MROUTE
250 : : /* Small optimization: do not loopback not local frames,
251 : : which returned after forwarding; they will be dropped
252 : : by ip_mr_input in any case.
253 : : Note, that local frames are looped back to be delivered
254 : : to local recipients.
255 : :
256 : : This check is duplicated in ip_mr_input at the moment.
257 : : */
258 : : &&
259 : : ((rt->rt_flags & RTCF_LOCAL) ||
260 : : !(IPCB(skb)->flags & IPSKB_FORWARDED))
261 : : #endif
262 : : ) {
263 : 0 : struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
264 [ # # ]: 0 : if (newskb)
265 : 0 : NF_HOOK(NFPROTO_IPV4, NF_INET_POST_ROUTING,
266 : : newskb, NULL, newskb->dev,
267 : : dev_loopback_xmit);
268 : : }
269 : :
270 : : /* Multicasts with ttl 0 must not go beyond the host */
271 : :
272 [ # # ]: 0 : if (ip_hdr(skb)->ttl == 0) {
273 : 0 : kfree_skb(skb);
274 : 0 : return 0;
275 : : }
276 : : }
277 : :
278 [ # # ]: 0 : if (rt->rt_flags&RTCF_BROADCAST) {
279 : 0 : struct sk_buff *newskb = skb_clone(skb, GFP_ATOMIC);
280 [ # # ]: 0 : if (newskb)
281 : 0 : NF_HOOK(NFPROTO_IPV4, NF_INET_POST_ROUTING, newskb,
282 : : NULL, newskb->dev, dev_loopback_xmit);
283 : : }
284 : :
285 : 0 : return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb, NULL,
286 : : skb->dev, ip_finish_output,
287 : 0 : !(IPCB(skb)->flags & IPSKB_REROUTED));
288 : : }
289 : :
290 : 0 : int ip_output(struct sk_buff *skb)
291 : : {
292 : 54528 : struct net_device *dev = skb_dst(skb)->dev;
293 : :
294 : 109055 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUT, skb->len);
295 : :
296 : 54527 : skb->dev = dev;
297 : 54527 : skb->protocol = htons(ETH_P_IP);
298 : :
299 : 54528 : return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb, NULL, dev,
300 : : ip_finish_output,
301 : 54527 : !(IPCB(skb)->flags & IPSKB_REROUTED));
302 : : }
303 : :
304 : : /*
305 : : * copy saddr and daddr, possibly using 64bit load/stores
306 : : * Equivalent to :
307 : : * iph->saddr = fl4->saddr;
308 : : * iph->daddr = fl4->daddr;
309 : : */
310 : : static void ip_copy_addrs(struct iphdr *iph, const struct flowi4 *fl4)
311 : : {
312 : : BUILD_BUG_ON(offsetof(typeof(*fl4), daddr) !=
313 : : offsetof(typeof(*fl4), saddr) + sizeof(fl4->saddr));
314 : 54498 : memcpy(&iph->saddr, &fl4->saddr,
315 : : sizeof(fl4->saddr) + sizeof(fl4->daddr));
316 : : }
317 : :
318 : 0 : int ip_queue_xmit(struct sk_buff *skb, struct flowi *fl)
319 : : {
320 : 54470 : struct sock *sk = skb->sk;
321 : : struct inet_sock *inet = inet_sk(sk);
322 : : struct ip_options_rcu *inet_opt;
323 : : struct flowi4 *fl4;
324 : : struct rtable *rt;
325 : : struct iphdr *iph;
326 : : int res;
327 : :
328 : : /* Skip all of this if the packet is already routed,
329 : : * f.e. by something like SCTP.
330 : : */
331 : : rcu_read_lock();
332 : 54470 : inet_opt = rcu_dereference(inet->inet_opt);
333 : 54470 : fl4 = &fl->u.ip4;
334 : : rt = skb_rtable(skb);
335 [ + - ]: 54470 : if (rt != NULL)
336 : : goto packet_routed;
337 : :
338 : : /* Make sure we can route this packet. */
339 : 54470 : rt = (struct rtable *)__sk_dst_check(sk, 0);
340 [ + + ]: 54469 : if (rt == NULL) {
341 : : __be32 daddr;
342 : :
343 : : /* Use correct destination address if we have options. */
344 : 2 : daddr = inet->inet_daddr;
345 [ - + ][ # # ]: 2 : if (inet_opt && inet_opt->opt.srr)
346 : 0 : daddr = inet_opt->opt.faddr;
347 : :
348 : : /* If this fails, retransmit mechanism of transport layer will
349 : : * keep trying until route appears or the connection times
350 : : * itself out.
351 : : */
352 : 6 : rt = ip_route_output_ports(sock_net(sk), fl4, sk,
353 : : daddr, inet->inet_saddr,
354 : : inet->inet_dport,
355 : : inet->inet_sport,
356 : : sk->sk_protocol,
357 : 2 : RT_CONN_FLAGS(sk),
358 : : sk->sk_bound_dev_if);
359 [ + - ]: 2 : if (IS_ERR(rt))
360 : : goto no_route;
361 : 2 : sk_setup_caps(sk, &rt->dst);
362 : : }
363 : 54469 : skb_dst_set_noref(skb, &rt->dst);
364 : :
365 : : packet_routed:
366 [ - + ][ # # ]: 54469 : if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_uses_gateway)
[ # # ]
367 : : goto no_route;
368 : :
369 : : /* OK, we know where to send it, allocate and build IP header. */
370 [ - + ]: 54469 : skb_push(skb, sizeof(struct iphdr) + (inet_opt ? inet_opt->opt.optlen : 0));
371 : : skb_reset_network_header(skb);
372 : : iph = ip_hdr(skb);
373 [ + ]: 108938 : *((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
374 [ + ][ + + ]: 54468 : if (ip_dont_fragment(sk, &rt->dst) && !skb->local_df)
375 : 54468 : iph->frag_off = htons(IP_DF);
376 : : else
377 : 0 : iph->frag_off = 0;
378 : 54468 : iph->ttl = ip_select_ttl(inet, &rt->dst);
379 : 54468 : iph->protocol = sk->sk_protocol;
380 : : ip_copy_addrs(iph, fl4);
381 : :
382 : : /* Transport layer set skb->h.foo itself. */
383 : :
384 [ - + ][ # # ]: 54468 : if (inet_opt && inet_opt->opt.optlen) {
385 : 0 : iph->ihl += inet_opt->opt.optlen >> 2;
386 : 0 : ip_options_build(skb, &inet_opt->opt, inet->inet_daddr, rt, 0);
387 : : }
388 : :
389 [ + - ]: 54469 : ip_select_ident_more(skb, &rt->dst, sk,
390 : 54469 : (skb_shinfo(skb)->gso_segs ?: 1) - 1);
391 : :
392 : 54470 : skb->priority = sk->sk_priority;
393 : 54470 : skb->mark = sk->sk_mark;
394 : :
395 : 54470 : res = ip_local_out(skb);
396 : : rcu_read_unlock();
397 : 54470 : return res;
398 : :
399 : : no_route:
400 : : rcu_read_unlock();
401 : 0 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
402 : 0 : kfree_skb(skb);
403 : 0 : return -EHOSTUNREACH;
404 : : }
405 : : EXPORT_SYMBOL(ip_queue_xmit);
406 : :
407 : :
408 : 0 : static void ip_copy_metadata(struct sk_buff *to, struct sk_buff *from)
409 : : {
410 : 0 : to->pkt_type = from->pkt_type;
411 : 0 : to->priority = from->priority;
412 : 0 : to->protocol = from->protocol;
413 : : skb_dst_drop(to);
414 : : skb_dst_copy(to, from);
415 : 0 : to->dev = from->dev;
416 : 0 : to->mark = from->mark;
417 : :
418 : : /* Copy the flags to each fragment. */
419 : 0 : IPCB(to)->flags = IPCB(from)->flags;
420 : :
421 : : #ifdef CONFIG_NET_SCHED
422 : : to->tc_index = from->tc_index;
423 : : #endif
424 : : nf_copy(to, from);
425 : : #if IS_ENABLED(CONFIG_NETFILTER_XT_TARGET_TRACE)
426 : : to->nf_trace = from->nf_trace;
427 : : #endif
428 : : #if defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE)
429 : : to->ipvs_property = from->ipvs_property;
430 : : #endif
431 : : skb_copy_secmark(to, from);
432 : 0 : }
433 : :
434 : : /*
435 : : * This IP datagram is too large to be sent in one piece. Break it up into
436 : : * smaller pieces (each of size equal to IP header plus
437 : : * a block of the data of the original IP data part) that will yet fit in a
438 : : * single device frame, and queue such a frame for sending.
439 : : */
440 : :
441 : 0 : int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
442 : : {
443 : 0 : struct iphdr *iph;
444 : : int ptr;
445 : : struct net_device *dev;
446 : 0 : struct sk_buff *skb2;
447 : : unsigned int mtu, hlen, left, len, ll_rs;
448 : : int offset;
449 : : __be16 not_last_frag;
450 : : struct rtable *rt = skb_rtable(skb);
451 : : int err = 0;
452 : :
453 : : dev = rt->dst.dev;
454 : :
455 : : /*
456 : : * Point into the IP datagram header.
457 : : */
458 : :
459 : : iph = ip_hdr(skb);
460 : :
461 [ # # ][ # # ]: 0 : if (unlikely(((iph->frag_off & htons(IP_DF)) && !skb->local_df) ||
[ # # ]
[ # # # # ]
[ # # ]
462 : : (IPCB(skb)->frag_max_size &&
463 : : IPCB(skb)->frag_max_size > dst_mtu(&rt->dst)))) {
464 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
465 : 0 : icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
466 : 0 : htonl(ip_skb_dst_mtu(skb)));
467 : 0 : kfree_skb(skb);
468 : 0 : return -EMSGSIZE;
469 : : }
470 : :
471 : : /*
472 : : * Setup starting values.
473 : : */
474 : :
475 : 0 : hlen = iph->ihl * 4;
476 : 0 : mtu = dst_mtu(&rt->dst) - hlen; /* Size of data space */
477 : : #ifdef CONFIG_BRIDGE_NETFILTER
478 [ # # ]: 0 : if (skb->nf_bridge)
479 : 0 : mtu -= nf_bridge_mtu_reduction(skb);
480 : : #endif
481 : 0 : IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;
482 : :
483 : : /* When frag_list is given, use it. First, check its validity:
484 : : * some transformers could create wrong frag_list or break existing
485 : : * one, it is not prohibited. In this case fall back to copying.
486 : : *
487 : : * LATER: this step can be merged to real generation of fragments,
488 : : * we can switch to copy when see the first bad fragment.
489 : : */
490 [ # # ]: 0 : if (skb_has_frag_list(skb)) {
491 : 0 : struct sk_buff *frag, *frag2;
492 : : int first_len = skb_pagelen(skb);
493 : :
494 [ # # ][ # # ]: 0 : if (first_len - hlen > mtu ||
495 [ # # ]: 0 : ((first_len - hlen) & 7) ||
496 [ # # ]: 0 : ip_is_fragment(iph) ||
497 : : skb_cloned(skb))
498 : : goto slow_path;
499 : :
500 [ # # ]: 0 : skb_walk_frags(skb, frag) {
501 : : /* Correct geometry. */
502 [ # # ][ # # ]: 0 : if (frag->len > mtu ||
503 [ # # ][ # # ]: 0 : ((frag->len & 7) && frag->next) ||
504 : : skb_headroom(frag) < hlen)
505 : : goto slow_path_clean;
506 : :
507 : : /* Partially cloned skb? */
508 [ # # ]: 0 : if (skb_shared(frag))
509 : : goto slow_path_clean;
510 : :
511 [ # # ]: 0 : BUG_ON(frag->sk);
512 [ # # ]: 0 : if (skb->sk) {
513 : 0 : frag->sk = skb->sk;
514 : 0 : frag->destructor = sock_wfree;
515 : : }
516 : 0 : skb->truesize -= frag->truesize;
517 : : }
518 : :
519 : : /* Everything is OK. Generate! */
520 : :
521 : : err = 0;
522 : : offset = 0;
523 : 0 : frag = skb_shinfo(skb)->frag_list;
524 : : skb_frag_list_init(skb);
525 : 0 : skb->data_len = first_len - skb_headlen(skb);
526 : 0 : skb->len = first_len;
527 [ # # ]: 0 : iph->tot_len = htons(first_len);
528 : 0 : iph->frag_off = htons(IP_MF);
529 : 0 : ip_send_check(iph);
530 : :
531 : : for (;;) {
532 : : /* Prepare header of the next frame,
533 : : * before previous one went down. */
534 [ # # ]: 0 : if (frag) {
535 : 0 : frag->ip_summed = CHECKSUM_NONE;
536 : : skb_reset_transport_header(frag);
537 : : __skb_push(frag, hlen);
538 : : skb_reset_network_header(frag);
539 : 0 : memcpy(skb_network_header(frag), iph, hlen);
540 : : iph = ip_hdr(frag);
541 [ # # ]: 0 : iph->tot_len = htons(frag->len);
542 : 0 : ip_copy_metadata(frag, skb);
543 [ # # ]: 0 : if (offset == 0)
544 : 0 : ip_options_fragment(frag);
545 : 0 : offset += skb->len - hlen;
546 [ # # ]: 0 : iph->frag_off = htons(offset>>3);
547 [ # # ]: 0 : if (frag->next != NULL)
548 : 0 : iph->frag_off |= htons(IP_MF);
549 : : /* Ready, complete checksum */
550 : 0 : ip_send_check(iph);
551 : : }
552 : :
553 : 0 : err = output(skb);
554 : :
555 [ # # ]: 0 : if (!err)
556 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
557 [ # # ]: 0 : if (err || !frag)
558 : : break;
559 : :
560 : : skb = frag;
561 : 0 : frag = skb->next;
562 : 0 : skb->next = NULL;
563 : 0 : }
564 : :
565 [ # # ]: 0 : if (err == 0) {
566 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
567 : 0 : return 0;
568 : : }
569 : :
570 [ # # ]: 0 : while (frag) {
571 : 0 : skb = frag->next;
572 : 0 : kfree_skb(frag);
573 : : frag = skb;
574 : : }
575 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
576 : 0 : return err;
577 : :
578 : : slow_path_clean:
579 [ # # ]: 0 : skb_walk_frags(skb, frag2) {
580 [ # # ]: 0 : if (frag2 == frag)
581 : : break;
582 : 0 : frag2->sk = NULL;
583 : 0 : frag2->destructor = NULL;
584 : 0 : skb->truesize += frag2->truesize;
585 : : }
586 : : }
587 : :
588 : : slow_path:
589 : : /* for offloaded checksums cleanup checksum before fragmentation */
590 [ # # ][ # # ]: 0 : if ((skb->ip_summed == CHECKSUM_PARTIAL) && skb_checksum_help(skb))
591 : : goto fail;
592 : : iph = ip_hdr(skb);
593 : :
594 : 0 : left = skb->len - hlen; /* Space per frame */
595 : : ptr = hlen; /* Where to start from */
596 : :
597 : : /* for bridged IP traffic encapsulated inside f.e. a vlan header,
598 : : * we need to make room for the encapsulating header
599 : : */
600 : 0 : ll_rs = LL_RESERVED_SPACE_EXTRA(rt->dst.dev, nf_bridge_pad(skb));
601 : :
602 : : /*
603 : : * Fragment the datagram.
604 : : */
605 : :
606 [ # # ]: 0 : offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
607 : 0 : not_last_frag = iph->frag_off & htons(IP_MF);
608 : :
609 : : /*
610 : : * Keep copying data until we run out.
611 : : */
612 : :
613 [ # # ]: 0 : while (left > 0) {
614 : : len = left;
615 : : /* IF: it doesn't fit, use 'mtu' - the data space left */
616 [ # # ]: 0 : if (len > mtu)
617 : : len = mtu;
618 : : /* IF: we are not sending up to and including the packet end
619 : : then align the next start on an eight byte boundary */
620 [ # # ]: 0 : if (len < left) {
621 : 0 : len &= ~7;
622 : : }
623 : : /*
624 : : * Allocate buffer.
625 : : */
626 : :
627 [ # # ]: 0 : if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {
628 [ # # ]: 0 : NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n");
629 : : err = -ENOMEM;
630 : : goto fail;
631 : : }
632 : :
633 : : /*
634 : : * Set up data on packet
635 : : */
636 : :
637 : 0 : ip_copy_metadata(skb2, skb);
638 : : skb_reserve(skb2, ll_rs);
639 : 0 : skb_put(skb2, len + hlen);
640 : : skb_reset_network_header(skb2);
641 : 0 : skb2->transport_header = skb2->network_header + hlen;
642 : :
643 : : /*
644 : : * Charge the memory for the fragment to any owner
645 : : * it might possess
646 : : */
647 : :
648 [ # # ]: 0 : if (skb->sk)
649 : : skb_set_owner_w(skb2, skb->sk);
650 : :
651 : : /*
652 : : * Copy the packet header into the new buffer.
653 : : */
654 : :
655 : : skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen);
656 : :
657 : : /*
658 : : * Copy a block of the IP datagram.
659 : : */
660 [ # # ]: 0 : if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len))
661 : 0 : BUG();
662 : 0 : left -= len;
663 : :
664 : : /*
665 : : * Fill in the new header fields.
666 : : */
667 : : iph = ip_hdr(skb2);
668 [ # # ]: 0 : iph->frag_off = htons((offset >> 3));
669 : :
670 : : /* ANK: dirty, but effective trick. Upgrade options only if
671 : : * the segment to be fragmented was THE FIRST (otherwise,
672 : : * options are already fixed) and make it ONCE
673 : : * on the initial skb, so that all the following fragments
674 : : * will inherit fixed options.
675 : : */
676 [ # # ]: 0 : if (offset == 0)
677 : 0 : ip_options_fragment(skb);
678 : :
679 : : /*
680 : : * Added AC : If we are fragmenting a fragment that's not the
681 : : * last fragment then keep MF on each bit
682 : : */
683 [ # # ]: 0 : if (left > 0 || not_last_frag)
684 : 0 : iph->frag_off |= htons(IP_MF);
685 : 0 : ptr += len;
686 : 0 : offset += len;
687 : :
688 : : /*
689 : : * Put this fragment into the sending queue.
690 : : */
691 [ # # ]: 0 : iph->tot_len = htons(len + hlen);
692 : :
693 : 0 : ip_send_check(iph);
694 : :
695 : 0 : err = output(skb2);
696 [ # # ]: 0 : if (err)
697 : : goto fail;
698 : :
699 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
700 : : }
701 : 0 : consume_skb(skb);
702 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
703 : 0 : return err;
704 : :
705 : : fail:
706 : 0 : kfree_skb(skb);
707 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
708 : 0 : return err;
709 : : }
710 : : EXPORT_SYMBOL(ip_fragment);
711 : :
712 : : int
713 : 0 : ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
714 : : {
715 : : struct iovec *iov = from;
716 : :
717 [ + + ]: 13 : if (skb->ip_summed == CHECKSUM_PARTIAL) {
718 [ - + ]: 2 : if (memcpy_fromiovecend(to, iov, offset, len) < 0)
719 : : return -EFAULT;
720 : : } else {
721 : 11 : __wsum csum = 0;
722 [ - + ]: 11 : if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0)
723 : 0 : return -EFAULT;
724 : 11 : skb->csum = csum_block_add(skb->csum, csum, odd);
725 : : }
726 : : return 0;
727 : : }
728 : : EXPORT_SYMBOL(ip_generic_getfrag);
729 : :
730 : : static inline __wsum
731 : : csum_page(struct page *page, int offset, int copy)
732 : : {
733 : : char *kaddr;
734 : : __wsum csum;
735 : 0 : kaddr = kmap(page);
736 : 0 : csum = csum_partial(kaddr + offset, copy, 0);
737 : 0 : kunmap(page);
738 : : return csum;
739 : : }
740 : :
741 : : static inline int ip_ufo_append_data(struct sock *sk,
742 : : struct sk_buff_head *queue,
743 : : int getfrag(void *from, char *to, int offset, int len,
744 : : int odd, struct sk_buff *skb),
745 : : void *from, int length, int hh_len, int fragheaderlen,
746 : : int transhdrlen, int maxfraglen, unsigned int flags)
747 : : {
748 : 0 : struct sk_buff *skb;
749 : : int err;
750 : :
751 : : /* There is support for UDP fragmentation offload by network
752 : : * device, so create one single skb packet containing complete
753 : : * udp datagram
754 : : */
755 [ # # ]: 0 : if ((skb = skb_peek_tail(queue)) == NULL) {
756 : 0 : skb = sock_alloc_send_skb(sk,
757 : 0 : hh_len + fragheaderlen + transhdrlen + 20,
758 : : (flags & MSG_DONTWAIT), &err);
759 : :
760 [ # # ]: 0 : if (skb == NULL)
761 : 0 : return err;
762 : :
763 : : /* reserve space for Hardware header */
764 : : skb_reserve(skb, hh_len);
765 : :
766 : : /* create space for UDP/IP header */
767 : 0 : skb_put(skb, fragheaderlen + transhdrlen);
768 : :
769 : : /* initialize network header pointer */
770 : : skb_reset_network_header(skb);
771 : :
772 : : /* initialize protocol header pointer */
773 : 0 : skb->transport_header = skb->network_header + fragheaderlen;
774 : :
775 : 0 : skb->csum = 0;
776 : :
777 : :
778 : : __skb_queue_tail(queue, skb);
779 [ # # ]: 0 : } else if (skb_is_gso(skb)) {
780 : : goto append;
781 : : }
782 : :
783 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
784 : : /* specify the length of each IP datagram fragment */
785 : 0 : skb_shinfo(skb)->gso_size = maxfraglen - fragheaderlen;
786 : 0 : skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
787 : :
788 : : append:
789 : 0 : return skb_append_datato_frags(sk, skb, getfrag, from,
790 : : (length - transhdrlen));
791 : : }
792 : :
793 : 0 : static int __ip_append_data(struct sock *sk,
794 : : struct flowi4 *fl4,
795 : : struct sk_buff_head *queue,
796 : : struct inet_cork *cork,
797 : : struct page_frag *pfrag,
798 : : int getfrag(void *from, char *to, int offset,
799 : : int len, int odd, struct sk_buff *skb),
800 : : void *from, int length, int transhdrlen,
801 : : unsigned int flags)
802 : : {
803 : : struct inet_sock *inet = inet_sk(sk);
804 : 32 : struct sk_buff *skb;
805 : :
806 : 32 : struct ip_options *opt = cork->opt;
807 : : int hh_len;
808 : : int exthdrlen;
809 : : int mtu;
810 : : int copy;
811 : : int err;
812 : : int offset = 0;
813 : : unsigned int maxfraglen, fragheaderlen, maxnonfragsize;
814 : : int csummode = CHECKSUM_NONE;
815 : 32 : struct rtable *rt = (struct rtable *)cork->dst;
816 : :
817 : : skb = skb_peek_tail(queue);
818 : :
819 [ + - ]: 32 : exthdrlen = !skb ? rt->dst.header_len : 0;
820 : 32 : mtu = cork->fragsize;
821 : :
822 : 32 : hh_len = LL_RESERVED_SPACE(rt->dst.dev);
823 : :
824 [ - + ]: 32 : fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
825 : 32 : maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
826 [ - + ]: 32 : maxnonfragsize = (inet->pmtudisc >= IP_PMTUDISC_DO) ?
827 : : mtu : 0xFFFF;
828 : :
829 [ - + ]: 32 : if (cork->length + length > maxnonfragsize - fragheaderlen) {
830 : 0 : ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
831 [ # # ]: 0 : mtu - (opt ? opt->optlen : 0));
832 : : return -EMSGSIZE;
833 : : }
834 : :
835 : : /*
836 : : * transhdrlen > 0 means that this is the first fragment and we wish
837 : : * it won't be fragmented in the future.
838 : : */
839 [ + + ][ + - ]: 32 : if (transhdrlen &&
840 [ + + ]: 29 : length + fragheaderlen <= mtu &&
841 [ + - ]: 18 : rt->dst.dev->features & NETIF_F_V4_CSUM &&
842 : : !exthdrlen)
843 : : csummode = CHECKSUM_PARTIAL;
844 : :
845 : 32 : cork->length += length;
846 [ + - ][ - + ]: 32 : if (((length > mtu) || (skb && skb_is_gso(skb))) &&
[ # # ][ # # ]
847 [ # # ]: 0 : (sk->sk_protocol == IPPROTO_UDP) &&
848 [ # # ]: 0 : (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len) {
849 : 0 : err = ip_ufo_append_data(sk, queue, getfrag, from, length,
850 : : hh_len, fragheaderlen, transhdrlen,
851 : : maxfraglen, flags);
852 [ # # ]: 0 : if (err)
853 : : goto error;
854 : : return 0;
855 : : }
856 : :
857 : : /* So, what's going on in the loop below?
858 : : *
859 : : * We use calculated fragment length to generate chained skb,
860 : : * each of segments is IP fragment ready for sending to network after
861 : : * adding appropriate IP header.
862 : : */
863 : :
864 [ + - ]: 32 : if (!skb)
865 : : goto alloc_new_skb;
866 : :
867 [ - + ]: 30 : while (length > 0) {
868 : : /* Check if the remaining data fits into current packet. */
869 : 0 : copy = mtu - skb->len;
870 [ # # ]: 0 : if (copy < length)
871 : 0 : copy = maxfraglen - skb->len;
872 [ # # ]: 0 : if (copy <= 0) {
873 : : char *data;
874 : : unsigned int datalen;
875 : : unsigned int fraglen;
876 : : unsigned int fraggap;
877 : : unsigned int alloclen;
878 : : struct sk_buff *skb_prev;
879 : : alloc_new_skb:
880 : : skb_prev = skb;
881 [ - + ]: 32 : if (skb_prev)
882 : 0 : fraggap = skb_prev->len - maxfraglen;
883 : : else
884 : : fraggap = 0;
885 : :
886 : : /*
887 : : * If remaining data exceeds the mtu,
888 : : * we know we need more fragment(s).
889 : : */
890 : 32 : datalen = length + fraggap;
891 [ - + ]: 32 : if (datalen > mtu - fragheaderlen)
892 : : datalen = maxfraglen - fragheaderlen;
893 : 32 : fraglen = datalen + fragheaderlen;
894 : :
895 [ + + ][ + - ]: 32 : if ((flags & MSG_MORE) &&
896 : 16 : !(rt->dst.dev->features&NETIF_F_SG))
897 : : alloclen = mtu;
898 : : else
899 : : alloclen = fraglen;
900 : :
901 : 32 : alloclen += exthdrlen;
902 : :
903 : : /* The last fragment gets additional space at tail.
904 : : * Note, with MSG_MORE we overallocate on fragments,
905 : : * because we have no idea what fragment will be
906 : : * the last.
907 : : */
908 [ + - ]: 32 : if (datalen == length + fraggap)
909 : 32 : alloclen += rt->dst.trailer_len;
910 : :
911 [ + + ]: 32 : if (transhdrlen) {
912 : 29 : skb = sock_alloc_send_skb(sk,
913 : 29 : alloclen + hh_len + 15,
914 : : (flags & MSG_DONTWAIT), &err);
915 : : } else {
916 : : skb = NULL;
917 [ + - ]: 3 : if (atomic_read(&sk->sk_wmem_alloc) <=
918 : 3 : 2 * sk->sk_sndbuf)
919 : 3 : skb = sock_wmalloc(sk,
920 : 3 : alloclen + hh_len + 15, 1,
921 : : sk->sk_allocation);
922 [ - + ]: 3 : if (unlikely(skb == NULL))
923 : 0 : err = -ENOBUFS;
924 : : else
925 : : /* only the initial fragment is
926 : : time stamped */
927 : 3 : cork->tx_flags = 0;
928 : : }
929 [ + - ]: 32 : if (skb == NULL)
930 : : goto error;
931 : :
932 : : /*
933 : : * Fill in the control structures
934 : : */
935 : 32 : skb->ip_summed = csummode;
936 : 32 : skb->csum = 0;
937 : : skb_reserve(skb, hh_len);
938 : 32 : skb_shinfo(skb)->tx_flags = cork->tx_flags;
939 : :
940 : : /*
941 : : * Find where to start putting bytes.
942 : : */
943 : 32 : data = skb_put(skb, fraglen + exthdrlen);
944 : : skb_set_network_header(skb, exthdrlen);
945 : 32 : skb->transport_header = (skb->network_header +
946 : : fragheaderlen);
947 : 32 : data += fragheaderlen + exthdrlen;
948 : :
949 [ - + ]: 32 : if (fraggap) {
950 : 0 : skb->csum = skb_copy_and_csum_bits(
951 : : skb_prev, maxfraglen,
952 : : data + transhdrlen, fraggap, 0);
953 : 0 : skb_prev->csum = csum_sub(skb_prev->csum,
954 : : skb->csum);
955 : 0 : data += fraggap;
956 : : pskb_trim_unique(skb_prev, maxfraglen);
957 : : }
958 : :
959 : 32 : copy = datalen - transhdrlen - fraggap;
960 [ + + ][ + + ]: 32 : if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
961 : 2 : err = -EFAULT;
962 : 2 : kfree_skb(skb);
963 : : goto error;
964 : : }
965 : :
966 : 30 : offset += copy;
967 : 30 : length -= datalen - fraggap;
968 : : transhdrlen = 0;
969 : : exthdrlen = 0;
970 : : csummode = CHECKSUM_NONE;
971 : :
972 : : /*
973 : : * Put the packet on the pending queue.
974 : : */
975 : : __skb_queue_tail(queue, skb);
976 : 30 : continue;
977 : : }
978 : :
979 [ # # ]: 0 : if (copy > length)
980 : : copy = length;
981 : :
982 [ # # ]: 0 : if (!(rt->dst.dev->features&NETIF_F_SG)) {
983 : : unsigned int off;
984 : :
985 : : off = skb->len;
986 [ # # ]: 0 : if (getfrag(from, skb_put(skb, copy),
987 : : offset, copy, off, skb) < 0) {
988 : : __skb_trim(skb, off);
989 : 0 : err = -EFAULT;
990 : : goto error;
991 : : }
992 : : } else {
993 : 0 : int i = skb_shinfo(skb)->nr_frags;
994 : :
995 : 0 : err = -ENOMEM;
996 [ # # ]: 0 : if (!sk_page_frag_refill(sk, pfrag))
997 : : goto error;
998 : :
999 [ # # ]: 0 : if (!skb_can_coalesce(skb, i, pfrag->page,
1000 : 0 : pfrag->offset)) {
1001 : 0 : err = -EMSGSIZE;
1002 [ # # ]: 0 : if (i == MAX_SKB_FRAGS)
1003 : : goto error;
1004 : :
1005 : : __skb_fill_page_desc(skb, i, pfrag->page,
1006 : : pfrag->offset, 0);
1007 : 0 : skb_shinfo(skb)->nr_frags = ++i;
1008 : 0 : get_page(pfrag->page);
1009 : : }
1010 : 0 : copy = min_t(int, copy, pfrag->size - pfrag->offset);
1011 [ # # ]: 0 : if (getfrag(from,
1012 : 0 : page_address(pfrag->page) + pfrag->offset,
1013 : 0 : offset, copy, skb->len, skb) < 0)
1014 : : goto error_efault;
1015 : :
1016 : 0 : pfrag->offset += copy;
1017 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1018 : 0 : skb->len += copy;
1019 : 0 : skb->data_len += copy;
1020 : 0 : skb->truesize += copy;
1021 : 0 : atomic_add(copy, &sk->sk_wmem_alloc);
1022 : : }
1023 : 0 : offset += copy;
1024 : 0 : length -= copy;
1025 : : }
1026 : :
1027 : : return 0;
1028 : :
1029 : : error_efault:
1030 : 0 : err = -EFAULT;
1031 : : error:
1032 : 2 : cork->length -= length;
1033 : 4 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
1034 : 2 : return err;
1035 : : }
1036 : :
1037 : 0 : static int ip_setup_cork(struct sock *sk, struct inet_cork *cork,
1038 : : struct ipcm_cookie *ipc, struct rtable **rtp)
1039 : : {
1040 : : struct ip_options_rcu *opt;
1041 : : struct rtable *rt;
1042 : :
1043 : : /*
1044 : : * setup for corking.
1045 : : */
1046 : 32 : opt = ipc->opt;
1047 [ - + ]: 32 : if (opt) {
1048 [ # # ]: 0 : if (cork->opt == NULL) {
1049 : 0 : cork->opt = kmalloc(sizeof(struct ip_options) + 40,
1050 : : sk->sk_allocation);
1051 [ # # ]: 0 : if (unlikely(cork->opt == NULL))
1052 : : return -ENOBUFS;
1053 : : }
1054 : 0 : memcpy(cork->opt, &opt->opt, sizeof(struct ip_options) + opt->opt.optlen);
1055 : 0 : cork->flags |= IPCORK_OPT;
1056 : 0 : cork->addr = ipc->addr;
1057 : : }
1058 : 32 : rt = *rtp;
1059 [ + - ]: 32 : if (unlikely(!rt))
1060 : : return -EFAULT;
1061 : : /*
1062 : : * We steal reference to this route, caller should not release it
1063 : : */
1064 : 32 : *rtp = NULL;
1065 : 32 : cork->fragsize = ip_sk_use_pmtu(sk) ?
1066 [ + - ]: 32 : dst_mtu(&rt->dst) : rt->dst.dev->mtu;
1067 : 32 : cork->dst = &rt->dst;
1068 : 32 : cork->length = 0;
1069 : 32 : cork->ttl = ipc->ttl;
1070 : 32 : cork->tos = ipc->tos;
1071 : 32 : cork->priority = ipc->priority;
1072 : 32 : cork->tx_flags = ipc->tx_flags;
1073 : :
1074 : 32 : return 0;
1075 : : }
1076 : :
1077 : : /*
1078 : : * ip_append_data() and ip_append_page() can make one large IP datagram
1079 : : * from many pieces of data. Each pieces will be holded on the socket
1080 : : * until ip_push_pending_frames() is called. Each piece can be a page
1081 : : * or non-page data.
1082 : : *
1083 : : * Not only UDP, other transport protocols - e.g. raw sockets - can use
1084 : : * this interface potentially.
1085 : : *
1086 : : * LATER: length must be adjusted by pad at tail, when it is required.
1087 : : */
1088 : 0 : int ip_append_data(struct sock *sk, struct flowi4 *fl4,
1089 : : int getfrag(void *from, char *to, int offset, int len,
1090 : : int odd, struct sk_buff *skb),
1091 : : void *from, int length, int transhdrlen,
1092 : : struct ipcm_cookie *ipc, struct rtable **rtp,
1093 : : unsigned int flags)
1094 : : {
1095 : : struct inet_sock *inet = inet_sk(sk);
1096 : : int err;
1097 : :
1098 [ + - ]: 19 : if (flags&MSG_PROBE)
1099 : : return 0;
1100 : :
1101 [ + - ]: 19 : if (skb_queue_empty(&sk->sk_write_queue)) {
1102 : 19 : err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
1103 [ + - ]: 19 : if (err)
1104 : : return err;
1105 : : } else {
1106 : : transhdrlen = 0;
1107 : : }
1108 : :
1109 : 19 : return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base,
1110 : : sk_page_frag(sk), getfrag,
1111 : : from, length, transhdrlen, flags);
1112 : : }
1113 : :
1114 : 0 : ssize_t ip_append_page(struct sock *sk, struct flowi4 *fl4, struct page *page,
1115 : : int offset, size_t size, int flags)
1116 : : {
1117 : : struct inet_sock *inet = inet_sk(sk);
1118 : 0 : struct sk_buff *skb;
1119 : : struct rtable *rt;
1120 : : struct ip_options *opt = NULL;
1121 : : struct inet_cork *cork;
1122 : : int hh_len;
1123 : : int mtu;
1124 : : int len;
1125 : : int err;
1126 : : unsigned int maxfraglen, fragheaderlen, fraggap, maxnonfragsize;
1127 : :
1128 [ + - ]: 16 : if (inet->hdrincl)
1129 : : return -EPERM;
1130 : :
1131 [ + - ]: 16 : if (flags&MSG_PROBE)
1132 : : return 0;
1133 : :
1134 [ + - ]: 16 : if (skb_queue_empty(&sk->sk_write_queue))
1135 : : return -EINVAL;
1136 : :
1137 : : cork = &inet->cork.base;
1138 : 16 : rt = (struct rtable *)cork->dst;
1139 [ - + ]: 16 : if (cork->flags & IPCORK_OPT)
1140 : 0 : opt = cork->opt;
1141 : :
1142 [ + - ]: 16 : if (!(rt->dst.dev->features&NETIF_F_SG))
1143 : : return -EOPNOTSUPP;
1144 : :
1145 : 16 : hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1146 : 16 : mtu = cork->fragsize;
1147 : :
1148 [ - + ]: 16 : fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
1149 : 16 : maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
1150 [ - + ]: 16 : maxnonfragsize = (inet->pmtudisc >= IP_PMTUDISC_DO) ?
1151 : : mtu : 0xFFFF;
1152 : :
1153 [ - + ]: 16 : if (cork->length + size > maxnonfragsize - fragheaderlen) {
1154 : 0 : ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
1155 [ # # ]: 0 : mtu - (opt ? opt->optlen : 0));
1156 : 0 : return -EMSGSIZE;
1157 : : }
1158 : :
1159 [ + - ]: 16 : if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
1160 : : return -EINVAL;
1161 : :
1162 : 16 : cork->length += size;
1163 [ - + ][ # # ]: 16 : if ((size + skb->len > mtu) &&
1164 [ # # ]: 0 : (sk->sk_protocol == IPPROTO_UDP) &&
1165 : 0 : (rt->dst.dev->features & NETIF_F_UFO)) {
1166 : 0 : skb_shinfo(skb)->gso_size = mtu - fragheaderlen;
1167 : 16 : skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
1168 : : }
1169 : :
1170 : :
1171 [ + + ]: 32 : while (size > 0) {
1172 : : int i;
1173 : :
1174 [ - + ]: 16 : if (skb_is_gso(skb))
1175 : 0 : len = size;
1176 : : else {
1177 : :
1178 : : /* Check if the remaining data fits into current packet. */
1179 : 16 : len = mtu - skb->len;
1180 [ - + ]: 16 : if (len < size)
1181 : 0 : len = maxfraglen - skb->len;
1182 : : }
1183 [ - + ]: 16 : if (len <= 0) {
1184 : : struct sk_buff *skb_prev;
1185 : : int alloclen;
1186 : :
1187 : : skb_prev = skb;
1188 : 0 : fraggap = skb_prev->len - maxfraglen;
1189 : :
1190 : 0 : alloclen = fragheaderlen + hh_len + fraggap + 15;
1191 : 0 : skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation);
1192 [ # # ]: 0 : if (unlikely(!skb)) {
1193 : : err = -ENOBUFS;
1194 : : goto error;
1195 : : }
1196 : :
1197 : : /*
1198 : : * Fill in the control structures
1199 : : */
1200 : 0 : skb->ip_summed = CHECKSUM_NONE;
1201 : 0 : skb->csum = 0;
1202 : : skb_reserve(skb, hh_len);
1203 : :
1204 : : /*
1205 : : * Find where to start putting bytes.
1206 : : */
1207 : 0 : skb_put(skb, fragheaderlen + fraggap);
1208 : : skb_reset_network_header(skb);
1209 : 0 : skb->transport_header = (skb->network_header +
1210 : : fragheaderlen);
1211 [ # # ]: 0 : if (fraggap) {
1212 : 0 : skb->csum = skb_copy_and_csum_bits(skb_prev,
1213 : : maxfraglen,
1214 : : skb_transport_header(skb),
1215 : : fraggap, 0);
1216 : 0 : skb_prev->csum = csum_sub(skb_prev->csum,
1217 : : skb->csum);
1218 : : pskb_trim_unique(skb_prev, maxfraglen);
1219 : : }
1220 : :
1221 : : /*
1222 : : * Put the packet on the pending queue.
1223 : : */
1224 : : __skb_queue_tail(&sk->sk_write_queue, skb);
1225 : 0 : continue;
1226 : : }
1227 : :
1228 : 16 : i = skb_shinfo(skb)->nr_frags;
1229 [ + - ]: 16 : if (len > size)
1230 : 16 : len = size;
1231 [ - + ]: 16 : if (skb_can_coalesce(skb, i, page, offset)) {
1232 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i-1], len);
1233 [ + - ]: 16 : } else if (i < MAX_SKB_FRAGS) {
1234 : : get_page(page);
1235 : : skb_fill_page_desc(skb, i, page, offset, len);
1236 : : } else {
1237 : : err = -EMSGSIZE;
1238 : : goto error;
1239 : : }
1240 : :
1241 [ - + ]: 16 : if (skb->ip_summed == CHECKSUM_NONE) {
1242 : : __wsum csum;
1243 : : csum = csum_page(page, offset, len);
1244 : 0 : skb->csum = csum_block_add(skb->csum, csum, skb->len);
1245 : : }
1246 : :
1247 : 16 : skb->len += len;
1248 : 16 : skb->data_len += len;
1249 : 16 : skb->truesize += len;
1250 : 16 : atomic_add(len, &sk->sk_wmem_alloc);
1251 : 16 : offset += len;
1252 : 16 : size -= len;
1253 : : }
1254 : : return 0;
1255 : :
1256 : : error:
1257 : 0 : cork->length -= size;
1258 : 0 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
1259 : 0 : return err;
1260 : : }
1261 : :
1262 : 0 : static void ip_cork_release(struct inet_cork *cork)
1263 : : {
1264 : 32 : cork->flags &= ~IPCORK_OPT;
1265 : 32 : kfree(cork->opt);
1266 : 32 : cork->opt = NULL;
1267 : 32 : dst_release(cork->dst);
1268 : 32 : cork->dst = NULL;
1269 : 32 : }
1270 : :
1271 : : /*
1272 : : * Combined all pending IP fragments on the socket as one IP datagram
1273 : : * and push them out.
1274 : : */
1275 : 0 : struct sk_buff *__ip_make_skb(struct sock *sk,
1276 : : struct flowi4 *fl4,
1277 : : struct sk_buff_head *queue,
1278 : : struct inet_cork *cork)
1279 : : {
1280 : 120 : struct sk_buff *skb, *tmp_skb;
1281 : : struct sk_buff **tail_skb;
1282 : : struct inet_sock *inet = inet_sk(sk);
1283 : : struct net *net = sock_net(sk);
1284 : : struct ip_options *opt = NULL;
1285 : 30 : struct rtable *rt = (struct rtable *)cork->dst;
1286 : : struct iphdr *iph;
1287 : : __be16 df = 0;
1288 : : __u8 ttl;
1289 : :
1290 [ + ]: 30 : if ((skb = __skb_dequeue(queue)) == NULL)
1291 : : goto out;
1292 : 60 : tail_skb = &(skb_shinfo(skb)->frag_list);
1293 : :
1294 : : /* move skb->data to ip header from ext header */
1295 [ - + ]: 60 : if (skb->data < skb_network_header(skb))
1296 : 0 : __skb_pull(skb, skb_network_offset(skb));
1297 [ - + ]: 30 : while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
1298 : : __skb_pull(tmp_skb, skb_network_header_len(skb));
1299 : 0 : *tail_skb = tmp_skb;
1300 : 0 : tail_skb = &(tmp_skb->next);
1301 : 0 : skb->len += tmp_skb->len;
1302 : 0 : skb->data_len += tmp_skb->len;
1303 : 0 : skb->truesize += tmp_skb->truesize;
1304 : 0 : tmp_skb->destructor = NULL;
1305 : 0 : tmp_skb->sk = NULL;
1306 : : }
1307 : :
1308 : : /* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow
1309 : : * to fragment the frame generated here. No matter, what transforms
1310 : : * how transforms change size of the packet, it will come out.
1311 : : */
1312 [ + - ]: 30 : if (inet->pmtudisc < IP_PMTUDISC_DO)
1313 : 30 : skb->local_df = 1;
1314 : :
1315 : : /* DF bit is set when we want to see DF on outgoing frames.
1316 : : * If local_df is set too, we still allow to fragment this frame
1317 : : * locally. */
1318 [ + - ]: 30 : if (inet->pmtudisc == IP_PMTUDISC_DO ||
1319 [ + - ]: 30 : inet->pmtudisc == IP_PMTUDISC_PROBE ||
1320 [ + - ]: 30 : (skb->len <= dst_mtu(&rt->dst) &&
1321 : : ip_dont_fragment(sk, &rt->dst)))
1322 : : df = htons(IP_DF);
1323 : :
1324 [ - + ]: 30 : if (cork->flags & IPCORK_OPT)
1325 : 0 : opt = cork->opt;
1326 : :
1327 [ + - ]: 30 : if (cork->ttl != 0)
1328 : : ttl = cork->ttl;
1329 [ - + ]: 30 : else if (rt->rt_type == RTN_MULTICAST)
1330 : 0 : ttl = inet->mc_ttl;
1331 : : else
1332 : 30 : ttl = ip_select_ttl(inet, &rt->dst);
1333 : :
1334 : : iph = ip_hdr(skb);
1335 : 30 : iph->version = 4;
1336 : 30 : iph->ihl = 5;
1337 [ - + ]: 30 : iph->tos = (cork->tos != -1) ? cork->tos : inet->tos;
1338 : 30 : iph->frag_off = df;
1339 : 30 : iph->ttl = ttl;
1340 : 30 : iph->protocol = sk->sk_protocol;
1341 : : ip_copy_addrs(iph, fl4);
1342 : 30 : ip_select_ident(skb, &rt->dst, sk);
1343 : :
1344 [ - + ]: 30 : if (opt) {
1345 : 0 : iph->ihl += opt->optlen>>2;
1346 : 0 : ip_options_build(skb, opt, cork->addr, rt, 0);
1347 : : }
1348 : :
1349 [ - + ]: 30 : skb->priority = (cork->tos != -1) ? cork->priority: sk->sk_priority;
1350 : 30 : skb->mark = sk->sk_mark;
1351 : : /*
1352 : : * Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec
1353 : : * on dst refcount
1354 : : */
1355 : 30 : cork->dst = NULL;
1356 : : skb_dst_set(skb, &rt->dst);
1357 : :
1358 [ - + ]: 30 : if (iph->protocol == IPPROTO_ICMP)
1359 : 0 : icmp_out_count(net, ((struct icmphdr *)
1360 : : skb_transport_header(skb))->type);
1361 : :
1362 : 30 : ip_cork_release(cork);
1363 : : out:
1364 : 0 : return skb;
1365 : : }
1366 : :
1367 : 0 : int ip_send_skb(struct net *net, struct sk_buff *skb)
1368 : : {
1369 : : int err;
1370 : :
1371 : 30 : err = ip_local_out(skb);
1372 [ - + ]: 30 : if (err) {
1373 [ # # ]: 0 : if (err > 0)
1374 [ # # ]: 0 : err = net_xmit_errno(err);
1375 [ - ]: 0 : if (err)
1376 : 0 : IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
1377 : : }
1378 : :
1379 : 0 : return err;
1380 : : }
1381 : :
1382 : 0 : int ip_push_pending_frames(struct sock *sk, struct flowi4 *fl4)
1383 : : {
1384 : : struct sk_buff *skb;
1385 : :
1386 : : skb = ip_finish_skb(sk, fl4);
1387 [ + - ]: 3 : if (!skb)
1388 : : return 0;
1389 : :
1390 : : /* Netfilter gets whole the not fragmented skb. */
1391 : 3 : return ip_send_skb(sock_net(sk), skb);
1392 : : }
1393 : :
1394 : : /*
1395 : : * Throw away all pending data on the socket.
1396 : : */
1397 : 2 : static void __ip_flush_pending_frames(struct sock *sk,
1398 : : struct sk_buff_head *queue,
1399 : : struct inet_cork *cork)
1400 : : {
1401 : : struct sk_buff *skb;
1402 : :
1403 [ - + ]: 2 : while ((skb = __skb_dequeue_tail(queue)) != NULL)
1404 : 0 : kfree_skb(skb);
1405 : :
1406 : 2 : ip_cork_release(cork);
1407 : 2 : }
1408 : :
1409 : 0 : void ip_flush_pending_frames(struct sock *sk)
1410 : : {
1411 : 0 : __ip_flush_pending_frames(sk, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
1412 : 0 : }
1413 : :
1414 : 0 : struct sk_buff *ip_make_skb(struct sock *sk,
1415 : : struct flowi4 *fl4,
1416 : : int getfrag(void *from, char *to, int offset,
1417 : : int len, int odd, struct sk_buff *skb),
1418 : : void *from, int length, int transhdrlen,
1419 : : struct ipcm_cookie *ipc, struct rtable **rtp,
1420 : : unsigned int flags)
1421 : : {
1422 : : struct inet_cork cork;
1423 : : struct sk_buff_head queue;
1424 : : int err;
1425 : :
1426 [ + - ]: 13 : if (flags & MSG_PROBE)
1427 : : return NULL;
1428 : :
1429 : : __skb_queue_head_init(&queue);
1430 : :
1431 : 13 : cork.flags = 0;
1432 : 13 : cork.addr = 0;
1433 : 13 : cork.opt = NULL;
1434 : 13 : err = ip_setup_cork(sk, &cork, ipc, rtp);
1435 [ - + ]: 26 : if (err)
1436 : 0 : return ERR_PTR(err);
1437 : :
1438 : 13 : err = __ip_append_data(sk, fl4, &queue, &cork,
1439 : 13 : ¤t->task_frag, getfrag,
1440 : : from, length, transhdrlen, flags);
1441 [ + + ]: 13 : if (err) {
1442 : 2 : __ip_flush_pending_frames(sk, &queue, &cork);
1443 : 2 : return ERR_PTR(err);
1444 : : }
1445 : :
1446 : 11 : return __ip_make_skb(sk, fl4, &queue, &cork);
1447 : : }
1448 : :
1449 : : /*
1450 : : * Fetch data from kernel space and fill in checksum if needed.
1451 : : */
1452 : 0 : static int ip_reply_glue_bits(void *dptr, char *to, int offset,
1453 : : int len, int odd, struct sk_buff *skb)
1454 : : {
1455 : : __wsum csum;
1456 : :
1457 : 3 : csum = csum_partial_copy_nocheck(dptr+offset, to, len, 0);
1458 : 3 : skb->csum = csum_block_add(skb->csum, csum, odd);
1459 : 0 : return 0;
1460 : : }
1461 : :
1462 : : /*
1463 : : * Generic function to send a packet as reply to another packet.
1464 : : * Used to send some TCP resets/acks so far.
1465 : : *
1466 : : * Use a fake percpu inet socket to avoid false sharing and contention.
1467 : : */
1468 : : static DEFINE_PER_CPU(struct inet_sock, unicast_sock) = {
1469 : : .sk = {
1470 : : .__sk_common = {
1471 : : .skc_refcnt = ATOMIC_INIT(1),
1472 : : },
1473 : : .sk_wmem_alloc = ATOMIC_INIT(1),
1474 : : .sk_allocation = GFP_ATOMIC,
1475 : : .sk_flags = (1UL << SOCK_USE_WRITE_QUEUE),
1476 : : },
1477 : : .pmtudisc = IP_PMTUDISC_WANT,
1478 : : .uc_ttl = -1,
1479 : : };
1480 : :
1481 : 0 : void ip_send_unicast_reply(struct net *net, struct sk_buff *skb, __be32 daddr,
1482 : 3 : __be32 saddr, const struct ip_reply_arg *arg,
1483 : : unsigned int len)
1484 : : {
1485 : : struct ip_options_data replyopts;
1486 : : struct ipcm_cookie ipc;
1487 : : struct flowi4 fl4;
1488 : 3 : struct rtable *rt = skb_rtable(skb);
1489 : 3 : struct sk_buff *nskb;
1490 : : struct sock *sk;
1491 : : struct inet_sock *inet;
1492 : :
1493 [ + - ]: 3 : if (ip_options_echo(&replyopts.opt.opt, skb))
1494 : 0 : return;
1495 : :
1496 : 3 : ipc.addr = daddr;
1497 : 3 : ipc.opt = NULL;
1498 : 3 : ipc.tx_flags = 0;
1499 : 3 : ipc.ttl = 0;
1500 : 3 : ipc.tos = -1;
1501 : :
1502 [ - + ]: 3 : if (replyopts.opt.opt.optlen) {
1503 : 0 : ipc.opt = &replyopts.opt;
1504 : :
1505 [ # # ]: 0 : if (replyopts.opt.opt.srr)
1506 : 0 : daddr = replyopts.opt.opt.faddr;
1507 : : }
1508 : :
1509 : 12 : flowi4_init_output(&fl4, arg->bound_dev_if, 0,
1510 : 3 : RT_TOS(arg->tos),
1511 : : RT_SCOPE_UNIVERSE, ip_hdr(skb)->protocol,
1512 : : ip_reply_arg_flowi_flags(arg),
1513 : : daddr, saddr,
1514 : : tcp_hdr(skb)->source, tcp_hdr(skb)->dest);
1515 : : security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
1516 : 3 : rt = ip_route_output_key(net, &fl4);
1517 [ + - ]: 3 : if (IS_ERR(rt))
1518 : : return;
1519 : :
1520 : 3 : inet = &get_cpu_var(unicast_sock);
1521 : :
1522 : 3 : inet->tos = arg->tos;
1523 : 3 : sk = &inet->sk;
1524 : 3 : sk->sk_priority = skb->priority;
1525 : 3 : sk->sk_protocol = ip_hdr(skb)->protocol;
1526 : 3 : sk->sk_bound_dev_if = arg->bound_dev_if;
1527 : : sock_net_set(sk, net);
1528 : 3 : __skb_queue_head_init(&sk->sk_write_queue);
1529 : 3 : sk->sk_sndbuf = sysctl_wmem_default;
1530 : 3 : ip_append_data(sk, &fl4, ip_reply_glue_bits, arg->iov->iov_base, len, 0,
1531 : : &ipc, &rt, MSG_DONTWAIT);
1532 : : nskb = skb_peek(&sk->sk_write_queue);
1533 [ + - ]: 3 : if (nskb) {
1534 [ + - ]: 3 : if (arg->csumoffset >= 0)
1535 : 3 : *((__sum16 *)skb_transport_header(nskb) +
1536 : 3 : arg->csumoffset) = csum_fold(csum_add(nskb->csum,
1537 : : arg->csum));
1538 : 3 : nskb->ip_summed = CHECKSUM_NONE;
1539 : : skb_orphan(nskb);
1540 : : skb_set_queue_mapping(nskb, skb_get_queue_mapping(skb));
1541 : 3 : ip_push_pending_frames(sk, &fl4);
1542 : : }
1543 : :
1544 : 3 : put_cpu_var(unicast_sock);
1545 : :
1546 : 3 : ip_rt_put(rt);
1547 : : }
1548 : :
1549 : 0 : void __init ip_init(void)
1550 : : {
1551 : 0 : ip_rt_init();
1552 : 0 : inet_initpeers();
1553 : :
1554 : : #if defined(CONFIG_IP_MULTICAST) && defined(CONFIG_PROC_FS)
1555 : 0 : igmp_mc_proc_init();
1556 : : #endif
1557 : 0 : }
|
