END_TEST
START_TEST (event_dump_test) {
int res;
const char *event = "foo";
pr_event_dump(NULL);
fail_unless(event_dumped == 0, "Expected dumped count of %u, got %u",
0, event_dumped);
pr_event_dump(event_dump);
fail_unless(event_dumped == 0, "Expected dumped count of %u, got %u",
0, event_dumped);
res = pr_event_register(NULL, event, event_cb, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
pr_event_dump(event_dump);
fail_unless(event_dumped == 1, "Expected dumped count of %u, got %u",
1, event_dumped);
event_dumped = 0;
res = pr_event_register(NULL, event, event_cb2, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
res = pr_event_register(NULL, "bar", event_cb2, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
pr_event_dump(event_dump);
fail_unless(event_dumped == 3, "Expected dumped count of %u, got %u",
3, event_dumped);
}
END_TEST
START_TEST (event_unregister_test) {
int res;
const char *event = "foo";
res = pr_event_unregister(NULL, NULL, NULL);
fail_unless(res == 0, "Failed to handle empty event lists");
res = pr_event_register(NULL, event, event_cb, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
res = pr_event_unregister(NULL, "bar", NULL);
fail_unless(res == -1, "Failed to handle unregistered event");
fail_unless(errno == ENOENT, "Failed to set errno to ENOENT");
res = pr_event_unregister(NULL, event, event_cb2);
fail_unless(res == -1, "Failed to handle unregistered event");
fail_unless(errno == ENOENT, "Failed to set errno to ENOENT");
res = pr_event_unregister(NULL, event, event_cb);
fail_unless(res == 0, "Failed to unregister event: %s", strerror(errno));
res = pr_event_register(NULL, event, event_cb, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
res = pr_event_unregister(NULL, event, NULL);
fail_unless(res == 0, "Failed to unregister event: %s", strerror(errno));
res = pr_event_register(NULL, event, event_cb, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
res = pr_event_unregister(NULL, NULL, NULL);
fail_unless(res == 0, "Failed to unregister event: %s", strerror(errno));
}
static int dynmasq_init(void) {
#if defined(PR_SHARED_MODULE)
pr_event_register(&dynmasq_module, "core.module-unload",
dynmasq_mod_unload_ev, NULL);
#endif /* !PR_SHARED_MODULE */
pr_event_register(&dynmasq_module, "core.postparse", dynmasq_postparse_ev,
NULL);
pr_event_register(&dynmasq_module, "core.restart", dynmasq_restart_ev,
NULL);
#ifdef PR_USE_CTRLS
if (pr_ctrls_register(&dynmasq_module, "dynmasq", "mod_dynmasq controls",
dynmasq_handle_dynmasq) < 0) {
pr_log_pri(PR_LOG_NOTICE, MOD_DYNMASQ_VERSION
": error registering 'dynmasq' control: %s", strerror(errno));
} else {
register unsigned int i;
dynmasq_act_pool = make_sub_pool(permanent_pool);
pr_pool_tag(dynmasq_act_pool, "DynMasq Controls Pool");
for (i = 0; dynmasq_acttab[i].act_action; i++) {
dynmasq_acttab[i].act_acl = palloc(dynmasq_act_pool, sizeof(ctrls_acl_t));
pr_ctrls_init_acl(dynmasq_acttab[i].act_acl);
}
}
#endif /* PR_USE_CTRLS */
return 0;
}
static int qos_init(void) {
#ifdef IP_TOS
pr_event_register(&qos_module, "core.ctrl-listen", qos_ctrl_listen_ev, NULL);
#endif
#ifdef PR_SHARED_MODULE
pr_event_register(&qos_module, "core.module-unload", qos_mod_unload_ev, NULL);
#endif
return 0;
}
static int sql_postgres_init(void) {
/* Register listeners for the load and unload events. */
pr_event_register(&sql_postgres_module, "core.module-load",
sql_postgres_mod_load_ev, NULL);
pr_event_register(&sql_postgres_module, "core.module-unload",
sql_postgres_mod_unload_ev, NULL);
return 0;
}
static int counter_init(void) {
counter_pool = make_sub_pool(permanent_pool);
pr_pool_tag(counter_pool, MOD_COUNTER_VERSION);
#if defined(PR_SHARED_MODULE)
pr_event_register(&counter_module, "core.module-unload",
counter_mod_unload_ev, NULL);
#endif
pr_event_register(&counter_module, "core.restart", counter_restart_ev,
NULL);
return 0;
}
void init_regexp(void) {
/* Register a restart handler for the regexp pool, so that when restarting,
* regfree(3) is called on each of the regex_t pointers in a
* regex_t-tracking array, thus preventing memory leaks on a long-running
* daemon.
*
* This registration is done here so that it only happens once.
*/
pr_event_register(NULL, "core.restart", regexp_restart_ev, NULL);
pr_event_register(NULL, "core.exit", regexp_exit_ev, NULL);
#ifdef PR_USE_PCRE
pr_log_debug(DEBUG2, "using PCRE %s", pcre_version());
#endif /* PR_USE_PCRE */
}
static int sftppam_init(void) {
#if defined(PR_SHARED_MODULE)
pr_event_register(&sftp_pam_module, "core.module-unload",
sftppam_mod_unload_ev, NULL);
#endif /* !PR_SHARED_MODULE */
/* Prepare our driver. */
memset(&sftppam_driver, 0, sizeof(sftppam_driver));
sftppam_driver.open = sftppam_driver_open;
sftppam_driver.authenticate = sftppam_driver_authenticate;
sftppam_driver.close = sftppam_driver_close;
/* Register ourselves with mod_sftp. */
if (sftp_kbdint_register_driver("pam", &sftppam_driver) < 0) {
int xerrno = errno;
pr_log_pri(PR_LOG_NOTICE, MOD_SFTP_PAM_VERSION
": notice: error registering 'keyboard-interactive' driver: %s",
strerror(xerrno));
errno = xerrno;
return -1;
}
return 0;
}
static int mcache_init(void) {
const char *version;
memcache_pool = make_sub_pool(permanent_pool);
pr_pool_tag(memcache_pool, MOD_MEMCACHE_VERSION);
memcache_server_lists = make_array(memcache_pool, 2,
sizeof(memcached_server_st **));
memcache_init();
pr_event_register(&memcache_module, "core.restart", mcache_restart_ev, NULL);
version = memcached_lib_version();
if (strcmp(version, LIBMEMCACHED_VERSION_STRING) != 0) {
pr_log_pri(PR_LOG_INFO, MOD_MEMCACHE_VERSION
": compiled using libmemcached-%s headers, but linked to "
"libmemcached-%s library", LIBMEMCACHED_VERSION_STRING, version);
} else {
pr_log_debug(DEBUG2, MOD_MEMCACHE_VERSION ": using libmemcached-%s",
version);
}
return 0;
}
static int dso_init(void) {
#ifdef PR_USE_CTRLS
register unsigned int i = 0;
#endif /* PR_USE_CTRLS */
/* Allocate the pool for this module's use. */
dso_pool = make_sub_pool(permanent_pool);
pr_pool_tag(dso_pool, MOD_DSO_VERSION);
lt_dlpreload_default(lt_preloaded_symbols);
/* Initialize libltdl. */
if (lt_dlinit() < 0) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": error initializing libltdl: %s",
lt_dlerror());
return -1;
}
/* Explicitly set the search path used for opening modules. */
if (lt_dlsetsearchpath(dso_module_path) < 0) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": error setting module path: %s",
lt_dlerror());
return -1;
}
#ifdef PR_USE_CTRLS
/* Register ctrls handlers. */
for (i = 0; dso_acttab[i].act_action; i++) {
pool *sub_pool = make_sub_pool(dso_pool);
/* Allocate and initialize the ACL for this control. */
dso_acttab[i].act_acl = pcalloc(sub_pool, sizeof(ctrls_acl_t));
dso_acttab[i].act_acl->acl_pool = sub_pool;
pr_ctrls_init_acl(dso_acttab[i].act_acl);
if (pr_ctrls_register(&dso_module, dso_acttab[i].act_action,
dso_acttab[i].act_desc, dso_acttab[i].act_cb) < 0)
pr_log_pri(PR_LOG_INFO, MOD_DSO_VERSION
": error registering '%s' control: %s", dso_acttab[i].act_action,
strerror(errno));
}
#endif /* PR_USE_CTRLS */
/* Ideally, we'd call register a listener for the 'core.exit' event
* and call lt_dlexit() there, politely freeing up any resources allocated
* by the ltdl library. However, it's possible that other modules, later in
* the dispatch cycles, may need to use pointers to memory in shared modules
* that would become invalid by such finalization. So we skip it, for now.
*
* If there was a way to schedule this handler, to happen after all other
* exit handlers, that'd be best.
*/
pr_event_register(&dso_module, "core.restart", dso_restart_ev, NULL);
return 0;
}
static int lmd_init(void) {
memcached_deny_blacklist_mmc = memcached_create(NULL);
if(!memcached_deny_blacklist_mmc) {
pr_log_pri(PR_LOG_ERR, "Fatal %s: Out of memory", MODULE_NAME);
exit(1);
}
pr_event_register(&libmemcached_deny_blacklist_module,
"core.postparse", lmd_postparse_ev, NULL);
pr_event_register(&libmemcached_deny_blacklist_module,
"core.module-unload", lmd_restart_ev, NULL);
/*
pr_event_register(&libmemcached_deny_blacklist_module,
"core.connect", lmd_connect_ev, NULL);
*/
return 0;
}
static int wrap_sess_init(void) {
pr_event_register(&wrap_module, "core.session-reinit", wrap_sess_reinit_ev,
NULL);
/* look up any configured TCPServiceName */
wrap_service_name = get_param_ptr(main_server->conf, "TCPServiceName", FALSE);
if (wrap_service_name == NULL) {
wrap_service_name = "proftpd";
}
return 0;
}
static int log_failure_init(void) {
#if defined(PR_SHARED_MODULE)
pr_event_register(&log_failure_module, "core.module-unload",
log_failure_mod_unload_ev, NULL);
#endif /* PR_SHARED_MODULE */
pr_event_register(&log_failure_module, "core.restart",
log_failure_restart_ev, NULL);
log_failure_pool = make_sub_pool(permanent_pool);
pr_pool_tag(log_failure_pool, MOD_LOG_FAILURE_VERSION);
if (log_failure_mkfields(log_failure_pool) < 0) {
return -1;
}
#if PROFTPD_VERSION_NUMBER >= 0x0001030603
/* Use our own OOM handler. */
json_set_oom(log_failure_oom);
#endif /* ProFTPD 1.3.6rc3 and later */
return 0;
}
static int qos_sess_init(void) {
#ifdef IP_TOS
config_rec *c;
c = find_config(main_server->conf, CONF_PARAM, "QoSOptions", FALSE);
if (c) {
int dataqos;
dataqos = *((int *) c->argv[1]);
if (dataqos != 0) {
pr_event_register(&qos_module, "core.data-connect", qos_data_connect_ev,
NULL);
pr_event_register(&qos_module, "core.data-listen", qos_data_listen_ev,
NULL);
}
}
#endif
pr_event_register(&qos_module, "core.session-reinit", qos_sess_reinit_ev,
NULL);
return 0;
}
static int filetab_init(void) {
/* Initialize the quota source objects for type "file".
*/
quotatab_register_backend("file", filetab_open,
QUOTATAB_LIMIT_SRC|QUOTATAB_TALLY_SRC);
#if defined(PR_SHARED_MODULE)
pr_event_register("atab_file_module, "core.module-unload",
filetab_mod_unload_ev, NULL);
#endif /* PR_SHARED_MODULE */
return 0;
}
MODRET sftppam_auth(cmd_rec *cmd) {
if (!sftppam_handle_auth) {
return PR_DECLINED(cmd);
}
if (sftppam_auth_code != PR_AUTH_OK) {
if (sftppam_authoritative) {
return PR_ERROR_INT(cmd, sftppam_auth_code);
}
return PR_DECLINED(cmd);
}
session.auth_mech = "mod_sftp_pam.c";
pr_event_register(&sftp_pam_module, "core.exit", sftppam_exit_ev, NULL);
return PR_HANDLED(cmd);
}
static int authfile_sess_init(void) {
config_rec *c = NULL;
pr_event_register(&auth_file_module, "core.session-reinit",
authfile_sess_reinit_ev, NULL);
c = find_config(main_server->conf, CONF_PARAM, "AuthUserFile", FALSE);
if (c) {
af_user_file = c->argv[0];
}
c = find_config(main_server->conf, CONF_PARAM, "AuthGroupFile", FALSE);
if (c) {
af_group_file = c->argv[0];
}
return 0;
}
END_TEST
START_TEST (event_generate_test) {
int res;
const char *event = "foo";
pr_event_generate(NULL, NULL);
fail_unless(event_triggered == 0, "Expected triggered count %u, got %u",
0, event_triggered);
pr_event_generate(event, NULL);
fail_unless(event_triggered == 0, "Expected triggered count %u, got %u",
0, event_triggered);
res = pr_event_register(NULL, event, event_cb, NULL);
fail_unless(res == 0, "Failed to register event: %s", strerror(errno));
pr_event_generate("bar", NULL);
fail_unless(event_triggered == 0, "Expected triggered count %u, got %u",
0, event_triggered);
pr_event_generate(event, NULL);
fail_unless(event_triggered == 1, "Expected triggered count %u, got %u",
1, event_triggered);
pr_event_generate(event, NULL);
fail_unless(event_triggered == 2, "Expected triggered count %u, got %u",
2, event_triggered);
res = pr_event_unregister(NULL, NULL, NULL);
fail_unless(res == 0, "Failed to unregister events: %s", strerror(errno));
pr_event_generate(event, NULL);
fail_unless(event_triggered == 2, "Expected triggered count %u, got %u",
2, event_triggered);
}
int pr_trace_set_levels(const char *channel, int min_level, int max_level) {
if (channel == NULL) {
void *v;
if (trace_tab == NULL) {
errno = EINVAL;
return -1;
}
v = pr_table_remove(trace_tab, channel, NULL);
if (v == NULL) {
errno = EINVAL;
return -1;
}
return 0;
}
if (min_level > max_level) {
errno = EINVAL;
return -1;
}
if (trace_tab == NULL &&
min_level < 0) {
return 0;
}
if (trace_pool == NULL) {
trace_pool = make_sub_pool(permanent_pool);
pr_pool_tag(trace_pool, "Trace API");
trace_tab = pr_table_alloc(trace_pool, 0);
/* Register a handler for churning the log pool during HUP. */
pr_event_register(NULL, "core.restart", trace_restart_ev, NULL);
}
if (min_level >= 0) {
struct trace_levels *levels;
levels = pcalloc(trace_pool, sizeof(struct trace_levels));
levels->min_level = min_level;
levels->max_level = max_level;
if (strcmp(channel, PR_TRACE_DEFAULT_CHANNEL) != 0) {
int count = pr_table_exists(trace_tab, channel);
if (count <= 0) {
if (pr_table_add(trace_tab, pstrdup(trace_pool, channel), levels,
sizeof(struct trace_levels)) < 0) {
return -1;
}
} else {
if (pr_table_set(trace_tab, pstrdup(trace_pool, channel), levels,
sizeof(struct trace_levels)) < 0)
return -1;
}
} else {
register unsigned int i;
for (i = 0; trace_channels[i]; i++) {
(void) pr_trace_set_levels(trace_channels[i], min_level, max_level);
}
}
} else {
if (strcmp(channel, PR_TRACE_DEFAULT_CHANNEL) != 0) {
(void) pr_table_remove(trace_tab, channel, NULL);
} else {
register unsigned int i;
for (i = 0; trace_channels[i]; i++) {
(void) pr_table_remove(trace_tab, trace_channels[i], NULL);
}
}
}
return 0;
}
static int counter_sess_init(void) {
config_rec *c;
c = find_config(main_server->conf, CONF_PARAM, "CounterEngine", FALSE);
if (c != NULL) {
counter_engine = *((int *) c->argv[0]);
}
if (counter_engine == FALSE) {
return 0;
}
c = find_config(main_server->conf, CONF_PARAM, "CounterLog", FALSE);
if (c != NULL) {
const char *path = c->argv[0];
if (strcasecmp(path, "none") != 0) {
int res, xerrno;
PRIVS_ROOT
res = pr_log_openfile(path, &counter_logfd, 0660);
xerrno = errno;
PRIVS_RELINQUISH;
if (res < 0) {
pr_log_debug(DEBUG2, MOD_COUNTER_VERSION
": error opening CounterLog '%s': %s", path, strerror(xerrno));
counter_logfd = -1;
}
}
}
/* Find all CounterFile directives for this vhost, and make sure they
* have open handles. We need to do this here, and not in a POST_CMD
* PASS handler because of the need to open handles that may be outside
* of a chroot.
*/
c = find_config(main_server->conf, CONF_PARAM, "CounterFile", TRUE);
while (c != NULL) {
int xerrno = 0;
const char *area = NULL, *path;
pr_fh_t *fh;
struct counter_fh *cfh;
pr_signals_handle();
path = c->argv[0];
if (c->parent != NULL) {
if (c->parent->config_type == CONF_ANON ||
c->parent->config_type == CONF_DIR) {
area = c->parent->name;
} else {
(void) pr_log_writefile(counter_logfd, MOD_COUNTER_VERSION,
"unhandled configuration parent type (%d) for CounterFile, skipping",
c->parent->config_type);
c = find_config_next(c, c->next, CONF_PARAM, "CounterFile", TRUE);
continue;
}
} else {
/* Toplevel CounterFile directive, in "server config" or <VirtualHost>
* sections.
*/
area = "/";
}
PRIVS_ROOT
fh = pr_fsio_open(path, O_RDWR|O_CREAT);
xerrno = errno;
PRIVS_RELINQUISH
if (fh == NULL) {
pr_log_debug(DEBUG1, MOD_COUNTER_VERSION
": error opening CounterFile '%s': %s", path, strerror(xerrno));
counter_engine = FALSE;
if (counter_fhs != NULL) {
for (cfh = (struct counter_fh *) counter_fhs->xas_list; cfh;
cfh = cfh->next) {
(void) pr_fsio_close(cfh->fh);
}
}
return 0;
}
(void) pr_log_writefile(counter_logfd, MOD_COUNTER_VERSION,
"opened CounterFile '%s'", path);
if (counter_fhs == NULL) {
counter_fhs = xaset_create(counter_pool, NULL);
}
cfh = pcalloc(counter_pool, sizeof(struct counter_fh));
/* Ignore any trailing slash. */
cfh->arealen = strlen(area);
if (cfh->arealen > 1 &&
area[cfh->arealen-1] == '/') {
cfh->arealen--;
}
cfh->area = pstrndup(counter_pool, area, cfh->arealen);
/* Mark any areas that use glob(3) characters. */
if (strpbrk(cfh->area, "[*?") != NULL) {
cfh->isglob = TRUE;
}
cfh->fh = fh;
xaset_insert(counter_fhs, (xasetmember_t *) cfh);
c = find_config_next(c, c->next, CONF_PARAM, "CounterFile", TRUE);
}
if (counter_fhs == NULL) {
(void) pr_log_writefile(counter_logfd, MOD_COUNTER_VERSION,
"no CounterFiles configured, disabling module");
counter_engine = FALSE;
return 0;
}
pr_event_register(&counter_module, "core.exit", counter_exit_ev, NULL);
/* If mod_vroot is present, we need to do a little more magic to counter
* the mod_vroot magic.
*/
if (pr_module_exists("mod_vroot.c") == TRUE) {
pr_event_register(&counter_module, "core.chroot", counter_chroot_ev, NULL);
}
return 0;
}
static int mcache_sess_init(void) {
config_rec *c;
pr_event_register(&memcache_module, "core.session-reinit",
mcache_sess_reinit_ev, NULL);
c = find_config(main_server->conf, CONF_PARAM, "MemcacheEngine", FALSE);
if (c) {
int engine;
engine = *((int *) c->argv[0]);
if (engine == FALSE) {
/* Explicitly disable memcache support for this session */
memcache_set_servers(NULL);
return 0;
}
}
pr_event_register(&memcache_module, "core.exit", mcache_exit_ev, NULL);
c = find_config(main_server->conf, CONF_PARAM, "MemcacheLog", FALSE);
if (c) {
const char *path;
path = c->argv[0];
if (strcasecmp(path, "none") != 0) {
int res, xerrno;
pr_signals_block();
PRIVS_ROOT
res = pr_log_openfile(path, &memcache_logfd, PR_LOG_SYSTEM_MODE);
xerrno = errno;
PRIVS_RELINQUISH
pr_signals_unblock();
switch (res) {
case 0:
break;
case -1:
pr_log_pri(PR_LOG_NOTICE, MOD_MEMCACHE_VERSION
": notice: unable to open MemcacheLog '%s': %s", path,
strerror(xerrno));
break;
case PR_LOG_WRITABLE_DIR:
pr_log_pri(PR_LOG_WARNING, MOD_MEMCACHE_VERSION
": notice: unable to use MemcacheLog '%s': parent directory is "
"world-writable", path);
break;
case PR_LOG_SYMLINK:
pr_log_pri(PR_LOG_WARNING, MOD_MEMCACHE_VERSION
": notice: unable to use MemcacheLog '%s': cannot log to a symlink",
path);
break;
}
}
}
c = find_config(main_server->conf, CONF_PARAM, "MemcacheServers", FALSE);
if (c) {
memcached_server_st *memcache_servers;
memcache_servers = c->argv[0];
memcache_set_servers(memcache_servers);
}
c = find_config(main_server->conf, CONF_PARAM, "MemcacheOptions", FALSE);
if (c) {
unsigned long flags;
flags = *((unsigned long *) c->argv[0]);
if (memcache_set_sess_flags(flags) < 0) {
(void) pr_log_writefile(memcache_logfd, MOD_MEMCACHE_VERSION,
"error setting memcache flags: %s", strerror(errno));
}
}
c = find_config(main_server->conf, CONF_PARAM, "MemcacheReplicas", FALSE);
if (c) {
uint64_t count;
count = *((uint64_t *) c->argv[0]);
if (memcache_set_sess_replicas(count) < 0) {
(void) pr_log_writefile(memcache_logfd, MOD_MEMCACHE_VERSION,
"error setting memcache replicas: %s", strerror(errno));
}
}
c = find_config(main_server->conf, CONF_PARAM, "MemcacheTimeouts", FALSE);
if (c) {
unsigned long conn_millis, read_millis, write_millis, retry_sec;
conn_millis = *((unsigned long *) c->argv[0]);
read_millis = *((unsigned long *) c->argv[1]);
write_millis = *((unsigned long *) c->argv[2]);
retry_sec = *((unsigned long *) c->argv[3]);
if (memcache_set_timeouts(conn_millis, read_millis, write_millis,
retry_sec) < 0) {
(void) pr_log_writefile(memcache_logfd, MOD_MEMCACHE_VERSION,
"error setting memcache timeouts: %s", strerror(errno));
}
}
return 0;
}
static int log_failure_sess_init(void) {
config_rec *c;
c = find_config(main_server->conf, CONF_PARAM, "FailureLog", FALSE);
if (c == NULL) {
return 0;
}
/* XXX Open FailureLog */
/* "Authentication" class */
pr_event_register(&log_failure_module, "mod_auth.authentication-code",
log_failure_auth_code_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.empty-password",
log_failure_empty_passwd_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-login-attempts",
log_failure_max_logins_ev, NULL);
/* XXX Include AnonRejectPassword? */
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_auth.max-clients",
log_failure_max_clients_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-clients-per-class",
log_failure_max_clients_per_class_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-clients-per-host",
log_failure_max_clients_per_host_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-clients-per-user",
log_failure_max_clients_per_user_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-connections-per-host",
log_failure_max_conns_per_host_ev, NULL);
pr_event_register(&log_failure_module, "mod_auth.max-hosts-per-user",
log_failure_max_hosts_per_user_ev, NULL);
/* XXX "Transfer" class, for failed uploads/downloads/dirlists */
/* "Timeout" class */
pr_event_register(&log_failure_module, "core.timeout-idle",
log_failure_timeout_idle_ev, NULL);
pr_event_register(&log_failure_module, "core.timeout-login",
log_failure_timeout_login_ev, NULL);
pr_event_register(&log_failure_module, "core.timeout-no-transfer",
log_failure_timeout_noxfer_ev, NULL);
pr_event_register(&log_failure_module, "core.timeout-session",
log_failure_timeout_session_ev, NULL);
pr_event_register(&log_failure_module, "core.timeout-stalled",
log_failure_timeout_stalled_ev, NULL);
if (pr_module_exists("mod_tls.c") == TRUE) {
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_tls.ctrl-handshake-failed",
log_failure_tls_ctrl_handshake_err_ev, NULL);
pr_event_register(&log_failure_module, "mod_tls.data-handshake-failed",
log_failure_tls_data_handshake_err_ev, NULL);
pr_event_register(&log_failure_module, "mod_tls.verify-client-failed",
log_failure_tls_verify_client_err_ev, NULL);
}
if (pr_module_exists("mod_sftp.c") == TRUE) {
/* "Authentication" class */
pr_event_register(&log_failure_module,
"mod_sftp.ssh2.auth-publickey.failed",
log_failure_sftp_auth_pubkey_err_ev, NULL);
pr_event_register(&log_failure_module, "mod_sftp.ssh2.auth-kbdint.failed",
log_failure_sftp_auth_kbdint_err_ev, NULL);
pr_event_register(&log_failure_module, "mod_sftp.ssh2.auth-password.failed",
log_failure_sftp_auth_passwd_err_ev, NULL);
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_sftp.ssh2.kex.failed",
log_failure_sftp_kex_err_ev, NULL);
}
if (pr_module_exists("mod_ban.c") == TRUE) {
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_ban.ban-user",
log_failure_ban_ban_user_ev, NULL);
pr_event_register(&log_failure_module, "mod_ban.ban-host",
log_failure_ban_ban_host_ev, NULL);
pr_event_register(&log_failure_module, "mod_ban.ban-class",
log_failure_ban_ban_class_ev, NULL);
}
if (pr_module_exists("mod_geoip.c") == TRUE) {
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_geoip.connection-denied",
log_failure_geoip_denied_ev, NULL);
}
if (pr_module_exists("mod_wrap.c") == TRUE ||
pr_module_exists("mod_wrap2.c") == TRUE) {
/* "Connection" class */
pr_event_register(&log_failure_module, "mod_wrap.connection-denied",
log_failure_wrap_denied_ev, NULL);
}
return 0;
}
