home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / net / route.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  5.2 KB  |  204 lines
  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.  *        Definitions for the IP router.
  7.  *
  8.  * Version:    @(#)route.h    1.0.4    05/27/93
  9.  *
  10.  * Authors:    Ross Biro
  11.  *        Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12.  * Fixes:
  13.  *        Alan Cox    :    Reformatted. Added ip_rt_local()
  14.  *        Alan Cox    :    Support for TCP parameters.
  15.  *        Alexey Kuznetsov:    Major changes for new routing code.
  16.  *        Mike McLagan    :    Routing by source
  17.  *        Robert Olsson   :    Added rt_cache statistics
  18.  *
  19.  *        This program is free software; you can redistribute it and/or
  20.  *        modify it under the terms of the GNU General Public License
  21.  *        as published by the Free Software Foundation; either version
  22.  *        2 of the License, or (at your option) any later version.
  23.  */
  24. #ifndef _ROUTE_H
  25. #define _ROUTE_H
  26.  
  27. #include <net/dst.h>
  28. #include <net/inetpeer.h>
  29. #include <net/flow.h>
  30. #include <linux/in_route.h>
  31. #include <linux/rtnetlink.h>
  32. #include <linux/route.h>
  33. #include <linux/ip.h>
  34. #include <linux/cache.h>
  35.  
  36. #ifndef __KERNEL__
  37. #warning This file is not supposed to be used outside of kernel.
  38. #endif
  39.  
  40. #define RTO_ONLINK    0x01
  41.  
  42. #define RTO_CONN    0
  43. /* RTO_CONN is not used (being alias for 0), but preserved not to break
  44.  * some modules referring to it. */
  45.  
  46. #define RT_CONN_FLAGS(sk)   (RT_TOS(inet_sk(sk)->tos) | sock_flag(sk, SOCK_LOCALROUTE))
  47.  
  48. struct fib_nh;
  49. struct inet_peer;
  50. struct rtable
  51. {
  52.     union
  53.     {
  54.         struct dst_entry    dst;
  55.         struct rtable        *rt_next;
  56.     } u;
  57.  
  58.     struct in_device    *idev;
  59.     
  60.     unsigned        rt_flags;
  61.     __u16            rt_type;
  62.     __u16            rt_multipath_alg;
  63.  
  64.     __u32            rt_dst;    /* Path destination    */
  65.     __u32            rt_src;    /* Path source        */
  66.     int            rt_iif;
  67.  
  68.     /* Info on neighbour */
  69.     __u32            rt_gateway;
  70.  
  71.     /* Cache lookup keys */
  72.     struct flowi        fl;
  73.  
  74.     /* Miscellaneous cached information */
  75.     __u32            rt_spec_dst; /* RFC1122 specific destination */
  76.     struct inet_peer    *peer; /* long-living peer info */
  77. };
  78.  
  79. struct ip_rt_acct
  80. {
  81.     __u32     o_bytes;
  82.     __u32     o_packets;
  83.     __u32     i_bytes;
  84.     __u32     i_packets;
  85. };
  86.  
  87. struct rt_cache_stat 
  88. {
  89.         unsigned int in_hit;
  90.         unsigned int in_slow_tot;
  91.         unsigned int in_slow_mc;
  92.         unsigned int in_no_route;
  93.         unsigned int in_brd;
  94.         unsigned int in_martian_dst;
  95.         unsigned int in_martian_src;
  96.         unsigned int out_hit;
  97.         unsigned int out_slow_tot;
  98.         unsigned int out_slow_mc;
  99.         unsigned int gc_total;
  100.         unsigned int gc_ignored;
  101.         unsigned int gc_goal_miss;
  102.         unsigned int gc_dst_overflow;
  103.         unsigned int in_hlist_search;
  104.         unsigned int out_hlist_search;
  105. };
  106.  
  107. extern struct ip_rt_acct *ip_rt_acct;
  108.  
  109. struct in_device;
  110. extern int        ip_rt_init(void);
  111. extern void        ip_rt_redirect(u32 old_gw, u32 dst, u32 new_gw,
  112.                        u32 src, struct net_device *dev);
  113. extern void        ip_rt_advice(struct rtable **rp, int advice);
  114. extern void        rt_cache_flush(int how);
  115. extern int        __ip_route_output_key(struct rtable **, const struct flowi *flp);
  116. extern int        ip_route_output_key(struct rtable **, struct flowi *flp);
  117. extern int        ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
  118. extern int        ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin);
  119. extern unsigned short    ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
  120. extern void        ip_rt_send_redirect(struct sk_buff *skb);
  121.  
  122. extern unsigned        inet_addr_type(u32 addr);
  123. extern void        ip_rt_multicast_event(struct in_device *);
  124. extern int        ip_rt_ioctl(unsigned int cmd, void __user *arg);
  125. extern void        ip_rt_get_source(u8 *src, struct rtable *rt);
  126. extern int        ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb);
  127.  
  128. struct in_ifaddr;
  129. extern void fib_add_ifaddr(struct in_ifaddr *);
  130.  
  131. static inline void ip_rt_put(struct rtable * rt)
  132. {
  133.     if (rt)
  134.         dst_release(&rt->u.dst);
  135. }
  136.  
  137. #define IPTOS_RT_MASK    (IPTOS_TOS_MASK & ~3)
  138.  
  139. extern __u8 ip_tos2prio[16];
  140.  
  141. static inline char rt_tos2priority(u8 tos)
  142. {
  143.     return ip_tos2prio[IPTOS_TOS(tos)>>1];
  144. }
  145.  
  146. static inline int ip_route_connect(struct rtable **rp, u32 dst,
  147.                    u32 src, u32 tos, int oif, u8 protocol,
  148.                    u16 sport, u16 dport, struct sock *sk)
  149. {
  150.     struct flowi fl = { .oif = oif,
  151.                 .nl_u = { .ip4_u = { .daddr = dst,
  152.                          .saddr = src,
  153.                          .tos   = tos } },
  154.                 .proto = protocol,
  155.                 .uli_u = { .ports =
  156.                        { .sport = sport,
  157.                      .dport = dport } } };
  158.  
  159.     int err;
  160.     if (!dst || !src) {
  161.         err = __ip_route_output_key(rp, &fl);
  162.         if (err)
  163.             return err;
  164.         fl.fl4_dst = (*rp)->rt_dst;
  165.         fl.fl4_src = (*rp)->rt_src;
  166.         ip_rt_put(*rp);
  167.         *rp = NULL;
  168.     }
  169.     return ip_route_output_flow(rp, &fl, sk, 0);
  170. }
  171.  
  172. static inline int ip_route_newports(struct rtable **rp, u8 protocol,
  173.                     u16 sport, u16 dport, struct sock *sk)
  174. {
  175.     if (sport != (*rp)->fl.fl_ip_sport ||
  176.         dport != (*rp)->fl.fl_ip_dport) {
  177.         struct flowi fl;
  178.  
  179.         memcpy(&fl, &(*rp)->fl, sizeof(fl));
  180.         fl.fl_ip_sport = sport;
  181.         fl.fl_ip_dport = dport;
  182.         fl.proto = protocol;
  183.         ip_rt_put(*rp);
  184.         *rp = NULL;
  185.         return ip_route_output_flow(rp, &fl, sk, 0);
  186.     }
  187.     return 0;
  188. }
  189.  
  190. extern void rt_bind_peer(struct rtable *rt, int create);
  191.  
  192. static inline struct inet_peer *rt_get_peer(struct rtable *rt)
  193. {
  194.     if (rt->peer)
  195.         return rt->peer;
  196.  
  197.     rt_bind_peer(rt, 0);
  198.     return rt->peer;
  199. }
  200.  
  201. extern ctl_table ipv4_route_table[];
  202.  
  203. #endif    /* _ROUTE_H */
  204.