XFRM,IPv6: Removal of RH2/HAO from IPsec-protected MIPv6 traffic
Subsystems (5)
v2 cover XFRM,IPv6: Removal of RH2/HAO from IPsec-protected MIPv6 traffic
Hi,
This an updated version of the patches. For reference, introduction of the feature is here http://thread.gmane.org/gmane.linux.network/172941
Just tell me if you prefer I resend the full intro each time.
Compared to initial version, this v2 is
- against net-next-2.6
- fixed and more exhaustively build tested for various kernel configuration (w/ and w/o IPv6, IPv4, MIPv6, XFRM*, RO, ...). It adds some #ifdef but I did not found good ways to spare those.
- built and tested on both current linux-2.6 and net-next-2.6 (*)
Comments welcome.
Cheers,
a+
(*): stripped from latest stats patches from Eric (crash at boot) until
associated fixes get included tomorrow
PATCH v2 1/5 XFRM,IPv6: Remove xfrm_spi_hash() dependency on destination address
In the new IPsec architecture [RFC4301], "for an SA used to carry unicast traffic, the Security Parameters Index (SPI) by itself suffices to specify an SA". Section 4.1 of [RFC4301] provides additional guidance on the topic.
In the old IPsec architecture [RFC2401], a SA "is uniquely identified by a triple consisting of a Security Parameter Index (SPI), an IP Destination Address and a security protocol (AH or ESP) identifier".
If an IPsec stack only supports the behavior mandated by the old IPsec architecture, SAD lookup on inbound packets require the use of both the SPI and the destination address of the SA.
For inbound IPsec traffic, IRO remapping rules may exist on the MN to remap the destination address (CoA) into the HoA. In that case, by design, the address found in the destination address field of the packet (CoA) does not match the one in the SA (HoA).
At the moment, Linux XFRM stack includes the address when computing the hash to perform state lookup by SPI. This patch changes XFRM state hash computation to prevent destination address to be used. This will later allow finding states for packets w/ mangled destination addresses.
--- net/xfrm/xfrm_hash.h | 21 +-------------------- net/xfrm/xfrm_state.c | 20 ++++++++------------ 2 files changed, 9 insertions(+), 32 deletions(-)
net/xfrm/xfrm_hash.h +1 -20
@@ -4,16 +4,6 @@#include <linux/xfrm.h> #include <linux/socket.h> -static inline unsigned int __xfrm4_addr_hash (xfrm_address_t *addr) -{ -return ntohl (addr->a4); -} - -static inline unsigned int __xfrm6_addr_hash (xfrm_address_t *addr) -{ -return ntohl (addr->a6[2 ] ^ addr->a6[3 ]); -} -static inline unsigned int __xfrm4_daddr_saddr_hash (xfrm_address_t *daddr,xfrm_address_t *saddr) {u32 sum = (__force u32 )daddr->a4 + (__force u32 )saddr->a4;
@@ -60,18 +50,9 @@ static inline unsigned __xfrm_src_hash(xfrm_address_t *daddr, }static inline unsigned int -__xfrm_spi_hash (xfrm_address_t *daddr,__be32 spi,u8 proto,unsigned short family, -unsigned int hmask) +__xfrm_spi_hash (__be32 spi,u8 proto,unsigned int hmask) {unsigned int h = (__force u32 )spi ^ proto; -switch (family) { -case AF_INET : - h ^=__xfrm4_addr_hash (daddr); -break ; -case AF_INET6 : - h ^=__xfrm6_addr_hash (daddr); -break ; - }return (h ^ (h >>10 ) ^ (h >>20 )) & hmask; }
net/xfrm/xfrm_state.c +8 -12
@@ -30,7 +30,7 @@/* Each xfrm_state may be linked to two tables: -1. Hash table by (spi,daddr,ah/esp) to find SA by SPI. (input,ctl) +1. Hash table by (spi,ah/esp) to find SA by SPI. (input,ctl) 2. Hash table by (daddr,family,reqid) to find what SAs exist for given destination/tunnel endpoint. (output) */
@@ -67,9 +67,9 @@ static inline unsigned int xfrm_src_hash(struct net *net, }static inline unsigned int -xfrm_spi_hash (struct net *net,xfrm_address_t *daddr,__be32 spi,u8 proto,unsigned short family) +xfrm_spi_hash (struct net *net,__be32 spi,u8 proto) { -return __xfrm_spi_hash (daddr, spi, proto, family, net->xfrm.state_hmask); +return __xfrm_spi_hash (spi, proto, net->xfrm.state_hmask); } static void xfrm_hash_transfer(struct hlist_head *list,
@@ -95,9 +95,7 @@ static void xfrm_hash_transfer(struct hlist_head *list,hlist_add_head (&x->bysrc, nsrctable+h);if (x->id.spi) { - h =__xfrm_spi_hash (&x->id.daddr, x->id.spi, - x->id.proto, x->props.family, - nhashmask); + h =__xfrm_spi_hash (x->id.spi, x->id.proto, nhashmask);hlist_add_head (&x->byspi, nspitable+h); } }
@@ -679,7 +677,7 @@ xfrm_init_tempstate(struct xfrm_state *x, struct flowi *fl,static struct xfrm_state *__xfrm_state_lookup (struct net *net,u32 mark,xfrm_address_t *daddr,__be32 spi,u8 proto,unsigned short family) { -unsigned int h =xfrm_spi_hash (net, daddr, spi, proto, family); +unsigned int h =xfrm_spi_hash (net, spi, proto);struct xfrm_state *x;struct hlist_node *entry;
@@ -868,7 +866,7 @@ found: h =xfrm_src_hash (net, daddr, saddr, encap_family);hlist_add_head (&x->bysrc, net->xfrm.state_bysrc+h);if (x->id.spi) { - h =xfrm_spi_hash (net, &x->id.daddr, x->id.spi, x->id.proto, encap_family); + h =xfrm_spi_hash (net, x->id.spi, x->id.proto);hlist_add_head (&x->byspi, net->xfrm.state_byspi+h); } x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;
@@ -942,9 +940,7 @@ static void __xfrm_state_insert(struct xfrm_state *x)hlist_add_head (&x->bysrc, net->xfrm.state_bysrc+h);if (x->id.spi) { - h =xfrm_spi_hash (net, &x->id.daddr, x->id.spi, x->id.proto, - x->props.family); - + h =xfrm_spi_hash (net, x->id.spi, x->id.proto);hlist_add_head (&x->byspi, net->xfrm.state_byspi+h); }
@@ -1535,7 +1531,7 @@ int xfrm_alloc_spi(struct xfrm_state *x, u32 low, u32 high) }if (x->id.spi) {spin_lock_bh (&xfrm_state_lock); - h =xfrm_spi_hash (net, &x->id.daddr, x->id.spi, x->id.proto, x->props.family); + h =xfrm_spi_hash (net, x->id.spi, x->id.proto);hlist_add_head (&x->byspi, net->xfrm.state_byspi+h);spin_unlock_bh (&xfrm_state_lock);
Signature · 1 line
1.7.1
PATCH v2 2/5 XFRM,IPv6: Introduce receive sockopts to access IRO remapped src/dst addresses
In reply to Arnaud EbalardThis patch introduces IRO recv sockopts, in order for userland processes (e.g. UMIP) to access on-wire source or destination addresses found in incoming (IPsec-protected) packets as they were before remapping by IRO. The socket options are respectively IPV6_RECVIROSRC and IPV6_RECVIRODST.
Basically, the two recv socket options are similar in their purpose to their generic RH2/HAO counterparts defined in RFC 3542 (IPV6_RECVIROSRC <-> IPV6_RECVDSTOPTS, IPV6_RECVIRODST <-> IPV6_RECVRTHDR). They differ on the following aspects:
- IRO reporting sockopts only work on incoming IPsec-protected packets Userspace will never get IRO remapped address report for common (non protected) packets.
- The receiver gets the original source/desination address (IRO remapping) from its IPsec stack.
- as IRO sockopts only deal with addresses, no specific structure is defined, i.e. struct in6_addr is used to pass info.
As we only interact with IPsec protected packets, struct sec_path is used to carry information (addresses) for incoming packets that have undergone remapping process.
--- include/linux/in6.h | 7 +++++++ include/linux/ipv6.h | 4 +++- include/net/xfrm.h | 5 +++++ net/ipv6/datagram.c | 18 ++++++++++++++++++ net/ipv6/ipv6_sockglue.c | 26 ++++++++++++++++++++++++++ 5 files changed, 59 insertions(+), 1 deletions(-)
include/linux/in6.h +7 -0
@@ -283,4 +283,11 @@ struct in6_flowlabel_req {* MRT6_PIM 208 * (reserved) 209 */ + +/* IRO (IPsec Route Optimization) sockopts */ +#define IPV6_RECVIROSRC 74 +#define IPV6_IROSRC 75 +#define IPV6_RECVIRODST 76 +#define IPV6_IRODST 77 +#endif
include/linux/ipv6.h +3 -1
@@ -341,7 +341,9 @@ struct ipv6_pinfo { odstopts:1, rxflow:1, rxtclass:1, - rxpmtu:1; + rxpmtu:1, + irosrc:1, + irodst:1; } bits;__u16 all; } rxopt;
include/net/xfrm.h +5 -0
@@ -909,6 +909,11 @@ struct sec_path {atomic_t refcnt;int len;struct xfrm_state *xvec[XFRM_MAX_DEPTH ]; + +#ifdef CONFIG_XFRM_SUB_POLICY +struct in6_addr irosrc; +struct in6_addr irodst; +#endif }; static inline struct sec_path *
net/ipv6/datagram.c +18 -0
@@ -29,6 +29,7 @@#include <net/transp_v6.h> #include <net/ip6_route.h> #include <net/tcp_states.h> +#include <net/xfrm.h> #include <linux/errqueue.h> #include <asm/uaccess.h>
@@ -504,6 +505,23 @@ int datagram_recv_ctl(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)put_cmsg (msg,SOL_IPV6 ,IPV6_HOPOPTS , (ptr[1 ]+1 )<<3 , ptr); } +#ifdef CONFIG_XFRM_SUB_POLICY +/* If access to IRO-remapped source or destination address has been +* requested and it has indeed been remapped, provide the on-wire +* address to userland */ +if (skb_sec_path (skb)) { +struct sec_path *sp =skb_sec_path (skb); + +if (np->rxopt.bits.irosrc && !ipv6_addr_any (&sp->irosrc)) +put_cmsg (msg,SOL_IPV6 ,IPV6_IROSRC , +sizeof (sp->irosrc), &sp->irosrc); + +if (np->rxopt.bits.irodst && !ipv6_addr_any (&sp->irodst)) +put_cmsg (msg,SOL_IPV6 ,IPV6_IRODST , +sizeof (sp->irodst), &sp->irodst); + } +#endif +if (opt->lastopt && (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {/*
net/ipv6/ipv6_sockglue.c +26 -0
@@ -302,6 +302,22 @@ static int do_ipv6_setsockopt(struct sock *sk, int level, int optname, retv =0 ;break ; +#ifdef CONFIG_XFRM_SUB_POLICY +case IPV6_RECVIROSRC : +if (optlen <sizeof (int )) + goto e_inval; + np->rxopt.bits.irosrc = valbool; + retv =0 ; +break ; + +case IPV6_RECVIRODST : +if (optlen <sizeof (int )) + goto e_inval; + np->rxopt.bits.irodst = valbool; + retv =0 ; +break ; +#endif +case IPV6_2292DSTOPTS :if (optlen <sizeof (int )) goto e_inval;
@@ -1056,6 +1072,16 @@ static int do_ipv6_getsockopt(struct sock *sk, int level, int optname, val = np->rxopt.bits.dstopts;break ; +#ifdef CONFIG_XFRM_SUB_POLICY +case IPV6_RECVIROSRC : + val = np->rxopt.bits.irosrc; +break ; + +case IPV6_RECVIRODST : + val = np->rxopt.bits.irodst; +break ; +#endif +case IPV6_2292DSTOPTS : val = np->rxopt.bits.odstopts;break ;
Signature · 1 line
1.7.1
PATCH v2 3/5 XFRM,IPv6: Add IRO src/dst address remapping XFRM types and i/o handlers
In reply to Arnaud EbalardAdd IRO source and destination remapping XFRM types and associated input/output handlers. This allows userland to install such states in order to support remapping of source or destination address of packet. They basically work like existing RH2 and HAO ones; the main difference is that output handlers do not expand the packet by adding an extension header: they simply change the source or destination in place. Input handlers are almost the same as RH2/HAO version in their behavior, but they are triggered differently. RH2 and HAO handlers are triggered based on structures found in the packet. On input, IRO states (and associated handlers) are looked up when processing an IPsec-protected packet, when there is an address mismatch.
--- include/net/xfrm.h | 2 + net/ipv6/mip6.c | 153 ++++++++++++++++++++++++++++++++++++++++++++++ net/ipv6/xfrm6_mode_ro.c | 11 +++- net/xfrm/xfrm_user.c | 4 + 4 files changed, 169 insertions(+), 1 deletions(-)
include/net/xfrm.h +2 -0
@@ -35,6 +35,8 @@#define XFRM_PROTO_IPV6 41#define XFRM_PROTO_ROUTING IPPROTO_ROUTING#define XFRM_PROTO_DSTOPTS IPPROTO_DSTOPTS +#define XFRM_PROTO_IRO_SRC 127 +#define XFRM_PROTO_IRO_DST 128#define XFRM_ALIGN8 (len) (((len) + 7) & ~7)#define MODULE_ALIAS_XFRM_MODE (family, encap) \
net/ipv6/mip6.c +153 -0
177 lines not on this page · raw message
net/ipv6/xfrm6_mode_ro.c +10 -1
@@ -45,6 +45,15 @@ static int xfrm6_ro_output(struct xfrm_state *x, struct sk_buff *skb)u8 *prevhdr;int hdr_len; +/* Unlike RH2 (IPPROTO_ROUTING) and HAO in DstOpt +* (IPPROTO_DSTOPTS), IRO remapping states do not +* add extension header to the packet. Source +* and/or destination addresses are simply modified +* in place. */ +if (x->id.proto ==XFRM_PROTO_IRO_SRC || + x->id.proto ==XFRM_PROTO_IRO_DST ) + goto out; + iph =ipv6_hdr (skb); hdr_len = x->type->hdr_offset (x, skb, &prevhdr);
@@ -54,8 +63,8 @@ static int xfrm6_ro_output(struct xfrm_state *x, struct sk_buff *skb)__skb_pull (skb, hdr_len);memmove (ipv6_hdr (skb), iph, hdr_len); + out: x->lastused =get_seconds (); -return 0 ; }
net/xfrm/xfrm_user.c +4 -0
@@ -179,6 +179,10 @@ static int verify_newsa_info(struct xfrm_usersa_info *p,#if defined(CONFIG_IPV6 ) || defined(CONFIG_IPV6_MODULE )case IPPROTO_DSTOPTS :case IPPROTO_ROUTING : +#ifdef CONFIG_XFRM_SUB_POLICY +case XFRM_PROTO_IRO_SRC : +case XFRM_PROTO_IRO_DST : +#endif if (attrs[XFRMA_ALG_COMP] || attrs[XFRMA_ALG_AUTH] || attrs[XFRMA_ALG_AUTH_TRUNC] ||
Signature · 1 line
1.7.1
PATCH v2 4/5 XFRM,IPv6: Add IRO remapping hook in xfrm_input()
In reply to Arnaud EbalardAdd a hook in xfrm_input() to allow IRO remapping to occur when an incoming packet matching an existing SA (based on SPI) with an unexpected destination or source address is received. Because IRO does not consume additional bits in a packet (that's the point), there is no way to demultiplex based on something like nh or spi. Instead, IRO input handlers (for source and destination address remapping) are called upon address mismatch during IPsec processing.
For that to work, we rely on the fact that SPI values generated locally are no more linked to destination address (first patch of the set) and we postpone a bit the expected address check in xfrm_input() (inside xfrm_state_lookup() against daddr param) by introducing xfrm_input_addr_check() helper.
--- include/net/xfrm.h | 3 ++ net/ipv4/xfrm4_input.c | 12 ++++++++ net/ipv6/xfrm6_input.c | 70 +++++++++++++++++++++++++++++++++++++++++++++++- net/xfrm/xfrm_input.c | 21 +++++++++++++- net/xfrm/xfrm_state.c | 2 +- 5 files changed, 104 insertions(+), 4 deletions(-)
include/net/xfrm.h +3 -0
@@ -623,6 +623,7 @@ struct xfrm_spi_skb_cb {struct inet6_skb_parm h6; } header; +unsigned int saddroff;unsigned int daddroff;unsigned int family; };
@@ -1405,6 +1406,7 @@ extern int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type);extern int xfrm4_transport_finish (struct sk_buff *skb,int async);extern int xfrm4_rcv (struct sk_buff *skb); +extern int xfrm4_input_addr_check (struct sk_buff *skb,struct xfrm_state *x);static inline int xfrm4_rcv_spi (struct sk_buff *skb,int nexthdr,__be32 spi) {
@@ -1423,6 +1425,7 @@ extern int xfrm6_transport_finish(struct sk_buff *skb, int async);extern int xfrm6_rcv (struct sk_buff *skb);extern int xfrm6_input_addr (struct sk_buff *skb,xfrm_address_t *daddr,xfrm_address_t *saddr,u8 proto); +extern int xfrm6_input_addr_check (struct sk_buff *skb,struct xfrm_state *x);extern int xfrm6_tunnel_register (struct xfrm6_tunnel *handler,unsigned short family);extern int xfrm6_tunnel_deregister (struct xfrm6_tunnel *handler,unsigned short family);extern __be32 xfrm6_tunnel_alloc_spi (struct net *net,xfrm_address_t *saddr);
net/ipv4/xfrm4_input.c +12 -0
@@ -41,6 +41,7 @@ int xfrm4_rcv_encap(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type) {XFRM_SPI_SKB_CB (skb)->family =AF_INET ; +XFRM_SPI_SKB_CB (skb)->saddroff = offsetof(struct iphdr , saddr);XFRM_SPI_SKB_CB (skb)->daddroff = offsetof(struct iphdr , daddr);return xfrm_input (skb, nexthdr, spi, encap_type); }
@@ -164,3 +165,14 @@ int xfrm4_rcv(struct sk_buff *skb)return xfrm4_rcv_spi (skb,ip_hdr (skb)->protocol,0 ); }EXPORT_SYMBOL (xfrm4_rcv); + +int xfrm4_input_addr_check (struct sk_buff *skb,struct xfrm_state *x) +{ +xfrm_address_t *daddr; + + daddr = (xfrm_address_t *)(skb_network_header (skb) + +XFRM_SPI_SKB_CB (skb)->daddroff); + +return xfrm_addr_cmp (&x->id.daddr, daddr,AF_INET ); +} +EXPORT_SYMBOL (xfrm4_input_addr_check);
net/ipv6/xfrm6_input.c +69 -1
86 lines not on this page · raw message
net/xfrm/xfrm_input.c +19 -2
@@ -102,6 +102,23 @@ int xfrm_prepare_input(struct xfrm_state *x, struct sk_buff *skb) }EXPORT_SYMBOL (xfrm_prepare_input); +static inline int xfrm_input_addr_check (struct sk_buff *skb,struct xfrm_state *x, +unsigned int family) +{ +switch (family) { +#ifdef CONFIG_INET +case AF_INET : +return xfrm4_input_addr_check (skb, x); +#endif +#if defined(CONFIG_IPV6 ) || defined (CONFIG_IPV6_MODULE ) +case AF_INET6 : +return xfrm6_input_addr_check (skb, x); +#endif +default : +return 0 ; + } +} +int xfrm_input (struct sk_buff *skb,int nexthdr,__be32 spi,int encap_type) {struct net *net =dev_net (skb->dev);
@@ -152,8 +169,8 @@ int xfrm_input(struct sk_buff *skb, int nexthdr, __be32 spi, int encap_type) goto drop; } - x =xfrm_state_lookup (net, skb->mark, daddr, spi, nexthdr, family); -if (x ==NULL ) { + x =xfrm_state_lookup (net, skb->mark,NULL , spi, nexthdr, family); +if (x ==NULL ||xfrm_input_addr_check (skb, x, family)) {XFRM_INC_STATS (net,LINUX_MIB_XFRMINNOSTATES );xfrm_audit_state_notfound (skb, family, spi, seq); goto drop;
net/xfrm/xfrm_state.c +1 -1
@@ -685,7 +685,7 @@ static struct xfrm_state *__xfrm_state_lookup(struct net *net, u32 mark, xfrm_adif (x->props.family != family || x->id.spi != spi || x->id.proto != proto || -xfrm_addr_cmp (&x->id.daddr, daddr, family)) + (daddr &&xfrm_addr_cmp (&x->id.daddr, daddr, family)))continue ;if ((mark & x->mark.m) != x->mark.v)
Signature · 1 line
1.7.1
PATCH v2 5/5 XFRM,IPv6: Add IRO remapping capability via socket ancillary data path
In reply to Arnaud EbalardThis provides the ability to remap src/dst address using IRO via ancillary data passed to sockets. This is the IRO equivalent of what is done for RH2/HAO (i.e. IPV6_RTHDR/IPV6_DSTOPTS). This is used by UMIP during BA emission when acting as a Home Agent.
--- include/net/ipv6.h | 4 ++++ net/ipv6/datagram.c | 20 ++++++++++++++++++++ net/ipv6/exthdrs.c | 19 +++++++++++++------ net/ipv6/ip6_flowlabel.c | 7 +++++++ net/ipv6/ip6_output.c | 22 ++++++++++++++++++++++ net/ipv6/raw.c | 3 ++- 6 files changed, 68 insertions(+), 7 deletions(-)
include/net/ipv6.h +4 -0
@@ -188,6 +188,10 @@ struct ipv6_txoptions {struct ipv6_rt_hdr *srcrt;/* Routing Header */ struct ipv6_opt_hdr *dst1opt; +/* XXX protect those via some ifdef e.g. CONFIG_XFRM_SUB_POLICY ? */ +struct in6_addr *iro_src; +struct in6_addr *iro_dst; +/* Option buffer, as read by IPV6_PKTOPTIONS, starts here. */ };
net/ipv6/datagram.c +20 -0
@@ -757,6 +757,26 @@ int datagram_send_ctl(struct net *net, }break ; +#ifdef CONFIG_XFRM_SUB_POLICY +case IPV6_IROSRC : +case IPV6_IRODST : +if (cmsg->cmsg_len <CMSG_LEN (sizeof (struct in6_addr ))) { + err = -EINVAL ; + goto exit_f; + } + +if (!capable (CAP_NET_RAW )) { + err = -EPERM ; + goto exit_f; + } + +if (cmsg->cmsg_type ==IPV6_IROSRC ) + opt->iro_src = (struct in6_addr *)CMSG_DATA (cmsg); +else + opt->iro_dst = (struct in6_addr *)CMSG_DATA (cmsg); +break ; +#endif +case IPV6_2292RTHDR :case IPV6_RTHDR :if (cmsg->cmsg_len <CMSG_LEN (sizeof (struct ipv6_rt_hdr ))) {
net/ipv6/exthdrs.c +13 -6
@@ -750,6 +750,10 @@ ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt) *((char **)&opt2->dst1opt) += dif;if (opt2->srcrt) *((char **)&opt2->srcrt) += dif; +if (opt2->iro_src) + *((char **)&opt2->iro_src) += dif; +if (opt2->iro_dst) + *((char **)&opt2->iro_dst) += dif; }return opt2; }
@@ -874,24 +878,27 @@ struct ipv6_txoptions *ipv6_fixup_options(struct ipv6_txoptions *opt_space,/** * fl6_update_dst - update flowi destination address with info given -* by srcrt option, if any. +* by srcrt/iro_dst option, if any. * * @fl: flowi for which fl6_dst is to be updated -* @opt: struct ipv6_txoptions in which to look for srcrt opt +* @opt: struct ipv6_txoptions in which to look for srcrt/iro_dst opt * @orig: copy of original fl6_dst address if modified * -* Returns NULL if no txoptions or no srcrt, otherwise returns orig -* and initial value of fl->fl6_dst set in orig +* Returns NULL if no txoptions or no options to change flowi destination +* (srcrt or IRO destination remapping rule), otherwise returns orig and +* initial value of fl->fl6_dst set in orig */ struct in6_addr *fl6_update_dst (struct flowi *fl,const struct ipv6_txoptions *opt,struct in6_addr *orig) { -if (!opt || !opt->srcrt) +if (!opt || (!opt->srcrt && !opt->iro_dst))return NULL ;ipv6_addr_copy (orig, &fl->fl6_dst); -ipv6_addr_copy (&fl->fl6_dst, ((struct rt0_hdr *)opt->srcrt)->addr); +ipv6_addr_copy (&fl->fl6_dst, + opt->iro_dst ?: ((struct rt0_hdr *)opt->srcrt)->addr); +return orig; }
net/ipv6/ip6_flowlabel.c +7 -0
@@ -280,6 +280,9 @@ struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space, opt_space->hopopt = fl_opt->hopopt; opt_space->dst0opt = fl_opt->dst0opt; opt_space->srcrt = fl_opt->srcrt; +/* XXX protect those via some ifdef - see net/ipv6.h */ + opt_space->iro_src = fl_opt->iro_src; + opt_space->iro_dst = fl_opt->iro_dst; opt_space->opt_nflen = fl_opt->opt_nflen; }else {if (fopt->opt_nflen ==0 )
@@ -287,6 +290,9 @@ struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space, opt_space->hopopt =NULL ; opt_space->dst0opt =NULL ; opt_space->srcrt =NULL ; +/* XXX protect those via some ifdef - see net/ipv6.h */ + opt_space->iro_src =NULL ; + opt_space->iro_dst =NULL ; opt_space->opt_nflen =0 ; } opt_space->dst1opt = fopt->dst1opt;
@@ -456,6 +462,7 @@ static int ipv6_opt_cmp(struct ipv6_txoptions *o1, struct ipv6_txoptions *o2)return 1 ;if (ipv6_hdr_cmp ((struct ipv6_opt_hdr *)o1->srcrt, (struct ipv6_opt_hdr *)o2->srcrt))return 1 ; +return 0 ; }
net/ipv6/ip6_output.c +22 -0
@@ -222,6 +222,8 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,ipv6_push_frag_opts (skb, opt, &proto);if (opt->opt_nflen)ipv6_push_nfrag_opts (skb, opt, &proto, &first_hop); +if (opt->iro_dst) + first_hop = opt->iro_dst; }skb_push (skb,sizeof (struct ipv6hdr ));
@@ -1106,6 +1108,12 @@ static inline struct ipv6_rt_hdr *ip6_rthdr_dup(struct ipv6_rt_hdr *src,return src ?kmemdup (src, (src->hdrlen +1 ) *8 , gfp) :NULL ; } +static inline struct in6_addr *ip6_iro_addr_dup (struct in6_addr *addr, +gfp_t gfp) +{ +return addr ?kmemdup (addr,sizeof (struct in6_addr ), gfp) :NULL ; +} + int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb), void *from, int length, int transhdrlen,
@@ -1162,6 +1170,16 @@ int ip6_append_data(struct sock *sk, int getfrag(void *from, char *to,if (opt->srcrt && !np->cork.opt->srcrt)return -ENOBUFS ; + np->cork.opt->iro_src =ip6_iro_addr_dup (opt->iro_src, + sk->sk_allocation); +if (opt->iro_src && !np->cork.opt->iro_src) +return -ENOBUFS ; + + np->cork.opt->iro_dst =ip6_iro_addr_dup (opt->iro_dst, + sk->sk_allocation); +if (opt->iro_dst && !np->cork.opt->iro_dst) +return -ENOBUFS ; +/* need source address above miyazawa*/ }dst_hold (&rt->dst);
@@ -1440,6 +1458,8 @@ static void ip6_cork_release(struct inet_sock *inet, struct ipv6_pinfo *np)kfree (np->cork.opt->dst1opt);kfree (np->cork.opt->hopopt);kfree (np->cork.opt->srcrt); +kfree (np->cork.opt->iro_src); +kfree (np->cork.opt->iro_dst);kfree (np->cork.opt); np->cork.opt =NULL ; }
@@ -1495,6 +1515,8 @@ int ip6_push_pending_frames(struct sock *sk)ipv6_push_frag_opts (skb, opt, &proto);if (opt && opt->opt_nflen)ipv6_push_nfrag_opts (skb, opt, &proto, &final_dst); +if (opt && opt->iro_dst) + final_dst = opt->iro_dst;skb_push (skb,sizeof (struct ipv6hdr ));skb_reset_network_header (skb);
net/ipv6/raw.c +2 -1
@@ -828,7 +828,8 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock *sk,if (flowlabel ==NULL )return -EINVAL ; } -if (!(opt->opt_nflen|opt->opt_flen)) +if (!(opt->opt_nflen|opt->opt_flen) && + (!opt->iro_src && !opt->iro_dst)) opt =NULL ; }if (opt ==NULL )
Signature · 1 line
1.7.1
David Miller
maintainerFrom: Arnaud Ebalard <[email protected]>
Date: Tue, 28 Sep 2010 17:53:50 +0200
Quoted 6 lines
This an updated version of the patches. For reference, introduction of the feature is here http://thread.gmane.org/gmane.linux.network/172941
Just tell me if you prefer I resend the full intro each time.Compared to initial version, this v2 is
Quoted 7 lines
- against net-next-2.6
- fixed and more exhaustively build tested for various kernel configuration (w/ and w/o IPv6, IPv4, MIPv6, XFRM*, RO, ...). It adds some #ifdef but I did not found good ways to spare those.
- built and tested on both current linux-2.6 and net-next-2.6 (*)Comments welcome.
Try again, this time with ipv6 modular:
net/built-in.o: In function `xfrm_input_addr_check':/home/davem/src/GIT/net-next-2.6/net/xfrm/xfrm_input.c:115: undefined reference to `xfrm6_input_addr_check'
You can't put xfrm6_input_addr_check into the ipv6.o object build if you want to call it from the generic xfrm stack which is always built statically.
Put this and xfrm4_input_addr_check where it belongs, as an afinfo->op()
Hi,
Quoted 9 lines · David Miller
Try again, this time with ipv6 modular:
net/built-in.o: In function `xfrm_input_addr_check':/home/davem/src/GIT/net-next-2.6/net/xfrm/xfrm_input.c:115: undefined reference to `xfrm6_input_addr_check'You can't put
xfrm6_input_addr_checkinto the ipv6.o object build if you want to call it from the generic xfrm stack which is always built statically.Put this and
xfrm4_input_addr_checkwhere it belongs, as anafinfo->op()
Before following the (dumb) #ifdef path, I was about to do that but worried about the penalty of the additional xfrm_state_get/put_afinfo() calls on each packet I was about to add. Should I just reduce my amount of coffee or is it a valid concern?
Cheers,
a+
David Miller
maintainerFrom: [email protected] (Arnaud Ebalard)
Date: Tue, 28 Sep 2010 23:33:16 +0200
Quoted 4 lines
Before following the (dumb) #ifdef path, I was about to do that but worried about the penalty of the additional xfrm_state_get/put_afinfo() calls on each packet I was about to add. Should I just reduce my amount of coffee or is it a valid concern?
Indeed, it is.
Even without the concern of afinfo refcounting, this test is very heavy handed for the packet path.
Can you make it small enough that it can reasonably be inlined?
Hi,
Quoted 8 lines · David Miller
From: [email protected] (Arnaud Ebalard)
Date: Tue, 28 Sep 2010 23:33:16 +0200Quoted 4 lines
Before following the (dumb) #ifdef path, I was about to do that but worried about the penalty of the additional xfrm_state_get/put_afinfo() calls on each packet I was about to add. Should I just reduce my amount of coffee or is it a valid concern?
Quoted 6 lines
Indeed, it is.
Even without the concern of afinfo refcounting, this test is very heavy handed for the packet path.
Can you make it small enough that it can reasonably be inlined?
I came up with an idea. A v3 follows; the cover letter details that.
Cheers,
a+