}
}
ncf2_list[ncf2_used] = handler;
- ncf2_list[ncf2_used++] = extra;
+ ncf2_list_extra[ncf2_used++] = extra;
}
}
static new_channel_func_t *ncf_list;
+static void **ncf_list_extra;
static unsigned int ncf_size = 0, ncf_used = 0;
void
-reg_new_channel_func(new_channel_func_t handler)
+reg_new_channel_func(new_channel_func_t handler, void *extra)
{
if (ncf_used == ncf_size) {
if (ncf_size) {
ncf_size <<= 1;
ncf_list = realloc(ncf_list, ncf_size*sizeof(ncf_list[0]));
+ ncf_list_extra = realloc(ncf_list_extra, ncf_size*sizeof(void*));
} else {
ncf_size = 8;
ncf_list = malloc(ncf_size*sizeof(ncf_list[0]));
+ ncf_list_extra = malloc(ncf_size*sizeof(void*));
}
}
- ncf_list[ncf_used++] = handler;
+ ncf_list[ncf_used] = handler;
+ ncf_list_extra[ncf_used++] = extra;
}
static join_func_t *jf_list;
/* if it's a new or updated channel, make callbacks */
if (rel_age > 0)
for (nn=0; nn<ncf_used; nn++)
- ncf_list[nn](cNode);
+ ncf_list[nn](cNode, ncf_list_extra[nn]);
/* go through list of bans and add each one */
if (banlist && (rel_age >= 0)) {
}
static del_channel_func_t *dcf_list;
+static void **dcf_list_extra;
static unsigned int dcf_size = 0, dcf_used = 0;
void
-reg_del_channel_func(del_channel_func_t handler)
+reg_del_channel_func(del_channel_func_t handler, void *extra)
{
if (dcf_used == dcf_size) {
if (dcf_size) {
dcf_size <<= 1;
dcf_list = realloc(dcf_list, dcf_size*sizeof(dcf_list[0]));
+ dcf_list_extra = realloc(dcf_list_extra, dcf_size*sizeof(void*));
} else {
dcf_size = 8;
dcf_list = malloc(dcf_size*sizeof(dcf_list[0]));
+ dcf_list_extra = malloc(dcf_size*sizeof(dcf_list_extra[0]));
}
}
- dcf_list[dcf_used++] = handler;
+ dcf_list[dcf_used] = handler;
+ dcf_list_extra[dcf_used++] = extra;
}
static void
channel->exemptlist.used = 0;
for (n=0; n<dcf_used; n++)
- dcf_list[n](channel);
+ dcf_list[n](channel, dcf_list_extra[n]);
modeList_clean(&channel->members);
banList_clean(&channel->banlist);
}
static part_func_t *pf_list;
+static void **pf_list_extra;
static unsigned int pf_size = 0, pf_used = 0;
void
-reg_part_func(part_func_t handler)
+reg_part_func(part_func_t handler, void *extra)
{
if (pf_used == pf_size) {
if (pf_size) {
pf_size <<= 1;
pf_list = realloc(pf_list, pf_size*sizeof(part_func_t));
+ pf_list_extra = realloc(pf_list_extra, pf_size*sizeof(void*));
} else {
pf_size = 8;
pf_list = malloc(pf_size*sizeof(part_func_t));
+ pf_list_extra = malloc(pf_size*sizeof(void*));
}
}
- pf_list[pf_used++] = handler;
+ pf_list[pf_used] = handler;
+ pf_list_extra[pf_used++] = extra;
}
void
-unreg_part_func(part_func_t handler)
+unreg_part_func(part_func_t handler, void *extra)
{
unsigned int i;
for (i=0; i<pf_used; i++)
- if (pf_list[i] == handler)
+ if (pf_list[i] == handler && pf_list_extra[i] == extra)
break;
if (i == pf_used)
return;
memmove(pf_list+i, pf_list+i+1, (pf_used-i-1)*sizeof(pf_list[0]));
+ memmove(pf_list_extra+i, pf_list_extra+i+1, (pf_used-i-1)*sizeof(pf_list_extra[0]));
pf_used--;
}
/* make callbacks */
for (n=0; n<pf_used; n++)
- pf_list[n](mNode, reason);
+ pf_list[n](mNode, reason, pf_list_extra[n]);
/* free memory */
free(mNode);
}
static kick_func_t *kf_list;
+static void **kf_list_extra;
static unsigned int kf_size = 0, kf_used = 0;
void
/* This may break things, but lets see.. -Rubin */
for (n=0; n<kf_used; n++)
- kf_list[n](kicker, target, channel);
+ kf_list[n](kicker, target, channel, kf_list_extra[n]);
/* don't remove them from the channel, since the server will send a PART */
irc_kick(kicker, target, channel, why);
}
void
-reg_kick_func(kick_func_t handler)
+reg_kick_func(kick_func_t handler, void *extra)
{
if (kf_used == kf_size) {
if (kf_size) {
kf_size <<= 1;
kf_list = realloc(kf_list, kf_size*sizeof(kick_func_t));
+ kf_list_extra = realloc(kf_list_extra, kf_size*sizeof(void*));
} else {
kf_size = 8;
kf_list = malloc(kf_size*sizeof(kick_func_t));
+ kf_list_extra = malloc(kf_size*sizeof(void*));
}
}
- kf_list[kf_used++] = handler;
+ kf_list[kf_used] = handler;
+ kf_list_extra[kf_used++] = extra;
}
void
mn->idle_since = now;
for (n=0; n<kf_used; n++)
- kf_list[n](kicker, victim, channel);
+ kf_list[n](kicker, victim, channel, kf_list_extra[n]);
DelChannelUser(victim, channel, 0, 0);
free(duf_list);
free(duf_list_extra);
free(ncf_list);
+ free(ncf_list_extra);
free(jf_list);
free(jf_list_extra);
free(dcf_list);
+ free(dcf_list_extra);
free(pf_list);
+ free(pf_list_extra);
free(kf_list);
+ free(kf_list_extra);
free(tf_list);
free(tf_list_extra);
}