SharedClipboard-transfers.h@ 81223

Last change on this file since 81223 was 81223, checked in by vboxsync, 5 years ago
Shared Clipboard/Transfers: Renaming.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 40.8 KB

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

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

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

Download in other formats: