ircd/hostmask.c

   1 /*
   2  *  Solanum: a slightly advanced ircd
   3  *  hostmask.c: Code to efficiently find IP & hostmask based configs.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *  Copyright (C) 2005-2008 charybdis development team
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  23  *  USA
  24  */
  25
  26 #include "stdinc.h"
  27 #include "ircd_defs.h"
  28 #include "s_conf.h"
  29 #include "s_newconf.h"
  30 #include "hostmask.h"
  31 #include "numeric.h"
  32 #include "send.h"
  33 #include "match.h"
  34
  35 static unsigned long hash_ipv6(struct sockaddr *, int);
  36 static unsigned long hash_ipv4(struct sockaddr *, int);
  37
  38
  39 static int
  40 _parse_netmask(const char *text, struct rb_sockaddr_storage *naddr, int *nb, bool strict)
  41 {
  42         char *ip = LOCAL_COPY(text);
  43         char *ptr;
  44         char *endp;
  45         struct rb_sockaddr_storage *addr, xaddr;
  46         int *b, xb;
  47         if(nb == NULL)
  48                 b = &xb;
  49         else
  50                 b = nb;
  51
  52         if(naddr == NULL)
  53                 addr = &xaddr;
  54         else
  55                 addr = naddr;
  56
  57         if(strpbrk(ip, "*?") != NULL)
  58         {
  59                 return HM_HOST;
  60         }
  61         if(strchr(ip, ':'))
  62         {
  63                 if((ptr = strchr(ip, '/')))
  64                 {
  65                         *ptr = '\0';
  66                         ptr++;
  67                         long n = strtol(ptr, &endp, 10);
  68                         if (endp == ptr || n < 0)
  69                                 return HM_HOST;
  70                         if (n > 128 || *endp != '\0')
  71                         {
  72                                 if (strict)
  73                                         return HM_ERROR;
  74                                 else
  75                                         n = 128;
  76                         }
  77                         *b = n;
  78                 } else
  79                         *b = 128;
  80                 if(rb_inet_pton_sock(ip, addr) > 0)
  81                         return HM_IPV6;
  82                 else
  83                         return HM_HOST;
  84         } else
  85         if(strchr(text, '.'))
  86         {
  87                 if((ptr = strchr(ip, '/')))
  88                 {
  89                         *ptr = '\0';
  90                         ptr++;
  91                         long n = strtol(ptr, &endp, 10);
  92                         if (endp == ptr || n < 0)
  93                                 return HM_HOST;
  94                         if (n > 32 || *endp != '\0')
  95                         {
  96                                 if (strict)
  97                                         return HM_ERROR;
  98                                 else
  99                                         n = 32;
 100                         }
 101                         *b = n;
 102                 } else
 103                         *b = 32;
 104                 if(rb_inet_pton_sock(ip, addr) > 0)
 105                         return HM_IPV4;
 106                 else
 107                         return HM_HOST;
 108         }
 109         return HM_HOST;
 110 }
 111
 112 /* int parse_netmask(const char *, struct rb_sockaddr_storage *, int *);
 113  * Input: A hostmask, or an IPV4/6 address.
 114  * Output: An integer describing whether it is an IPV4, IPV6 address or a
 115  *         hostmask, an address(if it is an IP mask),
 116  *         a bitlength(if it is IP mask).
 117  * Side effects: None
 118  */
 119 int parse_netmask(const char *mask, struct rb_sockaddr_storage *addr, int *blen)
 120 {
 121         return _parse_netmask(mask, addr, blen, false);
 122 }
 123
 124 int parse_netmask_strict(const char *mask, struct rb_sockaddr_storage *addr, int *blen)
 125 {
 126         return _parse_netmask(mask, addr, blen, true);
 127 }
 128
 129 /* Hashtable stuff...now external as its used in m_stats.c */
 130 struct AddressRec *atable[ATABLE_SIZE];
 131
 132 void
 133 init_host_hash(void)
 134 {
 135         memset(&atable, 0, sizeof(atable));
 136 }
 137
 138 /* unsigned long hash_ipv4(struct rb_sockaddr_storage*)
 139  * Input: An IP address.
 140  * Output: A hash value of the IP address.
 141  * Side effects: None
 142  */
 143 static unsigned long
 144 hash_ipv4(struct sockaddr *saddr, int bits)
 145 {
 146         struct sockaddr_in *addr = (struct sockaddr_in *)(void *)saddr;
 147
 148         if(bits != 0)
 149         {
 150                 unsigned long av = ntohl(addr->sin_addr.s_addr) & ~((1 << (32 - bits)) - 1);
 151                 return (av ^ (av >> 12) ^ (av >> 24)) & (ATABLE_SIZE - 1);
 152         }
 153
 154         return 0;
 155 }
 156
 157 /* unsigned long hash_ipv6(struct rb_sockaddr_storage*)
 158  * Input: An IP address.
 159  * Output: A hash value of the IP address.
 160  * Side effects: None
 161  */
 162 static unsigned long
 163 hash_ipv6(struct sockaddr *saddr, int bits)
 164 {
 165         struct sockaddr_in6 *addr = (struct sockaddr_in6 *)(void *)saddr;
 166         unsigned long v = 0, n;
 167         for (n = 0; n < 16; n++)
 168         {
 169                 if(bits >= 8)
 170                 {
 171                         v ^= addr->sin6_addr.s6_addr[n];
 172                         bits -= 8;
 173                 }
 174                 else if(bits)
 175                 {
 176                         v ^= addr->sin6_addr.s6_addr[n] & ~((1 << (8 - bits)) - 1);
 177                         return v & (ATABLE_SIZE - 1);
 178                 }
 179                 else
 180                         return v & (ATABLE_SIZE - 1);
 181         }
 182         return v & (ATABLE_SIZE - 1);
 183 }
 184
 185 /* int hash_text(const char *start)
 186  * Input: The start of the text to hash.
 187  * Output: The hash of the string between 1 and (TH_MAX-1)
 188  * Side-effects: None.
 189  */
 190 static int
 191 hash_text(const char *start)
 192 {
 193         const char *p = start;
 194         unsigned long h = 0;
 195
 196         while(*p)
 197         {
 198                 h = (h << 4) - (h + (unsigned char) irctolower(*p++));
 199         }
 200
 201         return (h & (ATABLE_SIZE - 1));
 202 }
 203
 204 /* unsigned long get_hash_mask(const char *)
 205  * Input: The text to hash.
 206  * Output: The hash of the string right of the first '.' past the last
 207  *         wildcard in the string.
 208  * Side-effects: None.
 209  */
 210 static unsigned long
 211 get_mask_hash(const char *text)
 212 {
 213         const char *hp = "", *p;
 214
 215         for (p = text + strlen(text) - 1; p >= text; p--)
 216                 if(*p == '*' || *p == '?')
 217                         return hash_text(hp);
 218                 else if(*p == '.')
 219                         hp = p + 1;
 220         return hash_text(text);
 221 }
 222
 223 /* struct ConfItem* find_conf_by_address(const char*, struct rb_sockaddr_storage*,
 224  *         int type, int fam, const char *username)
 225  *
 226  * This process needs to be kept in sync with check_one_kline().
 227  *
 228  * Input: The hostname, the address, the type of mask to find, the address
 229  *        family, the username.
 230  * Output: The matching value with the highest precedence.
 231  * Side-effects: None
 232  * Note: Setting bit 0 of the type means that the username is ignored.
 233  */
 234 struct ConfItem *
 235 find_conf_by_address(const char *name, const char *sockhost,
 236                         const char *orighost,
 237                         struct sockaddr *addr, int type, int fam,
 238                         const char *username, const char *auth_user)
 239 {
 240         unsigned long hprecv = 0;
 241         struct ConfItem *hprec = NULL;
 242         struct AddressRec *arec;
 243         struct sockaddr_in ip4;
 244         struct sockaddr *pip4 = NULL;
 245         int b;
 246
 247         if(username == NULL)
 248                 username = "";
 249
 250         if(addr)
 251         {
 252                 if (fam == AF_INET)
 253                         pip4 = addr;
 254
 255                 if (fam == AF_INET6)
 256                 {
 257                         if (type == CONF_KILL && rb_ipv4_from_ipv6((struct sockaddr_in6 *)addr, &ip4))
 258                                 pip4 = (struct sockaddr *)&ip4;
 259
 260                         for (b = 128; b >= 0; b -= 16)
 261                         {
 262                                 for (arec = atable[hash_ipv6(addr, b)]; arec; arec = arec->next)
 263                                         if(arec->type == (type & ~0x1) &&
 264                                            arec->masktype == HM_IPV6 &&
 265                                            comp_with_mask_sock(addr, (struct sockaddr *)&arec->Mask.ipa.addr,
 266                                                 arec->Mask.ipa.bits) &&
 267                                                 (type & 0x1 || match(arec-> username, username)) &&
 268                                                 (type != CONF_CLIENT || !arec->auth_user ||
 269                                                 (auth_user && match(arec->auth_user, auth_user))) &&
 270                                                 arec->precedence > hprecv)
 271                                         {
 272                                                 hprecv = arec->precedence;
 273                                                 hprec = arec->aconf;
 274                                         }
 275                         }
 276                 }
 277
 278                 if (pip4 != NULL)
 279                 {
 280                         for (b = 32; b >= 0; b -= 8)
 281                         {
 282                                 for (arec = atable[hash_ipv4(pip4, b)]; arec; arec = arec->next)
 283                                         if(arec->type == (type & ~0x1) &&
 284                                            arec->masktype == HM_IPV4 &&
 285                                            comp_with_mask_sock(pip4, (struct sockaddr *)&arec->Mask.ipa.addr,
 286                                                                arec->Mask.ipa.bits) &&
 287                                                 (type & 0x1 || match(arec->username, username)) &&
 288                                                 (type != CONF_CLIENT || !arec->auth_user ||
 289                                                 (auth_user && match(arec->auth_user, auth_user))) &&
 290                                                 arec->precedence > hprecv)
 291                                         {
 292                                                 hprecv = arec->precedence;
 293                                                 hprec = arec->aconf;
 294                                         }
 295                         }
 296                 }
 297         }
 298
 299         if(orighost != NULL)
 300         {
 301                 const char *p;
 302
 303                 for (p = orighost; p != NULL;)
 304                 {
 305                         for (arec = atable[hash_text(p)]; arec; arec = arec->next)
 306
 307                                 if((arec->type == (type & ~0x1)) &&
 308                                    (arec->masktype == HM_HOST) &&
 309                                    arec->precedence > hprecv &&
 310                                    match(arec->Mask.hostname, orighost) &&
 311                                    (type != CONF_CLIENT || !arec->auth_user ||
 312                                    (auth_user && match(arec->auth_user, auth_user))) &&
 313                                    (type & 0x1 || match(arec->username, username)))
 314                                 {
 315                                         hprecv = arec->precedence;
 316                                         hprec = arec->aconf;
 317                                 }
 318                         p = strchr(p, '.');
 319                         if(p != NULL)
 320                                 p++;
 321                         else
 322                                 break;
 323                 }
 324                 for (arec = atable[0]; arec; arec = arec->next)
 325                 {
 326                         if(arec->type == (type & ~0x1) &&
 327                            arec->masktype == HM_HOST &&
 328                            arec->precedence > hprecv &&
 329                            (match(arec->Mask.hostname, orighost) ||
 330                             (sockhost && match(arec->Mask.hostname, sockhost))) &&
 331                             (type != CONF_CLIENT || !arec->auth_user ||
 332                             (auth_user && match(arec->auth_user, auth_user))) &&
 333                            (type & 0x1 || match(arec->username, username)))
 334                         {
 335                                 hprecv = arec->precedence;
 336                                 hprec = arec->aconf;
 337                         }
 338                 }
 339         }
 340
 341         if(name != NULL)
 342         {
 343                 const char *p;
 344                 /* And yes - we have to check p after strchr and p after increment for
 345                  * NULL -kre */
 346                 for (p = name; p != NULL;)
 347                 {
 348                         for (arec = atable[hash_text(p)]; arec; arec = arec->next)
 349                                 if((arec->type == (type & ~0x1)) &&
 350                                    (arec->masktype == HM_HOST) &&
 351                                    arec->precedence > hprecv &&
 352                                    match(arec->Mask.hostname, name) &&
 353                                    (type != CONF_CLIENT || !arec->auth_user ||
 354                                    (auth_user && match(arec->auth_user, auth_user))) &&
 355                                    (type & 0x1 || match(arec->username, username)))
 356                                 {
 357                                         hprecv = arec->precedence;
 358                                         hprec = arec->aconf;
 359                                 }
 360                         p = strchr(p, '.');
 361                         if(p != NULL)
 362                                 p++;
 363                         else
 364                                 break;
 365                 }
 366                 for (arec = atable[0]; arec; arec = arec->next)
 367                 {
 368                         if(arec->type == (type & ~0x1) &&
 369                            arec->masktype == HM_HOST &&
 370                            arec->precedence > hprecv &&
 371                            (match(arec->Mask.hostname, name) ||
 372                             (sockhost && match(arec->Mask.hostname, sockhost))) &&
 373                             (type != CONF_CLIENT || !arec->auth_user ||
 374                             (auth_user && match(arec->auth_user, auth_user))) &&
 375                            (type & 0x1 || match(arec->username, username)))
 376                         {
 377                                 hprecv = arec->precedence;
 378                                 hprec = arec->aconf;
 379                         }
 380                 }
 381         }
 382         return hprec;
 383 }
 384
 385 /* struct ConfItem* find_address_conf(const char*, const char*,
 386  *                                     struct rb_sockaddr_storage*, int);
 387  * Input: The hostname, username, address, address family.
 388  * Output: The applicable ConfItem.
 389  * Side-effects: None
 390  */
 391 struct ConfItem *
 392 find_address_conf(const char *host, const char *sockhost, const char *user,
 393                 const char *notildeuser, struct sockaddr *ip, int aftype, char *auth_user)
 394 {
 395         struct ConfItem *iconf, *kconf;
 396         const char *vuser;
 397
 398         /* Find the best I-line... If none, return NULL -A1kmm */
 399         if(!(iconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_CLIENT, aftype, user, auth_user)))
 400                 return NULL;
 401         /* Find what their visible username will be.
 402          * Note that the username without tilde may contain one char more.
 403          * -- jilles */
 404         vuser = IsNoTilde(iconf) ? notildeuser : user;
 405
 406         /* If they are exempt from K-lines, return the best I-line. -A1kmm */
 407         if(IsConfExemptKline(iconf))
 408                 return iconf;
 409
 410         /* if theres a spoof, check it against klines.. */
 411         if(IsConfDoSpoofIp(iconf))
 412         {
 413                 char *p = strchr(iconf->info.name, '@');
 414
 415                 /* note, we dont need to pass sockhost here, as its
 416                  * guaranteed to not match by whats below.. --anfl
 417                  */
 418                 if(p)
 419                 {
 420                         *p = '\0';
 421                         kconf = find_conf_by_address(p+1, NULL, NULL, NULL, CONF_KILL, aftype, iconf->info.name, NULL);
 422                         *p = '@';
 423                 }
 424                 else
 425                         kconf = find_conf_by_address(iconf->info.name, NULL, NULL, NULL, CONF_KILL, aftype, vuser, NULL);
 426
 427                 if(kconf)
 428                         return kconf;
 429
 430                 /* everything else checks real hosts, if they're kline_spoof_ip we're done */
 431                 if(IsConfKlineSpoof(iconf))
 432                         return iconf;
 433         }
 434
 435         /* Find the best K-line... -A1kmm */
 436         kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, user, NULL);
 437
 438         /* If they are K-lined, return the K-line */
 439         if(kconf)
 440                 return kconf;
 441
 442         /* if no_tilde, check the username without tilde against klines too
 443          * -- jilles */
 444         if(user != vuser)
 445         {
 446                 kconf = find_conf_by_address(host, sockhost, NULL, ip, CONF_KILL, aftype, vuser, NULL);
 447                 if(kconf)
 448                         return kconf;
 449         }
 450
 451         return iconf;
 452 }
 453
 454 /* struct ConfItem* find_dline(struct rb_sockaddr_storage*, int)
 455  * Input: An address, an address family.
 456  * Output: The best matching D-line or exempt line.
 457  * Side effects: None.
 458  */
 459 struct ConfItem *
 460 find_dline(struct sockaddr *addr, int aftype)
 461 {
 462         struct ConfItem *aconf;
 463         struct sockaddr_in addr2;
 464
 465         aconf = find_conf_by_address(NULL, NULL, NULL, addr, CONF_EXEMPTDLINE | 1, aftype, NULL, NULL);
 466         if(aconf)
 467                 return aconf;
 468         aconf = find_conf_by_address(NULL, NULL, NULL, addr, CONF_DLINE | 1, aftype, NULL, NULL);
 469         if(aconf)
 470                 return aconf;
 471         if(addr->sa_family == AF_INET6 &&
 472                         rb_ipv4_from_ipv6((const struct sockaddr_in6 *)(const void *)addr, &addr2))
 473         {
 474                 aconf = find_conf_by_address(NULL, NULL, NULL, (struct sockaddr *)&addr2, CONF_DLINE | 1, AF_INET, NULL, NULL);
 475                 if(aconf)
 476                         return aconf;
 477         }
 478         return NULL;
 479 }
 480
 481 /* void find_exact_conf_by_address(const char*, int, const char *)
 482  * Input:
 483  * Output: ConfItem if found
 484  * Side-effects: None
 485  */
 486 struct ConfItem *
 487 find_exact_conf_by_address(const char *address, int type, const char *username)
 488 {
 489         int masktype, bits;
 490         unsigned long hv;
 491         struct AddressRec *arec;
 492         struct rb_sockaddr_storage addr;
 493
 494         if(address == NULL)
 495                 address = "/NOMATCH!/";
 496         masktype = parse_netmask(address, &addr, &bits);
 497         if(masktype == HM_IPV6)
 498         {
 499                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 500                 hv = hash_ipv6((struct sockaddr *)&addr, bits - bits % 16);
 501         }
 502         else if(masktype == HM_IPV4)
 503         {
 504                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 505                 hv = hash_ipv4((struct sockaddr *)&addr, bits - bits % 8);
 506         }
 507         else
 508         {
 509                 hv = get_mask_hash(address);
 510         }
 511         for (arec = atable[hv]; arec; arec = arec->next)
 512         {
 513                 if (arec->type == type &&
 514                                 arec->masktype == masktype &&
 515                                 (arec->username == NULL || username == NULL ? arec->username == username : !irccmp(arec->username, username)))
 516                 {
 517                         if (masktype == HM_HOST)
 518                         {
 519                                 if (!irccmp(arec->Mask.hostname, address))
 520                                         return arec->aconf;
 521                         }
 522                         else
 523                         {
 524                                 if (arec->Mask.ipa.bits == bits &&
 525                                         comp_with_mask_sock((struct sockaddr *)&arec->Mask.ipa.addr, (struct sockaddr *)&addr, bits))
 526                                         return arec->aconf;
 527                         }
 528                 }
 529         }
 530         return NULL;
 531 }
 532
 533 /* void add_conf_by_address(const char*, int, const char *,
 534  *         struct ConfItem *aconf)
 535  * Input:
 536  * Output: None
 537  * Side-effects: Adds this entry to the hash table.
 538  */
 539 void
 540 add_conf_by_address(const char *address, int type, const char *username, const char *auth_user, struct ConfItem *aconf)
 541 {
 542         static unsigned long prec_value = 0xFFFFFFFF;
 543         int bits;
 544         unsigned long hv;
 545         struct AddressRec *arec;
 546
 547         if(address == NULL)
 548                 address = "/NOMATCH!/";
 549         arec = rb_malloc(sizeof(struct AddressRec));
 550         arec->masktype = parse_netmask(address, &arec->Mask.ipa.addr, &bits);
 551         if(arec->masktype == HM_IPV6)
 552         {
 553                 arec->Mask.ipa.bits = bits;
 554                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 555                 bits -= bits % 16;
 556                 arec->next = atable[(hv = hash_ipv6((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
 557                 atable[hv] = arec;
 558         }
 559         else if(arec->masktype == HM_IPV4)
 560         {
 561                 arec->Mask.ipa.bits = bits;
 562                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 563                 bits -= bits % 8;
 564                 arec->next = atable[(hv = hash_ipv4((struct sockaddr *)&arec->Mask.ipa.addr, bits))];
 565                 atable[hv] = arec;
 566         }
 567         else
 568         {
 569                 arec->Mask.hostname = address;
 570                 arec->next = atable[(hv = get_mask_hash(address))];
 571                 atable[hv] = arec;
 572         }
 573         arec->username = username;
 574         arec->auth_user = auth_user;
 575         arec->aconf = aconf;
 576         arec->precedence = prec_value--;
 577         arec->type = type;
 578 }
 579
 580 /* void delete_one_address(const char*, struct ConfItem*)
 581  * Input: An address string, the associated ConfItem.
 582  * Output: None
 583  * Side effects: Deletes an address record. Frees the ConfItem if there
 584  *               is nothing referencing it, sets it as illegal otherwise.
 585  */
 586 void
 587 delete_one_address_conf(const char *address, struct ConfItem *aconf)
 588 {
 589         int masktype, bits;
 590         unsigned long hv;
 591         struct AddressRec *arec, *arecl = NULL;
 592         struct rb_sockaddr_storage addr;
 593         masktype = parse_netmask(address, &addr, &bits);
 594         if(masktype == HM_IPV6)
 595         {
 596                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 597                 bits -= bits % 16;
 598                 hv = hash_ipv6((struct sockaddr *)&addr, bits);
 599         }
 600         else if(masktype == HM_IPV4)
 601         {
 602                 /* We have to do this, since we do not re-hash for every bit -A1kmm. */
 603                 bits -= bits % 8;
 604                 hv = hash_ipv4((struct sockaddr *)&addr, bits);
 605         }
 606         else
 607                 hv = get_mask_hash(address);
 608         for (arec = atable[hv]; arec; arec = arec->next)
 609         {
 610                 if(arec->aconf == aconf)
 611                 {
 612                         if(arecl)
 613                                 arecl->next = arec->next;
 614                         else
 615                                 atable[hv] = arec->next;
 616                         aconf->status |= CONF_ILLEGAL;
 617                         if(!aconf->clients)
 618                                 free_conf(aconf);
 619                         rb_free(arec);
 620                         return;
 621                 }
 622                 arecl = arec;
 623         }
 624 }
 625
 626 /* void clear_out_address_conf(void)
 627  * Input: None
 628  * Output: None
 629  * Side effects: Clears out all address records in the hash table,
 630  *               frees them, and frees the ConfItems if nothing references
 631  *               them, otherwise sets them as illegal.
 632  */
 633 void
 634 clear_out_address_conf(void)
 635 {
 636         int i;
 637         struct AddressRec **store_next;
 638         struct AddressRec *arec, *arecn;
 639
 640         for (i = 0; i < ATABLE_SIZE; i++)
 641         {
 642                 store_next = &atable[i];
 643                 for (arec = atable[i]; arec; arec = arecn)
 644                 {
 645                         arecn = arec->next;
 646                         /* We keep the temporary K-lines and destroy the
 647                          * permanent ones, just to be confusing :) -A1kmm */
 648                         if(arec->aconf->flags & CONF_FLAGS_TEMPORARY ||
 649                            (arec->type != CONF_CLIENT && arec->type != CONF_EXEMPTDLINE))
 650                         {
 651                                 *store_next = arec;
 652                                 store_next = &arec->next;
 653                         }
 654                         else
 655                         {
 656                                 arec->aconf->status |= CONF_ILLEGAL;
 657                                 if(!arec->aconf->clients)
 658                                         free_conf(arec->aconf);
 659                                 rb_free(arec);
 660                         }
 661                 }
 662                 *store_next = NULL;
 663         }
 664 }
 665
 666 void
 667 clear_out_address_conf_bans(void)
 668 {
 669         int i;
 670         struct AddressRec **store_next;
 671         struct AddressRec *arec, *arecn;
 672
 673         for (i = 0; i < ATABLE_SIZE; i++)
 674         {
 675                 store_next = &atable[i];
 676                 for (arec = atable[i]; arec; arec = arecn)
 677                 {
 678                         arecn = arec->next;
 679                         /* We keep the temporary K-lines and destroy the
 680                          * permanent ones, just to be confusing :) -A1kmm */
 681                         if(arec->aconf->flags & CONF_FLAGS_TEMPORARY ||
 682                            (arec->type == CONF_CLIENT || arec->type == CONF_EXEMPTDLINE))
 683                         {
 684                                 *store_next = arec;
 685                                 store_next = &arec->next;
 686                         }
 687                         else
 688                         {
 689                                 arec->aconf->status |= CONF_ILLEGAL;
 690                                 if(!arec->aconf->clients)
 691                                         free_conf(arec->aconf);
 692                                 rb_free(arec);
 693                         }
 694                 }
 695                 *store_next = NULL;
 696         }
 697 }
 698
 699
 700 /*
 701  * show_iline_prefix()
 702  *
 703  * inputs       - pointer to struct Client requesting output
 704  *              - pointer to struct ConfItem
 705  *              - name to which iline prefix will be prefixed to
 706  * output       - pointer to static string with prefixes listed in ascii form
 707  * side effects - NONE
 708  */
 709 char *
 710 show_iline_prefix(struct Client *sptr, struct ConfItem *aconf, char *name)
 711 {
 712         static char prefix_of_host[USERLEN + 15];
 713         char *prefix_ptr;
 714
 715         prefix_ptr = prefix_of_host;
 716         if(IsNoTilde(aconf))
 717                 *prefix_ptr++ = '-';
 718         if(IsNeedIdentd(aconf))
 719                 *prefix_ptr++ = '+';
 720         if(IsConfDoSpoofIp(aconf))
 721                 *prefix_ptr++ = '=';
 722         if(IsOper(sptr) && IsConfExemptFlood(aconf))
 723                 *prefix_ptr++ = '|';
 724         if(IsOper(sptr) && IsConfExemptDNSBL(aconf) && !IsConfExemptKline(aconf))
 725                 *prefix_ptr++ = '$';
 726         if(IsOper(sptr) && IsConfExemptKline(aconf))
 727                 *prefix_ptr++ = '^';
 728         if(IsOper(sptr) && IsConfExemptLimits(aconf))
 729                 *prefix_ptr++ = '>';
 730         *prefix_ptr = '\0';
 731         strncpy(prefix_ptr, name, USERLEN);
 732         return (prefix_of_host);
 733 }
 734
 735 /* report_auth()
 736  *
 737  * Inputs: pointer to client to report to
 738  * Output: None
 739  * Side effects: Reports configured auth{} blocks to client_p
 740  */
 741 void
 742 report_auth(struct Client *client_p)
 743 {
 744         char *name, *host, *user, *classname;
 745         const char *pass;
 746         struct AddressRec *arec;
 747         struct ConfItem *aconf;
 748         int i, port;
 749
 750         for (i = 0; i < ATABLE_SIZE; i++)
 751                 for (arec = atable[i]; arec; arec = arec->next)
 752                         if(arec->type == CONF_CLIENT)
 753                         {
 754                                 aconf = arec->aconf;
 755
 756                                 if(!IsOperGeneral(client_p) && IsConfDoSpoofIp(aconf))
 757                                         continue;
 758
 759                                 get_printable_conf(aconf, &name, &host, &pass, &user, &port,
 760                                                    &classname);
 761
 762                                 if(!EmptyString(aconf->spasswd))
 763                                         pass = aconf->spasswd;
 764
 765                                 sendto_one_numeric(client_p, RPL_STATSILINE,
 766                                                    form_str(RPL_STATSILINE),
 767                                                    name, pass, show_iline_prefix(client_p, aconf, user),
 768                                                    show_ip_conf(aconf, client_p) ? host : "255.255.255.255",
 769                                                    port, classname);
 770                         }
 771 }
 772