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