2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Extension Header handling for IPv6
|
|
|
|
* Linux INET6 implementation
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Pedro Roque <roque@di.fc.ul.pt>
|
|
|
|
* Andi Kleen <ak@muc.de>
|
|
|
|
* Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
|
|
|
|
*
|
|
|
|
* $Id: exthdrs.c,v 1.13 2001/06/19 15:58:56 davem Exp $
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Changes:
|
2007-02-09 15:24:49 +01:00
|
|
|
* yoshfuji : ensure not to overrun while parsing
|
2005-04-17 00:20:36 +02:00
|
|
|
* tlv options.
|
|
|
|
* Mitsuru KANDA @USAGI and: Remove ipv6_parse_exthdrs().
|
|
|
|
* YOSHIFUJI Hideaki @USAGI Register inbound extension header
|
|
|
|
* handlers as inet6_protocol{}.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/net.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/in6.h>
|
|
|
|
#include <linux/icmpv6.h>
|
|
|
|
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/snmp.h>
|
|
|
|
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <net/transp_v6.h>
|
|
|
|
#include <net/rawv6.h>
|
|
|
|
#include <net/ndisc.h>
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
#include <net/addrconf.h>
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:16:22 +02:00
|
|
|
#include <net/xfrm.h>
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
2006-08-24 04:18:35 +02:00
|
|
|
int ipv6_find_tlv(struct sk_buff *skb, int offset, int type)
|
|
|
|
{
|
2007-04-11 05:50:43 +02:00
|
|
|
const unsigned char *nh = skb_network_header(skb);
|
2007-04-20 05:29:13 +02:00
|
|
|
int packet_len = skb->tail - skb->network_header;
|
2006-08-24 04:18:35 +02:00
|
|
|
struct ipv6_opt_hdr *hdr;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (offset + 2 > packet_len)
|
|
|
|
goto bad;
|
2007-04-11 05:50:43 +02:00
|
|
|
hdr = (struct ipv6_opt_hdr *)(nh + offset);
|
2006-08-24 04:18:35 +02:00
|
|
|
len = ((hdr->hdrlen + 1) << 3);
|
|
|
|
|
|
|
|
if (offset + len > packet_len)
|
|
|
|
goto bad;
|
|
|
|
|
|
|
|
offset += 2;
|
|
|
|
len -= 2;
|
|
|
|
|
|
|
|
while (len > 0) {
|
2007-04-11 05:50:43 +02:00
|
|
|
int opttype = nh[offset];
|
2006-08-24 04:18:35 +02:00
|
|
|
int optlen;
|
|
|
|
|
|
|
|
if (opttype == type)
|
|
|
|
return offset;
|
|
|
|
|
|
|
|
switch (opttype) {
|
|
|
|
case IPV6_TLV_PAD0:
|
|
|
|
optlen = 1;
|
|
|
|
break;
|
|
|
|
default:
|
2007-04-11 05:50:43 +02:00
|
|
|
optlen = nh[offset + 1] + 2;
|
2006-08-24 04:18:35 +02:00
|
|
|
if (optlen > len)
|
|
|
|
goto bad;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset += optlen;
|
|
|
|
len -= optlen;
|
|
|
|
}
|
|
|
|
/* not_found */
|
|
|
|
bad:
|
|
|
|
return -1;
|
|
|
|
}
|
2007-06-27 08:56:32 +02:00
|
|
|
EXPORT_SYMBOL_GPL(ipv6_find_tlv);
|
2006-08-24 04:18:35 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Parsing tlv encoded headers.
|
|
|
|
*
|
|
|
|
* Parsing function "func" returns 1, if parsing succeed
|
|
|
|
* and 0, if it failed.
|
|
|
|
* It MUST NOT touch skb->h.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct tlvtype_proc {
|
|
|
|
int type;
|
2006-08-24 04:19:50 +02:00
|
|
|
int (*func)(struct sk_buff **skbp, int offset);
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*********************
|
|
|
|
Generic functions
|
|
|
|
*********************/
|
|
|
|
|
|
|
|
/* An unknown option is detected, decide what to do */
|
|
|
|
|
2006-08-24 04:19:50 +02:00
|
|
|
static int ip6_tlvopt_unknown(struct sk_buff **skbp, int optoff)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 04:19:50 +02:00
|
|
|
struct sk_buff *skb = *skbp;
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
switch ((skb_network_header(skb)[optoff] & 0xC0) >> 6) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case 0: /* ignore */
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
case 1: /* drop packet */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 3: /* Send ICMP if not a multicast address and drop packet */
|
|
|
|
/* Actually, it is redundant check. icmp_send
|
|
|
|
will recheck in any case.
|
|
|
|
*/
|
2007-04-26 02:54:47 +02:00
|
|
|
if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr))
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
case 2: /* send ICMP PARM PROB regardless and drop packet */
|
|
|
|
icmpv6_param_prob(skb, ICMPV6_UNK_OPTION, optoff);
|
|
|
|
return 0;
|
2007-04-21 02:09:22 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Parse tlv encoded option header (hop-by-hop or destination) */
|
|
|
|
|
2006-08-24 04:19:50 +02:00
|
|
|
static int ip6_parse_tlv(struct tlvtype_proc *procs, struct sk_buff **skbp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 04:19:50 +02:00
|
|
|
struct sk_buff *skb = *skbp;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct tlvtype_proc *curr;
|
2007-04-11 05:50:43 +02:00
|
|
|
const unsigned char *nh = skb_network_header(skb);
|
2007-03-16 21:26:39 +01:00
|
|
|
int off = skb_network_header_len(skb);
|
2007-04-26 03:04:18 +02:00
|
|
|
int len = (skb_transport_header(skb)[1] + 1) << 3;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 02:55:53 +02:00
|
|
|
if (skb_transport_offset(skb) + len > skb_headlen(skb))
|
2005-04-17 00:20:36 +02:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
off += 2;
|
|
|
|
len -= 2;
|
|
|
|
|
|
|
|
while (len > 0) {
|
2007-04-11 05:50:43 +02:00
|
|
|
int optlen = nh[off + 1] + 2;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
switch (nh[off]) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case IPV6_TLV_PAD0:
|
|
|
|
optlen = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IPV6_TLV_PADN:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* Other TLV code so scan list */
|
|
|
|
if (optlen > len)
|
|
|
|
goto bad;
|
|
|
|
for (curr=procs; curr->type >= 0; curr++) {
|
2007-04-11 05:50:43 +02:00
|
|
|
if (curr->type == nh[off]) {
|
2007-02-09 15:24:49 +01:00
|
|
|
/* type specific length/alignment
|
|
|
|
checks will be performed in the
|
2005-04-17 00:20:36 +02:00
|
|
|
func(). */
|
2006-08-24 04:19:50 +02:00
|
|
|
if (curr->func(skbp, off) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (curr->type < 0) {
|
2006-08-24 04:19:50 +02:00
|
|
|
if (ip6_tlvopt_unknown(skbp, off) == 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
off += optlen;
|
|
|
|
len -= optlen;
|
|
|
|
}
|
|
|
|
if (len == 0)
|
|
|
|
return 1;
|
|
|
|
bad:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************
|
|
|
|
Destination options header.
|
|
|
|
*****************************/
|
|
|
|
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:24:48 +02:00
|
|
|
static int ipv6_dest_hao(struct sk_buff **skbp, int optoff)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb = *skbp;
|
|
|
|
struct ipv6_destopt_hao *hao;
|
|
|
|
struct inet6_skb_parm *opt = IP6CB(skb);
|
2007-04-26 02:54:47 +02:00
|
|
|
struct ipv6hdr *ipv6h = ipv6_hdr(skb);
|
2006-08-24 04:24:48 +02:00
|
|
|
struct in6_addr tmp_addr;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (opt->dsthao) {
|
|
|
|
LIMIT_NETDEBUG(KERN_DEBUG "hao duplicated\n");
|
|
|
|
goto discard;
|
|
|
|
}
|
|
|
|
opt->dsthao = opt->dst1;
|
|
|
|
opt->dst1 = 0;
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
hao = (struct ipv6_destopt_hao *)(skb_network_header(skb) + optoff);
|
2006-08-24 04:24:48 +02:00
|
|
|
|
|
|
|
if (hao->length != 16) {
|
|
|
|
LIMIT_NETDEBUG(
|
|
|
|
KERN_DEBUG "hao invalid option length = %d\n", hao->length);
|
|
|
|
goto discard;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ipv6_addr_type(&hao->addr) & IPV6_ADDR_UNICAST)) {
|
|
|
|
LIMIT_NETDEBUG(
|
|
|
|
KERN_DEBUG "hao is not an unicast addr: " NIP6_FMT "\n", NIP6(hao->addr));
|
|
|
|
goto discard;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = xfrm6_input_addr(skb, (xfrm_address_t *)&ipv6h->daddr,
|
|
|
|
(xfrm_address_t *)&hao->addr, IPPROTO_DSTOPTS);
|
|
|
|
if (unlikely(ret < 0))
|
|
|
|
goto discard;
|
|
|
|
|
|
|
|
if (skb_cloned(skb)) {
|
|
|
|
struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
|
2006-09-01 00:18:49 +02:00
|
|
|
struct inet6_skb_parm *opt2;
|
|
|
|
|
2006-08-24 04:24:48 +02:00
|
|
|
if (skb2 == NULL)
|
|
|
|
goto discard;
|
|
|
|
|
2006-09-01 00:18:49 +02:00
|
|
|
opt2 = IP6CB(skb2);
|
|
|
|
memcpy(opt2, opt, sizeof(*opt2));
|
|
|
|
|
2006-08-24 04:24:48 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
|
|
|
|
/* update all variable using below by copied skbuff */
|
|
|
|
*skbp = skb = skb2;
|
2007-04-11 05:50:43 +02:00
|
|
|
hao = (struct ipv6_destopt_hao *)(skb_network_header(skb2) +
|
|
|
|
optoff);
|
2007-04-26 02:54:47 +02:00
|
|
|
ipv6h = ipv6_hdr(skb2);
|
2006-08-24 04:24:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (skb->ip_summed == CHECKSUM_COMPLETE)
|
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
|
|
|
|
ipv6_addr_copy(&tmp_addr, &ipv6h->saddr);
|
|
|
|
ipv6_addr_copy(&ipv6h->saddr, &hao->addr);
|
|
|
|
ipv6_addr_copy(&hao->addr, &tmp_addr);
|
|
|
|
|
2007-04-20 01:16:32 +02:00
|
|
|
if (skb->tstamp.tv64 == 0)
|
2006-08-24 04:24:48 +02:00
|
|
|
__net_timestamp(skb);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
discard:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static struct tlvtype_proc tlvprocdestopt_lst[] = {
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:24:48 +02:00
|
|
|
{
|
|
|
|
.type = IPV6_TLV_HAO,
|
|
|
|
.func = ipv6_dest_hao,
|
|
|
|
},
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
{-1, NULL}
|
|
|
|
};
|
|
|
|
|
2006-01-07 08:02:34 +01:00
|
|
|
static int ipv6_destopt_rcv(struct sk_buff **skbp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sk_buff *skb = *skbp;
|
|
|
|
struct inet6_skb_parm *opt = IP6CB(skb);
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:24:48 +02:00
|
|
|
__u16 dstbuf;
|
|
|
|
#endif
|
2006-11-04 12:11:37 +01:00
|
|
|
struct dst_entry *dst;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 02:55:53 +02:00
|
|
|
if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
|
|
|
|
!pskb_may_pull(skb, (skb_transport_offset(skb) +
|
2007-04-26 03:04:18 +02:00
|
|
|
((skb_transport_header(skb)[1] + 1) << 3)))) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-03-16 21:26:39 +01:00
|
|
|
opt->lastopt = opt->dst1 = skb_network_header_len(skb);
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:24:48 +02:00
|
|
|
dstbuf = opt->dst1;
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-11-04 12:11:37 +01:00
|
|
|
dst = dst_clone(skb->dst);
|
2006-08-24 04:19:50 +02:00
|
|
|
if (ip6_parse_tlv(tlvprocdestopt_lst, skbp)) {
|
2006-11-04 12:11:37 +01:00
|
|
|
dst_release(dst);
|
2006-08-24 04:19:50 +02:00
|
|
|
skb = *skbp;
|
2007-04-11 06:21:55 +02:00
|
|
|
skb->transport_header += (skb_transport_header(skb)[1] + 1) << 3;
|
2006-09-01 00:18:49 +02:00
|
|
|
opt = IP6CB(skb);
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:24:48 +02:00
|
|
|
opt->nhoff = dstbuf;
|
|
|
|
#else
|
2006-01-07 08:02:34 +01:00
|
|
|
opt->nhoff = opt->dst1;
|
2006-08-24 04:24:48 +02:00
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(dst), IPSTATS_MIB_INHDRERRORS);
|
|
|
|
dst_release(dst);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_protocol destopt_protocol = {
|
|
|
|
.handler = ipv6_destopt_rcv,
|
2006-06-30 22:36:15 +02:00
|
|
|
.flags = INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
void __init ipv6_destopt_init(void)
|
|
|
|
{
|
|
|
|
if (inet6_add_protocol(&destopt_protocol, IPPROTO_DSTOPTS) < 0)
|
|
|
|
printk(KERN_ERR "ipv6_destopt_init: Could not register protocol\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/********************************
|
|
|
|
NONE header. No data in packet.
|
|
|
|
********************************/
|
|
|
|
|
2006-01-07 08:02:34 +01:00
|
|
|
static int ipv6_nodata_rcv(struct sk_buff **skbp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sk_buff *skb = *skbp;
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_protocol nodata_protocol = {
|
|
|
|
.handler = ipv6_nodata_rcv,
|
|
|
|
.flags = INET6_PROTO_NOPOLICY,
|
|
|
|
};
|
|
|
|
|
|
|
|
void __init ipv6_nodata_init(void)
|
|
|
|
{
|
|
|
|
if (inet6_add_protocol(&nodata_protocol, IPPROTO_NONE) < 0)
|
|
|
|
printk(KERN_ERR "ipv6_nodata_init: Could not register protocol\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/********************************
|
|
|
|
Routing header.
|
|
|
|
********************************/
|
|
|
|
|
2006-01-07 08:02:34 +01:00
|
|
|
static int ipv6_rthdr_rcv(struct sk_buff **skbp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct sk_buff *skb = *skbp;
|
|
|
|
struct inet6_skb_parm *opt = IP6CB(skb);
|
2006-08-24 04:16:22 +02:00
|
|
|
struct in6_addr *addr = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct in6_addr daddr;
|
2007-04-24 23:58:30 +02:00
|
|
|
struct inet6_dev *idev;
|
2005-04-17 00:20:36 +02:00
|
|
|
int n, i;
|
|
|
|
struct ipv6_rt_hdr *hdr;
|
|
|
|
struct rt0_hdr *rthdr;
|
2007-04-24 23:58:30 +02:00
|
|
|
int accept_source_route = ipv6_devconf.accept_source_route;
|
|
|
|
|
2007-07-11 07:47:58 +02:00
|
|
|
idev = in6_dev_get(skb->dev);
|
|
|
|
if (idev) {
|
|
|
|
if (accept_source_route > idev->cnf.accept_source_route)
|
|
|
|
accept_source_route = idev->cnf.accept_source_route;
|
2007-04-24 23:58:30 +02:00
|
|
|
in6_dev_put(idev);
|
|
|
|
}
|
|
|
|
|
2007-04-26 02:55:53 +02:00
|
|
|
if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) ||
|
|
|
|
!pskb_may_pull(skb, (skb_transport_offset(skb) +
|
2007-04-26 03:04:18 +02:00
|
|
|
((skb_transport_header(skb)[1] + 1) << 3)))) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2007-04-26 03:04:18 +02:00
|
|
|
hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-04-26 02:54:47 +02:00
|
|
|
if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ||
|
2005-04-17 00:20:36 +02:00
|
|
|
skb->pkt_type != PACKET_HOST) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INADDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
looped_back:
|
|
|
|
if (hdr->segments_left == 0) {
|
2006-08-24 04:16:22 +02:00
|
|
|
switch (hdr->type) {
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:16:22 +02:00
|
|
|
case IPV6_SRCRT_TYPE_2:
|
|
|
|
/* Silently discard type 2 header unless it was
|
|
|
|
* processed by own
|
|
|
|
*/
|
|
|
|
if (!addr) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INADDRERRORS);
|
2006-08-24 04:16:22 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-03-16 21:26:39 +01:00
|
|
|
opt->lastopt = opt->srcrt = skb_network_header_len(skb);
|
2007-04-11 06:21:55 +02:00
|
|
|
skb->transport_header += (hdr->hdrlen + 1) << 3;
|
2005-04-17 00:20:36 +02:00
|
|
|
opt->dst0 = opt->dst1;
|
|
|
|
opt->dst1 = 0;
|
2007-04-11 05:50:43 +02:00
|
|
|
opt->nhoff = (&hdr->nexthdr) - skb_network_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2006-08-24 04:16:22 +02:00
|
|
|
switch (hdr->type) {
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:16:22 +02:00
|
|
|
case IPV6_SRCRT_TYPE_2:
|
2007-07-11 07:47:58 +02:00
|
|
|
if (accept_source_route < 0)
|
|
|
|
goto unknown_rh;
|
2006-08-24 04:16:22 +02:00
|
|
|
/* Silently discard invalid RTH type 2 */
|
|
|
|
if (hdr->hdrlen != 2 || hdr->segments_left != 1) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2006-08-24 04:16:22 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2007-07-11 07:47:58 +02:00
|
|
|
default:
|
|
|
|
goto unknown_rh;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the routing header forwarding algorithm from
|
|
|
|
* RFC 2460, page 16.
|
|
|
|
*/
|
|
|
|
|
|
|
|
n = hdr->hdrlen >> 1;
|
|
|
|
|
|
|
|
if (hdr->segments_left > n) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2007-04-11 05:50:43 +02:00
|
|
|
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
|
|
|
|
((&hdr->segments_left) -
|
|
|
|
skb_network_header(skb)));
|
2005-04-17 00:20:36 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We are about to mangle packet header. Be careful!
|
|
|
|
Do not damage packets queued somewhere.
|
|
|
|
*/
|
|
|
|
if (skb_cloned(skb)) {
|
|
|
|
struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
|
|
|
|
/* the copy is a forwarded packet */
|
|
|
|
if (skb2 == NULL) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_OUTDISCARDS);
|
|
|
|
kfree_skb(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2006-11-04 12:11:37 +01:00
|
|
|
kfree_skb(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
*skbp = skb = skb2;
|
|
|
|
opt = IP6CB(skb2);
|
2007-03-16 21:19:57 +01:00
|
|
|
hdr = (struct ipv6_rt_hdr *)skb_transport_header(skb2);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-08-30 01:44:56 +02:00
|
|
|
if (skb->ip_summed == CHECKSUM_COMPLETE)
|
2005-04-17 00:20:36 +02:00
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
|
|
|
|
i = n - --hdr->segments_left;
|
|
|
|
|
|
|
|
rthdr = (struct rt0_hdr *) hdr;
|
|
|
|
addr = rthdr->addr;
|
|
|
|
addr += i - 1;
|
|
|
|
|
2006-08-24 04:16:22 +02:00
|
|
|
switch (hdr->type) {
|
2007-06-27 08:56:32 +02:00
|
|
|
#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
|
2006-08-24 04:16:22 +02:00
|
|
|
case IPV6_SRCRT_TYPE_2:
|
|
|
|
if (xfrm6_input_addr(skb, (xfrm_address_t *)addr,
|
2007-04-26 02:54:47 +02:00
|
|
|
(xfrm_address_t *)&ipv6_hdr(skb)->saddr,
|
2006-08-24 04:16:22 +02:00
|
|
|
IPPROTO_ROUTING) < 0) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INADDRERRORS);
|
2006-08-24 04:16:22 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!ipv6_chk_home_addr(addr)) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INADDRERRORS);
|
2006-08-24 04:16:22 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ipv6_addr_is_multicast(addr)) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INADDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ipv6_addr_copy(&daddr, addr);
|
2007-04-26 02:54:47 +02:00
|
|
|
ipv6_addr_copy(addr, &ipv6_hdr(skb)->daddr);
|
|
|
|
ipv6_addr_copy(&ipv6_hdr(skb)->daddr, &daddr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dst_release(xchg(&skb->dst, NULL));
|
|
|
|
ip6_route_input(skb);
|
|
|
|
if (skb->dst->error) {
|
2007-04-11 05:50:43 +02:00
|
|
|
skb_push(skb, skb->data - skb_network_header(skb));
|
2005-04-17 00:20:36 +02:00
|
|
|
dst_input(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (skb->dst->dev->flags&IFF_LOOPBACK) {
|
2007-04-26 02:54:47 +02:00
|
|
|
if (ipv6_hdr(skb)->hop_limit <= 1) {
|
2006-11-04 12:11:37 +01:00
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst),
|
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
icmpv6_send(skb, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
|
|
|
|
0, skb->dev);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
2007-04-26 02:54:47 +02:00
|
|
|
ipv6_hdr(skb)->hop_limit--;
|
2005-04-17 00:20:36 +02:00
|
|
|
goto looped_back;
|
|
|
|
}
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
skb_push(skb, skb->data - skb_network_header(skb));
|
2005-04-17 00:20:36 +02:00
|
|
|
dst_input(skb);
|
|
|
|
return -1;
|
2007-07-11 07:47:58 +02:00
|
|
|
|
|
|
|
unknown_rh:
|
|
|
|
IP6_INC_STATS_BH(ip6_dst_idev(skb->dst), IPSTATS_MIB_INHDRERRORS);
|
|
|
|
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD,
|
|
|
|
(&hdr->type) - skb_network_header(skb));
|
|
|
|
return -1;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct inet6_protocol rthdr_protocol = {
|
|
|
|
.handler = ipv6_rthdr_rcv,
|
2006-06-30 22:36:15 +02:00
|
|
|
.flags = INET6_PROTO_NOPOLICY | INET6_PROTO_GSO_EXTHDR,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
void __init ipv6_rthdr_init(void)
|
|
|
|
{
|
|
|
|
if (inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING) < 0)
|
|
|
|
printk(KERN_ERR "ipv6_rthdr_init: Could not register protocol\n");
|
|
|
|
};
|
|
|
|
|
|
|
|
/**********************************
|
|
|
|
Hop-by-hop options.
|
|
|
|
**********************************/
|
|
|
|
|
2007-05-09 23:01:59 +02:00
|
|
|
/*
|
|
|
|
* Note: we cannot rely on skb->dst before we assign it in ip6_route_input().
|
|
|
|
*/
|
|
|
|
static inline struct inet6_dev *ipv6_skb_idev(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
return skb->dst ? ip6_dst_idev(skb->dst) : __in6_dev_get(skb->dev);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Router Alert as of RFC 2711 */
|
|
|
|
|
2006-08-24 04:19:50 +02:00
|
|
|
static int ipv6_hop_ra(struct sk_buff **skbp, int optoff)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 04:19:50 +02:00
|
|
|
struct sk_buff *skb = *skbp;
|
2007-04-11 05:50:43 +02:00
|
|
|
const unsigned char *nh = skb_network_header(skb);
|
2006-08-24 04:19:50 +02:00
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
if (nh[optoff + 1] == 2) {
|
2005-04-17 00:20:36 +02:00
|
|
|
IP6CB(skb)->ra = optoff;
|
|
|
|
return 1;
|
|
|
|
}
|
2005-08-10 05:50:53 +02:00
|
|
|
LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_ra: wrong RA length %d\n",
|
2007-04-11 05:50:43 +02:00
|
|
|
nh[optoff + 1]);
|
2005-04-17 00:20:36 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Jumbo payload */
|
|
|
|
|
2006-08-24 04:19:50 +02:00
|
|
|
static int ipv6_hop_jumbo(struct sk_buff **skbp, int optoff)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 04:19:50 +02:00
|
|
|
struct sk_buff *skb = *skbp;
|
2007-04-11 05:50:43 +02:00
|
|
|
const unsigned char *nh = skb_network_header(skb);
|
2005-04-17 00:20:36 +02:00
|
|
|
u32 pkt_len;
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
if (nh[optoff + 1] != 4 || (optoff & 3) != 2) {
|
2005-08-10 05:50:53 +02:00
|
|
|
LIMIT_NETDEBUG(KERN_DEBUG "ipv6_hop_jumbo: wrong jumbo opt length/alignment %d\n",
|
2007-04-11 05:50:43 +02:00
|
|
|
nh[optoff+1]);
|
2007-05-09 23:01:59 +02:00
|
|
|
IP6_INC_STATS_BH(ipv6_skb_idev(skb),
|
2006-11-04 12:11:37 +01:00
|
|
|
IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto drop;
|
|
|
|
}
|
|
|
|
|
2007-04-11 05:50:43 +02:00
|
|
|
pkt_len = ntohl(*(__be32 *)(nh + optoff + 2));
|
2005-04-17 00:20:36 +02:00
|
|
|
if (pkt_len <= IPV6_MAXPLEN) {
|
2007-05-09 23:01:59 +02:00
|
|
|
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff+2);
|
|
|
|
return 0;
|
|
|
|
}
|
2007-04-26 02:54:47 +02:00
|
|
|
if (ipv6_hdr(skb)->payload_len) {
|
2007-05-09 23:01:59 +02:00
|
|
|
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INHDRERRORS);
|
2005-04-17 00:20:36 +02:00
|
|
|
icmpv6_param_prob(skb, ICMPV6_HDR_FIELD, optoff);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pkt_len > skb->len - sizeof(struct ipv6hdr)) {
|
2007-05-09 23:01:59 +02:00
|
|
|
IP6_INC_STATS_BH(ipv6_skb_idev(skb), IPSTATS_MIB_INTRUNCATEDPKTS);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto drop;
|
|
|
|
}
|
2005-09-08 21:57:43 +02:00
|
|
|
|
|
|
|
if (pskb_trim_rcsum(skb, pkt_len + sizeof(struct ipv6hdr)))
|
|
|
|
goto drop;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tlvtype_proc tlvprochopopt_lst[] = {
|
|
|
|
{
|
|
|
|
.type = IPV6_TLV_ROUTERALERT,
|
|
|
|
.func = ipv6_hop_ra,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.type = IPV6_TLV_JUMBO,
|
|
|
|
.func = ipv6_hop_jumbo,
|
|
|
|
},
|
|
|
|
{ -1, }
|
|
|
|
};
|
|
|
|
|
2006-08-24 04:19:50 +02:00
|
|
|
int ipv6_parse_hopopts(struct sk_buff **skbp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-08-24 04:19:50 +02:00
|
|
|
struct sk_buff *skb = *skbp;
|
2006-01-07 08:02:34 +01:00
|
|
|
struct inet6_skb_parm *opt = IP6CB(skb);
|
|
|
|
|
2006-04-18 23:46:26 +02:00
|
|
|
/*
|
2007-04-11 05:50:43 +02:00
|
|
|
* skb_network_header(skb) is equal to skb->data, and
|
2007-03-16 21:26:39 +01:00
|
|
|
* skb_network_header_len(skb) is always equal to
|
2006-04-18 23:46:26 +02:00
|
|
|
* sizeof(struct ipv6hdr) by definition of
|
|
|
|
* hop-by-hop options.
|
|
|
|
*/
|
|
|
|
if (!pskb_may_pull(skb, sizeof(struct ipv6hdr) + 8) ||
|
2007-04-26 03:04:18 +02:00
|
|
|
!pskb_may_pull(skb, (sizeof(struct ipv6hdr) +
|
|
|
|
((skb_transport_header(skb)[1] + 1) << 3)))) {
|
2006-04-18 23:46:26 +02:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2006-01-07 08:02:34 +01:00
|
|
|
opt->hop = sizeof(struct ipv6hdr);
|
2006-08-24 04:19:50 +02:00
|
|
|
if (ip6_parse_tlv(tlvprochopopt_lst, skbp)) {
|
|
|
|
skb = *skbp;
|
2007-04-11 06:21:55 +02:00
|
|
|
skb->transport_header += (skb_transport_header(skb)[1] + 1) << 3;
|
2006-09-01 00:18:49 +02:00
|
|
|
opt = IP6CB(skb);
|
2006-01-07 08:02:34 +01:00
|
|
|
opt->nhoff = sizeof(struct ipv6hdr);
|
2006-04-18 23:48:45 +02:00
|
|
|
return 1;
|
2006-01-07 08:02:34 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Creating outbound headers.
|
|
|
|
*
|
|
|
|
* "build" functions work when skb is filled from head to tail (datagram)
|
|
|
|
* "push" functions work when headers are added from tail to head (tcp)
|
|
|
|
*
|
|
|
|
* In both cases we assume, that caller reserved enough room
|
|
|
|
* for headers.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void ipv6_push_rthdr(struct sk_buff *skb, u8 *proto,
|
|
|
|
struct ipv6_rt_hdr *opt,
|
|
|
|
struct in6_addr **addr_p)
|
|
|
|
{
|
|
|
|
struct rt0_hdr *phdr, *ihdr;
|
|
|
|
int hops;
|
|
|
|
|
|
|
|
ihdr = (struct rt0_hdr *) opt;
|
2007-02-09 15:24:49 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
phdr = (struct rt0_hdr *) skb_push(skb, (ihdr->rt_hdr.hdrlen + 1) << 3);
|
|
|
|
memcpy(phdr, ihdr, sizeof(struct rt0_hdr));
|
|
|
|
|
|
|
|
hops = ihdr->rt_hdr.hdrlen >> 1;
|
|
|
|
|
|
|
|
if (hops > 1)
|
|
|
|
memcpy(phdr->addr, ihdr->addr + 1,
|
|
|
|
(hops - 1) * sizeof(struct in6_addr));
|
|
|
|
|
|
|
|
ipv6_addr_copy(phdr->addr + (hops - 1), *addr_p);
|
|
|
|
*addr_p = ihdr->addr;
|
|
|
|
|
|
|
|
phdr->rt_hdr.nexthdr = *proto;
|
|
|
|
*proto = NEXTHDR_ROUTING;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipv6_push_exthdr(struct sk_buff *skb, u8 *proto, u8 type, struct ipv6_opt_hdr *opt)
|
|
|
|
{
|
|
|
|
struct ipv6_opt_hdr *h = (struct ipv6_opt_hdr *)skb_push(skb, ipv6_optlen(opt));
|
|
|
|
|
|
|
|
memcpy(h, opt, ipv6_optlen(opt));
|
|
|
|
h->nexthdr = *proto;
|
|
|
|
*proto = type;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ipv6_push_nfrag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt,
|
|
|
|
u8 *proto,
|
|
|
|
struct in6_addr **daddr)
|
|
|
|
{
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
if (opt->srcrt) {
|
2005-04-17 00:20:36 +02:00
|
|
|
ipv6_push_rthdr(skb, proto, opt->srcrt, daddr);
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
/*
|
|
|
|
* IPV6_RTHDRDSTOPTS is ignored
|
|
|
|
* unless IPV6_RTHDR is set (RFC3542).
|
|
|
|
*/
|
|
|
|
if (opt->dst0opt)
|
|
|
|
ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst0opt);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (opt->hopopt)
|
|
|
|
ipv6_push_exthdr(skb, proto, NEXTHDR_HOP, opt->hopopt);
|
|
|
|
}
|
|
|
|
|
2007-02-22 14:05:40 +01:00
|
|
|
EXPORT_SYMBOL(ipv6_push_nfrag_opts);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
void ipv6_push_frag_opts(struct sk_buff *skb, struct ipv6_txoptions *opt, u8 *proto)
|
|
|
|
{
|
|
|
|
if (opt->dst1opt)
|
|
|
|
ipv6_push_exthdr(skb, proto, NEXTHDR_DEST, opt->dst1opt);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ipv6_txoptions *
|
|
|
|
ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt)
|
|
|
|
{
|
|
|
|
struct ipv6_txoptions *opt2;
|
|
|
|
|
|
|
|
opt2 = sock_kmalloc(sk, opt->tot_len, GFP_ATOMIC);
|
|
|
|
if (opt2) {
|
|
|
|
long dif = (char*)opt2 - (char*)opt;
|
|
|
|
memcpy(opt2, opt, opt->tot_len);
|
|
|
|
if (opt2->hopopt)
|
|
|
|
*((char**)&opt2->hopopt) += dif;
|
|
|
|
if (opt2->dst0opt)
|
|
|
|
*((char**)&opt2->dst0opt) += dif;
|
|
|
|
if (opt2->dst1opt)
|
|
|
|
*((char**)&opt2->dst1opt) += dif;
|
|
|
|
if (opt2->srcrt)
|
|
|
|
*((char**)&opt2->srcrt) += dif;
|
|
|
|
}
|
|
|
|
return opt2;
|
|
|
|
}
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
|
2005-12-14 08:23:20 +01:00
|
|
|
EXPORT_SYMBOL_GPL(ipv6_dup_options);
|
|
|
|
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
static int ipv6_renew_option(void *ohdr,
|
|
|
|
struct ipv6_opt_hdr __user *newopt, int newoptlen,
|
|
|
|
int inherit,
|
|
|
|
struct ipv6_opt_hdr **hdr,
|
|
|
|
char **p)
|
|
|
|
{
|
|
|
|
if (inherit) {
|
|
|
|
if (ohdr) {
|
|
|
|
memcpy(*p, ohdr, ipv6_optlen((struct ipv6_opt_hdr *)ohdr));
|
|
|
|
*hdr = (struct ipv6_opt_hdr *)*p;
|
|
|
|
*p += CMSG_ALIGN(ipv6_optlen(*(struct ipv6_opt_hdr **)hdr));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (newopt) {
|
|
|
|
if (copy_from_user(*p, newopt, newoptlen))
|
|
|
|
return -EFAULT;
|
|
|
|
*hdr = (struct ipv6_opt_hdr *)*p;
|
|
|
|
if (ipv6_optlen(*(struct ipv6_opt_hdr **)hdr) > newoptlen)
|
|
|
|
return -EINVAL;
|
|
|
|
*p += CMSG_ALIGN(newoptlen);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ipv6_txoptions *
|
|
|
|
ipv6_renew_options(struct sock *sk, struct ipv6_txoptions *opt,
|
|
|
|
int newtype,
|
|
|
|
struct ipv6_opt_hdr __user *newopt, int newoptlen)
|
|
|
|
{
|
|
|
|
int tot_len = 0;
|
|
|
|
char *p;
|
|
|
|
struct ipv6_txoptions *opt2;
|
|
|
|
int err;
|
|
|
|
|
2006-08-31 23:52:17 +02:00
|
|
|
if (opt) {
|
|
|
|
if (newtype != IPV6_HOPOPTS && opt->hopopt)
|
|
|
|
tot_len += CMSG_ALIGN(ipv6_optlen(opt->hopopt));
|
|
|
|
if (newtype != IPV6_RTHDRDSTOPTS && opt->dst0opt)
|
|
|
|
tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst0opt));
|
|
|
|
if (newtype != IPV6_RTHDR && opt->srcrt)
|
|
|
|
tot_len += CMSG_ALIGN(ipv6_optlen(opt->srcrt));
|
|
|
|
if (newtype != IPV6_DSTOPTS && opt->dst1opt)
|
|
|
|
tot_len += CMSG_ALIGN(ipv6_optlen(opt->dst1opt));
|
|
|
|
}
|
|
|
|
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
if (newopt && newoptlen)
|
|
|
|
tot_len += CMSG_ALIGN(newoptlen);
|
|
|
|
|
|
|
|
if (!tot_len)
|
|
|
|
return NULL;
|
|
|
|
|
2005-11-20 04:18:17 +01:00
|
|
|
tot_len += sizeof(*opt2);
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
opt2 = sock_kmalloc(sk, tot_len, GFP_ATOMIC);
|
|
|
|
if (!opt2)
|
|
|
|
return ERR_PTR(-ENOBUFS);
|
|
|
|
|
|
|
|
memset(opt2, 0, tot_len);
|
|
|
|
|
|
|
|
opt2->tot_len = tot_len;
|
|
|
|
p = (char *)(opt2 + 1);
|
|
|
|
|
2006-08-31 23:52:17 +02:00
|
|
|
err = ipv6_renew_option(opt ? opt->hopopt : NULL, newopt, newoptlen,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
newtype != IPV6_HOPOPTS,
|
|
|
|
&opt2->hopopt, &p);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2006-08-31 23:52:17 +02:00
|
|
|
err = ipv6_renew_option(opt ? opt->dst0opt : NULL, newopt, newoptlen,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
newtype != IPV6_RTHDRDSTOPTS,
|
|
|
|
&opt2->dst0opt, &p);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2006-08-31 23:52:17 +02:00
|
|
|
err = ipv6_renew_option(opt ? opt->srcrt : NULL, newopt, newoptlen,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
newtype != IPV6_RTHDR,
|
2006-08-31 23:52:17 +02:00
|
|
|
(struct ipv6_opt_hdr **)&opt2->srcrt, &p);
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2006-08-31 23:52:17 +02:00
|
|
|
err = ipv6_renew_option(opt ? opt->dst1opt : NULL, newopt, newoptlen,
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
newtype != IPV6_DSTOPTS,
|
|
|
|
&opt2->dst1opt, &p);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
opt2->opt_nflen = (opt2->hopopt ? ipv6_optlen(opt2->hopopt) : 0) +
|
|
|
|
(opt2->dst0opt ? ipv6_optlen(opt2->dst0opt) : 0) +
|
|
|
|
(opt2->srcrt ? ipv6_optlen(opt2->srcrt) : 0);
|
|
|
|
opt2->opt_flen = (opt2->dst1opt ? ipv6_optlen(opt2->dst1opt) : 0);
|
|
|
|
|
|
|
|
return opt2;
|
|
|
|
out:
|
2005-11-20 04:18:17 +01:00
|
|
|
sock_kfree_s(sk, opt2, opt2->tot_len);
|
[IPV6]: Support several new sockopt / ancillary data in Advanced API (RFC3542).
Support several new socket options / ancillary data:
IPV6_RECVPKTINFO, IPV6_PKTINFO,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS,
IPV6_RECVDSTOPTS, IPV6_DSTOPTS, IPV6_RTHDRDSTOPTS,
IPV6_RECVRTHDR, IPV6_RTHDR,
IPV6_RECVHOPOPTS, IPV6_HOPOPTS
Old semantics are preserved as IPV6_2292xxxx so that
we can maintain backward compatibility.
Signed-off-by: YOSHIFUJI Hideaki <yoshfuji@linux-ipv6.org>
2005-09-08 02:59:17 +02:00
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
2005-11-20 04:23:18 +01:00
|
|
|
struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space,
|
|
|
|
struct ipv6_txoptions *opt)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* ignore the dest before srcrt unless srcrt is being included.
|
|
|
|
* --yoshfuji
|
|
|
|
*/
|
|
|
|
if (opt && opt->dst0opt && !opt->srcrt) {
|
|
|
|
if (opt_space != opt) {
|
|
|
|
memcpy(opt_space, opt, sizeof(*opt_space));
|
|
|
|
opt = opt_space;
|
|
|
|
}
|
|
|
|
opt->opt_nflen -= ipv6_optlen(opt->dst0opt);
|
|
|
|
opt->dst0opt = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return opt;
|
|
|
|
}
|
|
|
|
|