public BattleNetPacket(bnet.protocol.Header h, IProtoBuf b) { this.headerSize = -1; this.bodySize = -1; this.header = h; this.body = b; }
public BattleNetPacket() { this.headerSize = -1; this.bodySize = -1; this.header = null; this.body = null; }
protected bnet.protocol.Header CreateHeader(uint serviceId, uint methodId, uint objectId, uint token, uint size) { bnet.protocol.Header header = new bnet.protocol.Header(); header.SetServiceId(serviceId); header.SetMethodId(methodId); if (objectId != 0) { header.SetObjectId((ulong)objectId); } header.SetToken(token); header.SetSize(size); return(header); }
public override int Decode(byte[] bytes, int offset, int available) { int num = 0; if (this.headerSize < 0) { if (available < 2) { return(num); } this.headerSize = (bytes[offset] << 8) + bytes[offset + 1]; available -= 2; num += 2; offset += 2; } if (this.header == null) { if (available < this.headerSize) { return(num); } this.header = new bnet.protocol.Header(); this.header.Deserialize(new MemoryStream(bytes, offset, this.headerSize)); this.bodySize = !this.header.HasSize ? 0 : ((int)this.header.Size); if (this.header == null) { throw new Exception("failed to parse BattleNet packet header"); } available -= this.headerSize; num += this.headerSize; offset += this.headerSize; } if (this.body != null) { return(num); } if (available < this.bodySize) { return(num); } byte[] destinationArray = new byte[this.bodySize]; Array.Copy(bytes, offset, destinationArray, 0, this.bodySize); this.body = destinationArray; return(num + this.bodySize); }
private void PrintHeader(bnet.protocol.Header h) { object[] args = new object[] { h.ServiceId, h.MethodId, h.Token, h.Size, (BattleNetErrors)h.Status }; string message = string.Format("Packet received: Header = [ ServiceId: {0}, MethodId: {1} Token: {2} Size: {3} Status: {4}", args); if (h.ErrorCount > 0) { message = message + " Error:["; foreach (bnet.protocol.ErrorInfo info in h.ErrorList) { string str2 = message; object[] objArray2 = new object[] { str2, " ErrorInfo{ ", info.ObjectAddress.Host.Label, "/", info.ObjectAddress.Host.Epoch, "}" }; message = string.Concat(objArray2); } message = message + "]"; } message = message + "]"; this.m_logSource.LogDebug(message); }
private void LogOutgoingPacket(BattleNetPacket packet, bool wasMetered) { if (this.m_logSource == null) { UnityEngine.Debug.LogWarning("tried to log with null log source, skipping"); } else { bool flag = false; IProtoBuf body = (IProtoBuf)packet.GetBody(); bnet.protocol.Header header = packet.GetHeader(); uint serviceId = header.ServiceId; uint methodId = header.MethodId; string str = !wasMetered ? "QueueRequest" : "QueueRequest (METERED)"; if (!string.IsNullOrEmpty(body.ToString())) { ServiceDescriptor importedServiceById = this.serviceHelper.GetImportedServiceById(serviceId); object[] args = new object[] { str, (importedServiceById != null) ? importedServiceById.GetMethodName(methodId) : "null", header.ToString(), body.ToString() }; this.m_logSource.LogDebug("{0}: type = {1}, header = {2}, request = {3}", args); } else { ServiceDescriptor descriptor2 = this.serviceHelper.GetImportedServiceById(serviceId); string str2 = (descriptor2 != null) ? descriptor2.GetMethodName(methodId) : null; if ((str2 != "bnet.protocol.connection.ConnectionService.KeepAlive") && (str2 != null)) { object[] objArray2 = new object[] { str, str2, header.ToString() }; this.m_logSource.LogDebug("{0}: type = {1}, header = {2}", objArray2); } else { flag = true; } } if (!flag) { this.m_logSource.LogDebugStackTrace("LogOutgoingPacket: ", 0x20, 1); } } }
public void QueueResponse(RPCContext context, IProtoBuf message) { if ((message == null) || (context.Header == null)) { this.m_logSource.LogError("QueueResponse: invalid response"); } else if (this.serviceHelper.GetImportedServiceById(context.Header.ServiceId) == null) { this.m_logSource.LogError("QueueResponse: error, unrecognized service id: " + context.Header.ServiceId); } else { this.m_logSource.LogDebug(string.Concat(new object[] { "QueueResponse: type=", this.serviceHelper.GetImportedServiceById(context.Header.ServiceId).GetMethodName(context.Header.MethodId), " data=", message })); bnet.protocol.Header header = context.Header; header.SetServiceId(0xfe); header.SetMethodId(0); header.SetSize(message.GetSerializedSize()); context.Header = header; BattleNetPacket packet = new BattleNetPacket(context.Header, message); this.QueuePacket(packet); } }
private void ProcessPendingOutboundPackets() { if (this.m_pendingOutboundPackets.Count > 0) { List <BattleNetPacket> list = new List <BattleNetPacket>(); foreach (BattleNetPacket packet in this.m_pendingOutboundPackets) { bnet.protocol.Header header = packet.GetHeader(); uint serviceId = header.ServiceId; uint methodId = header.MethodId; if (this.m_connMetering.AllowRPCCall(serviceId, methodId)) { this.QueuePacket(packet); } else { list.Add(packet); } } this.m_pendingOutboundPackets = list; } }
public RPCContext QueueRequest(uint serviceId, uint methodId, IProtoBuf message, RPCContextDelegate callback = null, uint objectId = 0) { uint nextToken; if (message == null) { return(null); } object tokenLock = this.tokenLock; lock (tokenLock) { nextToken = RPCConnection.nextToken; RPCConnection.nextToken++; } RPCContext context = new RPCContext(); if (callback != null) { context.Callback = callback; this.waitingForResponse.Add(nextToken, context); } bnet.protocol.Header h = this.CreateHeader(serviceId, methodId, objectId, nextToken, message.GetSerializedSize()); BattleNetPacket item = new BattleNetPacket(h, message); context.Header = h; context.Request = message; if (!this.m_connMetering.AllowRPCCall(serviceId, methodId)) { this.m_pendingOutboundPackets.Add(item); this.LogOutgoingPacket(item, true); return(context); } this.QueuePacket(item); return(context); }
public void Update() { this.ProcessPendingOutboundPackets(); if (this.outBoundPackets.Count > 0) { Queue <BattleNetPacket> queue; Queue <BattleNetPacket> outBoundPackets = this.outBoundPackets; lock (outBoundPackets) { queue = new Queue <BattleNetPacket>(this.outBoundPackets.ToArray()); this.outBoundPackets.Clear(); } while (queue.Count > 0) { BattleNetPacket packet = queue.Dequeue(); if (this.Connection != null) { this.Connection.QueuePacket(packet); } else { this.m_logSource.LogError("##Client Connection object does not exists!##"); } } } if (this.Connection != null) { this.Connection.Update(); } if (this.incomingPackets.Count > 0) { Queue <BattleNetPacket> queue3; Queue <BattleNetPacket> incomingPackets = this.incomingPackets; lock (incomingPackets) { queue3 = new Queue <BattleNetPacket>(this.incomingPackets.ToArray()); this.incomingPackets.Clear(); } while (queue3.Count > 0) { BattleNetPacket packet2 = queue3.Dequeue(); bnet.protocol.Header h = packet2.GetHeader(); this.PrintHeader(h); byte[] body = (byte[])packet2.GetBody(); if (h.ServiceId == 0xfe) { RPCContext context; if (this.waitingForResponse.TryGetValue(h.Token, out context)) { ServiceDescriptor importedServiceById = this.serviceHelper.GetImportedServiceById(context.Header.ServiceId); MethodDescriptor.ParseMethod parser = null; if (importedServiceById != null) { parser = importedServiceById.GetParser(context.Header.MethodId); } if (parser == null) { if (importedServiceById != null) { object[] args = new object[] { importedServiceById.Name, context.Header.MethodId }; this.m_logSource.LogWarning("Incoming Response: Unable to find method for serviceName={0} method id={1}", args); int methodCount = importedServiceById.GetMethodCount(); object[] objArray2 = new object[] { methodCount }; this.m_logSource.LogDebug(" Found {0} methods", objArray2); for (int i = 0; i < methodCount; i++) { MethodDescriptor methodDescriptor = importedServiceById.GetMethodDescriptor((uint)i); if ((methodDescriptor == null) && (i != 0)) { object[] objArray3 = new object[] { i, "<null>" }; this.m_logSource.LogDebug(" Found method id={0} name={1}", objArray3); } else { object[] objArray4 = new object[] { i, methodDescriptor.Name }; this.m_logSource.LogDebug(" Found method id={0} name={1}", objArray4); } } } else { object[] objArray5 = new object[] { context.Header.ServiceId }; this.m_logSource.LogWarning("Incoming Response: Unable to identify service id={0}", objArray5); } } context.Header = h; context.Payload = body; context.ResponseReceived = true; if (context.Callback != null) { context.Callback(context); } this.waitingForResponse.Remove(h.Token); } } else { ServiceDescriptor exportedServiceDescriptor = this.GetExportedServiceDescriptor(h.ServiceId); if (exportedServiceDescriptor != null) { if (this.serviceHelper.GetExportedServiceById(h.ServiceId).GetParser(h.MethodId) == null) { this.m_logSource.LogDebug("Incoming Packet: NULL TYPE service=" + this.serviceHelper.GetExportedServiceById(h.ServiceId).Name + ", method=" + this.serviceHelper.GetExportedServiceById(h.ServiceId).GetMethodName(h.MethodId)); } if (exportedServiceDescriptor.HasMethodListener(h.MethodId)) { RPCContext context2 = new RPCContext { Header = h, Payload = body, ResponseReceived = true }; exportedServiceDescriptor.NotifyMethodListener(context2); } else { string str = ((exportedServiceDescriptor == null) || string.IsNullOrEmpty(exportedServiceDescriptor.Name)) ? "<null>" : exportedServiceDescriptor.Name; this.m_logSource.LogError(string.Concat(new object[] { "[!]Unhandled Server Request Received (Service Name: ", str, " Service id:", h.ServiceId, " Method id:", h.MethodId, ")" })); } } else { this.m_logSource.LogError(string.Concat(new object[] { "[!]Server Requested an Unsupported (Service id:", h.ServiceId, " Method id:", h.MethodId, ")" })); } } } } }
public static void Serialize(Stream stream, Header instance) { stream.WriteByte(8); ProtocolParser.WriteUInt32(stream, instance.ServiceId); if (instance.HasMethodId) { stream.WriteByte(16); ProtocolParser.WriteUInt32(stream, instance.MethodId); } stream.WriteByte(24); ProtocolParser.WriteUInt32(stream, instance.Token); if (instance.HasObjectId) { stream.WriteByte(32); ProtocolParser.WriteUInt64(stream, instance.ObjectId); } if (instance.HasSize) { stream.WriteByte(40); ProtocolParser.WriteUInt32(stream, instance.Size); } if (instance.HasStatus) { stream.WriteByte(48); ProtocolParser.WriteUInt32(stream, instance.Status); } //if (instance.Error.Count > 0) //{ // foreach (ErrorInfo current in instance.Error) // { // stream.WriteByte(58); // ProtocolParser.WriteUInt32(stream, current.GetSerializedSize()); // ErrorInfo.Serialize(stream, current); // } //} if (instance.HasTimeout) { stream.WriteByte(64); ProtocolParser.WriteUInt64(stream, instance.Timeout); } }
public static Header DeserializeLengthDelimited(Stream stream, Header instance) { long num = (long)((ulong)ProtocolParser.ReadUInt32(stream)); num += stream.Position; return Header.Deserialize(stream, instance, num); }
public static Header DeserializeLengthDelimited(Stream stream) { Header header = new Header(); Header.DeserializeLengthDelimited(stream, header); return header; }
public static Header Deserialize(Stream stream, Header instance, long limit) { instance.ObjectId = 0uL; instance.Size = 0u; instance.Status = 0u; //if (instance.Error == null) //{ // instance.Error = new List<ErrorInfo>(); //} while (limit < 0L || stream.Position < limit) { int num = stream.ReadByte(); if (num == -1) { if (limit >= 0L) { throw new EndOfStreamException(); } return instance; } else { int num2 = num; if (num2 != 8) { if (num2 != 16) { if (num2 != 24) { if (num2 != 32) { if (num2 != 40) { if (num2 != 48) { if (num2 != 58) { if (num2 != 64) { Key key = ProtocolParser.ReadKey((byte)num, stream); uint field = key.Field; if (field == 0u) { throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream"); } ProtocolParser.SkipKey(stream, key); } else { instance.Timeout = ProtocolParser.ReadUInt64(stream); } } //else //{ // instance.Error.Add(ErrorInfo.DeserializeLengthDelimited(stream)); //} } else { instance.Status = ProtocolParser.ReadUInt32(stream); } } else { instance.Size = ProtocolParser.ReadUInt32(stream); } } else { instance.ObjectId = ProtocolParser.ReadUInt64(stream); } } else { instance.Token = ProtocolParser.ReadUInt32(stream); } } else { instance.MethodId = ProtocolParser.ReadUInt32(stream); } } else { instance.ServiceId = ProtocolParser.ReadUInt32(stream); } } } if (stream.Position == limit) { return instance; } throw new ProtocolBufferException("Read past max limit"); }
public static Header Deserialize(Stream stream, Header instance) { return Header.Deserialize(stream, instance, -1L); }