path: root/src/VBox/ValidationKit/utils/clipboard/ClipUtil.cpp

/* $Id: ClipUtil.cpp $ */
/** @file
 * ClipUtil - Clipboard Utility
 */

/*
 * Copyright (C) 2021-2023 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */


/*********************************************************************************************************************************
*   Header Files                                                                                                                 *
*********************************************************************************************************************************/
#ifdef RT_OS_OS2
# define INCL_BASE
# define INCL_PM
# define INCL_ERRORS
# include <os2.h>
# undef RT_MAX
#endif

#include <iprt/assert.h>
#include <iprt/errcore.h>
#include <iprt/file.h>
#include <iprt/getopt.h>
#include <iprt/initterm.h>
#include <iprt/mem.h>
#include <iprt/message.h>
#include <iprt/process.h>
#include <iprt/string.h>
#include <iprt/stream.h>
#include <iprt/utf16.h>
#include <iprt/zero.h>

#ifdef RT_OS_DARWIN
/** @todo   */
#elif defined(RT_OS_WINDOWS)
# include <iprt/nt/nt-and-windows.h>
#elif !defined(RT_OS_OS2)
# include <X11/Xlib.h>
# include <X11/Xatom.h>
#endif


/*********************************************************************************************************************************
*   Defined Constants And Macros                                                                                                 *
*********************************************************************************************************************************/
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2) || defined(RT_OS_DARWIN)
# undef MULTI_TARGET_CLIPBOARD
# undef CU_X11
#else
# define MULTI_TARGET_CLIPBOARD
# define CU_X11
#endif


/*********************************************************************************************************************************
*   Structures and Typedefs                                                                                                      *
*********************************************************************************************************************************/
/**
 * Clipboard format descriptor.
 */
typedef struct CLIPUTILFORMAT
{
    /** Format name. */
    const char *pszName;

#if defined(RT_OS_WINDOWS)
    /** Windows integer format (CF_XXXX). */
    UINT        fFormat;
    /** Windows string format name. */
    const WCHAR *pwszFormat;

#elif defined(RT_OS_OS2)
    /** OS/2 integer format. */
    ULONG       fFormat;
    /** OS/2 string format name. */
    const char *pszFormat;

#elif defined(RT_OS_DARWIN)
    /** Native format (flavor). */
    CFStringRef *hStrFormat;
#else
    /** The X11 atom for the format. */
    Atom        uAtom;
    /** The X11 atom name if uAtom must be termined dynamically. */
    const char *pszAtomName;
    /** @todo X11 */
#endif

    /** Description. */
    const char *pszDesc;
    /** CLIPUTILFORMAT_F_XXX. */
    uint32_t    fFlags;
} CLIPUTILFORMAT;
/** Pointer to a clipobard format descriptor. */
typedef CLIPUTILFORMAT const *PCCLIPUTILFORMAT;

/** Convert to/from UTF-8.  */
#define CLIPUTILFORMAT_F_CONVERT_UTF8       RT_BIT_32(0)
/** Ad hoc entry.  */
#define CLIPUTILFORMAT_F_AD_HOC             RT_BIT_32(1)


#ifdef MULTI_TARGET_CLIPBOARD
/**
 * Clipboard target descriptor.
 */
typedef struct CLIPUTILTARGET
{
    /** Target name.   */
    const char *pszName;
    /** The X11 atom for the target. */
    Atom        uAtom;
    /** The X11 atom name if uAtom must be termined dynamically. */
    const char *pszAtomName;
    /** Description. */
    const char *pszDesc;
} CLIPUTILTARGET;
/** Pointer to clipboard target descriptor. */
typedef CLIPUTILTARGET const *PCCLIPUTILTARGET;
#endif /* MULTI_TARGET_CLIPBOARD */


#ifdef RT_OS_OS2
/** Header for Odin32 specific clipboard entries.
 * (Used to get the correct size of the data.)
 */
typedef struct _Odin32ClipboardHeader
{
    /** Magic (CLIPHEADER_MAGIC) */
    char        achMagic[8];
    /** Size of the following data.
     * (The interpretation depends on the type.) */
    unsigned    cbData;
    /** Odin32 format number. */
    unsigned    uFormat;
} CLIPHEADER, *PCLIPHEADER;

#define CLIPHEADER_MAGIC "Odin\1\0\1"
#endif


/*********************************************************************************************************************************
*   Global Variables                                                                                                             *
*********************************************************************************************************************************/
/** Command line parameters */
static const RTGETOPTDEF g_aCmdOptions[] =
{
    { "--list",                     'l',                            RTGETOPT_REQ_NOTHING },
    { "--get",                      'g',                            RTGETOPT_REQ_STRING  },
    { "--get-file",                 'G',                            RTGETOPT_REQ_STRING  },
    { "--put",                      'p',                            RTGETOPT_REQ_STRING  },
    { "--put-file",                 'P',                            RTGETOPT_REQ_STRING  },
    { "--check",                    'c',                            RTGETOPT_REQ_STRING  },
    { "--check-file",               'C',                            RTGETOPT_REQ_STRING  },
    { "--check-not",                'n',                            RTGETOPT_REQ_STRING  },
    { "--zap",                      'z',                            RTGETOPT_REQ_NOTHING },
#ifdef MULTI_TARGET_CLIPBOARD
    { "--target",                   't',                            RTGETOPT_REQ_STRING  },
#endif
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
    { "--close",                    'k',                            RTGETOPT_REQ_NOTHING },
#endif
    { "--wait",                     'w',                            RTGETOPT_REQ_UINT32 },
    { "--quiet",                    'q',                            RTGETOPT_REQ_NOTHING },
    { "--verbose",                  'v',                            RTGETOPT_REQ_NOTHING },
    { "--version",                  'V',                            RTGETOPT_REQ_NOTHING },
    { "--help",                     'h',                            RTGETOPT_REQ_NOTHING }, /* for Usage() */
};

/** Format descriptors. */
static CLIPUTILFORMAT g_aFormats[] =
{
#if defined(RT_OS_WINDOWS)
    { "text/ansi",                  CF_TEXT, NULL,              "ANSI text", 0 },
    { "text/utf-16",                CF_UNICODETEXT, NULL,       "UTF-16 text", 0 },
    { "text/utf-8",                 CF_UNICODETEXT, NULL,       "UTF-8 text", CLIPUTILFORMAT_F_CONVERT_UTF8 },
    /* https://docs.microsoft.com/en-us/windows/desktop/dataxchg/html-clipboard-format */
    { "text/html",                  0, L"HTML Format",          "HTML text", 0 },
    { "bitmap",                     CF_DIB, NULL,               "Bitmap (DIB)", 0 },
    { "bitmap/v5",                  CF_DIBV5, NULL,             "Bitmap version 5 (DIBv5)", 0 },
#elif defined(RT_OS_OS2)
    { "text/ascii",                 CF_TEXT, NULL,              "ASCII text", 0 },
    { "text/utf-8",                 CF_TEXT, NULL,              "UTF-8 text", CLIPUTILFORMAT_F_CONVERT_UTF8 },
    { "text/utf-16",                0, "Odin32 UnicodeText",    "UTF-16 text", 0},
#elif defined(RT_OS_DARWIN)
    { "text/utf-8",                 kUTTypeUTF8PlainText,       "UTF-8 text", 0 },
    { "text/utf-16",                kUTTypeUTF16PlainText,      "UTF-16 text", 0 },
#else
    /** @todo X11   */
    { "text/utf-8",                 None, "UTF8_STRING",       "UTF-8 text", 0 },
#endif
};

#ifdef MULTI_TARGET_CLIPBOARD
/** Target descriptors. */
static CLIPUTILTARGET g_aTargets[] =
{
    { "clipboard", 0, "CLIPBOARD",     "XA_CLIPBOARD: The clipboard (default)" },
    { "primary",   XA_PRIMARY,   NULL, "XA_PRIMARY:   Primary selected text (middle mouse button)" },
    { "secondary", XA_SECONDARY, NULL, "XA_SECONDARY: Secondary selected text (with ctrl)" },
};

/** The current clipboard target. */
static CLIPUTILTARGET *g_pTarget = &g_aTargets[0];
#endif /* MULTI_TARGET_CLIPBOARD */

/** The -v/-q state. */
static unsigned g_uVerbosity = 1;

#ifdef RT_OS_DARWIN

#elif defined(RT_OS_OS2)
/** Anchorblock handle. */
static HAB      g_hOs2Ab = NULLHANDLE;
/** The message queue handle.   */
static HMQ      g_hOs2MsgQueue = NULLHANDLE;
/** Windows that becomes clipboard owner when setting data. */
static HWND     g_hOs2Wnd = NULLHANDLE;
/** Set if we've opened the clipboard. */
static bool     g_fOs2OpenedClipboard = false;
/** Set if we're the clipboard owner. */
static bool     g_fOs2ClipboardOwner = false;
/** Set when we receive a WM_TIMER message during DoWait(). */
static bool volatile g_fOs2TimerTicked = false;

#elif defined(RT_OS_WINDOWS)
/** Set if we've opened the clipboard. */
static bool     g_fWinOpenedClipboard = false;
/** Set when we receive a WM_TIMER message during DoWait(). */
static bool volatile g_fWinTimerTicked = false;
/** Window that becomes clipboard owner when setting data. */
static HWND     g_hWinWnd = NULL;

#else
/** Number of errors (incremented by error handle callback). */
static uint32_t volatile g_cX11Errors;
/** The X11 display. */
static Display *g_pX11Display = NULL;
/** The X11 dummy window.   */
static Window   g_hX11Window = 0;
/** TARGETS */
static Atom     g_uX11AtomTargets;
/** MULTIPLE */
static Atom     g_uX11AtomMultiple;

#endif


/**
 * Gets a format descriptor, complaining if invalid format.
 *
 * @returns Pointer to the descriptor if found, NULL + msg if not.
 * @param   pszFormat           The format to get.
 */
static PCCLIPUTILFORMAT GetFormatDesc(const char *pszFormat)
{
    for (size_t i = 0; i < RT_ELEMENTS(g_aFormats); i++)
        if (strcmp(pszFormat, g_aFormats[i].pszName) == 0)
        {
#if defined(RT_OS_DARWIN)
            /** @todo   */

#elif defined(RT_OS_OS2)
            if (g_aFormats[i].pszFormat && g_aFormats[i].fFormat == 0)
            {
                g_aFormats[i].fFormat = WinAddAtom(WinQuerySystemAtomTable(), g_aFormats[i].pszFormat);
                if (g_aFormats[i].fFormat == 0)
                    RTMsgError("WinAddAtom(,%s) failed: %#x", g_aFormats[i].pszFormat, WinGetLastError(g_hOs2Ab));
            }

#elif defined(RT_OS_WINDOWS)
            if (g_aFormats[i].pwszFormat && g_aFormats[i].fFormat == 0)
            {
                g_aFormats[i].fFormat = RegisterClipboardFormatW(g_aFormats[i].pwszFormat);
                if (g_aFormats[i].fFormat == 0)
                    RTMsgError("RegisterClipboardFormatW(%ls) failed: %u (%#x)",
                               g_aFormats[i].pwszFormat, GetLastError(), GetLastError());
            }
#elif defined(CU_X11)
            if (g_aFormats[i].pszAtomName && g_aFormats[i].uAtom == 0)
                g_aFormats[i].uAtom = XInternAtom(g_pX11Display, g_aFormats[i].pszAtomName, False);
#endif
            return &g_aFormats[i];
        }

    /*
     * Try register the format.
     */
    static CLIPUTILFORMAT AdHoc;
    AdHoc.pszName     = pszFormat;
    AdHoc.pszDesc     = pszFormat;
    AdHoc.fFlags      = CLIPUTILFORMAT_F_AD_HOC;
#ifdef RT_OS_DARWIN
/** @todo   */

#elif defined(RT_OS_OS2)
    AdHoc.pszFormat   = pszFormat;
    AdHoc.fFormat     = WinAddAtom(WinQuerySystemAtomTable(), pszFormat);
    if (AdHoc.fFormat == 0)
    {
        RTMsgError("Invalid format '%s' (%#x)", pszFormat, WinGetLastError(g_hOs2Ab));
        return NULL;
    }

#elif defined(RT_OS_WINDOWS)
    AdHoc.pwszFormat  = NULL;
    AdHoc.fFormat     = RegisterClipboardFormatA(pszFormat);
    if (AdHoc.fFormat == 0)
    {
        RTMsgError("RegisterClipboardFormatA(%s) failed: %u (%#x)", pszFormat, GetLastError(), GetLastError());
        return NULL;
    }

#else
    AdHoc.pszAtomName = pszFormat;
    AdHoc.uAtom       = XInternAtom(g_pX11Display, pszFormat, False);
    if (AdHoc.uAtom == None)
    {
        RTMsgError("Invalid format '%s' or out of memory for X11 atoms", pszFormat);
        return NULL;
    }

#endif
    return &AdHoc;
}


#ifdef RT_OS_DARWIN

/** @todo   */


#elif defined(RT_OS_OS2)

/**
 * The window procedure for the object window.
 *
 * @returns Message result.
 *
 * @param   hwnd    The window handle.
 * @param   msg     The message.
 * @param   mp1     Message parameter 1.
 * @param   mp2     Message parameter 2.
 */
static MRESULT EXPENTRY CuOs2WinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    if (g_uVerbosity > 2)
        RTMsgInfo("CuOs2WinProc: hwnd=%#lx msg=%#lx mp1=%#lx mp2=%#lx\n", hwnd, msg, mp1, mp2);

    switch (msg)
    {
        case WM_CREATE:
            return NULL; /* FALSE(/NULL) == Continue*/
        case WM_DESTROY:
            break;

        /*
         * Clipboard viewer message - the content has been changed.
         * This is sent *after* releasing the clipboard sem
         * and during the WinSetClipbrdViewer call.
         */
        case WM_DRAWCLIPBOARD:
            break;

        /*
         * Clipboard owner message - the content was replaced.
         * This is sent by someone with an open clipboard, so don't try open it now.
         */
        case WM_DESTROYCLIPBOARD:
            break;

        /*
         * Clipboard owner message - somebody is requesting us to render a format.
         * This is called by someone which owns the clipboard, but that's fine.
         */
        case WM_RENDERFMT:
            break;

        /*
         * Clipboard owner message - we're about to quit and should render all formats.
         */
        case WM_RENDERALLFMTS:
            break;

        /*
         * Clipboard owner messages dealing with owner drawn content.
         * We shouldn't be seeing any of these.
         */
        case WM_PAINTCLIPBOARD:
        case WM_SIZECLIPBOARD:
        case WM_HSCROLLCLIPBOARD:
        case WM_VSCROLLCLIPBOARD:
            AssertMsgFailed(("msg=%lx (%ld)\n", msg, msg));
            break;

        /*
         * We shouldn't be seeing any other messages according to the docs.
         * But for whatever reason, PM sends us a WM_ADJUSTWINDOWPOS message
         * during WinCreateWindow. So, ignore that and assert on anything else.
         */
        default:
            AssertMsgFailed(("msg=%lx (%ld)\n", msg, msg));
        case WM_ADJUSTWINDOWPOS:
            break;

        /*
         * We use this window fielding WM_TIMER during DoWait.
         */
        case WM_TIMER:
            if (SHORT1FROMMP(mp1) == 1)
                g_fOs2TimerTicked = true;
            break;
    }
    return NULL;
}


/**
 * Initialize the OS/2 bits.
 */
static RTEXITCODE CuOs2Init(void)
{
    g_hOs2Ab = WinInitialize(0);
    if (g_hOs2Ab == NULLHANDLE)
        return RTMsgErrorExitFailure("WinInitialize failed!");

    g_hOs2MsgQueue = WinCreateMsgQueue(g_hOs2Ab, 10);
    if (g_hOs2MsgQueue == NULLHANDLE)
        return RTMsgErrorExitFailure("WinCreateMsgQueue failed: %#x", WinGetLastError(g_hOs2Ab));

    static char s_szClass[] = "VBox-ClipUtilClipboardClass";
    if (!WinRegisterClass(g_hOs2Wnd, (PCSZ)s_szClass, CuOs2WinProc, 0, 0))
        return RTMsgErrorExitFailure("WinRegisterClass failed: %#x", WinGetLastError(g_hOs2Ab));

    g_hOs2Wnd = WinCreateWindow(HWND_OBJECT,                             /* hwndParent */
                                (PCSZ)s_szClass,                         /* pszClass */
                                (PCSZ)"VirtualBox Clipboard Utility",    /* pszName */
                                0,                                       /* flStyle */
                                0, 0, 0, 0,                              /* x, y, cx, cy */
                                NULLHANDLE,                              /* hwndOwner */
                                HWND_BOTTOM,                             /* hwndInsertBehind */
                                42,                                      /* id */
                                NULL,                                    /* pCtlData */
                                NULL);                                   /* pPresParams */
    if (g_hOs2Wnd == NULLHANDLE)
        return RTMsgErrorExitFailure("WinCreateWindow failed: %#x", WinGetLastError(g_hOs2Ab));

    return RTEXITCODE_SUCCESS;
}


/**
 * Terminates the OS/2 bits.
 */
static RTEXITCODE CuOs2Term(void)
{
    if (g_fOs2OpenedClipboard)
    {
        if (!WinCloseClipbrd(g_hOs2Ab))
            return RTMsgErrorExitFailure("WinCloseClipbrd failed: %#x", WinGetLastError(g_hOs2Ab));
        g_fOs2OpenedClipboard = false;
    }

    WinDestroyWindow(g_hOs2Wnd);
    g_hOs2Wnd = NULLHANDLE;

    WinDestroyMsgQueue(g_hOs2MsgQueue);
    g_hOs2MsgQueue = NULLHANDLE;

    WinTerminate(g_hOs2Ab);
    g_hOs2Ab = NULLHANDLE;

    return RTEXITCODE_SUCCESS;
}


/**
 * Opens the OS/2 clipboard.
 */
static RTEXITCODE CuOs2OpenClipboardIfNecessary(void)
{
    if (g_fOs2OpenedClipboard)
        return RTEXITCODE_SUCCESS;
    if (WinOpenClipbrd(g_hOs2Ab))
    {
        if (g_uVerbosity > 0)
            RTMsgInfo("Opened the clipboard\n");
        g_fOs2OpenedClipboard = true;
        return RTEXITCODE_SUCCESS;
    }
    return RTMsgErrorExitFailure("WinOpenClipbrd failed: %#x", WinGetLastError(g_hOs2Ab));
}


#elif defined(RT_OS_WINDOWS)

/**
 * Window procedure for the clipboard owner window on Windows.
 */
static LRESULT CALLBACK CuWinWndProc(HWND hWnd, UINT idMsg, WPARAM wParam, LPARAM lParam) RT_NOTHROW_DEF
{
    if (g_uVerbosity > 2)
        RTMsgInfo("CuWinWndProc: hWnd=%p idMsg=%#05x wParam=%#zx lParam=%#zx\n", hWnd, idMsg, wParam, lParam);

    switch (idMsg)
    {
        case WM_TIMER:
            if (wParam == 1)
                g_fWinTimerTicked = true;
            break;
    }
    return DefWindowProc(hWnd, idMsg, wParam, lParam);
}


/**
 * Initialize the Windows bits.
 */
static RTEXITCODE CuWinInit(void)
{
    /* Register the window class: */
    static wchar_t s_wszClass[] = L"VBox-ClipUtilClipboardClass";
    WNDCLASSW WndCls = {0};
    WndCls.style            = CS_NOCLOSE;
    WndCls.lpfnWndProc      = CuWinWndProc;
    WndCls.cbClsExtra       = 0;
    WndCls.cbWndExtra       = 0;
    WndCls.hInstance        = (HINSTANCE)GetModuleHandle(NULL);
    WndCls.hIcon            = NULL;
    WndCls.hCursor          = NULL;
    WndCls.hbrBackground    = (HBRUSH)(COLOR_BACKGROUND + 1);
    WndCls.lpszMenuName     = NULL;
    WndCls.lpszClassName    = s_wszClass;

    ATOM uAtomWndClass      = RegisterClassW(&WndCls);
    if (!uAtomWndClass)
        return RTMsgErrorExitFailure("RegisterClassW failed: %u (%#x)", GetLastError(), GetLastError());

    /* Create the clipboard owner window: */
    g_hWinWnd = CreateWindowExW(WS_EX_TRANSPARENT,                      /* fExStyle */
                                s_wszClass,                             /* pwszClass */
                                L"VirtualBox Clipboard Utility",        /* pwszName */
                                0,                                      /* fStyle */
                                0, 0, 0, 0,                             /* x, y, cx, cy */
                                HWND_MESSAGE,                           /* hWndParent */
                                NULL,                                   /* hMenu */
                                (HINSTANCE)GetModuleHandle(NULL),       /* hinstance */
                                NULL);                                  /* pParam */
    if (g_hWinWnd == NULL)
        return RTMsgErrorExitFailure("CreateWindowExW failed: %u (%#x)", GetLastError(), GetLastError());

    return RTEXITCODE_SUCCESS;
}

/**
 * Terminates the Windows bits.
 */
static RTEXITCODE CuWinTerm(void)
{
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
    if (g_fWinOpenedClipboard)
    {
        if (CloseClipboard())
            g_fWinOpenedClipboard = false;
        else
            rcExit = RTMsgErrorExitFailure("CloseClipboard failed: %u (%#x)", GetLastError(), GetLastError());
    }

    if (g_hWinWnd != NULL)
    {
        if (!DestroyWindow(g_hWinWnd))
            rcExit = RTMsgErrorExitFailure("DestroyWindow failed: %u (%#x)", GetLastError(), GetLastError());
        g_hWinWnd = NULL;
    }

    return rcExit;
}


/**
 * Opens the window clipboard.
 */
static RTEXITCODE WinOpenClipboardIfNecessary(void)
{
    if (g_fWinOpenedClipboard)
        return RTEXITCODE_SUCCESS;
    if (OpenClipboard(g_hWinWnd))
    {
        if (g_uVerbosity > 0)
            RTMsgInfo("Opened the clipboard\n");
        g_fWinOpenedClipboard = true;
        return RTEXITCODE_SUCCESS;
    }
    return RTMsgErrorExitFailure("OpenClipboard failed: %u (%#x)", GetLastError(), GetLastError());
}


#else /* X11: */

/**
 * Error handler callback.
 */
static int CuX11ErrorCallback(Display *pX11Display, XErrorEvent *pErrEvt)
{
    g_cX11Errors++;
    char szErr[2048];
    XGetErrorText(pX11Display, pErrEvt->error_code, szErr, sizeof(szErr));
    RTMsgError("An X Window protocol error occurred: %s\n"
               "  Request code: %u\n"
               "  Minor code:   %u\n"
               "  Serial number of the failed request: %u\n",
               szErr, pErrEvt->request_code, pErrEvt->minor_code, pErrEvt->serial);
    return 0;
}


/**
 * Initialize the X11 bits.
 */
static RTEXITCODE CuX11Init(void)
{
    /*
     * Open the X11 display and create a little dummy window.
     */
    XSetErrorHandler(CuX11ErrorCallback);
    g_pX11Display = XOpenDisplay(NULL);
    if (!g_pX11Display)
        return RTMsgErrorExitFailure("XOpenDisplay failed");

    int const iDefaultScreen = DefaultScreen(g_pX11Display);
    g_hX11Window = XCreateSimpleWindow(g_pX11Display,
                                       RootWindow(g_pX11Display, iDefaultScreen),
                                       0 /*x*/, 0 /*y*/,
                                       1 /*cx*/, 1 /*cy*/,
                                       0 /*cPxlBorder*/,
                                       BlackPixel(g_pX11Display, iDefaultScreen) /*Border*/,
                                       WhitePixel(g_pX11Display, iDefaultScreen) /*Background*/);

    /*
     * Resolve any unknown atom values we might need later.
     */
    for (size_t i = 0; i < RT_ELEMENTS(g_aTargets); i++)
        if (g_aTargets[i].pszAtomName)
        {
            g_aTargets[i].uAtom = XInternAtom(g_pX11Display, g_aTargets[i].pszAtomName, False);
            if (g_uVerbosity > 2)
                RTPrintf("target %s atom=%#x\n", g_aTargets[i].pszName, g_aTargets[i].uAtom);
        }

    g_uX11AtomTargets = XInternAtom(g_pX11Display, "TARGETS", False);
    g_uX11AtomMultiple = XInternAtom(g_pX11Display, "MULTIPLE", False);

    return RTEXITCODE_SUCCESS;
}

#endif /* X11 */


#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
/**
 * Closes the clipboard if open.
 */
static RTEXITCODE CuCloseClipboard(void)
{
# if defined(RT_OS_OS2)
    if (g_fOs2OpenedClipboard)
    {
        if (!WinCloseClipbrd(g_hOs2Ab))
            return RTMsgErrorExitFailure("WinCloseClipbrd failed: %#x", WinGetLastError(g_hOs2Ab));
        g_fOs2OpenedClipboard = false;
        if (g_uVerbosity > 0)
            RTMsgInfo("Closed the clipboard.\n");
    }
# else
    if (g_fWinOpenedClipboard)
    {
        if (!CloseClipboard())
            return RTMsgErrorExitFailure("CloseClipboard failed: %u (%#x)", GetLastError(), GetLastError());
        g_fWinOpenedClipboard = false;
        if (g_uVerbosity > 0)
            RTMsgInfo("Closed the clipboard.\n");
    }
# endif
    else if (g_uVerbosity > 0)
        RTMsgInfo("No need to close clipboard, not opened.\n");

    return RTEXITCODE_SUCCESS;
}
#endif /* RT_OS_OS2 || RT_OS_WINDOWS */


/**
 * Lists the clipboard format.
 */
static RTEXITCODE ListClipboardContent(void)
{
#if defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2OpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        HATOMTBL const hAtomTbl  = WinQuerySystemAtomTable();
        uint32_t       idx       = 0;
        ULONG          fFormat   = 0;
        while ((fFormat = WinEnumClipbrdFmts(g_hOs2Ab)) != 0)
        {
            char szName[256] = {0};
            ULONG cchRet = WinQueryAtomName(hAtomTbl, fFormat, szName, sizeof(szName));
            if (cchRet != 0)
                RTPrintf("#%02u: %#06x - %s\n", idx, fFormat, szName);
            else
            {
                const char *pszName = NULL;
                switch (fFormat)
                {
                    case CF_TEXT: pszName = "CF_TEXT"; break;
                    case CF_BITMAP: pszName = "CF_BITMAP"; break;
                    case CF_DSPTEXT: pszName = "CF_DSPTEXT"; break;
                    case CF_DSPBITMAP: pszName = "CF_DSPBITMAP"; break;
                    case CF_METAFILE: pszName = "CF_METAFILE"; break;
                    case CF_DSPMETAFILE: pszName = "CF_DSPMETAFILE"; break;
                    case CF_PALETTE: pszName = "CF_PALETTE"; break;
                    default:
                        break;
                }
                if (pszName)
                    RTPrintf("#%02u: %#06x - %s\n", idx, fFormat, pszName);
                else
                    RTPrintf("#%02u: %#06x\n", idx, fFormat);
            }

            idx++;
        }
    }

    return rcExit;

#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = WinOpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        SetLastError(0);
        uint32_t idx     = 0;
        UINT     fFormat = 0;
        while ((fFormat = EnumClipboardFormats(fFormat)) != 0)
        {
            WCHAR wszName[256];
            int   cchName = GetClipboardFormatNameW(fFormat, wszName, RT_ELEMENTS(wszName));
            if (cchName > 0)
                RTPrintf("#%02u: %#06x - %ls\n", idx, fFormat, wszName);
            else
            {
                const char *pszName = NULL;
                switch (fFormat)
                {
                    case CF_TEXT: pszName = "CF_TEXT"; break;
                    case CF_BITMAP: pszName = "CF_BITMAP"; break;
                    case CF_METAFILEPICT: pszName = "CF_METAFILEPICT"; break;
                    case CF_SYLK: pszName = "CF_SYLK"; break;
                    case CF_DIF: pszName = "CF_DIF"; break;
                    case CF_TIFF: pszName = "CF_TIFF"; break;
                    case CF_OEMTEXT: pszName = "CF_OEMTEXT"; break;
                    case CF_DIB: pszName = "CF_DIB"; break;
                    case CF_PALETTE: pszName = "CF_PALETTE"; break;
                    case CF_PENDATA: pszName = "CF_PENDATA"; break;
                    case CF_RIFF: pszName = "CF_RIFF"; break;
                    case CF_WAVE: pszName = "CF_WAVE"; break;
                    case CF_UNICODETEXT: pszName = "CF_UNICODETEXT"; break;
                    case CF_ENHMETAFILE: pszName = "CF_ENHMETAFILE"; break;
                    case CF_HDROP: pszName = "CF_HDROP"; break;
                    case CF_LOCALE: pszName = "CF_LOCALE"; break;
                    case CF_DIBV5: pszName = "CF_DIBV5"; break;
                    default:
                        break;
                }
                if (pszName)
                    RTPrintf("#%02u: %#06x - %s\n", idx, fFormat, pszName);
                else
                    RTPrintf("#%02u: %#06x\n", idx, fFormat);
            }

            idx++;
        }
        if (idx == 0)
            RTPrintf("Empty\n");
    }
    return rcExit;

#elif defined(CU_X11)
    /* Request the TARGETS property: */
    Atom uAtomDst = g_uX11AtomTargets;
    int rc = XConvertSelection(g_pX11Display, g_pTarget->uAtom, g_uX11AtomTargets, uAtomDst, g_hX11Window, CurrentTime);
    if (g_uVerbosity > 1)
        RTPrintf("XConvertSelection -> %d\n", rc);

    /* Wait for the reply: */
    for (;;)
    {
        XEvent Evt = {0};
        rc = XNextEvent(g_pX11Display, &Evt);
        if (Evt.type == SelectionNotify)
        {
            if (g_uVerbosity > 1)
                RTPrintf("XNextEvent -> %d; type=SelectionNotify\n", rc);
            if (Evt.xselection.selection == g_pTarget->uAtom)
            {
                if (Evt.xselection.property == None)
                    return RTMsgErrorExitFailure("XConvertSelection(,%s,TARGETS,) failed", g_pTarget->pszName);

                /* Get the TARGETS property data: */
                Atom            uAtomRetType = 0;
                int             iActualFmt   = 0;
                unsigned long   cbLeftToRead = 0;
                unsigned long   cItems       = 0;
                unsigned char  *pbData       = NULL;
                rc = XGetWindowProperty(g_pX11Display, g_hX11Window, uAtomDst,
                                        0 /*offset*/, sizeof(Atom) * 4096 /* should be enough */, True /*fDelete*/, XA_ATOM,
                                        &uAtomRetType, &iActualFmt, &cItems, &cbLeftToRead, &pbData);
                if (g_uVerbosity > 1)
                    RTPrintf("XConvertSelection -> %d; uAtomRetType=%u iActualFmt=%d cItems=%lu cbLeftToRead=%lu pbData=%p\n",
                             rc, uAtomRetType, iActualFmt, cItems, cbLeftToRead, pbData);
                if (pbData && cItems > 0)
                {
                    /* Display the TARGETS: */
                    Atom const *paTargets = (Atom const *)pbData;
                    for (unsigned long i = 0; i < cItems; i++)
                    {
                        const char *pszName = XGetAtomName(g_pX11Display, paTargets[i]);
                        if (pszName)
                            RTPrintf("#%02u: %#06x - %s\n", i, paTargets[i], pszName);
                        else
                            RTPrintf("#%02u: %#06x\n", i, paTargets[i]);
                    }
                }
                else
                    RTMsgInfo("Empty");
                if (pbData)
                    XFree(pbData);
                return RTEXITCODE_SUCCESS;
            }
        }
        else if (g_uVerbosity > 1)
            RTPrintf("XNextEvent -> %d; type=%d\n", rc, Evt.type);
    }

#else
    return RTMsgErrorExitFailure("ListClipboardContent is not implemented");
#endif
}


/**
 * Reads the given clipboard format and stores it in on the heap.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to get.
 * @param   ppvData     Where to return the pointer to the data. Free using
 *                      RTMemFree when done.
 * @param   pcbData     Where to return the amount of data returned.
 */
static RTEXITCODE ReadClipboardData(PCCLIPUTILFORMAT pFmtDesc, void **ppvData, size_t *pcbData)
{
    *ppvData = NULL;
    *pcbData = 0;

#if defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2OpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        ULONG fFmtInfo = 0;
        if (WinQueryClipbrdFmtInfo(g_hOs2Ab, pFmtDesc->fFormat, &fFmtInfo))
        {
            ULONG uData = WinQueryClipbrdData(g_hOs2Ab, pFmtDesc->fFormat);
            if (fFmtInfo & CFI_POINTER)
            {
                PCLIPHEADER pOdinHdr = (PCLIPHEADER)uData;
                if (pFmtDesc->fFormat == CF_TEXT)
                {
                    if (pFmtDesc->fFlags & CLIPUTILFORMAT_F_CONVERT_UTF8)
                    {
                        char *pszUtf8 = NULL;
                        int rc = RTStrCurrentCPToUtf8(&pszUtf8, (const char *)uData);
                        if (RT_SUCCESS(rc))
                        {
                            *pcbData = strlen(pszUtf8) + 1;
                            *ppvData = RTMemDup(pszUtf8, *pcbData);
                            RTStrFree(pszUtf8);
                        }
                        else
                            return RTMsgErrorExitFailure("RTStrCurrentCPToUtf8 failed: %Rrc", rc);
                    }
                    else
                    {
                        *pcbData = strlen((const char *)uData) + 1;
                        *ppvData = RTMemDup((const char *)uData, *pcbData);
                    }
                }
                else if (   strcmp(pFmtDesc->pszFormat, "Odin32 UnicodeText") == 0
                         && memcmp(pOdinHdr->achMagic, CLIPHEADER_MAGIC, sizeof(pOdinHdr->achMagic)) == 0)
                {
                    *pcbData = pOdinHdr->cbData;
                    *ppvData = RTMemDup(pOdinHdr + 1, pOdinHdr->cbData);
                }
                else
                {
                    /* We could use DosQueryMem here to figure out the size of the allocation... */
                    *pcbData = PAGE_SIZE - (uData & PAGE_OFFSET_MASK);
                    *ppvData = RTMemDup((void const *)uData, *pcbData);
                }
            }
            else
            {
                *pcbData = sizeof(uData);
                *ppvData = RTMemDup(&uData, sizeof(uData));
            }
            if (!*ppvData)
                rcExit = RTMsgErrorExitFailure("Out of memory allocating %#zx bytes.", *pcbData);
        }
        else
            rcExit = RTMsgErrorExitFailure("WinQueryClipbrdFmtInfo(,%s,) failed: %#x\n",
                                           pFmtDesc->pszName, WinGetLastError(g_hOs2Ab));
    }
    return rcExit;

#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = WinOpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        HANDLE hData = GetClipboardData(pFmtDesc->fFormat);
        if (hData != NULL)
        {
            SIZE_T const cbData = GlobalSize(hData);
            PVOID  const pvData = GlobalLock(hData);
            if (pvData != NULL)
            {
                *pcbData = cbData;
                if (cbData != 0)
                {
                    if (pFmtDesc->fFlags & CLIPUTILFORMAT_F_CONVERT_UTF8)
                    {
                        char  *pszUtf8 = NULL;
                        size_t cchUtf8 = 0;
                        int rc = RTUtf16ToUtf8Ex((PCRTUTF16)pvData, cbData / sizeof(RTUTF16), &pszUtf8, 0, &cchUtf8);
                        if (RT_SUCCESS(rc))
                        {
                            *pcbData = cchUtf8 + 1;
                            *ppvData = RTMemDup(pszUtf8, cchUtf8 + 1);
                            RTStrFree(pszUtf8);
                            if (!*ppvData)
                                rcExit = RTMsgErrorExitFailure("Out of memory allocating %#zx bytes.", cbData);
                        }
                        else
                            rcExit = RTMsgErrorExitFailure("RTUtf16ToUtf8Ex failed: %Rrc", rc);
                    }
                    else
                    {
                        *ppvData = RTMemDup(pvData, cbData);
                        if (!*ppvData)
                            rcExit = RTMsgErrorExitFailure("Out of memory allocating %#zx bytes.", cbData);
                    }
                }
                GlobalUnlock(hData);
            }
            else
                rcExit = RTMsgErrorExitFailure("GetClipboardData(%s) failed: %u (%#x)\n",
                                               pFmtDesc->pszName, GetLastError(), GetLastError());
        }
        else
            rcExit = RTMsgErrorExitFailure("GetClipboardData(%s) failed: %u (%#x)\n",
                                           pFmtDesc->pszName, GetLastError(), GetLastError());
    }
    return rcExit;

#elif defined(CU_X11)

    /* Request the data: */
    Atom const uAtomDst = pFmtDesc->uAtom;
    int rc = XConvertSelection(g_pX11Display, g_pTarget->uAtom, pFmtDesc->uAtom, uAtomDst, g_hX11Window, CurrentTime);
    if (g_uVerbosity > 1)
        RTPrintf("XConvertSelection -> %d\n", rc);

    /* Wait for the reply: */
    for (;;)
    {
        XEvent Evt = {0};
        rc = XNextEvent(g_pX11Display, &Evt);
        if (Evt.type == SelectionNotify)
        {
            if (g_uVerbosity > 1)
                RTPrintf("XNextEvent -> %d; type=SelectionNotify\n", rc);
            if (Evt.xselection.selection == g_pTarget->uAtom)
            {
                if (Evt.xselection.property == None)
                    return RTMsgErrorExitFailure("XConvertSelection(,%s,%s,) failed", g_pTarget->pszName, pFmtDesc->pszName);

                /*
                 * Retrieve the data.
                 */
                Atom            uAtomRetType   = 0;
                int             cBitsActualFmt = 0;
                unsigned long   cbLeftToRead   = 0;
                unsigned long   cItems         = 0;
                unsigned char  *pbData         = NULL;
                rc = XGetWindowProperty(g_pX11Display, g_hX11Window, uAtomDst,
                                        0 /*offset*/, _64M, False/*fDelete*/, AnyPropertyType,
                                        &uAtomRetType, &cBitsActualFmt, &cItems, &cbLeftToRead, &pbData);
                if (g_uVerbosity > 1)
                    RTPrintf("XConvertSelection -> %d; uAtomRetType=%u cBitsActualFmt=%d cItems=%lu cbLeftToRead=%lu pbData=%p\n",
                             rc, uAtomRetType, cBitsActualFmt, cItems, cbLeftToRead, pbData);
                RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
                if (pbData && cItems > 0)
                {
                    *pcbData = cItems * (cBitsActualFmt / 8);
                    *ppvData = RTMemDup(pbData, *pcbData);
                    if (!*ppvData)
                        rcExit = RTMsgErrorExitFailure("Out of memory allocating %#zx bytes.", *pcbData);
                }
                if (pbData)
                    XFree(pbData);
                XDeleteProperty(g_pX11Display, g_hX11Window, uAtomDst);
                return rcExit;
            }
        }
        else if (g_uVerbosity > 1)
            RTPrintf("XNextEvent -> %d; type=%d\n", rc, Evt.type);
    }

#else
    RT_NOREF(pFmtDesc);
    return RTMsgErrorExitFailure("ReadClipboardData is not implemented\n");
#endif
}


/**
 * Puts the given data and format on the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc     The format.
 * @param   pvData       The data.
 * @param   cbData       The amount of data in bytes.
 */
static RTEXITCODE WriteClipboardData(PCCLIPUTILFORMAT pFmtDesc, void const *pvData, size_t cbData)
{
#if defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2OpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        /** @todo do we need to become owner? */

        /* Convert to local code page if needed: */
        char *pszLocale = NULL;
        if (pFmtDesc->fFlags & CLIPUTILFORMAT_F_CONVERT_UTF8)
        {
            int rc = RTStrUtf8ToCurrentCPEx(&pszLocale, (char *)pvData, cbData);
            if (RT_SUCCESS(rc))
            {
                pvData = pszLocale;
                cbData = strlen(pszLocale) + 1;
            }
            else
                return RTMsgErrorExitFailure("RTStrUtf8ToCurrentCPEx failed: %Rrc\n", rc);
        }

        /* Allocate a bunch of shared memory for the object. */
        PVOID  pvShared = NULL;
        APIRET orc = DosAllocSharedMem(&pvShared, NULL, cbData,
                                       OBJ_GIVEABLE | OBJ_GETTABLE | OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
        if (orc == NO_ERROR)
        {
            memcpy(pvShared, pvData, cbData);

            if (WinSetClipbrdData(g_hOs2Ab, (uintptr_t)pvShared, pFmtDesc->fFormat, CFI_POINTER))
            {
                if (g_uVerbosity > 0)
                    RTMsgInfo("Put '%s' on the clipboard: %p LB %zu\n", pFmtDesc->pszName, pvShared, cbData);
                rcExit = RTEXITCODE_SUCCESS;
            }
            else
            {
                rcExit = RTMsgErrorExitFailure("WinSetClipbrdData(,%p LB %#x,%s,) failed: %#x\n",
                                               pvShared, cbData, pFmtDesc->pszName, WinGetLastError(g_hOs2Ab));
                DosFreeMem(pvShared);
            }
        }
        else
            rcExit = RTMsgErrorExitFailure("DosAllocSharedMem(,, %#x,) -> %u", cbData, orc);
        RTStrFree(pszLocale);
    }
    return rcExit;


#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = WinOpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        /*
         * Do input data conversion.
         */
        PRTUTF16 pwszFree = NULL;
        if (pFmtDesc->fFlags & CLIPUTILFORMAT_F_CONVERT_UTF8)
        {
            size_t cwcConv = 0;
            int rc = RTStrToUtf16Ex((char const *)pvData, cbData, &pwszFree, 0, &cwcConv);
            if (RT_SUCCESS(rc))
            {
                pvData = pwszFree;
                cbData = cwcConv * sizeof(RTUTF16);
            }
            else
                return RTMsgErrorExitFailure("RTStrToTUtf16Ex failed: %Rrc\n", rc);
        }

        /*
         * Text formats generally include the zero terminator.
         */
        uint32_t cbZeroPadding = 0;
        if (pFmtDesc->fFormat == CF_UNICODETEXT)
            cbZeroPadding = sizeof(WCHAR);
        else if (pFmtDesc->fFormat == CF_TEXT)
            cbZeroPadding = sizeof(char);

        HANDLE hDstData = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, cbData + cbZeroPadding);
        if (hDstData)
        {
            if (cbData)
            {
                PVOID pvDstData = GlobalLock(hDstData);
                if (pvDstData)
                    memcpy(pvDstData, pvData, cbData);
                else
                    rcExit = RTMsgErrorExitFailure("GlobalLock failed: %u (%#x)\n", GetLastError(), GetLastError());
            }
            if (rcExit == RTEXITCODE_SUCCESS)
            {
                if (SetClipboardData(pFmtDesc->fFormat, hDstData))
                {
                    if (g_uVerbosity > 0)
                        RTMsgInfo("Put '%s' on the clipboard: %p LB %zu\n", pFmtDesc->pszName, hDstData, cbData + cbZeroPadding);
                }
                else
                {
                    rcExit = RTMsgErrorExitFailure("SetClipboardData(%s) failed: %u (%#x)\n",
                                                   pFmtDesc->pszName, GetLastError(), GetLastError());
                    GlobalFree(hDstData);
                }
            }
            else
                GlobalFree(hDstData);
        }
        else
            rcExit = RTMsgErrorExitFailure("GlobalAlloc(,%#zx) failed: %u (%#x)\n",
                                           cbData + cbZeroPadding, GetLastError(), GetLastError());
    }
    return rcExit;

#else
    RT_NOREF(pFmtDesc, pvData, cbData);
    return RTMsgErrorExitFailure("WriteClipboardData is not implemented\n");
#endif
}


/**
 * Check if the given data + format matches what's actually on the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to compare.
 * @param   pvExpect    The expected clipboard data.
 * @param   cbExpect    The size of the expected clipboard data.
 */
static RTEXITCODE CompareDataWithClipboard(PCCLIPUTILFORMAT pFmtDesc, void const *pvExpect, size_t cbExpect)
{
    void      *pvData = NULL;
    size_t     cbData = 0;
    RTEXITCODE rcExit = ReadClipboardData(pFmtDesc, &pvData, &cbData);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        if (   cbData == cbExpect
            && memcmp(pvData, pvExpect, cbData) == 0)
            rcExit = RTEXITCODE_SUCCESS;
        else
            rcExit = RTMsgErrorExitFailure("Mismatch for '%s' (cbData=%#zx cbExpect=%#zx)\n",
                                           pFmtDesc->pszName, cbData, cbExpect);
        RTMemFree(pvData);
    }
    return rcExit;
}


/**
 * Gets the given clipboard format.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to get.
 * @param   pStrmOut    Where to output the data.
 * @param   fIsStdOut   Set if @a pStrmOut is standard output, clear if not.
 */
static RTEXITCODE ClipboardContentToStdOut(PCCLIPUTILFORMAT pFmtDesc)
{
    void      *pvData = NULL;
    size_t     cbData = 0;
    RTEXITCODE rcExit = ReadClipboardData(pFmtDesc, &pvData, &cbData);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        int rc = RTStrmWrite(g_pStdOut, pvData, cbData);
        RTMemFree(pvData);
        if (RT_FAILURE(rc))
            rcExit = RTMsgErrorExitFailure("Error writing %#zx bytes to standard output: %Rrc", cbData, rc);
    }
    return rcExit;
}


/**
 * Gets the given clipboard format.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to get.
 * @param   pszFilename The output filename.
 */
static RTEXITCODE ClipboardContentToFile(PCCLIPUTILFORMAT pFmtDesc, const char *pszFilename)
{
    void      *pvData = NULL;
    size_t     cbData = 0;
    RTEXITCODE rcExit = ReadClipboardData(pFmtDesc, &pvData, &cbData);
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        RTFILE hFile = NIL_RTFILE;
        int rc = RTFileOpen(&hFile, pszFilename,
                            RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE
                            | (0770 << RTFILE_O_CREATE_MODE_SHIFT));
        if (RT_SUCCESS(rc))
        {
            rc = RTFileWrite(hFile, pvData, cbData, NULL);
            int const rc2 = RTFileClose(hFile);
            if (RT_FAILURE(rc) || RT_FAILURE(rc2))
            {
                if (RT_FAILURE_NP(rc))
                    RTMsgError("Writing %#z bytes to '%s' failed: %Rrc", cbData, pszFilename, rc);
                else
                    RTMsgError("Closing '%s' failed: %Rrc", pszFilename, rc2);
                RTMsgInfo("Deleting '%s'.", pszFilename);
                RTFileDelete(pszFilename);
                rcExit = RTEXITCODE_FAILURE;
            }
        }
        else
            rcExit = RTMsgErrorExitFailure("Failed to open '%s' for writing: %Rrc", pszFilename, rc);
        RTMemFree(pvData);
    }
    return rcExit;
}


/**
 * Puts the given format + data onto the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to put.
 * @param   pszData     The string data.
 */
static RTEXITCODE PutStringOnClipboard(PCCLIPUTILFORMAT pFmtDesc, const char *pszData)
{
    return WriteClipboardData(pFmtDesc, pszData, strlen(pszData));
}


/**
 * Puts a format + file content onto the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to put.
 * @param   pszFilename The filename.
 */
static RTEXITCODE PutFileOnClipboard(PCCLIPUTILFORMAT pFmtDesc, const char *pszFilename)
{
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
    void      *pvData = NULL;
    size_t     cbData = 0;
    int rc = RTFileReadAll(pszFilename, &pvData, &cbData);
    if (RT_SUCCESS(rc))
    {
        rcExit = WriteClipboardData(pFmtDesc, pvData, cbData);
        RTFileReadAllFree(pvData, cbData);
    }
    else
        rcExit = RTMsgErrorExitFailure("Failed to open and read '%s' into memory: %Rrc", pszFilename, rc);
    return rcExit;
}


/**
 * Checks if the given format + data matches what's on the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to check.
 * @param   pszData     The string data.
 */
static RTEXITCODE CheckStringAgainstClipboard(PCCLIPUTILFORMAT pFmtDesc, const char *pszData)
{
    return CompareDataWithClipboard(pFmtDesc, pszData, strlen(pszData));
}


/**
 * Check if the given format + file content matches what's on the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to check.
 * @param   pszFilename The filename.
 */
static RTEXITCODE CheckFileAgainstClipboard(PCCLIPUTILFORMAT pFmtDesc, const char *pszFilename)
{
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
    void      *pvData = NULL;
    size_t     cbData = 0;
    int rc = RTFileReadAll(pszFilename, &pvData, &cbData);
    if (RT_SUCCESS(rc))
    {
        rcExit = CompareDataWithClipboard(pFmtDesc, pvData, cbData);
        RTFileReadAllFree(pvData, cbData);
    }
    else
        rcExit = RTMsgErrorExitFailure("Failed to open and read '%s' into memory: %Rrc", pszFilename, rc);
    return rcExit;
}


/**
 * Check that the given format is not on the clipboard.
 *
 * @returns Success indicator.
 * @param   pFmtDesc    The format to check.
 */
static RTEXITCODE CheckFormatNotOnClipboard(PCCLIPUTILFORMAT pFmtDesc)
{
#if defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2OpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        ULONG fFmtInfo = 0;
        if (WinQueryClipbrdFmtInfo(g_hOs2Ab, pFmtDesc->fFormat, &fFmtInfo))
            rcExit = RTMsgErrorExitFailure("Format '%s' is present");
    }
    return rcExit;

#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = WinOpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        if (IsClipboardFormatAvailable(pFmtDesc->fFormat))
            rcExit = RTMsgErrorExitFailure("Format '%s' is present");
    }
    return rcExit;

#else
    RT_NOREF(pFmtDesc);
    return RTMsgErrorExitFailure("CheckFormatNotOnClipboard is not implemented");
#endif
}


/**
 * Empties the clipboard.
 *
 * @returns Success indicator.
 */
static RTEXITCODE ZapAllClipboardData(void)
{
#if defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2OpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        ULONG fFmtInfo = 0;
        if (WinEmptyClipbrd(g_hOs2Ab))
        {
            WinSetClipbrdOwner(g_hOs2Ab, g_hOs2Wnd); /* Probably unnecessary? */
            WinSetClipbrdOwner(g_hOs2Ab, NULLHANDLE);
            g_fOs2ClipboardOwner = false;
        }
        else
            rcExit = RTMsgErrorExitFailure("WinEmptyClipbrd() failed: %#x\n", WinGetLastError(g_hOs2Ab));
    }
    return rcExit;

#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = WinOpenClipboardIfNecessary();
    if (rcExit == RTEXITCODE_SUCCESS)
    {
        if (!EmptyClipboard())
            rcExit = RTMsgErrorExitFailure("EmptyClipboard() failed: %u (%#x)\n", GetLastError(), GetLastError());
    }
    return rcExit;

#else
    return RTMsgErrorExitFailure("ZapAllClipboardData is not implemented");
#endif
}


/**
 * Waits/delays at least @a cMsWait milliseconds.
 *
 * @returns Success indicator.
 * @param   cMsWait     Minimum wait/delay time in milliseconds.
 */
static RTEXITCODE DoWait(uint32_t cMsWait)
{
    uint64_t const msStart = RTTimeMilliTS();
    if (g_uVerbosity > 1)
        RTMsgInfo("Waiting %u ms...\n", cMsWait);

#if defined(RT_OS_OS2)
    /*
     * Arm a timer which will timeout after the desired period and
     * quit when we've dispatched it.
     */
    g_fOs2TimerTicked = false;
    if (WinStartTimer(g_hOs2Ab, g_hOs2Wnd, 1 /*idEvent*/, cMsWait + 1) != 0)
    {
        QMSG Msg;
        while (WinGetMsg(g_hOs2Ab, &Msg, NULL, 0, 0))
        {
            WinDispatchMsg(g_hOs2Ab, &Msg);
            if (g_fOs2TimerTicked || RTTimeMilliTS() - msStart >= cMsWait)
                break;
        }

        if (!WinStopTimer(g_hOs2Ab, g_hOs2Wnd, 1 /*idEvent*/))
            RTMsgWarning("WinStopTimer failed: %#x", WinGetLastError(g_hOs2Ab));
    }
    else
        return RTMsgErrorExitFailure("WinStartTimer(,,,%u ms) failed: %#x", cMsWait + 1, WinGetLastError(g_hOs2Ab));

#elif defined(RT_OS_WINDOWS)
    /*
     * Arm a timer which will timeout after the desired period and
     * quit when we've dispatched it.
     */
    g_fWinTimerTicked = false;
    if (SetTimer(g_hWinWnd, 1 /*idEvent*/, cMsWait + 1, NULL /*pfnTimerProc*/) != 0)
    {
        MSG Msg;
        while (GetMessageW(&Msg, NULL, 0, 0))
        {
            TranslateMessage(&Msg);
            DispatchMessageW(&Msg);
            if (g_fWinTimerTicked || RTTimeMilliTS() - msStart >= cMsWait)
                break;
        }

        if (!KillTimer(g_hWinWnd, 1 /*idEvent*/))
            RTMsgWarning("KillTimer failed: %u (%#x)", GetLastError(), GetLastError());
    }
    else
        return RTMsgErrorExitFailure("SetTimer(,,%u ms,) failed: %u (%#x)", cMsWait + 1, GetLastError(), GetLastError());

#else
/** @todo X11 needs to run it's message queue too, because if we're offering
 *        things on the "clipboard" we must reply to requests for them.  */
    /*
     * Just a plain simple RTThreadSleep option (will probably not be used in the end):
     */
    for (;;)
    {
        uint64_t cMsElapsed = RTTimeMilliTS() - msStart;
        if (cMsElapsed >= cMsWait)
            break;
        RTThreadSleep(cMsWait - cMsElapsed);
    }
#endif

    if (g_uVerbosity > 2)
        RTMsgInfo("Done waiting after %u ms.\n", RTTimeMilliTS() - msStart);
    return RTEXITCODE_SUCCESS;
}


/**
 * Display the usage to @a pStrm.
 */
static void Usage(PRTSTREAM pStrm)
{
    RTStrmPrintf(pStrm,
                 "usage: %s [--get <fmt> [--get ...]] [--get-file <fmt> <file> [--get-file ...]]\n"
                 "       %s [--zap] [--put <fmt> <content> [--put ...]] [--put-file <fmt> <file> [--put-file ...]] [--wait <ms>]\n"
                 "       %s [--check <fmt> <expected> [--check ...]] [--check-file <fmt> <file> [--check-file ...]]\n"
                 "           [--check-no <fmt> [--check-no ...]]\n"
                 , RTProcShortName(), RTProcShortName(), RTProcShortName());
    RTStrmPrintf(pStrm, "\n");
    RTStrmPrintf(pStrm, "Actions/Options:\n");

    for (unsigned i = 0; i < RT_ELEMENTS(g_aCmdOptions); i++)
    {
        const char *pszHelp;
        switch (g_aCmdOptions[i].iShort)
        {
            case 'l':   pszHelp = "List the clipboard content."; break;
            case 'g':   pszHelp = "Get given clipboard format and writes it to standard output."; break;
            case 'G':   pszHelp = "Get given clipboard format and writes it to the specified file."; break;
            case 'p':   pszHelp = "Puts given format and content on the clipboard."; break;
            case 'P':   pszHelp = "Puts given format and file content on the clipboard."; break;
            case 'c':   pszHelp = "Checks that the given format and content matches the clipboard."; break;
            case 'C':   pszHelp = "Checks that the given format and file content matches the clipboard."; break;
            case 'n':   pszHelp = "Checks that the given format is not on the clipboard."; break;
            case 'z':   pszHelp = "Zaps the clipboard content."; break;
#ifdef MULTI_TARGET_CLIPBOARD
            case 't':   pszHelp = "Selects the target clipboard."; break;
#endif
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
            case 'k':   pszHelp = "Closes the clipboard if open (win,os2)."; break;
#endif
            case 'w':   pszHelp = "Waits a given number of milliseconds before continuing."; break;
            case 'v':   pszHelp = "More verbose execution."; break;
            case 'q':   pszHelp = "Quiet execution."; break;
            case 'h':   pszHelp = "Displays this help and exit"; break;
            case 'V':   pszHelp = "Displays the program revision"; break;

            default:
                pszHelp = "Option undocumented";
                break;
        }
        if ((unsigned)g_aCmdOptions[i].iShort < 127U)
        {
            char szOpt[64];
            RTStrPrintf(szOpt, sizeof(szOpt), "%s, -%c", g_aCmdOptions[i].pszLong, g_aCmdOptions[i].iShort);
            RTStrmPrintf(pStrm, "  %-19s %s\n", szOpt, pszHelp);
        }
        else
            RTStrmPrintf(pStrm, "  %-19s %s\n", g_aCmdOptions[i].pszLong, pszHelp);
    }
    RTStrmPrintf(pStrm,
                 "\n"
                 "Note! Options are processed in the order they are given.\n");

    RTStrmPrintf(pStrm, "\nFormats:\n");
    for (size_t i = 0; i < RT_ELEMENTS(g_aFormats); i++)
        RTStrmPrintf(pStrm, "    %-12s: %s\n", g_aFormats[i].pszName, g_aFormats[i].pszDesc);

#ifdef MULTI_TARGET_CLIPBOARD
    RTStrmPrintf(pStrm, "\nTarget:\n");
    for (size_t i = 0; i < RT_ELEMENTS(g_aTargets); i++)
        RTStrmPrintf(pStrm, "    %-12s: %s\n", g_aTargets[i].pszName, g_aTargets[i].pszDesc);
#endif
}


int main(int argc, char *argv[])
{
    /*
     * Init IPRT.
     */
    int rc = RTR3InitExe(argc, &argv, 0);
    if (RT_FAILURE(rc))
        return RTMsgInitFailure(rc);

    /*
     * Host specific init.
     */
#ifdef RT_OS_DARWIN
    RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
#elif defined(RT_OS_OS2)
    RTEXITCODE rcExit = CuOs2Init();
#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit = CuWinInit();
#else
    RTEXITCODE rcExit = CuX11Init();
#endif
    if (rcExit != RTEXITCODE_SUCCESS)
        return rcExit;

    /*
     * Process options (in order).
     */
    RTGETOPTUNION ValueUnion;
    RTGETOPTSTATE GetState;
    RTGetOptInit(&GetState, argc, argv, g_aCmdOptions, RT_ELEMENTS(g_aCmdOptions), 1, 0 /* fFlags */);
    while ((rc = RTGetOpt(&GetState, &ValueUnion)) != 0)
    {
        RTEXITCODE rcExit2 = RTEXITCODE_SUCCESS;
        switch (rc)
        {
#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
            case 'k':
                rcExit2 = CuCloseClipboard();
                break;
#endif

            case 'l':
                rcExit2 = ListClipboardContent();
                break;

            case 'g':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                    rcExit2 = ClipboardContentToStdOut(pFmtDesc);
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'G':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                {
                    rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
                    if (RT_SUCCESS(rc))
                        rcExit2 = ClipboardContentToFile(pFmtDesc, ValueUnion.psz);
                    else
                        return RTMsgErrorExitFailure("No filename given with --get-file");
                }
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'p':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                {
                    rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
                    if (RT_SUCCESS(rc))
                        rcExit2 = PutStringOnClipboard(pFmtDesc, ValueUnion.psz);
                    else
                        return RTMsgErrorExitFailure("No data string given with --put");
                }
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'P':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                {
                    rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
                    if (RT_SUCCESS(rc))
                        rcExit2 = PutFileOnClipboard(pFmtDesc, ValueUnion.psz);
                    else
                        return RTMsgErrorExitFailure("No filename given with --put-file");
                }
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'c':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                {
                    rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
                    if (RT_SUCCESS(rc))
                        rcExit2 = CheckStringAgainstClipboard(pFmtDesc, ValueUnion.psz);
                    else
                        return RTMsgErrorExitFailure("No data string given with --check");
                }
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'C':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                {
                    rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_STRING);
                    if (RT_SUCCESS(rc))
                        rcExit2 = CheckFileAgainstClipboard(pFmtDesc, ValueUnion.psz);
                    else
                        return RTMsgErrorExitFailure("No filename given with --check-file");
                }
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }

            case 'n':
            {
                PCCLIPUTILFORMAT pFmtDesc = GetFormatDesc(ValueUnion.psz);
                if (pFmtDesc)
                    rcExit2 = CheckFormatNotOnClipboard(pFmtDesc);
                else
                    rcExit2 = RTEXITCODE_FAILURE;
                break;
            }


            case 'z':
                rcExit2 = ZapAllClipboardData();
                break;

#ifdef MULTI_TARGET_CLIPBOARD
            case 't':
            {
                CLIPUTILTARGET *pNewTarget = NULL;
                for (size_t i = 0; i < RT_ELEMENTS(g_aTargets); i++)
                    if (strcmp(ValueUnion.psz, g_aTargets[i].pszName) == 0)
                    {
                        pNewTarget = &g_aTargets[i];
                        break;
                    }
                if (!pNewTarget)
                    return RTMsgErrorExitFailure("Unknown target '%s'", ValueUnion.psz);
                if (pNewTarget != g_pTarget && g_uVerbosity > 0)
                    RTMsgInfo("Switching from '%s' to '%s'\n", g_pTarget->pszName, pNewTarget->pszName);
                g_pTarget = pNewTarget;
                break;
            }
#endif

            case 'w':
                rcExit2 = DoWait(ValueUnion.u32);
                break;

            case 'q':
                g_uVerbosity = 0;
                break;

            case 'v':
                g_uVerbosity++;
                break;

            case 'h':
                Usage(g_pStdOut);
                return RTEXITCODE_SUCCESS;

            case 'V':
            {
                char szRev[] = "$Revision: 155244 $";
                szRev[RT_ELEMENTS(szRev) - 2] = '\0';
                RTPrintf(RTStrStrip(strchr(szRev, ':') + 1));
                return RTEXITCODE_SUCCESS;
            }

            default:
                return RTGetOptPrintError(rc, &ValueUnion);
        }

        if (rcExit2 != RTEXITCODE_SUCCESS && rcExit == RTEXITCODE_SUCCESS)
            rcExit = rcExit2;
    }

    /*
     * Host specific cleanup.
     */
#if defined(RT_OS_OS2)
    RTEXITCODE rcExit2 = CuOs2Term();
#elif defined(RT_OS_WINDOWS)
    RTEXITCODE rcExit2 = CuWinTerm();
#else
    RTEXITCODE rcExit2 = RTEXITCODE_SUCCESS;
#endif
    if (rcExit2 != RTEXITCODE_SUCCESS && rcExit != RTEXITCODE_SUCCESS)
        rcExit = rcExit2;

    return rcExit;
}