*/
if(rb_dlink_list_length(&chptr->members) < rb_dlink_list_length(&client_p->user->channel))
{
- DLINK_FOREACH(ptr, chptr->members.head)
+ RB_DLINK_FOREACH(ptr, chptr->members.head)
{
msptr = ptr->data;
}
else
{
- DLINK_FOREACH(ptr, client_p->user->channel.head)
+ RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = ptr->data;
if(client_p == NULL)
return;
- DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->user->channel.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->user->channel.head)
{
msptr = ptr->data;
chptr = msptr->chptr;
if(client_p == NULL)
return;
- DLINK_FOREACH(ptr, client_p->user->channel.head)
+ RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = ptr->data;
msptr->bants = 0;
rb_dlink_node *next_ptr;
struct Ban *actualBan;
- DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
{
actualBan = ptr->data;
free_ban(actualBan);
{
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->invites.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->invites.head)
{
del_invite(chptr, ptr->data);
}
t = lbuf + cur_len;
- DLINK_FOREACH(ptr, chptr->members.head)
+ RB_DLINK_FOREACH(ptr, chptr->members.head)
{
msptr = ptr->data;
target_p = msptr->client_p;
}
}
- DLINK_FOREACH(ptr, chptr->banlist.head)
+ RB_DLINK_FOREACH(ptr, chptr->banlist.head)
{
actualBan = ptr->data;
if(match(actualBan->banstr, s) ||
if((actualBan != NULL) && ConfigChannel.use_except)
{
- DLINK_FOREACH(ptr, chptr->exceptlist.head)
+ RB_DLINK_FOREACH(ptr, chptr->exceptlist.head)
{
actualExcept = ptr->data;
}
}
- DLINK_FOREACH(ptr, chptr->quietlist.head)
+ RB_DLINK_FOREACH(ptr, chptr->quietlist.head)
{
actualBan = ptr->data;
if(match(actualBan->banstr, s) ||
if((actualBan != NULL) && ConfigChannel.use_except)
{
- DLINK_FOREACH(ptr, chptr->exceptlist.head)
+ RB_DLINK_FOREACH(ptr, chptr->exceptlist.head)
{
actualExcept = ptr->data;
if(chptr->mode.mode & MODE_INVITEONLY)
{
- DLINK_FOREACH(invite, source_p->user->invited.head)
+ RB_DLINK_FOREACH(invite, source_p->user->invited.head)
{
if(invite->data == chptr)
break;
{
if(!ConfigChannel.use_invex)
return (ERR_INVITEONLYCHAN);
- DLINK_FOREACH(ptr, chptr->invexlist.head)
+ RB_DLINK_FOREACH(ptr, chptr->invexlist.head)
{
invex = ptr->data;
if(match(invex->banstr, src_host)
/* allow /invite to override +l/+r/+j also -- jilles */
if (i != 0 && invite == NULL)
{
- DLINK_FOREACH(invite, source_p->user->invited.head)
+ RB_DLINK_FOREACH(invite, source_p->user->invited.head)
{
if(invite->data == chptr)
break;
rb_sprintf(src_host, "%s!%s@%s", client_p->name, client_p->username, client_p->host);
rb_sprintf(src_iphost, "%s!%s@%s", client_p->name, client_p->username, client_p->sockhost);
- DLINK_FOREACH(ptr, client_p->user->channel.head)
+ RB_DLINK_FOREACH(ptr, client_p->user->channel.head)
{
msptr = ptr->data;
chptr = msptr->chptr;
return 0;
}
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
actualBan = ptr->data;
if(mask_match(actualBan->banstr, realban))
/* dont let remotes set duplicates */
else
{
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
actualBan = ptr->data;
if(!irccmp(actualBan->banstr, realban))
if(EmptyString(banid))
return 0;
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
banptr = ptr->data;
return;
}
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
banptr = ptr->data;
sendto_one(source_p, form_str(rpl_list),
if(classname == NULL)
return default_class;
- DLINK_FOREACH(ptr, class_list.head)
+ RB_DLINK_FOREACH(ptr, class_list.head)
{
cltmp = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, class_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, class_list.head)
{
cltmp = ptr->data;
struct Class *cltmp;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, class_list.head)
+ RB_DLINK_FOREACH(ptr, class_list.head)
{
cltmp = ptr->data;
int ping = 0; /* ping time value from client */
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
{
client_p = ptr->data;
struct Client *client_p;
int timeout;
- DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, list->head)
{
client_p = ptr->data;
struct ConfItem *aconf = NULL;
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
client_p = ptr->data;
}
/* also check the unknowns list for new dlines */
- DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
{
client_p = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
client_p = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
client_p = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
client_p = ptr->data;
}
/* dlines need to be checked against unknowns too */
- DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head)
{
client_p = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
client_p = ptr->data;
rb_dlink_node *ptr, *next;
struct Client *target_p;
- DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, dead_list.head)
{
target_p = ptr->data;
rb_dlink_node *aptr;
int found = 0;
- DLINK_FOREACH(aptr, abort_list.head)
+ RB_DLINK_FOREACH(aptr, abort_list.head)
{
abt = aptr->data;
if(abt->client == target_p)
}
#ifdef DEBUG_EXITED_CLIENTS
- DLINK_FOREACH_SAFE(ptr, next, dead_remote_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, dead_remote_list.head)
{
target_p = ptr->data;
}
else
{
- DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
{
target_p = ptr->data;
sendto_one(to, ":%s QUIT :%s", target_p->name, comment1);
}
- DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->servers.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->servers.head)
{
target_p = ptr->data;
recurse_send_quits(client_p, target_p, to, comment1, comment);
/* this is very ugly, but it saves cpu :P */
if(ConfigFileEntry.nick_delay > 0)
{
- DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
{
target_p = ptr->data;
target_p->flags |= FLAGS_KILLED;
}
else
{
- DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->users.head)
{
target_p = ptr->data;
target_p->flags |= FLAGS_KILLED;
}
}
- DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->servers.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->servers.head)
{
target_p = ptr->data;
recurse_remove_clients(target_p, comment);
struct Client *to;
rb_dlink_node *ptr, *next;
- DLINK_FOREACH_SAFE(ptr, next, serv_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, serv_list.head)
{
to = ptr->data;
{
struct abort_client *abt;
rb_dlink_node *ptr, *next;
- DLINK_FOREACH_SAFE(ptr, next, abort_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, abort_list.head)
{
abt = ptr->data;
s_assert(source_p->user->channel.head == NULL);
/* Clean up invitefield */
- DLINK_FOREACH_SAFE(ptr, next_ptr, source_p->user->invited.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, source_p->user->invited.head)
{
del_invite(ptr->data, source_p);
}
/* clear this clients accept list, and remove them from
* everyones on_accept_list
*/
- DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->allow_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->allow_list.head)
{
target_p = ptr->data;
rb_dlinkFindDestroy(client_p, &target_p->on_allow_list);
}
/* remove this client from everyones accept list */
- DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->on_allow_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->on_allow_list.head)
{
target_p = ptr->data;
rb_dlinkFindDestroy(client_p, &target_p->localClient->allow_list);
hashv = hash_id(name);
- DLINK_FOREACH(ptr, idTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, idTable[hashv].head)
{
target_p = ptr->data;
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
hashv = hash_nick(name);
- DLINK_FOREACH(ptr, clientTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, clientTable[hashv].head)
{
target_p = ptr->data;
hashv = hash_channel(name);
- DLINK_FOREACH(ptr, channelTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, channelTable[hashv].head)
{
chptr = ptr->data;
hashv = hash_channel(s);
- DLINK_FOREACH(ptr, channelTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, channelTable[hashv].head)
{
chptr = ptr->data;
hashv = hash_resv(name);
- DLINK_FOREACH(ptr, resvTable[hashv].head)
+ RB_DLINK_FOREACH(ptr, resvTable[hashv].head)
{
aconf = ptr->data;
/* The ID we were passed is the position in the hook table of this
* hook
*/
- DLINK_FOREACH(ptr, hooks[id].hooks.head)
+ RB_DLINK_FOREACH(ptr, hooks[id].hooks.head)
{
fn = ptr->data;
fn(arg);
s_assert(dtree != NULL);
- DLINK_FOREACH_SAFE(n, tn, dtree->head)
+ RB_DLINK_FOREACH_SAFE(n, tn, dtree->head)
{
if (destroy_cb != NULL)
(*destroy_cb)(n, privdata);
s_assert(dtree != NULL);
- DLINK_FOREACH_SAFE(n, tn, dtree->head)
+ RB_DLINK_FOREACH_SAFE(n, tn, dtree->head)
{
/* delem_t is a subclass of node_t. */
struct DictionaryElement *delem = (struct DictionaryElement *) n;
s_assert(dtree != NULL);
- DLINK_FOREACH_SAFE(n, tn, dtree->head)
+ RB_DLINK_FOREACH_SAFE(n, tn, dtree->head)
{
/* delem_t is a subclass of node_t. */
struct DictionaryElement *delem = (struct DictionaryElement *) n;
rb_dlink_node *ptr;
struct module_path *mpath;
- DLINK_FOREACH(ptr, mod_paths.head)
+ RB_DLINK_FOREACH(ptr, mod_paths.head)
{
mpath = ptr->data;
{
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, mod_paths.head)
{
MyFree(ptr->data);
free_rb_dlink_node(ptr);
if (server_state_foreground == 1)
inotice("loading module %s ...", path);
- DLINK_FOREACH(pathst, mod_paths.head)
+ RB_DLINK_FOREACH(pathst, mod_paths.head)
{
mpath = pathst->data;
struct monitor *monptr;
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->monitor_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, client_p->localClient->monitor_list.head)
{
monptr = ptr->data;
rb_dlink_node *d;
struct TopConf *tc;
- DLINK_FOREACH(d, conf_items.head)
+ RB_DLINK_FOREACH(d, conf_items.head)
{
tc = d->data;
if(strcasecmp(tc->tc_name, name) == 0)
}
}
- DLINK_FOREACH(d, top->tc_items.head)
+ RB_DLINK_FOREACH(d, top->tc_items.head)
{
cf = d->data;
if(strcasecmp(cf->cf_name, name) == 0)
yy_oper = NULL;
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
{
free_oper_conf(ptr->data);
rb_dlinkDestroy(ptr, &yy_oper_list);
* and host in, yy_oper contains the rest of the information which
* we need to copy into each element in yy_oper_list
*/
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
{
yy_tmpoper = ptr->data;
if(yy_aconf)
free_conf(yy_aconf);
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
{
free_conf(ptr->data);
rb_dlinkDestroy(ptr, &yy_aconf_list);
conf_add_class_to_conf(yy_aconf);
add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf);
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
{
yy_tmp = ptr->data;
{
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
{
free_remote_conf(ptr->data);
rb_dlinkDestroy(ptr, &yy_shared_list);
set_modes_from_table(&flags, "flag", shared_table, args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
{
yy_shared = ptr->data;
{
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
{
free_remote_conf(ptr->data);
rb_dlinkDestroy(ptr, &yy_cluster_list);
set_modes_from_table(&flags, "flag", cluster_table, args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
{
yy_shared = ptr->data;
yy_shared->flags = flags;
struct Client *target_p;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, global_serv_list.head)
+ RB_DLINK_FOREACH(ptr, global_serv_list.head)
{
target_p = ptr->data;
struct Client *client_p;
rb_dlink_node *ptr, *ptr_next;
- DLINK_FOREACH_SAFE(ptr, ptr_next, delay_exit.head)
+ RB_DLINK_FOREACH_SAFE(ptr, ptr_next, delay_exit.head)
{
client_p = ptr->data;
if(IsDead(client_p))
patricia_node_t *pnode;
struct reject_data *rdata;
- DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
{
pnode = ptr->data;
rdata = pnode->data;
patricia_node_t *pnode;
struct reject_data *rdata;
- DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
{
pnode = ptr->data;
rdata = pnode->data;
hashv ^= fnv_hash_upper(mask1, 32);
if (mask2 != NULL)
hashv ^= fnv_hash_upper(mask2, 32);
- DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next, reject_list.head)
{
pnode = ptr->data;
rdata = pnode->data;
time_t next_time = 0;
time_t timeout = 0;
- DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
{
request = ptr->data;
timeout = request->sentat + request->timeout;
rb_dlink_node *next_ptr;
struct reslist *request;
- DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, request_list.head)
{
if ((request = ptr->data) != NULL)
{
rb_dlink_node *ptr;
struct reslist *request;
- DLINK_FOREACH(ptr, request_list.head)
+ RB_DLINK_FOREACH(ptr, request_list.head)
{
request = ptr->data;
rb_dlink_node *next_ptr;
struct AuthRequest *auth;
- DLINK_FOREACH_SAFE(ptr, next_ptr, auth_poll_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, auth_poll_list.head)
{
auth = ptr->data;
/* find_hostname() returns the head of the list to search */
- DLINK_FOREACH(ptr, find_hostname(client_p->host))
+ RB_DLINK_FOREACH(ptr, find_hostname(client_p->host))
{
target_p = ptr->data;
rb_dlink_node *next_ptr;
struct ConfItem *aconf;
- DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
{
aconf = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, ((rb_dlink_list *) list)->head)
{
aconf = ptr->data;
* don't delete the class table, rather mark all entries
* for deletion. The table is cleaned up by check_class. - avalon
*/
- DLINK_FOREACH(ptr, class_list.head)
+ RB_DLINK_FOREACH(ptr, class_list.head)
{
cltmp = ptr->data;
MaxUsers(cltmp) = -1;
MyFree(ConfigFileEntry.servlink_path);
ConfigFileEntry.servlink_path = NULL;
- DLINK_FOREACH_SAFE(ptr, next_ptr, service_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, service_list.head)
{
MyFree(ptr->data);
rb_dlinkDestroy(ptr, &service_list);
rb_dlink_node *gline_node;
struct ConfItem *kill_ptr;
- DLINK_FOREACH(gline_node, glines.head)
+ RB_DLINK_FOREACH(gline_node, glines.head)
{
kill_ptr = gline_node->data;
if((kill_ptr->user && (!user || match(kill_ptr->user, user)))
rb_dlink_node *next_node;
struct ConfItem *kill_ptr;
- DLINK_FOREACH_SAFE(gline_node, next_node, glines.head)
+ RB_DLINK_FOREACH_SAFE(gline_node, next_node, glines.head)
{
kill_ptr = gline_node->data;
rb_dlink_node *next_node;
struct gline_pending *glp_ptr;
- DLINK_FOREACH_SAFE(pending_node, next_node, pending_glines.head)
+ RB_DLINK_FOREACH_SAFE(pending_node, next_node, pending_glines.head)
{
glp_ptr = pending_node->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, shared_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, shared_conf_list.head)
{
/* ptr here is ptr->data->node */
rb_dlinkDelete(ptr, &shared_conf_list);
free_remote_conf(ptr->data);
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, cluster_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, cluster_conf_list.head)
{
rb_dlinkDelete(ptr, &cluster_conf_list);
free_remote_conf(ptr->data);
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, hubleaf_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, hubleaf_conf_list.head)
{
rb_dlinkDelete(ptr, &hubleaf_conf_list);
free_remote_conf(ptr->data);
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, oper_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, oper_conf_list.head)
{
free_oper_conf(ptr->data);
rb_dlinkDestroy(ptr, &oper_conf_list);
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, server_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, server_conf_list.head)
{
server_p = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr, *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
{
aconf = ptr->data;
rb_dlinkDestroy(ptr, &xline_conf_list);
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
{
aconf = ptr->data;
struct remote_conf *shared_p;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, shared_conf_list.head)
+ RB_DLINK_FOREACH(ptr, shared_conf_list.head)
{
shared_p = ptr->data;
ircvsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
- DLINK_FOREACH(ptr, cluster_conf_list.head)
+ RB_DLINK_FOREACH(ptr, cluster_conf_list.head)
{
shared_p = ptr->data;
parse_netmask(locip, (struct sockaddr *)&cip, &cbits);
- DLINK_FOREACH(ptr, oper_conf_list.head)
+ RB_DLINK_FOREACH(ptr, oper_conf_list.head)
{
oper_p = ptr->data;
struct server_conf *server_p;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, server_conf_list.head)
+ RB_DLINK_FOREACH(ptr, server_conf_list.head)
{
server_p = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, xline_conf_list.head)
+ RB_DLINK_FOREACH(ptr, xline_conf_list.head)
{
aconf = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, xline_conf_list.head)
+ RB_DLINK_FOREACH(ptr, xline_conf_list.head)
{
aconf = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, resv_conf_list.head)
+ RB_DLINK_FOREACH(ptr, resv_conf_list.head)
{
aconf = ptr->data;
struct ConfItem *aconf;
rb_dlink_node *ptr;
- DLINK_FOREACH(ptr, resv_conf_list.head)
+ RB_DLINK_FOREACH(ptr, resv_conf_list.head)
{
aconf = ptr->data;
}
HASH_WALK_END
- DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
{
aconf = ptr->data;
}
}
- DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
{
aconf = ptr->data;
rb_dlink_node *ptr;
rb_dlink_node *next_ptr;
- DLINK_FOREACH_SAFE(ptr, next_ptr, nd_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, nd_list.head)
{
nd = ptr->data;
rb_dlink_node *ptr;
struct Client *target_p;
- DLINK_FOREACH(ptr, serv_list.head)
+ RB_DLINK_FOREACH(ptr, serv_list.head)
{
target_p = ptr->data;
if(IsCapable(target_p, CAP_ZIP))
{
target_p = NULL;
- DLINK_FOREACH(ptr, global_client_list.head)
+ RB_DLINK_FOREACH(ptr, global_client_list.head)
{
if(match(new, ((struct Client *) (ptr->data))->name))
{
int confrq = 0;
time_t next = 0;
- DLINK_FOREACH(ptr, server_conf_list.head)
+ RB_DLINK_FOREACH(ptr, server_conf_list.head)
{
tmp_p = ptr->data;
if(strlen(name) > HOSTLEN)
return -4;
- DLINK_FOREACH(ptr, server_conf_list.head)
+ RB_DLINK_FOREACH(ptr, server_conf_list.head)
{
tmp_p = ptr->data;
mp = mbuf;
pp = pbuf;
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
banptr = ptr->data;
tlen = strlen(banptr->banstr) + 3;
me.id, (long) chptr->channelts, chptr->chname, flag);
t = buf + mlen;
- DLINK_FOREACH(ptr, list->head)
+ RB_DLINK_FOREACH(ptr, list->head)
{
banptr = ptr->data;
hclientinfo.client = hchaninfo.client = client_p;
- DLINK_FOREACH(ptr, global_client_list.head)
+ RB_DLINK_FOREACH(ptr, global_client_list.head)
{
target_p = ptr->data;
call_hook(h_burst_client, &hclientinfo);
}
- DLINK_FOREACH(ptr, global_channel_list.head)
+ RB_DLINK_FOREACH(ptr, global_channel_list.head)
{
chptr = ptr->data;
t = buf + mlen;
- DLINK_FOREACH(uptr, chptr->members.head)
+ RB_DLINK_FOREACH(uptr, chptr->members.head)
{
msptr = uptr->data;
hclientinfo.client = hchaninfo.client = client_p;
- DLINK_FOREACH(ptr, global_client_list.head)
+ RB_DLINK_FOREACH(ptr, global_client_list.head)
{
target_p = ptr->data;
call_hook(h_burst_client, &hclientinfo);
}
- DLINK_FOREACH(ptr, global_channel_list.head)
+ RB_DLINK_FOREACH(ptr, global_channel_list.head)
{
chptr = ptr->data;
t = buf + mlen;
- DLINK_FOREACH(uptr, chptr->members.head)
+ RB_DLINK_FOREACH(uptr, chptr->members.head)
{
msptr = uptr->data;
** need to send different names to different servers
** (domain name matching) Send new server to other servers.
*/
- DLINK_FOREACH(ptr, serv_list.head)
+ RB_DLINK_FOREACH(ptr, serv_list.head)
{
target_p = ptr->data;
** see previous *WARNING*!!! (Also, original inpath
** is destroyed...)
*/
- DLINK_FOREACH(ptr, global_serv_list.head)
+ RB_DLINK_FOREACH(ptr, global_serv_list.head)
{
target_p = ptr->data;
sp = &tmp;
memcpy(sp, ServerStats, sizeof(struct ServerStatistics));
- DLINK_FOREACH(ptr, serv_list.head)
+ RB_DLINK_FOREACH(ptr, serv_list.head)
{
target_p = ptr->data;
}
}
- DLINK_FOREACH(ptr, lclient_list.head)
+ RB_DLINK_FOREACH(ptr, lclient_list.head)
{
target_p = ptr->data;
}
- DLINK_FOREACH(ptr, unknown_list.head)
+ RB_DLINK_FOREACH(ptr, unknown_list.head)
{
sp->is_ni++;
}
count_whowas_memory(&ww, &wwm);
- DLINK_FOREACH(ptr, global_client_list.head)
+ RB_DLINK_FOREACH(ptr, global_client_list.head)
{
target_p = ptr->data;
if(MyConnect(target_p))
}
/* Count up all channels, ban lists, except lists, Invex lists */
- DLINK_FOREACH(ptr, global_channel_list.head)
+ RB_DLINK_FOREACH(ptr, global_channel_list.head)
{
chptr = ptr->data;
channel_count++;
channel_users += rb_dlink_list_length(&chptr->members);
channel_invites += rb_dlink_list_length(&chptr->invites);
- DLINK_FOREACH(rb_dlink, chptr->banlist.head)
+ RB_DLINK_FOREACH(rb_dlink, chptr->banlist.head)
{
actualBan = rb_dlink->data;
channel_bans++;
channel_ban_memory += sizeof(rb_dlink_node) + sizeof(struct Ban);
}
- DLINK_FOREACH(rb_dlink, chptr->exceptlist.head)
+ RB_DLINK_FOREACH(rb_dlink, chptr->exceptlist.head)
{
actualBan = rb_dlink->data;
channel_except++;
channel_except_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
}
- DLINK_FOREACH(rb_dlink, chptr->invexlist.head)
+ RB_DLINK_FOREACH(rb_dlink, chptr->invexlist.head)
{
actualBan = rb_dlink->data;
channel_invex++;
channel_invex_memory += (sizeof(rb_dlink_node) + sizeof(struct Ban));
}
- DLINK_FOREACH(rb_dlink, chptr->quietlist.head)
+ RB_DLINK_FOREACH(rb_dlink, chptr->quietlist.head)
{
actualBan = rb_dlink->data;
channel_quiets++;
send_umode(NULL, source_p, old, 0, buf);
- DLINK_FOREACH(ptr, serv_list.head)
+ RB_DLINK_FOREACH(ptr, serv_list.head)
{
target_p = ptr->data;
target_p->name, target_p->username, target_p->host,
reason);
- DLINK_FOREACH(ptr, target_p->user->channel.head)
+ RB_DLINK_FOREACH(ptr, target_p->user->channel.head)
{
mscptr = ptr->data;
chptr = mscptr->chptr;
linebuf_putmsg(&linebuf, format, &args, NULL);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, serv_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, serv_list.head)
{
target_p = ptr->data;
linebuf_putmsg(&linebuf_name, NULL, NULL, ":%s %s", source_p->name, buf);
linebuf_putmsg(&linebuf_id, NULL, NULL, ":%s %s", use_id(source_p), buf);
- DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->members.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->members.head)
{
msptr = ptr->data;
target_p = msptr->client_p;
linebuf_putmsg(&linebuf, pattern, &args, NULL);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
{
msptr = ptr->data;
target_p = msptr->client_p;
linebuf_putmsg(&linebuf, pattern, &args, NULL);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, chptr->locmembers.head)
{
msptr = ptr->data;
target_p = msptr->client_p;
++current_serial;
- DLINK_FOREACH_SAFE(ptr, next_ptr, user->user->channel.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, user->user->channel.head)
{
mscptr = ptr->data;
chptr = mscptr->chptr;
- DLINK_FOREACH_SAFE(uptr, next_uptr, chptr->locmembers.head)
+ RB_DLINK_FOREACH_SAFE(uptr, next_uptr, chptr->locmembers.head)
{
msptr = uptr->data;
target_p = msptr->client_p;
/* Skip them -- jilles */
user->serial = current_serial;
- DLINK_FOREACH_SAFE(ptr, next_ptr, user->user->channel.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, user->user->channel.head)
{
mscptr = ptr->data;
chptr = mscptr->chptr;
- DLINK_FOREACH_SAFE(uptr, next_uptr, chptr->locmembers.head)
+ RB_DLINK_FOREACH_SAFE(uptr, next_uptr, chptr->locmembers.head)
{
msptr = uptr->data;
target_p = msptr->client_p;
if(what == MATCH_HOST)
{
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
target_p = ptr->data;
/* what = MATCH_SERVER, if it doesnt match us, just send remote */
else if(match(mask, me.name))
{
- DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, lclient_list.head)
{
target_p = ptr->data;
_send_linebuf(target_p, &linebuf_local);
}
}
- DLINK_FOREACH(ptr, serv_list.head)
+ RB_DLINK_FOREACH(ptr, serv_list.head)
{
target_p = ptr->data;
current_serial++;
- DLINK_FOREACH(ptr, global_serv_list.head)
+ RB_DLINK_FOREACH(ptr, global_serv_list.head)
{
target_p = ptr->data;
linebuf_putmsg(&linebuf, pattern, &args, NULL);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, monptr->users.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, monptr->users.head)
{
target_p = ptr->data;
":%s NOTICE * :*** Notice -- ", me.name);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
{
client_p = ptr->data;
}
level &= ~L_NETWIDE;
- DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
{
client_p = ptr->data;
":%s NOTICE * :*** Notice -- ", source_p->name);
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, local_oper_list.head)
{
client_p = ptr->data;
va_end(args);
- DLINK_FOREACH_SAFE(ptr, next_ptr, IsPerson(source_p) && flags == UMODE_WALLOP ? lclient_list.head : local_oper_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, IsPerson(source_p) && flags == UMODE_WALLOP ? lclient_list.head : local_oper_list.head)
{
client_p = ptr->data;
linebuf_putmsg(&linebuf_id, NULL, NULL, ":%s KILL %s :%s",
use_id(&me), use_id(target_p), buf);
- DLINK_FOREACH_SAFE(ptr, next_ptr, serv_list.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, serv_list.head)
{
client_p = ptr->data;
{
rb_dlink_node *nptr, *nptr2;
- DLINK_FOREACH_SAFE(nptr, nptr2, varlist->head)
+ RB_DLINK_FOREACH_SAFE(nptr, nptr2, varlist->head)
{
struct substitution_variable *tmp = (struct substitution_variable *) nptr->data;
/* advance ptr by length of variable */
ptr += (pptr - ptr);
- DLINK_FOREACH(nptr, varlist->head)
+ RB_DLINK_FOREACH(nptr, varlist->head)
{
struct substitution_variable *val = (struct substitution_variable *) nptr->data;
rb_dlink_node *ptr, *next_ptr;
struct isupportitem *item;
- DLINK_FOREACH_SAFE(ptr, next_ptr, isupportlist.head)
+ RB_DLINK_FOREACH_SAFE(ptr, next_ptr, isupportlist.head)
{
item = ptr->data;
extra_space += strlen(me.name) + 1 + strlen(form_str(RPL_ISUPPORT));
nchars = extra_space, nparams = 0, buf[0] = '\0';
- DLINK_FOREACH(ptr, isupportlist.head)
+ RB_DLINK_FOREACH(ptr, isupportlist.head)
{
item = ptr->data;
value = (*item->func)(item->param);