src/s_newconf.c

   1 /*
   2  * ircd-ratbox: an advanced Internet Relay Chat Daemon(ircd).
   3  * s_newconf.c - code for dealing with conf stuff
   4  *
   5  * Copyright (C) 2004 Lee Hardy <lee@leeh.co.uk>
   6  * Copyright (C) 2004-2005 ircd-ratbox development team
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met:
  11  *
  12  * 1.Redistributions of source code must retain the above copyright notice,
  13  *   this list of conditions and the following disclaimer.
  14  * 2.Redistributions in binary form must reproduce the above copyright
  15  *   notice, this list of conditions and the following disclaimer in the
  16  *   documentation and/or other materials provided with the distribution.
  17  * 3.The name of the author may not be used to endorse or promote products
  18  *   derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  23  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  24  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  26  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  28  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  29  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 #include "stdinc.h"
  35 #include "ircd_defs.h"
  36 #include "common.h"
  37 #include "s_conf.h"
  38 #include "s_newconf.h"
  39 #include "client.h"
  40 #include "s_serv.h"
  41 #include "send.h"
  42 #include "hostmask.h"
  43 #include "newconf.h"
  44 #include "hash.h"
  45 #include "irc_dictionary.h"
  46
  47 rb_dlink_list shared_conf_list;
  48 rb_dlink_list cluster_conf_list;
  49 rb_dlink_list oper_conf_list;
  50 rb_dlink_list hubleaf_conf_list;
  51 rb_dlink_list server_conf_list;
  52 rb_dlink_list xline_conf_list;
  53 rb_dlink_list resv_conf_list;   /* nicks only! */
  54 rb_dlink_list nd_list;          /* nick delay */
  55 rb_dlink_list tgchange_list;
  56
  57 rb_patricia_tree_t *tgchange_tree;
  58
  59 static rb_bh *nd_heap = NULL;
  60
  61 static void expire_temp_rxlines(void *unused);
  62 static void expire_nd_entries(void *unused);
  63
  64 struct ev_entry *expire_nd_entries_ev = NULL;
  65 struct ev_entry *expire_temp_rxlines_ev = NULL;
  66
  67 void
  68 init_s_newconf(void)
  69 {
  70         tgchange_tree = rb_new_patricia(PATRICIA_BITS);
  71         nd_heap = rb_bh_create(sizeof(struct nd_entry), ND_HEAP_SIZE, "nd_heap");
  72         expire_nd_entries_ev = rb_event_addish("expire_nd_entries", expire_nd_entries, NULL, 30);
  73         expire_temp_rxlines_ev = rb_event_addish("expire_temp_rxlines", expire_temp_rxlines, NULL, 60);
  74 }
  75
  76 void
  77 clear_s_newconf(void)
  78 {
  79         struct server_conf *server_p;
  80         rb_dlink_node *ptr;
  81         rb_dlink_node *next_ptr;
  82
  83         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, shared_conf_list.head)
  84         {
  85                 /* ptr here is ptr->data->node */
  86                 rb_dlinkDelete(ptr, &shared_conf_list);
  87                 free_remote_conf(ptr->data);
  88         }
  89
  90         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, cluster_conf_list.head)
  91         {
  92                 rb_dlinkDelete(ptr, &cluster_conf_list);
  93                 free_remote_conf(ptr->data);
  94         }
  95
  96         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, hubleaf_conf_list.head)
  97         {
  98                 rb_dlinkDelete(ptr, &hubleaf_conf_list);
  99                 free_remote_conf(ptr->data);
 100         }
 101
 102         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, oper_conf_list.head)
 103         {
 104                 free_oper_conf(ptr->data);
 105                 rb_dlinkDestroy(ptr, &oper_conf_list);
 106         }
 107
 108         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, server_conf_list.head)
 109         {
 110                 server_p = ptr->data;
 111
 112                 if(!server_p->servers)
 113                 {
 114                         rb_dlinkDelete(ptr, &server_conf_list);
 115                         free_server_conf(ptr->data);
 116                 }
 117                 else
 118                         server_p->flags |= SERVER_ILLEGAL;
 119         }
 120 }
 121
 122 void
 123 clear_s_newconf_bans(void)
 124 {
 125         struct ConfItem *aconf;
 126         rb_dlink_node *ptr, *next_ptr;
 127
 128         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
 129         {
 130                 aconf = ptr->data;
 131
 132                 if(aconf->hold)
 133                         continue;
 134
 135                 free_conf(aconf);
 136                 rb_dlinkDestroy(ptr, &xline_conf_list);
 137         }
 138
 139         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
 140         {
 141                 aconf = ptr->data;
 142
 143                 /* temporary resv */
 144                 if(aconf->hold)
 145                         continue;
 146
 147                 free_conf(aconf);
 148                 rb_dlinkDestroy(ptr, &resv_conf_list);
 149         }
 150
 151         clear_resv_hash();
 152 }
 153
 154 struct remote_conf *
 155 make_remote_conf(void)
 156 {
 157         struct remote_conf *remote_p = rb_malloc(sizeof(struct remote_conf));
 158         return remote_p;
 159 }
 160
 161 void
 162 free_remote_conf(struct remote_conf *remote_p)
 163 {
 164         s_assert(remote_p != NULL);
 165         if(remote_p == NULL)
 166                 return;
 167
 168         rb_free(remote_p->username);
 169         rb_free(remote_p->host);
 170         rb_free(remote_p->server);
 171         rb_free(remote_p);
 172 }
 173
 174 int
 175 find_shared_conf(const char *username, const char *host,
 176                 const char *server, int flags)
 177 {
 178         struct remote_conf *shared_p;
 179         rb_dlink_node *ptr;
 180
 181         RB_DLINK_FOREACH(ptr, shared_conf_list.head)
 182         {
 183                 shared_p = ptr->data;
 184
 185                 if(match(shared_p->username, username) &&
 186                    match(shared_p->host, host) &&
 187                    match(shared_p->server, server))
 188                 {
 189                         if(shared_p->flags & flags)
 190                                 return YES;
 191                         else
 192                                 return NO;
 193                 }
 194         }
 195
 196         return NO;
 197 }
 198
 199 void
 200 propagate_generic(struct Client *source_p, const char *command,
 201                 const char *target, int cap, const char *format, ...)
 202 {
 203         char buffer[BUFSIZE];
 204         va_list args;
 205
 206         va_start(args, format);
 207         rb_vsnprintf(buffer, sizeof(buffer), format, args);
 208         va_end(args);
 209
 210         sendto_match_servs(source_p, target, cap, NOCAPS,
 211                         "%s %s %s",
 212                         command, target, buffer);
 213         sendto_match_servs(source_p, target, CAP_ENCAP, cap,
 214                         "ENCAP %s %s %s",
 215                         target, command, buffer);
 216 }
 217
 218 void
 219 cluster_generic(struct Client *source_p, const char *command,
 220                 int cltype, int cap, const char *format, ...)
 221 {
 222         char buffer[BUFSIZE];
 223         struct remote_conf *shared_p;
 224         va_list args;
 225         rb_dlink_node *ptr;
 226
 227         va_start(args, format);
 228         rb_vsnprintf(buffer, sizeof(buffer), format, args);
 229         va_end(args);
 230
 231         RB_DLINK_FOREACH(ptr, cluster_conf_list.head)
 232         {
 233                 shared_p = ptr->data;
 234
 235                 if(!(shared_p->flags & cltype))
 236                         continue;
 237
 238                 sendto_match_servs(source_p, shared_p->server, cap, NOCAPS,
 239                                 "%s %s %s",
 240                                 command, shared_p->server, buffer);
 241                 sendto_match_servs(source_p, shared_p->server, CAP_ENCAP, cap,
 242                                 "ENCAP %s %s %s",
 243                                 shared_p->server, command, buffer);
 244         }
 245 }
 246
 247 struct oper_conf *
 248 make_oper_conf(void)
 249 {
 250         struct oper_conf *oper_p = rb_malloc(sizeof(struct oper_conf));
 251         return oper_p;
 252 }
 253
 254 void
 255 free_oper_conf(struct oper_conf *oper_p)
 256 {
 257         s_assert(oper_p != NULL);
 258         if(oper_p == NULL)
 259                 return;
 260
 261         rb_free(oper_p->username);
 262         rb_free(oper_p->host);
 263         rb_free(oper_p->name);
 264
 265         if(oper_p->passwd)
 266         {
 267                 memset(oper_p->passwd, 0, strlen(oper_p->passwd));
 268                 rb_free(oper_p->passwd);
 269         }
 270
 271 #ifdef HAVE_LIBCRYPTO
 272         rb_free(oper_p->rsa_pubkey_file);
 273
 274         if(oper_p->rsa_pubkey)
 275                 RSA_free(oper_p->rsa_pubkey);
 276 #endif
 277
 278         rb_free(oper_p);
 279 }
 280
 281 struct oper_conf *
 282 find_oper_conf(const char *username, const char *host, const char *locip, const char *name)
 283 {
 284         struct oper_conf *oper_p;
 285         struct rb_sockaddr_storage ip, cip;
 286         char addr[HOSTLEN+1];
 287         int bits, cbits;
 288         rb_dlink_node *ptr;
 289
 290         parse_netmask(locip, (struct sockaddr *)&cip, &cbits);
 291
 292         RB_DLINK_FOREACH(ptr, oper_conf_list.head)
 293         {
 294                 oper_p = ptr->data;
 295
 296                 /* name/username doesnt match.. */
 297                 if(irccmp(oper_p->name, name) || !match(oper_p->username, username))
 298                         continue;
 299
 300                 rb_strlcpy(addr, oper_p->host, sizeof(addr));
 301
 302                 if(parse_netmask(addr, (struct sockaddr *)&ip, &bits) != HM_HOST)
 303                 {
 304                         if(ip.ss_family == cip.ss_family &&
 305                            comp_with_mask_sock((struct sockaddr *)&ip, (struct sockaddr *)&cip, bits))
 306                                 return oper_p;
 307                 }
 308
 309                 /* we have to compare against the host as well, because its
 310                  * valid to set a spoof to an IP, which if we only compare
 311                  * in ip form to sockhost will not necessarily match --anfl
 312                  */
 313                 if(match(oper_p->host, host))
 314                         return oper_p;
 315         }
 316
 317         return NULL;
 318 }
 319
 320 struct server_conf *
 321 make_server_conf(void)
 322 {
 323         struct server_conf *server_p = rb_malloc(sizeof(struct server_conf));
 324         server_p->aftype = AF_INET;
 325         return server_p;
 326 }
 327
 328 void
 329 free_server_conf(struct server_conf *server_p)
 330 {
 331         s_assert(server_p != NULL);
 332         if(server_p == NULL)
 333                 return;
 334
 335         if(!EmptyString(server_p->passwd))
 336         {
 337                 memset(server_p->passwd, 0, strlen(server_p->passwd));
 338                 rb_free(server_p->passwd);
 339         }
 340
 341         if(!EmptyString(server_p->spasswd))
 342         {
 343                 memset(server_p->spasswd, 0, strlen(server_p->spasswd));
 344                 rb_free(server_p->spasswd);
 345         }
 346
 347         rb_free(server_p->name);
 348         rb_free(server_p->host);
 349         rb_free(server_p->class_name);
 350         rb_free(server_p);
 351 }
 352
 353 void
 354 add_server_conf(struct server_conf *server_p)
 355 {
 356         if(EmptyString(server_p->class_name))
 357         {
 358                 server_p->class_name = rb_strdup("default");
 359                 server_p->class = default_class;
 360                 return;
 361         }
 362
 363         server_p->class = find_class(server_p->class_name);
 364
 365         if(server_p->class == default_class)
 366         {
 367                 conf_report_error("Warning connect::class invalid for %s",
 368                                 server_p->name);
 369
 370                 rb_free(server_p->class_name);
 371                 server_p->class_name = rb_strdup("default");
 372         }
 373
 374         if(strchr(server_p->host, '*') || strchr(server_p->host, '?'))
 375                 return;
 376 }
 377
 378 struct server_conf *
 379 find_server_conf(const char *name)
 380 {
 381         struct server_conf *server_p;
 382         rb_dlink_node *ptr;
 383
 384         RB_DLINK_FOREACH(ptr, server_conf_list.head)
 385         {
 386                 server_p = ptr->data;
 387
 388                 if(ServerConfIllegal(server_p))
 389                         continue;
 390
 391                 if(match(name, server_p->name))
 392                         return server_p;
 393         }
 394
 395         return NULL;
 396 }
 397
 398 void
 399 attach_server_conf(struct Client *client_p, struct server_conf *server_p)
 400 {
 401         /* already have an attached conf */
 402         if(client_p->localClient->att_sconf)
 403         {
 404                 /* short circuit this special case :) */
 405                 if(client_p->localClient->att_sconf == server_p)
 406                         return;
 407
 408                 detach_server_conf(client_p);
 409         }
 410
 411         CurrUsers(server_p->class)++;
 412
 413         client_p->localClient->att_sconf = server_p;
 414         server_p->servers++;
 415 }
 416
 417 void
 418 detach_server_conf(struct Client *client_p)
 419 {
 420         struct server_conf *server_p = client_p->localClient->att_sconf;
 421
 422         if(server_p == NULL)
 423                 return;
 424
 425         client_p->localClient->att_sconf = NULL;
 426         server_p->servers--;
 427         CurrUsers(server_p->class)--;
 428
 429         if(ServerConfIllegal(server_p) && !server_p->servers)
 430         {
 431                 /* the class this one is using may need destroying too */
 432                 if(MaxUsers(server_p->class) < 0 && CurrUsers(server_p->class) <= 0)
 433                         free_class(server_p->class);
 434
 435                 rb_dlinkDelete(&server_p->node, &server_conf_list);
 436                 free_server_conf(server_p);
 437         }
 438 }
 439
 440 void
 441 set_server_conf_autoconn(struct Client *source_p, const char *name, int newval)
 442 {
 443         struct server_conf *server_p;
 444
 445         if((server_p = find_server_conf(name)) != NULL)
 446         {
 447                 if(newval)
 448                         server_p->flags |= SERVER_AUTOCONN;
 449                 else
 450                         server_p->flags &= ~SERVER_AUTOCONN;
 451
 452                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 453                                 "%s has changed AUTOCONN for %s to %i",
 454                                 get_oper_name(source_p), name, newval);
 455         }
 456         else
 457                 sendto_one_notice(source_p, ":Can't find %s", name);
 458 }
 459
 460 void
 461 disable_server_conf_autoconn(const char *name)
 462 {
 463         struct server_conf *server_p;
 464
 465         server_p = find_server_conf(name);
 466         if(server_p != NULL && server_p->flags & SERVER_AUTOCONN)
 467         {
 468                 server_p->flags &= ~SERVER_AUTOCONN;
 469
 470                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 471                                 "Disabling AUTOCONN for %s because of error",
 472                                 name);
 473                 ilog(L_SERVER, "Disabling AUTOCONN for %s because of error",
 474                                 name);
 475         }
 476 }
 477
 478 struct ConfItem *
 479 find_xline(const char *gecos, int counter)
 480 {
 481         struct ConfItem *aconf;
 482         rb_dlink_node *ptr;
 483
 484         RB_DLINK_FOREACH(ptr, xline_conf_list.head)
 485         {
 486                 aconf = ptr->data;
 487
 488                 if(match_esc(aconf->host, gecos))
 489                 {
 490                         if(counter)
 491                                 aconf->port++;
 492                         return aconf;
 493                 }
 494         }
 495
 496         return NULL;
 497 }
 498
 499 struct ConfItem *
 500 find_xline_mask(const char *gecos)
 501 {
 502         struct ConfItem *aconf;
 503         rb_dlink_node *ptr;
 504
 505         RB_DLINK_FOREACH(ptr, xline_conf_list.head)
 506         {
 507                 aconf = ptr->data;
 508
 509                 if(!irccmp(aconf->host, gecos))
 510                         return aconf;
 511         }
 512
 513         return NULL;
 514 }
 515
 516 struct ConfItem *
 517 find_nick_resv(const char *name)
 518 {
 519         struct ConfItem *aconf;
 520         rb_dlink_node *ptr;
 521
 522         RB_DLINK_FOREACH(ptr, resv_conf_list.head)
 523         {
 524                 aconf = ptr->data;
 525
 526                 if(match_esc(aconf->host, name))
 527                 {
 528                         aconf->port++;
 529                         return aconf;
 530                 }
 531         }
 532
 533         return NULL;
 534 }
 535
 536 struct ConfItem *
 537 find_nick_resv_mask(const char *name)
 538 {
 539         struct ConfItem *aconf;
 540         rb_dlink_node *ptr;
 541
 542         RB_DLINK_FOREACH(ptr, resv_conf_list.head)
 543         {
 544                 aconf = ptr->data;
 545
 546                 if(!irccmp(aconf->host, name))
 547                         return aconf;
 548         }
 549
 550         return NULL;
 551 }
 552
 553 /* clean_resv_nick()
 554  *
 555  * inputs       - nick
 556  * outputs      - 1 if nick is vaild resv, 0 otherwise
 557  * side effects -
 558  */
 559 int
 560 clean_resv_nick(const char *nick)
 561 {
 562         char tmpch;
 563         int as = 0;
 564         int q = 0;
 565         int ch = 0;
 566
 567         if(*nick == '-' || IsDigit(*nick))
 568                 return 0;
 569
 570         while ((tmpch = *nick++))
 571         {
 572                 if(tmpch == '?' || tmpch == '@' || tmpch == '#')
 573                         q++;
 574                 else if(tmpch == '*')
 575                         as++;
 576                 else if(IsNickChar(tmpch))
 577                         ch++;
 578                 else
 579                         return 0;
 580         }
 581
 582         if(!ch && as)
 583                 return 0;
 584
 585         return 1;
 586 }
 587
 588 /* valid_wild_card_simple()
 589  *
 590  * inputs       - "thing" to test
 591  * outputs      - 1 if enough wildcards, else 0
 592  * side effects -
 593  */
 594 int
 595 valid_wild_card_simple(const char *data)
 596 {
 597         const char *p;
 598         char tmpch;
 599         int nonwild = 0;
 600         int wild = 0;
 601
 602         /* check the string for minimum number of nonwildcard chars */
 603         p = data;
 604
 605         while((tmpch = *p++))
 606         {
 607                 /* found an escape, p points to the char after it, so skip
 608                  * that and move on.
 609                  */
 610                 if(tmpch == '\\' && *p)
 611                 {
 612                         p++;
 613                         if(++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
 614                                 return 1;
 615                 }
 616                 else if(!IsMWildChar(tmpch))
 617                 {
 618                         /* if we have enough nonwildchars, return */
 619                         if(++nonwild >= ConfigFileEntry.min_nonwildcard_simple)
 620                                 return 1;
 621                 }
 622                 else
 623                         wild++;
 624         }
 625
 626         /* strings without wilds are also ok */
 627         return wild == 0;
 628 }
 629
 630 time_t
 631 valid_temp_time(const char *p)
 632 {
 633         time_t result = 0;
 634
 635         while(*p)
 636         {
 637                 if(IsDigit(*p))
 638                 {
 639                         result *= 10;
 640                         result += ((*p) & 0xF);
 641                         p++;
 642                 }
 643                 else
 644                         return -1;
 645         }
 646
 647         if(result > (60 * 24 * 7 * 52))
 648                 result = (60 * 24 * 7 * 52);
 649
 650         return(result * 60);
 651 }
 652
 653 /* Propagated bans are expired elsewhere. */
 654 static void
 655 expire_temp_rxlines(void *unused)
 656 {
 657         struct ConfItem *aconf;
 658         rb_dlink_node *ptr;
 659         rb_dlink_node *next_ptr;
 660         int i;
 661
 662         HASH_WALK_SAFE(i, R_MAX, ptr, next_ptr, resvTable)
 663         {
 664                 aconf = ptr->data;
 665
 666                 if(aconf->lifetime != 0)
 667                         continue;
 668                 if(aconf->hold && aconf->hold <= rb_current_time())
 669                 {
 670                         if(ConfigFileEntry.tkline_expire_notices)
 671                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 672                                                 "Temporary RESV for [%s] expired",
 673                                                 aconf->host);
 674
 675                         free_conf(aconf);
 676                         rb_dlinkDestroy(ptr, &resvTable[i]);
 677                 }
 678         }
 679         HASH_WALK_END
 680
 681         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, resv_conf_list.head)
 682         {
 683                 aconf = ptr->data;
 684
 685                 if(aconf->lifetime != 0)
 686                         continue;
 687                 if(aconf->hold && aconf->hold <= rb_current_time())
 688                 {
 689                         if(ConfigFileEntry.tkline_expire_notices)
 690                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 691                                                 "Temporary RESV for [%s] expired",
 692                                                 aconf->host);
 693                         free_conf(aconf);
 694                         rb_dlinkDestroy(ptr, &resv_conf_list);
 695                 }
 696         }
 697
 698         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, xline_conf_list.head)
 699         {
 700                 aconf = ptr->data;
 701
 702                 if(aconf->lifetime != 0)
 703                         continue;
 704                 if(aconf->hold && aconf->hold <= rb_current_time())
 705                 {
 706                         if(ConfigFileEntry.tkline_expire_notices)
 707                                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 708                                                 "Temporary X-line for [%s] expired",
 709                                                 aconf->host);
 710                         free_conf(aconf);
 711                         rb_dlinkDestroy(ptr, &xline_conf_list);
 712                 }
 713         }
 714 }
 715
 716 unsigned long
 717 get_nd_count(void)
 718 {
 719         return(rb_dlink_list_length(&nd_list));
 720 }
 721
 722 void
 723 add_nd_entry(const char *name)
 724 {
 725         struct nd_entry *nd;
 726
 727         if(irc_dictionary_find(nd_dict, name) != NULL)
 728                 return;
 729
 730         nd = rb_bh_alloc(nd_heap);
 731
 732         rb_strlcpy(nd->name, name, sizeof(nd->name));
 733         nd->expire = rb_current_time() + ConfigFileEntry.nick_delay;
 734
 735         /* this list is ordered */
 736         rb_dlinkAddTail(nd, &nd->lnode, &nd_list);
 737
 738         irc_dictionary_add(nd_dict, nd->name, nd);
 739 }
 740
 741 void
 742 free_nd_entry(struct nd_entry *nd)
 743 {
 744         irc_dictionary_delete(nd_dict, nd->name);
 745
 746         rb_dlinkDelete(&nd->lnode, &nd_list);
 747         rb_bh_free(nd_heap, nd);
 748 }
 749
 750 void
 751 expire_nd_entries(void *unused)
 752 {
 753         struct nd_entry *nd;
 754         rb_dlink_node *ptr;
 755         rb_dlink_node *next_ptr;
 756
 757         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, nd_list.head)
 758         {
 759                 nd = ptr->data;
 760
 761                 /* this list is ordered - we can stop when we hit the first
 762                  * entry that doesnt expire..
 763                  */
 764                 if(nd->expire > rb_current_time())
 765                         return;
 766
 767                 free_nd_entry(nd);
 768         }
 769 }
 770
 771 void
 772 add_tgchange(const char *host)
 773 {
 774         tgchange *target;
 775         rb_patricia_node_t *pnode;
 776
 777         if(find_tgchange(host))
 778                 return;
 779
 780         target = rb_malloc(sizeof(tgchange));
 781         pnode = make_and_lookup(tgchange_tree, host);
 782
 783         pnode->data = target;
 784         target->pnode = pnode;
 785
 786         target->ip = rb_strdup(host);
 787         target->expiry = rb_current_time() + (60*60*12);
 788
 789         rb_dlinkAdd(target, &target->node, &tgchange_list);
 790 }
 791
 792 tgchange *
 793 find_tgchange(const char *host)
 794 {
 795         rb_patricia_node_t *pnode;
 796
 797         if((pnode = rb_match_exact_string(tgchange_tree, host)))
 798                 return pnode->data;
 799
 800         return NULL;
 801 }
 802