server_rec *pr_parser_server_ctxt_open(const char *addrstr) { server_rec *s; pool *p; p = make_sub_pool(permanent_pool); pr_pool_tag(p, "<VirtualHost> Pool"); s = (server_rec *) pcalloc(p, sizeof(server_rec)); s->pool = p; s->config_type = CONF_VIRTUAL; s->sid = ++parser_sid; s->notes = pr_table_nalloc(p, 0, 8); /* TCP KeepAlive is enabled by default, with the system defaults. */ s->tcp_keepalive = palloc(s->pool, sizeof(struct tcp_keepalive)); s->tcp_keepalive->keepalive_enabled = TRUE; s->tcp_keepalive->keepalive_idle = -1; s->tcp_keepalive->keepalive_count = -1; s->tcp_keepalive->keepalive_intvl = -1; /* Have to make sure it ends up on the end of the chain, otherwise * main_server becomes useless. */ xaset_insert_end(*parser_server_list, (xasetmember_t *) s); s->set = *parser_server_list; if (addrstr) { s->ServerAddress = pstrdup(s->pool, addrstr); } /* Default server port */ s->ServerPort = pr_inet_getservport(s->pool, "ftp", "tcp"); (void) pr_parser_server_ctxt_push(s); return s; }
static void create_main_server(void) { pool *main_pool; main_pool = make_sub_pool(permanent_pool); pr_pool_tag(main_pool, "testsuite#main_server pool"); server_list = xaset_create(main_pool, NULL); main_server = (server_rec *) pcalloc(main_pool, sizeof(server_rec)); xaset_insert(server_list, (xasetmember_t *) main_server); main_server->pool = main_pool; main_server->conf = xaset_create(main_pool, NULL); main_server->set = server_list; main_server->sid = 1; main_server->notes = pr_table_nalloc(main_pool, 0, 8); /* TCP KeepAlive is enabled by default, with the system defaults. */ main_server->tcp_keepalive = palloc(main_server->pool, sizeof(struct tcp_keepalive)); main_server->tcp_keepalive->keepalive_enabled = TRUE; main_server->tcp_keepalive->keepalive_idle = -1; main_server->tcp_keepalive->keepalive_count = -1; main_server->tcp_keepalive->keepalive_intvl = -1; main_server->ServerName = "Test Server"; main_server->ServerPort = 21; }
static pr_netio_stream_t *netio_stream_alloc(pool *parent_pool) { pool *netio_pool = NULL; pr_netio_stream_t *nstrm = NULL; if (!parent_pool) { errno = EINVAL; return NULL; } netio_pool = make_sub_pool(parent_pool); nstrm = pcalloc(netio_pool, sizeof(pr_netio_stream_t)); nstrm->strm_pool = netio_pool; nstrm->strm_fd = -1; nstrm->strm_mode = 0; nstrm->strm_flags = 0; nstrm->strm_buf = NULL; nstrm->strm_data = NULL; nstrm->strm_errno = 0; /* This table will not contain that many entries, so a low number * of chains should suffice. */ nstrm->notes = pr_table_nalloc(nstrm->strm_pool, 0, 4); return nstrm; }
int proxy_ftp_sess_get_feat(pool *p, struct proxy_session *proxy_sess) { pool *tmp_pool; int res, xerrno = 0; cmd_rec *cmd; pr_response_t *resp; unsigned int resp_nlines = 0; char *feats, *token; size_t token_len = 0; tmp_pool = make_sub_pool(p); cmd = pr_cmd_alloc(tmp_pool, 1, C_FEAT); res = proxy_ftp_ctrl_send_cmd(tmp_pool, proxy_sess->backend_ctrl_conn, cmd); if (res < 0) { xerrno = errno; pr_trace_msg(trace_channel, 4, "error sending %s to backend: %s", (char *) cmd->argv[0], strerror(xerrno)); destroy_pool(tmp_pool); errno = xerrno; return -1; } resp = proxy_ftp_ctrl_recv_resp(tmp_pool, proxy_sess->backend_ctrl_conn, &resp_nlines); if (resp == NULL) { xerrno = errno; pr_trace_msg(trace_channel, 4, "error receiving %s response from backend: %s", (char *) cmd->argv[0], strerror(xerrno)); 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); /* Note: If the UseProxyProtocol ProxyOption is enabled, AND if the * response message mentions a "PROXY" command, we might read an * error response here that is NOT actually for the FEAT command we just * sent. * * A backend FTP server which does not understand the PROXY protocol * will treat it as a normal FTP command, and respond. And that will * put us, the client, out of lockstep with the server, for how do we know * that we need to read that error response FIRST, then send another * command? */ destroy_pool(tmp_pool); errno = EPERM; return -1; } proxy_sess->backend_features = pr_table_nalloc(p, 0, 4); feats = resp->msg; token = pr_str_get_token2(&feats, (char *) feat_crlf, &token_len); while (token != NULL) { pr_signals_handle(); if (token_len > 0) { /* The FEAT response lines in which we are interested all start with * a single space, per RFC spec. Ignore any other lines. */ if (token[0] == ' ') { char *key, *val, *ptr; /* Find the next space in the string, to delimit our key/value pairs. */ ptr = strchr(token + 1, ' '); if (ptr != NULL) { key = pstrndup(p, token + 1, ptr - token - 1); val = pstrdup(p, ptr + 1); } else { key = pstrdup(p, token + 1); val = pstrdup(p, ""); } pr_table_add(proxy_sess->backend_features, key, val, 0); } } feats = token + token_len + 1; token = pr_str_get_token2(&feats, (char *) feat_crlf, &token_len); } destroy_pool(tmp_pool); return 0; }
int proxy_db_open(pool *p, const char *table_path, const char *schema_name) { int res; pool *tmp_pool; const char *stmt; if (p == NULL || table_path == NULL) { errno = EINVAL; return -1; } /* If we already have a database handle open, then attach the given * path to our handle. Otherwise, open/create the database file first. */ if (proxy_dbh == NULL) { res = sqlite3_open(table_path, &proxy_dbh); if (res != SQLITE_OK) { pr_log_debug(DEBUG0, MOD_PROXY_VERSION ": error opening SQLite database '%s': %s", table_path, sqlite3_errmsg(proxy_dbh)); errno = EPERM; return -1; } /* Tell SQLite to only use in-memory journals. This is necessary for * working properly when a chroot is used. Note that the MEMORY journal * mode of SQLite is supported only for SQLite-3.6.5 and later. */ res = sqlite3_exec(proxy_dbh, "PRAGMA journal_mode = MEMORY;", NULL, NULL, NULL); if (res != SQLITE_OK) { pr_trace_msg(trace_channel, 2, "error setting MEMORY journal mode on SQLite database '%s': %s", table_path, sqlite3_errmsg(proxy_dbh)); } if (pr_trace_get_level(trace_channel) >= PROXY_DB_SQLITE_TRACE_LEVEL) { sqlite3_trace(proxy_dbh, db_trace, NULL); } prepared_stmts = pr_table_nalloc(db_pool, 0, 4); } tmp_pool = make_sub_pool(p); stmt = pstrcat(tmp_pool, "ATTACH DATABASE '", table_path, "' AS ", schema_name, ";", NULL); res = sqlite3_exec(proxy_dbh, stmt, NULL, NULL, NULL); if (res != SQLITE_OK) { pr_trace_msg(trace_channel, 2, "error attaching database '%s' (as '%s') to existing SQLite handle " "using '%s': %s", table_path, schema_name, stmt, sqlite3_errmsg(proxy_dbh)); destroy_pool(tmp_pool); errno = EPERM; return -1; } destroy_pool(tmp_pool); return 0; }