1 /* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * ROUTE - implementation of the IP router. 7 * 8 * Version: $Id: route.c,v 1.103 2002/01/12 07:44:09 davem Exp $ 9 * 10 * Authors: Ross Biro 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 12 * Alan Cox, <gw4pts@gw4pts.ampr.org> 13 * Linus Torvalds, <Linus.Torvalds@helsinki.fi> 14 * Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 15 * 16 * Fixes: 17 * Alan Cox : Verify area fixes. 18 * Alan Cox : cli() protects routing changes 19 * Rui Oliveira : ICMP routing table updates 20 * (rco@di.uminho.pt) Routing table insertion and update 21 * Linus Torvalds : Rewrote bits to be sensible 22 * Alan Cox : Added BSD route gw semantics 23 * Alan Cox : Super /proc >4K 24 * Alan Cox : MTU in route table 25 * Alan Cox : MSS actually. Also added the window 26 * clamper. 27 * Sam Lantinga : Fixed route matching in rt_del() 28 * Alan Cox : Routing cache support. 29 * Alan Cox : Removed compatibility cruft. 30 * Alan Cox : RTF_REJECT support. 31 * Alan Cox : TCP irtt support. 32 * Jonathan Naylor : Added Metric support. 33 * Miquel van Smoorenburg : BSD API fixes. 34 * Miquel van Smoorenburg : Metrics. 35 * Alan Cox : Use __u32 properly 36 * Alan Cox : Aligned routing errors more closely with BSD 37 * our system is still very different. 38 * Alan Cox : Faster /proc handling 39 * Alexey Kuznetsov : Massive rework to support tree based routing, 40 * routing caches and better behaviour. 41 * 42 * Olaf Erb : irtt wasn't being copied right. 43 * Bjorn Ekwall : Kerneld route support. 44 * Alan Cox : Multicast fixed (I hope) 45 * Pavel Krauz : Limited broadcast fixed 46 * Mike McLagan : Routing by source 47 * Alexey Kuznetsov : End of old history. Split to fib.c and 48 * route.c and rewritten from scratch. 49 * Andi Kleen : Load-limit warning messages. 50 * Vitaly E. Lavrov : Transparent proxy revived after year coma. 51 * Vitaly E. Lavrov : Race condition in ip_route_input_slow. 52 * Tobias Ringstrom : Uninitialized res.type in ip_route_output_slow. 53 * Vladimir V. Ivanov : IP rule info (flowid) is really useful. 54 * Marc Boucher : routing by fwmark 55 * Robert Olsson : Added rt_cache statistics 56 * Arnaldo C. Melo : Convert proc stuff to seq_file 57 * Eric Dumazet : hashed spinlocks and rt_check_expire() fixes. 58 * Ilia Sotnikov : Ignore TOS on PMTUD and Redirect 59 * Ilia Sotnikov : Removed TOS from hash calculations 60 * 61 * This program is free software; you can redistribute it and/or 62 * modify it under the terms of the GNU General Public License 63 * as published by the Free Software Foundation; either version 64 * 2 of the License, or (at your option) any later version. 65 */ 66 67 #include <linux/module.h> 68 #include <asm/uaccess.h> 69 #include <asm/system.h> 70 #include <linux/bitops.h> 71 #include <linux/types.h> 72 #include <linux/kernel.h> 73 #include <linux/mm.h> 74 #include <linux/bootmem.h> 75 #include <linux/string.h> 76 #include <linux/socket.h> 77 #include <linux/sockios.h> 78 #include <linux/errno.h> 79 #include <linux/in.h> 80 #include <linux/inet.h> 81 #include <linux/netdevice.h> 82 #include <linux/proc_fs.h> 83 #include <linux/init.h> 84 #include <linux/workqueue.h> 85 #include <linux/skbuff.h> 86 #include <linux/inetdevice.h> 87 #include <linux/igmp.h> 88 #include <linux/pkt_sched.h> 89 #include <linux/mroute.h> 90 #include <linux/netfilter_ipv4.h> 91 #include <linux/random.h> 92 #include <linux/jhash.h> 93 #include <linux/rcupdate.h> 94 #include <linux/times.h> 95 #include <net/net_namespace.h> 96 #include <net/protocol.h> 97 #include <net/ip.h> 98 #include <net/route.h> 99 #include <net/inetpeer.h> 100 #include <net/sock.h> 101 #include <net/ip_fib.h> 102 #include <net/arp.h> 103 #include <net/tcp.h> 104 #include <net/icmp.h> 105 #include <net/xfrm.h> 106 #include <net/netevent.h> 107 #include <net/rtnetlink.h> 108 #ifdef CONFIG_SYSCTL 109 #include <linux/sysctl.h> 110 #endif 111 112 #define RT_FL_TOS(oldflp) \ 113 ((u32)(oldflp->fl4_tos & (IPTOS_RT_MASK | RTO_ONLINK))) 114 115 #define IP_MAX_MTU 0xFFF0 116 117 #define RT_GC_TIMEOUT (300*HZ) 118 119 static int ip_rt_min_delay = 2 * HZ; 120 static int ip_rt_max_delay = 10 * HZ; 121 static int ip_rt_max_size; 122 static int ip_rt_gc_timeout = RT_GC_TIMEOUT; 123 static int ip_rt_gc_interval = 60 * HZ; 124 static int ip_rt_gc_min_interval = HZ / 2; 125 static int ip_rt_redirect_number = 9; 126 static int ip_rt_redirect_load = HZ / 50; 127 static int ip_rt_redirect_silence = ((HZ / 50) << (9 + 1)); 128 static int ip_rt_error_cost = HZ; 129 static int ip_rt_error_burst = 5 * HZ; 130 static int ip_rt_gc_elasticity = 8; 131 static int ip_rt_mtu_expires = 10 * 60 * HZ; 132 static int ip_rt_min_pmtu = 512 + 20 + 20; 133 static int ip_rt_min_advmss = 256; 134 static int ip_rt_secret_interval = 10 * 60 * HZ; 135 static unsigned long rt_deadline; 136 137 #define RTprint(a...) printk(KERN_DEBUG a) 138 139 static struct timer_list rt_flush_timer; 140 static void rt_check_expire(struct work_struct *work); 141 static DECLARE_DELAYED_WORK(expires_work, rt_check_expire); 142 static struct timer_list rt_secret_timer; 143 144 /* 145 * Interface to generic destination cache. 146 */ 147 148 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie); 149 static void ipv4_dst_destroy(struct dst_entry *dst); 150 static void ipv4_dst_ifdown(struct dst_entry *dst, 151 struct net_device *dev, int how); 152 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst); 153 static void ipv4_link_failure(struct sk_buff *skb); 154 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu); 155 static int rt_garbage_collect(void); 156 157 158 static struct dst_ops ipv4_dst_ops = { 159 .family = AF_INET, 160 .protocol = __constant_htons(ETH_P_IP), 161 .gc = rt_garbage_collect, 162 .check = ipv4_dst_check, 163 .destroy = ipv4_dst_destroy, 164 .ifdown = ipv4_dst_ifdown, 165 .negative_advice = ipv4_negative_advice, 166 .link_failure = ipv4_link_failure, 167 .update_pmtu = ip_rt_update_pmtu, 168 .entry_size = sizeof(struct rtable), 169 }; 170 171 #define ECN_OR_COST(class) TC_PRIO_##class 172 173 const __u8 ip_tos2prio[16] = { 174 TC_PRIO_BESTEFFORT, 175 ECN_OR_COST(FILLER), 176 TC_PRIO_BESTEFFORT, 177 ECN_OR_COST(BESTEFFORT), 178 TC_PRIO_BULK, 179 ECN_OR_COST(BULK), 180 TC_PRIO_BULK, 181 ECN_OR_COST(BULK), 182 TC_PRIO_INTERACTIVE, 183 ECN_OR_COST(INTERACTIVE), 184 TC_PRIO_INTERACTIVE, 185 ECN_OR_COST(INTERACTIVE), 186 TC_PRIO_INTERACTIVE_BULK, 187 ECN_OR_COST(INTERACTIVE_BULK), 188 TC_PRIO_INTERACTIVE_BULK, 189 ECN_OR_COST(INTERACTIVE_BULK) 190 }; 191 192 193 /* 194 * Route cache. 195 */ 196 197 /* The locking scheme is rather straight forward: 198 * 199 * 1) Read-Copy Update protects the buckets of the central route hash. 200 * 2) Only writers remove entries, and they hold the lock 201 * as they look at rtable reference counts. 202 * 3) Only readers acquire references to rtable entries, 203 * they do so with atomic increments and with the 204 * lock held. 205 */ 206 207 struct rt_hash_bucket { 208 struct rtable *chain; 209 }; 210 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK) || \ 211 defined(CONFIG_PROVE_LOCKING) 212 /* 213 * Instead of using one spinlock for each rt_hash_bucket, we use a table of spinlocks 214 * The size of this table is a power of two and depends on the number of CPUS. 215 * (on lockdep we have a quite big spinlock_t, so keep the size down there) 216 */ 217 #ifdef CONFIG_LOCKDEP 218 # define RT_HASH_LOCK_SZ 256 219 #else 220 # if NR_CPUS >= 32 221 # define RT_HASH_LOCK_SZ 4096 222 # elif NR_CPUS >= 16 223 # define RT_HASH_LOCK_SZ 2048 224 # elif NR_CPUS >= 8 225 # define RT_HASH_LOCK_SZ 1024 226 # elif NR_CPUS >= 4 227 # define RT_HASH_LOCK_SZ 512 228 # else 229 # define RT_HASH_LOCK_SZ 256 230 # endif 231 #endif 232 233 static spinlock_t *rt_hash_locks; 234 # define rt_hash_lock_addr(slot) &rt_hash_locks[(slot) & (RT_HASH_LOCK_SZ - 1)] 235 # define rt_hash_lock_init() { \ 236 int i; \ 237 rt_hash_locks = kmalloc(sizeof(spinlock_t) * RT_HASH_LOCK_SZ, GFP_KERNEL); \ 238 if (!rt_hash_locks) panic("IP: failed to allocate rt_hash_locks\n"); \ 239 for (i = 0; i < RT_HASH_LOCK_SZ; i++) \ 240 spin_lock_init(&rt_hash_locks[i]); \ 241 } 242 #else 243 # define rt_hash_lock_addr(slot) NULL 244 # define rt_hash_lock_init() 245 #endif 246 247 static struct rt_hash_bucket *rt_hash_table; 248 static unsigned rt_hash_mask; 249 static unsigned int rt_hash_log; 250 static unsigned int rt_hash_rnd; 251 252 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat); 253 #define RT_CACHE_STAT_INC(field) \ 254 (__raw_get_cpu_var(rt_cache_stat).field++) 255 256 static int rt_intern_hash(unsigned hash, struct rtable *rth, 257 struct rtable **res); 258 259 static unsigned int rt_hash_code(u32 daddr, u32 saddr) 260 { 261 return (jhash_2words(daddr, saddr, rt_hash_rnd) 262 & rt_hash_mask); 263 } 264 265 #define rt_hash(daddr, saddr, idx) \ 266 rt_hash_code((__force u32)(__be32)(daddr),\ 267 (__force u32)(__be32)(saddr) ^ ((idx) << 5)) 268 269 #ifdef CONFIG_PROC_FS 270 struct rt_cache_iter_state { 271 int bucket; 272 }; 273 274 static struct rtable *rt_cache_get_first(struct seq_file *seq) 275 { 276 struct rtable *r = NULL; 277 struct rt_cache_iter_state *st = seq->private; 278 279 for (st->bucket = rt_hash_mask; st->bucket >= 0; --st->bucket) { 280 rcu_read_lock_bh(); 281 r = rt_hash_table[st->bucket].chain; 282 if (r) 283 break; 284 rcu_read_unlock_bh(); 285 } 286 return rcu_dereference(r); 287 } 288 289 static struct rtable *rt_cache_get_next(struct seq_file *seq, struct rtable *r) 290 { 291 struct rt_cache_iter_state *st = seq->private; 292 293 r = r->u.dst.rt_next; 294 while (!r) { 295 rcu_read_unlock_bh(); 296 if (--st->bucket < 0) 297 break; 298 rcu_read_lock_bh(); 299 r = rt_hash_table[st->bucket].chain; 300 } 301 return rcu_dereference(r); 302 } 303 304 static struct rtable *rt_cache_get_idx(struct seq_file *seq, loff_t pos) 305 { 306 struct rtable *r = rt_cache_get_first(seq); 307 308 if (r) 309 while (pos && (r = rt_cache_get_next(seq, r))) 310 --pos; 311 return pos ? NULL : r; 312 } 313 314 static void *rt_cache_seq_start(struct seq_file *seq, loff_t *pos) 315 { 316 return *pos ? rt_cache_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 317 } 318 319 static void *rt_cache_seq_next(struct seq_file *seq, void *v, loff_t *pos) 320 { 321 struct rtable *r = NULL; 322 323 if (v == SEQ_START_TOKEN) 324 r = rt_cache_get_first(seq); 325 else 326 r = rt_cache_get_next(seq, v); 327 ++*pos; 328 return r; 329 } 330 331 static void rt_cache_seq_stop(struct seq_file *seq, void *v) 332 { 333 if (v && v != SEQ_START_TOKEN) 334 rcu_read_unlock_bh(); 335 } 336 337 static int rt_cache_seq_show(struct seq_file *seq, void *v) 338 { 339 if (v == SEQ_START_TOKEN) 340 seq_printf(seq, "%-127s\n", 341 "Iface\tDestination\tGateway \tFlags\t\tRefCnt\tUse\t" 342 "Metric\tSource\t\tMTU\tWindow\tIRTT\tTOS\tHHRef\t" 343 "HHUptod\tSpecDst"); 344 else { 345 struct rtable *r = v; 346 char temp[256]; 347 348 sprintf(temp, "%s\t%08lX\t%08lX\t%8X\t%d\t%u\t%d\t" 349 "%08lX\t%d\t%u\t%u\t%02X\t%d\t%1d\t%08X", 350 r->u.dst.dev ? r->u.dst.dev->name : "*", 351 (unsigned long)r->rt_dst, (unsigned long)r->rt_gateway, 352 r->rt_flags, atomic_read(&r->u.dst.__refcnt), 353 r->u.dst.__use, 0, (unsigned long)r->rt_src, 354 (dst_metric(&r->u.dst, RTAX_ADVMSS) ? 355 (int)dst_metric(&r->u.dst, RTAX_ADVMSS) + 40 : 0), 356 dst_metric(&r->u.dst, RTAX_WINDOW), 357 (int)((dst_metric(&r->u.dst, RTAX_RTT) >> 3) + 358 dst_metric(&r->u.dst, RTAX_RTTVAR)), 359 r->fl.fl4_tos, 360 r->u.dst.hh ? atomic_read(&r->u.dst.hh->hh_refcnt) : -1, 361 r->u.dst.hh ? (r->u.dst.hh->hh_output == 362 dev_queue_xmit) : 0, 363 r->rt_spec_dst); 364 seq_printf(seq, "%-127s\n", temp); 365 } 366 return 0; 367 } 368 369 static const struct seq_operations rt_cache_seq_ops = { 370 .start = rt_cache_seq_start, 371 .next = rt_cache_seq_next, 372 .stop = rt_cache_seq_stop, 373 .show = rt_cache_seq_show, 374 }; 375 376 static int rt_cache_seq_open(struct inode *inode, struct file *file) 377 { 378 return seq_open_private(file, &rt_cache_seq_ops, 379 sizeof(struct rt_cache_iter_state)); 380 } 381 382 static const struct file_operations rt_cache_seq_fops = { 383 .owner = THIS_MODULE, 384 .open = rt_cache_seq_open, 385 .read = seq_read, 386 .llseek = seq_lseek, 387 .release = seq_release_private, 388 }; 389 390 391 static void *rt_cpu_seq_start(struct seq_file *seq, loff_t *pos) 392 { 393 int cpu; 394 395 if (*pos == 0) 396 return SEQ_START_TOKEN; 397 398 for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 399 if (!cpu_possible(cpu)) 400 continue; 401 *pos = cpu+1; 402 return &per_cpu(rt_cache_stat, cpu); 403 } 404 return NULL; 405 } 406 407 static void *rt_cpu_seq_next(struct seq_file *seq, void *v, loff_t *pos) 408 { 409 int cpu; 410 411 for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 412 if (!cpu_possible(cpu)) 413 continue; 414 *pos = cpu+1; 415 return &per_cpu(rt_cache_stat, cpu); 416 } 417 return NULL; 418 419 } 420 421 static void rt_cpu_seq_stop(struct seq_file *seq, void *v) 422 { 423 424 } 425 426 static int rt_cpu_seq_show(struct seq_file *seq, void *v) 427 { 428 struct rt_cache_stat *st = v; 429 430 if (v == SEQ_START_TOKEN) { 431 seq_printf(seq, "entries in_hit in_slow_tot in_slow_mc in_no_route in_brd in_martian_dst in_martian_src out_hit out_slow_tot out_slow_mc gc_total gc_ignored gc_goal_miss gc_dst_overflow in_hlist_search out_hlist_search\n"); 432 return 0; 433 } 434 435 seq_printf(seq,"%08x %08x %08x %08x %08x %08x %08x %08x " 436 " %08x %08x %08x %08x %08x %08x %08x %08x %08x \n", 437 atomic_read(&ipv4_dst_ops.entries), 438 st->in_hit, 439 st->in_slow_tot, 440 st->in_slow_mc, 441 st->in_no_route, 442 st->in_brd, 443 st->in_martian_dst, 444 st->in_martian_src, 445 446 st->out_hit, 447 st->out_slow_tot, 448 st->out_slow_mc, 449 450 st->gc_total, 451 st->gc_ignored, 452 st->gc_goal_miss, 453 st->gc_dst_overflow, 454 st->in_hlist_search, 455 st->out_hlist_search 456 ); 457 return 0; 458 } 459 460 static const struct seq_operations rt_cpu_seq_ops = { 461 .start = rt_cpu_seq_start, 462 .next = rt_cpu_seq_next, 463 .stop = rt_cpu_seq_stop, 464 .show = rt_cpu_seq_show, 465 }; 466 467 468 static int rt_cpu_seq_open(struct inode *inode, struct file *file) 469 { 470 return seq_open(file, &rt_cpu_seq_ops); 471 } 472 473 static const struct file_operations rt_cpu_seq_fops = { 474 .owner = THIS_MODULE, 475 .open = rt_cpu_seq_open, 476 .read = seq_read, 477 .llseek = seq_lseek, 478 .release = seq_release, 479 }; 480 481 #endif /* CONFIG_PROC_FS */ 482 483 static __inline__ void rt_free(struct rtable *rt) 484 { 485 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free); 486 } 487 488 static __inline__ void rt_drop(struct rtable *rt) 489 { 490 ip_rt_put(rt); 491 call_rcu_bh(&rt->u.dst.rcu_head, dst_rcu_free); 492 } 493 494 static __inline__ int rt_fast_clean(struct rtable *rth) 495 { 496 /* Kill broadcast/multicast entries very aggresively, if they 497 collide in hash table with more useful entries */ 498 return (rth->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST)) && 499 rth->fl.iif && rth->u.dst.rt_next; 500 } 501 502 static __inline__ int rt_valuable(struct rtable *rth) 503 { 504 return (rth->rt_flags & (RTCF_REDIRECTED | RTCF_NOTIFY)) || 505 rth->u.dst.expires; 506 } 507 508 static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2) 509 { 510 unsigned long age; 511 int ret = 0; 512 513 if (atomic_read(&rth->u.dst.__refcnt)) 514 goto out; 515 516 ret = 1; 517 if (rth->u.dst.expires && 518 time_after_eq(jiffies, rth->u.dst.expires)) 519 goto out; 520 521 age = jiffies - rth->u.dst.lastuse; 522 ret = 0; 523 if ((age <= tmo1 && !rt_fast_clean(rth)) || 524 (age <= tmo2 && rt_valuable(rth))) 525 goto out; 526 ret = 1; 527 out: return ret; 528 } 529 530 /* Bits of score are: 531 * 31: very valuable 532 * 30: not quite useless 533 * 29..0: usage counter 534 */ 535 static inline u32 rt_score(struct rtable *rt) 536 { 537 u32 score = jiffies - rt->u.dst.lastuse; 538 539 score = ~score & ~(3<<30); 540 541 if (rt_valuable(rt)) 542 score |= (1<<31); 543 544 if (!rt->fl.iif || 545 !(rt->rt_flags & (RTCF_BROADCAST|RTCF_MULTICAST|RTCF_LOCAL))) 546 score |= (1<<30); 547 548 return score; 549 } 550 551 static inline int compare_keys(struct flowi *fl1, struct flowi *fl2) 552 { 553 return ((__force u32)((fl1->nl_u.ip4_u.daddr ^ fl2->nl_u.ip4_u.daddr) | 554 (fl1->nl_u.ip4_u.saddr ^ fl2->nl_u.ip4_u.saddr)) | 555 (fl1->mark ^ fl2->mark) | 556 (*(u16 *)&fl1->nl_u.ip4_u.tos ^ 557 *(u16 *)&fl2->nl_u.ip4_u.tos) | 558 (fl1->oif ^ fl2->oif) | 559 (fl1->iif ^ fl2->iif)) == 0; 560 } 561 562 static void rt_check_expire(struct work_struct *work) 563 { 564 static unsigned int rover; 565 unsigned int i = rover, goal; 566 struct rtable *rth, **rthp; 567 u64 mult; 568 569 mult = ((u64)ip_rt_gc_interval) << rt_hash_log; 570 if (ip_rt_gc_timeout > 1) 571 do_div(mult, ip_rt_gc_timeout); 572 goal = (unsigned int)mult; 573 if (goal > rt_hash_mask) 574 goal = rt_hash_mask + 1; 575 for (; goal > 0; goal--) { 576 unsigned long tmo = ip_rt_gc_timeout; 577 578 i = (i + 1) & rt_hash_mask; 579 rthp = &rt_hash_table[i].chain; 580 581 if (need_resched()) 582 cond_resched(); 583 584 if (*rthp == NULL) 585 continue; 586 spin_lock_bh(rt_hash_lock_addr(i)); 587 while ((rth = *rthp) != NULL) { 588 if (rth->u.dst.expires) { 589 /* Entry is expired even if it is in use */ 590 if (time_before_eq(jiffies, rth->u.dst.expires)) { 591 tmo >>= 1; 592 rthp = &rth->u.dst.rt_next; 593 continue; 594 } 595 } else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) { 596 tmo >>= 1; 597 rthp = &rth->u.dst.rt_next; 598 continue; 599 } 600 601 /* Cleanup aged off entries. */ 602 *rthp = rth->u.dst.rt_next; 603 rt_free(rth); 604 } 605 spin_unlock_bh(rt_hash_lock_addr(i)); 606 } 607 rover = i; 608 schedule_delayed_work(&expires_work, ip_rt_gc_interval); 609 } 610 611 /* This can run from both BH and non-BH contexts, the latter 612 * in the case of a forced flush event. 613 */ 614 static void rt_run_flush(unsigned long dummy) 615 { 616 int i; 617 struct rtable *rth, *next; 618 619 rt_deadline = 0; 620 621 get_random_bytes(&rt_hash_rnd, 4); 622 623 for (i = rt_hash_mask; i >= 0; i--) { 624 spin_lock_bh(rt_hash_lock_addr(i)); 625 rth = rt_hash_table[i].chain; 626 if (rth) 627 rt_hash_table[i].chain = NULL; 628 spin_unlock_bh(rt_hash_lock_addr(i)); 629 630 for (; rth; rth = next) { 631 next = rth->u.dst.rt_next; 632 rt_free(rth); 633 } 634 } 635 } 636 637 static DEFINE_SPINLOCK(rt_flush_lock); 638 639 void rt_cache_flush(int delay) 640 { 641 unsigned long now = jiffies; 642 int user_mode = !in_softirq(); 643 644 if (delay < 0) 645 delay = ip_rt_min_delay; 646 647 spin_lock_bh(&rt_flush_lock); 648 649 if (del_timer(&rt_flush_timer) && delay > 0 && rt_deadline) { 650 long tmo = (long)(rt_deadline - now); 651 652 /* If flush timer is already running 653 and flush request is not immediate (delay > 0): 654 655 if deadline is not achieved, prolongate timer to "delay", 656 otherwise fire it at deadline time. 657 */ 658 659 if (user_mode && tmo < ip_rt_max_delay-ip_rt_min_delay) 660 tmo = 0; 661 662 if (delay > tmo) 663 delay = tmo; 664 } 665 666 if (delay <= 0) { 667 spin_unlock_bh(&rt_flush_lock); 668 rt_run_flush(0); 669 return; 670 } 671 672 if (rt_deadline == 0) 673 rt_deadline = now + ip_rt_max_delay; 674 675 mod_timer(&rt_flush_timer, now+delay); 676 spin_unlock_bh(&rt_flush_lock); 677 } 678 679 static void rt_secret_rebuild(unsigned long dummy) 680 { 681 unsigned long now = jiffies; 682 683 rt_cache_flush(0); 684 mod_timer(&rt_secret_timer, now + ip_rt_secret_interval); 685 } 686 687 /* 688 Short description of GC goals. 689 690 We want to build algorithm, which will keep routing cache 691 at some equilibrium point, when number of aged off entries 692 is kept approximately equal to newly generated ones. 693 694 Current expiration strength is variable "expire". 695 We try to adjust it dynamically, so that if networking 696 is idle expires is large enough to keep enough of warm entries, 697 and when load increases it reduces to limit cache size. 698 */ 699 700 static int rt_garbage_collect(void) 701 { 702 static unsigned long expire = RT_GC_TIMEOUT; 703 static unsigned long last_gc; 704 static int rover; 705 static int equilibrium; 706 struct rtable *rth, **rthp; 707 unsigned long now = jiffies; 708 int goal; 709 710 /* 711 * Garbage collection is pretty expensive, 712 * do not make it too frequently. 713 */ 714 715 RT_CACHE_STAT_INC(gc_total); 716 717 if (now - last_gc < ip_rt_gc_min_interval && 718 atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) { 719 RT_CACHE_STAT_INC(gc_ignored); 720 goto out; 721 } 722 723 /* Calculate number of entries, which we want to expire now. */ 724 goal = atomic_read(&ipv4_dst_ops.entries) - 725 (ip_rt_gc_elasticity << rt_hash_log); 726 if (goal <= 0) { 727 if (equilibrium < ipv4_dst_ops.gc_thresh) 728 equilibrium = ipv4_dst_ops.gc_thresh; 729 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium; 730 if (goal > 0) { 731 equilibrium += min_t(unsigned int, goal / 2, rt_hash_mask + 1); 732 goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium; 733 } 734 } else { 735 /* We are in dangerous area. Try to reduce cache really 736 * aggressively. 737 */ 738 goal = max_t(unsigned int, goal / 2, rt_hash_mask + 1); 739 equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal; 740 } 741 742 if (now - last_gc >= ip_rt_gc_min_interval) 743 last_gc = now; 744 745 if (goal <= 0) { 746 equilibrium += goal; 747 goto work_done; 748 } 749 750 do { 751 int i, k; 752 753 for (i = rt_hash_mask, k = rover; i >= 0; i--) { 754 unsigned long tmo = expire; 755 756 k = (k + 1) & rt_hash_mask; 757 rthp = &rt_hash_table[k].chain; 758 spin_lock_bh(rt_hash_lock_addr(k)); 759 while ((rth = *rthp) != NULL) { 760 if (!rt_may_expire(rth, tmo, expire)) { 761 tmo >>= 1; 762 rthp = &rth->u.dst.rt_next; 763 continue; 764 } 765 *rthp = rth->u.dst.rt_next; 766 rt_free(rth); 767 goal--; 768 } 769 spin_unlock_bh(rt_hash_lock_addr(k)); 770 if (goal <= 0) 771 break; 772 } 773 rover = k; 774 775 if (goal <= 0) 776 goto work_done; 777 778 /* Goal is not achieved. We stop process if: 779 780 - if expire reduced to zero. Otherwise, expire is halfed. 781 - if table is not full. 782 - if we are called from interrupt. 783 - jiffies check is just fallback/debug loop breaker. 784 We will not spin here for long time in any case. 785 */ 786 787 RT_CACHE_STAT_INC(gc_goal_miss); 788 789 if (expire == 0) 790 break; 791 792 expire >>= 1; 793 #if RT_CACHE_DEBUG >= 2 794 printk(KERN_DEBUG "expire>> %u %d %d %d\n", expire, 795 atomic_read(&ipv4_dst_ops.entries), goal, i); 796 #endif 797 798 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) 799 goto out; 800 } while (!in_softirq() && time_before_eq(jiffies, now)); 801 802 if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) 803 goto out; 804 if (net_ratelimit()) 805 printk(KERN_WARNING "dst cache overflow\n"); 806 RT_CACHE_STAT_INC(gc_dst_overflow); 807 return 1; 808 809 work_done: 810 expire += ip_rt_gc_min_interval; 811 if (expire > ip_rt_gc_timeout || 812 atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh) 813 expire = ip_rt_gc_timeout; 814 #if RT_CACHE_DEBUG >= 2 815 printk(KERN_DEBUG "expire++ %u %d %d %d\n", expire, 816 atomic_read(&ipv4_dst_ops.entries), goal, rover); 817 #endif 818 out: return 0; 819 } 820 821 static int rt_intern_hash(unsigned hash, struct rtable *rt, struct rtable **rp) 822 { 823 struct rtable *rth, **rthp; 824 unsigned long now; 825 struct rtable *cand, **candp; 826 u32 min_score; 827 int chain_length; 828 int attempts = !in_softirq(); 829 830 restart: 831 chain_length = 0; 832 min_score = ~(u32)0; 833 cand = NULL; 834 candp = NULL; 835 now = jiffies; 836 837 rthp = &rt_hash_table[hash].chain; 838 839 spin_lock_bh(rt_hash_lock_addr(hash)); 840 while ((rth = *rthp) != NULL) { 841 if (compare_keys(&rth->fl, &rt->fl)) { 842 /* Put it first */ 843 *rthp = rth->u.dst.rt_next; 844 /* 845 * Since lookup is lockfree, the deletion 846 * must be visible to another weakly ordered CPU before 847 * the insertion at the start of the hash chain. 848 */ 849 rcu_assign_pointer(rth->u.dst.rt_next, 850 rt_hash_table[hash].chain); 851 /* 852 * Since lookup is lockfree, the update writes 853 * must be ordered for consistency on SMP. 854 */ 855 rcu_assign_pointer(rt_hash_table[hash].chain, rth); 856 857 dst_use(&rth->u.dst, now); 858 spin_unlock_bh(rt_hash_lock_addr(hash)); 859 860 rt_drop(rt); 861 *rp = rth; 862 return 0; 863 } 864 865 if (!atomic_read(&rth->u.dst.__refcnt)) { 866 u32 score = rt_score(rth); 867 868 if (score <= min_score) { 869 cand = rth; 870 candp = rthp; 871 min_score = score; 872 } 873 } 874 875 chain_length++; 876 877 rthp = &rth->u.dst.rt_next; 878 } 879 880 if (cand) { 881 /* ip_rt_gc_elasticity used to be average length of chain 882 * length, when exceeded gc becomes really aggressive. 883 * 884 * The second limit is less certain. At the moment it allows 885 * only 2 entries per bucket. We will see. 886 */ 887 if (chain_length > ip_rt_gc_elasticity) { 888 *candp = cand->u.dst.rt_next; 889 rt_free(cand); 890 } 891 } 892 893 /* Try to bind route to arp only if it is output 894 route or unicast forwarding path. 895 */ 896 if (rt->rt_type == RTN_UNICAST || rt->fl.iif == 0) { 897 int err = arp_bind_neighbour(&rt->u.dst); 898 if (err) { 899 spin_unlock_bh(rt_hash_lock_addr(hash)); 900 901 if (err != -ENOBUFS) { 902 rt_drop(rt); 903 return err; 904 } 905 906 /* Neighbour tables are full and nothing 907 can be released. Try to shrink route cache, 908 it is most likely it holds some neighbour records. 909 */ 910 if (attempts-- > 0) { 911 int saved_elasticity = ip_rt_gc_elasticity; 912 int saved_int = ip_rt_gc_min_interval; 913 ip_rt_gc_elasticity = 1; 914 ip_rt_gc_min_interval = 0; 915 rt_garbage_collect(); 916 ip_rt_gc_min_interval = saved_int; 917 ip_rt_gc_elasticity = saved_elasticity; 918 goto restart; 919 } 920 921 if (net_ratelimit()) 922 printk(KERN_WARNING "Neighbour table overflow.\n"); 923 rt_drop(rt); 924 return -ENOBUFS; 925 } 926 } 927 928 rt->u.dst.rt_next = rt_hash_table[hash].chain; 929 #if RT_CACHE_DEBUG >= 2 930 if (rt->u.dst.rt_next) { 931 struct rtable *trt; 932 printk(KERN_DEBUG "rt_cache @%02x: %u.%u.%u.%u", hash, 933 NIPQUAD(rt->rt_dst)); 934 for (trt = rt->u.dst.rt_next; trt; trt = trt->u.dst.rt_next) 935 printk(" . %u.%u.%u.%u", NIPQUAD(trt->rt_dst)); 936 printk("\n"); 937 } 938 #endif 939 rt_hash_table[hash].chain = rt; 940 spin_unlock_bh(rt_hash_lock_addr(hash)); 941 *rp = rt; 942 return 0; 943 } 944 945 void rt_bind_peer(struct rtable *rt, int create) 946 { 947 static DEFINE_SPINLOCK(rt_peer_lock); 948 struct inet_peer *peer; 949 950 peer = inet_getpeer(rt->rt_dst, create); 951 952 spin_lock_bh(&rt_peer_lock); 953 if (rt->peer == NULL) { 954 rt->peer = peer; 955 peer = NULL; 956 } 957 spin_unlock_bh(&rt_peer_lock); 958 if (peer) 959 inet_putpeer(peer); 960 } 961 962 /* 963 * Peer allocation may fail only in serious out-of-memory conditions. However 964 * we still can generate some output. 965 * Random ID selection looks a bit dangerous because we have no chances to 966 * select ID being unique in a reasonable period of time. 967 * But broken packet identifier may be better than no packet at all. 968 */ 969 static void ip_select_fb_ident(struct iphdr *iph) 970 { 971 static DEFINE_SPINLOCK(ip_fb_id_lock); 972 static u32 ip_fallback_id; 973 u32 salt; 974 975 spin_lock_bh(&ip_fb_id_lock); 976 salt = secure_ip_id((__force __be32)ip_fallback_id ^ iph->daddr); 977 iph->id = htons(salt & 0xFFFF); 978 ip_fallback_id = salt; 979 spin_unlock_bh(&ip_fb_id_lock); 980 } 981 982 void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more) 983 { 984 struct rtable *rt = (struct rtable *) dst; 985 986 if (rt) { 987 if (rt->peer == NULL) 988 rt_bind_peer(rt, 1); 989 990 /* If peer is attached to destination, it is never detached, 991 so that we need not to grab a lock to dereference it. 992 */ 993 if (rt->peer) { 994 iph->id = htons(inet_getid(rt->peer, more)); 995 return; 996 } 997 } else 998 printk(KERN_DEBUG "rt_bind_peer(0) @%p\n", 999 __builtin_return_address(0)); 1000 1001 ip_select_fb_ident(iph); 1002 } 1003 1004 static void rt_del(unsigned hash, struct rtable *rt) 1005 { 1006 struct rtable **rthp; 1007 1008 spin_lock_bh(rt_hash_lock_addr(hash)); 1009 ip_rt_put(rt); 1010 for (rthp = &rt_hash_table[hash].chain; *rthp; 1011 rthp = &(*rthp)->u.dst.rt_next) 1012 if (*rthp == rt) { 1013 *rthp = rt->u.dst.rt_next; 1014 rt_free(rt); 1015 break; 1016 } 1017 spin_unlock_bh(rt_hash_lock_addr(hash)); 1018 } 1019 1020 void ip_rt_redirect(__be32 old_gw, __be32 daddr, __be32 new_gw, 1021 __be32 saddr, struct net_device *dev) 1022 { 1023 int i, k; 1024 struct in_device *in_dev = in_dev_get(dev); 1025 struct rtable *rth, **rthp; 1026 __be32 skeys[2] = { saddr, 0 }; 1027 int ikeys[2] = { dev->ifindex, 0 }; 1028 struct netevent_redirect netevent; 1029 1030 if (!in_dev) 1031 return; 1032 1033 if (new_gw == old_gw || !IN_DEV_RX_REDIRECTS(in_dev) 1034 || MULTICAST(new_gw) || BADCLASS(new_gw) || ZERONET(new_gw)) 1035 goto reject_redirect; 1036 1037 if (!IN_DEV_SHARED_MEDIA(in_dev)) { 1038 if (!inet_addr_onlink(in_dev, new_gw, old_gw)) 1039 goto reject_redirect; 1040 if (IN_DEV_SEC_REDIRECTS(in_dev) && ip_fib_check_default(new_gw, dev)) 1041 goto reject_redirect; 1042 } else { 1043 if (inet_addr_type(new_gw) != RTN_UNICAST) 1044 goto reject_redirect; 1045 } 1046 1047 for (i = 0; i < 2; i++) { 1048 for (k = 0; k < 2; k++) { 1049 unsigned hash = rt_hash(daddr, skeys[i], ikeys[k]); 1050 1051 rthp=&rt_hash_table[hash].chain; 1052 1053 rcu_read_lock(); 1054 while ((rth = rcu_dereference(*rthp)) != NULL) { 1055 struct rtable *rt; 1056 1057 if (rth->fl.fl4_dst != daddr || 1058 rth->fl.fl4_src != skeys[i] || 1059 rth->fl.oif != ikeys[k] || 1060 rth->fl.iif != 0) { 1061 rthp = &rth->u.dst.rt_next; 1062 continue; 1063 } 1064 1065 if (rth->rt_dst != daddr || 1066 rth->rt_src != saddr || 1067 rth->u.dst.error || 1068 rth->rt_gateway != old_gw || 1069 rth->u.dst.dev != dev) 1070 break; 1071 1072 dst_hold(&rth->u.dst); 1073 rcu_read_unlock(); 1074 1075 rt = dst_alloc(&ipv4_dst_ops); 1076 if (rt == NULL) { 1077 ip_rt_put(rth); 1078 in_dev_put(in_dev); 1079 return; 1080 } 1081 1082 /* Copy all the information. */ 1083 *rt = *rth; 1084 INIT_RCU_HEAD(&rt->u.dst.rcu_head); 1085 rt->u.dst.__use = 1; 1086 atomic_set(&rt->u.dst.__refcnt, 1); 1087 rt->u.dst.child = NULL; 1088 if (rt->u.dst.dev) 1089 dev_hold(rt->u.dst.dev); 1090 if (rt->idev) 1091 in_dev_hold(rt->idev); 1092 rt->u.dst.obsolete = 0; 1093 rt->u.dst.lastuse = jiffies; 1094 rt->u.dst.path = &rt->u.dst; 1095 rt->u.dst.neighbour = NULL; 1096 rt->u.dst.hh = NULL; 1097 rt->u.dst.xfrm = NULL; 1098 1099 rt->rt_flags |= RTCF_REDIRECTED; 1100 1101 /* Gateway is different ... */ 1102 rt->rt_gateway = new_gw; 1103 1104 /* Redirect received -> path was valid */ 1105 dst_confirm(&rth->u.dst); 1106 1107 if (rt->peer) 1108 atomic_inc(&rt->peer->refcnt); 1109 1110 if (arp_bind_neighbour(&rt->u.dst) || 1111 !(rt->u.dst.neighbour->nud_state & 1112 NUD_VALID)) { 1113 if (rt->u.dst.neighbour) 1114 neigh_event_send(rt->u.dst.neighbour, NULL); 1115 ip_rt_put(rth); 1116 rt_drop(rt); 1117 goto do_next; 1118 } 1119 1120 netevent.old = &rth->u.dst; 1121 netevent.new = &rt->u.dst; 1122 call_netevent_notifiers(NETEVENT_REDIRECT, 1123 &netevent); 1124 1125 rt_del(hash, rth); 1126 if (!rt_intern_hash(hash, rt, &rt)) 1127 ip_rt_put(rt); 1128 goto do_next; 1129 } 1130 rcu_read_unlock(); 1131 do_next: 1132 ; 1133 } 1134 } 1135 in_dev_put(in_dev); 1136 return; 1137 1138 reject_redirect: 1139 #ifdef CONFIG_IP_ROUTE_VERBOSE 1140 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) 1141 printk(KERN_INFO "Redirect from %u.%u.%u.%u on %s about " 1142 "%u.%u.%u.%u ignored.\n" 1143 " Advised path = %u.%u.%u.%u -> %u.%u.%u.%u\n", 1144 NIPQUAD(old_gw), dev->name, NIPQUAD(new_gw), 1145 NIPQUAD(saddr), NIPQUAD(daddr)); 1146 #endif 1147 in_dev_put(in_dev); 1148 } 1149 1150 static struct dst_entry *ipv4_negative_advice(struct dst_entry *dst) 1151 { 1152 struct rtable *rt = (struct rtable*)dst; 1153 struct dst_entry *ret = dst; 1154 1155 if (rt) { 1156 if (dst->obsolete) { 1157 ip_rt_put(rt); 1158 ret = NULL; 1159 } else if ((rt->rt_flags & RTCF_REDIRECTED) || 1160 rt->u.dst.expires) { 1161 unsigned hash = rt_hash(rt->fl.fl4_dst, rt->fl.fl4_src, 1162 rt->fl.oif); 1163 #if RT_CACHE_DEBUG >= 1 1164 printk(KERN_DEBUG "ipv4_negative_advice: redirect to " 1165 "%u.%u.%u.%u/%02x dropped\n", 1166 NIPQUAD(rt->rt_dst), rt->fl.fl4_tos); 1167 #endif 1168 rt_del(hash, rt); 1169 ret = NULL; 1170 } 1171 } 1172 return ret; 1173 } 1174 1175 /* 1176 * Algorithm: 1177 * 1. The first ip_rt_redirect_number redirects are sent 1178 * with exponential backoff, then we stop sending them at all, 1179 * assuming that the host ignores our redirects. 1180 * 2. If we did not see packets requiring redirects 1181 * during ip_rt_redirect_silence, we assume that the host 1182 * forgot redirected route and start to send redirects again. 1183 * 1184 * This algorithm is much cheaper and more intelligent than dumb load limiting 1185 * in icmp.c. 1186 * 1187 * NOTE. Do not forget to inhibit load limiting for redirects (redundant) 1188 * and "frag. need" (breaks PMTU discovery) in icmp.c. 1189 */ 1190 1191 void ip_rt_send_redirect(struct sk_buff *skb) 1192 { 1193 struct rtable *rt = (struct rtable*)skb->dst; 1194 struct in_device *in_dev = in_dev_get(rt->u.dst.dev); 1195 1196 if (!in_dev) 1197 return; 1198 1199 if (!IN_DEV_TX_REDIRECTS(in_dev)) 1200 goto out; 1201 1202 /* No redirected packets during ip_rt_redirect_silence; 1203 * reset the algorithm. 1204 */ 1205 if (time_after(jiffies, rt->u.dst.rate_last + ip_rt_redirect_silence)) 1206 rt->u.dst.rate_tokens = 0; 1207 1208 /* Too many ignored redirects; do not send anything 1209 * set u.dst.rate_last to the last seen redirected packet. 1210 */ 1211 if (rt->u.dst.rate_tokens >= ip_rt_redirect_number) { 1212 rt->u.dst.rate_last = jiffies; 1213 goto out; 1214 } 1215 1216 /* Check for load limit; set rate_last to the latest sent 1217 * redirect. 1218 */ 1219 if (rt->u.dst.rate_tokens == 0 || 1220 time_after(jiffies, 1221 (rt->u.dst.rate_last + 1222 (ip_rt_redirect_load << rt->u.dst.rate_tokens)))) { 1223 icmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, rt->rt_gateway); 1224 rt->u.dst.rate_last = jiffies; 1225 ++rt->u.dst.rate_tokens; 1226 #ifdef CONFIG_IP_ROUTE_VERBOSE 1227 if (IN_DEV_LOG_MARTIANS(in_dev) && 1228 rt->u.dst.rate_tokens == ip_rt_redirect_number && 1229 net_ratelimit()) 1230 printk(KERN_WARNING "host %u.%u.%u.%u/if%d ignores " 1231 "redirects for %u.%u.%u.%u to %u.%u.%u.%u.\n", 1232 NIPQUAD(rt->rt_src), rt->rt_iif, 1233 NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_gateway)); 1234 #endif 1235 } 1236 out: 1237 in_dev_put(in_dev); 1238 } 1239 1240 static int ip_error(struct sk_buff *skb) 1241 { 1242 struct rtable *rt = (struct rtable*)skb->dst; 1243 unsigned long now; 1244 int code; 1245 1246 switch (rt->u.dst.error) { 1247 case EINVAL: 1248 default: 1249 goto out; 1250 case EHOSTUNREACH: 1251 code = ICMP_HOST_UNREACH; 1252 break; 1253 case ENETUNREACH: 1254 code = ICMP_NET_UNREACH; 1255 IP_INC_STATS_BH(IPSTATS_MIB_INNOROUTES); 1256 break; 1257 case EACCES: 1258 code = ICMP_PKT_FILTERED; 1259 break; 1260 } 1261 1262 now = jiffies; 1263 rt->u.dst.rate_tokens += now - rt->u.dst.rate_last; 1264 if (rt->u.dst.rate_tokens > ip_rt_error_burst) 1265 rt->u.dst.rate_tokens = ip_rt_error_burst; 1266 rt->u.dst.rate_last = now; 1267 if (rt->u.dst.rate_tokens >= ip_rt_error_cost) { 1268 rt->u.dst.rate_tokens -= ip_rt_error_cost; 1269 icmp_send(skb, ICMP_DEST_UNREACH, code, 0); 1270 } 1271 1272 out: kfree_skb(skb); 1273 return 0; 1274 } 1275 1276 /* 1277 * The last two values are not from the RFC but 1278 * are needed for AMPRnet AX.25 paths. 1279 */ 1280 1281 static const unsigned short mtu_plateau[] = 1282 {32000, 17914, 8166, 4352, 2002, 1492, 576, 296, 216, 128 }; 1283 1284 static __inline__ unsigned short guess_mtu(unsigned short old_mtu) 1285 { 1286 int i; 1287 1288 for (i = 0; i < ARRAY_SIZE(mtu_plateau); i++) 1289 if (old_mtu > mtu_plateau[i]) 1290 return mtu_plateau[i]; 1291 return 68; 1292 } 1293 1294 unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu) 1295 { 1296 int i; 1297 unsigned short old_mtu = ntohs(iph->tot_len); 1298 struct rtable *rth; 1299 __be32 skeys[2] = { iph->saddr, 0, }; 1300 __be32 daddr = iph->daddr; 1301 unsigned short est_mtu = 0; 1302 1303 if (ipv4_config.no_pmtu_disc) 1304 return 0; 1305 1306 for (i = 0; i < 2; i++) { 1307 unsigned hash = rt_hash(daddr, skeys[i], 0); 1308 1309 rcu_read_lock(); 1310 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth; 1311 rth = rcu_dereference(rth->u.dst.rt_next)) { 1312 if (rth->fl.fl4_dst == daddr && 1313 rth->fl.fl4_src == skeys[i] && 1314 rth->rt_dst == daddr && 1315 rth->rt_src == iph->saddr && 1316 rth->fl.iif == 0 && 1317 !(dst_metric_locked(&rth->u.dst, RTAX_MTU))) { 1318 unsigned short mtu = new_mtu; 1319 1320 if (new_mtu < 68 || new_mtu >= old_mtu) { 1321 1322 /* BSD 4.2 compatibility hack :-( */ 1323 if (mtu == 0 && 1324 old_mtu >= rth->u.dst.metrics[RTAX_MTU-1] && 1325 old_mtu >= 68 + (iph->ihl << 2)) 1326 old_mtu -= iph->ihl << 2; 1327 1328 mtu = guess_mtu(old_mtu); 1329 } 1330 if (mtu <= rth->u.dst.metrics[RTAX_MTU-1]) { 1331 if (mtu < rth->u.dst.metrics[RTAX_MTU-1]) { 1332 dst_confirm(&rth->u.dst); 1333 if (mtu < ip_rt_min_pmtu) { 1334 mtu = ip_rt_min_pmtu; 1335 rth->u.dst.metrics[RTAX_LOCK-1] |= 1336 (1 << RTAX_MTU); 1337 } 1338 rth->u.dst.metrics[RTAX_MTU-1] = mtu; 1339 dst_set_expires(&rth->u.dst, 1340 ip_rt_mtu_expires); 1341 } 1342 est_mtu = mtu; 1343 } 1344 } 1345 } 1346 rcu_read_unlock(); 1347 } 1348 return est_mtu ? : new_mtu; 1349 } 1350 1351 static void ip_rt_update_pmtu(struct dst_entry *dst, u32 mtu) 1352 { 1353 if (dst->metrics[RTAX_MTU-1] > mtu && mtu >= 68 && 1354 !(dst_metric_locked(dst, RTAX_MTU))) { 1355 if (mtu < ip_rt_min_pmtu) { 1356 mtu = ip_rt_min_pmtu; 1357 dst->metrics[RTAX_LOCK-1] |= (1 << RTAX_MTU); 1358 } 1359 dst->metrics[RTAX_MTU-1] = mtu; 1360 dst_set_expires(dst, ip_rt_mtu_expires); 1361 call_netevent_notifiers(NETEVENT_PMTU_UPDATE, dst); 1362 } 1363 } 1364 1365 static struct dst_entry *ipv4_dst_check(struct dst_entry *dst, u32 cookie) 1366 { 1367 return NULL; 1368 } 1369 1370 static void ipv4_dst_destroy(struct dst_entry *dst) 1371 { 1372 struct rtable *rt = (struct rtable *) dst; 1373 struct inet_peer *peer = rt->peer; 1374 struct in_device *idev = rt->idev; 1375 1376 if (peer) { 1377 rt->peer = NULL; 1378 inet_putpeer(peer); 1379 } 1380 1381 if (idev) { 1382 rt->idev = NULL; 1383 in_dev_put(idev); 1384 } 1385 } 1386 1387 static void ipv4_dst_ifdown(struct dst_entry *dst, struct net_device *dev, 1388 int how) 1389 { 1390 struct rtable *rt = (struct rtable *) dst; 1391 struct in_device *idev = rt->idev; 1392 if (dev != init_net.loopback_dev && idev && idev->dev == dev) { 1393 struct in_device *loopback_idev = in_dev_get(init_net.loopback_dev); 1394 if (loopback_idev) { 1395 rt->idev = loopback_idev; 1396 in_dev_put(idev); 1397 } 1398 } 1399 } 1400 1401 static void ipv4_link_failure(struct sk_buff *skb) 1402 { 1403 struct rtable *rt; 1404 1405 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0); 1406 1407 rt = (struct rtable *) skb->dst; 1408 if (rt) 1409 dst_set_expires(&rt->u.dst, 0); 1410 } 1411 1412 static int ip_rt_bug(struct sk_buff *skb) 1413 { 1414 printk(KERN_DEBUG "ip_rt_bug: %u.%u.%u.%u -> %u.%u.%u.%u, %s\n", 1415 NIPQUAD(ip_hdr(skb)->saddr), NIPQUAD(ip_hdr(skb)->daddr), 1416 skb->dev ? skb->dev->name : "?"); 1417 kfree_skb(skb); 1418 return 0; 1419 } 1420 1421 /* 1422 We do not cache source address of outgoing interface, 1423 because it is used only by IP RR, TS and SRR options, 1424 so that it out of fast path. 1425 1426 BTW remember: "addr" is allowed to be not aligned 1427 in IP options! 1428 */ 1429 1430 void ip_rt_get_source(u8 *addr, struct rtable *rt) 1431 { 1432 __be32 src; 1433 struct fib_result res; 1434 1435 if (rt->fl.iif == 0) 1436 src = rt->rt_src; 1437 else if (fib_lookup(&rt->fl, &res) == 0) { 1438 src = FIB_RES_PREFSRC(res); 1439 fib_res_put(&res); 1440 } else 1441 src = inet_select_addr(rt->u.dst.dev, rt->rt_gateway, 1442 RT_SCOPE_UNIVERSE); 1443 memcpy(addr, &src, 4); 1444 } 1445 1446 #ifdef CONFIG_NET_CLS_ROUTE 1447 static void set_class_tag(struct rtable *rt, u32 tag) 1448 { 1449 if (!(rt->u.dst.tclassid & 0xFFFF)) 1450 rt->u.dst.tclassid |= tag & 0xFFFF; 1451 if (!(rt->u.dst.tclassid & 0xFFFF0000)) 1452 rt->u.dst.tclassid |= tag & 0xFFFF0000; 1453 } 1454 #endif 1455 1456 static void rt_set_nexthop(struct rtable *rt, struct fib_result *res, u32 itag) 1457 { 1458 struct fib_info *fi = res->fi; 1459 1460 if (fi) { 1461 if (FIB_RES_GW(*res) && 1462 FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) 1463 rt->rt_gateway = FIB_RES_GW(*res); 1464 memcpy(rt->u.dst.metrics, fi->fib_metrics, 1465 sizeof(rt->u.dst.metrics)); 1466 if (fi->fib_mtu == 0) { 1467 rt->u.dst.metrics[RTAX_MTU-1] = rt->u.dst.dev->mtu; 1468 if (rt->u.dst.metrics[RTAX_LOCK-1] & (1 << RTAX_MTU) && 1469 rt->rt_gateway != rt->rt_dst && 1470 rt->u.dst.dev->mtu > 576) 1471 rt->u.dst.metrics[RTAX_MTU-1] = 576; 1472 } 1473 #ifdef CONFIG_NET_CLS_ROUTE 1474 rt->u.dst.tclassid = FIB_RES_NH(*res).nh_tclassid; 1475 #endif 1476 } else 1477 rt->u.dst.metrics[RTAX_MTU-1]= rt->u.dst.dev->mtu; 1478 1479 if (rt->u.dst.metrics[RTAX_HOPLIMIT-1] == 0) 1480 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = sysctl_ip_default_ttl; 1481 if (rt->u.dst.metrics[RTAX_MTU-1] > IP_MAX_MTU) 1482 rt->u.dst.metrics[RTAX_MTU-1] = IP_MAX_MTU; 1483 if (rt->u.dst.metrics[RTAX_ADVMSS-1] == 0) 1484 rt->u.dst.metrics[RTAX_ADVMSS-1] = max_t(unsigned int, rt->u.dst.dev->mtu - 40, 1485 ip_rt_min_advmss); 1486 if (rt->u.dst.metrics[RTAX_ADVMSS-1] > 65535 - 40) 1487 rt->u.dst.metrics[RTAX_ADVMSS-1] = 65535 - 40; 1488 1489 #ifdef CONFIG_NET_CLS_ROUTE 1490 #ifdef CONFIG_IP_MULTIPLE_TABLES 1491 set_class_tag(rt, fib_rules_tclass(res)); 1492 #endif 1493 set_class_tag(rt, itag); 1494 #endif 1495 rt->rt_type = res->type; 1496 } 1497 1498 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr, 1499 u8 tos, struct net_device *dev, int our) 1500 { 1501 unsigned hash; 1502 struct rtable *rth; 1503 __be32 spec_dst; 1504 struct in_device *in_dev = in_dev_get(dev); 1505 u32 itag = 0; 1506 1507 /* Primary sanity checks. */ 1508 1509 if (in_dev == NULL) 1510 return -EINVAL; 1511 1512 if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr) || 1513 skb->protocol != htons(ETH_P_IP)) 1514 goto e_inval; 1515 1516 if (ZERONET(saddr)) { 1517 if (!LOCAL_MCAST(daddr)) 1518 goto e_inval; 1519 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK); 1520 } else if (fib_validate_source(saddr, 0, tos, 0, 1521 dev, &spec_dst, &itag) < 0) 1522 goto e_inval; 1523 1524 rth = dst_alloc(&ipv4_dst_ops); 1525 if (!rth) 1526 goto e_nobufs; 1527 1528 rth->u.dst.output= ip_rt_bug; 1529 1530 atomic_set(&rth->u.dst.__refcnt, 1); 1531 rth->u.dst.flags= DST_HOST; 1532 if (IN_DEV_CONF_GET(in_dev, NOPOLICY)) 1533 rth->u.dst.flags |= DST_NOPOLICY; 1534 rth->fl.fl4_dst = daddr; 1535 rth->rt_dst = daddr; 1536 rth->fl.fl4_tos = tos; 1537 rth->fl.mark = skb->mark; 1538 rth->fl.fl4_src = saddr; 1539 rth->rt_src = saddr; 1540 #ifdef CONFIG_NET_CLS_ROUTE 1541 rth->u.dst.tclassid = itag; 1542 #endif 1543 rth->rt_iif = 1544 rth->fl.iif = dev->ifindex; 1545 rth->u.dst.dev = init_net.loopback_dev; 1546 dev_hold(rth->u.dst.dev); 1547 rth->idev = in_dev_get(rth->u.dst.dev); 1548 rth->fl.oif = 0; 1549 rth->rt_gateway = daddr; 1550 rth->rt_spec_dst= spec_dst; 1551 rth->rt_type = RTN_MULTICAST; 1552 rth->rt_flags = RTCF_MULTICAST; 1553 if (our) { 1554 rth->u.dst.input= ip_local_deliver; 1555 rth->rt_flags |= RTCF_LOCAL; 1556 } 1557 1558 #ifdef CONFIG_IP_MROUTE 1559 if (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev)) 1560 rth->u.dst.input = ip_mr_input; 1561 #endif 1562 RT_CACHE_STAT_INC(in_slow_mc); 1563 1564 in_dev_put(in_dev); 1565 hash = rt_hash(daddr, saddr, dev->ifindex); 1566 return rt_intern_hash(hash, rth, (struct rtable**) &skb->dst); 1567 1568 e_nobufs: 1569 in_dev_put(in_dev); 1570 return -ENOBUFS; 1571 1572 e_inval: 1573 in_dev_put(in_dev); 1574 return -EINVAL; 1575 } 1576 1577 1578 static void ip_handle_martian_source(struct net_device *dev, 1579 struct in_device *in_dev, 1580 struct sk_buff *skb, 1581 __be32 daddr, 1582 __be32 saddr) 1583 { 1584 RT_CACHE_STAT_INC(in_martian_src); 1585 #ifdef CONFIG_IP_ROUTE_VERBOSE 1586 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) { 1587 /* 1588 * RFC1812 recommendation, if source is martian, 1589 * the only hint is MAC header. 1590 */ 1591 printk(KERN_WARNING "martian source %u.%u.%u.%u from " 1592 "%u.%u.%u.%u, on dev %s\n", 1593 NIPQUAD(daddr), NIPQUAD(saddr), dev->name); 1594 if (dev->hard_header_len && skb_mac_header_was_set(skb)) { 1595 int i; 1596 const unsigned char *p = skb_mac_header(skb); 1597 printk(KERN_WARNING "ll header: "); 1598 for (i = 0; i < dev->hard_header_len; i++, p++) { 1599 printk("%02x", *p); 1600 if (i < (dev->hard_header_len - 1)) 1601 printk(":"); 1602 } 1603 printk("\n"); 1604 } 1605 } 1606 #endif 1607 } 1608 1609 static inline int __mkroute_input(struct sk_buff *skb, 1610 struct fib_result* res, 1611 struct in_device *in_dev, 1612 __be32 daddr, __be32 saddr, u32 tos, 1613 struct rtable **result) 1614 { 1615 1616 struct rtable *rth; 1617 int err; 1618 struct in_device *out_dev; 1619 unsigned flags = 0; 1620 __be32 spec_dst; 1621 u32 itag; 1622 1623 /* get a working reference to the output device */ 1624 out_dev = in_dev_get(FIB_RES_DEV(*res)); 1625 if (out_dev == NULL) { 1626 if (net_ratelimit()) 1627 printk(KERN_CRIT "Bug in ip_route_input" \ 1628 "_slow(). Please, report\n"); 1629 return -EINVAL; 1630 } 1631 1632 1633 err = fib_validate_source(saddr, daddr, tos, FIB_RES_OIF(*res), 1634 in_dev->dev, &spec_dst, &itag); 1635 if (err < 0) { 1636 ip_handle_martian_source(in_dev->dev, in_dev, skb, daddr, 1637 saddr); 1638 1639 err = -EINVAL; 1640 goto cleanup; 1641 } 1642 1643 if (err) 1644 flags |= RTCF_DIRECTSRC; 1645 1646 if (out_dev == in_dev && err && !(flags & (RTCF_NAT | RTCF_MASQ)) && 1647 (IN_DEV_SHARED_MEDIA(out_dev) || 1648 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res)))) 1649 flags |= RTCF_DOREDIRECT; 1650 1651 if (skb->protocol != htons(ETH_P_IP)) { 1652 /* Not IP (i.e. ARP). Do not create route, if it is 1653 * invalid for proxy arp. DNAT routes are always valid. 1654 */ 1655 if (out_dev == in_dev && !(flags & RTCF_DNAT)) { 1656 err = -EINVAL; 1657 goto cleanup; 1658 } 1659 } 1660 1661 1662 rth = dst_alloc(&ipv4_dst_ops); 1663 if (!rth) { 1664 err = -ENOBUFS; 1665 goto cleanup; 1666 } 1667 1668 atomic_set(&rth->u.dst.__refcnt, 1); 1669 rth->u.dst.flags= DST_HOST; 1670 if (IN_DEV_CONF_GET(in_dev, NOPOLICY)) 1671 rth->u.dst.flags |= DST_NOPOLICY; 1672 if (IN_DEV_CONF_GET(out_dev, NOXFRM)) 1673 rth->u.dst.flags |= DST_NOXFRM; 1674 rth->fl.fl4_dst = daddr; 1675 rth->rt_dst = daddr; 1676 rth->fl.fl4_tos = tos; 1677 rth->fl.mark = skb->mark; 1678 rth->fl.fl4_src = saddr; 1679 rth->rt_src = saddr; 1680 rth->rt_gateway = daddr; 1681 rth->rt_iif = 1682 rth->fl.iif = in_dev->dev->ifindex; 1683 rth->u.dst.dev = (out_dev)->dev; 1684 dev_hold(rth->u.dst.dev); 1685 rth->idev = in_dev_get(rth->u.dst.dev); 1686 rth->fl.oif = 0; 1687 rth->rt_spec_dst= spec_dst; 1688 1689 rth->u.dst.input = ip_forward; 1690 rth->u.dst.output = ip_output; 1691 1692 rt_set_nexthop(rth, res, itag); 1693 1694 rth->rt_flags = flags; 1695 1696 *result = rth; 1697 err = 0; 1698 cleanup: 1699 /* release the working reference to the output device */ 1700 in_dev_put(out_dev); 1701 return err; 1702 } 1703 1704 static inline int ip_mkroute_input(struct sk_buff *skb, 1705 struct fib_result* res, 1706 const struct flowi *fl, 1707 struct in_device *in_dev, 1708 __be32 daddr, __be32 saddr, u32 tos) 1709 { 1710 struct rtable* rth = NULL; 1711 int err; 1712 unsigned hash; 1713 1714 #ifdef CONFIG_IP_ROUTE_MULTIPATH 1715 if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0) 1716 fib_select_multipath(fl, res); 1717 #endif 1718 1719 /* create a routing cache entry */ 1720 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth); 1721 if (err) 1722 return err; 1723 1724 /* put it into the cache */ 1725 hash = rt_hash(daddr, saddr, fl->iif); 1726 return rt_intern_hash(hash, rth, (struct rtable**)&skb->dst); 1727 } 1728 1729 /* 1730 * NOTE. We drop all the packets that has local source 1731 * addresses, because every properly looped back packet 1732 * must have correct destination already attached by output routine. 1733 * 1734 * Such approach solves two big problems: 1735 * 1. Not simplex devices are handled properly. 1736 * 2. IP spoofing attempts are filtered with 100% of guarantee. 1737 */ 1738 1739 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr, 1740 u8 tos, struct net_device *dev) 1741 { 1742 struct fib_result res; 1743 struct in_device *in_dev = in_dev_get(dev); 1744 struct flowi fl = { .nl_u = { .ip4_u = 1745 { .daddr = daddr, 1746 .saddr = saddr, 1747 .tos = tos, 1748 .scope = RT_SCOPE_UNIVERSE, 1749 } }, 1750 .mark = skb->mark, 1751 .iif = dev->ifindex }; 1752 unsigned flags = 0; 1753 u32 itag = 0; 1754 struct rtable * rth; 1755 unsigned hash; 1756 __be32 spec_dst; 1757 int err = -EINVAL; 1758 int free_res = 0; 1759 1760 /* IP on this device is disabled. */ 1761 1762 if (!in_dev) 1763 goto out; 1764 1765 /* Check for the most weird martians, which can be not detected 1766 by fib_lookup. 1767 */ 1768 1769 if (MULTICAST(saddr) || BADCLASS(saddr) || LOOPBACK(saddr)) 1770 goto martian_source; 1771 1772 if (daddr == htonl(0xFFFFFFFF) || (saddr == 0 && daddr == 0)) 1773 goto brd_input; 1774 1775 /* Accept zero addresses only to limited broadcast; 1776 * I even do not know to fix it or not. Waiting for complains :-) 1777 */ 1778 if (ZERONET(saddr)) 1779 goto martian_source; 1780 1781 if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr)) 1782 goto martian_destination; 1783 1784 /* 1785 * Now we are ready to route packet. 1786 */ 1787 if ((err = fib_lookup(&fl, &res)) != 0) { 1788 if (!IN_DEV_FORWARD(in_dev)) 1789 goto e_hostunreach; 1790 goto no_route; 1791 } 1792 free_res = 1; 1793 1794 RT_CACHE_STAT_INC(in_slow_tot); 1795 1796 if (res.type == RTN_BROADCAST) 1797 goto brd_input; 1798 1799 if (res.type == RTN_LOCAL) { 1800 int result; 1801 result = fib_validate_source(saddr, daddr, tos, 1802 init_net.loopback_dev->ifindex, 1803 dev, &spec_dst, &itag); 1804 if (result < 0) 1805 goto martian_source; 1806 if (result) 1807 flags |= RTCF_DIRECTSRC; 1808 spec_dst = daddr; 1809 goto local_input; 1810 } 1811 1812 if (!IN_DEV_FORWARD(in_dev)) 1813 goto e_hostunreach; 1814 if (res.type != RTN_UNICAST) 1815 goto martian_destination; 1816 1817 err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos); 1818 done: 1819 in_dev_put(in_dev); 1820 if (free_res) 1821 fib_res_put(&res); 1822 out: return err; 1823 1824 brd_input: 1825 if (skb->protocol != htons(ETH_P_IP)) 1826 goto e_inval; 1827 1828 if (ZERONET(saddr)) 1829 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK); 1830 else { 1831 err = fib_validate_source(saddr, 0, tos, 0, dev, &spec_dst, 1832 &itag); 1833 if (err < 0) 1834 goto martian_source; 1835 if (err) 1836 flags |= RTCF_DIRECTSRC; 1837 } 1838 flags |= RTCF_BROADCAST; 1839 res.type = RTN_BROADCAST; 1840 RT_CACHE_STAT_INC(in_brd); 1841 1842 local_input: 1843 rth = dst_alloc(&ipv4_dst_ops); 1844 if (!rth) 1845 goto e_nobufs; 1846 1847 rth->u.dst.output= ip_rt_bug; 1848 1849 atomic_set(&rth->u.dst.__refcnt, 1); 1850 rth->u.dst.flags= DST_HOST; 1851 if (IN_DEV_CONF_GET(in_dev, NOPOLICY)) 1852 rth->u.dst.flags |= DST_NOPOLICY; 1853 rth->fl.fl4_dst = daddr; 1854 rth->rt_dst = daddr; 1855 rth->fl.fl4_tos = tos; 1856 rth->fl.mark = skb->mark; 1857 rth->fl.fl4_src = saddr; 1858 rth->rt_src = saddr; 1859 #ifdef CONFIG_NET_CLS_ROUTE 1860 rth->u.dst.tclassid = itag; 1861 #endif 1862 rth->rt_iif = 1863 rth->fl.iif = dev->ifindex; 1864 rth->u.dst.dev = init_net.loopback_dev; 1865 dev_hold(rth->u.dst.dev); 1866 rth->idev = in_dev_get(rth->u.dst.dev); 1867 rth->rt_gateway = daddr; 1868 rth->rt_spec_dst= spec_dst; 1869 rth->u.dst.input= ip_local_deliver; 1870 rth->rt_flags = flags|RTCF_LOCAL; 1871 if (res.type == RTN_UNREACHABLE) { 1872 rth->u.dst.input= ip_error; 1873 rth->u.dst.error= -err; 1874 rth->rt_flags &= ~RTCF_LOCAL; 1875 } 1876 rth->rt_type = res.type; 1877 hash = rt_hash(daddr, saddr, fl.iif); 1878 err = rt_intern_hash(hash, rth, (struct rtable**)&skb->dst); 1879 goto done; 1880 1881 no_route: 1882 RT_CACHE_STAT_INC(in_no_route); 1883 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE); 1884 res.type = RTN_UNREACHABLE; 1885 if (err == -ESRCH) 1886 err = -ENETUNREACH; 1887 goto local_input; 1888 1889 /* 1890 * Do not cache martian addresses: they should be logged (RFC1812) 1891 */ 1892 martian_destination: 1893 RT_CACHE_STAT_INC(in_martian_dst); 1894 #ifdef CONFIG_IP_ROUTE_VERBOSE 1895 if (IN_DEV_LOG_MARTIANS(in_dev) && net_ratelimit()) 1896 printk(KERN_WARNING "martian destination %u.%u.%u.%u from " 1897 "%u.%u.%u.%u, dev %s\n", 1898 NIPQUAD(daddr), NIPQUAD(saddr), dev->name); 1899 #endif 1900 1901 e_hostunreach: 1902 err = -EHOSTUNREACH; 1903 goto done; 1904 1905 e_inval: 1906 err = -EINVAL; 1907 goto done; 1908 1909 e_nobufs: 1910 err = -ENOBUFS; 1911 goto done; 1912 1913 martian_source: 1914 ip_handle_martian_source(dev, in_dev, skb, daddr, saddr); 1915 goto e_inval; 1916 } 1917 1918 int ip_route_input(struct sk_buff *skb, __be32 daddr, __be32 saddr, 1919 u8 tos, struct net_device *dev) 1920 { 1921 struct rtable * rth; 1922 unsigned hash; 1923 int iif = dev->ifindex; 1924 1925 tos &= IPTOS_RT_MASK; 1926 hash = rt_hash(daddr, saddr, iif); 1927 1928 rcu_read_lock(); 1929 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth; 1930 rth = rcu_dereference(rth->u.dst.rt_next)) { 1931 if (rth->fl.fl4_dst == daddr && 1932 rth->fl.fl4_src == saddr && 1933 rth->fl.iif == iif && 1934 rth->fl.oif == 0 && 1935 rth->fl.mark == skb->mark && 1936 rth->fl.fl4_tos == tos) { 1937 dst_use(&rth->u.dst, jiffies); 1938 RT_CACHE_STAT_INC(in_hit); 1939 rcu_read_unlock(); 1940 skb->dst = (struct dst_entry*)rth; 1941 return 0; 1942 } 1943 RT_CACHE_STAT_INC(in_hlist_search); 1944 } 1945 rcu_read_unlock(); 1946 1947 /* Multicast recognition logic is moved from route cache to here. 1948 The problem was that too many Ethernet cards have broken/missing 1949 hardware multicast filters :-( As result the host on multicasting 1950 network acquires a lot of useless route cache entries, sort of 1951 SDR messages from all the world. Now we try to get rid of them. 1952 Really, provided software IP multicast filter is organized 1953 reasonably (at least, hashed), it does not result in a slowdown 1954 comparing with route cache reject entries. 1955 Note, that multicast routers are not affected, because 1956 route cache entry is created eventually. 1957 */ 1958 if (MULTICAST(daddr)) { 1959 struct in_device *in_dev; 1960 1961 rcu_read_lock(); 1962 if ((in_dev = __in_dev_get_rcu(dev)) != NULL) { 1963 int our = ip_check_mc(in_dev, daddr, saddr, 1964 ip_hdr(skb)->protocol); 1965 if (our 1966 #ifdef CONFIG_IP_MROUTE 1967 || (!LOCAL_MCAST(daddr) && IN_DEV_MFORWARD(in_dev)) 1968 #endif 1969 ) { 1970 rcu_read_unlock(); 1971 return ip_route_input_mc(skb, daddr, saddr, 1972 tos, dev, our); 1973 } 1974 } 1975 rcu_read_unlock(); 1976 return -EINVAL; 1977 } 1978 return ip_route_input_slow(skb, daddr, saddr, tos, dev); 1979 } 1980 1981 static inline int __mkroute_output(struct rtable **result, 1982 struct fib_result* res, 1983 const struct flowi *fl, 1984 const struct flowi *oldflp, 1985 struct net_device *dev_out, 1986 unsigned flags) 1987 { 1988 struct rtable *rth; 1989 struct in_device *in_dev; 1990 u32 tos = RT_FL_TOS(oldflp); 1991 int err = 0; 1992 1993 if (LOOPBACK(fl->fl4_src) && !(dev_out->flags&IFF_LOOPBACK)) 1994 return -EINVAL; 1995 1996 if (fl->fl4_dst == htonl(0xFFFFFFFF)) 1997 res->type = RTN_BROADCAST; 1998 else if (MULTICAST(fl->fl4_dst)) 1999 res->type = RTN_MULTICAST; 2000 else if (BADCLASS(fl->fl4_dst) || ZERONET(fl->fl4_dst)) 2001 return -EINVAL; 2002 2003 if (dev_out->flags & IFF_LOOPBACK) 2004 flags |= RTCF_LOCAL; 2005 2006 /* get work reference to inet device */ 2007 in_dev = in_dev_get(dev_out); 2008 if (!in_dev) 2009 return -EINVAL; 2010 2011 if (res->type == RTN_BROADCAST) { 2012 flags |= RTCF_BROADCAST | RTCF_LOCAL; 2013 if (res->fi) { 2014 fib_info_put(res->fi); 2015 res->fi = NULL; 2016 } 2017 } else if (res->type == RTN_MULTICAST) { 2018 flags |= RTCF_MULTICAST|RTCF_LOCAL; 2019 if (!ip_check_mc(in_dev, oldflp->fl4_dst, oldflp->fl4_src, 2020 oldflp->proto)) 2021 flags &= ~RTCF_LOCAL; 2022 /* If multicast route do not exist use 2023 default one, but do not gateway in this case. 2024 Yes, it is hack. 2025 */ 2026 if (res->fi && res->prefixlen < 4) { 2027 fib_info_put(res->fi); 2028 res->fi = NULL; 2029 } 2030 } 2031 2032 2033 rth = dst_alloc(&ipv4_dst_ops); 2034 if (!rth) { 2035 err = -ENOBUFS; 2036 goto cleanup; 2037 } 2038 2039 atomic_set(&rth->u.dst.__refcnt, 1); 2040 rth->u.dst.flags= DST_HOST; 2041 if (IN_DEV_CONF_GET(in_dev, NOXFRM)) 2042 rth->u.dst.flags |= DST_NOXFRM; 2043 if (IN_DEV_CONF_GET(in_dev, NOPOLICY)) 2044 rth->u.dst.flags |= DST_NOPOLICY; 2045 2046 rth->fl.fl4_dst = oldflp->fl4_dst; 2047 rth->fl.fl4_tos = tos; 2048 rth->fl.fl4_src = oldflp->fl4_src; 2049 rth->fl.oif = oldflp->oif; 2050 rth->fl.mark = oldflp->mark; 2051 rth->rt_dst = fl->fl4_dst; 2052 rth->rt_src = fl->fl4_src; 2053 rth->rt_iif = oldflp->oif ? : dev_out->ifindex; 2054 /* get references to the devices that are to be hold by the routing 2055 cache entry */ 2056 rth->u.dst.dev = dev_out; 2057 dev_hold(dev_out); 2058 rth->idev = in_dev_get(dev_out); 2059 rth->rt_gateway = fl->fl4_dst; 2060 rth->rt_spec_dst= fl->fl4_src; 2061 2062 rth->u.dst.output=ip_output; 2063 2064 RT_CACHE_STAT_INC(out_slow_tot); 2065 2066 if (flags & RTCF_LOCAL) { 2067 rth->u.dst.input = ip_local_deliver; 2068 rth->rt_spec_dst = fl->fl4_dst; 2069 } 2070 if (flags & (RTCF_BROADCAST | RTCF_MULTICAST)) { 2071 rth->rt_spec_dst = fl->fl4_src; 2072 if (flags & RTCF_LOCAL && 2073 !(dev_out->flags & IFF_LOOPBACK)) { 2074 rth->u.dst.output = ip_mc_output; 2075 RT_CACHE_STAT_INC(out_slow_mc); 2076 } 2077 #ifdef CONFIG_IP_MROUTE 2078 if (res->type == RTN_MULTICAST) { 2079 if (IN_DEV_MFORWARD(in_dev) && 2080 !LOCAL_MCAST(oldflp->fl4_dst)) { 2081 rth->u.dst.input = ip_mr_input; 2082 rth->u.dst.output = ip_mc_output; 2083 } 2084 } 2085 #endif 2086 } 2087 2088 rt_set_nexthop(rth, res, 0); 2089 2090 rth->rt_flags = flags; 2091 2092 *result = rth; 2093 cleanup: 2094 /* release work reference to inet device */ 2095 in_dev_put(in_dev); 2096 2097 return err; 2098 } 2099 2100 static inline int ip_mkroute_output(struct rtable **rp, 2101 struct fib_result* res, 2102 const struct flowi *fl, 2103 const struct flowi *oldflp, 2104 struct net_device *dev_out, 2105 unsigned flags) 2106 { 2107 struct rtable *rth = NULL; 2108 int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags); 2109 unsigned hash; 2110 if (err == 0) { 2111 hash = rt_hash(oldflp->fl4_dst, oldflp->fl4_src, oldflp->oif); 2112 err = rt_intern_hash(hash, rth, rp); 2113 } 2114 2115 return err; 2116 } 2117 2118 /* 2119 * Major route resolver routine. 2120 */ 2121 2122 static int ip_route_output_slow(struct rtable **rp, const struct flowi *oldflp) 2123 { 2124 u32 tos = RT_FL_TOS(oldflp); 2125 struct flowi fl = { .nl_u = { .ip4_u = 2126 { .daddr = oldflp->fl4_dst, 2127 .saddr = oldflp->fl4_src, 2128 .tos = tos & IPTOS_RT_MASK, 2129 .scope = ((tos & RTO_ONLINK) ? 2130 RT_SCOPE_LINK : 2131 RT_SCOPE_UNIVERSE), 2132 } }, 2133 .mark = oldflp->mark, 2134 .iif = init_net.loopback_dev->ifindex, 2135 .oif = oldflp->oif }; 2136 struct fib_result res; 2137 unsigned flags = 0; 2138 struct net_device *dev_out = NULL; 2139 int free_res = 0; 2140 int err; 2141 2142 2143 res.fi = NULL; 2144 #ifdef CONFIG_IP_MULTIPLE_TABLES 2145 res.r = NULL; 2146 #endif 2147 2148 if (oldflp->fl4_src) { 2149 err = -EINVAL; 2150 if (MULTICAST(oldflp->fl4_src) || 2151 BADCLASS(oldflp->fl4_src) || 2152 ZERONET(oldflp->fl4_src)) 2153 goto out; 2154 2155 /* It is equivalent to inet_addr_type(saddr) == RTN_LOCAL */ 2156 dev_out = ip_dev_find(oldflp->fl4_src); 2157 if (dev_out == NULL) 2158 goto out; 2159 2160 /* I removed check for oif == dev_out->oif here. 2161 It was wrong for two reasons: 2162 1. ip_dev_find(saddr) can return wrong iface, if saddr is 2163 assigned to multiple interfaces. 2164 2. Moreover, we are allowed to send packets with saddr 2165 of another iface. --ANK 2166 */ 2167 2168 if (oldflp->oif == 0 2169 && (MULTICAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF))) { 2170 /* Special hack: user can direct multicasts 2171 and limited broadcast via necessary interface 2172 without fiddling with IP_MULTICAST_IF or IP_PKTINFO. 2173 This hack is not just for fun, it allows 2174 vic,vat and friends to work. 2175 They bind socket to loopback, set ttl to zero 2176 and expect that it will work. 2177 From the viewpoint of routing cache they are broken, 2178 because we are not allowed to build multicast path 2179 with loopback source addr (look, routing cache 2180 cannot know, that ttl is zero, so that packet 2181 will not leave this host and route is valid). 2182 Luckily, this hack is good workaround. 2183 */ 2184 2185 fl.oif = dev_out->ifindex; 2186 goto make_route; 2187 } 2188 if (dev_out) 2189 dev_put(dev_out); 2190 dev_out = NULL; 2191 } 2192 2193 2194 if (oldflp->oif) { 2195 dev_out = dev_get_by_index(&init_net, oldflp->oif); 2196 err = -ENODEV; 2197 if (dev_out == NULL) 2198 goto out; 2199 2200 /* RACE: Check return value of inet_select_addr instead. */ 2201 if (__in_dev_get_rtnl(dev_out) == NULL) { 2202 dev_put(dev_out); 2203 goto out; /* Wrong error code */ 2204 } 2205 2206 if (LOCAL_MCAST(oldflp->fl4_dst) || oldflp->fl4_dst == htonl(0xFFFFFFFF)) { 2207 if (!fl.fl4_src) 2208 fl.fl4_src = inet_select_addr(dev_out, 0, 2209 RT_SCOPE_LINK); 2210 goto make_route; 2211 } 2212 if (!fl.fl4_src) { 2213 if (MULTICAST(oldflp->fl4_dst)) 2214 fl.fl4_src = inet_select_addr(dev_out, 0, 2215 fl.fl4_scope); 2216 else if (!oldflp->fl4_dst) 2217 fl.fl4_src = inet_select_addr(dev_out, 0, 2218 RT_SCOPE_HOST); 2219 } 2220 } 2221 2222 if (!fl.fl4_dst) { 2223 fl.fl4_dst = fl.fl4_src; 2224 if (!fl.fl4_dst) 2225 fl.fl4_dst = fl.fl4_src = htonl(INADDR_LOOPBACK); 2226 if (dev_out) 2227 dev_put(dev_out); 2228 dev_out = init_net.loopback_dev; 2229 dev_hold(dev_out); 2230 fl.oif = init_net.loopback_dev->ifindex; 2231 res.type = RTN_LOCAL; 2232 flags |= RTCF_LOCAL; 2233 goto make_route; 2234 } 2235 2236 if (fib_lookup(&fl, &res)) { 2237 res.fi = NULL; 2238 if (oldflp->oif) { 2239 /* Apparently, routing tables are wrong. Assume, 2240 that the destination is on link. 2241 2242 WHY? DW. 2243 Because we are allowed to send to iface 2244 even if it has NO routes and NO assigned 2245 addresses. When oif is specified, routing 2246 tables are looked up with only one purpose: 2247 to catch if destination is gatewayed, rather than 2248 direct. Moreover, if MSG_DONTROUTE is set, 2249 we send packet, ignoring both routing tables 2250 and ifaddr state. --ANK 2251 2252 2253 We could make it even if oif is unknown, 2254 likely IPv6, but we do not. 2255 */ 2256 2257 if (fl.fl4_src == 0) 2258 fl.fl4_src = inet_select_addr(dev_out, 0, 2259 RT_SCOPE_LINK); 2260 res.type = RTN_UNICAST; 2261 goto make_route; 2262 } 2263 if (dev_out) 2264 dev_put(dev_out); 2265 err = -ENETUNREACH; 2266 goto out; 2267 } 2268 free_res = 1; 2269 2270 if (res.type == RTN_LOCAL) { 2271 if (!fl.fl4_src) 2272 fl.fl4_src = fl.fl4_dst; 2273 if (dev_out) 2274 dev_put(dev_out); 2275 dev_out = init_net.loopback_dev; 2276 dev_hold(dev_out); 2277 fl.oif = dev_out->ifindex; 2278 if (res.fi) 2279 fib_info_put(res.fi); 2280 res.fi = NULL; 2281 flags |= RTCF_LOCAL; 2282 goto make_route; 2283 } 2284 2285 #ifdef CONFIG_IP_ROUTE_MULTIPATH 2286 if (res.fi->fib_nhs > 1 && fl.oif == 0) 2287 fib_select_multipath(&fl, &res); 2288 else 2289 #endif 2290 if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif) 2291 fib_select_default(&fl, &res); 2292 2293 if (!fl.fl4_src) 2294 fl.fl4_src = FIB_RES_PREFSRC(res); 2295 2296 if (dev_out) 2297 dev_put(dev_out); 2298 dev_out = FIB_RES_DEV(res); 2299 dev_hold(dev_out); 2300 fl.oif = dev_out->ifindex; 2301 2302 2303 make_route: 2304 err = ip_mkroute_output(rp, &res, &fl, oldflp, dev_out, flags); 2305 2306 2307 if (free_res) 2308 fib_res_put(&res); 2309 if (dev_out) 2310 dev_put(dev_out); 2311 out: return err; 2312 } 2313 2314 int __ip_route_output_key(struct rtable **rp, const struct flowi *flp) 2315 { 2316 unsigned hash; 2317 struct rtable *rth; 2318 2319 hash = rt_hash(flp->fl4_dst, flp->fl4_src, flp->oif); 2320 2321 rcu_read_lock_bh(); 2322 for (rth = rcu_dereference(rt_hash_table[hash].chain); rth; 2323 rth = rcu_dereference(rth->u.dst.rt_next)) { 2324 if (rth->fl.fl4_dst == flp->fl4_dst && 2325 rth->fl.fl4_src == flp->fl4_src && 2326 rth->fl.iif == 0 && 2327 rth->fl.oif == flp->oif && 2328 rth->fl.mark == flp->mark && 2329 !((rth->fl.fl4_tos ^ flp->fl4_tos) & 2330 (IPTOS_RT_MASK | RTO_ONLINK))) { 2331 dst_use(&rth->u.dst, jiffies); 2332 RT_CACHE_STAT_INC(out_hit); 2333 rcu_read_unlock_bh(); 2334 *rp = rth; 2335 return 0; 2336 } 2337 RT_CACHE_STAT_INC(out_hlist_search); 2338 } 2339 rcu_read_unlock_bh(); 2340 2341 return ip_route_output_slow(rp, flp); 2342 } 2343 2344 EXPORT_SYMBOL_GPL(__ip_route_output_key); 2345 2346 static void ipv4_rt_blackhole_update_pmtu(struct dst_entry *dst, u32 mtu) 2347 { 2348 } 2349 2350 static struct dst_ops ipv4_dst_blackhole_ops = { 2351 .family = AF_INET, 2352 .protocol = __constant_htons(ETH_P_IP), 2353 .destroy = ipv4_dst_destroy, 2354 .check = ipv4_dst_check, 2355 .update_pmtu = ipv4_rt_blackhole_update_pmtu, 2356 .entry_size = sizeof(struct rtable), 2357 }; 2358 2359 2360 static int ipv4_blackhole_output(struct sk_buff *skb) 2361 { 2362 kfree_skb(skb); 2363 return 0; 2364 } 2365 2366 static int ipv4_dst_blackhole(struct rtable **rp, struct flowi *flp, struct sock *sk) 2367 { 2368 struct rtable *ort = *rp; 2369 struct rtable *rt = (struct rtable *) 2370 dst_alloc(&ipv4_dst_blackhole_ops); 2371 2372 if (rt) { 2373 struct dst_entry *new = &rt->u.dst; 2374 2375 atomic_set(&new->__refcnt, 1); 2376 new->__use = 1; 2377 new->input = ipv4_blackhole_output; 2378 new->output = ipv4_blackhole_output; 2379 memcpy(new->metrics, ort->u.dst.metrics, RTAX_MAX*sizeof(u32)); 2380 2381 new->dev = ort->u.dst.dev; 2382 if (new->dev) 2383 dev_hold(new->dev); 2384 2385 rt->fl = ort->fl; 2386 2387 rt->idev = ort->idev; 2388 if (rt->idev) 2389 in_dev_hold(rt->idev); 2390 rt->rt_flags = ort->rt_flags; 2391 rt->rt_type = ort->rt_type; 2392 rt->rt_dst = ort->rt_dst; 2393 rt->rt_src = ort->rt_src; 2394 rt->rt_iif = ort->rt_iif; 2395 rt->rt_gateway = ort->rt_gateway; 2396 rt->rt_spec_dst = ort->rt_spec_dst; 2397 rt->peer = ort->peer; 2398 if (rt->peer) 2399 atomic_inc(&rt->peer->refcnt); 2400 2401 dst_free(new); 2402 } 2403 2404 dst_release(&(*rp)->u.dst); 2405 *rp = rt; 2406 return (rt ? 0 : -ENOMEM); 2407 } 2408 2409 int ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags) 2410 { 2411 int err; 2412 2413 if ((err = __ip_route_output_key(rp, flp)) != 0) 2414 return err; 2415 2416 if (flp->proto) { 2417 if (!flp->fl4_src) 2418 flp->fl4_src = (*rp)->rt_src; 2419 if (!flp->fl4_dst) 2420 flp->fl4_dst = (*rp)->rt_dst; 2421 err = __xfrm_lookup((struct dst_entry **)rp, flp, sk, flags); 2422 if (err == -EREMOTE) 2423 err = ipv4_dst_blackhole(rp, flp, sk); 2424 2425 return err; 2426 } 2427 2428 return 0; 2429 } 2430 2431 EXPORT_SYMBOL_GPL(ip_route_output_flow); 2432 2433 int ip_route_output_key(struct rtable **rp, struct flowi *flp) 2434 { 2435 return ip_route_output_flow(rp, flp, NULL, 0); 2436 } 2437 2438 static int rt_fill_info(struct sk_buff *skb, u32 pid, u32 seq, int event, 2439 int nowait, unsigned int flags) 2440 { 2441 struct rtable *rt = (struct rtable*)skb->dst; 2442 struct rtmsg *r; 2443 struct nlmsghdr *nlh; 2444 long expires; 2445 u32 id = 0, ts = 0, tsage = 0, error; 2446 2447 nlh = nlmsg_put(skb, pid, seq, event, sizeof(*r), flags); 2448 if (nlh == NULL) 2449 return -EMSGSIZE; 2450 2451 r = nlmsg_data(nlh); 2452 r->rtm_family = AF_INET; 2453 r->rtm_dst_len = 32; 2454 r->rtm_src_len = 0; 2455 r->rtm_tos = rt->fl.fl4_tos; 2456 r->rtm_table = RT_TABLE_MAIN; 2457 NLA_PUT_U32(skb, RTA_TABLE, RT_TABLE_MAIN); 2458 r->rtm_type = rt->rt_type; 2459 r->rtm_scope = RT_SCOPE_UNIVERSE; 2460 r->rtm_protocol = RTPROT_UNSPEC; 2461 r->rtm_flags = (rt->rt_flags & ~0xFFFF) | RTM_F_CLONED; 2462 if (rt->rt_flags & RTCF_NOTIFY) 2463 r->rtm_flags |= RTM_F_NOTIFY; 2464 2465 NLA_PUT_BE32(skb, RTA_DST, rt->rt_dst); 2466 2467 if (rt->fl.fl4_src) { 2468 r->rtm_src_len = 32; 2469 NLA_PUT_BE32(skb, RTA_SRC, rt->fl.fl4_src); 2470 } 2471 if (rt->u.dst.dev) 2472 NLA_PUT_U32(skb, RTA_OIF, rt->u.dst.dev->ifindex); 2473 #ifdef CONFIG_NET_CLS_ROUTE 2474 if (rt->u.dst.tclassid) 2475 NLA_PUT_U32(skb, RTA_FLOW, rt->u.dst.tclassid); 2476 #endif 2477 if (rt->fl.iif) 2478 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_spec_dst); 2479 else if (rt->rt_src != rt->fl.fl4_src) 2480 NLA_PUT_BE32(skb, RTA_PREFSRC, rt->rt_src); 2481 2482 if (rt->rt_dst != rt->rt_gateway) 2483 NLA_PUT_BE32(skb, RTA_GATEWAY, rt->rt_gateway); 2484 2485 if (rtnetlink_put_metrics(skb, rt->u.dst.metrics) < 0) 2486 goto nla_put_failure; 2487 2488 error = rt->u.dst.error; 2489 expires = rt->u.dst.expires ? rt->u.dst.expires - jiffies : 0; 2490 if (rt->peer) { 2491 id = rt->peer->ip_id_count; 2492 if (rt->peer->tcp_ts_stamp) { 2493 ts = rt->peer->tcp_ts; 2494 tsage = get_seconds() - rt->peer->tcp_ts_stamp; 2495 } 2496 } 2497 2498 if (rt->fl.iif) { 2499 #ifdef CONFIG_IP_MROUTE 2500 __be32 dst = rt->rt_dst; 2501 2502 if (MULTICAST(dst) && !LOCAL_MCAST(dst) && 2503 IPV4_DEVCONF_ALL(MC_FORWARDING)) { 2504 int err = ipmr_get_route(skb, r, nowait); 2505 if (err <= 0) { 2506 if (!nowait) { 2507 if (err == 0) 2508 return 0; 2509 goto nla_put_failure; 2510 } else { 2511 if (err == -EMSGSIZE) 2512 goto nla_put_failure; 2513 error = err; 2514 } 2515 } 2516 } else 2517 #endif 2518 NLA_PUT_U32(skb, RTA_IIF, rt->fl.iif); 2519 } 2520 2521 if (rtnl_put_cacheinfo(skb, &rt->u.dst, id, ts, tsage, 2522 expires, error) < 0) 2523 goto nla_put_failure; 2524 2525 return nlmsg_end(skb, nlh); 2526 2527 nla_put_failure: 2528 nlmsg_cancel(skb, nlh); 2529 return -EMSGSIZE; 2530 } 2531 2532 static int inet_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr* nlh, void *arg) 2533 { 2534 struct rtmsg *rtm; 2535 struct nlattr *tb[RTA_MAX+1]; 2536 struct rtable *rt = NULL; 2537 __be32 dst = 0; 2538 __be32 src = 0; 2539 u32 iif; 2540 int err; 2541 struct sk_buff *skb; 2542 2543 err = nlmsg_parse(nlh, sizeof(*rtm), tb, RTA_MAX, rtm_ipv4_policy); 2544 if (err < 0) 2545 goto errout; 2546 2547 rtm = nlmsg_data(nlh); 2548 2549 skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); 2550 if (skb == NULL) { 2551 err = -ENOBUFS; 2552 goto errout; 2553 } 2554 2555 /* Reserve room for dummy headers, this skb can pass 2556 through good chunk of routing engine. 2557 */ 2558 skb_reset_mac_header(skb); 2559 skb_reset_network_header(skb); 2560 2561 /* Bugfix: need to give ip_route_input enough of an IP header to not gag. */ 2562 ip_hdr(skb)->protocol = IPPROTO_ICMP; 2563 skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr)); 2564 2565 src = tb[RTA_SRC] ? nla_get_be32(tb[RTA_SRC]) : 0; 2566 dst = tb[RTA_DST] ? nla_get_be32(tb[RTA_DST]) : 0; 2567 iif = tb[RTA_IIF] ? nla_get_u32(tb[RTA_IIF]) : 0; 2568 2569 if (iif) { 2570 struct net_device *dev; 2571 2572 dev = __dev_get_by_index(&init_net, iif); 2573 if (dev == NULL) { 2574 err = -ENODEV; 2575 goto errout_free; 2576 } 2577 2578 skb->protocol = htons(ETH_P_IP); 2579 skb->dev = dev; 2580 local_bh_disable(); 2581 err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev); 2582 local_bh_enable(); 2583 2584 rt = (struct rtable*) skb->dst; 2585 if (err == 0 && rt->u.dst.error) 2586 err = -rt->u.dst.error; 2587 } else { 2588 struct flowi fl = { 2589 .nl_u = { 2590 .ip4_u = { 2591 .daddr = dst, 2592 .saddr = src, 2593 .tos = rtm->rtm_tos, 2594 }, 2595 }, 2596 .oif = tb[RTA_OIF] ? nla_get_u32(tb[RTA_OIF]) : 0, 2597 }; 2598 err = ip_route_output_key(&rt, &fl); 2599 } 2600 2601 if (err) 2602 goto errout_free; 2603 2604 skb->dst = &rt->u.dst; 2605 if (rtm->rtm_flags & RTM_F_NOTIFY) 2606 rt->rt_flags |= RTCF_NOTIFY; 2607 2608 err = rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq, 2609 RTM_NEWROUTE, 0, 0); 2610 if (err <= 0) 2611 goto errout_free; 2612 2613 err = rtnl_unicast(skb, NETLINK_CB(in_skb).pid); 2614 errout: 2615 return err; 2616 2617 errout_free: 2618 kfree_skb(skb); 2619 goto errout; 2620 } 2621 2622 int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb) 2623 { 2624 struct rtable *rt; 2625 int h, s_h; 2626 int idx, s_idx; 2627 2628 s_h = cb->args[0]; 2629 if (s_h < 0) 2630 s_h = 0; 2631 s_idx = idx = cb->args[1]; 2632 for (h = s_h; h <= rt_hash_mask; h++) { 2633 rcu_read_lock_bh(); 2634 for (rt = rcu_dereference(rt_hash_table[h].chain), idx = 0; rt; 2635 rt = rcu_dereference(rt->u.dst.rt_next), idx++) { 2636 if (idx < s_idx) 2637 continue; 2638 skb->dst = dst_clone(&rt->u.dst); 2639 if (rt_fill_info(skb, NETLINK_CB(cb->skb).pid, 2640 cb->nlh->nlmsg_seq, RTM_NEWROUTE, 2641 1, NLM_F_MULTI) <= 0) { 2642 dst_release(xchg(&skb->dst, NULL)); 2643 rcu_read_unlock_bh(); 2644 goto done; 2645 } 2646 dst_release(xchg(&skb->dst, NULL)); 2647 } 2648 rcu_read_unlock_bh(); 2649 s_idx = 0; 2650 } 2651 2652 done: 2653 cb->args[0] = h; 2654 cb->args[1] = idx; 2655 return skb->len; 2656 } 2657 2658 void ip_rt_multicast_event(struct in_device *in_dev) 2659 { 2660 rt_cache_flush(0); 2661 } 2662 2663 #ifdef CONFIG_SYSCTL 2664 static int flush_delay; 2665 2666 static int ipv4_sysctl_rtcache_flush(ctl_table *ctl, int write, 2667 struct file *filp, void __user *buffer, 2668 size_t *lenp, loff_t *ppos) 2669 { 2670 if (write) { 2671 proc_dointvec(ctl, write, filp, buffer, lenp, ppos); 2672 rt_cache_flush(flush_delay); 2673 return 0; 2674 } 2675 2676 return -EINVAL; 2677 } 2678 2679 static int ipv4_sysctl_rtcache_flush_strategy(ctl_table *table, 2680 int __user *name, 2681 int nlen, 2682 void __user *oldval, 2683 size_t __user *oldlenp, 2684 void __user *newval, 2685 size_t newlen) 2686 { 2687 int delay; 2688 if (newlen != sizeof(int)) 2689 return -EINVAL; 2690 if (get_user(delay, (int __user *)newval)) 2691 return -EFAULT; 2692 rt_cache_flush(delay); 2693 return 0; 2694 } 2695 2696 ctl_table ipv4_route_table[] = { 2697 { 2698 .ctl_name = NET_IPV4_ROUTE_FLUSH, 2699 .procname = "flush", 2700 .data = &flush_delay, 2701 .maxlen = sizeof(int), 2702 .mode = 0200, 2703 .proc_handler = &ipv4_sysctl_rtcache_flush, 2704 .strategy = &ipv4_sysctl_rtcache_flush_strategy, 2705 }, 2706 { 2707 .ctl_name = NET_IPV4_ROUTE_MIN_DELAY, 2708 .procname = "min_delay", 2709 .data = &ip_rt_min_delay, 2710 .maxlen = sizeof(int), 2711 .mode = 0644, 2712 .proc_handler = &proc_dointvec_jiffies, 2713 .strategy = &sysctl_jiffies, 2714 }, 2715 { 2716 .ctl_name = NET_IPV4_ROUTE_MAX_DELAY, 2717 .procname = "max_delay", 2718 .data = &ip_rt_max_delay, 2719 .maxlen = sizeof(int), 2720 .mode = 0644, 2721 .proc_handler = &proc_dointvec_jiffies, 2722 .strategy = &sysctl_jiffies, 2723 }, 2724 { 2725 .ctl_name = NET_IPV4_ROUTE_GC_THRESH, 2726 .procname = "gc_thresh", 2727 .data = &ipv4_dst_ops.gc_thresh, 2728 .maxlen = sizeof(int), 2729 .mode = 0644, 2730 .proc_handler = &proc_dointvec, 2731 }, 2732 { 2733 .ctl_name = NET_IPV4_ROUTE_MAX_SIZE, 2734 .procname = "max_size", 2735 .data = &ip_rt_max_size, 2736 .maxlen = sizeof(int), 2737 .mode = 0644, 2738 .proc_handler = &proc_dointvec, 2739 }, 2740 { 2741 /* Deprecated. Use gc_min_interval_ms */ 2742 2743 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL, 2744 .procname = "gc_min_interval", 2745 .data = &ip_rt_gc_min_interval, 2746 .maxlen = sizeof(int), 2747 .mode = 0644, 2748 .proc_handler = &proc_dointvec_jiffies, 2749 .strategy = &sysctl_jiffies, 2750 }, 2751 { 2752 .ctl_name = NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS, 2753 .procname = "gc_min_interval_ms", 2754 .data = &ip_rt_gc_min_interval, 2755 .maxlen = sizeof(int), 2756 .mode = 0644, 2757 .proc_handler = &proc_dointvec_ms_jiffies, 2758 .strategy = &sysctl_ms_jiffies, 2759 }, 2760 { 2761 .ctl_name = NET_IPV4_ROUTE_GC_TIMEOUT, 2762 .procname = "gc_timeout", 2763 .data = &ip_rt_gc_timeout, 2764 .maxlen = sizeof(int), 2765 .mode = 0644, 2766 .proc_handler = &proc_dointvec_jiffies, 2767 .strategy = &sysctl_jiffies, 2768 }, 2769 { 2770 .ctl_name = NET_IPV4_ROUTE_GC_INTERVAL, 2771 .procname = "gc_interval", 2772 .data = &ip_rt_gc_interval, 2773 .maxlen = sizeof(int), 2774 .mode = 0644, 2775 .proc_handler = &proc_dointvec_jiffies, 2776 .strategy = &sysctl_jiffies, 2777 }, 2778 { 2779 .ctl_name = NET_IPV4_ROUTE_REDIRECT_LOAD, 2780 .procname = "redirect_load", 2781 .data = &ip_rt_redirect_load, 2782 .maxlen = sizeof(int), 2783 .mode = 0644, 2784 .proc_handler = &proc_dointvec, 2785 }, 2786 { 2787 .ctl_name = NET_IPV4_ROUTE_REDIRECT_NUMBER, 2788 .procname = "redirect_number", 2789 .data = &ip_rt_redirect_number, 2790 .maxlen = sizeof(int), 2791 .mode = 0644, 2792 .proc_handler = &proc_dointvec, 2793 }, 2794 { 2795 .ctl_name = NET_IPV4_ROUTE_REDIRECT_SILENCE, 2796 .procname = "redirect_silence", 2797 .data = &ip_rt_redirect_silence, 2798 .maxlen = sizeof(int), 2799 .mode = 0644, 2800 .proc_handler = &proc_dointvec, 2801 }, 2802 { 2803 .ctl_name = NET_IPV4_ROUTE_ERROR_COST, 2804 .procname = "error_cost", 2805 .data = &ip_rt_error_cost, 2806 .maxlen = sizeof(int), 2807 .mode = 0644, 2808 .proc_handler = &proc_dointvec, 2809 }, 2810 { 2811 .ctl_name = NET_IPV4_ROUTE_ERROR_BURST, 2812 .procname = "error_burst", 2813 .data = &ip_rt_error_burst, 2814 .maxlen = sizeof(int), 2815 .mode = 0644, 2816 .proc_handler = &proc_dointvec, 2817 }, 2818 { 2819 .ctl_name = NET_IPV4_ROUTE_GC_ELASTICITY, 2820 .procname = "gc_elasticity", 2821 .data = &ip_rt_gc_elasticity, 2822 .maxlen = sizeof(int), 2823 .mode = 0644, 2824 .proc_handler = &proc_dointvec, 2825 }, 2826 { 2827 .ctl_name = NET_IPV4_ROUTE_MTU_EXPIRES, 2828 .procname = "mtu_expires", 2829 .data = &ip_rt_mtu_expires, 2830 .maxlen = sizeof(int), 2831 .mode = 0644, 2832 .proc_handler = &proc_dointvec_jiffies, 2833 .strategy = &sysctl_jiffies, 2834 }, 2835 { 2836 .ctl_name = NET_IPV4_ROUTE_MIN_PMTU, 2837 .procname = "min_pmtu", 2838 .data = &ip_rt_min_pmtu, 2839 .maxlen = sizeof(int), 2840 .mode = 0644, 2841 .proc_handler = &proc_dointvec, 2842 }, 2843 { 2844 .ctl_name = NET_IPV4_ROUTE_MIN_ADVMSS, 2845 .procname = "min_adv_mss", 2846 .data = &ip_rt_min_advmss, 2847 .maxlen = sizeof(int), 2848 .mode = 0644, 2849 .proc_handler = &proc_dointvec, 2850 }, 2851 { 2852 .ctl_name = NET_IPV4_ROUTE_SECRET_INTERVAL, 2853 .procname = "secret_interval", 2854 .data = &ip_rt_secret_interval, 2855 .maxlen = sizeof(int), 2856 .mode = 0644, 2857 .proc_handler = &proc_dointvec_jiffies, 2858 .strategy = &sysctl_jiffies, 2859 }, 2860 { .ctl_name = 0 } 2861 }; 2862 #endif 2863 2864 #ifdef CONFIG_NET_CLS_ROUTE 2865 struct ip_rt_acct *ip_rt_acct; 2866 2867 /* This code sucks. But you should have seen it before! --RR */ 2868 2869 /* IP route accounting ptr for this logical cpu number. */ 2870 #define IP_RT_ACCT_CPU(i) (ip_rt_acct + i * 256) 2871 2872 #ifdef CONFIG_PROC_FS 2873 static int ip_rt_acct_read(char *buffer, char **start, off_t offset, 2874 int length, int *eof, void *data) 2875 { 2876 unsigned int i; 2877 2878 if ((offset & 3) || (length & 3)) 2879 return -EIO; 2880 2881 if (offset >= sizeof(struct ip_rt_acct) * 256) { 2882 *eof = 1; 2883 return 0; 2884 } 2885 2886 if (offset + length >= sizeof(struct ip_rt_acct) * 256) { 2887 length = sizeof(struct ip_rt_acct) * 256 - offset; 2888 *eof = 1; 2889 } 2890 2891 offset /= sizeof(u32); 2892 2893 if (length > 0) { 2894 u32 *dst = (u32 *) buffer; 2895 2896 *start = buffer; 2897 memset(dst, 0, length); 2898 2899 for_each_possible_cpu(i) { 2900 unsigned int j; 2901 u32 *src = ((u32 *) IP_RT_ACCT_CPU(i)) + offset; 2902 2903 for (j = 0; j < length/4; j++) 2904 dst[j] += src[j]; 2905 } 2906 } 2907 return length; 2908 } 2909 #endif /* CONFIG_PROC_FS */ 2910 #endif /* CONFIG_NET_CLS_ROUTE */ 2911 2912 static __initdata unsigned long rhash_entries; 2913 static int __init set_rhash_entries(char *str) 2914 { 2915 if (!str) 2916 return 0; 2917 rhash_entries = simple_strtoul(str, &str, 0); 2918 return 1; 2919 } 2920 __setup("rhash_entries=", set_rhash_entries); 2921 2922 int __init ip_rt_init(void) 2923 { 2924 int rc = 0; 2925 2926 rt_hash_rnd = (int) ((num_physpages ^ (num_physpages>>8)) ^ 2927 (jiffies ^ (jiffies >> 7))); 2928 2929 #ifdef CONFIG_NET_CLS_ROUTE 2930 { 2931 int order; 2932 for (order = 0; 2933 (PAGE_SIZE << order) < 256 * sizeof(struct ip_rt_acct) * NR_CPUS; order++) 2934 /* NOTHING */; 2935 ip_rt_acct = (struct ip_rt_acct *)__get_free_pages(GFP_KERNEL, order); 2936 if (!ip_rt_acct) 2937 panic("IP: failed to allocate ip_rt_acct\n"); 2938 memset(ip_rt_acct, 0, PAGE_SIZE << order); 2939 } 2940 #endif 2941 2942 ipv4_dst_ops.kmem_cachep = 2943 kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0, 2944 SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL); 2945 2946 ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep; 2947 2948 rt_hash_table = (struct rt_hash_bucket *) 2949 alloc_large_system_hash("IP route cache", 2950 sizeof(struct rt_hash_bucket), 2951 rhash_entries, 2952 (num_physpages >= 128 * 1024) ? 2953 15 : 17, 2954 0, 2955 &rt_hash_log, 2956 &rt_hash_mask, 2957 0); 2958 memset(rt_hash_table, 0, (rt_hash_mask + 1) * sizeof(struct rt_hash_bucket)); 2959 rt_hash_lock_init(); 2960 2961 ipv4_dst_ops.gc_thresh = (rt_hash_mask + 1); 2962 ip_rt_max_size = (rt_hash_mask + 1) * 16; 2963 2964 devinet_init(); 2965 ip_fib_init(); 2966 2967 init_timer(&rt_flush_timer); 2968 rt_flush_timer.function = rt_run_flush; 2969 init_timer(&rt_secret_timer); 2970 rt_secret_timer.function = rt_secret_rebuild; 2971 2972 /* All the timers, started at system startup tend 2973 to synchronize. Perturb it a bit. 2974 */ 2975 schedule_delayed_work(&expires_work, 2976 net_random() % ip_rt_gc_interval + ip_rt_gc_interval); 2977 2978 rt_secret_timer.expires = jiffies + net_random() % ip_rt_secret_interval + 2979 ip_rt_secret_interval; 2980 add_timer(&rt_secret_timer); 2981 2982 #ifdef CONFIG_PROC_FS 2983 { 2984 struct proc_dir_entry *rtstat_pde = NULL; /* keep gcc happy */ 2985 if (!proc_net_fops_create(&init_net, "rt_cache", S_IRUGO, &rt_cache_seq_fops) || 2986 !(rtstat_pde = create_proc_entry("rt_cache", S_IRUGO, 2987 init_net.proc_net_stat))) { 2988 return -ENOMEM; 2989 } 2990 rtstat_pde->proc_fops = &rt_cpu_seq_fops; 2991 } 2992 #ifdef CONFIG_NET_CLS_ROUTE 2993 create_proc_read_entry("rt_acct", 0, init_net.proc_net, ip_rt_acct_read, NULL); 2994 #endif 2995 #endif 2996 #ifdef CONFIG_XFRM 2997 xfrm_init(); 2998 xfrm4_init(); 2999 #endif 3000 rtnl_register(PF_INET, RTM_GETROUTE, inet_rtm_getroute, NULL); 3001 3002 return rc; 3003 } 3004 3005 EXPORT_SYMBOL(__ip_select_ident); 3006 EXPORT_SYMBOL(ip_route_input); 3007 EXPORT_SYMBOL(ip_route_output_key); 3008