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