src/newconf.c

   1 /* This code is in the public domain.
   2  * $Id: newconf.c 3550 2007-08-09 06:47:26Z nenolod $
   3  */
   4
   5 #include "stdinc.h"
   6
   7 #ifdef HAVE_LIBCRYPTO
   8 #include <openssl/pem.h>
   9 #include <openssl/rsa.h>
  10 #endif
  11
  12 #include "newconf.h"
  13 #include "ircd_defs.h"
  14 #include "common.h"
  15 #include "logger.h"
  16 #include "s_conf.h"
  17 #include "s_user.h"
  18 #include "s_newconf.h"
  19 #include "send.h"
  20 #include "setup.h"
  21 #include "modules.h"
  22 #include "listener.h"
  23 #include "hostmask.h"
  24 #include "s_serv.h"
  25 #include "hash.h"
  26 #include "cache.h"
  27 #include "ircd.h"
  28 #include "snomask.h"
  29 #include "blacklist.h"
  30 #include "sslproc.h"
  31 #include "privilege.h"
  32
  33 #define CF_TYPE(x) ((x) & CF_MTYPE)
  34
  35 struct TopConf *conf_cur_block;
  36 static char *conf_cur_block_name;
  37
  38 static rb_dlink_list conf_items;
  39
  40 static struct ConfItem *yy_aconf = NULL;
  41
  42 static struct Class *yy_class = NULL;
  43
  44 static struct remote_conf *yy_shared = NULL;
  45 static struct server_conf *yy_server = NULL;
  46
  47 static rb_dlink_list yy_aconf_list;
  48 static rb_dlink_list yy_oper_list;
  49 static rb_dlink_list yy_shared_list;
  50 static rb_dlink_list yy_cluster_list;
  51 static struct oper_conf *yy_oper = NULL;
  52
  53 static struct alias_entry *yy_alias = NULL;
  54
  55 static char *yy_blacklist_host = NULL;
  56 static char *yy_blacklist_reason = NULL;
  57 static char *yy_privset_extends = NULL;
  58
  59 static const char *
  60 conf_strtype(int type)
  61 {
  62         switch (type & CF_MTYPE)
  63         {
  64         case CF_INT:
  65                 return "integer value";
  66         case CF_STRING:
  67                 return "unquoted string";
  68         case CF_YESNO:
  69                 return "yes/no value";
  70         case CF_QSTRING:
  71                 return "quoted string";
  72         case CF_TIME:
  73                 return "time/size value";
  74         default:
  75                 return "unknown type";
  76         }
  77 }
  78
  79 int
  80 add_top_conf(const char *name, int (*sfunc) (struct TopConf *),
  81                 int (*efunc) (struct TopConf *), struct ConfEntry *items)
  82 {
  83         struct TopConf *tc;
  84
  85         tc = rb_malloc(sizeof(struct TopConf));
  86
  87         tc->tc_name = name;
  88         tc->tc_sfunc = sfunc;
  89         tc->tc_efunc = efunc;
  90         tc->tc_entries = items;
  91
  92         rb_dlinkAddAlloc(tc, &conf_items);
  93         return 0;
  94 }
  95
  96 struct TopConf *
  97 find_top_conf(const char *name)
  98 {
  99         rb_dlink_node *d;
 100         struct TopConf *tc;
 101
 102         RB_DLINK_FOREACH(d, conf_items.head)
 103         {
 104                 tc = d->data;
 105                 if(strcasecmp(tc->tc_name, name) == 0)
 106                         return tc;
 107         }
 108
 109         return NULL;
 110 }
 111
 112
 113 struct ConfEntry *
 114 find_conf_item(const struct TopConf *top, const char *name)
 115 {
 116         struct ConfEntry *cf;
 117         rb_dlink_node *d;
 118
 119         if(top->tc_entries)
 120         {
 121                 int i;
 122
 123                 for(i = 0; top->tc_entries[i].cf_type; i++)
 124                 {
 125                         cf = &top->tc_entries[i];
 126
 127                         if(!strcasecmp(cf->cf_name, name))
 128                                 return cf;
 129                 }
 130         }
 131
 132         RB_DLINK_FOREACH(d, top->tc_items.head)
 133         {
 134                 cf = d->data;
 135                 if(strcasecmp(cf->cf_name, name) == 0)
 136                         return cf;
 137         }
 138
 139         return NULL;
 140 }
 141
 142 int
 143 remove_top_conf(char *name)
 144 {
 145         struct TopConf *tc;
 146         rb_dlink_node *ptr;
 147
 148         if((tc = find_top_conf(name)) == NULL)
 149                 return -1;
 150
 151         if((ptr = rb_dlinkFind(tc, &conf_items)) == NULL)
 152                 return -1;
 153
 154         rb_dlinkDestroy(ptr, &conf_items);
 155         rb_free(tc);
 156
 157         return 0;
 158 }
 159
 160 static void
 161 conf_set_serverinfo_name(void *data)
 162 {
 163         if(ServerInfo.name == NULL)
 164         {
 165                 const char *s;
 166                 int dots = 0;
 167
 168                 for(s = data; *s != '\0'; s++)
 169                 {
 170                         if(!IsServChar(*s))
 171                         {
 172                                 conf_report_error("Ignoring serverinfo::name "
 173                                                   "-- bogus servername.");
 174                                 return;
 175                         }
 176                         else if(*s == '.')
 177                                 ++dots;
 178                 }
 179
 180                 if(!dots)
 181                 {
 182                         conf_report_error("Ignoring serverinfo::name -- must contain '.'");
 183                         return;
 184                 }
 185
 186                 s = data;
 187
 188                 if(IsDigit(*s))
 189                 {
 190                         conf_report_error("Ignoring serverinfo::name -- cannot begin with digit.");
 191                         return;
 192                 }
 193
 194                 /* the ircd will exit() in main() if we dont set one */
 195                 if(strlen(s) <= HOSTLEN)
 196                         ServerInfo.name = rb_strdup((char *) data);
 197         }
 198 }
 199
 200 static void
 201 conf_set_serverinfo_sid(void *data)
 202 {
 203         char *sid = data;
 204
 205         if(ServerInfo.sid[0] == '\0')
 206         {
 207                 if(!IsDigit(sid[0]) || !IsIdChar(sid[1]) ||
 208                    !IsIdChar(sid[2]) || sid[3] != '\0')
 209                 {
 210                         conf_report_error("Ignoring serverinfo::sid "
 211                                           "-- bogus sid.");
 212                         return;
 213                 }
 214
 215                 strcpy(ServerInfo.sid, sid);
 216         }
 217 }
 218
 219 static void
 220 conf_set_serverinfo_network_name(void *data)
 221 {
 222         char *p;
 223
 224         if((p = strchr((char *) data, ' ')))
 225                 *p = '\0';
 226
 227         rb_free(ServerInfo.network_name);
 228         ServerInfo.network_name = rb_strdup((char *) data);
 229 }
 230
 231 static void
 232 conf_set_serverinfo_vhost(void *data)
 233 {
 234         if(rb_inet_pton(AF_INET, (char *) data, &ServerInfo.ip.sin_addr) <= 0)
 235         {
 236                 conf_report_error("Invalid netmask for server IPv4 vhost (%s)", (char *) data);
 237                 return;
 238         }
 239         ServerInfo.ip.sin_family = AF_INET;
 240         ServerInfo.specific_ipv4_vhost = 1;
 241 }
 242
 243 static void
 244 conf_set_serverinfo_vhost6(void *data)
 245 {
 246 #ifdef RB_IPV6
 247         if(rb_inet_pton(AF_INET6, (char *) data, &ServerInfo.ip6.sin6_addr) <= 0)
 248         {
 249                 conf_report_error("Invalid netmask for server IPv6 vhost (%s)", (char *) data);
 250                 return;
 251         }
 252
 253         ServerInfo.specific_ipv6_vhost = 1;
 254         ServerInfo.ip6.sin6_family = AF_INET6;
 255 #else
 256         conf_report_error("Warning -- ignoring serverinfo::vhost6 -- IPv6 support not available.");
 257 #endif
 258 }
 259
 260 static void
 261 conf_set_modules_module(void *data)
 262 {
 263 #ifndef STATIC_MODULES
 264         char *m_bn;
 265
 266         m_bn = rb_basename((char *) data);
 267
 268         if(findmodule_byname(m_bn) != -1)
 269                 return;
 270
 271         load_one_module((char *) data, 0);
 272
 273         rb_free(m_bn);
 274 #else
 275         conf_report_error("Ignoring modules::module -- loadable module support not present.");
 276 #endif
 277 }
 278
 279 static void
 280 conf_set_modules_path(void *data)
 281 {
 282 #ifndef STATIC_MODULES
 283         mod_add_path((char *) data);
 284 #else
 285         conf_report_error("Ignoring modules::path -- loadable module support not present.");
 286 #endif
 287 }
 288
 289 struct mode_table
 290 {
 291         const char *name;
 292         int mode;
 293 };
 294
 295 /* *INDENT-OFF* */
 296 static struct mode_table umode_table[] = {
 297         {"callerid",    UMODE_CALLERID  },
 298         {"deaf",        UMODE_DEAF      },
 299         {"invisible",   UMODE_INVISIBLE },
 300         {"locops",      UMODE_LOCOPS    },
 301         {"noforward",   UMODE_NOFORWARD },
 302         {"regonlymsg",  UMODE_REGONLYMSG},
 303         {"servnotice",  UMODE_SERVNOTICE},
 304         {"wallop",      UMODE_WALLOP    },
 305         {"operwall",    UMODE_OPERWALL  },
 306         {NULL, 0}
 307 };
 308
 309 static struct mode_table oper_table[] = {
 310         {"encrypted",           OPER_ENCRYPTED          },
 311         {"need_ssl",            OPER_NEEDSSL            },
 312         {NULL, 0}
 313 };
 314
 315 static struct mode_table auth_table[] = {
 316         {"encrypted",           CONF_FLAGS_ENCRYPTED    },
 317         {"spoof_notice",        CONF_FLAGS_SPOOF_NOTICE },
 318         {"exceed_limit",        CONF_FLAGS_NOLIMIT      },
 319         {"dnsbl_exempt",        CONF_FLAGS_EXEMPTDNSBL  },
 320         {"kline_exempt",        CONF_FLAGS_EXEMPTKLINE  },
 321         {"flood_exempt",        CONF_FLAGS_EXEMPTFLOOD  },
 322         {"spambot_exempt",      CONF_FLAGS_EXEMPTSPAMBOT },
 323         {"shide_exempt",        CONF_FLAGS_EXEMPTSHIDE  },
 324         {"jupe_exempt",         CONF_FLAGS_EXEMPTJUPE   },
 325         {"resv_exempt",         CONF_FLAGS_EXEMPTRESV   },
 326         {"no_tilde",            CONF_FLAGS_NO_TILDE     },
 327         {"need_ident",          CONF_FLAGS_NEED_IDENTD  },
 328         {"have_ident",          CONF_FLAGS_NEED_IDENTD  },
 329         {"need_ssl",            CONF_FLAGS_NEED_SSL     },
 330         {"need_sasl",           CONF_FLAGS_NEED_SASL    },
 331         {NULL, 0}
 332 };
 333
 334 static struct mode_table connect_table[] = {
 335         { "autoconn",   SERVER_AUTOCONN         },
 336         { "compressed", SERVER_COMPRESSED       },
 337         { "encrypted",  SERVER_ENCRYPTED        },
 338         { "topicburst", SERVER_TB               },
 339         { "ssl",        SERVER_SSL              },
 340         { NULL,         0                       },
 341 };
 342
 343 static struct mode_table cluster_table[] = {
 344         { "kline",      SHARED_PKLINE   },
 345         { "tkline",     SHARED_TKLINE   },
 346         { "unkline",    SHARED_UNKLINE  },
 347         { "locops",     SHARED_LOCOPS   },
 348         { "xline",      SHARED_PXLINE   },
 349         { "txline",     SHARED_TXLINE   },
 350         { "unxline",    SHARED_UNXLINE  },
 351         { "resv",       SHARED_PRESV    },
 352         { "tresv",      SHARED_TRESV    },
 353         { "unresv",     SHARED_UNRESV   },
 354         { "all",        CLUSTER_ALL     },
 355         {NULL, 0}
 356 };
 357
 358 static struct mode_table shared_table[] =
 359 {
 360         { "kline",      SHARED_PKLINE|SHARED_TKLINE     },
 361         { "xline",      SHARED_PXLINE|SHARED_TXLINE     },
 362         { "resv",       SHARED_PRESV|SHARED_TRESV       },
 363         { "dline",  SHARED_PDLINE|SHARED_TDLINE },
 364         { "tdline", SHARED_TDLINE       },
 365         { "pdline", SHARED_PDLINE   },
 366         { "undline",    SHARED_UNDLINE  },
 367         { "tkline",     SHARED_TKLINE   },
 368         { "unkline",    SHARED_UNKLINE  },
 369         { "txline",     SHARED_TXLINE   },
 370         { "unxline",    SHARED_UNXLINE  },
 371         { "tresv",      SHARED_TRESV    },
 372         { "unresv",     SHARED_UNRESV   },
 373         { "locops",     SHARED_LOCOPS   },
 374         { "rehash",     SHARED_REHASH   },
 375         { "all",        SHARED_ALL      },
 376         { "none",       0               },
 377         {NULL, 0}
 378 };
 379 /* *INDENT-ON* */
 380
 381 static int
 382 find_umode(struct mode_table *tab, const char *name)
 383 {
 384         int i;
 385
 386         for (i = 0; tab[i].name; i++)
 387         {
 388                 if(strcmp(tab[i].name, name) == 0)
 389                         return tab[i].mode;
 390         }
 391
 392         return -1;
 393 }
 394
 395 static void
 396 set_modes_from_table(int *modes, const char *whatis, struct mode_table *tab, conf_parm_t * args)
 397 {
 398         for (; args; args = args->next)
 399         {
 400                 const char *umode;
 401                 int dir = 1;
 402                 int mode;
 403
 404                 if((args->type & CF_MTYPE) != CF_STRING)
 405                 {
 406                         conf_report_error("Warning -- %s is not a string; ignoring.", whatis);
 407                         continue;
 408                 }
 409
 410                 umode = args->v.string;
 411
 412                 if(*umode == '~')
 413                 {
 414                         dir = 0;
 415                         umode++;
 416                 }
 417
 418                 mode = find_umode(tab, umode);
 419
 420                 if(mode == -1)
 421                 {
 422                         conf_report_error("Warning -- unknown %s %s.", whatis, args->v.string);
 423                         continue;
 424                 }
 425
 426                 if(mode)
 427                 {
 428                         if(dir)
 429                                 *modes |= mode;
 430                         else
 431                                 *modes &= ~mode;
 432                 }
 433                 else
 434                         *modes = 0;
 435         }
 436 }
 437
 438 static void
 439 conf_set_privset_extends(void *data)
 440 {
 441         yy_privset_extends = rb_strdup((char *) data);
 442 }
 443
 444 static void
 445 conf_set_privset_privs(void *data)
 446 {
 447         char *privs = NULL;
 448         conf_parm_t *args = data;
 449
 450         for (; args; args = args->next)
 451         {
 452                 if (privs == NULL)
 453                         privs = rb_strdup(args->v.string);
 454                 else
 455                 {
 456                         char *privs_old = privs;
 457
 458                         privs = rb_malloc(strlen(privs_old) + 1 + strlen(args->v.string) + 1);
 459                         strcpy(privs, privs_old);
 460                         strcat(privs, " ");
 461                         strcat(privs, args->v.string);
 462
 463                         rb_free(privs_old);
 464                 }
 465         }
 466
 467         if (privs)
 468         {
 469                 if (yy_privset_extends)
 470                 {
 471                         struct PrivilegeSet *set = privilegeset_get(yy_privset_extends);
 472
 473                         if (!set)
 474                         {
 475                                 conf_report_error("Warning -- unknown parent privilege set %s for %s; assuming defaults", yy_privset_extends, conf_cur_block_name);
 476
 477                                 set = privilegeset_get("default");
 478                         }
 479
 480                         privilegeset_extend(set, conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
 481
 482                         rb_free(yy_privset_extends);
 483                         yy_privset_extends = NULL;
 484                 }
 485                 else
 486                         privilegeset_set_new(conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
 487
 488                 rb_free(privs);
 489         }
 490 }
 491
 492 static int
 493 conf_begin_oper(struct TopConf *tc)
 494 {
 495         rb_dlink_node *ptr;
 496         rb_dlink_node *next_ptr;
 497
 498         if(yy_oper != NULL)
 499         {
 500                 free_oper_conf(yy_oper);
 501                 yy_oper = NULL;
 502         }
 503
 504         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
 505         {
 506                 free_oper_conf(ptr->data);
 507                 rb_dlinkDestroy(ptr, &yy_oper_list);
 508         }
 509
 510         yy_oper = make_oper_conf();
 511         yy_oper->flags |= OPER_ENCRYPTED;
 512
 513         return 0;
 514 }
 515
 516 static int
 517 conf_end_oper(struct TopConf *tc)
 518 {
 519         struct oper_conf *yy_tmpoper;
 520         rb_dlink_node *ptr;
 521         rb_dlink_node *next_ptr;
 522
 523         if(conf_cur_block_name != NULL)
 524         {
 525                 if(strlen(conf_cur_block_name) > OPERNICKLEN)
 526                         conf_cur_block_name[OPERNICKLEN] = '\0';
 527
 528                 yy_oper->name = rb_strdup(conf_cur_block_name);
 529         }
 530
 531         if(EmptyString(yy_oper->name))
 532         {
 533                 conf_report_error("Ignoring operator block -- missing name.");
 534                 return 0;
 535         }
 536
 537 #ifdef HAVE_LIBCRYPTO
 538         if(EmptyString(yy_oper->passwd) && EmptyString(yy_oper->rsa_pubkey_file))
 539 #else
 540         if(EmptyString(yy_oper->passwd))
 541 #endif
 542         {
 543                 conf_report_error("Ignoring operator block for %s -- missing password",
 544                                         yy_oper->name);
 545                 return 0;
 546         }
 547
 548
 549         if (!yy_oper->privset)
 550                 yy_oper->privset = privilegeset_get("default");
 551
 552         /* now, yy_oper_list contains a stack of oper_conf's with just user
 553          * and host in, yy_oper contains the rest of the information which
 554          * we need to copy into each element in yy_oper_list
 555          */
 556         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
 557         {
 558                 yy_tmpoper = ptr->data;
 559
 560                 yy_tmpoper->name = rb_strdup(yy_oper->name);
 561
 562                 /* could be an rsa key instead.. */
 563                 if(!EmptyString(yy_oper->passwd))
 564                         yy_tmpoper->passwd = rb_strdup(yy_oper->passwd);
 565
 566                 yy_tmpoper->flags = yy_oper->flags;
 567                 yy_tmpoper->umodes = yy_oper->umodes;
 568                 yy_tmpoper->snomask = yy_oper->snomask;
 569                 yy_tmpoper->privset = yy_oper->privset;
 570
 571 #ifdef HAVE_LIBCRYPTO
 572                 if(yy_oper->rsa_pubkey_file)
 573                 {
 574                         BIO *file;
 575
 576                         if((file = BIO_new_file(yy_oper->rsa_pubkey_file, "r")) == NULL)
 577                         {
 578                                 conf_report_error("Ignoring operator block for %s -- "
 579                                                 "rsa_public_key_file cant be opened",
 580                                                 yy_tmpoper->name);
 581                                 return 0;
 582                         }
 583
 584                         yy_tmpoper->rsa_pubkey =
 585                                 (RSA *) PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
 586
 587                         (void)BIO_set_close(file, BIO_CLOSE);
 588                         BIO_free(file);
 589
 590                         if(yy_tmpoper->rsa_pubkey == NULL)
 591                         {
 592                                 conf_report_error("Ignoring operator block for %s -- "
 593                                                 "rsa_public_key_file key invalid; check syntax",
 594                                                 yy_tmpoper->name);
 595                                 return 0;
 596                         }
 597                 }
 598 #endif
 599
 600                 /* all is ok, put it on oper_conf_list */
 601                 rb_dlinkMoveNode(ptr, &yy_oper_list, &oper_conf_list);
 602         }
 603
 604         free_oper_conf(yy_oper);
 605         yy_oper = NULL;
 606
 607         return 0;
 608 }
 609
 610 static void
 611 conf_set_oper_flags(void *data)
 612 {
 613         conf_parm_t *args = data;
 614
 615         set_modes_from_table(&yy_oper->flags, "flag", oper_table, args);
 616 }
 617
 618 static void
 619 conf_set_oper_fingerprint(void *data)
 620 {
 621         yy_oper->certfp = rb_strdup((char *) data);
 622 }
 623
 624 static void
 625 conf_set_oper_privset(void *data)
 626 {
 627         yy_oper->privset = privilegeset_get((char *) data);
 628 }
 629
 630 static void
 631 conf_set_oper_user(void *data)
 632 {
 633         struct oper_conf *yy_tmpoper;
 634         char *p;
 635         char *host = (char *) data;
 636
 637         yy_tmpoper = make_oper_conf();
 638
 639         if((p = strchr(host, '@')))
 640         {
 641                 *p++ = '\0';
 642
 643                 yy_tmpoper->username = rb_strdup(host);
 644                 yy_tmpoper->host = rb_strdup(p);
 645         }
 646         else
 647         {
 648
 649                 yy_tmpoper->username = rb_strdup("*");
 650                 yy_tmpoper->host = rb_strdup(host);
 651         }
 652
 653         if(EmptyString(yy_tmpoper->username) || EmptyString(yy_tmpoper->host))
 654         {
 655                 conf_report_error("Ignoring user -- missing username/host");
 656                 free_oper_conf(yy_tmpoper);
 657                 return;
 658         }
 659
 660         rb_dlinkAddAlloc(yy_tmpoper, &yy_oper_list);
 661 }
 662
 663 static void
 664 conf_set_oper_password(void *data)
 665 {
 666         if(yy_oper->passwd)
 667         {
 668                 memset(yy_oper->passwd, 0, strlen(yy_oper->passwd));
 669                 rb_free(yy_oper->passwd);
 670         }
 671
 672         yy_oper->passwd = rb_strdup((char *) data);
 673 }
 674
 675 static void
 676 conf_set_oper_rsa_public_key_file(void *data)
 677 {
 678 #ifdef HAVE_LIBCRYPTO
 679         rb_free(yy_oper->rsa_pubkey_file);
 680         yy_oper->rsa_pubkey_file = rb_strdup((char *) data);
 681 #else
 682         conf_report_error("Warning -- ignoring rsa_public_key_file (OpenSSL support not available");
 683 #endif
 684 }
 685
 686 static void
 687 conf_set_oper_umodes(void *data)
 688 {
 689         set_modes_from_table(&yy_oper->umodes, "umode", umode_table, data);
 690 }
 691
 692 static void
 693 conf_set_oper_snomask(void *data)
 694 {
 695         yy_oper->snomask = parse_snobuf_to_mask(0, (const char *) data);
 696 }
 697
 698 static int
 699 conf_begin_class(struct TopConf *tc)
 700 {
 701         if(yy_class)
 702                 free_class(yy_class);
 703
 704         yy_class = make_class();
 705         return 0;
 706 }
 707
 708 static int
 709 conf_end_class(struct TopConf *tc)
 710 {
 711         if(conf_cur_block_name != NULL)
 712                 yy_class->class_name = rb_strdup(conf_cur_block_name);
 713
 714         if(EmptyString(yy_class->class_name))
 715         {
 716                 conf_report_error("Ignoring connect block -- missing name.");
 717                 return 0;
 718         }
 719
 720         add_class(yy_class);
 721         yy_class = NULL;
 722         return 0;
 723 }
 724
 725 static void
 726 conf_set_class_ping_time(void *data)
 727 {
 728         yy_class->ping_freq = *(unsigned int *) data;
 729 }
 730
 731 static void
 732 conf_set_class_cidr_ipv4_bitlen(void *data)
 733 {
 734         unsigned int maxsize = 32;
 735         if(*(unsigned int *) data > maxsize)
 736                 conf_report_error
 737                         ("class::cidr_ipv4_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
 738                          *(unsigned int *) data, maxsize);
 739         else
 740                 yy_class->cidr_ipv4_bitlen = *(unsigned int *) data;
 741
 742 }
 743
 744 #ifdef RB_IPV6
 745 static void
 746 conf_set_class_cidr_ipv6_bitlen(void *data)
 747 {
 748         unsigned int maxsize = 128;
 749         if(*(unsigned int *) data > maxsize)
 750                 conf_report_error
 751                         ("class::cidr_ipv6_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
 752                          *(unsigned int *) data, maxsize);
 753         else
 754                 yy_class->cidr_ipv6_bitlen = *(unsigned int *) data;
 755
 756 }
 757 #endif
 758
 759 static void
 760 conf_set_class_number_per_cidr(void *data)
 761 {
 762         yy_class->cidr_amount = *(unsigned int *) data;
 763 }
 764
 765 static void
 766 conf_set_class_number_per_ip(void *data)
 767 {
 768         yy_class->max_local = *(unsigned int *) data;
 769 }
 770
 771
 772 static void
 773 conf_set_class_number_per_ip_global(void *data)
 774 {
 775         yy_class->max_global = *(unsigned int *) data;
 776 }
 777
 778 static void
 779 conf_set_class_number_per_ident(void *data)
 780 {
 781         yy_class->max_ident = *(unsigned int *) data;
 782 }
 783
 784 static void
 785 conf_set_class_connectfreq(void *data)
 786 {
 787         yy_class->con_freq = *(unsigned int *) data;
 788 }
 789
 790 static void
 791 conf_set_class_max_number(void *data)
 792 {
 793         yy_class->max_total = *(unsigned int *) data;
 794 }
 795
 796 static void
 797 conf_set_class_sendq(void *data)
 798 {
 799         yy_class->max_sendq = *(unsigned int *) data;
 800 }
 801
 802 static char *listener_address;
 803
 804 static int
 805 conf_begin_listen(struct TopConf *tc)
 806 {
 807         rb_free(listener_address);
 808         listener_address = NULL;
 809         return 0;
 810 }
 811
 812 static int
 813 conf_end_listen(struct TopConf *tc)
 814 {
 815         rb_free(listener_address);
 816         listener_address = NULL;
 817         return 0;
 818 }
 819
 820
 821
 822 static void
 823 conf_set_listen_port_both(void *data, int ssl)
 824 {
 825         conf_parm_t *args = data;
 826         for (; args; args = args->next)
 827         {
 828                 if((args->type & CF_MTYPE) != CF_INT)
 829                 {
 830                         conf_report_error
 831                                 ("listener::port argument is not an integer " "-- ignoring.");
 832                         continue;
 833                 }
 834                 if(listener_address == NULL)
 835                 {
 836                         add_listener(args->v.number, listener_address, AF_INET, ssl);
 837 #ifdef RB_IPV6
 838                         add_listener(args->v.number, listener_address, AF_INET6, ssl);
 839 #endif
 840                 }
 841                 else
 842                 {
 843                         int family;
 844 #ifdef RB_IPV6
 845                         if(strchr(listener_address, ':') != NULL)
 846                                 family = AF_INET6;
 847                         else
 848 #endif
 849                                 family = AF_INET;
 850
 851                         add_listener(args->v.number, listener_address, family, ssl);
 852
 853                 }
 854
 855         }
 856 }
 857
 858 static void
 859 conf_set_listen_port(void *data)
 860 {
 861         conf_set_listen_port_both(data, 0);
 862 }
 863
 864 static void
 865 conf_set_listen_sslport(void *data)
 866 {
 867         conf_set_listen_port_both(data, 1);
 868 }
 869
 870 static void
 871 conf_set_listen_address(void *data)
 872 {
 873         rb_free(listener_address);
 874         listener_address = rb_strdup(data);
 875 }
 876
 877 static int
 878 conf_begin_auth(struct TopConf *tc)
 879 {
 880         rb_dlink_node *ptr;
 881         rb_dlink_node *next_ptr;
 882
 883         if(yy_aconf)
 884                 free_conf(yy_aconf);
 885
 886         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
 887         {
 888                 free_conf(ptr->data);
 889                 rb_dlinkDestroy(ptr, &yy_aconf_list);
 890         }
 891
 892         yy_aconf = make_conf();
 893         yy_aconf->status = CONF_CLIENT;
 894
 895         return 0;
 896 }
 897
 898 static int
 899 conf_end_auth(struct TopConf *tc)
 900 {
 901         struct ConfItem *yy_tmp, *found_conf;
 902         rb_dlink_node *ptr;
 903         rb_dlink_node *next_ptr;
 904
 905         if(EmptyString(yy_aconf->name))
 906                 yy_aconf->name = rb_strdup("NOMATCH");
 907
 908         /* didnt even get one ->host? */
 909         if(EmptyString(yy_aconf->host))
 910         {
 911                 conf_report_error("Ignoring auth block -- missing user@host");
 912                 return 0;
 913         }
 914
 915         /* so the stacking works in order.. */
 916         collapse(yy_aconf->user);
 917         collapse(yy_aconf->host);
 918         conf_add_class_to_conf(yy_aconf);
 919         if ((found_conf = find_exact_conf_by_address("*", CONF_CLIENT, "*")) && found_conf->spasswd == NULL)
 920                 conf_report_error("Ignoring redundant auth block (after *@*)");
 921         else if ((found_conf = find_exact_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user)) &&
 922                         (!found_conf->spasswd || (yy_aconf->spasswd &&
 923                             0 == irccmp(found_conf->spasswd, yy_aconf->spasswd))))
 924                 conf_report_error("Ignoring duplicate auth block for %s@%s",
 925                                 yy_aconf->user, yy_aconf->host);
 926         else
 927                 add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf->spasswd, yy_aconf);
 928
 929         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
 930         {
 931                 yy_tmp = ptr->data;
 932
 933                 if(yy_aconf->passwd)
 934                         yy_tmp->passwd = rb_strdup(yy_aconf->passwd);
 935
 936                 if(yy_aconf->spasswd)
 937                         yy_tmp->spasswd = rb_strdup(yy_aconf->spasswd);
 938
 939                 /* this will always exist.. */
 940                 yy_tmp->name = rb_strdup(yy_aconf->name);
 941
 942                 if(yy_aconf->className)
 943                         yy_tmp->className = rb_strdup(yy_aconf->className);
 944
 945                 yy_tmp->flags = yy_aconf->flags;
 946                 yy_tmp->port = yy_aconf->port;
 947
 948                 collapse(yy_tmp->user);
 949                 collapse(yy_tmp->host);
 950
 951                 conf_add_class_to_conf(yy_tmp);
 952
 953                 if (find_exact_conf_by_address("*", CONF_CLIENT, "*"))
 954                         conf_report_error("Ignoring redundant auth block (after *@*)");
 955                 else if (find_exact_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user))
 956                         conf_report_error("Ignoring duplicate auth block for %s@%s",
 957                                         yy_tmp->user, yy_tmp->host);
 958                 else
 959                         add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp->spasswd, yy_tmp);
 960                 rb_dlinkDestroy(ptr, &yy_aconf_list);
 961         }
 962
 963         yy_aconf = NULL;
 964         return 0;
 965 }
 966
 967 static void
 968 conf_set_auth_user(void *data)
 969 {
 970         struct ConfItem *yy_tmp;
 971         char *p;
 972
 973         /* The first user= line doesn't allocate a new conf */
 974         if(!EmptyString(yy_aconf->host))
 975         {
 976                 yy_tmp = make_conf();
 977                 yy_tmp->status = CONF_CLIENT;
 978         }
 979         else
 980                 yy_tmp = yy_aconf;
 981
 982         if((p = strchr(data, '@')))
 983         {
 984                 *p++ = '\0';
 985
 986                 yy_tmp->user = rb_strdup(data);
 987                 yy_tmp->host = rb_strdup(p);
 988         }
 989         else
 990         {
 991                 yy_tmp->user = rb_strdup("*");
 992                 yy_tmp->host = rb_strdup(data);
 993         }
 994
 995         if(yy_aconf != yy_tmp)
 996                 rb_dlinkAddAlloc(yy_tmp, &yy_aconf_list);
 997 }
 998
 999 static void
1000 conf_set_auth_auth_user(void *data)
1001 {
1002         if(yy_aconf->spasswd)
1003                 memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
1004         rb_free(yy_aconf->spasswd);
1005         yy_aconf->spasswd = rb_strdup(data);
1006 }
1007
1008 static void
1009 conf_set_auth_passwd(void *data)
1010 {
1011         if(yy_aconf->passwd)
1012                 memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
1013         rb_free(yy_aconf->passwd);
1014         yy_aconf->passwd = rb_strdup(data);
1015 }
1016
1017 static void
1018 conf_set_auth_spoof(void *data)
1019 {
1020         char *p;
1021         char *user = NULL;
1022         char *host = NULL;
1023
1024         host = data;
1025
1026         /* user@host spoof */
1027         if((p = strchr(host, '@')) != NULL)
1028         {
1029                 *p = '\0';
1030                 user = data;
1031                 host = p+1;
1032
1033                 if(EmptyString(user))
1034                 {
1035                         conf_report_error("Warning -- spoof ident empty.");
1036                         return;
1037                 }
1038
1039                 if(strlen(user) > USERLEN)
1040                 {
1041                         conf_report_error("Warning -- spoof ident length invalid.");
1042                         return;
1043                 }
1044
1045                 if(!valid_username(user))
1046                 {
1047                         conf_report_error("Warning -- invalid spoof (ident).");
1048                         return;
1049                 }
1050
1051                 /* this must be restored! */
1052                 *p = '@';
1053         }
1054
1055         if(EmptyString(host))
1056         {
1057                 conf_report_error("Warning -- spoof host empty.");
1058                 return;
1059         }
1060
1061         if(strlen(host) > HOSTLEN)
1062         {
1063                 conf_report_error("Warning -- spoof host length invalid.");
1064                 return;
1065         }
1066
1067         if(!valid_hostname(host))
1068         {
1069                 conf_report_error("Warning -- invalid spoof (host).");
1070                 return;
1071         }
1072
1073         rb_free(yy_aconf->name);
1074         yy_aconf->name = rb_strdup(data);
1075         yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
1076 }
1077
1078 static void
1079 conf_set_auth_flags(void *data)
1080 {
1081         conf_parm_t *args = data;
1082
1083         set_modes_from_table((int *) &yy_aconf->flags, "flag", auth_table, args);
1084 }
1085
1086 static void
1087 conf_set_auth_redir_serv(void *data)
1088 {
1089         yy_aconf->flags |= CONF_FLAGS_REDIR;
1090         rb_free(yy_aconf->name);
1091         yy_aconf->name = rb_strdup(data);
1092 }
1093
1094 static void
1095 conf_set_auth_redir_port(void *data)
1096 {
1097         int port = *(unsigned int *) data;
1098
1099         yy_aconf->flags |= CONF_FLAGS_REDIR;
1100         yy_aconf->port = port;
1101 }
1102
1103 static void
1104 conf_set_auth_class(void *data)
1105 {
1106         rb_free(yy_aconf->className);
1107         yy_aconf->className = rb_strdup(data);
1108 }
1109
1110 /* ok, shared_oper handles the stacking, shared_flags handles adding
1111  * things.. so all we need to do when we start and end a shared block, is
1112  * clean up anything thats been left over.
1113  */
1114 static int
1115 conf_cleanup_shared(struct TopConf *tc)
1116 {
1117         rb_dlink_node *ptr, *next_ptr;
1118
1119         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
1120         {
1121                 free_remote_conf(ptr->data);
1122                 rb_dlinkDestroy(ptr, &yy_shared_list);
1123         }
1124
1125         if(yy_shared != NULL)
1126         {
1127                 free_remote_conf(yy_shared);
1128                 yy_shared = NULL;
1129         }
1130
1131         return 0;
1132 }
1133
1134 static void
1135 conf_set_shared_oper(void *data)
1136 {
1137         conf_parm_t *args = data;
1138         const char *username;
1139         char *p;
1140
1141         if(yy_shared != NULL)
1142                 free_remote_conf(yy_shared);
1143
1144         yy_shared = make_remote_conf();
1145
1146         if(args->next != NULL)
1147         {
1148                 if((args->type & CF_MTYPE) != CF_QSTRING)
1149                 {
1150                         conf_report_error("Ignoring shared::oper -- server is not a qstring");
1151                         return;
1152                 }
1153
1154                 yy_shared->server = rb_strdup(args->v.string);
1155                 args = args->next;
1156         }
1157         else
1158                 yy_shared->server = rb_strdup("*");
1159
1160         if((args->type & CF_MTYPE) != CF_QSTRING)
1161         {
1162                 conf_report_error("Ignoring shared::oper -- oper is not a qstring");
1163                 return;
1164         }
1165
1166         if((p = strchr(args->v.string, '@')) == NULL)
1167         {
1168                 conf_report_error("Ignoring shard::oper -- oper is not a user@host");
1169                 return;
1170         }
1171
1172         username = args->v.string;
1173         *p++ = '\0';
1174
1175         if(EmptyString(p))
1176                 yy_shared->host = rb_strdup("*");
1177         else
1178                 yy_shared->host = rb_strdup(p);
1179
1180         if(EmptyString(username))
1181                 yy_shared->username = rb_strdup("*");
1182         else
1183                 yy_shared->username = rb_strdup(username);
1184
1185         rb_dlinkAddAlloc(yy_shared, &yy_shared_list);
1186         yy_shared = NULL;
1187 }
1188
1189 static void
1190 conf_set_shared_flags(void *data)
1191 {
1192         conf_parm_t *args = data;
1193         int flags = 0;
1194         rb_dlink_node *ptr, *next_ptr;
1195
1196         if(yy_shared != NULL)
1197                 free_remote_conf(yy_shared);
1198
1199         set_modes_from_table(&flags, "flag", shared_table, args);
1200
1201         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
1202         {
1203                 yy_shared = ptr->data;
1204
1205                 yy_shared->flags = flags;
1206                 rb_dlinkDestroy(ptr, &yy_shared_list);
1207                 rb_dlinkAddTail(yy_shared, &yy_shared->node, &shared_conf_list);
1208         }
1209
1210         yy_shared = NULL;
1211 }
1212
1213 static int
1214 conf_begin_connect(struct TopConf *tc)
1215 {
1216         if(yy_server)
1217                 free_server_conf(yy_server);
1218
1219         yy_server = make_server_conf();
1220         yy_server->port = PORTNUM;
1221         yy_server->flags |= SERVER_TB;
1222
1223         if(conf_cur_block_name != NULL)
1224                 yy_server->name = rb_strdup(conf_cur_block_name);
1225
1226         return 0;
1227 }
1228
1229 static int
1230 conf_end_connect(struct TopConf *tc)
1231 {
1232         if(EmptyString(yy_server->name))
1233         {
1234                 conf_report_error("Ignoring connect block -- missing name.");
1235                 return 0;
1236         }
1237
1238         if(ServerInfo.name != NULL && !irccmp(ServerInfo.name, yy_server->name))
1239         {
1240                 conf_report_error("Ignoring connect block for %s -- name is equal to my own name.",
1241                                 yy_server->name);
1242                 return 0;
1243         }
1244
1245         if(EmptyString(yy_server->passwd) || EmptyString(yy_server->spasswd))
1246         {
1247                 conf_report_error("Ignoring connect block for %s -- missing password.",
1248                                         yy_server->name);
1249                 return 0;
1250         }
1251
1252         if(EmptyString(yy_server->host))
1253         {
1254                 conf_report_error("Ignoring connect block for %s -- missing host.",
1255                                         yy_server->name);
1256                 return 0;
1257         }
1258
1259 #ifndef HAVE_LIBZ
1260         if(ServerConfCompressed(yy_server))
1261         {
1262                 conf_report_error("Ignoring connect::flags::compressed -- zlib not available.");
1263                 yy_server->flags &= ~SERVER_COMPRESSED;
1264         }
1265 #endif
1266
1267         add_server_conf(yy_server);
1268         rb_dlinkAdd(yy_server, &yy_server->node, &server_conf_list);
1269
1270         yy_server = NULL;
1271         return 0;
1272 }
1273
1274 static void
1275 conf_set_connect_host(void *data)
1276 {
1277         rb_free(yy_server->host);
1278         yy_server->host = rb_strdup(data);
1279         if (strchr(yy_server->host, ':'))
1280                 yy_server->aftype = AF_INET6;
1281 }
1282
1283 static void
1284 conf_set_connect_vhost(void *data)
1285 {
1286         if(rb_inet_pton_sock(data, (struct sockaddr *)&yy_server->my_ipnum) <= 0)
1287         {
1288                 conf_report_error("Invalid netmask for server vhost (%s)",
1289                                   (char *) data);
1290                 return;
1291         }
1292
1293         yy_server->flags |= SERVER_VHOSTED;
1294 }
1295
1296 static void
1297 conf_set_connect_send_password(void *data)
1298 {
1299         if(yy_server->spasswd)
1300         {
1301                 memset(yy_server->spasswd, 0, strlen(yy_server->spasswd));
1302                 rb_free(yy_server->spasswd);
1303         }
1304
1305         yy_server->spasswd = rb_strdup(data);
1306 }
1307
1308 static void
1309 conf_set_connect_accept_password(void *data)
1310 {
1311         if(yy_server->passwd)
1312         {
1313                 memset(yy_server->passwd, 0, strlen(yy_server->passwd));
1314                 rb_free(yy_server->passwd);
1315         }
1316         yy_server->passwd = rb_strdup(data);
1317 }
1318
1319 static void
1320 conf_set_connect_port(void *data)
1321 {
1322         int port = *(unsigned int *) data;
1323
1324         if(port < 1)
1325                 port = PORTNUM;
1326
1327         yy_server->port = port;
1328 }
1329
1330 static void
1331 conf_set_connect_aftype(void *data)
1332 {
1333         char *aft = data;
1334
1335         if(strcasecmp(aft, "ipv4") == 0)
1336                 yy_server->aftype = AF_INET;
1337 #ifdef RB_IPV6
1338         else if(strcasecmp(aft, "ipv6") == 0)
1339                 yy_server->aftype = AF_INET6;
1340 #endif
1341         else
1342                 conf_report_error("connect::aftype '%s' is unknown.", aft);
1343 }
1344
1345 static void
1346 conf_set_connect_flags(void *data)
1347 {
1348         conf_parm_t *args = data;
1349
1350         /* note, we allow them to set compressed, then remove it later if
1351          * they do and LIBZ isnt available
1352          */
1353         set_modes_from_table(&yy_server->flags, "flag", connect_table, args);
1354 }
1355
1356 static void
1357 conf_set_connect_hub_mask(void *data)
1358 {
1359         struct remote_conf *yy_hub;
1360
1361         if(EmptyString(yy_server->name))
1362                 return;
1363
1364         yy_hub = make_remote_conf();
1365         yy_hub->flags = CONF_HUB;
1366
1367         yy_hub->host = rb_strdup(data);
1368         yy_hub->server = rb_strdup(yy_server->name);
1369         rb_dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
1370 }
1371
1372 static void
1373 conf_set_connect_leaf_mask(void *data)
1374 {
1375         struct remote_conf *yy_leaf;
1376
1377         if(EmptyString(yy_server->name))
1378                 return;
1379
1380         yy_leaf = make_remote_conf();
1381         yy_leaf->flags = CONF_LEAF;
1382
1383         yy_leaf->host = rb_strdup(data);
1384         yy_leaf->server = rb_strdup(yy_server->name);
1385         rb_dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
1386 }
1387
1388 static void
1389 conf_set_connect_class(void *data)
1390 {
1391         rb_free(yy_server->class_name);
1392         yy_server->class_name = rb_strdup(data);
1393 }
1394
1395 static void
1396 conf_set_exempt_ip(void *data)
1397 {
1398         struct ConfItem *yy_tmp;
1399
1400         if(parse_netmask(data, NULL, NULL) == HM_HOST)
1401         {
1402                 conf_report_error("Ignoring exempt -- invalid exempt::ip.");
1403                 return;
1404         }
1405
1406         yy_tmp = make_conf();
1407         yy_tmp->passwd = rb_strdup("*");
1408         yy_tmp->host = rb_strdup(data);
1409         yy_tmp->status = CONF_EXEMPTDLINE;
1410         add_conf_by_address(yy_tmp->host, CONF_EXEMPTDLINE, NULL, NULL, yy_tmp);
1411 }
1412
1413 static int
1414 conf_cleanup_cluster(struct TopConf *tc)
1415 {
1416         rb_dlink_node *ptr, *next_ptr;
1417
1418         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
1419         {
1420                 free_remote_conf(ptr->data);
1421                 rb_dlinkDestroy(ptr, &yy_cluster_list);
1422         }
1423
1424         if(yy_shared != NULL)
1425         {
1426                 free_remote_conf(yy_shared);
1427                 yy_shared = NULL;
1428         }
1429
1430         return 0;
1431 }
1432
1433 static void
1434 conf_set_cluster_name(void *data)
1435 {
1436         if(yy_shared != NULL)
1437                 free_remote_conf(yy_shared);
1438
1439         yy_shared = make_remote_conf();
1440         yy_shared->server = rb_strdup(data);
1441         rb_dlinkAddAlloc(yy_shared, &yy_cluster_list);
1442
1443         yy_shared = NULL;
1444 }
1445
1446 static void
1447 conf_set_cluster_flags(void *data)
1448 {
1449         conf_parm_t *args = data;
1450         int flags = 0;
1451         rb_dlink_node *ptr, *next_ptr;
1452
1453         if(yy_shared != NULL)
1454                 free_remote_conf(yy_shared);
1455
1456         set_modes_from_table(&flags, "flag", cluster_table, args);
1457
1458         RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
1459         {
1460                 yy_shared = ptr->data;
1461                 yy_shared->flags = flags;
1462                 rb_dlinkAddTail(yy_shared, &yy_shared->node, &cluster_conf_list);
1463                 rb_dlinkDestroy(ptr, &yy_cluster_list);
1464         }
1465
1466         yy_shared = NULL;
1467 }
1468
1469 static void
1470 conf_set_general_havent_read_conf(void *data)
1471 {
1472         if(*(unsigned int *) data)
1473         {
1474                 conf_report_error("You haven't read your config file properly.");
1475                 conf_report_error
1476                         ("There is a line in the example conf that will kill your server if not removed.");
1477                 conf_report_error
1478                         ("Consider actually reading/editing the conf file, and removing this line.");
1479                 if (!testing_conf)
1480                         exit(0);
1481         }
1482 }
1483
1484 static void
1485 conf_set_general_hide_error_messages(void *data)
1486 {
1487         char *val = data;
1488
1489         if(strcasecmp(val, "yes") == 0)
1490                 ConfigFileEntry.hide_error_messages = 2;
1491         else if(strcasecmp(val, "opers") == 0)
1492                 ConfigFileEntry.hide_error_messages = 1;
1493         else if(strcasecmp(val, "no") == 0)
1494                 ConfigFileEntry.hide_error_messages = 0;
1495         else
1496                 conf_report_error("Invalid setting '%s' for general::hide_error_messages.", val);
1497 }
1498
1499 static void
1500 conf_set_general_kline_delay(void *data)
1501 {
1502         ConfigFileEntry.kline_delay = *(unsigned int *) data;
1503
1504         /* THIS MUST BE HERE to stop us being unable to check klines */
1505         kline_queued = 0;
1506 }
1507
1508 static void
1509 conf_set_general_stats_k_oper_only(void *data)
1510 {
1511         char *val = data;
1512
1513         if(strcasecmp(val, "yes") == 0)
1514                 ConfigFileEntry.stats_k_oper_only = 2;
1515         else if(strcasecmp(val, "masked") == 0)
1516                 ConfigFileEntry.stats_k_oper_only = 1;
1517         else if(strcasecmp(val, "no") == 0)
1518                 ConfigFileEntry.stats_k_oper_only = 0;
1519         else
1520                 conf_report_error("Invalid setting '%s' for general::stats_k_oper_only.", val);
1521 }
1522
1523 static void
1524 conf_set_general_stats_i_oper_only(void *data)
1525 {
1526         char *val = data;
1527
1528         if(strcasecmp(val, "yes") == 0)
1529                 ConfigFileEntry.stats_i_oper_only = 2;
1530         else if(strcasecmp(val, "masked") == 0)
1531                 ConfigFileEntry.stats_i_oper_only = 1;
1532         else if(strcasecmp(val, "no") == 0)
1533                 ConfigFileEntry.stats_i_oper_only = 0;
1534         else
1535                 conf_report_error("Invalid setting '%s' for general::stats_i_oper_only.", val);
1536 }
1537
1538 static void
1539 conf_set_general_compression_level(void *data)
1540 {
1541 #ifdef HAVE_LIBZ
1542         ConfigFileEntry.compression_level = *(unsigned int *) data;
1543
1544         if((ConfigFileEntry.compression_level < 1) || (ConfigFileEntry.compression_level > 9))
1545         {
1546                 conf_report_error
1547                         ("Invalid general::compression_level %d -- using default.",
1548                          ConfigFileEntry.compression_level);
1549                 ConfigFileEntry.compression_level = 0;
1550         }
1551 #else
1552         conf_report_error("Ignoring general::compression_level -- zlib not available.");
1553 #endif
1554 }
1555
1556 static void
1557 conf_set_general_default_umodes(void *data)
1558 {
1559         char *pm;
1560         int what = MODE_ADD, flag;
1561
1562         ConfigFileEntry.default_umodes = 0;
1563         for (pm = (char *) data; *pm; pm++)
1564         {
1565                 switch (*pm)
1566                 {
1567                 case '+':
1568                         what = MODE_ADD;
1569                         break;
1570                 case '-':
1571                         what = MODE_DEL;
1572                         break;
1573
1574                 /* don't allow +o */
1575                 case 'o':
1576                 case 'S':
1577                 case ' ':
1578                         break;
1579
1580                 default:
1581                         if ((flag = user_modes[(unsigned char) *pm]))
1582                         {
1583                                 /* Proper value has probably not yet been set
1584                                  * so don't check oper_only_umodes -- jilles */
1585                                 if (what == MODE_ADD)
1586                                         ConfigFileEntry.default_umodes |= flag;
1587                                 else
1588                                         ConfigFileEntry.default_umodes &= ~flag;
1589                         }
1590                         break;
1591                 }
1592         }
1593 }
1594
1595 static void
1596 conf_set_general_oper_umodes(void *data)
1597 {
1598         set_modes_from_table(&ConfigFileEntry.oper_umodes, "umode", umode_table, data);
1599 }
1600
1601 static void
1602 conf_set_general_oper_only_umodes(void *data)
1603 {
1604         set_modes_from_table(&ConfigFileEntry.oper_only_umodes, "umode", umode_table, data);
1605 }
1606
1607 static void
1608 conf_set_general_oper_snomask(void *data)
1609 {
1610         char *pm;
1611         int what = MODE_ADD, flag;
1612
1613         ConfigFileEntry.oper_snomask = 0;
1614         for (pm = (char *) data; *pm; pm++)
1615         {
1616                 switch (*pm)
1617                 {
1618                 case '+':
1619                         what = MODE_ADD;
1620                         break;
1621                 case '-':
1622                         what = MODE_DEL;
1623                         break;
1624
1625                 default:
1626                         if ((flag = snomask_modes[(unsigned char) *pm]))
1627                         {
1628                                 if (what == MODE_ADD)
1629                                         ConfigFileEntry.oper_snomask |= flag;
1630                                 else
1631                                         ConfigFileEntry.oper_snomask &= ~flag;
1632                         }
1633                         break;
1634                 }
1635         }
1636 }
1637
1638 static void
1639 conf_set_serverhide_links_delay(void *data)
1640 {
1641         int val = *(unsigned int *) data;
1642
1643         ConfigServerHide.links_delay = val;
1644 }
1645
1646 static int
1647 conf_begin_service(struct TopConf *tc)
1648 {
1649         struct Client *target_p;
1650         rb_dlink_node *ptr;
1651
1652         RB_DLINK_FOREACH(ptr, global_serv_list.head)
1653         {
1654                 target_p = ptr->data;
1655
1656                 target_p->flags &= ~FLAGS_SERVICE;
1657         }
1658
1659         return 0;
1660 }
1661
1662 static void
1663 conf_set_service_name(void *data)
1664 {
1665         struct Client *target_p;
1666         const char *s;
1667         char *tmp;
1668         int dots = 0;
1669
1670         for(s = data; *s != '\0'; s++)
1671         {
1672                 if(!IsServChar(*s))
1673                 {
1674                         conf_report_error("Ignoring service::name "
1675                                          "-- bogus servername.");
1676                         return;
1677                 }
1678                 else if(*s == '.')
1679                          dots++;
1680         }
1681
1682         if(!dots)
1683         {
1684                 conf_report_error("Ignoring service::name -- must contain '.'");
1685                 return;
1686         }
1687
1688         tmp = rb_strdup(data);
1689         rb_dlinkAddAlloc(tmp, &service_list);
1690
1691         if((target_p = find_server(NULL, tmp)))
1692                 target_p->flags |= FLAGS_SERVICE;
1693 }
1694
1695 static int
1696 conf_begin_alias(struct TopConf *tc)
1697 {
1698         yy_alias = rb_malloc(sizeof(struct alias_entry));
1699
1700         if (conf_cur_block_name != NULL)
1701                 yy_alias->name = rb_strdup(conf_cur_block_name);
1702
1703         yy_alias->flags = 0;
1704         yy_alias->hits = 0;
1705
1706         return 0;
1707 }
1708
1709 static int
1710 conf_end_alias(struct TopConf *tc)
1711 {
1712         if (yy_alias == NULL)
1713                 return -1;
1714
1715         if (yy_alias->name == NULL)
1716         {
1717                 conf_report_error("Ignoring alias -- must have a name.");
1718
1719                 rb_free(yy_alias);
1720
1721                 return -1;
1722         }
1723
1724         if (yy_alias->target == NULL)
1725         {
1726                 conf_report_error("Ignoring alias -- must have a target.");
1727
1728                 rb_free(yy_alias);
1729
1730                 return -1;
1731         }
1732
1733         irc_dictionary_add(alias_dict, yy_alias->name, yy_alias);
1734
1735         return 0;
1736 }
1737
1738 static void
1739 conf_set_alias_name(void *data)
1740 {
1741         if (data == NULL || yy_alias == NULL)   /* this shouldn't ever happen */
1742                 return;
1743
1744         yy_alias->name = rb_strdup(data);
1745 }
1746
1747 static void
1748 conf_set_alias_target(void *data)
1749 {
1750         if (data == NULL || yy_alias == NULL)   /* this shouldn't ever happen */
1751                 return;
1752
1753         yy_alias->target = rb_strdup(data);
1754 }
1755
1756 static void
1757 conf_set_blacklist_host(void *data)
1758 {
1759         yy_blacklist_host = rb_strdup(data);
1760 }
1761
1762 static void
1763 conf_set_blacklist_reason(void *data)
1764 {
1765         yy_blacklist_reason = rb_strdup(data);
1766
1767         if (yy_blacklist_host && yy_blacklist_reason)
1768         {
1769                 new_blacklist(yy_blacklist_host, yy_blacklist_reason);
1770                 rb_free(yy_blacklist_host);
1771                 rb_free(yy_blacklist_reason);
1772                 yy_blacklist_host = NULL;
1773                 yy_blacklist_reason = NULL;
1774         }
1775 }
1776
1777 /* public functions */
1778
1779
1780 void
1781 conf_report_error(const char *fmt, ...)
1782 {
1783         va_list ap;
1784         char msg[IRCD_BUFSIZE + 1] = { 0 };
1785
1786         va_start(ap, fmt);
1787         rb_vsnprintf(msg, IRCD_BUFSIZE, fmt, ap);
1788         va_end(ap);
1789
1790         if (testing_conf)
1791         {
1792                 fprintf(stderr, "\"%s\", line %d: %s\n", current_file, lineno + 1, msg);
1793                 return;
1794         }
1795
1796         ierror("\"%s\", line %d: %s", current_file, lineno + 1, msg);
1797         sendto_realops_snomask(SNO_GENERAL, L_ALL, "\"%s\", line %d: %s", current_file, lineno + 1, msg);
1798 }
1799
1800 int
1801 conf_start_block(char *block, char *name)
1802 {
1803         if((conf_cur_block = find_top_conf(block)) == NULL)
1804         {
1805                 conf_report_error("Configuration block '%s' is not defined.", block);
1806                 return -1;
1807         }
1808
1809         if(name)
1810                 conf_cur_block_name = rb_strdup(name);
1811         else
1812                 conf_cur_block_name = NULL;
1813
1814         if(conf_cur_block->tc_sfunc)
1815                 if(conf_cur_block->tc_sfunc(conf_cur_block) < 0)
1816                         return -1;
1817
1818         return 0;
1819 }
1820
1821 int
1822 conf_end_block(struct TopConf *tc)
1823 {
1824         if(tc->tc_efunc)
1825                 return tc->tc_efunc(tc);
1826
1827         rb_free(conf_cur_block_name);
1828         return 0;
1829 }
1830
1831 static void
1832 conf_set_generic_int(void *data, void *location)
1833 {
1834         *((int *) location) = *((unsigned int *) data);
1835 }
1836
1837 static void
1838 conf_set_generic_string(void *data, int len, void *location)
1839 {
1840         char **loc = location;
1841         char *input = data;
1842
1843         if(len && strlen(input) > (unsigned int)len)
1844                 input[len] = '\0';
1845
1846         rb_free(*loc);
1847         *loc = rb_strdup(input);
1848 }
1849
1850 int
1851 conf_call_set(struct TopConf *tc, char *item, conf_parm_t * value, int type)
1852 {
1853         struct ConfEntry *cf;
1854         conf_parm_t *cp;
1855
1856         if(!tc)
1857                 return -1;
1858
1859         if((cf = find_conf_item(tc, item)) == NULL)
1860         {
1861                 conf_report_error
1862                         ("Non-existant configuration setting %s::%s.", tc->tc_name, (char *) item);
1863                 return -1;
1864         }
1865
1866         /* if it takes one thing, make sure they only passed one thing,
1867            and handle as needed. */
1868         if(value->type & CF_FLIST && !cf->cf_type & CF_FLIST)
1869         {
1870                 conf_report_error
1871                         ("Option %s::%s does not take a list of values.", tc->tc_name, item);
1872                 return -1;
1873         }
1874
1875         cp = value->v.list;
1876
1877
1878         if(CF_TYPE(value->v.list->type) != CF_TYPE(cf->cf_type))
1879         {
1880                 /* if it expects a string value, but we got a yesno,
1881                  * convert it back
1882                  */
1883                 if((CF_TYPE(value->v.list->type) == CF_YESNO) &&
1884                    (CF_TYPE(cf->cf_type) == CF_STRING))
1885                 {
1886                         value->v.list->type = CF_STRING;
1887
1888                         if(cp->v.number == 1)
1889                                 cp->v.string = rb_strdup("yes");
1890                         else
1891                                 cp->v.string = rb_strdup("no");
1892                 }
1893
1894                 /* maybe it's a CF_TIME and they passed CF_INT --
1895                    should still be valid */
1896                 else if(!((CF_TYPE(value->v.list->type) == CF_INT) &&
1897                           (CF_TYPE(cf->cf_type) == CF_TIME)))
1898                 {
1899                         conf_report_error
1900                                 ("Wrong type for %s::%s (expected %s, got %s)",
1901                                  tc->tc_name, (char *) item,
1902                                  conf_strtype(cf->cf_type), conf_strtype(value->v.list->type));
1903                         return -1;
1904                 }
1905         }
1906
1907         if(cf->cf_type & CF_FLIST)
1908         {
1909 #if 0
1910                 if(cf->cf_arg)
1911                         conf_set_generic_list(value->v.list, cf->cf_arg);
1912                 else
1913 #endif
1914                 /* just pass it the extended argument list */
1915                 cf->cf_func(value->v.list);
1916         }
1917         else
1918         {
1919                 /* it's old-style, needs only one arg */
1920                 switch (cf->cf_type)
1921                 {
1922                 case CF_INT:
1923                 case CF_TIME:
1924                 case CF_YESNO:
1925                         if(cf->cf_arg)
1926                                 conf_set_generic_int(&cp->v.number, cf->cf_arg);
1927                         else
1928                                 cf->cf_func(&cp->v.number);
1929                         break;
1930                 case CF_STRING:
1931                 case CF_QSTRING:
1932                         if(EmptyString(cp->v.string))
1933                                 conf_report_error("Ignoring %s::%s -- empty field",
1934                                                 tc->tc_name, item);
1935                         else if(cf->cf_arg)
1936                                 conf_set_generic_string(cp->v.string, cf->cf_len, cf->cf_arg);
1937                         else
1938                                 cf->cf_func(cp->v.string);
1939                         break;
1940                 }
1941         }
1942
1943
1944         return 0;
1945 }
1946
1947 int
1948 add_conf_item(const char *topconf, const char *name, int type, void (*func) (void *))
1949 {
1950         struct TopConf *tc;
1951         struct ConfEntry *cf;
1952
1953         if((tc = find_top_conf(topconf)) == NULL)
1954                 return -1;
1955
1956         if((cf = find_conf_item(tc, name)) != NULL)
1957                 return -1;
1958
1959         cf = rb_malloc(sizeof(struct ConfEntry));
1960
1961         cf->cf_name = name;
1962         cf->cf_type = type;
1963         cf->cf_func = func;
1964         cf->cf_arg = NULL;
1965
1966         rb_dlinkAddAlloc(cf, &tc->tc_items);
1967
1968         return 0;
1969 }
1970
1971 int
1972 remove_conf_item(const char *topconf, const char *name)
1973 {
1974         struct TopConf *tc;
1975         struct ConfEntry *cf;
1976         rb_dlink_node *ptr;
1977
1978         if((tc = find_top_conf(topconf)) == NULL)
1979                 return -1;
1980
1981         if((cf = find_conf_item(tc, name)) == NULL)
1982                 return -1;
1983
1984         if((ptr = rb_dlinkFind(cf, &tc->tc_items)) == NULL)
1985                 return -1;
1986
1987         rb_dlinkDestroy(ptr, &tc->tc_items);
1988         rb_free(cf);
1989
1990         return 0;
1991 }
1992
1993 /* *INDENT-OFF* */
1994 static struct ConfEntry conf_serverinfo_table[] =
1995 {
1996         { "description",        CF_QSTRING, NULL, 0, &ServerInfo.description    },
1997         { "network_desc",       CF_QSTRING, NULL, 0, &ServerInfo.network_desc   },
1998         { "hub",                CF_YESNO,   NULL, 0, &ServerInfo.hub            },
1999
2000         { "network_name",       CF_QSTRING, conf_set_serverinfo_network_name,   0, NULL },
2001         { "name",               CF_QSTRING, conf_set_serverinfo_name,   0, NULL },
2002         { "sid",                CF_QSTRING, conf_set_serverinfo_sid,    0, NULL },
2003         { "vhost",              CF_QSTRING, conf_set_serverinfo_vhost,  0, NULL },
2004         { "vhost6",             CF_QSTRING, conf_set_serverinfo_vhost6, 0, NULL },
2005
2006         { "ssl_private_key",    CF_QSTRING, NULL, 0, &ServerInfo.ssl_private_key },
2007         { "ssl_ca_cert",        CF_QSTRING, NULL, 0, &ServerInfo.ssl_ca_cert },
2008         { "ssl_cert",           CF_QSTRING, NULL, 0, &ServerInfo.ssl_cert },
2009         { "ssl_dh_params",      CF_QSTRING, NULL, 0, &ServerInfo.ssl_dh_params },
2010         { "ssld_count",         CF_INT,     NULL, 0, &ServerInfo.ssld_count },
2011
2012         { "default_max_clients",CF_INT,     NULL, 0, &ServerInfo.default_max_clients },
2013
2014         { "\0", 0, NULL, 0, NULL }
2015 };
2016
2017 static struct ConfEntry conf_admin_table[] =
2018 {
2019         { "name",       CF_QSTRING, NULL, 200, &AdminInfo.name          },
2020         { "description",CF_QSTRING, NULL, 200, &AdminInfo.description   },
2021         { "email",      CF_QSTRING, NULL, 200, &AdminInfo.email         },
2022         { "\0", 0, NULL, 0, NULL }
2023 };
2024
2025 static struct ConfEntry conf_log_table[] =
2026 {
2027         { "fname_userlog",      CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_userlog    },
2028         { "fname_fuserlog",     CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_fuserlog   },
2029         { "fname_operlog",      CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_operlog    },
2030         { "fname_foperlog",     CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_foperlog   },
2031         { "fname_serverlog",    CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_serverlog  },
2032         { "fname_killlog",      CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_killlog    },
2033         { "fname_klinelog",     CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_klinelog   },
2034         { "fname_operspylog",   CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_operspylog },
2035         { "fname_ioerrorlog",   CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_ioerrorlog },
2036         { "\0",                 0,          NULL, 0,          NULL }
2037 };
2038
2039 static struct ConfEntry conf_operator_table[] =
2040 {
2041         { "rsa_public_key_file",  CF_QSTRING, conf_set_oper_rsa_public_key_file, 0, NULL },
2042         { "flags",      CF_STRING | CF_FLIST, conf_set_oper_flags,      0, NULL },
2043         { "umodes",     CF_STRING | CF_FLIST, conf_set_oper_umodes,     0, NULL },
2044         { "privset",    CF_QSTRING, conf_set_oper_privset,      0, NULL },
2045         { "snomask",    CF_QSTRING, conf_set_oper_snomask,      0, NULL },
2046         { "user",       CF_QSTRING, conf_set_oper_user,         0, NULL },
2047         { "password",   CF_QSTRING, conf_set_oper_password,     0, NULL },
2048         { "fingerprint",        CF_QSTRING, conf_set_oper_fingerprint,  0, NULL },
2049         { "\0", 0, NULL, 0, NULL }
2050 };
2051
2052 static struct ConfEntry conf_privset_table[] =
2053 {
2054         { "extends",    CF_QSTRING,             conf_set_privset_extends,       0, NULL },
2055         { "privs",      CF_STRING | CF_FLIST,   conf_set_privset_privs,         0, NULL },
2056         { "\0", 0, NULL, 0, NULL }
2057 };
2058
2059 static struct ConfEntry conf_class_table[] =
2060 {
2061         { "ping_time",          CF_TIME, conf_set_class_ping_time,              0, NULL },
2062         { "cidr_ipv4_bitlen",   CF_INT,  conf_set_class_cidr_ipv4_bitlen,               0, NULL },
2063 #ifdef RB_IPV6
2064         { "cidr_ipv6_bitlen",   CF_INT,  conf_set_class_cidr_ipv6_bitlen,               0, NULL },
2065 #endif
2066         { "number_per_cidr",    CF_INT,  conf_set_class_number_per_cidr,        0, NULL },
2067         { "number_per_ip",      CF_INT,  conf_set_class_number_per_ip,          0, NULL },
2068         { "number_per_ip_global", CF_INT,conf_set_class_number_per_ip_global,   0, NULL },
2069         { "number_per_ident",   CF_INT,  conf_set_class_number_per_ident,       0, NULL },
2070         { "connectfreq",        CF_TIME, conf_set_class_connectfreq,            0, NULL },
2071         { "max_number",         CF_INT,  conf_set_class_max_number,             0, NULL },
2072         { "sendq",              CF_TIME, conf_set_class_sendq,                  0, NULL },
2073         { "\0", 0, NULL, 0, NULL }
2074 };
2075
2076 static struct ConfEntry conf_auth_table[] =
2077 {
2078         { "user",       CF_QSTRING, conf_set_auth_user,         0, NULL },
2079         { "auth_user",  CF_QSTRING, conf_set_auth_auth_user,    0, NULL },
2080         { "password",   CF_QSTRING, conf_set_auth_passwd,       0, NULL },
2081         { "class",      CF_QSTRING, conf_set_auth_class,        0, NULL },
2082         { "spoof",      CF_QSTRING, conf_set_auth_spoof,        0, NULL },
2083         { "redirserv",  CF_QSTRING, conf_set_auth_redir_serv,   0, NULL },
2084         { "redirport",  CF_INT,     conf_set_auth_redir_port,   0, NULL },
2085         { "flags",      CF_STRING | CF_FLIST, conf_set_auth_flags,      0, NULL },
2086         { "\0", 0, NULL, 0, NULL }
2087 };
2088
2089 static struct ConfEntry conf_connect_table[] =
2090 {
2091         { "send_password",      CF_QSTRING,   conf_set_connect_send_password,   0, NULL },
2092         { "accept_password",    CF_QSTRING,   conf_set_connect_accept_password, 0, NULL },
2093         { "flags",      CF_STRING | CF_FLIST, conf_set_connect_flags,   0, NULL },
2094         { "host",       CF_QSTRING, conf_set_connect_host,      0, NULL },
2095         { "vhost",      CF_QSTRING, conf_set_connect_vhost,     0, NULL },
2096         { "port",       CF_INT,     conf_set_connect_port,      0, NULL },
2097         { "aftype",     CF_STRING,  conf_set_connect_aftype,    0, NULL },
2098         { "hub_mask",   CF_QSTRING, conf_set_connect_hub_mask,  0, NULL },
2099         { "leaf_mask",  CF_QSTRING, conf_set_connect_leaf_mask, 0, NULL },
2100         { "class",      CF_QSTRING, conf_set_connect_class,     0, NULL },
2101         { "\0", 0, NULL, 0, NULL }
2102 };
2103
2104 static struct ConfEntry conf_general_table[] =
2105 {
2106         { "oper_only_umodes",   CF_STRING | CF_FLIST, conf_set_general_oper_only_umodes, 0, NULL },
2107         { "oper_umodes",        CF_STRING | CF_FLIST, conf_set_general_oper_umodes,      0, NULL },
2108         { "oper_snomask",       CF_QSTRING, conf_set_general_oper_snomask, 0, NULL },
2109         { "compression_level",  CF_INT,    conf_set_general_compression_level,  0, NULL },
2110         { "havent_read_conf",   CF_YESNO,  conf_set_general_havent_read_conf,   0, NULL },
2111         { "hide_error_messages",CF_STRING, conf_set_general_hide_error_messages,0, NULL },
2112         { "kline_delay",        CF_TIME,   conf_set_general_kline_delay,        0, NULL },
2113         { "stats_k_oper_only",  CF_STRING, conf_set_general_stats_k_oper_only,  0, NULL },
2114         { "stats_i_oper_only",  CF_STRING, conf_set_general_stats_i_oper_only,  0, NULL },
2115         { "default_umodes",     CF_QSTRING, conf_set_general_default_umodes, 0, NULL },
2116
2117         { "default_operstring", CF_QSTRING, NULL, REALLEN,    &ConfigFileEntry.default_operstring },
2118         { "default_adminstring",CF_QSTRING, NULL, REALLEN,    &ConfigFileEntry.default_adminstring },
2119         { "servicestring",      CF_QSTRING, NULL, REALLEN,    &ConfigFileEntry.servicestring },
2120         { "egdpool_path",       CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.egdpool_path },
2121         { "kline_reason",       CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.kline_reason },
2122         { "identify_service",   CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifyservice },
2123         { "identify_command",   CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifycommand },
2124
2125         { "anti_spam_exit_message_time", CF_TIME,  NULL, 0, &ConfigFileEntry.anti_spam_exit_message_time },
2126         { "disable_fake_channels",       CF_YESNO, NULL, 0, &ConfigFileEntry.disable_fake_channels },
2127         { "min_nonwildcard_simple",      CF_INT,   NULL, 0, &ConfigFileEntry.min_nonwildcard_simple },
2128         { "non_redundant_klines",        CF_YESNO, NULL, 0, &ConfigFileEntry.non_redundant_klines },
2129         { "tkline_expire_notices",       CF_YESNO, NULL, 0, &ConfigFileEntry.tkline_expire_notices },
2130
2131         { "anti_nick_flood",    CF_YESNO, NULL, 0, &ConfigFileEntry.anti_nick_flood     },
2132         { "burst_away",         CF_YESNO, NULL, 0, &ConfigFileEntry.burst_away          },
2133         { "caller_id_wait",     CF_TIME,  NULL, 0, &ConfigFileEntry.caller_id_wait      },
2134         { "client_exit",        CF_YESNO, NULL, 0, &ConfigFileEntry.client_exit         },
2135         { "client_flood",       CF_INT,   NULL, 0, &ConfigFileEntry.client_flood        },
2136         { "collision_fnc",      CF_YESNO, NULL, 0, &ConfigFileEntry.collision_fnc       },
2137         { "connect_timeout",    CF_TIME,  NULL, 0, &ConfigFileEntry.connect_timeout     },
2138         { "default_floodcount", CF_INT,   NULL, 0, &ConfigFileEntry.default_floodcount  },
2139         { "disable_auth",       CF_YESNO, NULL, 0, &ConfigFileEntry.disable_auth        },
2140         { "dots_in_ident",      CF_INT,   NULL, 0, &ConfigFileEntry.dots_in_ident       },
2141         { "failed_oper_notice", CF_YESNO, NULL, 0, &ConfigFileEntry.failed_oper_notice  },
2142         { "global_snotices",    CF_YESNO, NULL, 0, &ConfigFileEntry.global_snotices     },
2143         { "hide_spoof_ips",     CF_YESNO, NULL, 0, &ConfigFileEntry.hide_spoof_ips      },
2144         { "dline_with_reason",  CF_YESNO, NULL, 0, &ConfigFileEntry.dline_with_reason   },
2145         { "kline_with_reason",  CF_YESNO, NULL, 0, &ConfigFileEntry.kline_with_reason   },
2146         { "map_oper_only",      CF_YESNO, NULL, 0, &ConfigFileEntry.map_oper_only       },
2147         { "max_accept",         CF_INT,   NULL, 0, &ConfigFileEntry.max_accept          },
2148         { "max_monitor",        CF_INT,   NULL, 0, &ConfigFileEntry.max_monitor         },
2149         { "max_nick_time",      CF_TIME,  NULL, 0, &ConfigFileEntry.max_nick_time       },
2150         { "max_nick_changes",   CF_INT,   NULL, 0, &ConfigFileEntry.max_nick_changes    },
2151         { "max_targets",        CF_INT,   NULL, 0, &ConfigFileEntry.max_targets         },
2152         { "min_nonwildcard",    CF_INT,   NULL, 0, &ConfigFileEntry.min_nonwildcard     },
2153         { "nick_delay",         CF_TIME,  NULL, 0, &ConfigFileEntry.nick_delay          },
2154         { "no_oper_flood",      CF_YESNO, NULL, 0, &ConfigFileEntry.no_oper_flood       },
2155         { "operspy_admin_only", CF_YESNO, NULL, 0, &ConfigFileEntry.operspy_admin_only  },
2156         { "operspy_dont_care_user_info", CF_YESNO, NULL, 0, &ConfigFileEntry.operspy_dont_care_user_info },
2157         { "pace_wait",          CF_TIME,  NULL, 0, &ConfigFileEntry.pace_wait           },
2158         { "pace_wait_simple",   CF_TIME,  NULL, 0, &ConfigFileEntry.pace_wait_simple    },
2159         { "ping_cookie",        CF_YESNO, NULL, 0, &ConfigFileEntry.ping_cookie         },
2160         { "reject_after_count", CF_INT,   NULL, 0, &ConfigFileEntry.reject_after_count  },
2161         { "reject_ban_time",    CF_TIME,  NULL, 0, &ConfigFileEntry.reject_ban_time     },
2162         { "reject_duration",    CF_TIME,  NULL, 0, &ConfigFileEntry.reject_duration     },
2163         { "throttle_count",     CF_INT,   NULL, 0, &ConfigFileEntry.throttle_count      },
2164         { "throttle_duration",  CF_TIME,  NULL, 0, &ConfigFileEntry.throttle_duration   },
2165         { "short_motd",         CF_YESNO, NULL, 0, &ConfigFileEntry.short_motd          },
2166         { "stats_c_oper_only",  CF_YESNO, NULL, 0, &ConfigFileEntry.stats_c_oper_only   },
2167         { "stats_e_disabled",   CF_YESNO, NULL, 0, &ConfigFileEntry.stats_e_disabled    },
2168         { "stats_h_oper_only",  CF_YESNO, NULL, 0, &ConfigFileEntry.stats_h_oper_only   },
2169         { "stats_o_oper_only",  CF_YESNO, NULL, 0, &ConfigFileEntry.stats_o_oper_only   },
2170         { "stats_P_oper_only",  CF_YESNO, NULL, 0, &ConfigFileEntry.stats_P_oper_only   },
2171         { "stats_y_oper_only",  CF_YESNO, NULL, 0, &ConfigFileEntry.stats_y_oper_only   },
2172         { "target_change",      CF_YESNO, NULL, 0, &ConfigFileEntry.target_change       },
2173         { "ts_max_delta",       CF_TIME,  NULL, 0, &ConfigFileEntry.ts_max_delta        },
2174         { "use_egd",            CF_YESNO, NULL, 0, &ConfigFileEntry.use_egd             },
2175         { "ts_warn_delta",      CF_TIME,  NULL, 0, &ConfigFileEntry.ts_warn_delta       },
2176         { "use_whois_actually", CF_YESNO, NULL, 0, &ConfigFileEntry.use_whois_actually  },
2177         { "warn_no_nline",      CF_YESNO, NULL, 0, &ConfigFileEntry.warn_no_nline       },
2178         { "\0",                 0,        NULL, 0, NULL }
2179 };
2180
2181 static struct ConfEntry conf_channel_table[] =
2182 {
2183         { "default_split_user_count",   CF_INT,  NULL, 0, &ConfigChannel.default_split_user_count        },
2184         { "default_split_server_count", CF_INT,  NULL, 0, &ConfigChannel.default_split_server_count },
2185         { "burst_topicwho",     CF_YESNO, NULL, 0, &ConfigChannel.burst_topicwho        },
2186         { "kick_on_split_riding", CF_YESNO, NULL, 0, &ConfigChannel.kick_on_split_riding },
2187         { "knock_delay",        CF_TIME,  NULL, 0, &ConfigChannel.knock_delay           },
2188         { "knock_delay_channel",CF_TIME,  NULL, 0, &ConfigChannel.knock_delay_channel   },
2189         { "max_bans",           CF_INT,   NULL, 0, &ConfigChannel.max_bans              },
2190         { "max_bans_large",     CF_INT,   NULL, 0, &ConfigChannel.max_bans_large        },
2191         { "max_chans_per_user", CF_INT,   NULL, 0, &ConfigChannel.max_chans_per_user    },
2192         { "no_create_on_split", CF_YESNO, NULL, 0, &ConfigChannel.no_create_on_split    },
2193         { "no_join_on_split",   CF_YESNO, NULL, 0, &ConfigChannel.no_join_on_split      },
2194         { "only_ascii_channels", CF_YESNO, NULL, 0, &ConfigChannel.only_ascii_channels },
2195         { "use_except",         CF_YESNO, NULL, 0, &ConfigChannel.use_except            },
2196         { "use_invex",          CF_YESNO, NULL, 0, &ConfigChannel.use_invex             },
2197         { "use_knock",          CF_YESNO, NULL, 0, &ConfigChannel.use_knock             },
2198         { "use_forward",        CF_YESNO, NULL, 0, &ConfigChannel.use_forward           },
2199         { "resv_forcepart",     CF_YESNO, NULL, 0, &ConfigChannel.resv_forcepart        },
2200         { "\0",                 0,        NULL, 0, NULL }
2201 };
2202
2203 static struct ConfEntry conf_serverhide_table[] =
2204 {
2205         { "disable_hidden",     CF_YESNO, NULL, 0, &ConfigServerHide.disable_hidden     },
2206         { "flatten_links",      CF_YESNO, NULL, 0, &ConfigServerHide.flatten_links      },
2207         { "hidden",             CF_YESNO, NULL, 0, &ConfigServerHide.hidden             },
2208         { "links_delay",        CF_TIME,  conf_set_serverhide_links_delay, 0, NULL      },
2209         { "\0",                 0,        NULL, 0, NULL }
2210 };
2211 /* *INDENT-ON* */
2212
2213 void
2214 newconf_init()
2215 {
2216         add_top_conf("modules", NULL, NULL, NULL);
2217         add_conf_item("modules", "path", CF_QSTRING, conf_set_modules_path);
2218         add_conf_item("modules", "module", CF_QSTRING, conf_set_modules_module);
2219
2220         add_top_conf("serverinfo", NULL, NULL, conf_serverinfo_table);
2221         add_top_conf("admin", NULL, NULL, conf_admin_table);
2222         add_top_conf("log", NULL, NULL, conf_log_table);
2223         add_top_conf("operator", conf_begin_oper, conf_end_oper, conf_operator_table);
2224         add_top_conf("class", conf_begin_class, conf_end_class, conf_class_table);
2225         add_top_conf("privset", NULL, NULL, conf_privset_table);
2226
2227         add_top_conf("listen", conf_begin_listen, conf_end_listen, NULL);
2228         add_conf_item("listen", "port", CF_INT | CF_FLIST, conf_set_listen_port);
2229         add_conf_item("listen", "sslport", CF_INT | CF_FLIST, conf_set_listen_sslport);
2230         add_conf_item("listen", "ip", CF_QSTRING, conf_set_listen_address);
2231         add_conf_item("listen", "host", CF_QSTRING, conf_set_listen_address);
2232
2233         add_top_conf("auth", conf_begin_auth, conf_end_auth, conf_auth_table);
2234
2235         add_top_conf("shared", conf_cleanup_shared, conf_cleanup_shared, NULL);
2236         add_conf_item("shared", "oper", CF_QSTRING|CF_FLIST, conf_set_shared_oper);
2237         add_conf_item("shared", "flags", CF_STRING | CF_FLIST, conf_set_shared_flags);
2238
2239         add_top_conf("connect", conf_begin_connect, conf_end_connect, conf_connect_table);
2240
2241         add_top_conf("exempt", NULL, NULL, NULL);
2242         add_conf_item("exempt", "ip", CF_QSTRING, conf_set_exempt_ip);
2243
2244         add_top_conf("cluster", conf_cleanup_cluster, conf_cleanup_cluster, NULL);
2245         add_conf_item("cluster", "name", CF_QSTRING, conf_set_cluster_name);
2246         add_conf_item("cluster", "flags", CF_STRING | CF_FLIST, conf_set_cluster_flags);
2247
2248         add_top_conf("general", NULL, NULL, conf_general_table);
2249         add_top_conf("channel", NULL, NULL, conf_channel_table);
2250         add_top_conf("serverhide", NULL, NULL, conf_serverhide_table);
2251
2252         add_top_conf("service", conf_begin_service, NULL, NULL);
2253         add_conf_item("service", "name", CF_QSTRING, conf_set_service_name);
2254
2255         add_top_conf("alias", conf_begin_alias, conf_end_alias, NULL);
2256         add_conf_item("alias", "name", CF_QSTRING, conf_set_alias_name);
2257         add_conf_item("alias", "target", CF_QSTRING, conf_set_alias_target);
2258
2259         add_top_conf("blacklist", NULL, NULL, NULL);
2260         add_conf_item("blacklist", "host", CF_QSTRING, conf_set_blacklist_host);
2261         add_conf_item("blacklist", "reject_reason", CF_QSTRING, conf_set_blacklist_reason);
2262 }