icmp.c 28 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
/*
 *	NET3:	Implementation of the ICMP protocol layer.
 *
4
 *		Alan Cox, <alan@lxorguk.ukuu.org.uk>
Linus Torvalds's avatar
Linus Torvalds committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 *
 *	Some of the function names and the icmp unreach table for this
 *	module were derived from [icmp.c 1.0.11 06/02/93] by
 *	Ross Biro, Fred N. van Kempen, Mark Evans, Alan Cox, Gerhard Koerting.
 *	Other than that this module is a complete rewrite.
 *
 *	Fixes:
 *	Clemens Fruhwirth	:	introduce global icmp rate limiting
 *					with icmp type masking ability instead
 *					of broken per type icmp timeouts.
 *		Mike Shaver	:	RFC1122 checks.
 *		Alan Cox	:	Multicast ping reply as self.
 *		Alan Cox	:	Fix atomicity lockup in ip_build_xmit
 *					call.
 *		Alan Cox	:	Added 216,128 byte paths to the MTU
 *					code.
 *		Martin Mares	:	RFC1812 checks.
 *		Martin Mares	:	Can be configured to follow redirects
 *					if acting as a router _without_ a
 *					routing protocol (RFC 1812).
 *		Martin Mares	:	Echo requests may be configured to
 *					be ignored (RFC 1812).
 *		Martin Mares	:	Limitation of ICMP error message
 *					transmit rate (RFC 1812).
 *		Martin Mares	:	TOS and Precedence set correctly
 *					(RFC 1812).
 *		Martin Mares	:	Now copying as much data from the
 *					original packet as we can without
 *					exceeding 576 bytes (RFC 1812).
 *	Willy Konynenberg	:	Transparent proxying support.
 *		Keith Owens	:	RFC1191 correction for 4.2BSD based
 *					path MTU bug.
 *		Thomas Quinot	:	ICMP Dest Unreach codes up to 15 are
 *					valid (RFC 1812).
 *		Andi Kleen	:	Check all packet lengths properly
 *					and moved all kfree_skb() up to
 *					icmp_rcv.
 *		Andi Kleen	:	Move the rate limit bookkeeping
 *					into the dest entry and use a token
 *					bucket filter (thanks to ANK). Make
 *					the rates sysctl configurable.
 *		Yu Tianli	:	Fixed two ugly bugs in icmp_send
 *					- IP option length was accounted wrongly
 *					- ICMP header length was not accounted
 *					  at all.
 *              Tristan Greaves :       Added sysctl option to ignore bogus
 *              			broadcast responses from broken routers.
 *
 * To Fix:
 *
 *	- Should use skb_pull() instead of all the manual checking.
 *	  This would also greatly simply some upper layer error handlers. --AK
 *
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/fcntl.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/inet.h>
73
#include <linux/inetdevice.h>
Linus Torvalds's avatar
Linus Torvalds committed
74
75
76
#include <linux/netdevice.h>
#include <linux/string.h>
#include <linux/netfilter_ipv4.h>
77
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <net/snmp.h>
#include <net/ip.h>
#include <net/route.h>
#include <net/protocol.h>
#include <net/icmp.h>
#include <net/tcp.h>
#include <net/udp.h>
#include <net/raw.h>
#include <linux/skbuff.h>
#include <net/sock.h>
#include <linux/errno.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <net/checksum.h>
94
#include <net/xfrm.h>
95
#include <net/inet_common.h>
Linus Torvalds's avatar
Linus Torvalds committed
96
97
98
99
100
101
102
103
104
105
106
107

/*
 *	Build xmit assembly blocks
 */

struct icmp_bxm {
	struct sk_buff *skb;
	int offset;
	int data_len;

	struct {
		struct icmphdr icmph;
108
		__be32	       times[3];
Linus Torvalds's avatar
Linus Torvalds committed
109
110
111
112
113
114
115
116
117
	} data;
	int head_len;
	struct ip_options replyopts;
	unsigned char  optbuf[40];
};

/* An array of errno for error messages from dest unreach. */
/* RFC 1122: 3.2.2.1 States that NET_UNREACH, HOST_UNREACH and SR_FAILED MUST be considered 'transient errs'. */

118
const struct icmp_err icmp_err_convert[] = {
Linus Torvalds's avatar
Linus Torvalds committed
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
	{
		.errno = ENETUNREACH,	/* ICMP_NET_UNREACH */
		.fatal = 0,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_HOST_UNREACH */
		.fatal = 0,
	},
	{
		.errno = ENOPROTOOPT	/* ICMP_PROT_UNREACH */,
		.fatal = 1,
	},
	{
		.errno = ECONNREFUSED,	/* ICMP_PORT_UNREACH */
		.fatal = 1,
	},
	{
		.errno = EMSGSIZE,	/* ICMP_FRAG_NEEDED */
		.fatal = 0,
	},
	{
		.errno = EOPNOTSUPP,	/* ICMP_SR_FAILED */
		.fatal = 0,
	},
	{
		.errno = ENETUNREACH,	/* ICMP_NET_UNKNOWN */
		.fatal = 1,
	},
	{
		.errno = EHOSTDOWN,	/* ICMP_HOST_UNKNOWN */
		.fatal = 1,
	},
	{
		.errno = ENONET,	/* ICMP_HOST_ISOLATED */
		.fatal = 1,
	},
	{
		.errno = ENETUNREACH,	/* ICMP_NET_ANO	*/
		.fatal = 1,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_HOST_ANO */
		.fatal = 1,
	},
	{
		.errno = ENETUNREACH,	/* ICMP_NET_UNR_TOS */
		.fatal = 0,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_HOST_UNR_TOS */
		.fatal = 0,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_PKT_FILTERED */
		.fatal = 1,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_PREC_VIOLATION */
		.fatal = 1,
	},
	{
		.errno = EHOSTUNREACH,	/* ICMP_PREC_CUTOFF */
		.fatal = 1,
	},
};
184
EXPORT_SYMBOL(icmp_err_convert);
Linus Torvalds's avatar
Linus Torvalds committed
185
186
187
188
189
190
191
192
193
194

/*
 *	ICMP control array. This specifies what to do with each ICMP.
 */

struct icmp_control {
	void (*handler)(struct sk_buff *skb);
	short   error;		/* This ICMP is classed as an error message */
};

195
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES+1];
Linus Torvalds's avatar
Linus Torvalds committed
196
197
198
199
200
201
202
203

/*
 *	The ICMP socket(s). This is the most convenient way to flow control
 *	our ICMP output as well as maintain a clean interface throughout
 *	all layers. All Socketless IP sends will soon be gone.
 *
 *	On SMP we have one ICMP socket per-cpu.
 */
204
205
206
207
static struct sock *icmp_sk(struct net *net)
{
	return net->ipv4.icmp_sk[smp_processor_id()];
}
Linus Torvalds's avatar
Linus Torvalds committed
208

209
static inline struct sock *icmp_xmit_lock(struct net *net)
Linus Torvalds's avatar
Linus Torvalds committed
210
{
211
212
	struct sock *sk;

Linus Torvalds's avatar
Linus Torvalds committed
213
214
	local_bh_disable();

215
216
	sk = icmp_sk(net);

217
	if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds's avatar
Linus Torvalds committed
218
219
220
221
		/* This can happen if the output path signals a
		 * dst_link_failure() for an outgoing ICMP packet.
		 */
		local_bh_enable();
222
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
223
	}
224
	return sk;
Linus Torvalds's avatar
Linus Torvalds committed
225
226
}

227
static inline void icmp_xmit_unlock(struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
228
{
229
	spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds's avatar
Linus Torvalds committed
230
231
232
233
234
235
}

/*
 *	Send an ICMP frame.
 */

236
static inline bool icmpv4_xrlim_allow(struct net *net, struct rtable *rt,
237
		int type, int code)
Linus Torvalds's avatar
Linus Torvalds committed
238
{
239
	struct dst_entry *dst = &rt->dst;
240
	bool rc = true;
Linus Torvalds's avatar
Linus Torvalds committed
241
242
243
244
245
246
247
248
249
250

	if (type > NR_ICMP_TYPES)
		goto out;

	/* Don't limit PMTU discovery. */
	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
		goto out;

	/* No rate limit on loopback */
	if (dst->dev && (dst->dev->flags&IFF_LOOPBACK))
251
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
252
253

	/* Limit if icmp type is enabled in ratemask. */
254
255
256
257
258
259
	if ((1 << type) & net->ipv4.sysctl_icmp_ratemask) {
		if (!rt->peer)
			rt_bind_peer(rt, 1);
		rc = inet_peer_xrlim_allow(rt->peer,
					   net->ipv4.sysctl_icmp_ratelimit);
	}
Linus Torvalds's avatar
Linus Torvalds committed
260
261
262
263
264
265
266
out:
	return rc;
}

/*
 *	Maintain the counters used in the SNMP statistics for outgoing ICMP
 */
267
void icmp_out_count(struct net *net, unsigned char type)
Linus Torvalds's avatar
Linus Torvalds committed
268
{
269
	ICMPMSGOUT_INC_STATS(net, type);
270
	ICMP_INC_STATS(net, ICMP_MIB_OUTMSGS);
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274
275
276
277
278
279
280
}

/*
 *	Checksum each fragment, and on the first include the headers and final
 *	checksum.
 */
static int icmp_glue_bits(void *from, char *to, int offset, int len, int odd,
			  struct sk_buff *skb)
{
	struct icmp_bxm *icmp_param = (struct icmp_bxm *)from;
281
	__wsum csum;
Linus Torvalds's avatar
Linus Torvalds committed
282
283
284
285
286
287
288
289
290
291
292
293

	csum = skb_copy_and_csum_bits(icmp_param->skb,
				      icmp_param->offset + offset,
				      to, len, 0);

	skb->csum = csum_block_add(skb->csum, csum, odd);
	if (icmp_pointers[icmp_param->data.icmph.type].error)
		nf_ct_attach(skb, icmp_param->skb);
	return 0;
}

static void icmp_push_reply(struct icmp_bxm *icmp_param,
294
			    struct ipcm_cookie *ipc, struct rtable **rt)
Linus Torvalds's avatar
Linus Torvalds committed
295
{
296
	struct sock *sk;
Linus Torvalds's avatar
Linus Torvalds committed
297
298
	struct sk_buff *skb;

299
	sk = icmp_sk(dev_net((*rt)->dst.dev));
300
	if (ip_append_data(sk, icmp_glue_bits, icmp_param,
301
302
			   icmp_param->data_len+icmp_param->head_len,
			   icmp_param->head_len,
303
304
			   ipc, rt, MSG_DONTWAIT) < 0) {
		ICMP_INC_STATS_BH(sock_net(sk), ICMP_MIB_OUTERRORS);
305
		ip_flush_pending_frames(sk);
306
	} else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
307
		struct icmphdr *icmph = icmp_hdr(skb);
308
		__wsum csum = 0;
Linus Torvalds's avatar
Linus Torvalds committed
309
310
		struct sk_buff *skb1;

311
		skb_queue_walk(&sk->sk_write_queue, skb1) {
Linus Torvalds's avatar
Linus Torvalds committed
312
313
314
315
316
317
318
			csum = csum_add(csum, skb1->csum);
		}
		csum = csum_partial_copy_nocheck((void *)&icmp_param->data,
						 (char *)icmph,
						 icmp_param->head_len, csum);
		icmph->checksum = csum_fold(csum);
		skb->ip_summed = CHECKSUM_NONE;
319
		ip_push_pending_frames(sk);
Linus Torvalds's avatar
Linus Torvalds committed
320
321
322
323
324
325
326
327
328
329
	}
}

/*
 *	Driving logic for building and sending ICMP messages.
 */

static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb)
{
	struct ipcm_cookie ipc;
Eric Dumazet's avatar
Eric Dumazet committed
330
	struct rtable *rt = skb_rtable(skb);
331
	struct net *net = dev_net(rt->dst.dev);
332
333
	struct sock *sk;
	struct inet_sock *inet;
334
	__be32 daddr;
Linus Torvalds's avatar
Linus Torvalds committed
335
336

	if (ip_options_echo(&icmp_param->replyopts, skb))
337
		return;
Linus Torvalds's avatar
Linus Torvalds committed
338

339
340
	sk = icmp_xmit_lock(net);
	if (sk == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
341
		return;
342
	inet = inet_sk(sk);
Linus Torvalds's avatar
Linus Torvalds committed
343
344
345

	icmp_param->data.icmph.checksum = 0;

346
	inet->tos = ip_hdr(skb)->tos;
Linus Torvalds's avatar
Linus Torvalds committed
347
348
	daddr = ipc.addr = rt->rt_src;
	ipc.opt = NULL;
349
	ipc.tx_flags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
350
351
352
353
354
355
	if (icmp_param->replyopts.optlen) {
		ipc.opt = &icmp_param->replyopts;
		if (ipc.opt->srr)
			daddr = icmp_param->replyopts.faddr;
	}
	{
356
357
358
		struct flowi fl = { .fl4_dst= daddr,
				    .fl4_src = rt->rt_spec_dst,
				    .fl4_tos = RT_TOS(ip_hdr(skb)->tos),
Linus Torvalds's avatar
Linus Torvalds committed
359
				    .proto = IPPROTO_ICMP };
360
		security_skb_classify_flow(skb, &fl);
361
362
		rt = ip_route_output_key(net, &fl);
		if (IS_ERR(rt))
Linus Torvalds's avatar
Linus Torvalds committed
363
364
			goto out_unlock;
	}
365
	if (icmpv4_xrlim_allow(net, rt, icmp_param->data.icmph.type,
Linus Torvalds's avatar
Linus Torvalds committed
366
			       icmp_param->data.icmph.code))
367
		icmp_push_reply(icmp_param, &ipc, &rt);
Linus Torvalds's avatar
Linus Torvalds committed
368
369
	ip_rt_put(rt);
out_unlock:
370
	icmp_xmit_unlock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
371
372
}

373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
static struct rtable *icmp_route_lookup(struct net *net, struct sk_buff *skb_in,
					struct iphdr *iph,
					__be32 saddr, u8 tos,
					int type, int code,
					struct icmp_bxm *param)
{
	struct flowi fl = {
		.fl4_dst = (param->replyopts.srr ?
			    param->replyopts.faddr : iph->saddr),
		.fl4_src = saddr,
		.fl4_tos = RT_TOS(tos),
		.proto = IPPROTO_ICMP,
		.fl_icmp_type = type,
		.fl_icmp_code = code,
	};
	struct rtable *rt, *rt2;
	int err;

	security_skb_classify_flow(skb_in, &fl);
392
393
394
	rt = __ip_route_output_key(net, &fl);
	if (IS_ERR(rt))
		return rt;
395
396
397
398
399
400
401

	/* No need to clone since we're just using its address. */
	rt2 = rt;

	if (!fl.fl4_src)
		fl.fl4_src = rt->rt_src;

402
403
	rt = (struct rtable *) xfrm_lookup(net, &rt->dst, &fl, NULL, 0);
	if (!IS_ERR(rt)) {
404
405
		if (rt != rt2)
			return rt;
406
	} else if (PTR_ERR(rt) == -EPERM) {
407
		rt = NULL;
408
409
	} else
		return rt;
410
411
412
413
414
415

	err = xfrm_decode_session_reverse(skb_in, &fl, AF_INET);
	if (err)
		goto relookup_failed;

	if (inet_addr_type(net, fl.fl4_src) == RTN_LOCAL) {
416
417
418
		rt2 = __ip_route_output_key(net, &fl);
		if (IS_ERR(rt2))
			err = PTR_ERR(rt2);
419
420
421
422
423
	} else {
		struct flowi fl2 = {};
		unsigned long orefdst;

		fl2.fl4_dst = fl.fl4_src;
424
425
426
		rt2 = ip_route_output_key(net, &fl2);
		if (IS_ERR(rt2)) {
			err = PTR_ERR(rt2);
427
			goto relookup_failed;
428
		}
429
430
431
432
433
434
435
436
437
438
439
440
441
		/* Ugh! */
		orefdst = skb_in->_skb_refdst; /* save old refdst */
		err = ip_route_input(skb_in, fl.fl4_dst, fl.fl4_src,
				     RT_TOS(tos), rt2->dst.dev);

		dst_release(&rt2->dst);
		rt2 = skb_rtable(skb_in);
		skb_in->_skb_refdst = orefdst; /* restore old refdst */
	}

	if (err)
		goto relookup_failed;

442
443
	rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst, &fl, NULL, XFRM_LOOKUP_ICMP);
	if (!IS_ERR(rt2)) {
444
445
		dst_release(&rt->dst);
		rt = rt2;
446
447
448
449
450
451
452
	} else if (PTR_ERR(rt2) == -EPERM) {
		if (rt)
			dst_release(&rt->dst);
		return rt2;
	} else {
		err = PTR_ERR(rt2);
		goto relookup_failed;
453
454
455
456
457
458
459
460
	}
	return rt;

relookup_failed:
	if (rt)
		return rt;
	return ERR_PTR(err);
}
Linus Torvalds's avatar
Linus Torvalds committed
461
462
463
464
465
466
467
468
469
470
471
472

/*
 *	Send an ICMP message in response to a situation
 *
 *	RFC 1122: 3.2.2	MUST send at least the IP header and 8 bytes of header.
 *		  MAY send more (we do).
 *			MUST NOT change this header information.
 *			MUST NOT reply to a multicast/broadcast IP address.
 *			MUST NOT reply to a multicast/broadcast MAC address.
 *			MUST reply to only the first fragment.
 */

Al Viro's avatar
Al Viro committed
473
void icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info)
Linus Torvalds's avatar
Linus Torvalds committed
474
475
476
477
{
	struct iphdr *iph;
	int room;
	struct icmp_bxm icmp_param;
Eric Dumazet's avatar
Eric Dumazet committed
478
	struct rtable *rt = skb_rtable(skb_in);
Linus Torvalds's avatar
Linus Torvalds committed
479
	struct ipcm_cookie ipc;
480
	__be32 saddr;
Linus Torvalds's avatar
Linus Torvalds committed
481
	u8  tos;
482
	struct net *net;
483
	struct sock *sk;
Linus Torvalds's avatar
Linus Torvalds committed
484
485
486

	if (!rt)
		goto out;
487
	net = dev_net(rt->dst.dev);
Linus Torvalds's avatar
Linus Torvalds committed
488
489
490
491
492
493

	/*
	 *	Find the original header. It is expected to be valid, of course.
	 *	Check this, icmp_send is called from the most obscure devices
	 *	sometimes.
	 */
494
	iph = ip_hdr(skb_in);
Linus Torvalds's avatar
Linus Torvalds committed
495

496
497
	if ((u8 *)iph < skb_in->head ||
	    (skb_in->network_header + sizeof(*iph)) > skb_in->tail)
Linus Torvalds's avatar
Linus Torvalds committed
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
		goto out;

	/*
	 *	No replies to physical multicast/broadcast
	 */
	if (skb_in->pkt_type != PACKET_HOST)
		goto out;

	/*
	 *	Now check at the protocol level
	 */
	if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))
		goto out;

	/*
	 *	Only reply to fragment 0. We byte re-order the constant
	 *	mask for efficiency.
	 */
	if (iph->frag_off & htons(IP_OFFSET))
		goto out;

	/*
	 *	If we send an ICMP error to an ICMP error a mess would result..
	 */
	if (icmp_pointers[type].error) {
		/*
		 *	We are an error, check if we are replying to an
		 *	ICMP error
		 */
		if (iph->protocol == IPPROTO_ICMP) {
			u8 _inner_type, *itp;

			itp = skb_header_pointer(skb_in,
531
						 skb_network_header(skb_in) +
Linus Torvalds's avatar
Linus Torvalds committed
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
						 (iph->ihl << 2) +
						 offsetof(struct icmphdr,
							  type) -
						 skb_in->data,
						 sizeof(_inner_type),
						 &_inner_type);
			if (itp == NULL)
				goto out;

			/*
			 *	Assume any unknown ICMP type is an error. This
			 *	isn't specified by the RFC, but think about it..
			 */
			if (*itp > NR_ICMP_TYPES ||
			    icmp_pointers[*itp].error)
				goto out;
		}
	}

551
552
	sk = icmp_xmit_lock(net);
	if (sk == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
553
554
555
556
557
558
559
		return;

	/*
	 *	Construct source address and options.
	 */

	saddr = iph->daddr;
560
	if (!(rt->rt_flags & RTCF_LOCAL)) {
561
562
		struct net_device *dev = NULL;

563
		rcu_read_lock();
564
565
		if (rt_is_input_route(rt) &&
		    net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr)
566
			dev = dev_get_by_index_rcu(net, rt->fl.iif);
567

568
		if (dev)
569
			saddr = inet_select_addr(dev, 0, RT_SCOPE_LINK);
570
		else
571
			saddr = 0;
572
		rcu_read_unlock();
573
	}
Linus Torvalds's avatar
Linus Torvalds committed
574
575
576
577
578
579

	tos = icmp_pointers[type].error ? ((iph->tos & IPTOS_TOS_MASK) |
					   IPTOS_PREC_INTERNETCONTROL) :
					  iph->tos;

	if (ip_options_echo(&icmp_param.replyopts, skb_in))
580
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
581
582
583
584
585
586
587
588
589
590
591


	/*
	 *	Prepare data for ICMP header.
	 */

	icmp_param.data.icmph.type	 = type;
	icmp_param.data.icmph.code	 = code;
	icmp_param.data.icmph.un.gateway = info;
	icmp_param.data.icmph.checksum	 = 0;
	icmp_param.skb	  = skb_in;
592
	icmp_param.offset = skb_network_offset(skb_in);
593
	inet_sk(sk)->tos = tos;
Linus Torvalds's avatar
Linus Torvalds committed
594
595
	ipc.addr = iph->saddr;
	ipc.opt = &icmp_param.replyopts;
596
	ipc.tx_flags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
597

598
599
600
601
	rt = icmp_route_lookup(net, skb_in, iph, saddr, tos,
			       type, code, &icmp_param);
	if (IS_ERR(rt))
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
602

603
	if (!icmpv4_xrlim_allow(net, rt, type, code))
Linus Torvalds's avatar
Linus Torvalds committed
604
605
606
607
		goto ende;

	/* RFC says return as much as we can without exceeding 576 bytes. */

608
	room = dst_mtu(&rt->dst);
Linus Torvalds's avatar
Linus Torvalds committed
609
610
611
612
613
614
615
616
617
618
	if (room > 576)
		room = 576;
	room -= sizeof(struct iphdr) + icmp_param.replyopts.optlen;
	room -= sizeof(struct icmphdr);

	icmp_param.data_len = skb_in->len - icmp_param.offset;
	if (icmp_param.data_len > room)
		icmp_param.data_len = room;
	icmp_param.head_len = sizeof(struct icmphdr);

619
	icmp_push_reply(&icmp_param, &ipc, &rt);
Linus Torvalds's avatar
Linus Torvalds committed
620
621
622
ende:
	ip_rt_put(rt);
out_unlock:
623
	icmp_xmit_unlock(sk);
Linus Torvalds's avatar
Linus Torvalds committed
624
625
out:;
}
626
EXPORT_SYMBOL(icmp_send);
Linus Torvalds's avatar
Linus Torvalds committed
627
628
629
630
631
632
633
634
635
636
637


/*
 *	Handle ICMP_DEST_UNREACH, ICMP_TIME_EXCEED, and ICMP_QUENCH.
 */

static void icmp_unreach(struct sk_buff *skb)
{
	struct iphdr *iph;
	struct icmphdr *icmph;
	int hash, protocol;
638
	const struct net_protocol *ipprot;
Linus Torvalds's avatar
Linus Torvalds committed
639
	u32 info = 0;
640
641
	struct net *net;

Eric Dumazet's avatar
Eric Dumazet committed
642
	net = dev_net(skb_dst(skb)->dev);
Linus Torvalds's avatar
Linus Torvalds committed
643
644
645
646
647
648
649
650
651
652

	/*
	 *	Incomplete header ?
	 * 	Only checks for the IP header, there should be an
	 *	additional check for longer headers in upper levels.
	 */

	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
		goto out_err;

653
	icmph = icmp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
654
655
656
657
658
659
660
661
662
663
664
665
666
667
	iph   = (struct iphdr *)skb->data;

	if (iph->ihl < 5) /* Mangled header, drop. */
		goto out_err;

	if (icmph->type == ICMP_DEST_UNREACH) {
		switch (icmph->code & 15) {
		case ICMP_NET_UNREACH:
		case ICMP_HOST_UNREACH:
		case ICMP_PROT_UNREACH:
		case ICMP_PORT_UNREACH:
			break;
		case ICMP_FRAG_NEEDED:
			if (ipv4_config.no_pmtu_disc) {
668
669
				LIMIT_NETDEBUG(KERN_INFO "ICMP: %pI4: fragmentation needed and DF set.\n",
					       &iph->daddr);
Linus Torvalds's avatar
Linus Torvalds committed
670
			} else {
671
				info = ip_rt_frag_needed(net, iph,
672
673
							 ntohs(icmph->un.frag.mtu),
							 skb->dev);
Linus Torvalds's avatar
Linus Torvalds committed
674
675
676
677
678
				if (!info)
					goto out;
			}
			break;
		case ICMP_SR_FAILED:
679
680
			LIMIT_NETDEBUG(KERN_INFO "ICMP: %pI4: Source Route Failed.\n",
				       &iph->daddr);
Linus Torvalds's avatar
Linus Torvalds committed
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
			break;
		default:
			break;
		}
		if (icmph->code > NR_ICMP_UNREACH)
			goto out;
	} else if (icmph->type == ICMP_PARAMETERPROB)
		info = ntohl(icmph->un.gateway) >> 24;

	/*
	 *	Throw it at our lower layers
	 *
	 *	RFC 1122: 3.2.2 MUST extract the protocol ID from the passed
	 *		  header.
	 *	RFC 1122: 3.2.2.1 MUST pass ICMP unreach messages to the
	 *		  transport layer.
	 *	RFC 1122: 3.2.2.2 MUST pass ICMP time expired messages to
	 *		  transport layer.
	 */

	/*
	 *	Check the other end isnt violating RFC 1122. Some routers send
	 *	bogus responses to broadcast frames. If you see this message
	 *	first check your netmask matches at both ends, if it does then
	 *	get the other vendor to fix their kit.
	 */

708
	if (!net->ipv4.sysctl_icmp_ignore_bogus_error_responses &&
709
	    inet_addr_type(net, iph->daddr) == RTN_BROADCAST) {
Linus Torvalds's avatar
Linus Torvalds committed
710
		if (net_ratelimit())
711
			printk(KERN_WARNING "%pI4 sent an invalid ICMP "
Linus Torvalds's avatar
Linus Torvalds committed
712
					    "type %u, code %u "
713
714
					    "error to a broadcast: %pI4 on %s\n",
			       &ip_hdr(skb)->saddr,
Linus Torvalds's avatar
Linus Torvalds committed
715
			       icmph->type, icmph->code,
716
			       &iph->daddr,
Linus Torvalds's avatar
Linus Torvalds committed
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
			       skb->dev->name);
		goto out;
	}

	/* Checkin full IP header plus 8 bytes of protocol to
	 * avoid additional coding at protocol handlers.
	 */
	if (!pskb_may_pull(skb, iph->ihl * 4 + 8))
		goto out;

	iph = (struct iphdr *)skb->data;
	protocol = iph->protocol;

	/*
	 *	Deliver ICMP message to raw sockets. Pretty useless feature?
	 */
733
	raw_icmp_error(skb, protocol, info);
Linus Torvalds's avatar
Linus Torvalds committed
734
735
736
737
738
739
740
741
742
743
744

	hash = protocol & (MAX_INET_PROTOS - 1);
	rcu_read_lock();
	ipprot = rcu_dereference(inet_protos[hash]);
	if (ipprot && ipprot->err_handler)
		ipprot->err_handler(skb, info);
	rcu_read_unlock();

out:
	return;
out_err:
745
	ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds's avatar
Linus Torvalds committed
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
	goto out;
}


/*
 *	Handle ICMP_REDIRECT.
 */

static void icmp_redirect(struct sk_buff *skb)
{
	struct iphdr *iph;

	if (skb->len < sizeof(struct iphdr))
		goto out_err;

	/*
	 *	Get the copied header of the packet that caused the redirect
	 */
	if (!pskb_may_pull(skb, sizeof(struct iphdr)))
		goto out;

	iph = (struct iphdr *)skb->data;

769
	switch (icmp_hdr(skb)->code & 7) {
Linus Torvalds's avatar
Linus Torvalds committed
770
771
772
773
774
775
776
	case ICMP_REDIR_NET:
	case ICMP_REDIR_NETTOS:
		/*
		 * As per RFC recommendations now handle it as a host redirect.
		 */
	case ICMP_REDIR_HOST:
	case ICMP_REDIR_HOSTTOS:
777
		ip_rt_redirect(ip_hdr(skb)->saddr, iph->daddr,
778
			       icmp_hdr(skb)->un.gateway,
779
			       iph->saddr, skb->dev);
Linus Torvalds's avatar
Linus Torvalds committed
780
		break;
781
	}
Linus Torvalds's avatar
Linus Torvalds committed
782
783
784
out:
	return;
out_err:
785
	ICMP_INC_STATS_BH(dev_net(skb->dev), ICMP_MIB_INERRORS);
Linus Torvalds's avatar
Linus Torvalds committed
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
	goto out;
}

/*
 *	Handle ICMP_ECHO ("ping") requests.
 *
 *	RFC 1122: 3.2.2.6 MUST have an echo server that answers ICMP echo
 *		  requests.
 *	RFC 1122: 3.2.2.6 Data received in the ICMP_ECHO request MUST be
 *		  included in the reply.
 *	RFC 1812: 4.3.3.6 SHOULD have a config option for silently ignoring
 *		  echo requests, MUST have default=NOT.
 *	See also WRT handling of options once they are done and working.
 */

static void icmp_echo(struct sk_buff *skb)
{
803
804
	struct net *net;

Eric Dumazet's avatar
Eric Dumazet committed
805
	net = dev_net(skb_dst(skb)->dev);
806
	if (!net->ipv4.sysctl_icmp_echo_ignore_all) {
Linus Torvalds's avatar
Linus Torvalds committed
807
808
		struct icmp_bxm icmp_param;

809
		icmp_param.data.icmph	   = *icmp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
		icmp_param.data.icmph.type = ICMP_ECHOREPLY;
		icmp_param.skb		   = skb;
		icmp_param.offset	   = 0;
		icmp_param.data_len	   = skb->len;
		icmp_param.head_len	   = sizeof(struct icmphdr);
		icmp_reply(&icmp_param, skb);
	}
}

/*
 *	Handle ICMP Timestamp requests.
 *	RFC 1122: 3.2.2.8 MAY implement ICMP timestamp requests.
 *		  SHOULD be in the kernel for minimum random latency.
 *		  MUST be accurate to a few minutes.
 *		  MUST be updated at least at 15Hz.
 */
static void icmp_timestamp(struct sk_buff *skb)
{
828
	struct timespec tv;
Linus Torvalds's avatar
Linus Torvalds committed
829
830
831
832
833
834
835
836
837
838
	struct icmp_bxm icmp_param;
	/*
	 *	Too short.
	 */
	if (skb->len < 4)
		goto out_err;

	/*
	 *	Fill in the current time as ms since midnight UT:
	 */
839
840
841
	getnstimeofday(&tv);
	icmp_param.data.times[1] = htonl((tv.tv_sec % 86400) * MSEC_PER_SEC +
					 tv.tv_nsec / NSEC_PER_MSEC);
Linus Torvalds's avatar
Linus Torvalds committed
842
843
844
	icmp_param.data.times[2] = icmp_param.data.times[1];
	if (skb_copy_bits(skb, 0, &icmp_param.data.times[0], 4))
		BUG();
845
	icmp_param.data.icmph	   = *icmp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
846
847
848
849
850
851
852
853
854
855
	icmp_param.data.icmph.type = ICMP_TIMESTAMPREPLY;
	icmp_param.data.icmph.code = 0;
	icmp_param.skb		   = skb;
	icmp_param.offset	   = 0;
	icmp_param.data_len	   = 0;
	icmp_param.head_len	   = sizeof(struct icmphdr) + 12;
	icmp_reply(&icmp_param, skb);
out:
	return;
out_err:
Eric Dumazet's avatar
Eric Dumazet committed
856
	ICMP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), ICMP_MIB_INERRORS);
Linus Torvalds's avatar
Linus Torvalds committed
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
	goto out;
}


/*
 *	Handle ICMP_ADDRESS_MASK requests.  (RFC950)
 *
 * RFC1122 (3.2.2.9).  A host MUST only send replies to
 * ADDRESS_MASK requests if it's been configured as an address mask
 * agent.  Receiving a request doesn't constitute implicit permission to
 * act as one. Of course, implementing this correctly requires (SHOULD)
 * a way to turn the functionality on and off.  Another one for sysctl(),
 * I guess. -- MS
 *
 * RFC1812 (4.3.3.9).	A router MUST implement it.
 *			A router SHOULD have switch turning it on/off.
 *		      	This switch MUST be ON by default.
 *
 * Gratuitous replies, zero-source replies are not implemented,
 * that complies with RFC. DO NOT implement them!!! All the idea
 * of broadcast addrmask replies as specified in RFC950 is broken.
 * The problem is that it is not uncommon to have several prefixes
 * on one physical interface. Moreover, addrmask agent can even be
 * not aware of existing another prefixes.
 * If source is zero, addrmask agent cannot choose correct prefix.
 * Gratuitous mask announcements suffer from the same problem.
 * RFC1812 explains it, but still allows to use ADDRMASK,
 * that is pretty silly. --ANK
 *
 * All these rules are so bizarre, that I removed kernel addrmask
 * support at all. It is wrong, it is obsolete, nobody uses it in
 * any case. --ANK
 *
 * Furthermore you can do it with a usermode address agent program
 * anyway...
 */

static void icmp_address(struct sk_buff *skb)
{
#if 0
	if (net_ratelimit())
		printk(KERN_DEBUG "a guy asks for address mask. Who is it?\n");
#endif
}

/*
 * RFC1812 (4.3.3.9).	A router SHOULD listen all replies, and complain
 *			loudly if an inconsistency is found.
905
 * called with rcu_read_lock()
Linus Torvalds's avatar
Linus Torvalds committed
906
907
908
909
 */

static void icmp_address_reply(struct sk_buff *skb)
{
Eric Dumazet's avatar
Eric Dumazet committed
910
	struct rtable *rt = skb_rtable(skb);
Linus Torvalds's avatar
Linus Torvalds committed
911
912
913
914
915
	struct net_device *dev = skb->dev;
	struct in_device *in_dev;
	struct in_ifaddr *ifa;

	if (skb->len < 4 || !(rt->rt_flags&RTCF_DIRECTSRC))
916
		return;
Linus Torvalds's avatar
Linus Torvalds committed
917

918
	in_dev = __in_dev_get_rcu(dev);
Linus Torvalds's avatar
Linus Torvalds committed
919
	if (!in_dev)
920
921
		return;

Linus Torvalds's avatar
Linus Torvalds committed
922
923
924
	if (in_dev->ifa_list &&
	    IN_DEV_LOG_MARTIANS(in_dev) &&
	    IN_DEV_FORWARD(in_dev)) {
Al Viro's avatar
Al Viro committed
925
		__be32 _mask, *mp;
Linus Torvalds's avatar
Linus Torvalds committed
926
927

		mp = skb_header_pointer(skb, 0, sizeof(_mask), &_mask);
928
		BUG_ON(mp == NULL);
Linus Torvalds's avatar
Linus Torvalds committed
929
930
931
932
933
934
		for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
			if (*mp == ifa->ifa_mask &&
			    inet_ifa_match(rt->rt_src, ifa))
				break;
		}
		if (!ifa && net_ratelimit()) {
935
936
			printk(KERN_INFO "Wrong address mask %pI4 from %s/%pI4\n",
			       mp, dev->name, &rt->rt_src);
Linus Torvalds's avatar
Linus Torvalds committed
937
938
939
940
941
942
943
944
945
946
947
948
949
950
		}
	}
}

static void icmp_discard(struct sk_buff *skb)
{
}

/*
 *	Deal with incoming ICMP packets.
 */
int icmp_rcv(struct sk_buff *skb)
{
	struct icmphdr *icmph;
Eric Dumazet's avatar
Eric Dumazet committed
951
	struct rtable *rt = skb_rtable(skb);
952
	struct net *net = dev_net(rt->dst.dev);
Linus Torvalds's avatar
Linus Torvalds committed
953

954
	if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
955
		struct sec_path *sp = skb_sec_path(skb);
956
957
		int nh;

958
		if (!(sp && sp->xvec[sp->len - 1]->props.flags &
959
960
961
				 XFRM_STATE_ICMP))
			goto drop;

962
963
964
965
966
967
968
969
970
971
972
973
		if (!pskb_may_pull(skb, sizeof(*icmph) + sizeof(struct iphdr)))
			goto drop;

		nh = skb_network_offset(skb);
		skb_set_network_header(skb, sizeof(*icmph));

		if (!xfrm4_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
			goto drop;

		skb_set_network_header(skb, nh);
	}

974
	ICMP_INC_STATS_BH(net, ICMP_MIB_INMSGS);
Linus Torvalds's avatar
Linus Torvalds committed
975
976

	switch (skb->ip_summed) {
977
	case CHECKSUM_COMPLETE:
978
		if (!csum_fold(skb->csum))
Linus Torvalds's avatar
Linus Torvalds committed
979
			break;
980
		/* fall through */
Linus Torvalds's avatar
Linus Torvalds committed
981
	case CHECKSUM_NONE:
982
983
		skb->csum = 0;
		if (__skb_checksum_complete(skb))
Linus Torvalds's avatar
Linus Torvalds committed
984
985
986
			goto error;
	}

987
988
	if (!pskb_pull(skb, sizeof(*icmph)))
		goto error;
Linus Torvalds's avatar
Linus Torvalds committed
989

990
	icmph = icmp_hdr(skb);
Linus Torvalds's avatar
Linus Torvalds committed
991

992
	ICMPMSGIN_INC_STATS_BH(net, icmph->type);
Linus Torvalds's avatar
Linus Torvalds committed
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
	/*
	 *	18 is the highest 'known' ICMP type. Anything else is a mystery
	 *
	 *	RFC 1122: 3.2.2  Unknown ICMP messages types MUST be silently
	 *		  discarded.
	 */
	if (icmph->type > NR_ICMP_TYPES)
		goto error;


	/*
	 *	Parse the ICMP message
	 */

1007
	if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
Linus Torvalds's avatar
Linus Torvalds committed
1008
1009
1010
1011
1012
1013
		/*
		 *	RFC 1122: 3.2.2.6 An ICMP_ECHO to broadcast MAY be
		 *	  silently ignored (we let user decide with a sysctl).
		 *	RFC 1122: 3.2.2.8 An ICMP_TIMESTAMP MAY be silently
		 *	  discarded if to broadcast/multicast.
		 */
1014
1015
		if ((icmph->type == ICMP_ECHO ||
		     icmph->type == ICMP_TIMESTAMP) &&
1016
		    net->ipv4.sysctl_icmp_echo_ignore_broadcasts) {
Linus Torvalds's avatar
Linus Torvalds committed
1017
1018
1019
1020
1021
1022
1023
			goto error;
		}
		if (icmph->type != ICMP_ECHO &&
		    icmph->type != ICMP_TIMESTAMP &&
		    icmph->type != ICMP_ADDRESS &&
		    icmph->type != ICMP_ADDRESSREPLY) {
			goto error;
1024
		}
Linus Torvalds's avatar
Linus Torvalds committed
1025
1026
1027
1028
1029
1030
1031
1032
	}

	icmp_pointers[icmph->type].handler(skb);

drop:
	kfree_skb(skb);
	return 0;
error:
1033
	ICMP_INC_STATS_BH(net, ICMP_MIB_INERRORS);
Linus Torvalds's avatar
Linus Torvalds committed
1034
1035
1036
1037
1038
1039
	goto drop;
}

/*
 *	This table is the definition of how we handle ICMP.
 */
1040
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
Linus Torvalds's avatar
Linus Torvalds committed
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
	[ICMP_ECHOREPLY] = {
		.handler = icmp_discard,
	},
	[1] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[2] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[ICMP_DEST_UNREACH] = {
		.handler = icmp_unreach,
		.error = 1,
	},
	[ICMP_SOURCE_QUENCH] = {
		.handler = icmp_unreach,
		.error = 1,
	},
	[ICMP_REDIRECT] = {
		.handler = icmp_redirect,
		.error = 1,
	},
	[6] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[7] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[ICMP_ECHO] = {
		.handler = icmp_echo,
	},
	[9] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[10] = {
		.handler = icmp_discard,
		.error = 1,
	},
	[ICMP_TIME_EXCEEDED] = {
		.handler = icmp_unreach,
		.error = 1,
	},
	[ICMP_PARAMETERPROB] = {
		.handler = icmp_unreach,
		.error = 1,
	},
	[ICMP_TIMESTAMP] = {
		.handler = icmp_timestamp,
	},
	[ICMP_TIMESTAMPREPLY] = {
		.handler = icmp_discard,
	},
	[ICMP_INFO_REQUEST] = {
		.handler = icmp_discard,
	},
1100
	[ICMP_INFO_REPLY] = {
Linus Torvalds's avatar
Linus Torvalds committed
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
		.handler = icmp_discard,
	},
	[ICMP_ADDRESS] = {
		.handler = icmp_address,
	},
	[ICMP_ADDRESSREPLY] = {
		.handler = icmp_address_reply,
	},
};

1111
static void __net_exit icmp_sk_exit(struct net *net)
Linus Torvalds's avatar
Linus Torvalds committed
1112
1113
1114
{
	int i;

1115
	for_each_possible_cpu(i)
1116
		inet_ctl_sock_destroy(net->ipv4.icmp_sk[i]);
1117
1118
	kfree(net->ipv4.icmp_sk);
	net->ipv4.icmp_sk = NULL;
1119
}
Linus Torvalds's avatar
Linus Torvalds committed
1120

1121
static int __net_init icmp_sk_init(struct net *net)
1122
1123
1124
{
	int i, err;

1125
1126
1127
	net->ipv4.icmp_sk =
		kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
	if (net->ipv4.icmp_sk == NULL)
1128
1129
		return -ENOMEM;

1130
	for_each_possible_cpu(i) {
1131
		struct sock *sk;
Linus Torvalds's avatar
Linus Torvalds committed
1132

1133
1134
		err = inet_ctl_sock_create(&sk, PF_INET,
					   SOCK_RAW, IPPROTO_ICMP, net);
Linus Torvalds's avatar
Linus Torvalds committed
1135
		if (err < 0)
1136
			goto fail;
Linus Torvalds's avatar
Linus Torvalds committed
1137

1138
		net->ipv4.icmp_sk[i] = sk;
Linus Torvalds's avatar
Linus Torvalds committed
1139
1140
1141
1142

		/* Enough space for 2 64K ICMP packets, including
		 * sk_buff struct overhead.
		 */
1143
		sk->sk_sndbuf =
Linus Torvalds's avatar
Linus Torvalds committed
1144
1145
			(2 * ((64 * 1024) + sizeof(struct sk_buff)));

1146
1147
1148
1149
		/*
		 * Speedup sock_wfree()
		 */
		sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
1150
		inet_sk(sk)->pmtudisc = IP_PMTUDISC_DONT;
Linus Torvalds's avatar
Linus Torvalds committed
1151
	}
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175

	/* Control parameters for ECHO replies. */
	net->ipv4.sysctl_icmp_echo_ignore_all = 0;
	net->ipv4.sysctl_icmp_echo_ignore_broadcasts = 1;

	/* Control parameter - ignore bogus broadcast responses? */
	net->ipv4.sysctl_icmp_ignore_bogus_error_responses = 1;

	/*
	 * 	Configurable global rate limit.
	 *
	 *	ratelimit defines tokens/packet consumed for dst->rate_token
	 *	bucket ratemask defines which icmp types are ratelimited by
	 *	setting	it's bit position.
	 *
	 *	default:
	 *	dest unreachable (3), source quench (4),
	 *	time exceeded (11), parameter problem (12)
	 */

	net->ipv4.sysctl_icmp_ratelimit = 1 * HZ;
	net->ipv4.sysctl_icmp_ratemask = 0x1818;
	net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr = 0;

1176
1177
1178
	return 0;

fail:
1179
	for_each_possible_cpu(i)
1180
		inet_ctl_sock_destroy(net->ipv4.icmp_sk[i]);
1181
	kfree(net->ipv4.icmp_sk);
1182
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
1183
1184
}

1185
1186
1187
1188
1189
1190
1191
static struct pernet_operations __net_initdata icmp_sk_ops = {
       .init = icmp_sk_init,
       .exit = icmp_sk_exit,
};

int __init icmp_init(void)
{
Eric W. Biederman's avatar
Eric W. Biederman committed
1192
	return register_pernet_subsys(&icmp_sk_ops);
1193
}