VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h@ 100370

最後變更 在這個檔案從100370是 100370,由 vboxsync 提交於 21 月 前

Shared Clipboard: Removed ShClBackendTransferHGRootListRead(), not needed. ​​bugref:9437
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Author Date Id Revision
檔案大小: 20.0 KB
行 
1/* $Id: VBoxSharedClipboardSvc-internal.h 100370 2023-07-05 07:14:28Z vboxsync $ */
2/** @file
3 * Shared Clipboard Service - Internal header.
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.alldomusa.eu.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28#ifndef VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
29#define VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h
30#ifndef RT_WITHOUT_PRAGMA_ONCE
31# pragma once
32#endif
33
34#include <algorithm>
35#include <list>
36#include <map>
37
38#include <iprt/cpp/list.h> /* For RTCList. */
39#include <iprt/list.h>
40#include <iprt/semaphore.h>
41
42#include <VBox/hgcmsvc.h>
43#include <VBox/log.h>
44
45#include <VBox/HostServices/Service.h>
46#include <VBox/GuestHost/SharedClipboard.h>
47#include <VBox/GuestHost/SharedClipboard-transfers.h>
48
49using namespace HGCM;
50
51#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
52struct SHCLCLIENTSTATE;
53#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
54
55/**
56 * A queued message for the guest.
57 */
58typedef struct _SHCLCLIENTMSG
59{
60 /** The queue list entry. */
61 RTLISTNODE ListEntry;
62 /** Stored message ID (VBOX_SHCL_HOST_MSG_XXX). */
63 uint32_t idMsg;
64 /** Context ID. */
65 uint64_t idCtx;
66 /** Number of stored parameters in aParms. */
67 uint32_t cParms;
68 /** HGCM parameters. */
69 RT_FLEXIBLE_ARRAY_EXTENSION
70 VBOXHGCMSVCPARM aParms[RT_FLEXIBLE_ARRAY];
71} SHCLCLIENTMSG;
72/** Pointer to a queue message for the guest. */
73typedef SHCLCLIENTMSG *PSHCLCLIENTMSG;
74
75typedef struct SHCLCLIENTTRANSFERSTATE
76{
77 /** Directory of the transfer to start. */
78 SHCLTRANSFERDIR enmTransferDir;
79} SHCLCLIENTTRANSFERSTATE, *PSHCLCLIENTTRANSFERSTATE;
80
81/**
82 * Structure for holding a single POD (plain old data) transfer.
83 *
84 * This mostly is plain text, but also can be stuff like bitmap (BMP) or other binary data.
85 */
86typedef struct SHCLCLIENTPODSTATE
87{
88 /** POD transfer direction. */
89 SHCLTRANSFERDIR enmDir;
90 /** Format of the data to be read / written. */
91 SHCLFORMAT uFormat;
92 /** How much data (in bytes) to read/write for the current operation. */
93 uint64_t cbToReadWriteTotal;
94 /** How much data (in bytes) already has been read/written for the current operation. */
95 uint64_t cbReadWritten;
96 /** Timestamp (in ms) of Last read/write operation. */
97 uint64_t tsLastReadWrittenMs;
98} SHCLCLIENTPODSTATE, *PSHCLCLIENTPODSTATE;
99
100/** @name SHCLCLIENTSTATE_FLAGS_XXX
101 * @note Part of saved state!
102 * @{ */
103/** No Shared Clipboard client flags defined. */
104#define SHCLCLIENTSTATE_FLAGS_NONE 0
105/** Client has a guest read operation active. Currently unused. */
106#define SHCLCLIENTSTATE_FLAGS_READ_ACTIVE RT_BIT(0)
107/** Client has a guest write operation active. Currently unused. */
108#define SHCLCLIENTSTATE_FLAGS_WRITE_ACTIVE RT_BIT(1)
109/** @} */
110
111/**
112 * Structure needed to support backwards compatbility for old(er) Guest Additions (< 6.1),
113 * which did not know the context ID concept then.
114 */
115typedef struct SHCLCLIENTLEGACYCID
116{
117 /** List node. */
118 RTLISTNODE Node;
119 /** The actual context ID. */
120 uint64_t uCID;
121 /** Not used yet; useful to have it in the saved state though. */
122 uint32_t enmType;
123 /** @todo Add an union here as soon as we utilize \a enmType. */
124 SHCLFORMAT uFormat;
125} SHCLCLIENTLEGACYCID;
126/** Pointer to a SHCLCLIENTLEGACYCID struct. */
127typedef SHCLCLIENTLEGACYCID *PSHCLCLIENTLEGACYCID;
128
129/**
130 * Structure for keeping legacy state, required for keeping backwards compatibility
131 * to old(er) Guest Additions.
132 */
133typedef struct SHCLCLIENTLEGACYSTATE
134{
135 /** List of context IDs (of type SHCLCLIENTLEGACYCID) for older Guest Additions which (< 6.1)
136 * which did not know the concept of context IDs. */
137 RTLISTANCHOR lstCID;
138 /** Number of context IDs currently in \a lstCID. */
139 uint16_t cCID;
140} SHCLCLIENTLEGACYSTATE;
141
142/**
143 * Structure for keeping generic client state data within the Shared Clipboard host service.
144 * This structure needs to be serializable by SSM (must be a POD type).
145 */
146typedef struct SHCLCLIENTSTATE
147{
148 struct SHCLCLIENTSTATE *pNext;
149 struct SHCLCLIENTSTATE *pPrev;
150
151 /** Backend-dependent opaque context structure.
152 * This contains data only known to a certain backend implementation.
153 * Optional and can be NULL. */
154 SHCLCONTEXT *pCtx;
155 /** The client's HGCM ID. Not related to the session ID below! */
156 uint32_t uClientID;
157 /** The client's session ID. */
158 SHCLSESSIONID uSessionID;
159 /** Guest feature flags, VBOX_SHCL_GF_0_XXX. */
160 uint64_t fGuestFeatures0;
161 /** Guest feature flags, VBOX_SHCL_GF_1_XXX. */
162 uint64_t fGuestFeatures1;
163 /** Chunk size to use for data transfers. */
164 uint32_t cbChunkSize;
165 /** Where the transfer sources its data from. */
166 SHCLSOURCE enmSource;
167 /** Client state flags of type SHCLCLIENTSTATE_FLAGS_. */
168 uint32_t fFlags;
169 /** POD (plain old data) state. */
170 SHCLCLIENTPODSTATE POD;
171 /** The client's transfers state. */
172 SHCLCLIENTTRANSFERSTATE Transfers;
173} SHCLCLIENTSTATE, *PSHCLCLIENTSTATE;
174
175typedef struct _SHCLCLIENTCMDCTX
176{
177 uint64_t uContextID;
178} SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX;
179
180#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
181/**
182 * Structure for keeping transfer-related data per HGCM client.
183 */
184typedef struct _SHCLIENTTRANSFERS
185{
186 /** Transfer context. */
187 SHCLTRANSFERCTX Ctx;
188 /** Transfers callbacks to use. */
189 SHCLTRANSFERCALLBACKS Callbacks;
190} SHCLIENTTRANSFERS, *PSHCLIENTTRANSFERS;
191#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
192
193/** Prototypes for the Shared Clipboard backend. */
194struct SHCLBACKEND;
195typedef SHCLBACKEND *PSHCLBACKEND;
196
197/**
198 * Structure for keeping data per (connected) HGCM client.
199 */
200typedef struct _SHCLCLIENT
201{
202 /** Pointer to associated backend, if any.
203 * Might be NULL if not being used. */
204 PSHCLBACKEND pBackend;
205 /** General client state data. */
206 SHCLCLIENTSTATE State;
207 /** The critical section protecting the queue, event source and whatnot. */
208 RTCRITSECT CritSect;
209 /** The client's message queue (SHCLCLIENTMSG). */
210 RTLISTANCHOR MsgQueue;
211 /** Number of allocated messages (updated atomically, not under critsect). */
212 uint32_t volatile cMsgAllocated;
213 /** Legacy cruft we have to keep to support old(er) Guest Additions. */
214 SHCLCLIENTLEGACYSTATE Legacy;
215 /** The client's own event source.
216 * Needed for events which are not bound to a specific transfer. */
217 SHCLEVENTSOURCE EventSrc;
218#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
219 SHCLIENTTRANSFERS Transfers;
220#endif
221 /** Structure for keeping the client's pending (deferred return) state.
222 * A client is in a deferred state when it asks for the next HGCM message,
223 * but the service can't provide it yet. That way a client will block (on the guest side, does not return)
224 * until the service can complete the call. */
225 struct
226 {
227 /** The client's HGCM call handle. Needed for completing a deferred call. */
228 VBOXHGCMCALLHANDLE hHandle;
229 /** Message type (function number) to use when completing the deferred call.
230 * A non-0 value means the client is in pending mode. */
231 uint32_t uType;
232 /** Parameter count to use when completing the deferred call. */
233 uint32_t cParms;
234 /** Parameters to use when completing the deferred call. */
235 PVBOXHGCMSVCPARM paParms;
236 } Pending;
237} SHCLCLIENT, *PSHCLCLIENT;
238
239/**
240 * Structure for keeping a single event source map entry.
241 * Currently empty.
242 */
243typedef struct _SHCLEVENTSOURCEMAPENTRY
244{
245} SHCLEVENTSOURCEMAPENTRY;
246
247/** Map holding information about connected HGCM clients. Key is the (unique) HGCM client ID.
248 * The value is a weak pointer to PSHCLCLIENT, which is owned by HGCM. */
249typedef std::map<uint32_t, PSHCLCLIENT> ClipboardClientMap;
250
251/** Map holding information about event sources. Key is the (unique) event source ID. */
252typedef std::map<SHCLEVENTSOURCEID, SHCLEVENTSOURCEMAPENTRY> ClipboardEventSourceMap;
253
254/** Simple queue (list) which holds deferred (waiting) clients. */
255typedef std::list<uint32_t> ClipboardClientQueue;
256
257/**
258 * Structure for keeping the Shared Clipboard service extension state.
259 *
260 * A service extension is optional, and can be installed by a host component
261 * to communicate with the Shared Clipboard host service.
262 */
263typedef struct _SHCLEXTSTATE
264{
265 /** Pointer to the actual service extension handle. */
266 PFNHGCMSVCEXT pfnExtension;
267 /** Opaque pointer to extension-provided data. Don't touch. */
268 void *pvExtension;
269 /** The HGCM client ID currently assigned to this service extension.
270 * At the moment only one HGCM client can be assigned per extension. */
271 uint32_t uClientID;
272 /** Whether the host service is reading clipboard data currently. */
273 bool fReadingData;
274 /** Whether the service extension has sent the clipboard formats while
275 * the the host service is reading clipboard data from it. */
276 bool fDelayedAnnouncement;
277 /** The actual clipboard formats announced while the host service
278 * is reading clipboard data from the extension. */
279 uint32_t fDelayedFormats;
280} SHCLEXTSTATE, *PSHCLEXTSTATE;
281
282extern SHCLEXTSTATE g_ExtState;
283
284void shClSvcMsgQueueReset(PSHCLCLIENT pClient);
285PSHCLCLIENTMSG shClSvcMsgAlloc(PSHCLCLIENT pClient, uint32_t uMsg, uint32_t cParms);
286void shClSvcMsgFree(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
287void shClSvcMsgAdd(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg, bool fAppend);
288int shClSvcMsgAddAndWakeupClient(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg);
289
290int shClSvcClientInit(PSHCLCLIENT pClient, uint32_t uClientID);
291void shClSvcClientDestroy(PSHCLCLIENT pClient);
292void shClSvcClientLock(PSHCLCLIENT pClient);
293void shClSvcClientUnlock(PSHCLCLIENT pClient);
294void shClSvcClientReset(PSHCLCLIENT pClient);
295
296int shClSvcClientStateInit(PSHCLCLIENTSTATE pClientState, uint32_t uClientID);
297int shClSvcClientStateDestroy(PSHCLCLIENTSTATE pClientState);
298void shclSvcClientStateReset(PSHCLCLIENTSTATE pClientState);
299
300int shClSvcClientWakeup(PSHCLCLIENT pClient);
301
302/** @name Service functions, accessible by the backends.
303 * Locking is between the (host) service thread and the platform-dependent (window) thread.
304 * @{
305 */
306int ShClSvcReadDataFromGuestAsync(PSHCLCLIENT pClient, SHCLFORMATS fFormats, PSHCLEVENT *ppEvent);
307int ShClSvcReadDataFromGuest(PSHCLCLIENT pClient, SHCLFORMAT uFmt, void **ppv, uint32_t *pcb);
308int ShClSvcGuestDataSignal(PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
309int ShClSvcHostReportFormats(PSHCLCLIENT pClient, SHCLFORMATS fFormats);
310PSHCLBACKEND ShClSvcGetBackend(void);
311uint32_t ShClSvcGetMode(void);
312bool ShClSvcGetHeadless(void);
313bool ShClSvcLock(void);
314void ShClSvcUnlock(void);
315
316/**
317 * Checks if the backend is active (@c true), or if VRDE is in control of
318 * the host side.
319 */
320DECLINLINE(bool) ShClSvcIsBackendActive(void)
321{
322 return g_ExtState.pfnExtension == NULL;
323}
324/** @} */
325
326/** @name Platform-dependent implementations for the Shared Clipboard host service ("backends"),
327 * called *only* by the host service.
328 * @{
329 */
330/**
331 * Structure for keeping Shared Clipboard backend instance data.
332 */
333typedef struct SHCLBACKEND
334{
335 /** Callback table to use.
336 * Some callbacks might be optional and therefore NULL -- see the table for more details. */
337 SHCLCALLBACKS Callbacks;
338} SHCLBACKEND;
339/** Pointer to a Shared Clipboard backend. */
340typedef SHCLBACKEND *PSHCLBACKEND;
341
342/**
343 * Called on initialization.
344 *
345 * @param pBackend Shared Clipboard backend to initialize.
346 * @param pTable The HGCM service call and parameter table. Mainly for
347 * adjusting the limits.
348 */
349int ShClBackendInit(PSHCLBACKEND pBackend, VBOXHGCMSVCFNTABLE *pTable);
350
351/**
352 * Called on destruction.
353 *
354 * @param pBackend Shared Clipboard backend to destroy.
355 */
356void ShClBackendDestroy(PSHCLBACKEND pBackend);
357
358/**
359 * Called when a new HGCM client connects.
360 *
361 * @param pBackend Shared Clipboard backend to set callbacks for.
362 * @param pCallbacks Backend callbacks to use.
363 * When NULL is specified, the backend's default callbacks are being used.
364 */
365void ShClBackendSetCallbacks(PSHCLBACKEND pBackend, PSHCLCALLBACKS pCallbacks);
366
367/**
368 * Called when a new HGCM client connects.
369 *
370 * @returns VBox status code.
371 * @param pBackend Shared Clipboard backend to connect to.
372 * @param pClient Shared Clipboard client context.
373 * @param fHeadless Whether this is a headless connection or not.
374 */
375int ShClBackendConnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, bool fHeadless);
376
377/**
378 * Called when a HGCM client disconnects.
379 *
380 * @returns VBox status code.
381 * @param pBackend Shared Clipboard backend to disconnect from.
382 * @param pClient Shared Clipboard client context.
383 */
384int ShClBackendDisconnect(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
385
386/**
387 * Called when the guest reports available clipboard formats to the host OS.
388 *
389 * @returns VBox status code.
390 * @param pBackend Shared Clipboard backend to announce formats to.
391 * @param pClient Shared Clipboard client context.
392 * @param fFormats The announced formats from the guest,
393 * VBOX_SHCL_FMT_XXX.
394 */
395int ShClBackendReportFormats(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, SHCLFORMATS fFormats);
396
397/**
398 * Called when the guest wants to read host clipboard data.
399 *
400 * @returns VBox status code.
401 * @param pBackend Shared Clipboard backend to read data from.
402 * @param pClient Shared Clipboard client context.
403 * @param pCmdCtx Shared Clipboard command context.
404 * @param uFormat Clipboard format to read.
405 * @param pvData Where to return the read clipboard data.
406 * @param cbData Size (in bytes) of buffer where to return the clipboard data.
407 * @param pcbActual Where to return the amount of bytes read.
408 *
409 * @todo Document: Can return VINF_HGCM_ASYNC_EXECUTE to defer returning read
410 * data
411 */
412int ShClBackendReadData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat,
413 void *pvData, uint32_t cbData, uint32_t *pcbActual);
414
415/**
416 * Called when the guest writes clipboard data to the host.
417 *
418 * @returns VBox status code.
419 * @param pBackend Shared Clipboard backend to write data to.
420 * @param pClient Shared Clipboard client context.
421 * @param pCmdCtx Shared Clipboard command context.
422 * @param uFormat Clipboard format to write.
423 * @param pvData Clipboard data to write.
424 * @param cbData Size (in bytes) of buffer clipboard data to write.
425 */
426int ShClBackendWriteData(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLCLIENTCMDCTX pCmdCtx, SHCLFORMAT uFormat, void *pvData, uint32_t cbData);
427
428/**
429 * Called when synchronization of the clipboard contents of the host clipboard with the guest is needed.
430 *
431 * @returns VBox status code.
432 * @param pBackend Shared Clipboard backend to synchronize.
433 * @param pClient Shared Clipboard client context.
434 */
435int ShClBackendSync(PSHCLBACKEND pBackend, PSHCLCLIENT pClient);
436/** @} */
437
438#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
439/** @name Host implementations for Shared Clipboard transfers.
440 * @{
441 */
442/**
443 * Called before a transfer gets destroyed.
444 *
445 * @returns VBox status code.
446 * @param pBackend Shared Clipboard backend to use.
447 * @param pClient Shared Clipboard client context.
448 * @param pTransfer Shared Clipboard transfer to destroy.
449 */
450int ShClBackendTransferDestroy(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer);
451/**
452 * Called after a transfer status got processed.
453 *
454 * @returns VBox status code.
455 * @param pBackend Shared Clipboard backend to use.
456 * @param pClient Shared Clipboard client context.
457 * @param pTransfer Shared Clipboard transfer to process status for.
458 * @param enmSource Transfer source which issues the reply.
459 * @param enmStatus Transfer status.
460 * @param rcStatus Status code (IPRT-style). Depends on \a enmStatus set.
461 */
462int ShClBackendTransferHandleStatusReply(PSHCLBACKEND pBackend, PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLSOURCE enmSource, SHCLTRANSFERSTATUS enmStatus, int rcStatus);
463/** @} */
464#endif
465
466#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS
467/** @name Internal Shared Clipboard transfer host service functions.
468 * @{
469 */
470int shClSvcTransferHandler(PSHCLCLIENT pClient, VBOXHGCMCALLHANDLE callHandle, uint32_t u32Function,
471 uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival);
472int shClSvcTransferHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]);
473/** @} */
474
475/** @name Shared Clipboard transfer interface implementations for the host service.
476 * @{
477 */
478#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
479
480#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP */
481
482int shClSvcTransferIfaceRootsGet(PSHCLTXPROVIDERCTX pCtx, PSHCLLIST pRootList);
483int shClSvcTransferIfaceGHListOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
484int shClSvcTransferIfaceGHListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList);
485int shClSvcTransferIfaceGHListHdrRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
486int shClSvcTransferIfaceHGListHdrWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr);
487int shClSvcTransferIfaceGHListEntryRead(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
488int shClSvcTransferIfaceHGListEntryWrite(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry);
489
490int shClSvcTransferIfaceGHObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms,
491 PSHCLOBJHANDLE phObj);
492int shClSvcTransferIfaceGHObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj);
493int shClSvcTransferIfaceGHObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
494 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);
495int shClSvcTransferIfaceHGObjWrite(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
496 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);
497/** @} */
498
499/** @name Shared Clipboard transfer callbacks for the host service.
500 * @{
501 */
502DECLCALLBACK(void) VBoxSvcClipboardTransferPrepareCallback(PSHCLTXPROVIDERCTX pCtx);
503DECLCALLBACK(void) VBoxSvcClipboardDataHeaderCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
504DECLCALLBACK(void) VBoxSvcClipboardDataCompleteCallback(PSHCLTXPROVIDERCTX pCtx);
505DECLCALLBACK(void) VBoxSvcClipboardTransferCompleteCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
506DECLCALLBACK(void) VBoxSvcClipboardTransferCanceledCallback(PSHCLTXPROVIDERCTX pCtx);
507DECLCALLBACK(void) VBoxSvcClipboardTransferErrorCallback(PSHCLTXPROVIDERCTX pCtx, int rc);
508/** @} */
509#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS */
510
511/* Host unit testing interface */
512#ifdef UNIT_TEST
513uint32_t TestClipSvcGetMode(void);
514#endif
515
516#endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_internal_h */
517
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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