A Clipboard sharing idea

[stlintel]

Hi,

Some idea came into my mind. We could have a application running under guest Windows could share clipboard with the host.
Once smth is copied into Clipboard on the guest, it could mirror the clipboard of the guest to clipboard of the host.
So paste on the host would paste the same thing.

I had a brief ChatGPR consultation about it it came up with 2 prototypes.

1st one monitors clipboard of Windows and does smth with everything found (specifically prints on screen and add to a file).
It is pretty dump because it dumps the same clipboard content over and over again and not once per change but I bet it is fixable.

#include <windows.h>
#include <iostream>
#include <fstream>
#include <vector>

// Function to get the current clipboard text
std::wstring GetClipboardText() {
    std::wstring clipboardText;
    if (OpenClipboard(nullptr)) {
        HANDLE hData = GetClipboardData(CF_UNICODETEXT);
        if (hData != nullptr) {
            wchar_t* pszText = static_cast<wchar_t*>(GlobalLock(hData));
            if (pszText != nullptr) {
                clipboardText = pszText;
                GlobalUnlock(hData);
            }
        }
        CloseClipboard();
    }
    return clipboardText;
}

// Function to write text to a file
void WriteToFile(const std::wstring& text) {
    std::wofstream file("clipboard_history.txt", std::ios::app);
    if (file.is_open()) {
        file << text << std::endl;
    }
}

int main() {
    // Main loop to continuously monitor the clipboard
    while (true) {
        Sleep(1000);  // Sleep for 1 second (adjust as needed)

        // Get the current clipboard text
        std::wstring clipboardText = GetClipboardText();

        // If the clipboard contains new text, write it to the file
        if (!clipboardText.empty()) {
            std::wcout << L"New clipboard text: " << clipboardText << std::endl;

            // Write to file
            WriteToFile(clipboardText);
        }
    }

    return 0;
}

2nd is prototype of ability to copy stuff into host Windows clipboard

#include <vector>
#include <iostream>
#include <fstream>
#include <Windows.h>

bool CopyFileToClipboard(const std::string& filePath)
{
    // Open the file
    std::ifstream file(filePath, std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "Error: Unable to open file " << filePath << std::endl;
        return false;
    }

    // Read the file content
    std::vector<unsigned char> fileContent((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());

    // Close the file
    file.close();

    // Open the clipboard
    if (!OpenClipboard(nullptr)) {
        std::cerr << "Error: Unable to open the clipboard" << std::endl;
        return false;
    }

    // Clear the clipboard
    EmptyClipboard();

    // Allocate global memory to hold the file content
    HGLOBAL hClipboardData = GlobalAlloc(GMEM_MOVEABLE, fileContent.size());
    if (!hClipboardData) {
        std::cerr << "Error: Unable to allocate memory for clipboard data" << std::endl;
        CloseClipboard();
        return false;
    }

    // Lock the global memory and copy the file content
    LPVOID pClipboardData = GlobalLock(hClipboardData);
    if (!pClipboardData) {
        std::cerr << "Error: Unable to lock clipboard memory" << std::endl;
        GlobalFree(hClipboardData);
        CloseClipboard();
        return false;
    }

    memcpy(pClipboardData, fileContent.data(), fileContent.size());

    // Unlock the global memory
    GlobalUnlock(hClipboardData);

    // Set clipboard data
    SetClipboardData(CF_OEMTEXT, hClipboardData);

    // Close the clipboard
    CloseClipboard();

    return true;
}

int main(int argn, char **argv)
{
    if (argn < 2) {
        std::cerr << "Error: Failed to copy file to clipboard. Need a file name." << std::endl;
    }    

    std::string filePath = std::string(argv[1]);

    if (CopyFileToClipboard(filePath)) {
        std::cout << "File copied to clipboard successfully." << std::endl;
    } else {
        std::cerr << "Error: Failed to copy file to clipboard." << std::endl;
    }

    return 0;
}

Of course there is a need for some guest2host communication interface, smth like a methods to do memcpy from guest memory to host memory but this also doable with inventing some Bochs API. May be you could suggest smth.
I know some used magic CPUID operations. The CPUID can be called with some crazy leaf number like 0x48000000 and EBX, ECX, EDX will be parameters. Bochs can intercept the magic CPUID call and use it as guest2host memcpy command.

Now remains only to hide the clipboard program on guest windows so it won't bother but be kept as service.

Any suggestions ?

[stlintel]

I bet the same mechanisms exists also in Linux

[Vort]

Something like that is implemented in VirtualBox and probably many other VMs.
I don't know if this part of VirtualBox is open sourced, but if it is, it may worth to look how this feature is implemented there.

[vruppert]

In the' vnet' networking module I have added a small FTP server that can exchange files with the host. We could use this technique for such a project. A small program on the guest opens a network connection with the VNET server that can access the host clipboard. Adding a PCI pseudo device for this task would require to write a driver for the guest.

[Vort]

Clipboard sharing may be needed in modes other than vnet.
Yes, driver is needed. Maybe it is possible to make mechanism compatible with VirtualBox? It have drivers already.

[vruppert]

I have no experience in writing drivers at all. If the API is freely available, we could possibly use their drivers. On the other hand a networking based solution would be portable. As a first step I could improve the existing clipboard support. Currently it can only handle text to copy the text mode screen to the clipboard and paste text by simulating keystrokes. I think the work for the suggested feature cannot be done in a short term, so we should keep it in mind and make Bochs ready for release 2.8.