private void Create(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
{
Debug.Assert(direction != PipeDirection.InOut, "Anonymous pipe direction shouldn't be InOut");
// Ignore bufferSize. It's optional, and the fcntl F_SETPIPE_SZ for changing it is Linux specific.
// Use pipe or pipe2 to create our anonymous pipe
int[] fds = new int[2];
unsafe
{
fixed (int* fdsptr = fds)
{
CreatePipe(inheritability, fdsptr);
}
}
// Create SafePipeHandles for each end of the pipe. Which ends goes with server and which goes with
// client depends on the direction of the pipe.
SafePipeHandle serverHandle = new SafePipeHandle(
(IntPtr)fds[direction == PipeDirection.In ? Interop.libc.ReadEndOfPipe : Interop.libc.WriteEndOfPipe],
ownsHandle: true);
SafePipeHandle clientHandle = new SafePipeHandle(
(IntPtr)fds[direction == PipeDirection.In ? Interop.libc.WriteEndOfPipe : Interop.libc.ReadEndOfPipe],
ownsHandle: true);
// We're connected. Finish initialization using the newly created handles.
InitializeHandle(serverHandle, isExposed: false, isAsync: false);
_clientHandle = clientHandle;
State = PipeState.Connected;
}
protected static void StartClient(PipeDirection direction, SafePipeHandle clientPipeHandle)
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(direction, clientPipeHandle))
{
DoStreamOperations(client);
}
}
public static void NullServerName_Throws_ArgumentNullException(PipeDirection direction)
{
Assert.Throws<ArgumentNullException>("serverName", () => new NamedPipeClientStream(null, "client1"));
Assert.Throws<ArgumentNullException>("serverName", () => new NamedPipeClientStream(null, "client1", direction));
Assert.Throws<ArgumentNullException>("serverName", () => new NamedPipeClientStream(null, "client1", direction, PipeOptions.None));
Assert.Throws<ArgumentNullException>("serverName", () => new NamedPipeClientStream(null, "client1", direction, PipeOptions.None, TokenImpersonationLevel.None));
}
private void Init(PipeDirection direction, PipeTransmissionMode transmissionMode, int outBufferSize)
{
Debug.Assert(direction >= PipeDirection.In && direction <= PipeDirection.InOut, "invalid pipe direction");
Debug.Assert(transmissionMode >= PipeTransmissionMode.Byte && transmissionMode <= PipeTransmissionMode.Message, "transmissionMode is out of range");
Debug.Assert(outBufferSize >= 0, "outBufferSize is negative");
// always defaults to this until overridden
_readMode = transmissionMode;
_transmissionMode = transmissionMode;
_pipeDirection = direction;
if ((_pipeDirection & PipeDirection.In) != 0)
{
_canRead = true;
}
if ((_pipeDirection & PipeDirection.Out) != 0)
{
_canWrite = true;
}
_outBufferSize = outBufferSize;
// This should always default to true
_isMessageComplete = true;
_state = PipeState.WaitingToConnect;
_streamAsyncHelper = new StreamAsyncHelper(this);
}
private NamedPipeServerStream(String pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
HandleInheritability inheritability)
: base(direction, transmissionMode, outBufferSize)
{
if (pipeName == null)
{
throw new ArgumentNullException("pipeName");
}
if (pipeName.Length == 0)
{
throw new ArgumentException(SR.Argument_NeedNonemptyPipeName);
}
if ((options & ~(PipeOptions.WriteThrough | PipeOptions.Asynchronous)) != 0)
{
throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_OptionsInvalid);
}
if (inBufferSize < 0)
{
throw new ArgumentOutOfRangeException("inBufferSize", SR.ArgumentOutOfRange_NeedNonNegNum);
}
// win32 allows fixed values of 1-254 or 255 to mean max allowed by system. We expose 255 as -1 (unlimited)
// through the MaxAllowedServerInstances constant. This is consistent e.g. with -1 as infinite timeout, etc
if ((maxNumberOfServerInstances < 1 || maxNumberOfServerInstances > 254) && (maxNumberOfServerInstances != MaxAllowedServerInstances))
{
throw new ArgumentOutOfRangeException("maxNumberOfServerInstances", SR.ArgumentOutOfRange_MaxNumServerInstances);
}
if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable)
{
throw new ArgumentOutOfRangeException("inheritability", SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable);
}
Create(pipeName, direction, maxNumberOfServerInstances, transmissionMode,
options, inBufferSize, outBufferSize, inheritability);
}
public AnonymousPipeServerStream(PipeDirection direction, SafePipeHandle serverSafePipeHandle, SafePipeHandle clientSafePipeHandle) : base(direction, 0)
{
if (direction == PipeDirection.InOut)
{
throw new NotSupportedException(System.SR.GetString("NotSupported_AnonymousPipeUnidirectional"));
}
if (serverSafePipeHandle == null)
{
throw new ArgumentNullException("serverSafePipeHandle");
}
if (clientSafePipeHandle == null)
{
throw new ArgumentNullException("clientSafePipeHandle");
}
if (serverSafePipeHandle.IsInvalid)
{
throw new ArgumentException(System.SR.GetString("Argument_InvalidHandle"), "serverSafePipeHandle");
}
if (clientSafePipeHandle.IsInvalid)
{
throw new ArgumentException(System.SR.GetString("Argument_InvalidHandle"), "clientSafePipeHandle");
}
if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(serverSafePipeHandle) != 3)
{
throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
}
if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(clientSafePipeHandle) != 3)
{
throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
}
base.InitializeHandle(serverSafePipeHandle, true, false);
this.m_clientHandle = clientSafePipeHandle;
this.m_clientHandleExposed = true;
base.State = PipeState.Connected;
}
private NamedPipeServerStream(String pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
HandleInheritability inheritability)
: base(direction, transmissionMode, outBufferSize)
{
if (pipeName == null)
{
throw new ArgumentNullException("pipeName");
}
if (pipeName.Length == 0)
{
throw new ArgumentException(SR.Argument_NeedNonemptyPipeName);
}
if ((options & ~(PipeOptions.WriteThrough | PipeOptions.Asynchronous)) != 0)
{
throw new ArgumentOutOfRangeException("options", SR.ArgumentOutOfRange_OptionsInvalid);
}
if (inBufferSize < 0)
{
throw new ArgumentOutOfRangeException("inBufferSize", SR.ArgumentOutOfRange_NeedNonNegNum);
}
ValidateMaxNumberOfServerInstances(maxNumberOfServerInstances);
// inheritability will always be None since this private constructor is only called from other constructors from which
// inheritability is always set to None. Desktop has a public constructor to allow setting it to something else, but Core
// doesnt.
if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable)
{
throw new ArgumentOutOfRangeException("inheritability", SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable);
}
Create(pipeName, direction, maxNumberOfServerInstances, transmissionMode,
options, inBufferSize, outBufferSize, inheritability);
}
private void Create(string pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
HandleInheritability inheritability)
{
Debug.Assert(pipeName != null && pipeName.Length != 0, "fullPipeName is null or empty");
Debug.Assert(direction >= PipeDirection.In && direction <= PipeDirection.InOut, "invalid pipe direction");
Debug.Assert(inBufferSize >= 0, "inBufferSize is negative");
Debug.Assert(outBufferSize >= 0, "outBufferSize is negative");
Debug.Assert((maxNumberOfServerInstances >= 1) || (maxNumberOfServerInstances == MaxAllowedServerInstances), "maxNumberOfServerInstances is invalid");
Debug.Assert(transmissionMode >= PipeTransmissionMode.Byte && transmissionMode <= PipeTransmissionMode.Message, "transmissionMode is out of range");
if (transmissionMode == PipeTransmissionMode.Message)
{
throw new PlatformNotSupportedException(SR.PlatformNotSupported_MessageTransmissionMode);
}
// NOTE: We don't have a good way to enforce maxNumberOfServerInstances, and don't currently try.
// It's a Windows-specific concept.
_path = GetPipePath(".", pipeName);
_direction = direction;
_options = options;
_inBufferSize = inBufferSize;
_outBufferSize = outBufferSize;
_inheritability = inheritability;
}
private void Create(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
{
Debug.Assert(direction != PipeDirection.InOut, "Anonymous pipe direction shouldn't be InOut");
Debug.Assert(bufferSize >= 0, "bufferSize is negative");
throw NotImplemented.ByDesign; // TODO: Implement this
}
public AnonymousPipeClientStream(PipeDirection direction, String pipeHandleAsString)
: base(direction, 0)
{
if (direction == PipeDirection.InOut)
{
throw new NotSupportedException(SR.NotSupported_AnonymousPipeUnidirectional);
}
if (pipeHandleAsString == null)
{
throw new ArgumentNullException("pipeHandleAsString");
}
// Initialize SafePipeHandle from String and check if it's valid. First see if it's parseable
long result = 0;
bool parseable = long.TryParse(pipeHandleAsString, out result);
if (!parseable)
{
throw new ArgumentException(SR.Argument_InvalidHandle, "pipeHandleAsString");
}
// next check whether the handle is invalid
SafePipeHandle safePipeHandle = new SafePipeHandle((IntPtr)result, true);
if (safePipeHandle.IsInvalid)
{
throw new ArgumentException(SR.Argument_InvalidHandle, "pipeHandleAsString");
}
Init(direction, safePipeHandle);
}
public static void EmptyStringServerName_Throws_ArgumentException(PipeDirection direction)
{
Assert.Throws<ArgumentException>(() => new NamedPipeClientStream("", "client1"));
Assert.Throws<ArgumentException>(() => new NamedPipeClientStream("", "client1", direction));
Assert.Throws<ArgumentException>(() => new NamedPipeClientStream("", "client1", direction, PipeOptions.None));
Assert.Throws<ArgumentException>(() => new NamedPipeClientStream("", "client1", direction, PipeOptions.None, TokenImpersonationLevel.None));
}
public AnonymousPipeServerStream(PipeDirection direction, SafePipeHandle serverSafePipeHandle, SafePipeHandle clientSafePipeHandle)
: base(direction, 0)
{
if (direction == PipeDirection.InOut)
{
throw new NotSupportedException(SR.NotSupported_AnonymousPipeUnidirectional);
}
if (serverSafePipeHandle == null)
{
throw new ArgumentNullException("serverSafePipeHandle");
}
if (clientSafePipeHandle == null)
{
throw new ArgumentNullException("clientSafePipeHandle");
}
if (serverSafePipeHandle.IsInvalid)
{
throw new ArgumentException(SR.Argument_InvalidHandle, "serverSafePipeHandle");
}
if (clientSafePipeHandle.IsInvalid)
{
throw new ArgumentException(SR.Argument_InvalidHandle, "clientSafePipeHandle");
}
ValidateHandleIsPipe(serverSafePipeHandle);
ValidateHandleIsPipe(clientSafePipeHandle);
InitializeHandle(serverSafePipeHandle, true, false);
_clientHandle = clientSafePipeHandle;
_clientHandleExposed = true;
State = PipeState.Connected;
}
private void Create(string pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
HandleInheritability inheritability)
{
Debug.Assert(pipeName != null && pipeName.Length != 0, "fullPipeName is null or empty");
Debug.Assert(direction >= PipeDirection.In && direction <= PipeDirection.InOut, "invalid pipe direction");
Debug.Assert(inBufferSize >= 0, "inBufferSize is negative");
Debug.Assert(outBufferSize >= 0, "outBufferSize is negative");
Debug.Assert((maxNumberOfServerInstances >= 1) || (maxNumberOfServerInstances == MaxAllowedServerInstances), "maxNumberOfServerInstances is invalid");
Debug.Assert(transmissionMode >= PipeTransmissionMode.Byte && transmissionMode <= PipeTransmissionMode.Message, "transmissionMode is out of range");
if (transmissionMode == PipeTransmissionMode.Message)
{
throw new PlatformNotSupportedException();
}
// NOTE: We don't have a good way to enforce maxNumberOfServerInstances, and don't currently try.
// It's a Windows-specific concept.
// Make sure the FIFO exists, but don't open it until WaitForConnection is called.
_path = GetPipePath(".", pipeName);
while (true)
{
int result = Interop.libc.mkfifo(_path, (int)Interop.libc.Permissions.S_IRWXU);
if (result == 0)
{
// The FIFO was successfully created - note that although we create the FIFO here, we don't
// ever delete it. If we remove the FIFO we could invalidate other servers that also use it.
// See #2764 for further discussion.
break;
}
Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo();
if (errorInfo.Error == Interop.Error.EINTR)
{
// interrupted; try again
continue;
}
else if (errorInfo.Error == Interop.Error.EEXIST)
{
// FIFO already exists; nothing more to do
break;
}
else
{
// something else; fail
throw Interop.GetExceptionForIoErrno(errorInfo, _path);
}
}
// Store the rest of the creation arguments. They'll be used when we open the connection
// in WaitForConnection.
_direction = direction;
_options = options;
_inBufferSize = inBufferSize;
_outBufferSize = outBufferSize;
_inheritability = inheritability;
}
public static void StartClient(PipeDirection direction, SafePipeHandle clientPipeHandle)
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(direction, clientPipeHandle))
{
DoStreamOperations(client);
}
// If you don't see this message that means that this task crashed.
Console.WriteLine("*** Client operations suceedeed. ***");
}
private void Init(PipeDirection direction, SafePipeHandle safePipeHandle)
{
if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(safePipeHandle) != 3)
{
throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
}
base.InitializeHandle(safePipeHandle, true, false);
base.State = PipeState.Connected;
}
private void Init(PipeDirection direction, SafePipeHandle safePipeHandle)
{
Debug.Assert(direction != PipeDirection.InOut, "anonymous pipes are unidirectional, caller should have verified before calling Init");
Debug.Assert(safePipeHandle != null && !safePipeHandle.IsInvalid, "safePipeHandle must be valid");
ValidateHandleIsPipe(safePipeHandle);
InitializeHandle(safePipeHandle, true, false);
State = PipeState.Connected;
}
public static void NullPipeName_Throws_ArgumentNullException(PipeDirection direction)
{
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null));
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null, direction));
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null, direction, 2));
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null, direction, 3, PipeTransmissionMode.Byte));
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null, direction, 3, PipeTransmissionMode.Byte, PipeOptions.None));
Assert.Throws<ArgumentNullException>("pipeName", () => new NamedPipeServerStream(null, direction, 3, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0));
}
public static void ZeroLengthPipeName_Throws_ArgumentException(PipeDirection direction)
{
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream(""));
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream("", direction));
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream("", direction, 2));
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte));
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None));
Assert.Throws<ArgumentException>(() => new NamedPipeServerStream("", direction, 3, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0));
}
public static void ReservedPipeName_Throws_ArgumentOutOfRangeException(PipeDirection direction)
{
const string reservedName = "anonymous";
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName, direction));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName, direction, 1));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName, direction, 1, PipeTransmissionMode.Byte));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName, direction, 1, PipeTransmissionMode.Byte, PipeOptions.None));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeServerStream(reservedName, direction, 1, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0));}
public static void ReservedPipeName_Throws_ArgumentOutOfRangeException(PipeDirection direction)
{
const string serverName = ".";
const string reservedName = "anonymous";
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(reservedName));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction, PipeOptions.None));
Assert.Throws<ArgumentOutOfRangeException>("pipeName", () => new NamedPipeClientStream(serverName, reservedName, direction, PipeOptions.None, TokenImpersonationLevel.Impersonation));
}
public NamedPipeClientStream (PipeDirection direction, bool isAsync, bool isConnected, SafePipeHandle safePipeHandle)
: base (direction, DefaultBufferSize)
{
if (IsWindows)
impl = new Win32NamedPipeClient (this, safePipeHandle);
else
impl = new UnixNamedPipeClient (this, safePipeHandle);
IsConnected = isConnected;
InitializeHandle (safePipeHandle, true, isAsync);
}
protected PipeStream(PipeDirection direction, int bufferSize)
{
if ((direction < PipeDirection.In) || (direction > PipeDirection.InOut))
{
throw new ArgumentOutOfRangeException("direction", System.SR.GetString("ArgumentOutOfRange_DirectionModeInOutOrInOut"));
}
if (bufferSize < 0)
{
throw new ArgumentOutOfRangeException("bufferSize", System.SR.GetString("ArgumentOutOfRange_NeedNonNegNum"));
}
this.Init(direction, PipeTransmissionMode.Byte, bufferSize);
}
public AnonymousPipeServerStream(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
: base(direction, bufferSize) {
if (direction == PipeDirection.InOut) {
throw new NotSupportedException(SR.GetString(SR.NotSupported_AnonymousPipeUnidirectional));
}
if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable) {
throw new ArgumentOutOfRangeException("inheritability", SR.GetString(SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable));
}
UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = PipeStream.GetSecAttrs(inheritability);
Create(direction, secAttrs, bufferSize);
}
private void Create(string pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
HandleInheritability inheritability)
{
Debug.Assert(pipeName != null && pipeName.Length != 0, "fullPipeName is null or empty");
Debug.Assert(direction >= PipeDirection.In && direction <= PipeDirection.InOut, "invalid pipe direction");
Debug.Assert(inBufferSize >= 0, "inBufferSize is negative");
Debug.Assert(outBufferSize >= 0, "outBufferSize is negative");
Debug.Assert((maxNumberOfServerInstances >= 1 && maxNumberOfServerInstances <= 254) || (maxNumberOfServerInstances == MaxAllowedServerInstances), "maxNumberOfServerInstances is invalid");
Debug.Assert(transmissionMode >= PipeTransmissionMode.Byte && transmissionMode <= PipeTransmissionMode.Message, "transmissionMode is out of range");
throw NotImplemented.ByDesign; // TODO: Implement this
}
internal static PipeAccessRights ToAccessRights (PipeDirection direction)
{
switch (direction) {
case PipeDirection.In:
return PipeAccessRights.ReadData;
case PipeDirection.Out:
return PipeAccessRights.WriteData;
case PipeDirection.InOut:
return PipeAccessRights.ReadData | PipeAccessRights.WriteData;
default:
throw new ArgumentOutOfRangeException ();
}
}
public AnonymousPipeClientStream (PipeDirection direction,SafePipeHandle safePipeHandle)
: base (direction, DefaultBufferSize)
{
/*
if (IsWindows)
impl = new Win32AnonymousPipeClient (this, safePipeHandle);
else
impl = new UnixAnonymousPipeClient (this, safePipeHandle);
*/
InitializeHandle (safePipeHandle, false, false);
IsConnected = true;
}
protected PipeStream(PipeDirection direction, int bufferSize)
{
if (direction < PipeDirection.In || direction > PipeDirection.InOut)
{
throw new ArgumentOutOfRangeException("direction", SR.ArgumentOutOfRange_DirectionModeInOutOrInOut);
}
if (bufferSize < 0)
{
throw new ArgumentOutOfRangeException("bufferSize", SR.ArgumentOutOfRange_NeedNonNegNum);
}
Init(direction, PipeTransmissionMode.Byte, bufferSize);
}
public AnonymousPipeServerStream(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
: base(direction, bufferSize)
{
if (direction == PipeDirection.InOut)
{
throw new NotSupportedException(SR.NotSupported_AnonymousPipeUnidirectional);
}
if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable)
{
throw new ArgumentOutOfRangeException("inheritability", SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable);
}
Create(direction, inheritability, bufferSize);
}
public AnonymousPipeServerStream (PipeDirection direction, HandleInheritability inheritability, int bufferSize, PipeSecurity pipeSecurity)
: base (direction, bufferSize)
{
if (direction == PipeDirection.InOut)
throw new NotSupportedException ("Anonymous pipe direction can only be either in or out.");
if (IsWindows)
impl = new Win32AnonymousPipeServer (this, direction, inheritability, bufferSize, pipeSecurity);
else
impl = new UnixAnonymousPipeServer (this, direction, inheritability, bufferSize);
InitializeHandle (impl.Handle, false, false);
IsConnected = true;
}
public NamedPipeServerStream (string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeSecurity pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights)
: base (direction, transmissionMode, outBufferSize)
{
if (pipeSecurity != null)
throw ThrowACLException ();
var rights = ToAccessRights (direction) | additionalAccessRights;
// FIXME: reject some rights declarations (for ACL).
if (IsWindows)
impl = new Win32NamedPipeServer (this, pipeName, maxNumberOfServerInstances, transmissionMode, rights, options, inBufferSize, outBufferSize, inheritability);
else
impl = new UnixNamedPipeServer (this, pipeName, maxNumberOfServerInstances, transmissionMode, rights, options, inBufferSize, outBufferSize, inheritability);
InitializeHandle (impl.Handle, false, (options & PipeOptions.Asynchronous) != PipeOptions.None);
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeServerStreamAdapter" /> class from the specified pipe handles.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <param name="serverSafePipeHandle">A safe handle for the pipe that this <see cref="AnonymousPipeServerStreamAdapter" /> object will encapsulate.</param>
/// <param name="clientSafePipeHandle">A safe handle for the <see cref="T:System.IO.Pipes.AnonymousPipeClientStream" /> object.</param>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="serverSafePipeHandle" /> or <paramref name="clientSafePipeHandle" /> is an invalid handle.</exception>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="serverSafePipeHandle" /> or <paramref name="clientSafePipeHandle" /> is <see langword="null" />.</exception>
/// <exception cref="T:System.NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</exception>
/// <exception cref="T:System.IO.IOException">An I/O error, such as a disk error, has occurred.-or-The stream has been closed.</exception>
public AnonymousPipeServerStreamAdapter(PipeDirection direction, [NotNull] SafePipeHandle serverSafePipeHandle, [NotNull] SafePipeHandle clientSafePipeHandle)
: this(new AnonymousPipeServerStream(direction, serverSafePipeHandle, clientSafePipeHandle))
{
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeClientStreamAdapter" /> class from the specified handle.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <param name="safePipeHandle">A safe handle for the pipe that this <see cref="AnonymousPipeClientStreamAdapter" /> object will encapsulate.</param>
/// <exception cref="ArgumentException">
/// <paramref name="safePipeHandle " />is not a valid handle.</exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="safePipeHandle" /> is <see langword="null" />.</exception>
/// <exception cref="NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="PipeDirection.InOut" />.</exception>
/// <exception cref="IOException">An I/O error, such as a disk error, has occurred.-or-The stream has been closed.</exception>
public AnonymousPipeClientStreamAdapter(PipeDirection direction, [NotNull] SafePipeHandle safePipeHandle)
: this(new AnonymousPipeClientStream(direction, safePipeHandle))
{
}
public static void InvalidPipeOptions_Throws_ArgumentOutOfRangeException(PipeDirection direction)
{
Assert.Throws <ArgumentOutOfRangeException>("options", () => new NamedPipeServerStream("temp1", direction, 1, PipeTransmissionMode.Byte, (PipeOptions)255));
Assert.Throws <ArgumentOutOfRangeException>("options", () => new NamedPipeServerStream("tempx", direction, 1, PipeTransmissionMode.Byte, (PipeOptions)255, 0, 0));
}
public AnonymousPipeClientStream(PipeDirection direction, string pipeHandleAsString)
: this(direction, ToSafePipeHandle(pipeHandleAsString))
{
}
public NamedPipeServerStream(string pipeName, PipeDirection direction)
: this(pipeName, direction, 1)
{
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options)
: this(pipeName, direction, maxNumberOfServerInstances, transmissionMode, options, DefaultBufferSize, DefaultBufferSize)
{
}
public AnonymousPipeServerStream(PipeDirection direction, HandleInheritability inheritability)
: this(direction, inheritability, 0)
{
}
public PipeVisualState(PipeDirection pipeDirection, ConduitLayer conduitLayer)
{
PipeDirection = pipeDirection;
ConduitLayer = conduitLayer;
}
[PlatformSpecific(TestPlatforms.Windows)] // accessing SafePipeHandle on Unix fails for a non-connected stream
public static void Windows_CreateFromAlreadyBoundHandle_Throws_ArgumentException(PipeDirection direction)
{
// The pipe is already bound
using (var pipe = new NamedPipeServerStream(GetUniquePipeName(), direction, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
Assert.Throws <ArgumentException>(() => new NamedPipeServerStream(direction, true, true, pipe.SafePipeHandle));
}
}
[PlatformSpecific(TestPlatforms.Windows)] // accessing SafePipeHandle on Unix fails for a non-connected stream
public static void Windows_CreateFromDisposedServerHandle_Throws_ObjectDisposedException(PipeDirection direction)
{
// The pipe is closed when we try to make a new Stream with it
var pipe = new NamedPipeServerStream(GetUniquePipeName(), direction, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
SafePipeHandle handle = pipe.SafePipeHandle;
pipe.Dispose();
Assert.Throws <ObjectDisposedException>(() => new NamedPipeServerStream(direction, true, true, pipe.SafePipeHandle).Dispose());
}
public static void InvalidPipeHandle_Throws_ArgumentException(PipeDirection direction)
{
SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
Assert.Throws <ArgumentException>("safePipeHandle", () => new NamedPipeServerStream(direction, false, true, pipeHandle));
}
public static void NullPipeHandle_Throws_ArgumentNullException(PipeDirection direction)
{
Assert.Throws <ArgumentNullException>("safePipeHandle", () => new NamedPipeServerStream(direction, false, true, null));
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeClientStreamAdapter" /> class with the specified pipe direction and a string representation of the pipe handle.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <param name="pipeHandleAsString">A string that represents the pipe handle.</param>
/// <exception cref="ArgumentException">
/// <paramref name="pipeHandleAsString" /> is an invalid handle.</exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="pipeHandleAsString" /> is <see langword="null" />.</exception>
/// <exception cref="NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="PipeDirection.InOut" />.</exception>
public AnonymousPipeClientStreamAdapter(PipeDirection direction, [NotNull] string pipeHandleAsString)
: this(new AnonymousPipeClientStream(direction, pipeHandleAsString))
{
}
protected PipeStream(PipeDirection direction, int bufferSize)
: this(direction, PipeTransmissionMode.Byte, bufferSize)
{
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize)
#if MOBILE
: base(direction, inBufferSize)
{
throw new NotImplementedException();
}
public void InvalidReadMode_Throws_ArgumentOutOfRangeException(PipeDirection serverDirection, PipeDirection clientDirection)
{
string pipeName = GetUniquePipeName();
using (var server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
using (var client = new NamedPipeClientStream(".", pipeName, clientDirection))
{
Task clientConnect = client.ConnectAsync();
server.WaitForConnection();
clientConnect.Wait();
Assert.Throws <ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
Assert.Throws <ArgumentOutOfRangeException>(() => client.ReadMode = (PipeTransmissionMode)999);
}
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode)
: this(pipeName, direction, maxNumberOfServerInstances, transmissionMode, PipeOptions.None)
{
}
public NamedPipeServerStream(String pipeName, PipeDirection direction)
: this(pipeName, direction, 1, PipeTransmissionMode.Byte, PipeOptions.None, 0, 0, HandleInheritability.None)
{
}
internal static NamedPipeClientStream CreateNamedPipeClient(string serverName, string pipeName, PipeDirection direction, PipeOptions options) => new NamedPipeClientStream(serverName, pipeName, direction, options);
// Creates the anonymous pipe.
private void Create(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
{
Create(direction, inheritability, bufferSize, null);
}
//////////////////////////////////////////////////////////////////////////////////////////////////// Method
////////////////////////////////////////////////////////////////////////////////////////// Static
//////////////////////////////////////////////////////////////////////////////// Public
#region 서버 생성하기 - CreateServer(pipeName, pipeDirection)
/// <summary>
/// 서버 생성하기
/// </summary>
/// <param name="pipeName">파이프명</param>
/// <param name="pipeDirection">파이프 방향</param>
/// <returns>명명 파이프</returns>
public static NamedPipe CreateServer(string pipeName, PipeDirection pipeDirection)
{
NamedPipe pipe = new NamedPipe(pipeName, pipeDirection);
return(pipe);
}
public static void InvalidTransmissionMode_Throws_ArgumentOutOfRangeException(PipeDirection direction)
{
Assert.Throws <ArgumentOutOfRangeException>("transmissionMode", () => new NamedPipeServerStream("temp1", direction, 1, (PipeTransmissionMode)123));
Assert.Throws <ArgumentOutOfRangeException>("transmissionMode", () => new NamedPipeServerStream("temp1", direction, 1, (PipeTransmissionMode)123, PipeOptions.None));
Assert.Throws <ArgumentOutOfRangeException>("transmissionMode", () => new NamedPipeServerStream("tempx", direction, 1, (PipeTransmissionMode)123, PipeOptions.None, 0, 0));
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeServerStreamAdapter" /> class with the specified pipe direction, inheritability mode, buffer size, and pipe security.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <param name="inheritability">One of the enumeration values that determines whether the underlying handle can be inherited by child processes.</param>
/// <param name="bufferSize">The size of the buffer. This value must be greater than or equal to 0. </param>
/// <param name="pipeSecurity">An object that determines the access control and audit security for the pipe.</param>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="inheritability" /> is not set to either <see cref="F:System.IO.HandleInheritability.None" /> or <see cref="F:System.IO.HandleInheritability.Inheritable" />.-or-
/// <paramref name="bufferSize" /> is less than 0.</exception>
/// <exception cref="T:System.NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</exception>
public AnonymousPipeServerStreamAdapter(PipeDirection direction, HandleInheritability inheritability, int bufferSize, PipeSecurity pipeSecurity)
: this(new AnonymousPipeServerStream(direction, inheritability, bufferSize, pipeSecurity))
{
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="pipeName">파이프명</param>
/// <param name="pipeDirection">파이프 방향</param>
private NamedPipe(string pipeName, PipeDirection pipeDirection) : this()
{
this.pipeName = string.Format(PIPE_NAME, pipeName);
this.pipeDirection = pipeDirection;
}
public static NamedPipeClientStream CreatePipeStream(String pipe_name, String host_name, int pipe_connect_timeout, PipeDirection direction = PipeDirection.InOut)
{
NamedPipeClientStream pipeClientStream = null;
try
{
_logger.LogMsg(Level.Debug, String.Format("Creating .NET NamedPipeClientStream object for {0}", pipe_name));
pipeClientStream =
new NamedPipeClientStream(
host_name,
pipe_name,
direction,
PipeOptions.Asynchronous, // TO DO: is Asynchronous the correct option?
System.Security.Principal.TokenImpersonationLevel.Impersonation,
HandleInheritability.Inheritable);
// Connect to the pipe
_logger.LogMsg(Level.Debug, String.Format("Attempting to connect to pipe [{0}] on host [{1}].", pipe_name, host_name));
pipeClientStream.Connect(pipe_connect_timeout);
_logger.LogMsg(Level.Info, String.Format("Pipe connection successful: [{0}].", pipe_name));
_logger.LogMsg(Level.Debug, String.Format("There are currently {0} pipe server instances open.", pipeClientStream.NumberOfServerInstances));
}
catch (System.Exception ex)
{
Debug.WriteLine("Error in CreatePipeStream(): " + ex.Message);
throw ex;
}
return(pipeClientStream);
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeServerStreamAdapter" /> class with the specified pipe direction and inheritability mode.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <param name="inheritability">One of the enumeration values that determines whether the underlying handle can be inherited by child processes. Must be set to either <see cref="F:System.IO.HandleInheritability.None" /> or <see cref="F:System.IO.HandleInheritability.Inheritable" />. </param>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="inheritability" /> is not set to either <see cref="F:System.IO.HandleInheritability.None" /> or <see cref="F:System.IO.HandleInheritability.Inheritable" />.</exception>
/// <exception cref="T:System.NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</exception>
public AnonymousPipeServerStreamAdapter(PipeDirection direction, HandleInheritability inheritability)
: this(new AnonymousPipeServerStream(direction, inheritability))
{
}
public NamedPipeClientStreamWrapper(string v, string token, PipeDirection inOut)
{
_pipeClientStream = new NamedPipeClientStream(v, token, inOut);
}
/// <summary>Initializes a new instance of the <see cref="AnonymousPipeServerStreamAdapter" /> class with the specified pipe direction.</summary>
/// <param name="direction">One of the enumeration values that determines the direction of the pipe.Anonymous pipes can only be in one direction, so <paramref name="direction" /> cannot be set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</param>
/// <exception cref="T:System.NotSupportedException">
/// <paramref name="direction" /> is set to <see cref="F:System.IO.Pipes.PipeDirection.InOut" />.</exception>
public AnonymousPipeServerStreamAdapter(PipeDirection direction)
: this(new AnonymousPipeServerStream(direction))
{
}
public static void InvalidBufferSize_Throws_ArgumentOutOfRangeException(PipeDirection direction)
{
Assert.Throws <ArgumentOutOfRangeException>("inBufferSize", () => new NamedPipeServerStream("temp2", direction, 1, PipeTransmissionMode.Byte, PipeOptions.None, -1, 0));
Assert.Throws <ArgumentOutOfRangeException>("outBufferSize", () => new NamedPipeServerStream("temp2", direction, 1, PipeTransmissionMode.Byte, PipeOptions.None, 0, -123));
}
public NamedPipeClientStream(string serverName, string pipeName, PipeDirection direction,
PipeOptions options, TokenImpersonationLevel impersonationLevel)
: this(serverName, pipeName, direction, options, impersonationLevel, HandleInheritability.None)
{
}
