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/pfkeyv2.h>
21 #include <linux/percpu.h>
22 #include <linux/smp.h>
23 #include <linux/list.h>
24 #include <linux/vmalloc.h>
25 #include <linux/rtnetlink.h>
26 #include <linux/mutex.h>
30 #include <net/ipcomp.h>
31 #include <net/protocol.h>
34 struct list_head list
;
35 struct crypto_tfm
**tfms
;
39 static DEFINE_MUTEX(ipcomp_resource_mutex
);
40 static void **ipcomp_scratches
;
41 static int ipcomp_scratch_users
;
42 static LIST_HEAD(ipcomp_tfms_list
);
44 static int ipcomp_decompress(struct xfrm_state
*x
, struct sk_buff
*skb
)
47 struct ipcomp_data
*ipcd
= x
->data
;
49 struct crypto_tfm
*tfm
;
53 dlen
= IPCOMP_SCRATCH_SIZE
;
57 scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
58 tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
60 err
= crypto_comp_decompress(tfm
, start
, plen
, scratch
, &dlen
);
64 if (dlen
< (plen
+ sizeof(struct ip_comp_hdr
))) {
69 err
= pskb_expand_head(skb
, 0, dlen
- plen
, GFP_ATOMIC
);
73 skb_put(skb
, dlen
- plen
);
74 memcpy(skb
->data
, scratch
, dlen
);
80 static int ipcomp_input(struct xfrm_state
*x
, struct sk_buff
*skb
)
84 struct ip_comp_hdr
*ipch
;
86 if (skb_linearize_cow(skb
))
89 skb
->ip_summed
= CHECKSUM_NONE
;
91 /* Remove ipcomp header and decompress original payload */
93 ipch
= (void *)skb
->data
;
94 iph
->protocol
= ipch
->nexthdr
;
95 skb
->h
.raw
= skb
->nh
.raw
+ sizeof(*ipch
);
96 __skb_pull(skb
, sizeof(*ipch
));
97 err
= ipcomp_decompress(x
, skb
);
103 static int ipcomp_compress(struct xfrm_state
*x
, struct sk_buff
*skb
)
105 int err
, plen
, dlen
, ihlen
;
106 struct iphdr
*iph
= skb
->nh
.iph
;
107 struct ipcomp_data
*ipcd
= x
->data
;
109 struct crypto_tfm
*tfm
;
112 ihlen
= iph
->ihl
* 4;
113 plen
= skb
->len
- ihlen
;
114 dlen
= IPCOMP_SCRATCH_SIZE
;
115 start
= skb
->data
+ ihlen
;
118 scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
119 tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
121 err
= crypto_comp_compress(tfm
, start
, plen
, scratch
, &dlen
);
125 if ((dlen
+ sizeof(struct ip_comp_hdr
)) >= plen
) {
130 memcpy(start
+ sizeof(struct ip_comp_hdr
), scratch
, dlen
);
133 pskb_trim(skb
, ihlen
+ dlen
+ sizeof(struct ip_comp_hdr
));
141 static int ipcomp_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
145 struct ip_comp_hdr
*ipch
;
146 struct ipcomp_data
*ipcd
= x
->data
;
150 iph
->tot_len
= htons(skb
->len
);
151 hdr_len
= iph
->ihl
* 4;
152 if ((skb
->len
- hdr_len
) < ipcd
->threshold
) {
153 /* Don't bother compressing */
157 if (skb_linearize_cow(skb
))
160 err
= ipcomp_compress(x
, skb
);
167 /* Install ipcomp header, convert into ipcomp datagram. */
168 iph
->tot_len
= htons(skb
->len
);
169 ipch
= (struct ip_comp_hdr
*)((char *)iph
+ iph
->ihl
* 4);
170 ipch
->nexthdr
= iph
->protocol
;
172 ipch
->cpi
= htons((u16
)ntohl(x
->id
.spi
));
173 iph
->protocol
= IPPROTO_COMP
;
183 static void ipcomp4_err(struct sk_buff
*skb
, u32 info
)
186 struct iphdr
*iph
= (struct iphdr
*)skb
->data
;
187 struct ip_comp_hdr
*ipch
= (struct ip_comp_hdr
*)(skb
->data
+(iph
->ihl
<<2));
188 struct xfrm_state
*x
;
190 if (skb
->h
.icmph
->type
!= ICMP_DEST_UNREACH
||
191 skb
->h
.icmph
->code
!= ICMP_FRAG_NEEDED
)
194 spi
= htonl(ntohs(ipch
->cpi
));
195 x
= xfrm_state_lookup((xfrm_address_t
*)&iph
->daddr
,
196 spi
, IPPROTO_COMP
, AF_INET
);
199 NETDEBUG(KERN_DEBUG
"pmtu discovery on SA IPCOMP/%08x/%u.%u.%u.%u\n",
200 spi
, NIPQUAD(iph
->daddr
));
204 /* We always hold one tunnel user reference to indicate a tunnel */
205 static struct xfrm_state
*ipcomp_tunnel_create(struct xfrm_state
*x
)
207 struct xfrm_state
*t
;
209 t
= xfrm_state_alloc();
213 t
->id
.proto
= IPPROTO_IPIP
;
214 t
->id
.spi
= x
->props
.saddr
.a4
;
215 t
->id
.daddr
.a4
= x
->id
.daddr
.a4
;
216 memcpy(&t
->sel
, &x
->sel
, sizeof(t
->sel
));
217 t
->props
.family
= AF_INET
;
219 t
->props
.saddr
.a4
= x
->props
.saddr
.a4
;
220 t
->props
.flags
= x
->props
.flags
;
222 if (xfrm_init_state(t
))
225 atomic_set(&t
->tunnel_users
, 1);
230 t
->km
.state
= XFRM_STATE_DEAD
;
237 * Must be protected by xfrm_cfg_mutex. State and tunnel user references are
238 * always incremented on success.
240 static int ipcomp_tunnel_attach(struct xfrm_state
*x
)
243 struct xfrm_state
*t
;
245 t
= xfrm_state_lookup((xfrm_address_t
*)&x
->id
.daddr
.a4
,
246 x
->props
.saddr
.a4
, IPPROTO_IPIP
, AF_INET
);
248 t
= ipcomp_tunnel_create(x
);
253 xfrm_state_insert(t
);
257 atomic_inc(&t
->tunnel_users
);
262 static void ipcomp_free_scratches(void)
267 if (--ipcomp_scratch_users
)
270 scratches
= ipcomp_scratches
;
274 for_each_possible_cpu(i
)
275 vfree(*per_cpu_ptr(scratches
, i
));
277 free_percpu(scratches
);
280 static void **ipcomp_alloc_scratches(void)
285 if (ipcomp_scratch_users
++)
286 return ipcomp_scratches
;
288 scratches
= alloc_percpu(void *);
292 ipcomp_scratches
= scratches
;
294 for_each_possible_cpu(i
) {
295 void *scratch
= vmalloc(IPCOMP_SCRATCH_SIZE
);
298 *per_cpu_ptr(scratches
, i
) = scratch
;
304 static void ipcomp_free_tfms(struct crypto_tfm
**tfms
)
306 struct ipcomp_tfms
*pos
;
309 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
310 if (pos
->tfms
== tfms
)
319 list_del(&pos
->list
);
325 for_each_possible_cpu(cpu
) {
326 struct crypto_tfm
*tfm
= *per_cpu_ptr(tfms
, cpu
);
327 crypto_free_tfm(tfm
);
332 static struct crypto_tfm
**ipcomp_alloc_tfms(const char *alg_name
)
334 struct ipcomp_tfms
*pos
;
335 struct crypto_tfm
**tfms
;
338 /* This can be any valid CPU ID so we don't need locking. */
339 cpu
= raw_smp_processor_id();
341 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
342 struct crypto_tfm
*tfm
;
345 tfm
= *per_cpu_ptr(tfms
, cpu
);
347 if (!strcmp(crypto_tfm_alg_name(tfm
), alg_name
)) {
353 pos
= kmalloc(sizeof(*pos
), GFP_KERNEL
);
358 INIT_LIST_HEAD(&pos
->list
);
359 list_add(&pos
->list
, &ipcomp_tfms_list
);
361 pos
->tfms
= tfms
= alloc_percpu(struct crypto_tfm
*);
365 for_each_possible_cpu(cpu
) {
366 struct crypto_tfm
*tfm
= crypto_alloc_tfm(alg_name
, 0);
369 *per_cpu_ptr(tfms
, cpu
) = tfm
;
375 ipcomp_free_tfms(tfms
);
379 static void ipcomp_free_data(struct ipcomp_data
*ipcd
)
382 ipcomp_free_tfms(ipcd
->tfms
);
383 ipcomp_free_scratches();
386 static void ipcomp_destroy(struct xfrm_state
*x
)
388 struct ipcomp_data
*ipcd
= x
->data
;
391 xfrm_state_delete_tunnel(x
);
392 mutex_lock(&ipcomp_resource_mutex
);
393 ipcomp_free_data(ipcd
);
394 mutex_unlock(&ipcomp_resource_mutex
);
398 static int ipcomp_init_state(struct xfrm_state
*x
)
401 struct ipcomp_data
*ipcd
;
402 struct xfrm_algo_desc
*calg_desc
;
412 ipcd
= kmalloc(sizeof(*ipcd
), GFP_KERNEL
);
416 memset(ipcd
, 0, sizeof(*ipcd
));
417 x
->props
.header_len
= 0;
419 x
->props
.header_len
+= sizeof(struct iphdr
);
421 mutex_lock(&ipcomp_resource_mutex
);
422 if (!ipcomp_alloc_scratches())
425 ipcd
->tfms
= ipcomp_alloc_tfms(x
->calg
->alg_name
);
428 mutex_unlock(&ipcomp_resource_mutex
);
431 err
= ipcomp_tunnel_attach(x
);
436 calg_desc
= xfrm_calg_get_byname(x
->calg
->alg_name
, 0);
438 ipcd
->threshold
= calg_desc
->uinfo
.comp
.threshold
;
445 mutex_lock(&ipcomp_resource_mutex
);
447 ipcomp_free_data(ipcd
);
448 mutex_unlock(&ipcomp_resource_mutex
);
453 static struct xfrm_type ipcomp_type
= {
454 .description
= "IPCOMP4",
455 .owner
= THIS_MODULE
,
456 .proto
= IPPROTO_COMP
,
457 .init_state
= ipcomp_init_state
,
458 .destructor
= ipcomp_destroy
,
459 .input
= ipcomp_input
,
460 .output
= ipcomp_output
463 static struct net_protocol ipcomp4_protocol
= {
464 .handler
= xfrm4_rcv
,
465 .err_handler
= ipcomp4_err
,
469 static int __init
ipcomp4_init(void)
471 if (xfrm_register_type(&ipcomp_type
, AF_INET
) < 0) {
472 printk(KERN_INFO
"ipcomp init: can't add xfrm type\n");
475 if (inet_add_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0) {
476 printk(KERN_INFO
"ipcomp init: can't add protocol\n");
477 xfrm_unregister_type(&ipcomp_type
, AF_INET
);
483 static void __exit
ipcomp4_fini(void)
485 if (inet_del_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0)
486 printk(KERN_INFO
"ip ipcomp close: can't remove protocol\n");
487 if (xfrm_unregister_type(&ipcomp_type
, AF_INET
) < 0)
488 printk(KERN_INFO
"ip ipcomp close: can't remove xfrm type\n");
491 module_init(ipcomp4_init
);
492 module_exit(ipcomp4_fini
);
494 MODULE_LICENSE("GPL");
495 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp) - RFC3173");
496 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");