int
storeUnregister(StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
store_client *sc;
store_client **S;
STCB *callback;
if (mem == NULL)
return 0;
debug(20, 3) ("storeUnregister: called for '%s'\n", storeKeyText(e->key));
for (S = &mem->clients; (sc = *S) != NULL; S = &(*S)->next) {
if (sc->callback_data == data)
break;
}
if (sc == NULL)
return 0;
if (sc == mem->clients) {
/*
* If we are unregistering the _first_ client for this
* entry, then we have to reset the client FD to -1.
*/
mem->fd = -1;
}
*S = sc->next;
mem->nclients--;
sc->flags.disk_io_pending = 0;
if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
storeSwapOut(e);
if (sc->swapin_sio) {
storeClose(sc->swapin_sio);
sc->swapin_sio = NULL;
}
if ((callback = sc->callback) != NULL) {
/* callback with ssize = -1 to indicate unexpected termination */
debug(20, 3) ("storeUnregister: store_client for %s has a callback\n",
mem->url);
sc->callback = NULL;
if (cbdataValid(sc->callback_data))
callback(sc->callback_data, sc->copy_buf, -1);
}
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sc->delay_id);
#endif
cbdataUnlock(sc->callback_data); /* we're done with it now */
cbdataFree(sc);
assert(e->lock_count > 0);
if (mem->nclients == 0)
CheckQuickAbort(e);
return 1;
}
static void
sslPeerSelectComplete(FwdServer * fs, void *data)
{
SslStateData *sslState = data;
request_t *request = sslState->request;
peer *g = NULL;
if (fs == NULL) {
ErrorState *err;
err = errorCon(ERR_CANNOT_FORWARD, HTTP_SERVICE_UNAVAILABLE);
err->request = requestLink(sslState->request);
err->callback = sslErrorComplete;
err->callback_data = sslState;
errorSend(sslState->client.fd, err);
return;
}
sslState->servers = fs;
sslState->host = fs->peer ? fs->peer->host : request->host;
if (fs->peer == NULL) {
sslState->port = request->port;
} else if (fs->peer->http_port != 0) {
sslState->port = fs->peer->http_port;
} else if ((g = peerFindByName(fs->peer->host))) {
sslState->port = g->http_port;
} else {
sslState->port = CACHE_HTTP_PORT;
}
if (fs->peer) {
sslState->request->peer_login = fs->peer->login;
sslState->request->flags.proxying = 1;
} else {
sslState->request->flags.proxying = 0;
}
#if DELAY_POOLS
/* no point using the delayIsNoDelay stuff since ssl is nice and simple */
if (g && g->options.no_delay && sslState->delay_id) {
delayUnregisterDelayIdPtr(&sslState->delay_id);
sslState->delay_id = 0;
}
#endif
hierarchyNote(&sslState->request->hier,
fs->peer ? fs->code : DIRECT,
sslState->host);
commConnectStart(sslState->server.fd,
sslState->host,
sslState->port,
sslConnectDone,
sslState);
}
static void
sslStateFree(SslStateData * sslState)
{
debug(26, 3) ("sslStateFree: sslState=%p\n", sslState);
assert(sslState != NULL);
assert(sslState->client.fd == -1);
assert(sslState->server.fd == -1);
safe_free(sslState->server.buf);
safe_free(sslState->client.buf);
safe_free(sslState->url);
fwdServersFree(&sslState->servers);
sslState->host = NULL;
requestUnlink(sslState->request);
sslState->request = NULL;
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sslState->delay_id);
#endif
cbdataFree(sslState);
}
/*
* This routine hasn't been optimised to take advantage of the
* passed sc. Yet.
*/
int
storeUnregister(store_client * sc, StoreEntry * e, void *data)
{
MemObject *mem = e->mem_obj;
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, data));
#endif
if (mem == NULL)
return 0;
debug(20, 3) ("storeUnregister: called for '%s'\n", storeKeyText(e->hash.key));
if (sc == NULL)
return 0;
if (mem->clients.head == NULL)
return 0;
dlinkDelete(&sc->node, &mem->clients);
mem->nclients--;
if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
storeSwapOut(e);
if (sc->swapin_sio) {
storeClose(sc->swapin_sio);
cbdataUnlock(sc->swapin_sio);
sc->swapin_sio = NULL;
statCounter.swap.ins++;
}
if (NULL != sc->callback) {
/* callback with ssize = -1 to indicate unexpected termination */
debug(20, 3) ("storeUnregister: store_client for %s has a callback\n",
mem->url);
storeClientCallback(sc, -1);
}
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sc->delay_id);
#endif
cbdataUnlock(sc->callback_data); /* we're done with it now */
/*assert(!sc->flags.disk_io_pending); */
cbdataFree(sc);
assert(e->lock_count > 0);
storeSwapOutMaintainMemObject(e);
if (mem->nclients == 0)
CheckQuickAbort(e);
return 1;
}
/*
* This routine hasn't been optimised to take advantage of the
* passed sc. Yet.
*/
int
storeClientUnregister(store_client * sc, StoreEntry * e, void *owner)
{
MemObject *mem = e->mem_obj;
if (sc == NULL)
return 0;
debug(20, 3) ("storeClientUnregister: called for '%s'\n", storeKeyText(e->hash.key));
#if STORE_CLIENT_LIST_DEBUG
assert(sc == storeClientListSearch(e->mem_obj, owner));
#endif
assert(sc->entry == e);
if (mem->clients.head == NULL)
return 0;
dlinkDelete(&sc->node, &mem->clients);
mem->nclients--;
if (e->store_status == STORE_OK && e->swap_status != SWAPOUT_DONE)
storeSwapOut(e);
if (sc->swapin_sio) {
storeClose(sc->swapin_sio);
cbdataUnlock(sc->swapin_sio);
sc->swapin_sio = NULL;
statCounter.swap.ins++;
}
if (NULL != sc->new_callback) {
/* callback with ssize = -1 to indicate unexpected termination */
debug(20, 3) ("storeClientUnregister: store_client for %s has a callback\n",
mem->url);
storeClientCallback(sc, -1);
}
stmemNodeUnref(&sc->node_ref);
#if DELAY_POOLS
delayUnregisterDelayIdPtr(&sc->delay_id);
#endif
storeSwapOutMaintainMemObject(e);
if (mem->nclients == 0)
CheckQuickAbort(e);
storeUnlockObject(sc->entry);
sc->entry = NULL;
cbdataFree(sc);
return 1;
}