Skip to content
Snippets Groups Projects
arp.c 35.6 KiB
Newer Older
  • Learn to ignore specific revisions
  • Oussama Ghorbel's avatar
    Oussama Ghorbel committed
    /* linux/net/ipv4/arp.c
     *
     * Copyright (C) 1994 by Florian  La Roche
     *
     * This module implements the Address Resolution Protocol ARP (RFC 826),
     * which is used to convert IP addresses (or in the future maybe other
     * high-level addresses) into a low-level hardware address (like an Ethernet
     * address).
     *
     * This program is free software; you can redistribute it and/or
     * modify it under the terms of the GNU General Public License
     * as published by the Free Software Foundation; either version
     * 2 of the License, or (at your option) any later version.
     *
     * Fixes:
     *		Alan Cox	:	Removed the Ethernet assumptions in
     *					Florian's code
     *		Alan Cox	:	Fixed some small errors in the ARP
     *					logic
     *		Alan Cox	:	Allow >4K in /proc
     *		Alan Cox	:	Make ARP add its own protocol entry
     *		Ross Martin     :       Rewrote arp_rcv() and arp_get_info()
     *		Stephen Henson	:	Add AX25 support to arp_get_info()
     *		Alan Cox	:	Drop data when a device is downed.
     *		Alan Cox	:	Use init_timer().
     *		Alan Cox	:	Double lock fixes.
     *		Martin Seine	:	Move the arphdr structure
     *					to if_arp.h for compatibility.
     *					with BSD based programs.
     *		Andrew Tridgell :       Added ARP netmask code and
     *					re-arranged proxy handling.
     *		Alan Cox	:	Changed to use notifiers.
     *		Niibe Yutaka	:	Reply for this device or proxies only.
     *		Alan Cox	:	Don't proxy across hardware types!
     *		Jonathan Naylor :	Added support for NET/ROM.
     *		Mike Shaver     :       RFC1122 checks.
     *		Jonathan Naylor :	Only lookup the hardware address for
     *					the correct hardware type.
     *		Germano Caronni	:	Assorted subtle races.
     *		Craig Schlenter :	Don't modify permanent entry
     *					during arp_rcv.
     *		Russ Nelson	:	Tidied up a few bits.
     *		Alexey Kuznetsov:	Major changes to caching and behaviour,
     *					eg intelligent arp probing and
     *					generation
     *					of host down events.
     *		Alan Cox	:	Missing unlock in device events.
     *		Eckes		:	ARP ioctl control errors.
     *		Alexey Kuznetsov:	Arp free fix.
     *		Manuel Rodriguez:	Gratuitous ARP.
     *              Jonathan Layes  :       Added arpd support through kerneld
     *                                      message queue (960314)
     *		Mike Shaver	:	/proc/sys/net/ipv4/arp_* support
     *		Mike McLagan    :	Routing by source
     *		Stuart Cheshire	:	Metricom and grat arp fixes
     *					*** FOR 2.1 clean this up ***
     *		Lawrence V. Stefani: (08/12/96) Added FDDI support.
     *		Alan Cox	:	Took the AP1000 nasty FDDI hack and
     *					folded into the mainstream FDDI code.
     *					Ack spit, Linus how did you allow that
     *					one in...
     *		Jes Sorensen	:	Make FDDI work again in 2.1.x and
     *					clean up the APFDDI & gen. FDDI bits.
     *		Alexey Kuznetsov:	new arp state machine;
     *					now it is in net/core/neighbour.c.
     *		Krzysztof Halasa:	Added Frame Relay ARP support.
     *		Arnaldo C. Melo :	convert /proc/net/arp to seq_file
     *		Shmulik Hen:		Split arp_send to arp_create and
     *					arp_xmit so intermediate drivers like
     *					bonding can change the skb before
     *					sending (e.g. insert 8021q tag).
     *		Harald Welte	:	convert to make use of jenkins hash
     *		Jesper D. Brouer:       Proxy ARP PVLAN RFC 3069 support.
     */
    
    #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
    
    #include <linux/module.h>
    #include <linux/types.h>
    #include <linux/string.h>
    #include <linux/kernel.h>
    #include <linux/capability.h>
    #include <linux/socket.h>
    #include <linux/sockios.h>
    #include <linux/errno.h>
    #include <linux/in.h>
    #include <linux/mm.h>
    #include <linux/inet.h>
    #include <linux/inetdevice.h>
    #include <linux/netdevice.h>
    #include <linux/etherdevice.h>
    #include <linux/fddidevice.h>
    #include <linux/if_arp.h>
    #include <linux/skbuff.h>
    #include <linux/proc_fs.h>
    #include <linux/seq_file.h>
    #include <linux/stat.h>
    #include <linux/init.h>
    #include <linux/net.h>
    #include <linux/rcupdate.h>
    #include <linux/slab.h>
    #ifdef CONFIG_SYSCTL
    #include <linux/sysctl.h>
    #endif
    
    #include <net/net_namespace.h>
    #include <net/ip.h>
    #include <net/icmp.h>
    #include <net/route.h>
    #include <net/protocol.h>
    #include <net/tcp.h>
    #include <net/sock.h>
    #include <net/arp.h>
    #include <net/ax25.h>
    #include <net/netrom.h>
    #include <net/dst_metadata.h>
    #include <net/ip_tunnels.h>
    
    #include <linux/uaccess.h>
    
    #include <linux/netfilter_arp.h>
    
    /*
     *	Interface to generic neighbour cache.
     */
    static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
    static bool arp_key_eq(const struct neighbour *n, const void *pkey);
    static int arp_constructor(struct neighbour *neigh);
    static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
    static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
    static void parp_redo(struct sk_buff *skb);
    
    static const struct neigh_ops arp_generic_ops = {
    	.family =		AF_INET,
    	.solicit =		arp_solicit,
    	.error_report =		arp_error_report,
    	.output =		neigh_resolve_output,
    	.connected_output =	neigh_connected_output,
    };
    
    static const struct neigh_ops arp_hh_ops = {
    	.family =		AF_INET,
    	.solicit =		arp_solicit,
    	.error_report =		arp_error_report,
    	.output =		neigh_resolve_output,
    	.connected_output =	neigh_resolve_output,
    };
    
    static const struct neigh_ops arp_direct_ops = {
    	.family =		AF_INET,
    	.output =		neigh_direct_output,
    	.connected_output =	neigh_direct_output,
    };
    
    struct neigh_table arp_tbl = {
    	.family		= AF_INET,
    	.key_len	= 4,
    	.protocol	= cpu_to_be16(ETH_P_IP),
    	.hash		= arp_hash,
    	.key_eq		= arp_key_eq,
    	.constructor	= arp_constructor,
    	.proxy_redo	= parp_redo,
    	.id		= "arp_cache",
    	.parms		= {
    		.tbl			= &arp_tbl,
    		.reachable_time		= 30 * HZ,
    		.data	= {
    			[NEIGH_VAR_MCAST_PROBES] = 3,
    			[NEIGH_VAR_UCAST_PROBES] = 3,
    			[NEIGH_VAR_RETRANS_TIME] = 1 * HZ,
    			[NEIGH_VAR_BASE_REACHABLE_TIME] = 30 * HZ,
    			[NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ,
    			[NEIGH_VAR_GC_STALETIME] = 60 * HZ,
    			[NEIGH_VAR_QUEUE_LEN_BYTES] = 64 * 1024,
    			[NEIGH_VAR_PROXY_QLEN] = 64,
    			[NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ,
    			[NEIGH_VAR_PROXY_DELAY]	= (8 * HZ) / 10,
    			[NEIGH_VAR_LOCKTIME] = 1 * HZ,
    		},
    	},
    	.gc_interval	= 30 * HZ,
    	.gc_thresh1	= 128,
    	.gc_thresh2	= 512,
    	.gc_thresh3	= 1024,
    };
    EXPORT_SYMBOL(arp_tbl);
    
    int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
    {
    	switch (dev->type) {
    	case ARPHRD_ETHER:
    	case ARPHRD_FDDI:
    	case ARPHRD_IEEE802:
    		ip_eth_mc_map(addr, haddr);
    		return 0;
    	case ARPHRD_INFINIBAND:
    		ip_ib_mc_map(addr, dev->broadcast, haddr);
    		return 0;
    	case ARPHRD_IPGRE:
    		ip_ipgre_mc_map(addr, dev->broadcast, haddr);
    		return 0;
    	default:
    		if (dir) {
    			memcpy(haddr, dev->broadcast, dev->addr_len);
    			return 0;
    		}
    	}
    	return -EINVAL;
    }
    
    
    static u32 arp_hash(const void *pkey,
    		    const struct net_device *dev,
    		    __u32 *hash_rnd)
    {
    	return arp_hashfn(pkey, dev, hash_rnd);
    }
    
    static bool arp_key_eq(const struct neighbour *neigh, const void *pkey)
    {
    	return neigh_key_eq32(neigh, pkey);
    }
    
    static int arp_constructor(struct neighbour *neigh)
    {
    	__be32 addr;
    	struct net_device *dev = neigh->dev;
    	struct in_device *in_dev;
    	struct neigh_parms *parms;
    	u32 inaddr_any = INADDR_ANY;
    
    	if (dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT))
    		memcpy(neigh->primary_key, &inaddr_any, arp_tbl.key_len);
    
    	addr = *(__be32 *)neigh->primary_key;
    	rcu_read_lock();
    	in_dev = __in_dev_get_rcu(dev);
    	if (!in_dev) {
    		rcu_read_unlock();
    		return -EINVAL;
    	}
    
    	neigh->type = inet_addr_type_dev_table(dev_net(dev), dev, addr);
    
    	parms = in_dev->arp_parms;
    	__neigh_parms_put(neigh->parms);
    	neigh->parms = neigh_parms_clone(parms);
    	rcu_read_unlock();
    
    	if (!dev->header_ops) {
    		neigh->nud_state = NUD_NOARP;
    		neigh->ops = &arp_direct_ops;
    		neigh->output = neigh_direct_output;
    	} else {
    		/* Good devices (checked by reading texts, but only Ethernet is
    		   tested)
    
    		   ARPHRD_ETHER: (ethernet, apfddi)
    		   ARPHRD_FDDI: (fddi)
    		   ARPHRD_IEEE802: (tr)
    		   ARPHRD_METRICOM: (strip)
    		   ARPHRD_ARCNET:
    		   etc. etc. etc.
    
    		   ARPHRD_IPDDP will also work, if author repairs it.
    		   I did not it, because this driver does not work even
    		   in old paradigm.
    		 */
    
    		if (neigh->type == RTN_MULTICAST) {
    			neigh->nud_state = NUD_NOARP;
    			arp_mc_map(addr, neigh->ha, dev, 1);
    		} else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
    			neigh->nud_state = NUD_NOARP;
    			memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
    		} else if (neigh->type == RTN_BROADCAST ||
    			   (dev->flags & IFF_POINTOPOINT)) {
    			neigh->nud_state = NUD_NOARP;
    			memcpy(neigh->ha, dev->broadcast, dev->addr_len);
    		}
    
    		if (dev->header_ops->cache)
    			neigh->ops = &arp_hh_ops;
    		else
    			neigh->ops = &arp_generic_ops;
    
    		if (neigh->nud_state & NUD_VALID)
    			neigh->output = neigh->ops->connected_output;
    		else
    			neigh->output = neigh->ops->output;
    	}
    	return 0;
    }
    
    static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
    {
    	dst_link_failure(skb);
    	kfree_skb(skb);
    }
    
    /* Create and send an arp packet. */
    static void arp_send_dst(int type, int ptype, __be32 dest_ip,
    			 struct net_device *dev, __be32 src_ip,
    			 const unsigned char *dest_hw,
    			 const unsigned char *src_hw,
    			 const unsigned char *target_hw,
    			 struct dst_entry *dst)
    {
    	struct sk_buff *skb;
    
    	/* arp on this interface. */
    	if (dev->flags & IFF_NOARP)
    		return;
    
    	skb = arp_create(type, ptype, dest_ip, dev, src_ip,
    			 dest_hw, src_hw, target_hw);
    	if (!skb)
    		return;
    
    	skb_dst_set(skb, dst_clone(dst));
    
    	/* Set the ARP requests generated by CPU to the highest priority since it fails to do this
    	 * from the user space utilities. In order to make this work on Intel platform, a queue with
    	 * "--priority 1 --map 1" must be created. */
    	skb->priority = 7;
    
    Oussama Ghorbel's avatar
    Oussama Ghorbel committed
    325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000
    	arp_xmit(skb);
    }
    
    void arp_send(int type, int ptype, __be32 dest_ip,
    	      struct net_device *dev, __be32 src_ip,
    	      const unsigned char *dest_hw, const unsigned char *src_hw,
    	      const unsigned char *target_hw)
    {
    	arp_send_dst(type, ptype, dest_ip, dev, src_ip, dest_hw, src_hw,
    		     target_hw, NULL);
    }
    EXPORT_SYMBOL(arp_send);
    
    static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
    {
    	__be32 saddr = 0;
    	u8 dst_ha[MAX_ADDR_LEN], *dst_hw = NULL;
    	struct net_device *dev = neigh->dev;
    	__be32 target = *(__be32 *)neigh->primary_key;
    	int probes = atomic_read(&neigh->probes);
    	struct in_device *in_dev;
    	struct dst_entry *dst = NULL;
    
    	rcu_read_lock();
    	in_dev = __in_dev_get_rcu(dev);
    	if (!in_dev) {
    		rcu_read_unlock();
    		return;
    	}
    	switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
    	default:
    	case 0:		/* By default announce any local IP */
    		if (skb && inet_addr_type_dev_table(dev_net(dev), dev,
    					  ip_hdr(skb)->saddr) == RTN_LOCAL)
    			saddr = ip_hdr(skb)->saddr;
    		break;
    	case 1:		/* Restrict announcements of saddr in same subnet */
    		if (!skb)
    			break;
    		saddr = ip_hdr(skb)->saddr;
    		if (inet_addr_type_dev_table(dev_net(dev), dev,
    					     saddr) == RTN_LOCAL) {
    			/* saddr should be known to target */
    			if (inet_addr_onlink(in_dev, target, saddr))
    				break;
    		}
    		saddr = 0;
    		break;
    	case 2:		/* Avoid secondary IPs, get a primary/preferred one */
    		break;
    	}
    	rcu_read_unlock();
    
    	if (!saddr)
    		saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
    
    	probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
    	if (probes < 0) {
    		if (!(neigh->nud_state & NUD_VALID))
    			pr_debug("trying to ucast probe in NUD_INVALID\n");
    		neigh_ha_snapshot(dst_ha, neigh, dev);
    		dst_hw = dst_ha;
    	} else {
    		probes -= NEIGH_VAR(neigh->parms, APP_PROBES);
    		if (probes < 0) {
    			neigh_app_ns(neigh);
    			return;
    		}
    	}
    
    	if (skb && !(dev->priv_flags & IFF_XMIT_DST_RELEASE))
    		dst = skb_dst(skb);
    	arp_send_dst(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
    		     dst_hw, dev->dev_addr, NULL, dst);
    }
    
    static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
    {
    	struct net *net = dev_net(in_dev->dev);
    	int scope;
    
    	switch (IN_DEV_ARP_IGNORE(in_dev)) {
    	case 0:	/* Reply, the tip is already validated */
    		return 0;
    	case 1:	/* Reply only if tip is configured on the incoming interface */
    		sip = 0;
    		scope = RT_SCOPE_HOST;
    		break;
    	case 2:	/*
    		 * Reply only if tip is configured on the incoming interface
    		 * and is in same subnet as sip
    		 */
    		scope = RT_SCOPE_HOST;
    		break;
    	case 3:	/* Do not reply for scope host addresses */
    		sip = 0;
    		scope = RT_SCOPE_LINK;
    		in_dev = NULL;
    		break;
    	case 4:	/* Reserved */
    	case 5:
    	case 6:
    	case 7:
    		return 0;
    	case 8:	/* Do not reply */
    		return 1;
    	default:
    		return 0;
    	}
    	return !inet_confirm_addr(net, in_dev, sip, tip, scope);
    }
    
    static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
    {
    	struct rtable *rt;
    	int flag = 0;
    	/*unsigned long now; */
    	struct net *net = dev_net(dev);
    
    	rt = ip_route_output(net, sip, tip, 0, l3mdev_master_ifindex_rcu(dev));
    	if (IS_ERR(rt))
    		return 1;
    	if (rt->dst.dev != dev) {
    		__NET_INC_STATS(net, LINUX_MIB_ARPFILTER);
    		flag = 1;
    	}
    	ip_rt_put(rt);
    	return flag;
    }
    
    /*
     * Check if we can use proxy ARP for this path
     */
    static inline int arp_fwd_proxy(struct in_device *in_dev,
    				struct net_device *dev,	struct rtable *rt)
    {
    	struct in_device *out_dev;
    	int imi, omi = -1;
    
    	if (rt->dst.dev == dev)
    		return 0;
    
    	if (!IN_DEV_PROXY_ARP(in_dev))
    		return 0;
    	imi = IN_DEV_MEDIUM_ID(in_dev);
    	if (imi == 0)
    		return 1;
    	if (imi == -1)
    		return 0;
    
    	/* place to check for proxy_arp for routes */
    
    	out_dev = __in_dev_get_rcu(rt->dst.dev);
    	if (out_dev)
    		omi = IN_DEV_MEDIUM_ID(out_dev);
    
    	return omi != imi && omi != -1;
    }
    
    /*
     * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
     *
     * RFC3069 supports proxy arp replies back to the same interface.  This
     * is done to support (ethernet) switch features, like RFC 3069, where
     * the individual ports are not allowed to communicate with each
     * other, BUT they are allowed to talk to the upstream router.  As
     * described in RFC 3069, it is possible to allow these hosts to
     * communicate through the upstream router, by proxy_arp'ing.
     *
     * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
     *
     *  This technology is known by different names:
     *    In RFC 3069 it is called VLAN Aggregation.
     *    Cisco and Allied Telesyn call it Private VLAN.
     *    Hewlett-Packard call it Source-Port filtering or port-isolation.
     *    Ericsson call it MAC-Forced Forwarding (RFC Draft).
     *
     */
    static inline int arp_fwd_pvlan(struct in_device *in_dev,
    				struct net_device *dev,	struct rtable *rt,
    				__be32 sip, __be32 tip)
    {
    	/* Private VLAN is only concerned about the same ethernet segment */
    	if (rt->dst.dev != dev)
    		return 0;
    
    	/* Don't reply on self probes (often done by windowz boxes)*/
    	if (sip == tip)
    		return 0;
    
    	if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
    		return 1;
    	else
    		return 0;
    }
    
    /*
     *	Interface to link layer: send routine and receive handler.
     */
    
    /*
     *	Create an arp packet. If dest_hw is not set, we create a broadcast
     *	message.
     */
    struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
    			   struct net_device *dev, __be32 src_ip,
    			   const unsigned char *dest_hw,
    			   const unsigned char *src_hw,
    			   const unsigned char *target_hw)
    {
    	struct sk_buff *skb;
    	struct arphdr *arp;
    	unsigned char *arp_ptr;
    	int hlen = LL_RESERVED_SPACE(dev);
    	int tlen = dev->needed_tailroom;
    
    	/*
    	 *	Allocate a buffer
    	 */
    
    	skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
    	if (!skb)
    		return NULL;
    
    	skb_reserve(skb, hlen);
    	skb_reset_network_header(skb);
    	arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
    	skb->dev = dev;
    	skb->protocol = htons(ETH_P_ARP);
    	if (!src_hw)
    		src_hw = dev->dev_addr;
    	if (!dest_hw)
    		dest_hw = dev->broadcast;
    
    	/*
    	 *	Fill the device header for the ARP frame
    	 */
    	if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
    		goto out;
    
    	/*
    	 * Fill out the arp protocol part.
    	 *
    	 * The arp hardware type should match the device type, except for FDDI,
    	 * which (according to RFC 1390) should always equal 1 (Ethernet).
    	 */
    	/*
    	 *	Exceptions everywhere. AX.25 uses the AX.25 PID value not the
    	 *	DIX code for the protocol. Make these device structure fields.
    	 */
    	switch (dev->type) {
    	default:
    		arp->ar_hrd = htons(dev->type);
    		arp->ar_pro = htons(ETH_P_IP);
    		break;
    
    #if IS_ENABLED(CONFIG_AX25)
    	case ARPHRD_AX25:
    		arp->ar_hrd = htons(ARPHRD_AX25);
    		arp->ar_pro = htons(AX25_P_IP);
    		break;
    
    #if IS_ENABLED(CONFIG_NETROM)
    	case ARPHRD_NETROM:
    		arp->ar_hrd = htons(ARPHRD_NETROM);
    		arp->ar_pro = htons(AX25_P_IP);
    		break;
    #endif
    #endif
    
    #if IS_ENABLED(CONFIG_FDDI)
    	case ARPHRD_FDDI:
    		arp->ar_hrd = htons(ARPHRD_ETHER);
    		arp->ar_pro = htons(ETH_P_IP);
    		break;
    #endif
    	}
    
    	arp->ar_hln = dev->addr_len;
    	arp->ar_pln = 4;
    	arp->ar_op = htons(type);
    
    	arp_ptr = (unsigned char *)(arp + 1);
    
    	memcpy(arp_ptr, src_hw, dev->addr_len);
    	arp_ptr += dev->addr_len;
    	memcpy(arp_ptr, &src_ip, 4);
    	arp_ptr += 4;
    
    	switch (dev->type) {
    #if IS_ENABLED(CONFIG_FIREWIRE_NET)
    	case ARPHRD_IEEE1394:
    		break;
    #endif
    	default:
    		if (target_hw)
    			memcpy(arp_ptr, target_hw, dev->addr_len);
    		else
    			memset(arp_ptr, 0, dev->addr_len);
    		arp_ptr += dev->addr_len;
    	}
    	memcpy(arp_ptr, &dest_ip, 4);
    
    	return skb;
    
    out:
    	kfree_skb(skb);
    	return NULL;
    }
    EXPORT_SYMBOL(arp_create);
    
    static int arp_xmit_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
    {
    	return dev_queue_xmit(skb);
    }
    
    /*
     *	Send an arp packet.
     */
    void arp_xmit(struct sk_buff *skb)
    {
    	/* Send it off, maybe filter it using firewalling first.  */
    	NF_HOOK(NFPROTO_ARP, NF_ARP_OUT,
    		dev_net(skb->dev), NULL, skb, NULL, skb->dev,
    		arp_xmit_finish);
    }
    EXPORT_SYMBOL(arp_xmit);
    
    /*
     *	Process an arp request.
     */
    
    static int arp_process(struct net *net, struct sock *sk, struct sk_buff *skb)
    {
    	struct net_device *dev = skb->dev;
    	struct in_device *in_dev = __in_dev_get_rcu(dev);
    	struct arphdr *arp;
    	unsigned char *arp_ptr;
    	struct rtable *rt;
    	unsigned char *sha;
    	unsigned char *tha = NULL;
    	__be32 sip, tip;
    	u16 dev_type = dev->type;
    	int addr_type;
    	struct neighbour *n;
    	struct dst_entry *reply_dst = NULL;
    	bool is_garp = false;
    
    	/* arp_rcv below verifies the ARP header and verifies the device
    	 * is ARP'able.
    	 */
    
    	if (!in_dev)
    		goto out_free_skb;
    
    	arp = arp_hdr(skb);
    
    	switch (dev_type) {
    	default:
    		if (arp->ar_pro != htons(ETH_P_IP) ||
    		    htons(dev_type) != arp->ar_hrd)
    			goto out_free_skb;
    		break;
    	case ARPHRD_ETHER:
    	case ARPHRD_FDDI:
    	case ARPHRD_IEEE802:
    		/*
    		 * ETHERNET, and Fibre Channel (which are IEEE 802
    		 * devices, according to RFC 2625) devices will accept ARP
    		 * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
    		 * This is the case also of FDDI, where the RFC 1390 says that
    		 * FDDI devices should accept ARP hardware of (1) Ethernet,
    		 * however, to be more robust, we'll accept both 1 (Ethernet)
    		 * or 6 (IEEE 802.2)
    		 */
    		if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
    		     arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
    		    arp->ar_pro != htons(ETH_P_IP))
    			goto out_free_skb;
    		break;
    	case ARPHRD_AX25:
    		if (arp->ar_pro != htons(AX25_P_IP) ||
    		    arp->ar_hrd != htons(ARPHRD_AX25))
    			goto out_free_skb;
    		break;
    	case ARPHRD_NETROM:
    		if (arp->ar_pro != htons(AX25_P_IP) ||
    		    arp->ar_hrd != htons(ARPHRD_NETROM))
    			goto out_free_skb;
    		break;
    	}
    
    	/* Understand only these message types */
    
    	if (arp->ar_op != htons(ARPOP_REPLY) &&
    	    arp->ar_op != htons(ARPOP_REQUEST))
    		goto out_free_skb;
    
    /*
     *	Extract fields
     */
    	arp_ptr = (unsigned char *)(arp + 1);
    	sha	= arp_ptr;
    	arp_ptr += dev->addr_len;
    	memcpy(&sip, arp_ptr, 4);
    	arp_ptr += 4;
    	switch (dev_type) {
    #if IS_ENABLED(CONFIG_FIREWIRE_NET)
    	case ARPHRD_IEEE1394:
    		break;
    #endif
    	default:
    		tha = arp_ptr;
    		arp_ptr += dev->addr_len;
    	}
    	memcpy(&tip, arp_ptr, 4);
    /*
     *	Check for bad requests for 127.x.x.x and requests for multicast
     *	addresses.  If this is one such, delete it.
     */
    	if (ipv4_is_multicast(tip) ||
    	    (!IN_DEV_ROUTE_LOCALNET(in_dev) && ipv4_is_loopback(tip)))
    		goto out_free_skb;
    
     /*
      *	For some 802.11 wireless deployments (and possibly other networks),
      *	there will be an ARP proxy and gratuitous ARP frames are attacks
      *	and thus should not be accepted.
      */
    	if (sip == tip && IN_DEV_ORCONF(in_dev, DROP_GRATUITOUS_ARP))
    		goto out_free_skb;
    
    /*
     *     Special case: We must set Frame Relay source Q.922 address
     */
    	if (dev_type == ARPHRD_DLCI)
    		sha = dev->broadcast;
    
    /*
     *  Process entry.  The idea here is we want to send a reply if it is a
     *  request for us or if it is a request for someone else that we hold
     *  a proxy for.  We want to add an entry to our cache if it is a reply
     *  to us or if it is a request for our address.
     *  (The assumption for this last is that if someone is requesting our
     *  address, they are probably intending to talk to us, so it saves time
     *  if we cache their address.  Their address is also probably not in
     *  our cache, since ours is not in their cache.)
     *
     *  Putting this another way, we only care about replies if they are to
     *  us, in which case we add them to the cache.  For requests, we care
     *  about those for us and those for our proxies.  We reply to both,
     *  and in the case of requests for us we add the requester to the arp
     *  cache.
     */
    
    	if (arp->ar_op == htons(ARPOP_REQUEST) && skb_metadata_dst(skb))
    		reply_dst = (struct dst_entry *)
    			    iptunnel_metadata_reply(skb_metadata_dst(skb),
    						    GFP_ATOMIC);
    
    	/* Special case: IPv4 duplicate address detection packet (RFC2131) */
    	if (sip == 0) {
    		if (arp->ar_op == htons(ARPOP_REQUEST) &&
    		    inet_addr_type_dev_table(net, dev, tip) == RTN_LOCAL &&
    		    !arp_ignore(in_dev, sip, tip))
    			arp_send_dst(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip,
    				     sha, dev->dev_addr, sha, reply_dst);
    		goto out_consume_skb;
    	}
    
    	if (arp->ar_op == htons(ARPOP_REQUEST) &&
    	    ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
    
    		rt = skb_rtable(skb);
    		addr_type = rt->rt_type;
    
    		if (addr_type == RTN_LOCAL) {
    			int dont_send;
    
    			dont_send = arp_ignore(in_dev, sip, tip);
    			if (!dont_send && IN_DEV_ARPFILTER(in_dev))
    				dont_send = arp_filter(sip, tip, dev);
    			if (!dont_send) {
    				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
    				if (n) {
    					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
    						     sip, dev, tip, sha,
    						     dev->dev_addr, sha,
    						     reply_dst);
    					neigh_release(n);
    				}
    			}
    			goto out_consume_skb;
    		} else if (IN_DEV_FORWARD(in_dev)) {
    			if (addr_type == RTN_UNICAST  &&
    			    (arp_fwd_proxy(in_dev, dev, rt) ||
    			     arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
    			     (rt->dst.dev != dev &&
    			      pneigh_lookup(&arp_tbl, net, &tip, dev, 0)))) {
    				n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
    				if (n)
    					neigh_release(n);
    
    				if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
    				    skb->pkt_type == PACKET_HOST ||
    				    NEIGH_VAR(in_dev->arp_parms, PROXY_DELAY) == 0) {
    					arp_send_dst(ARPOP_REPLY, ETH_P_ARP,
    						     sip, dev, tip, sha,
    						     dev->dev_addr, sha,
    						     reply_dst);
    				} else {
    					pneigh_enqueue(&arp_tbl,
    						       in_dev->arp_parms, skb);
    					goto out_free_dst;
    				}
    				goto out_consume_skb;
    			}
    		}
    	}
    
    	/* Update our ARP tables */
    
    	n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
    
    	if (IN_DEV_ARP_ACCEPT(in_dev)) {
    		unsigned int addr_type = inet_addr_type_dev_table(net, dev, sip);
    
    		/* Unsolicited ARP is not accepted by default.
    		   It is possible, that this option should be enabled for some
    		   devices (strip is candidate)
    		 */
    		is_garp = tip == sip && addr_type == RTN_UNICAST;
    
    		/* Unsolicited ARP _replies_ also require target hwaddr to be
    		 * the same as source.
    		 */
    		if (is_garp && arp->ar_op == htons(ARPOP_REPLY))
    			is_garp =
    				/* IPv4 over IEEE 1394 doesn't provide target
    				 * hardware address field in its ARP payload.
    				 */
    				tha &&
    				!memcmp(tha, sha, dev->addr_len);
    
    		if (!n &&
    		    ((arp->ar_op == htons(ARPOP_REPLY)  &&
    				addr_type == RTN_UNICAST) || is_garp))
    			n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
    	}
    
    	if (n) {
    		int state = NUD_REACHABLE;
    		int override;
    
    		/* If several different ARP replies follows back-to-back,
    		   use the FIRST one. It is possible, if several proxy
    		   agents are active. Taking the first reply prevents
    		   arp trashing and chooses the fastest router.
    		 */
    		override = time_after(jiffies,
    				      n->updated +
    				      NEIGH_VAR(n->parms, LOCKTIME)) ||
    			   is_garp;
    
    		/* Broadcast replies and request packets
    		   do not assert neighbour reachability.
    		 */
    		if (arp->ar_op != htons(ARPOP_REPLY) ||
    		    skb->pkt_type != PACKET_HOST)
    			state = NUD_STALE;
    		neigh_update(n, sha, state,
    			     override ? NEIGH_UPDATE_F_OVERRIDE : 0);
    		neigh_release(n);
    	}
    
    out_consume_skb:
    	consume_skb(skb);
    
    out_free_dst:
    	dst_release(reply_dst);
    	return NET_RX_SUCCESS;
    
    out_free_skb:
    	kfree_skb(skb);
    	return NET_RX_DROP;
    }
    
    static void parp_redo(struct sk_buff *skb)
    {
    	arp_process(dev_net(skb->dev), NULL, skb);
    }
    
    
    /*
     *	Receive an arp request from the device layer.
     */
    
    static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
    		   struct packet_type *pt, struct net_device *orig_dev)
    {
    	const struct arphdr *arp;
    
    	/* do not tweak dropwatch on an ARP we will ignore */
    	if (dev->flags & IFF_NOARP ||
    	    skb->pkt_type == PACKET_OTHERHOST ||
    	    skb->pkt_type == PACKET_LOOPBACK)
    		goto consumeskb;
    
    	skb = skb_share_check(skb, GFP_ATOMIC);
    	if (!skb)
    		goto out_of_mem;
    
    	/* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
    	if (!pskb_may_pull(skb, arp_hdr_len(dev)))
    		goto freeskb;
    
    	arp = arp_hdr(skb);
    	if (arp->ar_hln != dev->addr_len || arp->ar_pln != 4)
    		goto freeskb;
    
    	memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
    
    	return NF_HOOK(NFPROTO_ARP, NF_ARP_IN,
    		       dev_net(dev), NULL, skb, dev, NULL,
    		       arp_process);
    
    consumeskb:
    	consume_skb(skb);
    	return NET_RX_SUCCESS;
    freeskb:
    	kfree_skb(skb);
    out_of_mem:
    	return NET_RX_DROP;
    }
    
    /*
     *	User level interface (ioctl)
     */
    
    /*
     *	Set (create) an ARP cache entry.
     */
    
    static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
    {
    	if (!dev) {
    		IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
    		return 0;
    	}
    	if (__in_dev_get_rtnl(dev)) {
    		IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
    		return 0;
    	}
    	return -ENXIO;
    }
    
    static int arp_req_set_public(struct net *net, struct arpreq *r,
    		struct net_device *dev)
    {
    	__be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
    	__be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
    
    	if (mask && mask != htonl(0xFFFFFFFF))
    		return -EINVAL;
    	if (!dev && (r->arp_flags & ATF_COM)) {
    		dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
    				      r->arp_ha.sa_data);
    		if (!dev)
    			return -ENODEV;
    	}
    	if (mask) {
    		if (!pneigh_lookup(&arp_tbl, net, &ip, dev, 1))
    			return -ENOBUFS;
    		return 0;
    	}