?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[IPV4]: Explicitly call fib_get_table() in fib_frontend.c
[wrt350n-kernel.git] / net / ipv4 / fib_frontend.c
blob60123905dbbf65d4e67a3c7adc86264091a52bfd
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 * IPv4 Forwarding Information Base: FIB frontend.
7 *
8 * Version: $Id: fib_frontend.c,v 1.26 2001/10/31 21:55:54 davem Exp $
9 *
10 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
16 */
17
18 #include <linux/module.h>
19 #include <asm/uaccess.h>
20 #include <asm/system.h>
21 #include <linux/bitops.h>
22 #include <linux/capability.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
25 #include <linux/mm.h>
26 #include <linux/string.h>
27 #include <linux/socket.h>
28 #include <linux/sockios.h>
29 #include <linux/errno.h>
30 #include <linux/in.h>
31 #include <linux/inet.h>
32 #include <linux/inetdevice.h>
33 #include <linux/netdevice.h>
34 #include <linux/if_addr.h>
35 #include <linux/if_arp.h>
36 #include <linux/skbuff.h>
37 #include <linux/init.h>
38 #include <linux/list.h>
39
40 #include <net/ip.h>
41 #include <net/protocol.h>
42 #include <net/route.h>
43 #include <net/tcp.h>
44 #include <net/sock.h>
45 #include <net/icmp.h>
46 #include <net/arp.h>
47 #include <net/ip_fib.h>
48 #include <net/rtnetlink.h>
49
50 #define FFprint(a...) printk(KERN_DEBUG a)
51
52 static struct sock *fibnl;
53
54 #ifndef CONFIG_IP_MULTIPLE_TABLES
55
56 struct fib_table *ip_fib_local_table;
57 struct fib_table *ip_fib_main_table;
58
59 #define FIB_TABLE_HASHSZ 1
60 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
61
62 #else
63
64 #define FIB_TABLE_HASHSZ 256
65 static struct hlist_head fib_table_hash[FIB_TABLE_HASHSZ];
66
67 struct fib_table *fib_new_table(u32 id)
68 {
69 struct fib_table *tb;
70 unsigned int h;
71
72 if (id == 0)
73 id = RT_TABLE_MAIN;
74 tb = fib_get_table(id);
75 if (tb)
76 return tb;
77 tb = fib_hash_init(id);
78 if (!tb)
79 return NULL;
80 h = id & (FIB_TABLE_HASHSZ - 1);
81 hlist_add_head_rcu(&tb->tb_hlist, &fib_table_hash[h]);
82 return tb;
83 }
84
85 struct fib_table *fib_get_table(u32 id)
86 {
87 struct fib_table *tb;
88 struct hlist_node *node;
89 unsigned int h;
90
91 if (id == 0)
92 id = RT_TABLE_MAIN;
93 h = id & (FIB_TABLE_HASHSZ - 1);
94 rcu_read_lock();
95 hlist_for_each_entry_rcu(tb, node, &fib_table_hash[h], tb_hlist) {
96 if (tb->tb_id == id) {
97 rcu_read_unlock();
98 return tb;
99 }
100 }
101 rcu_read_unlock();
102 return NULL;
103 }
104 #endif /* CONFIG_IP_MULTIPLE_TABLES */
105
106 static void fib_flush(void)
107 {
108 int flushed = 0;
109 struct fib_table *tb;
110 struct hlist_node *node;
111 unsigned int h;
112
113 for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
114 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist)
115 flushed += tb->tb_flush(tb);
116 }
117
118 if (flushed)
119 rt_cache_flush(-1);
120 }
121
122 /*
123 * Find the first device with a given source address.
124 */
125
126 struct net_device * ip_dev_find(__be32 addr)
127 {
128 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
129 struct fib_result res;
130 struct net_device *dev = NULL;
131 struct fib_table *local_table;
132
133 #ifdef CONFIG_IP_MULTIPLE_TABLES
134 res.r = NULL;
135 #endif
136
137 local_table = fib_get_table(RT_TABLE_LOCAL);
138 if (!local_table || local_table->tb_lookup(local_table, &fl, &res))
139 return NULL;
140 if (res.type != RTN_LOCAL)
141 goto out;
142 dev = FIB_RES_DEV(res);
143
144 if (dev)
145 dev_hold(dev);
146 out:
147 fib_res_put(&res);
148 return dev;
149 }
150
151 unsigned inet_addr_type(__be32 addr)
152 {
153 struct flowi fl = { .nl_u = { .ip4_u = { .daddr = addr } } };
154 struct fib_result res;
155 unsigned ret = RTN_BROADCAST;
156 struct fib_table *local_table;
157
158 if (ZERONET(addr) || BADCLASS(addr))
159 return RTN_BROADCAST;
160 if (MULTICAST(addr))
161 return RTN_MULTICAST;
162
163 #ifdef CONFIG_IP_MULTIPLE_TABLES
164 res.r = NULL;
165 #endif
166
167 local_table = fib_get_table(RT_TABLE_LOCAL);
168 if (local_table) {
169 ret = RTN_UNICAST;
170 if (!local_table->tb_lookup(local_table, &fl, &res)) {
171 ret = res.type;
172 fib_res_put(&res);
173 }
174 }
175 return ret;
176 }
177
178 /* Given (packet source, input interface) and optional (dst, oif, tos):
179 - (main) check, that source is valid i.e. not broadcast or our local
180 address.
181 - figure out what "logical" interface this packet arrived
182 and calculate "specific destination" address.
183 - check, that packet arrived from expected physical interface.
184 */
185
186 int fib_validate_source(__be32 src, __be32 dst, u8 tos, int oif,
187 struct net_device *dev, __be32 *spec_dst, u32 *itag)
188 {
189 struct in_device *in_dev;
190 struct flowi fl = { .nl_u = { .ip4_u =
191 { .daddr = src,
192 .saddr = dst,
193 .tos = tos } },
194 .iif = oif };
195 struct fib_result res;
196 int no_addr, rpf;
197 int ret;
198
199 no_addr = rpf = 0;
200 rcu_read_lock();
201 in_dev = __in_dev_get_rcu(dev);
202 if (in_dev) {
203 no_addr = in_dev->ifa_list == NULL;
204 rpf = IN_DEV_RPFILTER(in_dev);
205 }
206 rcu_read_unlock();
207
208 if (in_dev == NULL)
209 goto e_inval;
210
211 if (fib_lookup(&fl, &res))
212 goto last_resort;
213 if (res.type != RTN_UNICAST)
214 goto e_inval_res;
215 *spec_dst = FIB_RES_PREFSRC(res);
216 fib_combine_itag(itag, &res);
217 #ifdef CONFIG_IP_ROUTE_MULTIPATH
218 if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
219 #else
220 if (FIB_RES_DEV(res) == dev)
221 #endif
222 {
223 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
224 fib_res_put(&res);
225 return ret;
226 }
227 fib_res_put(&res);
228 if (no_addr)
229 goto last_resort;
230 if (rpf)
231 goto e_inval;
232 fl.oif = dev->ifindex;
233
234 ret = 0;
235 if (fib_lookup(&fl, &res) == 0) {
236 if (res.type == RTN_UNICAST) {
237 *spec_dst = FIB_RES_PREFSRC(res);
238 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
239 }
240 fib_res_put(&res);
241 }
242 return ret;
243
244 last_resort:
245 if (rpf)
246 goto e_inval;
247 *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
248 *itag = 0;
249 return 0;
250
251 e_inval_res:
252 fib_res_put(&res);
253 e_inval:
254 return -EINVAL;
255 }
256
257 static inline __be32 sk_extract_addr(struct sockaddr *addr)
258 {
259 return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
260 }
261
262 static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
263 {
264 struct nlattr *nla;
265
266 nla = (struct nlattr *) ((char *) mx + len);
267 nla->nla_type = type;
268 nla->nla_len = nla_attr_size(4);
269 *(u32 *) nla_data(nla) = value;
270
271 return len + nla_total_size(4);
272 }
273
274 static int rtentry_to_fib_config(int cmd, struct rtentry *rt,
275 struct fib_config *cfg)
276 {
277 __be32 addr;
278 int plen;
279
280 memset(cfg, 0, sizeof(*cfg));
281
282 if (rt->rt_dst.sa_family != AF_INET)
283 return -EAFNOSUPPORT;
284
285 /*
286 * Check mask for validity:
287 * a) it must be contiguous.
288 * b) destination must have all host bits clear.
289 * c) if application forgot to set correct family (AF_INET),
290 * reject request unless it is absolutely clear i.e.
291 * both family and mask are zero.
292 */
293 plen = 32;
294 addr = sk_extract_addr(&rt->rt_dst);
295 if (!(rt->rt_flags & RTF_HOST)) {
296 __be32 mask = sk_extract_addr(&rt->rt_genmask);
297
298 if (rt->rt_genmask.sa_family != AF_INET) {
299 if (mask || rt->rt_genmask.sa_family)
300 return -EAFNOSUPPORT;
301 }
302
303 if (bad_mask(mask, addr))
304 return -EINVAL;
305
306 plen = inet_mask_len(mask);
307 }
308
309 cfg->fc_dst_len = plen;
310 cfg->fc_dst = addr;
311
312 if (cmd != SIOCDELRT) {
313 cfg->fc_nlflags = NLM_F_CREATE;
314 cfg->fc_protocol = RTPROT_BOOT;
315 }
316
317 if (rt->rt_metric)
318 cfg->fc_priority = rt->rt_metric - 1;
319
320 if (rt->rt_flags & RTF_REJECT) {
321 cfg->fc_scope = RT_SCOPE_HOST;
322 cfg->fc_type = RTN_UNREACHABLE;
323 return 0;
324 }
325
326 cfg->fc_scope = RT_SCOPE_NOWHERE;
327 cfg->fc_type = RTN_UNICAST;
328
329 if (rt->rt_dev) {
330 char *colon;
331 struct net_device *dev;
332 char devname[IFNAMSIZ];
333
334 if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
335 return -EFAULT;
336
337 devname[IFNAMSIZ-1] = 0;
338 colon = strchr(devname, ':');
339 if (colon)
340 *colon = 0;
341 dev = __dev_get_by_name(&init_net, devname);
342 if (!dev)
343 return -ENODEV;
344 cfg->fc_oif = dev->ifindex;
345 if (colon) {
346 struct in_ifaddr *ifa;
347 struct in_device *in_dev = __in_dev_get_rtnl(dev);
348 if (!in_dev)
349 return -ENODEV;
350 *colon = ':';
351 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next)
352 if (strcmp(ifa->ifa_label, devname) == 0)
353 break;
354 if (ifa == NULL)
355 return -ENODEV;
356 cfg->fc_prefsrc = ifa->ifa_local;
357 }
358 }
359
360 addr = sk_extract_addr(&rt->rt_gateway);
361 if (rt->rt_gateway.sa_family == AF_INET && addr) {
362 cfg->fc_gw = addr;
363 if (rt->rt_flags & RTF_GATEWAY &&
364 inet_addr_type(addr) == RTN_UNICAST)
365 cfg->fc_scope = RT_SCOPE_UNIVERSE;
366 }
367
368 if (cmd == SIOCDELRT)
369 return 0;
370
371 if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw)
372 return -EINVAL;
373
374 if (cfg->fc_scope == RT_SCOPE_NOWHERE)
375 cfg->fc_scope = RT_SCOPE_LINK;
376
377 if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
378 struct nlattr *mx;
379 int len = 0;
380
381 mx = kzalloc(3 * nla_total_size(4), GFP_KERNEL);
382 if (mx == NULL)
383 return -ENOMEM;
384
385 if (rt->rt_flags & RTF_MTU)
386 len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
387
388 if (rt->rt_flags & RTF_WINDOW)
389 len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
390
391 if (rt->rt_flags & RTF_IRTT)
392 len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
393
394 cfg->fc_mx = mx;
395 cfg->fc_mx_len = len;
396 }
397
398 return 0;
399 }
400
401 /*
402 * Handle IP routing ioctl calls. These are used to manipulate the routing tables
403 */
404
405 int ip_rt_ioctl(unsigned int cmd, void __user *arg)
406 {
407 struct fib_config cfg;
408 struct rtentry rt;
409 int err;
410
411 switch (cmd) {
412 case SIOCADDRT: /* Add a route */
413 case SIOCDELRT: /* Delete a route */
414 if (!capable(CAP_NET_ADMIN))
415 return -EPERM;
416
417 if (copy_from_user(&rt, arg, sizeof(rt)))
418 return -EFAULT;
419
420 rtnl_lock();
421 err = rtentry_to_fib_config(cmd, &rt, &cfg);
422 if (err == 0) {
423 struct fib_table *tb;
424
425 if (cmd == SIOCDELRT) {
426 tb = fib_get_table(cfg.fc_table);
427 if (tb)
428 err = tb->tb_delete(tb, &cfg);
429 else
430 err = -ESRCH;
431 } else {
432 tb = fib_new_table(cfg.fc_table);
433 if (tb)
434 err = tb->tb_insert(tb, &cfg);
435 else
436 err = -ENOBUFS;
437 }
438
439 /* allocated by rtentry_to_fib_config() */
440 kfree(cfg.fc_mx);
441 }
442 rtnl_unlock();
443 return err;
444 }
445 return -EINVAL;
446 }
447
448 const struct nla_policy rtm_ipv4_policy[RTA_MAX+1] = {
449 [RTA_DST] = { .type = NLA_U32 },
450 [RTA_SRC] = { .type = NLA_U32 },
451 [RTA_IIF] = { .type = NLA_U32 },
452 [RTA_OIF] = { .type = NLA_U32 },
453 [RTA_GATEWAY] = { .type = NLA_U32 },
454 [RTA_PRIORITY] = { .type = NLA_U32 },
455 [RTA_PREFSRC] = { .type = NLA_U32 },
456 [RTA_METRICS] = { .type = NLA_NESTED },
457 [RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
458 [RTA_PROTOINFO] = { .type = NLA_U32 },
459 [RTA_FLOW] = { .type = NLA_U32 },
460 };
461
462 static int rtm_to_fib_config(struct sk_buff *skb, struct nlmsghdr *nlh,
463 struct fib_config *cfg)
464 {
465 struct nlattr *attr;
466 int err, remaining;
467 struct rtmsg *rtm;
468
469 err = nlmsg_validate(nlh, sizeof(*rtm), RTA_MAX, rtm_ipv4_policy);
470 if (err < 0)
471 goto errout;
472
473 memset(cfg, 0, sizeof(*cfg));
474
475 rtm = nlmsg_data(nlh);
476 cfg->fc_dst_len = rtm->rtm_dst_len;
477 cfg->fc_tos = rtm->rtm_tos;
478 cfg->fc_table = rtm->rtm_table;
479 cfg->fc_protocol = rtm->rtm_protocol;
480 cfg->fc_scope = rtm->rtm_scope;
481 cfg->fc_type = rtm->rtm_type;
482 cfg->fc_flags = rtm->rtm_flags;
483 cfg->fc_nlflags = nlh->nlmsg_flags;
484
485 cfg->fc_nlinfo.pid = NETLINK_CB(skb).pid;
486 cfg->fc_nlinfo.nlh = nlh;
487
488 if (cfg->fc_type > RTN_MAX) {
489 err = -EINVAL;
490 goto errout;
491 }
492
493 nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
494 switch (nla_type(attr)) {
495 case RTA_DST:
496 cfg->fc_dst = nla_get_be32(attr);
497 break;
498 case RTA_OIF:
499 cfg->fc_oif = nla_get_u32(attr);
500 break;
501 case RTA_GATEWAY:
502 cfg->fc_gw = nla_get_be32(attr);
503 break;
504 case RTA_PRIORITY:
505 cfg->fc_priority = nla_get_u32(attr);
506 break;
507 case RTA_PREFSRC:
508 cfg->fc_prefsrc = nla_get_be32(attr);
509 break;
510 case RTA_METRICS:
511 cfg->fc_mx = nla_data(attr);
512 cfg->fc_mx_len = nla_len(attr);
513 break;
514 case RTA_MULTIPATH:
515 cfg->fc_mp = nla_data(attr);
516 cfg->fc_mp_len = nla_len(attr);
517 break;
518 case RTA_FLOW:
519 cfg->fc_flow = nla_get_u32(attr);
520 break;
521 case RTA_TABLE:
522 cfg->fc_table = nla_get_u32(attr);
523 break;
524 }
525 }
526
527 return 0;
528 errout:
529 return err;
530 }
531
532 static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
533 {
534 struct fib_config cfg;
535 struct fib_table *tb;
536 int err;
537
538 err = rtm_to_fib_config(skb, nlh, &cfg);
539 if (err < 0)
540 goto errout;
541
542 tb = fib_get_table(cfg.fc_table);
543 if (tb == NULL) {
544 err = -ESRCH;
545 goto errout;
546 }
547
548 err = tb->tb_delete(tb, &cfg);
549 errout:
550 return err;
551 }
552
553 static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
554 {
555 struct fib_config cfg;
556 struct fib_table *tb;
557 int err;
558
559 err = rtm_to_fib_config(skb, nlh, &cfg);
560 if (err < 0)
561 goto errout;
562
563 tb = fib_new_table(cfg.fc_table);
564 if (tb == NULL) {
565 err = -ENOBUFS;
566 goto errout;
567 }
568
569 err = tb->tb_insert(tb, &cfg);
570 errout:
571 return err;
572 }
573
574 static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
575 {
576 unsigned int h, s_h;
577 unsigned int e = 0, s_e;
578 struct fib_table *tb;
579 struct hlist_node *node;
580 int dumped = 0;
581
582 if (nlmsg_len(cb->nlh) >= sizeof(struct rtmsg) &&
583 ((struct rtmsg *) nlmsg_data(cb->nlh))->rtm_flags & RTM_F_CLONED)
584 return ip_rt_dump(skb, cb);
585
586 s_h = cb->args[0];
587 s_e = cb->args[1];
588
589 for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
590 e = 0;
591 hlist_for_each_entry(tb, node, &fib_table_hash[h], tb_hlist) {
592 if (e < s_e)
593 goto next;
594 if (dumped)
595 memset(&cb->args[2], 0, sizeof(cb->args) -
596 2 * sizeof(cb->args[0]));
597 if (tb->tb_dump(tb, skb, cb) < 0)
598 goto out;
599 dumped = 1;
600 next:
601 e++;
602 }
603 }
604 out:
605 cb->args[1] = e;
606 cb->args[0] = h;
607
608 return skb->len;
609 }
610
611 /* Prepare and feed intra-kernel routing request.
612 Really, it should be netlink message, but :-( netlink
613 can be not configured, so that we feed it directly
614 to fib engine. It is legal, because all events occur
615 only when netlink is already locked.
616 */
617
618 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)
619 {
620 struct fib_table *tb;
621 struct fib_config cfg = {
622 .fc_protocol = RTPROT_KERNEL,
623 .fc_type = type,
624 .fc_dst = dst,
625 .fc_dst_len = dst_len,
626 .fc_prefsrc = ifa->ifa_local,
627 .fc_oif = ifa->ifa_dev->dev->ifindex,
628 .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
629 };
630
631 if (type == RTN_UNICAST)
632 tb = fib_new_table(RT_TABLE_MAIN);
633 else
634 tb = fib_new_table(RT_TABLE_LOCAL);
635
636 if (tb == NULL)
637 return;
638
639 cfg.fc_table = tb->tb_id;
640
641 if (type != RTN_LOCAL)
642 cfg.fc_scope = RT_SCOPE_LINK;
643 else
644 cfg.fc_scope = RT_SCOPE_HOST;
645
646 if (cmd == RTM_NEWROUTE)
647 tb->tb_insert(tb, &cfg);
648 else
649 tb->tb_delete(tb, &cfg);
650 }
651
652 void fib_add_ifaddr(struct in_ifaddr *ifa)
653 {
654 struct in_device *in_dev = ifa->ifa_dev;
655 struct net_device *dev = in_dev->dev;
656 struct in_ifaddr *prim = ifa;
657 __be32 mask = ifa->ifa_mask;
658 __be32 addr = ifa->ifa_local;
659 __be32 prefix = ifa->ifa_address&mask;
660
661 if (ifa->ifa_flags&IFA_F_SECONDARY) {
662 prim = inet_ifa_byprefix(in_dev, prefix, mask);
663 if (prim == NULL) {
664 printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULL\n");
665 return;
666 }
667 }
668
669 fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
670
671 if (!(dev->flags&IFF_UP))
672 return;
673
674 /* Add broadcast address, if it is explicitly assigned. */
675 if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))
676 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
677
678 if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
679 (prefix != addr || ifa->ifa_prefixlen < 32)) {
680 fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
681 RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
682
683 /* Add network specific broadcasts, when it takes a sense */
684 if (ifa->ifa_prefixlen < 31) {
685 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
686 fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
687 }
688 }
689 }
690
691 static void fib_del_ifaddr(struct in_ifaddr *ifa)
692 {
693 struct in_device *in_dev = ifa->ifa_dev;
694 struct net_device *dev = in_dev->dev;
695 struct in_ifaddr *ifa1;
696 struct in_ifaddr *prim = ifa;
697 __be32 brd = ifa->ifa_address|~ifa->ifa_mask;
698 __be32 any = ifa->ifa_address&ifa->ifa_mask;
699 #define LOCAL_OK 1
700 #define BRD_OK 2
701 #define BRD0_OK 4
702 #define BRD1_OK 8
703 unsigned ok = 0;
704
705 if (!(ifa->ifa_flags&IFA_F_SECONDARY))
706 fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
707 RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
708 else {
709 prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
710 if (prim == NULL) {
711 printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULL\n");
712 return;
713 }
714 }
715
716 /* Deletion is more complicated than add.
717 We should take care of not to delete too much :-)
718
719 Scan address list to be sure that addresses are really gone.
720 */
721
722 for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
723 if (ifa->ifa_local == ifa1->ifa_local)
724 ok |= LOCAL_OK;
725 if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
726 ok |= BRD_OK;
727 if (brd == ifa1->ifa_broadcast)
728 ok |= BRD1_OK;
729 if (any == ifa1->ifa_broadcast)
730 ok |= BRD0_OK;
731 }
732
733 if (!(ok&BRD_OK))
734 fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
735 if (!(ok&BRD1_OK))
736 fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
737 if (!(ok&BRD0_OK))
738 fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
739 if (!(ok&LOCAL_OK)) {
740 fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
741
742 /* Check, that this local address finally disappeared. */
743 if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
744 /* And the last, but not the least thing.
745 We must flush stray FIB entries.
746
747 First of all, we scan fib_info list searching
748 for stray nexthop entries, then ignite fib_flush.
749 */
750 if (fib_sync_down(ifa->ifa_local, NULL, 0))
751 fib_flush();
752 }
753 }
754 #undef LOCAL_OK
755 #undef BRD_OK
756 #undef BRD0_OK
757 #undef BRD1_OK
758 }
759
760 static void nl_fib_lookup(struct fib_result_nl *frn, struct fib_table *tb )
761 {
762
763 struct fib_result res;
764 struct flowi fl = { .mark = frn->fl_mark,
765 .nl_u = { .ip4_u = { .daddr = frn->fl_addr,
766 .tos = frn->fl_tos,
767 .scope = frn->fl_scope } } };
768
769 #ifdef CONFIG_IP_MULTIPLE_TABLES
770 res.r = NULL;
771 #endif
772
773 frn->err = -ENOENT;
774 if (tb) {
775 local_bh_disable();
776
777 frn->tb_id = tb->tb_id;
778 frn->err = tb->tb_lookup(tb, &fl, &res);
779
780 if (!frn->err) {
781 frn->prefixlen = res.prefixlen;
782 frn->nh_sel = res.nh_sel;
783 frn->type = res.type;
784 frn->scope = res.scope;
785 fib_res_put(&res);
786 }
787 local_bh_enable();
788 }
789 }
790
791 static void nl_fib_input(struct sk_buff *skb)
792 {
793 struct fib_result_nl *frn;
794 struct nlmsghdr *nlh;
795 struct fib_table *tb;
796 u32 pid;
797
798 nlh = nlmsg_hdr(skb);
799 if (skb->len < NLMSG_SPACE(0) || skb->len < nlh->nlmsg_len ||
800 nlh->nlmsg_len < NLMSG_LENGTH(sizeof(*frn))) {
801 kfree_skb(skb);
802 return;
803 }
804
805 frn = (struct fib_result_nl *) NLMSG_DATA(nlh);
806 tb = fib_get_table(frn->tb_id_in);
807
808 nl_fib_lookup(frn, tb);
809
810 pid = NETLINK_CB(skb).pid; /* pid of sending process */
811 NETLINK_CB(skb).pid = 0; /* from kernel */
812 NETLINK_CB(skb).dst_group = 0; /* unicast */
813 netlink_unicast(fibnl, skb, pid, MSG_DONTWAIT);
814 }
815
816 static void nl_fib_lookup_init(void)
817 {
818 fibnl = netlink_kernel_create(&init_net, NETLINK_FIB_LOOKUP, 0,
819 nl_fib_input, NULL, THIS_MODULE);
820 }
821
822 static void fib_disable_ip(struct net_device *dev, int force)
823 {
824 if (fib_sync_down(0, dev, force))
825 fib_flush();
826 rt_cache_flush(0);
827 arp_ifdown(dev);
828 }
829
830 static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
831 {
832 struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
833
834 switch (event) {
835 case NETDEV_UP:
836 fib_add_ifaddr(ifa);
837 #ifdef CONFIG_IP_ROUTE_MULTIPATH
838 fib_sync_up(ifa->ifa_dev->dev);
839 #endif
840 rt_cache_flush(-1);
841 break;
842 case NETDEV_DOWN:
843 fib_del_ifaddr(ifa);
844 if (ifa->ifa_dev->ifa_list == NULL) {
845 /* Last address was deleted from this interface.
846 Disable IP.
847 */
848 fib_disable_ip(ifa->ifa_dev->dev, 1);
849 } else {
850 rt_cache_flush(-1);
851 }
852 break;
853 }
854 return NOTIFY_DONE;
855 }
856
857 static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
858 {
859 struct net_device *dev = ptr;
860 struct in_device *in_dev = __in_dev_get_rtnl(dev);
861
862 if (dev->nd_net != &init_net)
863 return NOTIFY_DONE;
864
865 if (event == NETDEV_UNREGISTER) {
866 fib_disable_ip(dev, 2);
867 return NOTIFY_DONE;
868 }
869
870 if (!in_dev)
871 return NOTIFY_DONE;
872
873 switch (event) {
874 case NETDEV_UP:
875 for_ifa(in_dev) {
876 fib_add_ifaddr(ifa);
877 } endfor_ifa(in_dev);
878 #ifdef CONFIG_IP_ROUTE_MULTIPATH
879 fib_sync_up(dev);
880 #endif
881 rt_cache_flush(-1);
882 break;
883 case NETDEV_DOWN:
884 fib_disable_ip(dev, 0);
885 break;
886 case NETDEV_CHANGEMTU:
887 case NETDEV_CHANGE:
888 rt_cache_flush(0);
889 break;
890 }
891 return NOTIFY_DONE;
892 }
893
894 static struct notifier_block fib_inetaddr_notifier = {
895 .notifier_call =fib_inetaddr_event,
896 };
897
898 static struct notifier_block fib_netdev_notifier = {
899 .notifier_call =fib_netdev_event,
900 };
901
902 void __init ip_fib_init(void)
903 {
904 unsigned int i;
905
906 for (i = 0; i < FIB_TABLE_HASHSZ; i++)
907 INIT_HLIST_HEAD(&fib_table_hash[i]);
908 #ifndef CONFIG_IP_MULTIPLE_TABLES
909 ip_fib_local_table = fib_hash_init(RT_TABLE_LOCAL);
910 hlist_add_head_rcu(&ip_fib_local_table->tb_hlist, &fib_table_hash[0]);
911 ip_fib_main_table = fib_hash_init(RT_TABLE_MAIN);
912 hlist_add_head_rcu(&ip_fib_main_table->tb_hlist, &fib_table_hash[0]);
913 #else
914 fib4_rules_init();
915 #endif
916
917 register_netdevice_notifier(&fib_netdev_notifier);
918 register_inetaddr_notifier(&fib_inetaddr_notifier);
919 nl_fib_lookup_init();
920
921 rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL);
922 rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL);
923 rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib);
924 }
925
926 EXPORT_SYMBOL(inet_addr_type);
927 EXPORT_SYMBOL(ip_dev_find);
WRT350N Kernel Patches