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