/[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 1176 - (show annotations)
Sun Aug 14 11:24:24 2011 UTC (8 years, 6 months ago) by michael
File size: 16738 byte(s)
- remove idle-time klines
- rename LocalUser.last to LocalUser.last_privmsg
- m_message.c: reset source_p->last_privmsg even if a client is messaging itself


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 global_kill { return GLOBAL_KILL; }
196 have_ident { return NEED_IDENT; }
197 need_ident { return NEED_IDENT; }
198 havent_read_conf { return HAVENT_READ_CONF; }
199 hidden { return HIDDEN; }
200 hidden_admin { return HIDDEN_ADMIN; }
201 hidden_name { return HIDDEN_NAME; }
202 hidden_oper { return HIDDEN_OPER; }
203 hide_server_ips { return HIDE_SERVER_IPS; }
204 hide_servers { return HIDE_SERVERS; }
205 hide_spoof_ips { return HIDE_SPOOF_IPS; }
206 host { return HOST; }
207 hub { return HUB; }
208 hub_mask { return HUB_MASK; }
209 ignore_bogus_ts { return IGNORE_BOGUS_TS; }
210 invisible_on_connect { return INVISIBLE_ON_CONNECT; }
211 ip { return IP; }
212 ipv4 { return T_IPV4; }
213 ipv6 { return T_IPV6; }
214 join_flood_count { return JOIN_FLOOD_COUNT; }
215 join_flood_time { return JOIN_FLOOD_TIME; }
216 kill { return KILL; }
217 kill_chase_time_limit { return KILL_CHASE_TIME_LIMIT; }
218 kline { return KLINE; }
219 kline_exempt { return KLINE_EXEMPT; }
220 l_crit { return T_L_CRIT; }
221 l_debug { return T_L_DEBUG; }
222 l_error { return T_L_ERROR; }
223 l_info { return T_L_INFO; }
224 l_notice { return T_L_NOTICE; }
225 l_trace { return T_L_TRACE; }
226 l_warn { return T_L_WARN; }
227 leaf_mask { return LEAF_MASK; }
228 listen { return LISTEN; }
229 log_level { return LOG_LEVEL; }
230 log { return LOGGING; }
231 logging { return LOGGING; }
232 logpath { return T_LOGPATH; }
233 masked { return TMASKED; }
234 max_clients { return T_MAX_CLIENTS; }
235 max_ident { return MAX_IDENT; }
236 max_local { return MAX_LOCAL; }
237 max_global { return MAX_GLOBAL; }
238 max_number { return MAX_NUMBER; }
239 max_watch { return MAX_WATCH; }
240 message_locale { return MESSAGE_LOCALE; }
241 min_nonwildcard { return MIN_NONWILDCARD; }
242 min_nonwildcard_simple { return MIN_NONWILDCARD_SIMPLE; }
243 name { return NAME; }
244 need_password { return NEED_PASSWORD; }
245 network_desc { return NETWORK_DESC; }
246 network_name { return NETWORK_NAME; }
247 nick { return NICK; }
248 nick_changes { return NICK_CHANGES; }
249 no { yylval.number = NO; return TBOOL; }
250 no_create_on_split { return NO_CREATE_ON_SPLIT; }
251 no_join_on_split { return NO_JOIN_ON_SPLIT; }
252 no_oper_flood { return NO_OPER_FLOOD; }
253 no_tilde { return NO_TILDE; }
254 number_per_cidr { return NUMBER_PER_CIDR; }
255 number_per_ip { return NUMBER_PER_IP; }
256 oper { return OPERATOR; }
257 oper_log { return OPER_LOG; }
258 oper_pass_resv { return OPER_PASS_RESV; }
259 operator { return OPERATOR; }
260 passwd { return PASSWORD; }
261 password { return PASSWORD; }
262 ping_cookie { return PING_COOKIE; }
263 ping_time { return PING_TIME; }
264 ping_warning { return PING_WARNING; }
265 port { return PORT; }
266 quarantine { return RESV; }
267 quiet_on_ban { return QUIET_ON_BAN; }
268 reason { return REASON; }
269 redirport { return REDIRPORT; }
270 redirserv { return REDIRSERV; }
271 regex { return REGEX_T; }
272 rehash { return REHASH; }
273 reject { return T_REJECT; }
274 reject_hold_time { return TREJECT_HOLD_TIME; }
275 remote { return REMOTE; }
276 remoteban { return REMOTEBAN; }
277 restrict_channels { return RESTRICT_CHANNELS; }
278 resv { return RESV; }
279 resv_exempt { return RESV_EXEMPT; }
280 rsa_private_key_file { return RSA_PRIVATE_KEY_FILE; }
281 rsa_public_key_file { return RSA_PUBLIC_KEY_FILE; }
282 ssl { return T_SSL; }
283 ssl_certificate_file { return SSL_CERTIFICATE_FILE; }
284 ssl_server_protocol { return T_SSL_CONNECTION_METHOD; }
285 sslv3 { return T_SSLV3; }
286 tlsv1 { return T_TLSV1; }
287 send_password { return SEND_PASSWORD; }
288 sendq { return SENDQ; }
289 server { return T_SERVER; }
290 serverhide { return SERVERHIDE; }
291 serverinfo { return SERVERINFO; }
292 service { return T_SERVICE; }
293 services_name { return T_SERVICES_NAME; }
294 servlink_path { return SERVLINK_PATH; }
295 shared { return T_SHARED; }
296 short_motd { return SHORT_MOTD; }
297 sid { return IRCD_SID; }
298 silent { return SILENT; }
299 spoof { return SPOOF; }
300 spoof_notice { return SPOOF_NOTICE; }
301 tkline_expire_notices { return TKLINE_EXPIRE_NOTICES; }
302 type { return TYPE; }
303 true_no_oper_flood { return TRUE_NO_OPER_FLOOD; }
304 umodes { return T_UMODES; }
305 unkline { return UNKLINE; }
306 use_egd { return USE_EGD; }
307 use_except { return USE_EXCEPT; }
308 use_invex { return USE_INVEX; }
309 use_knock { return USE_KNOCK; }
310 use_logging { return USE_LOGGING; }
311 use_whois_actually { return USE_WHOIS_ACTUALLY; }
312 throttle_time { return THROTTLE_TIME; }
313 user { return USER; }
314 tkline { return TKLINE; }
315 txline { return TXLINE; }
316 tresv { return TRESV; }
317 vhost { return VHOST; }
318 vhost6 { return VHOST6; }
319 warn { return WARN; }
320 xline { return XLINE; }
321 yes { yylval.number = YES; return TBOOL; }
322
323 failed_oper_notice { return FAILED_OPER_NOTICE; }
324 max_accept { return MAX_ACCEPT; }
325 max_nick_changes { return MAX_NICK_CHANGES; }
326 max_chans_per_user { return MAX_CHANS_PER_USER; }
327 max_nick_time { return MAX_NICK_TIME; }
328 anti_nick_flood { return ANTI_NICK_FLOOD; }
329 anti_spam_exit_message_time { return ANTI_SPAM_EXIT_MESSAGE_TIME; }
330 ts_max_delta { return TS_MAX_DELTA; }
331 ts_warn_delta { return TS_WARN_DELTA; }
332 links_delay { return LINKS_DELAY; }
333 kline_reason { return KLINE_REASON; }
334 kline_with_reason { return KLINE_WITH_REASON; }
335 warn_no_nline { return WARN_NO_NLINE; }
336
337 stats_e_disabled { return STATS_E_DISABLED; }
338 stats_o_oper_only { return STATS_O_OPER_ONLY; }
339 stats_k_oper_only { return STATS_K_OPER_ONLY; }
340 stats_i_oper_only { return STATS_I_OPER_ONLY; }
341 stats_P_oper_only { return STATS_P_OPER_ONLY; }
342 pace_wait { return PACE_WAIT; }
343 pace_wait_simple { return PACE_WAIT_SIMPLE; }
344 knock_delay { return KNOCK_DELAY; }
345 knock_delay_channel { return KNOCK_DELAY_CHANNEL; }
346 max_bans { return MAX_BANS; }
347 modules { return MODULES; }
348 module { return MODULE; }
349 path { return PATH; }
350 max_targets { return MAX_TARGETS; }
351
352 unxline { return T_UNXLINE; }
353 unresv { return T_UNRESV; }
354
355 oper_only_umodes { return OPER_ONLY_UMODES; }
356 oper_umodes { return OPER_UMODES; }
357 bots { return T_BOTS; }
358 cconn { return T_CCONN; }
359 cconn_full { return T_CCONN_FULL; }
360 deaf { return T_DEAF; }
361 debug { return T_DEBUG; }
362 full { return T_FULL; }
363 skill { return T_SKILL; }
364 nchange { return T_NCHANGE; }
365 rej { return T_REJ; }
366 unauth { return T_UNAUTH; }
367 spy { return T_SPY; }
368 external { return T_EXTERNAL; }
369 operwall { return T_OPERWALL; }
370 servnotice { return T_SERVNOTICE; }
371 invisible { return T_INVISIBLE; }
372 wallop { return T_WALLOP; }
373 callerid { return T_CALLERID; }
374 softcallerid { return T_SOFTCALLERID; }
375 drone { return T_DRONE; }
376 locops { return T_LOCOPS; }
377 topicburst { return TOPICBURST; }
378
379 weeks { return WEEKS; }
380 week { return WEEKS; }
381 days { return DAYS; }
382 day { return DAYS; }
383 hours { return HOURS; }
384 hour { return HOURS; }
385 minutes { return MINUTES; }
386 minute { return MINUTES; }
387 seconds { return SECONDS; }
388 second { return SECONDS; }
389
390 bytes { return BYTES; }
391 byte { return BYTES; }
392 kilobytes { return KBYTES; }
393 kilobyte { return KBYTES; }
394 kbytes { return KBYTES; }
395 kbyte { return KBYTES; }
396 kb { return KBYTES; }
397 megabytes { return MBYTES; }
398 megabyte { return MBYTES; }
399 mbytes { return MBYTES; }
400 mbyte { return MBYTES; }
401 mb { return MBYTES; }
402 gigabytes { return GBYTES; }
403 gigabyte { return GBYTES; }
404 gbytes { return GBYTES; }
405 gbyte { return GBYTES; }
406 gb { return GBYTES; }
407 terabytes { return TBYTES; }
408 terabyte { return TBYTES; }
409 tbytes { return TBYTES; }
410 tbyte { return TBYTES; }
411 tb { return TBYTES; }
412 \.\. { return TWODOTS; }
413
414 . { return yytext[0]; }
415 <<EOF>> { if (ieof()) yyterminate(); }
416
417 %%
418
419 /* C-comment ignoring routine -kre*/
420 static void
421 ccomment(void)
422 {
423 int c = 0;
424
425 /* log(L_NOTICE, "got comment"); */
426 while (1)
427 {
428 while ((c = input()) != '*' && c != EOF)
429 if (c == '\n')
430 ++lineno;
431
432 if (c == '*')
433 {
434 while ((c = input()) == '*')
435 /* Nothing */ ;
436 if (c == '/')
437 break;
438 else if (c == '\n')
439 ++lineno;
440 }
441
442 if (c == EOF)
443 {
444 YY_FATAL_ERROR("EOF in comment");
445 /* XXX hack alert this disables
446 * the stupid unused function warning
447 * gcc generates
448 */
449 if (1 == 0)
450 yy_fatal_error("EOF in comment");
451 break;
452 }
453 }
454 }
455
456 /* C-style .includes. This function will properly swap input conf buffers,
457 * and lineno -kre */
458 static void
459 cinclude(void)
460 {
461 char *p = NULL;
462
463 if ((p = strchr(yytext, '<')) == NULL)
464 *strchr(p = strchr(yytext, '"') + 1, '"') = '\0';
465 else
466 *strchr(++p, '>') = '\0';
467
468 /* log(L_NOTICE, "got include %s!", c); */
469
470 /* do stacking and co. */
471 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
472 ilog(L_ERROR, "Includes nested too deep in %s", p);
473 else
474 {
475 FBFILE *tmp_fbfile_in = NULL;
476 char filenamebuf[IRCD_BUFSIZE];
477
478 if (*p == '/') /* if it is an absolute path */
479 snprintf(filenamebuf, sizeof(filenamebuf), "%s", p);
480 else
481 snprintf(filenamebuf, sizeof(filenamebuf), "%s/%s", ETCPATH, p);
482
483 tmp_fbfile_in = fbopen(filenamebuf, "r");
484
485 if (tmp_fbfile_in == NULL)
486 {
487 ilog(L_ERROR, "Unable to read configuration file '%s': %s",
488 filenamebuf, strerror(errno));
489 return;
490 }
491
492 lineno_stack[include_stack_ptr] = lineno;
493 lineno = 1;
494 inc_fbfile_in[include_stack_ptr] = conf_parser_ctx.conf_file;
495 strlcpy(conffile_stack[include_stack_ptr], conffilebuf, IRCD_BUFSIZE);
496 include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
497 conf_parser_ctx.conf_file = tmp_fbfile_in;
498 snprintf(conffilebuf, sizeof(conffilebuf), "%s", filenamebuf);
499 yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
500 }
501 }
502
503 /* This is function that will be called on EOF in conf file. It will
504 * apropriately close conf if it not main conf and swap input buffers -kre
505 * */
506 static int
507 ieof(void)
508 {
509 /* log(L_NOTICE, "return from include stack!"); */
510 if (include_stack_ptr)
511 fbclose(conf_parser_ctx.conf_file);
512 if (--include_stack_ptr < 0)
513 {
514 /* log(L_NOTICE, "terminating lexer"); */
515 /* We will now exit the lexer - restore init values if we get /rehash
516 * later and reenter lexer -kre */
517 include_stack_ptr = 0;
518 lineno = 1;
519 return 1;
520 }
521
522 /* switch buffer */
523 /* log(L_NOTICE, "deleting include_stack_ptr=%d", include_stack_ptr); */
524 yy_delete_buffer(YY_CURRENT_BUFFER);
525 lineno = lineno_stack[include_stack_ptr];
526 conf_parser_ctx.conf_file = inc_fbfile_in[include_stack_ptr];
527 strlcpy(conffilebuf, conffile_stack[include_stack_ptr], sizeof(conffilebuf));
528 yy_switch_to_buffer(include_stack[include_stack_ptr]);
529
530 return 0;
531 }

Properties

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

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