#include "cache.h"
#include "sprintf_irc.h"
#include "irc_dictionary.h"
+#include "numeric.h"
static BlockHeap *cachefile_heap = NULL;
static BlockHeap *cacheline_heap = NULL;
strlcpy(lineptr->data, " ", sizeof(lineptr->data));
else
strlcpy(lineptr->data, line, sizeof(lineptr->data));
- dlinkAddTail(lineptr, &lineptr->linenode, &cacheptr->contents);
+ rb_dlinkAddTail(lineptr, &lineptr->linenode, &cacheptr->contents);
}
fclose(in);
void
free_cachefile(struct cachefile *cacheptr)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(cacheptr == NULL)
return;
- DLINK_FOREACH_SAFE(ptr, next_ptr, cacheptr->contents.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, cacheptr->contents.head)
{
BlockHeapFree(cacheline_heap, ptr->data);
}
send_user_motd(struct Client *source_p)
{
struct cacheline *lineptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
const char *myname = get_id(&me, source_p);
const char *nick = get_id(source_p, source_p);
- if(user_motd == NULL || dlink_list_length(&user_motd->contents) == 0)
+ if(user_motd == NULL || rb_dlink_list_length(&user_motd->contents) == 0)
{
sendto_one(source_p, form_str(ERR_NOMOTD), myname, nick);
return;
sendto_one(source_p, form_str(RPL_MOTDSTART), myname, nick, me.name);
- DLINK_FOREACH(ptr, user_motd->contents.head)
+ RB_DLINK_FOREACH(ptr, user_motd->contents.head)
{
lineptr = ptr->data;
sendto_one(source_p, form_str(RPL_MOTD), myname, nick, lineptr->data);
send_oper_motd(struct Client *source_p)
{
struct cacheline *lineptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
- if(oper_motd == NULL || dlink_list_length(&oper_motd->contents) == 0)
+ if(oper_motd == NULL || rb_dlink_list_length(&oper_motd->contents) == 0)
return;
sendto_one(source_p, form_str(RPL_OMOTDSTART),
me.name, source_p->name);
- DLINK_FOREACH(ptr, oper_motd->contents.head)
+ RB_DLINK_FOREACH(ptr, oper_motd->contents.head)
{
lineptr = ptr->data;
sendto_one(source_p, form_str(RPL_OMOTD),
#include "balloc.h"
#include "s_log.h"
-extern dlink_list global_channel_list;
+extern rb_dlink_list global_channel_list;
extern struct config_channel_entry ConfigChannel;
extern BlockHeap *channel_heap;
find_channel_membership(struct Channel *chptr, struct Client *client_p)
{
struct membership *msptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
if(!IsClient(client_p))
return NULL;
/* Pick the most efficient list to use to be nice to things like
* CHANSERV which could be in a large number of channels
*/
- if(dlink_list_length(&chptr->members) < dlink_list_length(&client_p->user->channel))
+ if(rb_dlink_list_length(&chptr->members) < rb_dlink_list_length(&client_p->user->channel))
{
DLINK_FOREACH(ptr, chptr->members.head)
{
msptr->client_p = client_p;
msptr->flags = flags;
- dlinkAdd(msptr, &msptr->usernode, &client_p->user->channel);
- dlinkAdd(msptr, &msptr->channode, &chptr->members);
+ rb_dlinkAdd(msptr, &msptr->usernode, &client_p->user->channel);
+ rb_dlinkAdd(msptr, &msptr->channode, &chptr->members);
if(MyClient(client_p))
- dlinkAdd(msptr, &msptr->locchannode, &chptr->locmembers);
+ rb_dlinkAdd(msptr, &msptr->locchannode, &chptr->locmembers);
}
/* remove_user_from_channel()
client_p = msptr->client_p;
chptr = msptr->chptr;
- dlinkDelete(&msptr->usernode, &client_p->user->channel);
- dlinkDelete(&msptr->channode, &chptr->members);
+ rb_dlinkDelete(&msptr->usernode, &client_p->user->channel);
+ rb_dlinkDelete(&msptr->channode, &chptr->members);
if(client_p->servptr == &me)
- dlinkDelete(&msptr->locchannode, &chptr->locmembers);
+ rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
chptr->users_last = CurrentTime;
- if(!(chptr->mode.mode & MODE_PERMANENT) && dlink_list_length(&chptr->members) <= 0)
+ if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
destroy_channel(chptr);
BlockHeapFree(member_heap, msptr);
{
struct Channel *chptr;
struct membership *msptr;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(client_p == NULL)
return;
msptr = ptr->data;
chptr = msptr->chptr;
- dlinkDelete(&msptr->channode, &chptr->members);
+ rb_dlinkDelete(&msptr->channode, &chptr->members);
if(client_p->servptr == &me)
- dlinkDelete(&msptr->locchannode, &chptr->locmembers);
+ rb_dlinkDelete(&msptr->locchannode, &chptr->locmembers);
chptr->users_last = CurrentTime;
- if(!(chptr->mode.mode & MODE_PERMANENT) && dlink_list_length(&chptr->members) <= 0)
+ if(!(chptr->mode.mode & MODE_PERMANENT) && rb_dlink_list_length(&chptr->members) <= 0)
destroy_channel(chptr);
BlockHeapFree(member_heap, msptr);
invalidate_bancache_user(struct Client *client_p)
{
struct membership *msptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
if(client_p == NULL)
return;
/* free_channel_list()
*
- * input - dlink list to free
+ * input - rb_dlink list to free
* output -
* side effects - list of b/e/I modes is cleared
*/
void
-free_channel_list(dlink_list * list)
+free_channel_list(rb_dlink_list * list)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct Ban *actualBan;
DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
void
destroy_channel(struct Channel *chptr)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->invites.head)
{
/* Free the topic */
free_topic(chptr);
- dlinkDelete(&chptr->node, &global_channel_list);
+ rb_dlinkDelete(&chptr->node, &global_channel_list);
del_from_channel_hash(chptr->chname, chptr);
free_channel(chptr);
}
{
struct membership *msptr;
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
char lbuf[BUFSIZE];
char *t;
int mlen;
void
del_invite(struct Channel *chptr, struct Client *who)
{
- dlinkFindDestroy(who, &chptr->invites);
- dlinkFindDestroy(chptr, &who->user->invited);
+ rb_dlinkFindDestroy(who, &chptr->invites);
+ rb_dlinkFindDestroy(chptr, &who->user->invited);
}
/* is_banned()
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
char *s3 = NULL;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Ban *actualBan = NULL;
struct Ban *actualExcept = NULL;
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
char src_althost[NICKLEN + USERLEN + HOSTLEN + 6];
char *s3 = NULL;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Ban *actualBan = NULL;
struct Ban *actualExcept = NULL;
int
can_join(struct Client *source_p, struct Channel *chptr, char *key)
{
- dlink_node *invite = NULL;
- dlink_node *ptr;
+ rb_dlink_node *invite = NULL;
+ rb_dlink_node *ptr;
struct Ban *invex = NULL;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
return (ERR_BADCHANNELKEY);
if(chptr->mode.limit &&
- dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
+ rb_dlink_list_length(&chptr->members) >= (unsigned long) chptr->mode.limit)
i = ERR_CHANNELISFULL;
if(chptr->mode.mode & MODE_REGONLY && EmptyString(source_p->user->suser))
i = ERR_NEEDREGGEDNICK;
{
struct Channel *chptr;
struct membership *msptr;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
char src_host[NICKLEN + USERLEN + HOSTLEN + 6];
char src_iphost[NICKLEN + USERLEN + HOSTLEN + 6];
struct Channel *, struct membership *, int, const char **);
int add_id(struct Client *source_p, struct Channel *chptr,
- const char *banid, dlink_list * list, long mode_type);
+ const char *banid, rb_dlink_list * list, long mode_type);
static struct ChModeChange mode_changes[BUFSIZE];
static int mode_count;
*/
int
add_id(struct Client *source_p, struct Channel *chptr, const char *banid,
- dlink_list * list, long mode_type)
+ rb_dlink_list * list, long mode_type)
{
struct Ban *actualBan;
static char who[USERHOST_REPLYLEN];
char *realban = LOCAL_COPY(banid);
- dlink_node *ptr;
+ rb_dlink_node *ptr;
/* dont let local clients overflow the banlist, or set redundant
* bans
*/
if(MyClient(source_p))
{
- if((dlink_list_length(&chptr->banlist) + dlink_list_length(&chptr->exceptlist) + dlink_list_length(&chptr->invexlist) + dlink_list_length(&chptr->quietlist)) >= (chptr->mode.mode & MODE_EXLIMIT ? ConfigChannel.max_bans_large : ConfigChannel.max_bans))
+ if((rb_dlink_list_length(&chptr->banlist) + rb_dlink_list_length(&chptr->exceptlist) + rb_dlink_list_length(&chptr->invexlist) + rb_dlink_list_length(&chptr->quietlist)) >= (chptr->mode.mode & MODE_EXLIMIT ? ConfigChannel.max_bans_large : ConfigChannel.max_bans))
{
sendto_one(source_p, form_str(ERR_BANLISTFULL),
me.name, source_p->name, chptr->chname, realban);
actualBan = allocate_ban(realban, who);
actualBan->when = CurrentTime;
- dlinkAdd(actualBan, &actualBan->node, list);
+ rb_dlinkAdd(actualBan, &actualBan->node, list);
/* invalidate the can_send() cache */
if(mode_type == CHFL_BAN || mode_type == CHFL_QUIET || mode_type == CHFL_EXCEPTION)
* side effects - given id is removed from the appropriate list
*/
int
-del_id(struct Channel *chptr, const char *banid, dlink_list * list, long mode_type)
+del_id(struct Channel *chptr, const char *banid, rb_dlink_list * list, long mode_type)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Ban *banptr;
if(EmptyString(banid))
if(irccmp(banid, banptr->banstr) == 0)
{
- dlinkDelete(&banptr->node, list);
+ rb_dlinkDelete(&banptr->node, list);
free_ban(banptr);
/* invalidate the can_send() cache */
{
const char *mask;
const char *raw_mask;
- dlink_list *list;
- dlink_node *ptr;
+ rb_dlink_list *list;
+ rb_dlink_node *ptr;
struct Ban *banptr;
int errorval;
int rpl_list;
}
/* only propagate modes originating locally, or if we're hubbing */
- if(MyClient(source_p) || dlink_list_length(&serv_list) > 1)
+ if(MyClient(source_p) || rb_dlink_list_length(&serv_list) > 1)
send_cap_mode_changes(client_p, source_p, chptr, mode_changes, mode_count);
}
#define BAD_PING -2
#define BAD_CLIENT_CLASS -3
-dlink_list class_list;
+rb_dlink_list class_list;
struct Class *default_class;
struct Class *
if(tmpptr == default_class)
{
- dlinkAddAlloc(classptr, &class_list);
+ rb_dlinkAddAlloc(classptr, &class_list);
CurrUsers(classptr) = 0;
}
else
find_class(const char *classname)
{
struct Class *cltmp;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
if(classname == NULL)
return default_class;
check_class()
{
struct Class *cltmp;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, class_list.head)
{
if(MaxUsers(cltmp) < 0)
{
- dlinkDestroy(ptr, &class_list);
+ rb_dlinkDestroy(ptr, &class_list);
if(CurrUsers(cltmp) <= 0)
free_class(cltmp);
}
report_classes(struct Client *source_p)
{
struct Class *cltmp;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, class_list.head)
{
#define DEBUG_EXITED_CLIENTS
-static void check_pings_list(dlink_list * list);
-static void check_unknowns_list(dlink_list * list);
+static void check_pings_list(rb_dlink_list * list);
+static void check_unknowns_list(rb_dlink_list * list);
static void free_exited_clients(void *unused);
static void exit_aborted_clients(void *unused);
G_LINED
};
-dlink_list dead_list;
+rb_dlink_list dead_list;
#ifdef DEBUG_EXITED_CLIENTS
-static dlink_list dead_remote_list;
+static rb_dlink_list dead_remote_list;
#endif
struct abort_client
{
- dlink_node node;
+ rb_dlink_node node;
struct Client *client;
char notice[REASONLEN];
};
-static dlink_list abort_list;
+static rb_dlink_list abort_list;
/*
client_p->preClient = (struct PreClient *) BlockHeapAlloc(pclient_heap);
/* as good a place as any... */
- dlinkAdd(client_p, &client_p->localClient->tnode, &unknown_list);
+ rb_dlinkAdd(client_p, &client_p->localClient->tnode, &unknown_list);
}
else
{ /* from is not NULL */
* side effects -
*/
static void
-check_pings_list(dlink_list * list)
+check_pings_list(rb_dlink_list * list)
{
char scratch[32]; /* way too generous but... */
struct Client *client_p; /* current local client_p being examined */
int ping = 0; /* ping time value from client */
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
{
* side effects - unknown clients get marked for termination after n seconds
*/
static void
-check_unknowns_list(dlink_list * list)
+check_unknowns_list(rb_dlink_list * list)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
struct Client *client_p;
int timeout;
{
struct Client *client_p; /* current local client_p being examined */
struct ConfItem *aconf = NULL;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
{
struct Client *client_p;
struct ConfItem *aconf;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
{
struct Client *client_p;
struct ConfItem *aconf;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
{
struct Client *client_p;
struct ConfItem *aconf;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
{
struct Client *client_p;
struct ConfItem *aconf;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
if(client_p->node.prev == NULL && client_p->node.next == NULL)
return;
- dlinkDelete(&client_p->node, &global_client_list);
+ rb_dlinkDelete(&client_p->node, &global_client_list);
update_client_exit_stats(client_p);
}
static void
free_exited_clients(void *unused)
{
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
struct Client *target_p;
DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
#ifdef DEBUG_EXITED_CLIENTS
{
struct abort_client *abt;
- dlink_node *aptr;
+ rb_dlink_node *aptr;
int found = 0;
DLINK_FOREACH(aptr, abort_list.head)
if(found)
{
- dlinkDestroy(ptr, &dead_list);
+ rb_dlinkDestroy(ptr, &dead_list);
continue;
}
}
{
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Warning: null client on dead_list!");
- dlinkDestroy(ptr, &dead_list);
+ rb_dlinkDestroy(ptr, &dead_list);
continue;
}
release_client_state(target_p);
free_client(target_p);
- dlinkDestroy(ptr, &dead_list);
+ rb_dlinkDestroy(ptr, &dead_list);
}
#ifdef DEBUG_EXITED_CLIENTS
{
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Warning: null client on dead_list!");
- dlinkDestroy(ptr, &dead_list);
+ rb_dlinkDestroy(ptr, &dead_list);
continue;
}
release_client_state(target_p);
free_client(target_p);
- dlinkDestroy(ptr, &dead_remote_list);
+ rb_dlinkDestroy(ptr, &dead_remote_list);
}
#endif
const char *comment)
{
struct Client *target_p;
- dlink_node *ptr, *ptr_next;
+ rb_dlink_node *ptr, *ptr_next;
/* If this server can handle quit storm (QS) removal
* of dependents, just send the SQUIT
*/
recurse_remove_clients(struct Client *source_p, const char *comment)
{
struct Client *target_p;
- dlink_node *ptr, *ptr_next;
+ rb_dlink_node *ptr, *ptr_next;
if(IsMe(source_p))
return;
struct Client *from, const char *comment, const char *comment1)
{
struct Client *to;
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
DLINK_FOREACH_SAFE(ptr, next, serv_list.head)
{
exit_aborted_clients(void *unused)
{
struct abort_client *abt;
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
DLINK_FOREACH_SAFE(ptr, next, abort_list.head)
{
abt = ptr->data;
#ifdef DEBUG_EXITED_CLIENTS
{
- if(dlinkFind(abt->client, &dead_list))
+ if(rb_dlinkFind(abt->client, &dead_list))
{
s_assert(0);
sendto_realops_snomask(SNO_GENERAL, L_ALL,
#endif
s_assert(*((unsigned long*)abt->client) != 0xdeadbeef); /* This is lame but its a debug thing */
- dlinkDelete(ptr, &abort_list);
+ rb_dlinkDelete(ptr, &abort_list);
if(IsAnyServer(abt->client))
sendto_realops_snomask(SNO_GENERAL, L_ALL,
SetIOError(client_p);
SetDead(client_p);
SetClosing(client_p);
- dlinkAdd(abt, &abt->node, &abort_list);
+ rb_dlinkAdd(abt, &abt->node, &abort_list);
}
exit_generic_client(struct Client *client_p, struct Client *source_p, struct Client *from,
const char *comment)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
if(IsOper(source_p))
- dlinkFindDestroy(source_p, &oper_list);
+ rb_dlinkFindDestroy(source_p, &oper_list);
sendto_common_channels_local(source_p, ":%s!%s@%s QUIT :%s",
source_p->name,
if(source_p->servptr && source_p->servptr->serv)
{
- dlinkDelete(&source_p->lnode, &source_p->servptr->serv->users);
+ rb_dlinkDelete(&source_p->lnode, &source_p->servptr->serv->users);
}
if((source_p->flags & FLAGS_KILLED) == 0)
SetDead(source_p);
#ifdef DEBUG_EXITED_CLIENTS
- dlinkAddAlloc(source_p, &dead_remote_list);
+ rb_dlinkAddAlloc(source_p, &dead_remote_list);
#else
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
#endif
return(CLIENT_EXITED);
}
delete_auth_queries(source_p);
client_flush_input(source_p);
del_unknown_ip(source_p);
- dlinkDelete(&source_p->localClient->tnode, &unknown_list);
+ rb_dlinkDelete(&source_p->localClient->tnode, &unknown_list);
if(!IsIOError(source_p))
sendto_one(source_p, "ERROR :Closing Link: %s (%s)",
del_from_client_hash(source_p->name, source_p);
remove_client_from_list(source_p);
SetDead(source_p);
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
/* Note that we don't need to add unknowns to the dead_list */
return(CLIENT_EXITED);
remove_dependents(client_p, source_p, from, IsPerson(from) ? newcomment : comment, comment1);
if(source_p->servptr && source_p->servptr->serv)
- dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
+ rb_dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
else
s_assert(0);
- dlinkFindDestroy(source_p, &global_serv_list);
+ rb_dlinkFindDestroy(source_p, &global_serv_list);
target_p = source_p->from;
if(target_p != NULL && IsServer(target_p) && target_p != client_p &&
SetDead(source_p);
#ifdef DEBUG_EXITED_CLIENTS
- dlinkAddAlloc(source_p, &dead_remote_list);
+ rb_dlinkAddAlloc(source_p, &dead_remote_list);
#else
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
#endif
return 0;
}
struct Client *target_p;
if(source_p->servptr && source_p->servptr->serv)
- dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
+ rb_dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
else
s_assert(0);
- dlinkFindDestroy(source_p, &global_serv_list);
+ rb_dlinkFindDestroy(source_p, &global_serv_list);
target_p = source_p->from;
if(has_id(source_p))
scache_split(source_p->serv->nameinfo);
SetDead(source_p);
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
return 0;
}
static char newcomment[BUFSIZE];
unsigned int sendk, recvk;
- dlinkDelete(&source_p->localClient->tnode, &serv_list);
- dlinkFindDestroy(source_p, &global_serv_list);
+ rb_dlinkDelete(&source_p->localClient->tnode, &serv_list);
+ rb_dlinkFindDestroy(source_p, &global_serv_list);
unset_chcap_usage_counts(source_p);
sendk = source_p->localClient->sendK;
}
if(source_p->servptr && source_p->servptr->serv)
- dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
+ rb_dlinkDelete(&source_p->lnode, &source_p->servptr->serv->servers);
else
s_assert(0);
scache_split(source_p->serv->nameinfo);
SetDead(source_p);
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
return 0;
}
s_assert(IsPerson(source_p));
client_flush_input(source_p);
- dlinkDelete(&source_p->localClient->tnode, &lclient_list);
- dlinkDelete(&source_p->lnode, &me.serv->users);
+ rb_dlinkDelete(&source_p->localClient->tnode, &lclient_list);
+ rb_dlinkDelete(&source_p->lnode, &me.serv->users);
if(IsOper(source_p))
- dlinkFindDestroy(source_p, &local_oper_list);
+ rb_dlinkFindDestroy(source_p, &local_oper_list);
sendto_realops_snomask(SNO_CCONN, L_ALL,
"Client exiting: %s (%s@%s) [%s] [%s]",
}
SetDead(source_p);
- dlinkAddAlloc(source_p, &dead_list);
+ rb_dlinkAddAlloc(source_p, &dead_list);
return(CLIENT_EXITED);
}
void
del_all_accepts(struct Client *client_p)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct Client *target_p;
if(MyClient(client_p) && client_p->localClient->allow_list.head)
DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->allow_list.head)
{
target_p = ptr->data;
- dlinkFindDestroy(client_p, &target_p->on_allow_list);
- dlinkDestroy(ptr, &client_p->localClient->allow_list);
+ rb_dlinkFindDestroy(client_p, &target_p->on_allow_list);
+ rb_dlinkDestroy(ptr, &client_p->localClient->allow_list);
}
}
DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->on_allow_list.head)
{
target_p = ptr->data;
- dlinkFindDestroy(client_p, &target_p->localClient->allow_list);
- dlinkDestroy(ptr, &client_p->on_allow_list);
+ rb_dlinkFindDestroy(client_p, &target_p->localClient->allow_list);
+ rb_dlinkDestroy(ptr, &client_p->on_allow_list);
}
}
(unsigned long) user,
(unsigned long) user->invited.head,
(unsigned long) user->channel.head,
- dlink_list_length(&user->channel),
+ rb_dlink_list_length(&user->channel),
user->refcnt);
s_assert(!user->refcnt);
s_assert(!user->invited.head);
#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 = MyMalloc(sizeof(rb_dlink_list) * U_MAX);
+ idTable = MyMalloc(sizeof(rb_dlink_list) * U_MAX);
+ channelTable = MyMalloc(sizeof(rb_dlink_list) * CH_MAX);
+ hostTable = MyMalloc(sizeof(rb_dlink_list) * HOST_MAX);
+ resvTable = MyMalloc(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))
find_client(const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
find_named_client(const char *name)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
unsigned int hashv;
s_assert(name != NULL);
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))
/* 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);
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;
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);
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);
i = register_hook(name);
- dlinkAddAlloc(fn, &hooks[i].hooks);
+ rb_dlinkAddAlloc(fn, &hooks[i].hooks);
}
/* remove_hook()
if((i = find_hook(name)) < 0)
return;
- dlinkFindDestroy(fn, &hooks[i].hooks);
+ rb_dlinkFindDestroy(fn, &hooks[i].hooks);
}
/* call_hook()
call_hook(int id, void *arg)
{
hookfn fn;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
/* The ID we were passed is the position in the hook table of this
* hook
memset(&local_oper_list, 0, sizeof(local_oper_list));
memset(&oper_list, 0, sizeof(oper_list));
- dlinkAddTail(&me, &me.node, &global_client_list);
+ rb_dlinkAddTail(&me, &me.node, &global_client_list);
memset((void *) &Count, 0, sizeof(Count));
memset((void *) &ServerInfo, 0, sizeof(ServerInfo));
add_to_id_hash(me.id, &me);
me.serv->nameinfo = scache_connect(me.name, me.info, 0);
- dlinkAddAlloc(&me, &global_serv_list);
+ rb_dlinkAddAlloc(&me, &global_serv_list);
construct_umodebuf();
#include "patchlevel.h"
#include "serno.h"
-dlink_list lclient_list = { NULL, NULL, 0 };
-dlink_list global_client_list = { NULL, NULL, 0 };
-dlink_list global_channel_list = { NULL, NULL, 0 };
-
-dlink_list unknown_list; /* unknown clients ON this server only */
-dlink_list serv_list; /* local servers to this server ONLY */
-dlink_list global_serv_list; /* global servers on the network */
-dlink_list local_oper_list; /* our opers, duplicated in lclient_list */
-dlink_list oper_list; /* network opers */
+rb_dlink_list lclient_list = { NULL, NULL, 0 };
+rb_dlink_list global_client_list = { NULL, NULL, 0 };
+rb_dlink_list global_channel_list = { NULL, NULL, 0 };
+
+rb_dlink_list unknown_list; /* unknown clients ON this server only */
+rb_dlink_list serv_list; /* local servers to this server ONLY */
+rb_dlink_list global_serv_list; /* global servers on the network */
+rb_dlink_list local_oper_list; /* our opers, duplicated in lclient_list */
+rb_dlink_list oper_list; /* network opers */
/* /quote set variables */
struct SetOptions GlobalSetOptions;
DupString(aconf->name, gecos_field);
DupString(aconf->passwd, reason_field);
- dlinkAddAlloc(aconf, &xline_conf_list);
+ rb_dlinkAddAlloc(aconf, &xline_conf_list);
}
}
DupString(aconf->name, host_field);
DupString(aconf->passwd, reason_field);
- dlinkAddAlloc(aconf, &resv_conf_list);
+ rb_dlinkAddAlloc(aconf, &resv_conf_list);
}
}
}
int num_mods = 0;
int max_mods = MODS_INCREMENT;
-static dlink_list mod_paths;
+static rb_dlink_list mod_paths;
static int mo_modload(struct Client *, struct Client *, int, const char **);
static int mo_modlist(struct Client *, struct Client *, int, const char **);
static struct module_path *
mod_find_path(const char *path)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct module_path *mpath;
DLINK_FOREACH(ptr, mod_paths.head)
pathst = MyMalloc(sizeof(struct module_path));
strcpy(pathst->path, path);
- dlinkAddAlloc(pathst, &mod_paths);
+ rb_dlinkAddAlloc(pathst, &mod_paths);
}
/* mod_clear_paths()
void
mod_clear_paths(void)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
{
MyFree(ptr->data);
- free_dlink_node(ptr);
+ free_rb_dlink_node(ptr);
}
mod_paths.head = mod_paths.tail = NULL;
load_one_module(const char *path, int coremodule)
{
char modpath[MAXPATHLEN];
- dlink_node *pathst;
+ rb_dlink_node *pathst;
struct module_path *mpath;
struct stat statbuf;
clear_monitor(struct Client *client_p)
{
struct monitor *monptr;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->monitor_list.head)
{
/* we leave the actual entry around with no users, itll be
* cleaned up periodically by cleanup_monitor() --anfl
*/
- dlinkFindDestroy(client_p, &monptr->users);
- free_dlink_node(ptr);
+ rb_dlinkFindDestroy(client_p, &monptr->users);
+ free_rb_dlink_node(ptr);
}
client_p->localClient->monitor_list.head = client_p->localClient->monitor_list.tail = NULL;
{
next_ptr = ptr->hnext;
- if(!dlink_list_length(&ptr->users))
+ if(!rb_dlink_list_length(&ptr->users))
{
if(last_ptr)
last_ptr->hnext = next_ptr;
struct TopConf *conf_cur_block;
static char *conf_cur_block_name;
-static dlink_list conf_items;
+static rb_dlink_list conf_items;
static struct ConfItem *yy_aconf = NULL;
static struct remote_conf *yy_shared = NULL;
static struct server_conf *yy_server = NULL;
-static dlink_list yy_aconf_list;
-static dlink_list yy_oper_list;
-static dlink_list yy_shared_list;
-static dlink_list yy_cluster_list;
+static rb_dlink_list yy_aconf_list;
+static rb_dlink_list yy_oper_list;
+static rb_dlink_list yy_shared_list;
+static rb_dlink_list yy_cluster_list;
static struct oper_conf *yy_oper = NULL;
static struct alias_entry *yy_alias = NULL;
tc->tc_efunc = efunc;
tc->tc_entries = items;
- dlinkAddAlloc(tc, &conf_items);
+ rb_dlinkAddAlloc(tc, &conf_items);
return 0;
}
struct TopConf *
find_top_conf(const char *name)
{
- dlink_node *d;
+ rb_dlink_node *d;
struct TopConf *tc;
DLINK_FOREACH(d, conf_items.head)
find_conf_item(const struct TopConf *top, const char *name)
{
struct ConfEntry *cf;
- dlink_node *d;
+ rb_dlink_node *d;
if(top->tc_entries)
{
remove_top_conf(char *name)
{
struct TopConf *tc;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
if((tc = find_top_conf(name)) == NULL)
return -1;
- if((ptr = dlinkFind(tc, &conf_items)) == NULL)
+ if((ptr = rb_dlinkFind(tc, &conf_items)) == NULL)
return -1;
- dlinkDestroy(ptr, &conf_items);
+ rb_dlinkDestroy(ptr, &conf_items);
MyFree(tc);
return 0;
static int
conf_begin_oper(struct TopConf *tc)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(yy_oper != NULL)
{
DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
{
free_oper_conf(ptr->data);
- dlinkDestroy(ptr, &yy_oper_list);
+ rb_dlinkDestroy(ptr, &yy_oper_list);
}
yy_oper = make_oper_conf();
conf_end_oper(struct TopConf *tc)
{
struct oper_conf *yy_tmpoper;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(conf_cur_block_name != NULL)
{
#endif
/* all is ok, put it on oper_conf_list */
- dlinkMoveNode(ptr, &yy_oper_list, &oper_conf_list);
+ rb_dlinkMoveNode(ptr, &yy_oper_list, &oper_conf_list);
}
free_oper_conf(yy_oper);
return;
}
- dlinkAddAlloc(yy_tmpoper, &yy_oper_list);
+ rb_dlinkAddAlloc(yy_tmpoper, &yy_oper_list);
}
static void
static int
conf_begin_auth(struct TopConf *tc)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(yy_aconf)
free_conf(yy_aconf);
DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
{
free_conf(ptr->data);
- dlinkDestroy(ptr, &yy_aconf_list);
+ rb_dlinkDestroy(ptr, &yy_aconf_list);
}
yy_aconf = make_conf();
conf_end_auth(struct TopConf *tc)
{
struct ConfItem *yy_tmp;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
if(EmptyString(yy_aconf->name))
DupString(yy_aconf->name, "NOMATCH");
conf_add_class_to_conf(yy_tmp);
add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp);
- dlinkDestroy(ptr, &yy_aconf_list);
+ rb_dlinkDestroy(ptr, &yy_aconf_list);
}
yy_aconf = NULL;
}
if(yy_aconf != yy_tmp)
- dlinkAddAlloc(yy_tmp, &yy_aconf_list);
+ rb_dlinkAddAlloc(yy_tmp, &yy_aconf_list);
}
static void
static int
conf_cleanup_shared(struct TopConf *tc)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
{
free_remote_conf(ptr->data);
- dlinkDestroy(ptr, &yy_shared_list);
+ rb_dlinkDestroy(ptr, &yy_shared_list);
}
if(yy_shared != NULL)
else
DupString(yy_shared->username, username);
- dlinkAddAlloc(yy_shared, &yy_shared_list);
+ rb_dlinkAddAlloc(yy_shared, &yy_shared_list);
yy_shared = NULL;
}
{
conf_parm_t *args = data;
int flags = 0;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
if(yy_shared != NULL)
free_remote_conf(yy_shared);
yy_shared = ptr->data;
yy_shared->flags = flags;
- dlinkDestroy(ptr, &yy_shared_list);
- dlinkAddTail(yy_shared, &yy_shared->node, &shared_conf_list);
+ rb_dlinkDestroy(ptr, &yy_shared_list);
+ rb_dlinkAddTail(yy_shared, &yy_shared->node, &shared_conf_list);
}
yy_shared = NULL;
#endif
add_server_conf(yy_server);
- dlinkAdd(yy_server, &yy_server->node, &server_conf_list);
+ rb_dlinkAdd(yy_server, &yy_server->node, &server_conf_list);
yy_server = NULL;
return 0;
DupString(yy_hub->host, data);
DupString(yy_hub->server, yy_server->name);
- dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
+ rb_dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
}
static void
DupString(yy_leaf->host, data);
DupString(yy_leaf->server, yy_server->name);
- dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
+ rb_dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
}
static void
static int
conf_cleanup_cluster(struct TopConf *tc)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
{
free_remote_conf(ptr->data);
- dlinkDestroy(ptr, &yy_cluster_list);
+ rb_dlinkDestroy(ptr, &yy_cluster_list);
}
if(yy_shared != NULL)
yy_shared = make_remote_conf();
DupString(yy_shared->server, data);
- dlinkAddAlloc(yy_shared, &yy_cluster_list);
+ rb_dlinkAddAlloc(yy_shared, &yy_cluster_list);
yy_shared = NULL;
}
{
conf_parm_t *args = data;
int flags = 0;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
if(yy_shared != NULL)
free_remote_conf(yy_shared);
{
yy_shared = ptr->data;
yy_shared->flags = flags;
- dlinkAddTail(yy_shared, &yy_shared->node, &cluster_conf_list);
- dlinkDestroy(ptr, &yy_cluster_list);
+ rb_dlinkAddTail(yy_shared, &yy_shared->node, &cluster_conf_list);
+ rb_dlinkDestroy(ptr, &yy_cluster_list);
}
yy_shared = NULL;
conf_begin_service(struct TopConf *tc)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, global_serv_list.head)
{
}
DupString(tmp, data);
- dlinkAddAlloc(tmp, &service_list);
+ rb_dlinkAddAlloc(tmp, &service_list);
if((target_p = find_server(NULL, tmp)))
target_p->flags |= FLAGS_SERVICE;
cf->cf_func = func;
cf->cf_arg = NULL;
- dlinkAddAlloc(cf, &tc->tc_items);
+ rb_dlinkAddAlloc(cf, &tc->tc_items);
return 0;
}
{
struct TopConf *tc;
struct ConfEntry *cf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
if((tc = find_top_conf(topconf)) == NULL)
return -1;
if((cf = find_conf_item(tc, name)) == NULL)
return -1;
- if((ptr = dlinkFind(cf, &tc->tc_items)) == NULL)
+ if((ptr = rb_dlinkFind(cf, &tc->tc_items)) == NULL)
return -1;
- dlinkDestroy(ptr, &tc->tc_items);
+ rb_dlinkDestroy(ptr, &tc->tc_items);
MyFree(cf);
return 0;
#include "hash.h"
static patricia_tree_t *reject_tree;
-dlink_list delay_exit;
-static dlink_list reject_list;
+rb_dlink_list delay_exit;
+static rb_dlink_list reject_list;
static patricia_tree_t *unknown_tree;
struct reject_data
{
- dlink_node rnode;
+ rb_dlink_node rnode;
time_t time;
unsigned int count;
uint32_t mask_hashv;
reject_exit(void *unused)
{
struct Client *client_p;
- dlink_node *ptr, *ptr_next;
+ rb_dlink_node *ptr, *ptr_next;
DLINK_FOREACH_SAFE(ptr, ptr_next, delay_exit.head)
{
}
close_connection(client_p);
SetDead(client_p);
- dlinkAddAlloc(client_p, &dead_list);
+ rb_dlinkAddAlloc(client_p, &dead_list);
}
delay_exit.head = delay_exit.tail = NULL;
static void
reject_expires(void *unused)
{
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
patricia_node_t *pnode;
struct reject_data *rdata;
if(rdata->time + ConfigFileEntry.reject_duration > CurrentTime)
continue;
- dlinkDelete(ptr, &reject_list);
+ rb_dlinkDelete(ptr, &reject_list);
MyFree(rdata);
patricia_remove(reject_tree, pnode);
}
#endif
pnode = make_and_lookup_ip(reject_tree, (struct sockaddr *)&client_p->localClient->ip, bitlen);
pnode->data = rdata = MyMalloc(sizeof(struct reject_data));
- dlinkAddTail(pnode, &rdata->rnode, &reject_list);
+ rb_dlinkAddTail(pnode, &rdata->rnode, &reject_list);
rdata->time = CurrentTime;
rdata->count = 1;
}
SetReject(client_p);
rb_setselect(client_p->localClient->F->fd, FDLIST_NONE, COMM_SELECT_WRITE | COMM_SELECT_READ, NULL, NULL, 0);
SetClosing(client_p);
- dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &delay_exit);
+ rb_dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &delay_exit);
return 1;
}
}
void
flush_reject(void)
{
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
patricia_node_t *pnode;
struct reject_data *rdata;
{
pnode = ptr->data;
rdata = pnode->data;
- dlinkDelete(ptr, &reject_list);
+ rb_dlinkDelete(ptr, &reject_list);
MyFree(rdata);
patricia_remove(reject_tree, pnode);
}
if((pnode = match_string(reject_tree, ip)) != NULL)
{
struct reject_data *rdata = pnode->data;
- dlinkDelete(&rdata->rnode, &reject_list);
+ rb_dlinkDelete(&rdata->rnode, &reject_list);
MyFree(rdata);
patricia_remove(reject_tree, pnode);
return 1;
int
remove_reject_mask(const char *mask1, const char *mask2)
{
- dlink_node *ptr, *next;
+ rb_dlink_node *ptr, *next;
patricia_node_t *pnode;
struct reject_data *rdata;
uint32_t hashv;
rdata = pnode->data;
if (rdata->mask_hashv == hashv)
{
- dlinkDelete(ptr, &reject_list);
+ rb_dlinkDelete(ptr, &reject_list);
MyFree(rdata);
patricia_remove(reject_tree, pnode);
n++;
SetReject(client_p);
rb_setselect(client_p->localClient->F->fd, FDLIST_NONE, COMM_SELECT_WRITE | COMM_SELECT_READ, NULL, NULL, 0);
SetClosing(client_p);
- dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &delay_exit);
+ rb_dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &delay_exit);
return 1;
}
struct reslist
{
- dlink_node node;
+ rb_dlink_node node;
int id;
int sent; /* number of requests sent */
request_state state; /* State the resolver machine is in */
};
static int res_fd;
-static dlink_list request_list = { NULL, NULL, 0 };
+static rb_dlink_list request_list = { NULL, NULL, 0 };
static void rem_request(struct reslist *request);
static struct reslist *make_request(struct DNSQuery *query);
*/
static time_t timeout_query_list(time_t now)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct reslist *request;
time_t next_time = 0;
time_t timeout = 0;
*/
static void rem_request(struct reslist *request)
{
- dlinkDelete(&request->node, &request_list);
+ rb_dlinkDelete(&request->node, &request_list);
MyFree(request->name);
MyFree(request);
}
request->query = query;
request->state = REQ_IDLE;
- dlinkAdd(request, &request->node, &request_list);
+ rb_dlinkAdd(request, &request->node, &request_list);
return request;
}
*/
void delete_resolver_queries(const struct DNSQuery *query)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct reslist *request;
DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
*/
static struct reslist *find_id(int id)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct reslist *request;
DLINK_FOREACH(ptr, request_list.head)
#define sendheader(c, r) sendto_one_notice(c, HeaderMessages[(r)])
-static dlink_list auth_poll_list;
+static rb_dlink_list auth_poll_list;
static BlockHeap *auth_heap;
static EVH timeout_auth_queries_event;
return;
client->localClient->auth_request = NULL;
- dlinkDelete(&auth->node, &auth_poll_list);
+ rb_dlinkDelete(&auth->node, &auth_poll_list);
free_auth_request(auth);
if(client->localClient->F->fd > highest_fd)
highest_fd = client->localClient->F->fd;
*/
client->localClient->allow_read = MAX_FLOOD;
rb_setflush(client->localClient->F->fd, 1000, flood_recalc, client);
- dlinkAddTail(client, &client->node, &global_client_list);
+ rb_dlinkAddTail(client, &client->node, &global_client_list);
read_packet(client->localClient->F->fd, client);
}
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"auth_dns_callback(): auth->client->localClient (%s) is NULL", get_client_name(auth->client, HIDE_IP));
- dlinkDelete(&auth->node, &auth_poll_list);
+ rb_dlinkDelete(&auth->node, &auth_poll_list);
free_auth_request(auth);
/* and they will silently drop through and all will hopefully be ok... -nenolod */
if(ConfigFileEntry.disable_auth == 0)
start_auth_query(auth);
- dlinkAdd(auth, &auth->node, &auth_poll_list);
+ rb_dlinkAdd(auth, &auth->node, &auth_poll_list);
}
/*
static void
timeout_auth_queries_event(void *notused)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct AuthRequest *auth;
DLINK_FOREACH_SAFE(ptr, next_ptr, auth_poll_list.head)
if(auth->fd >= 0)
rb_close(auth->fd);
- dlinkDelete(&auth->node, &auth_poll_list);
+ rb_dlinkDelete(&auth->node, &auth_poll_list);
free_auth_request(auth);
}
static BlockHeap *confitem_heap = NULL;
-dlink_list temp_klines[LAST_TEMP_TYPE];
-dlink_list temp_dlines[LAST_TEMP_TYPE];
-dlink_list service_list;
+rb_dlink_list temp_klines[LAST_TEMP_TYPE];
+rb_dlink_list temp_dlines[LAST_TEMP_TYPE];
+rb_dlink_list service_list;
/* internally defined functions */
static void set_default_conf(void);
attach_iline(struct Client *client_p, struct ConfItem *aconf)
{
struct Client *target_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
int local_count = 0;
int global_count = 0;
int ident_count = 0;
{
if(aconf->hold >= CurrentTime + (10080 * 60))
{
- dlinkAddAlloc(aconf, &temp_klines[TEMP_WEEK]);
+ rb_dlinkAddAlloc(aconf, &temp_klines[TEMP_WEEK]);
aconf->port = TEMP_WEEK;
}
else if(aconf->hold >= CurrentTime + (1440 * 60))
{
- dlinkAddAlloc(aconf, &temp_klines[TEMP_DAY]);
+ rb_dlinkAddAlloc(aconf, &temp_klines[TEMP_DAY]);
aconf->port = TEMP_DAY;
}
else if(aconf->hold >= CurrentTime + (60 * 60))
{
- dlinkAddAlloc(aconf, &temp_klines[TEMP_HOUR]);
+ rb_dlinkAddAlloc(aconf, &temp_klines[TEMP_HOUR]);
aconf->port = TEMP_HOUR;
}
else
{
- dlinkAddAlloc(aconf, &temp_klines[TEMP_MIN]);
+ rb_dlinkAddAlloc(aconf, &temp_klines[TEMP_MIN]);
aconf->port = TEMP_MIN;
}
{
if(aconf->hold >= CurrentTime + (10080 * 60))
{
- dlinkAddAlloc(aconf, &temp_dlines[TEMP_WEEK]);
+ rb_dlinkAddAlloc(aconf, &temp_dlines[TEMP_WEEK]);
aconf->port = TEMP_WEEK;
}
else if(aconf->hold >= CurrentTime + (1440 * 60))
{
- dlinkAddAlloc(aconf, &temp_dlines[TEMP_DAY]);
+ rb_dlinkAddAlloc(aconf, &temp_dlines[TEMP_DAY]);
aconf->port = TEMP_DAY;
}
else if(aconf->hold >= CurrentTime + (60 * 60))
{
- dlinkAddAlloc(aconf, &temp_dlines[TEMP_HOUR]);
+ rb_dlinkAddAlloc(aconf, &temp_dlines[TEMP_HOUR]);
aconf->port = TEMP_HOUR;
}
else
{
- dlinkAddAlloc(aconf, &temp_dlines[TEMP_MIN]);
+ rb_dlinkAddAlloc(aconf, &temp_dlines[TEMP_MIN]);
aconf->port = TEMP_MIN;
}
static void
expire_temp_kd(void *list)
{
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
struct ConfItem *aconf;
- DLINK_FOREACH_SAFE(ptr, next_ptr, ((dlink_list *) list)->head)
+ DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
{
aconf = ptr->data;
user : "*", (aconf->host) ? aconf->host : "*");
delete_one_address_conf(aconf->host, aconf);
- dlinkDestroy(ptr, list);
+ rb_dlinkDestroy(ptr, list);
}
}
}
reorganise_temp_kd(void *list)
{
struct ConfItem *aconf;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, ((dlink_list *) list)->head)
+ DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
{
aconf = ptr->data;
if(aconf->hold < (CurrentTime + (60 * 60)))
{
- dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
+ rb_dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
&temp_klines[TEMP_MIN] : &temp_dlines[TEMP_MIN]);
aconf->port = TEMP_MIN;
}
{
if(aconf->hold < (CurrentTime + (1440 * 60)))
{
- dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
+ rb_dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
&temp_klines[TEMP_HOUR] : &temp_dlines[TEMP_HOUR]);
aconf->port = TEMP_HOUR;
}
else if(aconf->port > TEMP_DAY &&
(aconf->hold < (CurrentTime + (10080 * 60))))
{
- dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
+ rb_dlinkMoveNode(ptr, list, (aconf->status == CONF_KILL) ?
&temp_klines[TEMP_DAY] : &temp_dlines[TEMP_DAY]);
aconf->port = TEMP_DAY;
}
clear_out_old_conf(void)
{
struct Class *cltmp;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
/*
* don't delete the class table, rather mark all entries
DLINK_FOREACH_SAFE(ptr, next_ptr, service_list.head)
{
MyFree(ptr->data);
- dlinkDestroy(ptr, &service_list);
+ rb_dlinkDestroy(ptr, &service_list);
}
/* remove any aliases... -- nenolod */
#include "event.h"
#include "memory.h"
-dlink_list glines;
+rb_dlink_list glines;
static void expire_glines(void);
static void expire_pending_glines(void);
void
add_gline(struct ConfItem *aconf)
{
- dlinkAddTailAlloc(aconf, &glines);
+ rb_dlinkAddTailAlloc(aconf, &glines);
add_conf_by_address(aconf->host, CONF_GLINE, aconf->user, aconf);
}
struct ConfItem *
find_is_glined(const char *host, const char *user)
{
- dlink_node *gline_node;
+ rb_dlink_node *gline_node;
struct ConfItem *kill_ptr;
DLINK_FOREACH(gline_node, glines.head)
static void
expire_glines()
{
- dlink_node *gline_node;
- dlink_node *next_node;
+ rb_dlink_node *gline_node;
+ rb_dlink_node *next_node;
struct ConfItem *kill_ptr;
DLINK_FOREACH_SAFE(gline_node, next_node, glines.head)
if(kill_ptr->hold > CurrentTime)
break;
- dlinkDestroy(gline_node, &glines);
+ rb_dlinkDestroy(gline_node, &glines);
delete_one_address_conf(kill_ptr->host, kill_ptr);
}
}
static void
expire_pending_glines()
{
- dlink_node *pending_node;
- dlink_node *next_node;
+ rb_dlink_node *pending_node;
+ rb_dlink_node *next_node;
struct gline_pending *glp_ptr;
DLINK_FOREACH_SAFE(pending_node, next_node, pending_glines.head)
MyFree(glp_ptr->reason1);
MyFree(glp_ptr->reason2);
MyFree(glp_ptr);
- dlinkDestroy(pending_node, &pending_glines);
+ rb_dlinkDestroy(pending_node, &pending_glines);
}
}
}
#include "sprintf_irc.h"
#include "irc_dictionary.h"
-dlink_list shared_conf_list;
-dlink_list cluster_conf_list;
-dlink_list oper_conf_list;
-dlink_list hubleaf_conf_list;
-dlink_list server_conf_list;
-dlink_list xline_conf_list;
-dlink_list resv_conf_list; /* nicks only! */
-dlink_list nd_list; /* nick delay */
-dlink_list tgchange_list;
+rb_dlink_list shared_conf_list;
+rb_dlink_list cluster_conf_list;
+rb_dlink_list oper_conf_list;
+rb_dlink_list hubleaf_conf_list;
+rb_dlink_list server_conf_list;
+rb_dlink_list xline_conf_list;
+rb_dlink_list resv_conf_list; /* nicks only! */
+rb_dlink_list nd_list; /* nick delay */
+rb_dlink_list tgchange_list;
patricia_tree_t *tgchange_tree;
clear_s_newconf(void)
{
struct server_conf *server_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, shared_conf_list.head)
{
/* ptr here is ptr->data->node */
- dlinkDelete(ptr, &shared_conf_list);
+ rb_dlinkDelete(ptr, &shared_conf_list);
free_remote_conf(ptr->data);
}
DLINK_FOREACH_SAFE(ptr, next_ptr, cluster_conf_list.head)
{
- dlinkDelete(ptr, &cluster_conf_list);
+ rb_dlinkDelete(ptr, &cluster_conf_list);
free_remote_conf(ptr->data);
}
DLINK_FOREACH_SAFE(ptr, next_ptr, hubleaf_conf_list.head)
{
- dlinkDelete(ptr, &hubleaf_conf_list);
+ rb_dlinkDelete(ptr, &hubleaf_conf_list);
free_remote_conf(ptr->data);
}
DLINK_FOREACH_SAFE(ptr, next_ptr, oper_conf_list.head)
{
free_oper_conf(ptr->data);
- dlinkDestroy(ptr, &oper_conf_list);
+ rb_dlinkDestroy(ptr, &oper_conf_list);
}
DLINK_FOREACH_SAFE(ptr, next_ptr, server_conf_list.head)
if(!server_p->servers)
{
- dlinkDelete(ptr, &server_conf_list);
+ rb_dlinkDelete(ptr, &server_conf_list);
free_server_conf(ptr->data);
}
else
clear_s_newconf_bans(void)
{
struct ConfItem *aconf;
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
{
continue;
free_conf(aconf);
- dlinkDestroy(ptr, &xline_conf_list);
+ rb_dlinkDestroy(ptr, &xline_conf_list);
}
DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
continue;
free_conf(aconf);
- dlinkDestroy(ptr, &resv_conf_list);
+ rb_dlinkDestroy(ptr, &resv_conf_list);
}
clear_resv_hash();
const char *server, int flags)
{
struct remote_conf *shared_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, shared_conf_list.head)
{
char buffer[BUFSIZE];
struct remote_conf *shared_p;
va_list args;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
va_start(args, format);
ircvsnprintf(buffer, sizeof(buffer), format, args);
struct irc_sockaddr_storage ip, cip;
char addr[HOSTLEN+1];
int bits, cbits;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
parse_netmask(locip, (struct sockaddr *)&cip, &cbits);
find_server_conf(const char *name)
{
struct server_conf *server_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, server_conf_list.head)
{
if(MaxUsers(server_p->class) < 0 && CurrUsers(server_p->class) <= 0)
free_class(server_p->class);
- dlinkDelete(&server_p->node, &server_conf_list);
+ rb_dlinkDelete(&server_p->node, &server_conf_list);
free_server_conf(server_p);
}
}
find_xline(const char *gecos, int counter)
{
struct ConfItem *aconf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, xline_conf_list.head)
{
find_xline_mask(const char *gecos)
{
struct ConfItem *aconf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, xline_conf_list.head)
{
find_nick_resv(const char *name)
{
struct ConfItem *aconf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, resv_conf_list.head)
{
find_nick_resv_mask(const char *name)
{
struct ConfItem *aconf;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
DLINK_FOREACH(ptr, resv_conf_list.head)
{
expire_temp_rxlines(void *unused)
{
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)
aconf->name);
free_conf(aconf);
- dlinkDestroy(ptr, &resvTable[i]);
+ rb_dlinkDestroy(ptr, &resvTable[i]);
}
}
HASH_WALK_END
"Temporary RESV for [%s] expired",
aconf->name);
free_conf(aconf);
- dlinkDestroy(ptr, &resv_conf_list);
+ rb_dlinkDestroy(ptr, &resv_conf_list);
}
}
"Temporary X-line for [%s] expired",
aconf->name);
free_conf(aconf);
- dlinkDestroy(ptr, &xline_conf_list);
+ rb_dlinkDestroy(ptr, &xline_conf_list);
}
}
}
unsigned long
get_nd_count(void)
{
- return(dlink_list_length(&nd_list));
+ return(rb_dlink_list_length(&nd_list));
}
void
nd->expire = CurrentTime + ConfigFileEntry.nick_delay;
/* this list is ordered */
- dlinkAddTail(nd, &nd->lnode, &nd_list);
+ rb_dlinkAddTail(nd, &nd->lnode, &nd_list);
irc_dictionary_add(nd_dict, nd->name, nd);
}
{
irc_dictionary_delete(nd_dict, nd->name);
- dlinkDelete(&nd->lnode, &nd_list);
+ rb_dlinkDelete(&nd->lnode, &nd_list);
BlockHeapFree(nd_heap, nd);
}
expire_nd_entries(void *unused)
{
struct nd_entry *nd;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
DLINK_FOREACH_SAFE(ptr, next_ptr, nd_list.head)
{
DupString(target->ip, host);
target->expiry = CurrentTime + (60*60*12);
- dlinkAdd(target, &target->node, &tgchange_list);
+ rb_dlinkAdd(target, &target->node, &tgchange_list);
}
tgchange *
void
collect_zipstats(void *unused)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Client *target_p;
DLINK_FOREACH(ptr, serv_list.head)
{
struct Client *target_p;
int wilds;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
const char *old;
char *new;
struct server_conf *server_p = NULL;
struct server_conf *tmp_p;
struct Class *cltmp;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
int connecting = FALSE;
int confrq = 0;
time_t next = 0;
return;
/* move this connect entry to end.. */
- dlinkDelete(&server_p->node, &server_conf_list);
- dlinkAddTail(server_p, &server_p->node, &server_conf_list);
+ rb_dlinkDelete(&server_p->node, &server_conf_list);
+ rb_dlinkAddTail(server_p, &server_p->node, &server_conf_list);
/*
* We used to only print this if serv_connect() actually
{
struct server_conf *server_p = NULL;
struct server_conf *tmp_p;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
int error = -1;
s_assert(NULL != client_p);
* side effects - client is sent a list of +b, or +e, or +I modes
*/
static void
-burst_modes_TS5(struct Client *client_p, char *chname, dlink_list *list, char flag)
+burst_modes_TS5(struct Client *client_p, char *chname, rb_dlink_list *list, char flag)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Ban *banptr;
char mbuf[MODEBUFLEN];
char pbuf[BUFSIZE];
*/
static void
burst_modes_TS6(struct Client *client_p, struct Channel *chptr,
- dlink_list *list, char flag)
+ rb_dlink_list *list, char flag)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Ban *banptr;
char *t;
int tlen;
struct membership *msptr;
hook_data_client hclientinfo;
hook_data_channel hchaninfo;
- dlink_node *ptr;
- dlink_node *uptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *uptr;
char *t;
int tlen, mlen;
int cur_len = 0;
t += tlen;
}
- if (dlink_list_length(&chptr->members) > 0)
+ if (rb_dlink_list_length(&chptr->members) > 0)
{
/* remove trailing space */
t--;
struct membership *msptr;
hook_data_client hclientinfo;
hook_data_channel hchaninfo;
- dlink_node *ptr;
- dlink_node *uptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *uptr;
char *t;
int tlen, mlen;
int cur_len = 0;
t += tlen;
}
- if (dlink_list_length(&chptr->members) > 0)
+ if (rb_dlink_list_length(&chptr->members) > 0)
{
/* remove trailing space */
*(t-1) = '\0';
}
sendto_one(client_p, "%s", buf);
- if(dlink_list_length(&chptr->banlist) > 0)
+ if(rb_dlink_list_length(&chptr->banlist) > 0)
burst_modes_TS6(client_p, chptr, &chptr->banlist, 'b');
if(IsCapable(client_p, CAP_EX) &&
- dlink_list_length(&chptr->exceptlist) > 0)
+ rb_dlink_list_length(&chptr->exceptlist) > 0)
burst_modes_TS6(client_p, chptr, &chptr->exceptlist, 'e');
if(IsCapable(client_p, CAP_IE) &&
- dlink_list_length(&chptr->invexlist) > 0)
+ rb_dlink_list_length(&chptr->invexlist) > 0)
burst_modes_TS6(client_p, chptr, &chptr->invexlist, 'I');
- if(dlink_list_length(&chptr->quietlist) > 0)
+ if(rb_dlink_list_length(&chptr->quietlist) > 0)
burst_modes_TS6(client_p, chptr, &chptr->quietlist, 'q');
if(IsCapable(client_p, CAP_TB) && chptr->topic != NULL)
struct server_conf *server_p;
hook_data_client hdata;
char *host;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
s_assert(NULL != client_p);
if(client_p == NULL)
/* Update the capability combination usage counts */
set_chcap_usage_counts(client_p);
- dlinkAdd(client_p, &client_p->lnode, &me.serv->servers);
+ rb_dlinkAdd(client_p, &client_p->lnode, &me.serv->servers);
del_unknown_ip(client_p);
- dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &serv_list);
- dlinkAddTailAlloc(client_p, &global_serv_list);
+ rb_dlinkMoveNode(&client_p->localClient->tnode, &unknown_list, &serv_list);
+ rb_dlinkAddTailAlloc(client_p, &global_serv_list);
if(has_id(client_p))
add_to_id_hash(client_p->id, client_p);
client_p->localClient->firsttime = CurrentTime;
/* fixing eob timings.. -gnp */
- if((dlink_list_length(&lclient_list) + dlink_list_length(&serv_list)) >
+ if((rb_dlink_list_length(&lclient_list) + rb_dlink_list_length(&serv_list)) >
(unsigned long)MaxConnectionCount)
- MaxConnectionCount = dlink_list_length(&lclient_list) +
- dlink_list_length(&serv_list);
+ MaxConnectionCount = rb_dlink_list_length(&lclient_list) +
+ rb_dlink_list_length(&serv_list);
/* Show the real host/IP to admins */
sendto_realops_snomask(SNO_GENERAL, L_ALL,
client_p->serv->user = NULL;
}
SetConnecting(client_p);
- dlinkAddTail(client_p, &client_p->node, &global_client_list);
+ rb_dlinkAddTail(client_p, &client_p->node, &global_client_list);
if(ServerConfVhosted(server_p))
{
struct Client *target_p;
struct ServerStatistics *sp;
struct ServerStatistics tmp;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
sp = &tmp;
memcpy(sp, ServerStats, sizeof(struct ServerStatistics));
"T :accepts %u refused %u", sp->is_ac, sp->is_ref);
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"T :rejected %u delaying %lu",
- sp->is_rej, dlink_list_length(&delay_exit));
+ sp->is_rej, rb_dlink_list_length(&delay_exit));
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"T :nicks being delayed %lu",
get_nd_count());
"T :numerics seen %u", sp->is_num);
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"T :tgchange blocked msgs %u restricted addrs %lu",
- sp->is_tgch, dlink_list_length(&tgchange_list));
+ sp->is_tgch, rb_dlink_list_length(&tgchange_list));
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"T :auth successes %u fails %u",
sp->is_asuc, sp->is_abad);
struct Client *target_p;
struct Channel *chptr;
struct Ban *actualBan;
- dlink_node *dlink;
- dlink_node *ptr;
+ rb_dlink_node *rb_dlink;
+ rb_dlink_node *ptr;
int channel_count = 0;
int local_client_conf_count = 0; /* local client conf links */
int users_counted = 0; /* user structs */
if(target_p->user)
{
users_counted++;
- users_invited_count += dlink_list_length(&target_p->user->invited);
- user_channels += dlink_list_length(&target_p->user->channel);
+ users_invited_count += rb_dlink_list_length(&target_p->user->invited);
+ user_channels += rb_dlink_list_length(&target_p->user->channel);
if(target_p->user->away)
{
aways_counted++;
channel_count++;
channel_memory += (strlen(chptr->chname) + sizeof(struct Channel));
- channel_users += dlink_list_length(&chptr->members);
- channel_invites += dlink_list_length(&chptr->invites);
+ channel_users += rb_dlink_list_length(&chptr->members);
+ channel_invites += rb_dlink_list_length(&chptr->invites);
- DLINK_FOREACH(dlink, chptr->banlist.head)
+ DLINK_FOREACH(rb_dlink, chptr->banlist.head)
{
- actualBan = dlink->data;
+ actualBan = rb_dlink->data;
channel_bans++;
- channel_ban_memory += sizeof(dlink_node) + sizeof(struct Ban);
+ channel_ban_memory += sizeof(rb_dlink_node) + sizeof(struct Ban);
}
- DLINK_FOREACH(dlink, chptr->exceptlist.head)
+ DLINK_FOREACH(rb_dlink, chptr->exceptlist.head)
{
- actualBan = dlink->data;
+ actualBan = rb_dlink->data;
channel_except++;
- channel_except_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+ channel_except_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
}
- DLINK_FOREACH(dlink, chptr->invexlist.head)
+ DLINK_FOREACH(rb_dlink, chptr->invexlist.head)
{
- actualBan = dlink->data;
+ actualBan = rb_dlink->data;
channel_invex++;
- channel_invex_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+ channel_invex_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
}
- DLINK_FOREACH(dlink, chptr->quietlist.head)
+ DLINK_FOREACH(rb_dlink, chptr->quietlist.head)
{
- actualBan = dlink->data;
+ actualBan = rb_dlink->data;
channel_quiets++;
- channel_quiet_memory += (sizeof(dlink_node) + sizeof(struct Ban));
+ channel_quiet_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
}
}
/* count up all classes */
- class_count = dlink_list_length(&class_list) + 1;
+ class_count = rb_dlink_list_length(&class_list) + 1;
count_linebuf_memory(&linebuf_count, &linebuf_memory_used);
users_counted,
(unsigned long) users_counted * sizeof(struct User),
users_invited_count,
- (unsigned long) users_invited_count * sizeof(dlink_node));
+ (unsigned long) users_invited_count * sizeof(rb_dlink_node));
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :User channels %u(%lu) Aways %u(%d)",
user_channels,
- (unsigned long) user_channels * sizeof(dlink_node),
+ (unsigned long) user_channels * sizeof(rb_dlink_node),
aways_counted, (int) away_memory);
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :Attached confs %u(%lu)",
local_client_conf_count,
- (unsigned long) local_client_conf_count * sizeof(dlink_node));
+ (unsigned long) local_client_conf_count * sizeof(rb_dlink_node));
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :Conflines %u(%d)", conf_count, (int) conf_memory);
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :Channel members %u(%lu) invite %u(%lu)",
channel_users,
- (unsigned long) channel_users * sizeof(dlink_node),
+ (unsigned long) channel_users * sizeof(rb_dlink_node),
channel_invites,
- (unsigned long) channel_invites * sizeof(dlink_node));
+ (unsigned long) channel_invites * sizeof(rb_dlink_node));
total_channel_memory = channel_memory +
channel_ban_memory +
- channel_users * sizeof(dlink_node) + channel_invites * sizeof(dlink_node);
+ channel_users * sizeof(rb_dlink_node) + channel_invites * sizeof(rb_dlink_node);
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :Whowas array %ld(%ld)",
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :Hash: client %u(%ld) chan %u(%ld)",
- U_MAX, (long)(U_MAX * sizeof(dlink_list)),
- CH_MAX, (long)(CH_MAX * sizeof(dlink_list)));
+ U_MAX, (long)(U_MAX * sizeof(rb_dlink_list)),
+ CH_MAX, (long)(CH_MAX * sizeof(rb_dlink_list)));
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :linebuf %ld(%ld)",
sendto_one_numeric(source_p, RPL_STATSDEBUG,
"z :hostname hash %d(%ld)",
- HOST_MAX, (long)HOST_MAX * sizeof(dlink_list));
+ HOST_MAX, (long)HOST_MAX * sizeof(rb_dlink_list));
total_memory = totww + total_channel_memory + conf_memory +
class_count * sizeof(struct Class);
int
show_lusers(struct Client *source_p)
{
- if(dlink_list_length(&lclient_list) > (unsigned long)MaxClientCount)
- MaxClientCount = dlink_list_length(&lclient_list);
+ if(rb_dlink_list_length(&lclient_list) > (unsigned long)MaxClientCount)
+ MaxClientCount = rb_dlink_list_length(&lclient_list);
- if((dlink_list_length(&lclient_list) + dlink_list_length(&serv_list)) >
+ if((rb_dlink_list_length(&lclient_list) + rb_dlink_list_length(&serv_list)) >
(unsigned long)MaxConnectionCount)
- MaxConnectionCount = dlink_list_length(&lclient_list) +
- dlink_list_length(&serv_list);
+ MaxConnectionCount = rb_dlink_list_length(&lclient_list) +
+ rb_dlink_list_length(&serv_list);
sendto_one_numeric(source_p, RPL_LUSERCLIENT, form_str(RPL_LUSERCLIENT),
(Count.total - Count.invisi),
- Count.invisi, dlink_list_length(&global_serv_list));
+ Count.invisi, rb_dlink_list_length(&global_serv_list));
- if(dlink_list_length(&oper_list) > 0)
+ if(rb_dlink_list_length(&oper_list) > 0)
sendto_one_numeric(source_p, RPL_LUSEROP,
- form_str(RPL_LUSEROP), dlink_list_length(&oper_list));
+ form_str(RPL_LUSEROP), rb_dlink_list_length(&oper_list));
- if(dlink_list_length(&unknown_list) > 0)
+ if(rb_dlink_list_length(&unknown_list) > 0)
sendto_one_numeric(source_p, RPL_LUSERUNKNOWN,
form_str(RPL_LUSERUNKNOWN),
- dlink_list_length(&unknown_list));
+ rb_dlink_list_length(&unknown_list));
- if(dlink_list_length(&global_channel_list) > 0)
+ if(rb_dlink_list_length(&global_channel_list) > 0)
sendto_one_numeric(source_p, RPL_LUSERCHANNELS,
form_str(RPL_LUSERCHANNELS),
- dlink_list_length(&global_channel_list));
+ rb_dlink_list_length(&global_channel_list));
sendto_one_numeric(source_p, RPL_LUSERME, form_str(RPL_LUSERME),
- dlink_list_length(&lclient_list),
- dlink_list_length(&serv_list));
+ rb_dlink_list_length(&lclient_list),
+ rb_dlink_list_length(&serv_list));
sendto_one_numeric(source_p, RPL_LOCALUSERS,
form_str(RPL_LOCALUSERS),
- dlink_list_length(&lclient_list),
+ rb_dlink_list_length(&lclient_list),
Count.max_loc,
- dlink_list_length(&lclient_list),
+ rb_dlink_list_length(&lclient_list),
Count.max_loc);
sendto_one_numeric(source_p, RPL_GLOBALUSERS, form_str(RPL_GLOBALUSERS),
return -1;
/* still has DNSbls to validate against */
- if(dlink_list_length(&source_p->preClient->dnsbl_queries) > 0)
+ if(rb_dlink_list_length(&source_p->preClient->dnsbl_queries) > 0)
return -1;
client_p->localClient->last = CurrentTime;
* -Taner
*/
/* Except "F:" clients */
- if(dlink_list_length(&lclient_list) >=
+ if(rb_dlink_list_length(&lclient_list) >=
(unsigned long)GlobalSetOptions.maxclients && !IsConfExemptLimits(aconf))
{
sendto_realops_snomask(SNO_FULL, L_ALL,
source_p->sockhost, source_p->preClient->dnsbl_listed->host);
else
{
- dlink_list varlist = { NULL, NULL, 0 };
+ rb_dlink_list varlist = { NULL, NULL, 0 };
substitution_append_var(&varlist, "nick", source_p->name);
substitution_append_var(&varlist, "ip", source_p->sockhost);
s_assert(!IsClient(source_p));
del_unknown_ip(source_p);
- dlinkMoveNode(&source_p->localClient->tnode, &unknown_list, &lclient_list);
+ rb_dlinkMoveNode(&source_p->localClient->tnode, &unknown_list, &lclient_list);
SetClient(source_p);
source_p->servptr = &me;
- dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->users);
+ rb_dlinkAdd(source_p, &source_p->lnode, &source_p->servptr->serv->users);
/* Increment our total user count here */
if(++Count.total > Count.max_tot)
s_assert(source_p->localClient != NULL);
- if(dlink_list_length(&lclient_list) > (unsigned long)Count.max_loc)
+ if(rb_dlink_list_length(&lclient_list) > (unsigned long)Count.max_loc)
{
- Count.max_loc = dlink_list_length(&lclient_list);
+ Count.max_loc = rb_dlink_list_length(&lclient_list);
if(!(Count.max_loc % 10))
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"New Max Local Clients: %d", Count.max_loc);
{
++Count.oper;
SetOper(source_p);
- dlinkAddAlloc(source_p, &oper_list);
+ rb_dlinkAddAlloc(source_p, &oper_list);
}
}
else
MyFree(source_p->localClient->opername);
source_p->localClient->opername = NULL;
- dlinkFindDestroy(source_p, &local_oper_list);
+ rb_dlinkFindDestroy(source_p, &local_oper_list);
}
- dlinkFindDestroy(source_p, &oper_list);
+ rb_dlinkFindDestroy(source_p, &oper_list);
}
break;
{
struct Client *target_p;
char buf[BUFSIZE];
- dlink_node *ptr;
+ rb_dlink_node *ptr;
send_umode(NULL, source_p, old, 0, buf);
source_p->flags2 |= oper_p->flags;
DupString(source_p->localClient->opername, oper_p->name);
- dlinkAddAlloc(source_p, &local_oper_list);
- dlinkAddAlloc(source_p, &oper_list);
+ rb_dlinkAddAlloc(source_p, &local_oper_list);
+ rb_dlinkAddAlloc(source_p, &oper_list);
if(IsOperAdmin(source_p) && !IsOperHiddenAdmin(source_p))
source_p->umodes |= UMODE_ADMIN;
change_nick_user_host(struct Client *target_p, const char *nick, const char *user,
const char *host, int newts, char *format, ...)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Channel *chptr;
struct membership *mscptr;
int changed = irccmp(target_p->name, nick);
{
va_list args;
struct Client *target_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
buf_head_t linebuf;
/* noone to send to.. */
- if(dlink_list_length(&serv_list) == 0)
+ if(rb_dlink_list_length(&serv_list) == 0)
return;
if(chptr != NULL && *chptr->chname != '#')
buf_head_t linebuf_id;
struct Client *target_p;
struct membership *msptr;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
linebuf_newbuf(&linebuf_local);
linebuf_newbuf(&linebuf_name);
buf_head_t linebuf;
struct membership *msptr;
struct Client *target_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
linebuf_newbuf(&linebuf);
buf_head_t linebuf;
struct membership *msptr;
struct Client *target_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
linebuf_newbuf(&linebuf);
sendto_common_channels_local(struct Client *user, const char *pattern, ...)
{
va_list args;
- dlink_node *ptr;
- dlink_node *next_ptr;
- dlink_node *uptr;
- dlink_node *next_uptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
+ rb_dlink_node *uptr;
+ rb_dlink_node *next_uptr;
struct Channel *chptr;
struct Client *target_p;
struct membership *msptr;
sendto_common_channels_local_butone(struct Client *user, const char *pattern, ...)
{
va_list args;
- dlink_node *ptr;
- dlink_node *next_ptr;
- dlink_node *uptr;
- dlink_node *next_uptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
+ rb_dlink_node *uptr;
+ rb_dlink_node *next_uptr;
struct Channel *chptr;
struct Client *target_p;
struct membership *msptr;
static char buf[BUFSIZE];
va_list args;
struct Client *target_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
buf_head_t linebuf_local;
buf_head_t linebuf_name;
buf_head_t linebuf_id;
{
static char buf[BUFSIZE];
va_list args;
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct Client *target_p;
buf_head_t linebuf_id;
buf_head_t linebuf_name;
va_list args;
buf_head_t linebuf;
struct Client *target_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
linebuf_newbuf(&linebuf);
sendto_realops_flags(int flags, int level, const char *pattern, ...)
{
struct Client *client_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
va_list args;
buf_head_t linebuf;
static char buf[BUFSIZE];
char *snobuf;
struct Client *client_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
va_list args;
buf_head_t linebuf;
const char *pattern, ...)
{
struct Client *client_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
va_list args;
buf_head_t linebuf;
sendto_wallops_flags(int flags, struct Client *source_p, const char *pattern, ...)
{
struct Client *client_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
va_list args;
buf_head_t linebuf;
static char buf[BUFSIZE];
va_list args;
struct Client *client_p;
- dlink_node *ptr;
- dlink_node *next_ptr;
+ rb_dlink_node *ptr;
+ rb_dlink_node *next_ptr;
buf_head_t linebuf_id;
buf_head_t linebuf_name;
/*
* substitution_append_var
*
- * Inputs - A variable list (dlink_list), name -> value for mapping to make
+ * Inputs - A variable list (rb_dlink_list), name -> value for mapping to make
* Output - none
* Side Effects - Adds a name->value mapping to a list.
*/
-void substitution_append_var(dlink_list *varlist, const char *name, const char *value)
+void substitution_append_var(rb_dlink_list *varlist, const char *name, const char *value)
{
struct substitution_variable *tmp = MyMalloc(sizeof(struct substitution_variable));
DupString(tmp->name, name);
DupString(tmp->value, value);
- dlinkAddAlloc(tmp, varlist);
+ rb_dlinkAddAlloc(tmp, varlist);
}
/*
* substitution_free
*
- * Inputs - A dlink_list of markup variables to free.
+ * Inputs - A rb_dlink_list of markup variables to free.
* Outputs - none
* Side Effects - Empties a list of markup variables.
*/
-void substitution_free(dlink_list *varlist)
+void substitution_free(rb_dlink_list *varlist)
{
- dlink_node *nptr, *nptr2;
+ rb_dlink_node *nptr, *nptr2;
DLINK_FOREACH_SAFE(nptr, nptr2, varlist->head)
{
struct substitution_variable *tmp = (struct substitution_variable *) nptr->data;
- dlinkDelete(nptr, varlist);
+ rb_dlinkDelete(nptr, varlist);
MyFree(tmp->name);
MyFree(tmp->value);
MyFree(tmp);
/*
* substitution_parse
*
- * Inputs - A markup string, dlink-list of markup values
+ * Inputs - A markup string, rb_dlink-list of markup values
* Output - A string which has been markup-replaced.
* Side Effects - Strings larger than BUFSIZE are terminated.
*/
-char *substitution_parse(const char *fmt, dlink_list *varlist)
+char *substitution_parse(const char *fmt, rb_dlink_list *varlist)
{
static char buf[BUFSIZE];
const char *ptr;
static char varname[BUFSIZE];
char *vptr = varname;
const char *pptr;
- dlink_node *nptr;
+ rb_dlink_node *nptr;
*vptr = '\0';
#include "s_conf.h"
#include "supported.h"
-dlink_list isupportlist;
+rb_dlink_list isupportlist;
struct isupportitem
{
const char *name;
const char *(*func)(const void *);
const void *param;
- dlink_node node;
+ rb_dlink_node node;
};
void
item->name = name;
item->func = func;
item->param = param;
- dlinkAddTail(item, &item->node, &isupportlist);
+ rb_dlinkAddTail(item, &item->node, &isupportlist);
}
void
delete_isupport(const char *name)
{
- dlink_node *ptr, *next_ptr;
+ rb_dlink_node *ptr, *next_ptr;
struct isupportitem *item;
DLINK_FOREACH_SAFE(ptr, next_ptr, isupportlist.head)
if (!strcmp(item->name, name))
{
- dlinkDelete(ptr, &isupportlist);
+ rb_dlinkDelete(ptr, &isupportlist);
MyFree(item);
}
}
void
show_isupport(struct Client *client_p)
{
- dlink_node *ptr;
+ rb_dlink_node *ptr;
struct isupportitem *item;
const char *value;
char buf[512];
ConfigChannel.use_except ? "e" : "",
ConfigChannel.use_invex ? "I" : "",
ConfigChannel.use_forward ? "f" : "",
- dlink_list_length(&service_list) ? "r" : "",
+ rb_dlink_list_length(&service_list) ? "r" : "",
ConfigChannel.use_forward ? "QF" : "");
return result;
}
projects / irc / rqf / shadowircd.git / commitdiff
