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