clipboard-transfers-http.cpp@ 104305

最後變更在這個檔案從104305是 104305,由 vboxsync 提交於 12 月前
Shared Clipboard/transfers-http: Docs, made some functions inline. bugref:9437
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 47.8 KB

行
1	/* $Id: clipboard-transfers-http.cpp 104305 2024-04-12 08:29:33Z vboxsync $ */
2	/** @file
3	* Shared Clipboard: HTTP server implementation for Shared Clipboard transfers on UNIX-y guests / hosts.
4	*/
5
6	/*
7	* Copyright (C) 2020-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.alldomusa.eu.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <signal.h>
33
34	#include <iprt/http.h>
35	#include <iprt/http-server.h>
36
37	#include <iprt/net.h> /* To make use of IPv4Addr in RTGETOPTUNION. */
38
39	#include <iprt/asm.h>
40	#include <iprt/assert.h>
41	#include <iprt/ctype.h>
42	#include <iprt/errcore.h>
43	#include <iprt/file.h>
44	#include <iprt/getopt.h>
45	#include <iprt/initterm.h>
46	#include <iprt/list.h>
47	#include <iprt/mem.h>
48	#include <iprt/message.h>
49	#include <iprt/path.h>
50	#include <iprt/rand.h>
51	#include <iprt/semaphore.h>
52	#include <iprt/stream.h>
53	#include <iprt/string.h>
54	#include <iprt/thread.h>
55	#include <iprt/uri.h>
56	#include <iprt/uuid.h>
57	#include <iprt/vfs.h>
58
59	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
60	#include <iprt/log.h>
61
62	#include <VBox/HostServices/VBoxClipboardSvc.h>
63	#include <VBox/GuestHost/SharedClipboard-x11.h>
64	#include <VBox/GuestHost/SharedClipboard-transfers.h>
65
66
67	/*********************************************************************************************************************************
68	* Definitations *
69	*********************************************************************************************************************************/
70
71	#ifdef DEBUG_andy_0
72	/** When enabled, this lets the HTTP server run at a predictable URL and port for debugging:
73	* URL: http://localhost:49200/transfer<ID> */
74	# define VBOX_SHCL_DEBUG_HTTPSERVER
75	#endif
76
77	typedef struct _SHCLHTTPSERVERTRANSFER
78	{
79	/** The node list. */
80	RTLISTNODE Node;
81	/** Pointer to associated transfer. */
82	PSHCLTRANSFER pTransfer;
83	/** Critical section for serializing access. */
84	RTCRITSECT CritSect;
85	/** The handle we're going to use for this HTTP transfer. */
86	SHCLOBJHANDLE hObj;
87	/** The virtual path of the HTTP server's root directory for this transfer.
88	* Always has to start with a "/". Unescaped. */
89	char szPathVirtual[RTPATH_MAX];
90	} SHCLHTTPSERVERTRANSFER;
91	typedef SHCLHTTPSERVERTRANSFER *PSHCLHTTPSERVERTRANSFER;
92
93
94	/*********************************************************************************************************************************
95	* Prototypes *
96	*********************************************************************************************************************************/
97	static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pThis);
98	static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv);
99	static int shClTransferHttpServerDestroyTransfer(PSHCLHTTPSERVER pSrv, PSHCLHTTPSERVERTRANSFER pSrvTx);
100	static SHCLHTTPSERVERSTATUS shclTransferHttpServerSetStatusLocked(PSHCLHTTPSERVER pSrv, SHCLHTTPSERVERSTATUS fStatus);
101
102
103	/*********************************************************************************************************************************
104	* Static assets *
105	*********************************************************************************************************************************/
106
107	static char s_shClHttpServerPage404[] = " \
108	<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\" \
109	\"http://www.w3.org/TR/html4/strict.dtd\"> \
110	<html> \
111	<head> \
112	<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"> \
113	<title>VirtualBox Shared Clipboard</title> \
114	</head> \
115	<body> \
116	<h1>VirtualBox Shared Clipboard</h1> \
117	<p>Error: 404</p> \
118	<p>Message: Entry not found.</p> \
119	</body> \
120	</html>";
121
122
123	/*********************************************************************************************************************************
124	* Internal Shared Clipboard HTTP transfer functions *
125	*********************************************************************************************************************************/
126
127	/**
128	* Locks the critical section of a Shared Clipboard HTTP server instance.
129	*
130	* @param pSrv Shared Clipboard HTTP server instance to lock.
131	*/
132	DECLINLINE(void) shClTransferHttpServerLock(PSHCLHTTPSERVER pSrv)
133	{
134	int rc2 = RTCritSectEnter(&pSrv->CritSect);
135	AssertRC(rc2);
136	}
137
138	/**
139	* Unlocks the critical section of a Shared Clipboard HTTP server instance.
140	*
141	* @param pSrv Shared Clipboard HTTP server instance to unlock.
142	*/
143	DECLINLINE(void) shClTransferHttpServerUnlock(PSHCLHTTPSERVER pSrv)
144	{
145	int rc2 = RTCritSectLeave(&pSrv->CritSect);
146	AssertRC(rc2);
147	}
148
149	/**
150	* Locks an HTTP transfer.
151	*
152	* @param pSrvTx HTTP transfer to lock.
153	*/
154	DECLINLINE(void) shClHttpTransferLock(PSHCLHTTPSERVERTRANSFER pSrvTx)
155	{
156	int rc2 = RTCritSectEnter(&pSrvTx->CritSect);
157	AssertRC(rc2);
158	}
159
160	/**
161	* Unlocks an HTTP transfer.
162	*
163	* @param pSrvTx HTTP transfer to unlock.
164	*/
165	DECLINLINE(void) shClHttpTransferUnlock(PSHCLHTTPSERVERTRANSFER pSrvTx)
166	{
167	int rc2 = RTCritSectLeave(&pSrvTx->CritSect);
168	AssertRC(rc2);
169	}
170
171	/**
172	* Creates an URL from a given path, extended version.
173	*
174	* @returns VBox status code.
175	* @retval VERR_INVALID_PARAMETER if the path is not valid.
176	* @param pszPath Path to create URL for.
177	* @param ppszURL Where to return the allocated URL on success.
178	* @param pchScheme Where to return the size of the full HTTP scheme including "://". Optional and can be NULL.
179	* Right now this always is sizeof("http://").
180	*
181	* @note The path is not checked on file system level.
182	*/
183	static int shClTransferHttpURLCreateFromPathEx(const char pszPath, char ppszURL, size_t pchScheme)
184	{
185	AssertRCReturn(ShClTransferValidatePath(pszPath, false /* fMustExist */), VERR_INVALID_PARAMETER);
186
187	int rc = VINF_SUCCESS;
188
189	const char szScheme[] = "http://"; /** @todo For now we only support HTTP. */
190	const size_t cchScheme = strlen(szScheme);
191
192	char *pszURL = RTStrAPrintf2("%s%s", szScheme, pszPath);
193	if (pszURL)
194	{
195	AssertReturn(strlen(pszURL) > cchScheme, VERR_INVALID_PARAMETER);
196
197	*ppszURL = pszURL;
198	if (pchScheme)
199	*pchScheme = cchScheme;
200	}
201	else
202	rc = VERR_NO_MEMORY;
203
204	return rc;
205	}
206
207	/**
208	* Creates an URL from a given path.
209	*
210	* @returns VBox status code.
211	* @retval VERR_INVALID_PARAMETER if the path is not valid.
212	* @param pszPath Path to create URL for.
213	* @param ppszURL Where to return the allocated URL on success.
214	*
215	* @note The path is not checked on file system level.
216	*/
217	static int shClTransferHttpURLCreateFromPath(const char pszPath, char *ppszURL)
218	{
219	return shClTransferHttpURLCreateFromPathEx(pszPath, ppszURL, NULL /* pchScheme */);
220	}
221
222	/**
223	* Return the HTTP server transfer for a specific transfer ID.
224	*
225	* @returns Pointer to HTTP server transfer if found, NULL if not found.
226	* @param pSrv HTTP server instance.
227	* @param idTransfer Transfer ID to return HTTP server transfer for.
228	*/
229	DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpServerGetTransferById(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer)
230	{
231	PSHCLHTTPSERVERTRANSFER pSrvTx;
232	RTListForEach(&pSrv->lstTransfers, pSrvTx, SHCLHTTPSERVERTRANSFER, Node) /** @todo Slow O(n) lookup, but does it for now. */
233	{
234	if (pSrvTx->pTransfer->State.uID == idTransfer)
235	return pSrvTx;
236	}
237
238	return NULL;
239	}
240
241	/**
242	* Returns a HTTP server transfer from a given URL.
243	*
244	* @returns Pointer to HTTP server transfer if found, NULL if not found.
245	* @param pThis HTTP server instance data.
246	* @param pszUrl URL to validate.
247	*/
248	DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromUrl(PSHCLHTTPSERVER pThis, const char *pszUrl)
249	{
250	AssertPtrReturn(pszUrl, NULL);
251
252	PSHCLHTTPSERVERTRANSFER pSrvTx = NULL;
253
254	PSHCLHTTPSERVERTRANSFER pSrvTxCur;
255	RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node)
256	{
257	AssertPtr(pSrvTxCur->pTransfer);
258
259	LogFlowFunc(("pSrvTxCur=%s\n", pSrvTxCur->szPathVirtual));
260
261	/* Be picky here, do a case sensitive comparison. */
262	if (RTStrStartsWith(pszUrl, pSrvTxCur->szPathVirtual))
263	{
264	pSrvTx = pSrvTxCur;
265	break;
266	}
267	}
268
269	if (!pSrvTx)
270	LogRel2(("Shared Clipboard: HTTP URL '%s' not valid\n", pszUrl));
271
272	LogFlowFunc(("pszUrl=%s, pSrvTx=%p\n", pszUrl, pSrvTx));
273	return pSrvTx;
274	}
275
276	/**
277	* Returns a HTTP server transfer from an internal HTTP handle.
278	*
279	* @returns Pointer to HTTP server transfer if found, NULL if not found.
280	* @param pThis HTTP server instance data.
281	* @param pvHandle Handle to return transfer for.
282	*/
283	DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromHandle(PSHCLHTTPSERVER pThis, void *pvHandle)
284	{
285	AssertPtrReturn(pvHandle, NULL);
286
287	const SHCLTRANSFERID uHandle = (uint16_t )pvHandle;
288
289	/** @ŧodo Use a handle lookup table (map) later. */
290	PSHCLHTTPSERVERTRANSFER pSrvTxCur;
291	RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node)
292	{
293	AssertPtr(pSrvTxCur->pTransfer);
294
295	if (pSrvTxCur->pTransfer->State.uID == uHandle) /** @ŧodo We're using the transfer ID as handle for now. */
296	return pSrvTxCur;
297	}
298
299	return NULL;
300	}
301
302
303	/*********************************************************************************************************************************
304	* HTTP server callback implementations *
305	*********************************************************************************************************************************/
306
307	/** @copydoc RTHTTPSERVERCALLBACKS::pfnRequestBegin */
308	static DECLCALLBACK(int) shClTransferHttpBegin(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq)
309	{
310	PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; RT_NOREF(pThis);
311	Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
312
313	LogRel2(("Shared Clipboard: HTTP request begin\n"));
314
315	PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromUrl(pThis, pReq->pszUrl);
316	if (pSrvTx)
317	{
318	pReq->pvUser = pSrvTx;
319	}
320
321	return VINF_SUCCESS;
322	}
323
324	/** @copydoc RTHTTPSERVERCALLBACKS::pfnRequestEnd */
325	static DECLCALLBACK(int) shClTransferHttpEnd(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq)
326	{
327	PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; RT_NOREF(pThis);
328	Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
329
330	LogRel2(("Shared Clipboard: HTTP request end\n"));
331
332	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)pReq->pvUser;
333	if (pSrvTx)
334	{
335	pReq->pvUser = NULL;
336	}
337
338	return VINF_SUCCESS;
339
340	}
341
342	/** @copydoc RTHTTPSERVERCALLBACKS::pfnOpen */
343	static DECLCALLBACK(int) shClTransferHttpOpen(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq, void **ppvHandle)
344	{
345	PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser; RT_NOREF(pThis);
346	Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
347
348	int rc;
349
350	AssertPtr(pReq->pvUser);
351	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)pReq->pvUser;
352	if (pSrvTx)
353	{
354	LogRel2(("Shared Clipboard: HTTP transfer (handle %RU64) started ...\n", pSrvTx->hObj));
355
356	Assert(pSrvTx->hObj != NIL_SHCLOBJHANDLE);
357	*ppvHandle = &pSrvTx->hObj;
358	rc = VINF_SUCCESS;
359	}
360	else
361	rc = VERR_NOT_FOUND;
362
363	if (RT_FAILURE(rc))
364	LogRel(("Shared Clipboard: Error starting HTTP transfer for '%s', rc=%Rrc\n", pReq->pszUrl, rc));
365
366	LogFlowFuncLeaveRC(rc);
367	return rc;
368	}
369
370	/** @copydoc RTHTTPSERVERCALLBACKS::pfnRead */
371	static DECLCALLBACK(int) shClTransferHttpRead(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq,
372	void pvHandle, void pvBuf, size_t cbBuf, size_t *pcbRead)
373	{
374	RT_NOREF(pData);
375
376	if (pvHandle == NULL) /* Serve a 404 page if we got an invalid handle. */
377	{
378	Assert(cbBuf >= sizeof(s_shClHttpServerPage404)); /* Keep it simple for now. */
379	memcpy(pvBuf, &s_shClHttpServerPage404, RT_MIN(cbBuf, sizeof(s_shClHttpServerPage404)));
380	*pcbRead = sizeof(s_shClHttpServerPage404);
381	return VINF_SUCCESS;
382	}
383
384	int rc;
385
386	LogRel3(("Shared Clipboard: Reading %RU32 bytes from HTTP ...\n", cbBuf));
387
388	AssertPtr(pReq->pvUser);
389	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)pReq->pvUser;
390	if (pSrvTx)
391	{
392	PSHCLOBJHANDLE phObj = (PSHCLOBJHANDLE)pvHandle;
393	if (phObj)
394	{
395	uint32_t cbRead;
396	rc = ShClTransferObjRead(pSrvTx->pTransfer, phObj, pvBuf, cbBuf, 0 / fFlags */, &cbRead);
397	if (RT_SUCCESS(rc))
398	*pcbRead = (uint32_t)cbRead;
399
400	if (RT_FAILURE(rc))
401	LogRel(("Shared Clipboard: Error reading HTTP transfer (handle %RU64), rc=%Rrc\n", *phObj, rc));
402	}
403	else
404	rc = VERR_NOT_FOUND;
405	}
406	else
407	rc = VERR_NOT_FOUND;
408
409	LogFlowFuncLeaveRC(rc);
410	return rc;
411	}
412
413	/** @copydoc RTHTTPSERVERCALLBACKS::pfnClose */
414	static DECLCALLBACK(int) shClTransferHttpClose(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq, void *pvHandle)
415	{
416	RT_NOREF(pData);
417
418	int rc;
419
420	AssertPtr(pReq->pvUser);
421	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)pReq->pvUser;
422	if (pSrvTx)
423	{
424	PSHCLOBJHANDLE phObj = (PSHCLOBJHANDLE)pvHandle;
425	if (phObj)
426	{
427	Assert(*phObj != NIL_SHCLOBJHANDLE);
428	rc = ShClTransferObjClose(pSrvTx->pTransfer, *phObj);
429	if (RT_SUCCESS(rc))
430	{
431	pSrvTx->hObj = NIL_SHCLOBJHANDLE;
432	LogRel2(("Shared Clipboard: HTTP transfer %RU16 done\n", pSrvTx->pTransfer->State.uID));
433	}
434
435	if (RT_FAILURE(rc))
436	LogRel(("Shared Clipboard: Error closing HTTP transfer (handle %RU64), rc=%Rrc\n", *phObj, rc));
437	}
438	else
439	rc = VERR_NOT_FOUND;
440	}
441	else
442	rc = VERR_NOT_FOUND;
443
444	LogFlowFuncLeaveRC(rc);
445	return rc;
446	}
447
448	/** @copydoc RTHTTPSERVERCALLBACKS::pfnQueryInfo */
449	static DECLCALLBACK(int) shClTransferHttpQueryInfo(PRTHTTPCALLBACKDATA pData,
450	PRTHTTPSERVERREQ pReq, PRTFSOBJINFO pObjInfo, char **ppszMIMEHint)
451	{
452	RT_NOREF(pData);
453	RT_NOREF(ppszMIMEHint);
454
455	AssertReturn(RTStrIsValidEncoding(pReq->pszUrl), VERR_INVALID_PARAMETER);
456
457	LogRel2(("Shared Clipboard: HTTP query for '%s' ...\n", pReq->pszUrl));
458
459	char *pszUrl;
460	int rc = shClTransferHttpURLCreateFromPath(pReq->pszUrl, &pszUrl);
461	AssertRCReturn(rc, rc);
462
463	RTURIPARSED Parsed;
464	rc = RTUriParse(pszUrl, &Parsed);
465	if (RT_SUCCESS(rc))
466	{
467	char *pszPath = RTUriParsedPath(pszUrl, &Parsed);
468	AssertPtrReturn(pszPath, VERR_NO_MEMORY); /* Should be okay, as we succeeded RTUriParse() above. */
469	size_t const cchPath = strlen(pszPath);
470
471	/* For now we only know the transfer -- now we need to figure out the entry we want to serve. */
472	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)pReq->pvUser;
473	if (pSrvTx)
474	{
475	size_t const cchBase = strlen(pSrvTx->szPathVirtual) + 1 /* Skip slash separating the base from the rest */;
476	AssertReturn(cchPath >= cchBase, VERR_INVALID_PARAMETER);
477
478	SHCLOBJOPENCREATEPARMS openParms;
479	rc = ShClTransferObjOpenParmsInit(&openParms);
480	if (RT_SUCCESS(rc))
481	{
482	openParms.fCreate = SHCL_OBJ_CF_ACCESS_READ
483	\| SHCL_OBJ_CF_ACCESS_DENYWRITE;
484
485	PSHCLTRANSFER pTx = pSrvTx->pTransfer;
486	AssertPtr(pTx);
487
488	rc = VERR_NOT_FOUND; /* Must find the matching root entry first. */
489
490	uint64_t const cRoots = ShClTransferRootsCount(pTx);
491	for (uint32_t i = 0; i < cRoots; i++)
492	{
493	PCSHCLLISTENTRY pEntry = ShClTransferRootsEntryGet(pTx, i);
494	AssertPtrBreakStmt(pEntry, rc = VERR_NOT_FOUND);
495
496	Log3Func(("pszPath=%s vs. pEntry=%s\n", pszPath, pEntry->pszName));
497
498	if (RTStrCmp(pEntry->pszName, pszPath + cchBase)) /* Case-sensitive! */
499	continue;
500
501	rc = RTStrCopy(openParms.pszPath, openParms.cbPath, pEntry->pszName);
502	if (RT_SUCCESS(rc))
503	{
504	rc = ShClTransferObjOpen(pTx, &openParms, &pSrvTx->hObj);
505	if (RT_SUCCESS(rc))
506	{
507	rc = VERR_NOT_SUPPORTED; /* Play safe by default. */
508
509	if ( pEntry->fInfo & VBOX_SHCL_INFO_F_FSOBJINFO
510	&& pEntry->cbInfo == sizeof(SHCLFSOBJINFO))
511	{
512	PCSHCLFSOBJINFO pSrcObjInfo = (PSHCLFSOBJINFO)pEntry->pvInfo;
513
514	LogFlowFunc(("pszName=%s, cbInfo=%RU32, fMode=%#x (type %#x)\n",
515	pEntry->pszName, pEntry->cbInfo, pSrcObjInfo->Attr.fMode, (pSrcObjInfo->Attr.fMode & RTFS_TYPE_MASK)));
516
517	LogRel2(("Shared Clipboard: HTTP object info: fMode=%#x, cbObject=%zu\n", pSrcObjInfo->Attr.fMode, pSrcObjInfo->cbObject));
518
519	if (RTFS_IS_FILE(pSrcObjInfo->Attr.fMode))
520	{
521	memcpy(pObjInfo, pSrcObjInfo, sizeof(SHCLFSOBJINFO));
522	rc = VINF_SUCCESS;
523	}
524	}
525	else
526	LogRel2(("Shared Clipboard: Supplied entry information for '%s' not supported (fInfo=%#x, cbInfo=%RU32\n",
527	pEntry->pszName, pEntry->fInfo, pEntry->cbInfo));
528	}
529	/* Note: Directories are not supported here (yet) -- would require using WebDAV. */
530	}
531
532	break;
533	}
534
535	ShClTransferObjOpenParmsDestroy(&openParms);
536	}
537
538	RTStrFree(pszPath);
539	pszPath = NULL;
540	}
541	else
542	rc = VERR_NOT_FOUND;
543	}
544
545	RTStrFree(pszUrl);
546
547	if (RT_FAILURE(rc))
548	LogRel(("Shared Clipboard: Querying info for HTTP transfer failed with %Rrc\n", rc));
549
550	LogFlowFuncLeaveRC(rc);
551	return rc;
552	}
553
554
555	/*********************************************************************************************************************************
556	* Internal Shared Clipboard HTTP server functions *
557	*********************************************************************************************************************************/
558
559	/**
560	* Destroys a Shared Clipboard HTTP server instance, internal version.
561	*
562	* @returns VBox status code.
563	* @param pSrv Shared Clipboard HTTP server instance to destroy.
564	*
565	* @note Caller needs to take the critical section.
566	*/
567	static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pSrv)
568	{
569	Assert(RTCritSectIsOwner(&pSrv->CritSect));
570
571	LogFlowFuncEnter();
572
573	pSrv->fInitialized = false;
574	pSrv->fRunning = false;
575
576	int rc = VINF_SUCCESS;
577
578	PSHCLHTTPSERVERTRANSFER pSrvTx, pSrvTxNext;
579	RTListForEachSafe(&pSrv->lstTransfers, pSrvTx, pSrvTxNext, SHCLHTTPSERVERTRANSFER, Node)
580	{
581	int rc2 = shClTransferHttpServerDestroyTransfer(pSrv, pSrvTx);
582	if (RT_SUCCESS(rc))
583	rc = rc2;
584	}
585
586	RTHttpServerResponseDestroy(&pSrv->Resp);
587
588	pSrv->hHTTPServer = NIL_RTHTTPSERVER;
589
590	shClTransferHttpServerUnlock(pSrv); /* Unlock critical section taken by the caller before deleting it. */
591
592	if (RTCritSectIsInitialized(&pSrv->CritSect))
593	{
594	int rc2 = RTCritSectDelete(&pSrv->CritSect);
595	if (RT_SUCCESS(rc))
596	rc = rc2;
597	}
598
599	RTSemEventDestroy(pSrv->StatusEvent);
600	pSrv->StatusEvent = NIL_RTSEMEVENT;
601
602	LogFlowFuncLeaveRC(rc);
603	return rc;
604	}
605
606	/**
607	* Initializes a new Shared Clipboard HTTP server instance.
608	*
609	* @return VBox status code.
610	* @param pSrv HTTP server instance to initialize.
611	*/
612	static int shClTransferHttpServerInitInternal(PSHCLHTTPSERVER pSrv)
613	{
614	int rc = RTCritSectInit(&pSrv->CritSect);
615	AssertRCReturn(rc, rc);
616
617	rc = RTSemEventCreate(&pSrv->StatusEvent);
618	AssertRCReturn(rc, rc);
619
620	pSrv->hHTTPServer = NIL_RTHTTPSERVER;
621	pSrv->uPort = 0;
622	RTListInit(&pSrv->lstTransfers);
623	pSrv->cTransfers = 0;
624
625	rc = RTHttpServerResponseInit(&pSrv->Resp);
626	AssertRCReturn(rc, rc);
627
628	ASMAtomicXchgBool(&pSrv->fInitialized, true);
629	ASMAtomicXchgBool(&pSrv->fRunning, false);
630
631	return rc;
632	}
633
634
635	/*********************************************************************************************************************************
636	* Public Shared Clipboard HTTP server functions *
637	*********************************************************************************************************************************/
638
639	/**
640	* Initializes a new Shared Clipboard HTTP server instance.
641	*
642	* @return VBox status code.
643	* @param pSrv HTTP server instance to initialize.
644	*/
645	int ShClTransferHttpServerInit(PSHCLHTTPSERVER pSrv)
646	{
647	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
648
649	return shClTransferHttpServerInitInternal(pSrv);
650	}
651
652	/**
653	* Returns whether a given TCP port is known to be buggy or not.
654	*
655	* @returns \c true if the given port is known to be buggy, or \c false if not.
656	* @param uPort TCP port to check.
657	*/
658	static bool shClTransferHttpServerPortIsBuggy(uint16_t uPort)
659	{
660	uint16_t const aBuggyPorts[] = {
661	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS)
662	/* GNOME Nautilus ("Files") v43 is unable download HTTP files from this port. */
663	8080
664	#else /* Prevents zero-sized arrays. */
665	0
666	#endif
667	};
668
669	for (size_t i = 0; i < RT_ELEMENTS(aBuggyPorts); i++)
670	if (uPort == aBuggyPorts[i])
671	return true;
672	return false;
673	}
674
675	/**
676	* Starts the Shared Clipboard HTTP server instance, extended version.
677	*
678	* @returns VBox status code.
679	* @return VERR_ADDRESS_CONFLICT if the port is already taken or the port is known to be buggy.
680	* @param pSrv HTTP server instance to create.
681	* @param uPort TCP port number to use.
682	*/
683	int ShClTransferHttpServerStartEx(PSHCLHTTPSERVER pSrv, uint16_t uPort)
684	{
685	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
686	AssertReturn(uPort, VERR_INVALID_PARAMETER);
687
688	AssertReturn(!shClTransferHttpServerPortIsBuggy(uPort), VERR_ADDRESS_CONFLICT);
689
690	shClTransferHttpServerLock(pSrv);
691
692	RTHTTPSERVERCALLBACKS Callbacks;
693	RT_ZERO(Callbacks);
694
695	Callbacks.pfnRequestBegin = shClTransferHttpBegin;
696	Callbacks.pfnRequestEnd = shClTransferHttpEnd;
697	Callbacks.pfnOpen = shClTransferHttpOpen;
698	Callbacks.pfnRead = shClTransferHttpRead;
699	Callbacks.pfnClose = shClTransferHttpClose;
700	Callbacks.pfnQueryInfo = shClTransferHttpQueryInfo;
701
702	/* Note: The server always and only runs against the localhost interface. */
703	int rc = RTHttpServerCreate(&pSrv->hHTTPServer, "localhost", uPort, &Callbacks,
704	pSrv, sizeof(SHCLHTTPSERVER));
705	if (RT_SUCCESS(rc))
706	{
707	pSrv->uPort = uPort;
708	ASMAtomicXchgBool(&pSrv->fRunning, true);
709
710	LogRel2(("Shared Clipboard: HTTP server started at port %RU16\n", pSrv->uPort));
711
712	rc = shclTransferHttpServerSetStatusLocked(pSrv, SHCLHTTPSERVERSTATUS_STARTED);
713	}
714
715	shClTransferHttpServerUnlock(pSrv);
716
717	if (RT_FAILURE(rc))
718	LogRel(("Shared Clipboard: HTTP server failed to start, rc=%Rrc\n", rc));
719
720	return rc;
721	}
722
723	/**
724	* Returns a Shared Clipboard HTTP server status as a string.
725	*
726	* @returns Status as a string, or "Unknown" if invalid / unknown.
727	* @param enmStatus HTTP server status to return as a string.
728	*/
729	DECLINLINE(const char *) shClTransferHttpServerStatusToStr(SHCLHTTPSERVERSTATUS enmStatus)
730	{
731	switch (enmStatus)
732	{
733	RT_CASE_RET_STR(SHCLHTTPSERVERSTATUS_NONE);
734	RT_CASE_RET_STR(SHCLHTTPSERVERSTATUS_STARTED);
735	RT_CASE_RET_STR(SHCLHTTPSERVERSTATUS_STOPPED);
736	RT_CASE_RET_STR(SHCLHTTPSERVERSTATUS_TRANSFER_REGISTERED);
737	RT_CASE_RET_STR(SHCLHTTPSERVERSTATUS_TRANSFER_UNREGISTERED);
738	}
739
740	AssertFailedReturn("Unknown");
741	}
742
743	/**
744	* Starts the Shared Clipboard HTTP server instance using a random port (>= 49152).
745	*
746	* This does automatic probing of TCP ports if a port already is being used.
747	*
748	* @returns VBox status code.
749	* @param pSrv HTTP server instance to create.
750	* @param cMaxAttempts Maximum number of attempts to create a HTTP server.
751	* @param puPort Where to return the TCP port number being used on success. Optional.
752	*
753	* @note Complies with RFC 6335 (IANA).
754	*/
755	int ShClTransferHttpServerStart(PSHCLHTTPSERVER pSrv, unsigned cMaxAttempts, uint16_t *puPort)
756	{
757	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
758	AssertReturn(cMaxAttempts, VERR_INVALID_PARAMETER);
759	/* puPort is optional. */
760
761	int rc;
762	#ifdef VBOX_SHCL_DEBUG_HTTPSERVER
763	uint16_t uDebugPort = 49200;
764	rc = ShClTransferHttpServerStartEx(pSrv, (uint32_t)uDebugPort);
765	if (RT_SUCCESS(rc))
766	{
767	if (puPort)
768	*puPort = uDebugPort;
769	}
770	return rc;
771	#endif
772
773	RTRAND hRand;
774	rc = RTRandAdvCreateSystemFaster(&hRand); /* Should be good enough for this task. */
775	if (RT_SUCCESS(rc))
776	{
777	uint16_t uPort;
778	unsigned i = 0;
779	for (i; i < cMaxAttempts; i++)
780	{
781	/* Try some random ports >= 49152 (i.e. "dynamic ports", see RFC 6335)
782	* -- required, as VBoxClient runs as a user process on the guest. */
783	uPort = RTRandAdvU32Ex(hRand, 49152, UINT16_MAX);
784
785	/* If the port selected turns is known to be buggy for whatever reason, skip it and try another one. */
786	if (shClTransferHttpServerPortIsBuggy(uPort))
787	continue;
788
789	rc = ShClTransferHttpServerStartEx(pSrv, (uint32_t)uPort);
790	if (RT_SUCCESS(rc))
791	{
792	if (puPort)
793	*puPort = uPort;
794	break;
795	}
796	}
797
798	if ( RT_FAILURE(rc)
799	&& i == cMaxAttempts)
800	LogRel(("Shared Clipboard: Maximum attempts to start HTTP server reached (%u), giving up\n", cMaxAttempts));
801
802	RTRandAdvDestroy(hRand);
803	}
804
805	return rc;
806	}
807
808	/**
809	* Stops a Shared Clipboard HTTP server instance.
810	*
811	* @returns VBox status code.
812	* @param pSrv HTTP server instance to stop.
813	*/
814	int ShClTransferHttpServerStop(PSHCLHTTPSERVER pSrv)
815	{
816	LogFlowFuncEnter();
817
818	shClTransferHttpServerLock(pSrv);
819
820	int rc = VINF_SUCCESS;
821
822	if (pSrv->fRunning)
823	{
824	Assert(pSrv->hHTTPServer != NIL_RTHTTPSERVER);
825
826	rc = RTHttpServerDestroy(pSrv->hHTTPServer);
827	if (RT_SUCCESS(rc))
828	{
829	pSrv->hHTTPServer = NIL_RTHTTPSERVER;
830	pSrv->fRunning = false;
831
832	/* Let any eventual waiters know. */
833	shclTransferHttpServerSetStatusLocked(pSrv, SHCLHTTPSERVERSTATUS_STOPPED);
834
835	LogRel2(("Shared Clipboard: HTTP server stopped\n"));
836	}
837	}
838
839	if (RT_FAILURE(rc))
840	LogRel(("Shared Clipboard: HTTP server failed to stop, rc=%Rrc\n", rc));
841
842	shClTransferHttpServerUnlock(pSrv);
843
844	LogFlowFuncLeaveRC(rc);
845	return rc;
846	}
847
848	/**
849	* Destroys a Shared Clipboard HTTP server instance.
850	*
851	* @returns VBox status code.
852	* @param pSrv HTTP server instance to destroy.
853	*/
854	int ShClTransferHttpServerDestroy(PSHCLHTTPSERVER pSrv)
855	{
856	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
857
858	int rc = ShClTransferHttpServerStop(pSrv);
859	if (RT_FAILURE(rc))
860	return rc;
861
862	if (!ASMAtomicReadBool(&pSrv->fInitialized))
863	return VINF_SUCCESS;
864
865	shClTransferHttpServerLock(pSrv);
866
867	rc = shClTransferHttpServerDestroyInternal(pSrv);
868
869	/* Unlock not needed anymore, as the critical section got destroyed. */
870
871	return rc;
872	}
873
874	/**
875	* Returns the host name (scheme) of a HTTP server instance.
876	*
877	* @returns Host name (scheme).
878	* @param pSrv HTTP server instance to return host name (scheme) for.
879	*
880	* @note This is hardcoded to "localhost" for now.
881	*/
882	static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv)
883	{
884	RT_NOREF(pSrv);
885	return "http://localhost"; /* Hardcoded for now. */
886	}
887
888	/**
889	* Destroys a server transfer, internal version.
890	*
891	* @returns VBox status code.
892	* @param pSrv HTTP server instance to unregister transfer from.
893	* @param pSrvTx HTTP server transfer to destroy.
894	* The pointer will be invalid on success.
895	*
896	* @note Caller needs to take the server critical section.
897	*/
898	static int shClTransferHttpServerDestroyTransfer(PSHCLHTTPSERVER pSrv, PSHCLHTTPSERVERTRANSFER pSrvTx)
899	{
900	Assert(RTCritSectIsOwner(&pSrv->CritSect));
901
902	RTListNodeRemove(&pSrvTx->Node);
903
904	Assert(pSrv->cTransfers);
905	pSrv->cTransfers--;
906
907	LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n",
908	pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers));
909
910	LogRel2(("Shared Clipboard: Destroyed HTTP transfer %RU16, now %RU32 HTTP transfers total\n",
911	pSrvTx->pTransfer->State.uID, pSrv->cTransfers));
912
913	if (RTCritSectIsInitialized(&pSrvTx->CritSect))
914	{
915	int rc = RTCritSectDelete(&pSrvTx->CritSect);
916	AssertRCReturn(rc, rc);
917	}
918
919	RTMemFree(pSrvTx);
920	pSrvTx = NULL;
921
922	return VINF_SUCCESS;
923	}
924
925
926	/*********************************************************************************************************************************
927	* Public Shared Clipboard HTTP server functions *
928	*********************************************************************************************************************************/
929
930	/**
931	* Registers a Shared Clipboard transfer to a HTTP server instance.
932	*
933	* @returns VBox status code.
934	* @param pSrv HTTP server instance to register transfer for.
935	* @param pTransfer Transfer to register. Needs to be on the heap.
936	*/
937	int ShClTransferHttpServerRegisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer)
938	{
939	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
940	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
941
942	AssertMsgReturn(pTransfer->State.uID, ("Transfer needs to be registered with a transfer context first\n"),
943	VERR_INVALID_PARAMETER);
944
945	uint64_t const cRoots = ShClTransferRootsCount(pTransfer);
946	AssertMsgReturn(cRoots > 0, ("Transfer has no root entries\n"), VERR_INVALID_PARAMETER);
947	/** @todo Check for directories? */
948
949	shClTransferHttpServerLock(pSrv);
950
951	PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)RTMemAllocZ(sizeof(SHCLHTTPSERVERTRANSFER));
952	AssertPtrReturn(pSrvTx, VERR_NO_MEMORY);
953
954	RTUUID Uuid;
955	int rc = RTUuidCreate(&Uuid);
956	if (RT_SUCCESS(rc))
957	{
958	char szUuid[64];
959	rc = RTUuidToStr(&Uuid, szUuid, sizeof(szUuid));
960	if (RT_SUCCESS(rc))
961	{
962	rc = RTCritSectInit(&pSrvTx->CritSect);
963	AssertRCReturn(rc, rc);
964
965	/* Create the virtual HTTP path for the transfer.
966	* Every transfer has a dedicated HTTP path (but live in the same URL namespace). */
967	char *pszPath;
968	#ifdef VBOX_SHCL_DEBUG_HTTPSERVER
969	# ifdef DEBUG_andy /** Too lazy to specify a different transfer ID for debugging. */
970	ssize_t cch = RTStrAPrintf(&pszPath, "/transfer");
971	# else
972	ssize_t cch = RTStrAPrintf(&pszPath, "/transfer%RU16", pTransfer->State.uID);
973	# endif
974	#else /* Release mode */
975	ssize_t cch = RTStrAPrintf(&pszPath, "/%s/%s", SHCL_HTTPT_URL_NAMESPACE, szUuid);
976	#endif
977	AssertReturn(cch, VERR_NO_MEMORY);
978
979	char *pszURI;
980	size_t cchScheme;
981	rc = shClTransferHttpURLCreateFromPathEx(pszPath, &pszURI, &cchScheme);
982	if (RT_SUCCESS(rc))
983	{
984	/* For the virtual path we only keep everything after the full scheme (e.g. "http://").
985	* The virtual path always has to start with a "/". */
986	if (RTStrPrintf2(pSrvTx->szPathVirtual, sizeof(pSrvTx->szPathVirtual), "%s", pszURI + cchScheme) <= 0)
987	rc = VERR_BUFFER_OVERFLOW;
988
989	RTStrFree(pszURI);
990	pszURI = NULL;
991	}
992	else
993	rc = VERR_NO_MEMORY;
994
995	RTStrFree(pszPath);
996	pszPath = NULL;
997
998	if (RT_SUCCESS(rc))
999	{
1000	pSrvTx->pTransfer = pTransfer;
1001	pSrvTx->hObj = NIL_SHCLOBJHANDLE;
1002
1003	RTListAppend(&pSrv->lstTransfers, &pSrvTx->Node);
1004	pSrv->cTransfers++;
1005
1006	shclTransferHttpServerSetStatusLocked(pSrv, SHCLHTTPSERVERSTATUS_TRANSFER_REGISTERED);
1007
1008	LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n",
1009	pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers));
1010
1011	LogRel2(("Shared Clipboard: Registered HTTP transfer %RU16, now %RU32 HTTP transfers total\n",
1012	pTransfer->State.uID, pSrv->cTransfers));
1013	}
1014	}
1015
1016	}
1017
1018	if (RT_FAILURE(rc))
1019	RTMemFree(pSrvTx);
1020
1021	shClTransferHttpServerUnlock(pSrv);
1022
1023	LogFlowFuncLeaveRC(rc);
1024	return rc;
1025	}
1026
1027	/**
1028	* Unregisters a formerly registered Shared Clipboard transfer.
1029	*
1030	* @returns VBox status code.
1031	* @param pSrv HTTP server instance to unregister transfer from.
1032	* @param pTransfer Transfer to unregister.
1033	*/
1034	int ShClTransferHttpServerUnregisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer)
1035	{
1036	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
1037	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
1038
1039	shClTransferHttpServerLock(pSrv);
1040
1041	int rc = VINF_SUCCESS;
1042
1043	PSHCLHTTPSERVERTRANSFER pSrvTx, pSrvTxNext;
1044	RTListForEachSafe(&pSrv->lstTransfers, pSrvTx, pSrvTxNext, SHCLHTTPSERVERTRANSFER, Node)
1045	{
1046	AssertPtr(pSrvTx->pTransfer);
1047	if (pSrvTx->pTransfer->State.uID == pTransfer->State.uID)
1048	{
1049	rc = shClTransferHttpServerDestroyTransfer(pSrv, pSrvTx);
1050	if (RT_SUCCESS(rc))
1051	shclTransferHttpServerSetStatusLocked(pSrv, SHCLHTTPSERVERSTATUS_TRANSFER_UNREGISTERED);
1052	break;
1053	}
1054	}
1055
1056	shClTransferHttpServerUnlock(pSrv);
1057
1058	LogFlowFuncLeaveRC(rc);
1059	return rc;
1060	}
1061
1062	/**
1063	* Sets a new status.
1064	*
1065	* @returns New status set.
1066	* @param pSrv HTTP server instance to set status for.
1067	* @param fStatus New status to set.
1068	*
1069	* @note Caller needs to take critical section.
1070	*/
1071	static SHCLHTTPSERVERSTATUS shclTransferHttpServerSetStatusLocked(PSHCLHTTPSERVER pSrv, SHCLHTTPSERVERSTATUS enmStatus)
1072	{
1073	Assert(RTCritSectIsOwner(&pSrv->CritSect));
1074
1075	/* Bogus checks. */
1076	Assert(!(enmStatus & SHCLHTTPSERVERSTATUS_NONE) \|\| enmStatus == SHCLHTTPSERVERSTATUS_NONE);
1077
1078	pSrv->enmStatus = enmStatus;
1079	LogFlowFunc(("fStatus=%#x\n", pSrv->enmStatus));
1080
1081	int rc2 = RTSemEventSignal(pSrv->StatusEvent);
1082	AssertRC(rc2);
1083
1084	return pSrv->enmStatus;
1085	}
1086
1087	/**
1088	* Returns the first transfer in the list.
1089	*
1090	* @returns Pointer to first transfer if found, or NULL if not found.
1091	* @param pSrv HTTP server instance.
1092	*/
1093	PSHCLTRANSFER ShClTransferHttpServerGetTransferFirst(PSHCLHTTPSERVER pSrv)
1094	{
1095	shClTransferHttpServerLock(pSrv);
1096
1097	PSHCLHTTPSERVERTRANSFER pHttpTransfer = RTListGetFirst(&pSrv->lstTransfers, SHCLHTTPSERVERTRANSFER, Node);
1098
1099	shClTransferHttpServerUnlock(pSrv);
1100
1101	return pHttpTransfer ? pHttpTransfer->pTransfer : NULL;
1102	}
1103
1104	/**
1105	* Returns the last transfer in the list.
1106	*
1107	* @returns Pointer to last transfer if found, or NULL if not found.
1108	* @param pSrv HTTP server instance.
1109	*/
1110	PSHCLTRANSFER ShClTransferHttpServerGetTransferLast(PSHCLHTTPSERVER pSrv)
1111	{
1112	shClTransferHttpServerLock(pSrv);
1113
1114	PSHCLHTTPSERVERTRANSFER pHttpTransfer = RTListGetLast(&pSrv->lstTransfers, SHCLHTTPSERVERTRANSFER, Node);
1115
1116	shClTransferHttpServerUnlock(pSrv);
1117
1118	return pHttpTransfer ? pHttpTransfer->pTransfer : NULL;
1119	}
1120
1121	/**
1122	* Returns a transfer for a specific ID.
1123	*
1124	* @returns Pointer to the transfer if found, or NULL if not found.
1125	* @param pSrv HTTP server instance.
1126	* @param idTransfer Transfer ID of transfer to return..
1127	*/
1128	bool ShClTransferHttpServerGetTransfer(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer)
1129	{
1130	AssertPtrReturn(pSrv, false);
1131
1132	shClTransferHttpServerLock(pSrv);
1133
1134	PSHCLHTTPSERVERTRANSFER pTransfer = shClTransferHttpServerGetTransferById(pSrv, idTransfer);
1135
1136	shClTransferHttpServerUnlock(pSrv);
1137
1138	return pTransfer;
1139	}
1140
1141	/**
1142	* Returns the used TCP port number of a HTTP server instance.
1143	*
1144	* @returns TCP port number. 0 if not specified yet.
1145	* @param pSrv HTTP server instance to return port for.
1146	*/
1147	uint16_t ShClTransferHttpServerGetPort(PSHCLHTTPSERVER pSrv)
1148	{
1149	AssertPtrReturn(pSrv, 0);
1150
1151	shClTransferHttpServerLock(pSrv);
1152
1153	const uint16_t uPort = pSrv->uPort;
1154
1155	shClTransferHttpServerUnlock(pSrv);
1156
1157	return uPort;
1158	}
1159
1160	/**
1161	* Returns the number of registered HTTP server transfers of a HTTP server instance.
1162	*
1163	* @returns Number of registered transfers.
1164	* @param pSrv HTTP server instance to return registered transfers for.
1165	*/
1166	uint32_t ShClTransferHttpServerGetTransferCount(PSHCLHTTPSERVER pSrv)
1167	{
1168	AssertPtrReturn(pSrv, 0);
1169
1170	shClTransferHttpServerLock(pSrv);
1171
1172	const uint32_t cTransfers = pSrv->cTransfers;
1173	LogFlowFunc(("cTransfers=%RU32\n", cTransfers));
1174
1175	shClTransferHttpServerUnlock(pSrv);
1176
1177	return cTransfers;
1178	}
1179
1180	/**
1181	* Returns an allocated string with a HTTP server instance's address.
1182	*
1183	* @returns Allocated string with a HTTP server instance's address, or NULL on OOM.
1184	* Needs to be free'd by the caller using RTStrFree().
1185	* @param pSrv HTTP server instance to return address for.
1186	*/
1187	char *ShClTransferHttpServerGetAddressA(PSHCLHTTPSERVER pSrv)
1188	{
1189	AssertPtrReturn(pSrv, NULL);
1190
1191	shClTransferHttpServerLock(pSrv);
1192
1193	char *pszAddress = RTStrAPrintf2("%s:%RU16", shClTransferHttpServerGetHost(pSrv), pSrv->uPort);
1194	AssertPtr(pszAddress);
1195
1196	shClTransferHttpServerUnlock(pSrv);
1197
1198	return pszAddress;
1199	}
1200
1201	/**
1202	* Returns an allocated string with the URL of a given Shared Clipboard transfer ID.
1203	*
1204	* @returns Allocated string with the URL of a given Shared Clipboard transfer ID, or NULL if not found.
1205	* Needs to be free'd by the caller using RTStrFree().
1206	* @param pSrv HTTP server instance to return URL for.
1207	* @param idTransfer Transfer ID to return the URL for.
1208	* @param idxEntry Index of transfer entry to return URL for.
1209	* Specify UINT64_MAX to only return the base URL.
1210	*/
1211	char *ShClTransferHttpServerGetUrlA(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer, uint64_t idxEntry)
1212	{
1213	AssertPtrReturn(pSrv, NULL);
1214	AssertReturn(idTransfer != NIL_SHCLTRANSFERID, NULL);
1215
1216	shClTransferHttpServerLock(pSrv);
1217
1218	PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpServerGetTransferById(pSrv, idTransfer);
1219	if (!pSrvTx)
1220	{
1221	AssertFailed();
1222	shClTransferHttpServerUnlock(pSrv);
1223	return NULL;
1224	}
1225
1226	PSHCLTRANSFER pTx = pSrvTx->pTransfer;
1227	AssertPtr(pTx);
1228
1229	char *pszUrl = NULL;
1230
1231	if (RT_LIKELY(idxEntry != UINT64_MAX))
1232	{
1233	/* For now this only supports root entries. */
1234	PCSHCLLISTENTRY pEntry = ShClTransferRootsEntryGet(pTx, idxEntry);
1235	if (pEntry)
1236	{
1237	AssertReturn(RTStrNLen(pSrvTx->szPathVirtual, RTPATH_MAX), NULL);
1238	pszUrl = RTStrAPrintf2("%s:%RU16%s/%s", shClTransferHttpServerGetHost(pSrv), pSrv->uPort, pSrvTx->szPathVirtual, pEntry->pszName);
1239	}
1240	}
1241	else /* Only return the base. */
1242	pszUrl = RTStrAPrintf2("%s:%RU16%s", shClTransferHttpServerGetHost(pSrv), pSrv->uPort, pSrvTx->szPathVirtual);
1243
1244	shClTransferHttpServerUnlock(pSrv);
1245	return pszUrl;
1246	}
1247
1248	/**
1249	* Converts a HTTP transfer to a string list.
1250	*
1251	* @returns VBox status code.
1252	* @param pSrv HTTP server that contains the transfer.
1253	* @param pTransfer Transfer to convert data from.
1254	* @param pszSep Separator to use for the transfer entries.
1255	* @param ppszData Where to store the string list on success.
1256	* @param pcbData Where to return the bytes of \a ppszData on success.
1257	* Includes terminator. Optional.
1258	*/
1259	static int shClTransferHttpConvertToStringListEx(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer, const char *pszSep,
1260	char *ppszData, size_t pcbData)
1261	{
1262	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
1263	AssertPtrReturn(pszSep, VERR_INVALID_POINTER);
1264	AssertPtrReturn(ppszData, VERR_INVALID_POINTER);
1265	/* pcbData is optional. */
1266
1267	int rc = VINF_SUCCESS;
1268	char *pszData = NULL;
1269
1270	uint64_t const cRoots = ShClTransferRootsCount(pTransfer);
1271	for (uint32_t i = 0; i < cRoots; i++)
1272	{
1273	char pszEntry = ShClTransferHttpServerGetUrlA(pSrv, ShClTransferGetID(pTransfer), i / Entry index */);
1274	AssertPtrBreakStmt(pszEntry, rc = VERR_NO_MEMORY);
1275
1276	if (i > 0)
1277	{
1278	rc = RTStrAAppend(&pszData, pszSep); /* Separate entries with a newline. */
1279	AssertRCBreak(rc);
1280	}
1281
1282	rc = RTStrAAppend(&pszData, pszEntry);
1283	AssertRCBreak(rc);
1284
1285	RTStrFree(pszEntry);
1286	}
1287
1288	if (RT_FAILURE(rc))
1289	{
1290	RTStrFree(pszData);
1291	return rc;
1292	}
1293
1294	*ppszData = pszData;
1295	if (pcbData)
1296	pcbData = RTStrNLen(pszData, RTSTR_MAX) + 1 / Terminator. */;
1297
1298	return VINF_SUCCESS;
1299	}
1300
1301	/**
1302	* Converts a HTTP transfer to a string list.
1303	*
1304	* @returns VBox status code.
1305	* @param pSrv HTTP server that contains the transfer.
1306	* @param pTransfer Transfer to convert data from.
1307	* @param ppszData Where to store the string list on success.
1308	* @param pcbData Where to return the bytes of \a ppszData on success.
1309	* Includes terminator. Optional.
1310	*
1311	* @note Uses '\n' as the separator. @sa ShClTransferHttpConvertToStringListEx().
1312	*/
1313	int ShClTransferHttpConvertToStringList(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer, char *ppszData, size_t pcbData)
1314	{
1315	return shClTransferHttpConvertToStringListEx(pSrv, pTransfer, "\n", ppszData, pcbData);
1316	}
1317
1318	/**
1319	* Returns whether a given HTTP server instance is initialized or not.
1320	*
1321	* @returns \c true if running, or \c false if not.
1322	* @param pSrv HTTP server instance to check initialized state for.
1323	*/
1324	bool ShClTransferHttpServerIsInitialized(PSHCLHTTPSERVER pSrv)
1325	{
1326	AssertPtrReturn(pSrv, false);
1327
1328	return ASMAtomicReadBool(&pSrv->fInitialized);
1329	}
1330
1331	/**
1332	* Returns whether a given HTTP server instance is running or not.
1333	*
1334	* @returns \c true if running, or \c false if not.
1335	* @param pSrv HTTP server instance to check running state for.
1336	*/
1337	bool ShClTransferHttpServerIsRunning(PSHCLHTTPSERVER pSrv)
1338	{
1339	AssertPtrReturn(pSrv, false);
1340
1341	return ASMAtomicReadBool(&pSrv->fRunning);
1342	}
1343
1344	/**
1345	* Waits for a server status change.
1346	*
1347	* @returns VBox status code.
1348	* @retval VERR_STATE_CHANGED if the HTTP server was uninitialized.
1349	* @param pSrv HTTP server instance to wait for.
1350	* @param fStatus Status to wait for.
1351	* Multiple statuses are possible, @sa SHCLHTTPSERVERSTATUS.
1352	* @param msTimeout Timeout (in ms) to wait.
1353	*/
1354	int ShClTransferHttpServerWaitForStatusChange(PSHCLHTTPSERVER pSrv, SHCLHTTPSERVERSTATUS fStatus, RTMSINTERVAL msTimeout)
1355	{
1356	AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
1357	AssertMsgReturn(ASMAtomicReadBool(&pSrv->fInitialized), ("Server not initialized yet\n"), VERR_WRONG_ORDER);
1358
1359	shClTransferHttpServerLock(pSrv);
1360
1361	uint64_t const tsStartMs = RTTimeMilliTS();
1362
1363	int rc = VERR_TIMEOUT;
1364
1365	LogFlowFunc(("fStatus=%#x, msTimeout=%RU32 -- current is %#x\n", fStatus, msTimeout, pSrv->enmStatus));
1366
1367	while (RTTimeMilliTS() - tsStartMs <= msTimeout)
1368	{
1369	if (!pSrv->fInitialized)
1370	{
1371	rc = VERR_STATE_CHANGED;
1372	break;
1373	}
1374
1375	shClTransferHttpServerUnlock(pSrv); /* Leave lock before waiting. */
1376
1377	rc = RTSemEventWait(pSrv->StatusEvent, msTimeout);
1378
1379	shClTransferHttpServerLock(pSrv);
1380
1381	if (RT_FAILURE(rc))
1382	break;
1383
1384	LogFlowFunc(("Current status now is: %#x\n", pSrv->enmStatus));
1385	LogRel2(("Shared Clipboard: HTTP server entered status '%s'\n", shClTransferHttpServerStatusToStr(pSrv->enmStatus)));
1386
1387	if (pSrv->enmStatus & fStatus)
1388	{
1389	rc = VINF_SUCCESS;
1390	break;
1391	}
1392	}
1393
1394	shClTransferHttpServerUnlock(pSrv);
1395
1396	LogFlowFuncLeaveRC(rc);
1397	return rc;
1398	}
1399
1400
1401	/*********************************************************************************************************************************
1402	* Public Shared Clipboard HTTP context functions *
1403	*********************************************************************************************************************************/
1404
1405	/**
1406	* Starts the HTTP server, if not started already.
1407	*
1408	* @returns VBox status code.
1409	* @param pCtx HTTP context to start HTTP server for.
1410	*/
1411	int ShClTransferHttpServerMaybeStart(PSHCLHTTPCONTEXT pCtx)
1412	{
1413	int rc = VINF_SUCCESS;
1414
1415	LogFlowFuncEnter();
1416
1417	/* Start the built-in HTTP server to serve file(s). */
1418	if (!ShClTransferHttpServerIsRunning(&pCtx->HttpServer)) /* Only one HTTP server per transfer context. */
1419	rc = ShClTransferHttpServerStart(&pCtx->HttpServer, 32 /* cMaxAttempts /, NULL / puPort */);
1420
1421	LogFlowFuncLeaveRC(rc);
1422	return rc;
1423	}
1424
1425	/**
1426	* Stops the HTTP server, if no running transfers are left.
1427	*
1428	* @returns VBox status code.
1429	* @param pCtx HTTP context to stop HTTP server for.
1430	*/
1431	int ShClTransferHttpServerMaybeStop(PSHCLHTTPCONTEXT pCtx)
1432	{
1433	int rc = VINF_SUCCESS;
1434
1435	LogFlowFuncEnter();
1436
1437	if (ShClTransferHttpServerIsRunning(&pCtx->HttpServer))
1438	{
1439	/* No more registered transfers left? Tear down the HTTP server instance then. */
1440	if (ShClTransferHttpServerGetTransferCount(&pCtx->HttpServer) == 0)
1441	rc = ShClTransferHttpServerStop(&pCtx->HttpServer);
1442	}
1443
1444	LogFlowFuncLeaveRC(rc);
1445	return rc;
1446	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/GuestHost/SharedClipboard/clipboard-transfers-http.cpp@ 104305

以其他格式下載: