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