sctp: remove useless arguments from get_saddr() call
[linux-2.6.git] / include / net / route.h
index b8c1f77..3684c3e 100644 (file)
 #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 fib_info;
 struct rtable {
        struct dst_entry        dst;
 
-       /* Cache lookup keys */
-       struct flowi            fl;
+       /* Lookup key. */
+       __be32                  rt_key_dst;
+       __be32                  rt_key_src;
 
        int                     rt_genid;
        unsigned                rt_flags;
        __u16                   rt_type;
+       __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;
 
        /* 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 */
 };
 
 static inline bool rt_is_input_route(struct rtable *rt)
 {
-       return rt->fl.iif != 0;
+       return rt->rt_route_iif != 0;
 }
 
 static inline bool rt_is_output_route(struct rtable *rt)
 {
-       return rt->fl.iif == 0;
+       return rt->rt_route_iif == 0;
 }
 
 struct ip_rt_acct {
@@ -114,10 +118,59 @@ 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            rt_cache_flush(struct net *net, int how);
-extern void            rt_cache_flush_batch(void);
-extern int             __ip_route_output_key(struct net *, struct rtable **, const struct flowi *flp);
-extern int             ip_route_output_key(struct net *, struct rtable **, struct flowi *flp);
-extern int             ip_route_output_flow(struct net *, struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
+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);
@@ -134,7 +187,8 @@ static inline int ip_route_input_noref(struct sk_buff *skb, __be32 dst, __be32 s
        return ip_route_input_common(skb, dst, src, tos, devin, true);
 }
 
-extern unsigned short  ip_rt_frag_needed(struct net *net, struct iphdr *iph, unsigned short new_mtu, struct net_device *dev);
+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(struct net *net, __be32 addr);
@@ -146,6 +200,7 @@ 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)
 {
@@ -162,57 +217,61 @@ 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,
-                                  __be16 sport, __be16 dport, struct sock *sk,
-                                  int flags)
+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,
-                           .mark = sk->sk_mark,
-                           .fl4_dst = dst,
-                           .fl4_src = src,
-                           .fl4_tos = tos,
-                           .proto = protocol,
-                           .fl_ip_sport = sport,
-                           .fl_ip_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)
-               fl.flags |= FLOWI_FLAG_ANYSRC;
+               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(net, 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(net, rp, &fl, sk, flags);
+       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,
-                                   __be16 sport, __be16 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;
+       if (sport != orig_sport || dport != orig_dport) {
+               struct flowi4 fl4;
+               __u8 flow_flags;
+
+               flow_flags = 0;
                if (inet_sk(sk)->transparent)
-                       fl.flags |= FLOWI_FLAG_ANYSRC;
-               ip_rt_put(*rp);
-               *rp = NULL;
-               security_sk_classify_flow(sk, &fl);
-               return ip_route_output_flow(sock_net(sk), rp, &fl, sk, 0);
+                       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);
@@ -231,4 +290,15 @@ 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 */