private void InitMutex() { string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); string mutexId = string.Format("Global\\{{{0}}}", appGuid); this.mutex = new Mutex(false, mutexId); MutexAccessRule allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); MutexSecurity securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); this.mutex.SetAccessControl(securitySettings); }
private static Mutex CreateMutex(string name) { try { // Open the mutex. return(Mutex.OpenExisting(name)); } catch (WaitHandleCannotBeOpenedException) { // The named mutex does not exist. MutexSecurity mSec = new MutexSecurity(); MutexAccessRule rule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); mSec.AddAccessRule(rule); bool mutexWasCreated; return(new Mutex(false, name, out mutexWasCreated, mSec)); } catch (UnauthorizedAccessException) { // The named mutex exists, but the user does not have the security access required to use it. try { var mutex = Mutex.OpenExisting(name, MutexRights.ReadPermissions | MutexRights.ChangePermissions); // Get the current ACL. This requires MutexRights.ReadPermissions. MutexSecurity mSec = mutex.GetAccessControl(); // Now grant the user the correct rights. MutexAccessRule rule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); mSec.AddAccessRule(rule); // Update the ACL. This requires MutexRights.ChangePermissions. mutex.SetAccessControl(mSec); return(Mutex.OpenExisting(name)); } catch (UnauthorizedAccessException) { return(new Mutex(false, name)); } } }
/// <summary> /// Tries to acquire a mutex with the name <see cref="MutexName"/>. Call this at the end of your constructors. /// </summary> /// <exception cref="TimeoutException">Another process is already holding the mutex.</exception> protected void AcquireMutex() { #if NETFRAMEWORK if (MachineWide) { var mutexSecurity = new MutexSecurity(); mutexSecurity.AddAccessRule(new(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow)); _mutex = new(false, @"Global\" + MutexName, out _, mutexSecurity); } else #endif { _mutex = new(false, MutexName); } _mutex.WaitOne(Handler.CancellationToken, millisecondsTimeout: 2000); }
/// <summary> /// Initializes a new instance of the <see cref="MemoryNaturalKeyRepository"/> class. /// </summary> public MemoryNaturalKeyRepository() { var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule( new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow)); var mutexCreated = false; this.mutex = new Mutex(false, @"Global\MemoryNaturalKeyRepository3Mutex", out mutexCreated, securitySettings); this.file = MemoryMappedFile.CreateOrOpen("MemoryNaturalKeyRepository3", 1 * 1024 * 1024 /* 1MB */); Serializer.RegisterConverters(new[] { new DateTimeConverter() }); }
internal unsafe Mutex(bool initiallyOwned, String name, out bool createdNew, MutexSecurity mutexSecurity) { if (name == string.Empty) { // Empty name is treated as an unnamed mutex. Set to null, and we will check for null from now on. name = null; } #if PLATFORM_WINDOWS if (name != null && System.IO.Path.MaxPath < name.Length) { throw new ArgumentException(SR.Format(SR.Argument_WaitHandleNameTooLong, Path.MaxPath), nameof(name)); } #endif // PLATFORM_WINDOWS Win32Native.SECURITY_ATTRIBUTES secAttrs = null; CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, secAttrs); }
internal void InitMutex() { var appGuid = ((GuidAttribute) Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value; var mutexId = string.Format("Global\\{{{0}}}", appGuid); mutex = new Mutex(false, mutexId); var allowEveryoneRule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); }
public void Mutex_TryOpenExisting() { string name = GetRandomName(); MutexSecurity expectedSecurity = GetMutexSecurity(WellKnownSidType.BuiltinUsersSid, MutexRights.FullControl, AccessControlType.Allow); using Mutex mutexNew = CreateAndVerifyMutex(initiallyOwned: true, name, expectedSecurity, expectedCreatedNew: true); Assert.True(MutexAcl.TryOpenExisting(name, MutexRights.FullControl, out Mutex mutexExisting)); Assert.NotNull(mutexExisting); VerifyHandles(mutexNew, mutexExisting); MutexSecurity actualSecurity = mutexExisting.GetAccessControl(); VerifyMutexSecurity(expectedSecurity, actualSecurity); mutexExisting.Dispose(); }
/// <summary> /// Create a global shared mutex. /// </summary> /// <param name="mutexName">The mutex name.</param> /// <returns>Instance of Mutex.</returns> public static Mutex CreateSharedMutex(string mutexName) { try { MutexSecurity mutexSecurity = new MutexSecurity(); mutexSecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow)); bool createdNew; return(new Mutex(false, mutexName, out createdNew, mutexSecurity)); } catch { return(null); } }
private void InitMutex(string?mutexName) { if (string.IsNullOrEmpty(mutexName)) { mutexName = Assembly.GetExecutingAssembly().GetName().Name ??= nameof(Luna); } Guid uniqueId = new Guid(mutexName); Mutex = new Mutex(false, string.Format("{0}_{1}", mutexName, uniqueId.ToString())); var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); Mutex.SetAccessControl(securitySettings); }
static void Main(string[] args) { string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); string mutexId = string.Format("Global\\{{{0}}}", appGuid); using (var mutex = new Mutex(false, mutexId)) { var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); // edited by acidzombie24 var hasHandle = false; try { try { hasHandle = mutex.WaitOne(2000, false); if (hasHandle == false) { MessageBox.Show("osu!StreamCompanion is already running.", "Error"); return; } } catch (AbandonedMutexException) { hasHandle = true; } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); _initializer = new Initializer(); _initializer.Start(); Application.Run(_initializer); } finally { if (hasHandle) { mutex.ReleaseMutex(); } } } }
/// <summary> /// Initializes a new instance of the InterProcessWaitHandle class /// </summary> /// <param name="name">the name of the underlaying mutex</param> public InterProcessWaitHandle(string name) { var ctl = new MutexSecurity(); var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); ctl.AddAccessRule(allowEveryoneRule); innerMux = MutexAcl.Create(false, name, out bool isNew, ctl); if (!isNew) { LogEnvironment.LogDebugEvent("opened existing mutex...", LogSeverity.Report); //currentlyOwned.Value = false; } else { //currentlyOwned = false; } }
/// <summary> /// Creates a global mutex and allows everyone access to it. /// </summary> /// <param name="name">The name of the mutex to create in the Global namespace.</param> public GlobalMutex(string name) { // Allow full control of the mutex for everyone so that other users will be able to // create the same mutex and synchronise on it, if required. var allowEveryoneRule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); bool createdNew; // Use the Global prefix to make it a system-wide object mutex = new Mutex(false, @"Global\" + name, out createdNew, securitySettings); }
private static Mutex CreateMutex(string name) { if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } // Allow Everyone to signal the mutex from medium or higher integrity levels. MutexSecurity security = new MutexSecurity(); SignalViewModel.SetSecurity(security); // Create the mutex without taking ownership. bool created = false; Mutex mtx = new Mutex(false, name, out created, security); return mtx; }
private void InitializeMutex([NotNull] string serviceName) { string mutexId = string.Format("Global\\{{{0}}}", serviceName); m_Mutex = new Mutex(false, mutexId); var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); m_Mutex.SetAccessControl(securitySettings); }
/// <summary> /// Construct instance of InterProcessMutexLock with given name and acquire lock /// </summary> /// <param name="mutexName">Mutex name. Created if doesn't exist, otherwise attempts to open existing mutex</param> /// <exception cref="ArgumentException">Mutex must be given a name</exception> /// <exception cref="FailedToCreateOrAcquireMutexException">Failed to create or acquire mutex</exception> /// <exception cref="FailedToReaquireMutexException">Thrown when failing to re-acquire an abandoned mutex</exception> public InterProcessMutexLock(string mutexName) { if (string.IsNullOrEmpty(mutexName)) { throw new ArgumentException("Mutex must be given a name", "mutexName"); } try { try { _currentMutex = Mutex.OpenExisting(mutexName); } catch (WaitHandleCannotBeOpenedException) { // grant everyone access to the mutex var security = new MutexSecurity(); var everyoneIdentity = new SecurityIdentifier(WellKnownSidType.WorldSid, null); var rule = new MutexAccessRule(everyoneIdentity, MutexRights.FullControl, AccessControlType.Allow); security.AddAccessRule(rule); // make sure to not initially own it, because if you do it also acquires the lock // we want to explicitly attempt to acquire the lock ourselves so we know how many times // this object acquired and released the lock _currentMutex = new Mutex(false, mutexName, out _created, security); } AquireMutex(); } catch (IOException ex) { throw new FailedToCreateOrAcquireMutexException(string.Format("Failed to create or acquire mutext: {0}", mutexName), ex); } catch (UnauthorizedAccessException ex) { throw new FailedToCreateOrAcquireMutexException(string.Format("Failed to create or acquire mutext: {0}", mutexName), ex); } catch (IdentityNotMappedException ex) { throw new FailedToCreateOrAcquireMutexException(string.Format("Failed to create or acquire mutext: {0}", mutexName), ex); } catch (WaitHandleCannotBeOpenedException ex) { throw new FailedToCreateOrAcquireMutexException(string.Format("Failed to create or acquire mutext: {0}", mutexName), ex); } }
public bool Create() { m_Mutex = new Mutex(false, Log.MutexName, out bool createdNew); if (!createdNew) { return(false); } var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); m_Mutex.SetAccessControl(securitySettings); GC.KeepAlive(m_Mutex); return(true); }
public unsafe Mutex(bool initiallyOwned, String name, out bool createdNew, MutexSecurity mutexSecurity) { if (name == string.Empty) { // Empty name is treated as an unnamed mutex. Set to null, and we will check for null from now on. name = null; } #if !PLATFORM_UNIX if (name != null && System.IO.Path.MaxPath < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", Path.MaxPath), nameof(name)); } #endif Contract.EndContractBlock(); Win32Native.SECURITY_ATTRIBUTES secAttrs = null; CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, secAttrs); }
public unsafe Mutex(bool initiallyOwned, String name, out bool createdNew, MutexSecurity mutexSecurity) { if (name == string.Empty) { // Empty name is treated as an unnamed mutex. Set to null, and we will check for null from now on. name = null; } #if !PLATFORM_UNIX if (name != null && System.IO.Path.MaxPath < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", Path.MaxPath), nameof(name)); } #endif Contract.EndContractBlock(); Win32Native.SECURITY_ATTRIBUTES secAttrs = null; CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, secAttrs); }
private static void Main() { bool createdNew; var mutexSecurity = new MutexSecurity(); mutexSecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow)); using (var setupMutex = new Mutex(false, @"Global\JosipMedved_DmmLog", out createdNew, mutexSecurity)) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Medo.Application.UnhandledCatch.ThreadException += new EventHandler <ThreadExceptionEventArgs>(UnhandledCatch_ThreadException); Medo.Application.UnhandledCatch.Attach(); Drivers.Initialize(); Application.Run(new MainForm()); } }
public unsafe Mutex(bool initiallyOwned, string name, out bool createdNew, MutexSecurity mutexSecurity) { if (name != null && 260 < name.Length) { throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong", (object)name)); } Win32Native.SECURITY_ATTRIBUTES securityAttributes = (Win32Native.SECURITY_ATTRIBUTES)null; if (mutexSecurity != null) { securityAttributes = new Win32Native.SECURITY_ATTRIBUTES(); securityAttributes.nLength = Marshal.SizeOf <Win32Native.SECURITY_ATTRIBUTES>(securityAttributes); byte[] descriptorBinaryForm = mutexSecurity.GetSecurityDescriptorBinaryForm(); byte * pDest = stackalloc byte[descriptorBinaryForm.Length]; Buffer.Memcpy(pDest, 0, descriptorBinaryForm, 0, descriptorBinaryForm.Length); securityAttributes.pSecurityDescriptor = pDest; } this.CreateMutexWithGuaranteedCleanup(initiallyOwned, name, out createdNew, securityAttributes); }
static void Main() { MutexAccessRule allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); MutexSecurity securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); using (Mutex mutex = new Mutex(false, string.Format("Global\\{{{0}}}", "Synchrocade Updater"))) { ThreadingAclExtensions.SetAccessControl(mutex, securitySettings); bool hasHandle = false; try { try { hasHandle = mutex.WaitOne(TimeSpan.Zero, false); if (!hasHandle) { MessageBox.Show(MainWindowResources.ALREADY_RUNNING, MainWindowResources.ALREADY_RUNNING_ERROR, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return; } } catch (AbandonedMutexException) { hasHandle = true; } Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new PatcherMainWindow()); } catch (Exception ex) { Handler handler = new Handler(new WinformsErrorDisplay()); handler.Handle(ex); } finally { if (hasHandle) { mutex.ReleaseMutex(); } } } }
/// <summary> /// bassed on http://stackoverflow.com/questions/229565/what-is-a-good-pattern-for-using-a-global-mutex-in-c/229567 /// </summary> /// <returns></returns> public bool CheckInstance() { // get application GUID as defined in AssemblyInfo.cs string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly(). GetCustomAttributes(typeof(GuidAttribute), false). GetValue(0)).Value.ToString(); // unique id for global mutex - Global prefix means it is global to the machine string mutexId = string.Format("Global\\{{{0}}}", appGuid); // Need a place to store a return value in Mutex() constructor call bool createdNew; // edited by Jeremy Wiebe to add example of setting up security for multi-user usage // edited by 'Marc' to work also on localized systems (don't use just "Everyone") var allowEveryoneRule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex = new Mutex(false, mutexId, out createdNew, securitySettings); try { // note, you may want to time out here instead of waiting forever // edited by acidzombie24 // mutex.WaitOne(Timeout.Infinite, false); hasMutexHandle = mutex.WaitOne(TimeSpan.Zero, false); //if (hasMutexHandle == false) // throw new TimeoutException("Timeout waiting for exclusive access"); } catch (AbandonedMutexException) { // Log the fact that the mutex was abandoned in another process, // it will still get acquired hasMutexHandle = true; } return(hasMutexHandle); }
static void Main(string[] args) { // Get the application GUID defined in AssemblyInfo.cs string guid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); // id for global mutex (global to machine) string mutexId = string.Format("Global\\{{{0}}}", guid); MutexAccessRule allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); MutexSecurity securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); using (Mutex mutex = new Mutex(false, mutexId, out _, securitySettings)) { bool hasHandle = false; try { try { hasHandle = mutex.WaitOne(250, false); // Timeout after 250ms. if (!hasHandle) // Application is already running. // MessageBox.Show("The application is already running.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); { SendMessage("bringtofront"); Environment.Exit(0); return; } } catch (AbandonedMutexException) { hasHandle = true; // The mutex was abandoned in another process, it will still get acquired. } // Start application normally. Application.Run(new FormMain()); } finally { if (hasHandle) { mutex.ReleaseMutex(); } } } }
public static bool Create(string procMtxName, string title) { try { MutexSecurity security = new MutexSecurity(); security.AddAccessRule( new MutexAccessRule( new SecurityIdentifier( WellKnownSidType.WorldSid, null ), MutexRights.FullControl, AccessControlType.Allow ) ); bool createdNew; ProcMtx = new Mutex(false, @"Global\Global_" + procMtxName, out createdNew, security); if (ProcMtx.WaitOne(0)) { return(true); } ProcMtx.Close(); ProcMtx = null; } catch (Exception e) { MessageBox.Show("" + e, title + " / Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } CloseProcMtx(); MessageBox.Show( "Already started on the other logon session !", title + " / Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); return(false); }
public static Mutex Create(string Name, out bool mutexWasCreated) { //Always use global scop string name = @"Global\" + Name; MutexSecurity sec = new MutexSecurity(); MutexAccessRule secRule = new MutexAccessRule( new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); sec.AddAccessRule(secRule); bool mutexWasCreatedOut; Mutex m = new Mutex(false, name, out mutexWasCreatedOut, sec); mutexWasCreated = mutexWasCreatedOut; return(m); }
public DXHookD3D9SharedMem(CaptureInterface ssInterface) : base(ssInterface) { var security = new MutexSecurity(); security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow)); bool created; sharedMemMutexes = new[] { new Mutex(false, "Global\\DXHookD3D9Shared0", out created, security), new Mutex(false, "Global\\DXHookD3D9Shared1", out created, security) }; var ewsecurity = new EventWaitHandleSecurity(); ewsecurity.AddAccessRule(new EventWaitHandleAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), EventWaitHandleRights.FullControl, AccessControlType.Allow)); captureWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, "Global\\DXHookD3D9Capture", out created, ewsecurity); hookReadyWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, "Global\\DXHookD3D9CaptureReady", out created, ewsecurity); }
private void InitMutex(string _CustomID) { #if MUTEX_ENABLED //( (GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes( typeof( GuidAttribute ), false ).GetValue( 0 ) ).Value; string appGuid = HEVIO.AssemblyGuidCurrent(); string mutexId = string.Format("Global\\{{{0}}}", appGuid); if (HEVText.Validate(_CustomID)) { mutexId = _CustomID; } mutex = new Mutex(false, mutexId); var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); #endif }
/// <summary> /// Creates a mutex that is sharable by more than one process. /// </summary> /// <param name="mutexNamePrefix">The prefix to use for the name of the mutex.</param> /// <returns>A <see cref="Mutex"/> object which is sharable by multiple processes.</returns> protected Mutex CreateSharableMutex(string mutexNamePrefix) { if (!PlatformDetector.SupportsSharableMutex) { return(new Mutex()); } // Creates a mutex sharable by more than one process var mutexSecurity = new MutexSecurity(); var everyoneSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null); mutexSecurity.AddAccessRule(new MutexAccessRule(everyoneSid, MutexRights.FullControl, AccessControlType.Allow)); // The constructor will either create new mutex or open // an existing one, in a thread-safe manner bool createdNew; return(new Mutex(false, GetMutexName(mutexNamePrefix), out createdNew, mutexSecurity)); }
public static void Main() { // Create a string representing the current user. string user = Environment.UserDomainName + "\\" + Environment.UserName; // Create a security object that grants no access. MutexSecurity mSec = new MutexSecurity(); // Add a rule that grants the current user the // right to enter or release the mutex and read the // permissions on the mutex. MutexAccessRule rule = new MutexAccessRule(user, MutexRights.Synchronize | MutexRights.Modify | MutexRights.ReadPermissions, AccessControlType.Allow); mSec.AddAccessRule(rule); // Add a rule that denies the current user the // right to change permissions on the mutex. rule = new MutexAccessRule(user, MutexRights.ChangePermissions, AccessControlType.Deny); mSec.AddAccessRule(rule); // Display the rules in the security object. ShowSecurity(mSec); // Create a rule that grants the current user // the right to read permissions on the mutex, and // take ownership of the mutex. Use this rule to // remove the right to read permissions from the // Allow rule for the current user. The inclusion // of the right to take ownership has no effect. rule = new MutexAccessRule(user, MutexRights.TakeOwnership | MutexRights.ReadPermissions, AccessControlType.Allow); mSec.RemoveAccessRule(rule); ShowSecurity(mSec); }
private void InitMutex() { string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); string mutexId = string.Format("Global\\{{{0}}}", appGuid); mutex = new Mutex(false, mutexId); try { var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); } catch (PlatformNotSupportedException) { System.Diagnostics.Trace.WriteLine("Unable to set mutex security"); } }
/// <summary> /// /// </summary> public static ApplicationRunning getUserTypeRurnningthisApplication() { string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString(); // unique id for global mutex - Global prefix means it is global to the machine string mutexId = string.Format("Global\\{{{0}}}", appGuid); bool createdNew; // edited by Jeremy Wiebe to add example of setting up security for multi-user usage // edited by 'Marc' to work also on localized systems (don't use just "Everyone") var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); createdNew = true; try { Mutex mutex = new Mutex(true, mutexId, out createdNew, securitySettings); } catch (Exception e) { createdNew = false; } if (!createdNew) { //long sameUserRunning = 0; long wdwIntPtr = ApplicationInstanceChecker.getSameNameProcess(true); if (wdwIntPtr > 0) { ApplicationInstanceChecker.activateProcessMainWindow((long)wdwIntPtr); // TODO .. //MessageBox.Show("Same user running..."); return(ApplicationRunning.SameUserRunning); } // TODO .. //MessageBox.Show("Diff user running..."); return(ApplicationRunning.DifferentUserRunning); } return(ApplicationRunning.NoUserRunning); }
public SingletonAppGuard(Assembly assembly, int timeout) { try { assembly ??= Assembly.GetCallingAssembly(); AppInfo appInfo = new AppInfo(assembly); // Global prefix means it is global to the machine. string mutexId = $"Global\\{appInfo.AppGuid}"; _mutex = new Mutex(false, mutexId); SecurityIdentifier worldSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null); MutexAccessRule allowAll = new MutexAccessRule(worldSid, MutexRights.FullControl, AccessControlType.Allow); MutexSecurity mutexSecurity = new MutexSecurity(); mutexSecurity.AddAccessRule(allowAll); _mutex.SetAccessControl(mutexSecurity); _hasHandle = timeout < 0 ? _mutex.WaitOne(TimeSpanHelper.INFINITE, false) : _mutex.WaitOne(timeout, false); if (!_hasHandle) { throw new TimeoutException(); } } catch (AbandonedMutexException) { _hasHandle = true; } catch { if (_mutex != null) { if (_hasHandle) { _mutex.ReleaseMutex(); } _mutex.Close(); ObjectHelper.Dispose(ref _mutex); } throw; } }
// Mutex code from http://stackoverflow.com/questions/229565/what-is-a-good-pattern-for-using-a-global-mutex-in-c public static void PreloadUnmanagedLibraries(string hash, string tempBasePath, IEnumerable<string> libs, Dictionary<string, string> checksums) { var mutexId = string.Format("Global\\Costura{0}", hash); using (var mutex = new Mutex(false, mutexId)) { var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow); var securitySettings = new MutexSecurity(); securitySettings.AddAccessRule(allowEveryoneRule); mutex.SetAccessControl(securitySettings); var hasHandle = false; try { try { hasHandle = mutex.WaitOne(60000, false); if (hasHandle == false) throw new TimeoutException("Timeout waiting for exclusive access"); } catch (AbandonedMutexException) { hasHandle = true; } var bittyness = IntPtr.Size == 8 ? "64" : "32"; CreateDirectory(Path.Combine(tempBasePath, bittyness)); InternalPreloadUnmanagedLibraries(tempBasePath, libs, checksums); } finally { if (hasHandle) mutex.ReleaseMutex(); } } }
public static void SetAccessControl(this Mutex mutex, MutexSecurity mutexSecurity);
static void ThreadFunc() { bool bCreated = false; var user = "******"; var rule = new MutexAccessRule(user, MutexRights.FullControl, AccessControlType.Allow ); var mSecurity = new MutexSecurity(); mSecurity.AddAccessRule(rule); Mutex m = new Mutex(true, Program.mutex_name, out bCreated, mSecurity); if (!bCreated) { Console.WriteLine("Waiting... {0}", Thread.CurrentThread.ManagedThreadId); m.WaitOne(); Console.WriteLine("Acquired Mutex! {0}", Thread.CurrentThread.ManagedThreadId); } System.Threading.Thread.Sleep(5 * 1000); m.ReleaseMutex(); m.Close(); }