neighbour.h File Reference

#include <asm/atomic.h>
#include <linux/skbuff.h>

Go to the source code of this file.

Classes
struct	neigh_parms
struct	neigh_statistics
struct	neighbour
struct	neigh_ops
struct	pneigh_entry
struct	neigh_table
Defines
#define	NTF_PROXY   0x08
#define	NTF_ROUTER   0x80
#define	NUD_INCOMPLETE   0x01
#define	NUD_REACHABLE   0x02
#define	NUD_STALE   0x04
#define	NUD_DELAY   0x08
#define	NUD_PROBE   0x10
#define	NUD_FAILED   0x20
#define	NUD_NOARP   0x40
#define	NUD_PERMANENT   0x80
#define	NUD_NONE   0x00
#define	NUD_IN_TIMER   (NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE)
#define	NUD_VALID   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)
#define	NUD_CONNECTED   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)
#define	NEIGH_HASHMASK   0x1F
#define	PNEIGH_HASHMASK   0xF
#define	neigh_hold(n)   atomic_inc(&(n)->refcnt)
Functions
void	neigh_table_init (struct neigh_table *tbl)
int	neigh_table_clear (struct neigh_table *tbl)
neighbour *	neigh_lookup (struct neigh_table *tbl, const void *pkey, struct net_device *dev)
neighbour *	neigh_create (struct neigh_table *tbl, const void *pkey, struct net_device *dev)
void	neigh_destroy (struct neighbour *neigh)
int	__neigh_event_send (struct neighbour *neigh, struct sk_buff *skb)
int	neigh_update (struct neighbour *neigh, const u8 *lladdr, u8 new, int override, int arp)
void	neigh_changeaddr (struct neigh_table *tbl, struct net_device *dev)
int	neigh_ifdown (struct neigh_table *tbl, struct net_device *dev)
int	neigh_resolve_output (struct sk_buff *skb)
int	neigh_connected_output (struct sk_buff *skb)
int	neigh_compat_output (struct sk_buff *skb)
neighbour *	neigh_event_ns (struct neigh_table *tbl, u8 *lladdr, void *saddr, struct net_device *dev)
neigh_parms *	neigh_parms_alloc (struct net_device *dev, struct neigh_table *tbl)
void	neigh_parms_release (struct neigh_table *tbl, struct neigh_parms *parms)
unsigned long	neigh_rand_reach_time (unsigned long base)
void	pneigh_enqueue (struct neigh_table *tbl, struct neigh_parms *p, struct sk_buff *skb)
pneigh_entry *	pneigh_lookup (struct neigh_table *tbl, const void *key, struct net_device *dev, int creat)
int	pneigh_delete (struct neigh_table *tbl, const void *key, struct net_device *dev)
int	neigh_dump_info (struct sk_buff *skb, struct netlink_callback *cb)
int	neigh_add (struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
int	neigh_delete (struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
void	neigh_app_ns (struct neighbour *n)
int	neigh_sysctl_register (struct net_device *dev, struct neigh_parms *p, int p_id, int pdev_id, char *p_name)
void	neigh_sysctl_unregister (struct neigh_parms *p)
void	neigh_release (struct neighbour *neigh)
neighbour *	neigh_clone (struct neighbour *neigh)
void	neigh_confirm (struct neighbour *neigh)
int	neigh_is_connected (struct neighbour *neigh)
int	neigh_is_valid (struct neighbour *neigh)
int	neigh_event_send (struct neighbour *neigh, struct sk_buff *skb)
neighbour *	__neigh_lookup (struct neigh_table *tbl, const void *pkey, struct net_device *dev, int creat)
neighbour *	__neigh_lookup_errno (struct neigh_table *tbl, const void *pkey, struct net_device *dev)

---

Define Documentation

#define NEIGH_HASHMASK   0x1F

Definition at line 131 of file neighbour.h. Referenced by arp_hash(), neigh_changeaddr(), neigh_dump_table(), neigh_forced_gc(), and neigh_ifdown().

#define neigh_hold (  n   )     atomic_inc(&(n)->refcnt)

Definition at line 229 of file neighbour.h. Referenced by __neigh_event_send(), neigh_create(), and neigh_lookup().

#define NTF_PROXY   0x08

Definition at line 20 of file neighbour.h. Referenced by neigh_add(), and neigh_delete().

#define NTF_ROUTER   0x80

Definition at line 21 of file neighbour.h.

#define NUD_CONNECTED   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE)

Definition at line 51 of file neighbour.h. Referenced by __neigh_event_send(), neigh_event_send(), neigh_hh_init(), neigh_is_connected(), and neigh_update().

#define NUD_DELAY   0x08

Definition at line 30 of file neighbour.h. Referenced by __neigh_event_send(), neigh_event_send(), and neigh_timer_handler().

#define NUD_FAILED   0x20

Definition at line 32 of file neighbour.h. Referenced by __neigh_event_send(), arp_req_delete(), neigh_delete(), and neigh_timer_handler().

#define NUD_IN_TIMER   (NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE)

Definition at line 49 of file neighbour.h. Referenced by neigh_del_timer(), and neigh_timer_handler().

#define NUD_INCOMPLETE   0x01

Definition at line 27 of file neighbour.h. Referenced by __neigh_event_send(), and neigh_forced_gc().

#define NUD_NOARP   0x40

Definition at line 35 of file neighbour.h. Referenced by arp_constructor(), arp_req_delete(), neigh_ifdown(), neigh_sync(), and neigh_update().

#define NUD_NONE   0x00

Definition at line 37 of file neighbour.h. Referenced by fib_detect_death(), neigh_alloc(), and neigh_ifdown().

#define NUD_PERMANENT   0x80

Definition at line 36 of file neighbour.h. Referenced by arp_req_set(), arp_state_to_flags(), neigh_forced_gc(), neigh_sync(), and neigh_update().

#define NUD_PROBE   0x10

Definition at line 31 of file neighbour.h. Referenced by __neigh_event_send(), neigh_event_send(), and neigh_timer_handler().

#define NUD_REACHABLE   0x02

Definition at line 28 of file neighbour.h. Referenced by arp_process(), fib_detect_death(), neigh_sync(), and neigh_timer_handler().

#define NUD_STALE   0x04

Definition at line 29 of file neighbour.h. Referenced by __neigh_event_send(), arp_process(), arp_req_set(), neigh_event_ns(), neigh_sync(), and neigh_update().

#define NUD_VALID   (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY)

Definition at line 50 of file neighbour.h. Referenced by arp_constructor(), arp_find(), arp_solicit(), arp_state_to_flags(), fib_detect_death(), ip_rt_redirect(), neigh_fill_info(), neigh_ifdown(), neigh_is_valid(), neigh_sync(), neigh_timer_handler(), and neigh_update().

#define PNEIGH_HASHMASK   0xF

Definition at line 132 of file neighbour.h. Referenced by pneigh_delete(), pneigh_ifdown(), and pneigh_lookup().

---

Function Documentation

int __neigh_event_send (  struct neighbour *  neigh, struct sk_buff *  skb )

Definition at line 717 of file neighbour.c. References __skb_queue_tail(), __skb_unlink(), neigh_parms::app_probes, neighbour::arp_queue, neigh_parms::delay_probe_time, kfree_skb(), neighbour::lock, neigh_parms::mcast_probes, neigh_hold, NEIGH_PRINTK2, sk_buff_head::next, NUD_CONNECTED, NUD_DELAY, NUD_FAILED, NUD_INCOMPLETE, NUD_PROBE, NUD_STALE, neighbour::nud_state, neighbour::ops, neighbour::parms, neighbour::probes, neigh_parms::queue_len, neigh_parms::retrans_time, skb_queue_len(), neigh_ops::solicit, neighbour::timer, and neigh_parms::ucast_probes. Referenced by neigh_event_send(). { write_lock_bh(&neigh->lock); if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) { if (!(neigh->nud_state&(NUD_STALE|NUD_INCOMPLETE))) { if (neigh->parms->mcast_probes + neigh->parms->app_probes) { atomic_set(&neigh->probes, neigh->parms->ucast_probes); neigh->nud_state = NUD_INCOMPLETE; neigh_hold(neigh); neigh->timer.expires = jiffies + neigh->parms->retrans_time; add_timer(&neigh->timer); write_unlock_bh(&neigh->lock); neigh->ops->solicit(neigh, skb); atomic_inc(&neigh->probes); write_lock_bh(&neigh->lock); } else { neigh->nud_state = NUD_FAILED; write_unlock_bh(&neigh->lock); if (skb) kfree_skb(skb); return 1; } } if (neigh->nud_state == NUD_INCOMPLETE) { if (skb) { if (skb_queue_len(&neigh->arp_queue) >= neigh->parms->queue_len) { struct sk_buff *buff; buff = neigh->arp_queue.next; __skb_unlink(buff, &neigh->arp_queue); kfree_skb(buff); } __skb_queue_tail(&neigh->arp_queue, skb); } write_unlock_bh(&neigh->lock); return 1; } if (neigh->nud_state == NUD_STALE) { NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); neigh_hold(neigh); neigh->nud_state = NUD_DELAY; neigh->timer.expires = jiffies + neigh->parms->delay_probe_time; add_timer(&neigh->timer); } } write_unlock_bh(&neigh->lock); return 0; }

struct neighbour* __neigh_lookup (  struct neigh_table *  tbl, const void *  pkey, struct net_device *  dev, int  creat )  [inline, static]

Definition at line 256 of file neighbour.h. References neigh_create(), and neigh_lookup(). Referenced by arp_find(), arp_process(), ndisc_get_neigh(), and neigh_event_ns(). { struct neighbour *n = neigh_lookup(tbl, pkey, dev); if (n || !creat) return n; n = neigh_create(tbl, pkey, dev); return IS_ERR(n) ? NULL : n; }

struct neighbour* __neigh_lookup_errno (  struct neigh_table *  tbl, const void *  pkey, struct net_device *  dev )  [inline, static]

Definition at line 268 of file neighbour.h. References neigh_create(), and neigh_lookup(). Referenced by arp_bind_neighbour(), arp_req_set(), and neigh_add(). { struct neighbour *n = neigh_lookup(tbl, pkey, dev); if (n) return n; return neigh_create(tbl, pkey, dev); }

int neigh_add (  struct sk_buff *  skb, struct nlmsghdr *  nlh, void *  arg )

Definition at line 1245 of file neighbour.c. References __neigh_lookup_errno(), dev_get_by_index(), dev_put(), neigh_lookup(), neigh_release(), neigh_tables, neigh_tbl_lock, neigh_update(), neigh_table::next, NLM_F_CREATE, NLM_F_EXCL, NLM_F_REPLACE, NLMSG_DATA, nlmsghdr::nlmsg_flags, NTF_PROXY, and pneigh_lookup(). { struct ndmsg *ndm = NLMSG_DATA(nlh); struct rtattr **nda = arg; struct neigh_table *tbl; struct net_device *dev = NULL; if (ndm->ndm_ifindex) { if ((dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) return -ENODEV; } read_lock(&neigh_tbl_lock); for (tbl=neigh_tables; tbl; tbl = tbl->next) { int err = 0; int override = 1; struct neighbour *n; if (tbl->family != ndm->ndm_family) continue; read_unlock(&neigh_tbl_lock); err = -EINVAL; if (nda[NDA_DST-1] == NULL || nda[NDA_DST-1]->rta_len != RTA_LENGTH(tbl->key_len)) goto out; if (ndm->ndm_flags&NTF_PROXY) { err = -ENOBUFS; if (pneigh_lookup(tbl, RTA_DATA(nda[NDA_DST-1]), dev, 1)) err = 0; goto out; } if (dev == NULL) return -EINVAL; err = -EINVAL; if (nda[NDA_LLADDR-1] != NULL && nda[NDA_LLADDR-1]->rta_len != RTA_LENGTH(dev->addr_len)) goto out; err = 0; n = neigh_lookup(tbl, RTA_DATA(nda[NDA_DST-1]), dev); if (n) { if (nlh->nlmsg_flags&NLM_F_EXCL) err = -EEXIST; override = nlh->nlmsg_flags&NLM_F_REPLACE; } else if (!(nlh->nlmsg_flags&NLM_F_CREATE)) err = -ENOENT; else { n = __neigh_lookup_errno(tbl, RTA_DATA(nda[NDA_DST-1]), dev); if (IS_ERR(n)) { err = PTR_ERR(n); n = NULL; } } if (err == 0) { err = neigh_update(n, nda[NDA_LLADDR-1] ? RTA_DATA(nda[NDA_LLADDR-1]) : NULL, ndm->ndm_state, override, 0); } if (n) neigh_release(n); out: if (dev) dev_put(dev); return err; } read_unlock(&neigh_tbl_lock); if (dev) dev_put(dev); return -EADDRNOTAVAIL; }

void neigh_app_ns (  struct neighbour *  n  )

Referenced by arp_solicit().

void neigh_changeaddr (  struct neigh_table *  tbl, struct net_device *  dev )

Definition at line 173 of file neighbour.c. References neigh_table::hash_buckets, neigh_table::lock, neigh_del_timer(), NEIGH_HASHMASK, neigh_release(), and neighbour::next. { int i; write_lock_bh(&tbl->lock); for (i=0; i <= NEIGH_HASHMASK; i++) { struct neighbour *n, **np; np = &tbl->hash_buckets[i]; while ((n = *np) != NULL) { if (dev && n->dev != dev) { np = &n->next; continue; } *np = n->next; write_lock_bh(&n->lock); n->dead = 1; neigh_del_timer(n); write_unlock_bh(&n->lock); neigh_release(n); } } write_unlock_bh(&tbl->lock); }

struct neighbour* neigh_clone (  struct neighbour *  neigh  )  [inline, static]

Definition at line 222 of file neighbour.h. References neighbour::refcnt. { if (neigh) atomic_inc(&neigh->refcnt); return neigh; }

int neigh_compat_output (  struct sk_buff *  skb  )

Definition at line 951 of file neighbour.c. References __skb_pull(), sk_buff::data, sk_buff::dev, dev_queue_xmit(), sk_buff::len, sk_buff::nh, and sk_buff::protocol. { struct net_device *dev = skb->dev; __skb_pull(skb, skb->nh.raw - skb->data); if (dev->hard_header && dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, skb->len) < 0 && dev->rebuild_header(skb)) return 0; return dev_queue_xmit(skb); }

void neigh_confirm (  struct neighbour *  neigh  )  [inline, static]

Definition at line 231 of file neighbour.h. References neighbour::confirmed. Referenced by dst_confirm(). { if (neigh) neigh->confirmed = jiffies; }

int neigh_connected_output (  struct sk_buff *  skb  )

Definition at line 1006 of file neighbour.c. References __skb_pull(), sk_buff::data, neighbour::dev, sk_buff::dst, kfree_skb(), sk_buff::len, dst_entry::neighbour, sk_buff::nh, and sk_buff::protocol. { int err; struct dst_entry *dst = skb->dst; struct neighbour *neigh = dst->neighbour; struct net_device *dev = neigh->dev; __skb_pull(skb, skb->nh.raw - skb->data); read_lock_bh(&neigh->lock); err = dev->hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, NULL, skb->len); read_unlock_bh(&neigh->lock); if (err >= 0) return neigh->ops->queue_xmit(skb); kfree_skb(skb); return -EINVAL; }

struct neighbour* neigh_create (  struct neigh_table *  tbl, const void *  pkey, struct net_device *  dev )

Definition at line 310 of file neighbour.c. References neigh_table::constructor, neighbour::dead, dev_hold, error, neigh_table::hash, neigh_table::hash_buckets, neigh_table::key_len, neigh_table::lock, neigh_alloc(), neigh_hold, NEIGH_PRINTK2, neigh_release(), and neighbour::next. Referenced by __neigh_lookup(), and __neigh_lookup_errno(). { struct neighbour *n, *n1; u32 hash_val; int key_len = tbl->key_len; int error; n = neigh_alloc(tbl); if (n == NULL) return ERR_PTR(-ENOBUFS); memcpy(n->primary_key, pkey, key_len); n->dev = dev; dev_hold(dev); /* Protocol specific setup. */ if (tbl->constructor && (error = tbl->constructor(n)) < 0) { neigh_release(n); return ERR_PTR(error); } /* Device specific setup. */ if (n->parms->neigh_setup && (error = n->parms->neigh_setup(n)) < 0) { neigh_release(n); return ERR_PTR(error); } n->confirmed = jiffies - (n->parms->base_reachable_time<<1); hash_val = tbl->hash(pkey, dev); write_lock_bh(&tbl->lock); for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) { if (dev == n1->dev && memcmp(n1->primary_key, pkey, key_len) == 0) { neigh_hold(n1); write_unlock_bh(&tbl->lock); neigh_release(n); return n1; } } n->next = tbl->hash_buckets[hash_val]; tbl->hash_buckets[hash_val] = n; n->dead = 0; neigh_hold(n); write_unlock_bh(&tbl->lock); NEIGH_PRINTK2("neigh %p is created.\n", n); return n; }

int neigh_delete (  struct sk_buff *  skb, struct nlmsghdr *  nlh, void *  arg )

Definition at line 1193 of file neighbour.c. References dev_get_by_index(), dev_put(), neigh_lookup(), neigh_release(), neigh_tables, neigh_tbl_lock, neigh_update(), neigh_table::next, NLMSG_DATA, NTF_PROXY, NUD_FAILED, and pneigh_delete(). { struct ndmsg *ndm = NLMSG_DATA(nlh); struct rtattr **nda = arg; struct neigh_table *tbl; struct net_device *dev = NULL; int err = 0; if (ndm->ndm_ifindex) { if ((dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) return -ENODEV; } read_lock(&neigh_tbl_lock); for (tbl=neigh_tables; tbl; tbl = tbl->next) { struct neighbour *n; if (tbl->family != ndm->ndm_family) continue; read_unlock(&neigh_tbl_lock); err = -EINVAL; if (nda[NDA_DST-1] == NULL || nda[NDA_DST-1]->rta_len != RTA_LENGTH(tbl->key_len)) goto out; if (ndm->ndm_flags&NTF_PROXY) { err = pneigh_delete(tbl, RTA_DATA(nda[NDA_DST-1]), dev); goto out; } if (dev == NULL) return -EINVAL; n = neigh_lookup(tbl, RTA_DATA(nda[NDA_DST-1]), dev); if (n) { err = neigh_update(n, NULL, NUD_FAILED, 1, 0); neigh_release(n); } out: if (dev) dev_put(dev); return err; } read_unlock(&neigh_tbl_lock); if (dev) dev_put(dev); return -EADDRNOTAVAIL; }

void neigh_destroy (  struct neighbour *  neigh  )

Definition at line 461 of file neighbour.c. References neighbour::arp_queue, neighbour::dead, neigh_ops::destructor, neighbour::dev, dev_put(), neigh_table::entries, neighbour::hh, hh_cache::hh_next, neigh_table::kmem_cachep, neigh_blackhole(), neigh_del_timer(), neigh_glbl_allocs, NEIGH_PRINTK2, neighbour::ops, skb_queue_purge(), and neighbour::tbl. Referenced by neigh_release(). { struct hh_cache *hh; if (!neigh->dead) { printk("Destroying alive neighbour %p\n", neigh); dump_stack(); return; } if (neigh_del_timer(neigh)) printk("Impossible event.\n"); while ((hh = neigh->hh) != NULL) { neigh->hh = hh->hh_next; hh->hh_next = NULL; write_lock_bh(&hh->hh_lock); hh->hh_output = neigh_blackhole; write_unlock_bh(&hh->hh_lock); if (atomic_dec_and_test(&hh->hh_refcnt)) kfree(hh); } if (neigh->ops && neigh->ops->destructor) (neigh->ops->destructor)(neigh); skb_queue_purge(&neigh->arp_queue); dev_put(neigh->dev); NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh); neigh_glbl_allocs--; neigh->tbl->entries--; kmem_cache_free(neigh->tbl->kmem_cachep, neigh); }

int neigh_dump_info (  struct sk_buff *  skb, struct netlink_callback *  cb )

Definition at line 1392 of file neighbour.c. References netlink_callback::args, sk_buff::len, neigh_dump_table(), neigh_tables, neigh_tbl_lock, neigh_table::next, netlink_callback::nlh, and NLMSG_DATA. { int t; int s_t; struct neigh_table *tbl; int family = ((struct rtgenmsg*)NLMSG_DATA(cb->nlh))->rtgen_family; s_t = cb->args[0]; read_lock(&neigh_tbl_lock); for (tbl=neigh_tables, t=0; tbl; tbl = tbl->next, t++) { if (t < s_t) continue; if (family && tbl->family != family) continue; if (t > s_t) memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0])); if (neigh_dump_table(tbl, skb, cb) < 0) break; } read_unlock(&neigh_tbl_lock); cb->args[0] = t; return skb->len; }

struct neighbour* neigh_event_ns (  struct neigh_table *  tbl, u8 *  lladdr, void *  saddr, struct net_device *  dev )

Definition at line 900 of file neighbour.c. References __neigh_lookup(), net_device::addr_len, neigh_update(), and NUD_STALE. Referenced by arp_process(). { struct neighbour *neigh; neigh = __neigh_lookup(tbl, saddr, dev, lladdr || !dev->addr_len); if (neigh) neigh_update(neigh, lladdr, NUD_STALE, 1, 1); return neigh; }

int neigh_event_send (  struct neighbour *  neigh, struct sk_buff *  skb )  [inline, static]

Definition at line 247 of file neighbour.h. References __neigh_event_send(), NUD_CONNECTED, NUD_DELAY, NUD_PROBE, neighbour::nud_state, and neighbour::used. Referenced by arp_find(), ip_rt_redirect(), and neigh_resolve_output(). { neigh->used = jiffies; if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) return __neigh_event_send(neigh, skb); return 0; }

int neigh_ifdown (  struct neigh_table *  tbl, struct net_device *  dev )

Definition at line 200 of file neighbour.c. References neigh_table::hash_buckets, neigh_table::lock, neigh_blackhole(), neigh_del_timer(), NEIGH_HASHMASK, NEIGH_PRINTK2, neigh_release(), neighbour::next, NUD_NOARP, NUD_NONE, NUD_VALID, neigh_table::parms, pneigh_ifdown(), pneigh_queue_purge(), neigh_table::proxy_queue, neigh_table::proxy_timer, and skb_queue_purge(). Referenced by arp_ifdown(), and neigh_table_clear(). { int i; write_lock_bh(&tbl->lock); for (i=0; i<=NEIGH_HASHMASK; i++) { struct neighbour *n, **np; np = &tbl->hash_buckets[i]; while ((n = *np) != NULL) { if (dev && n->dev != dev) { np = &n->next; continue; } *np = n->next; write_lock(&n->lock); neigh_del_timer(n); n->dead = 1; if (atomic_read(&n->refcnt) != 1) { /* The most unpleasant situation. We must destroy neighbour entry, but someone still uses it. The destroy will be delayed until the last user releases us, but we must kill timers etc. and move it to safe state. */ n->parms = &tbl->parms; skb_queue_purge(&n->arp_queue); n->output = neigh_blackhole; if (n->nud_state&NUD_VALID) n->nud_state = NUD_NOARP; else n->nud_state = NUD_NONE; NEIGH_PRINTK2("neigh %p is stray.\n", n); } write_unlock(&n->lock); neigh_release(n); } } pneigh_ifdown(tbl, dev); write_unlock_bh(&tbl->lock); del_timer_sync(&tbl->proxy_timer); pneigh_queue_purge(&tbl->proxy_queue); return 0; }

int neigh_is_connected (  struct neighbour *  neigh  )  [inline, static]

Definition at line 237 of file neighbour.h. References NUD_CONNECTED, and neighbour::nud_state. { return neigh->nud_state&NUD_CONNECTED; }

int neigh_is_valid (  struct neighbour *  neigh  )  [inline, static]

Definition at line 242 of file neighbour.h. References neighbour::nud_state, and NUD_VALID. { return neigh->nud_state&NUD_VALID; }

struct neighbour* neigh_lookup (  struct neigh_table *  tbl, const void *  pkey, struct net_device *  dev )

Definition at line 289 of file neighbour.c. References neigh_table::hash, neigh_table::hash_buckets, neigh_table::key_len, neigh_table::lock, neigh_hold, and neighbour::next. Referenced by __neigh_lookup(), __neigh_lookup_errno(), arp_req_delete(), arp_req_get(), fib_detect_death(), neigh_add(), and neigh_delete(). { struct neighbour *n; u32 hash_val; int key_len = tbl->key_len; hash_val = tbl->hash(pkey, dev); read_lock_bh(&tbl->lock); for (n = tbl->hash_buckets[hash_val]; n; n = n->next) { if (dev == n->dev && memcmp(n->primary_key, pkey, key_len) == 0) { neigh_hold(n); break; } } read_unlock_bh(&tbl->lock); return n; }

struct neigh_parms* neigh_parms_alloc (  struct net_device *  dev, struct neigh_table *  tbl )

Definition at line 1086 of file neighbour.c. References neigh_table::lock, neigh_rand_reach_time(), net_device::neigh_setup, neigh_parms::next, and neigh_table::parms. Referenced by inetdev_init(). { struct neigh_parms *p; p = kmalloc(sizeof(*p), GFP_KERNEL); if (p) { memcpy(p, &tbl->parms, sizeof(*p)); p->tbl = tbl; p->reachable_time = neigh_rand_reach_time(p->base_reachable_time); if (dev && dev->neigh_setup) { if (dev->neigh_setup(dev, p)) { kfree(p); return NULL; } } p->sysctl_table = NULL; write_lock_bh(&tbl->lock); p->next = tbl->parms.next; tbl->parms.next = p; write_unlock_bh(&tbl->lock); } return p; }

void neigh_parms_release (  struct neigh_table *  tbl, struct neigh_parms *  parms )

Definition at line 1109 of file neighbour.c. References neigh_table::lock, NEIGH_PRINTK1, neigh_sysctl_unregister(), neigh_parms::next, and neigh_table::parms. Referenced by inetdev_destroy(). { struct neigh_parms **p; if (parms == NULL || parms == &tbl->parms) return; write_lock_bh(&tbl->lock); for (p = &tbl->parms.next; *p; p = &(*p)->next) { if (*p == parms) { *p = parms->next; write_unlock_bh(&tbl->lock); #ifdef CONFIG_SYSCTL neigh_sysctl_unregister(parms); #endif kfree(parms); return; } } write_unlock_bh(&tbl->lock); NEIGH_PRINTK1("neigh_parms_release: not found\n"); }

unsigned long neigh_rand_reach_time (  unsigned long  base  )

Definition at line 103 of file neighbour.c. References net_random(). Referenced by neigh_parms_alloc(), and neigh_table_init(). { return (net_random() % base) + (base>>1); }

void neigh_release (  struct neighbour *  neigh  )  [inline, static]

Definition at line 216 of file neighbour.h. References neigh_destroy(), and neighbour::refcnt. Referenced by arp_find(), arp_process(), arp_req_delete(), arp_req_get(), arp_req_set(), dst_destroy(), fib_detect_death(), neigh_add(), neigh_changeaddr(), neigh_create(), neigh_del_timer(), neigh_delete(), neigh_forced_gc(), neigh_ifdown(), and neigh_timer_handler(). { if (atomic_dec_and_test(&neigh->refcnt)) neigh_destroy(neigh); }

int neigh_resolve_output (  struct sk_buff *  skb  )

Definition at line 967 of file neighbour.c. References __skb_pull(), sk_buff::data, sk_buff::dst, kfree_skb(), sk_buff::len, neigh_event_send(), neigh_hh_init(), NEIGH_PRINTK1, sk_buff::nh, and sk_buff::protocol. { struct dst_entry *dst = skb->dst; struct neighbour *neigh; if (!dst || !(neigh = dst->neighbour)) goto discard; __skb_pull(skb, skb->nh.raw - skb->data); if (neigh_event_send(neigh, skb) == 0) { int err; struct net_device *dev = neigh->dev; if (dev->hard_header_cache && dst->hh == NULL) { write_lock_bh(&neigh->lock); if (dst->hh == NULL) neigh_hh_init(neigh, dst, dst->ops->protocol); err = dev->hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, NULL, skb->len); write_unlock_bh(&neigh->lock); } else { read_lock_bh(&neigh->lock); err = dev->hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, NULL, skb->len); read_unlock_bh(&neigh->lock); } if (err >= 0) return neigh->ops->queue_xmit(skb); kfree_skb(skb); return -EINVAL; } return 0; discard: NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n", dst, dst ? dst->neighbour : NULL); kfree_skb(skb); return -EINVAL; }

int neigh_sysctl_register (  struct net_device *  dev, struct neigh_parms *  p, int  p_id, int  pdev_id, char *  p_name )

Referenced by arp_init(), and inetdev_init().

void neigh_sysctl_unregister (  struct neigh_parms *  p  )

Referenced by neigh_parms_release(), and neigh_table_clear().

int neigh_table_clear (  struct neigh_table *  tbl  )

Definition at line 1167 of file neighbour.c. References neigh_table::entries, neigh_table::gc_task, neigh_table::gc_timer, neigh_ifdown(), neigh_sysctl_unregister(), neigh_tables, neigh_tbl_lock, neigh_table::next, neigh_table::parms, pneigh_queue_purge(), neigh_table::proxy_queue, and neigh_table::proxy_timer. { struct neigh_table **tp; /* It is not clean... Fix it to unload IPv6 module safely */ del_timer_sync(&tbl->gc_timer); tasklet_kill(&tbl->gc_task); del_timer_sync(&tbl->proxy_timer); pneigh_queue_purge(&tbl->proxy_queue); neigh_ifdown(tbl, NULL); if (tbl->entries) printk(KERN_CRIT "neighbour leakage\n"); write_lock(&neigh_tbl_lock); for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { if (*tp == tbl) { *tp = tbl->next; break; } } write_unlock(&neigh_tbl_lock); #ifdef CONFIG_SYSCTL neigh_sysctl_unregister(&tbl->parms); #endif return 0; }

void neigh_table_init (  struct neigh_table *  tbl  )

Definition at line 1132 of file neighbour.c. References neigh_parms::base_reachable_time, neigh_table::entry_size, neigh_table::gc_task, neigh_table::id, neigh_table::kmem_cachep, neigh_periodic_timer, neigh_proxy_process(), neigh_rand_reach_time(), neigh_tables, neigh_tbl_lock, neigh_table::parms, neigh_parms::reachable_time, and skb_queue_head_init(). Referenced by arp_init(). { unsigned long now = jiffies; tbl->parms.reachable_time = neigh_rand_reach_time(tbl->parms.base_reachable_time); if (tbl->kmem_cachep == NULL) tbl->kmem_cachep = kmem_cache_create(tbl->id, (tbl->entry_size+15)&~15, 0, SLAB_HWCACHE_ALIGN, NULL, NULL); #ifdef CONFIG_SMP tasklet_init(&tbl->gc_task, SMP_TIMER_NAME(neigh_periodic_timer), (unsigned long)tbl); #endif init_timer(&tbl->gc_timer); tbl->lock = RW_LOCK_UNLOCKED; tbl->gc_timer.data = (unsigned long)tbl; tbl->gc_timer.function = neigh_periodic_timer; tbl->gc_timer.expires = now + tbl->gc_interval + tbl->parms.reachable_time; add_timer(&tbl->gc_timer); init_timer(&tbl->proxy_timer); tbl->proxy_timer.data = (unsigned long)tbl; tbl->proxy_timer.function = neigh_proxy_process; skb_queue_head_init(&tbl->proxy_queue); tbl->last_flush = now; tbl->last_rand = now + tbl->parms.reachable_time*20; write_lock(&neigh_tbl_lock); tbl->next = neigh_tables; neigh_tables = tbl; write_unlock(&neigh_tbl_lock); }

int neigh_update (  struct neighbour *  neigh, const u8 *  lladdr, u8  new, int  override, int  arp )

Definition at line 792 of file neighbour.c. References __skb_dequeue(), neigh_parms::app_probes, neighbour::arp_queue, neigh_parms::base_reachable_time, neighbour::confirmed, neighbour::dev, neighbour::ha, neighbour::lock, neigh_connect(), neigh_del_timer(), neigh_suspect(), neigh_sync(), neigh_update_hhs(), NUD_CONNECTED, NUD_NOARP, NUD_PERMANENT, NUD_STALE, neighbour::nud_state, NUD_VALID, neighbour::parms, skb_queue_purge(), and neighbour::updated. Referenced by arp_process(), arp_req_delete(), arp_req_set(), neigh_add(), neigh_delete(), and neigh_event_ns(). { u8 old; int err; int notify = 0; struct net_device *dev = neigh->dev; write_lock_bh(&neigh->lock); old = neigh->nud_state; err = -EPERM; if (arp && (old&(NUD_NOARP|NUD_PERMANENT))) goto out; if (!(new&NUD_VALID)) { neigh_del_timer(neigh); if (old&NUD_CONNECTED) neigh_suspect(neigh); neigh->nud_state = new; err = 0; notify = old&NUD_VALID; goto out; } /* Compare new lladdr with cached one */ if (dev->addr_len == 0) { /* First case: device needs no address. */ lladdr = neigh->ha; } else if (lladdr) { /* The second case: if something is already cached and a new address is proposed: - compare new & old - if they are different, check override flag */ if (old&NUD_VALID) { if (memcmp(lladdr, neigh->ha, dev->addr_len) == 0) lladdr = neigh->ha; else if (!override) goto out; } } else { /* No address is supplied; if we know something, use it, otherwise discard the request. */ err = -EINVAL; if (!(old&NUD_VALID)) goto out; lladdr = neigh->ha; } neigh_sync(neigh); old = neigh->nud_state; if (new&NUD_CONNECTED) neigh->confirmed = jiffies; neigh->updated = jiffies; /* If entry was valid and address is not changed, do not change entry state, if new one is STALE. */ err = 0; if (old&NUD_VALID) { if (lladdr == neigh->ha) if (new == old || (new == NUD_STALE && (old&NUD_CONNECTED))) goto out; } neigh_del_timer(neigh); neigh->nud_state = new; if (lladdr != neigh->ha) { memcpy(&neigh->ha, lladdr, dev->addr_len); neigh_update_hhs(neigh); if (!(new&NUD_CONNECTED)) neigh->confirmed = jiffies - (neigh->parms->base_reachable_time<<1); #ifdef CONFIG_ARPD notify = 1; #endif } if (new == old) goto out; if (new&NUD_CONNECTED) neigh_connect(neigh); else neigh_suspect(neigh); if (!(old&NUD_VALID)) { struct sk_buff *skb; /* Again: avoid dead loop if something went wrong */ while (neigh->nud_state&NUD_VALID && (skb=__skb_dequeue(&neigh->arp_queue)) != NULL) { struct neighbour *n1 = neigh; write_unlock_bh(&neigh->lock); /* On shaper/eql skb->dst->neighbour != neigh :( */ if (skb->dst && skb->dst->neighbour) n1 = skb->dst->neighbour; n1->output(skb); write_lock_bh(&neigh->lock); } skb_queue_purge(&neigh->arp_queue); } out: write_unlock_bh(&neigh->lock); #ifdef CONFIG_ARPD if (notify && neigh->parms->app_probes) neigh_app_notify(neigh); #endif return err; }

int pneigh_delete (  struct neigh_table *  tbl, const void *  key, struct net_device *  dev )

Definition at line 409 of file neighbour.c. References neigh_table::key_len, neigh_table::lock, pneigh_entry::next, neigh_table::pdestructor, neigh_table::phash_buckets, and PNEIGH_HASHMASK. Referenced by arp_req_delete(), and neigh_delete(). { struct pneigh_entry *n, **np; u32 hash_val; int key_len = tbl->key_len; hash_val = *(u32*)(pkey + key_len - 4); hash_val ^= (hash_val>>16); hash_val ^= hash_val>>8; hash_val ^= hash_val>>4; hash_val &= PNEIGH_HASHMASK; for (np = &tbl->phash_buckets[hash_val]; (n=*np) != NULL; np = &n->next) { if (memcmp(n->key, pkey, key_len) == 0 && n->dev == dev) { write_lock_bh(&tbl->lock); *np = n->next; write_unlock_bh(&tbl->lock); if (tbl->pdestructor) tbl->pdestructor(n); kfree(n); return 0; } } return -ENOENT; }

void pneigh_enqueue (  struct neigh_table *  tbl, struct neigh_parms *  p, struct sk_buff *  skb )

Definition at line 1058 of file neighbour.c. References __skb_queue_tail(), sk_buff::dev, dev_hold, sk_buff::dst, dst_release(), kfree_skb(), sk_buff_head::lock, net_random(), neigh_parms::proxy_delay, neigh_parms::proxy_qlen, neigh_table::proxy_queue, neigh_table::proxy_timer, sk_buff_head::qlen, and sk_buff::stamp. Referenced by arp_process(). { unsigned long now = jiffies; long sched_next = net_random()%p->proxy_delay; if (tbl->proxy_queue.qlen > p->proxy_qlen) { kfree_skb(skb); return; } skb->stamp.tv_sec = 0; skb->stamp.tv_usec = now + sched_next; spin_lock(&tbl->proxy_queue.lock); if (del_timer(&tbl->proxy_timer)) { long tval = tbl->proxy_timer.expires - now; if (tval < sched_next) sched_next = tval; } dst_release(skb->dst); skb->dst = NULL; dev_hold(skb->dev); __skb_queue_tail(&tbl->proxy_queue, skb); mod_timer(&tbl->proxy_timer, now + sched_next); spin_unlock(&tbl->proxy_queue.lock); }

struct pneigh_entry* pneigh_lookup (  struct neigh_table *  tbl, const void *  key, struct net_device *  dev, int  creat )

Definition at line 363 of file neighbour.c. References neigh_table::key_len, neigh_table::lock, pneigh_entry::next, neigh_table::pconstructor, neigh_table::phash_buckets, and PNEIGH_HASHMASK. Referenced by arp_process(), arp_req_set(), and neigh_add(). { struct pneigh_entry *n; u32 hash_val; int key_len = tbl->key_len; hash_val = *(u32*)(pkey + key_len - 4); hash_val ^= (hash_val>>16); hash_val ^= hash_val>>8; hash_val ^= hash_val>>4; hash_val &= PNEIGH_HASHMASK; read_lock_bh(&tbl->lock); for (n = tbl->phash_buckets[hash_val]; n; n = n->next) { if (memcmp(n->key, pkey, key_len) == 0 && (n->dev == dev || !n->dev)) { read_unlock_bh(&tbl->lock); return n; } } read_unlock_bh(&tbl->lock); if (!creat) return NULL; n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); if (n == NULL) return NULL; memcpy(n->key, pkey, key_len); n->dev = dev; if (tbl->pconstructor && tbl->pconstructor(n)) { kfree(n); return NULL; } write_lock_bh(&tbl->lock); n->next = tbl->phash_buckets[hash_val]; tbl->phash_buckets[hash_val] = n; write_unlock_bh(&tbl->lock); return n; }

---