public void ResetPositionTest2()
{
MemoryStream bytesRead = new MemoryStream();
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
byte[] read = buffer.Read(BIG_BUFFER_DATA.Length);
try
{
buffer.Read(1);
Assert.Fail("An exception should have been thrown when reading a fully read buffer.");
}catch (Exception)
{
}
buffer.ResetPosition();
try
{
read = buffer.Read(1);
Assert.AreEqual <byte>(BIG_BUFFER_DATA[0], read[0]);
}
catch (Exception)
{
Assert.Fail("Reset position should have allowed for the buffer to be readable again.");
}
finally
{
buffer.Dispose();
}
}
public void AsyncCallbackIPV4SendLargeBufferTest()
{
try
{
ManualResetEventSlim mevent = new ManualResetEventSlim(false);
NetworkBuffer buffer = TestData.GetLargeBuffer();
byte[] sentData = null;
int bytesSent = 0;
while ((sentData = buffer.Read(UdpProtocol.BUFFER_SIZE)) != null)
{
mevent.Reset();
ipv4Client.SendAsync(sentData, (sent) =>
{
bytesSent += sent;
ipv4ServerClient.ReceiveAsync();
mevent.Set();
});
mevent.Wait(1000);
}
Assert.AreEqual(buffer.Size, bytesSent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
internal bool Execute(TCPConnection sender, NetworkBuffer data)
{
var msg = data.Read();
foreach (var filter in filters)
{
if (filter.Execute(msg, data, sender))
{
return(true);
}
}
return(false);
}
protected override void DataReceived(TCPConnection sender, NetworkBuffer data)
{
//throw new NotImplementedException();
var msg = data.Read();
foreach (Instance instance in Instance.Children)
{
var f = instance.Resource as TCPFilter;
if (f.Execute(msg, data, sender))
{
return;
}
}
}
public void DisposeTest()
{
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
buffer.Dispose();
try
{
buffer.Read(1);
Assert.Fail("Any buffer operation after the buffer is disposed should result in an object disposed exception.");
}
catch (Exception ex)
{
Assert.IsTrue(ex is ObjectDisposedException, "Any buffer operation after the buffer is disposed should result in an object disposed exception. (Error was not Object Disposed Exception)");
}
}
public void ReadTest3()
{
MemoryStream bytesRead = new MemoryStream();
var buffer = new NetworkBuffer(BIG_BUFFER_DATA.Length, BIG_BUFFER_DATA);
for (int i = 0; i < BIG_BUFFER_DATA.Length; i += 1024)
{
byte[] read = buffer.Read(1024);
if (read != null)
{
bytesRead.Write(read, 0, read.Length);
}
}
Assert.AreEqual <long>(bytesRead.Position, BIG_BUFFER_DATA.LongLength, "Bytes written should be equal to bytes read");
buffer.Dispose();
}
protected override void DataReceived(NetworkBuffer data)
{
// Console.WriteLine("DR " + hostType + " " + data.Available + " " + RemoteEndPoint.ToString());
var msg = data.Read();
uint offset = 0;
uint ends = (uint)msg.Length;
var packs = new List <string>();
var chunkId = (new Random()).Next(1000, 1000000);
while (offset < ends)
{
offset = processPacket(msg, offset, ends, data, chunkId);
}
}
public void ReadTest1()
{
var buffer = new NetworkBuffer(20, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
try
{
buffer.Read(5);
Assert.Fail("An exception should have been thrown when attempting to read this buffer.");
}
catch (Exception)
{
Assert.IsTrue(true);
}
finally
{
buffer.Dispose();
}
}
public void SynchronousIPV4SendLargeBufferTest()
{
try
{
NetworkBuffer buffer = TestData.GetLargeBuffer();
int sent = 0;
byte[] sentData = null;
while (null != (sentData = buffer.Read(UdpProtocol.BUFFER_SIZE)))
{
sent += ipv4Client.Send(sentData);
var task = ipv4ServerClient.ReceiveAsync();
}
Assert.AreEqual(buffer.Size, sent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void ReadTest2()
{
var buffer = new NetworkBuffer(10, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
try
{
var bytes = buffer.Read(5);
Assert.IsNotNull(bytes, "Byte array should not be null.");
Assert.AreEqual <int>(5, bytes.Length, "Byte array read should contain five elements.");
}
catch (Exception ex)
{
Assert.Fail($"No exception should be thrown. Exception: ${ex.ToString()}");
}
finally
{
buffer.Dispose();
}
}
public async Task AsyncTaskIPV4SendMidSizeBufferTest()
{
try
{
NetworkBuffer buffer = TestData.GetMidSizeBuffer();
byte[] sentData = null;
int bytesSent = 0;
while (null != (sentData = buffer.Read(UdpProtocol.BUFFER_SIZE)))
{
bytesSent += await ipv4Client.SendAsync(sentData);
var task = ipv4ServerClient.ReceiveAsync();
}
Assert.AreEqual(buffer.Size, bytesSent, "Not all bytes were sent");
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
}
public void Unhold()
{
lock (sendLock)
{
held = false;
var message = sendNetworkBuffer.Read();
//Console.WriteLine("WS Unhold {0}", message == null ? 0 : message.Length);
if (message == null)
{
return;
}
totalSent += message.Length;
pkt_send.Message = message;
if (pkt_send.Compose())
{
sock.Send(pkt_send.Data);
}
}
}
public void TestReadWriteMissaligned()
{
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteBit(true);
var writeBuffer = new byte[16]
{
0,
5,
2,
54,
192,
60,
214,
65,
95,
2,
43,
62,
252,
190,
45,
2
};
outNetworkBuffer.Write(writeBuffer);
var inNetworkBuffer = new NetworkBuffer(outNetworkBuffer.GetBuffer());
Assert.That(inNetworkBuffer.ReadBit(), Is.True);
var readBuffer = new byte[16];
inNetworkBuffer.Read(readBuffer, 0, 16);
Assert.That(readBuffer, Is.EquivalentTo(writeBuffer));
}
MessageHeader ReadMessageHeader(NetworkStream stream)
{
int bytesRead = m_ReadBuffer.Read(stream, 0, MessageHeader.k_EncodedSize);
return(new MessageHeader(m_ReadBuffer.buffer, bytesRead));
}
protected override void DataReceived(NetworkBuffer data)
{
byte[] msg = data.Read();
var BL = Parse(msg);
if (BL == 0)
{
if (Request.Method == HTTPRequestPacket.HTTPMethod.UNKNOWN)
{
Close();
return;
}
if (Request.URL == "")
{
Close();
return;
}
}
else if (BL == -1)
{
data.HoldForNextWrite(msg);
return;
}
else if (BL < 0)
{
data.HoldFor(msg, (uint)(msg.Length - BL));
return;
}
else if (BL > 0)
{
if (BL > Server.MaxPost)
{
Send(
"<html><body>POST method content is larger than "
+ Server.MaxPost
+ " bytes.</body></html>");
Close();
}
else
{
data.HoldFor(msg, (uint)(msg.Length + BL));
}
return;
}
else if (BL < 0) // for security
{
Close();
return;
}
if (IsWebsocketRequest(Request) & !WSMode)
{
Upgrade();
//return;
}
//return;
try
{
if (!Server.Execute(this))
{
Response.Number = HTTPResponsePacket.ResponseCode.InternalServerError;
Send("Bad Request");
Close();
}
}
catch (Exception ex)
{
if (ex.Message != "Thread was being aborted.")
{
Global.Log("HTTPServer", LogType.Error, ex.ToString());
//Console.WriteLine(ex.ToString());
//EventLog.WriteEntry("HttpServer", ex.ToString(), EventLogEntryType.Error);
Send(Error500(ex.Message));
}
}
}
protected override void DataReceived(HTTPConnection sender, NetworkBuffer data)
{
//Console.WriteLine(Data);
// Initialize a new session
//HTTPConnection HTTP = (HTTPConnection)sender.ExtraObject;
//string Data = System.Text.Encoding.Default.GetString(ReceivedData);
byte[] msg = data.Read();
var BL = sender.Parse(msg);
if (BL == 0)
{
if (sender.Request.Method == HTTPRequestPacket.HTTPMethod.UNKNOWN)
{
sender.Close();
return;
}
if (sender.Request.URL == "")
{
sender.Close();
return;
}
}
else if (BL == -1)
{
data.HoldForNextWrite(msg);
return;
}
else if (BL < 0)
{
data.HoldFor(msg, (uint)(msg.Length - BL));
return;
}
else if (BL > 0)
{
if (BL > maxPost)
{
sender.Send(
"<html><body>POST method content is larger than "
+ maxPost
+ " bytes.</body></html>");
sender.Close();
}
else
{
data.HoldFor(msg, (uint)(msg.Length + BL));
}
return;
}
else if (BL < 0) // for security
{
sender.Close();
return;
}
if (sender.IsWebsocketRequest() & !sender.WSMode)
{
sender.Upgrade();
//return;
}
//return;
try
{
foreach (IResource resource in Instance.Children)
{
if (resource is HTTPFilter)
{
if ((resource as HTTPFilter).Execute(sender))
{
return;
}
}
}
sender.Send("Bad Request");
sender.Close();
}
catch (Exception ex)
{
if (ex.Message != "Thread was being aborted.")
{
Global.Log("HTTPServer", LogType.Error, ex.ToString());
//Console.WriteLine(ex.ToString());
//EventLog.WriteEntry("HttpServer", ex.ToString(), EventLogEntryType.Error);
sender.Send(Return500(ex.Message));
}
}
}
private void Sock_OnReceive(NetworkBuffer buffer)
{
if (sock.State == SocketState.Closed || sock.State == SocketState.Terminated)
{
return;
}
if (buffer.Protected)
{
return;
}
if (processing)
{
return;
}
var msg = buffer.Read();
if (msg == null)
{
return;
}
var wsPacketLength = pkt_receive.Parse(msg, 0, (uint)msg.Length);
//Console.WriteLine("WSP: " + wsPacketLength);
if (wsPacketLength < 0)
{
buffer.Protect(msg, 0, (uint)msg.Length + (uint)-wsPacketLength);
return;
}
uint offset = 0;
while (wsPacketLength > 0)
{
if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.ConnectionClose)
{
Close();
return;
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Ping)
{
var pkt_pong = new WebsocketPacket();
pkt_pong.FIN = true;
pkt_pong.Mask = false;
pkt_pong.Opcode = WebsocketPacket.WSOpcode.Pong;
pkt_pong.Message = pkt_receive.Message;
offset += (uint)wsPacketLength;
Send(pkt_pong);
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.Pong)
{
offset += (uint)wsPacketLength;
}
else if (pkt_receive.Opcode == WebsocketPacket.WSOpcode.BinaryFrame ||
pkt_receive.Opcode == WebsocketPacket.WSOpcode.TextFrame ||
pkt_receive.Opcode == WebsocketPacket.WSOpcode.ContinuationFrame)
{
totalReceived += pkt_receive.Message.Length;
//Console.WriteLine("RX " + pkt_receive.Message.Length + "/" + totalReceived);// + " " + DC.ToHex(message, 0, (uint)size));
receiveNetworkBuffer.Write(pkt_receive.Message);
offset += (uint)wsPacketLength;
//Console.WriteLine("WS IN: " + pkt_receive.Opcode.ToString() + " " + pkt_receive.Message.Length + " | " + offset + " " + string.Join(" ", pkt_receive.Message));// DC.ToHex(pkt_receive.Message));
}
else
{
Console.WriteLine("Unknown WS opcode:" + pkt_receive.Opcode);
}
if (offset == msg.Length)
{
// Console.WriteLine("WS IN: " + receiveNetworkBuffer.Available);
OnReceive?.Invoke(receiveNetworkBuffer);
return;
}
wsPacketLength = pkt_receive.Parse(msg, offset, (uint)msg.Length);
}
if (wsPacketLength < 0)//(offset < msg.Length) && (offset > 0))
{
//receiveNetworkBuffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)msg.Length + (uint)-wsPacketLength);
// save the incomplete packet to the heldBuffer queue
buffer.HoldFor(msg, offset, (uint)(msg.Length - offset), (uint)(msg.Length - offset) + (uint)-wsPacketLength);
}
//Console.WriteLine("WS IN: " + receiveNetworkBuffer.Available);
OnReceive?.Invoke(receiveNetworkBuffer);
processing = false;
if (buffer.Available > 0 && !buffer.Protected)
{
Sock_OnReceive(buffer);
}
}
