Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Shared / MS / Win32 / ManagedWndProcTracker.cs / 1 / ManagedWndProcTracker.cs
//#define LOGGING using System; using System.Collections; using System.Threading; using System.Runtime.InteropServices; using MS.Internal; using System.Security; using System.Security.Permissions; // The SecurityHelper class differs between assemblies and could not actually be // shared, so it is duplicated across namespaces to prevent name collision. #if WINDOWS_BASE using MS.Internal.WindowsBase; #elif PRESENTATION_CORE using MS.Internal.PresentationCore; #elif PRESENTATIONFRAMEWORK using MS.Internal.PresentationFramework; #elif DRT using MS.Internal.Drt; #else #error Attempt to use a class (duplicated across multiple namespaces) from an unknown assembly. #endif namespace MS.Win32 { internal static class ManagedWndProcTracker { ////// Critical: This code calls into Link demanded methods to attach handlers /// TreatAsSafe: This code does not take any parameter or return state. /// It simply attaches private call back. /// [SecurityCritical,SecurityTreatAsSafe] static ManagedWndProcTracker() { // Listen for ProcessExit so we can detach ourselves when the CLR shuts down // and avoid unmanaged code from calling back in to managed code during shutdown. ManagedWndProcTrackerShutDownListener listener = new ManagedWndProcTrackerShutDownListener(); } ////// Critical: Uses critical member _hwndList /// [SecurityCritical] internal static void TrackHwndSubclass(HwndSubclass subclass, IntPtr hwnd) { lock (_hwndList) { // We use HwndSubclass as the key and the hwnd ptr as the value. // This supports the case where two (or more) HwndSubclasses // get attached to the same Hwnd. At AppDomain shutdown, we may // end up sending the Detach message to the Hwnd more than once, // but that won't cause any harm. _hwndList[subclass] = hwnd; } #if LOGGING LogStartHWND(hwnd, "Core HwndWrapper..ctor"); #endif } ////// Critical: Uses critical member _hwndList /// [SecurityCritical] internal static void UnhookHwndSubclass(HwndSubclass subclass) { // if exiting the AppDomain, ignore this call. This avoids changing // the list during the loop in OnAppDomainProcessExit if (_exiting) return; lock (_hwndList) { _hwndList.Remove(subclass); } } ////// Critical performs an elevation to call HookUpDefWindowProc. /// TreatAsSafe - net effect of this is to remove our already registered WndProc's on domain shutdown. /// safe - as you had to elevate to add these already. Removing them is considered safe. /// [SecurityCritical, SecurityTreatAsSafe] private static void OnAppDomainProcessExit() { // AppDomain is exiting -- if anyone tries to call back into managed code // after this point, bad things will happen. We must remove all unmanaged // code references to our WndProc delegates. USER will explode if we set the // WndProc to null, so the next most reasonable thing we can do is hook up // the DefaultWindowProc. //DbgUserBreakPoint(); _exiting = true; lock (_hwndList) { new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); // BlessedAssert: try { foreach (DictionaryEntry entry in _hwndList) { IntPtr hwnd = (IntPtr)entry.Value; int windowStyle = UnsafeNativeMethods.GetWindowLong(new HandleRef(null,hwnd), NativeMethods.GWL_STYLE); if((windowStyle & NativeMethods.WS_CHILD) != 0) { // Tell all the HwndSubclass WndProcs for WS_CHILD windows // to detach themselves. This is particularly important when // the parent hwnd belongs to a separate AppDomain in a // cross AppDomain hosting scenario. In this scenario it is // possible that the host has subclassed the WS_CHILD window // and hence it is important to notify the host before we set the // WndProc to DefWndProc. Also note that we do not want to make a // blocking SendMessage call to all the subclassed Hwnds in the // AppDomain because this can lead to slow shutdown speed. // Eg. Consider a MessageOnlyHwnd created and subclassed on a // worker thread which is no longer responsive. The SendMessage // call in this case will block. To avoid this we limit the conversation // only to WS_CHILD windows. We understand that this solution is // not foolproof but it is the best outside of re-designing the cleanup // of Hwnd subclasses. UnsafeNativeMethods.SendMessage(hwnd, HwndSubclass.DetachMessage, IntPtr.Zero /* wildcard */, (IntPtr) 2 /* force and forward */); } // the last WndProc on the chain might be managed as well // (see HwndSubclass.SubclassWndProc for explanation). // Just in case, restore the DefaultWindowProc. HookUpDefWindowProc(hwnd); } } finally { CodeAccessPermission.RevertAssert(); } } } ////// TreatAsSafe: Demands for unmanaged code /// Critical: Elevates by calling an unverifieds UnsafeNativeMethod call /// [SecurityTreatAsSafe, SecurityCritical] private static void HookUpDefWindowProc(IntPtr hwnd) { SecurityHelper.DemandUnmanagedCode(); #if LOGGING LogFinishHWND(hwnd, "Core HookUpDWP"); #endif IntPtr result = IntPtr.Zero ; // We've already cleaned up, return immediately. if (hwnd == IntPtr.Zero) { return; } IntPtr defWindowProc = GetDefWindowProcAddress(hwnd); if (defWindowProc != IntPtr.Zero) { try { result = UnsafeNativeMethods.SetWindowLong(new HandleRef(null,hwnd), NativeMethods.GWL_WNDPROC, defWindowProc); } catch(System.ComponentModel.Win32Exception e) { // We failed to change the window proc. Now what? if (e.NativeErrorCode != 1400) // ERROR_INVALID_WINDOW_HANDLE { // For debugging purposes, throw an exception so we can debug // this and know if it's possible to call SetWindowLong on // the wrong thread. throw; } } if (result != IntPtr.Zero ) { UnsafeNativeMethods.PostMessage(new HandleRef(null,hwnd), NativeMethods.WM_CLOSE, IntPtr.Zero, IntPtr.Zero); } } } // Get the DWP for the given HWND -- returns DefWindowProcA or DefWindowProcW // depending on IsWindowUnicode(hwnd). private static IntPtr GetDefWindowProcAddress(IntPtr hwnd) { // We need to swap back in the DefWindowProc, but which one we use depends on // what the Unicode-ness of the window. if (SafeNativeMethods.IsWindowUnicode(new HandleRef(null,hwnd))) { if (_cachedDefWindowProcW == IntPtr.Zero) { _cachedDefWindowProcW = GetUser32ProcAddress("DefWindowProcW"); } return _cachedDefWindowProcW; } else { if (_cachedDefWindowProcA == IntPtr.Zero) { _cachedDefWindowProcA = GetUser32ProcAddress("DefWindowProcA") ; } return _cachedDefWindowProcA; } } ////// SecurityCritical: elevates via a call to unsafe native methods /// SecurityTreatAsSafe: Demands unmgd code permission via SecurityHelper /// [SecurityCritical, SecurityTreatAsSafe] private static IntPtr GetUser32ProcAddress(string export) { SecurityHelper.DemandUnmanagedCode(); IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(ExternDll.User32); if (hModule != IntPtr.Zero) { return UnsafeNativeMethods.GetProcAddress(new HandleRef(null, hModule), export); } return IntPtr.Zero; } private sealed class ManagedWndProcTrackerShutDownListener : ShutDownListener { ////// Critical: accesses AppDomain.DomainUnload event /// TreatAsSafe: This code does not take any parameter or return state. /// It simply attaches private callbacks. /// [SecurityCritical,SecurityTreatAsSafe] public ManagedWndProcTrackerShutDownListener() : base(null, ShutDownEvents.AppDomain) { } internal override void OnShutDown(object target) { ManagedWndProcTracker.OnAppDomainProcessExit(); } } #if LOGGING [DllImport("ntdll.dll")] private static extern void DbgUserBreakPoint(); [DllImport("ntdll.dll")] private static extern void DbgPrint(string msg); internal static void LogStartHWND(IntPtr hwnd, string fromWhere) { string msg = String.Format("BEGIN: {0:X} -- Setting DWP, process = {1} ({2}) {3}", hwnd, System.Diagnostics.Process.GetCurrentProcess().ProcessName, fromWhere, System.Environment.NewLine); Log(msg); } internal static void LogFinishHWND(IntPtr hwnd, string fromWhere) { string msg = String.Format("END: {0:X} -- Setting DWP, process = {1} ({2}) {3}", hwnd, System.Diagnostics.Process.GetCurrentProcess().ProcessName, fromWhere, System.Environment.NewLine); Log(msg); } private static void Log(string msg) { //DbgUserBreakPoint(); /* byte[] msgBytes = System.Text.Encoding.ASCII.GetBytes(msg); System.IO.FileStream fs = System.IO.File.Open("c:\\dwplog.txt", System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite); fs.Write(msgBytes, 0, msgBytes.Length); fs.Flush(); fs.Close(); */ } #endif private static IntPtr _cachedDefWindowProcA = IntPtr.Zero; private static IntPtr _cachedDefWindowProcW = IntPtr.Zero; ////// Critical - used as input to unsafe calls /// [SecurityCritical] private static Hashtable _hwndList = new Hashtable(10); private static bool _exiting = false; } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved. //#define LOGGING using System; using System.Collections; using System.Threading; using System.Runtime.InteropServices; using MS.Internal; using System.Security; using System.Security.Permissions; // The SecurityHelper class differs between assemblies and could not actually be // shared, so it is duplicated across namespaces to prevent name collision. #if WINDOWS_BASE using MS.Internal.WindowsBase; #elif PRESENTATION_CORE using MS.Internal.PresentationCore; #elif PRESENTATIONFRAMEWORK using MS.Internal.PresentationFramework; #elif DRT using MS.Internal.Drt; #else #error Attempt to use a class (duplicated across multiple namespaces) from an unknown assembly. #endif namespace MS.Win32 { internal static class ManagedWndProcTracker { ////// Critical: This code calls into Link demanded methods to attach handlers /// TreatAsSafe: This code does not take any parameter or return state. /// It simply attaches private call back. /// [SecurityCritical,SecurityTreatAsSafe] static ManagedWndProcTracker() { // Listen for ProcessExit so we can detach ourselves when the CLR shuts down // and avoid unmanaged code from calling back in to managed code during shutdown. ManagedWndProcTrackerShutDownListener listener = new ManagedWndProcTrackerShutDownListener(); } ////// Critical: Uses critical member _hwndList /// [SecurityCritical] internal static void TrackHwndSubclass(HwndSubclass subclass, IntPtr hwnd) { lock (_hwndList) { // We use HwndSubclass as the key and the hwnd ptr as the value. // This supports the case where two (or more) HwndSubclasses // get attached to the same Hwnd. At AppDomain shutdown, we may // end up sending the Detach message to the Hwnd more than once, // but that won't cause any harm. _hwndList[subclass] = hwnd; } #if LOGGING LogStartHWND(hwnd, "Core HwndWrapper..ctor"); #endif } ////// Critical: Uses critical member _hwndList /// [SecurityCritical] internal static void UnhookHwndSubclass(HwndSubclass subclass) { // if exiting the AppDomain, ignore this call. This avoids changing // the list during the loop in OnAppDomainProcessExit if (_exiting) return; lock (_hwndList) { _hwndList.Remove(subclass); } } ////// Critical performs an elevation to call HookUpDefWindowProc. /// TreatAsSafe - net effect of this is to remove our already registered WndProc's on domain shutdown. /// safe - as you had to elevate to add these already. Removing them is considered safe. /// [SecurityCritical, SecurityTreatAsSafe] private static void OnAppDomainProcessExit() { // AppDomain is exiting -- if anyone tries to call back into managed code // after this point, bad things will happen. We must remove all unmanaged // code references to our WndProc delegates. USER will explode if we set the // WndProc to null, so the next most reasonable thing we can do is hook up // the DefaultWindowProc. //DbgUserBreakPoint(); _exiting = true; lock (_hwndList) { new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert(); // BlessedAssert: try { foreach (DictionaryEntry entry in _hwndList) { IntPtr hwnd = (IntPtr)entry.Value; int windowStyle = UnsafeNativeMethods.GetWindowLong(new HandleRef(null,hwnd), NativeMethods.GWL_STYLE); if((windowStyle & NativeMethods.WS_CHILD) != 0) { // Tell all the HwndSubclass WndProcs for WS_CHILD windows // to detach themselves. This is particularly important when // the parent hwnd belongs to a separate AppDomain in a // cross AppDomain hosting scenario. In this scenario it is // possible that the host has subclassed the WS_CHILD window // and hence it is important to notify the host before we set the // WndProc to DefWndProc. Also note that we do not want to make a // blocking SendMessage call to all the subclassed Hwnds in the // AppDomain because this can lead to slow shutdown speed. // Eg. Consider a MessageOnlyHwnd created and subclassed on a // worker thread which is no longer responsive. The SendMessage // call in this case will block. To avoid this we limit the conversation // only to WS_CHILD windows. We understand that this solution is // not foolproof but it is the best outside of re-designing the cleanup // of Hwnd subclasses. UnsafeNativeMethods.SendMessage(hwnd, HwndSubclass.DetachMessage, IntPtr.Zero /* wildcard */, (IntPtr) 2 /* force and forward */); } // the last WndProc on the chain might be managed as well // (see HwndSubclass.SubclassWndProc for explanation). // Just in case, restore the DefaultWindowProc. HookUpDefWindowProc(hwnd); } } finally { CodeAccessPermission.RevertAssert(); } } } ////// TreatAsSafe: Demands for unmanaged code /// Critical: Elevates by calling an unverifieds UnsafeNativeMethod call /// [SecurityTreatAsSafe, SecurityCritical] private static void HookUpDefWindowProc(IntPtr hwnd) { SecurityHelper.DemandUnmanagedCode(); #if LOGGING LogFinishHWND(hwnd, "Core HookUpDWP"); #endif IntPtr result = IntPtr.Zero ; // We've already cleaned up, return immediately. if (hwnd == IntPtr.Zero) { return; } IntPtr defWindowProc = GetDefWindowProcAddress(hwnd); if (defWindowProc != IntPtr.Zero) { try { result = UnsafeNativeMethods.SetWindowLong(new HandleRef(null,hwnd), NativeMethods.GWL_WNDPROC, defWindowProc); } catch(System.ComponentModel.Win32Exception e) { // We failed to change the window proc. Now what? if (e.NativeErrorCode != 1400) // ERROR_INVALID_WINDOW_HANDLE { // For debugging purposes, throw an exception so we can debug // this and know if it's possible to call SetWindowLong on // the wrong thread. throw; } } if (result != IntPtr.Zero ) { UnsafeNativeMethods.PostMessage(new HandleRef(null,hwnd), NativeMethods.WM_CLOSE, IntPtr.Zero, IntPtr.Zero); } } } // Get the DWP for the given HWND -- returns DefWindowProcA or DefWindowProcW // depending on IsWindowUnicode(hwnd). private static IntPtr GetDefWindowProcAddress(IntPtr hwnd) { // We need to swap back in the DefWindowProc, but which one we use depends on // what the Unicode-ness of the window. if (SafeNativeMethods.IsWindowUnicode(new HandleRef(null,hwnd))) { if (_cachedDefWindowProcW == IntPtr.Zero) { _cachedDefWindowProcW = GetUser32ProcAddress("DefWindowProcW"); } return _cachedDefWindowProcW; } else { if (_cachedDefWindowProcA == IntPtr.Zero) { _cachedDefWindowProcA = GetUser32ProcAddress("DefWindowProcA") ; } return _cachedDefWindowProcA; } } ////// SecurityCritical: elevates via a call to unsafe native methods /// SecurityTreatAsSafe: Demands unmgd code permission via SecurityHelper /// [SecurityCritical, SecurityTreatAsSafe] private static IntPtr GetUser32ProcAddress(string export) { SecurityHelper.DemandUnmanagedCode(); IntPtr hModule = UnsafeNativeMethods.GetModuleHandle(ExternDll.User32); if (hModule != IntPtr.Zero) { return UnsafeNativeMethods.GetProcAddress(new HandleRef(null, hModule), export); } return IntPtr.Zero; } private sealed class ManagedWndProcTrackerShutDownListener : ShutDownListener { ////// Critical: accesses AppDomain.DomainUnload event /// TreatAsSafe: This code does not take any parameter or return state. /// It simply attaches private callbacks. /// [SecurityCritical,SecurityTreatAsSafe] public ManagedWndProcTrackerShutDownListener() : base(null, ShutDownEvents.AppDomain) { } internal override void OnShutDown(object target) { ManagedWndProcTracker.OnAppDomainProcessExit(); } } #if LOGGING [DllImport("ntdll.dll")] private static extern void DbgUserBreakPoint(); [DllImport("ntdll.dll")] private static extern void DbgPrint(string msg); internal static void LogStartHWND(IntPtr hwnd, string fromWhere) { string msg = String.Format("BEGIN: {0:X} -- Setting DWP, process = {1} ({2}) {3}", hwnd, System.Diagnostics.Process.GetCurrentProcess().ProcessName, fromWhere, System.Environment.NewLine); Log(msg); } internal static void LogFinishHWND(IntPtr hwnd, string fromWhere) { string msg = String.Format("END: {0:X} -- Setting DWP, process = {1} ({2}) {3}", hwnd, System.Diagnostics.Process.GetCurrentProcess().ProcessName, fromWhere, System.Environment.NewLine); Log(msg); } private static void Log(string msg) { //DbgUserBreakPoint(); /* byte[] msgBytes = System.Text.Encoding.ASCII.GetBytes(msg); System.IO.FileStream fs = System.IO.File.Open("c:\\dwplog.txt", System.IO.FileMode.Append, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite); fs.Write(msgBytes, 0, msgBytes.Length); fs.Flush(); fs.Close(); */ } #endif private static IntPtr _cachedDefWindowProcA = IntPtr.Zero; private static IntPtr _cachedDefWindowProcW = IntPtr.Zero; ////// Critical - used as input to unsafe calls /// [SecurityCritical] private static Hashtable _hwndList = new Hashtable(10); private static bool _exiting = false; } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ManipulationDeltaEventArgs.cs
- LinqDataSourceStatusEventArgs.cs
- CreateUserErrorEventArgs.cs
- DBAsyncResult.cs
- WindowsRichEditRange.cs
- PlainXmlWriter.cs
- ParseNumbers.cs
- GeometryGroup.cs
- ConnectionProviderAttribute.cs
- SqlTrackingQuery.cs
- XmlLanguage.cs
- ProfessionalColors.cs
- HttpClientCertificate.cs
- TextElementEditingBehaviorAttribute.cs
- VirtualDirectoryMapping.cs
- FontStyles.cs
- OdbcConnectionHandle.cs
- BindingMemberInfo.cs
- DesignerSerializerAttribute.cs
- VisualTreeFlattener.cs
- SqlClientMetaDataCollectionNames.cs
- BinaryEditor.cs
- ArrayEditor.cs
- ToolStripItemDataObject.cs
- UIElement3DAutomationPeer.cs
- RawStylusInputCustomData.cs
- SiteMapProvider.cs
- webclient.cs
- DataGridToolTip.cs
- ProfileModule.cs
- DataRowComparer.cs
- NativeObjectSecurity.cs
- SecureStringHasher.cs
- WorkflowServiceOperationListItem.cs
- FontWeights.cs
- CodeGeneratorAttribute.cs
- GcSettings.cs
- LightweightCodeGenerator.cs
- BitFlagsGenerator.cs
- XmlSchemaInclude.cs
- PropertyEntry.cs
- OdbcConnection.cs
- ComplexTypeEmitter.cs
- ConstraintManager.cs
- KnownBoxes.cs
- OrderByBuilder.cs
- HtmlInputCheckBox.cs
- PathTooLongException.cs
- BufferBuilder.cs
- ChangeNode.cs
- RelatedImageListAttribute.cs
- ResourcePermissionBaseEntry.cs
- ElementHost.cs
- HotSpotCollection.cs
- TableCell.cs
- AssemblyBuilder.cs
- UnionExpr.cs
- CompositeCollectionView.cs
- FloaterParaClient.cs
- DiscoveryService.cs
- DataGridViewTopLeftHeaderCell.cs
- DrawToolTipEventArgs.cs
- XmlnsDictionary.cs
- EmbeddedMailObjectCollectionEditor.cs
- DataGridTableCollection.cs
- BaseWebProxyFinder.cs
- TreeView.cs
- TheQuery.cs
- OutputChannelBinder.cs
- FunctionDetailsReader.cs
- RuntimeTrackingProfile.cs
- XmlDeclaration.cs
- BindingContext.cs
- _NegoState.cs
- LinearKeyFrames.cs
- XmlRawWriter.cs
- ReflectTypeDescriptionProvider.cs
- ListViewContainer.cs
- SQLConvert.cs
- PageStatePersister.cs
- DataFormats.cs
- _Rfc2616CacheValidators.cs
- RegistrySecurity.cs
- DynamicResourceExtensionConverter.cs
- TransportOutputChannel.cs
- CompareValidator.cs
- DocumentApplicationJournalEntryEventArgs.cs
- DLinqAssociationProvider.cs
- PageAsyncTaskManager.cs
- OleDbEnumerator.cs
- CatalogPartCollection.cs
- OleDbStruct.cs
- Typeface.cs
- TableLayoutPanelResizeGlyph.cs
- Utility.cs
- SamlAction.cs
- WhereaboutsReader.cs
- StsCommunicationException.cs
- ViewManager.cs
- ImplicitInputBrush.cs