public static long GetHResult(Win32Error errorCode)
{
int error = (int)errorCode;
if ((error & 0x80000000) == 0x80000000)
{
return (long)error;
}
return (long)(0x80070000 | (uint)(error & 0xffff));
}
public void CreateSymbolicLinkTest()
{
var link = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
var fn = CreateTempFile(false);
Assert.That(File.Exists(fn));
var b = CreateSymbolicLink(link, fn, SymbolicLinkType.SYMBOLIC_LINK_FLAG_FILE);
if (!b)
{
TestContext.WriteLine($"CreateSymbolicLink:{Win32Error.GetLastError()}");
}
Assert.That(b);
Assert.That(File.Exists(link));
File.Delete(link);
File.Delete(fn);
}
public void GetGestureConfigTest()
{
var array = new GESTURECONFIG[] { new GESTURECONFIG(GID.GID_ZOOM), new GESTURECONFIG(GID.GID_ROTATE), new GESTURECONFIG(GID.GID_PAN) };
var aLen = (uint)array.Length;
var b = GetGestureConfig(FindWindow(null, null), 0, 0, ref aLen, array, (uint)Marshal.SizeOf(typeof(GESTURECONFIG)));
if (!b)
{
Win32Error.ThrowLastError();
}
Assert.That(b, Is.True);
Assert.That(aLen, Is.GreaterThan(0));
for (var i = 0; i < aLen; i++)
{
TestContext.WriteLine($"{array[i].dwID} = {array[i].dwWant} / {array[i].dwBlock}");
}
}
/// <summary>
/// Retrieves the cursor location safely, accounting for DPI settings in Vista/Windows 7.
/// <returns>Point with cursor location, relative to the origin of the monitor setup (i.e. negative coordinates are
/// possible in multiscreen setups)</returns>
public static Point GetCursorLocation()
{
if (Environment.OSVersion.Version.Major >= 6)
{
POINT cursorLocation;
if (User32.GetPhysicalCursorPos(out cursorLocation))
{
return(new Point(cursorLocation.X, cursorLocation.Y));
}
else
{
Win32Error error = Win32.GetLastErrorCode();
LOG.ErrorFormat("Error retrieving PhysicalCursorPos : {0}", Win32.GetMessage(error));
}
}
return(new Point(Cursor.Position.X, Cursor.Position.Y));
}
public static string GetDeviceInstanceId(string enum_device)
// Returns the device instance ID of the specified device
// 'enum_device' should have the following format:
// <enumerator>\<device_id>
{
const int BUFFER_SIZE = 4096;
string enumerator = enum_device.Split(new char[] { '\\' })[0];
StringBuilder deviceInstanceId = new StringBuilder(BUFFER_SIZE);
SetupApi.SP_DEVINFO_DATA devInfoData;
int reqSize;
using (SetupApi.DeviceInfoSet devInfoSet =
new SetupApi.DeviceInfoSet(
IntPtr.Zero,
enumerator,
IntPtr.Zero,
SetupApi.DiGetClassFlags.DIGCF_ALLCLASSES |
SetupApi.DiGetClassFlags.DIGCF_PRESENT))
{
devInfoData = Device.FindInSystem(
enum_device,
devInfoSet,
false
);
if (devInfoData == null)
{
return("");
}
if (!SetupApi.SetupDiGetDeviceInstanceId(
devInfoSet.Get(),
devInfoData,
deviceInstanceId,
BUFFER_SIZE,
out reqSize))
{
Win32Error.Set("SetupDiGetDeviceInstanceId");
throw new Exception(Win32Error.GetFullErrMsg());
}
}
return(deviceInstanceId.ToString());
}
/// <summary>
/// Get the list of registered trace providers.
/// </summary>
/// <returns>The list of trace providers.</returns>
public static IEnumerable <EventTraceProvider> GetProviders()
{
int retry_count = 10;
int buffer_length = 1024;
Dictionary <Guid, EventTraceProvider> providers = new Dictionary <Guid, EventTraceProvider>();
while (retry_count-- > 0)
{
using (var buffer = new SafeStructureInOutBuffer <PROVIDER_ENUMERATION_INFO>(buffer_length, false))
{
Win32Error error = Win32NativeMethods.TdhEnumerateProviders(buffer, ref buffer_length);
if (error == Win32Error.ERROR_INSUFFICIENT_BUFFER)
{
continue;
}
if (error != Win32Error.SUCCESS)
{
error.ToNtException();
}
var result = buffer.Result;
var data = buffer.Data;
TRACE_PROVIDER_INFO[] infos = new TRACE_PROVIDER_INFO[result.NumberOfProviders];
buffer.Data.ReadArray(0, infos, 0, infos.Length);
foreach (var info in infos)
{
if (!providers.ContainsKey(info.ProviderGuid))
{
providers.Add(info.ProviderGuid,
new EventTraceProvider(info.ProviderGuid,
buffer.ReadNulTerminatedUnicodeString(info.ProviderNameOffset),
info.SchemaSource == 0));
}
}
break;
}
}
foreach (var guid in GetTraceGuids())
{
if (!providers.ContainsKey(guid))
{
providers.Add(guid, new EventTraceProvider(guid));
}
}
return(providers.Values);
}
/// <summary>
/// Get a list of registered services.
/// </summary>
/// <returns>A list of running services with process IDs.</returns>
private static IEnumerable <RunningService> GetServices(SERVICE_STATE service_state)
{
using (SafeServiceHandle scm = Win32NativeMethods.OpenSCManager(null, null,
ServiceControlManagerAccessRights.Connect | ServiceControlManagerAccessRights.EnumerateService))
{
if (scm.IsInvalid)
{
throw new SafeWin32Exception();
}
ServiceType service_types = ServiceType.Win32OwnProcess | ServiceType.Win32ShareProcess;
if (!NtObjectUtils.IsWindows81OrLess)
{
service_types |= ServiceType.UserService;
}
const int Length = 32 * 1024;
using (var buffer = new SafeHGlobalBuffer(Length))
{
int resume_handle = 0;
while (true)
{
bool ret = Win32NativeMethods.EnumServicesStatusEx(scm, SC_ENUM_TYPE.SC_ENUM_PROCESS_INFO, service_types, service_state, buffer,
buffer.Length, out int bytes_needed, out int services_returned, ref resume_handle, null);
Win32Error error = Win32Utils.GetLastWin32Error();
if (!ret && error != Win32Error.ERROR_MORE_DATA)
{
throw new SafeWin32Exception(error);
}
ENUM_SERVICE_STATUS_PROCESS[] services = new ENUM_SERVICE_STATUS_PROCESS[services_returned];
buffer.ReadArray(0, services, 0, services_returned);
foreach (var service in services)
{
yield return(new RunningService(service));
}
if (ret)
{
break;
}
}
}
}
}
public static bool HasEmptyPassword(string userName)
{
IntPtr token;
bool success = LogonUser(userName, String.Empty, String.Empty, (int)LogonType.Network, LOGON32_PROVIDER_WINNT40, out token);
if (success)
{
CloseHandle(token);
return(true);
}
else
{
Win32Error error = (Win32Error)Marshal.GetLastWin32Error();
return(error == Win32Error.ERROR_ACCOUNT_RESTRICTION ||
error == Win32Error.ERROR_ACCOUNT_DISABLED ||
error == Win32Error.ERROR_LOGON_TYPE_NOT_GRANTED);
}
}
/// <summary>
/// Get the default RPC server security descriptor.
/// </summary>
/// <returns>The default security descriptor.</returns>
public static SecurityDescriptor GetDefaultSecurityDescriptor()
{
Win32Error result = Win32NativeMethods.I_RpcGetDefaultSD(out IntPtr sd);
if (result != Win32Error.SUCCESS)
{
result.ToNtException();
}
try
{
return(new SecurityDescriptor(sd));
}
finally
{
Win32NativeMethods.I_RpcFree(sd);
}
}
internal static string GetOwnerModule <T>(GetOwnerModuleDelegate <T> func, T entry, int process_id)
{
using (var buffer = new SafeStructureInOutBuffer <TCPIP_OWNER_MODULE_BASIC_INFO>(64 * 1024, true))
{
int size = buffer.Length;
Win32Error error = func(entry, TCPIP_OWNER_MODULE_INFO_CLASS.TCPIP_OWNER_MODULE_INFO_BASIC, buffer, ref size);
string ret;
if (error == Win32Error.SUCCESS)
{
ret = Marshal.PtrToStringUni(buffer.Result.pModulePath);
}
else
{
ret = NtSystemInfo.GetProcessIdImagePath(process_id, false).GetResultOrDefault(string.Empty);
}
return(ret);
}
}
public void AuthzModifySidsTest()
{
using (var hRM = GetAuthzInitializeResourceManager())
using (var hCtx = GetCurrentUserAuthContext(hRM))
{
var tg = new TOKEN_GROUPS(1);
var psid = new SafePSID("S-1-5-32-551");
tg.Groups[0] = new SID_AND_ATTRIBUTES {
Attributes = (uint)GroupAttributes.SE_GROUP_ENABLED, Sid = (IntPtr)psid
};
var b = AuthzModifySids(hCtx, AUTHZ_CONTEXT_INFORMATION_CLASS.AuthzContextInfoGroupsSids, new[] { AUTHZ_SID_OPERATION.AUTHZ_SID_OPERATION_ADD }, in tg);
if (!b)
{
TestContext.WriteLine($"AuthzModifySids:{Win32Error.GetLastError()}");
}
Assert.That(b);
}
}
public void GetCompressedFileSizeTest()
{
var highSz = 0U;
var lowSz = GetCompressedFileSize(AdvApi32Tests.fn, ref highSz);
Assert.That(lowSz, Is.Not.EqualTo(INVALID_FILE_SIZE));
if (lowSz == INVALID_FILE_SIZE)
{
TestContext.WriteLine(Win32Error.GetLastError());
}
var sz = MAKELONG64(lowSz, highSz);
Assert.That(sz, Is.GreaterThan(0));
highSz = 0;
lowSz = GetCompressedFileSize(@"C:\NoFile.txt", ref highSz);
Assert.That(lowSz, Is.EqualTo(INVALID_FILE_SIZE));
Assert.That(Win32Error.GetLastError() == Win32Error.ERROR_FILE_NOT_FOUND);
}
public void AccessCheckTest()
{
using (var pSD = GetSD(fn, SECURITY_INFORMATION.DACL_SECURITY_INFORMATION | SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION | SECURITY_INFORMATION.GROUP_SECURITY_INFORMATION))
using (var hTok = SafeHTOKEN.FromProcess(GetCurrentProcess(), TokenAccess.TOKEN_IMPERSONATE | TokenAccess.TOKEN_DUPLICATE | TokenAccess.TOKEN_READ).Duplicate(SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation))
{
var ps = PRIVILEGE_SET.InitializeWithCapacity(10);
var psSz = ps.SizeInBytes;
var gm = GENERIC_MAPPING.GenericFileMapping;
var accessMask = (uint)Kernel32.FileAccess.GENERIC_READ;
MapGenericMask(ref accessMask, gm);
var b = AccessCheck(pSD, hTok, accessMask, gm, ref ps, ref psSz, out var access, out var status);
if (!b)
{
TestContext.WriteLine($"AccessCheck failed: {Win32Error.GetLastError()}");
}
Assert.That(b, Is.True);
TestContext.WriteLine($"Access={(Kernel32.FileAccess)access}; Status={status}");
}
}
/// <summary>
/// Check if we can persist credentials to for the current process and logon session.
/// </summary>
/// <returns>True if persistence is possible, false otherwise.</returns>
public static bool CanPersist()
{
uint count = Advapi32.CRED_TYPE_MAXIMUM;
var arr = new CredentialPersist[count];
int result = Win32Error.GetLastError(
Advapi32.CredGetSessionTypes(count, arr)
);
CredentialPersist persist = CredentialPersist.None;
if (result == Win32Error.Success)
{
persist = arr[(int)CredentialType.Generic];
}
// If the maximum allowed is anything less than "local machine" then cannot persist credentials.
return(persist >= CredentialPersist.LocalMachine);
}
public void ThrowIfFailedTest()
{
Win32Error hr = Win32Error.ERROR_ACCESS_DENIED;
Assert.That(() => hr.ThrowIfFailed(), Throws.Exception);
Assert.That(() => hr.ThrowIfFailed("Bad"), Throws.TypeOf <UnauthorizedAccessException>().With.Message.EqualTo("Bad"));
Assert.That(() => Win32Error.ThrowIfFailed(0), Throws.Nothing);
var err = Win32Error.GetLastError();
Assert.That((int)err, Is.GreaterThanOrEqualTo(0));
if (err.Succeeded)
{
Assert.That(() => Win32Error.ThrowLastError(), Throws.Nothing);
}
else
{
Assert.That(() => Win32Error.ThrowLastError(), Throws.Exception);
}
}
public void CreateHardLinkTest()
{
var link = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
var fn = CreateTempFile();
var b = CreateHardLink(link, fn);
if (!b)
{
TestContext.WriteLine($"CreateHardLink:{Win32Error.GetLastError()}");
}
Assert.That(b);
Assert.That(File.Exists(fn));
var fnlen = new FileInfo(fn).Length;
File.AppendAllText(link, "More text");
Assert.That(fnlen, Is.LessThan(new FileInfo(fn).Length));
File.Delete(link);
File.Delete(fn);
}
public void AuthzAccessCheckAndCachedTest()
{
using (var hRM = GetAuthzInitializeResourceManager())
using (var hCtx = GetCurrentUserAuthContext(hRM))
using (var hEvt = GetAuthzInitializeObjectAccessAuditEvent())
using (var psd = AdvApi32Tests.GetSD(@"C:\Temp\help.ico"))
using (var reply = new AUTHZ_ACCESS_REPLY(1))
{
var req = new AUTHZ_ACCESS_REQUEST((uint)ACCESS_MASK.MAXIMUM_ALLOWED);
var b = AuthzAccessCheck(AuthzAccessCheckFlags.NONE, hCtx, req, hEvt, psd, null, 0, reply, out var hRes);
if (!b)
{
TestContext.WriteLine($"AuthzAccessCheck:{Win32Error.GetLastError()}");
}
Assert.That(b);
Assert.That(reply.GrantedAccessMask, Is.Not.EqualTo(IntPtr.Zero));
TestContext.WriteLine($"Access:{string.Join(",", reply.GrantedAccessMaskValues.Select(u => ((FileAccess)u).ToString()))}");
Assert.That(AuthzCachedAccessCheck(0, hRes, req, default, reply), Is.True);
public bool Remove(string key)
{
int result = Win32Error.GetLastError(
Advapi32.CredDelete(key, CredentialType.Generic, 0)
);
switch (result)
{
case Win32Error.Success:
return(true);
case Win32Error.NotFound:
return(false);
default:
Win32Error.ThrowIfError(result);
return(false);
}
}
public void LogonUserTest()
{
var b = LogonUser("*****@*****.**", null, "Itsdav1dg", LogonUserType.LOGON32_LOGON_INTERACTIVE,
LogonUserProvider.LOGON32_PROVIDER_DEFAULT, out SafeTokenHandle hTok);
if (!b)
{
TestContext.WriteLine(Win32Error.GetLastError());
}
Assert.That(b);
hTok.Dispose();
b = LogonUser("*****@*****.**", null, "pwd", LogonUserType.LOGON32_LOGON_INTERACTIVE,
LogonUserProvider.LOGON32_PROVIDER_DEFAULT, out hTok);
if (!b)
{
TestContext.WriteLine(Win32Error.GetLastError());
}
Assert.That(b, Is.False);
}
private void Refresh()
{
MainWindowModel model = DataContext as MainWindowModel;
atc.RefreshList(model.Filter);
if (model.SelectedConnection != null)
{
//change highlighted conn
model.HighlightedConnection = model.SelectedConnection;
scene.Values.Clear();
model.HighlightedGeolocation = string.Empty;
SetGeolocation(model.HighlightedConnection);
}
model.Connections.Clear();
foreach (TcpConnectionInfo tci in atc.Connections)
{
model.Connections.Add(tci);
}
if (model.HighlightedConnection != null)
{
Win32Error result = atc.Update(model.HighlightedConnection);
if (result.Failed)
{
model.HighlightedConnection = null;
scene.Values.Clear();
model.HighlightedGeolocation = string.Empty;
}
else
{
model.HighlightedConnection = model.HighlightedConnection;//force bindings update
scene.Values.Add(model.HighlightedConnection.RTT);
if (scene.Values.Count > 60)
{
scene.Values.RemoveAt(0);
}
uint maxVal = scene.Values.Max();
maxVal = Math.Max(maxVal, 100);
scene.Height = maxVal;
model.GraphHeight = maxVal;
}
}
}
private static Win32Error QueryDosDevice(string lpDeviceName, out string targetPath)
{
var qddBuf = new StringBuilder(MAX_PATH);
while (0 == Kernel32.QueryDosDevice(lpDeviceName, qddBuf, qddBuf.Capacity))
{
var err = Win32Error.GetLastError();
if (err == Win32Error.ERROR_INSUFFICIENT_BUFFER)
{
qddBuf.Capacity *= 2;
}
else
{
targetPath = null;
return(err);
}
}
targetPath = qddBuf.ToString();
return(Win32Error.ERROR_SUCCESS);
}
public static SafeHGlobalHandle GetCtxInfo(SafeAUTHZ_CLIENT_CONTEXT_HANDLE hCtx, AUTHZ_CONTEXT_INFORMATION_CLASS type)
{
bool b = AuthzGetInformationFromContext(hCtx, type, 0, out uint szReq, IntPtr.Zero);
if (!b && Win32Error.GetLastError() != Win32Error.ERROR_INSUFFICIENT_BUFFER)
{
TestContext.WriteLine($"AuthzGetInformationFromContext:{Win32Error.GetLastError()}");
}
Assert.That(!b);
if (szReq == 0)
{
return(SafeHGlobalHandle.Null);
}
SafeHGlobalHandle buf = new((int)szReq);
Assert.That(AuthzGetInformationFromContext(hCtx, type, szReq, out _, buf), ResultIs.Successful);
return(buf);
}
public static bool ValidateUserPassword(string userName, string password, LogonType logonType)
{
IntPtr token;
bool success = LogonUser(userName, String.Empty, password, (int)logonType, LOGON32_PROVIDER_WINNT40, out token);
if (!success)
{
Win32Error error = (Win32Error)Marshal.GetLastWin32Error();
if (error == Win32Error.ERROR_ACCOUNT_RESTRICTION ||
error == Win32Error.ERROR_ACCOUNT_DISABLED ||
error == Win32Error.ERROR_LOGON_FAILURE ||
error == Win32Error.ERROR_LOGON_TYPE_NOT_GRANTED)
{
return(false);
}
throw new Exception("ValidateUser failed, Win32 error: " + error.ToString("D"));
}
CloseHandle(token);
return(success);
}
/// <summary>
/// Convert SPN to a string.
/// </summary>
/// <returns>The SPN string.</returns>
public override string ToString()
{
int length = 0;
Win32Error err = SecurityNativeMethods.DsMakeSpn(ServiceClass, ServiceName, InstanceName,
(ushort)InstancePort, Referrer, ref length, null);
if (err == Win32Error.SUCCESS)
{
return(string.Empty);
}
if (err != Win32Error.ERROR_BUFFER_OVERFLOW)
{
throw new NtException(err.MapDosErrorToStatus());
}
StringBuilder builder = new StringBuilder(length);
SecurityNativeMethods.DsMakeSpn(ServiceClass, ServiceName, InstanceName,
(ushort)InstancePort, Referrer, ref length, builder).ToNtException();
return(builder.ToString());
}
internal MenuItemInfo(HMENU hMenu, uint idx)
{
using var strmem = new SafeHGlobalHandle(512);
var mii = new MENUITEMINFO
{
cbSize = (uint)Marshal.SizeOf(typeof(MENUITEMINFO)),
fMask = MenuItemInfoMask.MIIM_ID | MenuItemInfoMask.MIIM_SUBMENU | MenuItemInfoMask.MIIM_FTYPE | MenuItemInfoMask.MIIM_STRING | MenuItemInfoMask.MIIM_STATE | MenuItemInfoMask.MIIM_BITMAP,
fType = MenuItemType.MFT_STRING,
dwTypeData = (IntPtr)strmem,
cch = strmem.Size / (uint)StringHelper.GetCharSize()
};
Win32Error.ThrowLastErrorIfFalse(GetMenuItemInfo(hMenu, idx, true, ref mii));
Id = mii.wID;
Text = mii.fType.IsFlagSet(MenuItemType.MFT_SEPARATOR) ? "-" : mii.fType.IsFlagSet(MenuItemType.MFT_STRING) ? strmem.ToString(-1, CharSet.Auto) : "";
Type = mii.fType;
State = mii.fState;
BitmapHandle = mii.hbmpItem;
SubMenus = GetMenuItems(mii.hSubMenu);
}
internal static void WinIoError(int errorCode, String errorPath)
{
var isInvalidPath = errorCode == Win32Error.ERROR_INVALID_NAME || errorCode == Win32Error.ERROR_BAD_PATHNAME;
var path = GetDisplayablePath(errorPath, isInvalidPath);
switch (errorCode)
{
case Win32Error.ERROR_FILE_NOT_FOUND:
throw new FileNotFoundException("File not found", path);
case Win32Error.ERROR_PATH_NOT_FOUND:
throw new DirectoryNotFoundException("Path not found: " + path);
case Win32Error.ERROR_ACCESS_DENIED:
throw new UnauthorizedAccessException("Access denied to path: " + path);
case Win32Error.ERROR_ALREADY_EXISTS:
throw new IOException("Path already exists: " + path, Win32Error.MakeHRFromErrorCode(errorCode));
case Win32Error.ERROR_FILENAME_EXCED_RANGE:
throw new PathTooLongException("Path too long: " + path);
case Win32Error.ERROR_INVALID_DRIVE:
throw new DriveNotFoundException("Drive not found for path: " + path);
case Win32Error.ERROR_INVALID_PARAMETER:
throw new IOException(Win32Error.GetMessage(errorCode), Win32Error.MakeHRFromErrorCode(errorCode));
case Win32Error.ERROR_SHARING_VIOLATION:
throw new IOException("Sharing violation error for path: " + path, Win32Error.MakeHRFromErrorCode(errorCode));
case Win32Error.ERROR_FILE_EXISTS:
throw new IOException("File exists error for path: " + path, Win32Error.MakeHRFromErrorCode(errorCode));
case Win32Error.ERROR_OPERATION_ABORTED:
throw new OperationCanceledException();
default:
throw new IOException(Win32Error.GetMessage(errorCode), Win32Error.MakeHRFromErrorCode(errorCode));
}
}
// Token: 0x060025D7 RID: 9687 RVA: 0x00085DA8 File Offset: 0x00083FA8
public unsafe static string smethod_1(this Win32Error errorCode)
{
Struct35 @struct = default(Struct35);
if ((@struct.byte_0 = (byte)Class265.FormatMessage(12800, IntPtr.Zero, (int)errorCode, 0, new IntPtr((void *)(&@struct.struct36_0.char_0)), Struct35.int_0, IntPtr.Zero)) == 0)
{
return(string.Format("Unknown error (0x{0:x})", (int)errorCode));
}
Struct35 struct2 = default(Struct35);
for (int i = 0; i < (int)@struct.byte_0; i++)
{
char c = (&@struct.struct36_0.char_0)[i];
if (!char.IsLetterOrDigit(c) && !char.IsPunctuation(c) && !char.IsSymbol(c) && !char.IsWhiteSpace(c))
{
break;
}
struct2.method_0(c);
}
return(struct2.ToString().Replace("\r\n", ""));
}
private static Icon GetIcon(string path, bool small)
{
var flags = SHGFI.SHGFI_ICON | SHGFI.SHGFI_USEFILEATTRIBUTES | (small ? SHGFI.SHGFI_SMALLICON : SHGFI.SHGFI_LARGEICON);
var attribute = path == "5EEB255733234c4dBECF9A128E896A1E" ? FileAttributes.Directory : FileAttributes.Normal;
var shfi = new SHFILEINFO();
var res = SHGetFileInfo(path, attribute, ref shfi, Marshal.SizeOf(shfi), flags);
if (res == IntPtr.Zero)
{
Win32Error.ThrowLastError();
}
try
{
Icon.FromHandle(shfi.hIcon);
return((Icon)Icon.FromHandle(shfi.hIcon).Clone());
}
finally
{
DestroyIcon(shfi.hIcon);
}
}
public NTStatus Cancel(object ioRequest)
{
PendingRequest request = (PendingRequest)ioRequest;
const uint THREAD_TERMINATE = 0x00000001;
const uint THREAD_ALERT = 0x00000004;
uint threadID = request.ThreadID;
IntPtr threadHandle = ThreadingHelper.OpenThread(THREAD_TERMINATE | THREAD_ALERT, false, threadID);
if (threadHandle == IntPtr.Zero)
{
Win32Error error = (Win32Error)Marshal.GetLastWin32Error();
if (error == Win32Error.ERROR_INVALID_PARAMETER)
{
return(NTStatus.STATUS_INVALID_HANDLE);
}
else
{
throw new Exception("OpenThread failed, Win32 error: " + error.ToString("D"));
}
}
NTStatus status;
if (Environment.OSVersion.Version.Major >= 6)
{
IO_STATUS_BLOCK ioStatusBlock;
status = NtCancelSynchronousIoFile(threadHandle, ref request.IOStatusBlock, out ioStatusBlock);
}
else
{
// The handle was opened for synchronous operation so NtNotifyChangeDirectoryFile is blocking.
// We MUST use NtAlertThread to send a signal to stop the wait. The handle cannot be closed otherwise.
// Note: The handle was opened with CreateOptions.FILE_SYNCHRONOUS_IO_ALERT as required.
status = NtAlertThread(threadHandle);
}
ThreadingHelper.CloseHandle(threadHandle);
m_pendingRequests.Remove(request.FileHandle, request.ThreadID);
return(status);
}
public static int GetDevNode(string enum_device = "")
// Returns the device node of the specified device
// 'enum_device' should have the following format:
// <enumerator>\<device_id>
// If it is the empty string, the root of the device
// tree will be returned
{
CfgMgr32.CR err;
int devNode;
string deviceInstanceId;
if (!String.IsNullOrEmpty(enum_device))
{
deviceInstanceId = GetDeviceInstanceId(enum_device);
if (String.IsNullOrEmpty(deviceInstanceId))
{
Trace.WriteLine("No instance exists in system");
return(-1);
}
}
else
{
deviceInstanceId = "";
}
err = CfgMgr32.CM_Locate_DevNode(
out devNode,
deviceInstanceId,
CfgMgr32.CM_LOCATE_DEVNODE.NORMAL
);
if (err != CfgMgr32.CR.SUCCESS)
{
Win32Error.SetCR("CM_Locate_DevNode", err);
throw new Exception(Win32Error.GetFullErrMsg());
}
return(devNode);
}
public void CreateReadFileTest()
{
var rofn = CreateTempFile();
using (var f = CreateFile(rofn, Kernel32.FileAccess.GENERIC_READ, FileShare.Read, null, FileMode.Open, FileFlagsAndAttributes.FILE_ATTRIBUTE_NORMAL, IntPtr.Zero))
{
var sb = new SafeCoTaskMemString(100, CharSet.Ansi);
var b = ReadFile(f, (IntPtr)sb, (uint)sb.Capacity, out var read, IntPtr.Zero);
if (!b)
{
TestContext.WriteLine($"ReadFile:{Win32Error.GetLastError()}");
}
Assert.That(b);
if (read < sb.Capacity)
{
Marshal.WriteInt16((IntPtr)sb, (int)read, '\0');
}
Assert.That(read, Is.Not.Zero.And.LessThanOrEqualTo(sb.Capacity));
Assert.That((string)sb, Is.EqualTo(tmpstr));
b = SetFilePointerEx(f, 0, out var pos, SeekOrigin.Begin);
if (!b)
{
TestContext.WriteLine($"SetFilePointerEx:{Win32Error.GetLastError()}");
}
Assert.That(b);
Assert.That(pos, Is.Zero);
var bytes = new byte[100];
b = ReadFile(f, bytes, (uint)bytes.Length, out read, IntPtr.Zero);
if (!b)
{
TestContext.WriteLine($"ReadFile:{Win32Error.GetLastError()}");
}
Assert.That(b);
Assert.That(read, Is.Not.Zero.And.LessThanOrEqualTo(bytes.Length));
Assert.That(Encoding.ASCII.GetString(bytes, 0, (int)read), Is.EqualTo(tmpstr));
}
}
public static void ThrowLastError(Win32Error error)
{
throw new WindowsException(error);
}
/// <summary>
/// Creates an exception from a Win32 error code.
/// </summary>
/// <param name="errorCode">The Win32 error code.</param>
public WindowsException(Win32Error errorCode)
{
_errorCode = errorCode;
}
/// <summary>
/// This method is used to test Win32 Error related adapter requirements.
/// </summary>
/// <param name="instance">Specify the instance which need to be verified.</param>
/// <param name="site">Specify the ITestSite instance.</param>
public void VerifyWin32Error(Win32Error instance, ITestSite site)
{
// If the instance is not null and there are no parsing errors, then the Win32 Error related adapter requirements can be directly captured.
if (null == instance)
{
site.Assert.Fail("The instance of type Win32Error is null due to parsing error or type casting error.");
}
// Verify the stream object header related requirements.
this.ExpectStreamObjectHeaderStart(instance.StreamObjectHeaderStart, instance.GetType(), site);
// Directly capture requirement MS-FSSHTTPB_R769, if the header is StreamObjectHeaderStart32bit.
site.CaptureRequirementIfAreEqual<Type>(
typeof(StreamObjectHeaderStart32bit),
instance.StreamObjectHeaderStart.GetType(),
"MS-FSSHTTPB",
769,
@"[In Win32 Error] Error Win32 (4 bytes): A 32-bit stream object header (section 2.2.1.5.2) that specifies an error win32.");
// Directly capture requirement MS-FSSHTTPB_R770, if there are no parsing errors.
site.CaptureRequirement(
"MS-FSSHTTPB",
770,
@"[In Win32 Error] Error Code (4 bytes): An unsigned integer that specifies the Win32 error code.");
// Verify the compound related requirements.
this.ExpectSingleObject(instance.StreamObjectHeaderStart, site);
}
/// <summary>
/// Creates an exception from a NT status value.
/// </summary>
/// <param name="status">The NT status value.</param>
public WindowsException(NtStatus status)
{
_status = status;
_errorCode = status.ToDosError();
_isNtStatus = true;
}
public static bool PromptForCredentials2(
IWin32Window parent,
string messageText,
string captionText,
Win32Error errorCode,
ref string domainName,
ref string userName,
ref string password,
ref bool save,
CredUiWinFlags flags
)
{
Win32Error result;
CredUiInfo info = new CredUiInfo();
int authenticationPackage = 0;
IntPtr outAuthBuffer;
int outAuthBufferSize;
info.Size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(CredUiInfo));
info.Parent = parent != null ? parent.Handle : IntPtr.Zero;
info.MessageText = messageText;
info.CaptionText = captionText;
using (var inAuthBuffer = PackCredentials(0, userName, password))
{
result = Win32.CredUIPromptForWindowsCredentials(
ref info,
errorCode,
ref authenticationPackage,
inAuthBuffer,
inAuthBuffer.Size,
out outAuthBuffer,
out outAuthBufferSize,
ref save,
flags
);
if (result == Win32Error.Cancelled)
return false;
if (result != Win32Error.Success)
Win32.Throw(result);
try
{
UnpackCredentials(
new MemoryRegion(outAuthBuffer, 0, outAuthBufferSize),
CredPackFlags.ProtectedCredentials,
out domainName,
out userName,
out password
);
return true;
}
finally
{
System.Runtime.InteropServices.Marshal.FreeCoTaskMem(outAuthBuffer);
}
}
}
public static bool PromptForCredentials(
IWin32Window parent,
string messageText,
string captionText,
string targetName,
Win32Error errorCode,
ref string userName,
ref string password,
ref bool save,
CredUiFlags flags
)
{
const int maxBytes = 0x200;
const int maxChars = (maxBytes - 2) / 2;
Win32Error result;
CredUiInfo info = new CredUiInfo();
if (userName.Length > maxChars || password.Length > maxChars)
throw new ArgumentException("The user name or password string is too long.");
info.Size = System.Runtime.InteropServices.Marshal.SizeOf(typeof(CredUiInfo));
info.Parent = parent != null ? parent.Handle : IntPtr.Zero;
info.MessageText = messageText;
info.CaptionText = captionText;
using (var userNameAlloc = new MemoryAlloc(maxBytes))
using (var passwordAlloc = new MemoryAlloc(maxBytes))
{
userNameAlloc.WriteUnicodeString(0, userName);
userNameAlloc.WriteInt16(userName.Length * 2, 0);
passwordAlloc.WriteUnicodeString(0, password);
passwordAlloc.WriteInt16(password.Length * 2, 0);
result = Win32.CredUIPromptForCredentials(
ref info,
targetName,
IntPtr.Zero,
errorCode,
userNameAlloc,
maxBytes / 2,
passwordAlloc,
maxBytes / 2,
ref save,
flags
);
if (result == Win32Error.Cancelled)
return false;
if (result != Win32Error.Success)
Win32.Throw(result);
userName = userNameAlloc.ReadUnicodeString(0);
password = passwordAlloc.ReadUnicodeString(0);
return true;
}
}
public static string GetMessage(Win32Error errorCode)
{
StringBuilder buffer = new StringBuilder(0x100);
if (FormatMessage(0x3200, IntPtr.Zero, (uint)errorCode, 0, buffer, buffer.Capacity, IntPtr.Zero) == 0) {
return "Unknown error (0x" + ((int)errorCode).ToString("x") + ")";
}
StringBuilder result = new StringBuilder();
int i = 0;
while (i < buffer.Length) {
if (!char.IsLetterOrDigit(buffer[i]) &&
!char.IsPunctuation(buffer[i]) &&
!char.IsSymbol(buffer[i]) &&
!char.IsWhiteSpace(buffer[i]))
break;
result.Append(buffer[i]);
i++;
}
return result.ToString().Replace("\r\n", "");
}
