void pni_entry_free(pni_entry_t *entry)
{
if (!entry) return;
pni_stream_t *stream = entry->stream;
pni_store_t *store = stream->store;
LL_REMOVE(stream, stream, entry);
LL_REMOVE(store, store, entry);
entry->free = true;
pn_buffer_free(entry->bytes);
entry->bytes = NULL;
pn_decref(entry);
store->size--;
}
static void *worker_function(void *ptr) {
worker_t *worker = (worker_t *)ptr;
job_t *job;
while (1) {
/* Wait until we get notified. */
pthread_mutex_lock(&worker->workqueue->jobs_mutex);
while (worker->workqueue->waiting_jobs == NULL) {
pthread_cond_wait(&worker->workqueue->jobs_cond,
&worker->workqueue->jobs_mutex);
}
job = worker->workqueue->waiting_jobs;
if (job != NULL) {
LL_REMOVE(job, worker->workqueue->waiting_jobs);
}
pthread_mutex_unlock(&worker->workqueue->jobs_mutex);
/* If we're supposed to terminate, break out of our continuous loop. */
if (worker->terminate) break;
/* If we didn't get a job, then there's nothing to do at this time. */
if (job == NULL) continue;
/* Execute the job. */
job->job_function(job);
}
free(worker);
pthread_exit(NULL);
}
static int init_ssl_socket( pn_ssl_t *ssl )
{
if (ssl->ssl) return 0;
if (!ssl->domain) return -1;
ssl->ssl = SSL_new(ssl->domain->ctx);
if (!ssl->ssl) {
_log_error( "SSL socket setup failure.\n" );
return -1;
}
// store backpointer to pn_ssl_t in SSL object:
SSL_set_ex_data(ssl->ssl, ssl_ex_data_index, ssl);
#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
if (ssl->peer_hostname && ssl->domain->mode == PN_SSL_MODE_CLIENT) {
SSL_set_tlsext_host_name(ssl->ssl, ssl->peer_hostname);
}
#endif
// restore session, if available
if (ssl->session_id) {
pn_ssl_session_t *ssn = ssn_cache_find( ssl->domain, ssl->session_id );
if (ssn) {
_log( ssl, "Restoring previous session id=%s\n", ssn->id );
int rc = SSL_set_session( ssl->ssl, ssn->session );
if (rc != 1) {
_log( ssl, "Session restore failed, id=%s\n", ssn->id );
}
LL_REMOVE( ssl->domain, ssn_cache, ssn );
ssl_session_free( ssn );
}
}
// now layer a BIO over the SSL socket
ssl->bio_ssl = BIO_new(BIO_f_ssl());
if (!ssl->bio_ssl) {
_log_error( "BIO setup failure.\n" );
return -1;
}
(void)BIO_set_ssl(ssl->bio_ssl, ssl->ssl, BIO_NOCLOSE);
// create the "lower" BIO "pipe", and attach it below the SSL layer
if (!BIO_new_bio_pair(&ssl->bio_ssl_io, 0, &ssl->bio_net_io, 0)) {
_log_error( "BIO setup failure.\n" );
return -1;
}
SSL_set_bio(ssl->ssl, ssl->bio_ssl_io, ssl->bio_ssl_io);
if (ssl->domain->mode == PN_SSL_MODE_SERVER) {
SSL_set_accept_state(ssl->ssl);
BIO_set_ssl_mode(ssl->bio_ssl, 0); // server mode
_log( ssl, "Server SSL socket created.\n" );
} else { // client mode
SSL_set_connect_state(ssl->ssl);
BIO_set_ssl_mode(ssl->bio_ssl, 1); // client mode
_log( ssl, "Client SSL socket created.\n" );
}
return 0;
}
int
db_change_parent(Objid oid, Objid parent)
{
Objid old_parent;
if (!dbpriv_check_properties_for_chparent(oid, parent))
return 0;
if (objects[oid]->child == NOTHING && objects[oid]->verbdefs == NULL) {
/* Since this object has no children and no verbs, we know that it
can't have had any part in affecting verb lookup, since we use first
parent with verbs as a key in the verb lookup cache. */
/* The "no kids" rule is necessary because potentially one of the kids
could have verbs on it--and that kid could have cache entries for
THIS object's parentage. */
/* In any case, don't clear the cache. */
;
} else {
db_priv_affected_callable_verb_lookup();
}
old_parent = objects[oid]->parent;
if (old_parent != NOTHING)
LL_REMOVE(old_parent, child, oid, sibling);
if (parent != NOTHING)
LL_APPEND(parent, child, oid, sibling);
objects[oid]->parent = parent;
dbpriv_fix_properties_after_chparent(oid, old_parent);
return 1;
}
static void deadlines_remove(pn_selector_t *selector, iocpdesc_t *iocpd)
{
if (!iocpd->deadlines_prev && selector->deadlines_head != iocpd)
return; // not in list
LL_REMOVE(selector, deadlines, iocpd);
iocpd->deadlines_prev = NULL;
iocpd->deadlines_next = NULL;
}
static void triggered_list_remove(pn_selector_t *selector, iocpdesc_t *iocpd)
{
if (!iocpd->triggered_list_prev && selector->triggered_list_head != iocpd)
return; // not in list
LL_REMOVE(selector, triggered_list, iocpd);
iocpd->triggered_list_prev = NULL;
iocpd->triggered_list_next = NULL;
}
void
db_change_location(Objid oid, Objid location)
{
Objid old_location = objects[oid]->location;
if (valid(old_location))
LL_REMOVE(old_location, contents, oid, next);
if (valid(location))
LL_APPEND(location, contents, oid, next);
objects[oid]->location = location;
}
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;
}
