#include "newconf.h"
#include "ircd_defs.h"
-#include "sprintf_irc.h"
#include "common.h"
-#include "s_log.h"
+#include "logger.h"
#include "s_conf.h"
#include "s_user.h"
#include "s_newconf.h"
#include "ircd.h"
#include "snomask.h"
#include "blacklist.h"
+#include "sslproc.h"
+#include "privilege.h"
#define CF_TYPE(x) ((x) & CF_MTYPE)
static char *yy_blacklist_host = NULL;
static char *yy_blacklist_reason = NULL;
+static char *yy_privset_extends = NULL;
static const char *
conf_strtype(int type)
/* the ircd will exit() in main() if we dont set one */
if(strlen(s) <= HOSTLEN)
- DupString(ServerInfo.name, (char *) data);
+ ServerInfo.name = rb_strdup((char *) data);
}
}
*p = '\0';
rb_free(ServerInfo.network_name);
- DupString(ServerInfo.network_name, (char *) data);
+ ServerInfo.network_name = rb_strdup((char *) data);
}
static void
conf_set_serverinfo_vhost(void *data)
{
- if(inetpton(AF_INET, (char *) data, &ServerInfo.ip.sin_addr) <= 0)
+ if(rb_inet_pton(AF_INET, (char *) data, &ServerInfo.ip.sin_addr) <= 0)
{
conf_report_error("Invalid netmask for server IPv4 vhost (%s)", (char *) data);
return;
static void
conf_set_serverinfo_vhost6(void *data)
{
-#ifdef IPV6
- if(inetpton(AF_INET6, (char *) data, &ServerInfo.ip6.sin6_addr) <= 0)
+#ifdef RB_IPV6
+ if(rb_inet_pton(AF_INET6, (char *) data, &ServerInfo.ip6.sin6_addr) <= 0)
{
conf_report_error("Invalid netmask for server IPv6 vhost (%s)", (char *) data);
return;
#ifndef STATIC_MODULES
char *m_bn;
- m_bn = irc_basename((char *) data);
+ m_bn = rb_basename((char *) data);
if(findmodule_byname(m_bn) != -1)
return;
static struct mode_table oper_table[] = {
{"encrypted", OPER_ENCRYPTED },
- {"local_kill", OPER_LOCKILL },
- {"global_kill", OPER_GLOBKILL|OPER_LOCKILL },
- {"remote", OPER_REMOTE },
- {"kline", OPER_KLINE },
- {"unkline", OPER_UNKLINE },
- {"gline", OPER_GLINE },
- {"nick_changes", OPER_NICKS },
- {"rehash", OPER_REHASH },
- {"die", OPER_DIE },
- {"admin", OPER_ADMIN },
- {"hidden_admin", OPER_HADMIN },
- {"xline", OPER_XLINE },
- {"resv", OPER_RESV },
- {"operwall", OPER_OPERWALL },
- {"oper_spy", OPER_SPY },
- {"hidden_oper", OPER_INVIS },
- {"remoteban", OPER_REMOTEBAN },
- {"mass_notice", OPER_MASSNOTICE },
+ {"need_ssl", OPER_NEEDSSL },
{NULL, 0}
};
{"exceed_limit", CONF_FLAGS_NOLIMIT },
{"dnsbl_exempt", CONF_FLAGS_EXEMPTDNSBL },
{"kline_exempt", CONF_FLAGS_EXEMPTKLINE },
- {"gline_exempt", CONF_FLAGS_EXEMPTGLINE },
{"flood_exempt", CONF_FLAGS_EXEMPTFLOOD },
{"spambot_exempt", CONF_FLAGS_EXEMPTSPAMBOT },
{"shide_exempt", CONF_FLAGS_EXEMPTSHIDE },
{"no_tilde", CONF_FLAGS_NO_TILDE },
{"need_ident", CONF_FLAGS_NEED_IDENTD },
{"have_ident", CONF_FLAGS_NEED_IDENTD },
+ {"need_ssl", CONF_FLAGS_NEED_SSL },
{"need_sasl", CONF_FLAGS_NEED_SASL },
{NULL, 0}
};
{ "compressed", SERVER_COMPRESSED },
{ "encrypted", SERVER_ENCRYPTED },
{ "topicburst", SERVER_TB },
+ { "ssl", SERVER_SSL },
{ NULL, 0 },
};
{ "kline", SHARED_PKLINE|SHARED_TKLINE },
{ "xline", SHARED_PXLINE|SHARED_TXLINE },
{ "resv", SHARED_PRESV|SHARED_TRESV },
+ { "dline", SHARED_PDLINE|SHARED_TDLINE },
+ { "tdline", SHARED_TDLINE },
+ { "pdline", SHARED_PDLINE },
+ { "undline", SHARED_UNDLINE },
{ "tkline", SHARED_TKLINE },
{ "unkline", SHARED_UNKLINE },
{ "txline", SHARED_TXLINE },
}
}
+static void
+conf_set_privset_extends(void *data)
+{
+ yy_privset_extends = rb_strdup((char *) data);
+}
+
+static void
+conf_set_privset_privs(void *data)
+{
+ char *privs = NULL;
+ conf_parm_t *args = data;
+
+ for (; args; args = args->next)
+ {
+ if (privs == NULL)
+ privs = rb_strdup(args->v.string);
+ else
+ {
+ char *privs_old = privs;
+
+ privs = rb_malloc(strlen(privs_old) + 1 + strlen(args->v.string) + 1);
+ strcpy(privs, privs_old);
+ strcat(privs, " ");
+ strcat(privs, args->v.string);
+
+ rb_free(privs_old);
+ }
+ }
+
+ if (privs)
+ {
+ if (yy_privset_extends)
+ {
+ struct PrivilegeSet *set = privilegeset_get(yy_privset_extends);
+
+ if (!set)
+ {
+ conf_report_error("Warning -- unknown parent privilege set %s for %s; assuming defaults", yy_privset_extends, conf_cur_block_name);
+
+ set = privilegeset_get("default");
+ }
+
+ privilegeset_extend(set, conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
+
+ rb_free(yy_privset_extends);
+ yy_privset_extends = NULL;
+ }
+ else
+ privilegeset_set_new(conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
+
+ rb_free(privs);
+ }
+}
+
static int
conf_begin_oper(struct TopConf *tc)
{
}
yy_oper = make_oper_conf();
- yy_oper->flags |= OPER_ENCRYPTED|OPER_RESV|OPER_OPERWALL|OPER_REMOTEBAN|OPER_MASSNOTICE;
+ yy_oper->flags |= OPER_ENCRYPTED;
return 0;
}
if(strlen(conf_cur_block_name) > OPERNICKLEN)
conf_cur_block_name[OPERNICKLEN] = '\0';
- DupString(yy_oper->name, conf_cur_block_name);
+ yy_oper->name = rb_strdup(conf_cur_block_name);
}
if(EmptyString(yy_oper->name))
return 0;
}
+
+ if (!yy_oper->privset)
+ yy_oper->privset = privilegeset_get("default");
+
/* now, yy_oper_list contains a stack of oper_conf's with just user
* and host in, yy_oper contains the rest of the information which
* we need to copy into each element in yy_oper_list
{
yy_tmpoper = ptr->data;
- DupString(yy_tmpoper->name, yy_oper->name);
+ yy_tmpoper->name = rb_strdup(yy_oper->name);
/* could be an rsa key instead.. */
if(!EmptyString(yy_oper->passwd))
- DupString(yy_tmpoper->passwd, yy_oper->passwd);
+ yy_tmpoper->passwd = rb_strdup(yy_oper->passwd);
yy_tmpoper->flags = yy_oper->flags;
yy_tmpoper->umodes = yy_oper->umodes;
yy_tmpoper->snomask = yy_oper->snomask;
+ yy_tmpoper->privset = yy_oper->privset;
#ifdef HAVE_LIBCRYPTO
if(yy_oper->rsa_pubkey_file)
set_modes_from_table(&yy_oper->flags, "flag", oper_table, args);
}
+static void
+conf_set_oper_privset(void *data)
+{
+ yy_oper->privset = privilegeset_get((char *) data);
+}
+
static void
conf_set_oper_user(void *data)
{
{
*p++ = '\0';
- DupString(yy_tmpoper->username, host);
- DupString(yy_tmpoper->host, p);
+ yy_tmpoper->username = rb_strdup(host);
+ yy_tmpoper->host = rb_strdup(p);
}
else
{
- DupString(yy_tmpoper->username, "*");
- DupString(yy_tmpoper->host, host);
+ yy_tmpoper->username = rb_strdup("*");
+ yy_tmpoper->host = rb_strdup(host);
}
if(EmptyString(yy_tmpoper->username) || EmptyString(yy_tmpoper->host))
rb_free(yy_oper->passwd);
}
- DupString(yy_oper->passwd, (char *) data);
+ yy_oper->passwd = rb_strdup((char *) data);
}
static void
{
#ifdef HAVE_LIBCRYPTO
rb_free(yy_oper->rsa_pubkey_file);
- DupString(yy_oper->rsa_pubkey_file, (char *) data);
+ yy_oper->rsa_pubkey_file = rb_strdup((char *) data);
#else
conf_report_error("Warning -- ignoring rsa_public_key_file (OpenSSL support not available");
#endif
conf_end_class(struct TopConf *tc)
{
if(conf_cur_block_name != NULL)
- DupString(yy_class->class_name, conf_cur_block_name);
+ yy_class->class_name = rb_strdup(conf_cur_block_name);
if(EmptyString(yy_class->class_name))
{
}
static void
-conf_set_class_cidr_bitlen(void *data)
+conf_set_class_cidr_ipv4_bitlen(void *data)
{
-#ifdef IPV6
- unsigned int maxsize = 128;
-#else
unsigned int maxsize = 32;
-#endif
if(*(unsigned int *) data > maxsize)
conf_report_error
- ("class::cidr_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
+ ("class::cidr_ipv4_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
*(unsigned int *) data, maxsize);
else
- yy_class->cidr_bitlen = *(unsigned int *) data;
+ yy_class->cidr_ipv4_bitlen = *(unsigned int *) data;
}
+
+#ifdef RB_IPV6
+static void
+conf_set_class_cidr_ipv6_bitlen(void *data)
+{
+ unsigned int maxsize = 128;
+ if(*(unsigned int *) data > maxsize)
+ conf_report_error
+ ("class::cidr_ipv6_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
+ *(unsigned int *) data, maxsize);
+ else
+ yy_class->cidr_ipv6_bitlen = *(unsigned int *) data;
+
+}
+#endif
+
static void
conf_set_class_number_per_cidr(void *data)
{
return 0;
}
+
+
static void
-conf_set_listen_port(void *data)
+conf_set_listen_port_both(void *data, int ssl)
{
conf_parm_t *args = data;
for (; args; args = args->next)
}
if(listener_address == NULL)
{
- add_listener(args->v.number, listener_address, AF_INET);
-#ifdef IPV6
- add_listener(args->v.number, listener_address, AF_INET6);
+ add_listener(args->v.number, listener_address, AF_INET, ssl);
+#ifdef RB_IPV6
+ add_listener(args->v.number, listener_address, AF_INET6, ssl);
#endif
}
else
{
int family;
-#ifdef IPV6
+#ifdef RB_IPV6
if(strchr(listener_address, ':') != NULL)
family = AF_INET6;
else
#endif
family = AF_INET;
- add_listener(args->v.number, listener_address, family);
+ add_listener(args->v.number, listener_address, family, ssl);
}
}
}
+static void
+conf_set_listen_port(void *data)
+{
+ conf_set_listen_port_both(data, 0);
+}
+
+static void
+conf_set_listen_sslport(void *data)
+{
+ conf_set_listen_port_both(data, 1);
+}
+
static void
conf_set_listen_address(void *data)
{
rb_free(listener_address);
- DupString(listener_address, data);
+ listener_address = rb_strdup(data);
}
static int
rb_dlink_node *next_ptr;
if(EmptyString(yy_aconf->name))
- DupString(yy_aconf->name, "NOMATCH");
+ yy_aconf->name = rb_strdup("NOMATCH");
/* didnt even get one ->host? */
if(EmptyString(yy_aconf->host))
collapse(yy_aconf->user);
collapse(yy_aconf->host);
conf_add_class_to_conf(yy_aconf);
- add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf);
+ add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf->spasswd, yy_aconf);
RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
{
yy_tmp = ptr->data;
if(yy_aconf->passwd)
- DupString(yy_tmp->passwd, yy_aconf->passwd);
+ yy_tmp->passwd = rb_strdup(yy_aconf->passwd);
+ if(yy_aconf->spasswd)
+ yy_tmp->spasswd = rb_strdup(yy_aconf->spasswd);
+
/* this will always exist.. */
- DupString(yy_tmp->name, yy_aconf->name);
+ yy_tmp->name = rb_strdup(yy_aconf->name);
if(yy_aconf->className)
- DupString(yy_tmp->className, yy_aconf->className);
+ yy_tmp->className = rb_strdup(yy_aconf->className);
yy_tmp->flags = yy_aconf->flags;
yy_tmp->port = yy_aconf->port;
conf_add_class_to_conf(yy_tmp);
- add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp);
+ add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp->spasswd, yy_tmp);
rb_dlinkDestroy(ptr, &yy_aconf_list);
}
{
*p++ = '\0';
- DupString(yy_tmp->user, data);
- DupString(yy_tmp->host, p);
+ yy_tmp->user = rb_strdup(data);
+ yy_tmp->host = rb_strdup(p);
}
else
{
- DupString(yy_tmp->user, "*");
- DupString(yy_tmp->host, data);
+ yy_tmp->user = rb_strdup("*");
+ yy_tmp->host = rb_strdup(data);
}
if(yy_aconf != yy_tmp)
rb_dlinkAddAlloc(yy_tmp, &yy_aconf_list);
}
+static void
+conf_set_auth_auth_user(void *data)
+{
+ if(yy_aconf->spasswd)
+ memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
+ rb_free(yy_aconf->spasswd);
+ yy_aconf->spasswd = rb_strdup(data);
+}
+
static void
conf_set_auth_passwd(void *data)
{
if(yy_aconf->passwd)
memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
rb_free(yy_aconf->passwd);
- DupString(yy_aconf->passwd, data);
+ yy_aconf->passwd = rb_strdup(data);
}
static void
}
rb_free(yy_aconf->name);
- DupString(yy_aconf->name, data);
+ yy_aconf->name = rb_strdup(data);
yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
}
{
yy_aconf->flags |= CONF_FLAGS_REDIR;
rb_free(yy_aconf->name);
- DupString(yy_aconf->name, data);
+ yy_aconf->name = rb_strdup(data);
}
static void
conf_set_auth_class(void *data)
{
rb_free(yy_aconf->className);
- DupString(yy_aconf->className, data);
+ yy_aconf->className = rb_strdup(data);
}
/* ok, shared_oper handles the stacking, shared_flags handles adding
return;
}
- DupString(yy_shared->server, args->v.string);
+ yy_shared->server = rb_strdup(args->v.string);
args = args->next;
}
else
- DupString(yy_shared->server, "*");
+ yy_shared->server = rb_strdup("*");
if((args->type & CF_MTYPE) != CF_QSTRING)
{
*p++ = '\0';
if(EmptyString(p))
- DupString(yy_shared->host, "*");
+ yy_shared->host = rb_strdup("*");
else
- DupString(yy_shared->host, p);
+ yy_shared->host = rb_strdup(p);
if(EmptyString(username))
- DupString(yy_shared->username, "*");
+ yy_shared->username = rb_strdup("*");
else
- DupString(yy_shared->username, username);
+ yy_shared->username = rb_strdup(username);
rb_dlinkAddAlloc(yy_shared, &yy_shared_list);
yy_shared = NULL;
yy_server->flags |= SERVER_TB;
if(conf_cur_block_name != NULL)
- DupString(yy_server->name, conf_cur_block_name);
+ yy_server->name = rb_strdup(conf_cur_block_name);
return 0;
}
conf_set_connect_host(void *data)
{
rb_free(yy_server->host);
- DupString(yy_server->host, data);
+ yy_server->host = rb_strdup(data);
if (strchr(yy_server->host, ':'))
yy_server->aftype = AF_INET6;
}
static void
conf_set_connect_vhost(void *data)
{
- if(inetpton_sock(data, (struct sockaddr *)&yy_server->my_ipnum) <= 0)
+ if(rb_inet_pton_sock(data, (struct sockaddr *)&yy_server->my_ipnum) <= 0)
{
conf_report_error("Invalid netmask for server vhost (%s)",
(char *) data);
rb_free(yy_server->spasswd);
}
- DupString(yy_server->spasswd, data);
+ yy_server->spasswd = rb_strdup(data);
}
static void
memset(yy_server->passwd, 0, strlen(yy_server->passwd));
rb_free(yy_server->passwd);
}
- DupString(yy_server->passwd, data);
+ yy_server->passwd = rb_strdup(data);
}
static void
if(strcasecmp(aft, "ipv4") == 0)
yy_server->aftype = AF_INET;
-#ifdef IPV6
+#ifdef RB_IPV6
else if(strcasecmp(aft, "ipv6") == 0)
yy_server->aftype = AF_INET6;
#endif
yy_hub = make_remote_conf();
yy_hub->flags = CONF_HUB;
- DupString(yy_hub->host, data);
- DupString(yy_hub->server, yy_server->name);
+ yy_hub->host = rb_strdup(data);
+ yy_hub->server = rb_strdup(yy_server->name);
rb_dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
}
yy_leaf = make_remote_conf();
yy_leaf->flags = CONF_LEAF;
- DupString(yy_leaf->host, data);
- DupString(yy_leaf->server, yy_server->name);
+ yy_leaf->host = rb_strdup(data);
+ yy_leaf->server = rb_strdup(yy_server->name);
rb_dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
}
conf_set_connect_class(void *data)
{
rb_free(yy_server->class_name);
- DupString(yy_server->class_name, data);
+ yy_server->class_name = rb_strdup(data);
}
static void
}
yy_tmp = make_conf();
- DupString(yy_tmp->passwd, "*");
- DupString(yy_tmp->host, data);
+ yy_tmp->passwd = rb_strdup("*");
+ yy_tmp->host = rb_strdup(data);
yy_tmp->status = CONF_EXEMPTDLINE;
- add_conf_by_address(yy_tmp->host, CONF_EXEMPTDLINE, NULL, yy_tmp);
+ add_conf_by_address(yy_tmp->host, CONF_EXEMPTDLINE, NULL, NULL, yy_tmp);
}
static int
free_remote_conf(yy_shared);
yy_shared = make_remote_conf();
- DupString(yy_shared->server, data);
+ yy_shared->server = rb_strdup(data);
rb_dlinkAddAlloc(yy_shared, &yy_cluster_list);
yy_shared = NULL;
return;
}
- DupString(tmp, data);
+ tmp = rb_strdup(data);
rb_dlinkAddAlloc(tmp, &service_list);
if((target_p = find_server(NULL, tmp)))
yy_alias = rb_malloc(sizeof(struct alias_entry));
if (conf_cur_block_name != NULL)
- DupString(yy_alias->name, conf_cur_block_name);
+ yy_alias->name = rb_strdup(conf_cur_block_name);
yy_alias->flags = 0;
yy_alias->hits = 0;
if (data == NULL || yy_alias == NULL) /* this shouldn't ever happen */
return;
- DupString(yy_alias->name, data);
+ yy_alias->name = rb_strdup(data);
}
static void
if (data == NULL || yy_alias == NULL) /* this shouldn't ever happen */
return;
- DupString(yy_alias->target, data);
+ yy_alias->target = rb_strdup(data);
}
static void
conf_set_blacklist_host(void *data)
{
- DupString(yy_blacklist_host, data);
+ yy_blacklist_host = rb_strdup(data);
}
static void
conf_set_blacklist_reason(void *data)
{
- DupString(yy_blacklist_reason, data);
+ yy_blacklist_reason = rb_strdup(data);
if (yy_blacklist_host && yy_blacklist_reason)
{
char msg[IRCD_BUFSIZE + 1] = { 0 };
va_start(ap, fmt);
- ircvsnprintf(msg, IRCD_BUFSIZE, fmt, ap);
+ rb_vsnprintf(msg, IRCD_BUFSIZE, fmt, ap);
va_end(ap);
if (testing_conf)
}
if(name)
- DupString(conf_cur_block_name, name);
+ conf_cur_block_name = rb_strdup(name);
else
conf_cur_block_name = NULL;
char **loc = location;
char *input = data;
- if(len && strlen(input) > len)
+ if(len && strlen(input) > (unsigned int)len)
input[len] = '\0';
rb_free(*loc);
- DupString(*loc, input);
+ *loc = rb_strdup(input);
}
int
value->v.list->type = CF_STRING;
if(cp->v.number == 1)
- DupString(cp->v.string, "yes");
+ cp->v.string = rb_strdup("yes");
else
- DupString(cp->v.string, "no");
+ cp->v.string = rb_strdup("no");
}
/* maybe it's a CF_TIME and they passed CF_INT --
{ "vhost", CF_QSTRING, conf_set_serverinfo_vhost, 0, NULL },
{ "vhost6", CF_QSTRING, conf_set_serverinfo_vhost6, 0, NULL },
- { "max_clients", CF_INT, NULL, 0, &ServerInfo.max_clients },
+ { "ssl_private_key", CF_QSTRING, NULL, 0, &ServerInfo.ssl_private_key },
+ { "ssl_ca_cert", CF_QSTRING, NULL, 0, &ServerInfo.ssl_ca_cert },
+ { "ssl_cert", CF_QSTRING, NULL, 0, &ServerInfo.ssl_cert },
+ { "ssl_dh_params", CF_QSTRING, NULL, 0, &ServerInfo.ssl_dh_params },
+ { "ssld_count", CF_INT, NULL, 0, &ServerInfo.ssld_count },
+
+ { "default_max_clients",CF_INT, NULL, 0, &ServerInfo.default_max_clients },
{ "\0", 0, NULL, 0, NULL }
};
{ "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_glinelog", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_glinelog },
{ "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 },
{ "rsa_public_key_file", CF_QSTRING, conf_set_oper_rsa_public_key_file, 0, NULL },
{ "flags", CF_STRING | CF_FLIST, conf_set_oper_flags, 0, NULL },
{ "umodes", CF_STRING | CF_FLIST, conf_set_oper_umodes, 0, NULL },
+ { "privset", CF_QSTRING, conf_set_oper_privset, 0, NULL },
{ "snomask", CF_QSTRING, conf_set_oper_snomask, 0, NULL },
{ "user", CF_QSTRING, conf_set_oper_user, 0, NULL },
{ "password", CF_QSTRING, conf_set_oper_password, 0, NULL },
{ "\0", 0, NULL, 0, NULL }
};
+static struct ConfEntry conf_privset_table[] =
+{
+ { "extends", CF_QSTRING, conf_set_privset_extends, 0, NULL },
+ { "privs", CF_STRING | CF_FLIST, conf_set_privset_privs, 0, NULL },
+ { "\0", 0, NULL, 0, NULL }
+};
+
static struct ConfEntry conf_class_table[] =
{
{ "ping_time", CF_TIME, conf_set_class_ping_time, 0, NULL },
- { "cidr_bitlen", CF_INT, conf_set_class_cidr_bitlen, 0, NULL },
+ { "cidr_ipv4_bitlen", CF_INT, conf_set_class_cidr_ipv4_bitlen, 0, NULL },
+#ifdef RB_IPV6
+ { "cidr_ipv6_bitlen", CF_INT, conf_set_class_cidr_ipv6_bitlen, 0, NULL },
+#endif
{ "number_per_cidr", CF_INT, conf_set_class_number_per_cidr, 0, NULL },
{ "number_per_ip", CF_INT, conf_set_class_number_per_ip, 0, NULL },
{ "number_per_ip_global", CF_INT,conf_set_class_number_per_ip_global, 0, NULL },
static struct ConfEntry conf_auth_table[] =
{
{ "user", CF_QSTRING, conf_set_auth_user, 0, NULL },
+ { "auth_user", CF_QSTRING, conf_set_auth_auth_user, 0, NULL },
{ "password", CF_QSTRING, conf_set_auth_passwd, 0, NULL },
{ "class", CF_QSTRING, conf_set_auth_class, 0, NULL },
{ "spoof", CF_QSTRING, conf_set_auth_spoof, 0, NULL },
{ "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 },
- { "servlink_path", CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.servlink_path },
{ "anti_spam_exit_message_time", CF_TIME, NULL, 0, &ConfigFileEntry.anti_spam_exit_message_time },
{ "disable_fake_channels", CF_YESNO, NULL, 0, &ConfigFileEntry.disable_fake_channels },
{ "disable_auth", CF_YESNO, NULL, 0, &ConfigFileEntry.disable_auth },
{ "dots_in_ident", CF_INT, NULL, 0, &ConfigFileEntry.dots_in_ident },
{ "failed_oper_notice", CF_YESNO, NULL, 0, &ConfigFileEntry.failed_oper_notice },
- { "glines", CF_YESNO, NULL, 0, &ConfigFileEntry.glines },
- { "gline_min_cidr", CF_INT, NULL, 0, &ConfigFileEntry.gline_min_cidr },
- { "gline_min_cidr6", CF_INT, NULL, 0, &ConfigFileEntry.gline_min_cidr6 },
- { "gline_time", CF_TIME, NULL, 0, &ConfigFileEntry.gline_time },
{ "global_snotices", CF_YESNO, NULL, 0, &ConfigFileEntry.global_snotices },
{ "hide_spoof_ips", CF_YESNO, NULL, 0, &ConfigFileEntry.hide_spoof_ips },
{ "dline_with_reason", CF_YESNO, NULL, 0, &ConfigFileEntry.dline_with_reason },
{ "max_nick_time", CF_TIME, NULL, 0, &ConfigFileEntry.max_nick_time },
{ "max_nick_changes", CF_INT, NULL, 0, &ConfigFileEntry.max_nick_changes },
{ "max_targets", CF_INT, NULL, 0, &ConfigFileEntry.max_targets },
- { "max_unknown_ip", CF_INT, NULL, 0, &ConfigFileEntry.max_unknown_ip },
{ "min_nonwildcard", CF_INT, NULL, 0, &ConfigFileEntry.min_nonwildcard },
{ "nick_delay", CF_TIME, NULL, 0, &ConfigFileEntry.nick_delay },
{ "no_oper_flood", CF_YESNO, NULL, 0, &ConfigFileEntry.no_oper_flood },
{ "reject_after_count", CF_INT, NULL, 0, &ConfigFileEntry.reject_after_count },
{ "reject_ban_time", CF_TIME, NULL, 0, &ConfigFileEntry.reject_ban_time },
{ "reject_duration", CF_TIME, NULL, 0, &ConfigFileEntry.reject_duration },
+ { "throttle_count", CF_INT, NULL, 0, &ConfigFileEntry.throttle_count },
+ { "throttle_duration", CF_TIME, NULL, 0, &ConfigFileEntry.throttle_duration },
{ "short_motd", CF_YESNO, NULL, 0, &ConfigFileEntry.short_motd },
{ "stats_c_oper_only", CF_YESNO, NULL, 0, &ConfigFileEntry.stats_c_oper_only },
{ "stats_e_disabled", CF_YESNO, NULL, 0, &ConfigFileEntry.stats_e_disabled },
add_top_conf("log", NULL, NULL, conf_log_table);
add_top_conf("operator", conf_begin_oper, conf_end_oper, conf_operator_table);
add_top_conf("class", conf_begin_class, conf_end_class, conf_class_table);
+ add_top_conf("privset", NULL, NULL, conf_privset_table);
add_top_conf("listen", conf_begin_listen, conf_end_listen, NULL);
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_conf_item("listen", "host", CF_QSTRING, conf_set_listen_address);
projects / irc / rqf / shadowircd.git / blobdiff