Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | * |
Jesper Juhl | 02c30a8 | 2005-05-05 16:16:16 -0700 | [diff] [blame] | 10 | * Authors: Ross Biro |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | #include <net/dst.h> |
| 28 | #include <net/inetpeer.h> |
| 29 | #include <net/flow.h> |
KOVACS Krisztian | 7987687 | 2008-10-01 07:35:39 -0700 | [diff] [blame] | 30 | #include <net/inet_sock.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | #include <linux/in_route.h> |
| 32 | #include <linux/rtnetlink.h> |
| 33 | #include <linux/route.h> |
| 34 | #include <linux/ip.h> |
| 35 | #include <linux/cache.h> |
Venkat Yekkirala | beb8d13 | 2006-08-04 23:12:42 -0700 | [diff] [blame] | 36 | #include <linux/security.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | |
| 38 | #ifndef __KERNEL__ |
| 39 | #warning This file is not supposed to be used outside of kernel. |
| 40 | #endif |
| 41 | |
| 42 | #define RTO_ONLINK 0x01 |
| 43 | |
| 44 | #define RTO_CONN 0 |
| 45 | /* RTO_CONN is not used (being alias for 0), but preserved not to break |
| 46 | * some modules referring to it. */ |
| 47 | |
| 48 | #define RT_CONN_FLAGS(sk) (RT_TOS(inet_sk(sk)->tos) | sock_flag(sk, SOCK_LOCALROUTE)) |
| 49 | |
| 50 | struct fib_nh; |
| 51 | struct inet_peer; |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 52 | struct rtable { |
Changli Gao | d8d1f30 | 2010-06-10 23:31:35 -0700 | [diff] [blame] | 53 | struct dst_entry dst; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
Eric Dumazet | 093c2ca | 2007-02-09 16:19:26 -0800 | [diff] [blame] | 55 | /* Cache lookup keys */ |
| 56 | struct flowi fl; |
| 57 | |
Eric Dumazet | 29e7525 | 2008-01-31 17:05:09 -0800 | [diff] [blame] | 58 | int rt_genid; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | unsigned rt_flags; |
| 60 | __u16 rt_type; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
Al Viro | f2c3fe2 | 2006-09-26 21:26:42 -0700 | [diff] [blame] | 62 | __be32 rt_dst; /* Path destination */ |
| 63 | __be32 rt_src; /* Path source */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | int rt_iif; |
| 65 | |
| 66 | /* Info on neighbour */ |
Al Viro | f2c3fe2 | 2006-09-26 21:26:42 -0700 | [diff] [blame] | 67 | __be32 rt_gateway; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | /* Miscellaneous cached information */ |
Al Viro | f2c3fe2 | 2006-09-26 21:26:42 -0700 | [diff] [blame] | 70 | __be32 rt_spec_dst; /* RFC1122 specific destination */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | struct inet_peer *peer; /* long-living peer info */ |
| 72 | }; |
| 73 | |
David S. Miller | c753796 | 2010-11-11 17:07:48 -0800 | [diff] [blame] | 74 | static inline bool rt_is_input_route(struct rtable *rt) |
| 75 | { |
| 76 | return rt->fl.iif != 0; |
| 77 | } |
| 78 | |
| 79 | static inline bool rt_is_output_route(struct rtable *rt) |
| 80 | { |
| 81 | return rt->fl.iif == 0; |
| 82 | } |
| 83 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 84 | struct ip_rt_acct { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | __u32 o_bytes; |
| 86 | __u32 o_packets; |
| 87 | __u32 i_bytes; |
| 88 | __u32 i_packets; |
| 89 | }; |
| 90 | |
Eric Dumazet | fd2c3ef | 2009-11-03 03:26:03 +0000 | [diff] [blame] | 91 | struct rt_cache_stat { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 92 | unsigned int in_hit; |
| 93 | unsigned int in_slow_tot; |
| 94 | unsigned int in_slow_mc; |
| 95 | unsigned int in_no_route; |
| 96 | unsigned int in_brd; |
| 97 | unsigned int in_martian_dst; |
| 98 | unsigned int in_martian_src; |
| 99 | unsigned int out_hit; |
| 100 | unsigned int out_slow_tot; |
| 101 | unsigned int out_slow_mc; |
| 102 | unsigned int gc_total; |
| 103 | unsigned int gc_ignored; |
| 104 | unsigned int gc_goal_miss; |
| 105 | unsigned int gc_dst_overflow; |
| 106 | unsigned int in_hlist_search; |
| 107 | unsigned int out_hlist_search; |
| 108 | }; |
| 109 | |
Tejun Heo | 7d720c3 | 2010-02-16 15:20:26 +0000 | [diff] [blame] | 110 | extern struct ip_rt_acct __percpu *ip_rt_acct; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
| 112 | struct in_device; |
| 113 | extern int ip_rt_init(void); |
Al Viro | f765522 | 2006-09-26 21:25:43 -0700 | [diff] [blame] | 114 | extern void ip_rt_redirect(__be32 old_gw, __be32 dst, __be32 new_gw, |
| 115 | __be32 src, struct net_device *dev); |
Denis V. Lunev | 76e6ebf | 2008-07-05 19:00:44 -0700 | [diff] [blame] | 116 | extern void rt_cache_flush(struct net *net, int how); |
David S. Miller | 6561a3b | 2010-12-19 21:11:20 -0800 | [diff] [blame^] | 117 | extern void rt_cache_flush_batch(struct net *net); |
Denis V. Lunev | 611c183 | 2008-01-22 22:06:48 -0800 | [diff] [blame] | 118 | extern int __ip_route_output_key(struct net *, struct rtable **, const struct flowi *flp); |
Denis V. Lunev | f206351 | 2008-01-22 22:07:34 -0800 | [diff] [blame] | 119 | extern int ip_route_output_key(struct net *, struct rtable **, struct flowi *flp); |
Denis V. Lunev | f1b050b | 2008-01-22 22:07:10 -0800 | [diff] [blame] | 120 | extern int ip_route_output_flow(struct net *, struct rtable **rp, struct flowi *flp, struct sock *sk, int flags); |
Eric Dumazet | 407eadd | 2010-05-10 11:32:55 +0000 | [diff] [blame] | 121 | |
| 122 | extern int ip_route_input_common(struct sk_buff *skb, __be32 dst, __be32 src, |
| 123 | u8 tos, struct net_device *devin, bool noref); |
| 124 | |
| 125 | static inline int ip_route_input(struct sk_buff *skb, __be32 dst, __be32 src, |
| 126 | u8 tos, struct net_device *devin) |
| 127 | { |
| 128 | return ip_route_input_common(skb, dst, src, tos, devin, false); |
| 129 | } |
| 130 | |
| 131 | static inline int ip_route_input_noref(struct sk_buff *skb, __be32 dst, __be32 src, |
| 132 | u8 tos, struct net_device *devin) |
| 133 | { |
| 134 | return ip_route_input_common(skb, dst, src, tos, devin, true); |
| 135 | } |
| 136 | |
Timo Teras | 0010e46 | 2008-04-29 03:32:25 -0700 | [diff] [blame] | 137 | extern unsigned short ip_rt_frag_needed(struct net *net, struct iphdr *iph, unsigned short new_mtu, struct net_device *dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 138 | extern void ip_rt_send_redirect(struct sk_buff *skb); |
| 139 | |
Eric W. Biederman | 6b175b2 | 2008-01-10 03:25:28 -0800 | [diff] [blame] | 140 | extern unsigned inet_addr_type(struct net *net, __be32 addr); |
| 141 | extern unsigned inet_dev_addr_type(struct net *net, const struct net_device *dev, __be32 addr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 142 | extern void ip_rt_multicast_event(struct in_device *); |
Denis V. Lunev | 1bad118 | 2008-01-10 03:29:53 -0800 | [diff] [blame] | 143 | extern int ip_rt_ioctl(struct net *, unsigned int cmd, void __user *arg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | extern void ip_rt_get_source(u8 *src, struct rtable *rt); |
| 145 | extern int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb); |
| 146 | |
Jamal Hadi Salim | 0ff60a4 | 2005-11-22 14:47:37 -0800 | [diff] [blame] | 147 | struct in_ifaddr; |
| 148 | extern void fib_add_ifaddr(struct in_ifaddr *); |
| 149 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | static inline void ip_rt_put(struct rtable * rt) |
| 151 | { |
| 152 | if (rt) |
Changli Gao | d8d1f30 | 2010-06-10 23:31:35 -0700 | [diff] [blame] | 153 | dst_release(&rt->dst); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | #define IPTOS_RT_MASK (IPTOS_TOS_MASK & ~3) |
| 157 | |
Philippe De Muyter | 4839c52 | 2007-07-09 15:32:57 -0700 | [diff] [blame] | 158 | extern const __u8 ip_tos2prio[16]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 159 | |
| 160 | static inline char rt_tos2priority(u8 tos) |
| 161 | { |
| 162 | return ip_tos2prio[IPTOS_TOS(tos)>>1]; |
| 163 | } |
| 164 | |
Al Viro | bada8ad | 2006-09-26 21:27:15 -0700 | [diff] [blame] | 165 | static inline int ip_route_connect(struct rtable **rp, __be32 dst, |
| 166 | __be32 src, u32 tos, int oif, u8 protocol, |
David S. Miller | 8eb9086 | 2007-02-08 02:09:21 -0800 | [diff] [blame] | 167 | __be16 sport, __be16 dport, struct sock *sk, |
| 168 | int flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | { |
| 170 | struct flowi fl = { .oif = oif, |
Laszlo Attila Toth | 4a19ec5 | 2008-01-30 19:08:16 -0800 | [diff] [blame] | 171 | .mark = sk->sk_mark, |
Changli Gao | 5811662 | 2010-11-12 18:43:55 +0000 | [diff] [blame] | 172 | .fl4_dst = dst, |
| 173 | .fl4_src = src, |
| 174 | .fl4_tos = tos, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | .proto = protocol, |
Changli Gao | 5811662 | 2010-11-12 18:43:55 +0000 | [diff] [blame] | 176 | .fl_ip_sport = sport, |
| 177 | .fl_ip_dport = dport }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 178 | int err; |
YOSHIFUJI Hideaki | 3b1e0a6 | 2008-03-26 02:26:21 +0900 | [diff] [blame] | 179 | struct net *net = sock_net(sk); |
KOVACS Krisztian | 7987687 | 2008-10-01 07:35:39 -0700 | [diff] [blame] | 180 | |
| 181 | if (inet_sk(sk)->transparent) |
| 182 | fl.flags |= FLOWI_FLAG_ANYSRC; |
| 183 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 184 | if (!dst || !src) { |
Denis V. Lunev | eee8059 | 2008-01-22 23:49:35 -0800 | [diff] [blame] | 185 | err = __ip_route_output_key(net, rp, &fl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | if (err) |
| 187 | return err; |
| 188 | fl.fl4_dst = (*rp)->rt_dst; |
| 189 | fl.fl4_src = (*rp)->rt_src; |
| 190 | ip_rt_put(*rp); |
| 191 | *rp = NULL; |
| 192 | } |
Venkat Yekkirala | beb8d13 | 2006-08-04 23:12:42 -0700 | [diff] [blame] | 193 | security_sk_classify_flow(sk, &fl); |
Denis V. Lunev | eee8059 | 2008-01-22 23:49:35 -0800 | [diff] [blame] | 194 | return ip_route_output_flow(net, rp, &fl, sk, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Patrick McHardy | 5d39a79 | 2006-01-31 17:35:35 -0800 | [diff] [blame] | 197 | static inline int ip_route_newports(struct rtable **rp, u8 protocol, |
Al Viro | 39dccd9 | 2006-09-27 18:34:41 -0700 | [diff] [blame] | 198 | __be16 sport, __be16 dport, struct sock *sk) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 199 | { |
| 200 | if (sport != (*rp)->fl.fl_ip_sport || |
| 201 | dport != (*rp)->fl.fl_ip_dport) { |
| 202 | struct flowi fl; |
| 203 | |
| 204 | memcpy(&fl, &(*rp)->fl, sizeof(fl)); |
| 205 | fl.fl_ip_sport = sport; |
| 206 | fl.fl_ip_dport = dport; |
Patrick McHardy | 5d39a79 | 2006-01-31 17:35:35 -0800 | [diff] [blame] | 207 | fl.proto = protocol; |
Ulrich Weber | fb0c5f0 | 2010-09-27 03:31:00 +0000 | [diff] [blame] | 208 | if (inet_sk(sk)->transparent) |
| 209 | fl.flags |= FLOWI_FLAG_ANYSRC; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | ip_rt_put(*rp); |
| 211 | *rp = NULL; |
Venkat Yekkirala | beb8d13 | 2006-08-04 23:12:42 -0700 | [diff] [blame] | 212 | security_sk_classify_flow(sk, &fl); |
YOSHIFUJI Hideaki | 3b1e0a6 | 2008-03-26 02:26:21 +0900 | [diff] [blame] | 213 | return ip_route_output_flow(sock_net(sk), rp, &fl, sk, 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | } |
| 215 | return 0; |
| 216 | } |
| 217 | |
| 218 | extern void rt_bind_peer(struct rtable *rt, int create); |
| 219 | |
| 220 | static inline struct inet_peer *rt_get_peer(struct rtable *rt) |
| 221 | { |
| 222 | if (rt->peer) |
| 223 | return rt->peer; |
| 224 | |
| 225 | rt_bind_peer(rt, 0); |
| 226 | return rt->peer; |
| 227 | } |
| 228 | |
KOVACS Krisztian | 1668e01 | 2008-10-01 07:33:10 -0700 | [diff] [blame] | 229 | static inline int inet_iif(const struct sk_buff *skb) |
| 230 | { |
Eric Dumazet | 511c3f9 | 2009-06-02 05:14:27 +0000 | [diff] [blame] | 231 | return skb_rtable(skb)->rt_iif; |
KOVACS Krisztian | 1668e01 | 2008-10-01 07:33:10 -0700 | [diff] [blame] | 232 | } |
| 233 | |
David S. Miller | 323e126 | 2010-12-12 21:55:08 -0800 | [diff] [blame] | 234 | extern int sysctl_ip_default_ttl; |
| 235 | |
| 236 | static inline int ip4_dst_hoplimit(const struct dst_entry *dst) |
| 237 | { |
| 238 | int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT); |
| 239 | |
| 240 | if (hoplimit == 0) |
| 241 | hoplimit = sysctl_ip_default_ttl; |
| 242 | return hoplimit; |
| 243 | } |
| 244 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | #endif /* _ROUTE_H */ |