src/hostmask.c

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