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);
}
/// <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;
}
}
}
//---------------------------------------------------------------------
static T ReadMessage <T>(CodedInputStream input, Func <byte[], T> parseFrom)
{
uint size = 0;
if (!input.ReadUInt32(ref size))
{
throw new Exception("Cannot read message size.");
}
var data = input.ReadRawBytes((int)size);
return(parseFrom(data));
}
public static void Identify(IConnection connection, CodedInputStream stream)
{
var header = new BNetHeader(stream);
var payload = new byte[header.PayloadLength];
payload = stream.ReadRawBytes((int)header.PayloadLength);
var packet = new BNetPacket(header, payload);
var service = Service.GetByID(header.ServiceID);
if (service == null)
{
Logger.Error("No service exists with id: 0x{0}", header.ServiceID.ToString("X2"));
return;
}
//var method = service.DescriptorForType.Methods[(int)header.MethodID - 1];
//Logger.Warn("METHODID: {0}, from header: {1}", (uint)method.Options[bnet.protocol.Rpc.MethodId.Descriptor], header.MethodID);
var method = service.DescriptorForType.Methods.Single(m => (uint)m.Options[bnet.protocol.Rpc.MethodId.Descriptor] == header.MethodID);
var proto = service.GetRequestPrototype(method);
var builder = proto.WeakCreateBuilderForType();
try
{
var message = builder.WeakMergeFrom(CodedInputStream.CreateInstance(packet.Payload.ToArray())).WeakBuild();
lock (service) // lock the service so that it's in-context client does not get changed..
{
//Logger.Debug("service-call data:{0}", message.ToString());
((IServerService)service).Client = (IBNetClient)connection.Client;
service.CallMethod(method, null, message, (msg => SendResponse(connection, header.RequestID, msg)));
}
}
catch (NotImplementedException)
{
Logger.Debug("Unimplemented service method: {0} {1}", service.GetType().Name, method.Name);
}
catch (UninitializedMessageException e)
{
Logger.Debug("Failed to parse message: {0}", e.Message);
}
catch (Exception e)
{
Logger.DebugException(e, string.Empty);
}
}
private void Handle(CodedInputStream stream)
{
if (first)
{
first = false;
new HardcodedGsPackets(this.stream);
}
var size = stream.ReadInt32Reversed(); // includes size of size
var payLoad = stream.ReadRawBytes(size - 4);
payLoad.PrintHex();
var opcode = payLoad[0]; // assume that opcode is 1 byte for now
Console.WriteLine("GS: Opcode {0:X2}, payload size {1}", opcode, size - 4);
}
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();
}
public static void Identify(CodedInputStream stream)
{
try
{
var header = new BNetHeader(stream);
var payload = new byte[header.PayloadLength];
payload = stream.ReadRawBytes((int)header.PayloadLength);
var packet = new BNetPacket(header, payload);
if (header.ServiceID == 0xfe)
{
return;
}
var service = Service.GetByID(header.ServiceID);
if (service == null)
{
return;
}
var method =
service.DescriptorForType.Methods.Single(
m => (uint)m.Options[bnet.protocol.Rpc.MethodId.Descriptor] == header.MethodID);
var proto = service.GetRequestPrototype(method);
var builder = proto.WeakCreateBuilderForType();
var message =
builder.WeakMergeFrom(CodedInputStream.CreateInstance(packet.Payload.ToArray())).WeakBuild();
service.CallMethod(method, null, message, (msg => { }));
}
catch (UninitializedMessageException e)
{
Console.WriteLine("Failed to parse message: {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
//接收数据处理
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());
}
}
private void ParseHeader(byte[] array)
{
CodedInputStream stream = CodedInputStream.CreateInstance(array);
var size = (stream.ReadRawByte() << 8) | stream.ReadRawByte(); // header size.
var headerData = stream.ReadRawBytes(size); // header data.
var Header = bnet.protocol.Header.ParseFrom(headerData); // parse header.
outputBox.ResetText();
outputBox.Text = string.Format(
"ServiceID = {0}\r\n"
+ "MethodID = {1}\r\n"
+ "Token = {2}\r\n"
+ "ObjectID = {3}\r\n"
+ "Size = {4}\r\n"
+ "Status = {5}\r\n"
+ "Errors = {6}\r\n",
Header.ServiceId,
Header.HasMethodId ? Header.MethodId.ToString() : "None",
Header.HasToken ? Header.Token.ToString() : "None",
Header.HasObjectId ? Header.ObjectId.ToString() : "None",
Header.HasSize ? Header.Size.ToString() : "None",
Header.HasStatus ? Header.Status.ToString() : "None",
Header.ErrorCount);
}
public byte[] GetPayload(CodedInputStream stream)
{
return(stream.ReadRawBytes((int)this.Header.Size));
}
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));
}
public static void Main(string[] args)
{
var profile = new Profile();
RomanNumeral y = new RomanNumeral();
BinaryNumeral x = y;
using (var fs = new FileStream(@"C:\users\muks\desktop\perf.pb", FileMode.Open, FileAccess.Read))
{
using (var cis = new CodedInputStream(fs))
{
var valueTypeList = new List <ValueType>();
var samplesList = new List <Sample>();
var mappingList = new List <Mapping>();
var locationList = new List <Location>();
var stringTable = new List <string>();
profile.SampleTypes = valueTypeList;
profile.Samples = samplesList;
profile.Locations = locationList;
profile.StringTable = stringTable;
profile.Mappings = mappingList;
while (true)
{
var tag = cis.ReadTag();
if (tag > 0)
{
var fieldNumber = WireFormat.GetTagFieldNumber(tag);
switch (fieldNumber)
{
case 1:
valueTypeList.Add(HandleValueType(cis));
break;
case 2:
samplesList.Add(HandleSample(cis));
break;
case 3:
mappingList.Add(HandleMapping(cis));
break;
case 4:
locationList.Add(HandleLocation(cis));
break;
case 5:
cis.SkipLastField();
break;
case 6:
var strLength = cis.ReadLength();
stringTable.Add(System.Text.Encoding.UTF8.GetString(cis.ReadRawBytes(strLength), 0, strLength));
break;
default:
cis.SkipLastField();
break;
}
}
else
{
break;
}
}
}
}
for (int i = 0; i < profile.Mappings.Count; ++i)
{
var mapping = profile.Mappings[i];
var filename = profile.StringTable[(int)mapping.FileNameIndex];
var rangeBegin = mapping.MemoryStart;
var rangeEnd = mapping.MemoryLimit;
Console.WriteLine($"Filename: {filename}, Range Start: {rangeBegin}, Rang End: {rangeEnd}");
}
}
public static ushort ReadFixedUInt16(this CodedInputStream s)
{
return(BitConverter.ToUInt16(s.ReadRawBytes(2), 0));
}
private static Stream ReadStream(CodedInputStream input)
{
var length = input.ReadLength();
return(new MemoryStream(input.ReadRawBytes(length)));
}
public static int ReadInt32Reversed(this CodedInputStream s)
{
return(BitConverter.ToInt32(s.ReadRawBytes(4).Reverse().ToArray(), 0));
}
