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", ""); }