nf_conntrack_reasm.c revision abd6523d15f40bfee14652619a31a7f65f77f581
1/* 2 * IPv6 fragment reassembly for connection tracking 3 * 4 * Copyright (C)2004 USAGI/WIDE Project 5 * 6 * Author: 7 * Yasuyuki Kozakai @USAGI <yasuyuki.kozakai@toshiba.co.jp> 8 * 9 * Based on: net/ipv6/reassembly.c 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 */ 16 17#include <linux/errno.h> 18#include <linux/types.h> 19#include <linux/string.h> 20#include <linux/socket.h> 21#include <linux/sockios.h> 22#include <linux/jiffies.h> 23#include <linux/net.h> 24#include <linux/list.h> 25#include <linux/netdevice.h> 26#include <linux/in6.h> 27#include <linux/ipv6.h> 28#include <linux/icmpv6.h> 29#include <linux/random.h> 30#include <linux/jhash.h> 31 32#include <net/sock.h> 33#include <net/snmp.h> 34#include <net/inet_frag.h> 35 36#include <net/ipv6.h> 37#include <net/protocol.h> 38#include <net/transp_v6.h> 39#include <net/rawv6.h> 40#include <net/ndisc.h> 41#include <net/addrconf.h> 42#include <linux/sysctl.h> 43#include <linux/netfilter.h> 44#include <linux/netfilter_ipv6.h> 45#include <linux/kernel.h> 46#include <linux/module.h> 47 48#define NF_CT_FRAG6_HIGH_THRESH 262144 /* == 256*1024 */ 49#define NF_CT_FRAG6_LOW_THRESH 196608 /* == 192*1024 */ 50#define NF_CT_FRAG6_TIMEOUT IPV6_FRAG_TIMEOUT 51 52struct nf_ct_frag6_skb_cb 53{ 54 struct inet6_skb_parm h; 55 int offset; 56 struct sk_buff *orig; 57}; 58 59#define NFCT_FRAG6_CB(skb) ((struct nf_ct_frag6_skb_cb*)((skb)->cb)) 60 61struct nf_ct_frag6_queue 62{ 63 struct inet_frag_queue q; 64 65 __be32 id; /* fragment id */ 66 struct in6_addr saddr; 67 struct in6_addr daddr; 68 69 unsigned int csum; 70 __u16 nhoffset; 71}; 72 73struct inet_frags_ctl nf_frags_ctl __read_mostly = { 74 .high_thresh = 256 * 1024, 75 .low_thresh = 192 * 1024, 76 .timeout = IPV6_FRAG_TIMEOUT, 77 .secret_interval = 10 * 60 * HZ, 78}; 79 80static struct inet_frags nf_frags; 81 82static unsigned int ip6qhashfn(__be32 id, struct in6_addr *saddr, 83 struct in6_addr *daddr) 84{ 85 u32 a, b, c; 86 87 a = (__force u32)saddr->s6_addr32[0]; 88 b = (__force u32)saddr->s6_addr32[1]; 89 c = (__force u32)saddr->s6_addr32[2]; 90 91 a += JHASH_GOLDEN_RATIO; 92 b += JHASH_GOLDEN_RATIO; 93 c += nf_frags.rnd; 94 __jhash_mix(a, b, c); 95 96 a += (__force u32)saddr->s6_addr32[3]; 97 b += (__force u32)daddr->s6_addr32[0]; 98 c += (__force u32)daddr->s6_addr32[1]; 99 __jhash_mix(a, b, c); 100 101 a += (__force u32)daddr->s6_addr32[2]; 102 b += (__force u32)daddr->s6_addr32[3]; 103 c += (__force u32)id; 104 __jhash_mix(a, b, c); 105 106 return c & (INETFRAGS_HASHSZ - 1); 107} 108 109static unsigned int nf_hashfn(struct inet_frag_queue *q) 110{ 111 struct nf_ct_frag6_queue *nq; 112 113 nq = container_of(q, struct nf_ct_frag6_queue, q); 114 return ip6qhashfn(nq->id, &nq->saddr, &nq->daddr); 115} 116 117static void nf_skb_free(struct sk_buff *skb) 118{ 119 if (NFCT_FRAG6_CB(skb)->orig) 120 kfree_skb(NFCT_FRAG6_CB(skb)->orig); 121} 122 123/* Memory Tracking Functions. */ 124static inline void frag_kfree_skb(struct sk_buff *skb, unsigned int *work) 125{ 126 if (work) 127 *work -= skb->truesize; 128 atomic_sub(skb->truesize, &nf_frags.mem); 129 nf_skb_free(skb); 130 kfree_skb(skb); 131} 132 133static void nf_frag_free(struct inet_frag_queue *q) 134{ 135 kfree(container_of(q, struct nf_ct_frag6_queue, q)); 136} 137 138/* Destruction primitives. */ 139 140static __inline__ void fq_put(struct nf_ct_frag6_queue *fq) 141{ 142 inet_frag_put(&fq->q, &nf_frags); 143} 144 145/* Kill fq entry. It is not destroyed immediately, 146 * because caller (and someone more) holds reference count. 147 */ 148static __inline__ void fq_kill(struct nf_ct_frag6_queue *fq) 149{ 150 inet_frag_kill(&fq->q, &nf_frags); 151} 152 153static void nf_ct_frag6_evictor(void) 154{ 155 inet_frag_evictor(&nf_frags); 156} 157 158static void nf_ct_frag6_expire(unsigned long data) 159{ 160 struct nf_ct_frag6_queue *fq; 161 162 fq = container_of((struct inet_frag_queue *)data, 163 struct nf_ct_frag6_queue, q); 164 165 spin_lock(&fq->q.lock); 166 167 if (fq->q.last_in & COMPLETE) 168 goto out; 169 170 fq_kill(fq); 171 172out: 173 spin_unlock(&fq->q.lock); 174 fq_put(fq); 175} 176 177/* Creation primitives. */ 178 179static __inline__ struct nf_ct_frag6_queue * 180fq_find(__be32 id, struct in6_addr *src, struct in6_addr *dst) 181{ 182 struct inet_frag_queue *q; 183 struct ip6_create_arg arg; 184 unsigned int hash; 185 186 arg.id = id; 187 arg.src = src; 188 arg.dst = dst; 189 hash = ip6qhashfn(id, src, dst); 190 191 q = inet_frag_find(&nf_frags, &arg, hash); 192 if (q == NULL) 193 goto oom; 194 195 return container_of(q, struct nf_ct_frag6_queue, q); 196 197oom: 198 pr_debug("Can't alloc new queue\n"); 199 return NULL; 200} 201 202 203static int nf_ct_frag6_queue(struct nf_ct_frag6_queue *fq, struct sk_buff *skb, 204 struct frag_hdr *fhdr, int nhoff) 205{ 206 struct sk_buff *prev, *next; 207 int offset, end; 208 209 if (fq->q.last_in & COMPLETE) { 210 pr_debug("Allready completed\n"); 211 goto err; 212 } 213 214 offset = ntohs(fhdr->frag_off) & ~0x7; 215 end = offset + (ntohs(ipv6_hdr(skb)->payload_len) - 216 ((u8 *)(fhdr + 1) - (u8 *)(ipv6_hdr(skb) + 1))); 217 218 if ((unsigned int)end > IPV6_MAXPLEN) { 219 pr_debug("offset is too large.\n"); 220 return -1; 221 } 222 223 if (skb->ip_summed == CHECKSUM_COMPLETE) { 224 const unsigned char *nh = skb_network_header(skb); 225 skb->csum = csum_sub(skb->csum, 226 csum_partial(nh, (u8 *)(fhdr + 1) - nh, 227 0)); 228 } 229 230 /* Is this the final fragment? */ 231 if (!(fhdr->frag_off & htons(IP6_MF))) { 232 /* If we already have some bits beyond end 233 * or have different end, the segment is corrupted. 234 */ 235 if (end < fq->q.len || 236 ((fq->q.last_in & LAST_IN) && end != fq->q.len)) { 237 pr_debug("already received last fragment\n"); 238 goto err; 239 } 240 fq->q.last_in |= LAST_IN; 241 fq->q.len = end; 242 } else { 243 /* Check if the fragment is rounded to 8 bytes. 244 * Required by the RFC. 245 */ 246 if (end & 0x7) { 247 /* RFC2460 says always send parameter problem in 248 * this case. -DaveM 249 */ 250 pr_debug("end of fragment not rounded to 8 bytes.\n"); 251 return -1; 252 } 253 if (end > fq->q.len) { 254 /* Some bits beyond end -> corruption. */ 255 if (fq->q.last_in & LAST_IN) { 256 pr_debug("last packet already reached.\n"); 257 goto err; 258 } 259 fq->q.len = end; 260 } 261 } 262 263 if (end == offset) 264 goto err; 265 266 /* Point into the IP datagram 'data' part. */ 267 if (!pskb_pull(skb, (u8 *) (fhdr + 1) - skb->data)) { 268 pr_debug("queue: message is too short.\n"); 269 goto err; 270 } 271 if (pskb_trim_rcsum(skb, end - offset)) { 272 pr_debug("Can't trim\n"); 273 goto err; 274 } 275 276 /* Find out which fragments are in front and at the back of us 277 * in the chain of fragments so far. We must know where to put 278 * this fragment, right? 279 */ 280 prev = NULL; 281 for (next = fq->q.fragments; next != NULL; next = next->next) { 282 if (NFCT_FRAG6_CB(next)->offset >= offset) 283 break; /* bingo! */ 284 prev = next; 285 } 286 287 /* We found where to put this one. Check for overlap with 288 * preceding fragment, and, if needed, align things so that 289 * any overlaps are eliminated. 290 */ 291 if (prev) { 292 int i = (NFCT_FRAG6_CB(prev)->offset + prev->len) - offset; 293 294 if (i > 0) { 295 offset += i; 296 if (end <= offset) { 297 pr_debug("overlap\n"); 298 goto err; 299 } 300 if (!pskb_pull(skb, i)) { 301 pr_debug("Can't pull\n"); 302 goto err; 303 } 304 if (skb->ip_summed != CHECKSUM_UNNECESSARY) 305 skb->ip_summed = CHECKSUM_NONE; 306 } 307 } 308 309 /* Look for overlap with succeeding segments. 310 * If we can merge fragments, do it. 311 */ 312 while (next && NFCT_FRAG6_CB(next)->offset < end) { 313 /* overlap is 'i' bytes */ 314 int i = end - NFCT_FRAG6_CB(next)->offset; 315 316 if (i < next->len) { 317 /* Eat head of the next overlapped fragment 318 * and leave the loop. The next ones cannot overlap. 319 */ 320 pr_debug("Eat head of the overlapped parts.: %d", i); 321 if (!pskb_pull(next, i)) 322 goto err; 323 324 /* next fragment */ 325 NFCT_FRAG6_CB(next)->offset += i; 326 fq->q.meat -= i; 327 if (next->ip_summed != CHECKSUM_UNNECESSARY) 328 next->ip_summed = CHECKSUM_NONE; 329 break; 330 } else { 331 struct sk_buff *free_it = next; 332 333 /* Old fragmnet is completely overridden with 334 * new one drop it. 335 */ 336 next = next->next; 337 338 if (prev) 339 prev->next = next; 340 else 341 fq->q.fragments = next; 342 343 fq->q.meat -= free_it->len; 344 frag_kfree_skb(free_it, NULL); 345 } 346 } 347 348 NFCT_FRAG6_CB(skb)->offset = offset; 349 350 /* Insert this fragment in the chain of fragments. */ 351 skb->next = next; 352 if (prev) 353 prev->next = skb; 354 else 355 fq->q.fragments = skb; 356 357 skb->dev = NULL; 358 fq->q.stamp = skb->tstamp; 359 fq->q.meat += skb->len; 360 atomic_add(skb->truesize, &nf_frags.mem); 361 362 /* The first fragment. 363 * nhoffset is obtained from the first fragment, of course. 364 */ 365 if (offset == 0) { 366 fq->nhoffset = nhoff; 367 fq->q.last_in |= FIRST_IN; 368 } 369 write_lock(&nf_frags.lock); 370 list_move_tail(&fq->q.lru_list, &nf_frags.lru_list); 371 write_unlock(&nf_frags.lock); 372 return 0; 373 374err: 375 return -1; 376} 377 378/* 379 * Check if this packet is complete. 380 * Returns NULL on failure by any reason, and pointer 381 * to current nexthdr field in reassembled frame. 382 * 383 * It is called with locked fq, and caller must check that 384 * queue is eligible for reassembly i.e. it is not COMPLETE, 385 * the last and the first frames arrived and all the bits are here. 386 */ 387static struct sk_buff * 388nf_ct_frag6_reasm(struct nf_ct_frag6_queue *fq, struct net_device *dev) 389{ 390 struct sk_buff *fp, *op, *head = fq->q.fragments; 391 int payload_len; 392 393 fq_kill(fq); 394 395 BUG_TRAP(head != NULL); 396 BUG_TRAP(NFCT_FRAG6_CB(head)->offset == 0); 397 398 /* Unfragmented part is taken from the first segment. */ 399 payload_len = ((head->data - skb_network_header(head)) - 400 sizeof(struct ipv6hdr) + fq->q.len - 401 sizeof(struct frag_hdr)); 402 if (payload_len > IPV6_MAXPLEN) { 403 pr_debug("payload len is too large.\n"); 404 goto out_oversize; 405 } 406 407 /* Head of list must not be cloned. */ 408 if (skb_cloned(head) && pskb_expand_head(head, 0, 0, GFP_ATOMIC)) { 409 pr_debug("skb is cloned but can't expand head"); 410 goto out_oom; 411 } 412 413 /* If the first fragment is fragmented itself, we split 414 * it to two chunks: the first with data and paged part 415 * and the second, holding only fragments. */ 416 if (skb_shinfo(head)->frag_list) { 417 struct sk_buff *clone; 418 int i, plen = 0; 419 420 if ((clone = alloc_skb(0, GFP_ATOMIC)) == NULL) { 421 pr_debug("Can't alloc skb\n"); 422 goto out_oom; 423 } 424 clone->next = head->next; 425 head->next = clone; 426 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list; 427 skb_shinfo(head)->frag_list = NULL; 428 for (i=0; i<skb_shinfo(head)->nr_frags; i++) 429 plen += skb_shinfo(head)->frags[i].size; 430 clone->len = clone->data_len = head->data_len - plen; 431 head->data_len -= clone->len; 432 head->len -= clone->len; 433 clone->csum = 0; 434 clone->ip_summed = head->ip_summed; 435 436 NFCT_FRAG6_CB(clone)->orig = NULL; 437 atomic_add(clone->truesize, &nf_frags.mem); 438 } 439 440 /* We have to remove fragment header from datagram and to relocate 441 * header in order to calculate ICV correctly. */ 442 skb_network_header(head)[fq->nhoffset] = skb_transport_header(head)[0]; 443 memmove(head->head + sizeof(struct frag_hdr), head->head, 444 (head->data - head->head) - sizeof(struct frag_hdr)); 445 head->mac_header += sizeof(struct frag_hdr); 446 head->network_header += sizeof(struct frag_hdr); 447 448 skb_shinfo(head)->frag_list = head->next; 449 skb_reset_transport_header(head); 450 skb_push(head, head->data - skb_network_header(head)); 451 atomic_sub(head->truesize, &nf_frags.mem); 452 453 for (fp=head->next; fp; fp = fp->next) { 454 head->data_len += fp->len; 455 head->len += fp->len; 456 if (head->ip_summed != fp->ip_summed) 457 head->ip_summed = CHECKSUM_NONE; 458 else if (head->ip_summed == CHECKSUM_COMPLETE) 459 head->csum = csum_add(head->csum, fp->csum); 460 head->truesize += fp->truesize; 461 atomic_sub(fp->truesize, &nf_frags.mem); 462 } 463 464 head->next = NULL; 465 head->dev = dev; 466 head->tstamp = fq->q.stamp; 467 ipv6_hdr(head)->payload_len = htons(payload_len); 468 469 /* Yes, and fold redundant checksum back. 8) */ 470 if (head->ip_summed == CHECKSUM_COMPLETE) 471 head->csum = csum_partial(skb_network_header(head), 472 skb_network_header_len(head), 473 head->csum); 474 475 fq->q.fragments = NULL; 476 477 /* all original skbs are linked into the NFCT_FRAG6_CB(head).orig */ 478 fp = skb_shinfo(head)->frag_list; 479 if (NFCT_FRAG6_CB(fp)->orig == NULL) 480 /* at above code, head skb is divided into two skbs. */ 481 fp = fp->next; 482 483 op = NFCT_FRAG6_CB(head)->orig; 484 for (; fp; fp = fp->next) { 485 struct sk_buff *orig = NFCT_FRAG6_CB(fp)->orig; 486 487 op->next = orig; 488 op = orig; 489 NFCT_FRAG6_CB(fp)->orig = NULL; 490 } 491 492 return head; 493 494out_oversize: 495 if (net_ratelimit()) 496 printk(KERN_DEBUG "nf_ct_frag6_reasm: payload len = %d\n", payload_len); 497 goto out_fail; 498out_oom: 499 if (net_ratelimit()) 500 printk(KERN_DEBUG "nf_ct_frag6_reasm: no memory for reassembly\n"); 501out_fail: 502 return NULL; 503} 504 505/* 506 * find the header just before Fragment Header. 507 * 508 * if success return 0 and set ... 509 * (*prevhdrp): the value of "Next Header Field" in the header 510 * just before Fragment Header. 511 * (*prevhoff): the offset of "Next Header Field" in the header 512 * just before Fragment Header. 513 * (*fhoff) : the offset of Fragment Header. 514 * 515 * Based on ipv6_skip_hdr() in net/ipv6/exthdr.c 516 * 517 */ 518static int 519find_prev_fhdr(struct sk_buff *skb, u8 *prevhdrp, int *prevhoff, int *fhoff) 520{ 521 u8 nexthdr = ipv6_hdr(skb)->nexthdr; 522 const int netoff = skb_network_offset(skb); 523 u8 prev_nhoff = netoff + offsetof(struct ipv6hdr, nexthdr); 524 int start = netoff + sizeof(struct ipv6hdr); 525 int len = skb->len - start; 526 u8 prevhdr = NEXTHDR_IPV6; 527 528 while (nexthdr != NEXTHDR_FRAGMENT) { 529 struct ipv6_opt_hdr hdr; 530 int hdrlen; 531 532 if (!ipv6_ext_hdr(nexthdr)) { 533 return -1; 534 } 535 if (len < (int)sizeof(struct ipv6_opt_hdr)) { 536 pr_debug("too short\n"); 537 return -1; 538 } 539 if (nexthdr == NEXTHDR_NONE) { 540 pr_debug("next header is none\n"); 541 return -1; 542 } 543 if (skb_copy_bits(skb, start, &hdr, sizeof(hdr))) 544 BUG(); 545 if (nexthdr == NEXTHDR_AUTH) 546 hdrlen = (hdr.hdrlen+2)<<2; 547 else 548 hdrlen = ipv6_optlen(&hdr); 549 550 prevhdr = nexthdr; 551 prev_nhoff = start; 552 553 nexthdr = hdr.nexthdr; 554 len -= hdrlen; 555 start += hdrlen; 556 } 557 558 if (len < 0) 559 return -1; 560 561 *prevhdrp = prevhdr; 562 *prevhoff = prev_nhoff; 563 *fhoff = start; 564 565 return 0; 566} 567 568struct sk_buff *nf_ct_frag6_gather(struct sk_buff *skb) 569{ 570 struct sk_buff *clone; 571 struct net_device *dev = skb->dev; 572 struct frag_hdr *fhdr; 573 struct nf_ct_frag6_queue *fq; 574 struct ipv6hdr *hdr; 575 int fhoff, nhoff; 576 u8 prevhdr; 577 struct sk_buff *ret_skb = NULL; 578 579 /* Jumbo payload inhibits frag. header */ 580 if (ipv6_hdr(skb)->payload_len == 0) { 581 pr_debug("payload len = 0\n"); 582 return skb; 583 } 584 585 if (find_prev_fhdr(skb, &prevhdr, &nhoff, &fhoff) < 0) 586 return skb; 587 588 clone = skb_clone(skb, GFP_ATOMIC); 589 if (clone == NULL) { 590 pr_debug("Can't clone skb\n"); 591 return skb; 592 } 593 594 NFCT_FRAG6_CB(clone)->orig = skb; 595 596 if (!pskb_may_pull(clone, fhoff + sizeof(*fhdr))) { 597 pr_debug("message is too short.\n"); 598 goto ret_orig; 599 } 600 601 skb_set_transport_header(clone, fhoff); 602 hdr = ipv6_hdr(clone); 603 fhdr = (struct frag_hdr *)skb_transport_header(clone); 604 605 if (!(fhdr->frag_off & htons(0xFFF9))) { 606 pr_debug("Invalid fragment offset\n"); 607 /* It is not a fragmented frame */ 608 goto ret_orig; 609 } 610 611 if (atomic_read(&nf_frags.mem) > nf_frags_ctl.high_thresh) 612 nf_ct_frag6_evictor(); 613 614 fq = fq_find(fhdr->identification, &hdr->saddr, &hdr->daddr); 615 if (fq == NULL) { 616 pr_debug("Can't find and can't create new queue\n"); 617 goto ret_orig; 618 } 619 620 spin_lock(&fq->q.lock); 621 622 if (nf_ct_frag6_queue(fq, clone, fhdr, nhoff) < 0) { 623 spin_unlock(&fq->q.lock); 624 pr_debug("Can't insert skb to queue\n"); 625 fq_put(fq); 626 goto ret_orig; 627 } 628 629 if (fq->q.last_in == (FIRST_IN|LAST_IN) && fq->q.meat == fq->q.len) { 630 ret_skb = nf_ct_frag6_reasm(fq, dev); 631 if (ret_skb == NULL) 632 pr_debug("Can't reassemble fragmented packets\n"); 633 } 634 spin_unlock(&fq->q.lock); 635 636 fq_put(fq); 637 return ret_skb; 638 639ret_orig: 640 kfree_skb(clone); 641 return skb; 642} 643 644void nf_ct_frag6_output(unsigned int hooknum, struct sk_buff *skb, 645 struct net_device *in, struct net_device *out, 646 int (*okfn)(struct sk_buff *)) 647{ 648 struct sk_buff *s, *s2; 649 650 for (s = NFCT_FRAG6_CB(skb)->orig; s;) { 651 nf_conntrack_put_reasm(s->nfct_reasm); 652 nf_conntrack_get_reasm(skb); 653 s->nfct_reasm = skb; 654 655 s2 = s->next; 656 s->next = NULL; 657 658 NF_HOOK_THRESH(PF_INET6, hooknum, s, in, out, okfn, 659 NF_IP6_PRI_CONNTRACK_DEFRAG + 1); 660 s = s2; 661 } 662 nf_conntrack_put_reasm(skb); 663} 664 665int nf_ct_frag6_kfree_frags(struct sk_buff *skb) 666{ 667 struct sk_buff *s, *s2; 668 669 for (s = NFCT_FRAG6_CB(skb)->orig; s; s = s2) { 670 671 s2 = s->next; 672 kfree_skb(s); 673 } 674 675 kfree_skb(skb); 676 677 return 0; 678} 679 680int nf_ct_frag6_init(void) 681{ 682 nf_frags.ctl = &nf_frags_ctl; 683 nf_frags.hashfn = nf_hashfn; 684 nf_frags.constructor = ip6_frag_init; 685 nf_frags.destructor = nf_frag_free; 686 nf_frags.skb_free = nf_skb_free; 687 nf_frags.qsize = sizeof(struct nf_ct_frag6_queue); 688 nf_frags.match = ip6_frag_match; 689 nf_frags.equal = ip6_frag_equal; 690 nf_frags.frag_expire = nf_ct_frag6_expire; 691 inet_frags_init(&nf_frags); 692 693 return 0; 694} 695 696void nf_ct_frag6_cleanup(void) 697{ 698 inet_frags_fini(&nf_frags); 699 700 nf_frags_ctl.low_thresh = 0; 701 nf_ct_frag6_evictor(); 702} 703