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