private static SafeCertContextHandle FilterPFXStore(byte[] rawData, string password, PfxCertStoreFlags pfxCertStoreFlags) { SafeCertStoreHandle hStore; unsafe { fixed(byte *pbRawData = rawData) { CRYPTOAPI_BLOB certBlob = new CRYPTOAPI_BLOB(rawData.Length, pbRawData); hStore = Interop.crypt32.PFXImportCertStore(ref certBlob, password, pfxCertStoreFlags); if (hStore.IsInvalid) { throw Marshal.GetHRForLastWin32Error().ToCryptographicException(); } ; } } try { // Find the first cert with private key. If none, then simply take the very first cert. Along the way, delete the keycontainers // of any cert we don't accept. SafeCertContextHandle pCertContext = SafeCertContextHandle.InvalidHandle; SafeCertContextHandle pEnumContext = null; while (Interop.crypt32.CertEnumCertificatesInStore(hStore, ref pEnumContext)) { if (pEnumContext.ContainsPrivateKey) { if ((!pCertContext.IsInvalid) && pCertContext.ContainsPrivateKey) { // We already found our chosen one. Free up this one's key and move on. SafeCertContextHandleWithKeyContainerDeletion.DeleteKeyContainer(pEnumContext); } else { // Found our first cert that has a private key. Set him up as our chosen one but keep iterating // as we need to free up the keys of any remaining certs. pCertContext.Dispose(); pCertContext = pEnumContext.Duplicate(); } } else { if (pCertContext.IsInvalid) { pCertContext = pEnumContext.Duplicate(); // Doesn't have a private key but hang on to it anyway in case we don't find any certs with a private key. } } } if (pCertContext.IsInvalid) { // For compat, setting "hr" to ERROR_INVALID_PARAMETER even though ERROR_INVALID_PARAMETER is not actually an HRESULT. throw ErrorCode.ERROR_INVALID_PARAMETER.ToCryptographicException(); } return(pCertContext); } finally { hStore.Dispose(); } }
/// <summary> /// Move one file from source to destination. Create the target directory if necessary. /// </summary> /// <throws>IO related exceptions</throws> private bool MoveFileWithLogging ( string sourceFile, string destinationFile ) { if (FileSystems.Default.DirectoryExists(destinationFile)) { Log.LogErrorWithCodeFromResources("Move.DestinationIsDirectory", sourceFile, destinationFile); return(false); } if (FileSystems.Default.DirectoryExists(sourceFile)) { // If the source file passed in is actually a directory instead of a file, log a nice // error telling the user so. Otherwise, .NET Framework's File.Move method will throw // an FileNotFoundException, which is not very useful to the user. Log.LogErrorWithCodeFromResources("Move.SourceIsDirectory", sourceFile); return(false); } // Check the source exists. if (!FileSystems.Default.FileExists(sourceFile)) { Log.LogErrorWithCodeFromResources("Move.SourceDoesNotExist", sourceFile); return(false); } // We can't ovewrite a file unless it's writeable if (OverwriteReadOnlyFiles && FileSystems.Default.FileExists(destinationFile)) { MakeWriteableIfReadOnly(destinationFile); } string destinationFolder = Path.GetDirectoryName(destinationFile); if (!string.IsNullOrEmpty(destinationFolder) && !FileSystems.Default.DirectoryExists(destinationFolder)) { Log.LogMessageFromResources(MessageImportance.Normal, "Move.CreatesDirectory", destinationFolder); Directory.CreateDirectory(destinationFolder); } // Do not log a fake command line as well, as it's superfluous, and also potentially expensive Log.LogMessageFromResources(MessageImportance.Normal, "Move.FileComment", sourceFile, destinationFile); // We want to always overwrite any existing destination file. // Unlike File.Copy, File.Move does not have an overload to overwrite the destination. // We cannot simply delete the destination file first because possibly it is also the source! // Nor do we want to just do a Copy followed by a Delete, because for large files that will be slow. // We are forced to use Win32's MoveFileEx. bool result = NativeMethods.MoveFileEx(sourceFile, destinationFile, Flags); if (!result) { // It failed so we need a nice error message. Unfortunately // Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); and // throw new IOException((new Win32Exception(error)).Message) // do not produce great error messages (eg., "The operation succeeded" (!)). // For this reason the BCL has is own mapping in System.IO.__Error.WinIOError // which is unfortunately internal. // So try to get a nice message by using the BCL Move(), which will likely fail // and throw. Otherwise use the "correct" method. File.Move(sourceFile, destinationFile); // Apparently that didn't throw, so.. Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } // If the destination file exists, then make sure it's read-write. // The File.Move command copies attributes, but our move needs to // leave the file writeable. if (FileSystems.Default.FileExists(destinationFile)) { // Make it writable MakeWriteableIfReadOnly(destinationFile); } return(true); }
private static void ThrowLastWin32Error(string message) { throw new IOException(message, Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); }
public void Generate() { try { if (threadtoken != IntPtr.Zero) { if (!NativeMethods.SetThreadToken(IntPtr.Zero, threadtoken)) { throw new COMException(Resource.FormatString("Err_SetThreadToken"), Marshal.GetHRForLastWin32Error()); } } if (wsdlurl.Length <= 0) { return; } Stream oSchemaStream = new MemoryStream(); ArrayList aCodeStreamList = new ArrayList(); MetaData.RetrieveSchemaFromUrlToStream(wsdlurl, oSchemaStream); oSchemaStream.Position = 0; MetaData.ConvertSchemaStreamToCodeSourceStream(true, pathname, oSchemaStream, aCodeStreamList); MetaData.ConvertCodeSourceStreamToAssemblyFile(aCodeStreamList, filename, null); } catch (Exception e) { ComSoapPublishError.Report(e.ToString()); SavedException = e; ExceptionThrown = true; throw; } }
public void WriteData(string fileName, string templateFileName, byte[] data, ref long readTime) { if (!fileName.ToLowerInvariant().EndsWith(".config", StringComparison.Ordinal)) { throw new Exception(System.Web.SR.GetString("Can_not_access_files_other_than_config")); } bool flag = File.Exists(fileName); FileInfo info = null; FileAttributes normal = FileAttributes.Normal; string path = null; Exception exception = null; FileStream stream = null; long ticks = 0L; long num2 = 0L; if (flag && (File.GetLastWriteTimeUtc(fileName).Ticks > readTime)) { throw new Exception(System.Web.SR.GetString("File_changed_since_read", new object[] { fileName })); } if (flag) { try { info = new FileInfo(fileName); normal = info.Attributes; } catch { } if ((normal & (FileAttributes.Hidden | FileAttributes.ReadOnly)) != 0) { throw new Exception(System.Web.SR.GetString("File_is_read_only", new object[] { fileName })); } } path = fileName + "." + GetRandomFileExt() + ".tmp"; for (int i = 0; File.Exists(path); i++) { if (i > 100) { throw new Exception(System.Web.SR.GetString("Unable_to_create_temp_file")); } path = fileName + "." + GetRandomFileExt() + ".tmp"; } try { stream = new FileStream(path, FileMode.CreateNew, FileAccess.Write, FileShare.ReadWrite, data.Length, FileOptions.None | FileOptions.WriteThrough); stream.Write(data, 0, data.Length); } catch (Exception exception2) { exception = exception2; } finally { if (stream != null) { stream.Close(); } } if (exception != null) { try { File.Delete(path); } catch { } throw exception; } if (flag) { try { this.DuplicateFileAttributes(fileName, path); goto Label_0170; } catch { goto Label_0170; } } if (templateFileName != null) { try { this.DuplicateTemplateAttributes(fileName, templateFileName); } catch { } } Label_0170: if (!System.Web.UnsafeNativeMethods.MoveFileEx(path, fileName, 11)) { try { File.Delete(path); } catch { } Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } if (flag) { info = new FileInfo(fileName) { Attributes = normal }; } ticks = File.GetLastWriteTimeUtc(fileName).Ticks; num2 = DateTime.UtcNow.Ticks; readTime = (num2 > ticks) ? num2 : ticks; }
/// <summary> /// Execute message queue. /// </summary> /// <param name="task">Completion awaiting task</param> public void Run(Task task) { // Run only target thread. var currentThreadId = GetCurrentThreadId(); if (currentThreadId != targetThreadId) { throw new InvalidOperationException(); } // Schedule task completion for abort message loop. task?.ContinueWith(_ => PostThreadMessage(targetThreadId, WM_QUIT, IntPtr.Zero, IntPtr.Zero)); // Run message loop (very legacy knowledge...) while (true) { // Get front of queue (or waiting). MSG msg; var result = GetMessage(out msg, IntPtr.Zero, 0, 0); // If message number is WM_QUIT (Cause PostQuitMessage API): if (result == 0) { // Exit. break; } // If cause error: if (result == -1) { // Throw. var hr = Marshal.GetHRForLastWin32Error(); Marshal.ThrowExceptionForHR(hr); } // If message is WM_SC: if (msg.msg == WM_SC) { // Retreive GCHandles from cookies. var continuationHandle = GCHandle.FromIntPtr(msg.wParam); var stateHandle = GCHandle.FromIntPtr(msg.lParam); // Retreive continuation and state. var continuation = (SendOrPostCallback)continuationHandle.Target; var state = stateHandle.Target; // Release handle (Recollectable by GC) continuationHandle.Free(); stateHandle.Free(); // Invoke continuation. continuation(state); // Consumed message. continue; } // Translate accelerator (require UI stability) TranslateMessage(ref msg); // Send to assigned window procedure. DispatchMessage(ref msg); } }
public static void ChangeColorEffect(float[,] matrix) { ColorEffect colorEffect = new ColorEffect(matrix); if (!NativeMethods.SetMagnificationDesktopColorEffect(ref colorEffect)) { var inner = new Exception("SetMagnificationDesktopColorEffect()", Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); throw new CannotChangeColorEffectException("An error occured while applying a color effect. Another application using the same API might be interfering...", inner); } }
public static Exception LastWin32Exception() { return(Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); }
private void OverlappedIoThreadMainLoop() { // WaitCommEvent bool serialCommPending = false; m_SerialCommEvent.Reset(); NativeOverlapped serialCommOverlapped = new NativeOverlapped(); serialCommOverlapped.EventHandle = m_SerialCommEvent.SafeWaitHandle.DangerousGetHandle(); // ReadFile bool readPending = false; m_ReadEvent.Reset(); NativeOverlapped readOverlapped = new NativeOverlapped(); readOverlapped.EventHandle = m_ReadEvent.SafeWaitHandle.DangerousGetHandle(); // WriteFile bool writePending = false; m_WriteEvent.Reset(); NativeOverlapped writeOverlapped = new NativeOverlapped(); m_ReadByteAvailable = false; writeOverlapped.EventHandle = m_WriteEvent.SafeWaitHandle.DangerousGetHandle(); // SEt up the types of serial events we want to see. UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead); bool result; NativeMethods.SerialEventMask commEventMask = 0; bool running = true; uint bytes; List <WaitHandle> handles = new List <WaitHandle>(10); while (running) { handles.Clear(); handles.Add(m_StopRunning); handles.Add(m_WriteClearEvent); #if PL2303_WORKAROUNDS // - - - - - - - - - - - - - - - - - - - - - - - - - // PROLIFIC PL23030 WORKAROUND // - - - - - - - - - - - - - - - - - - - - - - - - - // If we have a read pending, we don't request events // for reading data. To do so will result in errors. // Have no idea why. if (readPending) { UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskReadPending); } else { UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead); // While the comm event mask was set to ignore read events, data could have been written // to the input queue. Check for that and if there are bytes waiting or EOF was received, // set the appropriate flags. uint bytesInQueue; bool eofReceived; if (GetReceiveStats(out bytesInQueue, out eofReceived) && (bytesInQueue > 0 || eofReceived)) { // Tell DoReadEvent that there is data pending m_ReadByteAvailable = true; m_ReadByteEof |= eofReceived; } } #else UnsafeNativeMethods.SetCommMask(m_ComPortHandle, maskRead); #endif // commEventMask is on the stack, and is therefore fixed if (!serialCommPending) { serialCommPending = DoWaitCommEvent(out commEventMask, ref serialCommOverlapped); } if (serialCommPending) { handles.Add(m_SerialCommEvent); } if (!readPending) { if (!m_Buffer.Serial.ReadBufferNotFull.WaitOne(0)) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Read Buffer Full", m_Name); handles.Add(m_Buffer.Serial.ReadBufferNotFull); } else { readPending = DoReadEvent(ref readOverlapped); } } if (readPending) { handles.Add(m_ReadEvent); } if (!writePending) { if (!m_Buffer.Serial.WriteBufferNotEmpty.WaitOne(0)) { handles.Add(m_Buffer.Serial.WriteBufferNotEmpty); } else { writePending = DoWriteEvent(ref writeOverlapped); } } if (writePending) { handles.Add(m_WriteEvent); } // We wait up to 100ms, in case we're not actually pending on anything. Normally, we should always be // pending on a Comm event. Just in case this is not so (and is a theoretical possibility), we will // slip out of this WaitAny() after 100ms and then restart the loop, effectively polling every 100ms in // worst case. WaitHandle[] whandles = handles.ToArray(); int ev = WaitHandle.WaitAny(whandles, 100); if (ev != WaitHandle.WaitTimeout) { if (whandles[ev] == m_StopRunning) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Thread closing", m_Name); result = UnsafeNativeMethods.CancelIo(m_ComPortHandle); if (!result) { int win32Error = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Warning, 0, "{0}: SerialThread: CancelIo error {1}", m_Name, win32Error); Marshal.ThrowExceptionForHR(hr); } running = false; } else if (whandles[ev] == m_SerialCommEvent) { result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref serialCommOverlapped, out bytes, true); if (!result) { int win32Error = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Error, 0, "{0}: SerialThread: Overlapped WaitCommEvent() error {1}", m_Name, win32Error); Marshal.ThrowExceptionForHR(hr); } ProcessWaitCommEvent(commEventMask); serialCommPending = false; } else if (whandles[ev] == m_ReadEvent) { result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref readOverlapped, out bytes, true); if (!result) { int win32Error = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); // Should never get ERROR_IO_PENDING, as this method is only called when the event is triggered. if (win32Error != WinError.ERROR_OPERATION_ABORTED || bytes > 0) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Error, 0, "{0}: SerialThread: Overlapped ReadFile() error {1} bytes {2}", m_Name, win32Error, bytes); Marshal.ThrowExceptionForHR(hr); } else { // ERROR_OPERATION_ABORTED may be caused by CancelIo or PurgeComm if (SerialTrace.TraceSer.Switch.ShouldTrace(System.Diagnostics.TraceEventType.Verbose)) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Overlapped ReadFile() error {1} bytes {2}", m_Name, win32Error, bytes); } } } else { ProcessReadEvent(bytes); } readPending = false; } else if (whandles[ev] == m_Buffer.Serial.ReadBufferNotFull) { // The read buffer is no longer full. We just loop back to the beginning to test if we // should read or not. } else if (whandles[ev] == m_WriteEvent) { result = UnsafeNativeMethods.GetOverlappedResult(m_ComPortHandle, ref writeOverlapped, out bytes, true); if (!result) { int win32Error = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); // Should never get ERROR_IO_PENDING, as this method is only called when the event is triggered. if (win32Error != WinError.ERROR_OPERATION_ABORTED || bytes > 0) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Error, 0, "{0}: SerialThread: Overlapped WriteFile() error {1} bytes {2}", m_Name, win32Error, bytes); Marshal.ThrowExceptionForHR(hr); } else { // ERROR_OPERATION_ABORTED may be caused by CancelIo or PurgeComm if (SerialTrace.TraceSer.Switch.ShouldTrace(System.Diagnostics.TraceEventType.Verbose)) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Overlapped WriteFile() error {1} bytes {2}", m_Name, win32Error, bytes); } } } else { ProcessWriteEvent(bytes); } writePending = false; } else if (whandles[ev] == m_Buffer.Serial.WriteBufferNotEmpty) { // The write buffer is no longer empty. We just loop back to the beginning to test if we // should write or not. } else if (whandles[ev] == m_WriteClearEvent) { if (writePending) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: PurgeComm() write pending", m_Name); m_PurgePending = true; result = UnsafeNativeMethods.PurgeComm(m_ComPortHandle, NativeMethods.PurgeFlags.PURGE_TXABORT | NativeMethods.PurgeFlags.PURGE_TXCLEAR); if (!result) { int win32Error = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); if (win32Error != WinError.ERROR_OPERATION_ABORTED) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Error, 0, "{0}: SerialThread: PurgeComm() error {1}", m_Name, win32Error); Marshal.ThrowExceptionForHR(hr); } else { if (SerialTrace.TraceSer.Switch.ShouldTrace(System.Diagnostics.TraceEventType.Verbose)) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: PurgeComm() error {1}", m_Name, win32Error); } } } } else { lock (m_Buffer.WriteLock) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: Purged", m_Name); m_Buffer.Serial.Purge(); m_WriteClearDoneEvent.Set(); } } } } #if STRESSTEST SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: STRESSTEST SerialThread: Stress Test Delay of 1000ms", m_Name); System.Threading.Thread.Sleep(1000); NativeMethods.ComStatErrors commStateErrors = new NativeMethods.ComStatErrors(); NativeMethods.COMSTAT commStat = new NativeMethods.COMSTAT(); result = UnsafeNativeMethods.ClearCommError(m_ComPortHandle, out commStateErrors, out commStat); if (result) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Information, 0, "{0}: STRESSTEST SerialThread: ClearCommError errors={1}", m_Name, commStateErrors); SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Information, 0, "{0}: STRESSTEST SerialThread: ClearCommError stats flags={1}, InQueue={2}, OutQueue={3}", m_Name, commStat.Flags, commStat.cbInQue, commStat.cbOutQue); } else { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Warning, 0, "{0}: STRESSTEST SerialThread: ClearCommError error: {1}", m_Name, Marshal.GetLastWin32Error()); } #endif } }
private IntPtr CreateWindow(NativeMethods.BitmapHandle hBitmap, int width, int height, bool topMost) { if (_defWndProc == null) { _defWndProc = new MS.Win32.NativeMethods.WndProc(UnsafeNativeMethods.DefWindowProc); } MS.Win32.NativeMethods.WNDCLASSEX_D wndClass = new MS.Win32.NativeMethods.WNDCLASSEX_D(); wndClass.cbSize = Marshal.SizeOf(typeof(MS.Win32.NativeMethods.WNDCLASSEX_D)); wndClass.style = 3; /* CS_HREDRAW | CS_VREDRAW */ wndClass.lpfnWndProc = null; wndClass.hInstance = _hInstance; wndClass.hCursor = IntPtr.Zero; wndClass.lpszClassName = CLASSNAME; wndClass.lpszMenuName = string.Empty; wndClass.lpfnWndProc = _defWndProc; // We chose to ignore re-registration errors in RegisterClassEx on the off chance that the user // wants to open multiple splash screens. _wndClass = MS.Win32.UnsafeNativeMethods.IntRegisterClassEx(wndClass); if (_wndClass == 0) { if (Marshal.GetLastWin32Error() != 0x582) /* class already registered */ { throw new Win32Exception(); } } int screenWidth = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CXSCREEN); int screenHeight = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CYSCREEN); int x = (screenWidth - width) / 2; int y = (screenHeight - height) / 2; HandleRef nullHandle = new HandleRef(null, IntPtr.Zero); int windowCreateFlags = (int)NativeMethods.WS_EX_WINDOWEDGE | NativeMethods.WS_EX_TOOLWINDOW | NativeMethods.WS_EX_LAYERED | (topMost ? NativeMethods.WS_EX_TOPMOST : 0); // CreateWindowEx will either succeed or throw IntPtr hWnd = MS.Win32.UnsafeNativeMethods.CreateWindowEx( windowCreateFlags, CLASSNAME, SR.Get(SRID.SplashScreenIsLoading), MS.Win32.NativeMethods.WS_POPUP | MS.Win32.NativeMethods.WS_VISIBLE, x, y, width, height, nullHandle, nullHandle, new HandleRef(null, _hInstance), IntPtr.Zero); // Display the image on the window IntPtr hScreenDC = UnsafeNativeMethods.GetDC(new HandleRef()); IntPtr memDC = UnsafeNativeMethods.CreateCompatibleDC(new HandleRef(null, hScreenDC)); IntPtr hOldBitmap = UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hBitmap.MakeHandleRef(null).Handle); NativeMethods.POINT newSize = new NativeMethods.POINT(width, height); NativeMethods.POINT newLocation = new NativeMethods.POINT(x, y); NativeMethods.POINT sourceLocation = new NativeMethods.POINT(0, 0); _blendFunc = new NativeMethods.BLENDFUNCTION(); _blendFunc.BlendOp = NativeMethods.AC_SRC_OVER; _blendFunc.BlendFlags = 0; _blendFunc.SourceConstantAlpha = 255; _blendFunc.AlphaFormat = 1; /*AC_SRC_ALPHA*/ bool result = UnsafeNativeMethods.UpdateLayeredWindow(hWnd, hScreenDC, newLocation, newSize, memDC, sourceLocation, 0, ref _blendFunc, NativeMethods.ULW_ALPHA); UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hOldBitmap); UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, memDC)); UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, hScreenDC)); if (result == false) { UnsafeNativeMethods.HRESULT.Check(Marshal.GetHRForLastWin32Error()); } return(hWnd); }
private static MetadataReaderProvider GetMetadataReaderProvider(Module module) { // TODO can the PEReader be pointed at a memory location instead of reading from disk? var dllFileContent = File.ReadAllBytes(module.FullyQualifiedName).ToImmutableArray(); var reader = new PEReader(dllFileContent); TraceSourceLink("probing for embedded symbols: " + module.FullyQualifiedName); if (!reader.HasMetadata) { return(null); } // https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/tests/PortableExecutable/PEReaderTests.cs var embeddedPdb = reader.ReadDebugDirectory().FirstOrDefault(x => x.Type == DebugDirectoryEntryType.EmbeddedPortablePdb); if (!embeddedPdb.Equals(default(DebugDirectoryEntry))) { TraceSourceLink("found embedded symbols: " + module.FullyQualifiedName); return(reader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedPdb)); } var sbFile = new StringBuilder(1024); var sbPath = new StringBuilder(1024); if (SymGetSymbolFile(ProcessHandle, null, module.FullyQualifiedName, SymbolFileType.sfPdb, sbFile, sbFile.Capacity, sbPath, sbPath.Capacity)) { // todo determine if pdb is not portable early // https://github.com/tmat/corefx/blob/f808e59c3ef93e141b019d661a4443a0e19c7442/src/System.Diagnostics.StackTrace/src/System/Diagnostics/StackTraceSymbols.CoreCLR.cs#L164 TraceSourceLink("probing for portable PDB symbols: " + sbFile); var pdbFileContent = File.ReadAllBytes(sbFile.ToString()).ToImmutableArray(); return(MetadataReaderProvider.FromPortablePdbImage(pdbFileContent)); } else { TraceSourceLink("probing for portable PDB symbols failed: " + Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); } return(null); }
public static string GetTarget(string path) { SymbolicLinkReparseData reparseDataBuffer; using (SafeFileHandle fileHandle = GetFileHandle(path)) { if (fileHandle.IsInvalid) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } #if NET35 int outBufferSize = Marshal.SizeOf(typeof(SymbolicLinkReparseData)); #else int outBufferSize = Marshal.SizeOf <SymbolicLinkReparseData>(); #endif IntPtr outBuffer = IntPtr.Zero; try { outBuffer = Marshal.AllocHGlobal(outBufferSize); bool success = DeviceIoControl( fileHandle.DangerousGetHandle(), ioctlCommandGetReparsePoint, IntPtr.Zero, 0, outBuffer, outBufferSize, out int bytesReturned, IntPtr.Zero); fileHandle.Dispose(); if (!success) { if (((uint)Marshal.GetHRForLastWin32Error()) == pathNotAReparsePointError) { return(null); } Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } #if NET35 reparseDataBuffer = (SymbolicLinkReparseData)Marshal.PtrToStructure( outBuffer, typeof(SymbolicLinkReparseData)); #else reparseDataBuffer = Marshal.PtrToStructure <SymbolicLinkReparseData>(outBuffer); #endif } finally { Marshal.FreeHGlobal(outBuffer); } } if (reparseDataBuffer.ReparseTag != symLinkTag) { return(null); } string target = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, reparseDataBuffer.PrintNameOffset, reparseDataBuffer.PrintNameLength); if ((reparseDataBuffer.Flags & symlinkReparsePointFlagRelative) == symlinkReparsePointFlagRelative) { string basePath = Path.GetDirectoryName(path.TrimEnd(Path.DirectorySeparatorChar)); string combinedPath = Path.Combine(basePath, target); target = Path.GetFullPath(combinedPath); } return(target); }
/// <summary> /// Add commands to a shortcut menu. /// </summary> /// <param name="hMenu">A handle to the shortcut menu.</param> /// <param name="iMenu"> /// The zero-based position at which to insert the first new menu item. /// </param> /// <param name="idCmdFirst"> /// The minimum value that the handler can specify for a menu item ID. /// </param> /// <param name="idCmdLast"> /// The maximum value that the handler can specify for a menu item ID. /// </param> /// <param name="uFlags"> /// Optional flags that specify how the shortcut menu can be changed. /// </param> /// <returns> /// If successful, returns an HRESULT value that has its severity value set /// to SEVERITY_SUCCESS and its code value set to the offset of the largest /// command identifier that was assigned, plus one. /// </returns> public int QueryContextMenu( IntPtr hMenu, uint iMenu, uint idCmdFirst, uint idCmdLast, uint uFlags) { // If uFlags include CMF_DEFAULTONLY then we should not do anything. if (((uint)CMF.CMF_DEFAULTONLY & uFlags) != 0) { return(WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 0)); } // Add a separator. var sep = new MENUITEMINFO(); sep.cbSize = (uint)Marshal.SizeOf(sep); sep.fMask = MIIM.MIIM_TYPE; sep.fType = MFT.MFT_SEPARATOR; if (!NativeMethods.InsertMenuItem(hMenu, 0, true, ref sep)) { return(Marshal.GetHRForLastWin32Error()); } // Register item 0: Submenu var hSubMenu = NativeMethods.CreatePopupMenu(); var item = menuItems[0]; RegisterMenuItem(0, idCmdFirst, item.Text, true, item.Bitmap, hSubMenu, 1, hMenu); // Register item 1: RunDefault item = menuItems[1]; RegisterMenuItem(1, idCmdFirst, item.Text, true, item.Bitmap, IntPtr.Zero, 0, hSubMenu); // Add a separator. sep = new MENUITEMINFO(); sep.cbSize = (uint)Marshal.SizeOf(sep); sep.fMask = MIIM.MIIM_TYPE; sep.fType = MFT.MFT_SEPARATOR; NativeMethods.InsertMenuItem(hSubMenu, 1, true, ref sep); // Register item 2 (Submenu->ManageApp). item = menuItems[2]; RegisterMenuItem(2, idCmdFirst, item.Text, true, item.Bitmap, IntPtr.Zero, 2, hSubMenu); // Register item 3 (Submenu->ManageAll). item = menuItems[3]; RegisterMenuItem(3, idCmdFirst, item.Text, true, item.Bitmap, IntPtr.Zero, 3, hSubMenu); //Register user-defined profiles. //We should count down to 4. for (var i = menuItems.Count - 1; i > 3; i--) { item = menuItems[i]; if (item.ShowInMainMenu == true) { RegisterMenuItem((uint)i, idCmdFirst, item.Text, item.Enabled, item.Bitmap, IntPtr.Zero, 1, hMenu); } else { RegisterMenuItem((uint)i, idCmdFirst, item.Text, item.Enabled, item.Bitmap, IntPtr.Zero, 0, hSubMenu); } } // Add a separator. sep = new MENUITEMINFO(); sep.cbSize = (uint)Marshal.SizeOf(sep); sep.fMask = MIIM.MIIM_TYPE; sep.fType = MFT.MFT_SEPARATOR; NativeMethods.InsertMenuItem(hSubMenu, (uint)menuItems.FindAll(t => t.ShowInMainMenu != true).Count - 4, true, ref sep); // Return an HRESULT value with the severity set to SEVERITY_SUCCESS. // Set the code value to the total number of items added. return(WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 3 + (uint)menuItems.Count)); }
private static ICertificatePal FromBlobOrFile(byte[] rawData, string fileName, string password, X509KeyStorageFlags keyStorageFlags) { Debug.Assert(rawData != null || fileName != null); bool loadFromFile = (fileName != null); PfxCertStoreFlags pfxCertStoreFlags = MapKeyStorageFlags(keyStorageFlags); bool persistKeySet = (0 != (keyStorageFlags & X509KeyStorageFlags.PersistKeySet)); CertEncodingType msgAndCertEncodingType; ContentType contentType; FormatType formatType; SafeCertStoreHandle hCertStore = null; SafeCryptMsgHandle hCryptMsg = null; SafeCertContextHandle pCertContext = null; try { unsafe { fixed(byte *pRawData = rawData) { fixed(char *pFileName = fileName) { CRYPTOAPI_BLOB certBlob = new CRYPTOAPI_BLOB(loadFromFile ? 0 : rawData.Length, pRawData); CertQueryObjectType objectType = loadFromFile ? CertQueryObjectType.CERT_QUERY_OBJECT_FILE : CertQueryObjectType.CERT_QUERY_OBJECT_BLOB; void *pvObject = loadFromFile ? (void *)pFileName : (void *)&certBlob; bool success = Interop.crypt32.CryptQueryObject( objectType, pvObject, X509ExpectedContentTypeFlags, X509ExpectedFormatTypeFlags, 0, out msgAndCertEncodingType, out contentType, out formatType, out hCertStore, out hCryptMsg, out pCertContext ); if (!success) { int hr = Marshal.GetHRForLastWin32Error(); throw hr.ToCryptographicException(); } } } if (contentType == ContentType.CERT_QUERY_CONTENT_PKCS7_SIGNED || contentType == ContentType.CERT_QUERY_CONTENT_PKCS7_SIGNED_EMBED) { pCertContext = GetSignerInPKCS7Store(hCertStore, hCryptMsg); } else if (contentType == ContentType.CERT_QUERY_CONTENT_PFX) { if (loadFromFile) { rawData = File.ReadAllBytes(fileName); } pCertContext = FilterPFXStore(rawData, password, pfxCertStoreFlags); } CertificatePal pal = new CertificatePal(pCertContext, deleteKeyContainer: !persistKeySet); pCertContext = null; return(pal); } } finally { if (hCertStore != null) { hCertStore.Dispose(); } if (hCryptMsg != null) { hCryptMsg.Dispose(); } if (pCertContext != null) { pCertContext.Dispose(); } } }
public bool Install(string path, out string errorMessage) { var manager = NativeMethods.OpenSCManager(null, null, ServiceControlManagerAccessRights.SC_MANAGER_ALL_ACCESS); if (manager == IntPtr.Zero) { errorMessage = "OpenSCManager returned zero."; return(false); } var service = NativeMethods.CreateService(manager, id, id, ServiceAccessRights.SERVICE_ALL_ACCESS, ServiceType.SERVICE_KERNEL_DRIVER, StartType.SERVICE_DEMAND_START, ErrorControl.SERVICE_ERROR_NORMAL, path, null, null, null, null, null); if (service == IntPtr.Zero) { if (Marshal.GetHRForLastWin32Error() == ERROR_SERVICE_EXISTS) { errorMessage = "Service already exists"; return(false); } else { errorMessage = "CreateService returned the error: " + Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; NativeMethods.CloseServiceHandle(manager); return(false); } } if (!NativeMethods.StartService(service, 0, null)) { if (Marshal.GetHRForLastWin32Error() != ERROR_SERVICE_ALREADY_RUNNING) { errorMessage = "StartService returned the error: " + Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()).Message; NativeMethods.CloseServiceHandle(service); NativeMethods.CloseServiceHandle(manager); return(false); } } NativeMethods.CloseServiceHandle(service); NativeMethods.CloseServiceHandle(manager); #if !NETSTANDARD2_0 try { // restrict the driver access to system (SY) and builtin admins (BA) // TODO: replace with a call to IoCreateDeviceSecure in the driver var fileSecurity = System.IO.File.GetAccessControl(@"\\.\" + id); fileSecurity.SetSecurityDescriptorSddlForm( "O:BAG:SYD:(A;;FA;;;SY)(A;;FA;;;BA)"); System.IO.File.SetAccessControl(@"\\.\" + id, fileSecurity); } catch { } #endif errorMessage = null; return(true); }
/// <summary> /// Check if we should ReadFile() and process the data if serial data is immediately. /// available. /// </summary> /// <remarks> /// This function should be called if there is no existing pending read operation. It /// will check if there is data to read (indicated by the variable m_ReadByteAvailable, /// which is set by ProcessWaitCommEvent()) and then issue a ReadFile(). If the result /// indicates that asynchronous I/O is happening, <b>true</b> is returned. Else this /// function automatically calls ProcessReadEvent() with the number of bytes read. If /// an asynchronous operation is pending, then you should wait on the event in the /// overlapped structure not call this function until GetOverlappedResult() has /// been called. /// </remarks> /// <param name="overlap">The overlap structure to use for reading.</param> /// <returns>If the operation is pending or not.</returns> private bool DoReadEvent(ref NativeOverlapped overlap) { // If WaitCommEvent() hasn't been called, there's no data if (!m_ReadByteAvailable) { return(false); } // Read Buffer is full, so can't write into it. if (!m_Buffer.Serial.ReadBufferNotFull.WaitOne(0)) { return(false); } // As C# can't convert an offset in the array to a pointer, we have to do // our own marshalling with (IntPtr)ReadBufferOffsetEnd that is the address // at the end of the read buffer. IntPtr bufPtr; uint bufLen; lock (m_Buffer.ReadLock) { bufPtr = m_Buffer.Serial.ReadBufferOffsetEnd; bufLen = (uint)m_Buffer.Serial.ReadBuffer.WriteLength; } uint bufRead; bool result = UnsafeNativeMethods.ReadFile(m_ComPortHandle, bufPtr, bufLen, out bufRead, ref overlap); int w32err = Marshal.GetLastWin32Error(); int hr = Marshal.GetHRForLastWin32Error(); if (SerialTrace.TraceSer.Switch.ShouldTrace(System.Diagnostics.TraceEventType.Verbose)) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Verbose, 0, "{0}: SerialThread: DoReadEvent: ReadFile({1}, {2}, {3}) == {4}", m_Name, m_ComPortHandle.DangerousGetHandle(), bufPtr, bufLen, result); } if (!result) { if (w32err == WinError.ERROR_OPERATION_ABORTED) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Information, 0, "{0}: SerialThread: DoReadEvent: ReadFile() error {1}", m_Name, w32err); return(false); } if (w32err != WinError.ERROR_IO_PENDING) { SerialTrace.TraceSer.TraceEvent(System.Diagnostics.TraceEventType.Error, 0, "{0}: SerialThread: DoReadEvent: ReadFile() error {1}", m_Name, w32err); // In case an unexpected error occurs here, we kill the thread and indicate an error. // One reason for this happening is a device error, or the device is removed from the // system. Marshal.ThrowExceptionForHR(hr); } } else { // MS Documentation for ReadFile() says that the 'bufRead' parameter should be NULL. // However, in the case that the COMMTIMEOUTS is set up so that no wait is required // (see COMMTIMEOUTS in Win32 API), this function will actually not perform an // asynchronous I/O operation and return the number of bytes copied in bufRead. ProcessReadEvent(bufRead); } return(!result); }
Create(string fileName, MapProtection protection, long maxSize, String name) { MemoryMappedFile map = new MemoryMappedFile(); if (!map.Is64bit && maxSize > uint.MaxValue) { throw new ConstraintException("32bit systems support max size of 4gb."); } // open file first IntPtr hFile = INVALID_HANDLE_VALUE; if (!string.IsNullOrEmpty(fileName)) { if (maxSize == 0) { if (!File.Exists(fileName)) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" does not exist ==> Unable to map entire file", fileName)); } FileInfo backingFileInfo = new FileInfo(fileName); maxSize = backingFileInfo.Length; if (maxSize == 0) { throw new Exception(string.Format("Winterdom.IO.FileMap.MemoryMappedFile.Create - \"{0}\" is zero bytes ==> Unable to map entire file", fileName)); } } // determine file access needed // we'll always need generic read access int desiredAccess = GENERIC_READ; if ((protection == MapProtection.PageReadWrite) || (protection == MapProtection.PageWriteCopy)) { desiredAccess |= GENERIC_WRITE; } // open or create the file // if it doesn't exist, it gets created hFile = Win32MapApis.CreateFile( fileName, desiredAccess, 0, IntPtr.Zero, OPEN_ALWAYS, 0, IntPtr.Zero ); if (hFile == INVALID_HANDLE_VALUE) { throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); } map._fileName = fileName; } map._hMap = Win32MapApis.CreateFileMapping( hFile, IntPtr.Zero, (int)protection, (int)((maxSize >> 32) & 0xFFFFFFFF), (int)(maxSize & 0xFFFFFFFF), name ); // close file handle, we don't need it if (hFile != INVALID_HANDLE_VALUE) { Win32MapApis.CloseHandle(hFile); } if (map._hMap == NULL_HANDLE) { throw new FileMapIOException(Marshal.GetHRForLastWin32Error()); } map._protection = protection; map._maxSize = maxSize; return(map); }
protected override void CreateDeviceDependentResources() { _dxgiFactory = CreateDxgiFactory(); _dxgiAdapter = GetDxgiAdapter(); _d3dDevice = CreateD3DDevice(); StartInfoPump(); _commandQueue = CreateCommandQueue(); CreateDescriptorHeaps(); for (int i = 0; i < FrameCount; i++) { _commandAllocators[i] = CreateCommandAllocator(); } _fence = CreateFence(); _fenceValues = CreateFenceValues(); _fenceEvent = CreateFenceEvent(); _rootSignature = CreateRootSignature(); _pipelineState = CreatePipelineState(); _graphicsCommandLists = CreateGraphicsCommandLists(); SilkMarshal.ThrowHResult(CommandAllocator->Reset()); SilkMarshal.ThrowHResult(GraphicsCommandList->Reset(CommandAllocator, PipelineState)); CreateAssets(); ID3D12CommandAllocator *CreateCommandAllocator() { ID3D12CommandAllocator *commandAllocator; var iid = ID3D12CommandAllocator.Guid; SilkMarshal.ThrowHResult ( D3DDevice->CreateCommandAllocator (CommandListType.CommandListTypeDirect, &iid, (void **)&commandAllocator) ); return(commandAllocator); } ID3D12CommandQueue *CreateCommandQueue() { var queueDesc = new CommandQueueDesc(); ID3D12CommandQueue *commandQueue; var iid = ID3D12CommandQueue.Guid; SilkMarshal.ThrowHResult(D3DDevice->CreateCommandQueue(&queueDesc, &iid, (void **)&commandQueue)); return(commandQueue); } ID3D12Device *CreateD3DDevice() { ID3D12Device *d3dDevice; var iid = ID3D12Device.Guid; SilkMarshal.ThrowHResult ( D3D12.CreateDevice ((IUnknown *)_dxgiAdapter, D3DFeatureLevel.D3DFeatureLevel110, &iid, (void **)&d3dDevice) ); return(d3dDevice); } IDXGIFactory4 *CreateDxgiFactory() { var dxgiFactoryFlags = TryEnableDebugLayer() ? 0x01 : 0u; IDXGIFactory4 *dxgiFactory; var iid = IDXGIFactory4.Guid; SilkMarshal.ThrowHResult(Dxgi.CreateDXGIFactory2(dxgiFactoryFlags, &iid, (void **)&dxgiFactory)); return(dxgiFactory); } ID3D12Fence *CreateFence() { ID3D12Fence *fence; var iid = ID3D12Fence.Guid; SilkMarshal.ThrowHResult (D3DDevice->CreateFence(InitialValue: 0, FenceFlags.FenceFlagNone, &iid, (void **)&fence)); return(fence); } IntPtr CreateFenceEvent() { var fenceEvent = SilkMarshal.CreateWindowsEvent(null, false, false, null); if (fenceEvent == IntPtr.Zero) { var hr = Marshal.GetHRForLastWin32Error(); Marshal.ThrowExceptionForHR(hr); } return(fenceEvent); } ulong[] CreateFenceValues() { var fenceValues = new ulong[FrameCount]; fenceValues[0] = 1; return(fenceValues); } ID3D12GraphicsCommandList *[] CreateGraphicsCommandLists() { var graphicsCommandLists = new ID3D12GraphicsCommandList *[FrameCount]; for (uint i = 0u; i < FrameCount; i++) { ID3D12GraphicsCommandList *graphicsCommandList; var iid = ID3D12GraphicsCommandList.Guid; SilkMarshal.ThrowHResult ( D3DDevice->CreateCommandList ( nodeMask: 0, CommandListType.CommandListTypeDirect, _commandAllocators[i], PipelineState, &iid, (void **)&graphicsCommandList ) ); SilkMarshal.ThrowHResult(graphicsCommandList->Close()); graphicsCommandLists[i] = graphicsCommandList; } return(graphicsCommandLists); } IDXGIAdapter1 *GetDxgiAdapter() { if (UseWarpDevice) { IDXGIAdapter1 *adapter; var iid = IDXGIAdapter.Guid; SilkMarshal.ThrowHResult(_dxgiFactory->EnumWarpAdapter(&iid, (void **)&adapter)); return(adapter); } else { return(GetHardwareAdapter((IDXGIFactory1 *)_dxgiFactory)); } } bool TryEnableDebugLayer() { #if DEBUG // Enable the debug layer (requires the Graphics Tools "optional feature"). // NOTE: Enabling the debug layer after device creation will invalidate the active device. using ComPtr <ID3D12Debug> debugController = null; var iid = ID3D12Debug.Guid; var hr = D3D12.GetDebugInterface(&iid, (void **)&debugController); if (HResult.IndicatesSuccess(hr)) { debugController.Get().EnableDebugLayer(); Log.LogInformation("Debug layer enabled"); return(_debug = true); } else { Log.LogWarning ( Marshal.GetExceptionForHR(hr), $"Failed to enable debug layer, failed with result {hr} (0x{hr:x8})" ); } #endif return(false); } void StartInfoPump() { #if DEBUG if (!_debug) { Log.LogInformation("Skipped creation of info pump due to the debug layer not being enabled."); return; } var iid = ID3D12InfoQueue.Guid; fixed(ID3D12InfoQueue ** @out = &_infoQueue) { SilkMarshal.ThrowHResult(D3DDevice->QueryInterface(&iid, (void **)@out)); } _infoPumpCancellationToken = new(); _infoPump = Task.Run ( () => { Log.LogInformation("Info queue pump started"); while (!_infoPumpCancellationToken.Token.IsCancellationRequested) { var numMessages = _infoQueue->GetNumStoredMessages(); if (numMessages == 0) { continue; } for (var i = 0ul; i < numMessages; i++) { nuint msgByteLength; SilkMarshal.ThrowHResult(_infoQueue->GetMessageA(i, null, &msgByteLength)); using var memory = GlobalMemory.Allocate((int)msgByteLength); SilkMarshal.ThrowHResult ( _infoQueue->GetMessageA(i, memory.AsPtr <Message>(), &msgByteLength) ); ref var msg = ref memory.AsRef <Message>(); var descBytes = new Span <byte>(msg.PDescription, (int)msg.DescriptionByteLength); var desc = Encoding.UTF8.GetString(descBytes[..^ 1]); var eid = new EventId((int)msg.ID, msg.ID.ToString()["MessageID".Length..]);
public int QueryContextMenu(IntPtr hMenu, uint iMenu, uint idCmdFirst, uint idCmdLast, uint uFlags) { if (((uint)CMF.CMF_DEFAULTONLY & uFlags) != 0) { return(WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, 0)); } #region Initialize Command List //this counter keep track of the # of commands uint idCommand = 0; this.Command = new Dictionary <uint, string>(); #endregion #region Create Command Separator Menu Item //Menu Item can be added multiple time, so we only need one separator menuitem MENUITEMINFO miiSeparator = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsSeparator(ref miiSeparator); #endregion bool onlyFolder = this.CheckOnlyFolder(); #region Create Main Menu (Explorer Extender) //this counter keep track of the position in menu MainMenu uint iPosition_Menu_Main = 0; IntPtr h_Menu_Main = NativeMethods.CreatePopupMenu(); MENUITEMINFO mii_Menu_Main = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsSubMenu(ref mii_Menu_Main, h_Menu_Main, "Explorer Extender", IntPtr.Zero); if (!NativeMethods.InsertMenuItem(hMenu, iMenu, true, ref mii_Menu_Main)) { return(Marshal.GetHRForLastWin32Error()); } #endregion #region Add MenuItem (Break Folder) if (!this.isClickedOnEmptyArea && onlyFolder) { MENUITEMINFO miiBreakFolder = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiBreakFolder, idCmdFirst + idCommand, this.SelectedItems.Count == 1 ? "Break Folder" : "Break Folders", this.hIconUngroup); if (!NativeMethods.InsertMenuItem(h_Menu_Main, iPosition_Menu_Main++, true, ref miiBreakFolder)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "Break"); } #endregion #region Add MenuItem (Group into new folder) if (!this.isClickedOnEmptyArea) { MENUITEMINFO miiBuildFolder = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiBuildFolder, idCmdFirst + idCommand, "Group", this.hIconGroup); if (!NativeMethods.InsertMenuItem(h_Menu_Main, iPosition_Menu_Main++, true, ref miiBuildFolder)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "Build"); } #endregion #region Add Separator if (!this.isClickedOnEmptyArea) { if (!NativeMethods.InsertMenuItem(h_Menu_Main, iPosition_Menu_Main++, true, ref miiSeparator)) { return(Marshal.GetHRForLastWin32Error()); } } #endregion if (!this.isClickedOnEmptyArea) { #region Create Submenu (Rename) //this counter keep track of the position in menu MainMenu uint iPosition_Menu_Rename = 0; IntPtr h_Menu_Rename = NativeMethods.CreatePopupMenu(); MENUITEMINFO mii_Menu_Rename = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsSubMenu(ref mii_Menu_Rename, h_Menu_Rename, "Rename", this.hIconRename); if (!NativeMethods.InsertMenuItem(h_Menu_Main, iPosition_Menu_Main++, true, ref mii_Menu_Rename)) { return(Marshal.GetHRForLastWin32Error()); } #endregion #region Add MenuItem (Search & Replace) MENUITEMINFO miiReplace = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiReplace, idCmdFirst + idCommand, "Search and Replace", this.hIconReplace); if (!NativeMethods.InsertMenuItem(h_Menu_Rename, iPosition_Menu_Rename++, true, ref miiReplace)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "Replace"); #endregion #region Add MenuItem (URL Decode) MENUITEMINFO miiUrlEncode = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiUrlEncode, idCmdFirst + idCommand, "Url Decode", this.hIconUrl); if (!NativeMethods.InsertMenuItem(h_Menu_Rename, iPosition_Menu_Rename++, true, ref miiUrlEncode)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "UrlDecode"); #endregion #region Add MenuItem (Html Decode) MENUITEMINFO miiHtmlEncode = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiHtmlEncode, idCmdFirst + idCommand, "Html Decode", this.hIconHtml); if (!NativeMethods.InsertMenuItem(h_Menu_Rename, iPosition_Menu_Rename++, true, ref miiHtmlEncode)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "HtmlDecode"); #endregion } #region Create Submenu (File Mover) uint iPosition_Menu_FileMover = 0; IntPtr h_Menu_FileMover = NativeMethods.CreatePopupMenu(); MENUITEMINFO mii_Menu_FileMover = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsSubMenu(ref mii_Menu_FileMover, h_Menu_FileMover, "File Mover", IntPtr.Zero); if (!NativeMethods.InsertMenuItem(h_Menu_Main, iPosition_Menu_Main++, true, ref mii_Menu_FileMover)) { return(Marshal.GetHRForLastWin32Error()); } #endregion int fileCount = FileMover.GetListCount(); #region Add MenuItem (Move File) if (CheckOnlyOneFolder() && fileCount > 0) { MENUITEMINFO miiFileMoverMove = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiFileMoverMove, idCmdFirst + idCommand, fileCount == 1 ? "Move File Here" : "Move Files here", IntPtr.Zero); if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref miiFileMoverMove)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "FileMoverMove"); if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref miiSeparator)) { return(Marshal.GetHRForLastWin32Error()); } } #endregion #region Add MenuItem (Add to List) MENUITEMINFO miiFileMoverAdd = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiFileMoverAdd, idCmdFirst + idCommand, "Add to list", this.hIconAdd); if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref miiFileMoverAdd)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "FileMoverAdd"); #endregion #region Add MenuItem (Clear List) if (fileCount > 0) { MENUITEMINFO miiFileMoverClear = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref miiFileMoverClear, idCmdFirst + idCommand, "Clear List", this.hIconDelete); if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref miiFileMoverClear)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, "FileMoverClear"); } #endregion if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref miiSeparator)) { return(Marshal.GetHRForLastWin32Error()); } var fileList = FileMover.GetList(); #region Add MenuItem (Remove File From List) foreach (var i in fileList) { MENUITEMINFO mii_MenuItem_Remove = new MENUITEMINFO(); Helper.InitializeMenuitemInfoAsMenuItem(ref mii_MenuItem_Remove, idCmdFirst + idCommand, i, this.hIconTrash); if (!NativeMethods.InsertMenuItem(h_Menu_FileMover, iPosition_Menu_FileMover++, true, ref mii_MenuItem_Remove)) { return(Marshal.GetHRForLastWin32Error()); } this.Command.Add(idCommand++, i); } #endregion return(WinError.MAKE_HRESULT(WinError.SEVERITY_SUCCESS, 0, idCommand)); }
public byte[] Export(X509ContentType contentType, SafePasswordHandle password) { Debug.Assert(password != null); switch (contentType) { case X509ContentType.Cert: { SafeCertContextHandle pCertContext = null; if (!Interop.crypt32.CertEnumCertificatesInStore(_certStore, ref pCertContext)) { return(null); } try { unsafe { byte[] rawData = new byte[pCertContext.CertContext->cbCertEncoded]; Marshal.Copy((IntPtr)(pCertContext.CertContext->pbCertEncoded), rawData, 0, rawData.Length); GC.KeepAlive(pCertContext); return(rawData); } } finally { pCertContext.Dispose(); } } case X509ContentType.SerializedCert: { SafeCertContextHandle pCertContext = null; if (!Interop.crypt32.CertEnumCertificatesInStore(_certStore, ref pCertContext)) { return(null); } try { int cbEncoded = 0; if (!Interop.crypt32.CertSerializeCertificateStoreElement(pCertContext, 0, null, ref cbEncoded)) { throw Marshal.GetHRForLastWin32Error().ToCryptographicException(); } byte[] pbEncoded = new byte[cbEncoded]; if (!Interop.crypt32.CertSerializeCertificateStoreElement(pCertContext, 0, pbEncoded, ref cbEncoded)) { throw Marshal.GetHRForLastWin32Error().ToCryptographicException(); } return(pbEncoded); } finally { pCertContext.Dispose(); } } case X509ContentType.Pkcs12: { unsafe { CRYPTOAPI_BLOB dataBlob = new CRYPTOAPI_BLOB(0, (byte *)null); if (!Interop.crypt32.PFXExportCertStore(_certStore, ref dataBlob, password, PFXExportFlags.EXPORT_PRIVATE_KEYS | PFXExportFlags.REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY)) { throw Marshal.GetHRForLastWin32Error().ToCryptographicException(); } byte[] pbEncoded = new byte[dataBlob.cbData]; fixed(byte *ppbEncoded = pbEncoded) { dataBlob.pbData = ppbEncoded; if (!Interop.crypt32.PFXExportCertStore(_certStore, ref dataBlob, password, PFXExportFlags.EXPORT_PRIVATE_KEYS | PFXExportFlags.REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY)) { throw Marshal.GetHRForLastWin32Error().ToCryptographicException(); } } return(pbEncoded); } } case X509ContentType.SerializedStore: return(SaveToMemoryStore(CertStoreSaveAs.CERT_STORE_SAVE_AS_STORE)); case X509ContentType.Pkcs7: return(SaveToMemoryStore(CertStoreSaveAs.CERT_STORE_SAVE_AS_PKCS7)); default: throw new CryptographicException(SR.Cryptography_X509_InvalidContentType); } }
public void Run(string WsdlUrl, string FileName, string PathName) { try { if (WsdlUrl.Length <= 0 || FileName.Length <= 0) { return; } wsdlurl = WsdlUrl; filename = PathName + FileName; pathname = PathName; NativeMethods.OpenThreadToken(NativeMethods.GetCurrentThread(), TOKEN_IMPERSONATE, true, ref threadtoken); int err = Marshal.GetLastWin32Error(); if (err != Util.ERROR_SUCCESS && err != Util.ERROR_NO_TOKEN) { throw new COMException(Resource.FormatString("Err_OpenThreadToken"), Marshal.GetHRForLastWin32Error()); } thisthread.Start(); thisthread.Join(); if (ExceptionThrown == true) { throw SavedException; } } catch (Exception e) { ComSoapPublishError.Report(e.ToString()); throw; } }
public void SetKeysMatrix(byte index) { byte[] lpBuffer = new byte[70]; for (int index1 = 0; index1 < 70; ++index1) { lpBuffer[index1] = (byte)0; } lpBuffer[1] = (byte)18; lpBuffer[2] = (byte)0; lpBuffer[3] = index; lpBuffer[4] = (byte)8; lpBuffer[5] = (byte)0; lpBuffer[8] = (byte)0; for (int index1 = 1; index1 <= 7; ++index1) { lpBuffer[8] = (byte)((uint)lpBuffer[8] + (uint)lpBuffer[index1]); } lpBuffer[8] = (byte)((uint)byte.MaxValue - (uint)lpBuffer[8]); Win32.HidD_SetFeature(_deviceHandle_2016, ref lpBuffer[0], 9); Thread.Sleep(65); uint lpNumberOfBytesWritten = 0; for (int index1 = 0; index1 < 70; ++index1) { lpBuffer[index1] = (byte)0; } int num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 64]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 128]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 192]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 256]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 320]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 384]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); lpBuffer[0] = (byte)0; num = 0; for (int index1 = 0; index1 < 64; ++index1) { lpBuffer[index1 + 1] = PictureMatrix[index1 + 448]; } if (!Win32.WriteFile(_deviceHandle_2016, lpBuffer, 65U, ref lpNumberOfBytesWritten, IntPtr.Zero)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } Thread.Sleep(100); }
/// <summary> /// A window /// </summary> /// <returns></returns> public static bool IsUserAnAdministrator() { var identity = WindowsIdentity.GetCurrent(); if (identity == null) { throw new WardenException("Unable to get the current user identity."); } var principal = new WindowsPrincipal(identity); // Check if this user has the Administrator role. If they do, return immediately. // If UAC is on, and the process is not elevated, then this will actually return false. if (principal.IsInRole(WindowsBuiltInRole.Administrator)) { return(true); } // If we're not running in Vista onwards, we don't have to worry about checking for UAC. // While Rainway is Windows 10 only, we need a solution that works for all users given this library is public. if (Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major < 6) { // Operating system does not support UAC; skipping elevation check. return(false); } var tokenInfLength = Marshal.SizeOf(typeof(int)); var tokenInformation = Marshal.AllocHGlobal(tokenInfLength); try { var token = identity.Token; var result = GetTokenInformation(token, TokenInformationClass.TokenElevationType, tokenInformation, tokenInfLength, out tokenInfLength); if (!result) { var exception = Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); throw new WardenException("Unable to retrieve token information", exception); } var elevationType = (TokenElevationType)Marshal.ReadInt32(tokenInformation); switch (elevationType) { case TokenElevationType.TokenElevationTypeDefault: // TokenElevationTypeDefault - User is not using a split token, so they cannot elevate. return(false); case TokenElevationType.TokenElevationTypeFull: // TokenElevationTypeFull - User has a split token, and the process is running elevated. Assuming they're an administrator. return(true); case TokenElevationType.TokenElevationTypeLimited: // TokenElevationTypeLimited - User has a split token, but the process is not running elevated. Assuming they're an administrator. return(true); default: // Unknown token elevation type. return(false); } } finally { if (tokenInformation != IntPtr.Zero) { Marshal.FreeHGlobal(tokenInformation); } } }
public static IEnumerable <UsbSerialDevice> EnumerateDevices(bool presentOnly = true) { var hDevInfoSet = NativeMethods.SetupDiGetClassDevs( ref NativeMethods.GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR, null, IntPtr.Zero, presentOnly ? NativeMethods.DiGetClassFlags.DIGCF_PRESENT : 0); if (hDevInfoSet.ToInt64() == NativeMethods.INVALID_HANDLE_VALUE) { yield break; } try { var devInfoData = new NativeMethods.DevInfoData { CbSize = (uint)Marshal.SizeOf <NativeMethods.DevInfoData>() }; for (uint i = 0; NativeMethods.SetupDiEnumDeviceInfo(hDevInfoSet, i, ref devInfoData); i++) { var id = GetDeviceIds(hDevInfoSet, devInfoData); var device = new UsbSerialDevice { PortName = GetPortName(hDevInfoSet, devInfoData), FriendlyName = GetFriendlyName(hDevInfoSet, devInfoData), Description = GetDescription(hDevInfoSet, devInfoData), Vid = id.ContainsKey("VID") ? (int?)int.Parse(id["VID"], System.Globalization.NumberStyles.HexNumber) : null, Pid = id.ContainsKey("PID") ? (int?)int.Parse(id["PID"], System.Globalization.NumberStyles.HexNumber) : null, Rev = id.ContainsKey("REV") ? (int?)int.Parse(id["REV"], System.Globalization.NumberStyles.HexNumber) : null, }; yield return(device); } if (Marshal.GetLastWin32Error() != NativeMethods.NO_ERROR && Marshal.GetLastWin32Error() != NativeMethods.ERROR_NO_MORE_ITEMS) { throw new Win32Exception(Marshal.GetLastWin32Error(), $"Failed to enumerate USB serial devices. Error: [{Marshal.GetLastWin32Error()}] HR: [{Marshal.GetHRForLastWin32Error()}]"); } } finally { NativeMethods.SetupDiDestroyDeviceInfoList(hDevInfoSet); } }
public void Dump(int pid, DumpType dumpType, IntPtr exceptionParam, string fileName, bool writeAsync = false, string dumpComment = null) { _pid = pid; _dumpType = dumpType; _spillSegmentsAsynchronously = writeAsync; dumpComment = dumpComment ?? ("DumpWriter: " + _dumpType.ToString()); IntPtr hProcess = DumpNativeMethods.OpenProcess( ProcessAccessFlags.QueryInformation | ProcessAccessFlags.VirtualMemoryRead | ProcessAccessFlags.DuplicateHandle, false, (uint)_pid ); if (hProcess == IntPtr.Zero) { throw new ArgumentException(String.Format("Unable to open process {0}, error {1:x8}", _pid, Marshal.GetLastWin32Error())); } _dumpFileStream = new FileStream(fileName, FileMode.Create); var userStreamParam = PrepareUserStream(dumpComment); var callbackParam = new MINIDUMP_CALLBACK_INFORMATION(); _needMemoryCallbacks = ( _dumpType == DumpType.FullMemoryExcludingSafeRegions || _dumpType == DumpType.MinimalWithFullCLRHeap ); if (_needMemoryCallbacks || _spillSegmentsAsynchronously) { callbackParam.CallbackRoutine = CallbackRoutine; } MINIDUMP_TYPE nativeDumpType = (_dumpType == DumpType.FullMemory || _dumpType == DumpType.FullMemoryExcludingSafeRegions) ? MINIDUMP_TYPE.MiniDumpWithFullMemory | MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo : MINIDUMP_TYPE.MiniDumpWithHandleData | MINIDUMP_TYPE.MiniDumpWithFullMemoryInfo; Stopwatch sw = Stopwatch.StartNew(); bool success = DumpNativeMethods.MiniDumpWriteDump( hProcess, (uint)_pid, _dumpFileStream.SafeFileHandle.DangerousGetHandle(), nativeDumpType, exceptionParam, ref userStreamParam, ref callbackParam); if (!success) { throw new ApplicationException(string.Format("Error writing dump, error: {0}", Marshal.GetExceptionForHR( Marshal.GetHRForLastWin32Error()))); } _logger.WriteLine("Process was suspended for {0:N2}ms", sw.Elapsed.TotalMilliseconds); if (_spillSegmentsAsynchronously) { // We are asynchronously spilling dump segments to disk, need to wait // for this process to complete before returning to the caller. _segmentSpillingTask.Wait(); _logger.WriteLine( "Total dump writing time including async flush was {0:N2}ms", sw.Elapsed.TotalMilliseconds); } userStreamParam.Delete(); DumpNativeMethods.CloseHandle(hProcess); _dumpFileStream.Close(); }
private static void ThrowExceptionForLastWin32Error() { throw new HResultException(Marshal.GetHRForLastWin32Error()); }
private static void ThrowExceptionForLastError() { int hr = Marshal.GetHRForLastWin32Error(); Marshal.ThrowExceptionForHR(hr); }
public Hardware() { using (BinaryWriter binaryWriter = new BinaryWriter(new MemoryStream())) { if (ProtectLoader.Debug) { UnityEngine.Debug.Log(Class3.smethod_10(12)); } string[] array = Hardware.smethod_2(Hardware.BiosFirmwareTableProvider.RSMB); if (array.Length != 0) { byte[] array2 = Hardware.smethod_0(Hardware.BiosFirmwareTableProvider.RSMB, array[0]); int num = array2.Length; if (num != 0) { if (num > 1024) { num = 1024; } binaryWriter.Write(array2, 0, num); if (ProtectLoader.Debug) { UnityEngine.Debug.Log(Class3.smethod_10(68)); } byte[] array3 = new byte[] { 85, 137, 229, 87, 139, 125, 16, 106, 1, 88, 83, 15, 162, 137, 7, 137, 87, 4, 91, 95, 137, 236, 93, 194, 16, 0 }; byte[] array4 = new byte[] { 83, 72, 199, 192, 1, 0, 0, 0, 15, 162, 65, 137, 0, 65, 137, 80, 4, 91, 195 }; byte[] array5 = new byte[8]; byte[] array6; if (IntPtr.Size == 8) { array6 = array4; } else { array6 = array3; } IntPtr intPtr = new IntPtr(array6.Length); int num2; if (!Hardware.Class1.VirtualProtect(array6, intPtr, 64, out num2)) { Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error()); } intPtr = new IntPtr(array5.Length); if (!(Hardware.Class1.CallWindowProcW(array6, IntPtr.Zero, 0, array5, intPtr) == IntPtr.Zero)) { if (ProtectLoader.Debug) { UnityEngine.Debug.Log(Class3.smethod_10(118)); } binaryWriter.Write(SystemInfo.deviceName); binaryWriter.Write(SystemInfo.deviceModel); binaryWriter.Write(SystemInfo.graphicsDeviceName); binaryWriter.Write(SystemInfo.graphicsDeviceID); binaryWriter.Write(SystemInfo.graphicsDeviceVendorID); binaryWriter.Write(SystemInfo.graphicsMemorySize); if (ProtectLoader.Debug) { UnityEngine.Debug.Log(Class3.smethod_10(166)); } binaryWriter.BaseStream.Seek(0L, SeekOrigin.Begin); Hardware.byte_0 = new MD5CryptoServiceProvider().ComputeHash(binaryWriter.BaseStream); binaryWriter.BaseStream.Seek(0L, SeekOrigin.Begin); Hardware.byte_1 = new SHA1CryptoServiceProvider().ComputeHash(binaryWriter.BaseStream); binaryWriter.BaseStream.Seek(0L, SeekOrigin.Begin); Hardware.byte_2 = new SHA256CryptoServiceProvider().ComputeHash(binaryWriter.BaseStream); binaryWriter.BaseStream.Seek(0L, SeekOrigin.Begin); Hardware.byte_3 = new SHA512CryptoServiceProvider().ComputeHash(binaryWriter.BaseStream); if (ProtectLoader.Debug) { UnityEngine.Debug.Log(Class3.smethod_10(214)); } } } } } }
async Task CheckForUpdates() { try { // Remove any old ClickOnce installs try { var uninstallInfo = UninstallInfo.Find("IPFilter Updater"); if (uninstallInfo != null) { Trace.TraceWarning("Old ClickOnce app installed! Trying to remove..."); var uninstaller = new Uninstaller(); uninstaller.Uninstall(uninstallInfo); Trace.TraceInformation("Successfully removed ClickOnce app"); } } catch (Exception ex) { Trace.TraceError("Failed to remove old ClickOnce app: " + ex); telemetryClient?.TrackException(ex); } Trace.TraceInformation("Checking for software updates..."); progress.Report(new ProgressModel(UpdateState.Downloading, "Checking for software updates...", -1)); var updater = new Updater(); var result = await updater.CheckForUpdateAsync(); var currentVersion = new Version(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion); var latestVersion = new Version(result.Version); Update.IsUpdateAvailable = latestVersion > currentVersion; if (Update.IsUpdateAvailable) { Update.AvailableVersion = latestVersion; Update.IsUpdateRequired = true; Update.MinimumRequiredVersion = latestVersion; Update.UpdateSizeBytes = 2000000; } Trace.TraceInformation("Current version: {0}", Update.CurrentVersion); Trace.TraceInformation("Available version: {0}", Update.AvailableVersion?.ToString() ?? "<no updates>"); if (!Update.IsUpdateAvailable) { return; } if (MessageBoxHelper.Show(dispatcher, "Update Available", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.Yes, "An update to version {0} is available. Would you like to update now?", Update.AvailableVersion) != MessageBoxResult.Yes) { return; } Trace.TraceInformation("Starting application update..."); // If we're not "installed", then don't check for updates. This is so the // executable can be stand-alone. Stand-alone self-update to come later. using (var key = Registry.CurrentUser.OpenSubKey("SOFTWARE\\IPFilter")) { var installPath = (string)key?.GetValue("InstallPath"); if (installPath == null) { using (var process = new Process()) { process.StartInfo = new ProcessStartInfo("https://davidmoore.github.io/ipfilter/") { UseShellExecute = true }; process.Start(); return; } } } var msiPath = Path.Combine(Path.GetTempPath(), "IPFilter.msi"); // Download the installer using (var handler = new WebRequestHandler()) { handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; var uri = new Uri($"{result.Uri}?{DateTime.Now.ToString("yyyyMMddHHmmss")}"); using (var httpClient = new HttpClient(handler)) using (var response = await httpClient.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken.Token)) { if (cancellationToken.IsCancellationRequested) { progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100)); Update.IsUpdating = false; return; } var length = response.Content.Headers.ContentLength; double lengthInMb = !length.HasValue ? -1 : (double)length.Value / 1024 / 1024; double bytesDownloaded = 0; using (var stream = await response.Content.ReadAsStreamAsync()) using (var msi = File.Open(msiPath, FileMode.Create, FileAccess.Write, FileShare.Read)) { var buffer = new byte[65535 * 4]; int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token); while (bytesRead != 0) { await msi.WriteAsync(buffer, 0, bytesRead, cancellationToken.Token); bytesDownloaded += bytesRead; if (length.HasValue) { double downloadedMegs = bytesDownloaded / 1024 / 1024; var percent = (int)Math.Floor((bytesDownloaded / length.Value) * 100); var status = string.Format(CultureInfo.CurrentUICulture, "Downloaded {0:F2} MB of {1:F2} MB", downloadedMegs, lengthInMb); Update.IsUpdating = true; Update.DownloadPercentage = percent; progress.Report(new ProgressModel(UpdateState.Downloading, status, percent)); } if (cancellationToken.IsCancellationRequested) { progress.Report(new ProgressModel(UpdateState.Ready, "Update cancelled. Ready.", 100)); Update.IsUpdating = false; return; } bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken.Token); } } } } progress.Report(new ProgressModel(UpdateState.Ready, "Launching update...", 100)); Update.IsUpdating = false; // Now run the installer var sb = new StringBuilder("msiexec.exe "); // Enable logging for the installer sb.AppendFormat(" /l*v \"{0}\"", Path.Combine(Path.GetTempPath(), "IPFilter.log")); sb.AppendFormat(" /i \"{0}\"", msiPath); //sb.Append(" /passive"); ProcessInformation processInformation = new ProcessInformation(); StartupInfo startupInfo = new StartupInfo(); SecurityAttributes processSecurity = new SecurityAttributes(); SecurityAttributes threadSecurity = new SecurityAttributes(); processSecurity.nLength = Marshal.SizeOf(processSecurity); threadSecurity.nLength = Marshal.SizeOf(threadSecurity); const int NormalPriorityClass = 0x0020; if (!ProcessManager.CreateProcess(null, sb, processSecurity, threadSecurity, false, NormalPriorityClass, IntPtr.Zero, null, startupInfo, processInformation)) { throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); } try { //dispatcher.Invoke(DispatcherPriority.Normal, new Action(Application.Current.Shutdown)); Application.Current.Shutdown(); } catch (Exception ex) { Trace.TraceError("Exception when shutting down app for update: " + ex); Update.ErrorMessage = "Couldn't shutdown the app to apply update."; telemetryClient?.TrackException(ex); } } catch (Exception ex) { Trace.TraceWarning("Application update check failed: " + ex); telemetryClient?.TrackException(ex); telemetryClient?.Flush(); } finally { progress.Report(new ProgressModel(UpdateState.Ready, "Ready", 0)); } }
public static void ThrowWin32Exception(string message) { throw new Win32Exception(Marshal.GetLastWin32Error(), message + Environment.NewLine + "HResult: " + Marshal.GetHRForLastWin32Error()); }