自学教程：C++ APR_RING_NEXT函数代码示例

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;}

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;}

/* * 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;}

/* * 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);    }//.........这里部分代码省略.........

/* * 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;            }//.........这里部分代码省略.........