ircd/ircd_lexer.l

   1 /*
   2  * ircd_lexer.l: A lexical scanner 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 <unistd.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "config.h"
  29 #include "fileio.h"
  30 #include "ircd.h"
  31 #include "ircd_alloc.h"
  32 #include "ircd_string.h"
  33 #include "s_debug.h"
  34 #include "y.tab.h"
  35
  36 extern int lineno;
  37
  38 static struct lexer_token {
  39   const char *string;
  40   int value;
  41 } tokens[] = {
  42 #define TOKEN(NAME) { #NAME, NAME }
  43   TOKEN(ADMIN),
  44   TOKEN(GENERAL),
  45   TOKEN(LOCATION),
  46   TOKEN(CONTACT),
  47   TOKEN(CLASS),
  48   TOKEN(PINGFREQ),
  49   TOKEN(CONNECT),
  50   TOKEN(CONNECTFREQ),
  51   TOKEN(MAXLINKS),
  52   TOKEN(MAXHOPS),
  53   TOKEN(SENDQ),
  54   TOKEN(NAME),
  55   TOKEN(HOST),
  56   TOKEN(IP),
  57   TOKEN(USERNAME),
  58   TOKEN(PASS),
  59   TOKEN(SECONDS),
  60   TOKEN(MINUTES),
  61   TOKEN(HOURS),
  62   TOKEN(DAYS),
  63   TOKEN(WEEKS),
  64   TOKEN(MONTHS),
  65   TOKEN(YEARS),
  66   TOKEN(DECADES),
  67   TOKEN(BYTES),
  68   TOKEN(KBYTES),
  69   TOKEN(MBYTES),
  70   TOKEN(GBYTES),
  71   TOKEN(TBYTES),
  72   TOKEN(PORT),
  73   TOKEN(SERVER),
  74   TOKEN(YES),
  75   TOKEN(NO),
  76   TOKEN(HUB),
  77   TOKEN(LEAF),
  78   TOKEN(UWORLD),
  79   TOKEN(OPER),
  80   TOKEN(LOCAL),
  81   TOKEN(VHOST),
  82   TOKEN(MASK),
  83   TOKEN(HIDDEN),
  84   TOKEN(MOTD),
  85   TOKEN(NUMERIC),
  86   TOKEN(NICK),
  87   TOKEN(JUPE),
  88   TOKEN(DESCRIPTION),
  89   TOKEN(CLIENT),
  90   TOKEN(REAL),
  91   TOKEN(REASON),
  92   TOKEN(RULE),
  93   TOKEN(ALL),
  94   TOKEN(CRULE),
  95   TOKEN(KILL),
  96   TOKEN(QUARANTINE),
  97   TOKEN(IAUTH),
  98   TOKEN(TIMEOUT),
  99   TOKEN(FEATURES),
 100   TOKEN(CHANNEL),
 101   TOKEN(PSEUDO),
 102   TOKEN(PREPEND),
 103   TOKEN(USERMODE),
 104   TOKEN(FAST),
 105   TOKEN(AUTOCONNECT),
 106   TOKEN(PROGRAM),
 107   TOKEN(DNS),
 108 #undef TOKEN
 109   { "administrator", ADMIN },
 110   { "apass_opmode", TPRIV_APASS_OPMODE },
 111   { "auto", AUTOCONNECT },
 112   { "b", BYTES },
 113   { "badchan", TPRIV_BADCHAN },
 114   { "chan_limit", TPRIV_CHAN_LIMIT },
 115   { "deop_lchan", TPRIV_DEOP_LCHAN },
 116   { "die", TPRIV_DIE },
 117   { "display", TPRIV_DISPLAY },
 118   { "file", TFILE },
 119   { "force_local_opmode", TPRIV_FORCE_LOCAL_OPMODE },
 120   { "force_opmode", TPRIV_FORCE_OPMODE },
 121   { "gb", GBYTES },
 122   { "gigabytes", GBYTES },
 123   { "gline", TPRIV_GLINE },
 124   { "ipv4", TOK_IPV4 },
 125   { "ipv6", TOK_IPV6 },
 126   { "kb", KBYTES },
 127   { "kilobytes", KBYTES },
 128   { "list_chan", TPRIV_LIST_CHAN },
 129   { "local_badchan", TPRIV_LOCAL_BADCHAN },
 130   { "local_gline", TPRIV_LOCAL_GLINE },
 131   { "local_jupe", TPRIV_LOCAL_JUPE },
 132   { "local_kill", TPRIV_LOCAL_KILL },
 133   { "local_opmode", TPRIV_LOCAL_OPMODE },
 134   { "mb", MBYTES },
 135   { "megabytes", MBYTES },
 136   { "mode_lchan", TPRIV_MODE_LCHAN },
 137   { "operator", OPER },
 138   { "opmode", TPRIV_OPMODE },
 139   { "password", PASS },
 140   { "propagate", TPRIV_PROPAGATE },
 141   { "realname", REAL },
 142   { "rehash", TPRIV_REHASH },
 143   { "restart", TPRIV_RESTART },
 144   { "see_chan", TPRIV_SEE_CHAN },
 145   { "see_opers", TPRIV_SEE_OPERS },
 146   { "set", TPRIV_SET },
 147   { "show_all_invis", TPRIV_SHOW_ALL_INVIS },
 148   { "show_invis", TPRIV_SHOW_INVIS },
 149   { "tb", TBYTES },
 150   { "terabytes", TBYTES },
 151   { "unlimit_query", TPRIV_UNLIMIT_QUERY },
 152   { "walk_lchan", TPRIV_WALK_LCHAN },
 153   { "wide_gline", TPRIV_WIDE_GLINE },
 154   { "whox", TPRIV_WHOX },
 155   { NULL, 0 }
 156 };
 157 static int ntokens;
 158
 159 static int
 160 token_compare(const void *pa, const void *pb)
 161 {
 162   const struct lexer_token *ta = pa;
 163   const struct lexer_token *tb = pb;
 164   unsigned int ii = 0;
 165   int res;
 166   while (ta->string[ii] && (ToLower(ta->string[ii]) == ToLower(tb->string[ii])))
 167     ii++;
 168   res = ToLower(tb->string[ii]) - ToLower(ta->string[ii]);
 169   return res;
 170 }
 171
 172 static void
 173 init_ntokens(void)
 174 {
 175   for (ntokens = 0; tokens[ntokens].string; ++ntokens) ;
 176   qsort(tokens, ntokens, sizeof(tokens[0]), token_compare);
 177 }
 178
 179 static int
 180 find_token(char *token)
 181 {
 182   struct lexer_token *tok;
 183   if (!ntokens)
 184     init_ntokens();
 185   tok = bsearch(&token, tokens, ntokens, sizeof(tokens[0]), token_compare);
 186   return tok ? tok->value : 0;
 187 }
 188
 189 static FBFILE *lexer_input;
 190
 191 #undef YY_INPUT
 192 #define YY_INPUT(buf, res, size) res = (fbgets(buf, size, lexer_input) ? strlen(buf) : 0)
 193
 194 int
 195 init_lexer(void)
 196 {
 197   lexer_input = fbopen(configfile, "r");
 198   if (lexer_input == NULL)
 199   {
 200 #ifdef YY_FATAL_ERROR
 201     YY_FATAL_ERROR("Could not open the configuration file.");
 202 #else
 203     fprintf(stderr, "Could not open the configuration file.");
 204 #endif
 205     return 0;
 206   }
 207 #ifdef YY_NEW_FILE
 208   YY_NEW_FILE;
 209 #endif
 210   lineno = 1;
 211   return 1;
 212 }
 213
 214 void deinit_lexer(void)
 215 {
 216   if (lexer_input != NULL)
 217   {
 218     fbclose(lexer_input);
 219     lexer_input = NULL;
 220   }
 221 }
 222
 223 int
 224 yywrap(void)
 225 {
 226   return 1;
 227 }
 228
 229 %}
 230
 231 WHITE [ \t\r]+
 232 SHCOMMENT #[^\n]*
 233 NUMBER [0-9]+
 234 QSTRING \"[^"\n]+[\"\n]
 235 %%
 236
 237 {QSTRING} {yytext[yyleng-1] = 0; DupString(yylval.text, yytext+1); return QSTRING;}
 238 {NUMBER} {yylval.num = strtoul(yytext, NULL, 10); return NUMBER;}
 239 {WHITE} ;
 240 {SHCOMMENT} ;
 241
 242 [a-zA-Z_][a-zA-Z_0-9]* { int res = find_token(yytext); if (res) return res; else REJECT; }
 243 \n lineno++;
 244 . return yytext[0];