AddAccessRule() public method

public AddAccessRule ( MutexAccessRule rule ) : void
rule MutexAccessRule
return void
示例#1
0
        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);
            }
        }
示例#2
0
 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;
 }
示例#3
0
 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;
 }
示例#4
0
        // 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;
        }
示例#5
0
        /// <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);
            }
        }
示例#6
0
        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);
            }

        }
示例#7
0
        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);
            }
        }
示例#9
0
        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);
 }
示例#12
0
        /// <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);
 }
示例#14
0
 // 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);
 }
示例#15
0
        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);
        }
示例#17
0
        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);
        }
示例#18
0
        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));
            }
        }
示例#20
0
        /// <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);
        }
示例#21
0
文件: App.cs 项目: medo64/HamCheck
        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);
            }
        }
示例#22
0
        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);
            }
        }
示例#24
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();
                }
            }
        }
示例#25
0
文件: Program.cs 项目: MoeChezzy/TBID
        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();
                }
            }
        }
示例#26
0
        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;
        }
示例#27
0
        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);
            }
        }
示例#30
0
        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;
            }
        }
示例#31
0
        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);
            }
        }