| public ReadBytes ( int numberOfBytes, byte &result ) : bool | ||
| numberOfBytes | int | |
| result | byte | |
| return | bool | |
public void Read(NetBuffer im)
{
MessagePacketId = im.ReadInt64();
Number = im.ReadInt32();
int length = im.ReadInt32();
if (length != 0)
{
Bytes = im.ReadBytes(length);
}
}
public void Read(NetBuffer im)
{
PluginName = im.ReadString();
MethodName = im.ReadString();
RspType = im.ReadByte();
if (RspType == StringDataType)
{
StringCommandRsp = im.ReadString();
}
else if (RspType == BinaryDataType)
{
int l = im.ReadInt32();
BinaryCommandRsp = im.ReadBytes(l);
}
}
/// <summary>
/// Read this message from the packet buffer
/// </summary>
/// <returns>new read pointer position</returns>
internal void ReadFrom(NetBuffer buffer, IPEndPoint endpoint)
{
m_senderEndPoint = endpoint;
// read header
byte header = buffer.ReadByte();
m_type = (NetMessageLibraryType)(header & 7);
m_sequenceChannel = (NetChannel)(header >> 3);
m_sequenceNumber = buffer.ReadUInt16();
int payLen = (int)buffer.ReadVariableUInt32();
// copy payload into message buffer
m_data.EnsureBufferSize(payLen * 8);
buffer.ReadBytes(m_data.Data, 0, payLen);
m_data.Reset(0, payLen * 8);
return;
}
/// <summary>
/// Read this message from the packet buffer
/// </summary>
/// <returns>new read pointer position</returns>
internal void ReadFrom(NetBuffer buffer, IPEndPoint endpoint)
{
m_senderEndPoint = endpoint;
// read header
byte header = buffer.ReadByte();
m_type = (NetMessageLibraryType)(header & 7);
m_sequenceChannel = (NetChannel)(header >> 3);
m_sequenceNumber = buffer.ReadUInt16();
int payLen = (int)buffer.ReadVariableUInt32();
// copy payload into message buffer
m_data.EnsureBufferSize(payLen * 8);
buffer.ReadBytes(m_data.Data, 0, payLen);
m_data.Reset(0, payLen * 8);
return;
}
/// <summary>
/// Read this message from the packet buffer
/// </summary>
/// <returns>new read pointer position</returns>
internal bool ReadFrom(NetBuffer buffer, NetworkEndPoint endpoint)
{
m_senderEndPoint = endpoint;
// read header
byte header;
// ignore zero padding in the beginning until we get something non-zero
do
{
if (buffer.BytesRemaining == 0)
{
return(false);
}
header = buffer.ReadByte();
} while (header == 0);
m_type = (NetMessageLibraryType)(header & 7);
m_sequenceChannel = (NetChannel)(header >> 3);
//TODO: do not read seqno for unreliable, just set it to 0 (DAVID)
m_sequenceNumber = buffer.ReadUInt16();
int payLen = (int)buffer.ReadVariableUInt32();
if (payLen > buffer.BytesRemaining)
{
return(false); // bad packet
}
// copy payload into message buffer
m_data.EnsureBufferSizeInBytes(payLen);
buffer.ReadBytes(m_data.Data, 0, payLen);
m_data.Reset(0, payLen * 8);
return(true);
}
static unsafe void Main(string[] args)
{
// JIT stuff
NetBuffer msg = new NetBuffer(20);
msg.Write((short)short.MaxValue);
// Go
double timeStart = NetTime.Now;
msg = new NetBuffer(20);
for (int n = 0; n < 10000; n++)
{
msg.Reset();
msg.Write((short)short.MaxValue);
msg.Write((short)short.MinValue);
msg.Write((short)-42);
msg.Write(421);
msg.Write((byte)7);
msg.Write(-42.8f);
if (msg.LengthBytes != 15)
throw new Exception("Bad message length");
msg.Write("duke of earl");
int bytesWritten;
bytesWritten = msg.WriteVariableInt32(-1);
bytesWritten = msg.WriteVariableInt32(5);
bytesWritten = msg.WriteVariableInt32(-18);
bytesWritten = msg.WriteVariableInt32(42);
bytesWritten = msg.WriteVariableInt32(-420);
msg.Write((uint)9991);
// byte boundary kept until here
msg.Write(true);
msg.Write((uint)3, 5);
msg.Write(8.111f);
msg.Write("again");
byte[] arr = new byte[] { 1, 6, 12, 24 };
msg.Write(arr);
msg.Write((byte)7, 7);
msg.Write(Int32.MinValue);
msg.Write(UInt32.MaxValue);
msg.WriteRangedSingle(21.0f, -10, 50, 12);
// test reduced bit signed writing
msg.Write(15, 5);
msg.Write(2, 5);
msg.Write(0, 5);
msg.Write(-1, 5);
msg.Write(-2, 5);
msg.Write(-15, 5);
msg.Write(UInt64.MaxValue);
msg.Write(Int64.MaxValue);
msg.Write(Int64.MinValue);
msg.Write(42);
msg.WritePadBits();
int numBits = msg.WriteRangedInteger(0, 10, 5);
if (numBits != 4)
throw new Exception("Ack WriteRangedInteger failed");
// verify
msg.Position = 0;
short a = msg.ReadInt16();
short b = msg.ReadInt16();
short c = msg.ReadInt16();
if (a != short.MaxValue || b != short.MinValue || c != -42)
throw new Exception("Ack thpth short failed");
if (msg.ReadInt32() != 421)
throw new Exception("Ack thphth 1");
if (msg.ReadByte() != (byte)7)
throw new Exception("Ack thphth 2");
if (msg.ReadSingle() != -42.8f)
throw new Exception("Ack thphth 3");
if (msg.ReadString() != "duke of earl")
throw new Exception("Ack thphth 4");
if (msg.ReadVariableInt32() != -1) throw new Exception("ReadVariableInt32 failed 1");
if (msg.ReadVariableInt32() != 5) throw new Exception("ReadVariableInt32 failed 2");
if (msg.ReadVariableInt32() != -18) throw new Exception("ReadVariableInt32 failed 3");
if (msg.ReadVariableInt32() != 42) throw new Exception("ReadVariableInt32 failed 4");
if (msg.ReadVariableInt32() != -420) throw new Exception("ReadVariableInt32 failed 5");
if (msg.ReadUInt32() != 9991)
throw new Exception("Ack thphth 4.5");
if (msg.ReadBoolean() != true)
throw new Exception("Ack thphth 5");
if (msg.ReadUInt32(5) != (uint)3)
throw new Exception("Ack thphth 6");
if (msg.ReadSingle() != 8.111f)
throw new Exception("Ack thphth 7");
if (msg.ReadString() != "again")
throw new Exception("Ack thphth 8");
byte[] rrr = msg.ReadBytes(4);
if (rrr[0] != arr[0] || rrr[1] != arr[1] || rrr[2] != arr[2] || rrr[3] != arr[3])
throw new Exception("Ack thphth 9");
if (msg.ReadByte(7) != 7)
throw new Exception("Ack thphth 10");
if (msg.ReadInt32() != Int32.MinValue)
throw new Exception("Ack thphth 11");
if (msg.ReadUInt32() != UInt32.MaxValue)
throw new Exception("Ack thphth 12");
float v = msg.ReadRangedSingle(-10, 50, 12);
// v should be close to, but not necessarily exactly, 21.0f
if ((float)Math.Abs(21.0f - v) > 0.1f)
throw new Exception("Ack thphth *RangedSingle() failed");
if (msg.ReadInt32(5) != 15)
throw new Exception("Ack thphth ReadInt32 1");
if (msg.ReadInt32(5) != 2)
throw new Exception("Ack thphth ReadInt32 2");
if (msg.ReadInt32(5) != 0)
throw new Exception("Ack thphth ReadInt32 3");
if (msg.ReadInt32(5) != -1)
throw new Exception("Ack thphth ReadInt32 4");
if (msg.ReadInt32(5) != -2)
throw new Exception("Ack thphth ReadInt32 5");
if (msg.ReadInt32(5) != -15)
throw new Exception("Ack thphth ReadInt32 6");
UInt64 longVal = msg.ReadUInt64();
if (longVal != UInt64.MaxValue)
throw new Exception("Ack thphth UInt64");
if (msg.ReadInt64() != Int64.MaxValue)
throw new Exception("Ack thphth Int64");
if (msg.ReadInt64() != Int64.MinValue)
throw new Exception("Ack thphth Int64");
if (msg.ReadInt32() != 42)
throw new Exception("Ack thphth end");
msg.SkipPadBits();
if (msg.ReadRangedInteger(0, 10) != 5)
throw new Exception("Ack thphth ranged integer");
}
// test writevariableuint64
NetBuffer largeBuffer = new NetBuffer(100 * 8);
UInt64[] largeNumbers = new ulong[100];
for (int i = 0; i < 100; i++)
{
largeNumbers[i] = ((ulong)NetRandom.Instance.NextUInt() << 32) | (ulong)NetRandom.Instance.NextUInt();
largeBuffer.WriteVariableUInt64(largeNumbers[i]);
}
largeBuffer.Position = 0;
for (int i = 0; i < 100; i++)
{
UInt64 ln = largeBuffer.ReadVariableUInt64();
if (ln != largeNumbers[i])
throw new Exception("large fail");
}
//
// Extended tests on padbits
//
for (int i = 1; i < 31; i++)
{
NetBuffer buf = new NetBuffer();
buf.Write((int)1, i);
if (buf.LengthBits != i)
throw new Exception("Bad length!");
buf.WritePadBits();
int wholeBytes = buf.LengthBits / 8;
if (wholeBytes * 8 != buf.LengthBits)
throw new Exception("WritePadBits failed! Length is " + buf.LengthBits);
}
NetBuffer small = new NetBuffer(100);
byte[] rnd = new byte[24];
int[] bits = new int[24];
for (int i = 0; i < 24; i++)
{
rnd[i] = (byte)NetRandom.Instance.Next(0, 65);
bits[i] = NetUtility.BitsToHoldUInt((uint)rnd[i]);
small.Write(rnd[i], bits[i]);
}
small.Position = 0;
for (int i = 0; i < 24; i++)
{
byte got = small.ReadByte(bits[i]);
if (got != rnd[i])
throw new Exception("Failed small allocation test");
}
double timeEnd = NetTime.Now;
double timeSpan = timeEnd - timeStart;
Console.WriteLine("Trivial tests passed in " + (timeSpan * 1000.0) + " milliseconds");
Console.WriteLine("Creating client and server for live testing...");
NetConfiguration config = new NetConfiguration("unittest");
config.Port = 14242;
NetServer server = new NetServer(config);
NetBuffer serverBuffer = new NetBuffer();
server.Start();
config = new NetConfiguration("unittest");
NetClient client = new NetClient(config);
client.SetMessageTypeEnabled(NetMessageType.Receipt, true);
NetBuffer clientBuffer = client.CreateBuffer();
client.Start();
client.Connect("127.0.0.1", 14242);
List<string> events = new List<string>();
double end = double.MaxValue;
double disconnect = double.MaxValue;
while (NetTime.Now < end)
{
double now = NetTime.Now;
NetMessageType nmt;
NetConnection sender;
//
// client
//
if (client.ReadMessage(clientBuffer, out nmt))
{
switch (nmt)
{
case NetMessageType.StatusChanged:
Console.WriteLine("Client: " + client.Status + " (" + clientBuffer.ReadString() + ")");
events.Add("CStatus " + client.Status);
if (client.Status == NetConnectionStatus.Connected)
{
// send reliable message
NetBuffer buf = client.CreateBuffer();
buf.Write(true);
buf.Write((int)52, 7);
buf.Write("Hallon");
client.SendMessage(buf, NetChannel.ReliableInOrder1, new NetBuffer("kokos"));
}
if (client.Status == NetConnectionStatus.Disconnected)
end = NetTime.Now + 1.0; // end in one second
break;
case NetMessageType.Receipt:
events.Add("CReceipt " + clientBuffer.ReadString());
break;
case NetMessageType.ConnectionRejected:
case NetMessageType.BadMessageReceived:
throw new Exception("Failed: " + nmt);
case NetMessageType.DebugMessage:
// silently ignore
break;
default:
// ignore
Console.WriteLine("Ignored: " + nmt);
break;
}
}
//
// server
//
if (server.ReadMessage(serverBuffer, out nmt, out sender))
{
switch (nmt)
{
case NetMessageType.StatusChanged:
events.Add("SStatus " + sender.Status);
Console.WriteLine("Server: " + sender.Status + " (" + serverBuffer.ReadString() + ")");
break;
case NetMessageType.ConnectionRejected:
case NetMessageType.BadMessageReceived:
throw new Exception("Failed: " + nmt);
case NetMessageType.Data:
events.Add("DataRec " + serverBuffer.LengthBits);
bool shouldBeTrue = serverBuffer.ReadBoolean();
int shouldBeFifthTwo = serverBuffer.ReadInt32(7);
string shouldBeHallon = serverBuffer.ReadString();
if (shouldBeTrue != true ||
shouldBeFifthTwo != 52 ||
shouldBeHallon != "Hallon")
throw new Exception("Bad data transmission");
disconnect = now + 1.0;
break;
case NetMessageType.DebugMessage:
// silently ignore
break;
default:
// ignore
Console.WriteLine("Ignored: " + nmt);
break;
}
}
if (now > disconnect)
{
server.Connections[0].Disconnect("Bye", 0.1f);
disconnect = double.MaxValue;
}
}
// verify events
string[] expected = new string[] {
"CStatus Connecting",
"SStatus Connecting",
"CStatus Connected",
"SStatus Connected",
"DataRec 64",
"CReceipt kokos",
"SStatus Disconnecting",
"CStatus Disconnecting",
"SStatus Disconnected",
"CStatus Disconnected"
};
if (events.Count != expected.Length)
throw new Exception("Mismatch in events count! Expected " + expected.Length + ", got " + events.Count);
for(int i=0;i<expected.Length;i++)
{
if (events[i] != expected[i])
throw new Exception("Event " + i + " (" + expected[i] + ") mismatched!");
}
Console.WriteLine("All tests successful");
Console.ReadKey();
server.Shutdown("App exiting");
client.Shutdown("App exiting");
}
public void Read(NetBuffer im)
{
MetaData = im.ReadString();
int l = im.ReadInt32();
Data = im.ReadBytes(l);
}
/*
================
CL_ParseSnapshot
If the snapshot is parsed properly, it will be copied to
cl.snap and saved in cl.snapshots[]. If the snapshot is invalid
for any reason, no changes to the state will be made at all.
================
*/
void ParseSnapshot(NetBuffer msg)
{
// read in the new snapshot to a temporary buffer
// we will only copy to cl.snap if it is valid
clSnapshot_t newsnap = new clSnapshot_t();
clSnapshot_t old;
// we will have read any new server commands in this
// message before we got to svc_snapshot
newsnap.ServerCommandNum = clc.serverCommandSequence;
newsnap.serverTime = msg.ReadInt32();
newsnap.messageNum = clc.serverMessageSequence;
int deltaNum = msg.ReadByte();
if (deltaNum <= 0)
{
newsnap.deltaNum = -1;
}
else
newsnap.deltaNum = newsnap.messageNum - deltaNum;
newsnap.snapFlags = msg.ReadByte();
// If the frame is delta compressed from data that we
// no longer have available, we must suck up the rest of
// the frame, but not use it, then ask for a non-compressed
// message
if (newsnap.deltaNum <= 0)
{
newsnap.valid = true; // uncompressed frame
old = null;
}
else
{
old = cl.snapshots[newsnap.deltaNum & 31];
if (!old.valid)
{
// should never happen
Common.Instance.WriteLine("ParseSnapshot: Delta from invalid frame (not supposed to happen!).");
}
else if (old.messageNum != newsnap.deltaNum)
{
// The frame that the server did the delta from
// is too old, so we can't reconstruct it properly.
Common.Instance.WriteLine("ParseSnapshot: Delta frame too old.");
}
else if (cl.parseEntitiesNum - old.parseEntitiesNum > 2048 - 128)
{
Common.Instance.WriteLine("ParseSnapshot: Delta parseEntitiesNum too old");
}
else
newsnap.valid = true; // valid delta parse
}
// read areamask
int len = msg.ReadByte();
newsnap.areamask = msg.ReadBytes(32);
// read playerinfo
if (old != null)
{
Net.ReadDeltaPlayerstate(msg, old.ps, newsnap.ps);
}
else
Net.ReadDeltaPlayerstate(msg, null, newsnap.ps);
// read packet entities
ParsePacketEntities(msg, old, newsnap);
// if not valid, dump the entire thing now that it has
// been properly read
if (!newsnap.valid)
return;
// clear the valid flags of any snapshots between the last
// received and this one, so if there was a dropped packet
// it won't look like something valid to delta from next
// time we wrap around in the buffer
int oldMessageNum = cl.snap.messageNum + 1;
if (newsnap.messageNum - oldMessageNum >= 32)
{
oldMessageNum = newsnap.messageNum - 31;
}
for (; oldMessageNum < newsnap.messageNum; oldMessageNum++ )
{
cl.snapshots[oldMessageNum & 31].valid = false;
}
// copy to the current good spot
cl.snap = newsnap;
cl.snap.ping = 999;
// calculate ping time
for (int i = 0; i < 32; i++)
{
int packetNum = (clc.netchan.outgoingSequence - 1 - i) & 31;
if (cl.snap.ps.commandTime >= cl.outPackets[packetNum].p_serverTime)
{
cl.snap.ping = realtime - cl.outPackets[packetNum].p_realtime;
break;
}
}
// save the frame off in the backup array for later delta comparisons
cl.snapshots[cl.snap.messageNum & 31] = cl.snap;
//Common.Instance.WriteLine(" Snapshot:{0} delta:{1} ping:{2}", cl.snap.messageNum, cl.snap.deltaNum, cl.snap.ping);
cl.newSnapshots = true;
}
protected override NetBuffer ProcessInboundMessage(NetBuffer message)
{
switch(cryptoState)
{
case CryptoHostState.Connected:
{
int code = message.ReadInt32();
if (code == RSA_KEY_MESSAGE)
{
XmlSerializer s = new XmlSerializer(typeof(RSAParameters));
string b = message.ReadString();
StringReader reader = new StringReader(b);
RSAKey = (RSAParameters)s.Deserialize(reader);
RSA = new RSACryptoServiceProvider();
RSA.ImportParameters(RSAKey);
NetBuffer msg = new NetBuffer();
msg.Write((Int32)CRYPTO_SECRET_MESSAGE);
byte[] secret = RSA.Encrypt(MakeSecret(),false);
msg.Write((Int32)secret.Length);
msg.Write(secret);
client.SendMessage(msg,NetChannel.ReliableInOrder1);
cryptoState = CryptoHostState.SentSecret;
}
else
{
cryptoState = CryptoHostState.Invalid;
client.Disconnect("Bad Crypto");
}
}
return null;
case CryptoHostState.SentSecret:
{
int code = message.ReadInt32();
if (code == CRYPTO_SECRET_VERIFY)
{
// set em as real and let the base class call any events it needs to
string verify = new UTF8Encoding().GetString(DecryptBuffer(message.ReadBytes(message.ReadInt32())));
NetBuffer b = new NetBuffer();
b.Write(CRYPTO_SECRET_VERIFY);
byte[] cryptoBuffer = EncryptBuffer(new UTF8Encoding().GetBytes(verify));
b.Write(cryptoBuffer.Length);
b.Write(cryptoBuffer);
client.SendMessage(b, NetChannel.ReliableInOrder1);
cryptoState = CryptoHostState.SentVerify;
}
else
{
cryptoState = CryptoHostState.Invalid;
client.Disconnect("Bad Crypto");
}
}
return null;
case CryptoHostState.SentVerify:
{
int code = message.ReadInt32();
if (code == CRYPTO_ACCEPT)
{
cryptoState = CryptoHostState.Authenticated;
base.Connected(message);
}
else
{
cryptoState = CryptoHostState.Invalid;
client.Disconnect("Bad Crypto");
}
}
return null;
case CryptoHostState.Authenticated:
return new NetBuffer(DecryptBuffer(message.ReadBytes(message.LengthBytes)));
}
return message;
}
protected override NetBuffer ProcessOutboundMessage(NetBuffer message)
{
if (cryptoState == CryptoHostState.Authenticated)
return new NetBuffer(EncryptBuffer(message.ReadBytes(message.LengthBytes)));
return message;
}
protected virtual NetBuffer DecryptMessage( CryptoHostConnection connection, NetBuffer buffer )
{
return new NetBuffer(connection.DecryptBuffer(buffer.ReadBytes(buffer.LengthBytes)));
}
protected override NetBuffer ProcessOutboundMessage(NetConnection to, NetBuffer message)
{
if (CryptoClients.ContainsKey(to))
{
CryptoHostConnection connection = CryptoClients[to];
if (connection.state == CryptoHostState.Authenticated)
return new NetBuffer(connection.EncryptBuffer(message.ReadBytes(message.LengthBytes)));
}
return message;
}
protected override NetBuffer ProcessInboundMessage(NetConnection from, NetBuffer message)
{
CryptoHostConnection connection;
if (CryptoClients.ContainsKey(from))
connection = CryptoClients[from];
else
return message;
int code = -1;
switch (connection.state)
{
case CryptoHostState.Authenticated:
return DecryptMessage(connection, message);
case CryptoHostState.Invalid:
return null;
case CryptoHostState.InitalConnect:
{
// should be the response with a random key encoded with the shit
code = message.ReadInt32();
if (code == CRYPTO_SECRET_MESSAGE)
{
connection.state = CryptoHostState.GotSecret;
connection.SetSecret(RSA.Decrypt(message.ReadBytes(message.ReadInt32()),false));
connection.secretVerifyString = new Random().Next().ToString();
// crypto the random string with the secret and send it back
NetBuffer b = new NetBuffer();
b.Write(CRYPTO_SECRET_VERIFY);
byte[] cryptoBuffer = connection.EncryptBuffer(new UTF8Encoding().GetBytes(connection.secretVerifyString));
b.Write(cryptoBuffer.Length);
b.Write(cryptoBuffer);
server.SendMessage(b, from, NetChannel.ReliableInOrder1);
}
else
{
NetBuffer errorBuffer = new NetBuffer();
errorBuffer.Write(CRYPTO_DENY);
errorBuffer.Write("Invalid Secret");
server.SendMessage(errorBuffer, from, NetChannel.ReliableInOrder1);
from.Disconnect("CryptoError", 1);
connection.state = CryptoHostState.Invalid;
}
return null;
}
case CryptoHostState.GotSecret:
{
// should be the response with the properly encrypted sample
code = message.ReadInt32();
if (code == CRYPTO_SECRET_VERIFY)
{
// set em as real and let the base class call any events it needs to
string verify = new UTF8Encoding().GetString(connection.DecryptBuffer(message.ReadBytes(message.ReadInt32())));
if (verify == connection.secretVerifyString)
{
connection.state = CryptoHostState.Authenticated;
NetBuffer b = new NetBuffer();
b.Write(CRYPTO_ACCEPT);
server.SendMessage(b, from, NetChannel.ReliableInOrder1);
base.UserConnected(from);
return null;
}
}
NetBuffer errorBuffer = new NetBuffer();
errorBuffer.Write(CRYPTO_DENY);
errorBuffer.Write("Invalid Verify");
server.SendMessage(errorBuffer, from, NetChannel.ReliableInOrder1);
from.Disconnect("CryptoError", 1);
connection.state = CryptoHostState.Invalid;
return null;
}
}
return message;
}
