VirtualBox

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

Last change on this file since 87621 was 87454, checked in by vboxsync, 4 years ago

Shared Clipboard/Transfers: More code for HTTP transfers [build fix]. bugref:9437
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 26.9 KB
Line 
1/* $Id: clipboard-transfers-http.cpp 87454 2021-01-27 18:31:48Z 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 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
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <signal.h>
23
24#include <iprt/http.h>
25#include <iprt/http-server.h>
26
27#include <iprt/net.h> /* To make use of IPv4Addr in RTGETOPTUNION. */
28
29#include <iprt/asm.h>
30#include <iprt/assert.h>
31#include <iprt/ctype.h>
32#include <iprt/errcore.h>
33#include <iprt/file.h>
34#include <iprt/getopt.h>
35#include <iprt/initterm.h>
36#include <iprt/list.h>
37#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
38#include <iprt/log.h>
39#include <iprt/mem.h>
40#include <iprt/message.h>
41#include <iprt/path.h>
42#include <iprt/rand.h>
43#include <iprt/stream.h>
44#include <iprt/string.h>
45#include <iprt/thread.h>
46#include <iprt/uuid.h>
47#include <iprt/vfs.h>
48
49#include <VBox/HostServices/VBoxClipboardSvc.h>
50#include <VBox/GuestHost/SharedClipboard-x11.h>
51#include <VBox/GuestHost/SharedClipboard-transfers.h>
52
53
54/*********************************************************************************************************************************
55* Definitations *
56*********************************************************************************************************************************/
57
58typedef struct _SHCLHTTPSERVERTRANSFER
59{
60 /** The node list. */
61 RTLISTNODE Node;
62 /** Pointer to associated transfer. */
63 PSHCLTRANSFER pTransfer;
64 /** The (cached) root list of the transfer. NULL if not cached yet. */
65 PSHCLROOTLIST pRootList;
66 /** Critical section for serializing access. */
67 RTCRITSECT CritSect;
68 /** The handle we're going to use for this HTTP transfer. */
69 SHCLOBJHANDLE hObj;
70 /** The virtual path of the HTTP server's root directory for this transfer. */
71 char szPathVirtual[RTPATH_MAX];
72} SHCLHTTPSERVERTRANSFER;
73typedef SHCLHTTPSERVERTRANSFER *PSHCLHTTPSERVERTRANSFER;
74
75
76/*********************************************************************************************************************************
77* Prototypes *
78*********************************************************************************************************************************/
79static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pThis);
80static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv);
81
82
83/*********************************************************************************************************************************
84* Public Shared Clipboard HTTP transfer functions *
85*********************************************************************************************************************************/
86
87int ShClHttpTransferCreate(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer)
88{
89 int rc = VINF_SUCCESS;
90
91 /* Start the built-in HTTP server to serve file(s). */
92 if (!ShClTransferHttpServerIsRunning(&pCtx->HttpServer)) /* Only one HTTP server per transfer context. */
93 rc = ShClTransferHttpServerCreate(&pCtx->HttpServer, NULL /* puPort */);
94
95 if (RT_SUCCESS(rc))
96 rc = ShClTransferHttpServerRegisterTransfer(&pCtx->HttpServer, pTransfer);
97
98 return rc;
99}
100
101int ShClHttpTransferDestroy(PSHCLHTTPCONTEXT pCtx, PSHCLTRANSFER pTransfer)
102{
103 int rc = VINF_SUCCESS;
104
105 if (ShClTransferHttpServerIsRunning(&pCtx->HttpServer))
106 {
107 /* Try unregistering transfer (if it was registered before). */
108 rc = ShClTransferHttpServerUnregisterTransfer(&pCtx->HttpServer, pTransfer);
109 if (RT_SUCCESS(rc))
110 {
111 /* No more registered transfers left? Tear down the HTTP server instance then. */
112 if (ShClTransferHttpServerGetTransferCount(&pCtx->HttpServer) == 0)
113 rc = ShClTransferHttpServerDestroy(&pCtx->HttpServer);
114 }
115 AssertRC(rc);
116 }
117
118 return rc;
119}
120
121
122/*********************************************************************************************************************************
123* Internal Shared Clipboard HTTP transfer functions *
124*********************************************************************************************************************************/
125
126DECLINLINE(void) shClHttpTransferLock(PSHCLHTTPSERVERTRANSFER pSrvTx)
127{
128 int rc2 = RTCritSectEnter(&pSrvTx->CritSect);
129 AssertRC(rc2);
130}
131
132DECLINLINE(void) shClHttpTransferUnlock(PSHCLHTTPSERVERTRANSFER pSrvTx)
133{
134 int rc2 = RTCritSectEnter(&pSrvTx->CritSect);
135 AssertRC(rc2);
136}
137
138/**
139 * Return the HTTP server transfer for a specific transfer ID.
140 *
141 * @returns Pointer to HTTP server transfer if found, NULL if not found.
142 * @param pSrv HTTP server instance.
143 * @param idTransfer Transfer ID to return HTTP server transfer for.
144 */
145static PSHCLHTTPSERVERTRANSFER shClTransferHttpServerGetTransferById(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer)
146{
147 PSHCLHTTPSERVERTRANSFER pSrvTx;
148 RTListForEach(&pSrv->lstTransfers, pSrvTx, SHCLHTTPSERVERTRANSFER, Node) /** @todo Slow O(n) lookup, but does it for now. */
149 {
150 if (pSrvTx->pTransfer->State.uID == idTransfer)
151 return pSrvTx;
152 }
153
154 return NULL;
155}
156
157/**
158 * Returns a HTTP server transfer from a given URL.
159 *
160 * @returns Pointer to HTTP server transfer if found, NULL if not found.
161 * @param pThis HTTP server instance data.
162 * @param pszUrl URL to validate.
163 */
164DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromUrl(PSHCLHTTPSERVER pThis, const char *pszUrl)
165{
166 AssertPtrReturn(pszUrl, NULL);
167
168 PSHCLHTTPSERVERTRANSFER pSrvTx = NULL;
169
170 PSHCLHTTPSERVERTRANSFER pSrvTxCur;
171 RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node)
172 {
173 AssertPtr(pSrvTxCur->pTransfer);
174
175 LogFlowFunc(("pSrvTxCur=%s\n", pSrvTxCur->szPathVirtual));
176
177 /* Be picky here, do a case sensitive comparison. */
178 if (RTStrStartsWith(pszUrl, pSrvTxCur->szPathVirtual))
179 {
180 pSrvTx = pSrvTxCur;
181 break;
182 }
183 }
184
185 if (!pSrvTx)
186 LogRel2(("Shared Clipboard: HTTP URL '%s' not valid\n", pszUrl));
187
188 LogFlowFunc(("pszUrl=%s, pSrvTx=%p\n", pszUrl, pSrvTx));
189 return pSrvTx;
190}
191
192/**
193 * Returns a HTTP server transfer from an internal HTTP handle.
194 *
195 * @returns Pointer to HTTP server transfer if found, NULL if not found.
196 * @param pThis HTTP server instance data.
197 * @param pvHandle Handle to return transfer for.
198 */
199DECLINLINE(PSHCLHTTPSERVERTRANSFER) shClTransferHttpGetTransferFromHandle(PSHCLHTTPSERVER pThis, void *pvHandle)
200{
201 AssertPtrReturn(pvHandle, NULL);
202
203 const SHCLTRANSFERID uHandle = *(uint16_t *)pvHandle;
204
205 /** @ŧodo Use a handle lookup table (map) later. */
206 PSHCLHTTPSERVERTRANSFER pSrvTxCur;
207 RTListForEach(&pThis->lstTransfers, pSrvTxCur, SHCLHTTPSERVERTRANSFER, Node)
208 {
209 AssertPtr(pSrvTxCur->pTransfer);
210
211 if (pSrvTxCur->pTransfer->State.uID == uHandle) /** @ŧodo We're using the transfer ID as handle for now. */
212 return pSrvTxCur;
213 }
214
215 return NULL;
216}
217
218static int shClTransferHttpGetTransferRoots(PSHCLHTTPSERVER pThis, PSHCLHTTPSERVERTRANSFER pSrvTx)
219{
220 RT_NOREF(pThis);
221
222 int rc = VINF_SUCCESS;
223
224 if (pSrvTx->pRootList == NULL)
225 {
226 AssertPtr(pSrvTx->pTransfer);
227 rc = ShClTransferRootsGet(pSrvTx->pTransfer, &pSrvTx->pRootList);
228 }
229
230 return rc;
231}
232
233
234/*********************************************************************************************************************************
235* HTTP server callback implementations *
236*********************************************************************************************************************************/
237
238/** @copydoc RTHTTPSERVERCALLBACKS::pfnOpen */
239static DECLCALLBACK(int) shClTransferHttpOpen(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq, void **ppvHandle)
240{
241 PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser;
242 Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
243
244 int rc;
245
246 PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromUrl(pThis, pReq->pszUrl);
247 if (pSrvTx)
248 {
249 shClHttpTransferLock(pSrvTx);
250
251 AssertPtr(pSrvTx->pTransfer);
252
253 SHCLOBJOPENCREATEPARMS openParms;
254 rc = ShClTransferObjOpenParmsInit(&openParms);
255 if (RT_SUCCESS(rc))
256 {
257 openParms.fCreate = SHCL_OBJ_CF_ACCESS_READ
258 | SHCL_OBJ_CF_ACCESS_DENYWRITE;
259
260 rc = RTStrCopy(openParms.pszPath, openParms.cbPath, "foo"); /** @ŧodo BUGBUG !!!! */
261 if (RT_SUCCESS(rc))
262 {
263 rc = ShClTransferObjOpen(pSrvTx->pTransfer, &openParms, &pSrvTx->hObj);
264 if (RT_SUCCESS(rc))
265 {
266 *ppvHandle = &pSrvTx->hObj;
267 LogRel2(("Shared Clipboard: HTTP transfer (handle %RU64) started ...\n", pSrvTx->hObj));
268 }
269 }
270
271 ShClTransferObjOpenParmsDestroy(&openParms);
272 }
273
274 shClHttpTransferUnlock(pSrvTx);
275 }
276 else
277 rc = VERR_NOT_FOUND;
278
279 if (RT_FAILURE(rc))
280 LogRel(("Shared Clipboard: Error starting HTTP transfer for '%s', rc=%Rrc\n", pReq->pszUrl, rc));
281
282 LogFlowFuncLeaveRC(rc);
283 return rc;
284}
285
286/** @copydoc RTHTTPSERVERCALLBACKS::pfnRead */
287static DECLCALLBACK(int) shClTransferHttpRead(PRTHTTPCALLBACKDATA pData, void *pvHandle, void *pvBuf, size_t cbBuf, size_t *pcbRead)
288{
289 PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser;
290 Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
291
292 RT_NOREF(pvBuf, cbBuf, pcbRead);
293
294 int rc;
295
296 PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromHandle(pThis, pvHandle);
297 if (pSrvTx)
298 {
299 Assert(pSrvTx->hObj != SHCLOBJHANDLE_INVALID);
300// rc = ShClTransferObjRead(pSrvTx->pTransfer, pSrvTx->hObj, );
301rc = 0;
302 if (RT_SUCCESS(rc))
303 {
304
305 }
306
307 if (RT_FAILURE(rc))
308 LogRel(("Shared Clipboard: Error reading HTTP transfer (handle %RU64), rc=%Rrc\n", pSrvTx->hObj, rc));
309 }
310 else
311 rc = VERR_NOT_FOUND;
312
313 LogFlowFuncLeaveRC(rc);
314 return rc;
315}
316
317/** @copydoc RTHTTPSERVERCALLBACKS::pfnClose */
318static DECLCALLBACK(int) shClTransferHttpClose(PRTHTTPCALLBACKDATA pData, void *pvHandle)
319{
320 PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser;
321 Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
322
323 int rc;
324
325 PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromHandle(pThis, pvHandle);
326 if (pSrvTx)
327 {
328 shClHttpTransferLock(pSrvTx);
329
330 Assert(pSrvTx->hObj != SHCLOBJHANDLE_INVALID);
331 rc = ShClTransferObjClose(pSrvTx->pTransfer, pSrvTx->hObj);
332 if (RT_SUCCESS(rc))
333 {
334 pSrvTx->hObj = SHCLOBJHANDLE_INVALID;
335 LogRel2(("Shared Clipboard: HTTP transfer %RU16 done\n", pSrvTx->pTransfer->State.uID));
336 }
337
338 if (RT_FAILURE(rc))
339 LogRel(("Shared Clipboard: Error closing HTTP transfer (handle %RU64), rc=%Rrc\n", pSrvTx->hObj, rc));
340
341 shClHttpTransferUnlock(pSrvTx);
342 }
343 else
344 rc = VERR_NOT_FOUND;
345
346 LogFlowFuncLeaveRC(rc);
347 return rc;
348}
349
350/** @copydoc RTHTTPSERVERCALLBACKS::pfnQueryInfo */
351static DECLCALLBACK(int) shClTransferHttpQueryInfo(PRTHTTPCALLBACKDATA pData,
352 PRTHTTPSERVERREQ pReq, PRTFSOBJINFO pObjInfo, char **ppszMIMEHint)
353{
354 PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser;
355 Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
356
357 int rc;
358
359 PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpGetTransferFromUrl(pThis, pReq->pszUrl);
360 if (pSrvTx)
361 {
362 shClHttpTransferLock(pSrvTx);
363
364 rc = shClTransferHttpGetTransferRoots(pThis, pSrvTx);
365
366 shClHttpTransferUnlock(pSrvTx);
367 }
368 else
369 rc = VERR_NOT_FOUND;
370
371 RT_NOREF(pObjInfo, ppszMIMEHint);
372
373 LogFlowFuncLeaveRC(rc);
374 return rc;
375}
376
377/** @copydoc RTHTTPSERVERCALLBACKS::pfnDestroy */
378static DECLCALLBACK(int) shClTransferHttpDestroy(PRTHTTPCALLBACKDATA pData)
379{
380 PSHCLHTTPSERVER pThis = (PSHCLHTTPSERVER)pData->pvUser;
381 Assert(pData->cbUser == sizeof(SHCLHTTPSERVER));
382
383 return shClTransferHttpServerDestroyInternal(pThis);
384}
385
386
387/*********************************************************************************************************************************
388* Internal Shared Clipboard HTTP server functions *
389*********************************************************************************************************************************/
390
391/**
392 * Destroys a Shared Clipboard HTTP server instance, internal version.
393 *
394 * @returns VBox status code.
395 * @param pSrv Shared Clipboard HTTP server instance to destroy.
396 */
397static int shClTransferHttpServerDestroyInternal(PSHCLHTTPSERVER pSrv)
398{
399 PSHCLHTTPSERVERTRANSFER pSrvTx, pSrvTxNext;
400 RTListForEachSafe(&pSrv->lstTransfers, pSrvTx, pSrvTxNext, SHCLHTTPSERVERTRANSFER, Node)
401 {
402 RTListNodeRemove(&pSrvTx->Node);
403
404 RTMemFree(pSrvTx);
405 pSrvTx = NULL;
406 }
407
408 RTHttpServerResponseDestroy(&pSrv->Resp);
409
410 pSrv->hHTTPServer = NIL_RTHTTPSERVER;
411
412 int rc = VINF_SUCCESS;
413
414 if (RTCritSectIsInitialized(&pSrv->CritSect))
415 rc = RTCritSectDelete(&pSrv->CritSect);
416
417 return rc;
418}
419
420/**
421 * Locks the critical section of a Shared Clipboard HTTP server instance.
422 *
423 * @param pSrv Shared Clipboard HTTP server instance to lock.
424 */
425DECLINLINE(void) shClTransferHttpServerLock(PSHCLHTTPSERVER pSrv)
426{
427 int rc2 = RTCritSectEnter(&pSrv->CritSect);
428 AssertRC(rc2);
429}
430
431/**
432 * Unlocks the critical section of a Shared Clipboard HTTP server instance.
433 *
434 * @param pSrv Shared Clipboard HTTP server instance to unlock.
435 */
436DECLINLINE(void) shClTransferHttpServerUnlock(PSHCLHTTPSERVER pSrv)
437{
438 int rc2 = RTCritSectLeave(&pSrv->CritSect);
439 AssertRC(rc2);
440}
441
442/**
443 * Initializes a new Shared Clipboard HTTP server instance.
444 *
445 * @param pSrv HTTP server instance to initialize.
446 */
447static void shClTransferHttpServerInitInternal(PSHCLHTTPSERVER pSrv)
448{
449 pSrv->hHTTPServer = NIL_RTHTTPSERVER;
450 pSrv->uPort = 0;
451 RTListInit(&pSrv->lstTransfers);
452 pSrv->cTransfers = 0;
453 int rc2 = RTHttpServerResponseInit(&pSrv->Resp);
454 AssertRC(rc2);
455}
456
457
458/*********************************************************************************************************************************
459* Public Shared Clipboard HTTP server functions *
460*********************************************************************************************************************************/
461
462/**
463 * Initializes a new Shared Clipboard HTTP server instance.
464 *
465 * @param pSrv HTTP server instance to initialize.
466 */
467void ShClTransferHttpServerInit(PSHCLHTTPSERVER pSrv)
468{
469 AssertPtrReturnVoid(pSrv);
470
471 shClTransferHttpServerInitInternal(pSrv);
472}
473
474/**
475 * Creates a new Shared Clipboard HTTP server instance, extended version.
476 *
477 * @returns VBox status code.
478 * @param pSrv HTTP server instance to create.
479 * @param uPort TCP port number to use.
480 */
481int ShClTransferHttpServerCreateEx(PSHCLHTTPSERVER pSrv, uint16_t uPort)
482{
483 AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
484
485 RTHTTPSERVERCALLBACKS Callbacks;
486 RT_ZERO(Callbacks);
487
488 Callbacks.pfnOpen = shClTransferHttpOpen;
489 Callbacks.pfnRead = shClTransferHttpRead;
490 Callbacks.pfnClose = shClTransferHttpClose;
491 Callbacks.pfnQueryInfo = shClTransferHttpQueryInfo;
492 Callbacks.pfnDestroy = shClTransferHttpDestroy;
493
494 /* Note: The server always and *only* runs against the localhost interface. */
495 int rc = RTHttpServerCreate(&pSrv->hHTTPServer, "localhost", uPort, &Callbacks,
496 pSrv, sizeof(SHCLHTTPSERVER));
497 if (RT_SUCCESS(rc))
498 {
499 rc = RTCritSectInit(&pSrv->CritSect);
500 AssertRCReturn(rc, rc);
501
502 pSrv->uPort = uPort;
503
504 LogRel2(("Shared Clipboard: HTTP server running at port %RU16\n", pSrv->uPort));
505 }
506 else
507 {
508 int rc2 = shClTransferHttpServerDestroyInternal(pSrv);
509 AssertRC(rc2);
510 }
511
512 if (RT_FAILURE(rc))
513 LogRel(("Shared Clipboard: HTTP server failed to run, rc=%Rrc\n", rc));
514
515 return rc;
516}
517
518/**
519 * Creates a new Shared Clipboard HTTP server instance.
520 *
521 * This does automatic probing of TCP ports if one already is being used.
522 *
523 * @returns VBox status code.
524 * @param pSrv HTTP server instance to create.
525 * @param puPort Where to return the TCP port number being used on success. Optional.
526 */
527int ShClTransferHttpServerCreate(PSHCLHTTPSERVER pSrv, uint16_t *puPort)
528{
529 AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
530 /* puPort is optional. */
531
532 /** @todo Try favorite ports first (e.g. 8080, 8000, ...)? */
533
534 RTRAND hRand;
535 int rc = RTRandAdvCreateSystemFaster(&hRand); /* Should be good enough for this task. */
536 if (RT_SUCCESS(rc))
537 {
538 uint16_t uPort;
539 for (int i = 0; i < 32; i++)
540 {
541#ifdef DEBUG_andy
542 uPort = 8080; /* Make the port predictable, but only for me, mwahaha! :-). */
543#else
544 uPort = RTRandAdvU32Ex(hRand, 1024, UINT16_MAX);
545#endif
546 rc = ShClTransferHttpServerCreateEx(pSrv, (uint32_t)uPort);
547 if (RT_SUCCESS(rc))
548 {
549 if (puPort)
550 *puPort = uPort;
551 break;
552 }
553 }
554
555 RTRandAdvDestroy(hRand);
556 }
557
558 return rc;
559}
560
561/**
562 * Destroys a Shared Clipboard HTTP server instance.
563 *
564 * @returns VBox status code.
565 * @param pSrv HTTP server instance to destroy.
566 */
567int ShClTransferHttpServerDestroy(PSHCLHTTPSERVER pSrv)
568{
569 AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
570
571 if (pSrv->hHTTPServer == NIL_RTHTTPSERVER)
572 return VINF_SUCCESS;
573
574 Assert(pSrv->cTransfers == 0); /* Sanity. */
575
576 int rc = RTHttpServerDestroy(pSrv->hHTTPServer);
577 if (RT_SUCCESS(rc))
578 rc = shClTransferHttpServerDestroyInternal(pSrv);
579
580 if (RT_SUCCESS(rc))
581 LogRel2(("Shared Clipboard: HTTP server stopped\n"));
582 else
583 LogRel(("Shared Clipboard: HTTP server failed to stop, rc=%Rrc\n", rc));
584
585 return rc;
586}
587
588/**
589 * Registers a Shared Clipboard transfer to a HTTP server instance.
590 *
591 * @returns VBox status code.
592 * @param pSrv HTTP server instance to register transfer for.
593 * @param pTransfer Transfer to register.
594 */
595int ShClTransferHttpServerRegisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer)
596{
597 AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
598 AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
599
600 AssertReturn(pTransfer->State.uID, VERR_INVALID_PARAMETER); /* Paranoia. */
601
602 shClTransferHttpServerLock(pSrv);
603
604 PSHCLHTTPSERVERTRANSFER pSrvTx = (PSHCLHTTPSERVERTRANSFER)RTMemAllocZ(sizeof(SHCLHTTPSERVERTRANSFER));
605 AssertPtrReturn(pSrvTx, VERR_NO_MEMORY);
606
607 RTUUID Uuid;
608 int rc = RTUuidCreate(&Uuid);
609 if (RT_SUCCESS(rc))
610 {
611 char szUuid[64];
612 rc = RTUuidToStr(&Uuid, szUuid, sizeof(szUuid));
613 if (RT_SUCCESS(rc))
614 {
615 rc = RTCritSectInit(&pSrvTx->CritSect);
616 AssertRC(rc);
617
618 /* Create the virtual HTTP path for the transfer.
619 * Every transfer has a dedicated HTTP path. */
620#ifdef DEBUG_andy
621 ssize_t cch = RTStrPrintf2(pSrvTx->szPathVirtual, sizeof(pSrvTx->szPathVirtual), "/d1bbda60-80b7-45dc-a41c-ac4686c1d988/10664");
622#else
623 ssize_t cch = RTStrPrintf2(pSrvTx->szPathVirtual, sizeof(pSrvTx->szPathVirtual), "%s/%RU16/", szUuid, pTransfer->State.uID);
624#endif
625 AssertReturn(cch, VERR_BUFFER_OVERFLOW);
626
627 pSrvTx->pTransfer = pTransfer;
628 pSrvTx->pRootList = NULL;
629 pSrvTx->hObj = SHCLOBJHANDLE_INVALID;
630
631 RTListAppend(&pSrv->lstTransfers, &pSrvTx->Node);
632 pSrv->cTransfers++;
633
634 LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n",
635 pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers));
636
637 LogRel2(("Shared Clipboard: Registered HTTP transfer %RU16, now %RU32 HTTP transfers total\n",
638 pTransfer->State.uID, pSrv->cTransfers));
639 }
640 }
641
642 if (RT_FAILURE(rc))
643 RTMemFree(pSrvTx);
644
645 shClTransferHttpServerUnlock(pSrv);
646
647 LogFlowFuncLeaveRC(rc);
648 return rc;
649}
650
651/**
652 * Unregisters a formerly registered Shared Clipboard transfer.
653 *
654 * @returns VBox status code.
655 * @param pSrv HTTP server instance to unregister transfer from.
656 * @param pTransfer Transfer to unregister.
657 */
658int ShClTransferHttpServerUnregisterTransfer(PSHCLHTTPSERVER pSrv, PSHCLTRANSFER pTransfer)
659{
660 AssertPtrReturn(pSrv, VERR_INVALID_POINTER);
661 AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
662
663 shClTransferHttpServerLock(pSrv);
664
665 AssertReturn(pSrv->cTransfers, VERR_WRONG_ORDER);
666
667 int rc = VINF_SUCCESS;
668
669 PSHCLHTTPSERVERTRANSFER pSrvTx;
670 RTListForEach(&pSrv->lstTransfers, pSrvTx, SHCLHTTPSERVERTRANSFER, Node)
671 {
672 AssertPtr(pSrvTx->pTransfer);
673 if (pSrvTx->pTransfer->State.uID == pTransfer->State.uID)
674 {
675 RTListNodeRemove(&pSrvTx->Node);
676
677 Assert(pSrv->cTransfers);
678 pSrv->cTransfers--;
679
680 LogFunc(("pTransfer=%p, idTransfer=%RU16, szPath=%s -> %RU32 transfers\n",
681 pSrvTx->pTransfer, pSrvTx->pTransfer->State.uID, pSrvTx->szPathVirtual, pSrv->cTransfers));
682
683 LogRel2(("Shared Clipboard: Unregistered HTTP transfer %RU16, now %RU32 HTTP transfers total\n",
684 pTransfer->State.uID, pSrv->cTransfers));
685
686 rc = RTCritSectDelete(&pSrvTx->CritSect);
687 AssertRC(rc);
688
689 RTMemFree(pSrvTx);
690 pSrvTx = NULL;
691
692 rc = VINF_SUCCESS;
693 break;
694 }
695 }
696
697 shClTransferHttpServerUnlock(pSrv);
698
699 LogFlowFuncLeaveRC(rc);
700 return rc;
701}
702
703/**
704 * Returns whether a specific transfer ID is registered with a HTTP server instance or not.
705 *
706 * @returns \c true if the transfer ID is registered, \c false if not.
707 * @param pSrv HTTP server instance.
708 * @param idTransfer Transfer ID to check for.
709 */
710bool ShClTransferHttpServerHasTransfer(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer)
711{
712 AssertPtrReturn(pSrv, false);
713
714 shClTransferHttpServerLock(pSrv);
715
716 const bool fRc = shClTransferHttpServerGetTransferById(pSrv, idTransfer) != NULL;
717
718 shClTransferHttpServerUnlock(pSrv);
719
720 return fRc;
721}
722
723/**
724 * Returns the used TCP port number of a HTTP server instance.
725 *
726 * @returns TCP port number. 0 if not specified yet.
727 * @param pSrv HTTP server instance to return port for.
728 */
729uint16_t ShClTransferHttpServerGetPort(PSHCLHTTPSERVER pSrv)
730{
731 AssertPtrReturn(pSrv, 0);
732
733 shClTransferHttpServerLock(pSrv);
734
735 const uint16_t uPort = pSrv->uPort;
736
737 shClTransferHttpServerUnlock(pSrv);
738
739 return uPort;
740}
741
742/**
743 * Returns the number of registered HTTP server transfers of a HTTP server instance.
744 *
745 * @returns Number of registered transfers.
746 * @param pSrv HTTP server instance to return registered transfers for.
747 */
748uint32_t ShClTransferHttpServerGetTransferCount(PSHCLHTTPSERVER pSrv)
749{
750 AssertPtrReturn(pSrv, 0);
751
752 shClTransferHttpServerLock(pSrv);
753
754 const uint32_t cTransfers = pSrv->cTransfers;
755
756 shClTransferHttpServerUnlock(pSrv);
757
758 return cTransfers;
759}
760
761/**
762 * Returns the host name (scheme) of a HTTP server instance.
763 *
764 * @param pSrv HTTP server instance to return host name (scheme) for.
765 *
766 * @returns Host name (scheme).
767 */
768static const char *shClTransferHttpServerGetHost(PSHCLHTTPSERVER pSrv)
769{
770 RT_NOREF(pSrv);
771 return "http://localhost"; /* Hardcoded for now. */
772}
773
774/**
775 * Returns an allocated string with a HTTP server instance's address.
776 *
777 * @returns Allocated string with a HTTP server instance's address, or NULL on OOM.
778 * Needs to be free'd by the caller using RTStrFree().
779 * @param pSrv HTTP server instance to return address for.
780 */
781char *ShClTransferHttpServerGetAddressA(PSHCLHTTPSERVER pSrv)
782{
783 AssertPtrReturn(pSrv, NULL);
784
785 shClTransferHttpServerLock(pSrv);
786
787 char *pszAddress = RTStrAPrintf2("%s:%RU16", shClTransferHttpServerGetHost(pSrv), pSrv->uPort);
788 AssertPtr(pszAddress);
789
790 shClTransferHttpServerUnlock(pSrv);
791
792 return pszAddress;
793}
794
795/**
796 * Returns an allocated string with the URL of a given Shared Clipboard transfer ID.
797 *
798 * @returns Allocated string with the URL of a given Shared Clipboard transfer ID, or NULL if not found.
799 * Needs to be free'd by the caller using RTStrFree().
800 * @param pSrv HTTP server instance to return URL for.
801 */
802char *ShClTransferHttpServerGetUrlA(PSHCLHTTPSERVER pSrv, SHCLTRANSFERID idTransfer)
803{
804 AssertPtrReturn(pSrv, NULL);
805 AssertReturn(idTransfer != NIL_SHCLTRANSFERID, NULL);
806
807 shClTransferHttpServerLock(pSrv);
808
809 PSHCLHTTPSERVERTRANSFER pSrvTx = shClTransferHttpServerGetTransferById(pSrv, idTransfer);
810 if (!pSrvTx)
811 {
812 AssertFailed();
813 shClTransferHttpServerUnlock(pSrv);
814 return NULL;
815 }
816
817 AssertReturn(RTStrNLen(pSrvTx->szPathVirtual, RTPATH_MAX), NULL);
818 char *pszUrl = RTStrAPrintf2("%s:%RU16/%s", shClTransferHttpServerGetHost(pSrv), pSrv->uPort, pSrvTx->szPathVirtual);
819 AssertPtr(pszUrl);
820
821 shClTransferHttpServerUnlock(pSrv);
822
823 return pszUrl;
824}
825
826/**
827 * Returns whether a given HTTP server instance is running or not.
828 *
829 * @returns \c true if running, or \c false if not.
830 * @param pSrv HTTP server instance to check running state for.
831 */
832bool ShClTransferHttpServerIsRunning(PSHCLHTTPSERVER pSrv)
833{
834 AssertPtrReturn(pSrv, false);
835
836 return (pSrv->hHTTPServer != NIL_RTHTTPSERVER); /* Seems enough for now. */
837}
Note: See TracBrowser for help on using the repository browser.

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