Linux Audio

Check our new training course

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