/* Get the value of a server (CGI) variable as a string */ static int GetVariable(private_ws_t *ws, char *hdrName, char *buf, DWORD bufsz, char **dest, const char *dflt) { int errID; if (ws->context->GetServerVariable(ws->context, hdrName, buf, bufsz, &errID)) *dest = jk_pool_strdup(&ws->p, buf); else *dest = jk_pool_strdup(&ws->p, dflt); DEBUG(("%s = %s\n", hdrName, *dest)); return JK_TRUE; }
int map_put(jk_map_t *m, const char *name, const void *value, void **old) { int rc = JK_FALSE; if(m && name && old) { unsigned i; for(i = 0 ; i < m->size ; i++) { if(0 == strcmp(m->names[i], name)) { break; } } if(i < m->size) { *old = (void *) m->values[i]; /* DIRTY */ m->values[i] = value; rc = JK_TRUE; } else { map_realloc(m); if(m->size < m->capacity) { m->values[m->size] = value; m->names[m->size] = jk_pool_strdup(&m->p, name); m->size ++; rc = JK_TRUE; } } } return rc; }
/* Handle an HTTP request. Works out whether Tomcat will be interested then either * despatches it to Tomcat or passes it back to Domino. */ static unsigned int ParsedRequest(FilterContext *context, FilterParsedRequest *reqData) { unsigned int errID; int rc; FilterRequest fr; int result = kFilterNotHandled; DEBUG(("\nParsedRequest starting\n")); rc = context->GetRequest(context, &fr, &errID); if (fr.URL && strlen(fr.URL)) { char *uri = fr.URL; char *workerName, *qp, *turi; if (!initDone) { /* One time initialisation which is deferred so that we have the name of * the server software to plug into worker_env */ int ok = JK_FALSE; jk_map_t *map = NULL; DEBUG(("Initialising worker map\n")); if (map_alloc(&map)) { if (map_read_properties(map, workerMountFile)) if (uri_worker_map_alloc(&uw_map, map, logger)) ok = JK_TRUE; map_free(&map); } DEBUG(("Got the URI worker map\n")); if (ok) { ok = JK_FALSE; DEBUG(("About to allocate map\n")); if (map_alloc(&map)) { DEBUG(("About to read %s\n", workerFile)); if (map_read_properties(map, workerFile)) { #if defined(JK_VERSION) && JK_VERSION >= MAKEVERSION(1, 2, 0, 1) char server[256]; worker_env.uri_to_worker = uw_map; if (context->GetServerVariable(context, "SERVER_SOFTWARE", server, sizeof(server)-1, &errID)) worker_env.server_name = jk_pool_strdup(&cfgPool, server); else worker_env.server_name = SERVERDFLT; DEBUG(("Server name %s\n", worker_env.server_name)); if (wc_open(map, &worker_env, logger)) ok = JK_TRUE; #else if (wc_open(map, logger)) ok = JK_TRUE; #endif DEBUG(("OK = %d\n", ok)); } DEBUG(("Read %s, OK = %d\n", workerFile, ok)); map_free(&map); } } if (!ok) return kFilterError; initDone = JK_TRUE; } turi = strdup(uri); if (qp = strchr(turi, '?'), tqp != NULL) *qp = '\0'; workerName = map_uri_to_worker(uw_map, turi, logger); free(turi); DEBUG(("Worker for this URL is %s\n", workerName)); if (NULL != workerName) { private_ws_t ws; jk_ws_service_t s; jk_pool_atom_t buf[SMALL_POOL_SIZE]; if (BadURI(uri)) return RejectBadURI(context); /* Go dispatch the call */ jk_init_ws_service(&s); jk_open_pool(&ws.p, buf, sizeof (buf)); ws.responseStarted = JK_FALSE; ws.context = context; ws.reqData = reqData; ws.reqSize = context->GetRequestContents(context, &ws.reqBuffer, &errID); s.ws_private = &ws; s.pool = &ws.p; if (InitService(&ws, &s)) { jk_worker_t *worker = wc_get_worker_for_name(workerName, logger); jk_log(logger, JK_LOG_DEBUG, "HttpExtensionProc %s a worker for name %s\n", worker ? "got" : "could not get", workerName); if (worker) { jk_endpoint_t *e = NULL; if (worker->get_endpoint(worker, &e, logger)) { int recover = JK_FALSE; if (e->service(e, &s, logger, &recover)) { result = kFilterHandledRequest; jk_log(logger, JK_LOG_DEBUG, "HttpExtensionProc service() returned OK\n"); DEBUG(("HttpExtensionProc service() returned OK\n")); } else { result = kFilterError; jk_log(logger, JK_LOG_ERROR, "HttpExtensionProc error, service() failed\n"); DEBUG(("HttpExtensionProc error, service() failed\n")); } e->done(&e, logger); } } else { jk_log(logger, JK_LOG_ERROR, "HttpExtensionProc error, could not get a worker for name %s\n", workerName); } } jk_close_pool(&ws.p); } } return result; }
/* 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; }
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; }