trunk/src/config-parser.y

/*
 * Copyright (C) 2002-2003  Erik Fears
 *
 * 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.
 *       59 Temple Place - Suite 330
 *       Boston, MA  02111-1307, USA.
 *
 *
 */


%{
#include <stdio.h>
#include <string.h>
#include "malloc.h"
#include "config.h"

int yylex(void);

int yydebug=0;
void *tmp;        /* Variable to temporarily hold nodes before insertion to list */

%}

%token AWAY
%token BAN_UNKNOWN
%token BLACKLIST
%token BYTES KBYTES MBYTES
%token CHANNEL
%token CONNREGEX
%token DNS_FDLIMIT
%token DNSBL_FROM
%token DNSBL_TO
%token EXEMPT
%token FD
%token INVITE
%token IRC
%token KLINE
%token KEY
%token MASK
%token MAX_READ
%token MODE
%token NAME
%token NEGCACHE
%token NICK
%token NICKSERV
%token OPER
%token OPM
%token OPTIONS
%token PASSWORD
%token PERFORM
%token PIDFILE
%token PORT
%token PROTOCOL
%token READTIMEOUT
%token REALNAME
%token REPLY
%token SCANLOG
%token SCANNER
%token SECONDS MINUTES HOURS DAYS WEEKS MONTHS YEARS
%token SENDMAIL
%token SERVER
%token TARGET_IP
%token TARGET_PORT
%token TARGET_STRING
%token TIMEOUT
%token TYPE
%token USERNAME
%token USER
%token VHOST

%union 
{
        int number;
        char *string;
}

%token <number> NUMBER
%token <string> STRING
%token <number> PROTOCOLTYPE
%type  <number> timespec
%type  <number> timespec_
%type  <number> sizespec
%type  <number> sizespec_

%%

config:
          | config config_items
          ;

config_items: irc_entry     |
              options_entry |
              opm_entry     |
              user_entry    |
              scanner_entry |
              exempt_entry;

timespec_: { $$ = 0; } | timespec;
timespec:  NUMBER timespec_         { $$ = $1 + $2; } |
           NUMBER SECONDS timespec_ { $$ = $1 + $3; } |
           NUMBER MINUTES timespec_ { $$ = $1 * 60 + $3; } |
           NUMBER HOURS timespec_   { $$ = $1 * 60 * 60 + $3; } |
           NUMBER DAYS timespec_    { $$ = $1 * 60 * 60 * 24 + $3; } |
           NUMBER WEEKS timespec_   { $$ = $1 * 60 * 60 * 24 * 7 + $3; } |
           NUMBER MONTHS timespec_  { $$ = $1 * 60 * 60 * 24 * 7 * 4 + $3; } |
           NUMBER YEARS timespec_   { $$ = $1 * 60 * 60 * 24 * 365 + $3; }
           ;

sizespec_:  { $$ = 0; } | sizespec;
sizespec:   NUMBER sizespec_ { $$ = $1 + $2; } |
            NUMBER BYTES sizespec_ { $$ = $1 + $3; } |
            NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; } |
            NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
            ;

/*************************** OPTIONS BLOCK ***********************/

options_entry: OPTIONS '{' options_items '}' ';';

options_items: options_items options_item |
               options_item;

options_item: options_negcache |
              options_pidfile |
              options_dns_fdlimit |
              options_scanlog |
              error;

options_negcache: NEGCACHE '=' timespec ';'
{
   OptionsItem->negcache = $3;
};

options_pidfile: PIDFILE '=' STRING ';'
{
   MyFree(OptionsItem->pidfile);
   OptionsItem->pidfile = xstrdup($3);
};

options_dns_fdlimit: DNS_FDLIMIT '=' NUMBER ';'
{
   OptionsItem->dns_fdlimit = $3;
};

options_scanlog: SCANLOG '=' STRING ';'
{
   MyFree(OptionsItem->scanlog);
   OptionsItem->scanlog = xstrdup($3);
};

/*************************** IRC BLOCK ***************************/

irc_entry: IRC '{' irc_items  '}' ';';

irc_items: irc_items irc_item |
           irc_item;

irc_item: irc_away        |
          irc_connregex   |
          irc_kline       |
          irc_nick        |
          irc_nickserv    |
          irc_mode        |
          irc_oper        |
          irc_password    |
          irc_port        | 
          irc_readtimeout |
          irc_realname    |
          irc_server      |
          irc_username    |
          irc_vhost       |
          irc_perform     |
          channel_entry   |
          error;

irc_away: AWAY '=' STRING ';'
{
   MyFree(IRCItem->away);
   IRCItem->away = xstrdup($3);
};

irc_kline: KLINE '=' STRING ';'
{
   MyFree(IRCItem->kline);
   IRCItem->kline = xstrdup($3);
};

irc_mode: MODE '=' STRING ';'
{
   MyFree(IRCItem->mode);
   IRCItem->mode = xstrdup($3);
};

irc_nick: NICK '=' STRING ';'
{
   MyFree(IRCItem->nick);
   IRCItem->nick = xstrdup($3);
};

irc_nickserv: NICKSERV '=' STRING ';'
{
   MyFree(IRCItem->nickserv);
   IRCItem->nickserv = xstrdup($3);
};

irc_oper: OPER '=' STRING ';'
{
   MyFree(IRCItem->oper);
   IRCItem->oper = xstrdup($3);
};

irc_password: PASSWORD '=' STRING ';'
{
   MyFree(IRCItem->password);
   IRCItem->password = xstrdup($3);
};

irc_perform: PERFORM '=' STRING ';'
{
   node_t *node;
   node = node_create(xstrdup($3));

   list_add(IRCItem->performs, node);
};

irc_port: PORT '=' NUMBER ';'
{
   IRCItem->port = $3;
};

irc_readtimeout: READTIMEOUT '=' timespec ';'
{
   IRCItem->readtimeout = $3;
};

irc_realname: REALNAME '=' STRING ';'
{
   MyFree(IRCItem->realname);
   IRCItem->realname = xstrdup($3);
};

irc_server: SERVER '=' STRING ';'
{
   MyFree(IRCItem->server);
   IRCItem->server = xstrdup($3);
};

irc_username: USERNAME '=' STRING ';'
{
   MyFree(IRCItem->username);
   IRCItem->username = xstrdup($3);
};

irc_vhost: VHOST '=' STRING ';'
{
   MyFree(IRCItem->vhost);
   IRCItem->vhost = xstrdup($3);
};

irc_connregex: CONNREGEX '=' STRING ';'
{
   MyFree(IRCItem->connregex);
   IRCItem->connregex = xstrdup($3);
};


/************************** CHANNEL BLOCK *************************/

channel_entry: 
{
   node_t *node;
   struct ChannelConf *item;

   item = MyMalloc(sizeof *item);

   item->name = xstrdup("");
   item->key = xstrdup("");
   item->invite = xstrdup("");

   node = node_create(item);
   list_add(IRCItem->channels, node);

   tmp = (void *) item;
}
CHANNEL '{' channel_items '}' ';';

channel_items: channel_items channel_item |
               channel_item;

channel_item:  channel_name  |
               channel_key   |
               channel_invite;

channel_name: NAME '=' STRING ';'
{
   struct ChannelConf *item = tmp;

   MyFree(item->name);
   item->name = xstrdup($3);
};

channel_key: KEY '=' STRING ';'
{
   struct ChannelConf *item = tmp;

   MyFree(item->key);
   item->key = xstrdup($3);
};

channel_invite: INVITE '=' STRING ';'
{
   struct ChannelConf *item = tmp;

   MyFree(item->invite);
   item->invite = xstrdup($3);
};

/*************************** USER BLOCK ***************************/

user_entry: 
{
   node_t *node;
   struct UserConf *item;

   item = MyMalloc(sizeof *item);

   item->masks = list_create();
   item->scanners = list_create();

   node = node_create(item);
   list_add(UserItemList, node);

   tmp = (void *) item; 
} 
USER '{' user_items  '}' ';' ;

user_items: user_items user_item |
           user_item;

user_item: user_mask     |
           user_scanner  |
          error;

user_mask: MASK '=' STRING ';'
{
   struct UserConf *item = (struct UserConf *) tmp;

   node_t *node;
   node = node_create((void *) xstrdup($3));

   list_add(item->masks, node);
};

user_scanner: SCANNER '=' STRING ';'
{
   struct UserConf *item = (struct UserConf *) tmp;

   node_t *node;
   node = node_create((void *) xstrdup($3));

   list_add(item->scanners, node);
};

/*************************** SCANNER BLOCK ***************************/

scanner_entry:
{
   node_t *node;
   struct ScannerConf *item, *olditem;

   item = MyMalloc(sizeof *item);

   /* Setup ScannerConf defaults */
   item->name = xstrdup("undefined");

        if(LIST_SIZE(ScannerItemList) > 0)
        {
           olditem = ScannerItemList->tail->data;

                item->vhost = xstrdup(olditem->vhost);
                item->fd = olditem->fd;
                item->target_ip = xstrdup(olditem->target_ip);
                item->target_port = olditem->target_port;
                item->timeout = olditem->timeout;
                item->max_read = olditem->max_read;

                item->target_string = olditem->target_string;
                item->target_string_created = 0;
        }
        else
        {
           item->vhost = xstrdup("0.0.0.0");
      item->fd = 512;
      item->target_ip = xstrdup("127.0.0.1");
      item->target_port = 6667;
      item->timeout = 30;
      item->max_read = 4096;
                
                item->target_string = list_create();
                item->target_string_created = 1;
        }
        
   item->protocols = list_create();

   node = node_create(item);

   list_add(ScannerItemList, node);
   tmp = (void *) item;
}
SCANNER '{' scanner_items  '}' ';' ;

scanner_items: scanner_items scanner_item |
               scanner_item;

scanner_item: scanner_name          |
              scanner_vhost         |
              scanner_fd            |
              scanner_target_ip     |
              scanner_target_port   |
              scanner_target_string |
              scanner_protocol      |
              scanner_timeout       |
              scanner_max_read      |
              error;

scanner_name: NAME '=' STRING ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   MyFree(item->name);
   item->name = xstrdup($3);
};

scanner_vhost: VHOST '=' STRING ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   MyFree(item->vhost);
   item->vhost = xstrdup($3);
};

scanner_target_ip: TARGET_IP '=' STRING ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   MyFree(item->target_ip);
   item->target_ip = xstrdup($3);
};

scanner_target_string: TARGET_STRING '=' STRING ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;

   node_t *node;
   node = node_create($3);

        if(item->target_string_created == 0)
        {
           item->target_string = list_create();
                item->target_string_created = 1;
        }

   list_add(item->target_string, node);
};

scanner_fd: FD '=' NUMBER ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   item->fd = $3;
};

scanner_target_port: TARGET_PORT '=' NUMBER ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   item->target_port = $3;
};

scanner_timeout: TIMEOUT '=' timespec ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   item->timeout = $3;
};

scanner_max_read: MAX_READ '=' sizespec ';'
{
   struct ScannerConf *item = (struct ScannerConf *) tmp;
   item->max_read = $3;
};

scanner_protocol: PROTOCOL '=' PROTOCOLTYPE ':' NUMBER ';'
{
   struct ProtocolConf *item;
   struct ScannerConf  *item2;

   node_t *node;
 
   item = MyMalloc(sizeof *item);
   item->type = $3;
   item->port = $5;

   item2 = (struct ScannerConf *) tmp;

   node = node_create(item);
   list_add(item2->protocols, node);
};

/*************************** OPM BLOCK ***************************/

opm_entry: OPM '{' opm_items  '}' ';' ;

opm_items: opm_items opm_item |
           opm_item;

opm_item: opm_dnsbl_from      |
          opm_dnsbl_to        |
          opm_sendmail        |
          opm_blacklist_entry |
          error;

opm_dnsbl_from: DNSBL_FROM '=' STRING ';'
{
   MyFree(OpmItem->dnsbl_from);
   OpmItem->dnsbl_from = xstrdup($3);
};

opm_dnsbl_to: DNSBL_TO '=' STRING ';'
{
   MyFree(OpmItem->dnsbl_to);
   OpmItem->dnsbl_to = xstrdup($3);
};

opm_sendmail: SENDMAIL '=' STRING ';'
{
   MyFree(OpmItem->sendmail);
   OpmItem->sendmail = xstrdup($3);
};

/************************** BLACKLIST BLOCK *************************/

opm_blacklist_entry:
{
   node_t *node;
   struct BlacklistConf *item;

   item = MyMalloc(sizeof *item);

   item->name = xstrdup("");
   item->kline = xstrdup("");
   item->ban_unknown = 0;
   item->type = A_BITMASK;
   item->reply = list_create();

   node = node_create(item);
   list_add(OpmItem->blacklists, node);

   tmp = (void *) item;
}
BLACKLIST '{' blacklist_items '}' ';';

blacklist_items: blacklist_items blacklist_item |
                 blacklist_item;

blacklist_item: blacklist_name        |
                blacklist_type        |
                blacklist_kline       |
                blacklist_ban_unknown |
                blacklist_reply       |
                error;

blacklist_name: NAME '=' STRING ';' {
   struct BlacklistConf *item = tmp;

   MyFree(item->name);
   item->name = xstrdup($3);
};

blacklist_kline: KLINE '=' STRING ';' {
   struct BlacklistConf *item = tmp;

   MyFree(item->kline);
   item->kline = xstrdup($3);
};

blacklist_type: TYPE '=' STRING ';' {
   struct BlacklistConf *item = tmp;
   
   if(strcmp("A record bitmask", $3) == 0)
      item->type = A_BITMASK;
   else if(strcmp("A record reply", $3) == 0)
      item->type = A_REPLY;
   else
      yyerror("Unknown blacklist type defined");
};

blacklist_ban_unknown: BAN_UNKNOWN '=' NUMBER ';' {
   struct BlacklistConf *item = tmp;

   item->ban_unknown = $3;
};

blacklist_reply: REPLY '{' blacklist_reply_items '}' ';';

blacklist_reply_items: blacklist_reply_items blacklist_reply_item |
                       blacklist_reply_item;

blacklist_reply_item: NUMBER '=' STRING ';'
{
   struct BlacklistReplyConf *item;
   struct BlacklistConf *blacklist = tmp;
   node_t *node;

   item = MyMalloc(sizeof *item);

   item->number = $1;
   item->type = xstrdup($3);

   node = node_create(item);
   list_add(blacklist->reply, node);
};

/*************************** EXEMPT BLOCK ***************************/


exempt_entry: EXEMPT '{' exempt_items  '}' ';' ;

exempt_items: exempt_items exempt_item |
              exempt_item;

exempt_item: exempt_mask  |
             error;

exempt_mask: MASK '=' STRING ';'
{
   node_t *node;
   node = node_create(xstrdup($3));

   list_add(ExemptItem->masks, node);
};

%%
Revision:	5198
Committed:	Mon Dec 29 16:53:16 2014 UTC (11 years, 6 months ago) by michael
File size:	13895 byte(s)
Log Message:	- Made NODATA_TIMEOUT a configuration option
#	User	Rev	Content
1	michael	5052	/*
2			* Copyright (C) 2002-2003 Erik Fears
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to
16			*
17			* The Free Software Foundation, Inc.
18			* 59 Temple Place - Suite 330
19			* Boston, MA 02111-1307, USA.
20			*
21			*
22			*/
23
24
25			%{
26			#include <stdio.h>
27			#include <string.h>
28			#include "malloc.h"
29			#include "config.h"
30
31	michael	5072	int yylex(void);
32
33	michael	5052	int yydebug=0;
34			void tmp; / Variable to temporarily hold nodes before insertion to list */
35
36			%}
37
38			%token AWAY
39			%token BAN_UNKNOWN
40			%token BLACKLIST
41	michael	5080	%token BYTES KBYTES MBYTES
42	michael	5052	%token CHANNEL
43			%token CONNREGEX
44			%token DNS_FDLIMIT
45			%token DNSBL_FROM
46			%token DNSBL_TO
47			%token EXEMPT
48			%token FD
49			%token INVITE
50			%token IRC
51			%token KLINE
52			%token KEY
53			%token MASK
54			%token MAX_READ
55			%token MODE
56			%token NAME
57			%token NEGCACHE
58			%token NICK
59			%token NICKSERV
60			%token OPER
61			%token OPM
62			%token OPTIONS
63			%token PASSWORD
64			%token PERFORM
65			%token PIDFILE
66			%token PORT
67			%token PROTOCOL
68	michael	5198	%token READTIMEOUT
69	michael	5052	%token REALNAME
70			%token REPLY
71			%token SCANLOG
72			%token SCANNER
73	michael	5080	%token SECONDS MINUTES HOURS DAYS WEEKS MONTHS YEARS
74	michael	5052	%token SENDMAIL
75			%token SERVER
76			%token TARGET_IP
77			%token TARGET_PORT
78			%token TARGET_STRING
79			%token TIMEOUT
80			%token TYPE
81			%token USERNAME
82			%token USER
83			%token VHOST
84
85			%union
86			{
87			int number;
88			char *string;
89			}
90
91			%token <number> NUMBER
92			%token <string> STRING
93			%token <number> PROTOCOLTYPE
94	michael	5080	%type <number> timespec
95			%type <number> timespec_
96			%type <number> sizespec
97			%type <number> sizespec_
98	michael	5052
99			%%
100
101	michael	5068	config:
102			\| config config_items
103	michael	5052	;
104
105			config_items: irc_entry \|
106			options_entry \|
107			opm_entry \|
108			user_entry \|
109			scanner_entry \|
110			exempt_entry;
111
112	michael	5080	timespec_: { $$ = 0; } \| timespec;
113			timespec: NUMBER timespec_ { $$ = $1 + $2; } \|
114			NUMBER SECONDS timespec_ { $$ = $1 + $3; } \|
115			NUMBER MINUTES timespec_ { $$ = $1 * 60 + $3; } \|
116			NUMBER HOURS timespec_ { $$ = $1 * 60 * 60 + $3; } \|
117			NUMBER DAYS timespec_ { $$ = $1 * 60 * 60 * 24 + $3; } \|
118			NUMBER WEEKS timespec_ { $$ = $1 * 60 * 60 * 24 * 7 + $3; } \|
119			NUMBER MONTHS timespec_ { $$ = $1 * 60 * 60 * 24 * 7 * 4 + $3; } \|
120			NUMBER YEARS timespec_ { $$ = $1 * 60 * 60 * 24 * 365 + $3; }
121			;
122	michael	5052
123	michael	5080	sizespec_: { $$ = 0; } \| sizespec;
124			sizespec: NUMBER sizespec_ { $$ = $1 + $2; } \|
125			NUMBER BYTES sizespec_ { $$ = $1 + $3; } \|
126			NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; } \|
127			NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
128			;
129
130	michael	5052	/************************* OPTIONS BLOCK *********************/
131
132			options_entry: OPTIONS '{' options_items '}' ';';
133
134	michael	5068	options_items: options_items options_item \|
135	michael	5052	options_item;
136
137			options_item: options_negcache \|
138			options_pidfile \|
139			options_dns_fdlimit \|
140			options_scanlog \|
141			error;
142
143	michael	5080	options_negcache: NEGCACHE '=' timespec ';'
144	michael	5052	{
145			OptionsItem->negcache = $3;
146			};
147
148			options_pidfile: PIDFILE '=' STRING ';'
149			{
150			MyFree(OptionsItem->pidfile);
151	michael	5092	OptionsItem->pidfile = xstrdup($3);
152	michael	5052	};
153
154			options_dns_fdlimit: DNS_FDLIMIT '=' NUMBER ';'
155			{
156			OptionsItem->dns_fdlimit = $3;
157			};
158
159			options_scanlog: SCANLOG '=' STRING ';'
160			{
161			MyFree(OptionsItem->scanlog);
162	michael	5092	OptionsItem->scanlog = xstrdup($3);
163	michael	5052	};
164
165			/************************* IRC BLOCK *************************/
166
167			irc_entry: IRC '{' irc_items '}' ';';
168
169			irc_items: irc_items irc_item \|
170			irc_item;
171
172	michael	5198	irc_item: irc_away \|
173			irc_connregex \|
174			irc_kline \|
175			irc_nick \|
176			irc_nickserv \|
177			irc_mode \|
178			irc_oper \|
179			irc_password \|
180			irc_port \|
181			irc_readtimeout \|
182			irc_realname \|
183			irc_server \|
184			irc_username \|
185			irc_vhost \|
186			irc_perform \|
187			channel_entry \|
188	michael	5052	error;
189
190			irc_away: AWAY '=' STRING ';'
191			{
192			MyFree(IRCItem->away);
193	michael	5092	IRCItem->away = xstrdup($3);
194	michael	5052	};
195
196			irc_kline: KLINE '=' STRING ';'
197			{
198			MyFree(IRCItem->kline);
199	michael	5092	IRCItem->kline = xstrdup($3);
200	michael	5052	};
201
202			irc_mode: MODE '=' STRING ';'
203			{
204			MyFree(IRCItem->mode);
205	michael	5092	IRCItem->mode = xstrdup($3);
206	michael	5052	};
207
208			irc_nick: NICK '=' STRING ';'
209			{
210			MyFree(IRCItem->nick);
211	michael	5092	IRCItem->nick = xstrdup($3);
212	michael	5052	};
213
214			irc_nickserv: NICKSERV '=' STRING ';'
215			{
216			MyFree(IRCItem->nickserv);
217	michael	5092	IRCItem->nickserv = xstrdup($3);
218	michael	5052	};
219
220			irc_oper: OPER '=' STRING ';'
221			{
222			MyFree(IRCItem->oper);
223	michael	5092	IRCItem->oper = xstrdup($3);
224	michael	5052	};
225
226			irc_password: PASSWORD '=' STRING ';'
227			{
228			MyFree(IRCItem->password);
229	michael	5092	IRCItem->password = xstrdup($3);
230	michael	5052	};
231
232			irc_perform: PERFORM '=' STRING ';'
233			{
234			node_t *node;
235	michael	5092	node = node_create(xstrdup($3));
236	michael	5052
237			list_add(IRCItem->performs, node);
238			};
239
240			irc_port: PORT '=' NUMBER ';'
241			{
242			IRCItem->port = $3;
243			};
244
245	michael	5198	irc_readtimeout: READTIMEOUT '=' timespec ';'
246			{
247			IRCItem->readtimeout = $3;
248			};
249
250	michael	5052	irc_realname: REALNAME '=' STRING ';'
251			{
252			MyFree(IRCItem->realname);
253	michael	5092	IRCItem->realname = xstrdup($3);
254	michael	5052	};
255
256			irc_server: SERVER '=' STRING ';'
257			{
258			MyFree(IRCItem->server);
259	michael	5092	IRCItem->server = xstrdup($3);
260	michael	5052	};
261
262			irc_username: USERNAME '=' STRING ';'
263			{
264			MyFree(IRCItem->username);
265	michael	5092	IRCItem->username = xstrdup($3);
266	michael	5052	};
267
268			irc_vhost: VHOST '=' STRING ';'
269			{
270			MyFree(IRCItem->vhost);
271	michael	5092	IRCItem->vhost = xstrdup($3);
272	michael	5052	};
273
274			irc_connregex: CONNREGEX '=' STRING ';'
275			{
276			MyFree(IRCItem->connregex);
277	michael	5092	IRCItem->connregex = xstrdup($3);
278	michael	5052	};
279
280
281			/************************ CHANNEL BLOCK ***********************/
282
283			channel_entry:
284			{
285			node_t *node;
286			struct ChannelConf *item;
287
288			item = MyMalloc(sizeof *item);
289
290	michael	5092	item->name = xstrdup("");
291			item->key = xstrdup("");
292			item->invite = xstrdup("");
293	michael	5052
294			node = node_create(item);
295			list_add(IRCItem->channels, node);
296
297			tmp = (void *) item;
298			}
299			CHANNEL '{' channel_items '}' ';';
300
301			channel_items: channel_items channel_item \|
302			channel_item;
303
304			channel_item: channel_name \|
305			channel_key \|
306			channel_invite;
307
308			channel_name: NAME '=' STRING ';'
309			{
310			struct ChannelConf *item = tmp;
311
312			MyFree(item->name);
313	michael	5092	item->name = xstrdup($3);
314	michael	5052	};
315
316			channel_key: KEY '=' STRING ';'
317			{
318			struct ChannelConf *item = tmp;
319
320			MyFree(item->key);
321	michael	5092	item->key = xstrdup($3);
322	michael	5052	};
323
324			channel_invite: INVITE '=' STRING ';'
325			{
326			struct ChannelConf *item = tmp;
327
328			MyFree(item->invite);
329	michael	5092	item->invite = xstrdup($3);
330	michael	5052	};
331
332			/************************* USER BLOCK *************************/
333
334			user_entry:
335			{
336			node_t *node;
337			struct UserConf *item;
338
339			item = MyMalloc(sizeof *item);
340
341			item->masks = list_create();
342			item->scanners = list_create();
343
344			node = node_create(item);
345			list_add(UserItemList, node);
346
347			tmp = (void *) item;
348			}
349			USER '{' user_items '}' ';' ;
350
351			user_items: user_items user_item \|
352			user_item;
353
354			user_item: user_mask \|
355			user_scanner \|
356			error;
357
358			user_mask: MASK '=' STRING ';'
359			{
360			struct UserConf item = (struct UserConf ) tmp;
361
362			node_t *node;
363	michael	5092	node = node_create((void *) xstrdup($3));
364	michael	5052
365			list_add(item->masks, node);
366			};
367
368			user_scanner: SCANNER '=' STRING ';'
369			{
370			struct UserConf item = (struct UserConf ) tmp;
371
372			node_t *node;
373	michael	5092	node = node_create((void *) xstrdup($3));
374	michael	5052
375			list_add(item->scanners, node);
376			};
377
378			/************************* SCANNER BLOCK *************************/
379
380			scanner_entry:
381			{
382			node_t *node;
383			struct ScannerConf item, olditem;
384
385			item = MyMalloc(sizeof *item);
386
387			/* Setup ScannerConf defaults */
388	michael	5092	item->name = xstrdup("undefined");
389	michael	5052
390			if(LIST_SIZE(ScannerItemList) > 0)
391			{
392			olditem = ScannerItemList->tail->data;
393
394	michael	5092	item->vhost = xstrdup(olditem->vhost);
395	michael	5052	item->fd = olditem->fd;
396	michael	5092	item->target_ip = xstrdup(olditem->target_ip);
397	michael	5052	item->target_port = olditem->target_port;
398			item->timeout = olditem->timeout;
399			item->max_read = olditem->max_read;
400
401			item->target_string = olditem->target_string;
402			item->target_string_created = 0;
403			}
404			else
405			{
406	michael	5092	item->vhost = xstrdup("0.0.0.0");
407	michael	5052	item->fd = 512;
408	michael	5092	item->target_ip = xstrdup("127.0.0.1");
409	michael	5052	item->target_port = 6667;
410			item->timeout = 30;
411			item->max_read = 4096;
412
413			item->target_string = list_create();
414			item->target_string_created = 1;
415			}
416
417			item->protocols = list_create();
418
419			node = node_create(item);
420
421			list_add(ScannerItemList, node);
422			tmp = (void *) item;
423			}
424			SCANNER '{' scanner_items '}' ';' ;
425
426			scanner_items: scanner_items scanner_item \|
427			scanner_item;
428
429			scanner_item: scanner_name \|
430			scanner_vhost \|
431			scanner_fd \|
432			scanner_target_ip \|
433			scanner_target_port \|
434			scanner_target_string \|
435			scanner_protocol \|
436			scanner_timeout \|
437			scanner_max_read \|
438			error;
439
440			scanner_name: NAME '=' STRING ';'
441			{
442			struct ScannerConf item = (struct ScannerConf ) tmp;
443			MyFree(item->name);
444	michael	5092	item->name = xstrdup($3);
445	michael	5052	};
446
447			scanner_vhost: VHOST '=' STRING ';'
448			{
449			struct ScannerConf item = (struct ScannerConf ) tmp;
450			MyFree(item->vhost);
451	michael	5092	item->vhost = xstrdup($3);
452	michael	5052	};
453
454			scanner_target_ip: TARGET_IP '=' STRING ';'
455			{
456			struct ScannerConf item = (struct ScannerConf ) tmp;
457			MyFree(item->target_ip);
458	michael	5092	item->target_ip = xstrdup($3);
459	michael	5052	};
460
461			scanner_target_string: TARGET_STRING '=' STRING ';'
462			{
463			struct ScannerConf item = (struct ScannerConf ) tmp;
464
465			node_t *node;
466			node = node_create($3);
467
468			if(item->target_string_created == 0)
469			{
470			item->target_string = list_create();
471			item->target_string_created = 1;
472			}
473
474			list_add(item->target_string, node);
475			};
476
477			scanner_fd: FD '=' NUMBER ';'
478			{
479			struct ScannerConf item = (struct ScannerConf ) tmp;
480			item->fd = $3;
481			};
482
483			scanner_target_port: TARGET_PORT '=' NUMBER ';'
484			{
485			struct ScannerConf item = (struct ScannerConf ) tmp;
486			item->target_port = $3;
487			};
488
489	michael	5080	scanner_timeout: TIMEOUT '=' timespec ';'
490	michael	5052	{
491			struct ScannerConf item = (struct ScannerConf ) tmp;
492			item->timeout = $3;
493			};
494
495	michael	5080	scanner_max_read: MAX_READ '=' sizespec ';'
496	michael	5052	{
497			struct ScannerConf item = (struct ScannerConf ) tmp;
498			item->max_read = $3;
499			};
500
501			scanner_protocol: PROTOCOL '=' PROTOCOLTYPE ':' NUMBER ';'
502			{
503			struct ProtocolConf *item;
504			struct ScannerConf *item2;
505
506			node_t *node;
507
508			item = MyMalloc(sizeof *item);
509			item->type = $3;
510			item->port = $5;
511
512			item2 = (struct ScannerConf *) tmp;
513
514			node = node_create(item);
515			list_add(item2->protocols, node);
516			};
517
518			/************************* OPM BLOCK *************************/
519
520			opm_entry: OPM '{' opm_items '}' ';' ;
521
522	michael	5068	opm_items: opm_items opm_item \|
523	michael	5052	opm_item;
524
525			opm_item: opm_dnsbl_from \|
526			opm_dnsbl_to \|
527			opm_sendmail \|
528			opm_blacklist_entry \|
529			error;
530
531			opm_dnsbl_from: DNSBL_FROM '=' STRING ';'
532			{
533			MyFree(OpmItem->dnsbl_from);
534	michael	5092	OpmItem->dnsbl_from = xstrdup($3);
535	michael	5052	};
536
537			opm_dnsbl_to: DNSBL_TO '=' STRING ';'
538			{
539			MyFree(OpmItem->dnsbl_to);
540	michael	5092	OpmItem->dnsbl_to = xstrdup($3);
541	michael	5052	};
542
543			opm_sendmail: SENDMAIL '=' STRING ';'
544			{
545			MyFree(OpmItem->sendmail);
546	michael	5092	OpmItem->sendmail = xstrdup($3);
547	michael	5052	};
548
549			/************************ BLACKLIST BLOCK ***********************/
550
551			opm_blacklist_entry:
552			{
553			node_t *node;
554			struct BlacklistConf *item;
555
556			item = MyMalloc(sizeof *item);
557
558	michael	5092	item->name = xstrdup("");
559			item->kline = xstrdup("");
560	michael	5052	item->ban_unknown = 0;
561			item->type = A_BITMASK;
562			item->reply = list_create();
563
564			node = node_create(item);
565			list_add(OpmItem->blacklists, node);
566
567			tmp = (void *) item;
568			}
569			BLACKLIST '{' blacklist_items '}' ';';
570
571	michael	5068	blacklist_items: blacklist_items blacklist_item \|
572			blacklist_item;
573	michael	5052
574			blacklist_item: blacklist_name \|
575			blacklist_type \|
576			blacklist_kline \|
577			blacklist_ban_unknown \|
578			blacklist_reply \|
579			error;
580
581			blacklist_name: NAME '=' STRING ';' {
582			struct BlacklistConf *item = tmp;
583
584			MyFree(item->name);
585	michael	5092	item->name = xstrdup($3);
586	michael	5052	};
587
588			blacklist_kline: KLINE '=' STRING ';' {
589			struct BlacklistConf *item = tmp;
590
591			MyFree(item->kline);
592	michael	5092	item->kline = xstrdup($3);
593	michael	5052	};
594
595			blacklist_type: TYPE '=' STRING ';' {
596			struct BlacklistConf *item = tmp;
597
598			if(strcmp("A record bitmask", $3) == 0)
599			item->type = A_BITMASK;
600			else if(strcmp("A record reply", $3) == 0)
601			item->type = A_REPLY;
602			else
603			yyerror("Unknown blacklist type defined");
604			};
605
606			blacklist_ban_unknown: BAN_UNKNOWN '=' NUMBER ';' {
607			struct BlacklistConf *item = tmp;
608
609			item->ban_unknown = $3;
610			};
611
612			blacklist_reply: REPLY '{' blacklist_reply_items '}' ';';
613
614	michael	5068	blacklist_reply_items: blacklist_reply_items blacklist_reply_item \|
615	michael	5052	blacklist_reply_item;
616
617			blacklist_reply_item: NUMBER '=' STRING ';'
618			{
619			struct BlacklistReplyConf *item;
620			struct BlacklistConf *blacklist = tmp;
621			node_t *node;
622
623			item = MyMalloc(sizeof *item);
624
625			item->number = $1;
626	michael	5092	item->type = xstrdup($3);
627	michael	5052
628			node = node_create(item);
629			list_add(blacklist->reply, node);
630			};
631
632			/************************* EXEMPT BLOCK *************************/
633
634
635			exempt_entry: EXEMPT '{' exempt_items '}' ';' ;
636
637	michael	5068	exempt_items: exempt_items exempt_item \|
638	michael	5052	exempt_item;
639
640			exempt_item: exempt_mask \|
641			error;
642
643			exempt_mask: MASK '=' STRING ';'
644			{
645			node_t *node;
646	michael	5092	node = node_create(xstrdup($3));
647	michael	5052
648			list_add(ExemptItem->masks, node);
649			};
650
651			%%