1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * INET An implementation of the TCP/IP protocol suite for the LINUX 4 * operating system. INET is implemented using the BSD Socket 5 * interface as the means of communication with the user level. 6 * 7 * The IP fragmentation functionality. 8 * 9 * Authors: Fred N. van Kempen <waltje@uWalt.NL.Mugnet.ORG> 10 * Alan Cox <alan@lxorguk.ukuu.org.uk> 11 * 12 * Fixes: 13 * Alan Cox : Split from ip.c , see ip_input.c for history. 14 * David S. Miller : Begin massive cleanup... 15 * Andi Kleen : Add sysctls. 16 * xxxx : Overlapfrag bug. 17 * Ultima : ip_expire() kernel panic. 18 * Bill Hawes : Frag accounting and evictor fixes. 19 * John McDonald : 0 length frag bug. 20 * Alexey Kuznetsov: SMP races, threading, cleanup. 21 * Patrick McHardy : LRU queue of frag heads for evictor. 22 */ 23 24 #define pr_fmt(fmt) "IPv4: " fmt 25 26 #include <linux/compiler.h> 27 #include <linux/module.h> 28 #include <linux/types.h> 29 #include <linux/mm.h> 30 #include <linux/jiffies.h> 31 #include <linux/skbuff.h> 32 #include <linux/list.h> 33 #include <linux/ip.h> 34 #include <linux/icmp.h> 35 #include <linux/netdevice.h> 36 #include <linux/jhash.h> 37 #include <linux/random.h> 38 #include <linux/slab.h> 39 #include <net/route.h> 40 #include <net/dst.h> 41 #include <net/sock.h> 42 #include <net/ip.h> 43 #include <net/icmp.h> 44 #include <net/checksum.h> 45 #include <net/inetpeer.h> 46 #include <net/inet_frag.h> 47 #include <linux/tcp.h> 48 #include <linux/udp.h> 49 #include <linux/inet.h> 50 #include <linux/netfilter_ipv4.h> 51 #include <net/inet_ecn.h> 52 #include <net/l3mdev.h> 53 54 /* NOTE. Logic of IP defragmentation is parallel to corresponding IPv6 55 * code now. If you change something here, _PLEASE_ update ipv6/reassembly.c 56 * as well. Or notify me, at least. --ANK 57 */ 58 static const char ip_frag_cache_name[] = "ip4-frags"; 59 60 /* Use skb->cb to track consecutive/adjacent fragments coming at 61 * the end of the queue. Nodes in the rb-tree queue will 62 * contain "runs" of one or more adjacent fragments. 63 * 64 * Invariants: 65 * - next_frag is NULL at the tail of a "run"; 66 * - the head of a "run" has the sum of all fragment lengths in frag_run_len. 67 */ 68 struct ipfrag_skb_cb { 69 struct inet_skb_parm h; 70 struct sk_buff *next_frag; 71 int frag_run_len; 72 }; 73 74 #define FRAG_CB(skb) ((struct ipfrag_skb_cb *)((skb)->cb)) 75 76 static void ip4_frag_init_run(struct sk_buff *skb) 77 { 78 BUILD_BUG_ON(sizeof(struct ipfrag_skb_cb) > sizeof(skb->cb)); 79 80 FRAG_CB(skb)->next_frag = NULL; 81 FRAG_CB(skb)->frag_run_len = skb->len; 82 } 83 84 /* Append skb to the last "run". */ 85 static void ip4_frag_append_to_last_run(struct inet_frag_queue *q, 86 struct sk_buff *skb) 87 { 88 RB_CLEAR_NODE(&skb->rbnode); 89 FRAG_CB(skb)->next_frag = NULL; 90 91 FRAG_CB(q->last_run_head)->frag_run_len += skb->len; 92 FRAG_CB(q->fragments_tail)->next_frag = skb; 93 q->fragments_tail = skb; 94 } 95 96 /* Create a new "run" with the skb. */ 97 static void ip4_frag_create_run(struct inet_frag_queue *q, struct sk_buff *skb) 98 { 99 if (q->last_run_head) 100 rb_link_node(&skb->rbnode, &q->last_run_head->rbnode, 101 &q->last_run_head->rbnode.rb_right); 102 else 103 rb_link_node(&skb->rbnode, NULL, &q->rb_fragments.rb_node); 104 rb_insert_color(&skb->rbnode, &q->rb_fragments); 105 106 ip4_frag_init_run(skb); 107 q->fragments_tail = skb; 108 q->last_run_head = skb; 109 } 110 111 /* Describe an entry in the "incomplete datagrams" queue. */ 112 struct ipq { 113 struct inet_frag_queue q; 114 115 u8 ecn; /* RFC3168 support */ 116 u16 max_df_size; /* largest frag with DF set seen */ 117 int iif; 118 unsigned int rid; 119 struct inet_peer *peer; 120 }; 121 122 static u8 ip4_frag_ecn(u8 tos) 123 { 124 return 1 << (tos & INET_ECN_MASK); 125 } 126 127 static struct inet_frags ip4_frags; 128 129 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb, 130 struct sk_buff *prev_tail, struct net_device *dev); 131 132 133 static void ip4_frag_init(struct inet_frag_queue *q, const void *a) 134 { 135 struct ipq *qp = container_of(q, struct ipq, q); 136 struct netns_ipv4 *ipv4 = container_of(q->net, struct netns_ipv4, 137 frags); 138 struct net *net = container_of(ipv4, struct net, ipv4); 139 140 const struct frag_v4_compare_key *key = a; 141 142 q->key.v4 = *key; 143 qp->ecn = 0; 144 qp->peer = q->net->max_dist ? 145 inet_getpeer_v4(net->ipv4.peers, key->saddr, key->vif, 1) : 146 NULL; 147 } 148 149 static void ip4_frag_free(struct inet_frag_queue *q) 150 { 151 struct ipq *qp; 152 153 qp = container_of(q, struct ipq, q); 154 if (qp->peer) 155 inet_putpeer(qp->peer); 156 } 157 158 159 /* Destruction primitives. */ 160 161 static void ipq_put(struct ipq *ipq) 162 { 163 inet_frag_put(&ipq->q); 164 } 165 166 /* Kill ipq entry. It is not destroyed immediately, 167 * because caller (and someone more) holds reference count. 168 */ 169 static void ipq_kill(struct ipq *ipq) 170 { 171 inet_frag_kill(&ipq->q); 172 } 173 174 static bool frag_expire_skip_icmp(u32 user) 175 { 176 return user == IP_DEFRAG_AF_PACKET || 177 ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_IN, 178 __IP_DEFRAG_CONNTRACK_IN_END) || 179 ip_defrag_user_in_between(user, IP_DEFRAG_CONNTRACK_BRIDGE_IN, 180 __IP_DEFRAG_CONNTRACK_BRIDGE_IN); 181 } 182 183 /* 184 * Oops, a fragment queue timed out. Kill it and send an ICMP reply. 185 */ 186 static void ip_expire(struct timer_list *t) 187 { 188 struct inet_frag_queue *frag = from_timer(frag, t, timer); 189 const struct iphdr *iph; 190 struct sk_buff *head = NULL; 191 struct net *net; 192 struct ipq *qp; 193 int err; 194 195 qp = container_of(frag, struct ipq, q); 196 net = container_of(qp->q.net, struct net, ipv4.frags); 197 198 rcu_read_lock(); 199 spin_lock(&qp->q.lock); 200 201 if (qp->q.flags & INET_FRAG_COMPLETE) 202 goto out; 203 204 ipq_kill(qp); 205 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 206 __IP_INC_STATS(net, IPSTATS_MIB_REASMTIMEOUT); 207 208 if (!(qp->q.flags & INET_FRAG_FIRST_IN)) 209 goto out; 210 211 /* sk_buff::dev and sk_buff::rbnode are unionized. So we 212 * pull the head out of the tree in order to be able to 213 * deal with head->dev. 214 */ 215 if (qp->q.fragments) { 216 head = qp->q.fragments; 217 qp->q.fragments = head->next; 218 } else { 219 head = skb_rb_first(&qp->q.rb_fragments); 220 if (!head) 221 goto out; 222 if (FRAG_CB(head)->next_frag) 223 rb_replace_node(&head->rbnode, 224 &FRAG_CB(head)->next_frag->rbnode, 225 &qp->q.rb_fragments); 226 else 227 rb_erase(&head->rbnode, &qp->q.rb_fragments); 228 memset(&head->rbnode, 0, sizeof(head->rbnode)); 229 barrier(); 230 } 231 if (head == qp->q.fragments_tail) 232 qp->q.fragments_tail = NULL; 233 234 sub_frag_mem_limit(qp->q.net, head->truesize); 235 236 head->dev = dev_get_by_index_rcu(net, qp->iif); 237 if (!head->dev) 238 goto out; 239 240 241 /* skb has no dst, perform route lookup again */ 242 iph = ip_hdr(head); 243 err = ip_route_input_noref(head, iph->daddr, iph->saddr, 244 iph->tos, head->dev); 245 if (err) 246 goto out; 247 248 /* Only an end host needs to send an ICMP 249 * "Fragment Reassembly Timeout" message, per RFC792. 250 */ 251 if (frag_expire_skip_icmp(qp->q.key.v4.user) && 252 (skb_rtable(head)->rt_type != RTN_LOCAL)) 253 goto out; 254 255 spin_unlock(&qp->q.lock); 256 icmp_send(head, ICMP_TIME_EXCEEDED, ICMP_EXC_FRAGTIME, 0); 257 goto out_rcu_unlock; 258 259 out: 260 spin_unlock(&qp->q.lock); 261 out_rcu_unlock: 262 rcu_read_unlock(); 263 if (head) 264 kfree_skb(head); 265 ipq_put(qp); 266 } 267 268 /* Find the correct entry in the "incomplete datagrams" queue for 269 * this IP datagram, and create new one, if nothing is found. 270 */ 271 static struct ipq *ip_find(struct net *net, struct iphdr *iph, 272 u32 user, int vif) 273 { 274 struct frag_v4_compare_key key = { 275 .saddr = iph->saddr, 276 .daddr = iph->daddr, 277 .user = user, 278 .vif = vif, 279 .id = iph->id, 280 .protocol = iph->protocol, 281 }; 282 struct inet_frag_queue *q; 283 284 q = inet_frag_find(&net->ipv4.frags, &key); 285 if (!q) 286 return NULL; 287 288 return container_of(q, struct ipq, q); 289 } 290 291 /* Is the fragment too far ahead to be part of ipq? */ 292 static int ip_frag_too_far(struct ipq *qp) 293 { 294 struct inet_peer *peer = qp->peer; 295 unsigned int max = qp->q.net->max_dist; 296 unsigned int start, end; 297 298 int rc; 299 300 if (!peer || !max) 301 return 0; 302 303 start = qp->rid; 304 end = atomic_inc_return(&peer->rid); 305 qp->rid = end; 306 307 rc = qp->q.fragments_tail && (end - start) > max; 308 309 if (rc) { 310 struct net *net; 311 312 net = container_of(qp->q.net, struct net, ipv4.frags); 313 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 314 } 315 316 return rc; 317 } 318 319 static int ip_frag_reinit(struct ipq *qp) 320 { 321 unsigned int sum_truesize = 0; 322 323 if (!mod_timer(&qp->q.timer, jiffies + qp->q.net->timeout)) { 324 refcount_inc(&qp->q.refcnt); 325 return -ETIMEDOUT; 326 } 327 328 sum_truesize = inet_frag_rbtree_purge(&qp->q.rb_fragments); 329 sub_frag_mem_limit(qp->q.net, sum_truesize); 330 331 qp->q.flags = 0; 332 qp->q.len = 0; 333 qp->q.meat = 0; 334 qp->q.fragments = NULL; 335 qp->q.rb_fragments = RB_ROOT; 336 qp->q.fragments_tail = NULL; 337 qp->q.last_run_head = NULL; 338 qp->iif = 0; 339 qp->ecn = 0; 340 341 return 0; 342 } 343 344 /* Add new segment to existing queue. */ 345 static int ip_frag_queue(struct ipq *qp, struct sk_buff *skb) 346 { 347 struct net *net = container_of(qp->q.net, struct net, ipv4.frags); 348 struct rb_node **rbn, *parent; 349 struct sk_buff *skb1, *prev_tail; 350 struct net_device *dev; 351 unsigned int fragsize; 352 int flags, offset; 353 int ihl, end; 354 int err = -ENOENT; 355 u8 ecn; 356 357 if (qp->q.flags & INET_FRAG_COMPLETE) 358 goto err; 359 360 if (!(IPCB(skb)->flags & IPSKB_FRAG_COMPLETE) && 361 unlikely(ip_frag_too_far(qp)) && 362 unlikely(err = ip_frag_reinit(qp))) { 363 ipq_kill(qp); 364 goto err; 365 } 366 367 ecn = ip4_frag_ecn(ip_hdr(skb)->tos); 368 offset = ntohs(ip_hdr(skb)->frag_off); 369 flags = offset & ~IP_OFFSET; 370 offset &= IP_OFFSET; 371 offset <<= 3; /* offset is in 8-byte chunks */ 372 ihl = ip_hdrlen(skb); 373 374 /* Determine the position of this fragment. */ 375 end = offset + skb->len - skb_network_offset(skb) - ihl; 376 err = -EINVAL; 377 378 /* Is this the final fragment? */ 379 if ((flags & IP_MF) == 0) { 380 /* If we already have some bits beyond end 381 * or have different end, the segment is corrupted. 382 */ 383 if (end < qp->q.len || 384 ((qp->q.flags & INET_FRAG_LAST_IN) && end != qp->q.len)) 385 goto discard_qp; 386 qp->q.flags |= INET_FRAG_LAST_IN; 387 qp->q.len = end; 388 } else { 389 if (end&7) { 390 end &= ~7; 391 if (skb->ip_summed != CHECKSUM_UNNECESSARY) 392 skb->ip_summed = CHECKSUM_NONE; 393 } 394 if (end > qp->q.len) { 395 /* Some bits beyond end -> corruption. */ 396 if (qp->q.flags & INET_FRAG_LAST_IN) 397 goto discard_qp; 398 qp->q.len = end; 399 } 400 } 401 if (end == offset) 402 goto discard_qp; 403 404 err = -ENOMEM; 405 if (!pskb_pull(skb, skb_network_offset(skb) + ihl)) 406 goto discard_qp; 407 408 err = pskb_trim_rcsum(skb, end - offset); 409 if (err) 410 goto discard_qp; 411 412 /* Note : skb->rbnode and skb->dev share the same location. */ 413 dev = skb->dev; 414 /* Makes sure compiler wont do silly aliasing games */ 415 barrier(); 416 417 /* RFC5722, Section 4, amended by Errata ID : 3089 418 * When reassembling an IPv6 datagram, if 419 * one or more its constituent fragments is determined to be an 420 * overlapping fragment, the entire datagram (and any constituent 421 * fragments) MUST be silently discarded. 422 * 423 * We do the same here for IPv4 (and increment an snmp counter). 424 */ 425 426 err = -EINVAL; 427 /* Find out where to put this fragment. */ 428 prev_tail = qp->q.fragments_tail; 429 if (!prev_tail) 430 ip4_frag_create_run(&qp->q, skb); /* First fragment. */ 431 else if (prev_tail->ip_defrag_offset + prev_tail->len < end) { 432 /* This is the common case: skb goes to the end. */ 433 /* Detect and discard overlaps. */ 434 if (offset < prev_tail->ip_defrag_offset + prev_tail->len) 435 goto overlap; 436 if (offset == prev_tail->ip_defrag_offset + prev_tail->len) 437 ip4_frag_append_to_last_run(&qp->q, skb); 438 else 439 ip4_frag_create_run(&qp->q, skb); 440 } else { 441 /* Binary search. Note that skb can become the first fragment, 442 * but not the last (covered above). 443 */ 444 rbn = &qp->q.rb_fragments.rb_node; 445 do { 446 parent = *rbn; 447 skb1 = rb_to_skb(parent); 448 if (end <= skb1->ip_defrag_offset) 449 rbn = &parent->rb_left; 450 else if (offset >= skb1->ip_defrag_offset + 451 FRAG_CB(skb1)->frag_run_len) 452 rbn = &parent->rb_right; 453 else /* Found an overlap with skb1. */ 454 goto overlap; 455 } while (*rbn); 456 /* Here we have parent properly set, and rbn pointing to 457 * one of its NULL left/right children. Insert skb. 458 */ 459 ip4_frag_init_run(skb); 460 rb_link_node(&skb->rbnode, parent, rbn); 461 rb_insert_color(&skb->rbnode, &qp->q.rb_fragments); 462 } 463 464 if (dev) 465 qp->iif = dev->ifindex; 466 skb->ip_defrag_offset = offset; 467 468 qp->q.stamp = skb->tstamp; 469 qp->q.meat += skb->len; 470 qp->ecn |= ecn; 471 add_frag_mem_limit(qp->q.net, skb->truesize); 472 if (offset == 0) 473 qp->q.flags |= INET_FRAG_FIRST_IN; 474 475 fragsize = skb->len + ihl; 476 477 if (fragsize > qp->q.max_size) 478 qp->q.max_size = fragsize; 479 480 if (ip_hdr(skb)->frag_off & htons(IP_DF) && 481 fragsize > qp->max_df_size) 482 qp->max_df_size = fragsize; 483 484 if (qp->q.flags == (INET_FRAG_FIRST_IN | INET_FRAG_LAST_IN) && 485 qp->q.meat == qp->q.len) { 486 unsigned long orefdst = skb->_skb_refdst; 487 488 skb->_skb_refdst = 0UL; 489 err = ip_frag_reasm(qp, skb, prev_tail, dev); 490 skb->_skb_refdst = orefdst; 491 if (err) 492 inet_frag_kill(&qp->q); 493 return err; 494 } 495 496 skb_dst_drop(skb); 497 return -EINPROGRESS; 498 499 overlap: 500 __IP_INC_STATS(net, IPSTATS_MIB_REASM_OVERLAPS); 501 discard_qp: 502 inet_frag_kill(&qp->q); 503 err: 504 kfree_skb(skb); 505 return err; 506 } 507 508 /* Build a new IP datagram from all its fragments. */ 509 static int ip_frag_reasm(struct ipq *qp, struct sk_buff *skb, 510 struct sk_buff *prev_tail, struct net_device *dev) 511 { 512 struct net *net = container_of(qp->q.net, struct net, ipv4.frags); 513 struct iphdr *iph; 514 struct sk_buff *fp, *head = skb_rb_first(&qp->q.rb_fragments); 515 struct sk_buff **nextp; /* To build frag_list. */ 516 struct rb_node *rbn; 517 int len; 518 int ihlen; 519 int err; 520 u8 ecn; 521 522 ipq_kill(qp); 523 524 ecn = ip_frag_ecn_table[qp->ecn]; 525 if (unlikely(ecn == 0xff)) { 526 err = -EINVAL; 527 goto out_fail; 528 } 529 /* Make the one we just received the head. */ 530 if (head != skb) { 531 fp = skb_clone(skb, GFP_ATOMIC); 532 if (!fp) 533 goto out_nomem; 534 FRAG_CB(fp)->next_frag = FRAG_CB(skb)->next_frag; 535 if (RB_EMPTY_NODE(&skb->rbnode)) 536 FRAG_CB(prev_tail)->next_frag = fp; 537 else 538 rb_replace_node(&skb->rbnode, &fp->rbnode, 539 &qp->q.rb_fragments); 540 if (qp->q.fragments_tail == skb) 541 qp->q.fragments_tail = fp; 542 skb_morph(skb, head); 543 FRAG_CB(skb)->next_frag = FRAG_CB(head)->next_frag; 544 rb_replace_node(&head->rbnode, &skb->rbnode, 545 &qp->q.rb_fragments); 546 consume_skb(head); 547 head = skb; 548 } 549 550 WARN_ON(head->ip_defrag_offset != 0); 551 552 /* Allocate a new buffer for the datagram. */ 553 ihlen = ip_hdrlen(head); 554 len = ihlen + qp->q.len; 555 556 err = -E2BIG; 557 if (len > 65535) 558 goto out_oversize; 559 560 /* Head of list must not be cloned. */ 561 if (skb_unclone(head, GFP_ATOMIC)) 562 goto out_nomem; 563 564 /* If the first fragment is fragmented itself, we split 565 * it to two chunks: the first with data and paged part 566 * and the second, holding only fragments. */ 567 if (skb_has_frag_list(head)) { 568 struct sk_buff *clone; 569 int i, plen = 0; 570 571 clone = alloc_skb(0, GFP_ATOMIC); 572 if (!clone) 573 goto out_nomem; 574 skb_shinfo(clone)->frag_list = skb_shinfo(head)->frag_list; 575 skb_frag_list_init(head); 576 for (i = 0; i < skb_shinfo(head)->nr_frags; i++) 577 plen += skb_frag_size(&skb_shinfo(head)->frags[i]); 578 clone->len = clone->data_len = head->data_len - plen; 579 head->truesize += clone->truesize; 580 clone->csum = 0; 581 clone->ip_summed = head->ip_summed; 582 add_frag_mem_limit(qp->q.net, clone->truesize); 583 skb_shinfo(head)->frag_list = clone; 584 nextp = &clone->next; 585 } else { 586 nextp = &skb_shinfo(head)->frag_list; 587 } 588 589 skb_push(head, head->data - skb_network_header(head)); 590 591 /* Traverse the tree in order, to build frag_list. */ 592 fp = FRAG_CB(head)->next_frag; 593 rbn = rb_next(&head->rbnode); 594 rb_erase(&head->rbnode, &qp->q.rb_fragments); 595 while (rbn || fp) { 596 /* fp points to the next sk_buff in the current run; 597 * rbn points to the next run. 598 */ 599 /* Go through the current run. */ 600 while (fp) { 601 *nextp = fp; 602 nextp = &fp->next; 603 fp->prev = NULL; 604 memset(&fp->rbnode, 0, sizeof(fp->rbnode)); 605 head->data_len += fp->len; 606 head->len += fp->len; 607 if (head->ip_summed != fp->ip_summed) 608 head->ip_summed = CHECKSUM_NONE; 609 else if (head->ip_summed == CHECKSUM_COMPLETE) 610 head->csum = csum_add(head->csum, fp->csum); 611 head->truesize += fp->truesize; 612 fp = FRAG_CB(fp)->next_frag; 613 } 614 /* Move to the next run. */ 615 if (rbn) { 616 struct rb_node *rbnext = rb_next(rbn); 617 618 fp = rb_to_skb(rbn); 619 rb_erase(rbn, &qp->q.rb_fragments); 620 rbn = rbnext; 621 } 622 } 623 sub_frag_mem_limit(qp->q.net, head->truesize); 624 625 *nextp = NULL; 626 head->next = NULL; 627 head->prev = NULL; 628 head->dev = dev; 629 head->tstamp = qp->q.stamp; 630 IPCB(head)->frag_max_size = max(qp->max_df_size, qp->q.max_size); 631 632 iph = ip_hdr(head); 633 iph->tot_len = htons(len); 634 iph->tos |= ecn; 635 636 /* When we set IP_DF on a refragmented skb we must also force a 637 * call to ip_fragment to avoid forwarding a DF-skb of size s while 638 * original sender only sent fragments of size f (where f < s). 639 * 640 * We only set DF/IPSKB_FRAG_PMTU if such DF fragment was the largest 641 * frag seen to avoid sending tiny DF-fragments in case skb was built 642 * from one very small df-fragment and one large non-df frag. 643 */ 644 if (qp->max_df_size == qp->q.max_size) { 645 IPCB(head)->flags |= IPSKB_FRAG_PMTU; 646 iph->frag_off = htons(IP_DF); 647 } else { 648 iph->frag_off = 0; 649 } 650 651 ip_send_check(iph); 652 653 __IP_INC_STATS(net, IPSTATS_MIB_REASMOKS); 654 qp->q.fragments = NULL; 655 qp->q.rb_fragments = RB_ROOT; 656 qp->q.fragments_tail = NULL; 657 qp->q.last_run_head = NULL; 658 return 0; 659 660 out_nomem: 661 net_dbg_ratelimited("queue_glue: no memory for gluing queue %p\n", qp); 662 err = -ENOMEM; 663 goto out_fail; 664 out_oversize: 665 net_info_ratelimited("Oversized IP packet from %pI4\n", &qp->q.key.v4.saddr); 666 out_fail: 667 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 668 return err; 669 } 670 671 /* Process an incoming IP datagram fragment. */ 672 int ip_defrag(struct net *net, struct sk_buff *skb, u32 user) 673 { 674 struct net_device *dev = skb->dev ? : skb_dst(skb)->dev; 675 int vif = l3mdev_master_ifindex_rcu(dev); 676 struct ipq *qp; 677 678 __IP_INC_STATS(net, IPSTATS_MIB_REASMREQDS); 679 skb_orphan(skb); 680 681 /* Lookup (or create) queue header */ 682 qp = ip_find(net, ip_hdr(skb), user, vif); 683 if (qp) { 684 int ret; 685 686 spin_lock(&qp->q.lock); 687 688 ret = ip_frag_queue(qp, skb); 689 690 spin_unlock(&qp->q.lock); 691 ipq_put(qp); 692 return ret; 693 } 694 695 __IP_INC_STATS(net, IPSTATS_MIB_REASMFAILS); 696 kfree_skb(skb); 697 return -ENOMEM; 698 } 699 EXPORT_SYMBOL(ip_defrag); 700 701 struct sk_buff *ip_check_defrag(struct net *net, struct sk_buff *skb, u32 user) 702 { 703 struct iphdr iph; 704 int netoff; 705 u32 len; 706 707 if (skb->protocol != htons(ETH_P_IP)) 708 return skb; 709 710 netoff = skb_network_offset(skb); 711 712 if (skb_copy_bits(skb, netoff, &iph, sizeof(iph)) < 0) 713 return skb; 714 715 if (iph.ihl < 5 || iph.version != 4) 716 return skb; 717 718 len = ntohs(iph.tot_len); 719 if (skb->len < netoff + len || len < (iph.ihl * 4)) 720 return skb; 721 722 if (ip_is_fragment(&iph)) { 723 skb = skb_share_check(skb, GFP_ATOMIC); 724 if (skb) { 725 if (!pskb_may_pull(skb, netoff + iph.ihl * 4)) 726 return skb; 727 if (pskb_trim_rcsum(skb, netoff + len)) 728 return skb; 729 memset(IPCB(skb), 0, sizeof(struct inet_skb_parm)); 730 if (ip_defrag(net, skb, user)) 731 return NULL; 732 skb_clear_hash(skb); 733 } 734 } 735 return skb; 736 } 737 EXPORT_SYMBOL(ip_check_defrag); 738 739 unsigned int inet_frag_rbtree_purge(struct rb_root *root) 740 { 741 struct rb_node *p = rb_first(root); 742 unsigned int sum = 0; 743 744 while (p) { 745 struct sk_buff *skb = rb_entry(p, struct sk_buff, rbnode); 746 747 p = rb_next(p); 748 rb_erase(&skb->rbnode, root); 749 while (skb) { 750 struct sk_buff *next = FRAG_CB(skb)->next_frag; 751 752 sum += skb->truesize; 753 kfree_skb(skb); 754 skb = next; 755 } 756 } 757 return sum; 758 } 759 EXPORT_SYMBOL(inet_frag_rbtree_purge); 760 761 #ifdef CONFIG_SYSCTL 762 static int dist_min; 763 764 static struct ctl_table ip4_frags_ns_ctl_table[] = { 765 { 766 .procname = "ipfrag_high_thresh", 767 .data = &init_net.ipv4.frags.high_thresh, 768 .maxlen = sizeof(unsigned long), 769 .mode = 0644, 770 .proc_handler = proc_doulongvec_minmax, 771 .extra1 = &init_net.ipv4.frags.low_thresh 772 }, 773 { 774 .procname = "ipfrag_low_thresh", 775 .data = &init_net.ipv4.frags.low_thresh, 776 .maxlen = sizeof(unsigned long), 777 .mode = 0644, 778 .proc_handler = proc_doulongvec_minmax, 779 .extra2 = &init_net.ipv4.frags.high_thresh 780 }, 781 { 782 .procname = "ipfrag_time", 783 .data = &init_net.ipv4.frags.timeout, 784 .maxlen = sizeof(int), 785 .mode = 0644, 786 .proc_handler = proc_dointvec_jiffies, 787 }, 788 { 789 .procname = "ipfrag_max_dist", 790 .data = &init_net.ipv4.frags.max_dist, 791 .maxlen = sizeof(int), 792 .mode = 0644, 793 .proc_handler = proc_dointvec_minmax, 794 .extra1 = &dist_min, 795 }, 796 { } 797 }; 798 799 /* secret interval has been deprecated */ 800 static int ip4_frags_secret_interval_unused; 801 static struct ctl_table ip4_frags_ctl_table[] = { 802 { 803 .procname = "ipfrag_secret_interval", 804 .data = &ip4_frags_secret_interval_unused, 805 .maxlen = sizeof(int), 806 .mode = 0644, 807 .proc_handler = proc_dointvec_jiffies, 808 }, 809 { } 810 }; 811 812 static int __net_init ip4_frags_ns_ctl_register(struct net *net) 813 { 814 struct ctl_table *table; 815 struct ctl_table_header *hdr; 816 817 table = ip4_frags_ns_ctl_table; 818 if (!net_eq(net, &init_net)) { 819 table = kmemdup(table, sizeof(ip4_frags_ns_ctl_table), GFP_KERNEL); 820 if (!table) 821 goto err_alloc; 822 823 table[0].data = &net->ipv4.frags.high_thresh; 824 table[0].extra1 = &net->ipv4.frags.low_thresh; 825 table[0].extra2 = &init_net.ipv4.frags.high_thresh; 826 table[1].data = &net->ipv4.frags.low_thresh; 827 table[1].extra2 = &net->ipv4.frags.high_thresh; 828 table[2].data = &net->ipv4.frags.timeout; 829 table[3].data = &net->ipv4.frags.max_dist; 830 } 831 832 hdr = register_net_sysctl(net, "net/ipv4", table); 833 if (!hdr) 834 goto err_reg; 835 836 net->ipv4.frags_hdr = hdr; 837 return 0; 838 839 err_reg: 840 if (!net_eq(net, &init_net)) 841 kfree(table); 842 err_alloc: 843 return -ENOMEM; 844 } 845 846 static void __net_exit ip4_frags_ns_ctl_unregister(struct net *net) 847 { 848 struct ctl_table *table; 849 850 table = net->ipv4.frags_hdr->ctl_table_arg; 851 unregister_net_sysctl_table(net->ipv4.frags_hdr); 852 kfree(table); 853 } 854 855 static void __init ip4_frags_ctl_register(void) 856 { 857 register_net_sysctl(&init_net, "net/ipv4", ip4_frags_ctl_table); 858 } 859 #else 860 static int ip4_frags_ns_ctl_register(struct net *net) 861 { 862 return 0; 863 } 864 865 static void ip4_frags_ns_ctl_unregister(struct net *net) 866 { 867 } 868 869 static void __init ip4_frags_ctl_register(void) 870 { 871 } 872 #endif 873 874 static int __net_init ipv4_frags_init_net(struct net *net) 875 { 876 int res; 877 878 /* Fragment cache limits. 879 * 880 * The fragment memory accounting code, (tries to) account for 881 * the real memory usage, by measuring both the size of frag 882 * queue struct (inet_frag_queue (ipv4:ipq/ipv6:frag_queue)) 883 * and the SKB's truesize. 884 * 885 * A 64K fragment consumes 129736 bytes (44*2944)+200 886 * (1500 truesize == 2944, sizeof(struct ipq) == 200) 887 * 888 * We will commit 4MB at one time. Should we cross that limit 889 * we will prune down to 3MB, making room for approx 8 big 64K 890 * fragments 8x128k. 891 */ 892 net->ipv4.frags.high_thresh = 4 * 1024 * 1024; 893 net->ipv4.frags.low_thresh = 3 * 1024 * 1024; 894 /* 895 * Important NOTE! Fragment queue must be destroyed before MSL expires. 896 * RFC791 is wrong proposing to prolongate timer each fragment arrival 897 * by TTL. 898 */ 899 net->ipv4.frags.timeout = IP_FRAG_TIME; 900 901 net->ipv4.frags.max_dist = 64; 902 net->ipv4.frags.f = &ip4_frags; 903 904 res = inet_frags_init_net(&net->ipv4.frags); 905 if (res < 0) 906 return res; 907 res = ip4_frags_ns_ctl_register(net); 908 if (res < 0) 909 inet_frags_exit_net(&net->ipv4.frags); 910 return res; 911 } 912 913 static void __net_exit ipv4_frags_exit_net(struct net *net) 914 { 915 ip4_frags_ns_ctl_unregister(net); 916 inet_frags_exit_net(&net->ipv4.frags); 917 } 918 919 static struct pernet_operations ip4_frags_ops = { 920 .init = ipv4_frags_init_net, 921 .exit = ipv4_frags_exit_net, 922 }; 923 924 925 static u32 ip4_key_hashfn(const void *data, u32 len, u32 seed) 926 { 927 return jhash2(data, 928 sizeof(struct frag_v4_compare_key) / sizeof(u32), seed); 929 } 930 931 static u32 ip4_obj_hashfn(const void *data, u32 len, u32 seed) 932 { 933 const struct inet_frag_queue *fq = data; 934 935 return jhash2((const u32 *)&fq->key.v4, 936 sizeof(struct frag_v4_compare_key) / sizeof(u32), seed); 937 } 938 939 static int ip4_obj_cmpfn(struct rhashtable_compare_arg *arg, const void *ptr) 940 { 941 const struct frag_v4_compare_key *key = arg->key; 942 const struct inet_frag_queue *fq = ptr; 943 944 return !!memcmp(&fq->key, key, sizeof(*key)); 945 } 946 947 static const struct rhashtable_params ip4_rhash_params = { 948 .head_offset = offsetof(struct inet_frag_queue, node), 949 .key_offset = offsetof(struct inet_frag_queue, key), 950 .key_len = sizeof(struct frag_v4_compare_key), 951 .hashfn = ip4_key_hashfn, 952 .obj_hashfn = ip4_obj_hashfn, 953 .obj_cmpfn = ip4_obj_cmpfn, 954 .automatic_shrinking = true, 955 }; 956 957 void __init ipfrag_init(void) 958 { 959 ip4_frags.constructor = ip4_frag_init; 960 ip4_frags.destructor = ip4_frag_free; 961 ip4_frags.qsize = sizeof(struct ipq); 962 ip4_frags.frag_expire = ip_expire; 963 ip4_frags.frags_cache_name = ip_frag_cache_name; 964 ip4_frags.rhash_params = ip4_rhash_params; 965 if (inet_frags_init(&ip4_frags)) 966 panic("IP: failed to allocate ip4_frags cache\n"); 967 ip4_frags_ctl_register(); 968 register_pernet_subsys(&ip4_frags_ops); 969 } 970