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 : : static struct sock *icmp_sk(struct net *net)
203 : : {
204 : 3 : return this_cpu_read(*net->ipv4.icmp_sk);
205 : : }
206 : :
207 : : /* Called with BH disabled */
208 : 3 : static inline struct sock *icmp_xmit_lock(struct net *net)
209 : : {
210 : : struct sock *sk;
211 : :
212 : : sk = icmp_sk(net);
213 : :
214 : 3 : 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 : 3 : return sk;
221 : : }
222 : :
223 : : static inline void icmp_xmit_unlock(struct sock *sk)
224 : : {
225 : : spin_unlock(&sk->sk_lock.slock);
226 : : }
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 : 3 : bool icmp_global_allow(void)
247 : : {
248 : 3 : u32 credit, delta, incr = 0, now = (u32)jiffies;
249 : : 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 : 3 : if (!READ_ONCE(icmp_global.credit)) {
256 : 3 : delta = min_t(u32, now - READ_ONCE(icmp_global.stamp), HZ);
257 : 3 : if (delta < HZ / 50)
258 : : return false;
259 : : }
260 : :
261 : : spin_lock(&icmp_global.lock);
262 : 3 : delta = min_t(u32, now - icmp_global.stamp, HZ);
263 : 3 : if (delta >= HZ / 50) {
264 : 3 : incr = sysctl_icmp_msgs_per_sec * delta / HZ ;
265 : 3 : if (incr)
266 : : WRITE_ONCE(icmp_global.stamp, now);
267 : : }
268 : 3 : credit = min_t(u32, icmp_global.credit + incr, sysctl_icmp_msgs_burst);
269 : 3 : if (credit) {
270 : 3 : credit--;
271 : : rc = true;
272 : : }
273 : : WRITE_ONCE(icmp_global.credit, credit);
274 : : spin_unlock(&icmp_global.lock);
275 : 3 : return rc;
276 : : }
277 : : EXPORT_SYMBOL(icmp_global_allow);
278 : :
279 : : static bool icmpv4_mask_allow(struct net *net, int type, int code)
280 : : {
281 : 3 : if (type > NR_ICMP_TYPES)
282 : : return true;
283 : :
284 : : /* Don't limit PMTU discovery. */
285 : 3 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
286 : : return true;
287 : :
288 : : /* Limit if icmp type is enabled in ratemask. */
289 : 3 : if (!((1 << type) & net->ipv4.sysctl_icmp_ratemask))
290 : : return true;
291 : :
292 : : return false;
293 : : }
294 : :
295 : 3 : static bool icmpv4_global_allow(struct net *net, int type, int code)
296 : : {
297 : 3 : if (icmpv4_mask_allow(net, type, code))
298 : : return true;
299 : :
300 : 3 : if (icmp_global_allow())
301 : : return true;
302 : :
303 : 0 : return false;
304 : : }
305 : :
306 : : /*
307 : : * Send an ICMP frame.
308 : : */
309 : :
310 : 3 : 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 : 3 : if (icmpv4_mask_allow(net, type, code))
319 : : goto out;
320 : :
321 : : /* No rate limit on loopback */
322 : 3 : if (dst->dev && (dst->dev->flags&IFF_LOOPBACK))
323 : : goto out;
324 : :
325 : : vif = l3mdev_master_ifindex(dst->dev);
326 : 2 : peer = inet_getpeer_v4(net->ipv4.peers, fl4->daddr, vif, 1);
327 : 2 : rc = inet_peer_xrlim_allow(peer, net->ipv4.sysctl_icmp_ratelimit);
328 : 2 : if (peer)
329 : 2 : inet_putpeer(peer);
330 : : out:
331 : 3 : return rc;
332 : : }
333 : :
334 : : /*
335 : : * Maintain the counters used in the SNMP statistics for outgoing ICMP
336 : : */
337 : 3 : void icmp_out_count(struct net *net, unsigned char type)
338 : : {
339 : 3 : ICMPMSGOUT_INC_STATS(net, type);
340 : 3 : ICMP_INC_STATS(net, ICMP_MIB_OUTMSGS);
341 : 3 : }
342 : :
343 : : /*
344 : : * Checksum each fragment, and on the first include the headers and final
345 : : * checksum.
346 : : */
347 : 3 : static int icmp_glue_bits(void *from, char *to, int offset, int len, int odd,
348 : : struct sk_buff *skb)
349 : : {
350 : : struct icmp_bxm *icmp_param = (struct icmp_bxm *)from;
351 : : __wsum csum;
352 : :
353 : 3 : csum = skb_copy_and_csum_bits(icmp_param->skb,
354 : 3 : icmp_param->offset + offset,
355 : : to, len, 0);
356 : :
357 : 3 : skb->csum = csum_block_add(skb->csum, csum, odd);
358 : 3 : if (icmp_pointers[icmp_param->data.icmph.type].error)
359 : 3 : nf_ct_attach(skb, icmp_param->skb);
360 : 3 : return 0;
361 : : }
362 : :
363 : 3 : static void icmp_push_reply(struct icmp_bxm *icmp_param,
364 : : struct flowi4 *fl4,
365 : : struct ipcm_cookie *ipc, struct rtable **rt)
366 : : {
367 : : struct sock *sk;
368 : : struct sk_buff *skb;
369 : :
370 : 3 : sk = icmp_sk(dev_net((*rt)->dst.dev));
371 : 3 : if (ip_append_data(sk, fl4, icmp_glue_bits, icmp_param,
372 : 3 : 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 : 3 : } else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
378 : : struct icmphdr *icmph = icmp_hdr(skb);
379 : : __wsum csum = 0;
380 : : struct sk_buff *skb1;
381 : :
382 : 3 : skb_queue_walk(&sk->sk_write_queue, skb1) {
383 : 3 : csum = csum_add(csum, skb1->csum);
384 : : }
385 : 3 : csum = csum_partial_copy_nocheck((void *)&icmp_param->data,
386 : : (char *)icmph,
387 : : icmp_param->head_len, csum);
388 : 3 : icmph->checksum = csum_fold(csum);
389 : 3 : skb->ip_summed = CHECKSUM_NONE;
390 : 3 : ip_push_pending_frames(sk, fl4);
391 : : }
392 : 3 : }
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 : : struct ipcm_cookie ipc;
401 : 0 : struct rtable *rt = skb_rtable(skb);
402 : 0 : struct net *net = dev_net(rt->dst.dev);
403 : : struct flowi4 fl4;
404 : : struct sock *sk;
405 : : struct inet_sock *inet;
406 : : __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 : : local_bh_disable();
416 : :
417 : : /* global icmp_msgs_per_sec */
418 : 0 : if (!icmpv4_global_allow(net, type, code))
419 : : goto out_bh_enable;
420 : :
421 : 0 : sk = icmp_xmit_lock(net);
422 : 0 : if (!sk)
423 : : goto out_bh_enable;
424 : : inet = inet_sk(sk);
425 : :
426 : 0 : icmp_param->data.icmph.checksum = 0;
427 : :
428 : : ipcm_init(&ipc);
429 : 0 : inet->tos = ip_hdr(skb)->tos;
430 : 0 : ipc.sockc.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 : : 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 : : 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 : : out_unlock:
455 : : icmp_xmit_unlock(sk);
456 : : out_bh_enable:
457 : : local_bh_enable();
458 : : }
459 : :
460 : 3 : 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 : : struct rtable *rt, *rt2;
469 : : struct flowi4 fl4_dec;
470 : : int err;
471 : :
472 : 3 : memset(fl4, 0, sizeof(*fl4));
473 : 3 : fl4->daddr = (param->replyopts.opt.opt.srr ?
474 : 3 : param->replyopts.opt.opt.faddr : iph->saddr);
475 : 3 : fl4->saddr = saddr;
476 : 3 : fl4->flowi4_mark = mark;
477 : 3 : fl4->flowi4_uid = sock_net_uid(net, NULL);
478 : 3 : fl4->flowi4_tos = RT_TOS(tos);
479 : 3 : fl4->flowi4_proto = IPPROTO_ICMP;
480 : 3 : fl4->fl4_icmp_type = type;
481 : 3 : fl4->fl4_icmp_code = code;
482 : 3 : fl4->flowi4_oif = l3mdev_master_ifindex(skb_dst(skb_in)->dev);
483 : :
484 : : security_skb_classify_flow(skb_in, flowi4_to_flowi(fl4));
485 : 3 : rt = ip_route_output_key_hash(net, fl4, skb_in);
486 : 3 : if (IS_ERR(rt))
487 : : return rt;
488 : :
489 : : /* No need to clone since we're just using its address. */
490 : : rt2 = rt;
491 : :
492 : 3 : rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
493 : : flowi4_to_flowi(fl4), NULL, 0);
494 : 3 : if (!IS_ERR(rt)) {
495 : 3 : if (rt != rt2)
496 : : return rt;
497 : 0 : } else if (PTR_ERR(rt) == -EPERM) {
498 : : rt = NULL;
499 : : } else
500 : : return rt;
501 : :
502 : : err = xfrm_decode_session_reverse(skb_in, flowi4_to_flowi(&fl4_dec), AF_INET);
503 : 3 : if (err)
504 : : goto relookup_failed;
505 : :
506 : 3 : if (inet_addr_type_dev_table(net, skb_dst(skb_in)->dev,
507 : : fl4_dec.saddr) == RTN_LOCAL) {
508 : : rt2 = __ip_route_output_key(net, &fl4_dec);
509 : 2 : if (IS_ERR(rt2))
510 : : err = PTR_ERR(rt2);
511 : : } else {
512 : 1 : struct flowi4 fl4_2 = {};
513 : : unsigned long orefdst;
514 : :
515 : 1 : fl4_2.daddr = fl4_dec.saddr;
516 : : rt2 = ip_route_output_key(net, &fl4_2);
517 : 1 : if (IS_ERR(rt2)) {
518 : : err = PTR_ERR(rt2);
519 : 0 : goto relookup_failed;
520 : : }
521 : : /* Ugh! */
522 : 1 : orefdst = skb_in->_skb_refdst; /* save old refdst */
523 : : skb_dst_set(skb_in, NULL);
524 : 1 : err = ip_route_input(skb_in, fl4_dec.daddr, fl4_dec.saddr,
525 : : RT_TOS(tos), rt2->dst.dev);
526 : :
527 : 1 : dst_release(&rt2->dst);
528 : : rt2 = skb_rtable(skb_in);
529 : 1 : skb_in->_skb_refdst = orefdst; /* restore old refdst */
530 : : }
531 : :
532 : 3 : if (err)
533 : : goto relookup_failed;
534 : :
535 : 3 : rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst,
536 : : flowi4_to_flowi(&fl4_dec), NULL,
537 : : XFRM_LOOKUP_ICMP);
538 : 3 : if (!IS_ERR(rt2)) {
539 : 0 : dst_release(&rt->dst);
540 : 0 : memcpy(fl4, &fl4_dec, sizeof(*fl4));
541 : : rt = rt2;
542 : 3 : } else if (PTR_ERR(rt2) == -EPERM) {
543 : 0 : if (rt)
544 : 0 : dst_release(&rt->dst);
545 : 0 : return rt2;
546 : : } else {
547 : : err = PTR_ERR(rt2);
548 : : goto relookup_failed;
549 : : }
550 : 0 : return rt;
551 : :
552 : : relookup_failed:
553 : 3 : 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 : 3 : void __icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info,
570 : : const struct ip_options *opt)
571 : : {
572 : : struct iphdr *iph;
573 : : int room;
574 : : struct icmp_bxm icmp_param;
575 : 3 : struct rtable *rt = skb_rtable(skb_in);
576 : : struct ipcm_cookie ipc;
577 : : struct flowi4 fl4;
578 : : __be32 saddr;
579 : : u8 tos;
580 : : u32 mark;
581 : : struct net *net;
582 : : struct sock *sk;
583 : :
584 : 3 : if (!rt)
585 : : goto out;
586 : :
587 : 3 : if (rt->dst.dev)
588 : : net = dev_net(rt->dst.dev);
589 : 0 : else if (skb_in->dev)
590 : : net = dev_net(skb_in->dev);
591 : : else
592 : : 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 : : iph = ip_hdr(skb_in);
600 : :
601 : 3 : if ((u8 *)iph < skb_in->head ||
602 : 3 : (skb_network_header(skb_in) + sizeof(*iph)) >
603 : : skb_tail_pointer(skb_in))
604 : : goto out;
605 : :
606 : : /*
607 : : * No replies to physical multicast/broadcast
608 : : */
609 : 3 : if (skb_in->pkt_type != PACKET_HOST)
610 : : goto out;
611 : :
612 : : /*
613 : : * Now check at the protocol level
614 : : */
615 : 3 : if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
616 : : goto out;
617 : :
618 : : /*
619 : : * Only reply to fragment 0. We byte re-order the constant
620 : : * mask for efficiency.
621 : : */
622 : 3 : if (iph->frag_off & htons(IP_OFFSET))
623 : : goto out;
624 : :
625 : : /*
626 : : * If we send an ICMP error to an ICMP error a mess would result..
627 : : */
628 : 3 : if (icmp_pointers[type].error) {
629 : : /*
630 : : * We are an error, check if we are replying to an
631 : : * ICMP error
632 : : */
633 : 3 : if (iph->protocol == IPPROTO_ICMP) {
634 : : 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 : : type) -
641 : 0 : skb_in->data,
642 : : sizeof(_inner_type),
643 : : &_inner_type);
644 : 0 : if (!itp)
645 : : 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 : : goto out;
654 : : }
655 : : }
656 : :
657 : : /* Needed by both icmp_global_allow and icmp_xmit_lock */
658 : : 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 : 3 : if (!(skb_in->dev && (skb_in->dev->flags&IFF_LOOPBACK)) &&
665 : 3 : !icmpv4_global_allow(net, type, code))
666 : : goto out_bh_enable;
667 : :
668 : 3 : sk = icmp_xmit_lock(net);
669 : 3 : if (!sk)
670 : : goto out_bh_enable;
671 : :
672 : : /*
673 : : * Construct source address and options.
674 : : */
675 : :
676 : 3 : saddr = iph->daddr;
677 : 3 : if (!(rt->rt_flags & RTCF_LOCAL)) {
678 : : struct net_device *dev = NULL;
679 : :
680 : : rcu_read_lock();
681 : 1 : 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 : 1 : if (dev)
686 : 0 : saddr = inet_select_addr(dev, 0, RT_SCOPE_LINK);
687 : : else
688 : : saddr = 0;
689 : : rcu_read_unlock();
690 : : }
691 : :
692 : 3 : tos = icmp_pointers[type].error ? ((iph->tos & IPTOS_TOS_MASK) |
693 : : IPTOS_PREC_INTERNETCONTROL) :
694 : : iph->tos;
695 : 3 : mark = IP4_REPLY_MARK(net, skb_in->mark);
696 : :
697 : 3 : if (__ip_options_echo(net, &icmp_param.replyopts.opt.opt, skb_in, opt))
698 : : goto out_unlock;
699 : :
700 : :
701 : : /*
702 : : * Prepare data for ICMP header.
703 : : */
704 : :
705 : 3 : icmp_param.data.icmph.type = type;
706 : 3 : icmp_param.data.icmph.code = code;
707 : 3 : icmp_param.data.icmph.un.gateway = info;
708 : 3 : icmp_param.data.icmph.checksum = 0;
709 : 3 : icmp_param.skb = skb_in;
710 : 3 : icmp_param.offset = skb_network_offset(skb_in);
711 : 3 : inet_sk(sk)->tos = tos;
712 : : ipcm_init(&ipc);
713 : 3 : ipc.addr = iph->saddr;
714 : 3 : ipc.opt = &icmp_param.replyopts.opt;
715 : 3 : ipc.sockc.mark = mark;
716 : :
717 : 3 : rt = icmp_route_lookup(net, &fl4, skb_in, iph, saddr, tos, mark,
718 : : type, code, &icmp_param);
719 : 3 : if (IS_ERR(rt))
720 : : goto out_unlock;
721 : :
722 : : /* peer icmp_ratelimit */
723 : 3 : if (!icmpv4_xrlim_allow(net, rt, &fl4, type, code))
724 : : goto ende;
725 : :
726 : : /* RFC says return as much as we can without exceeding 576 bytes. */
727 : :
728 : 3 : room = dst_mtu(&rt->dst);
729 : 3 : if (room > 576)
730 : : room = 576;
731 : 3 : room -= sizeof(struct iphdr) + icmp_param.replyopts.opt.opt.optlen;
732 : 3 : room -= sizeof(struct icmphdr);
733 : :
734 : 3 : icmp_param.data_len = skb_in->len - icmp_param.offset;
735 : 3 : if (icmp_param.data_len > room)
736 : 0 : icmp_param.data_len = room;
737 : 3 : icmp_param.head_len = sizeof(struct icmphdr);
738 : :
739 : 3 : icmp_push_reply(&icmp_param, &fl4, &ipc, &rt);
740 : : ende:
741 : 3 : ip_rt_put(rt);
742 : : out_unlock:
743 : : icmp_xmit_unlock(sk);
744 : : out_bh_enable:
745 : : local_bh_enable();
746 : : out:;
747 : 3 : }
748 : : EXPORT_SYMBOL(__icmp_send);
749 : :
750 : :
751 : 1 : static void icmp_socket_deliver(struct sk_buff *skb, u32 info)
752 : : {
753 : 1 : const struct iphdr *iph = (const struct iphdr *) skb->data;
754 : : const struct net_protocol *ipprot;
755 : 1 : int protocol = iph->protocol;
756 : :
757 : : /* Checkin full IP header plus 8 bytes of protocol to
758 : : * avoid additional coding at protocol handlers.
759 : : */
760 : 1 : if (!pskb_may_pull(skb, iph->ihl * 4 + 8)) {
761 : 0 : __ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
762 : 1 : return;
763 : : }
764 : :
765 : 1 : raw_icmp_error(skb, protocol, info);
766 : :
767 : 1 : ipprot = rcu_dereference(inet_protos[protocol]);
768 : 1 : if (ipprot && ipprot->err_handler)
769 : 1 : ipprot->err_handler(skb, info);
770 : : }
771 : :
772 : : static bool icmp_tag_validation(int proto)
773 : : {
774 : : bool ok;
775 : :
776 : : rcu_read_lock();
777 : 0 : ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation;
778 : : rcu_read_unlock();
779 : : return ok;
780 : : }
781 : :
782 : : /*
783 : : * Handle ICMP_DEST_UNREACH, ICMP_TIME_EXCEEDED, ICMP_QUENCH, and
784 : : * ICMP_PARAMETERPROB.
785 : : */
786 : :
787 : 1 : static bool icmp_unreach(struct sk_buff *skb)
788 : : {
789 : : const struct iphdr *iph;
790 : : struct icmphdr *icmph;
791 : : struct net *net;
792 : : u32 info = 0;
793 : :
794 : 1 : net = dev_net(skb_dst(skb)->dev);
795 : :
796 : : /*
797 : : * Incomplete header ?
798 : : * Only checks for the IP header, there should be an
799 : : * additional check for longer headers in upper levels.
800 : : */
801 : :
802 : 1 : if (!pskb_may_pull(skb, sizeof(struct iphdr)))
803 : : goto out_err;
804 : :
805 : : icmph = icmp_hdr(skb);
806 : 1 : iph = (const struct iphdr *)skb->data;
807 : :
808 : 1 : if (iph->ihl < 5) /* Mangled header, drop. */
809 : : goto out_err;
810 : :
811 : 1 : switch (icmph->type) {
812 : : case ICMP_DEST_UNREACH:
813 : 1 : switch (icmph->code & 15) {
814 : : case ICMP_NET_UNREACH:
815 : : case ICMP_HOST_UNREACH:
816 : : case ICMP_PROT_UNREACH:
817 : : case ICMP_PORT_UNREACH:
818 : : break;
819 : : case ICMP_FRAG_NEEDED:
820 : : /* for documentation of the ip_no_pmtu_disc
821 : : * values please see
822 : : * Documentation/networking/ip-sysctl.txt
823 : : */
824 : 0 : switch (net->ipv4.sysctl_ip_no_pmtu_disc) {
825 : : default:
826 : : net_dbg_ratelimited("%pI4: fragmentation needed and DF set\n",
827 : : &iph->daddr);
828 : : break;
829 : : case 2:
830 : : goto out;
831 : : case 3:
832 : 0 : if (!icmp_tag_validation(iph->protocol))
833 : : goto out;
834 : : /* fall through */
835 : : case 0:
836 : 0 : info = ntohs(icmph->un.frag.mtu);
837 : : }
838 : : break;
839 : : case ICMP_SR_FAILED:
840 : : net_dbg_ratelimited("%pI4: Source Route Failed\n",
841 : : &iph->daddr);
842 : : break;
843 : : default:
844 : : break;
845 : : }
846 : 1 : if (icmph->code > NR_ICMP_UNREACH)
847 : : goto out;
848 : : break;
849 : : case ICMP_PARAMETERPROB:
850 : 0 : info = ntohl(icmph->un.gateway) >> 24;
851 : 0 : break;
852 : : case ICMP_TIME_EXCEEDED:
853 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INTIMEEXCDS);
854 : 0 : if (icmph->code == ICMP_EXC_FRAGTIME)
855 : : goto out;
856 : : break;
857 : : }
858 : :
859 : : /*
860 : : * Throw it at our lower layers
861 : : *
862 : : * RFC 1122: 3.2.2 MUST extract the protocol ID from the passed
863 : : * header.
864 : : * RFC 1122: 3.2.2.1 MUST pass ICMP unreach messages to the
865 : : * transport layer.
866 : : * RFC 1122: 3.2.2.2 MUST pass ICMP time expired messages to
867 : : * transport layer.
868 : : */
869 : :
870 : : /*
871 : : * Check the other end isn't violating RFC 1122. Some routers send
872 : : * bogus responses to broadcast frames. If you see this message
873 : : * first check your netmask matches at both ends, if it does then
874 : : * get the other vendor to fix their kit.
875 : : */
876 : :
877 : 1 : if (!net->ipv4.sysctl_icmp_ignore_bogus_error_responses &&
878 : 0 : inet_addr_type_dev_table(net, skb->dev, iph->daddr) == RTN_BROADCAST) {
879 : 0 : net_warn_ratelimited("%pI4 sent an invalid ICMP type %u, code %u error to a broadcast: %pI4 on %s\n",
880 : : &ip_hdr(skb)->saddr,
881 : : icmph->type, icmph->code,
882 : : &iph->daddr, skb->dev->name);
883 : : goto out;
884 : : }
885 : :
886 : 1 : icmp_socket_deliver(skb, info);
887 : :
888 : : out:
889 : : return true;
890 : : out_err:
891 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
892 : 0 : return false;
893 : : }
894 : :
895 : :
896 : : /*
897 : : * Handle ICMP_REDIRECT.
898 : : */
899 : :
900 : 0 : static bool icmp_redirect(struct sk_buff *skb)
901 : : {
902 : 0 : if (skb->len < sizeof(struct iphdr)) {
903 : 0 : __ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
904 : 0 : return false;
905 : : }
906 : :
907 : 0 : if (!pskb_may_pull(skb, sizeof(struct iphdr))) {
908 : : /* there aught to be a stat */
909 : : return false;
910 : : }
911 : :
912 : 0 : icmp_socket_deliver(skb, ntohl(icmp_hdr(skb)->un.gateway));
913 : 0 : return true;
914 : : }
915 : :
916 : : /*
917 : : * Handle ICMP_ECHO ("ping") requests.
918 : : *
919 : : * RFC 1122: 3.2.2.6 MUST have an echo server that answers ICMP echo
920 : : * requests.
921 : : * RFC 1122: 3.2.2.6 Data received in the ICMP_ECHO request MUST be
922 : : * included in the reply.
923 : : * RFC 1812: 4.3.3.6 SHOULD have a config option for silently ignoring
924 : : * echo requests, MUST have default=NOT.
925 : : * See also WRT handling of options once they are done and working.
926 : : */
927 : :
928 : 0 : static bool icmp_echo(struct sk_buff *skb)
929 : : {
930 : : struct net *net;
931 : :
932 : 0 : net = dev_net(skb_dst(skb)->dev);
933 : 0 : if (!net->ipv4.sysctl_icmp_echo_ignore_all) {
934 : : struct icmp_bxm icmp_param;
935 : :
936 : 0 : icmp_param.data.icmph = *icmp_hdr(skb);
937 : 0 : icmp_param.data.icmph.type = ICMP_ECHOREPLY;
938 : 0 : icmp_param.skb = skb;
939 : 0 : icmp_param.offset = 0;
940 : 0 : icmp_param.data_len = skb->len;
941 : 0 : icmp_param.head_len = sizeof(struct icmphdr);
942 : 0 : icmp_reply(&icmp_param, skb);
943 : : }
944 : : /* should there be an ICMP stat for ignored echos? */
945 : 0 : return true;
946 : : }
947 : :
948 : : /*
949 : : * Handle ICMP Timestamp requests.
950 : : * RFC 1122: 3.2.2.8 MAY implement ICMP timestamp requests.
951 : : * SHOULD be in the kernel for minimum random latency.
952 : : * MUST be accurate to a few minutes.
953 : : * MUST be updated at least at 15Hz.
954 : : */
955 : 0 : static bool icmp_timestamp(struct sk_buff *skb)
956 : : {
957 : : struct icmp_bxm icmp_param;
958 : : /*
959 : : * Too short.
960 : : */
961 : 0 : if (skb->len < 4)
962 : : goto out_err;
963 : :
964 : : /*
965 : : * Fill in the current time as ms since midnight UT:
966 : : */
967 : 0 : icmp_param.data.times[1] = inet_current_timestamp();
968 : 0 : icmp_param.data.times[2] = icmp_param.data.times[1];
969 : :
970 : 0 : BUG_ON(skb_copy_bits(skb, 0, &icmp_param.data.times[0], 4));
971 : :
972 : 0 : icmp_param.data.icmph = *icmp_hdr(skb);
973 : 0 : icmp_param.data.icmph.type = ICMP_TIMESTAMPREPLY;
974 : 0 : icmp_param.data.icmph.code = 0;
975 : 0 : icmp_param.skb = skb;
976 : 0 : icmp_param.offset = 0;
977 : 0 : icmp_param.data_len = 0;
978 : 0 : icmp_param.head_len = sizeof(struct icmphdr) + 12;
979 : 0 : icmp_reply(&icmp_param, skb);
980 : 0 : return true;
981 : :
982 : : out_err:
983 : 0 : __ICMP_INC_STATS(dev_net(skb_dst(skb)->dev), ICMP_MIB_INERRORS);
984 : 0 : return false;
985 : : }
986 : :
987 : 0 : static bool icmp_discard(struct sk_buff *skb)
988 : : {
989 : : /* pretend it was a success */
990 : 0 : return true;
991 : : }
992 : :
993 : : /*
994 : : * Deal with incoming ICMP packets.
995 : : */
996 : 1 : int icmp_rcv(struct sk_buff *skb)
997 : : {
998 : : struct icmphdr *icmph;
999 : : struct rtable *rt = skb_rtable(skb);
1000 : 1 : struct net *net = dev_net(rt->dst.dev);
1001 : : bool success;
1002 : :
1003 : 1 : if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
1004 : : struct sec_path *sp = skb_sec_path(skb);
1005 : : int nh;
1006 : :
1007 : 0 : if (!(sp && sp->xvec[sp->len - 1]->props.flags &
1008 : : XFRM_STATE_ICMP))
1009 : : goto drop;
1010 : :
1011 : 0 : if (!pskb_may_pull(skb, sizeof(*icmph) + sizeof(struct iphdr)))
1012 : : goto drop;
1013 : :
1014 : : nh = skb_network_offset(skb);
1015 : : skb_set_network_header(skb, sizeof(*icmph));
1016 : :
1017 : 0 : if (!xfrm4_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
1018 : : goto drop;
1019 : :
1020 : : skb_set_network_header(skb, nh);
1021 : : }
1022 : :
1023 : 1 : __ICMP_INC_STATS(net, ICMP_MIB_INMSGS);
1024 : :
1025 : 1 : if (skb_checksum_simple_validate(skb))
1026 : : goto csum_error;
1027 : :
1028 : 1 : if (!pskb_pull(skb, sizeof(*icmph)))
1029 : : goto error;
1030 : :
1031 : : icmph = icmp_hdr(skb);
1032 : :
1033 : 1 : ICMPMSGIN_INC_STATS(net, icmph->type);
1034 : : /*
1035 : : * 18 is the highest 'known' ICMP type. Anything else is a mystery
1036 : : *
1037 : : * RFC 1122: 3.2.2 Unknown ICMP messages types MUST be silently
1038 : : * discarded.
1039 : : */
1040 : 1 : if (icmph->type > NR_ICMP_TYPES)
1041 : : goto error;
1042 : :
1043 : :
1044 : : /*
1045 : : * Parse the ICMP message
1046 : : */
1047 : :
1048 : 1 : if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
1049 : : /*
1050 : : * RFC 1122: 3.2.2.6 An ICMP_ECHO to broadcast MAY be
1051 : : * silently ignored (we let user decide with a sysctl).
1052 : : * RFC 1122: 3.2.2.8 An ICMP_TIMESTAMP MAY be silently
1053 : : * discarded if to broadcast/multicast.
1054 : : */
1055 : 0 : if ((icmph->type == ICMP_ECHO ||
1056 : 0 : icmph->type == ICMP_TIMESTAMP) &&
1057 : 0 : net->ipv4.sysctl_icmp_echo_ignore_broadcasts) {
1058 : : goto error;
1059 : : }
1060 : 0 : if (icmph->type != ICMP_ECHO &&
1061 : 0 : icmph->type != ICMP_TIMESTAMP &&
1062 : 0 : icmph->type != ICMP_ADDRESS &&
1063 : : icmph->type != ICMP_ADDRESSREPLY) {
1064 : : goto error;
1065 : : }
1066 : : }
1067 : :
1068 : 1 : success = icmp_pointers[icmph->type].handler(skb);
1069 : :
1070 : 1 : if (success) {
1071 : 1 : consume_skb(skb);
1072 : 1 : return NET_RX_SUCCESS;
1073 : : }
1074 : :
1075 : : drop:
1076 : 0 : kfree_skb(skb);
1077 : 0 : return NET_RX_DROP;
1078 : : csum_error:
1079 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_CSUMERRORS);
1080 : : error:
1081 : 0 : __ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
1082 : : goto drop;
1083 : : }
1084 : :
1085 : 0 : int icmp_err(struct sk_buff *skb, u32 info)
1086 : : {
1087 : 0 : struct iphdr *iph = (struct iphdr *)skb->data;
1088 : 0 : int offset = iph->ihl<<2;
1089 : 0 : struct icmphdr *icmph = (struct icmphdr *)(skb->data + offset);
1090 : 0 : int type = icmp_hdr(skb)->type;
1091 : 0 : int code = icmp_hdr(skb)->code;
1092 : 0 : struct net *net = dev_net(skb->dev);
1093 : :
1094 : : /*
1095 : : * Use ping_err to handle all icmp errors except those
1096 : : * triggered by ICMP_ECHOREPLY which sent from kernel.
1097 : : */
1098 : 0 : if (icmph->type != ICMP_ECHOREPLY) {
1099 : 0 : ping_err(skb, offset, info);
1100 : 0 : return 0;
1101 : : }
1102 : :
1103 : 0 : if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
1104 : 0 : ipv4_update_pmtu(skb, net, info, 0, IPPROTO_ICMP);
1105 : 0 : else if (type == ICMP_REDIRECT)
1106 : 0 : ipv4_redirect(skb, net, 0, IPPROTO_ICMP);
1107 : :
1108 : : return 0;
1109 : : }
1110 : :
1111 : : /*
1112 : : * This table is the definition of how we handle ICMP.
1113 : : */
1114 : : static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
1115 : : [ICMP_ECHOREPLY] = {
1116 : : .handler = ping_rcv,
1117 : : },
1118 : : [1] = {
1119 : : .handler = icmp_discard,
1120 : : .error = 1,
1121 : : },
1122 : : [2] = {
1123 : : .handler = icmp_discard,
1124 : : .error = 1,
1125 : : },
1126 : : [ICMP_DEST_UNREACH] = {
1127 : : .handler = icmp_unreach,
1128 : : .error = 1,
1129 : : },
1130 : : [ICMP_SOURCE_QUENCH] = {
1131 : : .handler = icmp_unreach,
1132 : : .error = 1,
1133 : : },
1134 : : [ICMP_REDIRECT] = {
1135 : : .handler = icmp_redirect,
1136 : : .error = 1,
1137 : : },
1138 : : [6] = {
1139 : : .handler = icmp_discard,
1140 : : .error = 1,
1141 : : },
1142 : : [7] = {
1143 : : .handler = icmp_discard,
1144 : : .error = 1,
1145 : : },
1146 : : [ICMP_ECHO] = {
1147 : : .handler = icmp_echo,
1148 : : },
1149 : : [9] = {
1150 : : .handler = icmp_discard,
1151 : : .error = 1,
1152 : : },
1153 : : [10] = {
1154 : : .handler = icmp_discard,
1155 : : .error = 1,
1156 : : },
1157 : : [ICMP_TIME_EXCEEDED] = {
1158 : : .handler = icmp_unreach,
1159 : : .error = 1,
1160 : : },
1161 : : [ICMP_PARAMETERPROB] = {
1162 : : .handler = icmp_unreach,
1163 : : .error = 1,
1164 : : },
1165 : : [ICMP_TIMESTAMP] = {
1166 : : .handler = icmp_timestamp,
1167 : : },
1168 : : [ICMP_TIMESTAMPREPLY] = {
1169 : : .handler = icmp_discard,
1170 : : },
1171 : : [ICMP_INFO_REQUEST] = {
1172 : : .handler = icmp_discard,
1173 : : },
1174 : : [ICMP_INFO_REPLY] = {
1175 : : .handler = icmp_discard,
1176 : : },
1177 : : [ICMP_ADDRESS] = {
1178 : : .handler = icmp_discard,
1179 : : },
1180 : : [ICMP_ADDRESSREPLY] = {
1181 : : .handler = icmp_discard,
1182 : : },
1183 : : };
1184 : :
1185 : 1 : static void __net_exit icmp_sk_exit(struct net *net)
1186 : : {
1187 : : int i;
1188 : :
1189 : 1 : for_each_possible_cpu(i)
1190 : 1 : inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.icmp_sk, i));
1191 : 1 : free_percpu(net->ipv4.icmp_sk);
1192 : 1 : net->ipv4.icmp_sk = NULL;
1193 : 1 : }
1194 : :
1195 : 3 : static int __net_init icmp_sk_init(struct net *net)
1196 : : {
1197 : : int i, err;
1198 : :
1199 : 3 : net->ipv4.icmp_sk = alloc_percpu(struct sock *);
1200 : 3 : if (!net->ipv4.icmp_sk)
1201 : : return -ENOMEM;
1202 : :
1203 : 3 : for_each_possible_cpu(i) {
1204 : : struct sock *sk;
1205 : :
1206 : 3 : err = inet_ctl_sock_create(&sk, PF_INET,
1207 : : SOCK_RAW, IPPROTO_ICMP, net);
1208 : 3 : if (err < 0)
1209 : : goto fail;
1210 : :
1211 : 3 : *per_cpu_ptr(net->ipv4.icmp_sk, i) = sk;
1212 : :
1213 : : /* Enough space for 2 64K ICMP packets, including
1214 : : * sk_buff/skb_shared_info struct overhead.
1215 : : */
1216 : 3 : sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
1217 : :
1218 : : /*
1219 : : * Speedup sock_wfree()
1220 : : */
1221 : : sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1222 : 3 : inet_sk(sk)->pmtudisc = IP_PMTUDISC_DONT;
1223 : : }
1224 : :
1225 : : /* Control parameters for ECHO replies. */
1226 : 3 : net->ipv4.sysctl_icmp_echo_ignore_all = 0;
1227 : 3 : net->ipv4.sysctl_icmp_echo_ignore_broadcasts = 1;
1228 : :
1229 : : /* Control parameter - ignore bogus broadcast responses? */
1230 : 3 : net->ipv4.sysctl_icmp_ignore_bogus_error_responses = 1;
1231 : :
1232 : : /*
1233 : : * Configurable global rate limit.
1234 : : *
1235 : : * ratelimit defines tokens/packet consumed for dst->rate_token
1236 : : * bucket ratemask defines which icmp types are ratelimited by
1237 : : * setting it's bit position.
1238 : : *
1239 : : * default:
1240 : : * dest unreachable (3), source quench (4),
1241 : : * time exceeded (11), parameter problem (12)
1242 : : */
1243 : :
1244 : 3 : net->ipv4.sysctl_icmp_ratelimit = 1 * HZ;
1245 : 3 : net->ipv4.sysctl_icmp_ratemask = 0x1818;
1246 : 3 : net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr = 0;
1247 : :
1248 : 3 : return 0;
1249 : :
1250 : : fail:
1251 : 0 : icmp_sk_exit(net);
1252 : 0 : return err;
1253 : : }
1254 : :
1255 : : static struct pernet_operations __net_initdata icmp_sk_ops = {
1256 : : .init = icmp_sk_init,
1257 : : .exit = icmp_sk_exit,
1258 : : };
1259 : :
1260 : 3 : int __init icmp_init(void)
1261 : : {
1262 : 3 : return register_pernet_subsys(&icmp_sk_ops);
1263 : : }
|
