private static SocketIOPacket CreateMessagePacket(JArray JsonArray, int PacketID, bool JsonOnly)
{
SocketIOPacket Packet = new SocketIOPacket()
{
EnginePacketType = EngineIOPacketType.MESSAGE
};
Packet.JsonData = JsonArray;
Packet.IsJson = true;
if (PacketID >= 0)
{
Packet.ID = PacketID;
}
if (!JsonOnly)
{
using (Deconstructor Deconstructor = new Deconstructor())
{
Deconstructor.SetPacket(Packet);
Packet = Deconstructor.Deconstruct();
if (Packet.Attachments.Count > 0)
{
Packet.IsJson = false;
}
}
}
return(Packet);
}
public static SocketIOPacket Decode(EngineIOPacketType EnginePacketType, byte[] BinaryData)
{
SocketIOPacket Packet = new SocketIOPacket();
Packet.EnginePacketType = EnginePacketType;
Packet.BinaryData = new List <byte>(BinaryData).ToArray();
Packet.IsBinary = true;
return(Packet);
}
public static SocketIOPacket CreateEventPacket(JArray JsonArray, SocketIOAck Ack, bool JsonOnly)
{
SocketIOPacket Packet = CreateMessagePacket(JsonArray, Ack, JsonOnly);
if (Packet.IsJson)
{
Packet.SocketPacketType = SocketIOPacketType.EVENT;
}
else
{
Packet.SocketPacketType = SocketIOPacketType.BINARY_EVENT;
}
Packet.IsJson = true;
return(Packet);
}
public static SocketIOPacket Decode(byte[] RawData)
{
try
{
SocketIOPacket Packet = new SocketIOPacket();
Queue <byte> BufferQueue = new Queue <byte>(RawData);
return(Decode((EngineIOPacketType)BufferQueue.Dequeue(), BufferQueue.ToArray()));
}
catch (Exception ex)
{
StringBuilder Builder = new StringBuilder();
if (RawData != null)
{
Builder.Append(BitConverter.ToString(RawData));
}
throw new SocketIOClientException("Packet decoding failed. " + Builder, ex);
}
}
private SocketIOPacket(SocketIOPacket Packet)
{
this.EnginePacketType = Packet.EnginePacketType;
this.SocketPacketType = Packet.SocketPacketType;
if (Packet.Attachments != null)
{
this.Attachments = new Queue <SocketIOPacket>(Packet.Attachments);
}
else
{
this.Attachments = null;
}
this.Namespace = Packet.Namespace;
this.ID = Packet.ID;
this.IsJson = Packet.IsJson;
this.IsBinary = Packet.IsBinary;
if (Packet.JsonData != null)
{
this.JsonData = Packet.JsonData.DeepClone();
}
else
{
this.JsonData = null;
}
if (Packet.BinaryData != null)
{
this.BinaryData = new List <byte>(Packet.BinaryData).ToArray();
}
else
{
this.BinaryData = null;
}
}
public static SocketIOPacket CreateAckPacket(JArray JsonArray, int PacketID)
{
if (PacketID >= 0)
{
SocketIOPacket Packet = CreateMessagePacket(JsonArray, PacketID, false);
if (Packet.IsJson)
{
Packet.SocketPacketType = SocketIOPacketType.ACK;
}
else
{
Packet.SocketPacketType = SocketIOPacketType.BINARY_ACK;
}
Packet.IsJson = true;
return(Packet);
}
else
{
return(null);
}
}
public static SocketIOPacket Decode(string PacketString)
{
try
{
SocketIOPacket Packet = new SocketIOPacket();
int Offset = 0;
if ((Packet.EnginePacketType = (EngineIOPacketType)(PacketString[Offset] - '0')) == EngineIOPacketType.MESSAGE)
{
Packet.SocketPacketType = (SocketIOPacketType)(PacketString[++Offset] - '0');
}
if (PacketString.Length <= 2)
{
return(Packet);
}
if (Packet.SocketPacketType == SocketIOPacketType.BINARY_EVENT || Packet.SocketPacketType == SocketIOPacketType.BINARY_ACK)
{
StringBuilder Builder = new StringBuilder();
while (Offset < PacketString.Length - 1)
{
char c = PacketString[++Offset];
if (char.IsNumber(c))
{
Builder.Append(c);
}
else
{
break;
}
}
Packet.Attachments = new Queue <SocketIOPacket>(new SocketIOPacket[int.Parse(Builder.ToString())]);
}
if ('/' == PacketString[Offset + 1])
{
StringBuilder Builder = new StringBuilder();
while (Offset < PacketString.Length - 1 && PacketString[++Offset] != ',')
{
Builder.Append(PacketString[Offset]);
}
Packet.Namespace = Builder.ToString();
}
else
{
Packet.Namespace = "/";
}
char Next = PacketString[Offset + 1];
if (!char.IsWhiteSpace(Next) && char.IsNumber(Next))
{
StringBuilder Builder = new StringBuilder();
while (Offset < PacketString.Length - 1)
{
char c = PacketString[++Offset];
if (char.IsNumber(c))
{
Builder.Append(c);
}
else
{
--Offset;
break;
}
}
Packet.ID = int.Parse(Builder.ToString());
}
if (++Offset < PacketString.Length - 1)
{
Packet.JsonData = (JToken)JsonConvert.DeserializeObject(PacketString.Substring(Offset));
Packet.IsJson = true;
}
return(Packet);
}
catch (Exception ex)
{
throw new SocketIOClientException("Packet decoding failed. " + PacketString, ex);
}
}
public static object Encode(SocketIOPacket Packet)
{
try
{
if (Packet.IsBinary)
{
List <byte> RawData = new List <byte>();
RawData.Add((byte)Packet.EnginePacketType);
RawData.AddRange(Packet.BinaryData);
return(RawData.ToArray());
}
else
{
StringBuilder Builder = new StringBuilder();
if (Packet.EnginePacketType.Equals(EngineIOPacketType.UNKNOWN))
{
return(Builder.ToString());
}
Builder.Append((int)Packet.EnginePacketType);
if (!Packet.EnginePacketType.Equals(EngineIOPacketType.MESSAGE))
{
return(Builder.ToString());
}
if (!Packet.SocketPacketType.Equals(SocketIOPacketType.UNKNOWN))
{
Builder.Append((int)Packet.SocketPacketType);
}
if (Packet.SocketPacketType == SocketIOPacketType.BINARY_EVENT || Packet.SocketPacketType == SocketIOPacketType.BINARY_ACK)
{
Builder.Append(Packet.Attachments.Count);
Builder.Append('-');
}
if (!string.IsNullOrEmpty(Packet.Namespace) && !Packet.Namespace.Equals("/"))
{
Builder.Append(Packet.Namespace);
Builder.Append(',');
}
if (Packet.ID > -1)
{
Builder.Append(Packet.ID);
}
if (Packet.IsJson)
{
if (Packet != null)
{
Builder.Append(Packet.JsonData.ToString());
}
else
{
Builder.Append("[null]");
}
}
return(Builder.ToString());
}
}
catch (Exception e)
{
throw new SocketIOClientException("Packet encoding failed. " + Packet, e);
}
}
