/**********************************************************************
*
* Set/get/delete/rehash items (internal versions)
*
**********************************************************************/
static struct pppox_sock *__get_item(unsigned long sid, unsigned char *addr)
{
int hash = hash_item(sid, addr);
struct pppox_sock *ret;
ret = item_hash_table[hash];
while (ret && !cmp_addr(&ret->pppoe_pa, sid, addr))
ret = ret->next;
return ret;
}
static struct pppox_sock *__get_item(struct pppoe_net *pn, __be16 sid,
unsigned char *addr, int ifindex)
{
int hash = hash_item(sid, addr);
struct pppox_sock *ret;
ret = pn->hash_table[hash];
while (ret) {
if (cmp_addr(&ret->pppoe_pa, sid, addr) &&
ret->pppoe_ifindex == ifindex)
return ret;
ret = ret->next;
}
return NULL;
}
bool
SelfDrainingQueue::enqueue( ServiceData* data, bool allow_dups )
{
if( ! allow_dups ) {
SelfDrainingHashItem hash_item(data);
if( m_hash.insert(hash_item,true) == -1 ) {
dprintf( D_FULLDEBUG, "SelfDrainingQueue::enqueue() "
"refusing duplicate data\n" );
return false;
}
}
queue.enqueue(data);
dprintf( D_FULLDEBUG,
"Added data to SelfDrainingQueue %s, now has %d element(s)\n",
name, queue.Length() );
registerTimer();
return true;
}
static int __set_item(struct pppox_sock *po)
{
int hash = hash_item(po->pppoe_pa.sid, po->pppoe_pa.remote);
struct pppox_sock *ret;
ret = item_hash_table[hash];
while (ret) {
if (cmp_2_addr(&ret->pppoe_pa, &po->pppoe_pa) && ret->pppoe_ifindex == po->pppoe_ifindex)
return -EALREADY;
ret = ret->next;
}
po->next = item_hash_table[hash];
item_hash_table[hash] = po;
return 0;
}
static struct pppox_sock *__delete_item(unsigned long sid, char *addr)
{
int hash = hash_item(sid, addr);
struct pppox_sock *ret, **src;
ret = item_hash_table[hash];
src = &item_hash_table[hash];
while (ret) {
if (cmp_addr(&ret->pppoe_pa, sid, addr)) {
*src = ret->next;
break;
}
src = &ret->next;
ret = ret->next;
}
return ret;
}
static int __set_item(struct pppox_opt *po)
{
int hash = hash_item(po->pppoe_pa.sid, po->pppoe_pa.remote);
struct pppox_opt *ret;
ret = item_hash_table[hash];
while (ret) {
if (cmp_2_addr(&ret->pppoe_pa, &po->pppoe_pa))
return -EALREADY;
ret = ret->next;
}
if (!ret) {
po->next = item_hash_table[hash];
item_hash_table[hash] = po;
}
return 0;
}
void
SelfDrainingQueue::timerHandler( void )
{
dprintf( D_FULLDEBUG,
"Inside SelfDrainingQueue::timerHandler() for %s\n", name );
if( queue.IsEmpty() ) {
dprintf( D_FULLDEBUG, "SelfDrainingQueue %s is empty, "
"timerHandler() has nothing to do\n", name );
cancelTimer();
return;
}
int count;
for( count=0; count<m_count_per_interval && !queue.IsEmpty(); count++ ) {
ServiceData* d = NULL;
queue.dequeue(d);
SelfDrainingHashItem hash_item(d);
m_hash.remove(hash_item);
if( handler_fn ) {
handler_fn( d );
} else if( handlercpp_fn && service_ptr ) {
(service_ptr->*handlercpp_fn)( d );
}
}
if( queue.IsEmpty() ) {
dprintf( D_FULLDEBUG,
"SelfDrainingQueue %s is empty, not resetting timer\n",
name );
cancelTimer();
} else {
// if there's anything left in the queue, reset our timer
dprintf( D_FULLDEBUG,
"SelfDrainingQueue %s still has %d element(s), "
"resetting timer\n", name, queue.Length() );
resetTimer();
}
}
static struct pppox_sock *__delete_item(struct pppoe_net *pn, __be16 sid,
char *addr, int ifindex)
{
int hash = hash_item(sid, addr);
struct pppox_sock *ret, **src;
ret = pn->hash_table[hash];
src = &pn->hash_table[hash];
while (ret) {
if (cmp_addr(&ret->pppoe_pa, sid, addr) &&
ret->pppoe_ifindex == ifindex) {
*src = ret->next;
break;
}
src = &ret->next;
ret = ret->next;
}
return ret;
}
