Pileus Git - ~andy/linux/blob - net/ipv4/arp.c

   1 /* linux/net/ipv4/arp.c
   2  *
   3  * Copyright (C) 1994 by Florian  La Roche
   4  *
   5  * This module implements the Address Resolution Protocol ARP (RFC 826),
   6  * which is used to convert IP addresses (or in the future maybe other
   7  * high-level addresses) into a low-level hardware address (like an Ethernet
   8  * address).
   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  * Fixes:
  16  *              Alan Cox        :       Removed the Ethernet assumptions in
  17  *                                      Florian's code
  18  *              Alan Cox        :       Fixed some small errors in the ARP
  19  *                                      logic
  20  *              Alan Cox        :       Allow >4K in /proc
  21  *              Alan Cox        :       Make ARP add its own protocol entry
  22  *              Ross Martin     :       Rewrote arp_rcv() and arp_get_info()
  23  *              Stephen Henson  :       Add AX25 support to arp_get_info()
  24  *              Alan Cox        :       Drop data when a device is downed.
  25  *              Alan Cox        :       Use init_timer().
  26  *              Alan Cox        :       Double lock fixes.
  27  *              Martin Seine    :       Move the arphdr structure
  28  *                                      to if_arp.h for compatibility.
  29  *                                      with BSD based programs.
  30  *              Andrew Tridgell :       Added ARP netmask code and
  31  *                                      re-arranged proxy handling.
  32  *              Alan Cox        :       Changed to use notifiers.
  33  *              Niibe Yutaka    :       Reply for this device or proxies only.
  34  *              Alan Cox        :       Don't proxy across hardware types!
  35  *              Jonathan Naylor :       Added support for NET/ROM.
  36  *              Mike Shaver     :       RFC1122 checks.
  37  *              Jonathan Naylor :       Only lookup the hardware address for
  38  *                                      the correct hardware type.
  39  *              Germano Caronni :       Assorted subtle races.
  40  *              Craig Schlenter :       Don't modify permanent entry
  41  *                                      during arp_rcv.
  42  *              Russ Nelson     :       Tidied up a few bits.
  43  *              Alexey Kuznetsov:       Major changes to caching and behaviour,
  44  *                                      eg intelligent arp probing and
  45  *                                      generation
  46  *                                      of host down events.
  47  *              Alan Cox        :       Missing unlock in device events.
  48  *              Eckes           :       ARP ioctl control errors.
  49  *              Alexey Kuznetsov:       Arp free fix.
  50  *              Manuel Rodriguez:       Gratuitous ARP.
  51  *              Jonathan Layes  :       Added arpd support through kerneld
  52  *                                      message queue (960314)
  53  *              Mike Shaver     :       /proc/sys/net/ipv4/arp_* support
  54  *              Mike McLagan    :       Routing by source
  55  *              Stuart Cheshire :       Metricom and grat arp fixes
  56  *                                      *** FOR 2.1 clean this up ***
  57  *              Lawrence V. Stefani: (08/12/96) Added FDDI support.
  58  *              Alan Cox        :       Took the AP1000 nasty FDDI hack and
  59  *                                      folded into the mainstream FDDI code.
  60  *                                      Ack spit, Linus how did you allow that
  61  *                                      one in...
  62  *              Jes Sorensen    :       Make FDDI work again in 2.1.x and
  63  *                                      clean up the APFDDI & gen. FDDI bits.
  64  *              Alexey Kuznetsov:       new arp state machine;
  65  *                                      now it is in net/core/neighbour.c.
  66  *              Krzysztof Halasa:       Added Frame Relay ARP support.
  67  *              Arnaldo C. Melo :       convert /proc/net/arp to seq_file
  68  *              Shmulik Hen:            Split arp_send to arp_create and
  69  *                                      arp_xmit so intermediate drivers like
  70  *                                      bonding can change the skb before
  71  *                                      sending (e.g. insert 8021q tag).
  72  *              Harald Welte    :       convert to make use of jenkins hash
  73  *              Jesper D. Brouer:       Proxy ARP PVLAN RFC 3069 support.
  74  */
  75
  76 #include <linux/module.h>
  77 #include <linux/types.h>
  78 #include <linux/string.h>
  79 #include <linux/kernel.h>
  80 #include <linux/capability.h>
  81 #include <linux/socket.h>
  82 #include <linux/sockios.h>
  83 #include <linux/errno.h>
  84 #include <linux/in.h>
  85 #include <linux/mm.h>
  86 #include <linux/inet.h>
  87 #include <linux/inetdevice.h>
  88 #include <linux/netdevice.h>
  89 #include <linux/etherdevice.h>
  90 #include <linux/fddidevice.h>
  91 #include <linux/if_arp.h>
  92 #include <linux/trdevice.h>
  93 #include <linux/skbuff.h>
  94 #include <linux/proc_fs.h>
  95 #include <linux/seq_file.h>
  96 #include <linux/stat.h>
  97 #include <linux/init.h>
  98 #include <linux/net.h>
  99 #include <linux/rcupdate.h>
 100 #include <linux/slab.h>
 101 #ifdef CONFIG_SYSCTL
 102 #include <linux/sysctl.h>
 103 #endif
 104
 105 #include <net/net_namespace.h>
 106 #include <net/ip.h>
 107 #include <net/icmp.h>
 108 #include <net/route.h>
 109 #include <net/protocol.h>
 110 #include <net/tcp.h>
 111 #include <net/sock.h>
 112 #include <net/arp.h>
 113 #include <net/ax25.h>
 114 #include <net/netrom.h>
 115
 116 #include <asm/system.h>
 117 #include <linux/uaccess.h>
 118
 119 #include <linux/netfilter_arp.h>
 120
 121 /*
 122  *      Interface to generic neighbour cache.
 123  */
 124 static u32 arp_hash(const void *pkey, const struct net_device *dev, __u32 *hash_rnd);
 125 static int arp_constructor(struct neighbour *neigh);
 126 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb);
 127 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb);
 128 static void parp_redo(struct sk_buff *skb);
 129
 130 static const struct neigh_ops arp_generic_ops = {
 131         .family =               AF_INET,
 132         .solicit =              arp_solicit,
 133         .error_report =         arp_error_report,
 134         .output =               neigh_resolve_output,
 135         .connected_output =     neigh_connected_output,
 136 };
 137
 138 static const struct neigh_ops arp_hh_ops = {
 139         .family =               AF_INET,
 140         .solicit =              arp_solicit,
 141         .error_report =         arp_error_report,
 142         .output =               neigh_resolve_output,
 143         .connected_output =     neigh_resolve_output,
 144 };
 145
 146 static const struct neigh_ops arp_direct_ops = {
 147         .family =               AF_INET,
 148         .output =               neigh_direct_output,
 149         .connected_output =     neigh_direct_output,
 150 };
 151
 152 static const struct neigh_ops arp_broken_ops = {
 153         .family =               AF_INET,
 154         .solicit =              arp_solicit,
 155         .error_report =         arp_error_report,
 156         .output =               neigh_compat_output,
 157         .connected_output =     neigh_compat_output,
 158 };
 159
 160 struct neigh_table arp_tbl = {
 161         .family         = AF_INET,
 162         .key_len        = 4,
 163         .hash           = arp_hash,
 164         .constructor    = arp_constructor,
 165         .proxy_redo     = parp_redo,
 166         .id             = "arp_cache",
 167         .parms          = {
 168                 .tbl                    = &arp_tbl,
 169                 .base_reachable_time    = 30 * HZ,
 170                 .retrans_time           = 1 * HZ,
 171                 .gc_staletime           = 60 * HZ,
 172                 .reachable_time         = 30 * HZ,
 173                 .delay_probe_time       = 5 * HZ,
 174                 .queue_len_bytes        = 64*1024,
 175                 .ucast_probes           = 3,
 176                 .mcast_probes           = 3,
 177                 .anycast_delay          = 1 * HZ,
 178                 .proxy_delay            = (8 * HZ) / 10,
 179                 .proxy_qlen             = 64,
 180                 .locktime               = 1 * HZ,
 181         },
 182         .gc_interval    = 30 * HZ,
 183         .gc_thresh1     = 128,
 184         .gc_thresh2     = 512,
 185         .gc_thresh3     = 1024,
 186 };
 187 EXPORT_SYMBOL(arp_tbl);
 188
 189 int arp_mc_map(__be32 addr, u8 *haddr, struct net_device *dev, int dir)
 190 {
 191         switch (dev->type) {
 192         case ARPHRD_ETHER:
 193         case ARPHRD_FDDI:
 194         case ARPHRD_IEEE802:
 195                 ip_eth_mc_map(addr, haddr);
 196                 return 0;
 197         case ARPHRD_IEEE802_TR:
 198                 ip_tr_mc_map(addr, haddr);
 199                 return 0;
 200         case ARPHRD_INFINIBAND:
 201                 ip_ib_mc_map(addr, dev->broadcast, haddr);
 202                 return 0;
 203         case ARPHRD_IPGRE:
 204                 ip_ipgre_mc_map(addr, dev->broadcast, haddr);
 205                 return 0;
 206         default:
 207                 if (dir) {
 208                         memcpy(haddr, dev->broadcast, dev->addr_len);
 209                         return 0;
 210                 }
 211         }
 212         return -EINVAL;
 213 }
 214
 215
 216 static u32 arp_hash(const void *pkey,
 217                     const struct net_device *dev,
 218                     __u32 *hash_rnd)
 219 {
 220         return arp_hashfn(*(u32 *)pkey, dev, *hash_rnd);
 221 }
 222
 223 static int arp_constructor(struct neighbour *neigh)
 224 {
 225         __be32 addr = *(__be32 *)neigh->primary_key;
 226         struct net_device *dev = neigh->dev;
 227         struct in_device *in_dev;
 228         struct neigh_parms *parms;
 229
 230         rcu_read_lock();
 231         in_dev = __in_dev_get_rcu(dev);
 232         if (in_dev == NULL) {
 233                 rcu_read_unlock();
 234                 return -EINVAL;
 235         }
 236
 237         neigh->type = inet_addr_type(dev_net(dev), addr);
 238
 239         parms = in_dev->arp_parms;
 240         __neigh_parms_put(neigh->parms);
 241         neigh->parms = neigh_parms_clone(parms);
 242         rcu_read_unlock();
 243
 244         if (!dev->header_ops) {
 245                 neigh->nud_state = NUD_NOARP;
 246                 neigh->ops = &arp_direct_ops;
 247                 neigh->output = neigh_direct_output;
 248         } else {
 249                 /* Good devices (checked by reading texts, but only Ethernet is
 250                    tested)
 251
 252                    ARPHRD_ETHER: (ethernet, apfddi)
 253                    ARPHRD_FDDI: (fddi)
 254                    ARPHRD_IEEE802: (tr)
 255                    ARPHRD_METRICOM: (strip)
 256                    ARPHRD_ARCNET:
 257                    etc. etc. etc.
 258
 259                    ARPHRD_IPDDP will also work, if author repairs it.
 260                    I did not it, because this driver does not work even
 261                    in old paradigm.
 262                  */
 263
 264 #if 1
 265                 /* So... these "amateur" devices are hopeless.
 266                    The only thing, that I can say now:
 267                    It is very sad that we need to keep ugly obsolete
 268                    code to make them happy.
 269
 270                    They should be moved to more reasonable state, now
 271                    they use rebuild_header INSTEAD OF hard_start_xmit!!!
 272                    Besides that, they are sort of out of date
 273                    (a lot of redundant clones/copies, useless in 2.1),
 274                    I wonder why people believe that they work.
 275                  */
 276                 switch (dev->type) {
 277                 default:
 278                         break;
 279                 case ARPHRD_ROSE:
 280 #if IS_ENABLED(CONFIG_AX25)
 281                 case ARPHRD_AX25:
 282 #if IS_ENABLED(CONFIG_NETROM)
 283                 case ARPHRD_NETROM:
 284 #endif
 285                         neigh->ops = &arp_broken_ops;
 286                         neigh->output = neigh->ops->output;
 287                         return 0;
 288 #else
 289                         break;
 290 #endif
 291                 }
 292 #endif
 293                 if (neigh->type == RTN_MULTICAST) {
 294                         neigh->nud_state = NUD_NOARP;
 295                         arp_mc_map(addr, neigh->ha, dev, 1);
 296                 } else if (dev->flags & (IFF_NOARP | IFF_LOOPBACK)) {
 297                         neigh->nud_state = NUD_NOARP;
 298                         memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
 299                 } else if (neigh->type == RTN_BROADCAST ||
 300                            (dev->flags & IFF_POINTOPOINT)) {
 301                         neigh->nud_state = NUD_NOARP;
 302                         memcpy(neigh->ha, dev->broadcast, dev->addr_len);
 303                 }
 304
 305                 if (dev->header_ops->cache)
 306                         neigh->ops = &arp_hh_ops;
 307                 else
 308                         neigh->ops = &arp_generic_ops;
 309
 310                 if (neigh->nud_state & NUD_VALID)
 311                         neigh->output = neigh->ops->connected_output;
 312                 else
 313                         neigh->output = neigh->ops->output;
 314         }
 315         return 0;
 316 }
 317
 318 static void arp_error_report(struct neighbour *neigh, struct sk_buff *skb)
 319 {
 320         dst_link_failure(skb);
 321         kfree_skb(skb);
 322 }
 323
 324 static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
 325 {
 326         __be32 saddr = 0;
 327         u8  *dst_ha = NULL;
 328         struct net_device *dev = neigh->dev;
 329         __be32 target = *(__be32 *)neigh->primary_key;
 330         int probes = atomic_read(&neigh->probes);
 331         struct in_device *in_dev;
 332
 333         rcu_read_lock();
 334         in_dev = __in_dev_get_rcu(dev);
 335         if (!in_dev) {
 336                 rcu_read_unlock();
 337                 return;
 338         }
 339         switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {
 340         default:
 341         case 0:         /* By default announce any local IP */
 342                 if (skb && inet_addr_type(dev_net(dev),
 343                                           ip_hdr(skb)->saddr) == RTN_LOCAL)
 344                         saddr = ip_hdr(skb)->saddr;
 345                 break;
 346         case 1:         /* Restrict announcements of saddr in same subnet */
 347                 if (!skb)
 348                         break;
 349                 saddr = ip_hdr(skb)->saddr;
 350                 if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {
 351                         /* saddr should be known to target */
 352                         if (inet_addr_onlink(in_dev, target, saddr))
 353                                 break;
 354                 }
 355                 saddr = 0;
 356                 break;
 357         case 2:         /* Avoid secondary IPs, get a primary/preferred one */
 358                 break;
 359         }
 360         rcu_read_unlock();
 361
 362         if (!saddr)
 363                 saddr = inet_select_addr(dev, target, RT_SCOPE_LINK);
 364
 365         probes -= neigh->parms->ucast_probes;
 366         if (probes < 0) {
 367                 if (!(neigh->nud_state & NUD_VALID))
 368                         printk(KERN_DEBUG
 369                                "trying to ucast probe in NUD_INVALID\n");
 370                 dst_ha = neigh->ha;
 371                 read_lock_bh(&neigh->lock);
 372         } else {
 373                 probes -= neigh->parms->app_probes;
 374                 if (probes < 0) {
 375 #ifdef CONFIG_ARPD
 376                         neigh_app_ns(neigh);
 377 #endif
 378                         return;
 379                 }
 380         }
 381
 382         arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
 383                  dst_ha, dev->dev_addr, NULL);
 384         if (dst_ha)
 385                 read_unlock_bh(&neigh->lock);
 386 }
 387
 388 static int arp_ignore(struct in_device *in_dev, __be32 sip, __be32 tip)
 389 {
 390         int scope;
 391
 392         switch (IN_DEV_ARP_IGNORE(in_dev)) {
 393         case 0: /* Reply, the tip is already validated */
 394                 return 0;
 395         case 1: /* Reply only if tip is configured on the incoming interface */
 396                 sip = 0;
 397                 scope = RT_SCOPE_HOST;
 398                 break;
 399         case 2: /*
 400                  * Reply only if tip is configured on the incoming interface
 401                  * and is in same subnet as sip
 402                  */
 403                 scope = RT_SCOPE_HOST;
 404                 break;
 405         case 3: /* Do not reply for scope host addresses */
 406                 sip = 0;
 407                 scope = RT_SCOPE_LINK;
 408                 break;
 409         case 4: /* Reserved */
 410         case 5:
 411         case 6:
 412         case 7:
 413                 return 0;
 414         case 8: /* Do not reply */
 415                 return 1;
 416         default:
 417                 return 0;
 418         }
 419         return !inet_confirm_addr(in_dev, sip, tip, scope);
 420 }
 421
 422 static int arp_filter(__be32 sip, __be32 tip, struct net_device *dev)
 423 {
 424         struct rtable *rt;
 425         int flag = 0;
 426         /*unsigned long now; */
 427         struct net *net = dev_net(dev);
 428
 429         rt = ip_route_output(net, sip, tip, 0, 0);
 430         if (IS_ERR(rt))
 431                 return 1;
 432         if (rt->dst.dev != dev) {
 433                 NET_INC_STATS_BH(net, LINUX_MIB_ARPFILTER);
 434                 flag = 1;
 435         }
 436         ip_rt_put(rt);
 437         return flag;
 438 }
 439
 440 /* OBSOLETE FUNCTIONS */
 441
 442 /*
 443  *      Find an arp mapping in the cache. If not found, post a request.
 444  *
 445  *      It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
 446  *      even if it exists. It is supposed that skb->dev was mangled
 447  *      by a virtual device (eql, shaper). Nobody but broken devices
 448  *      is allowed to use this function, it is scheduled to be removed. --ANK
 449  */
 450
 451 static int arp_set_predefined(int addr_hint, unsigned char *haddr,
 452                               __be32 paddr, struct net_device *dev)
 453 {
 454         switch (addr_hint) {
 455         case RTN_LOCAL:
 456                 printk(KERN_DEBUG "ARP: arp called for own IP address\n");
 457                 memcpy(haddr, dev->dev_addr, dev->addr_len);
 458                 return 1;
 459         case RTN_MULTICAST:
 460                 arp_mc_map(paddr, haddr, dev, 1);
 461                 return 1;
 462         case RTN_BROADCAST:
 463                 memcpy(haddr, dev->broadcast, dev->addr_len);
 464                 return 1;
 465         }
 466         return 0;
 467 }
 468
 469
 470 int arp_find(unsigned char *haddr, struct sk_buff *skb)
 471 {
 472         struct net_device *dev = skb->dev;
 473         __be32 paddr;
 474         struct neighbour *n;
 475
 476         if (!skb_dst(skb)) {
 477                 printk(KERN_DEBUG "arp_find is called with dst==NULL\n");
 478                 kfree_skb(skb);
 479                 return 1;
 480         }
 481
 482         paddr = skb_rtable(skb)->rt_gateway;
 483
 484         if (arp_set_predefined(inet_addr_type(dev_net(dev), paddr), haddr,
 485                                paddr, dev))
 486                 return 0;
 487
 488         n = __neigh_lookup(&arp_tbl, &paddr, dev, 1);
 489
 490         if (n) {
 491                 n->used = jiffies;
 492                 if (n->nud_state & NUD_VALID || neigh_event_send(n, skb) == 0) {
 493                         neigh_ha_snapshot(haddr, n, dev);
 494                         neigh_release(n);
 495                         return 0;
 496                 }
 497                 neigh_release(n);
 498         } else
 499                 kfree_skb(skb);
 500         return 1;
 501 }
 502 EXPORT_SYMBOL(arp_find);
 503
 504 /* END OF OBSOLETE FUNCTIONS */
 505
 506 /*
 507  * Check if we can use proxy ARP for this path
 508  */
 509 static inline int arp_fwd_proxy(struct in_device *in_dev,
 510                                 struct net_device *dev, struct rtable *rt)
 511 {
 512         struct in_device *out_dev;
 513         int imi, omi = -1;
 514
 515         if (rt->dst.dev == dev)
 516                 return 0;
 517
 518         if (!IN_DEV_PROXY_ARP(in_dev))
 519                 return 0;
 520         imi = IN_DEV_MEDIUM_ID(in_dev);
 521         if (imi == 0)
 522                 return 1;
 523         if (imi == -1)
 524                 return 0;
 525
 526         /* place to check for proxy_arp for routes */
 527
 528         out_dev = __in_dev_get_rcu(rt->dst.dev);
 529         if (out_dev)
 530                 omi = IN_DEV_MEDIUM_ID(out_dev);
 531
 532         return omi != imi && omi != -1;
 533 }
 534
 535 /*
 536  * Check for RFC3069 proxy arp private VLAN (allow to send back to same dev)
 537  *
 538  * RFC3069 supports proxy arp replies back to the same interface.  This
 539  * is done to support (ethernet) switch features, like RFC 3069, where
 540  * the individual ports are not allowed to communicate with each
 541  * other, BUT they are allowed to talk to the upstream router.  As
 542  * described in RFC 3069, it is possible to allow these hosts to
 543  * communicate through the upstream router, by proxy_arp'ing.
 544  *
 545  * RFC 3069: "VLAN Aggregation for Efficient IP Address Allocation"
 546  *
 547  *  This technology is known by different names:
 548  *    In RFC 3069 it is called VLAN Aggregation.
 549  *    Cisco and Allied Telesyn call it Private VLAN.
 550  *    Hewlett-Packard call it Source-Port filtering or port-isolation.
 551  *    Ericsson call it MAC-Forced Forwarding (RFC Draft).
 552  *
 553  */
 554 static inline int arp_fwd_pvlan(struct in_device *in_dev,
 555                                 struct net_device *dev, struct rtable *rt,
 556                                 __be32 sip, __be32 tip)
 557 {
 558         /* Private VLAN is only concerned about the same ethernet segment */
 559         if (rt->dst.dev != dev)
 560                 return 0;
 561
 562         /* Don't reply on self probes (often done by windowz boxes)*/
 563         if (sip == tip)
 564                 return 0;
 565
 566         if (IN_DEV_PROXY_ARP_PVLAN(in_dev))
 567                 return 1;
 568         else
 569                 return 0;
 570 }
 571
 572 /*
 573  *      Interface to link layer: send routine and receive handler.
 574  */
 575
 576 /*
 577  *      Create an arp packet. If (dest_hw == NULL), we create a broadcast
 578  *      message.
 579  */
 580 struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
 581                            struct net_device *dev, __be32 src_ip,
 582                            const unsigned char *dest_hw,
 583                            const unsigned char *src_hw,
 584                            const unsigned char *target_hw)
 585 {
 586         struct sk_buff *skb;
 587         struct arphdr *arp;
 588         unsigned char *arp_ptr;
 589         int hlen = LL_RESERVED_SPACE(dev);
 590         int tlen = dev->needed_tailroom;
 591
 592         /*
 593          *      Allocate a buffer
 594          */
 595
 596         skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
 597         if (skb == NULL)
 598                 return NULL;
 599
 600         skb_reserve(skb, hlen);
 601         skb_reset_network_header(skb);
 602         arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
 603         skb->dev = dev;
 604         skb->protocol = htons(ETH_P_ARP);
 605         if (src_hw == NULL)
 606                 src_hw = dev->dev_addr;
 607         if (dest_hw == NULL)
 608                 dest_hw = dev->broadcast;
 609
 610         /*
 611          *      Fill the device header for the ARP frame
 612          */
 613         if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)
 614                 goto out;
 615
 616         /*
 617          * Fill out the arp protocol part.
 618          *
 619          * The arp hardware type should match the device type, except for FDDI,
 620          * which (according to RFC 1390) should always equal 1 (Ethernet).
 621          */
 622         /*
 623          *      Exceptions everywhere. AX.25 uses the AX.25 PID value not the
 624          *      DIX code for the protocol. Make these device structure fields.
 625          */
 626         switch (dev->type) {
 627         default:
 628                 arp->ar_hrd = htons(dev->type);
 629                 arp->ar_pro = htons(ETH_P_IP);
 630                 break;
 631
 632 #if IS_ENABLED(CONFIG_AX25)
 633         case ARPHRD_AX25:
 634                 arp->ar_hrd = htons(ARPHRD_AX25);
 635                 arp->ar_pro = htons(AX25_P_IP);
 636                 break;
 637
 638 #if IS_ENABLED(CONFIG_NETROM)
 639         case ARPHRD_NETROM:
 640                 arp->ar_hrd = htons(ARPHRD_NETROM);
 641                 arp->ar_pro = htons(AX25_P_IP);
 642                 break;
 643 #endif
 644 #endif
 645
 646 #if IS_ENABLED(CONFIG_FDDI)
 647         case ARPHRD_FDDI:
 648                 arp->ar_hrd = htons(ARPHRD_ETHER);
 649                 arp->ar_pro = htons(ETH_P_IP);
 650                 break;
 651 #endif
 652 #if IS_ENABLED(CONFIG_TR)
 653         case ARPHRD_IEEE802_TR:
 654                 arp->ar_hrd = htons(ARPHRD_IEEE802);
 655                 arp->ar_pro = htons(ETH_P_IP);
 656                 break;
 657 #endif
 658         }
 659
 660         arp->ar_hln = dev->addr_len;
 661         arp->ar_pln = 4;
 662         arp->ar_op = htons(type);
 663
 664         arp_ptr = (unsigned char *)(arp + 1);
 665
 666         memcpy(arp_ptr, src_hw, dev->addr_len);
 667         arp_ptr += dev->addr_len;
 668         memcpy(arp_ptr, &src_ip, 4);
 669         arp_ptr += 4;
 670         if (target_hw != NULL)
 671                 memcpy(arp_ptr, target_hw, dev->addr_len);
 672         else
 673                 memset(arp_ptr, 0, dev->addr_len);
 674         arp_ptr += dev->addr_len;
 675         memcpy(arp_ptr, &dest_ip, 4);
 676
 677         return skb;
 678
 679 out:
 680         kfree_skb(skb);
 681         return NULL;
 682 }
 683 EXPORT_SYMBOL(arp_create);
 684
 685 /*
 686  *      Send an arp packet.
 687  */
 688 void arp_xmit(struct sk_buff *skb)
 689 {
 690         /* Send it off, maybe filter it using firewalling first.  */
 691         NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
 692 }
 693 EXPORT_SYMBOL(arp_xmit);
 694
 695 /*
 696  *      Create and send an arp packet.
 697  */
 698 void arp_send(int type, int ptype, __be32 dest_ip,
 699               struct net_device *dev, __be32 src_ip,
 700               const unsigned char *dest_hw, const unsigned char *src_hw,
 701               const unsigned char *target_hw)
 702 {
 703         struct sk_buff *skb;
 704
 705         /*
 706          *      No arp on this interface.
 707          */
 708
 709         if (dev->flags&IFF_NOARP)
 710                 return;
 711
 712         skb = arp_create(type, ptype, dest_ip, dev, src_ip,
 713                          dest_hw, src_hw, target_hw);
 714         if (skb == NULL)
 715                 return;
 716
 717         arp_xmit(skb);
 718 }
 719 EXPORT_SYMBOL(arp_send);
 720
 721 /*
 722  *      Process an arp request.
 723  */
 724
 725 static int arp_process(struct sk_buff *skb)
 726 {
 727         struct net_device *dev = skb->dev;
 728         struct in_device *in_dev = __in_dev_get_rcu(dev);
 729         struct arphdr *arp;
 730         unsigned char *arp_ptr;
 731         struct rtable *rt;
 732         unsigned char *sha;
 733         __be32 sip, tip;
 734         u16 dev_type = dev->type;
 735         int addr_type;
 736         struct neighbour *n;
 737         struct net *net = dev_net(dev);
 738
 739         /* arp_rcv below verifies the ARP header and verifies the device
 740          * is ARP'able.
 741          */
 742
 743         if (in_dev == NULL)
 744                 goto out;
 745
 746         arp = arp_hdr(skb);
 747
 748         switch (dev_type) {
 749         default:
 750                 if (arp->ar_pro != htons(ETH_P_IP) ||
 751                     htons(dev_type) != arp->ar_hrd)
 752                         goto out;
 753                 break;
 754         case ARPHRD_ETHER:
 755         case ARPHRD_IEEE802_TR:
 756         case ARPHRD_FDDI:
 757         case ARPHRD_IEEE802:
 758                 /*
 759                  * ETHERNET, Token Ring and Fibre Channel (which are IEEE 802
 760                  * devices, according to RFC 2625) devices will accept ARP
 761                  * hardware types of either 1 (Ethernet) or 6 (IEEE 802.2).
 762                  * This is the case also of FDDI, where the RFC 1390 says that
 763                  * FDDI devices should accept ARP hardware of (1) Ethernet,
 764                  * however, to be more robust, we'll accept both 1 (Ethernet)
 765                  * or 6 (IEEE 802.2)
 766                  */
 767                 if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
 768                      arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
 769                     arp->ar_pro != htons(ETH_P_IP))
 770                         goto out;
 771                 break;
 772         case ARPHRD_AX25:
 773                 if (arp->ar_pro != htons(AX25_P_IP) ||
 774                     arp->ar_hrd != htons(ARPHRD_AX25))
 775                         goto out;
 776                 break;
 777         case ARPHRD_NETROM:
 778                 if (arp->ar_pro != htons(AX25_P_IP) ||
 779                     arp->ar_hrd != htons(ARPHRD_NETROM))
 780                         goto out;
 781                 break;
 782         }
 783
 784         /* Understand only these message types */
 785
 786         if (arp->ar_op != htons(ARPOP_REPLY) &&
 787             arp->ar_op != htons(ARPOP_REQUEST))
 788                 goto out;
 789
 790 /*
 791  *      Extract fields
 792  */
 793         arp_ptr = (unsigned char *)(arp + 1);
 794         sha     = arp_ptr;
 795         arp_ptr += dev->addr_len;
 796         memcpy(&sip, arp_ptr, 4);
 797         arp_ptr += 4;
 798         arp_ptr += dev->addr_len;
 799         memcpy(&tip, arp_ptr, 4);
 800 /*
 801  *      Check for bad requests for 127.x.x.x and requests for multicast
 802  *      addresses.  If this is one such, delete it.
 803  */
 804         if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
 805                 goto out;
 806
 807 /*
 808  *     Special case: We must set Frame Relay source Q.922 address
 809  */
 810         if (dev_type == ARPHRD_DLCI)
 811                 sha = dev->broadcast;
 812
 813 /*
 814  *  Process entry.  The idea here is we want to send a reply if it is a
 815  *  request for us or if it is a request for someone else that we hold
 816  *  a proxy for.  We want to add an entry to our cache if it is a reply
 817  *  to us or if it is a request for our address.
 818  *  (The assumption for this last is that if someone is requesting our
 819  *  address, they are probably intending to talk to us, so it saves time
 820  *  if we cache their address.  Their address is also probably not in
 821  *  our cache, since ours is not in their cache.)
 822  *
 823  *  Putting this another way, we only care about replies if they are to
 824  *  us, in which case we add them to the cache.  For requests, we care
 825  *  about those for us and those for our proxies.  We reply to both,
 826  *  and in the case of requests for us we add the requester to the arp
 827  *  cache.
 828  */
 829
 830         /* Special case: IPv4 duplicate address detection packet (RFC2131) */
 831         if (sip == 0) {
 832                 if (arp->ar_op == htons(ARPOP_REQUEST) &&
 833                     inet_addr_type(net, tip) == RTN_LOCAL &&
 834                     !arp_ignore(in_dev, sip, tip))
 835                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip, dev, tip, sha,
 836                                  dev->dev_addr, sha);
 837                 goto out;
 838         }
 839
 840         if (arp->ar_op == htons(ARPOP_REQUEST) &&
 841             ip_route_input_noref(skb, tip, sip, 0, dev) == 0) {
 842
 843                 rt = skb_rtable(skb);
 844                 addr_type = rt->rt_type;
 845
 846                 if (addr_type == RTN_LOCAL) {
 847                         int dont_send;
 848
 849                         dont_send = arp_ignore(in_dev, sip, tip);
 850                         if (!dont_send && IN_DEV_ARPFILTER(in_dev))
 851                                 dont_send = arp_filter(sip, tip, dev);
 852                         if (!dont_send) {
 853                                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
 854                                 if (n) {
 855                                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
 856                                                  dev, tip, sha, dev->dev_addr,
 857                                                  sha);
 858                                         neigh_release(n);
 859                                 }
 860                         }
 861                         goto out;
 862                 } else if (IN_DEV_FORWARD(in_dev)) {
 863                         if (addr_type == RTN_UNICAST  &&
 864                             (arp_fwd_proxy(in_dev, dev, rt) ||
 865                              arp_fwd_pvlan(in_dev, dev, rt, sip, tip) ||
 866                              pneigh_lookup(&arp_tbl, net, &tip, dev, 0))) {
 867                                 n = neigh_event_ns(&arp_tbl, sha, &sip, dev);
 868                                 if (n)
 869                                         neigh_release(n);
 870
 871                                 if (NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED ||
 872                                     skb->pkt_type == PACKET_HOST ||
 873                                     in_dev->arp_parms->proxy_delay == 0) {
 874                                         arp_send(ARPOP_REPLY, ETH_P_ARP, sip,
 875                                                  dev, tip, sha, dev->dev_addr,
 876                                                  sha);
 877                                 } else {
 878                                         pneigh_enqueue(&arp_tbl,
 879                                                        in_dev->arp_parms, skb);
 880                                         return 0;
 881                                 }
 882                                 goto out;
 883                         }
 884                 }
 885         }
 886
 887         /* Update our ARP tables */
 888
 889         n = __neigh_lookup(&arp_tbl, &sip, dev, 0);
 890
 891         if (IPV4_DEVCONF_ALL(dev_net(dev), ARP_ACCEPT)) {
 892                 /* Unsolicited ARP is not accepted by default.
 893                    It is possible, that this option should be enabled for some
 894                    devices (strip is candidate)
 895                  */
 896                 if (n == NULL &&
 897                     (arp->ar_op == htons(ARPOP_REPLY) ||
 898                      (arp->ar_op == htons(ARPOP_REQUEST) && tip == sip)) &&
 899                     inet_addr_type(net, sip) == RTN_UNICAST)
 900                         n = __neigh_lookup(&arp_tbl, &sip, dev, 1);
 901         }
 902
 903         if (n) {
 904                 int state = NUD_REACHABLE;
 905                 int override;
 906
 907                 /* If several different ARP replies follows back-to-back,
 908                    use the FIRST one. It is possible, if several proxy
 909                    agents are active. Taking the first reply prevents
 910                    arp trashing and chooses the fastest router.
 911                  */
 912                 override = time_after(jiffies, n->updated + n->parms->locktime);
 913
 914                 /* Broadcast replies and request packets
 915                    do not assert neighbour reachability.
 916                  */
 917                 if (arp->ar_op != htons(ARPOP_REPLY) ||
 918                     skb->pkt_type != PACKET_HOST)
 919                         state = NUD_STALE;
 920                 neigh_update(n, sha, state,
 921                              override ? NEIGH_UPDATE_F_OVERRIDE : 0);
 922                 neigh_release(n);
 923         }
 924
 925 out:
 926         consume_skb(skb);
 927         return 0;
 928 }
 929
 930 static void parp_redo(struct sk_buff *skb)
 931 {
 932         arp_process(skb);
 933 }
 934
 935
 936 /*
 937  *      Receive an arp request from the device layer.
 938  */
 939
 940 static int arp_rcv(struct sk_buff *skb, struct net_device *dev,
 941                    struct packet_type *pt, struct net_device *orig_dev)
 942 {
 943         struct arphdr *arp;
 944
 945         /* ARP header, plus 2 device addresses, plus 2 IP addresses.  */
 946         if (!pskb_may_pull(skb, arp_hdr_len(dev)))
 947                 goto freeskb;
 948
 949         arp = arp_hdr(skb);
 950         if (arp->ar_hln != dev->addr_len ||
 951             dev->flags & IFF_NOARP ||
 952             skb->pkt_type == PACKET_OTHERHOST ||
 953             skb->pkt_type == PACKET_LOOPBACK ||
 954             arp->ar_pln != 4)
 955                 goto freeskb;
 956
 957         skb = skb_share_check(skb, GFP_ATOMIC);
 958         if (skb == NULL)
 959                 goto out_of_mem;
 960
 961         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
 962
 963         return NF_HOOK(NFPROTO_ARP, NF_ARP_IN, skb, dev, NULL, arp_process);
 964
 965 freeskb:
 966         kfree_skb(skb);
 967 out_of_mem:
 968         return 0;
 969 }
 970
 971 /*
 972  *      User level interface (ioctl)
 973  */
 974
 975 /*
 976  *      Set (create) an ARP cache entry.
 977  */
 978
 979 static int arp_req_set_proxy(struct net *net, struct net_device *dev, int on)
 980 {
 981         if (dev == NULL) {
 982                 IPV4_DEVCONF_ALL(net, PROXY_ARP) = on;
 983                 return 0;
 984         }
 985         if (__in_dev_get_rtnl(dev)) {
 986                 IN_DEV_CONF_SET(__in_dev_get_rtnl(dev), PROXY_ARP, on);
 987                 return 0;
 988         }
 989         return -ENXIO;
 990 }
 991
 992 static int arp_req_set_public(struct net *net, struct arpreq *r,
 993                 struct net_device *dev)
 994 {
 995         __be32 ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
 996         __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
 997
 998         if (mask && mask != htonl(0xFFFFFFFF))
 999                 return -EINVAL;
1000         if (!dev && (r->arp_flags & ATF_COM)) {
1001                 dev = dev_getbyhwaddr_rcu(net, r->arp_ha.sa_family,
1002                                       r->arp_ha.sa_data);
1003                 if (!dev)
1004                         return -ENODEV;
1005         }
1006         if (mask) {
1007                 if (pneigh_lookup(&arp_tbl, net, &ip, dev, 1) == NULL)
1008                         return -ENOBUFS;
1009                 return 0;
1010         }
1011
1012         return arp_req_set_proxy(net, dev, 1);
1013 }
1014
1015 static int arp_req_set(struct net *net, struct arpreq *r,
1016                        struct net_device *dev)
1017 {
1018         __be32 ip;
1019         struct neighbour *neigh;
1020         int err;
1021
1022         if (r->arp_flags & ATF_PUBL)
1023                 return arp_req_set_public(net, r, dev);
1024
1025         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1026         if (r->arp_flags & ATF_PERM)
1027                 r->arp_flags |= ATF_COM;
1028         if (dev == NULL) {
1029                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
1030
1031                 if (IS_ERR(rt))
1032                         return PTR_ERR(rt);
1033                 dev = rt->dst.dev;
1034                 ip_rt_put(rt);
1035                 if (!dev)
1036                         return -EINVAL;
1037         }
1038         switch (dev->type) {
1039 #if IS_ENABLED(CONFIG_FDDI)
1040         case ARPHRD_FDDI:
1041                 /*
1042                  * According to RFC 1390, FDDI devices should accept ARP
1043                  * hardware types of 1 (Ethernet).  However, to be more
1044                  * robust, we'll accept hardware types of either 1 (Ethernet)
1045                  * or 6 (IEEE 802.2).
1046                  */
1047                 if (r->arp_ha.sa_family != ARPHRD_FDDI &&
1048                     r->arp_ha.sa_family != ARPHRD_ETHER &&
1049                     r->arp_ha.sa_family != ARPHRD_IEEE802)
1050                         return -EINVAL;
1051                 break;
1052 #endif
1053         default:
1054                 if (r->arp_ha.sa_family != dev->type)
1055                         return -EINVAL;
1056                 break;
1057         }
1058
1059         neigh = __neigh_lookup_errno(&arp_tbl, &ip, dev);
1060         err = PTR_ERR(neigh);
1061         if (!IS_ERR(neigh)) {
1062                 unsigned state = NUD_STALE;
1063                 if (r->arp_flags & ATF_PERM)
1064                         state = NUD_PERMANENT;
1065                 err = neigh_update(neigh, (r->arp_flags & ATF_COM) ?
1066                                    r->arp_ha.sa_data : NULL, state,
1067                                    NEIGH_UPDATE_F_OVERRIDE |
1068                                    NEIGH_UPDATE_F_ADMIN);
1069                 neigh_release(neigh);
1070         }
1071         return err;
1072 }
1073
1074 static unsigned arp_state_to_flags(struct neighbour *neigh)
1075 {
1076         if (neigh->nud_state&NUD_PERMANENT)
1077                 return ATF_PERM | ATF_COM;
1078         else if (neigh->nud_state&NUD_VALID)
1079                 return ATF_COM;
1080         else
1081                 return 0;
1082 }
1083
1084 /*
1085  *      Get an ARP cache entry.
1086  */
1087
1088 static int arp_req_get(struct arpreq *r, struct net_device *dev)
1089 {
1090         __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1091         struct neighbour *neigh;
1092         int err = -ENXIO;
1093
1094         neigh = neigh_lookup(&arp_tbl, &ip, dev);
1095         if (neigh) {
1096                 read_lock_bh(&neigh->lock);
1097                 memcpy(r->arp_ha.sa_data, neigh->ha, dev->addr_len);
1098                 r->arp_flags = arp_state_to_flags(neigh);
1099                 read_unlock_bh(&neigh->lock);
1100                 r->arp_ha.sa_family = dev->type;
1101                 strlcpy(r->arp_dev, dev->name, sizeof(r->arp_dev));
1102                 neigh_release(neigh);
1103                 err = 0;
1104         }
1105         return err;
1106 }
1107
1108 int arp_invalidate(struct net_device *dev, __be32 ip)
1109 {
1110         struct neighbour *neigh = neigh_lookup(&arp_tbl, &ip, dev);
1111         int err = -ENXIO;
1112
1113         if (neigh) {
1114                 if (neigh->nud_state & ~NUD_NOARP)
1115                         err = neigh_update(neigh, NULL, NUD_FAILED,
1116                                            NEIGH_UPDATE_F_OVERRIDE|
1117                                            NEIGH_UPDATE_F_ADMIN);
1118                 neigh_release(neigh);
1119         }
1120
1121         return err;
1122 }
1123 EXPORT_SYMBOL(arp_invalidate);
1124
1125 static int arp_req_delete_public(struct net *net, struct arpreq *r,
1126                 struct net_device *dev)
1127 {
1128         __be32 ip = ((struct sockaddr_in *) &r->arp_pa)->sin_addr.s_addr;
1129         __be32 mask = ((struct sockaddr_in *)&r->arp_netmask)->sin_addr.s_addr;
1130
1131         if (mask == htonl(0xFFFFFFFF))
1132                 return pneigh_delete(&arp_tbl, net, &ip, dev);
1133
1134         if (mask)
1135                 return -EINVAL;
1136
1137         return arp_req_set_proxy(net, dev, 0);
1138 }
1139
1140 static int arp_req_delete(struct net *net, struct arpreq *r,
1141                           struct net_device *dev)
1142 {
1143         __be32 ip;
1144
1145         if (r->arp_flags & ATF_PUBL)
1146                 return arp_req_delete_public(net, r, dev);
1147
1148         ip = ((struct sockaddr_in *)&r->arp_pa)->sin_addr.s_addr;
1149         if (dev == NULL) {
1150                 struct rtable *rt = ip_route_output(net, ip, 0, RTO_ONLINK, 0);
1151                 if (IS_ERR(rt))
1152                         return PTR_ERR(rt);
1153                 dev = rt->dst.dev;
1154                 ip_rt_put(rt);
1155                 if (!dev)
1156                         return -EINVAL;
1157         }
1158         return arp_invalidate(dev, ip);
1159 }
1160
1161 /*
1162  *      Handle an ARP layer I/O control request.
1163  */
1164
1165 int arp_ioctl(struct net *net, unsigned int cmd, void __user *arg)
1166 {
1167         int err;
1168         struct arpreq r;
1169         struct net_device *dev = NULL;
1170
1171         switch (cmd) {
1172         case SIOCDARP:
1173         case SIOCSARP:
1174                 if (!capable(CAP_NET_ADMIN))
1175                         return -EPERM;
1176         case SIOCGARP:
1177                 err = copy_from_user(&r, arg, sizeof(struct arpreq));
1178                 if (err)
1179                         return -EFAULT;
1180                 break;
1181         default:
1182                 return -EINVAL;
1183         }
1184
1185         if (r.arp_pa.sa_family != AF_INET)
1186                 return -EPFNOSUPPORT;
1187
1188         if (!(r.arp_flags & ATF_PUBL) &&
1189             (r.arp_flags & (ATF_NETMASK | ATF_DONTPUB)))
1190                 return -EINVAL;
1191         if (!(r.arp_flags & ATF_NETMASK))
1192                 ((struct sockaddr_in *)&r.arp_netmask)->sin_addr.s_addr =
1193                                                            htonl(0xFFFFFFFFUL);
1194         rtnl_lock();
1195         if (r.arp_dev[0]) {
1196                 err = -ENODEV;
1197                 dev = __dev_get_by_name(net, r.arp_dev);
1198                 if (dev == NULL)
1199                         goto out;
1200
1201                 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
1202                 if (!r.arp_ha.sa_family)
1203                         r.arp_ha.sa_family = dev->type;
1204                 err = -EINVAL;
1205                 if ((r.arp_flags & ATF_COM) && r.arp_ha.sa_family != dev->type)
1206                         goto out;
1207         } else if (cmd == SIOCGARP) {
1208                 err = -ENODEV;
1209                 goto out;
1210         }
1211
1212         switch (cmd) {
1213         case SIOCDARP:
1214                 err = arp_req_delete(net, &r, dev);
1215                 break;
1216         case SIOCSARP:
1217                 err = arp_req_set(net, &r, dev);
1218                 break;
1219         case SIOCGARP:
1220                 err = arp_req_get(&r, dev);
1221                 break;
1222         }
1223 out:
1224         rtnl_unlock();
1225         if (cmd == SIOCGARP && !err && copy_to_user(arg, &r, sizeof(r)))
1226                 err = -EFAULT;
1227         return err;
1228 }
1229
1230 static int arp_netdev_event(struct notifier_block *this, unsigned long event,
1231                             void *ptr)
1232 {
1233         struct net_device *dev = ptr;
1234
1235         switch (event) {
1236         case NETDEV_CHANGEADDR:
1237                 neigh_changeaddr(&arp_tbl, dev);
1238                 rt_cache_flush(dev_net(dev), 0);
1239                 break;
1240         default:
1241                 break;
1242         }
1243
1244         return NOTIFY_DONE;
1245 }
1246
1247 static struct notifier_block arp_netdev_notifier = {
1248         .notifier_call = arp_netdev_event,
1249 };
1250
1251 /* Note, that it is not on notifier chain.
1252    It is necessary, that this routine was called after route cache will be
1253    flushed.
1254  */
1255 void arp_ifdown(struct net_device *dev)
1256 {
1257         neigh_ifdown(&arp_tbl, dev);
1258 }
1259
1260
1261 /*
1262  *      Called once on startup.
1263  */
1264
1265 static struct packet_type arp_packet_type __read_mostly = {
1266         .type = cpu_to_be16(ETH_P_ARP),
1267         .func = arp_rcv,
1268 };
1269
1270 static int arp_proc_init(void);
1271
1272 void __init arp_init(void)
1273 {
1274         neigh_table_init(&arp_tbl);
1275
1276         dev_add_pack(&arp_packet_type);
1277         arp_proc_init();
1278 #ifdef CONFIG_SYSCTL
1279         neigh_sysctl_register(NULL, &arp_tbl.parms, "ipv4", NULL);
1280 #endif
1281         register_netdevice_notifier(&arp_netdev_notifier);
1282 }
1283
1284 #ifdef CONFIG_PROC_FS
1285 #if IS_ENABLED(CONFIG_AX25)
1286
1287 /* ------------------------------------------------------------------------ */
1288 /*
1289  *      ax25 -> ASCII conversion
1290  */
1291 static char *ax2asc2(ax25_address *a, char *buf)
1292 {
1293         char c, *s;
1294         int n;
1295
1296         for (n = 0, s = buf; n < 6; n++) {
1297                 c = (a->ax25_call[n] >> 1) & 0x7F;
1298
1299                 if (c != ' ')
1300                         *s++ = c;
1301         }
1302
1303         *s++ = '-';
1304         n = (a->ax25_call[6] >> 1) & 0x0F;
1305         if (n > 9) {
1306                 *s++ = '1';
1307                 n -= 10;
1308         }
1309
1310         *s++ = n + '0';
1311         *s++ = '\0';
1312
1313         if (*buf == '\0' || *buf == '-')
1314                 return "*";
1315
1316         return buf;
1317 }
1318 #endif /* CONFIG_AX25 */
1319
1320 #define HBUFFERLEN 30
1321
1322 static void arp_format_neigh_entry(struct seq_file *seq,
1323                                    struct neighbour *n)
1324 {
1325         char hbuffer[HBUFFERLEN];
1326         int k, j;
1327         char tbuf[16];
1328         struct net_device *dev = n->dev;
1329         int hatype = dev->type;
1330
1331         read_lock(&n->lock);
1332         /* Convert hardware address to XX:XX:XX:XX ... form. */
1333 #if IS_ENABLED(CONFIG_AX25)
1334         if (hatype == ARPHRD_AX25 || hatype == ARPHRD_NETROM)
1335                 ax2asc2((ax25_address *)n->ha, hbuffer);
1336         else {
1337 #endif
1338         for (k = 0, j = 0; k < HBUFFERLEN - 3 && j < dev->addr_len; j++) {
1339                 hbuffer[k++] = hex_asc_hi(n->ha[j]);
1340                 hbuffer[k++] = hex_asc_lo(n->ha[j]);
1341                 hbuffer[k++] = ':';
1342         }
1343         if (k != 0)
1344                 --k;
1345         hbuffer[k] = 0;
1346 #if IS_ENABLED(CONFIG_AX25)
1347         }
1348 #endif
1349         sprintf(tbuf, "%pI4", n->primary_key);
1350         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1351                    tbuf, hatype, arp_state_to_flags(n), hbuffer, dev->name);
1352         read_unlock(&n->lock);
1353 }
1354
1355 static void arp_format_pneigh_entry(struct seq_file *seq,
1356                                     struct pneigh_entry *n)
1357 {
1358         struct net_device *dev = n->dev;
1359         int hatype = dev ? dev->type : 0;
1360         char tbuf[16];
1361
1362         sprintf(tbuf, "%pI4", n->key);
1363         seq_printf(seq, "%-16s 0x%-10x0x%-10x%s     *        %s\n",
1364                    tbuf, hatype, ATF_PUBL | ATF_PERM, "00:00:00:00:00:00",
1365                    dev ? dev->name : "*");
1366 }
1367
1368 static int arp_seq_show(struct seq_file *seq, void *v)
1369 {
1370         if (v == SEQ_START_TOKEN) {
1371                 seq_puts(seq, "IP address       HW type     Flags       "
1372                               "HW address            Mask     Device\n");
1373         } else {
1374                 struct neigh_seq_state *state = seq->private;
1375
1376                 if (state->flags & NEIGH_SEQ_IS_PNEIGH)
1377                         arp_format_pneigh_entry(seq, v);
1378                 else
1379                         arp_format_neigh_entry(seq, v);
1380         }
1381
1382         return 0;
1383 }
1384
1385 static void *arp_seq_start(struct seq_file *seq, loff_t *pos)
1386 {
1387         /* Don't want to confuse "arp -a" w/ magic entries,
1388          * so we tell the generic iterator to skip NUD_NOARP.
1389          */
1390         return neigh_seq_start(seq, pos, &arp_tbl, NEIGH_SEQ_SKIP_NOARP);
1391 }
1392
1393 /* ------------------------------------------------------------------------ */
1394
1395 static const struct seq_operations arp_seq_ops = {
1396         .start  = arp_seq_start,
1397         .next   = neigh_seq_next,
1398         .stop   = neigh_seq_stop,
1399         .show   = arp_seq_show,
1400 };
1401
1402 static int arp_seq_open(struct inode *inode, struct file *file)
1403 {
1404         return seq_open_net(inode, file, &arp_seq_ops,
1405                             sizeof(struct neigh_seq_state));
1406 }
1407
1408 static const struct file_operations arp_seq_fops = {
1409         .owner          = THIS_MODULE,
1410         .open           = arp_seq_open,
1411         .read           = seq_read,
1412         .llseek         = seq_lseek,
1413         .release        = seq_release_net,
1414 };
1415
1416
1417 static int __net_init arp_net_init(struct net *net)
1418 {
1419         if (!proc_net_fops_create(net, "arp", S_IRUGO, &arp_seq_fops))
1420                 return -ENOMEM;
1421         return 0;
1422 }
1423
1424 static void __net_exit arp_net_exit(struct net *net)
1425 {
1426         proc_net_remove(net, "arp");
1427 }
1428
1429 static struct pernet_operations arp_net_ops = {
1430         .init = arp_net_init,
1431         .exit = arp_net_exit,
1432 };
1433
1434 static int __init arp_proc_init(void)
1435 {
1436         return register_pernet_subsys(&arp_net_ops);
1437 }
1438
1439 #else /* CONFIG_PROC_FS */
1440
1441 static int __init arp_proc_init(void)
1442 {
1443         return 0;
1444 }
1445
1446 #endif /* CONFIG_PROC_FS */