public BNetHeader(CodedInputStream stream)
{
var serviceId = stream.ReadRawByte();
var methodId = stream.ReadRawVarint32();
var requestId = stream.ReadRawByte() | (stream.ReadRawByte() << 8);
var objectId = 0UL;
if (serviceId != 0xfe)
{
objectId = stream.ReadRawVarint64();
}
var payloadLength = stream.ReadRawVarint32();
this.SetData(serviceId, methodId, requestId, payloadLength, objectId);
}
private static void SkipUnknown(CodedInputStream input, WireType wireType)
{
switch (wireType)
{
case WireType.None:
break;
case WireType.Variant:
input.ReadRawVarint32();
break;
case WireType.Fixed64:
input.ReadFixed64();
break;
case WireType.String:
input.SkipString();
break;
case WireType.StartGroup:
break;
case WireType.EndGroup:
break;
case WireType.Fixed32:
input.ReadFixed32();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public static IMessage Decode(byte[] msg)
{
IMessage message = null;
CodedInputStream stream = new CodedInputStream(msg);
//data length,Protobuf 变长头, 也就是消息长度
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (msg.Length - (int)stream.Position))
{
try
{
byte[] body = stream.ReadRawBytes(varint32);
message = Message.Parser.ParseFrom(body);
}
catch (Exception exception)
{
Debug.Log(exception.Message);
}
}
else
{
Debug.LogError("网络数据读取不完整，丢包了？");
}
return(message);
}
//处理粘包(递归) 接收的长度
private void HandleReceveBytes(byte[] recveBytes, Int32 recelen)
{
try
{
CodedInputStream inputStream = CodedInputStream.CreateInstance(recveBytes);
//数据所有长度
Int32 varint32 = (Int32)inputStream.ReadRawVarint32();
//获取消息头长度
Int32 headlength = CodedOutputStream.ComputeRawVarint32Size((uint)varint32);
// System.Console.WriteLine("len:" + recelen + "\nvarint32:" + varint32 + "\nlen:" + headlength);
//如果所有有长度大于接收的长度。断包了
if (varint32 > recelen - headlength)
{
//需要的长度
Int32 needlen = varint32 + headlength - recelen;
//已经的长度
Int32 haslen = recelen;
byte[] resArr = new byte[varint32 + headlength];
recveBytes.CopyTo(resArr, 0);
while (true)
{
//
byte[] newResult = new byte[needlen];
int len = clientSocket.Receive(newResult, 0, needlen, SocketFlags.None);
//System.Console.WriteLine("len:" + len + "\nhaslen:" + haslen + "\nneedlen:" + needlen);
newResult.CopyTo(resArr, haslen);
haslen += len;
needlen -= len;
if (needlen == 0)
{
break;
}
}
Thread thread = new Thread(new ParameterizedThreadStart(ReceiveDataHandle));
thread.Start(resArr);
}
else
{
Thread thread = new Thread(new ParameterizedThreadStart(ReceiveDataHandle));
thread.Start(recveBytes);
// ReceiveDataHandle(recveBytes);
//如果实际接受的长度大于包体长度+包头长（粘包）
if (recelen > (varint32 + headlength))
{
//剩下的进行解决
byte[] res = recveBytes.Skip <byte>(varint32 + headlength).ToArray <byte>();
HandleReceveBytes(res, recelen - varint32 - headlength);
}
}
}
catch (Exception exc)
{
System.Console.WriteLine("接受数据出问题：" + exc);
}
}
private int GetReceivedMessageSize(out byte[] buffer)
{
buffer = new byte[MAX_VARINT32_SIZE];
socket.Receive(buffer);
CodedInputStream tmp = CodedInputStream.CreateInstance(buffer);
return((int)tmp.ReadRawVarint32());
}
internal static void MergeDelimitedFrom(this IMessage message, Stream input, bool discardUnknownFields, ExtensionRegistry registry)
{
ProtoPreconditions.CheckNotNull(message, "message");
ProtoPreconditions.CheckNotNull(input, "input");
int size = (int)CodedInputStream.ReadRawVarint32(input);
Stream limitedStream = new LimitedInputStream(input, size);
MergeFrom(message, limitedStream, discardUnknownFields, registry);
}
/// <summary>
/// 将数据解码
/// </summary>
public static void DecodeAsync(byte[] msg)
{
if (msg.Length <= 0)
{
return;
}
//把收取上来的自己全部缓存到本地 buffer 中
Array.Copy(msg, 0, buffer.Data, buffer.Length, msg.Length);
buffer.Length += msg.Length;
Debug.Log(string.Format("cache buff length: {0}, offset: {1}", buffer.Length, buffer.Offset));
CodedInputStream stream = new CodedInputStream(buffer.Data);
while (!stream.IsAtEnd)
{
//标记读取的Position, 在长度不够时进行数组拷贝，到下一次在进行解析
int markReadIndex = (int)stream.Position;
//data length,Protobuf 变长头, 也就是消息长度
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try
{
byte[] body = stream.ReadRawBytes(varint32);
Message message = Message.Parser.ParseFrom(body);
Debug.Log("Response: " + message.ToString());
//TODO: dispatcher message, 这里就可以用多线程进行协议分发
}
catch (Exception exception)
{
Debug.Log(exception.Message);
}
}
else
{
//本次数据不够长度,缓存进行下一次解析
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
/**
* 缓存未处理完的字节
*/
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
/**
* 协议解析，把这里搞明白了，就没白看
*/
public void OnDataReceive(Object sender, DataEventArgs e)
{
//DataEventArgs 里面有 byte[] Data是从协议层接收上来的字节数组，需要程序端进行缓存
Console.WriteLine("buff length: {0}, offset: {1}", e.Length, e.Offset);
if (e.Length <= 0)
{
return;
}
//把收取上来的自己全部缓存到本地 buffer 中
Array.Copy(e.Data, 0, buffer.Data, buffer.Length, e.Length);
buffer.Length += e.Length;
CodedInputStream stream = CodedInputStream.CreateInstance(buffer.Data);
while (!stream.IsAtEnd)
{
//标记读取的Position, 在长度不够时进行数组拷贝，到下一次在进行解析
int markReadIndex = (int)stream.Position;
//Protobuf 变长头, 也就是消息长度
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try
{
byte[] body = stream.ReadRawBytes(varint32);
LaidianCommandModel response = LaidianCommandModel.ParseFrom(body);
taskMsg.Enqueue(response);
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
}
else
{
/**
* 本次数据不够长度,缓存进行下一次解析
*/
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
/**
* 缓存未处理完的字节
*/
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
/// <exception cref="System.IO.IOException"/>
private static byte[][] LoadINodeSection(InputStream @in)
{
FsImageProto.INodeSection s = FsImageProto.INodeSection.ParseDelimitedFrom(@in);
Log.Info("Loading " + s.GetNumInodes() + " inodes.");
byte[][] inodes = new byte[(int)s.GetNumInodes()][];
for (int i = 0; i < s.GetNumInodes(); ++i)
{
int size = CodedInputStream.ReadRawVarint32(@in.Read(), @in);
byte[] bytes = new byte[size];
IOUtils.ReadFully(@in, bytes, 0, size);
inodes[i] = bytes;
}
Log.Debug("Sorting inodes");
Arrays.Sort(inodes, InodeBytesComparator);
Log.Debug("Finished sorting inodes");
return(inodes);
}
public static void OnDataReceive2(System.Object sender, DataEventArgs e)
{
print("buff length: " + e.Length + ", offset: " + e.Offset);
if (e.Length <= 0)
{
return;
}
Array.Copy(e.Data, 0, buffer.Data, buffer.Length, e.Length);
buffer.Length += e.Length;
CodedInputStream stream = CodedInputStream.CreateInstance(buffer.Data);
while (!stream.IsAtEnd)
{
int markReadIndex = (int)stream.Position;
int varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (buffer.Length - (int)stream.Position))
{
try {
byte[] body = stream.ReadRawBytes(varint32);
NamePacket response = NamePacket.ParseFrom(body);
print("Response: " + response.ToString() + ", count: " + (++count));
} catch (Exception exception) {
print(exception.Message);
}
}
else
{
byte[] dest = new byte[8192];
int remainSize = buffer.Length - markReadIndex;
Array.Copy(buffer.Data, markReadIndex, dest, 0, remainSize);
buffer.Data = dest;
buffer.Offset = 0;
buffer.Length = remainSize;
break;
}
}
}
public ProtobufRequestInfo <TMessage, TBuilder> Filter(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest)
{
rest = 0;
var readOffset = offset - m_OffsetDelta;
CodedInputStream stream = CodedInputStream.CreateInstance(readBuffer, readOffset, length);
var varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= 0)
{
return(null);
}
var headLen = (int)stream.Position - readOffset;
rest = length - varint32 - headLen + m_ParsedLength;
if (rest >= 0)
{
byte[] body = stream.ReadRawBytes(varint32);
TMessage message = CreateBuilder().MergeFrom(body).BuildParsed();
var requestInfo = new ProtobufRequestInfo <TMessage, TBuilder>(message);
InternalReset();
return(requestInfo);
}
else
{
m_ParsedLength += length;
m_OffsetDelta = m_ParsedLength;
rest = 0;
var expectedOffset = offset + length;
var newOffset = m_OrigOffset + m_OffsetDelta;
if (newOffset < expectedOffset)
{
Buffer.BlockCopy(readBuffer, offset - m_ParsedLength + length, readBuffer, m_OrigOffset, m_ParsedLength);
}
return(null);
}
}
private void onData()
{
CodedInputStream stream = CodedInputStream.CreateInstance(ioBuff.ToArray());
if (stream.IsAtEnd)
{
isRead = false;
return;
}
// 读取头信息转为int，为body的长度
int dataSize;
try
{
dataSize = (int)stream.ReadRawVarint32();
}
catch (Exception e)
{
// 读header失败，有可能是消息不完整，需要等待下一个消息。
isRead = false;
return;
}
int headerSize = (int)stream.Position;
// 判断是否已经读到一次完整的信息
if (dataSize > ioBuff.Count - headerSize)
{
//body长度不够 等待下个消息的到来
isRead = false;
return;
}
// 解析消息体
byte[] msg = stream.ReadRawBytes(dataSize);
SocketModelPB socketMsg = SocketModelPB.ParseFrom(msg);
messageList.Add(socketMsg);
//从消息数组中去掉已经解析完成的数据，保留缓存区的剩余数据
ioBuff.RemoveRange(0, headerSize + dataSize);
onData();
}
//接收数据处理
private void ReceiveDataHandle(object obj)
{
byte[] result = (byte[])obj;
try
{
CodedInputStream inputStream = CodedInputStream.CreateInstance(result);
int varint32 = (int)inputStream.ReadRawVarint32();
byte[] body = inputStream.ReadRawBytes(varint32);
MessagePack pack = MessagePack.ParseFrom(body);
// System.Console.WriteLine("pack:"+ pack);
if (ResultBlockEvent != null)
{
//移除已经不应该存在的方法
Delegate[] list = ResultBlockEvent.GetInvocationList();
foreach (Delegate de in list)
{
// System.Console.WriteLine("delegate:" + de.Method.Name + "target:" + de.Target.GetType().ToString());
if (de.Target.GetType().IsSubclassOf(typeof(UserControl)))
{
UserControl control = de.Target as UserControl;
if (control.IsDisposed)
{
ResultBlockEvent -= (de as DataResultBlock);
}
}
}
ResultBlockEvent(new ResultModel()
{
pack = pack,
error = 0,
});
}
}
catch (Exception exp)
{
System.Console.WriteLine("ReceiveMessage Exception:" + exp.ToString());
}
}
/// <exception cref="Com.Google.Protobuf.InvalidProtocolBufferException"/>
private ConcatVectorTable(CodedInputStream input, ExtensionRegistryLite extensionRegistry)
{
InitFields();
int mutable_bitField0_ = 0;
UnknownFieldSet.Builder unknownFields = UnknownFieldSet.NewBuilder();
try
{
bool done = false;
while (!done)
{
int tag = input.ReadTag();
switch (tag)
{
case 0:
{
done = true;
break;
}
default:
{
if (!ParseUnknownField(input, unknownFields, extensionRegistry, tag))
{
done = true;
}
break;
}
case 8:
{
if (!((mutable_bitField0_ & unchecked ((int)(0x00000001))) == unchecked ((int)(0x00000001))))
{
dimensionSize_ = new List <int>();
mutable_bitField0_ |= unchecked ((int)(0x00000001));
}
dimensionSize_.Add(input.ReadInt32());
break;
}
case 10:
{
int length = input.ReadRawVarint32();
int limit = input.PushLimit(length);
if (!((mutable_bitField0_ & unchecked ((int)(0x00000001))) == unchecked ((int)(0x00000001))) && input.GetBytesUntilLimit() > 0)
{
dimensionSize_ = new List <int>();
mutable_bitField0_ |= unchecked ((int)(0x00000001));
}
while (input.GetBytesUntilLimit() > 0)
{
dimensionSize_.Add(input.ReadInt32());
}
input.PopLimit(limit);
break;
}
case 18:
{
if (!((mutable_bitField0_ & unchecked ((int)(0x00000002))) == unchecked ((int)(0x00000002))))
{
factorTable_ = new List <ConcatVectorProto.ConcatVector>();
mutable_bitField0_ |= unchecked ((int)(0x00000002));
}
factorTable_.Add(input.ReadMessage(ConcatVectorProto.ConcatVector.Parser, extensionRegistry));
break;
}
}
}
}
catch (InvalidProtocolBufferException e)
{
throw e.SetUnfinishedMessage(this);
}
catch (IOException e)
{
throw new InvalidProtocolBufferException(e.Message).SetUnfinishedMessage(this);
}
finally
{
if (((mutable_bitField0_ & unchecked ((int)(0x00000001))) == unchecked ((int)(0x00000001))))
{
dimensionSize_ = Java.Util.Collections.UnmodifiableList(dimensionSize_);
}
if (((mutable_bitField0_ & unchecked ((int)(0x00000002))) == unchecked ((int)(0x00000002))))
{
factorTable_ = Java.Util.Collections.UnmodifiableList(factorTable_);
}
this.unknownFields = unknownFields.Build();
MakeExtensionsImmutable();
}
}
public static KeyValuePair <byte[], List <Google.Protobuf.IMessage> > Decode(byte[] msg)
{
List <Google.Protobuf.IMessage> list = new List <Google.Protobuf.IMessage>();
CodedInputStream stream = new CodedInputStream(msg);
bool atkat = false;
int varint32 = 0;
while (true)
{
if (stream.IsAtEnd)
{
break;
}
try
{
varint32 = (int)stream.ReadRawVarint32();
if (varint32 <= (msg.Length - (int)stream.Position))
{
byte[] body = stream.ReadRawBytes(varint32);
list.Add(Packet.Parser.ParseFrom(body));
}
else
{
atkat = true;
break;
}
}
catch
{
break;
}
}
byte[] bytes;
if (stream.IsAtEnd)
{
bytes = new byte[0];
}
else
{
if (atkat)
{
byte[] b = stream.ReadRawBytes(msg.Length - (int)stream.Position);
bytes = new byte[b.Length + 4];
byte[] intBytes = BitConverter.GetBytes(varint32);
Array.Reverse(intBytes);
Array.Copy(intBytes, bytes, intBytes.Length);
Array.Copy(b, 0, bytes, intBytes.Length, b.Length);
}
else
{
bytes = stream.ReadRawBytes(msg.Length - (int)stream.Position);
}
}
return(new KeyValuePair <byte[], List <Google.Protobuf.IMessage> >(bytes, list));
}
