2019-05-27 00:55:01 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* NET3: Implementation of the ICMP protocol layer.
|
|
|
|
*
|
2008-10-13 20:01:08 -06:00
|
|
|
* Alan Cox, <alan@lxorguk.ukuu.org.uk>
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2012-03-12 01:03:32 -06:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#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>
|
2005-12-26 21:43:12 -07:00
|
|
|
#include <linux/inetdevice.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#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>
|
net: ipv4: add IPPROTO_ICMP socket kind
This patch adds IPPROTO_ICMP socket kind. It makes it possible to send
ICMP_ECHO messages and receive the corresponding ICMP_ECHOREPLY messages
without any special privileges. In other words, the patch makes it
possible to implement setuid-less and CAP_NET_RAW-less /bin/ping. In
order not to increase the kernel's attack surface, the new functionality
is disabled by default, but is enabled at bootup by supporting Linux
distributions, optionally with restriction to a group or a group range
(see below).
Similar functionality is implemented in Mac OS X:
http://www.manpagez.com/man/4/icmp/
A new ping socket is created with
socket(PF_INET, SOCK_DGRAM, PROT_ICMP)
Message identifiers (octets 4-5 of ICMP header) are interpreted as local
ports. Addresses are stored in struct sockaddr_in. No port numbers are
reserved for privileged processes, port 0 is reserved for API ("let the
kernel pick a free number"). There is no notion of remote ports, remote
port numbers provided by the user (e.g. in connect()) are ignored.
Data sent and received include ICMP headers. This is deliberate to:
1) Avoid the need to transport headers values like sequence numbers by
other means.
2) Make it easier to port existing programs using raw sockets.
ICMP headers given to send() are checked and sanitized. The type must be
ICMP_ECHO and the code must be zero (future extensions might relax this,
see below). The id is set to the number (local port) of the socket, the
checksum is always recomputed.
ICMP reply packets received from the network are demultiplexed according
to their id's, and are returned by recv() without any modifications.
IP header information and ICMP errors of those packets may be obtained
via ancillary data (IP_RECVTTL, IP_RETOPTS, and IP_RECVERR). ICMP source
quenches and redirects are reported as fake errors via the error queue
(IP_RECVERR); the next hop address for redirects is saved to ee_info (in
network order).
socket(2) is restricted to the group range specified in
"/proc/sys/net/ipv4/ping_group_range". It is "1 0" by default, meaning
that nobody (not even root) may create ping sockets. Setting it to "100
100" would grant permissions to the single group (to either make
/sbin/ping g+s and owned by this group or to grant permissions to the
"netadmins" group), "0 4294967295" would enable it for the world, "100
4294967295" would enable it for the users, but not daemons.
The existing code might be (in the unlikely case anyone needs it)
extended rather easily to handle other similar pairs of ICMP messages
(Timestamp/Reply, Information Request/Reply, Address Mask Request/Reply
etc.).
Userspace ping util & patch for it:
http://openwall.info/wiki/people/segoon/ping
For Openwall GNU/*/Linux it was the last step on the road to the
setuid-less distro. A revision of this patch (for RHEL5/OpenVZ kernels)
is in use in Owl-current, such as in the 2011/03/12 LiveCD ISOs:
http://mirrors.kernel.org/openwall/Owl/current/iso/
Initially this functionality was written by Pavel Kankovsky for
Linux 2.4.32, but unfortunately it was never made public.
All ping options (-b, -p, -Q, -R, -s, -t, -T, -M, -I), are tested with
the patch.
PATCH v3:
- switched to flowi4.
- minor changes to be consistent with raw sockets code.
PATCH v2:
- changed ping_debug() to pr_debug().
- removed CONFIG_IP_PING.
- removed ping_seq_fops.owner field (unused for procfs).
- switched to proc_net_fops_create().
- switched to %pK in seq_printf().
PATCH v1:
- fixed checksumming bug.
- CAP_NET_RAW may not create icmp sockets anymore.
RFC v2:
- minor cleanups.
- introduced sysctl'able group range to restrict socket(2).
Signed-off-by: Vasiliy Kulikov <segoon@openwall.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-05-13 04:01:00 -06:00
|
|
|
#include <net/ping.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/init.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/checksum.h>
|
2007-12-12 11:44:43 -07:00
|
|
|
#include <net/xfrm.h>
|
2008-04-03 15:29:00 -06:00
|
|
|
#include <net/inet_common.h>
|
2012-06-28 04:59:11 -06:00
|
|
|
#include <net/ip_fib.h>
|
2015-09-29 21:07:13 -06:00
|
|
|
#include <net/l3mdev.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Build xmit assembly blocks
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct icmp_bxm {
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int offset;
|
|
|
|
int data_len;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
struct icmphdr icmph;
|
2006-09-27 19:38:30 -06:00
|
|
|
__be32 times[3];
|
2005-04-16 16:20:36 -06:00
|
|
|
} data;
|
|
|
|
int head_len;
|
2011-04-21 03:45:37 -06:00
|
|
|
struct ip_options_data replyopts;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/* 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'. */
|
|
|
|
|
2010-01-22 03:18:25 -07:00
|
|
|
const struct icmp_err icmp_err_convert[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
.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,
|
|
|
|
},
|
|
|
|
};
|
2010-07-09 15:22:10 -06:00
|
|
|
EXPORT_SYMBOL(icmp_err_convert);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ICMP control array. This specifies what to do with each ICMP.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct icmp_control {
|
2014-11-17 15:04:29 -07:00
|
|
|
bool (*handler)(struct sk_buff *skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
short error; /* This ICMP is classed as an error message */
|
|
|
|
};
|
|
|
|
|
2005-11-29 17:21:38 -07:00
|
|
|
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES+1];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2008-02-29 12:19:58 -07:00
|
|
|
static struct sock *icmp_sk(struct net *net)
|
|
|
|
{
|
2019-05-31 20:09:02 -06:00
|
|
|
return this_cpu_read(*net->ipv4.icmp_sk);
|
2008-02-29 12:19:58 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:14 -07:00
|
|
|
/* Called with BH disabled */
|
2008-08-23 05:43:33 -06:00
|
|
|
static inline struct sock *icmp_xmit_lock(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-08-23 05:43:33 -06:00
|
|
|
struct sock *sk;
|
|
|
|
|
|
|
|
sk = icmp_sk(net);
|
|
|
|
|
2008-02-29 12:16:46 -07:00
|
|
|
if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* This can happen if the output path signals a
|
|
|
|
* dst_link_failure() for an outgoing ICMP packet.
|
|
|
|
*/
|
2008-08-23 05:43:33 -06:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-08-23 05:43:33 -06:00
|
|
|
return sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-29 12:16:46 -07:00
|
|
|
static inline void icmp_xmit_unlock(struct sock *sk)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2017-01-09 08:04:14 -07:00
|
|
|
spin_unlock(&sk->sk_lock.slock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-09-19 08:38:40 -06:00
|
|
|
int sysctl_icmp_msgs_per_sec __read_mostly = 1000;
|
|
|
|
int sysctl_icmp_msgs_burst __read_mostly = 50;
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
spinlock_t lock;
|
|
|
|
u32 credit;
|
|
|
|
u32 stamp;
|
|
|
|
} icmp_global = {
|
|
|
|
.lock = __SPIN_LOCK_UNLOCKED(icmp_global.lock),
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* icmp_global_allow - Are we allowed to send one more ICMP message ?
|
|
|
|
*
|
|
|
|
* Uses a token bucket to limit our ICMP messages to sysctl_icmp_msgs_per_sec.
|
|
|
|
* Returns false if we reached the limit and can not send another packet.
|
|
|
|
* Note: called with BH disabled
|
|
|
|
*/
|
|
|
|
bool icmp_global_allow(void)
|
|
|
|
{
|
|
|
|
u32 credit, delta, incr = 0, now = (u32)jiffies;
|
|
|
|
bool rc = false;
|
|
|
|
|
|
|
|
/* Check if token bucket is empty and cannot be refilled
|
2019-11-08 11:34:47 -07:00
|
|
|
* without taking the spinlock. The READ_ONCE() are paired
|
|
|
|
* with the following WRITE_ONCE() in this same function.
|
2014-09-19 08:38:40 -06:00
|
|
|
*/
|
2019-11-08 11:34:47 -07:00
|
|
|
if (!READ_ONCE(icmp_global.credit)) {
|
|
|
|
delta = min_t(u32, now - READ_ONCE(icmp_global.stamp), HZ);
|
2014-09-19 08:38:40 -06:00
|
|
|
if (delta < HZ / 50)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock(&icmp_global.lock);
|
|
|
|
delta = min_t(u32, now - icmp_global.stamp, HZ);
|
|
|
|
if (delta >= HZ / 50) {
|
|
|
|
incr = sysctl_icmp_msgs_per_sec * delta / HZ ;
|
|
|
|
if (incr)
|
2019-11-08 11:34:47 -07:00
|
|
|
WRITE_ONCE(icmp_global.stamp, now);
|
2014-09-19 08:38:40 -06:00
|
|
|
}
|
|
|
|
credit = min_t(u32, icmp_global.credit + incr, sysctl_icmp_msgs_burst);
|
|
|
|
if (credit) {
|
|
|
|
credit--;
|
|
|
|
rc = true;
|
|
|
|
}
|
2019-11-08 11:34:47 -07:00
|
|
|
WRITE_ONCE(icmp_global.credit, credit);
|
2014-09-19 08:38:40 -06:00
|
|
|
spin_unlock(&icmp_global.lock);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(icmp_global_allow);
|
|
|
|
|
2017-01-09 08:04:09 -07:00
|
|
|
static bool icmpv4_mask_allow(struct net *net, int type, int code)
|
|
|
|
{
|
|
|
|
if (type > NR_ICMP_TYPES)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Don't limit PMTU discovery. */
|
|
|
|
if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Limit if icmp type is enabled in ratemask. */
|
|
|
|
if (!((1 << type) & net->ipv4.sysctl_icmp_ratemask))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool icmpv4_global_allow(struct net *net, int type, int code)
|
|
|
|
{
|
|
|
|
if (icmpv4_mask_allow(net, type, code))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (icmp_global_allow())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Send an ICMP frame.
|
|
|
|
*/
|
|
|
|
|
2014-09-19 08:38:40 -06:00
|
|
|
static bool icmpv4_xrlim_allow(struct net *net, struct rtable *rt,
|
|
|
|
struct flowi4 *fl4, int type, int code)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-06-11 00:31:35 -06:00
|
|
|
struct dst_entry *dst = &rt->dst;
|
2017-01-09 08:04:09 -07:00
|
|
|
struct inet_peer *peer;
|
2011-02-04 16:55:25 -07:00
|
|
|
bool rc = true;
|
2017-01-09 08:04:09 -07:00
|
|
|
int vif;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:09 -07:00
|
|
|
if (icmpv4_mask_allow(net, type, code))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* No rate limit on loopback */
|
|
|
|
if (dst->dev && (dst->dev->flags&IFF_LOOPBACK))
|
2007-02-09 07:24:47 -07:00
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:09 -07:00
|
|
|
vif = l3mdev_master_ifindex(dst->dev);
|
|
|
|
peer = inet_getpeer_v4(net->ipv4.peers, fl4->daddr, vif, 1);
|
|
|
|
rc = inet_peer_xrlim_allow(peer, net->ipv4.sysctl_icmp_ratelimit);
|
|
|
|
if (peer)
|
|
|
|
inet_putpeer(peer);
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maintain the counters used in the SNMP statistics for outgoing ICMP
|
|
|
|
*/
|
2008-07-15 00:00:43 -06:00
|
|
|
void icmp_out_count(struct net *net, unsigned char type)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-15 00:03:35 -06:00
|
|
|
ICMPMSGOUT_INC_STATS(net, type);
|
2008-07-15 00:02:35 -06:00
|
|
|
ICMP_INC_STATS(net, ICMP_MIB_OUTMSGS);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2006-11-14 22:36:54 -07:00
|
|
|
__wsum csum;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
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,
|
2011-05-08 18:12:19 -06:00
|
|
|
struct flowi4 *fl4,
|
2008-11-24 16:52:46 -07:00
|
|
|
struct ipcm_cookie *ipc, struct rtable **rt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-29 12:15:42 -07:00
|
|
|
struct sock *sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
sk = icmp_sk(dev_net((*rt)->dst.dev));
|
2011-05-08 18:24:10 -06:00
|
|
|
if (ip_append_data(sk, fl4, icmp_glue_bits, icmp_param,
|
2007-02-09 07:24:47 -07:00
|
|
|
icmp_param->data_len+icmp_param->head_len,
|
|
|
|
icmp_param->head_len,
|
2010-04-03 16:09:04 -06:00
|
|
|
ipc, rt, MSG_DONTWAIT) < 0) {
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(sock_net(sk), ICMP_MIB_OUTERRORS);
|
2008-02-29 12:15:42 -07:00
|
|
|
ip_flush_pending_frames(sk);
|
2010-04-03 16:09:04 -06:00
|
|
|
} else if ((skb = skb_peek(&sk->sk_write_queue)) != NULL) {
|
2007-03-13 11:43:18 -06:00
|
|
|
struct icmphdr *icmph = icmp_hdr(skb);
|
2006-11-14 22:24:49 -07:00
|
|
|
__wsum csum = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb1;
|
|
|
|
|
2008-02-29 12:15:42 -07:00
|
|
|
skb_queue_walk(&sk->sk_write_queue, skb1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
2011-05-08 18:12:19 -06:00
|
|
|
ip_push_pending_frames(sk, fl4);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
2009-06-01 23:14:27 -06:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
2010-06-11 00:31:35 -06:00
|
|
|
struct net *net = dev_net(rt->dst.dev);
|
2011-05-08 18:12:19 -06:00
|
|
|
struct flowi4 fl4;
|
2008-08-23 05:43:33 -06:00
|
|
|
struct sock *sk;
|
|
|
|
struct inet_sock *inet;
|
2012-06-28 04:59:11 -06:00
|
|
|
__be32 daddr, saddr;
|
2014-05-13 11:17:33 -06:00
|
|
|
u32 mark = IP4_REPLY_MARK(net, skb->mark);
|
2017-01-09 08:04:09 -07:00
|
|
|
int type = icmp_param->data.icmph.type;
|
|
|
|
int code = icmp_param->data.icmph.code;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-08-03 10:07:06 -06:00
|
|
|
if (ip_options_echo(net, &icmp_param->replyopts.opt.opt, skb))
|
2006-02-02 18:03:18 -07:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:14 -07:00
|
|
|
/* Needed by both icmp_global_allow and icmp_xmit_lock */
|
|
|
|
local_bh_disable();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:09 -07:00
|
|
|
/* global icmp_msgs_per_sec */
|
|
|
|
if (!icmpv4_global_allow(net, type, code))
|
2017-01-09 08:04:14 -07:00
|
|
|
goto out_bh_enable;
|
|
|
|
|
|
|
|
sk = icmp_xmit_lock(net);
|
|
|
|
if (!sk)
|
|
|
|
goto out_bh_enable;
|
|
|
|
inet = inet_sk(sk);
|
2017-01-09 08:04:09 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
icmp_param->data.icmph.checksum = 0;
|
|
|
|
|
2018-07-06 08:12:54 -06:00
|
|
|
ipcm_init(&ipc);
|
2007-04-20 23:47:35 -06:00
|
|
|
inet->tos = ip_hdr(skb)->tos;
|
2014-05-13 11:17:33 -06:00
|
|
|
sk->sk_mark = mark;
|
2011-05-09 14:28:22 -06:00
|
|
|
daddr = ipc.addr = ip_hdr(skb)->saddr;
|
2012-06-28 04:59:11 -06:00
|
|
|
saddr = fib_compute_spec_dst(skb);
|
2013-09-24 07:43:09 -06:00
|
|
|
|
2011-04-21 03:45:37 -06:00
|
|
|
if (icmp_param->replyopts.opt.opt.optlen) {
|
|
|
|
ipc.opt = &icmp_param->replyopts.opt;
|
|
|
|
if (ipc.opt->opt.srr)
|
|
|
|
daddr = icmp_param->replyopts.opt.opt.faddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-05-08 18:12:19 -06:00
|
|
|
memset(&fl4, 0, sizeof(fl4));
|
|
|
|
fl4.daddr = daddr;
|
2012-06-28 04:59:11 -06:00
|
|
|
fl4.saddr = saddr;
|
2014-05-13 11:17:33 -06:00
|
|
|
fl4.flowi4_mark = mark;
|
2016-11-03 11:23:43 -06:00
|
|
|
fl4.flowi4_uid = sock_net_uid(net, NULL);
|
2011-05-08 18:12:19 -06:00
|
|
|
fl4.flowi4_tos = RT_TOS(ip_hdr(skb)->tos);
|
|
|
|
fl4.flowi4_proto = IPPROTO_ICMP;
|
2015-09-29 21:07:13 -06:00
|
|
|
fl4.flowi4_oif = l3mdev_master_ifindex(skb->dev);
|
2011-05-08 18:12:19 -06:00
|
|
|
security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));
|
|
|
|
rt = ip_route_output_key(net, &fl4);
|
|
|
|
if (IS_ERR(rt))
|
|
|
|
goto out_unlock;
|
2017-01-09 08:04:09 -07:00
|
|
|
if (icmpv4_xrlim_allow(net, rt, &fl4, type, code))
|
2011-05-08 18:12:19 -06:00
|
|
|
icmp_push_reply(icmp_param, &fl4, &ipc, &rt);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_rt_put(rt);
|
|
|
|
out_unlock:
|
2008-02-29 12:16:46 -07:00
|
|
|
icmp_xmit_unlock(sk);
|
2017-01-09 08:04:14 -07:00
|
|
|
out_bh_enable:
|
|
|
|
local_bh_enable();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-05-08 18:12:19 -06:00
|
|
|
static struct rtable *icmp_route_lookup(struct net *net,
|
|
|
|
struct flowi4 *fl4,
|
|
|
|
struct sk_buff *skb_in,
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct iphdr *iph,
|
2014-05-13 11:17:33 -06:00
|
|
|
__be32 saddr, u8 tos, u32 mark,
|
2011-03-01 16:49:55 -07:00
|
|
|
int type, int code,
|
|
|
|
struct icmp_bxm *param)
|
|
|
|
{
|
|
|
|
struct rtable *rt, *rt2;
|
2011-07-22 07:22:10 -06:00
|
|
|
struct flowi4 fl4_dec;
|
2011-03-01 16:49:55 -07:00
|
|
|
int err;
|
|
|
|
|
2011-05-08 18:12:19 -06:00
|
|
|
memset(fl4, 0, sizeof(*fl4));
|
|
|
|
fl4->daddr = (param->replyopts.opt.opt.srr ?
|
|
|
|
param->replyopts.opt.opt.faddr : iph->saddr);
|
|
|
|
fl4->saddr = saddr;
|
2014-05-13 11:17:33 -06:00
|
|
|
fl4->flowi4_mark = mark;
|
2016-11-03 11:23:43 -06:00
|
|
|
fl4->flowi4_uid = sock_net_uid(net, NULL);
|
2011-05-08 18:12:19 -06:00
|
|
|
fl4->flowi4_tos = RT_TOS(tos);
|
|
|
|
fl4->flowi4_proto = IPPROTO_ICMP;
|
|
|
|
fl4->fl4_icmp_type = type;
|
|
|
|
fl4->fl4_icmp_code = code;
|
2016-11-07 13:03:09 -07:00
|
|
|
fl4->flowi4_oif = l3mdev_master_ifindex(skb_dst(skb_in)->dev);
|
2015-08-13 14:59:02 -06:00
|
|
|
|
2011-05-08 18:12:19 -06:00
|
|
|
security_skb_classify_flow(skb_in, flowi4_to_flowi(fl4));
|
2017-05-25 11:42:33 -06:00
|
|
|
rt = ip_route_output_key_hash(net, fl4, skb_in);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt))
|
|
|
|
return rt;
|
2011-03-01 16:49:55 -07:00
|
|
|
|
|
|
|
/* No need to clone since we're just using its address. */
|
|
|
|
rt2 = rt;
|
|
|
|
|
2011-03-11 23:12:47 -07:00
|
|
|
rt = (struct rtable *) xfrm_lookup(net, &rt->dst,
|
2011-05-08 18:12:19 -06:00
|
|
|
flowi4_to_flowi(fl4), NULL, 0);
|
2011-03-02 14:27:41 -07:00
|
|
|
if (!IS_ERR(rt)) {
|
2011-03-01 16:49:55 -07:00
|
|
|
if (rt != rt2)
|
|
|
|
return rt;
|
2011-03-02 14:27:41 -07:00
|
|
|
} else if (PTR_ERR(rt) == -EPERM) {
|
2011-03-01 16:49:55 -07:00
|
|
|
rt = NULL;
|
2011-03-02 14:27:41 -07:00
|
|
|
} else
|
|
|
|
return rt;
|
2011-03-01 16:49:55 -07:00
|
|
|
|
2011-07-22 07:22:10 -06:00
|
|
|
err = xfrm_decode_session_reverse(skb_in, flowi4_to_flowi(&fl4_dec), AF_INET);
|
2011-03-01 16:49:55 -07:00
|
|
|
if (err)
|
|
|
|
goto relookup_failed;
|
|
|
|
|
2016-11-07 13:03:09 -07:00
|
|
|
if (inet_addr_type_dev_table(net, skb_dst(skb_in)->dev,
|
2015-08-13 14:59:05 -06:00
|
|
|
fl4_dec.saddr) == RTN_LOCAL) {
|
2011-07-22 07:22:10 -06:00
|
|
|
rt2 = __ip_route_output_key(net, &fl4_dec);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt2))
|
|
|
|
err = PTR_ERR(rt2);
|
2011-03-01 16:49:55 -07:00
|
|
|
} else {
|
2011-03-11 23:12:47 -07:00
|
|
|
struct flowi4 fl4_2 = {};
|
2011-03-01 16:49:55 -07:00
|
|
|
unsigned long orefdst;
|
|
|
|
|
2011-07-22 07:22:10 -06:00
|
|
|
fl4_2.daddr = fl4_dec.saddr;
|
2011-03-11 23:12:47 -07:00
|
|
|
rt2 = ip_route_output_key(net, &fl4_2);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt2)) {
|
|
|
|
err = PTR_ERR(rt2);
|
2011-03-01 16:49:55 -07:00
|
|
|
goto relookup_failed;
|
2011-03-02 15:31:35 -07:00
|
|
|
}
|
2011-03-01 16:49:55 -07:00
|
|
|
/* Ugh! */
|
|
|
|
orefdst = skb_in->_skb_refdst; /* save old refdst */
|
2015-07-21 02:43:55 -06:00
|
|
|
skb_dst_set(skb_in, NULL);
|
2011-07-22 07:22:10 -06:00
|
|
|
err = ip_route_input(skb_in, fl4_dec.daddr, fl4_dec.saddr,
|
2011-03-01 16:49:55 -07:00
|
|
|
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;
|
|
|
|
|
2011-03-11 23:12:47 -07:00
|
|
|
rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst,
|
2011-07-22 07:22:10 -06:00
|
|
|
flowi4_to_flowi(&fl4_dec), NULL,
|
2011-03-11 23:12:47 -07:00
|
|
|
XFRM_LOOKUP_ICMP);
|
2011-03-02 14:27:41 -07:00
|
|
|
if (!IS_ERR(rt2)) {
|
2011-03-01 16:49:55 -07:00
|
|
|
dst_release(&rt->dst);
|
2011-07-22 07:22:10 -06:00
|
|
|
memcpy(fl4, &fl4_dec, sizeof(*fl4));
|
2011-03-01 16:49:55 -07:00
|
|
|
rt = rt2;
|
2011-03-02 14:27:41 -07:00
|
|
|
} else if (PTR_ERR(rt2) == -EPERM) {
|
|
|
|
if (rt)
|
|
|
|
dst_release(&rt->dst);
|
|
|
|
return rt2;
|
|
|
|
} else {
|
|
|
|
err = PTR_ERR(rt2);
|
|
|
|
goto relookup_failed;
|
2011-03-01 16:49:55 -07:00
|
|
|
}
|
|
|
|
return rt;
|
|
|
|
|
|
|
|
relookup_failed:
|
|
|
|
if (rt)
|
|
|
|
return rt;
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2019-02-25 09:24:15 -07:00
|
|
|
void __icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info,
|
|
|
|
const struct ip_options *opt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct iphdr *iph;
|
|
|
|
int room;
|
2017-01-09 08:04:04 -07:00
|
|
|
struct icmp_bxm icmp_param;
|
2009-06-01 23:14:27 -06:00
|
|
|
struct rtable *rt = skb_rtable(skb_in);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct ipcm_cookie ipc;
|
2011-05-08 18:12:19 -06:00
|
|
|
struct flowi4 fl4;
|
2006-09-26 22:27:54 -06:00
|
|
|
__be32 saddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
u8 tos;
|
2014-05-13 11:17:33 -06:00
|
|
|
u32 mark;
|
2008-01-23 00:50:57 -07:00
|
|
|
struct net *net;
|
2008-02-29 12:19:58 -07:00
|
|
|
struct sock *sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!rt)
|
|
|
|
goto out;
|
2019-08-22 08:19:48 -06:00
|
|
|
|
|
|
|
if (rt->dst.dev)
|
|
|
|
net = dev_net(rt->dst.dev);
|
|
|
|
else if (skb_in->dev)
|
|
|
|
net = dev_net(skb_in->dev);
|
|
|
|
else
|
|
|
|
goto out;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the original header. It is expected to be valid, of course.
|
|
|
|
* Check this, icmp_send is called from the most obscure devices
|
|
|
|
* sometimes.
|
|
|
|
*/
|
2007-04-20 23:47:35 -06:00
|
|
|
iph = ip_hdr(skb_in);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-19 21:29:13 -06:00
|
|
|
if ((u8 *)iph < skb_in->head ||
|
2013-05-28 14:34:27 -06:00
|
|
|
(skb_network_header(skb_in) + sizeof(*iph)) >
|
|
|
|
skb_tail_pointer(skb_in))
|
2005-04-16 16:20:36 -06:00
|
|
|
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,
|
2007-04-10 21:50:43 -06:00
|
|
|
skb_network_header(skb_in) +
|
2005-04-16 16:20:36 -06:00
|
|
|
(iph->ihl << 2) +
|
|
|
|
offsetof(struct icmphdr,
|
|
|
|
type) -
|
|
|
|
skb_in->data,
|
|
|
|
sizeof(_inner_type),
|
|
|
|
&_inner_type);
|
2015-04-03 02:17:26 -06:00
|
|
|
if (!itp)
|
2005-04-16 16:20:36 -06:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-09 08:04:14 -07:00
|
|
|
/* Needed by both icmp_global_allow and icmp_xmit_lock */
|
|
|
|
local_bh_disable();
|
2017-01-09 08:04:09 -07:00
|
|
|
|
2017-06-14 05:27:37 -06:00
|
|
|
/* Check global sysctl_icmp_msgs_per_sec ratelimit, unless
|
|
|
|
* incoming dev is loopback. If outgoing dev change to not be
|
|
|
|
* loopback, then peer ratelimit still work (in icmpv4_xrlim_allow)
|
|
|
|
*/
|
|
|
|
if (!(skb_in->dev && (skb_in->dev->flags&IFF_LOOPBACK)) &&
|
|
|
|
!icmpv4_global_allow(net, type, code))
|
2017-01-09 08:04:14 -07:00
|
|
|
goto out_bh_enable;
|
|
|
|
|
|
|
|
sk = icmp_xmit_lock(net);
|
|
|
|
if (!sk)
|
|
|
|
goto out_bh_enable;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct source address and options.
|
|
|
|
*/
|
|
|
|
|
|
|
|
saddr = iph->daddr;
|
2015-10-14 06:25:53 -06:00
|
|
|
if (!(rt->rt_flags & RTCF_LOCAL)) {
|
2007-06-01 12:45:04 -06:00
|
|
|
struct net_device *dev = NULL;
|
|
|
|
|
2009-11-01 12:31:03 -07:00
|
|
|
rcu_read_lock();
|
2010-11-11 18:07:48 -07:00
|
|
|
if (rt_is_input_route(rt) &&
|
|
|
|
net->ipv4.sysctl_icmp_errors_use_inbound_ifaddr)
|
2012-07-23 17:29:00 -06:00
|
|
|
dev = dev_get_by_index_rcu(net, inet_iif(skb_in));
|
2007-06-01 12:45:04 -06:00
|
|
|
|
2009-11-01 12:31:03 -07:00
|
|
|
if (dev)
|
2019-10-31 18:44:13 -06:00
|
|
|
saddr = inet_select_addr(dev, iph->saddr,
|
|
|
|
RT_SCOPE_LINK);
|
2009-11-01 12:31:03 -07:00
|
|
|
else
|
2005-06-13 16:19:03 -06:00
|
|
|
saddr = 0;
|
2009-11-01 12:31:03 -07:00
|
|
|
rcu_read_unlock();
|
2005-06-13 16:19:03 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
tos = icmp_pointers[type].error ? ((iph->tos & IPTOS_TOS_MASK) |
|
|
|
|
IPTOS_PREC_INTERNETCONTROL) :
|
|
|
|
iph->tos;
|
2014-05-13 11:17:33 -06:00
|
|
|
mark = IP4_REPLY_MARK(net, skb_in->mark);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-02-25 09:24:15 -07:00
|
|
|
if (__ip_options_echo(net, &icmp_param.replyopts.opt.opt, skb_in, opt))
|
2006-02-04 03:09:34 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare data for ICMP header.
|
|
|
|
*/
|
|
|
|
|
2017-01-09 08:04:04 -07:00
|
|
|
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;
|
|
|
|
icmp_param.offset = skb_network_offset(skb_in);
|
2008-02-29 12:16:46 -07:00
|
|
|
inet_sk(sk)->tos = tos;
|
2014-05-13 11:17:33 -06:00
|
|
|
sk->sk_mark = mark;
|
2018-07-06 08:12:54 -06:00
|
|
|
ipcm_init(&ipc);
|
2005-04-16 16:20:36 -06:00
|
|
|
ipc.addr = iph->saddr;
|
2017-01-09 08:04:04 -07:00
|
|
|
ipc.opt = &icmp_param.replyopts.opt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-13 11:17:33 -06:00
|
|
|
rt = icmp_route_lookup(net, &fl4, skb_in, iph, saddr, tos, mark,
|
2017-01-09 08:04:04 -07:00
|
|
|
type, code, &icmp_param);
|
2011-03-01 16:49:55 -07:00
|
|
|
if (IS_ERR(rt))
|
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:09 -07:00
|
|
|
/* peer icmp_ratelimit */
|
2011-05-18 16:42:43 -06:00
|
|
|
if (!icmpv4_xrlim_allow(net, rt, &fl4, type, code))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto ende;
|
|
|
|
|
|
|
|
/* RFC says return as much as we can without exceeding 576 bytes. */
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
room = dst_mtu(&rt->dst);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (room > 576)
|
|
|
|
room = 576;
|
2017-01-09 08:04:04 -07:00
|
|
|
room -= sizeof(struct iphdr) + icmp_param.replyopts.opt.opt.optlen;
|
2005-04-16 16:20:36 -06:00
|
|
|
room -= sizeof(struct icmphdr);
|
|
|
|
|
2017-01-09 08:04:04 -07:00
|
|
|
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);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-01-09 08:04:04 -07:00
|
|
|
icmp_push_reply(&icmp_param, &fl4, &ipc, &rt);
|
2005-04-16 16:20:36 -06:00
|
|
|
ende:
|
|
|
|
ip_rt_put(rt);
|
|
|
|
out_unlock:
|
2008-02-29 12:16:46 -07:00
|
|
|
icmp_xmit_unlock(sk);
|
2017-01-09 08:04:14 -07:00
|
|
|
out_bh_enable:
|
|
|
|
local_bh_enable();
|
2005-04-16 16:20:36 -06:00
|
|
|
out:;
|
|
|
|
}
|
2019-02-25 09:24:15 -07:00
|
|
|
EXPORT_SYMBOL(__icmp_send);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2020-02-11 12:47:05 -07:00
|
|
|
#if IS_ENABLED(CONFIG_NF_NAT)
|
|
|
|
#include <net/netfilter/nf_conntrack.h>
|
|
|
|
void icmp_ndo_send(struct sk_buff *skb_in, int type, int code, __be32 info)
|
|
|
|
{
|
|
|
|
struct sk_buff *cloned_skb = NULL;
|
|
|
|
enum ip_conntrack_info ctinfo;
|
|
|
|
struct nf_conn *ct;
|
|
|
|
__be32 orig_ip;
|
|
|
|
|
|
|
|
ct = nf_ct_get(skb_in, &ctinfo);
|
|
|
|
if (!ct || !(ct->status & IPS_SRC_NAT)) {
|
|
|
|
icmp_send(skb_in, type, code, info);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb_shared(skb_in))
|
|
|
|
skb_in = cloned_skb = skb_clone(skb_in, GFP_ATOMIC);
|
|
|
|
|
|
|
|
if (unlikely(!skb_in || skb_network_header(skb_in) < skb_in->head ||
|
|
|
|
(skb_network_header(skb_in) + sizeof(struct iphdr)) >
|
|
|
|
skb_tail_pointer(skb_in) || skb_ensure_writable(skb_in,
|
|
|
|
skb_network_offset(skb_in) + sizeof(struct iphdr))))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
orig_ip = ip_hdr(skb_in)->saddr;
|
|
|
|
ip_hdr(skb_in)->saddr = ct->tuplehash[0].tuple.src.u3.ip;
|
|
|
|
icmp_send(skb_in, type, code, info);
|
|
|
|
ip_hdr(skb_in)->saddr = orig_ip;
|
|
|
|
out:
|
|
|
|
consume_skb(cloned_skb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(icmp_ndo_send);
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-07-11 19:32:17 -06:00
|
|
|
static void icmp_socket_deliver(struct sk_buff *skb, u32 info)
|
|
|
|
{
|
|
|
|
const struct iphdr *iph = (const struct iphdr *) skb->data;
|
|
|
|
const struct net_protocol *ipprot;
|
|
|
|
int protocol = iph->protocol;
|
|
|
|
|
2012-07-12 09:06:04 -06:00
|
|
|
/* Checkin full IP header plus 8 bytes of protocol to
|
|
|
|
* avoid additional coding at protocol handlers.
|
|
|
|
*/
|
2014-07-31 03:54:32 -06:00
|
|
|
if (!pskb_may_pull(skb, iph->ihl * 4 + 8)) {
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
|
2012-07-12 09:06:04 -06:00
|
|
|
return;
|
2014-07-31 03:54:32 -06:00
|
|
|
}
|
2012-07-12 09:06:04 -06:00
|
|
|
|
2012-07-11 19:32:17 -06:00
|
|
|
raw_icmp_error(skb, protocol, info);
|
|
|
|
|
|
|
|
ipprot = rcu_dereference(inet_protos[protocol]);
|
|
|
|
if (ipprot && ipprot->err_handler)
|
|
|
|
ipprot->err_handler(skb, info);
|
|
|
|
}
|
|
|
|
|
2014-01-09 02:01:17 -07:00
|
|
|
static bool icmp_tag_validation(int proto)
|
|
|
|
{
|
|
|
|
bool ok;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation;
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
icmp: don't fail on fragment reassembly time exceeded
The ICMP implementation currently replies to an ICMP time exceeded message
(type 11) with an ICMP host unreachable message (type 3, code 1).
However, time exceeded messages can either represent "time to live exceeded
in transit" (code 0) or "fragment reassembly time exceeded" (code 1).
Unconditionally replying to "fragment reassembly time exceeded" with
host unreachable messages might cause unjustified connection resets
which are now easily triggered as UFO has been removed, because, in turn,
sending large buffers triggers IP fragmentation.
The issue can be easily reproduced by running a lot of UDP streams
which is likely to trigger IP fragmentation:
# start netserver in the test namespace
ip netns add test
ip netns exec test netserver
# create a VETH pair
ip link add name veth0 type veth peer name veth0 netns test
ip link set veth0 up
ip -n test link set veth0 up
for i in $(seq 20 29); do
# assign addresses to both ends
ip addr add dev veth0 192.168.$i.1/24
ip -n test addr add dev veth0 192.168.$i.2/24
# start the traffic
netperf -L 192.168.$i.1 -H 192.168.$i.2 -t UDP_STREAM -l 0 &
done
# wait
send_data: data send error: No route to host (errno 113)
netperf: send_omni: send_data failed: No route to host
We need to differentiate instead: if fragment reassembly time exceeded
is reported, we need to silently drop the packet,
if time to live exceeded is reported, maintain the current behaviour.
In both cases increment the related error count "icmpInTimeExcds".
While at it, fix a typo in a comment, and convert the if statement
into a switch to mate it more readable.
Signed-off-by: Matteo Croce <mcroce@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-12 08:12:37 -06:00
|
|
|
* Handle ICMP_DEST_UNREACH, ICMP_TIME_EXCEEDED, ICMP_QUENCH, and
|
2013-06-02 18:23:25 -06:00
|
|
|
* ICMP_PARAMETERPROB.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
static bool icmp_unreach(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct iphdr *iph;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct icmphdr *icmph;
|
2008-01-23 00:50:57 -07:00
|
|
|
struct net *net;
|
2012-06-19 19:56:21 -06:00
|
|
|
u32 info = 0;
|
2008-01-23 00:50:57 -07:00
|
|
|
|
2009-06-01 23:19:30 -06:00
|
|
|
net = dev_net(skb_dst(skb)->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2007-03-13 11:43:18 -06:00
|
|
|
icmph = icmp_hdr(skb);
|
2011-04-21 22:53:02 -06:00
|
|
|
iph = (const struct iphdr *)skb->data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (iph->ihl < 5) /* Mangled header, drop. */
|
|
|
|
goto out_err;
|
|
|
|
|
icmp: don't fail on fragment reassembly time exceeded
The ICMP implementation currently replies to an ICMP time exceeded message
(type 11) with an ICMP host unreachable message (type 3, code 1).
However, time exceeded messages can either represent "time to live exceeded
in transit" (code 0) or "fragment reassembly time exceeded" (code 1).
Unconditionally replying to "fragment reassembly time exceeded" with
host unreachable messages might cause unjustified connection resets
which are now easily triggered as UFO has been removed, because, in turn,
sending large buffers triggers IP fragmentation.
The issue can be easily reproduced by running a lot of UDP streams
which is likely to trigger IP fragmentation:
# start netserver in the test namespace
ip netns add test
ip netns exec test netserver
# create a VETH pair
ip link add name veth0 type veth peer name veth0 netns test
ip link set veth0 up
ip -n test link set veth0 up
for i in $(seq 20 29); do
# assign addresses to both ends
ip addr add dev veth0 192.168.$i.1/24
ip -n test addr add dev veth0 192.168.$i.2/24
# start the traffic
netperf -L 192.168.$i.1 -H 192.168.$i.2 -t UDP_STREAM -l 0 &
done
# wait
send_data: data send error: No route to host (errno 113)
netperf: send_omni: send_data failed: No route to host
We need to differentiate instead: if fragment reassembly time exceeded
is reported, we need to silently drop the packet,
if time to live exceeded is reported, maintain the current behaviour.
In both cases increment the related error count "icmpInTimeExcds".
While at it, fix a typo in a comment, and convert the if statement
into a switch to mate it more readable.
Signed-off-by: Matteo Croce <mcroce@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-12 08:12:37 -06:00
|
|
|
switch (icmph->type) {
|
|
|
|
case ICMP_DEST_UNREACH:
|
2005-04-16 16:20:36 -06:00
|
|
|
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:
|
2014-01-09 02:01:17 -07:00
|
|
|
/* for documentation of the ip_no_pmtu_disc
|
|
|
|
* values please see
|
|
|
|
* Documentation/networking/ip-sysctl.txt
|
|
|
|
*/
|
|
|
|
switch (net->ipv4.sysctl_ip_no_pmtu_disc) {
|
|
|
|
default:
|
2014-11-11 11:59:17 -07:00
|
|
|
net_dbg_ratelimited("%pI4: fragmentation needed and DF set\n",
|
|
|
|
&iph->daddr);
|
2014-01-09 02:01:17 -07:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
goto out;
|
|
|
|
case 3:
|
|
|
|
if (!icmp_tag_validation(iph->protocol))
|
|
|
|
goto out;
|
|
|
|
/* fall through */
|
|
|
|
case 0:
|
2012-06-10 01:04:12 -06:00
|
|
|
info = ntohs(icmph->un.frag.mtu);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ICMP_SR_FAILED:
|
2014-11-11 11:59:17 -07:00
|
|
|
net_dbg_ratelimited("%pI4: Source Route Failed\n",
|
|
|
|
&iph->daddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (icmph->code > NR_ICMP_UNREACH)
|
|
|
|
goto out;
|
icmp: don't fail on fragment reassembly time exceeded
The ICMP implementation currently replies to an ICMP time exceeded message
(type 11) with an ICMP host unreachable message (type 3, code 1).
However, time exceeded messages can either represent "time to live exceeded
in transit" (code 0) or "fragment reassembly time exceeded" (code 1).
Unconditionally replying to "fragment reassembly time exceeded" with
host unreachable messages might cause unjustified connection resets
which are now easily triggered as UFO has been removed, because, in turn,
sending large buffers triggers IP fragmentation.
The issue can be easily reproduced by running a lot of UDP streams
which is likely to trigger IP fragmentation:
# start netserver in the test namespace
ip netns add test
ip netns exec test netserver
# create a VETH pair
ip link add name veth0 type veth peer name veth0 netns test
ip link set veth0 up
ip -n test link set veth0 up
for i in $(seq 20 29); do
# assign addresses to both ends
ip addr add dev veth0 192.168.$i.1/24
ip -n test addr add dev veth0 192.168.$i.2/24
# start the traffic
netperf -L 192.168.$i.1 -H 192.168.$i.2 -t UDP_STREAM -l 0 &
done
# wait
send_data: data send error: No route to host (errno 113)
netperf: send_omni: send_data failed: No route to host
We need to differentiate instead: if fragment reassembly time exceeded
is reported, we need to silently drop the packet,
if time to live exceeded is reported, maintain the current behaviour.
In both cases increment the related error count "icmpInTimeExcds".
While at it, fix a typo in a comment, and convert the if statement
into a switch to mate it more readable.
Signed-off-by: Matteo Croce <mcroce@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-12 08:12:37 -06:00
|
|
|
break;
|
|
|
|
case ICMP_PARAMETERPROB:
|
2005-04-16 16:20:36 -06:00
|
|
|
info = ntohl(icmph->un.gateway) >> 24;
|
icmp: don't fail on fragment reassembly time exceeded
The ICMP implementation currently replies to an ICMP time exceeded message
(type 11) with an ICMP host unreachable message (type 3, code 1).
However, time exceeded messages can either represent "time to live exceeded
in transit" (code 0) or "fragment reassembly time exceeded" (code 1).
Unconditionally replying to "fragment reassembly time exceeded" with
host unreachable messages might cause unjustified connection resets
which are now easily triggered as UFO has been removed, because, in turn,
sending large buffers triggers IP fragmentation.
The issue can be easily reproduced by running a lot of UDP streams
which is likely to trigger IP fragmentation:
# start netserver in the test namespace
ip netns add test
ip netns exec test netserver
# create a VETH pair
ip link add name veth0 type veth peer name veth0 netns test
ip link set veth0 up
ip -n test link set veth0 up
for i in $(seq 20 29); do
# assign addresses to both ends
ip addr add dev veth0 192.168.$i.1/24
ip -n test addr add dev veth0 192.168.$i.2/24
# start the traffic
netperf -L 192.168.$i.1 -H 192.168.$i.2 -t UDP_STREAM -l 0 &
done
# wait
send_data: data send error: No route to host (errno 113)
netperf: send_omni: send_data failed: No route to host
We need to differentiate instead: if fragment reassembly time exceeded
is reported, we need to silently drop the packet,
if time to live exceeded is reported, maintain the current behaviour.
In both cases increment the related error count "icmpInTimeExcds".
While at it, fix a typo in a comment, and convert the if statement
into a switch to mate it more readable.
Signed-off-by: Matteo Croce <mcroce@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-10-12 08:12:37 -06:00
|
|
|
break;
|
|
|
|
case ICMP_TIME_EXCEEDED:
|
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INTIMEEXCDS);
|
|
|
|
if (icmph->code == ICMP_EXC_FRAGTIME)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2011-03-30 19:57:33 -06:00
|
|
|
* Check the other end isn't violating RFC 1122. Some routers send
|
2005-04-16 16:20:36 -06:00
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2008-03-26 03:00:21 -06:00
|
|
|
if (!net->ipv4.sysctl_icmp_ignore_bogus_error_responses &&
|
2015-08-13 14:59:05 -06:00
|
|
|
inet_addr_type_dev_table(net, skb->dev, iph->daddr) == RTN_BROADCAST) {
|
2012-05-13 15:56:26 -06:00
|
|
|
net_warn_ratelimited("%pI4 sent an invalid ICMP type %u, code %u error to a broadcast: %pI4 on %s\n",
|
|
|
|
&ip_hdr(skb)->saddr,
|
|
|
|
icmph->type, icmph->code,
|
|
|
|
&iph->daddr, skb->dev->name);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-07-11 19:32:17 -06:00
|
|
|
icmp_socket_deliver(skb, info);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
out:
|
2014-11-17 15:04:29 -07:00
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
out_err:
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
|
2014-11-17 15:04:29 -07:00
|
|
|
return false;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle ICMP_REDIRECT.
|
|
|
|
*/
|
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
static bool icmp_redirect(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-07-11 21:38:08 -06:00
|
|
|
if (skb->len < sizeof(struct iphdr)) {
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(dev_net(skb->dev), ICMP_MIB_INERRORS);
|
2014-11-17 15:04:29 -07:00
|
|
|
return false;
|
2012-07-11 21:38:08 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
if (!pskb_may_pull(skb, sizeof(struct iphdr))) {
|
|
|
|
/* there aught to be a stat */
|
|
|
|
return false;
|
|
|
|
}
|
net: ipv4: add IPPROTO_ICMP socket kind
This patch adds IPPROTO_ICMP socket kind. It makes it possible to send
ICMP_ECHO messages and receive the corresponding ICMP_ECHOREPLY messages
without any special privileges. In other words, the patch makes it
possible to implement setuid-less and CAP_NET_RAW-less /bin/ping. In
order not to increase the kernel's attack surface, the new functionality
is disabled by default, but is enabled at bootup by supporting Linux
distributions, optionally with restriction to a group or a group range
(see below).
Similar functionality is implemented in Mac OS X:
http://www.manpagez.com/man/4/icmp/
A new ping socket is created with
socket(PF_INET, SOCK_DGRAM, PROT_ICMP)
Message identifiers (octets 4-5 of ICMP header) are interpreted as local
ports. Addresses are stored in struct sockaddr_in. No port numbers are
reserved for privileged processes, port 0 is reserved for API ("let the
kernel pick a free number"). There is no notion of remote ports, remote
port numbers provided by the user (e.g. in connect()) are ignored.
Data sent and received include ICMP headers. This is deliberate to:
1) Avoid the need to transport headers values like sequence numbers by
other means.
2) Make it easier to port existing programs using raw sockets.
ICMP headers given to send() are checked and sanitized. The type must be
ICMP_ECHO and the code must be zero (future extensions might relax this,
see below). The id is set to the number (local port) of the socket, the
checksum is always recomputed.
ICMP reply packets received from the network are demultiplexed according
to their id's, and are returned by recv() without any modifications.
IP header information and ICMP errors of those packets may be obtained
via ancillary data (IP_RECVTTL, IP_RETOPTS, and IP_RECVERR). ICMP source
quenches and redirects are reported as fake errors via the error queue
(IP_RECVERR); the next hop address for redirects is saved to ee_info (in
network order).
socket(2) is restricted to the group range specified in
"/proc/sys/net/ipv4/ping_group_range". It is "1 0" by default, meaning
that nobody (not even root) may create ping sockets. Setting it to "100
100" would grant permissions to the single group (to either make
/sbin/ping g+s and owned by this group or to grant permissions to the
"netadmins" group), "0 4294967295" would enable it for the world, "100
4294967295" would enable it for the users, but not daemons.
The existing code might be (in the unlikely case anyone needs it)
extended rather easily to handle other similar pairs of ICMP messages
(Timestamp/Reply, Information Request/Reply, Address Mask Request/Reply
etc.).
Userspace ping util & patch for it:
http://openwall.info/wiki/people/segoon/ping
For Openwall GNU/*/Linux it was the last step on the road to the
setuid-less distro. A revision of this patch (for RHEL5/OpenVZ kernels)
is in use in Owl-current, such as in the 2011/03/12 LiveCD ISOs:
http://mirrors.kernel.org/openwall/Owl/current/iso/
Initially this functionality was written by Pavel Kankovsky for
Linux 2.4.32, but unfortunately it was never made public.
All ping options (-b, -p, -Q, -R, -s, -t, -T, -M, -I), are tested with
the patch.
PATCH v3:
- switched to flowi4.
- minor changes to be consistent with raw sockets code.
PATCH v2:
- changed ping_debug() to pr_debug().
- removed CONFIG_IP_PING.
- removed ping_seq_fops.owner field (unused for procfs).
- switched to proc_net_fops_create().
- switched to %pK in seq_printf().
PATCH v1:
- fixed checksumming bug.
- CAP_NET_RAW may not create icmp sockets anymore.
RFC v2:
- minor cleanups.
- introduced sysctl'able group range to restrict socket(2).
Signed-off-by: Vasiliy Kulikov <segoon@openwall.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-05-13 04:01:00 -06:00
|
|
|
|
2019-08-19 20:46:00 -06:00
|
|
|
icmp_socket_deliver(skb, ntohl(icmp_hdr(skb)->un.gateway));
|
2014-11-17 15:04:29 -07:00
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
static bool icmp_echo(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-03-26 03:00:21 -06:00
|
|
|
struct net *net;
|
|
|
|
|
2009-06-01 23:19:30 -06:00
|
|
|
net = dev_net(skb_dst(skb)->dev);
|
2008-03-26 03:00:21 -06:00
|
|
|
if (!net->ipv4.sysctl_icmp_echo_ignore_all) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct icmp_bxm icmp_param;
|
|
|
|
|
2007-03-13 11:43:18 -06:00
|
|
|
icmp_param.data.icmph = *icmp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
|
|
|
}
|
2014-11-17 15:04:29 -07:00
|
|
|
/* should there be an ICMP stat for ignored echos? */
|
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2014-11-17 15:04:29 -07:00
|
|
|
static bool icmp_timestamp(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct icmp_bxm icmp_param;
|
|
|
|
/*
|
|
|
|
* Too short.
|
|
|
|
*/
|
|
|
|
if (skb->len < 4)
|
|
|
|
goto out_err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fill in the current time as ms since midnight UT:
|
|
|
|
*/
|
2016-02-27 01:32:15 -07:00
|
|
|
icmp_param.data.times[1] = inet_current_timestamp();
|
2005-04-16 16:20:36 -06:00
|
|
|
icmp_param.data.times[2] = icmp_param.data.times[1];
|
2017-10-23 12:08:14 -06:00
|
|
|
|
|
|
|
BUG_ON(skb_copy_bits(skb, 0, &icmp_param.data.times[0], 4));
|
|
|
|
|
2007-03-13 11:43:18 -06:00
|
|
|
icmp_param.data.icmph = *icmp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
2014-11-17 15:04:29 -07:00
|
|
|
return true;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
out_err:
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(dev_net(skb_dst(skb)->dev), ICMP_MIB_INERRORS);
|
2014-11-17 15:04:29 -07:00
|
|
|
return false;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
static bool icmp_discard(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-11-17 15:04:29 -07:00
|
|
|
/* pretend it was a success */
|
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deal with incoming ICMP packets.
|
|
|
|
*/
|
|
|
|
int icmp_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct icmphdr *icmph;
|
2009-06-01 23:14:27 -06:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
2010-06-11 00:31:35 -06:00
|
|
|
struct net *net = dev_net(rt->dst.dev);
|
2014-11-17 15:04:29 -07:00
|
|
|
bool success;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-12 19:54:16 -07:00
|
|
|
if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
|
2008-10-28 14:24:06 -06:00
|
|
|
struct sec_path *sp = skb_sec_path(skb);
|
2007-12-12 11:44:43 -07:00
|
|
|
int nh;
|
|
|
|
|
2008-10-28 14:24:06 -06:00
|
|
|
if (!(sp && sp->xvec[sp->len - 1]->props.flags &
|
2007-12-12 19:54:16 -07:00
|
|
|
XFRM_STATE_ICMP))
|
|
|
|
goto drop;
|
|
|
|
|
2007-12-12 11:44:43 -07:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INMSGS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-05-07 17:52:21 -06:00
|
|
|
if (skb_checksum_simple_validate(skb))
|
|
|
|
goto csum_error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-05 04:15:50 -07:00
|
|
|
if (!pskb_pull(skb, sizeof(*icmph)))
|
|
|
|
goto error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-13 11:43:18 -06:00
|
|
|
icmph = icmp_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-04-27 17:44:33 -06:00
|
|
|
ICMPMSGIN_INC_STATS(net, icmph->type);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
if (rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-07-08 18:34:46 -06:00
|
|
|
if ((icmph->type == ICMP_ECHO ||
|
|
|
|
icmph->type == ICMP_TIMESTAMP) &&
|
2008-03-26 03:00:21 -06:00
|
|
|
net->ipv4.sysctl_icmp_echo_ignore_broadcasts) {
|
2005-04-16 16:20:36 -06:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (icmph->type != ICMP_ECHO &&
|
|
|
|
icmph->type != ICMP_TIMESTAMP &&
|
|
|
|
icmph->type != ICMP_ADDRESS &&
|
|
|
|
icmph->type != ICMP_ADDRESSREPLY) {
|
|
|
|
goto error;
|
2007-02-09 07:24:47 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-17 15:04:29 -07:00
|
|
|
success = icmp_pointers[icmph->type].handler(skb);
|
|
|
|
|
|
|
|
if (success) {
|
|
|
|
consume_skb(skb);
|
2016-12-06 23:52:53 -07:00
|
|
|
return NET_RX_SUCCESS;
|
2014-11-17 15:04:29 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
2016-12-06 23:52:53 -07:00
|
|
|
return NET_RX_DROP;
|
2013-04-29 02:39:56 -06:00
|
|
|
csum_error:
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_CSUMERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
error:
|
2016-04-27 17:44:29 -06:00
|
|
|
__ICMP_INC_STATS(net, ICMP_MIB_INERRORS);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
2018-11-08 04:19:21 -07:00
|
|
|
int icmp_err(struct sk_buff *skb, u32 info)
|
2013-02-21 15:18:44 -07:00
|
|
|
{
|
|
|
|
struct iphdr *iph = (struct iphdr *)skb->data;
|
2013-05-22 14:17:31 -06:00
|
|
|
int offset = iph->ihl<<2;
|
|
|
|
struct icmphdr *icmph = (struct icmphdr *)(skb->data + offset);
|
2013-02-21 15:18:44 -07:00
|
|
|
int type = icmp_hdr(skb)->type;
|
|
|
|
int code = icmp_hdr(skb)->code;
|
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use ping_err to handle all icmp errors except those
|
|
|
|
* triggered by ICMP_ECHOREPLY which sent from kernel.
|
|
|
|
*/
|
|
|
|
if (icmph->type != ICMP_ECHOREPLY) {
|
2013-05-22 14:17:31 -06:00
|
|
|
ping_err(skb, offset, info);
|
2018-11-08 04:19:21 -07:00
|
|
|
return 0;
|
2013-02-21 15:18:44 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
|
2018-09-25 21:56:26 -06:00
|
|
|
ipv4_update_pmtu(skb, net, info, 0, IPPROTO_ICMP);
|
2013-02-21 15:18:44 -07:00
|
|
|
else if (type == ICMP_REDIRECT)
|
2018-09-25 21:56:27 -06:00
|
|
|
ipv4_redirect(skb, net, 0, IPPROTO_ICMP);
|
2018-11-08 04:19:21 -07:00
|
|
|
|
|
|
|
return 0;
|
2013-02-21 15:18:44 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* This table is the definition of how we handle ICMP.
|
|
|
|
*/
|
2005-11-29 17:21:38 -07:00
|
|
|
static const struct icmp_control icmp_pointers[NR_ICMP_TYPES + 1] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
[ICMP_ECHOREPLY] = {
|
net: ipv4: add IPPROTO_ICMP socket kind
This patch adds IPPROTO_ICMP socket kind. It makes it possible to send
ICMP_ECHO messages and receive the corresponding ICMP_ECHOREPLY messages
without any special privileges. In other words, the patch makes it
possible to implement setuid-less and CAP_NET_RAW-less /bin/ping. In
order not to increase the kernel's attack surface, the new functionality
is disabled by default, but is enabled at bootup by supporting Linux
distributions, optionally with restriction to a group or a group range
(see below).
Similar functionality is implemented in Mac OS X:
http://www.manpagez.com/man/4/icmp/
A new ping socket is created with
socket(PF_INET, SOCK_DGRAM, PROT_ICMP)
Message identifiers (octets 4-5 of ICMP header) are interpreted as local
ports. Addresses are stored in struct sockaddr_in. No port numbers are
reserved for privileged processes, port 0 is reserved for API ("let the
kernel pick a free number"). There is no notion of remote ports, remote
port numbers provided by the user (e.g. in connect()) are ignored.
Data sent and received include ICMP headers. This is deliberate to:
1) Avoid the need to transport headers values like sequence numbers by
other means.
2) Make it easier to port existing programs using raw sockets.
ICMP headers given to send() are checked and sanitized. The type must be
ICMP_ECHO and the code must be zero (future extensions might relax this,
see below). The id is set to the number (local port) of the socket, the
checksum is always recomputed.
ICMP reply packets received from the network are demultiplexed according
to their id's, and are returned by recv() without any modifications.
IP header information and ICMP errors of those packets may be obtained
via ancillary data (IP_RECVTTL, IP_RETOPTS, and IP_RECVERR). ICMP source
quenches and redirects are reported as fake errors via the error queue
(IP_RECVERR); the next hop address for redirects is saved to ee_info (in
network order).
socket(2) is restricted to the group range specified in
"/proc/sys/net/ipv4/ping_group_range". It is "1 0" by default, meaning
that nobody (not even root) may create ping sockets. Setting it to "100
100" would grant permissions to the single group (to either make
/sbin/ping g+s and owned by this group or to grant permissions to the
"netadmins" group), "0 4294967295" would enable it for the world, "100
4294967295" would enable it for the users, but not daemons.
The existing code might be (in the unlikely case anyone needs it)
extended rather easily to handle other similar pairs of ICMP messages
(Timestamp/Reply, Information Request/Reply, Address Mask Request/Reply
etc.).
Userspace ping util & patch for it:
http://openwall.info/wiki/people/segoon/ping
For Openwall GNU/*/Linux it was the last step on the road to the
setuid-less distro. A revision of this patch (for RHEL5/OpenVZ kernels)
is in use in Owl-current, such as in the 2011/03/12 LiveCD ISOs:
http://mirrors.kernel.org/openwall/Owl/current/iso/
Initially this functionality was written by Pavel Kankovsky for
Linux 2.4.32, but unfortunately it was never made public.
All ping options (-b, -p, -Q, -R, -s, -t, -T, -M, -I), are tested with
the patch.
PATCH v3:
- switched to flowi4.
- minor changes to be consistent with raw sockets code.
PATCH v2:
- changed ping_debug() to pr_debug().
- removed CONFIG_IP_PING.
- removed ping_seq_fops.owner field (unused for procfs).
- switched to proc_net_fops_create().
- switched to %pK in seq_printf().
PATCH v1:
- fixed checksumming bug.
- CAP_NET_RAW may not create icmp sockets anymore.
RFC v2:
- minor cleanups.
- introduced sysctl'able group range to restrict socket(2).
Signed-off-by: Vasiliy Kulikov <segoon@openwall.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-05-13 04:01:00 -06:00
|
|
|
.handler = ping_rcv,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
|
|
|
[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,
|
|
|
|
},
|
2007-02-09 07:24:47 -07:00
|
|
|
[ICMP_INFO_REPLY] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.handler = icmp_discard,
|
|
|
|
},
|
|
|
|
[ICMP_ADDRESS] = {
|
2012-07-23 14:20:26 -06:00
|
|
|
.handler = icmp_discard,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
|
|
|
[ICMP_ADDRESSREPLY] = {
|
2012-07-23 14:20:26 -06:00
|
|
|
.handler = icmp_discard,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2008-02-29 12:19:58 -07:00
|
|
|
static void __net_exit icmp_sk_exit(struct net *net)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2008-02-29 12:19:22 -07:00
|
|
|
for_each_possible_cpu(i)
|
2015-01-29 16:58:09 -07:00
|
|
|
inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv4.icmp_sk, i));
|
|
|
|
free_percpu(net->ipv4.icmp_sk);
|
2008-02-29 12:19:58 -07:00
|
|
|
net->ipv4.icmp_sk = NULL;
|
2008-02-29 12:14:50 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-21 03:31:23 -06:00
|
|
|
static int __net_init icmp_sk_init(struct net *net)
|
2008-02-29 12:14:50 -07:00
|
|
|
{
|
|
|
|
int i, err;
|
|
|
|
|
2015-01-29 16:58:09 -07:00
|
|
|
net->ipv4.icmp_sk = alloc_percpu(struct sock *);
|
|
|
|
if (!net->ipv4.icmp_sk)
|
2008-02-29 12:17:11 -07:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-02-29 12:14:50 -07:00
|
|
|
for_each_possible_cpu(i) {
|
2008-02-29 12:15:42 -07:00
|
|
|
struct sock *sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-03 15:29:00 -06:00
|
|
|
err = inet_ctl_sock_create(&sk, PF_INET,
|
|
|
|
SOCK_RAW, IPPROTO_ICMP, net);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err < 0)
|
2008-02-29 12:14:50 -07:00
|
|
|
goto fail;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-01-29 16:58:09 -07:00
|
|
|
*per_cpu_ptr(net->ipv4.icmp_sk, i) = sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Enough space for 2 64K ICMP packets, including
|
2011-10-13 01:28:54 -06:00
|
|
|
* sk_buff/skb_shared_info struct overhead.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-10-13 01:28:54 -06:00
|
|
|
sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-24 06:16:51 -06:00
|
|
|
/*
|
|
|
|
* Speedup sock_wfree()
|
|
|
|
*/
|
|
|
|
sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
|
2008-04-03 15:29:00 -06:00
|
|
|
inet_sk(sk)->pmtudisc = IP_PMTUDISC_DONT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-03-26 02:55:37 -06:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2008-02-29 12:14:50 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2019-02-23 00:28:26 -07:00
|
|
|
icmp_sk_exit(net);
|
2008-02-29 12:14:50 -07:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-02-29 12:19:58 -07:00
|
|
|
static struct pernet_operations __net_initdata icmp_sk_ops = {
|
|
|
|
.init = icmp_sk_init,
|
|
|
|
.exit = icmp_sk_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init icmp_init(void)
|
|
|
|
{
|
2009-02-22 01:09:14 -07:00
|
|
|
return register_pernet_subsys(&icmp_sk_ops);
|
2008-02-29 12:19:58 -07:00
|
|
|
}
|