VirtualBox

source: vbox/trunk/include/VBox/GuestHost/SharedClipboard-transfers.h@ 99547

Last change on this file since 99547 was 99405, checked in by vboxsync, 2 years ago

Shared Clipboard/Transfers: Added ShClTransferCreateEx() and some defines for transfer defaults, more documentation for struct typedefs. bugref:9437
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 39.6 KB
Line 
1/* $Id: SharedClipboard-transfers.h 99405 2023-04-14 15:43:12Z vboxsync $ */
2/** @file
3 * Shared Clipboard - Shared transfer functions between host and guest.
4 */
5
6/*
7 * Copyright (C) 2019-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.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 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37#ifndef VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h
38#define VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h
39#ifndef RT_WITHOUT_PRAGMA_ONCE
40# pragma once
41#endif
42
43#include <map>
44
45#include <iprt/assert.h>
46#include <iprt/critsect.h>
47#include <iprt/fs.h>
48#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
49# include <iprt/http-server.h>
50#endif
51#include <iprt/list.h>
52
53#include <iprt/cpp/list.h>
54#include <iprt/cpp/ministring.h>
55
56#include <VBox/GuestHost/SharedClipboard.h>
57#include <VBox/HostServices/VBoxClipboardSvc.h>
58
59
60struct SHCLTRANSFER;
61/** Pointer to a single shared clipboard transfer. */
62typedef struct SHCLTRANSFER *PSHCLTRANSFER;
63
64
65/** @name Shared Clipboard transfer definitions.
66 * @{
67 */
68
69/** No Shared Clipboard listing feature flags defined. */
70#define SHCL_TRANSFER_LIST_FEATURE_F_NONE UINT32_C(0)
71/** Shared Clipboard feature flags valid mask. */
72#define SHCL_TRANSFER_LIST_FEATURE_F_VALID_MASK 0x0
73
74/** Defines the maximum length (in chars) a Shared Clipboard transfer path can have. */
75#define SHCL_TRANSFER_PATH_MAX RTPATH_MAX
76/** Defines the default maximum transfer chunk size (in bytes) of a Shared Clipboard transfer. */
77#define SHCL_TRANSFER_DEFAULT_MAX_CHUNK_SIZE _64K
78/** Defines the default maximum list handles a Shared Clipboard transfer can have. */
79#define SHCL_TRANSFER_DEFAULT_MAX_LIST_HANDLES _4K
80/** Defines the default maximum object handles a Shared Clipboard transfer can have. */
81#define SHCL_TRANSFER_DEFAULT_MAX_OBJ_HANDLES _4K
82
83/**
84 * Defines the transfer status codes.
85 */
86typedef enum
87{
88 /** No status set. */
89 SHCLTRANSFERSTATUS_NONE = 0,
90 /** The transfer has been initialized but is not running yet. */
91 SHCLTRANSFERSTATUS_INITIALIZED,
92 /** The transfer is active and running. */
93 SHCLTRANSFERSTATUS_STARTED,
94 /** The transfer has been stopped. */
95 SHCLTRANSFERSTATUS_STOPPED,
96 /** The transfer has been canceled. */
97 SHCLTRANSFERSTATUS_CANCELED,
98 /** The transfer has been killed. */
99 SHCLTRANSFERSTATUS_KILLED,
100 /** The transfer ran into an unrecoverable error. */
101 SHCLTRANSFERSTATUS_ERROR,
102 /** The usual 32-bit hack. */
103 SHCLTRANSFERSTATUS_32BIT_SIZE_HACK = 0x7fffffff
104} SHCLTRANSFERSTATUSENUM;
105
106/** Defines a transfer status. */
107typedef uint32_t SHCLTRANSFERSTATUS;
108
109/** @} */
110
111/** @name Shared Clipboard handles.
112 * @{
113 */
114
115/** A Shared Clipboard list handle. */
116typedef uint64_t SHCLLISTHANDLE;
117/** Pointer to a Shared Clipboard list handle. */
118typedef SHCLLISTHANDLE *PSHCLLISTHANDLE;
119/** Specifies an invalid Shared Clipboard list handle.
120 * @todo r=bird: The convention is NIL_SHCLLISTHANDLE. */
121#define SHCLLISTHANDLE_INVALID ((SHCLLISTHANDLE)UINT64_MAX)
122
123/** A Shared Clipboard object handle. */
124typedef uint64_t SHCLOBJHANDLE;
125/** Pointer to a Shared Clipboard object handle. */
126typedef SHCLOBJHANDLE *PSHCLOBJHANDLE;
127/** Specifies an invalid Shared Clipboard object handle.
128 * @todo r=bird: The convention is NIL_SHCLOBJHANDLE. */
129#define SHCLOBJHANDLE_INVALID ((SHCLOBJHANDLE)UINT64_MAX)
130
131/** @} */
132
133/** @name Shared Clipboard open/create flags.
134 * @{
135 */
136/** No flags. Initialization value. */
137#define SHCL_OBJ_CF_NONE UINT32_C(0x00000000)
138
139#if 0 /* These probably won't be needed either */
140/** Lookup only the object, do not return a handle. All other flags are ignored. */
141#define SHCL_OBJ_CF_LOOKUP UINT32_C(0x00000001)
142/** Create/open a directory. */
143#define SHCL_OBJ_CF_DIRECTORY UINT32_C(0x00000004)
144#endif
145
146/** Read/write requested access for the object. */
147#define SHCL_OBJ_CF_ACCESS_MASK_RW UINT32_C(0x00001000)
148/** No access requested. */
149#define SHCL_OBJ_CF_ACCESS_NONE UINT32_C(0x00000000)
150/** Read access requested. */
151#define SHCL_OBJ_CF_ACCESS_READ UINT32_C(0x00001000)
152
153/** Requested share access for the object. */
154#define SHCL_OBJ_CF_ACCESS_MASK_DENY UINT32_C(0x00008000)
155/** Allow any access. */
156#define SHCL_OBJ_CF_ACCESS_DENYNONE UINT32_C(0x00000000)
157/** Do not allow write. */
158#define SHCL_OBJ_CF_ACCESS_DENYWRITE UINT32_C(0x00008000)
159
160/** Requested access to attributes of the object. */
161#define SHCL_OBJ_CF_ACCESS_MASK_ATTR UINT32_C(0x00010000)
162/** No access requested. */
163#define SHCL_OBJ_CF_ACCESS_ATTR_NONE UINT32_C(0x00000000)
164/** Read access requested. */
165#define SHCL_OBJ_CF_ACCESS_ATTR_READ UINT32_C(0x00010000)
166
167/** Valid bits. */
168#define SHCL_OBJ_CF_VALID_MASK UINT32_C(0x00019000)
169/** @} */
170
171/**
172 * The available additional information in a SHCLFSOBJATTR object.
173 * @sa RTFSOBJATTRADD
174 */
175typedef enum _SHCLFSOBJATTRADD
176{
177 /** No additional information is available / requested. */
178 SHCLFSOBJATTRADD_NOTHING = 1,
179 /** The additional unix attributes (SHCLFSOBJATTR::u::Unix) are
180 * available / requested. */
181 SHCLFSOBJATTRADD_UNIX,
182 /** The additional extended attribute size (SHCLFSOBJATTR::u::EASize) is
183 * available / requested. */
184 SHCLFSOBJATTRADD_EASIZE,
185 /** The last valid item (inclusive).
186 * The valid range is SHCLFSOBJATTRADD_NOTHING thru
187 * SHCLFSOBJATTRADD_LAST. */
188 SHCLFSOBJATTRADD_LAST = SHCLFSOBJATTRADD_EASIZE,
189 /** The usual 32-bit hack. */
190 SHCLFSOBJATTRADD_32BIT_SIZE_HACK = 0x7fffffff
191} SHCLFSOBJATTRADD;
192
193
194/* Assert sizes of the IRPT types we're using below. */
195AssertCompileSize(RTFMODE, 4);
196AssertCompileSize(RTFOFF, 8);
197AssertCompileSize(RTINODE, 8);
198AssertCompileSize(RTTIMESPEC, 8);
199AssertCompileSize(RTDEV, 4);
200AssertCompileSize(RTUID, 4);
201
202/**
203 * Shared Clipboard filesystem object attributes.
204 *
205 * @sa RTFSOBJATTR
206 */
207typedef struct _SHCLFSOBJATTR
208{
209 /** Mode flags (st_mode). RTFS_UNIX_*, RTFS_TYPE_*, and RTFS_DOS_*.
210 * @remarks We depend on a number of RTFS_ defines to remain unchanged.
211 * Fortuntately, these are depending on windows, dos and unix
212 * standard values, so this shouldn't be much of a pain. */
213 RTFMODE fMode;
214
215 /** The additional attributes available. */
216 SHCLFSOBJATTRADD enmAdditional;
217
218 /**
219 * Additional attributes.
220 *
221 * Unless explicitly specified to an API, the API can provide additional
222 * data as it is provided by the underlying OS.
223 */
224 union SHCLFSOBJATTRUNION
225 {
226 /** Additional Unix Attributes
227 * These are available when SHCLFSOBJATTRADD is set in fUnix.
228 */
229 struct SHCLFSOBJATTRUNIX
230 {
231 /** The user owning the filesystem object (st_uid).
232 * This field is ~0U if not supported. */
233 RTUID uid;
234
235 /** The group the filesystem object is assigned (st_gid).
236 * This field is ~0U if not supported. */
237 RTGID gid;
238
239 /** Number of hard links to this filesystem object (st_nlink).
240 * This field is 1 if the filesystem doesn't support hardlinking or
241 * the information isn't available.
242 */
243 uint32_t cHardlinks;
244
245 /** The device number of the device which this filesystem object resides on (st_dev).
246 * This field is 0 if this information is not available. */
247 RTDEV INodeIdDevice;
248
249 /** The unique identifier (within the filesystem) of this filesystem object (st_ino).
250 * Together with INodeIdDevice, this field can be used as a OS wide unique id
251 * when both their values are not 0.
252 * This field is 0 if the information is not available. */
253 RTINODE INodeId;
254
255 /** User flags (st_flags).
256 * This field is 0 if this information is not available. */
257 uint32_t fFlags;
258
259 /** The current generation number (st_gen).
260 * This field is 0 if this information is not available. */
261 uint32_t GenerationId;
262
263 /** The device number of a character or block device type object (st_rdev).
264 * This field is 0 if the file isn't of a character or block device type and
265 * when the OS doesn't subscribe to the major+minor device idenfication scheme. */
266 RTDEV Device;
267 } Unix;
268
269 /**
270 * Extended attribute size.
271 */
272 struct SHCLFSOBJATTREASIZE
273 {
274 /** Size of EAs. */
275 RTFOFF cb;
276 } EASize;
277
278 /** Padding the structure to a multiple of 8 bytes. */
279 uint64_t au64Padding[5];
280 } u;
281} SHCLFSOBJATTR;
282AssertCompileSize(SHCLFSOBJATTR, 48);
283/** Pointer to a Shared Clipboard filesystem object attributes structure. */
284typedef SHCLFSOBJATTR *PSHCLFSOBJATTR;
285/** Pointer to a const Shared Clipboard filesystem object attributes structure. */
286typedef const SHCLFSOBJATTR *PCSHCLFSOBJATTR;
287
288/**
289 * Shared Clipboard file system object information structure.
290 *
291 * @sa RTFSOBJINFO
292 */
293typedef struct _SHCLFSOBJINFO
294{
295 /** Logical size (st_size).
296 * For normal files this is the size of the file.
297 * For symbolic links, this is the length of the path name contained
298 * in the symbolic link.
299 * For other objects this fields needs to be specified.
300 */
301 RTFOFF cbObject;
302
303 /** Disk allocation size (st_blocks * DEV_BSIZE). */
304 RTFOFF cbAllocated;
305
306 /** Time of last access (st_atime).
307 * @remarks Here (and other places) we depend on the IPRT timespec to
308 * remain unchanged. */
309 RTTIMESPEC AccessTime;
310
311 /** Time of last data modification (st_mtime). */
312 RTTIMESPEC ModificationTime;
313
314 /** Time of last status change (st_ctime).
315 * If not available this is set to ModificationTime.
316 */
317 RTTIMESPEC ChangeTime;
318
319 /** Time of file birth (st_birthtime).
320 * If not available this is set to ChangeTime.
321 */
322 RTTIMESPEC BirthTime;
323
324 /** Attributes. */
325 SHCLFSOBJATTR Attr;
326
327} SHCLFSOBJINFO;
328AssertCompileSize(SHCLFSOBJINFO, 96);
329/** Pointer to a Shared Clipboard filesystem object information structure. */
330typedef SHCLFSOBJINFO *PSHCLFSOBJINFO;
331/** Pointer to a const Shared Clipboard filesystem object information
332 * structure. */
333typedef const SHCLFSOBJINFO *PCSHCLFSOBJINFO;
334
335/**
336 * Structure for keeping object open/create parameters.
337 */
338typedef struct _SHCLOBJOPENCREATEPARMS
339{
340 /** Path to object to open / create. */
341 char *pszPath;
342 /** Size (in bytes) of path to to object. */
343 uint32_t cbPath;
344 /** SHCL_OBJ_CF_* */
345 uint32_t fCreate;
346 /**
347 * Attributes of object to open/create and
348 * returned actual attributes of opened/created object.
349 */
350 SHCLFSOBJINFO ObjInfo;
351} SHCLOBJOPENCREATEPARMS;
352/** Pointer to Shared Clipboard object open/create parameters. */
353typedef SHCLOBJOPENCREATEPARMS *PSHCLOBJOPENCREATEPARMS;
354
355/**
356 * Structure for keeping a reply message.
357 */
358typedef struct _SHCLREPLY
359{
360 /** Message type (of type VBOX_SHCL_REPLYMSGTYPE_TRANSFER_XXX). */
361 uint32_t uType;
362 /** IPRT result of overall operation. Note: int vs. uint32! */
363 uint32_t rc;
364 union
365 {
366 /** For VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS. */
367 struct
368 {
369 SHCLTRANSFERSTATUS uStatus;
370 } TransferStatus;
371 /** For VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN. */
372 struct
373 {
374 SHCLLISTHANDLE uHandle;
375 } ListOpen;
376 /** For VBOX_SHCL_REPLYMSGTYPE_LIST_CLOSE. */
377 struct
378 {
379 SHCLLISTHANDLE uHandle;
380 } ListClose;
381 /** For VBOX_SHCL_REPLYMSGTYPE_OBJ_OPEN. */
382 struct
383 {
384 SHCLOBJHANDLE uHandle;
385 } ObjOpen;
386 /** For VBOX_SHCL_REPLYMSGTYPE_OBJ_CLOSE. */
387 struct
388 {
389 SHCLOBJHANDLE uHandle;
390 } ObjClose;
391 } u;
392 /** Pointer to optional payload. */
393 void *pvPayload;
394 /** Payload size (in bytes). */
395 uint32_t cbPayload;
396} SHCLREPLY;
397/** Pointer to a Shared Clipboard reply. */
398typedef SHCLREPLY *PSHCLREPLY;
399
400struct _SHCLLISTENTRY;
401typedef _SHCLLISTENTRY SHCLLISTENTRY;
402
403/** Defines a single root list entry. Currently the same as a regular list entry. */
404typedef SHCLLISTENTRY SHCLROOTLISTENTRY;
405/** Defines a pointer to a single root list entry. Currently the same as a regular list entry pointer. */
406typedef SHCLROOTLISTENTRY *PSHCLROOTLISTENTRY;
407
408/**
409 * Structure for keeping Shared Clipboard root list headers.
410 */
411typedef struct _SHCLROOTLISTHDR
412{
413 /** Roots listing flags; unused at the moment. */
414 uint32_t fRoots;
415 /** Number of root list entries. */
416 uint32_t cRoots;
417} SHCLROOTLISTHDR;
418/** Pointer to a Shared Clipboard root list header. */
419typedef SHCLROOTLISTHDR *PSHCLROOTLISTHDR;
420
421/**
422 * Structure for maintaining a Shared Clipboard root list.
423 */
424typedef struct _SHCLROOTLIST
425{
426 /** Root list header. */
427 SHCLROOTLISTHDR Hdr;
428 /** Root list entries. */
429 SHCLROOTLISTENTRY *paEntries;
430} SHCLROOTLIST;
431/** Pointer to a Shared Clipboard root list. */
432typedef SHCLROOTLIST *PSHCLROOTLIST;
433
434/**
435 * Structure for maintaining Shared Clipboard list open parameters.
436 */
437typedef struct _SHCLLISTOPENPARMS
438{
439 /** Listing flags (see VBOX_SHCL_LIST_FLAG_XXX). */
440 uint32_t fList;
441 /** Size (in bytes) of the filter string. */
442 uint32_t cbFilter;
443 /** Filter string. DOS wilcard-style. */
444 char *pszFilter;
445 /** Size (in bytes) of the listing path. */
446 uint32_t cbPath;
447 /** Listing path (absolute). If empty or NULL the listing's root path will be opened. */
448 char *pszPath;
449} SHCLLISTOPENPARMS;
450/** Pointer to Shared Clipboard list open parameters. */
451typedef SHCLLISTOPENPARMS *PSHCLLISTOPENPARMS;
452
453/**
454 * Structure for keeping a Shared Clipboard list header.
455 */
456typedef struct _SHCLLISTHDR
457{
458 /** Feature flag(s) of type SHCL_TRANSFER_LIST_FEATURE_F_XXX. */
459 uint32_t fFeatures;
460 /** Total objects returned. */
461 uint64_t cTotalObjects;
462 /** Total size (in bytes) returned. */
463 uint64_t cbTotalSize;
464} SHCLLISTHDR;
465/** Pointer to a Shared Clipboard list header. */
466typedef SHCLLISTHDR *PSHCLLISTHDR;
467
468/**
469 * Structure for a Shared Clipboard list entry.
470 */
471typedef struct _SHCLLISTENTRY
472{
473 /** Entry name. */
474 char *pszName;
475 /** Size (in bytes) of entry name. */
476 uint32_t cbName;
477 /** Information flag(s). */
478 uint32_t fInfo;
479 /** Size (in bytes) of the actual list entry. */
480 uint32_t cbInfo;
481 /** Data of the actual list entry. */
482 void *pvInfo;
483} SHCLLISTENTRY;
484/** Pointer to a Shared Clipboard list entry. */
485typedef SHCLLISTENTRY *PSHCLLISTENTRY;
486
487/** Maximum length (in UTF-8 characters) of a list entry name. */
488#define SHCLLISTENTRY_MAX_NAME RTPATH_MAX /** @todo Improve this to be more dynamic. */
489
490/**
491 * Structure for maintaining a generic Shared Clipboard list.
492 */
493typedef struct _SHCLLIST
494{
495 /** List header. */
496 SHCLLISTHDR Hdr;
497 /** List entries. */
498 SHCLROOTLISTENTRY *paEntries;
499} SHCLLIST;
500/** Pointer to a Shared Clipboard transfer transfer list. */
501typedef SHCLLIST *PSHCLLIST;
502
503/**
504 * Structure for keeping a Shared Clipboard object data chunk.
505 */
506typedef struct _SHCLOBJDATACHUNK
507{
508 /** Handle of object this data chunk is related to. */
509 uint64_t uHandle;
510 /** Pointer to actual data chunk. */
511 void *pvData;
512 /** Size (in bytes) of data chunk. */
513 uint32_t cbData;
514} SHCLOBJDATACHUNK;
515/** Pointer to a Shared Clipboard transfer object data chunk. */
516typedef SHCLOBJDATACHUNK *PSHCLOBJDATACHUNK;
517
518/**
519 * Structure for handling a single transfer object context.
520 */
521typedef struct _SHCLCLIENTTRANSFEROBJCTX
522{
523 /** Pointer to the actual transfer object of this context. */
524 SHCLTRANSFER *pTransfer;
525 /** Object handle of this transfer context. */
526 SHCLOBJHANDLE uHandle;
527} SHCLCLIENTTRANSFEROBJCTX;
528/** Pointer to a Shared Clipboard transfer object context. */
529typedef SHCLCLIENTTRANSFEROBJCTX *PSHCLCLIENTTRANSFEROBJCTX;
530
531typedef struct _SHCLTRANSFEROBJSTATE
532{
533 /** How many bytes were processed (read / write) so far. */
534 uint64_t cbProcessed;
535} SHCLTRANSFEROBJSTATE;
536/** Pointer to a Shared Clipboard transfer object state. */
537typedef SHCLTRANSFEROBJSTATE *PSHCLTRANSFEROBJSTATE;
538
539/**
540 * Structure for a Shared Clipboard transfer object.
541 */
542typedef struct _SHCLTRANSFEROBJ
543{
544 /** Handle of the object. */
545 SHCLOBJHANDLE uHandle;
546 /** Absolute (local) path of the object. Source-style path. */
547 char *pszPathAbs;
548 /** Object information. */
549 SHCLFSOBJINFO objInfo;
550 /** Object type. */
551 SHCLSOURCE enmSource;
552 /** Current state. */
553 SHCLTRANSFEROBJSTATE State;
554} SHCLTRANSFEROBJ;
555/** Pointer to a Shared Clipboard transfer object. */
556typedef SHCLTRANSFEROBJ *PSHCLTRANSFEROBJ;
557
558/**
559 * Enumeration for specifying a Shared Clipboard object type.
560 */
561typedef enum _SHCLOBJTYPE
562{
563 /** Invalid object type. */
564 SHCLOBJTYPE_INVALID = 0,
565 /** Object is a directory. */
566 SHCLOBJTYPE_DIRECTORY,
567 /** Object is a file. */
568 SHCLOBJTYPE_FILE,
569 /** Object is a symbolic link. */
570 SHCLOBJTYPE_SYMLINK,
571 /** The usual 32-bit hack. */
572 SHCLOBJTYPE_32BIT_SIZE_HACK = 0x7fffffff
573} SHCLOBJTYPE;
574
575/**
576 * Structure for keeping transfer list handle information.
577 *
578 * This is using to map own (local) handles to the underlying file system.
579 */
580typedef struct _SHCLLISTHANDLEINFO
581{
582 /** The list node. */
583 RTLISTNODE Node;
584 /** The list's handle. */
585 SHCLLISTHANDLE hList;
586 /** Type of list handle. */
587 SHCLOBJTYPE enmType;
588 /** Absolute local path of the list object. */
589 char *pszPathLocalAbs;
590 union
591 {
592 /** Local data, based on enmType. */
593 struct
594 {
595 union
596 {
597 RTDIR hDir;
598 RTFILE hFile;
599 };
600 } Local;
601 } u;
602} SHCLLISTHANDLEINFO;
603/** Pointer to a Shared Clipboard transfer list handle info. */
604typedef SHCLLISTHANDLEINFO *PSHCLLISTHANDLEINFO;
605
606/**
607 * Structure for keeping transfer object handle information.
608 * This is using to map own (local) handles to the underlying file system.
609 */
610typedef struct _SHCLOBJHANDLEINFO
611{
612 /** The list node. */
613 RTLISTNODE Node;
614 /** The object's handle. */
615 SHCLOBJHANDLE hObj;
616 /** Type of object handle. */
617 SHCLOBJTYPE enmType;
618 /** Absolute local path of the object. */
619 char *pszPathLocalAbs;
620 /** Data union, based on \a enmType. */
621 union
622 {
623 /** Local data. */
624 struct
625 {
626 union
627 {
628 RTDIR hDir;
629 RTFILE hFile;
630 };
631 } Local;
632 } u;
633} SHCLOBJHANDLEINFO;
634/** Pointer to a Shared Clipboard transfer object handle. */
635typedef SHCLOBJHANDLEINFO *PSHCLOBJHANDLEINFO;
636
637/**
638 * Structure for keeping a single transfer root list entry.
639 */
640typedef struct _SHCLLISTROOT
641{
642 /** The list node. */
643 RTLISTNODE Node;
644 /** Absolute path of entry. */
645 char *pszPathAbs;
646} SHCLLISTROOT;
647/** Pointer to a Shared Clipboard transfer root list entry. */
648typedef SHCLLISTROOT *PSHCLLISTROOT;
649
650/**
651 * Structure for maintaining an Shared Clipboard transfer state.
652 * Everything in here will be part of a saved state (later).
653 */
654typedef struct _SHCLTRANSFERSTATE
655{
656 /** The transfer's (local) ID. */
657 SHCLTRANSFERID uID;
658 /** The transfer's current status. */
659 SHCLTRANSFERSTATUS enmStatus;
660 /** The transfer's direction, seen from the perspective who created the transfer. */
661 SHCLTRANSFERDIR enmDir;
662 /** The transfer's source, seen from the perspective who created the transfer. */
663 SHCLSOURCE enmSource;
664} SHCLTRANSFERSTATE;
665/** Pointer to a Shared Clipboard transfer state. */
666typedef SHCLTRANSFERSTATE *PSHCLTRANSFERSTATE;
667
668/**
669 * Structure maintaining clipboard transfer provider context data.
670 *
671 * This is handed-in to the provider interface implementations.
672 */
673typedef struct _SHCLTXPROVIDERCTX
674{
675 /** Pointer to the related Shared Clipboard transfer. */
676 PSHCLTRANSFER pTransfer;
677 /** User-defined data pointer. Can be NULL if not needed. */
678 void *pvUser;
679 /** Size (in bytes) of data at user pointer. */
680 size_t cbUser;
681} SHCLTXPROVIDERCTX;
682/** Pointer to Shared Clipboard transfer provider context data. */
683typedef SHCLTXPROVIDERCTX *PSHCLTXPROVIDERCTX;
684
685struct SHCLTRANSFERCTX;
686typedef struct SHCLTRANSFERCTX *PSHCLTRANSFERCTX;
687
688/**
689 * Shared Clipboard transfer provider interface table.
690 *
691 * A transfer provider inteface implementation realizes all low level functions
692 * needed for making a Shared Clipboard transfer happen.
693 */
694typedef struct _SHCLTXPROVIDERIFACE
695{
696 DECLCALLBACKMEMBER(int, pfnRootsGet,(PSHCLTXPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList));
697 DECLCALLBACKMEMBER(int, pfnListOpen,(PSHCLTXPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList));
698 DECLCALLBACKMEMBER(int, pfnListClose,(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList));
699 DECLCALLBACKMEMBER(int, pfnListHdrRead,(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr));
700 DECLCALLBACKMEMBER(int, pfnListHdrWrite,(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr));
701 DECLCALLBACKMEMBER(int, pfnListEntryRead,(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry));
702 DECLCALLBACKMEMBER(int, pfnListEntryWrite,(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry));
703 DECLCALLBACKMEMBER(int, pfnObjOpen,(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj));
704 DECLCALLBACKMEMBER(int, pfnObjClose,(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj));
705 DECLCALLBACKMEMBER(int, pfnObjRead,(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData,
706 uint32_t fFlags, uint32_t *pcbRead));
707 DECLCALLBACKMEMBER(int, pfnObjWrite,(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, void *pvData, uint32_t cbData,
708 uint32_t fFlags, uint32_t *pcbWritten));
709} SHCLTXPROVIDERIFACE;
710/** Pointer to a Shared Clipboard transfer provider interface table. */
711typedef SHCLTXPROVIDERIFACE *PSHCLTXPROVIDERIFACE;
712
713/**
714 * Structure for the Shared Clipboard transfer provider creation context.
715 */
716typedef struct _SHCLTXPROVIDERCREATIONCTX
717{
718 /** Specifies what the source of the provider is. */
719 SHCLSOURCE enmSource;
720 /** The provider interface table. */
721 SHCLTXPROVIDERIFACE Interface;
722 /** User-provided callback data. */
723 void *pvUser;
724 /** Size (in bytes) of data at user pointer. */
725 size_t cbUser;
726} SHCLTXPROVIDERCREATIONCTX;
727/** Pointer to a Shared Clipboard transfer provider creation context. */
728typedef SHCLTXPROVIDERCREATIONCTX *PSHCLTXPROVIDERCREATIONCTX;
729
730/**
731 * Structure maintaining clipboard transfer callback context data.
732 */
733typedef struct _SHCLTRANSFERCALLBACKCTX
734{
735 /** Pointer to the related Shared Clipboard transfer. */
736 PSHCLTRANSFER pTransfer;
737 /** User-defined data pointer. Can be NULL if not needed. */
738 void *pvUser;
739 /** Size (in bytes) of data at user pointer. */
740 size_t cbUser;
741} SHCLTRANSFERCALLBACKCTX;
742/** Pointer to a Shared Clipboard transfer callback context. */
743typedef SHCLTRANSFERCALLBACKCTX *PSHCLTRANSFERCALLBACKCTX;
744
745/**
746 * Shared Clipboard transfer callback table.
747 *
748 * All callbacks are optional and can provide additional information / feedback to a frontend.
749 */
750typedef struct _SHCLTRANSFERCALLBACKTABLE
751{
752 /**
753 * Called when the transfer gets initialized.
754 *
755 * @param pCbCtx Pointer to callback context to use.
756 */
757 DECLCALLBACKMEMBER(int, pfnOnInitialize,(PSHCLTRANSFERCALLBACKCTX pCbCtx));
758 /**
759 * Called before the transfer will be started.
760 *
761 * @param pCbCtx Pointer to callback context to use.
762 */
763 DECLCALLBACKMEMBER(int, pfnOnStart,(PSHCLTRANSFERCALLBACKCTX pCbCtx));
764 /**
765 * Called when the transfer has been complete.
766 *
767 * @param pCbCtx Pointer to callback context to use.
768 * @param rcCompletion Completion result.
769 * VERR_CANCELED if transfer has been canceled.
770 */
771 DECLCALLBACKMEMBER(void, pfnOnCompleted,(PSHCLTRANSFERCALLBACKCTX pCbCtx, int rcCompletion));
772 /**
773 * Called when transfer resulted in an unrecoverable error.
774 *
775 * @param pCbCtx Pointer to callback context to use.
776 * @param rcError Error reason, IPRT-style.
777 */
778 DECLCALLBACKMEMBER(void, pfnOnError,(PSHCLTRANSFERCALLBACKCTX pCbCtx, int rcError));
779 /**
780 * Called when transfer got registered to a transfer context.
781 *
782 * @param pCbCtx Pointer to callback context to use.
783 * @param pTransferCtx Transfer context transfer was registered to.
784 */
785 DECLCALLBACKMEMBER(void, pfnOnRegistered,(PSHCLTRANSFERCALLBACKCTX pCbCtx, PSHCLTRANSFERCTX pTransferCtx));
786 /**
787 * Called when transfer got unregistered from a transfer context.
788 *
789 * @param pCbCtx Pointer to callback context to use.
790 * @param pTransferCtx Transfer context transfer was unregistered from.
791 */
792 DECLCALLBACKMEMBER(void, pfnOnUnregistered,(PSHCLTRANSFERCALLBACKCTX pCbCtx, PSHCLTRANSFERCTX pTransferCtx));
793
794 /** User-provided callback data. Can be NULL if not used. */
795 void *pvUser;
796 /** Size (in bytes) of data pointer at \a pvUser. */
797 size_t cbUser;
798} SHCLTRANSFERCALLBACKTABLE;
799/** Pointer to a Shared Clipboard transfer callback table. */
800typedef SHCLTRANSFERCALLBACKTABLE *PSHCLTRANSFERCALLBACKTABLE;
801
802/**
803 * Structure for thread-related members for a single Shared Clipboard transfer.
804 */
805typedef struct _SHCLTRANSFERTHREAD
806{
807 /** Thread handle for the reading / writing thread.
808 * Can be NIL_RTTHREAD if not being used. */
809 RTTHREAD hThread;
810 /** Thread started indicator. */
811 volatile bool fStarted;
812 /** Thread stop flag. */
813 volatile bool fStop;
814 /** Thread cancelled flag / indicator. */
815 volatile bool fCancelled;
816} SHCLTRANSFERTHREAD;
817/** Pointer to a Shared Clipboard transfer thread. */
818typedef SHCLTRANSFERTHREAD *PSHCLTRANSFERTHREAD;
819
820/**
821 * A single Shared Clipboard transfer.
822 *
823 ** @todo Not yet thread safe.
824 */
825typedef struct SHCLTRANSFER
826{
827 /** The node member for using this struct in a RTList. */
828 RTLISTNODE Node;
829 /** The transfer's state (for SSM, later). */
830 SHCLTRANSFERSTATE State;
831 /** Absolute path to root entries. */
832 char *pszPathRootAbs;
833 /** Timeout (in ms) for waiting of events. Default is 30s. */
834 RTMSINTERVAL uTimeoutMs;
835 /** Maximum data chunk size (in bytes) to transfer. Default is 64K. */
836 uint32_t cbMaxChunkSize;
837 /** The transfer's own event source. */
838 SHCLEVENTSOURCE Events;
839 /** Current number of concurrent list handles. */
840 uint32_t cListHandles;
841 /** Maximum number of concurrent list handles. */
842 uint32_t cMaxListHandles;
843 /** Next upcoming list handle. */
844 SHCLLISTHANDLE uListHandleNext;
845 /** List of all list handles elated to this transfer. */
846 RTLISTANCHOR lstList;
847 /** Number of root entries in list. */
848 uint64_t cRoots;
849 /** List of root entries of this transfer. */
850 RTLISTANCHOR lstRoots;
851 /** Current number of concurrent object handles. */
852 uint32_t cObjHandles;
853 /** Maximum number of concurrent object handles. */
854 uint32_t cMaxObjHandles;
855 /** Next upcoming object handle. */
856 SHCLOBJHANDLE uObjHandleNext;
857 /** Map of all objects handles related to this transfer. */
858 RTLISTANCHOR lstObj;
859 /** The transfer's own provider context. */
860 SHCLTXPROVIDERCTX ProviderCtx;
861 /** The transfer's provider interface. */
862 SHCLTXPROVIDERIFACE ProviderIface;
863 /** The transfer's callback context. */
864 SHCLTRANSFERCALLBACKCTX CallbackCtx;
865 /** The transfer's callback table. */
866 SHCLTRANSFERCALLBACKTABLE Callbacks;
867 /** Opaque pointer to implementation-specific parameters. */
868 void *pvUser;
869 /** Size (in bytes) of implementation-specific parameters. */
870 size_t cbUser;
871 /** Contains thread-related attributes. */
872 SHCLTRANSFERTHREAD Thread;
873 /** Critical section for serializing access. */
874 RTCRITSECT CritSect;
875} SHCLTRANSFER;
876/** Pointer to a Shared Clipboard transfer. */
877typedef SHCLTRANSFER *PSHCLTRANSFER;
878
879/**
880 * Structure for keeping an Shared Clipboard transfer status report.
881 */
882typedef struct _SHCLTRANSFERREPORT
883{
884 /** Actual status to report. */
885 SHCLTRANSFERSTATUS uStatus;
886 /** Result code (rc) to report; might be unused / invalid, based on enmStatus. */
887 int rc;
888 /** Reporting flags. Currently unused and must be 0. */
889 uint32_t fFlags;
890} SHCLTRANSFERREPORT;
891/** Pointer to Shared Clipboard transfer status. */
892typedef SHCLTRANSFERREPORT *PSHCLTRANSFERREPORT;
893
894#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
895typedef struct _SHCLHTTPSERVER
896{
897 /** Critical section for serializing access. */
898 RTCRITSECT CritSect;
899 /** Handle of the HTTP server instance. */
900 RTHTTPSERVER hHTTPServer;
901 /** Port number the HTTP server is running on. 0 if not running. */
902 uint16_t uPort;
903 /** List of registered HTTP transfers. */
904 RTLISTANCHOR lstTransfers;
905 /** Number of registered HTTP transfers. */
906 uint32_t cTransfers;
907 /** Cached response data. */
908 RTHTTPSERVERRESP Resp;
909} SHCLHTTPSERVER;
910/** Pointer to Shared Clipboard HTTP server. */
911typedef SHCLHTTPSERVER *PSHCLHTTPSERVER;
912
913typedef struct _SHCLHTTPCONTEXT
914{
915 /** HTTP server instance data. */
916 SHCLHTTPSERVER HttpServer;
917} SHCLHTTPCONTEXT;
918/** Pointer to Shared Clipboard HTTP transfer context. */
919typedef SHCLHTTPCONTEXT *PSHCLHTTPCONTEXT;
920
921#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP */
922
923/**
924 * Structure for keeping Shared Clipboard transfer context around.
925 */
926struct SHCLTRANSFERCTX
927{
928 /** Critical section for serializing access. */
929 RTCRITSECT CritSect;
930 /** List of transfers. */
931 RTLISTANCHOR List;
932 /** Transfer ID allocation bitmap; clear bits are free, set bits are busy. */
933 uint64_t bmTransferIds[VBOX_SHCL_MAX_TRANSFERS / sizeof(uint64_t) / 8];
934 /** Number of running (concurrent) transfers. */
935 uint16_t cRunning;
936 /** Maximum Number of running (concurrent) transfers. */
937 uint16_t cMaxRunning;
938 /** Number of total transfers (in list). */
939 uint16_t cTransfers;
940#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
941 /** HTTP server instance for this transfer context. */
942 SHCLHTTPSERVER HttpServer;
943#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP */
944};
945
946int ShClTransferObjCtxInit(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
947void ShClTransferObjCtxDestroy(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
948bool ShClTransferObjCtxIsValid(PSHCLCLIENTTRANSFEROBJCTX pObjCtx);
949
950int ShClTransferObjHandleInfoInit(PSHCLOBJHANDLEINFO pInfo);
951void ShClTransferObjHandleInfoDestroy(PSHCLOBJHANDLEINFO pInfo);
952
953int ShClTransferObjOpenParmsInit(PSHCLOBJOPENCREATEPARMS pParms);
954int ShClTransferObjOpenParmsCopy(PSHCLOBJOPENCREATEPARMS pParmsDst, PSHCLOBJOPENCREATEPARMS pParmsSrc);
955void ShClTransferObjOpenParmsDestroy(PSHCLOBJOPENCREATEPARMS pParms);
956
957int ShClTransferObjOpen(PSHCLTRANSFER pTransfer, PSHCLOBJOPENCREATEPARMS pOpenCreateParms, PSHCLOBJHANDLE phObj);
958int ShClTransferObjClose(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj);
959int ShClTransferObjRead(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t fFlags, uint32_t *pcbRead);
960int ShClTransferObjWrite(PSHCLTRANSFER pTransfer, SHCLOBJHANDLE hObj, void *pvBuf, uint32_t cbBuf, uint32_t fFlags, uint32_t *pcbWritten);
961
962PSHCLOBJDATACHUNK ShClTransferObjDataChunkDup(PSHCLOBJDATACHUNK pDataChunk);
963void ShClTransferObjDataChunkDestroy(PSHCLOBJDATACHUNK pDataChunk);
964void ShClTransferObjDataChunkFree(PSHCLOBJDATACHUNK pDataChunk);
965
966int ShClTransferCreateEx(uint32_t cbMaxChunkSize, uint32_t cMaxListHandles, uint32_t cMaxObjHandles, PSHCLTRANSFER *ppTransfer);
967int ShClTransferCreate(PSHCLTRANSFER *ppTransfer);
968int ShClTransferInit(PSHCLTRANSFER pTransfer, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource);
969int ShClTransferDestroy(PSHCLTRANSFER pTransfer);
970
971int ShClTransferListOpen(PSHCLTRANSFER pTransfer, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList);
972int ShClTransferListClose(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
973int ShClTransferListGetHeader(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTHDR pHdr);
974PSHCLTRANSFEROBJ ShClTransferListGetObj(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, uint64_t uIdx);
975int ShClTransferListRead(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
976int ShClTransferListWrite(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList, PSHCLLISTENTRY pEntry);
977bool ShClTransferListHandleIsValid(PSHCLTRANSFER pTransfer, SHCLLISTHANDLE hList);
978
979int ShClPathSanitizeFilename(char *pszPath, size_t cbPath);
980int ShClPathSanitize(char *pszPath, size_t cbPath);
981
982PSHCLROOTLIST ShClTransferRootListAlloc(void);
983void ShClTransferRootListFree(PSHCLROOTLIST pRootList);
984
985PSHCLROOTLISTHDR ShClTransferRootListHdrDup(PSHCLROOTLISTHDR pRoots);
986int ShClTransferRootListHdrInit(PSHCLROOTLISTHDR pRoots);
987void ShClTransferRootListHdrDestroy(PSHCLROOTLISTHDR pRoots);
988
989int ShClTransferRootListEntryCopy(PSHCLROOTLISTENTRY pDst, PSHCLROOTLISTENTRY pSrc);
990int ShClTransferRootListEntryInit(PSHCLROOTLISTENTRY pRootListEntry);
991void ShClTransferRootListEntryDestroy(PSHCLROOTLISTENTRY pRootListEntry);
992PSHCLROOTLISTENTRY ShClTransferRootListEntryDup(PSHCLROOTLISTENTRY pRootListEntry);
993
994int ShClTransferListHandleInfoInit(PSHCLLISTHANDLEINFO pInfo);
995void ShClTransferListHandleInfoDestroy(PSHCLLISTHANDLEINFO pInfo);
996
997int ShClTransferListHdrAlloc(PSHCLLISTHDR *ppListHdr);
998void ShClTransferListHdrFree(PSHCLLISTHDR pListHdr);
999PSHCLLISTHDR ShClTransferListHdrDup(PSHCLLISTHDR pListHdr);
1000int ShClTransferListHdrInit(PSHCLLISTHDR pListHdr);
1001void ShClTransferListHdrDestroy(PSHCLLISTHDR pListHdr);
1002void ShClTransferListHdrReset(PSHCLLISTHDR pListHdr);
1003bool ShClTransferListHdrIsValid(PSHCLLISTHDR pListHdr);
1004
1005int ShClTransferListOpenParmsCopy(PSHCLLISTOPENPARMS pDst, PSHCLLISTOPENPARMS pSrc);
1006PSHCLLISTOPENPARMS ShClTransferListOpenParmsDup(PSHCLLISTOPENPARMS pParms);
1007int ShClTransferListOpenParmsInit(PSHCLLISTOPENPARMS pParms);
1008void ShClTransferListOpenParmsDestroy(PSHCLLISTOPENPARMS pParms);
1009
1010int ShClTransferListEntryAlloc(PSHCLLISTENTRY *ppListEntry);
1011void ShClTransferListEntryFree(PSHCLLISTENTRY pListEntry);
1012int ShClTransferListEntryCopy(PSHCLLISTENTRY pDst, PSHCLLISTENTRY pSrc);
1013PSHCLLISTENTRY ShClTransferListEntryDup(PSHCLLISTENTRY pListEntry);
1014int ShClTransferListEntryInit(PSHCLLISTENTRY pListEntry);
1015void ShClTransferListEntryDestroy(PSHCLLISTENTRY pListEntry);
1016bool ShClTransferListEntryIsValid(PSHCLLISTENTRY pListEntry);
1017
1018void ShClTransferCopyCallbacks(PSHCLTRANSFERCALLBACKTABLE pCallbacksDst, PSHCLTRANSFERCALLBACKTABLE pCallbacksSrc);
1019void ShClTransferSetCallbacks(PSHCLTRANSFER pTransfer, PSHCLTRANSFERCALLBACKTABLE pCallbacks);
1020int ShClTransferSetProviderIface(PSHCLTRANSFER pTransfer, PSHCLTXPROVIDERCREATIONCTX pCreationCtx);
1021int ShClTransferRootsSet(PSHCLTRANSFER pTransfer, const char *pszRoots, size_t cbRoots);
1022void ShClTransferReset(PSHCLTRANSFER pTransfer);
1023
1024uint32_t ShClTransferRootsCount(PSHCLTRANSFER pTransfer);
1025int ShClTransferRootsEntry(PSHCLTRANSFER pTransfer, uint64_t uIndex, PSHCLROOTLISTENTRY pEntry);
1026int ShClTransferRootsGet(PSHCLTRANSFER pTransfer, PSHCLROOTLIST *ppRootList);
1027
1028SHCLTRANSFERID ShClTransferGetID(PSHCLTRANSFER pTransfer);
1029SHCLTRANSFERDIR ShClTransferGetDir(PSHCLTRANSFER pTransfer);
1030SHCLSOURCE ShClTransferGetSource(PSHCLTRANSFER pTransfer);
1031SHCLTRANSFERSTATUS ShClTransferGetStatus(PSHCLTRANSFER pTransfer);
1032int ShClTransferRun(PSHCLTRANSFER pTransfer, PFNRTTHREAD pfnThreadFunc, void *pvUser);
1033int ShClTransferStart(PSHCLTRANSFER pTransfer);
1034
1035int ShClTransferCtxInit(PSHCLTRANSFERCTX pTransferCtx);
1036void ShClTransferCtxDestroy(PSHCLTRANSFERCTX pTransferCtx);
1037void ShClTransferCtxReset(PSHCLTRANSFERCTX pTransferCtx);
1038PSHCLTRANSFER ShClTransferCtxGetTransferById(PSHCLTRANSFERCTX pTransferCtx, uint32_t uID);
1039PSHCLTRANSFER ShClTransferCtxGetTransferByIndex(PSHCLTRANSFERCTX pTransferCtx, uint32_t uIdx);
1040uint32_t ShClTransferCtxGetRunningTransfers(PSHCLTRANSFERCTX pTransferCtx);
1041uint32_t ShClTransferCtxGetTotalTransfers(PSHCLTRANSFERCTX pTransferCtx);
1042void ShClTransferCtxCleanup(PSHCLTRANSFERCTX pTransferCtx);
1043bool ShClTransferCtxTransfersMaximumReached(PSHCLTRANSFERCTX pTransferCtx);
1044int ShClTransferCtxTransferRegister(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERID *pidTransfer);
1045int ShClTransferCtxTransferRegisterById(PSHCLTRANSFERCTX pTransferCtx, PSHCLTRANSFER pTransfer, SHCLTRANSFERID idTransfer);
1046int ShClTransferCtxTransferUnregister(PSHCLTRANSFERCTX pTransferCtx, SHCLTRANSFERID idTransfer);
1047
1048#ifdef VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP
1049int ShClHttpTransferRegister(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer);
1050int ShClHttpTransferUnregister(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer);
1051
1052int ShClTransferHttpServerCreate(PSHCLHTTPSERVER pSrv, uint16_t *puPort);
1053int ShClTransferHttpServerCreateEx(PSHCLHTTPSERVER pSrv, uint16_t uPort);
1054int ShClTransferHttpServerDestroy(PSHCLHTTPSERVER pSrv);
1055void ShClTransferHttpServerInit(PSHCLHTTPSERVER pSrv);
1056int ShClTransferHttpServerRegisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer);
1057int ShClTransferHttpServerUnregisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer);
1058bool ShClTransferHttpServerHasTransfer(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer);
1059uint16_t ShClTransferHttpServerGetPort(PSHCLHTTPSERVER pSrv);
1060uint32_t ShClTransferHttpServerGetTransferCount(PSHCLHTTPSERVER pSrv);
1061char *ShClTransferHttpServerGetAddressA(PSHCLHTTPSERVER pSrv);
1062char *ShClTransferHttpServerGetUrlA(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer);
1063bool ShClTransferHttpServerIsRunning(PSHCLHTTPSERVER pSrv);
1064#endif /* VBOX_WITH_SHARED_CLIPBOARD_TRANSFERS_HTTP */
1065
1066void ShClFsObjFromIPRT(PSHCLFSOBJINFO pDst, PCRTFSOBJINFO pSrc);
1067
1068bool ShClMIMEHasFileURLs(const char *pcszFormat, size_t cchFormatMax);
1069bool ShClMIMENeedsCache(const char *pcszFormat, size_t cchFormatMax);
1070
1071const char *ShClTransferStatusToStr(SHCLTRANSFERSTATUS enmStatus);
1072
1073#endif /* !VBOX_INCLUDED_GuestHost_SharedClipboard_transfers_h */
Note: See TracBrowser for help on using the repository browser.

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