VirtualBox

Ignore:
Timestamp:
Feb 24, 2010 12:51:09 PM (15 years ago)
Author:
vboxsync
Message:

VBoxTray/Clipboard: Cleanup, make more use of VbglR3* functions.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r24320 r26742  
    66
    77/*
    8  * Copyright (C) 2006-2007 Sun Microsystems, Inc.
     8 * Copyright (C) 2006-2010 Sun Microsystems, Inc.
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2222
    2323#include "VBoxTray.h"
     24#include "helpers.h"
     25
    2426#include <VBox/HostServices/VBoxClipboardSvc.h>
    25 #include "helpers.h"
    26 #include <iprt/asm.h>
    2727#include <strsafe.h>
    2828
    … …  
    4646} VBOXCLIPBOARDCONTEXT;
    4747
    48 
    4948static char gachWindowClassName[] = "VBoxSharedClipboardClass";
    5049
    5150
    52 #define VBOX_INIT_CALL(__a, __b, __c) do {                                                             \
    53     (__a)->hdr.result      = VINF_SUCCESS;                                                             \
    54     (__a)->hdr.u32ClientID = (__c)->u32ClientID;                                                       \
    55     (__a)->hdr.u32Function = (__b);                                                                    \
    56     (__a)->hdr.cParms      = (sizeof (*(__a)) - sizeof ((__a)->hdr)) / sizeof (HGCMFunctionParameter); \
    57 } while (0)
    58 
    59 
    60 //static bool vboxClipboardIsSameAsLastSent (VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format,
    61 //                                           void *pv, uint32_t cb)
    62 //{
    63 //    uint64_t u64CRC = RTCrc64 (pv, cb);
    64 //
    65 //    if (   pCtx->u32LastSentFormat == u32Format
    66 //        && pCtx->u64LastSentCRC64 == u64CRC)
    67 //    {
    68 //        return true;
    69 //    }
    70 //
    71 //    pCtx->u64LastSentCRC64 = u64CRC;
    72 //    pCtx->u32LastSentFormat = u32Format;
    73 //
    74 //    return false;
    75 //}
    76 
    77 static int vboxClipboardConnect (VBOXCLIPBOARDCONTEXT *pCtx)
    78 {
    79     VBoxGuestHGCMConnectInfo info;
    80 
    81     RT_ZERO (info);
    82 
    83     info.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
    84 
    85     memcpy (info.Loc.u.host.achName, "VBoxSharedClipboard", sizeof ("VBoxSharedClipboard"));
    86 
    87     DWORD cbReturned;
    88 
    89     if (DeviceIoControl (pCtx->pEnv->hDriver,
    90                          VBOXGUEST_IOCTL_HGCM_CONNECT,
    91                          &info, sizeof (info),
    92                          &info, sizeof (info),
    93                          &cbReturned,
    94                          NULL))
    95     {
    96         if (info.result == VINF_SUCCESS)
    97         {
    98             pCtx->u32ClientID = info.u32ClientID;
    99         }
     51static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx)
     52{
     53    AssertPtr(pCtx);
     54
     55    /* Query list of available formats and report to host. */
     56    int rc = VINF_SUCCESS;
     57    if (FALSE == OpenClipboard(pCtx->hwnd))
     58    {
     59        rc = RTErrConvertFromWin32(GetLastError());
    10060    }
    10161    else
    10262    {
    103         info.result = VERR_NOT_SUPPORTED;
    104     }
    105 
    106     return info.result;
    107 }
    108 
    109 static void vboxClipboardDisconnect (VBOXCLIPBOARDCONTEXT *pCtx)
    110 {
    111     if (pCtx->u32ClientID == 0)
    112     {
    113         return;
    114     }
    115 
    116     VBoxGuestHGCMDisconnectInfo info;
    117 
    118     RT_ZERO (info);
    119 
    120     info.u32ClientID = pCtx->u32ClientID;
    121 
    122     DWORD cbReturned;
    123 
    124     DeviceIoControl (pCtx->pEnv->hDriver,
    125                      VBOXGUEST_IOCTL_HGCM_DISCONNECT,
    126                      &info, sizeof (info),
    127                      &info, sizeof (info),
    128                      &cbReturned,
    129                      NULL);
    130 
    131     return;
    132 }
    133 
    134 
    135 static void VBoxHGCMParmUInt32Set (HGCMFunctionParameter *pParm, uint32_t u32)
    136 {
    137     pParm->type = VMMDevHGCMParmType_32bit;
    138     pParm->u.value32 = u32;
    139 }
    140 
    141 static int VBoxHGCMParmUInt32Get (HGCMFunctionParameter *pParm, uint32_t *pu32)
    142 {
    143     if (pParm->type == VMMDevHGCMParmType_32bit)
    144     {
    145         *pu32 = pParm->u.value32;
    146         return VINF_SUCCESS;
    147     }
    148 
    149     return VERR_INVALID_PARAMETER;
    150 }
    151 
    152 static void VBoxHGCMParmPtrSet (HGCMFunctionParameter *pParm, void *pv, uint32_t cb)
    153 {
    154     pParm->type                    = VMMDevHGCMParmType_LinAddr;
    155     pParm->u.Pointer.size          = cb;
    156     pParm->u.Pointer.u.linearAddr  = (uintptr_t)pv;
    157 }
    158 
    159 
    160 static int vboxCall (HANDLE hDriver, void *pvData, unsigned cbData)
    161 {
    162     DWORD cbReturned;
    163 
    164     if (DeviceIoControl (hDriver,
    165                          VBOXGUEST_IOCTL_HGCM_CALL(cbData),
    166                          pvData, cbData,
    167                          pvData, cbData,
    168                          &cbReturned,
    169                          NULL))
    170     {
    171         return VINF_SUCCESS;
    172     }
    173 
    174     return VERR_NOT_SUPPORTED;
    175 }
    176 
    177 static int vboxClipboardReportFormats (VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Formats)
    178 {
    179     VBoxClipboardFormats parms;
    180 
    181     VBOX_INIT_CALL(&parms, VBOX_SHARED_CLIPBOARD_FN_FORMATS, pCtx);
    182 
    183     VBoxHGCMParmUInt32Set (&parms.formats, u32Formats);
    184 
    185     int rc = vboxCall (pCtx->pEnv->hDriver, &parms, sizeof (parms));
    186 
    187     if (RT_SUCCESS (rc))
    188     {
    189         rc = parms.hdr.result;
    190     }
    191 
    192     return rc;
    193 }
    194 
    195 static int vboxClipboardReadData (VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual)
    196 {
    197     VBoxClipboardReadData parms;
    198 
    199     VBOX_INIT_CALL(&parms, VBOX_SHARED_CLIPBOARD_FN_READ_DATA, pCtx);
    200 
    201     VBoxHGCMParmUInt32Set (&parms.format, u32Format);
    202     VBoxHGCMParmPtrSet    (&parms.ptr, pv, cb);
    203     VBoxHGCMParmUInt32Set (&parms.size, 0);
    204 
    205     int rc = vboxCall (pCtx->pEnv->hDriver, &parms, sizeof (parms));
    206 
    207     if (RT_SUCCESS (rc))
    208     {
    209         rc = parms.hdr.result;
    210 
    211         if (RT_SUCCESS (rc))
    212         {
    213             uint32_t u32Size;
    214 
    215             rc = VBoxHGCMParmUInt32Get (&parms.size, &u32Size);
    216 
    217             Log (("vboxClipboardReadData: actual size = %d, rc = %d\n", u32Size, rc));
    218 
    219             if (RT_SUCCESS (rc))
    220             {
    221                 if (pcbActual)
    222                 {
    223                     *pcbActual = u32Size;
    224                 }
    225             }
    226         }
    227     }
    228 
    229     return rc;
    230 }
    231 
    232 static int vboxClipboardWriteData (VBOXCLIPBOARDCONTEXT *pCtx, uint32_t u32Format,
    233                                   void *pv, uint32_t cb)
    234 {
    235 //    if (vboxClipboardIsSameAsLastSent (pCtx, u32Format, pv, cb))
    236 //    {
    237 //        Log (("vboxClipboardWriteData: The data to be sent are the same as the last sent.\n"));
    238 //        return VINF_SUCCESS;
    239 //    }
    240 
    241     VBoxClipboardWriteData parms;
    242 
    243     VBOX_INIT_CALL(&parms, VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA, pCtx);
    244 
    245     VBoxHGCMParmUInt32Set (&parms.format, u32Format);
    246     VBoxHGCMParmPtrSet (&parms.ptr, pv, cb);
    247 
    248     int rc = vboxCall (pCtx->pEnv->hDriver, &parms, sizeof (parms));
    249 
    250     if (RT_SUCCESS (rc))
    251     {
    252         rc = parms.hdr.result;
    253     }
    254 
    255     return rc;
    256 }
    257 
    258 static void vboxClipboardChanged (VBOXCLIPBOARDCONTEXT *pCtx)
    259 {
    260     /* Query list of available formats and report to host. */
    261     if (OpenClipboard (pCtx->hwnd))
    262     {
    26363        uint32_t u32Formats = 0;
    264 
    26564        UINT format = 0;
    26665
    26766        while ((format = EnumClipboardFormats (format)) != 0)
    26867        {
    269             Log (("vboxClipboardChanged: format 0x%08X\n", format));
     68            Log (("vboxClipboardChanged: format = 0x%08X\n", format));
    27069            switch (format)
    27170            {
    … …  
    28685
    28786                        int cActual = GetClipboardFormatName(format, szFormatName, sizeof(szFormatName)/sizeof (TCHAR));
    288 
    28987                        if (cActual)
    29088                        {
    … …  
    30098
    30199        CloseClipboard ();
    302 
    303         vboxClipboardReportFormats (pCtx, u32Formats);
    304     }
     100        rc = VbglR3ClipboardReportFormats(pCtx->u32ClientID, u32Formats);
     101    }
     102    return rc;
    305103}
    306104
    … …  
    330128                {
    331129                    /* Pass the message further. */
    332                     rc = SendMessage (pCtx->hwndNextInChain, WM_CHANGECBCHAIN, wParam, lParam);
     130                    rc = SendMessage(pCtx->hwndNextInChain, WM_CHANGECBCHAIN, wParam, lParam);
    333131                }
    334132            }
    … …  
    342140            {
    343141                /* Clipboard was updated by another application. */
    344                 vboxClipboardChanged (pCtx);
     142                vboxClipboardChanged(pCtx); /** @todo r=andy Check for return code! */
    345143            }
    346144
    347145            /* Pass the message to next windows in the clipboard chain. */
    348             rc = SendMessage (pCtx->hwndNextInChain, msg, wParam, lParam);
     146            rc = SendMessage(pCtx->hwndNextInChain, msg, wParam, lParam);
    349147        } break;
    350148
    … …  
    358156            /* Insert the requested clipboard format data into the clipboard. */
    359157            uint32_t u32Format = 0;
    360 
    361158            UINT format = (UINT)wParam;
    362159
    363             Log (("vboxClipboardProcessMsg: WM_RENDERFORMAT, format %x\n", format));
    364 
     160            Log (("vboxClipboardProcessMsg: WM_RENDERFORMAT, format = %x\n", format));
    365161            switch (format)
    366162            {
    … …  
    394190            {
    395191                /* Unsupported clipboard format is requested. */
    396                 EmptyClipboard ();
     192                Log(("vboxClipboardProcessMsg: Unsupported clipboard format requested: %ld\n", u32Format));
     193                EmptyClipboard();
    397194            }
    398195            else
    399196            {
    400                 const uint32_t cbPrealloc = 4096;
     197                const uint32_t cbPrealloc = 4096; /* @todo r=andy Make it dynamic for supporting larger text buffers! */
    401198                uint32_t cb = 0;
    402199
    403200                /* Preallocate a buffer, most of small text transfers will fit into it. */
    404                 HANDLE hMem = GlobalAlloc (GMEM_DDESHARE | GMEM_MOVEABLE, cbPrealloc);
    405                 Log(("hMem %p\n", hMem));
     201                HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, cbPrealloc);
     202                Log(("vboxClipboardProcessMsg: Preallocated handle hMem = %p\n", hMem));
    406203
    407204                if (hMem)
    408205                {
    409                     void *pMem = GlobalLock (hMem);
    410                     Log(("pMem %p, GlobalSize %d\n", pMem, GlobalSize (hMem)));
     206                    void *pMem = GlobalLock(hMem);
     207                    Log(("vboxClipboardProcessMsg: Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
    411208
    412209                    if (pMem)
    413210                    {
    414211                        /* Read the host data to the preallocated buffer. */
    415                         int vboxrc = vboxClipboardReadData (pCtx, u32Format, pMem, cbPrealloc, &cb);
    416                         Log(("vboxClipboardReadData vboxrc %d\n",  vboxrc));
    417 
    418                         if (RT_SUCCESS (vboxrc))
     212                        int vboxrc = VbglR3ClipboardReadData(pCtx->u32ClientID, u32Format, pMem, cbPrealloc, &cb);
     213                        Log(("vboxClipboardProcessMsg: VbglR3ClipboardReadData returned with rc = %Rrc\n",  vboxrc));
     214
     215                        if (RT_SUCCESS(vboxrc))
    419216                        {
    420217                            if (cb == 0)
    … …  
    424221                                 * the clipboard empty code path.
    425222                                 */
    426                                 GlobalUnlock (hMem);
    427                                 GlobalFree (hMem);
     223                                GlobalUnlock(hMem);
     224                                GlobalFree(hMem);
    428225                                hMem = NULL;
    429226                            }
    430227                            else if (cb > cbPrealloc)
    431228                            {
    432                                 GlobalUnlock (hMem);
     229                                GlobalUnlock(hMem);
    433230
    434231                                /* The preallocated buffer is too small, adjust the size. */
    435                                 hMem = GlobalReAlloc (hMem, cb, 0);
    436                                 Log(("hMem %p\n", hMem));
     232                                hMem = GlobalReAlloc(hMem, cb, 0);
     233                                Log(("vboxClipboardProcessMsg: Reallocated hMem = %p\n", hMem));
    437234
    438235                                if (hMem)
    439236                                {
    440                                     pMem = GlobalLock (hMem);
    441                                     Log(("pMem %p, GlobalSize %d\n", pMem, GlobalSize (hMem)));
     237                                    pMem = GlobalLock(hMem);
     238                                    Log(("vboxClipboardProcessMsg: Locked pMem = %p, GlobalSize = %ld\n", pMem, GlobalSize(hMem)));
    442239
    443240                                    if (pMem)
    … …  
    445242                                        /* Read the host data to the preallocated buffer. */
    446243                                        uint32_t cbNew = 0;
    447                                         vboxrc = vboxClipboardReadData (pCtx, u32Format, pMem, cb, &cbNew);
    448                                         Log(("vboxClipboardReadData vboxrc %d, cb = %d, cbNew = %d\n", vboxrc, cb, cbNew));
     244                                        vboxrc = VbglR3ClipboardReadData(pCtx->u32ClientID, u32Format, pMem, cb, &cbNew);
     245                                        Log(("VbglR3ClipboardReadData returned with rc = %Rrc, cb = %d, cbNew = %d\n", vboxrc, cb, cbNew));
    449246
    450247                                        if (RT_SUCCESS (vboxrc) && cbNew <= cb)
    … …  
    454251                                        else
    455252                                        {
    456                                             GlobalUnlock (hMem);
    457                                             GlobalFree (hMem);
     253                                            GlobalUnlock(hMem);
     254                                            GlobalFree(hMem);
    458255                                            hMem = NULL;
    459256                                        }
    … …  
    461258                                    else
    462259                                    {
    463                                         GlobalFree (hMem);
     260                                        GlobalFree(hMem);
    464261                                        hMem = NULL;
    465262                                    }
    … …  
    476273                                {
    477274                                    size_t cbActual = 0;
    478                                     HRESULT hrc = StringCbLengthW ((LPWSTR)pMem, cb, &cbActual);
     275                                    HRESULT hrc = StringCbLengthW((LPWSTR)pMem, cb, &cbActual);
    479276                                    if (FAILED (hrc))
    480277                                    {
    481278                                        /* Discard invalid data. */
    482                                         GlobalUnlock (hMem);
    483                                         GlobalFree (hMem);
     279                                        GlobalUnlock(hMem);
     280                                        GlobalFree(hMem);
    484281                                        hMem = NULL;
    485282                                    }
    … …  
    496293                            if (hMem)
    497294                            {
    498                                 GlobalUnlock (hMem);
    499 
    500                                 hMem = GlobalReAlloc (hMem, cb, 0);
    501                                 Log(("hMem %p\n", hMem));
     295                                GlobalUnlock(hMem);
     296
     297                                hMem = GlobalReAlloc(hMem, cb, 0);
     298                                Log(("vboxClipboardProcessMsg: Reallocated hMem = %p\n", hMem));
    502299
    503300                                if (hMem)
    … …  
    507304                                     */
    508305                                    HANDLE hClip = SetClipboardData (format, hMem);
    509                                     Log(("WM_RENDERFORMAT hClip %p\n", hClip));
     306                                    Log(("vboxClipboardProcessMsg: WM_RENDERFORMAT hClip = %p\n", hClip));
    510307
    511308                                    if (hClip)
    … …  
    522319                        if (hMem)
    523320                        {
    524                             GlobalUnlock (hMem);
     321                            GlobalUnlock(hMem);
    525322                        }
    526323                    }
    … …  
    528325                    if (hMem)
    529326                    {
    530                         GlobalFree (hMem);
     327                        GlobalFree(hMem);
    531328                    }
    532329                }
    533330
    534331                /* Something went wrong. */
    535                 EmptyClipboard ();
     332                EmptyClipboard();
    536333            }
    537334        } break;
    … …  
    545342            {
    546343                EmptyClipboard();
    547 
    548344                CloseClipboard();
    549345            }
    … …  
    555351            uint32_t u32Formats = (uint32_t)lParam;
    556352
    557             if (OpenClipboard (hwnd))
     353            if (FALSE == OpenClipboard (hwnd))
     354            {
     355                Log(("vboxClipboardProcessMsg: WM_USER: Failed to open clipboard! Last error = %ld\n", GetLastError()));
     356            }
     357            else
    558358            {
    559359                EmptyClipboard();
    … …  
    563363                if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
    564364                {
    565                     Log(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n"));
    566 
    567                     hClip = SetClipboardData (CF_UNICODETEXT, NULL);
     365                    Log(("vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT\n"));
     366                    hClip = SetClipboardData(CF_UNICODETEXT, NULL);
    568367                }
    569368
    570369                if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    571370                {
    572                     Log(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
    573 
    574                     hClip = SetClipboardData (CF_DIB, NULL);
     371                    Log(("vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_BITMAP\n"));
     372                    hClip = SetClipboardData(CF_DIB, NULL);
    575373                }
    576374
    … …  
    578376                {
    579377                    UINT format = RegisterClipboardFormat ("HTML Format");
    580                     Log(("window proc WM_USER: VBOX_SHARED_CLIPBOARD_FMT_HTML 0x%04X\n", format));
     378                    Log(("vboxClipboardProcessMsg: WM_USER: VBOX_SHARED_CLIPBOARD_FMT_HTML 0x%04X\n", format));
    581379                    if (format != 0)
    582380                    {
    583                         hClip = SetClipboardData (format, NULL);
     381                        hClip = SetClipboardData(format, NULL);
    584382                    }
    585383                }
    586384
    587385                CloseClipboard();
    588 
    589                 Log(("window proc WM_USER: hClip %p, err %d\n", hClip, GetLastError ()));
    590             }
    591             else
    592             {
    593                 Log(("window proc WM_USER: failed to open clipboard\n"));
     386                Log(("vboxClipboardProcessMsg: WM_USER: hClip = %p, err = %ld\n", hClip, GetLastError ()));
    594387            }
    595388        } break;
    … …  
    602395            HANDLE hClip = NULL;
    603396
    604             if (OpenClipboard (hwnd))
    605             {
     397            if (FALSE == OpenClipboard(hwnd))
     398            {
     399            }
     400            else
     401            {
     402                int vboxrc;
    606403                if (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
    607404                {
    608                     hClip = GetClipboardData (CF_DIB);
     405                    hClip = GetClipboardData(CF_DIB);
    609406
    610407                    if (hClip != NULL)
    611408                    {
    612                         LPVOID lp = GlobalLock (hClip);
    613 
     409                        LPVOID lp = GlobalLock(hClip);
    614410                        if (lp != NULL)
    615411                        {
    616                             Log(("CF_DIB\n"));
    617 
    618                             vboxClipboardWriteData (pCtx, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
    619                                                     lp, GlobalSize (hClip));
    620 
     412                            Log(("vboxClipboardProcessMsg: WM_USER + 1: CF_DIB\n"));
     413                            vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_BITMAP,
     414                                                              lp, GlobalSize(hClip));
    621415                            GlobalUnlock(hClip);
    622416                        }
    … …  
    637431                        if (uniString != NULL)
    638432                        {
    639                             Log(("CF_UNICODETEXT\n"));
    640 
    641                             vboxClipboardWriteData (pCtx, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
    642                                                     uniString, (lstrlenW (uniString) + 1) * 2);
    643 
     433                            Log(("vboxClipboardProcessMsg: WM_USER + 1: CF_UNICODETEXT\n"));
     434                            vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT,
     435                                                              uniString, (lstrlenW(uniString) + 1) * 2);
    644436                            GlobalUnlock(hClip);
    645437                        }
    … …  
    653445                {
    654446                    UINT format = RegisterClipboardFormat ("HTML Format");
    655 
    656447                    if (format != 0)
    657448                    {
    658449                        hClip = GetClipboardData (format);
    659 
    660450                        if (hClip != NULL)
    661451                        {
    … …  
    664454                            if (lp != NULL)
    665455                            {
    666                                 Log(("CF_HTML\n"));
    667 
    668                                 vboxClipboardWriteData (pCtx, VBOX_SHARED_CLIPBOARD_FMT_HTML,
    669                                                         lp, GlobalSize (hClip));
    670 
     456                                Log(("vboxClipboardProcessMsg: WM_USER + 1: CF_HTML\n"));
     457                                vboxrc = VbglR3ClipboardWriteData(pCtx->u32ClientID, VBOX_SHARED_CLIPBOARD_FMT_HTML,
     458                                                                  lp, GlobalSize(hClip));
    671459                                GlobalUnlock(hClip);
    672460                            }
    … …  
    685473            {
    686474                /* Requested clipboard format is not available, send empty data. */
    687                 vboxClipboardWriteData (pCtx, 0, NULL, 0);
     475                VbglR3ClipboardWriteData(pCtx->u32ClientID, 0, NULL, 0);
    688476            }
    689477        } break;
    … …  
    702490static int vboxClipboardInit (VBOXCLIPBOARDCONTEXT *pCtx)
    703491{
    704     int rc = VINF_SUCCESS;
    705 
    706492    /* Register the Window Class. */
    707493    WNDCLASS wc;
    … …  
    720506    pCtx->atomWindowClass = RegisterClass (&wc);
    721507
     508    int rc = VINF_SUCCESS;
    722509    if (pCtx->atomWindowClass == 0)
    723510    {
    … …  
    745532    }
    746533
     534    Log(("vboxClipboardInit returned with rc = %Rrc\n", rc));
    747535    return rc;
    748536}
    … …  
    775563}
    776564
    777 int VBoxClipboardInit (const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
    778 {
    779     int rc = VINF_SUCCESS;
    780 
     565int VBoxClipboardInit(const VBOXSERVICEENV *pEnv, void **ppInstance, bool *pfStartThread)
     566{
    781567    Log (("VboxClipboardInit\n"));
    782 
    783568    if (gCtx.pEnv)
    784569    {
    … …  
    788573
    789574    RT_ZERO (gCtx);
    790 
    791575    gCtx.pEnv = pEnv;
    792576
    793     rc = vboxClipboardConnect (&gCtx);
    794 
     577    int rc = VbglR3ClipboardConnect(&gCtx.u32ClientID);
    795578    if (RT_SUCCESS (rc))
    796579    {
    797         rc = vboxClipboardInit (&gCtx);
    798 
    799         Log (("vboxClipboardInit: rc = %d\n", rc));
    800 
     580        rc = vboxClipboardInit(&gCtx);
    801581        if (RT_SUCCESS (rc))
    802582        {
    … …  
    804584            *pfStartThread = true;
    805585        }
     586        else
     587        {
     588            VbglR3ClipboardDisconnect(gCtx.u32ClientID);
     589        }
    806590    }
    807591
    808592    if (RT_SUCCESS (rc))
    809     {
    810593        *ppInstance = &gCtx;
    811     }
    812     else
    813     {
    814         vboxClipboardDisconnect (&gCtx);
    815     }
    816 
    817594    return rc;
    818595}
    819596
    820 unsigned __stdcall VBoxClipboardThread (void *pInstance)
    821 {
     597unsigned __stdcall VBoxClipboardThread(void *pInstance)
     598{
     599    Log(("VBoxClipboardThread\n"));
     600
    822601    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pInstance;
    823 
    824     Log(("VBoxClipboardThread\n"));
    825 
    826     /* Open the new driver instance to not interfere with other callers. */
    827     HANDLE hDriver = CreateFile(VBOXGUEST_DEVICE_NAME,
    828                                 GENERIC_READ | GENERIC_WRITE,
    829                                 FILE_SHARE_READ | FILE_SHARE_WRITE,
    830                                 NULL,
    831                                 OPEN_EXISTING,
    832                                 FILE_ATTRIBUTE_NORMAL,
    833                                 NULL);
     602    AssertPtr(pCtx);
    834603
    835604    /* The thread waits for incoming messages from the host. */
    836605    for (;;)
    837606    {
    838         VBoxClipboardGetHostMsg parms;
    839 
    840         VBOX_INIT_CALL(&parms, VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG, pCtx);
    841 
    842         VBoxHGCMParmUInt32Set (&parms.msg, 0);
    843         VBoxHGCMParmUInt32Set (&parms.formats, 0);
    844 
    845         DWORD cbReturned;
    846 
    847         if (!DeviceIoControl (hDriver,
    848                               VBOXGUEST_IOCTL_HGCM_CALL(sizeof (parms)),
    849                               &parms, sizeof (parms),
    850                               &parms, sizeof (parms),
    851                               &cbReturned,
    852                               NULL))
    853         {
    854             Log(("Failed to call the driver for host message.\n"));
    855 
     607        uint32_t u32Msg;
     608        uint32_t u32Formats;
     609        int rc = VbglR3ClipboardGetHostMsg(pCtx->u32ClientID, &u32Msg, &u32Formats);
     610        if (RT_FAILURE(rc))
     611        {
     612            Log(("VBoxClipboardThread: Failed to call the driver for host message! rc = %Rrc\n", rc));
     613            if (rc == VERR_INTERRUPTED)
     614            {
     615                /* Wait for termination event. */
     616                WaitForSingleObject(pCtx->pEnv->hStopEvent, INFINITE);
     617                break;
     618            }
    856619            /* Wait a bit before retrying. */
     620            AssertPtr(pCtx->pEnv);
    857621            if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 1000) == WAIT_OBJECT_0)
    858622            {
    859623                break;
    860624            }
    861 
    862625            continue;
     626       }
     627        else
     628        {
     629            Log(("VBoxClipboardThread: VbglR3ClipboardGetHostMsg u32Msg = %ld, u32Formats = %ld\n", u32Msg, u32Formats));
     630            switch (u32Msg)
     631            {
     632                case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
     633                {
     634                    /* The host has announced available clipboard formats.
     635                     * Forward the information to the window, so it can later
     636                     * respond to WM_RENDERFORMAT message. */
     637                    ::PostMessage (pCtx->hwnd, WM_USER, 0, u32Formats);
     638                } break;
     639
     640                case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
     641                {
     642                    /* The host needs data in the specified format. */
     643                    ::PostMessage (pCtx->hwnd, WM_USER + 1, 0, u32Formats);
     644                } break;
     645
     646                case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
     647                {
     648                    /* The host is terminating. */
     649                    rc = VERR_INTERRUPTED;
     650                } break;
     651
     652                default:
     653                {
     654                    Log(("VBoxClipboardThread: Unsupported message from host! Message = %ld\n", u32Msg));
     655                }
     656            }
    863657        }
    864 
    865         int rc = parms.hdr.result;
    866 
    867         if (RT_SUCCESS (rc))
    868         {
    869             uint32_t u32Msg;
    870             uint32_t u32Formats;
    871 
    872             rc = VBoxHGCMParmUInt32Get (&parms.msg, &u32Msg);
    873 
    874             if (RT_SUCCESS (rc))
    875             {
    876                 rc = VBoxHGCMParmUInt32Get (&parms.formats, &u32Formats);
    877 
    878                 if (RT_SUCCESS (rc))
    879                 {
    880                     Log(("vboxClipboardHostEvent u32Msg %d, u32Formats %d\n", u32Msg, u32Formats));
    881 
    882                     switch (u32Msg)
    883                     {
    884                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
    885                         {
    886                             /* The host has announced available clipboard formats.
    887                              * Forward the information to the window, so it can later
    888                              * respond to WM_RENDERFORMAT message.
    889                              */
    890                             ::PostMessage (pCtx->hwnd, WM_USER, 0, u32Formats);
    891                         } break;
    892                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
    893                         {
    894                             /* The host needs data in the specified format.
    895                              */
    896                             ::PostMessage (pCtx->hwnd, WM_USER + 1, 0, u32Formats);
    897                         } break;
    898                         case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
    899                         {
    900                             /* The host is terminating.
    901                              */
    902                             rc = VERR_INTERRUPTED;
    903                         } break;
    904                         default:
    905                         {
    906                             Log(("Unsupported message from host!!!\n"));
    907                         }
    908                     }
    909                 }
    910             }
    911         }
    912 
    913         if (rc == VERR_INTERRUPTED)
    914         {
    915             /* Wait for termination event. */
    916             WaitForSingleObject(pCtx->pEnv->hStopEvent, INFINITE);
    917             break;
    918         }
    919 
    920         if (RT_FAILURE (rc))
    921         {
    922             /* Wait a bit before retrying. */
    923             if (WaitForSingleObject(pCtx->pEnv->hStopEvent, 1000) == WAIT_OBJECT_0)
    924             {
    925                 break;
    926             }
    927 
    928             continue;
    929         }
    930 
    931         Log(("processed host event rc = %d\n", rc));
    932     }
    933 
    934     CloseHandle (hDriver);
    935 
     658    }
    936659    return 0;
    937660}
    938661
    939 void VBoxClipboardDestroy (const VBOXSERVICEENV *pEnv, void *pInstance)
     662void VBoxClipboardDestroy(const VBOXSERVICEENV *pEnv, void *pInstance)
    940663{
    941664    VBOXCLIPBOARDCONTEXT *pCtx = (VBOXCLIPBOARDCONTEXT *)pInstance;
    942 
    943665    if (pCtx != &gCtx)
    944666    {
    945         Log(("VBoxClipboardDestroy: invalid instance %p (our %p)!!!\n", pCtx, &gCtx));
    946 
     667        Log(("VBoxClipboardDestroy: invalid instance %p (our = %p)!\n", pCtx, &gCtx));
    947668        pCtx = &gCtx;
    948669    }
    949670
    950671    vboxClipboardDestroy (pCtx);
    951 
    952     vboxClipboardDisconnect (pCtx);
    953 
     672    VbglR3ClipboardDisconnect(pCtx->u32ClientID);
    954673    memset (pCtx, 0, sizeof (*pCtx));
    955 
    956674    return;
    957675}
     676
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette