trunk/src/config-lexer.l

/*
 *  Copyright (c) 2002 Erik Fears
 *  Copyright (c) 2014-2015 ircd-hybrid development team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

%option case-insensitive
%option noyywrap
%option nounput
%option never-interactive

%{
#include <stdio.h>
#include <string.h>

#include "compat.h"
#include "config.h"
#include "config-parser.h"


void ccomment(void);

int linenum = 1;
char linebuf[512];

%}

string                 \"[^\"\n]*[\"\n]
comment                ("//"|"#").*
whitespace             [ \t\r]*

%%

"/*"                    { ccomment(); }

{comment}               ;

{string}                {
                           /* QSTRING from Hybrid7. Why re-invent the wheel? */

                           if(yytext[yyleng-2] == '\\')
                           {
                              yyless(yyleng-1); /* return last quote */
                              yymore();         /* append next string */
                           }
                           else
                           {
                              yylval.string = yytext+1;
                              if(yylval.string[yyleng-2] != '"') ; /* log error */
                              else
                              {
                                 int i,j;

                                 yylval.string[yyleng-2] = '\0'; /* remove close
                                                                  *  quote
                                                                  */

                                 for (j=i=0 ;yylval.string[i] != '\0'; i++,j++)
                                 {
                                    if (yylval.string[i] != '\\')
                                    {
                                       yylval.string[j] = yylval.string[i];
                                    }
                                    else
                                    {
                                        i++;
                                        yylval.string[j] = yylval.string[i];
                                    }
                                 }
                                 yylval.string[j] = '\0';
                                 return STRING;
                              }
                           }
                        }

AWAY                    { return AWAY;         }
BAN_UNKNOWN             { return BAN_UNKNOWN;  }
BLACKLIST               { return BLACKLIST;    }
CHANNEL                 { return CHANNEL;      }
CONNREGEX               { return CONNREGEX;    }
DNS_FDLIMIT             { return DNS_FDLIMIT;  }
DNSBL_FROM              { return DNSBL_FROM;   }
DNSBL_TO                { return DNSBL_TO;     }
EXEMPT                  { return EXEMPT;       }
FD                      { return FD;           }
INVITE                  { return INVITE;       }
IRC                     { return IRC;          }
KLINE                   { return KLINE;        }
KEY                     { return KEY;          }
MASK                    { return MASK;         }
MAX_READ                { return MAX_READ;     }
MODE                    { return MODE;         }
NAME                    { return NAME;         }
NEGCACHE                { return NEGCACHE;     }
NEGCACHE_REBUILD        { return NEGCACHE_REBUILD; }
NICK                    { return NICK;         }
NICKSERV                { return NICKSERV;     }
NOTICE                  { return NOTICE;       }
OPER                    { return OPER;         }
OPM                     { return OPM;          }
OPTIONS                 { return OPTIONS;      }
PASSWORD                { return PASSWORD;     }
PERFORM                 { return PERFORM;      }
PIDFILE                 { return PIDFILE;      }
PORT                    { return PORT;         }
PROTOCOL                { return PROTOCOL;     }
READTIMEOUT             { return READTIMEOUT;  }
REALNAME                { return REALNAME;     }
REPLY                   { return REPLY;        }
SCANLOG                 { return SCANLOG;      }
SCANNER                 { return SCANNER;      }
SENDMAIL                { return SENDMAIL;     }
SERVER                  { return SERVER;       }
TARGET_IP               { return TARGET_IP;    }
TARGET_PORT             { return TARGET_PORT;  }
TARGET_STRING           { return TARGET_STRING;}
TIMEOUT                 { return TIMEOUT;      }
TYPE                    { return TYPE;         }
USER                    { return USER;         }
USERNAME                { return USERNAME;     }
VHOST                   { return VHOST;        }

years                   { return YEARS; }
year                    { return YEARS; }
months                  { return MONTHS; }
month                   { return MONTHS; }
weeks                   { return WEEKS; }
week                    { return WEEKS; }
days                    { return DAYS; }
day                     { return DAYS; }
hours                   { return HOURS; }
hour                    { return HOURS; }
minutes                 { return MINUTES; }
minute                  { return MINUTES; }
seconds                 { return SECONDS; }
second                  { return SECONDS; }

bytes                   { return BYTES; }
byte                    { return BYTES; }
kilobytes               { return KBYTES; }
kilobyte                { return KBYTES; }
kbytes                  { return KBYTES; }
kbyte                   { return KBYTES; }
kb                      { return KBYTES; }
megabytes               { return MBYTES; }
megabyte                { return MBYTES; }
mbytes                  { return MBYTES; }
mbyte                   { return MBYTES; }
mb                      { return MBYTES; }

HTTP                    {
                          yylval.number = OPM_TYPE_HTTP;
                          return PROTOCOLTYPE;
                        }

HTTPPOST                {
                          yylval.number = OPM_TYPE_HTTPPOST;
                          return PROTOCOLTYPE;
                        }

SOCKS4                  {
                          yylval.number = OPM_TYPE_SOCKS4;
                          return PROTOCOLTYPE;
                        }

SOCKS5                  {
                          yylval.number = OPM_TYPE_SOCKS5;
                          return PROTOCOLTYPE;
                        }

WINGATE                 {
                          yylval.number = OPM_TYPE_WINGATE;
                          return PROTOCOLTYPE;
                        }

ROUTER                  {
                          yylval.number = OPM_TYPE_ROUTER;
                          return PROTOCOLTYPE;
                        }

DREAMBOX                {
                          yylval.number = OPM_TYPE_DREAMBOX;
                          return PROTOCOLTYPE;
                        }


[0-9]+                  {
                           yylval.number=atoi(yytext);
                           return NUMBER;
                        }


TRUE                     {
                           yylval.number=1;
                           return NUMBER;
                         }
YES                      {
                           yylval.number=1;
                           return NUMBER;
                         }
ON                       {
                           yylval.number=1;
                           return NUMBER;
                         }


FALSE                    {
                           yylval.number=0;
                           return NUMBER;
                         }

NO                       {
                           yylval.number=0;
                           return NUMBER;
                         }

OFF                      {
                           yylval.number=0;
                           return NUMBER;
                         }


\n.*                     {
                           strlcpy(linebuf, yytext + 1, sizeof(linebuf));
                           ++linenum;
                           yyless(1);
                         }

{whitespace}            /* ignore whitespace */;

.                       return yytext[0];

%%


/* C-comment ignoring routine -kre*/
void ccomment(void)
{
  int c;

  /* log(L_NOTICE, "got comment"); */
  while (1)
  {
     while ((c = input()) != '*' && c != EOF)
        if (c == '\n') ++linenum;
     if (c == '*')
     {
        while ((c = input()) == '*');
        if (c == '/') break;
     }
    if (c == EOF)
    {
       YY_FATAL_ERROR("EOF in comment");
       /* XXX hack alert this disables
        * the stupid unused function warning
        * gcc generates
        */
       if(1 == 0)
          yy_fatal_error("EOF in comment");
       break;
    }
  }
}

Revision:	5998
Committed:	Thu May 28 14:59:47 2015 UTC (11 years, 2 months ago) by michael
File size:	9346 byte(s)
Log Message:	- HOPM can now detect Dreamboxes with default root passwords. Patch by Gavin Hanover (EFnet)
#	User	Rev	Content
1	michael	5052	/*
2	michael	5351	* Copyright (c) 2002 Erik Fears
3			* Copyright (c) 2014-2015 ircd-hybrid development team
4	michael	5052	*
5	michael	5351	* This program is free software; you can redistribute it and/or modify
6			* it under the terms of the GNU General Public License as published by
7			* the Free Software Foundation; either version 2 of the License, or
8			* (at your option) any later version.
9	michael	5052	*
10	michael	5351	* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14	michael	5052	*
15	michael	5351	* You should have received a copy of the GNU General Public License
16			* along with this program; if not, write to the Free Software
17			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
18			* USA
19	michael	5052	*/
20
21			%option case-insensitive
22			%option noyywrap
23			%option nounput
24	michael	5687	%option never-interactive
25	michael	5052
26			%{
27			#include <stdio.h>
28			#include <string.h>
29	michael	5078
30			#include "compat.h"
31	michael	5052	#include "config.h"
32			#include "config-parser.h"
33
34
35			void ccomment(void);
36
37			int linenum = 1;
38			char linebuf[512];
39
40			%}
41
42			string \"[^\"\n]*[\"\n]
43	michael	5078	comment ("//"\|"#").*
44	michael	5052	whitespace [ \t\r]*
45
46			%%
47
48			"/*" { ccomment(); }
49
50	michael	5078	{comment} ;
51	michael	5052
52			{string} {
53			/* QSTRING from Hybrid7. Why re-invent the wheel? */
54
55			if(yytext[yyleng-2] == '\\')
56			{
57			yyless(yyleng-1); /* return last quote */
58			yymore(); /* append next string */
59			}
60			else
61			{
62			yylval.string = yytext+1;
63			if(yylval.string[yyleng-2] != '"') ; /* log error */
64			else
65			{
66			int i,j;
67
68			yylval.string[yyleng-2] = '\0'; /* remove close
69			* quote
70			*/
71
72			for (j=i=0 ;yylval.string[i] != '\0'; i++,j++)
73			{
74			if (yylval.string[i] != '\\')
75			{
76			yylval.string[j] = yylval.string[i];
77			}
78			else
79			{
80			i++;
81			yylval.string[j] = yylval.string[i];
82			}
83			}
84			yylval.string[j] = '\0';
85			return STRING;
86			}
87			}
88			}
89
90			AWAY { return AWAY; }
91			BAN_UNKNOWN { return BAN_UNKNOWN; }
92			BLACKLIST { return BLACKLIST; }
93			CHANNEL { return CHANNEL; }
94			CONNREGEX { return CONNREGEX; }
95			DNS_FDLIMIT { return DNS_FDLIMIT; }
96			DNSBL_FROM { return DNSBL_FROM; }
97			DNSBL_TO { return DNSBL_TO; }
98			EXEMPT { return EXEMPT; }
99			FD { return FD; }
100			INVITE { return INVITE; }
101			IRC { return IRC; }
102			KLINE { return KLINE; }
103			KEY { return KEY; }
104			MASK { return MASK; }
105			MAX_READ { return MAX_READ; }
106			MODE { return MODE; }
107			NAME { return NAME; }
108			NEGCACHE { return NEGCACHE; }
109	michael	5332	NEGCACHE_REBUILD { return NEGCACHE_REBUILD; }
110	michael	5052	NICK { return NICK; }
111			NICKSERV { return NICKSERV; }
112	michael	5405	NOTICE { return NOTICE; }
113	michael	5052	OPER { return OPER; }
114			OPM { return OPM; }
115			OPTIONS { return OPTIONS; }
116			PASSWORD { return PASSWORD; }
117			PERFORM { return PERFORM; }
118			PIDFILE { return PIDFILE; }
119			PORT { return PORT; }
120			PROTOCOL { return PROTOCOL; }
121	michael	5198	READTIMEOUT { return READTIMEOUT; }
122	michael	5052	REALNAME { return REALNAME; }
123			REPLY { return REPLY; }
124			SCANLOG { return SCANLOG; }
125			SCANNER { return SCANNER; }
126			SENDMAIL { return SENDMAIL; }
127			SERVER { return SERVER; }
128			TARGET_IP { return TARGET_IP; }
129			TARGET_PORT { return TARGET_PORT; }
130			TARGET_STRING { return TARGET_STRING;}
131			TIMEOUT { return TIMEOUT; }
132			TYPE { return TYPE; }
133			USER { return USER; }
134			USERNAME { return USERNAME; }
135			VHOST { return VHOST; }
136
137	michael	5080	years { return YEARS; }
138			year { return YEARS; }
139			months { return MONTHS; }
140			month { return MONTHS; }
141			weeks { return WEEKS; }
142			week { return WEEKS; }
143			days { return DAYS; }
144			day { return DAYS; }
145			hours { return HOURS; }
146			hour { return HOURS; }
147			minutes { return MINUTES; }
148			minute { return MINUTES; }
149			seconds { return SECONDS; }
150			second { return SECONDS; }
151	michael	5052
152	michael	5080	bytes { return BYTES; }
153			byte { return BYTES; }
154			kilobytes { return KBYTES; }
155			kilobyte { return KBYTES; }
156			kbytes { return KBYTES; }
157			kbyte { return KBYTES; }
158			kb { return KBYTES; }
159			megabytes { return MBYTES; }
160			megabyte { return MBYTES; }
161			mbytes { return MBYTES; }
162			mbyte { return MBYTES; }
163			mb { return MBYTES; }
164
165	michael	5052	HTTP {
166			yylval.number = OPM_TYPE_HTTP;
167			return PROTOCOLTYPE;
168			}
169
170			HTTPPOST {
171			yylval.number = OPM_TYPE_HTTPPOST;
172			return PROTOCOLTYPE;
173			}
174
175			SOCKS4 {
176			yylval.number = OPM_TYPE_SOCKS4;
177			return PROTOCOLTYPE;
178			}
179
180			SOCKS5 {
181			yylval.number = OPM_TYPE_SOCKS5;
182			return PROTOCOLTYPE;
183			}
184
185			WINGATE {
186			yylval.number = OPM_TYPE_WINGATE;
187			return PROTOCOLTYPE;
188			}
189
190			ROUTER {
191			yylval.number = OPM_TYPE_ROUTER;
192			return PROTOCOLTYPE;
193			}
194
195	michael	5998	DREAMBOX {
196			yylval.number = OPM_TYPE_DREAMBOX;
197			return PROTOCOLTYPE;
198			}
199	michael	5052
200	michael	5998
201
202	michael	5052	[0-9]+ {
203	michael	5876	yylval.number=atoi(yytext);
204	michael	5052	return NUMBER;
205			}
206
207
208
209
210
211			TRUE {
212			yylval.number=1;
213			return NUMBER;
214			}
215			YES {
216			yylval.number=1;
217			return NUMBER;
218			}
219			ON {
220			yylval.number=1;
221			return NUMBER;
222			}
223
224
225
226			FALSE {
227			yylval.number=0;
228			return NUMBER;
229			}
230
231			NO {
232			yylval.number=0;
233			return NUMBER;
234			}
235
236			OFF {
237			yylval.number=0;
238			return NUMBER;
239			}
240
241
242	michael	5078	\n.* {
243			strlcpy(linebuf, yytext + 1, sizeof(linebuf));
244			++linenum;
245			yyless(1);
246			}
247	michael	5052
248			{whitespace} /* ignore whitespace */;
249
250	michael	5876	. return yytext[0];
251	michael	5052
252			%%
253
254
255			/* C-comment ignoring routine -kre*/
256			void ccomment(void)
257			{
258			int c;
259
260			/* log(L_NOTICE, "got comment"); */
261			while (1)
262			{
263			while ((c = input()) != '*' && c != EOF)
264			if (c == '\n') ++linenum;
265			if (c == '*')
266			{
267			while ((c = input()) == '*');
268			if (c == '/') break;
269			}
270			if (c == EOF)
271			{
272			YY_FATAL_ERROR("EOF in comment");
273			/* XXX hack alert this disables
274			* the stupid unused function warning
275			* gcc generates
276			*/
277			if(1 == 0)
278			yy_fatal_error("EOF in comment");
279			break;
280			}
281			}
282			}
283