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 : 23680 : iph->check = 0;
90 : 47360 : iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
91 : 23680 : }
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 [ - + ]: 23680 : iph->tot_len = htons(skb->len);
99 : 23680 : ip_send_check(iph);
100 : 23680 : 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 : 23680 : err = __ip_local_out(skb);
109 [ + - ]: 23680 : if (likely(err == 1))
110 : : err = dst_output(skb);
111 : :
112 : 0 : 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 : 23680 : int ttl = inet->uc_ttl;
119 : :
120 [ + - ][ + - ]: 23680 : 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 [ - + ]: 26 : skb_push(skb, sizeof(struct iphdr) + (opt ? opt->opt.optlen : 0));
138 : : skb_reset_network_header(skb);
139 : : iph = ip_hdr(skb);
140 : 26 : iph->version = 4;
141 : 26 : iph->ihl = 5;
142 : 26 : iph->tos = inet->tos;
143 [ + - ]: 26 : if (ip_dont_fragment(sk, &rt->dst))
144 : 26 : iph->frag_off = htons(IP_DF);
145 : : else
146 : 0 : iph->frag_off = 0;
147 : 26 : iph->ttl = ip_select_ttl(inet, &rt->dst);
148 [ - + ][ # # ]: 26 : iph->daddr = (opt && opt->opt.srr ? opt->opt.faddr : daddr);
149 : 26 : iph->saddr = saddr;
150 : 26 : iph->protocol = sk->sk_protocol;
151 : 26 : ip_select_ident(skb, &rt->dst, sk);
152 : :
153 [ - + ][ # # ]: 26 : 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 : 26 : skb->priority = sk->sk_priority;
159 : 26 : skb->mark = sk->sk_mark;
160 : :
161 : : /* Send it out. */
162 : 26 : 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 : 23680 : struct rtable *rt = (struct rtable *)dst;
170 : 23680 : struct net_device *dev = dst->dev;
171 : 23680 : unsigned int hh_len = LL_RESERVED_SPACE(dev);
172 : : struct neighbour *neigh;
173 : : u32 nexthop;
174 : :
175 [ - + ][ # # ]: 23680 : if (rt->rt_type == RTN_MULTICAST) {
176 : 0 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUTMCAST, skb->len);
177 [ - + ][ # # ]: 23680 : } 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 [ - + ][ # # ]: 23680 : 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 : 23680 : consume_skb(skb);
192 : : skb = skb2;
193 : : }
194 : :
195 : : rcu_read_lock_bh();
196 : 47360 : nexthop = (__force u32) rt_nexthop(rt, ip_hdr(skb)->daddr);
197 : : neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
198 [ + + ][ # # ]: 23680 : if (unlikely(!neigh))
199 : 1 : neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
200 [ + - ][ # # ]: 23680 : 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 [ - + ]: 23680 : if (skb_dst(skb)->xfrm != NULL) {
219 : 0 : IPCB(skb)->flags |= IPSKB_REROUTED;
220 : 0 : return dst_output(skb);
221 : : }
222 : : #endif
223 [ - + ][ # # ]: 23680 : if (skb->len > ip_skb_dst_mtu(skb) && !skb_is_gso(skb))
224 : 0 : return ip_fragment(skb, ip_finish_output2);
225 : : else
226 : 23680 : 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 : 23680 : struct net_device *dev = skb_dst(skb)->dev;
293 : :
294 : 71040 : IP_UPD_PO_STATS(dev_net(dev), IPSTATS_MIB_OUT, skb->len);
295 : :
296 : 23680 : skb->dev = dev;
297 : 23680 : skb->protocol = htons(ETH_P_IP);
298 : :
299 : 23680 : return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING, skb, NULL, dev,
300 : : ip_finish_output,
301 : 23680 : !(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 : 23654 : 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 : 23629 : 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 : 23629 : inet_opt = rcu_dereference(inet->inet_opt);
333 : 23629 : fl4 = &fl->u.ip4;
334 : : rt = skb_rtable(skb);
335 [ + - ]: 23629 : if (rt != NULL)
336 : : goto packet_routed;
337 : :
338 : : /* Make sure we can route this packet. */
339 : 23629 : rt = (struct rtable *)__sk_dst_check(sk, 0);
340 [ - + ]: 23629 : if (rt == NULL) {
341 : : __be32 daddr;
342 : :
343 : : /* Use correct destination address if we have options. */
344 : 0 : daddr = inet->inet_daddr;
345 [ # # ][ # # ]: 0 : 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 : 0 : 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 : 0 : RT_CONN_FLAGS(sk),
358 : : sk->sk_bound_dev_if);
359 [ # # ]: 0 : if (IS_ERR(rt))
360 : : goto no_route;
361 : 0 : sk_setup_caps(sk, &rt->dst);
362 : : }
363 : 23629 : skb_dst_set_noref(skb, &rt->dst);
364 : :
365 : : packet_routed:
366 [ - + ][ # # ]: 23629 : 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 [ - + ]: 23629 : 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 [ - + ]: 47258 : *((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
374 [ + + ][ + ]: 23629 : if (ip_dont_fragment(sk, &rt->dst) && !skb->local_df)
375 : 23629 : iph->frag_off = htons(IP_DF);
376 : : else
377 : 0 : iph->frag_off = 0;
378 : 23629 : iph->ttl = ip_select_ttl(inet, &rt->dst);
379 : 23629 : iph->protocol = sk->sk_protocol;
380 : : ip_copy_addrs(iph, fl4);
381 : :
382 : : /* Transport layer set skb->h.foo itself. */
383 : :
384 [ - + ][ # # ]: 23629 : 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 [ + - ]: 23629 : ip_select_ident_more(skb, &rt->dst, sk,
390 : 23629 : (skb_shinfo(skb)->gso_segs ?: 1) - 1);
391 : :
392 : 23629 : skb->priority = sk->sk_priority;
393 : 23629 : skb->mark = sk->sk_mark;
394 : :
395 : 23629 : res = ip_local_out(skb);
396 : : rcu_read_unlock();
397 : 23629 : 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 defined(CONFIG_IP_VS) || defined(CONFIG_IP_VS_MODULE)
426 : : to->ipvs_property = from->ipvs_property;
427 : : #endif
428 : : skb_copy_secmark(to, from);
429 : 0 : }
430 : :
431 : : /*
432 : : * This IP datagram is too large to be sent in one piece. Break it up into
433 : : * smaller pieces (each of size equal to IP header plus
434 : : * a block of the data of the original IP data part) that will yet fit in a
435 : : * single device frame, and queue such a frame for sending.
436 : : */
437 : :
438 : 0 : int ip_fragment(struct sk_buff *skb, int (*output)(struct sk_buff *))
439 : : {
440 : 0 : struct iphdr *iph;
441 : : int ptr;
442 : : struct net_device *dev;
443 : 0 : struct sk_buff *skb2;
444 : : unsigned int mtu, hlen, left, len, ll_rs;
445 : : int offset;
446 : : __be16 not_last_frag;
447 : : struct rtable *rt = skb_rtable(skb);
448 : : int err = 0;
449 : 0 : bool forwarding = IPCB(skb)->flags & IPSKB_FORWARDED;
450 : :
451 : : dev = rt->dst.dev;
452 : :
453 : : /*
454 : : * Point into the IP datagram header.
455 : : */
456 : :
457 : : iph = ip_hdr(skb);
458 : :
459 : 0 : mtu = ip_dst_mtu_maybe_forward(&rt->dst, forwarding);
460 [ # # ][ # # ]: 0 : if (unlikely(((iph->frag_off & htons(IP_DF)) && !skb->local_df) ||
[ # # ][ # # ]
[ # # ][ # # ]
461 : : (IPCB(skb)->frag_max_size &&
462 : : IPCB(skb)->frag_max_size > mtu))) {
463 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
464 [ # # ]: 0 : icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
465 : 0 : htonl(mtu));
466 : 0 : kfree_skb(skb);
467 : 0 : return -EMSGSIZE;
468 : : }
469 : :
470 : : /*
471 : : * Setup starting values.
472 : : */
473 : :
474 : 0 : hlen = iph->ihl * 4;
475 : 0 : mtu = mtu - hlen; /* Size of data space */
476 : : #ifdef CONFIG_BRIDGE_NETFILTER
477 [ # # ]: 0 : if (skb->nf_bridge)
478 : 0 : mtu -= nf_bridge_mtu_reduction(skb);
479 : : #endif
480 : 0 : IPCB(skb)->flags |= IPSKB_FRAG_COMPLETE;
481 : :
482 : : /* When frag_list is given, use it. First, check its validity:
483 : : * some transformers could create wrong frag_list or break existing
484 : : * one, it is not prohibited. In this case fall back to copying.
485 : : *
486 : : * LATER: this step can be merged to real generation of fragments,
487 : : * we can switch to copy when see the first bad fragment.
488 : : */
489 [ # # ]: 0 : if (skb_has_frag_list(skb)) {
490 : 0 : struct sk_buff *frag, *frag2;
491 : : int first_len = skb_pagelen(skb);
492 : :
493 [ # # ][ # # ]: 0 : if (first_len - hlen > mtu ||
494 [ # # ]: 0 : ((first_len - hlen) & 7) ||
495 [ # # ]: 0 : ip_is_fragment(iph) ||
496 : : skb_cloned(skb))
497 : : goto slow_path;
498 : :
499 [ # # ]: 0 : skb_walk_frags(skb, frag) {
500 : : /* Correct geometry. */
501 [ # # ][ # # ]: 0 : if (frag->len > mtu ||
502 [ # # ][ # # ]: 0 : ((frag->len & 7) && frag->next) ||
503 : : skb_headroom(frag) < hlen)
504 : : goto slow_path_clean;
505 : :
506 : : /* Partially cloned skb? */
507 [ # # ]: 0 : if (skb_shared(frag))
508 : : goto slow_path_clean;
509 : :
510 [ # # ]: 0 : BUG_ON(frag->sk);
511 [ # # ]: 0 : if (skb->sk) {
512 : 0 : frag->sk = skb->sk;
513 : 0 : frag->destructor = sock_wfree;
514 : : }
515 : 0 : skb->truesize -= frag->truesize;
516 : : }
517 : :
518 : : /* Everything is OK. Generate! */
519 : :
520 : : err = 0;
521 : : offset = 0;
522 : 0 : frag = skb_shinfo(skb)->frag_list;
523 : : skb_frag_list_init(skb);
524 : 0 : skb->data_len = first_len - skb_headlen(skb);
525 : 0 : skb->len = first_len;
526 [ # # ]: 0 : iph->tot_len = htons(first_len);
527 : 0 : iph->frag_off = htons(IP_MF);
528 : 0 : ip_send_check(iph);
529 : :
530 : : for (;;) {
531 : : /* Prepare header of the next frame,
532 : : * before previous one went down. */
533 [ # # ]: 0 : if (frag) {
534 : 0 : frag->ip_summed = CHECKSUM_NONE;
535 : : skb_reset_transport_header(frag);
536 : : __skb_push(frag, hlen);
537 : : skb_reset_network_header(frag);
538 : 0 : memcpy(skb_network_header(frag), iph, hlen);
539 : : iph = ip_hdr(frag);
540 [ # # ]: 0 : iph->tot_len = htons(frag->len);
541 : 0 : ip_copy_metadata(frag, skb);
542 [ # # ]: 0 : if (offset == 0)
543 : 0 : ip_options_fragment(frag);
544 : 0 : offset += skb->len - hlen;
545 [ # # ]: 0 : iph->frag_off = htons(offset>>3);
546 [ # # ]: 0 : if (frag->next != NULL)
547 : 0 : iph->frag_off |= htons(IP_MF);
548 : : /* Ready, complete checksum */
549 : 0 : ip_send_check(iph);
550 : : }
551 : :
552 : 0 : err = output(skb);
553 : :
554 [ # # ]: 0 : if (!err)
555 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
556 [ # # ]: 0 : if (err || !frag)
557 : : break;
558 : :
559 : : skb = frag;
560 : 0 : frag = skb->next;
561 : 0 : skb->next = NULL;
562 : 0 : }
563 : :
564 [ # # ]: 0 : if (err == 0) {
565 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
566 : 0 : return 0;
567 : : }
568 : :
569 [ # # ]: 0 : while (frag) {
570 : 0 : skb = frag->next;
571 : 0 : kfree_skb(frag);
572 : : frag = skb;
573 : : }
574 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
575 : 0 : return err;
576 : :
577 : : slow_path_clean:
578 [ # # ]: 0 : skb_walk_frags(skb, frag2) {
579 [ # # ]: 0 : if (frag2 == frag)
580 : : break;
581 : 0 : frag2->sk = NULL;
582 : 0 : frag2->destructor = NULL;
583 : 0 : skb->truesize += frag2->truesize;
584 : : }
585 : : }
586 : :
587 : : slow_path:
588 : : /* for offloaded checksums cleanup checksum before fragmentation */
589 [ # # ][ # # ]: 0 : if ((skb->ip_summed == CHECKSUM_PARTIAL) && skb_checksum_help(skb))
590 : : goto fail;
591 : : iph = ip_hdr(skb);
592 : :
593 : 0 : left = skb->len - hlen; /* Space per frame */
594 : : ptr = hlen; /* Where to start from */
595 : :
596 : : /* for bridged IP traffic encapsulated inside f.e. a vlan header,
597 : : * we need to make room for the encapsulating header
598 : : */
599 : 0 : ll_rs = LL_RESERVED_SPACE_EXTRA(rt->dst.dev, nf_bridge_pad(skb));
600 : :
601 : : /*
602 : : * Fragment the datagram.
603 : : */
604 : :
605 [ # # ]: 0 : offset = (ntohs(iph->frag_off) & IP_OFFSET) << 3;
606 : 0 : not_last_frag = iph->frag_off & htons(IP_MF);
607 : :
608 : : /*
609 : : * Keep copying data until we run out.
610 : : */
611 : :
612 [ # # ]: 0 : while (left > 0) {
613 : : len = left;
614 : : /* IF: it doesn't fit, use 'mtu' - the data space left */
615 [ # # ]: 0 : if (len > mtu)
616 : : len = mtu;
617 : : /* IF: we are not sending up to and including the packet end
618 : : then align the next start on an eight byte boundary */
619 [ # # ]: 0 : if (len < left) {
620 : 0 : len &= ~7;
621 : : }
622 : : /*
623 : : * Allocate buffer.
624 : : */
625 : :
626 [ # # ]: 0 : if ((skb2 = alloc_skb(len+hlen+ll_rs, GFP_ATOMIC)) == NULL) {
627 [ # # ]: 0 : NETDEBUG(KERN_INFO "IP: frag: no memory for new fragment!\n");
628 : : err = -ENOMEM;
629 : : goto fail;
630 : : }
631 : :
632 : : /*
633 : : * Set up data on packet
634 : : */
635 : :
636 : 0 : ip_copy_metadata(skb2, skb);
637 : : skb_reserve(skb2, ll_rs);
638 : 0 : skb_put(skb2, len + hlen);
639 : : skb_reset_network_header(skb2);
640 : 0 : skb2->transport_header = skb2->network_header + hlen;
641 : :
642 : : /*
643 : : * Charge the memory for the fragment to any owner
644 : : * it might possess
645 : : */
646 : :
647 [ # # ]: 0 : if (skb->sk)
648 : : skb_set_owner_w(skb2, skb->sk);
649 : :
650 : : /*
651 : : * Copy the packet header into the new buffer.
652 : : */
653 : :
654 : : skb_copy_from_linear_data(skb, skb_network_header(skb2), hlen);
655 : :
656 : : /*
657 : : * Copy a block of the IP datagram.
658 : : */
659 [ # # ]: 0 : if (skb_copy_bits(skb, ptr, skb_transport_header(skb2), len))
660 : 0 : BUG();
661 : 0 : left -= len;
662 : :
663 : : /*
664 : : * Fill in the new header fields.
665 : : */
666 : : iph = ip_hdr(skb2);
667 [ # # ]: 0 : iph->frag_off = htons((offset >> 3));
668 : :
669 : : /* ANK: dirty, but effective trick. Upgrade options only if
670 : : * the segment to be fragmented was THE FIRST (otherwise,
671 : : * options are already fixed) and make it ONCE
672 : : * on the initial skb, so that all the following fragments
673 : : * will inherit fixed options.
674 : : */
675 [ # # ]: 0 : if (offset == 0)
676 : 0 : ip_options_fragment(skb);
677 : :
678 : : /*
679 : : * Added AC : If we are fragmenting a fragment that's not the
680 : : * last fragment then keep MF on each bit
681 : : */
682 [ # # ]: 0 : if (left > 0 || not_last_frag)
683 : 0 : iph->frag_off |= htons(IP_MF);
684 : 0 : ptr += len;
685 : 0 : offset += len;
686 : :
687 : : /*
688 : : * Put this fragment into the sending queue.
689 : : */
690 [ # # ]: 0 : iph->tot_len = htons(len + hlen);
691 : :
692 : 0 : ip_send_check(iph);
693 : :
694 : 0 : err = output(skb2);
695 [ # # ]: 0 : if (err)
696 : : goto fail;
697 : :
698 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGCREATES);
699 : : }
700 : 0 : consume_skb(skb);
701 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGOKS);
702 : 0 : return err;
703 : :
704 : : fail:
705 : 0 : kfree_skb(skb);
706 : 0 : IP_INC_STATS(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
707 : 0 : return err;
708 : : }
709 : : EXPORT_SYMBOL(ip_fragment);
710 : :
711 : : int
712 : 0 : ip_generic_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
713 : : {
714 : : struct iovec *iov = from;
715 : :
716 [ + + ]: 10 : if (skb->ip_summed == CHECKSUM_PARTIAL) {
717 [ - + ]: 2 : if (memcpy_fromiovecend(to, iov, offset, len) < 0)
718 : : return -EFAULT;
719 : : } else {
720 : 8 : __wsum csum = 0;
721 [ - + ]: 8 : if (csum_partial_copy_fromiovecend(to, iov, offset, len, &csum) < 0)
722 : 0 : return -EFAULT;
723 : 8 : skb->csum = csum_block_add(skb->csum, csum, odd);
724 : : }
725 : : return 0;
726 : : }
727 : : EXPORT_SYMBOL(ip_generic_getfrag);
728 : :
729 : : static inline __wsum
730 : : csum_page(struct page *page, int offset, int copy)
731 : : {
732 : : char *kaddr;
733 : : __wsum csum;
734 : 0 : kaddr = kmap(page);
735 : 0 : csum = csum_partial(kaddr + offset, copy, 0);
736 : 0 : kunmap(page);
737 : : return csum;
738 : : }
739 : :
740 : : static inline int ip_ufo_append_data(struct sock *sk,
741 : : struct sk_buff_head *queue,
742 : : int getfrag(void *from, char *to, int offset, int len,
743 : : int odd, struct sk_buff *skb),
744 : : void *from, int length, int hh_len, int fragheaderlen,
745 : : int transhdrlen, int maxfraglen, unsigned int flags)
746 : : {
747 : 0 : struct sk_buff *skb;
748 : : int err;
749 : :
750 : : /* There is support for UDP fragmentation offload by network
751 : : * device, so create one single skb packet containing complete
752 : : * udp datagram
753 : : */
754 [ # # ]: 0 : if ((skb = skb_peek_tail(queue)) == NULL) {
755 : 0 : skb = sock_alloc_send_skb(sk,
756 : 0 : hh_len + fragheaderlen + transhdrlen + 20,
757 : : (flags & MSG_DONTWAIT), &err);
758 : :
759 [ # # ]: 0 : if (skb == NULL)
760 : 0 : return err;
761 : :
762 : : /* reserve space for Hardware header */
763 : : skb_reserve(skb, hh_len);
764 : :
765 : : /* create space for UDP/IP header */
766 : 0 : skb_put(skb, fragheaderlen + transhdrlen);
767 : :
768 : : /* initialize network header pointer */
769 : : skb_reset_network_header(skb);
770 : :
771 : : /* initialize protocol header pointer */
772 : 0 : skb->transport_header = skb->network_header + fragheaderlen;
773 : :
774 : 0 : skb->csum = 0;
775 : :
776 : :
777 : : __skb_queue_tail(queue, skb);
778 [ # # ]: 0 : } else if (skb_is_gso(skb)) {
779 : : goto append;
780 : : }
781 : :
782 : 0 : skb->ip_summed = CHECKSUM_PARTIAL;
783 : : /* specify the length of each IP datagram fragment */
784 : 0 : skb_shinfo(skb)->gso_size = maxfraglen - fragheaderlen;
785 : 0 : skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
786 : :
787 : : append:
788 : 0 : return skb_append_datato_frags(sk, skb, getfrag, from,
789 : : (length - transhdrlen));
790 : : }
791 : :
792 : 0 : static int __ip_append_data(struct sock *sk,
793 : : struct flowi4 *fl4,
794 : : struct sk_buff_head *queue,
795 : : struct inet_cork *cork,
796 : : struct page_frag *pfrag,
797 : : int getfrag(void *from, char *to, int offset,
798 : : int len, int odd, struct sk_buff *skb),
799 : : void *from, int length, int transhdrlen,
800 : : unsigned int flags)
801 : : {
802 : : struct inet_sock *inet = inet_sk(sk);
803 : 27 : struct sk_buff *skb;
804 : :
805 : 27 : struct ip_options *opt = cork->opt;
806 : : int hh_len;
807 : : int exthdrlen;
808 : : int mtu;
809 : : int copy;
810 : : int err;
811 : : int offset = 0;
812 : : unsigned int maxfraglen, fragheaderlen, maxnonfragsize;
813 : : int csummode = CHECKSUM_NONE;
814 : 27 : struct rtable *rt = (struct rtable *)cork->dst;
815 : :
816 : : skb = skb_peek_tail(queue);
817 : :
818 [ + - ]: 27 : exthdrlen = !skb ? rt->dst.header_len : 0;
819 : 27 : mtu = cork->fragsize;
820 : :
821 : 27 : hh_len = LL_RESERVED_SPACE(rt->dst.dev);
822 : :
823 [ - + ]: 27 : fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
824 : 27 : maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
825 [ - + ]: 27 : maxnonfragsize = (inet->pmtudisc >= IP_PMTUDISC_DO) ?
826 : : mtu : 0xFFFF;
827 : :
828 [ - + ]: 27 : if (cork->length + length > maxnonfragsize - fragheaderlen) {
829 : 0 : ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
830 [ # # ]: 0 : mtu - (opt ? opt->optlen : 0));
831 : : return -EMSGSIZE;
832 : : }
833 : :
834 : : /*
835 : : * transhdrlen > 0 means that this is the first fragment and we wish
836 : : * it won't be fragmented in the future.
837 : : */
838 [ + + ][ + - ]: 27 : if (transhdrlen &&
839 [ + + ]: 26 : length + fragheaderlen <= mtu &&
840 [ + - ]: 18 : rt->dst.dev->features & NETIF_F_V4_CSUM &&
841 : : !exthdrlen)
842 : : csummode = CHECKSUM_PARTIAL;
843 : :
844 : 27 : cork->length += length;
845 [ + - ][ - + ]: 27 : if (((length > mtu) || (skb && skb_is_gso(skb))) &&
[ # # ][ # # ]
846 [ # # ]: 0 : (sk->sk_protocol == IPPROTO_UDP) &&
847 [ # # ]: 0 : (rt->dst.dev->features & NETIF_F_UFO) && !rt->dst.header_len) {
848 : 0 : err = ip_ufo_append_data(sk, queue, getfrag, from, length,
849 : : hh_len, fragheaderlen, transhdrlen,
850 : : maxfraglen, flags);
851 [ # # ]: 0 : if (err)
852 : : goto error;
853 : : return 0;
854 : : }
855 : :
856 : : /* So, what's going on in the loop below?
857 : : *
858 : : * We use calculated fragment length to generate chained skb,
859 : : * each of segments is IP fragment ready for sending to network after
860 : : * adding appropriate IP header.
861 : : */
862 : :
863 [ + - ]: 27 : if (!skb)
864 : : goto alloc_new_skb;
865 : :
866 [ - + ]: 25 : while (length > 0) {
867 : : /* Check if the remaining data fits into current packet. */
868 : 0 : copy = mtu - skb->len;
869 [ # # ]: 0 : if (copy < length)
870 : 0 : copy = maxfraglen - skb->len;
871 [ # # ]: 0 : if (copy <= 0) {
872 : : char *data;
873 : : unsigned int datalen;
874 : : unsigned int fraglen;
875 : : unsigned int fraggap;
876 : : unsigned int alloclen;
877 : : struct sk_buff *skb_prev;
878 : : alloc_new_skb:
879 : : skb_prev = skb;
880 [ - + ]: 27 : if (skb_prev)
881 : 0 : fraggap = skb_prev->len - maxfraglen;
882 : : else
883 : : fraggap = 0;
884 : :
885 : : /*
886 : : * If remaining data exceeds the mtu,
887 : : * we know we need more fragment(s).
888 : : */
889 : 27 : datalen = length + fraggap;
890 [ - + ]: 27 : if (datalen > mtu - fragheaderlen)
891 : : datalen = maxfraglen - fragheaderlen;
892 : 27 : fraglen = datalen + fragheaderlen;
893 : :
894 [ + + ][ + - ]: 27 : if ((flags & MSG_MORE) &&
895 : 16 : !(rt->dst.dev->features&NETIF_F_SG))
896 : : alloclen = mtu;
897 : : else
898 : : alloclen = fraglen;
899 : :
900 : 27 : alloclen += exthdrlen;
901 : :
902 : : /* The last fragment gets additional space at tail.
903 : : * Note, with MSG_MORE we overallocate on fragments,
904 : : * because we have no idea what fragment will be
905 : : * the last.
906 : : */
907 [ + - ]: 27 : if (datalen == length + fraggap)
908 : 27 : alloclen += rt->dst.trailer_len;
909 : :
910 [ + + ]: 27 : if (transhdrlen) {
911 : 26 : skb = sock_alloc_send_skb(sk,
912 : 26 : alloclen + hh_len + 15,
913 : : (flags & MSG_DONTWAIT), &err);
914 : : } else {
915 : : skb = NULL;
916 [ + - ]: 1 : if (atomic_read(&sk->sk_wmem_alloc) <=
917 : 1 : 2 * sk->sk_sndbuf)
918 : 1 : skb = sock_wmalloc(sk,
919 : 1 : alloclen + hh_len + 15, 1,
920 : : sk->sk_allocation);
921 [ - + ]: 1 : if (unlikely(skb == NULL))
922 : 0 : err = -ENOBUFS;
923 : : else
924 : : /* only the initial fragment is
925 : : time stamped */
926 : 1 : cork->tx_flags = 0;
927 : : }
928 [ + - ]: 27 : if (skb == NULL)
929 : : goto error;
930 : :
931 : : /*
932 : : * Fill in the control structures
933 : : */
934 : 27 : skb->ip_summed = csummode;
935 : 27 : skb->csum = 0;
936 : : skb_reserve(skb, hh_len);
937 : 27 : skb_shinfo(skb)->tx_flags = cork->tx_flags;
938 : :
939 : : /*
940 : : * Find where to start putting bytes.
941 : : */
942 : 27 : data = skb_put(skb, fraglen + exthdrlen);
943 : : skb_set_network_header(skb, exthdrlen);
944 : 27 : skb->transport_header = (skb->network_header +
945 : : fragheaderlen);
946 : 27 : data += fragheaderlen + exthdrlen;
947 : :
948 [ - + ]: 27 : if (fraggap) {
949 : 0 : skb->csum = skb_copy_and_csum_bits(
950 : : skb_prev, maxfraglen,
951 : : data + transhdrlen, fraggap, 0);
952 : 0 : skb_prev->csum = csum_sub(skb_prev->csum,
953 : : skb->csum);
954 : 0 : data += fraggap;
955 : : pskb_trim_unique(skb_prev, maxfraglen);
956 : : }
957 : :
958 : 27 : copy = datalen - transhdrlen - fraggap;
959 [ + + ][ + + ]: 27 : if (copy > 0 && getfrag(from, data + transhdrlen, offset, copy, fraggap, skb) < 0) {
960 : 2 : err = -EFAULT;
961 : 2 : kfree_skb(skb);
962 : : goto error;
963 : : }
964 : :
965 : 25 : offset += copy;
966 : 25 : length -= datalen - fraggap;
967 : : transhdrlen = 0;
968 : : exthdrlen = 0;
969 : : csummode = CHECKSUM_NONE;
970 : :
971 : : /*
972 : : * Put the packet on the pending queue.
973 : : */
974 : : __skb_queue_tail(queue, skb);
975 : 25 : continue;
976 : : }
977 : :
978 [ # # ]: 0 : if (copy > length)
979 : : copy = length;
980 : :
981 [ # # ]: 0 : if (!(rt->dst.dev->features&NETIF_F_SG)) {
982 : : unsigned int off;
983 : :
984 : : off = skb->len;
985 [ # # ]: 0 : if (getfrag(from, skb_put(skb, copy),
986 : : offset, copy, off, skb) < 0) {
987 : : __skb_trim(skb, off);
988 : 0 : err = -EFAULT;
989 : : goto error;
990 : : }
991 : : } else {
992 : 0 : int i = skb_shinfo(skb)->nr_frags;
993 : :
994 : 0 : err = -ENOMEM;
995 [ # # ]: 0 : if (!sk_page_frag_refill(sk, pfrag))
996 : : goto error;
997 : :
998 [ # # ]: 0 : if (!skb_can_coalesce(skb, i, pfrag->page,
999 : 0 : pfrag->offset)) {
1000 : 0 : err = -EMSGSIZE;
1001 [ # # ]: 0 : if (i == MAX_SKB_FRAGS)
1002 : : goto error;
1003 : :
1004 : : __skb_fill_page_desc(skb, i, pfrag->page,
1005 : : pfrag->offset, 0);
1006 : 0 : skb_shinfo(skb)->nr_frags = ++i;
1007 : 0 : get_page(pfrag->page);
1008 : : }
1009 : 0 : copy = min_t(int, copy, pfrag->size - pfrag->offset);
1010 [ # # ]: 0 : if (getfrag(from,
1011 : 0 : page_address(pfrag->page) + pfrag->offset,
1012 : 0 : offset, copy, skb->len, skb) < 0)
1013 : : goto error_efault;
1014 : :
1015 : 0 : pfrag->offset += copy;
1016 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
1017 : 0 : skb->len += copy;
1018 : 0 : skb->data_len += copy;
1019 : 0 : skb->truesize += copy;
1020 : 0 : atomic_add(copy, &sk->sk_wmem_alloc);
1021 : : }
1022 : 0 : offset += copy;
1023 : 0 : length -= copy;
1024 : : }
1025 : :
1026 : : return 0;
1027 : :
1028 : : error_efault:
1029 : 0 : err = -EFAULT;
1030 : : error:
1031 : 2 : cork->length -= length;
1032 : 6 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
1033 : 2 : return err;
1034 : : }
1035 : :
1036 : 0 : static int ip_setup_cork(struct sock *sk, struct inet_cork *cork,
1037 : : struct ipcm_cookie *ipc, struct rtable **rtp)
1038 : : {
1039 : : struct ip_options_rcu *opt;
1040 : : struct rtable *rt;
1041 : :
1042 : : /*
1043 : : * setup for corking.
1044 : : */
1045 : 27 : opt = ipc->opt;
1046 [ - + ]: 27 : if (opt) {
1047 [ # # ]: 0 : if (cork->opt == NULL) {
1048 : 0 : cork->opt = kmalloc(sizeof(struct ip_options) + 40,
1049 : : sk->sk_allocation);
1050 [ # # ]: 0 : if (unlikely(cork->opt == NULL))
1051 : : return -ENOBUFS;
1052 : : }
1053 : 0 : memcpy(cork->opt, &opt->opt, sizeof(struct ip_options) + opt->opt.optlen);
1054 : 0 : cork->flags |= IPCORK_OPT;
1055 : 0 : cork->addr = ipc->addr;
1056 : : }
1057 : 27 : rt = *rtp;
1058 [ + - ]: 27 : if (unlikely(!rt))
1059 : : return -EFAULT;
1060 : : /*
1061 : : * We steal reference to this route, caller should not release it
1062 : : */
1063 : 27 : *rtp = NULL;
1064 : 27 : cork->fragsize = ip_sk_use_pmtu(sk) ?
1065 [ + - ]: 27 : dst_mtu(&rt->dst) : rt->dst.dev->mtu;
1066 : 27 : cork->dst = &rt->dst;
1067 : 27 : cork->length = 0;
1068 : 27 : cork->ttl = ipc->ttl;
1069 : 27 : cork->tos = ipc->tos;
1070 : 27 : cork->priority = ipc->priority;
1071 : 27 : cork->tx_flags = ipc->tx_flags;
1072 : :
1073 : 27 : return 0;
1074 : : }
1075 : :
1076 : : /*
1077 : : * ip_append_data() and ip_append_page() can make one large IP datagram
1078 : : * from many pieces of data. Each pieces will be holded on the socket
1079 : : * until ip_push_pending_frames() is called. Each piece can be a page
1080 : : * or non-page data.
1081 : : *
1082 : : * Not only UDP, other transport protocols - e.g. raw sockets - can use
1083 : : * this interface potentially.
1084 : : *
1085 : : * LATER: length must be adjusted by pad at tail, when it is required.
1086 : : */
1087 : 0 : int ip_append_data(struct sock *sk, struct flowi4 *fl4,
1088 : : int getfrag(void *from, char *to, int offset, int len,
1089 : : int odd, struct sk_buff *skb),
1090 : : void *from, int length, int transhdrlen,
1091 : : struct ipcm_cookie *ipc, struct rtable **rtp,
1092 : : unsigned int flags)
1093 : : {
1094 : : struct inet_sock *inet = inet_sk(sk);
1095 : : int err;
1096 : :
1097 [ + - ]: 17 : if (flags&MSG_PROBE)
1098 : : return 0;
1099 : :
1100 [ + - ]: 17 : if (skb_queue_empty(&sk->sk_write_queue)) {
1101 : 17 : err = ip_setup_cork(sk, &inet->cork.base, ipc, rtp);
1102 [ + - ]: 17 : if (err)
1103 : : return err;
1104 : : } else {
1105 : : transhdrlen = 0;
1106 : : }
1107 : :
1108 : 17 : return __ip_append_data(sk, fl4, &sk->sk_write_queue, &inet->cork.base,
1109 : : sk_page_frag(sk), getfrag,
1110 : : from, length, transhdrlen, flags);
1111 : : }
1112 : :
1113 : 0 : ssize_t ip_append_page(struct sock *sk, struct flowi4 *fl4, struct page *page,
1114 : : int offset, size_t size, int flags)
1115 : : {
1116 : : struct inet_sock *inet = inet_sk(sk);
1117 : 0 : struct sk_buff *skb;
1118 : : struct rtable *rt;
1119 : : struct ip_options *opt = NULL;
1120 : : struct inet_cork *cork;
1121 : : int hh_len;
1122 : : int mtu;
1123 : : int len;
1124 : : int err;
1125 : : unsigned int maxfraglen, fragheaderlen, fraggap, maxnonfragsize;
1126 : :
1127 [ + - ]: 16 : if (inet->hdrincl)
1128 : : return -EPERM;
1129 : :
1130 [ + - ]: 16 : if (flags&MSG_PROBE)
1131 : : return 0;
1132 : :
1133 [ + - ]: 16 : if (skb_queue_empty(&sk->sk_write_queue))
1134 : : return -EINVAL;
1135 : :
1136 : : cork = &inet->cork.base;
1137 : 16 : rt = (struct rtable *)cork->dst;
1138 [ - + ]: 16 : if (cork->flags & IPCORK_OPT)
1139 : 0 : opt = cork->opt;
1140 : :
1141 [ + - ]: 16 : if (!(rt->dst.dev->features&NETIF_F_SG))
1142 : : return -EOPNOTSUPP;
1143 : :
1144 : 16 : hh_len = LL_RESERVED_SPACE(rt->dst.dev);
1145 : 16 : mtu = cork->fragsize;
1146 : :
1147 [ - + ]: 16 : fragheaderlen = sizeof(struct iphdr) + (opt ? opt->optlen : 0);
1148 : 16 : maxfraglen = ((mtu - fragheaderlen) & ~7) + fragheaderlen;
1149 [ - + ]: 16 : maxnonfragsize = (inet->pmtudisc >= IP_PMTUDISC_DO) ?
1150 : : mtu : 0xFFFF;
1151 : :
1152 [ - + ]: 16 : if (cork->length + size > maxnonfragsize - fragheaderlen) {
1153 : 0 : ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
1154 [ # # ]: 0 : mtu - (opt ? opt->optlen : 0));
1155 : 0 : return -EMSGSIZE;
1156 : : }
1157 : :
1158 [ + - ]: 16 : if ((skb = skb_peek_tail(&sk->sk_write_queue)) == NULL)
1159 : : return -EINVAL;
1160 : :
1161 : 16 : cork->length += size;
1162 [ - + ][ # # ]: 16 : if ((size + skb->len > mtu) &&
1163 [ # # ]: 0 : (sk->sk_protocol == IPPROTO_UDP) &&
1164 : 0 : (rt->dst.dev->features & NETIF_F_UFO)) {
1165 : 0 : skb_shinfo(skb)->gso_size = mtu - fragheaderlen;
1166 : 16 : skb_shinfo(skb)->gso_type = SKB_GSO_UDP;
1167 : : }
1168 : :
1169 : :
1170 [ + + ]: 32 : while (size > 0) {
1171 : : int i;
1172 : :
1173 [ - + ]: 16 : if (skb_is_gso(skb))
1174 : 0 : len = size;
1175 : : else {
1176 : :
1177 : : /* Check if the remaining data fits into current packet. */
1178 : 16 : len = mtu - skb->len;
1179 [ - + ]: 16 : if (len < size)
1180 : 0 : len = maxfraglen - skb->len;
1181 : : }
1182 [ - + ]: 16 : if (len <= 0) {
1183 : : struct sk_buff *skb_prev;
1184 : : int alloclen;
1185 : :
1186 : : skb_prev = skb;
1187 : 0 : fraggap = skb_prev->len - maxfraglen;
1188 : :
1189 : 0 : alloclen = fragheaderlen + hh_len + fraggap + 15;
1190 : 0 : skb = sock_wmalloc(sk, alloclen, 1, sk->sk_allocation);
1191 [ # # ]: 0 : if (unlikely(!skb)) {
1192 : : err = -ENOBUFS;
1193 : : goto error;
1194 : : }
1195 : :
1196 : : /*
1197 : : * Fill in the control structures
1198 : : */
1199 : 0 : skb->ip_summed = CHECKSUM_NONE;
1200 : 0 : skb->csum = 0;
1201 : : skb_reserve(skb, hh_len);
1202 : :
1203 : : /*
1204 : : * Find where to start putting bytes.
1205 : : */
1206 : 0 : skb_put(skb, fragheaderlen + fraggap);
1207 : : skb_reset_network_header(skb);
1208 : 0 : skb->transport_header = (skb->network_header +
1209 : : fragheaderlen);
1210 [ # # ]: 0 : if (fraggap) {
1211 : 0 : skb->csum = skb_copy_and_csum_bits(skb_prev,
1212 : : maxfraglen,
1213 : : skb_transport_header(skb),
1214 : : fraggap, 0);
1215 : 0 : skb_prev->csum = csum_sub(skb_prev->csum,
1216 : : skb->csum);
1217 : : pskb_trim_unique(skb_prev, maxfraglen);
1218 : : }
1219 : :
1220 : : /*
1221 : : * Put the packet on the pending queue.
1222 : : */
1223 : : __skb_queue_tail(&sk->sk_write_queue, skb);
1224 : 0 : continue;
1225 : : }
1226 : :
1227 : 16 : i = skb_shinfo(skb)->nr_frags;
1228 [ + - ]: 16 : if (len > size)
1229 : 16 : len = size;
1230 [ - + ]: 16 : if (skb_can_coalesce(skb, i, page, offset)) {
1231 : 0 : skb_frag_size_add(&skb_shinfo(skb)->frags[i-1], len);
1232 [ + - ]: 16 : } else if (i < MAX_SKB_FRAGS) {
1233 : : get_page(page);
1234 : : skb_fill_page_desc(skb, i, page, offset, len);
1235 : : } else {
1236 : : err = -EMSGSIZE;
1237 : : goto error;
1238 : : }
1239 : :
1240 [ - + ]: 16 : if (skb->ip_summed == CHECKSUM_NONE) {
1241 : : __wsum csum;
1242 : : csum = csum_page(page, offset, len);
1243 : 0 : skb->csum = csum_block_add(skb->csum, csum, skb->len);
1244 : : }
1245 : :
1246 : 16 : skb->len += len;
1247 : 16 : skb->data_len += len;
1248 : 16 : skb->truesize += len;
1249 : 16 : atomic_add(len, &sk->sk_wmem_alloc);
1250 : 16 : offset += len;
1251 : 16 : size -= len;
1252 : : }
1253 : : return 0;
1254 : :
1255 : : error:
1256 : 0 : cork->length -= size;
1257 : 0 : IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS);
1258 : 0 : return err;
1259 : : }
1260 : :
1261 : 0 : static void ip_cork_release(struct inet_cork *cork)
1262 : : {
1263 : 27 : cork->flags &= ~IPCORK_OPT;
1264 : 27 : kfree(cork->opt);
1265 : 27 : cork->opt = NULL;
1266 : 27 : dst_release(cork->dst);
1267 : 27 : cork->dst = NULL;
1268 : 27 : }
1269 : :
1270 : : /*
1271 : : * Combined all pending IP fragments on the socket as one IP datagram
1272 : : * and push them out.
1273 : : */
1274 : 0 : struct sk_buff *__ip_make_skb(struct sock *sk,
1275 : : struct flowi4 *fl4,
1276 : : struct sk_buff_head *queue,
1277 : : struct inet_cork *cork)
1278 : : {
1279 : 100 : struct sk_buff *skb, *tmp_skb;
1280 : : struct sk_buff **tail_skb;
1281 : : struct inet_sock *inet = inet_sk(sk);
1282 : : struct net *net = sock_net(sk);
1283 : : struct ip_options *opt = NULL;
1284 : 25 : struct rtable *rt = (struct rtable *)cork->dst;
1285 : : struct iphdr *iph;
1286 : : __be16 df = 0;
1287 : : __u8 ttl;
1288 : :
1289 [ + ]: 25 : if ((skb = __skb_dequeue(queue)) == NULL)
1290 : : goto out;
1291 : 50 : tail_skb = &(skb_shinfo(skb)->frag_list);
1292 : :
1293 : : /* move skb->data to ip header from ext header */
1294 [ - + ]: 50 : if (skb->data < skb_network_header(skb))
1295 : 0 : __skb_pull(skb, skb_network_offset(skb));
1296 [ - + ]: 25 : while ((tmp_skb = __skb_dequeue(queue)) != NULL) {
1297 : : __skb_pull(tmp_skb, skb_network_header_len(skb));
1298 : 0 : *tail_skb = tmp_skb;
1299 : 0 : tail_skb = &(tmp_skb->next);
1300 : 0 : skb->len += tmp_skb->len;
1301 : 0 : skb->data_len += tmp_skb->len;
1302 : 0 : skb->truesize += tmp_skb->truesize;
1303 : 0 : tmp_skb->destructor = NULL;
1304 : 0 : tmp_skb->sk = NULL;
1305 : : }
1306 : :
1307 : : /* Unless user demanded real pmtu discovery (IP_PMTUDISC_DO), we allow
1308 : : * to fragment the frame generated here. No matter, what transforms
1309 : : * how transforms change size of the packet, it will come out.
1310 : : */
1311 [ + - ]: 25 : if (inet->pmtudisc < IP_PMTUDISC_DO)
1312 : 25 : skb->local_df = 1;
1313 : :
1314 : : /* DF bit is set when we want to see DF on outgoing frames.
1315 : : * If local_df is set too, we still allow to fragment this frame
1316 : : * locally. */
1317 [ + - ]: 25 : if (inet->pmtudisc == IP_PMTUDISC_DO ||
1318 [ + - ]: 25 : inet->pmtudisc == IP_PMTUDISC_PROBE ||
1319 [ + - ]: 25 : (skb->len <= dst_mtu(&rt->dst) &&
1320 : : ip_dont_fragment(sk, &rt->dst)))
1321 : : df = htons(IP_DF);
1322 : :
1323 [ - + ]: 25 : if (cork->flags & IPCORK_OPT)
1324 : 0 : opt = cork->opt;
1325 : :
1326 [ + - ]: 25 : if (cork->ttl != 0)
1327 : : ttl = cork->ttl;
1328 [ - + ]: 25 : else if (rt->rt_type == RTN_MULTICAST)
1329 : 0 : ttl = inet->mc_ttl;
1330 : : else
1331 : 25 : ttl = ip_select_ttl(inet, &rt->dst);
1332 : :
1333 : : iph = ip_hdr(skb);
1334 : 25 : iph->version = 4;
1335 : 25 : iph->ihl = 5;
1336 [ - + ]: 25 : iph->tos = (cork->tos != -1) ? cork->tos : inet->tos;
1337 : 25 : iph->frag_off = df;
1338 : 25 : iph->ttl = ttl;
1339 : 25 : iph->protocol = sk->sk_protocol;
1340 : : ip_copy_addrs(iph, fl4);
1341 : 25 : ip_select_ident(skb, &rt->dst, sk);
1342 : :
1343 [ - + ]: 25 : if (opt) {
1344 : 0 : iph->ihl += opt->optlen>>2;
1345 : 0 : ip_options_build(skb, opt, cork->addr, rt, 0);
1346 : : }
1347 : :
1348 [ - + ]: 25 : skb->priority = (cork->tos != -1) ? cork->priority: sk->sk_priority;
1349 : 25 : skb->mark = sk->sk_mark;
1350 : : /*
1351 : : * Steal rt from cork.dst to avoid a pair of atomic_inc/atomic_dec
1352 : : * on dst refcount
1353 : : */
1354 : 25 : cork->dst = NULL;
1355 : : skb_dst_set(skb, &rt->dst);
1356 : :
1357 [ - + ]: 25 : if (iph->protocol == IPPROTO_ICMP)
1358 : 0 : icmp_out_count(net, ((struct icmphdr *)
1359 : : skb_transport_header(skb))->type);
1360 : :
1361 : 25 : ip_cork_release(cork);
1362 : : out:
1363 : 0 : return skb;
1364 : : }
1365 : :
1366 : 0 : int ip_send_skb(struct net *net, struct sk_buff *skb)
1367 : : {
1368 : : int err;
1369 : :
1370 : 25 : err = ip_local_out(skb);
1371 [ - + ]: 25 : if (err) {
1372 [ # # ]: 0 : if (err > 0)
1373 [ # # ]: 0 : err = net_xmit_errno(err);
1374 [ - ]: 0 : if (err)
1375 : 0 : IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
1376 : : }
1377 : :
1378 : 0 : return err;
1379 : : }
1380 : :
1381 : 0 : int ip_push_pending_frames(struct sock *sk, struct flowi4 *fl4)
1382 : : {
1383 : : struct sk_buff *skb;
1384 : :
1385 : : skb = ip_finish_skb(sk, fl4);
1386 [ + - ]: 1 : if (!skb)
1387 : : return 0;
1388 : :
1389 : : /* Netfilter gets whole the not fragmented skb. */
1390 : 1 : return ip_send_skb(sock_net(sk), skb);
1391 : : }
1392 : :
1393 : : /*
1394 : : * Throw away all pending data on the socket.
1395 : : */
1396 : 2 : static void __ip_flush_pending_frames(struct sock *sk,
1397 : : struct sk_buff_head *queue,
1398 : : struct inet_cork *cork)
1399 : : {
1400 : : struct sk_buff *skb;
1401 : :
1402 [ - + ]: 2 : while ((skb = __skb_dequeue_tail(queue)) != NULL)
1403 : 0 : kfree_skb(skb);
1404 : :
1405 : 2 : ip_cork_release(cork);
1406 : 2 : }
1407 : :
1408 : 0 : void ip_flush_pending_frames(struct sock *sk)
1409 : : {
1410 : 0 : __ip_flush_pending_frames(sk, &sk->sk_write_queue, &inet_sk(sk)->cork.base);
1411 : 0 : }
1412 : :
1413 : 0 : struct sk_buff *ip_make_skb(struct sock *sk,
1414 : : struct flowi4 *fl4,
1415 : : int getfrag(void *from, char *to, int offset,
1416 : : int len, int odd, struct sk_buff *skb),
1417 : : void *from, int length, int transhdrlen,
1418 : : struct ipcm_cookie *ipc, struct rtable **rtp,
1419 : : unsigned int flags)
1420 : : {
1421 : : struct inet_cork cork;
1422 : : struct sk_buff_head queue;
1423 : : int err;
1424 : :
1425 [ + - ]: 10 : if (flags & MSG_PROBE)
1426 : : return NULL;
1427 : :
1428 : : __skb_queue_head_init(&queue);
1429 : :
1430 : 10 : cork.flags = 0;
1431 : 10 : cork.addr = 0;
1432 : 10 : cork.opt = NULL;
1433 : 10 : err = ip_setup_cork(sk, &cork, ipc, rtp);
1434 [ - + ]: 20 : if (err)
1435 : 0 : return ERR_PTR(err);
1436 : :
1437 : 10 : err = __ip_append_data(sk, fl4, &queue, &cork,
1438 : 10 : ¤t->task_frag, getfrag,
1439 : : from, length, transhdrlen, flags);
1440 [ + + ]: 10 : if (err) {
1441 : 2 : __ip_flush_pending_frames(sk, &queue, &cork);
1442 : 2 : return ERR_PTR(err);
1443 : : }
1444 : :
1445 : 8 : return __ip_make_skb(sk, fl4, &queue, &cork);
1446 : : }
1447 : :
1448 : : /*
1449 : : * Fetch data from kernel space and fill in checksum if needed.
1450 : : */
1451 : 0 : static int ip_reply_glue_bits(void *dptr, char *to, int offset,
1452 : : int len, int odd, struct sk_buff *skb)
1453 : : {
1454 : : __wsum csum;
1455 : :
1456 : 1 : csum = csum_partial_copy_nocheck(dptr+offset, to, len, 0);
1457 : 1 : skb->csum = csum_block_add(skb->csum, csum, odd);
1458 : 0 : return 0;
1459 : : }
1460 : :
1461 : : /*
1462 : : * Generic function to send a packet as reply to another packet.
1463 : : * Used to send some TCP resets/acks so far.
1464 : : *
1465 : : * Use a fake percpu inet socket to avoid false sharing and contention.
1466 : : */
1467 : : static DEFINE_PER_CPU(struct inet_sock, unicast_sock) = {
1468 : : .sk = {
1469 : : .__sk_common = {
1470 : : .skc_refcnt = ATOMIC_INIT(1),
1471 : : },
1472 : : .sk_wmem_alloc = ATOMIC_INIT(1),
1473 : : .sk_allocation = GFP_ATOMIC,
1474 : : .sk_flags = (1UL << SOCK_USE_WRITE_QUEUE),
1475 : : },
1476 : : .pmtudisc = IP_PMTUDISC_WANT,
1477 : : .uc_ttl = -1,
1478 : : };
1479 : :
1480 : 0 : void ip_send_unicast_reply(struct net *net, struct sk_buff *skb, __be32 daddr,
1481 : 1 : __be32 saddr, const struct ip_reply_arg *arg,
1482 : : unsigned int len)
1483 : : {
1484 : : struct ip_options_data replyopts;
1485 : : struct ipcm_cookie ipc;
1486 : : struct flowi4 fl4;
1487 : 1 : struct rtable *rt = skb_rtable(skb);
1488 : 1 : struct sk_buff *nskb;
1489 : : struct sock *sk;
1490 : : struct inet_sock *inet;
1491 : :
1492 [ + - ]: 1 : if (ip_options_echo(&replyopts.opt.opt, skb))
1493 : 0 : return;
1494 : :
1495 : 1 : ipc.addr = daddr;
1496 : 1 : ipc.opt = NULL;
1497 : 1 : ipc.tx_flags = 0;
1498 : 1 : ipc.ttl = 0;
1499 : 1 : ipc.tos = -1;
1500 : :
1501 [ - + ]: 1 : if (replyopts.opt.opt.optlen) {
1502 : 0 : ipc.opt = &replyopts.opt;
1503 : :
1504 [ # # ]: 0 : if (replyopts.opt.opt.srr)
1505 : 0 : daddr = replyopts.opt.opt.faddr;
1506 : : }
1507 : :
1508 : 4 : flowi4_init_output(&fl4, arg->bound_dev_if, 0,
1509 : 1 : RT_TOS(arg->tos),
1510 : : RT_SCOPE_UNIVERSE, ip_hdr(skb)->protocol,
1511 : : ip_reply_arg_flowi_flags(arg),
1512 : : daddr, saddr,
1513 : : tcp_hdr(skb)->source, tcp_hdr(skb)->dest);
1514 : : security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
1515 : 1 : rt = ip_route_output_key(net, &fl4);
1516 [ + - ]: 1 : if (IS_ERR(rt))
1517 : : return;
1518 : :
1519 : 1 : inet = &get_cpu_var(unicast_sock);
1520 : :
1521 : 1 : inet->tos = arg->tos;
1522 : 1 : sk = &inet->sk;
1523 : 1 : sk->sk_priority = skb->priority;
1524 : 1 : sk->sk_protocol = ip_hdr(skb)->protocol;
1525 : 1 : sk->sk_bound_dev_if = arg->bound_dev_if;
1526 : : sock_net_set(sk, net);
1527 : 1 : __skb_queue_head_init(&sk->sk_write_queue);
1528 : 1 : sk->sk_sndbuf = sysctl_wmem_default;
1529 : 1 : ip_append_data(sk, &fl4, ip_reply_glue_bits, arg->iov->iov_base, len, 0,
1530 : : &ipc, &rt, MSG_DONTWAIT);
1531 : : nskb = skb_peek(&sk->sk_write_queue);
1532 [ + - ]: 1 : if (nskb) {
1533 [ + - ]: 1 : if (arg->csumoffset >= 0)
1534 : 1 : *((__sum16 *)skb_transport_header(nskb) +
1535 : 1 : arg->csumoffset) = csum_fold(csum_add(nskb->csum,
1536 : : arg->csum));
1537 : 1 : nskb->ip_summed = CHECKSUM_NONE;
1538 : : skb_orphan(nskb);
1539 : : skb_set_queue_mapping(nskb, skb_get_queue_mapping(skb));
1540 : 1 : ip_push_pending_frames(sk, &fl4);
1541 : : }
1542 : :
1543 : 1 : put_cpu_var(unicast_sock);
1544 : :
1545 : 1 : ip_rt_put(rt);
1546 : : }
1547 : :
1548 : 0 : void __init ip_init(void)
1549 : : {
1550 : 0 : ip_rt_init();
1551 : 0 : inet_initpeers();
1552 : :
1553 : : #if defined(CONFIG_IP_MULTICAST)
1554 : 0 : igmp_mc_init();
1555 : : #endif
1556 : 0 : }
|
