sctp: remove useless arguments from get_saddr() call
[linux-2.6.git] / include / net / route.h
index 5875272..3684c3e 100644 (file)
@@ -27,6 +27,7 @@
 #include <net/dst.h>
 #include <net/inetpeer.h>
 #include <net/flow.h>
+#include <net/inet_sock.h>
 #include <linux/in_route.h>
 #include <linux/rtnetlink.h>
 #include <linux/route.h>
 #include <linux/cache.h>
 #include <linux/security.h>
 
-#ifndef __KERNEL__
-#warning This file is not supposed to be used outside of kernel.
-#endif
-
 #define RTO_ONLINK     0x01
 
 #define RTO_CONN       0
 
 struct fib_nh;
 struct inet_peer;
-struct rtable
-{
-       union
-       {
-               struct dst_entry        dst;
-               struct rtable           *rt_next;
-       } u;
-
-       struct in_device        *idev;
-       
+struct fib_info;
+struct rtable {
+       struct dst_entry        dst;
+
+       /* Lookup key. */
+       __be32                  rt_key_dst;
+       __be32                  rt_key_src;
+
+       int                     rt_genid;
        unsigned                rt_flags;
        __u16                   rt_type;
-       __u16                   rt_multipath_alg;
+       __u8                    rt_tos;
 
        __be32                  rt_dst; /* Path destination     */
        __be32                  rt_src; /* Path source          */
+       int                     rt_route_iif;
        int                     rt_iif;
+       int                     rt_oif;
+       __u32                   rt_mark;
 
        /* Info on neighbour */
        __be32                  rt_gateway;
 
-       /* Cache lookup keys */
-       struct flowi            fl;
-
        /* Miscellaneous cached information */
        __be32                  rt_spec_dst; /* RFC1122 specific destination */
+       u32                     rt_peer_genid;
        struct inet_peer        *peer; /* long-living peer info */
+       struct fib_info         *fi; /* for client ref to shared metrics */
 };
 
-struct ip_rt_acct
+static inline bool rt_is_input_route(struct rtable *rt)
 {
+       return rt->rt_route_iif != 0;
+}
+
+static inline bool rt_is_output_route(struct rtable *rt)
+{
+       return rt->rt_route_iif == 0;
+}
+
+struct ip_rt_acct {
        __u32   o_bytes;
        __u32   o_packets;
        __u32   i_bytes;
        __u32   i_packets;
 };
 
-struct rt_cache_stat 
-{
+struct rt_cache_stat {
         unsigned int in_hit;
         unsigned int in_slow_tot;
         unsigned int in_slow_mc;
@@ -105,89 +111,167 @@ struct rt_cache_stat
         unsigned int out_hlist_search;
 };
 
-extern struct ip_rt_acct *ip_rt_acct;
+extern struct ip_rt_acct __percpu *ip_rt_acct;
 
 struct in_device;
 extern int             ip_rt_init(void);
 extern void            ip_rt_redirect(__be32 old_gw, __be32 dst, __be32 new_gw,
                                       __be32 src, struct net_device *dev);
-extern void            ip_rt_advice(struct rtable **rp, int advice);
-extern void            rt_cache_flush(int how);
-extern int             __ip_route_output_key(struct rtable **, const struct flowi *flp);
-extern int             ip_route_output_key(struct rtable **, struct flowi *flp);
-extern int             ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
-extern int             ip_route_input(struct sk_buff*, __be32 dst, __be32 src, u8 tos, struct net_device *devin);
-extern unsigned short  ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
+extern void            rt_cache_flush(struct net *net, int how);
+extern void            rt_cache_flush_batch(struct net *net);
+extern struct rtable *__ip_route_output_key(struct net *, const struct flowi4 *flp);
+extern struct rtable *ip_route_output_flow(struct net *, struct flowi4 *flp,
+                                          struct sock *sk);
+extern struct dst_entry *ipv4_blackhole_route(struct net *net, struct dst_entry *dst_orig);
+
+static inline struct rtable *ip_route_output_key(struct net *net, struct flowi4 *flp)
+{
+       return ip_route_output_flow(net, flp, NULL);
+}
+
+static inline struct rtable *ip_route_output(struct net *net, __be32 daddr,
+                                            __be32 saddr, u8 tos, int oif)
+{
+       struct flowi4 fl4 = {
+               .flowi4_oif = oif,
+               .daddr = daddr,
+               .saddr = saddr,
+               .flowi4_tos = tos,
+       };
+       return ip_route_output_key(net, &fl4);
+}
+
+static inline struct rtable *ip_route_output_ports(struct net *net, struct sock *sk,
+                                                  __be32 daddr, __be32 saddr,
+                                                  __be16 dport, __be16 sport,
+                                                  __u8 proto, __u8 tos, int oif)
+{
+       struct flowi4 fl4;
+
+       flowi4_init_output(&fl4, oif, sk ? sk->sk_mark : 0, tos,
+                          RT_SCOPE_UNIVERSE, proto,
+                          sk ? inet_sk_flowi_flags(sk) : 0,
+                          daddr, saddr, dport, sport);
+       if (sk)
+               security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
+       return ip_route_output_flow(net, &fl4, sk);
+}
+
+static inline struct rtable *ip_route_output_gre(struct net *net,
+                                                __be32 daddr, __be32 saddr,
+                                                __be32 gre_key, __u8 tos, int oif)
+{
+       struct flowi4 fl4 = {
+               .flowi4_oif = oif,
+               .daddr = daddr,
+               .saddr = saddr,
+               .flowi4_tos = tos,
+               .flowi4_proto = IPPROTO_GRE,
+               .fl4_gre_key = gre_key,
+       };
+       return ip_route_output_key(net, &fl4);
+}
+
+extern int ip_route_input_common(struct sk_buff *skb, __be32 dst, __be32 src,
+                                u8 tos, struct net_device *devin, bool noref);
+
+static inline int ip_route_input(struct sk_buff *skb, __be32 dst, __be32 src,
+                                u8 tos, struct net_device *devin)
+{
+       return ip_route_input_common(skb, dst, src, tos, devin, false);
+}
+
+static inline int ip_route_input_noref(struct sk_buff *skb, __be32 dst, __be32 src,
+                                      u8 tos, struct net_device *devin)
+{
+       return ip_route_input_common(skb, dst, src, tos, devin, true);
+}
+
+extern unsigned short  ip_rt_frag_needed(struct net *net, const struct iphdr *iph,
+                                         unsigned short new_mtu, struct net_device *dev);
 extern void            ip_rt_send_redirect(struct sk_buff *skb);
 
-extern unsigned                inet_addr_type(__be32 addr);
+extern unsigned                inet_addr_type(struct net *net, __be32 addr);
+extern unsigned                inet_dev_addr_type(struct net *net, const struct net_device *dev, __be32 addr);
 extern void            ip_rt_multicast_event(struct in_device *);
-extern int             ip_rt_ioctl(unsigned int cmd, void __user *arg);
+extern int             ip_rt_ioctl(struct net *, unsigned int cmd, void __user *arg);
 extern void            ip_rt_get_source(u8 *src, struct rtable *rt);
 extern int             ip_rt_dump(struct sk_buff *skb,  struct netlink_callback *cb);
 
 struct in_ifaddr;
 extern void fib_add_ifaddr(struct in_ifaddr *);
+extern void fib_del_ifaddr(struct in_ifaddr *, struct in_ifaddr *);
 
 static inline void ip_rt_put(struct rtable * rt)
 {
        if (rt)
-               dst_release(&rt->u.dst);
+               dst_release(&rt->dst);
 }
 
 #define IPTOS_RT_MASK  (IPTOS_TOS_MASK & ~3)
 
-extern __u8 ip_tos2prio[16];
+extern const __u8 ip_tos2prio[16];
 
 static inline char rt_tos2priority(u8 tos)
 {
        return ip_tos2prio[IPTOS_TOS(tos)>>1];
 }
 
-static inline int ip_route_connect(struct rtable **rp, __be32 dst,
-                                  __be32 src, u32 tos, int oif, u8 protocol,
-                                  u16 sport, u16 dport, struct sock *sk)
+static inline struct rtable *ip_route_connect(__be32 dst, __be32 src, u32 tos,
+                                             int oif, u8 protocol,
+                                             __be16 sport, __be16 dport,
+                                             struct sock *sk, bool can_sleep)
 {
-       struct flowi fl = { .oif = oif,
-                           .nl_u = { .ip4_u = { .daddr = dst,
-                                                .saddr = src,
-                                                .tos   = tos } },
-                           .proto = protocol,
-                           .uli_u = { .ports =
-                                      { .sport = sport,
-                                        .dport = dport } } };
-
-       int err;
+       struct net *net = sock_net(sk);
+       struct rtable *rt;
+       struct flowi4 fl4;
+       __u8 flow_flags;
+
+       flow_flags = 0;
+       if (inet_sk(sk)->transparent)
+               flow_flags |= FLOWI_FLAG_ANYSRC;
+       if (protocol == IPPROTO_TCP)
+               flow_flags |= FLOWI_FLAG_PRECOW_METRICS;
+       if (can_sleep)
+               flow_flags |= FLOWI_FLAG_CAN_SLEEP;
+
+       flowi4_init_output(&fl4, oif, sk->sk_mark, tos, RT_SCOPE_UNIVERSE,
+                          protocol, flow_flags, dst, src, dport, sport);
+
        if (!dst || !src) {
-               err = __ip_route_output_key(rp, &fl);
-               if (err)
-                       return err;
-               fl.fl4_dst = (*rp)->rt_dst;
-               fl.fl4_src = (*rp)->rt_src;
-               ip_rt_put(*rp);
-               *rp = NULL;
+               rt = __ip_route_output_key(net, &fl4);
+               if (IS_ERR(rt))
+                       return rt;
+               fl4.daddr = rt->rt_dst;
+               fl4.saddr = rt->rt_src;
+               ip_rt_put(rt);
        }
-       security_sk_classify_flow(sk, &fl);
-       return ip_route_output_flow(rp, &fl, sk, 0);
+       security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
+       return ip_route_output_flow(net, &fl4, sk);
 }
 
-static inline int ip_route_newports(struct rtable **rp, u8 protocol,
-                                   u16 sport, u16 dport, struct sock *sk)
+static inline struct rtable *ip_route_newports(struct rtable *rt,
+                                              u8 protocol, __be16 orig_sport,
+                                              __be16 orig_dport, __be16 sport,
+                                              __be16 dport, struct sock *sk)
 {
-       if (sport != (*rp)->fl.fl_ip_sport ||
-           dport != (*rp)->fl.fl_ip_dport) {
-               struct flowi fl;
-
-               memcpy(&fl, &(*rp)->fl, sizeof(fl));
-               fl.fl_ip_sport = sport;
-               fl.fl_ip_dport = dport;
-               fl.proto = protocol;
-               ip_rt_put(*rp);
-               *rp = NULL;
-               security_sk_classify_flow(sk, &fl);
-               return ip_route_output_flow(rp, &fl, sk, 0);
+       if (sport != orig_sport || dport != orig_dport) {
+               struct flowi4 fl4;
+               __u8 flow_flags;
+
+               flow_flags = 0;
+               if (inet_sk(sk)->transparent)
+                       flow_flags |= FLOWI_FLAG_ANYSRC;
+               if (protocol == IPPROTO_TCP)
+                       flow_flags |= FLOWI_FLAG_PRECOW_METRICS;
+               flowi4_init_output(&fl4, rt->rt_oif, rt->rt_mark, rt->rt_tos,
+                                  RT_SCOPE_UNIVERSE, protocol, flow_flags,
+                                  rt->rt_dst, rt->rt_src, dport, sport);
+               ip_rt_put(rt);
+               security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
+               return ip_route_output_flow(sock_net(sk), &fl4, sk);
        }
-       return 0;
+       return rt;
 }
 
 extern void rt_bind_peer(struct rtable *rt, int create);
@@ -201,6 +285,20 @@ static inline struct inet_peer *rt_get_peer(struct rtable *rt)
        return rt->peer;
 }
 
-extern ctl_table ipv4_route_table[];
+static inline int inet_iif(const struct sk_buff *skb)
+{
+       return skb_rtable(skb)->rt_iif;
+}
+
+extern int sysctl_ip_default_ttl;
+
+static inline int ip4_dst_hoplimit(const struct dst_entry *dst)
+{
+       int hoplimit = dst_metric_raw(dst, RTAX_HOPLIMIT);
+
+       if (hoplimit == 0)
+               hoplimit = sysctl_ip_default_ttl;
+       return hoplimit;
+}
 
 #endif /* _ROUTE_H */