@Override
protected boolean doDecode(IoSession arg0, IoBuffer arg1, ProtocolDecoderOutput arg2)
throws Exception {
if (arg1.remaining() >= 8) {
arg1.mark();
HubMessage message = new HubMessage();
int type = arg1.getInt();
int length = arg1.getInt();
if (length != 0) {
if (arg1.remaining() >= length) {
message.setMessageType(type);
message.setMessageLength(length);
byte extendedData[] = new byte[length];
arg1.get(extendedData);
message.setExtendedData(extendedData);
arg2.write(message);
return true;
} else {
arg1.reset();
return false;
}
} else {
message.setMessageType(type);
message.setMessageLength(length);
arg2.write(message);
return true;
}
}
return false;
}
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
DecoderState decoderState = (DecoderState) session.getAttribute(DECODER_STATE_KEY);
if (decoderState == null) {
decoderState = new DecoderState();
session.setAttribute(DECODER_STATE_KEY, decoderState);
}
if (decoderState.image1 == null) {
// try to read first image
if (in.prefixedDataAvailable(4, MAX_IMAGE_SIZE)) {
decoderState.image1 = readImage(in);
} else {
// not enough data available to read first image
return false;
}
}
if (decoderState.image1 != null) {
// try to read second image
if (in.prefixedDataAvailable(4, MAX_IMAGE_SIZE)) {
BufferedImage image2 = readImage(in);
ImageResponse imageResponse = new ImageResponse(decoderState.image1, image2);
out.write(imageResponse);
decoderState.image1 = null;
return true;
} else {
// not enough data available to read second image
return false;
}
}
return false;
}
@Override
protected DecodingState finishDecode(List<Object> childProducts, ProtocolDecoderOutput out)
throws Exception {
for (Object child : childProducts) {
MutableHttpResponse response = (MutableHttpResponse) child;
String beanName = response.getHeader(Constants.HTTP_HEADER_BEANNAME);
String methodName = response.getHeader(Constants.HTTP_HEADER_METHOD);
String sequence = response.getHeader(Constants.HTTP_HEADER_SEQ);
IoBuffer content = response.getContent();
out.write(beanName);
out.write(methodName);
out.write(Integer.parseInt(sequence));
out.write(new IoBufferInputStream(content));
}
return null;
}
@Override
protected DecodingState finishDecode(boolean foundCRLF, ProtocolDecoderOutput out)
throws Exception {
if (foundCRLF) {
out.write(headers);
return null;
} else {
return READ_HEADER_NAME;
}
}
/** 解码 */
public void decode(IoSession session, IoBuffer buf, ProtocolDecoderOutput out) throws Exception {
IoBuffer allBuf = IoBuffer.allocate(100).setAutoExpand(true);
while (buf.hasRemaining()) {
byte b = buf.get();
System.out.println("b:" + b);
allBuf.put(b);
}
MinaProtocol protocol = null;
// 获取协议tag
// byte tag=buf.get();
// 获取协议体长度
int length = buf.getInt();
// 取出协议体
byte[] bodyData = new byte[length];
buf.get(bodyData);
// 为解析数据做准备
// 检测协议
IoBuffer tempBuf = IoBuffer.allocate(100).setAutoExpand(true);
// tempBuf.put(tag);
tempBuf.putInt(length);
tempBuf.put(bodyData);
tempBuf.flip();
if (!canDecode(tempBuf)) {
return;
}
// 协议体buf
IoBuffer bodyBuf = IoBuffer.allocate(100).setAutoExpand(true);
bodyBuf.put(bodyData);
bodyBuf.flip();
// 整个协议buf
// allBuf.put(tag);
allBuf.putInt(length);
allBuf.put(bodyData);
allBuf.flip();
//
// if(tag == Constant.REQ) {
// JMessageProtocolReq req=new JMessageProtocolReq();
// short functionCode=bodyBuf.getShort();
// String content=bodyBuf.getString(charset.newDecoder());
// req.setFunctionCode(functionCode);
// req.setContent(content);
// protocol=req;
// } else if(tag == Constant.RES) {
// JMessageProtocolRes res=new JMessageProtocolRes();
// byte resultCode=bodyBuf.get();
// String content=bodyBuf.getString(charset.newDecoder());
// res.setResultCode(resultCode);
// res.setContent(content);
// protocol=res;
// } else {
// LOG.error("未定义的Tag");
// }
out.write(protocol);
}
@Override
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) {
// Get the state of the current message and
// Skip what we have already scanned
DecoderState state = decoderState(session);
in.position(state.current());
while (in.hasRemaining()) {
byte current = in.get();
// If it is the start byte and mark the position
if (current == config.getStartByte()) {
state.markStart(in.position() - 1);
}
// If it is the end bytes, extract the payload and return
if (state.previous() == config.getEndByte1() && current == config.getEndByte2()) {
// Remember the current position and limit.
int position = in.position();
int limit = in.limit();
LOG.debug("Message ends at position {} with length {}", position, position - state.start());
try {
in.position(state.start());
in.limit(position);
// The bytes between in.position() and in.limit()
// now contain a full MLLP message including the
// start and end bytes.
out.write(
config.isProduceString()
? parseMessageToString(in.slice(), charsetDecoder(session))
: parseMessageToByteArray(in.slice()));
} catch (CharacterCodingException cce) {
throw new IllegalArgumentException("Exception while finalizing the message", cce);
} finally {
// Reset position, limit, and state
in.limit(limit);
in.position(position);
state.reset();
}
return true;
}
// Remember previous byte in state object because the buffer could
// be theoretically exhausted right between the two end bytes
state.markPrevious(current);
}
// Could not find a complete message in the buffer.
// Reset to the initial position and return false so that this method
// is called again with more data.
LOG.debug("No complete message yet at position {} ", in.position());
state.markCurrent(in.position());
in.position(0);
return false;
}
@Override
public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
LOG.info("decode invoked with buffer {}", in);
in.reset();
int startPos = in.markValue();
// Common decoding part
PublishMessage message = new PublishMessage();
if (!decodeCommonHeader(message, in)) {
LOG.info("decode ask for more data after {}", in);
in.reset();
return;
}
if (((int) session.getAttribute(MQTTDecoder.PROTOCOL_VERSION)) == MQTTProtocol.VERSION_3_1_1) {
if (message.getQos() == AbstractMessage.QOSType.MOST_ONE && message.isDupFlag()) {
// bad protocol, if QoS=0 => DUP = 0
throw new CorruptedFrameException(
"Received a PUBLISH with QoS=0 & DUP = 1, MQTT 3.1.1 violation");
}
if (message.getQos() == AbstractMessage.QOSType.RESERVED) {
throw new CorruptedFrameException(
"Received a PUBLISH with QoS flags setted 10 b11, MQTT 3.1.1 violation");
}
}
int remainingLength = message.getRemainingLength();
// Topic name
String topic = MQTTProtocol.decodeString(in);
if (topic == null) {
in.reset();
return;
}
if (topic.contains("+") || topic.contains("#")) {
throw new CorruptedFrameException(
"Received a PUBLISH with topic containting wild card chars, topic: " + topic);
}
message.setTopicName(topic);
if (message.getQos() == AbstractMessage.QOSType.LEAST_ONE
|| message.getQos() == AbstractMessage.QOSType.EXACTLY_ONCE) {
message.setMessageID(in.getUnsignedShort());
}
int stopPos = in.position();
// read the payload
int payloadSize =
remainingLength
- (stopPos - startPos - 2)
+ (MQTTProtocol.numBytesToEncode(remainingLength) - 1);
LOG.info("payload size: {}", payloadSize);
if (in.remaining() < payloadSize) {
in.reset();
return;
}
byte[] payload = new byte[payloadSize];
in.get(payload);
message.setPayload(payload);
out.write(message);
}
@Override
public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
// TODO Auto-generated method stub
int limit = in.limit();
byte[] bytes = new byte[limit];
in.get(bytes);
out.write(bytes);
}
public MessageDecoderResult decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
// Common decoding part
MessageIDMessage message = createMessage();
if (decodeCommonHeader(message, in) == NEED_DATA) {
return NEED_DATA;
}
// read messageIDs
message.setMessageID(Utils.readWord(in));
out.write(message);
return OK;
}
@Override
protected boolean doDecode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out)
throws Exception {
// Get the XML light parser from the IoSession
XMLLightweightParser parser =
(XMLLightweightParser) session.getAttribute(ConnectionHandler.XML_PARSER);
// Parse as many stanzas as possible from the received data
parser.read(in);
if (parser.areThereMsgs()) {
for (String stanza : parser.getMsgs()) {
out.write(stanza);
}
}
return !in.hasRemaining();
}
@Override
public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
in.reset();
// Common decoding part
ConnAckMessage message = new ConnAckMessage();
if (!decodeCommonHeader(message, 0x00, in)) {
in.reset();
return;
}
// skip reserved byte
in.skip(1);
// read return code
message.setReturnCode(in.get());
out.write(message);
}
/**
* Decodes protobuf messages of given type from buffer. If not enough data has been presented
* delegates to the {@link CumulativeProtocolDecoder} base class to read more data from the wire.
*
* <p>It uses instance of internal {@link SizeContext} class to calculate size of buffer expected
* by the given type of message. The size of every message that arrives on the wire is specified
* by the prepending varint value.
*
* @param session The session used to store internal {@link SizeContext}.
* @param in The buffer used to read messages if contains enough data.
* @param out The output for messages decoded from data provided.
* @see ProtobufEncoder
* @see SizeContext
*/
@Override
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
SizeContext ctx = SizeContext.get(session, in);
if (ctx.hasEnoughData(in)) {
try {
Message.Builder builder = prototype.newBuilderForType();
ctx.getInputStream(in).readMessage(builder, extentions);
out.write(builder.build());
return true;
} finally {
ctx.shiftPositionAndReset(session, in);
}
}
return false;
}
@Override
public MessageDecoderResult decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
// =================结合CumulativeProtocolDecoder================//
Context ctx = getContext(session); // 获取session 的context
long matchCount = ctx.getMatchLength(); // 目前已获取的数据
long length = ctx.getLength(); // 数据总长度
IoBuffer buffer = ctx.getBuffer(); // 数据存入buffer
// 第一次取数据
if (length == 0) {
length = in.getLong();
// 保存第一次获取的长度
ctx.setLength(length);
matchCount = in.remaining();
ctx.setMatchLength(matchCount);
} else {
matchCount += in.remaining();
ctx.setMatchLength(matchCount);
}
if (in.hasRemaining()) { // 如果buff中还有数据
if (matchCount < length) {
buffer.put(in); // 添加到保存数据的buffer中
}
if (matchCount >= length) { // 如果已经发送的数据的长度>=目标数据的长度,则进行解码
byte[] b = new byte[(int) length];
byte[] temp = new byte[(int) length];
in.get(temp, 0, (int) (length - buffer.position())); // 最后一次in的数据可能有多的
buffer.put(temp);
// 一定要添加以下这一段，否则不会有任何数据,因为，在执行in.put(buffer)时buffer的起始位置已经移动到最后，所有需要将buffer的起始位置移动到最开始
buffer.flip();
buffer.get(b);
File_ServiceRadio file = new File_ServiceRadio();
file.setFileContent(b);
out.write(file);
ctx.reset();
return MessageDecoderResult.OK;
} else {
ctx.setBuffer(buffer);
return MessageDecoderResult.NEED_DATA;
}
}
return MessageDecoderResult.NEED_DATA;
}
/** Decode the RpcRequest */
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
if (in.prefixedDataAvailable(HEADER_LENGTH, MAX_LENGTH)) {
RpcMessage.Builder rpcRequestBuilder = RpcMessage.newBuilder();
int length = in.getInt();
byte[] bytes = new byte[length];
in.get(bytes);
rpcRequestBuilder.mergeFrom(bytes);
out.write(rpcRequestBuilder.build());
return true;
} else {
// not enough data available
return false;
}
}
@Override
public MessageDecoderResult decode(IoSession ioSession, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
int hasCount = 0;
while (in.hasRemaining()) {
hasCount++;
if (hasCount == 17) {
byte bytes[] = new byte[17];
in.get(bytes);
Reply_SweepRange sweep = new Reply_SweepRange();
sweep.setContent(bytes);
out.write(sweep);
return MessageDecoderResult.OK;
}
}
return MessageDecoderResult.NEED_DATA;
}
@Override
protected DecodingState finishDecode(List<Object> childProducts, ProtocolDecoderOutput out)
throws Exception {
if (childProducts.size() < 4) {
return null;
}
int childs = childProducts.size();
for (int i = 0; i < childs; i = i + 4) {
AsyncClientResponse response = new AsyncClientResponse();
response.setBeanName((String) childProducts.get(i));
response.setMethodName((String) childProducts.get(i + 1));
response.setSequence((Integer) childProducts.get(i + 2));
response.setInputStream((InputStream) childProducts.get(i + 3));
out.write(response);
charsetDecoder.reset();
}
return null;
}
@Override
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
boolean has = in.prefixedDataAvailable(4, Integer.MAX_VALUE);
if (has) {
int length = in.getInt();
byte[] bytes = new byte[length];
in.get(bytes);
byte[] messageType = new byte[Constant.MESSAGE_TYPE_COUNT];
System.arraycopy(bytes, 0, messageType, 0, Constant.MESSAGE_TYPE_COUNT);
int type = ByteUtils.ByteArray2Int(messageType);
byte[] bodyByte = new byte[length - Constant.MESSAGE_TYPE_COUNT];
System.arraycopy(
bytes, Constant.MESSAGE_TYPE_COUNT, bodyByte, 0, length - Constant.MESSAGE_TYPE_COUNT);
AbstractChatMessage chatMessage = this.getMessageType(type);
chatMessage.bytes2Body(bodyByte);
chatMessage.setMessageType(type);
out.write(chatMessage);
return true;
}
return false;
}
@Override
public MessageDecoderResult decode(IoSession session, IoBuffer buffer, ProtocolDecoderOutput out)
throws Exception {
StartOnDemandMessage message = new StartOnDemandMessage();
buffer.getInt();
buffer.get();
int numTransients = buffer.getInt();
if (numTransients > 0) {
OnDemandRequest[] transients = new OnDemandRequest[numTransients];
for (int i = 0; i < numTransients; ++i) {
OnDemandRequest request = new OnDemandRequest();
request.setAttributeAlias(buffer.getInt());
int numIdPatterns = buffer.getInt();
if (numIdPatterns > 0) {
String[] idPatterns = new String[numIdPatterns];
for (int j = 0; j < numIdPatterns; ++j) {
int idLength = buffer.getInt();
byte[] idBytes = new byte[idLength];
buffer.get(idBytes);
idPatterns[j] = new String(idBytes, "UTF-16BE");
}
request.setIdPatterns(idPatterns);
}
}
message.setRequests(transients);
}
out.write(message);
return MessageDecoderResult.OK;
}
@Override
protected boolean doDecode(IoSession session, ByteBuffer in, ProtocolDecoderOutput out)
throws Exception {
final int origonPos = in.position();
if (in.remaining() < 16) {
in.position(origonPos);
return false;
}
int magic = in.getInt();
if (magic != Const.MAGIC)
throw new IOException("flag error, except: " + Const.MAGIC + ", but get " + magic);
int request = in.getInt();
int pcode = in.getInt();
int len = in.getInt();
if (in.remaining() < len) {
in.position(origonPos);
return false;
}
byte[] data = new byte[len];
in.get(data);
BaseResponsePacket packet = PacketCode.createPacket(pcode, request, data);
out.write(packet);
return true;
}
/** {@inheritDoc} */
@Override
protected boolean doDecode(
final IoSession session, final IoBuffer in, final ProtocolDecoderOutput out)
throws Exception {
MultilineOrientedResponse response =
(MultilineOrientedResponse) session.getAttribute(CURRENT_RESPONSE);
if (response == null) {
response = new MultilineOrientedResponse();
session.setAttribute(CURRENT_RESPONSE, response);
}
// Remember the initial position.
final int start = in.position();
// Now find the first CRLF in the buffer.
byte previous = 0;
while (in.hasRemaining()) {
final byte current = in.get();
if (previous == '\r' && current == '\n') {
// Remember the current position and limit.
final int position = in.position();
final int limit = in.limit();
try {
in.position(start);
in.limit(position);
// The bytes between in.position() and in.limit()
// now contain a full CRLF terminated line.
// If the multiline indicator is on this line then add the line to
// the response object and continue to process the next line
if (checkIndicator(in.slice())) {
response.addLine(in.getString(getCharset().newDecoder()));
} else {
// Otherwise, add the current line and then submit the response
// to the ProtocolDecoderOutput instance
response.addLine(in.getString(getCharset().newDecoder()));
out.write(response);
session.removeAttribute(CURRENT_RESPONSE);
return true;
}
} finally {
// Set the position to point right after the
// detected line and set the limit to the old
// one.
in.position(position);
in.limit(limit);
}
// Decoded one line; CumulativeProtocolDecoder will
// call me again until I return false. So just
// return true until there are no more lines in the
// buffer.
return true;
}
previous = current;
}
// Could not find CRLF in the buffer. Reset the initial
// position to the one we recorded above.
in.position(start);
return false;
}
@Override
public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
out.write(in.duplicate());
in.skip(in.remaining());
}
@Override
protected DecodingState finishDecode(int value, ProtocolDecoderOutput out)
throws Exception {
out.write(value);
return bodyState;
}
/** 把二进制流解码为服务器使用的数据包格式 */
@Override
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)
throws Exception {
// private short size;//包大小
// private short type;//版本号
// private short code;//包类型
// private int roleid; // 玩家ID
IoBuffer newBuf = in.slice();
// size
System.out.println(newBuf);
int size = newBuf.getInt();
System.out.printf("c size = %d\n", size);
int length = newBuf.getInt();
System.out.printf("c size = %d\n", length);
byte[] bytesaa = new byte[length];
newBuf.get(bytesaa);
String as = null;
try {
as = new String(bytesaa, "UTF-8");
} catch (UnsupportedEncodingException e) {
}
System.out.println(as);
Netmessage res = new Netmessage();
short type = newBuf.getShort();
short code = newBuf.getShort();
int roleid = newBuf.getInt();
// int roleid=newBuf.getInt();
System.out.printf("type = %d code = %d roleid = %d\n", (int) type, (int) code, roleid);
res.writeDataPack((short) size, type, code, roleid);
// BODY
int bodyLen = size - 10;
if (bodyLen > 0) {
byte[] bytes = new byte[bodyLen];
in.get(bytes, 0, bodyLen);
res.writeData(bytes, size);
}
out.write(res);
if (size <= 0 || size >= Short.MAX_VALUE) {
// 非法的数据长度
log.debug("Message Length Invalid size = " + size + ", throw this Message.");
return true;
}
System.out.print(newBuf.getHexDump());
// 000A 0001 0001 0000 0001
System.out.printf("buffer size = %d", in.remaining());
if (size > in.remaining()) {
// 数据还不够读取,等待下一次读取
System.out.printf(
"Data not integrity. there is a lack of " + (size - newBuf.remaining()) + " bytes.");
return true;
}
// Netmessage res=new Netmessage();
// short type=newBuf.getShort();
// short code=newBuf.getShort();
// int roleid=newBuf.getInt();
// //int roleid=newBuf.getInt();
// System.out.printf("type = %d code = %d roleid = %d\n",(int)type,(int)code,roleid);
// res.writeDataPack((short)size, type, code, roleid);
//
// // BODY
// int bodyLen = size-10;
// if (bodyLen > 0) {
// byte[] bytes = new byte[bodyLen];
// in.get(bytes, 0, bodyLen);
// res.writeData(bytes,size);
// }
out.write(res);
return false;
}