net/ipv4/arp.c

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