static void toHexString(String header, ByteBuffer buf) {
sb.delete(0, sb.length());
for (int index = 0; index < buf.limit(); index++) {
String hex = Integer.toHexString(0x0100 + (buf.get(index) & 0x00FF)).substring(1);
sb.append((hex.length() < 2 ? "0" : "") + hex + " ");
}
LOG.debug(
"hex->"
+ header
+ ": position,limit,capacity "
+ buf.position()
+ ","
+ buf.limit()
+ ","
+ buf.capacity());
LOG.debug("hex->" + sb.toString());
}
void isReadable(SelectionKey k) {
EventableChannel ec = (EventableChannel) k.attachment();
long b = ec.getBinding();
if (ec.isWatchOnly()) {
if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null);
} else {
myReadBuffer.clear();
try {
ec.readInboundData(myReadBuffer);
myReadBuffer.flip();
if (myReadBuffer.limit() > 0) {
if (ProxyConnections != null) {
EventableChannel target = ProxyConnections.get(b);
if (target != null) {
ByteBuffer myWriteBuffer = ByteBuffer.allocate(myReadBuffer.limit());
myWriteBuffer.put(myReadBuffer);
myWriteBuffer.flip();
target.scheduleOutboundData(myWriteBuffer);
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
}
} catch (IOException e) {
UnboundConnections.add(b);
}
}
}
/**
* sends data from buffer.
*
* <p>precondition: sendbb is in put mode post condition: sendbb is in put mode
*/
private void sendFromBuffer() {
aa(this, isSender(), "nonsender can't write");
aa(this, isConnected() || isClosurePending(), "needs to be established can't write");
// switch sendbb to get mode
sendbb.flip();
p(this, 3, "Sending from buffer. bb flipped.");
int payloadLength = Math.min(Transport.MAX_PAYLOAD_SIZE, sendbb.limit());
p(this, 4, "Max Payload size: " + Transport.MAX_PAYLOAD_SIZE);
p(this, 4, "payloadlen: " + payloadLength);
dumpState(4);
if (roomForPacket(payloadLength) && payloadLength > 0) {
byte[] payload = new byte[payloadLength];
sendbb.get(payload);
Transport t = makeTransport(Transport.DATA, seqNum, payload);
tcpMan.sendData(this.tsid, t);
p(this, 3, "Write: converting to packet: " + TCPManager.bytesToString(payload));
// only increment the seqNum if a packet is sent
seqNum += payloadLength;
}
// switch back to put mode
sendbb.compact();
dumpState(4);
if (isClosurePending() && sendbb.position() == 0) release();
}
static void printBBInfo(ByteBuffer buf) {
LOG.debug(
"Info : position,limit,capacity "
+ buf.position()
+ ","
+ buf.limit()
+ ","
+ buf.capacity());
}
public static void runTests() {
try {
// SHA1 sha1Jmule = new SHA1();
MessageDigest sha1Sun = MessageDigest.getInstance("SHA-1");
SHA1 sha1Gudy = new SHA1();
// SHA1Az shaGudyResume = new SHA1Az();
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
File dir = new File(dirname);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; i++) {
FileChannel fc = new RandomAccessFile(files[i], "r").getChannel();
System.out.println("Testing " + files[i].getName() + " ...");
while (fc.position() < fc.size()) {
fc.read(buffer);
buffer.flip();
byte[] raw = new byte[buffer.limit()];
System.arraycopy(buffer.array(), 0, raw, 0, raw.length);
sha1Gudy.update(buffer);
sha1Gudy.saveState();
ByteBuffer bb = ByteBuffer.wrap(new byte[56081]);
sha1Gudy.digest(bb);
sha1Gudy.restoreState();
sha1Sun.update(raw);
buffer.clear();
}
byte[] sun = sha1Sun.digest();
sha1Sun.reset();
byte[] gudy = sha1Gudy.digest();
sha1Gudy.reset();
if (Arrays.equals(sun, gudy)) {
System.out.println(" SHA1-Gudy: OK");
} else {
System.out.println(" SHA1-Gudy: FAILED");
}
buffer.clear();
fc.close();
System.out.println();
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
/**
* Read from the socket up to len bytes into the buffer buf starting at position pos.
*
* @param buf byte[] the buffer
* @param pos int starting position in buffer
* @param len int number of bytes to read
* @return int on success, the number of bytes read, which may be smaller than len; on failure, -1
*/
public int read(byte[] buf, int pos, int len) {
aa(this, isReceiver(), "nonreceiver socket reading");
aa(this, state == State.ESTABLISHED, "attempting to read from closed socket");
recvbb.flip();
int bytesCopied = Math.min(recvbb.limit(), len);
recvbb.get(buf, pos, bytesCopied);
recvbb.compact();
return bytesCopied;
}
static void testMixed(Charset cs) throws Throwable {
CharsetDecoder dec =
cs.newDecoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
CharsetEncoder enc =
cs.newEncoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
List<Integer> cps = new ArrayList<>(0x10000);
int off = 0;
int cp = 0;
while (cp < 0x10000) {
if (enc.canEncode((char) cp)) {
cps.add(cp);
}
cp++;
}
Collections.shuffle(cps);
char[] bmpCA = new char[cps.size()];
for (int i = 0; i < cps.size(); i++) bmpCA[i] = (char) (int) cps.get(i);
String bmpStr = new String(bmpCA);
// getBytes(csn);
byte[] bmpBA = bmpStr.getBytes(cs.name());
ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
byte[] baNIO = new byte[bf.limit()];
bf.get(baNIO, 0, baNIO.length);
if (!Arrays.equals(bmpBA, baNIO)) {
throw new RuntimeException("getBytes(csn) failed -> " + cs.name());
}
// getBytes(cs);
bmpBA = bmpStr.getBytes(cs);
if (!Arrays.equals(bmpBA, baNIO))
throw new RuntimeException("getBytes(cs) failed -> " + cs.name());
// new String(csn);
String strSC = new String(bmpBA, cs.name());
String strNIO = dec.reset().decode(ByteBuffer.wrap(bmpBA)).toString();
if (!strNIO.equals(strSC)) {
throw new RuntimeException("new String(csn) failed -> " + cs.name());
}
// new String(cs);
strSC = new String(bmpBA, cs);
if (!strNIO.equals(strSC)) throw new RuntimeException("new String(cs) failed -> " + cs.name());
}
void isReadable(SelectionKey k) {
EventableChannel ec = (EventableChannel) k.attachment();
long b = ec.getBinding();
if (ec.isWatchOnly()) {
if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null);
} else {
myReadBuffer.clear();
try {
ec.readInboundData(myReadBuffer);
myReadBuffer.flip();
if (myReadBuffer.limit() > 0) eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
} catch (IOException e) {
UnboundConnections.add(b);
}
}
}
private synchronized DBMessage go(DBMessage msg, ByteDecoder decoder) throws IOException {
if (_sock == null) _open();
{
ByteBuffer out = msg.prepare();
while (out.remaining() > 0) _sock.write(out);
}
if (_pool != null) _pool._everWorked = true;
if (decoder == null) return null;
ByteBuffer response = decoder._buf;
if (response.position() != 0) throw new IllegalArgumentException();
int read = 0;
while (read < DBMessage.HEADER_LENGTH) read += _read(response);
int len = response.getInt(0);
if (len <= DBMessage.HEADER_LENGTH)
throw new IllegalArgumentException("db sent invalid length: " + len);
if (len > response.capacity())
throw new IllegalArgumentException(
"db message size is too big (" + len + ") " + "max is (" + response.capacity() + ")");
response.limit(len);
while (read < len) read += _read(response);
if (read != len) throw new RuntimeException("something is wrong");
response.flip();
return new DBMessage(response);
}
private void readMessage(SelectionKey sk, SocketChannel readChannel, TcpAddress incomingAddress)
throws IOException {
// note that socket has been used
SocketEntry entry = (SocketEntry) sockets.get(incomingAddress);
if (entry != null) {
entry.used();
ByteBuffer readBuffer = entry.getReadBuffer();
if (readBuffer != null) {
readChannel.read(readBuffer);
if (readBuffer.hasRemaining()) {
readChannel.register(selector, SelectionKey.OP_READ, entry);
} else {
dispatchMessage(incomingAddress, readBuffer, readBuffer.capacity());
}
return;
}
}
ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
byteBuffer.limit(messageLengthDecoder.getMinHeaderLength());
long bytesRead = readChannel.read(byteBuffer);
if (logger.isDebugEnabled()) {
logger.debug("Reading header " + bytesRead + " bytes from " + incomingAddress);
}
MessageLength messageLength = new MessageLength(0, Integer.MIN_VALUE);
if (bytesRead == messageLengthDecoder.getMinHeaderLength()) {
messageLength = messageLengthDecoder.getMessageLength(ByteBuffer.wrap(buf));
if (logger.isDebugEnabled()) {
logger.debug("Message length is " + messageLength);
}
if ((messageLength.getMessageLength() > getMaxInboundMessageSize())
|| (messageLength.getMessageLength() <= 0)) {
logger.error(
"Received message length "
+ messageLength
+ " is greater than inboundBufferSize "
+ getMaxInboundMessageSize());
synchronized (entry) {
entry.getSocket().close();
logger.info("Socket to " + entry.getPeerAddress() + " closed due to an error");
}
} else {
byteBuffer.limit(messageLength.getMessageLength());
bytesRead += readChannel.read(byteBuffer);
if (bytesRead == messageLength.getMessageLength()) {
dispatchMessage(incomingAddress, byteBuffer, bytesRead);
} else {
byte[] message = new byte[byteBuffer.limit()];
byteBuffer.flip();
byteBuffer.get(message, 0, byteBuffer.limit() - byteBuffer.remaining());
entry.setReadBuffer(ByteBuffer.wrap(message));
}
readChannel.register(selector, SelectionKey.OP_READ, entry);
}
} else if (bytesRead < 0) {
logger.debug("Socket closed remotely");
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
null);
fireConnectionStateChanged(e);
}
}
static void test(Charset cs, char[] bmpCA, byte[] sbBA) throws Throwable {
String bmpStr = new String(bmpCA);
CharsetDecoder dec =
cs.newDecoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
CharsetEncoder enc =
cs.newEncoder()
.onMalformedInput(CodingErrorAction.REPLACE)
.onUnmappableCharacter(CodingErrorAction.REPLACE);
// getBytes(csn);
byte[] baSC = bmpStr.getBytes(cs.name());
ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
byte[] baNIO = new byte[bf.limit()];
bf.get(baNIO, 0, baNIO.length);
if (!Arrays.equals(baSC, baNIO))
throw new RuntimeException("getBytes(csn) failed -> " + cs.name());
// getBytes(cs);
baSC = bmpStr.getBytes(cs);
if (!Arrays.equals(baSC, baNIO))
throw new RuntimeException("getBytes(cs) failed -> " + cs.name());
// new String(csn);
String strSC = new String(sbBA, cs.name());
String strNIO = dec.reset().decode(ByteBuffer.wrap(sbBA)).toString();
if (!strNIO.equals(strSC))
throw new RuntimeException("new String(csn) failed -> " + cs.name());
// new String(cs);
strSC = new String(sbBA, cs);
if (!strNIO.equals(strSC)) throw new RuntimeException("new String(cs) failed -> " + cs.name());
// encode unmappable surrogates
if (enc instanceof sun.nio.cs.ArrayEncoder && cs.contains(Charset.forName("ASCII"))) {
if (cs.name().equals("UTF-8")
|| // utf8 handles surrogates
cs.name().equals("CESU-8")) // utf8 handles surrogates
return;
enc.replaceWith(new byte[] {(byte) 'A'});
sun.nio.cs.ArrayEncoder cae = (sun.nio.cs.ArrayEncoder) enc;
String str = "ab\uD800\uDC00\uD800\uDC00cd";
byte[] ba = new byte[str.length() - 2];
int n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 6 || !"abAAcd".equals(new String(ba, cs.name())))
throw new RuntimeException("encode1(surrogates) failed -> " + cs.name());
ba = new byte[str.length()];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 6 || !"abAAcd".equals(new String(ba, 0, n, cs.name())))
throw new RuntimeException("encode2(surrogates) failed -> " + cs.name());
str = "ab\uD800B\uDC00Bcd";
ba = new byte[str.length()];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 8 || !"abABABcd".equals(new String(ba, 0, n, cs.name())))
throw new RuntimeException("encode3(surrogates) failed -> " + cs.name());
/* sun.nio.cs.ArrayDeEncoder works on the assumption that the
invoker (StringCoder) allocates enough output buf, utf8
and double-byte coder does not check the output buffer limit.
ba = new byte[str.length() - 1];
n = cae.encode(str.toCharArray(), 0, str.length(), ba);
if (n != 7 || !"abABABc".equals(new String(ba, 0, n, cs.name()))) {
throw new RuntimeException("encode4(surrogates) failed -> "
+ cs.name());
}
*/
}
}
/**
* method to extract the next monitor entry from the instrumentation memory. assumes that
* nextEntry is the offset into the byte array at which to start the search for the next entry.
* method leaves next entry pointing to the next entry or to the end of data.
*/
protected Monitor getNextMonitorEntry() throws MonitorException {
Monitor monitor = null;
// entries are always 4 byte aligned.
if ((nextEntry % 4) != 0) {
throw new MonitorStructureException("Entry index not properly aligned: " + nextEntry);
}
// protect against a corrupted shared memory region.
if ((nextEntry < 0) || (nextEntry > buffer.limit())) {
throw new MonitorStructureException(
"Entry index out of bounds: nextEntry = " + nextEntry + ", limit = " + buffer.limit());
}
// check for the end of the buffer
if (nextEntry == buffer.limit()) {
lognl("getNextMonitorEntry():" + " nextEntry == buffer.limit(): returning");
return null;
}
buffer.position(nextEntry);
int entryStart = buffer.position();
int entryLength = buffer.getInt();
// check for valid entry length
if ((entryLength < 0) || (entryLength > buffer.limit())) {
throw new MonitorStructureException("Invalid entry length: entryLength = " + entryLength);
}
// check if last entry occurs before the eof.
if ((entryStart + entryLength) > buffer.limit()) {
throw new MonitorStructureException(
"Entry extends beyond end of buffer: "
+ " entryStart = "
+ entryStart
+ " entryLength = "
+ entryLength
+ " buffer limit = "
+ buffer.limit());
}
if (entryLength == 0) {
// end of data
return null;
}
int nameLength = buffer.getInt();
int vectorLength = buffer.getInt();
byte dataType = buffer.get();
byte flags = buffer.get();
Units u = Units.toUnits(buffer.get());
Variability v = Variability.toVariability(buffer.get());
boolean supported = (flags & 0x01) != 0;
// defend against corrupt entries
if ((nameLength <= 0) || (nameLength > entryLength)) {
throw new MonitorStructureException("Invalid Monitor name length: " + nameLength);
}
if ((vectorLength < 0) || (vectorLength > entryLength)) {
throw new MonitorStructureException("Invalid Monitor vector length: " + vectorLength);
}
// read in the perfData item name, casting bytes to chars. skip the
// null terminator
//
byte[] nameBytes = new byte[nameLength - 1];
for (int i = 0; i < nameLength - 1; i++) {
nameBytes[i] = buffer.get();
}
// convert name into a String
String name = new String(nameBytes, 0, nameLength - 1);
if (v == Variability.INVALID) {
throw new MonitorDataException(
"Invalid variability attribute:" + " entry index = " + perfDataItem + " name = " + name);
}
if (u == Units.INVALID) {
throw new MonitorDataException(
"Invalid units attribute: " + " entry index = " + perfDataItem + " name = " + name);
}
int offset;
if (vectorLength == 0) {
// scalar Types
if (dataType == BasicType.LONG.intValue()) {
offset = entryStart + entryLength - 8; /* 8 = sizeof(long) */
buffer.position(offset);
LongBuffer lb = buffer.asLongBuffer();
lb.limit(1);
monitor = new PerfLongMonitor(name, u, v, supported, lb);
perfDataItem++;
} else {
// bad data types.
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
} else {
// vector types
if (dataType == BasicType.BYTE.intValue()) {
if (u != Units.STRING) {
// only byte arrays of type STRING are currently supported
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
offset = entryStart + PERFDATA_NAME_OFFSET + nameLength;
buffer.position(offset);
ByteBuffer bb = buffer.slice();
bb.limit(vectorLength);
bb.position(0);
if (v == Variability.CONSTANT) {
monitor = new PerfStringConstantMonitor(name, supported, bb);
} else if (v == Variability.VARIABLE) {
monitor = new PerfStringVariableMonitor(name, supported, bb, vectorLength - 1);
} else {
// Monotonically increasing byte arrays are not supported
throw new MonitorDataException(
"Invalid variability attribute:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " variability = "
+ v);
}
perfDataItem++;
} else {
// bad data types.
throw new MonitorTypeException(
"Invalid Monitor type:"
+ " entry index = "
+ perfDataItem
+ " name = "
+ name
+ " type = "
+ dataType);
}
}
// setup index to next entry for next iteration of the loop.
nextEntry = entryStart + entryLength;
return monitor;
}