SharedClipboard-transfers.h@ 82490

Last change on this file since 82490 was 82490, checked in by vboxsync, 5 years ago
VBox/GuestHost/SharedClipboard-transfers.h: Just use DECLCALLBACKMEMBER for SHCLTRANSFERCALLBACKS. bugref:9437
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 37.8 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: