public void ReadValueError()
{
WireDecoder d = new WireDecoder(new byte[0]);
Assert.That(d.ReadValue(NtType.Unassigned), Is.Null);
Assert.That(d.Error, Is.Not.Null);
}
private void ReadThreadMain()
{
WireDecoder decoder = new WireDecoder(m_stream, ProtoRev);
m_state = State.Handshake;
if (!m_handshake(this, () =>
{
decoder.ProtoRev = ProtoRev;
var msg = Message.Read(decoder, m_getEntryType);
if (msg == null && decoder.Error != null)
{
Debug($"error reading in handshake: {decoder.Error}");
}
return(msg);
}, messages =>
{
m_outgoing.Add(messages);
}))
{
m_state = State.Dead;
Active = false;
return;
}
m_state = State.Active;
m_notifier.NotifyConnection(true, GetConnectionInfo());
while (Active)
{
if (m_stream == null)
{
break;
}
decoder.ProtoRev = ProtoRev;
decoder.Reset();
var msg = Message.Read(decoder, m_getEntryType);
if (msg == null)
{
if (decoder.Error != null)
{
Info($"read error: {decoder.Error}");
}
//terminate connection on bad message
m_stream?.Dispose();
break;
}
Debug3($"received type={msg.Type} with str={msg.Str} id={msg.Id} seqNum={msg.SeqNumUid}");
LastUpdate = Timestamp.Now();
m_processIncoming(msg, this);
}
Debug2($"read thread died ({this})");
if (m_state != State.Dead)
{
m_notifier.NotifyConnection(false, GetConnectionInfo());
}
m_state = State.Dead;
Active = false;
m_outgoing.Add(new List <Message>()); // Also kill write thread
}
public void TestRawValue()
{
byte[] rawData = new byte[]
{
0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o',
0x03, (byte)'b', (byte)'y', (byte)'e', 0x55,
};
WireDecoder d = new WireDecoder(rawData);
var val = d.ReadValue(NtType.Raw);
Assert.That(val.Type, Is.EqualTo(NtType.Raw));
Assert.That(val.Value, Is.EqualTo(v_raw.Value));
var vFalse = RpcValue.MakeRaw((byte)'b', (byte)'y', (byte)'e');
val = d.ReadValue(NtType.Raw);
Assert.That(val.Type, Is.EqualTo(NtType.Raw));
Assert.That(val.Value, Is.EqualTo(vFalse.Value));
byte b = 0;
Assert.That(d.Read8(ref b));
Assert.That(b, Is.EqualTo(0x55));
Assert.That(d.ReadValue(NtType.Raw), Is.Null);
Assert.That(d.Error, Is.Null);
}
public void Read32()
{
byte[] rawData = { 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xab, 0xcd, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00 };
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0300);
uint val = 0;
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(5));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(1));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0xabcd));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0x12345678));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0));
Assert.That(!d.Read32(ref val));
Assert.That(d.Error, Is.Null);
}
public void TestRead32()
{
byte[] rawData = { 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xab, 0xcd, 0x12, 0x34, 0x56, 0x78, 0x00, 0x00, 0x00, 0x00 };
WireDecoder d = new WireDecoder(rawData);
int val = 0;
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(5));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(1));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0xabcd));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0x12345678));
Assert.That(d.Read32(ref val));
Assert.That(val, Is.EqualTo(0));
Assert.That(!d.Read32(ref val));
Assert.That(d.Error, Is.Null);
}
public void StringValue2()
{
byte[] rawData = new byte[]
{
0x00, 0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o',
0x00, 0x03, (byte)'b', (byte)'y', (byte)'e', 0x55,
};
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0200);
var val = d.ReadValue(NtType.String);
Assert.That(val.Type, Is.EqualTo(NtType.String));
Assert.That(val.Val, Is.EqualTo(v_string.Val));
var vFalse = Value.MakeString("bye");
val = d.ReadValue(NtType.String);
Assert.That(val.Type, Is.EqualTo(NtType.String));
Assert.That(val.Val, Is.EqualTo(vFalse.Val));
byte b = 0;
Assert.That(d.Read8(ref b));
Assert.That(b, Is.EqualTo(0x55));
Assert.That(d.ReadValue(NtType.String), Is.Null);
Assert.That(d.Error, Is.Null);
}
public void WriteRpcResponse3()
{
uint id = 1;
uint uid = 1;
byte[] rpc = new byte[] { 0, 1, 2, 3, 4 };
Message msg = Message.RpcResponse(id, uid, rpc);
WireEncoder enc = new WireEncoder(0x0300);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0300);
byte u8 = 0;
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)RpcResponse));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(id));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(uid));
//Force Rpc as ExecuteRpc is Rpc
Value val = dec.ReadValue(NtType.Rpc);
Assert.That(val, Is.Not.Null);
Assert.That(val.Type, Is.EqualTo(NtType.Rpc));
Assert.That(val.GetRpc(), Is.EquivalentTo(rpc));
}
public void WriteEntryUpdate2()
{
uint id = 1;
uint seq = 1;
Value val = Value.MakeDouble(5);
Message msg = Message.EntryUpdate(id, seq, val);
WireEncoder enc = new WireEncoder(0x0200);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0200);
byte u8 = 0;
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)EntryUpdate));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(id));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(seq));
//Forcing double, as rev 2 has a seperate function to grab
val = dec.ReadValue(NtType.Double);
Assert.That(val, Is.Not.Null);
Assert.That(val.Type, Is.EqualTo(NtType.Double));
Assert.That(val.GetDouble(), Is.EqualTo(5));
}
public void RpcValue3()
{
byte[] rawData = new byte[]
{
0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o',
0x03, (byte)'b', (byte)'y', (byte)'e', 0x55,
};
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0300);
var val = d.ReadValue(NtType.Rpc);
Assert.That(val.Type, Is.EqualTo(NtType.Rpc));
Assert.That(val.Val, Is.EqualTo(v_rpc.Val));
var vFalse = Value.MakeRaw((byte)'b', (byte)'y', (byte)'e');
val = d.ReadValue(NtType.Rpc);
Assert.That(val.Type, Is.EqualTo(NtType.Rpc));
Assert.That(val.Val, Is.EqualTo(vFalse.Val));
byte b = 0;
Assert.That(d.Read8(ref b));
Assert.That(b, Is.EqualTo(0x55));
Assert.That(d.ReadValue(NtType.Rpc), Is.Null);
Assert.That(d.Error, Is.Null);
}
public void WriteEntryUpdate3()
{
uint id = 1;
uint seq = 1;
Value val = Value.MakeDouble(5);
Message msg = Message.EntryUpdate(id, seq, val);
WireEncoder enc = new WireEncoder(0x0300);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0300);
byte u8 = 0;
NtType type = 0;
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)EntryUpdate));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(id));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(seq));
Assert.That(dec.ReadType(ref type), Is.True);
Assert.That(type, Is.EqualTo(NtType.Double));
val = dec.ReadValue(type);
Assert.That(val, Is.Not.Null);
Assert.That(val.Type, Is.EqualTo(NtType.Double));
Assert.That(val.GetDouble(), Is.EqualTo(5));
}
public void WriteEntryAssign2()
{
uint id = 1;
uint seq = 1;
EntryFlags flags = EntryFlags.Persistent;
string name = "Testing";
Value val = Value.MakeDouble(5);
Message msg = Message.EntryAssign(name, id, seq, val, flags);
WireEncoder enc = new WireEncoder(0x0200);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0200);
byte u8 = 0;
NtType type = 0;
string str = "";
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)EntryAssign));
Assert.That(dec.ReadString(ref str), Is.True);
Assert.That(str, Is.EqualTo(name));
Assert.That(dec.ReadType(ref type), Is.True);
Assert.That(type, Is.EqualTo(NtType.Double));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(id));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(seq));
val = dec.ReadValue(type);
Assert.That(val, Is.Not.Null);
Assert.That(val.Type, Is.EqualTo(NtType.Double));
Assert.That(val.GetDouble(), Is.EqualTo(5));
}
public void ReadStringArray3()
{
List <byte> b = new List <byte>()
{
0x02,
0x05
};
b.AddRange(Encoding.UTF8.GetBytes("hello"));
b.Add(0x07);
b.AddRange(Encoding.UTF8.GetBytes("goodbye"));
b.Add(0x55);
MemoryStream stream = new MemoryStream(b.ToArray());
WireDecoder d = new WireDecoder(stream, 0x0300);
var val = d.ReadValue(NtType.StringArray);
Assert.That(val.Type, Is.EqualTo(NtType.StringArray));
Assert.That(val.Val, Is.EqualTo(v_stringArray.Val));
byte by = 0;
Assert.That(d.Read8(ref by));
Assert.That(by, Is.EqualTo(0x55));
Assert.That(d.ReadValue(NtType.StringArray), Is.Null);
Assert.That(d.Error, Is.Null);
}
public void ReadDouble()
{
byte[] rawData =
{
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x41, 0x0c, 0x13, 0x80, 0x00, 0x00, 0x00, 0x00,
0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0300);
double val = 0;
Assert.That(d.ReadDouble(ref val));
Assert.That(val, Is.EqualTo(0.0));
Assert.That(d.ReadDouble(ref val));
Assert.That(val, Is.EqualTo(2.3e5));
Assert.That(d.ReadDouble(ref val));
Assert.That(val, Is.EqualTo(double.PositiveInfinity));
Assert.That(d.ReadDouble(ref val));
Assert.That(val, Is.EqualTo(2.2250738585072014e-308));
Assert.That(d.ReadDouble(ref val));
Assert.That(val, Is.EqualTo(double.MaxValue));
Assert.That(!d.ReadDouble(ref val));
Assert.That(d.Error, Is.Null);
}
public void ReadType()
{
byte[] rawData = { 0x00, 0x01, 0x02, 0x03, 0x10, 0x11, 0x12, 0x20 };
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0300);
NtType val = 0;
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.Boolean));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.Double));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.String));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.Raw));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.BooleanArray));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.DoubleArray));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.StringArray));
Assert.That(d.ReadType(ref val));
Assert.That(val, Is.EqualTo(NtType.Rpc));
Assert.That(!d.ReadType(ref val));
Assert.That(d.Error, Is.Null);
}
public void ReadRawError3()
{
MemoryStream stream = new MemoryStream(new byte[] { 0x05 });
WireDecoder d = new WireDecoder(stream, 0x0300);
byte[] str = null;
Assert.That(d.ReadRaw(ref str), Is.False);
}
public void ReadStringError3()
{
MemoryStream stream = new MemoryStream(new byte[] { 0x05 });
WireDecoder d = new WireDecoder(stream, 0x0300);
string str = "";
Assert.That(d.ReadString(ref str), Is.False);
}
public void SetProtoRev()
{
MemoryStream stream = new MemoryStream(new byte[0]);
WireDecoder d = new WireDecoder(stream, 0x0300);
d.ProtoRev = 0x0200;
Assert.That(d.ProtoRev, Is.EqualTo(0x0200));
}
public void ReadValueError3()
{
MemoryStream stream = new MemoryStream(new byte[0]);
WireDecoder d = new WireDecoder(stream, 0x0300);
Assert.That(d.ReadValue(NtType.Unassigned), Is.Null);
Assert.That(d.Error, Is.Not.Null);
}
public void Construct()
{
MemoryStream stream = new MemoryStream(new byte[0]);
WireDecoder d = new WireDecoder(stream, 0x0300);
Assert.That(d.Error, Is.Null);
Assert.That(d.ProtoRev, Is.EqualTo(0x0300));
}
public void TestReadTypeError()
{
byte[] rawData = { 0x30 };
WireDecoder d = new WireDecoder(rawData);
NtType val = 0;
Assert.That(!d.ReadType(ref val));
Assert.That(d.Error, Is.Not.Null);
}
public void HasMoreBytesFailure()
{
int numBytes = 13;
byte[] data = new byte[numBytes - 1];
MemoryStream stream = new MemoryStream(data);
WireDecoder d = new WireDecoder(stream, 0x0300);
Assert.That(d.HasMoreBytes(numBytes), Is.False);
}
public void HasMoreBytesSuccess()
{
int numBytes = 13;
byte[] data = new byte[numBytes];
MemoryStream stream = new MemoryStream(data);
WireDecoder d = new WireDecoder(stream, 0x0300);
Assert.That(d.HasMoreBytes(numBytes), Is.True);
}
public void ReadTypeError()
{
byte[] rawData = { 0x30 };
MemoryStream stream = new MemoryStream(rawData);
WireDecoder d = new WireDecoder(stream, 0x0200);
NtType val = 0;
Assert.That(!d.ReadType(ref val));
Assert.That(d.Error, Is.Not.Null);
}
public void WriteClientHelloDone3()
{
Message msg = Message.ClientHelloDone();
WireEncoder enc = new WireEncoder(0x0300);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0300);
byte u8 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)ClientHelloDone));
}
public void ReadStringArrayError3()
{
byte[] b =
{
0x02,
};
MemoryStream stream = new MemoryStream(b);
WireDecoder d = new WireDecoder(stream, 0x0300);
var val = d.ReadValue(NtType.StringArray);
Assert.That(val, Is.Null);
}
public void WriteClearEntries3()
{
Message msg = Message.ClearEntries();
WireEncoder enc = new WireEncoder(0x0300);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0300);
byte u8 = 0;
uint u32 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)ClearEntries));
Assert.That(dec.Read32(ref u32), Is.True);
Assert.That(u32, Is.EqualTo(0xD06CB27Au));
}
public void WriteProtUnsup2()
{
Message msg = Message.ProtoUnsup();
WireEncoder enc = new WireEncoder(0x0200);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0200);
byte u8 = 0;
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)ProtoUnsup));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo((ushort)0x0200));
}
/// <summary>
/// Unpack a list of values
/// </summary>
/// <param name="packed">The packed data</param>
/// <param name="types">The types the packed data should be</param>
/// <returns>A list of the unpacked values</returns>
public static List <Value> UnpackRpcValues(byte[] packed, params NtType[] types)
{
MemoryStream iStream = new MemoryStream(packed);
WireDecoder dec = new WireDecoder(iStream, 0x0300);
List <Value> vec = new List <Value>();
foreach (var ntType in types)
{
var item = dec.ReadValue(ntType);
if (item == null)
{
return(new List <Value>());
}
vec.Add(item);
}
return(vec);
}
public void WriteEntryDelete3()
{
uint id = 1;
Message msg = Message.EntryDelete(id);
WireEncoder enc = new WireEncoder(0x0300);
msg.Write(enc);
byte[] buf = enc.Buffer;
WireDecoder dec = new WireDecoder(new MemoryStream(buf), 0x0300);
byte u8 = 0;
ushort u16 = 0;
Assert.That(dec.Read8(ref u8), Is.True);
Assert.That(u8, Is.EqualTo((byte)EntryDelete));
Assert.That(dec.Read16(ref u16), Is.True);
Assert.That(u16, Is.EqualTo(id));
}
/// <summary>
/// Unpack a list of values
/// </summary>
/// <param name="packed">The packed data</param>
/// <param name="types">The types the packed data should be</param>
/// <returns>A list of the unpacked values</returns>
public static List <Value> UnpackRpcValues(IList <byte> packed, IList <NtType> types)
{
ListStream iStream = new ListStream(packed);
WireDecoder dec = new WireDecoder(iStream, 0x0300);
List <Value> vec = new List <Value>();
foreach (var ntType in types)
{
var item = dec.ReadValue(ntType);
if (item == null)
{
return(new List <Value>());
}
vec.Add(item);
}
return(vec);
}
