Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * NET3: Implementation of the ICMP protocol layer.
4 : : *
5 : : * Alan Cox, <alan@lxorguk.ukuu.org.uk>
6 : : *
7 : : * Some of the function names and the icmp unreach table for this
8 : : * module were derived from [icmp.c 1.0.11 06/02/93] by
9 : : * Ross Biro, Fred N. van Kempen, Mark Evans, Alan Cox, Gerhard Koerting.
10 : : * Other than that this module is a complete rewrite.
11 : : *
12 : : * Fixes:
13 : : * Clemens Fruhwirth : introduce global icmp rate limiting
14 : : * with icmp type masking ability instead
15 : : * of broken per type icmp timeouts.
16 : : * Mike Shaver : RFC1122 checks.
17 : : * Alan Cox : Multicast ping reply as self.
18 : : * Alan Cox : Fix atomicity lockup in ip_build_xmit
19 : : * call.
20 : : * Alan Cox : Added 216,128 byte paths to the MTU
21 : : * code.
22 : : * Martin Mares : RFC1812 checks.
23 : : * Martin Mares : Can be configured to follow redirects
24 : : * if acting as a router _without_ a
25 : : * routing protocol (RFC 1812).
26 : : * Martin Mares : Echo requests may be configured to
27 : : * be ignored (RFC 1812).
28 : : * Martin Mares : Limitation of ICMP error message
29 : : * transmit rate (RFC 1812).
30 : : * Martin Mares : TOS and Precedence set correctly
31 : : * (RFC 1812).
32 : : * Martin Mares : Now copying as much data from the
33 : : * original packet as we can without
34 : : * exceeding 576 bytes (RFC 1812).
35 : : * Willy Konynenberg : Transparent proxying support.
36 : : * Keith Owens : RFC1191 correction for 4.2BSD based
37 : : * path MTU bug.
38 : : * Thomas Quinot : ICMP Dest Unreach codes up to 15 are
39 : : * valid (RFC 1812).
40 : : * Andi Kleen : Check all packet lengths properly
41 : : * and moved all kfree_skb() up to
42 : : * icmp_rcv.
43 : : * Andi Kleen : Move the rate limit bookkeeping
44 : : * into the dest entry and use a token
45 : : * bucket filter (thanks to ANK). Make
46 : : * the rates sysctl configurable.
47 : : * Yu Tianli : Fixed two ugly bugs in icmp_send
48 : : * - IP option length was accounted wrongly
49 : : * - ICMP header length was not accounted
50 : : * at all.
51 : : * Tristan Greaves : Added sysctl option to ignore bogus
52 : : * broadcast responses from broken routers.
53 : : *
54 : : * To Fix:
55 : : *
56 : : * - Should use skb_pull() instead of all the manual checking.
57 : : * This would also greatly simply some upper layer error handlers. --AK
58 : : */
59 : :
60 : : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
61 : :
62 : : #include <linux/module.h>
63 : : #include <linux/types.h>
64 : : #include <linux/jiffies.h>
65 : : #include <linux/kernel.h>
66 : : #include <linux/fcntl.h>
67 : : #include <linux/socket.h>
68 : : #include <linux/in.h>
69 : : #include <linux/inet.h>
70 : : #include <linux/inetdevice.h>
71 : : #include <linux/netdevice.h>
72 : : #include <linux/string.h>
73 : : #include <linux/netfilter_ipv4.h>
74 : : #include <linux/slab.h>
75 : : #include <net/snmp.h>
76 : : #include <net/ip.h>
77 : : #include <net/route.h>
78 : : #include <net/protocol.h>
79 : : #include <net/icmp.h>
80 : : #include <net/tcp.h>
81 : : #include <net/udp.h>
82 : : #include <net/raw.h>
83 : : #include <net/ping.h>
84 : : #include <linux/skbuff.h>
85 : : #include <net/sock.h>
86 : : #include <linux/errno.h>
87 : : #include <linux/timer.h>
88 : : #include <linux/init.h>
89 : : #include <linux/uaccess.h>
90 : : #include <net/checksum.h>
91 : : #include <net/xfrm.h>
92 : : #include <net/inet_common.h>
93 : : #include <net/ip_fib.h>
94 : : #include <net/l3mdev.h>
95 : :
96 : : /*
97 : : * Build xmit assembly blocks
98 : : */
99 : :
100 : : struct icmp_bxm {
101 : : struct sk_buff *skb;
102 : : int offset;
103 : : int data_len;
104 : :
105 : : struct {
106 : : struct icmphdr icmph;
107 : : __be32 times[3];
108 : : } data;
109 : : int head_len;
110 : : struct ip_options_data replyopts;
111 : : };
112 : :
113 : : /* An array of errno for error messages from dest unreach. */
114 : : /* RFC 1122: 3.2.2.1 States that NET_UNREACH, HOST_UNREACH and SR_FAILED MUST be considered 'transient errs'. */
115 : :
116 : : const struct icmp_err icmp_err_convert[] = {
117 : : {
118 : : .errno = ENETUNREACH, /* ICMP_NET_UNREACH */
119 : : .fatal = 0,
120 : : },
121 : : {
122 : : .errno = EHOSTUNREACH, /* ICMP_HOST_UNREACH */
123 : : .fatal = 0,
124 : : },
125 : : {
126 : : .errno = ENOPROTOOPT /* ICMP_PROT_UNREACH */,
127 : : .fatal = 1,
128 : : },
129 : : {
130 : : .errno = ECONNREFUSED, /* ICMP_PORT_UNREACH */
131 : : .fatal = 1,
132 : : },
133 : : {
134 : : .errno = EMSGSIZE, /* ICMP_FRAG_NEEDED */
135 : : .fatal = 0,
136 : : },
137 : : {
138 : : .errno = EOPNOTSUPP, /* ICMP_SR_FAILED */
139 : : .fatal = 0,
140 : : },
141 : : {
142 : : .errno = ENETUNREACH, /* ICMP_NET_UNKNOWN */
143 : : .fatal = 1,
144 : : },
145 : : {
146 : : .errno = EHOSTDOWN, /* ICMP_HOST_UNKNOWN */
147 : : .fatal = 1,
148 : : },
149 : : {
150 : : .errno = ENONET, /* ICMP_HOST_ISOLATED */
151 : : .fatal = 1,
152 : : },
153 : : {
154 : : .errno = ENETUNREACH, /* ICMP_NET_ANO */
155 : : .fatal = 1,
156 : : },
157 : : {
158 : : .errno = EHOSTUNREACH, /* ICMP_HOST_ANO */
159 : : .fatal = 1,
160 : : },
161 : : {
162 : : .errno = ENETUNREACH, /* ICMP_NET_UNR_TOS */
163 : : .fatal = 0,
164 : : },
165 : : {
166 : : .errno = EHOSTUNREACH, /* ICMP_HOST_UNR_TOS */
167 : : .fatal = 0,
168 : : },
169 : : {
170 : : .errno = EHOSTUNREACH, /* ICMP_PKT_FILTERED */
171 : : .fatal = 1,
172 : : },
173 : : {
174 : : .errno = EHOSTUNREACH, /* ICMP_PREC_VIOLATION */
175 : : .fatal = 1,
176 : : },
177 : : {
178 : : .errno = EHOSTUNREACH, /* ICMP_PREC_CUTOFF */
179 : : .fatal = 1,
180 : : },
181 : : };
182 : : EXPORT_SYMBOL(icmp_err_convert);
183 : :
184 : : /*
185 : : * ICMP control array. This specifies what to do with each ICMP.
186 : : */
187 : :
188 : : struct icmp_control {
189 : : bool (*handler)(struct sk_buff *skb);
190 : : short error; /* This ICMP is classed as an error message */
191 : : };
192 : :
193 : : static const struct icmp_control icmp_pointers[NR_ICMP_TYPES+1];
194 : :
195 : : /*
196 : : * The ICMP socket(s). This is the most convenient way to flow control
197 : : * our ICMP output as well as maintain a clean interface throughout
198 : : * all layers. All Socketless IP sends will soon be gone.
199 : : *
200 : : * On SMP we have one ICMP socket per-cpu.
201 : : */
202 : 0 : static struct sock *icmp_sk(struct net *net)
203 : : {
204 : 0 : return this_cpu_read(*net->ipv4.icmp_sk);
205 : : }
206 : :
207 : : /* Called with BH disabled */
208 : 0 : static inline struct sock *icmp_xmit_lock(struct net *net)
209 : : {
210 : 0 : struct sock *sk;
211 : :
212 : 0 : sk = icmp_sk(net);
213 : :
214 [ # # # # ]: 0 : if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
215 : : /* This can happen if the output path signals a
216 : : * dst_link_failure() for an outgoing ICMP packet.
217 : : */
218 : : return NULL;
219 : : }
220 : : return sk;
221 : : }
222 : :
223 : 0 : static inline void icmp_xmit_unlock(struct sock *sk)
224 : : {
225 : 0 : spin_unlock(&sk->sk_lock.slock);
226 : 0 : }
227 : :
228 : : int sysctl_icmp_msgs_per_sec __read_mostly = 1000;
229 : : int sysctl_icmp_msgs_burst __read_mostly = 50;
230 : :
231 : : static struct {
232 : : spinlock_t lock;
233 : : u32 credit;
234 : : u32 stamp;
235 : : } icmp_global = {
236 : : .lock = __SPIN_LOCK_UNLOCKED(icmp_global.lock),
237 : : };
238 : :
239 : : /**
240 : : * icmp_global_allow - Are we allowed to send one more ICMP message ?
241 : : *
242 : : * Uses a token bucket to limit our ICMP messages to sysctl_icmp_msgs_per_sec.
243 : : * Returns false if we reached the limit and can not send another packet.
244 : : * Note: called with BH disabled
245 : : */
246 : 0 : bool icmp_global_allow(void)
247 : : {
248 : 0 : u32 credit, delta, incr = 0, now = (u32)jiffies;
249 : 0 : bool rc = false;
250 : :
251 : : /* Check if token bucket is empty and cannot be refilled
252 : : * without taking the spinlock. The READ_ONCE() are paired
253 : : * with the following WRITE_ONCE() in this same function.
254 : : */
255 [ # # ]: 0 : if (!READ_ONCE(icmp_global.credit)) {
256 [ # # ]: 0 : delta = min_t(u32, now - READ_ONCE(icmp_global.stamp), HZ);
257 [ # # ]: 0 : if (delta < HZ / 50)
258 : : return false;
259 : : }
260 : :
261 : 0 : spin_lock(&icmp_global.lock);
262 : 0 : delta = min_t(u32, now - icmp_global.stamp, HZ);
263 [ # # ]: 0 : if (delta >= HZ / 50) {
264 : 0 : incr = sysctl_icmp_msgs_per_sec * delta / HZ ;
265 [ # # ]: 0 : if (incr)
266 : 0 : WRITE_ONCE(icmp_global.stamp, now);
267 : : }
268 : 0 : credit = min_t(u32, icmp_global.credit + incr, sysctl_icmp_msgs_burst);
269 [ # # ]: 0 : if (credit) {
270 : 0 : credit--;
271 : 0 : rc = true;
272 : : }
273 : 0 : WRITE_ONCE(icmp_global.credit, credit);
274 : 0 : spin_unlock(&icmp_global.lock);
275 : 0 : return rc;
276 : : }
277 : : EXPORT_SYMBOL(icmp_global_allow);
278 : :
279 : 0 : static bool icmpv4_mask_allow(struct net *net, int type, int code)
280 : : {
281 : 0 : if (type > NR_ICMP_TYPES)
282 : : return true;
283 : :
284 : : /* Don't limit PMTU discovery. */
285 [ # # ]: 0 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
286 : : return true;
287 : :
288 : : /* Limit if icmp type is enabled in ratemask. */
289 : 0 : if (!((1 << type) & net->ipv4.sysctl_icmp_ratemask))
290 : : return true;
291 : :
292 : : return false;
293 : : }
294 : :
295 : 0 : static bool icmpv4_global_allow(struct net *net, int type, int code)
296 : : {
297 [ # # # # ]: 0 : if (icmpv4_mask_allow(net, type, code))
298 : : return true;
299 : :
300 [ # # ]: 0 : if (icmp_global_allow())
301 : 0 : return true;
302 : :
303 : : return false;
304 : : }
305 : :
306 : : /*
307 : : * Send an ICMP frame.
308 : : */
309 : :
310 : : static bool icmpv4_xrlim_allow(struct net *net, struct rtable *rt,
311 : : struct flowi4 *fl4, int type, int code)
312 : : {
313 : : struct dst_entry *dst = &rt->dst;
314 : : struct inet_peer *peer;
315 : : bool rc = true;
316 : : int vif;
317 : :
318 : : if (icmpv4_mask_allow(net, type, code))
319 : : goto out;
320 : :
321 : : /* No rate limit on loopback */
322 : : if (dst->dev && (dst->dev->flags&IFF_LOOPBACK))
323 : : goto out;
324 : :
325 : : vif = l3mdev_master_ifindex(dst->dev);
326 : : peer = inet_getpeer_v4(net->ipv4.peers, fl4->daddr, vif, 1);
327 : : rc = inet_peer_xrlim_allow(peer, net->ipv4.sysctl_icmp_ratelimit);
328 : : if (peer)
329 : : inet_putpeer(peer);
330 : : out:
331 : : return rc;
332 : : }
333 : :
334 : : /*
335 : : * Maintain the counters used in the SNMP statistics for outgoing ICMP
336 : : */
337 : 0 : void icmp_out_count(struct net *net, unsigned char type)
338 : : {
339 : 0 : ICMPMSGOUT_INC_STATS(net, type);
340 : 0 : ICMP_INC_STATS(net, ICMP_MIB_OUTMSGS);
341 : 0 : }
342 : :
343 : : /*
344 : : * Checksum each fragment, and on the first include the headers and final
345 : : * checksum.
346 : : */
347 : 0 : static int icmp_glue_bits(void *from, char *to, int offset, int len, int odd,
348 : : struct sk_buff *skb)
349 : : {
350 : 0 : struct icmp_bxm *icmp_param = (struct icmp_bxm *)from;
351 : 0 : __wsum csum;
352 : :
353 : 0 : csum = skb_copy_and_csum_bits(icmp_param->skb,
354 : 0 : icmp_param->offset + offset,
355 : : to, len, 0);
356 : :
357 [ # # ]: 0 : skb->csum = csum_block_add(skb->csum, csum, odd);
358 [ # # ]: 0 : if (icmp_pointers[icmp_param->data.icmph.type].error)
359 : 0 : nf_ct_attach(skb, icmp_param->skb);
360 : 0 : return 0;
361 : : }
362 : :
363 : 0 : static void icmp_push_reply(struct icmp_bxm *icmp_param,
364 : : struct flowi4 *fl4,
365 : : struct ipcm_cookie *ipc, struct rtable **rt)
366 : : {
367 : 0 : struct sock *sk;
368 : 0 : struct sk_buff *skb;
369 : :
370 : 0 : sk = icmp_sk(dev_net((*rt)->dst.dev));
371 [ # # ]: 0 : if (ip_append_data(sk, fl4, icmp_glue_bits, icmp_param,
372 : 0 : icmp_param->data_len+icmp_param->head_len,
373 : : icmp_param->head_len,
374 : : ipc, rt, MSG_DONTWAIT) < 0) {
375 : 0 : __ICMP_INC_STATS(sock_net(sk), ICMP_MIB_OUTERRORS);
376 : 0 : ip_flush_pending_frames(sk);
377 [ # # # # ]: 0 : } else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
378 : 0 : struct icmphdr *icmph = icmp_hdr(skb);
379 : 0 : __wsum csum = 0;
380 : 0 : struct sk_buff *skb1;
381 : :
382 [ # # ]: 0 : skb_queue_walk(&sk->sk_write_queue, skb1) {
383 : 0 : csum = csum_add(csum, skb1->csum);
384 : : }
385 : 0 : csum = csum_partial_copy_nocheck((void *)&icmp_param->data,
386 : : (char *)icmph,
387 : : icmp_param->head_len, csum);
388 : 0 : icmph->checksum = csum_fold(csum);
389 : 0 : skb->ip_summed = CHECKSUM_NONE;
390 : 0 : ip_push_pending_frames(sk, fl4);
391 : : }
392 : 0 : }
393 : :
394 : : /*
395 : : * Driving logic for building and sending ICMP messages.
396 : : */
397 : :
398 : 0 : static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
399 : : {
400 : 0 : struct ipcm_cookie ipc;
401 [ # # ]: 0 : struct rtable *rt = skb_rtable(skb);
402 [ # # ]: 0 : struct net *net = dev_net(rt->dst.dev);
403 : 0 : struct flowi4 fl4;
404 : 0 : struct sock *sk;
405 : 0 : struct inet_sock *inet;
406 : 0 : __be32 daddr, saddr;
407 [ # # ]: 0 : u32 mark = IP4_REPLY_MARK(net, skb->mark);
408 : 0 : int type = icmp_param->data.icmph.type;
409 : 0 : int code = icmp_param->data.icmph.code;
410 : :
411 [ # # ]: 0 : if (ip_options_echo(net, &icmp_param->replyopts.opt.opt, skb))
412 : 0 : return;
413 : :
414 : : /* Needed by both icmp_global_allow and icmp_xmit_lock */
415 : 0 : local_bh_disable();
416 : :
417 : : /* global icmp_msgs_per_sec */
418 [ # # ]: 0 : if (!icmpv4_global_allow(net, type, code))
419 : 0 : goto out_bh_enable;
420 : :
421 : 0 : sk = icmp_xmit_lock(net);
422 [ # # ]: 0 : if (!sk)
423 : 0 : goto out_bh_enable;
424 : 0 : inet = inet_sk(sk);
425 : :
426 : 0 : icmp_param->data.icmph.checksum = 0;
427 : :
428 : 0 : ipcm_init(&ipc);
429 : 0 : inet->tos = ip_hdr(skb)->tos;
430 : 0 : sk->sk_mark = mark;
431 : 0 : daddr = ipc.addr = ip_hdr(skb)->saddr;
432 : 0 : saddr = fib_compute_spec_dst(skb);
433 : :
434 [ # # ]: 0 : if (icmp_param->replyopts.opt.opt.optlen) {
435 : 0 : ipc.opt = &icmp_param->replyopts.opt;
436 [ # # ]: 0 : if (ipc.opt->opt.srr)
437 : 0 : daddr = icmp_param->replyopts.opt.opt.faddr;
438 : : }
439 : 0 : memset(&fl4, 0, sizeof(fl4));
440 : 0 : fl4.daddr = daddr;
441 : 0 : fl4.saddr = saddr;
442 : 0 : fl4.flowi4_mark = mark;
443 : 0 : fl4.flowi4_uid = sock_net_uid(net, NULL);
444 : 0 : fl4.flowi4_tos = RT_TOS(ip_hdr(skb)->tos);
445 : 0 : fl4.flowi4_proto = IPPROTO_ICMP;
446 : 0 : fl4.flowi4_oif = l3mdev_master_ifindex(skb->dev);
447 : 0 : security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
448 : 0 : rt = ip_route_output_key(net, &fl4);
449 [ # # ]: 0 : if (IS_ERR(rt))
450 : 0 : goto out_unlock;
451 [ # # ]: 0 : if (icmpv4_xrlim_allow(net, rt, &fl4, type, code))
452 : 0 : icmp_push_reply(icmp_param, &fl4, &ipc, &rt);
453 : 0 : ip_rt_put(rt);
454 : 0 : out_unlock:
455 : 0 : icmp_xmit_unlock(sk);
456 : 0 : out_bh_enable:
457 : 0 : local_bh_enable();
458 : : }
459 : :
460 : 0 : static struct rtable *icmp_route_lookup(struct net *net,
461 : : struct flowi4 *fl4,
462 : : struct sk_buff *skb_in,
463 : : const struct iphdr *iph,
464 : : __be32 saddr, u8 tos, u32 mark,
465 : : int type, int code,
466 : : struct icmp_bxm *param)
467 : : {
468 : 0 : struct rtable *rt, *rt2;
469 : 0 : struct flowi4 fl4_dec;
470 : 0 : int err;
471 : :
472 : 0 : memset(fl4, 0, sizeof(*fl4));
473 : 0 : fl4->daddr = (param->replyopts.opt.opt.srr ?
474 [ # # ]: 0 : param->replyopts.opt.opt.faddr : iph->saddr);
475 : 0 : fl4->saddr = saddr;
476 : 0 : fl4->flowi4_mark = mark;
477 : 0 : fl4->flowi4_uid = sock_net_uid(net, NULL);
478 : 0 : fl4->flowi4_tos = RT_TOS(tos);
479 : 0 : fl4->flowi4_proto = IPPROTO_ICMP;
480 : 0 : fl4->fl4_icmp_type = type;
481 : 0 : fl4->fl4_icmp_code = code;
482 : 0 : fl4->flowi4_oif = l3mdev_master_ifindex(skb_dst(skb_in)->dev);
483 : :
484 : 0 : security_skb_classify_flow(skb_in, flowi4_to_flowi(fl4));
485 : 0 : rt = ip_route_output_key_hash(net, fl4, skb_in);
486 [ # # ]: 0 : if (IS_ERR(rt))
487 : : return rt;
488 : :
489 : : /* No need to clone since we're just using its address. */
490 : 0 : rt2 = rt;
491 : :
492 : 0 : rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
493 : : flowi4_to_flowi(fl4), NULL, 0);
494 [ # # ]: 0 : if (!IS_ERR(rt)) {
495 [ # # ]: 0 : if (rt != rt2)
496 : : return rt;
497 [ # # ]: 0 : } else if (PTR_ERR(rt) == -EPERM) {
498 : : rt = NULL;
499 : : } else
500 : : return rt;
501 : :
502 : 0 : err = xfrm_decode_session_reverse(skb_in, flowi4_to_flowi(&fl4_dec), AF_INET);
503 [ # # ]: 0 : if (err)
504 : 0 : goto relookup_failed;
505 : :
506 [ # # ]: 0 : if (inet_addr_type_dev_table(net, skb_dst(skb_in)->dev,
507 : : fl4_dec.saddr) == RTN_LOCAL) {
508 : 0 : rt2 = __ip_route_output_key(net, &fl4_dec);
509 [ # # ]: 0 : if (IS_ERR(rt2))
510 : 0 : err = PTR_ERR(rt2);
511 : : } else {
512 : 0 : struct flowi4 fl4_2 = {};
513 : 0 : unsigned long orefdst;
514 : :
515 : 0 : fl4_2.daddr = fl4_dec.saddr;
516 : 0 : rt2 = ip_route_output_key(net, &fl4_2);
517 [ # # ]: 0 : if (IS_ERR(rt2)) {
518 : 0 : err = PTR_ERR(rt2);
519 : 0 : goto relookup_failed;
520 : : }
521 : : /* Ugh! */
522 : 0 : orefdst = skb_in->_skb_refdst; /* save old refdst */
523 : 0 : skb_dst_set(skb_in, NULL);
524 : 0 : err = ip_route_input(skb_in, fl4_dec.daddr, fl4_dec.saddr,
525 : : RT_TOS(tos), rt2->dst.dev);
526 : :
527 : 0 : dst_release(&rt2->dst);
528 : 0 : rt2 = skb_rtable(skb_in);
529 : 0 : skb_in->_skb_refdst = orefdst; /* restore old refdst */
530 : : }
531 : :
532 [ # # ]: 0 : if (err)
533 : 0 : goto relookup_failed;
534 : :
535 : 0 : rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst,
536 : : flowi4_to_flowi(&fl4_dec), NULL,
537 : : XFRM_LOOKUP_ICMP);
538 [ # # ]: 0 : if (!IS_ERR(rt2)) {
539 : 0 : dst_release(&rt->dst);
540 : 0 : memcpy(fl4, &fl4_dec, sizeof(*fl4));
541 : 0 : rt = rt2;
542 [ # # ]: 0 : } else if (PTR_ERR(rt2) == -EPERM) {
543 [ # # ]: 0 : if (rt)
544 : 0 : dst_release(&rt->dst);
545 : 0 : return rt2;
546 : : } else {
547 : 0 : err = PTR_ERR(rt2);
548 : 0 : goto relookup_failed;
549 : : }
550 : 0 : return rt;
551 : :
552 : 0 : relookup_failed:
553 [ # # ]: 0 : if (rt)
554 : : return rt;
555 : 0 : return ERR_PTR(err);
556 : : }
557 : :
558 : : /*
559 : : * Send an ICMP message in response to a situation
560 : : *
561 : : * RFC 1122: 3.2.2 MUST send at least the IP header and 8 bytes of header.
562 : : * MAY send more (we do).
563 : : * MUST NOT change this header information.
564 : : * MUST NOT reply to a multicast/broadcast IP address.
565 : : * MUST NOT reply to a multicast/broadcast MAC address.
566 : : * MUST reply to only the first fragment.
567 : : */
568 : :
569 : 0 : void __icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info,
570 : : const struct ip_options *opt)
571 : : {
572 : 0 : struct iphdr *iph;
573 : 0 : int room;
574 : 0 : struct icmp_bxm icmp_param;
575 [ # # ]: 0 : struct rtable *rt = skb_rtable(skb_in);
576 : 0 : struct ipcm_cookie ipc;
577 : 0 : struct flowi4 fl4;
578 : 0 : __be32 saddr;
579 : 0 : u8 tos;
580 : 0 : u32 mark;
581 : 0 : struct net *net;
582 : 0 : struct sock *sk;
583 : :
584 [ # # ]: 0 : if (!rt)
585 : 0 : goto out;
586 : :
587 [ # # ]: 0 : if (rt->dst.dev)
588 : 0 : net = dev_net(rt->dst.dev);
589 [ # # ]: 0 : else if (skb_in->dev)
590 : 0 : net = dev_net(skb_in->dev);
591 : : else
592 : 0 : goto out;
593 : :
594 : : /*
595 : : * Find the original header. It is expected to be valid, of course.
596 : : * Check this, icmp_send is called from the most obscure devices
597 : : * sometimes.
598 : : */
599 [ # # ]: 0 : iph = ip_hdr(skb_in);
600 : :
601 [ # # # # ]: 0 : if ((u8 *)iph < skb_in->head ||
602 : 0 : (skb_network_header(skb_in) + sizeof(*iph)) >
603 [ # # ]: 0 : skb_tail_pointer(skb_in))
604 : 0 : goto out;
605 : :
606 : : /*
607 : : * No replies to physical multicast/broadcast
608 : : */
609 [ # # ]: 0 : if (skb_in->pkt_type != PACKET_HOST)
610 : 0 : goto out;
611 : :
612 : : /*
613 : : * Now check at the protocol level
614 : : */
615 [ # # ]: 0 : if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
616 : 0 : goto out;
617 : :
618 : : /*
619 : : * Only reply to fragment 0. We byte re-order the constant
620 : : * mask for efficiency.
621 : : */
622 [ # # ]: 0 : if (iph->frag_off & htons(IP_OFFSET))
623 : 0 : goto out;
624 : :
625 : : /*
626 : : * If we send an ICMP error to an ICMP error a mess would result..
627 : : */
628 [ # # ]: 0 : if (icmp_pointers[type].error) {
629 : : /*
630 : : * We are an error, check if we are replying to an
631 : : * ICMP error
632 : : */
633 [ # # ]: 0 : if (iph->protocol == IPPROTO_ICMP) {
634 : 0 : u8 _inner_type, *itp;
635 : :
636 : 0 : itp = skb_header_pointer(skb_in,
637 : : skb_network_header(skb_in) +
638 : 0 : (iph->ihl << 2) +
639 : : offsetof(struct icmphdr,
640 : 0 : type) -
641 : 0 : skb_in->data,
642 : : sizeof(_inner_type),
643 : : &_inner_type);
644 [ # # ]: 0 : if (!itp)
645 : 0 : goto out;
646 : :
647 : : /*
648 : : * Assume any unknown ICMP type is an error. This
649 : : * isn't specified by the RFC, but think about it..
650 : : */
651 [ # # ]: 0 : if (*itp > NR_ICMP_TYPES ||
652 [ # # ]: 0 : icmp_pointers[*itp].error)
653 : 0 : goto out;
654 : : }
655 : : }
656 : :
657 : : /* Needed by both icmp_global_allow and icmp_xmit_lock */
658 : 0 : local_bh_disable();
659 : :
660 : : /* Check global sysctl_icmp_msgs_per_sec ratelimit, unless
661 : : * incoming dev is loopback. If outgoing dev change to not be
662 : : * loopback, then peer ratelimit still work (in icmpv4_xrlim_allow)
663 : : */
664 [ # # # # : 0 : if (!(skb_in->dev && (skb_in->dev->flags&IFF_LOOPBACK)) &&
# # ]
665 : 0 : !icmpv4_global_allow(net, type, code))
666 : 0 : goto out_bh_enable;
667 : :
668 : 0 : sk = icmp_xmit_lock(net);
669 [ # # ]: 0 : if (!sk)
670 : 0 : goto out_bh_enable;
671 : :
672 : : /*
673 : : * Construct source address and options.
674 : : */
675 : :
676 : 0 : saddr = iph->daddr;
677 [ # # ]: 0 : if (!(rt->rt_flags & RTCF_LOCAL)) {
678 : 0 : struct net_device *dev = NULL;
679 : :
680 : 0 : rcu_read_lock();
681 [ # # ]: 0 : if (rt_is_input_route(rt) &&
682 [ # # ]: 0 : net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr)
683 [ # # ]: 0 : dev = dev_get_by_index_rcu(net, inet_iif(skb_in));
684 : :
685 [ # # ]: 0 : if (dev)
686 : 0 : saddr = inet_select_addr(dev, iph->saddr,
687 : : RT_SCOPE_LINK);
688 : : else
689 : : saddr = 0;
690 : 0 : rcu_read_unlock();
691 : : }
692 : :
693 [ # # ]: 0 : tos = icmp_pointers[type].error ? ((iph->tos & IPTOS_TOS_MASK) |
694 : : IPTOS_PREC_INTERNETCONTROL) :
695 : : iph->tos;
696 [ # # ]: 0 : mark = IP4_REPLY_MARK(net, skb_in->mark);
697 : :
698 [ # # ]: 0 : if (__ip_options_echo(net, &icmp_param.replyopts.opt.opt, skb_in, opt))
699 : 0 : goto out_unlock;
700 : :
701 : :
702 : : /*
703 : : * Prepare data for ICMP header.
704 : : */
705 : :
706 : 0 : icmp_param.data.icmph.type = type;
707 : 0 : icmp_param.data.icmph.code = code;
708 : 0 : icmp_param.data.icmph.un.gateway = info;
709 : 0 : icmp_param.data.icmph.checksum = 0;
710 : 0 : icmp_param.skb = skb_in;
711 : 0 : icmp_param.offset = skb_network_offset(skb_in);
712 : 0 : inet_sk(sk)->tos = tos;
713 : 0 : sk->sk_mark = mark;
714 : 0 : ipcm_init(&ipc);
715 : 0 : ipc.addr = iph->saddr;
716 : 0 : ipc.opt = &icmp_param.replyopts.opt;
717 : :
718 : 0 : rt = icmp_route_lookup(net, &fl4, skb_in, iph, saddr, tos, mark,
719 : : type, code, &icmp_param);
720 [ # # ]: 0 : if (IS_ERR(rt))
721 : 0 : goto out_unlock;
722 : :
723 : : /* peer icmp_ratelimit */
724 [ # # ]: 0 : if (!icmpv4_xrlim_allow(net, rt, &fl4, type, code))
725 : 0 : goto ende;
726 : :
727 : : /* RFC says return as much as we can without exceeding 576 bytes. */
728 : :
729 : 0 : room = dst_mtu(&rt->dst);
730 : 0 : if (room > 576)
731 : : room = 576;
732 : 0 : room -= sizeof(struct iphdr) + icmp_param.replyopts.opt.opt.optlen;
733 : 0 : room -= sizeof(struct icmphdr);
734 : :
735 : 0 : icmp_param.data_len = skb_in->len - icmp_param.offset;
736 [ # # ]: 0 : if (icmp_param.data_len > room)
737 : 0 : icmp_param.data_len = room;
738 : 0 : icmp_param.head_len = sizeof(struct icmphdr);
739 : :
740 : 0 : icmp_push_reply(&icmp_param, &fl4, &ipc, &rt);
741 : 0 : ende:
742 : 0 : ip_rt_put(rt);
743 : 0 : out_unlock:
744 : 0 : icmp_xmit_unlock(sk);
745 : 0 : out_bh_enable:
746 : 0 : local_bh_enable();
747 : 0 : out:;
748 : 0 : }
749 : : EXPORT_SYMBOL(__icmp_send);
750 : :
751 : : #if IS_ENABLED(CONFIG_NF_NAT)
752 : : #include <net/netfilter/nf_conntrack.h>
753 : 0 : void icmp_ndo_send(struct sk_buff *skb_in, int type, int code, __be32 info)
754 : : {
755 : 0 : struct sk_buff *cloned_skb = NULL;
756 : 0 : enum ip_conntrack_info ctinfo;
757 : 0 : struct nf_conn *ct;
758 : 0 : __be32 orig_ip;
759 : :
760 [ # # ]: 0 : ct = nf_ct_get(skb_in, &ctinfo);
761 [ # # # # ]: 0 : if (!ct || !(ct->status & IPS_SRC_NAT)) {
762 : 0 : icmp_send(skb_in, type, code, info);
763 : 0 : return;
764 : : }
765 : :
766 [ # # ]: 0 : if (skb_shared(skb_in))
767 : 0 : skb_in = cloned_skb = skb_clone(skb_in, GFP_ATOMIC);
768 : :
769 [ # # # # : 0 : if (unlikely(!skb_in || skb_network_header(skb_in) < skb_in->head ||
# # # # ]
770 : : (skb_network_header(skb_in) + sizeof(struct iphdr)) >
771 : : skb_tail_pointer(skb_in) || skb_ensure_writable(skb_in,
772 : : skb_network_offset(skb_in) + sizeof(struct iphdr))))
773 : 0 : goto out;
774 : :
775 : 0 : orig_ip = ip_hdr(skb_in)->saddr;
776 : 0 : ip_hdr(skb_in)->saddr = ct->tuplehash[0].tuple.src.u3.ip;
777 : 0 : icmp_send(skb_in, type, code, info);
778 : 0 : ip_hdr(skb_in)->saddr = orig_ip;
779 : 0 : out:
780 : 0 : consume_skb(cloned_skb);
781 : : }
782 : : EXPORT_SYMBOL(icmp_ndo_send);
783 : : #endif
784 : :
785 : 0 : static void icmp_socket_deliver(struct sk_buff *skb, u32 info)
786 : : {
787 : 0 : const struct iphdr *iph = (const struct iphdr *) skb->data;
788 : 0 : const struct net_protocol *ipprot;
789 : 0 : int protocol = iph->protocol;
790 : :
791 : : /* Checkin full IP header plus 8 bytes of protocol to
792 : : * avoid additional coding at protocol handlers.
793 : : */
794 [ # # ]: 0 : if (!pskb_may_pull(skb, iph->ihl * 4 + 8)) {
795 : 0 : __ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
796 : 0 : return;
797 : : }
798 : :
799 : 0 : raw_icmp_error(skb, protocol, info);
800 : :
801 [ # # ]: 0 : ipprot = rcu_dereference(inet_protos[protocol]);
802 [ # # # # ]: 0 : if (ipprot && ipprot->err_handler)
803 : 0 : ipprot->err_handler(skb, info);
804 : : }
805 : :
806 : 0 : static bool icmp_tag_validation(int proto)
807 : : {
808 : 0 : bool ok;
809 : :
810 : 0 : rcu_read_lock();
811 : 0 : ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation;
812 : 0 : rcu_read_unlock();
813 : 0 : return ok;
814 : : }
815 : :
816 : : /*
817 : : * Handle ICMP_DEST_UNREACH, ICMP_TIME_EXCEEDED, ICMP_QUENCH, and
818 : : * ICMP_PARAMETERPROB.
819 : : */
820 : :
821 : 0 : static bool icmp_unreach(struct sk_buff *skb)
822 : : {
823 : 0 : const struct iphdr *iph;
824 : 0 : struct icmphdr *icmph;
825 : 0 : struct net *net;
826 : 0 : u32 info = 0;
827 : :
828 : 0 : net = dev_net(skb_dst(skb)->dev);
829 : :
830 : : /*
831 : : * Incomplete header ?
832 : : * Only checks for the IP header, there should be an
833 : : * additional check for longer headers in upper levels.
834 : : */
835 : :
836 [ # # ]: 0 : if (!pskb_may_pull(skb, sizeof(struct iphdr)))
837 : 0 : goto out_err;
838 : :
839 [ # # ]: 0 : icmph = icmp_hdr(skb);
840 : 0 : iph = (const struct iphdr *)skb->data;
841 : :
842 [ # # ]: 0 : if (iph->ihl < 5) /* Mangled header, drop. */
843 : 0 : goto out_err;
844 : :
845 [ # # # # ]: 0 : switch (icmph->type) {
846 : 0 : case ICMP_DEST_UNREACH:
847 [ # # ]: 0 : switch (icmph->code & 15) {
848 : : case ICMP_NET_UNREACH:
849 : : case ICMP_HOST_UNREACH:
850 : : case ICMP_PROT_UNREACH:
851 : : case ICMP_PORT_UNREACH:
852 : : break;
853 : 0 : case ICMP_FRAG_NEEDED:
854 : : /* for documentation of the ip_no_pmtu_disc
855 : : * values please see
856 : : * Documentation/networking/ip-sysctl.txt
857 : : */
858 [ # # # # ]: 0 : switch (net->ipv4.sysctl_ip_no_pmtu_disc) {
859 : : default:
860 : : net_dbg_ratelimited("%pI4: fragmentation needed and DF set\n",
861 : : &iph->daddr);
862 : : break;
863 : 0 : case 2:
864 : 0 : goto out;
865 : 0 : case 3:
866 [ # # ]: 0 : if (!icmp_tag_validation(iph->protocol))
867 : 0 : goto out;
868 : : /* fall through */
869 : : case 0:
870 : 0 : info = ntohs(icmph->un.frag.mtu);
871 : : }
872 : : break;
873 : : case ICMP_SR_FAILED:
874 : : net_dbg_ratelimited("%pI4: Source Route Failed\n",
875 : : &iph->daddr);
876 : : break;
877 : : default:
878 : : break;
879 : : }
880 [ # # ]: 0 : if (icmph->code > NR_ICMP_UNREACH)
881 : 0 : goto out;
882 : : break;
883 : 0 : case ICMP_PARAMETERPROB:
884 : 0 : info = ntohl(icmph->un.gateway) >> 24;
885 : 0 : break;
886 : : case ICMP_TIME_EXCEEDED:
887 [ # # ]: 0 : __ICMP_INC_STATS(net, ICMP_MIB_INTIMEEXCDS);
888 [ # # ]: 0 : if (icmph->code == ICMP_EXC_FRAGTIME)
889 : 0 : goto out;
890 : : break;
891 : : }
892 : :
893 : : /*
894 : : * Throw it at our lower layers
895 : : *
896 : : * RFC 1122: 3.2.2 MUST extract the protocol ID from the passed
897 : : * header.
898 : : * RFC 1122: 3.2.2.1 MUST pass ICMP unreach messages to the
899 : : * transport layer.
900 : : * RFC 1122: 3.2.2.2 MUST pass ICMP time expired messages to
901 : : * transport layer.
902 : : */
903 : :
904 : : /*
905 : : * Check the other end isn't violating RFC 1122. Some routers send
906 : : * bogus responses to broadcast frames. If you see this message
907 : : * first check your netmask matches at both ends, if it does then
908 : : * get the other vendor to fix their kit.
909 : : */
910 : :
911 [ # # # # ]: 0 : if (!net->ipv4.sysctl_icmp_ignore_bogus_error_responses &&
912 : 0 : inet_addr_type_dev_table(net, skb->dev, iph->daddr) == RTN_BROADCAST) {
913 [ # # ]: 0 : net_warn_ratelimited("%pI4 sent an invalid ICMP type %u, code %u error to a broadcast: %pI4 on %s\n",
914 : : &ip_hdr(skb)->saddr,
915 : : icmph->type, icmph->code,
916 : : &iph->daddr, skb->dev->name);
917 : 0 : goto out;
918 : : }
919 : :
920 : 0 : icmp_socket_deliver(skb, info);
921 : :
922 : : out:
923 : : return true;
924 : 0 : out_err:
925 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
926 : 0 : return false;
927 : : }
928 : :
929 : :
930 : : /*
931 : : * Handle ICMP_REDIRECT.
932 : : */
933 : :
934 : 0 : static bool icmp_redirect(struct sk_buff *skb)
935 : : {
936 [ # # ]: 0 : if (skb->len < sizeof(struct iphdr)) {
937 : 0 : __ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
938 : 0 : return false;
939 : : }
940 : :
941 [ # # ]: 0 : if (!pskb_may_pull(skb, sizeof(struct iphdr))) {
942 : : /* there aught to be a stat */
943 : : return false;
944 : : }
945 : :
946 : 0 : icmp_socket_deliver(skb, ntohl(icmp_hdr(skb)->un.gateway));
947 : 0 : return true;
948 : : }
949 : :
950 : : /*
951 : : * Handle ICMP_ECHO ("ping") requests.
952 : : *
953 : : * RFC 1122: 3.2.2.6 MUST have an echo server that answers ICMP echo
954 : : * requests.
955 : : * RFC 1122: 3.2.2.6 Data received in the ICMP_ECHO request MUST be
956 : : * included in the reply.
957 : : * RFC 1812: 4.3.3.6 SHOULD have a config option for silently ignoring
958 : : * echo requests, MUST have default=NOT.
959 : : * See also WRT handling of options once they are done and working.
960 : : */
961 : :
962 : 0 : static bool icmp_echo(struct sk_buff *skb)
963 : : {
964 : 0 : struct net *net;
965 : :
966 [ # # ]: 0 : net = dev_net(skb_dst(skb)->dev);
967 [ # # ]: 0 : if (!net->ipv4.sysctl_icmp_echo_ignore_all) {
968 : 0 : struct icmp_bxm icmp_param;
969 : :
970 : 0 : icmp_param.data.icmph = *icmp_hdr(skb);
971 : 0 : icmp_param.data.icmph.type = ICMP_ECHOREPLY;
972 : 0 : icmp_param.skb = skb;
973 : 0 : icmp_param.offset = 0;
974 : 0 : icmp_param.data_len = skb->len;
975 : 0 : icmp_param.head_len = sizeof(struct icmphdr);
976 : 0 : icmp_reply(&icmp_param, skb);
977 : : }
978 : : /* should there be an ICMP stat for ignored echos? */
979 : 0 : return true;
980 : : }
981 : :
982 : : /*
983 : : * Handle ICMP Timestamp requests.
984 : : * RFC 1122: 3.2.2.8 MAY implement ICMP timestamp requests.
985 : : * SHOULD be in the kernel for minimum random latency.
986 : : * MUST be accurate to a few minutes.
987 : : * MUST be updated at least at 15Hz.
988 : : */
989 : 0 : static bool icmp_timestamp(struct sk_buff *skb)
990 : : {
991 : 0 : struct icmp_bxm icmp_param;
992 : : /*
993 : : * Too short.
994 : : */
995 [ # # ]: 0 : if (skb->len < 4)
996 : 0 : goto out_err;
997 : :
998 : : /*
999 : : * Fill in the current time as ms since midnight UT:
1000 : : */
1001 : 0 : icmp_param.data.times[1] = inet_current_timestamp();
1002 : 0 : icmp_param.data.times[2] = icmp_param.data.times[1];
1003 : :
1004 [ # # ]: 0 : BUG_ON(skb_copy_bits(skb, 0, &icmp_param.data.times[0], 4));
1005 : :
1006 : 0 : icmp_param.data.icmph = *icmp_hdr(skb);
1007 : 0 : icmp_param.data.icmph.type = ICMP_TIMESTAMPREPLY;
1008 : 0 : icmp_param.data.icmph.code = 0;
1009 : 0 : icmp_param.skb = skb;
1010 : 0 : icmp_param.offset = 0;
1011 : 0 : icmp_param.data_len = 0;
1012 : 0 : icmp_param.head_len = sizeof(struct icmphdr) + 12;
1013 : 0 : icmp_reply(&icmp_param, skb);
1014 : 0 : return true;
1015 : :
1016 : : out_err:
1017 : 0 : __ICMP_INC_STATS(dev_net(skb_dst(skb)->dev), ICMP_MIB_INERRORS);
1018 : 0 : return false;
1019 : : }
1020 : :
1021 : 0 : static bool icmp_discard(struct sk_buff *skb)
1022 : : {
1023 : : /* pretend it was a success */
1024 : 0 : return true;
1025 : : }
1026 : :
1027 : : /*
1028 : : * Deal with incoming ICMP packets.
1029 : : */
1030 : 0 : int icmp_rcv(struct sk_buff *skb)
1031 : : {
1032 : 0 : struct icmphdr *icmph;
1033 : 0 : struct rtable *rt = skb_rtable(skb);
1034 : 0 : struct net *net = dev_net(rt->dst.dev);
1035 : 0 : bool success;
1036 : :
1037 [ # # ]: 0 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1038 [ # # ]: 0 : struct sec_path *sp = skb_sec_path(skb);
1039 : 0 : int nh;
1040 : :
1041 [ # # # # ]: 0 : if (!(sp && sp->xvec[sp->len - 1]->props.flags &
1042 : : XFRM_STATE_ICMP))
1043 : 0 : goto drop;
1044 : :
1045 [ # # ]: 0 : if (!pskb_may_pull(skb, sizeof(*icmph) + sizeof(struct iphdr)))
1046 : 0 : goto drop;
1047 : :
1048 : 0 : nh = skb_network_offset(skb);
1049 : 0 : skb_set_network_header(skb, sizeof(*icmph));
1050 : :
1051 [ # # ]: 0 : if (!xfrm4_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
1052 : 0 : goto drop;
1053 : :
1054 : 0 : skb_set_network_header(skb, nh);
1055 : : }
1056 : :
1057 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INMSGS);
1058 : :
1059 [ # # # # ]: 0 : if (skb_checksum_simple_validate(skb))
1060 : 0 : goto csum_error;
1061 : :
1062 [ # # # # ]: 0 : if (!pskb_pull(skb, sizeof(*icmph)))
1063 : 0 : goto error;
1064 : :
1065 : 0 : icmph = icmp_hdr(skb);
1066 : :
1067 : 0 : ICMPMSGIN_INC_STATS(net, icmph->type);
1068 : : /*
1069 : : * 18 is the highest 'known' ICMP type. Anything else is a mystery
1070 : : *
1071 : : * RFC 1122: 3.2.2 Unknown ICMP messages types MUST be silently
1072 : : * discarded.
1073 : : */
1074 [ # # ]: 0 : if (icmph->type > NR_ICMP_TYPES)
1075 : 0 : goto error;
1076 : :
1077 : :
1078 : : /*
1079 : : * Parse the ICMP message
1080 : : */
1081 : :
1082 [ # # ]: 0 : if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1083 : : /*
1084 : : * RFC 1122: 3.2.2.6 An ICMP_ECHO to broadcast MAY be
1085 : : * silently ignored (we let user decide with a sysctl).
1086 : : * RFC 1122: 3.2.2.8 An ICMP_TIMESTAMP MAY be silently
1087 : : * discarded if to broadcast/multicast.
1088 : : */
1089 [ # # ]: 0 : if ((icmph->type == ICMP_ECHO ||
1090 : 0 : icmph->type == ICMP_TIMESTAMP) &&
1091 [ # # ]: 0 : net->ipv4.sysctl_icmp_echo_ignore_broadcasts) {
1092 : 0 : goto error;
1093 : : }
1094 [ # # ]: 0 : if (icmph->type != ICMP_ECHO &&
1095 [ # # ]: 0 : icmph->type != ICMP_TIMESTAMP &&
1096 [ # # ]: 0 : icmph->type != ICMP_ADDRESS &&
1097 : : icmph->type != ICMP_ADDRESSREPLY) {
1098 : 0 : goto error;
1099 : : }
1100 : : }
1101 : :
1102 : 0 : success = icmp_pointers[icmph->type].handler(skb);
1103 : :
1104 [ # # ]: 0 : if (success) {
1105 : 0 : consume_skb(skb);
1106 : 0 : return NET_RX_SUCCESS;
1107 : : }
1108 : :
1109 : 0 : drop:
1110 : 0 : kfree_skb(skb);
1111 : 0 : return NET_RX_DROP;
1112 : : csum_error:
1113 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_CSUMERRORS);
1114 : 0 : error:
1115 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
1116 : 0 : goto drop;
1117 : : }
1118 : :
1119 : 0 : int icmp_err(struct sk_buff *skb, u32 info)
1120 : : {
1121 : 0 : struct iphdr *iph = (struct iphdr *)skb->data;
1122 : 0 : int offset = iph->ihl<<2;
1123 : 0 : struct icmphdr *icmph = (struct icmphdr *)(skb->data + offset);
1124 [ # # ]: 0 : int type = icmp_hdr(skb)->type;
1125 : 0 : int code = icmp_hdr(skb)->code;
1126 [ # # ]: 0 : struct net *net = dev_net(skb->dev);
1127 : :
1128 : : /*
1129 : : * Use ping_err to handle all icmp errors except those
1130 : : * triggered by ICMP_ECHOREPLY which sent from kernel.
1131 : : */
1132 [ # # ]: 0 : if (icmph->type != ICMP_ECHOREPLY) {
1133 : 0 : ping_err(skb, offset, info);
1134 : 0 : return 0;
1135 : : }
1136 : :
1137 [ # # ]: 0 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
1138 : 0 : ipv4_update_pmtu(skb, net, info, 0, IPPROTO_ICMP);
1139 [ # # ]: 0 : else if (type == ICMP_REDIRECT)
1140 : 0 : ipv4_redirect(skb, net, 0, IPPROTO_ICMP);
1141 : :
1142 : : return 0;
1143 : : }
1144 : :
1145 : : /*
1146 : : * This table is the definition of how we handle ICMP.
1147 : : */
1148 : : static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
1149 : : [ICMP_ECHOREPLY] = {
1150 : : .handler = ping_rcv,
1151 : : },
1152 : : [1] = {
1153 : : .handler = icmp_discard,
1154 : : .error = 1,
1155 : : },
1156 : : [2] = {
1157 : : .handler = icmp_discard,
1158 : : .error = 1,
1159 : : },
1160 : : [ICMP_DEST_UNREACH] = {
1161 : : .handler = icmp_unreach,
1162 : : .error = 1,
1163 : : },
1164 : : [ICMP_SOURCE_QUENCH] = {
1165 : : .handler = icmp_unreach,
1166 : : .error = 1,
1167 : : },
1168 : : [ICMP_REDIRECT] = {
1169 : : .handler = icmp_redirect,
1170 : : .error = 1,
1171 : : },
1172 : : [6] = {
1173 : : .handler = icmp_discard,
1174 : : .error = 1,
1175 : : },
1176 : : [7] = {
1177 : : .handler = icmp_discard,
1178 : : .error = 1,
1179 : : },
1180 : : [ICMP_ECHO] = {
1181 : : .handler = icmp_echo,
1182 : : },
1183 : : [9] = {
1184 : : .handler = icmp_discard,
1185 : : .error = 1,
1186 : : },
1187 : : [10] = {
1188 : : .handler = icmp_discard,
1189 : : .error = 1,
1190 : : },
1191 : : [ICMP_TIME_EXCEEDED] = {
1192 : : .handler = icmp_unreach,
1193 : : .error = 1,
1194 : : },
1195 : : [ICMP_PARAMETERPROB] = {
1196 : : .handler = icmp_unreach,
1197 : : .error = 1,
1198 : : },
1199 : : [ICMP_TIMESTAMP] = {
1200 : : .handler = icmp_timestamp,
1201 : : },
1202 : : [ICMP_TIMESTAMPREPLY] = {
1203 : : .handler = icmp_discard,
1204 : : },
1205 : : [ICMP_INFO_REQUEST] = {
1206 : : .handler = icmp_discard,
1207 : : },
1208 : : [ICMP_INFO_REPLY] = {
1209 : : .handler = icmp_discard,
1210 : : },
1211 : : [ICMP_ADDRESS] = {
1212 : : .handler = icmp_discard,
1213 : : },
1214 : : [ICMP_ADDRESSREPLY] = {
1215 : : .handler = icmp_discard,
1216 : : },
1217 : : };
1218 : :
1219 : 0 : static void __net_exit icmp_sk_exit(struct net *net)
1220 : : {
1221 : 0 : int i;
1222 : :
1223 [ # # ]: 0 : for_each_possible_cpu(i)
1224 [ # # ]: 0 : inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.icmp_sk, i));
1225 : 0 : free_percpu(net->ipv4.icmp_sk);
1226 : 0 : net->ipv4.icmp_sk = NULL;
1227 : 0 : }
1228 : :
1229 : 3 : static int __net_init icmp_sk_init(struct net *net)
1230 : : {
1231 : 3 : int i, err;
1232 : :
1233 : 3 : net->ipv4.icmp_sk = alloc_percpu(struct sock *);
1234 [ + - ]: 3 : if (!net->ipv4.icmp_sk)
1235 : : return -ENOMEM;
1236 : :
1237 [ + + ]: 6 : for_each_possible_cpu(i) {
1238 : 3 : struct sock *sk;
1239 : :
1240 : 3 : err = inet_ctl_sock_create(&sk, PF_INET,
1241 : : SOCK_RAW, IPPROTO_ICMP, net);
1242 [ - + ]: 3 : if (err < 0)
1243 : 0 : goto fail;
1244 : :
1245 : 3 : *per_cpu_ptr(net->ipv4.icmp_sk, i) = sk;
1246 : :
1247 : : /* Enough space for 2 64K ICMP packets, including
1248 : : * sk_buff/skb_shared_info struct overhead.
1249 : : */
1250 : 3 : sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
1251 : :
1252 : : /*
1253 : : * Speedup sock_wfree()
1254 : : */
1255 : 3 : sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1256 : 3 : inet_sk(sk)->pmtudisc = IP_PMTUDISC_DONT;
1257 : : }
1258 : :
1259 : : /* Control parameters for ECHO replies. */
1260 : 3 : net->ipv4.sysctl_icmp_echo_ignore_all = 0;
1261 : 3 : net->ipv4.sysctl_icmp_echo_ignore_broadcasts = 1;
1262 : :
1263 : : /* Control parameter - ignore bogus broadcast responses? */
1264 : 3 : net->ipv4.sysctl_icmp_ignore_bogus_error_responses = 1;
1265 : :
1266 : : /*
1267 : : * Configurable global rate limit.
1268 : : *
1269 : : * ratelimit defines tokens/packet consumed for dst->rate_token
1270 : : * bucket ratemask defines which icmp types are ratelimited by
1271 : : * setting it's bit position.
1272 : : *
1273 : : * default:
1274 : : * dest unreachable (3), source quench (4),
1275 : : * time exceeded (11), parameter problem (12)
1276 : : */
1277 : :
1278 : 3 : net->ipv4.sysctl_icmp_ratelimit = 1 * HZ;
1279 : 3 : net->ipv4.sysctl_icmp_ratemask = 0x1818;
1280 : 3 : net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr = 0;
1281 : :
1282 : 3 : return 0;
1283 : :
1284 : : fail:
1285 : 0 : icmp_sk_exit(net);
1286 : 0 : return err;
1287 : : }
1288 : :
1289 : : static struct pernet_operations __net_initdata icmp_sk_ops = {
1290 : : .init = icmp_sk_init,
1291 : : .exit = icmp_sk_exit,
1292 : : };
1293 : :
1294 : 3 : int __init icmp_init(void)
1295 : : {
1296 : 3 : return register_pernet_subsys(&icmp_sk_ops);
1297 : : }
|
