#include "stdinc.h"
#include "ircd_defs.h"
-#include "tools.h"
#include "s_conf.h"
#include "channel.h"
#include "client.h"
#include "ircd.h"
#include "numeric.h"
#include "send.h"
-#include "memory.h"
#include "msg.h"
#include "cache.h"
#include "s_newconf.h"
-dlink_list *clientTable;
-dlink_list *channelTable;
-dlink_list *idTable;
-dlink_list *resvTable;
-dlink_list *hostTable;
+rb_dlink_list *clientTable;
+rb_dlink_list *channelTable;
+rb_dlink_list *idTable;
+rb_dlink_list *resvTable;
+rb_dlink_list *hostTable;
/*
* look in whowas.c for the missing ...[WW_MAX]; entry
void
init_hash(void)
{
- clientTable = MyMalloc(sizeof(dlink_list) * U_MAX);
- idTable = MyMalloc(sizeof(dlink_list) * U_MAX);
- channelTable = MyMalloc(sizeof(dlink_list) * CH_MAX);
- hostTable = MyMalloc(sizeof(dlink_list) * HOST_MAX);
- resvTable = MyMalloc(sizeof(dlink_list) * R_MAX);
+ clientTable = rb_malloc(sizeof(rb_dlink_list) * U_MAX);
+ idTable = rb_malloc(sizeof(rb_dlink_list) * U_MAX);
+ channelTable = rb_malloc(sizeof(rb_dlink_list) * CH_MAX);
+ hostTable = rb_malloc(sizeof(rb_dlink_list) * HOST_MAX);
+ resvTable = rb_malloc(sizeof(rb_dlink_list) * R_MAX);
}
#ifndef RICER_HASHING
return;
hashv = hash_id(name);
- dlinkAddAlloc(client_p, &idTable[hashv]);
+ rb_dlinkAddAlloc(client_p, &idTable[hashv]);
}
/* add_to_client_hash()
return;
hashv = hash_nick(name);
- dlinkAddAlloc(client_p, &clientTable[hashv]);
+ rb_dlinkAddAlloc(client_p, &clientTable[hashv]);
}
/* add_to_hostname_hash()
return;
hashv = hash_hostname(hostname);
- dlinkAddAlloc(client_p, &hostTable[hashv]);
+ rb_dlinkAddAlloc(client_p, &hostTable[hashv]);
}
/* add_to_resv_hash()
return;
hashv = hash_resv(name);
- dlinkAddAlloc(aconf, &resvTable[hashv]);
+ rb_dlinkAddAlloc(aconf, &resvTable[hashv]);
}
/* del_from_id_hash()
return;
hashv = hash_id(id);
- dlinkFindDestroy(client_p, &idTable[hashv]);
+ rb_dlinkFindDestroy(client_p, &idTable[hashv]);
}
/* del_from_client_hash()
return;
hashv = hash_nick(name);
- dlinkFindDestroy(client_p, &clientTable[hashv]);
+ rb_dlinkFindDestroy(client_p, &clientTable[hashv]);
}
/* del_from_channel_hash()
return;
hashv = hash_channel(name);
- dlinkFindDestroy(chptr, &channelTable[hashv]);
+ rb_dlinkFindDestroy(chptr, &channelTable[hashv]);
}
/* del_from_hostname_hash()
hashv = hash_hostname(hostname);
- dlinkFindDestroy(client_p, &hostTable[hashv]);
+ rb_dlinkFindDestroy(client_p, &hostTable[hashv]);
}
/* del_from_resv_hash()
hashv = hash_resv(name);
- dlinkFindDestroy(aconf, &resvTable[hashv]);
+ rb_dlinkFindDestroy(aconf, &resvTable[hashv]);
}
/* find_id()
find_id(const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
if(EmptyString(name))
hashv = hash_id(name);
- DLINK_FOREACH(ptr, idTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, idTable[hashv].head)
{
target_p = ptr->data;
find_client(const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
find_named_client(const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
find_server(struct Client *source_p, const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
if(EmptyString(name))
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
/* find_hostname()
*
- * finds a hostname dlink list from the hostname hash table.
- * we return the full dlink list, because you can have multiple
+ * finds a hostname rb_dlink list from the hostname hash table.
+ * we return the full rb_dlink list, because you can have multiple
* entries with the same hostname
*/
-dlink_node *
+rb_dlink_node *
find_hostname(const char *hostname)
{
unsigned int hashv;
find_channel(const char *name)
{
struct Channel *chptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
hashv = hash_channel(name);
- DLINK_FOREACH(ptr, channelTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, channelTable[hashv].head)
{
chptr = ptr->data;
get_or_create_channel(struct Client *client_p, const char *chname, int *isnew)
{
struct Channel *chptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
int len;
const char *s = chname;
hashv = hash_channel(s);
- DLINK_FOREACH(ptr, channelTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, channelTable[hashv].head)
{
chptr = ptr->data;
chptr = allocate_channel(s);
- dlinkAdd(chptr, &chptr->node, &global_channel_list);
+ rb_dlinkAdd(chptr, &chptr->node, &global_channel_list);
chptr->channelts = CurrentTime; /* doesn't hurt to set it here */
- dlinkAddAlloc(chptr, &channelTable[hashv]);
+ rb_dlinkAddAlloc(chptr, &channelTable[hashv]);
return chptr;
}
hash_find_resv(const char *name)
{
struct ConfItem *aconf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
hashv = hash_resv(name);
- DLINK_FOREACH(ptr, resvTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, resvTable[hashv].head)
{
aconf = ptr->data;
clear_resv_hash(void)
{
struct ConfItem *aconf;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
int i;
HASH_WALK_SAFE(i, R_MAX, ptr, next_ptr, resvTable)
continue;
free_conf(ptr->data);
- dlinkDestroy(ptr, &resvTable[i]);
+ rb_dlinkDestroy(ptr, &resvTable[i]);
}
HASH_WALK_END
}
static void
-count_hash(struct Client *source_p, dlink_list *table, int length, const char *name)
+count_hash(struct Client *source_p, rb_dlink_list *table, int length, const char *name)
{
int counts[11];
int deepest = 0;
for(i = 0; i < length; i++)
{
- if(dlink_list_length(&table[i]) >= 10)
+ if(rb_dlink_list_length(&table[i]) >= 10)
counts[10]++;
else
- counts[dlink_list_length(&table[i])]++;
+ counts[rb_dlink_list_length(&table[i])]++;
- if(dlink_list_length(&table[i]) > deepest)
- deepest = dlink_list_length(&table[i]);
+ if(rb_dlink_list_length(&table[i]) > deepest)
+ deepest = rb_dlink_list_length(&table[i]);
}
output_hash(source_p, name, length, counts, deepest);