public void WriteBooleanValue3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_boolean);
var v_false = Value.MakeBoolean(false);
e.WriteValue(v_false);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(2));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x01, 0x00 }));
}
public void WriteBooleanArrayValue3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_boolArray);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 3));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x03, 0x00, 0x01, 0x00 }));
e.Reset();
e.WriteValue(v_boolArrayBig);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 255));
Assert.That(new[] { e.Buffer[0], e.Buffer[1] }, Is.EquivalentTo(new byte[] { 0xff, 0x00 }));
}
/// <summary>
/// Pack an Rpc defintion in to a byte array
/// </summary>
/// <param name="def">The definition to pack</param>
/// <returns>The packed data</returns>
public static byte[] PackRpcDefinition(RpcDefinition def)
{
WireEncoder enc = new WireEncoder(0x0300);
enc.Write8((byte)def.Version);
enc.WriteString(def.Name);
int paramsSize = def.Params.Count;
if (paramsSize > 0xff)
{
paramsSize = 0xff;
}
enc.Write8((byte)paramsSize);
for (int i = 0; i < paramsSize; i++)
{
enc.WriteType(def.Params[i].DefValue.Type);
enc.WriteString(def.Params[i].Name);
enc.WriteValue(def.Params[i].DefValue);
}
int resultsSize = def.Results.Count;
if (resultsSize > 0xff)
{
resultsSize = 0xff;
}
enc.Write8((byte)resultsSize);
for (int i = 0; i < resultsSize; i++)
{
enc.WriteType(def.Results[i].Type);
enc.WriteString(def.Results[i].Name);
}
return(enc.Buffer);
}
public void WriteValueNull3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(null);
Assert.That(e.Buffer.Length, Is.EqualTo(0));
Assert.That(e.Error, Is.Not.Null);
}
public void TestWriteValueError()
{
WireEncoder e = new WireEncoder();
e.WriteValue(v_empty);
Assert.That(e.Buffer.Length, Is.EqualTo(0));
Assert.That(e.Error, Is.Not.Null);
}
public void WriteRpcArray3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_rpc);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(6));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' }));
}
public void WriteDoubleValue3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_double);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(8));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }));
}
public void WriteValueError2()
{
WireEncoder e = new WireEncoder(0x0200);
e.WriteValue(v_empty);
Assert.That(e.Buffer.Length, Is.EqualTo(0));
Assert.That(e.Error, Is.Not.Null);
e.Reset();
e.WriteValue(v_raw);
Assert.That(e.Count, Is.EqualTo(0));
Assert.That(e.Error, Is.Not.Null);
e.Reset();
e.WriteValue(v_rpc);
Assert.That(e.Count, Is.EqualTo(0));
Assert.That(e.Error, Is.Not.Null);
}
public void WriteStringValue2()
{
WireEncoder e = new WireEncoder(0x0200);
e.WriteValue(v_string);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(7));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x00, 0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' }));
}
public void TestWriteRawArray()
{
WireEncoder e = new WireEncoder();
e.WriteValue(v_raw);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(6));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[] { 0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o' }));
}
public void WriteStringArrayValue3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_stringArray);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 6 + 8));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[]
{
0x02, 0x05, (byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o',
0x07, (byte)'g', (byte)'o', (byte)'o', (byte)'d', (byte)'b', (byte)'y', (byte)'e'
}));
e.Reset();
e.WriteValue(v_stringArrayBig);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 255 * 2));
Assert.That(new[] { e.Buffer[0], e.Buffer[1] }, Is.EquivalentTo(new byte[] { 0xff, 0x01 }));
}
public void WriteDoubleArrayValue3()
{
WireEncoder e = new WireEncoder(0x0300);
e.WriteValue(v_doubleArray);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 2 * 8));
Assert.That(e.Buffer, Is.EquivalentTo(new byte[]
{
0x02, 0x3f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x3f, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
}));
e.Reset();
e.WriteValue(v_doubleArrayBig);
Assert.That(e.Error, Is.Null);
Assert.That(e.Buffer.Length, Is.EqualTo(1 + 255 * 8));
Assert.That(new[] { e.Buffer[0], e.Buffer[1] }, Is.EquivalentTo(new byte[] { 0xff, 0x00 }));
}
/// <summary>
/// Pack a list of values
/// </summary>
/// <param name="values">The values to pack</param>
/// <returns>The packed values</returns>
public static byte[] PackRpcValues(IList <Value> values)
{
WireEncoder enc = new WireEncoder(0x0300);
foreach (var value in values)
{
enc.WriteValue(value);
}
return(enc.Buffer);
}
public static byte[] PackRpcValues(params RpcValue[] values)
{
WireEncoder enc = new WireEncoder();
foreach (var value in values)
{
enc.WriteValue(value);
}
return(enc.Buffer);
}
public static byte[] PackRpcDefinition(NtRpcDefinition def, out UIntPtr packedLen)
{
WireEncoder enc = new WireEncoder();
enc.Write8((byte)def.Version);
enc.WriteString(def.Name);
int paramsSize = def.ParamsArray.Length;
if (paramsSize > 0xff)
{
paramsSize = 0xff;
}
enc.Write8((byte)paramsSize);
for (int i = 0; i < paramsSize; ++i)
{
enc.WriteType(def.ParamsArray[i].Value.Type);
enc.WriteString(def.ParamsArray[i].Name);
enc.WriteValue(def.ParamsArray[i].Value);
}
int resultsSize = def.ResultsArray.Length;
if (resultsSize > 0xff)
{
resultsSize = 0xff;
}
enc.Write8((byte)resultsSize);
for (int i = 0; i < resultsSize; ++i)
{
enc.WriteType(def.ResultsArray[i].Type);
enc.WriteString(def.ResultsArray[i].Name);
}
packedLen = (UIntPtr)enc.Buffer.Length;
return(enc.Buffer);
}
public void Write(WireEncoder encoder)
{
switch (Type)
{
case MsgType.KeepAlive:
encoder.Write8((byte)MsgType.KeepAlive);
break;
case MsgType.ClientHello:
encoder.Write8((byte)MsgType.ClientHello);
encoder.Write16((ushort)encoder.ProtoRev);
if (encoder.ProtoRev < 0x0300u)
{
return;
}
encoder.WriteString(m_str);
break;
case MsgType.ProtoUnsup:
encoder.Write8((byte)MsgType.ProtoUnsup);
encoder.Write16((ushort)encoder.ProtoRev);
break;
case MsgType.ServerHelloDone:
encoder.Write8((byte)MsgType.ServerHelloDone);
break;
case MsgType.ServerHello:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.ServerHello);
encoder.Write8((byte)Flags);
encoder.WriteString(m_str);
break;
case MsgType.ClientHelloDone:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.ClientHelloDone);
break;
case MsgType.EntryAssign:
encoder.Write8((byte)MsgType.EntryAssign);
encoder.WriteString(m_str);
encoder.WriteType(Val.Type);
encoder.Write16((ushort)Id);
encoder.Write16((ushort)SeqNumUid);
if (encoder.ProtoRev >= 0x0300u)
{
encoder.Write8((byte)Flags);
}
encoder.WriteValue(Val);
break;
case MsgType.EntryUpdate:
encoder.Write8((byte)MsgType.EntryUpdate);
encoder.Write16((ushort)Id);
encoder.Write16((ushort)SeqNumUid);
if (encoder.ProtoRev >= 0x0300u)
{
encoder.WriteType(Val.Type);
}
encoder.WriteValue(Val);
break;
case MsgType.FlagsUpdate:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.FlagsUpdate);
encoder.Write16((ushort)Id);
encoder.Write8((byte)Flags);
break;
case MsgType.EntryDelete:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.EntryDelete);
encoder.Write16((ushort)Id);
break;
case MsgType.ClearEntries:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.ClearEntries);
encoder.Write32(ClearAllMagic);
break;
case MsgType.ExecuteRpc:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.ExecuteRpc);
encoder.Write16((ushort)Id);
encoder.Write16((ushort)SeqNumUid);
encoder.WriteValue(Val);
break;
case MsgType.RpcResponse:
if (encoder.ProtoRev < 0x0300u)
{
return; // new message in version 3.0
}
encoder.Write8((byte)MsgType.RpcResponse);
encoder.Write16((ushort)Id);
encoder.Write16((ushort)SeqNumUid);
encoder.WriteValue(Val);
break;
}
}
