2 * AARP: An implementation of the AppleTalk AARP protocol for
5 * Alan Cox <Alan.Cox@linux.org>
7 * This doesn't fit cleanly with the IP arp. Potentially we can use
8 * the generic neighbour discovery code to clean this up.
11 * We ought to handle the retransmits with a single list and a
12 * separate fast timer for when it is needed.
13 * Use neighbour discovery code.
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License
18 * as published by the Free Software Foundation; either version
19 * 2 of the License, or (at your option) any later version.
23 * Inside AppleTalk (2nd Ed).
25 * Jaume Grau - flush caches on AARP_PROBE
26 * Rob Newberry - Added proxy AARP and AARP proc fs,
27 * moved probing from DDP module.
28 * Arnaldo C. Melo - don't mangle rx packets
32 #include <linux/if_arp.h>
34 #include <net/datalink.h>
35 #include <net/psnap.h>
36 #include <linux/atalk.h>
37 #include <linux/delay.h>
38 #include <linux/init.h>
39 #include <linux/proc_fs.h>
40 #include <linux/seq_file.h>
42 int sysctl_aarp_expiry_time
= AARP_EXPIRY_TIME
;
43 int sysctl_aarp_tick_time
= AARP_TICK_TIME
;
44 int sysctl_aarp_retransmit_limit
= AARP_RETRANSMIT_LIMIT
;
45 int sysctl_aarp_resolve_time
= AARP_RESOLVE_TIME
;
47 /* Lists of aarp entries */
49 * struct aarp_entry - AARP entry
50 * @last_sent - Last time we xmitted the aarp request
51 * @packet_queue - Queue of frames wait for resolution
52 * @status - Used for proxy AARP
53 * expires_at - Entry expiry time
54 * target_addr - DDP Address
56 * hwaddr - Physical i/f address of target/router
57 * xmit_count - When this hits 10 we give up
58 * next - Next entry in chain
61 /* These first two are only used for unresolved entries */
62 unsigned long last_sent
;
63 struct sk_buff_head packet_queue
;
65 unsigned long expires_at
;
66 struct atalk_addr target_addr
;
67 struct net_device
*dev
;
69 unsigned short xmit_count
;
70 struct aarp_entry
*next
;
73 /* Hashed list of resolved, unresolved and proxy entries */
74 static struct aarp_entry
*resolved
[AARP_HASH_SIZE
];
75 static struct aarp_entry
*unresolved
[AARP_HASH_SIZE
];
76 static struct aarp_entry
*proxies
[AARP_HASH_SIZE
];
77 static int unresolved_count
;
79 /* One lock protects it all. */
80 static DEFINE_RWLOCK(aarp_lock
);
82 /* Used to walk the list and purge/kick entries. */
83 static struct timer_list aarp_timer
;
86 * Delete an aarp queue
88 * Must run under aarp_lock.
90 static void __aarp_expire(struct aarp_entry
*a
)
92 skb_queue_purge(&a
->packet_queue
);
97 * Send an aarp queue entry request
99 * Must run under aarp_lock.
101 static void __aarp_send_query(struct aarp_entry
*a
)
103 static unsigned char aarp_eth_multicast
[ETH_ALEN
] =
104 { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
105 struct net_device
*dev
= a
->dev
;
106 struct elapaarp
*eah
;
107 int len
= dev
->hard_header_len
+ sizeof(*eah
) + aarp_dl
->header_length
;
108 struct sk_buff
*skb
= alloc_skb(len
, GFP_ATOMIC
);
109 struct atalk_addr
*sat
= atalk_find_dev_addr(dev
);
119 /* Set up the buffer */
120 skb_reserve(skb
, dev
->hard_header_len
+ aarp_dl
->header_length
);
121 skb_reset_network_header(skb
);
122 skb_reset_transport_header(skb
);
123 skb_put(skb
, sizeof(*eah
));
124 skb
->protocol
= htons(ETH_P_ATALK
);
129 eah
->hw_type
= htons(AARP_HW_TYPE_ETHERNET
);
130 eah
->pa_type
= htons(ETH_P_ATALK
);
131 eah
->hw_len
= ETH_ALEN
;
132 eah
->pa_len
= AARP_PA_ALEN
;
133 eah
->function
= htons(AARP_REQUEST
);
135 memcpy(eah
->hw_src
, dev
->dev_addr
, ETH_ALEN
);
137 eah
->pa_src_zero
= 0;
138 eah
->pa_src_net
= sat
->s_net
;
139 eah
->pa_src_node
= sat
->s_node
;
141 memset(eah
->hw_dst
, '\0', ETH_ALEN
);
143 eah
->pa_dst_zero
= 0;
144 eah
->pa_dst_net
= a
->target_addr
.s_net
;
145 eah
->pa_dst_node
= a
->target_addr
.s_node
;
148 aarp_dl
->request(aarp_dl
, skb
, aarp_eth_multicast
);
149 /* Update the sending count */
151 a
->last_sent
= jiffies
;
154 /* This runs under aarp_lock and in softint context, so only atomic memory
155 * allocations can be used. */
156 static void aarp_send_reply(struct net_device
*dev
, struct atalk_addr
*us
,
157 struct atalk_addr
*them
, unsigned char *sha
)
159 struct elapaarp
*eah
;
160 int len
= dev
->hard_header_len
+ sizeof(*eah
) + aarp_dl
->header_length
;
161 struct sk_buff
*skb
= alloc_skb(len
, GFP_ATOMIC
);
166 /* Set up the buffer */
167 skb_reserve(skb
, dev
->hard_header_len
+ aarp_dl
->header_length
);
168 skb_reset_network_header(skb
);
169 skb_reset_transport_header(skb
);
170 skb_put(skb
, sizeof(*eah
));
171 skb
->protocol
= htons(ETH_P_ATALK
);
176 eah
->hw_type
= htons(AARP_HW_TYPE_ETHERNET
);
177 eah
->pa_type
= htons(ETH_P_ATALK
);
178 eah
->hw_len
= ETH_ALEN
;
179 eah
->pa_len
= AARP_PA_ALEN
;
180 eah
->function
= htons(AARP_REPLY
);
182 memcpy(eah
->hw_src
, dev
->dev_addr
, ETH_ALEN
);
184 eah
->pa_src_zero
= 0;
185 eah
->pa_src_net
= us
->s_net
;
186 eah
->pa_src_node
= us
->s_node
;
189 memset(eah
->hw_dst
, '\0', ETH_ALEN
);
191 memcpy(eah
->hw_dst
, sha
, ETH_ALEN
);
193 eah
->pa_dst_zero
= 0;
194 eah
->pa_dst_net
= them
->s_net
;
195 eah
->pa_dst_node
= them
->s_node
;
198 aarp_dl
->request(aarp_dl
, skb
, sha
);
202 * Send probe frames. Called from aarp_probe_network and
203 * aarp_proxy_probe_network.
206 static void aarp_send_probe(struct net_device
*dev
, struct atalk_addr
*us
)
208 struct elapaarp
*eah
;
209 int len
= dev
->hard_header_len
+ sizeof(*eah
) + aarp_dl
->header_length
;
210 struct sk_buff
*skb
= alloc_skb(len
, GFP_ATOMIC
);
211 static unsigned char aarp_eth_multicast
[ETH_ALEN
] =
212 { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
217 /* Set up the buffer */
218 skb_reserve(skb
, dev
->hard_header_len
+ aarp_dl
->header_length
);
219 skb_reset_network_header(skb
);
220 skb_reset_transport_header(skb
);
221 skb_put(skb
, sizeof(*eah
));
222 skb
->protocol
= htons(ETH_P_ATALK
);
227 eah
->hw_type
= htons(AARP_HW_TYPE_ETHERNET
);
228 eah
->pa_type
= htons(ETH_P_ATALK
);
229 eah
->hw_len
= ETH_ALEN
;
230 eah
->pa_len
= AARP_PA_ALEN
;
231 eah
->function
= htons(AARP_PROBE
);
233 memcpy(eah
->hw_src
, dev
->dev_addr
, ETH_ALEN
);
235 eah
->pa_src_zero
= 0;
236 eah
->pa_src_net
= us
->s_net
;
237 eah
->pa_src_node
= us
->s_node
;
239 memset(eah
->hw_dst
, '\0', ETH_ALEN
);
241 eah
->pa_dst_zero
= 0;
242 eah
->pa_dst_net
= us
->s_net
;
243 eah
->pa_dst_node
= us
->s_node
;
246 aarp_dl
->request(aarp_dl
, skb
, aarp_eth_multicast
);
250 * Handle an aarp timer expire
252 * Must run under the aarp_lock.
255 static void __aarp_expire_timer(struct aarp_entry
**n
)
257 struct aarp_entry
*t
;
261 if (time_after(jiffies
, (*n
)->expires_at
)) {
270 * Kick all pending requests 5 times a second.
272 * Must run under the aarp_lock.
274 static void __aarp_kick(struct aarp_entry
**n
)
276 struct aarp_entry
*t
;
279 /* Expired: if this will be the 11th tx, we delete instead. */
280 if ((*n
)->xmit_count
>= sysctl_aarp_retransmit_limit
) {
285 __aarp_send_query(*n
);
291 * A device has gone down. Take all entries referring to the device
294 * Must run under the aarp_lock.
296 static void __aarp_expire_device(struct aarp_entry
**n
, struct net_device
*dev
)
298 struct aarp_entry
*t
;
301 if ((*n
)->dev
== dev
) {
309 /* Handle the timer event */
310 static void aarp_expire_timeout(unsigned long unused
)
314 write_lock_bh(&aarp_lock
);
316 for (ct
= 0; ct
< AARP_HASH_SIZE
; ct
++) {
317 __aarp_expire_timer(&resolved
[ct
]);
318 __aarp_kick(&unresolved
[ct
]);
319 __aarp_expire_timer(&unresolved
[ct
]);
320 __aarp_expire_timer(&proxies
[ct
]);
323 write_unlock_bh(&aarp_lock
);
324 mod_timer(&aarp_timer
, jiffies
+
325 (unresolved_count
? sysctl_aarp_tick_time
:
326 sysctl_aarp_expiry_time
));
329 /* Network device notifier chain handler. */
330 static int aarp_device_event(struct notifier_block
*this, unsigned long event
,
333 struct net_device
*dev
= ptr
;
336 if (dev
->nd_net
!= &init_net
)
339 if (event
== NETDEV_DOWN
) {
340 write_lock_bh(&aarp_lock
);
342 for (ct
= 0; ct
< AARP_HASH_SIZE
; ct
++) {
343 __aarp_expire_device(&resolved
[ct
], dev
);
344 __aarp_expire_device(&unresolved
[ct
], dev
);
345 __aarp_expire_device(&proxies
[ct
], dev
);
348 write_unlock_bh(&aarp_lock
);
353 /* Expire all entries in a hash chain */
354 static void __aarp_expire_all(struct aarp_entry
**n
)
356 struct aarp_entry
*t
;
365 /* Cleanup all hash chains -- module unloading */
366 static void aarp_purge(void)
370 write_lock_bh(&aarp_lock
);
371 for (ct
= 0; ct
< AARP_HASH_SIZE
; ct
++) {
372 __aarp_expire_all(&resolved
[ct
]);
373 __aarp_expire_all(&unresolved
[ct
]);
374 __aarp_expire_all(&proxies
[ct
]);
376 write_unlock_bh(&aarp_lock
);
380 * Create a new aarp entry. This must use GFP_ATOMIC because it
381 * runs while holding spinlocks.
383 static struct aarp_entry
*aarp_alloc(void)
385 struct aarp_entry
*a
= kmalloc(sizeof(*a
), GFP_ATOMIC
);
388 skb_queue_head_init(&a
->packet_queue
);
393 * Find an entry. We might return an expired but not yet purged entry. We
394 * don't care as it will do no harm.
396 * This must run under the aarp_lock.
398 static struct aarp_entry
*__aarp_find_entry(struct aarp_entry
*list
,
399 struct net_device
*dev
,
400 struct atalk_addr
*sat
)
403 if (list
->target_addr
.s_net
== sat
->s_net
&&
404 list
->target_addr
.s_node
== sat
->s_node
&&
413 /* Called from the DDP code, and thus must be exported. */
414 void aarp_proxy_remove(struct net_device
*dev
, struct atalk_addr
*sa
)
416 int hash
= sa
->s_node
% (AARP_HASH_SIZE
- 1);
417 struct aarp_entry
*a
;
419 write_lock_bh(&aarp_lock
);
421 a
= __aarp_find_entry(proxies
[hash
], dev
, sa
);
423 a
->expires_at
= jiffies
- 1;
425 write_unlock_bh(&aarp_lock
);
428 /* This must run under aarp_lock. */
429 static struct atalk_addr
*__aarp_proxy_find(struct net_device
*dev
,
430 struct atalk_addr
*sa
)
432 int hash
= sa
->s_node
% (AARP_HASH_SIZE
- 1);
433 struct aarp_entry
*a
= __aarp_find_entry(proxies
[hash
], dev
, sa
);
435 return a
? sa
: NULL
;
439 * Probe a Phase 1 device or a device that requires its Net:Node to
440 * be set via an ioctl.
442 static void aarp_send_probe_phase1(struct atalk_iface
*iface
)
445 struct sockaddr_at
*sa
= (struct sockaddr_at
*)&atreq
.ifr_addr
;
447 sa
->sat_addr
.s_node
= iface
->address
.s_node
;
448 sa
->sat_addr
.s_net
= ntohs(iface
->address
.s_net
);
450 /* We pass the Net:Node to the drivers/cards by a Device ioctl. */
451 if (!(iface
->dev
->do_ioctl(iface
->dev
, &atreq
, SIOCSIFADDR
))) {
452 (void)iface
->dev
->do_ioctl(iface
->dev
, &atreq
, SIOCGIFADDR
);
453 if (iface
->address
.s_net
!= htons(sa
->sat_addr
.s_net
) ||
454 iface
->address
.s_node
!= sa
->sat_addr
.s_node
)
455 iface
->status
|= ATIF_PROBE_FAIL
;
457 iface
->address
.s_net
= htons(sa
->sat_addr
.s_net
);
458 iface
->address
.s_node
= sa
->sat_addr
.s_node
;
463 void aarp_probe_network(struct atalk_iface
*atif
)
465 if (atif
->dev
->type
== ARPHRD_LOCALTLK
||
466 atif
->dev
->type
== ARPHRD_PPP
)
467 aarp_send_probe_phase1(atif
);
471 for (count
= 0; count
< AARP_RETRANSMIT_LIMIT
; count
++) {
472 aarp_send_probe(atif
->dev
, &atif
->address
);
477 if (atif
->status
& ATIF_PROBE_FAIL
)
483 int aarp_proxy_probe_network(struct atalk_iface
*atif
, struct atalk_addr
*sa
)
485 int hash
, retval
= -EPROTONOSUPPORT
;
486 struct aarp_entry
*entry
;
490 * we don't currently support LocalTalk or PPP for proxy AARP;
491 * if someone wants to try and add it, have fun
493 if (atif
->dev
->type
== ARPHRD_LOCALTLK
||
494 atif
->dev
->type
== ARPHRD_PPP
)
498 * create a new AARP entry with the flags set to be published --
499 * we need this one to hang around even if it's in use
501 entry
= aarp_alloc();
506 entry
->expires_at
= -1;
507 entry
->status
= ATIF_PROBE
;
508 entry
->target_addr
.s_node
= sa
->s_node
;
509 entry
->target_addr
.s_net
= sa
->s_net
;
510 entry
->dev
= atif
->dev
;
512 write_lock_bh(&aarp_lock
);
514 hash
= sa
->s_node
% (AARP_HASH_SIZE
- 1);
515 entry
->next
= proxies
[hash
];
516 proxies
[hash
] = entry
;
518 for (count
= 0; count
< AARP_RETRANSMIT_LIMIT
; count
++) {
519 aarp_send_probe(atif
->dev
, sa
);
522 write_unlock_bh(&aarp_lock
);
524 write_lock_bh(&aarp_lock
);
526 if (entry
->status
& ATIF_PROBE_FAIL
)
530 if (entry
->status
& ATIF_PROBE_FAIL
) {
531 entry
->expires_at
= jiffies
- 1; /* free the entry */
532 retval
= -EADDRINUSE
; /* return network full */
533 } else { /* clear the probing flag */
534 entry
->status
&= ~ATIF_PROBE
;
538 write_unlock_bh(&aarp_lock
);
543 /* Send a DDP frame */
544 int aarp_send_ddp(struct net_device
*dev
, struct sk_buff
*skb
,
545 struct atalk_addr
*sa
, void *hwaddr
)
547 static char ddp_eth_multicast
[ETH_ALEN
] =
548 { 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
550 struct aarp_entry
*a
;
552 skb_reset_network_header(skb
);
554 /* Check for LocalTalk first */
555 if (dev
->type
== ARPHRD_LOCALTLK
) {
556 struct atalk_addr
*at
= atalk_find_dev_addr(dev
);
557 struct ddpehdr
*ddp
= (struct ddpehdr
*)skb
->data
;
563 * IFF: src_net == dest_net == device_net
564 * (zero matches anything)
567 if ((!ddp
->deh_snet
|| at
->s_net
== ddp
->deh_snet
) &&
568 (!ddp
->deh_dnet
|| at
->s_net
== ddp
->deh_dnet
)) {
569 skb_pull(skb
, sizeof(*ddp
) - 4);
572 * The upper two remaining bytes are the port
573 * numbers we just happen to need. Now put the
574 * length in the lower two.
576 *((__be16
*)skb
->data
) = htons(skb
->len
);
580 * Nice and easy. No AARP type protocols occur here so we can
581 * just shovel it out with a 3 byte LLAP header
585 skb
->data
[0] = sa
->s_node
;
586 skb
->data
[1] = at
->s_node
;
592 /* On a PPP link we neither compress nor aarp. */
593 if (dev
->type
== ARPHRD_PPP
) {
594 skb
->protocol
= htons(ETH_P_PPPTALK
);
599 /* Non ELAP we cannot do. */
600 if (dev
->type
!= ARPHRD_ETHER
)
604 skb
->protocol
= htons(ETH_P_ATALK
);
605 hash
= sa
->s_node
% (AARP_HASH_SIZE
- 1);
607 /* Do we have a resolved entry? */
608 if (sa
->s_node
== ATADDR_BCAST
) {
610 ddp_dl
->request(ddp_dl
, skb
, ddp_eth_multicast
);
614 write_lock_bh(&aarp_lock
);
615 a
= __aarp_find_entry(resolved
[hash
], dev
, sa
);
617 if (a
) { /* Return 1 and fill in the address */
618 a
->expires_at
= jiffies
+ (sysctl_aarp_expiry_time
* 10);
619 ddp_dl
->request(ddp_dl
, skb
, a
->hwaddr
);
620 write_unlock_bh(&aarp_lock
);
624 /* Do we have an unresolved entry: This is the less common path */
625 a
= __aarp_find_entry(unresolved
[hash
], dev
, sa
);
626 if (a
) { /* Queue onto the unresolved queue */
627 skb_queue_tail(&a
->packet_queue
, skb
);
631 /* Allocate a new entry */
634 /* Whoops slipped... good job it's an unreliable protocol 8) */
635 write_unlock_bh(&aarp_lock
);
639 /* Set up the queue */
640 skb_queue_tail(&a
->packet_queue
, skb
);
641 a
->expires_at
= jiffies
+ sysctl_aarp_resolve_time
;
643 a
->next
= unresolved
[hash
];
644 a
->target_addr
= *sa
;
646 unresolved
[hash
] = a
;
649 /* Send an initial request for the address */
650 __aarp_send_query(a
);
653 * Switch to fast timer if needed (That is if this is the first
654 * unresolved entry to get added)
657 if (unresolved_count
== 1)
658 mod_timer(&aarp_timer
, jiffies
+ sysctl_aarp_tick_time
);
660 /* Now finally, it is safe to drop the lock. */
662 write_unlock_bh(&aarp_lock
);
664 /* Tell the ddp layer we have taken over for this frame. */
669 skb
->priority
= skb
->sk
->sk_priority
;
676 * An entry in the aarp unresolved queue has become resolved. Send
677 * all the frames queued under it.
679 * Must run under aarp_lock.
681 static void __aarp_resolved(struct aarp_entry
**list
, struct aarp_entry
*a
,
691 /* Move into the resolved list */
692 a
->next
= resolved
[hash
];
695 /* Kick frames off */
696 while ((skb
= skb_dequeue(&a
->packet_queue
)) != NULL
) {
697 a
->expires_at
= jiffies
+
698 sysctl_aarp_expiry_time
* 10;
699 ddp_dl
->request(ddp_dl
, skb
, a
->hwaddr
);
702 list
= &((*list
)->next
);
706 * This is called by the SNAP driver whenever we see an AARP SNAP
707 * frame. We currently only support Ethernet.
709 static int aarp_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
710 struct packet_type
*pt
, struct net_device
*orig_dev
)
712 struct elapaarp
*ea
= aarp_hdr(skb
);
715 struct aarp_entry
*a
;
716 struct atalk_addr sa
, *ma
, da
;
717 struct atalk_iface
*ifa
;
719 if (dev
->nd_net
!= &init_net
)
722 /* We only do Ethernet SNAP AARP. */
723 if (dev
->type
!= ARPHRD_ETHER
)
727 if (!skb_pull(skb
, sizeof(*ea
)))
730 function
= ntohs(ea
->function
);
732 /* Sanity check fields. */
733 if (function
< AARP_REQUEST
|| function
> AARP_PROBE
||
734 ea
->hw_len
!= ETH_ALEN
|| ea
->pa_len
!= AARP_PA_ALEN
||
735 ea
->pa_src_zero
|| ea
->pa_dst_zero
)
739 hash
= ea
->pa_src_node
% (AARP_HASH_SIZE
- 1);
741 /* Build an address. */
742 sa
.s_node
= ea
->pa_src_node
;
743 sa
.s_net
= ea
->pa_src_net
;
745 /* Process the packet. Check for replies of me. */
746 ifa
= atalk_find_dev(dev
);
750 if (ifa
->status
& ATIF_PROBE
&&
751 ifa
->address
.s_node
== ea
->pa_dst_node
&&
752 ifa
->address
.s_net
== ea
->pa_dst_net
) {
753 ifa
->status
|= ATIF_PROBE_FAIL
; /* Fail the probe (in use) */
757 /* Check for replies of proxy AARP entries */
758 da
.s_node
= ea
->pa_dst_node
;
759 da
.s_net
= ea
->pa_dst_net
;
761 write_lock_bh(&aarp_lock
);
762 a
= __aarp_find_entry(proxies
[hash
], dev
, &da
);
764 if (a
&& a
->status
& ATIF_PROBE
) {
765 a
->status
|= ATIF_PROBE_FAIL
;
767 * we do not respond to probe or request packets for
768 * this address while we are probing this address
775 if (!unresolved_count
) /* Speed up */
778 /* Find the entry. */
779 a
= __aarp_find_entry(unresolved
[hash
], dev
, &sa
);
780 if (!a
|| dev
!= a
->dev
)
783 /* We can fill one in - this is good. */
784 memcpy(a
->hwaddr
, ea
->hw_src
, ETH_ALEN
);
785 __aarp_resolved(&unresolved
[hash
], a
, hash
);
786 if (!unresolved_count
)
787 mod_timer(&aarp_timer
,
788 jiffies
+ sysctl_aarp_expiry_time
);
795 * If it is my address set ma to my address and reply.
796 * We can treat probe and request the same. Probe
797 * simply means we shouldn't cache the querying host,
798 * as in a probe they are proposing an address not
801 * Support for proxy-AARP added. We check if the
802 * address is one of our proxies before we toss the
806 sa
.s_node
= ea
->pa_dst_node
;
807 sa
.s_net
= ea
->pa_dst_net
;
809 /* See if we have a matching proxy. */
810 ma
= __aarp_proxy_find(dev
, &sa
);
813 else { /* We need to make a copy of the entry. */
814 da
.s_node
= sa
.s_node
;
819 if (function
== AARP_PROBE
) {
821 * A probe implies someone trying to get an
822 * address. So as a precaution flush any
823 * entries we have for this address.
825 a
= __aarp_find_entry(resolved
[sa
.s_node
%
826 (AARP_HASH_SIZE
- 1)],
830 * Make it expire next tick - that avoids us
831 * getting into a probe/flush/learn/probe/
832 * flush/learn cycle during probing of a slow
833 * to respond host addr.
836 a
->expires_at
= jiffies
- 1;
837 mod_timer(&aarp_timer
, jiffies
+
838 sysctl_aarp_tick_time
);
842 if (sa
.s_node
!= ma
->s_node
)
845 if (sa
.s_net
&& ma
->s_net
&& sa
.s_net
!= ma
->s_net
)
848 sa
.s_node
= ea
->pa_src_node
;
849 sa
.s_net
= ea
->pa_src_net
;
851 /* aarp_my_address has found the address to use for us.
853 aarp_send_reply(dev
, ma
, &sa
, ea
->hw_src
);
858 write_unlock_bh(&aarp_lock
);
866 static struct notifier_block aarp_notifier
= {
867 .notifier_call
= aarp_device_event
,
870 static unsigned char aarp_snap_id
[] = { 0x00, 0x00, 0x00, 0x80, 0xF3 };
872 void __init
aarp_proto_init(void)
874 aarp_dl
= register_snap_client(aarp_snap_id
, aarp_rcv
);
876 printk(KERN_CRIT
"Unable to register AARP with SNAP.\n");
877 setup_timer(&aarp_timer
, aarp_expire_timeout
, 0);
878 aarp_timer
.expires
= jiffies
+ sysctl_aarp_expiry_time
;
879 add_timer(&aarp_timer
);
880 register_netdevice_notifier(&aarp_notifier
);
883 /* Remove the AARP entries associated with a device. */
884 void aarp_device_down(struct net_device
*dev
)
888 write_lock_bh(&aarp_lock
);
890 for (ct
= 0; ct
< AARP_HASH_SIZE
; ct
++) {
891 __aarp_expire_device(&resolved
[ct
], dev
);
892 __aarp_expire_device(&unresolved
[ct
], dev
);
893 __aarp_expire_device(&proxies
[ct
], dev
);
896 write_unlock_bh(&aarp_lock
);
899 #ifdef CONFIG_PROC_FS
900 struct aarp_iter_state
{
902 struct aarp_entry
**table
;
906 * Get the aarp entry that is in the chain described
908 * If pos is set then skip till that index.
909 * pos = 1 is the first entry
911 static struct aarp_entry
*iter_next(struct aarp_iter_state
*iter
, loff_t
*pos
)
913 int ct
= iter
->bucket
;
914 struct aarp_entry
**table
= iter
->table
;
916 struct aarp_entry
*entry
;
919 while(ct
< AARP_HASH_SIZE
) {
920 for (entry
= table
[ct
]; entry
; entry
= entry
->next
) {
921 if (!pos
|| ++off
== *pos
) {
930 if (table
== resolved
) {
935 if (table
== unresolved
) {
943 static void *aarp_seq_start(struct seq_file
*seq
, loff_t
*pos
)
945 struct aarp_iter_state
*iter
= seq
->private;
947 read_lock_bh(&aarp_lock
);
948 iter
->table
= resolved
;
951 return *pos
? iter_next(iter
, pos
) : SEQ_START_TOKEN
;
954 static void *aarp_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
956 struct aarp_entry
*entry
= v
;
957 struct aarp_iter_state
*iter
= seq
->private;
961 /* first line after header */
962 if (v
== SEQ_START_TOKEN
)
963 entry
= iter_next(iter
, NULL
);
965 /* next entry in current bucket */
966 else if (entry
->next
)
969 /* next bucket or table */
972 entry
= iter_next(iter
, NULL
);
977 static void aarp_seq_stop(struct seq_file
*seq
, void *v
)
979 read_unlock_bh(&aarp_lock
);
982 static const char *dt2str(unsigned long ticks
)
986 sprintf(buf
, "%ld.%02ld", ticks
/ HZ
, ((ticks
% HZ
) * 100 ) / HZ
);
991 static int aarp_seq_show(struct seq_file
*seq
, void *v
)
993 struct aarp_iter_state
*iter
= seq
->private;
994 struct aarp_entry
*entry
= v
;
995 unsigned long now
= jiffies
;
996 DECLARE_MAC_BUF(mac
);
998 if (v
== SEQ_START_TOKEN
)
1000 "Address Interface Hardware Address"
1001 " Expires LastSend Retry Status\n");
1003 seq_printf(seq
, "%04X:%02X %-12s",
1004 ntohs(entry
->target_addr
.s_net
),
1005 (unsigned int) entry
->target_addr
.s_node
,
1006 entry
->dev
? entry
->dev
->name
: "????");
1007 seq_printf(seq
, "%s", print_mac(mac
, entry
->hwaddr
));
1008 seq_printf(seq
, " %8s",
1009 dt2str((long)entry
->expires_at
- (long)now
));
1010 if (iter
->table
== unresolved
)
1011 seq_printf(seq
, " %8s %6hu",
1012 dt2str(now
- entry
->last_sent
),
1016 seq_printf(seq
, " %s\n",
1017 (iter
->table
== resolved
) ? "resolved"
1018 : (iter
->table
== unresolved
) ? "unresolved"
1019 : (iter
->table
== proxies
) ? "proxies"
1025 static const struct seq_operations aarp_seq_ops
= {
1026 .start
= aarp_seq_start
,
1027 .next
= aarp_seq_next
,
1028 .stop
= aarp_seq_stop
,
1029 .show
= aarp_seq_show
,
1032 static int aarp_seq_open(struct inode
*inode
, struct file
*file
)
1034 struct seq_file
*seq
;
1036 struct aarp_iter_state
*s
= kmalloc(sizeof(*s
), GFP_KERNEL
);
1041 rc
= seq_open(file
, &aarp_seq_ops
);
1045 seq
= file
->private_data
;
1047 memset(s
, 0, sizeof(*s
));
1055 const struct file_operations atalk_seq_arp_fops
= {
1056 .owner
= THIS_MODULE
,
1057 .open
= aarp_seq_open
,
1059 .llseek
= seq_lseek
,
1060 .release
= seq_release_private
,
1064 /* General module cleanup. Called from cleanup_module() in ddp.c. */
1065 void aarp_cleanup_module(void)
1067 del_timer_sync(&aarp_timer
);
1068 unregister_netdevice_notifier(&aarp_notifier
);
1069 unregister_snap_client(aarp_dl
);