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/config.h>
17 #include <linux/module.h>
18 #include <asm/scatterlist.h>
19 #include <asm/semaphore.h>
20 #include <linux/crypto.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>
30 #include <net/ipcomp.h>
31 #include <net/protocol.h>
34 struct list_head list
;
35 struct crypto_tfm
**tfms
;
39 static DECLARE_MUTEX(ipcomp_resource_sem
);
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
)
48 struct ipcomp_data
*ipcd
= x
->data
;
50 struct crypto_tfm
*tfm
;
54 dlen
= IPCOMP_SCRATCH_SIZE
;
58 scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
59 tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
61 err
= crypto_comp_decompress(tfm
, start
, plen
, scratch
, &dlen
);
65 if (dlen
< (plen
+ sizeof(struct ip_comp_hdr
))) {
70 err
= pskb_expand_head(skb
, 0, dlen
- plen
, GFP_ATOMIC
);
74 skb_put(skb
, dlen
- plen
);
75 memcpy(skb
->data
, scratch
, dlen
);
77 iph
->tot_len
= htons(dlen
+ iph
->ihl
* 4);
83 static int ipcomp_input(struct xfrm_state
*x
,
84 struct xfrm_decap_state
*decap
, struct sk_buff
*skb
)
95 if ((skb_is_nonlinear(skb
) || skb_cloned(skb
)) &&
96 skb_linearize(skb
, GFP_ATOMIC
) != 0) {
101 skb
->ip_summed
= CHECKSUM_NONE
;
103 /* Remove ipcomp header and decompress original payload */
105 memcpy(&tmp_iph
, iph
, iph
->ihl
* 4);
106 nexthdr
= *(u8
*)skb
->data
;
107 skb_pull(skb
, sizeof(struct ip_comp_hdr
));
108 skb
->nh
.raw
+= sizeof(struct ip_comp_hdr
);
109 memcpy(skb
->nh
.raw
, &tmp_iph
, tmp_iph
.iph
.ihl
* 4);
111 iph
->tot_len
= htons(ntohs(iph
->tot_len
) - sizeof(struct ip_comp_hdr
));
112 iph
->protocol
= nexthdr
;
113 skb
->h
.raw
= skb
->data
;
114 err
= ipcomp_decompress(x
, skb
);
120 static int ipcomp_compress(struct xfrm_state
*x
, struct sk_buff
*skb
)
122 int err
, plen
, dlen
, ihlen
;
123 struct iphdr
*iph
= skb
->nh
.iph
;
124 struct ipcomp_data
*ipcd
= x
->data
;
126 struct crypto_tfm
*tfm
;
129 ihlen
= iph
->ihl
* 4;
130 plen
= skb
->len
- ihlen
;
131 dlen
= IPCOMP_SCRATCH_SIZE
;
132 start
= skb
->data
+ ihlen
;
135 scratch
= *per_cpu_ptr(ipcomp_scratches
, cpu
);
136 tfm
= *per_cpu_ptr(ipcd
->tfms
, cpu
);
138 err
= crypto_comp_compress(tfm
, start
, plen
, scratch
, &dlen
);
142 if ((dlen
+ sizeof(struct ip_comp_hdr
)) >= plen
) {
147 memcpy(start
+ sizeof(struct ip_comp_hdr
), scratch
, dlen
);
150 pskb_trim(skb
, ihlen
+ dlen
+ sizeof(struct ip_comp_hdr
));
158 static int ipcomp_output(struct xfrm_state
*x
, struct sk_buff
*skb
)
162 struct ip_comp_hdr
*ipch
;
163 struct ipcomp_data
*ipcd
= x
->data
;
167 iph
->tot_len
= htons(skb
->len
);
168 hdr_len
= iph
->ihl
* 4;
169 if ((skb
->len
- hdr_len
) < ipcd
->threshold
) {
170 /* Don't bother compressing */
174 if ((skb_is_nonlinear(skb
) || skb_cloned(skb
)) &&
175 skb_linearize(skb
, GFP_ATOMIC
) != 0) {
179 err
= ipcomp_compress(x
, skb
);
186 /* Install ipcomp header, convert into ipcomp datagram. */
187 iph
->tot_len
= htons(skb
->len
);
188 ipch
= (struct ip_comp_hdr
*)((char *)iph
+ iph
->ihl
* 4);
189 ipch
->nexthdr
= iph
->protocol
;
191 ipch
->cpi
= htons((u16
)ntohl(x
->id
.spi
));
192 iph
->protocol
= IPPROTO_COMP
;
202 static void ipcomp4_err(struct sk_buff
*skb
, u32 info
)
205 struct iphdr
*iph
= (struct iphdr
*)skb
->data
;
206 struct ip_comp_hdr
*ipch
= (struct ip_comp_hdr
*)(skb
->data
+(iph
->ihl
<<2));
207 struct xfrm_state
*x
;
209 if (skb
->h
.icmph
->type
!= ICMP_DEST_UNREACH
||
210 skb
->h
.icmph
->code
!= ICMP_FRAG_NEEDED
)
213 spi
= ntohl(ntohs(ipch
->cpi
));
214 x
= xfrm_state_lookup((xfrm_address_t
*)&iph
->daddr
,
215 spi
, IPPROTO_COMP
, AF_INET
);
218 NETDEBUG(KERN_DEBUG
"pmtu discovery on SA IPCOMP/%08x/%u.%u.%u.%u\n",
219 spi
, NIPQUAD(iph
->daddr
));
223 /* We always hold one tunnel user reference to indicate a tunnel */
224 static struct xfrm_state
*ipcomp_tunnel_create(struct xfrm_state
*x
)
226 struct xfrm_state
*t
;
228 t
= xfrm_state_alloc();
232 t
->id
.proto
= IPPROTO_IPIP
;
233 t
->id
.spi
= x
->props
.saddr
.a4
;
234 t
->id
.daddr
.a4
= x
->id
.daddr
.a4
;
235 memcpy(&t
->sel
, &x
->sel
, sizeof(t
->sel
));
236 t
->props
.family
= AF_INET
;
238 t
->props
.saddr
.a4
= x
->props
.saddr
.a4
;
239 t
->props
.flags
= x
->props
.flags
;
241 if (xfrm_init_state(t
))
244 atomic_set(&t
->tunnel_users
, 1);
249 t
->km
.state
= XFRM_STATE_DEAD
;
256 * Must be protected by xfrm_cfg_sem. State and tunnel user references are
257 * always incremented on success.
259 static int ipcomp_tunnel_attach(struct xfrm_state
*x
)
262 struct xfrm_state
*t
;
264 t
= xfrm_state_lookup((xfrm_address_t
*)&x
->id
.daddr
.a4
,
265 x
->props
.saddr
.a4
, IPPROTO_IPIP
, AF_INET
);
267 t
= ipcomp_tunnel_create(x
);
272 xfrm_state_insert(t
);
276 atomic_inc(&t
->tunnel_users
);
281 static void ipcomp_free_scratches(void)
286 if (--ipcomp_scratch_users
)
289 scratches
= ipcomp_scratches
;
294 void *scratch
= *per_cpu_ptr(scratches
, i
);
299 free_percpu(scratches
);
302 static void **ipcomp_alloc_scratches(void)
307 if (ipcomp_scratch_users
++)
308 return ipcomp_scratches
;
310 scratches
= alloc_percpu(void *);
314 ipcomp_scratches
= scratches
;
317 void *scratch
= vmalloc(IPCOMP_SCRATCH_SIZE
);
320 *per_cpu_ptr(scratches
, i
) = scratch
;
326 static void ipcomp_free_tfms(struct crypto_tfm
**tfms
)
328 struct ipcomp_tfms
*pos
;
331 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
332 if (pos
->tfms
== tfms
)
341 list_del(&pos
->list
);
348 struct crypto_tfm
*tfm
= *per_cpu_ptr(tfms
, cpu
);
349 crypto_free_tfm(tfm
);
354 static struct crypto_tfm
**ipcomp_alloc_tfms(const char *alg_name
)
356 struct ipcomp_tfms
*pos
;
357 struct crypto_tfm
**tfms
;
360 /* This can be any valid CPU ID so we don't need locking. */
361 cpu
= raw_smp_processor_id();
363 list_for_each_entry(pos
, &ipcomp_tfms_list
, list
) {
364 struct crypto_tfm
*tfm
;
367 tfm
= *per_cpu_ptr(tfms
, cpu
);
369 if (!strcmp(crypto_tfm_alg_name(tfm
), alg_name
)) {
375 pos
= kmalloc(sizeof(*pos
), GFP_KERNEL
);
380 INIT_LIST_HEAD(&pos
->list
);
381 list_add(&pos
->list
, &ipcomp_tfms_list
);
383 pos
->tfms
= tfms
= alloc_percpu(struct crypto_tfm
*);
388 struct crypto_tfm
*tfm
= crypto_alloc_tfm(alg_name
, 0);
391 *per_cpu_ptr(tfms
, cpu
) = tfm
;
397 ipcomp_free_tfms(tfms
);
401 static void ipcomp_free_data(struct ipcomp_data
*ipcd
)
404 ipcomp_free_tfms(ipcd
->tfms
);
405 ipcomp_free_scratches();
408 static void ipcomp_destroy(struct xfrm_state
*x
)
410 struct ipcomp_data
*ipcd
= x
->data
;
413 xfrm_state_delete_tunnel(x
);
414 down(&ipcomp_resource_sem
);
415 ipcomp_free_data(ipcd
);
416 up(&ipcomp_resource_sem
);
420 static int ipcomp_init_state(struct xfrm_state
*x
)
423 struct ipcomp_data
*ipcd
;
424 struct xfrm_algo_desc
*calg_desc
;
434 ipcd
= kmalloc(sizeof(*ipcd
), GFP_KERNEL
);
438 memset(ipcd
, 0, sizeof(*ipcd
));
439 x
->props
.header_len
= 0;
441 x
->props
.header_len
+= sizeof(struct iphdr
);
443 down(&ipcomp_resource_sem
);
444 if (!ipcomp_alloc_scratches())
447 ipcd
->tfms
= ipcomp_alloc_tfms(x
->calg
->alg_name
);
450 up(&ipcomp_resource_sem
);
453 err
= ipcomp_tunnel_attach(x
);
458 calg_desc
= xfrm_calg_get_byname(x
->calg
->alg_name
, 0);
460 ipcd
->threshold
= calg_desc
->uinfo
.comp
.threshold
;
467 down(&ipcomp_resource_sem
);
469 ipcomp_free_data(ipcd
);
470 up(&ipcomp_resource_sem
);
475 static struct xfrm_type ipcomp_type
= {
476 .description
= "IPCOMP4",
477 .owner
= THIS_MODULE
,
478 .proto
= IPPROTO_COMP
,
479 .init_state
= ipcomp_init_state
,
480 .destructor
= ipcomp_destroy
,
481 .input
= ipcomp_input
,
482 .output
= ipcomp_output
485 static struct net_protocol ipcomp4_protocol
= {
486 .handler
= xfrm4_rcv
,
487 .err_handler
= ipcomp4_err
,
491 static int __init
ipcomp4_init(void)
493 if (xfrm_register_type(&ipcomp_type
, AF_INET
) < 0) {
494 printk(KERN_INFO
"ipcomp init: can't add xfrm type\n");
497 if (inet_add_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0) {
498 printk(KERN_INFO
"ipcomp init: can't add protocol\n");
499 xfrm_unregister_type(&ipcomp_type
, AF_INET
);
505 static void __exit
ipcomp4_fini(void)
507 if (inet_del_protocol(&ipcomp4_protocol
, IPPROTO_COMP
) < 0)
508 printk(KERN_INFO
"ip ipcomp close: can't remove protocol\n");
509 if (xfrm_unregister_type(&ipcomp_type
, AF_INET
) < 0)
510 printk(KERN_INFO
"ip ipcomp close: can't remove xfrm type\n");
513 module_init(ipcomp4_init
);
514 module_exit(ipcomp4_fini
);
516 MODULE_LICENSE("GPL");
517 MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp) - RFC3173");
518 MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");