#define CF_TYPE(x) ((x) & CF_MTYPE)
+static int yy_defer_accept = 1;
+
struct TopConf *conf_cur_block;
static char *conf_cur_block_name;
static char *yy_blacklist_host = NULL;
static char *yy_blacklist_reason = NULL;
+static int yy_blacklist_ipv4 = 1;
+static int yy_blacklist_ipv6 = 0;
+static rb_dlink_list yy_blacklist_filters;
+
static char *yy_privset_extends = NULL;
static const char *
conf_strtype(int type)
{
- switch (type & CF_MTYPE)
+ switch (CF_TYPE(type))
{
case CF_INT:
return "integer value";
#endif
}
+static void
+conf_set_serverinfo_nicklen(void *data)
+{
+ ConfigFileEntry.nicklen = (*(unsigned int *) data) + 1;
+
+ if (ConfigFileEntry.nicklen > NICKLEN)
+ {
+ conf_report_error("Warning -- ignoring serverinfo::nicklen -- provided nicklen (%u) is greater than allowed nicklen (%u)",
+ ConfigFileEntry.nicklen - 1, NICKLEN - 1);
+ ConfigFileEntry.nicklen = NICKLEN;
+ }
+ else if (ConfigFileEntry.nicklen < 9 + 1)
+ {
+ conf_report_error("Warning -- serverinfo::nicklen is too low (%u) -- forcing 9",
+ ConfigFileEntry.nicklen);
+ ConfigFileEntry.nicklen = 9 + 1;
+ }
+}
+
static void
conf_set_modules_module(void *data)
{
m_bn = rb_basename((char *) data);
- if(findmodule_byname(m_bn) != -1)
- return;
-
- load_one_module((char *) data, 0);
+ if(findmodule_byname(m_bn) == -1)
+ load_one_module((char *) data, 0);
rb_free(m_bn);
#else
int dir = 1;
int mode;
- if((args->type & CF_MTYPE) != CF_STRING)
+ if(CF_TYPE(args->type) != CF_STRING)
{
conf_report_error("Warning -- %s is not a string; ignoring.", whatis);
continue;
}
if(!EmptyString(yy_oper->certfp))
- yy_tmpoper->certfp = yy_oper->certfp;
+ yy_tmpoper->certfp = rb_strdup(yy_oper->certfp);
#endif
/* all is ok, put it on oper_conf_list */
static void
conf_set_oper_fingerprint(void *data)
{
+ if (yy_oper->certfp)
+ rb_free(yy_oper->certfp);
yy_oper->certfp = rb_strdup((char *) data);
}
return 0;
}
-
+static void
+conf_set_listen_defer_accept(void *data)
+{
+ yy_defer_accept = *(unsigned int *) data;
+}
static void
conf_set_listen_port_both(void *data, int ssl)
conf_parm_t *args = data;
for (; args; args = args->next)
{
- if((args->type & CF_MTYPE) != CF_INT)
+ if(CF_TYPE(args->type) != CF_INT)
{
conf_report_error
("listener::port argument is not an integer " "-- ignoring.");
}
if(listener_address == NULL)
{
- add_listener(args->v.number, listener_address, AF_INET, ssl);
+ add_listener(args->v.number, listener_address, AF_INET, ssl, yy_defer_accept);
#ifdef RB_IPV6
- add_listener(args->v.number, listener_address, AF_INET6, ssl);
+ add_listener(args->v.number, listener_address, AF_INET6, ssl, yy_defer_accept);
#endif
}
else
#endif
family = AF_INET;
- add_listener(args->v.number, listener_address, family, ssl);
+ add_listener(args->v.number, listener_address, family, ssl, yy_defer_accept);
}
conf_add_class_to_conf(yy_tmp);
- if (find_exact_conf_by_address("*", CONF_CLIENT, "*"))
+ if ((found_conf = find_exact_conf_by_address("*", CONF_CLIENT, "*")) && found_conf->spasswd == NULL)
conf_report_error("Ignoring redundant auth block (after *@*)");
- else if (find_exact_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user))
+ else if ((found_conf = find_exact_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user)) &&
+ (!found_conf->spasswd || (yy_tmp->spasswd &&
+ 0 == irccmp(found_conf->spasswd, yy_tmp->spasswd))))
conf_report_error("Ignoring duplicate auth block for %s@%s",
yy_tmp->user, yy_tmp->host);
else
if(args->next != NULL)
{
- if((args->type & CF_MTYPE) != CF_QSTRING)
+ if(CF_TYPE(args->type) != CF_QSTRING)
{
conf_report_error("Ignoring shared::oper -- server is not a qstring");
return;
else
yy_shared->server = rb_strdup("*");
- if((args->type & CF_MTYPE) != CF_QSTRING)
+ if(CF_TYPE(args->type) != CF_QSTRING)
{
conf_report_error("Ignoring shared::oper -- oper is not a qstring");
return;
static void
conf_set_connect_fingerprint(void *data)
{
+ if (yy_server->certfp)
+ rb_free(yy_server->certfp);
yy_server->certfp = rb_strdup((char *) data);
/* force SSL to be enabled if fingerprint is enabled. */
/* don't allow +o */
case 'o':
case 'S':
+ case 'Z':
case ' ':
break;
ConfigServerHide.links_delay = val;
}
-static int
-conf_begin_service(struct TopConf *tc)
-{
- struct Client *target_p;
- rb_dlink_node *ptr;
-
- RB_DLINK_FOREACH(ptr, global_serv_list.head)
- {
- target_p = ptr->data;
-
- target_p->flags &= ~FLAGS_SERVICE;
- }
-
- return 0;
-}
-
static void
conf_set_service_name(void *data)
{
- struct Client *target_p;
const char *s;
char *tmp;
int dots = 0;
tmp = rb_strdup(data);
rb_dlinkAddAlloc(tmp, &service_list);
-
- if((target_p = find_server(NULL, tmp)))
- target_p->flags |= FLAGS_SERVICE;
}
static int
yy_alias->target = rb_strdup(data);
}
+/* XXX for below */
+static void conf_set_blacklist_reason(void *data);
+
static void
conf_set_blacklist_host(void *data)
{
+ if (yy_blacklist_host)
+ {
+ conf_report_error("blacklist::host %s overlaps existing host %s",
+ (char *)data, yy_blacklist_host);
+
+ /* Cleanup */
+ conf_set_blacklist_reason(NULL);
+ return;
+ }
+
+ yy_blacklist_ipv4 = 1;
+ yy_blacklist_ipv6 = 0;
yy_blacklist_host = rb_strdup(data);
}
+static void
+conf_set_blacklist_type(void *data)
+{
+ conf_parm_t *args = data;
+
+ /* Don't assume we have either if we got here */
+ yy_blacklist_ipv4 = 0;
+ yy_blacklist_ipv6 = 0;
+
+ for (; args; args = args->next)
+ {
+ if (!strcasecmp(args->v.string, "ipv4"))
+ yy_blacklist_ipv4 = 1;
+ else if (!strcasecmp(args->v.string, "ipv6"))
+ yy_blacklist_ipv6 = 1;
+ else
+ conf_report_error("blacklist::type has unknown address family %s",
+ args->v.string);
+ }
+
+ /* If we have neither, just default to IPv4 */
+ if (!yy_blacklist_ipv4 && !yy_blacklist_ipv6)
+ {
+ conf_report_error("blacklist::type has neither IPv4 nor IPv6 (defaulting to IPv4)");
+ yy_blacklist_ipv4 = 1;
+ }
+}
+
+static void
+conf_set_blacklist_matches(void *data)
+{
+ conf_parm_t *args = data;
+
+ for (; args; args = args->next)
+ {
+ struct BlacklistFilter *filter;
+ char *str = args->v.string;
+ char *p;
+ int type = BLACKLIST_FILTER_LAST;
+
+ if (CF_TYPE(args->type) != CF_QSTRING)
+ {
+ conf_report_error("blacklist::matches -- must be quoted string");
+ continue;
+ }
+
+ if (str == NULL)
+ {
+ conf_report_error("blacklist::matches -- invalid entry");
+ continue;
+ }
+
+ if (strlen(str) > HOSTIPLEN)
+ {
+ conf_report_error("blacklist::matches has an entry too long: %s",
+ str);
+ continue;
+ }
+
+ for (p = str; *p != '\0'; p++)
+ {
+ /* Check for validity */
+ if (*p == '.')
+ type = BLACKLIST_FILTER_ALL;
+ else if (!isalnum(*p))
+ {
+ conf_report_error("blacklist::matches has invalid IP match entry %s",
+ str);
+ type = 0;
+ break;
+ }
+ }
+
+ if (type == BLACKLIST_FILTER_ALL)
+ {
+ /* Basic IP sanity check */
+ struct rb_sockaddr_storage tmp;
+ if (rb_inet_pton(AF_INET, str, &tmp) <= 0)
+ {
+ conf_report_error("blacklist::matches has invalid IP match entry %s",
+ str);
+ continue;
+ }
+ }
+ else if (type == BLACKLIST_FILTER_LAST)
+ {
+ /* Verify it's the correct length */
+ if (strlen(str) > 3)
+ {
+ conf_report_error("blacklist::matches has invalid octet match entry %s",
+ str);
+ continue;
+ }
+ }
+ else
+ {
+ continue; /* Invalid entry */
+ }
+
+ filter = rb_malloc(sizeof(struct BlacklistFilter));
+ filter->type = type;
+ rb_strlcpy(filter->filterstr, str, sizeof(filter->filterstr));
+
+ rb_dlinkAdd(filter, &filter->node, &yy_blacklist_filters);
+ }
+}
+
static void
conf_set_blacklist_reason(void *data)
{
yy_blacklist_reason = rb_strdup(data);
+ rb_dlink_node *ptr, *nptr;
if (yy_blacklist_host && yy_blacklist_reason)
{
- new_blacklist(yy_blacklist_host, yy_blacklist_reason);
- rb_free(yy_blacklist_host);
- rb_free(yy_blacklist_reason);
- yy_blacklist_host = NULL;
- yy_blacklist_reason = NULL;
+ if (yy_blacklist_ipv6)
+ {
+ /* Make sure things fit (64 = alnum count + dots) */
+ if ((64 + strlen(yy_blacklist_host)) > IRCD_RES_HOSTLEN)
+ {
+ conf_report_error("blacklist::host %s results in IPv6 queries that are too long",
+ yy_blacklist_host);
+ goto cleanup_bl;
+ }
+ }
+ /* Avoid doing redundant check, IPv6 is bigger than IPv4 --Elizabeth */
+ if (yy_blacklist_ipv4 && !yy_blacklist_ipv6)
+ {
+ /* Make sure things fit (16 = number of nums + dots) */
+ if ((16 + strlen(yy_blacklist_host)) > IRCD_RES_HOSTLEN)
+ {
+ conf_report_error("blacklist::host %s results in IPv4 queries that are too long",
+ yy_blacklist_host);
+ goto cleanup_bl;
+ }
+ }
+
+ new_blacklist(yy_blacklist_host, yy_blacklist_reason, yy_blacklist_ipv4, yy_blacklist_ipv6,
+ &yy_blacklist_filters);
}
+
+cleanup_bl:
+ if (data == NULL)
+ {
+ RB_DLINK_FOREACH_SAFE(ptr, nptr, yy_blacklist_filters.head)
+ {
+ rb_dlinkDelete(ptr, &yy_blacklist_filters);
+ rb_free(ptr);
+ }
+ }
+ else
+ {
+ yy_blacklist_filters = (rb_dlink_list){ NULL, NULL, 0 };
+ }
+
+ rb_free(yy_blacklist_host);
+ rb_free(yy_blacklist_reason);
+ yy_blacklist_host = NULL;
+ yy_blacklist_reason = NULL;
+ yy_blacklist_ipv4 = 1;
+ yy_blacklist_ipv6 = 0;
}
/* public functions */
}
int
-conf_call_set(struct TopConf *tc, char *item, conf_parm_t * value, int type)
+conf_call_set(struct TopConf *tc, char *item, conf_parm_t * value)
{
struct ConfEntry *cf;
conf_parm_t *cp;
if((tc = find_top_conf(topconf)) == NULL)
return -1;
- if((cf = find_conf_item(tc, name)) != NULL)
+ if(find_conf_item(tc, name) != NULL)
return -1;
cf = rb_malloc(sizeof(struct ConfEntry));
{ "default_max_clients",CF_INT, NULL, 0, &ServerInfo.default_max_clients },
+ { "nicklen", CF_INT, conf_set_serverinfo_nicklen, 0, NULL },
+
{ "\0", 0, NULL, 0, NULL }
};
static struct ConfEntry conf_log_table[] =
{
- { "fname_userlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_userlog },
- { "fname_fuserlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_fuserlog },
- { "fname_operlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_operlog },
- { "fname_foperlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_foperlog },
- { "fname_serverlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_serverlog },
- { "fname_killlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_killlog },
- { "fname_klinelog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_klinelog },
- { "fname_operspylog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_operspylog },
- { "fname_ioerrorlog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_ioerrorlog },
+ { "fname_userlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_userlog },
+ { "fname_fuserlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_fuserlog },
+ { "fname_operlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_operlog },
+ { "fname_foperlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_foperlog },
+ { "fname_serverlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_serverlog },
+ { "fname_killlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_killlog },
+ { "fname_klinelog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_klinelog },
+ { "fname_operspylog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_operspylog },
+ { "fname_ioerrorlog", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.fname_ioerrorlog },
{ "\0", 0, NULL, 0, NULL }
};
{ "default_operstring", CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.default_operstring },
{ "default_adminstring",CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.default_adminstring },
{ "servicestring", CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.servicestring },
- { "egdpool_path", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.egdpool_path },
+ { "egdpool_path", CF_QSTRING, NULL, PATH_MAX, &ConfigFileEntry.egdpool_path },
{ "kline_reason", CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.kline_reason },
{ "identify_service", CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifyservice },
{ "identify_command", CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifycommand },
{ "burst_away", CF_YESNO, NULL, 0, &ConfigFileEntry.burst_away },
{ "caller_id_wait", CF_TIME, NULL, 0, &ConfigFileEntry.caller_id_wait },
{ "client_exit", CF_YESNO, NULL, 0, &ConfigFileEntry.client_exit },
- { "client_flood", CF_INT, NULL, 0, &ConfigFileEntry.client_flood },
{ "collision_fnc", CF_YESNO, NULL, 0, &ConfigFileEntry.collision_fnc },
+ { "resv_fnc", CF_YESNO, NULL, 0, &ConfigFileEntry.resv_fnc },
{ "connect_timeout", CF_TIME, NULL, 0, &ConfigFileEntry.connect_timeout },
{ "default_floodcount", CF_INT, NULL, 0, &ConfigFileEntry.default_floodcount },
{ "default_ident_timeout", CF_INT, NULL, 0, &ConfigFileEntry.default_ident_timeout },
{ "use_whois_actually", CF_YESNO, NULL, 0, &ConfigFileEntry.use_whois_actually },
{ "warn_no_nline", CF_YESNO, NULL, 0, &ConfigFileEntry.warn_no_nline },
{ "use_propagated_bans",CF_YESNO, NULL, 0, &ConfigFileEntry.use_propagated_bans },
+ { "client_flood_max_lines", CF_INT, NULL, 0, &ConfigFileEntry.client_flood_max_lines },
+ { "client_flood_burst_rate", CF_INT, NULL, 0, &ConfigFileEntry.client_flood_burst_rate },
+ { "client_flood_burst_max", CF_INT, NULL, 0, &ConfigFileEntry.client_flood_burst_max },
+ { "client_flood_message_num", CF_INT, NULL, 0, &ConfigFileEntry.client_flood_message_num },
+ { "client_flood_message_time", CF_INT, NULL, 0, &ConfigFileEntry.client_flood_message_time },
+ { "max_ratelimit_tokens", CF_INT, NULL, 0, &ConfigFileEntry.max_ratelimit_tokens },
+ { "away_interval", CF_INT, NULL, 0, &ConfigFileEntry.away_interval },
{ "\0", 0, NULL, 0, NULL }
};
{ "only_ascii_channels", CF_YESNO, NULL, 0, &ConfigChannel.only_ascii_channels },
{ "use_except", CF_YESNO, NULL, 0, &ConfigChannel.use_except },
{ "use_invex", CF_YESNO, NULL, 0, &ConfigChannel.use_invex },
- { "use_knock", CF_YESNO, NULL, 0, &ConfigChannel.use_knock },
{ "use_forward", CF_YESNO, NULL, 0, &ConfigChannel.use_forward },
+ { "use_knock", CF_YESNO, NULL, 0, &ConfigChannel.use_knock },
{ "resv_forcepart", CF_YESNO, NULL, 0, &ConfigChannel.resv_forcepart },
{ "channel_target_change", CF_YESNO, NULL, 0, &ConfigChannel.channel_target_change },
{ "disable_local_channels", CF_YESNO, NULL, 0, &ConfigChannel.disable_local_channels },
add_top_conf("privset", NULL, NULL, conf_privset_table);
add_top_conf("listen", conf_begin_listen, conf_end_listen, NULL);
+ add_conf_item("listen", "defer_accept", CF_YESNO, conf_set_listen_defer_accept);
add_conf_item("listen", "port", CF_INT | CF_FLIST, conf_set_listen_port);
add_conf_item("listen", "sslport", CF_INT | CF_FLIST, conf_set_listen_sslport);
add_conf_item("listen", "ip", CF_QSTRING, conf_set_listen_address);
add_top_conf("auth", conf_begin_auth, conf_end_auth, conf_auth_table);
add_top_conf("shared", conf_cleanup_shared, conf_cleanup_shared, NULL);
- add_conf_item("shared", "oper", CF_QSTRING|CF_FLIST, conf_set_shared_oper);
+ add_conf_item("shared", "oper", CF_QSTRING | CF_FLIST, conf_set_shared_oper);
add_conf_item("shared", "flags", CF_STRING | CF_FLIST, conf_set_shared_flags);
add_top_conf("connect", conf_begin_connect, conf_end_connect, conf_connect_table);
add_top_conf("channel", NULL, NULL, conf_channel_table);
add_top_conf("serverhide", NULL, NULL, conf_serverhide_table);
- add_top_conf("service", conf_begin_service, NULL, NULL);
+ add_top_conf("service", NULL, NULL, NULL);
add_conf_item("service", "name", CF_QSTRING, conf_set_service_name);
add_top_conf("alias", conf_begin_alias, conf_end_alias, NULL);
add_top_conf("blacklist", NULL, NULL, NULL);
add_conf_item("blacklist", "host", CF_QSTRING, conf_set_blacklist_host);
+ add_conf_item("blacklist", "type", CF_STRING | CF_FLIST, conf_set_blacklist_type);
+ add_conf_item("blacklist", "matches", CF_QSTRING | CF_FLIST, conf_set_blacklist_matches);
add_conf_item("blacklist", "reject_reason", CF_QSTRING, conf_set_blacklist_reason);
}