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); } }