private static readonly int BUF_LEN = 8192 + 8; //8 bytes for the leading USN #endregion Fields #region Methods public static bool Build_Volume_Mapping(SafeFileHandle roothandle, Win32Api.USN_JOURNAL_DATA currentUsnState, Action<Win32Api.UsnEntry> func) { Debug.WriteLine("Starting Build_Volume_Mapping"); DateTime startTime = DateTime.Now; Win32Api.MFT_ENUM_DATA med; med.StartFileReferenceNumber = 0; med.LowUsn = 0; med.HighUsn = currentUsnState.NextUsn; using(var med_struct = new StructWrapper(med)) using(var rawdata = new Raw_Array_Wrapper(BUF_LEN)) { uint outBytesReturned = 0; while(Win32Api.DeviceIoControl( roothandle.DangerousGetHandle(), Win32Api.FSCTL_ENUM_USN_DATA, med_struct.Ptr, med_struct.Size, rawdata.Ptr, rawdata.Size, out outBytesReturned, IntPtr.Zero)) { outBytesReturned = outBytesReturned - sizeof(Int64); IntPtr pUsnRecord = System.IntPtr.Add(rawdata.Ptr, sizeof(Int64));//need to skip 8 bytes because the first 8 bytes are to a usn number, which isnt in the structure while(outBytesReturned > 60) { var usnEntry = new Win32Api.UsnEntry(pUsnRecord); pUsnRecord = System.IntPtr.Add(pUsnRecord, (int)usnEntry.RecordLength); func(usnEntry); if(usnEntry.RecordLength > outBytesReturned) outBytesReturned = 0;// prevent overflow else outBytesReturned -= usnEntry.RecordLength; } Marshal.WriteInt64(med_struct.Ptr, Marshal.ReadInt64(rawdata.Ptr, 0));//read the usn that we skipped and place it into the nextusn } var possiblerror = Marshal.GetLastWin32Error(); if(possiblerror < 0) throw new Win32Exception(possiblerror); } Debug.WriteLine("Time took: " + (DateTime.Now - startTime).TotalMilliseconds + "ms"); return true; }
public int SetHook() { hProc = new Win32Api.HookProc(MouseHookProc); hHook = Win32Api.SetWindowsHookEx(WH_MOUSE_LL, hProc, IntPtr.Zero, 0); return(hHook); }
public UpdateContext GetUpdateContext() { var updateContext = new UpdateContext(); var directoryName = Path.GetDirectoryName(config.FullFileName); if (directoryName == null) { throw new InvalidOperationException("Couldn't get directory name that the app is running from"); } var directory = new DirectoryInfo(directoryName); // If the application is executing from the TEMP folder, then it's probably been executed from a .zip that has been // opened and temporarily extracted by Windows Explorer or 7-zip etc var isTempFolder = directoryName.StartsWith(Path.GetTempPath(), StringComparison.OrdinalIgnoreCase); // If the application is executing from the special Downloads folder, we can't really count it as "installed" // and it should probably be copied somewhere to be considered as installed and allowed to have shortcuts etc var downloadsFolder = Win32Api.GetKnownFolderPath(Win32Api.KnownFolders.Downloads, Win32Api.SpecialFolderOption.DoNotVerify); var isDownloadFolder = directoryName.StartsWith(downloadsFolder, StringComparison.OrdinalIgnoreCase); var filename = this.config.FileName; // We won't count as "installed" if we're running from temp or downloads updateContext.IsDeployed = !isTempFolder && !isDownloadFolder; // Check for in-place update of exe (.update.exe) var extensionless = Path.GetFileNameWithoutExtension(filename); if (extensionless.EndsWith(config.UpdateSuffix, StringComparison.OrdinalIgnoreCase)) { updateContext.IsUpdate = true; updateContext.PackageType = PackageType.Executable; updateContext.UpdateSource = new FileInfo(config.FullFileName); var destinationName = extensionless.Substring(0, extensionless.Length - config.UpdateSuffix.Length); updateContext.UpdateDestination = new FileInfo(Path.Combine(Path.GetDirectoryName(config.FullFileName), destinationName + ".exe")); return(updateContext); } // Check for archive update (update parent folder from extracted sub folder containing updates) if (Path.GetExtension(directoryName).Equals(config.UpdateSuffix)) { updateContext.IsUpdate = true; updateContext.PackageType = PackageType.Archive; updateContext.UpdateSource = directory; updateContext.UpdateDestination = directory.Parent; return(updateContext); } // Check if the app is executing from the TEMP folder, in which case it's been extracted // and executed from a zip file if (isTempFolder) { updateContext.IsUpdate = false; updateContext.IsDeployed = false; updateContext.PackageType = PackageType.Archive; updateContext.UpdateSource = directory; updateContext.UpdateDestination = new FileInfo(config.InstallPath); return(updateContext); } // Are we running from the Downloads folder? if (isDownloadFolder) { // If we're in a sub directory under Downloads then we can consider this an archive package (one or more files, in own folder) if (directory.Parent != null && directory.Parent.FullName.Equals(downloadsFolder, StringComparison.OrdinalIgnoreCase)) { updateContext.IsUpdate = true; updateContext.PackageType = PackageType.Archive; updateContext.UpdateSource = directory; updateContext.UpdateDestination = directory.Parent; } else { updateContext.IsUpdate = false; updateContext.PackageType = PackageType.Executable; updateContext.UpdateSource = new FileInfo(config.FullFileName); updateContext.UpdateDestination = new FileInfo(config.InstallPath); } return(updateContext); } return(null); }
/// <summary> /// Called when the user presses a key /// </summary> // ReSharper disable once RedundantAssignment public static bool KeyDownHandler(KeyEventArgs e) { // if set to true, the keyinput is completly intercepted, otherwise npp sill does its stuff bool handled = false; MenuItem menuItem = null; try { // Since it's a keydown message, we can receive this a lot if the user let a button pressed var isSpamming = Utils.IsSpamming(e.KeyCode.ToString(), 100, true); // check if the user triggered a 3P function defined in the AppliMenu menuItem = TriggeredMenuItem(AppliMenu.Instance.ShortcutableItemList, isSpamming, e, ref handled); if (handled) { return(true); } // Autocompletion if (AutoCompletion.IsVisible) { handled = AutoCompletion.PerformKeyDown(e); } // next tooltip if (!handled && InfoToolTip.IsVisible && e.Control && (e.KeyCode == Keys.Up || e.KeyCode == Keys.Down)) { if (e.KeyCode == Keys.Up) { InfoToolTip.IndexToShow--; } else { InfoToolTip.IndexToShow++; } InfoToolTip.TryToShowIndex(); handled = true; } if (handled) { return(true); } // Ok so... when we open a form in notepad++, we can't use the overrides PreviewKeyDown / KeyDown // like we normally can, for some reasons, they don't react to certain keys (like enter!) // It only works "almost normally" if we ShowDialog() the form?! // So i gave up and handle things here! // Each control / form that should use a key not handled by Npp should implement a method // "PerformKeyDown" that will be triggered from here (see below) var curControl = Win32Api.GetFocusedControl(); if (curControl != null) { var invokeResponse = curControl.InvokeMethod("PerformKeyDown", new[] { (object)e }); if (invokeResponse != null && (bool)invokeResponse) { return(true); } } var curWindow = Control.FromHandle(WinApi.GetForegroundWindow()); if (curWindow != null) { var invokeResponse = curWindow.InvokeMethod("PerformKeyDown", new[] { (object)e }); if (invokeResponse != null && (bool)invokeResponse) { return(true); } } // Close interfacePopups if (e.KeyCode == Keys.PageDown || e.KeyCode == Keys.PageUp || e.KeyCode == Keys.Next || e.KeyCode == Keys.Prior) { ClosePopups(); } } catch (Exception ex) { ErrorHandler.ShowErrors(ex, "Occurred in : " + (menuItem == null ? new ShortcutKey(e.Control, e.Alt, e.Shift, e.KeyCode).ToString() : menuItem.ItemId)); } return(handled); }
//-------------------------------------------------------------------------------------------------- public void SetWindowEnabled(bool bIsEnabled) { var hRefWnd = new HandleRef(this, new System.Windows.Interop.WindowInteropHelper(_TransparentInputWindow).Handle); Win32Api.EnableWindow(hRefWnd, bIsEnabled); }
internal static int FontSizeToHeight(int size, IntPtr hDc) { int devCap = Gdi32.GetDeviceCaps(hDc, LogPixels.LOGPIXELSY); return(-Win32Api.MulDiv(size, devCap, 72)); }
/// <summary> /// This message is used for your plugin's dockable dialog. S /// Send this message to update (redraw) the dialog. hDlg is the handle of your dialog to be updated /// </summary> public static void RedrawDialog(IntPtr handle) { Win32Api.SendMessage(Handle, NppMsg.NPPM_DMMUPDATEDISPINFO, 0, handle); }
private static string GetActualPath(NtfsUsnJournal journal, Win32Api.UsnEntry item) { string actualPath = null; string rawPath; var usnRtnCode = journal.GetPathFromFileReference(item.ParentFileReferenceNumber, out rawPath); if (usnRtnCode == NtfsUsnJournal.UsnJournalReturnCode.USN_JOURNAL_SUCCESS && 0 != String.Compare(rawPath, "Unavailable", StringComparison.OrdinalIgnoreCase)) { actualPath = $"{journal.MountPoint.TrimEnd('\\')}{rawPath.TrimEnd('\\')}\\{item.Name}"; } else { return actualPath; } if (actualPath.ToLowerInvariant().StartsWith($"{journal.MountPoint.TrimEnd('\\')}\\System Volume Information".ToLowerInvariant())) { return actualPath; } return actualPath; }
/// <summary> /// Reload given document /// </summary> public static void Reload(string path, bool askConfirmation) { Win32Api.SendMessage(Handle, NppMsg.NPPM_RELOADFILE, askConfirmation ? 1 : 0, path); }
/// <summary> /// Allows to execute one of Npp's command /// </summary> /// <param name="cmd"></param> public static void RunCommand(NppMenuCmd cmd) { Win32Api.SendMessage(Handle, NppMsg.NPPM_MENUCOMMAND, 0, cmd); }
/// <summary> /// Sending this message to get the current index in the view that you indicates in iView : MAIN_VIEW or SUB_VIEW /// Returned value is -1 if the view is invisible (hidden), otherwise is the current index /// </summary> public static int CurrentDocIndexInView(int view) { return(Win32Api.SendMessage(Handle, NppMsg.NPPM_GETCURRENTDOCINDEX, 0, view).ToInt32()); }
/// <summary> /// Use this message to set/remove the check on menu item. cmdID is the command ID which corresponds to the menu item. /// </summary> public static void SetMenuItemCheck(int cmdId, bool @checked) { Win32Api.SendMessage(Handle, NppMsg.NPPM_SETMENUITEMCHECK, cmdId, @checked); }
/// <summary> /// Send this message to hide the dialog. handle is the handle of your dialog to be hidden. /// </summary> public static void HideDockableDialog(IntPtr handle) { Win32Api.SendMessage(Handle, NppMsg.NPPM_DMMHIDE, 0, handle); }
/// <summary> /// Send this message to show the dialog. handle is the handle of your dialog to be shown /// </summary> public static void ShowDockableDialog(IntPtr handle) { Win32Api.SendMessage(Handle, NppMsg.NPPM_DMMSHOW, 0, handle); }
public static void QueryUsnJournal(SafeFileHandle roothandle, ref Win32Api.USN_JOURNAL_DATA usnJournalState) { int sizeUsnJournalState = Marshal.SizeOf(usnJournalState); UInt32 cb; if(!Win32Api.DeviceIoControl( roothandle.DangerousGetHandle(), Win32Api.FSCTL_QUERY_USN_JOURNAL, IntPtr.Zero, 0, out usnJournalState, sizeUsnJournalState, out cb, IntPtr.Zero)) { throw new Win32Exception(Marshal.GetLastWin32Error()); } }
public static void GetUsnJournalEntries(SafeFileHandle roothandle, Win32Api.USN_JOURNAL_DATA previousUsnState, UInt32 reasonMask, out List<Win32Api.UsnEntry> usnEntries, out Win32Api.USN_JOURNAL_DATA newUsnState) { usnEntries = new List<Win32Api.UsnEntry>(); newUsnState = new Win32Api.USN_JOURNAL_DATA(); QueryUsnJournal(roothandle, ref newUsnState); Win32Api.READ_USN_JOURNAL_DATA rujd = new Win32Api.READ_USN_JOURNAL_DATA(); rujd.StartUsn = previousUsnState.NextUsn; rujd.ReasonMask = reasonMask; rujd.ReturnOnlyOnClose = 0; rujd.Timeout = 0; rujd.bytesToWaitFor = 0; rujd.UsnJournalId = previousUsnState.UsnJournalID; using(var med_struct = new StructWrapper(rujd)) using(var rawdata = new Raw_Array_Wrapper(BUF_LEN)) { uint outBytesReturned = 0; var nextusn = previousUsnState.NextUsn; while(nextusn < newUsnState.NextUsn && Win32Api.DeviceIoControl( roothandle.DangerousGetHandle(), Win32Api.FSCTL_READ_USN_JOURNAL, med_struct.Ptr, med_struct.Size, rawdata.Ptr, rawdata.Size, out outBytesReturned, IntPtr.Zero)) { outBytesReturned = outBytesReturned - sizeof(Int64); IntPtr pUsnRecord = System.IntPtr.Add(rawdata.Ptr, sizeof(Int64));//point safe arithmetic!~!! while(outBytesReturned > 60) // while there are at least one entry in the usn journal { var usnEntry = new Win32Api.UsnEntry(pUsnRecord); if(usnEntry.USN > newUsnState.NextUsn) break; usnEntries.Add(usnEntry); pUsnRecord = System.IntPtr.Add(pUsnRecord, (int)usnEntry.RecordLength);//point safe arithmetic!~!! outBytesReturned -= usnEntry.RecordLength; } nextusn = Marshal.ReadInt64(rawdata.Ptr, 0); Marshal.WriteInt64(med_struct.Ptr, nextusn);//read the usn that we skipped and place it into the nextusn } } }
static bool RollBack(InstallInfo info) { // Unregister assembly foreach (string item in info.FilesToRegister) { string targetFilePath = Path.Combine(info.TargetPath, item); RegisterDLL(targetFilePath, false, true); RegisterDLL(targetFilePath, true, true); } // Delete files RestartExplorer restartExplorer = new RestartExplorer(); restartExplorer.Execute(() => { // Remove files foreach (string filename in info.FilesToCopy) { string targetFilePath = Path.Combine(info.TargetPath, filename); if (File.Exists(targetFilePath)) { Console.Write($"Deleting {filename}.. "); File.Delete(targetFilePath); Console.WriteLine("OK."); } } }); Console.Write($"Deleting {InstallerExecutableName}.. "); try { if (Win32Api.DeleteFile(Path.Combine(info.TargetPath, InstallerExecutableName))) { Console.WriteLine("OK."); } else { Win32Api.MoveFileEx(Path.Combine(info.TargetPath, InstallerExecutableName), null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT); Console.WriteLine("Scheduled for deletion after next reboot."); } } catch { Win32Api.MoveFileEx(Path.Combine(info.TargetPath, InstallerExecutableName), null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT); Console.WriteLine("Scheduled for deletion after next reboot."); } if (Directory.Exists(info.TargetPath)) { Console.Write("Deleting target directory.. "); try { Directory.Delete(info.TargetPath); Console.WriteLine("OK."); } catch { Win32Api.MoveFileEx(info.TargetPath, null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT); Console.WriteLine("Scheduled for deletion after next reboot."); } } Console.Write("Removing uninstall info from registry.. "); DeleteUninstaller(); Console.WriteLine("OK."); return(true); }
public NTFS_File(Win32Api.UsnEntry u) { Entry = u; Children = new List<NTFS_File>(); Parent = null; }
static void Main(string[] args) { try { if (args.Length < 2) { Console.WriteLine( "Command line syntax:\n\tfilter.exe index scenario \n\tindex - network interface index.\n\tscenario - sample set of filters to load.\n\tYou can use ListAdapters to determine correct index."); Console.WriteLine("Available Scenarios:"); Console.WriteLine("1 - Redirect only IPv4 DNS packets for processing in user mode."); Console.WriteLine("2 - Redirect only HTTP(TCP port 80) packets for processing in user mode. Both IPv4 and IPv6 protocols."); Console.WriteLine("3 - Drop all IPv4 ICMP packets. Redirect all other packets to user mode (default behaviour)."); Console.WriteLine("4 - Block IPv4 access to http://www.ntkernel.com. Pass all other packets without processing in user mode."); Console.WriteLine("5 - Redirect only ARP/RARP packets to user mode. Pass all others."); return; } var adapterIndex = uint.Parse(args[0]) - 1; var scena = uint.Parse(args[1]); var driverPtr = Ndisapi.OpenFilterDriver(); if (!Ndisapi.IsDriverLoaded(driverPtr)) { Console.WriteLine("Driver not installed on this system of failed to load."); return; } // Retrieve adapter list var adapters = new TCP_AdapterList(); Ndisapi.GetTcpipBoundAdaptersInfo(driverPtr, ref adapters); // Set tunnel mode for the selected network interface var mode = new ADAPTER_MODE { dwFlags = Ndisapi.MSTCP_FLAG_SENT_TUNNEL | Ndisapi.MSTCP_FLAG_RECV_TUNNEL, hAdapterHandle = adapters.m_nAdapterHandle[adapterIndex] }; Ndisapi.SetAdapterMode(driverPtr, ref mode); // Create and set event for the adapter var manualResetEvent = new ManualResetEvent(false); Ndisapi.SetPacketEvent(driverPtr, adapters.m_nAdapterHandle[adapterIndex], manualResetEvent.SafeWaitHandle); var filtersTable = new STATIC_FILTER_TABLE(); filtersTable.m_StaticFilters = new STATIC_FILTER[256]; switch (scena) { case 1: filtersTable.m_TableSize = 3; //************************************************************************************** // 1. Outgoing DNS requests filter: REDIRECT OUT UDP packets with destination PORT 53 // Common values filtersTable.m_StaticFilters[0].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[0].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[0].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[0].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND; // Network layer filter filtersTable.m_StaticFilters[0].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_Protocol = 17; //IPPROTO_UDP // Transport layer filter filtersTable.m_StaticFilters[0].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_DEST_PORT; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_StartRange = 53; // DNS filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_EndRange = 53; //**************************************************************************************** // 2. Incoming DNS responses filter: REDIRECT IN UDP packets with source PORT 53 // Common values filtersTable.m_StaticFilters[1].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[1].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[1].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[1].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE; // Network layer filter filtersTable.m_StaticFilters[1].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[1].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL; filtersTable.m_StaticFilters[1].m_NetworkFilter.m_IPv4.m_Protocol = 17; //IPPROTO_UDP // Transport layer filter filtersTable.m_StaticFilters[1].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_SRC_PORT; filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_SourcePort.m_StartRange = 53; // DNS filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_SourcePort.m_EndRange = 53; //*************************************************************************************** // 3. Pass all packets (skipped by previous filters) without processing in user mode // Common values filtersTable.m_StaticFilters[2].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[2].m_ValidFields = 0; filtersTable.m_StaticFilters[2].m_FilterAction = Ndisapi.FILTER_PACKET_PASS; filtersTable.m_StaticFilters[2].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE | Ndisapi.PACKET_FLAG_ON_SEND; break; case 2: filtersTable.m_TableSize = 5; //************************************************************************************** // 1. Outgoing HTTP requests filter: REDIRECT OUT TCP packets with destination PORT 80 IPv4 // Common values filtersTable.m_StaticFilters[0].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[0].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[0].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[0].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND; // Network layer filter filtersTable.m_StaticFilters[0].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_Protocol = 6; //IPPROTO_TCP // Transport layer filter filtersTable.m_StaticFilters[0].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_DEST_PORT; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_StartRange = 80; // HTTP filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_EndRange = 80; //**************************************************************************************** // 2. Incoming HTTP responses filter: REDIRECT IN TCP packets with source PORT 80 IPv4 // Common values filtersTable.m_StaticFilters[1].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[1].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[1].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[1].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE; // Network layer filter filtersTable.m_StaticFilters[1].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[1].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL; filtersTable.m_StaticFilters[1].m_NetworkFilter.m_IPv4.m_Protocol = 6; //IPPROTO_TCP // Transport layer filter filtersTable.m_StaticFilters[1].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_SRC_PORT; filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_SourcePort.m_StartRange = 80; // HTTP filtersTable.m_StaticFilters[1].m_TransportFilter.m_TcpUdp.m_SourcePort.m_EndRange = 80; //**************************************************************************************** // 3. Outgoing HTTP requests filter: REDIRECT OUT TCP packets with destination PORT 80 IPv6 // Common values filtersTable.m_StaticFilters[2].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[2].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[2].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[2].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND; // Network layer filter filtersTable.m_StaticFilters[2].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV6; filtersTable.m_StaticFilters[2].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V6_FILTER_PROTOCOL; filtersTable.m_StaticFilters[2].m_NetworkFilter.m_IPv4.m_Protocol = 6; //IPPROTO_TCP // Transport layer filter filtersTable.m_StaticFilters[2].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[2].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_DEST_PORT; filtersTable.m_StaticFilters[2].m_TransportFilter.m_TcpUdp.m_DestPort.m_StartRange = 80; // HTTP filtersTable.m_StaticFilters[2].m_TransportFilter.m_TcpUdp.m_DestPort.m_EndRange = 80; //**************************************************************************************** // 4. Incoming HTTP responses filter: REDIRECT IN TCP packets with source PORT 80 IPv6 // Common values filtersTable.m_StaticFilters[3].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[3].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[3].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[3].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE; // Network layer filter filtersTable.m_StaticFilters[3].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV6; filtersTable.m_StaticFilters[3].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V6_FILTER_PROTOCOL; filtersTable.m_StaticFilters[3].m_NetworkFilter.m_IPv4.m_Protocol = 6; // IPPROTO_TCP // Transport layer filter filtersTable.m_StaticFilters[3].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[3].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_SRC_PORT; filtersTable.m_StaticFilters[3].m_TransportFilter.m_TcpUdp.m_SourcePort.m_StartRange = 80; // HTTP filtersTable.m_StaticFilters[3].m_TransportFilter.m_TcpUdp.m_SourcePort.m_EndRange = 80; //*************************************************************************************** // 5. Pass all packets (skipped by previous filters) without processing in user mode // Common values filtersTable.m_StaticFilters[4].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[4].m_ValidFields = 0; filtersTable.m_StaticFilters[4].m_FilterAction = Ndisapi.FILTER_PACKET_PASS; filtersTable.m_StaticFilters[4].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE | Ndisapi.PACKET_FLAG_ON_SEND; break; case 3: filtersTable.m_TableSize = 5; //************************************************************************************** // 1. Block all ICMP packets // Common values filtersTable.m_StaticFilters[0].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[0].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID; filtersTable.m_StaticFilters[0].m_FilterAction = Ndisapi.FILTER_PACKET_DROP; filtersTable.m_StaticFilters[0].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND | Ndisapi.PACKET_FLAG_ON_RECEIVE; // Network layer filter filtersTable.m_StaticFilters[0].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_Protocol = 1; //IPPROTO_ICMP break; case 4: filtersTable.m_TableSize = 2; //************************************************************************************** // 1. Outgoing HTTP requests filter: DROP OUT TCP packets with destination IP 104.196.49.47 PORT 80 - 443 (http://www.ntkernel.com) // Common values filtersTable.m_StaticFilters[0].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[0].m_ValidFields = Ndisapi.NETWORK_LAYER_VALID | Ndisapi.TRANSPORT_LAYER_VALID; filtersTable.m_StaticFilters[0].m_FilterAction = Ndisapi.FILTER_PACKET_DROP; filtersTable.m_StaticFilters[0].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND; // Network layer filter var address = new in_addr(); var mask = new in_addr(); // IP address 104.196.49.47 address.s_b1 = 104; address.s_b2 = 196; address.s_b3 = 49; address.s_b4 = 47; // Network mask 255.255.255.255 mask.s_b1 = 255; mask.s_b2 = 255; mask.s_b3 = 255; mask.s_b4 = 255; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_dwUnionSelector = Ndisapi.IPV4; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_ValidFields = Ndisapi.IP_V4_FILTER_PROTOCOL | Ndisapi.IP_V4_FILTER_DEST_ADDRESS; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_DestAddress.m_AddressType = Ndisapi.IP_SUBNET_V4_TYPE; filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_DestAddress.m_IpSubnet.m_Ip = address.s_addr; // IP address filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_DestAddress.m_IpSubnet.m_IpMask = mask.s_addr; // network mask filtersTable.m_StaticFilters[0].m_NetworkFilter.m_IPv4.m_Protocol = 6; //IPPROTO_TCP // Transport layer filter filtersTable.m_StaticFilters[0].m_TransportFilter.m_dwUnionSelector = Ndisapi.TCPUDP; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_ValidFields = Ndisapi.TCPUDP_DEST_PORT; filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_StartRange = 80; // HTTP filtersTable.m_StaticFilters[0].m_TransportFilter.m_TcpUdp.m_DestPort.m_EndRange = 443; //HTTPS //*************************************************************************************** // 2. Pass all packets (skipped by previous filters) without processing in user mode // Common values filtersTable.m_StaticFilters[1].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[1].m_ValidFields = 0; filtersTable.m_StaticFilters[1].m_FilterAction = Ndisapi.FILTER_PACKET_PASS; filtersTable.m_StaticFilters[1].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE | Ndisapi.PACKET_FLAG_ON_SEND; break; case 5: filtersTable.m_TableSize = 3; //************************************************************************************** // 1. Redirects all ARP packets to be processes by user mode application // Common values filtersTable.m_StaticFilters[0].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[0].m_ValidFields = Ndisapi.DATA_LINK_LAYER_VALID; filtersTable.m_StaticFilters[0].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[0].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND | Ndisapi.PACKET_FLAG_ON_RECEIVE; filtersTable.m_StaticFilters[0].m_DataLinkFilter.m_dwUnionSelector = Ndisapi.ETH_802_3; filtersTable.m_StaticFilters[0].m_DataLinkFilter.m_Eth8023Filter.m_ValidFields = Ndisapi.ETH_802_3_PROTOCOL; filtersTable.m_StaticFilters[0].m_DataLinkFilter.m_Eth8023Filter.m_Protocol = 0x0806; // ETH_P_ARP; //************************************************************************************** // 1. Redirects all RARP packets to be processes by user mode application // Common values filtersTable.m_StaticFilters[1].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[1].m_ValidFields = Ndisapi.DATA_LINK_LAYER_VALID; filtersTable.m_StaticFilters[1].m_FilterAction = Ndisapi.FILTER_PACKET_REDIRECT; filtersTable.m_StaticFilters[1].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_SEND | Ndisapi.PACKET_FLAG_ON_RECEIVE; filtersTable.m_StaticFilters[1].m_DataLinkFilter.m_dwUnionSelector = Ndisapi.ETH_802_3; filtersTable.m_StaticFilters[1].m_DataLinkFilter.m_Eth8023Filter.m_ValidFields = Ndisapi.ETH_802_3_PROTOCOL; filtersTable.m_StaticFilters[1].m_DataLinkFilter.m_Eth8023Filter.m_Protocol = 0x0806; // ETH_P_ARP; //*************************************************************************************** // 2. Pass all packets (skipped by previous filters) without processing in user mode // Common values filtersTable.m_StaticFilters[2].m_Adapter = 0; // applied to all adapters filtersTable.m_StaticFilters[2].m_ValidFields = 0; filtersTable.m_StaticFilters[2].m_FilterAction = Ndisapi.FILTER_PACKET_PASS; filtersTable.m_StaticFilters[2].m_dwDirectionFlags = Ndisapi.PACKET_FLAG_ON_RECEIVE | Ndisapi.PACKET_FLAG_ON_SEND; break; default: Console.WriteLine("Unknown test scenario specified. Exiting."); return; } // Load filters into driver Ndisapi.SetPacketFilterTable(driverPtr, ref filtersTable); // Allocate and initialize packet structures var request = new ETH_REQUEST(); var buffer = new INTERMEDIATE_BUFFER(); var bufferPtr = Marshal.AllocHGlobal(Marshal.SizeOf(buffer)); Win32Api.ZeroMemory(bufferPtr, Marshal.SizeOf(buffer)); request.hAdapterHandle = adapters.m_nAdapterHandle[adapterIndex]; request.EthPacket.Buffer = bufferPtr; while (true) { manualResetEvent.WaitOne(); while (Ndisapi.ReadPacket(driverPtr, ref request)) { buffer = (INTERMEDIATE_BUFFER)Marshal.PtrToStructure(bufferPtr, typeof(INTERMEDIATE_BUFFER)); WriteToConsole(buffer, bufferPtr); if (buffer.m_dwDeviceFlags == Ndisapi.PACKET_FLAG_ON_SEND) { Ndisapi.SendPacketToAdapter(driverPtr, ref request); } else { Ndisapi.SendPacketToMstcp(driverPtr, ref request); } } manualResetEvent.Reset(); } } catch (Exception ex) { Console.WriteLine(ex); } }
/// <summary> /// Saves a copy of the current document /// </summary> public void SaveAsCopy(string path) { Win32Api.SendMessage(Handle, NppMsg.NPPM_SAVECURRENTFILEAS, 1, path); }
private void buttonAccept_Click(object sender, EventArgs e) { if (windows.Count <= 0 || listWindows.SelectedIndices.Count <= 0) { return; //If there are zero windows or nothing is selected, do nothing } Window w = windows[listWindows.SelectedItems[0].Index]; //Get some information for the selected window, to be used in settings its style Win32Api.tagWINDOWINFO info = new Win32Api.tagWINDOWINFO(); Win32Api.GetWindowInfo(w.Handle, out info); //Get the current windows style uint lStyle = (uint)info.dwStyle; Console.WriteLine(lStyle); //DEBUG switch (comboBorderStyle.SelectedIndex) { case 0: //None lStyle &= ~(Win32Api.WS_CAPTION | Win32Api.WS_BORDER); //Bit shit that shift break; case 1: //Sizable lStyle = lStyle | Win32Api.WS_CAPTION; //These two enumerations make the border exist lStyle = lStyle | Win32Api.WS_BORDER; break; case 2: //Custom lStyle = GetCustomStyle(); //Get the custom style selected in the advanced menu break; default: break; } //Set the window properties Win32Api.SetWindowLong((IntPtr)w.Handle, (int)Win32Api.WindowLongFlags.GWL_STYLE, (int)lStyle); //Window settings are cached, so we must set the position to update them Win32Api.SetWindowPos((IntPtr)w.Handle, IntPtr.Zero, info.rcWindow.Left, info.rcWindow.Top, info.rcWindow.Right - info.rcWindow.Left, info.rcWindow.Bottom - info.rcWindow.Top, Win32Api.SetWindowPosFlags.FrameChanged); //Now for the Window State switch (comboWinStyle.SelectedIndex) { case 0: //Normal Win32Api.ShowWindowAsync((IntPtr)w.Handle, 1); break; case 1: //Minimized Win32Api.ShowWindowAsync((IntPtr)w.Handle, 2); break; case 2: //Maximised Win32Api.ShowWindowAsync((IntPtr)w.Handle, 3); break; default: break; } }
internal static int FontHeightToSize(int height, IntPtr hDc) { int devCap = Gdi32.GetDeviceCaps(hDc, LogPixels.LOGPIXELSY); return(-Win32Api.MulDivReverse(height, devCap, 72)); }
/// <summary>Returns an enumerable collection of <see cref="UsnEntry"/> entries that meet specified criteria.</summary> /// <param name="filter">The filter.</param> /// <param name="onlyFiles">If gets only the file entries.</param> public IEnumerable <UsnEntry> EnumerateUsnEntries(string filter, bool?onlyFiles) { var usnState = new USN_JOURNAL_DATA_V0(); if (QueryUsnJournal(ref usnState) != (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS) { throw new Win32Exception("Failed to query the USN journal on the volume."); } // Set up MFT_ENUM_DATA_V0 structure. var mftData = new MFT_ENUM_DATA_V0 { StartFileReferenceNumber = 0, LowUsn = 0, HighUsn = usnState.NextUsn }; var mftDataSize = Marshal.SizeOf(mftData); var mftDataBuffer = Marshal.AllocHGlobal(mftDataSize); Win32Api.ZeroMemory(mftDataBuffer, mftDataSize); Marshal.StructureToPtr(mftData, mftDataBuffer, true); // Set up the data buffer which receives the USN_RECORD data. const int pDataSize = sizeof(ulong) + 10000; var pData = Marshal.AllocHGlobal(pDataSize); Win32Api.ZeroMemory(pData, pDataSize); // Gather up volume's directories. while (Win32Api.DeviceIoControl( _usnJournalRootHandle, Win32Api.FSCTL_ENUM_USN_DATA, mftDataBuffer, mftDataSize, pData, pDataSize, out var outBytesReturned, IntPtr.Zero)) { var pUsnRecord = new IntPtr(pData.ToInt64() + sizeof(long)); // While there is at least one entry in the USN journal. while (outBytesReturned > 60) { var usnEntry = new UsnEntry(pUsnRecord); switch (onlyFiles) { case true when usnEntry.IsFolder: case false when !usnEntry.IsFolder: { pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; continue; } } if (string.IsNullOrWhiteSpace(filter)) { yield return(usnEntry); } else { var options = new GlobOptions { Evaluation = { CaseInsensitive = true } }; var glob = Glob.Parse(filter, options); if (glob.IsMatch(usnEntry.Name.AsSpan())) { yield return(usnEntry); } } pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; } Marshal.WriteInt64(mftDataBuffer, Marshal.ReadInt64(pData, 0)); } Marshal.FreeHGlobal(pData); }
static void Main(string[] Args) { // Connect the application to console to have proper output there if requested. bool consoleRedirectionWorked = Win32Api.RedirectConsole(); // Start with command line parsing. string userDir = System.IO.Path.Combine(System.IO.Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MySQL"), "Workbench"); Logger.InitLogger(userDir); if (!consoleRedirectionWorked) { Logger.LogError("Workbench", "Console redirection failed.\n"); } System.Reflection.Assembly asm = System.Reflection.Assembly.GetEntryAssembly(); string baseDir = System.IO.Path.GetDirectoryName(asm.Location); WbOptions wbOptions = new WbOptions(baseDir, userDir, true); if (!wbOptions.parse_args(Args, asm.Location)) { Logger.LogInfo("Workbench", "Command line params told us to shut down.\n"); return; } PrintInitialLogInfo(); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // Hook into the exception handling to establish our own handling. AppDomain currentDomain = AppDomain.CurrentDomain; // CLR currentDomain.UnhandledException += new UnhandledExceptionEventHandler(OnUnhandledException); Application.ThreadException += // Windows Forms new System.Threading.ThreadExceptionEventHandler(OnGuiUnhandledException); // Read some early values which cannot be stored in the preferences (since they are loaded // later) from registry. bool singleInstance = true; string lastVersion = ""; string currentVersion = GetApplicationMetaInfo(ApplicationMetaInfo.Version); Logger.LogInfo("Workbench", "Current version given by meta info is: " + currentVersion + '\n'); RegistryKey wbKey = Registry.CurrentUser; try { wbKey = wbKey.OpenSubKey(@"Software\Oracle\MySQL Workbench", false); if (wbKey != null) { if (wbKey.GetValue("DisableSingleInstance", 0).ToString() == "1") { singleInstance = false; } lastVersion = wbKey.GetValue("LastStartedAs", "").ToString(); } else { Registry.CurrentUser.CreateSubKey(@"Software\Oracle\MySQL Workbench"); } } catch (Exception e) { Logger.LogError("Workbench", "Error while checking single instance reg key: " + e.Message + '\n'); } finally { if (wbKey != null) { wbKey.Close(); } } // First check if this is the first instance of Workbench (if enabled). // The setting for single-instance is stored in the registry as it is Windows-only // and loading of the application settings happens later. if (singleInstance) { if (!ApplicationInstanceManager.CreateSingleInstance( Assembly.GetExecutingAssembly().GetName().Name, Args, SingleInstanceCallback)) { Logger.LogInfo("Workbench", "Exiting as another instance of WB is already running.\n"); return; } } // Give the main thread a proper name, so we can later check for it when needed. Thread.CurrentThread.Name = "mainthread"; // Change the working dir to to application path. // This is necessary because all our internal data files etc. are located under the app dir // and WB could have been called from a different dir. string workdir = System.IO.Directory.GetCurrentDirectory(); System.IO.Directory.SetCurrentDirectory(baseDir); // Next check if this is the first start of a new version of WB. In this case remove all // compiled python files. They will be automatically recreated and can produce problems // under certain circumstances. if (currentVersion != lastVersion) { Logger.LogInfo("Workbench", "This is the first start of a new version. Doing some clean up.\n"); List <string> failed = new List <string>(); RemoveCompiledPythonFiles(baseDir, failed); // TODO: decide if we wanna ask the user to remove those files manually or just ignore them. } // Some people don't have c:\windows\system32 in PATH, so we need to set it here // for WBA to find the needed commands String systemFolder = Environment.GetFolderPath(Environment.SpecialFolder.System); String cleanedPath = Environment.GetEnvironmentVariable("PATH"); String [] paths = cleanedPath.Split(new char[] { ';' }); cleanedPath = ""; // Strip all python related dirs from PATH to avoid conflicts with other Python installations. foreach (String path in paths) { if (!path.ToLower().Contains("python")) { cleanedPath = cleanedPath + ";" + path; } } Environment.SetEnvironmentVariable("PATH", systemFolder + cleanedPath); Logger.LogInfo("Workbench", "Setting PATH to: " + systemFolder + cleanedPath + '\n'); // Clear PYTHONPATH environment variable, as we do not need it but our python impl // seriously gets confused with it. Environment.SetEnvironmentVariable("PYTHONPATH", workdir + "\\python\\Lib;" + workdir + "\\python\\DLLs;" + workdir + "\\python"); Environment.SetEnvironmentVariable("PYTHONHOME", workdir + "\\python"); // Initialize forms stuff. MySQL.Forms.Manager formsManager = MySQL.Forms.Manager.get_instance(); // Creates the singleton. // init extra mforms things that are delegated to the frontend, indirectly through RecordsetWrapper in wbpublic MySQL.Grt.Db.RecordsetWrapper.init_mforms(MySQL.Grt.Db.RecordsetView.create); #region Runtime path check // Currently WB has trouble running from a path containing non-ASCII characters. // Actually, our third party libraries have (namely lua, python, ctemplate), // as they don't consider Unicode file names (encoded as UTF-8) which leads to file-not-found // errors. Refuse to work in such a path for now. foreach (Char c in baseDir) { if (c > 0x7f) { MessageBox.Show("MySQL Workbench cannot be executed from a path that contains non-ASCII characters.\n" + "This problem is imposed by used third-party libraries.\n" + "Please run this application from the default installation path or at least a path which is all ASCII characters.", "MySQL Workbench Execution Problem", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } } #endregion #region Release check (outdated beta or rc version) // check the date of the executable and suggest to install a new version if this is a beta or rc if (GetApplicationMetaInfo(ApplicationMetaInfo.Configuration).ToUpper().IndexOf("BETA") >= 0 || GetApplicationMetaInfo(ApplicationMetaInfo.Configuration).ToUpper().IndexOf("RC") >= 0) { DateTime fileDate = System.IO.File.GetCreationTime(Application.ExecutablePath); if (DateTime.Now.Subtract(fileDate).TotalDays > 45) { Logger.LogInfo("Workbench", "Found an old WB pre release. Showing warning.\n"); if (MessageBox.Show("This version of MySQL Workbench is older than 45 days and most probably outdated. " + Environment.NewLine + "It is recommended to upgrade to a newer version if available. " + Environment.NewLine + "Press [OK] to check for a new version and exit the application. " + "Press [Cancel] to continue using this version.", "MySQL Workbench Version Outdated", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1) == DialogResult.OK) { CheckForNewVersion(); return; } } } #endregion #region Variables and Splashscreen #endregion #region Initialize GRT // Try to instantiate the Workbench context and the GRT Manager and catch exceptions try { // Create Workbench Context wbContext = new WbContext(wbOptions.Verbose); if (wbContext != null) { // Create the GRT Manager instance grtManager = wbContext.get_grt_manager(); } } catch (Exception ex) { HandleException(ex); } #endregion // If the Workbench Context and GRT Manager were successfully created, // initialize the application if (wbContext != null && grtManager != null) { #region Initialize Callbacks and Mainform mainForm = new MainForm(wbContext); // Initialize the Workbench context ManagedApplication formsApplication = new ManagedApplication( new AppCommandDelegate(mainForm.ApplicationCommand), mainForm.dockDelegate); callbacks = new WbFrontendCallbacks( new WbFrontendCallbacks.StrStrStrStrDelegate(mainForm.ShowFileDialog), new WbFrontendCallbacks.VoidStrDelegate(mainForm.ShowStatusText), new WbFrontendCallbacks.BoolStrStrFloatDelegate(mainForm.ShowProgress), new WbFrontendCallbacks.CanvasViewStringStringDelegate(mainForm.CreateNewDiagram), new WbFrontendCallbacks.VoidCanvasViewDelegate(mainForm.DestroyView), new WbFrontendCallbacks.VoidCanvasViewDelegate(mainForm.SwitchedView), new WbFrontendCallbacks.VoidCanvasViewDelegate(mainForm.ToolChanged), new WbFrontendCallbacks.IntPtrGRTManagerModuleStrStrGrtListFlagsDelegate(mainForm.OpenPlugin), new WbFrontendCallbacks.VoidIntPtrDelegate(mainForm.ShowPlugin), new WbFrontendCallbacks.VoidIntPtrDelegate(mainForm.HidePlugin), new WbFrontendCallbacks.VoidRefreshTypeStringIntPtrDelegate(mainForm.RefreshGUI), new WbFrontendCallbacks.VoidBoolDelegate(mainForm.LockGUI), new WbFrontendCallbacks.VoidStrDelegate(mainForm.PerformCommand), new WbFrontendCallbacks.BoolDelegate(mainForm.QuitApplication)); // TODO: check return value and show error message. // Currently the return value is always true. In case of an error an exception is raised. // That should change. wbContext.init(callbacks, wbOptions, new WbContext.VoidStrUIFormDelegate(mainForm.CreateMainFormView) ); // command registration must be done after WBContext init mainForm.PostInit(); // Set the Application.Idle event handler Application.Idle += new EventHandler(OnApplicationIdle); // Don't call the idle handler too often. timer = new System.Windows.Forms.Timer(); timer.Interval = 100; timer.Tick += new EventHandler(timer_Tick); timer.Start(); // Trigger GRT idle tasks grtManager.perform_idle_tasks(); // Setup Menus wbContext.validate_edit_menu(); mainForm.Show(); Logger.LogInfo("Workbench", "UI is up\n"); // Tell the backend our main UI is ready. This will also load a model if it was given via command line // and opens the overview form for it. wbContext.finished_loading(wbOptions); // Right before we go to work and everything was loaded write the current version to registry // to allow us later to find out if we ran a new version the first time. try { wbKey = Registry.CurrentUser.OpenSubKey(@"Software\Oracle\MySQL Workbench", true); if (wbKey != null) { wbKey.SetValue("LastStartedAs", currentVersion); } } catch (Exception e) { Logger.LogError("Workbench", "Couldn't write regkey LastStartedAs: " + e.Message + '\n'); } finally { if (wbKey != null) { wbKey.Close(); } } // Start the Application if we are not already shutting down. if (!wbContext.is_quitting()) { try { Logger.LogInfo("Workbench", "Running the application\n"); Application.Run(new ApplicationContext(mainForm)); } catch (Exception e) { HandleException(e); } } #endregion Logger.LogInfo("Workbench", "Shutting down Workbench\n"); timer.Stop(); timer.Dispose(); // shutdown wb context if (wbContext != null) { while (wbContext.is_busy()) { wbContext.flush_idle_tasks(); } wbContext.finalize(); wbContext.Dispose(); } formsApplication.Dispose(); formsManager.Dispose(); GC.Collect(); } Win32Api.ReleaseConsole(); Logger.LogInfo("Workbench", "Done\n"); }
/// <summary>Given a file reference number GetPathFromFrn() calculates the full path in the out parameter 'path'.</summary> /// <param name="frn">A 64-bit file reference number</param> /// <param name="path"></param> /// <returns> /// USN_JOURNAL_SUCCESS GetPathFromFrn() function succeeded. /// VOLUME_NOT_NTFS volume is not an NTFS volume. /// INVALID_HANDLE_VALUE NtfsUsnJournal object failed initialization. /// ERROR_ACCESS_DENIED accessing the USN journal requires admin rights, see remarks. /// INVALID_FILE_REFERENCE_NUMBER file reference number not found in Master File Table. /// ERROR_INVALID_FUNCTION error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_FILE_NOT_FOUND error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_PATH_NOT_FOUND error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_TOO_MANY_OPEN_FILES error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_INVALID_HANDLE error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_INVALID_DATA error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_NOT_SUPPORTED error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_INVALID_PARAMETER error generated by NtCreateFile() or NtQueryInformationFile() call. /// ERROR_INVALID_USER_BUFFER error generated by NtCreateFile() or NtQueryInformationFile() call. /// USN_JOURNAL_ERROR unspecified USN journal error. /// </returns> /// <remarks> /// If function returns ERROR_ACCESS_DENIED you need to run application as an Administrator. /// </remarks> public bool TryGetPathFromFileId(ulong frn, out string path) { path = null; if (_isNtfsVolume) { if (_usnJournalRootHandle.ToInt64() != Win32Api.INVALID_HANDLE_VALUE) { if (frn != 0) { long allocSize = 0; UNICODE_STRING unicodeString; var objAttributes = new OBJECT_ATTRIBUTES(); var ioStatusBlock = new IO_STATUS_BLOCK(); var hFile = IntPtr.Zero; var buffer = Marshal.AllocHGlobal(4096); var refPtr = Marshal.AllocHGlobal(8); var objAttIntPtr = Marshal.AllocHGlobal(Marshal.SizeOf(objAttributes)); // Pointer >> fileid. Marshal.WriteInt64(refPtr, (long)frn); unicodeString.Length = 8; unicodeString.MaximumLength = 8; unicodeString.Buffer = refPtr; // Copy unicode structure to pointer. Marshal.StructureToPtr(unicodeString, objAttIntPtr, true); // InitializeObjectAttributes. objAttributes.Length = (ulong)Marshal.SizeOf(objAttributes); objAttributes.ObjectName = objAttIntPtr; objAttributes.RootDirectory = _usnJournalRootHandle; objAttributes.Attributes = (int)Win32Api.OBJ_CASE_INSENSITIVE; var fOk = Win32Api.NtCreateFile(ref hFile, FileAccess.Read, ref objAttributes, ref ioStatusBlock, ref allocSize, 0, FileShare.ReadWrite, Win32Api.FILE_OPEN_IF, Win32Api.FILE_OPEN_BY_FILE_ID /* | Win32Api.FILE_OPEN_FOR_BACKUP_INTENT*/, IntPtr.Zero, 0); if (fOk == 0) { fOk = Win32Api.NtQueryInformationFile(hFile, ref ioStatusBlock, buffer, 4096, FILE_INFORMATION_CLASS.FileNameInformation); if (fOk == 0) { // The first 4 bytes are the name length. var nameLength = Marshal.ReadInt32(buffer, 0); // The next bytes are the name. path = Marshal.PtrToStringUni(new IntPtr(buffer.ToInt64() + 4), nameLength / 2); return(true); } else { // throw new Exception($"NtQueryInformationFile failed with error: 0x{fOk:X8}"); } } else { // throw new Exception($"NtCreateFile failed with error: {fOk:X8}"); } Win32Api.CloseHandle(hFile); Marshal.FreeHGlobal(buffer); Marshal.FreeHGlobal(objAttIntPtr); Marshal.FreeHGlobal(refPtr); } } } return(false); }
/// <summary> /// Returns true if the cursor is within the form window /// </summary> public static bool IsMouseIn() { return(Win32Api.IsCursorIn(_form.Handle)); }
public IEnumerable <UsnEntry> ReadUsnEntries(USN_JOURNAL_DATA_V0 previousUsnState, uint reasonMask, string filter, bool?onlyFiles) { var newUsnState = new USN_JOURNAL_DATA_V0(); var lastError = (int)UsnJournalReturnCode.VOLUME_NOT_NTFS; if (_isNtfsVolume) { if (_usnJournalRootHandle.ToInt64() != Win32Api.INVALID_HANDLE_VALUE) { // Get current USN journal state. lastError = QueryUsnJournal(ref newUsnState); if (lastError == (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS) { var bReadMore = true; // Sequentially process the USN journal looking for image file entries. const int pbDataSize = sizeof(ulong) * 16384; var pbData = Marshal.AllocHGlobal(pbDataSize); Win32Api.ZeroMemory(pbData, pbDataSize); var rujd = new READ_USN_JOURNAL_DATA_V0 { StartUsn = (ulong)previousUsnState.NextUsn, ReasonMask = reasonMask, ReturnOnlyOnClose = 0, Timeout = 0, BytesToWaitFor = 0, UsnJournalId = previousUsnState.UsnJournalID }; var sizeRujd = Marshal.SizeOf(rujd); var rujdBuffer = Marshal.AllocHGlobal(sizeRujd); Win32Api.ZeroMemory(rujdBuffer, sizeRujd); Marshal.StructureToPtr(rujd, rujdBuffer, true); // Read USN journal entries. while (bReadMore) { var bRtn = Win32Api.DeviceIoControl(_usnJournalRootHandle, Win32Api.FSCTL_READ_USN_JOURNAL, rujdBuffer, sizeRujd, pbData, pbDataSize, out var outBytesReturned, IntPtr.Zero); if (bRtn) { var pUsnRecord = new IntPtr(pbData.ToInt64() + sizeof(ulong)); // While there is at least one entry in the USN journal. while (outBytesReturned > 60) { var usnEntry = new UsnEntry(pUsnRecord); // Only read until the current usn points beyond the current state's USN. if (usnEntry.USN >= newUsnState.NextUsn) { bReadMore = false; break; } switch (onlyFiles) { case true when usnEntry.IsFolder: case false when !usnEntry.IsFolder: { pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; continue; } } if (string.IsNullOrWhiteSpace(filter)) { yield return(usnEntry); } else { var options = new GlobOptions { Evaluation = { CaseInsensitive = true } }; var glob = Glob.Parse(filter, options); if (glob.IsMatch(usnEntry.Name.AsSpan())) { yield return(usnEntry); } } pUsnRecord = new IntPtr(pUsnRecord.ToInt64() + usnEntry.RecordLength); outBytesReturned -= usnEntry.RecordLength; } } else { var lastWin32Error = Marshal.GetLastWin32Error(); if (lastWin32Error == (int)Win32Errors.ERROR_HANDLE_EOF) { lastError = (int)UsnJournalReturnCode.USN_JOURNAL_SUCCESS; } break; } var nextUsn = Marshal.ReadInt64(pbData, 0); if (nextUsn >= newUsnState.NextUsn) { break; } Marshal.WriteInt64(rujdBuffer, nextUsn); } Marshal.FreeHGlobal(rujdBuffer); Marshal.FreeHGlobal(pbData); } } else { lastError = (int)UsnJournalReturnCode.INVALID_HANDLE_VALUE; } } }
/// <summary> /// Snapshots the VM and gets its (maybe partial) StorageLayout /// </summary> /// <returns> /// The physical disks. /// </returns> retrieve a public StorageLayout BuildStorageLayout() { StorageLayout sl = new StorageLayout(); // http://jo0ls-dotnet-stuff.blogspot.fr/2008/12/howto-get-physical-drive-string.html foreach (DriveInfo di in DriveInfo.GetDrives()) { if (di.DriveType != DriveType.Fixed /*&& di.DriveType != DriveType.Network*/) { continue; } string devicePath = @"\\.\" + di.RootDirectory.ToString().TrimEnd(new char[] { '\\' }); Console.WriteLine("Mounted dev path=" + devicePath); IntPtr handle = Win32Api.CreateFile(devicePath, Win32Api.GENERIC_READ | Win32Api.GENERIC_WRITE, Win32Api.FILE_SHARE_READ | Win32Api.FILE_SHARE_WRITE, IntPtr.Zero, Win32Api.OPEN_EXISTING, 0 /*Win32Api.FILE_FLAG_BACKUP_SEMANTICS | (uint)Alphaleonis.Win32.Filesystem.FileSystemRights.SystemSecurity*/, IntPtr.Zero); openHandles.Add(handle); // Then query underlying partition(s) Win32Api.DiskExtents extents = new Win32Api.DiskExtents(); int size = 0; bool ok = Win32Api.DeviceIoControl(handle, (uint)Win32Api.Ioctls.GetVolumeDiskExtents, IntPtr.Zero, 0, ref extents, Marshal.SizeOf(extents), out size, IntPtr.Zero); //Console.WriteLine ("DeviceIoControl : "+(new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error())).Message); if (!ok) { Console.WriteLine("DeviceIoControl failed : " + (new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error())).Message); int blobSize = Marshal.SizeOf(typeof(Win32Api.DiskExtents)) + (extents.numberOfExtents - 1) * Marshal.SizeOf(typeof(Win32Api.DiskExtent)); IntPtr pBlob = Marshal.AllocHGlobal(blobSize); uint dataSize = 0; ok = Win32Api.DeviceIoControl(handle, (uint)Win32Api.Ioctls.GetVolumeDiskExtents, IntPtr.Zero, 0, pBlob, blobSize, out dataSize, IntPtr.Zero); if (ok) { IntPtr pNext = new IntPtr(pBlob.ToInt32() + IntPtr.Size /*4*/); // is this always ok on 64 bit OSes? ToInt64? for (int i = 0; i < extents.numberOfExtents; i++) { // DiskExtent diskExtentN = DirectCast(Marshal.PtrToStructure(pNext, GetType(DiskExtent)), DiskExtent) Win32Api.DiskExtent diskExtentN = (Win32Api.DiskExtent)Marshal.PtrToStructure(pNext, typeof(Win32Api.DiskExtent)); // physicalDrives.Add("\\.\PhysicalDrive" & diskExtentN.DiskNumber.ToString) Console.WriteLine("found multiple backing part disk=: " + diskExtentN.DiskNumber + ", offset=" + diskExtentN.StartingOffset + ", length=" + diskExtentN.ExtentLength); pNext = new IntPtr(pNext.ToInt32() + Marshal.SizeOf(typeof(Win32Api.DiskExtent))); } } else { Console.WriteLine("DeviceIoControl for multiple backing extents failed : " + (new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error())).Message); } } else { Console.WriteLine("found part disk=: " + extents.first.DiskNumber + ", offset=" + extents.first.StartingOffset + ", length=" + extents.first.ExtentLength); } Disk disk = new Disk(); disk.Path = @"\\.\PhysicalDrive" + extents.first.DiskNumber.ToString(); //+disk.Id; IntPtr physDiskHandle = Win32Api.CreateFile(disk.Path, Win32Api.GENERIC_READ | Win32Api.GENERIC_WRITE, Win32Api.FILE_SHARE_READ | Win32Api.FILE_SHARE_WRITE, IntPtr.Zero, Win32Api.OPEN_EXISTING, 0 /*Win32Api.FILE_FLAG_BACKUP_SEMANTICS | (uint)Alphaleonis.Win32.Filesystem.FileSystemRights.SystemSecurity*/, IntPtr.Zero); //Console.WriteLine ("CreateFile : "+(new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error())).Message); openHandles.Add(physDiskHandle); disk.BlockStream = new FileStream(physDiskHandle, FileAccess.Read); disk.Id = (string)extents.first.DiskNumber.ToString(); // now get the disk geometry to obtain physical sector size Win32Api.DISK_GEOMETRY diskGeometry = new Win32Api.DISK_GEOMETRY(); ok = Win32Api.DeviceIoControl(physDiskHandle, (uint)Win32Api.Ioctls.DiskGetDriveGeometry, IntPtr.Zero, 0, ref diskGeometry, Marshal.SizeOf(diskGeometry), out size, IntPtr.Zero); Win32Api.MEDIA_SERIAL_NUMBER_DATA diskSerial = new Win32Api.MEDIA_SERIAL_NUMBER_DATA(); ok = Win32Api.DeviceIoControl(physDiskHandle, (uint)Win32Api.Ioctls.GetMediaSerialNumber, IntPtr.Zero, 0, ref diskSerial, Marshal.SizeOf(diskSerial), out size, IntPtr.Zero); Console.WriteLine("DeviceIoControl : " + (new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error())).Message); disk.SectorSize = (uint)diskGeometry.BytesPerSector; if (diskSerial.SerialNumberData != null) { disk.Id = System.Text.Encoding.Default.GetString(diskSerial.SerialNumberData); } disk.Size = diskGeometry.DiskSize; if (!sl.Entries.Contains(disk)) { sl.Entries.Add(disk); } Partition p = new Partition(); p.Offset = (ulong)extents.first.StartingOffset / disk.SectorSize; p.Size = extents.first.ExtentLength; FileSystem fs = new FileSystem(); fs.Path = devicePath; fs.DriveFormat = fs.DriveFormat; fs.MountPoint = di.RootDirectory.ToString(); fs.OriginalMountPoint = di.RootDirectory.ToString(); fs.AvailableFreeSpace = di.AvailableFreeSpace; fs.Size = di.TotalSize; p.AddChild(fs); Console.WriteLine("created new FS, mnt=" + fs.MountPoint); foreach (IDiskElement de in sl.Entries) { if (de is Disk && de.Id == disk.Id) { Console.WriteLine("adding new part to layout"); de.AddChild(p); } } } return(sl); }
/// <summary>This function queries the USN journal on the volume.</summary> /// <param name="usnJournalState">the USN_JOURNAL_DATA object that is associated with this volume</param> private int QueryUsnJournal(ref USN_JOURNAL_DATA_V0 usnJournalState) { Win32Api.DeviceIoControl(_usnJournalRootHandle, Win32Api.FSCTL_QUERY_USN_JOURNAL, IntPtr.Zero, 0, out usnJournalState, Marshal.SizeOf(usnJournalState), out _, IntPtr.Zero); return(Marshal.GetLastWin32Error()); }
public static List<Win32Api.UsnEntry> Get_Changes(SafeFileHandle roothandle, Win32Api.USN_JOURNAL_DATA startUsnState) { uint reasonMask = Win32Api.USN_REASON_DATA_OVERWRITE | Win32Api.USN_REASON_DATA_EXTEND | Win32Api.USN_REASON_NAMED_DATA_OVERWRITE | Win32Api.USN_REASON_NAMED_DATA_TRUNCATION | Win32Api.USN_REASON_FILE_CREATE | Win32Api.USN_REASON_FILE_DELETE | Win32Api.USN_REASON_EA_CHANGE | Win32Api.USN_REASON_SECURITY_CHANGE | Win32Api.USN_REASON_RENAME_OLD_NAME | Win32Api.USN_REASON_RENAME_NEW_NAME | Win32Api.USN_REASON_INDEXABLE_CHANGE | Win32Api.USN_REASON_BASIC_INFO_CHANGE | Win32Api.USN_REASON_HARD_LINK_CHANGE | Win32Api.USN_REASON_COMPRESSION_CHANGE | Win32Api.USN_REASON_ENCRYPTION_CHANGE | Win32Api.USN_REASON_OBJECT_ID_CHANGE | Win32Api.USN_REASON_REPARSE_POINT_CHANGE | Win32Api.USN_REASON_STREAM_CHANGE | Win32Api.USN_REASON_CLOSE; var changes = new List<Win32Api.UsnEntry>(); Win32Api.USN_JOURNAL_DATA newUsnState; GetUsnJournalEntries(roothandle, startUsnState, reasonMask, out changes, out newUsnState); return changes; }
/// <summary> /// Releases unmanaged resources /// </summary> protected override void DisposeUnmanaged() { Win32Api.FreeLibrary(PtrLib); base.DisposeUnmanaged(); }
public void LoginHandler(SessionHandler session) { try { var login = session.CompletedBuffer.GetMessageEntity <LoginPack>(); var syncContext = new SessionSyncContext() { IPv4 = login.IPV4, MachineName = login.MachineName, Remark = login.Remark, CpuInfo = login.ProcessorInfo, CoreCount = login.ProcessorCount, MemroySize = login.MemorySize, StarupDateTime = login.StartRunTime, Version = login.ServiceVison, AdminName = login.UserName, OSVersion = login.OSVersion, IsCameraExist = login.ExistCameraDevice, IsRecordExist = login.ExitsRecordDevice, IsPlayerExist = login.ExitsPlayerDevice, IsOpenScreenRecord = login.OpenScreenRecord, IsOpenScreenView = login.OpenScreenWall, IdentifyId = login.IdentifyId, RecordScreenIsAction = false, //桌面记录状态 RecordScreenHeight = login.RecordHeight, //用于桌面记录的高 RecordScreenWidth = login.RecordWidth, //用于桌面记录宽 RecordScreenSpanTime = login.RecordSpanTime, Session = session }; _syncContexts.Add(syncContext); var listItem = new USessionListItem(syncContext); syncContext.OnSessionListItem = listItem; session.AppTokens[SysConstants.INDEX_WORKER] = syncContext; onlineList.Items.Add(listItem); //是否开启桌面视图 if (syncContext.IsOpenScreenView != true) { listItem.BackColor = _closeScreenColor; } else { byte[] data = MessageHelper.CopyMessageHeadTo(MessageHead.S_MAIN_DESKTOPVIEW, new byte[] { 0 });//强制创建视图 session.SendAsync(data); } //是否桌面记录 if (syncContext.IsOpenScreenRecord) { byte[] data = MessageHelper.CopyMessageHeadTo(MessageHead.S_MAIN_SCREEN_RECORD_OPEN, new DesktopRecordGetFramePack() { Height = syncContext.RecordScreenHeight, Width = syncContext.RecordScreenWidth, TimeSpan = syncContext.RecordScreenSpanTime }); session.SendAsync(data); } _connect_count++; stripConnectedNum.Text = _connect_count.ToString(); Win32Api.FlashWindow(this.Handle, true); //上线任务栏图标闪烁 this.WriteRuninglog("计算机:" + syncContext.MachineName + "(" + syncContext.Remark + ") -->已连接控制端!", "ok"); } catch (Exception ex) { LogHelper.WriteErrorByCurrentMethod(ex); //可能是旧版本上线包 } }
/// <summary> /// Erzeugt einen Screenshot dieses Fensters. /// </summary> /// <param name="isClientWnd">Handelt es sich um das Handle eines Client-Fensters oder nícht.</param> /// <param name="nCmdShow">Der WindowShowStyle.</param> /// <param name="timeForRedrawing">Die Zeit, die gewartet werden soll, bis der Screenshot gemacht wird.</param> /// <returns>Der Screenshot oder <see langword="null" />, wenn nicht ermittelbar.</returns> public Bitmap MakeScreenshot(bool isClientWnd = false, Win32Api.WindowShowStyle nCmdShow = Win32Api.WindowShowStyle.Restore, TimeSpan?timeForRedrawing = null) { var appWndHandle = this.HWnd; if (appWndHandle == IntPtr.Zero || !Win32Api.IsWindow(appWndHandle) || !Win32Api.IsWindowVisible(appWndHandle)) { return(null); } if (Win32Api.IsIconic(appWndHandle)) { Win32Api.ShowWindow(appWndHandle, nCmdShow); // show it } if (!Win32Api.SetForegroundWindow(appWndHandle)) { return(null); // can't bring it to front } if (timeForRedrawing.HasValue) { // give it some time to redraw Thread.Sleep(timeForRedrawing.Value); } RECT appRect; var res = isClientWnd ? Win32Api.GetClientRect(appWndHandle, out appRect) : Win32Api.GetWindowRect(appWndHandle, out appRect); if (!res || appRect.Height == 0 || appRect.Width == 0) { return(null); // some hidden window } if (isClientWnd) { var lt = new Point(appRect.Left, appRect.Top); var rb = new Point(appRect.Right, appRect.Bottom); Win32Api.ClientToScreen(appWndHandle, ref lt); Win32Api.ClientToScreen(appWndHandle, ref rb); appRect.Left = lt.X; appRect.Top = lt.Y; appRect.Right = rb.X; appRect.Bottom = rb.Y; } // intersect with the Desktop rectangle and get what's visible var desktopHandle = Win32Api.GetDesktopWindow(); RECT desktopRect; Win32Api.GetWindowRect(desktopHandle, out desktopRect); RECT visibleRect; if (!Win32Api.IntersectRect(out visibleRect, ref desktopRect, ref appRect)) { visibleRect = appRect; } if (Win32Api.IsRectEmpty(ref visibleRect)) { return(null); } var width = visibleRect.Width; var height = visibleRect.Height; var hdcTo = IntPtr.Zero; var hdcFrom = IntPtr.Zero; var hBitmap = IntPtr.Zero; try { Bitmap clsRet = null; // get device context of the window... hdcFrom = isClientWnd ? Win32Api.GetDC(appWndHandle) : Win32Api.GetWindowDC(appWndHandle); // create dc that we can draw to... hdcTo = Win32Api.CreateCompatibleDC(hdcFrom); hBitmap = Win32Api.CreateCompatibleBitmap(hdcFrom, width, height); // validate... if (hBitmap != IntPtr.Zero) { // copy... var x = appRect.Left < 0 ? -appRect.Left : 0; var y = appRect.Top < 0 ? -appRect.Top : 0; var hLocalBitmap = Win32Api.SelectObject(hdcTo, hBitmap); Win32Api.BitBlt(hdcTo, 0, 0, width, height, hdcFrom, x, y, Win32Api.SRCCOPY); Win32Api.SelectObject(hdcTo, hLocalBitmap); // create bitmap for window image... clsRet = System.Drawing.Image.FromHbitmap(hBitmap); } return(clsRet); } finally { // release... if (hdcFrom != IntPtr.Zero) { Win32Api.ReleaseDC(appWndHandle, hdcFrom); } if (hdcTo != IntPtr.Zero) { Win32Api.DeleteDC(hdcTo); } if (hBitmap != IntPtr.Zero) { Win32Api.DeleteObject(hBitmap); } } }
/// <summary> /// This function queries the usn journal on the volume. /// </summary> /// <param name="usnJournalState">the USN_JOURNAL_DATA object that is associated with this volume</param> /// <returns> /// The success state of the <c>WinApi32.DeviceIoControl</c> call. /// </returns> private bool QueryUsnJournal(ref Win32Api.USN_JOURNAL_DATA usnJournalState) { UInt32 cb; return Win32Api.DeviceIoControl( _usnJournalRootHandle, Win32Api.FSCTL_QUERY_USN_JOURNAL, IntPtr.Zero, 0, out usnJournalState, Marshal.SizeOf(usnJournalState), out cb, IntPtr.Zero ); }
/// <summary> /// Initialisiert eine neue Instanz der Klasse <see cref="GuiApp" />. /// </summary> /// <param name="proc">Der zugrundeliegende Prozess.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="proc" /> ist <see langword="null" />. /// </exception> public GuiApp(Process proc) { if (proc == null) { throw new ArgumentNullException("proc"); } var desktopHandle = Win32Api.GetDesktopWindow(); Win32Api.GetWindowRect(desktopHandle, out DESKTOP_SIZE); this._PROCESS = proc; this._REAL_HWND = IntPtr.Zero; var windowHandleList = new List <IntPtr>(); var listHandle = default(GCHandle); try { if (proc.MainWindowHandle == IntPtr.Zero) { throw new ApplicationException("Can't add a process with no MainFrame"); } var maxRect = default(RECT); // init with 0 if (IsValidGUIWnd(proc.MainWindowHandle, DESKTOP_SIZE)) { this._REAL_HWND = proc.MainWindowHandle; return; } // the mainFrame is size == 0, so we look for the 'real' window listHandle = GCHandle.Alloc(windowHandleList); foreach (ProcessThread pt in proc.Threads) { Win32Api.EnumThreadWindows((uint)pt.Id, new Win32Api.EnumThreadDelegate(EnumThreadCallback), GCHandle.ToIntPtr(listHandle)); } this._WINDOW_HANDLES = windowHandleList.ToArray(); // get the biggest visible window in the current proc var maxHWnd = IntPtr.Zero; foreach (var hWnd in _WINDOW_HANDLES) { RECT crtWndRect; // do we have a valid rect for this window if (Win32Api.IsWindowVisible(hWnd) && Win32Api.GetWindowRect(hWnd, out crtWndRect) && crtWndRect.Height > maxRect.Height && crtWndRect.Width > maxRect.Width) { // if the rect is outside the desktop, it's a dummy window RECT visibleRect; if (Win32Api.IntersectRect(out visibleRect, ref this.DESKTOP_SIZE, ref crtWndRect) && !Win32Api.IsRectEmpty(ref visibleRect)) { maxHWnd = hWnd; maxRect = crtWndRect; } } } if (maxHWnd != IntPtr.Zero && maxRect.Width > 0 && maxRect.Height > 0) { this._REAL_HWND = maxHWnd; } else { this._REAL_HWND = proc.MainWindowHandle; // just add something even if it's a bad window } } finally { if (listHandle != default(GCHandle) && listHandle.IsAllocated) { listHandle.Free(); } } }
private void PopulateFlags(RawUSNEntry dbEntry, Win32Api.UsnEntry entry) { uint value = entry.Reason & Win32Api.USN_REASON_DATA_OVERWRITE; if (0 != value) { dbEntry.DataOverwrite = true; } value = entry.Reason & Win32Api.USN_REASON_DATA_EXTEND; if (0 != value) { dbEntry.DataExtend = true; } value = entry.Reason & Win32Api.USN_REASON_DATA_TRUNCATION; if (0 != value) { dbEntry.DataTruncation = true; } value = entry.Reason & Win32Api.USN_REASON_NAMED_DATA_OVERWRITE; if (0 != value) { dbEntry.NamedDataOverwrite = true; } value = entry.Reason & Win32Api.USN_REASON_NAMED_DATA_EXTEND; if (0 != value) { dbEntry.NamedDataExtend = true; } value = entry.Reason & Win32Api.USN_REASON_NAMED_DATA_TRUNCATION; if (0 != value) { dbEntry.NamedDataTruncation = true; } value = entry.Reason & Win32Api.USN_REASON_FILE_CREATE; if (0 != value) { dbEntry.FileCreate = true; } value = entry.Reason & Win32Api.USN_REASON_FILE_DELETE; if (0 != value) { dbEntry.FileDelete = true; } value = entry.Reason & Win32Api.USN_REASON_EA_CHANGE; if (0 != value) { dbEntry.EaChange = true; } value = entry.Reason & Win32Api.USN_REASON_SECURITY_CHANGE; if (0 != value) { dbEntry.SecurityChange = true; } value = entry.Reason & Win32Api.USN_REASON_RENAME_OLD_NAME; if (0 != value) { dbEntry.RenameOldName = true; } value = entry.Reason & Win32Api.USN_REASON_RENAME_NEW_NAME; if (0 != value) { dbEntry.RenameNewName = true; } value = entry.Reason & Win32Api.USN_REASON_INDEXABLE_CHANGE; if (0 != value) { dbEntry.IndexableChange = true; } value = entry.Reason & Win32Api.USN_REASON_BASIC_INFO_CHANGE; if (0 != value) { dbEntry.BasicInfoChange = true; } value = entry.Reason & Win32Api.USN_REASON_HARD_LINK_CHANGE; if (0 != value) { dbEntry.HardLinkChange = true; } value = entry.Reason & Win32Api.USN_REASON_COMPRESSION_CHANGE; if (0 != value) { dbEntry.CompressionChange = true; } value = entry.Reason & Win32Api.USN_REASON_ENCRYPTION_CHANGE; if (0 != value) { dbEntry.EncryptionChange = true; } value = entry.Reason & Win32Api.USN_REASON_OBJECT_ID_CHANGE; if (0 != value) { dbEntry.ObjectIdChange = true; } value = entry.Reason & Win32Api.USN_REASON_REPARSE_POINT_CHANGE; if (0 != value) { dbEntry.ReparsePointChange = true; } value = entry.Reason & Win32Api.USN_REASON_STREAM_CHANGE; if (0 != value) { dbEntry.StreamChange = true; } value = entry.Reason & Win32Api.USN_REASON_CLOSE; if (0 != value) { dbEntry.Close = true; } }
/// <summary> /// Saves the current document /// </summary> public void Save() { Win32Api.SendMessage(Handle, NppMsg.NPPM_SAVECURRENTFILE, 0, 0); }
private static bool RegisterRawInputDevice(Win32Api.RawInput.RAWINPUTDEVICE device) { RawInput.RAWINPUTDEVICE[] devices = new RawInput.RAWINPUTDEVICE[1]; // Raw input devices. devices[0] = device; return RawInput.RegisterRawInputDevices(devices, 1, Marshal.SizeOf(typeof(RawInput.RAWINPUTDEVICE))); }
/// <summary> /// For each created dialog in your plugin, you should register it (and unregister while destroy it) to Notepad++ by using this message. /// If this message is ignored, then your dialog won't react with the key stroke messages such as TAB key. /// For the good functioning of your plugin dialog, you're recommended to not ignore this message. /// </summary> public static void UnRegisterToNpp(IntPtr handle) { Win32Api.SendMessage(Handle, NppMsg.NPPM_MODELESSDIALOG, (int)NppMsg.MODELESSDIALOGREMOVE, handle); }