src/hash.c

   1 /* hash.c - IRC network state database
   2  * Copyright 2000-2004 srvx Development Team
   3  *
   4  * This file is part of srvx.
   5  *
   6  * srvx is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with srvx; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
  19  */
  20
  21 #include "conf.h"
  22 #include "global.h"
  23 #include "hash.h"
  24 #include "log.h"
  25
  26 struct server *self;
  27 dict_t channels;
  28 dict_t clients;
  29 dict_t servers;
  30 unsigned int max_clients, invis_clients;
  31 unsigned long max_clients_time;
  32 struct userList curr_opers;
  33
  34 static void hash_cleanup(void);
  35
  36 void init_structs(void)
  37 {
  38     channels = dict_new();
  39     clients = dict_new();
  40     servers = dict_new();
  41     userList_init(&curr_opers);
  42     reg_exit_func(hash_cleanup);
  43 }
  44
  45 int userList_contains(struct userList *list, struct userNode *user)
  46 {
  47     unsigned int ii;
  48
  49     for (ii = 0; ii < list->used; ++ii) {
  50         if (user == list->list[ii]) {
  51             return 1;
  52         }
  53     }
  54     return 0;
  55 }
  56
  57 server_link_func_t *slf_list;
  58 unsigned int slf_size = 0, slf_used = 0;
  59
  60 void
  61 reg_server_link_func(server_link_func_t handler)
  62 {
  63     if (slf_used == slf_size) {
  64         if (slf_size) {
  65             slf_size <<= 1;
  66             slf_list = realloc(slf_list, slf_size*sizeof(server_link_func_t));
  67         } else {
  68             slf_size = 8;
  69             slf_list = malloc(slf_size*sizeof(server_link_func_t));
  70         }
  71     }
  72     slf_list[slf_used++] = handler;
  73 }
  74
  75 struct server*
  76 GetServerH(const char *name)
  77 {
  78     return dict_find(servers, name, NULL);
  79 }
  80
  81 new_user_func_t *nuf_list;
  82 unsigned int nuf_size = 0, nuf_used = 0;
  83
  84 void
  85 reg_new_user_func(new_user_func_t handler)
  86 {
  87     if (nuf_used == nuf_size) {
  88         if (nuf_size) {
  89             nuf_size <<= 1;
  90             nuf_list = realloc(nuf_list, nuf_size*sizeof(new_user_func_t));
  91         } else {
  92             nuf_size = 8;
  93             nuf_list = malloc(nuf_size*sizeof(new_user_func_t));
  94         }
  95     }
  96     nuf_list[nuf_used++] = handler;
  97 }
  98
  99 static nick_change_func_t *ncf2_list;
 100 static unsigned int ncf2_size = 0, ncf2_used = 0;
 101
 102 void
 103 reg_nick_change_func(nick_change_func_t handler)
 104 {
 105     if (ncf2_used == ncf2_size) {
 106         if (ncf2_size) {
 107             ncf2_size <<= 1;
 108             ncf2_list = realloc(ncf2_list, ncf2_size*sizeof(nick_change_func_t));
 109         } else {
 110             ncf2_size = 8;
 111             ncf2_list = malloc(ncf2_size*sizeof(nick_change_func_t));
 112         }
 113     }
 114     ncf2_list[ncf2_used++] = handler;
 115 }
 116
 117
 118 del_user_func_t *duf_list;
 119 unsigned int duf_size = 0, duf_used = 0;
 120
 121 void
 122 reg_del_user_func(del_user_func_t handler)
 123 {
 124     if (duf_used == duf_size) {
 125         if (duf_size) {
 126             duf_size <<= 1;
 127             duf_list = realloc(duf_list, duf_size*sizeof(del_user_func_t));
 128         } else {
 129             duf_size = 8;
 130             duf_list = malloc(duf_size*sizeof(del_user_func_t));
 131         }
 132     }
 133     duf_list[duf_used++] = handler;
 134 }
 135
 136 void
 137 unreg_del_user_func(del_user_func_t handler)
 138 {
 139     unsigned int i;
 140     for (i=0; i<duf_used; i++) {
 141         if (duf_list[i] == handler) break;
 142     }
 143     if (i == duf_used) return;
 144     memmove(duf_list+i, duf_list+i+1, (duf_used-i-1)*sizeof(duf_list[0]));
 145     duf_used--;
 146 }
 147
 148 /* reintroduces a user after it has been killed. */
 149 void
 150 ReintroduceUser(struct userNode *user)
 151 {
 152     struct mod_chanmode change;
 153     unsigned int n;
 154
 155     irc_user(user);
 156     mod_chanmode_init(&change);
 157     change.argc = 1;
 158     for (n = 0; n < user->channels.used; n++) {
 159         struct modeNode *mn = user->channels.list[n];
 160         irc_join(user, mn->channel);
 161         if (mn->modes) {
 162             change.args[0].mode = mn->modes;
 163             change.args[0].u.member = mn;
 164             mod_chanmode_announce(user, mn->channel, &change);
 165         }
 166     }
 167 }
 168
 169 void
 170 NickChange(struct userNode* user, const char *new_nick, int no_announce)
 171 {
 172     char *old_nick;
 173     unsigned int nn;
 174
 175     /* don't do anything if there's no change */
 176     old_nick = user->nick;
 177     if (!strncmp(new_nick, old_nick, NICKLEN))
 178         return;
 179
 180     /* remove old entry from clients dictionary */
 181     dict_remove(clients, old_nick);
 182 #if !defined(WITH_PROTOCOL_P10)
 183     /* Remove from uplink's clients dict */
 184     dict_remove(user->uplink->users, old_nick);
 185 #endif
 186     /* and reinsert */
 187     user->nick = strdup(new_nick);
 188     dict_insert(clients, user->nick, user);
 189 #if !defined(WITH_PROTOCOL_P10)
 190     dict_insert(user->uplink->users, user->nick, user);
 191 #endif
 192
 193     /* Make callbacks for nick changes.  Do this with new nick in
 194      * place because that is slightly more useful.  Stop if the user
 195      * gets killed by any of the hooks, so that later hooks do not get
 196      * confused by the user having disappeared.
 197      */
 198     for (nn=0; (nn<ncf2_used) && !user->dead; nn++)
 199         ncf2_list[nn](user, old_nick);
 200     user->timestamp = now;
 201     if (IsLocal(user) && !no_announce)
 202         irc_nick(user, old_nick);
 203     free(old_nick);
 204 }
 205
 206 struct userNode *
 207 GetUserH(const char *nick)
 208 {
 209     return dict_find(clients, nick, NULL);
 210 }
 211
 212 static account_func_t account_func;
 213
 214 void
 215 reg_account_func(account_func_t handler)
 216 {
 217     if (account_func) {
 218         log_module(MAIN_LOG, LOG_WARNING, "Reregistering ACCOUNT handler.");
 219     }
 220     account_func = handler;
 221 }
 222
 223 void
 224 call_account_func(struct userNode *user, const char *stamp, unsigned long timestamp, unsigned long serial)
 225 {
 226     /* We've received an account stamp for a user; notify
 227        NickServ, which registers the sole account_func
 228        right now.
 229
 230        P10 Protocol violation if (user->modes & FLAGS_STAMPED) here.
 231     */
 232     if (account_func)
 233         account_func(user, stamp, timestamp, serial);
 234
 235 #ifdef WITH_PROTOCOL_P10
 236     /* Mark the user so we don't stamp it again. */
 237     user->modes |= FLAGS_STAMPED;
 238 #endif
 239 }
 240
 241 void
 242 StampUser(struct userNode *user, const char *stamp, unsigned long timestamp, unsigned long serial)
 243 {
 244 #ifdef WITH_PROTOCOL_P10
 245     /* The P10 protocol says we can't stamp users who already
 246        have a stamp. */
 247     if (IsStamped(user))
 248         return;
 249 #endif
 250
 251     irc_account(user, stamp, timestamp, serial);
 252     user->modes |= FLAGS_STAMPED;
 253 }
 254
 255 void
 256 assign_fakehost(struct userNode *user, const char *host, const char *ident, int force, int announce)
 257 {
 258     if (host)
 259         safestrncpy(user->fakehost, host, sizeof(user->fakehost));
 260     if (ident)
 261         safestrncpy(user->fakeident, ident, sizeof(user->ident));
 262     if (announce)
 263         irc_fakehost(user, host, ident, force);
 264 }
 265
 266 static new_channel_func_t *ncf_list;
 267 static unsigned int ncf_size = 0, ncf_used = 0;
 268
 269 void
 270 reg_new_channel_func(new_channel_func_t handler)
 271 {
 272     if (ncf_used == ncf_size) {
 273         if (ncf_size) {
 274             ncf_size <<= 1;
 275             ncf_list = realloc(ncf_list, ncf_size*sizeof(ncf_list[0]));
 276         } else {
 277             ncf_size = 8;
 278             ncf_list = malloc(ncf_size*sizeof(ncf_list[0]));
 279         }
 280     }
 281     ncf_list[ncf_used++] = handler;
 282 }
 283
 284 static join_func_t *jf_list;
 285 static unsigned int jf_size = 0, jf_used = 0;
 286
 287 void
 288 reg_join_func(join_func_t handler)
 289 {
 290     if (jf_used == jf_size) {
 291         if (jf_size) {
 292             jf_size <<= 1;
 293             jf_list = realloc(jf_list, jf_size*sizeof(join_func_t));
 294         } else {
 295             jf_size = 8;
 296             jf_list = malloc(jf_size*sizeof(join_func_t));
 297         }
 298     }
 299     jf_list[jf_used++] = handler;
 300 }
 301
 302 int rel_age;
 303
 304 static void
 305 wipeout_channel(struct chanNode *cNode, unsigned long new_time, char **modes, unsigned int modec) {
 306     unsigned int orig_limit;
 307     chan_mode_t orig_modes;
 308     char orig_key[KEYLEN+1];
 309     char orig_apass[KEYLEN+1];
 310     char orig_upass[KEYLEN+1];
 311     unsigned int nn, argc;
 312
 313     /* nuke old topic */
 314     cNode->topic[0] = '\0';
 315     cNode->topic_nick[0] = '\0';
 316     cNode->topic_time = 0;
 317
 318     /* remember the old modes, and update them with the new */
 319     orig_modes = cNode->modes;
 320     orig_limit = cNode->limit;
 321     strcpy(orig_key, cNode->key);
 322     strcpy(orig_upass, cNode->upass);
 323     strcpy(orig_apass, cNode->apass);
 324     cNode->modes = 0;
 325     mod_chanmode(NULL, cNode, modes, modec, 0);
 326     cNode->timestamp = new_time;
 327
 328     /* remove our old ban list, replace it with the new one */
 329     for (nn=0; nn<cNode->banlist.used; nn++)
 330         free(cNode->banlist.list[nn]);
 331     cNode->banlist.used = 0;
 332
 333     /* deop anybody in the channel now, but count services to reop */
 334     for (nn=argc=0; nn<cNode->members.used; nn++) {
 335         struct modeNode *mn = cNode->members.list[nn];
 336         if ((mn->modes & MODE_CHANOP) && IsService(mn->user) && IsLocal(mn->user))
 337             argc++;
 338     }
 339     if (argc) {
 340         struct mod_chanmode *change;
 341
 342         change = mod_chanmode_alloc(argc);
 343         change->modes_clear = 0;
 344         change->modes_set = orig_modes;
 345         change->new_limit = orig_limit;
 346         strcpy(change->new_key, orig_key);
 347         strcpy(change->new_upass, orig_upass);
 348         strcpy(change->new_apass, orig_apass);
 349         for (nn = argc = 0; nn < cNode->members.used; ++nn) {
 350             struct modeNode *mn = cNode->members.list[nn];
 351             if ((mn->modes & MODE_CHANOP) && IsService(mn->user) && IsLocal(mn->user)) {
 352                 change->args[argc].mode = MODE_CHANOP;
 353                 change->args[argc].u.member = mn;
 354                 argc++;
 355             }
 356         }
 357         assert(argc == change->argc);
 358         change->args[0].u.member->modes &= ~MODE_CHANOP;
 359         mod_chanmode_announce(change->args[0].u.member->user, cNode, change);
 360         mod_chanmode_free(change);
 361     }
 362 }
 363
 364 struct chanNode *
 365 AddChannel(const char *name, unsigned long time_, const char *modes, char *banlist)
 366 {
 367     struct chanNode *cNode;
 368     char new_modes[MAXLEN], *argv[MAXNUMPARAMS];
 369     unsigned int nn;
 370
 371     if (!IsChannelName(name)) {
 372         log_module(MAIN_LOG, LOG_ERROR, "Somebody asked to add channel '%s', which isn't a channel name!", name);
 373         return NULL;
 374     }
 375     if (!modes)
 376         modes = "";
 377
 378     safestrncpy(new_modes, modes, sizeof(new_modes));
 379     nn = split_line(new_modes, 0, ArrayLength(argv), argv);
 380     if (!(cNode = GetChannel(name))) {
 381         cNode = calloc(1, sizeof(*cNode) + strlen(name));
 382         strcpy(cNode->name, name);
 383         banList_init(&cNode->banlist);
 384         modeList_init(&cNode->members);
 385         userList_init(&cNode->invited);
 386         mod_chanmode(NULL, cNode, argv, nn, MCP_FROM_SERVER);
 387         dict_insert(channels, cNode->name, cNode);
 388         cNode->timestamp = time_;
 389         rel_age = 1;
 390     } else if (cNode->timestamp > time_) {
 391         wipeout_channel(cNode, time_, argv, nn);
 392         rel_age = 1;
 393     } else if (cNode->timestamp == time_) {
 394         mod_chanmode(NULL, cNode, argv, nn, MCP_FROM_SERVER);
 395         rel_age = 0;
 396     } else {
 397         rel_age = -1;
 398     }
 399
 400     /* rel_age is the relative ages of our channel data versus what is
 401      * in a BURST command.  1 means ours is younger, 0 means both are
 402      * the same age, -1 means ours is older. */
 403
 404     /* if it's a new or updated channel, make callbacks */
 405     if (rel_age > 0)
 406         for (nn=0; nn<ncf_used; nn++)
 407             ncf_list[nn](cNode);
 408
 409     /* go through list of bans and add each one */
 410     if (banlist && (rel_age >= 0)) {
 411         for (nn=0; banlist[nn];) {
 412             char *ban = banlist + nn;
 413             struct banNode *bn;
 414             while (banlist[nn] != ' ' && banlist[nn])
 415                 nn++;
 416             while (banlist[nn] == ' ')
 417                 banlist[nn++] = 0;
 418             bn = calloc(1, sizeof(*bn));
 419             safestrncpy(bn->ban, ban, sizeof(bn->ban));
 420             safestrncpy(bn->who, "<unknown>", sizeof(bn->who));
 421             bn->set = now;
 422             banList_append(&cNode->banlist, bn);
 423         }
 424     }
 425
 426     return cNode;
 427 }
 428
 429 static del_channel_func_t *dcf_list;
 430 static unsigned int dcf_size = 0, dcf_used = 0;
 431
 432 void
 433 reg_del_channel_func(del_channel_func_t handler)
 434 {
 435     if (dcf_used == dcf_size) {
 436         if (dcf_size) {
 437             dcf_size <<= 1;
 438             dcf_list = realloc(dcf_list, dcf_size*sizeof(dcf_list[0]));
 439         } else {
 440             dcf_size = 8;
 441             dcf_list = malloc(dcf_size*sizeof(dcf_list[0]));
 442         }
 443     }
 444     dcf_list[dcf_used++] = handler;
 445 }
 446
 447 static void
 448 DelChannel(struct chanNode *channel)
 449 {
 450     unsigned int n;
 451
 452     verify(channel);
 453     dict_remove(channels, channel->name);
 454
 455     if (channel->members.used || channel->locks) {
 456         log_module(MAIN_LOG, LOG_ERROR, "Warning: deleting channel %s with %d users and %d locks remaining.", channel->name, channel->members.used, channel->locks);
 457     }
 458
 459     /* go through all channel members and delete them from the channel */
 460     for (n=channel->members.used; n>0; )
 461         DelChannelUser(channel->members.list[--n]->user, channel, NULL, 1);
 462
 463     /* delete all channel bans */
 464     for (n=channel->banlist.used; n>0; )
 465         free(channel->banlist.list[--n]);
 466     channel->banlist.used = 0;
 467
 468     for (n=0; n<dcf_used; n++)
 469         dcf_list[n](channel);
 470
 471     modeList_clean(&channel->members);
 472     banList_clean(&channel->banlist);
 473     userList_clean(&channel->invited);
 474     free(channel);
 475 }
 476
 477 struct modeNode *
 478 AddChannelUser(struct userNode *user, struct chanNode* channel)
 479 {
 480         struct modeNode *mNode;
 481         unsigned int n;
 482
 483         mNode = GetUserMode(channel, user);
 484         if (mNode)
 485             return mNode;
 486
 487         mNode = malloc(sizeof(*mNode));
 488
 489         /* set up modeNode */
 490         mNode->channel = channel;
 491         mNode->user = user;
 492         mNode->modes = 0;
 493         mNode->oplevel = MAXOPLEVEL;
 494         mNode->idle_since = now;
 495
 496         /* Add modeNode to channel and to user.
 497          * We have to do this before calling join funcs in case the
 498          * modeNode is manipulated (e.g. chanserv ops the user).
 499          */
 500         modeList_append(&channel->members, mNode);
 501         modeList_append(&user->channels, mNode);
 502
 503         if (channel->members.used == 1
 504             && !(channel->modes & MODE_REGISTERED)
 505             && !(channel->modes & MODE_APASS))
 506             mNode->modes |= MODE_CHANOP;
 507
 508         if (IsLocal(user)) {
 509             irc_join(user, channel);
 510         }
 511
 512         for (n=0; (n<jf_used) && !user->dead; n++) {
 513             /* Callbacks return true if they kick or kill the user,
 514              * and we can continue without removing mNode. */
 515             if (jf_list[n](mNode))
 516                 return NULL;
 517         }
 518
 519         return mNode;
 520 }
 521
 522 /* Return negative if *(struct modeNode**)pa is "less than" pb,
 523  * positive if pa is "larger than" pb.  Comparison is based on sorting
 524  * so that non-voiced/non-opped users are first, voiced-only users are
 525  * next, and the "strongest" oplevels are before "weaker" oplevels.
 526  * Within those sets, ordering is arbitrary.
 527  */
 528 int
 529 modeNode_sort(const void *pa, const void *pb)
 530 {
 531         struct modeNode *a = *(struct modeNode**)pa;
 532         struct modeNode *b = *(struct modeNode**)pb;
 533
 534         if (a->modes & MODE_CHANOP) {
 535             if (!(b->modes & MODE_CHANOP))
 536                 return -1;
 537             else if ((b->modes & MODE_VOICE) != (a->modes & MODE_VOICE))
 538                 return (b->modes & MODE_VOICE) - (a->modes & MODE_VOICE);
 539             else if (a->oplevel != b->oplevel)
 540                 return a->oplevel - b->oplevel;
 541         } else if (b->modes & MODE_CHANOP)
 542             return 1;
 543         else if ((b->modes & MODE_VOICE) != (a->modes & MODE_VOICE))
 544             return (b->modes & MODE_VOICE) - (a->modes & MODE_VOICE);
 545
 546         return irccasecmp(a->user->nick, b->user->nick);
 547 }
 548
 549 static part_func_t *pf_list;
 550 static unsigned int pf_size = 0, pf_used = 0;
 551
 552 void
 553 reg_part_func(part_func_t handler)
 554 {
 555     if (pf_used == pf_size) {
 556         if (pf_size) {
 557             pf_size <<= 1;
 558             pf_list = realloc(pf_list, pf_size*sizeof(part_func_t));
 559         } else {
 560             pf_size = 8;
 561             pf_list = malloc(pf_size*sizeof(part_func_t));
 562         }
 563     }
 564     pf_list[pf_used++] = handler;
 565 }
 566
 567 void
 568 unreg_part_func(part_func_t handler)
 569 {
 570     unsigned int i;
 571     for (i=0; i<pf_used; i++)
 572         if (pf_list[i] == handler)
 573             break;
 574     if (i == pf_used)
 575         return;
 576     memmove(pf_list+i, pf_list+i+1, (pf_used-i-1)*sizeof(pf_list[0]));
 577     pf_used--;
 578 }
 579
 580 void
 581 LockChannel(struct chanNode* channel)
 582 {
 583     channel->locks++;
 584 }
 585
 586 void
 587 UnlockChannel(struct chanNode *channel)
 588 {
 589     assert(channel->locks > 0);
 590     if (!--channel->locks && !channel->members.used)
 591         DelChannel(channel);
 592 }
 593
 594 void
 595 DelChannelUser(struct userNode* user, struct chanNode* channel, const char *reason, int deleting)
 596 {
 597     struct modeNode* mNode;
 598     unsigned int n;
 599
 600     if (IsLocal(user) && reason)
 601         irc_part(user, channel, reason);
 602
 603     mNode = GetUserMode(channel, user);
 604
 605     /* Sometimes we get a PART when the user has been KICKed.
 606      * In this case, we get no usermode, and should not try to free it.
 607      */
 608     if (!mNode)
 609         return;
 610
 611     /* remove modeNode from channel and user */
 612     modeList_remove(&channel->members, mNode);
 613     modeList_remove(&user->channels, mNode);
 614
 615     /* make callbacks */
 616     for (n=0; n<pf_used; n++)
 617         pf_list[n](mNode, reason);
 618
 619     /* free memory */
 620     free(mNode);
 621
 622     /* A single check for APASS only should be enough here */
 623     if (!deleting && !channel->members.used && !channel->locks
 624         && !(channel->modes & MODE_REGISTERED) && !(channel->modes & MODE_APASS))
 625         DelChannel(channel);
 626 }
 627
 628 void
 629 KickChannelUser(struct userNode* target, struct chanNode* channel, struct userNode *kicker, const char *why)
 630 {
 631     if (!target || !channel || IsService(target) || !GetUserMode(channel, target))
 632         return;
 633     /* don't remove them from the channel, since the server will send a PART */
 634     irc_kick(kicker, target, channel, why);
 635
 636     if (IsLocal(target))
 637     {
 638         /* NULL reason because we don't want a PART message to be
 639            sent by DelChannelUser. */
 640         DelChannelUser(target, channel, NULL, 0);
 641     }
 642 }
 643
 644 static kick_func_t *kf_list;
 645 static unsigned int kf_size = 0, kf_used = 0;
 646
 647 void
 648 reg_kick_func(kick_func_t handler)
 649 {
 650     if (kf_used == kf_size) {
 651         if (kf_size) {
 652             kf_size <<= 1;
 653             kf_list = realloc(kf_list, kf_size*sizeof(kick_func_t));
 654         } else {
 655             kf_size = 8;
 656             kf_list = malloc(kf_size*sizeof(kick_func_t));
 657         }
 658     }
 659     kf_list[kf_used++] = handler;
 660 }
 661
 662 void
 663 ChannelUserKicked(struct userNode* kicker, struct userNode* victim, struct chanNode* channel)
 664 {
 665     unsigned int n;
 666     struct modeNode *mn;
 667
 668     if (!victim || !channel || !GetUserMode(channel, victim))
 669         return;
 670
 671     /* Update the kicker's idle time (kicker may be null if it was a server) */
 672     if (kicker && (mn = GetUserMode(channel, kicker)))
 673         mn->idle_since = now;
 674
 675     for (n=0; n<kf_used; n++)
 676         kf_list[n](kicker, victim, channel);
 677
 678     DelChannelUser(victim, channel, 0, 0);
 679
 680     if (IsLocal(victim))
 681         irc_part(victim, channel, NULL);
 682 }
 683
 684 int ChannelBanExists(struct chanNode *channel, const char *ban)
 685 {
 686     unsigned int n;
 687
 688     for (n = 0; n < channel->banlist.used; n++)
 689         if (match_ircglobs(channel->banlist.list[n]->ban, ban))
 690             return 1;
 691     return 0;
 692 }
 693
 694 static topic_func_t *tf_list;
 695 static unsigned int tf_size = 0, tf_used = 0;
 696
 697 void
 698 reg_topic_func(topic_func_t handler)
 699 {
 700     if (tf_used == tf_size) {
 701         if (tf_size) {
 702             tf_size <<= 1;
 703             tf_list = realloc(tf_list, tf_size*sizeof(topic_func_t));
 704         } else {
 705             tf_size = 8;
 706             tf_list = malloc(tf_size*sizeof(topic_func_t));
 707         }
 708     }
 709     tf_list[tf_used++] = handler;
 710 }
 711
 712 void
 713 SetChannelTopic(struct chanNode *channel, struct userNode *user, const char *topic, int announce)
 714 {
 715     unsigned int n;
 716     struct modeNode *mn;
 717     char old_topic[TOPICLEN+1];
 718
 719     safestrncpy(old_topic, channel->topic, sizeof(old_topic));
 720     safestrncpy(channel->topic, topic, sizeof(channel->topic));
 721     channel->topic_time = now;
 722
 723     if (user) {
 724         safestrncpy(channel->topic_nick, user->nick, sizeof(channel->topic_nick));
 725
 726         /* Update the setter's idle time */
 727         if ((mn = GetUserMode(channel, user)))
 728             mn->idle_since = now;
 729     }
 730
 731     if (announce) {
 732         /* We don't really care if a local user messes with the topic,
 733          * so don't call the tf_list functions. */
 734         irc_topic(user, channel, topic);
 735     } else {
 736         for (n=0; n<tf_used; n++)
 737             /* A topic change handler can return non-zero to indicate
 738              * that it has reverted the topic change, and that further
 739              * hooks should not be called.
 740              */
 741             if (tf_list[n](user, channel, old_topic))
 742                 break;
 743     }
 744 }
 745
 746 struct chanNode *
 747 GetChannel(const char *name)
 748 {
 749     return dict_find(channels, name, NULL);
 750 }
 751
 752 struct modeNode *
 753 GetUserMode(struct chanNode *channel, struct userNode *user)
 754 {
 755     unsigned int n;
 756     struct modeNode *mn = NULL;
 757
 758     verify(channel);
 759     verify(channel->members.list);
 760     verify(user);
 761     verify(user->channels.list);
 762     if (channel->members.used < user->channels.used) {
 763         for (n=0; n<channel->members.used; n++) {
 764             verify(channel->members.list[n]);
 765             if (user == channel->members.list[n]->user) {
 766                 mn = channel->members.list[n];
 767                 break;
 768             }
 769         }
 770     } else {
 771         for (n=0; n<user->channels.used; n++) {
 772             verify(user->channels.list[n]);
 773             if (channel == user->channels.list[n]->channel) {
 774                 mn = user->channels.list[n];
 775                 break;
 776             }
 777         }
 778     }
 779     return mn;
 780 }
 781
 782 DEFINE_LIST(userList, struct userNode*)
 783 DEFINE_LIST(modeList, struct modeNode*)
 784 DEFINE_LIST(banList, struct banNode*)
 785 DEFINE_LIST(channelList, struct chanNode*)
 786 DEFINE_LIST(serverList, struct server*)
 787
 788 static void
 789 hash_cleanup(void)
 790 {
 791     dict_iterator_t it, next;
 792
 793     DelServer(self, 0, NULL);
 794     for (it = dict_first(channels); it; it = next) {
 795         next = iter_next(it);
 796         DelChannel(iter_data(it));
 797     }
 798     dict_delete(channels);
 799     dict_delete(clients);
 800     dict_delete(servers);
 801     userList_clean(&curr_opers);
 802
 803     free(slf_list);
 804     free(nuf_list);
 805     free(ncf2_list);
 806     free(duf_list);
 807     free(ncf_list);
 808     free(jf_list);
 809     free(dcf_list);
 810     free(pf_list);
 811     free(kf_list);
 812     free(tf_list);
 813 }