/** Create interruptable pollset on top of APR pollset */
APT_DECLARE(apt_pollset_t*) apt_pollset_create(apr_uint32_t size, apr_pool_t *pool)
{
apt_pollset_t *pollset = apr_palloc(pool,sizeof(apt_pollset_t));
pollset->pool = pool;
memset(&pollset->wakeup_pfd,0,sizeof(pollset->wakeup_pfd));
/* create pollset with max number of descriptors size+1,
where +1 is builtin wakeup descriptor */
if(apr_pollset_create(&pollset->base,size+1,pool,0) != APR_SUCCESS) {
return NULL;
}
/* create wakeup pipe */
if(apt_wakeup_pipe_create(pollset) != TRUE) {
apr_pollset_destroy(pollset->base);
return NULL;
}
/* add wakeup pipe to pollset */
if(apr_pollset_add(pollset->base,&pollset->wakeup_pfd) != APR_SUCCESS) {
apt_wakeup_pipe_destroy(pollset);
apr_pollset_destroy(pollset->base);
return NULL;
}
return pollset;
}
static apt_bool_t mrcp_client_agent_pollset_create(mrcp_connection_agent_t *agent)
{
apr_status_t status;
/* create pollset */
status = apr_pollset_create(&agent->pollset, (apr_uint32_t)agent->max_connection_count + 1, agent->pool, 0);
if(status != APR_SUCCESS) {
apt_log(APT_PRIO_WARNING,"Failed to Create Pollset");
return FALSE;
}
/* create control socket */
if(mrcp_client_agent_control_socket_create(agent) != TRUE) {
apt_log(APT_PRIO_WARNING,"Failed to Create Control Socket");
apr_pollset_destroy(agent->pollset);
return FALSE;
}
/* add control socket to pollset */
agent->control_sock_pfd.desc_type = APR_POLL_SOCKET;
agent->control_sock_pfd.reqevents = APR_POLLIN;
agent->control_sock_pfd.desc.s = agent->control_sock;
agent->control_sock_pfd.client_data = agent->control_sock;
status = apr_pollset_add(agent->pollset, &agent->control_sock_pfd);
if(status != APR_SUCCESS) {
apt_log(APT_PRIO_WARNING,"Failed to Add Control Socket to Pollset");
mrcp_client_agent_control_socket_destroy(agent);
apr_pollset_destroy(agent->pollset);
return FALSE;
}
return TRUE;
}
apr_status_t file_cleanup_model(int fd)
{
apr_status_t rv = APR_SUCCESS;
(*set_errno)(errno);
if ((*fs_close)(fd) == 0) {
int flags = 0; // TODO
if (flags & APR_FOPEN_DELONCLOSE) {
char *fname = ""; // TODO
(*fs_unlink)(fname);
}
errno = (*get_errno)();
}
else {
/* fs_close() was not successful. */
errno = (*get_errno)();
rv = errno;
}
#ifndef WAITIO_USES_POLL
int pollset = 0; // TODO? or delete?
if (pollset != NULL) {
apr_status_t pollset_rv = apr_pollset_destroy(pollset);
/* If the file close failed, return its error value,
* not apr_pollset_destroy()'s.
*/
if (rv == APR_SUCCESS) {
rv = pollset_rv;
}
}
#endif /* !WAITIO_USES_POLL */
return rv;
}
static void mrcp_client_agent_pollset_destroy(mrcp_connection_agent_t *agent)
{
mrcp_client_agent_control_socket_destroy(agent);
if(agent->pollset) {
apr_pollset_destroy(agent->pollset);
agent->pollset = NULL;
}
}
int poll_worker_destroy(
poll_worker_t *worker) {
worker->fg_exit = true;
poll_worker_stop(worker);
apr_pollset_destroy(worker->ps);
apr_pool_destroy(worker->mp_poll);
free(worker);
return 0;
}
/** Destroy pollset */
APT_DECLARE(apt_bool_t) apt_pollset_destroy(apt_pollset_t *pollset)
{
/* remove wakeup pipe from pollset */
apr_pollset_remove(pollset->base,&pollset->wakeup_pfd);
/* destroy wakeup pipe */
apt_wakeup_pipe_destroy(pollset);
/* destroy pollset */
apr_pollset_destroy(pollset->base);
return TRUE;
}
void LLPumpIO::rebuildPollset()
{
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
// lldebugs << "LLPumpIO::rebuildPollset()" << llendl;
if(mPollset)
{
//lldebugs << "destroying pollset" << llendl;
apr_pollset_destroy(mPollset);
mPollset = NULL;
}
U32 size = 0;
running_chains_t::iterator run_it = mRunningChains.begin();
running_chains_t::iterator run_end = mRunningChains.end();
for(; run_it != run_end; ++run_it)
{
size += (*run_it).mDescriptors.size();
}
//lldebugs << "found " << size << " descriptors." << llendl;
if(size)
{
// Recycle the memory pool
const S32 POLLSET_POOL_RECYCLE_COUNT = 100;
if(mCurrentPool
&& (0 == (++mCurrentPoolReallocCount % POLLSET_POOL_RECYCLE_COUNT)))
{
apr_pool_destroy(mCurrentPool);
mCurrentPool = NULL;
mCurrentPoolReallocCount = 0;
}
if(!mCurrentPool)
{
apr_status_t status = apr_pool_create(&mCurrentPool, mPool);
(void)ll_apr_warn_status(status);
}
// add all of the file descriptors
run_it = mRunningChains.begin();
LLChainInfo::conditionals_t::iterator fd_it;
LLChainInfo::conditionals_t::iterator fd_end;
apr_pollset_create(&mPollset, size, mCurrentPool, 0);
for(; run_it != run_end; ++run_it)
{
fd_it = (*run_it).mDescriptors.begin();
fd_end = (*run_it).mDescriptors.end();
for(; fd_it != fd_end; ++fd_it)
{
apr_pollset_add(mPollset, &((*fd_it).second));
}
}
}
}
LLPumpIO::~LLPumpIO()
{
LLMemType m1(LLMemType::MTYPE_IO_PUMP);
#if LL_THREADS_APR
if (mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
if (mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
#endif
mChainsMutex = NULL;
mCallbackMutex = NULL;
if(mPollset)
{
// lldebugs << "cleaning up pollset" << llendl;
apr_pollset_destroy(mPollset);
mPollset = NULL;
}
}
static apr_status_t file_cleanup(apr_file_t *file, int is_child)
{
apr_status_t rv = APR_SUCCESS;
int fd = file->filedes;
/* Set file descriptor to -1 before close(), so that there is no
* chance of returning an already closed FD from apr_os_file_get().
*/
file->filedes = -1;
if (close(fd) == 0) {
/* Only the parent process should delete the file! */
if (!is_child && (file->flags & APR_DELONCLOSE)) {
unlink(file->fname);
}
#if APR_HAS_THREADS
if (file->thlock) {
rv = apr_thread_mutex_destroy(file->thlock);
}
#endif
}
else {
/* Restore, close() was not successful. */
file->filedes = fd;
/* Are there any error conditions other than EINTR or EBADF? */
rv = errno;
}
#ifndef WAITIO_USES_POLL
if (file->pollset != NULL) {
apr_status_t pollset_rv = apr_pollset_destroy(file->pollset);
/* If the file close failed, return its error value,
* not apr_pollset_destroy()'s.
*/
if (rv == APR_SUCCESS) {
rv = pollset_rv;
}
}
#endif /* !WAITIO_USES_POLL */
return rv;
}
void LLPumpIO::cleanup()
{
#if LL_THREADS_APR
if(mChainsMutex) apr_thread_mutex_destroy(mChainsMutex);
if(mCallbackMutex) apr_thread_mutex_destroy(mCallbackMutex);
#endif
mChainsMutex = NULL;
mCallbackMutex = NULL;
if(mPollset)
{
// LL_DEBUGS() << "cleaning up pollset" << LL_ENDL;
apr_pollset_destroy(mPollset);
mPollset = NULL;
}
if(mCurrentPool)
{
apr_pool_destroy(mCurrentPool);
mCurrentPool = NULL;
}
mPool = NULL;
}
int sock_close(net_sock_t *nsock)
{
network_sock_t *sock = (network_sock_t *)nsock;
if (sock == NULL) return(0);
//log_printf(15, "sock_close: closing fd=%d\n", sock->fd);
//**QWERT
apr_thread_mutex_destroy(sock->lock);
//**QWERTY
if (sock->fd != NULL) apr_socket_close(sock->fd);
if (sock->pollset != NULL) apr_pollset_destroy(sock->pollset);
apr_pool_destroy(sock->mpool);
free(sock);
return(0);
}
void LLPluginProcessParent::updatePollset()
{
if(!sInstancesMutex)
{
// No instances have been created yet. There's no work to do.
return;
}
LLMutexLock lock(sInstancesMutex);
if(sPollSet)
{
LL_DEBUGS("PluginPoll") << "destroying pollset " << sPollSet << LL_ENDL;
// delete the existing pollset.
apr_pollset_destroy(sPollSet);
sPollSet = NULL;
sPollSetPool.destroy();
}
std::list<LLPluginProcessParent*>::iterator iter;
int count = 0;
// Count the number of instances that want to be in the pollset
for(iter = sInstances.begin(); iter != sInstances.end(); iter++)
{
(*iter)->mPolledInput = false;
if((*iter)->mPollFD.client_data)
{
// This instance has a socket that needs to be polled.
++count;
}
}
if(sUseReadThread && sReadThread && !sReadThread->isQuitting())
{
if(!sPollSet && (count > 0))
{
#ifdef APR_POLLSET_NOCOPY
// The pollset doesn't exist yet. Create it now.
sPollSetPool.create();
apr_status_t status = apr_pollset_create(&sPollSet, count, sPollSetPool(), APR_POLLSET_NOCOPY);
if(status != APR_SUCCESS)
{
#endif // APR_POLLSET_NOCOPY
LL_WARNS("PluginPoll") << "Couldn't create pollset. Falling back to non-pollset mode." << LL_ENDL;
sPollSet = NULL;
sPollSetPool.destroy();
#ifdef APR_POLLSET_NOCOPY
}
else
{
LL_DEBUGS("PluginPoll") << "created pollset " << sPollSet << LL_ENDL;
// Pollset was created, add all instances to it.
for(iter = sInstances.begin(); iter != sInstances.end(); iter++)
{
if((*iter)->mPollFD.client_data)
{
status = apr_pollset_add(sPollSet, &((*iter)->mPollFD));
if(status == APR_SUCCESS)
{
(*iter)->mPolledInput = true;
}
else
{
LL_WARNS("PluginPoll") << "apr_pollset_add failed with status " << status << LL_ENDL;
}
}
}
}
#endif // APR_POLLSET_NOCOPY
}
}
}
apr_status_t run_test_server(serv_ctx_t *servctx,
apr_short_interval_time_t duration,
apr_pool_t *pool)
{
apr_status_t status;
apr_pollset_t *pollset;
apr_int32_t num;
const apr_pollfd_t *desc;
/* create a new pollset */
#ifdef BROKEN_WSAPOLL
status = apr_pollset_create_ex(&pollset, 32, pool, 0,
APR_POLLSET_SELECT);
#else
status = apr_pollset_create(&pollset, 32, pool, 0);
#endif
if (status != APR_SUCCESS)
return status;
/* Don't accept new connection while processing client connection. At
least for present time.*/
if (servctx->client_sock) {
apr_pollfd_t pfd = { 0 };
pfd.desc_type = APR_POLL_SOCKET;
pfd.desc.s = servctx->client_sock;
pfd.reqevents = APR_POLLIN | APR_POLLOUT;
status = apr_pollset_add(pollset, &pfd);
if (status != APR_SUCCESS)
goto cleanup;
if (servctx->proxy_client_sock) {
apr_pollfd_t pfd = { 0 };
pfd.desc_type = APR_POLL_SOCKET;
pfd.desc.s = servctx->proxy_client_sock;
pfd.reqevents = APR_POLLIN | APR_POLLOUT;
status = apr_pollset_add(pollset, &pfd);
if (status != APR_SUCCESS)
goto cleanup;
}
}
else {
apr_pollfd_t pfd = { 0 };
pfd.desc_type = APR_POLL_SOCKET;
pfd.desc.s = servctx->serv_sock;
pfd.reqevents = APR_POLLIN;
status = apr_pollset_add(pollset, &pfd);
if (status != APR_SUCCESS)
goto cleanup;
}
status = apr_pollset_poll(pollset, APR_USEC_PER_SEC >> 1, &num, &desc);
if (status != APR_SUCCESS)
goto cleanup;
while (num--) {
if (desc->desc.s == servctx->serv_sock) {
status = apr_socket_accept(&servctx->client_sock, servctx->serv_sock,
servctx->pool);
if (status != APR_SUCCESS)
goto cleanup;
serf__log_skt(TEST_VERBOSE, __FILE__, servctx->client_sock,
"server/proxy accepted incoming connection.\n");
apr_socket_opt_set(servctx->client_sock, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(servctx->client_sock, 0);
status = APR_SUCCESS;
goto cleanup;
}
if (desc->desc.s == servctx->client_sock) {
if (servctx->handshake) {
status = servctx->handshake(servctx);
if (status)
goto cleanup;
}
/* Replay data to socket. */
status = replay(servctx, desc->rtnevents, pool);
if (APR_STATUS_IS_EOF(status)) {
apr_socket_close(servctx->client_sock);
servctx->client_sock = NULL;
if (servctx->reset)
servctx->reset(servctx);
/* If this is a proxy and the client closed the connection, also
close the connection to the server. */
if (servctx->proxy_client_sock) {
apr_socket_close(servctx->proxy_client_sock);
servctx->proxy_client_sock = NULL;
goto cleanup;
}
}
else if (APR_STATUS_IS_EAGAIN(status)) {
status = APR_SUCCESS;
}
else if (status != APR_SUCCESS) {
/* Real error. */
goto cleanup;
}
}
if (desc->desc.s == servctx->proxy_client_sock) {
/* Replay data to proxy socket. */
status = proxy_replay(servctx, desc->rtnevents, pool);
if (APR_STATUS_IS_EOF(status)) {
apr_socket_close(servctx->proxy_client_sock);
servctx->proxy_client_sock = NULL;
}
else if (APR_STATUS_IS_EAGAIN(status)) {
status = APR_SUCCESS;
}
else if (status != APR_SUCCESS) {
/* Real error. */
goto cleanup;
}
}
desc++;
}
cleanup:
apr_pollset_destroy(pollset);
return status;
}
static void justsleep(abts_case *tc, void *data)
{
apr_int32_t nsds;
const apr_pollfd_t *hot_files;
apr_pollset_t *pollset;
apr_status_t rv;
apr_time_t t1, t2;
int i;
apr_pollset_method_e methods[] = {
APR_POLLSET_DEFAULT,
APR_POLLSET_SELECT,
APR_POLLSET_KQUEUE,
APR_POLLSET_PORT,
APR_POLLSET_EPOLL,
APR_POLLSET_POLL};
nsds = 1;
t1 = apr_time_now();
rv = apr_poll(NULL, 0, &nsds, apr_time_from_msec(200));
t2 = apr_time_now();
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 0, nsds);
ABTS_ASSERT(tc,
"apr_poll() didn't sleep",
(t2 - t1) > apr_time_from_msec(100));
for (i = 0; i < sizeof methods / sizeof methods[0]; i++) {
rv = apr_pollset_create_ex(&pollset, 5, p, 0, methods[i]);
if (rv != APR_ENOTIMPL) {
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
nsds = 1;
t1 = apr_time_now();
rv = apr_pollset_poll(pollset, apr_time_from_msec(200), &nsds,
&hot_files);
t2 = apr_time_now();
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 0, nsds);
ABTS_ASSERT(tc,
"apr_pollset_poll() didn't sleep",
(t2 - t1) > apr_time_from_msec(100));
rv = apr_pollset_destroy(pollset);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
rv = apr_pollcb_create_ex(&pollcb, 5, p, 0, methods[0]);
if (rv != APR_ENOTIMPL) {
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
t1 = apr_time_now();
rv = apr_pollcb_poll(pollcb, apr_time_from_msec(200), NULL, NULL);
t2 = apr_time_now();
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_ASSERT(tc,
"apr_pollcb_poll() didn't sleep",
(t2 - t1) > apr_time_from_msec(100));
/* no apr_pollcb_destroy() */
}
}
}
int main(int argc, const char *const *argv, const char *const *env)
{
const char *db_filename = "last_message.db";
int dying = 0;
sqlite3 *sql = NULL;
lmSQL lmdb = {};
apr_socket_t *acc = NULL;
apr_pollset_t *pollset = NULL;
APR_DO_OR_DIE(apr_app_initialize(&argc, &argv, &env));
atexit(&apr_terminate);
apr_pool_t *pool;
APR_DO_OR_DIE(apr_pool_create(&pool, NULL));
if (argc > 2) {
return print_usage();
}
if (argc == 2) {
if (strcmp(argv[1], "--help") == 0) {
return print_usage();
}
db_filename = argv[1];
}
int err;
if ((err = sqlite3_open(db_filename, &sql)) != SQLITE_OK) {
fprintf(stderr, "Can't open DB (%s): %s.\n", db_filename,
sqlite3_errstr(err));
return 1;
}
int rc;
char *rc_msg;
const char *CREATE_MESSAGE_TABLES =
"CREATE TABLE IF NOT EXISTS messages ("
" msgid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
" name BLOB NOT NULL,"
" left INTEGER NOT NULL,"
" message BLOB NOT NULL"
");";
rc = sqlite3_exec(sql, CREATE_MESSAGE_TABLES, NULL, NULL, &rc_msg);
if (rc != SQLITE_OK) {
FAIL("Can't create 'messages' table: %s.\n", rc_msg);
sqlite3_close(sql);
return 1;
}
const char *CREATE_MESSAGE_SEEN = "CREATE TABLE IF NOT EXISTS seen ("
" name BLOB PRIMARY KEY NOT NULL,"
" msgid INTEGER NOT NULL"
");";
rc = sqlite3_exec(sql, CREATE_MESSAGE_SEEN, NULL, NULL, &rc_msg);
if (rc != SQLITE_OK) {
FAIL("Can't create 'seen' table: %s.\n", rc_msg);
sqlite3_close(sql);
return 1;
}
lmdb.sql = sql;
#define LM_SQLITE_PREP(thing, statement) \
do { \
int prep = \
sqlite3_prepare_v2(sql, (statement), -1, (thing), NULL); \
if (prep != SQLITE_OK) { \
FAIL("SQL compilation error: (%s) while compiling " \
"(%s).\n", \
sqlite3_errmsg(sql), statement); \
goto die; \
} \
} while (0)
LM_SQLITE_PREP(&lmdb.put, "INSERT INTO messages (name, left, message) "
"VALUES (?, ?, ?);");
LM_SQLITE_PREP(&lmdb.get, "SELECT msgid, left, message "
"FROM messages "
"WHERE name = ? "
"ORDER BY msgid ASC;");
LM_SQLITE_PREP(&lmdb.seen_add, "INSERT INTO seen (name, msgid) "
"VALUES (?, ?);");
LM_SQLITE_PREP(&lmdb.seen_del, "DELETE FROM seen "
"WHERE name = ?;");
LM_SQLITE_PREP(&lmdb.seen_get, "SELECT msgid FROM seen "
"WHERE name = ?;");
LM_SQLITE_PREP(&lmdb.drop, "DELETE FROM messages "
"WHERE msgid <= ? "
" AND name = ?;");
APR_DO_OR_DIE(apr_socket_create(&acc, APR_INET, SOCK_STREAM, 0, pool));
APR_DO_OR_DIE(apr_socket_opt_set(acc, APR_SO_REUSEADDR, 1));
apr_sockaddr_t *l_addr;
APR_DO_OR_DIE(
apr_sockaddr_info_get(&l_addr, NULL, APR_INET, 1066, 0, pool));
APR_DO_OR_DIE(apr_socket_bind(acc, l_addr));
APR_DO_OR_DIE(apr_socket_listen(acc, 8));
apr_pollfd_t apr_accept_desc;
memset(&apr_accept_desc, 0, sizeof apr_accept_desc);
apr_accept_desc.p = pool;
apr_accept_desc.desc_type = APR_POLL_SOCKET;
apr_accept_desc.desc.s = acc;
apr_accept_desc.reqevents = APR_POLLIN;
apr_accept_desc.client_data = NULL;
APR_DO_OR_DIE(apr_pollset_create(&pollset, 256, pool, 0));
APR_DO_OR_DIE(apr_pollset_add(pollset, &apr_accept_desc));
apr_signal(SIGTERM, shutdown_on_signal);
apr_signal(SIGINT, shutdown_on_signal);
apr_int32_t signalled_len = 0;
const apr_pollfd_t *signalled = NULL;
apr_status_t poll_err = 0;
for (;;) {
if (global_shutting_down) {
goto goodnight;
}
if (!APR_STATUS_IS_EINTR(poll_err)) {
APR_DO_OR_DIE(poll_err);
}
for (apr_int32_t i = 0; i < signalled_len; i++) {
const apr_pollfd_t *s = signalled + i;
if (s->desc.s == acc) {
DEBUG("accept\n");
do_client_accept(acc, pollset, pool, &lmdb);
} else {
do_client_state_machine(s, pollset);
}
}
poll_err =
apr_pollset_poll(pollset, -1, &signalled_len, &signalled);
}
if (0) {
goodnight:
fprintf(stderr, "Goodnight!\n");
}
if (0) {
die:
dying = 1;
}
sqlite3_finalize(lmdb.put);
lmdb.put = 0;
sqlite3_finalize(lmdb.get);
lmdb.get = 0;
sqlite3_finalize(lmdb.seen_add);
lmdb.seen_add = 0;
sqlite3_finalize(lmdb.seen_del);
lmdb.seen_del = 0;
sqlite3_finalize(lmdb.seen_get);
lmdb.seen_get = 0;
sqlite3_finalize(lmdb.drop);
lmdb.drop = 0;
if (sqlite3_close(sql) != SQLITE_OK) {
fprintf(stderr, "Error closing DB (%s): %s.\n", db_filename,
sqlite3_errmsg(sql));
return 1;
}
apr_pollset_destroy(pollset);
apr_socket_close(acc);
return dying;
}
apr_status_t test_server_run(test_baton_t *tb,
apr_short_interval_time_t duration,
apr_pool_t *pool)
{
apr_status_t status;
apr_pollset_t *pollset;
apr_int32_t num;
const apr_pollfd_t *desc;
/* create a new pollset */
status = apr_pollset_create(&pollset, 32, pool, 0);
if (status != APR_SUCCESS)
return status;
/* Don't accept new connection while processing client connection. At
least for present time.*/
if (tb->client_sock) {
apr_pollfd_t pfd = { pool, APR_POLL_SOCKET, APR_POLLIN | APR_POLLOUT, 0,
{ NULL }, NULL };
pfd.desc.s = tb->client_sock;
status = apr_pollset_add(pollset, &pfd);
if (status != APR_SUCCESS)
goto cleanup;
}
else {
apr_pollfd_t pfd = { pool, APR_POLL_SOCKET, APR_POLLIN, 0,
{ NULL }, NULL };
pfd.desc.s = tb->serv_sock;
status = apr_pollset_add(pollset, &pfd);
if (status != APR_SUCCESS)
goto cleanup;
}
status = apr_pollset_poll(pollset, APR_USEC_PER_SEC >> 1, &num, &desc);
if (status != APR_SUCCESS)
goto cleanup;
while (num--) {
if (desc->desc.s == tb->serv_sock) {
status = apr_socket_accept(&tb->client_sock, tb->serv_sock,
tb->pool);
if (status != APR_SUCCESS)
goto cleanup;
apr_socket_opt_set(tb->client_sock, APR_SO_NONBLOCK, 1);
apr_socket_timeout_set(tb->client_sock, 0);
status = APR_SUCCESS;
goto cleanup;
}
if (desc->desc.s == tb->client_sock) {
/* Replay data to socket. */
status = replay(tb, pool);
if (APR_STATUS_IS_EOF(status)) {
apr_socket_close(tb->client_sock);
tb->client_sock = NULL;
}
else if (APR_STATUS_IS_EAGAIN(status)) {
status = APR_SUCCESS;
}
else if (status != APR_SUCCESS) {
/* Real error. */
goto cleanup;
}
}
desc++;
}
cleanup:
apr_pollset_destroy(pollset);
return status;
}