public EventWaitHandleAccessRule (String identity, EventWaitHandleRights eventRights, AccessControlType type) : base(IdentityReference.IdentityFromName(identity), (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, type) {}
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if (name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if ((name != null) && (260 < name.Length)) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } SafeWaitHandle handle = Win32Native.OpenEvent((int)rights, false, name); if (handle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if ((2 == errorCode) || (0x7b == errorCode)) { throw new WaitHandleCannotBeOpenedException(); } if (((name != null) && (name.Length != 0)) && (6 == errorCode)) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(errorCode, ""); } return(new EventWaitHandle(handle)); }
static public EventWaitHandle CreateWaitHandle(string id, bool initState, EventResetMode resetMode, bool allowEveryone) { //EventResetMode.AutoReset: Set()後,不管有無進入WaitOne(),馬上被自動reset EventWaitHandle eventWaitHandle; bool createNew; if (allowEveryone) { //避免跨Process因權限不足產生WinIOError (Access to the path 'id' is denied.) // create a rule that allows anybody in the "Users" group to synchronise with us //var users = new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null); EventWaitHandleSecurity evhSec = new EventWaitHandleSecurity(); EventWaitHandleRights rights = EventWaitHandleRights.FullControl;// EventWaitHandleRights.Synchronize | EventWaitHandleRights.Modify; EventWaitHandleAccessRule evhAccessRule = new EventWaitHandleAccessRule("Everyone", rights, AccessControlType.Allow); evhSec.AddAccessRule(evhAccessRule); eventWaitHandle = new EventWaitHandle(initState, resetMode, id, out createNew); //eventWaitHandle.SetAccessControl(evhSec); } else { eventWaitHandle = new EventWaitHandle(initState, resetMode, id, out createNew); } return(eventWaitHandle); }
public EventWaitHandleAuditRule(IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : base(identity, 0, false, InheritanceFlags.None, PropagationFlags.None, flags) { if (eventRights < EventWaitHandleRights.Modify || eventRights > EventWaitHandleRights.FullControl) { throw new ArgumentOutOfRangeException("eventRights"); } if (flags < AuditFlags.None || flags > AuditFlags.Failure) { throw new ArgumentOutOfRangeException("flags"); } if (identity == null) { throw new ArgumentNullException("identity"); } if (eventRights == 0) { throw new ArgumentNullException("eventRights"); } if (flags == AuditFlags.None) { throw new ArgumentException("flags"); } if (!(identity is SecurityIdentifier)) { throw new ArgumentException("identity"); } this.rights = eventRights; }
public EventWaitHandleAccessRule (IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) : base (identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow) { }
public EventWaitHandleAuditRule (IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : base (identity, 0, false, InheritanceFlags.None, PropagationFlags.None, flags) { if (eventRights < EventWaitHandleRights.Modify || eventRights > EventWaitHandleRights.FullControl) { throw new ArgumentOutOfRangeException ("eventRights"); } if (flags < AuditFlags.None || flags > AuditFlags.Failure) { throw new ArgumentOutOfRangeException ("flags"); } if (identity == null) { throw new ArgumentNullException ("identity"); } if (eventRights == 0) { throw new ArgumentNullException ("eventRights"); } if (flags == AuditFlags.None) { throw new ArgumentException ("flags"); } if (!(identity is SecurityIdentifier)) { throw new ArgumentException ("identity"); } this.rights = eventRights; }
private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle?result) { if (name == null) { throw new ArgumentNullException(nameof(name)); } if (name.Length == 0) { throw new ArgumentException(SR.Argument_EmptyName, nameof(name)); } result = null; SafeWaitHandle existingHandle = Interop.Kernel32.OpenEvent((uint)rights, false, name); int errorCode = Marshal.GetLastWin32Error(); if (existingHandle.IsInvalid) { return(errorCode switch { Interop.Errors.ERROR_FILE_NOT_FOUND or Interop.Errors.ERROR_INVALID_NAME => OpenExistingResult.NameNotFound, Interop.Errors.ERROR_PATH_NOT_FOUND => OpenExistingResult.PathNotFound, Interop.Errors.ERROR_INVALID_HANDLE => OpenExistingResult.NameInvalid, _ => throw Win32Marshal.GetExceptionForWin32Error(errorCode, name) });
private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if (name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if (null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", name)); } Contract.EndContractBlock(); result = null; #if MOBILE throw new NotSupportedException(); #else #if MONO int errorCode; var myHandle = new SafeWaitHandle(NativeEventCalls.OpenEvent_internal(name, rights, out errorCode), true); #else #if FEATURE_MACL SafeWaitHandle myHandle = Win32Native.OpenEvent((int)rights, false, name); #else SafeWaitHandle myHandle = Win32Native.OpenEvent(Win32Native.EVENT_MODIFY_STATE | Win32Native.SYNCHRONIZE, false, name); #endif #endif if (myHandle.IsInvalid) { #if !MONO int errorCode = Marshal.GetLastWin32Error(); #endif if (Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode) { return(OpenExistingResult.NameNotFound); } if (Win32Native.ERROR_PATH_NOT_FOUND == errorCode) { return(OpenExistingResult.PathNotFound); } if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) { return(OpenExistingResult.NameInvalid); } //this is for passed through Win32Native Errors __Error.WinIOError(errorCode, ""); } result = new EventWaitHandle(myHandle); return(OpenExistingResult.Success); #endif }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { if (name == null) { throw new ArgumentNullException("name"); } if ((name.Length == 0) || (name.Length > 260)) { throw new ArgumentException("name", Locale.GetText("Invalid length [1-260].")); } MonoIOError error; IntPtr handle = NativeEventCalls.OpenEvent_internal(name, rights, out error); if (handle == (IntPtr)null) { if (error == MonoIOError.ERROR_FILE_NOT_FOUND) { throw new WaitHandleCannotBeOpenedException(Locale.GetText("Named Event handle does not exist: ") + name); } else if (error == MonoIOError.ERROR_ACCESS_DENIED) { throw new UnauthorizedAccessException(); } else { throw new IOException(Locale.GetText("Win32 IO error: ") + error.ToString()); } } return(new EventWaitHandle(handle)); }
public EventWaitHandleAccessRule(IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) : base(identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow) { }
private EventWaitHandleSecurity CreateSecurity(EventWaitHandleRights eventRights) { EventWaitHandleSecurity security = null; // When "running as user", we have to grant the target user permissions to the objects (events and file mapping) explicitly if (!string.IsNullOrEmpty(_session.ExecutableProcessUserName)) { security = new EventWaitHandleSecurity(); IdentityReference si; try { si = new NTAccount(_session.ExecutableProcessUserName); } catch (Exception e) { throw _logger.WriteException(new SessionLocalException(_session, string.Format(CultureInfo.CurrentCulture, "Error resolving account {0}", _session.ExecutableProcessUserName), e)); } EventWaitHandleAccessRule rule = new EventWaitHandleAccessRule( si, eventRights, AccessControlType.Allow); security.AddAccessRule(rule); } return(security); }
// Constructor. public EventWaitHandleAuditRule (IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags auditFlags) : base(identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, auditFlags) { }
public EventWaitHandleAccessRule (IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) // FIXME: accessMask=0 likely causes an error : base (identity, 0, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow) { this.rights = eventRights; }
public EventWaitHandleAccessRule(IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) // FIXME: accessMask=0 likely causes an error : base(identity, 0, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow) { this.rights = eventRights; }
public EventWaitHandleAccessRule (String identity, EventWaitHandleRights eventRights, AccessControlType type) : base(IdentityReference.IdentityFromName(identity), (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, type) { }
public EventWaitHandleAuditRule (IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : base (identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, flags) { if (eventRights < EventWaitHandleRights.Modify || eventRights > EventWaitHandleRights.FullControl) { throw new ArgumentOutOfRangeException ("eventRights"); } }
public EventWaitHandleAuditRule(IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : base(identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, flags) { if (eventRights < EventWaitHandleRights.Modify || eventRights > EventWaitHandleRights.FullControl) { throw new ArgumentOutOfRangeException("eventRights"); } }
private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result) { #if PLATFORM_UNIX throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); #else if (name == null) { throw new ArgumentNullException(nameof(name), SR.ArgumentNull_WithParamName); } if (name.Length == 0) { throw new ArgumentException(SR.Argument_EmptyName, nameof(name)); } if (null != name && System.IO.Path.MaxPath < name.Length) { throw new ArgumentException(SR.Format(SR.Argument_WaitHandleNameTooLong, Path.MaxPath), nameof(name)); } Contract.EndContractBlock(); result = null; SafeWaitHandle myHandle = Win32Native.OpenEvent(AccessRights, false, name); if (myHandle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if (Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode) { return(OpenExistingResult.NameNotFound); } if (Win32Native.ERROR_PATH_NOT_FOUND == errorCode) { return(OpenExistingResult.PathNotFound); } if (null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) { return(OpenExistingResult.NameInvalid); } //this is for passed through Win32Native Errors __Error.WinIOError(errorCode, ""); } result = new EventWaitHandle(myHandle); return(OpenExistingResult.Success); #endif }
/// <summary> /// Opens a specified named event wait handle, if it already exists, applying the desired access rights. /// </summary> /// <param name="name">The name of the event wait handle to be opened. If it's prefixed by "Global", it refers to a machine-wide event wait handle. If it's prefixed by "Local", or doesn't have a prefix, it refers to a session-wide event wait handle. Both prefix and name are case-sensitive.</param> /// <param name="rights">The desired access rights to apply to the returned event wait handle.</param> /// <returns>An existing named event wait handle.</returns> /// <exception cref="ArgumentNullException"><paramref name="name"/> is <see langword="null" />.</exception> /// <exception cref="ArgumentException"><paramref name="name"/> is an empty string.</exception> /// <exception cref="WaitHandleCannotBeOpenedException">The named event wait handle does not exist or is invalid.</exception> /// <exception cref="DirectoryNotFoundException">The path was not found.</exception> /// <exception cref="IOException">A Win32 error occurred.</exception> /// <exception cref="UnauthorizedAccessException">The named event wait handle exists, but the user does not have the security access required to use it.</exception> public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { switch (OpenExistingWorker(name, rights, out EventWaitHandle? result)) { case OpenExistingResult.NameNotFound: throw new WaitHandleCannotBeOpenedException(); case OpenExistingResult.NameInvalid: throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)); case OpenExistingResult.PathNotFound: throw new DirectoryNotFoundException(SR.Format(SR.IO_PathNotFound_Path, name)); case OpenExistingResult.Success: default: Debug.Assert(result != null, "result should be non-null on success"); return(result); } }
internal static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { EventWaitHandle result; switch (OpenExistingWorker(name, rights, out result)) { case OpenExistingResult.NameNotFound: throw new WaitHandleCannotBeOpenedException(); case OpenExistingResult.NameInvalid: throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name)); case OpenExistingResult.PathNotFound: throw Win32Marshal.GetExceptionForWin32Error(Interop.Errors.ERROR_PATH_NOT_FOUND, ""); default: return(result); } }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { EventWaitHandle result; switch (OpenExistingWorker(name, rights, out result)) { case OpenExistingResult.NameNotFound: throw new WaitHandleCannotBeOpenedException(); case OpenExistingResult.NameInvalid: throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name)); case OpenExistingResult.PathNotFound: __Error.WinIOError(Win32Native.ERROR_PATH_NOT_FOUND, ""); return(result); //never executes default: return(result); } }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { EventWaitHandle result; switch (EventWaitHandle.OpenExistingWorker(name, rights, out result)) { case WaitHandle.OpenExistingResult.NameNotFound: throw new WaitHandleCannotBeOpenedException(); case WaitHandle.OpenExistingResult.PathNotFound: __Error.WinIOError(3, ""); return(result); case WaitHandle.OpenExistingResult.NameInvalid: throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", (object)name)); default: return(result); } }
private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result) { #if PLATFORM_WINDOWS if (name == null) { throw new ArgumentNullException(nameof(name)); } if (name.Length == 0) { throw new ArgumentException(SR.Argument_EmptyName, nameof(name)); } result = null; SafeWaitHandle myHandle = Win32Native.OpenEvent(AccessRights, false, name); if (myHandle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if (Interop.Errors.ERROR_FILE_NOT_FOUND == errorCode || Interop.Errors.ERROR_INVALID_NAME == errorCode) { return(OpenExistingResult.NameNotFound); } if (Interop.Errors.ERROR_PATH_NOT_FOUND == errorCode) { return(OpenExistingResult.PathNotFound); } if (null != name && 0 != name.Length && Interop.Errors.ERROR_INVALID_HANDLE == errorCode) { return(OpenExistingResult.NameInvalid); } //this is for passed through Win32Native Errors throw Win32Marshal.GetExceptionForWin32Error(errorCode, ""); } result = new EventWaitHandle(myHandle); return(OpenExistingResult.Success); #else throw new PlatformNotSupportedException(SR.PlatformNotSupported_NamedSynchronizationPrimitives); #endif }
private static WaitHandle.OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if (name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if (name != null && 260 < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } result = null; SafeWaitHandle safeWaitHandle = Win32Native.OpenEvent((int)rights, false, name); if (safeWaitHandle.IsInvalid) { int lastWin32Error = Marshal.GetLastWin32Error(); if (2 == lastWin32Error || 123 == lastWin32Error) { return(WaitHandle.OpenExistingResult.NameNotFound); } if (3 == lastWin32Error) { return(WaitHandle.OpenExistingResult.PathNotFound); } if (name != null && name.Length != 0 && 6 == lastWin32Error) { return(WaitHandle.OpenExistingResult.NameInvalid); } __Error.WinIOError(lastWin32Error, ""); } result = new EventWaitHandle(safeWaitHandle); return(WaitHandle.OpenExistingResult.Success); }
public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result) { if (name == null) { throw new ArgumentNullException("name"); } if ((name.Length == 0) || (name.Length > 260)) { throw new ArgumentException("name", Locale.GetText("Invalid length [1-260].")); } MonoIOError error; IntPtr handle = NativeEventCalls.OpenEvent_internal(name, rights, out error); if (handle == (IntPtr)null) { result = null; return(false); } result = new EventWaitHandle(handle); return(true); }
public EventWaitHandleAccessRule(IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type);
public EventWaitHandleAuditRule(IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags);
public EventWaitHandleAccessRule (string identity, EventWaitHandleRights eventRights, AccessControlType type) : this (new SecurityIdentifier (identity), eventRights, type) { }
public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result) { return(OpenExistingWorker(name, rights, out result) == OpenExistingResult.Success); }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if (name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if ((name != null) && (260 < name.Length)) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", new object[] { name })); } SafeWaitHandle handle = Win32Native.OpenEvent((int) rights, false, name); if (handle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if ((2 == errorCode) || (0x7b == errorCode)) { throw new WaitHandleCannotBeOpenedException(); } if (((name != null) && (name.Length != 0)) && (6 == errorCode)) { throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", new object[] { name })); } __Error.WinIOError(errorCode, ""); } return new EventWaitHandle(handle); }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights);
private static OpenExistingResult OpenExistingWorker(string name, EventWaitHandleRights rights, out EventWaitHandle result) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if(name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if(null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); } Contract.EndContractBlock(); result = null; #if FEATURE_MACL SafeWaitHandle myHandle = Win32Native.OpenEvent((int) rights, false, name); #else SafeWaitHandle myHandle = Win32Native.OpenEvent(Win32Native.EVENT_MODIFY_STATE | Win32Native.SYNCHRONIZE, false, name); #endif if (myHandle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if(Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode) return OpenExistingResult.NameNotFound; if (Win32Native.ERROR_PATH_NOT_FOUND == errorCode) return OpenExistingResult.PathNotFound; if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) return OpenExistingResult.NameInvalid; //this is for passed through Win32Native Errors __Error.WinIOError(errorCode,""); } result = new EventWaitHandle(myHandle); return OpenExistingResult.Success; }
public static EventWaitHandle OpenExisting (string name, EventWaitHandleRights rights) { throw new NotSupportedException (); }
public EventWaitHandleAccessRule(System.Security.Principal.IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(InheritanceFlags), default(PropagationFlags), default(AccessControlType)) { }
public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result) { return OpenExistingWorker(name, rights, out result) == OpenExistingResult.Success; }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { throw new NotSupportedException(); }
public EventWaitHandleAuditRule(IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : this(identity, (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, flags) { }
public EventWaitHandleAccessRule(String identity, EventWaitHandleRights eventRights, AccessControlType type) : this(new NTAccount(identity), (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, type) { }
public IAutoResetEvent OpenExisting(string name, EventWaitHandleRights rights) { return new AutoResetEventWrap(AutoResetEvent.OpenExisting(name, rights) as AutoResetEvent); }
public EventWaitHandleAccessRule(string identity, EventWaitHandleRights eventRights, AccessControlType type) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(InheritanceFlags), default(PropagationFlags), default(AccessControlType)) { Contract.Ensures(0 <= identity.Length); Contract.Ensures(identity.Length <= 512); }
public static IntPtr OpenEvent_internal (string name, EventWaitHandleRights rights, out MonoIOError error) { throw new System.NotImplementedException(); }
public EventWaitHandleAccessRule (string identity, EventWaitHandleRights eventRights, AccessControlType type) : this (new NTAccount (identity), eventRights, type) { }
public static bool TryOpenExisting (string name, EventWaitHandleRights rights, out EventWaitHandle result) { throw new NotSupportedException (); }
public static extern IntPtr OpenEvent_internal(string name, EventWaitHandleRights rights, out MonoIOError error);
public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result);
// Constructors public EventWaitHandleAccessRule(System.Security.Principal.IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) { }
/// <summary>Initializes a new instance of the <see cref="T:System.Security.AccessControl.EventWaitHandleAccessRule" /> class, specifying the name of the user or group the rule applies to, the access rights, and whether the specified access rights are allowed or denied.</summary><param name="identity">The name of the user or group the rule applies to.</param><param name="eventRights">A bitwise combination of <see cref="T:System.Security.AccessControl.EventWaitHandleRights" /> values specifying the rights allowed or denied.</param><param name="type">One of the <see cref="T:System.Security.AccessControl.AccessControlType" /> values specifying whether the rights are allowed or denied.</param><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="eventRights" /> specifies an invalid value.-or-<paramref name="type" /> specifies an invalid value.</exception><exception cref="T:System.ArgumentNullException"><paramref name="eventRights" /> is zero.</exception><exception cref="T:System.ArgumentException"><paramref name="identity" /> is null.-or-<paramref name="identity" /> is a zero-length string.-or-<paramref name="identity" /> is longer than 512 characters.</exception> public EventWaitHandleAccessRule(string identity, EventWaitHandleRights eventRights, AccessControlType type) : base(null, 0, false, InheritanceFlags.None, PropagationFlags.None, AccessControlType.Allow) { throw new NotImplementedException(); }
public EventWaitHandleAccessRule(string identity, EventWaitHandleRights eventRights, AccessControlType type) { }
public EventWaitHandleAuditRule(System.Security.Principal.IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) : base (default(System.Security.Principal.IdentityReference), default(int), default(bool), default(InheritanceFlags), default(PropagationFlags), default(AuditFlags)) { }
// Constructors public EventWaitHandleAuditRule(System.Security.Principal.IdentityReference identity, EventWaitHandleRights eventRights, AuditFlags flags) {}
// Constructors public EventWaitHandleAccessRule(System.Security.Principal.IdentityReference identity, EventWaitHandleRights eventRights, AccessControlType type) {}
public static extern IntPtr OpenEvent_internal (string name, EventWaitHandleRights rights, out int errorCode);
public EventWaitHandleAccessRule(string identity, EventWaitHandleRights eventRights, AccessControlType type);
public EventWaitHandleAccessRule(string identity, EventWaitHandleRights eventRights, AccessControlType type) : this(new NTAccount(identity), (int)eventRights, false, InheritanceFlags.None, PropagationFlags.None, type) { }
public static EventWaitHandle OpenExisting (string name, EventWaitHandleRights rights) { if (name == null) { throw new ArgumentNullException ("name"); } if ((name.Length == 0) || (name.Length > 260)) { throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260].")); } MonoIOError error; IntPtr handle = NativeEventCalls.OpenEvent_internal (name, rights, out error); if (handle == (IntPtr)null) { if (error == MonoIOError.ERROR_FILE_NOT_FOUND) { throw new WaitHandleCannotBeOpenedException (Locale.GetText ("Named Event handle does not exist: ") + name); } else if (error == MonoIOError.ERROR_ACCESS_DENIED) { throw new UnauthorizedAccessException (); } else { throw new IOException (Locale.GetText ("Win32 IO error: ") + error.ToString ()); } } return(new EventWaitHandle (handle)); }
public static bool TryOpenExisting (string name, EventWaitHandleRights rights, out EventWaitHandle result) { if (name == null) { throw new ArgumentNullException ("name"); } if ((name.Length == 0) || (name.Length > 260)) { throw new ArgumentException ("name", Locale.GetText ("Invalid length [1-260].")); } MonoIOError error; IntPtr handle = NativeEventCalls.OpenEvent_internal (name, rights, out error); if (handle == (IntPtr)null) { result = null; return false; } result = new EventWaitHandle (handle); return true; }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { EventWaitHandle result; switch (OpenExistingWorker(name, rights, out result)) { case OpenExistingResult.NameNotFound: throw new WaitHandleCannotBeOpenedException(); case OpenExistingResult.NameInvalid: throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle", name)); case OpenExistingResult.PathNotFound: __Error.WinIOError(Win32Native.ERROR_PATH_NOT_FOUND, ""); return result; //never executes default: return result; } }
public static extern IntPtr OpenEvent_internal (string name, EventWaitHandleRights rights, out MonoIOError error);
public static bool TryOpenExisting(string name, EventWaitHandleRights rights, out EventWaitHandle result) { throw new NotSupportedException(); }
public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights) { if (name == null) { throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName")); } if(name.Length == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); } if(null != name && System.IO.Path.MAX_PATH < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); } Contract.EndContractBlock(); #if !FEATURE_PAL && FEATURE_MACL SafeWaitHandle myHandle = Win32Native.OpenEvent((int) rights, false, name); #else SafeWaitHandle myHandle = Win32Native.OpenEvent(Win32Native.EVENT_MODIFY_STATE | Win32Native.SYNCHRONIZE, false, name); #endif if (myHandle.IsInvalid) { int errorCode = Marshal.GetLastWin32Error(); if(Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode) throw new WaitHandleCannotBeOpenedException(); if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name)); //this is for passed through Win32Native Errors __Error.WinIOError(errorCode,""); } return new EventWaitHandle(myHandle); }