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 7624 by michael, Thu Jun 23 12:44:09 2016 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-2016 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 31 | Line 31
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"
# Line 90 | 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,
100 –    max_global,
101 –    max_local,
103      max_sendq,
104      max_recvq,
105      max_channels,
# Line 110 | 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 <    xfree(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)
123 <  {
124 <    xfree(node->data);
125 <    dlinkDelete(node, &block_state.leaf.list);
126 <    free_dlink_node(node);
127 <  }
128 <
129 <  DLINK_FOREACH_SAFE(node, node_next, block_state.hub.list.head)
130 <  {
131 <    xfree(node->data);
132 <    dlinkDelete(node, &block_state.hub.list);
133 <    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 155 | Line 147 | reset_block_state(void)
147   %token  CALLER_ID_WAIT
148   %token  CAN_FLOOD
149   %token  CHANNEL
158 – %token  CHECK_CACHE
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  DEFER
164   %token  DENY
165   %token  DESCRIPTION
166   %token  DIE
# Line 177 | Line 171 | reset_block_state(void)
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
# Line 197 | Line 193 | reset_block_state(void)
193   %token  HOST
194   %token  HUB
195   %token  HUB_MASK
200 – %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
# Line 217 | Line 213 | reset_block_state(void)
213   %token  KNOCK_CLIENT_TIME
214   %token  KNOCK_DELAY_CHANNEL
215   %token  LEAF_MASK
220 – %token  LIBGEOIP_DATABASE_OPTIONS
221 – %token  LIBGEOIP_IPV4_DATABASE_FILE
222 – %token  LIBGEOIP_IPV6_DATABASE_FILE
216   %token  LISTEN
217   %token  MASK
218   %token  MAX_ACCEPT
219   %token  MAX_BANS
220 + %token  MAX_BANS_LARGE
221   %token  MAX_CHANNELS
228 – %token  MAX_GLOBAL
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 235 | Line 228 | reset_block_state(void)
228   %token  MAX_TARGETS
229   %token  MAX_TOPIC_LENGTH
230   %token  MAX_WATCH
238 – %token  MEMORY_CACHE
231   %token  MIN_IDLE
232   %token  MIN_NONWILDCARD
233   %token  MIN_NONWILDCARD_SIMPLE
242 – %token  MMAP_CACHE
234   %token  MODULE
235   %token  MODULES
236   %token  MOTD
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
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
250   %token  OPER_UMODES
251   %token  OPERATOR
# Line 283 | Line 275 | reset_block_state(void)
275   %token  SERVERINFO
276   %token  SHORT_MOTD
277   %token  SPOOF
286 – %token  SPOOF_NOTICE
278   %token  SQUIT
288 – %token  SSL_CERTIFICATE_FILE
289 – %token  SSL_CERTIFICATE_FINGERPRINT
290 – %token  SSL_CONNECTION_REQUIRED
291 – %token  SSL_DH_ELLIPTIC_CURVE
292 – %token  SSL_DH_PARAM_FILE
293 – %token  SSL_MESSAGE_DIGEST_ALGORITHM
294 – %token  STANDARD
279   %token  STATS_E_DISABLED
280   %token  STATS_I_OPER_ONLY
281   %token  STATS_K_OPER_ONLY
# Line 300 | 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 311 | 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 335 | Line 319 | reset_block_state(void)
319   %token  T_SKILL
320   %token  T_SOFTCALLERID
321   %token  T_SPY
338 – %token  T_SSL
339 – %token  T_SSL_CIPHER_LIST
322   %token  T_TARGET
323 + %token  T_TLS
324   %token  T_UMODES
342 – %token  T_UNAUTH
325   %token  T_UNDLINE
326   %token  T_UNLIMITED
327   %token  T_UNRESV
# Line 350 | 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 447 | Line 436 | modules_path: PATH '=' QSTRING ';'
436  
437  
438   /***************************************************************************
439 < * serverinfo {}  section
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 |
456 –                        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 |
467 –                        serverinfo_vhost6 |
455                          serverinfo_sid |
456 <                        serverinfo_ssl_certificate_file |
457 <                        serverinfo_ssl_cipher_list |
458 <                        serverinfo_ssl_message_digest_algorithm |
459 <                        serverinfo_libgeoip_database_options |
473 <                        serverinfo_libgeoip_ipv4_database_file |
474 <                        serverinfo_libgeoip_ipv6_database_file |
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   {
465    if (conf_parser_ctx.pass == 2)
466    {
467 <    xfree(ConfigServerInfo.ssl_certificate_file);
468 <    ConfigServerInfo.ssl_certificate_file = xstrdup(yylval.string);
467 >    xfree(ConfigServerInfo.tls_certificate_file);
468 >    ConfigServerInfo.tls_certificate_file = xstrdup(yylval.string);
469    }
470   };
471  
# Line 493 | Line 478 | serverinfo_rsa_private_key_file: RSA_PRI
478    }
479   };
480  
481 < serverinfo_ssl_dh_param_file: SSL_DH_PARAM_FILE '=' QSTRING ';'
481 > serverinfo_tls_dh_param_file: TLS_DH_PARAM_FILE '=' QSTRING ';'
482   {
483    if (conf_parser_ctx.pass == 2)
484    {
485 <    xfree(ConfigServerInfo.ssl_dh_param_file);
486 <    ConfigServerInfo.ssl_dh_param_file = xstrdup(yylval.string);
485 >    xfree(ConfigServerInfo.tls_dh_param_file);
486 >    ConfigServerInfo.tls_dh_param_file = xstrdup(yylval.string);
487    }
488   };
489  
490 < serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
490 > serverinfo_tls_cipher_list: TLS_CIPHER_LIST '=' QSTRING ';'
491   {
492    if (conf_parser_ctx.pass == 2)
493    {
494 <    xfree(ConfigServerInfo.ssl_cipher_list);
495 <    ConfigServerInfo.ssl_cipher_list = xstrdup(yylval.string);
494 >    xfree(ConfigServerInfo.tls_cipher_list);
495 >    ConfigServerInfo.tls_cipher_list = xstrdup(yylval.string);
496    }
497   };
498  
499 < serverinfo_ssl_message_digest_algorithm: SSL_MESSAGE_DIGEST_ALGORITHM '=' QSTRING ';'
515 < {
516 <  if (conf_parser_ctx.pass == 2)
517 <  {
518 <    xfree(ConfigServerInfo.ssl_message_digest_algorithm);
519 <    ConfigServerInfo.ssl_message_digest_algorithm = xstrdup(yylval.string);
520 <  }
521 < }
522 <
523 < serverinfo_ssl_dh_elliptic_curve: SSL_DH_ELLIPTIC_CURVE '=' QSTRING ';'
499 > serverinfo_tls_cipher_suites: TLS_CIPHER_SUITES '=' QSTRING ';'
500   {
501    if (conf_parser_ctx.pass == 2)
502    {
503 <    xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
504 <    ConfigServerInfo.ssl_dh_elliptic_curve = xstrdup(yylval.string);
503 >    xfree(ConfigServerInfo.tls_cipher_suites);
504 >    ConfigServerInfo.tls_cipher_suites = xstrdup(yylval.string);
505    }
506   };
507  
508 < serverinfo_libgeoip_database_options: LIBGEOIP_DATABASE_OPTIONS
533 < {
534 <  if (conf_parser_ctx.pass == 1)
535 <    ConfigServerInfo.libgeoip_database_options = 0;
536 < } '='  options_items ';';
537 <
538 < options_items: options_items ',' options_item | options_item;
539 < options_item: STANDARD
540 < {
541 < #ifdef HAVE_LIBGEOIP
542 <  if (conf_parser_ctx.pass == 1)
543 <    ConfigServerInfo.libgeoip_database_options |= GEOIP_STANDARD;
544 < #endif
545 < } | MEMORY_CACHE
546 < {
547 < #ifdef HAVE_LIBGEOIP
548 <  if (conf_parser_ctx.pass == 1)
549 <    ConfigServerInfo.libgeoip_database_options |= GEOIP_MEMORY_CACHE;
550 < #endif
551 < } | MMAP_CACHE
552 < {
553 < #ifdef HAVE_LIBGEOIP
554 <  if (conf_parser_ctx.pass == 1)
555 <    ConfigServerInfo.libgeoip_database_options |= GEOIP_MMAP_CACHE;
556 < #endif
557 < } | CHECK_CACHE
558 < {
559 < #ifdef HAVE_LIBGEOIP
560 <  if (conf_parser_ctx.pass == 1)
561 <    ConfigServerInfo.libgeoip_database_options |= GEOIP_CHECK_CACHE;
562 < #endif
563 < };
564 <
565 < serverinfo_libgeoip_ipv4_database_file:  LIBGEOIP_IPV4_DATABASE_FILE '=' QSTRING ';'
508 > serverinfo_tls_message_digest_algorithm: TLS_MESSAGE_DIGEST_ALGORITHM '=' QSTRING ';'
509   {
510    if (conf_parser_ctx.pass == 2)
511    {
512 <    xfree(ConfigServerInfo.libgeoip_ipv4_database_file);
513 <    ConfigServerInfo.libgeoip_ipv4_database_file = xstrdup(yylval.string);
571 <
572 < #ifdef HAVE_LIBGEOIP
573 <    if (GeoIPv4_ctx)
574 <      GeoIP_delete(GeoIPv4_ctx);
575 <    GeoIPv4_ctx = GeoIP_open(yylval.string, ConfigServerInfo.libgeoip_database_options);
576 < #endif
512 >    xfree(ConfigServerInfo.tls_message_digest_algorithm);
513 >    ConfigServerInfo.tls_message_digest_algorithm = xstrdup(yylval.string);
514    }
515 < };
515 > }
516  
517 < serverinfo_libgeoip_ipv6_database_file:  LIBGEOIP_IPV6_DATABASE_FILE '=' QSTRING ';'
517 > serverinfo_tls_supported_groups: TLS_SUPPORTED_GROUPS '=' QSTRING ';'
518   {
519    if (conf_parser_ctx.pass == 2)
520    {
521 <    xfree(ConfigServerInfo.libgeoip_ipv6_database_file);
522 <    ConfigServerInfo.libgeoip_ipv6_database_file = xstrdup(yylval.string);
586 <
587 < #ifdef HAVE_LIBGEOIP
588 <    if (GeoIPv6_ctx)
589 <      GeoIP_delete(GeoIPv6_ctx);
590 <    GeoIPv6_ctx = GeoIP_open(yylval.string, ConfigServerInfo.libgeoip_database_options);
591 < #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)
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      {
# Line 610 | Line 541 | serverinfo_name: NAME '=' QSTRING ';'
541   serverinfo_sid: IRCD_SID '=' QSTRING ';'
542   {
543    /* This isn't rehashable */
544 <  if (conf_parser_ctx.pass == 2 && !ConfigServerInfo.sid)
544 >  if (conf_parser_ctx.pass == 2 && ConfigServerInfo.sid == NULL)
545    {
546      if (valid_sid(yylval.string))
547        ConfigServerInfo.sid = xstrdup(yylval.string);
# Line 636 | 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      xfree(ConfigServerInfo.network_name);
# Line 646 | Line 577 | serverinfo_network_name: NETWORK_NAME '=
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 <  xfree(ConfigServerInfo.network_desc);
586 <  ConfigServerInfo.network_desc = xstrdup(yylval.string);
656 < };
657 <
658 < serverinfo_vhost: VHOST '=' QSTRING ';'
659 < {
660 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
661 <  {
662 <    struct addrinfo hints, *res;
663 <
664 <    memset(&hints, 0, sizeof(hints));
665 <
666 <    hints.ai_family   = AF_UNSPEC;
667 <    hints.ai_socktype = SOCK_STREAM;
668 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
669 <
670 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
671 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
672 <    else
673 <    {
674 <      assert(res);
675 <
676 <      memcpy(&ConfigServerInfo.ip, res->ai_addr, res->ai_addrlen);
677 <      ConfigServerInfo.ip.ss.ss_family = res->ai_family;
678 <      ConfigServerInfo.ip.ss_len = res->ai_addrlen;
679 <      freeaddrinfo(res);
680 <
681 <      ConfigServerInfo.specific_ipv4_vhost = 1;
682 <    }
683 <  }
684 < };
685 <
686 < serverinfo_vhost6: VHOST6 '=' QSTRING ';'
687 < {
688 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
689 <  {
690 <    struct addrinfo hints, *res;
691 <
692 <    memset(&hints, 0, sizeof(hints));
693 <
694 <    hints.ai_family   = AF_UNSPEC;
695 <    hints.ai_socktype = SOCK_STREAM;
696 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
697 <
698 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
699 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
700 <    else
701 <    {
702 <      assert(res);
703 <
704 <      memcpy(&ConfigServerInfo.ip6, res->ai_addr, res->ai_addrlen);
705 <      ConfigServerInfo.ip6.ss.ss_family = res->ai_family;
706 <      ConfigServerInfo.ip6.ss_len = res->ai_addrlen;
707 <      freeaddrinfo(res);
708 <
709 <      ConfigServerInfo.specific_ipv6_vhost = 1;
710 <    }
711 <  }
585 >  xfree(ConfigServerInfo.network_description);
586 >  ConfigServerInfo.network_description = xstrdup(yylval.string);
587   };
588  
589   serverinfo_default_max_clients: DEFAULT_MAX_CLIENTS '=' NUMBER ';'
# Line 716 | 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 <
723 <    snprintf(buf, sizeof(buf), "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
724 <    conf_error_report(buf);
725 <    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 748 | 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 770 | 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 790 | Line 665 | serverinfo_hub: HUB '=' TBOOL ';'
665   /***************************************************************************
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 835 | 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 928 | Line 803 | pseudo_target: T_TARGET '=' QSTRING ';'
803   /***************************************************************************
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 980 | 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 1030 | 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;
# Line 1043 | Line 918 | oper_entry: OPERATOR
918  
919    DLINK_FOREACH(node, block_state.mask.list.head)
920    {
1046 –    struct MaskItem *conf = NULL;
921      struct split_nuh_item nuh;
922      char *s = node->data;
923  
# Line 1054 | Line 928 | oper_entry: OPERATOR
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 1076 | 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);
959    }
# Line 1090 | Line 967 | oper_item:      oper_name |
967                  oper_umodes |
968                  oper_class |
969                  oper_encrypted |
970 <                oper_ssl_certificate_fingerprint |
971 <                oper_ssl_connection_required |
970 >                oper_tls_certificate_fingerprint |
971 >                oper_tls_connection_required |
972                  oper_flags |
973                  error ';' ;
974  
# Line 1130 | Line 1007 | oper_encrypted: ENCRYPTED '=' TBOOL ';'
1007      block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
1008   };
1009  
1010 < 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 1157 | 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
1164 < {
1165 <  if (conf_parser_ctx.pass == 2)
1166 <    block_state.modes.value |= UMODE_BOTS;
1167 < } | T_CCONN
1040 > oper_umodes_item:  T_CCONN
1041   {
1042    if (conf_parser_ctx.pass == 2)
1043      block_state.modes.value |= UMODE_CCONN;
# Line 1176 | 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 1204 | Line 1077 | oper_umodes_item:  T_BOTS
1077   {
1078    if (conf_parser_ctx.pass == 2)
1079      block_state.modes.value |= UMODE_REJ;
1207 – } | T_UNAUTH
1208 – {
1209 –  if (conf_parser_ctx.pass == 2)
1210 –    block_state.modes.value |= UMODE_UNAUTH;
1080   } | T_SPY
1081   {
1082    if (conf_parser_ctx.pass == 2)
# Line 1248 | 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 1388 | Line 1261 | class_entry: CLASS
1261  
1262    block_state.ping_freq.value = DEFAULT_PINGFREQUENCY;
1263    block_state.con_freq.value  = DEFAULT_CONNECTFREQUENCY;
1391 –  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   {
1396 –  struct ClassItem *class = NULL;
1397 –
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;
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;
1414 –  class->max_global = block_state.max_global.value;
1415 –  class->max_local = block_state.max_local.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 1428 | 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 <  rebuild_cidr_list(class);
1302 <
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 1441 | 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 |
1448 –                class_max_global |
1449 –                class_max_local |
1322                  class_sendq |
1323                  class_recvq |
1324                  class_min_idle |
# Line 1466 | 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 1490 | Line 1368 | class_max_number: MAX_NUMBER '=' NUMBER
1368      block_state.max_total.value = $3;
1369   };
1370  
1493 – class_max_global: MAX_GLOBAL '=' NUMBER ';'
1494 – {
1495 –  if (conf_parser_ctx.pass == 1)
1496 –    block_state.max_global.value = $3;
1497 – };
1498 –
1499 – class_max_local: MAX_LOCAL '=' NUMBER ';'
1500 – {
1501 –  if (conf_parser_ctx.pass == 1)
1502 –    block_state.max_local.value = $3;
1503 – };
1504 –
1371   class_sendq: SENDQ '=' sizespec ';'
1372   {
1373    if (conf_parser_ctx.pass == 1)
# Line 1555 | 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 1581 | 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 1596 | 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 1610 | Line 1484 | port_item: NUMBER
1484    if (conf_parser_ctx.pass == 2)
1485    {
1486   #ifndef HAVE_TLS
1487 <    if (block_state.flags.value & LISTENER_SSL)
1487 >    if (block_state.flags.value & LISTENER_TLS)
1488      {
1489        conf_error_report("TLS not available - port closed");
1490        break;
# Line 1623 | Line 1497 | port_item: NUMBER
1497    if (conf_parser_ctx.pass == 2)
1498    {
1499   #ifndef HAVE_TLS
1500 <    if (block_state.flags.value & LISTENER_SSL)
1500 >    if (block_state.flags.value & LISTENER_TLS)
1501      {
1502        conf_error_report("TLS not available - port closed");
1503        break;
# Line 1657 | 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    {
1667 –    struct MaskItem *conf = NULL;
1541      struct split_nuh_item nuh;
1542      char *s = node->data;
1543  
# Line 1675 | Line 1548 | auth_entry: IRCD_AUTH
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 1690 | 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 1741 | 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
1748 < {
1749 <  if (conf_parser_ctx.pass == 2)
1750 <    block_state.flags.value |= CONF_FLAGS_SPOOF_NOTICE;
1751 < } | 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 1872 | 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 ServiceItem *service = service_make();
1749      service->name = xstrdup(yylval.string);
# Line 2077 | 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   {
2082 –  struct MaskItem *conf = NULL;
1954    struct addrinfo hints, *res;
1955  
1956    if (conf_parser_ctx.pass != 2)
# Line 2093 | 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 2124 | 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 2169 | 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 2180 | 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 2193 | 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 2226 | 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 2268 | 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_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 TLS support");
2162 >    conf_error_report("Ignoring connect::tls_cipher_list -- no TLS support");
2163   #endif
2164   };
2165  
# Line 2289 | Line 2173 | kill_entry: KILL
2173      reset_block_state();
2174   } '{' kill_items '}' ';'
2175   {
2292 –  struct MaskItem *conf = NULL;
2293 –
2176    if (conf_parser_ctx.pass != 2)
2177      break;
2178  
# Line 2298 | 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 2348 | Line 2230 | deny_entry: DENY
2230      reset_block_state();
2231   } '{' deny_items '}' ';'
2232   {
2351 –  struct MaskItem *conf = NULL;
2352 –
2233    if (conf_parser_ctx.pass != 2)
2234      break;
2235  
# Line 2358 | 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 2455 | Line 2335 | general_entry: GENERAL '{' general_items
2335   general_items:      general_items general_item | general_item;
2336   general_item:       general_away_count |
2337                      general_away_time |
2458 –                    general_ignore_bogus_ts |
2338                      general_failed_oper_notice |
2339                      general_anti_nick_flood |
2340                      general_max_nick_time |
# Line 2485 | Line 2364 | general_item:       general_away_count |
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 |
2372                      general_ping_cookie |
2373                      general_disable_auth |
2494 –                    general_tkline_expire_notices |
2374                      general_dline_min_cidr |
2375                      general_dline_min_cidr6 |
2376                      general_kline_min_cidr |
# Line 2524 | Line 2403 | general_whowas_history_length: WHOWAS_HI
2403  
2404   general_cycle_on_host_change: CYCLE_ON_HOST_CHANGE '=' TBOOL ';'
2405   {
2406 <  if (conf_parser_ctx.pass == 2)
2528 <    ConfigGeneral.cycle_on_host_change = yylval.number;
2406 >  ConfigGeneral.cycle_on_host_change = yylval.number;
2407   };
2408  
2409   general_dline_min_cidr: DLINE_MIN_CIDR '=' NUMBER ';'
# Line 2548 | Line 2426 | general_kline_min_cidr6: KLINE_MIN_CIDR6
2426    ConfigGeneral.kline_min_cidr6 = $3;
2427   };
2428  
2551 – general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2552 – {
2553 –  ConfigGeneral.tkline_expire_notices = yylval.number;
2554 – };
2555 –
2429   general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
2430   {
2431    ConfigGeneral.kill_chase_time_limit = $3;
2432   };
2433  
2561 – general_ignore_bogus_ts: IGNORE_BOGUS_TS '=' TBOOL ';'
2562 – {
2563 –  ConfigGeneral.ignore_bogus_ts = yylval.number;
2564 – };
2565 –
2434   general_failed_oper_notice: FAILED_OPER_NOTICE '=' TBOOL ';'
2435   {
2436    ConfigGeneral.failed_oper_notice = yylval.number;
# Line 2600 | 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)
2604 <    ConfigGeneral.ts_max_delta = $3;
2471 >  ConfigGeneral.ts_max_delta = $3;
2472   };
2473  
2474   general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
# Line 2641 | 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;
2645 < } | STATS_K_OPER_ONLY '=' TMASKED ';'
2646 < {
2647 <  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;
2653 < } | STATS_I_OPER_ONLY '=' TMASKED ';'
2654 < {
2655 <  ConfigGeneral.stats_i_oper_only = 1;
2516 >  ConfigGeneral.stats_i_oper_only = yylval.number;
2517   };
2518  
2519   general_pace_wait: PACE_WAIT '=' timespec ';'
# Line 2718 | 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
2725 < {
2726 <  ConfigGeneral.oper_umodes |= UMODE_BOTS;
2727 < } | T_CCONN
2585 > umode_oitem: T_CCONN
2586   {
2587    ConfigGeneral.oper_umodes |= UMODE_CCONN;
2588   } | T_DEAF
# Line 2733 | 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 2754 | Line 2612 | umode_oitem:     T_BOTS
2612   } | T_REJ
2613   {
2614    ConfigGeneral.oper_umodes |= UMODE_REJ;
2757 – } | T_UNAUTH
2758 – {
2759 –  ConfigGeneral.oper_umodes |= UMODE_UNAUTH;
2615   } | T_SPY
2616   {
2617    ConfigGeneral.oper_umodes |= UMODE_SPY;
# Line 2787 | 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
2799 < {
2800 <  ConfigGeneral.oper_only_umodes |= UMODE_BOTS;
2801 < } | T_CCONN
2656 > umode_item: T_CCONN
2657   {
2658    ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
2659   } | T_DEAF
# Line 2807 | 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 2822 | Line 2677 | umode_item:   T_BOTS
2677   } | T_REJ
2678   {
2679    ConfigGeneral.oper_only_umodes |= UMODE_REJ;
2825 – } | T_UNAUTH
2826 – {
2827 –  ConfigGeneral.oper_only_umodes |= UMODE_UNAUTH;
2680   } | T_SPY
2681   {
2682    ConfigGeneral.oper_only_umodes |= UMODE_SPY;
# Line 2855 | 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 2872 | 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   * channel {} section
# Line 2880 | Line 2740 | 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_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 2912 | Line 2781 | channel_invite_delay_channel: INVITE_DEL
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 2932 | Line 2806 | channel_max_channels: MAX_CHANNELS '=' N
2806    ConfigChannel.max_channels = $3;
2807   };
2808  
2809 + channel_max_invites: MAX_INVITES '=' NUMBER ';'
2810 + {
2811 +  ConfigChannel.max_invites = $3;
2812 + };
2813 +
2814   channel_max_bans: MAX_BANS '=' NUMBER ';'
2815   {
2816    ConfigChannel.max_bans = $3;
2817   };
2818  
2819 + channel_max_bans_large: MAX_BANS_LARGE '=' NUMBER ';'
2820 + {
2821 +  ConfigChannel.max_bans_large = $3;
2822 + };
2823 +
2824   channel_default_join_flood_count: DEFAULT_JOIN_FLOOD_COUNT '=' NUMBER ';'
2825   {
2826    ConfigChannel.default_join_flood_count = yylval.number;

Comparing ircd-hybrid/trunk/src/conf_parser.y (property svn:keywords):
Revision 7624 by michael, Thu Jun 23 12:44:09 2016 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)