1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * INET		An implementation of the TCP/IP protocol suite for the LINUX
   4 *		operating system.  INET is implemented using the  BSD Socket
   5 *		interface as the means of communication with the user level.
   6 *
   7 *		IPv4 Forwarding Information Base: FIB frontend.
   8 *
   9 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10 */
  11
  12#include <linux/module.h>
  13#include <linux/uaccess.h>
  14#include <linux/bitops.h>
  15#include <linux/capability.h>
  16#include <linux/types.h>
  17#include <linux/kernel.h>
  18#include <linux/mm.h>
  19#include <linux/string.h>
  20#include <linux/socket.h>
  21#include <linux/sockios.h>
  22#include <linux/errno.h>
  23#include <linux/in.h>
  24#include <linux/inet.h>
  25#include <linux/inetdevice.h>
  26#include <linux/netdevice.h>
  27#include <linux/if_addr.h>
  28#include <linux/if_arp.h>
  29#include <linux/skbuff.h>
  30#include <linux/cache.h>
  31#include <linux/init.h>
  32#include <linux/list.h>
  33#include <linux/slab.h>
  34
  35#include <net/inet_dscp.h>
  36#include <net/ip.h>
  37#include <net/protocol.h>
  38#include <net/route.h>
  39#include <net/tcp.h>
  40#include <net/sock.h>
  41#include <net/arp.h>
  42#include <net/ip_fib.h>
  43#include <net/nexthop.h>
  44#include <net/rtnetlink.h>
  45#include <net/xfrm.h>
  46#include <net/l3mdev.h>
  47#include <net/lwtunnel.h>
  48#include <trace/events/fib.h>
  49
  50#ifndef CONFIG_IP_MULTIPLE_TABLES
  51
  52static int __net_init fib4_rules_init(struct net *net)
  53{
  54	struct fib_table *local_table, *main_table;
  55
  56	main_table  = fib_trie_table(RT_TABLE_MAIN, NULL);
  57	if (!main_table)
  58		return -ENOMEM;
  59
  60	local_table = fib_trie_table(RT_TABLE_LOCAL, main_table);
  61	if (!local_table)
  62		goto fail;
  63
  64	hlist_add_head_rcu(&local_table->tb_hlist,
  65				&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]);
  66	hlist_add_head_rcu(&main_table->tb_hlist,
  67				&net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]);
  68	return 0;
  69
  70fail:
  71	fib_free_table(main_table);
  72	return -ENOMEM;
  73}
 
 
 
 
 
  74#else
  75
  76struct fib_table *fib_new_table(struct net *net, u32 id)
  77{
  78	struct fib_table *tb, *alias = NULL;
  79	unsigned int h;
  80
  81	if (id == 0)
  82		id = RT_TABLE_MAIN;
  83	tb = fib_get_table(net, id);
  84	if (tb)
  85		return tb;
  86
  87	if (id == RT_TABLE_LOCAL && !net->ipv4.fib_has_custom_rules)
  88		alias = fib_new_table(net, RT_TABLE_MAIN);
  89
  90	tb = fib_trie_table(id, alias);
  91	if (!tb)
  92		return NULL;
  93
  94	switch (id) {
  95	case RT_TABLE_MAIN:
  96		rcu_assign_pointer(net->ipv4.fib_main, tb);
  97		break;
  98	case RT_TABLE_DEFAULT:
  99		rcu_assign_pointer(net->ipv4.fib_default, tb);
 100		break;
 101	default:
 102		break;
 103	}
 104
 105	h = id & (FIB_TABLE_HASHSZ - 1);
 106	hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);
 107	return tb;
 108}
 109EXPORT_SYMBOL_GPL(fib_new_table);
 110
 111/* caller must hold either rtnl or rcu read lock */
 112struct fib_table *fib_get_table(struct net *net, u32 id)
 113{
 114	struct fib_table *tb;
 115	struct hlist_head *head;
 116	unsigned int h;
 117
 118	if (id == 0)
 119		id = RT_TABLE_MAIN;
 120	h = id & (FIB_TABLE_HASHSZ - 1);
 121
 122	head = &net->ipv4.fib_table_hash[h];
 123	hlist_for_each_entry_rcu(tb, head, tb_hlist,
 124				 lockdep_rtnl_is_held()) {
 125		if (tb->tb_id == id)
 126			return tb;
 127	}
 128	return NULL;
 129}
 
 
 
 
 
 130#endif /* CONFIG_IP_MULTIPLE_TABLES */
 131
 132static void fib_replace_table(struct net *net, struct fib_table *old,
 133			      struct fib_table *new)
 134{
 135#ifdef CONFIG_IP_MULTIPLE_TABLES
 136	switch (new->tb_id) {
 137	case RT_TABLE_MAIN:
 138		rcu_assign_pointer(net->ipv4.fib_main, new);
 139		break;
 140	case RT_TABLE_DEFAULT:
 141		rcu_assign_pointer(net->ipv4.fib_default, new);
 142		break;
 143	default:
 144		break;
 145	}
 146
 147#endif
 148	/* replace the old table in the hlist */
 149	hlist_replace_rcu(&old->tb_hlist, &new->tb_hlist);
 150}
 151
 152int fib_unmerge(struct net *net)
 153{
 154	struct fib_table *old, *new, *main_table;
 155
 156	/* attempt to fetch local table if it has been allocated */
 157	old = fib_get_table(net, RT_TABLE_LOCAL);
 158	if (!old)
 159		return 0;
 160
 161	new = fib_trie_unmerge(old);
 162	if (!new)
 163		return -ENOMEM;
 164
 165	/* table is already unmerged */
 166	if (new == old)
 167		return 0;
 168
 169	/* replace merged table with clean table */
 170	fib_replace_table(net, old, new);
 171	fib_free_table(old);
 172
 173	/* attempt to fetch main table if it has been allocated */
 174	main_table = fib_get_table(net, RT_TABLE_MAIN);
 175	if (!main_table)
 176		return 0;
 177
 178	/* flush local entries from main table */
 179	fib_table_flush_external(main_table);
 180
 181	return 0;
 182}
 183
 184void fib_flush(struct net *net)
 185{
 186	int flushed = 0;
 187	unsigned int h;
 188
 189	for (h = 0; h < FIB_TABLE_HASHSZ; h++) {
 190		struct hlist_head *head = &net->ipv4.fib_table_hash[h];
 191		struct hlist_node *tmp;
 192		struct fib_table *tb;
 193
 194		hlist_for_each_entry_safe(tb, tmp, head, tb_hlist)
 195			flushed += fib_table_flush(net, tb, false);
 196	}
 197
 198	if (flushed)
 199		rt_cache_flush(net);
 200}
 201
 202/*
 203 * Find address type as if only "dev" was present in the system. If
 204 * on_dev is NULL then all interfaces are taken into consideration.
 205 */
 206static inline unsigned int __inet_dev_addr_type(struct net *net,
 207						const struct net_device *dev,
 208						__be32 addr, u32 tb_id)
 209{
 210	struct flowi4		fl4 = { .daddr = addr };
 211	struct fib_result	res;
 212	unsigned int ret = RTN_BROADCAST;
 213	struct fib_table *table;
 214
 215	if (ipv4_is_zeronet(addr) || ipv4_is_lbcast(addr))
 216		return RTN_BROADCAST;
 217	if (ipv4_is_multicast(addr))
 218		return RTN_MULTICAST;
 219
 220	rcu_read_lock();
 221
 222	table = fib_get_table(net, tb_id);
 223	if (table) {
 224		ret = RTN_UNICAST;
 225		if (!fib_table_lookup(table, &fl4, &res, FIB_LOOKUP_NOREF)) {
 226			struct fib_nh_common *nhc = fib_info_nhc(res.fi, 0);
 227
 228			if (!dev || dev == nhc->nhc_dev)
 229				ret = res.type;
 230		}
 231	}
 232
 233	rcu_read_unlock();
 234	return ret;
 235}
 236
 237unsigned int inet_addr_type_table(struct net *net, __be32 addr, u32 tb_id)
 238{
 239	return __inet_dev_addr_type(net, NULL, addr, tb_id);
 240}
 241EXPORT_SYMBOL(inet_addr_type_table);
 242
 243unsigned int inet_addr_type(struct net *net, __be32 addr)
 244{
 245	return __inet_dev_addr_type(net, NULL, addr, RT_TABLE_LOCAL);
 246}
 247EXPORT_SYMBOL(inet_addr_type);
 248
 249unsigned int inet_dev_addr_type(struct net *net, const struct net_device *dev,
 250				__be32 addr)
 251{
 252	u32 rt_table = l3mdev_fib_table(dev) ? : RT_TABLE_LOCAL;
 253
 254	return __inet_dev_addr_type(net, dev, addr, rt_table);
 255}
 256EXPORT_SYMBOL(inet_dev_addr_type);
 257
 258/* inet_addr_type with dev == NULL but using the table from a dev
 259 * if one is associated
 260 */
 261unsigned int inet_addr_type_dev_table(struct net *net,
 262				      const struct net_device *dev,
 263				      __be32 addr)
 264{
 265	u32 rt_table = l3mdev_fib_table(dev) ? : RT_TABLE_LOCAL;
 266
 267	return __inet_dev_addr_type(net, NULL, addr, rt_table);
 268}
 269EXPORT_SYMBOL(inet_addr_type_dev_table);
 270
 271__be32 fib_compute_spec_dst(struct sk_buff *skb)
 272{
 273	struct net_device *dev = skb->dev;
 274	struct in_device *in_dev;
 275	struct fib_result res;
 276	struct rtable *rt;
 277	struct net *net;
 278	int scope;
 279
 280	rt = skb_rtable(skb);
 281	if ((rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST | RTCF_LOCAL)) ==
 282	    RTCF_LOCAL)
 283		return ip_hdr(skb)->daddr;
 284
 285	in_dev = __in_dev_get_rcu(dev);
 286
 287	net = dev_net(dev);
 288
 289	scope = RT_SCOPE_UNIVERSE;
 290	if (!ipv4_is_zeronet(ip_hdr(skb)->saddr)) {
 291		bool vmark = in_dev && IN_DEV_SRC_VMARK(in_dev);
 292		struct flowi4 fl4 = {
 293			.flowi4_iif = LOOPBACK_IFINDEX,
 294			.flowi4_l3mdev = l3mdev_master_ifindex_rcu(dev),
 295			.daddr = ip_hdr(skb)->saddr,
 296			.flowi4_tos = inet_dscp_to_dsfield(ip4h_dscp(ip_hdr(skb))),
 297			.flowi4_scope = scope,
 298			.flowi4_mark = vmark ? skb->mark : 0,
 299		};
 300		if (!fib_lookup(net, &fl4, &res, 0))
 301			return fib_result_prefsrc(net, &res);
 302	} else {
 303		scope = RT_SCOPE_LINK;
 304	}
 305
 306	return inet_select_addr(dev, ip_hdr(skb)->saddr, scope);
 307}
 308
 309bool fib_info_nh_uses_dev(struct fib_info *fi, const struct net_device *dev)
 310{
 311	bool dev_match = false;
 312#ifdef CONFIG_IP_ROUTE_MULTIPATH
 313	if (unlikely(fi->nh)) {
 314		dev_match = nexthop_uses_dev(fi->nh, dev);
 315	} else {
 316		int ret;
 317
 318		for (ret = 0; ret < fib_info_num_path(fi); ret++) {
 319			const struct fib_nh_common *nhc = fib_info_nhc(fi, ret);
 320
 321			if (nhc_l3mdev_matches_dev(nhc, dev)) {
 322				dev_match = true;
 323				break;
 324			}
 
 
 325		}
 326	}
 327#else
 328	if (fib_info_nhc(fi, 0)->nhc_dev == dev)
 329		dev_match = true;
 330#endif
 331
 332	return dev_match;
 333}
 334EXPORT_SYMBOL_GPL(fib_info_nh_uses_dev);
 335
 336/* Given (packet source, input interface) and optional (dst, oif, tos):
 337 * - (main) check, that source is valid i.e. not broadcast or our local
 338 *   address.
 339 * - figure out what "logical" interface this packet arrived
 340 *   and calculate "specific destination" address.
 341 * - check, that packet arrived from expected physical interface.
 342 * called with rcu_read_lock()
 343 */
 344static int __fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
 345				 dscp_t dscp, int oif, struct net_device *dev,
 346				 int rpf, struct in_device *idev, u32 *itag)
 347{
 348	struct net *net = dev_net(dev);
 349	enum skb_drop_reason reason;
 350	struct flow_keys flkeys;
 351	int ret, no_addr;
 352	struct fib_result res;
 353	struct flowi4 fl4;
 354	bool dev_match;
 355
 356	fl4.flowi4_oif = 0;
 357	fl4.flowi4_l3mdev = l3mdev_master_ifindex_rcu(dev);
 358	fl4.flowi4_iif = oif ? : LOOPBACK_IFINDEX;
 
 359	fl4.daddr = src;
 360	fl4.saddr = dst;
 361	fl4.flowi4_tos = inet_dscp_to_dsfield(dscp);
 362	fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
 363	fl4.flowi4_tun_key.tun_id = 0;
 364	fl4.flowi4_flags = 0;
 365	fl4.flowi4_uid = sock_net_uid(net, NULL);
 366	fl4.flowi4_multipath_hash = 0;
 367
 368	no_addr = idev->ifa_list == NULL;
 369
 370	fl4.flowi4_mark = IN_DEV_SRC_VMARK(idev) ? skb->mark : 0;
 371	if (!fib4_rules_early_flow_dissect(net, skb, &fl4, &flkeys)) {
 372		fl4.flowi4_proto = 0;
 373		fl4.fl4_sport = 0;
 374		fl4.fl4_dport = 0;
 375	} else {
 376		swap(fl4.fl4_sport, fl4.fl4_dport);
 377	}
 378
 379	if (fib_lookup(net, &fl4, &res, 0))
 380		goto last_resort;
 381	if (res.type != RTN_UNICAST) {
 382		if (res.type != RTN_LOCAL) {
 383			reason = SKB_DROP_REASON_IP_INVALID_SOURCE;
 384			goto e_inval;
 385		} else if (!IN_DEV_ACCEPT_LOCAL(idev)) {
 386			reason = SKB_DROP_REASON_IP_LOCAL_SOURCE;
 387			goto e_inval;
 388		}
 389	}
 390	fib_combine_itag(itag, &res);
 391
 392	dev_match = fib_info_nh_uses_dev(res.fi, dev);
 393	/* This is not common, loopback packets retain skb_dst so normally they
 394	 * would not even hit this slow path.
 395	 */
 396	dev_match = dev_match || (res.type == RTN_LOCAL &&
 397				  dev == net->loopback_dev);
 398	if (dev_match) {
 399		ret = FIB_RES_NHC(res)->nhc_scope >= RT_SCOPE_HOST;
 400		return ret;
 401	}
 402	if (no_addr)
 403		goto last_resort;
 404	if (rpf == 1)
 405		goto e_rpf;
 406	fl4.flowi4_oif = dev->ifindex;
 407
 408	ret = 0;
 409	if (fib_lookup(net, &fl4, &res, FIB_LOOKUP_IGNORE_LINKSTATE) == 0) {
 410		if (res.type == RTN_UNICAST)
 411			ret = FIB_RES_NHC(res)->nhc_scope >= RT_SCOPE_HOST;
 412	}
 413	return ret;
 414
 415last_resort:
 416	if (rpf)
 417		goto e_rpf;
 418	*itag = 0;
 419	return 0;
 420
 421e_inval:
 422	return -reason;
 423e_rpf:
 424	return -SKB_DROP_REASON_IP_RPFILTER;
 425}
 426
 427/* Ignore rp_filter for packets protected by IPsec. */
 428int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst,
 429			dscp_t dscp, int oif, struct net_device *dev,
 430			struct in_device *idev, u32 *itag)
 431{
 432	int r = secpath_exists(skb) ? 0 : IN_DEV_RPFILTER(idev);
 433	struct net *net = dev_net(dev);
 434
 435	if (!r && !fib_num_tclassid_users(net) &&
 436	    (dev->ifindex != oif || !IN_DEV_TX_REDIRECTS(idev))) {
 437		if (IN_DEV_ACCEPT_LOCAL(idev))
 438			goto ok;
 439		/* with custom local routes in place, checking local addresses
 440		 * only will be too optimistic, with custom rules, checking
 441		 * local addresses only can be too strict, e.g. due to vrf
 442		 */
 443		if (net->ipv4.fib_has_custom_local_routes ||
 444		    fib4_has_custom_rules(net))
 445			goto full_check;
 446		/* Within the same container, it is regarded as a martian source,
 447		 * and the same host but different containers are not.
 448		 */
 449		if (inet_lookup_ifaddr_rcu(net, src))
 450			return -SKB_DROP_REASON_IP_LOCAL_SOURCE;
 451
 452ok:
 453		*itag = 0;
 454		return 0;
 455	}
 456
 457full_check:
 458	return __fib_validate_source(skb, src, dst, dscp, oif, dev, r, idev,
 459				     itag);
 460}
 461
 462static inline __be32 sk_extract_addr(struct sockaddr *addr)
 463{
 464	return ((struct sockaddr_in *) addr)->sin_addr.s_addr;
 465}
 466
 467static int put_rtax(struct nlattr *mx, int len, int type, u32 value)
 468{
 469	struct nlattr *nla;
 470
 471	nla = (struct nlattr *) ((char *) mx + len);
 472	nla->nla_type = type;
 473	nla->nla_len = nla_attr_size(4);
 474	*(u32 *) nla_data(nla) = value;
 475
 476	return len + nla_total_size(4);
 477}
 478
 479static int rtentry_to_fib_config(struct net *net, int cmd, struct rtentry *rt,
 480				 struct fib_config *cfg)
 481{
 482	__be32 addr;
 483	int plen;
 484
 485	memset(cfg, 0, sizeof(*cfg));
 486	cfg->fc_nlinfo.nl_net = net;
 487
 488	if (rt->rt_dst.sa_family != AF_INET)
 489		return -EAFNOSUPPORT;
 490
 491	/*
 492	 * Check mask for validity:
 493	 * a) it must be contiguous.
 494	 * b) destination must have all host bits clear.
 495	 * c) if application forgot to set correct family (AF_INET),
 496	 *    reject request unless it is absolutely clear i.e.
 497	 *    both family and mask are zero.
 498	 */
 499	plen = 32;
 500	addr = sk_extract_addr(&rt->rt_dst);
 501	if (!(rt->rt_flags & RTF_HOST)) {
 502		__be32 mask = sk_extract_addr(&rt->rt_genmask);
 503
 504		if (rt->rt_genmask.sa_family != AF_INET) {
 505			if (mask || rt->rt_genmask.sa_family)
 506				return -EAFNOSUPPORT;
 507		}
 508
 509		if (bad_mask(mask, addr))
 510			return -EINVAL;
 511
 512		plen = inet_mask_len(mask);
 513	}
 514
 515	cfg->fc_dst_len = plen;
 516	cfg->fc_dst = addr;
 517
 518	if (cmd != SIOCDELRT) {
 519		cfg->fc_nlflags = NLM_F_CREATE;
 520		cfg->fc_protocol = RTPROT_BOOT;
 521	}
 522
 523	if (rt->rt_metric)
 524		cfg->fc_priority = rt->rt_metric - 1;
 525
 526	if (rt->rt_flags & RTF_REJECT) {
 527		cfg->fc_scope = RT_SCOPE_HOST;
 528		cfg->fc_type = RTN_UNREACHABLE;
 529		return 0;
 530	}
 531
 532	cfg->fc_scope = RT_SCOPE_NOWHERE;
 533	cfg->fc_type = RTN_UNICAST;
 534
 535	if (rt->rt_dev) {
 536		char *colon;
 537		struct net_device *dev;
 538		char devname[IFNAMSIZ];
 539
 540		if (copy_from_user(devname, rt->rt_dev, IFNAMSIZ-1))
 541			return -EFAULT;
 542
 543		devname[IFNAMSIZ-1] = 0;
 544		colon = strchr(devname, ':');
 545		if (colon)
 546			*colon = 0;
 547		dev = __dev_get_by_name(net, devname);
 548		if (!dev)
 549			return -ENODEV;
 550		cfg->fc_oif = dev->ifindex;
 551		cfg->fc_table = l3mdev_fib_table(dev);
 552		if (colon) {
 553			const struct in_ifaddr *ifa;
 554			struct in_device *in_dev;
 555
 556			in_dev = __in_dev_get_rtnl(dev);
 557			if (!in_dev)
 558				return -ENODEV;
 559
 560			*colon = ':';
 561
 562			rcu_read_lock();
 563			in_dev_for_each_ifa_rcu(ifa, in_dev) {
 564				if (strcmp(ifa->ifa_label, devname) == 0)
 565					break;
 566			}
 567			rcu_read_unlock();
 568
 569			if (!ifa)
 570				return -ENODEV;
 571			cfg->fc_prefsrc = ifa->ifa_local;
 572		}
 573	}
 574
 575	addr = sk_extract_addr(&rt->rt_gateway);
 576	if (rt->rt_gateway.sa_family == AF_INET && addr) {
 577		unsigned int addr_type;
 578
 579		cfg->fc_gw4 = addr;
 580		cfg->fc_gw_family = AF_INET;
 581		addr_type = inet_addr_type_table(net, addr, cfg->fc_table);
 582		if (rt->rt_flags & RTF_GATEWAY &&
 583		    addr_type == RTN_UNICAST)
 584			cfg->fc_scope = RT_SCOPE_UNIVERSE;
 585	}
 586
 587	if (!cfg->fc_table)
 588		cfg->fc_table = RT_TABLE_MAIN;
 589
 590	if (cmd == SIOCDELRT)
 591		return 0;
 592
 593	if (rt->rt_flags & RTF_GATEWAY && !cfg->fc_gw_family)
 594		return -EINVAL;
 595
 596	if (cfg->fc_scope == RT_SCOPE_NOWHERE)
 597		cfg->fc_scope = RT_SCOPE_LINK;
 598
 599	if (rt->rt_flags & (RTF_MTU | RTF_WINDOW | RTF_IRTT)) {
 600		struct nlattr *mx;
 601		int len = 0;
 602
 603		mx = kcalloc(3, nla_total_size(4), GFP_KERNEL);
 604		if (!mx)
 605			return -ENOMEM;
 606
 607		if (rt->rt_flags & RTF_MTU)
 608			len = put_rtax(mx, len, RTAX_ADVMSS, rt->rt_mtu - 40);
 609
 610		if (rt->rt_flags & RTF_WINDOW)
 611			len = put_rtax(mx, len, RTAX_WINDOW, rt->rt_window);
 612
 613		if (rt->rt_flags & RTF_IRTT)
 614			len = put_rtax(mx, len, RTAX_RTT, rt->rt_irtt << 3);
 615
 616		cfg->fc_mx = mx;
 617		cfg->fc_mx_len = len;
 618	}
 619
 620	return 0;
 621}
 622
 623/*
 624 * Handle IP routing ioctl calls.
 625 * These are used to manipulate the routing tables
 626 */
 627int ip_rt_ioctl(struct net *net, unsigned int cmd, struct rtentry *rt)
 628{
 629	struct fib_config cfg;
 630	int err;
 631
 632	switch (cmd) {
 633	case SIOCADDRT:		/* Add a route */
 634	case SIOCDELRT:		/* Delete a route */
 635		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
 636			return -EPERM;
 637
 638		rtnl_lock();
 639		err = rtentry_to_fib_config(net, cmd, rt, &cfg);
 640		if (err == 0) {
 641			struct fib_table *tb;
 642
 643			if (cmd == SIOCDELRT) {
 644				tb = fib_get_table(net, cfg.fc_table);
 645				if (tb)
 646					err = fib_table_delete(net, tb, &cfg,
 647							       NULL);
 648				else
 649					err = -ESRCH;
 650			} else {
 651				tb = fib_new_table(net, cfg.fc_table);
 652				if (tb)
 653					err = fib_table_insert(net, tb,
 654							       &cfg, NULL);
 655				else
 656					err = -ENOBUFS;
 657			}
 658
 659			/* allocated by rtentry_to_fib_config() */
 660			kfree(cfg.fc_mx);
 661		}
 662		rtnl_unlock();
 663		return err;
 664	}
 665	return -EINVAL;
 666}
 667
 668const struct nla_policy rtm_ipv4_policy[RTA_MAX + 1] = {
 669	[RTA_UNSPEC]		= { .strict_start_type = RTA_DPORT + 1 },
 670	[RTA_DST]		= { .type = NLA_U32 },
 671	[RTA_SRC]		= { .type = NLA_U32 },
 672	[RTA_IIF]		= { .type = NLA_U32 },
 673	[RTA_OIF]		= { .type = NLA_U32 },
 674	[RTA_GATEWAY]		= { .type = NLA_U32 },
 675	[RTA_PRIORITY]		= { .type = NLA_U32 },
 676	[RTA_PREFSRC]		= { .type = NLA_U32 },
 677	[RTA_METRICS]		= { .type = NLA_NESTED },
 678	[RTA_MULTIPATH]		= { .len = sizeof(struct rtnexthop) },
 679	[RTA_FLOW]		= { .type = NLA_U32 },
 680	[RTA_ENCAP_TYPE]	= { .type = NLA_U16 },
 681	[RTA_ENCAP]		= { .type = NLA_NESTED },
 682	[RTA_UID]		= { .type = NLA_U32 },
 683	[RTA_MARK]		= { .type = NLA_U32 },
 684	[RTA_TABLE]		= { .type = NLA_U32 },
 685	[RTA_IP_PROTO]		= { .type = NLA_U8 },
 686	[RTA_SPORT]		= { .type = NLA_U16 },
 687	[RTA_DPORT]		= { .type = NLA_U16 },
 688	[RTA_NH_ID]		= { .type = NLA_U32 },
 689};
 690
 691int fib_gw_from_via(struct fib_config *cfg, struct nlattr *nla,
 692		    struct netlink_ext_ack *extack)
 693{
 694	struct rtvia *via;
 695	int alen;
 696
 697	if (nla_len(nla) < offsetof(struct rtvia, rtvia_addr)) {
 698		NL_SET_ERR_MSG(extack, "Invalid attribute length for RTA_VIA");
 699		return -EINVAL;
 700	}
 701
 702	via = nla_data(nla);
 703	alen = nla_len(nla) - offsetof(struct rtvia, rtvia_addr);
 704
 705	switch (via->rtvia_family) {
 706	case AF_INET:
 707		if (alen != sizeof(__be32)) {
 708			NL_SET_ERR_MSG(extack, "Invalid IPv4 address in RTA_VIA");
 709			return -EINVAL;
 710		}
 711		cfg->fc_gw_family = AF_INET;
 712		cfg->fc_gw4 = *((__be32 *)via->rtvia_addr);
 713		break;
 714	case AF_INET6:
 715#if IS_ENABLED(CONFIG_IPV6)
 716		if (alen != sizeof(struct in6_addr)) {
 717			NL_SET_ERR_MSG(extack, "Invalid IPv6 address in RTA_VIA");
 718			return -EINVAL;
 719		}
 720		cfg->fc_gw_family = AF_INET6;
 721		cfg->fc_gw6 = *((struct in6_addr *)via->rtvia_addr);
 722#else
 723		NL_SET_ERR_MSG(extack, "IPv6 support not enabled in kernel");
 724		return -EINVAL;
 725#endif
 726		break;
 727	default:
 728		NL_SET_ERR_MSG(extack, "Unsupported address family in RTA_VIA");
 729		return -EINVAL;
 730	}
 731
 732	return 0;
 733}
 734
 735static int rtm_to_fib_config(struct net *net, struct sk_buff *skb,
 736			     struct nlmsghdr *nlh, struct fib_config *cfg,
 737			     struct netlink_ext_ack *extack)
 738{
 739	bool has_gw = false, has_via = false;
 740	struct nlattr *attr;
 741	int err, remaining;
 742	struct rtmsg *rtm;
 743
 744	err = nlmsg_validate_deprecated(nlh, sizeof(*rtm), RTA_MAX,
 745					rtm_ipv4_policy, extack);
 746	if (err < 0)
 747		goto errout;
 748
 749	memset(cfg, 0, sizeof(*cfg));
 750
 751	rtm = nlmsg_data(nlh);
 752
 753	if (!inet_validate_dscp(rtm->rtm_tos)) {
 754		NL_SET_ERR_MSG(extack,
 755			       "Invalid dsfield (tos): ECN bits must be 0");
 756		err = -EINVAL;
 757		goto errout;
 758	}
 759	cfg->fc_dscp = inet_dsfield_to_dscp(rtm->rtm_tos);
 760
 761	cfg->fc_dst_len = rtm->rtm_dst_len;
 
 762	cfg->fc_table = rtm->rtm_table;
 763	cfg->fc_protocol = rtm->rtm_protocol;
 764	cfg->fc_scope = rtm->rtm_scope;
 765	cfg->fc_type = rtm->rtm_type;
 766	cfg->fc_flags = rtm->rtm_flags;
 767	cfg->fc_nlflags = nlh->nlmsg_flags;
 768
 769	cfg->fc_nlinfo.portid = NETLINK_CB(skb).portid;
 770	cfg->fc_nlinfo.nlh = nlh;
 771	cfg->fc_nlinfo.nl_net = net;
 772
 773	if (cfg->fc_type > RTN_MAX) {
 774		NL_SET_ERR_MSG(extack, "Invalid route type");
 775		err = -EINVAL;
 776		goto errout;
 777	}
 778
 779	nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {
 780		switch (nla_type(attr)) {
 781		case RTA_DST:
 782			cfg->fc_dst = nla_get_be32(attr);
 783			break;
 784		case RTA_OIF:
 785			cfg->fc_oif = nla_get_u32(attr);
 786			break;
 787		case RTA_GATEWAY:
 788			has_gw = true;
 789			cfg->fc_gw4 = nla_get_be32(attr);
 790			if (cfg->fc_gw4)
 791				cfg->fc_gw_family = AF_INET;
 792			break;
 793		case RTA_VIA:
 794			has_via = true;
 795			err = fib_gw_from_via(cfg, attr, extack);
 796			if (err)
 797				goto errout;
 798			break;
 799		case RTA_PRIORITY:
 800			cfg->fc_priority = nla_get_u32(attr);
 801			break;
 802		case RTA_PREFSRC:
 803			cfg->fc_prefsrc = nla_get_be32(attr);
 804			break;
 805		case RTA_METRICS:
 806			cfg->fc_mx = nla_data(attr);
 807			cfg->fc_mx_len = nla_len(attr);
 808			break;
 809		case RTA_MULTIPATH:
 810			err = lwtunnel_valid_encap_type_attr(nla_data(attr),
 811							     nla_len(attr),
 812							     extack);
 813			if (err < 0)
 814				goto errout;
 815			cfg->fc_mp = nla_data(attr);
 816			cfg->fc_mp_len = nla_len(attr);
 817			break;
 818		case RTA_FLOW:
 819			cfg->fc_flow = nla_get_u32(attr);
 820			break;
 821		case RTA_TABLE:
 822			cfg->fc_table = nla_get_u32(attr);
 823			break;
 824		case RTA_ENCAP:
 825			cfg->fc_encap = attr;
 826			break;
 827		case RTA_ENCAP_TYPE:
 828			cfg->fc_encap_type = nla_get_u16(attr);
 829			err = lwtunnel_valid_encap_type(cfg->fc_encap_type,
 830							extack);
 831			if (err < 0)
 832				goto errout;
 833			break;
 834		case RTA_NH_ID:
 835			cfg->fc_nh_id = nla_get_u32(attr);
 836			break;
 837		}
 838	}
 839
 840	if (cfg->fc_nh_id) {
 841		if (cfg->fc_oif || cfg->fc_gw_family ||
 842		    cfg->fc_encap || cfg->fc_mp) {
 843			NL_SET_ERR_MSG(extack,
 844				       "Nexthop specification and nexthop id are mutually exclusive");
 845			return -EINVAL;
 846		}
 847	}
 848
 849	if (has_gw && has_via) {
 850		NL_SET_ERR_MSG(extack,
 851			       "Nexthop configuration can not contain both GATEWAY and VIA");
 852		return -EINVAL;
 853	}
 854
 855	if (!cfg->fc_table)
 856		cfg->fc_table = RT_TABLE_MAIN;
 857
 858	return 0;
 859errout:
 860	return err;
 861}
 862
 863static int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
 864			     struct netlink_ext_ack *extack)
 865{
 866	struct net *net = sock_net(skb->sk);
 867	struct fib_config cfg;
 868	struct fib_table *tb;
 869	int err;
 870
 871	err = rtm_to_fib_config(net, skb, nlh, &cfg, extack);
 872	if (err < 0)
 873		goto errout;
 874
 875	if (cfg.fc_nh_id && !nexthop_find_by_id(net, cfg.fc_nh_id)) {
 876		NL_SET_ERR_MSG(extack, "Nexthop id does not exist");
 877		err = -EINVAL;
 878		goto errout;
 879	}
 880
 881	tb = fib_get_table(net, cfg.fc_table);
 882	if (!tb) {
 883		NL_SET_ERR_MSG(extack, "FIB table does not exist");
 884		err = -ESRCH;
 885		goto errout;
 886	}
 887
 888	err = fib_table_delete(net, tb, &cfg, extack);
 889errout:
 890	return err;
 891}
 892
 893static int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
 894			     struct netlink_ext_ack *extack)
 895{
 896	struct net *net = sock_net(skb->sk);
 897	struct fib_config cfg;
 898	struct fib_table *tb;
 899	int err;
 900
 901	err = rtm_to_fib_config(net, skb, nlh, &cfg, extack);
 902	if (err < 0)
 903		goto errout;
 904
 905	tb = fib_new_table(net, cfg.fc_table);
 906	if (!tb) {
 907		err = -ENOBUFS;
 908		goto errout;
 909	}
 910
 911	err = fib_table_insert(net, tb, &cfg, extack);
 912	if (!err && cfg.fc_type == RTN_LOCAL)
 913		net->ipv4.fib_has_custom_local_routes = true;
 914errout:
 915	return err;
 916}
 917
 918int ip_valid_fib_dump_req(struct net *net, const struct nlmsghdr *nlh,
 919			  struct fib_dump_filter *filter,
 920			  struct netlink_callback *cb)
 921{
 922	struct netlink_ext_ack *extack = cb->extack;
 923	struct nlattr *tb[RTA_MAX + 1];
 924	struct rtmsg *rtm;
 925	int err, i;
 926
 927	if (filter->rtnl_held)
 928		ASSERT_RTNL();
 929
 930	if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
 931		NL_SET_ERR_MSG(extack, "Invalid header for FIB dump request");
 932		return -EINVAL;
 933	}
 934
 935	rtm = nlmsg_data(nlh);
 936	if (rtm->rtm_dst_len || rtm->rtm_src_len  || rtm->rtm_tos   ||
 937	    rtm->rtm_scope) {
 938		NL_SET_ERR_MSG(extack, "Invalid values in header for FIB dump request");
 939		return -EINVAL;
 940	}
 941
 942	if (rtm->rtm_flags & ~(RTM_F_CLONED | RTM_F_PREFIX)) {
 943		NL_SET_ERR_MSG(extack, "Invalid flags for FIB dump request");
 944		return -EINVAL;
 945	}
 946	if (rtm->rtm_flags & RTM_F_CLONED)
 947		filter->dump_routes = false;
 948	else
 949		filter->dump_exceptions = false;
 950
 
 951	filter->flags    = rtm->rtm_flags;
 952	filter->protocol = rtm->rtm_protocol;
 953	filter->rt_type  = rtm->rtm_type;
 954	filter->table_id = rtm->rtm_table;
 955
 956	err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
 957					    rtm_ipv4_policy, extack);
 958	if (err < 0)
 959		return err;
 960
 961	for (i = 0; i <= RTA_MAX; ++i) {
 962		int ifindex;
 963
 964		if (!tb[i])
 965			continue;
 966
 967		switch (i) {
 968		case RTA_TABLE:
 969			filter->table_id = nla_get_u32(tb[i]);
 970			break;
 971		case RTA_OIF:
 972			ifindex = nla_get_u32(tb[i]);
 973			if (filter->rtnl_held)
 974				filter->dev = __dev_get_by_index(net, ifindex);
 975			else
 976				filter->dev = dev_get_by_index_rcu(net, ifindex);
 977			if (!filter->dev)
 978				return -ENODEV;
 979			break;
 980		default:
 981			NL_SET_ERR_MSG(extack, "Unsupported attribute in dump request");
 982			return -EINVAL;
 983		}
 984	}
 985
 986	if (filter->flags || filter->protocol || filter->rt_type ||
 987	    filter->table_id || filter->dev) {
 988		filter->filter_set = 1;
 989		cb->answer_flags = NLM_F_DUMP_FILTERED;
 990	}
 991
 992	return 0;
 993}
 994EXPORT_SYMBOL_GPL(ip_valid_fib_dump_req);
 995
 996static int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb)
 997{
 998	struct fib_dump_filter filter = {
 999		.dump_routes = true,
1000		.dump_exceptions = true,
1001		.rtnl_held = false,
1002	};
1003	const struct nlmsghdr *nlh = cb->nlh;
1004	struct net *net = sock_net(skb->sk);
1005	unsigned int h, s_h;
1006	unsigned int e = 0, s_e;
1007	struct fib_table *tb;
1008	struct hlist_head *head;
1009	int dumped = 0, err = 0;
1010
1011	rcu_read_lock();
1012	if (cb->strict_check) {
1013		err = ip_valid_fib_dump_req(net, nlh, &filter, cb);
1014		if (err < 0)
1015			goto unlock;
1016	} else if (nlmsg_len(nlh) >= sizeof(struct rtmsg)) {
1017		struct rtmsg *rtm = nlmsg_data(nlh);
1018
1019		filter.flags = rtm->rtm_flags & (RTM_F_PREFIX | RTM_F_CLONED);
1020	}
1021
1022	/* ipv4 does not use prefix flag */
1023	if (filter.flags & RTM_F_PREFIX)
1024		goto unlock;
1025
1026	if (filter.table_id) {
1027		tb = fib_get_table(net, filter.table_id);
1028		if (!tb) {
1029			if (rtnl_msg_family(cb->nlh) != PF_INET)
1030				goto unlock;
1031
1032			NL_SET_ERR_MSG(cb->extack, "ipv4: FIB table does not exist");
1033			err = -ENOENT;
1034			goto unlock;
1035		}
 
1036		err = fib_table_dump(tb, skb, cb, &filter);
1037		goto unlock;
1038	}
1039
1040	s_h = cb->args[0];
1041	s_e = cb->args[1];
1042
1043	err = 0;
 
1044	for (h = s_h; h < FIB_TABLE_HASHSZ; h++, s_e = 0) {
1045		e = 0;
1046		head = &net->ipv4.fib_table_hash[h];
1047		hlist_for_each_entry_rcu(tb, head, tb_hlist) {
1048			if (e < s_e)
1049				goto next;
1050			if (dumped)
1051				memset(&cb->args[2], 0, sizeof(cb->args) -
1052						 2 * sizeof(cb->args[0]));
1053			err = fib_table_dump(tb, skb, cb, &filter);
1054			if (err < 0)
1055				goto out;
 
 
 
 
1056			dumped = 1;
1057next:
1058			e++;
1059		}
1060	}
1061out:
 
 
 
1062
1063	cb->args[1] = e;
1064	cb->args[0] = h;
1065
1066unlock:
1067	rcu_read_unlock();
1068	return err;
1069}
1070
1071/* Prepare and feed intra-kernel routing request.
1072 * Really, it should be netlink message, but :-( netlink
1073 * can be not configured, so that we feed it directly
1074 * to fib engine. It is legal, because all events occur
1075 * only when netlink is already locked.
1076 */
1077static void fib_magic(int cmd, int type, __be32 dst, int dst_len,
1078		      struct in_ifaddr *ifa, u32 rt_priority)
1079{
1080	struct net *net = dev_net(ifa->ifa_dev->dev);
1081	u32 tb_id = l3mdev_fib_table(ifa->ifa_dev->dev);
1082	struct fib_table *tb;
1083	struct fib_config cfg = {
1084		.fc_protocol = RTPROT_KERNEL,
1085		.fc_type = type,
1086		.fc_dst = dst,
1087		.fc_dst_len = dst_len,
1088		.fc_priority = rt_priority,
1089		.fc_prefsrc = ifa->ifa_local,
1090		.fc_oif = ifa->ifa_dev->dev->ifindex,
1091		.fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,
1092		.fc_nlinfo = {
1093			.nl_net = net,
1094		},
1095	};
1096
1097	if (!tb_id)
1098		tb_id = (type == RTN_UNICAST) ? RT_TABLE_MAIN : RT_TABLE_LOCAL;
1099
1100	tb = fib_new_table(net, tb_id);
1101	if (!tb)
1102		return;
1103
1104	cfg.fc_table = tb->tb_id;
1105
1106	if (type != RTN_LOCAL)
1107		cfg.fc_scope = RT_SCOPE_LINK;
1108	else
1109		cfg.fc_scope = RT_SCOPE_HOST;
1110
1111	if (cmd == RTM_NEWROUTE)
1112		fib_table_insert(net, tb, &cfg, NULL);
1113	else
1114		fib_table_delete(net, tb, &cfg, NULL);
1115}
1116
1117void fib_add_ifaddr(struct in_ifaddr *ifa)
1118{
1119	struct in_device *in_dev = ifa->ifa_dev;
1120	struct net_device *dev = in_dev->dev;
1121	struct in_ifaddr *prim = ifa;
1122	__be32 mask = ifa->ifa_mask;
1123	__be32 addr = ifa->ifa_local;
1124	__be32 prefix = ifa->ifa_address & mask;
1125
1126	if (ifa->ifa_flags & IFA_F_SECONDARY) {
1127		prim = inet_ifa_byprefix(in_dev, prefix, mask);
1128		if (!prim) {
1129			pr_warn("%s: bug: prim == NULL\n", __func__);
1130			return;
1131		}
1132	}
1133
1134	fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim, 0);
1135
1136	if (!(dev->flags & IFF_UP))
1137		return;
1138
1139	/* Add broadcast address, if it is explicitly assigned. */
1140	if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF)) {
1141		fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32,
1142			  prim, 0);
1143		arp_invalidate(dev, ifa->ifa_broadcast, false);
1144	}
1145
1146	if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags & IFA_F_SECONDARY) &&
1147	    (prefix != addr || ifa->ifa_prefixlen < 32)) {
1148		if (!(ifa->ifa_flags & IFA_F_NOPREFIXROUTE))
1149			fib_magic(RTM_NEWROUTE,
1150				  dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
1151				  prefix, ifa->ifa_prefixlen, prim,
1152				  ifa->ifa_rt_priority);
1153
1154		/* Add the network broadcast address, when it makes sense */
1155		if (ifa->ifa_prefixlen < 31) {
 
 
1156			fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix | ~mask,
1157				  32, prim, 0);
1158			arp_invalidate(dev, prefix | ~mask, false);
1159		}
1160	}
1161}
1162
1163void fib_modify_prefix_metric(struct in_ifaddr *ifa, u32 new_metric)
1164{
1165	__be32 prefix = ifa->ifa_address & ifa->ifa_mask;
1166	struct in_device *in_dev = ifa->ifa_dev;
1167	struct net_device *dev = in_dev->dev;
1168
1169	if (!(dev->flags & IFF_UP) ||
1170	    ifa->ifa_flags & (IFA_F_SECONDARY | IFA_F_NOPREFIXROUTE) ||
1171	    ipv4_is_zeronet(prefix) ||
1172	    (prefix == ifa->ifa_local && ifa->ifa_prefixlen == 32))
1173		return;
1174
1175	/* add the new */
1176	fib_magic(RTM_NEWROUTE,
1177		  dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
1178		  prefix, ifa->ifa_prefixlen, ifa, new_metric);
1179
1180	/* delete the old */
1181	fib_magic(RTM_DELROUTE,
1182		  dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
1183		  prefix, ifa->ifa_prefixlen, ifa, ifa->ifa_rt_priority);
1184}
1185
1186/* Delete primary or secondary address.
1187 * Optionally, on secondary address promotion consider the addresses
1188 * from subnet iprim as deleted, even if they are in device list.
1189 * In this case the secondary ifa can be in device list.
1190 */
1191void fib_del_ifaddr(struct in_ifaddr *ifa, struct in_ifaddr *iprim)
1192{
1193	struct in_device *in_dev = ifa->ifa_dev;
1194	struct net_device *dev = in_dev->dev;
1195	struct in_ifaddr *ifa1;
1196	struct in_ifaddr *prim = ifa, *prim1 = NULL;
1197	__be32 brd = ifa->ifa_address | ~ifa->ifa_mask;
1198	__be32 any = ifa->ifa_address & ifa->ifa_mask;
1199#define LOCAL_OK	1
1200#define BRD_OK		2
1201#define BRD0_OK		4
1202#define BRD1_OK		8
1203	unsigned int ok = 0;
1204	int subnet = 0;		/* Primary network */
1205	int gone = 1;		/* Address is missing */
1206	int same_prefsrc = 0;	/* Another primary with same IP */
1207
1208	if (ifa->ifa_flags & IFA_F_SECONDARY) {
1209		prim = inet_ifa_byprefix(in_dev, any, ifa->ifa_mask);
1210		if (!prim) {
1211			/* if the device has been deleted, we don't perform
1212			 * address promotion
1213			 */
1214			if (!in_dev->dead)
1215				pr_warn("%s: bug: prim == NULL\n", __func__);
1216			return;
1217		}
1218		if (iprim && iprim != prim) {
1219			pr_warn("%s: bug: iprim != prim\n", __func__);
1220			return;
1221		}
1222	} else if (!ipv4_is_zeronet(any) &&
1223		   (any != ifa->ifa_local || ifa->ifa_prefixlen < 32)) {
1224		if (!(ifa->ifa_flags & IFA_F_NOPREFIXROUTE))
1225			fib_magic(RTM_DELROUTE,
1226				  dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,
1227				  any, ifa->ifa_prefixlen, prim, 0);
1228		subnet = 1;
1229	}
1230
1231	if (in_dev->dead)
1232		goto no_promotions;
1233
1234	/* Deletion is more complicated than add.
1235	 * We should take care of not to delete too much :-)
1236	 *
1237	 * Scan address list to be sure that addresses are really gone.
1238	 */
1239	rcu_read_lock();
1240	in_dev_for_each_ifa_rcu(ifa1, in_dev) {
1241		if (ifa1 == ifa) {
1242			/* promotion, keep the IP */
1243			gone = 0;
1244			continue;
1245		}
1246		/* Ignore IFAs from our subnet */
1247		if (iprim && ifa1->ifa_mask == iprim->ifa_mask &&
1248		    inet_ifa_match(ifa1->ifa_address, iprim))
1249			continue;
1250
1251		/* Ignore ifa1 if it uses different primary IP (prefsrc) */
1252		if (ifa1->ifa_flags & IFA_F_SECONDARY) {
1253			/* Another address from our subnet? */
1254			if (ifa1->ifa_mask == prim->ifa_mask &&
1255			    inet_ifa_match(ifa1->ifa_address, prim))
1256				prim1 = prim;
1257			else {
1258				/* We reached the secondaries, so
1259				 * same_prefsrc should be determined.
1260				 */
1261				if (!same_prefsrc)
1262					continue;
1263				/* Search new prim1 if ifa1 is not
1264				 * using the current prim1
1265				 */
1266				if (!prim1 ||
1267				    ifa1->ifa_mask != prim1->ifa_mask ||
1268				    !inet_ifa_match(ifa1->ifa_address, prim1))
1269					prim1 = inet_ifa_byprefix(in_dev,
1270							ifa1->ifa_address,
1271							ifa1->ifa_mask);
1272				if (!prim1)
1273					continue;
1274				if (prim1->ifa_local != prim->ifa_local)
1275					continue;
1276			}
1277		} else {
1278			if (prim->ifa_local != ifa1->ifa_local)
1279				continue;
1280			prim1 = ifa1;
1281			if (prim != prim1)
1282				same_prefsrc = 1;
1283		}
1284		if (ifa->ifa_local == ifa1->ifa_local)
1285			ok |= LOCAL_OK;
1286		if (ifa->ifa_broadcast == ifa1->ifa_broadcast)
1287			ok |= BRD_OK;
1288		if (brd == ifa1->ifa_broadcast)
1289			ok |= BRD1_OK;
1290		if (any == ifa1->ifa_broadcast)
1291			ok |= BRD0_OK;
1292		/* primary has network specific broadcasts */
1293		if (prim1 == ifa1 && ifa1->ifa_prefixlen < 31) {
1294			__be32 brd1 = ifa1->ifa_address | ~ifa1->ifa_mask;
1295			__be32 any1 = ifa1->ifa_address & ifa1->ifa_mask;
1296
1297			if (!ipv4_is_zeronet(any1)) {
1298				if (ifa->ifa_broadcast == brd1 ||
1299				    ifa->ifa_broadcast == any1)
1300					ok |= BRD_OK;
1301				if (brd == brd1 || brd == any1)
1302					ok |= BRD1_OK;
1303				if (any == brd1 || any == any1)
1304					ok |= BRD0_OK;
1305			}
1306		}
1307	}
1308	rcu_read_unlock();
1309
1310no_promotions:
1311	if (!(ok & BRD_OK))
1312		fib_magic(RTM_DELROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32,
1313			  prim, 0);
1314	if (subnet && ifa->ifa_prefixlen < 31) {
1315		if (!(ok & BRD1_OK))
1316			fib_magic(RTM_DELROUTE, RTN_BROADCAST, brd, 32,
1317				  prim, 0);
1318		if (!(ok & BRD0_OK))
1319			fib_magic(RTM_DELROUTE, RTN_BROADCAST, any, 32,
1320				  prim, 0);
1321	}
1322	if (!(ok & LOCAL_OK)) {
1323		unsigned int addr_type;
1324
1325		fib_magic(RTM_DELROUTE, RTN_LOCAL, ifa->ifa_local, 32, prim, 0);
1326
1327		/* Check, that this local address finally disappeared. */
1328		addr_type = inet_addr_type_dev_table(dev_net(dev), dev,
1329						     ifa->ifa_local);
1330		if (gone && addr_type != RTN_LOCAL) {
1331			/* And the last, but not the least thing.
1332			 * We must flush stray FIB entries.
1333			 *
1334			 * First of all, we scan fib_info list searching
1335			 * for stray nexthop entries, then ignite fib_flush.
1336			 */
1337			if (fib_sync_down_addr(dev, ifa->ifa_local))
1338				fib_flush(dev_net(dev));
1339		}
1340	}
1341#undef LOCAL_OK
1342#undef BRD_OK
1343#undef BRD0_OK
1344#undef BRD1_OK
1345}
1346
1347static void nl_fib_lookup(struct net *net, struct fib_result_nl *frn)
1348{
1349
1350	struct fib_result       res;
1351	struct flowi4           fl4 = {
1352		.flowi4_mark = frn->fl_mark,
1353		.daddr = frn->fl_addr,
1354		.flowi4_tos = frn->fl_tos & INET_DSCP_MASK,
1355		.flowi4_scope = frn->fl_scope,
1356	};
1357	struct fib_table *tb;
1358
1359	rcu_read_lock();
1360
1361	tb = fib_get_table(net, frn->tb_id_in);
1362
1363	frn->err = -ENOENT;
1364	if (tb) {
1365		local_bh_disable();
1366
1367		frn->tb_id = tb->tb_id;
1368		frn->err = fib_table_lookup(tb, &fl4, &res, FIB_LOOKUP_NOREF);
1369
1370		if (!frn->err) {
1371			frn->prefixlen = res.prefixlen;
1372			frn->nh_sel = res.nh_sel;
1373			frn->type = res.type;
1374			frn->scope = res.scope;
1375		}
1376		local_bh_enable();
1377	}
1378
1379	rcu_read_unlock();
1380}
1381
1382static void nl_fib_input(struct sk_buff *skb)
1383{
1384	struct net *net;
1385	struct fib_result_nl *frn;
1386	struct nlmsghdr *nlh;
1387	u32 portid;
1388
1389	net = sock_net(skb->sk);
1390	nlh = nlmsg_hdr(skb);
1391	if (skb->len < nlmsg_total_size(sizeof(*frn)) ||
1392	    skb->len < nlh->nlmsg_len ||
1393	    nlmsg_len(nlh) < sizeof(*frn))
1394		return;
1395
1396	skb = netlink_skb_clone(skb, GFP_KERNEL);
1397	if (!skb)
1398		return;
1399	nlh = nlmsg_hdr(skb);
1400
1401	frn = nlmsg_data(nlh);
1402	nl_fib_lookup(net, frn);
1403
1404	portid = NETLINK_CB(skb).portid;      /* netlink portid */
1405	NETLINK_CB(skb).portid = 0;        /* from kernel */
1406	NETLINK_CB(skb).dst_group = 0;  /* unicast */
1407	nlmsg_unicast(net->ipv4.fibnl, skb, portid);
1408}
1409
1410static int __net_init nl_fib_lookup_init(struct net *net)
1411{
1412	struct sock *sk;
1413	struct netlink_kernel_cfg cfg = {
1414		.input	= nl_fib_input,
1415	};
1416
1417	sk = netlink_kernel_create(net, NETLINK_FIB_LOOKUP, &cfg);
1418	if (!sk)
1419		return -EAFNOSUPPORT;
1420	net->ipv4.fibnl = sk;
1421	return 0;
1422}
1423
1424static void nl_fib_lookup_exit(struct net *net)
1425{
1426	netlink_kernel_release(net->ipv4.fibnl);
1427	net->ipv4.fibnl = NULL;
1428}
1429
1430static void fib_disable_ip(struct net_device *dev, unsigned long event,
1431			   bool force)
1432{
1433	if (fib_sync_down_dev(dev, event, force))
1434		fib_flush(dev_net(dev));
1435	else
1436		rt_cache_flush(dev_net(dev));
1437	arp_ifdown(dev);
1438}
1439
1440static int fib_inetaddr_event(struct notifier_block *this, unsigned long event, void *ptr)
1441{
1442	struct in_ifaddr *ifa = ptr;
1443	struct net_device *dev = ifa->ifa_dev->dev;
1444	struct net *net = dev_net(dev);
1445
1446	switch (event) {
1447	case NETDEV_UP:
1448		fib_add_ifaddr(ifa);
1449#ifdef CONFIG_IP_ROUTE_MULTIPATH
1450		fib_sync_up(dev, RTNH_F_DEAD);
1451#endif
1452		atomic_inc(&net->ipv4.dev_addr_genid);
1453		rt_cache_flush(dev_net(dev));
1454		break;
1455	case NETDEV_DOWN:
1456		fib_del_ifaddr(ifa, NULL);
1457		atomic_inc(&net->ipv4.dev_addr_genid);
1458		if (!ifa->ifa_dev->ifa_list) {
1459			/* Last address was deleted from this interface.
1460			 * Disable IP.
1461			 */
1462			fib_disable_ip(dev, event, true);
1463		} else {
1464			rt_cache_flush(dev_net(dev));
1465		}
1466		break;
1467	}
1468	return NOTIFY_DONE;
1469}
1470
1471static int fib_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1472{
1473	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1474	struct netdev_notifier_changeupper_info *upper_info = ptr;
1475	struct netdev_notifier_info_ext *info_ext = ptr;
1476	struct in_device *in_dev;
1477	struct net *net = dev_net(dev);
1478	struct in_ifaddr *ifa;
1479	unsigned int flags;
1480
1481	if (event == NETDEV_UNREGISTER) {
1482		fib_disable_ip(dev, event, true);
1483		rt_flush_dev(dev);
1484		return NOTIFY_DONE;
1485	}
1486
1487	in_dev = __in_dev_get_rtnl(dev);
1488	if (!in_dev)
1489		return NOTIFY_DONE;
1490
1491	switch (event) {
1492	case NETDEV_UP:
1493		in_dev_for_each_ifa_rtnl(ifa, in_dev) {
1494			fib_add_ifaddr(ifa);
1495		}
1496#ifdef CONFIG_IP_ROUTE_MULTIPATH
1497		fib_sync_up(dev, RTNH_F_DEAD);
1498#endif
1499		atomic_inc(&net->ipv4.dev_addr_genid);
1500		rt_cache_flush(net);
1501		break;
1502	case NETDEV_DOWN:
1503		fib_disable_ip(dev, event, false);
1504		break;
1505	case NETDEV_CHANGE:
1506		flags = dev_get_flags(dev);
1507		if (flags & (IFF_RUNNING | IFF_LOWER_UP))
1508			fib_sync_up(dev, RTNH_F_LINKDOWN);
1509		else
1510			fib_sync_down_dev(dev, event, false);
1511		rt_cache_flush(net);
1512		break;
1513	case NETDEV_CHANGEMTU:
1514		fib_sync_mtu(dev, info_ext->ext.mtu);
1515		rt_cache_flush(net);
1516		break;
1517	case NETDEV_CHANGEUPPER:
1518		upper_info = ptr;
1519		/* flush all routes if dev is linked to or unlinked from
1520		 * an L3 master device (e.g., VRF)
1521		 */
1522		if (upper_info->upper_dev &&
1523		    netif_is_l3_master(upper_info->upper_dev))
1524			fib_disable_ip(dev, NETDEV_DOWN, true);
1525		break;
1526	}
1527	return NOTIFY_DONE;
1528}
1529
1530static struct notifier_block fib_inetaddr_notifier = {
1531	.notifier_call = fib_inetaddr_event,
1532};
1533
1534static struct notifier_block fib_netdev_notifier = {
1535	.notifier_call = fib_netdev_event,
1536};
1537
1538static int __net_init ip_fib_net_init(struct net *net)
1539{
1540	int err;
1541	size_t size = sizeof(struct hlist_head) * FIB_TABLE_HASHSZ;
1542
1543	err = fib4_notifier_init(net);
1544	if (err)
1545		return err;
1546
1547#ifdef CONFIG_IP_ROUTE_MULTIPATH
1548	/* Default to 3-tuple */
1549	net->ipv4.sysctl_fib_multipath_hash_fields =
1550		FIB_MULTIPATH_HASH_FIELD_DEFAULT_MASK;
1551#endif
1552
1553	/* Avoid false sharing : Use at least a full cache line */
1554	size = max_t(size_t, size, L1_CACHE_BYTES);
1555
1556	net->ipv4.fib_table_hash = kzalloc(size, GFP_KERNEL);
1557	if (!net->ipv4.fib_table_hash) {
1558		err = -ENOMEM;
1559		goto err_table_hash_alloc;
1560	}
1561
1562	err = fib4_rules_init(net);
1563	if (err < 0)
1564		goto err_rules_init;
1565	return 0;
1566
1567err_rules_init:
1568	kfree(net->ipv4.fib_table_hash);
1569err_table_hash_alloc:
1570	fib4_notifier_exit(net);
1571	return err;
1572}
1573
1574static void ip_fib_net_exit(struct net *net)
1575{
1576	int i;
1577
1578	ASSERT_RTNL();
1579#ifdef CONFIG_IP_MULTIPLE_TABLES
1580	RCU_INIT_POINTER(net->ipv4.fib_main, NULL);
1581	RCU_INIT_POINTER(net->ipv4.fib_default, NULL);
1582#endif
1583	/* Destroy the tables in reverse order to guarantee that the
1584	 * local table, ID 255, is destroyed before the main table, ID
1585	 * 254. This is necessary as the local table may contain
1586	 * references to data contained in the main table.
1587	 */
1588	for (i = FIB_TABLE_HASHSZ - 1; i >= 0; i--) {
1589		struct hlist_head *head = &net->ipv4.fib_table_hash[i];
1590		struct hlist_node *tmp;
1591		struct fib_table *tb;
1592
1593		hlist_for_each_entry_safe(tb, tmp, head, tb_hlist) {
1594			hlist_del(&tb->tb_hlist);
1595			fib_table_flush(net, tb, true);
1596			fib_free_table(tb);
1597		}
1598	}
1599
1600#ifdef CONFIG_IP_MULTIPLE_TABLES
1601	fib4_rules_exit(net);
1602#endif
1603
1604	kfree(net->ipv4.fib_table_hash);
1605	fib4_notifier_exit(net);
1606}
1607
1608static int __net_init fib_net_init(struct net *net)
1609{
1610	int error;
1611
1612#ifdef CONFIG_IP_ROUTE_CLASSID
1613	atomic_set(&net->ipv4.fib_num_tclassid_users, 0);
1614#endif
1615	error = ip_fib_net_init(net);
1616	if (error < 0)
1617		goto out;
1618	error = nl_fib_lookup_init(net);
1619	if (error < 0)
1620		goto out_nlfl;
1621	error = fib_proc_init(net);
1622	if (error < 0)
1623		goto out_proc;
1624out:
1625	return error;
1626
1627out_proc:
1628	nl_fib_lookup_exit(net);
1629out_nlfl:
1630	rtnl_lock();
1631	ip_fib_net_exit(net);
1632	rtnl_unlock();
1633	goto out;
1634}
1635
1636static void __net_exit fib_net_exit(struct net *net)
1637{
1638	fib_proc_exit(net);
1639	nl_fib_lookup_exit(net);
1640}
1641
1642static void __net_exit fib_net_exit_batch(struct list_head *net_list)
1643{
1644	struct net *net;
1645
1646	rtnl_lock();
1647	list_for_each_entry(net, net_list, exit_list)
1648		ip_fib_net_exit(net);
1649
1650	rtnl_unlock();
1651}
1652
1653static struct pernet_operations fib_net_ops = {
1654	.init = fib_net_init,
1655	.exit = fib_net_exit,
1656	.exit_batch = fib_net_exit_batch,
1657};
1658
1659static const struct rtnl_msg_handler fib_rtnl_msg_handlers[] __initconst = {
1660	{.protocol = PF_INET, .msgtype = RTM_NEWROUTE,
1661	 .doit = inet_rtm_newroute},
1662	{.protocol = PF_INET, .msgtype = RTM_DELROUTE,
1663	 .doit = inet_rtm_delroute},
1664	{.protocol = PF_INET, .msgtype = RTM_GETROUTE, .dumpit = inet_dump_fib,
1665	 .flags = RTNL_FLAG_DUMP_UNLOCKED | RTNL_FLAG_DUMP_SPLIT_NLM_DONE},
1666};
1667
1668void __init ip_fib_init(void)
1669{
1670	fib_trie_init();
1671
1672	register_pernet_subsys(&fib_net_ops);
1673
1674	register_netdevice_notifier(&fib_netdev_notifier);
1675	register_inetaddr_notifier(&fib_inetaddr_notifier);
1676
1677	rtnl_register_many(fib_rtnl_msg_handlers);
 
 
1678}