/// <summary> /// Tries to parse data that has been received. /// </summary> /// <param name="numBytes">the number of bytes waiting to be read</param> protected override bool OnReceive(BufferSegment segment) { var packet = new AuthPacketIn(segment, 0, _remainingLength); segment.IncrementUsage(); Console.WriteLine("S <- C: " + packet.PacketId); AuthPacketManager.Instance.HandlePacket(this, packet); _remainingLength = 0; return(true); }
/// <summary> /// </summary> /// <param name="buffer"> /// </param> /// <returns> /// </returns> /// <exception cref="NotImplementedException"> /// </exception> protected override bool OnReceive(BufferSegment buffer) { Message message = null; var packet = new byte[this._remainingLength]; Array.Copy(buffer.SegmentData, packet, this._remainingLength); LogUtil.Debug(DebugInfoDetail.Network, "\r\nReceived: \r\n" + HexOutput.Output(packet)); this._remainingLength = 0; try { message = this.messageSerializer.Deserialize(packet); } catch (Exception) { uint messageNumber = this.GetMessageNumber(packet); this.Server.Warning( this, "Client sent malformed message {0}", messageNumber.ToString(CultureInfo.InvariantCulture)); LogUtil.Debug(DebugInfoDetail.Error, HexOutput.Output(packet)); return(false); } buffer.IncrementUsage(); if (message == null) { uint messageNumber = this.GetMessageNumber(packet); this.Server.Warning( this, "Client sent unknown message {0}", messageNumber.ToString(CultureInfo.InvariantCulture)); return(false); } // FUUUUUGLY Type wrapperType = typeof(MessageWrapper <>); Type genericWrapperType = wrapperType.MakeGenericType(message.Body.GetType()); object wrapped = Activator.CreateInstance(genericWrapperType); wrapped.GetType().GetProperty("Client").SetValue(wrapped, (IZoneClient)this, null); wrapped.GetType().GetProperty("Message").SetValue(wrapped, message, null); wrapped.GetType().GetProperty("MessageBody").SetValue(wrapped, message.Body, null); this.bus.Publish(wrapped); return(true); }
/// <summary> /// </summary> /// <param name="buffer"> /// </param> /// <returns> /// </returns> protected override bool OnReceive(BufferSegment buffer) { Message message = null; var packet = new byte[this._remainingLength]; Array.Copy(buffer.SegmentData, packet, this._remainingLength); if (Program.DebugNetwork) { LogUtil.Debug("Offset: " + buffer.Offset.ToString() + " -- RemainingLength: " + this._remainingLength); LogUtil.Debug(NiceHexOutput.Output(packet)); } this._remainingLength = 0; try { message = this.messageSerializer.Deserialize(packet); } catch (Exception) { uint messageNumber = this.GetMessageNumber(packet); this.Server.Warning( this, "Client sent malformed message {0}", messageNumber.ToString(CultureInfo.InvariantCulture)); return(false); } buffer.IncrementUsage(); if (message == null) { uint messageNumber = this.GetMessageNumber(packet); this.Server.Warning( this, "Client sent unknown message {0}", messageNumber.ToString(CultureInfo.InvariantCulture)); return(false); } this.bus.Publish(new MessageReceivedEvent(this, message)); return(true); }
/// <summary> /// Pass recieved data into the packet buffer and try to parse. /// </summary> /// <param name="_remainingLength">number of bytes waiting to be read</param> /// <returns>false, if there is a part of a packet still remaining</returns> protected override bool OnReceive(BufferSegment segment) { var recvBuffer = segment.Buffer.Array; var i = 1; do { if (_remainingLength < RealmPacketIn.HEADER_SIZE) { return(false); } RealmServerOpCode opcode; //var headerSize = GetContentInfo(recvBuffer, segment.Offset + _offset, out packetLength, out opcode); var offset = segment.Offset + _offset; int headerSize; bool isLargePacket; var packetLength = 0; if (IsEncrypted) { //headerSize = Decrypt(recvBuffer, offset, out packetLength, out opcode); var firstByte = GetDecryptedByte(recvBuffer, offset, 0); isLargePacket = (firstByte & 0x80) != 0; // check for the big packet marker if (isLargePacket) { // packetLength has 23 bits if (_remainingLength < RealmPacketIn.LARGE_PACKET_HEADER_SIZE) { decryptUntil = 0; log.Warn("DecryptUntil: " + decryptUntil); return(false); } packetLength = (firstByte & 0x7F) << 16; packetLength |= GetDecryptedByte(recvBuffer, offset, 1) << 8; packetLength |= GetDecryptedByte(recvBuffer, offset, 2); opcode = (RealmServerOpCode)GetDecryptedOpcode(recvBuffer, offset, 3); headerSize = RealmPacketIn.LARGE_PACKET_HEADER_SIZE; } else { // packetLength has 15 bits packetLength |= firstByte << 8; packetLength |= GetDecryptedByte(recvBuffer, offset, 1); opcode = (RealmServerOpCode)GetDecryptedOpcode(recvBuffer, offset, 2); headerSize = RealmPacketIn.HEADER_SIZE; } } else { packetLength = recvBuffer[offset] << 8 | recvBuffer[offset + 1]; isLargePacket = false; // the opcode is actually 4 bytes, but can never go over 2, so we skip the last 2 opcode = (RealmServerOpCode)(recvBuffer[offset + 2] | recvBuffer[offset + 3] << 8); headerSize = RealmPacketIn.HEADER_SIZE; } packetLength += (headerSize - 4); if (packetLength > BufferSize) { // packet is just too big var bytes = new byte[headerSize]; Array.Copy(recvBuffer, offset, bytes, 0, headerSize); var str = Encoding.UTF8.GetString(bytes); if (str.Equals("GET HT", StringComparison.InvariantCultureIgnoreCase)) { log.Warn("HTTP crawler bot connected from {0} - requesting: {1}", this, str); } else { LogUtil.ErrorException("Client {0} sent corrupted packet (ID: {1}) with size {2} bytes, which exceeds maximum: " + "{3} (packet #{4}, segment #{5}, LargePacket: {6}, Remaining: {7}, Header: {8} ({9}))", this, opcode, packetLength, BufferSize, i, segment.Number, isLargePacket, _remainingLength, Utility.ToString(bytes, " ", b => string.Format("{0:X2}", b)), str); } Disconnect(); return(false); } if (_remainingLength < packetLength) { // packet incomplete if (IsEncrypted) { decryptUntil = headerSize; log.Warn("DecryptUntil: {0}, HeaderSize: {1}, Packet: {2}", decryptUntil, headerSize, opcode); } return(false); } var pkt = new RealmPacketIn(segment, _offset, packetLength, opcode, headerSize); segment.IncrementUsage(); //.UpdatePacketCounters(pkt.PacketId, fullPacketSize); PerformanceCounters.PacketsReceivedPerSecond.Increment(); PerformanceCounters.TotalBytesReceived.IncrementBy(packetLength); RealmPacketMgr.Instance.HandlePacket(this, pkt); _remainingLength -= packetLength; _offset += packetLength; decryptUntil = -1; i++; } while (_remainingLength > 0); return(true); }