ircd/ircd_parser.y

   1 /*
   2  * ircd_parser.y: A yacc/bison parser for ircd config files.
   3  * This is part of ircu, an Internet Relay Chat server.
   4  * The contents of this file are Copyright(C) 2001 by Andrew Miller, the
   5  * ircd-hybrid team and the ircu team.
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  * $Id$
  21  */
  22 %{
  23
  24 #include "config.h"
  25 #include "s_conf.h"
  26 #include "class.h"
  27 #include "client.h"
  28 #include "crule.h"
  29 #include "ircd_features.h"
  30 #include "fileio.h"
  31 #include "gline.h"
  32 #include "hash.h"
  33 #include "ircd.h"
  34 #include "ircd_alloc.h"
  35 #include "ircd_chattr.h"
  36 #include "ircd_log.h"
  37 #include "ircd_reply.h"
  38 #include "ircd_snprintf.h"
  39 #include "ircd_string.h"
  40 #include "list.h"
  41 #include "listener.h"
  42 #include "match.h"
  43 #include "motd.h"
  44 #include "numeric.h"
  45 #include "numnicks.h"
  46 #include "opercmds.h"
  47 #include "parse.h"
  48 #include "res.h"
  49 #include "s_bsd.h"
  50 #include "s_conf.h"
  51 #include "s_debug.h"
  52 #include "s_misc.h"
  53 #include "send.h"
  54 #include "struct.h"
  55 #include "support.h"
  56 #include "sys.h"
  57 #include <stdlib.h>
  58 #include <string.h>
  59 #include <arpa/inet.h>
  60 #define MAX_STRINGS 80 /* Maximum number of feature params. */
  61   extern struct LocalConf   localConf;
  62   extern struct DenyConf*   denyConfList;
  63   extern struct CRuleConf*  cruleConfList;
  64   extern struct ServerConf* serverConfList;
  65
  66   int yylex(void);
  67   /* Now all the globals we need :/... */
  68   int tping, tconn, maxlinks, sendq, port;
  69   int stringno;
  70   char *name, *pass, *host;
  71   char *stringlist[MAX_STRINGS];
  72   struct ConnectionClass *class;
  73   struct ConfItem *aconf;
  74   struct DenyConf *dconf;
  75   struct ServerConf *sconf;
  76 %}
  77
  78 %token <text> QSTRING
  79 %token <num> NUMBER
  80 %token <text> FNAME
  81
  82 %token GENERAL
  83 %token ADMIN
  84 %token LOCATION
  85 %token CONTACT
  86 %token CONNECT
  87 %token CLASS
  88 %token PINGFREQ
  89 %token CONNECTFREQ
  90 %token MAXLINKS
  91 %token SENDQ
  92 %token NAME
  93 %token HOST
  94 %token PASS
  95 %token LOCAL
  96 %token SECONDS
  97 %token MINUTES
  98 %token HOURS
  99 %token DAYS
 100 %token WEEKS
 101 %token MONTHS
 102 %token YEARS
 103 %token DECADES
 104 %token BYTES
 105 %token KBYTES
 106 %token MBYTES
 107 %token GBYTES
 108 %token TBYTES
 109 %token SERVER
 110 %token PORT
 111 %token MASK
 112 %token HUB
 113 %token LEAF
 114 %token UWORLD
 115 %token YES
 116 %token NO
 117 %token OPER
 118 %token PORT
 119 %token VHOST
 120 %token MASK
 121 %token HIDDEN
 122 %token MOTD
 123 %token JUPE
 124 %token NICK
 125 %token NUMERIC
 126 %token DESCRIPTION
 127 %token CLIENT
 128 %token KILL
 129 %token CRULE
 130 %token REAL
 131 %token REASON
 132 %token TFILE
 133 %token RULE
 134 %token ALL
 135 %token IP
 136 %token FEATURES
 137 /* and now a lot of priviledges... */
 138 %token TPRIV_CHAN_LIMIT, TPRIV_MODE_LCHAN, TPRIV_DEOP_LCHAN, TPRIV_WALK_LCHAN
 139 %token TPRIV_KILL, TPRIV_LOCAL_KILL, TPRIV_REHASH, TPRIV_RESTART, TPRIV_DIE
 140 %token TPRIV_GLINE, TPRIV_LOCAL_GLINE, TPRIV_JUPE, TPRIV_LOCAL_JUPE
 141 %token TPRIV_LOCAL_OPMODE, TPRIV_OPMODE, TPRIV_SET, TPRIV_WHOX, TPRIV_BADCHAN
 142 %token TPRIV_LOCAL_BADCHAN
 143 %token TPRIV_SEE_CHAN, TPRIV_SHOW_INVIS, TPRIV_SHOW_ALL_INVIS, TPRIV_PROPAGATE
 144 %token TPRIV_UNLIMIT_QUERY, TPRIV_DISPLAY, TPRIV_SEE_OPERS, TPRIV_WIDE_GLINE
 145 /* and some types... */
 146 %type <num> sizespec
 147 %type <num> timespec, timefactor, factoredtimes, factoredtime
 148 %type <num> expr, yesorno, privtype
 149 %left '+' '-'
 150 %left '*' '/'
 151
 152 %union{
 153  char *text;
 154  int num;
 155 }
 156
 157 %%
 158 /* Blocks in the config file... */
 159 blocks: blocks block | block;
 160 block: adminblock | generalblock | classblock | connectblock |
 161        serverblock | operblock | portblock | jupeblock | clientblock |
 162        killblock | cruleblock | motdblock | featuresblock;
 163
 164 /* The timespec, sizespec and expr was ripped straight from
 165  * ircd-hybrid-7. */
 166 timespec: expr | factoredtimes;
 167
 168 factoredtimes: factoredtimes factoredtime
 169 {
 170   $$ = $1 + $2;
 171 } | factoredtime;
 172
 173 factoredtime: expr timefactor
 174 {
 175   $$ = $1 * $2;
 176 };
 177
 178 timefactor: SECONDS { $$ = 1; }
 179 | MINUTES { $$ = 60; }
 180 | HOURS { $$ = 60 * 60; }
 181 | DAYS { $$ = 60 * 60 * 24; }
 182 | WEEKS { $$ = 60 * 60 * 24 * 7; }
 183 | MONTHS { $$ = 60 * 60 * 24 * 7 * 4; }
 184 | YEARS { $$ = 60 * 60 * 24 * 365; }
 185 | DECADES { $$ = 60 * 60 * 24 * 365 * 10; };
 186
 187
 188 sizespec:       expr
 189                 = {
 190                         $$ = $1;
 191                 }
 192                 | expr BYTES
 193                 = {
 194                         $$ = $1;
 195                 }
 196                 | expr KBYTES
 197                 = {
 198                         $$ = $1 * 1024;
 199                 }
 200                 | expr MBYTES
 201                 = {
 202                         $$ = $1 * 1024 * 1024;
 203                 }
 204                 | expr GBYTES
 205                 = {
 206                         $$ = $1 * 1024 * 1024 * 1024;
 207                 }
 208                 | expr TBYTES
 209                 = {
 210                         $$ = $1 * 1024 * 1024 * 1024;
 211                 }
 212                 ;
 213
 214 /* this is an arithmatic expression */
 215 expr: NUMBER
 216                 = {
 217                         $$ = $1;
 218                 }
 219                 | expr '+' expr
 220                 = {
 221                         $$ = $1 + $3;
 222                 }
 223                 | expr '-' expr
 224                 = {
 225                         $$ = $1 - $3;
 226                 }
 227                 | expr '*' expr
 228                 = {
 229                         $$ = $1 * $3;
 230                 }
 231                 | expr '/' expr
 232                 = {
 233                         $$ = $1 / $3;
 234                 }
 235 /* leave this out until we find why it makes BSD yacc dump core -larne
 236                 | '-' expr  %prec NEG
 237                 = {
 238                         $$ = -$2;
 239                 } */
 240                 | '(' expr ')'
 241                 = {
 242                         $$ = $2;
 243                 }
 244                 ;
 245
 246 jupeblock: JUPE '{' jupeitems '}' ';' ;
 247 jupeitems: jupeitem jupeitems | jupeitem;
 248 jupeitem: jupenick;
 249 jupenick: NICK '=' QSTRING
 250 {
 251   addNickJupes(yylval.text);
 252 } ';';
 253
 254 generalblock: GENERAL '{' generalitems '}' ';' ;
 255 generalitems: generalitem generalitems | generalitem;
 256 generalitem: generalnumeric | generalname | generalvhost | generaldesc;
 257 generalnumeric: NUMERIC '=' NUMBER ';'
 258 {
 259   if (localConf.numeric == 0)
 260     localConf.numeric = yylval.num;
 261 };
 262
 263 generalname: NAME '=' QSTRING ';'
 264 {
 265   if (localConf.name == NULL)
 266     DupString(localConf.name, yylval.text);
 267 };
 268
 269 generaldesc: DESCRIPTION '=' QSTRING ';'
 270 {
 271   MyFree(localConf.description);
 272   DupString(localConf.description, yylval.text);
 273   ircd_strncpy(cli_info(&me), yylval.text, REALLEN);
 274 };
 275
 276 generalvhost: VHOST '=' QSTRING ';'
 277 {
 278   if (INADDR_NONE ==
 279       (localConf.vhost_address.s_addr = inet_addr(yylval.text)))
 280     localConf.vhost_address.s_addr = INADDR_ANY;
 281 };
 282
 283 adminblock: ADMIN '{' adminitems '}'
 284 {
 285   if (localConf.location1 == NULL)
 286     DupString(localConf.location1, "");
 287   if (localConf.location2 == NULL)
 288     DupString(localConf.location2, "");
 289   if (localConf.contact == NULL)
 290     DupString(localConf.contact, "");
 291 } ';';
 292 adminitems: adminitems adminitem | adminitem;
 293 adminitem: adminlocation | admincontact;
 294 adminlocation: LOCATION '=' QSTRING ';'
 295 {
 296  if (localConf.location1 == NULL)
 297   DupString(localConf.location1, yylval.text);
 298  else if (localConf.location2 == NULL)
 299   DupString(localConf.location2, yylval.text);
 300  /* Otherwise just drop it. -A1kmm */
 301 };
 302 admincontact: CONTACT '=' QSTRING ';'
 303 {
 304  if (localConf.contact != NULL)
 305    MyFree(localConf.contact);
 306  DupString(localConf.contact, yylval.text);
 307 };
 308
 309 classblock: CLASS {
 310   name = NULL;
 311   tping = 90;
 312   tconn = 0;
 313   maxlinks = 0;
 314   sendq = 0;
 315 } '{' classitems '}'
 316 {
 317   if (name != NULL)
 318   {
 319    add_class(name, tping, tconn, maxlinks, sendq);
 320   }
 321 } ';';
 322 classitems: classitem classitems | classitem;
 323 classitem: classname | classpingfreq | classconnfreq | classmaxlinks |
 324            classsendq;
 325 classname: NAME '=' QSTRING ';'
 326 {
 327   MyFree(name);
 328   DupString(name, yylval.text);
 329 };
 330 classpingfreq: PINGFREQ '=' timespec ';'
 331 {
 332   tping = yylval.num;
 333 };
 334 classconnfreq: CONNECTFREQ '=' timespec ';'
 335 {
 336   tconn = yylval.num;
 337 };
 338 classmaxlinks: MAXLINKS '=' expr ';'
 339 {
 340   maxlinks = yylval.num;
 341 };
 342 classsendq: SENDQ '=' sizespec ';'
 343 {
 344   sendq = yylval.num;
 345 };
 346
 347 connectblock: CONNECT
 348 {
 349  name = pass = host = NULL;
 350  class = NULL;
 351  port = 0;
 352 } '{' connectitems '}'
 353 {
 354  if (name != NULL && pass != NULL && host != NULL && class != NULL &&
 355      /*ccount < MAXCONFLINKS &&*/ !strchr(host, '*') &&
 356      !strchr(host, '?'))
 357  {
 358    aconf = make_conf();
 359    aconf->status = CONF_SERVER;
 360    aconf->name = name;
 361    aconf->passwd = pass;
 362    aconf->conn_class = class;
 363    aconf->port = port;
 364    aconf->status = CONF_SERVER;
 365    aconf->host = host;
 366    aconf->next = GlobalConfList;
 367    aconf->ipnum.s_addr = INADDR_NONE;
 368    lookup_confhost(aconf);
 369    GlobalConfList = aconf;
 370  }
 371  else
 372  {
 373    MyFree(name);
 374    MyFree(pass);
 375    MyFree(host);
 376    name = pass = host = NULL;
 377  }
 378 }';';
 379 connectitems: connectitem connectitems | connectitem;
 380 connectitem: connectname | connectpass | connectclass | connecthost
 381               | connectport;
 382 connectname: NAME '=' QSTRING ';'
 383 {
 384  MyFree(name);
 385  DupString(name, yylval.text);
 386 };
 387 connectpass: PASS '=' QSTRING ';'
 388 {
 389  MyFree(pass);
 390  DupString(pass, yylval.text);
 391 };
 392 connectclass: CLASS '=' QSTRING ';'
 393 {
 394  class = find_class(yylval.text);
 395 };
 396 connecthost: HOST '=' QSTRING ';'
 397 {
 398  MyFree(host);
 399  DupString(host, yylval.text);
 400 };
 401 connectport: PORT '=' NUMBER ';'
 402 {
 403  port = yylval.num;
 404 };
 405
 406 serverblock: SERVER
 407 {
 408  aconf = MyMalloc(sizeof(*aconf));
 409  memset(aconf, 0, sizeof(*aconf));
 410 } '{' serveritems '}'
 411 {
 412  if (aconf->status == 0)
 413  {
 414    MyFree(aconf->host);
 415    MyFree(aconf->name);
 416    MyFree(aconf);
 417    aconf = NULL;
 418  }
 419  else
 420  {
 421    aconf->next = GlobalConfList;
 422    GlobalConfList = aconf;
 423  }
 424 } ';';
 425 serveritems: serveritem serveritems | serveritem;
 426 serveritem: servername | servermask | serverhub | serverleaf |
 427              serveruworld;
 428 servername: NAME '=' QSTRING
 429 {
 430  MyFree(aconf->name);
 431  DupString(aconf->name, yylval.text);
 432 } ';' ;
 433 servermask: MASK '=' QSTRING
 434 {
 435  MyFree(aconf->host);
 436  DupString(aconf->host, yylval.text);
 437 } ';' ;
 438 /* XXX - perhaps we should do this the hybrid way in connect blocks
 439  * instead -A1kmm. */
 440 serverhub: HUB '=' YES ';'
 441 {
 442  aconf->status |= CONF_HUB;
 443  aconf->status &= ~CONF_LEAF;
 444 }
 445 | HUB '=' NO
 446 {
 447  aconf->status &= ~CONF_HUB;
 448 } ';';
 449 serverleaf: LEAF '=' YES ';'
 450 {
 451  if (!(aconf->status & CONF_HUB && aconf->status & CONF_UWORLD))
 452   aconf->status |= CONF_LEAF;
 453 }
 454 | LEAF '=' NO ';'
 455 {
 456  aconf->status &= ~CONF_LEAF;
 457 };
 458 serveruworld: UWORLD '=' YES ';'
 459 {
 460  aconf->status |= CONF_UWORLD;
 461  aconf->status &= ~CONF_LEAF;
 462 }
 463 | UWORLD '=' NO ';'
 464 {
 465   aconf->status &= ~CONF_UWORLD;
 466 };
 467
 468 operblock: OPER
 469 {
 470   aconf = MyMalloc(sizeof(*aconf));
 471   memset(aconf, 0, sizeof(*aconf));
 472   aconf->status = CONF_OPERATOR;
 473   set_initial_oper_privs(aconf, (FLAGS_OPER | FLAGS_LOCOP));
 474 } '{' operitems '}' ';'
 475 {
 476   if (aconf->name != NULL && aconf->passwd != NULL && aconf->host != NULL)
 477   {
 478     aconf->next = GlobalConfList;
 479     GlobalConfList = aconf;
 480   }
 481   else
 482   {
 483     log_write(LS_CONFIG, L_ERROR, 0, "operator blocks need a name, password, and host.");
 484     MyFree(aconf->name);
 485     MyFree(aconf->passwd);
 486     MyFree(aconf->host);
 487     MyFree(aconf);
 488     aconf = NULL;
 489   }
 490 };
 491 operitems: operitem | operitems operitem;
 492 operitem: opername | operpass | operlocal | operhost | operclass | operpriv;
 493
 494 opername: NAME '=' QSTRING ';'
 495 {
 496   MyFree(aconf->name);
 497   DupString(aconf->name, yylval.text);
 498 };
 499
 500 operpass: PASS '=' QSTRING ';'
 501 {
 502   MyFree(aconf->passwd);
 503   DupString(aconf->passwd, yylval.text);
 504 };
 505
 506 operlocal: LOCAL '=' YES ';'
 507 {
 508   /* XXX it would be good to get rid of local operators and add same
 509    * permission values here. But for now, I am just going with local
 510    * opers... */
 511   aconf->status = CONF_LOCOP;
 512   /* XXX blow away existing priviledges. */
 513   set_initial_oper_privs(aconf, FLAGS_LOCOP);
 514 } | LOCAL '=' NO ';'
 515 {
 516   /* XXX blow away existing priviledges. */
 517   set_initial_oper_privs(aconf, (FLAGS_OPER|FLAGS_LOCOP));
 518   aconf->status = CONF_OPERATOR;
 519 };
 520
 521 operhost: HOST '=' QSTRING ';'
 522 {
 523  MyFree(aconf->host);
 524  if (!strchr(yylval.text, '@'))
 525  {
 526    int uh_len;
 527    char *b = MyMalloc((uh_len = strlen(yylval.text)+3));
 528    ircd_snprintf(0, b, uh_len, "*@%s", yylval.text);
 529    aconf->host = b;
 530  }
 531  else
 532    DupString(aconf->host, yylval.text);
 533 };
 534
 535 operclass: CLASS '=' QSTRING ';'
 536 {
 537  aconf->conn_class = find_class(yylval.text);
 538 };
 539
 540 operpriv: privtype '=' yesorno ';'
 541 {
 542   if ($3 == 1)
 543     PrivSet(&aconf->privs, $1);
 544   else
 545     PrivClr(&aconf->privs, $1);
 546 };
 547
 548 privtype: TPRIV_CHAN_LIMIT { $$ = PRIV_CHAN_LIMIT; } |
 549           TPRIV_MODE_LCHAN { $$ = PRIV_MODE_LCHAN; } |
 550           TPRIV_DEOP_LCHAN { $$ = PRIV_DEOP_LCHAN; } |
 551           TPRIV_WALK_LCHAN { $$ = PRIV_WALK_LCHAN; } |
 552           TPRIV_KILL { $$ = PRIV_KILL; } |
 553           TPRIV_LOCAL_KILL { $$ = PRIV_LOCAL_KILL; } |
 554           TPRIV_REHASH { $$ = PRIV_REHASH; } |
 555           TPRIV_RESTART { $$ = PRIV_RESTART; } |
 556           TPRIV_DIE { $$ = PRIV_DIE; } |
 557           TPRIV_GLINE { $$ = PRIV_GLINE; } |
 558           TPRIV_LOCAL_GLINE { $$ = PRIV_LOCAL_GLINE; } |
 559           TPRIV_JUPE { $$ = PRIV_JUPE; } |
 560           TPRIV_LOCAL_JUPE { $$ = PRIV_LOCAL_JUPE; } |
 561           TPRIV_LOCAL_OPMODE { $$ = PRIV_LOCAL_OPMODE; } |
 562           TPRIV_OPMODE { $$ = PRIV_OPMODE; }|
 563           TPRIV_SET { $$ = PRIV_SET; } |
 564           TPRIV_WHOX { $$ = PRIV_WHOX; } |
 565           TPRIV_BADCHAN { $$ = PRIV_BADCHAN; } |
 566           TPRIV_LOCAL_BADCHAN { $$ = TPRIV_LOCAL_BADCHAN; } |
 567           TPRIV_SEE_CHAN { $$ = PRIV_SEE_CHAN; } |
 568           TPRIV_SHOW_INVIS { $$ = PRIV_SHOW_INVIS; } |
 569           TPRIV_SHOW_ALL_INVIS { $$ = PRIV_SHOW_ALL_INVIS; } |
 570           TPRIV_PROPAGATE { $$ = PRIV_PROPAGATE; } |
 571           TPRIV_UNLIMIT_QUERY { $$ = PRIV_UNLIMIT_QUERY; } |
 572           TPRIV_DISPLAY { $$ = PRIV_DISPLAY; } |
 573           TPRIV_SEE_OPERS { $$ = PRIV_SEE_OPERS; } |
 574           TPRIV_WIDE_GLINE { $$ = PRIV_WIDE_GLINE; };
 575
 576 yesorno: YES { $$ = 1; } | NO { $$ = 0; };
 577
 578 /* The port block... */
 579 portblock: PORT {
 580   port = 0;
 581   host = NULL;
 582   /* Hijack these for is_server, is_hidden to cut down on globals... */
 583   tconn = 0;
 584   tping = 0;
 585   /* and this for mask... */
 586   pass = NULL;
 587 } '{' portitems '}' ';'
 588 {
 589   if (port > 0 && port <= 0xFFFF)
 590   {
 591     add_listener(port, host, pass, tconn, tping);
 592     host = pass = NULL;
 593   }
 594   else
 595   {
 596     MyFree(host);
 597     MyFree(pass);
 598   }
 599 };
 600 portitems: portitem portitems | portitem;
 601 portitem: portnumber | portvhost | portmask | portserver | porthidden;
 602 portnumber: PORT '=' NUMBER ';'
 603 {
 604   port = yylval.num;
 605 };
 606
 607 portvhost: VHOST '=' QSTRING ';'
 608 {
 609   MyFree(host);
 610   DupString(host, yylval.text);
 611 };
 612
 613 portmask: MASK '=' QSTRING ';'
 614 {
 615   MyFree(pass);
 616   DupString(pass, yylval.text);
 617 };
 618
 619 portserver: SERVER '=' YES ';'
 620 {
 621   tconn = -1;
 622 } | SERVER '=' NO ';'
 623 {
 624   tconn = 0;
 625 };
 626
 627 porthidden: HIDDEN '=' YES ';'
 628 {
 629   tping = -1;
 630 } | HIDDEN '=' NO ';'
 631 {
 632   tping = 0;
 633 };
 634
 635 clientblock: CLIENT
 636 {
 637   aconf = MyMalloc(sizeof(*aconf));
 638   memset(aconf, 0, sizeof(*aconf));
 639   aconf->status = CONF_CLIENT;
 640 } '{' clientitems '}'
 641 {
 642   if ((aconf->host != NULL || aconf->name!=NULL))
 643   {
 644     if (aconf->host == NULL)
 645       DupString(aconf->host, "");
 646     if (aconf->name == NULL)
 647       DupString(aconf->name, "");
 648     if (aconf->conn_class == NULL)
 649       aconf->conn_class = find_class("default");
 650     aconf->next = GlobalConfList;
 651     GlobalConfList = aconf;
 652     aconf = NULL;
 653   }
 654   else
 655   {
 656    MyFree(aconf->host);
 657    MyFree(aconf->passwd);
 658    MyFree(aconf);
 659    aconf = NULL;
 660   }
 661 } ';';
 662 clientitems: clientitem clientitems | clientitem;
 663 clientitem: clienthost | clientclass | clientpass | clientip;
 664 clientip: IP '=' QSTRING ';'
 665 {
 666   MyFree(aconf->host);
 667   DupString(aconf->host, yylval.text);
 668 };
 669
 670 clienthost: HOST '=' QSTRING ';'
 671 {
 672   MyFree(aconf->name);
 673   DupString(aconf->name, yylval.text);
 674 };
 675
 676 clientclass: CLASS '=' QSTRING ';'
 677 {
 678   aconf->conn_class = find_class(yylval.text);
 679 };
 680
 681 clientpass: PASS '=' QSTRING ';'
 682 {
 683   MyFree(aconf->passwd);
 684   DupString(aconf->passwd, yylval.text);
 685 };
 686
 687 killblock: KILL
 688 {
 689   dconf = MyMalloc(sizeof(*dconf));
 690   memset(dconf, 0, sizeof(*dconf));
 691 } '{' killitems '}'
 692 {
 693   if (dconf->hostmask != NULL)
 694   {
 695     if (dconf->usermask == NULL)
 696       DupString(dconf->usermask, "*");
 697     dconf->next = denyConfList;
 698     denyConfList = dconf;
 699     dconf = NULL;
 700   }
 701   else
 702   {
 703     MyFree(dconf->hostmask);
 704     MyFree(dconf->message);
 705     MyFree(dconf);
 706     dconf = NULL;
 707   }
 708 } ';';
 709 killitems: killitem killitems | killitem;
 710 killitem: killuhost | killreal | killreasonfile | killreason;
 711 killuhost: HOST '=' QSTRING ';'
 712 {
 713   char *u, *h;
 714   dconf->flags &= ~DENY_FLAGS_REALNAME;
 715   MyFree(dconf->hostmask);
 716   MyFree(dconf->usermask);
 717   if ((h = strchr(yylval.text, '@')) == NULL)
 718   {
 719     u = "*";
 720     h = yylval.text;
 721   }
 722   else
 723   {
 724     u = yylval.text;
 725     h++;
 726   }
 727   DupString(dconf->hostmask, h);
 728   DupString(dconf->usermask, u);
 729   if (strchr(yylval.text, '.'))
 730   {
 731     int  c_class;
 732     char ipname[16];
 733     int  ad[4] = { 0 };
 734     int  bits2 = 0;
 735     dconf->flags |= DENY_FLAGS_IP;
 736     c_class = sscanf(dconf->hostmask, "%d.%d.%d.%d/%d",
 737                      &ad[0], &ad[1], &ad[2], &ad[3], &bits2);
 738     if (c_class != 5) {
 739       dconf->bits = c_class * 8;
 740     }
 741     else {
 742       dconf->bits = bits2;
 743     }
 744     ircd_snprintf(0, ipname, sizeof(ipname), "%d.%d.%d.%d", ad[0], ad[1],
 745                   ad[2], ad[3]);
 746     dconf->address = inet_addr(ipname);
 747   }
 748 };
 749
 750 killreal: REAL '=' QSTRING ';'
 751 {
 752  dconf->flags &= ~DENY_FLAGS_IP;
 753  dconf->flags |= DENY_FLAGS_REALNAME;
 754  MyFree(dconf->hostmask);
 755  /* Leave usermask so you can specify user and real... */
 756  DupString(dconf->hostmask, yylval.text);
 757 };
 758
 759 killreason: REASON '=' QSTRING ';'
 760 {
 761  dconf->flags &= DENY_FLAGS_FILE;
 762  MyFree(dconf->message);
 763  DupString(dconf->message, yylval.text);
 764 };
 765
 766 killreasonfile: TFILE '=' QSTRING ';'
 767 {
 768  dconf->flags |= DENY_FLAGS_FILE;
 769  MyFree(dconf->message);
 770  DupString(dconf->message, yylval.text);
 771 };
 772
 773 cruleblock: CRULE
 774 {
 775   host = pass = NULL;
 776   tconn = CRULE_AUTO;
 777 } '{' cruleitems '}'
 778 {
 779   struct CRuleNode *node;
 780   if (host != NULL && pass != NULL && (node=crule_parse(pass)) != NULL)
 781   {
 782     struct CRuleConf *p = MyMalloc(sizeof(*p));
 783     p->hostmask = host;
 784     p->rule = pass;
 785     p->type = tconn;
 786     p->node = node;
 787     p->next = cruleConfList;
 788     cruleConfList = p;
 789   }
 790   else
 791   {
 792     MyFree(host);
 793     MyFree(pass);
 794   }
 795 } ';';
 796
 797 cruleitems: cruleitem cruleitems | cruleitem;
 798 cruleitem: cruleserver | crulerule | cruleall;
 799
 800 cruleserver: SERVER '=' QSTRING ';'
 801 {
 802   MyFree(host);
 803   collapse(yylval.text);
 804   DupString(host, yylval.text);
 805 };
 806
 807 crulerule: RULE '=' QSTRING ';'
 808 {
 809  MyFree(pass);
 810  DupString(pass, yylval.text);
 811 };
 812
 813 cruleall: ALL '=' YES ';'
 814 {
 815  tconn = CRULE_ALL;
 816 } | ALL '=' NO ';'
 817 {
 818  tconn = CRULE_AUTO;
 819 };
 820
 821 motdblock: MOTD {
 822  pass = host = NULL;
 823 } '{' motditems '}'
 824 {
 825   if (host != NULL && pass != NULL)
 826     motd_add(host, pass);
 827   MyFree(host);
 828   MyFree(pass);
 829   host = pass = NULL;
 830 } ';';
 831
 832 motditems: motditem motditems | motditem;
 833 motditem: motdhost | motdfile;
 834 motdhost: HOST '=' QSTRING ';'
 835 {
 836   DupString(host, yylval.text);
 837 };
 838
 839 motdfile: TFILE '=' QSTRING ';'
 840 {
 841   DupString(pass, yylval.text);
 842 };
 843
 844 featuresblock: FEATURES '{' featureitems '}' ';';
 845 featureitems: featureitems featureitem | featureitem;
 846
 847 featureitem: QSTRING
 848 {
 849   stringlist[0] = $1;
 850   stringno = 1;
 851 } '=' stringlist ';';
 852
 853 stringlist: QSTRING
 854 {
 855   stringlist[1] = $1;
 856   stringno = 2;
 857 } posextrastrings
 858 {
 859   feature_set(NULL, (const char * const *)stringlist, stringno);
 860 };
 861 posextrastrings: /* empty */ | extrastrings;
 862 extrastrings: extrastrings extrastring | extrastring;
 863 extrastring: QSTRING
 864 {
 865   if (stringno < MAX_STRINGS)
 866     stringlist[stringno++] = $1;
 867 };