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