AjpMessage (Apache Tomcat 7.0.109 API Documentation)

java.lang.Object
- org.apache.coyote.ajp.AjpMessage

```
public class AjpMessage
extends Object
```
A single packet for communication between the web server and the container. Designed to be reused many times with no creation of garbage. Understands the format of data types for these packets. Can be used (somewhat confusingly) for both incoming and outgoing packets.

Author:

Henri Gomez, Dan Milstein, Keith Wannamaker, Kevin Seguin, Costin Manolache

Field Summary

Fields
Modifier and Type	Field and Description
`protected byte[]`	`buf` Fixed size buffer.
`protected int`	`len` This actually means different things depending on whether the packet is read or write.
`protected int`	`pos` The current read or write position in the buffer.
`protected static StringManager`	`sm` The string manager for this package.

Constructor Summary

Constructors
Constructor and Description

AjpMessage(int packetSize)

Constructors
Constructor and Description
`AjpMessage(int packetSize)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`appendByte(int val)` Append a byte (1 byte) to the message.
`void`	`appendByteChunk(ByteChunk bc)` Write a ByteChunk out at the current write position.
`void`	`appendBytes(byte[] b, int off, int numBytes)` Copy a chunk of bytes into the packet, starting at the current write position.
`void`	`appendBytes(MessageBytes mb)` Write a MessageBytes out at the current write position.
`void`	`appendCharChunk(CharChunk cc)` Write a CharChunk out at the current write position.
`void`	`appendInt(int val)` Add a short integer (2 bytes) to the message.
`void`	`appendString(String str)` Write a String out at the current write position.
`void`	`dump(String msg)` Dump the contents of the message.
`void`	`end()` For a packet to be sent to the web server, finish the process of accumulating data and write the length of the data payload into the header.
`void`	`getBodyBytes(MessageBytes mb)`
`byte[]`	`getBuffer()` Return the underlying byte buffer.
`byte`	`getByte()`
`void`	`getBytes(MessageBytes mb)`
`int`	`getHeaderLength()`
`int`	`getInt()` Read an integer from packet, and advance the read position past it.
`int`	`getLen()` Return the current message length.
`int`	`getLongInt()` Read a 32 bits integer from packet, and advance the read position past it.
`int`	`getPacketSize()`
`protected static String`	`hex(int x)`
`protected static String`	`hexLine(byte[] buf, int start, int len)`
`int`	`peekInt()`
`int`	`processHeader()` Deprecated.
`int`	`processHeader(boolean toContainer)`
`void`	`reset()` Prepare this packet for accumulating a message from the container to the web server.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - sm
```
protected static final StringManager sm
```
    The string manager for this package.
  - buf
```
protected byte[] buf
```
    Fixed size buffer.
  - pos
```
protected int pos
```
    The current read or write position in the buffer.
  - len
```
protected int len
```
    This actually means different things depending on whether the packet is read or write. For read, it's the length of the payload (excluding the header). For write, it's the length of the packet as a whole (counting the header). Oh, well.
- Constructor Detail
  - AjpMessage
```
public AjpMessage(int packetSize)
```
- Method Detail
  - reset
```
public void reset()
```
    Prepare this packet for accumulating a message from the container to the web server. Set the write position to just after the header (but leave the length unwritten, because it is as yet unknown).
  - end
```
public void end()
```
    For a packet to be sent to the web server, finish the process of accumulating data and write the length of the data payload into the header.
  - getBuffer
```
public byte[] getBuffer()
```
    Return the underlying byte buffer.
    
    Returns:
    The buffer
  - getLen
```
public int getLen()
```
    Return the current message length.
    
    Returns:
    For read, it's the length of the payload (excluding the header). For write, it's the length of the packet as a whole (counting the header).
  - appendInt
```
public void appendInt(int val)
```
    Add a short integer (2 bytes) to the message.
    
    Parameters:
    val - The integer to append
  - appendByte
```
public void appendByte(int val)
```
    Append a byte (1 byte) to the message.
    
    Parameters:
    val - The byte value to append
  - appendBytes
```
public void appendBytes(MessageBytes mb)
```
    Write a MessageBytes out at the current write position. A null MessageBytes is encoded as a string with length 0.
    
    Parameters:
    mb - The data to write
  - appendByteChunk
```
public void appendByteChunk(ByteChunk bc)
```
    Write a ByteChunk out at the current write position. A null ByteChunk is encoded as a string with length 0.
    
    Parameters:
    bc - The data to write
  - appendCharChunk
```
public void appendCharChunk(CharChunk cc)
```
    Write a CharChunk out at the current write position. A null CharChunk is encoded as a string with length 0.
    
    Parameters:
    cc - The data to write
  - appendString
```
public void appendString(String str)
```
    Write a String out at the current write position. Strings are encoded with the length in two bytes first, then the string, and then a terminating \0 (which is not included in the encoded length). The terminator is for the convenience of the C code, where it saves a round of copying. A null string is encoded as a string with length 0.
    
    Parameters:
    str - The String to append
  - appendBytes
```
public void appendBytes(byte[] b,
               int off,
               int numBytes)
```
    Copy a chunk of bytes into the packet, starting at the current write position. The chunk of bytes is encoded with the length in two bytes first, then the data itself, and finally a terminating \0 (which is not included in the encoded length).
    
    Parameters:
    b - The array from which to copy bytes.
    off - The offset into the array at which to start copying
    numBytes - The number of bytes to copy.
  - getInt
```
public int getInt()
```
    Read an integer from packet, and advance the read position past it. Integers are encoded as two unsigned bytes with the high-order byte first, and, as far as I can tell, in little-endian order within each byte.
    
    Returns:
    The integer value read from the message
  - peekInt
```
public int peekInt()
```
  - getByte
```
public byte getByte()
```
  - getBytes
```
public void getBytes(MessageBytes mb)
```
  - getBodyBytes
```
public void getBodyBytes(MessageBytes mb)
```
  - getLongInt
```
public int getLongInt()
```
    Read a 32 bits integer from packet, and advance the read position past it. Integers are encoded as four unsigned bytes with the high-order byte first, and, as far as I can tell, in little-endian order within each byte.
    
    Returns:
    The long value read from the message
  - getHeaderLength
```
public int getHeaderLength()
```
  - getPacketSize
```
public int getPacketSize()
```
  - processHeader
```
@Deprecated
public int processHeader()
```
    Deprecated.
  - processHeader
```
public int processHeader(boolean toContainer)
```
  - dump
```
public void dump(String msg)
```
    Dump the contents of the message.
    
    Parameters:
    msg - The message to write
  - hexLine
```
protected static String hexLine(byte[] buf,
             int start,
             int len)
```
  - hex
```
protected static String hex(int x)
```

Class AjpMessage

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

sm

buf

pos

len

Constructor Detail

AjpMessage

Method Detail

reset

end

getBuffer

getLen

appendInt

appendByte

appendBytes

appendByteChunk

appendCharChunk

appendString

appendBytes

getInt

peekInt

getByte

getBytes

getBodyBytes

getLongInt

getHeaderLength

getPacketSize

processHeader

processHeader

dump

hexLine

hex