SharedClipboard-transfers.h@ 80886

Last change on this file since 80886 was 80886, checked in by vboxsync, 5 years ago
Shared Clipboard/Transfers: More renaming, fixed some assertions.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 41.4 KB

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

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

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

Download in other formats: