2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
|
|
|
* operating system. INET is implemented using the BSD Socket
|
|
|
|
* interface as the means of communication with the user level.
|
|
|
|
*
|
|
|
|
* The options processing module for ip.c
|
|
|
|
*
|
|
|
|
* Authors: A.N.Kuznetsov
|
2007-02-09 15:24:47 +01:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
|
2006-01-11 21:17:47 +01:00
|
|
|
#include <linux/capability.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/module.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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <asm/uaccess.h>
|
2011-05-29 12:55:44 +02:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/icmp.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/icmp.h>
|
2005-12-27 05:43:12 +01:00
|
|
|
#include <net/route.h>
|
2006-08-04 01:46:20 +02:00
|
|
|
#include <net/cipso_ipv4.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-02-09 15:24:47 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* Write options to IP header, record destination address to
|
|
|
|
* source route option, address of outgoing interface
|
|
|
|
* (we should already know it, so that this function is allowed be
|
|
|
|
* called only after routing decision) and timestamp,
|
|
|
|
* if we originate this datagram.
|
|
|
|
*
|
|
|
|
* daddr is real destination address, next hop is recorded in IP header.
|
|
|
|
* saddr is address of outgoing interface.
|
|
|
|
*/
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
void ip_options_build(struct sk_buff *skb, struct ip_options *opt,
|
2011-05-13 23:29:41 +02:00
|
|
|
__be32 daddr, struct rtable *rt, int is_frag)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-11 05:50:43 +02:00
|
|
|
unsigned char *iph = skb_network_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
memcpy(&(IPCB(skb)->opt), opt, sizeof(struct ip_options));
|
|
|
|
memcpy(iph+sizeof(struct iphdr), opt->__data, opt->optlen);
|
|
|
|
opt = &(IPCB(skb)->opt);
|
|
|
|
|
|
|
|
if (opt->srr)
|
|
|
|
memcpy(iph+opt->srr+iph[opt->srr+1]-4, &daddr, 4);
|
|
|
|
|
|
|
|
if (!is_frag) {
|
|
|
|
if (opt->rr_needaddr)
|
2011-05-13 23:29:41 +02:00
|
|
|
ip_rt_get_source(iph+opt->rr+iph[opt->rr+2]-5, skb, rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (opt->ts_needaddr)
|
2011-05-13 23:29:41 +02:00
|
|
|
ip_rt_get_source(iph+opt->ts+iph[opt->ts+2]-9, skb, rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (opt->ts_needtime) {
|
2008-04-21 11:34:08 +02:00
|
|
|
struct timespec tv;
|
2006-09-28 03:28:47 +02:00
|
|
|
__be32 midtime;
|
2008-04-21 11:34:08 +02:00
|
|
|
getnstimeofday(&tv);
|
|
|
|
midtime = htonl((tv.tv_sec % 86400) * MSEC_PER_SEC + tv.tv_nsec / NSEC_PER_MSEC);
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(iph+opt->ts+iph[opt->ts+2]-5, &midtime, 4);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (opt->rr) {
|
|
|
|
memset(iph+opt->rr, IPOPT_NOP, iph[opt->rr+1]);
|
|
|
|
opt->rr = 0;
|
|
|
|
opt->rr_needaddr = 0;
|
|
|
|
}
|
|
|
|
if (opt->ts) {
|
|
|
|
memset(iph+opt->ts, IPOPT_NOP, iph[opt->ts+1]);
|
|
|
|
opt->ts = 0;
|
|
|
|
opt->ts_needaddr = opt->ts_needtime = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-09 15:24:47 +01:00
|
|
|
/*
|
2005-04-17 00:20:36 +02:00
|
|
|
* Provided (sopt, skb) points to received options,
|
|
|
|
* build in dopt compiled option set appropriate for answering.
|
|
|
|
* i.e. invert SRR option, copy anothers,
|
|
|
|
* and grab room in RR/TS options.
|
|
|
|
*
|
|
|
|
* NOTE: dopt cannot point to skb.
|
|
|
|
*/
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
int ip_options_echo(struct ip_options *dopt, struct sk_buff *skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-04-21 11:45:37 +02:00
|
|
|
const struct ip_options *sopt;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned char *sptr, *dptr;
|
|
|
|
int soffset, doffset;
|
|
|
|
int optlen;
|
2006-09-28 03:28:47 +02:00
|
|
|
__be32 daddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
memset(dopt, 0, sizeof(struct ip_options));
|
|
|
|
|
|
|
|
sopt = &(IPCB(skb)->opt);
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
if (sopt->optlen == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
sptr = skb_network_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
dptr = dopt->__data;
|
|
|
|
|
2009-06-02 07:14:27 +02:00
|
|
|
daddr = skb_rtable(skb)->rt_spec_dst;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (sopt->rr) {
|
|
|
|
optlen = sptr[sopt->rr+1];
|
|
|
|
soffset = sptr[sopt->rr+2];
|
|
|
|
dopt->rr = dopt->optlen + sizeof(struct iphdr);
|
|
|
|
memcpy(dptr, sptr+sopt->rr, optlen);
|
|
|
|
if (sopt->rr_needaddr && soffset <= optlen) {
|
|
|
|
if (soffset + 3 > optlen)
|
|
|
|
return -EINVAL;
|
|
|
|
dptr[2] = soffset + 4;
|
|
|
|
dopt->rr_needaddr = 1;
|
|
|
|
}
|
|
|
|
dptr += optlen;
|
|
|
|
dopt->optlen += optlen;
|
|
|
|
}
|
|
|
|
if (sopt->ts) {
|
|
|
|
optlen = sptr[sopt->ts+1];
|
|
|
|
soffset = sptr[sopt->ts+2];
|
|
|
|
dopt->ts = dopt->optlen + sizeof(struct iphdr);
|
|
|
|
memcpy(dptr, sptr+sopt->ts, optlen);
|
|
|
|
if (soffset <= optlen) {
|
|
|
|
if (sopt->ts_needaddr) {
|
|
|
|
if (soffset + 3 > optlen)
|
|
|
|
return -EINVAL;
|
|
|
|
dopt->ts_needaddr = 1;
|
|
|
|
soffset += 4;
|
|
|
|
}
|
|
|
|
if (sopt->ts_needtime) {
|
|
|
|
if (soffset + 3 > optlen)
|
|
|
|
return -EINVAL;
|
|
|
|
if ((dptr[3]&0xF) != IPOPT_TS_PRESPEC) {
|
|
|
|
dopt->ts_needtime = 1;
|
|
|
|
soffset += 4;
|
|
|
|
} else {
|
|
|
|
dopt->ts_needtime = 0;
|
|
|
|
|
2011-03-24 08:44:22 +01:00
|
|
|
if (soffset + 7 <= optlen) {
|
2006-09-27 07:17:51 +02:00
|
|
|
__be32 addr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-03-24 08:44:22 +01:00
|
|
|
memcpy(&addr, dptr+soffset-1, 4);
|
|
|
|
if (inet_addr_type(dev_net(skb_dst(skb)->dev), addr) != RTN_UNICAST) {
|
2005-04-17 00:20:36 +02:00
|
|
|
dopt->ts_needtime = 1;
|
|
|
|
soffset += 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dptr[2] = soffset;
|
|
|
|
}
|
|
|
|
dptr += optlen;
|
|
|
|
dopt->optlen += optlen;
|
|
|
|
}
|
|
|
|
if (sopt->srr) {
|
2011-04-21 11:45:37 +02:00
|
|
|
unsigned char *start = sptr+sopt->srr;
|
2006-09-28 03:28:07 +02:00
|
|
|
__be32 faddr;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
optlen = start[1];
|
|
|
|
soffset = start[2];
|
|
|
|
doffset = 0;
|
|
|
|
if (soffset > optlen)
|
|
|
|
soffset = optlen + 1;
|
|
|
|
soffset -= 4;
|
|
|
|
if (soffset > 3) {
|
|
|
|
memcpy(&faddr, &start[soffset-1], 4);
|
|
|
|
for (soffset-=4, doffset=4; soffset > 3; soffset-=4, doffset+=4)
|
|
|
|
memcpy(&dptr[doffset-1], &start[soffset-1], 4);
|
|
|
|
/*
|
|
|
|
* RFC1812 requires to fix illegal source routes.
|
|
|
|
*/
|
2007-04-21 07:47:35 +02:00
|
|
|
if (memcmp(&ip_hdr(skb)->saddr,
|
|
|
|
&start[soffset + 3], 4) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
doffset -= 4;
|
|
|
|
}
|
|
|
|
if (doffset > 3) {
|
|
|
|
memcpy(&start[doffset-1], &daddr, 4);
|
|
|
|
dopt->faddr = faddr;
|
|
|
|
dptr[0] = start[0];
|
|
|
|
dptr[1] = doffset+3;
|
|
|
|
dptr[2] = 4;
|
|
|
|
dptr += doffset+3;
|
|
|
|
dopt->srr = dopt->optlen + sizeof(struct iphdr);
|
|
|
|
dopt->optlen += doffset+3;
|
|
|
|
dopt->is_strictroute = sopt->is_strictroute;
|
|
|
|
}
|
|
|
|
}
|
2006-08-04 01:46:20 +02:00
|
|
|
if (sopt->cipso) {
|
|
|
|
optlen = sptr[sopt->cipso+1];
|
|
|
|
dopt->cipso = dopt->optlen+sizeof(struct iphdr);
|
|
|
|
memcpy(dptr, sptr+sopt->cipso, optlen);
|
|
|
|
dptr += optlen;
|
|
|
|
dopt->optlen += optlen;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
while (dopt->optlen & 3) {
|
|
|
|
*dptr++ = IPOPT_END;
|
|
|
|
dopt->optlen++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Options "fragmenting", just fill options not
|
|
|
|
* allowed in fragments with NOOPs.
|
|
|
|
* Simple and stupid 8), but the most efficient way.
|
|
|
|
*/
|
|
|
|
|
2007-02-09 15:24:47 +01:00
|
|
|
void ip_options_fragment(struct sk_buff * skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-04-11 05:50:43 +02:00
|
|
|
unsigned char *optptr = skb_network_header(skb) + sizeof(struct iphdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
struct ip_options * opt = &(IPCB(skb)->opt);
|
|
|
|
int l = opt->optlen;
|
|
|
|
int optlen;
|
|
|
|
|
|
|
|
while (l > 0) {
|
|
|
|
switch (*optptr) {
|
|
|
|
case IPOPT_END:
|
|
|
|
return;
|
|
|
|
case IPOPT_NOOP:
|
|
|
|
l--;
|
|
|
|
optptr++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
optlen = optptr[1];
|
|
|
|
if (optlen<2 || optlen>l)
|
|
|
|
return;
|
|
|
|
if (!IPOPT_COPIED(*optptr))
|
|
|
|
memset(optptr, IPOPT_NOOP, optlen);
|
|
|
|
l -= optlen;
|
|
|
|
optptr += optlen;
|
|
|
|
}
|
|
|
|
opt->ts = 0;
|
|
|
|
opt->rr = 0;
|
|
|
|
opt->rr_needaddr = 0;
|
|
|
|
opt->ts_needaddr = 0;
|
|
|
|
opt->ts_needtime = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify options and fill pointers in struct options.
|
|
|
|
* Caller should clear *opt, and set opt->data.
|
|
|
|
* If opt == NULL, then skb->data should point to IP header.
|
|
|
|
*/
|
|
|
|
|
2008-03-24 23:29:23 +01:00
|
|
|
int ip_options_compile(struct net *net,
|
|
|
|
struct ip_options * opt, struct sk_buff * skb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int l;
|
|
|
|
unsigned char * iph;
|
|
|
|
unsigned char * optptr;
|
|
|
|
int optlen;
|
|
|
|
unsigned char * pp_ptr = NULL;
|
2008-03-23 00:36:20 +01:00
|
|
|
struct rtable *rt = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-23 00:36:20 +01:00
|
|
|
if (skb != NULL) {
|
2009-06-02 07:14:27 +02:00
|
|
|
rt = skb_rtable(skb);
|
2008-03-23 00:36:20 +01:00
|
|
|
optptr = (unsigned char *)&(ip_hdr(skb)[1]);
|
|
|
|
} else
|
2008-03-23 00:35:00 +01:00
|
|
|
optptr = opt->__data;
|
2008-03-23 00:36:20 +01:00
|
|
|
iph = optptr - sizeof(struct iphdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
for (l = opt->optlen; l > 0; ) {
|
|
|
|
switch (*optptr) {
|
|
|
|
case IPOPT_END:
|
|
|
|
for (optptr++, l--; l>0; optptr++, l--) {
|
|
|
|
if (*optptr != IPOPT_END) {
|
|
|
|
*optptr = IPOPT_END;
|
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
goto eol;
|
|
|
|
case IPOPT_NOOP:
|
|
|
|
l--;
|
|
|
|
optptr++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
optlen = optptr[1];
|
|
|
|
if (optlen<2 || optlen>l) {
|
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
switch (*optptr) {
|
|
|
|
case IPOPT_SSRR:
|
|
|
|
case IPOPT_LSRR:
|
|
|
|
if (optlen < 3) {
|
|
|
|
pp_ptr = optptr + 1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] < 4) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
/* NB: cf RFC-1812 5.2.4.1 */
|
|
|
|
if (opt->srr) {
|
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (!skb) {
|
|
|
|
if (optptr[2] != 4 || optlen < 7 || ((optlen-3) & 3)) {
|
|
|
|
pp_ptr = optptr + 1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
memcpy(&opt->faddr, &optptr[3], 4);
|
|
|
|
if (optlen > 7)
|
|
|
|
memmove(&optptr[3], &optptr[7], optlen-7);
|
|
|
|
}
|
|
|
|
opt->is_strictroute = (optptr[0] == IPOPT_SSRR);
|
|
|
|
opt->srr = optptr - iph;
|
|
|
|
break;
|
|
|
|
case IPOPT_RR:
|
|
|
|
if (opt->rr) {
|
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optlen < 3) {
|
|
|
|
pp_ptr = optptr + 1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] < 4) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] <= optlen) {
|
|
|
|
if (optptr[2]+3 > optlen) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
2011-04-14 07:55:37 +02:00
|
|
|
if (rt) {
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
|
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
optptr[2] += 4;
|
|
|
|
opt->rr_needaddr = 1;
|
|
|
|
}
|
|
|
|
opt->rr = optptr - iph;
|
|
|
|
break;
|
|
|
|
case IPOPT_TIMESTAMP:
|
|
|
|
if (opt->ts) {
|
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optlen < 4) {
|
|
|
|
pp_ptr = optptr + 1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] < 5) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] <= optlen) {
|
2011-05-29 12:55:44 +02:00
|
|
|
unsigned char *timeptr = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (optptr[2]+3 > optptr[1]) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
switch (optptr[3]&0xF) {
|
|
|
|
case IPOPT_TS_TSONLY:
|
|
|
|
opt->ts = optptr - iph;
|
2007-02-09 15:24:47 +01:00
|
|
|
if (skb)
|
2011-05-29 12:55:44 +02:00
|
|
|
timeptr = &optptr[optptr[2]-1];
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->ts_needtime = 1;
|
|
|
|
optptr[2] += 4;
|
|
|
|
break;
|
|
|
|
case IPOPT_TS_TSANDADDR:
|
|
|
|
if (optptr[2]+7 > optptr[1]) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
opt->ts = optptr - iph;
|
2011-04-14 07:55:37 +02:00
|
|
|
if (rt) {
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(&optptr[optptr[2]-1], &rt->rt_spec_dst, 4);
|
2011-05-29 12:55:44 +02:00
|
|
|
timeptr = &optptr[optptr[2]+3];
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
opt->ts_needaddr = 1;
|
|
|
|
opt->ts_needtime = 1;
|
|
|
|
optptr[2] += 8;
|
|
|
|
break;
|
|
|
|
case IPOPT_TS_PRESPEC:
|
|
|
|
if (optptr[2]+7 > optptr[1]) {
|
|
|
|
pp_ptr = optptr + 2;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
opt->ts = optptr - iph;
|
|
|
|
{
|
2006-09-27 07:17:51 +02:00
|
|
|
__be32 addr;
|
2005-04-17 00:20:36 +02:00
|
|
|
memcpy(&addr, &optptr[optptr[2]-1], 4);
|
2008-03-24 23:29:23 +01:00
|
|
|
if (inet_addr_type(net, addr) == RTN_UNICAST)
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
if (skb)
|
2011-05-29 12:55:44 +02:00
|
|
|
timeptr = &optptr[optptr[2]+3];
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
opt->ts_needtime = 1;
|
|
|
|
optptr[2] += 8;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (!skb && !capable(CAP_NET_RAW)) {
|
|
|
|
pp_ptr = optptr + 3;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (timeptr) {
|
2008-04-21 11:34:08 +02:00
|
|
|
struct timespec tv;
|
2011-05-29 12:55:44 +02:00
|
|
|
u32 midtime;
|
2008-04-21 11:34:08 +02:00
|
|
|
getnstimeofday(&tv);
|
2011-05-29 12:55:44 +02:00
|
|
|
midtime = (tv.tv_sec % 86400) * MSEC_PER_SEC + tv.tv_nsec / NSEC_PER_MSEC;
|
|
|
|
put_unaligned_be32(midtime, timeptr);
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
unsigned overflow = optptr[3]>>4;
|
|
|
|
if (overflow == 15) {
|
|
|
|
pp_ptr = optptr + 3;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
opt->ts = optptr - iph;
|
|
|
|
if (skb) {
|
|
|
|
optptr[3] = (optptr[3]&0xF)|((overflow+1)<<4);
|
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IPOPT_RA:
|
|
|
|
if (optlen < 4) {
|
|
|
|
pp_ptr = optptr + 1;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
if (optptr[2] == 0 && optptr[3] == 0)
|
|
|
|
opt->router_alert = optptr - iph;
|
|
|
|
break;
|
2006-08-04 01:46:20 +02:00
|
|
|
case IPOPT_CIPSO:
|
2006-10-31 00:22:15 +01:00
|
|
|
if ((!skb && !capable(CAP_NET_RAW)) || opt->cipso) {
|
2006-08-04 01:46:20 +02:00
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
opt->cipso = optptr - iph;
|
2008-10-10 16:16:34 +02:00
|
|
|
if (cipso_v4_validate(skb, &optptr)) {
|
2006-08-04 01:46:20 +02:00
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
case IPOPT_SEC:
|
|
|
|
case IPOPT_SID:
|
|
|
|
default:
|
|
|
|
if (!skb && !capable(CAP_NET_RAW)) {
|
|
|
|
pp_ptr = optptr;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
l -= optlen;
|
|
|
|
optptr += optlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
eol:
|
|
|
|
if (!pp_ptr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (skb) {
|
|
|
|
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((pp_ptr-iph)<<24));
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-09-19 11:34:33 +02:00
|
|
|
EXPORT_SYMBOL(ip_options_compile);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Undo all the changes done by ip_options_compile().
|
|
|
|
*/
|
|
|
|
|
|
|
|
void ip_options_undo(struct ip_options * opt)
|
|
|
|
{
|
|
|
|
if (opt->srr) {
|
|
|
|
unsigned char * optptr = opt->__data+opt->srr-sizeof(struct iphdr);
|
|
|
|
memmove(optptr+7, optptr+3, optptr[1]-7);
|
|
|
|
memcpy(optptr+3, &opt->faddr, 4);
|
|
|
|
}
|
|
|
|
if (opt->rr_needaddr) {
|
|
|
|
unsigned char * optptr = opt->__data+opt->rr-sizeof(struct iphdr);
|
|
|
|
optptr[2] -= 4;
|
|
|
|
memset(&optptr[optptr[2]-1], 0, 4);
|
|
|
|
}
|
|
|
|
if (opt->ts) {
|
|
|
|
unsigned char * optptr = opt->__data+opt->ts-sizeof(struct iphdr);
|
|
|
|
if (opt->ts_needtime) {
|
|
|
|
optptr[2] -= 4;
|
|
|
|
memset(&optptr[optptr[2]-1], 0, 4);
|
|
|
|
if ((optptr[3]&0xF) == IPOPT_TS_PRESPEC)
|
|
|
|
optptr[2] -= 4;
|
|
|
|
}
|
|
|
|
if (opt->ts_needaddr) {
|
|
|
|
optptr[2] -= 4;
|
|
|
|
memset(&optptr[optptr[2]-1], 0, 4);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
static struct ip_options_rcu *ip_options_get_alloc(const int optlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2011-04-21 11:45:37 +02:00
|
|
|
return kzalloc(sizeof(struct ip_options_rcu) + ((optlen + 3) & ~3),
|
2007-07-31 23:06:45 +02:00
|
|
|
GFP_KERNEL);
|
2005-08-17 00:46:48 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
static int ip_options_get_finish(struct net *net, struct ip_options_rcu **optp,
|
|
|
|
struct ip_options_rcu *opt, int optlen)
|
2005-08-17 00:46:48 +02:00
|
|
|
{
|
2005-04-17 00:20:36 +02:00
|
|
|
while (optlen & 3)
|
2011-04-21 11:45:37 +02:00
|
|
|
opt->opt.__data[optlen++] = IPOPT_END;
|
|
|
|
opt->opt.optlen = optlen;
|
|
|
|
if (optlen && ip_options_compile(net, &opt->opt, NULL)) {
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree(opt);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2005-11-08 18:41:34 +01:00
|
|
|
kfree(*optp);
|
2005-04-17 00:20:36 +02:00
|
|
|
*optp = opt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
int ip_options_get_from_user(struct net *net, struct ip_options_rcu **optp,
|
2008-03-24 23:29:55 +01:00
|
|
|
unsigned char __user *data, int optlen)
|
2005-08-17 00:46:48 +02:00
|
|
|
{
|
2011-04-21 11:45:37 +02:00
|
|
|
struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
|
2005-08-17 00:46:48 +02:00
|
|
|
|
|
|
|
if (!opt)
|
|
|
|
return -ENOMEM;
|
2011-04-21 11:45:37 +02:00
|
|
|
if (optlen && copy_from_user(opt->opt.__data, data, optlen)) {
|
2005-08-17 00:46:48 +02:00
|
|
|
kfree(opt);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
2008-03-24 23:29:55 +01:00
|
|
|
return ip_options_get_finish(net, optp, opt, optlen);
|
2005-08-17 00:46:48 +02:00
|
|
|
}
|
|
|
|
|
2011-04-21 11:45:37 +02:00
|
|
|
int ip_options_get(struct net *net, struct ip_options_rcu **optp,
|
2008-03-24 23:29:55 +01:00
|
|
|
unsigned char *data, int optlen)
|
2005-08-17 00:46:48 +02:00
|
|
|
{
|
2011-04-21 11:45:37 +02:00
|
|
|
struct ip_options_rcu *opt = ip_options_get_alloc(optlen);
|
2005-08-17 00:46:48 +02:00
|
|
|
|
|
|
|
if (!opt)
|
|
|
|
return -ENOMEM;
|
|
|
|
if (optlen)
|
2011-04-21 11:45:37 +02:00
|
|
|
memcpy(opt->opt.__data, data, optlen);
|
2008-03-24 23:29:55 +01:00
|
|
|
return ip_options_get_finish(net, optp, opt, optlen);
|
2005-08-17 00:46:48 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void ip_forward_options(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ip_options * opt = &(IPCB(skb)->opt);
|
|
|
|
unsigned char * optptr;
|
2009-06-02 07:14:27 +02:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
2007-04-11 05:50:43 +02:00
|
|
|
unsigned char *raw = skb_network_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (opt->rr_needaddr) {
|
|
|
|
optptr = (unsigned char *)raw + opt->rr;
|
2011-05-13 23:29:41 +02:00
|
|
|
ip_rt_get_source(&optptr[optptr[2]-5], skb, rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
if (opt->srr_is_hit) {
|
|
|
|
int srrptr, srrspace;
|
|
|
|
|
|
|
|
optptr = raw + opt->srr;
|
|
|
|
|
|
|
|
for ( srrptr=optptr[2], srrspace = optptr[1];
|
|
|
|
srrptr <= srrspace;
|
|
|
|
srrptr += 4
|
|
|
|
) {
|
|
|
|
if (srrptr + 3 > srrspace)
|
|
|
|
break;
|
2011-11-23 00:33:10 +01:00
|
|
|
if (memcmp(&opt->nexthop, &optptr[srrptr-1], 4) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (srrptr + 3 <= srrspace) {
|
|
|
|
opt->is_changed = 1;
|
2011-05-13 23:29:41 +02:00
|
|
|
ip_rt_get_source(&optptr[srrptr-1], skb, rt);
|
2011-11-23 00:33:10 +01:00
|
|
|
ip_hdr(skb)->daddr = opt->nexthop;
|
2005-04-17 00:20:36 +02:00
|
|
|
optptr[2] = srrptr+4;
|
|
|
|
} else if (net_ratelimit())
|
|
|
|
printk(KERN_CRIT "ip_forward(): Argh! Destination lost!\n");
|
|
|
|
if (opt->ts_needaddr) {
|
|
|
|
optptr = raw + opt->ts;
|
2011-05-13 23:29:41 +02:00
|
|
|
ip_rt_get_source(&optptr[optptr[2]-9], skb, rt);
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (opt->is_changed) {
|
|
|
|
opt->is_changed = 0;
|
2007-04-21 07:47:35 +02:00
|
|
|
ip_send_check(ip_hdr(skb));
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int ip_options_rcv_srr(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ip_options *opt = &(IPCB(skb)->opt);
|
|
|
|
int srrspace, srrptr;
|
2006-09-27 06:25:20 +02:00
|
|
|
__be32 nexthop;
|
2007-04-21 07:47:35 +02:00
|
|
|
struct iphdr *iph = ip_hdr(skb);
|
2007-04-11 05:50:43 +02:00
|
|
|
unsigned char *optptr = skb_network_header(skb) + opt->srr;
|
2009-06-02 07:14:27 +02:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
struct rtable *rt2;
|
2010-05-12 01:19:48 +02:00
|
|
|
unsigned long orefdst;
|
2005-04-17 00:20:36 +02:00
|
|
|
int err;
|
|
|
|
|
2011-05-13 01:26:57 +02:00
|
|
|
if (!rt)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (skb->pkt_type != PACKET_HOST)
|
|
|
|
return -EINVAL;
|
|
|
|
if (rt->rt_type == RTN_UNICAST) {
|
|
|
|
if (!opt->is_strictroute)
|
|
|
|
return 0;
|
|
|
|
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl(16<<24));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (rt->rt_type != RTN_LOCAL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (srrptr=optptr[2], srrspace = optptr[1]; srrptr <= srrspace; srrptr += 4) {
|
|
|
|
if (srrptr + 3 > srrspace) {
|
|
|
|
icmp_send(skb, ICMP_PARAMETERPROB, 0, htonl((opt->srr+2)<<24));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
memcpy(&nexthop, &optptr[srrptr-1], 4);
|
|
|
|
|
2010-05-12 01:19:48 +02:00
|
|
|
orefdst = skb->_skb_refdst;
|
2009-06-02 07:19:30 +02:00
|
|
|
skb_dst_set(skb, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
err = ip_route_input(skb, nexthop, iph->saddr, iph->tos, skb->dev);
|
2009-06-02 07:14:27 +02:00
|
|
|
rt2 = skb_rtable(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (err || (rt2->rt_type != RTN_UNICAST && rt2->rt_type != RTN_LOCAL)) {
|
2010-05-12 01:19:48 +02:00
|
|
|
skb_dst_drop(skb);
|
|
|
|
skb->_skb_refdst = orefdst;
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2010-05-12 01:19:48 +02:00
|
|
|
refdst_drop(orefdst);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (rt2->rt_type != RTN_LOCAL)
|
|
|
|
break;
|
|
|
|
/* Superfast 8) loopback forward */
|
2011-05-13 01:30:58 +02:00
|
|
|
iph->daddr = nexthop;
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
if (srrptr <= srrspace) {
|
|
|
|
opt->srr_is_hit = 1;
|
2011-11-23 00:33:10 +01:00
|
|
|
opt->nexthop = nexthop;
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->is_changed = 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-09-19 11:34:33 +02:00
|
|
|
EXPORT_SYMBOL(ip_options_rcv_srr);
|