ircd/ircd_parser.y

   1 /* This code is in the public domain.
   2  * $Nightmare: nightmare/src/main/parser.y,v 1.2.2.1.2.1 2002/07/02 03:42:10 ejb Exp $
   3  * $Id: ircd_parser.y 871 2006-02-18 21:56:00Z nenolod $
   4  */
   5
   6 %{
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9
  10 #include <netinet/in.h>
  11
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <stdarg.h>
  15 #include <stdio.h>
  16 #define WE_ARE_MEMORY_C
  17 #include "stdinc.h"
  18 #include "setup.h"
  19 #include "common.h"
  20 #include "ircd_defs.h"
  21 #include "config.h"
  22 #include "client.h"
  23 #include "modules.h"
  24 #include "newconf.h"
  25
  26 #define YY_NO_UNPUT
  27
  28 int yyparse(void);
  29 void yyerror(const char *);
  30 int yylex(void);
  31
  32 static time_t conf_find_time(char*);
  33
  34 static struct {
  35         const char *    name;
  36         const char *    plural;
  37         time_t  val;
  38 } ircd_times[] = {
  39         {"second",     "seconds",    1},
  40         {"minute",     "minutes",    60},
  41         {"hour",       "hours",      60 * 60},
  42         {"day",        "days",       60 * 60 * 24},
  43         {"week",       "weeks",      60 * 60 * 24 * 7},
  44         {"fortnight",  "fortnights", 60 * 60 * 24 * 14},
  45         {"month",      "months",     60 * 60 * 24 * 7 * 4},
  46         {"year",       "years",      60 * 60 * 24 * 365},
  47         /* ok-- we now do sizes here too. they aren't times, but
  48            it's close enough */
  49         {"byte",        "bytes",        1},
  50         {"kb",          NULL,           1024},
  51         {"kbyte",       "kbytes",       1024},
  52         {"kilobyte",    "kilebytes",    1024},
  53         {"mb",          NULL,           1024 * 1024},
  54         {"mbyte",       "mbytes",       1024 * 1024},
  55         {"megabyte",    "megabytes",    1024 * 1024},
  56         {NULL, NULL, 0},
  57 };
  58
  59 time_t conf_find_time(char *name)
  60 {
  61   int i;
  62
  63   for (i = 0; ircd_times[i].name; i++)
  64     {
  65       if (strcasecmp(ircd_times[i].name, name) == 0 ||
  66           (ircd_times[i].plural && strcasecmp(ircd_times[i].plural, name) == 0))
  67         return ircd_times[i].val;
  68     }
  69
  70   return 0;
  71 }
  72
  73 static struct
  74 {
  75         const char *word;
  76         int yesno;
  77 } yesno[] = {
  78         {"yes",         1},
  79         {"no",          0},
  80         {"true",        1},
  81         {"false",       0},
  82         {"on",          1},
  83         {"off",         0},
  84         {NULL,          0}
  85 };
  86
  87 static int      conf_get_yesno_value(char *str)
  88 {
  89         int i;
  90
  91         for (i = 0; yesno[i].word; i++)
  92         {
  93                 if (strcasecmp(str, yesno[i].word) == 0)
  94                 {
  95                         return yesno[i].yesno;
  96                 }
  97         }
  98
  99         return -1;
 100 }
 101
 102 static void     free_cur_list(conf_parm_t* list)
 103 {
 104         if (list->type == CF_STRING || list->type == CF_QSTRING) {
 105                 rb_free(list->v.string);
 106         } else if (list->type == CF_FLIST) {
 107                 /* Even though CF_FLIST is a flag, comparing with == is valid
 108                  * because conf_parm_t.type must be either a type or one flag.
 109                  */
 110                 free_cur_list(list->v.list);
 111         }
 112
 113         if (list->next) {
 114                 free_cur_list(list->next);
 115         }
 116
 117         rb_free(list);
 118 }
 119
 120
 121 conf_parm_t *   cur_list = NULL;
 122
 123 static void     add_cur_list_cpt(conf_parm_t *new)
 124 {
 125         if (cur_list == NULL)
 126         {
 127                 cur_list = rb_malloc(sizeof(conf_parm_t));
 128                 cur_list->type = CF_FLIST;
 129                 cur_list->v.list = new;
 130         }
 131         else
 132         {
 133                 new->next = cur_list->v.list;
 134                 cur_list->v.list = new;
 135         }
 136 }
 137
 138 static void     add_cur_list(int type, char *str, int number)
 139 {
 140         conf_parm_t *new;
 141
 142         new = rb_malloc(sizeof(conf_parm_t));
 143         new->next = NULL;
 144         new->type = type;
 145
 146         switch(type)
 147         {
 148         case CF_INT:
 149         case CF_TIME:
 150         case CF_YESNO:
 151                 new->v.number = number;
 152                 break;
 153         case CF_STRING:
 154         case CF_QSTRING:
 155                 new->v.string = rb_strdup(str);
 156                 break;
 157         }
 158
 159         add_cur_list_cpt(new);
 160 }
 161
 162
 163 %}
 164
 165 %union {
 166         int             number;
 167         char            string[IRCD_BUFSIZE + 1];
 168         conf_parm_t *   conf_parm;
 169 }
 170
 171 %token LOADMODULE TWODOTS
 172
 173 %token <string> QSTRING STRING
 174 %token <number> NUMBER
 175
 176 %type <string> qstring string
 177 %type <number> number timespec
 178 %type <conf_parm> oneitem single itemlist
 179
 180 %start conf
 181
 182 %%
 183
 184 conf:
 185         | conf conf_item
 186         | error
 187         ;
 188
 189 conf_item: block
 190          | loadmodule
 191          ;
 192
 193 block: string
 194          {
 195            conf_start_block($1, NULL);
 196          }
 197        '{' block_items '}' ';'
 198          {
 199            if (conf_cur_block)
 200                    conf_end_block(conf_cur_block);
 201          }
 202      | string qstring
 203          {
 204            conf_start_block($1, $2);
 205          }
 206        '{' block_items '}' ';'
 207          {
 208            if (conf_cur_block)
 209                    conf_end_block(conf_cur_block);
 210          }
 211      ;
 212
 213 block_items: block_items block_item
 214            | block_item
 215            ;
 216
 217 block_item:     string '=' itemlist ';'
 218                 {
 219                         conf_call_set(conf_cur_block, $1, cur_list);
 220                         free_cur_list(cur_list);
 221                         cur_list = NULL;
 222                 }
 223                 ;
 224
 225 itemlist: itemlist ',' single
 226         | single
 227         ;
 228
 229 single: oneitem
 230         {
 231                 add_cur_list_cpt($1);
 232         }
 233         | oneitem TWODOTS oneitem
 234         {
 235                 /* "1 .. 5" meaning 1,2,3,4,5 - only valid for integers */
 236                 if ($1->type != CF_INT || $3->type != CF_INT)
 237                 {
 238                         conf_report_error("Both arguments in '..' notation must be integers.");
 239                         break;
 240                 }
 241                 else
 242                 {
 243                         int i;
 244
 245                         for (i = $1->v.number; i <= $3->v.number; i++)
 246                         {
 247                                 add_cur_list(CF_INT, 0, i);
 248                         }
 249                 }
 250         }
 251         ;
 252
 253 oneitem: qstring
 254             {
 255                 $$ = rb_malloc(sizeof(conf_parm_t));
 256                 $$->type = CF_QSTRING;
 257                 $$->v.string = rb_strdup($1);
 258             }
 259           | timespec
 260             {
 261                 $$ = rb_malloc(sizeof(conf_parm_t));
 262                 $$->type = CF_TIME;
 263                 $$->v.number = $1;
 264             }
 265           | number
 266             {
 267                 $$ = rb_malloc(sizeof(conf_parm_t));
 268                 $$->type = CF_INT;
 269                 $$->v.number = $1;
 270             }
 271           | string
 272             {
 273                 /* a 'string' could also be a yes/no value ..
 274                    so pass it as that, if so */
 275                 int val = conf_get_yesno_value($1);
 276
 277                 $$ = rb_malloc(sizeof(conf_parm_t));
 278
 279                 if (val != -1)
 280                 {
 281                         $$->type = CF_YESNO;
 282                         $$->v.number = val;
 283                 }
 284                 else
 285                 {
 286                         $$->type = CF_STRING;
 287                         $$->v.string = rb_strdup($1);
 288                 }
 289             }
 290           ;
 291
 292 loadmodule:
 293           LOADMODULE QSTRING
 294             {
 295               char *m_bn;
 296
 297               m_bn = rb_basename((char *) $2);
 298
 299               if (findmodule_byname(m_bn) == -1)
 300                   load_one_module($2, 0);
 301
 302               rb_free(m_bn);
 303             }
 304           ';'
 305           ;
 306
 307 qstring: QSTRING { strcpy($$, $1); } ;
 308 string: STRING { strcpy($$, $1); } ;
 309 number: NUMBER { $$ = $1; } ;
 310
 311 timespec:       number string
 312                 {
 313                         time_t t;
 314
 315                         if ((t = conf_find_time($2)) == 0)
 316                         {
 317                                 conf_report_error("Unrecognised time type/size '%s'", $2);
 318                                 t = 1;
 319                         }
 320
 321                         $$ = $1 * t;
 322                 }
 323                 | timespec timespec
 324                 {
 325                         $$ = $1 + $2;
 326                 }
 327                 | timespec number
 328                 {
 329                         $$ = $1 + $2;
 330                 }
 331                 ;