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_debug.h"
  51 #include "s_misc.h"
  52 #include "send.h"
  53 #include "struct.h"
  54 #include "support.h"
  55 #include "sys.h"
  56 #include <stdlib.h>
  57 #include <string.h>
  58 #include <arpa/inet.h>
  59 #define MAX_STRINGS 80 /* Maximum number of feature params. */
  60   extern struct LocalConf   localConf;
  61   extern struct DenyConf*   denyConfList;
  62   extern struct CRuleConf*  cruleConfList;
  63   extern struct ServerConf* serverConfList;
  64
  65   int yylex(void);
  66   /* Now all the globals we need :/... */
  67   int tping, tconn, maxlinks, sendq, port;
  68   int stringno;
  69   char *name, *pass, *host;
  70   char *stringlist[MAX_STRINGS];
  71   struct ConnectionClass *class;
  72   struct ConfItem *aconf;
  73   struct DenyConf *dconf;
  74   struct ServerConf *sconf;
  75 %}
  76
  77 %token <text> QSTRING
  78 %token <num> NUMBER
  79 %token <text> FNAME
  80
  81 %token GENERAL
  82 %token ADMIN
  83 %token LOCATION
  84 %token CONTACT
  85 %token CONNECT
  86 %token CLASS
  87 %token PINGFREQ
  88 %token CONNECTFREQ
  89 %token MAXLINKS
  90 %token SENDQ
  91 %token NAME
  92 %token HOST
  93 %token PASS
  94 %token LOCAL
  95 %token SECONDS
  96 %token MINUTES
  97 %token HOURS
  98 %token DAYS
  99 %token WEEKS
 100 %token MONTHS
 101 %token YEARS
 102 %token DECADES
 103 %token BYTES
 104 %token KBYTES
 105 %token MBYTES
 106 %token GBYTES
 107 %token TBYTES
 108 %token SERVER
 109 %token PORT
 110 %token MASK
 111 %token HUB
 112 %token LEAF
 113 %token UWORLD
 114 %token YES
 115 %token NO
 116 %token OPER
 117 %token PORT
 118 %token VHOST
 119 %token MASK
 120 %token HIDDEN
 121 %token MOTD
 122 %token JUPE
 123 %token NICK
 124 %token NUMERIC
 125 %token DESCRIPTION
 126 %token CLIENT
 127 %token KILL
 128 %token CRULE
 129 %token REAL
 130 %token REASON
 131 %token TFILE
 132 %token RULE
 133 %token ALL
 134 %token IP
 135 %token FEATURES
 136 /* and now a lot of priviledges... */
 137 %token TPRIV_CHAN_LIMIT, TPRIV_MODE_LCHAN, TPRIV_DEOP_LCHAN, TPRIV_WALK_LCHAN
 138 %token TPRIV_KILL, TPRIV_LOCAL_KILL, TPRIV_REHASH, TPRIV_RESTART, TPRIV_DIE
 139 %token TPRIV_GLINE, TPRIV_LOCAL_GLINE, TPRIV_JUPE, TPRIV_LOCAL_JUPE
 140 %token TPRIV_LOCAL_OPMODE, TPRIV_OPMODE, TPRIV_SET, TPRIV_WHOX, TPRIV_BADCHAN
 141 %token TPRIV_LOCAL_BADCHAN
 142 %token TPRIV_SEE_CHAN, TPRIV_SHOW_INVIS, TPRIV_SHOW_ALL_INVIS, TPRIV_PROPAGATE
 143 %token TPRIV_UNLIMIT_QUERY, TPRIV_DISPLAY, TPRIV_SEE_OPERS, TPRIV_WIDE_GLINE
 144 /* and some types... */
 145 %type <num> sizespec
 146 %type <num> timespec, timefactor, factoredtimes, factoredtime
 147 %type <num> expr, yesorno, privtype
 148 %left '+' '-'
 149 %left '*' '/'
 150
 151 %union{
 152  char *text;
 153  int num;
 154 }
 155
 156 %%
 157 /* Blocks in the config file... */
 158 blocks: blocks block | block;
 159 block: adminblock | generalblock | classblock | connectblock |
 160        serverblock | operblock | portblock | jupeblock | clientblock |
 161        killblock | cruleblock | motdblock | featuresblock;
 162
 163 /* The timespec, sizespec and expr was ripped straight from
 164  * ircd-hybrid-7. */
 165 timespec: expr | factoredtimes;
 166
 167 factoredtimes: factoredtimes factoredtime
 168 {
 169   $$ = $1 + $2;
 170 } | factoredtime;
 171
 172 factoredtime: expr timefactor
 173 {
 174   $$ = $1 * $2;
 175 };
 176
 177 timefactor: SECONDS { $$ = 1; }
 178 | MINUTES { $$ = 60; }
 179 | HOURS { $$ = 60 * 60; }
 180 | DAYS { $$ = 60 * 60 * 24; }
 181 | WEEKS { $$ = 60 * 60 * 24 * 7; }
 182 | MONTHS { $$ = 60 * 60 * 24 * 7 * 4; }
 183 | YEARS { $$ = 60 * 60 * 24 * 365; }
 184 | DECADES { $$ = 60 * 60 * 24 * 365 * 10; };
 185
 186
 187 sizespec:       expr
 188                 = {
 189                         $$ = $1;
 190                 }
 191                 | expr BYTES
 192                 = {
 193                         $$ = $1;
 194                 }
 195                 | expr KBYTES
 196                 = {
 197                         $$ = $1 * 1024;
 198                 }
 199                 | expr MBYTES
 200                 = {
 201                         $$ = $1 * 1024 * 1024;
 202                 }
 203                 | expr GBYTES
 204                 = {
 205                         $$ = $1 * 1024 * 1024 * 1024;
 206                 }
 207                 | expr TBYTES
 208                 = {
 209                         $$ = $1 * 1024 * 1024 * 1024;
 210                 }
 211                 ;
 212
 213 /* this is an arithmatic expression */
 214 expr: NUMBER
 215                 = {
 216                         $$ = $1;
 217                 }
 218                 | expr '+' expr
 219                 = {
 220                         $$ = $1 + $3;
 221                 }
 222                 | expr '-' expr
 223                 = {
 224                         $$ = $1 - $3;
 225                 }
 226                 | expr '*' expr
 227                 = {
 228                         $$ = $1 * $3;
 229                 }
 230                 | expr '/' expr
 231                 = {
 232                         $$ = $1 / $3;
 233                 }
 234 /* leave this out until we find why it makes BSD yacc dump core -larne
 235                 | '-' expr  %prec NEG
 236                 = {
 237                         $$ = -$2;
 238                 } */
 239                 | '(' expr ')'
 240                 = {
 241                         $$ = $2;
 242                 }
 243                 ;
 244
 245 jupeblock: JUPE '{' jupeitems '}' ';' ;
 246 jupeitems: jupeitem jupeitems | jupeitem;
 247 jupeitem: jupenick;
 248 jupenick: NICK '=' QSTRING
 249 {
 250   addNickJupes(yylval.text);
 251 } ';';
 252
 253 generalblock: GENERAL '{' generalitems '}' ';' ;
 254 generalitems: generalitem generalitems | generalitem;
 255 generalitem: generalnumeric | generalname | generalvhost | generaldesc;
 256 generalnumeric: NUMERIC '=' NUMBER ';'
 257 {
 258   if (localConf.numeric == 0)
 259     localConf.numeric = yylval.num;
 260 };
 261
 262 generalname: NAME '=' QSTRING ';'
 263 {
 264   if (localConf.name == NULL)
 265     DupString(localConf.name, yylval.text);
 266 };
 267
 268 generaldesc: DESCRIPTION '=' QSTRING ';'
 269 {
 270   MyFree(localConf.description);
 271   DupString(localConf.description, yylval.text);
 272   ircd_strncpy(cli_info(&me), yylval.text, REALLEN);
 273 };
 274
 275 generalvhost: VHOST '=' QSTRING ';'
 276 {
 277   if (INADDR_NONE ==
 278       (localConf.vhost_address.s_addr = inet_addr(yylval.text)))
 279     localConf.vhost_address.s_addr = INADDR_ANY;
 280 };
 281
 282 adminblock: ADMIN '{' adminitems '}'
 283 {
 284   if (localConf.location1 == NULL)
 285     DupString(localConf.location1, "");
 286   if (localConf.location2 == NULL)
 287     DupString(localConf.location2, "");
 288   if (localConf.contact == NULL)
 289     DupString(localConf.contact, "");
 290 } ';';
 291 adminitems: adminitems adminitem | adminitem;
 292 adminitem: adminlocation | admincontact;
 293 adminlocation: LOCATION '=' QSTRING ';'
 294 {
 295  if (localConf.location1 == NULL)
 296   DupString(localConf.location1, yylval.text);
 297  else if (localConf.location2 == NULL)
 298   DupString(localConf.location2, yylval.text);
 299  /* Otherwise just drop it. -A1kmm */
 300 };
 301 admincontact: CONTACT '=' QSTRING ';'
 302 {
 303  if (localConf.contact != NULL)
 304   free(localConf.contact);
 305  DupString(localConf.contact, yylval.text);
 306 };
 307
 308 classblock: CLASS {
 309  name = NULL;
 310  tping = 90;
 311  tconn = 0;
 312  maxlinks = 0;
 313  sendq = 0;
 314 } '{' classitems '}'
 315 {
 316  if (name != NULL)
 317  {
 318   add_class(name, tping, tconn, maxlinks, sendq);
 319  }
 320 } ';';
 321 classitems: classitem classitems | classitem;
 322 classitem: classname | classpingfreq | classconnfreq | classmaxlinks |
 323            classsendq;
 324 classname: NAME '=' QSTRING ';'
 325 {
 326  MyFree(name);
 327  DupString(name, yylval.text);
 328 };
 329 classpingfreq: PINGFREQ '=' timespec ';'
 330 {
 331  tping = yylval.num;
 332 };
 333 classconnfreq: CONNECTFREQ '=' timespec ';'
 334 {
 335  tconn = yylval.num;
 336 };
 337 classmaxlinks: MAXLINKS '=' expr ';'
 338 {
 339  maxlinks = yylval.num;
 340 };
 341 classsendq: SENDQ '=' sizespec ';'
 342 {
 343  sendq = yylval.num;
 344 };
 345
 346 connectblock: CONNECT
 347 {
 348  name = pass = host = NULL;
 349  class = NULL;
 350  port = 0;
 351 } '{' connectitems '}'
 352 {
 353  if (name != NULL && pass != NULL && host != NULL && class != NULL &&
 354      /*ccount < MAXCONFLINKS &&*/ !strchr(host, '*') &&
 355      !strchr(host, '?'))
 356  {
 357   aconf = MyMalloc(sizeof(*aconf));
 358   aconf->status = CONF_SERVER;
 359   aconf->name = name;
 360   aconf->passwd = pass;
 361   aconf->conn_class = class;
 362   aconf->port = port;
 363   aconf->status = CONF_SERVER;
 364   aconf->host = host;
 365   aconf->next = GlobalConfList;
 366   GlobalConfList = aconf;
 367   printf("Server added: %s\n", name);
 368   /* ccount++; -- XXX fixme --- A1kmm */
 369  }
 370  else
 371  {
 372   MyFree(name);
 373   MyFree(pass);
 374   MyFree(host);
 375   name = pass = host = NULL;
 376  }
 377 }';';
 378 connectitems: connectitem connectitems | connectitem;
 379 connectitem: connectname | connectpass | connectclass | connecthost
 380               | connectport;
 381 connectname: NAME '=' QSTRING ';'
 382 {
 383  MyFree(name);
 384  DupString(name, yylval.text);
 385 };
 386 connectpass: PASS '=' QSTRING ';'
 387 {
 388  MyFree(pass);
 389  DupString(pass, yylval.text);
 390 };
 391 connectclass: CLASS '=' QSTRING ';'
 392 {
 393  class = find_class(yylval.text);
 394 };
 395 connecthost: HOST '=' QSTRING ';'
 396 {
 397  MyFree(host);
 398  DupString(host, yylval.text);
 399 };
 400 connectport: PORT '=' NUMBER ';'
 401 {
 402  port = yylval.num;
 403 };
 404
 405 serverblock: SERVER
 406 {
 407  aconf = MyMalloc(sizeof(*aconf));
 408  memset(aconf, 0, sizeof(*aconf));
 409 } '{' serveritems '}'
 410 {
 411  if (aconf->status == 0)
 412  {
 413    MyFree(aconf->host);
 414    MyFree(aconf->name);
 415    MyFree(aconf);
 416    aconf = NULL;
 417  }
 418  else
 419  {
 420    aconf->next = GlobalConfList;
 421    GlobalConfList = aconf;
 422  }
 423 } ';';
 424 serveritems: serveritem serveritems | serveritem;
 425 serveritem: servername | servermask | serverhub | serverleaf |
 426              serveruworld;
 427 servername: NAME '=' QSTRING
 428 {
 429  MyFree(aconf->name);
 430  DupString(aconf->name, yylval.text);
 431 } ';' ;
 432 servermask: MASK '=' QSTRING
 433 {
 434  MyFree(aconf->host);
 435  DupString(aconf->host, yylval.text);
 436 } ';' ;
 437 /* XXX - perhaps we should do this the hybrid way in connect blocks
 438  * instead -A1kmm. */
 439 serverhub: HUB '=' YES ';'
 440 {
 441  aconf->status |= CONF_HUB;
 442  aconf->status &= ~CONF_LEAF;
 443 }
 444 | HUB '=' NO
 445 {
 446  aconf->status &= ~CONF_HUB;
 447 } ';';
 448 serverleaf: LEAF '=' YES ';'
 449 {
 450  if (!(aconf->status & CONF_HUB && aconf->status & CONF_UWORLD))
 451   aconf->status |= CONF_LEAF;
 452 }
 453 | LEAF '=' NO ';'
 454 {
 455  aconf->status &= ~CONF_LEAF;
 456 };
 457 serveruworld: UWORLD '=' YES ';'
 458 {
 459  aconf->status |= CONF_UWORLD;
 460  aconf->status &= ~CONF_LEAF;
 461 }
 462 | UWORLD '=' NO ';'
 463 {
 464   aconf->status &= ~CONF_UWORLD;
 465 };
 466
 467 operblock: OPER
 468 {
 469   aconf = MyMalloc(sizeof(*aconf));
 470   memset(aconf, 0, sizeof(*aconf));
 471   aconf->status = CONF_OPERATOR;
 472   set_initial_oper_privs(aconf, (FLAGS_OPER | FLAGS_LOCOP));
 473 } '{' operitems '}' ';'
 474 {
 475   if (aconf->name != NULL && aconf->passwd != NULL && aconf->host != NULL)
 476   {
 477     log_write(LS_CONFIG, L_ERROR, 0, "added an oper block for host %s", aconf->host);
 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 };