Обмен сообщениями между программами

struct TMyData
{
 char Text1[100];
 int Data1;
 int Data2;
};
TMyData *MyData;
<...>
BEGIN_MESSAGE_MAP
      MESSAGE_HANDLER(WM_COPYDATA, TMessage, OnMyMessage)
    END_MESSAGE_MAP(TForm)
<...>
void __fastcall TForm1::OnMyMessage(TMessage& Message)
{
  COPYDATASTRUCT *cpDS;
  cpDS = (COPYDATASTRUCT *)(void *)Message.LParam;
  MyData = (TMyData *)(cpDS->lpData);
  Edit1->Text = MyData->Text1;
  Edit2->Text = IntToStr((int)MyData->Data1);
  Edit3->Text = IntToStr((int)MyData->Data2);
};

void __fastcall TForm1::DefaultHandler(void* Message)
{
  TMessage *msg=(TMessage*)Message;
  switch(msg->Msg)
  {
    case WM_USER:  // твое сообщение  
    if (msg->WParam == ....)
    {  
      // какая-то обработка
      msg->Result = tue;
      return;
    }
  }
  TForm::::DefaultHandler(Message);  // вызов базового метода
}

class PipeBase
{
public:
    void close();
    bool send(void* buff, size_t size);
    bool recv(void* buff, size_t& size);

protected:
    PipeBase();
    ~PipeBase();

    HANDLE hPipe;
};


class ServerPipe :public PipeBase
{
public:
    bool create(const char* name);
    bool connect();
};


class ClientPipe :public PipeBase
{
public:
    bool open(const char* name);
};

//============================================================================
//  PipeBase
//
PipeBase::PipeBase() :hPipe(INVALID_HANDLE_VALUE)
{}

PipeBase::~PipeBase()
{
    close();
}

void PipeBase::close()
{
    if(INVALID_HANDLE_VALUE != hPipe) {
        CloseHandle(hPipe);
        hPipe = INVALID_HANDLE_VALUE;
    }
}

bool PipeBase::send(void* buff, size_t size)
{
    DWORD bytes;
    return (WriteFile(hPipe, buff, (DWORD)size, &bytes, NULL) == TRUE);
}

bool PipeBase::recv(void* buff, size_t& size)
{
    return (ReadFile(hPipe, buff, (DWORD)size, (PDWORD)&size, NULL) == TRUE);
}


//============================================================================
//  ServerPipe
//
bool ServerPipe::create(const char* name)
{
    std::string pipeName("\\\\.\\pipe\\");
    pipeName += name;

    hPipe = CreateNamedPipe(pipeName.c_str(), PIPE_ACCESS_DUPLEX,
        PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
        PIPE_UNLIMITED_INSTANCES, BUFSIZE, BUFSIZE,
        NMPWAIT_USE_DEFAULT_WAIT, NULL);

    return (INVALID_HANDLE_VALUE != hPipe);
}

bool ServerPipe::connect()
{
    BOOL res = ConnectNamedPipe(hPipe, NULL);
    return (res == TRUE ? true : GetLastError() == ERROR_PIPE_CONNECTED);
}


//============================================================================
//  ClientPipe
//
bool ClientPipe::open(const char* name)
{
    std::string pipeName("\\\\.\\pipe\\");
    pipeName += name;

    while(true) {   // !!!
        hPipe = CreateFile(pipeName.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
        if (INVALID_HANDLE_VALUE != hPipe) {
            break;
        }
        DWORD err = GetLastError();
        if (GetLastError() != ERROR_PIPE_BUSY) {
            return false;
        }      
        if (!WaitNamedPipe(name, 200)) {    // All pipe instances are busy, so wait for 200 ms.
            return false;
        }
    }

    DWORD dwMode = PIPE_READMODE_MESSAGE;
    BOOL res = SetNamedPipeHandleState(hPipe, &dwMode, NULL, NULL);
   
    return (res == TRUE);
}

// in dll
class TEditHook
{
private:
    TEdit*          FEdit;
    HWND            FWnd;
    TKeyPressEvent  OnKeyPress;
    void __fastcall OnKeyPress2(TObject *Sender, char &Key);
public:
    void __fastcall Attach(TEdit* AEdit);
    void __fastcall Detach();
public:
    __fastcall TEditHook(String WndName);
    __fastcall ~TEditHook();
};
-------------------------------------------------------------
__fastcall TEditHook::TEditHook(String WndName)
{
    FEdit = NULL;
    OnKeyPress = NULL;
    FWnd = FindWindow(NULL, WndName.c_str());
}
//---------------------------------------------------------------------------
__fastcall TEditHook::~TEditHook()
{
    Detach();
}
//---------------------------------------------------------------------------
void __fastcall TEditHook::Attach(TEdit* AEdit)
{
    //TODO: Add your source code here
    if(FEdit) Detach();

    if(AEdit)
    {
        FEdit = AEdit;
        OnKeyPress = FEdit->OnKeyPress;
        FEdit->OnKeyPress = OnKeyPress2;
    }
}
//---------------------------------------------------------------------------
void __fastcall TEditHook::Detach()
{
    //TODO: Add your source code here
    if(FEdit)
    {
        FEdit->OnKeyPress = OnKeyPress;
        FEdit = NULL;
    }
}
//---------------------------------------------------------------------------

void __fastcall TEditHook::OnKeyPress2(TObject *Sender, char &Key)
{
  if(OnKeyPress)
    OnKeyPress(Sender, Key);

  if(FWnd)
  {
    String data("Кто-то нажал - "); data += Key;
    COPYDATASTRUCT CopyData = { 0, strlen(data.c_str()) + sizeof(char), data.c_str()};
    ::SendMessage( FWnd, WM_COPYDATA, NULL, reinterpret_cast<LPARAM>(&CopyData));
  }
}
//----------------------------------------------------------
...
#define TESTDLL_EXPORTS
#include "testdll.h"
#include "hook_events.h"

extern HHOOK    hHook;
HINSTANCE       hDLL;
char            Work[256];
String          s;
Windows::HINST  hModule=NULL;

TForm *fmMain=NULL;
TEditHook ehk("VCLViewer"); //<===========
...
TForm **pForm=(TForm**)::GetProcAddress(::GetModuleHandle(NULL), "_TargetForm");
            if(pForm == NULL)
            {
                ShowMessage("ERROR: export not found");
            }
            else
            {
                fmMain=*pForm;
                if(fmMain == NULL)
                {
                    ShowMessage("ERROR: form is not accessible");
                }

                TEdit* ed = (TEdit*)fmMain->FindComponent("Edit1");
                if(!ed)ShowMessage("Edit1 not found");
                else
                {ehk.Attach(ed); }
            }
...
// in injector
// hpp
class TfmMain : public TForm
{
...
protected:
    BEGIN_MESSAGE_MAP
        VCL_MESSAGE_HANDLER(WM_COPYDATA, TMessage, OnWMCopyData)
    END_MESSAGE_MAP(TForm)
};
// cpp
void __fastcall TfmMain::OnWMCopyData(TMessage& Message)
{
   
    DWORD CountData;
    PCOPYDATASTRUCT PassedCopyDataStruct;

    char* data;

    PassedCopyDataStruct = reinterpret_cast<COPYDATASTRUCT*>(Message.LParam);

    CountData = PassedCopyDataStruct->cbData;
    if (CountData > 0) {
        data = new char[CountData];
        if (PassedCopyDataStruct->lpData != NULL)
            memmove(data, PassedCopyDataStruct->lpData, CountData);
    }

    Win32Check( ReplyMessage(true) );

    if(data)
        Memo1->Lines->Add(data);

    delete [] data;
}