net/ipv4/arp.c

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