static apr_status_t remove_tasks(apr_thread_pool_t *me, void *owner)
{
apr_thread_pool_task_t *t_loc;
apr_thread_pool_task_t *next;
int seg;
t_loc = APR_RING_FIRST(me->tasks);
while (t_loc != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link)) {
next = APR_RING_NEXT(t_loc, link);
if (t_loc->owner == owner) {
--me->task_cnt;
seg = TASK_PRIORITY_SEG(t_loc);
if (t_loc == me->task_idx[seg]) {
me->task_idx[seg] = APR_RING_NEXT(t_loc, link);
if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
apr_thread_pool_task,
link)
|| TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
me->task_idx[seg] = NULL;
}
}
APR_RING_REMOVE(t_loc, link);
}
t_loc = next;
}
return APR_SUCCESS;
}
static apr_status_t mmap_cleanup(void *themmap)
{
apr_mmap_t *mm = themmap;
apr_mmap_t *next = APR_RING_NEXT(mm,link);
int rv = 0;
/* we no longer refer to the mmaped region */
APR_RING_REMOVE(mm,link);
APR_RING_NEXT(mm,link) = NULL;
APR_RING_PREV(mm,link) = NULL;
if (next != mm) {
/* more references exist, so we're done */
return APR_SUCCESS;
}
#ifdef BEOS
rv = delete_area(mm->area);
#else
rv = munmap(mm->mm, mm->size);
#endif
mm->mm = (void *)-1;
if (rv == 0) {
return APR_SUCCESS;
}
return errno;
}
APR_DECLARE(apr_status_t) apr_pollset_remove(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor)
{
apr_os_sock_t fd;
pfd_elem_t *ep;
apr_status_t rv = APR_SUCCESS;
int res;
pollset_lock_rings();
if (descriptor->desc_type == APR_POLL_SOCKET) {
fd = descriptor->desc.s->socketdes;
}
else {
fd = descriptor->desc.f->filedes;
}
res = port_dissociate(pollset->port_fd, PORT_SOURCE_FD, fd);
if (res < 0) {
rv = APR_NOTFOUND;
}
if (!APR_RING_EMPTY(&(pollset->query_ring), pfd_elem_t, link)) {
for (ep = APR_RING_FIRST(&(pollset->query_ring));
ep != APR_RING_SENTINEL(&(pollset->query_ring),
pfd_elem_t, link);
ep = APR_RING_NEXT(ep, link)) {
if (descriptor->desc.s == ep->pfd.desc.s) {
APR_RING_REMOVE(ep, link);
APR_RING_INSERT_TAIL(&(pollset->dead_ring),
ep, pfd_elem_t, link);
break;
}
}
}
if (!APR_RING_EMPTY(&(pollset->add_ring), pfd_elem_t, link)) {
for (ep = APR_RING_FIRST(&(pollset->add_ring));
ep != APR_RING_SENTINEL(&(pollset->add_ring),
pfd_elem_t, link);
ep = APR_RING_NEXT(ep, link)) {
if (descriptor->desc.s == ep->pfd.desc.s) {
APR_RING_REMOVE(ep, link);
APR_RING_INSERT_TAIL(&(pollset->dead_ring),
ep, pfd_elem_t, link);
break;
}
}
}
pollset_unlock_rings();
return rv;
}
/*
* This function stop extra idle threads to the cnt.
* @return the number of threads stopped
* NOTE: There could be busy threads become idle during this function
*/
static struct apr_thread_list_elt *trim_threads(apr_thread_pool_t *me,
apr_size_t *cnt, int idle)
{
struct apr_thread_list *thds;
apr_size_t n, n_dbg, i;
struct apr_thread_list_elt *head, *tail, *elt;
apr_thread_mutex_lock(me->lock);
if (idle) {
thds = me->idle_thds;
n = me->idle_cnt;
}
else {
thds = me->busy_thds;
n = me->thd_cnt - me->idle_cnt;
}
if (n <= *cnt) {
apr_thread_mutex_unlock(me->lock);
*cnt = 0;
return NULL;
}
n -= *cnt;
head = APR_RING_FIRST(thds);
for (i = 0; i < *cnt; i++) {
head = APR_RING_NEXT(head, link);
}
tail = APR_RING_LAST(thds);
if (idle) {
APR_RING_UNSPLICE(head, tail, link);
me->idle_cnt = *cnt;
}
n_dbg = 0;
for (elt = head; elt != tail; elt = APR_RING_NEXT(elt, link)) {
elt->state = TH_STOP;
n_dbg++;
}
elt->state = TH_STOP;
n_dbg++;
assert(n == n_dbg);
*cnt = n;
apr_thread_mutex_unlock(me->lock);
APR_RING_PREV(head, link) = NULL;
APR_RING_NEXT(tail, link) = NULL;
return head;
}
static apr_size_t trim_idle_threads(apr_thread_pool_t *me, apr_size_t cnt)
{
apr_size_t n_dbg;
struct apr_thread_list_elt *elt, *head, *tail;
apr_status_t rv;
elt = trim_threads(me, &cnt, 1);
apr_thread_mutex_lock(me->lock);
apr_thread_cond_broadcast(me->cond);
apr_thread_mutex_unlock(me->lock);
n_dbg = 0;
if (NULL != (head = elt)) {
while (elt) {
tail = elt;
apr_thread_join(&rv, elt->thd);
elt = APR_RING_NEXT(elt, link);
++n_dbg;
}
apr_thread_mutex_lock(me->lock);
APR_RING_SPLICE_TAIL(me->recycled_thds, head, tail,
apr_thread_list_elt, link);
apr_thread_mutex_unlock(me->lock);
}
assert(cnt == n_dbg);
return cnt;
}
apr_status_t ap_mpm_end_gen_helper(void *unused) /* cleanup on pconf */
{
int gen = ap_config_generation - 1; /* differs from MPM generation */
mpm_gen_info_t *cur;
if (geninfo == NULL) {
/* initial pconf teardown, MPM hasn't run */
return APR_SUCCESS;
}
cur = APR_RING_FIRST(geninfo);
while (cur != APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link) &&
cur->gen != gen) {
cur = APR_RING_NEXT(cur, link);
}
if (cur == APR_RING_SENTINEL(geninfo, mpm_gen_info_t, link)) {
/* last child of generation already exited */
ap_log_error(APLOG_MARK, APLOG_TRACE4, 0, ap_server_conf,
"no record of generation %d", gen);
}
else {
cur->done = 1;
if (cur->active == 0) {
end_gen(cur);
}
}
return APR_SUCCESS;
}
/*
* Test it the task is the only one within the priority segment.
* If it is not, return the first element with same or lower priority.
* Otherwise, add the task into the queue and return NULL.
*
* NOTE: This function is not thread safe by itself. Caller should hold the lock
*/
static apr_thread_pool_task_t *add_if_empty(apr_thread_pool_t * me,
apr_thread_pool_task_t * const t)
{
int seg;
int next;
apr_thread_pool_task_t *t_next;
seg = TASK_PRIORITY_SEG(t);
if (me->task_idx[seg]) {
assert(APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
me->task_idx[seg]);
t_next = me->task_idx[seg];
while (t_next->dispatch.priority > t->dispatch.priority) {
t_next = APR_RING_NEXT(t_next, link);
if (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) ==
t_next) {
return t_next;
}
}
return t_next;
}
for (next = seg - 1; next >= 0; next--) {
if (me->task_idx[next]) {
APR_RING_INSERT_BEFORE(me->task_idx[next], t, link);
break;
}
}
if (0 > next) {
APR_RING_INSERT_TAIL(me->tasks, t, apr_thread_pool_task, link);
}
me->task_idx[seg] = t;
return NULL;
}
/**
* Called by other modules to print their "jmx beans" to the response in
* whatever format was requested by the client.
*/
static apr_status_t bmx_bean_print_text_plain(request_rec *r,
const struct bmx_bean *bean)
{
apr_size_t objectname_strlen = bmx_objectname_strlen(bean->objectname) + 1;
char *objectname_str = apr_palloc(r->pool, objectname_strlen);
(void)bmx_objectname_str(bean->objectname, objectname_str,
objectname_strlen);
(void)ap_rputs("Name: ", r);
(void)ap_rputs(objectname_str, r);
(void)ap_rputs("\n", r);
/* for each element in bean->bean_properties, print it */
if (!APR_RING_EMPTY(&(bean->bean_props), bmx_property, link)) {
struct bmx_property *p = NULL;
const char *value;
for (p = APR_RING_FIRST(&(bean->bean_props));
p != APR_RING_SENTINEL(&(bean->bean_props), bmx_property, link);
p = APR_RING_NEXT(p, link)) {
(void)ap_rputs(p->key, r);
(void)ap_rputs(": ", r);
value = property_print(r->pool, p);
if (value)
(void)ap_rputs(value, r);
(void)ap_rputs("\n", r);
}
}
(void)ap_rputs("\n", r);
return APR_SUCCESS;
}
static void wait_on_busy_threads(apr_thread_pool_t *me, void *owner)
{
#ifndef NDEBUG
apr_os_thread_t *os_thread;
#endif
struct apr_thread_list_elt *elt;
apr_thread_mutex_lock(me->lock);
elt = APR_RING_FIRST(me->busy_thds);
while (elt != APR_RING_SENTINEL(me->busy_thds, apr_thread_list_elt, link)) {
if (elt->current_owner != owner) {
elt = APR_RING_NEXT(elt, link);
continue;
}
#ifndef NDEBUG
/* make sure the thread is not the one calling tasks_cancel */
apr_os_thread_get(&os_thread, elt->thd);
#ifdef WIN32
/* hack for apr win32 bug */
assert(!apr_os_thread_equal(apr_os_thread_current(), os_thread));
#else
assert(!apr_os_thread_equal(apr_os_thread_current(), *os_thread));
#endif
#endif
while (elt->current_owner == owner) {
apr_thread_mutex_unlock(me->lock);
apr_sleep(200 * 1000);
apr_thread_mutex_lock(me->lock);
}
elt = APR_RING_FIRST(me->busy_thds);
}
apr_thread_mutex_unlock(me->lock);
return;
}
/** Get (copy) MRCP header fields */
MRCP_DECLARE(apt_bool_t) mrcp_header_fields_get(mrcp_message_header_t *header, const mrcp_message_header_t *src_header, const mrcp_message_header_t *mask_header, apr_pool_t *pool)
{
apt_header_field_t *header_field;
const apt_header_field_t *src_header_field;
const apt_header_field_t *mask_header_field;
for(mask_header_field = APR_RING_FIRST(&mask_header->header_section.ring);
mask_header_field != APR_RING_SENTINEL(&mask_header->header_section.ring, apt_header_field_t, link);
mask_header_field = APR_RING_NEXT(mask_header_field, link)) {
header_field = apt_header_section_field_get(&header->header_section,mask_header_field->id);
if(header_field) {
/* this header field has already been set, skip to the next one */
continue;
}
src_header_field = apt_header_section_field_get(&src_header->header_section,mask_header_field->id);
if(src_header_field) {
/* copy the entire header field */
header_field = apt_header_field_copy(src_header_field,pool);
mrcp_header_accessor_value_duplicate(header,header_field,src_header,src_header_field,pool);
}
else {
/* copy only the name of the header field */
header_field = apt_header_field_copy(mask_header_field,pool);
}
/* add the header field to the header section */
apt_header_section_field_add(&header->header_section,header_field);
}
return TRUE;
}
APT_DECLARE(apt_list_elem_t*) apt_list_next_elem_get(apt_obj_list_t *list, apt_list_elem_t *elem)
{
apt_list_elem_t *next_elem = APR_RING_NEXT(elem,link);
if(next_elem == APR_RING_SENTINEL(&list->head,apt_list_elem_t,link)) {
next_elem = NULL;
}
return next_elem;
}
static apr_status_t add_task(apr_thread_pool_t *me, apr_thread_start_t func,
void *param, apr_byte_t priority, int push,
void *owner)
{
apr_thread_pool_task_t *t;
apr_thread_pool_task_t *t_loc;
apr_thread_t *thd;
apr_status_t rv = APR_SUCCESS;
apr_thread_mutex_lock(me->lock);
t = task_new(me, func, param, priority, owner, 0);
if (NULL == t) {
apr_thread_mutex_unlock(me->lock);
return APR_ENOMEM;
}
t_loc = add_if_empty(me, t);
if (NULL == t_loc) {
goto FINAL_EXIT;
}
if (push) {
while (APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link) !=
t_loc && t_loc->dispatch.priority >= t->dispatch.priority) {
t_loc = APR_RING_NEXT(t_loc, link);
}
}
APR_RING_INSERT_BEFORE(t_loc, t, link);
if (!push) {
if (t_loc == me->task_idx[TASK_PRIORITY_SEG(t)]) {
me->task_idx[TASK_PRIORITY_SEG(t)] = t;
}
}
FINAL_EXIT:
me->task_cnt++;
if (me->task_cnt > me->tasks_high)
me->tasks_high = me->task_cnt;
if (0 == me->thd_cnt || (0 == me->idle_cnt && me->thd_cnt < me->thd_max &&
me->task_cnt > me->threshold)) {
rv = apr_thread_create(&thd, NULL, thread_pool_func, me, me->pool);
if (APR_SUCCESS == rv) {
++me->thd_cnt;
if (me->thd_cnt > me->thd_high)
me->thd_high = me->thd_cnt;
}
}
apr_thread_mutex_unlock(me->lock);
apr_thread_mutex_lock(me->cond_lock);
apr_thread_cond_signal(me->cond);
apr_thread_mutex_unlock(me->cond_lock);
return rv;
}
/** Generate header section */
APT_DECLARE(apt_bool_t) apt_header_section_generate(const apt_header_section_t *header, apt_text_stream_t *stream)
{
apt_header_field_t *header_field;
for(header_field = APR_RING_FIRST(&header->ring);
header_field != APR_RING_SENTINEL(&header->ring, apt_header_field_t, link);
header_field = APR_RING_NEXT(header_field, link)) {
apt_header_field_generate(header_field,stream);
}
return apt_text_eol_insert(stream);
}
MPF_DECLARE(apt_bool_t) mpf_context_factory_process(mpf_context_factory_t *factory)
{
mpf_context_t *context;
for(context = APR_RING_FIRST(&factory->head);
context != APR_RING_SENTINEL(&factory->head, mpf_context_t, link);
context = APR_RING_NEXT(context, link)) {
mpf_context_process(context);
}
return TRUE;
}
static apr_status_t impl_pollset_remove(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor)
{
pfd_elem_t *ep;
apr_status_t rv = APR_SUCCESS;
#ifdef HAVE_MTCP
struct mtcp_epoll_event ev = {0};
#else
struct epoll_event ev = {0}; /* ignored, but must be passed with
* kernel < 2.6.9
*/
#endif
int ret = -1;
if (descriptor->desc_type == APR_POLL_SOCKET) {
#ifdef HAVE_MTCP
int cpu = sched_getcpu();
ret = mtcp_epoll_ctl(g_mctx[cpu], pollset->p->epoll_fd, EPOLL_CTL_DEL,
descriptor->desc.s->socketdes, &ev);
#else
ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL,
descriptor->desc.s->socketdes, &ev);
#endif
}
else {
ret = epoll_ctl(pollset->p->epoll_fd, EPOLL_CTL_DEL,
descriptor->desc.f->filedes, &ev);
}
if (ret < 0) {
rv = APR_NOTFOUND;
}
if (!(pollset->flags & APR_POLLSET_NOCOPY)) {
pollset_lock_rings();
for (ep = APR_RING_FIRST(&(pollset->p->query_ring));
ep != APR_RING_SENTINEL(&(pollset->p->query_ring),
pfd_elem_t, link);
ep = APR_RING_NEXT(ep, link)) {
if (descriptor->desc.s == ep->pfd.desc.s) {
APR_RING_REMOVE(ep, link);
APR_RING_INSERT_TAIL(&(pollset->p->dead_ring),
ep, pfd_elem_t, link);
break;
}
}
pollset_unlock_rings();
}
return rv;
}
static apr_status_t mmap_cleanup(void *themmap)
{
apr_mmap_t *mm = themmap;
apr_mmap_t *next = APR_RING_NEXT(mm,link);
apr_status_t rv = 0;
/* we no longer refer to the mmaped region */
APR_RING_REMOVE(mm,link);
APR_RING_NEXT(mm,link) = NULL;
APR_RING_PREV(mm,link) = NULL;
if (next != mm) {
/* more references exist, so we're done */
return APR_SUCCESS;
}
if (mm->mv) {
if (!UnmapViewOfFile(mm->mv))
{
apr_status_t rv = apr_get_os_error();
CloseHandle(mm->mhandle);
mm->mv = NULL;
mm->mhandle = NULL;
return rv;
}
mm->mv = NULL;
}
if (mm->mhandle)
{
if (!CloseHandle(mm->mhandle))
{
apr_status_t rv = apr_get_os_error();
CloseHandle(mm->mhandle);
mm->mhandle = NULL;
return rv;
}
mm->mhandle = NULL;
}
return APR_SUCCESS;
}
/** Execute the filters. */
int kdfilter_exec(kdfilter *self,
struct filter_params *params,
struct filter_result *res) {
struct filter_driver * en;
memset(res, 0, sizeof(struct filter_result));
for (en = APR_RING_FIRST(&self->filter_drv_list);
en != APR_RING_SENTINEL(&self->filter_drv_list, filter_driver, link);
en = APR_RING_NEXT(en, link)) {
kerror_reset();
INFO(_log_filter_, "Filtering message with filter: %s", en->filter_name);
/* Filter test phase. */
DEBUG(_log_filter_, "Filter %s test phase.", en->filter_name);
if ((en->p_test)(self, en->private_data) < 0) {
if (kerror_has_error())
KERROR_PUSH(_filter_, 0, "filter %s failed test phase", en->filter_name);
else
KERROR_SET(_filter_, 0, "filter %s failed test phase", en->filter_name);
return -1;
}
/* Proceed to filtering. */
DEBUG(_log_filter_, "Filter %s scan phase.", en->filter_name);
if ((en->p_scan)(self, en->private_data, params, res) < 0) {
if (kerror_has_error())
KERROR_PUSH(_filter_, 0, "filter %s failed scan", en->filter_name);
else
KERROR_SET(_filter_, 0, "filter %s failed scan", en->filter_name);
return -1;
}
if (res->msg_state)
INFO(_log_filter_, "Filter %s report: %s", en->filter_name, res->msg);
else
INFO(_log_filter_, "Filter %s returned an empty report.", en->filter_name);
DEBUG(_log_filter_, "Filter %s rating: %d.", en->filter_name, res->rating);
/*
* If one of those bit is set, that means we need to interrupt the filtering
* and go back to the main loop for confirmation.
*/
if ((res->rating & FILTER_EXEC_DENY) != 0 || (res->rating & FILTER_EXEC_CHALLENGE) != 0)
return 0;
}
return 0;
}
static apr_status_t impl_pollset_remove(apr_pollset_t *pollset,
const apr_pollfd_t *descriptor)
{
pfd_elem_t *ep;
apr_status_t rv;
apr_os_sock_t fd;
pollset_lock_rings();
if (descriptor->desc_type == APR_POLL_SOCKET) {
fd = descriptor->desc.s->socketdes;
}
else {
fd = descriptor->desc.f->filedes;
}
rv = APR_NOTFOUND; /* unless at least one of the specified conditions is */
if (descriptor->reqevents & APR_POLLIN) {
EV_SET(&pollset->p->kevent, fd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,
NULL) != -1) {
rv = APR_SUCCESS;
}
}
if (descriptor->reqevents & APR_POLLOUT) {
EV_SET(&pollset->p->kevent, fd, EVFILT_WRITE, EV_DELETE, 0, 0, NULL);
if (kevent(pollset->p->kqueue_fd, &pollset->p->kevent, 1, NULL, 0,
NULL) != -1) {
rv = APR_SUCCESS;
}
}
for (ep = APR_RING_FIRST(&(pollset->p->query_ring));
ep != APR_RING_SENTINEL(&(pollset->p->query_ring),
pfd_elem_t, link);
ep = APR_RING_NEXT(ep, link)) {
if (descriptor->desc.s == ep->pfd.desc.s) {
APR_RING_REMOVE(ep, link);
APR_RING_INSERT_TAIL(&(pollset->p->dead_ring),
ep, pfd_elem_t, link);
break;
}
}
pollset_unlock_rings();
return rv;
}
/*
* schedule a task to run in "time" microseconds. Find the spot in the ring where
* the time fits. Adjust the short_time so the thread wakes up when the time is reached.
*/
static apr_status_t schedule_task(apr_thread_pool_t *me,
apr_thread_start_t func, void *param,
void *owner, apr_interval_time_t time)
{
apr_thread_pool_task_t *t;
apr_thread_pool_task_t *t_loc;
apr_thread_t *thd;
apr_status_t rv = APR_SUCCESS;
apr_thread_mutex_lock(me->lock);
t = task_new(me, func, param, 0, owner, time);
if (NULL == t) {
apr_thread_mutex_unlock(me->lock);
return APR_ENOMEM;
}
t_loc = APR_RING_FIRST(me->scheduled_tasks);
while (NULL != t_loc) {
/* if the time is less than the entry insert ahead of it */
if (t->dispatch.time < t_loc->dispatch.time) {
++me->scheduled_task_cnt;
APR_RING_INSERT_BEFORE(t_loc, t, link);
break;
}
else {
t_loc = APR_RING_NEXT(t_loc, link);
if (t_loc ==
APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
link)) {
++me->scheduled_task_cnt;
APR_RING_INSERT_TAIL(me->scheduled_tasks, t,
apr_thread_pool_task, link);
break;
}
}
}
/* there should be at least one thread for scheduled tasks */
if (0 == me->thd_cnt) {
rv = apr_thread_create(&thd, NULL, thread_pool_func, me, me->pool);
if (APR_SUCCESS == rv) {
++me->thd_cnt;
if (me->thd_cnt > me->thd_high)
me->thd_high = me->thd_cnt;
}
}
apr_thread_mutex_unlock(me->lock);
apr_thread_mutex_lock(me->cond_lock);
apr_thread_cond_signal(me->cond);
apr_thread_mutex_unlock(me->cond_lock);
return rv;
}
/* Cleanup function. */
static apr_status_t kdfilter_delete(void *data) {
kdfilter *self = (kdfilter *)data;
struct filter_driver *drv;
/* Call the close method of each filters. */
for (drv = APR_RING_FIRST(&self->filter_drv_list);
drv != APR_RING_SENTINEL(&self->filter_drv_list, filter_driver, link);
drv = APR_RING_NEXT(drv, link)) {
DEBUG(_log_filter_, "Unregistering filter: %s.", drv->filter_name);
(drv->p_close)(self, drv->private_data);
}
return APR_SUCCESS;
}
/** Parse MRCP channel-identifier */
MRCP_DECLARE(apt_bool_t) mrcp_channel_id_parse(mrcp_channel_id *channel_id, mrcp_message_header_t *header, apr_pool_t *pool)
{
apt_header_field_t *header_field;
for(header_field = APR_RING_FIRST(&header->header_section.ring);
header_field != APR_RING_SENTINEL(&header->header_section.ring, apt_header_field_t, link);
header_field = APR_RING_NEXT(header_field, link)) {
if(header_field->value.length && strncasecmp(header_field->name.buf,MRCP_CHANNEL_ID,MRCP_CHANNEL_ID_LENGTH) == 0) {
apt_id_resource_parse(&header_field->value,'@',&channel_id->session_id,&channel_id->resource_name,pool);
apt_header_section_field_remove(&header->header_section,header_field);
return TRUE;
}
}
return FALSE;
}
static mrcp_connection_t* mrcp_connection_find(mrcp_connection_agent_t *agent, const apt_str_t *remote_ip)
{
mrcp_connection_t *connection;
if(!agent || !remote_ip) {
return NULL;
}
for(connection = APR_RING_FIRST(&agent->connection_list);
connection != APR_RING_SENTINEL(&agent->connection_list, mrcp_connection_t, link);
connection = APR_RING_NEXT(connection, link)) {
if(apt_string_compare(&connection->remote_ip,remote_ip) == TRUE) {
return connection;
}
}
return NULL;
}
static mrcp_connection_t* mrcp_client_agent_connection_find(mrcp_connection_agent_t *agent, mrcp_control_descriptor_t *descriptor)
{
apr_sockaddr_t *sockaddr;
mrcp_connection_t *connection;
for(connection = APR_RING_FIRST(&agent->connection_list);
connection != APR_RING_SENTINEL(&agent->connection_list, mrcp_connection_t, link);
connection = APR_RING_NEXT(connection, link)) {
if(apr_sockaddr_info_get(&sockaddr,descriptor->ip.buf,APR_INET,descriptor->port,0,connection->pool) == APR_SUCCESS) {
if(apr_sockaddr_equal(sockaddr,connection->r_sockaddr) != 0 &&
descriptor->port == connection->r_sockaddr->port) {
return connection;
}
}
}
return NULL;
}
static apr_status_t remove_scheduled_tasks(apr_thread_pool_t *me,
void *owner)
{
apr_thread_pool_task_t *t_loc;
apr_thread_pool_task_t *next;
t_loc = APR_RING_FIRST(me->scheduled_tasks);
while (t_loc !=
APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
link)) {
next = APR_RING_NEXT(t_loc, link);
/* if this is the owner remove it */
if (t_loc->owner == owner) {
--me->scheduled_task_cnt;
APR_RING_REMOVE(t_loc, link);
}
t_loc = next;
}
return APR_SUCCESS;
}
/** Parse MRCP header fields */
MRCP_DECLARE(apt_bool_t) mrcp_header_fields_parse(mrcp_message_header_t *header, apr_pool_t *pool)
{
apt_header_field_t *header_field;
for(header_field = APR_RING_FIRST(&header->header_section.ring);
header_field != APR_RING_SENTINEL(&header->header_section.ring, apt_header_field_t, link);
header_field = APR_RING_NEXT(header_field, link)) {
if(mrcp_header_field_value_parse(&header->resource_header_accessor,header_field,pool) == TRUE) {
header_field->id += GENERIC_HEADER_COUNT;
apt_header_section_field_set(&header->header_section,header_field);
}
else if(mrcp_header_field_value_parse(&header->generic_header_accessor,header_field,pool) == TRUE) {
apt_header_section_field_set(&header->header_section,header_field);
}
else {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Unknown MRCP header field: %s",header_field->name.buf);
}
}
return TRUE;
}
/*
* NOTE: This function is not thread safe by itself. Caller should hold the lock
*/
static apr_thread_pool_task_t *pop_task(apr_thread_pool_t * me)
{
apr_thread_pool_task_t *task = NULL;
int seg;
/* check for scheduled tasks */
if (me->scheduled_task_cnt > 0) {
task = APR_RING_FIRST(me->scheduled_tasks);
assert(task != NULL);
assert(task !=
APR_RING_SENTINEL(me->scheduled_tasks, apr_thread_pool_task,
link));
/* if it's time */
if (task->dispatch.time <= apr_time_now()) {
--me->scheduled_task_cnt;
APR_RING_REMOVE(task, link);
return task;
}
}
/* check for normal tasks if we're not returning a scheduled task */
if (me->task_cnt == 0) {
return NULL;
}
task = APR_RING_FIRST(me->tasks);
assert(task != NULL);
assert(task != APR_RING_SENTINEL(me->tasks, apr_thread_pool_task, link));
--me->task_cnt;
seg = TASK_PRIORITY_SEG(task);
if (task == me->task_idx[seg]) {
me->task_idx[seg] = APR_RING_NEXT(task, link);
if (me->task_idx[seg] == APR_RING_SENTINEL(me->tasks,
apr_thread_pool_task, link)
|| TASK_PRIORITY_SEG(me->task_idx[seg]) != seg) {
me->task_idx[seg] = NULL;
}
}
APR_RING_REMOVE(task, link);
return task;
}
/** Set (copy) MRCP header fields */
MRCP_DECLARE(apt_bool_t) mrcp_header_fields_set(mrcp_message_header_t *header, const mrcp_message_header_t *src_header, apr_pool_t *pool)
{
apt_header_field_t *header_field;
const apt_header_field_t *src_header_field;
for(src_header_field = APR_RING_FIRST(&src_header->header_section.ring);
src_header_field != APR_RING_SENTINEL(&src_header->header_section.ring, apt_header_field_t, link);
src_header_field = APR_RING_NEXT(src_header_field, link)) {
header_field = apt_header_section_field_get(&header->header_section,src_header_field->id);
if(header_field) {
/* this header field has already been set, just copy its value */
apt_string_copy(&header_field->value,&src_header_field->value,pool);
}
else {
/* copy the entire header field and add it to the header section */
header_field = apt_header_field_copy(src_header_field,pool);
apt_header_section_field_add(&header->header_section,header_field);
}
mrcp_header_accessor_value_duplicate(header,header_field,src_header,src_header_field,pool);
}
return TRUE;
}
/*
* The worker thread function. Take a task from the queue and perform it if
* there is any. Otherwise, put itself into the idle thread list and waiting
* for signal to wake up.
* The thread terminate directly by detach and exit when it is asked to stop
* after finishing a task. Otherwise, the thread should be in idle thread list
* and should be joined.
*/
static void *APR_THREAD_FUNC thread_pool_func(apr_thread_t * t, void *param)
{
apr_thread_pool_t *me = param;
apr_thread_pool_task_t *task = NULL;
apr_interval_time_t wait;
struct apr_thread_list_elt *elt;
apr_thread_mutex_lock(me->lock);
--me->spawning_cnt;
elt = elt_new(me, t);
if (!elt) {
apr_thread_mutex_unlock(me->lock);
apr_thread_exit(t, APR_ENOMEM);
}
while (!me->terminated && elt->state != TH_STOP) {
/* Test if not new element, it is awakened from idle */
if (APR_RING_NEXT(elt, link) != elt) {
--me->idle_cnt;
APR_RING_REMOVE(elt, link);
}
APR_RING_INSERT_TAIL(me->busy_thds, elt, apr_thread_list_elt, link);
task = pop_task(me);
while (NULL != task && !me->terminated) {
++me->tasks_run;
elt->current_owner = task->owner;
apr_thread_mutex_unlock(me->lock);
apr_thread_data_set(task, "apr_thread_pool_task", NULL, t);
task->func(t, task->param);
apr_thread_mutex_lock(me->lock);
APR_RING_INSERT_TAIL(me->recycled_tasks, task,
apr_thread_pool_task, link);
elt->current_owner = NULL;
if (TH_STOP == elt->state) {
break;
}
task = pop_task(me);
}
assert(NULL == elt->current_owner);
if (TH_STOP != elt->state)
APR_RING_REMOVE(elt, link);
/* Test if a busy thread been asked to stop, which is not joinable */
if ((me->idle_cnt >= me->idle_max
&& !(me->scheduled_task_cnt && 0 >= me->idle_max)
&& !me->idle_wait)
|| me->terminated || elt->state != TH_RUN) {
--me->thd_cnt;
if ((TH_PROBATION == elt->state) && me->idle_wait)
++me->thd_timed_out;
APR_RING_INSERT_TAIL(me->recycled_thds, elt,
apr_thread_list_elt, link);
apr_thread_mutex_unlock(me->lock);
apr_thread_detach(t);
apr_thread_exit(t, APR_SUCCESS);
return NULL; /* should not be here, safe net */
}
/* busy thread become idle */
++me->idle_cnt;
APR_RING_INSERT_TAIL(me->idle_thds, elt, apr_thread_list_elt, link);
/*
* If there is a scheduled task, always scheduled to perform that task.
* Since there is no guarantee that current idle threads are scheduled
* for next scheduled task.
*/
if (me->scheduled_task_cnt)
wait = waiting_time(me);
else if (me->idle_cnt > me->idle_max) {
wait = me->idle_wait;
elt->state = TH_PROBATION;
}
else
wait = -1;
if (wait >= 0) {
apr_thread_cond_timedwait(me->cond, me->lock, wait);
}
else {
apr_thread_cond_wait(me->cond, me->lock);
}
}
/* idle thread been asked to stop, will be joined */
--me->thd_cnt;
apr_thread_mutex_unlock(me->lock);
apr_thread_exit(t, APR_SUCCESS);
return NULL; /* should not be here, safe net */
}
/*
* purge cache entries
*/
static void purge(char *path, apr_pool_t *pool, apr_off_t max)
{
apr_off_t sum, total, entries, etotal;
ENTRY *e, *n, *oldest;
sum = 0;
entries = 0;
for (e = APR_RING_FIRST(&root);
e != APR_RING_SENTINEL(&root, _entry, link);
e = APR_RING_NEXT(e, link)) {
sum += e->hsize;
sum += e->dsize;
entries++;
}
total = sum;
etotal = entries;
if (sum <= max) {
printstats(total, sum, max, etotal, entries);
return;
}
/* process all entries with a timestamp in the future, this may
* happen if a wrong system time is corrected
*/
for (e = APR_RING_FIRST(&root);
e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {
n = APR_RING_NEXT(e, link);
if (e->response_time > now || e->htime > now || e->dtime > now) {
delete_entry(path, e->basename, pool);
sum -= e->hsize;
sum -= e->dsize;
entries--;
APR_RING_REMOVE(e, link);
if (sum <= max) {
if (!interrupted) {
printstats(total, sum, max, etotal, entries);
}
return;
}
}
e = n;
}
if (interrupted) {
return;
}
/* process all entries with are expired */
for (e = APR_RING_FIRST(&root);
e != APR_RING_SENTINEL(&root, _entry, link) && !interrupted;) {
n = APR_RING_NEXT(e, link);
if (e->expire != APR_DATE_BAD && e->expire < now) {
delete_entry(path, e->basename, pool);
sum -= e->hsize;
sum -= e->dsize;
entries--;
APR_RING_REMOVE(e, link);
if (sum <= max) {
if (!interrupted) {
printstats(total, sum, max, etotal, entries);
}
return;
}
}
e = n;
}
if (interrupted) {
return;
}
/* process remaining entries oldest to newest, the check for an emtpy
* ring actually isn't necessary except when the compiler does
* corrupt 64bit arithmetics which happend to me once, so better safe
* than sorry
*/
while (sum > max && !interrupted && !APR_RING_EMPTY(&root, _entry, link)) {
oldest = APR_RING_FIRST(&root);
for (e = APR_RING_NEXT(oldest, link);
e != APR_RING_SENTINEL(&root, _entry, link);
e = APR_RING_NEXT(e, link)) {
if (e->dtime < oldest->dtime) {
oldest = e;
}
}
delete_entry(path, oldest->basename, pool);
sum -= oldest->hsize;
sum -= oldest->dsize;
entries--;
APR_RING_REMOVE(oldest, link);
}
if (!interrupted) {
printstats(total, sum, max, etotal, entries);
}
}
/*
* walk the cache directory tree
*/
static int process_dir(char *path, apr_pool_t *pool)
{
apr_dir_t *dir;
apr_pool_t *p;
apr_hash_t *h;
apr_hash_index_t *i;
apr_file_t *fd;
apr_status_t status;
apr_finfo_t info;
apr_size_t len;
apr_time_t current, deviation;
char *nextpath, *base, *ext, *orig_basename;
APR_RING_ENTRY(_direntry) anchor;
DIRENTRY *d, *t, *n;
ENTRY *e;
int skip, retries;
disk_cache_info_t disk_info;
APR_RING_INIT(&anchor, _direntry, link);
apr_pool_create(&p, pool);
h = apr_hash_make(p);
fd = NULL;
skip = 0;
deviation = MAXDEVIATION * APR_USEC_PER_SEC;
if (apr_dir_open(&dir, path, p) != APR_SUCCESS) {
return 1;
}
while (apr_dir_read(&info, 0, dir) == APR_SUCCESS && !interrupted) {
if (!strcmp(info.name, ".") || !strcmp(info.name, "..")) {
continue;
}
d = apr_pcalloc(p, sizeof(DIRENTRY));
d->basename = apr_pstrcat(p, path, "/", info.name, NULL);
APR_RING_INSERT_TAIL(&anchor, d, _direntry, link);
}
apr_dir_close(dir);
if (interrupted) {
return 1;
}
skip = baselen + 1;
for (d = APR_RING_FIRST(&anchor);
!interrupted && d != APR_RING_SENTINEL(&anchor, _direntry, link);
d=n) {
n = APR_RING_NEXT(d, link);
base = strrchr(d->basename, '/');
if (!base++) {
base = d->basename;
}
ext = strchr(base, '.');
/* there may be temporary files which may be gone before
* processing, always skip these if not in realclean mode
*/
if (!ext && !realclean) {
if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
&& strlen(base) == AP_TEMPFILE_NAMELEN) {
continue;
}
}
/* this may look strange but apr_stat() may return errno which
* is system dependent and there may be transient failures,
* so just blindly retry for a short while
*/
retries = STAT_ATTEMPTS;
status = APR_SUCCESS;
do {
if (status != APR_SUCCESS) {
apr_sleep(STAT_DELAY);
}
status = apr_stat(&info, d->basename, DIRINFO, p);
} while (status != APR_SUCCESS && !interrupted && --retries);
/* what may happen here is that apache did create a file which
* we did detect but then does delete the file before we can
* get file information, so if we don't get any file information
* we will ignore the file in this case
*/
if (status != APR_SUCCESS) {
if (!realclean && !interrupted) {
continue;
}
return 1;
}
if (info.filetype == APR_DIR) {
/* Make a copy of the basename, as process_dir modifies it */
orig_basename = apr_pstrdup(pool, d->basename);
if (process_dir(d->basename, pool)) {
return 1;
}
/* If asked to delete dirs, do so now. We don't care if it fails.
* If it fails, it likely means there was something else there.
*/
if (deldirs && !dryrun) {
apr_dir_remove(orig_basename, pool);
}
continue;
}
if (info.filetype != APR_REG) {
continue;
}
if (!ext) {
if (!strncasecmp(base, AP_TEMPFILE_BASE, AP_TEMPFILE_BASELEN)
&& strlen(base) == AP_TEMPFILE_NAMELEN) {
d->basename += skip;
d->type = TEMP;
d->dsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
}
continue;
}
if (!strcasecmp(ext, CACHE_HEADER_SUFFIX)) {
*ext = '\0';
d->basename += skip;
/* if a user manually creates a '.header' file */
if (d->basename[0] == '\0') {
continue;
}
t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
if (t) {
d = t;
}
d->type |= HEADER;
d->htime = info.mtime;
d->hsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
continue;
}
if (!strcasecmp(ext, CACHE_DATA_SUFFIX)) {
*ext = '\0';
d->basename += skip;
/* if a user manually creates a '.data' file */
if (d->basename[0] == '\0') {
continue;
}
t = apr_hash_get(h, d->basename, APR_HASH_KEY_STRING);
if (t) {
d = t;
}
d->type |= DATA;
d->dtime = info.mtime;
d->dsize = info.size;
apr_hash_set(h, d->basename, APR_HASH_KEY_STRING, d);
}
}
if (interrupted) {
return 1;
}
path[baselen] = '\0';
for (i = apr_hash_first(p, h); i && !interrupted; i = apr_hash_next(i)) {
void *hvalue;
apr_uint32_t format;
apr_hash_this(i, NULL, NULL, &hvalue);
d = hvalue;
switch(d->type) {
case HEADERDATA:
nextpath = apr_pstrcat(p, path, "/", d->basename,
CACHE_HEADER_SUFFIX, NULL);
if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,
APR_OS_DEFAULT, p) == APR_SUCCESS) {
len = sizeof(format);
if (apr_file_read_full(fd, &format, len,
&len) == APR_SUCCESS) {
if (format == DISK_FORMAT_VERSION) {
apr_off_t offset = 0;
apr_file_seek(fd, APR_SET, &offset);
len = sizeof(disk_cache_info_t);
if (apr_file_read_full(fd, &disk_info, len,
&len) == APR_SUCCESS) {
apr_file_close(fd);
e = apr_palloc(pool, sizeof(ENTRY));
APR_RING_INSERT_TAIL(&root, e, _entry, link);
e->expire = disk_info.expire;
e->response_time = disk_info.response_time;
e->htime = d->htime;
e->dtime = d->dtime;
e->hsize = d->hsize;
e->dsize = d->dsize;
e->basename = apr_pstrdup(pool, d->basename);
break;
}
else {
apr_file_close(fd);
}
}
else if (format == VARY_FORMAT_VERSION) {
/* This must be a URL that added Vary headers later,
* so kill the orphaned .data file
*/
apr_file_close(fd);
apr_file_remove(apr_pstrcat(p, path, "/", d->basename,
CACHE_DATA_SUFFIX, NULL),
p);
}
}
else {
apr_file_close(fd);
}
}
/* we have a somehow unreadable headers file which is associated
* with a data file. this may be caused by apache currently
* rewriting the headers file. thus we may delete the file set
* either in realclean mode or if the headers file modification
* timestamp is not within a specified positive or negative offset
* to the current time.
*/
current = apr_time_now();
if (realclean || d->htime < current - deviation
|| d->htime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->hsize;
unsolicited += d->dsize;
}
break;
/* single data and header files may be deleted either in realclean
* mode or if their modification timestamp is not within a
* specified positive or negative offset to the current time.
* this handling is necessary due to possible race conditions
* between apache and this process
*/
case HEADER:
current = apr_time_now();
nextpath = apr_pstrcat(p, path, "/", d->basename,
CACHE_HEADER_SUFFIX, NULL);
if (apr_file_open(&fd, nextpath, APR_FOPEN_READ | APR_FOPEN_BINARY,
APR_OS_DEFAULT, p) == APR_SUCCESS) {
len = sizeof(format);
if (apr_file_read_full(fd, &format, len,
&len) == APR_SUCCESS) {
if (format == VARY_FORMAT_VERSION) {
apr_time_t expires;
len = sizeof(expires);
apr_file_read_full(fd, &expires, len, &len);
apr_file_close(fd);
if (expires < current) {
delete_entry(path, d->basename, p);
}
break;
}
}
apr_file_close(fd);
}
if (realclean || d->htime < current - deviation
|| d->htime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->hsize;
}
break;
case DATA:
current = apr_time_now();
if (realclean || d->dtime < current - deviation
|| d->dtime > current + deviation) {
delete_entry(path, d->basename, p);
unsolicited += d->dsize;
}
break;
/* temp files may only be deleted in realclean mode which
* is asserted above if a tempfile is in the hash array
*/
case TEMP:
delete_file(path, d->basename, p);
unsolicited += d->dsize;
break;
}
}
if (interrupted) {
return 1;
}
apr_pool_destroy(p);
if (benice) {
apr_sleep(NICE_DELAY);
}
if (interrupted) {
return 1;
}
return 0;
}