Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Shared / MS / Win32 / UnsafeNativeMethodsCLR.cs / 2 / UnsafeNativeMethodsCLR.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace MS.Win32
{
using Accessibility;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using System.Runtime.ConstrainedExecution;
using System;
using System.Security.Permissions;
using System.Collections;
using System.IO;
using System.Text;
using System.Security;
using System.Diagnostics;
using System.ComponentModel;
using MS.Win32 ;
// 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
using IComDataObject = System.Runtime.InteropServices.ComTypes.IDataObject;
internal partial class UnsafeNativeMethods {
private struct POINTSTRUCT {
public int x;
public int y;
public POINTSTRUCT(int x, int y) {
this.x = x;
this.y = y;
}
}
// For some reason "PtrToStructure" requires super high permission.
///
/// Critical: The code below has a link demand for unmanaged code permission.This code can be used to
/// get to data that a pointer points to which can lead to easier data reading.
///
[SecurityCritical]
public static object PtrToStructure(IntPtr lparam, Type cls) {
return Marshal.PtrToStructure(lparam, cls);
}
// For some reason "StructureToPtr" requires super high permission.
///
/// Critical: The code below has a link demand for unmanaged code permission.This code can be used to
/// write data to arbitrary memory.
///
[SecurityCritical]
public static void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld)
{
Marshal.StructureToPtr(structure, ptr, fDeleteOld);
}
#if BASE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Ole32, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern int OleGetClipboard(ref IComDataObject data);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Ole32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern int OleSetClipboard(IComDataObject pDataObj);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Ole32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern int OleFlushClipboard();
#endif
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Uxtheme, CharSet = CharSet.Auto, BestFitMapping = false)]
public static extern int GetCurrentThemeName(StringBuilder pszThemeFileName, int dwMaxNameChars, StringBuilder pszColorBuff, int dwMaxColorChars, StringBuilder pszSizeBuff, int cchMaxSizeChars);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.DwmAPI, BestFitMapping = false)]
public static extern int DwmIsCompositionEnabled(out Int32 enabled);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern IntPtr GetCurrentThread();
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false)]
public static extern int RegisterWindowMessage(string msg);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, EntryPoint = "SetWindowPos", ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true)]
public static extern bool SetWindowPos(HandleRef hWnd, HandleRef hWndInsertAfter, int x, int y, int cx, int cy, int flags);
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true)]
public static extern IntPtr GetWindow(HandleRef hWnd, int uCmd);
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false)]
public static extern int GetClassName(HandleRef hwnd, StringBuilder lpClassName, int nMaxCount);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false)]
public static extern int MessageBox(HandleRef hWnd, string text, string caption, int type);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Uxtheme, CharSet = CharSet.Auto, BestFitMapping = false, EntryPoint = "SetWindowTheme")]
public static extern int CriticalSetWindowTheme(HandleRef hWnd, string subAppName, string subIdList);
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, EntryPoint = "CreateCompatibleBitmap", CharSet = CharSet.Auto)]
public static extern IntPtr CreateCompatibleBitmap(HandleRef hDC, int width, int height);
///
/// Critical - elevates via a SUC. Can be used to run arbitrary code.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, EntryPoint = "CreateCompatibleBitmap", CharSet = CharSet.Auto)]
public static extern IntPtr CriticalCreateCompatibleBitmap(HandleRef hDC, int width, int height);
///
/// Critical - elevates via a SUC. Can be used to run arbitrary code.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, EntryPoint = "GetStockObject", SetLastError = true, CharSet = CharSet.Auto)]
public static extern IntPtr CriticalGetStockObject(int stockObject);
///
/// Critical - elevates via a SUC. Can be used to run arbitrary code.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "FillRect", SetLastError = true, CharSet = CharSet.Auto)]
public static extern int CriticalFillRect(IntPtr hdc, ref NativeMethods.RECT rcFill, IntPtr brush);
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern int GetBitmapBits(HandleRef hbmp, int cbBuffer, byte[] lpvBits);
///
/// Critical: This code escalates to unmanaged code permission
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool ShowWindow(HandleRef hWnd, int nCmdShow);
///
/// Critical: This code escalates to unmanaged code permission
///
[SecurityCritical]
public static void DeleteObject(HandleRef hObject)
{
HandleCollector.Remove((IntPtr)hObject, NativeMethods.CommonHandles.GDI);
if (!IntDeleteObject(hObject))
{
throw new Win32Exception();
}
}
///
/// Critical: This code escalates to unmanaged code permission via a call to IntDeleteObject
///
[SecurityCritical]
public static bool DeleteObjectNoThrow(HandleRef hObject)
{
HandleCollector.Remove((IntPtr)hObject, NativeMethods.CommonHandles.GDI);
bool result = IntDeleteObject(hObject);
int error = Marshal.GetLastWin32Error();
if(!result)
{
Debug.WriteLine("DeleteObject failed. Error = " + error);
}
return result;
}
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Gdi32, SetLastError=true, ExactSpelling = true, EntryPoint="DeleteObject", CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool IntDeleteObject(HandleRef hObject);
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern IntPtr SelectObject(HandleRef hdc, IntPtr obj);
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Gdi32, EntryPoint="SelectObject", SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern IntPtr CriticalSelectObject(HandleRef hdc, IntPtr obj);
[DllImport(ExternDll.User32, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false, SetLastError = true)]
public static extern int GetClipboardFormatName(int format, StringBuilder lpString, int cchMax);
///
/// This code elevates to unmanaged code permission
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, BestFitMapping = false)]
public static extern int RegisterClipboardFormat(string format);
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool BitBlt(HandleRef hDC, int x, int y, int nWidth, int nHeight,
HandleRef hSrcDC, int xSrc, int ySrc, int dwRop);
///
/// This code elevates to unmanaged code permission
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="PrintWindow", SetLastError = true, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool CriticalPrintWindow(HandleRef hWnd, HandleRef hDC, int flags);
///
/// This code elevates to unmanaged code permission
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="RedrawWindow", ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool CriticalRedrawWindow(HandleRef hWnd, IntPtr lprcUpdate, IntPtr hrgnUpdate, int flags);
[DllImport(ExternDll.Shell32, CharSet=CharSet.Auto, BestFitMapping = false)]
public static extern int DragQueryFile(HandleRef hDrop, int iFile, StringBuilder lpszFile, int cch);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Shell32, CharSet=CharSet.Auto, BestFitMapping = false)]
public static extern IntPtr ShellExecute(HandleRef hwnd, string lpOperation, string lpFile, string lpParameters, string lpDirectory, int nShowCmd);
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
internal class ShellExecuteInfo
{
public int cbSize;
public ShellExecuteFlags fMask;
public IntPtr hwnd;
public string lpVerb;
public string lpFile;
public string lpParameters;
public string lpDirectory;
public int nShow;
public IntPtr hInstApp;
public IntPtr lpIDList;
public string lpClass;
public IntPtr hkeyClass;
public int dwHotKey;
public IntPtr hIcon;
public IntPtr hProcess;
}
[Flags]
internal enum ShellExecuteFlags
{
SEE_MASK_CLASSNAME = 0x00000001,
SEE_MASK_CLASSKEY = 0x00000003,
SEE_MASK_NOCLOSEPROCESS = 0x00000040,
SEE_MASK_FLAG_DDEWAIT = 0x00000100,
SEE_MASK_DOENVSUBST = 0x00000200,
SEE_MASK_FLAG_NO_UI = 0x00000400,
SEE_MASK_UNICODE = 0x00004000,
SEE_MASK_NO_CONSOLE = 0x00008000,
SEE_MASK_ASYNCOK = 0x00100000,
SEE_MASK_HMONITOR = 0x00200000,
SEE_MASK_NOZONECHECKS = 0x00800000,
SEE_MASK_NOQUERYCLASSSTORE = 0x01000000,
SEE_MASK_WAITFORINPUTIDLE = 0x02000000
};
///
/// Critical - elevates via SUC. Starts a new process.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Shell32, CharSet = CharSet.Unicode, SetLastError = true)]
internal static extern bool ShellExecuteEx([In, Out] ShellExecuteInfo lpExecInfo);
public const int MB_PRECOMPOSED = 0x00000001;
public const int MB_COMPOSITE = 0x00000002;
public const int MB_USEGLYPHCHARS = 0x00000004;
public const int MB_ERR_INVALID_CHARS = 0x00000008;
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Kernel32, ExactSpelling=true, CharSet=CharSet.Unicode, SetLastError=true)]
public static extern int MultiByteToWideChar(int CodePage, int dwFlags, byte[] lpMultiByteStr, int cchMultiByte, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpWideCharStr, int cchWideChar);
///
/// Critical - elevates (via SuppressUnmanagedCodeSecurity).
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.Kernel32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Unicode)]
public static extern int WideCharToMultiByte(int codePage, int flags, [MarshalAs(UnmanagedType.LPWStr)]string wideStr, int chars, [In,Out]byte[] pOutBytes, int bufferBytes, IntPtr defaultChar, IntPtr pDefaultUsed);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling=true, EntryPoint="RtlMoveMemory", CharSet=CharSet.Unicode)]
public static extern void CopyMemoryW(IntPtr pdst, string psrc, int cb);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, EntryPoint = "RtlMoveMemory", CharSet = CharSet.Unicode)]
public static extern void CopyMemoryW(IntPtr pdst, char[] psrc, int cb);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling=true, EntryPoint="RtlMoveMemory")]
public static extern void CopyMemory(IntPtr pdst, byte[] psrc, int cb);
#if BASE_NATIVEMETHODS
///
/// Critical as this code performs an elevation due to an unmanaged code call. Also this
/// information can be used to exploit the system.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="GetKeyboardState", CharSet=CharSet.Auto, SetLastError=true)]
private static extern int IntGetKeyboardState(byte [] keystate);
[SecurityCritical]
public static void GetKeyboardState(byte [] keystate)
{
if(IntGetKeyboardState(keystate) == 0)
{
throw new Win32Exception();
}
}
#endif
#if DRT_NATIVEMETHODS
[DllImport(ExternDll.User32, ExactSpelling=true, EntryPoint="keybd_event", CharSet=CharSet.Auto)]
public static extern void Keybd_event(byte vk, byte scan, int flags, IntPtr extrainfo);
#endif
///
/// Critical: This code elevates to unmanaged code permission
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, EntryPoint = "GetModuleFileName", CharSet = CharSet.Auto, BestFitMapping = false, SetLastError = true)]
private static extern int IntGetModuleFileName(HandleRef hModule, StringBuilder buffer, int length);
///
/// Critical: This code elevates to unmanaged code permission by calling into IntGetModuleFileName
///
[SecurityCritical]
internal static int GetModuleFileName(HandleRef hModule, StringBuilder buffer, int length)
{
int size = IntGetModuleFileName(hModule, buffer, length);
if (size == 0)
{
throw new Win32Exception();
}
return size;
}
#if BASE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern bool TranslateMessage([In, Out] ref System.Windows.Interop.MSG msg);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, CharSet=CharSet.Auto)]
public static extern IntPtr DispatchMessage([In] ref System.Windows.Interop.MSG msg);
#endif
#if BASE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, CharSet=CharSet.Auto, EntryPoint="PostThreadMessage", SetLastError=true)]
private static extern int IntPostThreadMessage(int id, int msg, IntPtr wparam, IntPtr lparam);
[SecurityCritical]
public static void PostThreadMessage(int id, int msg, IntPtr wparam, IntPtr lparam)
{
if(IntPostThreadMessage(id, msg, wparam, lparam) == 0)
{
throw new Win32Exception();
}
}
#endif
///
/// Critical - elevates via a SUC. Can be used to run arbitrary code.
///
[return: MarshalAs(UnmanagedType.Interface)]
[DllImport(ExternDll.Ole32, ExactSpelling = true, PreserveSig = false)]
[SecurityCritical, SuppressUnmanagedCodeSecurity]
public static extern object CoCreateInstance(
[In]
ref Guid clsid,
[MarshalAs(UnmanagedType.Interface)]
object punkOuter,
int context,
[In]
ref Guid iid);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Ole32, EntryPoint="OleInitialize")]
private static extern int IntOleInitialize(IntPtr val);
[SecurityCritical]
public static int OleInitialize()
{
return IntOleInitialize(IntPtr.Zero);
}
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public extern static bool EnumThreadWindows(int dwThreadId, NativeMethods.EnumThreadWindowsCallback lpfn, HandleRef lParam);
///
/// Critical: This code calls into unmanaged code which elevates
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Ole32, ExactSpelling=true, CharSet=CharSet.Auto, SetLastError=true)]
public static extern int OleUninitialize();
[DllImport(ExternDll.Kernel32, EntryPoint="CloseHandle", CharSet=CharSet.Auto, SetLastError=true)]
private static extern bool IntCloseHandle(HandleRef handle);
/*
public static void CloseHandle(HandleRef handle)
{
HandleCollector.Remove((IntPtr)handle, NativeMethods.CommonHandles.Kernel);
if(!IntCloseHandle(handle))
{
throw new Win32Exception();
}
}
*/
///
/// Critical: Closes a passed in handle, LinkDemand on Marshal.GetLastWin32Error
///
[SecurityCritical]
public static bool CloseHandleNoThrow(HandleRef handle)
{
HandleCollector.Remove((IntPtr)handle, NativeMethods.CommonHandles.Kernel);
bool result = IntCloseHandle(handle);
int error = Marshal.GetLastWin32Error();
if(!result)
{
Debug.WriteLine("CloseHandle failed. Error = " + error);
}
return result;
}
///
/// Critical as this code performs an UnmanagedCodeSecurity elevation.
///
[SecurityCritical]
[DllImport(ExternDll.Ole32, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern int CreateStreamOnHGlobal(IntPtr hGlobal, bool fDeleteOnRelease, ref System.Runtime.InteropServices.ComTypes.IStream istream);
#if BASE_NATIVEMETHODS
[DllImport(ExternDll.Gdi32, SetLastError=true, EntryPoint="CreateCompatibleDC", CharSet=CharSet.Auto)]
private static extern IntPtr IntCreateCompatibleDC(HandleRef hDC);
///
/// Critical - elevates via a SUC. Can be used to run arbitrary code.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError=true, EntryPoint="CreateCompatibleDC", CharSet=CharSet.Auto)]
public static extern IntPtr CriticalCreateCompatibleDC(HandleRef hDC);
///
/// Critical: LinkDemand on Win32Exception constructor
/// TreatAsSafe: Throwing an exception isn't unsafe
/// Note: If SupressUnmanagedCodeSecurity attribute is ever added to IntCreateCompatibleDC, we need to be Critical
///
[SecurityCritical, SecurityTreatAsSafe]
public static IntPtr CreateCompatibleDC(HandleRef hDC)
{
IntPtr h = IntCreateCompatibleDC(hDC);
if(h == IntPtr.Zero)
{
throw new Win32Exception();
}
return HandleCollector.Add(h, NativeMethods.CommonHandles.HDC);
}
#endif
[DllImport(ExternDll.Kernel32, EntryPoint="UnmapViewOfFile", CharSet=CharSet.Auto, SetLastError=true)]
private static extern bool IntUnmapViewOfFile(HandleRef pvBaseAddress);
/*
///
/// Critical: LinkDemand on Win32Exception constructor
/// TreatAsSafe: Throwing an exception isn't unsafe
/// Note: If SupressUnmanagedCodeSecurity attribute is ever added to IntUnmapViewOfFile, we need to be Critical
///
[SecurityCritical, SecurityTreatAsSafe]
public static void UnmapViewOfFile(HandleRef pvBaseAddress)
{
HandleCollector.Remove((IntPtr)pvBaseAddress, NativeMethods.CommonHandles.Kernel);
if(IntUnmapViewOfFile(pvBaseAddress) == 0)
{
throw new Win32Exception();
}
}
*/
///
/// Critical: Unmaps a file handle, LinkDemand on Marshal.GetLastWin32Error
///
[SecurityCritical]
public static bool UnmapViewOfFileNoThrow(HandleRef pvBaseAddress)
{
HandleCollector.Remove((IntPtr)pvBaseAddress, NativeMethods.CommonHandles.Kernel);
bool result = IntUnmapViewOfFile(pvBaseAddress);
int error = Marshal.GetLastWin32Error();
if(!result)
{
Debug.WriteLine("UnmapViewOfFile failed. Error = " + error);
}
return result;
}
///
/// Critical: This code calls into unmanaged code which elevates
///
[SecurityCritical]
public static bool EnableWindow(HandleRef hWnd, bool enable)
{
UnsafeNativeMethods.SetLastError(0);
bool result = IntEnableWindow(hWnd, enable);
if(!result)
{
int win32Err = Marshal.GetLastWin32Error();
if(win32Err != 0)
{
throw new Win32Exception(win32Err);
}
}
return result;
}
///
/// Critical: This code calls into unmanaged code which elevates
///
[SecurityCritical]
public static bool EnableWindowNoThrow(HandleRef hWnd, bool enable)
{
// This method is not throwing because the caller don't want to fail after calling this.
// If the window was not previously disabled, the return value is zero, else it is non-zero.
return IntEnableWindowNoThrow(hWnd, enable);
}
///
/// Critical: This code calls into unmanaged code which elevates
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="EnableWindow", SetLastError = true, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool IntEnableWindow(HandleRef hWnd, bool enable);
///
/// Critical: This code calls into unmanaged code which elevates
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="EnableWindow", CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool IntEnableWindowNoThrow(HandleRef hWnd, bool enable);
// GetObject stuff
[DllImport(ExternDll.Gdi32, SetLastError=true, CharSet=CharSet.Auto)]
public static extern int GetObject(HandleRef hObject, int nSize, [In, Out] NativeMethods.BITMAP bm);
///
/// Critical: This code returns the window which has focus and elevates to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern IntPtr GetFocus();
///
/// Critical - this code elevates via SUC.
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "GetCursorPos", ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
private static extern bool IntGetCursorPos([In, Out] NativeMethods.POINT pt);
///
/// Critical - calls a critical function.
///
[SecurityCritical]
internal static bool GetCursorPos([In, Out] NativeMethods.POINT pt)
{
bool returnValue = IntGetCursorPos(pt);
if (returnValue == false)
{
throw new Win32Exception();
}
return returnValue;
}
///
/// Critical - this code elevates via SUC.
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "GetCursorPos", ExactSpelling = true, CharSet = CharSet.Auto)]
private static extern bool IntTryGetCursorPos([In, Out] NativeMethods.POINT pt);
///
/// Critical - calls a critical function.
///
[SecurityCritical]
internal static bool TryGetCursorPos([In, Out] NativeMethods.POINT pt)
{
bool returnValue = IntTryGetCursorPos(pt);
// Sometimes Win32 will fail this call, such as if you are
// not running in the interactive desktop. For example,
// a secure screen saver may be running.
if (returnValue == false)
{
System.Diagnostics.Debug.WriteLine("GetCursorPos failed!");
pt.x = 0;
pt.y = 0;
}
return returnValue;
}
#if BASE_NATIVEMETHODS || CORE_NATIVEMETHODS || FRAMEWORK_NATIVEMETHODS
///
/// Critical:Unmanaged code that gets the state of the keyboard keys
/// This can be exploited to get keyboard state.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern int GetWindowThreadProcessId(HandleRef hWnd, out int lpdwProcessId);
///
/// Critical:Unmanaged code that gets the state of the keyboard keys
/// This can be exploited to get keyboard state.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern short GetKeyState(int keyCode);
[DllImport(ExternDll.Ole32, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto, PreserveSig = false)]
public static extern void DoDragDrop(IComDataObject dataObject, UnsafeNativeMethods.IOleDropSource dropSource, int allowedEffects, int[] finalEffect);
///
/// Critical - this code elevates via SUC.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Auto)]
public static extern bool InvalidateRect(HandleRef hWnd, IntPtr rect, bool erase);
#endif
///
/// Critical - this code elevates via SUC.
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "GetWindowText", CharSet=CharSet.Auto, BestFitMapping = false, SetLastError = true)]
private static extern int IntGetWindowText(HandleRef hWnd, [Out] StringBuilder lpString, int nMaxCount);
///
/// SecurityCritical due to a call to SetLastError and calls GetWindowText
///
[SecurityCritical]
internal static int GetWindowText(HandleRef hWnd, [Out] StringBuilder lpString, int nMaxCount)
{
SetLastError(0);
int returnValue = IntGetWindowText(hWnd, lpString, nMaxCount);
if (returnValue == 0)
{
int win32Err = Marshal.GetLastWin32Error();
if (win32Err != 0)
{
throw new Win32Exception(win32Err);
}
}
return returnValue;
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "GetWindowTextLength", CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true)]
private static extern int IntGetWindowTextLength(HandleRef hWnd);
///
/// SecurityCritical due to a call to SetLastError
///
[SecurityCritical]
internal static int GetWindowTextLength(HandleRef hWnd)
{
SetLastError(0);
int returnValue = IntGetWindowTextLength(hWnd);
if (returnValue == 0)
{
int win32Err = Marshal.GetLastWin32Error();
if (win32Err != 0)
{
throw new Win32Exception(win32Err);
}
}
return returnValue;
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GlobalAlloc(int uFlags, IntPtr dwBytes);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GlobalReAlloc(HandleRef handle, IntPtr bytes, int flags);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GlobalLock(HandleRef handle);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool GlobalUnlock(HandleRef handle);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GlobalFree(HandleRef handle);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
public static extern IntPtr GlobalSize(HandleRef handle);
#if BASE_NATIVEMETHODS || CORE_NATIVEMETHODS || FRAMEWORK_NATIVEMETHODS
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet=CharSet.Auto)]
public static extern bool ImmSetConversionStatus(HandleRef hIMC, int conversion, int sentence);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet=CharSet.Auto)]
public static extern bool ImmGetConversionStatus(HandleRef hIMC, ref int conversion, ref int sentence);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern IntPtr ImmGetContext(HandleRef hWnd);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern bool ImmReleaseContext(HandleRef hWnd, HandleRef hIMC);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet=CharSet.Auto)]
public static extern IntPtr ImmAssociateContext(HandleRef hWnd, HandleRef hIMC);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern bool ImmSetOpenStatus(HandleRef hIMC, bool open);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern bool ImmGetOpenStatus(HandleRef hIMC);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern bool ImmNotifyIME(HandleRef hIMC, int dwAction, int dwIndex, int dwValue);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet=CharSet.Auto)]
public static extern int ImmGetProperty(HandleRef hkl, int flags);
// ImmGetCompositionString for result and composition strings
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmGetCompositionString(HandleRef hIMC, int dwIndex, char[] lpBuf, int dwBufLen);
// ImmGetCompositionString for display attributes
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmGetCompositionString(HandleRef hIMC, int dwIndex, byte[] lpBuf, int dwBufLen);
// ImmGetCompositionString for clause information
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmGetCompositionString(HandleRef hIMC, int dwIndex, int[] lpBuf, int dwBufLen);
// ImmGetCompositionString for query information
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmGetCompositionString(HandleRef hIMC, int dwIndex, IntPtr lpBuf, int dwBufLen);
//[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
//public static extern int ImmSetCompositionFont(HandleRef hIMC, [In, Out] ref NativeMethods.LOGFONT lf);
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmConfigureIME(HandleRef hkl, HandleRef hwnd, int dwData, IntPtr pvoid);
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmConfigureIME(HandleRef hkl, HandleRef hwnd, int dwData, [In] ref NativeMethods.REGISTERWORD registerWord);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmSetCompositionWindow(HandleRef hIMC, [In, Out] ref NativeMethods.COMPOSITIONFORM compform);
///
/// Critical:This code causes an elevation of privilige to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern int ImmSetCandidateWindow(HandleRef hIMC, [In, Out] ref NativeMethods.CANDIDATEFORM candform);
[DllImport(ExternDll.Imm32, CharSet = CharSet.Auto)]
public static extern IntPtr ImmGetDefaultIMEWnd(HandleRef hwnd);
#endif
///
/// SecurityCritical: This code happens to return a critical resource and causes unmanaged code elevation
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="SetFocus", ExactSpelling=true, CharSet=CharSet.Auto, SetLastError=true)]
private static extern IntPtr IntSetFocus(HandleRef hWnd);
///
/// Critical - calls IntSetFocus (the real PInvoke method)
///
[SecurityCritical]
internal static IntPtr SetFocus(HandleRef hWnd)
{
SetLastError(0);
IntPtr retVal = IntSetFocus(hWnd);
int errorCode = Marshal.GetLastWin32Error();
if (retVal == IntPtr.Zero)
{
if (errorCode != 0)
{
throw new Win32Exception(errorCode);
}
}
return retVal;
}
///
/// Critical - calls IntSetFocus (the real PInvoke method)
///
[SecurityCritical]
internal static bool TrySetFocus(HandleRef hWnd, ref IntPtr result)
{
SetLastError(0);
result = IntSetFocus(hWnd);
int errorCode = Marshal.GetLastWin32Error();
if (result == IntPtr.Zero)
{
if (errorCode != 0)
{
return false;
}
}
return true;
}
///
/// Critical: It calls methods with SuppressUnmanagedCodeSecurity attribute, Win32 call
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "GetParent", ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr IntGetParent(HandleRef hWnd);
///
/// Critical - it calls SetLastError, which is Critical. it returns an IntPtr that represents the parent of a given hwnd.
///
[SecurityCritical]
internal static IntPtr GetParent(HandleRef hWnd)
{
const int successErrorCode = 0;
SetLastError(successErrorCode);
IntPtr retVal = IntGetParent(hWnd);
int errorCode = Marshal.GetLastWin32Error();
if (retVal == IntPtr.Zero)
{
if (errorCode != successErrorCode)
{
throw new Win32Exception(errorCode);
}
}
return retVal;
}
///
/// Critical - This code returns a critical resource and causes unmanaged code elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern IntPtr GetAncestor(HandleRef hWnd, int flags);
///
/// Critical - This code causes unmanaged code elevation.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32, SetLastError = true, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern bool IsChild(HandleRef hWndParent, HandleRef hwnd);
//*****************
//
// if you're thinking of enabling either of the functions below.
// you should first take a look at SafeSecurityHelper.TransformGlobalRectToLocal & TransformLocalRectToScreen
// they likely do what you typically use the function for - and it's safe to use.
// if you use the function below - you will get exceptions in partial trust.
// anyquestions - email avsee.
//
//******************
///
/// Critical as this code performs an elevation.
///
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
[ SecurityCritical, SuppressUnmanagedCodeSecurity]
public static extern IntPtr SetParent(HandleRef hWnd, HandleRef hWndParent);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, EntryPoint = "GetModuleHandle", CharSet = CharSet.Auto, BestFitMapping = false, ThrowOnUnmappableChar = true, SetLastError = true)]
private static extern IntPtr IntGetModuleHandle(string modName);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
internal static IntPtr GetModuleHandle(string modName)
{
IntPtr retVal = IntGetModuleHandle(modName);
if (retVal == IntPtr.Zero)
{
throw new Win32Exception();
}
return retVal;
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, CharSet=CharSet.Auto)]
public static extern IntPtr CallWindowProc(IntPtr wndProc, IntPtr hWnd, int msg,
IntPtr wParam, IntPtr lParam);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, SetLastError=true, EntryPoint="GetProcAddress", CharSet=CharSet.Ansi, BestFitMapping=false)]
public static extern IntPtr IntGetProcAddress(HandleRef hModule, string lpProcName);
///
/// Critical - calls IntGetProcAddress (the real PInvoke method)
///
[SecurityCritical]
public static IntPtr GetProcAddress(HandleRef hModule, string lpProcName)
{
IntPtr result = IntGetProcAddress(hModule, lpProcName);
if(result == IntPtr.Zero)
{
throw new Win32Exception();
}
return result;
}
// GetProcAddress Note : The lpProcName parameter can identify the DLL function by specifying an ordinal value associated
// with the function in the EXPORTS statement. GetProcAddress verifies that the specified ordinal is in
// the range 1 through the highest ordinal value exported in the .def file. The function then uses the
// ordinal as an index to read the function's address from a function table. If the .def file does not number
// the functions consecutively from 1 to N (where N is the number of exported functions), an error can
// occur where GetProcAddress returns an invalid, non-NULL address, even though there is no function with the specified ordinal.
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, EntryPoint="GetProcAddress", CharSet=CharSet.Ansi, BestFitMapping=false)]
public static extern IntPtr GetProcAddressNoThrow(HandleRef hModule, string lpProcName);
///
/// Critical: as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, CharSet = CharSet.Unicode)]
public static extern IntPtr LoadLibrary(string lpFileName);
#if BASE_NATIVEMETHODS || FRAMEWORK_NATIVEMETHODS || CORE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern int GetSystemMetrics(int nIndex);
#endif
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet=CharSet.Auto, BestFitMapping = false)]
public static extern bool SystemParametersInfo(int nAction, int nParam, ref NativeMethods.RECT rc, int nUpdate);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
public static extern bool SystemParametersInfo(int nAction, int nParam, ref int value, int ignore);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
public static extern bool SystemParametersInfo(int nAction, int nParam, ref bool value, int ignore);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
public static extern bool SystemParametersInfo(int nAction, int nParam, ref NativeMethods.HIGHCONTRAST_I rc, int nUpdate);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
public static extern bool SystemParametersInfo(int nAction, int nParam, [In, Out] NativeMethods.NONCLIENTMETRICS metrics, int nUpdate);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Kernel32, CharSet = CharSet.Auto, ExactSpelling = true)]
public static extern bool GetSystemPowerStatus(ref NativeMethods.SYSTEM_POWER_STATUS systemPowerStatus);
///
/// Critical - performs an elevation via SUC.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="ClientToScreen", SetLastError=true, ExactSpelling=true, CharSet=CharSet.Auto)]
private static extern int IntClientToScreen(HandleRef hWnd, [In, Out] NativeMethods.POINT pt);
///
/// Critical calls critical code - IntClientToScreen
///
[SecurityCritical]
public static void ClientToScreen(HandleRef hWnd, [In, Out] NativeMethods.POINT pt)
{
if(IntClientToScreen(hWnd, pt) == 0)
{
throw new Win32Exception();
}
}
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern IntPtr GetDesktopWindow();
///
/// Critical:Elevates to Unmanaged code permission and can be used to
/// change the foreground window.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern IntPtr GetForegroundWindow();
[DllImport(ExternDll.Ole32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern int RegisterDragDrop(HandleRef hwnd, UnsafeNativeMethods.IOleDropTarget target);
[DllImport(ExternDll.Ole32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern int RevokeDragDrop(HandleRef hwnd);
///
/// Critical:Elevates to Unmanaged code permission and can be used to
/// get information of messages in queues.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, CharSet=CharSet.Auto)]
public static extern bool PeekMessage([In, Out] ref System.Windows.Interop.MSG msg, HandleRef hwnd, int msgMin, int msgMax, int remove);
#if BASE_NATIVEMETHODS
[DllImport(ExternDll.User32, BestFitMapping = false, CharSet=CharSet.Auto)]
public static extern bool SetProp(HandleRef hWnd, string propName, HandleRef data);
#endif
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "PostMessage", CharSet = CharSet.Auto, SetLastError = true)]
private static extern bool IntPostMessage(HandleRef hwnd, int msg, IntPtr wparam, IntPtr lparam);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
internal static void PostMessage(HandleRef hwnd, int msg, IntPtr wparam, IntPtr lparam)
{
if (!IntPostMessage(hwnd, msg, wparam, lparam))
{
throw new Win32Exception();
}
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint = "PostMessage", CharSet = CharSet.Auto)]
internal static extern bool TryPostMessage(HandleRef hwnd, int msg, IntPtr wparam, IntPtr lparam);
#if BASE_NATIVEMETHODS || CORE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern void NotifyWinEvent(int winEvent, HandleRef hwnd, int objType, int objID);
#endif
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, EntryPoint = "BeginPaint", CharSet = CharSet.Auto)]
private static extern IntPtr IntBeginPaint(HandleRef hWnd, [In, Out] ref NativeMethods.PAINTSTRUCT lpPaint);
///
/// Critical as this code performs an elevation. via the call to IntBeginPaint
///
[SecurityCritical]
public static IntPtr BeginPaint(HandleRef hWnd, [In, Out, MarshalAs(UnmanagedType.LPStruct)] ref NativeMethods.PAINTSTRUCT lpPaint) {
return HandleCollector.Add(IntBeginPaint(hWnd, ref lpPaint), NativeMethods.CommonHandles.HDC);
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, EntryPoint = "EndPaint", CharSet = CharSet.Auto)]
private static extern bool IntEndPaint(HandleRef hWnd, ref NativeMethods.PAINTSTRUCT lpPaint);
///
/// Critical as this code performs an elevation via the call to IntEndPaint.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
public static bool EndPaint(HandleRef hWnd, [In, MarshalAs(UnmanagedType.LPStruct)] ref NativeMethods.PAINTSTRUCT lpPaint) {
HandleCollector.Remove(lpPaint.hdc, NativeMethods.CommonHandles.HDC);
return IntEndPaint(hWnd, ref lpPaint);
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, ExactSpelling = true, EntryPoint = "GetDC", CharSet = CharSet.Auto)]
private static extern IntPtr IntGetDC(HandleRef hWnd);
///
/// Critical as this code performs an elevation. The call to handle collector is
/// by itself not dangerous because handle collector simply
/// stores a count of the number of instances of a given
/// handle and not the handle itself.
///
[SecurityCritical]
public static IntPtr GetDC(HandleRef hWnd)
{
IntPtr hDc = IntGetDC(hWnd);
if(hDc == IntPtr.Zero)
{
throw new Win32Exception();
}
return HandleCollector.Add(hDc, NativeMethods.CommonHandles.HDC);
}
///
/// Critical as this code performs an elevation.The call to handle collector
/// is by itself not dangerous because handle collector simply
/// stores a count of the number of instances of a given handle and not the handle itself.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling = true, EntryPoint = "ReleaseDC", CharSet = CharSet.Auto)]
private static extern int IntReleaseDC(HandleRef hWnd, HandleRef hDC);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
public static int ReleaseDC(HandleRef hWnd, HandleRef hDC) {
HandleCollector.Remove((IntPtr)hDC, NativeMethods.CommonHandles.HDC);
return IntReleaseDC(hWnd, hDC);
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto)]
public static extern int GetDeviceCaps(HandleRef hDC, int nIndex);
///
/// Critical as this code performs an elevation to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern IntPtr GetActiveWindow();
///
/// Critical as this code performs an elevation to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern bool SetForegroundWindow(HandleRef hWnd);
// Begin API Additions to support common dialog controls
///
/// Critical as this code performs an elevation to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Comdlg32, SetLastError = true, ExactSpelling = true, CharSet = System.Runtime.InteropServices.CharSet.Auto)]
internal static extern int CommDlgExtendedError();
///
/// Critical as this code performs an elevation to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Comdlg32, SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool GetOpenFileName([In, Out] NativeMethods.OPENFILENAME_I ofn);
///
/// Critical as this code performs an elevation to unmanaged code
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Comdlg32, SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool GetSaveFileName([In, Out] NativeMethods.OPENFILENAME_I ofn);
// End Common Dialog API Additions
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[return:MarshalAs(UnmanagedType.Bool)]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto, SetLastError=true)]
public static extern bool SetLayeredWindowAttributes(HandleRef hwnd, int crKey, byte bAlpha, int dwFlags);
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[return:MarshalAs(UnmanagedType.Bool)]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto, SetLastError=true)]
public static extern bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, IntPtr pptDst, IntPtr pSizeDst, IntPtr hdcSrc, IntPtr pptSrc, int crKey, ref NativeMethods.BLENDFUNCTION pBlend, int dwFlags);
[DllImport(ExternDll.User32, EntryPoint = "SetActiveWindow", ExactSpelling = true, CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr IntSetActiveWindow(HandleRef hWnd);
///
/// Critical: LinkDemand on Win32Exception constructor
/// TreatAsSafe: Throwing an exception isn't unsafe
/// Note: If SupressUnmanagedCodeSecurity attribute is ever added to IntSetActiveWindow, we need to be Critical
///
[SecurityCritical, SecurityTreatAsSafe]
internal static IntPtr SetActiveWindow(HandleRef hWnd)
{
IntPtr retVal = IntSetActiveWindow(hWnd);
if (retVal == IntPtr.Zero)
{
throw new Win32Exception();
}
return retVal;
}
//
#if PBTCOMPILER
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern IntPtr SetCursor(HandleRef hcursor);
#endif
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, EntryPoint="DestroyCursor", CharSet=CharSet.Auto)]
private static extern bool IntDestroyCursor(IntPtr hCurs);
///
/// Critical calls IntDestroyCursor
///
[SecurityCritical]
public static bool DestroyCursor(IntPtr hCurs) {
return IntDestroyCursor(hCurs);
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="DestroyIcon", CharSet=System.Runtime.InteropServices.CharSet.Auto, SetLastError=true)]
private static extern bool IntDestroyIcon(IntPtr hIcon);
///
/// Critical: calls a critical method (IntDestroyIcon)
///
[SecurityCritical]
public static bool DestroyIcon(IntPtr hIcon)
{
bool result = IntDestroyIcon(hIcon);
int error = Marshal.GetLastWin32Error();
if(!result)
{
// To be consistent with out other PInvoke wrappers
// we should "throw" here. But we don't want to
// introduce new "throws" w/o time to follow up on any
// new problems that causes.
Debug.WriteLine("DestroyIcon failed. Error = " + error);
//throw new Win32Exception();
}
return result;
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, EntryPoint="DeleteObject", CharSet=System.Runtime.InteropServices.CharSet.Auto, SetLastError=true)]
private static extern bool IntDeleteObject(IntPtr hObject);
///
/// Critical: calls a critical method (IntDeleteObject)
///
[SecurityCritical]
public static bool DeleteObject(IntPtr hObject)
{
bool result = IntDeleteObject(hObject);
int error = Marshal.GetLastWin32Error();
if(!result)
{
// To be consistent with out other PInvoke wrappers
// we should "throw" here. But we don't want to
// introduce new "throws" w/o time to follow up on any
// new problems that causes.
Debug.WriteLine("DeleteObject failed. Error = " + error);
//throw new Win32Exception();
}
return result;
}
///
/// Critical as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = "CreateDIBSection")]
private static extern NativeMethods.BitmapHandle PrivateCreateDIBSection(HandleRef hdc, ref NativeMethods.BITMAPINFO bitmapInfo, int iUsage, ref IntPtr ppvBits, IntPtr hSection, int dwOffset);
///
/// Critical - The method invokes PrivateCreateDIBSection.
///
[SecurityCritical]
internal static NativeMethods.BitmapHandle CreateDIBSection(HandleRef hdc, ref NativeMethods.BITMAPINFO bitmapInfo, int iUsage, ref IntPtr ppvBits, IntPtr hSection, int dwOffset)
{
NativeMethods.BitmapHandle hBitmap = PrivateCreateDIBSection(hdc, ref bitmapInfo, iUsage, ref ppvBits, hSection, dwOffset);
int error = Marshal.GetLastWin32Error();
if ( hBitmap.IsInvalid )
{
Debug.WriteLine("CreateDIBSection failed. Error = " + error);
}
return hBitmap;
}
///
/// Critical as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = "CreateBitmap")]
private static extern NativeMethods.BitmapHandle PrivateCreateBitmap(int width, int height, int planes, int bitsPerPixel, byte[] lpvBits);
///
/// Critical - The method invokes PrivateCreateBitmap.
///
[SecurityCritical]
internal static NativeMethods.BitmapHandle CreateBitmap(int width, int height, int planes, int bitsPerPixel, byte[] lpvBits)
{
NativeMethods.BitmapHandle hBitmap = PrivateCreateBitmap(width, height, planes, bitsPerPixel, lpvBits);
int error = Marshal.GetLastWin32Error();
if ( hBitmap.IsInvalid )
{
Debug.WriteLine("CreateBitmap failed. Error = " + error);
}
return hBitmap;
}
///
/// Critical as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = "DestroyIcon")]
private static extern bool PrivateDestroyIcon(HandleRef handle);
///
/// Critical - The method invokes PrivateDestroyIcon.
///
[SecurityCritical]
internal static bool DestroyIcon(HandleRef handle)
{
HandleCollector.Remove((IntPtr)handle, NativeMethods.CommonHandles.Icon);
bool result = PrivateDestroyIcon(handle);
int error = Marshal.GetLastWin32Error();
if ( !result )
{
Debug.WriteLine("DestroyIcon failed. Error = " + error);
}
return result;
}
///
/// Critical as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, ExactSpelling = true, CharSet = CharSet.Auto, EntryPoint = "CreateIconIndirect")]
private static extern NativeMethods.IconHandle PrivateCreateIconIndirect([In, MarshalAs(UnmanagedType.LPStruct)]NativeMethods.ICONINFO iconInfo);
///
/// Critical - The method invokes PrivateCreateIconIndirect.
///
[SecurityCritical]
internal static NativeMethods.IconHandle CreateIconIndirect([In, MarshalAs(UnmanagedType.LPStruct)]NativeMethods.ICONINFO iconInfo)
{
NativeMethods.IconHandle hIcon = PrivateCreateIconIndirect(iconInfo);
int error = Marshal.GetLastWin32Error();
if ( hIcon.IsInvalid )
{
Debug.WriteLine("CreateIconIndirect failed. Error = " + error);
}
return hIcon;
}
///
/// Critical: This code elevates to unmanaged code
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, ExactSpelling=true, CharSet=CharSet.Auto)]
public static extern bool IsWindow(HandleRef hWnd);
#if BASE_NATIVEMETHODS
[DllImport(ExternDll.Gdi32, SetLastError=true, ExactSpelling=true, EntryPoint="DeleteDC", CharSet=CharSet.Auto)]
private static extern bool IntDeleteDC(HandleRef hDC);
///
/// Critical: LinkDemand on Win32Exception constructor
/// TreatAsSafe: Throwing an exception isn't unsafe
/// Note: If SupressUnmanagedCodeSecurity attribute is ever added to IntDeleteDC, we need to be Critical
///
[SecurityCritical, SecurityTreatAsSafe]
public static void DeleteDC(HandleRef hDC)
{
HandleCollector.Remove((IntPtr)hDC, NativeMethods.CommonHandles.HDC);
if(!IntDeleteDC(hDC))
{
throw new Win32Exception();
}
}
///
/// Critical: This code elevates to unmanaged code
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.Gdi32, SetLastError=true, ExactSpelling=true, EntryPoint="DeleteDC", CharSet=CharSet.Auto)]
private static extern bool IntCriticalDeleteDC(HandleRef hDC);
///
/// Critical: This code elevates to unmanaged code
///
[SecurityCritical]
public static void CriticalDeleteDC(HandleRef hDC)
{
HandleCollector.Remove((IntPtr)hDC, NativeMethods.CommonHandles.HDC);
if(!IntCriticalDeleteDC(hDC))
{
throw new Win32Exception();
}
}
#endif
#if BASE_NATIVEMETHODS
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError=true, EntryPoint="GetMessageW", ExactSpelling=true, CharSet=CharSet.Unicode)]
private static extern int IntGetMessageW([In, Out] ref System.Windows.Interop.MSG msg, HandleRef hWnd, int uMsgFilterMin, int uMsgFilterMax);
///
/// Critical - calls IntGetMessageW (the real PInvoke method)
///
[SecurityCritical]
public static bool GetMessageW([In, Out] ref System.Windows.Interop.MSG msg, HandleRef hWnd, int uMsgFilterMin, int uMsgFilterMax)
{
bool boolResult = false;
int result = IntGetMessageW(ref msg, hWnd, uMsgFilterMin, uMsgFilterMax);
if(result == -1)
{
throw new Win32Exception();
}
else if(result == 0)
{
boolResult = false;
}
else
{
boolResult = true;
}
return boolResult;
}
#endif
#if BASE_NATIVEMETHODS
///
/// Critical: This code elevates via a SUC to call into unmanaged Code and can get the HWND of windows at any arbitrary point on the screen
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="WindowFromPoint", ExactSpelling=true, CharSet=CharSet.Auto)]
private static extern IntPtr IntWindowFromPoint(POINTSTRUCT pt);
///
/// Critical: This calls WindowFromPoint(POINTSTRUCT) which is marked SecurityCritical
///
[SecurityCritical]
public static IntPtr WindowFromPoint(int x, int y) {
POINTSTRUCT ps = new POINTSTRUCT(x, y);
return IntWindowFromPoint(ps);
}
#endif
///
/// Critical: This code elevates to call into unmanaged Code
///
[SecurityCritical,SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, EntryPoint="CreateWindowEx", CharSet=CharSet.Auto, BestFitMapping = false, SetLastError=true)]
public static extern IntPtr IntCreateWindowEx(int dwExStyle, string lpszClassName,
string lpszWindowName, int style, int x, int y, int width, int height,
HandleRef hWndParent, HandleRef hMenu, HandleRef hInst, [MarshalAs(UnmanagedType.AsAny)] object pvParam);
///
/// Critical: This code elevates to call into unmanaged Code by calling IntCreateWindowEx
///
[SecurityCritical]
public static IntPtr CreateWindowEx(int dwExStyle, string lpszClassName,
string lpszWindowName, int style, int x, int y, int width, int height,
HandleRef hWndParent, HandleRef hMenu, HandleRef hInst, [MarshalAs(UnmanagedType.AsAny)]object pvParam) {
IntPtr retVal = IntCreateWindowEx(dwExStyle, lpszClassName,
lpszWindowName, style, x, y, width, height, hWndParent, hMenu,
hInst, pvParam);
if(retVal == IntPtr.Zero)
{
throw new Win32Exception();
}
return retVal;
}
///
/// Critical as this code performs an elevation.
///
[SecurityCritical]
[SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError = true, EntryPoint="DestroyWindow", CharSet=CharSet.Auto)]
public static extern bool IntDestroyWindow(HandleRef hWnd);
///
/// Critical - calls Security Critical method
///
[SecurityCritical]
public static void DestroyWindow(HandleRef hWnd)
{
if(!IntDestroyWindow(hWnd))
{
throw new Win32Exception();
}
}
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32)]
internal static extern IntPtr SetWinEventHook(int eventMin, int eventMax, IntPtr hmodWinEventProc, NativeMethods.WinEventProcDef WinEventReentrancyFilter, uint idProcess, uint idThread, int dwFlags);
///
/// Critical - elevates via a SUC.
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[DllImport(ExternDll.User32)]
internal static extern bool UnhookWinEvent(IntPtr winEventHook);
// for GetUserNameEx
public enum EXTENDED_NAME_FORMAT {
NameUnknown = 0,
NameFullyQualifiedDN = 1,
NameSamCompatible = 2,
NameDisplay = 3,
NameUniqueId = 6,
NameCanonical = 7,
NameUserPrincipal = 8,
NameCanonicalEx = 9,
NameServicePrincipal = 10
}
[ComImport(), Guid("00000122-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleDropTarget {
[PreserveSig]
int OleDragEnter(
[In, MarshalAs(UnmanagedType.Interface)]
object pDataObj,
[In, MarshalAs(UnmanagedType.U4)]
int grfKeyState,
[In, MarshalAs(UnmanagedType.U8)]
long pt,
[In, Out]
ref int pdwEffect);
[PreserveSig]
int OleDragOver(
[In, MarshalAs(UnmanagedType.U4)]
int grfKeyState,
[In, MarshalAs(UnmanagedType.U8)]
long pt,
[In, Out]
ref int pdwEffect);
[PreserveSig]
int OleDragLeave();
[PreserveSig]
int OleDrop(
[In, MarshalAs(UnmanagedType.Interface)]
object pDataObj,
[In, MarshalAs(UnmanagedType.U4)]
int grfKeyState,
[In, MarshalAs(UnmanagedType.U8)]
long pt,
[In, Out]
ref int pdwEffect);
}
[ComImport(), Guid("00000121-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleDropSource {
[PreserveSig]
int OleQueryContinueDrag(
int fEscapePressed,
[In, MarshalAs(UnmanagedType.U4)]
int grfKeyState);
[PreserveSig]
int OleGiveFeedback(
[In, MarshalAs(UnmanagedType.U4)]
int dwEffect);
}
[
ComImport(),
Guid("B196B289-BAB4-101A-B69C-00AA00341D07"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)
]
public interface IOleControlSite {
[PreserveSig]
int OnControlInfoChanged();
[PreserveSig]
int LockInPlaceActive(int fLock);
[PreserveSig]
int GetExtendedControl(
[Out, MarshalAs(UnmanagedType.IDispatch)]
out object ppDisp);
[PreserveSig]
int TransformCoords(
[In, Out]
NativeMethods.POINT pPtlHimetric,
[In, Out]
NativeMethods.POINTF pPtfContainer,
[In, MarshalAs(UnmanagedType.U4)]
int dwFlags);
[PreserveSig]
int TranslateAccelerator(
[In]
ref System.Windows.Interop.MSG pMsg,
[In, MarshalAs(UnmanagedType.U4)]
int grfModifiers);
[PreserveSig]
int OnFocus(int fGotFocus);
[PreserveSig]
int ShowPropertyFrame();
}
[ComImport(), Guid("00000118-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleClientSite {
[PreserveSig]
int SaveObject();
[PreserveSig]
int GetMoniker(
[In, MarshalAs(UnmanagedType.U4)]
int dwAssign,
[In, MarshalAs(UnmanagedType.U4)]
int dwWhichMoniker,
[Out, MarshalAs(UnmanagedType.Interface)]
out object moniker);
[PreserveSig]
int GetContainer(out IOleContainer container);
[PreserveSig]
int ShowObject();
[PreserveSig]
int OnShowWindow(int fShow);
[PreserveSig]
int RequestNewObjectLayout();
}
[ComImport(), Guid("00000119-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceSite {
IntPtr GetWindow();
[PreserveSig]
int ContextSensitiveHelp(int fEnterMode);
[PreserveSig]
int CanInPlaceActivate();
[PreserveSig]
int OnInPlaceActivate();
[PreserveSig]
int OnUIActivate();
[PreserveSig]
int GetWindowContext(
[Out, MarshalAs(UnmanagedType.Interface)]
out UnsafeNativeMethods.IOleInPlaceFrame ppFrame,
[Out, MarshalAs(UnmanagedType.Interface)]
out UnsafeNativeMethods.IOleInPlaceUIWindow ppDoc,
[Out]
NativeMethods.COMRECT lprcPosRect,
[Out]
NativeMethods.COMRECT lprcClipRect,
[In, Out]
NativeMethods.OLEINPLACEFRAMEINFO lpFrameInfo);
[PreserveSig]
int Scroll(
NativeMethods.SIZE scrollExtant);
[PreserveSig]
int OnUIDeactivate(
int fUndoable);
[PreserveSig]
int OnInPlaceDeactivate();
[PreserveSig]
int DiscardUndoState();
[PreserveSig]
int DeactivateAndUndo();
[PreserveSig]
int OnPosRectChange(
[In]
NativeMethods.COMRECT lprcPosRect);
}
[ComImport(), Guid("9BFBBC02-EFF1-101A-84ED-00AA00341D07"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IPropertyNotifySink {
void OnChanged(int dispID);
[PreserveSig]
int OnRequestEdit(int dispID);
}
[ComImport(), Guid("00000100-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumUnknown {
[PreserveSig]
int Next(
[In, MarshalAs(UnmanagedType.U4)]
int celt,
[Out]
IntPtr rgelt,
IntPtr pceltFetched);
[PreserveSig]
int Skip(
[In, MarshalAs(UnmanagedType.U4)]
int celt);
void Reset();
void Clone(
[Out]
out IEnumUnknown ppenum);
}
[ComImport(), Guid("0000011B-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleContainer {
[PreserveSig]
int ParseDisplayName(
[In, MarshalAs(UnmanagedType.Interface)]
object pbc,
[In, MarshalAs(UnmanagedType.BStr)]
string pszDisplayName,
[Out, MarshalAs(UnmanagedType.LPArray)]
int[] pchEaten,
[Out, MarshalAs(UnmanagedType.LPArray)]
object[] ppmkOut);
[PreserveSig]
int EnumObjects(
[In, MarshalAs(UnmanagedType.U4)]
int grfFlags,
[Out]
out IEnumUnknown ppenum);
[PreserveSig]
int LockContainer(
bool fLock);
}
[ComImport(), Guid("00000116-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceFrame {
IntPtr GetWindow();
[PreserveSig]
int ContextSensitiveHelp(int fEnterMode);
[PreserveSig]
int GetBorder(
[Out]
NativeMethods.COMRECT lprectBorder);
[PreserveSig]
int RequestBorderSpace(
[In]
NativeMethods.COMRECT pborderwidths);
[PreserveSig]
int SetBorderSpace(
[In]
NativeMethods.COMRECT pborderwidths);
[PreserveSig]
int SetActiveObject(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject,
[In, MarshalAs(UnmanagedType.LPWStr)]
string pszObjName);
[PreserveSig]
int InsertMenus(
[In]
IntPtr hmenuShared,
[In, Out]
NativeMethods.tagOleMenuGroupWidths lpMenuWidths);
[PreserveSig]
int SetMenu(
[In]
IntPtr hmenuShared,
[In]
IntPtr holemenu,
[In]
IntPtr hwndActiveObject);
[PreserveSig]
int RemoveMenus(
[In]
IntPtr hmenuShared);
[PreserveSig]
int SetStatusText(
[In, MarshalAs(UnmanagedType.LPWStr)]
string pszStatusText);
[PreserveSig]
int EnableModeless(
bool fEnable);
[PreserveSig]
int TranslateAccelerator(
[In]
ref System.Windows.Interop.MSG lpmsg,
[In, MarshalAs(UnmanagedType.U2)]
short wID);
}
//IMPORTANT: Do not try to optimize perf here by changing the enum size to byte
//instead of int since this is used in COM Interop for browser hosting scenarios
// Enum for OLECMDIDs used by IOleCommandTarget in browser hosted scenarios
// Imported from the published header - docobj.h, If you need to support more
// than these OLECMDS, add it from that header file
public enum OLECMDID {
OLECMDID_SAVE = 3,
OLECMDID_SAVEAS = 4,
OLECMDID_PRINT = 6,
OLECMDID_PRINTPREVIEW = 7,
OLECMDID_PAGESETUP = 8,
OLECMDID_PROPERTIES = 10,
OLECMDID_CUT = 11,
OLECMDID_COPY = 12,
OLECMDID_PASTE = 13,
OLECMDID_SELECTALL = 17,
OLECMDID_REFRESH = 22,
OLECMDID_STOP = 23,
}
public enum OLECMDEXECOPT {
OLECMDEXECOPT_DODEFAULT = 0,
OLECMDEXECOPT_PROMPTUSER = 1,
OLECMDEXECOPT_DONTPROMPTUSER = 2,
OLECMDEXECOPT_SHOWHELP = 3
}
// OLECMDID Flags used by IOleCommandTarget to specify status of commands in browser hosted scenarios
// Imported from the published header - docobj.h
public enum OLECMDF {
///
/// The command is supported by this object
///
OLECMDF_SUPPORTED = 0x1,
///
/// The command is available and enabled
///
OLECMDF_ENABLED = 0x2,
///
/// The command is an on-off toggle and is currently on
///
OLECMDF_LATCHED = 0x4,
///
/// Reserved for future use
///
OLECMDF_NINCHED = 0x8,
///
/// Command is invisible
///
OLECMDF_INVISIBLE = 0x10,
///
/// Command should not be displayed in the context menu
///
OLECMDF_DEFHIDEONCTXTMENU = 0x20
}
[ComImport(), Guid("00000115-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceUIWindow {
IntPtr GetWindow();
[PreserveSig]
int ContextSensitiveHelp(
int fEnterMode);
[PreserveSig]
int GetBorder(
[Out]
NativeMethods.RECT lprectBorder);
[PreserveSig]
int RequestBorderSpace(
[In]
NativeMethods.RECT pborderwidths);
[PreserveSig]
int SetBorderSpace(
[In]
NativeMethods.RECT pborderwidths);
void SetActiveObject(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleInPlaceActiveObject pActiveObject,
[In, MarshalAs(UnmanagedType.LPWStr)]
string pszObjName);
}
[ComImport(),
Guid("00000117-0000-0000-C000-000000000046"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceActiveObject {
[PreserveSig]
int GetWindow( out IntPtr hwnd );
void ContextSensitiveHelp(
int fEnterMode);
///
/// Critical: This code escalates to unmanaged code permission
///
[SuppressUnmanagedCodeSecurity, SecurityCritical]
[PreserveSig]
int TranslateAccelerator(
[In]
ref System.Windows.Interop.MSG lpmsg);
void OnFrameWindowActivate(
int fActivate);
void OnDocWindowActivate(
int fActivate);
void ResizeBorder(
[In]
NativeMethods.RECT prcBorder,
[In]
UnsafeNativeMethods.IOleInPlaceUIWindow pUIWindow,
bool fFrameWindow);
void EnableModeless(
int fEnable);
}
[ComImport(), Guid("00000114-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleWindow {
[PreserveSig]
int GetWindow( [Out]out IntPtr hwnd );
void ContextSensitiveHelp(
int fEnterMode);
}
///
/// Critical - elevates via a SUC.
///
[ SecurityCritical( SecurityCriticalScope.Everything ) , SuppressUnmanagedCodeSecurity ]
[ComImport(),
Guid("00000113-0000-0000-C000-000000000046"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceObject {
[PreserveSig]
int GetWindow( [Out]out IntPtr hwnd );
void ContextSensitiveHelp(
int fEnterMode);
void InPlaceDeactivate();
[PreserveSig]
int UIDeactivate();
void SetObjectRects(
[In]
NativeMethods.COMRECT lprcPosRect,
[In]
NativeMethods.COMRECT lprcClipRect);
void ReactivateAndUndo();
}
///
/// Critical - elevates via a SUC.
///
[SecurityCritical( SecurityCriticalScope.Everything ) , SuppressUnmanagedCodeSecurity ]
[ComImport(),
Guid("00000112-0000-0000-C000-000000000046"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleObject {
[PreserveSig]
int SetClientSite(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleClientSite pClientSite);
UnsafeNativeMethods.IOleClientSite GetClientSite();
[PreserveSig]
int SetHostNames(
[In, MarshalAs(UnmanagedType.LPWStr)]
string szContainerApp,
[In, MarshalAs(UnmanagedType.LPWStr)]
string szContainerObj);
[PreserveSig]
int Close(
int dwSaveOption);
[PreserveSig]
int SetMoniker(
[In, MarshalAs(UnmanagedType.U4)]
int dwWhichMoniker,
[In, MarshalAs(UnmanagedType.Interface)]
object pmk);
[PreserveSig]
int GetMoniker(
[In, MarshalAs(UnmanagedType.U4)]
int dwAssign,
[In, MarshalAs(UnmanagedType.U4)]
int dwWhichMoniker,
[Out, MarshalAs(UnmanagedType.Interface)]
out object moniker);
[PreserveSig]
int InitFromData(
[In, MarshalAs(UnmanagedType.Interface)]
IComDataObject pDataObject,
int fCreation,
[In, MarshalAs(UnmanagedType.U4)]
int dwReserved);
[PreserveSig]
int GetClipboardData(
[In, MarshalAs(UnmanagedType.U4)]
int dwReserved,
out IComDataObject data);
[PreserveSig]
int DoVerb(
int iVerb,
[In]
IntPtr lpmsg,
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleClientSite pActiveSite,
int lindex,
IntPtr hwndParent,
[In]
NativeMethods.COMRECT lprcPosRect);
[PreserveSig]
int EnumVerbs(out UnsafeNativeMethods.IEnumOLEVERB e);
[PreserveSig]
int OleUpdate();
[PreserveSig]
int IsUpToDate();
[PreserveSig]
int GetUserClassID(
[In, Out]
ref Guid pClsid);
[PreserveSig]
int GetUserType(
[In, MarshalAs(UnmanagedType.U4)]
int dwFormOfType,
[Out, MarshalAs(UnmanagedType.LPWStr)]
out string userType);
[PreserveSig]
int SetExtent(
[In, MarshalAs(UnmanagedType.U4)]
int dwDrawAspect,
[In]
NativeMethods.SIZE pSizel);
[PreserveSig]
int GetExtent(
[In, MarshalAs(UnmanagedType.U4)]
int dwDrawAspect,
[Out]
NativeMethods.SIZE pSizel);
[PreserveSig]
int Advise(
IAdviseSink pAdvSink,
out int cookie);
[PreserveSig]
int Unadvise(
[In, MarshalAs(UnmanagedType.U4)]
int dwConnection);
[PreserveSig]
int EnumAdvise(out IEnumSTATDATA e);
[PreserveSig]
int GetMiscStatus(
[In, MarshalAs(UnmanagedType.U4)]
int dwAspect,
out int misc);
[PreserveSig]
int SetColorScheme(
[In]
NativeMethods.tagLOGPALETTE pLogpal);
}
[ComImport(), Guid("1C2056CC-5EF4-101B-8BC8-00AA003E3B29"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleInPlaceObjectWindowless {
[PreserveSig]
int SetClientSite(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleClientSite pClientSite);
[PreserveSig]
int GetClientSite(out UnsafeNativeMethods.IOleClientSite site);
[PreserveSig]
int SetHostNames(
[In, MarshalAs(UnmanagedType.LPWStr)]
string szContainerApp,
[In, MarshalAs(UnmanagedType.LPWStr)]
string szContainerObj);
[PreserveSig]
int Close(
int dwSaveOption);
[PreserveSig]
int SetMoniker(
[In, MarshalAs(UnmanagedType.U4)]
int dwWhichMoniker,
[In, MarshalAs(UnmanagedType.Interface)]
object pmk);
[PreserveSig]
int GetMoniker(
[In, MarshalAs(UnmanagedType.U4)]
int dwAssign,
[In, MarshalAs(UnmanagedType.U4)]
int dwWhichMoniker,
[Out, MarshalAs(UnmanagedType.Interface)]
out object moniker);
[PreserveSig]
int InitFromData(
[In, MarshalAs(UnmanagedType.Interface)]
IComDataObject pDataObject,
int fCreation,
[In, MarshalAs(UnmanagedType.U4)]
int dwReserved);
[PreserveSig]
int GetClipboardData(
[In, MarshalAs(UnmanagedType.U4)]
int dwReserved,
out IComDataObject data);
[PreserveSig]
int DoVerb(
int iVerb,
[In]
IntPtr lpmsg,
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleClientSite pActiveSite,
int lindex,
IntPtr hwndParent,
[In]
NativeMethods.RECT lprcPosRect);
[PreserveSig]
int EnumVerbs(out UnsafeNativeMethods.IEnumOLEVERB e);
[PreserveSig]
int OleUpdate();
[PreserveSig]
int IsUpToDate();
[PreserveSig]
int GetUserClassID(
[In, Out]
ref Guid pClsid);
[PreserveSig]
int GetUserType(
[In, MarshalAs(UnmanagedType.U4)]
int dwFormOfType,
[Out, MarshalAs(UnmanagedType.LPWStr)]
out string userType);
[PreserveSig]
int SetExtent(
[In, MarshalAs(UnmanagedType.U4)]
int dwDrawAspect,
[In]
NativeMethods.SIZE pSizel);
[PreserveSig]
int GetExtent(
[In, MarshalAs(UnmanagedType.U4)]
int dwDrawAspect,
[Out]
NativeMethods.SIZE pSizel);
[PreserveSig]
int Advise(
[In, MarshalAs(UnmanagedType.Interface)]
IAdviseSink pAdvSink,
out int cookie);
[PreserveSig]
int Unadvise(
[In, MarshalAs(UnmanagedType.U4)]
int dwConnection);
[PreserveSig]
int EnumAdvise(out IEnumSTATDATA e);
[PreserveSig]
int GetMiscStatus(
[In, MarshalAs(UnmanagedType.U4)]
int dwAspect,
out int misc);
[PreserveSig]
int SetColorScheme(
[In]
NativeMethods.tagLOGPALETTE pLogpal);
[PreserveSig]
int OnWindowMessage(
[In, MarshalAs(UnmanagedType.U4)] int msg,
[In, MarshalAs(UnmanagedType.U4)] int wParam,
[In, MarshalAs(UnmanagedType.U4)] int lParam,
[Out, MarshalAs(UnmanagedType.U4)] int plResult);
[PreserveSig]
int GetDropTarget(
[Out, MarshalAs(UnmanagedType.Interface)] object ppDropTarget);
};
///
/// Critical - elevates via a SUC.
///
[SecurityCritical( SecurityCriticalScope.Everything ) , SuppressUnmanagedCodeSecurity ]
[ComImport(),
Guid("B196B288-BAB4-101A-B69C-00AA00341D07"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IOleControl {
[PreserveSig]
int GetControlInfo(
[Out]
NativeMethods.tagCONTROLINFO pCI);
[PreserveSig]
int OnMnemonic(
[In]
ref System.Windows.Interop.MSG pMsg);
[PreserveSig]
int OnAmbientPropertyChange(
int dispID);
[PreserveSig]
int FreezeEvents(
int bFreeze);
}
///
/// Critical - elevates via a SUC.
///
[SecurityCritical( SecurityCriticalScope.Everything ) , SuppressUnmanagedCodeSecurity ]
[ComImport(),
Guid("B196B286-BAB4-101A-B69C-00AA00341D07"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IConnectionPoint {
[PreserveSig]
int GetConnectionInterface(out Guid iid);
[PreserveSig]
int GetConnectionPointContainer(
[MarshalAs(UnmanagedType.Interface)]
ref IConnectionPointContainer pContainer);
[PreserveSig]
int Advise(
[In, MarshalAs(UnmanagedType.Interface)]
object pUnkSink,
ref int cookie);
[PreserveSig]
int Unadvise(
int cookie);
[PreserveSig]
int EnumConnections(out object pEnum);
}
[ComImport(), Guid("00020404-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumVariant {
///
/// Critical: This code elevates to call unmanaged code
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[PreserveSig]
int Next(
[In, MarshalAs(UnmanagedType.U4)]
int celt,
[In, Out]
IntPtr rgvar,
[Out, MarshalAs(UnmanagedType.LPArray)]
int[] pceltFetched);
void Skip(
[In, MarshalAs(UnmanagedType.U4)]
int celt);
///
/// Critical: This code elevates to call unmanaged code
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
void Reset();
void Clone(
[Out, MarshalAs(UnmanagedType.LPArray)]
UnsafeNativeMethods.IEnumVariant[] ppenum);
}
[ComImport(), Guid("00000104-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumOLEVERB {
[PreserveSig]
int Next(
[MarshalAs(UnmanagedType.U4)]
int celt,
[Out]
NativeMethods.tagOLEVERB rgelt,
[Out, MarshalAs(UnmanagedType.LPArray)]
int[] pceltFetched);
[PreserveSig]
int Skip(
[In, MarshalAs(UnmanagedType.U4)]
int celt);
void Reset();
void Clone(
out IEnumOLEVERB ppenum);
}
[ComImport(), Guid("0000000C-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IStream {
int Read(
IntPtr buf,
int len);
int Write(
IntPtr buf,
int len);
[return: MarshalAs(UnmanagedType.I8)]
long Seek(
[In, MarshalAs(UnmanagedType.I8)]
long dlibMove,
int dwOrigin);
void SetSize(
[In, MarshalAs(UnmanagedType.I8)]
long libNewSize);
[return: MarshalAs(UnmanagedType.I8)]
long CopyTo(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IStream pstm,
[In, MarshalAs(UnmanagedType.I8)]
long cb,
[Out, MarshalAs(UnmanagedType.LPArray)]
long[] pcbRead);
void Commit(
int grfCommitFlags);
void Revert();
void LockRegion(
[In, MarshalAs(UnmanagedType.I8)]
long libOffset,
[In, MarshalAs(UnmanagedType.I8)]
long cb,
int dwLockType);
void UnlockRegion(
[In, MarshalAs(UnmanagedType.I8)]
long libOffset,
[In, MarshalAs(UnmanagedType.I8)]
long cb,
int dwLockType);
void Stat(
[Out]
NativeMethods.STATSTG pStatstg,
int grfStatFlag);
[return: MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IStream Clone();
}
///
/// Critical - elevates via a SUC.
///
[SecurityCritical( SecurityCriticalScope.Everything ) , SuppressUnmanagedCodeSecurity ]
[ComImport(),
Guid("B196B284-BAB4-101A-B69C-00AA00341D07"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IConnectionPointContainer
{
[return: MarshalAs(UnmanagedType.Interface)]
object EnumConnectionPoints();
[PreserveSig]
int FindConnectionPoint([In] ref Guid guid, [Out, MarshalAs(UnmanagedType.Interface)]out IConnectionPoint ppCP);
}
[ComImport(), Guid("B196B285-BAB4-101A-B69C-00AA00341D07"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IEnumConnectionPoints {
[PreserveSig]
int Next(int cConnections, out IConnectionPoint pCp, out int pcFetched);
[PreserveSig]
int Skip(int cSkip);
void Reset();
IEnumConnectionPoints Clone();
}
[ComImport(), Guid("00020400-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
public interface IDispatch {
int GetTypeInfoCount();
[return: MarshalAs(UnmanagedType.Interface)]
ITypeInfo GetTypeInfo(
[In, MarshalAs(UnmanagedType.U4)]
int iTInfo,
[In, MarshalAs(UnmanagedType.U4)]
int lcid);
[PreserveSig]
int GetIDsOfNames(
[In]
ref Guid riid,
[In, MarshalAs(UnmanagedType.LPArray)]
string[] rgszNames,
[In, MarshalAs(UnmanagedType.U4)]
int cNames,
[In, MarshalAs(UnmanagedType.U4)]
int lcid,
[Out, MarshalAs(UnmanagedType.LPArray)]
int[] rgDispId);
[PreserveSig]
int Invoke(
int dispIdMember,
[In]
ref Guid riid,
[In, MarshalAs(UnmanagedType.U4)]
int lcid,
[In, MarshalAs(UnmanagedType.U4)]
int dwFlags,
[Out, In]
NativeMethods.tagDISPPARAMS pDispParams,
[Out, MarshalAs(UnmanagedType.LPArray)]
object[] pVarResult,
[Out, In]
NativeMethods.tagEXCEPINFO pExcepInfo,
[Out, MarshalAs(UnmanagedType.LPArray)]
IntPtr [] pArgErr);
}
#region WebBrowser Related Definitions
[ComImport(), Guid("D30C1661-CDAF-11d0-8A3E-00C04FC9E26E"),
TypeLibType(TypeLibTypeFlags.FHidden | TypeLibTypeFlags.FDual | TypeLibTypeFlags.FOleAutomation)]
public interface IWebBrowser2
{
//
// IWebBrowser members
[DispId(100)]
void GoBack();
[DispId(101)]
void GoForward();
[DispId(102)]
void GoHome();
[DispId(103)]
void GoSearch();
[DispId(104)]
void Navigate([In] string Url, [In] ref object flags,
[In] ref object targetFrameName, [In] ref object postData,
[In] ref object headers);
[DispId(-550)]
void Refresh();
[DispId(105)]
void Refresh2([In] ref object level);
[DispId(106)]
void Stop();
[DispId(200)]
object Application { [return: MarshalAs(UnmanagedType.IDispatch)]get;}
[DispId(201)]
object Parent { [return: MarshalAs(UnmanagedType.IDispatch)]get;}
[DispId(202)]
object Container { [return: MarshalAs(UnmanagedType.IDispatch)]get;}
[DispId(203)]
object Document { [return: MarshalAs(UnmanagedType.IDispatch)]get;}
[DispId(204)]
bool TopLevelContainer { get;}
[DispId(205)]
string Type { get;}
[DispId(206)]
int Left { get; set;}
[DispId(207)]
int Top { get; set;}
[DispId(208)]
int Width { get; set;}
[DispId(209)]
int Height { get; set;}
[DispId(210)]
string LocationName { get;}
[DispId(211)]
string LocationURL { get;}
[DispId(212)]
bool Busy { get;}
//
// IWebBrowserApp members
[DispId(300)]
void Quit();
[DispId(301)]
void ClientToWindow([Out]out int pcx, [Out]out int pcy);
[DispId(302)]
void PutProperty([In] string property, [In] object vtValue);
[DispId(303)]
object GetProperty([In] string property);
[DispId(0)]
string Name { get;}
[DispId(-515)]
int HWND { get;}
[DispId(400)]
string FullName { get;}
[DispId(401)]
string Path { get;}
[DispId(402)]
bool Visible { get; set;}
[DispId(403)]
bool StatusBar { get; set;}
[DispId(404)]
string StatusText { get; set;}
[DispId(405)]
int ToolBar { get; set;}
[DispId(406)]
bool MenuBar { get; set;}
[DispId(407)]
bool FullScreen { get; set;}
//
// IWebBrowser2 members
///
/// Critical elevates via a SUC.
///
[DispId(500)]
[SuppressUnmanagedCodeSecurity, SecurityCritical ]
void Navigate2([In] ref object URL, [In] ref object flags,
[In] ref object targetFrameName, [In] ref object postData,
[In] ref object headers);
[DispId(501)]
UnsafeNativeMethods.OLECMDF QueryStatusWB([In] UnsafeNativeMethods.OLECMDID cmdID);
[DispId(502)]
void ExecWB([In] UnsafeNativeMethods.OLECMDID cmdID,
[In] UnsafeNativeMethods.OLECMDEXECOPT cmdexecopt,
ref object pvaIn,
IntPtr pvaOut);
[DispId(503)]
void ShowBrowserBar([In] ref object pvaClsid, [In] ref object pvarShow,
[In] ref object pvarSize);
[DispId(-525)]
NativeMethods.WebBrowserReadyState ReadyState { get;}
[DispId(550)]
bool Offline { get; set;}
[DispId(551)]
bool Silent { get; set;}
[DispId(552)]
bool RegisterAsBrowser { get; set;}
[DispId(553)]
bool RegisterAsDropTarget { get; set;}
[DispId(554)]
bool TheaterMode { get; set;}
[DispId(555)]
bool AddressBar { get; set;}
[DispId(556)]
bool Resizable { get; set;}
}
[ComImport(), Guid("34A715A0-6587-11D0-924A-0020AFC7AC4D"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIDispatch),
TypeLibType(TypeLibTypeFlags.FHidden)]
public interface DWebBrowserEvents2
{
[DispId(102)]
void StatusTextChange([In] string text);
[DispId(108)]
void ProgressChange([In] int progress, [In] int progressMax);
[DispId(105)]
void CommandStateChange([In] long command, [In] bool enable);
[DispId(106)]
void DownloadBegin();
[DispId(104)]
void DownloadComplete();
[DispId(113)]
void TitleChange([In] string text);
[DispId(112)]
void PropertyChange([In] string szProperty);
[DispId(250)]
void BeforeNavigate2([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp,
[In] ref object URL, [In] ref object flags,
[In] ref object targetFrameName, [In] ref object postData,
[In] ref object headers, [In, Out] ref bool cancel);
[DispId(251)]
void NewWindow2([In, Out, MarshalAs(UnmanagedType.IDispatch)] ref object pDisp,
[In, Out] ref bool cancel);
[DispId(252)]
void NavigateComplete2([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp,
[In] ref object URL);
[DispId(259)]
void DocumentComplete([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp,
[In] ref object URL);
[DispId(253)]
void OnQuit();
[DispId(254)]
void OnVisible([In] bool visible);
[DispId(255)]
void OnToolBar([In] bool toolBar);
[DispId(256)]
void OnMenuBar([In] bool menuBar);
[DispId(257)]
void OnStatusBar([In] bool statusBar);
[DispId(258)]
void OnFullScreen([In] bool fullScreen);
[DispId(260)]
void OnTheaterMode([In] bool theaterMode);
[DispId(262)]
void WindowSetResizable([In] bool resizable);
[DispId(264)]
void WindowSetLeft([In] int left);
[DispId(265)]
void WindowSetTop([In] int top);
[DispId(266)]
void WindowSetWidth([In] int width);
[DispId(267)]
void WindowSetHeight([In] int height);
[DispId(263)]
void WindowClosing([In] bool isChildWindow, [In, Out] ref bool cancel);
[DispId(268)]
void ClientToHostWindow([In, Out] ref long cx, [In, Out] ref long cy);
[DispId(269)]
void SetSecureLockIcon([In] int secureLockIcon);
[DispId(270)]
void FileDownload([In, Out] ref bool cancel);
[DispId(271)]
void NavigateError([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp,
[In] ref object URL, [In] ref object frame, [In] ref object statusCode, [In, Out] ref bool cancel);
[DispId(225)]
void PrintTemplateInstantiation([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp);
[DispId(226)]
void PrintTemplateTeardown([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp);
[DispId(227)]
void UpdatePageStatus([In, MarshalAs(UnmanagedType.IDispatch)] object pDisp,
[In] ref object nPage, [In] ref object fDone);
[DispId(272)]
void PrivacyImpactedStateChange([In] bool bImpacted);
}
// Used to control the webbrowser appearance and provide DTE to script via window.external
[ ComImport(), Guid("BD3F23C0-D43E-11CF-893B-00AA00BDCE1A"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)]
internal interface IDocHostUIHandler
{
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ShowContextMenu(
[In, MarshalAs(UnmanagedType.U4)]
int dwID,
[In]
NativeMethods.POINT pt,
[In, MarshalAs(UnmanagedType.Interface)]
object pcmdtReserved,
[In, MarshalAs(UnmanagedType.Interface)]
object pdispReserved);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetHostInfo(
[In, Out]
NativeMethods.DOCHOSTUIINFO info);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ShowUI(
[In, MarshalAs(UnmanagedType.I4)]
int dwID,
[In]
UnsafeNativeMethods.IOleInPlaceActiveObject activeObject,
[In]
NativeMethods.IOleCommandTarget commandTarget,
[In]
UnsafeNativeMethods.IOleInPlaceFrame frame,
[In]
UnsafeNativeMethods.IOleInPlaceUIWindow doc);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int HideUI();
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int UpdateUI();
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int EnableModeless(
[In, MarshalAs(UnmanagedType.Bool)]
bool fEnable);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int OnDocWindowActivate(
[In, MarshalAs(UnmanagedType.Bool)]
bool fActivate);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int OnFrameWindowActivate(
[In, MarshalAs(UnmanagedType.Bool)]
bool fActivate);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int ResizeBorder(
[In]
NativeMethods.COMRECT rect,
[In]
UnsafeNativeMethods.IOleInPlaceUIWindow doc,
bool fFrameWindow);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int TranslateAccelerator(
[In]
ref System.Windows.Interop.MSG msg,
[In]
ref Guid group,
[In, MarshalAs(UnmanagedType.I4)]
int nCmdID);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetOptionKeyPath(
[Out, MarshalAs(UnmanagedType.LPArray)]
String[] pbstrKey,
[In, MarshalAs(UnmanagedType.U4)]
int dw);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetDropTarget(
[In, MarshalAs(UnmanagedType.Interface)]
UnsafeNativeMethods.IOleDropTarget pDropTarget,
[Out, MarshalAs(UnmanagedType.Interface)]
out UnsafeNativeMethods.IOleDropTarget ppDropTarget);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int GetExternal(
[Out, MarshalAs(UnmanagedType.Interface)]
out object ppDispatch);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int TranslateUrl(
[In, MarshalAs(UnmanagedType.U4)]
int dwTranslate,
[In, MarshalAs(UnmanagedType.LPWStr)]
string strURLIn,
[Out, MarshalAs(UnmanagedType.LPWStr)]
out string pstrURLOut);
[return: MarshalAs(UnmanagedType.I4)]
[PreserveSig]
int FilterDataObject(
IComDataObject pDO,
out IComDataObject ppDORet);
}
#if never
//
// Used to control the webbrowser security
[ComVisible(true), ComImport(), Guid("79eac9ee-baf9-11ce-8c82-00aa004ba90b"),
InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown), CLSCompliant(false)]
public interface IInternetSecurityManager {
[PreserveSig] int SetSecuritySite();
[PreserveSig] int GetSecuritySite();
[PreserveSig] int MapUrlToZone();
[PreserveSig] int GetSecurityId();
[PreserveSig] int ProcessUrlAction(string url, int action,
[Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] byte[] policy,
int cbPolicy, ref byte context, int cbContext,
int flags, int reserved);
[PreserveSig] int QueryCustomPolicy();
[PreserveSig] int SetZoneMapping();
[PreserveSig] int GetZoneMappings();
}
#endif
#endregion WebBrowser Related Definitions
///
/// Critical: as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError=true, CharSet=CharSet.Auto)]
public static extern uint GetRawInputDeviceList(
[In, Out] NativeMethods.RAWINPUTDEVICELIST[] ridl,
[In, Out] ref uint numDevices,
uint sizeInBytes);
///
/// Critical: as suppressing UnmanagedCodeSecurity
///
[SecurityCritical, SuppressUnmanagedCodeSecurity]
[DllImport(ExternDll.User32, SetLastError=true, CharSet=CharSet.Auto)]
public static extern uint GetRawInputDeviceInfo(
IntPtr hDevice,
uint command,
[In] ref NativeMethods.RID_DEVICE_INFO ridInfo,
ref uint sizeInBytes);
}
}
// 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
- DesignerActionPropertyItem.cs
- PropertyGroupDescription.cs
- ImageSource.cs
- SplineQuaternionKeyFrame.cs
- RelativeSource.cs
- ScriptingJsonSerializationSection.cs
- CodeParameterDeclarationExpressionCollection.cs
- ColorPalette.cs
- NameSpaceEvent.cs
- StrongTypingException.cs
- ActiveXHelper.cs
- FileSystemInfo.cs
- AtomContentProperty.cs
- NavigatorInput.cs
- FeatureSupport.cs
- SByteConverter.cs
- DiscoveryClientReferences.cs
- TextModifier.cs
- LinqDataSourceDisposeEventArgs.cs
- _TimerThread.cs
- MediaContextNotificationWindow.cs
- PrintController.cs
- BamlRecordReader.cs
- AppDomainShutdownMonitor.cs
- _HeaderInfo.cs
- ImageFormat.cs
- ReturnValue.cs
- AsyncCompletedEventArgs.cs
- LocalFileSettingsProvider.cs
- GlobalProxySelection.cs
- RepeaterCommandEventArgs.cs
- SimpleType.cs
- SplineKeyFrames.cs
- ProcessHostConfigUtils.cs
- FunctionImportMapping.cs
- EntityViewGenerationAttribute.cs
- IPipelineRuntime.cs
- TreeViewImageKeyConverter.cs
- GenericNameHandler.cs
- Transform3DCollection.cs
- MenuStrip.cs
- NamespaceDecl.cs
- DbDataSourceEnumerator.cs
- TransformerInfoCollection.cs
- BrowserCapabilitiesFactory.cs
- FileAuthorizationModule.cs
- NotEqual.cs
- nulltextcontainer.cs
- ContractComponent.cs
- FacetValues.cs
- XmlValidatingReader.cs
- EventRouteFactory.cs
- MemoryFailPoint.cs
- CallSiteBinder.cs
- Paragraph.cs
- ChannelParameterCollection.cs
- PerformanceCounterPermission.cs
- DetailsViewPagerRow.cs
- StringCollectionMarkupSerializer.cs
- MetadataPropertyAttribute.cs
- BitmapData.cs
- TextEditorSpelling.cs
- ProfileServiceManager.cs
- AssertFilter.cs
- AdCreatedEventArgs.cs
- DocComment.cs
- SqlBuffer.cs
- LassoHelper.cs
- XmlSchemaElement.cs
- TextPointer.cs
- DbMetaDataCollectionNames.cs
- ColorBlend.cs
- UserPreferenceChangingEventArgs.cs
- TextInfo.cs
- SegmentInfo.cs
- Function.cs
- XmlSerializer.cs
- UpdateException.cs
- TripleDESCryptoServiceProvider.cs
- followingquery.cs
- ValueUnavailableException.cs
- SqlDataRecord.cs
- FormView.cs
- EnvelopeVersion.cs
- PermissionListSet.cs
- RawStylusInputCustomDataList.cs
- HitTestWithGeometryDrawingContextWalker.cs
- TemplatedAdorner.cs
- TypeBuilderInstantiation.cs
- TraceContextRecord.cs
- CreateUserWizard.cs
- ImageDrawing.cs
- CalendarDateRangeChangingEventArgs.cs
- WhitespaceRuleReader.cs
- WindowsBrush.cs
- DateTimeFormatInfoScanner.cs
- FixedSOMPageElement.cs
- SourceFilter.cs
- FontUnitConverter.cs
- TableStyle.cs