public bool ReadFrame(out PipeFrame frame)
{
if (!this.IsConnected)
{
throw new InvalidPipeException("Cannot read Native Stream as pipe is not connected");
}
int count = NativePipe.ReadFrame(this._buffer, this._buffer.Length);
if (count <= 0)
{
this._lasterr = NativePipe.PipeReadError.ReadEmptyMessage;
if (count < 0)
{
this._lasterr = (NativePipe.PipeReadError)count;
this.Logger.Error("Native pipe failed to read: {0}", (object)this._lasterr.ToString());
this.Close();
}
frame = new PipeFrame();
return(false);
}
using (MemoryStream memoryStream = new MemoryStream(this._buffer, 0, count))
{
frame = new PipeFrame();
if (frame.ReadStream((Stream)memoryStream) && frame.Length != 0U)
{
return(true);
}
this.Logger.Error("Pipe failed to read from the data received by the stream.");
return(false);
}
}
public bool WriteFrame(PipeFrame frame)
{
//Write the frame. We are assuming proper duplex connection here
if (!IsConnected)
{
Logger.Error("Failed to write frame because the stream is closed");
return(false);
}
try
{
//Write the pipe
frame.WriteStream(_stream);
return(true);
}
catch (IOException io)
{
Logger.Error("Failed to write frame because of a IO Exception: {0}", io.Message);
}
catch (ObjectDisposedException)
{
Logger.Warning("Failed to write frame as the stream was already disposed");
}
catch (InvalidOperationException)
{
Logger.Warning("Failed to write frame because of a invalid operation");
}
//We must have failed the try catch
return(false);
}
public bool WriteFrame(PipeFrame frame)
{
if (this._isDisposed)
{
throw new ObjectDisposedException("_stream");
}
if (!this._isClosed)
{
if (this.IsConnected)
{
try
{
frame.WriteStream((Stream)this._stream);
return(true);
}
catch (IOException ex)
{
this.Logger.Error("Failed to write frame because of a IO Exception: {0}", (object)ex.Message);
}
catch (ObjectDisposedException ex)
{
this.Logger.Warning("Failed to write frame as the stream was already disposed");
}
catch (InvalidOperationException ex)
{
this.Logger.Warning("Failed to write frame because of a invalid operation");
}
return(false);
}
}
this.Logger.Error("Failed to write frame because the stream is closed");
return(false);
}
private void EndRead(IAsyncResult callback)
{
Logger.Info("Ending Read");
int bytes = 0;
try
{
//Attempt to read the bytes, catching for IO exceptions or dispose exceptions
bytes = _stream.EndRead(callback);
}
catch (IOException)
{
Logger.Warning("Attempted to end reading from a closed pipe");
return;
}
catch (ObjectDisposedException)
{
Logger.Warning("Attemped to end reading from a disposed pipe");
return;
}
//How much did we read?
Logger.Info("Read {0} bytes", bytes);
//Did we read anything? If we did we should enqueue it.
if (bytes > 0)
{
//Load it into a memory stream and read the frame
using (MemoryStream stream = new MemoryStream(_buffer, 0, bytes))
{
PipeFrame frame = new PipeFrame();
if (frame.ReadStream(stream))
{
Logger.Info("Read a frame: {0}", frame.Opcode);
//Enqueue the stream
lock (_framequeuelock)
_framequeue.Enqueue(frame);
}
else
{
//TODO: Enqueue a pipe close event here as we failed to read something.
Logger.Error("Pipe failed to read from the data received by the stream.");
}
}
}
//We are still connected, so continue to read
if (IsConnected)
{
Logger.Info("Starting another read");
BeginRead();
}
}
public bool WriteFrame(PipeFrame frame)
{
if (!this.IsConnected)
{
throw new InvalidPipeException("Cannot write Native Stream as pipe is not connected");
}
using (MemoryStream memoryStream = new MemoryStream())
{
frame.WriteStream((Stream)memoryStream);
byte[] array = memoryStream.ToArray();
return(NativePipe.WriteFrame(array, array.Length));
}
}
/// <summary>
/// Reads a frame, returning false if none are available
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public bool ReadFrame(out PipeFrame frame)
{
if (_isDisposed)
{
throw new ObjectDisposedException("_stream");
}
//Check the queue, returning the pipe if we have anything available. Otherwise null.
var dequeued = _framequeue.TryDequeue(out frame);
if (!dequeued)
{
frame = default(PipeFrame);
}
return(dequeued);
}
/// <summary>
/// Attempts to read a frame
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public bool ReadFrame(out PipeFrame frame)
{
//Make sure we are connected
if (!IsConnected)
{
throw new InvalidPipeException("Cannot read Native Stream as pipe is not connected");
}
//Try and read the frame from the native pipe
int bytesRead = NativePipe.ReadFrame(_buffer, _buffer.Length);
if (bytesRead <= 0)
{
//Update the error message
_lasterr = NativePipe.PipeReadError.ReadEmptyMessage;
//A error actively occured. If it is 0 we just read no bytes.
if (bytesRead < 0)
{
//We have a pretty bad error, we will log it for prosperity.
_lasterr = (NativePipe.PipeReadError)bytesRead;
Logger.Error("Native pipe failed to read: {0}", _lasterr.ToString());
//Close this pipe
this.Close();
}
//Return a empty frame and return false (read failure).
frame = default(PipeFrame);
return(false);
}
//Parse the pipe
using (MemoryStream stream = new MemoryStream(_buffer, 0, bytesRead))
{
//Try to parse the stream
frame = new PipeFrame();
if (frame.ReadStream(stream) && frame.Length != 0)
{
return(true);
}
//We failed
Logger.Error("Pipe failed to read from the data received by the stream.");
return(false);
}
}
public bool ReadFrame(out PipeFrame frame)
{
//Check the queue, returning the pipe if we have anything available. Otherwise null.
lock (_framequeuelock)
{
if (_framequeue.Count == 0)
{
//We found nothing, so just default and return null
frame = default(PipeFrame);
return(false);
}
//Return the dequed frame
frame = _framequeue.Dequeue();
return(true);
}
}
public bool ReadFrame(out PipeFrame frame)
{
if (this._isDisposed)
{
throw new ObjectDisposedException("_stream");
}
lock (this._framequeuelock)
{
if (this._framequeue.Count == 0)
{
frame = new PipeFrame();
return(false);
}
frame = this._framequeue.Dequeue();
return(true);
}
}
/// <summary>
/// Attempts to write a frame
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public bool WriteFrame(PipeFrame frame)
{
if (!IsConnected)
{
throw new InvalidPipeException("Cannot write Native Stream as pipe is not connected");
}
//Create a memory stream so we can write it to the pipe
using (MemoryStream stream = new MemoryStream())
{
//Write the stream and the send it to the pipe
frame.WriteStream(stream);
//Get the bytes and send it
byte[] bytes = stream.ToArray();
return(NativePipe.WriteFrame(bytes, bytes.Length));
}
}
public bool ReadFrame(out PipeFrame frame)
{
//Make sure we are connected
if (!IsConnected)
{
throw new InvalidPipeException("Cannot read Native Stream as pipe is not connected");
}
//Try and read the frame from the native pipe
int bytesRead = NativePipe.ReadFrame(_buffer, _buffer.Length);
if (bytesRead <= 0)
{
//A error actively occured. If it is 0 we just read no bytes.
if (bytesRead < 0)
{
Logger.Error("Native pipe failed to read. Err: {0}", bytesRead);
}
frame = default(PipeFrame);
return(false);
}
//Parse the pipe
using (MemoryStream stream = new MemoryStream(_buffer, 0, bytesRead))
{
//Try to parse the stream
frame = new PipeFrame();
if (frame.ReadStream(stream) && frame.Length != 0)
{
return(true);
}
//We failed
Logger.Error("Pipe failed to read from the data received by the stream.");
return(false);
}
}
/// <summary>
/// Writes a frame to the pipe
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public bool WriteFrame(PipeFrame frame)
{
if (_isDisposed)
{
throw new ObjectDisposedException("_stream");
}
//Write the frame. We are assuming proper duplex connection here
if (_isClosed || !IsConnected)
{
Console.WriteLine("Failed to write frame because the stream is closed");
return(false);
}
try
{
//Write the pipe
//This can only happen on the main thread so it should be fine.
frame.WriteStream(_stream);
return(true);
}
catch (IOException io)
{
Console.WriteLine($"Failed to write frame because of a IO Exception: {io.Message}");
}
catch (ObjectDisposedException)
{
Console.WriteLine("Failed to write frame as the stream was already disposed");
}
catch (InvalidOperationException)
{
Console.WriteLine("Failed to write frame because of a invalid operation");
}
//We must have failed the try catch
return(false);
}
/// <summary>
/// Ends a read. Can be executed in another thread.
/// </summary>
/// <param name="callback"></param>
private void TEndRead(IAsyncResult callback)
{
Console.WriteLine("Ending Read");
int bytes = 0;
try
{
//Attempt to read the bytes, catching for IO exceptions or dispose exceptions
lock (l_stream)
{
//Make sure the stream is still valid
if (_stream == null || !_stream.IsConnected)
{
return;
}
//Read our btyes
bytes = _stream.EndRead(callback);
}
}
catch (IOException)
{
Console.WriteLine("Attempted to end reading from a closed pipe");
return;
}
catch (NullReferenceException)
{
Console.WriteLine("Attempted to read from a null pipe");
return;
}
catch (ObjectDisposedException)
{
Console.WriteLine("Attemped to end reading from a disposed pipe");
return;
}
catch (Exception e)
{
Console.WriteLine($"An exception occured while ending a read of a stream: {e.Message}");
Console.WriteLine(e.StackTrace);
return;
}
//How much did we read?
Console.WriteLine($"Read {bytes} bytes");
//Did we read anything? If we did we should enqueue it.
if (bytes > 0)
{
//Load it into a memory stream and read the frame
using (MemoryStream memory = new MemoryStream(_buffer, 0, bytes))
{
try
{
PipeFrame frame = new PipeFrame();
if (frame.ReadStream(memory))
{
Console.WriteLine($"Read a frame: {frame.Opcode}");
//Enqueue the stream
lock (_framequeuelock)
_framequeue.Enqueue(frame);
}
else
{
//TODO: Enqueue a pipe close event here as we failed to read something.
Console.WriteLine("Pipe failed to read from the data received by the stream.");
Close();
}
}
catch (Exception e)
{
Console.WriteLine("A exception has occured while trying to parse the pipe data: " + e.Message);
Close();
}
}
}
//We are still connected, so continue to read
if (!_isClosed && IsConnected)
{
Console.WriteLine("Starting another read");
TBeginRead();
}
}
/// <summary>
/// Ends a read. Can be executed in another thread.
/// </summary>
/// <param name="callback"></param>
private void EndReadStream(IAsyncResult callback)
{
Logger.Trace("Ending Read");
int bytes = 0;
try
{
//Attempt to read the bytes, catching for IO exceptions or dispose exceptions
lock (l_stream)
{
//Make sure the stream is still valid
if (_stream == null || !_stream.IsConnected)
{
return;
}
//Read our btyes
bytes = _stream.EndRead(callback);
}
}
catch (IOException)
{
Logger.Warning("Attempted to end reading from a closed pipe");
return;
}
catch (NullReferenceException)
{
Logger.Warning("Attempted to read from a null pipe");
return;
}
catch (ObjectDisposedException)
{
Logger.Warning("Attemped to end reading from a disposed pipe");
return;
}
catch (Exception e)
{
Logger.Error("An exception occured while ending a read of a stream: {0}", e.Message);
Logger.Error(e.StackTrace);
return;
}
//How much did we read?
Logger.Trace("Read {0} bytes", bytes);
//Did we read anything? If we did we should enqueue it.
if (bytes > 0)
{
//Load it into a memory stream and read the frame
using (MemoryStream memory = new MemoryStream(_buffer, 0, bytes))
{
try
{
PipeFrame frame = new PipeFrame();
if (frame.ReadStream(memory))
{
Logger.Trace("Read a frame: {0}", frame.Opcode);
//Enqueue the stream
lock (_framequeuelock)
_framequeue.Enqueue(frame);
}
else
{
//TODO: Enqueue a pipe close event here as we failed to read something.
Logger.Error("Pipe failed to read from the data received by the stream.");
Close();
}
}
catch (Exception e)
{
Logger.Error("A exception has occured while trying to parse the pipe data: " + e.Message);
Close();
}
}
}
else
{
//If we read 0 bytes, its probably a broken pipe. However, I have only confirmed this is the case for MacOSX.
// I have added this check here just so the Windows builds are not effected and continue to work as expected.
if (IsUnix())
{
Logger.Error("Empty frame was read on " + Environment.OSVersion.ToString() + ", aborting.");
Close();
}
else
{
Logger.Warning("Empty frame was read. Please send report to Lachee.");
}
}
//We are still connected, so continue to read
if (!_isClosed && IsConnected)
{
Logger.Trace("Starting another read");
BeginReadStream();
}
}
private void tEndRead(IAsyncResult callback)
{
this.Logger.Info("Ending Read");
int count = 0;
try
{
lock (this.l_stream)
{
if (this._stream == null || !this._stream.IsConnected)
{
return;
}
count = this._stream.EndRead(callback);
}
}
catch (IOException ex)
{
this.Logger.Warning("Attempted to end reading from a closed pipe");
return;
}
catch (NullReferenceException ex)
{
this.Logger.Warning("Attempted to read from a null pipe");
return;
}
catch (ObjectDisposedException ex)
{
this.Logger.Warning("Attemped to end reading from a disposed pipe");
return;
}
catch (Exception ex)
{
this.Logger.Error("An exception occured while ending a read of a stream: {0}", (object)ex.Message);
this.Logger.Error(ex.StackTrace);
return;
}
this.Logger.Info("Read {0} bytes", (object)count);
if (count > 0)
{
using (MemoryStream memoryStream = new MemoryStream(this._buffer, 0, count))
{
try
{
PipeFrame pipeFrame = new PipeFrame();
if (pipeFrame.ReadStream((Stream)memoryStream))
{
this.Logger.Info("Read a frame: {0}", (object)pipeFrame.Opcode);
lock (this._framequeuelock)
this._framequeue.Enqueue(pipeFrame);
}
else
{
this.Logger.Error("Pipe failed to read from the data received by the stream.");
this.Close();
}
}
catch (Exception ex)
{
this.Logger.Error("A exception has occured while trying to parse the pipe data: " + ex.Message);
this.Close();
}
}
}
if (this._isClosed || !this.IsConnected)
{
return;
}
this.Logger.Info("Starting another read");
this.tBeginRead();
}
