trunk/src/config-parser.y

/*
 *  Copyright (c) 2002-2003 Erik Fears
 *  Copyright (c) 2014-2017 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
 */

%{
#include <string.h>

#include "memory.h"
#include "config.h"

int yylex(void);

static void *tmp;  /* Variable to temporarily hold nodes before insertion to list */

%}

%token ADDRESS_FAMILY
%token AWAY
%token BAN_UNKNOWN
%token BLACKLIST
%token BYTES KBYTES MBYTES
%token CHANNEL
%token COMMAND_INTERVAL
%token COMMAND_QUEUE_SIZE
%token COMMAND_TIMEOUT
%token CONNREGEX
%token DNS_FDLIMIT
%token DNS_TIMEOUT
%token DNSBL_FROM
%token DNSBL_TO
%token EXEMPT
%token FD
%token INVITE
%token IPV4
%token IPV6
%token IRC
%token KLINE
%token KEY
%token MASK
%token MAX_READ
%token MODE
%token NAME
%token NEGCACHE
%token NEGCACHE_REBUILD
%token NICK
%token NICKSERV
%token NOTICE
%token OPER
%token OPM
%token OPTIONS
%token PASSWORD
%token PERFORM
%token PIDFILE
%token PORT
%token PROTOCOL
%token READTIMEOUT
%token REALNAME
%token RECONNECTINTERVAL
%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_negcache_rebuild   |
              options_pidfile            |
              options_dns_fdlimit        |
              options_dns_timeout        |
              options_scanlog            |
              options_command_queue_size |
              options_command_interval   |
              options_command_timeout    |
              error;

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

options_negcache_rebuild: NEGCACHE_REBUILD '=' timespec ';'
{
  OptionsItem->negcache_rebuild = $3;
};

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

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

options_dns_timeout: DNS_TIMEOUT '=' timespec ';'
{
  OptionsItem->dns_timeout = $3;
};

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

options_command_queue_size: COMMAND_QUEUE_SIZE '=' NUMBER ';'
{
  OptionsItem->command_queue_size = $3;
};

options_command_interval: COMMAND_INTERVAL '=' timespec ';'
{
  OptionsItem->command_interval = $3;
};

options_command_timeout: COMMAND_TIMEOUT '=' timespec ';'
{
  OptionsItem->command_timeout = $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_reconnectinterval |
          irc_realname          |
          irc_server            |
          irc_username          |
          irc_vhost             |
          irc_perform           |
          irc_notice            |
          channel_entry         |
          error;

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

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

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

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

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

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

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

irc_perform: PERFORM '=' STRING ';'
{
  node_t *node;

  node = node_create(xstrdup($3));
  list_add(IRCItem->performs, node);
};

irc_notice: NOTICE '=' STRING ';'
{
  node_t *node;

  node = node_create(xstrdup($3));
  list_add(IRCItem->notices, node);
};

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

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

irc_reconnectinterval: RECONNECTINTERVAL '=' timespec ';'
{
  IRCItem->reconnectinterval = $3;
};

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

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

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

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

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


/************************** CHANNEL BLOCK *************************/
channel_entry:
{
  node_t *node;
  struct ChannelConf *item;

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

  node = node_create(item);

  list_add(IRCItem->channels, node);
  tmp = 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;

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

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

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

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

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


/*************************** USER BLOCK ***************************/
user_entry:
{
  node_t *node;
  struct UserConf *item;

  item = xcalloc(sizeof(*item));
  item->masks = list_create();
  item->scanners = list_create();

  node = node_create(item);

  list_add(UserItemList, node);
  tmp = 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 = tmp;
  node_t *node;

  node = node_create(xstrdup($3));

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

user_scanner: SCANNER '=' STRING ';'
{
  struct UserConf *item = tmp;
  node_t *node;

  node = node_create(xstrdup($3));

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


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

  item = xcalloc(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 = 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 = tmp;

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

scanner_vhost: VHOST '=' STRING ';'
{
  struct ScannerConf *item = tmp;

  xfree(item->vhost);
  item->vhost = xstrdup($3);
};

scanner_target_ip: TARGET_IP '=' STRING ';'
{
  struct ScannerConf *item = tmp;

  xfree(item->target_ip);
  item->target_ip = xstrdup($3);
};

scanner_target_string: TARGET_STRING '=' STRING ';'
{
  struct ScannerConf *item = tmp;
  node_t *node;

  node = node_create(xstrdup($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 = tmp;

  item->fd = $3;
};

scanner_target_port: TARGET_PORT '=' NUMBER ';'
{
  struct ScannerConf *item = tmp;

  item->target_port = $3;
};

scanner_timeout: TIMEOUT '=' timespec ';'
{
  struct ScannerConf *item = tmp;

  item->timeout = $3;
};

scanner_max_read: MAX_READ '=' sizespec ';'
{
  struct ScannerConf *item = tmp;

  item->max_read = $3;
};

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

  item = xcalloc(sizeof(*item));
  item->type = $3;
  item->port = $5;

  item2 = 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 ';'
{
  xfree(OpmItem->dnsbl_from);
  OpmItem->dnsbl_from = xstrdup($3);
};

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

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


/************************** BLACKLIST BLOCK *************************/
opm_blacklist_entry:
{
  node_t *node;
  struct BlacklistConf *item;

  item = xcalloc(sizeof(*item));
  item->name = xstrdup("");
  item->kline = xstrdup("");
  item->ipv4 = 1;
  item->ban_unknown = 0;
  item->type = A_BITMASK;
  item->reply = list_create();

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

  tmp = item;
}
BLACKLIST '{' blacklist_items '}' ';';

blacklist_items: blacklist_items blacklist_item |
                 blacklist_item;

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

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

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

blacklist_address_family: ADDRESS_FAMILY
{
  struct BlacklistConf *item = tmp;

  item->ipv4 = 0;
  item->ipv6 = 0;
} '='  blacklist_address_family_items ';' ;

blacklist_address_family_items: blacklist_address_family_items ',' blacklist_address_family_item | blacklist_address_family_item;
blacklist_address_family_item:  IPV4
{
  struct BlacklistConf *item = tmp;

  item->ipv4 = 1;
} | IPV6
{
  struct BlacklistConf *item = tmp;

  item->ipv6 = 1;
};

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

  xfree(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 = xcalloc(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:	8179
Committed:	Thu Apr 13 17:24:47 2017 UTC (9 years, 3 months ago) by michael
File size:	15311 byte(s)
Log Message:	- config-parser.y: remove stdio.h header include
#	User	Rev	Content
1	michael	5052	/*
2	michael	5351	* Copyright (c) 2002-2003 Erik Fears
3	michael	7927	* Copyright (c) 2014-2017 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			%{
22			#include <string.h>
23	michael	5333
24			#include "memory.h"
25	michael	5052	#include "config.h"
26
27	michael	5072	int yylex(void);
28
29	michael	6049	static void tmp; / Variable to temporarily hold nodes before insertion to list */
30	michael	5052
31			%}
32
33	michael	8098	%token ADDRESS_FAMILY
34	michael	5052	%token AWAY
35			%token BAN_UNKNOWN
36			%token BLACKLIST
37	michael	5080	%token BYTES KBYTES MBYTES
38	michael	5052	%token CHANNEL
39	michael	7014	%token COMMAND_INTERVAL
40			%token COMMAND_QUEUE_SIZE
41			%token COMMAND_TIMEOUT
42	michael	5052	%token CONNREGEX
43			%token DNS_FDLIMIT
44	michael	6200	%token DNS_TIMEOUT
45	michael	5052	%token DNSBL_FROM
46			%token DNSBL_TO
47			%token EXEMPT
48			%token FD
49			%token INVITE
50	michael	8098	%token IPV4
51			%token IPV6
52	michael	5052	%token IRC
53			%token KLINE
54			%token KEY
55			%token MASK
56			%token MAX_READ
57			%token MODE
58			%token NAME
59			%token NEGCACHE
60	michael	5332	%token NEGCACHE_REBUILD
61	michael	5052	%token NICK
62			%token NICKSERV
63	michael	5405	%token NOTICE
64	michael	5052	%token OPER
65			%token OPM
66			%token OPTIONS
67			%token PASSWORD
68			%token PERFORM
69			%token PIDFILE
70			%token PORT
71			%token PROTOCOL
72	michael	5198	%token READTIMEOUT
73	michael	5052	%token REALNAME
74	michael	6078	%token RECONNECTINTERVAL
75	michael	5052	%token REPLY
76			%token SCANLOG
77			%token SCANNER
78	michael	5080	%token SECONDS MINUTES HOURS DAYS WEEKS MONTHS YEARS
79	michael	5052	%token SENDMAIL
80			%token SERVER
81			%token TARGET_IP
82			%token TARGET_PORT
83			%token TARGET_STRING
84			%token TIMEOUT
85			%token TYPE
86			%token USERNAME
87			%token USER
88			%token VHOST
89
90	michael	5650	%union
91	michael	5052	{
92	michael	5650	int number;
93			char *string;
94	michael	5052	}
95
96			%token <number> NUMBER
97			%token <string> STRING
98			%token <number> PROTOCOLTYPE
99	michael	5080	%type <number> timespec
100			%type <number> timespec_
101			%type <number> sizespec
102			%type <number> sizespec_
103	michael	5052
104			%%
105
106	michael	5068	config:
107			\| config config_items
108	michael	5052	;
109
110			config_items: irc_entry \|
111			options_entry \|
112			opm_entry \|
113			user_entry \|
114			scanner_entry \|
115			exempt_entry;
116
117	michael	5080	timespec_: { $$ = 0; } \| timespec;
118			timespec: NUMBER timespec_ { $$ = $1 + $2; } \|
119			NUMBER SECONDS timespec_ { $$ = $1 + $3; } \|
120			NUMBER MINUTES timespec_ { $$ = $1 * 60 + $3; } \|
121			NUMBER HOURS timespec_ { $$ = $1 * 60 * 60 + $3; } \|
122			NUMBER DAYS timespec_ { $$ = $1 * 60 * 60 * 24 + $3; } \|
123			NUMBER WEEKS timespec_ { $$ = $1 * 60 * 60 * 24 * 7 + $3; } \|
124			NUMBER MONTHS timespec_ { $$ = $1 * 60 * 60 * 24 * 7 * 4 + $3; } \|
125			NUMBER YEARS timespec_ { $$ = $1 * 60 * 60 * 24 * 365 + $3; }
126			;
127	michael	5052
128	michael	6049	sizespec_: { $$ = 0; } \| sizespec;
129			sizespec: NUMBER sizespec_ { $$ = $1 + $2; } \|
130			NUMBER BYTES sizespec_ { $$ = $1 + $3; } \|
131			NUMBER KBYTES sizespec_ { $$ = $1 * 1024 + $3; } \|
132			NUMBER MBYTES sizespec_ { $$ = $1 * 1024 * 1024 + $3; }
133			;
134	michael	5080
135	michael	6049
136	michael	5052	/************************* OPTIONS BLOCK *********************/
137			options_entry: OPTIONS '{' options_items '}' ';';
138
139	michael	5068	options_items: options_items options_item \|
140	michael	5052	options_item;
141
142	michael	7014	options_item: options_negcache \|
143			options_negcache_rebuild \|
144			options_pidfile \|
145			options_dns_fdlimit \|
146			options_dns_timeout \|
147			options_scanlog \|
148			options_command_queue_size \|
149			options_command_interval \|
150			options_command_timeout \|
151	michael	5052	error;
152
153	michael	5080	options_negcache: NEGCACHE '=' timespec ';'
154	michael	5052	{
155	michael	5650	OptionsItem->negcache = $3;
156	michael	5052	};
157
158	michael	5332	options_negcache_rebuild: NEGCACHE_REBUILD '=' timespec ';'
159			{
160	michael	5650	OptionsItem->negcache_rebuild = $3;
161	michael	5332	};
162
163	michael	5052	options_pidfile: PIDFILE '=' STRING ';'
164			{
165	michael	5650	xfree(OptionsItem->pidfile);
166			OptionsItem->pidfile = xstrdup($3);
167	michael	5052	};
168
169			options_dns_fdlimit: DNS_FDLIMIT '=' NUMBER ';'
170			{
171	michael	5650	OptionsItem->dns_fdlimit = $3;
172	michael	5052	};
173
174	michael	6200	options_dns_timeout: DNS_TIMEOUT '=' timespec ';'
175			{
176			OptionsItem->dns_timeout = $3;
177			};
178
179	michael	5052	options_scanlog: SCANLOG '=' STRING ';'
180			{
181	michael	5650	xfree(OptionsItem->scanlog);
182			OptionsItem->scanlog = xstrdup($3);
183	michael	5052	};
184
185	michael	7014	options_command_queue_size: COMMAND_QUEUE_SIZE '=' NUMBER ';'
186			{
187			OptionsItem->command_queue_size = $3;
188			};
189	michael	6049
190	michael	7014	options_command_interval: COMMAND_INTERVAL '=' timespec ';'
191			{
192			OptionsItem->command_interval = $3;
193			};
194
195			options_command_timeout: COMMAND_TIMEOUT '=' timespec ';'
196			{
197			OptionsItem->command_timeout = $3;
198			};
199
200
201	michael	5052	/************************* IRC BLOCK *************************/
202	michael	5650	irc_entry: IRC '{' irc_items '}' ';';
203	michael	5052
204			irc_items: irc_items irc_item \|
205			irc_item;
206
207	michael	6078	irc_item: irc_away \|
208			irc_connregex \|
209			irc_kline \|
210			irc_nick \|
211			irc_nickserv \|
212			irc_mode \|
213			irc_oper \|
214			irc_password \|
215			irc_port \|
216			irc_readtimeout \|
217			irc_reconnectinterval \|
218			irc_realname \|
219			irc_server \|
220			irc_username \|
221			irc_vhost \|
222			irc_perform \|
223			irc_notice \|
224			channel_entry \|
225	michael	5052	error;
226
227			irc_away: AWAY '=' STRING ';'
228			{
229	michael	5650	xfree(IRCItem->away);
230			IRCItem->away = xstrdup($3);
231	michael	5052	};
232
233			irc_kline: KLINE '=' STRING ';'
234			{
235	michael	5650	xfree(IRCItem->kline);
236			IRCItem->kline = xstrdup($3);
237	michael	5052	};
238
239			irc_mode: MODE '=' STRING ';'
240			{
241	michael	5650	xfree(IRCItem->mode);
242			IRCItem->mode = xstrdup($3);
243	michael	5052	};
244
245			irc_nick: NICK '=' STRING ';'
246			{
247	michael	5650	xfree(IRCItem->nick);
248			IRCItem->nick = xstrdup($3);
249	michael	5052	};
250
251			irc_nickserv: NICKSERV '=' STRING ';'
252			{
253	michael	5650	xfree(IRCItem->nickserv);
254			IRCItem->nickserv = xstrdup($3);
255	michael	5052	};
256
257			irc_oper: OPER '=' STRING ';'
258			{
259	michael	5650	xfree(IRCItem->oper);
260			IRCItem->oper = xstrdup($3);
261	michael	5052	};
262
263			irc_password: PASSWORD '=' STRING ';'
264			{
265	michael	5650	xfree(IRCItem->password);
266			IRCItem->password = xstrdup($3);
267	michael	5052	};
268
269			irc_perform: PERFORM '=' STRING ';'
270			{
271	michael	5650	node_t *node;
272	michael	5052
273	michael	5650	node = node_create(xstrdup($3));
274			list_add(IRCItem->performs, node);
275	michael	5052	};
276
277	michael	5405	irc_notice: NOTICE '=' STRING ';'
278			{
279	michael	5650	node_t *node;
280	michael	5405
281	michael	5650	node = node_create(xstrdup($3));
282			list_add(IRCItem->notices, node);
283	michael	5405	};
284
285	michael	5052	irc_port: PORT '=' NUMBER ';'
286			{
287	michael	5650	IRCItem->port = $3;
288	michael	5052	};
289
290	michael	5198	irc_readtimeout: READTIMEOUT '=' timespec ';'
291			{
292	michael	5650	IRCItem->readtimeout = $3;
293	michael	5198	};
294
295	michael	6078	irc_reconnectinterval: RECONNECTINTERVAL '=' timespec ';'
296			{
297			IRCItem->reconnectinterval = $3;
298			};
299
300	michael	5052	irc_realname: REALNAME '=' STRING ';'
301			{
302	michael	5650	xfree(IRCItem->realname);
303			IRCItem->realname = xstrdup($3);
304	michael	5052	};
305
306			irc_server: SERVER '=' STRING ';'
307			{
308	michael	5650	xfree(IRCItem->server);
309			IRCItem->server = xstrdup($3);
310	michael	5052	};
311
312			irc_username: USERNAME '=' STRING ';'
313			{
314	michael	5650	xfree(IRCItem->username);
315			IRCItem->username = xstrdup($3);
316	michael	5052	};
317
318			irc_vhost: VHOST '=' STRING ';'
319			{
320	michael	5650	xfree(IRCItem->vhost);
321			IRCItem->vhost = xstrdup($3);
322	michael	5052	};
323
324			irc_connregex: CONNREGEX '=' STRING ';'
325			{
326	michael	5650	xfree(IRCItem->connregex);
327			IRCItem->connregex = xstrdup($3);
328	michael	5052	};
329
330
331			/************************ CHANNEL BLOCK ***********************/
332	michael	5650	channel_entry:
333	michael	5052	{
334	michael	5650	node_t *node;
335			struct ChannelConf *item;
336	michael	5052
337	michael	6149	item = xcalloc(sizeof(*item));
338	michael	5650	item->name = xstrdup("");
339			item->key = xstrdup("");
340			item->invite = xstrdup("");
341	michael	5052
342	michael	5650	node = node_create(item);
343	michael	5052
344	michael	5650	list_add(IRCItem->channels, node);
345			tmp = item;
346	michael	5052	}
347			CHANNEL '{' channel_items '}' ';';
348
349			channel_items: channel_items channel_item \|
350			channel_item;
351
352			channel_item: channel_name \|
353			channel_key \|
354			channel_invite;
355
356			channel_name: NAME '=' STRING ';'
357			{
358	michael	5650	struct ChannelConf *item = tmp;
359	michael	5052
360	michael	5650	xfree(item->name);
361			item->name = xstrdup($3);
362	michael	5052	};
363
364			channel_key: KEY '=' STRING ';'
365			{
366	michael	5650	struct ChannelConf *item = tmp;
367	michael	5052
368	michael	5650	xfree(item->key);
369			item->key = xstrdup($3);
370	michael	5052	};
371
372			channel_invite: INVITE '=' STRING ';'
373			{
374	michael	5650	struct ChannelConf *item = tmp;
375	michael	5052
376	michael	5650	xfree(item->invite);
377			item->invite = xstrdup($3);
378	michael	5052	};
379
380	michael	6049
381	michael	5052	/************************* USER BLOCK *************************/
382	michael	5650	user_entry:
383	michael	5052	{
384	michael	5650	node_t *node;
385			struct UserConf *item;
386	michael	5052
387	michael	6149	item = xcalloc(sizeof(*item));
388	michael	5650	item->masks = list_create();
389			item->scanners = list_create();
390	michael	5052
391	michael	5650	node = node_create(item);
392	michael	5052
393	michael	5650	list_add(UserItemList, node);
394			tmp = item;
395			}
396			USER '{' user_items '}' ';' ;
397	michael	5052
398			user_items: user_items user_item \|
399	michael	5650	user_item;
400	michael	5052
401			user_item: user_mask \|
402			user_scanner \|
403	michael	5650	error;
404	michael	5052
405			user_mask: MASK '=' STRING ';'
406			{
407	michael	5650	struct UserConf *item = tmp;
408			node_t *node;
409	michael	5052
410	michael	5650	node = node_create(xstrdup($3));
411	michael	5249
412	michael	5650	list_add(item->masks, node);
413	michael	5052	};
414
415			user_scanner: SCANNER '=' STRING ';'
416			{
417	michael	5650	struct UserConf *item = tmp;
418			node_t *node;
419	michael	5052
420	michael	5650	node = node_create(xstrdup($3));
421	michael	5249
422	michael	5650	list_add(item->scanners, node);
423	michael	5052	};
424
425	michael	6049
426	michael	5052	/************************* SCANNER BLOCK *************************/
427			scanner_entry:
428			{
429	michael	5650	node_t *node;
430			struct ScannerConf item, olditem;
431	michael	5052
432	michael	6149	item = xcalloc(sizeof(*item));
433	michael	5052
434	michael	5650	/* Setup ScannerConf defaults */
435			item->name = xstrdup("undefined");
436	michael	5052
437	michael	5650	if (LIST_SIZE(ScannerItemList) > 0)
438			{
439			olditem = ScannerItemList->tail->data;
440	michael	5052
441	michael	5650	item->vhost = xstrdup(olditem->vhost);
442			item->fd = olditem->fd;
443			item->target_ip = xstrdup(olditem->target_ip);
444			item->target_port = olditem->target_port;
445			item->timeout = olditem->timeout;
446			item->max_read = olditem->max_read;
447			item->target_string = olditem->target_string;
448			item->target_string_created = 0;
449			}
450			else
451			{
452			item->vhost = xstrdup("0.0.0.0");
453			item->fd = 512;
454			item->target_ip = xstrdup("127.0.0.1");
455			item->target_port = 6667;
456			item->timeout = 30;
457			item->max_read = 4096;
458			item->target_string = list_create();
459			item->target_string_created = 1;
460			}
461	michael	5052
462	michael	5650	item->protocols = list_create();
463	michael	5052
464	michael	5650	node = node_create(item);
465	michael	5052
466	michael	5650	list_add(ScannerItemList, node);
467			tmp = item;
468	michael	5052	}
469	michael	5650	SCANNER '{' scanner_items '}' ';' ;
470	michael	5052
471			scanner_items: scanner_items scanner_item \|
472			scanner_item;
473
474			scanner_item: scanner_name \|
475			scanner_vhost \|
476			scanner_fd \|
477			scanner_target_ip \|
478			scanner_target_port \|
479			scanner_target_string \|
480			scanner_protocol \|
481			scanner_timeout \|
482			scanner_max_read \|
483			error;
484
485			scanner_name: NAME '=' STRING ';'
486			{
487	michael	5650	struct ScannerConf *item = tmp;
488
489			xfree(item->name);
490			item->name = xstrdup($3);
491	michael	5052	};
492
493			scanner_vhost: VHOST '=' STRING ';'
494			{
495	michael	5650	struct ScannerConf *item = tmp;
496
497			xfree(item->vhost);
498			item->vhost = xstrdup($3);
499	michael	5052	};
500
501			scanner_target_ip: TARGET_IP '=' STRING ';'
502			{
503	michael	5650	struct ScannerConf *item = tmp;
504
505			xfree(item->target_ip);
506			item->target_ip = xstrdup($3);
507	michael	5052	};
508
509			scanner_target_string: TARGET_STRING '=' STRING ';'
510			{
511	michael	5650	struct ScannerConf *item = tmp;
512			node_t *node;
513	michael	5052
514	michael	7559	node = node_create(xstrdup($3));
515	michael	5052
516	michael	5650	if (item->target_string_created == 0)
517			{
518			item->target_string = list_create();
519			item->target_string_created = 1;
520			}
521	michael	5052
522	michael	5650	list_add(item->target_string, node);
523	michael	5052	};
524
525			scanner_fd: FD '=' NUMBER ';'
526			{
527	michael	5650	struct ScannerConf *item = tmp;
528
529			item->fd = $3;
530	michael	5052	};
531
532			scanner_target_port: TARGET_PORT '=' NUMBER ';'
533			{
534	michael	5650	struct ScannerConf *item = tmp;
535
536			item->target_port = $3;
537	michael	5052	};
538
539	michael	5080	scanner_timeout: TIMEOUT '=' timespec ';'
540	michael	5052	{
541	michael	5650	struct ScannerConf *item = tmp;
542
543			item->timeout = $3;
544	michael	5052	};
545
546	michael	5080	scanner_max_read: MAX_READ '=' sizespec ';'
547	michael	5052	{
548	michael	5650	struct ScannerConf *item = tmp;
549
550			item->max_read = $3;
551	michael	5052	};
552
553			scanner_protocol: PROTOCOL '=' PROTOCOLTYPE ':' NUMBER ';'
554			{
555	michael	5650	struct ProtocolConf *item;
556			struct ScannerConf *item2;
557			node_t *node;
558	michael	5052
559	michael	6149	item = xcalloc(sizeof(*item));
560	michael	5650	item->type = $3;
561			item->port = $5;
562	michael	5052
563	michael	5650	item2 = tmp;
564
565			node = node_create(item);
566			list_add(item2->protocols, node);
567	michael	5052	};
568
569	michael	6049
570	michael	5052	/************************* OPM BLOCK *************************/
571	michael	5650	opm_entry: OPM '{' opm_items '}' ';' ;
572	michael	5052
573	michael	5068	opm_items: opm_items opm_item \|
574	michael	5052	opm_item;
575
576			opm_item: opm_dnsbl_from \|
577			opm_dnsbl_to \|
578			opm_sendmail \|
579			opm_blacklist_entry \|
580			error;
581
582			opm_dnsbl_from: DNSBL_FROM '=' STRING ';'
583			{
584	michael	5650	xfree(OpmItem->dnsbl_from);
585			OpmItem->dnsbl_from = xstrdup($3);
586	michael	5052	};
587
588			opm_dnsbl_to: DNSBL_TO '=' STRING ';'
589			{
590	michael	5650	xfree(OpmItem->dnsbl_to);
591			OpmItem->dnsbl_to = xstrdup($3);
592	michael	5052	};
593
594			opm_sendmail: SENDMAIL '=' STRING ';'
595			{
596	michael	5650	xfree(OpmItem->sendmail);
597			OpmItem->sendmail = xstrdup($3);
598	michael	5052	};
599
600	michael	6049
601	michael	5052	/************************ BLACKLIST BLOCK ***********************/
602			opm_blacklist_entry:
603			{
604	michael	5650	node_t *node;
605			struct BlacklistConf *item;
606	michael	5052
607	michael	6149	item = xcalloc(sizeof(*item));
608	michael	5650	item->name = xstrdup("");
609			item->kline = xstrdup("");
610	michael	8098	item->ipv4 = 1;
611	michael	5650	item->ban_unknown = 0;
612			item->type = A_BITMASK;
613			item->reply = list_create();
614	michael	5052
615	michael	5650	node = node_create(item);
616			list_add(OpmItem->blacklists, node);
617	michael	5052
618	michael	5650	tmp = item;
619	michael	5052	}
620			BLACKLIST '{' blacklist_items '}' ';';
621
622	michael	5068	blacklist_items: blacklist_items blacklist_item \|
623			blacklist_item;
624	michael	5052
625	michael	8098	blacklist_item: blacklist_name \|
626			blacklist_address_family \|
627			blacklist_type \|
628			blacklist_kline \|
629			blacklist_ban_unknown \|
630			blacklist_reply \|
631	michael	5052	error;
632
633	michael	5650	blacklist_name: NAME '=' STRING ';'
634			{
635			struct BlacklistConf *item = tmp;
636	michael	5052
637	michael	5650	xfree(item->name);
638			item->name = xstrdup($3);
639	michael	5052	};
640
641	michael	8098	blacklist_address_family: ADDRESS_FAMILY
642			{
643			struct BlacklistConf *item = tmp;
644
645			item->ipv4 = 0;
646			item->ipv6 = 0;
647			} '=' blacklist_address_family_items ';' ;
648
649			blacklist_address_family_items: blacklist_address_family_items ',' blacklist_address_family_item \| blacklist_address_family_item;
650			blacklist_address_family_item: IPV4
651			{
652			struct BlacklistConf *item = tmp;
653
654			item->ipv4 = 1;
655			} \| IPV6
656			{
657			struct BlacklistConf *item = tmp;
658
659			item->ipv6 = 1;
660			};
661
662	michael	5650	blacklist_kline: KLINE '=' STRING ';'
663			{
664			struct BlacklistConf *item = tmp;
665	michael	5052
666	michael	5650	xfree(item->kline);
667			item->kline = xstrdup($3);
668	michael	5052	};
669
670	michael	5650	blacklist_type: TYPE '=' STRING ';'
671			{
672			struct BlacklistConf *item = tmp;
673
674			if (strcmp("A record bitmask", $3) == 0)
675			item->type = A_BITMASK;
676			else if (strcmp("A record reply", $3) == 0)
677			item->type = A_REPLY;
678			else
679			yyerror("Unknown blacklist type defined");
680	michael	5052	};
681
682	michael	5650	blacklist_ban_unknown: BAN_UNKNOWN '=' NUMBER ';'
683			{
684	michael	6049	struct BlacklistConf *item = tmp;
685	michael	5052
686	michael	6049	item->ban_unknown = $3;
687	michael	5052	};
688
689			blacklist_reply: REPLY '{' blacklist_reply_items '}' ';';
690
691	michael	5068	blacklist_reply_items: blacklist_reply_items blacklist_reply_item \|
692	michael	5052	blacklist_reply_item;
693
694			blacklist_reply_item: NUMBER '=' STRING ';'
695			{
696	michael	5650	struct BlacklistReplyConf *item;
697			struct BlacklistConf *blacklist = tmp;
698			node_t *node;
699	michael	5052
700	michael	6149	item = xcalloc(sizeof(*item));
701	michael	5650	item->number = $1;
702			item->type = xstrdup($3);
703	michael	5052
704	michael	5650	node = node_create(item);
705			list_add(blacklist->reply, node);
706	michael	5052	};
707
708	michael	6049
709	michael	5052	/************************* EXEMPT BLOCK *************************/
710	michael	5650	exempt_entry: EXEMPT '{' exempt_items '}' ';' ;
711	michael	5052
712	michael	5068	exempt_items: exempt_items exempt_item \|
713	michael	5052	exempt_item;
714
715	michael	6049	exempt_item: exempt_mask \|
716	michael	5052	error;
717
718			exempt_mask: MASK '=' STRING ';'
719			{
720	michael	5650	node_t *node;
721			node = node_create(xstrdup($3));
722	michael	5052
723	michael	5650	list_add(ExemptItem->masks, node);
724	michael	5052	};
725
726			%%