/// <summary>
/// Reads up to the specified length of data into the specified buffer at the specified offset in the buffer.
/// </summary>
/// <param name="Data">The buffer to read into.</param>
/// <param name="Offset">The offset in the buffer to write data to.</param>
/// <param name="Length">The maximum length of data to read.</param>
/// <param name="Blocking">Whether the read should be blocking or non-blocking.</param>
/// <returns>The actual number of bytes read.</returns>
public int Read(byte[] Data, int Offset, int Length, bool Blocking)
{
int BytesRead = 0;
Pipes.ReadPipeRequest *ReadPipeRequestPtr = (Pipes.ReadPipeRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.ReadPipeRequest), "BasicInPipe : Alloc ReadPipeRequest");
try
{
if (ReadPipeRequestPtr != null)
{
ReadPipeRequestPtr->PipeId = PipeId;
ReadPipeRequestPtr->Offset = Offset;
ReadPipeRequestPtr->Length = FOS_System.Math.Min(Data.Length - Offset, Length);
ReadPipeRequestPtr->OutBuffer = (byte *)Utilities.ObjectUtilities.GetHandle(Data) + FOS_System.Array.FieldsBytesSize;
ReadPipeRequestPtr->Blocking = Blocking;
SystemCallResults SysCallResult = SystemCalls.ReadPipe(ReadPipeRequestPtr, out BytesRead);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Unhandled!");
ExceptionMethods.Throw(new Exceptions.RWUnhandledException("BasicInPipe : Read Pipe unexpected unhandled!"));
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Failed!");
if (Blocking)
{
ExceptionMethods.Throw(new Exceptions.RWFailedException("BasicInPipe : Write Pipe unexpected failed! (Blocking call)"));
}
else
{
ExceptionMethods.Throw(new Exceptions.RWFailedException("BasicInPipe : Write Pipe failed. (Non-blocking call)"));
}
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Succeeded.");
break;
default:
//BasicConsole.WriteLine("BasicInPipe > ReadPipe: Unexpected system call result!");
ExceptionMethods.Throw(new Exceptions.RWUnhandledException("BasicInPipe : Read Pipe unexpected result!"));
break;
}
}
else
{
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicInPipe : Couldn't allocate memory to read from pipe!"));
}
}
finally
{
if (ReadPipeRequestPtr != null)
{
Heap.Free(ReadPipeRequestPtr);
}
}
return(BytesRead);
}
/// <summary>
/// Gets the outpoint desciptors of the available outpoints of the specified class and subclass.
/// </summary>
/// <param name="numOutpoints">The known number of available outpoints. Use GetNumPipeOutpoints to obtain this number.</param>
/// <param name="SysCallResult">Out : The result of the system call. Check this is set to OK.</param>
/// <param name="OutpointDescriptors">Out : The array of outpoint descriptors.</param>
/// <param name="Class">The class of pipe to search for.</param>
/// <param name="Subclass">The subclass of pipe to search for.</param>
public static void GetOutpointDescriptors(int numOutpoints, out SystemCallResults SysCallResult, out Pipes.PipeOutpointDescriptor[] OutpointDescriptors, Pipes.PipeClasses Class, Pipes.PipeSubclasses Subclass)
{
OutpointDescriptors = new Pipes.PipeOutpointDescriptor[numOutpoints];
Pipes.PipeOutpointsRequest *RequestPtr = (Pipes.PipeOutpointsRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.PipeOutpointsRequest), "BasicServerHelpers : Alloc PipeOutpointsRequest");
if (RequestPtr != null)
{
try
{
RequestPtr->MaxDescriptors = numOutpoints;
RequestPtr->Outpoints = (Pipes.PipeOutpointDescriptor *)((byte *)Utilities.ObjectUtilities.GetHandle(OutpointDescriptors) + FOS_System.Array.FieldsBytesSize);
if (RequestPtr->Outpoints != null)
{
SysCallResult = SystemCalls.GetPipeOutpoints(Class, Subclass, RequestPtr);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unhandled!");
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Failed!");
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Succeeded.");
break;
default:
//BasicConsole.WriteLine("BasicServerHelpers > GetPipeOutpoints: Unexpected system call result!");
break;
}
}
else
{
SysCallResult = SystemCallResults.Fail;
//BasicConsole.WriteLine("BasicServerHelpers > RequestPtr->Outpoints null! No memory allocated.");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory outpoints list in outpoints request!"));
}
}
finally
{
Heap.Free(RequestPtr);
}
}
else
{
SysCallResult = SystemCallResults.Fail;
//BasicConsole.WriteLine("BasicServerHelpers > RequestPtr null! No memory allocated.");
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicServerHelpers : Couldn't allocate memory get outpoints request!"));
}
}
/// <summary>
/// Creates and connects a new pipe to the specified target process.
/// </summary>
/// <param name="anOutProcessId">The target process to connect to.</param>
/// <param name="aClass">The class of pipe to create.</param>
/// <param name="aSubclass">The subclass of pipe to create.</param>
/// <param name="aBufferSize">The size of buffer to use within the core OS.</param>
public BasicInpoint(uint anOutProcessId, PipeClasses aClass, PipeSubclasses aSubclass, int aBufferSize)
{
OutProcessId = anOutProcessId;
Class = aClass;
Subclass = aSubclass;
BufferSize = aBufferSize;
Pipes.CreatePipeRequest *RequestPtr = (Pipes.CreatePipeRequest *)Heap.AllocZeroed((uint)sizeof(Pipes.CreatePipeRequest), "BasicInPipe : Alloc CreatePipeRequest");
if (RequestPtr != null)
{
try
{
RequestPtr->BufferSize = aBufferSize;
RequestPtr->Class = aClass;
RequestPtr->Subclass = aSubclass;
SystemCallResults SysCallResult = SystemCalls.CreatePipe(anOutProcessId, RequestPtr);
switch (SysCallResult)
{
case SystemCallResults.Unhandled:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Unhandled!");
break;
case SystemCallResults.Fail:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Failed!");
break;
case SystemCallResults.OK:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Succeeded.");
PipeId = RequestPtr->Result.Id;
//BasicConsole.Write("BasicInPipe > CreatePipe: New pipe id = ");
//BasicConsole.WriteLine(PipeId);
break;
default:
//BasicConsole.WriteLine("BasicInPipe > CreatePipe: Unexpected system call result!");
break;
}
}
finally
{
Heap.Free(RequestPtr);
}
}
else
{
ExceptionMethods.Throw(new FOS_System.Exceptions.ArgumentException("BasicInPipe : Couldn't allocate memory to create pipe!"));
//BasicConsole.WriteLine("BasicInPipe > RequestPtr null! No memory allocated.");
}
}
