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 8792 by michael, Thu Jan 17 18:35:32 2019 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-2019 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 91 | Line 91 | static struct
91      size,
92      type,
93      port,
94 +    timeout,
95      aftype,
96      ping_freq,
97      max_perip_local,
# 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 158 | 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
# Line 167 | Line 160 | reset_block_state(void)
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 241 | 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
243   %token  NO_OPER_FLOOD
# Line 279 | Line 275 | reset_block_state(void)
275   %token  SERVERINFO
276   %token  SHORT_MOTD
277   %token  SPOOF
282 – %token  SPOOF_NOTICE
278   %token  SQUIT
284 – %token  SSL_CERTIFICATE_FILE
285 – %token  SSL_CERTIFICATE_FINGERPRINT
286 – %token  SSL_CONNECTION_REQUIRED
287 – %token  SSL_DH_ELLIPTIC_CURVE
288 – %token  SSL_DH_PARAM_FILE
289 – %token  SSL_MESSAGE_DIGEST_ALGORITHM
279   %token  STATS_E_DISABLED
280   %token  STATS_I_OPER_ONLY
281   %token  STATS_K_OPER_ONLY
# Line 295 | 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 306 | 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 330 | Line 319 | reset_block_state(void)
319   %token  T_SKILL
320   %token  T_SOFTCALLERID
321   %token  T_SPY
333 – %token  T_SSL
334 – %token  T_SSL_CIPHER_LIST
322   %token  T_TARGET
323 + %token  T_TLS
324   %token  T_UMODES
337 – %token  T_UNAUTH
325   %token  T_UNDLINE
326   %token  T_UNLIMITED
327   %token  T_UNRESV
# Line 345 | 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 442 | 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 |
451 –                        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 |
462 –                        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   {
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 485 | 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.tls_dh_param_file);
486 >    ConfigServerInfo.tls_dh_param_file = xstrdup(yylval.string);
487 >  }
488 > };
489 >
490 > serverinfo_tls_cipher_list: TLS_CIPHER_LIST '=' QSTRING ';'
491   {
492    if (conf_parser_ctx.pass == 2)
493    {
494 <    xfree(ConfigServerInfo.ssl_dh_param_file);
495 <    ConfigServerInfo.ssl_dh_param_file = xstrdup(yylval.string);
494 >    xfree(ConfigServerInfo.tls_cipher_list);
495 >    ConfigServerInfo.tls_cipher_list = xstrdup(yylval.string);
496    }
497   };
498  
499 < serverinfo_ssl_cipher_list: T_SSL_CIPHER_LIST '=' QSTRING ';'
499 > serverinfo_tls_cipher_suites: TLS_CIPHER_SUITES '=' QSTRING ';'
500   {
501    if (conf_parser_ctx.pass == 2)
502    {
503 <    xfree(ConfigServerInfo.ssl_cipher_list);
504 <    ConfigServerInfo.ssl_cipher_list = xstrdup(yylval.string);
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   {
510    if (conf_parser_ctx.pass == 2)
511    {
512 <    xfree(ConfigServerInfo.ssl_message_digest_algorithm);
513 <    ConfigServerInfo.ssl_message_digest_algorithm = xstrdup(yylval.string);
512 >    xfree(ConfigServerInfo.tls_message_digest_algorithm);
513 >    ConfigServerInfo.tls_message_digest_algorithm = xstrdup(yylval.string);
514    }
515   }
516  
517 < serverinfo_ssl_dh_elliptic_curve: SSL_DH_ELLIPTIC_CURVE '=' QSTRING ';'
517 > serverinfo_tls_supported_groups: TLS_SUPPORTED_GROUPS '=' QSTRING ';'
518   {
519    if (conf_parser_ctx.pass == 2)
520    {
521 <    xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
522 <    ConfigServerInfo.ssl_dh_elliptic_curve = xstrdup(yylval.string);
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 (server_valid_name(yylval.string) == true)
532        ConfigServerInfo.name = xstrdup(yylval.string);
# Line 539 | 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 565 | 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 575 | 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);
585 < };
586 <
587 < serverinfo_vhost: VHOST '=' QSTRING ';'
588 < {
589 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
590 <  {
591 <    struct addrinfo hints, *res;
592 <
593 <    memset(&hints, 0, sizeof(hints));
594 <
595 <    hints.ai_family   = AF_UNSPEC;
596 <    hints.ai_socktype = SOCK_STREAM;
597 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
598 <
599 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
600 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost(%s)", yylval.string);
601 <    else
602 <    {
603 <      assert(res);
604 <
605 <      memcpy(&ConfigServerInfo.ip, res->ai_addr, res->ai_addrlen);
606 <      ConfigServerInfo.ip.ss.ss_family = res->ai_family;
607 <      ConfigServerInfo.ip.ss_len = res->ai_addrlen;
608 <      freeaddrinfo(res);
609 <
610 <      ConfigServerInfo.specific_ipv4_vhost = 1;
611 <    }
612 <  }
613 < };
614 <
615 < serverinfo_vhost6: VHOST6 '=' QSTRING ';'
616 < {
617 <  if (conf_parser_ctx.pass == 2 && *yylval.string != '*')
618 <  {
619 <    struct addrinfo hints, *res;
620 <
621 <    memset(&hints, 0, sizeof(hints));
622 <
623 <    hints.ai_family   = AF_UNSPEC;
624 <    hints.ai_socktype = SOCK_STREAM;
625 <    hints.ai_flags    = AI_PASSIVE | AI_NUMERICHOST;
626 <
627 <    if (getaddrinfo(yylval.string, NULL, &hints, &res))
628 <      ilog(LOG_TYPE_IRCD, "Invalid netmask for server vhost6(%s)", yylval.string);
629 <    else
630 <    {
631 <      assert(res);
632 <
633 <      memcpy(&ConfigServerInfo.ip6, res->ai_addr, res->ai_addrlen);
634 <      ConfigServerInfo.ip6.ss.ss_family = res->ai_family;
635 <      ConfigServerInfo.ip6.ss_len = res->ai_addrlen;
636 <      freeaddrinfo(res);
637 <
638 <      ConfigServerInfo.specific_ipv6_vhost = 1;
639 <    }
640 <  }
585 >  xfree(ConfigServerInfo.network_description);
586 >  ConfigServerInfo.network_description = xstrdup(yylval.string);
587   };
588  
589   serverinfo_default_max_clients: DEFAULT_MAX_CLIENTS '=' NUMBER ';'
# Line 652 | Line 598 | serverinfo_default_max_clients: DEFAULT_
598    }
599    else if ($3 > MAXCLIENTS_MAX)
600    {
601 <    char buf[IRCD_BUFSIZE] = "";
601 >    char buf[IRCD_BUFSIZE];
602  
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 674 | 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 696 | 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 716 | 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 761 | 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 854 | 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 906 | 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 956 | 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 969 | Line 918 | oper_entry: OPERATOR
918  
919    DLINK_FOREACH(node, block_state.mask.list.head)
920    {
972 –    struct MaskItem *conf = NULL;
921      struct split_nuh_item nuh;
922      char *s = node->data;
923  
# Line 980 | 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 1002 | 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 1016 | 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 1056 | 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 1083 | 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
1090 < {
1091 <  if (conf_parser_ctx.pass == 2)
1092 <    block_state.modes.value |= UMODE_BOTS;
1093 < } | T_CCONN
1040 > oper_umodes_item:  T_CCONN
1041   {
1042    if (conf_parser_ctx.pass == 2)
1043      block_state.modes.value |= UMODE_CCONN;
# Line 1102 | 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 1130 | Line 1077 | oper_umodes_item:  T_BOTS
1077   {
1078    if (conf_parser_ctx.pass == 2)
1079      block_state.modes.value |= UMODE_REJ;
1133 – } | T_UNAUTH
1134 – {
1135 –  if (conf_parser_ctx.pass == 2)
1136 –    block_state.modes.value |= UMODE_UNAUTH;
1080   } | T_SPY
1081   {
1082    if (conf_parser_ctx.pass == 2)
# Line 1174 | 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 1314 | Line 1261 | class_entry: CLASS
1261  
1262    block_state.ping_freq.value = DEFAULT_PINGFREQUENCY;
1263    block_state.con_freq.value  = DEFAULT_CONNECTFREQUENCY;
1317 –  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   {
1322 –  struct ClassItem *class = NULL;
1323 –
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, false)))
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;
# Line 1353 | 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 <  int diff = (class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value ||
1302 <              class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value);
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;
# Line 1476 | 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 1502 | 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 1517 | 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 1531 | 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 1544 | 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 1578 | 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    {
1588 –    struct MaskItem *conf = NULL;
1541      struct split_nuh_item nuh;
1542      char *s = node->data;
1543  
# Line 1596 | 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 1611 | 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 1662 | 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
1669 < {
1670 <  if (conf_parser_ctx.pass == 2)
1671 <    block_state.flags.value |= CONF_FLAGS_SPOOF_NOTICE;
1672 < } | 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 1998 | 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   {
2003 –  struct MaskItem *conf = NULL;
1954    struct addrinfo hints, *res;
1955  
1956    if (conf_parser_ctx.pass != 2)
# Line 2014 | 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 2045 | 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 2090 | 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 2101 | 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 2114 | 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 2147 | 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 2189 | 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 2210 | Line 2173 | kill_entry: KILL
2173      reset_block_state();
2174   } '{' kill_items '}' ';'
2175   {
2213 –  struct MaskItem *conf = NULL;
2214 –
2176    if (conf_parser_ctx.pass != 2)
2177      break;
2178  
# Line 2219 | 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 2269 | Line 2230 | deny_entry: DENY
2230      reset_block_state();
2231   } '{' deny_items '}' ';'
2232   {
2272 –  struct MaskItem *conf = NULL;
2273 –
2233    if (conf_parser_ctx.pass != 2)
2234      break;
2235  
# Line 2279 | 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 2412 | Line 2371 | general_item:       general_away_count |
2371                      general_throttle_time |
2372                      general_ping_cookie |
2373                      general_disable_auth |
2415 –                    general_tkline_expire_notices |
2374                      general_dline_min_cidr |
2375                      general_dline_min_cidr6 |
2376                      general_kline_min_cidr |
# Line 2445 | 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)
2449 <    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 2469 | Line 2426 | general_kline_min_cidr6: KLINE_MIN_CIDR6
2426    ConfigGeneral.kline_min_cidr6 = $3;
2427   };
2428  
2472 – general_tkline_expire_notices: TKLINE_EXPIRE_NOTICES '=' TBOOL ';'
2473 – {
2474 –  ConfigGeneral.tkline_expire_notices = yylval.number;
2475 – };
2476 –
2429   general_kill_chase_time_limit: KILL_CHASE_TIME_LIMIT '=' timespec ';'
2430   {
2431    ConfigGeneral.kill_chase_time_limit = $3;
# Line 2516 | 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)
2520 <    ConfigGeneral.ts_max_delta = $3;
2471 >  ConfigGeneral.ts_max_delta = $3;
2472   };
2473  
2474   general_invisible_on_connect: INVISIBLE_ON_CONNECT '=' TBOOL ';'
# Line 2557 | 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;
2561 < } | STATS_K_OPER_ONLY '=' TMASKED ';'
2562 < {
2563 <  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;
2569 < } | STATS_I_OPER_ONLY '=' TMASKED ';'
2570 < {
2571 <  ConfigGeneral.stats_i_oper_only = 1;
2516 >  ConfigGeneral.stats_i_oper_only = yylval.number;
2517   };
2518  
2519   general_pace_wait: PACE_WAIT '=' timespec ';'
# Line 2634 | 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
2641 < {
2642 <  ConfigGeneral.oper_umodes |= UMODE_BOTS;
2643 < } | T_CCONN
2585 > umode_oitem: T_CCONN
2586   {
2587    ConfigGeneral.oper_umodes |= UMODE_CCONN;
2588   } | T_DEAF
# Line 2649 | 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 2670 | Line 2612 | umode_oitem:     T_BOTS
2612   } | T_REJ
2613   {
2614    ConfigGeneral.oper_umodes |= UMODE_REJ;
2673 – } | T_UNAUTH
2674 – {
2675 –  ConfigGeneral.oper_umodes |= UMODE_UNAUTH;
2615   } | T_SPY
2616   {
2617    ConfigGeneral.oper_umodes |= UMODE_SPY;
# Line 2703 | 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
2715 < {
2716 <  ConfigGeneral.oper_only_umodes |= UMODE_BOTS;
2717 < } | T_CCONN
2656 > umode_item: T_CCONN
2657   {
2658    ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
2659   } | T_DEAF
# Line 2723 | 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 2738 | Line 2677 | umode_item:   T_BOTS
2677   } | T_REJ
2678   {
2679    ConfigGeneral.oper_only_umodes |= UMODE_REJ;
2741 – } | T_UNAUTH
2742 – {
2743 –  ConfigGeneral.oper_only_umodes |= UMODE_UNAUTH;
2680   } | T_SPY
2681   {
2682    ConfigGeneral.oper_only_umodes |= UMODE_SPY;
# Line 2771 | 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 2814 | Line 2753 | channel_item:       channel_max_bans |
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;

Diff Legend

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