开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
fib_frontend.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：15k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

fib_frontend.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.  * 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.  */
  18. #include <linux/config.h>
  19. #include <asm/uaccess.h>
  20. #include <asm/system.h>
  21. #include <asm/bitops.h>
  22. #include <linux/types.h>
  23. #include <linux/kernel.h>
  24. #include <linux/sched.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/netdevice.h>
  33. #include <linux/if_arp.h>
  34. #include <linux/proc_fs.h>
  35. #include <linux/skbuff.h>
  36. #include <linux/netlink.h>
  37. #include <linux/init.h>
  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/icmp.h>
  45. #include <net/arp.h>
  46. #include <net/ip_fib.h>
  48. #define FFprint(a...) printk(KERN_DEBUG a)
  50. #ifndef CONFIG_IP_MULTIPLE_TABLES
  52. #define RT_TABLE_MIN RT_TABLE_MAIN
  54. struct fib_table *local_table;
  55. struct fib_table *main_table;
  57. #else
  59. #define RT_TABLE_MIN 1
  61. struct fib_table *fib_tables[RT_TABLE_MAX+1];
  63. struct fib_table *__fib_new_table(int id)
  64. {
  65. struct fib_table *tb;
  67. tb = fib_hash_init(id);
  68. if (!tb)
  69. return NULL;
  70. fib_tables[id] = tb;
  71. return tb;
  72. }
  75. #endif /* CONFIG_IP_MULTIPLE_TABLES */
  78. void fib_flush(void)
  79. {
  80. int flushed = 0;
  81. #ifdef CONFIG_IP_MULTIPLE_TABLES
  82. struct fib_table *tb;
  83. int id;
  85. for (id = RT_TABLE_MAX; id>0; id--) {
  86. if ((tb = fib_get_table(id))==NULL)
  87. continue;
  88. flushed += tb->tb_flush(tb);
  89. }
  90. #else /* CONFIG_IP_MULTIPLE_TABLES */
  91. flushed += main_table->tb_flush(main_table);
  92. flushed += local_table->tb_flush(local_table);
  93. #endif /* CONFIG_IP_MULTIPLE_TABLES */
  95. if (flushed)
  96. rt_cache_flush(-1);
  97. }
  100. #ifdef CONFIG_PROC_FS
  102. /* 
  103.  * Called from the PROCfs module. This outputs /proc/net/route.
  104.  *
  105.  * It always works in backward compatibility mode.
  106.  * The format of the file is not supposed to be changed.
  107.  */
  108.  
  109. static int
  110. fib_get_procinfo(char *buffer, char **start, off_t offset, int length)
  111. {
  112. int first = offset/128;
  113. char *ptr = buffer;
  114. int count = (length+127)/128;
  115. int len;
  117. *start = buffer + offset%128;
  119. if (--first < 0) {
  120. sprintf(buffer, "%-127sn", "IfacetDestinationtGateway tFlagstRefCnttUsetMetrictMaskttMTUtWindowtIRTT");
  121. --count;
  122. ptr += 128;
  123. first = 0;
  124.    }
  126. if (main_table && count > 0) {
  127. int n = main_table->tb_get_info(main_table, ptr, first, count);
  128. count -= n;
  129. ptr += n*128;
  130. }
  131. len = ptr - *start;
  132. if (len >= length)
  133. return length;
  134. if (len >= 0)
  135. return len;
  136. return 0;
  137. }
  139. #endif /* CONFIG_PROC_FS */
  141. /*
  142.  * Find the first device with a given source address.
  143.  */
  145. struct net_device * ip_dev_find(u32 addr)
  146. {
  147. struct rt_key key;
  148. struct fib_result res;
  149. struct net_device *dev = NULL;
  151. memset(&key, 0, sizeof(key));
  152. key.dst = addr;
  153. #ifdef CONFIG_IP_MULTIPLE_TABLES
  154. res.r = NULL;
  155. #endif
  157. if (!local_table || local_table->tb_lookup(local_table, &key, &res)) {
  158. return NULL;
  159. }
  160. if (res.type != RTN_LOCAL)
  161. goto out;
  162. dev = FIB_RES_DEV(res);
  163. if (dev)
  164. atomic_inc(&dev->refcnt);
  166. out:
  167. fib_res_put(&res);
  168. return dev;
  169. }
  171. unsigned inet_addr_type(u32 addr)
  172. {
  173. struct rt_key key;
  174. struct fib_result res;
  175. unsigned ret = RTN_BROADCAST;
  177. if (ZERONET(addr) || BADCLASS(addr))
  178. return RTN_BROADCAST;
  179. if (MULTICAST(addr))
  180. return RTN_MULTICAST;
  182. memset(&key, 0, sizeof(key));
  183. key.dst = addr;
  184. #ifdef CONFIG_IP_MULTIPLE_TABLES
  185. res.r = NULL;
  186. #endif
  188. if (local_table) {
  189. ret = RTN_UNICAST;
  190. if (local_table->tb_lookup(local_table, &key, &res) == 0) {
  191. ret = res.type;
  192. fib_res_put(&res);
  193. }
  194. }
  195. return ret;
  196. }
  198. /* Given (packet source, input interface) and optional (dst, oif, tos):
  199.    - (main) check, that source is valid i.e. not broadcast or our local
  200.      address.
  201.    - figure out what "logical" interface this packet arrived
  202.      and calculate "specific destination" address.
  203.    - check, that packet arrived from expected physical interface.
  204.  */
  206. int fib_validate_source(u32 src, u32 dst, u8 tos, int oif,
  207. struct net_device *dev, u32 *spec_dst, u32 *itag)
  208. {
  209. struct in_device *in_dev;
  210. struct rt_key key;
  211. struct fib_result res;
  212. int no_addr, rpf;
  213. int ret;
  215. key.dst = src;
  216. key.src = dst;
  217. key.tos = tos;
  218. key.oif = 0;
  219. key.iif = oif;
  220. key.scope = RT_SCOPE_UNIVERSE;
  222. no_addr = rpf = 0;
  223. read_lock(&inetdev_lock);
  224. in_dev = __in_dev_get(dev);
  225. if (in_dev) {
  226. no_addr = in_dev->ifa_list == NULL;
  227. rpf = IN_DEV_RPFILTER(in_dev);
  228. }
  229. read_unlock(&inetdev_lock);
  231. if (in_dev == NULL)
  232. goto e_inval;
  234. if (fib_lookup(&key, &res))
  235. goto last_resort;
  236. if (res.type != RTN_UNICAST)
  237. goto e_inval_res;
  238. *spec_dst = FIB_RES_PREFSRC(res);
  239. fib_combine_itag(itag, &res);
  240. #ifdef CONFIG_IP_ROUTE_MULTIPATH
  241. if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
  242. #else
  243. if (FIB_RES_DEV(res) == dev)
  244. #endif
  245. {
  246. ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
  247. fib_res_put(&res);
  248. return ret;
  249. }
  250. fib_res_put(&res);
  251. if (no_addr)
  252. goto last_resort;
  253. if (rpf)
  254. goto e_inval;
  255. key.oif = dev->ifindex;
  257. ret = 0;
  258. if (fib_lookup(&key, &res) == 0) {
  259. if (res.type == RTN_UNICAST) {
  260. *spec_dst = FIB_RES_PREFSRC(res);
  261. ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
  262. }
  263. fib_res_put(&res);
  264. }
  265. return ret;
  267. last_resort:
  268. if (rpf)
  269. goto e_inval;
  270. *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
  271. *itag = 0;
  272. return 0;
  274. e_inval_res:
  275. fib_res_put(&res);
  276. e_inval:
  277. return -EINVAL;
  278. }
  280. #ifndef CONFIG_IP_NOSIOCRT
  282. /*
  283.  * Handle IP routing ioctl calls. These are used to manipulate the routing tables
  284.  */
  285.  
  286. int ip_rt_ioctl(unsigned int cmd, void *arg)
  287. {
  288. int err;
  289. struct kern_rta rta;
  290. struct rtentry  r;
  291. struct {
  292. struct nlmsghdr nlh;
  293. struct rtmsg rtm;
  294. } req;
  296. switch (cmd) {
  297. case SIOCADDRT: /* Add a route */
  298. case SIOCDELRT: /* Delete a route */
  299. if (!capable(CAP_NET_ADMIN))
  300. return -EPERM;
  301. if (copy_from_user(&r, arg, sizeof(struct rtentry)))
  302. return -EFAULT;
  303. rtnl_lock();
  304. err = fib_convert_rtentry(cmd, &req.nlh, &req.rtm, &rta, &r);
  305. if (err == 0) {
  306. if (cmd == SIOCDELRT) {
  307. struct fib_table *tb = fib_get_table(req.rtm.rtm_table);
  308. err = -ESRCH;
  309. if (tb)
  310. err = tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
  311. } else {
  312. struct fib_table *tb = fib_new_table(req.rtm.rtm_table);
  313. err = -ENOBUFS;
  314. if (tb)
  315. err = tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
  316. }
  317. if (rta.rta_mx)
  318. kfree(rta.rta_mx);
  319. }
  320. rtnl_unlock();
  321. return err;
  322. }
  323. return -EINVAL;
  324. }
  326. #else
  328. int ip_rt_ioctl(unsigned int cmd, void *arg)
  329. {
  330. return -EINVAL;
  331. }
  333. #endif
  335. static int inet_check_attr(struct rtmsg *r, struct rtattr **rta)
  336. {
  337. int i;
  339. for (i=1; i<=RTA_MAX; i++) {
  340. struct rtattr *attr = rta[i-1];
  341. if (attr) {
  342. if (RTA_PAYLOAD(attr) < 4)
  343. return -EINVAL;
  344. if (i != RTA_MULTIPATH && i != RTA_METRICS)
  345. rta[i-1] = (struct rtattr*)RTA_DATA(attr);
  346. }
  347. }
  348. return 0;
  349. }
  351. int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
  352. {
  353. struct fib_table * tb;
  354. struct rtattr **rta = arg;
  355. struct rtmsg *r = NLMSG_DATA(nlh);
  357. if (inet_check_attr(r, rta))
  358. return -EINVAL;
  360. tb = fib_get_table(r->rtm_table);
  361. if (tb)
  362. return tb->tb_delete(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
  363. return -ESRCH;
  364. }
  366. int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
  367. {
  368. struct fib_table * tb;
  369. struct rtattr **rta = arg;
  370. struct rtmsg *r = NLMSG_DATA(nlh);
  372. if (inet_check_attr(r, rta))
  373. return -EINVAL;
  375. tb = fib_new_table(r->rtm_table);
  376. if (tb)
  377. return tb->tb_insert(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb));
  378. return -ENOBUFS;
  379. }
  381. int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
  382. {
  383. int t;
  384. int s_t;
  385. struct fib_table *tb;
  387. if (NLMSG_PAYLOAD(cb->nlh, 0) >= sizeof(struct rtmsg) &&
  388.     ((struct rtmsg*)NLMSG_DATA(cb->nlh))->rtm_flags&RTM_F_CLONED)
  389. return ip_rt_dump(skb, cb);
  391. s_t = cb->args[0];
  392. if (s_t == 0)
  393. s_t = cb->args[0] = RT_TABLE_MIN;
  395. for (t=s_t; t<=RT_TABLE_MAX; t++) {
  396. if (t < s_t) continue;
  397. if (t > s_t)
  398. memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0]));
  399. if ((tb = fib_get_table(t))==NULL)
  400. continue;
  401. if (tb->tb_dump(tb, skb, cb) < 0) 
  402. break;
  403. }
  405. cb->args[0] = t;
  407. return skb->len;
  408. }
  410. /* Prepare and feed intra-kernel routing request.
  411.    Really, it should be netlink message, but :-( netlink
  412.    can be not configured, so that we feed it directly
  413.    to fib engine. It is legal, because all events occur
  414.    only when netlink is already locked.
  415.  */
  417. static void fib_magic(int cmd, int type, u32 dst, int dst_len, struct in_ifaddr *ifa)
  418. {
  419. struct fib_table * tb;
  420. struct {
  421. struct nlmsghdr nlh;
  422. struct rtmsg rtm;
  423. } req;
  424. struct kern_rta rta;
  426. memset(&req.rtm, 0, sizeof(req.rtm));
  427. memset(&rta, 0, sizeof(rta));
  429. if (type == RTN_UNICAST)
  430. tb = fib_new_table(RT_TABLE_MAIN);
  431. else
  432. tb = fib_new_table(RT_TABLE_LOCAL);
  434. if (tb == NULL)
  435. return;
  437. req.nlh.nlmsg_len = sizeof(req);
  438. req.nlh.nlmsg_type = cmd;
  439. req.nlh.nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE|NLM_F_APPEND;
  440. req.nlh.nlmsg_pid = 0;
  441. req.nlh.nlmsg_seq = 0;
  443. req.rtm.rtm_dst_len = dst_len;
  444. req.rtm.rtm_table = tb->tb_id;
  445. req.rtm.rtm_protocol = RTPROT_KERNEL;
  446. req.rtm.rtm_scope = (type != RTN_LOCAL ? RT_SCOPE_LINK : RT_SCOPE_HOST);
  447. req.rtm.rtm_type = type;
  449. rta.rta_dst = &dst;
  450. rta.rta_prefsrc = &ifa->ifa_local;
  451. rta.rta_oif = &ifa->ifa_dev->dev->ifindex;
  453. if (cmd == RTM_NEWROUTE)
  454. tb->tb_insert(tb, &req.rtm, &rta, &req.nlh, NULL);
  455. else
  456. tb->tb_delete(tb, &req.rtm, &rta, &req.nlh, NULL);
  457. }
  459. static void fib_add_ifaddr(struct in_ifaddr *ifa)
  460. {
  461. struct in_device *in_dev = ifa->ifa_dev;
  462. struct net_device *dev = in_dev->dev;
  463. struct in_ifaddr *prim = ifa;
  464. u32 mask = ifa->ifa_mask;
  465. u32 addr = ifa->ifa_local;
  466. u32 prefix = ifa->ifa_address&mask;
  468. if (ifa->ifa_flags&IFA_F_SECONDARY) {
  469. prim = inet_ifa_byprefix(in_dev, prefix, mask);
  470. if (prim == NULL) {
  471. printk(KERN_DEBUG "fib_add_ifaddr: bug: prim == NULLn");
  472. return;
  473. }
  474. }
  476. fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);
  478. if (!(dev->flags&IFF_UP))
  479. return;
  481. /* Add broadcast address, if it is explicitly assigned. */
  482. if (ifa->ifa_broadcast && ifa->ifa_broadcast != 0xFFFFFFFF)
  483. fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
  485. if (!ZERONET(prefix) && !(ifa->ifa_flags&IFA_F_SECONDARY) &&
  486.     (prefix != addr || ifa->ifa_prefixlen < 32)) {
  487. fib_magic(RTM_NEWROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
  488.   RTN_UNICAST, prefix, ifa->ifa_prefixlen, prim);
  490. /* Add network specific broadcasts, when it takes a sense */
  491. if (ifa->ifa_prefixlen < 31) {
  492. fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);
  493. fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix|~mask, 32, prim);
  494. }
  495. }
  496. }
  498. static void fib_del_ifaddr(struct in_ifaddr *ifa)
  499. {
  500. struct in_device *in_dev = ifa->ifa_dev;
  501. struct net_device *dev = in_dev->dev;
  502. struct in_ifaddr *ifa1;
  503. struct in_ifaddr *prim = ifa;
  504. u32 brd = ifa->ifa_address|~ifa->ifa_mask;
  505. u32 any = ifa->ifa_address&ifa->ifa_mask;
  506. #define LOCAL_OK 1
  507. #define BRD_OK 2
  508. #define BRD0_OK 4
  509. #define BRD1_OK 8
  510. unsigned ok = 0;
  512. if (!(ifa->ifa_flags&IFA_F_SECONDARY))
  513. fib_magic(RTM_DELROUTE, dev->flags&IFF_LOOPBACK ? RTN_LOCAL :
  514.   RTN_UNICAST, any, ifa->ifa_prefixlen, prim);
  515. else {
  516. prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
  517. if (prim == NULL) {
  518. printk(KERN_DEBUG "fib_del_ifaddr: bug: prim == NULLn");
  519. return;
  520. }
  521. }
  523. /* Deletion is more complicated than add.
  524.    We should take care of not to delete too much :-)
  526.    Scan address list to be sure that addresses are really gone.
  527.  */
  529. for (ifa1 = in_dev->ifa_list; ifa1; ifa1 = ifa1->ifa_next) {
  530. if (ifa->ifa_local == ifa1->ifa_local)
  531. ok |= LOCAL_OK;
  532. if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
  533. ok |= BRD_OK;
  534. if (brd == ifa1->ifa_broadcast)
  535. ok |= BRD1_OK;
  536. if (any == ifa1->ifa_broadcast)
  537. ok |= BRD0_OK;
  538. }
  540. if (!(ok&BRD_OK))
  541. fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);
  542. if (!(ok&BRD1_OK))
  543. fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32, prim);
  544. if (!(ok&BRD0_OK))
  545. fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32, prim);
  546. if (!(ok&LOCAL_OK)) {
  547. fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim);
  549. /* Check, that this local address finally disappeared. */
  550. if (inet_addr_type(ifa->ifa_local) != RTN_LOCAL) {
  551. /* And the last, but not the least thing.
  552.    We must flush stray FIB entries.
  554.    First of all, we scan fib_info list searching
  555.    for stray nexthop entries, then ignite fib_flush.
  556. */
  557. if (fib_sync_down(ifa->ifa_local, NULL, 0))
  558. fib_flush();
  559. }
  560. }
  561. #undef LOCAL_OK
  562. #undef BRD_OK
  563. #undef BRD0_OK
  564. #undef BRD1_OK
  565. }
  567. static void fib_disable_ip(struct net_device *dev, int force)
  568. {
  569. if (fib_sync_down(0, dev, force))
  570. fib_flush();
  571. rt_cache_flush(0);
  572. arp_ifdown(dev);
  573. }
  575. static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
  576. {
  577. struct in_ifaddr *ifa = (struct in_ifaddr*)ptr;
  579. switch (event) {
  580. case NETDEV_UP:
  581. fib_add_ifaddr(ifa);
  582. rt_cache_flush(-1);
  583. break;
  584. case NETDEV_DOWN:
  585. fib_del_ifaddr(ifa);
  586. if (ifa->ifa_dev && ifa->ifa_dev->ifa_list == NULL) {
  587. /* Last address was deleted from this interface.
  588.    Disable IP.
  589.  */
  590. fib_disable_ip(ifa->ifa_dev->dev, 1);
  591. } else {
  592. rt_cache_flush(-1);
  593. }
  594. break;
  595. }
  596. return NOTIFY_DONE;
  597. }
  599. static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
  600. {
  601. struct net_device *dev = ptr;
  602. struct in_device *in_dev = __in_dev_get(dev);
  604. if (!in_dev)
  605. return NOTIFY_DONE;
  607. switch (event) {
  608. case NETDEV_UP:
  609. for_ifa(in_dev) {
  610. fib_add_ifaddr(ifa);
  611. } endfor_ifa(in_dev);
  612. #ifdef CONFIG_IP_ROUTE_MULTIPATH
  613. fib_sync_up(dev);
  614. #endif
  615. rt_cache_flush(-1);
  616. break;
  617. case NETDEV_DOWN:
  618. fib_disable_ip(dev, 0);
  619. break;
  620. case NETDEV_UNREGISTER:
  621. fib_disable_ip(dev, 1);
  622. break;
  623. case NETDEV_CHANGEMTU:
  624. case NETDEV_CHANGE:
  625. rt_cache_flush(0);
  626. break;
  627. }
  628. return NOTIFY_DONE;
  629. }
  631. struct notifier_block fib_inetaddr_notifier = {
  632. notifier_call: fib_inetaddr_event,
  633. };
  635. struct notifier_block fib_netdev_notifier = {
  636. notifier_call: fib_netdev_event,
  637. };
  639. void __init ip_fib_init(void)
  640. {
  641. #ifdef CONFIG_PROC_FS
  642. proc_net_create("route",0,fib_get_procinfo);
  643. #endif /* CONFIG_PROC_FS */
  645. #ifndef CONFIG_IP_MULTIPLE_TABLES
  646. local_table = fib_hash_init(RT_TABLE_LOCAL);
  647. main_table = fib_hash_init(RT_TABLE_MAIN);
  648. #else
  649. fib_rules_init();
  650. #endif
  652. register_netdevice_notifier(&fib_netdev_notifier);
  653. register_inetaddr_notifier(&fib_inetaddr_notifier);
  654. }