Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9d6ec938 authored by David S. Miller's avatar David S. Miller
Browse files

ipv4: Use flowi4 in public route lookup interfaces. 



Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 68a5e3dd

include/net/route.h

+59 −59
Original line number Diff line number Diff line
@@ -122,12 +122,12 @@ 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(struct net *net);

extern struct rtable *__ip_route_output_key(struct net *, const struct flowi *flp);

extern struct rtable *ip_route_output_flow(struct net *, struct flowi *flp,

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 flowi *flp)

static inline struct rtable *ip_route_output_key(struct net *net, struct flowi4 *flp)

{

	return ip_route_output_flow(net, flp, NULL);

}
@@ -135,13 +135,13 @@ static inline struct rtable *ip_route_output_key(struct net *net, struct flowi * 
static inline struct rtable *ip_route_output(struct net *net, __be32 daddr,

					     __be32 saddr, u8 tos, int oif)

{

	struct flowi fl = {

		.flowi_oif = oif,

		.fl4_dst = daddr,

		.fl4_src = saddr,

		.fl4_tos = tos,

	struct flowi4 fl4 = {

		.flowi4_oif = oif,

		.daddr = daddr,

		.saddr = saddr,

		.flowi4_tos = tos,

	};

	return ip_route_output_key(net, &fl);

	return ip_route_output_key(net, &fl4);

}



static inline struct rtable *ip_route_output_ports(struct net *net, struct sock *sk,
@@ -149,35 +149,35 @@ static inline struct rtable *ip_route_output_ports(struct net *net, struct sock 
						   __be16 dport, __be16 sport,

						   __u8 proto, __u8 tos, int oif)

{

	struct flowi fl = {

		.flowi_oif = oif,

		.flowi_flags = sk ? inet_sk_flowi_flags(sk) : 0,

		.flowi_mark = sk ? sk->sk_mark : 0,

		.fl4_dst = daddr,

		.fl4_src = saddr,

		.fl4_tos = tos,

		.flowi_proto = proto,

		.fl4_dport = dport,

		.fl4_sport = sport,

	struct flowi4 fl4 = {

		.flowi4_oif = oif,

		.flowi4_flags = sk ? inet_sk_flowi_flags(sk) : 0,

		.flowi4_mark = sk ? sk->sk_mark : 0,

		.daddr = daddr,

		.saddr = saddr,

		.flowi4_tos = tos,

		.flowi4_proto = proto,

		.uli.ports.dport = dport,

		.uli.ports.sport = sport,

	};

	if (sk)

		security_sk_classify_flow(sk, &fl);

	return ip_route_output_flow(net, &fl, 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 flowi fl = {

		.flowi_oif = oif,

		.fl4_dst = daddr,

		.fl4_src = saddr,

		.fl4_tos = tos,

		.flowi_proto = IPPROTO_GRE,

		.fl4_gre_key = gre_key,

	struct flowi4 fl4 = {

		.flowi4_oif = oif,

		.daddr = daddr,

		.saddr = saddr,

		.flowi4_tos = tos,

		.flowi4_proto = IPPROTO_GRE,

		.uli.gre_key = gre_key,

	};

	return ip_route_output_key(net, &fl);

	return ip_route_output_key(net, &fl4);

}



extern int ip_route_input_common(struct sk_buff *skb, __be32 dst, __be32 src,
@@ -228,36 +228,36 @@ static inline struct rtable *ip_route_connect(__be32 dst, __be32 src, u32 tos, 
					      __be16 sport, __be16 dport,

					      struct sock *sk, bool can_sleep)

{

	struct flowi fl = {

		.flowi_oif = oif,

		.flowi_mark = sk->sk_mark,

		.fl4_dst = dst,

		.fl4_src = src,

		.fl4_tos = tos,

		.flowi_proto = protocol,

		.fl4_sport = sport,

		.fl4_dport = dport,

	struct flowi4 fl4 = {

		.flowi4_oif = oif,

		.flowi4_mark = sk->sk_mark,

		.daddr = dst,

		.saddr = src,

		.flowi4_tos = tos,

		.flowi4_proto = protocol,

		.uli.ports.sport = sport,

		.uli.ports.dport = dport,

	};

	struct net *net = sock_net(sk);

	struct rtable *rt;



	if (inet_sk(sk)->transparent)

		fl.flowi_flags |= FLOWI_FLAG_ANYSRC;

		fl4.flowi4_flags |= FLOWI_FLAG_ANYSRC;

	if (protocol == IPPROTO_TCP)

		fl.flowi_flags |= FLOWI_FLAG_PRECOW_METRICS;

		fl4.flowi4_flags |= FLOWI_FLAG_PRECOW_METRICS;

	if (can_sleep)

		fl.flowi_flags |= FLOWI_FLAG_CAN_SLEEP;

		fl4.flowi4_flags |= FLOWI_FLAG_CAN_SLEEP;



	if (!dst || !src) {

		rt = __ip_route_output_key(net, &fl);

		rt = __ip_route_output_key(net, &fl4);

		if (IS_ERR(rt))

			return rt;

		fl.fl4_dst = rt->rt_dst;

		fl.fl4_src = rt->rt_src;

		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, &fl, sk);

	security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));

	return ip_route_output_flow(net, &fl4, sk);

}



static inline struct rtable *ip_route_newports(struct rtable *rt,
@@ -266,23 +266,23 @@ static inline struct rtable *ip_route_newports(struct rtable *rt, 
					       __be16 dport, struct sock *sk)

{

	if (sport != orig_sport || dport != orig_dport) {

		struct flowi fl = {

			.flowi_oif = rt->rt_oif,

			.flowi_mark = rt->rt_mark,

			.fl4_dst = rt->rt_key_dst,

			.fl4_src = rt->rt_key_src,

			.fl4_tos = rt->rt_tos,

			.flowi_proto = protocol,

			.fl4_sport = sport,

			.fl4_dport = dport

		struct flowi4 fl4 = {

			.flowi4_oif = rt->rt_oif,

			.flowi4_mark = rt->rt_mark,

			.daddr = rt->rt_key_dst,

			.saddr = rt->rt_key_src,

			.flowi4_tos = rt->rt_tos,

			.flowi4_proto = protocol,

			.uli.ports.sport = sport,

			.uli.ports.dport = dport

		};

		if (inet_sk(sk)->transparent)

			fl.flowi_flags |= FLOWI_FLAG_ANYSRC;

			fl4.flowi4_flags |= FLOWI_FLAG_ANYSRC;

		if (protocol == IPPROTO_TCP)

			fl.flowi_flags |= FLOWI_FLAG_PRECOW_METRICS;

			fl4.flowi4_flags |= FLOWI_FLAG_PRECOW_METRICS;

		ip_rt_put(rt);

		security_sk_classify_flow(sk, &fl);

		return ip_route_output_flow(sock_net(sk), &fl, sk);

		security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));

		return ip_route_output_flow(sock_net(sk), &fl4, sk);

	}

	return rt;

}

net/dccp/ipv4.c

+10 −10
Original line number Diff line number Diff line
@@ -465,18 +465,18 @@ static struct dst_entry* dccp_v4_route_skb(struct net *net, struct sock *sk, 
					   struct sk_buff *skb)

{

	struct rtable *rt;

	struct flowi fl = {

		.flowi_oif = skb_rtable(skb)->rt_iif,

		.fl4_dst = ip_hdr(skb)->saddr,

		.fl4_src = ip_hdr(skb)->daddr,

		.fl4_tos = RT_CONN_FLAGS(sk),

		.flowi_proto = sk->sk_protocol,

		.fl4_sport = dccp_hdr(skb)->dccph_dport,

		.fl4_dport = dccp_hdr(skb)->dccph_sport,

	struct flowi4 fl4 = {

		.flowi4_oif = skb_rtable(skb)->rt_iif,

		.daddr = ip_hdr(skb)->saddr,

		.saddr = ip_hdr(skb)->daddr,

		.flowi4_tos = RT_CONN_FLAGS(sk),

		.flowi4_proto = sk->sk_protocol,

		.uli.ports.sport = dccp_hdr(skb)->dccph_dport,

		.uli.ports.dport = dccp_hdr(skb)->dccph_sport,

	};



	security_skb_classify_flow(skb, &fl);

	rt = ip_route_output_flow(net, &fl, sk);

	security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));

	rt = ip_route_output_flow(net, &fl4, sk);

	if (IS_ERR(rt)) {

		IP_INC_STATS_BH(net, IPSTATS_MIB_OUTNOROUTES);

		return NULL;

net/ipv4/icmp.c

+31 −28
Original line number Diff line number Diff line
@@ -353,14 +353,14 @@ static void icmp_reply(struct icmp_bxm *icmp_param, struct sk_buff *skb) 
			daddr = icmp_param->replyopts.faddr;

	}

	{

		struct flowi fl = {

			.fl4_dst = daddr,

			.fl4_src = rt->rt_spec_dst,

			.fl4_tos = RT_TOS(ip_hdr(skb)->tos),

			.flowi_proto = IPPROTO_ICMP,

		struct flowi4 fl4 = {

			.daddr = daddr,

			.saddr = rt->rt_spec_dst,

			.flowi4_tos = RT_TOS(ip_hdr(skb)->tos),

			.flowi4_proto = IPPROTO_ICMP,

		};

		security_skb_classify_flow(skb, &fl);

		rt = ip_route_output_key(net, &fl);

		security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));

		rt = ip_route_output_key(net, &fl4);

		if (IS_ERR(rt))

			goto out_unlock;

	}
@@ -378,30 +378,31 @@ static struct rtable *icmp_route_lookup(struct net *net, struct sk_buff *skb_in, 
					int type, int code,

					struct icmp_bxm *param)

{

	struct flowi fl = {

		.fl4_dst = (param->replyopts.srr ?

	struct flowi4 fl4 = {

		.daddr = (param->replyopts.srr ?

			  param->replyopts.faddr : iph->saddr),

		.fl4_src = saddr,

		.fl4_tos = RT_TOS(tos),

		.flowi_proto = IPPROTO_ICMP,

		.fl4_icmp_type = type,

		.fl4_icmp_code = code,

		.saddr = saddr,

		.flowi4_tos = RT_TOS(tos),

		.flowi4_proto = IPPROTO_ICMP,

		.uli.icmpt.type = type,

		.uli.icmpt.code = code,

	};

	struct rtable *rt, *rt2;

	int err;



	security_skb_classify_flow(skb_in, &fl);

	rt = __ip_route_output_key(net, &fl);

	security_skb_classify_flow(skb_in, flowi4_to_flowi(&fl4));

	rt = __ip_route_output_key(net, &fl4);

	if (IS_ERR(rt))

		return rt;



	/* No need to clone since we're just using its address. */

	rt2 = rt;



	if (!fl.fl4_src)

		fl.fl4_src = rt->rt_src;

	if (!fl4.saddr)

		fl4.saddr = rt->rt_src;



	rt = (struct rtable *) xfrm_lookup(net, &rt->dst, &fl, NULL, 0);

	rt = (struct rtable *) xfrm_lookup(net, &rt->dst,

					   flowi4_to_flowi(&fl4), NULL, 0);

	if (!IS_ERR(rt)) {

		if (rt != rt2)

			return rt;
@@ -410,27 +411,27 @@ static struct rtable *icmp_route_lookup(struct net *net, struct sk_buff *skb_in, 
	} else

		return rt;



	err = xfrm_decode_session_reverse(skb_in, &fl, AF_INET);

	err = xfrm_decode_session_reverse(skb_in, flowi4_to_flowi(&fl4), AF_INET);

	if (err)

		goto relookup_failed;



	if (inet_addr_type(net, fl.fl4_src) == RTN_LOCAL) {

		rt2 = __ip_route_output_key(net, &fl);

	if (inet_addr_type(net, fl4.saddr) == RTN_LOCAL) {

		rt2 = __ip_route_output_key(net, &fl4);

		if (IS_ERR(rt2))

			err = PTR_ERR(rt2);

	} else {

		struct flowi fl2 = {};

		struct flowi4 fl4_2 = {};

		unsigned long orefdst;



		fl2.fl4_dst = fl.fl4_src;

		rt2 = ip_route_output_key(net, &fl2);

		fl4_2.daddr = fl4.saddr;

		rt2 = ip_route_output_key(net, &fl4_2);

		if (IS_ERR(rt2)) {

			err = PTR_ERR(rt2);

			goto relookup_failed;

		}

		/* Ugh! */

		orefdst = skb_in->_skb_refdst; /* save old refdst */

		err = ip_route_input(skb_in, fl.fl4_dst, fl.fl4_src,

		err = ip_route_input(skb_in, fl4.daddr, fl4.saddr,

				     RT_TOS(tos), rt2->dst.dev);



		dst_release(&rt2->dst);
@@ -441,7 +442,9 @@ static struct rtable *icmp_route_lookup(struct net *net, struct sk_buff *skb_in, 
	if (err)

		goto relookup_failed;



	rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst, &fl, NULL, XFRM_LOOKUP_ICMP);

	rt2 = (struct rtable *) xfrm_lookup(net, &rt2->dst,

					    flowi4_to_flowi(&fl4), NULL,

					    XFRM_LOOKUP_ICMP);

	if (!IS_ERR(rt2)) {

		dst_release(&rt->dst);

		rt = rt2;

net/ipv4/inet_connection_sock.c

+13 −13
Original line number Diff line number Diff line
@@ -356,22 +356,22 @@ struct dst_entry *inet_csk_route_req(struct sock *sk, 
	struct rtable *rt;

	const struct inet_request_sock *ireq = inet_rsk(req);

	struct ip_options *opt = inet_rsk(req)->opt;

	struct flowi fl = {

		.flowi_oif = sk->sk_bound_dev_if,

		.flowi_mark = sk->sk_mark,

		.fl4_dst = ((opt && opt->srr) ?

	struct flowi4 fl4 = {

		.flowi4_oif = sk->sk_bound_dev_if,

		.flowi4_mark = sk->sk_mark,

		.daddr = ((opt && opt->srr) ?

			  opt->faddr : ireq->rmt_addr),

		.fl4_src = ireq->loc_addr,

		.fl4_tos = RT_CONN_FLAGS(sk),

		.flowi_proto = sk->sk_protocol,

		.flowi_flags = inet_sk_flowi_flags(sk),

		.fl4_sport = inet_sk(sk)->inet_sport,

		.fl4_dport = ireq->rmt_port,

		.saddr = ireq->loc_addr,

		.flowi4_tos = RT_CONN_FLAGS(sk),

		.flowi4_proto = sk->sk_protocol,

		.flowi4_flags = inet_sk_flowi_flags(sk),

		.uli.ports.sport = inet_sk(sk)->inet_sport,

		.uli.ports.dport = ireq->rmt_port,

	};

	struct net *net = sock_net(sk);



	security_req_classify_flow(req, &fl);

	rt = ip_route_output_flow(net, &fl, sk);

	security_req_classify_flow(req, flowi4_to_flowi(&fl4));

	rt = ip_route_output_flow(net, &fl4, sk);

	if (IS_ERR(rt))

		goto no_route;

	if (opt && opt->is_strictroute && rt->rt_dst != rt->rt_gateway)

net/ipv4/ip_output.c

+11 −11
Original line number Diff line number Diff line
@@ -1474,18 +1474,18 @@ void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *ar 
	}



	{

		struct flowi fl = {

			.flowi_oif = arg->bound_dev_if,

			.fl4_dst = daddr,

			.fl4_src = rt->rt_spec_dst,

			.fl4_tos = RT_TOS(ip_hdr(skb)->tos),

			.fl4_sport = tcp_hdr(skb)->dest,

			.fl4_dport = tcp_hdr(skb)->source,

			.flowi_proto = sk->sk_protocol,

			.flowi_flags = ip_reply_arg_flowi_flags(arg),

		struct flowi4 fl4 = {

			.flowi4_oif = arg->bound_dev_if,

			.daddr = daddr,

			.saddr = rt->rt_spec_dst,

			.flowi4_tos = RT_TOS(ip_hdr(skb)->tos),

			.uli.ports.sport = tcp_hdr(skb)->dest,

			.uli.ports.dport = tcp_hdr(skb)->source,

			.flowi4_proto = sk->sk_protocol,

			.flowi4_flags = ip_reply_arg_flowi_flags(arg),

		};

		security_skb_classify_flow(skb, &fl);

		rt = ip_route_output_key(sock_net(sk), &fl);

		security_skb_classify_flow(skb, flowi4_to_flowi(&fl4));

		rt = ip_route_output_key(sock_net(sk), &fl4);

		if (IS_ERR(rt))

			return;

	}