protected override void ChannelRead0(IChannelHandlerContext context, IByteBuffer message)
{
int msgType = message.GetInt(4);
int svrID = msgType / 10000;
int msgLen = message.GetInt(0);
var msgData = message.GetIoBuffer(8, msgLen - 8);
Log.Info("msg : {0}", msgType);
IGateMessage gate = null;
if (svrID == 1)
{
gate = clusterClient.GetGrain <IGateMaster>(0);
}
if (svrID == 3)
{
gate = clusterClient.GetGrain <IGateBattle>(0);
}
if (gate != null)
{
Task.Run(async() =>
{
var response = await gate.SendMessage(msgType, msgData.ToArray());
if (response != null)
{
//约定response msg id = req + 1
await Send(msgType + 1, response);
}
});
}
}
/// <summary>
/// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is
/// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to
/// decode the length field encoded differently.
/// Note that this method must not modify the state of the specified buffer (e.g.
/// <see cref="IByteBuffer.ReaderIndex" />,
/// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.)
/// </summary>
/// <param name="buffer">The buffer we'll be extracting the frame length from.</param>
/// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param>
/// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param>
/// <param name="order">The preferred <see cref="ByteOrder" /> of <see cref="buffer" />.</param>
/// <returns>A long integer that represents the unadjusted length of the next frame.</returns>
protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
buffer = buffer.WithOrder(order);
long frameLength;
switch (length)
{
case 1:
frameLength = buffer.GetByte(offset);
break;
case 2:
frameLength = buffer.GetShort(offset);
break;
case 4:
frameLength = buffer.GetInt(offset);
break;
case 8:
frameLength = buffer.GetLong(offset);
break;
default:
throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)");
}
return(frameLength);
}
public static uint GetUnsignedInt(this IByteBuffer buf, int index)
{
unchecked
{
return((uint)(buf.GetInt(index)));
}
}
public MsgPacket(IByteBuffer byteBuf)
{
int len = byteBuf.GetInt(0);
this.data = new byte[len];
byteBuf.ReadBytes(this.data);
}
/// <summary>
/// Calculates the hash code of the specified buffer. This method is
/// useful when implementing a new buffer type.
/// </summary>
public static int HashCode(IByteBuffer buffer)
{
int aLen = buffer.ReadableBytes;
int intCount = (int)((uint)aLen >> 2);
int byteCount = aLen & 3;
int hashCode = 1;
int arrayIndex = buffer.ReaderIndex;
for (int i = intCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetInt(arrayIndex);
arrayIndex += 4;
}
for (int i = byteCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetByte(arrayIndex++);
}
if (hashCode == 0)
{
hashCode = 1;
}
return(hashCode);
}
/// <summary>
/// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is
/// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to
/// decode the length field encoded differently.
/// Note that this method must not modify the state of the specified buffer (e.g.
/// <see cref="IByteBuffer.ReaderIndex" />,
/// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.)
/// </summary>
/// <param name="buffer">The buffer we'll be extracting the frame length from.</param>
/// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param>
/// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param>
/// <param name="order">The preferred <see cref="ByteOrder" /> of buffer.</param>
/// <returns>A long integer that represents the unadjusted length of the next frame.</returns>
protected virtual long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
long frameLength;
switch (length)
{
case 1:
frameLength = buffer.GetByte(offset);
break;
case 2:
frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedShort(offset) : buffer.GetUnsignedShortLE(offset);
break;
case 3:
frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedMedium(offset) : buffer.GetUnsignedMediumLE(offset);
break;
case 4:
frameLength = order == ByteOrder.BigEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset);
break;
case 8:
frameLength = order == ByteOrder.BigEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset);
break;
default:
throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)");
}
return(frameLength);
}
/// <summary>
/// Calculates the hash code of the specified buffer. This method is
/// useful when implementing a new buffer type.
/// </summary>
public static int HashCode(IByteBuffer buffer)
{
int aLen = buffer.ReadableBytes;
int intCount = aLen.RightUShift(2);
int byteCount = aLen & 3;
int hashCode = EmptyByteBuffer.EmptyByteBufferHashCode;
int arrayIndex = buffer.ReaderIndex;
for (int i = intCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetInt(arrayIndex);
arrayIndex += 4;
}
for (int i = byteCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetByte(arrayIndex++);
}
if (0u >= (uint)hashCode)
{
hashCode = 1;
}
return(hashCode);
}
void Unmask(IByteBuffer frame)
{
int i = frame.ReaderIndex;
int end = frame.WriterIndex;
int intMask = BitConverter.IsLittleEndian
? (this.maskingKey[0])
| (this.maskingKey[1] << 8)
| (this.maskingKey[2] << 16)
| (this.maskingKey[3] << 24)
: (this.maskingKey[0] << 24)
| (this.maskingKey[1] << 16)
| (this.maskingKey[2] << 8)
| this.maskingKey[3];
for (; i + 3 < end; i += 4)
{
int unmasked = frame.GetInt(i) ^ intMask;
frame.SetInt(i, unmasked);
}
for (; i < end; i++)
{
frame.SetByte(i, frame.GetByte(i) ^ this.maskingKey[i % 4]);
}
}
protected override void Decode(IChannelHandlerContext context, IByteBuffer cumulationBuff, List <object> output)
{
bool isParse = true;
while (isParse)
{
isParse = false;
if (Status == 0 && cumulationBuff.ReadableBytes >= HEADER_LENGTH)//解析head
{
bodyLength = cumulationBuff.GetInt(cumulationBuff.ReaderIndex + 4);
Status = 1;
if (bodyLength > cumulationBuff.MaxCapacity)
{
throw new Exception("包长超过最大值");
}
}
if (Status == 1 && cumulationBuff.ReadableBytes >= bodyLength + HEADER_LENGTH) //解析body
{
byte[] frameData = cumulationBuff.ReadeBytes(cumulationBuff.ReaderIndex, bodyLength + HEADER_LENGTH);
Status = 0;
output.Add(Decode(frameData));
isParse = true;
}
}//while
}
protected override long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
buffer = buffer.WithOrder(order);
var scalarPrefix = buffer.GetByte(offset++);
if (buffer.ReadableBytes - (offset - buffer.ReaderIndex) < scalarPrefix)
{
return(scalarPrefix);
}
switch (scalarPrefix)
{
case 1:
return(buffer.GetByte(offset) + scalarPrefix);
case 2:
return(buffer.GetShort(offset) + scalarPrefix);
case 4:
return(buffer.GetInt(offset) + scalarPrefix);
default:
throw new ProudException("Invalid scalar prefix " + scalarPrefix);
}
}
/// <summary>
/// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is
/// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to
/// decode the length field encoded differently.
/// Note that this method must not modify the state of the specified buffer (e.g.
/// <see cref="IByteBuffer.ReaderIndex" />,
/// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.)
/// </summary>
/// <param name="buffer">The buffer we'll be extracting the frame length from.</param>
/// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param>
/// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param>
/// <returns>A long integer that represents the unadjusted length of the next frame.</returns>
protected static long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length)
{
return(length switch
{
1 => buffer.GetByte(offset),
2 => buffer.GetUnsignedShort(offset),
3 => buffer.GetUnsignedMedium(offset),
4 => buffer.GetInt(offset),
8 => buffer.GetLong(offset),
_ => CThrowHelper.ThrowDecoderException(length),
});
protected IByteBuffer TryDecodeFramedMessage(IChannelHandlerContext ctx,
IChannel channel,
IByteBuffer buffer,
bool stripFraming)
{
// Framed messages are prefixed by the size of the frame (which doesn't include the
// framing itself).
int messageStartReaderIndex = buffer.ReaderIndex;
int messageContentsOffset;
if (stripFraming)
{
messageContentsOffset = messageStartReaderIndex + MessageFrameSize;
}
else
{
messageContentsOffset = messageStartReaderIndex;
}
// The full message is larger by the size of the frame size prefix
int messageLength = buffer.GetInt(messageStartReaderIndex) + MessageFrameSize;
int messageContentsLength = messageStartReaderIndex + messageLength - messageContentsOffset;
if (messageContentsLength > _maxFrameSize)
{
ctx.FireExceptionCaught(
new TooLongFrameException("Maximum frame size of " + _maxFrameSize +
" exceeded")
);
}
if (messageLength == 0)
{
// Zero-sized frame: just ignore it and return nothing
buffer.SetReaderIndex(messageContentsOffset);
return(null);
}
else if (buffer.ReadableBytes < messageLength)
{
// Full message isn't available yet, return nothing for now
return(null);
}
else
{
// Full message is available, return it
IByteBuffer messageBuffer = ExtractFrame(buffer,
messageContentsOffset,
messageContentsLength);
buffer.SetReaderIndex(messageStartReaderIndex + messageLength);
return(messageBuffer);
}
}
public List <Message> AddAndGetMessage(IByteBuffer byteBuf)
{
List <Message> list = new List <Message>();
if (cumulationBuff == null)
{
cumulationBuff = byteBuf;
}
else
{
cumulationBuff.WriteBytes(byteBuf.ReadeBytes());
}
bool isParse = true;
while (isParse)
{
isParse = false;
if (Status == 0 && cumulationBuff.ReadableBytes >= HEADER_LENGTH)//解析head
{
bodyLength = cumulationBuff.GetInt(cumulationBuff.ReaderIndex + 4);
Status = 1;
if (bodyLength > cumulationBuff.MaxCapacity)
{
throw new Exception("包长超过最大值");
}
}
if (Status == 1 && cumulationBuff.ReadableBytes >= bodyLength + HEADER_LENGTH) //解析body
{
byte[] frameData = cumulationBuff.ReadeBytes(cumulationBuff.ReaderIndex, bodyLength + HEADER_LENGTH);
Status = 0;
list.Add(Decode(frameData));
isParse = true;
}
}//while
if (list.Count > 0)
{
if (cumulationBuff != null && !cumulationBuff.IsReadable())
{
cumulationBuff = null;
}
else
{
cumulationBuff.DiscardReadBytes();
}
}
return(list);
}
/// <summary>
/// Decryptes data using XTEA.
/// </summary>
/// <param name="buffer"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="keys"></param>
/// <returns></returns>
private static IByteBuffer DecryptXTEA(IByteBuffer buffer, int start, int end, int[] keys)
{
int length = (end - start) / 8;
for (int index = 0; index < length; index++)
{
int v1 = buffer.GetInt(start + index * 8);
int v0 = buffer.GetInt(start + index * 8 + 4);
int ratio = unchecked ((int)0x9e3779b9);
int rounds = 32;
int offset = ratio * rounds;
while (rounds-- > 0)
{
v0 -= (((int)((uint)v1 >> -1563092443) ^ v1 << 611091524) + v1 ^ offset + keys[(int)((uint)offset >> -1002502837) & 0x56c00003]);
offset -= ratio;
v1 -= (((int)((uint)v0 >> 1337206757) ^ v0 << 363118692) - -v0 ^ offset + keys[offset & 0x3]);
}
buffer.SetInt(start + index * 8, v1);
buffer.SetInt(start + index * 8 + 4, v0);
}
return(buffer);
}
void Unmask(IByteBuffer frame)
{
int i = frame.ReaderIndex;
int end = frame.WriterIndex;
int intMask = (this.maskingKey[0] << 24)
| (this.maskingKey[1] << 16)
| (this.maskingKey[2] << 8)
| this.maskingKey[3];
for (; i + 3 < end; i += 4)
{
int unmasked = frame.GetInt(i) ^ intMask;
_ = frame.SetInt(i, unmasked);
}
for (; i < end; i++)
{
_ = frame.SetByte(i, frame.GetByte(i) ^ this.maskingKey[i % 4]);
}
}
protected override long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
buffer = buffer.WithOrder(ByteOrder.LittleEndian);
var scalarPrefix = buffer.GetByte(offset++);
switch (scalarPrefix)
{
case 1:
return(buffer.ReadableBytes < 1 ? 1 : buffer.GetByte(offset) + 1);
case 2:
return(buffer.ReadableBytes < 2 ? 2 : buffer.GetShort(offset) + 2);
case 4:
return(buffer.ReadableBytes < 4 ? 4 : buffer.GetInt(offset) + 4);
default:
throw new ProudException("Invalid scalar prefix " + scalarPrefix);
}
}
protected override long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
buffer = buffer.WithOrder(ByteOrder.LittleEndian);
var scalarPrefix = buffer.GetByte(offset++);
// lengthFieldOffset from constructor + scalarPrefix from above
var bytesLeft = buffer.ReadableBytes - Math.Abs(buffer.ReaderIndex - offset) + 1;
switch (scalarPrefix)
{
case 1:
return(bytesLeft < 1 ? 1 : buffer.GetByte(offset) + 1);
case 2:
return(bytesLeft < 2 ? 2 : buffer.GetShort(offset) + 2);
case 4:
return(bytesLeft < 4 ? 4 : buffer.GetInt(offset) + 4);
default:
throw new ProudException("Invalid scalar prefix " + scalarPrefix);
}
}
protected override void Decode(IChannelHandlerContext channelHandlerContext, IByteBuffer byteBuf, List <Object> list)
{
if (byteBuf.ReadableBytes < HeadSize)
{
return;
}
int length = byteBuf.GetInt(byteBuf.ReaderIndex + LengthOffset); // 获取取消息内容长度
if (byteBuf.ReadableBytes < length)
{
return;
}
int readerIndex = byteBuf.ReaderIndex;
IByteBuffer frame = byteBuf.Slice(readerIndex, length);
frame.Retain();
byteBuf.SetReaderIndex(readerIndex + length);
list.Add(frame);
}
/// <summary>
/// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is
/// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to
/// decode the length field encoded differently.
/// Note that this method must not modify the state of the specified buffer (e.g.
/// <see cref="IByteBuffer.ReaderIndex" />,
/// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.)
/// </summary>
/// <param name="buffer">The buffer we'll be extracting the frame length from.</param>
/// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param>
/// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param>
/// <param name="order">The preferred <see cref="ByteOrder" /> of buffer.</param>
/// <returns>A long integer that represents the unadjusted length of the next frame.</returns>
protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
long frameLength;
switch (length)
{
case 1:
frameLength = buffer.GetByte(offset);
break;
case 2:
frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedShort(offset) : buffer.GetUnsignedShortLE(offset);
break;
case 3:
frameLength = order == ByteOrder.BigEndian ? buffer.GetUnsignedMedium(offset) : buffer.GetUnsignedMediumLE(offset);
break;
case 4:
frameLength = order == ByteOrder.BigEndian ? buffer.GetInt(offset) : buffer.GetIntLE(offset);
break;
case 8:
frameLength = order == ByteOrder.BigEndian ? buffer.GetLong(offset) : buffer.GetLongLE(offset);
break;
default:
throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)");
}
byte[] bytes = BitConverter.GetBytes(frameLength);
string slength = Encoding.UTF8.GetString(bytes);
frameLength = long.Parse(slength);
return(frameLength);
}
/// <summary>
/// Calculates the hash code of the specified buffer. This method is
/// useful when implementing a new buffer type.
/// </summary>
public static int HashCode(IByteBuffer buffer)
{
int aLen = buffer.ReadableBytes;
int intCount = (int)((uint)aLen >> 2);
int byteCount = aLen & 3;
int hashCode = 1;
int arrayIndex = buffer.ReaderIndex;
if (buffer.Order == ByteOrder.BigEndian)
{
for (int i = intCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetInt(arrayIndex);
arrayIndex += 4;
}
}
else
{
for (int i = intCount; i > 0; i--)
{
hashCode = 31 * hashCode + SwapInt(buffer.GetInt(arrayIndex));
arrayIndex += 4;
}
}
for (int i = byteCount; i > 0; i--)
{
hashCode = 31 * hashCode + buffer.GetByte(arrayIndex++);
}
if (hashCode == 0)
{
hashCode = 1;
}
return hashCode;
}
public override unsafe void Encode(IChannelHandlerContext ctx, WebSocketFrame msg, List <object> output)
{
IByteBuffer data = msg.Content;
var mask = stackalloc byte[4];
byte opcode = 0;
if (msg is TextWebSocketFrame)
{
opcode = OpcodeText;
}
else if (msg is PingWebSocketFrame)
{
opcode = OpcodePing;
}
else if (msg is PongWebSocketFrame)
{
opcode = OpcodePong;
}
else if (msg is CloseWebSocketFrame)
{
opcode = OpcodeClose;
}
else if (msg is BinaryWebSocketFrame)
{
opcode = OpcodeBinary;
}
else if (msg is ContinuationWebSocketFrame)
{
opcode = OpcodeCont;
}
else
{
ThrowNotSupportedException(msg);
}
int length = data.ReadableBytes;
if (Logger.DebugEnabled)
{
Logger.Debug($"Encoding WebSocket Frame opCode={opcode} length={length}");
}
int b0 = 0;
if (msg.IsFinalFragment)
{
b0 |= 1 << 7;
}
b0 |= msg.Rsv % 8 << 4;
b0 |= opcode % 128;
if (opcode == OpcodePing && length > 125)
{
ThrowTooLongFrameException(length);
}
bool release = true;
IByteBuffer buf = null;
try
{
int maskLength = this.maskPayload ? 4 : 0;
if (length <= 125)
{
int size = 2 + maskLength;
if (this.maskPayload || length <= GatheringWriteThreshold)
{
size += length;
}
buf = ctx.Allocator.Buffer(size);
buf.WriteByte(b0);
byte b = (byte)(this.maskPayload ? 0x80 | (byte)length : (byte)length);
buf.WriteByte(b);
}
else if (length <= 0xFFFF)
{
int size = 4 + maskLength;
if (this.maskPayload || length <= GatheringWriteThreshold)
{
size += length;
}
buf = ctx.Allocator.Buffer(size);
buf.WriteByte(b0);
buf.WriteByte(this.maskPayload ? 0xFE : 126);
buf.WriteByte(length.RightUShift(8) & 0xFF);
buf.WriteByte(length & 0xFF);
}
else
{
int size = 10 + maskLength;
if (this.maskPayload || length <= GatheringWriteThreshold)
{
size += length;
}
buf = ctx.Allocator.Buffer(size);
buf.WriteByte(b0);
buf.WriteByte(this.maskPayload ? 0xFF : 127);
buf.WriteLong(length);
}
// Write payload
if (this.maskPayload)
{
int intMask = (this.random.Next() * int.MaxValue);
// Mask bytes in BE
uint unsignedValue = (uint)intMask;
* mask = (byte)(unsignedValue >> 24);
*(mask + 1) = (byte)(unsignedValue >> 16);
*(mask + 2) = (byte)(unsignedValue >> 8);
*(mask + 3) = (byte)unsignedValue;
// Mask in BE
buf.WriteInt(intMask);
int counter = 0;
int i = data.ReaderIndex;
int end = data.WriterIndex;
for (; i + 3 < end; i += 4)
{
int intData = data.GetInt(i);
buf.WriteInt(intData ^ intMask);
}
for (; i < end; i++)
{
byte byteData = data.GetByte(i);
buf.WriteByte(byteData ^ mask[counter++ % 4]);
}
output.Add(buf);
}
else
{
if (buf.WritableBytes >= data.ReadableBytes)
{
// merge buffers as this is cheaper then a gathering write if the payload is small enough
buf.WriteBytes(data);
output.Add(buf);
}
else
{
output.Add(buf);
output.Add(data.Retain());
}
}
release = false;
}
finally
{
if (release)
{
buf?.Release();
}
}
}
public static float GetFloat(this IByteBuffer buf, int index) => ByteBufferUtil.Int32BitsToSingle(buf.GetInt(index));
public virtual int GetInt(int index) => Buf.GetInt(index);
/// <summary>
/// Decodes the specified region of the buffer into an unadjusted frame length. The default implementation is
/// capable of decoding the specified region into an unsigned 8/16/24/32/64 bit integer. Override this method to
/// decode the length field encoded differently.
/// Note that this method must not modify the state of the specified buffer (e.g.
/// <see cref="IByteBuffer.ReaderIndex" />,
/// <see cref="IByteBuffer.WriterIndex" />, and the content of the buffer.)
/// </summary>
/// <param name="buffer">The buffer we'll be extracting the frame length from.</param>
/// <param name="offset">The offset from the absolute <see cref="IByteBuffer.ReaderIndex" />.</param>
/// <param name="length">The length of the framelenght field. Expected: 1, 2, 3, 4, or 8.</param>
/// <param name="order">The preferred <see cref="ByteOrder" /> of <see cref="buffer" />.</param>
/// <returns>A long integer that represents the unadjusted length of the next frame.</returns>
protected long GetUnadjustedFrameLength(IByteBuffer buffer, int offset, int length, ByteOrder order)
{
buffer = buffer.WithOrder(order);
long frameLength;
switch (length)
{
case 1:
frameLength = buffer.GetByte(offset);
break;
case 2:
frameLength = buffer.GetShort(offset);
break;
case 4:
frameLength = buffer.GetInt(offset);
break;
case 8:
frameLength = buffer.GetLong(offset);
break;
default:
throw new DecoderException("unsupported lengthFieldLength: " + this.lengthFieldLength + " (expected: 1, 2, 3, 4, or 8)");
}
return frameLength;
}
/// <summary>
/// 解析消息包
/// </summary>
protected override void Decode(IChannelHandlerContext context, IByteBuffer input, List <object> output)
{
try
{
//数据包长度为一个int至少4个字节
if (input.ReadableBytes < 4)
{
return;
}
//仅仅是Get没有Read
int msgLen = input.GetInt(input.ReaderIndex);
if (!CheckMsgLen(msgLen))
{
context.CloseAsync();
return;
}
//如果接受数据不够，等待下次
if (input.ReadableBytes < msgLen)
{
return;
}
//在buffer中读取掉消息长度
input.ReadInt();
// 时间合法性检查
long time = input.ReadLong();
if (!CheckTime(context, time))
{
context.CloseAsync();
return;
}
// 序列号检查
int order = input.ReadInt();
if (!CheckMagicNumber(context, order, msgLen))
{
context.CloseAsync();
return;
}
//消息id
int msgId = input.ReadInt();
byte[] msgData = null;
msgData = new byte[msgLen - 20];
input.ReadBytes(msgData);
var msg = TcpHandlerFactory.GetMsg(msgId);
if (msg == null)
{
LOGGER.Error("消息ID:{} 找不到对应的Msg.", msgId);
return;
}
else
{
if (msg.GetMsgId() == msgId)
{
msg.Deserialize(msgData);
}
else
{
LOGGER.Error("后台解析消息失败，注册消息id和消息无法对应.real:{0}, register:{1}", msg.GetMsgId(), msgId);
return;
}
}
output.Add(msg);
}
catch (Exception e)
{
LOGGER.Error(e, "解析数据异常," + e.Message + "\n" + e.StackTrace);
}
}
public int GetInt(int index)
{
CheckIndex(index, 4);
return(_buffer.GetInt(index));
}
/// <summary>
/// Compares the two specified buffers as described in {@link ByteBuf#compareTo(ByteBuf)}.
/// This method is useful when implementing a new buffer type.
/// </summary>
public static int Compare(IByteBuffer bufferA, IByteBuffer bufferB)
{
int aLen = bufferA.ReadableBytes;
int bLen = bufferB.ReadableBytes;
int minLength = Math.Min(aLen, bLen);
int uintCount = (int)((uint)minLength >> 2);
int byteCount = minLength & 3;
int aIndex = bufferA.ReaderIndex;
int bIndex = bufferB.ReaderIndex;
if (bufferA.Order == bufferB.Order)
{
for (int i = uintCount; i > 0; i--)
{
long va = bufferA.GetUnsignedInt(aIndex);
long vb = bufferB.GetUnsignedInt(bIndex);
if (va > vb)
{
return(1);
}
if (va < vb)
{
return(-1);
}
aIndex += 4;
bIndex += 4;
}
}
else
{
for (int i = uintCount; i > 0; i--)
{
long va = bufferA.GetUnsignedInt(aIndex);
long vb = SwapInt(bufferB.GetInt(bIndex)) & 0xFFFFFFFFL;
if (va > vb)
{
return(1);
}
if (va < vb)
{
return(-1);
}
aIndex += 4;
bIndex += 4;
}
}
for (int i = byteCount; i > 0; i--)
{
short va = bufferA.GetByte(aIndex);
short vb = bufferB.GetByte(bIndex);
if (va > vb)
{
return(1);
}
if (va < vb)
{
return(-1);
}
aIndex++;
bIndex++;
}
return(aLen - bLen);
}
/// <summary>
/// Compares the two specified buffers as described in {@link ByteBuf#compareTo(ByteBuf)}.
/// This method is useful when implementing a new buffer type.
/// </summary>
public static int Compare(IByteBuffer bufferA, IByteBuffer bufferB)
{
int aLen = bufferA.ReadableBytes;
int bLen = bufferB.ReadableBytes;
int minLength = Math.Min(aLen, bLen);
int uintCount = (int)((uint)minLength >> 2);
int byteCount = minLength & 3;
int aIndex = bufferA.ReaderIndex;
int bIndex = bufferB.ReaderIndex;
if (bufferA.Order == bufferB.Order)
{
for (int i = uintCount; i > 0; i--)
{
long va = bufferA.GetUnsignedInt(aIndex);
long vb = bufferB.GetUnsignedInt(bIndex);
if (va > vb)
{
return 1;
}
if (va < vb)
{
return -1;
}
aIndex += 4;
bIndex += 4;
}
}
else
{
for (int i = uintCount; i > 0; i--)
{
long va = bufferA.GetUnsignedInt(aIndex);
long vb = SwapInt(bufferB.GetInt(bIndex)) & 0xFFFFFFFFL;
if (va > vb)
{
return 1;
}
if (va < vb)
{
return -1;
}
aIndex += 4;
bIndex += 4;
}
}
for (int i = byteCount; i > 0; i--)
{
short va = bufferA.GetByte(aIndex);
short vb = bufferB.GetByte(bIndex);
if (va > vb)
{
return 1;
}
if (va < vb)
{
return -1;
}
aIndex++;
bIndex++;
}
return aLen - bLen;
}
