SysListView32 запись значений в чужом окне

public class Class1
{
 
 
/// <summary>
/// Reads a list view item and returns the
User32.Consts.ListView.LV_ITEM read.
/// </summary>
/// <param name="hWnd"></param>
/// <param name="item"></param>
/// <param name="subItem"></param>
/// <param name="selected"></param>
/// <param name="returnItem"></param>
/// <returns></returns>
public static string ReadListViewItem(
IntPtr hWnd,
int item,
int subItem,
out bool selected,
out User32.Consts.ListView.LV_ITEM returnItem)
{
User32.Consts.ListView.LV_ITEM lvItem;
string retval;
IntPtr hProcess = IntPtr.Zero;
IntPtr lpRemoteBuffer = IntPtr.Zero;
IntPtr lpLocalBuffer = IntPtr.Zero;
IntPtr threadId = IntPtr.Zero;
 
try
{
//create a new "Storage" object
lvItem = new User32.Consts.ListView.LV_ITEM();
 
//create a local buffer
lpLocalBuffer =
Marshal.AllocHGlobal(User32.Consts.CrossProcessMem.dwBufferSize);
 
//create a remote buffer in the other process
lpRemoteBuffer = AllocateMemoryInOtherProcess(hWnd, ref
hProcess);
 
//Create a "Storage" object
// Fill in the LVITEM struct, this is in your own process
// Set the pszText member to somewhere in the remote buffer,
// For the example I used the address imediately following the
LVITEM stuct
lvItem.mask = User32.Consts.ListView.Masks.LVIF_TEXT |
User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.iItem = item;
lvItem.iSubItem = subItem;
lvItem.pszText = (IntPtr)(lpRemoteBuffer.ToInt32() +
Marshal.SizeOf(typeof(User32.Consts.ListView.LV_ITEM)));
lvItem.cchTextMax = 255;
lvItem.stateMask = (uint)(new IntPtr(-1).ToInt32());
 
// process the message using the remote buffer
IntPtr local = ProcessRemoteMessage(
hProcess,
hWnd,
User32.Consts.ListView.Messages.LVM_GETITEM,
IntPtr.Zero,
lpRemoteBuffer,
lpLocalBuffer,
typeof(User32.Consts.ListView.LV_ITEM),
ref lvItem);
 
//set the local buffer to our returned pointer
lpLocalBuffer = local;
 
//convert the pointer back to the structure
User32.Consts.ListView.LV_ITEM lv = new
User32.Consts.ListView.LV_ITEM();
lv =
(User32.Consts.ListView.LV_ITEM)Marshal.PtrToStructure(lpLocalBuffer,
typeof(User32.Consts.ListView.LV_ITEM));
 
returnItem = lv;
 
if (lv.state > 8191)
{
selected = true;
}
else
{
selected = false;
}
 
// At this point the lpLocalBuffer contains the returned
User32.Consts.ListView.LV_ITEM structure
// the next line extracts the text from the buffer into a
managed string
retval = Marshal.PtrToStringAnsi(
(IntPtr)(lpLocalBuffer.ToInt32() +
Marshal.SizeOf(typeof(User32.Consts.ListView.LV_ITEM)))
);
}
finally
{
if (lpLocalBuffer != IntPtr.Zero)
Marshal.FreeHGlobal(lpLocalBuffer);
if (lpRemoteBuffer != IntPtr.Zero)
User32.VirtualFreeEx(hProcess, lpRemoteBuffer, 0,
User32.Consts.CrossProcessMem.MEM_RELEASE);
if (hProcess != IntPtr.Zero)
User32.CloseHandle(hProcess);
}
return retval;
}
 
/// <summary>
/// Sets the state of a listview item
/// </summary>
/// <param name="hWnd">handle to the listview</param>
/// <param name="item">Item to manipulate</param>
/// <param name="subItem">subitem should generally be set to
zero</param>
/// <param name="selected">value of the Checked state</param>
/// <param name="activate">Activates the item</param>
/// <param name="setFocus">Sets focus to the item</param>
/// <param name="selectItem">Selects the item (highlights
it)</param>
/// <param name="checkItem">Attempts to Check the item</param>
public static void SetListViewItem(
IntPtr hWnd,
int item,
int subItem,
bool selected,
bool activate,
bool setFocus,
bool selectItem,
bool checkItem ) //add a string text parameter here
{
User32.Consts.ListView.LV_ITEM lvItem;
string retval;
IntPtr hProcess = IntPtr.Zero;
IntPtr lpRemoteBuffer = IntPtr.Zero;
IntPtr lpLocalBuffer = IntPtr.Zero;
IntPtr threadId = IntPtr.Zero;
 
try
{
bool tmp = false;
//Read the list view item to retrieve the LV_ITEM struct
from the existing item
ReadListViewItem(hWnd, item, subItem, out tmp, out lvItem);
 
//create a local buffer
lpLocalBuffer =
Marshal.AllocHGlobal(User32.Consts.CrossProcessMem.dwBufferSize);
 
//create a remote buffer in the other process
lpRemoteBuffer = AllocateMemoryInOtherProcess(hWnd, ref
hProcess);
 
 
#region Set Focus Item
if (setFocus)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_FOCUSED;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_FOCUSED;
 
// send the message to the process using the remote
buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to
send
ref lvItem); //return object
}
#endregion Set Focus Item
 
#region Select Item
if (selectItem)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_SELECTED;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_SELECTED;
 
// send the message to the process using the remote
buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to
send
ref lvItem); //return object
}
#endregion Select Item
 
#region Activate Item
if (activate)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_ACTIVATING;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_ACTIVATING;
 
// send the message to the process using the remote
buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to
send
ref lvItem); //return object
}
#endregion Activate Item
 
#region Check Item
if (checkItem)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_STATEIMAGEMASK;
 
if (selected)
{
//>8192
lvItem.state = 8192;
}
else
{
lvItem.state = 4096;
}
 
 
// send the message to the process using the remote
buffer
ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to
send
ref lvItem); //return object
}
#endregion CheckItem
 
//add a region for changing the text if it is not null here
}
finally
{
if (lpLocalBuffer != IntPtr.Zero)
Marshal.FreeHGlobal(lpLocalBuffer);
if (lpRemoteBuffer != IntPtr.Zero)
User32.VirtualFreeEx(hProcess, lpRemoteBuffer, 0,
User32.Consts.CrossProcessMem.MEM_RELEASE);
if (hProcess != IntPtr.Zero)
User32.CloseHandle(hProcess);
}
return retval;
}
 
/// <summary>
/// Calls
/// WriteObjectToOtherProcessMemory,
/// SendMessageToRemoteBuffer and
/// ReadRemoteBufferIntoLocalBuffer
/// in one call.
/// </summary>
/// <param name="hProcess"></param>
/// <param name="hWnd"></param>
/// <param name="message"></param>
/// <param name="wParam"></param>
/// <param name="lpRemoteBuffer"></param>
/// <param name="lpLocalBuffer"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static IntPtr ProcessRemoteMessage(
IntPtr hProcess,
IntPtr hWnd,
uint message,
IntPtr wParam,
IntPtr lpRemoteBuffer,
IntPtr lpLocalBuffer,
Type typeToMarshal,
ref User32.Consts.ListView.LV_ITEM obj)
{
 
//Write to the other process memory
WriteObjectToOtherProcessMemory(
hProcess,
lpRemoteBuffer,
typeToMarshal,
ref obj);
 
SendMessageToRemoteBuffer(
hWnd,
message,
wParam,
lpRemoteBuffer);
 
IntPtr retVal = ReadRemoteBufferIntoLocalBuffer(
hProcess,
lpRemoteBuffer,
lpLocalBuffer);
 
return retVal;
}
 
/// <summary>
/// Writes an object (managed buffer) into a different unmanaged
/// process memory
/// </summary>
/// <param name="hProcess"></param>
/// <param name="lpRemoteBuffer"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static bool WriteObjectToOtherProcessMemory(
IntPtr hProcess,
IntPtr lpRemoteBuffer,
Type typeToMarshal,
ref User32.Consts.ListView.LV_ITEM obj)
{
bool bSuccess;
 
bSuccess = User32.WriteProcessMemory(
hProcess,
lpRemoteBuffer,
ref obj,
Marshal.SizeOf(typeToMarshal), IntPtr.Zero);
 
if (!bSuccess)
throw new SystemException("Failed to write to process
memory");
 
return bSuccess;
}
 
/// <summary>
/// Sends a Message to an unmanaged process window
/// </summary>
/// <param name="hWnd"></param>
/// <param name="message"></param>
/// <param name="wParam"></param>
/// <param name="lpRemoteBuffer"></param>
public static void SendMessageToRemoteBuffer(
IntPtr hWnd,
uint message,
IntPtr wParam,
IntPtr lpRemoteBuffer)
{
object o = new object();
 
HandleRef handleRef = new HandleRef(o, hWnd);
 
IntPtr result = IntPtr.Zero;
 
User32.SendMessageTimeout(
handleRef,
message,
wParam,
lpRemoteBuffer,
new
UIntPtr(User32.Consts.SendMessageTimeOutFlags.SMTO_ABORTIFHUNG),
Properties.Settings.Default.SendMessageBaseTimeOut,
out result);
 
int r = result.ToInt32();
 
}
 
/// <summary>
/// Reads a remote buffer and places its contents into a local
(managed) buffer. The
/// method returns the local buffer.
/// </summary>
/// <param name="hProcess"></param>
/// <param name="lpRemoteBuffer"></param>
/// <param name="lpLocalBuffer"></param>
/// <returns></returns>
public static IntPtr ReadRemoteBufferIntoLocalBuffer(
IntPtr hProcess,
IntPtr lpRemoteBuffer,
IntPtr lpLocalBuffer)
{
bool bSuccess = false;
 
bSuccess = User32.ReadProcessMemory(
hProcess,
lpRemoteBuffer,
lpLocalBuffer,
User32.Consts.CrossProcessMem.dwBufferSize,
IntPtr.Zero);
 
if (!bSuccess)
throw new SystemException("Failed to read from process
memory");
 
return lpLocalBuffer;
}
 
 
}
 
public class User32
{
 
[DllImport("user32")]
public static extern IntPtr GetWindowThreadProcessId(IntPtr hWnd, out
int lpwdProcessID);
 
[DllImport("kernel32")]
public static extern IntPtr OpenProcess(uint dwDesiredAccess, bool
bInheritHandle,
int dwProcessId);
 
[DllImport("kernel32")]
public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr
lpAddress,
int dwSize, uint flAllocationType, uint flProtect);
 
[DllImport("kernel32")]
public static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr
lpAddress, int dwSize,
uint dwFreeType);
 
[DllImport("kernel32")]
public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr
lpBaseAddress,
ref User32.Consts.ListView.LV_ITEM buffer, int dwSize, IntPtr
lpNumberOfBytesWritten);
 
[DllImport("kernel32")]
public static extern bool CloseHandle(IntPtr hObject);
}

public class Class1
{
/// <summary>
/// Writes an object (managed buffer) into a different unmanaged
/// process memory
/// </summary>
/// <param name="hProcess">Remote Process</param>
/// <param name="lpRemoteBuffer">Remote Memory Address (base
address)</param>
/// <param name="obj">object to write</param>
/// <returns>Bool if the method was successful</returns>
public static bool WriteObjectToOtherProcessMemory(
IntPtr hProcess,
IntPtr lpRemoteBuffer,
Type typeToMarshal,
ref StringBuilder obj)
{
bool bSuccess;
 
//call the WriteProcessMemory (slightly different then
//the other methods. We use the Capacity value of
//the stringbuilder for the 'size' parameter
bSuccess = User32.WriteProcessMemory(
hProcess,
lpRemoteBuffer,
obj, obj.Capacity, IntPtr.Zero);
 
if (!bSuccess)
throw new SystemException("Failed to write to process memory");
 
return bSuccess;
}
 
 
public static string SetListViewItem(
IntPtr hWnd,
int item,
int subItem,
string text,
bool selected,
bool activate,
bool setFocus,
bool highlightItem,
bool checkItem,
bool manipulateOnlySubItem)
{
User32.Consts.ListView.LV_ITEM lvItem;
string retval;
IntPtr hProcess = IntPtr.Zero;
IntPtr lpRemoteBuffer = IntPtr.Zero;
IntPtr lpLocalBuffer = IntPtr.Zero;
IntPtr lpRemoteBufferWithText = IntPtr.Zero;
IntPtr threadId = IntPtr.Zero;
 
try
{
int tmpSubItem = subItem;
bool tmp = false;
ReadListViewItem(hWnd, item, subItem, out tmp, out lvItem);
 
//create a local buffer
lpLocalBuffer =
Marshal.AllocHGlobal(User32.Consts.CrossProcessMem.dwBufferSize * 2);
 
//create a remote buffer in the other process
lpRemoteBuffer = AllocateMemoryInOtherProcess(hWnd, ref
hProcess);
 
if (!manipulateOnlySubItem)
{
subItem = item;
}
 
#region Set Focus Item
if (setFocus)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_FOCUSED;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_FOCUSED;
 
// process the message using the remote buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to send
ref lvItem); //return object
}
#endregion Set Focus Item
 
#region Select Item
if (highlightItem)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_SELECTED;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_SELECTED;
 
// process the message using the remote buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to send
ref lvItem); //return object
}
#endregion Select Item
 
#region Activate Item
if (activate)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_ACTIVATING;
lvItem.state =
User32.Consts.ListView.StateMasks.LVIS_ACTIVATING;
 
// process the message using the remote buffer
IntPtr local = ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to send
ref lvItem); //return object
}
#endregion Activate Item
 
#region Check Item
if (checkItem)
{
lvItem.mask = User32.Consts.ListView.Masks.LVIF_STATE;
lvItem.stateMask =
User32.Consts.ListView.StateMasks.LVIS_STATEIMAGEMASK;
 
if (selected)
{
//>8192
lvItem.state = 8192;
}
else
{
lvItem.state = 4096;
}
 
 
// process the message using the remote buffer
ProcessRemoteMessage(
hProcess, //process
hWnd,//handle
User32.Consts.ListView.Messages.LVM_SETITEM,//message
IntPtr.Zero, //Wparam
lpRemoteBuffer, //remote buffer
lpLocalBuffer, //local buffer
typeof(User32.Consts.ListView.LV_ITEM), //type to send
ref lvItem); //return object
}
#endregion CheckItem
 
if (!manipulateOnlySubItem)
{
subItem = tmpSubItem;
}
 
#region Text
 
 
//Create a "Storage" object
// Fill in the LVITEM struct, this is in your own process
// Set the pszText member to somewhere in the remote buffer,
// Use the address imediately following the LVITEM stuct
// to store the text for retrieve by the ListView upon
// sending the message
lvItem.mask = User32.Consts.ListView.Masks.LVIF_TEXT;
lvItem.iSubItem = subItem;
lvItem.iItem = item;
 
//Allocate the buffer (make a 1mb area)
IntPtr remoteBufferLVITEM = lpRemoteBuffer;
 
//assign the text location in the remote buffer
IntPtr remoteBufferText = new
IntPtr(remoteBufferLVITEM.ToInt32() +
Marshal.SizeOf(typeof(User32.Consts.ListView.LV_ITEM)));
 
//assign our stringbuilder the text value
StringBuilder builderText = new StringBuilder(text);
lvItem.cchTextMax = builderText.Capacity;
 
//set the text pointer to point to the text
//in the remote buffer
lvItem.pszText = remoteBufferText;
 
//Write the LV_ITEM Struct to the remote memory location
WriteObjectToOtherProcessMemory(
hProcess,
remoteBufferLVITEM,
typeof(User32.Consts.ListView.LV_ITEM),
ref lvItem);
 
//write the text to the remote memory location
WriteObjectToOtherProcessMemory(
hProcess,
remoteBufferText,
typeof(StringBuilder),
ref builderText);
 
//send the message to have the ListView read the text
//from the memory location
SendMessageToRemoteBuffer(
hWnd,
User32.Consts.ListView.Messages.LVM_SETITEM,
IntPtr.Zero,
remoteBufferLVITEM);
 
//used to check the value after the write
 
//IntPtr remoteBufferValue = ReadRemoteBufferIntoLocalBuffer(
// hProcess,
// lpRemoteBuffer,
// lpLocalBuffer);
 
//string value = Marshal.PtrToStringAnsi(
// (IntPtr)(lpLocalBuffer.ToInt32() +
Marshal.SizeOf(typeof(User32.Consts.ListView.LV_ITEM)))
// );
 
#endregion Text
 
retval = string.Empty;
}
finally
{
if (lpLocalBuffer != IntPtr.Zero)
Marshal.FreeHGlobal(lpLocalBuffer);
if (lpRemoteBuffer != IntPtr.Zero)
User32.VirtualFreeEx(hProcess, lpRemoteBuffer, 0,
User32.Consts.CrossProcessMem.MEM_RELEASE);
if (hProcess != IntPtr.Zero)
User32.CloseHandle(hProcess);
}
return retval;
}
}
 
 
public class User32
{
//it is important to have the MarshalAs attribute for the
//StringBuilder here otherwise the system can
//not Marshal the StringBuilder
[DllImport("kernel32")]
public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr
lpBaseAddress,
[MarshalAs(UnmanagedType.LPStr)] StringBuilder buffer, int dwSize,
IntPtr lpNumberOfBytesWritten);
 
}