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