private static int AccessMaskFromRights(PipeAccessRights rights)
{
if (rights < (PipeAccessRights)0 || rights > (PipeAccessRights.FullControl | PipeAccessRights.AccessSystemSecurity))
{
throw new ArgumentOutOfRangeException(nameof(rights), SR.ArgumentOutOfRange_NeedValidPipeAccessRights);
}
return (int)rights;
}
//
// Constructor for creating access rules for pipe objects
//
public PipeAccessRule(
String identity,
PipeAccessRights rights,
AccessControlType type)
: this(
new NTAccount(identity),
AccessMaskFromRights(rights, type),
false,
type) {
}
public PipeAuditRule(
String identity,
PipeAccessRights rights,
AuditFlags flags)
: this(
new NTAccount(identity),
AccessMaskFromRights(rights),
false,
flags)
{
}
public PipeAuditRule(
IdentityReference identity,
PipeAccessRights rights,
AuditFlags flags)
: this(
identity,
AccessMaskFromRights(rights),
false,
flags)
{
}
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);
}
internal static PipeDirection ToDirection (PipeAccessRights rights)
{
bool r = (rights & PipeAccessRights.ReadData) != 0;
bool w = (rights & PipeAccessRights.WriteData) != 0;
if (r) {
if (w)
return PipeDirection.InOut;
else
return PipeDirection.In;
} else {
if (w)
return PipeDirection.Out;
else
throw new ArgumentOutOfRangeException ();
}
}
public NamedPipeClientStream(string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability) : base(DirectionFromRights(desiredAccessRights), 0)
{
if (pipeName == null)
{
throw new ArgumentNullException("pipeName");
}
if (serverName == null)
{
throw new ArgumentNullException("serverName", System.SR.GetString("ArgumentNull_ServerName"));
}
if (pipeName.Length == 0)
{
throw new ArgumentException(System.SR.GetString("Argument_NeedNonemptyPipeName"));
}
if (serverName.Length == 0)
{
throw new ArgumentException(System.SR.GetString("Argument_EmptyServerName"));
}
if ((options & ~(PipeOptions.Asynchronous | PipeOptions.WriteThrough)) != PipeOptions.None)
{
throw new ArgumentOutOfRangeException("options", System.SR.GetString("ArgumentOutOfRange_OptionsInvalid"));
}
if ((impersonationLevel < TokenImpersonationLevel.None) || (impersonationLevel > TokenImpersonationLevel.Delegation))
{
throw new ArgumentOutOfRangeException("impersonationLevel", System.SR.GetString("ArgumentOutOfRange_ImpersonationInvalid"));
}
if ((inheritability < HandleInheritability.None) || (inheritability > HandleInheritability.Inheritable))
{
throw new ArgumentOutOfRangeException("inheritability", System.SR.GetString("ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable"));
}
if ((desiredAccessRights & ~(PipeAccessRights.AccessSystemSecurity | PipeAccessRights.FullControl)) != 0)
{
throw new ArgumentOutOfRangeException("desiredAccessRights", System.SR.GetString("ArgumentOutOfRange_InvalidPipeAccessRights"));
}
this.m_normalizedPipePath = Path.GetFullPath(@"\\" + serverName + @"\pipe\" + pipeName);
if (string.Compare(this.m_normalizedPipePath, @"\\.\pipe\anonymous", StringComparison.OrdinalIgnoreCase) == 0)
{
throw new ArgumentOutOfRangeException("pipeName", System.SR.GetString("ArgumentOutOfRange_AnonymousReserved"));
}
this.m_inheritability = inheritability;
this.m_impersonationLevel = impersonationLevel;
this.m_pipeOptions = options;
this.m_access = (int) desiredAccessRights;
}
// ACL's on pipes have a SYNCHRONIZE bit, and CreateFile ALWAYS asks for it.
// So for allows, let's always include this bit, and for denies, let's never
// include this bit unless we're denying full control. This is the right
// thing for users, even if it does make the model look asymmetrical from a
// purist point of view.
internal static int AccessMaskFromRights(PipeAccessRights rights, AccessControlType controlType)
{
if (rights < (PipeAccessRights)0 || rights > (PipeAccessRights.FullControl | PipeAccessRights.AccessSystemSecurity))
throw new ArgumentOutOfRangeException("rights", SR.ArgumentOutOfRange_NeedValidPipeAccessRights);
if (controlType == AccessControlType.Allow)
{
rights |= PipeAccessRights.Synchronize;
}
else if (controlType == AccessControlType.Deny)
{
if (rights != PipeAccessRights.FullControl)
{
rights &= ~PipeAccessRights.Synchronize;
}
}
return (int)rights;
}
protected FileAccess RightsToFileAccess(PipeAccessRights rights)
{
if ((rights & PipeAccessRights.ReadData) != 0)
{
if ((rights & PipeAccessRights.WriteData) != 0)
{
return(FileAccess.ReadWrite);
}
else
{
return(FileAccess.Read);
}
}
else if ((rights & PipeAccessRights.WriteData) != 0)
{
return(FileAccess.Write);
}
else
{
throw new InvalidOperationException("The pipe must be opened to either read or write");
}
}
internal NamedPipeServerStream(
string pipeName,
PipeDirection direction,
int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode,
PipeOptions options,
int inBufferSize,
int outBufferSize,
PipeSecurity?pipeSecurity,
HandleInheritability inheritability = HandleInheritability.None,
PipeAccessRights additionalAccessRights = default)
: base(direction, transmissionMode, outBufferSize)
{
ValidateParameters(pipeName, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize, outBufferSize, inheritability);
if (pipeSecurity != null && IsCurrentUserOnly)
{
throw new ArgumentException(SR.NotSupported_PipeSecurityIsCurrentUserOnly, nameof(pipeSecurity));
}
Create(pipeName, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize, outBufferSize, pipeSecurity, inheritability, additionalAccessRights);
}
// .ctor without handle - create new
public Win32NamedPipeClient(NamedPipeClientStream owner, string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, HandleInheritability inheritability)
{
name = String.Format("\\\\{0}\\pipe\\{1}", serverName, pipeName);
var att = new SecurityAttributesHack(inheritability == HandleInheritability.Inheritable);
is_async = (options & PipeOptions.Asynchronous) != PipeOptions.None;
opener = delegate
{
var ret = Win32Marshal.CreateFile(name, desiredAccessRights, 0, ref att, 3, 0, IntPtr.Zero);
if (ret == new IntPtr(-1L))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(new SafePipeHandle(ret, true));
};
this.owner = owner;
}
public PipeAccessRule (string identity, PipeAccessRights rights, AccessControlType type)
: this ((IdentityReference) null, rights, type)
{
throw new NotImplementedException ("ACL is not supported in Mono");
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeSecurity pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights)
: base(PipeDirection.InOut, -1)
{
throw new NotImplementedException();
}
// .ctor without handle - create new
public unsafe Win32NamedPipeServer (NamedPipeServerStream owner, string pipeName, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeAccessRights rights,
PipeOptions options, int inBufferSize, int outBufferSize,
PipeSecurity pipeSecurity, HandleInheritability inheritability)
{
string name = String.Format ("\\\\.\\pipe\\{0}", pipeName);
uint openMode;
openMode = (uint)rights | (uint)options; // Enum values match Win32 flags exactly.
int pipeMode = 0;
if ((owner.TransmissionMode & PipeTransmissionMode.Message) != 0)
pipeMode |= 4;
//if ((readTransmissionMode & PipeTransmissionMode.Message) != 0)
// pipeMode |= 2;
if ((options & PipeOptions.Asynchronous) != 0)
pipeMode |= 1;
byte[] securityDescriptor = null;
if (pipeSecurity != null)
securityDescriptor = pipeSecurity.GetSecurityDescriptorBinaryForm ();
fixed (byte* securityDescriptorPtr = securityDescriptor) {
// FIXME: is nDefaultTimeout = 0 ok?
var att = new SecurityAttributes (inheritability, (IntPtr)securityDescriptorPtr);
var ret = Win32Marshal.CreateNamedPipe (name, openMode, pipeMode, maxNumberOfServerInstances,
outBufferSize, inBufferSize, 0, ref att, IntPtr.Zero);
if (ret == new IntPtr (-1L))
throw Win32PipeError.GetException ();
handle = new SafePipeHandle (ret, true);
}
}
public PipeAccessRule(IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: base(identity, 0, false, InheritanceFlags.None, PropagationFlags.None, type)
{
throw new NotImplementedException("ACL is not supported in Mono");
}
// .ctor without handle - create new
public UnixNamedPipeClient (NamedPipeClientStream owner, string serverName, string pipeName,
PipeAccessRights desiredAccessRights, PipeOptions options, HandleInheritability inheritability)
{
this.owner = owner;
if (serverName != "." && !Dns.GetHostEntry (serverName).AddressList.Contains (IPAddress.Loopback))
throw new NotImplementedException ("Unix fifo does not support remote server connection");
var name = Path.Combine ("/var/tmp/", pipeName);
EnsureTargetFile (name);
RightsToAccess (desiredAccessRights);
ValidateOptions (options, owner.TransmissionMode);
// FIXME: handle inheritability
opener = delegate {
var fs = new FileStream (name, FileMode.Open, RightsToFileAccess (desiredAccessRights), FileShare.ReadWrite);
owner.Stream = fs;
handle = new SafePipeHandle (fs.Handle, false);
};
}
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 (pipeName == null) {
throw new ArgumentNullException("pipeName");
}
if (pipeName.Length == 0) {
throw new ArgumentException(SR.GetString(SR.Argument_NeedNonemptyPipeName));
}
if ((options & ~(PipeOptions.WriteThrough | PipeOptions.Asynchronous)) != 0) {
throw new ArgumentOutOfRangeException("options", SR.GetString(SR.ArgumentOutOfRange_OptionsInvalid));
}
if (inBufferSize < 0) {
throw new ArgumentOutOfRangeException("inBufferSize", SR.GetString(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.GetString(SR.ArgumentOutOfRange_MaxNumServerInstances));
}
if (inheritability < HandleInheritability.None || inheritability > HandleInheritability.Inheritable) {
throw new ArgumentOutOfRangeException("inheritability", SR.GetString(SR.ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable));
}
// ChangePermissions, TakeOwnership, and AccessSystemSecurity are only legal values user may provide;
// internally this is set to 0 if not provided. This handles both cases.
if ((additionalAccessRights & ~(PipeAccessRights.ChangePermissions | PipeAccessRights.TakeOwnership |
PipeAccessRights.AccessSystemSecurity)) != 0) {
throw new ArgumentOutOfRangeException("additionalAccessRights", SR.GetString(SR.ArgumentOutOfRange_AdditionalAccessLimited));
}
// Named Pipe Servers require Windows NT
if (Environment.OSVersion.Platform == PlatformID.Win32Windows) {
throw new PlatformNotSupportedException(SR.GetString(SR.PlatformNotSupported_NamedPipeServers));
}
string normalizedPipePath = Path.GetFullPath(@"\\.\pipe\" + pipeName);
// Make sure the pipe name isn't one of our reserved names for anonymous pipes.
if (String.Compare(normalizedPipePath, @"\\.\pipe\anonymous", StringComparison.OrdinalIgnoreCase) == 0) {
throw new ArgumentOutOfRangeException("pipeName", SR.GetString(SR.ArgumentOutOfRange_AnonymousReserved));
}
Object pinningHandle = null;
UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = PipeStream.GetSecAttrs(inheritability, pipeSecurity, out pinningHandle);
try {
Create(normalizedPipePath, direction, maxNumberOfServerInstances, transmissionMode,
options, inBufferSize, outBufferSize, additionalAccessRights, secAttrs);
}
finally {
if (pinningHandle != null) {
GCHandle pinHandle = (GCHandle)pinningHandle;
pinHandle.Free();
}
}
}
public NamedPipeClientStream(string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability)
: base(PipeDirection.In, 0)
{
throw new PlatformNotSupportedException();
}
public PipeAccessRule(IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: this(identity, AccessMaskFromRights(rights, type), false, type)
{
}
//
// Constructor for creating access rules for pipe objects
//
public PipeAccessRule(String identity, PipeAccessRights rights, AccessControlType type)
: this(new NTAccount(identity), AccessMaskFromRights(rights, type), false, type)
{
}
public PipeAuditRule(IdentityReference identity, PipeAccessRights accessRights, AuditFlags type)
: base(identity, (int)accessRights, false, InheritanceFlags.None, PropagationFlags.None, type)
{
}
public void AddAuditRule(IdentityReference identityReference, PipeAccessRights accessMask, AuditFlags flags)
{
AddAuditRule(new PipeAuditRule(identityReference, accessMask, flags));
}
public void AddAccessRule(IdentityReference identityReference, PipeAccessRights accessMask, AccessControlType type)
{
AddAccessRule(new PipeAccessRule(identityReference, accessMask, type));
}
internal static extern IntPtr CreateFile(string name, PipeAccessRights desiredAccess, FileShare fileShare, ref SecurityAttributesHack atts, int creationDisposition, int flags, IntPtr templateHandle);
private static SafePipeHandle CreateNamedPipe(string fullPipeName, PipeDirection direction,
uint maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options,
uint inBufferSize, uint outBufferSize, PipeAccessRights rights, SECURITY_ATTRIBUTES secAttrs)
{
uint openMode = (uint)direction | (uint)options;
uint pipeMode = 0;
if (maxNumberOfServerInstances == -1)
{
maxNumberOfServerInstances = 0xff;
}
SafePipeHandle handle = CreateNamedPipe(fullPipeName, openMode, pipeMode,
maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, ref secAttrs);
if (handle.IsInvalid)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return(handle);
}
// .ctor without handle - create new
public Win32NamedPipeClient (NamedPipeClientStream owner, string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, HandleInheritability inheritability)
{
name = String.Format ("\\\\{0}\\pipe\\{1}", serverName, pipeName);
var att = new SecurityAttributesHack (inheritability == HandleInheritability.Inheritable);
is_async = (options & PipeOptions.Asynchronous) != PipeOptions.None;
opener = delegate {
var ret = Win32Marshal.CreateFile (name, desiredAccessRights, 0, ref att, 3, 0, IntPtr.Zero);
if (ret == new IntPtr (-1L))
throw new Win32Exception (Marshal.GetLastWin32Error ());
return new SafePipeHandle (ret, true);
};
this.owner = owner;
}
protected string RightsToAccess (PipeAccessRights rights)
{
string access = null;
if ((rights & PipeAccessRights.ReadData) != 0) {
if ((rights & PipeAccessRights.WriteData) != 0)
access = "r+";
else
access = "r";
}
else if ((rights & PipeAccessRights.WriteData) != 0)
access = "w";
else
throw new InvalidOperationException ("The pipe must be opened to either read or write");
return access;
}
// .ctor without handle - create new
public Win32NamedPipeServer (NamedPipeServerStream owner, string pipeName, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeAccessRights rights, PipeOptions options, int inBufferSize, int outBufferSize, HandleInheritability inheritability)
{
string name = String.Format ("\\\\.\\pipe\\{0}", pipeName);
uint openMode = 0;
if ((rights & PipeAccessRights.ReadData) != 0)
openMode |= 1;
if ((rights & PipeAccessRights.WriteData) != 0)
openMode |= 2;
if ((options & PipeOptions.WriteThrough) != 0)
openMode |= 0x80000000;
int pipeMode = 0;
if ((owner.TransmissionMode & PipeTransmissionMode.Message) != 0)
pipeMode |= 4;
//if ((readTransmissionMode & PipeTransmissionMode.Message) != 0)
// pipeMode |= 2;
if ((options & PipeOptions.Asynchronous) != 0)
pipeMode |= 1;
// FIXME: is nDefaultTimeout = 0 ok?
var att = new SecurityAttributesHack (inheritability == HandleInheritability.Inheritable);
var ret = Win32Marshal.CreateNamedPipe (name, openMode, pipeMode, maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, ref att, IntPtr.Zero);
if (ret == new IntPtr (-1L))
throw new Win32Exception (Marshal.GetLastWin32Error ());
handle = new SafePipeHandle (ret, true);
}
public PipeAuditRule(IdentityReference identity, PipeAccessRights rights, AuditFlags flags)
: base(identity, (int)rights, false, InheritanceFlags.None, PropagationFlags.None, flags)
{
}
internal static extern IntPtr CreateFile (string name, PipeAccessRights desiredAccess, FileShare fileShare, ref SecurityAttributesHack atts, int creationDisposition, int flags, IntPtr templateHandle);
public PipeAccessRule( IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: this(identity, AccessMaskFromRights(rights, type), false, type)
{
}
public PipeAuditRule(string identity, PipeAccessRights rights, AuditFlags flags)
: this((IdentityReference)null, rights, flags)
{
throw new NotImplementedException("ACL is not supported in Mono");
}
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);
}
public PipeAuditRule(string identity, PipeAccessRights rights, System.Security.AccessControl.AuditFlags flags) : base(default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AuditFlags))
{
}
public PipeAccessRule (IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: base (identity, 0, false, InheritanceFlags.None, PropagationFlags.None, type)
{
throw new NotImplementedException ("ACL is not supported in Mono");
}
public PipeAccessRule(IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: base(identity, (int)rights, false, InheritanceFlags.None, PropagationFlags.None, type)
{
}
public PipeAuditRule(string identity, PipeAccessRights rights, AuditFlags flags)
: this(new NTAccount(identity), rights, flags)
{
}
public PipeAccessRule(string identity, PipeAccessRights rights, AccessControlType type)
: this(new NTAccount(identity), rights, type)
{
}
// .ctor without handle - create new
public Win32NamedPipeServer(NamedPipeServerStream owner, string pipeName, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeAccessRights rights, PipeOptions options, int inBufferSize, int outBufferSize, HandleInheritability inheritability)
{
string name = String.Format("\\\\.\\pipe\\{0}", pipeName);
uint openMode = 0;
if ((rights & PipeAccessRights.ReadData) != 0)
{
openMode |= 1;
}
if ((rights & PipeAccessRights.WriteData) != 0)
{
openMode |= 2;
}
if ((options & PipeOptions.WriteThrough) != 0)
{
openMode |= 0x80000000;
}
int pipeMode = 0;
if ((owner.TransmissionMode & PipeTransmissionMode.Message) != 0)
{
pipeMode |= 4;
}
//if ((readTransmissionMode & PipeTransmissionMode.Message) != 0)
// pipeMode |= 2;
if ((options & PipeOptions.Asynchronous) != 0)
{
pipeMode |= 1;
}
// FIXME: is nDefaultTimeout = 0 ok?
var att = new SecurityAttributesHack(inheritability == HandleInheritability.Inheritable);
var ret = Win32Marshal.CreateNamedPipe(name, openMode, pipeMode, maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, ref att, IntPtr.Zero);
if (ret == new IntPtr(-1L))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
handle = new SafePipeHandle(ret, true);
}
public PipeAccessRule(IdentityReference identity, PipeAccessRights rights, AccessControlType type)
: base(null, 0, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow)
{
throw new NotImplementedException();
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeSecurity pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights) : base (default(PipeDirection), default(int))
{
Contract.Ensures(1 <= pipeName.Length);
}
private void VerifyValidSecurity(PipeAccessRights rights, AccessControlType accessControl)
{
PipeSecurity security = GetPipeSecurity(WellKnownSidType.BuiltinUsersSid, rights, accessControl);
CreateAndVerifyAnonymousPipe(security).Dispose();
}
// Helper method for the constructor above. The PipeStream protected constructor takes in a PipeDirection so we need
// to convert the access rights to a direction. Usually, PipeDirection.In/Out maps to GENERIC_READ/WRITE but in the
// other direction, READ/WRITE_DATA is sufficient.
private static PipeDirection DirectionFromRights(PipeAccessRights rights) {
PipeDirection direction = 0;
if ((rights & PipeAccessRights.ReadData) != 0) {
direction |= PipeDirection.In;
}
if ((rights & PipeAccessRights.WriteData) != 0) {
direction |= PipeDirection.Out;
}
return direction;
}
public PipeAccessRule(System.Security.Principal.IdentityReference identity, PipeAccessRights rights, System.Security.AccessControl.AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(System.Security.AccessControl.InheritanceFlags), default(System.Security.AccessControl.PropagationFlags), default(System.Security.AccessControl.AccessControlType))
{
}
private void Create(String fullPipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
PipeAccessRights rights, UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs) {
Debug.Assert(fullPipeName != null && fullPipeName.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");
int openMode = ((int)direction) |
(maxNumberOfServerInstances == 1 ? UnsafeNativeMethods.FILE_FLAG_FIRST_PIPE_INSTANCE : 0) |
(int)options |
(int)rights;
// We automatically set the ReadMode to match the TransmissionMode.
int pipeModes = (int)transmissionMode << 2 | (int)transmissionMode << 1;
// Convert -1 to 255 to match win32 (we asserted that it is between -1 and 254).
if (maxNumberOfServerInstances == MaxAllowedServerInstances) {
maxNumberOfServerInstances = 255;
}
SafePipeHandle handle = UnsafeNativeMethods.CreateNamedPipe(fullPipeName, openMode, pipeModes,
maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, secAttrs);
if (handle.IsInvalid) {
__Error.WinIOError(Marshal.GetLastWin32Error(), String.Empty);
}
InitializeHandle(handle, false, (options & PipeOptions.Asynchronous) != 0);
}
static NamedPipeServerStream CreateNamedServer (bool @async, string name,
PipeSecurity security,
PipeAccessRights additionalRights)
{
return new NamedPipeServerStream (name,
PipeDirection.InOut, 1,
PipeTransmissionMode.Byte,
@async ? PipeOptions.Asynchronous : PipeOptions.None,
512, 512, security,
HandleInheritability.None,
additionalRights);
}
protected FileAccess RightsToFileAccess (PipeAccessRights rights)
{
if ((rights & PipeAccessRights.ReadData) != 0) {
if ((rights & PipeAccessRights.WriteData) != 0)
return FileAccess.ReadWrite;
else
return FileAccess.Read;
}
else if ((rights & PipeAccessRights.WriteData) != 0)
return FileAccess.Write;
else
throw new InvalidOperationException ("The pipe must be opened to either read or write");
}
private void Create(string fullPipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeAccessRights rights, Microsoft.Win32.UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs)
{
int openMode = (int)(((direction | ((maxNumberOfServerInstances == 1) ? ((PipeDirection)0x80000) : ((PipeDirection)0))) | ((PipeDirection)((int)options))) | ((PipeDirection)((int)rights)));
int pipeMode = (((int)transmissionMode) << 2) | (((int)transmissionMode) << 1);
if (maxNumberOfServerInstances == -1)
{
maxNumberOfServerInstances = 0xff;
}
SafePipeHandle handle = Microsoft.Win32.UnsafeNativeMethods.CreateNamedPipe(fullPipeName, openMode, pipeMode, maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, secAttrs);
if (handle.IsInvalid)
{
System.IO.__Error.WinIOError(Marshal.GetLastWin32Error(), string.Empty);
}
base.InitializeHandle(handle, false, (options & PipeOptions.Asynchronous) != PipeOptions.None);
}
// .ctor without handle - create new
public UnixNamedPipeServer (NamedPipeServerStream owner, string pipeName, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeAccessRights rights, PipeOptions options,
int inBufferSize, int outBufferSize, HandleInheritability inheritability)
{
string name = Path.Combine ("/var/tmp/", pipeName);
EnsureTargetFile (name);
RightsToAccess (rights);
ValidateOptions (options, owner.TransmissionMode);
// FIXME: maxNumberOfServerInstances, modes, sizes, handle inheritability
var fs = new FileStream (name, FileMode.Open, RightsToFileAccess (rights), FileShare.ReadWrite);
handle = new SafePipeHandle (fs.Handle, false);
owner.Stream = fs;
should_close_handle = true;
}
public PipeAuditRule (string identity, PipeAccessRights rights, AuditFlags flags)
: this ((IdentityReference) null, rights, flags)
{
throw new NotImplementedException ("ACL is not supported in Mono");
}
public PipeAuditRule(string identity, PipeAccessRights rights, AuditFlags flags)
: base(null, 0, false, InheritanceFlags.None, PropagationFlags.None, AuditFlags.None)
{
throw new NotImplementedException();
}
public NamedPipeClientStream (string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability)
: base (ToDirection (desiredAccessRights), DefaultBufferSize)
{
if (impersonationLevel != TokenImpersonationLevel.None ||
inheritability != HandleInheritability.None)
throw ThrowACLException ();
if (IsWindows)
impl = new Win32NamedPipeClient (this, serverName, pipeName, desiredAccessRights, options, inheritability);
else
impl = new UnixNamedPipeClient (this, serverName, pipeName, desiredAccessRights, options, inheritability);
}
public PipeAccessRule(string identity, PipeAccessRights rights, AccessControlType type)
: this((IdentityReference)null, rights, type)
{
throw new NotImplementedException("ACL is not supported in Mono");
}
public void Create_ValidBitwiseRightsSecurity(PipeAccessRights rights, AccessControlType accessControl)
{
VerifyValidSecurity(rights, accessControl);
}
public NamedPipeClientStream(string serverName, string pipeName, PipeAccessRights desiredAccessRights, PipeOptions options, System.Security.Principal.TokenImpersonationLevel impersonationLevel, HandleInheritability inheritability) : base(default(PipeDirection), default(int))
{
Contract.Ensures(1 <= pipeName.Length);
Contract.Ensures(1 <= serverName.Length);
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeSecurity pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights)
: this(pipeName, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize, outBufferSize, inheritability)
{
if (additionalAccessRights != 0 || pipeSecurity != null)
{
throw new PlatformNotSupportedException();
}
}
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 (pipeName == null)
{
throw new ArgumentNullException("pipeName");
}
if (pipeName.Length == 0)
{
throw new ArgumentException(System.SR.GetString("Argument_NeedNonemptyPipeName"));
}
if ((options & ~(PipeOptions.Asynchronous | PipeOptions.WriteThrough)) != PipeOptions.None)
{
throw new ArgumentOutOfRangeException("options", System.SR.GetString("ArgumentOutOfRange_OptionsInvalid"));
}
if (inBufferSize < 0)
{
throw new ArgumentOutOfRangeException("inBufferSize", System.SR.GetString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (((maxNumberOfServerInstances < 1) || (maxNumberOfServerInstances > 0xfe)) && (maxNumberOfServerInstances != -1))
{
throw new ArgumentOutOfRangeException("maxNumberOfServerInstances", System.SR.GetString("ArgumentOutOfRange_MaxNumServerInstances"));
}
if ((inheritability < HandleInheritability.None) || (inheritability > HandleInheritability.Inheritable))
{
throw new ArgumentOutOfRangeException("inheritability", System.SR.GetString("ArgumentOutOfRange_HandleInheritabilityNoneOrInheritable"));
}
if ((additionalAccessRights & ~(PipeAccessRights.AccessSystemSecurity | PipeAccessRights.TakeOwnership | PipeAccessRights.ChangePermissions)) != 0)
{
throw new ArgumentOutOfRangeException("additionalAccessRights", System.SR.GetString("ArgumentOutOfRange_AdditionalAccessLimited"));
}
if (Environment.OSVersion.Platform == PlatformID.Win32Windows)
{
throw new PlatformNotSupportedException(System.SR.GetString("PlatformNotSupported_NamedPipeServers"));
}
string fullPath = Path.GetFullPath(@"\\.\pipe\" + pipeName);
if (string.Compare(fullPath, @"\\.\pipe\anonymous", StringComparison.OrdinalIgnoreCase) == 0)
{
throw new ArgumentOutOfRangeException("pipeName", System.SR.GetString("ArgumentOutOfRange_AnonymousReserved"));
}
object pinningHandle = null;
Microsoft.Win32.UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = PipeStream.GetSecAttrs(inheritability, pipeSecurity, out pinningHandle);
try
{
this.Create(fullPath, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize, outBufferSize, additionalAccessRights, secAttrs);
}
finally
{
if (pinningHandle != null)
{
((GCHandle)pinningHandle).Free();
}
}
}
public NamedPipeServerStream(string pipeName, PipeDirection direction, int maxNumberOfServerInstances, PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize, PipeSecurity pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights) : base(default(PipeDirection), default(int))
{
Contract.Ensures(1 <= pipeName.Length);
}
// This overload is used in Mono to implement public constructors.
private void Create(string pipeName, PipeDirection direction, int maxNumberOfServerInstances,
PipeTransmissionMode transmissionMode, PipeOptions options, int inBufferSize, int outBufferSize,
PipeSecurity?pipeSecurity, HandleInheritability inheritability, PipeAccessRights additionalAccessRights)
{
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");
string fullPipeName = Path.GetFullPath(@"\\.\pipe\" + pipeName);
// Make sure the pipe name isn't one of our reserved names for anonymous pipes.
if (string.Equals(fullPipeName, @"\\.\pipe\anonymous", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentOutOfRangeException(nameof(pipeName), SR.ArgumentOutOfRange_AnonymousReserved);
}
if (IsCurrentUserOnly)
{
Debug.Assert(pipeSecurity == null);
using (WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent())
{
SecurityIdentifier identifier = currentIdentity.Owner !;
// Grant full control to the owner so multiple servers can be opened.
// Full control is the default per MSDN docs for CreateNamedPipe.
PipeAccessRule rule = new PipeAccessRule(identifier, PipeAccessRights.FullControl, AccessControlType.Allow);
pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(rule);
pipeSecurity.SetOwner(identifier);
}
// PipeOptions.CurrentUserOnly is special since it doesn't match directly to a corresponding Win32 valid flag.
// Remove it, while keeping others untouched since historically this has been used as a way to pass flags to CreateNamedPipe
// that were not defined in the enumeration.
options &= ~PipeOptions.CurrentUserOnly;
}
int openMode = ((int)direction) |
(maxNumberOfServerInstances == 1 ? Interop.Kernel32.FileOperations.FILE_FLAG_FIRST_PIPE_INSTANCE : 0) |
(int)options |
(int)additionalAccessRights;
// We automatically set the ReadMode to match the TransmissionMode.
int pipeModes = (int)transmissionMode << 2 | (int)transmissionMode << 1;
// Convert -1 to 255 to match win32 (we asserted that it is between -1 and 254).
if (maxNumberOfServerInstances == MaxAllowedServerInstances)
{
maxNumberOfServerInstances = 255;
}
GCHandle pinningHandle = default;
try
{
Interop.Kernel32.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(inheritability, pipeSecurity, ref pinningHandle);
SafePipeHandle handle = Interop.Kernel32.CreateNamedPipe(fullPipeName, openMode, pipeModes,
maxNumberOfServerInstances, outBufferSize, inBufferSize, 0, ref secAttrs);
if (handle.IsInvalid)
{
throw Win32Marshal.GetExceptionForLastWin32Error();
}
InitializeHandle(handle, false, (options & PipeOptions.Asynchronous) != 0);
}
finally
{
if (pinningHandle.IsAllocated)
{
pinningHandle.Free();
}
}
}
public void Create_ValidParameters(PipeOptions options, PipeDirection direction, PipeTransmissionMode transmissionMode, HandleInheritability inheritability, int inBufferSize, int outBufferSize, int maxNumberOfServerInstances, PipeAccessRights rights, AccessControlType controlType)
{
if (controlType != AccessControlType.Deny && (rights & ~PipeAccessRights.Synchronize) != 0)
{
PipeSecurity security = GetPipeSecurity(WellKnownSidType.BuiltinUsersSid, rights, controlType);
CreateAndVerifyNamedPipe(GetRandomName(), security, direction, maxNumberOfServerInstances, transmissionMode, options, inBufferSize, outBufferSize, inheritability, 0).Dispose();
}
}
