public static Header DeSerialize(Type HeaderType, PayloadReader pr)
{
if (pr.Position + 2 > pr.Buffer.Length)
return null;
ushort size = pr.ReadUShort();
if (pr.Position + size > pr.Buffer.Length)
return null;
//byte[] data = pr.ReadBytes(size);
Header header = (Header)Serializer.Deserialize(new MemoryStream(pr.Buffer, pr.Position, size), HeaderType);
pr.Position += size;
return header;
/*FieldInfo[] fields = header.GetType().GetFields();
for (int i = 0; i < fields.Length; i++)
{
//if (fields[i].GetCustomAttributes(typeof(HeaderInfoAttribute), false).Length > 0)
{
object val = pr.ReadObject();
fields[i].SetValue(header, val);
}
}
return header;*/
}
public static Command Parse(Payload payload)
{
if (payload.Length < 2)
{
throw new ArgumentOutOfRangeException(nameof(payload), "payload must have at least 2 bytes");
}
var commandClass = (CommandClass)payload[0];
var commandID = payload[1];
using (var reader = new PayloadReader(payload))
{
switch (commandClass)
{
case CommandClass.Crc16Encap when Crc16Command.EncapCommandID == commandID:
return(reader.ReadObject <Crc16Command>());
case CommandClass.MultiChannel when MultiChannelCommand.EncapCommandID == commandID:
return(reader.ReadObject <MultiChannelCommand>());
default:
return(reader.ReadObject <Command>());
}
}
}
internal ControllerMessage Decode(Message message, bool hasCallbackID)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
// create reader to deserialize the request
using (var reader = new PayloadReader(message.Payload))
{
// read the function
var function = (Function)reader.ReadByte();
var callbackID = hasCallbackID ? reader.ReadByte() : default(byte?);
// read the payload
var payload = new Payload(reader.ReadBytes(reader.Length - reader.Position));
if (message is ResponseMessage)
{
return(new ControllerResponse(function, callbackID, payload));
}
if (message is EventMessage)
{
return(new ControllerEvent(function, callbackID, payload));
}
throw new InvalidOperationException("Unknown message type");
}
}
public void ReadsEventsFromRawBufferFiles()
{
using var tmp = new TempFolder();
var fn = tmp.AllocateFilename("json");
var lines = IOFile.ReadAllText(Path.Combine("Resources", "ThreeBufferedEvents.json.txt"), Encoding.UTF8).Split(new [] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
using (var f = IOFile.Create(fn))
using (var fw = new StreamWriter(f, Encoding.UTF8))
{
foreach (var line in lines)
{
fw.WriteLine(line);
}
}
var position = new FileSetPosition(0, fn);
var count = 0;
var payload = PayloadReader.ReadPayload(1000, null, ref position, ref count, out var mimeType);
Assert.Equal(SeqIngestionApi.RawEventFormatMediaType, mimeType);
Assert.Equal(3, count);
Assert.Equal(576 + 3 * (Environment.NewLine.Length - 1), position.NextLineStart);
Assert.Equal(fn, position.File);
var data = JsonConvert.DeserializeObject <dynamic>(payload);
var events = data["Events"];
Assert.NotNull(events);
Assert.Equal(3, events.Count);
}
protected override void Read(PayloadReader reader)
{
EndpointID = (byte)(reader.ReadByte() & 0x7F);
GenericType = (GenericType)reader.ReadByte();
SpecificType = reader.ReadSpecificType(GenericType);
SupportedCommandClasses = reader.ReadBytes(reader.Length - reader.Position).Select(element => (CommandClass)element).ToArray();
}
/// <summary>
/// This method is used to receive data from anyone
/// The main function of this method is establishing udp-hole connections
/// </summary>
private void UdpAsyncSocketCallback(object o, SocketAsyncEventArgs e)
{
if (e.LastOperation == SocketAsyncOperation.ReceiveFrom)
{
try
{
if (e.BytesTransferred >= 21)
{
PayloadReader pr = new PayloadReader(e.Buffer);
decimal ClientId = pr.ReadDecimal();
lock (Clients)
{
if (Clients.ContainsKey(ClientId))
{
SSPClient client = Clients[ClientId];
client.AsyncSocketCallback(o, e);
}
}
}
}
catch { }
if (!UdpServer.ReceiveFromAsync(udpAsyncSocket))
{
UdpAsyncSocketCallback(null, udpAsyncSocket);
}
}
}
protected override void Read(PayloadReader reader)
{
var commandClass = reader.ReadByte();
CommandClass = (CommandClass)commandClass;
Version = reader.ReadByte();
}
internal static T Create <T>(Node node, Endpoint endpoint, Payload payload) where T : Report, new()
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (payload == null)
{
throw new ArgumentNullException(nameof(payload));
}
var report = new T()
{
Sender = new ReportSender(node, endpoint),
};
using (var reader = new PayloadReader(payload))
{
report.Read(reader);
}
return(report);
}
public void ReadSatoshis()
{
var spanToRead = new byte[50];
BitConverter.TryWriteBytes(spanToRead, 20000UL);
Assert.Equal(20000UL, PayloadReader.GetSatoshis(spanToRead));
}
public static Header DeSerialize(Type HeaderType, PayloadReader pr)
{
if (pr.Position + 2 > pr.Buffer.Length)
{
return(null);
}
ushort size = pr.ReadUShort();
if (pr.Position + size > pr.Buffer.Length)
{
return(null);
}
//byte[] data = pr.ReadBytes(size);
Header header = (Header)Serializer.Deserialize(new MemoryStream(pr.Buffer, pr.Position, size), HeaderType);
pr.Position += size;
return(header);
/*FieldInfo[] fields = header.GetType().GetFields();
* for (int i = 0; i < fields.Length; i++)
* {
* //if (fields[i].GetCustomAttributes(typeof(HeaderInfoAttribute), false).Length > 0)
* {
* object val = pr.ReadObject();
* fields[i].SetValue(header, val);
* }
* }
* return header;*/
}
public void ReadsEventsFromBufferFiles()
{
using var tmp = new TempFolder();
var fn = tmp.AllocateFilename("clef");
var lines = IOFile.ReadAllText(Path.Combine("Resources", "ThreeBufferedEvents.clef.txt"), Encoding.UTF8).Split(new [] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
using (var f = IOFile.Create(fn))
using (var fw = new StreamWriter(f, Encoding.UTF8))
{
foreach (var line in lines)
{
fw.WriteLine(line);
}
}
var position = new FileSetPosition(0, fn);
var count = 0;
PayloadReader.ReadPayload(1000, null, ref position, ref count, out var mimeType);
Assert.Equal(SeqIngestionApi.CompactLogEventFormatMediaType, mimeType);
Assert.Equal(3, count);
Assert.Equal(465 + 3 * (Environment.NewLine.Length - 1), position.NextLineStart);
Assert.Equal(fn, position.File);
}
protected override void Read(PayloadReader reader)
{
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
SourceEndpointID = reader.ReadByte();
TargetEndpointID = reader.ReadByte();
Payload = reader.ReadObject <Payload>();
}
public override void OnPacket(byte[] packetData)
{
try
{
InPacket iPacket = new InPacket(packetData, _CryptoHandler);
PayloadReader pReader = new PayloadReader(iPacket.Payload);
CenterOpcodes opcode = (CenterOpcodes)pReader.Id;
bool isCompressed = pReader.CompressionFlag;
if (isCompressed)
{
Log.Packet("Pacote comprimido recebido: 0x{0:X2} ({1})", (int)opcode, opcode.ToString());
}
else
{
Log.Packet("Opcode: 0x{0:X2} ({1})", (int)opcode, opcode.ToString());
}
switch (opcode)
{
case CenterOpcodes.HEART_BIT_NOT:
OnHeartBeatNot();
break;
case CenterOpcodes.ENU_VERIFY_ACCOUNT_REQ:
MyUser.OnLogin(this, iPacket);
break;
case CenterOpcodes.ENU_GUIDE_BOOK_LIST_REQ:
MyUser.OnGuideBookList(this);
break;
case CenterOpcodes.ENU_CLIENT_CONTENTS_FIRST_INIT_INFO_REQ:
MyLoading.NotifyContentInfo(this);
break;
case CenterOpcodes.ENU_CLIENT_PING_CONFIG_REQ:
OnClientPingConfig();
break;
case CenterOpcodes.ENU_SHAFILENAME_LIST_REQ:
MyLoading.NotifySHAFile(this);
break;
default:
Log.Warn("Pacote indefinido recebido. Opcode: {0:X} ({1})", (int)opcode, opcode.ToString());
Log.Hex("Payload:", iPacket.Payload);
break;
}
}
catch (Exception e)
{
Log.Error(e.Message);
Close();
}
}
public void ReadUdpPacket(IMessage message, PayloadReader pr)
{
FieldInfo[] fields = message.GetType().GetFields();
for (int i = 0; i < fields.Length; i++)
{
fields[i].SetValue(message, pr.ReadObject());
}
}
protected override void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
Value = reader.ReadByte();
}
protected override void Read(PayloadReader reader)
{
var libraryType = reader.ReadByte();
LibraryType = Enum.IsDefined(typeof(LibraryType), libraryType) ? (LibraryType)libraryType : LibraryType.NotApplicable;
ProtocolVersion = reader.ReadByte().ToString("d") + "." + reader.ReadByte().ToString("d2");
ApplicationVersion = reader.ReadByte().ToString("d") + "." + reader.ReadByte().ToString("d2");
}
protected override void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
SupportedGroupings = reader.ReadByte();
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest request,
ILogger logger)
{
string token = request.Headers.GetValueOrDefault("X-Ahk-Token");
string receivedSignature = request.Headers.GetValueOrDefault("X-Ahk-Sha256");
string deliveryId = request.Headers.GetValueOrDefault("X-Ahk-Delivery");
string dateStr = request.Headers.GetValueOrDefault(HeaderNames.Date);
logger.LogInformation("evaluation-result request with X-Ahk-Delivery='{DeliveryId}', X-Ahk-Token = '{Token}'", deliveryId, token);
if (string.IsNullOrEmpty(dateStr))
{
return(new BadRequestObjectResult(new { error = "Date header missing" }));
}
if (!DateTime.TryParseExact(dateStr, "R", provider: System.Globalization.CultureInfo.InvariantCulture, style: System.Globalization.DateTimeStyles.AdjustToUniversal | System.Globalization.DateTimeStyles.AssumeUniversal, out var date))
{
return(new BadRequestObjectResult(new { error = "Date header value not valid RFC1123 string" }));
}
var now = dateTimeProvider.GetUtcNow();
if (date < now.AddMinutes(-10) || date > now.AddMinutes(10))
{
return(new BadRequestObjectResult(new { error = "Date header value is not close enough to current date" }));
}
if (string.IsNullOrEmpty(receivedSignature))
{
return(new BadRequestObjectResult(new { error = "X-Ahk-Sha256 header missing" }));
}
if (string.IsNullOrEmpty(token))
{
return(new BadRequestObjectResult(new { error = "X-Ahk-Token header missing" }));
}
var secret = await service.GetSecretForToken(token);
if (string.IsNullOrEmpty(secret))
{
return(new BadRequestObjectResult(new { error = "X-Ahk-Token invalid" }));
}
string requestBody = await request.ReadAsStringAsync();
if (!HmacSha256Validator.IsSignatureValid(request.Method, request.GetDisplayUrl(), date, requestBody, receivedSignature, secret))
{
return(new BadRequestObjectResult(new { error = "X-Ahk-Sha256 signature not valid" }));
}
if (!PayloadReader.TryGetPayload <AhkProcessResult>(requestBody, out var requestDeserialized, out var deserializationError))
{
return(new BadRequestObjectResult(new { error = deserializationError }));
}
return(await runCore(logger, deliveryId, requestDeserialized, date));
}
/// <summary>
/// Generates the key after a response is received.
/// </summary>
/// <param name="response">The string representation of the response.</param>
public void HandleResponse(PayloadReader pr)
{
// Get the response and modpow it with the stored prime.
using (BigInteger given = pr.ReadBigInteger())
using (BigInteger key = given.modPow(mine, prime))
{
this.key = key.getBytes();
}
Dispose();
}
void IPayloadSerializable.Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
TransmissionState = (TransmissionState)reader.ReadByte();
Unknown1 = reader.ReadByte();
Unknown2 = reader.ReadByte();
}
protected virtual void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
Payload = new Payload(reader.ReadBytes(reader.Length - reader.Position));
}
protected override void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
Type = (SensorType)reader.ReadByte();
Value = reader.ReadDouble(out var scale);
Unit = GetUnit(Type, scale);
Scale = scale;
}
protected override void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
GroupID = reader.ReadByte();
MaxNodesSupported = reader.ReadByte();
ReportsToFollow = reader.ReadByte();
Nodes = reader.ReadBytes(reader.Length - reader.Position);
}
public void ReadData()
{
var spanToRead = new byte[50];
BitConverter.TryWriteBytes(new Span<byte>(spanToRead).Slice(sizeof(ulong)), 20);
spanToRead[sizeof(ulong) + sizeof(int)] = 25;
spanToRead[sizeof(ulong) + sizeof(int) + 19] = 26;
var data = PayloadReader.GetData(spanToRead);
Assert.Equal(20, data.Length);
Assert.Equal(25, data[0]);
Assert.Equal(26, data[19]);
}
protected override void Read(PayloadReader reader)
{
var endpointsInfo = reader.ReadByte();
IsDynamicNumberOfEndpoints = (endpointsInfo & 0x80) > 0;
AllEndpointsAreIdentical = (endpointsInfo & 0x40) > 0;
NumberOfIndividualEndpoints = (byte)(reader.ReadByte() & 0x7F);
// For version 4 only.
if (reader.Position < reader.Length)
{
NumberOfAggregatedEndpoints = (byte)(reader.ReadByte() & 0x7F);
}
}
protected override void Read(PayloadReader reader)
{
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
Payload = new Payload(reader.ReadBytes(reader.Length - reader.Position - 2));
var actualChecksum = reader.ReadInt16();
var expectedChecksum = new byte[] { (byte)CommandClass, CommandID }.Concat(Payload.ToArray()).CalculateCrc16Checksum();
if (actualChecksum != expectedChecksum)
{
throw new ChecksumException("CRC-16 encapsulated command checksum failure");
}
}
/*public IMessage HandleMessage(PayloadReader reader, uint MessageId)
* {
* lock (Messages)
* {
* Type type = null;
* if (!Messages.TryGetValue(MessageId, out type))
* return null;
*
* IMessage message = null;//IMessage.DeSerialize(type, reader);
* return message;
* }
* }*/
public IMessage HandleUdpMessage(PayloadReader reader, uint MessageId)
{
lock (Messages)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
{
return(null);
}
IMessage message = null;//IMessage.DeSerialize(type, reader);
message.RawSize = reader.Length;
return(message);
}
}
internal IMessage DeSerialize(PayloadReader pr, uint MessageId)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
{
return(null);
}
int len = pr.Length - pr.Position;
IMessage message = (IMessage)Serializer.Deserialize(new MemoryStream(pr.Buffer, pr.Position, len), type);
pr.Position += len;
return(message);
}
public void ReadDnsFile(string FilePath)
{
DnsNames.Clear();
if (File.Exists(FilePath) && new FileInfo(FilePath).Length > 0)
{
PayloadReader pr = new PayloadReader(File.ReadAllBytes(FilePath));
for (int i = 0; pr.Offset < pr.Length; i++)
{
string name = pr.ReadString();
uint DnsId = pr.ReadUInteger();
DnsNames.Add(DnsId, new RootDnsInfo(name, DnsId));
}
}
}
private UnknownData ReadUnknownData(byte[] data)
{
MemoryStream stream = new MemoryStream(data);
BinaryReader reader = new BinaryReader(stream);
Serializer dataReader = new PayloadReader(reader);
UnknownData unknownData = new UnknownData();
unknownData.Serialize(dataReader);
reader.Close();
stream.Close();
return(unknownData);
}
public IMessage HandleUdpMessage(PayloadReader reader, uint MessageId)
{
lock (Messages)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
{
return(null);
}
IMessage message = (IMessage)Activator.CreateInstance(type, new object[0]);
message.ReadUdpPacket(message, reader);
message.RawSize = reader.Length;
return(message);
}
}
public object Deserialize(byte[] data)
{
PayloadReader pr = new PayloadReader(data);
ObjectTypes Id = (ObjectTypes)pr.ReadByte();
switch (Id)
{
case ObjectTypes.Null: return null;
case ObjectTypes.Other:
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new DeserializationBinder();
return bf.Deserialize(new MemoryStream(pr.ReadBytes(pr.Length - pr.Position)));
}
case ObjectTypes.Byte: return pr.ReadByte();
case ObjectTypes.Short: return pr.ReadShort();
case ObjectTypes.UShort: return pr.ReadUShort();
case ObjectTypes.Int: return pr.ReadInteger();
case ObjectTypes.UINT: return pr.ReadUInteger();
case ObjectTypes.Long: return pr.ReadLong();
case ObjectTypes.Bool: return pr.ReadByte() == 1;
case ObjectTypes.String: return pr.ReadString();
case ObjectTypes.SolidBrush: return new SolidBrush(Color.FromArgb(pr.ReadByte(), pr.ReadByte(), pr.ReadByte(), pr.ReadByte()));
case ObjectTypes.Rectangle: return new Rectangle(pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger());
case ObjectTypes.Size: return new Size(pr.ReadInteger(), pr.ReadInteger());
case ObjectTypes.ByteArray: return pr.ReadBytes(pr.ReadInteger());
case ObjectTypes.Bitmap:
{
using (MemoryStream stream = new MemoryStream(pr.Buffer, pr.Position, pr.Length - pr.Position))
{
long oldPos = stream.Position;
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
pr.Position += (int)(stream.Position - oldPos);
return bmp;
}
}
default: throw new Exception("Error deserializing");
}
}
internal IMessage DeSerialize(PayloadReader pr, uint MessageId)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
return null;
int len = pr.Length - pr.Position;
IMessage message = (IMessage)Serializer.Deserialize(new MemoryStream(pr.Buffer, pr.Position, len), type);
pr.Position += len;
return message;
}
/*public IMessage HandleMessage(PayloadReader reader, uint MessageId)
{
lock (Messages)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
return null;
IMessage message = null;//IMessage.DeSerialize(type, reader);
return message;
}
}*/
public IMessage HandleUdpMessage(PayloadReader reader, uint MessageId)
{
lock (Messages)
{
Type type = null;
if (!Messages.TryGetValue(MessageId, out type))
return null;
IMessage message = null;//IMessage.DeSerialize(type, reader);
message.RawSize = reader.Length;
return message;
}
}
public object onRequest(AClient connection, PayloadReader pr)
{
ReturnResult result = new ReturnResult(null, false);
bool isDelegate = false;
bool ReadFullHeader = false;
try
{
int SharedClassId = pr.ReadInteger();
int MethodId = pr.ReadInteger();
isDelegate = pr.ReadByte() == 1;
int DelegateId = isDelegate ? pr.ReadInteger() : 0;
int DelegateClassId = isDelegate ? pr.ReadInteger() : 0;
ReadFullHeader = true;
if (connection.RemoteSharedClasses.ContainsKey(SharedClassId) ||
(isDelegate && connection.LocalSharedClasses.ContainsKey(DelegateClassId)))
{
SharedClass sClass = isDelegate ? connection.LocalSharedClasses[SharedClassId] : connection.RemoteSharedClasses[SharedClassId];
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List<object> args = new List<object>();
List<Type> types = new List<Type>();
SortedList<int, SharedDelegate> SharedDelegates = new SortedList<int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock(sharedMethod.Delegates)
{
if(sharedMethod.Delegates.ContainsKey(DelegateId))
{
for (int i = 0; i < sharedMethod.Delegates[DelegateId].sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject<SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
//only show the result and not the actual ReturnResult type
return sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray());
}
else
{
MethodInfo m = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
if (m.GetCustomAttributes(typeof(RemoteExecutionAttribute), false).Length == 0 &&
m.GetCustomAttributes(typeof(UncheckedRemoteExecutionAttribute), false).Length == 0)
{
return null;
}
result.ReturnValue = m.Invoke(sClass.InitializedClass, args.ToArray());
}
}
}
} catch (Exception ex)
{
if (isDelegate && ReadFullHeader)
throw ex;
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
}
return result;
}
private void AynsReceive(IAsyncResult result)
{
int BytesTransferred = -1;
try
{
BytesTransferred = Handle.EndReceive(result);
SysLogger.Log("Received " + BytesTransferred, SysLogType.Network);
if (BytesTransferred <= 0)
{
Disconnect();
return;
}
}
catch(Exception ex)
{
SysLogger.Log(ex.Message, SysLogType.Error);
Disconnect();
return;
}
try
{
//let's check the certificate
if (Client.Server != null && Client.Server.serverProperties != null)
{
if (Client.ConnectionTime > Client.Server.serverProperties.ClientTimeConnected)
{
//we need to wait till the time is right
Disconnect();
return;
}
}
this.LastPacketRecvSW = Stopwatch.StartNew();
ReadableDataLen += BytesTransferred;
DataIn += (ulong)BytesTransferred;
bool Process = true;
while (Process)
{
if (ReceiveState == ReceiveType.Header)
{
Process = ReadableDataLen >= HEADER_SIZE;
if (ReadableDataLen >= HEADER_SIZE)
{
lock (HeaderEncryption)
{
headerConfuser.Deobfuscate(ref Buffer, ReadOffset);
HeaderEncryption.Decrypt(Buffer, ReadOffset, HEADER_SIZE);
}
using(PayloadReader pr = new PayloadReader(Buffer))
{
pr.Position = ReadOffset;
PayloadLen = pr.ReadThreeByteInteger();
CurPacketId = pr.ReadByte();
ConnectionId = pr.ReadUShort();
HeaderId = pr.ReadUShort();
HeaderChecksum = pr.ReadByte();
FeatureId = pr.ReadInteger();
}
byte ReChecksum = 0; //re-calculate the checksum
ReChecksum += (byte)PayloadLen;
ReChecksum += CurPacketId;
ReChecksum += (byte)ConnectionId;
ReChecksum += (byte)HeaderId;
ReChecksum += (byte)FeatureId;
if (ReChecksum != HeaderChecksum ||
PayloadLen >= MAX_PACKET_SIZE ||
PayloadLen < 0)
{
Disconnect();
return;
}
if(PayloadLen > Buffer.Length)
{
ResizeBuffer(PayloadLen);
}
TotalReceived = HEADER_SIZE;
ReadableDataLen -= HEADER_SIZE;
ReadOffset += HEADER_SIZE;
ReceiveState = ReceiveType.Payload;
}
}
else if (ReceiveState == ReceiveType.Payload)
{
Process = ReadableDataLen >= PayloadLen;
if (ReadableDataLen >= PayloadLen)
{
byte[] DecryptedBuffer = null;
int DecryptedBuffLen = 0;
messageHandler.DecryptMessage(this, Buffer, ReadOffset, PayloadLen, ref DecryptedBuffer, ref DecryptedBuffLen);
if (DecryptedBuffer == null)
{
//failed to decrypt data
Disconnect();
return;
}
TotalReceived += PayloadLen;
using (PayloadReader pr = new PayloadReader(DecryptedBuffer))
{
OperationalSocket OpSocket = null;
if (ConnectionId > 0)
{
lock(OperationalSockets)
{
if (!OperationalSockets.TryGetValue(ConnectionId, out OpSocket))
{
//strange...
Disconnect();
return;
}
}
}
Type type = Headers.GetHeaderType(HeaderId);
if (type != null)
{
Header header = Header.DeSerialize(type, pr);
if(header == null)
{
Disconnect();
return;
}
uint MessageId = pr.ReadUInteger();
IMessage message = OpSocket != null ? OpSocket.MessageHandler.DeSerialize(pr, MessageId) : messageHandler.DeSerialize(pr, MessageId);
if (message != null)
{
message.RawSize = TotalReceived;
message.Header = header;
if (!HandShakeCompleted)
{
if (message.GetType() == typeof(MsgHandshake))
{
//process the handshake messages straight away
message.ProcessPayload(Client, null);
}
}
else
{
ProcessMessage(new SystemPacket(header, message, ConnectionId, OpSocket));
}
}
}
else
{
Disconnect();
return;
}
}
TotalReceived = 0;
PacketsIn++;
ReadOffset += PayloadLen;
ReadableDataLen -= PayloadLen;
ReceiveState = ReceiveType.Header;
}
}
}
int len = ReceiveState == ReceiveType.Header ? HEADER_SIZE : PayloadLen;
if (ReadOffset + len >= this.Buffer.Length)
{
//no more room for this data size, at the end of the buffer ?
//copy the buffer to the beginning
Array.Copy(this.Buffer, ReadOffset, this.Buffer, 0, ReadableDataLen);
WriteOffset = ReadableDataLen;
ReadOffset = 0;
}
else
{
//payload fits in the buffer from the current offset
//use BytesTransferred to write at the end of the payload
//so that the data is not split
WriteOffset += BytesTransferred;
}
if (Buffer.Length - WriteOffset > 0)
{
Handle.BeginReceive(this.Buffer, WriteOffset, Buffer.Length - WriteOffset, SocketFlags.None, AynsReceive, null);
}
else
{
//Shoudln't be even possible... very strange
Disconnect();
}
}
catch(Exception ex)
{
//unexpected error, client might have disconnected itself, or else report this error
SysLogger.Log(ex.Message, SysLogType.Error);
Disconnect();
return;
}
}
