1 /* linux/net/inet/arp.c
3 * Version: $Id: arp.c,v 1.78 1999/06/09 10:10:36 davem Exp $
5 * Copyright (C) 1994 by Florian La Roche
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
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.
18 * Alan Cox : Removed the Ethernet assumptions in
20 * Alan Cox : Fixed some small errors in the ARP
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
44 * Russ Nelson : Tidied up a few bits.
45 * Alexey Kuznetsov: Major changes to caching and behaviour,
46 * eg intelligent arp probing and
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
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.
71 2.3.2.1 (ARP Cache Validation):
72 MUST provide mechanism to flush stale cache entries (OK)
73 SHOULD be able to configure cache timeout (OK)
74 MUST throttle ARP retransmits (OK)
75 2.3.2.2 (ARP Packet Queue):
76 SHOULD save at least one packet from each "conversation" with an
77 unresolved IP address. (OK)
81 #include <linux/types.h>
82 #include <linux/string.h>
83 #include <linux/kernel.h>
84 #include <linux/sched.h>
85 #include <linux/config.h>
86 #include <linux/socket.h>
87 #include <linux/sockios.h>
88 #include <linux/errno.h>
91 #include <linux/inet.h>
92 #include <linux/netdevice.h>
93 #include <linux/etherdevice.h>
94 #include <linux/fddidevice.h>
95 #include <linux/if_arp.h>
96 #include <linux/trdevice.h>
97 #include <linux/skbuff.h>
98 #include <linux/proc_fs.h>
99 #include <linux/stat.h>
100 #include <linux/init.h>
102 #include <linux/sysctl.h>
106 #include <net/icmp.h>
107 #include <net/route.h>
108 #include <net/protocol.h>
110 #include <net/sock.h>
112 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
113 #include <net/ax25.h>
114 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
115 #include <net/netrom.h>
119 #include <asm/system.h>
120 #include <asm/uaccess.h>
122 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
123 static char *ax2asc2(ax25_address
*a
, char *buf
);
128 * Interface to generic neighbour cache.
130 static int arp_constructor(struct neighbour
*neigh
);
131 static void arp_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
132 static void arp_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
133 static void parp_redo(struct sk_buff
*skb
);
135 static struct neigh_ops arp_generic_ops
=
141 neigh_resolve_output
,
142 neigh_connected_output
,
147 static struct neigh_ops arp_hh_ops
=
153 neigh_resolve_output
,
154 neigh_resolve_output
,
159 static struct neigh_ops arp_direct_ops
=
171 struct neigh_ops arp_broken_ops
=
183 struct neigh_table arp_tbl
=
187 sizeof(struct neighbour
) + 4,
193 { NULL
, NULL
, &arp_tbl
, 0, NULL
, NULL
,
194 30*HZ
, 1*HZ
, 60*HZ
, 30*HZ
, 5*HZ
, 3, 3, 0, 3, 1*HZ
, (8*HZ
)/10, 64, 1*HZ
},
195 30*HZ
, 128, 512, 1024,
198 int arp_mc_map(u32 addr
, u8
*haddr
, struct device
*dev
, int dir
)
204 ip_eth_mc_map(addr
, haddr
);
208 memcpy(haddr
, dev
->broadcast
, dev
->addr_len
);
217 static int arp_constructor(struct neighbour
*neigh
)
219 u32 addr
= *(u32
*)neigh
->primary_key
;
220 struct device
*dev
= neigh
->dev
;
221 struct in_device
*in_dev
= dev
->ip_ptr
;
226 neigh
->type
= inet_addr_type(addr
);
227 if (in_dev
->arp_parms
)
228 neigh
->parms
= in_dev
->arp_parms
;
230 if (dev
->hard_header
== NULL
) {
231 neigh
->nud_state
= NUD_NOARP
;
232 neigh
->ops
= &arp_direct_ops
;
233 neigh
->output
= neigh
->ops
->queue_xmit
;
235 /* Good devices (checked by reading texts, but only Ethernet is
238 ARPHRD_ETHER: (ethernet, apfddi)
241 ARPHRD_METRICOM: (strip)
245 ARPHRD_IPDDP will also work, if author repairs it.
246 I did not it, because this driver does not work even
251 /* So... these "amateur" devices are hopeless.
252 The only thing, that I can say now:
253 It is very sad that we need to keep ugly obsolete
254 code to make them happy.
256 They should be moved to more reasonable state, now
257 they use rebuild_header INSTEAD OF hard_start_xmit!!!
258 Besides that, they are sort of out of date
259 (a lot of redundant clones/copies, useless in 2.1),
260 I wonder why people believe that they work.
266 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
268 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
271 neigh
->ops
= &arp_broken_ops
;
272 neigh
->output
= neigh
->ops
->output
;
277 if (neigh
->type
== RTN_MULTICAST
) {
278 neigh
->nud_state
= NUD_NOARP
;
279 arp_mc_map(addr
, neigh
->ha
, dev
, 1);
280 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
281 neigh
->nud_state
= NUD_NOARP
;
282 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
283 } else if (neigh
->type
== RTN_BROADCAST
|| dev
->flags
&IFF_POINTOPOINT
) {
284 neigh
->nud_state
= NUD_NOARP
;
285 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
287 if (dev
->hard_header_cache
)
288 neigh
->ops
= &arp_hh_ops
;
290 neigh
->ops
= &arp_generic_ops
;
291 if (neigh
->nud_state
&NUD_VALID
)
292 neigh
->output
= neigh
->ops
->connected_output
;
294 neigh
->output
= neigh
->ops
->output
;
300 static void arp_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
302 dst_link_failure(skb
);
306 static void arp_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
310 struct device
*dev
= neigh
->dev
;
311 u32 target
= *(u32
*)neigh
->primary_key
;
312 int probes
= atomic_read(&neigh
->probes
);
314 if (skb
&& inet_addr_type(skb
->nh
.iph
->saddr
) == RTN_LOCAL
)
315 saddr
= skb
->nh
.iph
->saddr
;
317 saddr
= inet_select_addr(dev
, target
, RT_SCOPE_LINK
);
319 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
320 if (!(neigh
->nud_state
&NUD_VALID
))
321 printk(KERN_DEBUG
"trying to ucast probe in NUD_INVALID\n");
323 read_lock_bh(&neigh
->lock
);
324 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
331 arp_send(ARPOP_REQUEST
, ETH_P_ARP
, target
, dev
, saddr
,
332 dst_ha
, dev
->dev_addr
, NULL
);
334 read_unlock_bh(&neigh
->lock
);
337 /* OBSOLETE FUNCTIONS */
340 * Find an arp mapping in the cache. If not found, post a request.
342 * It is very UGLY routine: it DOES NOT use skb->dst->neighbour,
343 * even if it exists. It is supposed that skb->dev was mangled
344 * by a virtual device (eql, shaper). Nobody but broken devices
345 * is allowed to use this function, it is scheduled to be removed. --ANK
348 static int arp_set_predefined(int addr_hint
, unsigned char * haddr
, u32 paddr
, struct device
* dev
)
352 printk(KERN_DEBUG
"ARP: arp called for own IP address\n");
353 memcpy(haddr
, dev
->dev_addr
, dev
->addr_len
);
356 arp_mc_map(paddr
, haddr
, dev
, 1);
359 memcpy(haddr
, dev
->broadcast
, dev
->addr_len
);
366 int arp_find(unsigned char *haddr
, struct sk_buff
*skb
)
368 struct device
*dev
= skb
->dev
;
373 printk(KERN_DEBUG
"arp_find is called with dst==NULL\n");
378 paddr
= ((struct rtable
*)skb
->dst
)->rt_gateway
;
380 if (arp_set_predefined(inet_addr_type(paddr
), haddr
, paddr
, dev
))
383 n
= __neigh_lookup(&arp_tbl
, &paddr
, dev
, 1);
387 if (n
->nud_state
&NUD_VALID
|| neigh_event_send(n
, skb
) == 0) {
388 read_lock_bh(&n
->lock
);
389 memcpy(haddr
, n
->ha
, dev
->addr_len
);
390 read_unlock_bh(&n
->lock
);
400 /* END OF OBSOLETE FUNCTIONS */
402 int arp_bind_neighbour(struct dst_entry
*dst
)
404 struct device
*dev
= dst
->dev
;
408 if (dst
->neighbour
== NULL
) {
409 u32 nexthop
= ((struct rtable
*)dst
)->rt_gateway
;
410 if (dev
->flags
&(IFF_LOOPBACK
|IFF_POINTOPOINT
))
412 dst
->neighbour
= __neigh_lookup(&arp_tbl
, &nexthop
, dev
, 1);
414 return (dst
->neighbour
!= NULL
);
418 * Interface to link layer: send routine and receive handler.
422 * Create and send an arp packet. If (dest_hw == NULL), we create a broadcast
426 void arp_send(int type
, int ptype
, u32 dest_ip
,
427 struct device
*dev
, u32 src_ip
,
428 unsigned char *dest_hw
, unsigned char *src_hw
,
429 unsigned char *target_hw
)
433 unsigned char *arp_ptr
;
436 * No arp on this interface.
439 if (dev
->flags
&IFF_NOARP
)
446 skb
= alloc_skb(sizeof(struct arphdr
)+ 2*(dev
->addr_len
+4)
447 + dev
->hard_header_len
+ 15, GFP_ATOMIC
);
451 skb_reserve(skb
, (dev
->hard_header_len
+15)&~15);
452 skb
->nh
.raw
= skb
->data
;
453 arp
= (struct arphdr
*) skb_put(skb
,sizeof(struct arphdr
) + 2*(dev
->addr_len
+4));
455 skb
->protocol
= __constant_htons (ETH_P_ARP
);
457 src_hw
= dev
->dev_addr
;
459 dest_hw
= dev
->broadcast
;
462 * Fill the device header for the ARP frame
464 dev
->hard_header(skb
,dev
,ptype
,dest_hw
,src_hw
,skb
->len
);
467 * Fill out the arp protocol part.
469 * The arp hardware type should match the device type, except for FDDI,
470 * which (according to RFC 1390) should always equal 1 (Ethernet).
473 * Exceptions everywhere. AX.25 uses the AX.25 PID value not the
474 * DIX code for the protocol. Make these device structure fields.
478 arp
->ar_hrd
= htons(dev
->type
);
479 arp
->ar_pro
= __constant_htons(ETH_P_IP
);
482 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
484 arp
->ar_hrd
= __constant_htons(ARPHRD_AX25
);
485 arp
->ar_pro
= __constant_htons(AX25_P_IP
);
488 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
490 arp
->ar_hrd
= __constant_htons(ARPHRD_NETROM
);
491 arp
->ar_pro
= __constant_htons(AX25_P_IP
);
498 arp
->ar_hrd
= __constant_htons(ARPHRD_ETHER
);
499 arp
->ar_pro
= __constant_htons(ETH_P_IP
);
504 arp
->ar_hln
= dev
->addr_len
;
506 arp
->ar_op
= htons(type
);
508 arp_ptr
=(unsigned char *)(arp
+1);
510 memcpy(arp_ptr
, src_hw
, dev
->addr_len
);
511 arp_ptr
+=dev
->addr_len
;
512 memcpy(arp_ptr
, &src_ip
,4);
514 if (target_hw
!= NULL
)
515 memcpy(arp_ptr
, target_hw
, dev
->addr_len
);
517 memset(arp_ptr
, 0, dev
->addr_len
);
518 arp_ptr
+=dev
->addr_len
;
519 memcpy(arp_ptr
, &dest_ip
, 4);
525 static void parp_redo(struct sk_buff
*skb
)
527 arp_rcv(skb
, skb
->dev
, NULL
);
531 * Receive an arp request by the device layer.
534 int arp_rcv(struct sk_buff
*skb
, struct device
*dev
, struct packet_type
*pt
)
536 struct arphdr
*arp
= skb
->nh
.arph
;
537 unsigned char *arp_ptr
= (unsigned char *)(arp
+1);
539 unsigned char *sha
, *tha
;
541 u16 dev_type
= dev
->type
;
543 struct in_device
*in_dev
= dev
->ip_ptr
;
547 * The hardware length of the packet should match the hardware length
548 * of the device. Similarly, the hardware types should match. The
549 * device should be ARP-able. Also, if pln is not 4, then the lookup
550 * is not from an IP number. We can't currently handle this, so toss
553 if (in_dev
== NULL
||
554 arp
->ar_hln
!= dev
->addr_len
||
555 dev
->flags
& IFF_NOARP
||
556 skb
->pkt_type
== PACKET_OTHERHOST
||
557 skb
->pkt_type
== PACKET_LOOPBACK
||
563 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
565 if (htons(dev_type
) != arp
->ar_hrd
)
568 #ifdef CONFIG_NET_ETHERNET
571 * ETHERNET devices will accept ARP hardware types of either
572 * 1 (Ethernet) or 6 (IEEE 802.2).
574 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_ETHER
) &&
575 arp
->ar_hrd
!= __constant_htons(ARPHRD_IEEE802
))
577 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
584 * According to RFC 1390, FDDI devices should accept ARP hardware types
585 * of 1 (Ethernet). However, to be more robust, we'll accept hardware
586 * types of either 1 (Ethernet) or 6 (IEEE 802.2).
588 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_ETHER
) &&
589 arp
->ar_hrd
!= __constant_htons(ARPHRD_IEEE802
))
591 if (arp
->ar_pro
!= __constant_htons(ETH_P_IP
))
595 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
597 if (arp
->ar_pro
!= __constant_htons(AX25_P_IP
))
599 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_AX25
))
602 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
604 if (arp
->ar_pro
!= __constant_htons(AX25_P_IP
))
606 if (arp
->ar_hrd
!= __constant_htons(ARPHRD_NETROM
))
613 /* Undertsand only these message types */
615 if (arp
->ar_op
!= __constant_htons(ARPOP_REPLY
) &&
616 arp
->ar_op
!= __constant_htons(ARPOP_REQUEST
))
623 arp_ptr
+= dev
->addr_len
;
624 memcpy(&sip
, arp_ptr
, 4);
627 arp_ptr
+= dev
->addr_len
;
628 memcpy(&tip
, arp_ptr
, 4);
630 * Check for bad requests for 127.x.x.x and requests for multicast
631 * addresses. If this is one such, delete it.
633 if (LOOPBACK(tip
) || MULTICAST(tip
))
637 * Process entry. The idea here is we want to send a reply if it is a
638 * request for us or if it is a request for someone else that we hold
639 * a proxy for. We want to add an entry to our cache if it is a reply
640 * to us or if it is a request for our address.
641 * (The assumption for this last is that if someone is requesting our
642 * address, they are probably intending to talk to us, so it saves time
643 * if we cache their address. Their address is also probably not in
644 * our cache, since ours is not in their cache.)
646 * Putting this another way, we only care about replies if they are to
647 * us, in which case we add them to the cache. For requests, we care
648 * about those for us and those for our proxies. We reply to both,
649 * and in the case of requests for us we add the requester to the arp
653 /* Special case: IPv4 duplicate address detection packet (RFC2131) */
655 if (arp
->ar_op
== __constant_htons(ARPOP_REQUEST
) &&
656 inet_addr_type(tip
) == RTN_LOCAL
)
657 arp_send(ARPOP_REPLY
,ETH_P_ARP
,tip
,dev
,tip
,sha
,dev
->dev_addr
,dev
->dev_addr
);
661 if (arp
->ar_op
== __constant_htons(ARPOP_REQUEST
) &&
662 ip_route_input(skb
, tip
, sip
, 0, dev
) == 0) {
664 rt
= (struct rtable
*)skb
->dst
;
665 addr_type
= rt
->rt_type
;
667 if (addr_type
== RTN_LOCAL
) {
668 n
= neigh_event_ns(&arp_tbl
, sha
, &sip
, dev
);
670 arp_send(ARPOP_REPLY
,ETH_P_ARP
,sip
,dev
,tip
,sha
,dev
->dev_addr
,sha
);
674 } else if (IN_DEV_FORWARD(in_dev
)) {
675 if ((rt
->rt_flags
&RTCF_DNAT
) ||
676 (addr_type
== RTN_UNICAST
&& rt
->u
.dst
.dev
!= dev
&&
677 (IN_DEV_PROXY_ARP(in_dev
) || pneigh_lookup(&arp_tbl
, &tip
, dev
, 0)))) {
678 n
= neigh_event_ns(&arp_tbl
, sha
, &sip
, dev
);
682 if (skb
->stamp
.tv_sec
== 0 ||
683 skb
->pkt_type
== PACKET_HOST
||
684 in_dev
->arp_parms
->proxy_delay
== 0) {
685 arp_send(ARPOP_REPLY
,ETH_P_ARP
,sip
,dev
,tip
,sha
,dev
->dev_addr
,sha
);
687 pneigh_enqueue(&arp_tbl
, in_dev
->arp_parms
, skb
);
695 /* Update our ARP tables */
697 n
= __neigh_lookup(&arp_tbl
, &sip
, dev
, 0);
699 #ifdef CONFIG_IP_ACCEPT_UNSOLICITED_ARP
700 /* Unsolicited ARP is not accepted by default.
701 It is possible, that this option should be enabled for some
702 devices (strip is candidate)
705 arp
->ar_op
== __constant_htons(ARPOP_REPLY
) &&
706 inet_addr_type(sip
) == RTN_UNICAST
)
707 n
= __neigh_lookup(&arp_tbl
, &sip
, dev
, -1);
711 int state
= NUD_REACHABLE
;
714 /* If several different ARP replies follows back-to-back,
715 use the FIRST one. It is possible, if several proxy
716 agents are active. Taking the first reply prevents
717 arp trashing and chooses the fastest router.
719 if (jiffies
- n
->updated
>= n
->parms
->locktime
)
722 /* Broadcast replies and request packets
723 do not assert neighbour reachability.
725 if (arp
->ar_op
!= __constant_htons(ARPOP_REPLY
) ||
726 skb
->pkt_type
!= PACKET_HOST
)
728 neigh_update(n
, sha
, state
, override
, 1);
740 * User level interface (ioctl, /proc)
744 * Set (create) an ARP cache entry.
747 int arp_req_set(struct arpreq
*r
, struct device
* dev
)
749 u32 ip
= ((struct sockaddr_in
*) &r
->arp_pa
)->sin_addr
.s_addr
;
750 struct neighbour
*neigh
;
753 if (r
->arp_flags
&ATF_PUBL
) {
754 u32 mask
= ((struct sockaddr_in
*) &r
->arp_netmask
)->sin_addr
.s_addr
;
755 if (mask
&& mask
!= 0xFFFFFFFF)
757 if (!dev
&& (r
->arp_flags
& ATF_COM
)) {
758 dev
= dev_getbyhwaddr(r
->arp_ha
.sa_family
, r
->arp_ha
.sa_data
);
763 if (pneigh_lookup(&arp_tbl
, &ip
, dev
, 1) == NULL
)
768 ipv4_devconf
.proxy_arp
= 1;
772 ((struct in_device
*)dev
->ip_ptr
)->cnf
.proxy_arp
= 1;
778 if (r
->arp_flags
& ATF_PERM
)
779 r
->arp_flags
|= ATF_COM
;
782 if ((err
= ip_route_output(&rt
, ip
, 0, RTO_ONLINK
, 0)) != 0)
789 if (r
->arp_ha
.sa_family
!= dev
->type
)
793 neigh
= __neigh_lookup(&arp_tbl
, &ip
, dev
, 1);
795 unsigned state
= NUD_STALE
;
796 if (r
->arp_flags
& ATF_PERM
)
797 state
= NUD_PERMANENT
;
798 err
= neigh_update(neigh
, (r
->arp_flags
&ATF_COM
) ?
799 r
->arp_ha
.sa_data
: NULL
, state
, 1, 0);
800 neigh_release(neigh
);
805 static unsigned arp_state_to_flags(struct neighbour
*neigh
)
808 if (neigh
->nud_state
&NUD_PERMANENT
)
809 flags
= ATF_PERM
|ATF_COM
;
810 else if (neigh
->nud_state
&NUD_VALID
)
816 * Get an ARP cache entry.
819 static int arp_req_get(struct arpreq
*r
, struct device
*dev
)
821 u32 ip
= ((struct sockaddr_in
*) &r
->arp_pa
)->sin_addr
.s_addr
;
822 struct neighbour
*neigh
;
825 neigh
= neigh_lookup(&arp_tbl
, &ip
, dev
);
827 read_lock_bh(&neigh
->lock
);
828 memcpy(r
->arp_ha
.sa_data
, neigh
->ha
, dev
->addr_len
);
829 r
->arp_flags
= arp_state_to_flags(neigh
);
830 read_unlock_bh(&neigh
->lock
);
831 r
->arp_ha
.sa_family
= dev
->type
;
832 strncpy(r
->arp_dev
, dev
->name
, sizeof(r
->arp_dev
));
833 neigh_release(neigh
);
839 int arp_req_delete(struct arpreq
*r
, struct device
* dev
)
842 u32 ip
= ((struct sockaddr_in
*)&r
->arp_pa
)->sin_addr
.s_addr
;
843 struct neighbour
*neigh
;
845 if (r
->arp_flags
& ATF_PUBL
) {
846 u32 mask
= ((struct sockaddr_in
*) &r
->arp_netmask
)->sin_addr
.s_addr
;
847 if (mask
== 0xFFFFFFFF)
848 return pneigh_delete(&arp_tbl
, &ip
, dev
);
851 ipv4_devconf
.proxy_arp
= 0;
855 ((struct in_device
*)dev
->ip_ptr
)->cnf
.proxy_arp
= 0;
865 if ((err
= ip_route_output(&rt
, ip
, 0, RTO_ONLINK
, 0)) != 0)
873 neigh
= neigh_lookup(&arp_tbl
, &ip
, dev
);
875 if (neigh
->nud_state
&~NUD_NOARP
)
876 err
= neigh_update(neigh
, NULL
, NUD_FAILED
, 1, 0);
877 neigh_release(neigh
);
883 * Handle an ARP layer I/O control request.
886 int arp_ioctl(unsigned int cmd
, void *arg
)
890 struct device
* dev
= NULL
;
895 if (!capable(CAP_NET_ADMIN
))
898 err
= copy_from_user(&r
, arg
, sizeof(struct arpreq
));
906 if (r
.arp_pa
.sa_family
!= AF_INET
)
907 return -EPFNOSUPPORT
;
909 if (!(r
.arp_flags
& ATF_PUBL
) &&
910 (r
.arp_flags
& (ATF_NETMASK
|ATF_DONTPUB
)))
912 if (!(r
.arp_flags
& ATF_NETMASK
))
913 ((struct sockaddr_in
*)&r
.arp_netmask
)->sin_addr
.s_addr
=__constant_htonl(0xFFFFFFFFUL
);
918 if ((dev
= dev_get(r
.arp_dev
)) == NULL
)
921 /* Mmmm... It is wrong... ARPHRD_NETROM==0 */
922 if (!r
.arp_ha
.sa_family
)
923 r
.arp_ha
.sa_family
= dev
->type
;
925 if ((r
.arp_flags
& ATF_COM
) && r
.arp_ha
.sa_family
!= dev
->type
)
927 } else if (cmd
== SIOCGARP
) {
934 err
= arp_req_delete(&r
, dev
);
937 err
= arp_req_set(&r
, dev
);
940 err
= arp_req_get(&r
, dev
);
941 if (!err
&& copy_to_user(arg
, &r
, sizeof(r
)))
951 * Write the contents of the ARP cache to a PROCfs file.
953 #ifdef CONFIG_PROC_FS
955 #define HBUFFERLEN 30
957 int arp_get_info(char *buffer
, char **start
, off_t offset
, int length
, int dummy
)
962 char hbuffer
[HBUFFERLEN
];
964 const char hexbuf
[] = "0123456789ABCDEF";
967 size
= sprintf(buffer
,"IP address HW type Flags HW address Mask Device\n");
972 for(i
=0; i
<=NEIGH_HASHMASK
; i
++) {
974 read_lock_bh(&arp_tbl
.lock
);
975 for (n
=arp_tbl
.hash_buckets
[i
]; n
; n
=n
->next
) {
976 struct device
*dev
= n
->dev
;
977 int hatype
= dev
->type
;
979 /* Do not confuse users "arp -a" with magic entries */
980 if (!(n
->nud_state
&~NUD_NOARP
))
986 * Convert hardware address to XX:XX:XX:XX ... form.
988 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
989 if (hatype
== ARPHRD_AX25
|| hatype
== ARPHRD_NETROM
)
990 ax2asc2((ax25_address
*)n
->ha
, hbuffer
);
993 for (k
=0,j
=0;k
<HBUFFERLEN
-3 && j
<dev
->addr_len
;j
++) {
994 hbuffer
[k
++]=hexbuf
[(n
->ha
[j
]>>4)&15 ];
995 hbuffer
[k
++]=hexbuf
[n
->ha
[j
]&15 ];
1000 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1004 size
= sprintf(buffer
+len
,
1005 "%-17s0x%-10x0x%-10x%s",
1006 in_ntoa2(*(u32
*)n
->primary_key
, abuf
),
1008 arp_state_to_flags(n
),
1010 size
+= sprintf(buffer
+len
+size
,
1013 read_unlock(&n
->lock
);
1020 if (pos
>= offset
+length
) {
1021 read_unlock_bh(&arp_tbl
.lock
);
1025 read_unlock_bh(&arp_tbl
.lock
);
1028 for (i
=0; i
<=PNEIGH_HASHMASK
; i
++) {
1029 struct pneigh_entry
*n
;
1030 for (n
=arp_tbl
.phash_buckets
[i
]; n
; n
=n
->next
) {
1031 struct device
*dev
= n
->dev
;
1032 int hatype
= dev
? dev
->type
: 0;
1034 size
= sprintf(buffer
+len
,
1035 "%-17s0x%-10x0x%-10x%s",
1036 in_ntoa2(*(u32
*)n
->key
, abuf
),
1039 "00:00:00:00:00:00");
1040 size
+= sprintf(buffer
+len
+size
,
1042 "*", dev
? dev
->name
: "*");
1049 if (pos
>= offset
+length
)
1056 *start
= buffer
+len
-(pos
-offset
); /* Start of wanted data */
1057 len
= pos
-offset
; /* Start slop */
1059 len
= length
; /* Ending slop */
1066 /* Note, that it is not on notifier chain.
1067 It is necessary, that this routine was called after route cache will be
1070 void arp_ifdown(struct device
*dev
)
1072 neigh_ifdown(&arp_tbl
, dev
);
1077 * Called once on startup.
1080 static struct packet_type arp_packet_type
=
1082 __constant_htons(ETH_P_ARP
),
1083 NULL
, /* All devices */
1089 #ifdef CONFIG_PROC_FS
1090 static struct proc_dir_entry proc_net_arp
= {
1091 PROC_NET_ARP
, 3, "arp",
1092 S_IFREG
| S_IRUGO
, 1, 0, 0,
1093 0, &proc_net_inode_operations
,
1098 __initfunc(void arp_init (void))
1100 neigh_table_init(&arp_tbl
);
1102 dev_add_pack(&arp_packet_type
);
1104 #ifdef CONFIG_PROC_FS
1105 proc_net_register(&proc_net_arp
);
1107 #ifdef CONFIG_SYSCTL
1108 neigh_sysctl_register(NULL
, &arp_tbl
.parms
, NET_IPV4
, NET_IPV4_NEIGH
, "ipv4");
1113 #if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
1116 * ax25 -> ASCII conversion
1118 char *ax2asc2(ax25_address
*a
, char *buf
)
1123 for (n
= 0, s
= buf
; n
< 6; n
++) {
1124 c
= (a
->ax25_call
[n
] >> 1) & 0x7F;
1126 if (c
!= ' ') *s
++ = c
;
1131 if ((n
= ((a
->ax25_call
[6] >> 1) & 0x0F)) > 9) {
1139 if (*buf
== '\0' || *buf
== '-')