internal OSFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
{
string fullPath = Path.GetFullPath(path);
_access = access;
_share = share;
_fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
try
{
if (mode == FileMode.Append && CanSeek)
{
_appendStart = _filePosition = Length;
}
else
{
_appendStart = -1;
}
}
catch
{
// If anything goes wrong while setting up the stream, make sure we deterministically dispose
// of the opened handle.
_fileHandle.Dispose();
_fileHandle = null !;
throw;
}
}
internal Net5CompatFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize)
{
string fullPath = Path.GetFullPath(path);
_access = access;
_bufferLength = bufferSize;
if ((options & FileOptions.Asynchronous) != 0)
{
_useAsyncIO = true;
}
_fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
try
{
Init(mode, path, options);
}
catch
{
// If anything goes wrong while setting up the stream, make sure we deterministically dispose
// of the opened handle.
_fileHandle.Dispose();
_fileHandle = null !;
throw;
}
}
private static void WriteToStderr(string message)
{
// We don't want to write UTF-16 to a file like standard error. Ideally we would transcode this
// to UTF8, but the downside of that is it pulls in a bunch of stuff into what is ideally
// a path with minimal dependencies (as to prevent re-entrency), so we'll take the strategy
// of just throwing away any non ASCII characters from the message and writing the rest
const int BufferLength = 256;
unsafe
{
byte *buf = stackalloc byte[BufferLength];
int bufCount;
int i = 0;
using (SafeFileHandle fileHandle = SafeFileHandle.Open(() => Interop.Sys.Dup(Interop.Sys.FileDescriptors.STDERR_FILENO)))
{
while (i < message.Length)
{
for (bufCount = 0; bufCount < BufferLength && i < message.Length; i++)
{
if (message[i] <= 0x7F)
{
buf[bufCount] = (byte)message[i];
bufCount++;
}
}
int totalBytesWritten = 0;
while (bufCount > 0)
{
int bytesWritten = Interop.Sys.Write((int)fileHandle.DangerousGetHandle(), buf + totalBytesWritten, bufCount);
if (bytesWritten < 0)
{
if (Interop.Sys.GetLastErrorInfo().Error == Interop.Error.EINTR)
{
continue;
}
// On error, simply stop writing the debug output. This could commonly happen if stderr
// was piped to a program that ended before this program did, resulting in EPIPE errors.
return;
}
bufCount -= bytesWritten;
totalBytesWritten += bytesWritten;
}
}
}
}
}
private static void WriteToFile(string filePath, string message)
{
// We don't want to write UTF-16 to a file like standard error. Ideally we would transcode this
// to UTF8, but the downside of that is it pulls in a bunch of stuff into what is ideally
// a path with minimal dependencies (as to prevent re-entrency), so we'll take the strategy
// of just throwing away any non ASCII characters from the message and writing the rest
const int BufferLength = 256;
unsafe
{
byte *buf = stackalloc byte[BufferLength];
int bufCount;
int i = 0;
using (SafeFileHandle fileHandle = SafeFileHandle.Open(filePath, Interop.Sys.OpenFlags.O_WRONLY, 0))
{
while (i < message.Length)
{
for (bufCount = 0; bufCount < BufferLength && i < message.Length; i++)
{
if (message[i] <= 0x7F)
{
buf[bufCount] = (byte)message[i];
bufCount++;
}
}
int totalBytesWritten = 0;
while (bufCount > 0)
{
int bytesWritten;
while (Interop.CheckIo(bytesWritten = (int)Interop.Sys.Write((int)fileHandle.DangerousGetHandle(), buf + totalBytesWritten, (ulong)bufCount)))
{
;
}
bufCount -= bytesWritten;
totalBytesWritten += bytesWritten;
}
}
}
}
}
internal WindowsFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
{
string fullPath = Path.GetFullPath(path);
_access = access;
_share = share;
_fileHandle = SafeFileHandle.Open(fullPath, mode, access, share, options, preallocationSize);
try
{
Init(mode, path);
}
catch
{
// If anything goes wrong while setting up the stream, make sure we deterministically dispose
// of the opened handle.
_fileHandle.Dispose();
_fileHandle = null !;
throw;
}
}
public void WriteCore(string message)
{
// We don't want to write UTF-16 to standard error. Ideally we would transcode this
// to UTF8, but the downside of that is it pulls in a bunch of stuff into what is ideally
// a path with minimal dependencies (as to prevent re-entrency), so we'll take the strategy
// of just throwing away any non ASCII characters from the message and writing the rest
const int BufferLength = 256;
unsafe
{
byte *buf = stackalloc byte[BufferLength];
int bufCount;
int i = 0;
using (SafeFileHandle stderr = SafeFileHandle.Open(Interop.Devices.stderr, Interop.libc.OpenFlags.O_WRONLY, 0))
{
while (i < message.Length)
{
for (bufCount = 0; bufCount < BufferLength && i < message.Length; i++)
{
if (message[i] <= 0x7F)
{
buf[bufCount] = (byte)message[i];
bufCount++;
}
}
if (bufCount != 0)
{
while (Interop.CheckIo((long)Interop.libc.write((int)stderr.DangerousGetHandle(), buf, new IntPtr(bufCount))))
{
;
}
}
}
}
}
}
public static Stream OpenStandardError()
{
return(new UnixConsoleStream(SafeFileHandle.Open(() => Interop.Sys.Dup(Interop.Sys.FileDescriptors.STDERR_FILENO)), FileAccess.Write));
}
public static Stream OpenStandardInput()
{
return(new UnixConsoleStream(SafeFileHandle.Open(() => Interop.Sys.Dup(Interop.Sys.FileDescriptors.STDIN_FILENO)), FileAccess.Read));
}