ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-8/src/ircd_lexer.l
Revision: 1247
Committed: Sat Oct 1 07:54:24 2011 UTC (12 years, 5 months ago) by michael
File size: 16094 byte(s)
Log Message:
- Rewrite and cleanup half-broken logging subsystem.
  Logfile rotating is not working yet

File Contents

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

Properties

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