|
public AddAccessRule ( |
||
| rule | ||
| return | void | |
public static Mutex GrabMutex(string name)
{
var mutexName = "kalixLuceneSegmentMutex_" + name;
try
{
return Mutex.OpenExisting(mutexName);
}
catch (WaitHandleCannotBeOpenedException)
{
var worldSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var security = new MutexSecurity();
var rule = new MutexAccessRule(worldSid, MutexRights.FullControl, AccessControlType.Allow);
security.AddAccessRule(rule);
var mutexIsNew = false;
return new Mutex(false, mutexName, out mutexIsNew, security);
}
catch (UnauthorizedAccessException)
{
var m = Mutex.OpenExisting(mutexName, MutexRights.ReadPermissions | MutexRights.ChangePermissions);
var security = m.GetAccessControl();
var user = Environment.UserDomainName + "\\" + Environment.UserName;
var rule = new MutexAccessRule(user, MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow);
security.AddAccessRule(rule);
m.SetAccessControl(security);
return Mutex.OpenExisting(mutexName);
}
}
public static bool ObtainMutex(string settingsFolder)
{
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
MutexSecurity security = new MutexSecurity();
bool useDefaultSecurity = false;
bool createdNew;
try {
security.AddAccessRule(new MutexAccessRule(sid, MutexRights.FullControl, AccessControlType.Allow));
security.AddAccessRule(new MutexAccessRule(sid, MutexRights.ChangePermissions, AccessControlType.Deny));
security.AddAccessRule(new MutexAccessRule(sid, MutexRights.Delete, AccessControlType.Deny));
}
catch (Exception ex) {
if (ex is ArgumentOutOfRangeException || ex is NotImplementedException) {
// Workaround for Mono
useDefaultSecurity = true;
}
else {
throw;
}
}
string name = @"Global\ChanThreadWatch_" + General.Calculate64BitMD5(Encoding.UTF8.GetBytes(
settingsFolder.ToUpperInvariant())).ToString("X16");
Mutex mutex = !useDefaultSecurity ?
new Mutex(false, name, out createdNew, security) :
new Mutex(false, name);
try {
if (!mutex.WaitOne(0, false)) {
return false;
}
}
catch (AbandonedMutexException) { }
ReleaseMutex();
_mutex = mutex;
return true;
}
private static MutexSecurity CreateFullAccessMutexSecurity ()
{
// full permissions for all authorized users
var mutexSecurity = new MutexSecurity();
mutexSecurity.AddAccessRule(new MutexAccessRule(
WellKnownSidType.CreatorOwnerSid.ToIdentifier(), MutexRights.FullControl, AccessControlType.Allow));
mutexSecurity.AddAccessRule(new MutexAccessRule(
WellKnownSidType.AuthenticatedUserSid.ToIdentifier(), MutexRights.FullControl, AccessControlType.Allow));
return mutexSecurity;
}
// Note: configuration based on stackoverflow answer: http://stackoverflow.com/questions/229565/what-is-a-good-pattern-for-using-a-global-mutex-in-c
public BankAccountMutex(double money)
{
// 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;
// set up security for multi-user usage
// 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);
LogConsole("Setting initial amount of money: " + money);
if (money < 0)
{
LogConsole("The entered money quantity cannot be negative. Money: " + money);
throw new ArgumentException(GetMessageWithTreadId("The entered money quantity cannot be negative. Money: " + money));
}
this.bankMoney = money;
}
/// <summary>
/// Tries to aquire a mutex with the name <see cref="MutexName"/>. Call this at the end of your constructors.
/// </summary>
/// <exception cref="UnauthorizedAccessException">Another process is already holding the mutex.</exception>
protected void AquireMutex()
{
if (MachineWide)
{
var mutexSecurity = new MutexSecurity();
mutexSecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow));
bool createdNew;
_mutex = new Mutex(false, @"Global\" + MutexName, out createdNew, mutexSecurity);
}
_mutex = new Mutex(false, MutexName);
try
{
switch (WaitHandle.WaitAny(new[] {_mutex, Handler.CancellationToken.WaitHandle},
millisecondsTimeout: (Handler.Verbosity == Verbosity.Batch) ? 30000 : 1000, exitContext: false))
{
case 0:
return;
case 1:
throw new OperationCanceledException();
default:
case WaitHandle.WaitTimeout:
throw new UnauthorizedAccessException("Another process is already holding the mutex " + MutexName + ".");
}
}
catch (AbandonedMutexException ex)
{
// Abandoned mutexes also get owned, but indicate something may have gone wrong elsewhere
Log.Warn(ex.Message);
}
}
public UIMutex(string mutexName)
{
pGlobalMutexName = mutexName;
// Create a string representing the current user.
string userName = Environment.UserDomainName + "\\" + Environment.UserName;
// Create a security object that grants no access.
MutexSecurity mutexSecurity = new MutexSecurity();
// Add a rule that grants the current user the right
// to enter or release the mutex.
MutexAccessRule mutexAccessRule = new MutexAccessRule(userName, MutexRights.FullControl, AccessControlType.Allow);
mutexSecurity.AddAccessRule(mutexAccessRule);
bool createdNew = false;
pMutex = new Mutex(false, pGlobalMutexName, out createdNew, mutexSecurity);
if (createdNew)
{
// loggingSystem.LogVerbose("New Mutex created {0}", pGlobalMutexName);
}
else
{
//loggingSystem.LogVerbose("Existing Mutex opened {0}", globalMutextName);
}
}
protected override void OnStartup(StartupEventArgs e)
{
// store mutex result
bool createdNew;
// allow multiple users to run it, but only one per user
var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow);
var securitySettings = new MutexSecurity();
securitySettings.AddAccessRule(allowEveryoneRule);
// create mutex
_instanceMutex = new Mutex(true, @"Global\MercurialForge_Mastery", out createdNew, securitySettings);
// check if conflict
if (!createdNew)
{
MessageBox.Show("Instance of Mastery is already running");
_instanceMutex = null;
Application.Current.Shutdown();
return;
}
base.OnStartup(e);
MainWindow window = new MainWindow();
MainWindowViewModel viewModel = new MainWindowViewModel(window);
window.DataContext = viewModel;
window.Show();
}
public InterProcessMutexLock(String mutexName)
{
try
{
_mutexName = mutexName;
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(Exception ex)
{
var exceptionString = String.Format("Exception in InterProcessMutexLock, mutex name {0}", mutexName);
Log.Error(this, exceptionString, ex);
throw ExceptionUtil.Rethrow(ex, exceptionString);
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(true);
string title = "KeyMagic";
bool beta = Properties.Settings.Default.BetaRelease;
if (beta) title += " (beta)";
string mutexName = "\u1000\u1001";
// http://stackoverflow.com/questions/229565/what-is-a-good-pattern-for-using-a-global-mutex-in-c/229567
using (var mutex = new Mutex(false, mutexName))
{
// 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.SetAccessControl(securitySettings);
//edited by acidzombie24
var hasHandle = false;
try
{
try
{
// note, you may want to time out here instead of waiting forever
//edited by acidzombie24
//mutex.WaitOne(Timeout.Infinite, false);
hasHandle = mutex.WaitOne(100, false);
if (hasHandle == false) //another instance exist
{
IntPtr pWnd = NativeMethods.FindWindow(null, title);
if (pWnd != IntPtr.Zero)
{
NativeMethods.ShowWindow(pWnd, 0x05);
}
return;
}
}
catch (AbandonedMutexException)
{
// Log the fact the mutex was abandoned in another process, it will still get aquired
}
frmMain f = new frmMain();
Application.Run();
}
finally
{
//edit by acidzombie24, added if statemnet
if (hasHandle)
mutex.ReleaseMutex();
}
}
}
public static Mutex CreateMutexWithFullControlRights(String name, out Boolean createdNew)
{
SecurityIdentifier securityIdentifier = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
MutexSecurity mutexSecurity = new MutexSecurity();
MutexAccessRule rule = new MutexAccessRule(securityIdentifier, MutexRights.FullControl, AccessControlType.Allow);
mutexSecurity.AddAccessRule(rule);
return new Mutex(false, name, out createdNew, mutexSecurity);
}
public InterProcessLock(string name, TimeSpan timeout)
{
bool created;
var security = new MutexSecurity();
security.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
this.Mutex = new Mutex(false, name, out created, security);
this.IsAcquired = this.Mutex.WaitOne(timeout);
}
/// <summary>
/// Create the mutex instance used to singal that one or more listeners are active.
/// </summary>
/// <param name="mutexName">The shared mutex name.</param>
protected static Mutex CreateMutex(String mutexName)
{
var securitySettings = new MutexSecurity();
var createdNew = false;
securitySettings.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow));
return new Mutex(false, mutexName, out createdNew, securitySettings);
}
internal static void EnterMutexWithoutGlobal(string mutexName, ref Mutex mutex)
{
bool flag;
MutexSecurity mutexSecurity = new MutexSecurity();
SecurityIdentifier identity = new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null);
mutexSecurity.AddAccessRule(new MutexAccessRule(identity, MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
Mutex mutexIn = new Mutex(false, mutexName, out flag, mutexSecurity);
SafeWaitForMutex(mutexIn, ref mutex);
}
// Methods
public MutexHelper(string mutexName)
{
bool flag;
this.pGlobalMutexName = mutexName;
string identity = Environment.UserDomainName + @"\" + Environment.UserName;
MutexSecurity mutexSecurity = new MutexSecurity();
MutexAccessRule rule = new MutexAccessRule(identity, MutexRights.FullControl, AccessControlType.Allow);
mutexSecurity.AddAccessRule(rule);
this.pMutex = new Mutex(false, this.pGlobalMutexName, out flag, mutexSecurity);
}
public static MutexSecurity MutexSecurity()
{
SecurityIdentifier user = GetEveryoneSID();
MutexSecurity result = new MutexSecurity();
MutexAccessRule rule = new MutexAccessRule(user, MutexRights.Synchronize | MutexRights.Modify | MutexRights.Delete, AccessControlType.Allow);
result.AddAccessRule(rule);
return result;
}
private void InitMutex(Guid appGuid)
{
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);
}
private 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);
}
private static Mutex CreateSharableMutex(string name)
{
// Creates a mutex sharable by more than one process
var mutexSecurity = new MutexSecurity();
mutexSecurity.AddAccessRule(new MutexAccessRule("Everyone", 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, name, out createdNew, mutexSecurity);
}
private void InitWaitHandle() {
string mutexId = String.Format("Global\\{{{0}}}", _key);
try {
var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow);
var securitySettings = new MutexSecurity();
securitySettings.AddAccessRule(allowEveryoneRule);
bool wasCreated = false;
_waitHandle = new Mutex(false, mutexId, out wasCreated, securitySettings);
} catch (Exception) {
// We fallback to AutoResetEvent because Mutex isn't supported in medium trust.
_waitHandle = _namedLocks.GetOrAdd(_key, key => new AutoResetEvent(true));
}
}
/// <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);
}
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_HamCheck", out createdNew, mutexSecurity)) {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo(Medo.Configuration.Settings.Read("CultureName", "en-US"));
Medo.Application.UnhandledCatch.ThreadException += new EventHandler<ThreadExceptionEventArgs>(UnhandledCatch_ThreadException);
Medo.Application.UnhandledCatch.Attach();
Medo.Configuration.Settings.NoRegistryWrites = Settings.NoRegistryWrites;
Medo.Windows.Forms.State.NoRegistryWrites = Settings.NoRegistryWrites;
Medo.Diagnostics.ErrorReport.DisableAutomaticSaveToTemp = Settings.NoRegistryWrites;
if (!((Environment.OSVersion.Version.Build < 7000) || (App.IsRunningOnMono))) {
var appId = Assembly.GetExecutingAssembly().Location;
if (appId.Length > 127) { appId = @"JosipMedved_HamCheck\" + appId.Substring(appId.Length - 127 - 20); }
NativeMethods.SetCurrentProcessExplicitAppUserModelID(appId);
}
var mainForm = new MainForm();
//single instance
Medo.Application.SingleInstance.NewInstanceDetected += delegate (object sender, Medo.Application.NewInstanceEventArgs e) {
mainForm.Show();
mainForm.Activate();
};
if (Medo.Application.SingleInstance.IsOtherInstanceRunning) {
var currProcess = Process.GetCurrentProcess();
foreach (var iProcess in Process.GetProcessesByName(currProcess.ProcessName)) {
try {
if (iProcess.Id != currProcess.Id) {
NativeMethods.AllowSetForegroundWindow(iProcess.Id);
break;
}
} catch (Win32Exception) { }
}
}
Medo.Application.SingleInstance.Attach();
Application.Run(mainForm);
}
}
public static bool TryGetMutex()
{
//source: http://stackoverflow.com/questions/229565/what-is-a-good-pattern-for-using-a-global-mutex-in-c
// get application GUID as defined in AssemblyInfo.cs
//string appGuid = "SjUpdater\\v" +Assembly.GetExecutingAssembly().GetName().Version.Major;
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);
mutex = new Mutex(false, mutexId);
// 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.SetAccessControl(securitySettings);
// edited by acidzombie24
try
{
try
{
// note, you may want to time out here instead of waiting forever
// edited by acidzombie24
// mutex.WaitOne(Timeout.Infinite, false);
hasHandle = mutex.WaitOne(5000, false);
if (hasHandle == false)
throw new TimeoutException("Timeout waiting for exclusive access");
}
catch (AbandonedMutexException)
{
// Log the fact the mutex was abandoned in another process, it will still get aquired
hasHandle = true;
}
return true;
}
catch
{
return false;
}
}
public static void RunSingleProcessOnly(bool silent = false)
{
string app_name = ProgramRoutines.GetAppName();
bool createdNew;
MutexSecurity mutexSecurity = new System.Security.AccessControl.MutexSecurity();
mutexSecurity.AddAccessRule(new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow));
for (int i = 0; i < 2; i++)
{
try
{
GLOBAL_SINGLE_PROCESS_MUTEX = new Mutex(false, @"Global\CLIVERSOFT_" + app_name + @"_SINGLE_PROCESS", out createdNew, mutexSecurity);
break;
}
catch (Exception e)
{//An “access denied” while creating a new Mutex can happen in the following situation:
//a.Process A running as an administrator creates a named mutex.
//b.Process B running as a normal user attempts to access the mutex which fails with “access denied” since only Administrators can access the mutex.
if (i == 0)
{
Thread.Sleep(1000);//wait for some time while contending, if the other instance of the program is still in progress of shutting down.
continue;
}
if (!silent)
{
LogMessage.Exit(e);
}
else
{
Environment.Exit(0);
}
}
}
if (GLOBAL_SINGLE_PROCESS_MUTEX.WaitOne(1000, false))//wait for some time while contending, if the other instance of the program is still in progress of shutting down.
{
return;
}
if (!silent)
{
LogMessage.Exit2(app_name + " is already running, so this instance will exit.");
}
else
{
Environment.Exit(0);
}
}
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();
}
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Initialize variables for mutex.
string MutexId = string.Format("Global\\{{{0}}}", Guid);
bool CreatedNewMutex;
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, MutexId, out CreatedNewMutex, SecuritySettings))
{
bool HandleAcquired = false;
try
{
try
{
HandleAcquired = Mutex.WaitOne(2000, false);
if (!HandleAcquired)
{
MessageBox.Show("There is an instance of " + Name + " already currently running.", Name + " already open.", MessageBoxButtons.OK, MessageBoxIcon.Information);
Close();
}
}
catch (AbandonedMutexException)
{
// The mutex was abandoned in another process, so in this case it will still get acquired.
HandleAcquired = true;
}
// Begin program.
Application.Run(new MainForm());
// End program.
}
finally
{
// Release the mutex if it was acquired.
if (HandleAcquired)
Mutex.ReleaseMutex();
}
}
}
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 ManagedFileLock(string name)
{
_name = name;
var mutexName = String.Format(@"Global\{0}", name);
if (!FileExtensions.TryOpenExistingMutex(mutexName, out _mutex));
{
bool isNew = true;
MutexSecurity mSec = new MutexSecurity();
SecurityIdentifier sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
MutexAccessRule rule = new MutexAccessRule(sid, MutexRights.FullControl, AccessControlType.Allow);
mSec.AddAccessRule(rule);
_mutex = new Mutex(false, mutexName, out isNew, mSec);
}
if (!_mutex.WaitOne(10000))
throw new InvalidOperationException(string.Format("File Locked {0}", _name));
}
private SingleInstanceApp()
{
_id = "SIA_" + GetAppId();
//string identity = "Everyone";
string identity = Environment.UserDomainName + "\\" + Environment.UserName;
MutexAccessRule rule = new MutexAccessRule(identity, MutexRights.FullControl, AccessControlType.Allow);
MutexSecurity security = new MutexSecurity();
try
{
security.AddAccessRule(rule);
_instanceCounter = new Mutex(false, _id, out _firstInstance, security);
}
catch
{
_firstInstance = true;
}
}
public static Mutex GrabMutex(string name)
{
var mutexName = "luceneSegmentMutex_" + name;
Mutex mutex;
var notExisting = false;
if (Mutex.TryOpenExisting(mutexName, MutexRights.Synchronize | MutexRights.Modify, out mutex))
{
return mutex;
}
// Here we know the mutex either doesn't exist or we don't have the necessary permissions.
if (!Mutex.TryOpenExisting(mutexName, MutexRights.ReadPermissions | MutexRights.ChangePermissions, out mutex))
{
notExisting = true;
}
if (notExisting)
{
var worldSid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
var security = new MutexSecurity();
var rule = new MutexAccessRule(worldSid, MutexRights.FullControl, AccessControlType.Allow);
security.AddAccessRule(rule);
var mutexIsNew = false;
return new Mutex(false, mutexName, out mutexIsNew, security);
}
else
{
var m = Mutex.OpenExisting(mutexName, MutexRights.ReadPermissions | MutexRights.ChangePermissions);
var security = m.GetAccessControl();
var user = Environment.UserDomainName + "\\" + Environment.UserName;
var rule = new MutexAccessRule(user, MutexRights.Synchronize | MutexRights.Modify, AccessControlType.Allow);
security.AddAccessRule(rule);
m.SetAccessControl(security);
return Mutex.OpenExisting(mutexName);
}
}
public void CreateMutex(int timeOut = 100)
{
// Получаем GUID и формируем имя мутекса
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);
// Установка прав доступа к нему
var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow);
var securitySettings = new MutexSecurity();
securitySettings.AddAccessRule(allowEveryoneRule);
mutex.SetAccessControl(securitySettings);
try {
// Попытка получить эксклюзивный доступ к мутексу с таким именем (если не получится, значит нас опередили)
Success = mutex.WaitOne(timeOut, false);
} catch (AbandonedMutexException) {
// "Брошенный" мутекс (видимо завершили задачу в "Диспетчер задач")
Success = true;
}
}
protected GatewayBase(string mutexName, Guid uniqueIdentifier, int timeout, string customError, bool doNotAutoEnter)
{
if (string.IsNullOrWhiteSpace(mutexName)) throw new ArgumentException("mutexName cannot be empty");
if (uniqueIdentifier == Guid.Empty) throw new ArgumentException("uniqueIdentifier cannot be empty");
MutexName = mutexName;
UniqueIdentifier = uniqueIdentifier.ToString().ToUpperInvariant();
UniqueId = MutexName + UniqueIdentifier;
mutexId = string.Format("Global\\{{{0}}}", UniqueId);
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);
if (!doNotAutoEnter)
{
Enter(timeout, customError);
}
}