409 lines
13 KiB
C#
409 lines
13 KiB
C#
using Quobject.EngineIoClientDotNet.Modules;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace Quobject.EngineIoClientDotNet.Parser
|
|
{
|
|
/// <remarks>
|
|
/// Packet type which is ported from the JavaScript module.
|
|
/// This is the JavaScript parser for the engine.io protocol encoding,
|
|
/// shared by both engine.io-client and engine.io.
|
|
/// <see href="https://github.com/Automattic/engine.io-parser">https://github.com/Automattic/engine.io-parser</see>
|
|
/// </remarks>
|
|
public class Packet
|
|
{
|
|
public static readonly string OPEN = "open";
|
|
public static readonly string CLOSE = "close";
|
|
public static readonly string PING = "ping";
|
|
public static readonly string PONG = "pong";
|
|
public static readonly string UPGRADE = "upgrade";
|
|
public static readonly string MESSAGE = "message";
|
|
public static readonly string NOOP = "noop";
|
|
public static readonly string ERROR = "error";
|
|
|
|
private static readonly int MAX_INT_CHAR_LENGTH = int.MaxValue.ToString().Length;
|
|
|
|
//TODO: suport binary?
|
|
private bool SupportsBinary = false;
|
|
|
|
private static readonly Dictionary<string, byte> _packets = new Dictionary<string, byte>()
|
|
{
|
|
{Packet.OPEN, 0},
|
|
{Packet.CLOSE, 1},
|
|
{Packet.PING, 2},
|
|
{Packet.PONG, 3},
|
|
{Packet.MESSAGE, 4},
|
|
{Packet.UPGRADE, 5},
|
|
{Packet.NOOP, 6}
|
|
};
|
|
|
|
private static readonly Dictionary<byte, string> _packetsList = new Dictionary<byte, string>();
|
|
|
|
static Packet()
|
|
{
|
|
foreach (var entry in _packets)
|
|
{
|
|
_packetsList.Add(entry.Value,entry.Key);
|
|
}
|
|
}
|
|
|
|
private static readonly Packet _err = new Packet(Packet.ERROR,"parser error");
|
|
|
|
public string Type { get; set; }
|
|
public object Data { get; set; }
|
|
|
|
|
|
public Packet(string type, object data)
|
|
{
|
|
this.Type = type;
|
|
this.Data = data;
|
|
}
|
|
|
|
public Packet(string type)
|
|
{
|
|
this.Type = type;
|
|
this.Data = null;
|
|
}
|
|
|
|
internal void Encode(IEncodeCallback callback,bool utf8encode = false)
|
|
{
|
|
if ( Data is byte[])
|
|
{
|
|
if (!SupportsBinary)
|
|
{
|
|
EncodeBase64Packet(callback);
|
|
return;
|
|
}
|
|
EncodeByteArray(callback);
|
|
return;
|
|
}
|
|
var encodedStringBuilder = new StringBuilder();
|
|
encodedStringBuilder.Append(_packets[Type]);
|
|
|
|
if (Data != null)
|
|
{
|
|
encodedStringBuilder.Append( utf8encode ? UTF8.Encode((string) Data): (string)Data);
|
|
}
|
|
|
|
callback.Call(encodedStringBuilder.ToString());
|
|
}
|
|
|
|
private void EncodeBase64Packet(IEncodeCallback callback)
|
|
{
|
|
var byteData = Data as byte[];
|
|
if (byteData != null)
|
|
{
|
|
var result = new StringBuilder();
|
|
result.Append("b");
|
|
result.Append(_packets[Type]);
|
|
result.Append(Convert.ToBase64String(byteData));
|
|
callback.Call(result.ToString());
|
|
return;
|
|
}
|
|
throw new Exception("byteData == null");
|
|
}
|
|
|
|
private void EncodeByteArray(IEncodeCallback callback)
|
|
{
|
|
var byteData = Data as byte[];
|
|
if (byteData != null)
|
|
{
|
|
var resultArray = new byte[1 + byteData.Length];
|
|
resultArray[0] = _packets[Type];
|
|
Array.Copy(byteData, 0, resultArray, 1, byteData.Length);
|
|
callback.Call(resultArray);
|
|
return;
|
|
}
|
|
throw new Exception("byteData == null");
|
|
}
|
|
|
|
internal static Packet DecodePacket(string data, bool utf8decode = false)
|
|
{
|
|
if (data.StartsWith("b"))
|
|
{
|
|
return DecodeBase64Packet(data.Substring(1));
|
|
}
|
|
|
|
int type;
|
|
var s = data.Substring(0, 1);
|
|
if (!int.TryParse(s, out type))
|
|
{
|
|
type = -1;
|
|
}
|
|
|
|
if (utf8decode)
|
|
{
|
|
try
|
|
{
|
|
data = UTF8.Decode(data);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
return _err;
|
|
}
|
|
}
|
|
|
|
if (type < 0 || type >= _packetsList.Count)
|
|
{
|
|
return _err;
|
|
}
|
|
|
|
if (data.Length > 1)
|
|
{
|
|
return new Packet(_packetsList[(byte) type], data.Substring(1));
|
|
}
|
|
return new Packet(_packetsList[(byte) type], null);
|
|
}
|
|
|
|
private static Packet DecodeBase64Packet(string msg)
|
|
{
|
|
int type;
|
|
var s = msg.Substring(0, 1);
|
|
if (!int.TryParse(s, out type))
|
|
{
|
|
type = -1;
|
|
}
|
|
if (type < 0 || type >= _packetsList.Count)
|
|
{
|
|
return _err;
|
|
}
|
|
msg = msg.Substring(1);
|
|
byte[] decodedFromBase64 = Convert.FromBase64String(msg);
|
|
return new Packet(_packetsList[(byte)type], decodedFromBase64);
|
|
}
|
|
|
|
internal static Packet DecodePacket(byte[] data)
|
|
{
|
|
int type = data[0];
|
|
var byteArray = new byte[data.Length - 1];
|
|
Array.Copy(data,1,byteArray,0, byteArray.Length);
|
|
return new Packet(_packetsList[(byte)type], byteArray);
|
|
}
|
|
|
|
|
|
|
|
internal static void EncodePayload(Packet[] packets, IEncodeCallback callback)
|
|
{
|
|
if (packets.Length == 0)
|
|
{
|
|
callback.Call(new byte[0]);
|
|
return;
|
|
}
|
|
|
|
var results = new List<byte[]>(packets.Length);
|
|
var encodePayloadCallback = new EncodePayloadCallback(results);
|
|
foreach (var packet in packets)
|
|
{
|
|
packet.Encode(encodePayloadCallback, true);
|
|
}
|
|
|
|
callback.Call(Buffer.Concat(results.ToArray()));//new byte[results.Count][]
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decodes data when a payload is maybe expected.
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <param name="callback"></param>
|
|
public static void DecodePayload(string data, IDecodePayloadCallback callback)
|
|
{
|
|
if (String.IsNullOrEmpty(data))
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
return;
|
|
}
|
|
|
|
var length = new StringBuilder();
|
|
for (int i = 0, l = data.Length; i < l; i++)
|
|
{
|
|
var chr = Convert.ToChar(data.Substring(i, 1));
|
|
|
|
if (chr != ':')
|
|
{
|
|
length.Append(chr);
|
|
}
|
|
else
|
|
{
|
|
int n;
|
|
if (!int.TryParse(length.ToString(), out n))
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
return;
|
|
}
|
|
|
|
string msg;
|
|
try
|
|
{
|
|
msg = data.Substring(i + 1, n);
|
|
}
|
|
catch (ArgumentOutOfRangeException)
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
return;
|
|
}
|
|
|
|
if (msg.Length != 0)
|
|
{
|
|
Packet packet = DecodePacket(msg, true);
|
|
if (_err.Type == packet.Type && _err.Data == packet.Data)
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
return;
|
|
}
|
|
|
|
bool ret = callback.Call(packet, i + n, l);
|
|
if (!ret)
|
|
{
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
i += n;
|
|
length = new StringBuilder();
|
|
}
|
|
}
|
|
if (length.Length > 0)
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decodes data when a payload is maybe expected.
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <param name="callback"></param>
|
|
public static void DecodePayload(byte[] data, IDecodePayloadCallback callback)
|
|
{
|
|
var bufferTail = ByteBuffer.Wrap(data);
|
|
|
|
var buffers = new List<object>();
|
|
int bufferTail_offset = 0;
|
|
while (bufferTail.Capacity - bufferTail_offset > 0)
|
|
{
|
|
var strLen = new StringBuilder();
|
|
var isString = (bufferTail.Get(0 + bufferTail_offset) & 0xFF) == 0;
|
|
var numberTooLong = false;
|
|
for (int i = 1;; i++)
|
|
{
|
|
int b = bufferTail.Get(i + bufferTail_offset) & 0xFF;
|
|
if (b == 255)
|
|
{
|
|
break;
|
|
}
|
|
// support only integer
|
|
if (strLen.Length > MAX_INT_CHAR_LENGTH)
|
|
{
|
|
numberTooLong = true;
|
|
break;
|
|
}
|
|
strLen.Append(b);
|
|
}
|
|
if (numberTooLong)
|
|
{
|
|
callback.Call(_err, 0, 1);
|
|
return;
|
|
}
|
|
bufferTail_offset += strLen.Length + 1;
|
|
|
|
int msgLength = int.Parse(strLen.ToString());
|
|
|
|
bufferTail.Position(1 + bufferTail_offset);
|
|
bufferTail.Limit(msgLength + 1 + bufferTail_offset);
|
|
var msg = new byte[bufferTail.Remaining()];
|
|
bufferTail.Get(msg, 0, msg.Length);
|
|
|
|
if (isString)
|
|
{
|
|
buffers.Add(ByteArrayToString(msg));
|
|
}
|
|
else
|
|
{
|
|
buffers.Add(msg);
|
|
}
|
|
bufferTail.Clear();
|
|
bufferTail.Position(msgLength + 1 + bufferTail_offset);
|
|
bufferTail_offset += msgLength + 1;
|
|
}
|
|
|
|
var total = buffers.Count;
|
|
for (int i = 0; i < total; i++)
|
|
{
|
|
var buffer = buffers[i];
|
|
if (buffer is string)
|
|
{
|
|
callback.Call(DecodePacket((string) buffer, true), i, total);
|
|
}
|
|
else if (buffer is byte[])
|
|
{
|
|
callback.Call(DecodePacket((byte[])buffer), i, total);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
internal static byte[] StringToByteArray(string str)
|
|
{
|
|
int len = str.Length;
|
|
var bytes = new byte[len];
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
bytes[i] = (byte)str[i];
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
internal static string ByteArrayToString(byte[] bytes)
|
|
{
|
|
//return Encoding.ASCII.GetString(bytes);
|
|
//http://stackoverflow.com/questions/7750850/encoding-ascii-getstring-in-windows-phone-platform
|
|
return string.Concat(bytes.Select(b => b <= 0x7f ? (char)b : '?'));
|
|
}
|
|
|
|
private class EncodePayloadCallback : IEncodeCallback
|
|
{
|
|
private readonly List<byte[]> _results;
|
|
|
|
public EncodePayloadCallback(List<byte[]> results)
|
|
{
|
|
this._results = results;
|
|
}
|
|
|
|
public void Call(object data)
|
|
{
|
|
if (data is string)
|
|
{
|
|
var packet = (string) data;
|
|
var encodingLength = packet.Length.ToString();
|
|
var sizeBuffer = new byte[encodingLength.Length + 2];
|
|
sizeBuffer[0] = (byte) 0; // is a string
|
|
for (var i = 0; i < encodingLength.Length; i++)
|
|
{
|
|
sizeBuffer[i + 1] = byte.Parse(encodingLength.Substring(i,1));
|
|
}
|
|
sizeBuffer[sizeBuffer.Length - 1] = (byte) 255;
|
|
_results.Add(Buffer.Concat(new byte[][] { sizeBuffer, StringToByteArray(packet) }));
|
|
return;
|
|
}
|
|
|
|
var packet1 = (byte[]) data;
|
|
var encodingLength1 = packet1.Length.ToString();
|
|
var sizeBuffer1 = new byte[encodingLength1.Length + 2];
|
|
sizeBuffer1[0] = (byte)1; // is binary
|
|
for (var i = 0; i < encodingLength1.Length; i++)
|
|
{
|
|
sizeBuffer1[i + 1] = byte.Parse(encodingLength1.Substring(i, 1));
|
|
}
|
|
sizeBuffer1[sizeBuffer1.Length - 1] = (byte)255;
|
|
_results.Add(Buffer.Concat(new byte[][] { sizeBuffer1, packet1 }));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|