/[svn]/ircd-hybrid-8/src/ircd_lexer.l
ViewVC logotype

Contents of /ircd-hybrid-8/src/ircd_lexer.l

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1216 - (show annotations)
Tue Sep 13 18:22:31 2011 UTC (8 years, 5 months ago) by michael
File size: 16776 byte(s)
- add 'globops' to operflags

1 /*
2 * ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 * ircd_lexer.l: Scans the ircd configuration file for tokens.
4 *
5 * Copyright (C) 2002 by the past and present ircd coders, and others.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 * USA
21 *
22 * $Id$
23 */
24
25 %option case-insensitive
26 %option noyywrap
27 %option nounput
28 %option never-interactive
29
30 %{
31 #include "stdinc.h"
32 #include "irc_string.h"
33 #include "common.h"
34 #include "s_conf.h"
35 #include "memory.h"
36 #include "hostmask.h"
37 #include "s_log.h"
38
39 #include "ircd_parser.h"
40
41 #undef YY_INPUT
42 #define YY_FATAL_ERROR(msg) conf_yy_fatal_error(msg)
43 #define YY_INPUT(buf,result,max_size) \
44 if (!(result = conf_fbgets(buf, max_size, conf_parser_ctx.conf_file))) \
45 YY_FATAL_ERROR("input in flex scanner failed");
46 #define MAX_INCLUDE_DEPTH 10
47
48
49 unsigned int lineno = 1;
50 char linebuf[IRCD_BUFSIZE];
51 char conffilebuf[IRCD_BUFSIZE];
52
53 static int include_stack_ptr = 0;
54 static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
55 static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
56 static FBFILE *inc_fbfile_in[MAX_INCLUDE_DEPTH];
57 static char conffile_stack[MAX_INCLUDE_DEPTH][IRCD_BUFSIZE];
58 static void ccomment(void);
59 static void cinclude(void);
60 static int ieof(void);
61 %}
62
63 WS [[:blank:]]*
64 DIGIT [[:digit:]]+
65 COMMENT ("//"|"#").*
66 qstring \"[^\"\n]*[\"\n]
67 include \.include{WS}(\<.*\>|\".*\")
68
69 %%
70 {include} { cinclude(); }
71 "/*" { ccomment(); }
72
73 \n.* { strcpy(linebuf, yytext+1); ++lineno; yyless(1); }
74
75 {WS} ;
76 {COMMENT} ;
77
78 {DIGIT} { yylval.number = atoi(yytext); return NUMBER; }
79
80 {qstring} { if (yytext[yyleng-2] == '\\')
81 {
82 yyless(yyleng-1); /* return last quote */
83 yymore(); /* append next string */
84 }
85 else
86 {
87 yylval.string = yytext+1;
88 if(yylval.string[yyleng-2] != '"')
89 ilog(L_ERROR, "Unterminated character string");
90 else
91 {
92 int i,j;
93
94 yylval.string[yyleng-2] = '\0'; /* remove close
95 * quote
96 */
97
98 for (j=i=0 ;yylval.string[i] != '\0'; i++,j++)
99 {
100 if (yylval.string[i] != '\\')
101 {
102 yylval.string[j] = yylval.string[i];
103 }
104 else
105 {
106 i++;
107 if (yylval.string[i] == '\0') /* XXX
108 * should not
109 * happen
110 */
111 {
112 ilog(L_ERROR,
113 "Unterminated character string");
114 break;
115 }
116 yylval.string[j] = yylval.string[i];
117 }
118 }
119 yylval.string[j] = '\0';
120 return QSTRING;
121 }
122 }
123 }
124
125 ~ { return NOT; }
126 accept_password { return ACCEPT_PASSWORD; }
127 action { return ACTION; }
128 admin { return ADMIN; }
129 administrator { return ADMIN; }
130 aftype { return AFTYPE; }
131 all { return T_ALL; }
132 allow { return T_ALLOW; }
133 auth { return IRCD_AUTH; }
134 autoconn { return AUTOCONN; }
135 block { return T_BLOCK; }
136 burst_away { return BURST_AWAY; }
137 burst_topicwho { return BURST_TOPICWHO; }
138 can_flood { return CAN_FLOOD; }
139 caller_id_wait { return CALLER_ID_WAIT; }
140 opers_bypass_callerid { return OPERS_BYPASS_CALLERID; }
141 channel { return CHANNEL; }
142 cidr_bitlen_ipv4 { return CIDR_BITLEN_IPV4; }
143 cidr_bitlen_ipv6 { return CIDR_BITLEN_IPV6; }
144 cipher_preference { return CIPHER_PREFERENCE; }
145 class { return CLASS; }
146 client_flood { return T_CLIENT_FLOOD; }
147 cluster { return T_CLUSTER; }
148 compressed { return COMPRESSED; }
149 compression_level { return COMPRESSION_LEVEL; }
150 connect { return CONNECT; }
151 connectfreq { return CONNECTFREQ; }
152 cryptlink { return CRYPTLINK; }
153 default_cipher_preference { return DEFAULT_CIPHER_PREFERENCE; }
154 default_floodcount { return DEFAULT_FLOODCOUNT; }
155 default_split_server_count { return DEFAULT_SPLIT_SERVER_COUNT; }
156 default_split_user_count { return DEFAULT_SPLIT_USER_COUNT; }
157 deny { return DENY; }
158 description { return DESCRIPTION; }
159 die { return DIE; }
160 disable_auth { return DISABLE_AUTH; }
161 disable_fake_channels { return DISABLE_FAKE_CHANNELS; }
162 disable_hidden { return DISABLE_HIDDEN; }
163 disable_local_channels { return DISABLE_LOCAL_CHANNELS; }
164 disable_remote_commands { return DISABLE_REMOTE_COMMANDS; }
165 dots_in_ident { return DOTS_IN_IDENT; }
166 duration { return DURATION; }
167 egdpool_path { return EGDPOOL_PATH; }
168 email { return EMAIL; }
169 enable { return ENABLE; }
170 encrypted { return ENCRYPTED; }
171 exceed_limit { return EXCEED_LIMIT; }
172 exempt { return EXEMPT; }
173 flags { return IRCD_FLAGS; }
174 flatten_links { return FLATTEN_LINKS; }
175 fglinelog { return FGLINELOG; }
176 fname_glinelog { return FGLINELOG; }
177 fkilllog { return FKILLLOG; }
178 fioerrlog { return FIOERRLOG; }
179 fname_ioerrlog { return FIOERRLOG; }
180 fname_killlog { return FKILLLOG; }
181 fklinelog { return FKLINELOG; }
182 fname_klinelog { return FKLINELOG; }
183 ffailed_operlog { return FFAILED_OPERLOG; }
184 fname_operlog { return FOPERLOG; }
185 foperlog { return FOPERLOG; }
186 fname_userlog { return FUSERLOG; }
187 fuserlog { return FUSERLOG; }
188 gecos { return GECOS; }
189 general { return GENERAL; }
190 gline { return GLINE; }
191 glines { return GLINES; }
192 gline_exempt { return GLINE_EXEMPT; }
193 gline_min_cidr { return GLINE_MIN_CIDR; }
194 gline_min_cidr6 { return GLINE_MIN_CIDR6; }
195 globops { return T_GLOBOPS; }
196 global_kill { return GLOBAL_KILL; }
197 have_ident { return NEED_IDENT; }
198 need_ident { return NEED_IDENT; }
199 havent_read_conf { return HAVENT_READ_CONF; }
200 hidden { return HIDDEN; }
201 hidden_admin { return HIDDEN_ADMIN; }
202 hidden_name { return HIDDEN_NAME; }
203 hidden_oper { return HIDDEN_OPER; }
204 hide_server_ips { return HIDE_SERVER_IPS; }
205 hide_servers { return HIDE_SERVERS; }
206 hide_spoof_ips { return HIDE_SPOOF_IPS; }
207 host { return HOST; }
208 hub { return HUB; }
209 hub_mask { return HUB_MASK; }
210 ignore_bogus_ts { return IGNORE_BOGUS_TS; }
211 invisible_on_connect { return INVISIBLE_ON_CONNECT; }
212 ip { return IP; }
213 ipv4 { return T_IPV4; }
214 ipv6 { return T_IPV6; }
215 join_flood_count { return JOIN_FLOOD_COUNT; }
216 join_flood_time { return JOIN_FLOOD_TIME; }
217 kill { return KILL; }
218 kill_chase_time_limit { return KILL_CHASE_TIME_LIMIT; }
219 kline { return KLINE; }
220 kline_exempt { return KLINE_EXEMPT; }
221 l_crit { return T_L_CRIT; }
222 l_debug { return T_L_DEBUG; }
223 l_error { return T_L_ERROR; }
224 l_info { return T_L_INFO; }
225 l_notice { return T_L_NOTICE; }
226 l_trace { return T_L_TRACE; }
227 l_warn { return T_L_WARN; }
228 leaf_mask { return LEAF_MASK; }
229 listen { return LISTEN; }
230 log_level { return LOG_LEVEL; }
231 log { return LOGGING; }
232 logging { return LOGGING; }
233 logpath { return T_LOGPATH; }
234 masked { return TMASKED; }
235 max_clients { return T_MAX_CLIENTS; }
236 max_ident { return MAX_IDENT; }
237 max_local { return MAX_LOCAL; }
238 max_global { return MAX_GLOBAL; }
239 max_number { return MAX_NUMBER; }
240 max_watch { return MAX_WATCH; }
241 message_locale { return MESSAGE_LOCALE; }
242 min_nonwildcard { return MIN_NONWILDCARD; }
243 min_nonwildcard_simple { return MIN_NONWILDCARD_SIMPLE; }
244 name { return NAME; }
245 need_password { return NEED_PASSWORD; }
246 network_desc { return NETWORK_DESC; }
247 network_name { return NETWORK_NAME; }
248 nick { return NICK; }
249 nick_changes { return NICK_CHANGES; }
250 no { yylval.number = NO; return TBOOL; }
251 no_create_on_split { return NO_CREATE_ON_SPLIT; }
252 no_join_on_split { return NO_JOIN_ON_SPLIT; }
253 no_oper_flood { return NO_OPER_FLOOD; }
254 no_tilde { return NO_TILDE; }
255 number_per_cidr { return NUMBER_PER_CIDR; }
256 number_per_ip { return NUMBER_PER_IP; }
257 oper { return OPERATOR; }
258 oper_log { return OPER_LOG; }
259 oper_pass_resv { return OPER_PASS_RESV; }
260 operator { return OPERATOR; }
261 passwd { return PASSWORD; }
262 password { return PASSWORD; }
263 ping_cookie { return PING_COOKIE; }
264 ping_time { return PING_TIME; }
265 ping_warning { return PING_WARNING; }
266 port { return PORT; }
267 quarantine { return RESV; }
268 quiet_on_ban { return QUIET_ON_BAN; }
269 reason { return REASON; }
270 redirport { return REDIRPORT; }
271 redirserv { return REDIRSERV; }
272 regex { return REGEX_T; }
273 rehash { return REHASH; }
274 reject { return T_REJECT; }
275 reject_hold_time { return TREJECT_HOLD_TIME; }
276 remote { return REMOTE; }
277 remoteban { return REMOTEBAN; }
278 restrict_channels { return RESTRICT_CHANNELS; }
279 resv { return RESV; }
280 resv_exempt { return RESV_EXEMPT; }
281 rsa_private_key_file { return RSA_PRIVATE_KEY_FILE; }
282 rsa_public_key_file { return RSA_PUBLIC_KEY_FILE; }
283 ssl { return T_SSL; }
284 ssl_certificate_file { return SSL_CERTIFICATE_FILE; }
285 ssl_server_protocol { return T_SSL_CONNECTION_METHOD; }
286 sslv3 { return T_SSLV3; }
287 tlsv1 { return T_TLSV1; }
288 send_password { return SEND_PASSWORD; }
289 sendq { return SENDQ; }
290 server { return T_SERVER; }
291 serverhide { return SERVERHIDE; }
292 serverinfo { return SERVERINFO; }
293 service { return T_SERVICE; }
294 services_name { return T_SERVICES_NAME; }
295 servlink_path { return SERVLINK_PATH; }
296 shared { return T_SHARED; }
297 short_motd { return SHORT_MOTD; }
298 sid { return IRCD_SID; }
299 silent { return SILENT; }
300 spoof { return SPOOF; }
301 spoof_notice { return SPOOF_NOTICE; }
302 tkline_expire_notices { return TKLINE_EXPIRE_NOTICES; }
303 type { return TYPE; }
304 true_no_oper_flood { return TRUE_NO_OPER_FLOOD; }
305 umodes { return T_UMODES; }
306 unkline { return UNKLINE; }
307 use_egd { return USE_EGD; }
308 use_except { return USE_EXCEPT; }
309 use_invex { return USE_INVEX; }
310 use_knock { return USE_KNOCK; }
311 use_logging { return USE_LOGGING; }
312 use_whois_actually { return USE_WHOIS_ACTUALLY; }
313 throttle_time { return THROTTLE_TIME; }
314 user { return USER; }
315 tkline { return TKLINE; }
316 txline { return TXLINE; }
317 tresv { return TRESV; }
318 vhost { return VHOST; }
319 vhost6 { return VHOST6; }
320 warn { return WARN; }
321 xline { return XLINE; }
322 yes { yylval.number = YES; return TBOOL; }
323
324 failed_oper_notice { return FAILED_OPER_NOTICE; }
325 max_accept { return MAX_ACCEPT; }
326 max_nick_changes { return MAX_NICK_CHANGES; }
327 max_chans_per_user { return MAX_CHANS_PER_USER; }
328 max_nick_time { return MAX_NICK_TIME; }
329 anti_nick_flood { return ANTI_NICK_FLOOD; }
330 anti_spam_exit_message_time { return ANTI_SPAM_EXIT_MESSAGE_TIME; }
331 ts_max_delta { return TS_MAX_DELTA; }
332 ts_warn_delta { return TS_WARN_DELTA; }
333 links_delay { return LINKS_DELAY; }
334 kline_reason { return KLINE_REASON; }
335 kline_with_reason { return KLINE_WITH_REASON; }
336 warn_no_nline { return WARN_NO_NLINE; }
337
338 stats_e_disabled { return STATS_E_DISABLED; }
339 stats_o_oper_only { return STATS_O_OPER_ONLY; }
340 stats_k_oper_only { return STATS_K_OPER_ONLY; }
341 stats_i_oper_only { return STATS_I_OPER_ONLY; }
342 stats_P_oper_only { return STATS_P_OPER_ONLY; }
343 pace_wait { return PACE_WAIT; }
344 pace_wait_simple { return PACE_WAIT_SIMPLE; }
345 knock_delay { return KNOCK_DELAY; }
346 knock_delay_channel { return KNOCK_DELAY_CHANNEL; }
347 max_bans { return MAX_BANS; }
348 modules { return MODULES; }
349 module { return MODULE; }
350 path { return PATH; }
351 max_targets { return MAX_TARGETS; }
352
353 unxline { return T_UNXLINE; }
354 unresv { return T_UNRESV; }
355
356 oper_only_umodes { return OPER_ONLY_UMODES; }
357 oper_umodes { return OPER_UMODES; }
358 bots { return T_BOTS; }
359 cconn { return T_CCONN; }
360 cconn_full { return T_CCONN_FULL; }
361 deaf { return T_DEAF; }
362 debug { return T_DEBUG; }
363 full { return T_FULL; }
364 skill { return T_SKILL; }
365 nchange { return T_NCHANGE; }
366 rej { return T_REJ; }
367 unauth { return T_UNAUTH; }
368 spy { return T_SPY; }
369 external { return T_EXTERNAL; }
370 operwall { return T_OPERWALL; }
371 servnotice { return T_SERVNOTICE; }
372 invisible { return T_INVISIBLE; }
373 wallop { return T_WALLOP; }
374 callerid { return T_CALLERID; }
375 softcallerid { return T_SOFTCALLERID; }
376 drone { return T_DRONE; }
377 locops { return T_LOCOPS; }
378 topicburst { return TOPICBURST; }
379
380 weeks { return WEEKS; }
381 week { return WEEKS; }
382 days { return DAYS; }
383 day { return DAYS; }
384 hours { return HOURS; }
385 hour { return HOURS; }
386 minutes { return MINUTES; }
387 minute { return MINUTES; }
388 seconds { return SECONDS; }
389 second { return SECONDS; }
390
391 bytes { return BYTES; }
392 byte { return BYTES; }
393 kilobytes { return KBYTES; }
394 kilobyte { return KBYTES; }
395 kbytes { return KBYTES; }
396 kbyte { return KBYTES; }
397 kb { return KBYTES; }
398 megabytes { return MBYTES; }
399 megabyte { return MBYTES; }
400 mbytes { return MBYTES; }
401 mbyte { return MBYTES; }
402 mb { return MBYTES; }
403 gigabytes { return GBYTES; }
404 gigabyte { return GBYTES; }
405 gbytes { return GBYTES; }
406 gbyte { return GBYTES; }
407 gb { return GBYTES; }
408 terabytes { return TBYTES; }
409 terabyte { return TBYTES; }
410 tbytes { return TBYTES; }
411 tbyte { return TBYTES; }
412 tb { return TBYTES; }
413 \.\. { return TWODOTS; }
414
415 . { return yytext[0]; }
416 <<EOF>> { if (ieof()) yyterminate(); }
417
418 %%
419
420 /* C-comment ignoring routine -kre*/
421 static void
422 ccomment(void)
423 {
424 int c = 0;
425
426 /* log(L_NOTICE, "got comment"); */
427 while (1)
428 {
429 while ((c = input()) != '*' && c != EOF)
430 if (c == '\n')
431 ++lineno;
432
433 if (c == '*')
434 {
435 while ((c = input()) == '*')
436 /* Nothing */ ;
437 if (c == '/')
438 break;
439 else if (c == '\n')
440 ++lineno;
441 }
442
443 if (c == EOF)
444 {
445 YY_FATAL_ERROR("EOF in comment");
446 /* XXX hack alert this disables
447 * the stupid unused function warning
448 * gcc generates
449 */
450 if (1 == 0)
451 yy_fatal_error("EOF in comment");
452 break;
453 }
454 }
455 }
456
457 /* C-style .includes. This function will properly swap input conf buffers,
458 * and lineno -kre */
459 static void
460 cinclude(void)
461 {
462 char *p = NULL;
463
464 if ((p = strchr(yytext, '<')) == NULL)
465 *strchr(p = strchr(yytext, '"') + 1, '"') = '\0';
466 else
467 *strchr(++p, '>') = '\0';
468
469 /* log(L_NOTICE, "got include %s!", c); */
470
471 /* do stacking and co. */
472 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
473 ilog(L_ERROR, "Includes nested too deep in %s", p);
474 else
475 {
476 FBFILE *tmp_fbfile_in = NULL;
477 char filenamebuf[IRCD_BUFSIZE];
478
479 if (*p == '/') /* if it is an absolute path */
480 snprintf(filenamebuf, sizeof(filenamebuf), "%s", p);
481 else
482 snprintf(filenamebuf, sizeof(filenamebuf), "%s/%s", ETCPATH, p);
483
484 tmp_fbfile_in = fbopen(filenamebuf, "r");
485
486 if (tmp_fbfile_in == NULL)
487 {
488 ilog(L_ERROR, "Unable to read configuration file '%s': %s",
489 filenamebuf, strerror(errno));
490 return;
491 }
492
493 lineno_stack[include_stack_ptr] = lineno;
494 lineno = 1;
495 inc_fbfile_in[include_stack_ptr] = conf_parser_ctx.conf_file;
496 strlcpy(conffile_stack[include_stack_ptr], conffilebuf, IRCD_BUFSIZE);
497 include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
498 conf_parser_ctx.conf_file = tmp_fbfile_in;
499 snprintf(conffilebuf, sizeof(conffilebuf), "%s", filenamebuf);
500 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
501 }
502 }
503
504 /* This is function that will be called on EOF in conf file. It will
505 * apropriately close conf if it not main conf and swap input buffers -kre
506 * */
507 static int
508 ieof(void)
509 {
510 /* log(L_NOTICE, "return from include stack!"); */
511 if (include_stack_ptr)
512 fbclose(conf_parser_ctx.conf_file);
513 if (--include_stack_ptr < 0)
514 {
515 /* log(L_NOTICE, "terminating lexer"); */
516 /* We will now exit the lexer - restore init values if we get /rehash
517 * later and reenter lexer -kre */
518 include_stack_ptr = 0;
519 lineno = 1;
520 return 1;
521 }
522
523 /* switch buffer */
524 /* log(L_NOTICE, "deleting include_stack_ptr=%d", include_stack_ptr); */
525 yy_delete_buffer(YY_CURRENT_BUFFER);
526 lineno = lineno_stack[include_stack_ptr];
527 conf_parser_ctx.conf_file = inc_fbfile_in[include_stack_ptr];
528 strlcpy(conffilebuf, conffile_stack[include_stack_ptr], sizeof(conffilebuf));
529 yy_switch_to_buffer(include_stack[include_stack_ptr]);
530
531 return 0;
532 }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.26