pni_entry_t *pni_store_get(pni_store_t *store, const char *address)
{
assert(store);
if (address) {
pni_stream_t *stream = pni_stream_get(store, address);
if (!stream) return NULL;
return LL_HEAD(stream, stream);
} else {
return LL_HEAD(store, store);
}
}
static void deadlines_update(iocpdesc_t *iocpd, pn_timestamp_t deadline)
{
if (deadline == iocpd->deadline)
return;
iocpd->deadline = deadline;
pn_selector_t *selector = iocpd->selector;
if (!deadline) {
deadlines_remove(selector, iocpd);
pni_events_update(iocpd, iocpd->events & ~PN_EXPIRED);
} else {
if (iocpd->deadlines_prev || selector->deadlines_head == iocpd) {
deadlines_remove(selector, iocpd);
pni_events_update(iocpd, iocpd->events & ~PN_EXPIRED);
}
iocpdesc_t *dl_iocpd = LL_HEAD(selector, deadlines);
while (dl_iocpd && dl_iocpd->deadline <= deadline)
dl_iocpd = dl_iocpd->deadlines_next;
if (dl_iocpd) {
// insert
iocpd->deadlines_prev = dl_iocpd->deadlines_prev;
iocpd->deadlines_next = dl_iocpd;
dl_iocpd->deadlines_prev = iocpd;
if (selector->deadlines_head == dl_iocpd)
selector->deadlines_head = iocpd;
} else {
LL_ADD(selector, deadlines, iocpd); // append
}
}
}
//
// bring the time current
// check the list to see if anything expired
// if so, do it - and either return it to the freelist
// or put it back into the timeoutq
//
// return whether or not you handled anything
//
int
handle_timeoutq_event( )
{
struct event *ep;
//struct event *head_timeoutq;
ep = (struct event *)LL_HEAD(timeoutq); //ep now points to the head of TimeoutQ
//if diff < 1 us then execute the function
if(ep->timeout - then_usec < 1 )
{
//execute function
pfv_t tmp = ep->go;
(* tmp)(ep->data);
//remove from the timeoutq and reinsert back to freelist
LL_DETACH(timeoutq, ep);
if(ep->repeat_interval != 0)
{
create_timeoutq_event( ep->repeat_interval, ep->repeat_interval, ep->go, ep->data);
//update then_usec
// then_usec -= now_usec();
}
else
{
//push to freelist
LL_PUSH(freelist,ep);
}
return 1;
}
else
return 0;
}
void pni_stream_free(pni_stream_t *stream)
{
if (!stream) return;
pni_entry_t *entry;
while ((entry = LL_HEAD(stream, stream))) {
pni_entry_free(entry);
}
free(stream);
}
//
// account for however much time has elapsed since last update
// return timeout or MAX
//
int
bring_timeoutq_current()
{
unsigned int now;
struct event *ep;
ep = (struct event *)LL_HEAD(timeoutq); //ep now points to the head of TimeoutQ
if(!LL_IS_EMPTY(ep))
{
// now = now_usec();
ep->timeout -= (now-then_usec);
return (ep->timeout);
}
else
return 0;
}
void pn_ssl_domain_free( pn_ssl_domain_t *domain )
{
if (--domain->ref_count == 0) {
pn_ssl_session_t *ssn = LL_HEAD( domain, ssn_cache );
while (ssn) {
pn_ssl_session_t *next = ssn->ssn_cache_next;
LL_REMOVE( domain, ssn_cache, ssn );
ssl_session_free( ssn );
ssn = next;
}
if (domain->ctx) SSL_CTX_free(domain->ctx);
if (domain->keyfile_pw) free(domain->keyfile_pw);
if (domain->trusted_CAs) free(domain->trusted_CAs);
free(domain);
}
}
static pn_ssl_session_t *ssn_cache_find( pn_ssl_domain_t *domain, const char *id )
{
pn_timestamp_t now_msec = pn_i_now();
long now_sec = (long)(now_msec / 1000);
pn_ssl_session_t *ssn = LL_HEAD( domain, ssn_cache );
while (ssn) {
long expire = SSL_SESSION_get_time( ssn->session )
+ SSL_SESSION_get_timeout( ssn->session );
if (expire < now_sec) {
pn_ssl_session_t *next = ssn->ssn_cache_next;
LL_REMOVE( domain, ssn_cache, ssn );
ssl_session_free( ssn );
ssn = next;
continue;
}
if (!strcmp(ssn->id, id)) {
break;
}
ssn = ssn->ssn_cache_next;
}
return ssn;
}