ipcomp.c revision 6ab3d5624e172c553004ecc862bfeac16d9d68b7 
1/*
2 * IP Payload Compression Protocol (IPComp) - RFC3173.
3 *
4 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
5 *
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)
9 * any later version.
10 *
11 * Todo:
12 *   - Tunable compression parameters.
13 *   - Compression stats.
14 *   - Adaptive compression.
15 */
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>
27#include <net/ip.h>
28#include <net/xfrm.h>
29#include <net/icmp.h>
30#include <net/ipcomp.h>
31#include <net/protocol.h>
32
33struct ipcomp_tfms {
34	struct list_head list;
35	struct crypto_tfm **tfms;
36	int users;
37};
38
39static DEFINE_MUTEX(ipcomp_resource_mutex);
40static void **ipcomp_scratches;
41static int ipcomp_scratch_users;
42static LIST_HEAD(ipcomp_tfms_list);
43
44static int ipcomp_decompress(struct xfrm_state *x, struct sk_buff *skb)
45{
46	int err, plen, dlen;
47	struct ipcomp_data *ipcd = x->data;
48	u8 *start, *scratch;
49	struct crypto_tfm *tfm;
50	int cpu;
51
52	plen = skb->len;
53	dlen = IPCOMP_SCRATCH_SIZE;
54	start = skb->data;
55
56	cpu = get_cpu();
57	scratch = *per_cpu_ptr(ipcomp_scratches, cpu);
58	tfm = *per_cpu_ptr(ipcd->tfms, cpu);
59
60	err = crypto_comp_decompress(tfm, start, plen, scratch, &dlen);
61	if (err)
62		goto out;
63
64	if (dlen < (plen + sizeof(struct ip_comp_hdr))) {
65		err = -EINVAL;
66		goto out;
67	}
68
69	err = pskb_expand_head(skb, 0, dlen - plen, GFP_ATOMIC);
70	if (err)
71		goto out;
72
73	skb_put(skb, dlen - plen);
74	memcpy(skb->data, scratch, dlen);
75out:
76	put_cpu();
77	return err;
78}
79
80static int ipcomp_input(struct xfrm_state *x, struct sk_buff *skb)
81{
82	int err = -ENOMEM;
83	struct iphdr *iph;
84	struct ip_comp_hdr *ipch;
85
86	if (skb_linearize_cow(skb))
87	    	goto out;
88
89	skb->ip_summed = CHECKSUM_NONE;
90
91	/* Remove ipcomp header and decompress original payload */
92	iph = skb->nh.iph;
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);
98
99out:
100	return err;
101}
102
103static int ipcomp_compress(struct xfrm_state *x, struct sk_buff *skb)
104{
105	int err, plen, dlen, ihlen;
106	struct iphdr *iph = skb->nh.iph;
107	struct ipcomp_data *ipcd = x->data;
108	u8 *start, *scratch;
109	struct crypto_tfm *tfm;
110	int cpu;
111
112	ihlen = iph->ihl * 4;
113	plen = skb->len - ihlen;
114	dlen = IPCOMP_SCRATCH_SIZE;
115	start = skb->data + ihlen;
116
117	cpu = get_cpu();
118	scratch = *per_cpu_ptr(ipcomp_scratches, cpu);
119	tfm = *per_cpu_ptr(ipcd->tfms, cpu);
120
121	err = crypto_comp_compress(tfm, start, plen, scratch, &dlen);
122	if (err)
123		goto out;
124
125	if ((dlen + sizeof(struct ip_comp_hdr)) >= plen) {
126		err = -EMSGSIZE;
127		goto out;
128	}
129
130	memcpy(start + sizeof(struct ip_comp_hdr), scratch, dlen);
131	put_cpu();
132
133	pskb_trim(skb, ihlen + dlen + sizeof(struct ip_comp_hdr));
134	return 0;
135
136out:
137	put_cpu();
138	return err;
139}
140
141static int ipcomp_output(struct xfrm_state *x, struct sk_buff *skb)
142{
143	int err;
144	struct iphdr *iph;
145	struct ip_comp_hdr *ipch;
146	struct ipcomp_data *ipcd = x->data;
147	int hdr_len = 0;
148
149	iph = skb->nh.iph;
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 */
154		goto out_ok;
155	}
156
157	if (skb_linearize_cow(skb))
158		goto out_ok;
159
160	err = ipcomp_compress(x, skb);
161	iph = skb->nh.iph;
162
163	if (err) {
164		goto out_ok;
165	}
166
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;
171	ipch->flags = 0;
172	ipch->cpi = htons((u16 )ntohl(x->id.spi));
173	iph->protocol = IPPROTO_COMP;
174	ip_send_check(iph);
175	return 0;
176
177out_ok:
178	if (x->props.mode)
179		ip_send_check(iph);
180	return 0;
181}
182
183static void ipcomp4_err(struct sk_buff *skb, u32 info)
184{
185	u32 spi;
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;
189
190	if (skb->h.icmph->type != ICMP_DEST_UNREACH ||
191	    skb->h.icmph->code != ICMP_FRAG_NEEDED)
192		return;
193
194	spi = htonl(ntohs(ipch->cpi));
195	x = xfrm_state_lookup((xfrm_address_t *)&iph->daddr,
196	                      spi, IPPROTO_COMP, AF_INET);
197	if (!x)
198		return;
199	NETDEBUG(KERN_DEBUG "pmtu discovery on SA IPCOMP/%08x/%u.%u.%u.%u\n",
200		 spi, NIPQUAD(iph->daddr));
201	xfrm_state_put(x);
202}
203
204/* We always hold one tunnel user reference to indicate a tunnel */
205static struct xfrm_state *ipcomp_tunnel_create(struct xfrm_state *x)
206{
207	struct xfrm_state *t;
208
209	t = xfrm_state_alloc();
210	if (t == NULL)
211		goto out;
212
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;
218	t->props.mode = 1;
219	t->props.saddr.a4 = x->props.saddr.a4;
220	t->props.flags = x->props.flags;
221
222	if (xfrm_init_state(t))
223		goto error;
224
225	atomic_set(&t->tunnel_users, 1);
226out:
227	return t;
228
229error:
230	t->km.state = XFRM_STATE_DEAD;
231	xfrm_state_put(t);
232	t = NULL;
233	goto out;
234}
235
236/*
237 * Must be protected by xfrm_cfg_mutex.  State and tunnel user references are
238 * always incremented on success.
239 */
240static int ipcomp_tunnel_attach(struct xfrm_state *x)
241{
242	int err = 0;
243	struct xfrm_state *t;
244
245	t = xfrm_state_lookup((xfrm_address_t *)&x->id.daddr.a4,
246	                      x->props.saddr.a4, IPPROTO_IPIP, AF_INET);
247	if (!t) {
248		t = ipcomp_tunnel_create(x);
249		if (!t) {
250			err = -EINVAL;
251			goto out;
252		}
253		xfrm_state_insert(t);
254		xfrm_state_hold(t);
255	}
256	x->tunnel = t;
257	atomic_inc(&t->tunnel_users);
258out:
259	return err;
260}
261
262static void ipcomp_free_scratches(void)
263{
264	int i;
265	void **scratches;
266
267	if (--ipcomp_scratch_users)
268		return;
269
270	scratches = ipcomp_scratches;
271	if (!scratches)
272		return;
273
274	for_each_possible_cpu(i)
275		vfree(*per_cpu_ptr(scratches, i));
276
277	free_percpu(scratches);
278}
279
280static void **ipcomp_alloc_scratches(void)
281{
282	int i;
283	void **scratches;
284
285	if (ipcomp_scratch_users++)
286		return ipcomp_scratches;
287
288	scratches = alloc_percpu(void *);
289	if (!scratches)
290		return NULL;
291
292	ipcomp_scratches = scratches;
293
294	for_each_possible_cpu(i) {
295		void *scratch = vmalloc(IPCOMP_SCRATCH_SIZE);
296		if (!scratch)
297			return NULL;
298		*per_cpu_ptr(scratches, i) = scratch;
299	}
300
301	return scratches;
302}
303
304static void ipcomp_free_tfms(struct crypto_tfm **tfms)
305{
306	struct ipcomp_tfms *pos;
307	int cpu;
308
309	list_for_each_entry(pos, &ipcomp_tfms_list, list) {
310		if (pos->tfms == tfms)
311			break;
312	}
313
314	BUG_TRAP(pos);
315
316	if (--pos->users)
317		return;
318
319	list_del(&pos->list);
320	kfree(pos);
321
322	if (!tfms)
323		return;
324
325	for_each_possible_cpu(cpu) {
326		struct crypto_tfm *tfm = *per_cpu_ptr(tfms, cpu);
327		crypto_free_tfm(tfm);
328	}
329	free_percpu(tfms);
330}
331
332static struct crypto_tfm **ipcomp_alloc_tfms(const char *alg_name)
333{
334	struct ipcomp_tfms *pos;
335	struct crypto_tfm **tfms;
336	int cpu;
337
338	/* This can be any valid CPU ID so we don't need locking. */
339	cpu = raw_smp_processor_id();
340
341	list_for_each_entry(pos, &ipcomp_tfms_list, list) {
342		struct crypto_tfm *tfm;
343
344		tfms = pos->tfms;
345		tfm = *per_cpu_ptr(tfms, cpu);
346
347		if (!strcmp(crypto_tfm_alg_name(tfm), alg_name)) {
348			pos->users++;
349			return tfms;
350		}
351	}
352
353	pos = kmalloc(sizeof(*pos), GFP_KERNEL);
354	if (!pos)
355		return NULL;
356
357	pos->users = 1;
358	INIT_LIST_HEAD(&pos->list);
359	list_add(&pos->list, &ipcomp_tfms_list);
360
361	pos->tfms = tfms = alloc_percpu(struct crypto_tfm *);
362	if (!tfms)
363		goto error;
364
365	for_each_possible_cpu(cpu) {
366		struct crypto_tfm *tfm = crypto_alloc_tfm(alg_name, 0);
367		if (!tfm)
368			goto error;
369		*per_cpu_ptr(tfms, cpu) = tfm;
370	}
371
372	return tfms;
373
374error:
375	ipcomp_free_tfms(tfms);
376	return NULL;
377}
378
379static void ipcomp_free_data(struct ipcomp_data *ipcd)
380{
381	if (ipcd->tfms)
382		ipcomp_free_tfms(ipcd->tfms);
383	ipcomp_free_scratches();
384}
385
386static void ipcomp_destroy(struct xfrm_state *x)
387{
388	struct ipcomp_data *ipcd = x->data;
389	if (!ipcd)
390		return;
391	xfrm_state_delete_tunnel(x);
392	mutex_lock(&ipcomp_resource_mutex);
393	ipcomp_free_data(ipcd);
394	mutex_unlock(&ipcomp_resource_mutex);
395	kfree(ipcd);
396}
397
398static int ipcomp_init_state(struct xfrm_state *x)
399{
400	int err;
401	struct ipcomp_data *ipcd;
402	struct xfrm_algo_desc *calg_desc;
403
404	err = -EINVAL;
405	if (!x->calg)
406		goto out;
407
408	if (x->encap)
409		goto out;
410
411	err = -ENOMEM;
412	ipcd = kmalloc(sizeof(*ipcd), GFP_KERNEL);
413	if (!ipcd)
414		goto out;
415
416	memset(ipcd, 0, sizeof(*ipcd));
417	x->props.header_len = 0;
418	if (x->props.mode)
419		x->props.header_len += sizeof(struct iphdr);
420
421	mutex_lock(&ipcomp_resource_mutex);
422	if (!ipcomp_alloc_scratches())
423		goto error;
424
425	ipcd->tfms = ipcomp_alloc_tfms(x->calg->alg_name);
426	if (!ipcd->tfms)
427		goto error;
428	mutex_unlock(&ipcomp_resource_mutex);
429
430	if (x->props.mode) {
431		err = ipcomp_tunnel_attach(x);
432		if (err)
433			goto error_tunnel;
434	}
435
436	calg_desc = xfrm_calg_get_byname(x->calg->alg_name, 0);
437	BUG_ON(!calg_desc);
438	ipcd->threshold = calg_desc->uinfo.comp.threshold;
439	x->data = ipcd;
440	err = 0;
441out:
442	return err;
443
444error_tunnel:
445	mutex_lock(&ipcomp_resource_mutex);
446error:
447	ipcomp_free_data(ipcd);
448	mutex_unlock(&ipcomp_resource_mutex);
449	kfree(ipcd);
450	goto out;
451}
452
453static 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
461};
462
463static struct net_protocol ipcomp4_protocol = {
464	.handler	=	xfrm4_rcv,
465	.err_handler	=	ipcomp4_err,
466	.no_policy	=	1,
467};
468
469static int __init ipcomp4_init(void)
470{
471	if (xfrm_register_type(&ipcomp_type, AF_INET) < 0) {
472		printk(KERN_INFO "ipcomp init: can't add xfrm type\n");
473		return -EAGAIN;
474	}
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);
478		return -EAGAIN;
479	}
480	return 0;
481}
482
483static void __exit ipcomp4_fini(void)
484{
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");
489}
490
491module_init(ipcomp4_init);
492module_exit(ipcomp4_fini);
493
494MODULE_LICENSE("GPL");
495MODULE_DESCRIPTION("IP Payload Compression Protocol (IPComp) - RFC3173");
496MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");
497
498