static void tear_down(void) {
(void) unlink(trace_path);
pr_inet_clear();
pr_trace_set_options(PR_TRACE_OPT_DEFAULT);
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
}
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_use_stderr(FALSE);
pr_trace_set_levels("timers", 0, 0);
}
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
}
}
config_rec *pr_parser_config_ctxt_close(int *empty) {
config_rec *c = *parser_curr_config;
/* Note that if the current config is empty, it should simply be removed.
* Such empty configs can happen for <Directory> sections that
* contain no directives, for example.
*/
if (parser_curr_config == (config_rec **) parser_confstack->elts) {
if (c != NULL &&
(!c->subset || !c->subset->xas_list)) {
xaset_remove(c->set, (xasetmember_t *) c);
destroy_pool(c->pool);
if (empty) {
*empty = TRUE;
}
}
if (*parser_curr_config) {
*parser_curr_config = NULL;
}
return NULL;
}
if (c != NULL &&
(!c->subset || !c->subset->xas_list)) {
xaset_remove(c->set, (xasetmember_t *) c);
destroy_pool(c->pool);
if (empty) {
*empty = TRUE;
}
}
parser_curr_config--;
parser_confstack->nelts--;
return *parser_curr_config;
}
static void log_failure_restart_ev(const void *event_data, void *user_data) {
destroy_pool(log_failure_pool);
log_failure_fields = 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) {
pr_trace_msg(trace_channel, 3, "error creating fields table: %s",
strerror(errno));
}
}
int main()
{
init_pool(&tp,threads_number);
int i;
for(i=0;i<10;i++)
{
add_task(&tp,task,NULL);
printf("%s%d\n", "add ",i+1);
}
destroy_pool(&tp);
return 0;
}
static void tear_down(void) {
pr_inet_clear();
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
}
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("inet", 0, 0);
}
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("config", 0, 0);
}
pr_parser_cleanup();
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
}
}
/* main */
int main() {
init_pool();
init_env();
init_stack_root();
test();
destroy_pool();
stack_dispose(stack_root);
return 0;
}
int proxy_ftp_sess_send_host(pool *p, struct proxy_session *proxy_sess) {
pool *tmp_pool;
int xerrno = 0;
cmd_rec *cmd;
pr_response_t *resp;
unsigned int resp_nlines = 0;
const char *host;
if (pr_table_get(proxy_sess->backend_features, C_HOST, NULL) == NULL) {
pr_trace_msg(trace_channel, 9,
"HOST not supported by backend server, ignoring");
return 0;
}
tmp_pool = make_sub_pool(p);
host = proxy_conn_get_host(proxy_sess->dst_pconn);
cmd = pr_cmd_alloc(tmp_pool, 2, C_HOST, host);
cmd->arg = pstrdup(tmp_pool, host);
resp = send_recv(tmp_pool, proxy_sess->backend_ctrl_conn, cmd, &resp_nlines);
if (resp == NULL) {
xerrno = errno;
destroy_pool(tmp_pool);
errno = xerrno;
return -1;
}
if (resp->num[0] != '2') {
pr_trace_msg(trace_channel, 4,
"received unexpected %s response code %s from backend",
(char *) cmd->argv[0], resp->num);
destroy_pool(tmp_pool);
errno = EPERM;
return -1;
}
destroy_pool(tmp_pool);
return 0;
}
/* Sentinel values:
*
* cmd_type = 0
* cmd_group = NULL
* cmd_class = -1
*/
int pr_stash_remove_cmd(const char *cmd_name, module *m,
unsigned char cmd_type, const char *cmd_group, int cmd_class) {
int count = 0, prev_idx, symtab_idx = 0;
size_t cmd_namelen = 0;
unsigned int hash;
cmdtable *tab = NULL;
if (cmd_name == NULL) {
errno = EINVAL;
return -1;
}
/* Don't forget to include one for the terminating NUL. */
cmd_namelen = strlen(cmd_name) + 1;
hash = sym_type_hash(PR_SYM_CMD, cmd_name, cmd_namelen);
symtab_idx = hash % PR_TUNABLE_HASH_TABLE_SIZE;
prev_idx = -1;
tab = pr_stash_get_symbol2(PR_SYM_CMD, cmd_name, NULL, &prev_idx, &hash);
while (tab) {
cmdtable *cmd_sym;
pr_signals_handle();
/* Note: this works because of a hack: the symbol lookup functions set a
* static pointer, cmd_curr_sym, to point to the struct stash just looked
* up. cmd_curr_sym will not be NULL if pr_stash_get_symbol2() returns
* non-NULL.
*/
cmd_sym = cmd_curr_sym->ptr.sym_cmd;
if ((m == NULL || cmd_curr_sym->sym_module == m) &&
(cmd_type == 0 || cmd_sym->cmd_type == cmd_type) &&
(cmd_group == NULL ||
(cmd_group != NULL &&
cmd_sym->group != NULL &&
strcmp(cmd_sym->group, cmd_group) == 0)) &&
(cmd_class == -1 || cmd_sym->cmd_class == cmd_class)) {
xaset_remove(cmd_symbol_table[symtab_idx],
(xasetmember_t *) cmd_curr_sym);
destroy_pool(cmd_curr_sym->sym_pool);
cmd_curr_sym = NULL;
tab = NULL;
count++;
}
tab = pr_stash_get_symbol2(PR_SYM_CMD, cmd_name, tab, &prev_idx, &hash);
}
return count;
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("aws.http", 0, 0);
pr_trace_set_levels("aws.cloudwatch.conn", 0, 0);
}
aws_http_free();
if (p != NULL) {
destroy_pool(p);
p = permanent_pool = NULL;
}
}
void pr_auth_endgrent(pool *p) {
cmd_rec *cmd = NULL;
cmd = make_cmd(p, 0);
(void) dispatch_auth(cmd, "endgrent", NULL);
if (cmd->tmp_pool) {
destroy_pool(cmd->tmp_pool);
cmd->tmp_pool = NULL;
}
return;
}
static void dso_restart_ev(const void *event_data, void *user_data) {
module *m, *mi;
#ifdef PR_USE_CTRLS
register unsigned int i = 0;
#endif /* PR_USE_CTRLS */
if (dso_pool)
destroy_pool(dso_pool);
dso_pool = make_sub_pool(permanent_pool);
pr_pool_tag(dso_pool, MOD_DSO_VERSION);
#ifdef PR_USE_CTRLS
/* Re-register the control 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);
}
#endif /* PR_USE_CTRLS */
/* Unload all shared modules. */
for (mi = loaded_modules; mi; mi = m) {
#ifndef PR_USE_CTRLS
register unsigned int i;
#endif /* PR_USE_CTRLS */
int is_static = FALSE;
m = mi->next;
for (i = 0; static_modules[i]; i++) {
if (strcmp(mi->name, static_modules[i]->name) == 0) {
is_static = TRUE;
break;
}
}
if (!is_static) {
pr_log_debug(DEBUG7, "unloading 'mod_%s.c'", mi->name);
if (dso_unload_module(mi) < 0)
pr_log_pri(PR_LOG_INFO, "error unloading 'mod_%s.c': %s",
mi->name, strerror(errno));
}
}
return;
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("encode", 0, 0);
}
#ifdef PR_USE_NLS
encode_free();
#endif /* PR_USE_NLS */
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
}
}
static int sftppam_driver_close(sftp_kbdint_driver_t *driver) {
if (driver->driver_pool) {
destroy_pool(driver->driver_pool);
driver->driver_pool = NULL;
}
if (sftppam_user) {
free(sftppam_user);
sftppam_user = NULL;
sftppam_userlen = 0;
}
return 0;
}
int var_free(void) {
if (var_pool) {
if (var_tab) {
pr_table_empty(var_tab);
pr_table_free(var_tab);
}
destroy_pool(var_pool);
var_pool = NULL;
var_tab = NULL;
}
return 0;
}
void pr_data_clear_xfer_pool(void) {
int xfer_type;
if (session.xfer.p)
destroy_pool(session.xfer.p);
/* Note that session.xfer.xfer_type may have been set already, e.g.
* for STOR_UNIQUE uploads. To support this, we need to preserve that
* value.
*/
xfer_type = session.xfer.xfer_type;
memset(&session.xfer, 0, sizeof(session.xfer));
session.xfer.xfer_type = xfer_type;
}
int vroot_fsio_utimes(pr_fs_t *fs, const char *utimes_path,
struct timeval *tvs) {
int res, xerrno;
char vpath[PR_TUNABLE_PATH_MAX + 1], *path = NULL;
pool *tmp_pool = NULL;
if (session.curr_phase == LOG_CMD ||
session.curr_phase == LOG_CMD_ERR ||
(session.sf_flags & SF_ABORT) ||
vroot_path_have_base() == FALSE) {
/* NOTE: once stackable FS modules are supported, have this fall through
* to the next module in the stack.
*/
return utimes(utimes_path, tvs);
}
tmp_pool = make_sub_pool(session.pool);
pr_pool_tag(tmp_pool, "VRoot FSIO utimes pool");
path = vroot_realpath(tmp_pool, utimes_path, VROOT_REALPATH_FL_ABS_PATH);
if (vroot_path_lookup(NULL, vpath, sizeof(vpath)-1, path, 0, NULL) < 0) {
xerrno = errno;
destroy_pool(tmp_pool);
errno = xerrno;
return -1;
}
res = utimes(vpath, tvs);
xerrno = errno;
destroy_pool(tmp_pool);
errno = xerrno;
return res;
}
int main(int argc,char* argv[])
{
int i;
init_pool(3);
for(i=0;i<10;i++)
{
pool_addtask(my_task,&i);
}
//int pool_addtask(void* (*process)(void*),void* arg);
sleep(15);
destroy_pool(pool);
return 0;
}
int init_stash(void) {
if (symbol_pool != NULL) {
destroy_pool(symbol_pool);
}
symbol_pool = make_sub_pool(permanent_pool);
pr_pool_tag(symbol_pool, "Stash Pool");
memset(conf_symbol_table, '\0', sizeof(conf_symbol_table));
memset(cmd_symbol_table, '\0', sizeof(cmd_symbol_table));
memset(auth_symbol_table, '\0', sizeof(auth_symbol_table));
memset(hook_symbol_table, '\0', sizeof(hook_symbol_table));
return 0;
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("proxy.ftp.msg", 0, 0);
}
if (use_ipv6 == FALSE) {
pr_netaddr_disable_ipv6();
}
if (p) {
destroy_pool(p);
p = permanent_pool = session.pool = NULL;
session.c = NULL;
session.notes = NULL;
}
}
static void trace_restart_ev(const void *event_data, void *user_data) {
trace_opts = PR_TRACE_OPT_DEFAULT;
close(trace_logfd);
trace_logfd = -1;
if (trace_pool) {
destroy_pool(trace_pool);
trace_pool = NULL;
trace_tab = NULL;
pr_event_unregister(NULL, "core.restart", trace_restart_ev);
}
return;
}
static void tear_down(void) {
proxy_db_free();
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("proxy.db", 0, 0);
}
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
session.c = NULL;
session.notes = NULL;
}
(void) unlink(db_test_table);
}
static void tear_down(void) {
(void) unlink(misc_test_shutmsg);
pr_fs_statcache_set_policy(PR_TUNABLE_FS_STATCACHE_SIZE,
PR_TUNABLE_FS_STATCACHE_MAX_AGE, 0);
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("fsio", 0, 0);
pr_trace_set_levels("fs.statcache", 0, 0);
}
if (p) {
destroy_pool(p);
p = session.pool = permanent_pool = NULL;
}
}
static void dynmasq_mod_unload_ev(const void *event_data, void *user_data) {
if (strcmp("mod_dynmasq.c", (const char *) event_data) == 0) {
pr_event_unregister(&dynmasq_module, NULL, NULL);
# ifdef PR_USE_CTRLS
/* Unregister any control actions. */
pr_ctrls_unregister(&dynmasq_module, "dynmasq");
destroy_pool(dynmasq_act_pool);
dynmasq_act_pool = NULL;
# endif /* PR_USE_CTRLS */
pr_timer_remove(dynmasq_timer_id, &dynmasq_module);
dynmasq_timer_id = -1;
}
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("netio", 0, 0);
pr_trace_set_levels("inet", 0, 0);
pr_trace_set_levels("proxy.inet", 0, 0);
}
pr_inet_set_default_family(p, 0);
pr_inet_clear();
if (p) {
destroy_pool(p);
p = permanent_pool = NULL;
session.c = NULL;
session.notes = NULL;
}
}
char *pr_ctrls_unregister_module_actions(ctrls_acttab_t *acttab,
char **actions, module *mod) {
register unsigned int i = 0;
/* First, sanity check the given actions against the actions supported by
* this module.
*/
for (i = 0; actions[i]; i++) {
register unsigned int j = 0;
unsigned char valid_action = FALSE;
for (j = 0; acttab[j].act_action; j++) {
if (strcmp(actions[i], acttab[j].act_action) == 0) {
valid_action = TRUE;
break;
}
}
if (!valid_action)
return actions[i];
}
/* Next, iterate through both lists again, looking for actions of the
* module _not_ in the given list.
*/
for (i = 0; acttab[i].act_action; i++) {
register unsigned int j = 0;
unsigned char have_action = FALSE;
for (j = 0; actions[j]; j++) {
if (strcmp(acttab[i].act_action, actions[j]) == 0) {
have_action = TRUE;
break;
}
}
if (have_action) {
pr_trace_msg(trace_channel, 4, "mod_%s.c: removing '%s' control",
mod->name, acttab[i].act_action);
pr_ctrls_unregister(mod, acttab[i].act_action);
destroy_pool(acttab[i].act_acl->acl_pool);
}
}
return NULL;
}
int pr_stash_remove_conf(const char *directive_name, module *m) {
int count = 0, prev_idx, symtab_idx = 0;
size_t directive_namelen = 0;
unsigned int hash;
conftable *tab = NULL;
if (directive_name == NULL) {
errno = EINVAL;
return -1;
}
/* Don't forget to include one for the terminating NUL. */
directive_namelen = strlen(directive_name) + 1;
hash = sym_type_hash(PR_SYM_CONF, directive_name, directive_namelen);
symtab_idx = hash % PR_TUNABLE_HASH_TABLE_SIZE;
prev_idx = -1;
tab = pr_stash_get_symbol2(PR_SYM_CONF, directive_name, NULL, &prev_idx,
&hash);
while (tab) {
pr_signals_handle();
/* Note: this works because of a hack: the symbol lookup functions set a
* static pointer, conf_curr_sym, to point to the struct stash just looked
* up. conf_curr_sym will not be NULL if pr_stash_get_symbol2() returns
* non-NULL.
*/
if (m == NULL ||
conf_curr_sym->sym_module == m) {
xaset_remove(conf_symbol_table[symtab_idx],
(xasetmember_t *) conf_curr_sym);
destroy_pool(conf_curr_sym->sym_pool);
conf_curr_sym = NULL;
tab = NULL;
count++;
}
tab = pr_stash_get_symbol2(PR_SYM_CONF, directive_name, tab, &prev_idx,
&hash);
}
return count;
}
void run_schedule(void) {
sched_t *s, *snext;
if (scheds == NULL ||
scheds->xas_list == NULL) {
return;
}
for (s = (sched_t *) scheds->xas_list; s; s = snext) {
snext = s->next;
if (s->loops-- <= 0) {
s->f(s->a1, s->a2, s->a3, s->a4);
xaset_remove(scheds, (xasetmember_t *) s);
destroy_pool(s->pool);
}
}
}
static void tear_down(void) {
if (getenv("TEST_VERBOSE") != NULL) {
pr_trace_set_levels("proxy.db", 0, 0);
pr_trace_set_levels("proxy.tls", 0, 0);
}
proxy_db_free();
(void) tests_rmpath(p, test_dir);
if (p) {
destroy_pool(p);
p = permanent_pool = proxy_pool = NULL;
server_list = NULL;
main_server = NULL;
session.c = NULL;
session.notes = NULL;
}
}
