// SPDX-License-Identifier: GPL-2.0-or-later /* * AARP: An implementation of the AppleTalk AARP protocol for * Ethernet 'ELAP'. * * Alan Cox <[email protected]> * * This doesn't fit cleanly with the IP arp. Potentially we can use * the generic neighbour discovery code to clean this up. * * FIXME: * We ought to handle the retransmits with a single list and a * separate fast timer for when it is needed. * Use neighbour discovery code. * Token Ring Support. * * References: * Inside AppleTalk (2nd Ed). * Fixes: * Jaume Grau - flush caches on AARP_PROBE * Rob Newberry - Added proxy AARP and AARP proc fs, * moved probing from DDP module. * Arnaldo C. Melo - don't mangle rx packets */ #include <linux/if_arp.h> #include <linux/slab.h> #include <net/sock.h> #include <net/datalink.h> #include <net/psnap.h> #include <linux/atalk.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/export.h> #include <linux/etherdevice.h> int sysctl_aarp_expiry_time = …; int sysctl_aarp_tick_time = …; int sysctl_aarp_retransmit_limit = …; int sysctl_aarp_resolve_time = …; /* Lists of aarp entries */ /** * struct aarp_entry - AARP entry * @last_sent: Last time we xmitted the aarp request * @packet_queue: Queue of frames wait for resolution * @status: Used for proxy AARP * @expires_at: Entry expiry time * @target_addr: DDP Address * @dev: Device to use * @hwaddr: Physical i/f address of target/router * @xmit_count: When this hits 10 we give up * @next: Next entry in chain */ struct aarp_entry { … }; /* Hashed list of resolved, unresolved and proxy entries */ static struct aarp_entry *resolved[AARP_HASH_SIZE]; static struct aarp_entry *unresolved[AARP_HASH_SIZE]; static struct aarp_entry *proxies[AARP_HASH_SIZE]; static int unresolved_count; /* One lock protects it all. */ static DEFINE_RWLOCK(aarp_lock); /* Used to walk the list and purge/kick entries. */ static struct timer_list aarp_timer; /* * Delete an aarp queue * * Must run under aarp_lock. */ static void __aarp_expire(struct aarp_entry *a) { … } /* * Send an aarp queue entry request * * Must run under aarp_lock. */ static void __aarp_send_query(struct aarp_entry *a) { … } /* This runs under aarp_lock and in softint context, so only atomic memory * allocations can be used. */ static void aarp_send_reply(struct net_device *dev, struct atalk_addr *us, struct atalk_addr *them, unsigned char *sha) { … } /* * Send probe frames. Called from aarp_probe_network and * aarp_proxy_probe_network. */ static void aarp_send_probe(struct net_device *dev, struct atalk_addr *us) { … } /* * Handle an aarp timer expire * * Must run under the aarp_lock. */ static void __aarp_expire_timer(struct aarp_entry **n) { … } /* * Kick all pending requests 5 times a second. * * Must run under the aarp_lock. */ static void __aarp_kick(struct aarp_entry **n) { … } /* * A device has gone down. Take all entries referring to the device * and remove them. * * Must run under the aarp_lock. */ static void __aarp_expire_device(struct aarp_entry **n, struct net_device *dev) { … } /* Handle the timer event */ static void aarp_expire_timeout(struct timer_list *unused) { … } /* Network device notifier chain handler. */ static int aarp_device_event(struct notifier_block *this, unsigned long event, void *ptr) { … } /* Expire all entries in a hash chain */ static void __aarp_expire_all(struct aarp_entry **n) { … } /* Cleanup all hash chains -- module unloading */ static void aarp_purge(void) { … } /* * Create a new aarp entry. This must use GFP_ATOMIC because it * runs while holding spinlocks. */ static struct aarp_entry *aarp_alloc(void) { … } /* * Find an entry. We might return an expired but not yet purged entry. We * don't care as it will do no harm. * * This must run under the aarp_lock. */ static struct aarp_entry *__aarp_find_entry(struct aarp_entry *list, struct net_device *dev, struct atalk_addr *sat) { … } /* Called from the DDP code, and thus must be exported. */ void aarp_proxy_remove(struct net_device *dev, struct atalk_addr *sa) { … } /* This must run under aarp_lock. */ static struct atalk_addr *__aarp_proxy_find(struct net_device *dev, struct atalk_addr *sa) { … } /* * Probe a Phase 1 device or a device that requires its Net:Node to * be set via an ioctl. */ static void aarp_send_probe_phase1(struct atalk_iface *iface) { … } void aarp_probe_network(struct atalk_iface *atif) { … } int aarp_proxy_probe_network(struct atalk_iface *atif, struct atalk_addr *sa) { … } /* Send a DDP frame */ int aarp_send_ddp(struct net_device *dev, struct sk_buff *skb, struct atalk_addr *sa, void *hwaddr) { … } EXPORT_SYMBOL(…); /* * An entry in the aarp unresolved queue has become resolved. Send * all the frames queued under it. * * Must run under aarp_lock. */ static void __aarp_resolved(struct aarp_entry **list, struct aarp_entry *a, int hash) { … } /* * This is called by the SNAP driver whenever we see an AARP SNAP * frame. We currently only support Ethernet. */ static int aarp_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev) { … } static struct notifier_block aarp_notifier = …; static unsigned char aarp_snap_id[] = …; int __init aarp_proto_init(void) { … } /* Remove the AARP entries associated with a device. */ void aarp_device_down(struct net_device *dev) { … } #ifdef CONFIG_PROC_FS /* * Get the aarp entry that is in the chain described * by the iterator. * If pos is set then skip till that index. * pos = 1 is the first entry */ static struct aarp_entry *iter_next(struct aarp_iter_state *iter, loff_t *pos) { … } static void *aarp_seq_start(struct seq_file *seq, loff_t *pos) __acquires(aarp_lock) { … } static void *aarp_seq_next(struct seq_file *seq, void *v, loff_t *pos) { … } static void aarp_seq_stop(struct seq_file *seq, void *v) __releases(aarp_lock) { … } static const char *dt2str(unsigned long ticks) { … } static int aarp_seq_show(struct seq_file *seq, void *v) { … } const struct seq_operations aarp_seq_ops = …; #endif /* General module cleanup. Called from cleanup_module() in ddp.c. */ void aarp_cleanup_module(void) { … }
Codebase Browser
linux