Sending a Custom windows message...custom data marshalling

Question

I have a WPF application that needs to interface with another application.

This application has about 20 custom Windows Messages (WM_USER+50...WM_USER+70).

Summary of what I'm trying to accomplish:

WPF Application -> SendMessage -> ThirdParty application

The problem I have is that all of the Messages are CUSTOM messages. Therefore I have to implement my own data marshaling.

See http://msdn.microsoft.com/en-us/library/windows/desktop/ms644950(v=vs.85).aspx

It seems that the process I need to go through is:

1. Grab the process and open it for all access. User32.GetWindowThreadProcessId(windowHandle, out pId);

   // Open the process with all access
   someprocess = OpenProcess((0x1F0FFF), false, (int)pId);

2. Allocate a buffer in the process: IntPtr buffer = VirtualAllocEx( hProcess, IntPtr.Zero, 1024, 0x1000, 0x04 );

3. Fill up some sort of struct that will be written to the buffer created in #2?

4. Copy #3 to the remote buffer is #2? WriteProcessMemory??

5. Send the custom message ( SendMessage(windowhandle, customMsg, 0, buffer from #2?)

6. Read the struct back in from the remote process buffer into a local buffer

7. Marshal this data to a managed type. (This is a C# .Net application)

I could really use some insight. I haven't had much luck thus far. I think the part that I'm most stuck on is what type of struct to send to the WriteProcessMemory?

Answer 1

WM_COPYDATA is definitely the easiest way to do this. WM_COPYDATA lets you send two distinct items of data to another process - a DWORD value, and an arbitrarily-sized chunk of data. So for your implementation you would probably do something like this:

COPYDATASTRUCT cds;
cds.dwData = WM_USER + 50; // the "message" you want to send
cds.cbData = sizeof(MyDataForMessage50); // the size of the chunk of data
cds.lpData = lpMessage50Data; // a pointer to the chunk of data
SendMessage(hwndTarget, WM_COPYDATA, reinterpret_cast<WPARAM>(hwndSender),
            reinterpret_cast<LPARAM>(&cds));

Note that hwndTarget is the target window in the other process, and hwndSender is a window in the sending process. The target window receives the same parameters and so can use wParam to learn who sent the message, and can therefore send a reply if needed.

In the WndProc at the receiving end:

if (uMsg == WM_COPYDATA)
{
    HWND hwndSender = reinterpret_cast<HWND>(wParam);
    LPCOPYDATASTRUCT pcds = reinterpret_cast<LPCOPYDATASTRUCT>(lParam);
    DWORD dwCustomMsg = pcds->dwData;
    LPVOID pCustomData = pcds->lpData;
    DWORD dwCustomDataSize = pcds->cbData;

    // do something with the custom message

    // return TRUE to indicate message received
    return TRUE;
}

Also note the important note in the docs for WM_COPYDATA:

The receiving application should consider the data read-only. The lParam parameter is valid only during the processing of the message. The receiving application should not free the memory referenced by lParam. If the receiving application must access the data after SendMessage returns, it must copy the data into a local buffer

Answer 2

Sample code for Sending message:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApp2
{
    class Program
    {
        public const int WM_COPYDATA = 0x4A;
        public const UInt32 WM_COMMAND = 0x0111;
        public const UInt32 IDM_MENU_SECUREDISCONNECT = 305;
        public const UInt32 PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
        [StructLayout(LayoutKind.Sequential)]
        public struct COPYDATASTRUCT
        {
            public IntPtr dwData;
            public int cbData;
            [MarshalAs(UnmanagedType.LPWStr)]
            public string lpData;
        }
        [DllImport("User32.dll", EntryPoint = "SendMessage", SetLastError = true)]
        public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, ref COPYDATASTRUCT lParam);
        private const string MARKER = "MARKER\n";
        static void Main(string[] args)
        {
            IntPtr destWnd = (IntPtr)int.Parse(args[0]);
          string packedargs = DAZZLE_MARKER + String.Join("\n", args[1]);
            /
            byte[] sarr = System.Text.Encoding.Unicode.GetBytes(packedargs);
            int len = sarr.Length;
            COPYDATASTRUCT CopyDataStruct;
            CopyDataStruct.dwData = (IntPtr)100;
            CopyDataStruct.cbData = (len + 1) * 2;
            CopyDataStruct.lpData = packedargs;
            int result = SendMessage(destWnd, WM_COPYDATA, 0, ref CopyDataStruct);
        }
    }
}