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