📄 ajpaprprocessor.java
字号:
for (int i = 0; i < valueL; i++) {
char b = (char) valueB[i + valueS];
hostNameC[i] = b;
if (b == ']') {
bracketClosed = true;
} else if (b == ':') {
if (!ipv6 || bracketClosed) {
colonPos = i;
break;
}
}
}
if (colonPos < 0) {
if (request.scheme().equalsIgnoreCase("https")) {
// 443 - Default HTTPS port
request.setServerPort(443);
} else {
// 80 - Default HTTTP port
request.setServerPort(80);
}
request.serverName().setChars(hostNameC, 0, valueL);
} else {
request.serverName().setChars(hostNameC, 0, colonPos);
int port = 0;
int mult = 1;
for (int i = valueL - 1; i > colonPos; i--) {
int charValue = HexUtils.DEC[(int) valueB[i + valueS]];
if (charValue == -1) {
// Invalid character
error = true;
// 400 - Bad request
response.setStatus(400);
break;
}
port = port + (charValue * mult);
mult = 10 * mult;
}
request.setServerPort(port);
}
}
/**
* When committing the response, we have to validate the set of headers, as
* well as setup the response filters.
*/
protected void prepareResponse()
throws IOException {
response.setCommitted(true);
responseHeaderMessage.reset();
responseHeaderMessage.appendByte(Constants.JK_AJP13_SEND_HEADERS);
// HTTP header contents
responseHeaderMessage.appendInt(response.getStatus());
String message = response.getMessage();
if (message == null){
message = HttpMessages.getMessage(response.getStatus());
} else {
message = message.replace('\n', ' ').replace('\r', ' ');
}
tmpMB.setString(message);
responseHeaderMessage.appendBytes(tmpMB);
// Special headers
MimeHeaders headers = response.getMimeHeaders();
String contentType = response.getContentType();
if (contentType != null) {
headers.setValue("Content-Type").setString(contentType);
}
String contentLanguage = response.getContentLanguage();
if (contentLanguage != null) {
headers.setValue("Content-Language").setString(contentLanguage);
}
int contentLength = response.getContentLength();
if (contentLength >= 0) {
headers.setValue("Content-Length").setInt(contentLength);
}
// Other headers
int numHeaders = headers.size();
responseHeaderMessage.appendInt(numHeaders);
for (int i = 0; i < numHeaders; i++) {
MessageBytes hN = headers.getName(i);
int hC = Constants.getResponseAjpIndex(hN.toString());
if (hC > 0) {
responseHeaderMessage.appendInt(hC);
}
else {
responseHeaderMessage.appendBytes(hN);
}
MessageBytes hV=headers.getValue(i);
responseHeaderMessage.appendBytes(hV);
}
// Write to buffer
responseHeaderMessage.end();
outputBuffer.put(responseHeaderMessage.getBuffer(), 0, responseHeaderMessage.getLen());
}
/**
* Finish AJP response.
*/
protected void finish()
throws IOException {
if (!response.isCommitted()) {
// Validate and write response headers
try {
prepareResponse();
} catch (IOException e) {
// Set error flag
error = true;
}
}
if (finished)
return;
finished = true;
// Add the end message
if (outputBuffer.position() + endMessageArray.length > outputBuffer.capacity()) {
flush();
}
outputBuffer.put(endMessageArray);
flush();
}
/**
* Read at least the specified amount of bytes, and place them
* in the input buffer.
*/
protected boolean read(int n)
throws IOException {
if (inputBuffer.capacity() - inputBuffer.limit() <=
n - inputBuffer.remaining()) {
inputBuffer.compact();
inputBuffer.limit(inputBuffer.position());
inputBuffer.position(0);
}
int nRead;
while (inputBuffer.remaining() < n) {
nRead = Socket.recvbb
(socket, inputBuffer.limit(),
inputBuffer.capacity() - inputBuffer.limit());
if (nRead > 0) {
inputBuffer.limit(inputBuffer.limit() + nRead);
} else {
throw new IOException(sm.getString("ajpprotocol.failedread"));
}
}
return true;
}
/**
* Read at least the specified amount of bytes, and place them
* in the input buffer.
*/
protected boolean readt(int n, boolean useAvailableData)
throws IOException {
if (useAvailableData && inputBuffer.remaining() == 0) {
return false;
}
if (inputBuffer.capacity() - inputBuffer.limit() <=
n - inputBuffer.remaining()) {
inputBuffer.compact();
inputBuffer.limit(inputBuffer.position());
inputBuffer.position(0);
}
int nRead;
while (inputBuffer.remaining() < n) {
if (readTimeout > 0) {
nRead = Socket.recvbbt
(socket, inputBuffer.limit(),
inputBuffer.capacity() - inputBuffer.limit(), readTimeout);
} else {
nRead = Socket.recvbb
(socket, inputBuffer.limit(),
inputBuffer.capacity() - inputBuffer.limit());
}
if (nRead > 0) {
inputBuffer.limit(inputBuffer.limit() + nRead);
} else {
if ((-nRead) == Status.ETIMEDOUT || (-nRead) == Status.TIMEUP) {
return false;
} else {
throw new IOException(sm.getString("ajpprotocol.failedread"));
}
}
}
return true;
}
/** Receive a chunk of data. Called to implement the
* 'special' packet in ajp13 and to receive the data
* after we send a GET_BODY packet
*/
public boolean receive() throws IOException {
first = false;
bodyMessage.reset();
readMessage(bodyMessage, false, false);
// No data received.
if (bodyMessage.getLen() == 0) {
// just the header
// Don't mark 'end of stream' for the first chunk.
return false;
}
int blen = bodyMessage.peekInt();
if (blen == 0) {
return false;
}
bodyMessage.getBytes(bodyBytes);
empty = false;
return true;
}
/**
* Get more request body data from the web server and store it in the
* internal buffer.
*
* @return true if there is more data, false if not.
*/
private boolean refillReadBuffer() throws IOException {
// If the server returns an empty packet, assume that that end of
// the stream has been reached (yuck -- fix protocol??).
// FORM support
if (replay) {
endOfStream = true; // we've read everything there is
}
if (endOfStream) {
return false;
}
// Request more data immediately
Socket.sendb(socket, getBodyMessageBuffer, 0,
getBodyMessageBuffer.position());
boolean moreData = receive();
if( !moreData ) {
endOfStream = true;
}
return moreData;
}
/**
* Read an AJP message.
*
* @param first is true if the message is the first in the request, which
* will cause a short duration blocking read
* @return true if the message has been read, false if the short read
* didn't return anything
* @throws IOException any other failure, including incomplete reads
*/
protected boolean readMessage(AjpMessage message, boolean first,
boolean useAvailableData)
throws IOException {
byte[] buf = message.getBuffer();
int headerLength = message.getHeaderLength();
if (first) {
if (!readt(headerLength, useAvailableData)) {
return false;
}
} else {
read(headerLength);
}
inputBuffer.get(message.getBuffer(), 0, headerLength);
message.processHeader();
read(message.getLen());
inputBuffer.get(message.getBuffer(), headerLength, message.getLen());
return true;
}
/**
* Recycle the processor.
*/
public void recycle() {
// Recycle Request object
first = true;
endOfStream = false;
empty = true;
replay = false;
finished = false;
request.recycle();
response.recycle();
certificates.recycle();
inputBuffer.clear();
inputBuffer.limit(0);
outputBuffer.clear();
}
/**
* Callback to write data from the buffer.
*/
protected void flush()
throws IOException {
if (outputBuffer.position() > 0) {
if (Socket.sendbb(socket, 0, outputBuffer.position()) < 0) {
throw new IOException(sm.getString("ajpprocessor.failedsend"));
}
outputBuffer.clear();
}
}
// ------------------------------------- InputStreamInputBuffer Inner Class
/**
* This class is an input buffer which will read its data from an input
* stream.
*/
protected class SocketInputBuffer
implements InputBuffer {
/**
* Read bytes into the specified chunk.
*/
public int doRead(ByteChunk chunk, Request req )
throws IOException {
if (endOfStream) {
return -1;
}
if (first && req.getContentLength() > 0) {
// Handle special first-body-chunk
if (!receive()) {
return 0;
}
} else if (empty) {
if (!refillReadBuffer()) {
return -1;
}
}
ByteChunk bc = bodyBytes.getByteChunk();
chunk.setBytes(bc.getBuffer(), bc.getStart(), bc.getLength());
empty = true;
return chunk.getLength();
}
}
// ----------------------------------- OutputStreamOutputBuffer Inner Class
/**
* This class is an output buffer which will write data to an output
* stream.
*/
protected class SocketOutputBuffer
implements OutputBuffer {
/**
* Write chunk.
*/
public int doWrite(ByteChunk chunk, Response res)
throws IOException {
if (!response.isCommitted()) {
// Validate and write response headers
try {
prepareResponse();
} catch (IOException e) {
// Set error flag
error = true;
}
}
int len = chunk.getLength();
// 4 - hardcoded, byte[] marshalling overhead
int chunkSize = Constants.MAX_SEND_SIZE;
int off = 0;
while (len > 0) {
int thisTime = len;
if (thisTime > chunkSize) {
thisTime = chunkSize;
}
len -= thisTime;
if (outputBuffer.position() + thisTime +
Constants.H_SIZE + 4 > outputBuffer.capacity()) {
flush();
}
outputBuffer.put((byte) 0x41);
outputBuffer.put((byte) 0x42);
outputBuffer.putShort((short) (thisTime + 4));
outputBuffer.put(Constants.JK_AJP13_SEND_BODY_CHUNK);
outputBuffer.putShort((short) thisTime);
outputBuffer.put(chunk.getBytes(), chunk.getOffset() + off, thisTime);
outputBuffer.put((byte) 0x00);
off += thisTime;
}
return chunk.getLength();
}
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -