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