*
* @return create jkstatus link
*/
private StringBuffer createLink() {
// Building URL
StringBuffer sb = new StringBuffer();
try {
sb.append("?cmd=update&mime=txt");
sb.append("&w=");
if (isLBMode) {
sb.append(URLEncoder.encode(worker, getCharset()));
//http://localhost/jkstatus?cmd=update&mime=txt&w=lb&vlf=false&vls=true
if ((lbRetries != null)) { // > 0
sb.append("&vlr=");
sb.append(lbRetries);
}
if ((lbRecovertime != null)) { // > 59
sb.append("&vlt=");
sb.append(lbRecovertime);
}
if ((lbStickySession != null)) {
sb.append("&vls=");
sb.append(lbStickySession);
}
if ((lbForceSession != null)) {
sb.append("&vlf=");
sb.append(lbForceSession);
}
} else {
//http://localhost/status?cmd=update&mime=txt&sw=node1&w=lb&vwf=1&wd=false&ws=false
if (workerLb != null) { // must be configured
sb.append(URLEncoder.encode(workerLb, getCharset()));
}
sb.append("&sw=");
sb.append(URLEncoder.encode(worker, getCharset()));
if (workerLoadFactor != null) { // >= 1
sb.append("&vwf=");
sb.append(workerLoadFactor);
}
if (workerJvmRoute != null) {
sb.append("&vwn=");
sb.append(URLEncoder.encode(workerJvmRoute, getCharset()));
}
if (workerDisabled != null) {
sb.append("&vwd=");
sb.append(workerDisabled);
}
if (workerStopped != null) {
sb.append("&vws=");
sb.append(workerStopped);
}
if (workerActivation >= 0 && workerActivation < 3) {
sb.append("&vwa=");
sb.append(workerActivation);
}
if (workerDistance >= 0) {
sb.append("&vwx=");
sb.append(workerDistance);
}
if (workerRedirect != null) { // other worker conrecte lb's
sb.append("&vwr=");
sb.append(URLEncoder.encode(workerRedirect,
getCharset()));
}
if (workerClusterDomain != null) {
sb.append("&vwc=");
sb.append(URLEncoder.encode(workerClusterDomain,
getCharset()));
}
}
} catch (UnsupportedEncodingException e) {
throw new BuildException("Invalid 'charset' attribute: "
+ getCharset());
}
return sb;
}
/**
* check correct lb and worker pararmeter
*/
protected void checkParameter() {
if (worker == null) {
throw new BuildException("Must specify 'worker' attribute");
}
if (workerType == null) {
throw new BuildException("Must specify 'workerType' attribute");
}
if ("lb".equals(workerType)) {
if (lbRecovertime == null && lbRetries == null) {
throw new BuildException(
"Must specify at a lb worker either 'lbRecovertime' or"
+ "'lbRetries' attribute");
}
if (lbStickySession == null || lbForceSession == null) {
throw new BuildException("Must specify at a lb worker either"
+ "'lbStickySession' and 'lbForceSession' attribute");
}
if (null != lbRecovertime && 60 < lbRecovertime.intValue()) {
throw new BuildException(
"The 'lbRecovertime' must be greater than 59");
}
if (null != lbRetries && 1 < lbRetries.intValue()) {
throw new BuildException(
"The 'lbRetries' must be greater than 1");
}
isLBMode = true;
} else if ("worker".equals(workerType)) {
if (workerLoadFactor == null ) {
throw new BuildException(
"Must specify at a node worker 'workerLoadFactor' attribute");
}
if (workerClusterDomain == null) {
throw new BuildException(
"Must specify at a node worker 'workerClusterDomain' attribute");
}
if (workerRedirect == null) {
throw new BuildException(
"Must specify at a node worker 'workerRedirect' attribute");
}
if (workerLb == null) {
throw new BuildException("Must specify 'workerLb' attribute");
}
if (workerLoadFactor.intValue() < 1) {
throw new BuildException(
"The 'workerLoadFactor' must be greater or equal 1");
}
isLBMode = false;
} else {
throw new BuildException(
"Only 'lb' and 'worker' supported as workerType attribute");
}
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatusAccessor.java 0000644 0000000 0000002 00000010446 13623533443 030133 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLConnection;
import org.apache.catalina.util.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.tomcat.util.digester.Digester;
/**
* Create connection to mod_jk jkstatus page.
* Optional you can use Http basic auth user and password.
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
* @since 5.5.10
*/
public class JkStatusAccessor {
private static Log log = LogFactory.getLog(JkStatusAccessor.class);
/**
* The descriptive information about this implementation.
*/
protected static final String info = "org.apache.jk.status.JkStatusAccessor/1.0";
/**
* Parse Apache mod_jk Status from base url http://host:port/jkstatus)
* @param url
* @param username
* @param password
*
*/
public JkStatus status(String url, String username, String password)
throws Exception {
if(url == null || "".equals(url))
return null ;
HttpURLConnection hconn = null;
JkStatus status = null;
try {
// FIXME: use cmd show for older mod_jk versions
hconn = openConnection(url + "?cmd=list&mime=xml", username, password);
Digester digester = JkStatusParser.getDigester();
synchronized (digester) {
status = (JkStatus) digester.parse(hconn.getInputStream());
}
} catch (Throwable t) {
throw new Exception(t);
} finally {
if (hconn != null) {
try {
hconn.disconnect();
} catch (Throwable u) {
;
}
hconn = null;
}
}
return status;
}
/**
* Create a auth http connection for this url
*
* @param url
* @param username
* @param password
* @return HttpConnection
* @throws IOException
* @throws MalformedURLException
* @throws ProtocolException
*/
protected HttpURLConnection openConnection(String url, String username,
String password) throws IOException, MalformedURLException,
ProtocolException {
URLConnection conn;
conn = (new URL(url)).openConnection();
HttpURLConnection hconn = (HttpURLConnection) conn;
// Set up standard connection characteristics
hconn.setAllowUserInteraction(false);
hconn.setDoInput(true);
hconn.setUseCaches(false);
hconn.setDoOutput(false);
hconn.setRequestMethod("GET");
hconn.setRequestProperty("User-Agent", "JkStatus-Client/1.0");
if(username != null && password != null ) {
setAuthHeader(hconn, username, password);
}
// Establish the connection with the server
hconn.connect();
return hconn;
}
/**
* Set Basic Auth Header
*
* @param hconn
* @param username
* @param password
*/
protected void setAuthHeader(HttpURLConnection hconn, String username,
String password) {
// Set up an authorization header with our credentials
String input = username + ":" + password;
String output = new String(Base64.encode(input.getBytes()));
hconn.setRequestProperty("Authorization", "Basic " + output);
}
} ././@LongLink 0000644 0000000 0000000 00000000151 00000000000 011600 L ustar root root tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatusUpdateLoadbalancerTask.java tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatusUpdateLoadbalancerTask.0000644 0000000 0000002 00000015753 13623533443 032072 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import org.apache.tools.ant.BuildException;
/**
* Ant task that implements the /status update loadbalancer command, supported by the
* mod_jk status (1.2.20) application.
*
*
* @author Peter Rossbach
* @since mod_jk 1.2.20
*/
public class JkStatusUpdateLoadbalancerTask extends AbstractJkStatusTask {
/**
* The descriptive information about this implementation.
*/
private static final String info = "org.apache.jk.status.JkStatusUpdateLoadbalancerTask/1.0";
protected String loadbalancer ;
protected int retries = -1;
protected int recoverWaitTime = -1;
protected int methodCode = -1;
protected String method;
protected Boolean stickySession ;
protected Boolean forceStickySession ;
protected int lockCode = -1;
protected String lock;
protected int maxReplyTimeouts = -1;
/**
* Return descriptive information about this implementation and the
* corresponding version number, in the format
* <description>/<version>.
*/
public String getInfo() {
return (info);
}
/**
*
*/
public JkStatusUpdateLoadbalancerTask() {
super();
setUrl("http://localhost/jkstatus");
}
/**
* @return the forceStickySession
*/
public Boolean getForceStickySession() {
return forceStickySession;
}
/**
* @param forceStickySession the forceStickySession to set
*/
public void setForceStickySession(Boolean forceStickySession) {
this.forceStickySession = forceStickySession;
}
/**
* @return the loadbalancer
*/
public String getLoadbalancer() {
return loadbalancer;
}
/**
* @param loadbalancer the loadbalancer to set
*/
public void setLoadbalancer(String loadbalancer) {
this.loadbalancer = loadbalancer;
}
/**
* @return the locking
*/
public String getLock() {
return lock;
}
/**
* @param locking the locking to set
*/
public void setLock(String locking) {
this.lock = locking;
}
/**
* @return the lockingCode
*/
public int getLockCode() {
return lockCode;
}
/**
* @param lockingCode the lockingCode to set
*/
public void setLockCode(int lockingCode) {
this.lockCode = lockingCode;
}
/**
* @return the method
*/
public String getMethod() {
return method;
}
/**
* @param method the method to set
*/
public void setMethod(String method) {
this.method = method;
}
/**
* @return the methodCode
*/
public int getMethodCode() {
return methodCode;
}
/**
* @param methodCode the methodCode to set
*/
public void setMethodCode(int methodCode) {
this.methodCode = methodCode;
}
/**
* @return the recoverWaitTime
*/
public int getRecoverWaitTime() {
return recoverWaitTime;
}
/**
* @param recoverWaitTime the recoverWaitTime to set
*/
public void setRecoverWaitTime(int recoverWaitTime) {
this.recoverWaitTime = recoverWaitTime;
}
/**
* @return the retries
*/
public int getRetries() {
return retries;
}
/**
* @param retries the retries to set
*/
public void setRetries(int retries) {
this.retries = retries;
}
/**
* @return the stickySession
*/
public Boolean getStickySession() {
return stickySession;
}
/**
* @param stickySession the stickySession to set
*/
public void setStickySession(Boolean stickySession) {
this.stickySession = stickySession;
}
/**
* @return the maxReplyTimeouts
*/
public int getMaxReplyTimeouts() {
return maxReplyTimeouts;
}
/**
* @param maxReplyTimeouts the maxReplyTimeouts to set
*/
public void setMaxReplyTimeouts(int maxReplyTimeouts) {
this.maxReplyTimeouts = maxReplyTimeouts;
}
/**
* Create JkStatus worker update link
*
*
* @return create jkstatus update worker link
*/
protected StringBuffer createLink() {
// Building URL
StringBuffer sb = new StringBuffer();
try {
sb.append("?cmd=update&mime=txt");
sb.append("&w=");
sb.append(URLEncoder.encode(loadbalancer, getCharset()));
if (stickySession != null) {
sb.append("&vls=");
sb.append(stickySession);
}
if (forceStickySession != null) {
sb.append("&vlf=");
sb.append(forceStickySession);
}
if (retries >= 0) {
sb.append("&vlr=");
sb.append(retries);
}
if (recoverWaitTime >= 0) {
sb.append("&vlt=");
sb.append(recoverWaitTime);
}
if (method == null && methodCode >= 0 && methodCode < 4) {
sb.append("&vlm=");
sb.append(methodCode);
}
if (method != null) {
sb.append("&vlm=");
sb.append(method);
}
if (lock == null && lockCode >= 0 && lockCode < 2) {
sb.append("&vll=");
sb.append(lockCode);
}
if (lock != null) {
sb.append("&vll=");
sb.append(lock);
}
if (maxReplyTimeouts >= 0) {
sb.append("&vlx=");
sb.append(maxReplyTimeouts);
}
} catch (UnsupportedEncodingException e) {
throw new BuildException("Invalid 'charset' attribute: "
+ getCharset());
}
return sb;
}
/**
* check correct lb and worker pararmeter
*/
protected void checkParameter() {
if (loadbalancer == null) {
throw new BuildException("Must specify 'loadbalancer' attribute");
}
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/package.html 0000644 0000000 0000002 00000013132 13623533443 026311 0 ustar root bin
This package contains a set of Task implementations for
Ant (version 1.6.x or later) that can be used to interact with the
Apaache mod_jk status page to show, update, disable and stop mod_jk worker.
For more information, see
JK Documenation.
The attributes of each task element correspond
exactly to the request parameters that are included with an HTTP request
sent directly to jk status page. They are summarized as follows:
General parameter
Attribute
Description
url
The URL of the jk status page you will use to
perform the requested operations. If not specified, defaults to
http://localhost:80/jkstatus (which corresponds
to a standard installation of Apache mod_jk).
username
The username of a mod_jk status user that has been configured with the
Allow user Apache Location constraint. This attribute is optional.
password
The password of a mod_jk status user that has been configured with the
Allow user Apache Location constraint. This attribute is optional.
resultProperty
Bind all show results with this prefix property name. This attribute is optional.
echo
show result at ant console. (default false)
errorProperty
set this property, as a failure detected. This attribute is optional.
Command show parameter
Attribute
Description
worker
only bind properties from this balancer tcp worker (node)
loadbalancer
only bind properties from this loadbalancer worker
Command reset parameter
Attribute
Description
workerLb
name of loadbalancer worker.
Command update loadbalancer parameter
Attribute
Description
workerType=loadbalancer
type of update
workerLb
name of loadbalancer worker.
lbForceSession
Force Sticky Session. (true/false)
lbStickySession
Sticky Session. (true/false)
lbRetries
loadbalancer retries after worker connection failure (int)
lbRecovertime
Recover timeout after a worker set to "error" state (int sec's)
Command update worker parameter
Attribute
Description
workerType=worker
type of update
worker
name of tcp worker.
workerActivation (>=1.2.19
set worker activation (1 Active, 2 Disabled, 3 Stopped)
workerDisabled (< 1.2.19)
set disable state. (true/false)
workerStoppend (< 1.2.19)
set stopped state. (true/false)
workerJvmRoute
set jvm route
workerLaodFactor
set load factor (int)
workerDistance
set worker distance (int)
workerRedirect
other worker name to redirect after failure
workerClusterDomain
cluster domain name, group of worker at a repliation cluster.
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/mbeans-descriptors.xml 0000644 0000000 0000002 00000003306 13623533443 030360 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatusResetTask.java 0000644 0000000 0000002 00000006712 13623533443 030277 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import org.apache.tools.ant.BuildException;
/**
* Ant task that implements the /jkstatus?cmd=reset&w=loadbalancer command, supported by the
* mod_jk status (1.2.20) application.
*
* @author Peter Rossbach
* @since mod_jk 1.2.20
*/
public class JkStatusResetTask extends AbstractJkStatusTask {
/**
* The descriptive information about this implementation.
*/
private static final String info = "org.apache.jk.status.JkStatusResetTask/1.1";
private String worker;
private String loadbalancer;
/**
*
*/
public JkStatusResetTask() {
super();
setUrl("http://localhost/jkstatus");
}
/**
* Return descriptive information about this implementation and the
* corresponding version number, in the format
* <description>/<version>.
*/
public String getInfo() {
return (info);
}
/**
* @return the loadbalancer
*/
public String getLoadbalancer() {
return loadbalancer;
}
/**
* @param loadbalancer the loadbalancer to set
*/
public void setLoadbalancer(String loadbalancer) {
this.loadbalancer = loadbalancer;
}
/**
* @return the worker
*/
public String getWorker() {
return worker;
}
/**
* @param worker the worker to set
*/
public void setWorker(String worker) {
this.worker = worker;
}
/**
* Create jkstatus reset link
*
loadbalancer + sub worker example:
* http://localhost/jkstatus?cmd=reset&mime=txt&w=loadbalancer&sw=node01
*
*
* @return create jkstatus reset link
*/
protected StringBuffer createLink() {
// Building URL
StringBuffer sb = new StringBuffer();
try {
sb.append("?cmd=reset");
sb.append("&mime=txt");
sb.append("&w=");
sb.append(URLEncoder.encode(loadbalancer, getCharset()));
if(worker != null) {
sb.append("&sw=");
sb.append(URLEncoder.encode(worker, getCharset()));
}
} catch (UnsupportedEncodingException e) {
throw new BuildException("Invalid 'charset' attribute: "
+ getCharset());
}
return sb;
}
/**
* check correct pararmeter
*/
protected void checkParameter() {
if (loadbalancer == null) {
throw new BuildException("Must specify 'loadbalanacer' attribute");
}
}
} tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkBalancerMember.java 0000644 0000000 0000002 00000023462 13623533443 030026 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.Serializable;
/**
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
*/
public class JkBalancerMember implements Serializable {
int id = -1;
String name;
/* possible with >= 1.2.16 */
String jvm_route;
/* possible with >= 1.2.20 */
String route;
String type;
String host;
int port;
String address;
/* deprecated with mod_jk 1.2.16*/
String status;
/* possible with > 1.2.16 */
String activation;
/* possible with > 1.2.16 */
String state;
int lbfactor;
long lbvalue;
/* possible with > 1.2.16 */
long lbmult = -1 ;
int elected;
long readed;
long transferred;
long errors;
long clienterrors = -1;
int busy;
/* possible with > 1.2.16 */
int maxbusy = -1;
String redirect;
String domain;
/* possible with > 1.2.16 */
int distance = -1;
/* possible with > 1.2.20 */
int time_to_recover = -1 ;
/* possible with > 1.2.21 */
int time_to_recover_max = -1 ;
/* possible with > 1.2.21 */
int time_to_recover_min = -1 ;
/**
* @return Returns the jvm_route.
* @since mod_jk 1.2.16
* @deprecated
*/
public String getJvm_route() {
return jvm_route;
}
/**
* @param jvm_route The jvm_route to set.
* @since mod_jk 1.2.16
* @deprecated
*/
public void setJvm_route(String jvm_route) {
this.jvm_route = jvm_route;
}
/**
* @return the route
* @since mod_jk 1.2.20
*/
public String getRoute() {
return route;
}
/**
* @param route the route to set
* @since mod_jk 1.2.20
*/
public void setRoute(String route) {
this.route = route;
}
/**
* @return Returns the address.
*/
public String getAddress() {
return address;
}
/**
* @param address
* The address to set.
*/
public void setAddress(String address) {
this.address = address;
}
/**
* @return Returns the busy.
*/
public int getBusy() {
return busy;
}
/**
* @param busy
* The busy to set.
*/
public void setBusy(int busy) {
this.busy = busy;
}
/**
* @return Returns the maxbusy.
* @since mod_jk 1.2.18
*/
public int getMax_busy() {
return maxbusy;
}
/**
* @param maxbusy The maxbusy to set.
* @since mod_jk 1.2.18
*/
public void setMax_busy(int maxbusy) {
this.maxbusy = maxbusy;
}
/**
* @return Returns the elected.
*/
public int getElected() {
return elected;
}
/**
* @param elected
* The elected to set.
*/
public void setElected(int elected) {
this.elected = elected;
}
/**
* @return Returns the clienterrors.
* @since mod_jk 1.2.19
*/
public long getClient_errors() {
return clienterrors;
}
/**
* @param clienterrors The clienterrors to set.
* @since mod_jk 1.2.19
*/
public void setClient_errors(long clienterrors) {
this.clienterrors = clienterrors;
}
/**
* @return Returns the errors.
*/
public long getErrors() {
return errors;
}
/**
* @param errors
* The errors to set.
*/
public void setErrors(long errors) {
this.errors = errors;
}
/**
* @return Returns the host.
*/
public String getHost() {
return host;
}
/**
* @param host
* The host to set.
*/
public void setHost(String host) {
this.host = host;
}
/**
* @return Returns the id.
*/
public int getId() {
return id;
}
/**
* @param id
* The id to set.
*/
public void setId(int id) {
this.id = id;
}
/**
* @return Returns the lbfactor.
*/
public int getLbfactor() {
return lbfactor;
}
/**
* @param lbfactor
* The lbfactor to set.
*/
public void setLbfactor(int lbfactor) {
this.lbfactor = lbfactor;
}
/**
* @return Returns the lbvalue.
*/
public long getLbvalue() {
return lbvalue;
}
/**
* @param lbvalue
* The lbvalue to set.
*/
public void setLbvalue(long lbvalue) {
this.lbvalue = lbvalue;
}
/**
* @return Returns the lbmult.
* @since mod_jk 1.2.19
*/
public long getLbmult() {
return lbmult;
}
/**
* @param lbmult The lbmult to set.
* @since mod_jk 1.2.19
*/
public void setLbmult(long lbmult) {
this.lbmult = lbmult;
}
/**
* @return Returns the name.
*/
public String getName() {
return name;
}
/**
* @param name
* The name to set.
*/
public void setName(String name) {
this.name = name;
}
/**
* @return Returns the port.
*/
public int getPort() {
return port;
}
/**
* @param port
* The port to set.
*/
public void setPort(int port) {
this.port = port;
}
/**
* @return Returns the readed.
*/
public long getReaded() {
return readed;
}
/**
* @param readed
* The readed to set.
*/
public void setReaded(long readed) {
this.readed = readed;
}
/**
* @return Returns the status.
* @deprecated since 1.2.16
*/
public String getStatus() {
return status;
}
/**
* @param status
* The status to set.
* @deprecated since 1.2.16
*/
public void setStatus(String status) {
this.status = status;
}
/**
* @return Returns the activation.
* @since mod_jk 1.2.19
*/
public String getActivation() {
return activation;
}
/**
* @param activation The activation to set.
* @since mod_jk 1.2.19
*/
public void setActivation(String activation) {
this.activation = activation;
}
/**
* @return Returns the state.
* @since mod_jk 1.2.19
*/
public String getState() {
return state;
}
/**
* @param state The state to set.
* @since mod_jk 1.2.19
*/
public void setState(String state) {
this.state = state;
}
/**
* @return Returns the transferred.
*/
public long getTransferred() {
return transferred;
}
/**
* @param transferred
* The transferred to set.
*/
public void setTransferred(long transferred) {
this.transferred = transferred;
}
/**
* @return Returns the type.
*/
public String getType() {
return type;
}
/**
* @param type
* The type to set.
*/
public void setType(String type) {
this.type = type;
}
/**
* @return Returns the domain.
*/
public String getDomain() {
return domain;
}
/**
* @param domain The domain to set.
*/
public void setDomain(String domain) {
this.domain = domain;
}
/**
* @return Returns the redirect.
*/
public String getRedirect() {
return redirect;
}
/**
* @param redirect The redirect to set.
*/
public void setRedirect(String redirect) {
this.redirect = redirect;
}
/**
* @return Returns the distance.
* @since mod_jk 1.2.18
*/
public int getDistance() {
return distance;
}
/**
* @param distance The distance to set.
* @since mod_jk 1.2.18
*/
public void setDistance(int distance) {
this.distance = distance;
}
/**
* @return the time_to_recover
* @since mod_jk 1.2.20
*/
public int getTime_to_recover() {
return time_to_recover;
}
/**
* @param time_to_recover the time_to_recover to set
* @since mod_jk 1.2.20
*/
public void setTime_to_recover(int time_to_recover) {
this.time_to_recover = time_to_recover;
}
/**
* @return the time_to_recover_min
* @since mod_jk 1.2.21
*/
public int getTime_to_recover_min() {
return time_to_recover_min;
}
/**
* @param time_to_recover_min the time_to_recover_min to set
* @since mod_jk 1.2.21
*/
public void setTime_to_recover_min(int time_to_recover_min) {
this.time_to_recover_min = time_to_recover_min;
}
/**
* @return the time_to_recover_max
* @since mod_jk 1.2.21
*/
public int getTime_to_recover_max() {
return time_to_recover_max;
}
/**
* @param time_to_recover_max the time_to_recover_max to set
* @since mod_jk 1.2.21
*/
public void setTime_to_recover_max(int time_to_recover_max) {
this.time_to_recover_max = time_to_recover_max;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatusUpdateWorkerTask.java 0000644 0000000 0000002 00000014672 13623533443 031635 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import org.apache.tools.ant.BuildException;
/**
* Ant task that implements the /status update worker command, supported by the
* mod_jk status (1.2.20) application.
*
* @author Peter Rossbach
* @since mod_jk 1.2.20
*/
public class JkStatusUpdateWorkerTask extends AbstractJkStatusTask {
/**
* The descriptive information about this implementation.
*/
private static final String info = "org.apache.jk.status.JkStatusUpdateWorkerTask/1.0";
protected String loadbalancer ;
protected String worker ;
protected int loadfactor =-1;
protected String route ;
protected int distance = -1;
protected String redirect;
protected String domain;
protected int activationCode = -1;
protected String activation ;
/**
* Return descriptive information about this implementation and the
* corresponding version number, in the format
* <description>/<version>.
*/
public String getInfo() {
return (info);
}
/**
*
*/
public JkStatusUpdateWorkerTask() {
super();
setUrl("http://localhost/jkstatus");
}
/**
* @return the activation
*/
public String getActivation() {
return activation;
}
/**
* @param activation the activation to set
*/
public void setActivation(String activation) {
this.activation = activation;
}
/**
* @return the activationCode
*/
public int getActivationCode() {
return activationCode;
}
/**
* @param activationCode the activationCode to set
*/
public void setActivationCode(int activationCode) {
this.activationCode = activationCode;
}
/**
* @return the distance
*/
public int getDistance() {
return distance;
}
/**
* @param distance the distance to set
*/
public void setDistance(int distance) {
this.distance = distance;
}
/**
* @return the domain
*/
public String getDomain() {
return domain;
}
/**
* @param domain the domain to set
*/
public void setDomain(String domain) {
this.domain = domain;
}
/**
* @return the loadbalancer
*/
public String getLoadbalancer() {
return loadbalancer;
}
/**
* @param loadbalancer the loadbalaner to set
*/
public void setLoadbalancer(String loadbalancer) {
this.loadbalancer = loadbalancer;
}
/**
* @return the loadfactor
*/
public int getLoadfactor() {
return loadfactor;
}
/**
* @param loadfactor the loadfactor to set
*/
public void setLoadfactor(int loadfactor) {
this.loadfactor = loadfactor;
}
/**
* @return the redirect
*/
public String getRedirect() {
return redirect;
}
/**
* @param redirect the redirect to set
*/
public void setRedirect(String redirect) {
this.redirect = redirect;
}
/**
* @return the route
*/
public String getRoute() {
return route;
}
/**
* @param route the route to set
*/
public void setRoute(String route) {
this.route = route;
}
/**
* @return the worker
*/
public String getWorker() {
return worker;
}
/**
* @param worker the worker to set
*/
public void setWorker(String worker) {
this.worker = worker;
}
/**
* Create JkStatus worker update link
*
*
* @return create jkstatus update worker link
*/
protected StringBuffer createLink() {
// Building URL
StringBuffer sb = new StringBuffer();
try {
sb.append("?cmd=update&mime=txt");
sb.append("&w=");
sb.append(URLEncoder.encode(loadbalancer, getCharset()));
sb.append("&sw=");
sb.append(URLEncoder.encode(worker, getCharset()));
if (loadfactor >= 0) {
sb.append("&vwf=");
sb.append(loadfactor);
}
if (route != null) {
sb.append("&vwn=");
sb.append(URLEncoder.encode(route, getCharset()));
}
if (activation == null && activationCode > 0 && activationCode < 4) {
sb.append("&vwa=");
sb.append(activation);
}
if (activation != null) {
sb.append("&vwa=");
sb.append(URLEncoder.encode(activation, getCharset()));
}
if (distance >= 0) {
sb.append("&vwd=");
sb.append(distance);
}
if (redirect != null) { // other worker conrecte lb's
sb.append("&vwr=");
sb.append(URLEncoder.encode(redirect, getCharset()));
}
if (domain != null) {
sb.append("&vwc=");
sb.append(URLEncoder.encode(domain, getCharset()));
}
} catch (UnsupportedEncodingException e) {
throw new BuildException("Invalid 'charset' attribute: "
+ getCharset());
}
return sb;
}
/**
* check correct lb and worker pararmeter
*/
protected void checkParameter() {
if (worker == null) {
throw new BuildException("Must specify 'worker' attribute");
}
if (loadbalancer == null) {
throw new BuildException("Must specify 'loadbalancer' attribute");
}
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkSoftware.java 0000644 0000000 0000002 00000003077 13623533443 026761 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.Serializable;
/**
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
*/
public class JkSoftware implements Serializable {
String web_server;
String jk_version ;
/**
* @return Returns the software.
*/
public String getWeb_server() {
return web_server;
}
/**
* @param software The software to set.
*/
public void setWeb_server(String software) {
this.web_server = software;
}
/**
* @return Returns the version.
*/
public String getJk_version() {
return jk_version;
}
/**
* @param version The version to set.
*/
public void setJk_version(String version) {
this.jk_version = version;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkBalancerMapping.java 0000644 0000000 0000002 00000004360 13623533443 030206 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.Serializable;
/**
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
*/
public class JkBalancerMapping implements Serializable {
int id =-1 ;
String type ;
String uri;
String context ;
String source ;
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}
/**
* @return Returns the context.
* @deprecated mod_jk 1.2.20
*/
public String getContext() {
return context;
}
/**
* @param context The context to set.
* @deprecated mod_jk 1.2.20
*/
public void setContext(String context) {
this.context = context;
}
/**
* @return Returns the type.
*/
public String getType() {
return type;
}
/**
* @param type The type to set.
*/
public void setType(String type) {
this.type = type;
}
/**
* @return Returns the uri.
*/
public String getUri() {
return uri;
}
/**
* @param uri The uri to set.
*/
public void setUri(String uri) {
this.uri = uri;
}
/**
* @return the source
* @since mod_jk 1.2.20
*/
public String getSource() {
return source;
}
/**
* @param source the source to set
* @since mod_jk 1.2.20
*/
public void setSource(String source) {
this.source = source;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkResult.java 0000644 0000000 0000002 00000002626 13623533443 026444 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.Serializable;
/**
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
*/
public class JkResult implements Serializable {
String type ;
String message;
/**
* @return the message
*/
public String getMessage() {
return message;
}
/**
* @param message the message to set
*/
public void setMessage(String message) {
this.message = message;
}
/**
* @return the type
*/
public String getType() {
return type;
}
/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/AbstractJkStatusTask.java 0000644 0000000 0000002 00000015363 13623533443 030762 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLConnection;
import org.apache.catalina.ant.AbstractCatalinaTask;
import org.apache.catalina.util.Base64;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
/**
* Ant task that implements mod_jk 1.2.20 result message string
*
* @author Peter Rossbach
* @since mod_jk 1.2.20
*/
public abstract class AbstractJkStatusTask extends AbstractCatalinaTask {
/**
* Execute the requested operation.
*
* @exception BuildException
* if an error occurs
*/
public void execute() throws BuildException {
super.execute();
checkParameter();
StringBuffer sb = createLink();
execute(sb.toString(), null, null, -1);
}
protected abstract void checkParameter() ;
protected abstract StringBuffer createLink() ;
/**
* Execute the specified command, based on the configured properties.
* The input stream will be closed upon completion of this task, whether
* it was executed successfully or not.
*
* @param command Command to be executed
* @param istream InputStream to include in an HTTP PUT, if any
* @param contentType Content type to specify for the input, if any
* @param contentLength Content length to specify for the input, if any
*
* @exception BuildException if an error occurs
*/
public void execute(String command, InputStream istream,
String contentType, int contentLength)
throws BuildException {
InputStreamReader reader = null;
try {
HttpURLConnection hconn = send(command, istream, contentType, contentLength);
// Process the response message
reader = new InputStreamReader(hconn.getInputStream(), "UTF-8");
String error = null;
error = handleResult(reader, error);
if (error != null && isFailOnError()) {
// exception should be thrown only if failOnError == true
// or error line will be logged twice
throw new BuildException(error);
}
} catch (Throwable t) {
if (isFailOnError()) {
throw new BuildException(t);
} else {
handleErrorOutput(t.getMessage());
}
} finally {
closeRedirector();
if (reader != null) {
try {
reader.close();
} catch (Throwable u) {
;
}
reader = null;
}
if (istream != null) {
try {
istream.close();
} catch (Throwable u) {
;
}
istream = null;
}
}
}
private String handleResult(InputStreamReader reader, String error) throws IOException {
StringBuffer buff = new StringBuffer();
int msgPriority = Project.MSG_INFO;
boolean first = true;
while (true) {
int ch = reader.read();
if (ch < 0) {
break;
} else if ((ch == '\r') || (ch == '\n')) {
// in Win \r\n would cause handleOutput() to be called
// twice, the second time with an empty string,
// producing blank lines
if (buff.length() > 0) {
String line = buff.toString();
buff.setLength(0);
if (first) {
if (!line.startsWith("Result: type=OK")) {
error = line;
msgPriority = Project.MSG_ERR;
}
first = false;
}
handleOutput(line, msgPriority);
}
} else {
buff.append((char) ch);
}
}
if (buff.length() > 0) {
handleOutput(buff.toString(), msgPriority);
}
return error;
}
protected HttpURLConnection send(String command, InputStream istream, String contentType, int contentLength) throws IOException, MalformedURLException, ProtocolException {
URLConnection conn;
// Create a connection for this command
conn = (new URL(url + command)).openConnection();
HttpURLConnection hconn = (HttpURLConnection) conn;
// Set up standard connection characteristics
hconn.setAllowUserInteraction(false);
hconn.setDoInput(true);
hconn.setUseCaches(false);
if (istream != null) {
hconn.setDoOutput(true);
hconn.setRequestMethod("PUT");
if (contentType != null) {
hconn.setRequestProperty("Content-Type", contentType);
}
if (contentLength >= 0) {
hconn.setRequestProperty("Content-Length",
"" + contentLength);
}
} else {
hconn.setDoOutput(false);
hconn.setRequestMethod("GET");
}
hconn.setRequestProperty("User-Agent",
"JkStatus-Ant-Task/1.1");
// Set up an authorization header with our credentials
String input = username + ":" + password;
String output = new String(Base64.encode(input.getBytes()));
hconn.setRequestProperty("Authorization",
"Basic " + output);
// Establish the connection with the server
hconn.connect();
// Send the request data (if any)
if (istream != null) {
BufferedOutputStream ostream =
new BufferedOutputStream(hconn.getOutputStream(), 1024);
byte buffer[] = new byte[1024];
while (true) {
int n = istream.read(buffer);
if (n < 0) {
break;
}
ostream.write(buffer, 0, n);
}
ostream.flush();
ostream.close();
istream.close();
}
return hconn;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/JkStatus.java 0000644 0000000 0000002 00000004377 13623533443 026456 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* @author Peter Rossbach
* @see org.apache.jk.status.JkStatusParser
*/
public class JkStatus implements Serializable {
JkServer server ;
JkSoftware software ;
JkResult result ;
List balancers = new ArrayList() ;
/**
* @return Returns the balancers.
*/
public List getBalancers() {
return balancers;
}
/**
* @param balancers The balancers to set.
*/
public void setBalancers(List balancers) {
this.balancers = balancers;
}
public void addBalancer(JkBalancer balancer) {
balancers.add(balancer);
}
public void removeBalancer(JkBalancer balancer) {
balancers.remove(balancer);
}
/**
* @return Returns the server.
*/
public JkServer getServer() {
return server;
}
public void setServer(JkServer server) {
this.server = server ;
}
/**
* @return the result
*/
public JkResult getResult() {
return result;
}
/**
* @param result the result to set
*/
public void setResult(JkResult result) {
this.result = result;
}
/**
* @return Returns the software.
*/
public JkSoftware getSoftware() {
return software;
}
/**
* @param software The software to set.
*/
public void setSoftware(JkSoftware software) {
this.software = software;
}
}
tomcat-connectors-1.2.48-src/jkstatus/src/share/org/apache/jk/status/antlib.xml 0000644 0000000 0000002 00000002511 13623533443 026022 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/test/ 0000755 0000000 0000002 00000000000 13623533443 017157 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/build.xml 0000644 0000000 0000002 00000010724 13623533443 021004 0 ustar root bin
This ant script implements some testcases to verify the key functions of tomcat apache mod_jk jkstatus module.
You find this script at: ${ant.file}
tomcat-connectors-1.2.48-src/jkstatus/test/conf/ 0000755 0000000 0000002 00000000000 13623533443 020104 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/conf/log4j.xml 0000644 0000000 0000002 00000004764 13623533443 021660 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/test/conf/jkstatus.xml 0000644 0000000 0000002 00000003507 13623533443 022503 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/test/src/ 0000755 0000000 0000002 00000000000 13623533443 017746 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/ 0000755 0000000 0000002 00000000000 13623533443 021050 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/org/ 0000755 0000000 0000002 00000000000 13623533443 021637 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/org/apache/ 0000755 0000000 0000002 00000000000 13623533443 023060 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/org/apache/jk/ 0000755 0000000 0000002 00000000000 13623533443 023464 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/org/apache/jk/status/ 0000755 0000000 0000002 00000000000 13623533443 025007 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/test/src/share/org/apache/jk/status/JkStatusParserTest.java 0000644 0000000 0000002 00000006447 13623533443 031452 0 ustar root bin /* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jk.status;
import java.io.IOException;
import java.io.StringReader;
import junit.framework.TestCase;
import org.apache.tomcat.util.digester.Digester;
import org.xml.sax.SAXException;
/**
* @author Peter Rossbach
*
*/
public class JkStatusParserTest extends TestCase {
public void testDigester() throws IOException, SAXException {
Digester digester = JkStatusParser.createDigester();
String example = ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ ""
+ "" ;
StringReader reader = new StringReader(example);
JkStatus status = (JkStatus) digester
.parse(reader);
assertNotNull(status);
assertNotNull(status.getServer());
assertEquals(1,status.getBalancers().size());
JkBalancer balancer = (JkBalancer)status.getBalancers().get(0);
assertEquals(2,balancer.getBalancerMembers().size());
assertEquals("node1",((JkBalancerMember)balancer.getBalancerMembers().get(0)).getName());
assertEquals("node2",((JkBalancerMember)balancer.getBalancerMembers().get(1)).getName());
assertEquals(4,balancer.getBalancerMappings().size());
}
}
tomcat-connectors-1.2.48-src/jkstatus/build.properties.default 0000644 0000000 0000002 00000001453 13623533443 023043 0 ustar root bin # -----------------------------------------------------------------------------
# build.properties.default
#
# This is an example "build.properties" file, used to customize building Tomcat
# for your local environment. It defines the location of all external
# modules that Tomcat depends on. Copy this file to "build.properties"
# in the top-level source directory, and customize it as needed.
# -----------------------------------------------------------------------------
# ----- Compile Control Flags -----
compile.debug=on
compile.deprecation=off
compile.optimize=off
# ----- Path to Tomcat installation -----
catalina.build=/usr/local/share/tomcat-5.5
# ----- Some version dependent jar file names -----
commons-modeler.jar=commons-modeler-2.0.1.jar
commons-logging.jar=commons-logging-api-1.1.1.jar
tomcat-connectors-1.2.48-src/jkstatus/example/ 0000755 0000000 0000002 00000000000 13623533443 017633 5 ustar root bin tomcat-connectors-1.2.48-src/jkstatus/example/jkstatus.xml 0000644 0000000 0000002 00000010421 13623533443 022223 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/example/jkstatus.properties.default 0000644 0000000 0000002 00000002010 13623533443 025235 0 ustar root bin # Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
jkstatus.host=localhost
jkstatus.port=2090
jkstatus.username=manager
jkstatus.password=tomcat
jkstatus.url=http://${jkstatus.host}:${jkstatus.port}/jkstatus
jkstatus.testlb=loadbalancer
jkstatus.testworker=node01
catalina.home=../../../../build/build tomcat-connectors-1.2.48-src/jkstatus/example/show.xml 0000644 0000000 0000002 00000004011 13623533443 021331 0 ustar root bin
tomcat-connectors-1.2.48-src/jkstatus/example/show.txt 0000644 0000000 0000002 00000001776 13623533443 021367 0 ustar root bin Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
How to use the show example:
ant -f show.xml
Configure mod_jk (httpd.conf and workers.properties):
JkMount /jkstatus jkstatus
worker.list=jkstatus
worker.jkstatus.type=status
Adjust jkstatus.properties.default:
jkstatus.port (for example).
tomcat-connectors-1.2.48-src/.gitignore 0000644 0000000 0000002 00000000040 13623533443 016312 0 ustar root bin .project
build
build.properties
tomcat-connectors-1.2.48-src/conf/ 0000755 0000000 0000002 00000000000 13623533444 015256 5 ustar root bin tomcat-connectors-1.2.48-src/conf/uriworkermap.properties 0000644 0000000 0000002 00000002665 13623533443 022133 0 ustar root bin # Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# uriworkermap.properties
#
# Use for IIS or with the Apache web server as an alternative
# to JkMount and JkUnmount
#
# This file provides sample mappings for the example
# worker "balancer" defined in workermap.properties.
# The general syntax for this file is:
# [URL]=[Worker name]
/admin/*=balancer
/manager/*=balancer
/examples/*=balancer
# Optionally filter out all .jpg files inside that context
# For no mapping the url has to start with exclamation mark (!)
!/examples/*.jpg=balancer
#
# Mount jk status and manager
# For production servers you will need to
# secure the access to the /jk-manager and
# /jk-status urls
#
/jk-manager=jk-manager
/jk-status=jk-status
tomcat-connectors-1.2.48-src/conf/workers.properties 0000644 0000000 0000002 00000013513 13623533443 021072 0 ustar root bin # Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Note that the distributed version of this file requires modification
# before it is usable.
#
# Reference documentation: http://tomcat.apache.org/connectors-doc/reference/workers.html
#
# As a general note, the characters $( and ) are used to reference
# property values in other properties.
#
# Whenever you see a set of lines such as:
# x=value
# y=$(x)othervalue
#
# the final value for y will be "valueothervalue"
# Define two status worker:
# - jk-status for read-only use
# - jk-manager for read/write use
worker.list=jk-status
worker.jk-status.type=status
worker.jk-status.read_only=true
worker.list=jk-manager
worker.jk-manager.type=status
# We define a load balancer worker
# with name "balancer"
worker.list=balancer
worker.balancer.type=lb
# error_escalation_time: seconds, default = recover_time/2 (=30)
# Determines, how fast a detected error should switch from
# local error state to global error state
# Since: 1.2.28
worker.balancer.error_escalation_time=0
# - max_reply_timeouts: number, default=0
# If there are to many reply timeouts, a worker
# is put into the error state, i.e. it will become
# unavailable for all sessions residing on the respective
# Tomcat. The number of tolerated reply timeouts is
# configured with max_reply_timeouts. The number of
# timeouts occuring is divided by 2 once a minute and the
# resulting counter is compared against max_reply_timeouts.
# If you set max_reply_timeouts to N and the errors are
# occuring equally distributed over time, you will
# tolerate N/2 errors per minute. If they occur in a burst
# you will tolerate N errors.
# Since: 1.2.24
worker.balancer.max_reply_timeouts=10
# Now we add members to the load balancer
# First member is "node1", most
# attributes are inherited from the
# template "worker.template".
worker.balancer.balance_workers=node1
worker.node1.reference=worker.template
worker.node1.host=localhost
worker.node1.port=8109
# Activation allows to configure
# whether this node should actually be used
# A: active (use node fully)
# D: disabled (only use, if sticky session needs this node)
# S: stopped (do not use)
# Since: 1.2.19
worker.node1.activation=A
# Second member is "node2", most
# attributes are inherited from the
# template "worker.template".
worker.balancer.balance_workers=node2
worker.node2.reference=worker.template
worker.node2.host=localhost
worker.node2.port=8209
# Activation allows to configure
# whether this node should actually be used
# A: active (use node fully)
# D: disabled (only use, if sticky session needs this node)
# S: stopped (do not use)
# Since: 1.2.19
worker.node2.activation=A
# Finally we put the parameters
# which should apply to all our ajp13
# workers into the referenced template
# - Type is ajp13
worker.template.type=ajp13
# - socket_connect_timeout: milliseconds, default=0
# Since: 1.2.27
worker.template.socket_connect_timeout=5000
# - socket_keepalive: boolean, default=false
# Should we send TCP keepalive packets
# when connection is idle (socket option)?
worker.template.socket_keepalive=true
# - ping_mode: Character, default=none
# When should we use cping/cpong connection probing?
# C = directly after establishing a new connection
# P = directly before sending each request
# I = in regular intervals for idle connections
# using the watchdog thread
# A = all of the above
# Since: 1.2.27
worker.template.ping_mode=A
# - ping_timeout: milliseconds, default=10000
# Wait timeout for cpong after cping
# Can be overwritten for modes C and P
# Using connect_timeout and prepost_timeout.
# Since: 1.2.27
worker.template.ping_timeout=10000
# - connection_pool_minsize: number, default=connection_pool_size
# Lower pool size when shrinking pool due
# to idle connections
# We want all connections to be closed when
# idle for a long time in order to prevent
# firewall problems.
# Since: 1.2.16
worker.template.connection_pool_minsize=0
# - connection_pool_timeout: seconds, default=0
# Idle time, before a connection is eligible
# for being closed (pool shrinking).
# This should be the same value as keepAliveTimeout
# (if it is set explicitly) or connectionTimeout
# in the Tomcat AJP connector, but there it is
# milliseconds, here seconds.
worker.template.connection_pool_timeout=600
# - reply_timeout: milliseconds, default=0
# Any pause longer than this timeout during waiting
# for a part of the reply will abort handling the request
# in mod_jk. The request will proceed running in
# Tomcat, but the web server resources will be freed
# and an error is send to the client.
# For individual requests, the timeout can be overwritten
# by the Apache environment variable JK_REPLY_TIMEOUT.
# JK_REPLY_TIMEOUT since: 1.2.27
worker.template.reply_timeout=300000
# - recovery_options: number, default=0
# Bit mask to configure, if a request, which was send
# to a backend successfully, should be retried on another backend
# in case there's a problem with the response.
# Value "3" disables retries, whenever a part of the request was
# successfully send to the backend.
worker.template.recovery_options=3
tomcat-connectors-1.2.48-src/conf/httpd-jk.conf 0000644 0000000 0000002 00000011474 13623533443 017660 0 ustar root bin # Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Configuration Example for mod_jk
# used in combination with Apache 2.2.x
# Change the path and file name of the module, in case
# you have installed it outside of httpd, or using
# a versioned file name.
LoadModule jk_module modules/mod_jk.so
# We need a workers file exactly once
# and in the global server
JkWorkersFile conf/workers.properties
# Our JK error log
# You can (and should) use rotatelogs here
JkLogFile logs/mod_jk.log
# Our JK log level (trace,debug,info,warn,error)
JkLogLevel info
# Our JK shared memory file
JkShmFile logs/mod_jk.shm
# Define a new log format you can use in any CustomLog in order
# to add mod_jk specific information to your access log.
# LogFormat "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" \"%{Cookie}i\" \"%{Set-Cookie}o\" %{pid}P %{tid}P %{JK_LB_FIRST_NAME}n %{JK_LB_LAST_NAME}n ACC %{JK_LB_LAST_ACCESSED}n ERR %{JK_LB_LAST_ERRORS}n BSY %{JK_LB_LAST_BUSY}n %{JK_LB_LAST_STATE}n %D" extended_jk
# This option will reject all requests, which contain an
# encoded percent sign (%25) or backslash (%5C) in the URL
# If you are sure, that your webapp doesn't use such
# URLs, enable the option to prevent double encoding attacks.
# Since: 1.2.24
# JkOptions +RejectUnsafeURI
# After setting JkStripSession to "On", mod_jk will
# strip all ";jsessionid=..." from request URLs it
# does *not* forward to a backend.
# This is useful, if all links in a webapp use
# URLencoded session IDs and parts of the static
# content should be delivered directly by Apache.
# Of course you can also do it with mod_rewrite.
# Since: 1.2.21
# JkStripSession On
# Start a separate thread for internal tasks like
# idle connection probing, connection pool resizing
# and load value decay.
# Run these tasks every JkWatchdogInterval seconds.
# Since: 1.2.27
JkWatchdogInterval 60
# Configure access to jk-status and jk-manager
# If you want to make this available in a virtual host,
# either move this block into the virtual host
# or copy it logically there by including "JkMountCopy On"
# in the virtual host.
# Add an appropriate authentication method here!
# Inside Location we can omit the URL in JkMount
JkMount jk-status
Require ip 127.0.0.1
# Inside Location we can omit the URL in JkMount
JkMount jk-manager
Require ip 127.0.0.1
# If you want to put all mounts into an external file
# that gets reloaded automatically after changes
# (with a default latency of 1 minute),
# you can define the name of the file here.
# JkMountFile conf/extra/uriworkermap.properties
# Example for Mounting a context to the worker "balancer"
# The URL syntax "a|b" instantiates two mounts at once,
# the first one is "a", the second one is "ab".
# JkMount /myapp|/* balancer
# Example for UnMounting requests for all workers
# using a simple URL pattern
# Since: 1.2.26
# JkUnMount /myapp/static/* *
# Example for UnMounting requests for a named worker
# JkUnMount /myapp/images/* balancer
# Example for UnMounting requests using regexps
# SetEnvIf REQUEST_URI "\.(htm|html|css|gif|jpg|js)$" no-jk
# Example for setting a reply timeout depending on the request URL
# Since: 1.2.27
# SetEnvIf Request_URI "/transactions/" JK_REPLY_TIMEOUT=600000
# Example for disabling reply timeouts for certain request URLs
# Since: 1.2.27
# SetEnvIf Request_URI "/reports/" JK_REPLY_TIMEOUT=0
# IMPORTANT: Mounts and virtual hosts
# If you are using VirtualHost elements, you
# - can put mounts only used in some virtual host into its VirtualHost element
# - can copy all global mounts to it using "JkMountCopy On" inside the VirtualHost
# - can copy all global mounts to all virtual hosts by putting
# "JkMountCopy All" into the global server
# Since: 1.2.26
tomcat-connectors-1.2.48-src/xdocs/ 0000755 0000000 0000002 00000000000 13623533444 015451 5 ustar root bin tomcat-connectors-1.2.48-src/xdocs/reference/ 0000755 0000000 0000002 00000000000 13623533443 017406 5 ustar root bin tomcat-connectors-1.2.48-src/xdocs/reference/iis.xml 0000644 0000000 0000002 00000037461 13623533443 020727 0 ustar root bin
]>
&project;
Mladen TurkConfiguring the ISAPI redirector for Microsoft IIS
The Tomcat redirector requires three entities:
isapi_redirect.dll - The IIS ISAPI redirector plugin, either obtain a pre-built DLL or build it yourself (see the build section).
workers.properties - A file that describes the host(s) and port(s) used by the workers (Tomcat processes).
A sample workers.properties can be found under the conf directory.
uriworkermap.properties - A file that maps URL-Path patterns to workers.
A sample uriworkermap.properties can be found under the conf directory as well.
The installation includes the following parts:
Configuring the ISAPI redirector with a default /examples context and checking that you can serve servlets with IIS.
Adding more contexts to the configuration.
Note that in a 64 Bit environment - at least for IIS 7 - the used IIS Application Pool
should have "Enable 32-bit Applications" set to "False". Otherwise the redirector will
not be called and returns an http code 404. If you think, the 32bit version of
isapi_redirect.dll would do the job instead, you will get an http code 500,
because the library is not loadable into a 64 Bit IIS.
ISAPI redirector reads configuration from the registry, create a new registry key named:
Attributes described below as a "string value representing a boolean"
can be set either using the numbers 0 (false) and 1 (true)
as values, or off (false) and on (true) or any other string
starting with the letters f (false), n (false),
t (true) or y (true).
The values are taken case insensitive. In this documentation we will stick
to false and true.
A string value pointing to the ISAPI extension /jakarta/isapi_redirect.dll
A value pointing to location where log file will be created.
(for example c:\tomcat\logs\isapi.log)
If one of the log rotation settings (log_rotationtime or log_filesize) are specified then the actual log file name is based on this setting.
If the log file name includes any '%' characters, then it is treated as a format string for strftime(3),
e.g. c:\tomcat\logs\isapi-%Y-%m-%d-%H_%M_%S.log. Otherwise, the suffix .nnnnnnnnnn is automatically added and is the time in seconds.
A full list of format string substitutions can be found in the Apache rotatelogs documentation
A string value for log level
(can be debug, info, warn, error or trace).
This directive was added in version 1.2.31
The time between log file rotations in seconds.
Setting this to 0 (the default) disables log rotation based on time.
This directive was added in version 1.2.31
The maximum log file size in megabytes, after which the log file will be rotated. Setting this to 0 (the default) disables log rotation based on file size.
The value can have an optional M suffix, i.e. both 5 and 5M will rotate the log file when it grows to 5MB.
If log_rotationtime is specified, then this setting is ignored.
A string value which is the full path to workers.properties file
(for example c:\tomcat\conf\workers.properties)
A string value which is the full path to uriworkermap.properties file
(for example c:\tomcat\conf\uriworkermap.properties)
A string value which is the full path to rewrite.properties file
(for example c:\tomcat\conf\rewrite.properties)
A DWORD value size of the shared memory. Set this value to be
the number of all defined workers * 400.
(Set this value only if you have more then 64 workers)
This directive has been added in version 1.2.20
Starting with version 1.2.27 the size of the shared memory is determined
automatically, even for large numbers of workers. This attribute is not
needed any longer.
A DWORD value specifying the time in seconds upon which the
worker_mount_file will be reloaded.
This directive has been added in version 1.2.20
A string value representing a boolean. If it is set to true,
URL session suffixes of the form ";jsessionid=..." get stripped of
URLs, if the are served locally by the web server.
The default value is false.
This directive has been added in version 1.2.21
A DWORD value representing "0" or "1". This is needed because
of minor incompatibilities with IIS 5.1.
By default its value is 1, which means we use the SF_NOTIFY_AUTH_COMPLETE
event. If you set this to 0, then we use SF_NOTIFY_PREPROC_HEADERS.
This might be needed for IIS 5.1 when handling requests using the
PUT HTTP method.
This directive has been added in version 1.2.21
A string value which influences, how URIs are decoded and re-encoded
between IIS and Tomcat. You should leave this at it's default value,
unless you have a very good reason to change it.
If the value is "parsed", the forwarded URI
will be decoded and explicit path components like ".." will already
be resolved. This is less spec compliant and is not safe
if you are using prefix forwarding rules.
If the value is "unparsed", the forwarded URI
will be the original request URI. It's spec compliant and also
the safest option. Rewriting the URI and then forwarding the rewritten
URI will not work.
If the value is "escaped", the forwarded URI
will be the re-encoded form of the URI used by "parsed".
Explicit path components like ".." will already be resolved.
This will not work in combination with URL encoded session IDs.
If the value is "proxy", the forwarded URI
will be a partially re-encoded form of the URI used by "parsed".
Explicit path components like ".." will already be resolved.
and problematic are re-encoded.
The default value since version 1.2.24 is "proxy". Before it was "parsed".
A string value representing a boolean. If it is set to true,
URLs still containing percent signs '%' or backslashes '\'
after decoding will be rejected.
Most web apps do not use such URLs. By enabling reject_unsafe you
can block several well known URL encoding attacks.
The default value is false.
This directive has been added in version 1.2.24
This options is deprecated as of 1.2.44 and will be ignored if used.
Before version 1.2.41 collapsing was never done. Starting with
version 1.2.41 collapsing before looking for unmount matches
is the default to prevent easy bypassing of unmount rules.
As of 1.2.44, collpasing is always performed before looking for mount
or unmount rules.
This directive has been added in version 1.2.41
A DWORD value representing the watchdog thread interval in seconds.
The workers are maintained periodically by a background thread
running periodically every watchdog_interval seconds. Worker maintenance
checks for idle connections, corrects load status and is able
to detect backend health status.
The maintenance only happens, if since the last maintenance at
least worker.maintain
seconds have passed. So setting the watchdog_interval
much smaller than worker.maintain is not useful.
The default value is 0 seconds, meaning the watchdog thread
will not be created, and the maintenance is done in combination
with normal requests instead.
This directive has been added in version 1.2.27
A string value representing the error page url redirection when
backend returns non-200 response. This directive can be used
to customise the error messages returned from backend server.
The url must point to a valid server url and can contain
format string number (%d) that can be used to
separate the pages by error number. The redirect url in that
case is formatted by replacing %d from
error_page to returned error number.
This directive has been added in version 1.2.27
A string value representing a boolean. If it is set to true,
chunked encoding is supported by the server.
The default value is false.
This directive has been added in version 1.2.27. Until version 1.2.30 it
was considered experimental and only available when a special build containing
chunking support was used. Starting with 1.2.30 it is no longer considered
experimental.
A string value representing a boolean. If it is set to true,
data is flushed immediately to the client as each AJP packet is received.
Otherwise, IIS buffers the data and only writes to the client when the buffer
is full or the response is complete.
The default value is false.
This directive has been added in version 1.2.42
The ISAPI redirector can read it's configuration from a properties file instead of the registry.
This has the advantage that you can use multiple ISAPI redirectors with independent configurations on the same server.
The redirector will check for the properties file during initialisation, and use it in preference to the registry if present.
Create a properties file in the same directory as the ISAPI redirector called isapi_redirect.properties i.e.
with the same name as the ISAPI redirector DLL but with a .properties extension.
A sample isapi_redirect.properties can be found under the conf directory.
The property names and values in the properties file are the same as for the registry settings described above. For example:
# Configuration file for the Tomcat ISAPI Redirector
# The path to the ISAPI Redirector Extension, relative to the website
# This must be in a virtual directory with execute privileges
extension_uri=/jakarta/isapi_redirect.dll
# Full path to the log file for the ISAPI Redirector
log_file=c:\tomcat\logs\isapi_redirect.log
# Log level (debug, info, warn, error or trace)
log_level=info
# Full path to the workers.properties file
worker_file=c:\tomcat\conf\workers.properties
# Full path to the uriworkermap.properties file
worker_mount_file=c:\tomcat\conf\uriworkermap.properties
Notes:
Back-slashes - '\' - are not escape characters.
Comment lines begin with '#'.
Starting with version 1.2.27 two environment variables are
automatically added to the environment that can be used inside
.properties files.
JKISAPI_PATH - Full path to the ISAPI Redirector.
JKISAPI_NAME - Name of the ISAPI Redirector dll without extension
# Use the logs in the installation path of ISAPI Redirector
log_file=$(JKISAPI_PATH)\$(JKISAPI_NAME).log
The ISAPI redirector with version 1.2.31 can perform log rotation, with configuration and behaviour similar to the
rotatelogs program provided with Apache HTTP Server.
To configure log rotation, configure a log_file, and one of the log_rotationtime or log_filesize options.
If both are specified, the log_rotationtime will take precedence, and log_filesize will be ignored.
For example, to configure daily rotation of the log file:
# Configuration file for the Tomcat ISAPI Redirector
...
# Full path to the log file for the ISAPI Redirector
log_file=c:\tomcat\logs\isapi_redirect.%Y-%m-%d.log
# Log level (debug, info, warn, error or trace)
log_level=info
# Rotate the log file every day
log_rotationtime=86400
...
Or to configure rotation of the log file when it reaches 5MB in size:
# Configuration file for the Tomcat ISAPI Redirector
...
# Full path to the log file for the ISAPI Redirector
log_file=c:\tomcat\logs\isapi_redirect.%Y-%m-%d-%H.log
# Log level (debug, info, warn, error or trace)
log_level=info
# Rotate the log file at 5 MB
log_filesize=5M
...
The log will be rotated whenever the configured limit is reached, but only if the log file name would change. If you configure
a log file name with strftime(3) format codes in it, then ensure it specifies the same granularity
as the rotation time configured, e.g. %Y-%m-%d if rotating daily (log_rotationtime=86400).
See the rotatelogs documentation for more examples.
The ISAPI redirector with version 1.2.16 can do a simple URL rewriting. Although not
as powerful as Apache HTTP Server's mod_rewrite, it allows a simple exchange of request URIs
The rule is in the form original-url-prefix=forward-url-prefix. For example:
# Simple rewrite rules, making examples
# available under shorter URLs
/jsp/=/examples/jsp/
/servlets/=/examples/servlets/
You can also use regular expressions, if you prefix the rule with a tilde ~:
# Complex rewrite rule, prefixing "/examples/"
# to the first path component of all requests
~/([^/]*)=/examples/$1
Note that uriworkermap.properties must use the URLs before rewriting.
A Tomcat worker is a Tomcat instance that is waiting to execute servlets or any other content
on behalf of some web server. For example, we can have a web server such as
the Apache HTTP Server forwarding servlet requests to a Tomcat process (the worker) running behind it.
The scenario described above is a very simple one;
in fact one can configure multiple Tomcat workers to serve servlets on
behalf of a certain web server.
The reasons for such configuration can be:
We want different contexts to be served by different Tomcat workers to provide a
development environment where all the developers share the same web server but
own a Tomcat worker of their own.
We want different virtual hosts served by different Tomcat processes to provide a
clear separation between sites belonging to different companies.
We want to provide load balancing, meaning run multiple Tomcat workers each on a
machine of its own and distribute the requests between them.
There are probably more reasons for having multiple workers but I guess that this list is enough...
Tomcat workers are defined in a properties file dubbed workers.properties and this tutorial
explains how to work with it.
Defining workers to the Tomcat web server plugin can be done using a properties file
(a sample file named workers.properties is available in the conf/ directory).
The lines in the file define properties. The general format is
<name>=<value>
Dots are used as part of the name to represent a configuration hierarchy.
Invalid directives will be logged during web server startup and prevent the web server
from working properly. Some directives have been deprecated. Although they will
still work, you should replace them by their
successors.
Some directives are allowed multiple times. This will be explicitly
noted in the tables below.
Whitespace at the beginning and the end of a property name or value gets ignored.
Comments can be placed in any line and start with a hash sign '#'.
Any line contents behind the hash sign get ignored.
Boolean properties can be set either using the numbers 0 (false) and 1 (true)
as values, or off (false) and on (true) or any other string starting with the
letters f (false), n (false), t (true) or y (true).
The values are taken case insensitive. In this documentation we will stick
to false and true.
These directives have global scope.
A comma separated list of workers names that the JK will use. When starting up,
the web server plugin will instantiate the workers whose name appears in the
worker.list property, these are also the workers to whom you can map requests.
This directive can be used multiple times.
Worker connection pool maintain interval in seconds. If set to the positive
value JK will scan all connections for all workers specified in worker.list
directive and check if connections needs to be recycled.
Furthermore any load balancer does a global maintenance every worker.maintain
seconds. During global maintenance load counters are decayed and workers
in error are checked for recover_time.
This feature has been added in jk 1.2.13.
Each worker configuration directive consists of three words separated by a dot:
worker.<worker name>.<directive>=<value>
The first word is always worker.
The second word is the worker name you can choose. In the case of load balancing,
the worker name has an additional meaning. Please consult the
Load Balancer HowTo.
The name of the worker can contain only the alphanumeric characters
[a-z][A-Z][0-9][_\-] and is case sensitive.
You can define and use variables in the workers.properties file.
To define a variable you use the syntax:
<variable_name>=<value>
Dots are allowed in the variable name, but you have to be careful
not to use variable names, that clash with standard directives.
Therefore variable names should never start with "worker.".
To use a variable, you can insert "$(variable_name)" at any place
on the value side of a property line. If a variable has not been
defined before its use, we will search the process environment for
a variable with the same name and use their value.
Often one wants to use the same property values for various workers.
To reduce duplication of configuration lines and to ease the maintenance of
the file, you can inherit properties from one worker to another, or even
from a template to real workers.
The directive "reference" allows to copy configurations between workers or
worker templates in a hierarchical way. If worker castor sets
worker.castor.reference=worker.pollux then it inherits all properties
of pollux, except for the ones that are explicitly set for castor.
Please note, that the value of the directive is not only the name of the referred worker,
but the complete prefix including "worker.".
To use a template worker simply define it like a real worker, but do not add it
to the "worker.list" or as a member to any load balancer. Such a template worker
does not have to contain mandatory directives. This approach is especially useful,
if one has a lot of balanced workers in a load balancer
and these workers share most of their properties. You can set all of these properties
in a template worker, e.g. using the prefix "worker.template1", and then simply
reference those common properties in all balanced workers.
References can be used to inherit properties over multiple hops in a hierarchical way.
The maximum depth for nesting references is 20. Be careful not to introduce a reference
loop!
This feature has been added in jk 1.2.19.
Mandatory directives are the one that each worker must contain. Without them the worker will
be unavailable or will misbehave. Those directives will be marked with a strong font in the following tables.
Type of the worker (can be one of ajp12, ajp13, ajp14, jni, lb or status). The type of the worker
defines the directives that can be applied to the worker.
Type ajp13 is the preferred worker type that JK uses for communication
between web server and Tomcat. This type of worker uses sockets as communication
channel. For detailed description of the ajp13 protocol stack browse to
AJPv13 protocol specification. Type lb is
used for load balancing workers,
type status for status workers.
Type ajp14 is experimental and not recommended, type ajp12
is obsolete.
JNI workers are no longer supported and will likely not work. Do not use them.
Connection directives defines the parameters needed to connect and maintain
the connections pool of persistent connections between JK and remote Tomcat.
Host name or IP address of the backend Tomcat instance. The remote Tomcat must
support the AJP13 protocol stack. The host name can have a port number
embedded separated by the colon (':') character.
Port number of the remote Tomcat instance listening for defined protocol requests.
The default value depends on the worker type. For ajp13 workers the default port is
8009, while for ajp14 type of worker that value is 8011.
Name or IP address used for the connection source (outgoing address).
It should only be used on multi-homed hosts.
This feature is experimental and has been added in jk 1.2.41.
Socket timeout in seconds used for the communication channel between JK and remote host.
If the remote host does not respond inside the timeout specified, JK will generate an error,
and retry again. If set to zero (default) JK will wait for an infinite amount of time
on all socket operations.
Socket connect timeout in milliseconds used for the communication channel between JK and remote host.
If the remote host does not respond inside the timeout specified, JK will generate an error,
and retry again.
Note that socket_timeout is in seconds, and
socket_connect_timeout in milliseconds,
so in absolute terms the default socket_connect_timeout is
equal to "socket_timeout.
This feature has been added in jk 1.2.27.
This directive should be used when you have a firewall between your web server
and the Tomcat engine, who tend to drop inactive connections. This flag will tell the Operating System
to send KEEP_ALIVE messages on inactive connections (interval depend on global OS settings,
generally 120 minutes), and thus prevent the firewall to cut inactive connections.
To enable keepalive set this property value to true.
The problem with Firewall cutting inactive connections is that sometimes, neither web server or Tomcat
have information about the cut and couldn't handle it.
This flag determines, under which conditions established
connections are probed to ensure they are still working.
The probe is done with an empty AJP13 packet (CPing) and
expects to receive an appropriate answer (CPong) within
some timeout.
The value of the flag can be any combination of the following
flags (multiple values are combined without any separators):
C (connect): If set, the connection will
be probed once after connecting to the backend. The timeout
can be set by connect_timeout. If it is not set,
the value of ping_timeout will be used instead.
P (prepost): If set, the connection will
be probed before sending each request to the backend. The timeout
can be set by prepost_timeout. If it is not set,
the value of ping_timeout will be used instead.
I (interval): If set, the connection will
be probed during the regular internal maintenance cycle,
but only if it is idle longer than
connection_ping_interval. The timeout
can be set by ping_timeout.
A If set, all of the above probes will be used.
This feature has been added in jk 1.2.27. Connect and
prepost probing were already available via connect_timeout
and prepost_timeout since version jk 1.2.6.
Timeout in milliseconds used when waiting for the CPong answer of a
CPing connection probe. The activation of the probes is done via
ping_mode. The timeouts for ping_mode
connect and prepost can be overwritten individually via
connect_timeout and prepost_timeout.
For compatibility reasons, CPing/CPong is also used, whenever
connect_timeout or prepost_timeout are set,
even if ping_mode is empty.
This feature has been added in jk 1.2.27.
The usage depend on the ping_mode flags used.
directive connection_ping_interval was not set, the
value of (ping_timeout/1000) * 10 will be used as
connection_ping_interval value.
When using interval connection probing, connections idle for longer than this
interval in seconds are probed by CPing packets whether they still work.
Interval probing can be activated either by ping_mode,
or by setting connection_ping_interval to some value bigger
than zero. If you activate interval probing via ping_mode,
then the default value of connection_ping_interval is
(ping_timeout/1000) * 10. Note that ping_timeout
is in milliseconds, and connection_ping_interval in seconds,
so in absolute terms the default connection_ping_interval is
10 times ping_timeout.
This feature has been added in jk 1.2.27.
This defines the number of connections made to the AJP backend that
are maintained as a connection pool.
It will limit the number of those connection that each web server child
process can made.
Connection pool size property is only used for multi threaded
web servers such as the Apache HTTP Server, Microsoft IIS and the iPlanet Web Server.
The connection_pool_size property
needs to reflect the number of requests one web server process should
be able to send to a backend in parallel. Usually this is the same as
the number of threads per web server process. JK will discover
this number for the Apache HTTP Server automatically and set the pool size to
this value. For IIS the default value is 250 (before version 1.2.20: 10),
for iPlanet the default value is 1.
We strongly recommend adjusting this value for IIS and iPlanet
to the number of requests one web server process should
be able to send to a backend in parallel. You should measure how many connections
you need during peak activity without performance problems, and then add some
percentage depending on your growth rate. Finally you should check,
whether your web server processes are able to use at least as many threads,
as you configured as the pool size.
Do not use connection_pool_size with values higher then 1 on Apache 2.x with prefork MPM or Apache 1.3.x!
Minimum size of the connection pool that will be maintained.
Its default value is (connection_pool_size+1)/2.
Do not use connection_pool_minsize with values higher then 1 on Apache 2.x with prefork MPM or Apache 1.3.x!
This feature has been added in jk 1.2.16.
Cache timeout property should be used with connection_pool_minsize to specify how many seconds JK should keep
an inactive socket in cache before closing it. This property should be used to reduce the number of threads
on the Tomcat web server. The default value zero disables the closing (infinite timeout).
Each child could open an ajp13 connection if it has to forward a request to Tomcat, creating
a new ajp13 thread on Tomcat side.
The problem is that after an ajp13 connection is created, the child won't drop it
until killed. And since the web server will keep its childs/threads running
to handle high-load, even it the child/thread handle only static contents, you could
finish having many unused ajp13 threads on the Tomcat side.
You should keep this time interval in sync with the keepAliveTimeout attribute
(if it is set explicitly) or connectionTimeout attribute
of your AJP connector in Tomcat's server.xml. Note however, that the value
for mod_jk is given in seconds, the one in server.xml has to use milliseconds.
Timeout the worker will wait for a free socket in cache before giving up.
Its default value is retries * retry_interval.
This feature has been added in jk 1.2.27.
Only used for a member worker of a load balancer.
The integer number lbfactor (load balancing factor) is
how much we expect this worker to work, or
the worker's work quota. Load balancing factor is compared with other workers
that makes the load balancer. For example if one worker has lb_factor 5 times higher then
other worker, then it will receive five times more requests.
Load balancer is a virtual worker that does not really communicate with Tomcat workers.
Instead it is responsible for the management of several "real" workers.
The worker is supposed to be a load balancer if it's worker type is lb.
See worker's type directive.
Loadbalancer directives define the parameters needed to create the workers that are
connecting to a remote cluster of backend Tomcat servers. Each cluster node has to
have a worker defined.
Load balancer management includes:
Instantiating the workers in the web server.
Using the worker's load balancing factor, perform weighted round-robin load balancing where
high lbfactor means stronger machine (that is going to handle more requests)
Keeping requests belonging to the same session executing on the same Tomcat worker.
Identifying failed Tomcat workers, suspending requests to them and instead fail over on
other workers managed by the lb worker.
The overall result is that workers managed by the same lb worker are load balanced
(based on their lbfactor and current user session) and also fail over so a single
Tomcat process death will not "kill" the entire site.
If you want to use session stickiness, you must set different jvmRoute attributes
in the Engine element in Tomcat's server.xml. Furthermore the names of the workers
which are managed by the balancer have to be equal to the jvmRoute of the Tomcat
instance they connect with.
The restriction on the worker names can be lifted, if you use the route attribute for the workers.
The following table specifies properties that the lb worker can accept:
A comma separated list of workers that the load balancer
need to manage.
This directive can be used multiple times for the same load balancer.
This directive replaces old balanced_workers directive and
can be used only with mod_jk versions 1.2.7 and up.
As long as these workers should only be used via the load balancer worker,
there is no need to also put them into the worker.list property.
Specifies whether requests with SESSION ID's should be routed back to the same
Tomcat worker. If sticky_session is set to true sessions are sticky, otherwise
sticky_session is set to false. Set sticky_session to false when Tomcat
is using a Session Manager which can persist session data across multiple
instances of Tomcat.
The sticky_session setting can be overwritten using the Apache HTTP Server
environment variable JK_STICKY_IGNORE and the worker map extension for
sticky_ignore. This has been added in version 1.2.33.
Specifies whether requests with SESSION ID's for workers that are in error state
should be rejected. If sticky_session_force is set to true
and the worker that matches that SESSION ID is in error state, client will
receive 500 (Server Error). If set to false failover on
another worker will be issued with losing client session. This directive is
used only when you set sticky_session=true.
This feature has been added in jk 1.2.9.
Specifies what method load balancer is using for electing the best worker.
Please note, that session stickiness and perfect load balancing are
conflicting targets, especially when the number
of sessions is small, or the usage of sessions is extremely varying
For huge numbers of sessions this usually is not a problem.
Some methods note, that they aggregate in a sliding time window. They add up
accesses, and on each run of the global maintain method, the load counters
get divided by 2. Usually this happens once a minute, depending on the
setting of worker.maintain. The value of the load counters can be inspected
using the status worker.
If method is set to R[equest] the balancer will use the number of requests
to find the best worker. Accesses will be distributed according to the
lbfactor in a sliding time window. This is the default value and should be
working well for most applications.
If method is set to S[ession] the balancer will use the number of sessions
to find the best worker. Accesses will be distributed according to the
lbfactor in a sliding time window. This method should be used,
if sessions are your limiting resource, e.g. when you only have limited memory
and your sessions need a lot of memory. Because the balancer does not keep any state,
it actually does not know the number of sessions. Instead it counts each request
without a session cookie or URL encoding as a new session. This method will neither
know, when a session is being invalidated, nor will it correct its load numbers
according to session timeouts or worker failover. If you know request URLs, that will be
called without a session ID but should not be counted as new sessions, you should
add them to the stateless mapping rule extension or set the Apache HTTP Server
environment variable JK_STATELESS for them.
If method is set to N[ext] the balancer will again use the number of sessions
to find the best worker. All remarks concerning the Sessionmethod apply as well.
The difference to the Session method is how the session count is handled in the
sliding time window. The Next method does not divide by 2, instead it subtracts
the current minimum number. This should effectively result in a round-robin session
balancing, thus the name Next. Under high load, the two session balancing
methods will result in a similar distribution, but Next will be better
if you need to distribute small numbers of sessions.
If set to T[raffic] the balancer will use
the network traffic between JK and Tomcat to find the best worker.
Accesses will be distributed according to the lbfactor in a sliding time window.
This method should be used, if network to and from the backends is your
limiting resource.
If set to B[usyness] the balancer will
pick the worker with the lowest current load, based on how many requests the
worker is currently serving. This number is divided by the workers lbfactor,
and the lowest value (least busy) worker is picked. This method is especially
interesting, if your request take a long time to process, like for a download
application. The method is not recommended for general use, because under high
load on some hardware architectures the busy counter can become wrong.
This feature has been added in version 1.2.9.
The Session method has been added in version 1.2.20,
the Next method in version 1.2.33.
Specifies what lock method the load balancer will use for synchronising
shared memory runtime data.
If lock is set to O[ptimistic] balancer will not use shared memory lock
to find the best worker. If set to P[essimistic] balancer will use
shared memory lock. The balancer will work more accurately in case of
Pessimistic locking, but can slow down the average response time.
This feature has been added in jk 1.2.13.
This directive also exists for normal workers.
For those it has a different
meaning.
When making a request, the load-balancer worker will allocate the request to a
member worker. If that member worker is either unable to service the request or
fails to service the request, the request will be passed to another member
worker until the request is processed, every member worker has attempted to
process the request or lb_retries member workers have attempted to
process the request.
If the request remains unprocessed, the load-balancer worker will repeat the
above process a maximum of retries times (including the original
attempt). Before each retry, the load-balancer worker will pause for a time
defined by the retry_interval directive.
Note that this means that, if all workers fail, there will be a total of
worker.retries * min(lb.lb_retries,member worker count) * lb.retries requests
before a 504 response is returned to the client. So for an lb worker with four
members and a default configuration, if all workers fail there will be a total
of 8 requests before a 504 response is returned to the client.
Until version 1.2.16 the default value was 3.
When making a request, the load-balancer worker will allocate the request to a
member worker. If that member worker is either unable to service the request or
fails to service the request, the request will be passed to another member
worker until the request is processed, every member worker has attempted to
process the request or lb_retries member workers have attempted to
process the request.
If the request remains unprocessed, the load-balancer worker will repeat the
above process a maximum of retries times (including the original
attempt). Before each retry, the load-balancer worker will pause for a time
defined by the retry_interval directive.
Note that this means that, if all workers fail, there will be a total of
worker.retries * min(lb.lb_retries,member worker count) * lb.retries requests
before a 504 response is returned to the client. So for an lb worker with four
members and a default configuration, if all workers fail there will be a total
of 8 requests before a 504 response is returned to the client.
This feature has been added in jk 1.2.44. Prior to this feature being
added, the load-balancer worker behaved as if lb_retries was equal to the
number of member workers.
The status worker does not communicate with Tomcat.
Instead it is responsible for the load balancer management.
Specifies the url for cascading stylesheet to use.
A status worker with read_only=true will not allow any operations,
that change the runtime state or configuration of the other workers.
These are edit/update/reset/recover.
This feature has been added in jk 1.2.20.
It is a list of users
which gets compared to the user name authenticated by the web server.
If the name is not contained in this list, access is denied. Per
default the list is empty and then access is allowed to anybody.
This directive can be used multiple times.
This feature has been added in jk 1.2.20.
By default, the user names are matched case sensitively. You can set
user_case_insensitive=true to make the comparison case insensitive.
This may be especially useful on the Windows platform.
This feature has been added in jk 1.2.21.
For every load balancer worker, the status worker shows a summary
of the state of its members. There are three such states,
"good", "bad" and "degraded".
These states are determined depending on the activation of the members
(active, disabled, stopped) and their runtime state
(ok, n/a, busy, recovering, probing, forced recovery, error).
By default, members are assumed to be "good", if their activation
is "active" and their runtime state is not "error".
You can change this mapping, by assigning a list of values to the
attribute "good". Each value gives a possible match for the members,
and one match suffices. Each value is either a single character, or two
characters combined with a dot ".". The single characters are the
first characters in the words "active", "disabled", "stopped",
"ok", "na", "busy", "recovering", "error". The additional states "probing"
and "forced recovery" are always rated equivalent to "recovering".
If a value consists only
of a single character, then all members with this activation or runtime
state will be assumed good. A combination of an activation and a runtime
state concatenated with a dot "." does only apply to a member, that has
exactly this activation and state.
Members of a load balancer will first be matched against the state "bad",
if they don't match, the state "good" will be tried, and if they
still don't match, their state will be "degraded".
This directive can be used multiple times.
This feature has been added in jk 1.2.20.
See: "good".
By default, members are assumed to be "bad", if their activation
is "stopped" or their runtime state is "error".
This directive can be used multiple times.
This feature has been added in jk 1.2.20.
The prefix, which will be used by the status worker
when producing properties output (mime=prop).
Each property key will be prefixed by this value.
This feature has been added in jk 1.2.20.
This directive can be used to customise the XML output from the
status worker. If set to - no namespace will be used.
This feature has been added in jk 1.2.20.
This directive can be used to customise the XML output from the
status worker. If set to - no xmlns will be used.
Default value is set to xmlns:jk="http://tomcat.apache.org"
This feature has been added in jk 1.2.20.
This directive can be used to customise the XML output from the
status worker. This value will be inserted to the output xml
after the xml header.
This feature has been added in jk 1.2.20.
This table lists more advanced configuration options. Most of them only apply to
some types of workers. We use the abbreviations AJP for ajp13/ajp14 workers
used directly via the workers.list, LB for load balancer workers,
and SUB for the workers used indirectly in a load balancer worker
as a sub worker or member.
Connect timeout property told web server to send a PING request on ajp13 connection after
connection is established. The parameter is the delay in milliseconds to wait for the PONG reply.
The default value zero disables the timeout (infinite timeout).
This features has been added in jk 1.2.6 to avoid problem with hung Tomcat's and require ajp13
ping/pong support which has been implemented on Tomcat 3.3.2+, 4.1.28+ and 5.0.13+.
Disabled by default.
Prepost timeout property told web server to send a PING request on ajp13 connection before
forwarding to it a request. The parameter is the delay in milliseconds to wait for the PONG reply.
The default value zero disables the timeout (infinite timeout).
This features has been added in jk 1.2.6 to avoid problem with hung Tomcat's and require ajp13
ping/pong support which has been implemented on Tomcat 3.3.2+, 4.1.28+ and 5.0.13+.
Disabled by default.
The parameter is the number of milliseconds to wait for success during a read event.
So this is not a timeout for the complete answer time of a request, but only
for the maximum time between two packets received from Tomcat. Usually the longest
pause is between sending the request and getting the first packet of the response.
If the timeout passes without any data received from Tomcat, the web server will
no longer wait for the rest of the response and send an error to the client (browser).
Usually this does not mean, that the request is also aborted on the Tomcat backend.
If the worker is a member of a load balancer, the load balancer might place the
worker into an error state and retry the request on another member.
See also max_reply_timeouts, retries and recovery_options.
By default (value zero) the web server will wait forever which could be an issue for you.
If you set a reply_timeout, adjust it carefully if you have long running servlets.
The reply_timeout can be overwritten using the Apache HTTP Server environment variable
JK_REPLY_TIMEOUT and the worker map extension for reply_timeout.
This features has been added in jk 1.2.6 to avoid problem with hung Tomcat's and
works on all servlet engines supporting ajp13.
The variable JK_REPLY_TIMEOUT and the worker map
extension have been added in version 1.2.27.
This directive also exists for load balancer workers.
For those it has a different meaning.
The maximum number of times that the worker will send a request to Tomcat
in case of a communication error. Each retry will be done over another
connection. The first time already gets counted, so retries=2 means
one retry after error. Before a retry, the worker waits for a configurable
sleeping time.
See also the attribute recovery_options for a more fine-grained control
of retries and retry_interval for the sleep time configuration.
Until version 1.2.16 the default value was 3.
The amount of time in milliseconds the worker sleeps before doing any retry.
This features has been added in jk 1.2.27.
Recovery options influence, how we should handle retries,
in case we detect a problem with Tomcat.
How often we will retry is controlled by the attribute retries.
This attribute is a bit mask. The following bits are allowed:
1: don't recover if Tomcat failed after getting the request
2: don't recover if Tomcat failed after sending the headers to client
4: close the connection to Tomcat, if we detect an error when writing back
the answer to the client (browser)
8: always recover requests for HTTP method HEAD (even if Bits 1 or 2 are set)
16: always recover requests for HTTP method GET (even if Bits 1 or 2 are set)
This features has been added in jk 1.2.6.
Option 4 has been added in version 1.2.16,
options 8 and 16 in version 1.2.24.
Set this value to the HTTP status code that will cause a worker to fail
if returned from Servlet container. Use this directive to deal with
cases when the servlet container can temporary return non-200 responses
for a short amount of time, e.g during redeployment.
The error page, headers and status codes of the original response will not be send back
to the client. Instead the request will result in a 503 response.
If the worker is a member of a load balancer, the member will
be put into an error state. Request failover and worker recovery will be handled
with the usual load balancer procedures.
This feature has been added in jk 1.2.20.
Starting with jk 1.2.22 it is possible to define multiple
status codes separated by space or comma characters.
For example: worker.xxx.fail_on_status=500,503
Starting with jk 1.2.25 you can also tell the load
balancer to not put a member into an error state, if a
response returned with one of the status codes in
fail_on_status. This feature gets enabled, by putting a minus sign in
front of those status codes.
For example: worker.xxx.fail_on_status=-404,-500,503
If set to a positive number, the worker will only be used for a request,
if it is currently working on less than this number of concurrent requests.
Note that this is not related to the Busyness load balancing
method.
This feature is experimental and has been added in jk 1.2.41.
This attribute sets the maximal AJP packet size in Bytes. It should be a
multiple of 1024. Configuration values that are not a multiple of 1024 will be
aligned to the next multiple of 1024. The maximum value is 65536. If you change
it from the default, you must also change the packetSize attribute of
your AJP connector on the Tomcat side! The attribute packetSize is available in
Tomcat 6.0.2 onwards.
Normally it is not necessary to change the maximum packet size. Problems
with the default value have been reported when sending certificates or
certificate chains.
This feature has been added in jk 1.2.19.
When compiled with IPV6 support, this directive forces IPV6 address
resolution for host names which have both IPV6 and IPV4 addresses. In case there is
no IPV6 address defined for the given hostname this directive in ineffective. This directive will
be also ineffective if there is only IPV6 address defined or if IP address is used for "host",
either in IPV4 or IPV6 notation.
This feature has been added in jk 1.2.38.
You can set a secret keyword on the Tomcat AJP Connector. Then only requests
from workers with the same secret keyword will be accepted.
Use attribute secret="secret key word" in your Tomcat AJP Connector configuration.
(Historical note: the attribute name was requiredSecret in Tomcat
9.0, 8.x, 7.0 versions released earlier than February 2020,
request.secret in Tomcat 6.0 and earlier.)
If you set a secret on a load balancer, all its members will inherit this secret.
This feature has been added in jk 1.2.12.
Space delimited list of uri maps the worker should handle. It is only used,
if the worker is included in worker.list.
This directive can be used multiple times for the same worker.
If you use a reply_timeout for the members of a load balancer worker,
and you want to tolerate a few requests taking longer than reply_timeout,
you can set this attribute to some positive value.
Long running requests will still time out after reply_timeout milliseconds waiting for
data, but the corresponding member worker will only be put into an error state,
if more than max_reply_timeouts requests have timed out.
More precisely, the counter for those bad requests will be divided by two,
whenever the load balancer does its internal maintenance (by default every 60
seconds).
This features has been added in jk 1.2.24 to make reply_timeout less
sensitive for sporadic long running requests.
The recover time is the time in seconds the load balancer will not try
to use a worker, after it went into error state. Only after this time has passed,
a worker in error state will be marked as in recovering, so that it will be
tried for new requests.
This interval is not checked every time a request is being processed.
Instead it is being checked during global maintenance. The time between two
runs of global maintenance is controlled by worker.maintain.
Do not set recover_time to a very short time unless you understand the implications.
Every recovery attempt for a worker in error is done by a real request!
Setting a member of a load balancer into an error state is quite serious. E.g.
it means that if you need stickyness, all access to the sessions of the
respective node is blocked.
Some types of error detection do not provide a precise information, whether
a node is completely broken or not. In those cases an LB will not immediately
put the node into the error state. Only when there have been no successful
responses for error_escalation_time seconds after such an error,
will the node be put into error state.
This features has been added in jk 1.2.28.
The name of the cookie that contains the routing identifier needed for session stickyness.
The routing identifier is everything after a "." character in the value of the cookie.
This feature has been added in jk 1.2.27.
The name of the path parameter that contains the routing identifier needed for
session stickyness. The routing identifier is everything after a "." character in the value
of the path parameter.
This feature has been added in jk 1.2.27.
Activates generation of session stickyness cookies. Typically you don't need this.
Some web frameworks replace Tomcat session management and use a different way
of generating session IDs. As a consequence the routing ID added by Tomcat to the
end of the session ID is lost and we no longer can do sticky load balancing.
As a workaround you can use the following steps:
Choose a non-standard cookie name using the "session_cookie" attribute.
Activate cookie sending by setting the attribute "set_session_cookie" to true.
Set the attribute "session_cookie_path" to the correct application URI, like
e.g. "/myapp/".
The cookie will only be send if the request does not already contain
a cookie of the same name, or that cookie does not contain a routing
ID which the load balancer can fulfill. Especially after a node failover
we will send a new cookie to switch stickyness to the new node.
This feature has been added in jk 1.2.38.
This attribute is only used if "set_session_cookie" is set to true.
See "set_session_cookie" for a description. If the value of "session_cookie_path"
is empty (default), then the send cookie will not contain a PATH information.
This feature has been added in jk 1.2.38.
Using this directive, a balanced worker of a load balancer
can be configured as disabled or stopped. A disabled worker only gets
requests, which belong to sessions for that worker. A stopped
worker does not get any requests. Users of a stopped worker will
lose their sessions, unless session replication via clustering is used.
Use d or D to disable and s or S to stop.
If this directive is not present the deprecated directives
"disabled" or "stopped" are used.
This flag can be changed at runtime using status worker.
This feature has been added in jk 1.2.19.
Normally the name of a balanced worker in a load balancer is equal to the jvmRoute
of the corresponding Tomcat instance. If you want to include a worker corresponding
to a Tomcat instance into several load balancers with different balancing configuration
(e.g. disabled, stopped) you can use this attribute.
Define a separate worker per lb and per Tomcat instance with an arbitrary worker name and
set the route attribute of the worker equal to the jvmRoute of the target Tomcat instance.
If this attribute is left empty, the name of the worker will be used.
This attribute can be changed at runtime using status worker.
If the route name contains a period, the part before the first period will be
used as domain name, unless domain is set explicitly.
This feature has been added in jk 1.2.16.
The automatic domain rule has been added in jk 1.2.20.
The attribute has been renamed from jvm_route to route in jk 1.2.20.
An integer number to express preferences between
the balanced workers of an lb worker.
A load balancer will never choose some balanced worker
in case there is another usable worker with lower distance.
Only in case all workers below a given distance are in error, disabled or stopped,
workers of a larger distance are eligible for balancing.
This feature has been added in jk 1.2.16.
Domain directive can be used only when the worker is a member of the load balancer.
Workers that share the same domain name are treated as single worker. If sticky_session
is used, then the domain name is used as session route.
This directive is used for large system with more then 6 Tomcats, to be able
to cluster the Tomcats in two groups and thus lowering the session replication
transfer between them.
This feature has been added in jk 1.2.8.
Set to the name of the preferred failover worker. If worker matching
SESSION ID is in error state then the redirect worker will be used instead.
It will be used even if being disabled, thus offering hot standby.
If you explicitly set a route via the "route" attribute, you must set "redirect"
to this route of the preferred failover worker and not to its name.
This feature has been added in jk 1.2.9.
The following directives have been deprecated in the past. We include their documentation
in case you need to use an older version of mod_jk. We urge you to update and not use
them any more. Please migrate your existing configurations.
This directive has been deprecated since 1.2.16.
Cachesize defines the number of connections made to the AJP backend that
are maintained as a connection pool.
It will limit the number of those connection that each web server child
process can make.
Cachesize property is used only for multi threaded
web servers such as Apache HTTP Server 2.x (all MPMs except prefork), IIS and iPlanet. The cachesize property
should reflect the number of threads per child process. JK will discover
the number of threads per child process on the Apache HTTP Server with threaded MPM and set
its default value to match the current ThreadsPerChild Apache configuration. For IIS the default
value is 10. For web servers other than Apache or IIS this value has to be set manually.
Do not use cachesize with values higher then 1 on Apache 2.x with prefork MPM or Apache 1.3.x!This directive has been deprecated since 1.2.16.
Cache timeout property should be used with cachesize to specify how to time JK should keep
an open socket in cache before closing it. This property should be used to reduce the number of threads
on the Tomcat web server.
Each child could open an ajp13 connection if it have to forward a request to Tomcat, creating
a new ajp13 thread on Tomcat side.
The problem is that after an ajp13 connection is created, the child won't drop it
until killed. And since the web server will keep its childs/threads running
to handle high-load, even it the child/thread handle only static contents, you could
finish having many unused ajp13 threads on the Tomcat side.
This directive has been deprecated since 1.2.16.
The number of seconds that told web server to cut an ajp13 connection after some time of
inactivity. When choosing an endpoint for a request and the assigned socket is open, it will be
closed if it was not used for the configured time.
It's a good way to ensure that there won't too old threads living on Tomcat side,
with the extra cost you need to reopen the socket next time a request be forwarded.
This property is very similar to cache_timeout but works also in non-cache mode.
If set to value zero (default) no recycle will took place.
This directive has been deprecated since 1.2.7.
A comma separated list of workers that the load balancer
need to manage.
This directive has been deprecated since 1.2.19.
If set to true the worker will be disabled if member
of load balancer. This flag can be changed at runtime using status worker.
This feature has been added in jk 1.2.9.
This directive has been deprecated since 1.2.19.
If set to true the worker will be stopped if member
of load balancer. The flag is needed for stop complete traffic of a sticky session
worker. It is only useful, when you have a cluster that replicated the sessions.
This flag can be changed at runtime using status worker.
This feature has been added in jk 1.2.11.
This directive has been deprecated since 1.2.20.
Normally the name of a balanced worker in a load balancer is equal to the jvmRoute
of the corresponding Tomcat instance. If you want to include a worker corresponding
to a Tomcat instance into several load balancers with different balancing configuration
(e.g. disabled, stopped) you can use this attribute.
Define a separate worker per lb and per Tomcat instance with an arbitrary worker name and
set the jvm_route attribute of the worker equal to the jvmRoute of the target Tomcat instance.
If this attribute is left empty, the name of the worker will be used.
This attribute can be changed at runtime using status worker.
The forwarding of requests from the web server to tomcat gets configured by defining mapping rules.
Such a rule maps requests to workers. The request part of the map is described by a URI pattern,
the worker by it's worker name.
The so-called uriworkermap file is a mechanism of defining rules,
which works for all web servers. There exist also other web server specific configuration
options for defining rules, which will be mostly discussed on the reference pages for
configuring tomcat connectors for the individual web servers.
The name of the file is usually uriworkermap.properties,
although this is configurable in the web server.
Please consult the web server specific documentation pages on
how to enable the uriworkermap file.
The main features supported by the uriworkermap file are
Support for comments in the rule file.
Exact and wildchar matches, shortcuts to map a directory and all including content.
Exclusion rules, disabling of rules and rule priorities.
Rule extensions, modifying worker behaviour per rule.
Virtual host integration: uri mapping rules can be expressed per virtual host.
The details are web server specific though.
Dynamic reloading: The file gets checked periodically for changes.
New versions are automatically reloaded without web server restarts.
Integration with the status worker.
The following sections describe these aspects in more detail.
The file has a line based format. There are no continuation characters,
so each rule needs to be defined on a single line. Each rule is a pair consisting
of a URI pattern and a worker name, combined by an equals sign '=':
/myapp=myworker
The URI pattern is case sensitive.
All text after and including the character '#' gets ignored and can be used for comments.
Leading and trailing white space gets trimmed around the URI pattern and also around the worker name.
The following definitions are all equivalent:
# This is a white space example
/myapp=myworker
/myapp=myworker
/myapp = myworker
Inside the URI pattern three special characters can be used, '*', '?' and '|'.
The character '*' is a wildchar that matches any number of arbitrary characters
in the URI, '?' matches exactly one character.
Each URI pattern has to start with the character '/', or with '*' or with '?',
optionally prefixed by any combination of the modifiers '!' and '-' (see next section).
# Mapping the URI /myapp1 and everything under /myapp1/:
/myapp1=myworker-a
/myapp1/*=myworker-a
# Mapping all URI which end with a common suffix:
*.jsp=myworker
*.do=myworker
Since the first case of mapping a certain location and everything inside
it is very common, the character '|' gives a handy shortcut:
# Mapping the URI /myapp1 and everything under /myapp1/:
/myapp1|/*=myworker-a
The pattern 'X|Y' is exactly equivalent to the two maps 'X' and 'XY'.
Exclusion rules allows to define exclusions from URI rules, which would forward
requests to tomcat. If the exclusion rule matches, the request will not be forwarded.
This is usually used to serve static content by the web server.
A rule is an exclusion rule, if it is suffixed with '!':
# Mapping the URI /myapp and everything under /myapp/:
/myapp|/*=myworker
# Exclude the subdirectory static:
!/myapp/static|/*=myworker
# Exclude some suffixes:
!*.html=myworker
An exclusion rule overrides a normal mapping rule only, if the worker names in the
normal rule and in the exclusion rule are the same. Starting with version 1.2.26 of JK
you can apply an exclusion rule to any worker, by using the star character '*' as
the worker name in the exclusion rule.
More complex patterns in exclusion worker names are not allowed.
# Mapping the webapps /myapp1 and /myapp2:
/myapp1|/*=myworker1
/myapp2|/*=myworker2
# Exclude the all subdirectories static for all workers:
!/*/static|/*=*
# Exclude some suffixes for all workers:
!*.html=*
Rule disabling comes into play, if your web server merges rules from various sources,
and you want to disable any rule defined previously. Since the uriworkermap file gets
reloaded dynamically, you can use this to temporarily disable request forwarding:
A rule gets disabled, if it is suffixed with '-':
# We are not in maintenance.
# The maintenance rule got defined somewhere else.
-/*=maintenance
Exclusion rules can get disabled as well, then the rule starts with '-!'.
The most restrictive URI pattern is applied first. More precisely the URI patterns are
sorted by the number of '/' characters in the pattern (highest number first), and
rules with equal numbers are sorted by their string length (longest first).
If both distinctions still do not suffice, then the defining source of the rule is considered.
Rules defined in uriworkermap.properties come first, before rules defined by JkMount
(for the Apache HTTP Server) and inside workers.properties using the mount attribute.
All disabled rules are ignored. Exclusion rules are applied after all normal rules
have been applied.
There is no defined behaviour, for the following configuration conflict:
using literally the same URI pattern in the same defining source but with
different worker targets.
Rule extensions were added in version 1.2.27 and are not available in earlier versions.
Rule extensions are additional attributes, that can be attached to any rule.
They are added at the end of the rule, each extension separated by a semicolon:
# This is an extension example,
# setting a reply_timeout of 1 minute
# only for this mapping.
/myapp=myworker;reply_timeout=60000
#
# This is an example using multiple extensions
/myapp=myloadbalancer;reply_timeout=60000;stopped=member1
Attributes set via rule extensions always overwrite conflicting
configurations in the worker definition file.
The extension reply_timeout sets a reply timeout for a single mapping rule.
# Setting a reply_timeout of 1 minute
# only for this mapping.
/myapp=myworker;reply_timeout=60000
It overrides any reply_timeout defined for the worker. The extension allows
to set a reasonable default reply timeout to the worker, and a more relaxed
reply timeout to URLs, which are known to start time intensive tasks.
For a general description of reply timeouts see the
timeouts documentation.
The extension sticky_ignore will disable session stickyness for a single
mapping rule.
# Disable session stickyness
# only for this mapping.
/myapp/loginform.jsp=myworker;sticky_ignore=1
This extension can be useful to optimize load balancing when using
cookie based session stickyness. In this case, as long as she keeps
her browser open, any request by a user who started a session will
be send to the same Tomcat instance, even if he left the part of
the application which uses the session. You can for instance
set this environment variable when a user requests a login form
to ensure, that this initial session request is balanced non-sticky.
This extension is available since version 1.2.33.
The extension stateless is only useful when using session based
load balancing. In this case normally any request which does not come with
a session id counts as a new session. If you mark a mapping rule with
the stateless extension, then the requests matching the mapping
rule will not count as a new session, even if they do not come with a session
id.
# Don't let static content trash our session balancing
/myapp/static/*=myworker;stateless=1
This extension is available since version 1.2.33.
The extensions active, disabled, and stopped
can be used in a load balancer mapping rule to set selected members
of the load balancer into a special activation state.
# Stop forwarding only for member1 of loadbalancer
/myapp=myloadbalancer;stopped=member1
Multiple members must be separated by commas or white space:
# Stop forwarding for member01 and member02 of loadbalancer
# Disable forwarding for member21 and member22 of loadbalancer
/myapp=myloadbalancer;stopped=member01,member02;disabled=member21,member22
For the precise meaning of the activation states see the description of
activation.
The extension fail_on_status can be used in any rule:
# Send 503 instead of 404 and 500,
# and if we get a 503 also set the worker to error
/myapp=myworker;fail_on_status=-404,-500,503
Multiple status codes must be separated by commas.
For the precise meaning of the attribute see the description of
fail_on_status.
The extension use_server_errors allows to let the web server
send an error page, instead of the backend (e.g. Tomcat) error page.
This is useful, if one wants to send customized error pages, but those are
not part of all web applications. They can then be put onto the web server.
The value of use_server_errors is a positive number.
Any request send to the backend, that returns with an http status
code bigger or equal to use_server_errors, will
be answered to the client with the error page of the web server
for this status code.
# Use web server error page for all errors
/myapp=myworker;use_server_errors=400
# Use web server error page only for technical errors
/myotherapp=myworker;use_server_errors=500
When using the ISAPI redirector for Microsoft IIS you can restrict
individual rules to special virtual hosts
by prefixing the URI pattern with the virtual host information.
The rules is that the url must be prefixed with the host name.
# Use www.foo.org as virtual host
/www.foo.org/myapp/*=myworker
# Use www.bar.org as virtual host
/www.bar.org/myapp/*=myworker
# Normal mapping
/mysecondapp/*=myworker
Note that /mysecondapp/* will be mapped to all virtual hosts present.
In case one needs to prevent the mappings to some particular virtual host then
the exclusion rule must be used
# Make sure the myapp is accessible by all virtual hosts
/myapp/*=myworker
# Disable mapping myapp for www.foo.org virtual host
!/www.foo.org/myapp/*=myworker
For the Apache HTTP Server you can define individual uriworkermap files per virtual host.
The directive JkMountFile can be used in the main server and in each virtual host.
If a virtual host does not use JkMountfile, but JkMountCopy is set to 'On',
then it inherits the JkMountFile from the main server. If you want all vhost to inherit
mounts from the main server, you can set JkMountCopy to 'All' in the main server.
When a request is being processed, tomcat connectors check the file modification time
of the uriworkermap file. To keep the performance penalty low, this happens only,
if the last check happened at least n seconds ago.
For the Apache HTTP Server you can configure the interval "n" using the directive JkMountFileReload,
for Microsoft IIS you would use the attribute worker_mount_reload.
The default value is 60 seconds. A value of "0" turns off the reloading.
If the file changed, it gets reloaded completely. If there exist rules coming
from other sources than the uriworkermap file (e.g. the workers.properties mount
attribute or JkMount for the Apache HTTP Server), the new uriworkermap file gets dynamically
merged with these ones exactly like when you do a web server restart.
Until version 1.2.19 reloading behaved slightly differently: it continuously added
the full contents of the uriworkermap file to the rule mapping. The merging rules
were, that duplicated got eliminated and old rules could be disabled, by defining the
rule as disabled in the new file. Rules never got deleted.
The configuration view of the status worker also shows the various mapping rules.
After each worker's configuration, the rules are listed, that forward to this worker.
The list contains four columns:
the name of the virtual server
the URI pattern, prefixed with '-' for a disabled pattern and '!' for an exclusion pattern
the type of the rule: Exact or Wildchar
and the source of the rule definition: 'worker definition' for the workers.properties file (mount attribute),
'JkMount' for the Apache HTTP Server JkMount and it's relatives and finally 'uriworkermap' for the uriworkermap file.
Note: The following restriction has been removed starting with version 1.2.26.
For the Apache HTTP Server, there is an important subtlety: the request going to the status worker
gets executed in the context of some server (main or virtual). The status worker will only show the
mapping rules, that are defined for this server (main or virtual).
Until version 1.2.25 the list contained three columns:
the type of the rule: Exact or Wildchar, eventually prefixed with Disabled or Unmount (for exclusion rules)
the URI pattern
and the source of the rule definition: 'worker definition' for the workers.properties file (mount attribute),
'JkMount' for the Apache HTTP Server JkMount and it's relatives and finally 'uriworkermap' for the uriworkermap file.
Tomcat Connectors has a special type of worker, the so-called status worker.
The status worker does not forward requests to Tomcat instances. Instead it allows
to retrieve status and configuration information at runtime,
and furthermore to change many configuration items dynamically. This can be done
via a simple embedded web interface.
The status worker is especially powerful, when used together with load balancing workers.
This document does not explain the HTML user interface of the status worker.
Until now it is very simple, so just go ahead and use it. This doc instead
tries to explain the less obvious features of the status worker. We also will give a
complete coverage of the various request parameters and their meaning, so that you can
include the status worker in your automation scripts.
The documentation of the status worker starts with jk 1.2.20
The status worker knows about the following actions:
list: lists the configurations and runtime information of all configured workers.
The output will be grouped by global information first (version data), then load balancer
information, after that AJP worker information and finally the legend. For load balancers,
there will be a summary part, and after that details for each member worker. For all workers,
we also include the URL mappings (forward definitions).
show: the same as list, but only shows data for one chosen worker
edit: produces a form to edit configuration data for a chosen worker. There is a
special subtype of "edit", that makes it easy to change one attribute for all members of
a load balancer, e.g. their activation state.
update: commit changes made in an edit form. Caution: the changes will not be
persisted to the configuration files. As soon as your restart your web server, all changes
made through the status worker will be lost! On the other hand, the changes done by the status
worker will be applied during runtime without a restart of the web server.
reset: reset all runtime statistics for a worker.
recover: Mark a member of a load balancer, that is in error state, for immediate recovery.
version: only show version information of the web server and the JK software
dump: list the original workers configuration. Caution: the dump will only contain
the configuration that was used during startup. Any changes applied later by the dynamic management
interface of the status worker itself will not be contained in this dump.
The dump action has been added in version 1.2.27.
For most actions you can choose between 4 output formats.
HTML: Used interactively with a browser
XML: Mostly useful for automation, when your scripting environment is XML friendly.
This format has rich structure information, but does not work line based, so you would really
like to use it together with XML tools.
Properties: This format is a line based format, that conforms to the rules of Java
property files. Most structure information is contained in the hierarchical key. For information,
that is of configuration nature, the format should produce lines very similar to the ones you can
use in workers.properties. It will not produce a complete configuration file!
Text: A simple textual output format.
The "edit" action does only make sense for the HTML output type.
In the HTML view, there is an automatic refresh feature, implemented via the meta refresh
option of HTML. Once you start the automatic refresh, the UI will will respect it for all actions
except edit, update and maintain. Even if you navigate through one of those, the automatic refresh
will start again as soon as you come back to one of the other actions.
Many parts of the HTML page can be minimised, if they are not interesting for you. There are a couple
of "Hide" links, which will collapse parts of the information. The feature exists for the following
blocks of information:
Legend: Do not show the legend for the information presented in "list" and "show" actions
URI mappings: Do not show the URI mapping for the workers
Load Balancing Workers: Do not show workers of type "lb"
AJP Workers: Do not show workers of type ajp
Balancer Members: Do not show detailed information concerning each member of load balancers
Load Balancer Configuration: Do not show configuration data for load balancers
Load Balancer Summary: Do not show status summary for load balancers
AJP Configuration: Do not show configuration data for ajp workers load balancer members
The last three minimisation features have been added in version 1.2.27.
Note: The following restriction has been removed starting with version 1.2.26.
The Apache module mod_jk makes use of the internal Apache HTTP Server infrastructure concerning
virtual hosts. The downside of this is, that the status worker can only show URL maps, for
the virtual host it is defined in. It is not able to reach the configuration objects
for other virtual hosts. Of course you can define a status worker in any virtual host you
are using. All information presented apart from the URL maps will be the same, independent
of the virtual host the status worker has been called in.
The status worker will log changes made to the configuration with log level "info" to the usual
JK log file. Invalid requests will be logged with log level "warn". If you want to report some
broken behaviour, log file content of level "debug" or even "trace" will be useful.
The basic configuration of a status worker is very similar to that of a usual ajp worker.
You need to specify a name for the worker, and the URLs you want to map to it. The first
part of the configuration happens in the workers.properties file. We define a worker named
mystatus of type status:
worker.list=mystatus
worker.mystatus.type=status
Then we define a URL, which should be mapped to this worker, i.e. the URL we use
to reach the functionality of the status worker. You can use any method mod_jk supports
for the web server of your choice. Possibilities are maps inside uriworkermap.properties,
an additional mount attribute in workers.properties, or JkMount for the Apache HTTP Server.
Here's an example for a uriworkermap.properties line:
/private/admin/mystatus=mystatus
The URI pattern is case sensitive.
As you will learn in the following sections, the status worker is very powerful. You should
use the usual authentication and authorisation methods of your web server to secure this URL.
You can also define multiple instances of the status worker, by using different names and URL mappings.
For instance you might want to configure them individually
and then allow special groups of people to use them
There are a couple of attributes for the workers.properties entries, which allow to customise
various aspects of the output of the status worker.
The attribute css can be set to the URL of a stylesheet:
worker.mystatus.css=/private/admin/static/mystatus.css
When writing HTML output, the status worker then includes the line
<link rel="stylesheet" type="text/css" href="/private/admin/static/mystatus.css" />
There is no sample stylesheet included with the mod_jk release, and by default the attribute css
is empty, so no stylesheet reference will be included in the pages. The HTML code
of the status worker output pages does not include any class attributes. If you like to contribute a
stylesheet or improvements to the HTML layout, please contact us on the tomcat developers list.
The properties output format can be customised via the attribute prefix. The names of all
properties the status worker does output, will begin with this prefix. The default is "worker".
Several attributes influence the format when writing XML output.
The attribute ns allows to set a namespace prefix, that will be used for every status worker+element.
The default is "jk:". Setting it to "-" disables the namespace prefix.
With the attribute xmlns you can map the prefix to a namespace URL. The default value
is xmlns:jk="http://tomcat.apache.org". Setting it to "-" disables the output of the URL.
Finally you can specify an XML document type via the attribute doctype. The specified string will
be inserted at the beginning of the document, directly after the xml header. The default is empty.
We urge you to use the builtin access control features of your web server to control
access to the status worker URLs you have chosen. Nevertheless two configuration
attributes of status workers are helpful. The attribute "read_only" disables all features of
the status worker, that can be used to change configurations or runtime status of the other workers.
A read_only status worker will not allow access to the edit, update, reset or recover actions.
The default value is false, ie. read/write. To enable read_only you need to set it to true.
You could configure two status workers, one has read_only and will be made available to a larger
admin group, the other one will be used fully featured, but only by fewer people:
worker.list=jk-watch
worker.jk-watch.type=status
worker.jk-watch.read_only=true
worker.jk-watch.mount=/user/status/jk
worker.list=jk-manage
worker.jk-manage.type=status
worker.jk-manage.mount=/admin/status/jk
Starting with version 1.2.21, a read/write status worker can also be switched temporarily
into read-only mode by the user via a link in the HTML GUI. The user can always switch it
back to read/write. Only a status worker configured as read-only via the "read_only" attribute
is completely safe from applying any changes.
The other attribute you can use is user. By default this list is empty, which means
no limit on the users. You can set "user" to a comma separated list of user names. If your
web server is configured such that it sends the user names with the request, the status worker
will check, if the name attached with the request is contained in it's "user" list.
The user list can be split over multiple occurrences of the "user" attribute.
By default, the user names are matched case sensitively. Starting with version 1.2.21 you can set
the attribute user_case_insensitive to true. Then the comparison will be made case insensitive.
For load balancing workers the status worker shows some interesting overview information.
It categorises the members of the load balancer into the classes "good", "bad" and degraded".
This feature can be combined with external escalation procedures. Depending on your global
system design and your operating practises your preferred categorisation might vary.
The categorisation is based on the activation state of the workers (active, disabled or stopped),
which is a pure configuration state, and the runtime state
(OK or ERR with possible substates idle, busy, recovering, probing, and forced recovery)
which only depends on the runtime situation.
The runtime substates have the following meaning:
OK (idle): This worker didn't receive any request since the last balancer
maintenance. By default balancer maintenance runs every 60 seconds. The
worker should be OK, but since we didn't have to use it for some time, we
can't be sure. This state has been called N/A before version 1.2.24.
OK (busy): All connections for this worker are in use for requests.
ERROR (recovering): The worker was in error state for some time and is now
marked for recovery. The next request suitable for this worker will use it.
ERROR (probing): After setting the worker to recovering, we received a request
suitable for this worker. This request is now using the worker.
ERROR (forced recovery): The worker is in error, but we don't have an alternative
worker, so we keep using it.
By default the status worker groups into "good" all members, that have activation "active" and
runtime state not equal to "error" with empty substate.
The "bad" group consists of the members, that have either activation
"stopped", or are in runtime state "error" with empty substate.
Workers that fit neither of the two groups, are considered to be "degraded".
You can define other rules for the grouping into good, bad and degraded.
The two attributes "good" and "bad" can be populated by a comma-separated list ob single characters or
dot-separated pairs. Each character stands for the first character of one of the possible states "active",
"disabled", "stopped", "ok", "idle", "busy", "recovering" and "error". The additional states "probing"
and "forced recovery" are always rated equivalent to "recovering".
Comma-separated entries will be combined
with logical "or", if you combine a configuration and a runtime state with a dot. the are combined with logical
"and". So the default value for "good" is "a.o,a.i,a.b,a.r", for "bad" it is "e,s".
The status worker first tries to match against the "bad" definitions, if this doesn't succeed
it tries to match against "good", and finally it chooses "degraded", if no "bad" or "good" match
can be found.
This section should help you building automation scripts based on the jk status
management interface. This interface is stable in the sense, that we only expect
to add further parameters in the future. Existing parameters from previous versions
will keep their original semantics. We also expect the output formats XML, Properties
and Text to be kept stable. So please use those, if you want to parse status worker
output in your automation scripts.
The action is determined by the parameter cmd. It can have the values "list", "show",
"edit", "update", "reset", "recover", "version" and "dump". If you omit the cmd parameter,
the default "list" will be used.
All actions except for "list", "refresh", "version" and "dump" need additional parameters.
The action "dump" has been added in version 1.2.27.
The format is determined by the parameter mime. It can have the values "html", "xml",
"txt" and "prop". If you omit the mime parameter, the default "html"
will be used. The action "edit" (the edit form) does only make sense for "mime=html".
Actions that operate on a single worker need one or two additional parameters to select
this worker. The parameter w contains the name of the worker from the worker list.
If an action operates on a member (sub worker) of a load balancer, the parameter w
contains the name of the load balancer worker, and the additional parameter sw contains the
name of the sub worker.
During automatic refresh, the parameter re contain the refresh interval in seconds.
If you omit this parameter, automatic refresh will be off.
The parameter opt contains a bit mask of activated options. The default is 0, so
by default no options are activated. The following options exist:
0x0001: hide members of lb workers
0x0002: hide URL maps
0x0004: hide the legend
0x0008: hide load balancer workers
0x0010: hide ajp workers
0x0020: only allow read_only actions for a read/write status worker.
0x0040: hide load balancer configuration
0x0080: hide load balancer status summary
0x0100: hide configuration for ajp and load balancer member workers
Values 0x0040-0x0100 have been added in version 1.2.27.
You can use the edit action with a final click to the update button, to change settings of workers.
But you can also make direct calls to the update action. The following request parameters
contain the configuration information, you want to change. First the list for load balancer workers:
vlr: retries (number)
vlt: recover_time (seconds)
vlee: error_escalation_time (seconds)
vlx: max_reply_timeouts (number)
vls: sticky_session (0/f/n/off=off, 1/t/y/on=on; case insensitive)
vlf: sticky_session_force (0/f/n/off=off, 1/t/y/on=on; case insensitive)
vlm: method (0/r="Requests", 1/t="Traffic", 2/b="Busyness", 3/s="Sessions", 4/s="Next"; case insensitive, only first character is used)
vll: lock (0/o="Optimistic", 1/p="Pessimistic"; case insensitive, only first character is used)
And now the list of parameters you can use to change settings for load balancer members:
vwa: activation flag (0/a="active", 1/d="disabled", 2/s="stopped"; case insensitive, only first character is used)
vwf: load balancing factor (integer weight)
vwn: route for use with sticky sessions (string)
vwr: redirect to define simple failover rules (string)
vwc: domain to tell JK about your replication design (string)
vwd: distance to express preferences (integer)
Finally the list of parameters you can use to change settings for ajp workers and ajp load balancer members:
vahst: host (string)
vaprt: port (number)
vacpt: connection_pool_timeout (number)
vact: connect_timeout (number)
vapt: prepost_timeout (number)
vart: reply_timeout (number)
var: retries (number)
varo: recovery_options (number)
vabl: busy_limit (number)
vamps: max_packet_size (number)
Note that changing the host name or port will only take effect for new connections.
Already established connections to the old address will still be used.
Nevertheless this feature is interesting, because you can provision load balancer
members with port "0", which will automatically be stopped during startup. Later
when you know the final names and ports, you can set them and they will be
automatically activated.
The leading character "v" has been added to the parameters in version 1.2.27.
Changing settings for ajp workers has also been introduced in version 1.2.27.
You can use the edit action to edit all settings for a load balancer or for a
member of a load balancer respectively on one page. If you want to edit one
configuration aspect for all members of a load balancer simultaneously, this
will be triggered by the parameter att. The value of the parameter indicates,
which aspect you want to edit. The list is the same as in the previous section,
except for "vahst" and "vaprt":
"vwa", "vwf", "vwn", "vwr", "vwc", "vwd", "vacpt", "vact", "vapt", "vart", "var",
"varo", "vabl" and "vamps". But here you
need to put the name into the parameter att, instead of using it as a request
parameter name.
The values of the common aspect for all the load balancer members will be given
in parameters named "val0", "val1", ....
tomcat-connectors-1.2.48-src/xdocs/reference/project.xml 0000644 0000000 0000002 00000012330 13623533443 021575 0 ustar root bin
The Apache Tomcat Connectors - Reference Guide
The Apache Tomcat Connectors - Reference Guide
tomcat-connectors-1.2.48-src/xdocs/reference/apache.xml 0000644 0000000 0000002 00000135134 13623533443 021360 0 ustar root bin
]>
&project;
Mladen TurkConfiguring mod_jk for the Apache HTTP Server
Most of the directives are allowed once in the global part of the Apache HTTP Server
configuration and once in every <VirtualHost> elements. Exceptions from this rule are
explicitly listed in the table below.
Most values are inherited from the main server to the virtual hosts.
Since version 1.2.20 they can be overwritten in the virtual hosts.
Exceptions from this rule are again explicitly listed in the table below.
See especially JkMountCopy.
Warning: If Apache and Tomcat are configured to serve content from
the same file system location then care must be taken to ensure that Apache is
not able to serve inappropriate content such as the contents of the WEB-INF
directory or JSP source code.
This could occur if the Apache DocumentRoot
overlaps with a Tomcat Host's appBase or the docBase of any Context. It could
also occur when using the Apache Alias directive with a Tomcat Host's appBase or
the docBase of any Context.
Here are the all directives supported by Apache:
The name of a worker file for the Tomcat servlet containers.
This directive is only allowed once. It must be put into
the global part of the configuration.
If you don't use the JkWorkerProperty directives, then you must
define your workers with a valid JkWorkersFile. There is no default
value.
Enables setting worker properties inside Apache configuration file.
The syntax is the same as in the JkWorkersFile (usually workers.properties).
Simply prefix each line with "JkWorkerProperty" to put it directly into
the Apache config files.
This directive is allowed multiple times.
It must be put into the global part of the configuration.
If you don't use the JkWorkerProperty directives, then you must
define your workers with a valid JkWorkersFile. There is no default
value.
This directive is available in jk1.2.7 version and later.
Shared memory file name. Used only on unix platforms.
The shm file is used by balancer and status workers.
This directive is only allowed once. It must be put into
the global part of the configuration.
The default value is logs/jk-runtime-status.
It is highly recommended that the shm file be placed on a local
drive and not an NFS share.
The shared memory contains configuration and runtime information for load balancer
workers and their members. It is need in order that all Apache children
share the same status information for load balancing members (OK, ERROR, ...),
share the information about load taken by the individual workers,
share the information for the parts of the configuration, which are changeable
during runtime by status workers.
Size of the shared memory file name.
This directive is only allowed once. It must be put into
the global part of the configuration.
The default value depends on the platform. It is usually less than 64KB.
Starting with version 1.2.27 the size of the shared memory is determined
automatically, even for large numbers of workers. This attribute is not
needed any longer.
File containing multiple mappings from a context to a Tomcat worker.
It is usually called uriworkermap.properties.
For inheritance rules, see: JkMountCopy.
There is no default value.
This directive configures the reload check interval in seconds.
The JkMountFile is checked periodically for changes.
A changed file gets reloaded automatically. If you set
this directive to "0", reload checking is turned off.
The default value is 60 seconds.
This directive has been added in version 1.2.20 of mod_jk.
A mount point from a context to a Tomcat worker.
This directive is allowed multiple times.
It is allowed in the global configuration and in VirtualHost.
You can also use it inside Location with a different syntax.
Inside Location, one omits the first argument (path),
which gets inherited verbatim from the Location argument.
Whereas <Location /myapp> matches any URI beginning with
"/myapp", any JkMount nested in such a Location block will
only match for requests with exact URI /myapp. Therefore nesting
JkMount in Location is typically not the right thing to do.
By default JkMount entries are not inherited from the global
server to other VirtualHosts or between VirtualHosts.
For the complete inheritance rules, see: JkMountCopy.
You might append rule extensions to the worker name.
The extensions are separated from the worker name by a
semicolon ";" using the same syntax as in the
uriworkermap.properties file.
An exclusion mount point from a context to a Tomcat worker.
All exclusion mounts are checked after mapping a request
to a tomcat worker. If the request maps also to an exclusion,
it will not be forwarded to tomcat, and instead be served locally.
This directive is allowed multiple times.
It is allowed in the global configuration and in VirtualHost.
You can also use it inside Location with a different syntax.
Inside Location, one omits the first argument (path),
which gets inherited verbatim from the Location argument.
Whereas <Location /myapp> matches any URI beginning with
"/myapp", any JkUnMount nested in such a Location block will
only match for requests with exact URI /myapp. Therefore nesting
JkUnMount in Location is typically not the right thing to do.
For inheritance rules, see: JkMountCopy.
This directive is available in jk1.2.7 version and later.
Automatically Alias webapp context directories into the Apache
document space.
Care should be taken to ensure that only static content is served via Apache as a
result of using this directive. Any static content served by Apache will bypass any
security constraints defined in the application's web.xml.
For inheritance rules, see: JkMountCopy.
There is no default value.
If this directive is set to "On" in some virtual server,
the mounts from the global server will be copied to this
virtual server, more precisely all mounts defined by JkMount
or JkUnMount. The Mounts defined by JkMountFile and JkAutoAlias
will only be inherited, if the VirtualHost does not define
it's own JkMountFile or JkAutoAlias.
If you want all vhost to inherit mounts from the main server,
you can set JkMountCopy to 'All' in the main server.
This directive is only allowed inside VirtualHost (with value "On")
and in the global server (with value "All").
The default is Off, so no mounts will be inherited from the global
server to any VirtualHost.
Starting with version 1.2.26 you can also set it to "All" in the
global virtual server. This will switch the default to On.
Name of the Apache environment variable that can be used to set worker names
in combination with SetHandler jakarta-servlet.
This directive is only allowed once per virtual server.
It is allowed in the global configuration and in VirtualHost.
The default value is JK_WORKER_NAME.
This directive configures the watchdog thread interval in seconds.
The workers are maintained periodically by a background thread
running periodically every watchdog_interval seconds. Worker maintenance
checks for idle connections, corrects load status and is able
to detect backend health status.
The maintenance only happens, if since the last maintenance at
least worker.maintain
seconds have passed. So setting the JkWatchdogInterval
much smaller than worker.maintain is not useful.
The default value is 0 seconds, meaning the watchdog thread
will not be created, and the maintenance is done in combination
with normal requests instead.
This directive is only allowed once. It must be put into
the global part of the configuration.
This directive has been added in version 1.2.27 of mod_jk.
It is available only for Apache 2.x and above using APR libraries
including thread support.
Full or server relative path to the mod_jk log file.
It will also work with pipe, by using a value of the form "| ...".
The default value is logs/mod_jk.log.
Pipes are supported for Apache 1.3 only since version 1.2.16.
The default value exists only since version 1.2.20.
The mod_jk log level, can be debug, info, warn
error or trace.
The default value is info.
The mod_jk date log format, using an
extended strftime syntax.
This format will be used for the time stamps in the JkLogFile.
The maximum length of the format is 63 characters.
Starting with version 1.2.24 of mod_jk you can also use %Q
for adding milliseconds to the log and %q for microseconds.
These conversion specifiers are an extension to strftime.
They will only work on platforms with a gettimeofday() function.
You can use %Q and %q only once in the pattern and also not both
together in the same pattern.
The default value is "[%a %b %d %H:%M:%S %Y] " and beginning
with version 1.2.24 on platforms with a gettimeofday()
function it is "[%a %b %d %H:%M:%S.%Q %Y] ".
Request log format string. See detailed description below.
There is no default value. Without defining a value, the request logging
is turned off.
Turns on SSL processing and information gathering by mod_jk
The default value is On.
In order to make SSL data available for mod_jk in Apache, you need to
set SSLOptions +StdEnvVars. For the certificate information you also need
to add SSLOptions +ExportCertData.
Specifically, mod_jk will export the following environment variables from
Apache to Tomcat under these request attributes as per the
Servlet Specification 3.0, section 3.8:
Env Var
Request Attribute Name
Type
Example
SSL_CIPHER (or JkKEYSIZEIndicator)
javax.servlet.request.cipher_suite
java.lang.String
DHE-RSA-AES256-SHA
SSL_CIPHER_USEKEYSIZE (or JkKEYSIZEIndicator)
javax.servlet.request.key_size
java.lang.Integer
256
SSL_SESSION_ID (or JkSESSIONIndicator)
javax.servlet.request.ssl_session
java.lang.String
905...32E (a hex string)
SSL_CLIENT_CERT_CHAIN_n (or JkCERTCHAINPrefixn)
javax.servlet.request.X509Certificate
java.security.X509Certificate[]
(A chain of certs in ascending order of trust, the first one being
ths client's certificate, the second being the signer of that
certificate, and so on)
In addition mod_jk sends the name of the SSL protocol used as a proprietary
request attribute named AJP_SSL_PROTOCOL. Modern Tomcat
versions will expose this attribute under the name
org.apache.tomcat.util.net.secure_protocol_version.
This feature has been added in version 1.2.41 of mod_jk. See also
JkSSLPROTOCOLIndicator.
For all other SSL-related variables, use JkEnvVar for each
variable you want. Please note that, like JkEnvVar, these
variables are available from the request attributes, not as
environment variables or as request headers.
Name of the Apache environment variable that contains SSL indication.
The default value is "HTTPS".
Name of the Apache environment variable that contains the SSL protocol name.
The default value is "SSL_PROTOCOL".
This directive has been added in version 1.2.41 of mod_jk.
Name of the Apache environment variable that contains SSL client certificates.
The default value is "SSL_CLIENT_CERT".
Name of the Apache environment variable that contains SSL client cipher.
The default value is "SSL_CIPHER".
Name of the Apache environment (prefix) that contains SSL client chain certificates.
The default value is "SSL_CLIENT_CERT_CHAIN_".
Name of the Apache environment variable that contains SSL session.
The default value is "SSL_SESSION_ID".
Name of the Apache environment variable that contains SSL key size in use.
The default value is "SSL_CIPHER_USEKEYSIZE".
Name of the Apache environment variable which can be used to overwrite
the forwarded local name.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_LOCAL_NAME".
This directive has been added in version 1.2.28 of mod_jk.
Name of the Apache environment variable which forces to
ignore an existing Content-Length request header. This can be
used to make mod_jk conpatible with mod_deflate request body
inflation (see below).
The default value is "JK_IGNORE_CL".
This directive has been added in version 1.2.41 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded local IP address.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_LOCAL_ADDR".
This directive has been added in version 1.2.41 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded local port.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_LOCAL_PORT".
This directive has been added in version 1.2.28 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded remote (client) host name.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_REMOTE_HOST".
This directive has been added in version 1.2.28 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded remote (client) IP address.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_REMOTE_ADDR".
This directive has been added in version 1.2.28 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded remote (client) IP address.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_REMOTE_PORT".
This directive has been added in version 1.2.32 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded user name.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_REMOTE_USER".
This directive has been added in version 1.2.28 of mod_jk.
Name of the Apache environment variable which can be used to overwrite
the forwarded authentication type.
Use this only if you need to adjust the data (see the
proxy documentation).
The default value is "JK_AUTH_TYPE".
This directive has been added in version 1.2.28 of mod_jk.
Set one of more options to configure the mod_jk module. See below for
details about this directive.
This directive can be used multiple times per virtual server.
The default value is "ForwardURIProxy" since version 1.2.24.
It was "ForwardURICompatUnparsed" in version 1.2.23 and
"ForwardURICompat" until version 1.2.22.
Adds a name and an optional default value of environment variable
that should be sent to servlet-engine as a request attribute.
If the default value is not given explicitly, the variable
will only be send, if it is set during runtime.
The default is empty, so no additional variables will be sent.
This directive can be used multiple times per virtual server.
The settings will be merged between the global server and any
virtual server.
You can retrieve the variables on Tomcat as request attributes
via request.getAttribute(attributeName). Note that the variables
send via JkEnvVar will not be listed in request.getAttributeNames().
Empty default values are supported since version 1.2.20.
Not sending variables with empty defaults and empty runtime value
has been introduced in version 1.2.21.
If this directive is set to On in some virtual server,
the session IDs ;jsessionid=... will be
removed for URLs which are not forwarded but instead are
handled by the local server.
This directive is only allowed inside VirtualHost.
The default is Off.
This directive has been introduced in version 1.2.21.
With version 1.2.27 and later this directive can have optional
session ID identifier. If not specified it defaults to
;jsessionid.
We'll discuss here the mod_jk directive types.
JkWorkersFile specify the location where mod_jk will find the workers definitions.
Take a look at Workers documentation for detailed description.
JkWorkersFile /etc/httpd/conf/workers.properties
JkLogFile specify the location where mod_jk is going to place its log file.
JkLogFile /var/log/httpd/mod_jk.log
Since JK 1.2.3 for Apache 2.x and JK 1.2.16 for Apache 1.3 this can also
be used for piped logging:
info log will contain standard mod_jk activity (default).
warn log will contain non fatal error reports.
error log will contain also error reports.
debug log will contain all information on mod_jk activity
trace log will contain all tracing information on mod_jk activity
JkLogLevel info
info should be your default selection for normal operations.
JkLogStampFormat will configure the date/time format found on mod_jk log file.
See above for details.
JkLogStampFormat "[%Y-%m-%d %H:%M:%S.%Q] "
You can log mod_jk information using the Apache standard module mod_log_config.
The module sets several notes in the Apache notes table.
Most of them are are only useful in combination with a load balancer worker.
Name of the worker selected by the URI mappingType of the worker selected by the URI mappingActual worker name selected by the URI mapping (usually a member of the load balancer).
Before version 1.2.26 only available if JkRequestLogFormat is set.Request duration in seconds and microseconds.
Before version 1.2.26 only available if JkRequestLogFormat is set.Load balancer: Name of the first worker triedLoad balancer: Type of the first worker triedLoad balancer: Access count for the first worker triedLoad balancer: Count of created sessions for the first worker triedLoad balancer: Bytes read for the first worker triedLoad balancer: Bytes transferred for the first worker triedLoad balancer: Error count for the first worker triedLoad balancer: Busy count for the first worker triedLoad balancer: Activation state for the first worker triedLoad balancer: Error state for the first worker triedLoad balancer: Name of the last worker triedLoad balancer: Type of the last worker triedLoad balancer: Access count for the last worker triedLoad balancer: Count of created sessions for the last worker triedLoad balancer: Bytes read for the last worker triedLoad balancer: Bytes transferred for the last worker triedLoad balancer: Error count for the last worker triedLoad balancer: Busy count for the last worker triedLoad balancer: Activation state for the last worker triedLoad balancer: Error state for the last worker triedLogFormat "%h %l %u %t \"%r\" %>s %b %{JK_WORKER_NAME}n %{JK_LB_FIRST_NAME}n \
%{JK_LB_FIRST_BUSY}n %{JK_LB_LAST_NAME}n %{JK_LB_LAST_BUSY}n" mod_jk_log
CustomLog logs/access_log mod_jk_log
You can also log a request protocol in the mod_jk log file instead of
the access log. This is not recommended and mostly a backward compatibility
feature. The directive JkRequestLogFormat will configure the format
of this protocol. It gets configured and enabled on a per virtual host basis.
To enable request logging for a virtual host just add a JkRequestLogFormat config.
The syntax of the format string is similar to the Apache LogFormat command,
here is a list of the available request log format options:
Bytes sent, excluding HTTP headers (CLF format)Bytes sent, excluding HTTP headersThe request protocolThe request methodThe canonical Port of the server serving the requestThe query string (prepended with a ? if a query string exists, otherwise an empty string)First line of requestRequest HTTP status codeRequest duration, elapsed time to handle request in seconds '.' micro secondsThe URL path requested, not including any query string.The canonical ServerName of the server serving the requestThe server name according to the UseCanonicalName settingTomcat worker nameReal worker nameJkRequestLogFormat "%w %V %T"
The directive JkOptions allow you to set many forwarding options which will enable (+)
or disable (-) following option. Without any leading signs, options will be enabled.
The four following options +ForwardURIxxx are mutually exclusive.
Exactly one of them is required, a negative sign prefix is not allowed with them.
The default value is "ForwardURIProxy" since version 1.2.24.
It was "ForwardURICompatUnparsed" in version 1.2.23 and
"ForwardURICompat" until version 1.2.22.
You can turn the default off by switching on one of the other two options.
You should leave this at it's default value, unless you have a very good
reason to change it.
All options are inherited from the global server to virtual hosts.
Options that support enabling (plus options) and disabling (minus options),
are inherited in the following way:
options(vhost) = plus_options(global) - minus_options(global) + plus_options(vhost) - minus_options(vhost)
Using JkOptions ForwardURIProxy, the forwarded URI
will be partially reencoded after processing inside Apache and
before forwarding to Tomcat. This will be compatible with local
URL manipulation by mod_rewrite and with URL encoded session ids.
JkOptions +ForwardURIProxy
Using JkOptions ForwardURICompatUnparsed, the forwarded URI
will be unparsed. It's spec compliant and secure.
It will always forward the original request URI, so rewriting
URIs with mod_rewrite and then forwarding the rewritten URI
will not work.
JkOptions +ForwardURICompatUnparsed
Using JkOptions ForwardURICompat, the forwarded URI will
be decoded by Apache. Encoded characters will be decoded and
explicit path components like ".." will already be resolved.
This is less spec compliant and is not safe if you are using
prefix JkMount. This option will allow to rewrite URIs with
mod_rewrite before forwarding.
JkOptions +ForwardURICompat
Using JkOptions ForwardURIEscaped, the forwarded URI will
be the encoded form of the URI used by ForwardURICompat.
Explicit path components like ".." will already be resolved.
This will not work in combination with URL encoded session IDs,
but it will allow to rewrite URIs with mod_rewrite before forwarding.
JkOptions +ForwardURIEscaped
JkOptions RejectUnsafeURI will block all
URLs, which contain percent signs '%' or backslashes '\'
after decoding.
Most web apps do not use such URLs. Using the option RejectUnsafeURI, you
can block several well known URL encoding attacks. By default, this option
is not set.
You can also realise such a check with mod_rewrite, which is more powerful
but also slightly more complicated.
JkOptions +RejectUnsafeURI
JkOptions CollapseSlashesAll is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions CollapseSlashesUnmount is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions CollapseSlashesNone is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions ForwardDirectories is used in conjunction with DirectoryIndex
directive of Apache. As such mod_dir should be available to Apache,
statically or dynamically (DSO)
When DirectoryIndex is configured, Apache will create sub-requests for
each of the local-url's specified in the directive, to determine if there is a
local file that matches (this is done by stat-ing the file).
If ForwardDirectories is set to false (default) and Apache doesn't find any
files that match, Apache will serve the content of the directory (if directive
Options specifies Indexes for that directory) or a 403 Forbidden response (if
directive Options doesn't specify Indexes for that directory).
If ForwardDirectories is set to true and Apache doesn't find any files that
match, the request will be forwarded to Tomcat for resolution. This is used in
cases when Apache cannot see the index files on the file system for various
reasons: Tomcat is running on a different machine, the JSP file has been
precompiled etc.
Note that locally visible files will take precedence over the
ones visible only to Tomcat (i.e. if Apache can see the file, that's the one
that's going to get served). This is important if there is more then one type of
file that Tomcat normally serves - for instance Velocity pages and JSP pages.
JkOptions +ForwardDirectories
Setting JkOptions ForwardLocalAddress, you ask mod_jk to send the local address,
of the Apache HTTP Server instead remote client address. This can be used by the
Tomcat remote address valve for allowing connections only from configured Apache
servers.
JkOptions +ForwardLocalAddress
Setting JkOptions ForwardPhysicalAddress, you ask mod_jk to send the
physical peer TCP IP address as the client address. By default mod_jk
uses the logical address as provided by the web server. For example the module
mod_remoteip sets the logical IP address to the client IP forwarded by proxies
in the X-Forwarded-For header.
JkOptions +ForwardPhysicalAddress
JkOptions FlushPackets, you ask mod_jk to flush Apache's connection
buffer after each AJP packet chunk received from Tomcat. This option can have
a strong performance penalty for Apache and Tomcat as writes are performed
more often than would normally be required (ie: at the end of each
response).
JkOptions +FlushPackets
JkOptions FlushHeader, you ask mod_jk to flush Apache's connection
buffer after the response headers have been received from Tomcat.
JkOptions +FlushHeader
JkOptions DisableReuse, you ask mod_jk to close connections immediately
after their use. Normally mod_jk uses persistent connections and pools idle
connections to reuse them, when new requests have to be sent to Tomcat.
Using this option will have a strong performance penalty for Apache and Tomcat.
Use this only as a last resort in case of unfixable network problems.
If a firewall between Apache and Tomcat silently kills idle connections,
try to use the worker attribute socket_keepalive in combination with an appropriate
TCP keepalive value in your OS.
JkOptions +DisableReuse
JkOptions ForwardKeySize, you ask mod_jk, when using ajp13, to forward also the SSL Key Size as
required by Servlet API 2.3.
This flag shouldn't be set when servlet engine is Tomcat 3.2.x (on by default).
JkOptions +ForwardKeySize
JkOptions ForwardSSLCertChain, you ask mod_jk, when using ajp13,
to forward SSL certificate chain (off by default).
Mod_jk only passes the SSL_CLIENT_CERT to the AJP connector. This is not a
problem with self-signed certificates or certificates directly signed by the
root CA certificate. However, there's a large number of certificates signed by
an intermediate CA certificate, where this is a significant problem: A servlet
will not have the possibility to validate the client certificate on its own. The
bug would be fixed by passing on the SSL_CLIENT_CERT_CHAIN to Tomcat via the AJP connector.
This directive exists only since version 1.2.22.
JkOptions +ForwardSSLCertChain
The directive JkEnvVar allows you to forward environment variables
from Apache server to Tomcat engine.
You can add a default value as a second parameter to the directive.
If the default value is not given explicitly, the variable
will only be send, if it is set during runtime.
The variables can be retrieved on the Tomcat side as request attributes
via request.getAttribute(attributeName).
Note that the variables send via JkEnvVar will not be listed
in request.getAttributeNames().
The variables are inherited from the global server to virtual hosts.
JkEnvVar SSL_CLIENT_V_START undefined
If you have created a custom or local version of mod_jk.conf-local as noted above,
you can change settings such as the workers or URL prefix.
JkMount directive assign specific URLs to Tomcat.
In general the structure of a JkMount directive is:
JkMount [URL prefix] [Worker name]
# send all requests ending in .jsp to worker1
JkMount /*.jsp worker1
# send all requests ending /servlet to worker1
JkMount /*/servlet/ worker1
# send all requests jsp requests to files located in /otherworker will go worker2
JkMount /otherworker/*.jsp worker2
You can use the JkMount directive at the top level or inside <VirtualHost>
sections of your httpd.conf file.
JkUnMount directive acts as an opposite to JkMount and blocks access
to a particular URL. The purpose is to be able to filter out the particular content
types from mounted context. The following example mounts /servlet/*
context, but all .gif files that belongs to that context are not served.
# send all requests ending with /servlet to worker1
JkMount /servlet/* worker1
# do not send requests ending with .gif to worker1
JkUnMount /servlet/*.gif worker1
JkUnMount takes precedence over JkMount directives, meaning that the JK
will first try to mount and then checks, if there is an exclusion defined by a
JkUnMount. A JkUnMount overrides a JkMount only, if the worker names in the
JkMount and in the JkUnMount are the same.
The following example will block all .gif files although there is a JkMount for them:
# do not send requests ending with .gif to worker1
JkUnMount /*.gif worker1
# The .gif files will not be mounted cause JkUnMount takes
# precedence over JkMount directive
JkMount /servlet/*.gif worker1
Starting with version 1.2.26 of JK you can apply a JkUnMount to any worker,
by using the star character '*' as the worker name in the JkUnMount.
More complex patterns in JkUnMount worker names are not allowed.
# Mapping the webapps myapp1 and myapp2:
/myapp1/*=worker1
/myapp2/*=worker2
# Exclude the all subdirectories static for all workers:
!/*/static/*=*
# Exclude some suffixes for all workers:
!*.html=*
JkAutoAlias directive automatically Alias webapp context directories into
the Apache document space. It enables Apache to serve a static context while Tomcat
serving dynamic context. This directive is used for convenience so that you don't
have to put an Apache Alias directive for each application directory inside Tomcat's
webapp directory. For security reasons it is strongly recommended that JkMount
is used to pass all requests to Tomcat by default and JkUnMount is used to
explicitly exclude static content to be served by Apache. It should also be noted
that content served by Apache will bypass any security constraints defined in the
application's web.xml. The directive only works in the simple case of contexts
with a single path element and no version marker. It does not support:
# enter the full path to the tomcat webapps directory
JkAutoAlias /opt/tomcat/webapps
The following example shows how to serve a dynamic context by
Tomcat and static using Apache. The webapps directory has to
be accessible by Apache.
# enter the full path to the tomcat webapps directory
JkAutoAlias /opt/tomcat/webapps
# Mount 'examples' directory. It's physical location
# is assumed to be in the /opt/tomcat/webapps/examples
# ajp13w is a worker defined in the workers.properties
JkMount /examples/* ajp13w
# Unmount desired static content from examples webapp.
# This content will be served by the Apache directly.
JkUnMount /*.gif ajp13w
Note that you can have a single JkAutoAlias directive per virtual
host inside your httpd.conf
JkWorkerProperty is a new directive available from JK 1.2.7
version. It is a convenient method for setting directives that are
usually set inside workers.propeties file. The parameter for
that directive is raw line from workers.properties file.
# Just like workers.properties but exact line is prefixed
# with JkWorkerProperty
# Minimal jk configuration
JkWorkerProperty worker.list=ajp13w
JkWorkerProperty worker.ajp13w.type=ajp13
JkWorkerProperty worker.ajp13w.host=localhost
JkWorkerProperty worker.ajp13w.port=8009
JkMountFile is a new directive available from JK 1.2.9
version. It is used for dynamic updates of mount points at runtime.
When the mount file is changed, JK will reload it's content.
# Load mount points
JkMountFile conf/uriworkermap.properties
If the mount point uri starts with an exclamation mark '!'
it defines an exclusion in the same way JkUnMount does.
If the mount point uri starts with minus sign '-'
the mount point will only be disabled. A disabled mount can be reenabled
by deleting the minus sign and waiting for the JkMountFile to reload.
An exclusion can be disabled by prefixing it with a minus sign.
# Sample uriworkermap.properties file
/examples/*=ajp13w
# Do not map .gif files
!/*.gif=ajp13w
# Make jsp examples initially disabled
-/examples/jsp/*=ajp13w
At run time you can change the content of this file. For example
removing minus signs will enable the previously disabled uri mappings.
You can add any number of new entries at runtime that reflects the newly deployed
applications. Apache will reload the file and update the mount
points within 60 second interval.
There is no way to delete entries by dynamic reloading, but you can disable or
exclude mappings.
Alternatively to the mod_jk specific directives, you can also use
SetHandler and environment variables to control, which requests
are being forwarded via which worker. This gives you more flexibility,
but the results might be more difficult to understand. If you mix both
ways of defining the forwards, in general to mod_jk directives will win.
SetHandler jakarta-servlet forces requests to be handled by mod_jk.
If you neither specify any workers via JkMount and the related directives,
not via the environment variable described below,
the first worker in the list of all worker will be chosen. You can use SetHandler
for example in Location blocks or with Apache 2.2 and later also in RewriteRule.
In order to control the worker using SetEnvIf or RewriteRule
for more complex rules, you can set the environment variable JK_WORKER_NAME
to the name of your chosen target worker. This enables you to decide on
the chosen worker in a more flexible way, including dependencies on cookie values.
This feature has been added in version 1.2.19 of mod_jk. Furthermore you might
append rule extensions to the worker name. The extensions are separated from the
worker name by a semicolon ";" using the same syntax as in the
uriworkermap.properties file. Supporting rule extensions in the worker name has
been added in version 1.2.33.
In order to use another variable than JK_WORKER_NAME, you can set the name
of this variable via the JkWorkerIndicator directive.
You can also define exclusions from mod_jk forwards by setting the environment
variable no-jk.
# Automatically map all encoded urls
<Location *;jsessionid=>
SetHandler jakarta-servlet
SetEnv JK_WORKER_NAME my_worker
</Location>
# Map all subdirs to workers via naming rule
# and exclude static content.
<Location /apps/>
SetHandler jakarta-servlet
SetEnvIf REQUEST_URI ^/apps/([^/]*)/ JK_WORKER_NAME=$1
SetEnvIf REQUEST_URI ^/apps/([^/]*)/static no-jk
</Location>
Environment variables allow to overwrite the default behaviour
of mod_jk depending on request properties like e.g. the request URI,
header values or cookie. This can be done using the SetEnvIf or
RewriteRule directives.
The environment variable
JK_ROUTE can be set to explicitely choose a member of a
load balancer worker. The value must be equal to the
route attribute of the member, or if that attribute is not
used, equal to the member name. Note that this is only needed if
session IDs and routes are encoded in a non standard way in the
request. Stickyness using the Java Servlet compliant way of encoding
the IDs is supported by default.
This is available since version 1.2.33.
The environment variable
JK_REPLY_TIMEOUT can be set to dynamically define a reply timeout.
The value must be given in milliseconds.
This is available since version 1.2.27.
The environment variable
JK_STICKY_IGNORE can be set to disable session stickyness
for individual requests. If the variable is set to an empty string
or a nonzero number, session stickyness will be disabled. Setting
it to 0 will reset to the behaviour defined by the worker
configuration.
This is available since version 1.2.33.
This feature can be useful to optimize load balancing when using
cookie based session stickyness. In this case, as long as she keeps
her browser open, any request by a user who started a session will
be send to the same Tomcat instance, even if he left the part of
the application which uses the session. You can for instance
set this environment variable when a user requests a login form
to ensure, that this initial session request is balanced non-sticky.
The environment variable
JK_STATELESS can be used to improve load balancing
for the session based balancing methods Session and
Next.
In this case normally any request which does not come with
a session id counts as a new session. This can be problematic,
if for instance static content is retrieved without a session id.
If you set the environment variable JK_STATELESS for a request,
then the request will not count as a new session, even if it does not
come with a session id.
This is available since version 1.2.33.
The environment variable
JK_IGNORE_CL can be set to force ignoring the request
Content-Length header (if it exists). mod_jk will then stream
the request body until the web server indicates that the full body
was read. No Content-Length header will be send to the backend.
This is available since version 1.2.41.
This feature can be used to make mod_jk compatible with filters
which change the size of the request body. One such filter is
mod_deflate when used to inflate the body of a request with gzip
encoded body. In this case mod_jk will by default forward a truncated
body, because it gets the wrong body size from the web server.
Telling mod_jk to ignore the Content-Length header will result
in streaming all request body data it can read from the web server
to the backend.
You should only set the JK_IGNORE_CL environment variables
for requests that actually need it. Unfortunately there's no way
for mod_jk to detect the need automatically.
Notice: This comments section collects your suggestions
on improving documentation for Apache Tomcat.
If you have trouble and need help, read
Find Help page
and ask your question on the tomcat-users
mailing list.
Do not ask such questions here. This is not a Q&A section.
The Apache Comments System is explained here.
Comments may be removed by our moderators if they are either
implemented or considered invalid/off-topic.
wrap
Attribute
Description
Directive
Default
Description
-
Directive
Worker Type
Default
Description
?
-
Directive
Successor
Default
Description
-
-
Property
Description
/images/add.gif
/images/update.gif
/images/design.gif
/images/docs.gif
/images/fix.gif
/images/code.gif
r
tomcat-connectors-1.2.48-src/xdocs/index.xml 0000644 0000000 0000002 00000020056 13623533443 017304 0 ustar root bin
]>
&project;
Mladen TurkRainer JungDocumentation Overview
The Apache Tomcat Connectors project is part of the Tomcat project
and provides web server plugins to connect web servers with Tomcat and other backends.
The supported web servers are:
the Apache HTTP Server with a plugin (module) named mod_jk.
Microsoft IIS with a plugin (extension) named ISAPI redirector
(or simply redirector).
the iPlanet Web Server with a plugin named NSAPI redirector. The
iPlanet Web Server was previously known under various names, including Netscape Enterprise Server,
SunOne Web Server and Sun Enterprise System web server.
In all cases the plugin uses a special protocol named Apache JServ Protocol
or simply AJP to connect to the backend. Backends known to support AJP
are Apache Tomcat, Jetty and JBoss. Although there exist 3 versions of the protocol,
ajp12, ajp13, ajp14, most installations
only use ajp13. The older ajp12 does not use persistent connections and is obsolete, the newer
version ajp14 is still experimental. Sometimes ajp13 is called AJP 1.3 or AJPv13, but we
will mostly use the name ajp13.
Most features of the plugins are the same for all web servers. Some details vary
on a per web server basis. The documentation and the configuration is split into common
parts and web server specific parts.
down to the more detailed documentation that is available. Each available
manual is described in more detail below.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.48 Stable. This release contains improvements and
bug fixes for issues found in previous releases.
A Tomcat worker is a Tomcat instance that is waiting to execute servlets
on behalf of some web server. For example, we can have a web server such as Apache
forwarding servlet requests to a Tomcat process (the worker) running behind it.
This page contains detailed description of all workers.properties
directives.
The forwarding of requests from the web server to tomcat gets configured by defining mapping rules.
The so-called uriworkermap file is a mechanism of defining those rules.
tomcat-connectors-1.2.48-src/xdocs/miscellaneous/ 0000755 0000000 0000002 00000000000 13623533443 020313 5 ustar root bin tomcat-connectors-1.2.48-src/xdocs/miscellaneous/reporttools.xml 0000644 0000000 0000002 00000006537 13623533443 023444 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Reporting ToolsGlenn Nielsen
The mod_jk source distribution contains two perl scripts in the
tools/reports directory which can be used to analyze the mod_jk
logs, save statistical data, and generate report graphs.
tomcat_trend.pl log_dir archive_dir
Script for analyzing mod_jk.log data when logging tomcat request data using
the JkRequestLogFormat Apache mod_jk configuration.
Generates statistics for request latency and errors. Archives the generated
data to files for later use in long term trend graphs and reports.
tomcat_reports.pl archive_dir reports_dir
Script for generating reports and graphs using statistical data generated
by the tomcat_trend.pl script.
The following graphs are created:
tomcat_request.png - Long term trend graph of total number of tomcat
requests handled.
tomcat_median.png - Long term overall trend graph of tomcat request
latency median.
tomcat_deviation.png - Long term overall trend graph of tomcat request
mean and standard deviation.
tomcat_error.png - Long term trend graph of requests rejected by tomcat.
Shows requests rejected when tomcat has no request processors available.
Can be an indicator that tomcat is overloaded or having other scaling
problems.
tomcat_client.png - Long term trend graph of requests forward to tomcat
which were aborted by the remote client (browser). You will normally see
some aborted requests. High numbers of these can be an indicator that
tomcat is overloaded or there are requests which have very high latency.
A great deal of statistical data is generated but at this time
only long term trend graphs are being created and no reports.
This is only a start. Many more graphs and reports could be
generated from the data. Please consider contributing back any
new reports or graphs you create. Thanks.
These perl scripts depend upon the following perl modules and libraries:
This is the Changelog for Apache Tomcat Connectors. This changelog
does not contain all updates and fixes to the Tomcat connectors (yet).
It should contain fixes made only after November 10th 2004, when the
new documentation project for JK was started.
IIS: Update the installation how-to to remove windows versions that are no
longer supported and to add Windows Server 2019. (markt)
Apache: Extend trace level logging of method entry/exit to aid debugging
of request mapping issues. (markt)
Apache: Fix a bug in the normalization checks that prevented file based
requests, such as SSI file includes, from being processed. (markt)
63214: Apache: When using JkAutoAlias, ensure
that files that include spaces in their name are accessible. (markt)
Common: Update the documentation to reflect that the source code for the
Apache Tomcat Connectors has moved from Subversion to Git. (markt)
64051: Common. When using set_session_cookie,
ensure that an updated session cookie is issued if the load-balancer has
to failover to a different worker. (markt)
Common: Update config.guess and config.sub from
https://git.savannah.gnu.org/git/config.git.
(markt)
Common; Update release script for migration to git. (rjung)
62751: Apache: Fix regression in 1.2.44 which resulted in
socket_connect_timeout to be interpreted in units of seconds
instead of milliseconds on platforms that provide poll(). (rjung)
62689: Correct regression in 1.2.44 that broke request
handling for OPTIONS * requests. (rjung)
Apache: Update the documentation to note additional limitations of the
JkAutoAlias directive. (markt)
Common: Optimize path parameter handling. (rjung)
Improve path parameter parsing so that the session ID specified by the
session_path worker property for load-balanced workers can
be extracted from a path parameter in any segment of the URI, rather
than only from the final segment. (markt)
Apache: Improve path parameter handling so that
JkStripSession can remove session IDs that are specified on
path parameters in any segment of the URI rather than only the final
segment. (markt)
IIS: Improve path parameter handling so that strip_session
can remove session IDs that are specified on path parameters in any
segment of the URI rather than only the final segment. (markt)
Remove the Novell Netware make files and Netware specific source code
since there has not been a supported version of Netware available for
over five years. (markt)
57946: Apache: Update the documentation to use httpd 2.4.x
style access control directives. (markt)
58287: Common: Use Local, rather than Global, mutexs on
Windows to better support multi-user environments. (markt)
59897: Apache: Use poll rather than select to avoid the
limitations of select triggering an httpd crash. Patch provided by Koen
Wilde. (markt)
60745: ISAPI: Remove the check that rejects requests that
contain path segments that match WEB-INF or META-INF as it duplicates
a check that Tomcat performs and, because ISAPI does not have visibility
of the current context path, it is impossible to implement this check
without valid requests being rejected. (markt)
Clarify the behvaiour of lb workers when all ajp13 workers fail with
particular reference to the role of the retries attribute. (markt)
62408: Add the new load-balancer worker property lb_retries
to improve the control over the number of retries. Based on a patch
provided by Frederik Nosi. (markt)
Refactor normalisation of request URIs to a common location and align
the normalisation implementation for mod_jk with that implemented by
Tomcat. (markt)
Add a note to the documentation that the CollapseSlashes options are
now effectively hard-coded to CollpaseSlashesAll due to the changes
made to align normalization with that implemented in Tomcat. (markt)
Update PCRE bundled with the ISAPI redirector to 8.42. (rjung)
Update config.guess and config.sub from
https://git.savannah.gnu.org/git/config.git.
(rjung)
61733: LB: Propagate load factor changes applied by the status worker
to a load balancer sub worker correctly to all processes.
Based on a patch provided by Jonathan Oddy. (rjung)
ISAPI: Align the make files for 32-bit and 64-bit builds. (markt)
Update config.guess and config.sub from
http://git.savannah.gnu.org/cgit/config.git.
(rjung)
Update PCRE bundled with the ISAPI redirector to 8.41. (rjung)
Update the ISAPI redirector installation documentation to reflect the
currently supported versions of Windows. (markt)
Align the normalization performed by the ISAPI redirector with that
implemented by Tomcat. (markt)
Status: Fix displayed number of bytes read from and written
to the backend when an AJP worker is used without a load
balancer worker. (rjung)
Apache: Don't try to read remaining request body parts during
clean up if reading the request body from the client already
failed during earlier processing phases. (rjung)
57485: Apache: Propagate errors reading the request body from
the client to mod_jk so Tomcat sees an error rather than a truncated
body. (markt)
57836: ISAPI: Empty REMOTE_USER should not be
translated to "". (rjung)
58249: Add a note the the documentation that max_packet_size
will be aligned to the next multiple of 1024 if a value is specified
that is not a multiple of 1024. (markt)
58309: ISAPI: Update bundled pcre from version 5.0
to 8.38. (rjung)
58286: Fix crash in mod_jk and in the ISAPI Redirector.
The crash only happens on Windows when retrieving the jk-status
for the HTML format (which is the default format). This regression
was introduced by the fix to 54177. (rjung)
58285: Don't use GCC atomics on platforms, for which
GCC doesn't provide an atomics implementation. This regression
was introduced by the fix to 44454 and 56703.
(rjung)
58425: Fix regression in 1.2.41 that prevented AJP 1.2
workers from initialising. Note that the AJP 1.2 protocol is deprecated.
Patch provided by yagisita. (markt)
58504: If a background thread is used to perform worker
maintenance, ensure that maintenance runs are not skipped. Patch
provided by Hiroto Shimizu. (markt)
58608: ISAPI: Add a new registry option "flush_packets"
that allows the flushing behaviour of IIS7+ to be controlled. The
default is not to flush. Setting the option to "true" with cause IIS to
write data to the client as each AJP packet is received. (markt)
58813: ISAPI: Correctly release a mutex allowing the plugin
to complete initialization. Prior to this fix, the incomplete
initialization was causing a hang on shutdown. Patch provided by Matthew
Reiter. (markt)
58895: Correct an off-by-one error in the log messages for
the number of attempts made to communicate with the backend server.
Patch provided by Hiroto Shimizu. (markt)
59164: Fix crash on first connection if a host name is
specified for the worker that cannot be resolved to an IP address.
(markt)
59184: HTTPD: Avoid segmentation fault if mod_jk is
configured with an invalid value for JkShmFile. This causes the server
startup to fail. (markt)
Minor code clean-up and optimization. (markt)
AJP, LB: Reduce lock contention during maintenance function.
This was observable when using a big number of AJP13 and LB
workers, especially in combination with the Apache httpd prefork
MPM. (rjung)
57060: Allow building from outside of source tree.
Patch contributed by Petr Sumbera. (rjung)
56703: Status: Fix inflated counter for current number
of backend connections especially when a connection timeout occurred
on the backend. (rjung)
56661: Fix Servlet API getLocalAddr().
Works for Tomcat 6.0.42, 7.0.55 and 8.0.11 and Apache and ISAPI
plugins. (rjung)
Status: Log old and new values when changing worker attributes.
(rjung)
56667: Status: Fix log message when changing activation
state of all members. (rjung)
56565: Fix IPV6 address resolve on non-dual
network stacks. (mturk)
50511: Reduce log level for "OPTIONS *" requests
from warning to debug. (rjung)
Apache: Copy log notes instead of using references to prevent access
to memory from closed pool. (rjung)
Add option to control handling of multiple adjacent slashes in
mount and unmount. New default is collapsing the slashes only in
unmount. Configuration is done via new JkOption for Apache
("CollapseSlashesAll", "CollapseSlashesNone" or
"CollapseSlashesUnmount") and via property "collapse_slashes" for IIS
(values "all", "none", "unmount"). This is the fix for CVE-2014-8111.
(rjung)
Add more checks for shared memory allocation. (rjung)
56869: Status: Add maximum number of open backend connections
to status worker. Patch contributed by Martin Knoblauch. (rjung)
56770: AJP: Add worker name to all log messages.
Patch contributed by Martin Knoblauch. (rjung)
50186: Docs: Clarify relation between
"connection_pool_timeout" and "keepAliveTimeout" or "connectionTimeout"
in the Tomcat AJP connector configuration. (rjung)
52334: LB: Calculate worker recovery time based on last
recovery attempt time instead of original error time after the first
recovery attempt. (rjung)
54596 part 1: IIS: Fix missing last character when parsing
relative file names with no ".." directory components from
configuration. (rjung)
54596 part 2: IIS: Fix using relative file names in config
with ".." path segments that go up the directory hierarchy higher
than the starting point of the relative file name. (rjung)
Status: Add logging if status worker output was dropped due to
insufficient buffer size. (rjung)
Reduce log buffer from 8KB to 1KB. Add logging in case of failed
logging and add trailing "..." to lines which were likely truncated.
(rjung)
Replace fixed allocation of 32 entries for fail_on_status by
dynamic allocation. (rjung)
Enforce implementation restriction on maximal length "60" of worker
attributes "name", "host", "route", "domain", "redirect",
"session_cookie", "session_path" and "set_session_cookie". Checks were
added to configuration file processing and configuration
updates via the status worker. (rjung)
52483: Apache: Add debug logging for result
of JkOptions configuration processing. (rjung)
54177: Status: Use numeric time stamps instead of
textual ones to avoid non-well-formed XML output. Textual
timestamps are formatted according to locale settings and
reencoding them to UTF-8 would be cumbersome. (rjung)
56618: Status: Use percent decoding when reading
query string parameters. For example this fixes editing IPv6
addresses via the status worker if the client encodes
":" as "%3A". Patch contributed by Christopher Schultz. (rjung)
56452: Fix crash in debug logging for IPv6 adresses.
Patch contributed by Christopher Schultz. (rjung)
34526: Apache: Improve compatibility with mod_deflate
request body inflation. An automatic detection of mod_deflate
inflation is not implemented. Use the new Apache environment variable
JK_IGNORE_CL instead, to let mod_jk ignore an existing Content-Length
request header. (rjung)
44454: LB: Add warning to docs about problems with
"busyness" load balancing method. (rjung)
44454: Improve busy counter by using atomics. (rjung)
56703: Status: Improve connected counter. Use atomics
and for mod_jk (Apache) currectly count down connections closed
by child processes that are stopped. (rjung)
44571: Ensure that we return with status 503 if we
can not get and endpoint for a worker. (rjung)
Apache: Improve log handling during graceful or normal restart.
(rjung)
Don't update last access time of worker connections during optional
checking of idle connections using CPing. Updating the time stamp
breaks closing idle connections. (rjung)
Adjust linger parameters used during connection shutdown. (rjung)
Fix annoying redefine warnings for the autoconf PACKAGE defines
during configure based builds. (rjung)
Status: Use multi-line table headers and fix invalid xml output.
(rjung)
44571: Implement an optional limit on concurrent requests
allowed for a worker (attribute "busy_limit"). Original patch
contributed by zealot0630 at gmail dot com. (rjung)
Correct log message "all endpoints are disconnected" to
"no usable connection found, will create a new one". Tone done
from info log level to debug for the common case. (rjung)
57536: AJP: Allow to configure connection source address.
This should only be used on multi-homed hosts. The feature is
experimental. (rjung)
57540: AJP: Forward name of SSL protocol used for handling
the request (SSLv3, TLSv1, TLSv1.1, TLSv1.2). (rjung)
Fix forwarding of chunked requests, which is broken in version 1.2.39.
(rjung)
56352: Fix regression in memory release. (mturk)
Fix status worker display of worker IP address after name or port
was changed. (rjung)
56297: Improve key hash function. Copied from APR. (rjung)
55683: Remove quotes from quoted session cookies. (rjung)
53542: ISAPI: Fix grammar in 503 error page. (rjung)
55696: Crash on Mac OS X 10.9 during config parsing.
(rjung)
Deprecate nt_service from Apache Tomcat Connectors. (mturk)
56133: Fix possible crash when a request fails during
request body transfer to the back end and reply_timeout was set.
Patch contributed by Hiroto Shimizu. (rjung)
Fix status worker not updating parameters for all members. (mturk)
55853: HTTPD: Use the correct API for setting Content-Length.
Patch contributed by areese yahoo-inc.com. (rjung)
Add IPV6 support for connection to webserver.
New directive prefer_ipv6 has been added to control the hostname resolution
and preserve backward compatibility. (mturk)
Add --disable-sock-cloexec to configure to disable use of SOCK_CLOEXEC
(using FD_CLOEXEC + fnctl instead) so built modules will work with
Linux kernels prior to 2.6.27. (timw)
Clean up config file parsing. Worker names are now restricted to
60 bytes. (rjung)
Allow to set a stickyness cookie in case a web framework breaks
Tomcat's adding of the routing ID to the end of the JSESSIONID
cookie. (rjung)
Use max_packet_size also for request body forwarding. (rjung)
Apache 2.4: By default forward logical client address as provided by
mod_remoteip. When setting JkOptions ForwardPhysicalAddress mod_jk
will instead forward the physical peer address. (rjung)
Minor documentation improvements. (rjung)
Fix regression which can crash webserver in case worker is
defined both as member of load balancer and as standalone worker. (mturk)
Fix core if debug log level is specified and there is no
session identifier present. (mturk)
Use named shared memory objects so that we preserve runtime configured
data instead of resetting on each child creation. (mturk)
Fix dead-lock caused by not releasing mutex on close. (mturk)
Fix compilation of mod_jk for HTTPD 1.3. (rjung)
46893: HTTPD 1.3: Apply fix to HTTPD 1.3.
It was fixed for HTTPD 2.x already in version 1.2.30. (rjung)
HTTPD 1.3: Allow to set path parameter used when doing JkStripSession.
This was available for HTTPD 2.x already since mod_jk 1.2.27. (rjung)
HTTPD: Fix crash on unknown worker names. (mturk)
IIS: Fix crash on worker process recycle. (mturk)
52659: IIS: Fix shared memory corruption. (mturk)
52921: HTTPD: Fix crash in uri mapping. (mturk)
52793: AJP: Fix default value of forwarded worker
activation state. Contributed by Yoshihito Fukuyama. (rjung)
HTTPD: Improve support for HTTPD 2.4 by using client_* instead
of remote_* variables. (rjung)
52564: Fix building with format checking gcc security
hardening cflags. Contributed by Tony Mancill. (rjung)
52567: Balancer member in recovery state can switch
back into error state if it is idle. (rjung)
Log error if unable to load URI workermap file, and improve logging
of unreadable worker files on IIS. (timw)
Remove deprecated JNI worker and build dependency on Java SDK. (mturk)
51253: Forward WWW-Authenticate header when using
server generated error pages (rjung, mturk).
46406: IIS: Support relative paths in configuration.
The paths are presumed to be relative from isapi_redirect.dll. (mturk)
50233: Do not use hard limit on uri size (mturk).
IIS: Use Windows Server 2003 SP1, Windows XP SP2 as minimal
version supported. (mturk)
47038: Fix compiler warning when using --enable-flock
for configure. (rjung)
51326: URI Map: Add "session_cookie" and "session_path"
rule extensions. Contributed by Eiji Takahashi. (rjung)
51333: IIS: Document configuration
requirement for 64 Bit environment. (rjung)
51743: HTTPD: Support rule extensions when defining
the request worker with an environment variable
(e.g. JK_WORKER_NAME). (rjung)
51769: IIS: Allow URIs which contain "META-INF" or
"WEB-INF" as long as they are not path components of the URI. (rjung)
52056: HTTPD: JK request log does not always log
correct response status. Fixed by refactoring JK request
log to use the standard request log hook. (rjung)
HTTPD: Allow to choose a sticky worker using the environment
variable JK_ROUTE. This can be used if sessions and routes
are send with the request in a non-standard way. (rjung)
URI Map: Add "sticky_ignore" extension attributes to uri worker map.
It allows to disable stickyness for individual mounts. (rjung)
HTTPD: Allow dynamic disabling of stickyness using the environment
variable JK_STICKY_IGNORE. This can be useful to break cookie stickyness
for non-sticky requests like login forms. (rjung)
LB: New balancing method "Next" to distribute sessions in a round-robin
way. (rjung)
LB: Add counter for created sessions to status worker and HTTPD notes.
It actually counts the number of requests that do not carry a session id.
(rjung)
URI Map: Add "stateless" extension attributes to uri worker map.
This can improve session load balancing. (rjung)
HTTPD: Allow dynamic switching of requests to "stateless" using the
environment variable JK_STATELESS. (rjung)
AJP: Improve logging when request does not fit into an AJP packet. (rjung)
51417: Fix worker busy detection by querying the
worker endpoint. Abandoned connections can leave a worker
in busy state without decrementing busy counter. (mturk)
50339: Fix whitespace trimming when parsing attribute
lists. (rjung)
41263: Support Servlet API getRemotePort().
Works for Tomcat 5.5.28, 6.0.20 and 7.0.0 and Apache and ISAPI
plugins. (rjung)
41923: AJP: Close AJP connection to Tomcat on client write
error when recovery_options 4 is specified, aborting the response
write on the Tomcat side. (timw)
AJP: Cap the lingering bytes that will be read
when shutting down an AJP socket at 32k to prevent CPU spikes
in the web server when a client aborts on a large response body.
Also reduce total linger time to 2s. (timw)
50839: AJP: Fix 30sec CPU spike due to incorrect counting
of lingering bytes causing a busy loop when a client aborts
connection during a response write.
Fixes regression in 1.2.31. (timw)
LB: Forward worker activation state as request attribute
"JK_LB_ACTIVATION". Possible values are "ACT" (active),
"DIS" (disabled) and "STP" (stopped). (rjung)
HTTPD: Forward WWW-Authenticate from backend when status is 401
and server generated error pages are used. (rjung)
50363: IIS: Prevent chunk encoding of empty message
bodies for 204, 205 and 304 responses. (timw)
50975: IIS: Fix hanging of Transfer-Encoding: chunked
requests when Content-Length header is present in request as well.
Also addresses situation where IIS appears to create a Content-Length
header for a small chunk encoded request when none was present in the
original request. (timw)
47679: IIS: stop truncation of request headers when
ISAPI redirector used as an extension without the corresponding
filter installed. (timw)
NSAPI: Use lower case header names for responses.
Otherwise the web server might add chunked transfer encoding header
in addition to our content length header.
Docs: Improve load balancer documentation. (rjung)
49413: AJP13: Drop flush packets send by the backend
after the response has been finished. (rjung)
AJP: Log the local and remote socket address. (mturk)
Watchdog: Move the maintain workers outside the critical
section allowing other threads to use the connection
pool during maintenance. (mturk)
Common: Add svn revision to init log message. (rjung)
Common: Don't destroy errno during trace logging. (rjung)
Apache: Add support for Apache 2.3/2.4. (rjung)
Apache: Added version number resource for mod_jk.so on Windows. (timw)
48501: IIS: Added rotatelogs style log rotation to ISAPI
Redirector. (timw)
38895: IIS: Use RAW headers instead of CGI headers by default
to prevent conversion of underscores '_' to hyphens '-' in header names.
Old behaviour can be enabled by defining USE_CGI_HEADERS. (timw)
49511: IIS: Do not override IIS log information when subsequent
requests on a keep-alive connection are not mapped into the ISAPI Redirector. (timw)
Docs: Document SSLOptions needed for SSL information forwarding. (rjung)
Docs: Grammar and style improvements and clarification about serving
static content by IIS.
Patch provided by André Warnier. (rjung)
Docs: Update subversion paths used in docs. (rjung)
Apache: Improve compatibility with Apache 2.3. (rjung)
46632: Apache: Do not register child cleanup for
our pools. (mturk)
46893: Apache: Log warning only if JkShmSize was actually
set in the configuration. (mturk)
IIS: Include optional chunking support. Off by default. (mturk)
48763: IIS: Do not send Content-Length when using chunked encoding
or length larger 4GB. (mturk)
48223: IIS: Propagate correct backend error code to IIS. (rjung)
47867: IIS: crash during startup, when compiled with VS2008
and workers.properties contains unsupported properties.
Patch provided by Indrek Juhani (rjung)
47628: IIS: Fix deadlock when restarting the Application Pool
caused by not releasing the critical section lock.
Patch provided by Bret Prucha. (mturk)
IIS/NSAPI: Correct log file flushing after each line. (mturk)
NSAPI: Add Microsoft Visual C++ Makefile. (mturk)
AJP: Improve socket shutdown handling. (mturk)
AJP: Ensure we never reuse a non reusable socket. (mturk)
AJP: Tolerate a single excess packet when waiting for cpong. (mturk)
AJP: Check protocol correctness more strictly. (mturk)
48410: AJP: Use poll instead select so we can work with more
then 1024 sockets. (mturk)
46503: AJP/Status: Garbage data in worker domain and route. (mturk)
48276: AJP: When worker contact cannot be resolved mark the
worker as disabled instead failing to start the server. (mturk)
48169: AJP: Improve CGI interoperability by closing all
sockets during EXEC. (mturk)
Status: Add number of open backend connections to status worker.
This feature is experimental, the displayed value might not be
accurate. (mturk)
47224: Status: When address gets changed invalidate
all opened sockets in the endpoint cache. This will cause new
backend connections to get opened using new address. (mturk)
48305: Status: Do not show "secret" property when
doing dump. (mturk)
45610: Status: Don't accept requests with
empty value for sub worker parameter. (rjung)
45610: Status: Fix erroneous unsetting of
sticky_session and sticky_session_force when updating other
load balancer attributes via the status worker. (rjung)
47222: Status: Add ping_timeout to the shared memory
and allow dynamic configuration. (mturk)
Status: Remove duplicate "errors" line in property view of
AJP13 workers that are part of a load balancer. (rjung)
LB: Fix route logging. (rjung)
Logging: Automatically detect size of thread id for logging. (rjung)
Logging: Add optional log file locking for Windows when defining
JK_LOG_LOCKING. (mturk)
Configuration: Update example configuration. (rjung)
Docs: Update information about tools needed to create a release. (rjung)
47983: Docs: Fix typo in example config
which breaks startup. (rjung)
Build: Force copy of automake files. (rjung)
Build: Tomcat code repository structure cleanup reflected in documentation
and build script. (rjung, mturk)
Apache: Add more environment variables to overwrite request
information. Useful in case a proxy is in front of Apache and sends
us original request information e.g. via custom headers. (rjung)
Apache: No longer preallocate entries for JK request log. (rjung)
46352: Apache: Fix crash when using SetHandler jakarta-servlet
in VHost without any JkMount. Crash due to incorrect initialization
of mount extensions. (rjung)
Apache: JkWatchdogInterval had wrong interval calculation
causing a 10 times higher watchdog interval then configured. (mturk)
Apache: Activate forwarding of SSL key size by default. (rjung)
46169: Apache 1.3: Backport use_server_errors mount extension. (rjung)
46763: Apache 2.0: Survive the log mutex during graceful
restart. Patch provided by Eiji Takahashi. (mturk)
46416: Apache 2.0 on Windows: Include mstcipip.h even if
the apr doesn't include it. (mturk)
IIS: Update uriworkermap.properties file on
a regular interval. This requires both worker_mount_reload
and watchdog_interval to be defined. (mturk)
IIS: Remove obsolete entries from registry file. (mturk)
46579: IIS: Use local environment table instead environment
variables for setting the JKISAPI_PATH and JKISAPI_NAME. (mturk)
LB: Add new property error_escalation_time to fine tune
escalation of local errors to global errors. (rjung)
LB: If the sticky session affinity mark contains a dot, treat the
part before the dot as the domain name. This allows to have full node
session affinity with domain failover. (mturk)
LB: make forced recovery work with local error states. (rjung)
LB: Only update error state and error time, if we actually have a new state. (rjung)
LB: Set global worker state to error when we reach max_reply_timeouts,
or fail_on_status triggered hard error. (rjung)
AJP: Add a new error type JK_AJP_PROTOCOL_ERROR. (mturk)
AJP: Allow worker ports lower or equal to 1024. (rjung)
AJP: Improve some AJP error log messages. (mturk)
Status: Allow changing worker address and port of AJP workers.
The address is resolved on next request for that worker. (mturk)
Status: Allow update actions to show error messages in the result page. (rjung)
Status: Refactor update actions. (rjung)
Status: Do not redirect to the show or list page, if an error occured
during an action. (rjung)
Status: Include error time in display. (rjung)
Status: Remove redundant port information from worker display.
Rename address column and remove its explanation from the legend. (rjung)
Status: Optimize forced uriworkermap.properties reload. (mturk)
Status: Fix crash in text display. (rjung)
Status: Show - Edit - Show always ends in single lb member show,
even when started from all members lb show. (rjung)
Status: Wildcards in sub worker names were broken for update actions. (rjung)
Status: Add use_server_errors to map display. (rjung)
SHM: Move locking into the data pull and push methods. (rjung)
JNI: Deprecate JNI workers. (rjung)
Netware: Missing define for MAX_PATH. Patch by Guenter Knauf. (rjung)
Docs: Add a new HowTo page about reverse proxies. (rjung)
Docs: Add an explanation of local error states to the timeouts documentation. (rjung)
Docs: Clarify relation between socket_timeout and socket_connect_timeout. (rjung)
Docs: Clarify IIS URL rewrite feature. (rjung)
46834,46734: Docs: Fix a couple of missing or broken links. (markt,rjung)
Docs: Add 2008 news to main page and menues. (mturk, rjung)
46109: Decay reply_timeouts even when lb method is
busyness. Also reset reply_timeouts during forced recovery. (rjung)
AJP13: Recycle connection if previous request didn't complete. (mturk)
Maintain should not run multiple times in parallel. (mturk)
Apache: Fix small memory leak during restart. (mturk)
Improve signal handling during socket shutdown. (mturk)
URI Map: Add debug dump function for uri worker map. (rjung)
Add revision number to version info for non-release builds. (rjung)
IIS: Optionally allow chunked encoding for responses.
At the moment only usable, if build with ISAPI_ALLOW_CHUNKING
defined. Based on patch by Tim Whittington. (rjung)
IIS: Optionally use raw headers instead of CGI
headers. Fixes problem "underscore=dash" problem in
header names. At the moment only available, if build with USE_RAW_HEADERS
defined. (rjung)
IIS: Optionally improve IIS 5.1 compatibility.
At the moment only available, if build with AUTOMATIC_AUTH_NOTIFICATION
defined. Based on patch by Tim Whittington. (rjung)
IIS: Fix memory corruption due to parallel initialization
by multiple threads. (rjung)
Windows: Use non-default socket keepalive interval. (mturk)
IIS: Add environment variables JKISAPI_PATH and JKISAPI_NAME. (mturk)
Added socket_connect_timeout directive for setting the
connect timeout for the socket. This enables to have low
connection timeout but higher operational timeouts. (mturk)
AJP13:
[CVE-2008-5519]
Always send initial POST packet even if the client
disconnected after sending request but before providing
POST data. In that case or in case the client broke the
connection in a middle of read send an zero size packet
informing container about broken client connection. (mturk)
AJP13: Added connection_acquire_timeout directive for setting the
absolute timeout the worker will wait for a free endpoint. (mturk)
Apache: Allow to set path parameter used when doing JkStripSession. (mturk)
Refactor retries implementation and change semantics of retries attributes. (mturk)
Status: Allow showing only a single member for a load balancer. (rjung)
Status: Add display of seconds since last statistics reset and access and
transfer rates. (rjung)
AJP13: Add a configurable retry_interval time. (rjung)
Documentation: Enhance description of connection_pool_size. (rjung)
IIS: Refactor error page generation. (mturk)
IIS: SERVER_NAME variable can be the same for
multiple different server instances if requests
are handled according to the ip:port combination.
Use INSTANCE_ID variable to which the request
belongs instead. (mturk)
Allow forwarding server error pages. This can be done
on per-uri basis using new use_server_errors extension.
(mturk)
Added session_cookie and session_path for configuring
default session identifiers. (mturk)
Use max_packet_size also as TCP send and receive buffer size. (mturk)
Apache: Do not allow Apache to start in multi-threaded mode if mod_jk
was only build for single threaded server (prefork). (mturk)
45812: Add done() service method that
causes sending EOS bucket for Apache httpd 2.x.
This allows filter chain to work properly. (mturk)
Added connection_ping_interval, ping_timeout and ping_mode directives.
(mturk)
Apache: Use correct ld flags provided by apxs when building module.
Prevents some crashes on AIX for httpd 1.3 module. (rjung)
Documentation: "val" attribute numbering in status worker
needs to start with 0 instead of 1. (rjung)
Documentation: Remove JNI parameters from sample configuration
in the workers common howto. (rjung)
45026: For Apache httpd 2.x add "Unknown Reason"
as the reason phrase, if we get an empty one from the backend.
Otherwise httpd 2.x returns status 500. (rjung)
Build: Fix Cygwin build. (rjung)
Documentation: Add info to docs, that variables sent via JkEnvVar
are not listed in request.getAttributeNames(). (rjung)
Add watchdog background thread for Apache 2.x and IIS
doing internal maintenance (idle connection checks, backend probing).
See JkWatchdogInternal (Apache) and watchdog_interval (IIS). (mturk)
Change log level of some messages from error to info. (mturk)
Documentation: Fix docs for worker attribute "secret". (rjung)
Detect correct plugin name for various web servers via additional
preprocessor defines. (rjung)
LB: Do not put loadbalancer node in error state if there is opened
channel. This fixes the bug when new connection fails due to
busyness, causing opened connections fail stickyness.
This brings back per-node busy counter and private state array
for each request. We can mark the state as error for failover to
work while still operating and reporting node as OK if there are
opened working connections. (mturk)
44738: Fix merging of JkOption ForwardURI* between virtual hosts.
Patch contributed by Toshihiro Sasajima. (rjung)
URI Map: Add extension attributes to uri worker map.
Allowed are reply_timeout, active/disabled/stopped
and fail_on_status.
Usage currently only implemented for httpd and IIS. (rjung+mturk)
URI Map: Make dynamic reloading atomic and free memory
not needed any longer. (rjung)
Configure: Don't use post httpd 2.2.0 API functions when building
with new --enable-api-compatibility configure switch. (rjung)
Apache: JkAutoAlias does not work in combination with JkMountCopy
if there are no JkMount in virtual host. (rjung)
LB: Optimize state macros to improve performance. (rjung)
Apache: Allow dynamic setting of reply timeout using the environment
variable JK_REPLY_TIMEOUT. (rjung)
Status: Add manageability for ajp parameters of ajp
workers and ajp lb members. (rjung)
Status: Change parameter names of update action to
make them more easily distinguishable from other parameters. (rjung)
Status: Add ajp worker statistics also for
workers, that are not lb members. (rjung)
AJP: Refactor factories, move ajp13/ajp14 common parts into
ajp_factory. (rjung)
Status: Only sync shm worker config values of the workers
for which we changed values. (rjung)
Status: Set lb_factor instead of distance. (rjung)
Status: Minor layout changes, use drop down instead of multiple
text links. (rjung)
SHM: Use local copies of read mostly attributes of lb sub workers
in lb and status worker. (rjung)
Status: Add "dump" action to dump our initial configuration. (rjung)
Status: Use property table to decide which cmd action uses which
output elements. (rjung)
Common: Include original configuration map in worker_env
to make it available for workers, e.g. the status worker. (rjung)
LB: Refactor "route" return for httpd note. Don't use a
member of the worker_record, because that's not thread safe. (rjung)
Common: Refactor "retries", remove from service and jk_worker,
move into ajp worker instead. (rjung)
SHM: Use distinct structs for lb and ajp13 in shm.
Improves type safety and saves a few bytes. (rjung)
SHM: Remove unused attributes. (rjung)
SHM: Automatically determine shm size for all web servers. (rjung)
SHM: Make open/attach logging consistent for all web servers. (rjung)
Status: Include server local time in output. (rjung)
44116: Fix handling of multiple JSESSIONID cookies. (rjung)
37850: Use thread safe localtime_r where appropriate. (rjung)
Use thread safe strtok_r on more platforms, especially AIX. (rjung)
Status: Improve XSS hardening. (rjung)
35303: Move initialization of service members with defaults from
web server specific code to our generic jk_init_ws_service() function. (rjung)
36385: Add missing prepost CPing/CPong directly after connect
in case prepost CPing is used, but no connect CPing. (rjung)
37322: Apache: Enhance robustness of message formating
in jk_error_exit(). (rjung)
44147: Multiple load balancing workers problem. (rjung)
42003: Allocate memory instead using fixed size from
the stack. (mturk)
43229: Load balancer does not do fail over after
reply timeouts. (rjung)
JKStatus: Repair detailed Apache httpd version display.
This was broken for httpd version 2.2.4+. (rjung)
LB/AJP: Refactoring of jk_connect.c, jk_ajp_common.c,
jk_lb_worker.c (rjung)
Configure: Repair broken apxs auto-detection. (rjung)
Configure: Remove trace logging from compiled code
via new --disable-trace configure switch. (rjung)
Common: Maintain idle connections in decreasing (LRU)
slot order. (rjung)
Apache: Create JK_WORKER_ROUTE and JK_REQUEST_DURATION notes for
access log even if no JkRequestLogFormat is set. (rjung)
JKStatus: Enhance URI to worker map listing for Apache httpd.
We now list maps for all virtual servers and not only
the one, in which JKStatus itself was called. (rjung)
JKStatus: Enhance URI to worker map listing.
Update stale uriworkermap.properties immediately. (rjung)
43873: Fix small memory leak occuring during httpd restart. (rjung)
Common: Allow '*' for the worker name in exclusion rules (resp. JkUnMount)
which will override all workers. (rjung)
42038: Correct overlay of mounts and unmounts for IIS. (rjung)
43684: Replace JkMountFile by JkMountFileReload in
uriworkermap.properties docs. (rjung)
Apache: Add new value "All" for JkMountCopy. (rjung)
43516: Memory leak for Apache httpd module
of size 8KB for every virtual host without JK directive
after each restart. (rjung)
Apache: Cleanup init and destroy of server configuration. (rjung)
Apache: Remove global configuration items from per server
configuration. (rjung)
Apache: Remove unused attributes secret_key and
automount/JkAutoMount. (rjung)
Cleanup of jk_uri_worker_map. (rjung)
Documentation: Small additions to JkShmFile documentation.
Contributed by Gerhardus Geldenhuis. (rjung)
AJP13: Ignore flush packets before we received the response headers. (rjung)
Fix crash during startup when using worker configuration inheritance
(attribute "reference") and log level debug. (rjung)
AJP13: Match header names exactly against pre defined constants. Avoid
possible confusion with custom header names using a standard header name
as a prefix. (rjung)
jkstatus: Fix correct parameter validation at JkStatusUpdateTask and
JkStatusUpdateLoadbalancerTask ant tasks. Reported by Christian Mittendorf. (pero)
IIS: Fix shm shutdown behaviour. (rjung)
General: fail_on_status used in a load balancer can optionally
do fail over without putting the failed worker in error state. (rjung)
NSAPI: Improve build description for Unix. (rjung)
NSAPI: Add initialization startup message containing JK version. (rjung)
General: Declare static functions as static. (jim)
Documentation: Clarify fail_on_status behaviour. (rjung)
General: Do fail_on_status before returning the response headers. (rjung)
NSAPI: Fix shm shutdown behaviour. (rjung)
NSAPI: Set return status even if request ended with an error. (rjung)
NSAPI: Allow using without shm_file on WIN32 and Netware. (rjung)
NSAPI: Fix Crash of nsapi for log level debug and unset refect_unsafe. (rjung)
NSAPI: Improve Solaris and Linux Makefiles for nsapi build. (rjung)
Build: Improve pid_t type detection during configure on Solaris. (rjung)
Build: Experimental build support for gcc on WIN32 and Netware. (fuankg)
Build: Makefile optimizations for Apache httpd 1.3/Netware . (fuankg)
General: Fix missing flush bug introduced in 1.2.24. (rjung)
Documentation: Improved workers.properties description in the
reference guide. (rjung)
Documentation: Add a HowTo about the various timeouts. rjung)
Logging: add milliseconds to the default timestamp format,
if we have gettimeofday(). (rjung)
Apache: add milliseconds (%Q) and microseconds (%q) as possible
JkLogStampFormat conversion specifiers. This does not use strftime(),
but needs gettimeofday(). (rjung)
IIS & Sun: Log service failures also, if return code is negative. (rjung)
42849: Abort startup of Apache httpd 1.3 in case
mod_jk initialization failed. We already do the same
for Apache httpd 2.x. (rjung)
42849: Refuse to operate with IIS in case the
initialization failed. Instead requesting isapi_redirect.dll
500 will be returned to the user. This is as closest as it
can get to Apache Httpd where we refuse to start the server
in case of fatal initialization errors. (mturk)
Load Balancer: Fix a deadlock in lb worker, which was exposed on Solaris
for threaded Apache MPMs. (rjung)
Logging: handle LWP IDs as 32 Bit unsigned. Try to make
it work, although pthread IDs are opaque. (rjung)
JkStatus: Added manipulation of max_reply_timeouts. (rjung)
LB, Status: Add feature max_reply_timeouts, to make lb tolerant against
occasional long running requests. (rjung)
JkStatus: Added OK/IDLE as the successor of N/A. (rjung)
Status worker: Renamed runtime states. All states have a major
state (OK or ERR) and a substate. Changed the name N/A to OK/IDLE.
Added docs about the meaning of the states to the status worker
page in the reference guide.
No new states have been added to code. (rjung)
Common: Add recovery options for recovering idempotent http methods
HEAD and GET. (rjung)
Correct documentation for worker attributes retries and
recovery_options. (rjung)
Make writing log lines and line endings more atomic. (rjung)
Common: Refactored and unified jk_map_read_prop* and jk_map_load_prop*
for all use cases. (rjung)
Common/Apache/IIS/Netscape: Add an option to check decoded URLs for
potentially malicious constructions. (rjung)
IIS: Document auth_complete and uri_select. (rjung)
Apache/IIS/Netscape: Change the default forwarding encoding to the new
proxy method. (jfclere, rjung)
Common: Optionally reencode URIs before forwarding to the backend.
Based on the URI reencoding done bei httpd mod_proxy. (jfclere, rjung)
Common: auto-detect correct print format for pid_t.
This fixes at least compiler warnings on Solaris. (rjung)
42608: Handle Content-length as unsigned 64Bit
to allow for huge up- and downloads. (rjung)
Apache: Add forwarding uri to debug log. (rjung)
Docs: Clarify relation between worker names and jvmRoute for load balancing. (rjung)
Use initial zero timeout for jk_is_socket_connected. The resulting
detection is the same but offers a huge performance increase
with mod_jk. In most cases the Operating System does not favor
the 1 microsecond timeout, but it rather rounds that up to much
higher value (frequency of interrupt timer which on most systems
defaults to 100Hz).
Patch provided by David McLaughlin. (mturk)
NSAPI: Check correct log file and shm file configuration during startup. (rjung)
NSAPI: Add support for the general options concerning retries, flushing
and connection persistance. (rjung)
NSAPI: fix crashes due to use of mount attribute in workers.properties.
Changed initialization order. (rjung)
Improved handling of libtool and discrepancies between CC env variable and
CC used during apache build by configure script. (rjung)
Always build with thread support, unless flag --enable-prefork
is set during for configure. (rjung)
Use snprintf/vsnprintf from ap_snprintf.c for platforms other
than Windows, which might lack snprintf/vsnprintf implementations
when NOT build for Apache httpd 2.x/APR (e.g. Sub Web Server)
or without using configure. (fuankg)
Imported ap_snprintf() from Apache 1.3. (fuankg)
Fix incorrect log object cleanup during statup,
leading to crashes at least on iSeries. (rjung)
Add jk_stat() and jk_file_exists() as wrapper functions.
i5/OS V5R4 expects filename in ASCII for fopen but requires them
in EBCDIC for stat(). (hgomez)
i5/OS (AS/400) V5R4 port where Apache 2.0 modules should now use UTF8. (hgomez)
Docs: Add comments on i5/OS build for V5R4 and previous releases. (hgomez)
[CVE-2007-0450]
and
[CVE-2007-1860]:
Change the default value of JkOptions to ForwardURICompatUnparsed.
The old default value was ForwardURICompat.
This should make URL interpretation between Apache httpd and
Tomcat consistent (prevent double decoding problems). (rjung)
Refactor line endings logging to make it correct for all
platforms and webservers. (mturk)
Added command line windows make files. (mturk)
Allow fail_on_status directive to be multi line. (mturk)
42076: Fix name of new option from ForwardCertChain to
ForwardSSLCertChain as documented. (rjung)
Docs: Fix a couple of typos, change format of a few tables,
fix links to news pages. (rjung)
Fix correct URL for TC 6 examples in new IIS rewrite.properties
configuration example file. (rjung)
Add svn properties to several files. (rjung)
Add TC 6 examples to uriworkermap.properties in config examples. (rjung)
Allow multiple status codes for fail_on_status directive.
The status codes can be delimited by space or comma characters. (mturk)
IIS. Added pcre like regular expressions for url rewrite rules. (mturk)
41922: Apache 1.3. Enable JkEnvVar. (mturk)
Apache. Add --enable-flock configure parameter for explicit
compilation of faster flock() system calls for OS supporting
those calls. By default the fcntl system call for locking will
be used that is a little bit slower but it can work on NFS
mounted volumes as well. (mturk)
41562: Add Debug logging for read from client in ISAPI Redirector.
Contributed by Tim Whittington. (mturk)
Apache. Add ForwardSSLCertChain JkOption.
Contributed by Patrik Schnellmann. (mturk)
IIS. Do not forbid access to web-inf or meta-inf if there is
no mapped worker. This allows to have resource with those names
that are outside mapped contexts. (mturk)
Apache. Use process id for creating shared memory name and delete shared
memory and shared memory lock files on exit. (mturk)
IIS. Fix Keep-Alive regression introduced in 1.2.21. (mturk)
Delete unused check for empty init_map during startup. (rjung)
41770: Fix startup error if no JkWorkersFile is used. (rjung)
Use JK_TRUE/JK_FALSE instead of OK/!OK as return values in init_jk(). (rjung)
Minor adjustments to apache startup log messages (when to use STDERR, remove
deprecated NOERRNO flag, shm warning and warnings for usage of default files). (rjung)
Replace APR precompiler directive by httpd mpm_query to detect MPM threading.
Add a debug log message about auto-detected pool size. (rjung)
Make MMN check easier to understand and a little more precise
(for new ap_get_server_banner()/ap_get_server_description()).
We use the new API only for Apache httpd 2.3. This way our binaries are not
tightly coupled to a minor 2.0 version, and we don't use ap_get_server_banner()
any way. (rjung)
Use the full description string ap_get_server_description() instead of
the truncated info from ap_get_server_banner(), because this info gets used internally
(status worker display and ajp14 backend communication) and is not send back to the
normal user. (rjung)
41757: Document the "--enable-prefork" flag of configure. (rjung)
Enhance log messages for failures when parsing attribute maps. (rjung)
Correct log message during worker initialization, in case remote host could not be
resolved. We logged the default host name "localhost" instead of the configured one. (rjung)
41770: Fix the second part of the bug: local_worker and local_worker_only
is missing from the list of deprecated attributes (and not supported either), so prevents
the web server from startup. (rjung)
[CVE-2007-0774]:
A denial of service and critical remote code execution vulnerability.
Caused by buffer overflow in map_uri_to_worker() when URL were longer that 4095 bytes.
Reported by ZDI (www.zerodayintiative.com).
Please note this issue only affected versions 1.2.19 and 1.2.20 of the
Apache Tomcat JK Web Server Connector and not previous versions.
Tomcat 5.5.20 and Tomcat 4.1.34
included a vulnerable version in their source packages.
Other versions of Tomcat were not affected.
Check the worker. parameters and don't start if the parameter is not a valid one. (jfclere)
41439: Allow session IDs to get stripped off URLs of static
content in Apache by adding JkStripSession
directive (configurable per vhost). (mturk)
Change semantics of empty defaults for JkEnvVar variables.
Until 1.2.19: not allowed. In 1.2.20: send variables as empty strings, if
neither set to non empty in config, nor during runtime.
Starting with 1.2.21: If config has no second argument only send
variable if set (even when set to empty string) during runtime.
Allows good combination with condition attribute in tomcat access log. (rjung)
41610: Fix incorrect detection of missing Content-Length
header leading to duplicate headers. Contributed by Boris Maras. (rjung)
Better build support for SunONE (Netscape/iPlanet) webservers. (jim)
Add warning if duplicate map keys are read and are not allowed,
e.g. when parsing uriworkermap.properties. (rjung)
Don't concat worker names, if uriworkermap.properties has a duplicate
pattern, instead overwrite the worker. (rjung)
Log deprecation message even in duplication case. (rjung)
uriworkermap.properties: Fix off-by-one problem when deleting
URL mapping during reloading of uriworkermap.properties. (rjung)
41439: Allow session IDs to get stripped off URLs of static
content in IIS (configurable). (rjung)
41333: Refactoring isapi_plugin configuration reading. (rjung)
41332: Add some more errno logging and unify the format. (rjung)
JkStatus: Improved logging by adding status worker name to messages.
Added messages to the recover worker action. (rjung)
JkStatus: Refactoring searching for workers and sub workers. (rjung)
41318: Add configuration to make status worker user
name checks case insensitive. (rjung)
JkStatus: Add estimated time until next global maintenance to other
mime types and adopt jkstatus ant task. (rjung)
JkStatus: Show estimated time until next global maintenance.
Change displayed time until next recovery to a min/max pair. (rjung)
JkStatus: Allow a user of a read/write status worker to switch it
to and from read_only mode temporarily. (rjung)
JkStatus: Do not show read/write commands in a read_only status worker. (rjung)
JkStatus: Allow lb sub workers in error state to be marked for recovery
administratively from the status worker. (rjung)
Load Balancer: Do not try to recover multiple times in parallel.
Use additional runtime states "PROBE" and "FORCED". (rjung)
JkStatus: Improve data synchronization between different processes. (rjung)
41381: Fix segfault in feature fail_on_status
(wrong order of log arguments). Patch by Juri Haberland. (rjung)
Use correct windows line endings for log file on WIN32 platform. (rjung)
JkStatus Ant Task documentation page. (pero/rjung)
JkStatus Ant Tasks: Add new tasks for update and reset. (pero)
JkStatus Ant Tasks: Update for new xml status format. (pero)
Allow integer and string values when setting enumeration/boolean
attributes via status worker update action. (rjung)
Docs: New reference guide page for status worker. (rjung)
Docs: Renaming the config dir to reference and using the title
Reference Guide in the docs. (rjung)
Added retry_on_status for workers directive. (mturk)
Status Worker: Add directive to make property prefix
and good/bad rule configurable. (rjung)
Status Worker: Omit lb members when att=nosw. (rjung)
Status Worker: New command cmd=version for a short version output. (rjung)
Status Worker: New output stype mime=prop produces property lists. (rjung)
Apache: Fix incorrect handling of JkEnvVar when Vars are set multiple times. (rjung)
Renamed jvm_route to route. Deprecated jvm_route, but still use it as fallback
when parsing the worker configuration. (rjung)
IIS: Make uriworkermap file reload check interval configurable. (mturk)
Apache: Make uriworkermap file reload check interval configurable. (rjung)
Status Worker: Add directives for customizing the XML
output (ns, xmlns, doctype). (mturk)
Docs: New page with description of uriworkermap. (rjung)
Docs: Added short description of max_packet_size to worker
reference. (rjung)
Status Worker: All functions accessible also for xml and txt
mime types (list, show, update, reset). (rjung)
Status Worker: New global health indicators for load balancers
named bad (error, recovering or stopped), degraded (busy or disabled)
and good (the rest, active and OK or N/A). (rjung)
Status Worker: New edit page, to change one attribute for all
members of a load balancer. (rjung)
Status Worker: Standard logging for status worker. (rjung)
Status Worker: code refactoring. (rjung)
Status Worker: New attribute user (list) denies access, if
the request user in the sense of remote_user is not in this list.
Empty list = no deny (rjung)
Status Worker: New attribute read_only disables the parts
of the status worker, that change states and configurations. (rjung)
36121: Don't change main uri when mod_jk serves
included uri. (markt)
Apache VHosts: Merge JkOptions +base - -base + +vhost - -vhost. (rjung)
Apache Docs: Adding requirements, context information, default values and
inheritance rules to the Apache config documentation. (rjung)
Status Worker: Add source type to status worker, remove the redundant "context"
column in the map listing (context=uri). (rjung)
uriworkermap: On reload of the file, all old entries from the previous file
version get deleted, before the new ones are being read. (rjung)
Keep normal maps and exclusion maps internally separate. Don't treat them
as the same when adding a rule. (rjung)
Status Worker: Display mapping rules also for non-lb workers and in global view. (rjung)
Apache VHosts: Use the vhost log files instead of the main log. (rjung)
Apache VHosts: Allow individual timestamp formats by refactoring the formatting
method. (rjung)
Apache VHosts: Adding all missing config items to the virtual host level.
Don't overwrite the settings from the global server, but inherit them
in case they are not set in the virtual host. (rjung)
Apache: remove unnecessary function names from log messages. (rjung)
Apache: add a default log file location and a message, if the default gets used. (rjung)
Apache: add missing JK_IS_DEBUG_LEVEL() (rjung)
Apache VHosts: Allow JkWorkersFile, JKWorkerProperty, JkShmFile and JkShmFileSize
only in global virtual server. (rjung)
Add some more jk_close_socket() and reduce log level for some info messages. (rjung)
Load Balancer: Added the Sessions strategy. Contributed by Takayuki Kaneko. (rjung)
Docs: Minor enhancements and syncing with more recent versions. (rjung)
40997: Separate uri mappings from their '!'
counterpart when checking for duplicates in uriworkermap
reloading. (rjung)
40877: Make sure the shared memory is reset on
attach for multiple web server child processes. (mturk)
IIS: Added shm_size property to be able to deal with over 64
workers configurations. (mturk)
IIS: Increase default thread count to 250, so its the same as Apache Httpd
default configuration. (mturk)
40966: Fix socket descriptor checks on windows. (mturk)
40965: Initialize missing service parameters. (mturk)
40938: Fix releasing of rewrite map.
Thanks to Chris Adams for spotting that. (mturk)
Apache: Added +FlushHeader JkOptions. (mturk)
Added explicit flush when AJP body packet size is zero. (mturk)
40856: Fixing case sensitivity bug in URL mapping. (rjung)
40793: Documentation: Improvements to Apache HowTo provided by
Paul Charles Leddy. (markt)
40774: Fixing wrong recursion termination. This one restricted the
"reference" feature unintentionally to 20 workers. (rjung)
40716: Adding "reference" feature to IIS and Netscape. (rjung)
Documentation: Corrected SetEnvIf syntax in JK_WORKER_NAME example. (rjung)
Documentation: Added forgotten STATE and ACTIVATION notes for load balancer logging in Apache. (rjung)
Apache: Use instdso.sh instead libtool: libtool does not work on HP-UX for example. (jfclere)
Docs: Add SetHandler and new env var to Apache config docs. (rjung)
Apache 1.3: Backport "no-jk" feature. (rjung)
Apache: Add an environment variable to make SetHandler "jakarta-servlet" more
useful. The variable is JK_WORKER_NAME, but can be changed by the
new directive JkWorkerIndicator. (rjung)
LB: Don't use single worker shortcut, if the single worker is being diabled. (rjung)
Status worker: Add short explanation of activation and error states to legend. (rjung)
Docs: Add meaning of zero timeout values for various timeouts
in workers.properties. (rjung)
LB: Cleanup of Mladens forced recovery. (rjung)
LB: Do not change lb_value for recovering workers to max, if
we are using BUSYNESS method. (rjung)
Apache: Since 1.2.14 mod_jk failed to detect client abort. (rjung)
Docs: Corrected description of JkEnvVar. (rjung)
Solaris: Detect filio.h in configure to make the new connection detection
build on solaris (r432825). (rjung)
Add feature to force the recovery of workers that are
member of loadbalancer if all the members are in error
state. This fixes the time gap where 503 was returned
caused by recovery_timeout although the backend was
ready to handle the requests. (mturk)
Docs: Seperate deprecated directives in their own table. (rjung)
Docs: Allow "-" and "_" in worker names. (rjung)
Allow multiple lines with attributes "balance_workers" and "mount". (rjung)
Make jk_is_some_property match more precisely. (rjung)
JkStatus: Make refresh interval changeable. (rjung)
JkStatus: Adjust display of recover time wrt. global maintenance. (rjung)
LB: Resetting worker state from OK to NA, if worker has been idle
too long. (rjung)
Avoid compiler warnings concerning the use of lb_*_type arrays.
Use functions instead. (rjung)
Added %R JkRequestLogFormat option for Apache 1 and Apache 2. (mturk)
Allow changing jvm Route from status manager. (mturk)
Do not retun 400 if Tomcat fails in the midle of the post
request. Return 500 insted. (mturk)
LB: Combine ok/error/recovering/busy runtime states into a single scalar. (rjung)
LB: Combine active/disabled/stopped configuration states into a single scalar. (rjung)
LB: Add several Apache notes to enable standard logging for load balancer results. (rjung)
LB: Reorganisation of the main load balancer service loop. (rjung)
Implement hierarchical worker configuration via attribute "reference". (rjung)
Log deprecated properties. (rjung)
IIS: Fix simple_rewrite for the cases where the
rewritten url is larger then the original one. (mturk)
New JkOption "DisableReuse" to disable connection persistence. (jim)
LB: Move sessionid retrieval out of get_most_suitable_worker into service. (rjung)
Code cleanup for all service methods (use TRACE, JK_LOG_NULL_PARAMS, null pointer checks). (rjung)
JKSTATUS: add refresh link. No refresh for updates. Redirect to list view after update. (rjung)
Add new hook add_log_items into servers. (rjung)
APACHE httpd: Rename apache logging notes. (rjung)
LB: Rename lock and method constants. Add constants for defaults. (rjung)
Default log level should be INFO and not DEBUG.
Default log level should be the same for all server types. (rjung)
Make rewrite_rule_map and log_level as non mandatory
directives for isapi_redirect. (mturk)
40107: Rewrite is_socket_connected function.
Non blocking socket is not used any more. (mturk)
Allow building with VS2005 without too many warnings. (mturk)
Decide by MMN, which piped log API we should use.
mod_jk 1.2.18 broke compilation with Apache 1.3 pre 1.3.28. (rjung)
Using socklen_t in getsockopt. Also introducing jk_sock_t. (mturk)
Allow recovery wait time below 60 seconds (new minimum is 1 second). (mturk)
Fix hanging jk status worker when certain attributes are being updated
due to double locking. (rjung)
Allow JkMount to behave like uriworkermap.properties
by parsing pipe symbol as two directive marker. (mturk)
Added simple rewrite capability for IIS. Although simple it
will fulfill most needs. (mturk)
Added RECOVER_ABORT_IF_CLIENTERROR recovery_option that closes
the connection if client connection is broken during the request. (mturk)
Renamed cache_timeout directive to connection_pool_timeout. (mturk)
Added connection_pool_minsize directive. (mturk)
Deprecate recycle_timeout directive. (mturk)
Corrected some HTML syntax bugs in output of status worker. (rjung)
Added the refresh=n parameter to the status worker. It will update the display every n seconds. (rjung)
Balancer: Add attribute distance to balanced workers to express preferences between workers. (rjung)
Balancer: Add attribute jvm_route to balanced workers to be able to use the same target in different balancers. (rjung)
Status: Add lb_mult to status. (rjung)
Balancer: Make different balancing strategies work in a similar way (use lb_value, use decay during global maintenance, use integer factors for weights. (rjung)
Balancer: Improve locking. (rjung)
Balancer: Workers start slower after recovering. (rjung)
Balancer: Make different balancing strategies work in a similar way (use lb_value, use decay during global maintenance, use integer factors lb_mult for weights). (rjung)
Balancer: Move recovery check to global maintenance. (rjung)
Balancer: Add global maintenance method, that is called in only one process. (rjung)
Extend our use of autoconf to find a 32Bit and a 64Bit unsigned type and their printf formats. (rjung)
Logging: piped loggers for JkLogFile and Apache 1.3. (rjung)
Logging: Add PID to log lines for each log level apart from REQUEST. (rjung)
Logging: flush buffered logs to keep lines in correct order. Output final newline together with log message. (rjung)
Reducing shm size. (rjung)
Only log removing of old worker, when we actually do it. (rjung)
37469: Fix shared memory close for forked childs.
The shared memory will be closed by the parent process. (mturk)
37332: Fix potential misuse of buffer length with
snprintf functions. (mturk)
38859:
[CVE-2006-7197]
Protect mod_jk against buggy or malicious
AJP servers in the backend. Patch provided by Ruediger Pluem. (mturk)
38889: Use worker map sorting depending on the path
elements, to comply with Servlet spec. Patch provided by
Steve Revilak. (mturk)
36138: Added Busyness lb method. Patch provided
by Chris Lamprecht. (mturk)
Fix pessimistic locking mode. The patch correctly handles the
burst load, by syncing the access to the shared memory data. (mturk)
38806: Reclycle worker even if it is disabled.
This fixes hot-standby workers in error state. (mturk)
37167: Allow building with BSD-ish like make. (mturk)
ISAPI plugin (isapi_redirect.dll) did not provide correct request data
for IIS
to include in the IIS log. (markt)
Fix AJP13 Cookie2 parsing. Cookie2 was always send as Cookie.
Patch provided by Andre Gebers. (mturk)
35862: NSAPI plugin attempts to read freed memory and attempts to
dereference a null pointer. Patch provided by Brian Kavanagh. (markt)
Fix lb for worker mpm's with cachesize set to lower number then
ThreadsPerChild is. If retries is set to value larger then 3 sleep for
100 ms on each attempt. This enables to tune the connection cache,
and serialize incoming connections instead returning busy if connection
count is larger then cachesize. (mturk)
36525: Solaris core dump. (mturk)
36102: Worker actions do not persist. (mturk)
35864: Status worker doesn't list workers.
Patch provided by Martin Goldhahn. (mturk)
35809: JkMountCopy don't work for Apache 2.0 Patch provided by
Christophe Dubach. (mturk)
35298: Multiple JK/ISAPI redirectors on a single IIS site are not supported
Patch provided by Tim Whittington. (mturk)
34397: Emergency was handled as Error. (jfclere)
34474: // in URL were not handled correctly with Apache-1.3. (jfclere)
Use 64 bits int for transferred/read bytes.
Added JkOptions +FlushPackets used to optimize memory
usage when sending large data. (mturk)
Added lock directive for load balancer that allows more acurate
load balancing in case of burst load. (mturk)
Added worker.maintain directive to allow customizing default 10
second timeout. On busy servers this value needs to be set on
higher value. (mturk)
Fix for NetWare compiler to deal with different types between AP13
and AP2 SDKs. (fuankg)
Emit much more legible user.dmp crash analysis output for WIN32. (wrowe)
34558: Fix first failover request. (mturk)
Added ForwardLocalAddress JkOptions flag for passing local instead remote
address. Useful for remote addr valve. (mturk)
Fix that worker does not get used, when stopped flag is set to
true. (pero)
Add loadbalance default worker secret attribute to the documentation (pero)
Backport SC_M_JK_STORED from JK2 for passing arbitrary
methods instead failing the request. (mturk)
Added missing SEARCH and ACL http methods. (mturk)
Add worker secret attribute to the documentation (pero)
Add a stopped flag to worker configuration. Set flag to true and
the complete traffic to the worker will be stopped.
Also update the Ant JkStatusUpdateTask at Tomcat 5.5.10 release.
Only usefull in a replicated session cluster.(pero)
Added worker maintain function that will maintain all
the workers instead just the current one. This enables to recycle
the connections on all workers. (mturk)
Use shutdown when recycling connections instead hard
breaking the socket. (mturk)
Add unique directives checking. The directives if
unique are now overwritten instead concatenated. (mturk)
Allow multiple worker.list directives. (mturk)
34577: For IIS log original request instead loging
the request for ISAPI extension. (mturk)
34558: Make sure the returned status codes are the same
for ajp and lb workers. (mturk)
34423: Use APR_USE_FLOCK_SERIALIZE for setting log lock
on platforms like FreeBSD. Patch provided by Allan Saddi. (mturk)
33843: Fix obtaining LDFLAGS that were used for building
Apache HTTPD. Patch provided by Beat Kneubuehl. (mturk)
34358: Enable load balancer method configuration. (glenn)
34357: In some situations Apache 2 mod_jk could segfault
when the JkAutoAlias directive is used. (glenn)
Add --enable-prefork to the documentation (pero)
Update tomcat_trend.pl for new error log string formatting.
(glenn)
Set default shared memory to 64K instead 1M. (mturk)
Do not mark the worker in error state if headers are
larger then AJP13 limit. (mturk)
On iSeries you should use the latest PTF for Apache 2.0
(which is now 2.0.52) and ad minima SI17402/SI17061 or cumulative
including them. (hgomez)
Change the xml status format to xml attribute syntax (pero)
33248: Fix builds where apxs defines multiple
directories for APR includes. (mturk)
32696: Return 404 instead 403 when WEB-INF is requested
to comply with Servlet spec. (mturk)
Added ANT task for managing jkstatus. (pero)
If socket_timeout is set, check if socket is alive before
sending any request to Tomcat. (mturk)
Added JkMountFile for Apache web servers. This file can contain
uri mappings in the form (/url=worker), and is checked for
updates at regular 60 second interval. (mturk)
Added status worker for managing worker runtime data using
web page. (mturk)
Added load balancer method directive that is used for setting
the algorithm used for balancing workers. Method can be either
Request (default) or Traffic. (mturk)
Added shared memory to allow dynamic configuration. Shared memory
is needed only for unix platform and web servers having multiple
child processes. For Apache web server two new directives has been
added (JkShmFile and JkShmSize). (mturk)
Added textupdate mode to status worker to handle remote updates
from ant tasks.(pero)
33562: Fix Reply_timeout when recovery_options
is larger than 1. Patch provided by Takashi Satou. (mturk)
33308: Fix segfaults when ForwardDirectories is enabled
with Apache 1.3
Allow anyone to debug and diagnose stack dumps using windbg or any
other debugging tool, and (if they add the .pdb files to their
installation) to make sense of dr watson logs.
Patch provided by William A. Rowe (wrowe)
Fix in_addr_t usage by using the real struct ignoring typedef.
Patch provided by William A. Rowe (wrowe)
Fix url rewriting by restoring the in place uri from which the
jsessionid was removed. (mturk)
Make load balancer algorithm thread safe by introducing mutex
to the load balancer worker. (mturk)
Fix sending error pages for IIS to client by adding Content-Type header
using correct api function call. (mturk)
32696: Prevent IIS from crushing when web-inf url was requested. (mturk)
Use default cachesize for servers that support discovering the number of
threads per child process. (mturk).
Fix Apache content-length header parsing using case insensitive compare. (billbarker)
Fix parsing AJP headers using case insensitive compare. (mturk)
Use infinite socket timeout if socket_timeout is set to zero or less then zero. (mturk)
Change balanced_workers to balance_workers but keep
backward compatibility preserving the old directive. (mturk).
Fix ajp initialization for workers with cache_size set to zero. (mturk)
32317: Making mod_jk replication aware (Clustering Support).
Patch provided by Rainer Jung. (mturk).
31132: Core dump when JkLogFile is missing from conf. (mturk)
Added new property named recover_time that can be used to change the
default 60 second recover time. (mturk)
Added custom retries for worker, so we don't depend on default setting.
If set to a number grater then 3, it will sleep for 100ms on retry greater
then 3 and then try again. (mturk)
Added JkWorkerProperty directive that enables omiting workers.properties file.
For example: JkWorkerProperty worker.ajp13a.port=8009. (mturk)
Check all JSESSIONID cookies for a valid jvmRoute. If you have multiple Tomcats
with overlapping domains, then you can get multiple cookies without a defined order.
This will route correctly as long as the different domains don't have any
Tomcats in common. (billbarker)
Added JkUnMount directive for negative mappings that works as opposite to JkMount directives.
It is used for blocking of particular URL or content type. (mturk)
Added wildchar match uri mappings. One can now use JkMount to
map /app/*/servlet/* or /app?/*/*.jsp. (mturk)
Rewrite the logging by adding Trace options. (mturk)
Added socket_timeout property that sets the timeout
for the socket itself. (mturk)
Changed socket_timeout property to recycle_timeout. This better
explains what the directive actually does. (mturk)
Changed the load balancer algorithm.
The idea behind this new scheduler is the following:
lbfactor is how much we expect this worker to work,
or the worker's work quota.
lbstatus is how urgent this worker has to work to fulfill its quota
of work. We distribute each worker's work quota to the worker, and then look
which of them needs to work most urgently (biggest lbstatus). This
worker is then selected for work, and its lbstatus reduced by the
total work quota we distributed to all workers. Thus the sum of all
lbstatus does not change.(*)
If some workers are disabled, the others will
still be scheduled correctly. (mturk)
Fix iis redirector that was figuring .properties file on each request. (mturk)
Start fixing 64/32 bit compatibility issues. (mturk)
Fix POST Recovery problems in LB mode. (hgomez)
Add CPING/CPONG support to avoid problems with hang tomcats. (hgomez)
Make POST recovery in LB configurable. (hgomez)
Update to Apache License 2.0. (hgomez)
For Apache 2.0, when the env var no-jk is present, mod_jk didn't handle request (declined)
and as such dont forward requests to tomcats even if URL match.
To be used with SetEnvIf or BrowserMatch directives for example to exclude some URL/URI or
Browser (hgomez).
Add a fix for iSeries (AS/400) which use XOPEN/Unix98 APIs and need sa_len to be set when
calling connect(), it will resolve the error EINVAL in jk_connect. (hgomez)
Fix a thread safe bug when mapping URI's. (billbarker)
Fix a thread safe bug when resolving worker host name
when using mod_jk with Apache 2 and the worker MPM. (hgomez)
Remove an unnecessary error message when connections to
all load balanced workers fail. (glenn)
When mod_jk cannot connect to a worker include the name of
the worker in the error message. This is especially helpful
when you are using load balanced workers. (glenn)
Fix problem with mod_jk.log getting opened multiple times for
Apache 2. Only one mod_jk.log can be configured. (glenn)
Fix Apache 2 connector so that DirectoryIndex works for an
index.jsp page if JkOptions ForwardDirectories was configured. (hgomez)
Fix exposure of JSP source if a //path/to.jsp URL was requested
in Apache 1.3 and Apache 2.0 connector. (billbarker)
Fix use of libtool for Apache mod_jk builds with more recent
versions of Apache 2. (jfclere)
Use reentrant version of strtok() for web server's which use
threads. This fixes a thread safe bug under Apache 2 and the
worker MPM. (glenn)
Fix the Apache 2 mod_jk hook priority so that mod_jk works
well with both mod_alias and mod_dir. (glenn)
Add the ability to configure JkLog to pipe its log output to an
executable such as Apache rotatelogs or cronolog.
Apache 2.0 only. (glenn)
Add JkAutoAlias to Apache 2.0. (glenn)
Apache 2/1.3, if Tomcat returns an error but not content,
let Apache handle processing the error returned by Tomcat. (glenn)
Added the load balancer sticky_session property. If set to 0
requests with servlet SESSION ID's can be routed to any Tomcat
worker. Default is 1, sessions are sticky. (glenn)
Cleaned up detection and reporting of aborted client connections.
This cleanup also makes sure that mod_jk does not pass any requests
on to Tomcat if the remote client aborted its connection. (glenn)
Fixed a bug in Apache 2.0 which caused a POST request forwarded to
Tomcat to fail if it generated SSI directives which were post
processed by mod_include. (glenn)
Fixed a bug in JkRequestLogFormat when printing the request URI that
could cause a URI with hex escapes sequences to be formatted wrong. (glenn)
tomcat_trend.pl updated script to support changed logging of
aborted requests. (glenn)
jk set correctly the content-type in Apache 2.0,
making it ready to works with mod_deflate and AddOutputFilterByType. (hgomez)
jk will check result of get_endpoint and handle a failure.
This call can fail if the allocation for the endpoint fails because
of low memory conditions causing a dereference of NULL when we try and
access the endpoint. (mmanders)
14282: Don't send initial chunk for chunked encoding. (costin)
Add perl scripts for analyzing mod_jk logs and generating graphs/reports. (glenn)
Make JK honor the CanonicalHost directive. (hgomez)
Log cleanup. (costin)
Fix typos in jk xdocs/docs. (hgomez)
Add JkRequestLogFormat to Apache 2.0. (hgomez)
Final patches to make JK iSeries compliant. (hgomez)
JK2 has been put in maintainer mode and no further development will take place.
The reason for shutting down JK2 development was the lack of developers interest.
Other reason was lack of users interest in adopting JK2, caused by configuration
complexity when compared to JK.
tomcat-connectors-1.2.48-src/xdocs/miscellaneous/jkstatustasks.xml 0000644 0000000 0000002 00000016642 13623533443 023764 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Status Worker Ant TasksPeter Rossbach
Since version 1.2.19 the JK release contains additional ant tasks.
They can be used to manage the JK web server plugins via the special status worker.
tomcat-connectors-1.2.48-src/xdocs/miscellaneous/faq.xml 0000644 0000000 0000002 00000030054 13623533443 021606 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Frequently Asked QuestionsHenri Gomez
General Informations and FAQ about JK
The primary mechanism for support is through the JK
documentation included in the doc directory.
Documentation is also available on the Apache Tomcat web site devoted to the
Apache Tomcat Connectors Project
For additional help, the best resource is the Tomcat Users Discussion list.
You should start by searching
the mail list archive
before you post questions to the list.
If you are unable to locate the answer to your question in the archive,
you can post questions about JK to the user list for assistance.
Make sure that you include the version of your web server,
that you are using as well as the platform you are running on
and go
here
to determine how to subscribe to tomcat mailing list.
For more detailed information, have a look at the Reference Guide.
You could also try searching the mailing list archives for "JK" or look at the source.
ajp13 is the standard. The old
ajp12 is deprecated and ajp14 is experimental.
Also ajp13 is supported by all Apache Tomcat versions starting with Tomcat 3.2
and by other servlet engines like Jetty and JBoss.
The ajp13 protocol uses persistant connections where the traffic could be null if there is no request to be sent to Tomcat.
Firewalls use to drop inactive connections and will make your web server and Tomcat think the connection is valid.
Starting with JK 1.2.0, a socket_keepalive property as been added to ajp13 settings, and you should take a look at
it in Workers HowTo and
workers.properties reference.
If nothing else helps, you can try JkOptions +DisableReuse, but this will have strong performance implications.
Under heavy load, the Apache HTTP Server creates many children to handle the load,
which will in turn create many connections
to Tomcat to forward the requests they should handle.
The Apache HTTP Server will normally kill the children/threads when the load decreases.
But if the load is still there and even if only Apache handles the requests,
ie static contents, the children are kept and with them all the ajp13 connections,
even if they are no more used.
To close connections after some time of inactivity you can use connection_pool_timeout,
for more informations refer to workers.properties reference.
Informations and FAQ about mod_jk and the Apache HTTP Server.
The ajp13 protocol keeps an open socket between Tomcat and Apache.
Release of mod_jk present in Tomcat Connectors handles the network failure.
But with very ancient releases of mod_jk, you may have to restart Apache as well.
Many versions of Apache use a modified API, known at Extended API, developed for use with the
mod_ssl module. Starting with Apache 2.0 there is no more difference.
For example, Apache 1.3 present in certains recent Linux distributions include the
mod_ssl module.
So if you got such 'Extended Apache', you need to use mod_jk.so-eapi.
You should use mod_jk.so-noeapi only for 'Standard Apache' (ie without mod_ssl).
It's wise to avoid using EAPI modules on STD API Apache or to use standard API modules on EAPI Apache.
Allways be sure to have the mod_jk.so which match your version of Apache.
It's related to Apache EAPI, the message 'mod_jk.so is garbled - perhaps this is not an Apache module DSO ?'
just told you, that your're trying to install a mod_jk.so DSO module that was compiled on an Apache using EAPI,
like apache-mod_ssl or apache from Redhat distro 6.2/7.0 but your system use the standard Apache with normal API.
Also related to EAPI, the message '[warn] Loaded DSO /usr/lib/apache/mod_jk.so uses plain Apache 1.3 API,
this module might crash under EAPI! (please recompile it with -DEAPI)', the mod_jk.so was compiled under normal
Apache with standard API and you try to install the module on an Apache using EAPI.
APXS is a Perl script that is created when you build the Apache web server from source.
Chances are that if you are getting these errors and you obtained Apache as a binary distribution,
that APXS is not configured correctly for your system.
Your best bet is to get the Apache source from the Apache HTTP Server homepage and build it yourself.
Use the following for a basic build (read the Apache docs for other options):
[user@host] ~ $ cd /usr/local/src
[user@host] ~ $ gzip -dc apache_1.3.19.tar.gz|tar xvf -
[user@host] ~ $ cd apache_1.3.19
[user@host] ~ $ ./configure --prefix=/usr/local/apache \
--enable-module=most \
--enable-shared=max
[user@host] ~ $ make
[user@host] ~ $ make install
Note: The above steps assume that you downloaded the Apache source and placed it in your /usr/local/src directory.
Since the Apache API can change between versions, any Apache module contains the
Apache API version used to compile the module. This is called the Magic Module Number.
At start time Apache checks that the version in the module header is compatible
with the Apache server. If not it will deny to start and log an error.
Note that minor versions are forward compatible. If the module was compiled using
Apache 2.x.y the resulting binary should work with any other version 2.x.z where z
is bigger or equals to y. If you also need compatibility for versions 2.x.z
with z smaller than y, use the configure flag --enable-api-compatibility. Note
that the module compiled with any 2.x will never be compatible with 2.y for
x different from y. In this case you need to recompile the module.
mod_jk works well with Apache 2.x from 2.0 to 2.4.
Important parts of the functionality of mod_jk have been reimplemented in the Apache HTTP Server modules mod_proxy_ajp
and mod_proxy_balancer. These are part of the standard distribution of Apache 2.2 and 2.4. The new modules do not contain
all features of mod_jk, but on the other hand you get the modules automatically with every new Apache release.
JNI workers have been deprecated. They will likely not work. Do not use them.
JNI support requires a multi-threaded environment which is not the general case for Apache 1.3.
You should verify if Apache 1.3 has been build with thread support and if not you could add the
the pthreads library to your httpd.conf file.
# Add pthread to Apache in httpd.conf
LoadModule "/usr/lib/libpthreads.so"
Also keep in mind that JNI is suited for multi-threaded servers and you should consider upgrading
to Apache 2.x to support JNI.
JNI workers have been deprecated. They will likely not work. Do not use them.
Under Linux, you should set some environment variables BEFORE launching your Apache HTTP Server:
Also some Linux distributions have enabled a GLIBC feature called 'floating stacks' which may not works with kernel
less than 2.4.10 on SMP machines. You should disable floating stacks by exporting an environment variable:
export LD_ASSUME_KERNEL=2.2.5
You could have to update your service scripts, ie /etc/rc.d/init.d/httpd, to set these env vars
before your Apache server starts.
configure assume you have some GNU tools already installed and configured for your system, and ad minima libtool.
Also some systems may have mixed cc and gcc setup which may make you puzzled when trying to link an Apache built with native
c compiler with a jk/jk2 build with gcc.
In case the make processing doesn't work as expected, you should use a GNU make gmake.
tomcat-connectors-1.2.48-src/xdocs/miscellaneous/doccontrib.xml 0000644 0000000 0000002 00000022666 13623533443 023177 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
How to Contribute to the DocumentationRobert Sowders
This document describes how you can easily contribute to the
documentation. I'm going to try to make it easy for everyone to help out with
the documentation of Tomcat, more specifically the documentation for the
connectors. This is written from a windows user perspective as I believe they
will most benefit from it. For people using Unix it should be easy for them to
apply these steps. Just substitute Unix syntax where needed.
The documentation is produced using xml with xsl style sheets. This
effectivly seperates the content of the documents from the style, so all that
contributers need to worry about the content. It is much easier to use than
html.
It's all really quite simple. Here is what you will need:
A recent version of Ant
The source code for the connectors from subversion
Any ascii text editor
After you get these tools they are simple to set up.
Install Ant. The only advice I
have is to choose a simple installation path. Now set an environment variable
for ANT_HOME, and then add the location of the Ant/bin directory to your PATH
variable. Consult your Operating system documentation for information on how
to do this. When you are finished verify that you can run ant from the command
line.
Ant is used to build the documentation, among other things, and it must be
able to see a file called build.xml. This file is located in the
xdocs directory. In the
build.xml file there is a target named all that will be used to build
the docs.
Get the sources for
tomcat-connectors
from the git repository. You will need a git client. Install the client of
your choice, if you don't already have one.
You are ready to download the sources now. Change directory to the
location where you want your repository to be. For simplicity we will call this
your GIT_HOME. Mine is located in C:\build.
Run the following command to clone the sources for the first time.
You should only need to do this once.
C:\build\>git clone https://github.com/apache/tomcat-connectors tomcat-connectors
You should now be watching all the downloads come in. Now that you have
the sources on your machine the hard part is over. From now on, to update your
sources all you have to do is cd into any directory in your repository and run
the git pull command.
Open a command prompt window and cd to the directory where you downloaded
the source. Now cd into the xdocs directory so that Ant can see the
build.xml file. Then from a command prompt, run the following:
C:\build\tomcat-connectors> cd xdocs
C:\build\tomcat-connectors\xdocs> ant all
.
You should see the ant compiler messages scrolling by rapidly and then stop
with the following:
[style] Transforming into C:\build\tomcat-connectors\build\docs\news\printer>
[style] Processing C:\build\tomcat-connectors\xdocs\news\20041100.xml
to
C:\build\tomcat-connectors\build\docs\news/20041100.html
[style] Loading stylesheet C:\build\tomcat-connectors\xdocs\style.xsl
[style] Processing C:\build\tomcat-connectors\xdocs\news\20050101.xml
to
C:\build\tomcat-connectors\build\docs\news/20050101.html
[style] Processing C:\build\tomcat-connectors\xdocs\news\20060101.xml
to
C:\build\tomcat-connectors\build\docs\news/20060101.html
[style] Transforming into C:\build\tomcat-connectors\build\docs>
[style] Processing C:\build\tomcat-connectors\xdocs\index.xml
to
C:\build\tomcat-connectors\build\docs\index.html
[style] Loading stylesheet C:\build\tomcat-connectors\xdocs\style.xsl
BUILD SUCCESSFUL
Total time: 10 seconds
C:\build\tomcat-connectors>
All the xml files present in the xdocs directory structure were transformed
to html and copied to the GIT_HOME\tomcat-connectors\build\docs
directory. Open one of the
html files in your browser and see how it looks.
I find it easier to use two windows while doing my updates. One I call my
build window. I keep this one in the GIT_HOME\tomcat-connectors\xdocs
directory and I only run two commands in this window:
First I runant clean
Then I runant all
My second window I call my edit window and I keep that one in the
GIT_HOME\tomcat-connectors\xdocs directory where I'm doing my
edits, diffs and git pulls.
Before you start editing you should always update your local repository to
prevent conflicts.
C:\build\tomcat-connectors> git pull
Now that your repository is up to date you can begin editing. Find
something in the documentation to edit. When you find something remember the
name of the file. In your edit window find and edit the xml source file
with the same name. After you are done return to the build window, and
in the GIT_HOME\tomcat-connectors\xdocs directory run:
C:\build\tomcat-connectors\xdocs> ant clean
This will delete all the previous html files and make the area ready for
updated material. Now to make fresh documents that incorporate your changes
run:
C:\build\tomcat-connectors\xdocs> ant all
Use your browser to view the edits you just made, they will be in the
GIT_HOME\tomcat-connectors\build\docs sub-tree. If it looks
good and is ready to go,
all that is left to do is to create a patch and submit it.
From your edit window cd into the directory that contains the xml
file you are working on, and run the git pull command. For example,
to produce a diff of the index.xml file and call it patch.txt, you
would cd into the directory containing the index.xml file and:
C:\build\tomcat-connectors\xdocs\>git diff index.xml >
patch.txt.
Now that you have your patch you are ready to send it in.
Patches to the documentation are handled just like a bug report. You
should submit your patches to http://issues.apache.org/bugzilla/
and include a good one line subject. If this is your first time to use the
bug database then you should read http://issues.apach
e.org/bugzilla/bugwritinghelp.html. You will need to create a user
account. At the web site paste your patch into the web form and don't forget
to describe what it is your patch is for. Sooner or later a someone with
commit privileges will review your suggestion.
Only Committers are able to update the web site (http://tomcat.apache.org/connectors-doc/).
To do it:
Connect to people.apache.org.
umask 002
Copy the changed files to /www/tomcat.apache.org/connectors-doc/.
or use ant from a checkout tomcat/jk/trunk/xdocs repository:
ant -Dbuild.dir=/www/tomcat.apache.org -Ddist.name=connectors-doc
The changes should sync to tomcat.apache.org within seconds.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20140201.xml 0000644 0000000 0000002 00000004776 13623533443 020055 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2014 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.40. This is a stable release concentrating mainly on
bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.39. This is a stable release containing both bug fixes and
few new features like IPV6 support. Note that version 1.2.38 was not released due to
some minor issues found in release process.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20100101.xml 0000644 0000000 0000002 00000006135 13623533443 020037 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2010 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.31. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.30. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
Tomcat Connectors 1.2.29 has been withdrawn because of regression inside
Microsoft IIS connector.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.29. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20090301.xml 0000644 0000000 0000002 00000006701 13623533443 020050 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2009 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.28. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The most important new features in this version are:
Better Error Detection for Load Balancer Workers
Local and global error states have been improved. You can fine tune the
behaviour with the new "error_escalation_time" attribute
(see the timeouts documentation).
Dynamic Address and Port Change Using the Status Worker
The status worker now allows you to change the address and the port
of an AJP13 worker on the fly. You can e.g. provision dummy workers with a port
equal to "0", which will be automatically put into stopped mode during startup.
Later, when you want to actually use these workers, you set their address and
port to the final values.
Note that already existing connections will go on using the old
address and port. This will be improved in future versions.
New Data in Status Worker Display
The status worker display now also contains the timestamp of the last
worker errors.
Improved Proxy Flexibility
You can now overwrite more request metadata before the request gets send to the backend.
This is helpful in case there are other reverse proxies in front of your web server.
A new documentation page explains this in detail.
Improved IIS Support
IIS support has been improved especially when using mutltiple application pools.
Furthermore you can now configure the ISAPI plugin to update the uriworkermap.properies
file on a regular interval using the watchdog thread.
JNI Worker Deprecation
Workers of type jni are broken since a long time. Since there is no more
use for them, they have been deprecated now, and will be removed in a future release.
tomcat-connectors-1.2.48-src/xdocs/news/20200201.xml 0000644 0000000 0000002 00000003247 13623533443 020042 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2020 News & Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.48. This is a maintenance release.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20041100.xml 0000644 0000000 0000002 00000013715 13623533443 020044 0 ustar root bin
]>
&project;
Apache Jakarta Project2004 News and Status
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.7-beta-3. The release contains a fix to few configuration
problems detected with JK-1.2.7-beta-2 version.
We expect it to be ratified as a Stable release when the vote takes place
in the next week.
Please see the ChangeLog for a full list of changes.
If you find any bugs during testing this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.7-beta-2. The release contains a fix to few compilation
problems detected with JK-1.2.7-beta version. This release also introduces a new
domain concept clustering support. See 32317 for details.
We expect it to be ratified as a Stable release when the vote takes place
in the next two weeks.
Please see the ChangeLog for a full list of changes.
If you find any bugs during testing this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.7-beta. The release contains a significant number
of bug fixes and new features.
We expect it to be ratified as a Stable release when the vote takes place
in the next two weeks.
Please see the ChangeLog for a full list of changes.
Since release 1.2.7 the socket_timeout property has been renamed to
recycle_timeout.
The socket_timeout now sets the real timeout for socket operations.
If you find any bugs during testing this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
JK2 has been put in maintainer mode and no further development will take place.
The reason for shutting down JK2 development was the lack of developers interest.
Other reason was lack of users interest in adopting JK2, caused by configuration
complexity when compared to JK.
The latest official JK2 release is 2.0.4.
JK2 will have it's successor within core Apache2.1/2.2 distribution.
We have developed new proxy_ajp that is an addition to
the mod_proxy and uses Tomcat's AJP protocol stack. It is developped in httpd-2.1
and integrated in it. We have also developed a new proxy_balancer module
for load balancing http and ajp protocol stacks.
JK will be fully supported for all other web servers. The next JK release is
planned for the end of November. Lots of code from JK2 has been ported to JK
tomcat-connectors-1.2.48-src/xdocs/news/20060101.xml 0000644 0000000 0000002 00000007707 13623533443 020052 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2006 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.20. This is a stable release adding new features
and a few bug fixes to version 1.2.19.
Furthermore the documentation has been reorganised.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.19. This is a stable release adding some features
and a few bug fixes to version 1.2.18.
Furthermore the non-functional code trees for isapi and domino have been removed.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.18. This is a stable release adding
a few bug fixes to the not released 1.2.17 version.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
Version 1.2.16 of Tomcat Connectors 1.2.16 has not been released
due to a bug in the jk status worker. This version adds some features
and a few bug fixes to the 1.2.15 version. Furthermore some worker attributes
have been deprecated.
Please see the ChangeLog for a full list of changes.
tomcat-connectors-1.2.48-src/xdocs/news/20180301.xml 0000644 0000000 0000002 00000005437 13623533443 020055 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2018 News & Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.46. This is a maintenance release.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.44. This is a maintenance release.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.43. This is a maintenance release.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20081001.xml 0000644 0000000 0000002 00000017163 13623533443 020051 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2008 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.27. This is a stable release adding lots of new features
and some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The most important new features in this version are:
Watchdog Thread for Periodic Tasks
The connector has to run some periodic tasks independant of
request processing. Examples are probing or closing down idle backend
connections, adjusting load numbers and recovering workers from error state.
Before version 1.2.27 these tasks were done inside the request processing loop.
When a new request came in and the task was due, the thread handling the
request first executed the internal task and then handled the request.
If there were no requests coming in, the tasks would not run. If any of
the tasks took unexpectedly long, the response time of the request waiting
for the finishing of the task went up.
Starting with this release you can configure a separate watchdog thread inside
the web server to run all those tasks independantly of request processing.
This new feature is avaliable for the connector when used with Apache httpd 2.x
or with Microsoft IIS. To keep the behaviour of the new version consistent
with previous releases, this feature is turned off by default.
You can activate the watchdog thread via
JkWatchdogInterval
for Apache or
watchdog_interval
for IIS.
Connection Probing
In previous releases connection probing (checking whether connections still work)
could only be done immediately after a new connection was established and
directly before sending each request. Since we now have the watchdog
thread available, we also added a periodic probing option, which you
can activate with the worker attribute
ping_mode.
This will also be useful as a protection against the infamous firewall
idle connection drop.
The older attributes connect_timeout and prepost_timeout
still exist and work the same way they did in previous releases.
Since there are now three different probing options, we recommend to migrate
your configuration to the newer attributes ping_mode,
ping_timeout and connection_ping_interval.
Mount Extensions
Usually one defines workers and mounts for the connector.
A worker defines a backend we want to talk to and the configuration parameters of the
communication, connection pools etc. The mounts define which URIs we want to forward to
which worker (so we also call a mount an URI map rule).
In version 1.2.27 you can overwrite certain worker parameter per mount.
One easy to understand example is reply timeouts. Until this release you had to specify
a reply timeout for the whole worker. But reply times depend a lot on the type of
request. So normally you want to define a general reply timeout and
for some special URLs you need to relax the reply timeout, because you know those
URLs take much longer to process (like e.g. reporting or other compute intensive tasks).
Another possible case is the activation status. You might use a load balancer worker to
forward requests to certain webapps in a farm of Tomcat nodes. If you wanted
to update some webapp on one node, you previously had to stop forwarding requests for
all webapps on this Tomcat node. What was not possible until now, was stopping forwarding
requests restricted to the webapp and the node you wanted to update.
Starting with this release, you can add so-called
rule extensions
to your uriworkermap file to influence worker parameters per mount. This will
work for all Apache versions and for IIS. Remember, that
the uriworkermap file automatically gets reloaded after changes without web server
restart.
Improved IIS support
We improved IIS support im various ways. It is now possible to use
multiple IIS 6 application pools with the ISAPI redirector.
Furthermore some improvements were added as compile time features.
The most notable one is chunked encoding support, which was a major
refactoring and is therefore still considered experimental. You can
download binaries with and without chunked encoding support. In future
versions, chunked encoding will likely be availabe in all builds.
Another new feature is an elegant way of configuring error page redirects.
All new features are documented on the documentation page about
configuring IIS.
Enhanced Status Worker
The
status worker
now can also manage and show statistics for AJP workers that
are not part of a load balancer. Other improvements are the new dump
action, the integration of the new configuration attributes, showing average
request and transfer rates since the last statistics reset and the ability to
display only a single member of a load balancer.
Unfortunately we had to change
some request parameters
used for the update action of the status worker.
Miscellaneous Improvements
Further enhancements are:
Configurable session stickyness indicator: cookie name and URL path
parameter name can be freely chosen instead of the servlet spec compliant
JSESSIONID and ;jsessionid.
Automatically determining the size of the shared memory segment needed
to accommodate all workers.
New connection establishment timeout socket_connect_timeout.
New timeout connection_acquire_timeout for acquiring a free connection from
the pool.
Improved retry handling by adjusting the meaning of the attribute retries for
AJP workers and for load balancers and by adding the new retry_interval.
Allowing the web server to provide error pages instead of Tomcat.
tomcat-connectors-1.2.48-src/xdocs/news/20160901.xml 0000644 0000000 0000002 00000003247 13623533443 020056 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2016 News & Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.42. This is a maintenance release.
Please see the ChangeLog
for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20050101.xml 0000644 0000000 0000002 00000014574 13623533443 020051 0 ustar root bin
]>
&project;
Apache Jakarta Project2005 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.15. This is Stable release and it contains
few bug fixes found in 1.2.14 version.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.14. This is Stable release and it contains
few bug fixes found in 1.2.13 version.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.13. This is development release and contains
few bug fixes found in 1.2.12 version.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.12 The release contains a significant number
of bug fixes and new features.
We expect it to be ratified as a Stable release when the vote takes place
in the next week.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.11 The release contains a significant number
of bug fixes and new features.
This version has not been released.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.10 The release contains a significant number
of bug fixes and new features.
We expect it to be ratified as a Stable release when the vote takes place
in the next two weeks.
Please see the ChangeLog for a full list of changes.
Since release 1.2.10 the JkShmFile property has been added for
Apache 1.3.x and Apache 2.x web servers on UNIX and LINUX platforms.
Load balancer will not work properly if this directive is not present.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Jakarta Tomcat team is proud to announce the immediate availability
of Jakarta Tomcat Connectors 1.2.9-beta. The release contains a significant number
of bug fixes and new features.
We expect it to be ratified as a Stable release when the vote takes place
in the next two weeks.
Please see the ChangeLog for a full list of changes.
Since release 1.2.9 the JkShmFile property has been added for
Apache 1.3.x and Apache 2.x web servers on UNIX and LINUX platforms.
Load balancer will not work properly if this directive is not present.
If you find any bugs during testing this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
tomcat-connectors-1.2.48-src/xdocs/news/20120301.xml 0000644 0000000 0000002 00000010317 13623533443 020040 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2012 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.37. This is a stable release concentrating mainly on
bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.36. This is a stable release concentrating mainly on
bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.35. This is a stable release concentrating mainly on
bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
The Apache Tomcat team wishes to draw your attention to stability issues
that have been identified with the recent mod_jk 1.2.33 release. If you
have not yet upgraded to mod_jk 1.2.33 we recommend that you wait for
the mod_jk 1.2.34 release which is currently in progress. If you have
upgraded and are experienced issues we recommend that you downgrade to
mod_jk 1.2.32 until mod_jk 1.2.34 is available.
We apologise for any inconvenience.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.33. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20110701.xml 0000644 0000000 0000002 00000003415 13623533443 020044 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2011 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.32. This is a stable release concentrating mainly on
some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report.
tomcat-connectors-1.2.48-src/xdocs/news/20070301.xml 0000644 0000000 0000002 00000011103 13623533443 020036 0 ustar root bin
]>
&project;
Apache Tomcat Connectors Project2007 News and Status
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.26. This is a stable release adding few new features
and some bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.25. This is a stable release adding new features
and a few bug fixes.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.23. This is a stable release adding new features
and a few bug fixes to version 1.2.23.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.22. This is a stable release adding new features
and a few bug fixes to version 1.2.22.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
The Apache Tomcat team is proud to announce the immediate availability
of Tomcat Connectors 1.2.21. This is a stable release adding new features
and a few bug fixes to version 1.2.20.
Please see the ChangeLog for a full list of changes.
If you find any bugs while using this release, please fill in the
Bugzilla
Bug Report. When entering bug select Native:JK Component.
tomcat-connectors-1.2.48-src/xdocs/news/project.xml 0000644 0000000 0000002 00000012267 13623533443 020624 0 ustar root bin
The Apache Tomcat Connectors - News
The Apache Tomcat Connectors - News
tomcat-connectors-1.2.48-src/xdocs/empty.xml 0000644 0000000 0000002 00000002367 13623533443 017340 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Empty templateDeveloper Name
This is a generic template for JK documentation. Please fill in the url and title
tags, as well as author tags.
tomcat-connectors-1.2.48-src/xdocs/webserver_howto/ 0000755 0000000 0000002 00000000000 13623533443 020674 5 ustar root bin tomcat-connectors-1.2.48-src/xdocs/webserver_howto/iis.xml 0000644 0000000 0000002 00000067072 13623533443 022216 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
ISAPI redirector for Micrsoft IIS HowToHenri GomezGal ShachorYoav Shapira
This document explains how to set up the ISAPI redirector for IIS to cooperate with Tomcat.
Normally IIS can not execute Servlets and Java Server Pages (JSPs),
configuring IIS to use the ISAPI redirector plugin will let IIS send servlet and
JSP requests to Tomcat (and this way, serve them to clients).
It is recommended that you also read the
Workers HowTo document
to learn how to setup the working entities between your web server and Tomcat Engines.
For more detailed configuration information consult the Reference Guide for
workers.properties,
uriworkermap
and IIS.
${tomcat_home} is the root directory of tomcat.
Your Tomcat installation should have the following subdirectories:
${tomcat_home}\conf - Where you can place various configuration files
${tomcat_home}\webapps - Containing example applications
${tomcat_home}\bin - Where you place web server plugins
In all the examples in this document ${tomcat_home} will be c:\tomcat.
A worker is defined to be a tomcat process that accepts work from the IIS server.
The IIS to Tomcat redirector is supported for:
IIS running on Windows 8.1 or later
IIS running on Windows Server 2012 or later
Tomcat 7 or later
The redirector may work with IIS running on older versions of Windows but such
configurations are not supported.
The mod_jk module uses the AJP protocol to send requests to the Tomcat
containers. The AJP version used is ajp13. All current versions Tomcat
support the ajp13 protocol. Others servlet engines such as Jetty and
JBoss also support the ajp13 protocol.
The ISAPI redirector is a Microsoft IIS plugin (filter + extension). IIS loads
the redirector plugin and calls its filter function for each in-coming request.
The filter then tests the request URL against a list of URI-paths held inside
uriworkermap.properties. If the current request matches one of the entries in
the list of URI-paths, the filter transfers the request to the extension.
The extension collects the request parameters and forwards them to the
appropriate worker using the defined protocol like ajp13.
The extension collects the response from the worker and returns it to the
browser.
Pre-built versions of the ISAPI redirector plugin, isapi_redirect.dll, for
32-bit and 64-bit environments are available from the
Apache Tomcat
Connectors Downloads page.
You can also build a copy locally from the Tomcat Connectors source
distribution.
The ISAPI redirector requires three entities:
isapi_redirect.dll - The ISAPI redirector for Microsoft IIS plugin,
either obtain a pre-built DLL or build it yourself (see the build section).
workers.properties - A file that
describes the host(s) and port(s) used by the workers (Tomcat processes).
A sample workers.properties can be found under the conf directory.
uriworkermap.properties - A
file that maps URL-Path patterns to workers.
A sample uriworkermap.properties can be found under the conf directory as well.
The installation includes the following parts:
Configuring the ISAPI redirector with a default /examples context and checking
that you can serve servlets with IIS.
Adding more contexts to the configuration.
These instructions have been written based on Windows Server 2012 R2 and
tested with all supported Windows operating systems up to Windows 10 / Windows
Server 2019.
These installation instructions have been tested with a default installation of
IIS plus ISAPI Extensions and Filters on a clean, fully patched OS installation
with Tomcat 9 installed in C:\Program Files\Apache Software Foundation\Tomcat
9.0. This is referred to as ${tomcat_home} for the remainder of this
document.
Create a directory ${tomcat_home}\isapi
Allow the IIS process to create the ISAPI redirector log file. Modify the path
as necessary if the log file is to be written to a different directory. Enter
the following at a command prompt:
>icacls "C:\Program Files\Apache Software Foundation\Tomcat 9.0\isapi" /grant "IIS APPPOOL\DefaultAppPool":(OI)(CI)M
On client operating systems with User Account Control (UAC) enabled, the command
prompt must be opened using Run as administrator for the above command to
complete successfully.
Download the appropriate (32-bit or 64-bit) isapi_redirect.dll for your
operating system and place it in ${tomcat_home}\isapi
Set the premissions for isapi_redirect.dll. On Windows Server 2019 it appears to be
necessary to explicitly set the permissions for this dll. Enter
the following at a command prompt:
>icacls "C:\Program Files\Apache Software Foundation\Tomcat 9.0\isapi\isapi_redirect.dll" /grant "Everyone":RX
Create ${tomcat_home}\isapi\isapi_redirect.properties file to configure the ISAPI
redirctor. Configuration can also be performed via registry settings - see
below. The contents of this file should be:
extension_uri=/jakarta/isapi_redirect.dll
log_file=C:\Program Files\Apache Software Foundation\Tomcat 9.0\isapi\isapi_redirect.log
log_level=info
worker_file=C:\Program Files\Apache Software Foundation\Tomcat 9.0\isapi\workers.properties
worker_mount_file=C:\Program Files\Apache Software Foundation\Tomcat 9.0\isapi\uriworkermap.properties
Be careful so that Windows does not add a .txt extension to the file.
Create ${tomcat_home}\isapi\workers.properties file to configure the Tomcat
instances that requests will be passed to. For a single Tomcat instance on the
local machine the contents of this file should be:
worker.list=tomcat01
worker.tomcat01.type=ajp13
worker.tomcat01.host=localhost
worker.tomcat01.port=8009
Create ${tomcat_home}\isapi\uriworkermap.properties file to configure which
requests will be passed to Tomcat. To expose the examples web application the
contents of this file should be:
/examples/*=tomcat01
Using the IIS management console, add a new virtual directory to your IIS web
site. In a clean install, this will be the Default Web Site. The name of
the virtual directory must be jakarta. Its physical path should be the
directory where you placed isapi_redirect.dll.
Select the newly created virtual directory in the management console and then
double-click Handler Mappings. Select the (currently disabled)
ISAPI-dll entry and then click Edit Feature Permissions in the
action pane. In the dialog box that opens, select Execute so all three
permissions are selected. Click OK and ISAPI-dll should now be in
the enabled state.
Again using the IIS management console, add the ISAPI redirector as a filter to
your web site. Select your web site and then double-click ISAPI Filters.
From the action pane, click Add.... For the filter name use tomcat
and the executable should be the full path to isapi_redirect.dll. Once
configured, click OK.
Still using the IIS management console, configure the ISAPI redirector as
allowed. Select your server (not the web site) and then double-click on ISAPI
and CGI Restrictions. From the action pane, click Add.... Select the
isapi_redirect.dll, add a descripion (e.g. tomcat) and select the Allow
extension path to execute and then click OK.
Restart IIS (stop + start the IIS service).
That's all, you should now start Tomcat and ask IIS to serve you the /examples
context. Try http://localhost/examples/
for example and execute some of the Servlet or JSP examples.
If this does not work successfully, refer to the Troubleshooting section below for help on correcting the problem.
If the IIS access logs show entries such as /jakarta/isapi_redirect.dll
rather than /examples/servlets then this can be corrected via the IIS
management console. Select your server (not the web site) and then double-click
on Modules. In the Actions pane, click
View Ordered List..., select the IsapiFilterModule and move it up
until it is above the HttpLoggingModule.
As an alternative to using the isapi_redirector.properties file, the
ISAPI redirector may be configured via the registry. To do this, follow these
steps:
In the registry, create a new registry key named
"HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0"
Add a string value with the name extension_uri and a value of /jakarta/isapi_redirect.dll
Add a string value with the name log_file and a value pointing to where you want your
log file to be (for example c:\tomcat\logs\isapi.log).
Add a string value with the name log_level and a value for your log level
(can be debug, info, error or emerg).
Add a string value with the name worker_file and a value which is the full path
to your workers.properties file (for example c:\tomcat\conf\workers.properties)
Add a string value with the name worker_mount_file and a value which is the full path
to your uriworkermap.properties file (for example c:\tomcat\conf\uriworkermap.properties)
In a 64 Bit environment the used IIS Application Pool should have "Enable 32-bit
Applications" set to "False". To check this, select Application Pools in
the IIS management console, then right-click on the pool you are using and
select Set Application Pool Defaults.... Enable 32-Bit
Applications may be found in the General section. If this is not
configured correctly, the redirector will not be called and IIS will return an
HTTP code 404.
You must use the 64-bit version of the ISAPI redirector on 64-bit operating
systems. If you attempt to use the 32bit version, you will get an HTTP code 500
for every request because the library is not loadable into a 64-bit IIS.
The examples context is useful for verifying your installation,
but you will also need to add your own contexts. Adding a new context requires two operations:
Adding the context to Tomcat (I am not going to talk about this).
Adding the context to the ISAPI redirector.
Adding a context to the ISAPI redirector is simple, all you need to do is to edit
your uriworkermap.properties and to add a line that looks like:
/context/*=worker_name
Workers and their name are defined in workers.properties, by default workers.properties comes
with a single pre-configured worker named "defworker" so you can use it.
As an example, if you want to add a context named "shop", the line that you should add to
uriworkermap.properties will be:
/shop/*=defworker
After saving uriworkermap.properties restart IIS and it will serve the new context.
The above should be all you need for IIS to pass through to Tomcat any request for any URI which corresponds
to a Tomcat context (webapp).
If your webiste is very busy (more than 100 requests/second, or more than 100 simultaneous client connections),
it might sometimes be desirable to have IIS serve static content (html, gif, jpeg etc.) directly,
even if these files are part of a context served by Tomcat. Allowing IIS to serve such files directly may
avoid the small overhead consisting of passing the request to Tomcat via the redirector, and may free up
Tomcat somewhat, by using it only to process requests that only Tomcat can handle (e.g. requests to JSP pages and java servlets).
For example, consider the html and gif files in the examples context: you could serve these files directly
with IIS; there is no need to serve them from the Tomcat process.
However, you should be very careful when you implement the following configuration style, because by doing so you are
in fact providing a "back-door" to IIS, and allowing it to serve files out of a Tomcat context without Tomcat's knowledge,
thus bypassing any security
restrictions which Tomcat itself and the Tomcat context (webapp) may place on those files.
Making IIS serve static files that are part of the Tomcat contexts requires the following:
Configuring IIS to know about the Tomcat contexts
Configuring the redirector to leave the static files for IIS
Adding a Tomcat context to IIS requires the addition of a new IIS virtual directory that covers the Tomcat context.
For example adding a /example IIS virtual directory that covers the c:\tomcat\webapps\examples directory.
Configuring the redirector is somewhat harder, you will need to specify the exact
URL-Path pattern(s) which you want Tomcat to handle (usually only JSP files and servlets).
This requires a change to the uriworkermap.properties:
For the examples context it requires to replace the following line
/examples/*=defworker
with the following two lines
/examples/*.jsp=defworker
/examples/servlet/*=defworker
As you can see the second configuration is more explicit, it actually instruct the redirector
to redirect only requests to resources under /examples/servlet/ and resources under /examples/
whose name ends with .jsp.
You can even be more explicit and provide lines such as:
/example/servlets/chat=defworker
that instructs the redirector to redirect all requests whose URL-path matches the leading string "/example/servlets/chat"
to the worker named defworker.
Once again, be aware that by allowing IIS to access the content of your Tomcat context directly, you are
potentially bypassing Tomcat's protection of that content. You should thus make sure to protect this content
at the IIS level if needed, by using the corresponding IIS management console functions.
In particular, each servlet application (context) has a special directory named WEB-INF,
which contains sensitive configuration data and Java classes, and which should always be kept hidden from web users.
Using the IIS management console it is possible to protect the WEB-INF directory from user access, but considering that
this is a general requirement, and considering that it is easy to forget to implement this protection
at the IIS level, the ISAPI redirector plugin does it automatically for you, and it will reject any request
which contains WEB-INF in its URL path. It will also reject any request which contains META-INF in its URL path.
Sometimes you may want to serve different contexts with different Tomcat processes
(for example to spread the load among different machines).
To achieve such a goal you will need to define several workers and assign each context to its own worker.
Defining additional workers is done in the workers.properties file. This file includes two types of entries:
# An entry that lists all the workers defined
worker.list=worker1, worker2
# Entries that define the host and port associated with each of these workers
worker.worker1.host=localhost
worker.worker1.port=8009
worker.worker1.type=ajp13
worker.worker2.host=otherhost
worker.worker2.port=8009
worker.worker2.type=ajp13
The above example defined two workers, now we can use these workers to serve two different contexts
each with its own worker:
example uriworkermap.properties fragment
/examples/*=worker1
/webpages/*=worker2
As you can see the examples context is served by worker1 while the
webpages context is served by worker2.
The redirector was developed using Microsoft Visual C++, so having Visual Studio installed
is a prerequisite if you want to perform your own build.
You can build the source using the IDE GUI, or using a pure
commandline build based on nmake. The IDE build currently only
supports building 32 Bit binaries. The nmake builds are available
for 32 Bit, 64 Bit and Itanium binaries.
The common steps for all build procedures are:
Set up your build environment for 32 Bits or 64 Bits.
The IDE build only supports 32 Bits.
Download the sources as a zip file and unpack it.
Change directory to the ISAPI redirector source directory.
Set up 32 or 64 Bit build environmentsetenv /Release /X86or (not available for IDE build)setenv /Release /X64Download tomcat-connectors-xxx-src.zip fromhttps://tomcat.apache.org/download-connectors.cgiand unpack itunzip tomcat-connectors-xxx-src.zipChange directory to the ISAPI redirector source directorycd tomcat-connectors-xxx-src\native\iis
The steps for an IDE build are then:
Start Visual Studio using "start isapi.dsw"
During IDE startup choose "Yes" in all conversion popups.
Next choose "Debug" or "Release" in the Configuration dropdown.
Finally choose "Build Solution" in the "Build" menu.
The resulting file isapi_redirect.dll (and the debug symbol file
isapi_redirect.pdb) is located in the "Debug" resp. "Release" sub
directory depending on the build Configuration chosen. As an
intermediate step the build first creates a static PCRE library
named pcre.lib in the sub directory "pcre/LibD" resp. "pcre/LibR".
Alternatively the steps for an nmake commandline build are:
Issue "nmake -f Makefile.x86" for a 32 Bit build, or
Issue "nmake -f Makefile.amd64" for a 64 Bit build
The resulting file isapi_redirect.dll (and the debug symbol file
isapi_redirect.pdb) is located in the "Release_x86" or "Release_amd64"
sub directory. As an intermediate step the build first creates a static
PCRE library named pcre.lib in the sub directory "pcre/Release_x86" or
"pcre/Release_amd64".
It is easy to have the ISAPI redirector not work the first time you try to install it.
If this happens to you, here are some steps to follow to try to correct the problem.
These steps aren't guaranteed to cover all possible problems,
but they should help find the typical mistakes.
If you make any corrections during these steps, restart the IIS service as described above in the last step
of the installation, then retry the step.
To enable error tracking, make sure web site activity is being logged.
For PWS 4.0 make sure "Save Web Site Activity Log" is checked in the Advanced Options of the Personal Web Manager.
Note: These steps assume your worker_mount_file setting points to an unmodified copy of the
uriworkermap.properties file.
Results may be misleading if worker_mount_file points to a modified uriworkermap.properties
or the uriworkermap.properties-auto file.
It is also assumed that the "/examples" context works correctly if you access Tomcat directly.
Start the IIS service and Tomcat.
Check for the presence of the ISAPI redirector log file you specified in the log_file setting.
If not found, verify the following:
Check the "Filter DLLs" setting in the "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\W3SVC\Parameters"
key and make sure the path is correct.
Check the spelling of the "HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0" key.
Case isn't important, but an incorrect letter will prevent the isapi_redirect.dll from finding its registry settings.
Check the log_file setting for typos, name and data. Also insure the directory in which the log file will appear already exists.
If the above are set correctly, the ISAPI redirector should be able to create the log file.
Invoke the URL http://localhost/examples/
in your browser.
Case is important in Tomcat. The characters following "localhost" in the URL must be lower case.
If the page fails to appear, stop the IIS service (required to view the IIS log file).
Then examine the last line in the IIS log file in found in SYSTEM/LogFiles/W3SVC1:
If the last line contains:
GET "/examples/ HTTP/1.1" 404
then the ISAPI redirector is not recognising that it should be handling requests for the "/examples" context.
Check the following:
Check the extension_uri name for typos.
Check the worker_file setting for typos, name and data.
Check the worker_mount_file setting typos, name and data.
If these are set correctly, the ISAPI redirector should recognise that it should handle requests for the "/examples" context.
If the last line contains something like:
GET "/jakarta/isapi_redirect.dll HTTP1.1"
then the ISAPI redirector is recognising that it should handle the request,
but is not successful at getting Tomcat to service the request.
You should check the HTTP error code following GET "/...":
Error 404
GET "/..." 404
Make sure you entered the URL correctly.
Make sure the virtual directory created was called "jakarta".
It should display in Personal Web Manager as "/jakarta" (without the quotes).
Make sure the extension_uri data begins with "/jakarta/" (without the quotes).
Error 500
GET "/..." 500
Make sure that "isapi_redirect.dll" follows "/jakarta/" in the extension_uri setting.
Check the workers.properties file and make sure the port setting for worker.ajp13.port is the same as the port specified in the server.xml for the "AJP" connector.
Error 200 or 403
GET "/..." 200
GET "/..." 403
Make sure you have checked Execute Access
for the jakarta virtual directory in the Advanced Options of the Personal Web Manager.
If the above settings are correct, the index.html page should appear in your browser.
You should also be able to click the links to execute some Servlet or JSP examples.
Start the World Wide Web Publishing Service and Tomcat.
Check for the presence of the ISAPI redirector log file you specified in the log_file setting.
If not found, check the following:
Check the "executable" you set for the filter in the IIS Management Console and make sure the path is correct.
Check the spelling of the "HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0" key.
Case isn't important, but an incorrect letter will prevent the isapi_redirect.dll from finding its registry settings.
Check the log_file setting for typos, name and data. Also insure the directory in which the log file will appear already exists.
If the above are set correctly, the ISAPI redirector should be able to create the log file.
Check the tomcat filter you added and make sure its status shows a green upward-pointing arrow.
If not, check the following:
Check the worker_file setting for typos, name and data.
Check the worker_mount_file setting typos, name and data.
If the above are set correctly, the green upward-pointing arrow should appear, even if the other settings are wrong.
Invoke the URL http://localhost/examples/
in your browser. Case is important in Tomcat. The characters following "localhost" in the URL must be lower case.
If the page fails to appear, examine the last line in the IIS server log file in found in SYSTEM32/LogFiles/W3SVC1.
The last line should contain something like: GET "/jakarta/isapi_redirect.dll HTTP1.1",
which indicates the ISAPI redirector is recognising that it should handle the request.
You should check the HTTP error code following GET "/...":
Error 404
GET "/..." 404
Make sure you entered the URL correctly.
Error 500
GET "/..." 500
Make sure the virtual directory created was called "jakarta".
Make sure that the extension_uri setting is correct.
Check the workers.properties file and make sure the port setting for worker.ajp13.port is the same as the port specified in the server.xml for the "AJP" connector.
Error 200 or 403
GET "/..." 200
GET "/..." 403
Make sure you have checked Execute Access for the jakarta virtual directory in the
Advanced Options of the Personal Web Manager.
If the above settings are correct, the index.html page should appear in your browser.
You should also be able to click the links to execute some Servlet or JSP examples.
tomcat-connectors-1.2.48-src/xdocs/webserver_howto/nes.xml 0000644 0000000 0000002 00000040045 13623533443 022206 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
iPlanet Web Server HowToHenri GomezJim JagielskiGal ShachorMladen Turk
This document explains how to set up the iPlanet Web Server
to cooperate with Tomcat. The iPlanet Web Server was previously known under
various names, including Netscape Enterprise Server, SunOne Web Server and
Sun Enterprise System web server.
Normally the iPlanet Web Server comes with its own Servlet engine,
but you can also configure it to send servlet and JSP requests to Tomcat
using the NSAPI redirector plugin.
It is recommended that you also read the Workers HowTo document
to learn how to setup the working entities between your web server and Tomcat Engines.
${tomcat_home} is the root directory of tomcat.
Your Tomcat installation should have the following subdirectories:
${tomcat_home}\conf - Where you can place various configuration files
${tomcat_home}\webapps - Containing example applications
${tomcat_home}\bin - Where you place web server plugins
In all the examples in this document ${tomcat_home} will be c:\tomcat.
A worker is defined to be a tomcat process that accepts work from the iPlanet Web Server.
The NSAPI redirector was developed and tested on:
WINNT 2000/XP/2003 (should be able to work with other service packs) and some Unixes
Sun ONE Web Server 6.1
Tomcat 4.1 to Tomcat 8.
The redirector uses the AJP protocol to send requests to the Tomcat containers.
The AJP version typically used is ajp13.
Tomcat supports ajp13 since Tomcat 3.2.
Others servlet engines such as Jetty or JBoss also support the ajp13 protocol
The ajp12 protocol has been deprecated and you should no longer use it.
The ajp14 protocol is considered experimental.
The NSAPI redirector is a web server plugin based on the NSAPI web server API.
The web server loads the NSAPI redirector plugin and calls its service handler
function for all requests that are assigned to the "servlet" configuration object.
For each in-coming request the web server will execute the set of NameTrans directives
that we added to obj.conf, the assign-name function will check if it's from
parameter matches the request URL.
If a match is found, assign-name will assign the servlet object name to the request.
This will cause the web server to send the request to the servlet configuration object.
The web server will execute our jk_service extension. The extension collects the
request parameters and forwards them to the appropriate worker using the ajp13 protocol
(the worker="defworker" parameter in jk_service inform it that the worker for this request is named defworker).
the workers properties files, workers.properties, will indicate that defworker use ajp13 protocol.
The extension collects the response from the worker and returns it to the browser.
A pre-built version of the NSAPI redirector, nsapi_redirect.dll, may be available under
the win32/i386 directory of the Tomcat Connectors distribution.
You can also build a copy locally from the Tomcat Connectors source distribution.
The NSAPI redirector requires two files:
nsapi_redirect.dll (Windows) -or- nsapi_redirector.so (Unix) - The NSAPI web server plugin, either obtain a pre-built DLL/so or build it yourself
(see the build section).
workers.properties - A file that describes the host(s) and port(s) used by the workers (Tomcat processes).
A sample workers.properties can be found under the conf directory of the source distribution.
The installation includes the following parts:
Configuring the NSAPI redirector with a default /examples context and checking that you can serve servlets
with your browser.
Adding your own contexts to the configuration.
In this document we'll assume that nsapi_redirect.dll is placed in
c:\jk\lib\nsapi_redirect.dll, the properties file is inc:\jk\conf
and you created a log directory c:\jk\logs
If the built in servlet support is working disable it.
Add the NSAPI redirector plugin into the iPlanet Web Server configuration.
Edit your server magnus.conf and add the following lines:
Edit your server obj.conf and add the following lines:
In the default object NameTrans section
<Object name="default">
NameTrans fn="assign-name" from="/examples(|/*)" name="jknsapi"
....
</Object>
Create a new configuration object by adding the following lines to the end of the obj.conf file
<Object name="jknsapi">
ObjectType fn=force-type type=text/plain
Service fn="jk_service" method="*" worker="worker1"
</Object>
Edit your worker definition file workers.properties. You should at least choose a connection pool size:
#An entry that lists all the workers defined. For example:
worker.list=worker1
# Entries that define the host and port associated with these workers.
worker.worker1.host=localhost
worker.worker1.port=8009
worker.worker1.type=ajp13
worker.worker1.connection_pool_size=50
Restart the web server (stop and start the server)
That's all, now you should start tomcat and ask for http://server:port/examples/
The file obj.conf seems to be sensitive to leading white space in lines, especially in
the Object element. Make sure you have no leading white space (no indentation)
on any line of this file.
The examples context is useful for verifying your installation, but you will also need to add your own contexts.
Adding a new context requires two operations:
Adding the context to Tomcat (I am not going to talk about this).
Assigning the NSAPI redirector to handle this context.
Assigning the NSAPI redirector to handle this context is simple,
all you need to do is to edit obj.conf and add a NameTrans line that looks like:
After saving obj.conf restart the web server and it will serve the new context.
Sometimes it is better to have the web server serve the static pages (html, gif, jpeg etc.)
even if these files are part of a context served by Tomcat. For example, consider the html and gif files in the examples context, there is no need to serve them from the Tomcat process. The web server can do it on its own.
Making the web server serve static files that are part of the Tomcat contexts requires the following:
Configuring the web server to know about the Tomcat contexts
Make sure that the WEB-INF and META-INF directories are protected from access.
Configuring the web server to assign the NSAPI redirector only specific requests that requires JSP/Servlet handling.
Adding the contents of a Tomcat context to the web server requires the addition of a new virtual directory
that covers the Tomcat context.
For example, adding a /example virtual directory that
covers the c:\tomcat\webapps\examples directory.
To add a new virtual directory add the following line to your obj.conf:
WEB-INF protection requires some explanation; Each servlet application (context) has a special directory named WEB-INF,
this directory contains sensitive configurations data and Java classes and must be kept hidden from web users.
A second directory that should be protected is META-INF.
Those directories can be protected by adding the following line to the PathCheck section in the default configuration object:
PathCheck fn="deny-existence" path="*/WEB-INF/*"
PathCheck fn="deny-existence" path="*/META-INF/*"
These lines instruct the web server to reject any request with a URL that contains the path /WEB-INF/
or /META-INF/.
Configuring the web server to assign the NSAPI redirector only specific requests is somewhat harder,
you will need to specify the exact URL-Path pattern(s) that you want Tomcat to handle
(usually only JSP files and servlets).
This requires a change to NameTrans portion of obj.conf.
For the examples context it requires to replace the following line:
NameTrans fn="assign-name" from="/examples/*" name="jknsapi"
with the following two lines:
NameTrans fn="assign-name" from="/examples/jsp/*.jsp" name="jknsapi"
NameTrans fn="assign-name" from="/examples/servlet/*" name="jknsapi"
As you can see the second configuration is more explicit, it actually instructs
the web server to assign the redirector with only requests to resources under
/examples/servlet/ and resources under /examples/ whose name ends with .jsp.
You can be even more explicit and provide lines such as:
NameTrans fn="assign-name" from="/examples/servlets/chat" name="jknsapi"
Instructs the web server to assign the redirector requests whose URL path equals /example/servlets/chat
Sometimes you want to serve different contexts with different Tomcat processes
(for example to spread the load among different machines).
To achieve such goal you will need to define several workers and assign each context with its own worker.
Defining workers is done in workers.properties, this file includes two types of entries:
#An entry that lists all the workers defined. For example:
worker.list=worker1,worker2
# Entries that define the host and port associated with these workers.
worker.worker1.host=localhost
worker.worker1.port=8009
worker.worker1.type=ajp13
worker.worker2.host=otherhost
worker.worker2.port=8009
worker.worker2.type=ajp13
The above examples defined two workers, now we can use these workers to serve two different
contexts each with it's own worker.
Submitting requests to different workers is accomplished by using multiple Service directives
in the servlet configuration Object, each with a different path pattern parameter.
For example, if we want to submit the /examples context to the worker named worker1 and the
/webpages context to the worker named worker2 we should use the following configuration:
<Object name="jknsapi">
ObjectType fn=force-type type=text/plain
Service fn="jk_service" worker="worker1" path="/examples/*"
Service fn="jk_service" worker="worker2" path="/webpages/*"
Service fn="jk_service" worker="worker1"
</Object>
The redirector was developed using Visual C++ Ver.6.0, so having this environment is a prereq if you want
to perform a custom build. You should also have web server developer SDK for your version of the web server.
The steps that you need to take are:
Change directory to the native/netscape source directory.
Edit nsapi.dsp and update the include and library path to reflect your own web server installation
(search for a /I compiler option and /libpath linker option)
Make the source with MSDEV
Change directory to the NSAPI redirector source directorycd c:\tomcat-connectors-xxx-src\native\netscapeBuild the sources using MSDEVMSDEV nsapi.dsp /MAKE ALL
If msdev is not in your path, enter the full path to msdev.exe.
This will build both release and debug versions of the NSAPI redirector plugin.
An alternative will be to open the nsapi workspace file (nsapi.dsw) in msdev and
build it using the build menu.
After the build, you will have the required nsapi_redirect.dll plugin.
The redirector requires either gcc (Linux) or gcc or the Sun cc compiler (Solaris).
The steps that you need to take are:
Change directory to the native source directory.
configure for the iPlanet Web Server.
Change directory to the netscape sub directory.
Set environment variables JAVA_HOME resp. SUITSPOT_HOME to the location of your Java installation
resp. web server server installation. Depending on the web server version, you must add the subdirectory
"plugins" to SUITSPOT_HOME.
The variable is correct, if the file $SUITSPOT_HOME/include/nsapi.h exists.
Edit Makefile.solaris resp. Makefile.linux and update the variables according to your needs.
In the Solaris Makefile, you need to switch the commented lines in order to use the Sun compiler cc
instead of GNU gcc.
Make the source with gmake.
Change directory to the NSAPI redirector source directorycd /usr/local/src/tomcat-connectors-xxx-src/nativeconfigure for iPlanet Web Server./configure --enable-netscapeChange directory to the netscape directorycd netscapeSet JAVA_HOME (ksh example)export JAVA_HOME=/path/to/my/javaSet SUITSPOT_HOME (ksh example)export SUITSPOT_HOME=/path/to/my/netscape/serverEdit the Makefilevi Makefile.solarisMake the source with gmakegmake -f Makefile.solaris
After the build, you will have the required nsapi_redirector.so plugin.
tomcat-connectors-1.2.48-src/xdocs/webserver_howto/project.xml 0000644 0000000 0000002 00000012333 13623533443 023066 0 ustar root bin
The Apache Tomcat Connectors - Web Server HowTo
The Apache Tomcat Connectors - Web Server HowTo
tomcat-connectors-1.2.48-src/xdocs/webserver_howto/apache.xml 0000644 0000000 0000002 00000123261 13623533443 022644 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Apache HTTP Server HowToHenri GomezGal Shachor
This document explains how to connect Tomcat to the popular open source web server, Apache HTTP Server.
You can use the connection module mod_jk with any version of Apache starting with 1.3 and any version
of Tomcat starting with (at least) 3.2.
It is recommended that you also read the
Workers HowTo document
to learn how to setup the working entities between your web server and Tomcat Engines.
For more detailed configuration information consult the Reference Guide for
workers.properties,
uriworkermap
and Apache.
Warning: If Apache and Tomcat are configured to serve content from
the same file system location then care must be taken to ensure that Apache is
not able to serve inappropriate content such as the contents of the WEB-INF
directory or JSP source code. This could occur if the Apache DocumentRoot
overlaps with a Tomcat Host's appBase or the docBase of any Context. It could
also occur when using the Apache Alias directive with a Tomcat Host's appBase or
the docBase of any Context.
This document was originally part of Tomcat: A Minimalistic User's Guide written by Gal Shachor,
but has been split off for organisational reasons.
${tomcat_home} is the root directory of tomcat.
Your Tomcat installation should have the following subdirectories:
${tomcat_home}\conf - Where you can place various configuration files
${tomcat_home}\webapps - Containing example applications
${tomcat_home}\bin - Where you place web server plugins
In all the examples in this document ${tomcat_home} will be /var/tomcat3.
A worker is defined to be a tomcat process that accepts work from the Apache server.
The mod_jk module was developed and tested on:
Linux, FreeBSD, AIX, HP-UX, MacOS X, Solaris and should work on major Unixes platforms
supporting Apache 1.3 and/or 2.x
WinNT4.0-i386 SP4/SP5/SP6a (should be able to work with other service packs), Win2K and WinXP and Win98
Cygwin (until you have an Apache server and autoconf/automake support tools)
i5/OS V5R4 (System I) with Apache HTTP Server 2.0.58. Be sure to have the latest Apache PTF installed.
Tomcat 3.2 to Tomcat 8.
The mod_jk module uses the AJP protocol to send requests to the Tomcat containers.
The AJP version typically used is ajp13.
Tomcat supports ajp13 since Tomcat 3.2.
Others servlet engines such as Jetty or JBoss also support the ajp13 protocol
The ajp12 protocol has been deprecated and you should no longer use it.
The ajp14 protocol is considered experimental.
In a nutshell a web server is waiting for client HTTP requests.
When these requests arrive the server does whatever is needed to serve the
requests by providing the necessary content.
Adding a servlet container may somewhat change this behaviour.
Now the web server needs also to perform the following:
Load the servlet container adaptor library and initialise it (prior to serving requests).
When a request arrives, it needs to check and see if a certain request belongs to a servlet,
if so it needs to let the adaptor take the request and handle it.
The adaptor on the other hand needs to know what requests it is going to serve,
usually based on some pattern in the request URL, and to where to direct these requests.
Things are even more complex when the user wants to set a configuration that uses virtual hosts,
or when they want multiple developers to work on the same web server
but on different servlet container JVMs.
We will cover these two cases in the advanced sections.
mod_jk can be obtained in two formats - binary and source.
Depending on the platform you are running your web server on, a binary version of mod_jk may be available.
It is recommended to use the binary version if one is available.
If the binary is not available, follow the instructions
given in the below "Building mod_jk" sections for building mod_jk from source.
The mod_jk source can be downloaded from a mirror
here
The binaries for mod_jk are now available for several platforms.
The binaries are located in subdirectories by platform.
For some platforms, such as Windows, this is the typical way of obtaining mod_jk
since most Windows systems do not have C compilers.
For others, the binary distribution of mod_jk offers simpler installation.
For example JK 1.2.x can be downloaded from a mirror
here (look for JK 1.2 Binary Releases). The "JK 1.2 Binary Releases" link contains binary version for a variety of
operating systems for both Apache 1.3 and Apache 2.x.
mod_jk requires two entities:
mod_jk.xxx - The Apache HTTP Server module, depending on your operating system, it will be mod_jk.so, mod_jk.nlm
or MOD_JK.SRVPGM (see the build section).
workers.properties - A file that describes the host(s) and port(s) used by the workers (Tomcat processes).
A sample workers.properties can be found under the conf directory in the source download.
Also as with other Apache modules, mod_jk should be first installed on the modules directory of your
Apache HTTP Server, ie: /usr/lib/apache and you should update your httpd.conf file.
If you've previously configured Apache to use mod_jserv, remove any ApJServMount directives
from your httpd.conf.
If you're including tomcat-apache.conf or tomcat.conf, you'll want to remove them as well -
they are specific to mod_jserv.
The mod_jserv configuration directives are not compatible with mod_jk !
Tomcat auto-configure is deprecated and has been removed in Tomcat 7 and later.
The auto-configure works only for a single Tomcat running on the same machine where the Apache HTTP Server is running.
The simplest way to configure Apache HTTP Server to use mod_jk is to turn on the Apache HTTP Server auto-configure setting
in Tomcat and put the following include directive at the end of your Apache httpd.conf file
(make sure you replace $TOMCAT_HOME with the correct path for your Tomcat installation:
# To be added at the end of your httpd.conf
Include $TOMCAT_HOME/conf/jk/mod_jk.conf-auto
Note: this file may also be generated as $TOMCAT_HOME/conf/auto/mod_jk.conf
This will tell the Apache HTTP Server to use directives in the mod_jk.conf-auto file in
the Apache configuration. This file is created by enabling the Apache
auto-configuration by creating your workers.properties file at
$TOMCAT_HOME/conf/jk/workers.properties and adding the listener to the Engine
element in the server.xml file as per the following example.
Please note that this example is specific to Tomcat 5.x, unlike other sections of this document
which also apply to previous Tomcat branches.
Then restart Tomcat and mod_jk.conf should be generated. For more information on
this topic, please refer to the API documentation at the
Tomcat docs website.
You should use custom configuration when:
You couldn't use mod_jk.conf-auto since Tomcat engine isn't on the same machine that your Apache web server,
ie when you have an Apache in front of a Tomcat Farm.
Another case for custom configuration is when your Apache is in front of many different Tomcat engines,
each one having it's own configuration, a general case in ISP hosting
Also most Apache web masters will retain custom configuration to be able to tune the settings
to their real needs.
Here is a simple configuration:
# Load mod_jk module
LoadModule jk_module modules/mod_jk.so
# Add the module (activate this lne for Apache 1.3)
# AddModule mod_jk.c
# Where to find workers.properties
JkWorkersFile /etc/httpd/conf/workers.properties
# Where to put jk shared memory
JkShmFile /var/log/httpd/mod_jk.shm
# Where to put jk logs
JkLogFile /var/log/httpd/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel info
# Send requests for context /examples to worker named worker1
JkMount /examples/* worker1
We'll discuss here the mod_jk directives and details behind them
JkWorkersFile specify the location where mod_jk will find the workers definitions.
JkWorkersFile /etc/httpd/conf/workers.properties
JkLogFile specify the location where mod_jk is going to place its log file.
JkLogFile /var/log/httpd/mod_jk.log
Since JK 1.2.3 for Apache 2.x and JK 1.2.16 for Apache 1.3 this can also
be used for piped logging:
info log will contains standard mod_jk activity (default).
error log will contains also error reports.
debug log will contains all information on mod_jk activity
JkLogLevel info
info should be your default selection for normal operations.
JkLogStampFormat will configure the date/time format found on mod_jk logfile.
See the mod_jk Apache HTTP Server reference for details.
JkLogStampFormat "[%y-%m-%d %H:%M:%S.%Q] "
You can log mod_jk information using the Apache standard module mod_log_config.
The module sets several notes in the Apache notes table.
Most of them are are only useful in combination with a load balancer worker.
See the mod_jk Apache HTTP Server reference for details.
You can also log a request protocol in the mod_jk log file instead of
the access log. This is not recommended and mostly a backward compatibility
feature. The directive JkRequestLogFormat will configure the format
of this protocol. It gets configured and enabled on a per virtual host basis.
See the mod_jk Apache HTTP Server reference for details.
JkRequestLogFormat "%w %V %T"
The directive JkOptions allow you to set many forwarding options which will enable (+)
or disable (-) following option. Without any leading signs, options will be enabled.
The four following options +ForwardURIxxx are mutually exclusive.
Exactly one of them is required, a negative sign prefix is not allowed with them.
The default value is "ForwardURIProxy" since version 1.2.24.
It was "ForwardURICompatUnparsed" in version 1.2.23 and
"ForwardURICompat" until version 1.2.22.
You can turn the default off by switching on one of the other two options.
You should leave this at it's default value, unless you have a very good
reason to change it.
All options are inherited from the global server to virtual hosts.
Options that support enabling (plus options) and disabling (minus options),
are inherited in the following way:
options(vhost) = plus_options(global) - minus_options(global) + plus_options(vhost) - minus_options(vhost)
Using JkOptions ForwardURIProxy, the forwarded URI
will be partially reencoded after processing inside Apache and
before forwarding to Tomcat. This will be compatible with local
URL manipulation by mod_rewrite and with URL encoded session ids.
JkOptions +ForwardURIProxy
Using JkOptions ForwardURICompatUnparsed, the forwarded URI
will be unparsed. It's spec compliant and secure.
It will always forward the original request URI, so rewriting
URIs with mod_rewrite and then forwarding the rewritten URI
will not work.
JkOptions +ForwardURICompatUnparsed
Using JkOptions ForwardURICompat, the forwarded URI will
be decoded by Apache. Encoded characters will be decoded and
explicit path components like ".." will already be resolved.
This is less spec compliant and is not safe if you are using
prefix JkMount. This option will allow to rewrite URIs with
mod_rewrite before forwarding.
JkOptions +ForwardURICompat
Using JkOptions ForwardURIEscaped, the forwarded URI will
be the encoded form of the URI used by ForwardURICompat.
Explicit path components like ".." will already be resolved.
This will not work in combination with URL encoded session IDs,
but it will allow to rewrite URIs with mod_rewrite before forwarding.
JkOptions +ForwardURIEscaped
JkOptions RejectUnsafeURI will block all
URLs, which contain percent signs '%' or backslashes '\'
after decoding.
Most web apps do not use such URLs. Using the option RejectUnsafeURI, you
can block several well known URL encoding attacks. By default, this option
is not set.
You can also realise such a check with mod_rewrite, which is more powerful
but also slightly more complicated.
JkOptions +RejectUnsafeURI
JkOptions CollapseSlashesAll is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions CollapseSlashesUnmount is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions CollapseSlashesNone is deprecated as of 1.2.44 and will be
ignored if used.
JkOptions ForwardDirectories is used in conjunction with DirectoryIndex
directive of Apache. As such mod_dir should be available to Apache,
statically or dynamically (DSO)
When DirectoryIndex is configured, Apache will create sub-requests for
each of the local-url's specified in the directive, to determine if there is a
local file that matches (this is done by stat-ing the file).
If ForwardDirectories is set to false (default) and Apache doesn't find any
files that match, Apache will serve the content of the directory (if directive
Options specifies Indexes for that directory) or a 403 Forbidden response (if
directive Options doesn't specify Indexes for that directory).
If ForwardDirectories is set to true and Apache doesn't find any files that
match, the request will be forwarded to Tomcat for resolution. This is used in
cases when Apache cannot see the index files on the file system for various
reasons: Tomcat is running on a different machine, the JSP file has been
precompiled etc.
Note that locally visible files will take precedence over the
ones visible only to Tomcat (i.e. if Apache can see the file, that's the one
that's going to get served). This is important if there is more then one type of
file that Tomcat normally serves - for instance Velocity pages and JSP pages.
JkOptions +ForwardDirectories
Setting JkOptions ForwardLocalAddress, you ask mod_jk to send the local address
of the Apache HTTP Server instead of remote client address. This can be used by
Tomcat remote address valve for allowing connections only from configured Apache
servers.
JkOptions +ForwardLocalAddress
Setting JkOptions ForwardPhysicalAddress, you ask mod_jk to send the
physical peer TCP IP address as the client address. By default mod_jk
uses the logical address as provided by the web server. For example the module
mod_remoteip sets the logical IP address to the client IP forwarded by proxies
in the X-Forwarded-For header.
JkOptions +ForwardPhysicalAddress
JkOptions FlushPackets, you ask mod_jk to flush Apache's connection
buffer after each AJP packet chunk received from Tomcat. This option can have
a strong performance penalty for Apache and Tomcat as writes are performed
more often than would normally be required (ie: at the end of each
response).
JkOptions +FlushPackets
JkOptions FlushHeader, you ask mod_jk to flush Apache's connection
buffer after the response headers have been received from Tomcat.
JkOptions +FlushHeader
JkOptions DisableReuse, you ask mod_jk to close connections immediately
after their use. Normally mod_jk uses persistent connections and pools idle
connections to reuse them, when new requests have to be sent to Tomcat.
Using this option will have a strong performance penalty for Apache and Tomcat.
Use this only as a last resort in case of unfixable network problems.
If a firewall between Apache and Tomcat silently kills idle connections,
try to use the worker attribute socket_keepalive in combination with an appropriate
TCP keepalive value in your OS.
JkOptions +DisableReuse
JkOptions ForwardKeySize, you ask mod_jk, when using ajp13, to forward also the SSL Key Size as
required by Servlet API 2.3.
This flag shouldn't be set when servlet engine is Tomcat 3.2.x (off by default).
JkOptions +ForwardKeySize
JkOptions ForwardSSLCertChain, you ask mod_jk, when using ajp13,
to forward SSL certificate chain (off by default).
Mod_jk only passes the SSL_CLIENT_CERT to the AJP connector. This is not a
problem with self-signed certificates or certificates directly signed by the
root CA certificate. However, there's a large number of certificates signed by
an intermediate CA certificate, where this is a significant problem: A servlet
will not have the possibility to validate the client certificate on its own. The
bug would be fixed by passing on the SSL_CLIENT_CERT_CHAIN to Tomcat via the AJP connector.
This directive exists only since version 1.2.22.
JkOptions +ForwardSSLCertChain
The directive JkEnvVar allows you to forward environment variables
from Apache server to Tomcat engine.
You can add a default value as a second parameter to the directive.
If the default value is not given explicitly, the variable
will only be send, if it is set during runtime.
The variables can be retrieved on the Tomcat side as request attributes
via request.getAttribute(attributeName).
Note that the variables send via JkEnvVar will not be listed
in request.getAttributeNames().
The variables are inherited from the global server to virtual hosts.
JkEnvVar SSL_CLIENT_V_START undefined
If you have created a custom or local version of mod_jk.conf-local as noted above,
you can change settings such as the workers or URL prefix.
JkMount directive assign specific URLs to Tomcat.
In general the structure of a JkMount directive is:
JkMount [URL prefix] [Worker name]# send all requests ending in .jsp to worker1
JkMount /*.jsp worker1
# send all requests ending /servlet to worker1
JkMount /*/servlet/ worker1
# send all requests jsp requests to files located in /otherworker will go worker2
JkMount /otherworker/*.jsp worker2
You can use the JkMount directive at the top level or inside <VirtualHost> sections of your httpd.conf file.
If the Tomcat Host appBase (webapps) directory is accessible by the Apache HTTP Server,
Apache can be configured to serve web application context directory static files instead
of passing the request to Tomcat.
Caution: For security reasons it is strongly recommended that JkMount is used to
pass all requests to Tomcat by default and JkUnMount is used to explicitly
exclude static content to be served by Apache. It should also be noted that
content served by Apache will bypass any security constraints defined in the
application's web.xml.
Use Apache's Alias directive to map a single web application context directory into Apache's
document space for a VirtualHost:
# Static files in the examples webapp are served by Apache
Alias /examples /vat/tomcat3/webapps/examples
# All requests go to worker1 by default
JkMount /* worker1
# Serve html, jpg and gif using Apache
JkUnMount /*.html worker1
JkUnMount /*.jpg worker1
JkUnMount /*.gif worker1
Starting with mod_jk 1.2.6 for Apache 2.x and 1.2.19 for Apache 1.3, it's possible to exclude some URL/URI from
jk processing by setting the env var no-jk, for example with the SetEnvIf Directive.
You could use no-jk env var to fix problem with mod_alias or mod_userdir
directive when jk and alias/userdir URLs matches.
# All URL goes to tomcat except the one containing /home
<VirtualHost *:80>
ServerName testxxx.mysys
DocumentRoot /www/testxxx/htdocs
# Use SetEnvIf to set no-jk when /home/ is encountered
SetEnvIf Request_URI "/home/*" no-jk
# Now /home will goes to /home/dataxxx/
Alias /home /home/dataxxx/
<Directory "/home/dataxxx">
Options Indexes MultiViews
AllowOverride None
Require all granted
</Directory>
JkMount /* myssys-xxx
</VirtualHost>
Use the mod_jk JkAutoAlias directive to map all web application context directories
into Apache's document space.
Attempts to access the WEB-INF or META-INF directories within a web application context
or a Web Archive *.war within the Tomcat Host appBase (webapps) directory will fail with an
HTTP 403, Access Forbidden
# Static files in all Tomcat webapp context directories are served by Apache
JkAutoAlias /var/tomcat3/webapps
# All requests go to worker1 by default
JkMount /* ajp13
# Serve html, jpg and gif using Apache
JkUnMount /*.html ajp13
JkUnMount /*.jpg ajp13
JkUnMount /*.gif ajp13
If you encoded all your URLs to contain the session id
(;jsessionid=...), and you later decide, you want to
move part of the content to Apache, you can tell
mod_jk to strip off all session ids from URLs for
those requests, that do not get forwarded via mod_jk.
You enable this feature by setting JkStripSession to On.
It can be enabled individually for virtual servers. The default
value is Off.
The mod_jk build use the widely used configure system.
In case you get source from subversion, ie without an existing configure script,
you should have autoconf for configuration and installation.
To create the mod_jk autoconf script, you will need libtool
1.5.2, automake 1.10 and autoconf 2.59 or newer. The use of more recent
versions is encouraged, e.g. for reliable detection of the features of
recent version of operating systems.
Those tools will not be required if you are just using a package downloaded from apache.org,
they are only required for developers.
To create the configure script just type:
./buildconf.sh
Here's how to use configure to prepare mod_jk for building, just type:
./configure [autoconf arguments] [mod_jk arguments]
You could set CFLAGS and LDFLAGS to add some platform specifics:
If you want to build mod_jk for different versions of the Apache HTTP Server, like 1.3 or 2.x,
you need to go through the full build process for each of them.
Please note, that Apache 2.0, 2.2 or 2.4 modules are not binary compatible.
You have to compile the module using the Apache version you plan to run it in.
The mod_jk build directory used is "apache-2.0" for all 2.x builds. The source code
is compatible with Apache HTTP Server 2.0, 2.2 and 2.4.
use configure and indicate the correct Apache HTTP Server apxs location (--with-apxs)
use make
copy the resulting mod_jk.so binary from the apache-1.3 or apache-2.0 subdirectory
to the Apache HTTP Server modules location.
make clean (to remove all previously compiled object files)
Start over with the apxs location for your next Apache HTTP Server version.
Apache related parameters
--with-apxs[=FILE]
FILE is the location of the apxs tool. Default is finding apxs in PATH.
It builds a shared Apache module. It detects automatically the Apache version.
(2.x and 1.3)
--with-apache=DIR
DIR is the path where Apache sources are located.
The Apache sources should have been configured before configuring mod_jk.
DIR is something like: /home/apache/apache_1.3.19
It builds a static Apache module.
--enable-EAPI
This parameter is needed when using Apache-1.3 and mod_ssl, otherwise you will get the error message:
"this module might crash under EAPI!" when loading mod_jk.so in Apache.
Not needed when --with-apxs has been used
--enable-prefork
In case you build mod_jk for a multi-threaded Apache HTTP Server 2.x MPM (Multi-Processing Module),
some areas of mod_jk code need to be synchronised to make it thread-safe.
Because configure can not easily detect, whether your are using a multi-threaded MPM,
mod_jk by default is always build thread-safe for Apache HTTP Server 2.x.
If you are sure, that your MPM is not multi-threaded, you can use "--enable-prefork"
to force the removal of the synchronisation code (thus increasing performance a bit).
For instance, the prefork MPM is not multi-threaded. For Apache HTTP Server 1.3
this flag will be set automatically.
--disable-trace
When using log level "trace", mod_jk traces a lot of function calls with
"enter" and "exit" log messages. Even if the log level is not "trace",
comparing the log levels to decide about logging has some performance
impact.
If you use "--disable-trace", then the trace log code doesn't get compiled
into the module binary and you might save some cycles during execution.
Even with "--disable-trace" logging debug messages with debug log level
will still be possible.
--enable-api-compatibility
Only use Apache API functions available in all Apache production releases
of the chosen major Apache release branch. This improves binary
compatibility of module builds with Apache releases older than the release
against mod_jk is build (only between minor Apache versions).
--enable-flock
In case the operating system supports flock system call use this flag to enable this
faster locks that are implemented as system call instead emulated by GNU C library.
However those locks does not work on NFS mounted volumes, so you can use
"--enable-flock" during compile time to force the flocks() calls.
Apache 1.3 and 2.x build./configure --with-apxs=/usr/sbin/apxs make cp ./apache-1.3/mod_jk.so /usr/lib/apache make clean ./configure --with-apxs=/usr/sbin/apxs2 make cp ./apache-2.0/mod_jk.so /usr/lib/apache2
The module was developed using Microsoft Visual C++, so having Visual Studio installed
is a prerequisite if you want to perform your own build.
You can build the source using the IDE GUI, or using a pure
commandline build based on nmake. The IDE build currently only
supports building 32 Bit binaries. The nmake builds are available
for 32 Bit and 64 Bit binaries.
The common steps for all build procedures are:
Set up your build environment for 32 Bits or 64 Bits.
The IDE build only supports 32 Bits.
Download the sources as a zip file and unpack it.
Change directory to the ISAPI redirector source directory.
Set your path to the Apache web server directory in your
environment.
Set up 32 or 64 Bit build environmentsetenv /Release /X86or (not available for IDE build)setenv /Release /X64Download tomcat-connectors-xxx-src.zip fromhttps://tomcat.apache.org/download-connectors.cgiand unpack itunzip tomcat-connectors-xxx-src.zipChange directory to the mod_jk source directory.To build mod_jk for the Apache HTTP server 2.0, 2.2 or 2.4,use the "apache-2.0" directory, for the oldApache HTTP server 1.3, the "apache-1.3" directory.cd tomcat-connectors-xxx-src\native\apache-2.0Set the environment variable "APACHE1_HOME" resp."APACHE2_HOME" resp. "APACHE22_HOME" resp. "APACHE24_HOME"to the installation path of your Apache web server.set APACHE24_HOME=D:\software\Apache\httpd-2.4.16
The steps for an IDE build are then:
Start Visual Studio using "start mod_jk.dsp"
During IDE startup choose "Yes" in all conversion popups.
Next choose a Configuration form the dropdown. There are pre-defined
configurations for debug and release builds and in the
"apache-2.0" directory each of them is available as a configuration
to build against the web server versions 2.0, 2.2 and 2.4.
Finally choose "Build Solution" in the "Build" menu.
The resulting file mod_jk.so (and the debug symbol file
mod_jk.pdb) is located in the "Debug" resp. "Release" sub
directory depending on the build Configuration chosen. For
the "apache-2.0" module the directories are named "Debug_20",
"Release_20", "Debug_22", "Release_22", "Debug_24" and "Release_24"
depending on the chosen build configuration.
Alternatively the steps for an nmake commandline build are:
Set your target architecture to X86 or X64 by editing the "ARCH="
line in the file Makefile.vc.
Issue "nmake -f Makefile.vc"
The resulting file mod_jk.so (and the debug symbol file
mod_jk.pdb) is located in the "Debug" resp. "Release" sub
directory depending on the build Configuration chosen. For
the "apache-2.0" module the directories are named "Debug_20",
"Release_20", "Debug_22", "Release_22", "Debug_24" and "Release_24"
depending on the chosen build configuration.
Finally you need to copy the file mod_jk.so to the modules directory
of your Apache HTTP server (resp. the libexec directory for the old Apache 1.3).
For Apache HTTP Server 1.3, ApacheCore.lib is expected to exist before
linking mod_jk will succeed.
Since OS400 V4R5, System I (AS/400) has used Apache 2.0 as their primary web server,
replacing the old IBM web server.
It's now possible to build mod_jk on System I thanks to the help of the IBM
Rochester Labs which has provided information and patches to adapt mod_jk to i5/OS.
You should have at least Apache 2.0.58 (product 5722DG1), a C Compiler and IFS.
Apache 2.0.58 is provided with the most recent set of PTFs for the iSeries Apache
server, which can be found at
http://www.ibm.com/servers/eserver/iseries/software/http/
The all latest Apache 2 for i5/OS V5R3 (or V5R4) is now 2.0.58 (as of 2007/04/17).
Be sure to have the latest PTFs loaded if you want to make use of jk 1.2.15 and higher.
NB: The latest mod_jk known to work on i5/OS V5R3 was 1.2.19.
New in i5/OS V5R4, UTF is required, also for Apache modules, as such Apache modules do not require
translations to/from EBCDIC but works should be done to port mod_jk 1.2.23 (and higher) to V5R4.
From the V5R4 Infocenter:
As of i5/OS(tm) V5R4, modules must be recompiled with a UTF locale. This creates an environment where locale-dependent C runtime functions assume
that string data is encoded in UTF-8. Any hardcoded constants can be encoded in UTF-8 by adding a #pragma convert(1208) statement in the module.
Additionally, input data from the client will no longer be converted to EBCDIC but will be passed as-is.
Output data sent from the module is not converted either so it must be encoded in ASCII or UTF8 as required.
APR and HTTP APIs as of V5R4, expect data in UTF-8. Note that several APIs have additional functions that allow a CCSID to be set to
indicate the encoding of the parameters being passed. Conversion functions between UTF-8 and EBCDIC have been added.
Be sure to review APIs used by your module to be aware of current changes.
To configure mod_jk on System I use the CL source provided with the mod_jk source.
Get the latest mod_jk source and untar it on a Windows or Unix boxes
Create a directory in IFS, ie /home/apache
Send the whole jk source directory to System I directory via FTP.
Then go to the System I command line:
Create mod_jk libraryCRTLIB MOD_JK TEXT(‘Apache mod'jk tomcat connector module')Create service program source fileCRTSRCPF MOD_JK/QSRVSRC TEXT(‘Service program source file’)Create the CL build program source fileCRTSRCPF FILE(MOD_JK/QCLSRC) TEXT(‘Build program source file’)Edit the service program source fileSTRSEU MOD_JK/QSRVSRC MOD_JK
In the edited file, specify that only jk_module should be exported:
Columns . . : 1 71 Edit MOD_JK/QSRVSRC SEU==> MOD_JK *************** Beginning of data ************************************* 0001.00 STRPGMEXP PGMLVL(*CURRENT) 0002.00 EXPORT SYMBOL("jk_module") 0003.00 ENDPGMEXP ****************** End of data ****************************************
You could start to build all the modules of mod_jk (cases for V5R4 or previous releases):
Copy the CL build program source for i5/OS before V5R4 from IFSCPYFRMSTMF FROMSTMF('/home/apache/jk/native/apache-2.0/bldjk.qclsrc') +TOMBR('/QSYS.LIB/MOD_JK.LIB/QCLSRC.FILE/BLDJK.MBR') MBROPT(*REPLACE)Build the CL build programCRTCLPGM PGM(MOD_JK/BLDJK) SRCFILE(MOD_JK/QCLSRC) TEXT('Apache mod_jk build program')Launch the buildCALL MOD_JK/BLDJK If the build if successfull, copy the new mod_jk moduleCRTDUPOBJ OBJ(MOD_JK) FROMLIB(MOD_JK) OBJTYPE(*SRVPGM) TOLIB(QHTTPSVR) NEWOBJ(MOD_JK)Copy the CL build program source for i5/OS V5R4 from IFSCPYFRMSTMF FROMSTMF('/home/apache/jk/native/apache-2.0/bldjk54.qclsrc') +TOMBR('/QSYS.LIB/MOD_JK.LIB/QCLSRC.FILE/BLDJK54.MBR') MBROPT(*REPLACE)Build the CL build program for i5/OS V5R4CRTCLPGM PGM(MOD_JK/BLDJK54) SRCFILE(MOD_JK/QCLSRC) TEXT('Apache mod_jk build program') TGTRLS(*CURRENT)Launch the build for i5/OS V5R4CALL MOD_JK/BLDJK54 If the build if successfull, copy the new mod_jk moduleCRTDUPOBJ OBJ(MOD_JK) FROMLIB(MOD_JK) OBJTYPE(*SRVPGM) TOLIB(QHTTPSVR) NEWOBJ(MOD_JK)
Next, you should restart your Apache 2.0 instance and enjoy this piece of OpenSource on System I.
For Apache 1.3:./configure --with-apxs=/usr/sbin/apxscd apache-1.3make -f Makefile.apxscp mod_jk.so /etc/libexec/httpdFor Apache 2.x:./configure --with-apxs=/usr/local/apache2/bin/apxs(you should point to the directory where you installed Apache 2.x)cd apache-2.0make -f Makefile.apxs install
mod_jk allows to install mod_jk in the Apache source tree to get a statically
linked mod_jk. Having mod_jk in the Apache executable brings some small performance
improvements. The configure option --with-apache prepare mod_jk to install it
in the Apache source tree.
The option --with-apache works both for Apache 1.3 and Apache 2.x.
The examples below show how to get mod_jk in the Apache process.
/home/apache24/httpd-2.4.12 is the directory where the Apache HTTP Server sources
are located. ./configure --with-apache=/home/apache24/httpd-2.4.12 make Install the mod_jk library and other files in
/home/apache24/httpd-2.4.12/modules: make install It is not possible to configure Apache directly because the config.m4 of mod_jk must
be added to the configure of httpd-2.x. cd /home/apache24/httpd-2.4.12sh buildconfconfigure ... --with-mod_jkmakemake install
The enable-jk=share and enable-jk=static are not supported. --with-mod_jk only
allow static linking of mod_jk.
/home/apache/apache_1.3.27 is the directory where the apache-1.3 sources
are located. ./configure --with-apache=/home/apache/apache_1.3.27 make Install the libjk library, mod_jk.c, includes and other files in
/home/apache/apache_1.3.27/src/modules/jk: make install Configure in the Apache sources: cd /home/apache/apache_1.3.27configure ... --enable-module=dir --disable-shared=dir \ --activate-module=src/modules/jk/libjk.a \ --disable-shared=jkmakemake install
The --enable-shared=jk is also working and builds a dso file.
The Apache HTTP Server module mod_jk and its ISAPI and NSAPI redirector
variants for Microsoft IIS and the iPlanet Web Server connect
the web server to a backend (typically Tomcat) using the AJP protocol.
The web server receives an HTTP(S) request and the module forwards
the request to the backend. This function is usually called a gateway
or a proxy, in the context of HTTP it is called a reverse proxy.
A reverse proxy is not totally transparent to the application on
the backend. For instance the host name and port the original client
(e.g. browser) needs to talk to belong to the web server and not to the
backend, so the reverse proxy talks to a different host name and port.
When the application on the backend returns content including
self-referential URLs using its own backend address and port, the
client will usually not be able to use these URLs.
Another example is the client IP address, which for the web server is the
source IP of the incoming connection, whereas for the backend the
connection always comes from the web server. This can be a problem, when
the client IP is used by the backend application e.g. for security reasons.
Most of these problems are automatically handled by the AJP protocol
and the AJP connectors of the backend. The AJP protocol transports
this communication metadata and the backend connector presents this
metadata whenever the application asks for it using Servlet API methods.
The following list contains the communication metadata handled by AJP
and the ServletRequest/HttpServletRequest API calls which can be used to retrieve them:
local name: getLocalName().
This is also equal to getServerName(), unless a Host header
is contained in the request. In this case the server name is taken from that header.
local IP address: getLocalAddr().
The local IP address was initially not supported. It is available when using version 1.2.41
for Apache or IIS together with Tomcat version at least
6.0.42, 7.0.55 or 8.0.11. For older versions or when using the NSAPI redirector, getLocalAddr()
will incorrectly return the same result as getLocalName().
As a workaround you can forward the local IP address by setting
JkEnvVar SERVER_ADDR and then either using
request.getAttribute("SERVER_ADDR") instead of getLocalAddr()
or wrapping the request using a filter and overriding getLocalAddr() with
request.getAttribute("SERVER_ADDR").
local port: getLocalPort().
This is also equal to getServerPort(), unless a Host header
is contained in the request. In this case the server port is taken from that header
if it contains an explicit port, or is equal to the default port of the scheme used.
client address: getRemoteAddr()
client port: getRemotePort().
The remote port was initially not supported. It is available when using version 1.2.32
for Apache or IIS together with Tomcat version at least
5.5.28, 6.0.20 or 7.0.0. For older versions or when using the NSAPI redirector, getRemotePort()
will incorrectly return 0 or -1. As a workaround you can forward the remote port by setting
JkEnvVar REMOTE_PORT and then either using
request.getAttribute("REMOTE_PORT") instead of getRemotePort()
or wrapping the request using a filter and overriding getRemotePort() with
request.getAttribute("REMOTE_PORT").
client host: getRemoteHost()
authentication type: getAuthType()
remote user: getRemoteUser(),
if tomcatAuthentication="false"
protocol: getProtocol()
HTTP method: getMethod()
URI: getRequestURI()
HTTPS used: isSecure(), getScheme()
query string: getQueryString()
The following additional SSL-related data will be made available by the Apache HTTP Server and forwarded by mod_jk only
if you set SSLOptions +StdEnvVars. For the certificate information you also need
to set SSLOptions +ExportCertData.
SSL key size: getAttribute(javax.servlet.request.key_size).
Can be disabled using JkOptions -ForwardKeySize.
SSL client certificate: getAttribute(javax.servlet.request.X509Certificate).
If you want the whole certificate chain, then you need to also set JkOptions ForwardSSLCertChain.
It is likely, that in this case you also need to adjust the maximal AJP packet size
using the worker attribute max_packet_size.
SSL session ID: getAttribute(javax.servlet.request.ssl_session).
This is for Tomcat, it has not yet been standardized.
In some situations this is not enough though. Assume there is another
less clever reverse proxy in front of your web server, for instance an
HTTP load balancer or similar device which also serves as an SSL accelerator.
Then you are sure that all your clients use HTTPS, but your web server doesn't
know about that. All it can see is requests coming from the accelerator using
plain HTTP.
Another example would be a simple reverse proxy in front of your web server,
so that the client IP address that your web server sees is always the IP address
of this reverse proxy, and not of the original client. Often such reverse proxies
generate an additional HTTP header, like X-Forwareded-for which
contains the original client IP address (or a list of IP addresses, if there are
more cascading reverse proxies in front). It would be nice, if we could use the
content of such a header as the client IP address to pass to the backend.
So we might need to manipulate some of the data that AJP sends to the backend.
When using mod_jk inside the Apache HTTP Server you can use several Apache environment
variables to let mod_jk know, which data it should forward. These environment variables
can be set by the configuration directives SetEnv or SetEnvIf, but also in a very flexible
way using mod_rewrite (since Apache 2.x it can not only test against environment
variables, but also set them).
The following list contains all environment variables mod_jk checks, before
sending data to the backend:
JK_LOCAL_NAME: the local name
JK_LOCAL_PORT: the local port
JK_REMOTE_HOST: the client host
JK_REMOTE_ADDR: the client address
JK_AUTH_TYPE: the authentication type
JK_REMOTE_USER: the remote user
HTTPS: On (case-insensitive) to indicate, that HTTPS is used
SSL_CIPHER: the SSL cipher
SSL_CIPHER_USEKEYSIZE: the SSL key size
SSL_CLIENT_CERT: the SSL client certificate
SSL_CLIENT_CERT_CHAIN_: prefix of variable names, containing
the client cerificate chain
SSL_SESSION_ID: the SSL session ID
Remember: in general you don't need to set them. The module retrieves the data automatically
from the web server. Only in case you want to change this data, you can overwrite it by
using these variables.
Some of these variables might also be used by other web server modules. All
variables whose name does not begin with "JK" are set directly by the Apache HTTP Server.
If you want to change the data, but do not want to negatively influence the behaviour
of other modules, you can change the names of all variables mod_jk uses to private ones.
For the details see the Apache reference page.
All variables, that are not SSL-related have only been introduced in version 1.2.27.
In addition there are two special shortcuts to influence the client IP address that is forwarded.
Using JkOptions ForwardLocalAddress you can forward the local IP address of the web server
as the client IP address. This can be useful, e.g. when using the Tomcat remote address valve for
allowing connections only from registered Apache HTTP Servers.
Using JkOptions ForwardPhysicalAddress you always forward the physical peer
IP address as the client address. By default mod_jk
uses the logical address as provided by the web server. For example the module
mod_remoteip sets the logical IP address to the client IP forwarded by proxies
in the X-Forwarded-For header.
As an alternative to using the environment variables described in the previous section
(which do only exist when using Apache), you can also configure Tomcat to overwrite
some of the communications data forwarded by mod_jk. The AJP connector in Tomcat's server.xml
allows to set the following properties:
proxyName: server name as returned by getServerName()
proxyPort: server port as returned by getServerPort()
scheme: protocol scheme as returned by getScheme()
secure: set to "true", if you wish isSecure() to return "true".
Remember: in general you don't need to set those. AJP automatically handles all cases
where the web server running mod_jk knows the right data.
Sometimes one want to change path components of the URLs under which an application
is available. Especially if a web application is deployed as some context, say /myapp,
marketing prefers short URLs, so want the application to be directly available under
http://www.mycompany.com/. Although you can deploy the application as the so-called
ROOT context, which will be directly available at "/", admins often prefer not to use
the ROOT context, e.g. because only one application can be the root context (per host).
The procedure to change the URLs in the reverse proxy is tedious, because often
an application produces self-referential URLs, which then include the path components
which you tried to hide to the outside world. Nevertheless, if you absolutely need to do it,
here are the steps.
Case A: You need to make the application available at a simple URL, but it is OK, if
users proceed using the more complex URLs, as long as they don't have to type them in.
That's the easy case, and if this suffices to you, you're lucky. Use a simply RedirectMatch
for the Apache HTTP Server:
RedirectMatch ^/$ http://www.mycompany.com/myapp/
Your application will then be available under http://www.mycompany.com/,
and each visitor will be immediately redirected to the real URL
http://www.mycompany.com/myapp/
Case B: You need to hide path components for all requests going to the application.
Here's the recipe for the case, where you want to hide the first path component
/myapp. More complex manipulations are left as an exercise to the reader.
First the solution for the case of the Apache HTTP Server:
1. Use mod_rewrite
to add /myapp to all requests before forwarding to the backend:
2. Use mod_headers
to rewrite any HTTP redirects your application might return. Such redirects typically contain
the path components you want to hide, because by the HTTP standard, redirects always need to include
the full URL, and your application is not aware of the fact, that your clients talk to it via
some shortened URL. An HTTP redirect is done with a special response header named Location.
We rewrite the Location headers of our responses:
# Keep protocol, server and port if present,
# but insert our webapp name before the rest of the URL
Header edit Location ^([^/]*//[^/]*)?/(.*)$ $1/myapp/$2
3. Use mod_headers again, to rewrite the paths contained in any cookies,
your application might set. Such cookie paths again might contain
the path components you want to hide.
A cookie is set with the HTTP response header named Set-Cookie.
We rewrite the Set-Cookie headers of our responses:
3. Some applications might contain hard coded absolute links.
In this case check, whether you find a configuration item for your web framework
to configure the base URL. If not, your only chance is to parse all response
content bodies and do search and replace. This is fragile and very resource intensive.
If you really need to do this, you can use
mod_proxy_html,
mod_substitute
or mod_sed
for this task.
If you are using Microsoft IIS as a web server, the ISAPI redirector provides a way
of doing the first step with a builtin feature. You define a mapping file for simple prefix
changes like this:
# Add a context prefix to all requests ...
/=/myapp/
# ... or change some prefix ...
/oldapp/=/myapp/
and then put the name of the file in the rewrite_rule_file entry of the registry or your
isapi_redirect.properties file. In your uriworkermap.properties file, you
still need to map the URLs as they are before rewriting!
More complex rewrites can be done using the same file, but with regular expressions. A leading
tilde sign '~', indicates, that you are using a regular expression:
# Use a regular expression rewrite
~/oldapps([0-9]*)/=/newapps$1/
There is no support for Steps 2 (rewriting redirect responses) or 3 (rewriting cookie paths).
Some types of problems are triggered by the use of encoded URLs
(see percent encoding).
For the same location there exist
a lot of different URLs which are equivalent. The reverse proxy needs to inspect the URL in order
to apply its own authentication rules and to decide, to which backend it should send the request
(or whether it should handle it itself). Therefore the request URL first is normalized:
percent encoded characters are decoded, /./ is replaced by /,
/XXX/../ is replaced by / and similar manipulations of the URL are done.
After that, the web server might apply rewrite rules to further change the URL in less obvious ways.
Finally there is no more way to put the resulting URL in an encoding, which is "similar" to
the one which was used for the original URL.
For historical reasons, there have been several alternatives, how mod_jk and the ISAPI
plugin encoded the resulting URL before sending it to the backend. They could be chosen via
JkOptions (mod_jk) or uri_select (ISAPI). None of those historical
encodings are recommended, because they have either negative functionality implications or
pose a security risk. The default encoding since version 1.2.24 is ForwardURIProxy
(mod_jk) or proxy (ISAPI) and it is strongly recommended to keep the default
and remove all old explicit settings.
You can also add more attributes to any request you are forwarding when using the Apache HTTP Server.
For this use the JkEnvVar directive (for details see the
Apache reference page). Such request attributes can be
retrieved on the Tomcat side via request.getAttribute(attributeName).
Note that the names of attributes set via mod_jk will not be listed in request.getAttributeNames()!
tomcat-connectors-1.2.48-src/xdocs/common_howto/workers.xml 0000644 0000000 0000002 00000033510 13623533443 022400 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Workers HowToHenri GomezGal ShachorMladen Turk
A Tomcat worker is a Tomcat instance that is waiting to execute servlets on behalf of some web server.
For example, we can have a web server such as the Apache HTTP Server forwarding servlet requests to a
Tomcat process (the worker) running behind it.
The scenario described above is a very simple one;
in fact one can configure multiple Tomcat workers to serve servlets on
behalf of a certain web server.
The reasons for such configuration can be:
We want different contexts to be served by different Tomcat workers to provide a
development environment where all the developers share the same web server but own a Tomcat worker of their own.
We want different virtual hosts served by different Tomcat processes to provide a
clear separation between sites belonging to different companies.
We want to provide load balancing, meaning run multiple Tomcat workers each on a
machine of its own and distribute the requests between them.
There are probably more reasons for having multiple workers but I guess that this list is enough...
Tomcat workers are defined in a properties file dubbed workers.properties and this tutorial
explains how to work with it.
This document was originally part of Tomcat: A Minimalistic User's Guide written by Gal Shachor,
but has been split off for organisational reasons.
Defining workers to the Tomcat web server plugin can be done using a properties file
(a sample file named workers.properties is available in the conf/ directory).
the file contains entries of the following form:
worker.list=<a comma separated list of worker names>
# the list of workers
worker.list= worker1, worker2
When starting up, the web server plugin will instantiate the workers whose name appears in the
worker.list property, these are also the workers to whom you can map requests. The directive can be used multiple times.
Each named worker should also have a few entries to provide additional information on his behalf.
This information includes the worker's type and other related worker information.
Currently the following worker types that exists are (JK 1.2.5):
Type
Description
ajp13
This worker knows how to forward requests to out-of-process Tomcat workers using the ajp13 protocol.
lb
This is a load balancing worker; it knows how to provide flexible load balancing with a certain level of fault-tolerance.
status
This is a status worker for managing load balancers.
ajp12
This worker knows how to forward requests to out-of-process Tomcat workers using the ajp12 protocol. It is deprecated
ajp14
This worker knows how to forward requests to out-of-process Tomcat workers using the ajp14 protocol. It is experimental
Defining workers of a certain type should be done with the following property format:
worker.worker name.type=<worker type>
Where worker name is the name assigned to the worker and the worker type is one of the four types defined
in the table (a worker name may only contain any space the characters [a-zA-Z0-9\-_]).
# Defines a worker named "local" that uses the ajp12 protocol to forward requests to a Tomcat process.
worker.local.type=ajp12
# Defines a worker named "remote" that uses the ajp13 protocol to forward requests to a Tomcat process.
worker.remote.type=ajp13
# Defines a worker named "loadbalancer" that loadbalances several Tomcat processes transparently.
worker.loadbalancer.type=lb
After defining the workers you can also specify properties for them.
Properties can be specified in the following manner:
worker.<worker name>.<property>=<property value>
Each worker has a set of properties that you can set as specified in the following subsections:
The worker type ajp12 has been deprecated and you should use instead
ajp13 instead.
The ajp12 typed workers forward requests to out-of-process Tomcat workers
using the ajp12 protocol over TCP/IP sockets. It does not use persistent connections.
The ajp12 worker properties are:
host property sets the host where the Tomcat worker is listening for ajp12 requests.
port property sets the port where the Tomcat worker is listening for ajp12 requests
lbfactor property is used when working with a load balancer worker, this is the load balancing factor for the worker.
We'll see more on this in the load balancer worker section.
# worker "worker1" will talk to Tomcat listening on machine www.x.com at port 8007 using 2 lb factor
worker.worker1.type=ajp12
worker.worker1.host=www.x.com
worker.worker1.port=8007
worker.worker1.lbfactor=2
Note: The default port for ajp12 is 8007
The ajp13 typed workers forward requests to out-of-process Tomcat workers using the ajp13 protocol over TCP/IP sockets.
The main difference between ajp12 and ajp13 are that:
ajp13 is a more binary protocol and it tries to compress some of the request data by coding
frequently used strings as small integers.
ajp13 reuses open sockets and leaves them open for future requests (remember when you've got a Firewall between your
web server and Tomcat).
ajp13 has special treatment for SSL information so that the container can implement
SSL related methods such as isSecure().
You should note that ajp13 is the recommended protocol to connect to Tomcat.
# worker "worker2" will talk to Tomcat listening on machine www2.x.com at port 8009 using 3 lb factor
worker.worker2.type=ajp13
worker.worker2.host=www2.x.com
worker.worker2.port=8009
worker.worker2.lbfactor=3
# worker "worker2" uses connections, which will stay no more than 10mn in the connection pool
worker.worker2.connection_pool_timeout=600
# worker "worker2" ask operating system to send KEEP-ALIVE signal on the connection
worker.worker2.socket_keepalive=1
# mount can be used as an alternative to the JkMount directive
worker.worker2.mount=/contexta /contexta/* /contextb /contextb/*
Notes: In the ajp13 protocol, the default port is 8009
The load balancing worker does not really communicate with Tomcat workers.
Instead it is responsible for the management of several "real" workers.
This management includes:
Instantiating the workers in the web server.
Using the worker's load balancing factor, perform weighted round-robin load balancing where
a higher lbfactor means stronger machine (that is going to handle proportionally more requests)
Keeping requests belonging to the same session executing on the same Tomcat worker
(session stickyness).
Identifying failed Tomcat workers, suspending requests to them and instead failing over on
other workers managed by the lb worker.
The overall result is that workers managed by the same lb worker are load balanced
(based on their lbfactor and current user session) and also fail over so a single
Tomcat process death will not "kill" the entire site.
The following table specifies some properties that the lb worker can accept:
balance_workers is a comma separated list of workers that the load balancer need to manage.
As long as these workers should only be used via the load balancer worker,
there is no need to also put them into the worker.list property.
This directive can be used multiple times for the same load balancer.
sticky_session specifies whether requests with SESSION ID's should be routed back to the same
Tomcat worker. Set sticky_session to false when Tomcat is using a Session Manager which
can persist session data across multiple instances of Tomcat. By default sticky_session is set to
true.
# The worker balance1 while use "real" workers worker1 and worker2
worker.balance1.balance_workers=worker1, worker2
The status worker does not communicate with Tomcat.
Instead it is responsible for the load balancer management.
# Add the status worker to the worker list
worker.list=jkstatus
# Define a 'jkstatus' worker using status
worker.jkstatus.type=status
Next thing is to mount the requests to the jkstatus worker. For Apache
HTTP Servers use:
# Add the jkstatus mount point
JkMount /jkmanager/* jkstatus
To obtain a higher level of security use the:
# Enable the JK manager access from localhost only
<Location /jkmanager/>
JkMount jkstatus
Require ip 127.0.0.1
</Location>
You can define "macros" in the property files.
These macros let you define properties and later on use them while
constructing other properties.
# property example, like a network base address
mynet=194.226.31
# Using the above macro to simplify the address definitions
# for a farm of workers.
worker.node1.host=$(mynet).11
worker.node2.host=$(mynet).12
worker.node3.host=$(mynet).13
Workers can reference configurations of other workers.
If worker "x" references worker "y", then it inherits all
configuration parameters from "y", except for the ones
that have explicitly been set for "x".
# worker toe defines some default settings
worker.toe.type=ajp13
worker.toe.socket_keepalive=true
worker.toe.connect_timeout=10000
worker.toe.recovery_options=7
# workers tic and tac inherit those values
worker.tic.reference=worker.toe
worker.tac.reference=worker.toe
Please note, that the reference contains
the full prefix to the referenced configuration attributes,
not only the name of the referenced worker.
References can be nested with a maximum depth of 20.
Be careful to avoid loops!
Attributes which are allowed multiple times for a single worker
can not be merged from a worker and a reference. An attribute
is only inherited from a reference, if it is not already set
for the referring worker.
References are especially useful, when configuring load balancers.
Try to understand the following two stage references:
# We only use one load balancer
worker.list=lb
# Let's define some defaults
worker.basic.port=8009
worker.basic.type=ajp13
worker.basic.socket_keepalive=true
worker.basic.connect_timeout=10000
worker.basic.recovery_options=7
# And we use them in two groups
worker.lb1.domain=dom1
worker.lb1.distance=0
worker.lb1.reference=worker.basic
worker.lb2.domain=dom2
worker.lb2.distance=1
worker.lb2.reference=worker.basic
# Now we configure the load balancer
worker.lb.type=lb
worker.lb.method=B
worker.lb.balanced_workers=w11,w12,w21,w22
worker.w11.host=myhost11
worker.w11.reference=worker.lb1
worker.w12.host=myhost12
worker.w12.reference=worker.lb1
worker.w21.host=myhost21
worker.w21.reference=worker.lb2
worker.w22.host=myhost22
worker.w22.reference=worker.lb2
Since coping with worker.properties on your own is not an easy thing to do,
a sample worker.properties file is bundled along JK.
You could also find here a sample workers.properties defining:
Two ajp13 workers that use the host localhost and the ports 8109 and 8209
An lb worker that load balances over the two ajp13 workers
# Define 3 workers, 2 real workers using ajp13, and one being a load balancing worker
worker.list=node1, node2, lbworker
# Set properties for node1 (ajp13)
worker.node1.type=ajp13
worker.node1.host=localhost
worker.node1.port=8109
worker.node1.connection_pool_timeout=600
worker.node1.socket_keepalive=1
# Set properties for node2 (ajp13)
worker.node2.type=ajp13
worker.node2.host=localhost
worker.node2.port=8209
worker.node2.connection_pool_timeout=600
worker.node2.socket_keepalive=1
# Set properties for lbworker which uses node1 and node2
worker.lbworker.type=lb
worker.lbworker.balance_workers=node1,node2
tomcat-connectors-1.2.48-src/xdocs/common_howto/loadbalancers.xml 0000644 0000000 0000002 00000022717 13623533443 023505 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Load Balancing HowToMladen Turk
A load balancer is a worker that does not directly communicate with Tomcat.
Instead it is responsible for the management of several "real" workers,
called members or sub workers of the load balancer.
This management includes:
Instantiating the workers in the web server.
Using the worker's load balancing factor, perform weighted load balancing
(distributing load according to defined strengths of the targets).
Keeping requests belonging to the same session executing on the same Tomcat
(session stickyness).
Identifying failed Tomcat workers, suspending requests to them and instead
failing over on other workers managed by the load balancer.
Providing status and load metrics for the load balancer itself and all
members via the status worker interface.
Allowing to dynamically reconfigure load balancing via the status worker
interface.
Workers managed by the same load balancer worker are load balanced
(based on their configured balancing factors and current request or session load)
and also secured against failure by providing failover to other members of the same
load balancer. So a single Tomcat process death will not "kill" the entire site.
Some of the features provided by a load balancer are even interesting, when
only working with a single member worker (where load balancing is not possible).
A worker is configured as a load balancer by setting its worker type
to lb.
The following table specifies some properties used to configure a load balancer worker:
balance_workers is a comma separated list of names of the member workers of the
load balancer. These workers are typically of type ajp13. The member workers do
not need to appear in the worker.list property themselves, adding the
load balancer to it suffices.
sticky_session specifies whether requests with SESSION ID's should be routed
back to the same Tomcat instance that created the session. You can set sticky_session to
false when Tomcat is using a session manager which can share session data across
multiple instances of Tomcat - or if your application is stateless.
By default sticky_session is set to true.
lbfactor can be added to each member worker to configure individual
strengths for the members. A higher lbfactor will lead to more
requests being balanced to that worker. The factors must be given by integers and the
load will be distributed proportional to the factors given. Higher factors lead to
more requests.
# The load balancer worker balance1 will distribute
# load to the members worker1 and worker2
worker.balance1.type=lb
worker.balance1.balance_workers=worker1, worker2
worker.worker1.type=ajp13
worker.worker1.host=myhost1
worker.worker1.port=8009
worker.worker2.type=ajp13
worker.worker1.host=myhost2
worker.worker1.port=8009
Session stickyness is not implemented using a tracking table for sessions.
Instead each Tomcat instance gets an individual name and adds its name at
the end of the session id. When the load balancer sees a session id, it
finds the name of the Tomcat instance and sends the request via the correct
member worker. For this to work you must set the name of the Tomcat instances
as the value of the jvmRoute attribute in the Engine element of
each Tomcat's server.xml. The name of the Tomcat needs to be equal to the name
of the corresponding load balancer member. In the above example, Tomcat on host
"myhost1" needs jvmRoute="worker1", Tomcat on host "myhost2"
needs jvmRoute="worker2".
For a complete reference of all load balancer configuration
attributes, please consult the worker reference.
The load balancer supports complex topologies and failover configurations.
Using the member attribute distance you can group members.
The load balancer will always send a request to a member of lowest distance.
Only when all of those are broken, it will balance to the members of the
next higher configured distance. This allows to define priorities between
Tomcat instances in different data center locations.
When working with shared sessions, either by using session replication
or a persisting session manager (e.g. via a database), one often splits
up the Tomcat farm into replication groups. In case of failure of a member,
the load balancer needs to know, which other members share the session.
This is configured using the domain attribute. All workers
with the same domain are assumed to share the sessions.
For maintenance purposes you can tell the load balancer to not
allow any new sessions on some members, or even not use them at all.
This is controlled by the member attribute activation.
The value Active allows normal use of a member, disabled
will not create new sessions on it, but still allow sticky requests,
and stopped will no longer send any requests to the member.
Switching the activation from "active" to "disabled" some time before
maintenance will drain the sessions on the worker and minimize disruption.
Depending on the usage pattern of the application, draining will take from
minutes to hours. Switching the worker to stopped immediately before
maintenance will reduce logging of false errors by mod_jk.
Finally you can also configure hot spare workers by using
activation set to disabled in combination with
the attribute redirect added to the other workers:
# The advanced router LB worker
worker.list=router
worker.router.type=lb
worker.router.balance_workers=worker1,worker2
# Define the first member worker
worker.worker1.type=ajp13
worker.worker1.host=myhost1
worker.worker1.port=8009
# Define preferred failover node for worker1
worker.worker1.redirect=worker2
# Define the second member worker
worker.worker2.type=ajp13
worker.worker2.host=myhost2
worker.worker2.port=8009
# Disable worker2 for all requests except failover
worker.worker2.activation=disabled
The redirect flag on worker1 tells the load balancer
to redirect the requests to worker2 in case that worker1 has a problem.
In all other cases worker2 will not receive any requests, thus acting
like a hot standby.
A final note about setting activation to disabled:
The session id coming with a request is send either
as part of the request URL (;jsessionid=...) or via a cookie.
When using bookmarks or browsers that are running since a long time,
it is possible to send a request carrying an old and invalid session id
pointing at a disabled member.
Since the load balancer does not have a list of valid sessions, it will
forward the request to the disabled member. Thus draining takes longer than
expected. To handle such cases, you can add a Servlet filter to your web
application, which checks the request attribute JK_LB_ACTIVATION.
This attribute contains one of the strings "ACT", "DIS" or "STP". If you
detect "DIS" and the session for the request is no longer active, delete the
session cookie and redirect using a self-referential URL. The redirected
request will then no longer carry session information and thus the load
balancer will not send it to the disabled worker. The request attribute
JK_LB_ACTIVATION has been added in version 1.2.32.
The status worker does not communicate with Tomcat.
Instead it is responsible for the worker management. It is
especially useful when combined with load balancer workers.
# Add the status worker to the worker list
worker.list=jkstatus
# Define a 'jkstatus' worker using status
worker.jkstatus.type=status
Next thing is to mount the requests to the jkstatus worker. For Apache
HTTP Servers use:
# Add the jkstatus mount point
JkMount /jkmanager/* jkstatus
To obtain a higher level of security use the:
# Enable the JK manager access from localhost only
<Location /jkmanager/>
JkMount jkstatus
Require ip 127.0.0.1
</Location>
tomcat-connectors-1.2.48-src/xdocs/common_howto/quick.xml 0000644 0000000 0000002 00000012245 13623533443 022022 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Quick Start HowToHenri Gomez
This document describes the configuration files used by JK on the
web server side for the 'impatient':
workers.properties is a mandatory file used by the web server and which
is the same for all JK implementations (mod_jk for the Apache HTTP Server,
ISAPI for Microsoft IIS, NSAPI for the iPlanet Web Server).
web server add-ons to be set on the web server side.
We'll give here minimum servers configuration and an example workers.properties
to be able to install and check quickly your configuration.
Here is a minimum workers.properties, using just ajp13 to connect your web server
to the Tomcat engine, complete documentation is available in Workers HowTo.
# Define 1 real worker using ajp13
worker.list=worker1
# Set properties for worker1 (ajp13)
worker.worker1.type=ajp13
worker.worker1.host=localhost
worker.worker1.port=8009
Here is some very basic information about Apache configuration, a
more complete HowTo for Apache is available.
You should first have mod_jk.so (unix) or mod_jk.dll (Windows) installed
in your Apache module directory (see your Apache documentation to locate it).
Here is the minimum which should be set in httpd.conf directly or
included from another file:
Usual locations for configuration directory on Unix:
/etc/httpd/conf/
/etc/httpd2/conf/
/usr/local/apache/conf/
Usual locations for configuration directory on Windows:
C:\Program Files\Apache Group\Apache\conf\
C:\Program Files\Apache Group\Apache2\conf\
# Load mod_jk module
# Update this path to match your modules location
LoadModule jk_module modules/mod_jk.so
# Declare the module for <IfModule directive> (remove this line for Apache 2.x)
AddModule mod_jk.c
# Where to find workers.properties
# Update this path to match your conf directory location (put workers.properties next to httpd.conf)
JkWorkersFile /etc/httpd/conf/workers.properties
# Where to put jk shared memory
# Update this path to match your local state directory or logs directory
JkShmFile /var/log/httpd/mod_jk.shm
# Where to put jk logs
# Update this path to match your logs directory location (put mod_jk.log next to access_log)
JkLogFile /var/log/httpd/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel info
# Select the timestamp log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
# Send everything for context /examples to worker named worker1 (ajp13)
JkMount /examples/* worker1
tomcat-connectors-1.2.48-src/xdocs/common_howto/timeouts.xml 0000644 0000000 0000002 00000046342 13623533443 022564 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Timeouts HowToRainer Jung
Setting communication timeouts is very important to improve the
communication process. They help to detect problems and stabilise
a distributed system. JK can use several different timeout types, which
can be individually configured. For historical reasons, all of them are
disabled by default. This HowTo explains their use and gives
hints how to find appropriate values.
All timeouts can be configured in the workers.properties file.
For a complete reference of all worker configuration
items, please consult the worker reference.
This page assumes, that you are using at least version 1.2.16 of JK.
Dependencies on newer versions will be mentioned where necessary.
Do not set timeouts to extreme values. Very small timeouts will likely
be counterproductive.
Long Garbage Collection pauses on the backend do not make a good
fit with some timeouts. Try to optimise your Java memory and GC settings.
CPing/CPong is our notion for using small test packets to check the
status of backend connections. JK can use such test packets directly after establishing
a new backend connection (connect mode) and also directly before each request gets
send to a backend (prepost mode).
Starting with version 1.2.27 it can also be used when a connection was idle
for a long time (interval mode).
The maximum waiting time (timeout) for a CPong answer to a CPing and the idle
time in interval mode can be configured.
The test packets will be answered by the backend very fast with a minimal amount of
needed processing resources. A positive answer tells us, that the backend can be reached
and is actively processing requests. It does not detect, if some context is deployed
and working. The benefit of CPing/CPong is a fast detection of a communication
problem with the backend. The downside is a slightly increased latency.
The worker attribute ping_mode can be set to a combination of characters
to determine, in which situations test packets are used:
C: connect mode, timeout ping_timeout overwritten by connect_timeout
P: prepost mode, timeout ping_timeout overwritten by prepost_timeout
I: interval mode, timeout ping_timeout, idle time connection_ping_interval
A: all modes
Multiple values must be concatenated without any separator characters.
We recommend using all CPing tests. If your application is very latency sensitive, then
you should only use the combination of connect and interval mode.
Activating the CPing probing via ping_mode has been added in version 1.2.27.
For older versions only the connect and prepost modes exist and must be activated by
explicitely setting connect_timeout and prepost_timeout.
The worker attribute ping_timeout sets the default wait timeout
in milliseconds for CPong for all modes. By default the value is "10000"
milliseconds. The value only gets used, if you activate CPing/Cpong probes
via ping_mode. The default value should be fine, except if you experience
very long Java garbage collection pauses.
Depending on your network latency and stability, good custom values
often are between 5000 and 15000 milliseconds.
You can overwrite the timeout used for connect and prepost mode with
connect_timeout and prepost_timeout.
Remember: don't use extremely small values.
The worker attribute connect_timeout sets the wait timeout
in milliseconds for CPong during connection establishment. You can use it
if you want to overwrite the general timeout set with ping_timeout.
To use connect mode CPing, you need to enable it via ping_mode.
Since JK usually uses persistent connections, opening new connections is a
rare event. We therefore recommend activating connect mode.
Depending on your network latency and stability, good values often
are between 5000 and 15000 milliseconds.
Remember: don't use extremely small values.
The worker attribute prepost_timeout sets the wait timeout
in milliseconds for CPong before request forwarding. You can use it
if you want to overwrite the general timeout set with ping_timeout.
To use prepost mode CPing, you need to enable it via ping_mode.
Activating this type of CPing/CPong adds a small latency to each
request. Usually this is small enough and the benefit of CPing/CPong is more important.
So in general we also recommend using prepost_timeout.
Depending on your network latency and stability, good values often
are between 5000 and 10000 milliseconds.
Remember: don't use extremely small values.
Until version 1.2.27 ping_mode and ping_timeout did not
exist and to enable connect or prepost mode CPing you had to set connect_timeout
respectively prepost_timeout to some reasonable positive value.
Some platforms allow to set timeouts for all operations on TCP sockets.
This is available for Linux and Windows, other platforms do not support this,
e.g. Solaris. If your platform supports TCP send and receive timeouts,
you can set them using the worker attribute socket_timeout.
You can not set the two timeouts to different values.
JK will accept this attribute even if your platform does not support
socket timeouts. In this case setting the attribute will have no effect.
By default the value is "0" and the timeout is disabled.
You can set the attribute to some seconds value (not: milliseconds).
JK will then set the send and the receive timeouts of the backend
connections to this value. The timeout is low-level, it is
used for each read and write operation on the socket individually.
Using this attribute will make JK react faster to some types of network problems.
Unfortunately socket timeouts have negative side effects, because for most
platforms, there is no good way to recover from such a timeout, once it fired.
For JK there is no way to decide, if this timeout fired because of real network
problems, or only because it didn't receive an answer packet from a backend in time.
So remember: don't use extremely small values.
For the general case of connection establishment you can use
socket_connect_timeout. It takes a millisecond value and works
on most platforms, even if socket_timeout is not supported.
We recommend using socket_connect_timeout because in some network
failure situations failure detection during connection establishment
can take several minutes due to TCP retransmits. Depending on the quality
of your network a timeout somewhere between 1000 and 5000 milliseconds
should be fine. Note that socket_timeout is in seconds, and
socket_connect_timeout in milliseconds.
JK handles backend connections in a connection pool per web server process.
The connections are used in a persistent mode. After a request completed
successfully we keep the connection open and wait for the next
request to forward. The connection pool is able to grow according
to the number of threads that want to forward requests in parallel.
Most applications have a varying load depending on the hour of the day
or the day of the month. Other reasons for a growing connection pool
would be temporary slowness of backends, leading to an increasing
congestion of the frontends like web servers. Many backends use a dedicated
thread for each incoming connection they handle. So usually one wants the
connection pool to shrink, if the load diminishes.
JK allows connections in the pool to get closed after some idle time.
This maximum idle time can be configured with the attribute
connection_pool_timeout which is given in units of seconds.
The default value is "0", which disables closing idle connections.
We generally recommend values around 10 minutes, so setting
connection_pool_timeout to 600 (seconds). If you use this attribute,
please also set the attribute keepAliveTimeout
(if it is set explicitly) or connectionTimeout in the AJP
Connector element of your Tomcat server.xml configuration file to
an analogous value. Caution: keepAliveTimeout and
connectionTimeout must be given in milliseconds.
So if you set JK connection_pool_timeout to 600, you should set Tomcat
keepAliveTimeout or connectionTimeout to 600000.
JK connections do not get closed immediately after the timeout passed.
Instead there is an automatic internal maintenance task
running every 60 seconds, that checks the idle status of all connections.
The 60 seconds interval
can be adjusted with the global attribute worker.maintain. We do not
recommend to change this value, because it has a lot of side effects.
Until version 1.2.26, the maintenance task only runs, if requests get
processed. So if your web server has processes that do not receive any
requests for a long time, there is no way to close the idle connections
in its pool. Starting with version 1.2.27 you can configure an independent
watchdog thread when using Apache HTTP Server 2.x with threaded APR or Microsoft IIS.
The maximum connection pool size can be configured with the
attribute connection_pool_size. We generally do not recommend
to use this attribute in combination with Apache HTTP Server. For
Apache we automatically detect the number of threads per
process and set the maximum pool size to this value. For Microsoft IIS we use
a default value of 250 (before version 1.2.20: 10),
for the iPlanet Web Server the default is "1".
We strongly recommend adjusting this value for IIS and the iPlanet Web Server
to the number of requests one web server process should
be able to send to a backend in parallel. You should measure how many connections
you need during peak hours without performance problems, and then add some
percentage depending on your growth rate etc. Finally you should check,
whether your web server processes are able to use at least as many threads,
as you configured as the pool size.
The JK attribute connection_pool_minsize defines,
how many idle connections remain when the pool gets shrunken.
By default this is half of the maximum pool size.
One particular problem with idle connections comes from firewalls, that
are often deployed between the web server layer and the backend.
Depending on their configuration, they will silently drop
connections from their status table if they are idle for to long.
From the point of view of JK and of the web server, the other side
simply doesn't answer any traffic. Since TCP is a reliable protocol
it detects the missing TCP ACKs and tries to resend the packets for
a relatively long time, typically several minutes.
Therefore you should always use
connection_pool_timeout and
connection_pool_minsize on the JK side and keepAliveTimeout
or connectionTimeout on the Tomcat side to prevent idle
connection drop.
Furthermore using the boolean attribute socket_keepalive you can
set a standard socket option, that automatically sends TCP keepalive packets
after some idle time on each connection. By default this is set to false.
If you suspect idle connection drops by firewalls you should set this to
true.
Unfortunately the default intervals and algorithms for these packets
are platform specific. You might need to inspect TCP tuning options for
your platform on how to control TCP keepalive.
Often the default intervals are much longer than the firewall timeouts
for idle connections. Nevertheless we recommend talking to your firewall
administration and your platform administration in order to make them agree
on good configuration values for the firewall and the platform TCP tuning.
In case none of our recommendations help and you are definitively having
problems with idle connection drops, you can disable the use of persistent
connections when using JK together with Apache HTTP Server. For this you set
"JkOptions +DisableReuse" in your Apache configuration.
The amount of performance impact this will have depends on the details of
your network and your firewall.
JK can also use a timeout on request replies. This timeout does not
measure the full processing time of the response. Instead it controls,
how much time between consecutive response packets is allowed.
In most cases, this is what one actually wants. Consider for example
long running downloads. You would not be able to set an effective global
reply timeout, because downloads could last for many minutes.
Most applications though have limited processing time before starting
to return the response. For those applications you could set an explicit
reply timeout. Applications that do not harmonise with reply timeouts
are batch type applications, data warehouse and reporting applications
which are expected to observe long processing times.
If JK aborts waiting for a response, because a reply timeout fired,
there is no way to stop processing on the backend. Although you free
processing resources in your web server, the request
will continue to run on the backend - without any way to send back a
result once the reply timeout fired.
JK uses the worker attribute reply_timeout to set reply timeouts.
The default value is "0" (timeout disabled) and you can set it to any
millisecond value.
In combination with Apache HTTP Server, you can also set a more flexible reply_timeout
using an Apache environment variable. If you set the variable JK_REPLY_TIMEOUT
to some integer value, this value will be used instead of the value in
the worker configuration. This way you can set reply timeouts more flexible
with mod_setenvif and mod_rewrite depending on URI, query string etc.
If the environment variable JK_REPLY_TIMEOUT is not set, or is set to a
negative value, the default reply timeout of the worker will be used. If
JK_REPLY_TIMEOUT contains the value "0", then the reply timeout will be disabled
for the request.
In combination with a load balancing worker, JK will disable a member
worker of the load balancer if a reply timeout fires. The worker will then
no longer be used until it gets recovered during the next automatic
maintenance task. Starting with JK 1.2.24 you can improve this behaviour using
max_reply_timeouts. This
attribute will allow occasional long running requests without disabling the
worker. Only if those requests happen to often, the worker gets disabled by the
load balancer.
A load balancer worker does not only have the ability to balance load.
It also handles stickyness and failover of requests in case of errors.
When a load balancer detects an error on one of its members, it needs to
decide, whether the error is serious, or only a temporary error or maybe
only related to the actual request that was processed. Temporary errors
are called local errors, serious errors will be called global errors.
If the load balancer decides that a backend should be put into the global error
state, then the web server will not send any more requests there. If no session
replication is used, this means that all user sessions located on the respective
backend are no longer available. The users will be send to another backend
and will have to login again. So the global error state is not transparent to the
users. The application is still available, but users might loose some work.
In some cases the decision between local error and global error is easy.
For instance if there is an error sending back the response to the client (browser),
then it is very unlikely that the backend is broken.
So this situation is a typical example of a local error.
Some situations are harder to decide though. If the load balancer can't establish
a new connection to a backend, it could be because of a temporary overload situation
(so no more free threads in the backend), or because the backend isn't alive any more.
Depending on the details, the right state could either be local error or global error.
Until version 1.2.26 most errors were interpreted as global errors.
Starting with version 1.2.27 many errors which were previously interpreted as global
were switched to being local whenever the backend is still busy. Busy means, that
other concurrent requests are send to the same backend (successful or not).
In many cases there is no perfect way of making the decision
between local and global error. The load balancer simply doesn't have enough information.
In version 1.2.28 you can now tune, how fast the load balancer switches from local error to
global error. If a member of a load balancer stays in local error state for too long,
the load balancer will escalate it into global error state.
The time tolerated in local error state is controlled by the load balancer attribute
error_escalation_time (in seconds). The default value is half of recover_time,
so unless you changed recover_time the default is 30 seconds.
Using a smaller value for error_escalation_time will make the load balancer react
faster to serious errors, but also carries the risk of more often loosing sessions
in not so serious situations. You can lower error_escalation_time down to 0 seconds,
which means all local errors which are potentially serious are escalated to global errors
immediately.
Note that without good basic error detection the whole escalation procedure is useless.
So you should definitely use socket_connect_timeout and activate CPing/CPong
with ping_mode and ping_timeout before thinking about also tuning
error_escalation_time.
tomcat-connectors-1.2.48-src/xdocs/common_howto/project.xml 0000644 0000000 0000002 00000012200 13623533443 022343 0 ustar root bin
The Apache Tomcat Connectors - Common HowTo
The Apache Tomcat Connectors - Common HowTo
tomcat-connectors-1.2.48-src/xdocs/project.xml 0000644 0000000 0000002 00000012145 13623533443 017643 0 ustar root bin
The Apache Tomcat Connectors: mod_jk, ISAPI redirector, NSAPI redirector
The Apache Tomcat Connectors
tomcat-connectors-1.2.48-src/xdocs/ajp/ 0000755 0000000 0000002 00000000000 13623533443 016222 5 ustar root bin tomcat-connectors-1.2.48-src/xdocs/ajp/ajpv13ext.xml 0000644 0000000 0000002 00000052342 13623533443 020577 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
AJPv13 extensions ProposalHenri Gomez
This document is a proposal of evolution of the current
Apache JServ Protocol version 1.3, also known as ajp13.
I'll not cover here the full protocol but only the add-on from ajp13.
This nth pass include comments from the tomcat-dev list and
misses discovered during developpment.
ajp13 is a good protocol to link a servlet engine like tomcat to a web server like Apache:
use persistants connections to avoid reconnect time at each request
encode many http commands to reduce stream size
send to servlet engine many info from web server (like SSL certs)
But ajp13 lacks support for:
security between web server and servlet engine.
Anybody can connect to an ajp13 port (no login mechanism used)
You could connect, for example with telnet, and keep the remote thread
up by not sending any data (no timeout in connection)
context information passed from servlet engine to web server.
Part of the configuration of JK, the web server connector, is to
indicate to the web server which URI to handle.
The mod_jk JkMount directive, told to web server which URI must be
forwarded to servlet engine.
A servlet engine allready knows which URI it handle and TC 3.3 is
allready capable to generate a config file for JK from the list
of available contexts.
state update of contexts from servlet engine to web server.
Big site with farm of Tomcat, like ISP and virtuals hosters,
may need to stop a context for admin purposes. In that case the front
web server must know that the context is currently down, to eventually
relay the request to another Tomcat
verify state of connection before sending request.
Actually JK send the request to the servlet engine and next wait
for the answer. But one of the beauty of the socket API, is you that
you could write() to a closed connection without any error reporting,
but a read() to a closed connection return you the error code.
Let's descrive here the features and add-on that could be added to AJP13.
Since this document is a proposal, a reasonable level of chaos must be expected at first.
Be sure that discussion on tomcat list will help clarify points, add
features but the current list seems to be a 'minimun vital'
Advanced login features at connect time
Basic authorisation system, where a shared secret key is
present in web server and servlet engine.
Basic protocol negociation, just to be sure that if functionnalities are added
to AJP13 in the future, current implementations will still works.
Clean handling of 'Unknown packets'
Extended env vars passed from web-server to servlet engine.
Add extra SSL informations needed by Servlet 2.3 API (like SSL_KEY_SIZE)
WEB-SERVER send LOGIN INIT CMD + NEGOCIATION DATA + WEB SERVER INFO
TOMCAT respond with LOGIN SEED CMD + RANDOM DATA
WEB-SERVER calculted the MD5 of RANDOM DATA+SECRET DATA
WEB-SERVER send LOGIN COMP CMD + MD5 (SECRET DATA + RANDOM DATA)
TOMCAT respond with LOGIN STATUS CMD + NEGOCIED DATA + SERVLET ENGINE INFO
To prevent DOS attack, the servlet engine will wait
the LOGIN CMD only 15/30 seconds and reports the
timeout exception for admins investigation.
The login command will contains basic protocol
negociation information like compressing ability,
crypto, context info (at start up), context update at
run-time (up/down), level of SSL env vars, AJP protocol
level supported (level1/level2/level3...)
The web server info will contain web server info and
connector name (ie Apache 1.3.26 + mod_ssl 2.8.8 + mod_jk 1.2.41 + mod_perl 1.25).
The servlet engine will mask the negociation mask with it's own
mask (what it can do) and return it when loggin is accepted.
This will help having a basic AJP13 implementation (level 1)
on a web-server working with a more advanced protocol handler on
the servlet engine side or vice-versa.
AJP13 was designed to be small and fast and so many
SSL informations present in the web-server are not
forwarded to the servlet engine.
We add here four negociations flags to provide more
informations on client SSL data (certs), server SSL datas,
crypto used, and misc datas (timeout...).
+----------------+------------------+-----------------+
| LOGIN INIT CMD | NEGOCIATION DATA | WEB SERVER INFO |
+----------------+------------------+-----------------+
+----------------+----------------+
| LOGIN SEED CMD | MD5 of entropy |
+----------------+----------------+
+----------------+----------------------------+
| LOGIN COMP CMD | MD5 of RANDOM + SECRET KEY |
+----------------+----------------------------+
+-----------+---------------+---------------------+
| LOGOK CMD | NEGOCIED DATA | SERVLET ENGINE INFO |
+-----------+---------------+---------------------+
+------------+--------------+
| LOGNOK CMD | FAILURE CODE |
+------------+--------------+
MD5, MD5 of RANDOM + SECRET KEY are 32 chars long.
NEGOCIATION DATA, NEGOCIED DATA, FAILURE CODE are 32 bits long.
WEB SERVER INFO, SERVLET ENGINE INFO are CString.
The secret key will be set by a new property in
workers.properties: secretkey
worker.ajp13.port=8009
worker.ajp13.host=localhost
worker.ajp13.type=ajp13
worker.ajp13.secretkey=myverysecretkey
AJP13 miss a functionality of AJP12, which is shutdown command.
A logout will tell servlet engine to shutdown itself.
+--------------+----------------------------+
| SHUTDOWN CMD | MD5 of RANDOM + SECRET KEY |
+--------------+----------------------------+
+------------+
| SHUTOK CMD |
+------------+
+-------------+--------------+
| SHUTNOK CMD | FAILURE CODE |
+-------------+--------------+
SHUTDOWN CMD, SHUTOK CMD, SHUTNOK CMD are 1 byte long.
MD5 of RANDOM + SECRET KEY are 32 chars long.
FAILURE CODE is 32 bits long.
NOTA:
While working on AJP13 in JK, I really discovered "JkEnvVar".
The following "Extended Env Vars feature" description may not
be implemented in extended AJP13 since allready available in original
implementation.
DESC:
Many users will want to see some of their web-server env vars
passed to their servlet engine.
To reduce the network traffic, the web-servlet will send a
table to describing the external vars in a shorter fashion.
We'll use there a functionality allready present in AJP13,
attributes list:
In the AJP13, we've got:
AJP13_FORWARD_REQUEST :=
prefix_code 2
method (byte)
protocol (string)
req_uri (string)
remote_addr (string)
remote_host (string)
server_name (string)
server_port (integer)
is_ssl (boolean)
num_headers (integer)
request_headers *(req_header_name req_header_value)
?context (byte string)
?servlet_path (byte string)
?remote_user (byte string)
?auth_type (byte string)
?query_string (byte string)
?route (byte string)
?ssl_cert (byte string)
?ssl_cipher (byte string)
?ssl_session (byte string)
?attributes *(attribute_name attribute_value)
request_terminator (byte)
Using short 'web server attribute name' will reduce the
network traffic.
+-------------------+---------------------------+-------------------------------+----+
| EXTENDED VARS CMD | WEB SERVER ATTRIBUTE NAME | SERVLET ENGINE ATTRIBUTE NAME | ES |
+-------------------+---------------------------+-------------------------------+----+
ie:
JkExtVars S1 SSL_CLIENT_V_START javax.servlet.request.ssl_start_cert_date
JkExtVars S2 SSL_CLIENT_V_END javax.servlet.request.ssl_end_cert_date
JkExtVars S3 SSL_SESSION_ID javax.servlet.request.ssl_session_id
+-------------------+----+-------------------------------------------+
| EXTENDED VARS CMD | S1 | javax.servlet.request.ssl_start_cert_date |
+-------------------+----+-------------------------------------------+
+----+-----------------------------------------+
| S2 | javax.servlet.request.ssl_end_cert_date |
+----+-----------------------------------------+
+----+-----------------------------------------+
| S3 | javax.servlet.request.ssl_end_cert_date |
+----+-----------------------------------------+
During transmission in extended AJP13 we'll see attributes name
containing S1, S2, S3 and attributes values of
2001/01/03, 2002/01/03, 0123AFE56.
This example showed the use of extended SSL vars but
any 'personal' web-server vars like custom authentification
vars could be reused in the servlet engine.
The cost will be only some more bytes in the AJP traffic.
EXTENDED VARS CMD is 1 byte long.
WEB SERVER ATTRIBUTE NAME, SERVLET ENGINE ATTRIBUTE NAME are CString.
ES is an empty CString.
Just after the LOGON PHASE, the web server will ask for the list of contexts
and URLs/URIs handled by the servlet engine.
It will ease installation in many sites, reduce questions about configuration
on tomcat-user list, and be ready for servlet API 2.3.
This mode will be activated by a new directive JkAutoMount
ie: JkAutoMount examples myworker1 /examples/
If we want to get ALL the contexts handled by the servlet engine, willcard
could be used:
ie: JkAutoMount * myworker1 *
A servlet engine could have many contexts, /examples, /admin, /test.
We may want to use only some contexts for a given worker. It was
done previously, in Apache HTTP Server for example, by setting by
hand the JkMount accordingly in each [virtual] area of Apache.
If you web-server support virtual hosting, we'll forward also that
information to servlet engine which will only return contexts for
that virtual host.
In that case the servlet engine will only return the URL/URI matching
these particular virtual server (defined in server.xml).
This feature will help ISP and big sites which mutualize large farm
of Tomcat in load balancing configuration.
+-----------------+-------------------+----------+----------+----+
| CONTEXT QRY CMD | VIRTUAL HOST NAME | CONTEXTA | CONTEXTB | ES |
+-----------------+-------------------+----------+----------+----+
+------------------+-------------------+----------+-------------------+----------+---------------+----+
| CONTEXT INFO CMD | VIRTUAL HOST NAME | CONTEXTA | URL1 URL2 URL3 ES | CONTEXTB | URL1 URL2 ... | ES |
+------------------+-------------------+----------+-------------------+----------+---------------+----+
We'll discover via context-query, the list of URL/MIMES handled by the remove servlet engine
for a list of contextes.
In wildcard mode, CONTEXTA will contains just '*'.
CONTEXT QRY CMD and CONTEXT INFO CMD are 1 byte long.
VIRTUAL HOST NAME is a CString, ie an array of chars terminated by a null byte (/0).
An empty string is just a null byte (/0).
ES is an empty CString. Indicate end of URI/URLs or end of CONTEXTs.
NB:
When VirtualMode is not to be used, the VIRTUAL HOST NAME is '*'.
In that case the servlet engine will send all contexts handled.
Context update are messages caming from the servlet engine each time a context
is desactivated/reactivated. The update will be in use when the directive JkUpdateMount.
This directive will set the AJP13_CONTEXT_UPDATE_NEG flag.
ie: JkUpdateMount myworker1
+--------------------+-------------------+----------+--------+----------+--------+----+
| CONTEXT UPDATE CMD | VIRTUAL HOST NAME | CONTEXTA | STATUS | CONTEXTB | STATUS | ES |
+--------------------+-------------------+----------+--------+----------+--------+----+
CONTEXT UPDATE CMD, STATUS are 1 byte long.
VIRTUAL HOST NAME, CONTEXTS are CString.
ES is an empty CString. Indicate end of CONTEXTs.
NB:
When VirtualMode is not in use, the VIRTUAL HOST NAME is '*'.
STATUS is one byte indicating if context is UP/DOWN/INVALID
This query will be used by the web-server to determine if a given
contexts are UP, DOWN or INVALID (and should be removed).
+-------------------+--------------------+----------+----------+----+
| CONTEXT STATE CMD | VIRTUAL HOST NAME | CONTEXTA | CONTEXTB | ES |
+-------------------+--------------------+----------+----------+----+
+-------------------------+-------------------+----------+--------+----------+--------+----+
| CONTEXT STATE REPLY CMD | VIRTUAL HOST NAME | CONTEXTA | STATUS | CONTEXTB | STATUS | ES |
+-------------------------+-------------------+----------+-------------------+--------+----+
CONTEXT STATE CMD, CONTEXT STATE REPLY CMD, STATUS are 1 byte long.
VIRTUAL HOST NAME, CONTEXTs are CString
ES is an empty CString
NB:
When VirtualMode is not in use, the VIRTUAL HOST NAME is an empty string.
Sometimes even with a well negocied protocol, we may be in a situation
where one end (web server or servlet engine), will receive a message it
couldn't understand. In that case the receiver will send an
'UNKNOW PACKET CMD' with attached the unhandled message.
+--------------------+------------------------+-------------------+
| UNKNOWN PACKET CMD | UNHANDLED MESSAGE SIZE | UNHANDLED MESSAGE |
+--------------------+------------------------+-------------------+
Depending on the message, the sender will report an error and if
possible will try to forward the message to another endpoint.
UNKNOWN PACKET CMD is 1 byte long.
UNHANDLED MESSAGE SIZE is 16bits long.
UNHANDLED MESSAGE is an array of byte (length is contained in UNHANDLED MESSAGE SIZE)
NB:
added UNHANDLED MESSAGE SIZE (development)
NOTA: This fonctionality may never be used, since it may slow up the normal process
since requiring on the web-server side an extra IO (read) before forwarding
the request.....
One of the beauty of socket APIs, is that you could write on a half closed socket.
When servlet engine close the socket, the web server will discover it only at the
next read() to the socket.
Basically, in the AJP13 protocol, the web server send the HTTP HEADER and HTTP BODY
(POST by chunk of 8K) to the servlet engine and then try to receive the reply.
If the connection was broken the web server will learn it only at receive time.
We could use a buffering scheme but what happen when you use the servlet engine
for upload operations with more than 8ko of datas ?
The hack in the AJP13 protocol is to add some bytes to read after the end of the
service:
EXAMPLE OF DISCUSSION BETWEEN WEB SERVER AND SERVLET ENGINE
AJP HTTP-HEADER (+ HTTP-POST) (WEB->SERVLET)
AJP HTTP-REPLY (SERVLET->WEB)
AJP END OF DISCUSSION (SERVLET->WEB)
---> AJP STATUS (SERVLET->WEB AJP13)
The AJP STATUS will not be read by the servlet engine at the end of
the request/response #N but at the begining of the next session.
More at that time the web server could also use OS dependants functions
(or better APR functions) to determine if there is also more data
to read. And that datas could be CONTEXT Updates.
This will avoid the web server sending a request to a
desactivated context. In that case, if the load balancing is used,
it will search for another servlet engine to handle the request.
And that feature will help ISP and big sites with farm of tomcat,
to updates their servlet engine without any service interruption.
+------------+-------------+
| STATUS CMD | STATUS DATA |
+------------+-------------+
STATUS CMD and STATUS DATA are one byte long.
The goal of the extended AJP13 protocol is to overcome some of the original AJP13 limitation.
An easier configuration, a better support for large site and farm of Tomcat,
a simple authentification system and provision for protocol updates.
Using the stable ajp13 implementation in JK (native) and in servlet
engine (java), it's a reasonable evolution of the well known ajp13.
Index of Commands and ID to be added in AJP13 Protocol
Command Name
Command Number
AJP13_LOGINIT_CMD
0x10
AJP13_LOGSEED_CMD
0x11
AJP13_LOGCOMP_CMD
0x12
AJP13_LOGOK_CMD
0x13
AJP13_LOGNOK_CMD
0x14
AJP13_CONTEXT_QRY_CMD
0x15
AJP13_CONTEXT_INFO_CMD
0x16
AJP13_CONTEXT_UPDATE_CMD
0x17
AJP13_STATUS_CMD
0x18
AJP13_SHUTDOWN_CMD
0x19
AJP13_SHUTOK_CMD
0x1A
AJP13_SHUTNOK_CMD
0x1B
AJP13_CONTEXT_STATE_CMD
0x1C
AJP13_CONTEXT_STATE_REP_CMD
0x1D
AJP13_UNKNOW_PACKET_CMD
0x1E
Command Name
Number
Description
AJP13_CONTEXT_INFO_NEG
0x80000000
web-server want context info after login
AJP13_CONTEXT_UPDATE_NEG
0x40000000
web-server want context updates
AJP13_GZIP_STREAM_NEG
0x20000000
web-server want compressed stream
AJP13_DES56_STREAM_NEG
0x10000000
web-server want crypted DES56 stream with secret key
AJP13_SSL_VSERVER_NEG
0x08000000
Extended info on server SSL vars
AJP13_SSL_VCLIENT_NEG
0x04000000
Extended info on client SSL vars
AJP13_SSL_VCRYPTO_NEG
0x02000000
Extended info on crypto SSL vars
AJP13_SSL_VMISC_NEG
0x01000000
Extended info on misc SSL vars
Negociation ID
Number
Description
AJP13_PROTO_SUPPORT_AJPXX_NEG
0x00FF0000
mask of protocol supported
AJP13_PROTO_SUPPORT_AJP13L1_NEG
0x00010000
communication could use AJP13 Level 1
AJP13_PROTO_SUPPORT_AJP13L2_NEG
0x00020000
communication could use AJP13 Level 2
AJP13_PROTO_SUPPORT_AJP13L3_NEG
0x00040000
communication could use AJP13 Level 3
All others flags must be set to 0 since they are reserved for future use.
Failure Id
Number
AJP13_BAD_KEY_ERR
0xFFFFFFFF
AJP13_ENGINE_DOWN_ERR
0xFFFFFFFE
AJP13_RETRY_LATER_ERR
0xFFFFFFFD
AJP13_SHUT_AUTHOR_FAILED_ERR
0xFFFFFFFC
Failure Id
Number
AJP13_CONTEXT_DOWN
0x01
AJP13_CONTEXT_UP
0x02
AJP13_CONTEXT_OK
0x03
tomcat-connectors-1.2.48-src/xdocs/ajp/ajpv13a.xml 0000644 0000000 0000002 00000056502 13623533443 020221 0 ustar root bin
]>
&project;
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
AJPv13danmil@shore.netJean-Frederic Clere
The original document was written by
Dan Milstein, danmil@shore.net
on December 2000. The present document is generated out of an xml file
to allow a more easy integration in the Tomcat documentation.
This describes the Apache JServ Protocol version 1.3 (hereafter
ajp13). There is, apparently, no current documentation of how the
protocol works. This document is an attempt to remedy that, in order to
make life easier for maintainers of JK, and for anyone who wants to
port the protocol somewhere (into jakarta 4.x, for example).
I am not one of the designers of this protocol -- I believe that Gal
Shachor was the original designer. Everything in this document is derived
from the actual implementation I found in the tomcat 3.x code. I hope it
is useful, but I can't make any grand claims to perfect accuracy. I also
don't know why certain design decisions were made. Where I was able, I've
offered some possible justifications for certain choices, but those are
only my guesses. In general, the C code which Shachor wrote is very clean
and comprehensible (if almost totally undocumented). I've cleaned up the
Java code, and I think it's reasonably readable.
According to email from Gal Shachor to the jakarta-dev mailing list,
the original goals of JK (and thus ajp13) were to extend
mod_jserv and ajp12 by (I am only including the goals which
relate to communication between the web server and the servlet container):
Increasing performance (speed, specifically).
Adding support for SSL, so that isSecure() and
getScheme() will function correctly within the servlet
container. The client certificates and cipher suite will be
available to servlets as request attributes.
The ajp13 protocol is packet-oriented. A binary format was
presumably chosen over the more readable plain text for reasons of
performance. The web server communicates with the servlet container over
TCP connections. To cut down on the expensive process of socket creation,
the web server will attempt to maintain persistent TCP connections to the
servlet container, and to reuse a connection for multiple request/response
cycles.
Once a connection is assigned to a particular request, it will not be
used for any others until the request-handling cycle has terminated. In
other words, requests are not multiplexed over connections. This makes
for much simpler code at either end of the connection, although it does
cause more connections to be open at once.
Once the web server has opened a connection to the servlet container,
the connection can be in one of the following states:
Idle No request is being handled over this connection.
Assigned The connecton is handling a specific request.
Once a connection is assigned to handle a particular request, the basic
request informaton (e.g. HTTP headers, etc) is sent over the connection in
a highly condensed form (e.g. common strings are encoded as integers).
Details of that format are below in Request Packet Structure. If there is a
body to the request (content-length > 0), that is sent in a separate
packet immediately after.
At this point, the servlet container is presumably ready to start
processing the request. As it does so, it can send the
following messages back to the web server:
SEND_HEADERS Send a set of headers back to the browser.
SEND_BODY_CHUNK Send a chunk of body data back to the browser.
GET_BODY_CHUNK Get further data from the request if it hasn't all
been transferred yet. This is necessary because the packets have a fixed
maximum size and arbitrary amounts of data can be included the body of a
request (for uploaded files, for example). (Note: this is unrelated to
HTTP chunked tranfer).
END_RESPONSE Finish the request-handling cycle.
Each message is accompanied by a differently formatted packet of data. See
Response Packet Structures below for details.
There is a bit of an XDR heritage to this protocol, but it differs in
lots of ways (no 4 byte alignment, for example).
AJP13 uses network byte order for all data types.
There are four data types in the protocol: bytes, booleans, integers and
strings.
Byte
A single byte.
Boolean
A single byte, 1 = true, 0 = false. Using other non-zero values as
true (i.e. C-style) may work in some places, but it won't in
others.
Integer
A number in the range of 0 to 2^16 (32768). Stored in 2 bytes with
the high-order byte first.
String
A variable-sized string (length bounded by 2^16). Encoded with the
length packed into two bytes first, followed by the string (including the
terminating '\0'). Note that the encoded length does not include
the trailing '\0' -- it is like strlen. This is a touch
confusing on the Java side, which is littered with odd autoincrement
statements to skip over these terminators. I believe the reason this was
done was to allow the C code to be extra efficient when reading strings
which the servlet container is sending back -- with the terminating \0
character, the C code can pass around references into a single buffer,
without copying. If the \0 was missing, the C code would have to copy
things out in order to get its notion of a string. Note a size of -1
(65535) indicates a null string and no data follow the length in this
case.
According to much of the code, the max packet
size is 8 * 1024 bytes (8K). The actual length of the packet is encoded in the
header.
Packets sent from the server to the container begin with
0x1234. Packets sent from the container to the server begin
with AB (that's the ASCII code for A followed by the ASCII
code for B). After those first two bytes, there is an integer (encoded as
above) with the length of the payload. Although this might suggest that
the maximum payload could be as large as 2^16, in fact, the code sets the
maximum to be 8K.
Packet Format (Server->Container)
Byte
0
1
2
3
4...(n+3)
Contents
0x12
0x34
Data Length (n)
Data
Packet Format (Container->Server)
Byte
0
1
2
3
4...(n+3)
Contents
A
B
Data Length (n)
Data
For most packets, the first byte of the
payload encodes the type of message. The exception is for request body
packets sent from the server to the container -- they are sent with a
standard packet header (0x1234 and then length of the packet), but without
any prefix code after that (this seems like a mistake to me).
The web server can send the following messages to the servlet container:
Code
Type of Packet
Meaning
2
Forward Request
Begin the request-processing cycle with the following data
7
Shutdown
The web server asks the container to shut itself down.
8
Ping
The web server asks the container to take control (secure login phase).
10
CPing
The web server asks the container to respond quickly with a CPong.
none
Data
Size (2 bytes) and corresponding body data.
To ensure some
basic security, the container will only actually do the Shutdown if the
request comes from the same machine on which it's hosted.
The first Data packet is send immediatly after the Forward Request by the web server.
The servlet container can send the following types of messages to the web
server:
Code
Type of Packet
Meaning
3
Send Body Chunk
Send a chunk of the body from the servlet container to the web
server (and presumably, onto the browser).
4
Send Headers
Send the response headers from the servlet container to the web
server (and presumably, onto the browser).
5
End Response
Marks the end of the response (and thus the request-handling cycle).
6
Get Body Chunk
Get further data from the request if it hasn't all been transferred
yet.
9
CPong Reply
The reply to a CPing request
Each of the above messages has a different internal structure, detailed below.
For messages from the server to the container of type "Forward Request":
req_header_name :=
sc_req_header_name | (string) [see below for how this is parsed]
sc_req_header_name := 0xA0xx (integer)
req_header_value := (string)
The attributes are optional and have the following structure:
Not that the all-important header is "content-length', because it
determines whether or not the container looks for another packet
immediately.
Detailed description of the elements of Forward Request.
For all requests, this will be 2.
See above for details on other prefix codes.
The HTTP method, encoded as a single byte:
Command Name
Code
OPTIONS
1
GET
2
HEAD
3
POST
4
PUT
5
DELETE
6
TRACE
7
PROPFIND
8
PROPPATCH
9
MKCOL
10
COPY
11
MOVE
12
LOCK
13
UNLOCK
14
ACL
15
REPORT
16
VERSION-CONTROL
17
CHECKIN
18
CHECKOUT
19
UNCHECKOUT
20
SEARCH
21
MKWORKSPACE
22
UPDATE
23
LABEL
24
MERGE
25
BASELINE_CONTROL
26
MKACTIVITY
27
Later version of ajp13, when used with mod_jk2, will transport
additional methods, even if they are not in this list.
These are all fairly self-explanatory. Each of these is required, and
will be sent for every request.
The structure of request_headers is the following:
First, the number of headers num_headers is encoded.
Then, a series of header name req_header_name / value
req_header_value pairs follows.
Common header names are encoded as integers,
to save space. If the header name is not in the list of basic headers,
it is encoded normally (as a string, with prefixed length). The list of
common headers sc_req_header_nameand their codes
is as follows (all are case-sensitive):
Name
Code value
Code name
accept
0xA001
SC_REQ_ACCEPT
accept-charset
0xA002
SC_REQ_ACCEPT_CHARSET
accept-encoding
0xA003
SC_REQ_ACCEPT_ENCODING
accept-language
0xA004
SC_REQ_ACCEPT_LANGUAGE
authorization
0xA005
SC_REQ_AUTHORIZATION
connection
0xA006
SC_REQ_CONNECTION
content-type
0xA007
SC_REQ_CONTENT_TYPE
content-length
0xA008
SC_REQ_CONTENT_LENGTH
cookie
0xA009
SC_REQ_COOKIE
cookie2
0xA00A
SC_REQ_COOKIE2
host
0xA00B
SC_REQ_HOST
pragma
0xA00C
SC_REQ_PRAGMA
referer
0xA00D
SC_REQ_REFERER
user-agent
0xA00E
SC_REQ_USER_AGENT
The Java code that reads this grabs the first two-byte integer and if
it sees an '0xA0' in the most significant
byte, it uses the integer in the second byte as an index into an array of
header names. If the first byte is not '0xA0', it assumes that the
two-byte integer is the length of a string, which is then read in.
This works on the assumption that no header names will have length
greater than 0x9FFF (==0xA000 - 1), which is perfectly reasonable, though
somewhat arbitrary. (If you, like me, started to think about the cookie
spec here, and about how long headers can get, fear not -- this limit is
on header names not header values. It seems unlikely that
unmanageably huge header names will be showing up in the HTTP spec any time
soon).
Note: The content-length header is extremely
important. If it is present and non-zero, the container assumes that
the request has a body (a POST request, for example), and immediately
reads a separate packet off the input stream to get that body.
The attributes prefixed with a ?
(e.g. ?context) are all optional. For each, there is a
single byte code to indicate the type of attribute, and then a string to
give its value. They can be sent in any order (though the C code always
sends them in the order listed below). A special terminating code is
sent to signal the end of the list of optional attributes. The list of
byte codes is:
Information
Code Value
Note
?context
0x01
Not currently implemented
?servlet_path
0x02
Not currently implemented
?remote_user
0x03
?auth_type
0x04
?query_string
0x05
?route
0x06
?ssl_cert
0x07
?ssl_cipher
0x08
?ssl_session
0x09
?req_attribute
0x0A
Name (the name of the attribut follows)
?ssl_key_size
0x0B
?secret
0x0C
?stored_method
0x0D
are_done
0xFF
request_terminator
The context and servlet_path are not currently
set by the C code, and most of the Java code completely ignores whatever
is sent over for those fields (and some of it will actually break if a
string is sent along after one of those codes). I don't know if this is
a bug or an unimplemented feature or just vestigial code, but it's
missing from both sides of the connection.
The remote_user and auth_type presumably refer
to HTTP-level authentication, and communicate the remote user's username
and the type of authentication used to establish their identity (e.g. Basic,
Digest). I'm not clear on why the password isn't also sent, but I don't
know HTTP authentication inside and out.
The query_string, ssl_cert,
ssl_cipher, and ssl_session refer to the
corresponding pieces of HTTP and HTTPS.
The route, as I understand it, is used to support sticky
sessions -- associating a user's session with a particular Tomcat instance
in the presence of multiple, load balancing servers. I don't know the
details.
Beyond this list of basic attributes, any number of other attributes can
be sent via the req_attribute code (0x0A). A pair of strings
to represent the attribute name and value are sent immediately after each
instance of that code. Environment values are passed in via this method.
Finally, after all the attributes have been sent, the attribute terminator,
0xFF, is sent. This signals both the end of the list of attributes and
also then end of the Request Packet.
For messages which the container can send back to the server.
AJP13_SEND_BODY_CHUNK :=
prefix_code 3
chunk_length (integer)
chunk *(byte)
AJP13_SEND_HEADERS :=
prefix_code 4
http_status_code (integer)
http_status_msg (string)
num_headers (integer)
response_headers *(res_header_name header_value)
res_header_name :=
sc_res_header_name | (string) [see below for how this is parsed]
sc_res_header_name := 0xA0 (byte)
header_value := (string)
AJP13_END_RESPONSE :=
prefix_code 5
reuse (boolean)
AJP13_GET_BODY_CHUNK :=
prefix_code 6
requested_length (integer)
Details:
The chunk is basically binary data, and is sent directly back to the browser.
The status code and message are the usual HTTP things (e.g. "200" and "OK").
The response header names are encoded the same way the request header names are.
See above for details about how the the
codes are distinguished from the strings. The codes for common headers are:
Name
Code value
Content-Type
0xA001
Content-Language
0xA002
Content-Length
0xA003
Date
0xA004
Last-Modified
0xA005
Location
0xA006
Set-Cookie
0xA007
Set-Cookie2
0xA008
Servlet-Engine
0xA009
Status
0xA00A
WWW-Authenticate
0xA00B
After the code or the string header name, the header value is immediately
encoded.
Signals the end of this request-handling cycle. If the
reuse flag is true (anything other than 0 in the actual
C code), this TCP connection can now be used to handle new incoming
requests. If reuse is false (==0), the connection
should be closed.
The container asks for more data from the request (If the body was
too large to fit in the first packet sent over or when the request is
chuncked).
The server will send a body packet back with an amount of data which is
the minimum of the request_length,
the maximum send body size (8186 (8 Kbytes - 6)), and the
number of bytes actually left to send from the request body.
If there is no more data in the body (i.e. the servlet container is
trying to read past the end of the body), the server will send back an
"empty" packet, which is a body packet with a payload length of 0.
(0x12,0x34,0x00,0x00)
What happens if the request headers > max packet size? There is no
provision to send a second packet of request headers in case there are more
than 8K (I think this is correctly handled for response headers, though I'm
not certain). I don't know if there is a way to get more than 8K worth of
data into that initial set of request headers, but I'll bet there is
(combine long cookies with long ssl information and a lot of environment
variables, and you should hit 8K easily). I think the connector would just
fail before trying to send any headers in this case, but I'm not certain.
What about authentication? There doesn't seem to be any authentication
of the connection between the web server and the container. This strikes
me as potentially dangerous.
\n");
}
}
}
if (hide) {
JK_TRACE_EXIT(l);
return;
}
for (i = 0; i < w->we->num_of_workers; i++) {
jw = wc_get_worker_for_name(w->we->worker_list[i], l);
if (!jw) {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not find worker '%s'",
w->name, w->we->worker_list[i]);
continue;
}
if ((list_lb && jw->type == JK_LB_WORKER_TYPE) ||
(!list_lb && jw->type != JK_LB_WORKER_TYPE)) {
display_worker(s, p, jw, NULL, l);
}
}
if (list_lb) {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, l, w, 0, "balancers");
}
else if (mime == JK_STATUS_MIME_TXT) {
}
else if (mime == JK_STATUS_MIME_PROP) {
}
else if (mime == JK_STATUS_MIME_HTML) {
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, l, w, 0, "ajp_workers");
}
else if (mime == JK_STATUS_MIME_TXT) {
}
else if (mime == JK_STATUS_MIME_PROP) {
}
else if (mime == JK_STATUS_MIME_HTML) {
}
}
JK_TRACE_EXIT(l);
}
static int list_workers(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
int lb_cnt = 0;
int ajp_cnt = 0;
JK_TRACE_ENTER(l);
count_workers(s, p, &lb_cnt, &ajp_cnt, l);
if (lb_cnt) {
list_workers_type(s, p, 1, lb_cnt, l);
}
if (ajp_cnt) {
list_workers_type(s, p, 0, ajp_cnt, l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int show_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
lb_sub_worker_t *wr = NULL;
JK_TRACE_ENTER(l);
if (fetch_worker_and_sub_worker(p, "showing", &worker, &sub_worker, l) == JK_FALSE ||
search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (sub_worker && sub_worker[0]) {
if (search_sub_worker(s, p, jw, worker, &wr, sub_worker,
NULL, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
}
display_worker(s, p, jw, wr, l);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int edit_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
status_worker_t *w = p->worker;
jk_worker_t *jw = NULL;
lb_worker_t *lb = NULL;
lb_sub_worker_t *wr = NULL;
ajp_worker_t *aw = NULL;
JK_TRACE_ENTER(l);
if (fetch_worker_and_sub_worker(p, "editing", &worker, &sub_worker, l) == JK_FALSE ||
search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (jw->type == JK_LB_WORKER_TYPE) {
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (lb->sequence != lb->s->h.sequence)
jk_lb_pull(lb, JK_FALSE, l);
if (!sub_worker || !sub_worker[0]) {
const char *arg;
if (status_get_string(p, JK_STATUS_ARG_ATTRIBUTE,
NULL, &arg, l) == JK_TRUE) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' with all sub workers",
w->name, "editing", lb->name);
form_all_members(s, p, jw, arg, l);
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s'",
w->name, "editing", lb->name);
form_worker(s, p, jw, l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
if (search_sub_worker(s, p, jw, worker, &wr, sub_worker,
NULL, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' sub worker '%s'",
w->name, "editing", lb->name, wr->name);
aw = (ajp_worker_t *)wr->worker->worker_private;
form_member(s, p, wr, aw, worker, l);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
else if (jw->type == JK_AJP13_WORKER_TYPE ||
jw->type == JK_AJP14_WORKER_TYPE) {
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (aw) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s ajp worker '%s'",
w->name, "editing", aw->name);
if (aw->sequence != aw->s->h.sequence)
jk_ajp_pull(aw, JK_FALSE, l);
form_member(s, p, NULL, aw, worker, l);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' aw worker is (null)",
w->name);
}
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' worker type not implemented",
w->name);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int update_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
status_worker_t *w = p->worker;
jk_worker_t *jw = NULL;
lb_worker_t *lb = NULL;
lb_sub_worker_t *wr = NULL;
ajp_worker_t *aw = NULL;
int rc = JK_TRUE;
int rv;
JK_TRACE_ENTER(l);
if (fetch_worker_and_sub_worker(p, "updating", &worker, &sub_worker, l) == JK_FALSE ||
search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (jw->type == JK_LB_WORKER_TYPE) {
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (lb->sequence != lb->s->h.sequence)
jk_lb_pull(lb, JK_TRUE, l);
if (!sub_worker || !sub_worker[0]) {
const char *arg;
if (status_get_string(p, JK_STATUS_ARG_ATTRIBUTE,
NULL, &arg, l) == JK_TRUE) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' with all sub workers",
w->name, "updating", lb->name);
commit_all_members(s, p, jw, arg, l);
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s'",
w->name, "updating", lb->name);
commit_worker(s, p, jw, l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
unsigned int idx = 0;
unsigned int *wi = NULL;
int is_wildchar = JK_FALSE;
if (strchr(sub_worker, '*') || strchr(sub_worker, '?')) {
/* We have a wildchar matching rule */
wi = &idx;
is_wildchar = JK_TRUE;
}
for (;;) {
if (search_sub_worker(s, p, jw, worker, &wr, sub_worker,
wi, l) == JK_FALSE) {
if (!idx) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
else {
/* We have found at least one match previously */
p->msg = "OK";
break;
}
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' sub worker '%s'",
w->name, "updating", lb->name, wr->name);
aw = (ajp_worker_t *)wr->worker->worker_private;
rv = 0;
rc = commit_member(s, p, lb, wr, aw, &rv, l);
if (rv & JK_STATUS_NEEDS_ADDR_PUSH) {
aw->addr_sequence = -1;
}
if (rv & JK_STATUS_NEEDS_RESET_LB_VALUES)
reset_lb_values(lb, l);
if (rv & JK_STATUS_NEEDS_UPDATE_MULT)
/* Recalculate the load multiplicators wrt. lb_factor */
update_mult(lb, l);
if (rv & (JK_STATUS_NEEDS_PUSH | JK_STATUS_NEEDS_ADDR_PUSH)) {
wr->sequence = -1;
lb->sequence = -1;
jk_lb_push(lb, JK_TRUE, rv & JK_STATUS_NEEDS_UPDATE_MULT ? JK_TRUE: JK_FALSE, l);
}
if (rc == JK_FALSE) {
jk_log(l, JK_LOG_ERROR,
"Status worker '%s' failed updating sub worker '%s' (at least partially).%s",
w->name, aw->name, (is_wildchar == JK_TRUE) ? " Aborting further wildcard updates." : "");
if (!strncmp("OK", p->msg, 3)) {
const char *msg = "Update failed (at least partially) for sub worker '%s'";
size_t size = strlen(msg) + strlen(aw->name) + 1;
p->msg = jk_pool_alloc(s->pool, size);
snprintf(p->msg, size, msg, aw->name);
}
if (is_wildchar == JK_TRUE) {
const char *msg = " Aborting further wildcard updates.";
size_t size = strlen(msg) + strlen(p->msg) + 1;
p->msg = jk_pool_realloc(s->pool, size, p->msg, strlen(p->msg) + 1);
strcat(p->msg, msg);
}
break;
}
if (!wi)
break;
}
JK_TRACE_EXIT(l);
return rc;
}
}
else if (jw->type == JK_AJP13_WORKER_TYPE ||
jw->type == JK_AJP14_WORKER_TYPE) {
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (aw) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s ajp worker '%s'",
w->name, "updating", aw->name);
if (aw->sequence != aw->s->h.sequence)
jk_ajp_pull(aw, JK_TRUE, l);
rv = 0;
rc = commit_member(s, p, NULL, NULL, aw, &rv, l);
if (rv & JK_STATUS_NEEDS_ADDR_PUSH) {
aw->addr_sequence = -1;
}
if (rv & (JK_STATUS_NEEDS_PUSH | JK_STATUS_NEEDS_ADDR_PUSH)) {
aw->sequence = -1;
jk_ajp_push(aw, JK_TRUE, l);
}
if (rc == JK_FALSE) {
jk_log(l, JK_LOG_ERROR,
"Status worker '%s' failed updating worker '%s' (at least partially).",
w->name, aw->name);
if (!strncmp("OK", p->msg, 3)) {
const char *msg = "Update failed (at least partially) for worker '%s'";
size_t size = strlen(msg) + strlen(aw->name) + 1;
p->msg = jk_pool_alloc(s->pool, size);
snprintf(p->msg, size, msg, aw->name);
}
}
JK_TRACE_EXIT(l);
return rc;
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' aw worker is (null)",
w->name);
}
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' worker type not implemented",
w->name);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int reset_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
unsigned int i;
const char *worker;
const char *sub_worker;
status_worker_t *w = p->worker;
jk_worker_t *jw = NULL;
lb_worker_t *lb = NULL;
lb_sub_worker_t *wr = NULL;
ajp_worker_t *aw = NULL;
time_t now = 0;
JK_TRACE_ENTER(l);
if (fetch_worker_and_sub_worker(p, "resetting", &worker, &sub_worker, l) == JK_FALSE ||
search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
now = time(NULL);
if (jw->type == JK_LB_WORKER_TYPE) {
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (!sub_worker || !sub_worker[0]) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' with all sub workers",
w->name, "resetting", lb->name);
lb->s->max_busy = 0;
lb->s->last_reset = now;
for (i = 0; i < lb->num_of_workers; i++) {
wr = &(lb->lb_workers[i]);
aw = (ajp_worker_t *)wr->worker->worker_private;
wr->s->state = JK_LB_STATE_IDLE;
wr->s->elected_snapshot = 0;
wr->s->sessions = 0;
wr->s->first_error_time = 0;
wr->s->last_error_time = 0;
wr->s->errors = 0;
wr->s->lb_value = 0;
aw->s->used = 0;
aw->s->client_errors = 0;
aw->s->reply_timeouts = 0;
aw->s->transferred = 0;
aw->s->readed = 0;
aw->s->max_busy = 0;
aw->s->max_connected = 0;
aw->s->last_reset = now;
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
if (search_sub_worker(s, p, jw, worker, &wr, sub_worker,
NULL, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s lb worker '%s' sub worker '%s'",
w->name, "resetting", lb->name, wr->name);
aw = (ajp_worker_t *)wr->worker->worker_private;
wr->s->state = JK_LB_STATE_IDLE;
wr->s->elected_snapshot = 0;
wr->s->sessions = 0;
wr->s->first_error_time = 0;
wr->s->last_error_time = 0;
wr->s->errors = 0;
wr->s->lb_value = 0;
aw->s->used = 0;
aw->s->client_errors = 0;
aw->s->reply_timeouts = 0;
aw->s->transferred = 0;
aw->s->readed = 0;
aw->s->max_busy = 0;
aw->s->max_connected = 0;
aw->s->last_reset = now;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
else if (jw->type == JK_AJP13_WORKER_TYPE ||
jw->type == JK_AJP14_WORKER_TYPE) {
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (aw) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' %s ajp worker '%s'",
w->name, "resetting", aw->name);
aw->s->errors = 0;
aw->s->used = 0;
aw->s->client_errors = 0;
aw->s->reply_timeouts = 0;
aw->s->transferred = 0;
aw->s->readed = 0;
aw->s->max_busy = 0;
aw->s->max_connected = 0;
aw->s->last_reset = now;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' aw worker is (null)",
w->name);
}
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' worker type not implemented",
w->name);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int recover_worker(jk_ws_service_t *s,
status_endpoint_t *p,
jk_logger_t *l)
{
const char *worker;
const char *sub_worker;
jk_worker_t *jw = NULL;
lb_sub_worker_t *wr = NULL;
ajp_worker_t *aw = NULL;
status_worker_t *w = p->worker;
JK_TRACE_ENTER(l);
if (fetch_worker_and_sub_worker(p, "recovering", &worker, &sub_worker, l) == JK_FALSE ||
search_worker(s, p, &jw, worker, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (search_sub_worker(s, p, jw, worker, &wr, sub_worker,
NULL, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
aw = (ajp_worker_t *)wr->worker->worker_private;
if (wr->s->state == JK_LB_STATE_ERROR) {
lb_worker_t *lb = NULL;
/* We need an lb to correct the lb_value */
if (check_valid_lb(s, p, jw, worker, &lb, 0, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (lb->lbmethod != JK_LB_METHOD_BUSYNESS) {
unsigned int i;
jk_uint64_t curmax = 0;
for (i = 0; i < lb->num_of_workers; i++) {
if (lb->lb_workers[i].s->lb_value > curmax) {
curmax = lb->lb_workers[i].s->lb_value;
}
}
wr->s->lb_value = curmax;
}
aw->s->reply_timeouts = 0;
wr->s->state = JK_LB_STATE_RECOVER;
jk_log(l, JK_LOG_INFO,
"Status worker '%s' marked worker '%s' sub worker '%s' for recovery",
w->name, worker ? worker : "(null)", sub_worker ? sub_worker : "(null)");
JK_TRACE_EXIT(l);
return JK_TRUE;
}
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' could not mark worker '%s' sub worker '%s' for recovery - state %s is not an error state",
w->name, worker ? worker : "(null)", sub_worker ? sub_worker : "(null)",
jk_lb_get_state(wr, l));
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int dump_config(jk_ws_service_t *s,
status_endpoint_t *p,
int mime, jk_logger_t *l)
{
status_worker_t *w = p->worker;
jk_worker_env_t *we = w->we;
jk_map_t *init_data = we->init_data;
JK_TRACE_ENTER(l);
if (init_data) {
int n = jk_map_size(init_data);
int i;
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "
Configuration Data
\n");
jk_puts(s, "This dump does not include any changes applied by the status worker\n");
jk_puts(s, "to the configuration after the initial startup\n");
jk_puts(s, "
\n");
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, l, w, 2, 0, "configuration");
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Configuration:\n");
}
for (i=0;i sizeof(".secret") &&
strcmp(name + nl - 7, ".secret") == 0) {
continue;
}
value = jk_map_value_at(init_data, i);
if (!value)
value = "(null)";
if (mime == JK_STATUS_MIME_HTML ||
mime == JK_STATUS_MIME_PROP ||
mime == JK_STATUS_MIME_TXT) {
jk_putv(s, name, "=", value, "\n", NULL);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_att_string(s, l, 4, name, value);
}
}
}
if (mime == JK_STATUS_MIME_HTML) {
jk_puts(s, "
\n");
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_stop_elt(s, l, 2, 1);
}
}
else {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
/*
* Return values of service() method for status worker:
* return value is_error reason
* JK_FALSE JK_HTTP_SERVER_ERROR Invalid parameters (null values)
* JK_TRUE JK_HTTP_OK All other cases
*/
static int JK_METHOD service(jk_endpoint_t *e,
jk_ws_service_t *s,
jk_logger_t *l, int *is_error)
{
int cmd;
jk_uint32_t cmd_props;
int mime;
int refresh;
int read_only = 0;
const char *arg;
char *err = NULL;
status_endpoint_t *p;
status_worker_t *w;
int denied = 0;
JK_TRACE_ENTER(l);
if (!e || !e->endpoint_private || !s || !is_error) {
JK_LOG_NULL_PARAMS(l);
if (is_error)
*is_error = JK_HTTP_SERVER_ERROR;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p = e->endpoint_private;
w = p->worker;
/* Set returned error to OK */
*is_error = JK_HTTP_OK;
if (w->num_of_users) {
if (s->remote_user) {
unsigned int i;
denied = 1;
for (i = 0; i < w->num_of_users; i++) {
if (w->user_case_insensitive) {
if (!strcasecmp(s->remote_user, w->user_names[i])) {
denied = 0;
break;
}
}
else {
if (!strcmp(s->remote_user, w->user_names[i])) {
denied = 0;
break;
}
}
}
}
else {
denied = 2;
}
}
/* Step 1: Process GET params and update configuration */
if (status_parse_uri(s, p, l) != JK_TRUE) {
err = "Error during parsing of URI";
}
status_get_string(p, JK_STATUS_ARG_CMD, NULL, &arg, l);
cmd = status_cmd_int(arg);
cmd_props = status_cmd_props(cmd);
status_get_string(p, JK_STATUS_ARG_MIME, NULL, &arg, l);
mime = status_mime_int(arg);
refresh = status_get_int(p, JK_STATUS_ARG_REFRESH, 0, l);
if (w->read_only) {
read_only = 1;
}
else {
read_only = status_get_int(p, JK_STATUS_ARG_OPTIONS, 0, l) &
JK_STATUS_ARG_OPTION_READ_ONLY;
}
if (mime == JK_STATUS_MIME_HTML) {
s->start_response(s, 200, "OK", headers_names, headers_vhtml, 3);
jk_puts(s, JK_STATUS_HEAD);
}
else if (mime == JK_STATUS_MIME_XML) {
s->start_response(s, 200, "OK", headers_names, headers_vxml, 3);
jk_puts(s, JK_STATUS_XMLH);
if (w->doctype) {
jk_putv(s, w->doctype, "\n", NULL);
}
jk_print_xml_start_elt(s, l, w, 0, 0, "status");
if (w->xmlns && strlen(w->xmlns))
jk_putv(s, " ", w->xmlns, NULL);
jk_print_xml_stop_elt(s, l, 0, 0);
}
else {
s->start_response(s, 200, "OK", headers_names, headers_vtxt, 3);
}
if (denied == 0) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' service allowed for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else if (denied == 1) {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else if (denied == 2) {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied (no user) [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
else {
err = "Access denied.";
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' service denied (unknown reason) for user '%s' [%s] from %s [%s]",
w->name,
s->remote_user ? s->remote_user : "(null)",
s->auth_type ? s->auth_type : "(null)",
s->remote_addr ? s->remote_addr : "(null)",
s->remote_host ? s->remote_host : "(null)");
}
if (!err) {
if (read_only && !(cmd_props & JK_STATUS_CMD_PROP_READONLY)) {
err = "This command is not allowed in read only mode.";
}
}
if (!err) {
if (cmd == JK_STATUS_CMD_UNKNOWN) {
err = "Invalid command.";
}
else if (mime == JK_STATUS_MIME_UNKNOWN) {
err = "Invalid mime type.";
}
else if (cmd_props & JK_STATUS_CMD_PROP_CHECK_WORKER &&
(check_worker(s, p, cmd_props & JK_STATUS_CMD_PROP_WILDCARD, l) != JK_TRUE)) {
err = p->msg;
}
}
if (!err) {
char buf_time[JK_STATUS_TIME_BUF_SZ];
char buf_tz[JK_STATUS_TIME_BUF_SZ];
time_t clock = time(NULL);
long unix_seconds = (long)clock;
int rc_time = status_strftime(clock, mime, buf_time, buf_tz, l);
if (cmd == JK_STATUS_CMD_UPDATE) {
/* lock shared memory */
jk_shm_lock();
if (update_worker(s, p, l) == JK_FALSE) {
if (strncmp("OK", p->msg, 3))
err = p->msg;
else
err = "Update failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
write_html_refresh_response(s, p, err, l);
}
}
else if (cmd == JK_STATUS_CMD_RESET) {
/* lock shared memory */
jk_shm_lock();
if (reset_worker(s, p, l) == JK_FALSE) {
err = "Reset failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
write_html_refresh_response(s, p, err, l);
}
}
else if (cmd == JK_STATUS_CMD_RECOVER) {
/* lock shared memory */
jk_shm_lock();
if (recover_worker(s, p, l) == JK_FALSE) {
err = "Marking worker for recovery failed";
}
/* unlock the shared memory */
jk_shm_unlock();
if (mime == JK_STATUS_MIME_HTML) {
write_html_refresh_response(s, p, err, l);
}
}
else {
if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_start_elt(s, l, w, 0, 0, "server");
jk_print_xml_att_string(s, l, 2, "name", s->server_name);
jk_print_xml_att_int(s, l, 2, "port", s->server_port);
jk_print_xml_stop_elt(s, l, 0, 1);
if (cmd_props & JK_STATUS_CMD_PROP_HEAD) {
if (rc_time > 0 ) {
jk_print_xml_start_elt(s, l, w, 0, 0, "time");
jk_print_xml_att_string(s, l, 2, "datetime", buf_time);
jk_print_xml_att_string(s, l, 2, "tz", buf_tz);
jk_print_xml_att_long(s, l, 2, "unix", unix_seconds);
jk_print_xml_stop_elt(s, l, 0, 1);
}
jk_print_xml_start_elt(s, l, w, 0, 0, "software");
jk_print_xml_att_string(s, l, 2, "web_server", s->server_software);
jk_print_xml_att_string(s, l, 2, "jk_version", JK_FULL_EXPOSED_VERSION);
jk_print_xml_stop_elt(s, l, 0, 1);
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if (show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_TXT) {
jk_puts(s, "Server:");
jk_printf(s, l, " name=%s", s->server_name);
jk_printf(s, l, " port=%d", s->server_port);
jk_puts(s, "\n");
if (cmd_props & JK_STATUS_CMD_PROP_HEAD) {
if (rc_time > 0) {
jk_puts(s, "Time:");
jk_printf(s, l, " datetime=%s", buf_time);
jk_printf(s, l, " tz=%s", buf_tz);
jk_printf(s, l, " unix=%ld", unix_seconds);
jk_puts(s, "\n");
}
jk_puts(s, "Software:");
jk_printf(s, l, " web_server=\"%s\"", s->server_software);
jk_printf(s, l, " jk_version=%s", JK_FULL_EXPOSED_VERSION);
jk_puts(s, "\n");
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if (show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_PROP) {
jk_print_prop_att_string(s, l, w, NULL, "server_name", s->server_name);
jk_print_prop_att_int(s, l, w, NULL, "server_port", s->server_port);
if (cmd_props & JK_STATUS_CMD_PROP_HEAD) {
if (rc_time > 0) {
jk_print_prop_att_string(s, l, w, NULL, "time_datetime", buf_time);
jk_print_prop_att_string(s, l, w, NULL, "time_tz", buf_tz);
jk_print_prop_att_long(s, l, w, NULL, "time_unix", unix_seconds);
}
jk_print_prop_att_string(s, l, w, NULL, "web_server", s->server_software);
jk_print_prop_att_string(s, l, w, NULL, "jk_version", JK_FULL_EXPOSED_VERSION);
}
if (cmd == JK_STATUS_CMD_LIST) {
/* Step 2: Display configuration */
if (list_workers(s, p, l) != JK_TRUE) {
err = "Error in listing the workers.";
}
}
else if (cmd == JK_STATUS_CMD_SHOW) {
/* Step 2: Display detailed configuration */
if (show_worker(s, p, l) != JK_TRUE) {
err = "Error in showing this worker.";
}
}
}
else if (mime == JK_STATUS_MIME_HTML) {
if (cmd_props & JK_STATUS_CMD_PROP_REFRESH &&
refresh > 0) {
jk_printf(s, l, "\n",
refresh, s->req_uri, p->query_string);
}
if (w->css) {
jk_putv(s, "\ncss, "\" />\n", NULL);
}
jk_puts(s, JK_STATUS_HEND);
jk_puts(s, "
JK Status Manager for ");
jk_puts(s, s->server_name);
jk_printf(s, l, ":%d", s->server_port);
if (read_only) {
jk_puts(s, " (read only)");
}
jk_puts(s, "
\n\n");
if (cmd_props & JK_STATUS_CMD_PROP_HEAD) {
jk_putv(s, "
Server Version:
",
s->server_software, "
", NULL);
if (rc_time > 0) {
jk_putv(s, "Server Time:
", buf_time, NULL);
}
jk_puts(s, "
\n");
jk_putv(s, "
JK Version:
",
JK_FULL_EXPOSED_VERSION, "
", NULL);
jk_printf(s, l, "Unix Seconds:
%d", unix_seconds);
jk_puts(s, "
\n\n");
}
jk_puts(s, "
\n");
if (cmd_props & JK_STATUS_CMD_PROP_REFRESH) {
jk_puts(s, "
\n", NULL);
}
jk_puts(s, JK_STATUS_BEND);
}
else if (mime == JK_STATUS_MIME_XML) {
jk_print_xml_close_elt(s, l, w, 0, "status");
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (e && *e && (*e)->endpoint_private) {
status_endpoint_t *p = (*e)->endpoint_private;
jk_map_free(&(p->req_params));
free(p);
*e = NULL;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private) {
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private) {
status_worker_t *p = pThis->worker_private;
char **good_rating;
unsigned int num_of_good;
char **bad_rating;
unsigned int num_of_bad;
unsigned int i;
p->we = we;
p->css = jk_get_worker_style_sheet(props, p->name, NULL);
p->prefix = jk_get_worker_prop_prefix(props, p->name, JK_STATUS_PREFIX_DEF);
p->ns = jk_get_worker_name_space(props, p->name, JK_STATUS_NS_DEF);
p->xmlns = jk_get_worker_xmlns(props, p->name, JK_STATUS_XMLNS_DEF);
p->doctype = jk_get_worker_xml_doctype(props, p->name, NULL);
p->read_only = jk_get_is_read_only(props, p->name);
p->user_case_insensitive = jk_get_worker_user_case_insensitive(props, p->name);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' is %s and has css '%s', prefix '%s', name space '%s', xml name space '%s', document type '%s'",
p->name,
p->read_only ? "read-only" : "read/write",
p->css ? p->css : "(null)",
p->prefix ? p->prefix : "(null)",
p->ns ? p->ns : "(null)",
p->xmlns ? p->xmlns : "(null)",
p->doctype ? p->doctype : "(null)");
if (jk_get_worker_user_list(props, p->name,
&(p->user_names),
&(p->num_of_users)) && p->num_of_users) {
for (i = 0; i < p->num_of_users; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' restricting access to user '%s' case %s",
p->name, p->user_names[i],
p->user_case_insensitive ? "insensitive" : "sensitive");
}
}
if (jk_get_worker_good_rating(props, p->name,
&good_rating,
&num_of_good) && num_of_good) {
p->good_mask = 0;
for (i = 0; i < num_of_good; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' rating as good: '%s'",
p->name, good_rating[i]);
p->good_mask |= status_get_rating(good_rating[i], l);
}
}
else {
p->good_mask = JK_STATUS_MASK_GOOD_DEF;
}
if (jk_get_worker_bad_rating(props, p->name,
&bad_rating,
&num_of_bad) && num_of_bad) {
p->bad_mask = 0;
for (i = 0; i < num_of_bad; i++) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' rating as bad: '%s'",
p->name, bad_rating[i]);
p->bad_mask |= status_get_rating(bad_rating[i], l);
}
}
else {
p->bad_mask = JK_STATUS_MASK_BAD_DEF;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Status worker '%s' has good rating for '%08" JK_UINT32_T_HEX_FMT
"' and bad rating for '%08" JK_UINT32_T_HEX_FMT "'",
p->name,
p->good_mask,
p->bad_mask);
if (p->good_mask & p->bad_mask)
jk_log(l, JK_LOG_WARNING,
"Status worker '%s' has non empty intersection '%08" JK_UINT32_T_HEX_FMT
"' between good rating for '%08" JK_UINT32_T_HEX_FMT
"' and bad rating for '%08" JK_UINT32_T_HEX_FMT "'",
p->name,
p->good_mask & p->bad_mask,
p->good_mask,
p->bad_mask);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private && pend) {
status_endpoint_t *p = (status_endpoint_t *) malloc(sizeof(status_endpoint_t));
p->worker = pThis->worker_private;
p->endpoint.endpoint_private = p;
p->endpoint.service = service;
p->endpoint.done = done;
p->req_params = NULL;
p->msg = NULL;
*pend = &p->endpoint;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && *pThis && (*pThis)->worker_private) {
status_worker_t *private_data = (*pThis)->worker_private;
jk_close_pool(&private_data->p);
free(private_data);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
int JK_METHOD status_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (NULL != name && NULL != w) {
status_worker_t *private_data =
(status_worker_t *) calloc(1, sizeof(status_worker_t));
jk_open_pool(&private_data->p,
private_data->buf,
sizeof(jk_pool_atom_t) * TINY_POOL_SIZE);
private_data->name = name;
private_data->worker.worker_private = private_data;
private_data->worker.validate = validate;
private_data->worker.init = init;
private_data->worker.get_endpoint = get_endpoint;
private_data->worker.destroy = destroy;
*w = &private_data->worker;
JK_TRACE_EXIT(l);
return JK_STATUS_WORKER_TYPE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return 0;
}
tomcat-connectors-1.2.48-src/native/common/jk_ajp13.h 0000644 0000000 0000002 00000007312 13623533443 020664 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Experimental bi-directionl protocol handler. *
* Author: Gal Shachor *
***************************************************************************/
#ifndef JK_AJP13_H
#define JK_AJP13_H
#include "jk_ajp_common.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define AJP13_PROTO 13
#define AJP13_WS_HEADER 0x1234
#define AJP13_SW_HEADER 0x4142 /* 'AB' */
#define AJP13_DEF_HOST ("localhost")
#define AJP13_DEF_PORT (8009)
#define AJP13_DEF_PACKET_SIZE (8*1024)
#define AJP13_MAX_PACKET_SIZE (64*1024)
#define AJP13_PACKET_SIZE_ALIGN (1024)
#define AJP13_DEF_CACHE_SZ (1)
#define JK_INTERNAL_ERROR (-2)
#define JK_FATAL_ERROR (-3)
#define JK_CLIENT_ERROR (-4)
#define JK_SERVER_ERROR (-5)
#define JK_CLIENT_RD_ERROR (-6)
#define JK_CLIENT_WR_ERROR (-7)
#define JK_STATUS_ERROR (-8)
#define JK_STATUS_FATAL_ERROR (-9)
#define JK_REPLY_TIMEOUT (-10)
#define JK_AJP_PROTOCOL_ERROR (-11)
#define JK_BUSY_ERROR (-12)
#define AJP13_DEF_TIMEOUT (0) /* Idle timout for pooled connections */
/*
* Message does not have a response (for example, JK_AJP13_END_RESPONSE)
*/
#define JK_AJP13_ERROR -1
/*
* Message does not have a response (for example, JK_AJP13_END_RESPONSE)
*/
#define JK_AJP13_NO_RESPONSE 0
/*
* Message have a response.
*/
#define JK_AJP13_HAS_RESPONSE 1
/*
* Forward a request from the web server to the servlet container.
*/
#define JK_AJP13_FORWARD_REQUEST (unsigned char)2
/*
* Write a body chunk from the servlet container to the web server
*/
#define JK_AJP13_SEND_BODY_CHUNK (unsigned char)3
/*
* Send response headers from the servlet container to the web server.
*/
#define JK_AJP13_SEND_HEADERS (unsigned char)4
/*
* Marks the end of response.
*/
#define JK_AJP13_END_RESPONSE (unsigned char)5
/*
* Marks the end of response.
*/
#define JK_AJP13_GET_BODY_CHUNK (unsigned char)6
/*
* Asks the container to shutdown
*/
#define JK_AJP13_SHUTDOWN (unsigned char)7
/*
* Told container to take control (secure login phase)
*/
#define AJP13_PING_REQUEST (unsigned char)8
/*
* Check if the container is alive
*/
#define AJP13_CPING_REQUEST (unsigned char)10
/*
* Reply from the container to alive request
*/
#define AJP13_CPONG_REPLY (unsigned char)9
/*
* Functions
*/
int ajp13_marshal_shutdown_into_msgb(jk_msg_buf_t *msg,
jk_pool_t *p, jk_logger_t *l);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* JK_AJP13_H */
tomcat-connectors-1.2.48-src/native/common/jk_uri_worker_map.c 0000644 0000000 0000002 00000131735 13623533443 022775 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: URI to worker map object. *
* *
* Author: Gal Shachor *
* Author: Mladen Turk *
***************************************************************************/
#include "jk_pool.h"
#include "jk_util.h"
#include "jk_map.h"
#include "jk_mt.h"
#include "jk_uri_worker_map.h"
#include "jk_worker.h"
#include "jk_lb_worker.h"
#ifdef WIN32
#define JK_STRCMP strcasecmp
#define JK_STRNCMP strnicmp
#else
#define JK_STRCMP strcmp
#define JK_STRNCMP strncmp
#endif
#define JK_UWMAP_EXTENSION_REPLY_TIMEOUT "reply_timeout="
#define JK_UWMAP_EXTENSION_STICKY_IGNORE "sticky_ignore="
#define JK_UWMAP_EXTENSION_STATELESS "stateless="
#define JK_UWMAP_EXTENSION_ACTIVE "active="
#define JK_UWMAP_EXTENSION_DISABLED "disabled="
#define JK_UWMAP_EXTENSION_STOPPED "stopped="
#define JK_UWMAP_EXTENSION_FAIL_ON_STATUS "fail_on_status="
#define JK_UWMAP_EXTENSION_USE_SRV_ERRORS "use_server_errors="
#define JK_UWMAP_EXTENSION_SESSION_COOKIE "session_cookie="
#define JK_UWMAP_EXTENSION_SESSION_PATH "session_path="
#define JK_UWMAP_EXTENSION_SET_SESSION_COOKIE "set_session_cookie="
#define JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH "session_cookie_path="
#define IND_SWITCH(x) (((x)+1) % 2)
#define IND_THIS(x) ((x)[uw_map->index])
#define IND_NEXT(x) ((x)[IND_SWITCH(uw_map->index)])
#define STRNULL_FOR_NULL(x) ((x) ? (x) : "(null)")
static volatile int map_id_counter = 0;
static const char *uri_worker_map_source_type[] = {
"unknown",
SOURCE_TYPE_TEXT_WORKERDEF,
SOURCE_TYPE_TEXT_JKMOUNT,
SOURCE_TYPE_TEXT_URIMAP,
SOURCE_TYPE_TEXT_DISCOVER,
NULL
};
/* Return the string representation of the uwr source */
const char *uri_worker_map_get_source(uri_worker_record_t *uwr, jk_logger_t *l)
{
return uri_worker_map_source_type[uwr->source_type];
}
/* Return the string representation of the uwr match type */
char *uri_worker_map_get_match(uri_worker_record_t *uwr, char *buf, jk_logger_t *l)
{
unsigned int match;
buf[0] = '\0';
match = uwr->match_type;
if (match & MATCH_TYPE_DISABLED)
strcat(buf, "Disabled ");
/* deprecated
if (match & MATCH_TYPE_STOPPED)
strcat(buf, "Stopped ");
*/
if (match & MATCH_TYPE_NO_MATCH)
strcat(buf, "Unmount ");
if (match & MATCH_TYPE_EXACT)
strcat(buf, "Exact");
else if (match & MATCH_TYPE_WILDCHAR_PATH)
strcat(buf, "Wildchar");
/* deprecated
else if (match & MATCH_TYPE_CONTEXT)
strcat(buf, "Context");
else if (match & MATCH_TYPE_CONTEXT_PATH)
strcat(buf, "Context Path");
else if (match & MATCH_TYPE_SUFFIX)
strcat(buf, "Suffix");
else if (match & MATCH_TYPE_GENERAL_SUFFIX)
return "General Suffix";
*/
else
strcat(buf, "Unknown");
return buf;
}
/*
* Given context uri, count the number of path tokens.
*
* Servlet specification 2.4, SRV.11.1 says
* The container will recursively try tomatch the longest
* path-prefix. This is done by stepping down the path tree a
* directory at a time, using the / character as a path
* separator. The longest match determines the servlet selected.
*
* The implication seems to be `most uri path elements is most exact'.
* This is a little helper function to count uri tokens, so we can
* keep the worker map sorted with most specific first.
*/
static int worker_count_context_uri_tokens(const char * context)
{
const char * c = context;
int count = 0;
while (c && *c) {
if ('/' == *c++)
count++;
}
return count;
}
static int worker_compare(const void *elem1, const void *elem2)
{
uri_worker_record_t *e1 = *(uri_worker_record_t **)elem1;
uri_worker_record_t *e2 = *(uri_worker_record_t **)elem2;
int e1_tokens = 0;
int e2_tokens = 0;
e1_tokens = worker_count_context_uri_tokens(e1->context);
e2_tokens = worker_count_context_uri_tokens(e2->context);
if (e1_tokens != e2_tokens) {
return (e2_tokens - e1_tokens);
}
/* given the same number of URI tokens, use character
* length as a tie breaker
*/
if(e2->context_len != e1->context_len)
return ((int)e2->context_len - (int)e1->context_len);
return ((int)e2->source_type - (int)e1->source_type);
}
static void worker_qsort(jk_uri_worker_map_t *uw_map)
{
/* Sort remaining args using Quicksort algorithm: */
qsort((void *)IND_NEXT(uw_map->maps), IND_NEXT(uw_map->size),
sizeof(uri_worker_record_t *), worker_compare );
}
/* Dump the map contents - only call if debug log is active. */
static void uri_worker_map_dump(jk_uri_worker_map_t *uw_map,
const char *reason, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (uw_map) {
int i, off;
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG, "uri map dump %s: id=%d, index=%d file='%s' reject_unsafe=%d "
"reload=%d modified=%d checked=%d",
reason, uw_map->id, uw_map->index, STRNULL_FOR_NULL(uw_map->fname),
uw_map->reject_unsafe, uw_map->reload, uw_map->modified, uw_map->checked);
}
for (i = 0; i <= 1; i++) {
jk_log(l, JK_LOG_DEBUG, "generation %d: size=%d nosize=%d capacity=%d",
i, uw_map->size[i], uw_map->nosize[i], uw_map->capacity[i], uw_map->maps[i]);
}
off = uw_map->index;
for (i = 0; i <= 1; i++) {
char buf[32];
int k;
unsigned int j;
k = (i + off) % 2;
for (j = 0; j < uw_map->size[k]; j++) {
uri_worker_record_t *uwr = uw_map->maps[k][j];
if (uwr && JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG, "%s (%d) map #%d: uri=%s worker=%s context=%s "
"source=%s type=%s len=%d",
i ? "NEXT" : "THIS", i, j,
STRNULL_FOR_NULL(uwr->uri), STRNULL_FOR_NULL(uwr->worker_name),
STRNULL_FOR_NULL(uwr->context), STRNULL_FOR_NULL(uri_worker_map_get_source(uwr,l)),
STRNULL_FOR_NULL(uri_worker_map_get_match(uwr,buf,l)), uwr->context_len);
}
}
}
}
JK_TRACE_EXIT(l);
}
int uri_worker_map_alloc(jk_uri_worker_map_t **uw_map_p,
jk_map_t *init_data, jk_logger_t *l)
{
int i;
JK_TRACE_ENTER(l);
if (uw_map_p) {
int rc;
jk_uri_worker_map_t *uw_map;
*uw_map_p = (jk_uri_worker_map_t *)calloc(1, sizeof(jk_uri_worker_map_t));
uw_map = *uw_map_p;
JK_INIT_CS(&(uw_map->cs), rc);
if (rc == JK_FALSE) {
jk_log(l, JK_LOG_ERROR,
"creating thread lock (errno=%d)",
errno);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_open_pool(&(uw_map->p),
uw_map->buf, sizeof(jk_pool_atom_t) * BIG_POOL_SIZE);
for (i = 0; i <= 1; i++) {
jk_open_pool(&(uw_map->p_dyn[i]),
uw_map->buf_dyn[i], sizeof(jk_pool_atom_t) * BIG_POOL_SIZE);
uw_map->size[i] = 0;
uw_map->nosize[i] = 0;
uw_map->capacity[i] = 0;
uw_map->maps[i] = NULL;
}
uw_map->id = 0;
uw_map->index = 0;
uw_map->fname = NULL;
uw_map->reject_unsafe = 0;
uw_map->reload = JK_URIMAP_DEF_RELOAD;
uw_map->modified = 0;
uw_map->checked = 0;
if (init_data)
rc = uri_worker_map_open(uw_map, init_data, l);
if (rc == JK_TRUE)
uw_map->id = ++map_id_counter;
JK_TRACE_EXIT(l);
return rc;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int uri_worker_map_close(jk_uri_worker_map_t *uw_map, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (uw_map) {
JK_DELETE_CS(&uw_map->cs);
jk_close_pool(&uw_map->p_dyn[0]);
jk_close_pool(&uw_map->p_dyn[1]);
jk_close_pool(&uw_map->p);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
int uri_worker_map_free(jk_uri_worker_map_t **uw_map, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (uw_map && *uw_map) {
uri_worker_map_close(*uw_map, l);
free(*uw_map);
*uw_map = NULL;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
/*
* Ensure there will be memory in context info to store Context Bases
*/
#define UW_INC_SIZE 4 /* 4 URI->WORKER STEP */
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;
}
/*
* Delete all entries of a given source type
*/
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 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;
size_t status_len;
char *status;
#ifdef _MT_CODE_PTHREAD
char *lasts;
#endif
JK_TRACE_ENTER(l);
status_len = strlen(extensions->fail_on_status_str);
for (i = 0; i < status_len; 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; jfail_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; jactivation_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;
}
static void extension_fix_session(jk_pool_t *p, const char *name, jk_worker_t *jw,
rule_extension_t *extensions, jk_logger_t *l)
{
if (jw->type != JK_LB_WORKER_TYPE && extensions->session_cookie) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, extension "
JK_UWMAP_EXTENSION_SESSION_COOKIE " for %s ignored",
name, extensions->session_cookie);
}
if (jw->type != JK_LB_WORKER_TYPE && extensions->session_path) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, extension "
JK_UWMAP_EXTENSION_SESSION_PATH " for %s ignored",
name, extensions->session_path);
}
if (jw->type != JK_LB_WORKER_TYPE && extensions->set_session_cookie) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, extension "
JK_UWMAP_EXTENSION_SET_SESSION_COOKIE " for %s ignored",
name, extensions->set_session_cookie ? "'true'" : "'false'");
}
if (jw->type != JK_LB_WORKER_TYPE && extensions->session_cookie_path) {
jk_log(l, JK_LOG_WARNING,
"Worker %s is not of type lb, extension "
JK_UWMAP_EXTENSION_SESSION_COOKIE_PATH " for %s ignored",
name, extensions->session_cookie_path);
}
}
void extension_fix(jk_pool_t *p, const char *name,
rule_extension_t *extensions, jk_logger_t *l)
{
jk_worker_t *jw = wc_get_worker_for_name(name, l);
if(!jw) {
jk_log(l, JK_LOG_ERROR,
"Could not find worker with name '%s' in uri map post processing.",
name);
return;
}
if (!extension_fix_activation(p, name, jw, extensions, l))
return;
if (extensions->fail_on_status_str) {
extension_fix_fail_on_status(p, name, extensions, l);
}
extension_fix_session(p, name, jw, extensions, l);
}
void uri_worker_map_switch(jk_uri_worker_map_t *uw_map, jk_logger_t *l)
{
int new_index;
JK_TRACE_ENTER(l);
if (uw_map) {
new_index = IND_SWITCH(uw_map->index);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Switching uri worker map from index %d to index %d",
uw_map->index, new_index);
uw_map->index = new_index;
jk_reset_pool(&(IND_NEXT(uw_map->p_dyn)));
}
JK_TRACE_EXIT(l);
}
void uri_worker_map_ext(jk_uri_worker_map_t *uw_map, jk_logger_t *l)
{
unsigned int i;
JK_TRACE_ENTER(l);
for (i = 0; i < IND_NEXT(uw_map->size); i++) {
uri_worker_record_t *uwr = IND_NEXT(uw_map->maps)[i];
jk_pool_t *p;
if(uwr->match_type & MATCH_TYPE_NO_MATCH)
continue;
if (uwr->source_type == SOURCE_TYPE_URIMAP)
p = &IND_NEXT(uw_map->p_dyn);
else
p = &uw_map->p;
extension_fix(p, uwr->worker_name, &uwr->extensions, l);
}
if (JK_IS_DEBUG_LEVEL(l))
uri_worker_map_dump(uw_map, "after extension stripping", l);
JK_TRACE_EXIT(l);
return;
}
/* 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;
}
int uri_worker_map_open(jk_uri_worker_map_t *uw_map,
jk_map_t *init_data, jk_logger_t *l)
{
int rc = JK_TRUE;
JK_TRACE_ENTER(l);
if (uw_map) {
int sz = jk_map_size(init_data);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"rule map size is %d",
sz);
if (sz > 0) {
int i;
for (i = 0; i < sz; i++) {
const char *u = jk_map_name_at(init_data, i);
const char *w = jk_map_value_at(init_data, i);
/* Multiple mappings like :
* /servlets-examples|/ *
* will create two mappings:
* /servlets-examples
* and:
* /servlets-examples/ *
*/
if (strchr(u, '|')) {
char *s, *r = strdup(u);
s = strchr(r, '|');
*(s++) = '\0';
/* Add first mapping */
if (!uri_worker_map_add(uw_map, r, w, SOURCE_TYPE_JKMOUNT, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s", r, w);
rc = JK_FALSE;
}
for (; *s; s++)
*(s - 1) = *s;
*(s - 1) = '\0';
/* add second mapping */
if (!uri_worker_map_add(uw_map, r, w, SOURCE_TYPE_JKMOUNT, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s", r, w);
rc = JK_FALSE;
}
free(r);
}
else if (!uri_worker_map_add(uw_map, u, w, SOURCE_TYPE_JKMOUNT, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s",
u, w);
rc = JK_FALSE;
break;
}
if (rc == JK_FALSE)
break;
}
}
if (rc == JK_FALSE) {
jk_log(l, JK_LOG_ERROR,
"there was an error, freeing buf");
jk_close_pool(&uw_map->p_dyn[0]);
jk_close_pool(&uw_map->p_dyn[1]);
jk_close_pool(&uw_map->p);
}
else if (JK_IS_DEBUG_LEVEL(l))
uri_worker_map_dump(uw_map, "after map open", l);
}
JK_TRACE_EXIT(l);
return rc;
}
static int find_match(jk_uri_worker_map_t *uw_map,
const char *url, jk_logger_t *l)
{
unsigned int i;
JK_TRACE_ENTER(l);
for (i = 0; i < IND_THIS(uw_map->size); i++) {
uri_worker_record_t *uwr = IND_THIS(uw_map->maps)[i];
/* Check for match types */
if ((uwr->match_type & MATCH_TYPE_DISABLED) ||
(uwr->match_type & MATCH_TYPE_NO_MATCH))
continue;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "Attempting to map context URI '%s=%s' source '%s'",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
if (uwr->match_type & MATCH_TYPE_WILDCHAR_PATH) {
/* Map is already sorted by context_len */
if (jk_wildchar_match(url, uwr->context,
#ifdef WIN32
0
#else
0
#endif
) == 0) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Found a wildchar match '%s=%s'",
uwr->context, uwr->worker_name);
JK_TRACE_EXIT(l);
return i;
}
}
else if (JK_STRNCMP(uwr->context, url, uwr->context_len) == 0) {
if (strlen(url) == uwr->context_len) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Found an exact match '%s=%s'",
uwr->context, uwr->worker_name);
JK_TRACE_EXIT(l);
return i;
}
}
}
JK_TRACE_EXIT(l);
return -1;
}
static int is_nomatch(jk_uri_worker_map_t *uw_map,
const char *uri, int match,
jk_logger_t *l)
{
unsigned int i;
const char *worker = IND_THIS(uw_map->maps)[match]->worker_name;
JK_TRACE_ENTER(l);
for (i = 0; i < IND_THIS(uw_map->size); i++) {
uri_worker_record_t *uwr = IND_THIS(uw_map->maps)[i];
/* Check only nomatch mappings */
if (!(uwr->match_type & MATCH_TYPE_NO_MATCH) ||
(uwr->match_type & MATCH_TYPE_DISABLED))
continue;
/* Check only matching workers */
if (strcmp(uwr->worker_name, worker) &&
strcmp(uwr->worker_name, "*"))
continue;
if (uwr->match_type & MATCH_TYPE_WILDCHAR_PATH) {
/* Map is already sorted by context_len */
if (jk_wildchar_match(uri, uwr->context,
#ifdef WIN32
0
#else
0
#endif
) == 0) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Found a wildchar no match '%s=%s' source '%s'",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
else if (JK_STRNCMP(uwr->context, uri, uwr->context_len) == 0) {
if (strlen(uri) == uwr->context_len) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Found an exact no match '%s=%s' source '%s'",
uwr->context, uwr->worker_name, uri_worker_map_get_source(uwr, l));
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
const char *map_uri_to_worker_ext(jk_uri_worker_map_t *uw_map,
const char *uri, const char *vhost,
rule_extension_t **extensions,
int *index, jk_logger_t *l)
{
unsigned int i;
unsigned int vhost_len;
int reject_unsafe;
size_t uri_len;
size_t remain;
int rv = -1;
char url[JK_MAX_URI_LEN+1];
JK_TRACE_ENTER(l);
if (!uw_map || !uri || !extensions) {
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return NULL;
}
*extensions = NULL;
if (index)
*index = -1;
if (*uri != '/') {
if (*uri == '*' && *(uri+1) == '\0') {
/* Most likely an "OPTIONS *" request */
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"Uri %s can't be mapped.", uri);
}
} else {
jk_log(l, JK_LOG_WARNING,
"Uri %s is invalid. Uri must start with /", uri);
}
JK_TRACE_EXIT(l);
return NULL;
}
if (uw_map->fname) {
uri_worker_map_update(uw_map, 0, l);
if (!IND_THIS(uw_map->size)) {
jk_log(l, JK_LOG_INFO,
"No worker maps defined for %s.",
uw_map->fname);
JK_TRACE_EXIT(l);
return NULL;
}
}
reject_unsafe = uw_map->reject_unsafe;
vhost_len = 0;
/*
* In case we got a vhost, we prepend a slash
* and the vhost to the url in order to enable
* vhost mapping rules especially for IIS.
*/
if (vhost) {
int off = 0;
/* Add leading '/' if necessary */
if (vhost[0] != '/') {
url[0] = '/';
off = 1;
}
/* Size including leading slash. */
vhost_len = (unsigned int)strlen(vhost);
if (vhost_len + off >= JK_MAX_URI_LEN) {
vhost_len = 0;
jk_log(l, JK_LOG_WARNING,
"Host prefix %s for URI %s is invalid and will be ignored."
" It must be smaller than %d chars",
vhost, JK_MAX_URI_LEN - off);
}
else {
strncpy(&url[off], vhost, vhost_len + 1);
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG, "Prefixing mapping uri with vhost '%s'", vhost);
}
}
vhost_len += off;
}
/* Make the copy of the provided uri, check length
* and look for potentially unsafe constructs
*/
uri_len = strlen(uri);
remain = JK_MAX_URI_LEN - vhost_len;
for (i = 0; i < uri_len; i++) {
if (i == remain) {
jk_log(l, JK_LOG_WARNING,
"URI %s is invalid. URI must be smaller than %d chars",
uri, remain);
JK_TRACE_EXIT(l);
return NULL;
}
url[i + vhost_len] = uri[i];
if (reject_unsafe && (uri[i] == '%' || uri[i] == '\\')) {
jk_log(l, JK_LOG_INFO, "Potentially unsafe request url '%s' rejected", uri);
JK_TRACE_EXIT(l);
return NULL;
}
}
url[i + vhost_len] = '\0';
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "Attempting to map URI '%s' from %d maps",
url, IND_THIS(uw_map->size));
rv = find_match(uw_map, url, l);
/* If this doesn't find a match, try without the vhost. */
if (rv < 0 && vhost_len) {
rv = find_match(uw_map, &url[vhost_len], l);
}
/* In case we found a match, check for the unmounts. */
if (rv >= 0 && IND_THIS(uw_map->nosize)) {
int rc;
/* Again first including vhost. */
rc = is_nomatch(uw_map, url, rv, l);
/* If no unmount was found, try without vhost. */
if (!rc && vhost_len)
rc = is_nomatch(uw_map, &url[vhost_len], rv, l);
if (rc) {
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"Denying match for worker %s by nomatch rule",
IND_THIS(uw_map->maps)[rv]->worker_name);
}
rv = -1;
}
}
if (rv >= 0) {
*extensions = &(IND_THIS(uw_map->maps)[rv]->extensions);
if (index)
*index = rv;
JK_TRACE_EXIT(l);
return IND_THIS(uw_map->maps)[rv]->worker_name;
}
JK_TRACE_EXIT(l);
return NULL;
}
rule_extension_t *get_uri_to_worker_ext(jk_uri_worker_map_t *uw_map,
int index)
{
if (index >= 0) {
return &(IND_THIS(uw_map->maps)[index]->extensions);
}
else {
return NULL;
}
}
int uri_worker_map_load(jk_uri_worker_map_t *uw_map,
jk_logger_t *l)
{
int rc = JK_FALSE;
jk_map_t *map;
jk_map_alloc(&map);
if (jk_map_read_properties(map, NULL, uw_map->fname, &uw_map->modified,
JK_MAP_HANDLE_NORMAL, l)) {
int i;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Loading urimaps from %s with reload check interval %d seconds",
uw_map->fname, uw_map->reload);
uri_worker_map_clear(uw_map, l);
for (i = 0; i < jk_map_size(map); i++) {
const char *u = jk_map_name_at(map, i);
const char *w = jk_map_value_at(map, i);
/* Multiple mappings like :
* /servlets-examples|/ *
* will create two mappings:
* /servlets-examples
* and:
* /servlets-examples/ *
*/
if (strchr(u, '|')) {
char *s, *r = strdup(u);
s = strchr(r, '|');
*(s++) = '\0';
/* Add first mapping */
if (!uri_worker_map_add(uw_map, r, w, SOURCE_TYPE_URIMAP, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s", r, w);
}
for (; *s; s++)
*(s - 1) = *s;
*(s - 1) = '\0';
/* add second mapping */
if (!uri_worker_map_add(uw_map, r, w, SOURCE_TYPE_URIMAP, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s", r, w);
}
free(r);
}
else if (!uri_worker_map_add(uw_map, u, w, SOURCE_TYPE_URIMAP, l)) {
jk_log(l, JK_LOG_ERROR,
"invalid mapping rule %s->%s",
u, w);
}
}
uw_map->checked = time(NULL);
if (JK_IS_DEBUG_LEVEL(l))
uri_worker_map_dump(uw_map, "after file load", l);
rc = JK_TRUE;
} else {
jk_log(l, JK_LOG_ERROR, "Failed to load uri_worker_map file %s (errno=%d, err=%s).", uw_map->fname, errno, strerror(errno));
}
jk_map_free(&map);
return rc;
}
int uri_worker_map_update(jk_uri_worker_map_t *uw_map,
int force, jk_logger_t *l)
{
int rc = JK_TRUE;
time_t now = time(NULL);
if (force || (uw_map->reload > 0 && difftime(now, uw_map->checked) >
uw_map->reload)) {
struct stat statbuf;
uw_map->checked = now;
if ((rc = jk_stat(uw_map->fname, &statbuf)) == -1) {
jk_log(l, JK_LOG_ERROR,
"Unable to stat the %s (errno=%d)",
uw_map->fname, errno);
return JK_FALSE;
}
if (statbuf.st_mtime == uw_map->modified) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"File %s is not modified",
uw_map->fname);
return JK_TRUE;
}
JK_ENTER_CS(&uw_map->cs);
/* Check if some other thread updated status */
if (statbuf.st_mtime == uw_map->modified) {
JK_LEAVE_CS(&uw_map->cs);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"File %s is not modified",
uw_map->fname);
return JK_TRUE;
}
rc = uri_worker_map_load(uw_map, l);
uri_worker_map_ext(uw_map, l);
uri_worker_map_switch(uw_map, l);
JK_LEAVE_CS(&uw_map->cs);
jk_log(l, JK_LOG_INFO,
"Reloaded urimaps from %s", uw_map->fname);
}
return JK_TRUE;
}
tomcat-connectors-1.2.48-src/native/common/jk_ajp12_worker.c 0000644 0000000 0000002 00000055367 13623533443 022264 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: ajpv1.2 worker, used to call local or remote jserv hosts *
* This worker is deprecated *
* Author: Gal Shachor *
* Based on: jserv_ajpv12.c from Jserv *
***************************************************************************/
#include "jk_ajp12_worker.h"
#include "jk_pool.h"
#include "jk_connect.h"
#include "jk_util.h"
#include "jk_sockbuf.h"
#if defined(AS400) && !defined(AS400_UTF8)
#include "util_ebcdic.h"
#include
#endif
#define AJP_DEF_HOST ("localhost")
#define AJP_DEF_PORT (8007)
#define READ_BUF_SIZE (8*1024)
#define DEF_RETRY_ATTEMPTS (1)
struct ajp12_worker
{
jk_sockaddr_t worker_inet_addr;
jk_sockaddr_t worker_source_inet_addr;
unsigned connect_retry_attempts;
char *name;
jk_worker_t worker;
};
typedef struct ajp12_worker ajp12_worker_t;
struct ajp12_endpoint
{
ajp12_worker_t *worker;
jk_sock_t sd;
jk_sockbuf_t sb;
jk_endpoint_t endpoint;
};
typedef struct ajp12_endpoint ajp12_endpoint_t;
static int ajpv12_mark(ajp12_endpoint_t * p, unsigned char type);
#if defined(AS400) && !defined(AS400_UTF8)
static int ajpv12_sendasciistring(ajp12_endpoint_t * p, char *buffer);
#endif
#if defined(AS400) && !defined(AS400_UTF8)
static int ajpv12_sendstring(ajp12_endpoint_t * p, char *buffer);
#else
static int ajpv12_sendstring(ajp12_endpoint_t * p, const char *buffer);
#endif
static int ajpv12_sendint(ajp12_endpoint_t * p, int d);
static int ajpv12_sendnbytes(ajp12_endpoint_t * p,
const void *buffer, int bufferlen);
static int ajpv12_flush(ajp12_endpoint_t * p);
static int ajpv12_handle_response(ajp12_endpoint_t * p,
jk_ws_service_t *s, jk_logger_t *l);
static int ajpv12_handle_request(ajp12_endpoint_t * p,
jk_ws_service_t *s, jk_logger_t *l);
/*
* Return values of service() method for ajp12 worker:
* return value is_error reason
* JK_FALSE JK_HTTP_SERVER_ERROR Invalid parameters (null values)
* Error during connect to the backend
* ajpv12_handle_request() returns false:
* Any error during reading a request body from the client or
* sending the request to the backend
* JK_FALSE JK_HTTP_OK ajpv12_handle_response() returns false:
* Any error during reading parts of response from backend or
* sending to client
* JK_TRUE JK_HTTP_OK All other cases
*/
static int JK_METHOD service(jk_endpoint_t *e,
jk_ws_service_t *s,
jk_logger_t *l, int *is_error)
{
ajp12_endpoint_t *p;
unsigned int attempt;
int rc = -1;
/*
* AJP12 protocol is not recoverable.
*/
JK_TRACE_ENTER(l);
if (!e || !e->endpoint_private || !s || !is_error) {
JK_LOG_NULL_PARAMS(l);
if (is_error)
*is_error = JK_HTTP_SERVER_ERROR;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p = e->endpoint_private;
/* Set returned error to OK */
*is_error = JK_HTTP_OK;
for (attempt = 0; attempt < p->worker->connect_retry_attempts;
attempt++) {
p->sd =
jk_open_socket(&p->worker->worker_inet_addr,
p->worker->worker_source_inet_addr.ipaddr_ptr != NULL ?
&p->worker->worker_source_inet_addr :
NULL,
JK_FALSE, 0, 0, 0, l);
jk_log(l, JK_LOG_DEBUG, "In jk_endpoint_t::service, sd = %d",
p->sd);
if (IS_VALID_SOCKET(p->sd)) {
break;
}
}
if (IS_VALID_SOCKET(p->sd)) {
jk_sb_open(&p->sb, p->sd);
if (ajpv12_handle_request(p, s, l)) {
jk_log(l, JK_LOG_DEBUG,
"In jk_endpoint_t::service, sent request");
rc = ajpv12_handle_response(p, s, l);
JK_TRACE_EXIT(l);
return rc;
}
}
jk_log(l, JK_LOG_ERROR, "In jk_endpoint_t::service, Error sd = %d",
p->sd);
*is_error = JK_HTTP_SERVER_ERROR;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l)
{
jk_log(l, JK_LOG_DEBUG, "Into jk_endpoint_t::done");
if (e && *e && (*e)->endpoint_private) {
ajp12_endpoint_t *p = (*e)->endpoint_private;
if (IS_VALID_SOCKET(p->sd)) {
jk_shutdown_socket(p->sd, l);
}
free(p);
*e = NULL;
return JK_TRUE;
}
jk_log(l, JK_LOG_ERROR, "In jk_endpoint_t::done, NULL parameters");
return JK_FALSE;
}
static int JK_METHOD validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
jk_log(l, JK_LOG_DEBUG, "Into jk_worker_t::validate");
if (pThis && pThis->worker_private) {
ajp12_worker_t *p = pThis->worker_private;
int port = jk_get_worker_port(props,
p->name,
AJP_DEF_PORT);
const char *host = jk_get_worker_host(props,
p->name,
AJP_DEF_HOST);
const char *source = jk_get_worker_host(props,
p->name,
"");
jk_log(l, JK_LOG_DEBUG,
"In jk_worker_t::validate for worker %s target is %s:%d",
p->name, host, port);
if (host) {
if (!jk_resolve(host, port, &p->worker_inet_addr, we->pool, JK_FALSE, l)) {
jk_log(l, JK_LOG_ERROR,
"In jk_worker_t::validate, host '%s:%d' resolve failed",
host, port);
return JK_FALSE;
}
} else {
jk_log(l, JK_LOG_ERROR,
"In jk_worker_t::validate, Error no host name given");
return JK_FALSE;
}
if (source && *source) {
if (!jk_resolve(source, 0, &p->worker_source_inet_addr, we->pool, JK_FALSE, l)) {
p->worker_source_inet_addr.ipaddr_ptr = NULL;
jk_log(l, JK_LOG_WARNING,
"In jk_worker_t::validate, source addr '%s' resolve failed - ignored",
source);
}
}
return JK_TRUE;
}
else {
jk_log(l, JK_LOG_ERROR,
"In jk_worker_t::validate, NULL parameters");
}
return JK_FALSE;
}
static int JK_METHOD init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *log)
{
/* Nothing to do for now */
return JK_TRUE;
}
static int JK_METHOD get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l)
{
jk_log(l, JK_LOG_DEBUG, "Into jk_worker_t::get_endpoint");
if (pThis && pThis->worker_private && pend) {
ajp12_endpoint_t *p =
(ajp12_endpoint_t *) malloc(sizeof(ajp12_endpoint_t));
if (p) {
p->sd = JK_INVALID_SOCKET;
p->worker = pThis->worker_private;
p->endpoint.endpoint_private = p;
p->endpoint.service = service;
p->endpoint.done = done;
*pend = &p->endpoint;
return JK_TRUE;
}
jk_log(l, JK_LOG_ERROR,
"In jk_worker_t::get_endpoint, malloc failed");
}
else {
jk_log(l, JK_LOG_ERROR,
"In jk_worker_t::get_endpoint, NULL parameters");
}
return JK_FALSE;
}
static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l)
{
jk_log(l, JK_LOG_DEBUG, "Into jk_worker_t::destroy");
if (pThis && *pThis && (*pThis)->worker_private) {
ajp12_worker_t *private_data = (*pThis)->worker_private;
free(private_data->name);
free(private_data);
return JK_TRUE;
}
jk_log(l, JK_LOG_ERROR, "In jk_worker_t::destroy, NULL parameters");
return JK_FALSE;
}
int JK_METHOD ajp12_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l)
{
jk_log(l, JK_LOG_DEBUG, "Into ajp12_worker_factory");
if (NULL != name && NULL != w) {
ajp12_worker_t *private_data =
(ajp12_worker_t *) malloc(sizeof(ajp12_worker_t));
if (private_data) {
private_data->name = strdup(name);
if (private_data->name) {
private_data->connect_retry_attempts = DEF_RETRY_ATTEMPTS;
private_data->worker.worker_private = private_data;
private_data->worker.validate = validate;
private_data->worker.init = init;
private_data->worker.get_endpoint = get_endpoint;
private_data->worker.destroy = destroy;
private_data->worker.maintain = NULL;
*w = &private_data->worker;
return JK_AJP12_WORKER_TYPE;
}
free(private_data);
}
jk_log(l, JK_LOG_ERROR, "In ajp12_worker_factory, malloc failed");
}
else {
jk_log(l, JK_LOG_ERROR, "In ajp12_worker_factory, NULL parameters");
}
return 0;
}
static int ajpv12_sendnbytes(ajp12_endpoint_t * p,
const void *buffer, int bufferlen)
{
unsigned char bytes[2];
static const unsigned char null_b[2] =
{ (unsigned char)0xff, (unsigned char)0xff };
if (buffer) {
bytes[0] = (unsigned char)((bufferlen >> 8) & 0xff);
bytes[1] = (unsigned char)(bufferlen & 0xff);
if (jk_sb_write(&p->sb, bytes, 2)) {
return jk_sb_write(&p->sb, buffer, bufferlen);
}
else {
return JK_FALSE;
}
}
else {
return jk_sb_write(&p->sb, null_b, 2);
}
}
#if defined(AS400) && !defined(AS400_UTF8)
static int ajpv12_sendasciistring(ajp12_endpoint_t * p, const char *buffer)
{
int bufferlen;
if (buffer && (bufferlen = strlen(buffer))) {
return ajpv12_sendnbytes(p, buffer, bufferlen);
}
else {
return ajpv12_sendnbytes(p, NULL, 0);
}
}
#endif
static int ajpv12_sendstring(ajp12_endpoint_t * p, const char *buffer)
{
int bufferlen;
if (buffer && (bufferlen = (int)strlen(buffer))) {
#if (defined(AS400) && !defined(AS400_UTF8)) || defined(_OSD_POSIX)
char buf[2048];
if (bufferlen < 2048) {
memcpy(buf, buffer, bufferlen);
jk_xlate_to_ascii(buf, bufferlen);
return ajpv12_sendnbytes(p, buf, bufferlen);
}
else
return -1;
#else
return ajpv12_sendnbytes(p, buffer, bufferlen);
#endif
}
else {
return ajpv12_sendnbytes(p, NULL, 0);
}
}
static int ajpv12_mark(ajp12_endpoint_t * p, unsigned char type)
{
if (jk_sb_write(&p->sb, &type, 1)) {
return JK_TRUE;
}
else {
return JK_FALSE;
}
}
static int ajpv12_sendint(ajp12_endpoint_t * p, int d)
{
char buf[20];
sprintf(buf, "%d", d);
return ajpv12_sendstring(p, buf);
}
static int ajpv12_flush(ajp12_endpoint_t * p)
{
return jk_sb_flush(&p->sb);
}
static int ajpv12_handle_request(ajp12_endpoint_t * p,
jk_ws_service_t *s, jk_logger_t *l)
{
int ret;
jk_log(l, JK_LOG_DEBUG, "Into ajpv12_handle_request");
/*
* Start the ajp 12 service sequence
*/
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_request, sending the ajp12 start sequence");
ret = (ajpv12_mark(p, 1) && ajpv12_sendstring(p, s->method) && ajpv12_sendstring(p, 0) && /* zone */
ajpv12_sendstring(p, 0) && /* servlet */
ajpv12_sendstring(p, s->server_name) && ajpv12_sendstring(p, 0) && /* doc root */
ajpv12_sendstring(p, 0) && /* path info */
ajpv12_sendstring(p, 0) && /* path translated */
#if defined(AS400) && !defined(AS400_UTF8)
ajpv12_sendasciistring(p, s->query_string) &&
#else
ajpv12_sendstring(p, s->query_string) &&
#endif
ajpv12_sendstring(p, s->remote_addr) &&
ajpv12_sendstring(p, s->remote_host) &&
ajpv12_sendstring(p, s->remote_user) &&
ajpv12_sendstring(p, s->auth_type) &&
ajpv12_sendint(p, s->server_port) &&
#if defined(AS400) && !defined(AS400_UTF8)
ajpv12_sendasciistring(p, s->method) &&
#else
ajpv12_sendstring(p, s->method) &&
#endif
ajpv12_sendstring(p, s->req_uri) && ajpv12_sendstring(p, 0) && /* */
ajpv12_sendstring(p, 0) && /* SCRIPT_NAME */
#if defined(AS400) && !defined(AS400_UTF8)
ajpv12_sendasciistring(p, s->server_name) &&
#else
ajpv12_sendstring(p, s->server_name) &&
#endif
ajpv12_sendint(p, s->server_port) && ajpv12_sendstring(p, s->protocol) && ajpv12_sendstring(p, 0) && /* SERVER_SIGNATURE */
ajpv12_sendstring(p, s->server_software) && ajpv12_sendstring(p, s->route) && /* JSERV_ROUTE */
ajpv12_sendstring(p, "") && /* JSERV ajpv12 compatibility */
ajpv12_sendstring(p, "")); /* JSERV ajpv12 compatibility */
if (!ret) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to send the ajp12 start sequence");
return JK_FALSE;
}
if (s->num_attributes > 0) {
unsigned i;
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_request, sending the environment variables");
for (i = 0; i < s->num_attributes; i++) {
ret = (ajpv12_mark(p, 5) &&
ajpv12_sendstring(p, s->attributes_names[i]) &&
ajpv12_sendstring(p, s->attributes_values[i]));
if (!ret) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to send environment");
return JK_FALSE;
}
}
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_request, sending the headers");
/* Send the request headers */
if (s->num_headers) {
unsigned i;
for (i = 0; i < s->num_headers; ++i) {
ret = (ajpv12_mark(p, 3) &&
ajpv12_sendstring(p, s->headers_names[i]) &&
ajpv12_sendstring(p, s->headers_values[i]));
if (!ret) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to send headers");
return JK_FALSE;
}
}
}
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_request, sending the terminating mark");
ret = (ajpv12_mark(p, 4) && ajpv12_flush(p));
if (!ret) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to send the terminating mark");
return JK_FALSE;
}
if (s->content_length) {
char buf[READ_BUF_SIZE];
jk_uint64_t so_far = 0;
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_request, sending the request body");
while (so_far < s->content_length) {
unsigned this_time = 0;
unsigned to_read;
if (s->content_length > so_far + READ_BUF_SIZE) {
to_read = READ_BUF_SIZE;
}
else {
to_read = (unsigned int)(s->content_length - so_far);
}
if (!s->read(s, buf, to_read, &this_time)) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to read from the web server");
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_request, read %d bytes",
this_time);
if (this_time > 0) {
so_far += this_time;
if ((int)this_time != send(p->sd, buf, this_time, 0)) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, failed to write to the container");
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_request, sent %d bytes", this_time);
}
else if (this_time == 0) {
jk_log(l, JK_LOG_ERROR,
"In ajpv12_handle_request, Error: short read. content length is %" JK_UINT64_T_FMT ", read %" JK_UINT64_T_FMT,
s->content_length, so_far);
return JK_FALSE;
}
}
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_request done");
return JK_TRUE;
}
static int ajpv12_handle_response(ajp12_endpoint_t * p,
jk_ws_service_t *s, jk_logger_t *l)
{
int status = 200;
char *reason = NULL;
char **names = NULL;
char **values = NULL;
int headers_capacity = 0;
int headers_len = 0;
int write_to_ws;
jk_log(l, JK_LOG_DEBUG, "Into ajpv12_handle_response");
/*
* Read headers ...
*/
while (1) {
char *line = NULL;
char *name = NULL;
char *value = NULL;
#ifdef _MT_CODE_PTHREAD
char *lasts;
#endif
if (!jk_sb_gets(&p->sb, &line)) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, error reading header line");
return JK_FALSE;
}
#if (defined(AS400) && !defined(AS400_UTF8)) || defined(_OSD_POSIX)
jk_xlate_from_ascii(line, strlen(line));
#endif
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_response, read %s", line);
if (0 == strlen(line)) {
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_response, headers are done");
break; /* Empty line -> end of headers */
}
name = line;
while (jk_isspace(*name) && *name) {
name++; /* Skip leading white chars */
}
if (!*name) { /* Empty header name */
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, empty header name");
return JK_FALSE;
}
if (!(value = strchr(name, ':'))) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, no value supplied");
return JK_FALSE; /* No value !!! */
}
*value = '\0';
value++;
while (jk_isspace(*value) && *value) {
value++; /* Skip leading white chars */
}
if (!*value) { /* Empty header value */
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, empty header value");
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_response, read %s=%s", name,
value);
if (0 == strcmp("Status", name)) {
#ifdef _MT_CODE_PTHREAD
char *numeric = strtok_r(value, " \t", &lasts);
#else
char *numeric = strtok(value, " \t");
#endif
status = atoi(numeric);
if (status < 100 || status > 999) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, invalid status code");
return JK_FALSE;
}
#ifdef _MT_CODE_PTHREAD
reason = jk_pool_strdup(s->pool, strtok_r(NULL, " \t", &lasts));
#else
reason = jk_pool_strdup(s->pool, strtok(NULL, " \t"));
#endif
}
else {
if (headers_capacity == headers_len) {
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_response, allocating header arrays");
names =
(char **)jk_pool_realloc(s->pool,
sizeof(char *) *
(headers_capacity + 5), names,
sizeof(char *) *
headers_capacity);
values =
(char **)jk_pool_realloc(s->pool,
sizeof(char *) *
(headers_capacity + 5), values,
sizeof(char *) *
headers_capacity);
if (!values || !names) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, malloc error");
return JK_FALSE;
}
headers_capacity = headers_capacity + 5;
}
names[headers_len] = jk_pool_strdup(s->pool, name);
values[headers_len] = jk_pool_strdup(s->pool, value);
headers_len++;
}
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_response, starting response");
if (!s->start_response(s,
status,
reason,
(const char *const *)names,
(const char *const *)values, headers_len)) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, error starting response");
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_response, reading response body");
/*
* Read response body
*/
write_to_ws = JK_TRUE;
while (1) {
unsigned to_read = READ_BUF_SIZE;
unsigned acc = 0;
char *buf = NULL;
if (!jk_sb_read(&p->sb, &buf, to_read, &acc)) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, error reading from ");
return JK_FALSE;
}
if (!acc) {
jk_log(l, JK_LOG_DEBUG,
"ajpv12_handle_response, response body is done");
break;
}
if (write_to_ws) {
if (!s->write(s, buf, acc)) {
jk_log(l, JK_LOG_ERROR,
"ajpv12_handle_response, error writing back to server");
write_to_ws = JK_FALSE;
}
}
}
jk_log(l, JK_LOG_DEBUG, "ajpv12_handle_response done");
return JK_TRUE;
}
tomcat-connectors-1.2.48-src/native/common/config.h.in 0000644 0000000 0000002 00000006330 13623533446 021136 0 ustar root bin /* common/config.h.in. Generated from configure.ac by autoheader. */
/* Define to 1 if you have IPv6 support */
#undef HAVE_AF_INET6
/* Define to 1 if the compiler provides atomic builtins */
#undef HAVE_ATOMIC_BUILTINS
/* Define to 1 if you have the header file. */
#undef HAVE_DLFCN_H
/* Have flock() */
#undef HAVE_FLOCK
/* Have getaddrinfo() */
#undef HAVE_GETADDRINFO
/* Have gethostbyname_r() */
#undef HAVE_GETHOSTBYNAME_R
/* Define to 1 if you have the header file. */
#undef HAVE_INTTYPES_H
/* Define to 1 if you have the header file. */
#undef HAVE_MEMORY_H
/* Define to 1 if you have the header file. */
#undef HAVE_NETDB_H
/* Define to 1 if you have the header file. */
#undef HAVE_NETINET_IN_H
/* Have poll() */
#undef HAVE_POLL
/* Define to 1 if you have the header file. */
#undef HAVE_POLL_H
/* Have snprintf() */
#undef HAVE_SNPRINTF
/* Define to 1 if you have struct sockaddr_storage */
#undef HAVE_SOCKADDR_STORAGE
/* Define to 1 if you have the header file. */
#undef HAVE_STDINT_H
/* Define to 1 if you have the header file. */
#undef HAVE_STDLIB_H
/* Define to 1 if you have the header file. */
#undef HAVE_STRINGS_H
/* Define to 1 if you have the header file. */
#undef HAVE_STRING_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_FILIO_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_STAT_H
/* Define to 1 if you have the header file. */
#undef HAVE_SYS_TYPES_H
/* Define to 1 if you have the header file. */
#undef HAVE_UNISTD_H
/* Have vsnprintf() */
#undef HAVE_VSNPRINTF
/* Define to the sub-directory where libtool stores uninstalled libraries. */
#undef LT_OBJDIR
/* Name of package */
#undef PACKAGE
/* Define to the address where bug reports for this package should be sent. */
#undef PACKAGE_BUGREPORT
/* Define to the full name of this package. */
#undef PACKAGE_NAME
/* Define to the full name and version of this package. */
#undef PACKAGE_STRING
/* Define to the one symbol short name of this package. */
#undef PACKAGE_TARNAME
/* Define to the home page for this package. */
#undef PACKAGE_URL
/* Define to the version of this package. */
#undef PACKAGE_VERSION
/* The size of `char', as computed by sizeof. */
#undef SIZEOF_CHAR
/* The size of `int', as computed by sizeof. */
#undef SIZEOF_INT
/* The size of `long', as computed by sizeof. */
#undef SIZEOF_LONG
/* The size of `longlong', as computed by sizeof. */
#undef SIZEOF_LONGLONG
/* The size of `long double', as computed by sizeof. */
#undef SIZEOF_LONG_DOUBLE
/* The size of `long long', as computed by sizeof. */
#undef SIZEOF_LONG_LONG
/* The size of pid_t */
#undef SIZEOF_PID_T
/* The size of pthread_t */
#undef SIZEOF_PTHREAD_T
/* The size of `short', as computed by sizeof. */
#undef SIZEOF_SHORT
/* Define to 1 if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Define to use SOCK_CLOEXEC with socket() */
#undef USE_SOCK_CLOEXEC
/* Define to use SO_RCVTIMEO with setsockopt() */
#undef USE_SO_RCVTIMEO
/* Define to use SO_SNDTIMEO with setsockopt() */
#undef USE_SO_SNDTIMEO
/* Version number of package */
#undef VERSION
tomcat-connectors-1.2.48-src/native/common/jk_util.h 0000644 0000000 0000002 00000023646 13623533443 020733 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Various utility functions *
* Author: Gal Shachor *
* Author: Henri Gomez *
* Author: Rainer Jung *
***************************************************************************/
#ifndef _JK_UTIL_H
#define _JK_UTIL_H
#include "jk_global.h"
#include "jk_logger.h"
#include "jk_map.h"
#include "jk_pool.h"
#include "jk_service.h"
#define JK_SLEEP_DEF (100)
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
const char *jk_get_bool(int v);
int jk_get_bool_code(const char *v, int def);
void jk_sleep(int ms);
void jk_set_time_fmt(jk_logger_t *l, const char *jk_log_fmt);
int jk_parse_log_level(const char *level);
int jk_open_file_logger(jk_logger_t **l, const char *file, int level);
int jk_attach_file_logger(jk_logger_t **l, int fd, int level);
int jk_close_file_logger(jk_logger_t **l);
int jk_log(jk_logger_t *l,
const char *file, int line, const char *funcname, int level,
const char *fmt, ...);
int jk_check_attribute_length(const char *name, const char *value,
jk_logger_t *l);
const char *jk_get_worker_host(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_source(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_type(jk_map_t *m, const char *wname);
int jk_get_worker_port(jk_map_t *m, const char *wname, int def);
int jk_get_worker_prefer_ipv6(jk_map_t *m, const char *wname, int def);
int jk_get_worker_cache_size(jk_map_t *m, const char *wname, int def);
int jk_get_worker_cache_size_min(jk_map_t *m, const char *wname, int def);
int jk_get_worker_cache_acquire_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_socket_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_socket_connect_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_socket_buffer(jk_map_t *m, const char *wname, int def);
int jk_get_worker_socket_keepalive(jk_map_t *m, const char *wname, int def);
int jk_get_worker_conn_ping_interval(jk_map_t *m, const char *wname, int def);
int jk_get_worker_cache_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_recovery_opts(jk_map_t *m, const char *wname, int def);
int jk_get_worker_connect_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_reply_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_prepost_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_ping_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_ping_mode(jk_map_t *m, const char *wname, int def);
int jk_get_worker_recycle_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_recover_timeout(jk_map_t *m, const char *wname, int def);
int jk_get_worker_error_escalation_time(jk_map_t *m, const char *wname, int def);
int jk_get_worker_max_reply_timeouts(jk_map_t *m, const char *wname, int def);
int jk_get_worker_retry_interval(jk_map_t *m, const char *wname, int def);
int jk_get_worker_busy_limit(jk_map_t *m, const char *wname, int def);
const char *jk_get_worker_route(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_domain(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_redirect(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_secret_key(jk_map_t *m, const char *wname);
const char *jk_get_lb_session_cookie(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_lb_session_path(jk_map_t *m, const char *wname, const char *def);
int jk_get_lb_set_session_cookie(jk_map_t *m, const char *wname, int def);
const char *jk_get_lb_session_cookie_path(jk_map_t *m, const char *wname, const char *def);
int jk_get_worker_retries(jk_map_t *m, const char *wname, int def);
int jk_get_worker_lb_retries(jk_map_t *m, const char *wname, int def);
int jk_get_is_worker_disabled(jk_map_t *m, const char *wname);
int jk_get_is_worker_stopped(jk_map_t *m, const char *wname);
int jk_get_worker_activation(jk_map_t *m, const char *wname);
int jk_get_worker_list(jk_map_t *m, char ***list, unsigned *num_of_workers);
int jk_get_lb_factor(jk_map_t *m, const char *wname);
int jk_get_distance(jk_map_t *m, const char *wname);
int jk_get_is_sticky_session(jk_map_t *m, const char *wname);
int jk_get_is_sticky_session_force(jk_map_t *m, const char *wname);
int jk_get_lb_method(jk_map_t *m, const char *wname);
int jk_get_lb_lock(jk_map_t *m, const char *wname);
int jk_get_lb_worker_list(jk_map_t *m,
const char *lb_wname,
char ***list, unsigned int *num_of_workers);
int jk_get_worker_mount_list(jk_map_t *m,
const char *wname,
char ***list, unsigned int *num_of_maps);
const char *jk_get_worker_secret(jk_map_t *m, const char *wname);
int jk_get_worker_mx(jk_map_t *m, const char *wname, unsigned *mx);
int jk_get_worker_ms(jk_map_t *m, const char *wname, unsigned *ms);
int jk_get_worker_classpath(jk_map_t *m, const char *wname, const char **cp);
int jk_get_worker_bridge_type(jk_map_t *m, const char *wname, unsigned *bt);
int jk_get_worker_jvm_path(jk_map_t *m, const char *wname, const char **vm_path);
int jk_get_worker_callback_dll(jk_map_t *m,
const char *wname, const char **cb_path);
int jk_get_worker_cmd_line(jk_map_t *m, const char *wname, const char **cmd_line);
int jk_file_exists(const char *f);
int jk_is_list_property(const char *prp_name);
int jk_is_path_property(const char *prp_name);
int jk_is_cmd_line_property(const char *prp_name);
int jk_is_unique_property(const char *prp_name);
int jk_is_deprecated_property(const char *prp_name);
int jk_check_buffer_size();
int jk_is_valid_property(const char *prp_name);
int jk_get_worker_stdout(jk_map_t *m, const char *wname, const char **stdout_name);
int jk_get_worker_stderr(jk_map_t *m, const char *wname, const char **stderr_name);
int jk_get_worker_sysprops(jk_map_t *m, const char *wname, const char **sysprops);
int jk_get_worker_libpath(jk_map_t *m, const char *wname, const char **libpath);
char **jk_parse_sysprops(jk_pool_t *p, const char *sysprops);
void jk_append_libpath(jk_pool_t *p, const char *libpath);
void jk_set_worker_def_cache_size(int sz);
int jk_get_worker_def_cache_size(int protocol);
int jk_get_worker_maintain_time(jk_map_t *m);
int jk_get_max_packet_size(jk_map_t *m, const char *wname);
const char *jk_get_worker_style_sheet(jk_map_t *m, const char *wname, const char *def);
int jk_get_is_read_only(jk_map_t *m, const char *wname);
int jk_get_worker_user_list(jk_map_t *m,
const char *wname,
char ***list, unsigned int *num);
int jk_get_worker_good_rating(jk_map_t *m,
const char *wname,
char ***list, unsigned int *num);
int jk_get_worker_bad_rating(jk_map_t *m,
const char *wname,
char ***list, unsigned int *num);
const char *jk_get_worker_name_space(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_xmlns(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_xml_doctype(jk_map_t *m, const char *wname, const char *def);
const char *jk_get_worker_prop_prefix(jk_map_t *m, const char *wname, const char *def);
int jk_get_worker_fail_on_status(jk_map_t *m, const char *wname,
int **list, unsigned int *list_size);
int jk_get_worker_user_case_insensitive(jk_map_t *m, const char *wname);
int is_http_status_fail(unsigned int http_status_fail_num,
int *http_status_fail, int status);
int jk_wildchar_match(const char *str, const char *exp, int icase);
int jk_servlet_normalize(char *path, jk_logger_t *logger);
int jk_strip_session_id(char* path, char* session_name, jk_logger_t *logger);
#define JK_NORMALIZE_BAD_PATH -1
#define JK_NORMALIZE_TRAVERSAL -2
#define TC32_BRIDGE_TYPE 32
#define TC33_BRIDGE_TYPE 33
#define TC40_BRIDGE_TYPE 40
#define TC41_BRIDGE_TYPE 41
#define TC50_BRIDGE_TYPE 50
#ifdef AS400
#define S_IFREG _S_IFREG
#ifdef AS400_UTF8
void jk_ascii2ebcdic(char *src, char *dst);
void jk_ebcdic2ascii(char *src, char *dst);
#endif /* AS400_UTF8 */
#endif
/* i5/OS V5R4 need ASCII-EBCDIC conversion before stat() call */
/* added a stat() mapper function, jk_stat, for such purpose */
int jk_stat(const char *f, struct stat * statbuf);
#if defined (WIN32)
PSECURITY_ATTRIBUTES jk_get_sa_with_null_dacl(void);
#endif
#define jk_isspace(c) (isspace(((unsigned char)(c))))
#define jk_isalnum(c) (isalnum(((unsigned char)(c))))
#define jk_isdigit(c) (isdigit(((unsigned char)(c))))
#define jk_isalpha(c) (isalpha(((unsigned char)(c))))
#define jk_islower(c) (islower(((unsigned char)(c))))
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _JK_UTIL_H */
tomcat-connectors-1.2.48-src/native/common/jk_ajp14.h 0000644 0000000 0000002 00000020230 13623533443 020657 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Next generation bi-directional protocol handler. *
* Author: Henri Gomez *
***************************************************************************/
#ifndef JK_AJP14_H
#define JK_AJP14_H
#include "jk_ajp_common.h"
#include "jk_context.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define AJP14_PROTO 14
#define AJP14_WS_HEADER 0x1235
#define AJP14_SW_HEADER 0x1235 /* AJP14 use now the same header in both directions */
#define AJP14_DEF_HOST ("localhost")
#define AJP14_DEF_PORT (8011)
#define AJP14_DEF_RETRY_ATTEMPTS (1)
#define AJP14_DEF_CACHE_SZ (1)
#define AJP14_HEADER_LEN (4)
#define AJP14_HEADER_SZ_LEN (2)
/*
* Initial Login Phase (web server -> servlet engine)
*/
#define AJP14_LOGINIT_CMD (unsigned char)0x10
/*
* Second Login Phase (servlet engine -> web server), md5 seed is received
*/
#define AJP14_LOGSEED_CMD (unsigned char)0x11
/*
* Third Login Phase (web server -> servlet engine), md5 of seed + secret is sent
*/
#define AJP14_LOGCOMP_CMD (unsigned char)0x12
/*
* Login Accepted (servlet engine -> web server)
*/
#define AJP14_LOGOK_CMD (unsigned char)0x13
/*
* Login Rejected (servlet engine -> web server), will be logged
*/
#define AJP14_LOGNOK_CMD (unsigned char)0x14
/*
* Context Query (web server -> servlet engine), which URI are handled by servlet engine ?
*/
#define AJP14_CONTEXT_QRY_CMD (unsigned char)0x15
/*
* Context Info (servlet engine -> web server), URI handled response
*/
#define AJP14_CONTEXT_INFO_CMD (unsigned char)0x16
/*
* Context Update (servlet engine -> web server), status of context changed
*/
#define AJP14_CONTEXT_UPDATE_CMD (unsigned char)0x17
/*
* Servlet Engine Status (web server -> servlet engine), what's the status of the servlet engine ?
*/
#define AJP14_STATUS_CMD (unsigned char)0x18
/*
* Secure Shutdown command (web server -> servlet engine), please servlet stop yourself.
*/
#define AJP14_SHUTDOWN_CMD (unsigned char)0x19
/*
* Secure Shutdown command Accepted (servlet engine -> web server)
*/
#define AJP14_SHUTOK_CMD (unsigned char)0x1A
/*
* Secure Shutdown Rejected (servlet engine -> web server)
*/
#define AJP14_SHUTNOK_CMD (unsigned char)0x1B
/*
* Context Status (web server -> servlet engine), what's the status of the context ?
*/
#define AJP14_CONTEXT_STATE_CMD (unsigned char)0x1C
/*
* Context Status Reply (servlet engine -> web server), status of context
*/
#define AJP14_CONTEXT_STATE_REP_CMD (unsigned char)0x1D
/*
* Unknown Packet Reply (web server <-> servlet engine), when a packet couldn't be decoded
*/
#define AJP14_UNKNOW_PACKET_CMD (unsigned char)0x1E
/*
* Negotiation flags
*/
/*
* web-server want context info after login
*/
#define AJP14_CONTEXT_INFO_NEG 0x80000000
/*
* web-server want context updates
*/
#define AJP14_CONTEXT_UPDATE_NEG 0x40000000
/*
* web-server want compressed stream
*/
#define AJP14_GZIP_STREAM_NEG 0x20000000
/*
* web-server want crypted DES56 stream with secret key
*/
#define AJP14_DES56_STREAM_NEG 0x10000000
/*
* Extended info on server SSL vars
*/
#define AJP14_SSL_VSERVER_NEG 0x08000000
/*
*Extended info on client SSL vars
*/
#define AJP14_SSL_VCLIENT_NEG 0x04000000
/*
* Extended info on crypto SSL vars
*/
#define AJP14_SSL_VCRYPTO_NEG 0x02000000
/*
* Extended info on misc SSL vars
*/
#define AJP14_SSL_VMISC_NEG 0x01000000
/*
* mask of protocol supported
*/
#define AJP14_PROTO_SUPPORT_AJPXX_NEG 0x00FF0000
/*
* communication could use AJP14
*/
#define AJP14_PROTO_SUPPORT_AJP14_NEG 0x00010000
/*
* communication could use AJP15
*/
#define AJP14_PROTO_SUPPORT_AJP15_NEG 0x00020000
/*
* communication could use AJP16
*/
#define AJP14_PROTO_SUPPORT_AJP16_NEG 0x00040000
/*
* Some failure codes
*/
#define AJP14_BAD_KEY_ERR 0xFFFFFFFF
#define AJP14_ENGINE_DOWN_ERR 0xFFFFFFFE
#define AJP14_RETRY_LATER_ERR 0xFFFFFFFD
#define AJP14_SHUT_AUTHOR_FAILED_ERR 0xFFFFFFFC
/*
* Some status codes
*/
#define AJP14_CONTEXT_DOWN 0x01
#define AJP14_CONTEXT_UP 0x02
#define AJP14_CONTEXT_OK 0x03
/*
* Misc defines
*/
#define AJP14_ENTROPY_SEED_LEN 32 /* we're using MD5 => 32 chars */
#define AJP14_COMPUTED_KEY_LEN 32 /* we're using MD5 also */
/*
* The login structure
*/
typedef struct jk_login_service jk_login_service_t;
struct jk_login_service
{
/*
* Pointer to web-server name
*/
const char *web_server_name;
/*
* Pointer to servlet-engine name
*/
char *servlet_engine_name;
/*
* Pointer to secret key
*/
const char *secret_key;
/*
* Received entropy seed
*/
char entropy[AJP14_ENTROPY_SEED_LEN + 1];
/*
* Computed key
*/
char computed_key[AJP14_COMPUTED_KEY_LEN + 1];
/*
* What we want to negociate
*/
unsigned long negotiation;
/*
* What we received from servlet engine
*/
unsigned long negociated;
};
/*
* functions defined here
*/
void ajp14_compute_md5(jk_login_service_t *s, jk_logger_t *l);
int ajp14_marshal_login_init_into_msgb(jk_msg_buf_t *msg,
jk_login_service_t *s,
jk_logger_t *l);
int ajp14_unmarshal_login_seed(jk_msg_buf_t *msg,
jk_login_service_t *s, jk_logger_t *l);
int ajp14_marshal_login_comp_into_msgb(jk_msg_buf_t *msg,
jk_login_service_t *s,
jk_logger_t *l);
int ajp14_unmarshal_log_ok(jk_msg_buf_t *msg,
jk_login_service_t *s, jk_logger_t *l);
int ajp14_unmarshal_log_nok(jk_msg_buf_t *msg, jk_logger_t *l);
int ajp14_marshal_shutdown_into_msgb(jk_msg_buf_t *msg,
jk_login_service_t *s,
jk_logger_t *l);
int ajp14_unmarshal_shutdown_nok(jk_msg_buf_t *msg, jk_logger_t *l);
int ajp14_marshal_unknown_packet_into_msgb(jk_msg_buf_t *msg,
jk_msg_buf_t *unk,
jk_logger_t *l);
int ajp14_marshal_context_query_into_msgb(jk_msg_buf_t *msg,
char *virtual, jk_logger_t *l);
int ajp14_unmarshal_context_info(jk_msg_buf_t *msg,
jk_context_t *context, jk_logger_t *l);
int ajp14_marshal_context_state_into_msgb(jk_msg_buf_t *msg,
jk_context_t *context,
char *cname, jk_logger_t *l);
int ajp14_unmarshal_context_state_reply(jk_msg_buf_t *msg,
jk_context_t *context,
jk_logger_t *l);
int ajp14_unmarshal_context_update_cmd(jk_msg_buf_t *msg,
jk_context_t *context,
jk_logger_t *l);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* JK_AJP14_H */
tomcat-connectors-1.2.48-src/native/common/jk_ajp_common.h 0000644 0000000 0000002 00000040443 13623533443 022072 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: common stuff for bi-directional protocol ajp13/ajp14. *
* Author: Gal Shachor *
* Author: Henri Gomez *
***************************************************************************/
#ifndef JK_AJP_COMMON_H
#define JK_AJP_COMMON_H
#include "jk_service.h"
#include "jk_msg_buff.h"
#include "jk_shm.h"
#include "jk_mt.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define JK_AJP_STATE_IDLE (0)
#define JK_AJP_STATE_OK (1)
#define JK_AJP_STATE_ERROR (2)
#define JK_AJP_STATE_PROBE (3)
#define JK_AJP_STATE_DEF (JK_AJP_STATE_IDLE)
#define JK_AJP_STATE_TEXT_IDLE ("OK/IDLE")
#define JK_AJP_STATE_TEXT_OK ("OK")
#define JK_AJP_STATE_TEXT_ERROR ("ERR")
#define JK_AJP_STATE_TEXT_PROBE ("ERR/PRB")
#define JK_AJP_STATE_TEXT_MAX (JK_AJP_STATE_PROBE)
#define JK_AJP_STATE_TEXT_DEF (JK_AJP_STATE_TEXT_IDLE)
/*
* Conditional request attributes
*
*/
#define SC_A_CONTEXT (unsigned char)1
#define SC_A_SERVLET_PATH (unsigned char)2
#define SC_A_REMOTE_USER (unsigned char)3
#define SC_A_AUTH_TYPE (unsigned char)4
#define SC_A_QUERY_STRING (unsigned char)5
#define SC_A_ROUTE (unsigned char)6
#define SC_A_SSL_CERT (unsigned char)7
#define SC_A_SSL_CIPHER (unsigned char)8
#define SC_A_SSL_SESSION (unsigned char)9
#define SC_A_REQ_ATTRIBUTE (unsigned char)10
#define SC_A_SSL_KEY_SIZE (unsigned char)11 /* only in if JkOptions +ForwardKeySize */
#define SC_A_SECRET (unsigned char)12
#define SC_A_STORED_METHOD (unsigned char)13
#define SC_A_ARE_DONE (unsigned char)0xFF
/*
* AJP private request attributes
*/
/*
* The following request attribute is recognized by Tomcat
* to contain the name of the ssl protocol used
*/
#define SC_A_SSL_PROTOCOL ("AJP_SSL_PROTOCOL")
/*
* The following request attribute is recognized by Tomcat
* to contain the forwarded remote port.
*/
#define SC_A_REQ_REMOTE_PORT ("AJP_REMOTE_PORT")
/*
* The following request attribute is recognized by Tomcat
* to contain the forwarded local ip address.
*/
#define SC_A_REQ_LOCAL_ADDR ("AJP_LOCAL_ADDR")
/*
* JK public request attributes
*
* Activation state of the worker in the load balancer.
* Can be any of the JK_LB_ACTIVATION_TEXT_* strings
* from jk_lb_worker.h.
*/
#define SC_A_JK_LB_ACTIVATION ("JK_LB_ACTIVATION")
/*
* Request methods, coded as numbers instead of strings.
* The list of methods was taken from Section 5.1.1 of RFC 2616,
* RFC 2518, the ACL IETF draft, and the DeltaV IESG Proposed Standard.
* Method = "OPTIONS"
* | "GET"
* | "HEAD"
* | "POST"
* | "PUT"
* | "DELETE"
* | "TRACE"
* | "PROPFIND"
* | "PROPPATCH"
* | "MKCOL"
* | "COPY"
* | "MOVE"
* | "LOCK"
* | "UNLOCK"
* | "ACL"
* | "REPORT"
* | "VERSION-CONTROL"
* | "CHECKIN"
* | "CHECKOUT"
* | "UNCHECKOUT"
* | "SEARCH"
* | "MKWORKSPACE"
* | "UPDATE"
* | "LABEL"
* | "MERGE"
* | "BASELINE-CONTROL"
* | "MKACTIVITY"
*
*/
#define SC_M_OPTIONS (unsigned char)1
#define SC_M_GET (unsigned char)2
#define SC_M_HEAD (unsigned char)3
#define SC_M_POST (unsigned char)4
#define SC_M_PUT (unsigned char)5
#define SC_M_DELETE (unsigned char)6
#define SC_M_TRACE (unsigned char)7
#define SC_M_PROPFIND (unsigned char)8
#define SC_M_PROPPATCH (unsigned char)9
#define SC_M_MKCOL (unsigned char)10
#define SC_M_COPY (unsigned char)11
#define SC_M_MOVE (unsigned char)12
#define SC_M_LOCK (unsigned char)13
#define SC_M_UNLOCK (unsigned char)14
#define SC_M_ACL (unsigned char)15
#define SC_M_REPORT (unsigned char)16
#define SC_M_VERSION_CONTROL (unsigned char)17
#define SC_M_CHECKIN (unsigned char)18
#define SC_M_CHECKOUT (unsigned char)19
#define SC_M_UNCHECKOUT (unsigned char)20
#define SC_M_SEARCH (unsigned char)21
#define SC_M_MKWORKSPACE (unsigned char)22
#define SC_M_UPDATE (unsigned char)23
#define SC_M_LABEL (unsigned char)24
#define SC_M_MERGE (unsigned char)25
#define SC_M_BASELINE_CONTROL (unsigned char)26
#define SC_M_MKACTIVITY (unsigned char)27
#define SC_M_JK_STORED (unsigned char)0xFF
/*
* Frequent request headers, these headers are coded as numbers
* instead of strings.
*
* Accept
* Accept-Charset
* Accept-Encoding
* Accept-Language
* Authorization
* Connection
* Content-Type
* Content-Length
* Cookie
* Cookie2
* Host
* Pragma
* Referer
* User-Agent
*
*/
#define SC_ACCEPT (unsigned short)0xA001
#define SC_ACCEPT_CHARSET (unsigned short)0xA002
#define SC_ACCEPT_ENCODING (unsigned short)0xA003
#define SC_ACCEPT_LANGUAGE (unsigned short)0xA004
#define SC_AUTHORIZATION (unsigned short)0xA005
#define SC_CONNECTION (unsigned short)0xA006
#define SC_CONTENT_TYPE (unsigned short)0xA007
#define SC_CONTENT_LENGTH (unsigned short)0xA008
#define SC_COOKIE (unsigned short)0xA009
#define SC_COOKIE2 (unsigned short)0xA00A
#define SC_HOST (unsigned short)0xA00B
#define SC_PRAGMA (unsigned short)0xA00C
#define SC_REFERER (unsigned short)0xA00D
#define SC_USER_AGENT (unsigned short)0xA00E
/*
* Frequent response headers, these headers are coded as numbers
* instead of strings.
*
* Content-Type
* Content-Language
* Content-Length
* Date
* Last-Modified
* Location
* Set-Cookie
* Servlet-Engine
* Status
* WWW-Authenticate
*
*/
#define SC_RESP_CONTENT_TYPE (unsigned short)0xA001
#define SC_RESP_CONTENT_LANGUAGE (unsigned short)0xA002
#define SC_RESP_CONTENT_LENGTH (unsigned short)0xA003
#define SC_RESP_DATE (unsigned short)0xA004
#define SC_RESP_LAST_MODIFIED (unsigned short)0xA005
#define SC_RESP_LOCATION (unsigned short)0xA006
#define SC_RESP_SET_COOKIE (unsigned short)0xA007
#define SC_RESP_SET_COOKIE2 (unsigned short)0xA008
#define SC_RESP_SERVLET_ENGINE (unsigned short)0xA009
#define SC_RESP_STATUS (unsigned short)0xA00A
#define SC_RESP_WWW_AUTHENTICATE (unsigned short)0xA00B
#define SC_RES_HEADERS_NUM 11
/*
* AJP13/AJP14 use same message structure
*/
#define AJP_DEF_RETRY_ATTEMPTS (1)
#define AJP_HEADER_LEN (4)
#define AJP_HEADER_SZ_LEN (2)
#define CHUNK_BUFFER_PAD (12)
#define AJP_DEF_CACHE_TIMEOUT (0)
#define AJP_DEF_CONNECT_TIMEOUT (0) /* NO CONNECTION TIMEOUT => NO CPING/CPONG */
#define AJP_DEF_REPLY_TIMEOUT (0) /* NO REPLY TIMEOUT */
#define AJP_DEF_PREPOST_TIMEOUT (0) /* NO PREPOST TIMEOUT => NO CPING/CPONG */
#define AJP_DEF_RECOVERY_OPTS (0) /* NO RECOVERY / NO */
#define AJP_DEF_SOCKET_TIMEOUT (0) /* No timeout */
#define AJP_DEF_PING_TIMEOUT (10000) /* Default CPING/CPONG timeout (10 seconds) */
#define AJP_CPING_NONE (0) /* Do not send cping packets */
#define AJP_CPING_CONNECT (1) /* Send cping on fresh connection */
#define AJP_CPING_PREPOST (2) /* Send cping before sending request */
#define AJP_CPING_INTERVAL (4) /* Send cping on regular intervals */
#define AJP_CPING_MAX (AJP_CPING_INTERVAL)
#define AJP_CPING_CONNECT_TEXT ('C') /* Send cping on fresh connection */
#define AJP_CPING_PREPOST_TEXT ('P') /* Send cping before sending request */
#define AJP_CPING_INTERVAL_TEXT ('I') /* Send cping on regular intervals */
#define AJP_CPING_ALL_TEXT ('A') /* Send cping on regular intervals */
#define RECOVER_ABORT_IF_TCGETREQUEST 0x0001 /* DON'T RECOVER IF TOMCAT FAILS AFTER RECEIVING REQUEST */
#define RECOVER_ABORT_IF_TCSENDHEADER 0x0002 /* DON'T RECOVER IF TOMCAT FAILS AFTER SENDING HEADERS */
#define RECOVER_ABORT_IF_CLIENTERROR 0x0004 /* CLOSE THE SOCKET IN CASE OF CLIENT ERROR */
#define RECOVER_ALWAYS_HTTP_HEAD 0x0008 /* RECOVER HTTP HEAD REQUESTS, EVEN IF ABORT OPTIONS ARE SET */
#define RECOVER_ALWAYS_HTTP_GET 0x0010 /* RECOVER HTTP GET REQUESTS, EVEN IF ABORT OPTIONS ARE SET */
struct jk_res_data
{
int status;
#ifdef AS400
char *msg;
#else
const char *msg;
#endif
unsigned num_headers;
char **header_names;
char **header_values;
};
typedef struct jk_res_data jk_res_data_t;
#include "jk_ajp14.h"
struct ajp_operation;
typedef struct ajp_operation ajp_operation_t;
struct ajp_endpoint;
typedef struct ajp_endpoint ajp_endpoint_t;
struct ajp_worker;
typedef struct ajp_worker ajp_worker_t;
struct ajp_worker
{
jk_worker_t worker;
/* Shared memory worker data */
jk_shm_ajp_worker_t *s;
char name[JK_SHM_STR_SIZ];
/* Sequence counter starting at 0 and increasing
* every time we change the config
*/
volatile unsigned int sequence;
jk_pool_t p;
jk_pool_atom_t buf[TINY_POOL_SIZE];
JK_CRIT_SEC cs;
jk_sockaddr_t worker_inet_addr; /* Contains host and port */
jk_sockaddr_t worker_source_inet_addr; /* Contains source ip */
unsigned connect_retry_attempts;
char host[JK_SHM_STR_SIZ];
int port;
char source[JK_SHM_STR_SIZ];
int addr_sequence; /* Whether the address is resolved */
int maintain_time;
int prefer_ipv6;
/*
* Open connections cache...
*
* 1. Critical section object to protect the cache.
* 2. Cache size.
* 3. An array of "open" endpoints.
*/
unsigned int ep_cache_sz;
unsigned int ep_mincache_sz;
unsigned int ep_maxcache_sz;
int cache_acquire_timeout;
ajp_endpoint_t **ep_cache;
int proto; /* PROTOCOL USED AJP13/AJP14 */
jk_login_service_t *login;
/* Weak secret similar with ajp12, used in ajp13 */
const char *secret;
/*
* Post physical connect handler.
* AJP14 will set here its login handler
*/
int (*logon) (ajp_endpoint_t * ae, jk_logger_t *l);
/*
* Handle Socket Timeouts
*/
int socket_timeout;
int socket_connect_timeout;
int keepalive;
int socket_buf;
/*
* Handle Cache Timeouts
*/
int cache_timeout;
/*
* Handle Connection/Reply Timeouts
*/
int connect_timeout; /* connect cping/cpong delay in ms (0 means disabled) */
int reply_timeout; /* reply timeout delay in ms (0 means disabled) */
int prepost_timeout; /* before sending a request cping/cpong timeout delay in ms (0 means disabled) */
int conn_ping_interval; /* interval for sending keepalive cping packets on
* unused connection */
int ping_timeout; /* generic cping/cpong timeout. Used for keepalive packets or
* as default for boolean valued connect and prepost timeouts.
*/
unsigned int ping_mode; /* Ping mode flags (which types of cpings should be used) */
/*
* Recovery options
*/
unsigned int recovery_opts;
/*
* Public property to enable the number of retry attempts
* on this worker.
*/
int retries;
/*
* Public property used in load balancer workers, meaning
* the maximum number of failover attempts between ajp
* workers of cluster.
*/
int lb_retries;
unsigned int max_packet_size; /* Maximum AJP Packet size */
int retry_interval; /* Number of milliseconds to sleep before doing a retry */
int busy_limit; /* Maximum allowed number of concurrent requests (if > 0) */
/*
* HTTP status that will cause failover (0 means disabled)
*/
unsigned int http_status_fail_num;
int *http_status_fail;
};
/*
* endpoint, the remote connector which does the work
*/
struct ajp_endpoint
{
ajp_worker_t *worker;
jk_pool_t pool;
jk_pool_atom_t buf[BIG_POOL_SIZE];
int proto; /* PROTOCOL USED AJP13/AJP14 */
jk_sock_t sd;
int reuse;
int avail; /* Set to non-zero if cache slot is available */
/* Used with RECOVER_ABORT_IF_CLIENTERROR to hard abort
write of AJP response on client write errors */
int hard_close;
jk_endpoint_t endpoint;
jk_uint64_t left_bytes_to_send;
/* time of the last request
handled by this endpoint */
time_t last_access;
int last_errno;
/* Last operation performed via this endpoint */
int last_op;
int addr_sequence; /* Whether the address is resolved */
};
/*
* little struct to avoid multiples ptr passing
* this struct is ready to hold upload file fd
* to add upload persistant storage
*/
struct ajp_operation
{
jk_msg_buf_t *request; /* original request storage */
jk_msg_buf_t *reply; /* reply storage (chuncked by ajp13 */
jk_msg_buf_t *post; /* small post data storage area */
int uploadfd; /* future persistant storage id */
int recoverable; /* if exchange could be conducted on another TC */
};
/*
* Functions
*/
const char *jk_ajp_get_state(ajp_worker_t *aw, jk_logger_t *l);
int jk_ajp_get_state_code(const char *v);
int ajp_validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l, int proto);
int ajp_init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l, int proto);
int JK_METHOD ajp_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l);
int ajp_destroy(jk_worker_t **pThis, jk_logger_t *l, int proto);
int JK_METHOD ajp_done(jk_endpoint_t **e, jk_logger_t *l);
int ajp_get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l, int proto);
int ajp_connect_to_endpoint(ajp_endpoint_t * ae, jk_logger_t *l);
void ajp_close_endpoint(ajp_endpoint_t * ae, jk_logger_t *l);
void jk_ajp_pull(ajp_worker_t * aw, int locked, jk_logger_t *l);
void jk_ajp_push(ajp_worker_t * aw, int locked, jk_logger_t *l);
int ajp_connection_tcp_send_message(ajp_endpoint_t * ae,
jk_msg_buf_t *msg, jk_logger_t *l);
int ajp_connection_tcp_get_message(ajp_endpoint_t * ae,
jk_msg_buf_t *msg, jk_logger_t *l);
int JK_METHOD ajp_maintain(jk_worker_t *pThis, time_t now, int global, jk_logger_t *l);
int JK_METHOD ajp_shutdown(jk_worker_t *pThis, jk_logger_t *l);
void jk_ajp_get_cping_text(int mode, char *buf);
int jk_ajp_get_cping_mode(const char *m, int def);
int ajp_has_endpoint(jk_worker_t *pThis, jk_logger_t *l);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* JK_AJP_COMMON_H */
tomcat-connectors-1.2.48-src/native/common/ap_snprintf.c 0000644 0000000 0000002 00000105317 13623533443 021604 0 ustar root bin /* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* This code is based on, and used with the permission of, the
* SIO stdio-replacement strx_* functions by Panos Tsirigotis
* for xinetd.
*/
#define BUILD_STANDALONE
#ifndef BUILD_STANDALONE
#include "httpd.h"
#else
#include "ap_snprintf.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#ifdef WIN32
#include
#endif
typedef enum {
NO = 0, YES = 1
} boolean_e;
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif
#ifndef AP_LONGEST_LONG
#define AP_LONGEST_LONG long
#endif
#define NUL '\0'
#define WIDE_INT long
#define WIDEST_INT AP_LONGEST_LONG
typedef WIDE_INT wide_int;
typedef unsigned WIDE_INT u_wide_int;
typedef WIDEST_INT widest_int;
#ifdef __TANDEM
/* Although Tandem supports "long long" there is no unsigned variant. */
typedef unsigned long u_widest_int;
#else
typedef unsigned WIDEST_INT u_widest_int;
#endif
typedef int bool_int;
#define S_NULL "(null)"
#define S_NULL_LEN 6
#define FLOAT_DIGITS 6
#define EXPONENT_LENGTH 10
/*
* NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions
*
* XXX: this is a magic number; do not decrease it
*/
#define NUM_BUF_SIZE 512
/*
* cvt - IEEE floating point formatting routines.
* Derived from UNIX V7, Copyright(C) Caldera International Inc.
*/
/*
* ap_ecvt converts to decimal
* the number of digits is specified by ndigit
* decpt is set to the position of the decimal point
* sign is set to 0 for positive, 1 for negative
*/
#define NDIG 80
/* buf must have at least NDIG bytes */
static char *ap_cvt(double arg, int ndigits, int *decpt, int *sign, int eflag, char *buf)
{
register int r2;
double fi, fj;
register char *p, *p1;
if (ndigits >= NDIG - 1)
ndigits = NDIG - 2;
r2 = 0;
*sign = 0;
p = &buf[0];
if (arg < 0) {
*sign = 1;
arg = -arg;
}
arg = modf(arg, &fi);
p1 = &buf[NDIG];
/*
* Do integer part
*/
if (fi != 0) {
p1 = &buf[NDIG];
while (p1 > &buf[0] && fi != 0) {
fj = modf(fi / 10, &fi);
*--p1 = (int) ((fj + .03) * 10) + '0';
r2++;
}
while (p1 < &buf[NDIG])
*p++ = *p1++;
}
else if (arg > 0) {
while ((fj = arg * 10) < 1) {
arg = fj;
r2--;
}
}
p1 = &buf[ndigits];
if (eflag == 0)
p1 += r2;
*decpt = r2;
if (p1 < &buf[0]) {
buf[0] = '\0';
return (buf);
}
while (p <= p1 && p < &buf[NDIG]) {
arg *= 10;
arg = modf(arg, &fj);
*p++ = (int) fj + '0';
}
if (p1 >= &buf[NDIG]) {
buf[NDIG - 1] = '\0';
return (buf);
}
p = p1;
*p1 += 5;
while (*p1 > '9') {
*p1 = '0';
if (p1 > buf)
++ * --p1;
else {
*p1 = '1';
(*decpt)++;
if (eflag == 0) {
if (p > buf)
*p = '0';
p++;
}
}
}
*p = '\0';
return (buf);
}
static char *ap_ecvt(double arg, int ndigits, int *decpt, int *sign, char *buf)
{
return (ap_cvt(arg, ndigits, decpt, sign, 1, buf));
}
static char *ap_fcvt(double arg, int ndigits, int *decpt, int *sign, char *buf)
{
return (ap_cvt(arg, ndigits, decpt, sign, 0, buf));
}
/*
* ap_gcvt - Floating output conversion to
* minimal length string
*/
static char *ap_gcvt(double number, int ndigit, char *buf, boolean_e altform)
{
int sign, decpt;
register char *p1, *p2;
register int i;
char buf1[NDIG];
p1 = ap_ecvt(number, ndigit, &decpt, &sign, buf1);
p2 = buf;
if (sign)
*p2++ = '-';
for (i = ndigit - 1; i > 0 && p1[i] == '0'; i--)
ndigit--;
if ((decpt >= 0 && decpt - ndigit > 4)
|| (decpt < 0 && decpt < -3)) { /* use E-style */
decpt--;
*p2++ = *p1++;
*p2++ = '.';
for (i = 1; i < ndigit; i++)
*p2++ = *p1++;
*p2++ = 'e';
if (decpt < 0) {
decpt = -decpt;
*p2++ = '-';
}
else
*p2++ = '+';
if (decpt / 100 > 0)
*p2++ = decpt / 100 + '0';
if (decpt / 10 > 0)
*p2++ = (decpt % 100) / 10 + '0';
*p2++ = decpt % 10 + '0';
}
else {
if (decpt <= 0) {
if (*p1 != '0')
*p2++ = '.';
while (decpt < 0) {
decpt++;
*p2++ = '0';
}
}
for (i = 1; i <= ndigit; i++) {
*p2++ = *p1++;
if (i == decpt)
*p2++ = '.';
}
if (ndigit < decpt) {
while (ndigit++ < decpt)
*p2++ = '0';
*p2++ = '.';
}
}
if (p2[-1] == '.' && !altform)
p2--;
*p2 = '\0';
return (buf);
}
/*
* The INS_CHAR macro inserts a character in the buffer and writes
* the buffer back to disk if necessary
* It uses the char pointers sp and bep:
* sp points to the next available character in the buffer
* bep points to the end-of-buffer+1
* While using this macro, note that the nextb pointer is NOT updated.
*
* NOTE: Evaluation of the c argument should not have any side-effects
*/
#define INS_CHAR(c, sp, bep, cc) \
{ \
if (sp >= bep) { \
vbuff->curpos = sp; \
if (flush_func(vbuff)) \
return -1; \
sp = vbuff->curpos; \
bep = vbuff->endpos; \
} \
*sp++ = (c); \
cc++; \
}
#define NUM( c ) ( c - '0' )
#define STR_TO_DEC( str, num ) \
num = NUM( *str++ ) ; \
while ( ap_isdigit( *str ) ) \
{ \
num *= 10 ; \
num += NUM( *str++ ) ; \
}
/*
* This macro does zero padding so that the precision
* requirement is satisfied. The padding is done by
* adding '0's to the left of the string that is going
* to be printed. We don't allow precision to be large
* enough that we continue past the start of s.
*
* NOTE: this makes use of the magic info that s is
* always based on num_buf with a size of NUM_BUF_SIZE.
*/
#define FIX_PRECISION( adjust, precision, s, s_len ) \
if ( adjust ) { \
int p = precision < NUM_BUF_SIZE - 1 ? precision : NUM_BUF_SIZE - 1; \
while ( s_len < p ) \
{ \
*--s = '0' ; \
s_len++ ; \
} \
}
/*
* Macro that does padding. The padding is done by printing
* the character ch.
*/
#define PAD( width, len, ch ) do \
{ \
INS_CHAR( ch, sp, bep, cc ) ; \
width-- ; \
} \
while ( width > len )
/*
* Prefix the character ch to the string str
* Increase length
* Set the has_prefix flag
*/
#define PREFIX( str, length, ch ) *--str = ch ; length++ ; has_prefix = YES
/*
* Convert num to its decimal format.
* Return value:
* - a pointer to a string containing the number (no sign)
* - len contains the length of the string
* - is_negative is set to TRUE or FALSE depending on the sign
* of the number (always set to FALSE if is_unsigned is TRUE)
*
* The caller provides a buffer for the string: that is the buf_end argument
* which is a pointer to the END of the buffer + 1 (i.e. if the buffer
* is declared as buf[ 100 ], buf_end should be &buf[ 100 ])
*
* Note: we have 2 versions. One is used when we need to use quads
* (conv_10_quad), the other when we don't (conv_10). We're assuming the
* latter is faster.
*/
static char *conv_10(register wide_int num, register bool_int is_unsigned,
register bool_int *is_negative, char *buf_end,
register int *len)
{
register char *p = buf_end;
register u_wide_int magnitude;
if (is_unsigned) {
magnitude = (u_wide_int) num;
*is_negative = FALSE;
}
else {
*is_negative = (num < 0);
/*
* On a 2's complement machine, negating the most negative integer
* results in a number that cannot be represented as a signed integer.
* Here is what we do to obtain the number's magnitude:
* a. add 1 to the number
* b. negate it (becomes positive)
* c. convert it to unsigned
* d. add 1
*/
if (*is_negative) {
wide_int t = num + 1;
magnitude = ((u_wide_int) -t) + 1;
}
else
magnitude = (u_wide_int) num;
}
/*
* We use a do-while loop so that we write at least 1 digit
*/
do {
register u_wide_int new_magnitude = magnitude / 10;
*--p = (char) (magnitude - new_magnitude * 10 + '0');
magnitude = new_magnitude;
}
while (magnitude);
*len = buf_end - p;
return (p);
}
static char *conv_10_quad(widest_int num, register bool_int is_unsigned,
register bool_int *is_negative, char *buf_end,
register int *len)
{
register char *p = buf_end;
u_widest_int magnitude;
/*
* We see if we can use the faster non-quad version by checking the
* number against the largest long value it can be. If <=, we
* punt to the quicker version.
*/
if ((num <= ULONG_MAX && is_unsigned) || (num <= LONG_MAX && !is_unsigned))
return(conv_10( (wide_int)num, is_unsigned, is_negative,
buf_end, len));
if (is_unsigned) {
magnitude = (u_widest_int) num;
*is_negative = FALSE;
}
else {
*is_negative = (num < 0);
/*
* On a 2's complement machine, negating the most negative integer
* results in a number that cannot be represented as a signed integer.
* Here is what we do to obtain the number's magnitude:
* a. add 1 to the number
* b. negate it (becomes positive)
* c. convert it to unsigned
* d. add 1
*/
if (*is_negative) {
widest_int t = num + 1;
magnitude = ((u_widest_int) -t) + 1;
}
else
magnitude = (u_widest_int) num;
}
/*
* We use a do-while loop so that we write at least 1 digit
*/
do {
u_widest_int new_magnitude = magnitude / 10;
*--p = (char) (magnitude - new_magnitude * 10 + '0');
magnitude = new_magnitude;
}
while (magnitude);
*len = buf_end - p;
return (p);
}
#ifndef BUILD_STANDALONE
static char *conv_in_addr(struct in_addr *ia, char *buf_end, int *len)
{
unsigned addr = ntohl(ia->s_addr);
char *p = buf_end;
bool_int is_negative;
int sub_len;
p = conv_10((addr & 0x000000FF) , TRUE, &is_negative, p, &sub_len);
*--p = '.';
p = conv_10((addr & 0x0000FF00) >> 8, TRUE, &is_negative, p, &sub_len);
*--p = '.';
p = conv_10((addr & 0x00FF0000) >> 16, TRUE, &is_negative, p, &sub_len);
*--p = '.';
p = conv_10((addr & 0xFF000000) >> 24, TRUE, &is_negative, p, &sub_len);
*len = buf_end - p;
return (p);
}
static char *conv_sockaddr_in(struct sockaddr_in *si, char *buf_end, int *len)
{
char *p = buf_end;
bool_int is_negative;
int sub_len;
p = conv_10(ntohs(si->sin_port), TRUE, &is_negative, p, &sub_len);
*--p = ':';
p = conv_in_addr(&si->sin_addr, p, &sub_len);
*len = buf_end - p;
return (p);
}
#endif
/*
* Convert a floating point number to a string formats 'f', 'e' or 'E'.
* The result is placed in buf, and len denotes the length of the string
* The sign is returned in the is_negative argument (and is not placed
* in buf).
*/
static char *conv_fp(register char format, register double num,
boolean_e add_dp, int precision, bool_int *is_negative,
char *buf, int *len)
{
register char *s = buf;
register char *p;
int decimal_point;
char buf1[NDIG];
if (format == 'f')
p = ap_fcvt(num, precision, &decimal_point, is_negative, buf1);
else /* either e or E format */
p = ap_ecvt(num, precision + 1, &decimal_point, is_negative, buf1);
/*
* Check for Infinity and NaN
*/
if (ap_isalpha(*p)) {
*len = strlen(strcpy(buf, p));
*is_negative = FALSE;
return (buf);
}
if (format == 'f') {
if (decimal_point <= 0) {
*s++ = '0';
if (precision > 0) {
*s++ = '.';
while (decimal_point++ < 0)
*s++ = '0';
}
else if (add_dp)
*s++ = '.';
}
else {
while (decimal_point-- > 0)
*s++ = *p++;
if (precision > 0 || add_dp)
*s++ = '.';
}
}
else {
*s++ = *p++;
if (precision > 0 || add_dp)
*s++ = '.';
}
/*
* copy the rest of p, the NUL is NOT copied
*/
while (*p)
*s++ = *p++;
if (format != 'f') {
char temp[EXPONENT_LENGTH]; /* for exponent conversion */
int t_len;
bool_int exponent_is_negative;
*s++ = format; /* either e or E */
decimal_point--;
if (decimal_point != 0) {
p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative,
&temp[EXPONENT_LENGTH], &t_len);
*s++ = exponent_is_negative ? '-' : '+';
/*
* Make sure the exponent has at least 2 digits
*/
if (t_len == 1)
*s++ = '0';
while (t_len--)
*s++ = *p++;
}
else {
*s++ = '+';
*s++ = '0';
*s++ = '0';
}
}
*len = s - buf;
return (buf);
}
/*
* Convert num to a base X number where X is a power of 2. nbits determines X.
* For example, if nbits is 3, we do base 8 conversion
* Return value:
* a pointer to a string containing the number
*
* The caller provides a buffer for the string: that is the buf_end argument
* which is a pointer to the END of the buffer + 1 (i.e. if the buffer
* is declared as buf[ 100 ], buf_end should be &buf[ 100 ])
*
* As with conv_10, we have a faster version which is used when
* the number isn't quad size.
*/
static char *conv_p2(register u_wide_int num, register int nbits,
char format, char *buf_end, register int *len)
{
register int mask = (1 << nbits) - 1;
register char *p = buf_end;
static const char low_digits[] = "0123456789abcdef";
static const char upper_digits[] = "0123456789ABCDEF";
register const char *digits = (format == 'X') ? upper_digits : low_digits;
do {
*--p = digits[num & mask];
num >>= nbits;
}
while (num);
*len = buf_end - p;
return (p);
}
static char *conv_p2_quad(u_widest_int num, register int nbits,
char format, char *buf_end, register int *len)
{
register int mask = (1 << nbits) - 1;
register char *p = buf_end;
static const char low_digits[] = "0123456789abcdef";
static const char upper_digits[] = "0123456789ABCDEF";
register const char *digits = (format == 'X') ? upper_digits : low_digits;
if (num <= ULONG_MAX)
return(conv_p2( (u_wide_int)num, nbits, format, buf_end, len));
do {
*--p = digits[num & mask];
num >>= nbits;
}
while (num);
*len = buf_end - p;
return (p);
}
/*
* Do format conversion placing the output in buffer
*/
API_EXPORT(int) ap_vformatter(int (*flush_func)(ap_vformatter_buff *),
ap_vformatter_buff *vbuff, const char *fmt, va_list ap)
{
register char *sp;
register char *bep;
register int cc = 0;
register int i;
register char *s = NULL;
char *q;
int s_len;
register int min_width = 0;
int precision = 0;
enum {
LEFT, RIGHT
} adjust;
char pad_char;
char prefix_char;
double fp_num;
widest_int i_quad = (widest_int) 0;
u_widest_int ui_quad;
wide_int i_num = (wide_int) 0;
u_wide_int ui_num;
char num_buf[NUM_BUF_SIZE];
char char_buf[2]; /* for printing %% and % */
enum var_type_enum {
IS_QUAD, IS_LONG, IS_SHORT, IS_INT
};
enum var_type_enum var_type = IS_INT;
/*
* Flag variables
*/
boolean_e alternate_form;
boolean_e print_sign;
boolean_e print_blank;
boolean_e adjust_precision;
boolean_e adjust_width;
bool_int is_negative;
sp = vbuff->curpos;
bep = vbuff->endpos;
while (*fmt) {
if (*fmt != '%') {
INS_CHAR(*fmt, sp, bep, cc);
}
else {
/*
* Default variable settings
*/
adjust = RIGHT;
alternate_form = print_sign = print_blank = NO;
pad_char = ' ';
prefix_char = NUL;
fmt++;
/*
* Try to avoid checking for flags, width or precision
*/
if (!ap_islower(*fmt)) {
/*
* Recognize flags: -, #, BLANK, +
*/
for (;; fmt++) {
if (*fmt == '-')
adjust = LEFT;
else if (*fmt == '+')
print_sign = YES;
else if (*fmt == '#')
alternate_form = YES;
else if (*fmt == ' ')
print_blank = YES;
else if (*fmt == '0')
pad_char = '0';
else
break;
}
/*
* Check if a width was specified
*/
if (ap_isdigit(*fmt)) {
STR_TO_DEC(fmt, min_width);
adjust_width = YES;
}
else if (*fmt == '*') {
min_width = va_arg(ap, int);
fmt++;
adjust_width = YES;
if (min_width < 0) {
adjust = LEFT;
min_width = -min_width;
}
}
else
adjust_width = NO;
/*
* Check if a precision was specified
*/
if (*fmt == '.') {
adjust_precision = YES;
fmt++;
if (ap_isdigit(*fmt)) {
STR_TO_DEC(fmt, precision);
}
else if (*fmt == '*') {
precision = va_arg(ap, int);
fmt++;
if (precision < 0)
precision = 0;
}
else
precision = 0;
}
else
adjust_precision = NO;
}
else
adjust_precision = adjust_width = NO;
/*
* Modifier check
*/
if (*fmt == 'q') {
var_type = IS_QUAD;
fmt++;
}
else if (*fmt == 'l') {
var_type = IS_LONG;
fmt++;
}
else if (*fmt == 'h') {
var_type = IS_SHORT;
fmt++;
}
else {
var_type = IS_INT;
}
/*
* Argument extraction and printing.
* First we determine the argument type.
* Then, we convert the argument to a string.
* On exit from the switch, s points to the string that
* must be printed, s_len has the length of the string
* The precision requirements, if any, are reflected in s_len.
*
* NOTE: pad_char may be set to '0' because of the 0 flag.
* It is reset to ' ' by non-numeric formats
*/
switch (*fmt) {
case 'u':
if (var_type == IS_QUAD) {
i_quad = va_arg(ap, u_widest_int);
s = conv_10_quad(i_quad, 1, &is_negative,
&num_buf[NUM_BUF_SIZE], &s_len);
}
else {
if (var_type == IS_LONG)
i_num = (wide_int) va_arg(ap, u_wide_int);
else if (var_type == IS_SHORT)
i_num = (wide_int) (unsigned short) va_arg(ap, unsigned int);
else
i_num = (wide_int) va_arg(ap, unsigned int);
s = conv_10(i_num, 1, &is_negative,
&num_buf[NUM_BUF_SIZE], &s_len);
}
FIX_PRECISION(adjust_precision, precision, s, s_len);
break;
case 'd':
case 'i':
if (var_type == IS_QUAD) {
i_quad = va_arg(ap, widest_int);
s = conv_10_quad(i_quad, 0, &is_negative,
&num_buf[NUM_BUF_SIZE], &s_len);
}
else {
if (var_type == IS_LONG)
i_num = (wide_int) va_arg(ap, wide_int);
else if (var_type == IS_SHORT)
i_num = (wide_int) (short) va_arg(ap, int);
else
i_num = (wide_int) va_arg(ap, int);
s = conv_10(i_num, 0, &is_negative,
&num_buf[NUM_BUF_SIZE], &s_len);
}
FIX_PRECISION(adjust_precision, precision, s, s_len);
if (is_negative)
prefix_char = '-';
else if (print_sign)
prefix_char = '+';
else if (print_blank)
prefix_char = ' ';
break;
case 'o':
if (var_type == IS_QUAD) {
ui_quad = va_arg(ap, u_widest_int);
s = conv_p2_quad(ui_quad, 3, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
}
else {
if (var_type == IS_LONG)
ui_num = (u_wide_int) va_arg(ap, u_wide_int);
else if (var_type == IS_SHORT)
ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
else
ui_num = (u_wide_int) va_arg(ap, unsigned int);
s = conv_p2(ui_num, 3, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
}
FIX_PRECISION(adjust_precision, precision, s, s_len);
if (alternate_form && *s != '0') {
*--s = '0';
s_len++;
}
break;
case 'x':
case 'X':
if (var_type == IS_QUAD) {
ui_quad = va_arg(ap, u_widest_int);
s = conv_p2_quad(ui_quad, 4, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
}
else {
if (var_type == IS_LONG)
ui_num = (u_wide_int) va_arg(ap, u_wide_int);
else if (var_type == IS_SHORT)
ui_num = (u_wide_int) (unsigned short) va_arg(ap, unsigned int);
else
ui_num = (u_wide_int) va_arg(ap, unsigned int);
s = conv_p2(ui_num, 4, *fmt,
&num_buf[NUM_BUF_SIZE], &s_len);
}
FIX_PRECISION(adjust_precision, precision, s, s_len);
if (alternate_form && i_num != 0) {
*--s = *fmt; /* 'x' or 'X' */
*--s = '0';
s_len += 2;
}
break;
case 's':
s = va_arg(ap, char *);
if (s != NULL) {
s_len = strlen(s);
if (adjust_precision && precision < s_len)
s_len = precision;
}
else {
s = S_NULL;
s_len = S_NULL_LEN;
}
pad_char = ' ';
break;
case 'f':
case 'e':
case 'E':
fp_num = va_arg(ap, double);
/*
* * We use &num_buf[ 1 ], so that we have room for the sign
*/
#ifdef HAVE_ISNAN
if (isnan(fp_num)) {
s = "nan";
s_len = 3;
}
else
#endif
#ifdef HAVE_ISINF
if (isinf(fp_num)) {
s = "inf";
s_len = 3;
}
else
#endif
{
s = conv_fp(*fmt, fp_num, alternate_form,
(adjust_precision == NO) ? FLOAT_DIGITS : precision,
&is_negative, &num_buf[1], &s_len);
if (is_negative)
prefix_char = '-';
else if (print_sign)
prefix_char = '+';
else if (print_blank)
prefix_char = ' ';
}
break;
case 'g':
case 'G':
if (adjust_precision == NO)
precision = FLOAT_DIGITS;
else if (precision == 0)
precision = 1;
/*
* * We use &num_buf[ 1 ], so that we have room for the sign
*/
s = ap_gcvt(va_arg(ap, double), precision, &num_buf[1],
alternate_form);
if (*s == '-')
prefix_char = *s++;
else if (print_sign)
prefix_char = '+';
else if (print_blank)
prefix_char = ' ';
s_len = strlen(s);
if (alternate_form && (q = strchr(s, '.')) == NULL) {
s[s_len++] = '.';
s[s_len] = '\0'; /* delimit for following strchr() */
}
if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL)
*q = 'E';
break;
case 'c':
char_buf[0] = (char) (va_arg(ap, int));
s = &char_buf[0];
s_len = 1;
pad_char = ' ';
break;
case '%':
char_buf[0] = '%';
s = &char_buf[0];
s_len = 1;
pad_char = ' ';
break;
case 'n':
if (var_type == IS_QUAD)
*(va_arg(ap, widest_int *)) = cc;
else if (var_type == IS_LONG)
*(va_arg(ap, long *)) = cc;
else if (var_type == IS_SHORT)
*(va_arg(ap, short *)) = cc;
else
*(va_arg(ap, int *)) = cc;
break;
/*
* This is where we extend the printf format, with a second
* type specifier
*/
case 'p':
switch(*++fmt) {
/*
* If the pointer size is equal to or smaller than the size
* of the largest unsigned int, we convert the pointer to a
* hex number, otherwise we print "%p" to indicate that we
* don't handle "%p".
*/
case 'p':
#ifdef AP_VOID_P_IS_QUAD
if (sizeof(void *) <= sizeof(u_widest_int)) {
ui_quad = (u_widest_int) va_arg(ap, void *);
s = conv_p2_quad(ui_quad, 4, 'x',
&num_buf[NUM_BUF_SIZE], &s_len);
}
#else
if (sizeof(void *) <= sizeof(u_wide_int)) {
ui_num = (u_wide_int) va_arg(ap, void *);
s = conv_p2(ui_num, 4, 'x',
&num_buf[NUM_BUF_SIZE], &s_len);
}
#endif
else {
s = "%p";
s_len = 2;
prefix_char = NUL;
}
pad_char = ' ';
break;
#ifndef BUILD_STANDALONE
/* print a struct sockaddr_in as a.b.c.d:port */
case 'I':
{
struct sockaddr_in *si;
si = va_arg(ap, struct sockaddr_in *);
if (si != NULL) {
s = conv_sockaddr_in(si, &num_buf[NUM_BUF_SIZE], &s_len);
if (adjust_precision && precision < s_len)
s_len = precision;
}
else {
s = S_NULL;
s_len = S_NULL_LEN;
}
pad_char = ' ';
}
break;
/* print a struct in_addr as a.b.c.d */
case 'A':
{
struct in_addr *ia;
ia = va_arg(ap, struct in_addr *);
if (ia != NULL) {
s = conv_in_addr(ia, &num_buf[NUM_BUF_SIZE], &s_len);
if (adjust_precision && precision < s_len)
s_len = precision;
}
else {
s = S_NULL;
s_len = S_NULL_LEN;
}
pad_char = ' ';
}
break;
#endif
case NUL:
/* if %p ends the string, oh well ignore it */
continue;
default:
s = "bogus %p";
s_len = 8;
prefix_char = NUL;
break;
}
break;
case NUL:
/*
* The last character of the format string was %.
* We ignore it.
*/
continue;
/*
* The default case is for unrecognized %'s.
* We print % to help the user identify what
* option is not understood.
* This is also useful in case the user wants to pass
* the output of format_converter to another function
* that understands some other % (like syslog).
* Note that we can't point s inside fmt because the
* unknown could be preceded by width etc.
*/
default:
char_buf[0] = '%';
char_buf[1] = *fmt;
s = char_buf;
s_len = 2;
pad_char = ' ';
break;
}
if (prefix_char != NUL && s != S_NULL && s != char_buf) {
*--s = prefix_char;
s_len++;
}
if (adjust_width && adjust == RIGHT && min_width > s_len) {
if (pad_char == '0' && prefix_char != NUL) {
INS_CHAR(*s, sp, bep, cc);
s++;
s_len--;
min_width--;
}
PAD(min_width, s_len, pad_char);
}
/*
* Print the string s.
*/
for (i = s_len; i != 0; i--) {
INS_CHAR(*s, sp, bep, cc);
s++;
}
if (adjust_width && adjust == LEFT && min_width > s_len)
PAD(min_width, s_len, pad_char);
}
fmt++;
}
vbuff->curpos = sp;
return cc;
}
static int snprintf_flush(ap_vformatter_buff *vbuff)
{
/* if the buffer fills we have to abort immediately, there is no way
* to "flush" an ap_snprintf... there's nowhere to flush it to.
*/
return -1;
}
API_EXPORT_NONSTD(int) ap_snprintf(char *buf, size_t len, const char *format,...)
{
int cc;
va_list ap;
ap_vformatter_buff vbuff;
if (len == 0)
return 0;
/* save one byte for nul terminator */
vbuff.curpos = buf;
vbuff.endpos = buf + len - 1;
va_start(ap, format);
cc = ap_vformatter(snprintf_flush, &vbuff, format, ap);
va_end(ap);
*vbuff.curpos = '\0';
return (cc == -1) ? len : cc;
}
API_EXPORT(int) ap_vsnprintf(char *buf, size_t len, const char *format,
va_list ap)
{
int cc;
ap_vformatter_buff vbuff;
if (len == 0)
return 0;
/* save one byte for nul terminator */
vbuff.curpos = buf;
vbuff.endpos = buf + len - 1;
cc = ap_vformatter(snprintf_flush, &vbuff, format, ap);
*vbuff.curpos = '\0';
return (cc == -1) ? len : cc;
}
tomcat-connectors-1.2.48-src/native/common/jk.rc 0000644 0000000 0000002 00000005537 13623533443 020052 0 ustar root bin /* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include "jk_version.h"
#define ASF_COPYRIGHT "Licensed to the Apache Software Foundation " \
"(ASF) under one or more contributor license " \
"agreements. See the NOTICE file distributed " \
"with this work for additional information " \
"regarding copyright ownership."
#define ASF_LICENSE "The ASF licenses this file to You under the " \
"Apache License, Version 2.0 (the ""License""); " \
"you may not use this file except in compliance " \
"with the License. You may obtain a copy of " \
"the License at\r\n\r\n" \
"http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n" \
"Unless required by applicable law or agreed to in " \
"writing, software distributed under the License is " \
"distributed on an ""AS IS"" BASIS, WITHOUT " \
"WARRANTIES OR CONDITIONS OF ANY KIND, either " \
"express or implied. See the License for the " \
"specific language governing permissions and " \
"limitations under the License."
1 VERSIONINFO
FILEVERSION JK_VERSIONCSV
PRODUCTVERSION JK_VERSIONCSV
FILEFLAGSMASK 0x3fL
#if defined(_DEBUG)
FILEFLAGS 0x01L
#else
FILEFLAGS 0x00L
#endif
FILEOS 0x40004L
FILETYPE 0x1L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "Comments", ASF_LICENSE "\0"
VALUE "CompanyName", "Apache Software Foundation\0"
VALUE "FileDescription", "Apache Tomcat Connector\0"
VALUE "FileVersion", JK_VERSTRING "\0"
VALUE "InternalName", PACKAGE "\0"
VALUE "LegalCopyright", ASF_COPYRIGHT "\0"
VALUE "OriginalFilename", PACKAGE "." JK_DLL_SUFFIX "\0"
VALUE "ProductName", "Apache Tomcat " PACKAGE " Connector\0"
VALUE "ProductVersion", JK_VERSTRING "\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
tomcat-connectors-1.2.48-src/native/common/jk_connect.c 0000644 0000000 0000002 00000131364 13623533443 021377 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Description: Socket/Naming manipulation functions
* Based on: Various Jserv files
*/
/**
* @package jk_connect
* @author Gal Shachor
* @author Mladen Turk
*/
#include "jk_connect.h"
#include "jk_util.h"
#ifdef HAVE_APR
#include "apr_network_io.h"
#include "apr_errno.h"
#include "apr_general.h"
#include "apr_pools.h"
static apr_pool_t *jk_apr_pool = NULL;
#endif
#ifdef HAVE_SYS_FILIO_H
/* FIONREAD on Solaris et al. */
#include
#endif
#ifdef HAVE_POLL_H
/* Use poll instead select */
#include
#endif
#if defined(WIN32)
#define JK_IS_SOCKET_ERROR(x) ((x) == SOCKET_ERROR)
#define JK_GET_SOCKET_ERRNO() errno = WSAGetLastError() - WSABASEERR
#else
#define JK_IS_SOCKET_ERROR(x) ((x) == -1)
#define JK_GET_SOCKET_ERRNO() ((void)0)
#endif /* WIN32 */
#ifndef INET6_ADDRSTRLEN
/* Maximum size of an IPv6 address in ASCII */
#define INET6_ADDRSTRLEN 46
#endif
/* 2 IPv6 adresses of length (INET6_ADDRSTRLEN-1)
* each suffixed with a ":" and a port (5 digits)
* plus " -> " plus terminating "\0"
*/
#define DUMP_SINFO_BUF_SZ (2 * (INET6_ADDRSTRLEN - 1 + 1 + 5) + 4 + 1)
#ifndef IN6ADDRSZ
#define IN6ADDRSZ 16
#endif
#ifndef INT16SZ
#define INT16SZ sizeof(short)
#endif
#if !defined(EAFNOSUPPORT) && defined(WSAEAFNOSUPPORT)
#define EAFNOSUPPORT WSAEAFNOSUPPORT
#endif
/** Set socket to blocking
* @param sd socket to manipulate
* @return errno: fcntl returns -1 (!WIN32)
* pseudo errno: ioctlsocket returns SOCKET_ERROR (WIN32)
* 0: success
*/
static int soblock(jk_sock_t sd)
{
/* BeOS uses setsockopt at present for non blocking... */
#if defined (WIN32)
u_long on = 0;
if (JK_IS_SOCKET_ERROR(ioctlsocket(sd, FIONBIO, &on))) {
JK_GET_SOCKET_ERRNO();
return errno;
}
#else
int fd_flags;
fd_flags = fcntl(sd, F_GETFL, 0);
#if defined(O_NONBLOCK)
fd_flags &= ~O_NONBLOCK;
#elif defined(O_NDELAY)
fd_flags &= ~O_NDELAY;
#elif defined(FNDELAY)
fd_flags &= ~FNDELAY;
#else
#error Please teach JK how to make sockets blocking on your platform.
#endif
if (fcntl(sd, F_SETFL, fd_flags) == -1) {
return errno;
}
#endif /* WIN32 */
return 0;
}
/** Set socket to non-blocking
* @param sd socket to manipulate
* @return errno: fcntl returns -1 (!WIN32)
* pseudo errno: ioctlsocket returns SOCKET_ERROR (WIN32)
* 0: success
*/
static int sononblock(jk_sock_t sd)
{
#if defined (WIN32)
u_long on = 1;
if (JK_IS_SOCKET_ERROR(ioctlsocket(sd, FIONBIO, &on))) {
JK_GET_SOCKET_ERRNO();
return errno;
}
#else
int fd_flags;
fd_flags = fcntl(sd, F_GETFL, 0);
#if defined(O_NONBLOCK)
fd_flags |= O_NONBLOCK;
#elif defined(O_NDELAY)
fd_flags |= O_NDELAY;
#elif defined(FNDELAY)
fd_flags |= FNDELAY;
#else
#error Please teach JK how to make sockets non-blocking on your platform.
#endif
if (fcntl(sd, F_SETFL, fd_flags) == -1) {
return errno;
}
#endif /* WIN32 */
return 0;
}
#if defined (WIN32)
/* WIN32 implementation */
/** Non-blocking socket connect
* @param sd socket to connect
* @param addr address to connect to
* @param source optional source address
* @param timeout connect timeout in seconds
* (<=0: no timeout=blocking)
* @param l logger
* @return -1: some kind of error occured
* SOCKET_ERROR: no timeout given and error
* during blocking connect
* 0: success
*/
static int nb_connect(jk_sock_t sd, jk_sockaddr_t *addr, jk_sockaddr_t *source,
int timeout, jk_logger_t *l)
{
int rc;
char buf[64];
JK_TRACE_ENTER(l);
if (source != NULL) {
if (bind(sd, (const struct sockaddr *)&source->sa.sin, source->salen)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"error during source bind on socket %d [%s] (errno=%d)",
sd, jk_dump_hinfo(source, buf, sizeof(buf)), errno);
}
}
if (timeout <= 0) {
rc = connect(sd, (const struct sockaddr *)&addr->sa.sin, addr->salen);
JK_TRACE_EXIT(l);
return rc;
}
if ((rc = sononblock(sd))) {
JK_TRACE_EXIT(l);
return -1;
}
if (JK_IS_SOCKET_ERROR(connect(sd, (const struct sockaddr *)&addr->sa.sin, addr->salen))) {
struct timeval tv;
fd_set wfdset, efdset;
if ((rc = WSAGetLastError()) != WSAEWOULDBLOCK) {
soblock(sd);
WSASetLastError(rc);
JK_TRACE_EXIT(l);
return -1;
}
/* wait for the connect to complete or timeout */
FD_ZERO(&wfdset);
FD_SET(sd, &wfdset);
FD_ZERO(&efdset);
FD_SET(sd, &efdset);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
rc = select((int)sd + 1, NULL, &wfdset, &efdset, &tv);
if (JK_IS_SOCKET_ERROR(rc) || rc == 0) {
rc = WSAGetLastError();
soblock(sd);
WSASetLastError(rc);
JK_TRACE_EXIT(l);
return -1;
}
/* Evaluate the efdset */
if (FD_ISSET(sd, &efdset)) {
/* The connect failed. */
int rclen = (int)sizeof(rc);
if (getsockopt(sd, SOL_SOCKET, SO_ERROR, (char*) &rc, &rclen))
rc = 0;
soblock(sd);
if (rc)
WSASetLastError(rc);
JK_TRACE_EXIT(l);
return -1;
}
}
soblock(sd);
JK_TRACE_EXIT(l);
return 0;
}
#elif defined(HAVE_POLL_H)
/* POSIX implementation using poll(2) */
/** Non-blocking socket connect
* @param sd socket to connect
* @param addr address to connect to
* @param source optional source address
* @param timeout connect timeout in seconds
* (<=0: no timeout=blocking)
* @param l logger
* @return -1: some kind of error occured
* 0: success
*/
static int nb_connect(jk_sock_t sd, jk_sockaddr_t *addr, jk_sockaddr_t *source,
int timeout, jk_logger_t *l) {
int rc = 0;
char buf[64];
JK_TRACE_ENTER(l);
if (source != NULL) {
if (bind(sd, (const struct sockaddr *)&source->sa.sin, source->salen)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"error during source bind on socket %d [%s] (errno=%d)", sd,
jk_dump_hinfo(source, buf, sizeof(buf)), errno);
}
}
if (timeout > 0) {
if (sononblock(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
}
do {
rc = connect(sd, (const struct sockaddr *)&addr->sa.sin, addr->salen);
} while (rc == -1 && errno == EINTR);
if ((rc == -1) && (errno == EINPROGRESS || errno == EALREADY)
&& (timeout > 0)) {
struct pollfd pfd;
socklen_t rclen = (socklen_t)sizeof(rc);
pfd.fd = sd;
pfd.events = POLLOUT;
rc = poll(&pfd, 1, timeout);
if (rc <= 0) {
/* Save errno */
int err = errno;
soblock(sd);
errno = err;
JK_TRACE_EXIT(l);
return -1;
}
rc = 0;
#ifdef SO_ERROR
if (getsockopt(sd, SOL_SOCKET, SO_ERROR,
(char *)&rc, &rclen) < 0 || rc) {
if (rc)
errno = rc;
rc = -1;
}
#endif
}
soblock(sd);
JK_TRACE_EXIT(l);
return rc;
}
#else
/* POSIX implementation using select(2) */
/** Non-blocking socket connect
* @param sd socket to connect
* @param addr address to connect to
* @param source optional source address
* @param timeout connect timeout in seconds
* (<=0: no timeout=blocking)
* @param l logger
* @return -1: some kind of error occured
* 0: success
*/
static int nb_connect(jk_sock_t sd, jk_sockaddr_t *addr, jk_sockaddr_t *source,
int timeout, jk_logger_t *l)
{
int rc = 0;
char buf[64];
JK_TRACE_ENTER(l);
if (source != NULL) {
if (bind(sd, (const struct sockaddr *)&source->sa.sin, source->salen)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"error during source bind on socket %d [%s] (errno=%d)",
sd, jk_dump_hinfo(source, buf, sizeof(buf)), errno);
}
}
if (timeout > 0) {
if (sononblock(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
}
do {
rc = connect(sd, (const struct sockaddr *)&addr->sa.sin, addr->salen);
} while (rc == -1 && errno == EINTR);
if ((rc == -1) && (errno == EINPROGRESS || errno == EALREADY)
&& (timeout > 0)) {
fd_set wfdset;
struct timeval tv;
socklen_t rclen = (socklen_t)sizeof(rc);
FD_ZERO(&wfdset);
FD_SET(sd, &wfdset);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
rc = select(sd + 1, NULL, &wfdset, NULL, &tv);
if (rc <= 0) {
/* Save errno */
int err = errno;
soblock(sd);
errno = err;
JK_TRACE_EXIT(l);
return -1;
}
rc = 0;
#ifdef SO_ERROR
if (!FD_ISSET(sd, &wfdset) ||
(getsockopt(sd, SOL_SOCKET, SO_ERROR,
(char *)&rc, &rclen) < 0) || rc) {
if (rc)
errno = rc;
rc = -1;
}
#endif /* SO_ERROR */
}
/* Not sure we can be already connected */
if (rc == -1 && errno == EISCONN)
rc = 0;
soblock(sd);
JK_TRACE_EXIT(l);
return rc;
}
#endif
/** Clone a jk_sockaddr_t
* @param out The source structure
* @param in The target structure
*/
void jk_clone_sockaddr(jk_sockaddr_t *out, jk_sockaddr_t *in)
{
memcpy(out, in, sizeof(*in));
/* The ipaddr_ptr member points to memory inside the struct.
* Do not copy the pointer but use the same offset relative
* to the struct start
*/
out->ipaddr_ptr = (char *)out + ((char *)in->ipaddr_ptr - (char *)in);
}
/** Resolve the host IP
* @param host host or ip address
* @param port port
* @param rc return value pointer
* @param l logger
* @return JK_FALSE: some kind of error occured
* JK_TRUE: success
*/
int jk_resolve(const char *host, int port, jk_sockaddr_t *saddr,
void *pool, int prefer_ipv6, jk_logger_t *l)
{
int family = JK_INET;
struct in_addr iaddr;
JK_TRACE_ENTER(l);
memset(saddr, 0, sizeof(jk_sockaddr_t));
if (*host >= '0' && *host <= '9' && strspn(host, "0123456789.") == strlen(host)) {
/* If we found only digits we use inet_addr() */
iaddr.s_addr = jk_inet_addr(host);
memcpy(&(saddr->sa.sin.sin_addr), &iaddr, sizeof(struct in_addr));
}
else {
#ifdef HAVE_APR
apr_sockaddr_t *remote_sa, *temp_sa;
if (!jk_apr_pool) {
if (apr_pool_create(&jk_apr_pool, (apr_pool_t *)pool) != APR_SUCCESS) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
}
apr_pool_clear(jk_apr_pool);
if (apr_sockaddr_info_get(&remote_sa, host, APR_UNSPEC, (apr_port_t)port,
0, jk_apr_pool) != APR_SUCCESS) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
/* Check if we have multiple address matches
*/
if (remote_sa->next) {
/* Since we are only handling JK_INET (IPV4) address (in_addr_t) */
/* make sure we find one of those. */
temp_sa = remote_sa;
#if APR_HAVE_IPV6
if (prefer_ipv6) {
while ((NULL != temp_sa) && (APR_INET6 != temp_sa->family))
temp_sa = temp_sa->next;
}
#endif
if (NULL != temp_sa) {
remote_sa = temp_sa;
}
else {
while ((NULL != temp_sa) && (APR_INET != temp_sa->family))
temp_sa = temp_sa->next;
#if APR_HAVE_IPV6
if (NULL == temp_sa) {
temp_sa = remote_sa;
while ((NULL != temp_sa) && (APR_INET6 != temp_sa->family))
temp_sa = temp_sa->next;
}
#endif
}
/* if temp_sa is set, we have a valid address otherwise, just return */
if (NULL != temp_sa) {
remote_sa = temp_sa;
}
else {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
}
if (remote_sa->family == APR_INET) {
saddr->sa.sin = remote_sa->sa.sin;
family = JK_INET;
}
#if APR_HAVE_IPV6
else {
saddr->sa.sin6 = remote_sa->sa.sin6;
family = JK_INET6;
}
#endif
#else /* HAVE_APR */
/* Without APR go the classic way.
*/
#if defined(HAVE_GETADDRINFO)
/* TODO:
* 1. Check for numeric IPV6 addresses
* 2. Do we need to set service name for getaddrinfo?
*/
struct addrinfo hints, *ai_list, *ai = NULL;
int error;
char pbuf[12];
char *pbufptr = NULL;
memset(&hints, 0, sizeof(hints));
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
#if JK_HAVE_IPV6
if (strchr(host, ':')) {
/* If host name contains colon this must be IPV6 address.
* Set prefer_ipv6 flag in this case if it wasn't set already
*/
prefer_ipv6 = 1;
}
if (prefer_ipv6)
hints.ai_family = JK_INET6;
else
#endif
hints.ai_family = JK_INET;
if (port > 0) {
snprintf(pbuf, sizeof(pbuf), "%d", port);
pbufptr = pbuf;
}
error = getaddrinfo(host, pbufptr, &hints, &ai_list);
#if JK_HAVE_IPV6
/* XXX:
* Is the check for EAI_FAMILY/WSAEAFNOSUPPORT correct
* way to retry the IPv4 address?
*/
if (error == EAI_FAMILY && prefer_ipv6) {
hints.ai_family = JK_INET;
error = getaddrinfo(host, pbufptr, &hints, &ai_list);
}
#endif
if (error) {
JK_TRACE_EXIT(l);
errno = error;
return JK_FALSE;
}
#if JK_HAVE_IPV6
if (prefer_ipv6) {
ai = ai_list;
while (ai) {
if (ai->ai_family == JK_INET6) {
/* ignore elements without required address info */
if((ai->ai_addr != NULL) && (ai->ai_addrlen > 0)) {
family = JK_INET6;
break;
}
}
ai = ai->ai_next;
}
}
#endif
if (ai == NULL) {
ai = ai_list;
while (ai) {
if (ai->ai_family == JK_INET) {
/* ignore elements without required address info */
if((ai->ai_addr != NULL) && (ai->ai_addrlen > 0)) {
family = JK_INET;
break;
}
}
ai = ai->ai_next;
}
}
if (ai == NULL) {
/* No address found
* XXX: Use better error code?
*/
freeaddrinfo(ai_list);
JK_TRACE_EXIT(l);
errno = ENOENT;
return JK_FALSE;
}
memcpy(&(saddr->sa), ai->ai_addr, ai->ai_addrlen);
freeaddrinfo(ai_list);
#else /* HAVE_GETADDRINFO */
struct hostent *hoste;
/* XXX : WARNING : We should really use gethostbyname_r in multi-threaded env */
/* Fortunatly when APR is available, ie under Apache 2.0, we use it */
hoste = gethostbyname(host);
if (!hoste) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
iaddr = *((struct in_addr *)hoste->h_addr_list[0]);
memcpy(&(saddr->sa.sin.sin_addr), &iaddr, sizeof(struct in_addr));
#endif /* HAVE_GETADDRINFO */
#endif /* HAVE_APR */
}
if (family == JK_INET) {
saddr->ipaddr_ptr = &(saddr->sa.sin.sin_addr);
saddr->ipaddr_len = (int)sizeof(struct in_addr);
saddr->salen = (int)sizeof(struct sockaddr_in);
}
#if JK_HAVE_IPV6
else {
saddr->ipaddr_ptr = &(saddr->sa.sin6.sin6_addr);
saddr->ipaddr_len = (int)sizeof(struct in6_addr);
saddr->salen = (int)sizeof(struct sockaddr_in6);
}
#endif
saddr->sa.sin.sin_family = family;
/* XXX IPv6: assumes sin_port and sin6_port at same offset */
saddr->sa.sin.sin_port = htons(port);
saddr->port = port;
saddr->family = family;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
/** Connect to Tomcat
* @param addr address to connect to
* @param keepalive should we set SO_KEEPALIVE (if !=0)
* @param timeout connect timeout in seconds
* (<=0: no timeout=blocking)
* @param sock_buf size of send and recv buffer
* (<=0: use default)
* @param l logger
* @return JK_INVALID_SOCKET: some kind of error occured
* created socket: success
* @remark Cares about errno
*/
jk_sock_t jk_open_socket(jk_sockaddr_t *addr, jk_sockaddr_t *source,
int keepalive,
int timeout, int connect_timeout,
int sock_buf, jk_logger_t *l)
{
char buf[DUMP_SINFO_BUF_SZ];
jk_sock_t sd;
int set = 1;
int ret = 0;
int flags = 0;
#ifdef SO_LINGER
struct linger li;
#endif
JK_TRACE_ENTER(l);
errno = 0;
#if defined(SOCK_CLOEXEC) && defined(USE_SOCK_CLOEXEC)
flags |= SOCK_CLOEXEC;
#endif
sd = socket(addr->family, SOCK_STREAM | flags, 0);
if (!IS_VALID_SOCKET(sd)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"socket() failed (errno=%d)", errno);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#if defined(FD_CLOEXEC) && !defined(USE_SOCK_CLOEXEC)
if ((flags = fcntl(sd, F_GETFD)) == -1) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"fcntl() failed (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
flags |= FD_CLOEXEC;
if (fcntl(sd, F_SETFD, flags) == -1) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"fcntl() failed (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
/* Disable Nagle algorithm */
if (setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (const char*)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting TCP_NODELAY (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket TCP_NODELAY set to On");
if (keepalive) {
#if defined(WIN32)
DWORD dw;
struct tcp_keepalive ka = { 0 }, ks = { 0 };
if (timeout)
ka.keepalivetime = timeout * 10000;
else
ka.keepalivetime = 60 * 10000; /* 10 minutes */
ka.keepaliveinterval = 1000;
ka.onoff = 1;
if (WSAIoctl(sd, SIO_KEEPALIVE_VALS, &ka, sizeof(ka),
&ks, sizeof(ks), &dw, NULL, NULL)) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SIO_KEEPALIVE_VALS (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_KEEPALIVE set to %d seconds",
ka.keepalivetime / 1000);
#else
set = 1;
if (setsockopt(sd, SOL_SOCKET, SO_KEEPALIVE, (const char*)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_KEEPALIVE (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_KEEPALIVE set to On");
#endif
}
if (sock_buf > 0) {
set = sock_buf;
/* Set socket send buffer size */
if (setsockopt(sd, SOL_SOCKET, SO_SNDBUF, (const char*)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_SNDBUF (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
set = sock_buf;
/* Set socket receive buffer size */
if (setsockopt(sd, SOL_SOCKET, SO_RCVBUF, (const char*)&set,
sizeof(set))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_RCVBUF (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"socket SO_SNDBUF and SO_RCVBUF set to %d",
sock_buf);
}
if (timeout > 0) {
#if defined(WIN32)
int tmout = timeout * 1000;
setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO,
(const char *) &tmout, sizeof(int));
setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO,
(const char *) &tmout, sizeof(int));
JK_GET_SOCKET_ERRNO();
#elif defined(SO_RCVTIMEO) && defined(USE_SO_RCVTIMEO) && defined(SO_SNDTIMEO) && defined(USE_SO_SNDTIMEO)
struct timeval tv;
tv.tv_sec = timeout;
tv.tv_usec = 0;
setsockopt(sd, SOL_SOCKET, SO_RCVTIMEO,
(const void *) &tv, sizeof(tv));
setsockopt(sd, SOL_SOCKET, SO_SNDTIMEO,
(const void *) &tv, sizeof(tv));
#endif
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"timeout %d set for socket=%d",
timeout, sd);
}
#ifdef SO_NOSIGPIPE
/* The preferred method on Mac OS X (10.2 and later) to prevent SIGPIPEs when
* sending data to a dead peer. Possibly also existing and in use on other BSD
* systems?
*/
set = 1;
if (setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, (const char *)&set,
sizeof(int))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_NOSIGPIPE (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
#ifdef SO_LINGER
/* Make hard closesocket by disabling lingering */
li.l_linger = li.l_onoff = 0;
if (setsockopt(sd, SOL_SOCKET, SO_LINGER, (const char*)&li,
sizeof(li))) {
JK_GET_SOCKET_ERRNO();
jk_log(l, JK_LOG_ERROR,
"failed setting SO_LINGER (errno=%d)", errno);
jk_close_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_INVALID_SOCKET;
}
#endif
/* Tries to connect to Tomcat (continues trying while error is EINTR) */
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"trying to connect socket %d to %s", sd,
jk_dump_hinfo(addr, buf, sizeof(buf)));
/* Need more infos for BSD 4.4 and Unix 98 defines, for now only
iSeries when Unix98 is required at compile time */
#if (_XOPEN_SOURCE >= 520) && defined(AS400)
((struct sockaddr *)addr)->sa.sin.sa_len = sizeof(struct sockaddr_in);
#endif
ret = nb_connect(sd, addr, source, connect_timeout, l);
#if defined(WIN32)
if (JK_IS_SOCKET_ERROR(ret)) {
JK_GET_SOCKET_ERRNO();
}
#endif /* WIN32 */
/* Check if we are connected */
if (ret) {
jk_log(l, JK_LOG_INFO,
"connect to %s failed (errno=%d)",
jk_dump_hinfo(addr, buf, sizeof(buf)), errno);
jk_close_socket(sd, l);
sd = JK_INVALID_SOCKET;
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "socket %d [%s] connected",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)));
}
JK_TRACE_EXIT(l);
return sd;
}
/** Close the socket
* @param sd socket to close
* @param l logger
* @return -1: some kind of error occured (!WIN32)
* SOCKET_ERROR: some kind of error occured (WIN32)
* 0: success
* @remark Does not change errno
*/
int jk_close_socket(jk_sock_t sd, jk_logger_t *l)
{
int rc;
int save_errno;
JK_TRACE_ENTER(l);
if (!IS_VALID_SOCKET(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
save_errno = errno;
#if defined(WIN32)
rc = closesocket(sd) ? -1 : 0;
#else
do {
rc = close(sd);
} while (JK_IS_SOCKET_ERROR(rc) && (errno == EINTR || errno == EAGAIN));
#endif
JK_TRACE_EXIT(l);
errno = save_errno;
return rc;
}
#ifndef MAX_SECS_TO_LINGER
#define MAX_SECS_TO_LINGER 2
#endif
#ifndef MS_TO_LINGER
#define MS_TO_LINGER 100
#endif
#ifndef MS_TO_LINGER_LAST
#define MS_TO_LINGER_LAST 20
#endif
#ifndef MAX_READ_RETRY
#define MAX_READ_RETRY 10
#endif
#ifndef MAX_LINGER_BYTES
#define MAX_LINGER_BYTES 32768
#endif
#ifndef SHUT_WR
#ifdef SD_SEND
#define SHUT_WR SD_SEND
#else
#define SHUT_WR 0x01
#endif
#endif
#ifndef SHUT_RD
#ifdef SD_RECEIVE
#define SHUT_RD SD_RECEIVE
#else
#define SHUT_RD 0x00
#endif
#endif
/** Drain and close the socket
* @param sd socket to close
* @param l logger
* @return -1: socket to close is invalid
* -1: some kind of error occured (!WIN32)
* SOCKET_ERROR: some kind of error occured (WIN32)
* 0: success
* @remark Does not change errno
*/
int jk_shutdown_socket(jk_sock_t sd, jk_logger_t *l)
{
char dummy[512];
char buf[DUMP_SINFO_BUF_SZ];
char *sb = NULL;
int rc = 0;
size_t rd = 0;
size_t rp = 0;
int save_errno;
int timeout = MS_TO_LINGER;
time_t start = time(NULL);
JK_TRACE_ENTER(l);
if (!IS_VALID_SOCKET(sd)) {
JK_TRACE_EXIT(l);
return -1;
}
save_errno = errno;
if (JK_IS_DEBUG_LEVEL(l)) {
sb = jk_dump_sinfo(sd, buf, sizeof(buf));
jk_log(l, JK_LOG_DEBUG, "About to shutdown socket %d [%s]",
sd, sb);
}
/* Shut down the socket for write, which will send a FIN
* to the peer.
*/
if (shutdown(sd, SHUT_WR)) {
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Failed sending SHUT_WR for socket %d [%s]",
sd, sb);
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
do {
rp = 0;
if (jk_is_input_event(sd, timeout, l)) {
/* Do a restartable read on the socket
* draining out all the data currently in the socket buffer.
*/
int num = 0;
do {
num++;
#if defined(WIN32)
rc = recv(sd, &dummy[0], sizeof(dummy), 0);
if (JK_IS_SOCKET_ERROR(rc))
JK_GET_SOCKET_ERRNO();
#else
rc = read(sd, &dummy[0], sizeof(dummy));
#endif
if (rc > 0)
rp += rc;
} while (JK_IS_SOCKET_ERROR(rc) && (errno == EINTR || errno == EAGAIN) && num < MAX_READ_RETRY);
if (rc < 0) {
/* Read failed.
* Bail out from the loop.
*/
break;
}
}
else {
/* Error or timeout (reason is logged within jk_is_input_event)
* Exit the drain loop
*/
break;
}
rd += rp;
if (rp < sizeof(dummy)) {
if (timeout > MS_TO_LINGER_LAST) {
/* Try one last time with a short timeout
*/
timeout = MS_TO_LINGER_LAST;
continue;
}
/* We have read less then size of buffer
* It's a good chance there will be no more data
* to read.
*/
if ((rc = sononblock(sd))) {
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"error setting socket %d [%s] to nonblocking",
sd, sb);
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"shutting down the read side of socket %d [%s]",
sd, sb);
shutdown(sd, SHUT_RD);
break;
}
timeout = MS_TO_LINGER;
} while ((rd < MAX_LINGER_BYTES) && (difftime(time(NULL), start) < MAX_SECS_TO_LINGER));
rc = jk_close_socket(sd, l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"Shutdown socket %d [%s] and read %d lingering bytes in %d sec.",
sd, sb, rd, (int)difftime(time(NULL), start));
errno = save_errno;
JK_TRACE_EXIT(l);
return rc;
}
/** send a message
* @param sd socket to use
* @param b buffer containing the data
* @param len length to send
* @param l logger
* @return negative errno: write returns a fatal -1 (!WIN32)
* negative pseudo errno: send returns SOCKET_ERROR (WIN32)
* JK_SOCKET_EOF: no bytes could be sent
* >0: success, provided number of bytes send
* @remark Always closes socket in case of error
* @remark Cares about errno
* @bug this fails on Unixes if len is too big for the underlying
* protocol
*/
int jk_tcp_socket_sendfull(jk_sock_t sd, const unsigned char *b, int len, jk_logger_t *l)
{
int sent = 0;
int wr;
JK_TRACE_ENTER(l);
errno = 0;
while (sent < len) {
do {
#if defined(WIN32)
wr = send(sd, (const char*)(b + sent),
len - sent, 0);
if (JK_IS_SOCKET_ERROR(wr))
JK_GET_SOCKET_ERRNO();
#else
wr = write(sd, b + sent, len - sent);
#endif
} while (JK_IS_SOCKET_ERROR(wr) && (errno == EINTR || errno == EAGAIN));
if (JK_IS_SOCKET_ERROR(wr)) {
int err;
jk_shutdown_socket(sd, l);
err = (errno > 0) ? -errno : errno;
JK_TRACE_EXIT(l);
return err;
}
else if (wr == 0) {
jk_shutdown_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_SOCKET_EOF;
}
sent += wr;
}
JK_TRACE_EXIT(l);
return sent;
}
/** receive a message
* @param sd socket to use
* @param b buffer to store the data
* @param len length to receive
* @param l logger
* @return negative errno: read returns a fatal -1 (!WIN32)
* negative pseudo errno: recv returns SOCKET_ERROR (WIN32)
* JK_SOCKET_EOF: no bytes could be read
* >0: success, requested number of bytes received
* @remark Always closes socket in case of error
* @remark Cares about errno
*/
int jk_tcp_socket_recvfull(jk_sock_t sd, unsigned char *b, int len, jk_logger_t *l)
{
int rdlen = 0;
int rd;
JK_TRACE_ENTER(l);
errno = 0;
while (rdlen < len) {
do {
#if defined(WIN32)
rd = recv(sd, (char *)b + rdlen,
len - rdlen, 0);
if (JK_IS_SOCKET_ERROR(rd))
JK_GET_SOCKET_ERRNO();
#else
rd = read(sd, (char *)b + rdlen, len - rdlen);
#endif
} while (JK_IS_SOCKET_ERROR(rd) && errno == EINTR);
if (JK_IS_SOCKET_ERROR(rd)) {
int err = (errno > 0) ? -errno : errno;
jk_shutdown_socket(sd, l);
JK_TRACE_EXIT(l);
return (err == 0) ? JK_SOCKET_EOF : err;
}
else if (rd == 0) {
jk_shutdown_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_SOCKET_EOF;
}
rdlen += rd;
}
JK_TRACE_EXIT(l);
return rdlen;
}
/* const char *
* inet_ntop4(src, dst, size)
* format an IPv4 address, more or less like inet_ntoa()
* return:
* `dst' (as a const)
* notes:
* (1) uses no statics
* (2) takes a u_char* not an in_addr as input
* author:
* Paul Vixie, 1996.
*/
static const char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
{
const size_t MIN_SIZE = 16; /* space for 255.255.255.255\0 */
int n = 0;
char *next = dst;
if (size < MIN_SIZE) {
errno = ENOSPC;
return NULL;
}
do {
unsigned char u = *src++;
if (u > 99) {
*next++ = '0' + u/100;
u %= 100;
*next++ = '0' + u/10;
u %= 10;
}
else if (u > 9) {
*next++ = '0' + u/10;
u %= 10;
}
*next++ = '0' + u;
*next++ = '.';
n++;
} while (n < 4);
*--next = '\0';
return dst;
}
#if JK_HAVE_IPV6
/* const char *
* inet_ntop6(src, dst, size)
* convert IPv6 binary address into presentation (printable) format
* author:
* Paul Vixie, 1996.
*/
static const char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
{
/*
* Note that int32_t and int16_t need only be "at least" large enough
* to contain a value of the specified size. On some systems, like
* Crays, there is no such thing as an integer variable with 16 bits.
* Keep this in mind if you think this function should have been coded
* to use pointer overlays. All the world's not a VAX.
*/
char tmp[INET6_ADDRSTRLEN], *tp;
struct { int base, len; } best = {-1, 0}, cur = {-1, 0};
unsigned int words[IN6ADDRSZ / INT16SZ];
int i;
const unsigned char *next_src, *src_end;
unsigned int *next_dest;
/*
* Preprocess:
* Copy the input (bytewise) array into a wordwise array.
* Find the longest run of 0x00's in src[] for :: shorthanding.
*/
next_src = src;
src_end = src + IN6ADDRSZ;
next_dest = words;
i = 0;
do {
unsigned int next_word = (unsigned int)*next_src++;
next_word <<= 8;
next_word |= (unsigned int)*next_src++;
*next_dest++ = next_word;
if (next_word == 0) {
if (cur.base == -1) {
cur.base = i;
cur.len = 1;
}
else {
cur.len++;
}
} else {
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len) {
best = cur;
}
cur.base = -1;
}
}
i++;
} while (next_src < src_end);
if (cur.base != -1) {
if (best.base == -1 || cur.len > best.len) {
best = cur;
}
}
if (best.base != -1 && best.len < 2) {
best.base = -1;
}
/*
* Format the result.
*/
tp = tmp;
for (i = 0; i < (IN6ADDRSZ / INT16SZ);) {
/* Are we inside the best run of 0x00's? */
if (i == best.base) {
*tp++ = ':';
i += best.len;
continue;
}
/* Are we following an initial run of 0x00s or any real hex? */
if (i != 0) {
*tp++ = ':';
}
/* Is this address an encapsulated IPv4? */
if (i == 6 && best.base == 0 &&
(best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
if (!inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp))) {
return (NULL);
}
tp += strlen(tp);
break;
}
tp += sprintf(tp, "%x", words[i]);
i++;
}
/* Was it a trailing run of 0x00's? */
if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
*tp++ = ':';
}
*tp++ = '\0';
/*
* Check for overflow, copy, and we're done.
*/
if ((size_t)(tp - tmp) > size) {
errno = ENOSPC;
return NULL;
}
strcpy(dst, tmp);
return dst;
}
#endif
/**
* dump a jk_sockaddr_t in A.B.C.D:P in ASCII buffer
*
*/
char *jk_dump_hinfo(jk_sockaddr_t *saddr, char *buf, size_t size)
{
char pb[8];
if (saddr->ipaddr_ptr == NULL) {
strcpy(buf, "UnresolvedIP");
} else {
if (saddr->family == JK_INET) {
inet_ntop4(saddr->ipaddr_ptr, buf, size);
}
#if JK_HAVE_IPV6
else {
inet_ntop6(saddr->ipaddr_ptr, buf, size);
}
#endif
}
sprintf(pb, ":%d", saddr->port);
strncat(buf, pb, size - strlen(buf) - 1);
return buf;
}
char *jk_dump_sinfo(jk_sock_t sd, char *buf, size_t size)
{
struct sockaddr rsaddr;
struct sockaddr lsaddr;
socklen_t salen;
salen = sizeof(struct sockaddr);
if (getsockname(sd, &lsaddr, &salen) == 0) {
salen = sizeof(struct sockaddr);
if (getpeername(sd, &rsaddr, &salen) == 0) {
char pb[8];
size_t ps;
if (lsaddr.sa_family == JK_INET) {
struct sockaddr_in *sa = (struct sockaddr_in *)&lsaddr;
inet_ntop4((unsigned char *)&sa->sin_addr, buf, size);
sprintf(pb, ":%d", (unsigned int)htons(sa->sin_port));
}
#if JK_HAVE_IPV6
else {
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)&lsaddr;
inet_ntop6((unsigned char *)&sa->sin6_addr, buf, size);
sprintf(pb, ":%d", (unsigned int)htons(sa->sin6_port));
}
#endif
ps = strlen(buf);
strncat(buf, pb, size - ps - 1);
ps = strlen(buf);
strncat(buf, " -> ", size - ps - 1);
ps = strlen(buf);
if (rsaddr.sa_family == JK_INET) {
struct sockaddr_in *sa = (struct sockaddr_in *)&rsaddr;
inet_ntop4((unsigned char *)&sa->sin_addr, buf + ps, size - ps);
sprintf(pb, ":%d", (unsigned int)htons(sa->sin_port));
}
#if JK_HAVE_IPV6
else {
struct sockaddr_in6 *sa = (struct sockaddr_in6 *)&rsaddr;
inet_ntop6((unsigned char *)&sa->sin6_addr, buf + ps, size - ps);
sprintf(pb, ":%d", (unsigned int)htons(sa->sin6_port));
}
#endif
strncat(buf, pb, size - strlen(buf) - 1);
return buf;
}
}
snprintf(buf, size, "errno=%d", errno);
return buf;
}
/** Wait for input event on socket until timeout
* @param sd socket to use
* @param timeout wait timeout in milliseconds
* @param l logger
* @return JK_FALSE: Timeout expired without something to read
* JK_FALSE: Error during waiting
* JK_TRUE: success
* @remark Does not close socket in case of error
* to allow for iterative waiting
* @remark Cares about errno
*/
#ifdef HAVE_POLL
int jk_is_input_event(jk_sock_t sd, int timeout, jk_logger_t *l)
{
struct pollfd fds;
int rc;
int save_errno;
char buf[DUMP_SINFO_BUF_SZ];
JK_TRACE_ENTER(l);
errno = 0;
fds.fd = sd;
fds.events = POLLIN;
fds.revents = 0;
do {
rc = poll(&fds, 1, timeout);
} while (rc < 0 && errno == EINTR);
if (rc == 0) {
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"timeout during poll on socket %d [%s] (timeout=%d)",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)), timeout);
}
/* Timeout. Set the errno to timeout */
errno = ETIMEDOUT;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
else if (rc < 0) {
save_errno = errno;
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"error during poll on socket %d [%s] (errno=%d)",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)), errno);
}
errno = save_errno;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if ((fds.revents & (POLLERR | POLLHUP))) {
save_errno = fds.revents & (POLLERR | POLLHUP);
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"error event during poll on socket %d [%s] (event=%d)",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)), save_errno);
}
errno = save_errno;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
errno = 0;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
#else
int jk_is_input_event(jk_sock_t sd, int timeout, jk_logger_t *l)
{
fd_set rset;
struct timeval tv;
int rc;
int save_errno;
char buf[DUMP_SINFO_BUF_SZ];
JK_TRACE_ENTER(l);
errno = 0;
FD_ZERO(&rset);
FD_SET(sd, &rset);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
do {
rc = select((int)sd + 1, &rset, NULL, NULL, &tv);
} while (rc < 0 && errno == EINTR);
if (rc == 0) {
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"timeout during select on socket %d [%s] (timeout=%d)",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)), timeout);
}
/* Timeout. Set the errno to timeout */
#if defined(WIN32)
errno = WSAETIMEDOUT - WSABASEERR;
#else
errno = ETIMEDOUT;
#endif
JK_TRACE_EXIT(l);
return JK_FALSE;
}
else if (rc < 0) {
save_errno = errno;
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"error during select on socket %d [%s] (errno=%d)",
sd, jk_dump_sinfo(sd, buf, sizeof(buf)), errno);
}
errno = save_errno;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
errno = 0;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
#endif
/** Test if a socket is still connected
* @param sd socket to use
* @param l logger
* @return JK_FALSE: failure
* JK_TRUE: success
* @remark Always closes socket in case of error
* @remark Cares about errno
*/
#ifdef HAVE_POLL
int jk_is_socket_connected(jk_sock_t sd, jk_logger_t *l)
{
struct pollfd fds;
int rc;
JK_TRACE_ENTER(l);
errno = 0;
fds.fd = sd;
fds.events = POLLIN;
do {
rc = poll(&fds, 1, 0);
} while (rc < 0 && errno == EINTR);
if (rc == 0) {
/* If we get a timeout, then we are still connected */
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else if (rc == 1 && fds.revents == POLLIN) {
char buf;
do {
rc = (int)recvfrom(sd, &buf, 1, MSG_PEEK, NULL, NULL);
} while (rc < 0 && errno == EINTR);
if (rc == 1) {
/* There is at least one byte to read. */
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
jk_shutdown_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
#else
int jk_is_socket_connected(jk_sock_t sd, jk_logger_t *l)
{
fd_set fd;
struct timeval tv;
int rc;
JK_TRACE_ENTER(l);
errno = 0;
FD_ZERO(&fd);
FD_SET(sd, &fd);
/* Initially test the socket without any blocking.
*/
tv.tv_sec = 0;
tv.tv_usec = 0;
do {
rc = select((int)sd + 1, &fd, NULL, NULL, &tv);
JK_GET_SOCKET_ERRNO();
/* Wait one microsecond on next select, if EINTR */
tv.tv_sec = 0;
tv.tv_usec = 1;
} while (JK_IS_SOCKET_ERROR(rc) && errno == EINTR);
errno = 0;
if (rc == 0) {
/* If we get a timeout, then we are still connected */
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else if (rc == 1) {
#if defined(WIN32)
u_long nr;
rc = ioctlsocket(sd, FIONREAD, &nr);
if (rc == 0) {
if (WSAGetLastError() == 0)
errno = 0;
else
JK_GET_SOCKET_ERRNO();
}
#else
int nr;
rc = ioctl(sd, FIONREAD, (void*)&nr);
#endif
if (rc == 0 && nr != 0) {
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_GET_SOCKET_ERRNO();
}
jk_shutdown_socket(sd, l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
#endif
tomcat-connectors-1.2.48-src/native/common/jk_lb_worker.c 0000644 0000000 0000002 00000226517 13623533443 021741 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Load balancer worker, knows how to load balance among *
* several workers. *
* Author: Gal Shachor *
* Author: Mladen Turk *
* Author: Rainer Jung *
***************************************************************************/
#include "jk_pool.h"
#include "jk_service.h"
#include "jk_util.h"
#include "jk_worker.h"
#include "jk_lb_worker.h"
#include "jk_ajp13_worker.h"
#include "jk_ajp14_worker.h"
#include "jk_mt.h"
#include "jk_shm.h"
/*
* The load balancing code in this
*/
/*
* The following two macros need to be kept in sync with
* the existing values for state and activation.
* Note: state <= JK_LB_STATE_FORCE is equivalent to
* state is none of JK_LB_STATE_BUSY, JK_LB_STATE_ERROR, JK_LB_STATE_PROBE
* Note: state <= JK_LB_STATE_BUSY is equivalent to
* state is none of JK_LB_STATE_ERROR, JK_LB_STATE_PROBE
* Note: activation == JK_LB_ACTIVATION_ACTIVE is equivalent to
* activation is none of JK_LB_ACTIVATION_STOPPED, JK_LB_ACTIVATION_DISABLED
*/
#define JK_WORKER_USABLE(s, activation) ((s) <= JK_LB_STATE_FORCE && activation == JK_LB_ACTIVATION_ACTIVE)
#define JK_WORKER_USABLE_STICKY(s, activation) ((s) <= JK_LB_STATE_FORCE && activation != JK_LB_ACTIVATION_STOPPED)
static const char *lb_locking_type[] = {
JK_LB_LOCK_TEXT_OPTIMISTIC,
JK_LB_LOCK_TEXT_PESSIMISTIC,
"unknown",
NULL
};
static const char *lb_method_type[] = {
JK_LB_METHOD_TEXT_REQUESTS,
JK_LB_METHOD_TEXT_TRAFFIC,
JK_LB_METHOD_TEXT_BUSYNESS,
JK_LB_METHOD_TEXT_SESSIONS,
JK_LB_METHOD_TEXT_NEXT,
"unknown",
NULL
};
static const char *lb_state_type[] = {
JK_LB_STATE_TEXT_IDLE,
JK_LB_STATE_TEXT_OK,
JK_LB_STATE_TEXT_RECOVER,
JK_LB_STATE_TEXT_FORCE,
JK_LB_STATE_TEXT_BUSY,
JK_LB_STATE_TEXT_ERROR,
JK_LB_STATE_TEXT_PROBE,
"unknown",
NULL
};
static const char *lb_activation_type[] = {
JK_LB_ACTIVATION_TEXT_ACTIVE,
JK_LB_ACTIVATION_TEXT_DISABLED,
JK_LB_ACTIVATION_TEXT_STOPPED,
"unknown",
NULL
};
static const char *lb_first_log_names[] = {
JK_NOTE_LB_FIRST_NAME,
JK_NOTE_LB_FIRST_VALUE,
JK_NOTE_LB_FIRST_ACCESSED,
JK_NOTE_LB_FIRST_SESSIONS,
JK_NOTE_LB_FIRST_READ,
JK_NOTE_LB_FIRST_TRANSFERRED,
JK_NOTE_LB_FIRST_ERRORS,
JK_NOTE_LB_FIRST_BUSY,
JK_NOTE_LB_FIRST_ACTIVATION,
JK_NOTE_LB_FIRST_STATE,
NULL
};
static const char *lb_last_log_names[] = {
JK_NOTE_LB_LAST_NAME,
JK_NOTE_LB_LAST_VALUE,
JK_NOTE_LB_LAST_ACCESSED,
JK_NOTE_LB_LAST_SESSIONS,
JK_NOTE_LB_LAST_READ,
JK_NOTE_LB_LAST_TRANSFERRED,
JK_NOTE_LB_LAST_ERRORS,
JK_NOTE_LB_LAST_BUSY,
JK_NOTE_LB_LAST_ACTIVATION,
JK_NOTE_LB_LAST_STATE,
NULL
};
struct lb_endpoint
{
lb_worker_t *worker;
jk_endpoint_t endpoint;
int *states;
};
typedef struct lb_endpoint lb_endpoint_t;
/* Calculate the greatest common divisor of two positive integers */
static jk_uint64_t gcd(jk_uint64_t a, jk_uint64_t b)
{
jk_uint64_t r;
if (b > a) {
r = a;
a = b;
b = r;
}
while (b > 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
/* Calculate the smallest common multiple of two positive integers */
static jk_uint64_t scm(jk_uint64_t a, jk_uint64_t b)
{
return a * b / gcd(a, b);
}
/* Return the string representation of the lb lock type */
/* based on the integer representation */
const char *jk_lb_get_lock_direct(int lblock, jk_logger_t *l)
{
return lb_locking_type[lblock];
}
/* Return the string representation of the lb lock type */
/* based on the lb worker struct */
const char *jk_lb_get_lock(lb_worker_t *p, jk_logger_t *l)
{
return lb_locking_type[p->lblock];
}
/* Return the int representation of the lb lock type */
int jk_lb_get_lock_code(const char *v)
{
if (!v)
return JK_LB_LOCK_DEF;
if (*v == 'o' || *v == 'O' || *v == '0')
return JK_LB_LOCK_OPTIMISTIC;
if (*v == 'p' || *v == 'P' || *v == '1')
return JK_LB_LOCK_PESSIMISTIC;
return JK_LB_LOCK_DEF;
}
/* Return the string representation of the lb method type */
/* based on the integer representation */
const char *jk_lb_get_method_direct(int lbmethod, jk_logger_t *l)
{
return lb_method_type[lbmethod];
}
/* Return the string representation of the lb method type */
/* based on the lb worker struct */
const char *jk_lb_get_method(lb_worker_t *p, jk_logger_t *l)
{
return lb_method_type[p->lbmethod];
}
/* Return the int representation of the lb method type */
int jk_lb_get_method_code(const char *v)
{
if (!v)
return JK_LB_METHOD_DEF;
if (*v == 'r' || *v == 'R' || *v == '0')
return JK_LB_METHOD_REQUESTS;
if (*v == 't' || *v == 'T' || *v == '1')
return JK_LB_METHOD_TRAFFIC;
if (*v == 'b' || *v == 'B' || *v == '2')
return JK_LB_METHOD_BUSYNESS;
if (*v == 's' || *v == 'S' || *v == '3')
return JK_LB_METHOD_SESSIONS;
if (*v == 'n' || *v == 'N' || *v == '4')
return JK_LB_METHOD_NEXT;
return JK_LB_METHOD_DEF;
}
/* Return the string representation of the balance worker state */
/* based on the integer representation */
const char *jk_lb_get_state_direct(int state, jk_logger_t *l)
{
return lb_state_type[state];
}
/* Return the string representation of the balance worker state */
/* based on the sub worker struct */
const char *jk_lb_get_state(lb_sub_worker_t *p, jk_logger_t *l)
{
return lb_state_type[p->s->state];
}
/* Return the int representation of the lb state */
int jk_lb_get_state_code(const char *v)
{
if (!v)
return JK_LB_STATE_DEF;
if (*v == 'i' || *v == 'I' || *v == 'n' || *v == 'N' || *v == '0')
return JK_LB_STATE_IDLE;
if (*v == 'o' || *v == 'O' || *v == '1')
return JK_LB_STATE_OK;
if (*v == 'r' || *v == 'R' || *v == '2')
return JK_LB_STATE_RECOVER;
if (*v == 'f' || *v == 'F' || *v == '3')
return JK_LB_STATE_FORCE;
if (*v == 'b' || *v == 'B' || *v == '4')
return JK_LB_STATE_BUSY;
if (*v == 'e' || *v == 'E' || *v == '5')
return JK_LB_STATE_ERROR;
if (*v == 'p' || *v == 'P' || *v == '6')
return JK_LB_STATE_PROBE;
return JK_LB_STATE_DEF;
}
/* Return the string representation of the balance worker activation */
/* based on the integer representation */
const char *jk_lb_get_activation_direct(int activation, jk_logger_t *l)
{
return lb_activation_type[activation];
}
/* Return the string representation of the balance worker activation */
/* based on the sub worker struct */
const char *jk_lb_get_activation(lb_sub_worker_t *p, jk_logger_t *l)
{
return lb_activation_type[p->activation];
}
int jk_lb_get_activation_code(const char *v)
{
if (!v)
return JK_LB_ACTIVATION_DEF;
if (*v == 'a' || *v == 'A' || *v == '0')
return JK_LB_ACTIVATION_ACTIVE;
if (*v == 'd' || *v == 'D' || *v == '1')
return JK_LB_ACTIVATION_DISABLED;
if (*v == 's' || *v == 'S' || *v == '2')
return JK_LB_ACTIVATION_STOPPED;
return JK_LB_ACTIVATION_DEF;
}
/* Update the load multipliers wrt. lb_factor */
void update_mult(lb_worker_t *p, jk_logger_t *l)
{
unsigned int i = 0;
jk_uint64_t s = 1;
JK_TRACE_ENTER(l);
for (i = 0; i < p->num_of_workers; i++) {
s = scm(s, p->lb_workers[i].lb_factor);
}
for (i = 0; i < p->num_of_workers; i++) {
p->lb_workers[i].lb_mult = s / p->lb_workers[i].lb_factor;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s gets multiplicity %"
JK_UINT64_T_FMT,
p->lb_workers[i].name,
p->lb_workers[i].lb_mult);
}
JK_TRACE_EXIT(l);
}
/* Reset all lb values.
*/
void reset_lb_values(lb_worker_t *p, jk_logger_t *l)
{
unsigned int i = 0;
JK_TRACE_ENTER(l);
if (p->lbmethod != JK_LB_METHOD_BUSYNESS) {
for (i = 0; i < p->num_of_workers; i++) {
p->lb_workers[i].s->lb_value = 0;
}
}
JK_TRACE_EXIT(l);
}
static void jk_lb_pull_worker(lb_worker_t *p, int i, jk_logger_t *l)
{
lb_sub_worker_t *w = &p->lb_workers[i];
if (w->sequence < w->s->h.sequence) {
jk_worker_t *jw = w->worker;
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"syncing mem for member '%s' of lb '%s' from shm",
w->name, p->name);
jk_ajp_pull(aw, JK_TRUE, l);
strncpy(w->route, w->s->route, JK_SHM_STR_SIZ);
strncpy(w->domain, w->s->domain, JK_SHM_STR_SIZ);
strncpy(w->redirect, w->s->redirect, JK_SHM_STR_SIZ);
w->distance = w->s->distance;
w->activation = w->s->activation;
w->lb_factor = w->s->lb_factor;
w->lb_mult = w->s->lb_mult;
w->sequence = w->s->h.sequence;
}
}
/* Syncing config values from shm */
void jk_lb_pull(lb_worker_t *p, int locked, jk_logger_t *l)
{
unsigned int i = 0;
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"syncing mem for lb '%s' from shm (%u->%u)",
p->name, p->sequence, p->s->h.sequence);
if (locked == JK_FALSE)
jk_shm_lock();
if (p->sequence == p->s->h.sequence) {
if (locked == JK_FALSE)
jk_shm_unlock();
return;
}
p->sticky_session = p->s->sticky_session;
p->sticky_session_force = p->s->sticky_session_force;
p->recover_wait_time = p->s->recover_wait_time;
p->error_escalation_time = p->s->error_escalation_time;
p->max_reply_timeouts = p->s->max_reply_timeouts;
p->retries = p->s->retries;
p->retry_interval = p->s->retry_interval;
p->lbmethod = p->s->lbmethod;
p->lblock = p->s->lblock;
p->max_packet_size = p->s->max_packet_size;
for (i = 0; i < p->num_of_workers; i++) {
jk_lb_pull_worker(p, i, l);
}
p->sequence = p->s->h.sequence;
if (locked == JK_FALSE)
jk_shm_unlock();
JK_TRACE_EXIT(l);
}
/* Syncing config values to shm */
void jk_lb_push(lb_worker_t *p, int locked, int push_all_members, jk_logger_t *l)
{
unsigned int i = 0;
JK_TRACE_ENTER(l);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"syncing shm for lb '%s' from mem (%u->%u)",
p->name, p->s->h.sequence, p->sequence);
if (locked == JK_FALSE)
jk_shm_lock();
p->s->sticky_session = p->sticky_session;
p->s->sticky_session_force = p->sticky_session_force;
p->s->recover_wait_time = p->recover_wait_time;
p->s->error_escalation_time = p->error_escalation_time;
p->s->max_reply_timeouts = p->max_reply_timeouts;
p->s->retries = p->retries;
p->s->retry_interval = p->retry_interval;
p->s->lbmethod = p->lbmethod;
p->s->lblock = p->lblock;
p->s->max_packet_size = p->max_packet_size;
for (i = 0; i < p->num_of_workers; i++) {
lb_sub_worker_t *w = &p->lb_workers[i];
if (push_all_members == JK_TRUE || w->sequence != w->s->h.sequence) {
jk_worker_t *jw = w->worker;
ajp_worker_t *aw = (ajp_worker_t *)jw->worker_private;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"syncing shm for member '%s' of lb '%s' from mem",
w->name, p->name);
jk_ajp_push(aw, JK_TRUE, l);
strncpy(w->s->route, w->route, JK_SHM_STR_SIZ);
strncpy(w->s->domain, w->domain, JK_SHM_STR_SIZ);
strncpy(w->s->redirect, w->redirect, JK_SHM_STR_SIZ);
w->s->distance = w->distance;
w->s->activation = w->activation;
w->s->lb_factor = w->lb_factor;
w->s->lb_mult = w->lb_mult;
w->s->h.sequence++;
w->sequence = w->s->h.sequence;
}
}
/* Increment the shared memory sequence number.
* Our number can be behind the actual value in
* shared memory.
*/
p->s->h.sequence++;
p->sequence = p->s->h.sequence;
if (locked == JK_FALSE)
jk_shm_unlock();
JK_TRACE_EXIT(l);
}
/* Retrieve the parameter with the given name */
static char *get_path_param(jk_ws_service_t *s, const char *name)
{
char *id_start = NULL;
for (id_start = strstr(s->req_uri, name); id_start; id_start = strstr(id_start + 1, name)) {
if (id_start[strlen(name)] == '=') {
/*
* Session path-cookie was found, get it's value
*/
id_start += (1 + strlen(name));
if (strlen(id_start)) {
char *id_end;
id_start = jk_pool_strdup(s->pool, id_start);
/*
* The query string is not part of req_uri, however
* to be on the safe side lets remove the trailing query
* string if appended...
*/
if ((id_end = strchr(id_start, '?')) != NULL) {
*id_end = '\0';
}
/*
* Remove any trailing path element.
*/
if ((id_end = strchr(id_start, ';')) != NULL) {
*id_end = '\0';
}
/*
* Remove any trailing URI segments.
*/
if ((id_end = strchr(id_start, '/')) != NULL) {
*id_end = '\0';
}
return id_start;
}
}
}
return NULL;
}
/* Retrieve the cookie with the given name */
static char *get_cookie(jk_ws_service_t *s, const char *name)
{
unsigned i;
char *result = NULL;
for (i = 0; i < s->num_headers; i++) {
if (strcasecmp(s->headers_names[i], "cookie") == 0) {
char *id_start;
for (id_start = strstr(s->headers_values[i], name);
id_start; id_start = strstr(id_start + 1, name)) {
if (id_start == s->headers_values[i] ||
id_start[-1] == ';' ||
id_start[-1] == ',' || jk_isspace(id_start[-1])) {
id_start += strlen(name);
while (*id_start && jk_isspace(*id_start))
++id_start;
if (*id_start == '=' && id_start[1]) {
/*
* Session cookie was found, get it's value
*/
char *id_end;
size_t sz;
++id_start;
if ((id_end = strpbrk(id_start, ";,")) != NULL)
sz = id_end - id_start;
else {
sz = strlen(id_start);
id_end = id_start + sz;
}
/* Chop off surrounding '"' (quoted cookie) */
if (sz > 1 && *id_start == '"' && *(id_start + sz - 1) == '"') {
id_start++;
sz -= 2;
}
if (result == NULL) {
result = jk_pool_alloc(s->pool, sz + 1);
memcpy(result, id_start, sz);
result[sz] = '\0';
}
else {
size_t osz = strlen(result) + 1;
result =
jk_pool_realloc(s->pool, osz + sz + 1, result, osz);
strcat(result, ";");
strncat(result, id_start, sz);
}
id_start = id_end;
}
}
}
}
}
return result;
}
/* Retrieve session id from the cookie or the parameter
* (parameter first)
*/
static char *get_sessionid(jk_ws_service_t *s, lb_worker_t *p, jk_logger_t *l)
{
char *val;
char *session_path;
char *session_cookie;
/* If the web server sets a route, ignore the real session id
* and fake a new one for that route.
*/
if (s->route) {
size_t sz = strlen(s->route) + 1;
val = jk_pool_alloc(s->pool, sz + 1);
val[0] = '.';
memcpy(val + 1, s->route, sz);
return val;
}
/* set session_path */
session_path = (s->extension.session_path) ?
s->extension.session_path : p->session_path;
/* set session_cookie */
session_cookie = (s->extension.session_cookie) ?
s->extension.session_cookie : p->session_cookie;
val = get_path_param(s, session_path);
if (!val) {
val = get_cookie(s, session_cookie);
}
if (val && !*val) {
/* TODO: For now only log the empty sessions.
* However we should probably return 400
* (BAD_REQUEST) in this case
*/
jk_log(l, JK_LOG_INFO,
"Detected empty session identifier.");
return NULL;
}
return val;
}
static void close_workers(lb_worker_t *p, int num_of_workers, jk_logger_t *l)
{
int i = 0;
for (i = 0; i < num_of_workers; i++) {
p->lb_workers[i].worker->destroy(&(p->lb_workers[i].worker), l);
}
}
/* If the worker is in error state run
* retry on that worker. It will be marked as
* operational if the retry timeout is elapsed.
* The worker might still be unusable, but we try
* anyway.
* If the worker is in ok state and got no requests
* since the last global maintenance, we mark its
* state as not available.
* Return the number of workers not in error state.
*/
static int recover_workers(lb_worker_t *p,
jk_uint64_t curmax,
time_t now,
jk_logger_t *l)
{
unsigned int i;
int non_error = 0;
int elapsed;
lb_sub_worker_t *w = NULL;
ajp_worker_t *aw = NULL;
JK_TRACE_ENTER(l);
if (p->sequence < p->s->h.sequence)
jk_lb_pull(p, JK_TRUE, l);
for (i = 0; i < p->num_of_workers; i++) {
w = &p->lb_workers[i];
aw = (ajp_worker_t *)w->worker->worker_private;
if (w->s->state == JK_LB_STATE_ERROR) {
elapsed = (int)difftime(now, w->s->last_error_time);
if (elapsed <= p->recover_wait_time) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s will recover in %d seconds",
w->name, p->recover_wait_time - elapsed);
}
else {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s is marked for recovery",
w->name);
if (p->lbmethod != JK_LB_METHOD_BUSYNESS)
w->s->lb_value = curmax;
aw->s->reply_timeouts = 0;
w->s->state = JK_LB_STATE_RECOVER;
non_error++;
}
}
else if (w->s->first_error_time > 0 &&
(int)difftime(now, w->s->first_error_time) >= p->error_escalation_time &&
w->s->state != JK_LB_STATE_RECOVER) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s escalating local error to global error",
w->name);
w->s->state = JK_LB_STATE_ERROR;
}
else {
non_error++;
if (w->s->state == JK_LB_STATE_OK &&
aw->s->used == w->s->elected_snapshot)
w->s->state = JK_LB_STATE_IDLE;
}
w->s->elected_snapshot = aw->s->used;
}
JK_TRACE_EXIT(l);
return non_error;
}
static int force_recovery(lb_worker_t *p,
int *states,
jk_logger_t *l)
{
unsigned int i;
int forced = 0;
lb_sub_worker_t *w = NULL;
ajp_worker_t *aw = NULL;
JK_TRACE_ENTER(l);
for (i = 0; i < p->num_of_workers; i++) {
w = &p->lb_workers[i];
if (w->s->state == JK_LB_STATE_ERROR) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_INFO,
"worker %s is marked for forced recovery",
w->name);
aw = (ajp_worker_t *)w->worker->worker_private;
aw->s->reply_timeouts = 0;
w->s->state = JK_LB_STATE_FORCE;
if (states != NULL)
states[i] = JK_LB_STATE_FORCE;
forced++;
}
}
JK_TRACE_EXIT(l);
return forced;
}
/* Divide old load values by the decay factor,
* such that older values get less important
* for the routing decisions.
*/
static jk_uint64_t decay_load(lb_worker_t *p,
time_t exponent,
jk_logger_t *l)
{
unsigned int i;
jk_uint64_t curmax = 0;
jk_uint64_t curmin = 0;
int no_curmin = JK_TRUE;
lb_sub_worker_t *w;
ajp_worker_t *aw;
JK_TRACE_ENTER(l);
for (i = 0; i < p->num_of_workers; i++) {
w = &p->lb_workers[i];
if (p->lbmethod != JK_LB_METHOD_BUSYNESS) {
if (p->lbmethod != JK_LB_METHOD_NEXT) {
w->s->lb_value >>= exponent;
}
if (w->s->lb_value > curmax) {
curmax = w->s->lb_value;
}
}
aw = (ajp_worker_t *)w->worker->worker_private;
aw->s->reply_timeouts >>= exponent;
}
if (p->lbmethod == JK_LB_METHOD_NEXT) {
for (i = 0; i < p->num_of_workers; i++) {
w = &p->lb_workers[i];
/* Take into account only the workers that are
* not in error state, stopped, disabled or busy.
* Unfortunately we can not respect activations
* defined by mapping rules here.
*/
if (JK_WORKER_USABLE(w->s->state, w->activation)) {
if (w->s->lb_value < curmin || no_curmin == JK_TRUE) {
no_curmin = JK_FALSE;
curmin = w->s->lb_value;
}
}
}
for (i = 0; i < p->num_of_workers; i++) {
w = &p->lb_workers[i];
if (w->s->lb_value >= curmin)
w->s->lb_value -= curmin;
else
w->s->lb_value = 0;
}
}
JK_TRACE_EXIT(l);
return curmax;
}
static int JK_METHOD maintain_workers(jk_worker_t *p, time_t now, int global, jk_logger_t *l)
{
unsigned int i = 0;
jk_uint64_t curmax = 0;
JK_TRACE_ENTER(l);
if (p && p->worker_private) {
lb_worker_t *lb = (lb_worker_t *)p->worker_private;
/* Now we check for global maintenance (once for all processes).
* Checking workers for recovery and applying decay to the
* load values should not be done by each process individually.
* Therefore we globally sync and we use a global timestamp.
* Since it's possible that we come here a few milliseconds
* before the interval has passed, we allow a little tolerance.
*/
if (global == JK_TRUE) {
time_t exponent = JK_LB_DECAY_MULT * ((long)difftime(now, lb->s->last_maintain_time)) / lb->maintain_time;
lb->s->last_maintain_time = now;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"decay with 2^%d",
exponent);
jk_shm_lock();
curmax = decay_load(lb, exponent, l);
if (!recover_workers(lb, curmax, now, l)) {
force_recovery(lb, NULL, l);
}
/*
* Checking workers for idleness.
*/
for (i = 0; i < lb->num_of_workers; i++) {
ajp_worker_t *aw = lb->lb_workers[i].worker->worker_private;
if (aw->s->state == JK_AJP_STATE_OK &&
aw->s->used == aw->s->used_snapshot)
aw->s->state = JK_AJP_STATE_IDLE;
aw->s->used_snapshot = aw->s->used;
}
jk_shm_unlock();
}
for (i = 0; i < lb->num_of_workers; i++) {
if (lb->lb_workers[i].worker->maintain) {
lb->lb_workers[i].worker->maintain(lb->lb_workers[i].worker, now, global, l);
}
}
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD shutdown_workers(jk_worker_t *p, jk_logger_t *l)
{
unsigned int i = 0;
JK_TRACE_ENTER(l);
if (p && p->worker_private) {
lb_worker_t *lb = (lb_worker_t *)p->worker_private;
for (i = 0; i < lb->num_of_workers; i++) {
if (lb->lb_workers[i].worker->shutdown) {
lb->lb_workers[i].worker->shutdown(lb->lb_workers[i].worker, l);
}
}
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int find_by_session(jk_ws_service_t *s,
lb_worker_t *p,
const char *session_route,
jk_logger_t *l)
{
int rc = -1;
unsigned int i;
for (i = 0; i < p->num_of_workers; i++) {
if (strcmp(p->lb_workers[i].route, session_route) == 0) {
rc = i;
break;
}
}
return rc;
}
static int find_best_bydomain(jk_ws_service_t *s,
lb_worker_t *p,
const char *route_or_domain,
int *states,
jk_logger_t *l)
{
unsigned int i;
int d = 0;
jk_uint64_t curmin = 0;
int candidate = -1;
int activation;
lb_sub_worker_t wr;
char *idpart = strchr(route_or_domain, '.');
size_t domain_len = 0;
if (idpart) {
domain_len = idpart - route_or_domain;
}
else {
domain_len = strlen(route_or_domain);
}
/* First try to see if we have available candidate */
for (i = 0; i < p->num_of_workers; i++) {
/* Skip all workers that are not member of domain */
wr = p->lb_workers[i];
if (strlen(wr.domain) == 0 ||
strlen(wr.domain) != domain_len ||
strncmp(wr.domain, route_or_domain, domain_len))
continue;
/* Take into account only the workers that are
* not in error state, stopped, disabled or busy.
*/
activation = s->extension.activation ?
s->extension.activation[i] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = wr.activation;
if (JK_WORKER_USABLE(states[wr.i], activation)) {
if (candidate < 0 || wr.distance < d ||
(wr.s->lb_value < curmin &&
wr.distance == d)) {
candidate = i;
curmin = wr.s->lb_value;
d = wr.distance;
}
}
}
return candidate;
}
static int find_best_byvalue(jk_ws_service_t *s,
lb_worker_t *p,
int *states,
jk_logger_t *l)
{
unsigned int i;
unsigned int j;
unsigned int offset;
int d = 0;
jk_uint64_t curmin = 0;
/* find the least busy worker */
int candidate = -1;
int activation;
lb_sub_worker_t wr;
offset = p->next_offset;
/* First try to see if we have available candidate */
for (j = offset; j < p->num_of_workers + offset; j++) {
i = j % p->num_of_workers;
wr = p->lb_workers[i];
activation = s->extension.activation ?
s->extension.activation[i] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = wr.activation;
/* Take into account only the workers that are
* not in error state, stopped, disabled or busy.
*/
if (JK_WORKER_USABLE(states[wr.i], activation)) {
if (candidate < 0 || wr.distance < d ||
(s->extension.stateless != JK_TRUE &&
wr.s->lb_value < curmin &&
wr.distance == d)) {
candidate = i;
curmin = wr.s->lb_value;
d = wr.distance;
p->next_offset = i + 1;
}
}
}
return candidate;
}
static int find_bysession_route(jk_ws_service_t *s,
lb_worker_t *p,
const char *session_route,
int *states,
jk_logger_t *l)
{
int uses_domain = 0;
int candidate = -1;
candidate = find_by_session(s, p, session_route, l);
if (candidate < 0) {
uses_domain = 1;
candidate = find_best_bydomain(s, p, session_route, states, l);
} else {
s->sticky = JK_TRUE;
}
if (candidate >= 0) {
lb_sub_worker_t wr = p->lb_workers[candidate];
int activation;
if (uses_domain)
s->route = wr.domain;
activation = s->extension.activation ?
s->extension.activation[candidate] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = wr.activation;
if (!JK_WORKER_USABLE_STICKY(states[wr.i], activation)) {
/* We have a worker that is error state or stopped.
* If it has a redirection set use that redirection worker.
* This enables to safely remove the member from the
* balancer. Of course you will need a some kind of
* session replication between those two remote.
*/
s->sticky = JK_FALSE;
if (p->sticky_session_force)
candidate = -1;
else if (*wr.redirect) {
candidate = find_by_session(s, p, wr.redirect, l);
s->route = NULL;
}
else if (*wr.domain && !uses_domain) {
candidate = find_best_bydomain(s, p, wr.domain, states, l);
if (candidate >= 0) {
s->route = wr.domain;
} else {
s->route = NULL;
}
}
if (candidate >= 0) {
wr = p->lb_workers[candidate];
activation = s->extension.activation ?
s->extension.activation[candidate] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = wr.activation;
if (!JK_WORKER_USABLE_STICKY(states[wr.i], activation))
candidate = -1;
}
}
}
return candidate;
}
static int find_failover_worker(jk_ws_service_t *s,
lb_worker_t *p,
int *states,
jk_logger_t *l)
{
int rc = -1;
unsigned int i;
char *redirect = NULL;
for (i = 0; i < p->num_of_workers; i++) {
if (strlen(p->lb_workers[i].redirect)) {
redirect = p->lb_workers[i].redirect;
break;
}
}
if (redirect) {
rc = find_bysession_route(s, p, redirect, states, l);
s->sticky = JK_FALSE;
}
return rc;
}
static int find_best_worker(jk_ws_service_t *s,
lb_worker_t *p,
int *states,
jk_logger_t *l)
{
int rc = -1;
rc = find_best_byvalue(s, p, states, l);
/* By default use worker route as session route */
if (rc < 0)
rc = find_failover_worker(s, p, states, l);
return rc;
}
static int get_most_suitable_worker(jk_ws_service_t *s,
lb_worker_t *p,
char *sessionid,
int *states,
jk_logger_t *l)
{
int rc = -1;
JK_TRACE_ENTER(l);
s->sticky = JK_FALSE;
if (p->num_of_workers == 1) {
/* No need to find the best worker
* if there is a single one
*/
int activation = s->extension.activation ?
s->extension.activation[0] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = p->lb_workers[0].activation;
if (JK_WORKER_USABLE_STICKY(states[0], activation)) {
if (activation != JK_LB_ACTIVATION_DISABLED) {
s->sticky = JK_TRUE;
JK_TRACE_EXIT(l);
return 0;
}
}
else {
JK_TRACE_EXIT(l);
return -1;
}
}
if (p->lblock == JK_LB_LOCK_PESSIMISTIC) {
if (!jk_shm_lock()) {
jk_log(l, JK_LOG_ERROR, "locking failed (errno=%d)", errno);
JK_TRACE_EXIT(l);
return -1;
}
}
else {
JK_ENTER_CS(&p->cs);
}
if (sessionid) {
char *session = sessionid;
while (sessionid) {
char *next = strchr(sessionid, ';');
char *session_route = NULL;
if (next)
*next++ = '\0';
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"searching worker for partial sessionid %s",
sessionid);
session_route = strchr(sessionid, '.');
if (session_route) {
++session_route;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"searching worker for session route %s",
session_route);
/* We have a session route. Whow! */
rc = find_bysession_route(s, p, session_route, states, l);
if (rc >= 0) {
lb_sub_worker_t *wr = &(p->lb_workers[rc]);
if (p->lblock == JK_LB_LOCK_PESSIMISTIC) {
jk_shm_unlock();
}
else {
JK_LEAVE_CS(&p->cs);
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"found worker %s (%s) for route %s and partial sessionid %s",
wr->name, wr->route, session_route, sessionid);
JK_TRACE_EXIT(l);
return rc;
}
}
/* Try next partial sessionid if present */
sessionid = next;
rc = -1;
}
if (rc < 0 && p->sticky_session_force) {
if (p->lblock == JK_LB_LOCK_PESSIMISTIC) {
jk_shm_unlock();
}
else {
JK_LEAVE_CS(&p->cs);
}
jk_log(l, JK_LOG_INFO,
"all workers are in error state for session %s",
session);
JK_TRACE_EXIT(l);
return -1;
}
}
rc = find_best_worker(s, p, states, l);
if (p->lblock == JK_LB_LOCK_PESSIMISTIC) {
jk_shm_unlock();
}
else {
JK_LEAVE_CS(&p->cs);
}
if (rc >= 0) {
lb_sub_worker_t *wr = &(p->lb_workers[rc]);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"found best worker %s (%s) using method '%s'",
wr->name, wr->route, jk_lb_get_method(p, l));
JK_TRACE_EXIT(l);
return rc;
}
JK_TRACE_EXIT(l);
return -1;
}
static void lb_add_log_items(jk_ws_service_t *s,
const char *const *log_names,
lb_sub_worker_t *w,
jk_logger_t *l)
{
/* ADJUST JK_LB_NOTES_COUNT WHEN ADDING MORE NOTES HERE! */
ajp_worker_t *aw = (ajp_worker_t *)w->worker->worker_private;
const char **log_values = jk_pool_alloc(s->pool, sizeof(char *) * JK_LB_NOTES_COUNT);
char *buf = jk_pool_alloc(s->pool, sizeof(char *) * JK_LB_NOTES_COUNT * JK_LB_UINT64_STR_SZ);
if (log_values && buf) {
/* JK_NOTE_LB_FIRST/LAST_NAME */
log_values[0] = w->name;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT64_T_FMT, w->s->lb_value);
/* JK_NOTE_LB_FIRST/LAST_VALUE */
log_values[1] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT64_T_FMT, aw->s->used);
/* JK_NOTE_LB_FIRST/LAST_ACCESSED */
log_values[2] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT64_T_FMT, w->s->sessions);
/* JK_NOTE_LB_FIRST/LAST_SESSIONS */
log_values[3] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT64_T_FMT, aw->s->readed);
/* JK_NOTE_LB_FIRST/LAST_READ */
log_values[4] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT64_T_FMT, aw->s->transferred);
/* JK_NOTE_LB_FIRST/LAST_TRANSFERRED */
log_values[5] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%" JK_UINT32_T_FMT, w->s->errors);
/* JK_NOTE_LB_FIRST/LAST_ERRORS */
log_values[6] = buf;
buf += JK_LB_UINT64_STR_SZ;
snprintf(buf, JK_LB_UINT64_STR_SZ, "%d", aw->s->busy);
/* JK_NOTE_LB_FIRST/LAST_BUSY */
log_values[7] = buf;
/* JK_NOTE_LB_FIRST/LAST_ACTIVATION */
log_values[8] = jk_lb_get_activation(w, l);
/* JK_NOTE_LB_FIRST/LAST_STATE */
log_values[9] = jk_lb_get_state(w, l);
s->add_log_items(s, log_names, log_values, JK_LB_NOTES_COUNT);
}
}
static int JK_METHOD service(jk_endpoint_t *e,
jk_ws_service_t *s,
jk_logger_t *l, int *is_error)
{
lb_endpoint_t *p;
int attempt = 0;
lb_sub_worker_t *prec = NULL;
int num_of_workers;
int first = 1;
int was_forced = 0;
int recoverable = JK_TRUE;
int rc = JK_UNSET;
char *sessionid = NULL;
int i;
int retry = 0;
JK_TRACE_ENTER(l);
if (!e || !e->endpoint_private || !s || !is_error) {
JK_LOG_NULL_PARAMS(l);
if (is_error)
*is_error = JK_HTTP_SERVER_ERROR;
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p = e->endpoint_private;
num_of_workers = p->worker->num_of_workers;
/* Set returned error to OK */
*is_error = JK_HTTP_OK;
if (p->worker->sequence < p->worker->s->h.sequence)
jk_lb_pull(p->worker, JK_FALSE, l);
for (i = 0; i < num_of_workers; i++) {
lb_sub_worker_t *rec;
ajp_worker_t *aw;
jk_log(l, JK_LOG_DEBUG, "LB - num_of_workers: %d, retry: %d, lb_retries: %d", num_of_workers, i, p->worker->lb_retries);
rec = &(p->worker->lb_workers[i]);
aw = (ajp_worker_t *)rec->worker->worker_private;
if (rec->s->state == JK_LB_STATE_BUSY) {
if ((aw->busy_limit <= 0 || aw->s->busy < aw->busy_limit) &&
ajp_has_endpoint(rec->worker, l)) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s busy state ended",
rec->name);
rec->s->state = JK_LB_STATE_OK;
}
}
/* Copy the shared state info */
p->states[i] = rec->s->state;
}
/* set the recovery post, for LB mode */
s->reco_buf = jk_b_new(s->pool);
if (!s->reco_buf) {
*is_error = JK_HTTP_SERVER_ERROR;
jk_log(l, JK_LOG_ERROR,
"Failed allocating AJP message");
JK_TRACE_EXIT(l);
return JK_SERVER_ERROR;
}
if (jk_b_set_buffer_size(s->reco_buf, p->worker->max_packet_size)) {
*is_error = JK_HTTP_SERVER_ERROR;
jk_log(l, JK_LOG_ERROR,
"Failed allocating AJP message buffer of %d bytes.", p->worker->max_packet_size);
JK_TRACE_EXIT(l);
return JK_SERVER_ERROR;
}
jk_b_reset(s->reco_buf);
s->reco_status = RECO_INITED;
if (p->worker->sticky_session && s->extension.sticky_ignore != JK_TRUE) {
/* Use sessionid only if sticky_session is
* defined and not overwritten for this load balancer
*/
sessionid = get_sessionid(s, p->worker, l);
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"service sticky_session=%d id='%s'",
p->worker->sticky_session, sessionid ? sessionid : "empty");
while (recoverable == JK_TRUE) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "attempt %d, max attempts %d, worker count %d",
attempt, p->worker->lb_retries, num_of_workers);
if (attempt >= num_of_workers || attempt >= p->worker->lb_retries) {
retry++;
if (retry >= p->worker->retries) {
/* Done with retrying */
break;
}
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"retry %d, sleeping for %d ms before retrying",
retry, p->worker->retry_interval);
jk_sleep(p->worker->retry_interval);
/* Pull shared memory if something changed during sleep */
if (p->worker->sequence < p->worker->s->h.sequence)
jk_lb_pull(p->worker, JK_FALSE, l);
for (i = 0; i < num_of_workers; i++) {
/* Copy the shared state info */
p->states[i] = p->worker->lb_workers[i].s->state;
}
attempt = 0;
}
rc = JK_FALSE;
*is_error = JK_HTTP_SERVER_BUSY;
i = get_most_suitable_worker(s, p->worker, sessionid, p->states, l);
if (i >= 0) {
int r;
int is_service_error = JK_HTTP_OK;
lb_sub_worker_t *rec = &(p->worker->lb_workers[i]);
ajp_worker_t *aw = (ajp_worker_t *)rec->worker->worker_private;
jk_endpoint_t *end = NULL;
int activation = s->extension.activation ?
s->extension.activation[i] :
JK_LB_ACTIVATION_UNSET;
if (activation == JK_LB_ACTIVATION_UNSET)
activation = rec->activation;
if (!s->route)
s->route = rec->route;
s->activation = jk_lb_get_activation_direct(activation, l);
prec = rec;
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"service worker=%s route=%s failover=%s",
rec->name, s->route, s->sticky ? "false" : "true");
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_lock();
if (rec->s->state == JK_LB_STATE_RECOVER) {
rec->s->state = JK_LB_STATE_PROBE;
p->states[rec->i] = JK_LB_STATE_PROBE;
}
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_unlock();
r = rec->worker->get_endpoint(rec->worker, &end, l);
if (!r || !end) {
/* If we can not get the endpoint
* mark the worker as busy rather then
* as in error if the retry number is
* greater then the number of retries.
*/
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_lock();
if (rec->s->state != JK_LB_STATE_ERROR) {
rec->s->state = JK_LB_STATE_BUSY;
p->states[rec->i] = JK_LB_STATE_BUSY;
}
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_unlock();
jk_log(l, JK_LOG_INFO,
"could not get free endpoint for worker %s (%d retries)",
rec->name, retry);
}
else {
int service_stat = JK_UNSET;
jk_uint64_t rd = 0;
jk_uint64_t wr = 0;
int busy;
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_lock();
/* Increment the number of workers serving request */
busy = JK_ATOMIC_INCREMENT(&(p->worker->s->busy));
if (busy > p->worker->s->max_busy)
p->worker->s->max_busy = busy;
if (p->worker->lbmethod == JK_LB_METHOD_REQUESTS ||
p->worker->lbmethod == JK_LB_METHOD_BUSYNESS ||
(!sessionid &&
s->extension.stateless != JK_TRUE &&
(p->worker->lbmethod == JK_LB_METHOD_SESSIONS ||
p->worker->lbmethod == JK_LB_METHOD_NEXT)))
rec->s->lb_value += rec->lb_mult;
if (!sessionid && s->extension.stateless != JK_TRUE) {
rec->s->sessions++;
}
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_unlock();
if (!s->sticky && (s->extension.set_session_cookie || p->worker->set_session_cookie)) {
char **old_names = s->resp_headers_names;
char **old_values = s->resp_headers_values;
s->resp_headers_names = jk_pool_alloc(s->pool,
(s->num_resp_headers + 1) * sizeof(char *));
s->resp_headers_values = jk_pool_alloc(s->pool,
(s->num_resp_headers + 1) * sizeof(char *));
if (!s->resp_headers_names || !s->resp_headers_values) {
jk_log(l, JK_LOG_ERROR,
"Failed allocating %d new response headers.", s->num_resp_headers + 1);
s->resp_headers_names = old_names;
s->resp_headers_values = old_values;
} else if (s->num_resp_headers) {
memcpy(s->resp_headers_names, old_names, s->num_resp_headers * sizeof(char *));
memcpy(s->resp_headers_values, old_values, s->num_resp_headers * sizeof(char *));
}
s->resp_headers_names[s->num_resp_headers] = "Set-Cookie";
s->resp_headers_values[s->num_resp_headers] = jk_pool_strcatv(s->pool, p->worker->session_cookie,
"=.", rec->route,
NULL);
if (p->worker->session_cookie_path && *p->worker->session_cookie_path) {
s->resp_headers_values[s->num_resp_headers] = jk_pool_strcatv(s->pool, s->resp_headers_values[s->num_resp_headers],
";PATH=", p->worker->session_cookie_path,
NULL);
}
s->resp_headers_values[s->num_resp_headers] = jk_pool_strcatv(s->pool, s->resp_headers_values[s->num_resp_headers],
";HttpOnly",
(s->is_ssl ? ";Secure" : ""),
NULL);
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG, "Added cookie header '%s' with value '%s' ",
s->resp_headers_names[s->num_resp_headers],
s->resp_headers_values[s->num_resp_headers]);
s->num_resp_headers++;
}
service_stat = end->service(end, s, l, &is_service_error);
rd = end->rd;
wr = end->wr;
recoverable = end->recoverable;
*is_error = is_service_error;
end->done(&end, l);
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_lock();
/* Update partial reads and writes if any */
if (p->worker->lbmethod == JK_LB_METHOD_TRAFFIC) {
rec->s->lb_value += (rd+wr)*rec->lb_mult;
}
else if (p->worker->lbmethod == JK_LB_METHOD_BUSYNESS) {
if (rec->s->lb_value >= rec->lb_mult) {
rec->s->lb_value -= rec->lb_mult;
}
else {
rec->s->lb_value = 0;
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"worker %s has load value to low (%"
JK_UINT64_T_FMT
" < %"
JK_UINT64_T_FMT
") ",
"- correcting to 0",
rec->name,
rec->s->lb_value,
rec->lb_mult);
}
}
}
/* When have an endpoint and we ran a request, assume
* we are OK, unless we last were in error.
* We will below explicitely set OK or ERROR according
* to the returned service_stat.
*/
if (rec->s->state != JK_LB_STATE_ERROR) {
rec->s->state = JK_LB_STATE_OK;
p->states[rec->i] = JK_LB_STATE_OK;
}
/* Decrement the busy worker count.
* Check if the busy was reset to zero by graceful
* restart of the server.
*/
JK_ATOMIC_DECREMENT(&(p->worker->s->busy));
if (service_stat == JK_TRUE) {
/*
* Successful request.
*/
rec->s->state = JK_LB_STATE_OK;
p->states[rec->i] = JK_LB_STATE_OK;
rec->s->first_error_time = 0;
rec->s->last_error_time = 0;
rc = JK_TRUE;
recoverable = JK_UNSET;
}
else if (service_stat == JK_CLIENT_ERROR) {
/*
* Client error !!!
* Since this is bad request do not fail over.
*/
rec->s->state = JK_LB_STATE_OK;
p->states[rec->i] = JK_LB_STATE_ERROR;
rec->s->first_error_time = 0;
rec->s->last_error_time = 0;
rc = JK_CLIENT_ERROR;
recoverable = JK_FALSE;
}
else if (service_stat == JK_SERVER_ERROR) {
/*
* Internal JK server error.
* Keep previous global state.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
p->states[rec->i] = JK_LB_STATE_ERROR;
rc = JK_FALSE;
}
else if (service_stat == JK_AJP_PROTOCOL_ERROR) {
/*
* We've received a bad AJP message from the backend.
* Keep previous global state.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
p->states[rec->i] = JK_LB_STATE_ERROR;
rc = JK_FALSE;
}
else if (service_stat == JK_STATUS_ERROR) {
/*
* Status code configured as service is down.
* The node is fine.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
rec->s->state = JK_LB_STATE_OK;
p->states[rec->i] = JK_LB_STATE_ERROR;
rec->s->first_error_time = 0;
rec->s->last_error_time = 0;
rc = JK_FALSE;
}
else if (service_stat == JK_BUSY_ERROR) {
/*
* Node was busy.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
rec->s->state = JK_LB_STATE_BUSY;
p->states[rec->i] = JK_LB_STATE_BUSY;
rc = JK_FALSE;
}
else if (service_stat == JK_STATUS_FATAL_ERROR) {
/*
* Status code configured as service is down.
* Mark the node as bad.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
rec->s->errors++;
rec->s->state = JK_LB_STATE_ERROR;
p->states[rec->i] = JK_LB_STATE_ERROR;
rec->s->first_error_time = time(NULL);
rec->s->last_error_time = rec->s->first_error_time;
rc = JK_FALSE;
}
else if (service_stat == JK_REPLY_TIMEOUT) {
if (aw->s->reply_timeouts > (unsigned)p->worker->max_reply_timeouts) {
/*
* Service failed - to many reply timeouts
* Mark the node as bad.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
rec->s->errors++;
rec->s->state = JK_LB_STATE_ERROR;
p->states[rec->i] = JK_LB_STATE_ERROR;
rec->s->first_error_time = time(NULL);
rec->s->last_error_time = rec->s->first_error_time;
}
else {
/*
* Reply timeout, but not yet too many of them.
* Keep previous global state.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
p->states[rec->i] = JK_LB_STATE_ERROR;
}
rc = JK_FALSE;
}
else {
/*
* Various unspecific error cases.
* Keep previous global state, if we are not in local error since to long.
* Do not try to reuse the same node for the same request.
* Failing over to another node could help.
*/
time_t now = time(NULL);
rec->s->errors++;
if (aw->s->busy == 0 ||
p->worker->error_escalation_time == 0 ||
(rec->s->first_error_time > 0 &&
(int)difftime(now, rec->s->first_error_time) >= p->worker->error_escalation_time)) {
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"worker %s escalating local error to global error",
rec->name);
rec->s->state = JK_LB_STATE_ERROR;
}
p->states[rec->i] = JK_LB_STATE_ERROR;
if (rec->s->first_error_time == 0) {
rec->s->first_error_time = now;
}
rec->s->last_error_time = now;
rc = JK_FALSE;
}
if (p->worker->lblock == JK_LB_LOCK_PESSIMISTIC)
jk_shm_unlock();
if (p->states[rec->i] == JK_LB_STATE_ERROR)
jk_log(l, JK_LOG_INFO,
"service failed, worker %s is in %serror state",
rec->name,
rec->s->state == JK_LB_STATE_ERROR ? "" : "local ");
}
if (recoverable == JK_TRUE) {
/*
* Error is recoverable by submitting the request to
* another worker... Lets try to do that.
*/
if (JK_IS_DEBUG_LEVEL(l))
jk_log(l, JK_LOG_DEBUG,
"recoverable error... will try to recover on other worker");
}
else {
/*
* Error is not recoverable - break with an error.
*/
if (rc == JK_CLIENT_ERROR)
jk_log(l, JK_LOG_INFO,
"unrecoverable error %d, request failed."
" Client failed in the middle of request,"
" we can't recover to another instance.",
*is_error);
else if (rc != JK_TRUE)
jk_log(l, JK_LOG_ERROR,
"unrecoverable error %d, request failed."
" Tomcat failed in the middle of request,"
" we can't recover to another instance.",
*is_error);
}
if (first == 1 && s->add_log_items) {
first = 0;
lb_add_log_items(s, lb_first_log_names, prec, l);
}
}
else {
/* No more workers left ... */
if (!was_forced) {
int nf;
/* Force recovery only once.
* If it still fails, Tomcat is still disconnected.
*/
jk_shm_lock();
nf = force_recovery(p->worker, p->states, l);
jk_shm_unlock();
was_forced = 1;
if (nf) {
/* We have forced recovery.
* Reset the service loop and go again
*/
prec = NULL;
jk_log(l, JK_LOG_INFO,
"Forcing recovery once for %d workers", nf);
continue;
}
else {
/* No workers in error state.
* Somebody set them all to disabled?
*/
jk_log(l, JK_LOG_INFO,
"All tomcat instances failed, no more workers "
"left for recovery (attempt=%d, retry=%d)",
attempt + 1, retry);
*is_error = JK_HTTP_SERVER_BUSY;
rc = JK_FALSE;
}
}
else {
jk_log(l, JK_LOG_INFO,
"All tomcat instances failed, no more workers "
"left (attempt=%d, retry=%d)",
attempt + 1, retry);
*is_error = JK_HTTP_SERVER_BUSY;
rc = JK_FALSE;
}
}
attempt++;
}
if (recoverable == JK_TRUE) {
jk_log(l, JK_LOG_INFO,
"All tomcat instances are busy or in error state");
/* rc and http error must be set above */
}
if (rc == JK_FALSE) {
jk_log(l, JK_LOG_ERROR,
"All tomcat instances failed, no more workers left");
}
if (prec && s->add_log_items) {
lb_add_log_items(s, lb_last_log_names, prec, l);
}
JK_TRACE_EXIT(l);
return rc;
}
static int JK_METHOD done(jk_endpoint_t **e, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (e && *e && (*e)->endpoint_private) {
lb_endpoint_t *p = (*e)->endpoint_private;
free(p->states);
free(p);
*e = NULL;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private) {
lb_worker_t *p = pThis->worker_private;
char **worker_names;
unsigned int num_of_workers;
const char *secret;
p->worker.we = we;
p->sticky_session = jk_get_is_sticky_session(props, p->name);
p->sticky_session_force = jk_get_is_sticky_session_force(props, p->name);
secret = jk_get_worker_secret(props, p->name);
if (jk_get_lb_worker_list(props,
p->name,
&worker_names,
&num_of_workers) && num_of_workers) {
unsigned int i = 0;
unsigned int j = 0;
p->lb_workers = jk_pool_alloc(&p->p,
num_of_workers *
sizeof(lb_sub_worker_t));
if (!p->lb_workers) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
memset(p->lb_workers, 0, num_of_workers * sizeof(lb_sub_worker_t));
for (i = 0; i < num_of_workers; i++) {
if (jk_check_attribute_length("host name", worker_names[i], l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p->lb_workers[i].s = jk_shm_alloc_lb_sub_worker(&p->p, p->s->h.id, worker_names[i], l);
if (p->lb_workers[i].s == NULL) {
jk_log(l, JK_LOG_ERROR,
"allocating lb sub worker record from shared memory");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
p->lb_workers[i].i = i;
strncpy(p->lb_workers[i].name, worker_names[i], JK_SHM_STR_SIZ);
}
for (i = 0; i < num_of_workers; i++) {
const char *s;
unsigned int ms;
if (p->lb_workers[i].s->h.sequence != 0) {
/* Somebody already setup this worker.
* Just pull the data.
*/
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"Balanced worker %s already configured (sequence=%d)",
p->lb_workers[i].name, p->lb_workers[i].s->h.sequence);
}
if (!wc_create_worker(p->lb_workers[i].name, 0,
props,
&(p->lb_workers[i].worker),
we, l) || !p->lb_workers[i].worker) {
break;
}
jk_lb_pull_worker(p, i, l);
continue;
}
p->lb_workers[i].lb_factor =
jk_get_lb_factor(props, worker_names[i]);
if (p->lb_workers[i].lb_factor < 1) {
p->lb_workers[i].lb_factor = 1;
}
/* Calculate the maximum packet size from all workers
* for the recovery buffer.
*/
ms = jk_get_max_packet_size(props, worker_names[i]);
if (ms > p->max_packet_size)
p->max_packet_size = ms;
p->lb_workers[i].distance =
jk_get_distance(props, worker_names[i]);
if ((s = jk_get_worker_route(props, worker_names[i], NULL))) {
if (jk_check_attribute_length("route", s, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
strncpy(p->lb_workers[i].route, s, JK_SHM_STR_SIZ);
}
else
strncpy(p->lb_workers[i].route, worker_names[i], JK_SHM_STR_SIZ);
if ((s = jk_get_worker_domain(props, worker_names[i], NULL))) {
if (jk_check_attribute_length("domain", s, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
strncpy(p->lb_workers[i].domain, s, JK_SHM_STR_SIZ);
}
if ((s = jk_get_worker_redirect(props, worker_names[i], NULL))) {
if (jk_check_attribute_length("redirect", s, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
strncpy(p->lb_workers[i].redirect, s, JK_SHM_STR_SIZ);
}
p->lb_workers[i].s->lb_value = 0;
p->lb_workers[i].s->state = JK_LB_STATE_IDLE;
p->lb_workers[i].s->first_error_time = 0;
p->lb_workers[i].s->last_error_time = 0;
p->lb_workers[i].s->elected_snapshot = 0;
p->lb_workers[i].s->sessions = 0;
p->lb_workers[i].activation =
jk_get_worker_activation(props, worker_names[i]);
if (!wc_create_worker(p->lb_workers[i].name, 0,
props,
&(p->lb_workers[i].worker),
we, l) || !p->lb_workers[i].worker) {
break;
}
if (secret && (p->lb_workers[i].worker->type == JK_AJP13_WORKER_TYPE ||
p->lb_workers[i].worker->type == JK_AJP14_WORKER_TYPE)) {
ajp_worker_t *aw = (ajp_worker_t *)p->lb_workers[i].worker->worker_private;
if (!aw->secret)
aw->secret = secret;
}
if (p->lb_workers[i].worker->type == JK_AJP13_WORKER_TYPE ||
p->lb_workers[i].worker->type == JK_AJP14_WORKER_TYPE) {
ajp_worker_t *aw = (ajp_worker_t *)p->lb_workers[i].worker->worker_private;
if (aw->port == 0) {
p->lb_workers[i].activation = JK_LB_ACTIVATION_STOPPED;
}
}
}
if (i != num_of_workers) {
jk_log(l, JK_LOG_ERROR,
"Failed creating worker %s",
p->lb_workers[i].name);
close_workers(p, i, l);
}
else {
/* Update domain names if route contains period '.' */
for (i = 0; i < num_of_workers; i++) {
if (!p->lb_workers[i].domain[0]) {
char *id_domain = strchr(p->lb_workers[i].route, '.');
if (id_domain) {
*id_domain = '\0';
strcpy(p->lb_workers[i].domain, p->lb_workers[i].route);
*id_domain = '.';
}
}
if (JK_IS_DEBUG_LEVEL(l)) {
jk_log(l, JK_LOG_DEBUG,
"Balanced worker %d has name %s and route %s in domain %s",
i,
p->lb_workers[i].name,
p->lb_workers[i].route,
p->lb_workers[i].domain);
}
}
p->num_of_workers = num_of_workers;
update_mult(p, l);
for (i = 0; i < num_of_workers; i++) {
for (j = 0; j < i; j++) {
if (strcmp(p->lb_workers[i].route, p->lb_workers[j].route) == 0) {
jk_log(l, JK_LOG_ERROR,
"Balanced workers number %d (%s) and %d (%s) share the same route %s - aborting configuration!",
i,
p->lb_workers[i].name,
j,
p->lb_workers[j].name,
p->lb_workers[i].route);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
}
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
}
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *log)
{
int i;
const char *s;
lb_worker_t *p = (lb_worker_t *)pThis->worker_private;
JK_TRACE_ENTER(log);
p->worker.we = we;
p->retries = jk_get_worker_retries(props, p->name,
JK_RETRIES);
p->lb_retries = jk_get_worker_lb_retries(props, p->name,
JK_LB_RETRIES);
p->retry_interval =
jk_get_worker_retry_interval(props, p->name,
JK_SLEEP_DEF);
p->recover_wait_time = jk_get_worker_recover_timeout(props, p->name,
WAIT_BEFORE_RECOVER);
if (p->recover_wait_time < 1)
p->recover_wait_time = 1;
p->error_escalation_time = jk_get_worker_error_escalation_time(props, p->name,
p->recover_wait_time / 2);
p->max_reply_timeouts = jk_get_worker_max_reply_timeouts(props, p->name,
0);
p->maintain_time = jk_get_worker_maintain_time(props);
if(p->maintain_time < 0)
p->maintain_time = 0;
p->s->last_maintain_time = time(NULL);
p->s->last_reset = p->s->last_maintain_time;
p->lbmethod = jk_get_lb_method(props, p->name);
#ifdef JK_ATOMIC_MISSING
if (p->lbmethod == JK_LB_METHOD_BUSYNESS) {
jk_log(log, JK_LOG_WARNING, "Missing support for atomics: "
"LB method 'busyness' not recommended");
}
#endif
p->lblock = jk_get_lb_lock(props, p->name);
s = jk_get_lb_session_cookie(props, p->name, JK_SESSION_IDENTIFIER);
if (jk_check_attribute_length("session_cookie", s, log) == JK_FALSE) {
JK_TRACE_EXIT(log);
return JK_FALSE;
}
strncpy(p->session_cookie, s, JK_SHM_STR_SIZ);
s = jk_get_lb_session_path(props, p->name, JK_PATH_SESSION_IDENTIFIER);
if (jk_check_attribute_length("session_path", s, log) == JK_FALSE) {
JK_TRACE_EXIT(log);
return JK_FALSE;
}
strncpy(p->session_path, s, JK_SHM_STR_SIZ);
p->set_session_cookie = jk_get_lb_set_session_cookie(props, p->name, JK_FALSE);
s = jk_get_lb_session_cookie_path(props, p->name, "/");
if (jk_check_attribute_length("session_cookie_path", s, log) == JK_FALSE) {
JK_TRACE_EXIT(log);
return JK_FALSE;
}
strncpy(p->session_cookie_path, s, JK_SHM_STR_SIZ);
JK_INIT_CS(&(p->cs), i);
if (i == JK_FALSE) {
jk_log(log, JK_LOG_ERROR,
"creating thread lock (errno=%d)",
errno);
JK_TRACE_EXIT(log);
return JK_FALSE;
}
if (p->s->h.sequence == 0) {
/* Set configuration data to shared memory
*/
jk_lb_push(p, JK_TRUE, JK_FALSE, log);
}
else {
/* Shared memory for this worker is already configured.
* Update with runtime data
*/
jk_lb_pull(p, JK_TRUE, log);
}
JK_TRACE_EXIT(log);
return JK_TRUE;
}
static int JK_METHOD get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && pThis->worker_private && pend) {
lb_endpoint_t *p = (lb_endpoint_t *) malloc(sizeof(lb_endpoint_t));
p->worker = pThis->worker_private;
p->endpoint.endpoint_private = p;
p->endpoint.service = service;
p->endpoint.done = done;
p->states = (int *)malloc((p->worker->num_of_workers + 1) * sizeof(int));
if (!p->states) {
free(p);
jk_log(l, JK_LOG_ERROR,
"Failed allocating private worker state memory");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
*pend = &p->endpoint;
JK_TRACE_EXIT(l);
return JK_TRUE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (pThis && *pThis && (*pThis)->worker_private) {
lb_worker_t *private_data = (*pThis)->worker_private;
close_workers(private_data, private_data->num_of_workers, l);
JK_DELETE_CS(&private_data->cs);
jk_close_pool(&private_data->p);
free(private_data);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
JK_LOG_NULL_PARAMS(l);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
int JK_METHOD lb_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l)
{
JK_TRACE_ENTER(l);
if (NULL != name && NULL != w) {
lb_worker_t *private_data =
(lb_worker_t *) calloc(1, sizeof(lb_worker_t));
jk_open_pool(&private_data->p,
private_data->buf,
sizeof(jk_pool_atom_t) * TINY_POOL_SIZE);
private_data->s = jk_shm_alloc_lb_worker(&private_data->p, name, l);
if (!private_data->s) {
free(private_data);
JK_TRACE_EXIT(l);
return 0;
}
strncpy(private_data->name, name, JK_SHM_STR_SIZ);
private_data->lb_workers = NULL;
private_data->num_of_workers = 0;
private_data->worker.worker_private = private_data;
private_data->worker.validate = validate;
private_data->worker.init = init;
private_data->worker.get_endpoint = get_endpoint;
private_data->worker.destroy = destroy;
private_data->worker.maintain = maintain_workers;
private_data->worker.shutdown = shutdown_workers;
private_data->recover_wait_time = WAIT_BEFORE_RECOVER;
private_data->error_escalation_time = private_data->recover_wait_time / 2;
private_data->max_reply_timeouts = 0;
private_data->max_packet_size = AJP13_DEF_PACKET_SIZE;
private_data->sequence = 0;
private_data->next_offset = 0;
*w = &private_data->worker;
JK_TRACE_EXIT(l);
return JK_LB_WORKER_TYPE;
}
else {
JK_LOG_NULL_PARAMS(l);
}
JK_TRACE_EXIT(l);
return 0;
}
tomcat-connectors-1.2.48-src/native/common/jk_ajp12_worker.h 0000644 0000000 0000002 00000003141 13623533443 022250 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: ajpv1.2 worker header file *
* Author: Gal Shachor *
***************************************************************************/
#ifndef JK_AJP12_WORKER_H
#define JK_AJP12_WORKER_H
#include "jk_logger.h"
#include "jk_service.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define JK_AJP12_WORKER_NAME ("ajp12")
#define JK_AJP12_WORKER_TYPE (1)
int JK_METHOD ajp12_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* JK_AJP12_WORKER_H */
tomcat-connectors-1.2.48-src/native/common/jk_ajp14_worker.c 0000644 0000000 0000002 00000024646 13623533443 022262 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: AJP14 next generation Bi-directional protocol. *
* Author: Henri Gomez *
***************************************************************************/
#include "jk_context.h"
#include "jk_ajp14_worker.h"
/*
* AJP14 Autoconf Phase
*
* CONTEXT QUERY / REPLY
*/
#define MAX_URI_SIZE 512
static int handle_discovery(ajp_endpoint_t * ae,
jk_worker_env_t *we,
jk_msg_buf_t *msg, jk_logger_t *l)
{
int cmd;
int i, j;
#if 0
/* Not used for now */
jk_login_service_t *jl = ae->worker->login;
#endif
jk_context_item_t *ci;
jk_context_t *c;
char *buf;
#ifndef TESTME
JK_TRACE_ENTER(l);
ajp14_marshal_context_query_into_msgb(msg, we->virtual, l);
jk_log(l, JK_LOG_DEBUG, "send query");
if (ajp_connection_tcp_send_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "wait context reply");
jk_b_reset(msg);
if (ajp_connection_tcp_get_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if ((cmd = jk_b_get_byte(msg)) != AJP14_CONTEXT_INFO_CMD) {
jk_log(l, JK_LOG_ERROR,
"awaited command %d, received %d",
AJP14_CONTEXT_INFO_CMD, cmd);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (context_alloc(&c, we->virtual) != JK_TRUE) {
jk_log(l, JK_LOG_ERROR,
"can't allocate context room");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (ajp14_unmarshal_context_info(msg, c, l) != JK_TRUE) {
jk_log(l, JK_LOG_ERROR,
"can't get context reply");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "received context");
buf = malloc(MAX_URI_SIZE); /* Really a very long URI */
if (!buf) {
jk_log(l, JK_LOG_ERROR, "can't malloc buf");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
for (i = 0; i < c->size; i++) {
ci = c->contexts[i];
for (j = 0; j < ci->size; j++) {
#ifndef USE_SPRINTF
snprintf(buf, MAX_URI_SIZE - 1, "/%s/%s", ci->cbase, ci->uris[j]);
#else
sprintf(buf, "/%s/%s", ci->cbase, ci->uris[j]);
#endif
jk_log(l, JK_LOG_INFO,
"worker %s will handle uri %s in context %s [%s]",
ae->worker->name, ci->uris[j], ci->cbase, buf);
uri_worker_map_add(we->uri_to_worker, buf, ae->worker->name, SOURCE_TYPE_DISCOVER, l);
}
}
free(buf);
context_free(&c);
#else
uri_worker_map_add(we->uri_to_worker, "/examples/servlet/*",
ae->worker->name, SOURCE_TYPE_DISCOVER, l);
uri_worker_map_add(we->uri_to_worker, "/examples/*.jsp", ae->worker->name,
SOURCE_TYPE_DISCOVER, l);
uri_worker_map_add(we->uri_to_worker, "/examples/*.gif", ae->worker->name,
SOURCE_TYPE_DISCOVER, l);
#endif
JK_TRACE_EXIT(l);
return JK_TRUE;
}
/*
* AJP14 Logon Phase
*
* INIT + REPLY / NEGO + REPLY
*/
static int handle_logon(ajp_endpoint_t * ae,
jk_msg_buf_t *msg, jk_logger_t *l)
{
int cmd;
jk_login_service_t *jl = ae->worker->login;
JK_TRACE_ENTER(l);
ajp14_marshal_login_init_into_msgb(msg, jl, l);
jk_log(l, JK_LOG_DEBUG, "send init");
if (ajp_connection_tcp_send_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "wait init reply");
jk_b_reset(msg);
if (ajp_connection_tcp_get_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if ((cmd = jk_b_get_byte(msg)) != AJP14_LOGSEED_CMD) {
jk_log(l, JK_LOG_ERROR,
"awaited command %d, received %d",
AJP14_LOGSEED_CMD, cmd);
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (ajp14_unmarshal_login_seed(msg, jl, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_log(l, JK_LOG_DEBUG, "received entropy %s",
jl->entropy);
ajp14_compute_md5(jl, l);
if (ajp14_marshal_login_comp_into_msgb(msg, jl, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (ajp_connection_tcp_send_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
jk_b_reset(msg);
if (ajp_connection_tcp_get_message(ae, msg, l) != JK_TRUE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
switch (jk_b_get_byte(msg)) {
case AJP14_LOGOK_CMD:
if (ajp14_unmarshal_log_ok(msg, jl, l) == JK_TRUE) {
jk_log(l, JK_LOG_DEBUG,
"Successfully connected to servlet-engine %s",
jl->servlet_engine_name);
JK_TRACE_EXIT(l);
return JK_TRUE;
}
break;
case AJP14_LOGNOK_CMD:
ajp14_unmarshal_log_nok(msg, l);
break;
}
JK_TRACE_EXIT(l);
return JK_FALSE;
}
static int logon(ajp_endpoint_t * ae, jk_logger_t *l)
{
jk_pool_t *p = &ae->pool;
jk_msg_buf_t *msg;
int rc;
JK_TRACE_ENTER(l);
msg = jk_b_new(p);
jk_b_set_buffer_size(msg, AJP13_DEF_PACKET_SIZE);
if ((rc = handle_logon(ae, msg, l)) == JK_FALSE)
ajp_close_endpoint(ae, l);
JK_TRACE_EXIT(l);
return rc;
}
static int discovery(ajp_endpoint_t * ae, jk_worker_env_t *we, jk_logger_t *l)
{
jk_pool_t *p = &ae->pool;
jk_msg_buf_t *msg;
int rc;
JK_TRACE_ENTER(l);
msg = jk_b_new(p);
jk_b_set_buffer_size(msg, AJP13_DEF_PACKET_SIZE);
if ((rc = handle_discovery(ae, we, msg, l)) == JK_FALSE)
ajp_close_endpoint(ae, l);
JK_TRACE_EXIT(l);
return rc;
}
/* -------------------- Method -------------------- */
static int JK_METHOD validate(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
ajp_worker_t *aw;
const char *secret_key;
JK_TRACE_ENTER(l);
if (ajp_validate(pThis, props, we, l, AJP14_PROTO) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
aw = pThis->worker_private;
secret_key = jk_get_worker_secret_key(props, aw->name);
if ((!secret_key) || (!strlen(secret_key))) {
jk_log(l, JK_LOG_ERROR,
"validate error, empty or missing secretkey");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
/* jk_log(l, JK_LOG_DEBUG, "Into ajp14:validate - secret_key=%s", secret_key); */
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD get_endpoint(jk_worker_t *pThis,
jk_endpoint_t **pend, jk_logger_t *l)
{
int rc;
JK_TRACE_ENTER(l);
rc = ajp_get_endpoint(pThis, pend, l, AJP14_PROTO);
JK_TRACE_EXIT(l);
return rc;
}
static int JK_METHOD init(jk_worker_t *pThis,
jk_map_t *props,
jk_worker_env_t *we, jk_logger_t *l)
{
ajp_worker_t *aw;
ajp_endpoint_t *ae;
jk_endpoint_t *je;
int rc;
JK_TRACE_EXIT(l);
if (ajp_init(pThis, props, we, l, AJP14_PROTO) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
aw = pThis->worker_private;
/* Set Secret Key (used at logon time) */
aw->login->secret_key = jk_get_worker_secret_key(props, aw->name);
if (aw->login->secret_key == NULL) {
jk_log(l, JK_LOG_ERROR, "can't malloc secret_key");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
/* Set WebServerName (used at logon time) */
aw->login->web_server_name = strdup(we->server_name);
if (aw->login->web_server_name == NULL) {
jk_log(l, JK_LOG_ERROR, "can't malloc web_server_name");
JK_TRACE_EXIT(l);
return JK_FALSE;
}
if (get_endpoint(pThis, &je, l) == JK_FALSE) {
JK_TRACE_EXIT(l);
return JK_FALSE;
}
ae = je->endpoint_private;
if (ajp_connect_to_endpoint(ae, l) == JK_TRUE) {
/* connection stage passed - try to get context info
* this is the long awaited autoconf feature :)
*/
rc = discovery(ae, we, l);
ajp_close_endpoint(ae, l);
JK_TRACE_EXIT(l);
return rc;
}
JK_TRACE_EXIT(l);
return JK_TRUE;
}
static int JK_METHOD destroy(jk_worker_t **pThis, jk_logger_t *l)
{
int rc;
ajp_worker_t *aw = (*pThis)->worker_private;
JK_TRACE_ENTER(l);
if (aw->login) {
free(aw->login);
aw->login = NULL;
}
rc = ajp_destroy(pThis, l, AJP14_PROTO);
JK_TRACE_EXIT(l);
return rc;
}
int JK_METHOD ajp14_worker_factory(jk_worker_t **w,
const char *name, jk_logger_t *l)
{
ajp_worker_t *aw;
JK_TRACE_ENTER(l);
if (ajp_worker_factory(w, name, l) == JK_FALSE)
return 0;
aw = (*w)->worker_private;
aw->proto = AJP14_PROTO;
aw->login = (jk_login_service_t *)malloc(sizeof(jk_login_service_t));
if (aw->login == NULL) {
jk_log(l, JK_LOG_ERROR,
"malloc failed for login area");
JK_TRACE_EXIT(l);
return 0;
}
memset(aw->login, 0, sizeof(jk_login_service_t));
aw->login->negotiation =
(AJP14_CONTEXT_INFO_NEG | AJP14_PROTO_SUPPORT_AJP14_NEG);
aw->login->web_server_name = NULL; /* must be set in init */
aw->worker.validate = validate;
aw->worker.init = init;
aw->worker.get_endpoint = get_endpoint;
aw->worker.destroy = destroy;
aw->logon = logon; /* LogOn Handler for AJP14 */
JK_TRACE_EXIT(l);
return JK_AJP14_WORKER_TYPE;
}
tomcat-connectors-1.2.48-src/native/common/ap_snprintf.h 0000644 0000000 0000002 00000013560 13623533443 021607 0 ustar root bin /* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* The ap_vsnprintf/ap_snprintf functions are based on, and used with the
* permission of, the SIO stdio-replacement strx_* functions by Panos
* Tsirigotis for xinetd.
*/
#ifndef APACHE_AP_SNPRINTF_H
#define APACHE_AP_SNPRINTF_H
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
/* stuff marked API_EXPORT is part of the API, and intended for use
* by modules
*/
#ifndef API_EXPORT
#define API_EXPORT(type) type
#endif
/* Stuff marked API_EXPORT_NONSTD is part of the API, and intended for
* use by modules. The difference between API_EXPORT and
* API_EXPORT_NONSTD is that the latter is required for any functions
* which use varargs or are used via indirect function call. This
* is to accomodate the two calling conventions in windows dlls.
*/
#ifndef API_EXPORT_NONSTD
#define API_EXPORT_NONSTD(type) type
#endif
#if !defined(__GNUC__) || __GNUC__ < 2 || \
(__GNUC__ == 2 && __GNUC_MINOR__ < 7) ||\
defined(NEXT)
#define __attribute__(__x)
#endif
/* These macros allow correct support of 8-bit characters on systems which
* support 8-bit characters. Pretty dumb how the cast is required, but
* that's legacy libc for ya. These new macros do not support EOF like
* the standard macros do. Tough.
*/
#define ap_isalpha(c) (isalpha(((unsigned char)(c))))
#define ap_isdigit(c) (isdigit(((unsigned char)(c))))
#define ap_islower(c) (islower(((unsigned char)(c))))
/* ap_vformatter() is a generic printf-style formatting routine
* with some extensions. The extensions are:
*
* %pA takes a struct in_addr *, and prints it as a.b.c.d
* %pI takes a struct sockaddr_in * and prints it as a.b.c.d:port
* %pp takes a void * and outputs it in hex
*
* The %p hacks are to force gcc's printf warning code to skip
* over a pointer argument without complaining. This does
* mean that the ANSI-style %p (output a void * in hex format) won't
* work as expected at all, but that seems to be a fair trade-off
* for the increased robustness of having printf-warnings work.
*
* Additionally, ap_vformatter allows for arbitrary output methods
* using the ap_vformatter_buff and flush_func.
*
* The ap_vformatter_buff has two elements curpos and endpos.
* curpos is where ap_vformatter will write the next byte of output.
* It proceeds writing output to curpos, and updating curpos, until
* either the end of output is reached, or curpos == endpos (i.e. the
* buffer is full).
*
* If the end of output is reached, ap_vformatter returns the
* number of bytes written.
*
* When the buffer is full, the flush_func is called. The flush_func
* can return -1 to indicate that no further output should be attempted,
* and ap_vformatter will return immediately with -1. Otherwise
* the flush_func should flush the buffer in whatever manner is
* appropriate, re-initialize curpos and endpos, and return 0.
*
* Note that flush_func is only invoked as a result of attempting to
* write another byte at curpos when curpos >= endpos. So for
* example, it's possible when the output exactly matches the buffer
* space available that curpos == endpos will be true when
* ap_vformatter returns.
*
* ap_vformatter does not call out to any other code, it is entirely
* self-contained. This allows the callers to do things which are
* otherwise "unsafe". For example, ap_psprintf uses the "scratch"
* space at the unallocated end of a block, and doesn't actually
* complete the allocation until ap_vformatter returns. ap_psprintf
* would be completely broken if ap_vformatter were to call anything
* that used a pool. Similarly http_bprintf() uses the "scratch"
* space at the end of its output buffer, and doesn't actually note
* that the space is in use until it either has to flush the buffer
* or until ap_vformatter returns.
*/
typedef struct {
char *curpos;
char *endpos;
} ap_vformatter_buff;
API_EXPORT(int) ap_vformatter(int (*flush_func)(ap_vformatter_buff *),
ap_vformatter_buff *, const char *fmt, va_list ap);
/* These are snprintf implementations based on ap_vformatter().
*
* Note that various standards and implementations disagree on the return
* value of snprintf, and side-effects due to %n in the formatting string.
* ap_snprintf behaves as follows:
*
* Process the format string until the entire string is exhausted, or
* the buffer fills. If the buffer fills then stop processing immediately
* (so no further %n arguments are processed), and return the buffer
* length. In all cases the buffer is NUL terminated. The return value
* is the number of characters placed in the buffer, excluding the
* terminating NUL. All this implies that, at most, (len-1) characters
* will be copied over; if the return value is >= len, then truncation
* occured.
*
* In no event does ap_snprintf return a negative number.
*/
API_EXPORT_NONSTD(int) ap_snprintf(char *buf, size_t len, const char *format,...)
__attribute__((format(printf,3,4)));
API_EXPORT(int) ap_vsnprintf(char *buf, size_t len, const char *format,
va_list ap);
#ifdef __cplusplus
}
#endif
#endif /* !APACHE_AP_SNPRINTF_H */
tomcat-connectors-1.2.48-src/native/common/jk_types.h.in 0000644 0000000 0000002 00000003730 13623533443 021517 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Platform specific, auto-detected types. *
* Author: Rainer Jung *
***************************************************************************/
#ifndef JK_TYPES_H
#define JK_TYPES_H
/* GENERATED FILE WARNING! DO NOT EDIT jk_types.h
*
* You must modify jk_types.h.in instead.
*
*/
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* jk_uint32_t defines a four byte word */
typedef unsigned @int32_value@ jk_uint32_t;
/* And JK_UINT32_T_FMT */
@uint32_t_fmt@
/* And JK_UINT32_T_HEX_FMT */
@uint32_t_hex_fmt@
/* jk_uint64_t defines a eight byte word */
typedef unsigned @int64_value@ jk_uint64_t;
/* And JK_UINT64_T_FMT */
@uint64_t_fmt@
/* And JK_UINT64_T_HEX_FMT */
@uint64_t_hex_fmt@
/* And JK_PID_T_FMT */
@pid_t_fmt@
/* jk_pthread_t defines a eight byte word */
typedef unsigned @pthread_t_value@ jk_pthread_t;
/* And JK_PTHREAD_T_FMT */
@pthread_t_fmt@
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* JK_TYPES_H */
tomcat-connectors-1.2.48-src/native/common/jk_mt.h 0000644 0000000 0000002 00000010116 13623533443 020362 0 ustar root bin /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************************************
* Description: Multi thread portability code for JK *
* Author: Gal Shachor *
***************************************************************************/
#ifndef _JK_MT_H
#define _JK_MT_H
#include "jk_global.h"
#if defined(WIN32)
#define jk_gettid() ((jk_uint32_t)GetCurrentThreadId())
#endif
#ifdef JK_PREFORK
#define _MT_CODE 0
#else
#define _MT_CODE 1
#endif
/*
* Marks execution under MT compilation
*/
#if _MT_CODE
#ifdef WIN32
#include