2 * IP Payload Compression Protocol (IPComp) - RFC3173.
4 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
12 * - Tunable compression parameters.
13 * - Compression stats.
14 * - Adaptive compression.
16 #include <linux/module.h>
17 #include <asm/scatterlist.h>
18 #include <asm/semaphore.h>
19 #include <linux/crypto.h>
20 #include <linux/err.h>
21 #include <linux/pfkeyv2.h>
22 #include <linux/percpu.h>
23 #include <linux/smp.h>
24 #include <linux/list.h>
25 #include <linux/vmalloc.h>
26 #include <linux/rtnetlink.h>
27 #include <linux/mutex.h>
31 #include <net/ipcomp.h>
32 #include <net/protocol.h>
35 struct list_head list
;
36 struct crypto_comp
**tfms
;
40 static DEFINE_MUTEX(ipcomp_resource_mutex
);
41 static void **ipcomp_scratches
;
42 static int ipcomp_scratch_users
;
43 static LIST_HEAD(ipcomp_tfms_list
);
45 static int ipcomp_decompress(struct xfrm_state
*x
, struct sk_buff
*skb
)
47 struct ipcomp_data
*ipcd
= x
->data
;
48 const int plen
= skb
->len
;
49 int dlen
= IPCOMP_SCRATCH_SIZE
;
50 const u8
*start
= skb
->data
;
51 const int cpu
= get_cpu();
52 u8
*scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
53 struct crypto_comp
*tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
54 int err
= crypto_comp_decompress(tfm
, start
, plen
, scratch
, &dlen
);
59 if (dlen
< (plen
+ sizeof(struct ip_comp_hdr
))) {
64 err
= pskb_expand_head(skb
, 0, dlen
- plen
, GFP_ATOMIC
);
68 skb
->truesize
+= dlen
- plen
;
69 __skb_put(skb
, dlen
- plen
);
70 skb_copy_to_linear_data(skb
, scratch
, dlen
);
76 static int ipcomp_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
80 struct ip_comp_hdr
*ipch
;
82 if (skb_linearize_cow(skb
))
85 skb
->ip_summed
= CHECKSUM_NONE
;
87 /* Remove ipcomp header and decompress original payload */
89 ipch
= (void *)skb
->data
;
90 iph
->protocol
= ipch
->nexthdr
;
91 skb
->transport_header
= skb
->network_header
+ sizeof(*ipch
);
92 __skb_pull(skb
, sizeof(*ipch
));
93 err
= ipcomp_decompress(x
, skb
);
99 static int ipcomp_compress(struct xfrm_state
*x
, struct sk_buff
*skb
)
101 struct ipcomp_data
*ipcd
= x
->data
;
102 const int ihlen
= ip_hdrlen(skb
);
103 const int plen
= skb
->len
- ihlen
;
104 int dlen
= IPCOMP_SCRATCH_SIZE
;
105 u8
*start
= skb
->data
+ ihlen
;
106 const int cpu
= get_cpu();
107 u8
*scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
108 struct crypto_comp
*tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
109 int err
= crypto_comp_compress(tfm
, start
, plen
, scratch
, &dlen
);
114 if ((dlen
+ sizeof(struct ip_comp_hdr
)) >= plen
) {
119 memcpy(start
+ sizeof(struct ip_comp_hdr
), scratch
, dlen
);
122 pskb_trim(skb
, ihlen
+ dlen
+ sizeof(struct ip_comp_hdr
));
130 static int ipcomp_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
133 struct ip_comp_hdr
*ipch
;
134 struct ipcomp_data
*ipcd
= x
->data
;
136 struct iphdr
*iph
= ip_hdr(skb
);
138 iph
->tot_len
= htons(skb
->len
);
139 hdr_len
= iph
->ihl
* 4;
140 if ((skb
->len
- hdr_len
) < ipcd
->threshold
) {
141 /* Don't bother compressing */
145 if (skb_linearize_cow(skb
))
148 err
= ipcomp_compress(x
, skb
);
155 /* Install ipcomp header, convert into ipcomp datagram. */
156 iph
->tot_len
= htons(skb
->len
);
157 ipch
= (struct ip_comp_hdr
*)((char *)iph
+ iph
->ihl
* 4);
158 ipch
->nexthdr
= iph
->protocol
;
160 ipch
->cpi
= htons((u16
)ntohl(x
->id
.spi
));
161 iph
->protocol
= IPPROTO_COMP
;
166 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
171 static void ipcomp4_err(struct sk_buff
*skb
, u32 info
)
174 struct iphdr
*iph
= (struct iphdr
*)skb
->data
;
175 struct ip_comp_hdr
*ipch
= (struct ip_comp_hdr
*)(skb
->data
+(iph
->ihl
<<2));
176 struct xfrm_state
*x
;
178 if (icmp_hdr(skb
)->type
!= ICMP_DEST_UNREACH
||
179 icmp_hdr(skb
)->code
!= ICMP_FRAG_NEEDED
)
182 spi
= htonl(ntohs(ipch
->cpi
));
183 x
= xfrm_state_lookup((xfrm_address_t
*)&iph
->daddr
,
184 spi
, IPPROTO_COMP
, AF_INET
);
187 NETDEBUG(KERN_DEBUG
"pmtu discovery on SA IPCOMP/%08x/%u.%u.%u.%u\n",
188 spi
, NIPQUAD(iph
->daddr
));
192 /* We always hold one tunnel user reference to indicate a tunnel */
193 static struct xfrm_state
*ipcomp_tunnel_create(struct xfrm_state
*x
)
195 struct xfrm_state
*t
;
196 u8 mode
= XFRM_MODE_TUNNEL
;
198 t
= xfrm_state_alloc();
202 t
->id
.proto
= IPPROTO_IPIP
;
203 t
->id
.spi
= x
->props
.saddr
.a4
;
204 t
->id
.daddr
.a4
= x
->id
.daddr
.a4
;
205 memcpy(&t
->sel
, &x
->sel
, sizeof(t
->sel
));
206 t
->props
.family
= AF_INET
;
207 if (x
->props
.mode
== XFRM_MODE_BEET
)
208 mode
= x
->props
.mode
;
209 t
->props
.mode
= mode
;
210 t
->props
.saddr
.a4
= x
->props
.saddr
.a4
;
211 t
->props
.flags
= x
->props
.flags
;
213 if (xfrm_init_state(t
))
216 atomic_set(&t
->tunnel_users
, 1);
221 t
->km
.state
= XFRM_STATE_DEAD
;
228 * Must be protected by xfrm_cfg_mutex. State and tunnel user references are
229 * always incremented on success.
231 static int ipcomp_tunnel_attach(struct xfrm_state
*x
)
234 struct xfrm_state
*t
;
236 t
= xfrm_state_lookup((xfrm_address_t
*)&x
->id
.daddr
.a4
,
237 x
->props
.saddr
.a4
, IPPROTO_IPIP
, AF_INET
);
239 t
= ipcomp_tunnel_create(x
);
244 xfrm_state_insert(t
);
248 atomic_inc(&t
->tunnel_users
);
253 static void ipcomp_free_scratches(void)
258 if (--ipcomp_scratch_users
)
261 scratches
= ipcomp_scratches
;
265 for_each_possible_cpu(i
)
266 vfree(*per_cpu_ptr(scratches
, i
));
268 free_percpu(scratches
);
271 static void **ipcomp_alloc_scratches(void)
276 if (ipcomp_scratch_users
++)
277 return ipcomp_scratches
;
279 scratches
= alloc_percpu(void *);
283 ipcomp_scratches
= scratches
;
285 for_each_possible_cpu(i
) {
286 void *scratch
= vmalloc(IPCOMP_SCRATCH_SIZE
);
289 *per_cpu_ptr(scratches
, i
) = scratch
;
295 static void ipcomp_free_tfms(struct crypto_comp
**tfms
)
297 struct ipcomp_tfms
*pos
;
300 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
301 if (pos
->tfms
== tfms
)
310 list_del(&pos
->list
);
316 for_each_possible_cpu(cpu
) {
317 struct crypto_comp
*tfm
= *per_cpu_ptr(tfms
, cpu
);
318 crypto_free_comp(tfm
);
323 static struct crypto_comp
**ipcomp_alloc_tfms(const char *alg_name
)
325 struct ipcomp_tfms
*pos
;
326 struct crypto_comp
**tfms
;
329 /* This can be any valid CPU ID so we don't need locking. */
330 cpu
= raw_smp_processor_id();
332 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
333 struct crypto_comp
*tfm
;
336 tfm
= *per_cpu_ptr(tfms
, cpu
);
338 if (!strcmp(crypto_comp_name(tfm
), alg_name
)) {
344 pos
= kmalloc(sizeof(*pos
), GFP_KERNEL
);
349 INIT_LIST_HEAD(&pos
->list
);
350 list_add(&pos
->list
, &ipcomp_tfms_list
);
352 pos
->tfms
= tfms
= alloc_percpu(struct crypto_comp
*);
356 for_each_possible_cpu(cpu
) {
357 struct crypto_comp
*tfm
= crypto_alloc_comp(alg_name
, 0,
361 *per_cpu_ptr(tfms
, cpu
) = tfm
;
367 ipcomp_free_tfms(tfms
);
371 static void ipcomp_free_data(struct ipcomp_data
*ipcd
)
374 ipcomp_free_tfms(ipcd
->tfms
);
375 ipcomp_free_scratches();
378 static void ipcomp_destroy(struct xfrm_state
*x
)
380 struct ipcomp_data
*ipcd
= x
->data
;
383 xfrm_state_delete_tunnel(x
);
384 mutex_lock(&ipcomp_resource_mutex
);
385 ipcomp_free_data(ipcd
);
386 mutex_unlock(&ipcomp_resource_mutex
);
390 static int ipcomp_init_state(struct xfrm_state
*x
)
393 struct ipcomp_data
*ipcd
;
394 struct xfrm_algo_desc
*calg_desc
;
404 ipcd
= kzalloc(sizeof(*ipcd
), GFP_KERNEL
);
408 x
->props
.header_len
= 0;
409 if (x
->props
.mode
== XFRM_MODE_TUNNEL
)
410 x
->props
.header_len
+= sizeof(struct iphdr
);
412 mutex_lock(&ipcomp_resource_mutex
);
413 if (!ipcomp_alloc_scratches())
416 ipcd
->tfms
= ipcomp_alloc_tfms(x
->calg
->alg_name
);
419 mutex_unlock(&ipcomp_resource_mutex
);
421 if (x
->props
.mode
== XFRM_MODE_TUNNEL
) {
422 err
= ipcomp_tunnel_attach(x
);
427 calg_desc
= xfrm_calg_get_byname(x
->calg
->alg_name
, 0);
429 ipcd
->threshold
= calg_desc
->uinfo
.comp
.threshold
;
436 mutex_lock(&ipcomp_resource_mutex
);
438 ipcomp_free_data(ipcd
);
439 mutex_unlock(&ipcomp_resource_mutex
);
444 static struct xfrm_type ipcomp_type
= {
445 .description
= "IPCOMP4",
446 .owner
= THIS_MODULE
,
447 .proto
= IPPROTO_COMP
,
448 .init_state
= ipcomp_init_state
,
449 .destructor
= ipcomp_destroy
,
450 .input
= ipcomp_input
,
451 .output
= ipcomp_output
454 static struct net_protocol ipcomp4_protocol
= {
455 .handler
= xfrm4_rcv
,
456 .err_handler
= ipcomp4_err
,
460 static int __init
ipcomp4_init(void)
462 if (xfrm_register_type(&ipcomp_type
, AF_INET
) < 0) {
463 printk(KERN_INFO
"ipcomp init: can't add xfrm type\n");
466 if (inet_add_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0) {
467 printk(KERN_INFO
"ipcomp init: can't add protocol\n");
468 xfrm_unregister_type(&ipcomp_type
, AF_INET
);
474 static void __exit
ipcomp4_fini(void)
476 if (inet_del_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0)
477 printk(KERN_INFO
"ip ipcomp close: can't remove protocol\n");
478 if (xfrm_unregister_type(&ipcomp_type
, AF_INET
) < 0)
479 printk(KERN_INFO
"ip ipcomp close: can't remove xfrm type\n");
482 module_init(ipcomp4_init
);
483 module_exit(ipcomp4_fini
);
485 MODULE_LICENSE("GPL");
486 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp) - RFC3173");
487 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");