1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Diagnostics;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
namespace System.Threading
{
public sealed partial class Mutex
{
private const uint AccessRights = (uint)(Interop.Constants.MaximumAllowed | Interop.Constants.Synchronize | Interop.Constants.MutexModifyState);
private static void VerifyNameForCreate(string name)
{
if (null != name && Interop.Kernel32.MAX_PATH < name.Length)
{
throw new ArgumentException(SR.Format(SR.Argument_WaitHandleNameTooLong, Interop.Kernel32.MAX_PATH), nameof(name));
}
}
private void CreateMutexCore(bool initiallyOwned, string name, out bool createdNew)
{
Debug.Assert(name == null || name.Length <= Interop.Kernel32.MAX_PATH);
uint mutexFlags = initiallyOwned ? (uint)Interop.Constants.CreateMutexInitialOwner : 0;
SafeWaitHandle mutexHandle = Interop.mincore.CreateMutexEx(IntPtr.Zero, name, mutexFlags, AccessRights);
int errorCode = Marshal.GetLastWin32Error();
if (mutexHandle.IsInvalid)
{
mutexHandle.SetHandleAsInvalid();
if (null != name && 0 != name.Length && Interop.Errors.ERROR_INVALID_HANDLE == errorCode)
throw new WaitHandleCannotBeOpenedException(SR.Format(SR.Threading_WaitHandleCannotBeOpenedException_InvalidHandle, name));
throw ExceptionFromCreationError(errorCode, name);
}
createdNew = errorCode != Interop.Errors.ERROR_ALREADY_EXISTS;
SafeWaitHandle = mutexHandle;
}
private static OpenExistingResult OpenExistingWorker(string name, out Mutex result)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name), SR.ArgumentNull_WithParamName);
}
if (name.Length == 0)
{
throw new ArgumentException(SR.Argument_EmptyName, nameof(name));
}
if (Interop.Kernel32.MAX_PATH < (uint)name.Length)
{
throw new ArgumentException(SR.Format(SR.Argument_WaitHandleNameTooLong, Interop.Kernel32.MAX_PATH), nameof(name));
}
result = null;
SafeWaitHandle myHandle = Interop.mincore.OpenMutex(AccessRights, false, name);
int errorCode = 0;
if (myHandle.IsInvalid)
{
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;
throw ExceptionFromCreationError(errorCode, name);
}
result = new Mutex(myHandle);
return OpenExistingResult.Success;
}
private static void ReleaseMutexCore(IntPtr handle)
{
if (!Interop.mincore.ReleaseMutex(handle))
{
ThrowSignalOrUnsignalException();
}
}
}
}
|
