2 * IP Payload Compression Protocol (IPComp) for IPv6 - RFC3173
4 * Copyright (C)2003 USAGI/WIDE Project
6 * Author Mitsuru KANDA <mk@linux-ipv6.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * The compression of IP datagram MUST be done before AH/ESP processing,
27 * fragmentation, and the addition of Hop-by-Hop/Routing header.
30 * The decompression of IP datagram MUST be done after the reassembly,
34 #define pr_fmt(fmt) "IPv6: " fmt
36 #include <linux/module.h>
39 #include <net/ipcomp.h>
40 #include <linux/crypto.h>
41 #include <linux/err.h>
42 #include <linux/pfkeyv2.h>
43 #include <linux/random.h>
44 #include <linux/percpu.h>
45 #include <linux/smp.h>
46 #include <linux/list.h>
47 #include <linux/vmalloc.h>
48 #include <linux/rtnetlink.h>
51 #include <net/protocol.h>
52 #include <linux/ipv6.h>
53 #include <linux/icmpv6.h>
54 #include <linux/mutex.h>
56 static void ipcomp6_err(struct sk_buff
*skb
, struct inet6_skb_parm
*opt
,
57 u8 type
, u8 code
, int offset
, __be32 info
)
59 struct net
*net
= dev_net(skb
->dev
);
61 const struct ipv6hdr
*iph
= (const struct ipv6hdr
*)skb
->data
;
62 struct ip_comp_hdr
*ipcomph
=
63 (struct ip_comp_hdr
*)(skb
->data
+ offset
);
66 if (type
!= ICMPV6_DEST_UNREACH
&& type
!= ICMPV6_PKT_TOOBIG
)
69 spi
= htonl(ntohs(ipcomph
->cpi
));
70 x
= xfrm_state_lookup(net
, skb
->mark
, (const xfrm_address_t
*)&iph
->daddr
,
71 spi
, IPPROTO_COMP
, AF_INET6
);
75 pr_debug("pmtu discovery on SA IPCOMP/%08x/%pI6\n",
80 static struct xfrm_state
*ipcomp6_tunnel_create(struct xfrm_state
*x
)
82 struct net
*net
= xs_net(x
);
83 struct xfrm_state
*t
= NULL
;
85 t
= xfrm_state_alloc(net
);
89 t
->id
.proto
= IPPROTO_IPV6
;
90 t
->id
.spi
= xfrm6_tunnel_alloc_spi(net
, (xfrm_address_t
*)&x
->props
.saddr
);
94 memcpy(t
->id
.daddr
.a6
, x
->id
.daddr
.a6
, sizeof(struct in6_addr
));
95 memcpy(&t
->sel
, &x
->sel
, sizeof(t
->sel
));
96 t
->props
.family
= AF_INET6
;
97 t
->props
.mode
= x
->props
.mode
;
98 memcpy(t
->props
.saddr
.a6
, x
->props
.saddr
.a6
, sizeof(struct in6_addr
));
99 memcpy(&t
->mark
, &x
->mark
, sizeof(t
->mark
));
101 if (xfrm_init_state(t
))
104 atomic_set(&t
->tunnel_users
, 1);
110 t
->km
.state
= XFRM_STATE_DEAD
;
116 static int ipcomp6_tunnel_attach(struct xfrm_state
*x
)
118 struct net
*net
= xs_net(x
);
120 struct xfrm_state
*t
= NULL
;
122 u32 mark
= x
->mark
.m
& x
->mark
.v
;
124 spi
= xfrm6_tunnel_spi_lookup(net
, (xfrm_address_t
*)&x
->props
.saddr
);
126 t
= xfrm_state_lookup(net
, mark
, (xfrm_address_t
*)&x
->id
.daddr
,
127 spi
, IPPROTO_IPV6
, AF_INET6
);
129 t
= ipcomp6_tunnel_create(x
);
134 xfrm_state_insert(t
);
138 atomic_inc(&t
->tunnel_users
);
144 static int ipcomp6_init_state(struct xfrm_state
*x
)
148 x
->props
.header_len
= 0;
149 switch (x
->props
.mode
) {
150 case XFRM_MODE_TRANSPORT
:
152 case XFRM_MODE_TUNNEL
:
153 x
->props
.header_len
+= sizeof(struct ipv6hdr
);
159 err
= ipcomp_init_state(x
);
163 if (x
->props
.mode
== XFRM_MODE_TUNNEL
) {
164 err
= ipcomp6_tunnel_attach(x
);
174 static const struct xfrm_type ipcomp6_type
=
176 .description
= "IPCOMP6",
177 .owner
= THIS_MODULE
,
178 .proto
= IPPROTO_COMP
,
179 .init_state
= ipcomp6_init_state
,
180 .destructor
= ipcomp_destroy
,
181 .input
= ipcomp_input
,
182 .output
= ipcomp_output
,
183 .hdr_offset
= xfrm6_find_1stfragopt
,
186 static const struct inet6_protocol ipcomp6_protocol
=
188 .handler
= xfrm6_rcv
,
189 .err_handler
= ipcomp6_err
,
190 .flags
= INET6_PROTO_NOPOLICY
,
193 static int __init
ipcomp6_init(void)
195 if (xfrm_register_type(&ipcomp6_type
, AF_INET6
) < 0) {
196 pr_info("%s: can't add xfrm type\n", __func__
);
199 if (inet6_add_protocol(&ipcomp6_protocol
, IPPROTO_COMP
) < 0) {
200 pr_info("%s: can't add protocol\n", __func__
);
201 xfrm_unregister_type(&ipcomp6_type
, AF_INET6
);
207 static void __exit
ipcomp6_fini(void)
209 if (inet6_del_protocol(&ipcomp6_protocol
, IPPROTO_COMP
) < 0)
210 pr_info("%s: can't remove protocol\n", __func__
);
211 if (xfrm_unregister_type(&ipcomp6_type
, AF_INET6
) < 0)
212 pr_info("%s: can't remove xfrm type\n", __func__
);
215 module_init(ipcomp6_init
);
216 module_exit(ipcomp6_fini
);
217 MODULE_LICENSE("GPL");
218 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp) for IPv6 - RFC3173");
219 MODULE_AUTHOR("Mitsuru KANDA <mk@linux-ipv6.org>");
221 MODULE_ALIAS_XFRM_TYPE(AF_INET6
, XFRM_PROTO_COMP
);