git.oblomov.eu Git - linux-2.6/blob - net/ipv4/arp.c

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