static int map_realloc(jk_map_t *m)
{
if(m->size == m->capacity) {
char **names;
void **values;
int capacity = m->capacity + CAPACITY_INC_SIZE;
names = (char **)jk_pool_alloc(&m->p, sizeof(char *) * capacity);
values = (void **)jk_pool_alloc(&m->p, sizeof(void *) * capacity);
if(values && names) {
if (m->capacity && m->names)
memcpy(names, m->names, sizeof(char *) * m->capacity);
if (m->capacity && m->values)
memcpy(values, m->values, sizeof(void *) * m->capacity);
m->names = (const char **)names;
m->values = (const void **)values;
m->capacity = capacity;
return JK_TRUE;
}
}
return JK_FALSE;
}
/* Allocate space for a string given a start pointer and an end pointer
* and return a pointer to the allocated, copied string.
*/
static char *MemDup(private_ws_t *ws, const char *start, const char *end)
{
char *out = NULL;
if (start != NULL && end != NULL && end > start)
{
int len = end - start;
out = jk_pool_alloc(&ws->p, len + 1);
memcpy(out, start, len);
out[len] = '\0';
}
return out;
}
/**
* Replace $(property) in value.
*
*/
char *map_replace_properties(const char *value, jk_map_t *m)
{
char *rc = (char *)value;
char *env_start = rc;
int rec = 0;
while(env_start = strstr(env_start, "$(")) {
char *env_end = strstr(env_start, ")");
if( rec++ > 20 ) return rc;
if(env_end) {
char env_name[LENGTH_OF_LINE + 1] = "";
char *env_value;
*env_end = '\0';
strcpy(env_name, env_start + 2);
*env_end = ')';
env_value = map_get_string(m, env_name, NULL);
if(!env_value) {
env_value=getenv( env_name );
}
if(env_value) {
int offset=0;
char *new_value = jk_pool_alloc(&m->p,
(sizeof(char) * (strlen(rc) + strlen(env_value))));
if(!new_value) {
break;
}
*env_start = '\0';
strcpy(new_value, rc);
strcat(new_value, env_value);
strcat(new_value, env_end + 1);
offset= env_start - rc + strlen( env_value );
rc = new_value;
/* Avoid recursive subst */
env_start = rc + offset;
} else {
env_start = env_end;
}
} else {
break;
}
}
return rc;
}
/* Write bytes to the buffer returning the number of bytes successfully
* written. Can't be called again once poolbuf_read() has been called.
*/
size_t poolbuf_write(poolbuf *pb, const void *buf, size_t size)
{
const char *cbuf = (const char *) buf;
size_t left = size;
if (READ == pb->state)
return 0;
/* first work out what we can write into the current buffer */
if (pb->current != NULL && pb->writePos < pb->current->size)
{
char *chbuf = poolbuf__buf(pb->current) + pb->writePos;
size_t sz = pb->current->size - pb->writePos;
if (sz > left) sz = left;
memcpy(chbuf, cbuf, sz);
pb->writePos += sz;
pb->avail += sz;
cbuf += sz;
left -= sz;
}
/* something left that we couldn't fit in the last chunk */
if (left > 0)
{
poolbuf__chunk *chnk;
size_t sz = size;
if (sz < poolbuf__MINCHUNK)
sz = poolbuf__MINCHUNK;
if (NULL == pb->p || NULL == (chnk = jk_pool_alloc(pb->p, sz + sizeof(poolbuf__chunk))))
return size - left;
chnk->next = NULL;
chnk->size = sz;
if (NULL == pb->head) pb->head = chnk;
if (NULL != pb->current) pb->current->next = chnk;
pb->current = chnk;
memcpy(poolbuf__buf(chnk), cbuf, left);
pb->avail += left;
pb->writePos = left;
}
return size;
}
static const char *GetRegString(HKEY hkey, const char *key)
{
DWORD type = 0;
DWORD sz = 0;
LONG rc;
char *val;
rc = RegQueryValueEx(hkey, key, (LPDWORD) 0, &type, NULL, &sz);
if (rc != ERROR_SUCCESS || type != REG_SZ)
return NULL;
if (val = jk_pool_alloc(&cfgPool, sz), NULL == val)
return NULL;
rc = RegQueryValueEx(hkey, key, (LPDWORD) 0, &type, val, &sz);
if (rc == ERROR_SUCCESS)
return val;
return NULL;
}
static int uri_worker_map_clear(jk_uri_worker_map_t *uw_map,
jk_logger_t *l)
{
uri_worker_record_t *uwr = NULL;
unsigned int i;
unsigned int new_size = 0;
unsigned int new_nosize = 0;
JK_TRACE_ENTER(l);
IND_NEXT(uw_map->maps) =
(uri_worker_record_t **) jk_pool_alloc(&(IND_NEXT(uw_map->p_dyn)),
sizeof(uri_worker_record_t
*) * IND_THIS(uw_map->size));
IND_NEXT(uw_map->capacity) = IND_THIS(uw_map->size);
IND_NEXT(uw_map->size) = 0;
IND_NEXT(uw_map->nosize) = 0;
for (i = 0; i < IND_THIS(uw_map->size); i++) {
uwr = IND_THIS(uw_map->maps)[i];
if (uwr->source_type == SOURCE_TYPE_URIMAP) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"deleting map rule '%s=%s' source '%s'",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
}
else {
IND_NEXT(uw_map->maps)[new_size] = uwr;
new_size++;
if (uwr->match_type & MATCH_TYPE_NO_MATCH)
new_nosize++;
}
}
IND_NEXT(uw_map->size) = new_size;
IND_NEXT(uw_map->nosize) = new_nosize;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int uri_worker_map_realloc(jk_uri_worker_map_t *uw_map)
{
if (IND_NEXT(uw_map->size) == IND_NEXT(uw_map->capacity)) {
uri_worker_record_t **uwr;
int capacity = IND_NEXT(uw_map->capacity) + UW_INC_SIZE;
uwr =
(uri_worker_record_t **) jk_pool_alloc(&IND_NEXT(uw_map->p_dyn),
sizeof(uri_worker_record_t
*) * capacity);
if (!uwr)
return JK_FALSE;
if (IND_NEXT(uw_map->capacity) && IND_NEXT(uw_map->maps))
memcpy(uwr, IND_NEXT(uw_map->maps),
sizeof(uri_worker_record_t *) * IND_NEXT(uw_map->capacity));
IND_NEXT(uw_map->maps) = uwr;
IND_NEXT(uw_map->capacity) = capacity;
}
return JK_TRUE;
}
/* Set up all the necessary jk_* workspace based on the current HTTP request.
*/
static int InitService(private_ws_t *ws, jk_ws_service_t *s)
{
/* This is the only fixed size buffer left. It won't be overflowed
* because the Domino API that reads into the buffer accepts a length
* constraint, and it's unlikely ever to be exhausted because the
* strings being will typically be short, but it's still aesthetically
* troublesome.
*/
char workBuf[16 * 1024];
FilterRequest fr;
char *hdrs, *qp;
int hdrsz;
int errID;
int hdrCount;
int rc /*, dummy*/;
static char *methodName[] = { "", "HEAD", "GET", "POST", "PUT", "DELETE" };
rc = ws->context->GetRequest(ws->context, &fr, &errID);
s->jvm_route = NULL;
s->start_response = StartResponse;
s->read = Read;
s->write = Write;
s->req_uri = jk_pool_strdup(&ws->p, fr.URL);
s->query_string = NULL;
if (qp = strchr(s->req_uri, '?'), qp != NULL)
{
*qp++ = '\0';
if (strlen(qp))
s->query_string = qp;
}
GETVARIABLE("AUTH_TYPE", &s->auth_type, "");
GETVARIABLE("REMOTE_USER", &s->remote_user, "");
GETVARIABLE("SERVER_PROTOCOL", &s->protocol, "");
GETVARIABLE("REMOTE_HOST", &s->remote_host, "");
GETVARIABLE("REMOTE_ADDR", &s->remote_addr, "");
GETVARIABLE("SERVER_NAME", &s->server_name, "");
GETVARIABLEINT("SERVER_PORT", &s->server_port, 80);
GETVARIABLE("SERVER_SOFTWARE", &s->server_software, SERVERDFLT);
GETVARIABLEINT("CONTENT_LENGTH", &s->content_length, 0);
/* SSL Support
*/
GETVARIABLEBOOL("HTTPS", &s->is_ssl, 0);
if (ws->reqData->requestMethod < 0 ||
ws->reqData->requestMethod >= sizeof(methodName) / sizeof(methodName[0]))
return JK_FALSE;
s->method = methodName[ws->reqData->requestMethod];
s->headers_names = NULL;
s->headers_values = NULL;
s->num_headers = 0;
s->ssl_cert_len = fr.clientCertLen;
s->ssl_cert = fr.clientCert;
s->ssl_cipher = NULL; /* required by Servlet 2.3 Api */
s->ssl_session = NULL;
#if defined(JK_VERSION) && JK_VERSION >= MAKEVERSION(1, 2, 0, 1)
s->ssl_key_size = -1; /* required by Servlet 2.3 Api, added in jtc */
#endif
if (s->is_ssl)
{
int dummy;
#if 0
char *sslNames[] =
{
"CERT_ISSUER", "CERT_SUBJECT", "CERT_COOKIE", "CERT_FLAGS", "CERT_SERIALNUMBER",
"HTTPS_SERVER_SUBJECT", "HTTPS_SECRETKEYSIZE", "HTTPS_SERVER_ISSUER", "HTTPS_KEYSIZE"
};
char *sslValues[] =
{
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL
};
unsigned i, varCount = 0;
#endif
DEBUG(("SSL request\n"));
#if defined(JK_VERSION) && JK_VERSION >= MAKEVERSION(1, 2, 0, 1)
/* Read the variable into a dummy variable: we do this for the side effect of
* reading it into workBuf.
*/
GETVARIABLEINT("HTTPS_KEYSIZE", &dummy, 0);
if (workBuf[0] == '[')
s->ssl_key_size = atoi(workBuf+1);
#else
(void) dummy;
#endif
#if 0
for (i = 0; i < sizeof(sslNames)/sizeof(sslNames[0]); i++)
{
GETVARIABLE(sslNames[i], &sslValues[i], NULL);
if (sslValues[i]) varCount++;
}
/* Andy, some SSL vars must be mapped directly in s->ssl_cipher,
* ssl->session and s->ssl_key_size
* ie:
* Cipher could be "RC4-MD5"
* KeySize 128 (bits)
* SessionID a string containing the UniqID used in SSL dialogue
*/
if (varCount > 0)
{
unsigned j;
s->attributes_names = jk_pool_alloc(&ws->p, varCount * sizeof (char *));
s->attributes_values = jk_pool_alloc(&ws->p, varCount * sizeof (char *));
j = 0;
for (i = 0; i < sizeof(sslNames)/sizeof(sslNames[0]); i++)
{
if (sslValues[i])
{
s->attributes_names[j] = sslNames[i];
s->attributes_values[j] = sslValues[i];
j++;
}
}
s->num_attributes = varCount;
}
#endif
}
/* Duplicate all the headers now */
hdrsz = ws->reqData->GetAllHeaders(ws->context, &hdrs, &errID);
DEBUG(("\nGot headers (length %d)\n--------\n%s\n--------\n\n", hdrsz, hdrs));
s->headers_names =
s->headers_values = NULL;
hdrCount = ParseHeaders(ws, hdrs, hdrsz, s);
DEBUG(("Found %d headers\n", hdrCount));
s->num_headers = hdrCount;
s->headers_names = jk_pool_alloc(&ws->p, hdrCount * sizeof(char *));
s->headers_values = jk_pool_alloc(&ws->p, hdrCount * sizeof(char *));
hdrCount = ParseHeaders(ws, hdrs, hdrsz, s);
return JK_TRUE;
}
/* Start the response by sending any headers. Invoked by Tomcat. I don't
* particularly like the fact that this always allocates memory, but
* perhaps jk_pool_alloc() is efficient.
*/
static int JK_METHOD StartResponse(jk_ws_service_t *s, int status, const char *reason,
const char *const *hdrNames,
const char *const *hdrValues, unsigned hdrCount)
{
DEBUG(("StartResponse()\n"));
jk_log(logger, JK_LOG_DEBUG, "Into jk_ws_service_t::StartResponse\n");
if (status < 100 || status > 1000)
{
jk_log(logger, JK_LOG_ERROR, "jk_ws_service_t::StartResponse, invalid status %d\n", status);
return JK_FALSE;
}
if (s && s->ws_private)
{
private_ws_t *p = s->ws_private;
if (!p->responseStarted)
{
char *hdrBuf;
FilterResponseHeaders frh;
int rc, errID;
p->responseStarted = JK_TRUE;
if (NULL == reason)
reason = "";
/* Build a single string containing all the headers
* because that's what Domino needs.
*/
if (hdrCount > 0)
{
unsigned i;
unsigned hdrLen;
char *bufp;
for (i = 0, hdrLen = 3; i < hdrCount; i++)
hdrLen += strlen(hdrNames[i]) + strlen(hdrValues[i]) + 4;
hdrBuf = jk_pool_alloc(&p->p, hdrLen);
bufp = hdrBuf;
for (i = 0; i < hdrCount; i++)
{
Append(&bufp, hdrNames[i]);
Append(&bufp, ": ");
Append(&bufp, hdrValues[i]);
Append(&bufp, crlf);
}
Append(&bufp, crlf);
}
else
{
hdrBuf = crlf;
}
frh.responseCode = status;
frh.reasonText = (char *) reason;
frh.headerText = hdrBuf;
DEBUG(("%d %s\n%s", status, reason, hdrBuf));
/* Send the headers */
rc = p->context->ServerSupport(p->context, kWriteResponseHeaders, &frh, NULL, 0, &errID);
/*
if (rc)
{
jk_log(logger, JK_LOG_ERROR,
"jk_ws_service_t::StartResponse, ServerSupportFunction failed\n");
return JK_FALSE;
}
*/
}
return JK_TRUE;
}
jk_log(logger, JK_LOG_ERROR, "jk_ws_service_t::StartResponse, NULL parameters\n");
return JK_FALSE;
}
int map_read_properties(jk_map_t *m,
const char *f)
{
int rc = JK_FALSE;
if(m && f) {
#ifdef AS400
FILE *fp = fopen(f, "r, o_ccsid=0");
#else
FILE *fp = fopen(f, "r");
#endif
if(fp) {
char buf[LENGTH_OF_LINE + 1];
char *prp;
rc = JK_TRUE;
while(NULL != (prp = fgets(buf, LENGTH_OF_LINE, fp))) {
trim_prp_comment(prp);
if(trim(prp)) {
char *v = strchr(prp, '=');
if(v) {
*v = '\0';
v++;
if(strlen(v) && strlen(prp)) {
char *oldv = map_get_string(m, prp, NULL);
v = map_replace_properties(v, m);
if(oldv) {
char *tmpv = jk_pool_alloc(&m->p,
strlen(v) + strlen(oldv) + 3);
if(tmpv) {
char sep = '*';
if(jk_is_path_poperty(prp)) {
sep = PATH_SEPERATOR;
} else if(jk_is_cmd_line_poperty(prp)) {
sep = ' ';
}
sprintf(tmpv, "%s%c%s",
oldv, sep, v);
}
v = tmpv;
} else {
v = jk_pool_strdup(&m->p, v);
}
if(v) {
void *old = NULL;
map_put(m, prp, v, &old);
} else {
rc = JK_FALSE;
break;
}
}
}
}
}
fclose(fp);
}
}
return rc;
}
/* Parse rule extensions */
void parse_rule_extensions(char *rule, rule_extension_t *extensions,
jk_logger_t *l)
{
char *param;
#ifdef _MT_CODE_PTHREAD
char *lasts = NULL;
#endif
extensions->reply_timeout = -1;
extensions->sticky_ignore = JK_FALSE;
extensions->stateless = JK_FALSE;
extensions->active = NULL;
extensions->disabled = NULL;
extensions->stopped = NULL;
extensions->activation_size = 0;
extensions->activation = NULL;
extensions->fail_on_status_size = 0;
extensions->fail_on_status = NULL;
extensions->fail_on_status_str = NULL;
extensions->use_server_error_pages = 0;
extensions->session_cookie = NULL;
extensions->session_path = NULL;
extensions->set_session_cookie = JK_FALSE;
extensions->session_cookie_path = NULL;
#ifdef _MT_CODE_PTHREAD
param = strtok_r(rule, ";", &lasts);
#else
param = strtok(rule, ";");
#endif
if (param) {
#ifdef _MT_CODE_PTHREAD
for (param = strtok_r(NULL, ";", &lasts); param; param = strtok_r(NULL, ";", &lasts)) {
#else
for (param = strtok(NULL, ";"); param; param = strtok(NULL, ";")) {
#endif
if (!strncmp(param, JK_UWMAP_EXTENSION_REPLY_TIMEOUT, strlen(JK_UWMAP_EXTENSION_REPLY_TIMEOUT))) {
extensions->reply_timeout = atoi(param + strlen(JK_UWMAP_EXTENSION_REPLY_TIMEOUT));
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_STICKY_IGNORE, strlen(JK_UWMAP_EXTENSION_STICKY_IGNORE))) {
int val = atoi(param + strlen(JK_UWMAP_EXTENSION_STICKY_IGNORE));
if (val) {
extensions->sticky_ignore = JK_TRUE;
}
else {
extensions->sticky_ignore = JK_FALSE;
}
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_STATELESS, strlen(JK_UWMAP_EXTENSION_STATELESS))) {
int val = atoi(param + strlen(JK_UWMAP_EXTENSION_STATELESS));
if (val) {
extensions->stateless = JK_TRUE;
}
else {
extensions->stateless = JK_FALSE;
}
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_USE_SRV_ERRORS, strlen(JK_UWMAP_EXTENSION_USE_SRV_ERRORS))) {
extensions->use_server_error_pages = atoi(param + strlen(JK_UWMAP_EXTENSION_USE_SRV_ERRORS));
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_ACTIVE, strlen(JK_UWMAP_EXTENSION_ACTIVE))) {
if (extensions->active)
jk_log(l, JK_LOG_WARNING,
"rule extension '" JK_UWMAP_EXTENSION_ACTIVE "' only allowed once");
else
extensions->active = param + strlen(JK_UWMAP_EXTENSION_ACTIVE);
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_DISABLED, strlen(JK_UWMAP_EXTENSION_DISABLED))) {
if (extensions->disabled)
jk_log(l, JK_LOG_WARNING,
"rule extension '" JK_UWMAP_EXTENSION_DISABLED "' only allowed once");
else
extensions->disabled = param + strlen(JK_UWMAP_EXTENSION_DISABLED);
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_STOPPED, strlen(JK_UWMAP_EXTENSION_STOPPED))) {
if (extensions->stopped)
jk_log(l, JK_LOG_WARNING,
"rule extension '" JK_UWMAP_EXTENSION_STOPPED "' only allowed once");
else
extensions->stopped = param + strlen(JK_UWMAP_EXTENSION_STOPPED);
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_FAIL_ON_STATUS, strlen(JK_UWMAP_EXTENSION_FAIL_ON_STATUS))) {
if (extensions->fail_on_status_str)
jk_log(l, JK_LOG_WARNING,
"rule extension '" JK_UWMAP_EXTENSION_FAIL_ON_STATUS "' only allowed once");
else
extensions->fail_on_status_str = param + strlen(JK_UWMAP_EXTENSION_FAIL_ON_STATUS);
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_SESSION_COOKIE, strlen(JK_UWMAP_EXTENSION_SESSION_COOKIE))) {
if (extensions->session_cookie)
jk_log(l, JK_LOG_WARNING,
"extension '" JK_UWMAP_EXTENSION_SESSION_COOKIE "' in uri worker map only allowed once");
else
extensions->session_cookie = param + strlen(JK_UWMAP_EXTENSION_SESSION_COOKIE);
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_SESSION_PATH, strlen(JK_UWMAP_EXTENSION_SESSION_PATH))) {
if (extensions->session_path)
jk_log(l, JK_LOG_WARNING,
"extension '" JK_UWMAP_EXTENSION_SESSION_PATH "' in uri worker map only allowed once");
else {
// Check if the session identifier starts with semicolon.
if (!strcmp(param, JK_UWMAP_EXTENSION_SESSION_PATH)) {
#ifdef _MT_CODE_PTHREAD
param = strtok_r(NULL, ";", &lasts);
#else
param = strtok(NULL, ";");
#endif
extensions->session_path = param;
} else
extensions->session_path = param + strlen(JK_UWMAP_EXTENSION_SESSION_PATH);
}
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_SET_SESSION_COOKIE, strlen(JK_UWMAP_EXTENSION_SET_SESSION_COOKIE))) {
if (extensions->set_session_cookie)
jk_log(l, JK_LOG_WARNING,
"extension '" JK_UWMAP_EXTENSION_SET_SESSION_COOKIE "' in uri worker map only allowed once");
else {
int val = atoi(param + strlen(JK_UWMAP_EXTENSION_SET_SESSION_COOKIE));
if (val) {
extensions->set_session_cookie = JK_TRUE;
}
else {
extensions->set_session_cookie = JK_FALSE;
}
}
}
else if (!strncmp(param, JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH, strlen(JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH))) {
if (extensions->session_cookie_path)
jk_log(l, JK_LOG_WARNING,
"extension '" JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH "' in uri worker map only allowed once");
else
extensions->session_cookie_path = param + strlen(JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH);
}
else {
jk_log(l, JK_LOG_WARNING,
"unknown rule extension '%s'",
param);
}
}
}
}
/* Add new entry to NEXT generation */
int uri_worker_map_add(jk_uri_worker_map_t *uw_map,
const char *puri, const char *worker,
unsigned int source_type, jk_logger_t *l)
{
uri_worker_record_t *uwr = NULL;
char *uri;
jk_pool_t *p;
unsigned int match_type = 0;
JK_TRACE_ENTER(l);
if (*puri == '-') {
/* Disable urimap.
* This way you can disable already mounted
* context.
*/
match_type = MATCH_TYPE_DISABLED;
puri++;
}
if (*puri == '!') {
match_type |= MATCH_TYPE_NO_MATCH;
puri++;
}
if (uri_worker_map_realloc(uw_map) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (source_type == SOURCE_TYPE_URIMAP)
p = &IND_NEXT(uw_map->p_dyn);
else
p = &uw_map->p;
uwr = (uri_worker_record_t *)jk_pool_alloc(p, sizeof(uri_worker_record_t));
if (!uwr) {
jk_log(l, JK_LOG_ERROR,
"can't alloc map entry");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
uri = jk_pool_strdup(p, puri);
if (!uri || !worker) {
jk_log(l, JK_LOG_ERROR,
"can't alloc uri/worker strings");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (*uri == '/') {
char *w = jk_pool_strdup(p, worker);
parse_rule_extensions(w, &uwr->extensions, l);
uwr->source_type = source_type;
uwr->worker_name = w;
uwr->uri = uri;
uwr->context = uri;
uwr->context_len = strlen(uwr->context);
if (strchr(uri, '*') ||
strchr(uri, '?')) {
/* Something like
* /context/ * /user/ *
* /context/ *.suffix
*/
match_type |= MATCH_TYPE_WILDCHAR_PATH;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"wildchar rule '%s=%s' source '%s' was added",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
}
else {
/* Something like: JkMount /login/j_security_check ajp13 */
match_type |= MATCH_TYPE_EXACT;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"exact rule '%s=%s' source '%s' was added",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
}
}
else {
/*
* JFC: please check...
* Not sure what to do, but I try to prevent problems.
* I have fixed jk_mount_context() in apaches/mod_jk.c so we should
* not arrive here when using Apache.
*/
jk_log(l, JK_LOG_ERROR,
"invalid context '%s': does not begin with '/'",
uri);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
uwr->match_type = match_type;
IND_NEXT(uw_map->maps)[IND_NEXT(uw_map->size)] = uwr;
IND_NEXT(uw_map->size)++;
if (match_type & MATCH_TYPE_NO_MATCH) {
/* If we split the mappings this one will be calculated */
IND_NEXT(uw_map->nosize)++;
}
worker_qsort(uw_map);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static void extract_activation(jk_pool_t *p,
lb_worker_t *lb,
int *activations,
char *workers,
int activation,
jk_logger_t *l)
{
unsigned int i;
char *worker;
#ifdef _MT_CODE_PTHREAD
char *lasts;
#endif
JK_TRACE_ENTER(l);
worker = jk_pool_strdup(p, workers);
#ifdef _MT_CODE_PTHREAD
for (worker = strtok_r(worker, ", ", &lasts);
worker; worker = strtok_r(NULL, ", ", &lasts)) {
#else
for (worker = strtok(worker, ", "); worker; worker = strtok(NULL, ", ")) {
#endif
for (i = 0; i < lb->num_of_workers; i++) {
if (!strcmp(worker, lb->lb_workers[i].name)) {
if (activations[i] != JK_LB_ACTIVATION_UNSET)
jk_log(l, JK_LOG_WARNING,
"inconsistent activation overwrite for member %s "
"of load balancer %s: '%s' replaced by '%s'",
worker, lb->name,
jk_lb_get_activation_direct(activations[i], l),
jk_lb_get_activation_direct(activation, l));
activations[i] = activation;
break;
}
}
if (i >= lb->num_of_workers)
jk_log(l, JK_LOG_WARNING,
"could not find member %s of load balancer %s",
worker, lb->name);
}
JK_TRACE_EXIT(l);
}
static void extension_fix_fail_on_status(jk_pool_t *p,
const char *name,
rule_extension_t *extensions,
jk_logger_t *l)
{
unsigned int i;
int j;
int cnt = 1;
char *status;
#ifdef _MT_CODE_PTHREAD
char *lasts;
#endif
JK_TRACE_ENTER(l);
for (i = 0; i < (unsigned int)strlen(extensions->fail_on_status_str); i++) {
if (extensions->fail_on_status_str[i] == ',' ||
extensions->fail_on_status_str[i] == ' ')
cnt++;
}
extensions->fail_on_status_size = cnt;
status = jk_pool_strdup(p, extensions->fail_on_status_str);
extensions->fail_on_status = (int *)jk_pool_alloc(p,
extensions->fail_on_status_size * sizeof(int));
if (!extensions->fail_on_status) {
jk_log(l, JK_LOG_ERROR,
"can't alloc extensions fail_on_status list for worker (%s)",
name);
JK_TRACE_EXIT(l);
return;
} else if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Allocated fail_on_status array of size %d for worker (%s)",
extensions->fail_on_status_size, name);
for (j=0; j<extensions->fail_on_status_size; j++) {
extensions->fail_on_status[j] = 0;
}
cnt = 0;
#ifdef _MT_CODE_PTHREAD
for (status = strtok_r(status, ", ", &lasts);
status; status = strtok_r(NULL, ", ", &lasts)) {
#else
for (status = strtok(status, ", "); status; status = strtok(NULL, ", ")) {
#endif
extensions->fail_on_status[cnt] = atoi(status);
cnt++;
}
JK_TRACE_EXIT(l);
}
static int extension_fix_activation(jk_pool_t *p, const char *name, jk_worker_t *jw,
rule_extension_t *extensions, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Checking extension for worker %s of type %s (%d)",
name, wc_get_name_for_type(jw->type,l), jw->type);
if (jw->type == JK_LB_WORKER_TYPE &&
(extensions->active || extensions->disabled || extensions->stopped)) {
int j;
lb_worker_t *lb = (lb_worker_t *)jw->worker_private;
if (!extensions->activation) {
extensions->activation_size = lb->num_of_workers;
extensions->activation = (int *)jk_pool_alloc(p,
extensions->activation_size * sizeof(int));
if (!extensions->activation) {
jk_log(l, JK_LOG_ERROR,
"can't alloc extensions activation list");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
else if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Allocated activations array of size %d for lb worker %s",
extensions->activation_size, name);
for (j=0; j<extensions->activation_size; j++) {
extensions->activation[j] = JK_LB_ACTIVATION_UNSET;
}
}
if (extensions->active)
extract_activation(p, lb, extensions->activation,
extensions->active, JK_LB_ACTIVATION_ACTIVE, l);
if (extensions->disabled)
extract_activation(p, lb, extensions->activation,
extensions->disabled, JK_LB_ACTIVATION_DISABLED, l);
if (extensions->stopped)
extract_activation(p, lb, extensions->activation,
extensions->stopped, JK_LB_ACTIVATION_STOPPED, l);
}
else if (extensions->active) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, activation extension "
JK_UWMAP_EXTENSION_ACTIVE " for %s ignored",
name, extensions->active);
}
else if (extensions->disabled) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, activation extension "
JK_UWMAP_EXTENSION_DISABLED " for %s ignored",
name, extensions->disabled);
}
else if (extensions->stopped) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, activation extension "
JK_UWMAP_EXTENSION_STOPPED " for %s ignored",
name, extensions->stopped);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
