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