ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.y
(Generate patch)

Comparing ircd-hybrid/trunk/src/conf_parser.y (file contents):
Revision 5800 by michael, Fri Apr 17 18:55:55 2015 UTC vs.
Revision 9692 by michael, Sat Oct 31 19:05:15 2020 UTC

# Line 1 | Line 1
1   /*
2   *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (c) 2000-2015 ircd-hybrid development team
4 > *  Copyright (c) 2000-2020 ircd-hybrid development team
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 27 | Line 27
27  
28   %{
29  
30 – #include <sys/types.h>
31 – #include <string.h>
32 –
30   #include "config.h"
31   #include "stdinc.h"
32   #include "ircd.h"
33   #include "list.h"
34 + #include "parse.h"
35   #include "conf.h"
36   #include "conf_class.h"
37 + #include "conf_cluster.h"
38 + #include "conf_gecos.h"
39   #include "conf_pseudo.h"
40 + #include "conf_resv.h"
41 + #include "conf_service.h"
42 + #include "conf_shared.h"
43   #include "event.h"
44 + #include "id.h"
45   #include "log.h"
42 – #include "client.h"     /* for UMODE_ALL only */
46   #include "irc_string.h"
47   #include "memory.h"
48   #include "modules.h"
49   #include "server.h"
50   #include "hostmask.h"
48 – #include "send.h"
51   #include "listener.h"
50 – #include "resv.h"
51 – #include "numeric.h"
52   #include "user.h"
53   #include "motd.h"
54  
55 – #ifdef HAVE_LIBCRYPTO
56 – #include <openssl/rsa.h>
57 – #include <openssl/bio.h>
58 – #include <openssl/pem.h>
59 – #include <openssl/dh.h>
60 – #endif
61 –
62 – #include "rsa.h"
63 –
55   int yylex(void);
56  
57   static struct
# Line 100 | Line 91 | static struct
91      size,
92      type,
93      port,
94 +    timeout,
95      aftype,
96      ping_freq,
97 <    max_perip,
97 >    max_perip_local,
98 >    max_perip_global,
99      con_freq,
100      min_idle,
101      max_idle,
102      max_total,
110 –    max_global,
111 –    max_local,
112 –    max_ident,
103      max_sendq,
104      max_recvq,
105      max_channels,
# Line 121 | Line 111 | static struct
111   static void
112   reset_block_state(void)
113   {
114 <  dlink_node *node = NULL, *node_next = NULL;
114 >  dlink_node *node, *node_next;
115 >  dlink_list *tab[] = { &block_state.mask.list,
116 >                        &block_state.leaf.list, &block_state.hub.list, NULL };
117  
118 <  DLINK_FOREACH_SAFE(node, node_next, block_state.mask.list.head)
118 >  for (dlink_list **list = tab; *list; ++list)
119    {
120 <    MyFree(node->data);
121 <    dlinkDelete(node, &block_state.mask.list);
122 <    free_dlink_node(node);
123 <  }
124 <
125 <  DLINK_FOREACH_SAFE(node, node_next, block_state.leaf.list.head)
134 <  {
135 <    MyFree(node->data);
136 <    dlinkDelete(node, &block_state.leaf.list);
137 <    free_dlink_node(node);
138 <  }
139 <
140 <  DLINK_FOREACH_SAFE(node, node_next, block_state.hub.list.head)
141 <  {
142 <    MyFree(node->data);
143 <    dlinkDelete(node, &block_state.hub.list);
144 <    free_dlink_node(node);
120 >    DLINK_FOREACH_SAFE(node, node_next, (*list)->head)
121 >    {
122 >      xfree(node->data);
123 >      dlinkDelete(node, *list);
124 >      free_dlink_node(node);
125 >    }
126    }
127  
128    memset(&block_state, 0, sizeof(block_state));
# Line 169 | Line 150 | reset_block_state(void)
150   %token  CIDR_BITLEN_IPV4
151   %token  CIDR_BITLEN_IPV6
152   %token  CLASS
153 + %token  CLIENT
154 + %token  CLOSE
155   %token  CONNECT
156   %token  CONNECTFREQ
157   %token  CYCLE_ON_HOST_CHANGE
158   %token  DEFAULT_FLOODCOUNT
159 + %token  DEFAULT_FLOODTIME
160   %token  DEFAULT_JOIN_FLOOD_COUNT
161   %token  DEFAULT_JOIN_FLOOD_TIME
162   %token  DEFAULT_MAX_CLIENTS
163 < %token  DEFAULT_SPLIT_SERVER_COUNT
180 < %token  DEFAULT_SPLIT_USER_COUNT
163 > %token  DEFER
164   %token  DENY
165   %token  DESCRIPTION
166   %token  DIE
167   %token  DISABLE_AUTH
168   %token  DISABLE_FAKE_CHANNELS
169   %token  DISABLE_REMOTE_COMMANDS
170 + %token  DLINE_MIN_CIDR
171 + %token  DLINE_MIN_CIDR6
172   %token  DOTS_IN_IDENT
173   %token  EMAIL
174 + %token  ENABLE_EXTBANS
175   %token  ENCRYPTED
176   %token  EXCEED_LIMIT
177   %token  EXEMPT
178 + %token  EXPIRATION
179   %token  FAILED_OPER_NOTICE
180   %token  FLATTEN_LINKS
181 + %token  FLATTEN_LINKS_DELAY
182 + %token  FLATTEN_LINKS_FILE
183   %token  GECOS
184   %token  GENERAL
196 – %token  GLINE
197 – %token  GLINE_DURATION
198 – %token  GLINE_ENABLE
199 – %token  GLINE_EXEMPT
200 – %token  GLINE_MIN_CIDR
201 – %token  GLINE_MIN_CIDR6
202 – %token  GLINE_REQUEST_DURATION
203 – %token  HAVENT_READ_CONF
185   %token  HIDDEN
186   %token  HIDDEN_NAME
187   %token  HIDE_CHANS
# Line 212 | Line 193 | reset_block_state(void)
193   %token  HOST
194   %token  HUB
195   %token  HUB_MASK
215 – %token  IGNORE_BOGUS_TS
196   %token  INVISIBLE_ON_CONNECT
197   %token  INVITE_CLIENT_COUNT
198   %token  INVITE_CLIENT_TIME
199 + %token  INVITE_DELAY_CHANNEL
200 + %token  INVITE_EXPIRE_TIME
201   %token  IP
202   %token  IRCD_AUTH
203   %token  IRCD_FLAGS
204   %token  IRCD_SID
205 + %token  JOIN
206   %token  KILL
207   %token  KILL_CHASE_TIME_LIMIT
208   %token  KLINE
209   %token  KLINE_EXEMPT
210 + %token  KLINE_MIN_CIDR
211 + %token  KLINE_MIN_CIDR6
212   %token  KNOCK_CLIENT_COUNT
213   %token  KNOCK_CLIENT_TIME
214   %token  KNOCK_DELAY_CHANNEL
215   %token  LEAF_MASK
231 – %token  LINKS_DELAY
216   %token  LISTEN
217   %token  MASK
218   %token  MAX_ACCEPT
219   %token  MAX_BANS
220 + %token  MAX_BANS_LARGE
221   %token  MAX_CHANNELS
237 – %token  MAX_GLOBAL
238 – %token  MAX_IDENT
222   %token  MAX_IDLE
223 < %token  MAX_LOCAL
223 > %token  MAX_INVITES
224   %token  MAX_NICK_CHANGES
225   %token  MAX_NICK_LENGTH
226   %token  MAX_NICK_TIME
# Line 254 | Line 237 | reset_block_state(void)
237   %token  NAME
238   %token  NEED_IDENT
239   %token  NEED_PASSWORD
240 < %token  NETWORK_DESC
240 > %token  NETWORK_DESCRIPTION
241   %token  NETWORK_NAME
242   %token  NICK
260 – %token  NO_CREATE_ON_SPLIT
261 – %token  NO_JOIN_ON_SPLIT
243   %token  NO_OPER_FLOOD
244   %token  NO_TILDE
245   %token  NUMBER
246   %token  NUMBER_PER_CIDR
247 < %token  NUMBER_PER_IP
247 > %token  NUMBER_PER_IP_GLOBAL
248 > %token  NUMBER_PER_IP_LOCAL
249   %token  OPER_ONLY_UMODES
268 – %token  OPER_PASS_RESV
250   %token  OPER_UMODES
251   %token  OPERATOR
252   %token  OPERS_BYPASS_CALLERID
# Line 287 | Line 268 | reset_block_state(void)
268   %token  RESV
269   %token  RESV_EXEMPT
270   %token  RSA_PRIVATE_KEY_FILE
290 – %token  RSA_PUBLIC_KEY_FILE
271   %token  SECONDS MINUTES HOURS DAYS WEEKS MONTHS YEARS
272   %token  SEND_PASSWORD
273   %token  SENDQ
# Line 295 | Line 275 | reset_block_state(void)
275   %token  SERVERINFO
276   %token  SHORT_MOTD
277   %token  SPOOF
298 – %token  SPOOF_NOTICE
278   %token  SQUIT
300 – %token  SSL_CERTIFICATE_FILE
301 – %token  SSL_CERTIFICATE_FINGERPRINT
302 – %token  SSL_CONNECTION_REQUIRED
303 – %token  SSL_DH_ELLIPTIC_CURVE
304 – %token  SSL_DH_PARAM_FILE
305 – %token  SSL_MESSAGE_DIGEST_ALGORITHM
279   %token  STATS_E_DISABLED
280   %token  STATS_I_OPER_ONLY
281   %token  STATS_K_OPER_ONLY
# Line 311 | Line 284 | reset_block_state(void)
284   %token  STATS_P_OPER_ONLY
285   %token  STATS_U_OPER_ONLY
286   %token  T_ALL
287 < %token  T_BOTS
287 > %token  T_BIND
288   %token  T_CALLERID
289   %token  T_CCONN
290   %token  T_COMMAND
# Line 322 | Line 295 | reset_block_state(void)
295   %token  T_EXTERNAL
296   %token  T_FARCONNECT
297   %token  T_FILE
298 < %token  T_FULL
298 > %token  T_FLOOD
299   %token  T_GLOBOPS
300   %token  T_INVISIBLE
301   %token  T_IPV4
# Line 346 | Line 319 | reset_block_state(void)
319   %token  T_SKILL
320   %token  T_SOFTCALLERID
321   %token  T_SPY
349 – %token  T_SSL
350 – %token  T_SSL_CIPHER_LIST
322   %token  T_TARGET
323 + %token  T_TLS
324   %token  T_UMODES
353 – %token  T_UNAUTH
325   %token  T_UNDLINE
326   %token  T_UNLIMITED
327   %token  T_UNRESV
# Line 361 | Line 332 | reset_block_state(void)
332   %token  TBOOL
333   %token  THROTTLE_COUNT
334   %token  THROTTLE_TIME
335 < %token  TKLINE_EXPIRE_NOTICES
336 < %token  TMASKED
335 > %token  TIMEOUT
336 > %token  TLS_CERTIFICATE_FILE
337 > %token  TLS_CERTIFICATE_FINGERPRINT
338 > %token  TLS_CIPHER_LIST
339 > %token  TLS_CIPHER_SUITES
340 > %token  TLS_CONNECTION_REQUIRED
341 > %token  TLS_DH_PARAM_FILE
342 > %token  TLS_MESSAGE_DIGEST_ALGORITHM
343 > %token  TLS_SUPPORTED_GROUPS
344   %token  TS_MAX_DELTA
345   %token  TS_WARN_DELTA
346   %token  TWODOTS
# Line 374 | Line 352 | reset_block_state(void)
352   %token  VHOST6
353   %token  WARN_NO_CONNECT_BLOCK
354   %token  WHOIS
355 + %token  WHOWAS_HISTORY_LENGTH
356   %token  XLINE
357 + %token  XLINE_EXEMPT
358  
359   %type  <string> QSTRING
360   %type  <number> NUMBER
# Line 435 | Line 415 | sizespec:   NUMBER sizespec_ { $$ = $1 +
415  
416  
417   /***************************************************************************
418 < *  section modules
418 > * modules {} section
419   ***************************************************************************/
420 < modules_entry: MODULES
441 <  '{' modules_items '}' ';';
420 > modules_entry: MODULES '{' modules_items '}' ';';
421  
422   modules_items:  modules_items modules_item | modules_item;
423   modules_item:   modules_module | modules_path | error ';' ;
# Line 456 | Line 435 | modules_path: PATH '=' QSTRING ';'
435   };
436  
437  
438 + /***************************************************************************
439 + * serverinfo {} section
440 + ***************************************************************************/
441   serverinfo_entry: SERVERINFO '{' serverinfo_items '}' ';';
442  
443   serverinfo_items:       serverinfo_items serverinfo_item | serverinfo_item ;
444   serverinfo_item:        serverinfo_name |
463 –                        serverinfo_vhost |
445                          serverinfo_hub |
446                          serverinfo_description |
447                          serverinfo_network_name |
448 <                        serverinfo_network_desc |
448 >                        serverinfo_network_description |
449                          serverinfo_default_max_clients |
450                          serverinfo_max_nick_length |
451                          serverinfo_max_topic_length |
452 <                        serverinfo_ssl_dh_param_file |
453 <                        serverinfo_ssl_dh_elliptic_curve |
452 >                        serverinfo_tls_dh_param_file |
453 >                        serverinfo_tls_supported_groups |
454                          serverinfo_rsa_private_key_file |
474 –                        serverinfo_vhost6 |
455                          serverinfo_sid |
456 <                        serverinfo_ssl_certificate_file |
457 <                        serverinfo_ssl_cipher_list |
458 <                        serverinfo_ssl_message_digest_algorithm |
456 >                        serverinfo_tls_certificate_file |
457 >                        serverinfo_tls_cipher_list |
458 >                        serverinfo_tls_cipher_suites |
459 >                        serverinfo_tls_message_digest_algorithm |
460                          error ';' ;
461  
462  
463 < serverinfo_ssl_certificate_file: SSL_CERTIFICATE_FILE '=' QSTRING ';'
463 > serverinfo_tls_certificate_file: TLS_CERTIFICATE_FILE '=' QSTRING ';'
464   {
484 – #ifdef HAVE_LIBCRYPTO
465    if (conf_parser_ctx.pass == 2)
466    {
467 <    if (!ConfigServerInfo.rsa_private_key_file)
468 <    {
489 <      conf_error_report("No rsa_private_key_file specified, SSL disabled");
490 <      break;
491 <    }
492 <
493 <    if (SSL_CTX_use_certificate_chain_file(ConfigServerInfo.server_ctx, yylval.string) <= 0 ||
494 <        SSL_CTX_use_certificate_chain_file(ConfigServerInfo.client_ctx, yylval.string) <= 0)
495 <    {
496 <      report_crypto_errors();
497 <      conf_error_report("Could not open/read certificate file");
498 <      break;
499 <    }
500 <
501 <    if (SSL_CTX_use_PrivateKey_file(ConfigServerInfo.server_ctx, ConfigServerInfo.rsa_private_key_file,
502 <                                    SSL_FILETYPE_PEM) <= 0 ||
503 <        SSL_CTX_use_PrivateKey_file(ConfigServerInfo.client_ctx, ConfigServerInfo.rsa_private_key_file,
504 <                                    SSL_FILETYPE_PEM) <= 0)
505 <    {
506 <      report_crypto_errors();
507 <      conf_error_report("Could not read RSA private key");
508 <      break;
509 <    }
510 <
511 <    if (!SSL_CTX_check_private_key(ConfigServerInfo.server_ctx) ||
512 <        !SSL_CTX_check_private_key(ConfigServerInfo.client_ctx))
513 <    {
514 <      report_crypto_errors();
515 <      conf_error_report("Could not read RSA private key");
516 <      break;
517 <    }
467 >    xfree(ConfigServerInfo.tls_certificate_file);
468 >    ConfigServerInfo.tls_certificate_file = xstrdup(yylval.string);
469    }
519 – #endif
470   };
471  
472   serverinfo_rsa_private_key_file: RSA_PRIVATE_KEY_FILE '=' QSTRING ';'
473   {
474 < #ifdef HAVE_LIBCRYPTO
525 <  BIO *file = NULL;
526 <
527 <  if (conf_parser_ctx.pass != 1)
528 <    break;
529 <
530 <  if (ConfigServerInfo.rsa_private_key)
531 <  {
532 <    RSA_free(ConfigServerInfo.rsa_private_key);
533 <    ConfigServerInfo.rsa_private_key = NULL;
534 <  }
535 <
536 <  if (ConfigServerInfo.rsa_private_key_file)
537 <  {
538 <    MyFree(ConfigServerInfo.rsa_private_key_file);
539 <    ConfigServerInfo.rsa_private_key_file = NULL;
540 <  }
541 <
542 <  ConfigServerInfo.rsa_private_key_file = xstrdup(yylval.string);
543 <
544 <  if ((file = BIO_new_file(yylval.string, "r")) == NULL)
545 <  {
546 <    conf_error_report("File open failed, ignoring");
547 <    break;
548 <  }
549 <
550 <  ConfigServerInfo.rsa_private_key = PEM_read_bio_RSAPrivateKey(file, NULL, 0, NULL);
551 <
552 <  BIO_set_close(file, BIO_CLOSE);
553 <  BIO_free(file);
554 <
555 <  if (ConfigServerInfo.rsa_private_key == NULL)
474 >  if (conf_parser_ctx.pass == 2)
475    {
476 <    conf_error_report("Couldn't extract key, ignoring");
477 <    break;
559 <  }
560 <
561 <  if (!RSA_check_key(ConfigServerInfo.rsa_private_key))
562 <  {
563 <    RSA_free(ConfigServerInfo.rsa_private_key);
564 <    ConfigServerInfo.rsa_private_key = NULL;
565 <
566 <    conf_error_report("Invalid key, ignoring");
567 <    break;
476 >    xfree(ConfigServerInfo.rsa_private_key_file);
477 >    ConfigServerInfo.rsa_private_key_file = xstrdup(yylval.string);
478    }
479 + };
480  
481 <  if (RSA_size(ConfigServerInfo.rsa_private_key) < 128)
481 > serverinfo_tls_dh_param_file: TLS_DH_PARAM_FILE '=' QSTRING ';'
482 > {
483 >  if (conf_parser_ctx.pass == 2)
484    {
485 <    RSA_free(ConfigServerInfo.rsa_private_key);
486 <    ConfigServerInfo.rsa_private_key = NULL;
574 <
575 <    conf_error_report("Ignoring serverinfo::rsa_private_key_file -- need at least a 1024 bit key size");
485 >    xfree(ConfigServerInfo.tls_dh_param_file);
486 >    ConfigServerInfo.tls_dh_param_file = xstrdup(yylval.string);
487    }
577 – #endif
488   };
489  
490 < serverinfo_ssl_dh_param_file: SSL_DH_PARAM_FILE '=' QSTRING ';'
490 > serverinfo_tls_cipher_list: TLS_CIPHER_LIST '=' QSTRING ';'
491   {
582 – #ifdef HAVE_LIBCRYPTO
492    if (conf_parser_ctx.pass == 2)
493    {
494 <    BIO *file = BIO_new_file(yylval.string, "r");
495 <
587 <    if (file)
588 <    {
589 <      DH *dh = PEM_read_bio_DHparams(file, NULL, NULL, NULL);
590 <
591 <      BIO_free(file);
592 <
593 <      if (dh)
594 <      {
595 <        if (DH_size(dh) < 128)
596 <          conf_error_report("Ignoring serverinfo::ssl_dh_param_file -- need at least a 1024 bit DH prime size");
597 <        else
598 <          SSL_CTX_set_tmp_dh(ConfigServerInfo.server_ctx, dh);
599 <
600 <        DH_free(dh);
601 <      }
602 <    }
603 <    else
604 <      conf_error_report("Ignoring serverinfo::ssl_dh_param_file -- could not open/read Diffie-Hellman parameter file");
494 >    xfree(ConfigServerInfo.tls_cipher_list);
495 >    ConfigServerInfo.tls_cipher_list = xstrdup(yylval.string);
496    }
606 – #endif
497   };
498  
499 < serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
499 > serverinfo_tls_cipher_suites: TLS_CIPHER_SUITES '=' QSTRING ';'
500   {
611 – #ifdef HAVE_LIBCRYPTO
501    if (conf_parser_ctx.pass == 2)
502 <    SSL_CTX_set_cipher_list(ConfigServerInfo.server_ctx, yylval.string);
503 < #endif
502 >  {
503 >    xfree(ConfigServerInfo.tls_cipher_suites);
504 >    ConfigServerInfo.tls_cipher_suites = xstrdup(yylval.string);
505 >  }
506   };
507  
508 < serverinfo_ssl_message_digest_algorithm: SSL_MESSAGE_DIGEST_ALGORITHM '=' QSTRING ';'
508 > serverinfo_tls_message_digest_algorithm: TLS_MESSAGE_DIGEST_ALGORITHM '=' QSTRING ';'
509   {
619 – #ifdef HAVE_LIBCRYPTO
510    if (conf_parser_ctx.pass == 2)
511    {
512 <    if ((ConfigServerInfo.message_digest_algorithm = EVP_get_digestbyname(yylval.string)) == NULL)
513 <    {
624 <      ConfigServerInfo.message_digest_algorithm = EVP_sha256();
625 <      conf_error_report("Ignoring serverinfo::ssl_message_digest_algorithm -- unknown message digest algorithm");
626 <    }
512 >    xfree(ConfigServerInfo.tls_message_digest_algorithm);
513 >    ConfigServerInfo.tls_message_digest_algorithm = xstrdup(yylval.string);
514    }
628 – #endif
515   }
516  
517 < serverinfo_ssl_dh_elliptic_curve: SSL_DH_ELLIPTIC_CURVE '=' QSTRING ';'
517 > serverinfo_tls_supported_groups: TLS_SUPPORTED_GROUPS '=' QSTRING ';'
518   {
633 – #ifdef HAVE_LIBCRYPTO
634 – #if OPENSSL_VERSION_NUMBER >= 0x009080FFL && !defined(OPENSSL_NO_ECDH)
635 –  int nid = 0;
636 –  EC_KEY *key = NULL;
637 –
519    if (conf_parser_ctx.pass == 2)
520    {
521 <    if ((nid = OBJ_sn2nid(yylval.string)) == 0)
522 <    {
523 <        conf_error_report("Ignoring serverinfo::ssl_dh_elliptic_curve -- unknown curve name");
643 <        break;
644 <    }
645 <
646 <    if ((key = EC_KEY_new_by_curve_name(nid)) == NULL)
647 <    {
648 <      conf_error_report("Ignoring serverinfo::ssl_dh_elliptic_curve -- could not create curve");
649 <      break;
650 <    }
651 <
652 <    SSL_CTX_set_tmp_ecdh(ConfigServerInfo.server_ctx, key);
653 <    EC_KEY_free(key);
654 < }
655 < #endif
656 < #endif
521 >    xfree(ConfigServerInfo.tls_supported_groups);
522 >    ConfigServerInfo.tls_supported_groups = xstrdup(yylval.string);
523 >  }
524   };
525  
526   serverinfo_name: NAME '=' QSTRING ';'
527   {
528 <  /* this isn't rehashable */
529 <  if (conf_parser_ctx.pass == 2 && !ConfigServerInfo.name)
528 >  /* This isn't rehashable */
529 >  if (conf_parser_ctx.pass == 2 && ConfigServerInfo.name == NULL)
530    {
531 <    if (valid_servname(yylval.string))
531 >    if (server_valid_name(yylval.string) == true)
532        ConfigServerInfo.name = xstrdup(yylval.string);
533      else
534      {
535        conf_error_report("Ignoring serverinfo::name -- invalid name. Aborting.");
536 <      exit(0);
536 >      exit(EXIT_FAILURE);
537      }
538    }
539   };
540  
541   serverinfo_sid: IRCD_SID '=' QSTRING ';'
542   {
543 <  /* this isn't rehashable */
544 <  if (conf_parser_ctx.pass == 2 && !ConfigServerInfo.sid)
543 >  /* This isn't rehashable */
544 >  if (conf_parser_ctx.pass == 2 && ConfigServerInfo.sid == NULL)
545    {
546      if (valid_sid(yylval.string))
547        ConfigServerInfo.sid = xstrdup(yylval.string);
548      else
549      {
550        conf_error_report("Ignoring serverinfo::sid -- invalid SID. Aborting.");
551 <      exit(0);
551 >      exit(EXIT_FAILURE);
552      }
553    }
554   };
# Line 690 | Line 557 | serverinfo_description: DESCRIPTION '='
557   {
558    if (conf_parser_ctx.pass == 2)
559    {
560 <    MyFree(ConfigServerInfo.description);
560 >    xfree(ConfigServerInfo.description);
561      ConfigServerInfo.description = xstrdup(yylval.string);
562      strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
563    }
# Line 700 | Line 567 | serverinfo_network_name: NETWORK_NAME '=
567   {
568    if (conf_parser_ctx.pass == 2)
569    {
570 <    char *p;
570 >    char *p = strchr(yylval.string, ' ');
571  
572 <    if ((p = strchr(yylval.string, ' ')))
572 >    if (p)
573        *p = '\0';
574  
575 <    MyFree(ConfigServerInfo.network_name);
575 >    xfree(ConfigServerInfo.network_name);
576      ConfigServerInfo.network_name = xstrdup(yylval.string);
577    }
578   };
579  
580 < serverinfo_network_desc: NETWORK_DESC '=' QSTRING ';'
580 > serverinfo_network_description: NETWORK_DESCRIPTION '=' QSTRING ';'
581   {
582    if (conf_parser_ctx.pass != 2)
583      break;
584  
585 <  MyFree(ConfigServerInfo.network_desc);
586 <  ConfigServerInfo.network_desc = xstrdup(yylval.string);
720 < };
721 <
722 < serverinfo_vhost: VHOST '=' QSTRING ';'
723 < {
724 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
725 <  {
726 <    struct addrinfo hints, *res;
727 <
728 <    memset(&hints, 0, sizeof(hints));
729 <
730 <    hints.ai_family   = AF_UNSPEC;
731 <    hints.ai_socktype = SOCK_STREAM;
732 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
733 <
734 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
735 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
736 <    else
737 <    {
738 <      assert(res);
739 <
740 <      memcpy(&ConfigServerInfo.ip, res->ai_addr, res->ai_addrlen);
741 <      ConfigServerInfo.ip.ss.ss_family = res->ai_family;
742 <      ConfigServerInfo.ip.ss_len = res->ai_addrlen;
743 <      freeaddrinfo(res);
744 <
745 <      ConfigServerInfo.specific_ipv4_vhost = 1;
746 <    }
747 <  }
748 < };
749 <
750 < serverinfo_vhost6: VHOST6 '=' QSTRING ';'
751 < {
752 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
753 <  {
754 <    struct addrinfo hints, *res;
755 <
756 <    memset(&hints, 0, sizeof(hints));
757 <
758 <    hints.ai_family   = AF_UNSPEC;
759 <    hints.ai_socktype = SOCK_STREAM;
760 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
761 <
762 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
763 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
764 <    else
765 <    {
766 <      assert(res);
767 <
768 <      memcpy(&ConfigServerInfo.ip6, res->ai_addr, res->ai_addrlen);
769 <      ConfigServerInfo.ip6.ss.ss_family = res->ai_family;
770 <      ConfigServerInfo.ip6.ss_len = res->ai_addrlen;
771 <      freeaddrinfo(res);
772 <
773 <      ConfigServerInfo.specific_ipv6_vhost = 1;
774 <    }
775 <  }
585 >  xfree(ConfigServerInfo.network_description);
586 >  ConfigServerInfo.network_description = xstrdup(yylval.string);
587   };
588  
589   serverinfo_default_max_clients: DEFAULT_MAX_CLIENTS '=' NUMBER ';'
# Line 780 | Line 591 | serverinfo_default_max_clients: DEFAULT_
591    if (conf_parser_ctx.pass != 2)
592      break;
593  
594 <  if ($3 < MAXCLIENTS_MIN)
594 >  if ($3 < 1)
595    {
596 <    char buf[IRCD_BUFSIZE] = "";
597 <
787 <    snprintf(buf, sizeof(buf), "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
788 <    conf_error_report(buf);
789 <    ConfigServerInfo.default_max_clients = MAXCLIENTS_MIN;
596 >    conf_error_report("default_max_clients too low, setting to 1");
597 >    ConfigServerInfo.default_max_clients = 1;
598    }
599    else if ($3 > MAXCLIENTS_MAX)
600    {
601 <    char buf[IRCD_BUFSIZE] = "";
601 >    char buf[IRCD_BUFSIZE];
602  
603 <    snprintf(buf, sizeof(buf), "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
603 >    snprintf(buf, sizeof(buf), "default_max_clients too high, setting to %d", MAXCLIENTS_MAX);
604      conf_error_report(buf);
605 +
606      ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
607    }
608    else
# Line 812 | Line 621 | serverinfo_max_nick_length: MAX_NICK_LEN
621    }
622    else if ($3 > NICKLEN)
623    {
624 <    char buf[IRCD_BUFSIZE] = "";
624 >    char buf[IRCD_BUFSIZE];
625  
626      snprintf(buf, sizeof(buf), "max_nick_length too high, setting to %d", NICKLEN);
627      conf_error_report(buf);
628 +
629      ConfigServerInfo.max_nick_length = NICKLEN;
630    }
631    else
# Line 834 | Line 644 | serverinfo_max_topic_length: MAX_TOPIC_L
644    }
645    else if ($3 > TOPICLEN)
646    {
647 <    char buf[IRCD_BUFSIZE] = "";
647 >    char buf[IRCD_BUFSIZE];
648  
649      snprintf(buf, sizeof(buf), "max_topic_length too high, setting to %d", TOPICLEN);
650      conf_error_report(buf);
651 +
652      ConfigServerInfo.max_topic_length = TOPICLEN;
653    }
654    else
# Line 850 | Line 661 | serverinfo_hub: HUB '=' TBOOL ';'
661      ConfigServerInfo.hub = yylval.number;
662   };
663  
664 +
665   /***************************************************************************
666 < * admin section
666 > * admin {} section
667   ***************************************************************************/
668 < admin_entry: ADMIN  '{' admin_items '}' ';' ;
668 > admin_entry: ADMIN '{' admin_items '}' ';' ;
669  
670   admin_items: admin_items admin_item | admin_item;
671   admin_item:  admin_name |
# Line 866 | Line 678 | admin_name: NAME '=' QSTRING ';'
678    if (conf_parser_ctx.pass != 2)
679      break;
680  
681 <  MyFree(ConfigAdminInfo.name);
681 >  xfree(ConfigAdminInfo.name);
682    ConfigAdminInfo.name = xstrdup(yylval.string);
683   };
684  
# Line 875 | Line 687 | admin_email: EMAIL '=' QSTRING ';'
687    if (conf_parser_ctx.pass != 2)
688      break;
689  
690 <  MyFree(ConfigAdminInfo.email);
690 >  xfree(ConfigAdminInfo.email);
691    ConfigAdminInfo.email = xstrdup(yylval.string);
692   };
693  
# Line 884 | Line 696 | admin_description: DESCRIPTION '=' QSTRI
696    if (conf_parser_ctx.pass != 2)
697      break;
698  
699 <  MyFree(ConfigAdminInfo.description);
699 >  xfree(ConfigAdminInfo.description);
700    ConfigAdminInfo.description = xstrdup(yylval.string);
701   };
702  
703 +
704   /***************************************************************************
705 < * motd section
705 > * motd {} section
706   ***************************************************************************/
707   motd_entry: MOTD
708   {
# Line 897 | Line 710 | motd_entry: MOTD
710      reset_block_state();
711   } '{' motd_items '}' ';'
712   {
713 <  dlink_node *node = NULL;
713 >  dlink_node *node;
714  
715    if (conf_parser_ctx.pass != 2)
716      break;
# Line 924 | Line 737 | motd_file: T_FILE '=' QSTRING ';'
737      strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
738   };
739  
740 +
741   /***************************************************************************
742 < * pseudo section
742 > * pseudo {} section
743   ***************************************************************************/
744   pseudo_entry: T_PSEUDO
745   {
# Line 985 | Line 799 | pseudo_target: T_TARGET '=' QSTRING ';'
799    }
800   };
801  
802 +
803   /***************************************************************************
804 < *  section logging
804 > * log {} section
805   ***************************************************************************/
806 < logging_entry:          T_LOG  '{' logging_items '}' ';' ;
806 > logging_entry:          T_LOG '{' logging_items '}' ';' ;
807   logging_items:          logging_items logging_item | logging_item ;
808  
809   logging_item:           logging_use_logging | logging_file_entry |
# Line 1040 | Line 855 | logging_file_type: TYPE
855   {
856    if (conf_parser_ctx.pass == 2)
857      block_state.type.value = 0;
858 < } '='  logging_file_type_items ';' ;
858 > } '=' logging_file_type_items ';' ;
859  
860   logging_file_type_items: logging_file_type_items ',' logging_file_type_item | logging_file_type_item;
861   logging_file_type_item:  USER
# Line 1051 | Line 866 | logging_file_type_item:  USER
866   {
867    if (conf_parser_ctx.pass == 2)
868      block_state.type.value = LOG_TYPE_OPER;
1054 – } | GLINE
1055 – {
1056 –  if (conf_parser_ctx.pass == 2)
1057 –    block_state.type.value = LOG_TYPE_GLINE;
869   } | XLINE
870   {
871    if (conf_parser_ctx.pass == 2)
# Line 1083 | Line 894 | logging_file_type_item:  USER
894  
895  
896   /***************************************************************************
897 < * section oper
897 > * operator {} section
898   ***************************************************************************/
899   oper_entry: OPERATOR
900   {
# Line 1094 | Line 905 | oper_entry: OPERATOR
905    block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
906   } '{' oper_items '}' ';'
907   {
908 <  dlink_node *node = NULL;
908 >  dlink_node *node;
909  
910    if (conf_parser_ctx.pass != 2)
911      break;
912  
913    if (!block_state.name.buf[0])
914      break;
915 < #ifdef HAVE_LIBCRYPTO
1105 <  if (!block_state.file.buf[0] &&
1106 <      !block_state.rpass.buf[0])
1107 <    break;
1108 < #else
915 >
916    if (!block_state.rpass.buf[0])
917      break;
1111 – #endif
918  
919    DLINK_FOREACH(node, block_state.mask.list.head)
920    {
1115 –    struct MaskItem *conf = NULL;
921      struct split_nuh_item nuh;
922 +    char *s = node->data;
923 +
924 +    if (EmptyString(s))
925 +      continue;
926  
927 <    nuh.nuhmask  = node->data;
927 >    nuh.nuhmask  = s;
928      nuh.nickptr  = NULL;
929      nuh.userptr  = block_state.user.buf;
930      nuh.hostptr  = block_state.host.buf;
931 +
932      nuh.nicksize = 0;
933      nuh.usersize = sizeof(block_state.user.buf);
934      nuh.hostsize = sizeof(block_state.host.buf);
935 +
936      split_nuh(&nuh);
937  
938 <    conf         = conf_make(CONF_OPER);
939 <    conf->name   = xstrdup(block_state.name.buf);
940 <    conf->user   = xstrdup(block_state.user.buf);
941 <    conf->host   = xstrdup(block_state.host.buf);
938 >    struct MaskItem *conf = conf_make(CONF_OPER);
939 >    conf->addr = xcalloc(sizeof(*conf->addr));
940 >    conf->name = xstrdup(block_state.name.buf);
941 >    conf->user = xstrdup(block_state.user.buf);
942 >    conf->host = xstrdup(block_state.host.buf);
943  
944      if (block_state.cert.buf[0])
945        conf->certfp = xstrdup(block_state.cert.buf);
# Line 1141 | Line 953 | oper_entry: OPERATOR
953      conf->flags = block_state.flags.value;
954      conf->modes = block_state.modes.value;
955      conf->port  = block_state.port.value;
956 <    conf->htype = parse_netmask(conf->host, &conf->addr, &conf->bits);
956 >    conf->htype = parse_netmask(conf->host, conf->addr, &conf->bits);
957  
958      conf_add_class_to_conf(conf, block_state.class.buf);
1147 –
1148 – #ifdef HAVE_LIBCRYPTO
1149 –    if (block_state.file.buf[0])
1150 –    {
1151 –      BIO *file = NULL;
1152 –      RSA *pkey = NULL;
1153 –
1154 –      if ((file = BIO_new_file(block_state.file.buf, "r")) == NULL)
1155 –      {
1156 –        ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- file doesn't exist");
1157 –        break;
1158 –      }
1159 –
1160 –      if ((pkey = PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL)) == NULL)
1161 –        ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- key invalid; check key syntax");
1162 –      else
1163 –      {
1164 –        if (RSA_size(pkey) > 128)
1165 –          ilog(LOG_TYPE_IRCD, "Ignoring rsa_public_key_file -- key size must be 1024 or below");
1166 –        else
1167 –          conf->rsa_public_key = pkey;
1168 –      }
1169 –
1170 –      BIO_set_close(file, BIO_CLOSE);
1171 –      BIO_free(file);
1172 –    }
1173 – #endif /* HAVE_LIBCRYPTO */
959    }
960   };
961  
# Line 1182 | Line 967 | oper_item:      oper_name |
967                  oper_umodes |
968                  oper_class |
969                  oper_encrypted |
970 <                oper_rsa_public_key_file |
971 <                oper_ssl_certificate_fingerprint |
1187 <                oper_ssl_connection_required |
970 >                oper_tls_certificate_fingerprint |
971 >                oper_tls_connection_required |
972                  oper_flags |
973                  error ';' ;
974  
# Line 1223 | Line 1007 | oper_encrypted: ENCRYPTED '=' TBOOL ';'
1007      block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
1008   };
1009  
1010 < oper_rsa_public_key_file: RSA_PUBLIC_KEY_FILE '=' QSTRING ';'
1227 < {
1228 <  if (conf_parser_ctx.pass == 2)
1229 <    strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
1230 < };
1231 <
1232 < oper_ssl_certificate_fingerprint: SSL_CERTIFICATE_FINGERPRINT '=' QSTRING ';'
1010 > oper_tls_certificate_fingerprint: TLS_CERTIFICATE_FINGERPRINT '=' QSTRING ';'
1011   {
1012    if (conf_parser_ctx.pass == 2)
1013      strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
1014   };
1015  
1016 < oper_ssl_connection_required: SSL_CONNECTION_REQUIRED '=' TBOOL ';'
1016 > oper_tls_connection_required: TLS_CONNECTION_REQUIRED '=' TBOOL ';'
1017   {
1018    if (conf_parser_ctx.pass != 2)
1019      break;
1020  
1021    if (yylval.number)
1022 <    block_state.flags.value |= CONF_FLAGS_SSL;
1022 >    block_state.flags.value |= CONF_FLAGS_TLS;
1023    else
1024 <    block_state.flags.value &= ~CONF_FLAGS_SSL;
1024 >    block_state.flags.value &= ~CONF_FLAGS_TLS;
1025   };
1026  
1027   oper_class: CLASS '=' QSTRING ';'
# Line 1256 | Line 1034 | oper_umodes: T_UMODES
1034   {
1035    if (conf_parser_ctx.pass == 2)
1036      block_state.modes.value = 0;
1037 < } '='  oper_umodes_items ';' ;
1037 > } '=' oper_umodes_items ';' ;
1038  
1039   oper_umodes_items: oper_umodes_items ',' oper_umodes_item | oper_umodes_item;
1040 < oper_umodes_item:  T_BOTS
1263 < {
1264 <  if (conf_parser_ctx.pass == 2)
1265 <    block_state.modes.value |= UMODE_BOTS;
1266 < } | T_CCONN
1040 > oper_umodes_item:  T_CCONN
1041   {
1042    if (conf_parser_ctx.pass == 2)
1043      block_state.modes.value |= UMODE_CCONN;
# Line 1275 | Line 1049 | oper_umodes_item:  T_BOTS
1049   {
1050    if (conf_parser_ctx.pass == 2)
1051      block_state.modes.value |= UMODE_DEBUG;
1052 < } | T_FULL
1052 > } | T_FLOOD
1053   {
1054    if (conf_parser_ctx.pass == 2)
1055 <    block_state.modes.value |= UMODE_FULL;
1055 >    block_state.modes.value |= UMODE_FLOOD;
1056   } | HIDDEN
1057   {
1058    if (conf_parser_ctx.pass == 2)
# Line 1303 | Line 1077 | oper_umodes_item:  T_BOTS
1077   {
1078    if (conf_parser_ctx.pass == 2)
1079      block_state.modes.value |= UMODE_REJ;
1306 – } | T_UNAUTH
1307 – {
1308 –  if (conf_parser_ctx.pass == 2)
1309 –    block_state.modes.value |= UMODE_UNAUTH;
1080   } | T_SPY
1081   {
1082    if (conf_parser_ctx.pass == 2)
# Line 1347 | Line 1117 | oper_umodes_item:  T_BOTS
1117   {
1118    if (conf_parser_ctx.pass == 2)
1119      block_state.modes.value |= UMODE_FARCONNECT;
1120 + } | EXPIRATION
1121 + {
1122 +  if (conf_parser_ctx.pass == 2)
1123 +    block_state.modes.value |= UMODE_EXPIRATION;
1124   };
1125  
1126   oper_flags: IRCD_FLAGS
1127   {
1128    if (conf_parser_ctx.pass == 2)
1129      block_state.port.value = 0;
1130 < } '='  oper_flags_items ';';
1130 > } '=' oper_flags_items ';';
1131  
1132   oper_flags_items: oper_flags_items ',' oper_flags_item | oper_flags_item;
1133   oper_flags_item: KILL ':' REMOTE
# Line 1404 | Line 1178 | oper_flags_item: KILL ':' REMOTE
1178   {
1179    if (conf_parser_ctx.pass == 2)
1180      block_state.port.value |= OPER_FLAG_UNXLINE;
1407 – } | GLINE
1408 – {
1409 –  if (conf_parser_ctx.pass == 2)
1410 –    block_state.port.value |= OPER_FLAG_GLINE;
1181   } | DIE
1182   {
1183    if (conf_parser_ctx.pass == 2)
# Line 1416 | Line 1186 | oper_flags_item: KILL ':' REMOTE
1186   {
1187    if (conf_parser_ctx.pass == 2)
1188      block_state.port.value |= OPER_FLAG_RESTART;
1189 + } | REHASH ':' REMOTE
1190 + {
1191 +  if (conf_parser_ctx.pass == 2)
1192 +    block_state.port.value |= OPER_FLAG_REHASH_REMOTE;
1193   } | REHASH
1194   {
1195    if (conf_parser_ctx.pass == 2)
# Line 1452 | Line 1226 | oper_flags_item: KILL ':' REMOTE
1226   {
1227    if (conf_parser_ctx.pass == 2)
1228      block_state.port.value |= OPER_FLAG_OPME;
1229 + } | NICK ':' RESV
1230 + {
1231 +  if (conf_parser_ctx.pass == 2)
1232 +    block_state.port.value |= OPER_FLAG_NICK_RESV;
1233 + } | JOIN ':' RESV
1234 + {
1235 +  if (conf_parser_ctx.pass == 2)
1236 +    block_state.port.value |= OPER_FLAG_JOIN_RESV;
1237 + } | RESV
1238 + {
1239 +  if (conf_parser_ctx.pass == 2)
1240 +    block_state.port.value |= OPER_FLAG_RESV;
1241 + } | T_UNRESV
1242 + {
1243 +  if (conf_parser_ctx.pass == 2)
1244 +    block_state.port.value |= OPER_FLAG_UNRESV;
1245 + } | CLOSE
1246 + {
1247 +  if (conf_parser_ctx.pass == 2)
1248 +    block_state.port.value |= OPER_FLAG_CLOSE;
1249   };
1250  
1251  
1252   /***************************************************************************
1253 < *  section class
1253 > * class {} section
1254   ***************************************************************************/
1255   class_entry: CLASS
1256   {
# Line 1467 | Line 1261 | class_entry: CLASS
1261  
1262    block_state.ping_freq.value = DEFAULT_PINGFREQUENCY;
1263    block_state.con_freq.value  = DEFAULT_CONNECTFREQUENCY;
1470 –  block_state.max_total.value = MAXIMUM_LINKS_DEFAULT;
1264    block_state.max_sendq.value = DEFAULT_SENDQ;
1265    block_state.max_recvq.value = DEFAULT_RECVQ;
1266   } '{' class_items '}' ';'
1267   {
1475 –  struct ClassItem *class = NULL;
1476 –
1268    if (conf_parser_ctx.pass != 1)
1269      break;
1270  
1271    if (!block_state.class.buf[0])
1272      break;
1273  
1274 <  if (!(class = class_find(block_state.class.buf, 0)))
1274 >  struct ClassItem *class = class_find(block_state.class.buf, false);
1275 >  if (class == NULL)
1276      class = class_make();
1277  
1278 <  class->active = 1;
1279 <  MyFree(class->name);
1278 >  class->active = true;
1279 >  xfree(class->name);
1280    class->name = xstrdup(block_state.class.buf);
1281    class->ping_freq = block_state.ping_freq.value;
1282 <  class->max_perip = block_state.max_perip.value;
1282 >  class->max_perip_local = block_state.max_perip_local.value;
1283 >  class->max_perip_global = block_state.max_perip_global.value;
1284    class->con_freq = block_state.con_freq.value;
1285    class->max_total = block_state.max_total.value;
1493 –  class->max_global = block_state.max_global.value;
1494 –  class->max_local = block_state.max_local.value;
1495 –  class->max_ident = block_state.max_ident.value;
1286    class->max_sendq = block_state.max_sendq.value;
1287    class->max_recvq = block_state.max_recvq.value;
1288    class->max_channels = block_state.max_channels.value;
# Line 1508 | Line 1298 | class_entry: CLASS
1298    class->min_idle = block_state.min_idle.value;
1299    class->max_idle = block_state.max_idle.value;
1300  
1301 <  if (class->number_per_cidr && block_state.number_per_cidr.value)
1302 <    if ((class->cidr_bitlen_ipv4 && block_state.cidr_bitlen_ipv4.value) ||
1513 <        (class->cidr_bitlen_ipv6 && block_state.cidr_bitlen_ipv6.value))
1514 <      if ((class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value) ||
1515 <          (class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value))
1516 <        rebuild_cidr_list(class);
1517 <
1301 >  bool diff = (class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value ||
1302 >               class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value);
1303    class->cidr_bitlen_ipv4 = block_state.cidr_bitlen_ipv4.value;
1304    class->cidr_bitlen_ipv6 = block_state.cidr_bitlen_ipv6.value;
1305    class->number_per_cidr = block_state.number_per_cidr.value;
1306 +
1307 +  if (diff)
1308 +    class_ip_limit_rebuild(class);
1309   };
1310  
1311   class_items:    class_items class_item | class_item;
# Line 1526 | Line 1314 | class_item:     class_name |
1314                  class_cidr_bitlen_ipv6 |
1315                  class_ping_time |
1316                  class_number_per_cidr |
1317 <                class_number_per_ip |
1317 >                class_number_per_ip_local |
1318 >                class_number_per_ip_global |
1319                  class_connectfreq |
1320                  class_max_channels |
1321                  class_max_number |
1322 <                class_max_global |
1323 <                class_max_local |
1535 <                class_max_ident |
1536 <                class_sendq | class_recvq |
1322 >                class_sendq |
1323 >                class_recvq |
1324                  class_min_idle |
1325                  class_max_idle |
1326                  class_flags |
# Line 1551 | Line 1338 | class_ping_time: PING_TIME '=' timespec
1338      block_state.ping_freq.value = $3;
1339   };
1340  
1341 < class_number_per_ip: NUMBER_PER_IP '=' NUMBER ';'
1341 > class_number_per_ip_local: NUMBER_PER_IP_LOCAL '=' NUMBER ';'
1342 > {
1343 >  if (conf_parser_ctx.pass == 1)
1344 >    block_state.max_perip_local.value = $3;
1345 > };
1346 >
1347 > class_number_per_ip_global: NUMBER_PER_IP_GLOBAL '=' NUMBER ';'
1348   {
1349    if (conf_parser_ctx.pass == 1)
1350 <    block_state.max_perip.value = $3;
1350 >    block_state.max_perip_global.value = $3;
1351   };
1352  
1353   class_connectfreq: CONNECTFREQ '=' timespec ';'
# Line 1575 | Line 1368 | class_max_number: MAX_NUMBER '=' NUMBER
1368      block_state.max_total.value = $3;
1369   };
1370  
1578 – class_max_global: MAX_GLOBAL '=' NUMBER ';'
1579 – {
1580 –  if (conf_parser_ctx.pass == 1)
1581 –    block_state.max_global.value = $3;
1582 – };
1583 –
1584 – class_max_local: MAX_LOCAL '=' NUMBER ';'
1585 – {
1586 –  if (conf_parser_ctx.pass == 1)
1587 –    block_state.max_local.value = $3;
1588 – };
1589 –
1590 – class_max_ident: MAX_IDENT '=' NUMBER ';'
1591 – {
1592 –  if (conf_parser_ctx.pass == 1)
1593 –    block_state.max_ident.value = $3;
1594 – };
1595 –
1371   class_sendq: SENDQ '=' sizespec ';'
1372   {
1373    if (conf_parser_ctx.pass == 1)
# Line 1646 | Line 1421 | class_flags: IRCD_FLAGS
1421   {
1422    if (conf_parser_ctx.pass == 1)
1423      block_state.flags.value &= CLASS_FLAGS_FAKE_IDLE;
1424 < } '='  class_flags_items ';';
1424 > } '=' class_flags_items ';';
1425  
1426   class_flags_items: class_flags_items ',' class_flags_item | class_flags_item;
1427   class_flags_item: RANDOM_IDLE
# Line 1661 | Line 1436 | class_flags_item: RANDOM_IDLE
1436  
1437  
1438   /***************************************************************************
1439 < *  section listen
1439 > * listen {} section
1440   ***************************************************************************/
1441   listen_entry: LISTEN
1442   {
# Line 1672 | Line 1447 | listen_entry: LISTEN
1447   listen_flags: IRCD_FLAGS
1448   {
1449    block_state.flags.value = 0;
1450 < } '='  listen_flags_items ';';
1450 > } '=' listen_flags_items ';';
1451  
1452   listen_flags_items: listen_flags_items ',' listen_flags_item | listen_flags_item;
1453 < listen_flags_item: T_SSL
1453 > listen_flags_item: T_TLS
1454   {
1455    if (conf_parser_ctx.pass == 2)
1456 <    block_state.flags.value |= LISTENER_SSL;
1456 >    block_state.flags.value |= LISTENER_TLS;
1457   } | HIDDEN
1458   {
1459    if (conf_parser_ctx.pass == 2)
# Line 1687 | Line 1462 | listen_flags_item: T_SSL
1462   {
1463    if (conf_parser_ctx.pass == 2)
1464     block_state.flags.value |= LISTENER_SERVER;
1465 + } | CLIENT
1466 + {
1467 +  if (conf_parser_ctx.pass == 2)
1468 +   block_state.flags.value |= LISTENER_CLIENT;
1469 + } | DEFER
1470 + {
1471 +  if (conf_parser_ctx.pass == 2)
1472 +   block_state.flags.value |= LISTENER_DEFER;
1473   };
1474  
1475   listen_items:   listen_items listen_item | listen_item;
# Line 1700 | Line 1483 | port_item: NUMBER
1483   {
1484    if (conf_parser_ctx.pass == 2)
1485    {
1486 < #ifndef HAVE_LIBCRYPTO
1487 <    if (block_state.flags.value & LISTENER_SSL)
1486 > #ifndef HAVE_TLS
1487 >    if (block_state.flags.value & LISTENER_TLS)
1488      {
1489 <      conf_error_report("SSL not available - port closed");
1489 >      conf_error_report("TLS not available - port closed");
1490        break;
1491      }
1492   #endif
1493 <    add_listener($1, block_state.addr.buf, block_state.flags.value);
1493 >    listener_add($1, block_state.addr.buf, block_state.flags.value);
1494    }
1495   } | NUMBER TWODOTS NUMBER
1496   {
1497    if (conf_parser_ctx.pass == 2)
1498    {
1499 < #ifndef HAVE_LIBCRYPTO
1500 <    if (block_state.flags.value & LISTENER_SSL)
1499 > #ifndef HAVE_TLS
1500 >    if (block_state.flags.value & LISTENER_TLS)
1501      {
1502 <      conf_error_report("SSL not available - port closed");
1502 >      conf_error_report("TLS not available - port closed");
1503        break;
1504      }
1505   #endif
1506  
1507      for (int i = $1; i <= $3; ++i)
1508 <      add_listener(i, block_state.addr.buf, block_state.flags.value);
1508 >      listener_add(i, block_state.addr.buf, block_state.flags.value);
1509    }
1510   };
1511  
# Line 1738 | Line 1521 | listen_host: HOST '=' QSTRING ';'
1521      strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
1522   };
1523  
1524 +
1525   /***************************************************************************
1526 < *  section auth
1526 > * auth {} section
1527   ***************************************************************************/
1528   auth_entry: IRCD_AUTH
1529   {
# Line 1747 | Line 1531 | auth_entry: IRCD_AUTH
1531      reset_block_state();
1532   } '{' auth_items '}' ';'
1533   {
1534 <  dlink_node *node = NULL;
1534 >  dlink_node *node;
1535  
1536    if (conf_parser_ctx.pass != 2)
1537      break;
1538  
1539    DLINK_FOREACH(node, block_state.mask.list.head)
1540    {
1757 –    struct MaskItem *conf = NULL;
1541      struct split_nuh_item nuh;
1542 +    char *s = node->data;
1543  
1544 <    nuh.nuhmask  = node->data;
1544 >    if (EmptyString(s))
1545 >      continue;
1546 >
1547 >    nuh.nuhmask  = s;
1548      nuh.nickptr  = NULL;
1549      nuh.userptr  = block_state.user.buf;
1550      nuh.hostptr  = block_state.host.buf;
1551 +
1552      nuh.nicksize = 0;
1553      nuh.usersize = sizeof(block_state.user.buf);
1554      nuh.hostsize = sizeof(block_state.host.buf);
1555 +
1556      split_nuh(&nuh);
1557  
1558 <    conf        = conf_make(CONF_CLIENT);
1559 <    conf->user  = xstrdup(block_state.user.buf);
1560 <    conf->host  = xstrdup(block_state.host.buf);
1558 >    struct MaskItem *conf = conf_make(CONF_CLIENT);
1559 >    conf->user = xstrdup(block_state.user.buf);
1560 >    conf->host = xstrdup(block_state.host.buf);
1561  
1562      if (block_state.rpass.buf[0])
1563        conf->passwd = xstrdup(block_state.rpass.buf);
# Line 1776 | Line 1565 | auth_entry: IRCD_AUTH
1565        conf->name = xstrdup(block_state.name.buf);
1566  
1567      conf->flags = block_state.flags.value;
1568 <    conf->port  = block_state.port.value;
1568 >    conf->port = block_state.port.value;
1569  
1570      conf_add_class_to_conf(conf, block_state.class.buf);
1571      add_conf_by_address(CONF_CLIENT, conf);
# Line 1827 | Line 1616 | auth_flags: IRCD_FLAGS
1616   {
1617    if (conf_parser_ctx.pass == 2)
1618      block_state.flags.value &= (CONF_FLAGS_ENCRYPTED | CONF_FLAGS_SPOOF_IP);
1619 < } '='  auth_flags_items ';';
1619 > } '=' auth_flags_items ';';
1620  
1621   auth_flags_items: auth_flags_items ',' auth_flags_item | auth_flags_item;
1622 < auth_flags_item: SPOOF_NOTICE
1834 < {
1835 <  if (conf_parser_ctx.pass == 2)
1836 <    block_state.flags.value |= CONF_FLAGS_SPOOF_NOTICE;
1837 < } | EXCEED_LIMIT
1622 > auth_flags_item: EXCEED_LIMIT
1623   {
1624    if (conf_parser_ctx.pass == 2)
1625      block_state.flags.value |= CONF_FLAGS_NOLIMIT;
# Line 1842 | Line 1627 | auth_flags_item: SPOOF_NOTICE
1627   {
1628    if (conf_parser_ctx.pass == 2)
1629      block_state.flags.value |= CONF_FLAGS_EXEMPTKLINE;
1630 + } | XLINE_EXEMPT
1631 + {
1632 +  if (conf_parser_ctx.pass == 2)
1633 +    block_state.flags.value |= CONF_FLAGS_EXEMPTXLINE;
1634   } | NEED_IDENT
1635   {
1636    if (conf_parser_ctx.pass == 2)
# Line 1854 | Line 1643 | auth_flags_item: SPOOF_NOTICE
1643   {
1644    if (conf_parser_ctx.pass == 2)
1645      block_state.flags.value |= CONF_FLAGS_NO_TILDE;
1857 – } | GLINE_EXEMPT
1858 – {
1859 –  if (conf_parser_ctx.pass == 2)
1860 –    block_state.flags.value |= CONF_FLAGS_EXEMPTGLINE;
1646   } | RESV_EXEMPT
1647   {
1648    if (conf_parser_ctx.pass == 2)
# Line 1906 | Line 1691 | auth_redir_port: REDIRPORT '=' NUMBER ';
1691  
1692  
1693   /***************************************************************************
1694 < *  section resv
1694 > * resv {} section
1695   ***************************************************************************/
1696   resv_entry: RESV
1697   {
# Line 1920 | Line 1705 | resv_entry: RESV
1705    if (conf_parser_ctx.pass != 2)
1706      break;
1707  
1708 <  create_resv(block_state.name.buf, block_state.rpass.buf, &block_state.mask.list);
1708 >  resv_make(block_state.name.buf, block_state.rpass.buf, &block_state.mask.list);
1709   };
1710  
1711   resv_items:     resv_items resv_item | resv_item;
# Line 1946 | Line 1731 | resv_exempt: EXEMPT '=' QSTRING ';'
1731  
1732  
1733   /***************************************************************************
1734 < *  section service
1734 > * service {} section
1735   ***************************************************************************/
1736   service_entry: T_SERVICE '{' service_items '}' ';';
1737  
# Line 1958 | Line 1743 | service_name: NAME '=' QSTRING ';'
1743    if (conf_parser_ctx.pass != 2)
1744      break;
1745  
1746 <  if (valid_servname(yylval.string))
1746 >  if (server_valid_name(yylval.string) == true)
1747    {
1748 <    struct MaskItem *conf = conf_make(CONF_SERVICE);
1749 <    conf->name = xstrdup(yylval.string);
1748 >    struct ServiceItem *service = service_make();
1749 >    service->name = xstrdup(yylval.string);
1750    }
1751   };
1752  
1753 +
1754   /***************************************************************************
1755 < *  section shared, for sharing remote klines etc.
1755 > * shared {} section, for sharing remote klines etc.
1756   ***************************************************************************/
1757   shared_entry: T_SHARED
1758   {
# Line 1981 | Line 1767 | shared_entry: T_SHARED
1767    block_state.flags.value = SHARED_ALL;
1768   } '{' shared_items '}' ';'
1769   {
1984 –  struct MaskItem *conf = NULL;
1985 –
1770    if (conf_parser_ctx.pass != 2)
1771      break;
1772  
1773 <  conf = conf_make(CONF_ULINE);
1774 <  conf->flags = block_state.flags.value;
1775 <  conf->name = xstrdup(block_state.name.buf);
1776 <  conf->user = xstrdup(block_state.user.buf);
1777 <  conf->host = xstrdup(block_state.host.buf);
1773 >  struct SharedItem *shared = shared_make();
1774 >  shared->type = block_state.flags.value;
1775 >  shared->server = xstrdup(block_state.name.buf);
1776 >  shared->user = xstrdup(block_state.user.buf);
1777 >  shared->host = xstrdup(block_state.host.buf);
1778   };
1779  
1780   shared_items: shared_items shared_item | shared_item;
# Line 2070 | Line 1854 | shared_type_item: KLINE
1854      block_state.flags.value = SHARED_ALL;
1855   };
1856  
1857 +
1858   /***************************************************************************
1859 < *  section cluster
1859 > * cluster {} section
1860   ***************************************************************************/
1861   cluster_entry: T_CLUSTER
1862   {
# Line 2081 | Line 1866 | cluster_entry: T_CLUSTER
1866    reset_block_state();
1867  
1868    strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
1869 <  block_state.flags.value = SHARED_ALL;
1869 >  block_state.flags.value = CLUSTER_ALL;
1870   } '{' cluster_items '}' ';'
1871   {
2087 –  struct MaskItem *conf = NULL;
2088 –
1872    if (conf_parser_ctx.pass != 2)
1873      break;
1874  
1875 <  conf = conf_make(CONF_CLUSTER);
1876 <  conf->flags = block_state.flags.value;
1877 <  conf->name = xstrdup(block_state.name.buf);
1875 >  struct ClusterItem *cluster = cluster_make();
1876 >  cluster->type = block_state.flags.value;
1877 >  cluster->server = xstrdup(block_state.name.buf);
1878   };
1879  
1880   cluster_items:  cluster_items cluster_item | cluster_item;
# Line 2113 | Line 1896 | cluster_types:  cluster_types ',' cluste
1896   cluster_type_item: KLINE
1897   {
1898    if (conf_parser_ctx.pass == 2)
1899 <    block_state.flags.value |= SHARED_KLINE;
1899 >    block_state.flags.value |= CLUSTER_KLINE;
1900   } | UNKLINE
1901   {
1902    if (conf_parser_ctx.pass == 2)
1903 <    block_state.flags.value |= SHARED_UNKLINE;
1903 >    block_state.flags.value |= CLUSTER_UNKLINE;
1904   } | T_DLINE
1905   {
1906    if (conf_parser_ctx.pass == 2)
1907 <    block_state.flags.value |= SHARED_DLINE;
1907 >    block_state.flags.value |= CLUSTER_DLINE;
1908   } | T_UNDLINE
1909   {
1910    if (conf_parser_ctx.pass == 2)
1911 <    block_state.flags.value |= SHARED_UNDLINE;
1911 >    block_state.flags.value |= CLUSTER_UNDLINE;
1912   } | XLINE
1913   {
1914    if (conf_parser_ctx.pass == 2)
1915 <    block_state.flags.value |= SHARED_XLINE;
1915 >    block_state.flags.value |= CLUSTER_XLINE;
1916   } | T_UNXLINE
1917   {
1918    if (conf_parser_ctx.pass == 2)
1919 <    block_state.flags.value |= SHARED_UNXLINE;
1919 >    block_state.flags.value |= CLUSTER_UNXLINE;
1920   } | RESV
1921   {
1922    if (conf_parser_ctx.pass == 2)
1923 <    block_state.flags.value |= SHARED_RESV;
1923 >    block_state.flags.value |= CLUSTER_RESV;
1924   } | T_UNRESV
1925   {
1926    if (conf_parser_ctx.pass == 2)
1927 <    block_state.flags.value |= SHARED_UNRESV;
1927 >    block_state.flags.value |= CLUSTER_UNRESV;
1928   } | T_LOCOPS
1929   {
1930    if (conf_parser_ctx.pass == 2)
1931 <    block_state.flags.value |= SHARED_LOCOPS;
1931 >    block_state.flags.value |= CLUSTER_LOCOPS;
1932   } | T_ALL
1933   {
1934    if (conf_parser_ctx.pass == 2)
1935 <    block_state.flags.value = SHARED_ALL;
1935 >    block_state.flags.value = CLUSTER_ALL;
1936   };
1937  
1938 +
1939   /***************************************************************************
1940 < *  section connect
1940 > * connect {}  section
1941   ***************************************************************************/
1942   connect_entry: CONNECT
1943   {
# Line 2164 | Line 1948 | connect_entry: CONNECT
1948    reset_block_state();
1949    block_state.aftype.value = AF_INET;
1950    block_state.port.value = PORTNUM;
1951 +  block_state.timeout.value = CONNECTTIMEOUT;
1952   } '{' connect_items '}' ';'
1953   {
2169 –  struct MaskItem *conf = NULL;
1954    struct addrinfo hints, *res;
1955  
1956    if (conf_parser_ctx.pass != 2)
# Line 2180 | Line 1964 | connect_entry: CONNECT
1964        !block_state.spass.buf[0])
1965      break;
1966  
1967 +  if (server_valid_name(block_state.name.buf) == false)
1968 +    break;
1969 +
1970    if (has_wildcards(block_state.name.buf) ||
1971        has_wildcards(block_state.host.buf))
1972      break;
1973  
1974 <  conf = conf_make(CONF_SERVER);
1974 >  struct MaskItem *conf = conf_make(CONF_SERVER);
1975 >  conf->addr = xcalloc(sizeof(*conf->addr));
1976    conf->port = block_state.port.value;
1977 +  conf->timeout = block_state.timeout.value;
1978    conf->flags = block_state.flags.value;
1979    conf->aftype = block_state.aftype.value;
1980    conf->host = xstrdup(block_state.host.buf);
# Line 2211 | Line 2000 | connect_entry: CONNECT
2000      hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
2001  
2002      if (getaddrinfo(block_state.bind.buf, NULL, &hints, &res))
2003 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", block_state.bind.buf);
2003 >      ilog(LOG_TYPE_IRCD, "Invalid netmask for server bind(%s)", block_state.bind.buf);
2004      else
2005      {
2006        assert(res);
2007  
2008 <      memcpy(&conf->bind, res->ai_addr, res->ai_addrlen);
2009 <      conf->bind.ss.ss_family = res->ai_family;
2010 <      conf->bind.ss_len = res->ai_addrlen;
2008 >      conf->bind = xcalloc(sizeof(*conf->bind));
2009 >
2010 >      memcpy(conf->bind, res->ai_addr, res->ai_addrlen);
2011 >      conf->bind->ss_len = res->ai_addrlen;
2012        freeaddrinfo(res);
2013      }
2014    }
2015  
2016    conf_add_class_to_conf(conf, block_state.class.buf);
2017 <  lookup_confhost(conf);
2017 >  conf_dns_lookup(conf);
2018   };
2019  
2020   connect_items:  connect_items connect_item | connect_item;
2021   connect_item:   connect_name |
2022                  connect_host |
2023 <                connect_vhost |
2023 >                connect_timeout |
2024 >                connect_bind |
2025                  connect_send_password |
2026                  connect_accept_password |
2027 <                connect_ssl_certificate_fingerprint |
2027 >                connect_tls_certificate_fingerprint |
2028                  connect_aftype |
2029                  connect_port |
2030 <                connect_ssl_cipher_list |
2030 >                connect_tls_cipher_list |
2031                  connect_flags |
2032                  connect_hub_mask |
2033                  connect_leaf_mask |
# Line 2256 | Line 2047 | connect_host: HOST '=' QSTRING ';'
2047      strlcpy(block_state.host.buf, yylval.string, sizeof(block_state.host.buf));
2048   };
2049  
2050 < connect_vhost: VHOST '=' QSTRING ';'
2050 > connect_timeout: TIMEOUT '=' timespec ';'
2051 > {
2052 >  if (conf_parser_ctx.pass == 2)
2053 >    block_state.timeout.value = $3;
2054 > };
2055 >
2056 > connect_bind: T_BIND '=' QSTRING ';'
2057   {
2058    if (conf_parser_ctx.pass == 2)
2059      strlcpy(block_state.bind.buf, yylval.string, sizeof(block_state.bind.buf));
# Line 2267 | Line 2064 | connect_send_password: SEND_PASSWORD '='
2064    if (conf_parser_ctx.pass != 2)
2065      break;
2066  
2067 <  if ($3[0] == ':')
2067 >  if (*yylval.string == ':')
2068      conf_error_report("Server passwords cannot begin with a colon");
2069 <  else if (strchr($3, ' '))
2069 >  else if (strchr(yylval.string, ' '))
2070      conf_error_report("Server passwords cannot contain spaces");
2071    else
2072      strlcpy(block_state.spass.buf, yylval.string, sizeof(block_state.spass.buf));
# Line 2280 | Line 2077 | connect_accept_password: ACCEPT_PASSWORD
2077    if (conf_parser_ctx.pass != 2)
2078      break;
2079  
2080 <  if ($3[0] == ':')
2080 >  if (*yylval.string == ':')
2081      conf_error_report("Server passwords cannot begin with a colon");
2082 <  else if (strchr($3, ' '))
2082 >  else if (strchr(yylval.string, ' '))
2083      conf_error_report("Server passwords cannot contain spaces");
2084    else
2085      strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2086   };
2087  
2088 < connect_ssl_certificate_fingerprint: SSL_CERTIFICATE_FINGERPRINT '=' QSTRING ';'
2088 > connect_tls_certificate_fingerprint: TLS_CERTIFICATE_FINGERPRINT '=' QSTRING ';'
2089   {
2090    if (conf_parser_ctx.pass == 2)
2091      strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
# Line 2313 | Line 2110 | connect_aftype: AFTYPE '=' T_IPV4 ';'
2110   connect_flags: IRCD_FLAGS
2111   {
2112    block_state.flags.value &= CONF_FLAGS_ENCRYPTED;
2113 < } '='  connect_flags_items ';';
2113 > } '=' connect_flags_items ';';
2114  
2115   connect_flags_items: connect_flags_items ',' connect_flags_item | connect_flags_item;
2116   connect_flags_item: AUTOCONN
2117   {
2118    if (conf_parser_ctx.pass == 2)
2119      block_state.flags.value |= CONF_FLAGS_ALLOW_AUTO_CONN;
2120 < } | T_SSL
2120 > } | T_TLS
2121   {
2122    if (conf_parser_ctx.pass == 2)
2123 <    block_state.flags.value |= CONF_FLAGS_SSL;
2123 >    block_state.flags.value |= CONF_FLAGS_TLS;
2124   };
2125  
2126   connect_encrypted: ENCRYPTED '=' TBOOL ';'
# Line 2355 | Line 2152 | connect_class: CLASS '=' QSTRING ';'
2152      strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
2153   };
2154  
2155 < connect_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
2155 > connect_tls_cipher_list: TLS_CIPHER_LIST '=' QSTRING ';'
2156   {
2157 < #ifdef HAVE_LIBCRYPTO
2157 > #ifdef HAVE_TLS
2158    if (conf_parser_ctx.pass == 2)
2159      strlcpy(block_state.ciph.buf, yylval.string, sizeof(block_state.ciph.buf));
2160   #else
2161    if (conf_parser_ctx.pass == 2)
2162 <    conf_error_report("Ignoring connect::ciphers -- no OpenSSL support");
2162 >    conf_error_report("Ignoring connect::tls_cipher_list -- no TLS support");
2163   #endif
2164   };
2165  
2166  
2167   /***************************************************************************
2168 < *  section kill
2168 > * kill {} section
2169   ***************************************************************************/
2170   kill_entry: KILL
2171   {
# Line 2376 | Line 2173 | kill_entry: KILL
2173      reset_block_state();
2174   } '{' kill_items '}' ';'
2175   {
2379 –  struct MaskItem *conf = NULL;
2380 –
2176    if (conf_parser_ctx.pass != 2)
2177      break;
2178  
# Line 2385 | Line 2180 | kill_entry: KILL
2180        !block_state.host.buf[0])
2181      break;
2182  
2183 <  conf = conf_make(CONF_KLINE);
2183 >  struct MaskItem *conf = conf_make(CONF_KLINE);
2184    conf->user = xstrdup(block_state.user.buf);
2185    conf->host = xstrdup(block_state.host.buf);
2186  
# Line 2425 | Line 2220 | kill_reason: REASON '=' QSTRING ';'
2220      strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2221   };
2222  
2223 +
2224   /***************************************************************************
2225 < *  section deny
2225 > * deny {} section
2226   ***************************************************************************/
2227   deny_entry: DENY
2228   {
# Line 2434 | Line 2230 | deny_entry: DENY
2230      reset_block_state();
2231   } '{' deny_items '}' ';'
2232   {
2437 –  struct MaskItem *conf = NULL;
2438 –
2233    if (conf_parser_ctx.pass != 2)
2234      break;
2235  
# Line 2444 | Line 2238 | deny_entry: DENY
2238  
2239    if (parse_netmask(block_state.addr.buf, NULL, NULL) != HM_HOST)
2240    {
2241 <    conf = conf_make(CONF_DLINE);
2241 >    struct MaskItem *conf = conf_make(CONF_DLINE);
2242      conf->host = xstrdup(block_state.addr.buf);
2243  
2244      if (block_state.rpass.buf[0])
# Line 2470 | Line 2264 | deny_reason: REASON '=' QSTRING ';'
2264      strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2265   };
2266  
2267 +
2268   /***************************************************************************
2269 < *  section exempt
2269 > * exempt {} section
2270   ***************************************************************************/
2271   exempt_entry: EXEMPT '{' exempt_items '}' ';';
2272  
2273 < exempt_items:     exempt_items exempt_item | exempt_item;
2274 < exempt_item:      exempt_ip | error;
2273 > exempt_items: exempt_items exempt_item | exempt_item;
2274 > exempt_item:  exempt_ip | error;
2275  
2276   exempt_ip: IP '=' QSTRING ';'
2277   {
2278    if (conf_parser_ctx.pass == 2)
2279    {
2280 <    if (yylval.string[0] && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
2280 >    if (*yylval.string && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
2281      {
2282        struct MaskItem *conf = conf_make(CONF_EXEMPT);
2283        conf->host = xstrdup(yylval.string);
# Line 2493 | Line 2288 | exempt_ip: IP '=' QSTRING ';'
2288   };
2289  
2290   /***************************************************************************
2291 < *  section gecos
2291 > * gecos {} section
2292   ***************************************************************************/
2293   gecos_entry: GECOS
2294   {
# Line 2501 | Line 2296 | gecos_entry: GECOS
2296      reset_block_state();
2297   } '{' gecos_items '}' ';'
2298   {
2504 –  struct MaskItem *conf = NULL;
2505 –
2299    if (conf_parser_ctx.pass != 2)
2300      break;
2301  
2302    if (!block_state.name.buf[0])
2303      break;
2304  
2305 <  conf = conf_make(CONF_XLINE);
2306 <  conf->name = xstrdup(block_state.name.buf);
2305 >  struct GecosItem *gecos = gecos_make();
2306 >  gecos->mask = xstrdup(block_state.name.buf);
2307  
2308    if (block_state.rpass.buf[0])
2309 <    conf->reason = xstrdup(block_state.rpass.buf);
2309 >    gecos->reason = xstrdup(block_state.rpass.buf);
2310    else
2311 <    conf->reason = xstrdup(CONF_NOREASON);
2311 >    gecos->reason = xstrdup(CONF_NOREASON);
2312   };
2313  
2314   gecos_items: gecos_items gecos_item | gecos_item;
# Line 2533 | Line 2326 | gecos_reason: REASON '=' QSTRING ';'
2326      strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
2327   };
2328  
2329 +
2330   /***************************************************************************
2331 < *  section general
2331 > * general {} section
2332   ***************************************************************************/
2333 < general_entry: GENERAL
2540 <  '{' general_items '}' ';';
2333 > general_entry: GENERAL '{' general_items '}' ';';
2334  
2335   general_items:      general_items general_item | general_item;
2336   general_item:       general_away_count |
2337                      general_away_time |
2545 –                    general_ignore_bogus_ts |
2338                      general_failed_oper_notice |
2339                      general_anti_nick_flood |
2340                      general_max_nick_time |
2341                      general_max_nick_changes |
2342                      general_max_accept |
2343 +                    general_whowas_history_length |
2344                      general_anti_spam_exit_message_time |
2345                      general_ts_warn_delta |
2346                      general_ts_max_delta |
# Line 2565 | Line 2358 | general_item:       general_away_count |
2358                      general_pace_wait_simple |
2359                      general_short_motd |
2360                      general_no_oper_flood |
2568 –                    general_oper_pass_resv |
2361                      general_oper_only_umodes |
2362                      general_max_targets |
2363                      general_oper_umodes |
2364                      general_caller_id_wait |
2365                      general_opers_bypass_callerid |
2366                      general_default_floodcount |
2367 +                    general_default_floodtime |
2368                      general_min_nonwildcard |
2369                      general_min_nonwildcard_simple |
2370                      general_throttle_count |
2371                      general_throttle_time |
2579 –                    general_havent_read_conf |
2372                      general_ping_cookie |
2373                      general_disable_auth |
2374 <                    general_tkline_expire_notices |
2375 <                    general_gline_enable |
2376 <                    general_gline_duration |
2377 <                    general_gline_request_duration |
2586 <                    general_gline_min_cidr |
2587 <                    general_gline_min_cidr6 |
2374 >                    general_dline_min_cidr |
2375 >                    general_dline_min_cidr6 |
2376 >                    general_kline_min_cidr |
2377 >                    general_kline_min_cidr6 |
2378                      general_stats_e_disabled |
2379                      general_max_watch |
2380                      general_cycle_on_host_change |
# Line 2606 | Line 2396 | general_max_watch: MAX_WATCH '=' NUMBER
2396    ConfigGeneral.max_watch = $3;
2397   };
2398  
2399 < general_cycle_on_host_change: CYCLE_ON_HOST_CHANGE '=' TBOOL ';'
2399 > general_whowas_history_length: WHOWAS_HISTORY_LENGTH '=' NUMBER ';'
2400   {
2401 <  if (conf_parser_ctx.pass == 2)
2612 <    ConfigGeneral.cycle_on_host_change = yylval.number;
2401 >  ConfigGeneral.whowas_history_length = $3;
2402   };
2403  
2404 < general_gline_enable: GLINE_ENABLE '=' TBOOL ';'
2616 < {
2617 <  if (conf_parser_ctx.pass == 2)
2618 <    ConfigGeneral.glines = yylval.number;
2619 < };
2620 <
2621 < general_gline_duration: GLINE_DURATION '=' timespec ';'
2404 > general_cycle_on_host_change: CYCLE_ON_HOST_CHANGE '=' TBOOL ';'
2405   {
2406 <  if (conf_parser_ctx.pass == 2)
2624 <    ConfigGeneral.gline_time = $3;
2406 >  ConfigGeneral.cycle_on_host_change = yylval.number;
2407   };
2408  
2409 < general_gline_request_duration: GLINE_REQUEST_DURATION '=' timespec ';'
2409 > general_dline_min_cidr: DLINE_MIN_CIDR '=' NUMBER ';'
2410   {
2411 <  if (conf_parser_ctx.pass == 2)
2630 <    ConfigGeneral.gline_request_time = $3;
2411 >  ConfigGeneral.dline_min_cidr = $3;
2412   };
2413  
2414 < general_gline_min_cidr: GLINE_MIN_CIDR '=' NUMBER ';'
2414 > general_dline_min_cidr6: DLINE_MIN_CIDR6 '=' NUMBER ';'
2415   {
2416 <  ConfigGeneral.gline_min_cidr = $3;
2416 >  ConfigGeneral.dline_min_cidr6 = $3;
2417   };
2418  
2419 < general_gline_min_cidr6: GLINE_MIN_CIDR6 '=' NUMBER ';'
2419 > general_kline_min_cidr: KLINE_MIN_CIDR '=' NUMBER ';'
2420   {
2421 <  ConfigGeneral.gline_min_cidr6 = $3;
2421 >  ConfigGeneral.kline_min_cidr = $3;
2422   };
2423  
2424 < general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2424 > general_kline_min_cidr6: KLINE_MIN_CIDR6 '=' NUMBER ';'
2425   {
2426 <  ConfigGeneral.tkline_expire_notices = yylval.number;
2426 >  ConfigGeneral.kline_min_cidr6 = $3;
2427   };
2428  
2429   general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
# Line 2650 | Line 2431 | general_kill_chase_time_limit: KILL_CHAS
2431    ConfigGeneral.kill_chase_time_limit = $3;
2432   };
2433  
2653 – general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
2654 – {
2655 –  ConfigGeneral.ignore_bogus_ts = yylval.number;
2656 – };
2657 –
2434   general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
2435   {
2436    ConfigGeneral.failed_oper_notice = yylval.number;
# Line 2692 | Line 2468 | general_ts_warn_delta: TS_WARN_DELTA '='
2468  
2469   general_ts_max_delta: TS_MAX_DELTA '=' timespec ';'
2470   {
2471 <  if (conf_parser_ctx.pass == 2)
2696 <    ConfigGeneral.ts_max_delta = $3;
2697 < };
2698 <
2699 < general_havent_read_conf: HAVENT_READ_CONF '=' NUMBER ';'
2700 < {
2701 <  if (($3 > 0) && conf_parser_ctx.pass == 1)
2702 <  {
2703 <    ilog(LOG_TYPE_IRCD, "You haven't read your config file properly.");
2704 <    ilog(LOG_TYPE_IRCD, "There is a line in the example conf that will kill your server if not removed.");
2705 <    ilog(LOG_TYPE_IRCD, "Consider actually reading/editing the conf file, and removing this line.");
2706 <    exit(0);
2707 <  }
2471 >  ConfigGeneral.ts_max_delta = $3;
2472   };
2473  
2474   general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
# Line 2744 | Line 2508 | general_stats_u_oper_only: STATS_U_OPER_
2508  
2509   general_stats_k_oper_only: STATS_K_OPER_ONLY '=' TBOOL ';'
2510   {
2511 <  ConfigGeneral.stats_k_oper_only = 2 * yylval.number;
2748 < } | STATS_K_OPER_ONLY '=' TMASKED ';'
2749 < {
2750 <  ConfigGeneral.stats_k_oper_only = 1;
2511 >  ConfigGeneral.stats_k_oper_only = yylval.number;
2512   };
2513  
2514   general_stats_i_oper_only: STATS_I_OPER_ONLY '=' TBOOL ';'
2515   {
2516 <  ConfigGeneral.stats_i_oper_only = 2 * yylval.number;
2756 < } | STATS_I_OPER_ONLY '=' TMASKED ';'
2757 < {
2758 <  ConfigGeneral.stats_i_oper_only = 1;
2516 >  ConfigGeneral.stats_i_oper_only = yylval.number;
2517   };
2518  
2519   general_pace_wait: PACE_WAIT '=' timespec ';'
# Line 2788 | Line 2546 | general_no_oper_flood: NO_OPER_FLOOD '='
2546    ConfigGeneral.no_oper_flood = yylval.number;
2547   };
2548  
2791 – general_oper_pass_resv: OPER_PASS_RESV '=' TBOOL ';'
2792 – {
2793 –  ConfigGeneral.oper_pass_resv = yylval.number;
2794 – };
2795 –
2549   general_dots_in_ident: DOTS_IN_IDENT '=' NUMBER ';'
2550   {
2551    ConfigGeneral.dots_in_ident = $3;
# Line 2826 | Line 2579 | general_throttle_time: THROTTLE_TIME '='
2579   general_oper_umodes: OPER_UMODES
2580   {
2581    ConfigGeneral.oper_umodes = 0;
2582 < } '='  umode_oitems ';' ;
2582 > } '=' umode_oitems ';' ;
2583  
2584   umode_oitems:    umode_oitems ',' umode_oitem | umode_oitem;
2585 < umode_oitem:     T_BOTS
2833 < {
2834 <  ConfigGeneral.oper_umodes |= UMODE_BOTS;
2835 < } | T_CCONN
2585 > umode_oitem: T_CCONN
2586   {
2587    ConfigGeneral.oper_umodes |= UMODE_CCONN;
2588   } | T_DEAF
# Line 2841 | Line 2591 | umode_oitem:     T_BOTS
2591   } | T_DEBUG
2592   {
2593    ConfigGeneral.oper_umodes |= UMODE_DEBUG;
2594 < } | T_FULL
2594 > } | T_FLOOD
2595   {
2596 <  ConfigGeneral.oper_umodes |= UMODE_FULL;
2596 >  ConfigGeneral.oper_umodes |= UMODE_FLOOD;
2597   } | HIDDEN
2598   {
2599    ConfigGeneral.oper_umodes |= UMODE_HIDDEN;
# Line 2862 | Line 2612 | umode_oitem:     T_BOTS
2612   } | T_REJ
2613   {
2614    ConfigGeneral.oper_umodes |= UMODE_REJ;
2865 – } | T_UNAUTH
2866 – {
2867 –  ConfigGeneral.oper_umodes |= UMODE_UNAUTH;
2615   } | T_SPY
2616   {
2617    ConfigGeneral.oper_umodes |= UMODE_SPY;
# Line 2895 | Line 2642 | umode_oitem:     T_BOTS
2642   } | T_FARCONNECT
2643   {
2644    ConfigGeneral.oper_umodes |= UMODE_FARCONNECT;
2645 + } | EXPIRATION
2646 + {
2647 +  ConfigGeneral.oper_umodes |= UMODE_EXPIRATION;
2648   };
2649  
2650   general_oper_only_umodes: OPER_ONLY_UMODES
2651   {
2652    ConfigGeneral.oper_only_umodes = 0;
2653 < } '='  umode_items ';' ;
2653 > } '=' umode_items ';' ;
2654  
2655   umode_items:  umode_items ',' umode_item | umode_item;
2656 < umode_item:   T_BOTS
2907 < {
2908 <  ConfigGeneral.oper_only_umodes |= UMODE_BOTS;
2909 < } | T_CCONN
2656 > umode_item: T_CCONN
2657   {
2658    ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
2659   } | T_DEAF
# Line 2915 | Line 2662 | umode_item:   T_BOTS
2662   } | T_DEBUG
2663   {
2664    ConfigGeneral.oper_only_umodes |= UMODE_DEBUG;
2665 < } | T_FULL
2665 > } | T_FLOOD
2666   {
2667 <  ConfigGeneral.oper_only_umodes |= UMODE_FULL;
2667 >  ConfigGeneral.oper_only_umodes |= UMODE_FLOOD;
2668   } | T_SKILL
2669   {
2670    ConfigGeneral.oper_only_umodes |= UMODE_SKILL;
# Line 2930 | Line 2677 | umode_item:   T_BOTS
2677   } | T_REJ
2678   {
2679    ConfigGeneral.oper_only_umodes |= UMODE_REJ;
2933 – } | T_UNAUTH
2934 – {
2935 –  ConfigGeneral.oper_only_umodes |= UMODE_UNAUTH;
2680   } | T_SPY
2681   {
2682    ConfigGeneral.oper_only_umodes |= UMODE_SPY;
# Line 2963 | Line 2707 | umode_item:   T_BOTS
2707   } | T_FARCONNECT
2708   {
2709    ConfigGeneral.oper_only_umodes |= UMODE_FARCONNECT;
2710 + } | EXPIRATION
2711 + {
2712 +  ConfigGeneral.oper_only_umodes |= UMODE_EXPIRATION;
2713   };
2714  
2715   general_min_nonwildcard: MIN_NONWILDCARD '=' NUMBER ';'
# Line 2980 | Line 2727 | general_default_floodcount: DEFAULT_FLOO
2727    ConfigGeneral.default_floodcount = $3;
2728   };
2729  
2730 + general_default_floodtime: DEFAULT_FLOODTIME '=' timespec ';'
2731 + {
2732 +  ConfigGeneral.default_floodtime = $3;
2733 + };
2734 +
2735  
2736   /***************************************************************************
2737 < *  section channel
2737 > * channel {} section
2738   ***************************************************************************/
2739 < channel_entry: CHANNEL
2988 <  '{' channel_items '}' ';';
2739 > channel_entry: CHANNEL '{' channel_items '}' ';';
2740  
2741   channel_items:      channel_items channel_item | channel_item;
2742   channel_item:       channel_max_bans |
2743 +                    channel_max_bans_large |
2744                      channel_invite_client_count |
2745                      channel_invite_client_time |
2746 +                    channel_invite_delay_channel |
2747 +                    channel_invite_expire_time |
2748                      channel_knock_client_count |
2749                      channel_knock_client_time |
2750                      channel_knock_delay_channel |
2751                      channel_max_channels |
2752 <                    channel_default_split_user_count |
2999 <                    channel_default_split_server_count |
3000 <                    channel_no_create_on_split |
3001 <                    channel_no_join_on_split |
2752 >                    channel_max_invites |
2753                      channel_default_join_flood_count |
2754                      channel_default_join_flood_time |
2755                      channel_disable_fake_channels |
2756 +                    channel_enable_extbans |
2757                      error;
2758  
2759 + channel_enable_extbans: ENABLE_EXTBANS '=' TBOOL ';'
2760 + {
2761 +  ConfigChannel.enable_extbans = yylval.number;
2762 + };
2763 +
2764   channel_disable_fake_channels: DISABLE_FAKE_CHANNELS '=' TBOOL ';'
2765   {
2766    ConfigChannel.disable_fake_channels = yylval.number;
# Line 3019 | Line 2776 | channel_invite_client_time: INVITE_CLIEN
2776    ConfigChannel.invite_client_time = $3;
2777   };
2778  
2779 + channel_invite_delay_channel: INVITE_DELAY_CHANNEL '=' timespec ';'
2780 + {
2781 +  ConfigChannel.invite_delay_channel = $3;
2782 + };
2783 +
2784 + channel_invite_expire_time: INVITE_EXPIRE_TIME '=' timespec ';'
2785 + {
2786 +  ConfigChannel.invite_expire_time = $3;
2787 + };
2788 +
2789   channel_knock_client_count: KNOCK_CLIENT_COUNT '=' NUMBER ';'
2790   {
2791    ConfigChannel.knock_client_count = $3;
# Line 3039 | Line 2806 | channel_max_channels: MAX_CHANNELS '=' N
2806    ConfigChannel.max_channels = $3;
2807   };
2808  
2809 < channel_max_bans: MAX_BANS '=' NUMBER ';'
3043 < {
3044 <  ConfigChannel.max_bans = $3;
3045 < };
3046 <
3047 < channel_default_split_user_count: DEFAULT_SPLIT_USER_COUNT '=' NUMBER ';'
3048 < {
3049 <  ConfigChannel.default_split_user_count = $3;
3050 < };
3051 <
3052 < channel_default_split_server_count: DEFAULT_SPLIT_SERVER_COUNT '=' NUMBER ';'
2809 > channel_max_invites: MAX_INVITES '=' NUMBER ';'
2810   {
2811 <  ConfigChannel.default_split_server_count = $3;
2811 >  ConfigChannel.max_invites = $3;
2812   };
2813  
2814 < channel_no_create_on_split: NO_CREATE_ON_SPLIT '=' TBOOL ';'
2814 > channel_max_bans: MAX_BANS '=' NUMBER ';'
2815   {
2816 <  ConfigChannel.no_create_on_split = yylval.number;
2816 >  ConfigChannel.max_bans = $3;
2817   };
2818  
2819 < channel_no_join_on_split: NO_JOIN_ON_SPLIT '=' TBOOL ';'
2819 > channel_max_bans_large: MAX_BANS_LARGE '=' NUMBER ';'
2820   {
2821 <  ConfigChannel.no_join_on_split = yylval.number;
2821 >  ConfigChannel.max_bans_large = $3;
2822   };
2823  
2824   channel_default_join_flood_count: DEFAULT_JOIN_FLOOD_COUNT '=' NUMBER ';'
# Line 3074 | Line 2831 | channel_default_join_flood_time: DEFAULT
2831    ConfigChannel.default_join_flood_time = $3;
2832   };
2833  
2834 +
2835   /***************************************************************************
2836 < *  section serverhide
2836 > * serverhide {} section
2837   ***************************************************************************/
2838 < serverhide_entry: SERVERHIDE
3081 <  '{' serverhide_items '}' ';';
2838 > serverhide_entry: SERVERHIDE '{' serverhide_items '}' ';';
2839  
2840   serverhide_items:   serverhide_items serverhide_item | serverhide_item;
2841   serverhide_item:    serverhide_flatten_links |
2842 +                    serverhide_flatten_links_delay |
2843 +                    serverhide_flatten_links_file |
2844                      serverhide_disable_remote_commands |
2845                      serverhide_hide_servers |
2846                      serverhide_hide_services |
3088 –                    serverhide_links_delay |
2847                      serverhide_hidden |
2848                      serverhide_hidden_name |
2849                      serverhide_hide_server_ips |
# Line 3097 | Line 2855 | serverhide_flatten_links: FLATTEN_LINKS
2855      ConfigServerHide.flatten_links = yylval.number;
2856   };
2857  
2858 + serverhide_flatten_links_delay: FLATTEN_LINKS_DELAY '=' timespec ';'
2859 + {
2860 +  if (conf_parser_ctx.pass == 2)
2861 +  {
2862 +    if ($3 > 0)
2863 +    {
2864 +      event_write_links_file.when = $3;
2865 +      event_add(&event_write_links_file, NULL);
2866 +    }
2867 +    else
2868 +     event_delete(&event_write_links_file);
2869 +
2870 +    ConfigServerHide.flatten_links_delay = $3;
2871 +  }
2872 + };
2873 +
2874 + serverhide_flatten_links_file: FLATTEN_LINKS_FILE '=' QSTRING ';'
2875 + {
2876 +  if (conf_parser_ctx.pass == 2)
2877 +  {
2878 +    xfree(ConfigServerHide.flatten_links_file);
2879 +    ConfigServerHide.flatten_links_file = xstrdup(yylval.string);
2880 +  }
2881 + };
2882 +
2883   serverhide_disable_remote_commands: DISABLE_REMOTE_COMMANDS '=' TBOOL ';'
2884   {
2885    if (conf_parser_ctx.pass == 2)
# Line 3119 | Line 2902 | serverhide_hidden_name: HIDDEN_NAME '='
2902   {
2903    if (conf_parser_ctx.pass == 2)
2904    {
2905 <    MyFree(ConfigServerHide.hidden_name);
2905 >    xfree(ConfigServerHide.hidden_name);
2906      ConfigServerHide.hidden_name = xstrdup(yylval.string);
2907    }
2908   };
2909  
3127 – serverhide_links_delay: LINKS_DELAY '=' timespec ';'
3128 – {
3129 –  if (conf_parser_ctx.pass == 2)
3130 –  {
3131 –    if (($3 > 0) && ConfigServerHide.links_disabled == 1)
3132 –    {
3133 –      event_write_links_file.when = $3;
3134 –      event_addish(&event_write_links_file, NULL);
3135 –      ConfigServerHide.links_disabled = 0;
3136 –    }
3137 –
3138 –    ConfigServerHide.links_delay = $3;
3139 –  }
3140 – };
3141 –
2910   serverhide_hidden: HIDDEN '=' TBOOL ';'
2911   {
2912    if (conf_parser_ctx.pass == 2)

Comparing ircd-hybrid/trunk/src/conf_parser.y (property svn:keywords):
Revision 5800 by michael, Fri Apr 17 18:55:55 2015 UTC vs.
Revision 9692 by michael, Sat Oct 31 19:05:15 2020 UTC

# Line 1 | Line 1
1 < Id Revision
1 > Id

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)