static void
ConnRun(Conn *connPtr)
{
Tcl_Encoding encoding = NULL;
Ns_Conn *conn = (Ns_Conn *) connPtr;
NsServer *servPtr = connPtr->servPtr;
int i, status;
/*
* Initialize the connection encodings.
*/
encoding = NsGetInputEncoding(connPtr);
if (encoding == NULL) {
encoding = NsGetOutputEncoding(connPtr);
if (encoding == NULL) {
encoding = connPtr->servPtr->urlEncoding;
}
}
Ns_ConnSetUrlEncoding((Ns_Conn *) connPtr, encoding);
if (connPtr->servPtr->opts.hdrcase != Preserve) {
for (i = 0; i < Ns_SetSize(connPtr->headers); ++i) {
if (connPtr->servPtr->opts.hdrcase == ToLower) {
Ns_StrToLower(Ns_SetKey(connPtr->headers, i));
} else {
Ns_StrToUpper(Ns_SetKey(connPtr->headers, i));
}
}
}
/*
* Run the request.
*/
if (connPtr->request->protocol != NULL && connPtr->request->host != NULL) {
status = NsConnRunProxyRequest((Ns_Conn *) connPtr);
} else {
status = NsRunFilters(conn, NS_FILTER_PRE_AUTH);
if (status == NS_OK) {
status = Ns_AuthorizeRequest(servPtr->server,
connPtr->request->method, connPtr->request->url,
connPtr->authUser, connPtr->authPasswd, connPtr->peer);
switch (status) {
case NS_OK:
status = NsRunFilters(conn, NS_FILTER_POST_AUTH);
if (status == NS_OK) {
status = Ns_ConnRunRequest(conn);
}
break;
case NS_FORBIDDEN:
Ns_ConnReturnForbidden(conn);
break;
case NS_UNAUTHORIZED:
Ns_ConnReturnUnauthorized(conn);
break;
case NS_ERROR:
default:
Ns_ConnReturnInternalError(conn);
break;
}
} else if (status != NS_FILTER_RETURN) {
/* if not ok or filter_return, then the pre-auth filter coughed
* an error. We are not going to proceed, but also we
* can't count on the filter to have sent a response
* back to the client. So, send an error response.
*/
Ns_ConnReturnInternalError(conn);
status = NS_FILTER_RETURN; /* to allow tracing to happen */
}
}
Ns_ConnClose(conn);
if (status == NS_OK || status == NS_FILTER_RETURN) {
status = NsRunFilters(conn, NS_FILTER_TRACE);
if (status == NS_OK) {
(void) NsRunFilters(conn, NS_FILTER_VOID_TRACE);
NsRunTraces(conn);
}
}
/*
* Cleanup the connections, calling any registered cleanup traces
* followed by free the connection interp if it was used.
*/
NsRunCleanups(conn);
NsFreeConnInterp(connPtr);
}
/** Main service method, called to forward a request to tomcat
*/
static int jk2_handler(void* context, Ns_Conn *conn)
{
jk_logger_t *l=NULL;
int rc;
jk_worker_t *worker=NULL;
jk_endpoint_t *end = NULL;
jk_env_t *env;
char* workerName;
jk_ws_service_t *s=NULL;
jk_pool_t *rPool=NULL;
int rc1;
jk_uriEnv_t *uriEnv;
uriContext* uriCtx = (uriContext*)context;
/* must make this call to assure TLS destructor runs when thread exists */
Ns_TlsSet (&jkTls, jvmGlobal);
uriEnv= uriCtx->uriEnv;
/* there is a chance of dynamic reconfiguration, so instead of doing above statement, might map
the URI to its context object on the fly, like this:
uriEnv = workerEnv->uriMap->mapUri (workerEnv->globalEnv, workerEnv->uriMap, conn->request->host, conn->request->url);
*/
/* Get an env instance */
env = workerEnv->globalEnv->getEnv( workerEnv->globalEnv );
worker = uriEnv->worker;
if (worker == NULL) /* use global default */
worker=workerEnv->defaultWorker;
workerName = uriEnv->mbean->getAttribute (env, uriEnv->mbean, "group");
if( worker==NULL && workerName!=NULL ) {
worker=env->getByName( env, workerName);
env->l->jkLog(env, env->l, JK_LOG_INFO,
"finding worker for %#lx %#lx %s\n",
worker, uriEnv, workerName);
uriEnv->worker=worker;
}
if(worker==NULL || worker->mbean==NULL || worker->mbean->localName==NULL ) {
env->l->jkLog(env, env->l, JK_LOG_ERROR,
"No worker for %s\n", conn->request->url);
workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
return NS_FILTER_RETURN;
}
if( uriEnv->mbean->debug > 0 )
env->l->jkLog(env, env->l, JK_LOG_DEBUG,
"serving %s with %#lx %#lx %s\n",
uriEnv->mbean->localName, worker, worker->mbean, worker->mbean->localName );
/* Get a pool for the request */
rPool= worker->rPoolCache->get( env, worker->rPoolCache );
if( rPool == NULL ) {
rPool=worker->mbean->pool->create( env, worker->mbean->pool, HUGE_POOL_SIZE );
if( uriEnv->mbean->debug > 0 )
env->l->jkLog(env, env->l, JK_LOG_DEBUG, "new rpool %#lx\n", rPool );
}
s=(jk_ws_service_t *)rPool->calloc( env, rPool, sizeof( jk_ws_service_t ));
jk2_service_ns_init( env, s, uriCtx->serverName);
s->pool = rPool;
s->init( env, s, worker, conn );
s->is_recoverable_error = JK_FALSE;
s->uriEnv = uriEnv;
rc = worker->service(env, worker, s);
s->afterRequest(env, s);
rPool->reset(env, rPool);
rc1=worker->rPoolCache->put( env, worker->rPoolCache, rPool );
if( rc1 == JK_OK ) {
rPool=NULL;
}
if( rPool!=NULL ) {
rPool->close(env, rPool);
}
if(rc==JK_OK) {
workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
return NS_OK;
}
env->l->jkLog(env, env->l, JK_LOG_ERROR, "Error connecting to tomcat %d\n", rc);
workerEnv->globalEnv->releaseEnv( workerEnv->globalEnv, env );
Ns_ConnReturnInternalError (conn);
return NS_FILTER_RETURN;
}
