ConsoleImplTeleporter.cpp@ 98278

Last change on this file since 98278 was 98278, checked in by vboxsync, 22 months ago
Main/src-client: Some more rc -> hrc/vrc stuff found by grep. A build fix. bugref:10223
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 48.2 KB

Line
1	/* $Id: ConsoleImplTeleporter.cpp 98278 2023-01-24 11:55:00Z vboxsync $ */
2	/** @file
3	* VBox Console COM Class implementation, The Teleporter Part.
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.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	#define LOG_GROUP LOG_GROUP_MAIN_CONSOLE
33	#include "LoggingNew.h"
34
35	#include "ConsoleImpl.h"
36	#include "ProgressImpl.h"
37	#include "Global.h"
38	#include "StringifyEnums.h"
39
40	#include "AutoCaller.h"
41	#include "HashedPw.h"
42
43	#include <iprt/asm.h>
44	#include <iprt/err.h>
45	#include <iprt/rand.h>
46	#include <iprt/socket.h>
47	#include <iprt/tcp.h>
48	#include <iprt/timer.h>
49
50	#include <VBox/vmm/vmapi.h>
51	#include <VBox/vmm/ssm.h>
52	#include <VBox/vmm/vmmr3vtable.h>
53	#include <VBox/err.h>
54	#include <VBox/version.h>
55	#include <VBox/com/string.h>
56	#include "VBox/com/ErrorInfo.h"
57
58
59	/*********************************************************************************************************************************
60	* Structures and Typedefs *
61	*********************************************************************************************************************************/
62	/**
63	* Base class for the teleporter state.
64	*
65	* These classes are used as advanced structs, not as proper classes.
66	*/
67	class TeleporterState
68	{
69	public:
70	ComPtr<Console> mptrConsole;
71	PUVM mpUVM;
72	PCVMMR3VTABLE mpVMM;
73	ComObjPtr<Progress> mptrProgress;
74	Utf8Str mstrPassword;
75	bool const mfIsSource;
76
77	/** @name stream stuff
78	* @{ */
79	RTSOCKET mhSocket;
80	uint64_t moffStream;
81	uint32_t mcbReadBlock;
82	bool volatile mfStopReading;
83	bool volatile mfEndOfStream;
84	bool volatile mfIOError;
85	/** @} */
86
87	TeleporterState(Console pConsole, PUVM pUVM, PCVMMR3VTABLE pVMM, Progress pProgress, bool fIsSource)
88	: mptrConsole(pConsole)
89	, mpUVM(pUVM)
90	, mpVMM(pVMM)
91	, mptrProgress(pProgress)
92	, mfIsSource(fIsSource)
93	, mhSocket(NIL_RTSOCKET)
94	, moffStream(UINT64_MAX / 2)
95	, mcbReadBlock(0)
96	, mfStopReading(false)
97	, mfEndOfStream(false)
98	, mfIOError(false)
99	{
100	pVMM->pfnVMR3RetainUVM(mpUVM);
101	}
102
103	~TeleporterState()
104	{
105	if (mpVMM)
106	mpVMM->pfnVMR3ReleaseUVM(mpUVM);
107	mpUVM = NULL;
108	}
109	};
110
111
112	/**
113	* Teleporter state used by the source side.
114	*/
115	class TeleporterStateSrc : public TeleporterState
116	{
117	public:
118	Utf8Str mstrHostname;
119	uint32_t muPort;
120	uint32_t mcMsMaxDowntime;
121	MachineState_T menmOldMachineState;
122	bool mfSuspendedByUs;
123	bool mfUnlockedMedia;
124
125	TeleporterStateSrc(Console pConsole, PUVM pUVM, PCVMMR3VTABLE pVMM, Progress pProgress, MachineState_T enmOldMachineState)
126	: TeleporterState(pConsole, pUVM, pVMM, pProgress, true /fIsSource/)
127	, muPort(UINT32_MAX)
128	, mcMsMaxDowntime(250)
129	, menmOldMachineState(enmOldMachineState)
130	, mfSuspendedByUs(false)
131	, mfUnlockedMedia(false)
132	{
133	}
134	};
135
136
137	/**
138	* Teleporter state used by the destination side.
139	*/
140	class TeleporterStateTrg : public TeleporterState
141	{
142	public:
143	IMachine *mpMachine;
144	IInternalMachineControl *mpControl;
145	PRTTCPSERVER mhServer;
146	PRTTIMERLR mphTimerLR;
147	bool mfLockedMedia;
148	int mRc;
149	Utf8Str mErrorText;
150
151	TeleporterStateTrg(Console pConsole, PUVM pUVM, PCVMMR3VTABLE pVMM, Progress pProgress,
152	IMachine pMachine, IInternalMachineControl pControl,
153	PRTTIMERLR phTimerLR, bool fStartPaused)
154	: TeleporterState(pConsole, pUVM, pVMM, pProgress, false /fIsSource/)
155	, mpMachine(pMachine)
156	, mpControl(pControl)
157	, mhServer(NULL)
158	, mphTimerLR(phTimerLR)
159	, mfLockedMedia(false)
160	, mRc(VINF_SUCCESS)
161	, mErrorText()
162	{
163	RT_NOREF(fStartPaused); /** @todo figure out why fStartPaused isn't used */
164	}
165	};
166
167
168	/**
169	* TCP stream header.
170	*
171	* This is an extra layer for fixing the problem with figuring out when the SSM
172	* stream ends.
173	*/
174	typedef struct TELEPORTERTCPHDR
175	{
176	/** Magic value. */
177	uint32_t u32Magic;
178	/** The size of the data block following this header.
179	* 0 indicates the end of the stream, while UINT32_MAX indicates
180	* cancelation. */
181	uint32_t cb;
182	} TELEPORTERTCPHDR;
183	/** Magic value for TELEPORTERTCPHDR::u32Magic. (Egberto Gismonti Amin) */
184	#define TELEPORTERTCPHDR_MAGIC UINT32_C(0x19471205)
185	/** The max block size. */
186	#define TELEPORTERTCPHDR_MAX_SIZE UINT32_C(0x00fffff8)
187
188
189	/*********************************************************************************************************************************
190	* Global Variables *
191	*********************************************************************************************************************************/
192	static const char g_szWelcome[] = "VirtualBox-Teleporter-1.0\n";
193
194
195	/**
196	* Reads a string from the socket.
197	*
198	* @returns VBox status code.
199	*
200	* @param pState The teleporter state structure.
201	* @param pszBuf The output buffer.
202	* @param cchBuf The size of the output buffer.
203	*
204	*/
205	static int teleporterTcpReadLine(TeleporterState pState, char pszBuf, size_t cchBuf)
206	{
207	char *pszStart = pszBuf;
208	RTSOCKET hSocket = pState->mhSocket;
209
210	AssertReturn(cchBuf > 1, VERR_INTERNAL_ERROR);
211	*pszBuf = '\0';
212
213	/* dead simple approach. */
214	for (;;)
215	{
216	char ch;
217	int vrc = RTTcpRead(hSocket, &ch, sizeof(ch), NULL);
218	if (RT_FAILURE(vrc))
219	{
220	LogRel(("Teleporter: RTTcpRead -> %Rrc while reading string ('%s')\n", vrc, pszStart));
221	return vrc;
222	}
223	if ( ch == '\n'
224	\|\| ch == '\0')
225	return VINF_SUCCESS;
226	if (cchBuf <= 1)
227	{
228	LogRel(("Teleporter: String buffer overflow: '%s'\n", pszStart));
229	return VERR_BUFFER_OVERFLOW;
230	}
231	*pszBuf++ = ch;
232	*pszBuf = '\0';
233	cchBuf--;
234	}
235	}
236
237
238	/**
239	* Reads an ACK or NACK.
240	*
241	* @returns S_OK on ACK, E_FAIL+setError() on failure or NACK.
242	* @param pState The teleporter source state.
243	* @param pszWhich Which ACK is this this?
244	* @param pszNAckMsg Optional NACK message.
245	*
246	* @remarks the setError laziness forces this to be a Console member.
247	*/
248	HRESULT
249	Console::i_teleporterSrcReadACK(TeleporterStateSrc pState, const char pszWhich, const char pszNAckMsg /= NULL*/)
250	{
251	char szMsg[256];
252	int vrc = teleporterTcpReadLine(pState, szMsg, sizeof(szMsg));
253	if (RT_FAILURE(vrc))
254	return setErrorBoth(E_FAIL, vrc, tr("Failed reading ACK(%s): %Rrc"), pszWhich, vrc);
255
256	if (!strcmp(szMsg, "ACK"))
257	return S_OK;
258
259	if (!strncmp(szMsg, RT_STR_TUPLE("NACK=")))
260	{
261	char *pszMsgText = strchr(szMsg, ';');
262	if (pszMsgText)
263	*pszMsgText++ = '\0';
264
265	int32_t vrc2;
266	vrc = RTStrToInt32Full(&szMsg[sizeof("NACK=") - 1], 10, &vrc2);
267	if (vrc == VINF_SUCCESS)
268	{
269	/*
270	* Well formed NACK, transform it into an error.
271	*/
272	if (pszNAckMsg)
273	{
274	LogRel(("Teleporter: %s: NACK=%Rrc (%d)\n", pszWhich, vrc2, vrc2));
275	return setError(E_FAIL, pszNAckMsg);
276	}
277
278	if (pszMsgText)
279	{
280	pszMsgText = RTStrStrip(pszMsgText);
281	for (size_t off = 0; pszMsgText[off]; off++)
282	if (pszMsgText[off] == '\r')
283	pszMsgText[off] = '\n';
284
285	LogRel(("Teleporter: %s: NACK=%Rrc (%d) - '%s'\n", pszWhich, vrc2, vrc2, pszMsgText));
286	if (strlen(pszMsgText) > 4)
287	return setError(E_FAIL, "%s", pszMsgText);
288	return setError(E_FAIL, "NACK(%s) - %Rrc (%d) '%s'", pszWhich, vrc2, vrc2, pszMsgText);
289	}
290
291	return setError(E_FAIL, "NACK(%s) - %Rrc (%d)", pszWhich, vrc2, vrc2);
292	}
293
294	if (pszMsgText)
295	pszMsgText[-1] = ';';
296	}
297	return setError(E_FAIL, tr("%s: Expected ACK or NACK, got '%s'"), pszWhich, szMsg);
298	}
299
300
301	/**
302	* Submitts a command to the destination and waits for the ACK.
303	*
304	* @returns S_OK on ACKed command, E_FAIL+setError() on failure.
305	*
306	* @param pState The teleporter source state.
307	* @param pszCommand The command.
308	* @param fWaitForAck Whether to wait for the ACK.
309	*
310	* @remarks the setError laziness forces this to be a Console member.
311	*/
312	HRESULT Console::i_teleporterSrcSubmitCommand(TeleporterStateSrc pState, const char pszCommand, bool fWaitForAck /= true/)
313	{
314	int vrc = RTTcpSgWriteL(pState->mhSocket, 2, pszCommand, strlen(pszCommand), "\n", sizeof("\n") - 1);
315	if (RT_FAILURE(vrc))
316	return setErrorBoth(E_FAIL, vrc, tr("Failed writing command '%s': %Rrc"), pszCommand, vrc);
317	if (!fWaitForAck)
318	return S_OK;
319	return i_teleporterSrcReadACK(pState, pszCommand);
320	}
321
322
323	/**
324	* @copydoc SSMSTRMOPS::pfnWrite
325	*/
326	static DECLCALLBACK(int) teleporterTcpOpWrite(void pvUser, uint64_t offStream, const void pvBuf, size_t cbToWrite)
327	{
328	RT_NOREF(offStream);
329	TeleporterState pState = (TeleporterState )pvUser;
330
331	AssertReturn(cbToWrite > 0, VINF_SUCCESS);
332	AssertReturn(cbToWrite < UINT32_MAX, VERR_OUT_OF_RANGE);
333	AssertReturn(pState->mfIsSource, VERR_INVALID_HANDLE);
334
335	for (;;)
336	{
337	TELEPORTERTCPHDR Hdr;
338	Hdr.u32Magic = TELEPORTERTCPHDR_MAGIC;
339	Hdr.cb = RT_MIN((uint32_t)cbToWrite, TELEPORTERTCPHDR_MAX_SIZE);
340	int vrc = RTTcpSgWriteL(pState->mhSocket, 2, &Hdr, sizeof(Hdr), pvBuf, (size_t)Hdr.cb);
341	if (RT_FAILURE(vrc))
342	{
343	LogRel(("Teleporter/TCP: Write error: %Rrc (cb=%#x)\n", vrc, Hdr.cb));
344	return vrc;
345	}
346	pState->moffStream += Hdr.cb;
347	if (Hdr.cb == cbToWrite)
348	return VINF_SUCCESS;
349
350	/* advance */
351	cbToWrite -= Hdr.cb;
352	pvBuf = (uint8_t const *)pvBuf + Hdr.cb;
353	}
354	}
355
356
357	/**
358	* Selects and poll for close condition.
359	*
360	* We can use a relatively high poll timeout here since it's only used to get
361	* us out of error paths. In the normal cause of events, we'll get a
362	* end-of-stream header.
363	*
364	* @returns VBox status code.
365	*
366	* @param pState The teleporter state data.
367	*/
368	static int teleporterTcpReadSelect(TeleporterState *pState)
369	{
370	int vrc;
371	do
372	{
373	vrc = RTTcpSelectOne(pState->mhSocket, 1000);
374	if (RT_FAILURE(vrc) && vrc != VERR_TIMEOUT)
375	{
376	pState->mfIOError = true;
377	LogRel(("Teleporter/TCP: Header select error: %Rrc\n", vrc));
378	break;
379	}
380	if (pState->mfStopReading)
381	{
382	vrc = VERR_EOF;
383	break;
384	}
385	} while (vrc == VERR_TIMEOUT);
386	return vrc;
387	}
388
389
390	/**
391	* @copydoc SSMSTRMOPS::pfnRead
392	*/
393	static DECLCALLBACK(int) teleporterTcpOpRead(void pvUser, uint64_t offStream, void pvBuf, size_t cbToRead, size_t *pcbRead)
394	{
395	RT_NOREF(offStream);
396	TeleporterState pState = (TeleporterState )pvUser;
397	AssertReturn(!pState->mfIsSource, VERR_INVALID_HANDLE);
398
399	for (;;)
400	{
401	int vrc;
402
403	/*
404	* Check for various conditions and may have been signalled.
405	*/
406	if (pState->mfEndOfStream)
407	return VERR_EOF;
408	if (pState->mfStopReading)
409	return VERR_EOF;
410	if (pState->mfIOError)
411	return VERR_IO_GEN_FAILURE;
412
413	/*
414	* If there is no more data in the current block, read the next
415	* block header.
416	*/
417	if (!pState->mcbReadBlock)
418	{
419	vrc = teleporterTcpReadSelect(pState);
420	if (RT_FAILURE(vrc))
421	return vrc;
422	TELEPORTERTCPHDR Hdr;
423	vrc = RTTcpRead(pState->mhSocket, &Hdr, sizeof(Hdr), NULL);
424	if (RT_FAILURE(vrc))
425	{
426	pState->mfIOError = true;
427	LogRel(("Teleporter/TCP: Header read error: %Rrc\n", vrc));
428	return vrc;
429	}
430
431	if (RT_UNLIKELY( Hdr.u32Magic != TELEPORTERTCPHDR_MAGIC
432	\|\| Hdr.cb > TELEPORTERTCPHDR_MAX_SIZE
433	\|\| Hdr.cb == 0))
434	{
435	if ( Hdr.u32Magic == TELEPORTERTCPHDR_MAGIC
436	&& ( Hdr.cb == 0
437	\|\| Hdr.cb == UINT32_MAX)
438	)
439	{
440	pState->mfEndOfStream = true;
441	pState->mcbReadBlock = 0;
442	return Hdr.cb ? VERR_SSM_CANCELLED : VERR_EOF;
443	}
444	pState->mfIOError = true;
445	LogRel(("Teleporter/TCP: Invalid block: u32Magic=%#x cb=%#x\n", Hdr.u32Magic, Hdr.cb));
446	return VERR_IO_GEN_FAILURE;
447	}
448
449	pState->mcbReadBlock = Hdr.cb;
450	if (pState->mfStopReading)
451	return VERR_EOF;
452	}
453
454	/*
455	* Read more data.
456	*/
457	vrc = teleporterTcpReadSelect(pState);
458	if (RT_FAILURE(vrc))
459	return vrc;
460	uint32_t cb = (uint32_t)RT_MIN(pState->mcbReadBlock, cbToRead);
461	vrc = RTTcpRead(pState->mhSocket, pvBuf, cb, pcbRead);
462	if (RT_FAILURE(vrc))
463	{
464	pState->mfIOError = true;
465	LogRel(("Teleporter/TCP: Data read error: %Rrc (cb=%#x)\n", vrc, cb));
466	return vrc;
467	}
468	if (pcbRead)
469	{
470	cb = (uint32_t)*pcbRead;
471	pState->moffStream += cb;
472	pState->mcbReadBlock -= cb;
473	return VINF_SUCCESS;
474	}
475	pState->moffStream += cb;
476	pState->mcbReadBlock -= cb;
477	if (cbToRead == cb)
478	return VINF_SUCCESS;
479
480	/* Advance to the next block. */
481	cbToRead -= cb;
482	pvBuf = (uint8_t *)pvBuf + cb;
483	}
484	}
485
486
487	/**
488	* @copydoc SSMSTRMOPS::pfnSeek
489	*/
490	static DECLCALLBACK(int) teleporterTcpOpSeek(void pvUser, int64_t offSeek, unsigned uMethod, uint64_t poffActual)
491	{
492	RT_NOREF(pvUser, offSeek, uMethod, poffActual);
493	return VERR_NOT_SUPPORTED;
494	}
495
496
497	/**
498	* @copydoc SSMSTRMOPS::pfnTell
499	*/
500	static DECLCALLBACK(uint64_t) teleporterTcpOpTell(void *pvUser)
501	{
502	TeleporterState pState = (TeleporterState )pvUser;
503	return pState->moffStream;
504	}
505
506
507	/**
508	* @copydoc SSMSTRMOPS::pfnSize
509	*/
510	static DECLCALLBACK(int) teleporterTcpOpSize(void pvUser, uint64_t pcb)
511	{
512	RT_NOREF(pvUser, pcb);
513	return VERR_NOT_SUPPORTED;
514	}
515
516
517	/**
518	* @copydoc SSMSTRMOPS::pfnIsOk
519	*/
520	static DECLCALLBACK(int) teleporterTcpOpIsOk(void *pvUser)
521	{
522	TeleporterState pState = (TeleporterState )pvUser;
523
524	if (pState->mfIsSource)
525	{
526	/* Poll for incoming NACKs and errors from the other side */
527	int vrc = RTTcpSelectOne(pState->mhSocket, 0);
528	if (vrc != VERR_TIMEOUT)
529	{
530	if (RT_SUCCESS(vrc))
531	{
532	LogRel(("Teleporter/TCP: Incoming data detect by IsOk, assuming it is a cancellation NACK.\n"));
533	vrc = VERR_SSM_CANCELLED;
534	}
535	else
536	LogRel(("Teleporter/TCP: RTTcpSelectOne -> %Rrc (IsOk).\n", vrc));
537	return vrc;
538	}
539	}
540
541	return VINF_SUCCESS;
542	}
543
544
545	/**
546	* @copydoc SSMSTRMOPS::pfnClose
547	*/
548	static DECLCALLBACK(int) teleporterTcpOpClose(void *pvUser, bool fCancelled)
549	{
550	TeleporterState pState = (TeleporterState )pvUser;
551
552	if (pState->mfIsSource)
553	{
554	TELEPORTERTCPHDR EofHdr;
555	EofHdr.u32Magic = TELEPORTERTCPHDR_MAGIC;
556	EofHdr.cb = fCancelled ? UINT32_MAX : 0;
557	int vrc = RTTcpWrite(pState->mhSocket, &EofHdr, sizeof(EofHdr));
558	if (RT_FAILURE(vrc))
559	{
560	LogRel(("Teleporter/TCP: EOF Header write error: %Rrc\n", vrc));
561	return vrc;
562	}
563	}
564	else
565	{
566	ASMAtomicWriteBool(&pState->mfStopReading, true);
567	}
568
569	return VINF_SUCCESS;
570	}
571
572
573	/**
574	* Method table for a TCP based stream.
575	*/
576	static SSMSTRMOPS const g_teleporterTcpOps =
577	{
578	SSMSTRMOPS_VERSION,
579	teleporterTcpOpWrite,
580	teleporterTcpOpRead,
581	teleporterTcpOpSeek,
582	teleporterTcpOpTell,
583	teleporterTcpOpSize,
584	teleporterTcpOpIsOk,
585	teleporterTcpOpClose,
586	SSMSTRMOPS_VERSION
587	};
588
589
590	/**
591	* Progress cancelation callback.
592	*/
593	static void teleporterProgressCancelCallback(void *pvUser)
594	{
595	TeleporterState pState = (TeleporterState )pvUser;
596	pState->mpVMM->pfnSSMR3Cancel(pState->mpUVM);
597	if (!pState->mfIsSource)
598	{
599	TeleporterStateTrg pStateTrg = (TeleporterStateTrg )pState;
600	RTTcpServerShutdown(pStateTrg->mhServer);
601	}
602	}
603
604	/**
605	* @copydoc PFNVMPROGRESS
606	*/
607	static DECLCALLBACK(int) teleporterProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
608	{
609	TeleporterState pState = (TeleporterState )pvUser;
610	if (pState->mptrProgress)
611	{
612	HRESULT hrc = pState->mptrProgress->SetCurrentOperationProgress(uPercent);
613	if (FAILED(hrc))
614	{
615	/* check if the failure was caused by cancellation. */
616	BOOL fCanceled;
617	hrc = pState->mptrProgress->COMGETTER(Canceled)(&fCanceled);
618	if (SUCCEEDED(hrc) && fCanceled)
619	{
620	pState->mpVMM->pfnSSMR3Cancel(pState->mpUVM);
621	return VERR_SSM_CANCELLED;
622	}
623	}
624	}
625
626	NOREF(pUVM);
627	return VINF_SUCCESS;
628	}
629
630
631	/**
632	* @copydoc FNRTTIMERLR
633	*/
634	static DECLCALLBACK(void) teleporterDstTimeout(RTTIMERLR hTimerLR, void *pvUser, uint64_t iTick)
635	{
636	RT_NOREF(hTimerLR, iTick);
637	/* This is harmless for any open connections. */
638	RTTcpServerShutdown((PRTTCPSERVER)pvUser);
639	}
640
641
642	/**
643	* Do the teleporter.
644	*
645	* @returns VBox status code.
646	* @param pState The teleporter state.
647	*/
648	HRESULT Console::i_teleporterSrc(TeleporterStateSrc *pState)
649	{
650	AutoCaller autoCaller(this);
651	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
652
653	/*
654	* Wait for Console::Teleport to change the state.
655	*/
656	{ AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS); }
657
658	BOOL fCanceled = TRUE;
659	HRESULT hrc = pState->mptrProgress->COMGETTER(Canceled)(&fCanceled);
660	if (FAILED(hrc))
661	return hrc;
662	if (fCanceled)
663	return setError(E_FAIL, tr("canceled"));
664
665	/*
666	* Try connect to the destination machine, disable Nagle.
667	* (Note. The caller cleans up mhSocket, so we can return without worries.)
668	*/
669	int vrc = RTTcpClientConnect(pState->mstrHostname.c_str(), pState->muPort, &pState->mhSocket);
670	if (RT_FAILURE(vrc))
671	return setErrorBoth(E_FAIL, vrc, tr("Failed to connect to port %u on '%s': %Rrc"),
672	pState->muPort, pState->mstrHostname.c_str(), vrc);
673	vrc = RTTcpSetSendCoalescing(pState->mhSocket, false /fEnable/);
674	AssertRC(vrc);
675
676	/* Read and check the welcome message. */
677	char szLine[RT_MAX(128, sizeof(g_szWelcome))];
678	RT_ZERO(szLine);
679	vrc = RTTcpRead(pState->mhSocket, szLine, sizeof(g_szWelcome) - 1, NULL);
680	if (RT_FAILURE(vrc))
681	return setErrorBoth(E_FAIL, vrc, tr("Failed to read welcome message: %Rrc"), vrc);
682	if (strcmp(szLine, g_szWelcome))
683	return setError(E_FAIL, tr("Unexpected welcome %.*Rhxs"), sizeof(g_szWelcome) - 1, szLine);
684
685	/* password */
686	pState->mstrPassword.append('\n');
687	vrc = RTTcpWrite(pState->mhSocket, pState->mstrPassword.c_str(), pState->mstrPassword.length());
688	if (RT_FAILURE(vrc))
689	return setErrorBoth(E_FAIL, vrc, tr("Failed to send password: %Rrc"), vrc);
690
691	/* ACK */
692	hrc = i_teleporterSrcReadACK(pState, "password", tr("Invalid password"));
693	if (FAILED(hrc))
694	return hrc;
695
696	/*
697	* Start loading the state.
698	*
699	* Note! The saved state includes vital configuration data which will be
700	* verified against the VM config on the other end. This is all done
701	* in the first pass, so we should fail pretty promptly on misconfig.
702	*/
703	hrc = i_teleporterSrcSubmitCommand(pState, "load");
704	if (FAILED(hrc))
705	return hrc;
706
707	RTSocketRetain(pState->mhSocket);
708	void pvUser = static_cast<void >(static_cast<TeleporterState *>(pState));
709	vrc = pState->mpVMM->pfnVMR3Teleport(pState->mpUVM,
710	pState->mcMsMaxDowntime,
711	&g_teleporterTcpOps, pvUser,
712	teleporterProgressCallback, pvUser,
713	&pState->mfSuspendedByUs);
714	RTSocketRelease(pState->mhSocket);
715	if (RT_FAILURE(vrc))
716	{
717	if ( vrc == VERR_SSM_CANCELLED
718	&& RT_SUCCESS(RTTcpSelectOne(pState->mhSocket, 1)))
719	{
720	hrc = i_teleporterSrcReadACK(pState, "load-complete");
721	if (FAILED(hrc))
722	return hrc;
723	}
724	return setErrorBoth(E_FAIL, vrc, "VMR3Teleport -> %Rrc", vrc);
725	}
726
727	hrc = i_teleporterSrcReadACK(pState, "load-complete");
728	if (FAILED(hrc))
729	return hrc;
730
731	/*
732	* We're at the point of no return.
733	*/
734	if (FAILED(pState->mptrProgress->NotifyPointOfNoReturn()))
735	{
736	i_teleporterSrcSubmitCommand(pState, "cancel", false /fWaitForAck/);
737	return E_FAIL;
738	}
739
740	/*
741	* Hand over any media which we might be sharing.
742	*
743	* Note! This is only important on localhost teleportations.
744	*/
745	/** @todo Maybe we should only do this if it's a local teleportation... */
746	hrc = mControl->UnlockMedia();
747	if (FAILED(hrc))
748	return hrc;
749	pState->mfUnlockedMedia = true;
750
751	hrc = i_teleporterSrcSubmitCommand(pState, "lock-media");
752	if (FAILED(hrc))
753	return hrc;
754
755	/*
756	* The FINAL step is giving the target instructions how to proceed with the VM.
757	*/
758	if ( vrc == VINF_SSM_LIVE_SUSPENDED
759	\|\| pState->menmOldMachineState == MachineState_Paused)
760	hrc = i_teleporterSrcSubmitCommand(pState, "hand-over-paused");
761	else
762	hrc = i_teleporterSrcSubmitCommand(pState, "hand-over-resume");
763	if (FAILED(hrc))
764	return hrc;
765
766	/*
767	* teleporterSrcThreadWrapper will do the automatic power off because it
768	* has to release the AutoVMCaller.
769	*/
770	return S_OK;
771	}
772
773
774	/**
775	* Static thread method wrapper.
776	*
777	* @returns VINF_SUCCESS (ignored).
778	* @param hThreadSelf The thread.
779	* @param pvUser Pointer to a TeleporterStateSrc instance.
780	*/
781	/static/ DECLCALLBACK(int)
782	Console::i_teleporterSrcThreadWrapper(RTTHREAD hThreadSelf, void *pvUser)
783	{
784	RT_NOREF(hThreadSelf);
785	TeleporterStateSrc pState = (TeleporterStateSrc )pvUser;
786
787	/*
788	* Console::teleporterSrc does the work, we just grab onto the VM handle
789	* and do the cleanups afterwards.
790	*/
791	SafeVMPtr ptrVM(pState->mptrConsole);
792	HRESULT hrc = ptrVM.hrc();
793
794	if (SUCCEEDED(hrc))
795	hrc = pState->mptrConsole->i_teleporterSrc(pState);
796
797	/* Close the connection ASAP on so that the other side can complete. */
798	if (pState->mhSocket != NIL_RTSOCKET)
799	{
800	RTTcpClientClose(pState->mhSocket);
801	pState->mhSocket = NIL_RTSOCKET;
802	}
803
804	/* Aaarg! setMachineState trashes error info on Windows, so we have to
805	complete things here on failure instead of right before cleanup. */
806	if (FAILED(hrc))
807	pState->mptrProgress->i_notifyComplete(hrc);
808
809	/* We can no longer be canceled (success), or it doesn't matter any longer (failure). */
810	pState->mptrProgress->i_setCancelCallback(NULL, NULL);
811
812	/*
813	* Write lock the console before resetting mptrCancelableProgress and
814	* fixing the state.
815	*/
816	AutoWriteLock autoLock(pState->mptrConsole COMMA_LOCKVAL_SRC_POS);
817	pState->mptrConsole->mptrCancelableProgress.setNull();
818
819	VMSTATE const enmVMState = pState->mpVMM->pfnVMR3GetStateU(pState->mpUVM);
820	MachineState_T const enmMachineState = pState->mptrConsole->mMachineState;
821	if (SUCCEEDED(hrc))
822	{
823	/*
824	* Automatically shut down the VM on success.
825	*
826	* Note! We have to release the VM caller object or we'll deadlock in
827	* powerDown.
828	*/
829	AssertLogRelMsg(enmVMState == VMSTATE_SUSPENDED, ("%s\n", pState->mpVMM->pfnVMR3GetStateName(enmVMState)));
830	AssertLogRelMsg(enmMachineState == MachineState_TeleportingPausedVM, ("%s\n", ::stringifyMachineState(enmMachineState)));
831
832	ptrVM.release();
833
834	pState->mptrConsole->mVMIsAlreadyPoweringOff = true; /* (Make sure we stick in the TeleportingPausedVM state.) */
835	autoLock.release();
836
837	hrc = pState->mptrConsole->i_powerDown();
838
839	autoLock.acquire();
840	pState->mptrConsole->mVMIsAlreadyPoweringOff = false;
841
842	pState->mptrProgress->i_notifyComplete(hrc);
843	}
844	else
845	{
846	/*
847	* Work the state machinery on failure.
848	*
849	* If the state is no longer 'Teleporting*', some other operation has
850	* canceled us and there is nothing we need to do here. In all other
851	* cases, we've failed one way or another.
852	*/
853	if ( enmMachineState == MachineState_Teleporting
854	\|\| enmMachineState == MachineState_TeleportingPausedVM
855	)
856	{
857	if (pState->mfUnlockedMedia)
858	{
859	ErrorInfoKeeper Oak;
860	HRESULT hrc2 = pState->mptrConsole->mControl->LockMedia();
861	if (FAILED(hrc2))
862	{
863	uint64_t StartMS = RTTimeMilliTS();
864	do
865	{
866	RTThreadSleep(2);
867	hrc2 = pState->mptrConsole->mControl->LockMedia();
868	} while ( FAILED(hrc2)
869	&& RTTimeMilliTS() - StartMS < 2000);
870	}
871	if (SUCCEEDED(hrc2))
872	pState->mfUnlockedMedia = true;
873	else
874	LogRel(("FATAL ERROR: Failed to re-take the media locks. hrc2=%Rhrc\n", hrc2));
875	}
876
877	switch (enmVMState)
878	{
879	case VMSTATE_RUNNING:
880	case VMSTATE_RUNNING_LS:
881	case VMSTATE_DEBUGGING:
882	case VMSTATE_DEBUGGING_LS:
883	case VMSTATE_POWERING_OFF:
884	case VMSTATE_POWERING_OFF_LS:
885	case VMSTATE_RESETTING:
886	case VMSTATE_RESETTING_LS:
887	case VMSTATE_SOFT_RESETTING:
888	case VMSTATE_SOFT_RESETTING_LS:
889	Assert(!pState->mfSuspendedByUs);
890	Assert(!pState->mfUnlockedMedia);
891	pState->mptrConsole->i_setMachineState(MachineState_Running);
892	break;
893
894	case VMSTATE_GURU_MEDITATION:
895	case VMSTATE_GURU_MEDITATION_LS:
896	pState->mptrConsole->i_setMachineState(MachineState_Stuck);
897	break;
898
899	case VMSTATE_FATAL_ERROR:
900	case VMSTATE_FATAL_ERROR_LS:
901	pState->mptrConsole->i_setMachineState(MachineState_Paused);
902	break;
903
904	default:
905	AssertMsgFailed(("%s\n", pState->mpVMM->pfnVMR3GetStateName(enmVMState)));
906	RT_FALL_THRU();
907	case VMSTATE_SUSPENDED:
908	case VMSTATE_SUSPENDED_LS:
909	case VMSTATE_SUSPENDING:
910	case VMSTATE_SUSPENDING_LS:
911	case VMSTATE_SUSPENDING_EXT_LS:
912	if (!pState->mfUnlockedMedia)
913	{
914	pState->mptrConsole->i_setMachineState(MachineState_Paused);
915	if (pState->mfSuspendedByUs)
916	{
917	autoLock.release();
918	int vrc = pState->mpVMM->pfnVMR3Resume(pState->mpUVM, VMRESUMEREASON_TELEPORT_FAILED);
919	AssertLogRelMsgRC(vrc, ("VMR3Resume -> %Rrc\n", vrc));
920	autoLock.acquire();
921	}
922	}
923	else
924	{
925	/* Faking a guru meditation is the best I can think of doing here... */
926	pState->mptrConsole->i_setMachineState(MachineState_Stuck);
927	}
928	break;
929	}
930	}
931	}
932	autoLock.release();
933
934	/*
935	* Cleanup.
936	*/
937	Assert(pState->mhSocket == NIL_RTSOCKET);
938	delete pState;
939
940	return VINF_SUCCESS; /* ignored */
941	}
942
943
944	/**
945	* Start teleporter to the specified target.
946	*
947	* @returns COM status code.
948	*
949	* @param aHostname The name of the target host.
950	* @param aTcpport The TCP port number.
951	* @param aPassword The password.
952	* @param aMaxDowntime Max allowed "downtime" in milliseconds.
953	* @param aProgress Where to return the progress object.
954	*/
955	HRESULT Console::teleport(const com::Utf8Str &aHostname, ULONG aTcpport, const com::Utf8Str &aPassword,
956	ULONG aMaxDowntime, ComPtr<IProgress> &aProgress)
957	{
958	/*
959	* Validate parameters, check+hold object status, write lock the object
960	* and validate the state.
961	*/
962	Utf8Str strPassword(aPassword);
963	if (!strPassword.isEmpty())
964	{
965	if (VBoxIsPasswordHashed(&strPassword))
966	return setError(E_INVALIDARG, tr("The specified password resembles a hashed password, expected plain text"));
967	VBoxHashPassword(&strPassword);
968	}
969
970	AutoCaller autoCaller(this);
971	if (FAILED(autoCaller.hrc())) return autoCaller.hrc();
972
973	AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
974	LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
975
976	switch (mMachineState)
977	{
978	case MachineState_Running:
979	case MachineState_Paused:
980	break;
981
982	default:
983	return setError(VBOX_E_INVALID_VM_STATE, tr("Invalid machine state: %s (must be Running or Paused)"),
984	Global::stringifyMachineState(mMachineState));
985	}
986
987
988	/*
989	* Create a progress object, spawn a worker thread and change the state.
990	* Note! The thread won't start working until we release the lock.
991	*/
992	LogFlowThisFunc(("Initiating TELEPORT request...\n"));
993
994	ComObjPtr<Progress> ptrProgress;
995	HRESULT hrc = ptrProgress.createObject();
996	if (SUCCEEDED(hrc))
997	hrc = ptrProgress->init(static_cast<IConsole *>(this),
998	Bstr(tr("Teleporter")).raw(),
999	TRUE /aCancelable/);
1000	if (FAILED(hrc))
1001	return hrc;
1002
1003	TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpUVM, mpVMM, ptrProgress, mMachineState);
1004	pState->mstrPassword = strPassword;
1005	pState->mstrHostname = aHostname;
1006	pState->muPort = aTcpport;
1007	pState->mcMsMaxDowntime = aMaxDowntime;
1008
1009	void pvUser = static_cast<void >(static_cast<TeleporterState *>(pState));
1010	ptrProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser);
1011
1012	int vrc = RTThreadCreate(NULL, Console::i_teleporterSrcThreadWrapper, (void )pState, 0 /cbStack*/,
1013	RTTHREADTYPE_EMULATION, 0 /fFlags/, "Teleport");
1014	if (RT_SUCCESS(vrc))
1015	{
1016	if (mMachineState == MachineState_Running)
1017	hrc = i_setMachineState(MachineState_Teleporting);
1018	else
1019	hrc = i_setMachineState(MachineState_TeleportingPausedVM);
1020	if (SUCCEEDED(hrc))
1021	{
1022	ptrProgress.queryInterfaceTo(aProgress.asOutParam());
1023	mptrCancelableProgress = aProgress;
1024	}
1025	else
1026	ptrProgress->Cancel();
1027	}
1028	else
1029	{
1030	ptrProgress->i_setCancelCallback(NULL, NULL);
1031	delete pState;
1032	hrc = setErrorBoth(E_FAIL, vrc, "RTThreadCreate -> %Rrc", vrc);
1033	}
1034
1035	return hrc;
1036	}
1037
1038
1039	/**
1040	* Creates a TCP server that listens for the source machine and passes control
1041	* over to Console::teleporterTrgServeConnection().
1042	*
1043	* @returns VBox status code.
1044	* @param pUVM The user-mode VM handle
1045	* @param pVMM The VMM vtable.
1046	* @param pMachine The IMachine for the virtual machine.
1047	* @param pErrorMsg Pointer to the error string for VMSetError.
1048	* @param fStartPaused Whether to start it in the Paused (true) or
1049	* Running (false) state,
1050	* @param pProgress Pointer to the progress object.
1051	* @param pfPowerOffOnFailure Whether the caller should power off
1052	* the VM on failure.
1053	*
1054	* @remarks The caller expects error information to be set on failure.
1055	* @todo Check that all the possible failure paths sets error info...
1056	*/
1057	HRESULT Console::i_teleporterTrg(PUVM pUVM, PCVMMR3VTABLE pVMM, IMachine pMachine, Utf8Str pErrorMsg, bool fStartPaused,
1058	Progress pProgress, bool pfPowerOffOnFailure)
1059	{
1060	LogThisFunc(("pUVM=%p pVMM=%p pMachine=%p fStartPaused=%RTbool pProgress=%p\n", pUVM, pVMM, pMachine, fStartPaused, pProgress));
1061
1062	*pfPowerOffOnFailure = true;
1063
1064	/*
1065	* Get the config.
1066	*/
1067	ULONG uPort;
1068	HRESULT hrc = pMachine->COMGETTER(TeleporterPort)(&uPort);
1069	if (FAILED(hrc))
1070	return hrc;
1071	ULONG const uPortOrg = uPort;
1072
1073	Bstr bstrAddress;
1074	hrc = pMachine->COMGETTER(TeleporterAddress)(bstrAddress.asOutParam());
1075	if (FAILED(hrc))
1076	return hrc;
1077	Utf8Str strAddress(bstrAddress);
1078	const char *pszAddress = strAddress.isEmpty() ? NULL : strAddress.c_str();
1079
1080	Bstr bstrPassword;
1081	hrc = pMachine->COMGETTER(TeleporterPassword)(bstrPassword.asOutParam());
1082	if (FAILED(hrc))
1083	return hrc;
1084	Utf8Str strPassword(bstrPassword);
1085	strPassword.append('\n'); /* To simplify password checking. */
1086
1087	/*
1088	* Create the TCP server.
1089	*/
1090	int vrc = VINF_SUCCESS; /* Shut up MSC */
1091	PRTTCPSERVER hServer = NULL; /* ditto */
1092	if (uPort)
1093	vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer);
1094	else
1095	{
1096	for (int cTries = 10240; cTries > 0; cTries--)
1097	{
1098	uPort = RTRandU32Ex(cTries >= 8192 ? 49152 : 1024, 65534);
1099	vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer);
1100	if (vrc != VERR_NET_ADDRESS_IN_USE)
1101	break;
1102	}
1103	if (RT_SUCCESS(vrc))
1104	{
1105	hrc = pMachine->COMSETTER(TeleporterPort)(uPort);
1106	if (FAILED(hrc))
1107	{
1108	RTTcpServerDestroy(hServer);
1109	return hrc;
1110	}
1111	}
1112	}
1113	if (RT_FAILURE(vrc))
1114	return setErrorBoth(E_FAIL, vrc, tr("RTTcpServerCreateEx failed with status %Rrc"), vrc);
1115
1116	/*
1117	* Create a one-shot timer for timing out after 5 mins.
1118	*/
1119	RTTIMERLR hTimerLR;
1120	vrc = RTTimerLRCreateEx(&hTimerLR, 0 /ns/, RTTIMER_FLAGS_CPU_ANY, teleporterDstTimeout, hServer);
1121	if (RT_SUCCESS(vrc))
1122	{
1123	vrc = RTTimerLRStart(hTimerLR, 560UINT64_C(1000000000) /ns/);
1124	if (RT_SUCCESS(vrc))
1125	{
1126	/*
1127	* Do the job, when it returns we're done.
1128	*/
1129	TeleporterStateTrg theState(this, pUVM, pVMM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused);
1130	theState.mstrPassword = strPassword;
1131	theState.mhServer = hServer;
1132
1133	void pvUser = static_cast<void >(static_cast<TeleporterState *>(&theState));
1134	if (pProgress->i_setCancelCallback(teleporterProgressCancelCallback, pvUser))
1135	{
1136	LogRel(("Teleporter: Waiting for incoming VM...\n"));
1137	hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")).raw(), 1);
1138	if (SUCCEEDED(hrc))
1139	{
1140	vrc = RTTcpServerListen(hServer, Console::i_teleporterTrgServeConnection, &theState);
1141	pProgress->i_setCancelCallback(NULL, NULL);
1142
1143	if (vrc == VERR_TCP_SERVER_STOP)
1144	{
1145	vrc = theState.mRc;
1146	/* Power off the VM on failure unless the state callback
1147	already did that. */
1148	*pfPowerOffOnFailure = false;
1149	if (RT_SUCCESS(vrc))
1150	hrc = S_OK;
1151	else
1152	{
1153	VMSTATE enmVMState = pVMM->pfnVMR3GetStateU(pUVM);
1154	if ( enmVMState != VMSTATE_OFF
1155	&& enmVMState != VMSTATE_POWERING_OFF)
1156	*pfPowerOffOnFailure = true;
1157
1158	/* Set error. */
1159	if (pErrorMsg->length())
1160	hrc = setError(E_FAIL, "%s", pErrorMsg->c_str());
1161	else
1162	hrc = setError(E_FAIL, tr("Teleporation failed (%Rrc)"), vrc);
1163	}
1164	}
1165	else if (vrc == VERR_TCP_SERVER_SHUTDOWN)
1166	{
1167	BOOL fCanceled = TRUE;
1168	hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
1169	if (FAILED(hrc) \|\| fCanceled)
1170	hrc = setError(E_FAIL, tr("Teleporting canceled"));
1171	else
1172	hrc = setError(E_FAIL, tr("Teleporter timed out waiting for incoming connection"));
1173	LogRel(("Teleporter: RTTcpServerListen aborted - %Rrc\n", vrc));
1174	}
1175	else
1176	{
1177	hrc = setErrorBoth(E_FAIL, vrc, tr("Unexpected RTTcpServerListen status code %Rrc"), vrc);
1178	LogRel(("Teleporter: Unexpected RTTcpServerListen vrc: %Rrc\n", vrc));
1179	}
1180	}
1181	else
1182	LogThisFunc(("SetNextOperation failed, %Rhrc\n", hrc));
1183	}
1184	else
1185	{
1186	LogThisFunc(("Canceled - check point #1\n"));
1187	hrc = setError(E_FAIL, tr("Teleporting canceled"));
1188	}
1189	}
1190	else
1191	hrc = setErrorBoth(E_FAIL, vrc, "RTTimerLRStart -> %Rrc", vrc);
1192
1193	RTTimerLRDestroy(hTimerLR);
1194	}
1195	else
1196	hrc = setErrorBoth(E_FAIL, vrc, "RTTimerLRCreate -> %Rrc", vrc);
1197	RTTcpServerDestroy(hServer);
1198
1199	/*
1200	* If we change TeleporterPort above, set it back to it's original
1201	* value before returning.
1202	*/
1203	if (uPortOrg != uPort)
1204	{
1205	ErrorInfoKeeper Eik;
1206	pMachine->COMSETTER(TeleporterPort)(uPortOrg);
1207	}
1208
1209	return hrc;
1210	}
1211
1212
1213	/**
1214	* Unlock the media.
1215	*
1216	* This is used in error paths.
1217	*
1218	* @param pState The teleporter state.
1219	*/
1220	static void teleporterTrgUnlockMedia(TeleporterStateTrg *pState)
1221	{
1222	if (pState->mfLockedMedia)
1223	{
1224	pState->mpControl->UnlockMedia();
1225	pState->mfLockedMedia = false;
1226	}
1227	}
1228
1229
1230	static int teleporterTcpWriteACK(TeleporterStateTrg *pState, bool fAutomaticUnlock = true)
1231	{
1232	int vrc = RTTcpWrite(pState->mhSocket, "ACK\n", sizeof("ACK\n") - 1);
1233	if (RT_FAILURE(vrc))
1234	{
1235	LogRel(("Teleporter: RTTcpWrite(,ACK,) -> %Rrc\n", vrc));
1236	if (fAutomaticUnlock)
1237	teleporterTrgUnlockMedia(pState);
1238	}
1239	return vrc;
1240	}
1241
1242
1243	static int teleporterTcpWriteNACK(TeleporterStateTrg pState, int32_t rc2, const char pszMsgText = NULL)
1244	{
1245	/*
1246	* Unlock media sending the NACK. That way the other doesn't have to spin
1247	* waiting to regain the locks.
1248	*/
1249	teleporterTrgUnlockMedia(pState);
1250
1251	char szMsg[256];
1252	size_t cch;
1253	if (pszMsgText && *pszMsgText)
1254	{
1255	cch = RTStrPrintf(szMsg, sizeof(szMsg), "NACK=%d;%s\n", rc2, pszMsgText);
1256	for (size_t off = 6; off + 1 < cch; off++)
1257	if (szMsg[off] == '\n')
1258	szMsg[off] = '\r';
1259	}
1260	else
1261	cch = RTStrPrintf(szMsg, sizeof(szMsg), "NACK=%d\n", rc2);
1262	int vrc = RTTcpWrite(pState->mhSocket, szMsg, cch);
1263	if (RT_FAILURE(vrc))
1264	LogRel(("Teleporter: RTTcpWrite(,%s,%zu) -> %Rrc\n", szMsg, cch, vrc));
1265	return vrc;
1266	}
1267
1268
1269	/**
1270	* @copydoc FNRTTCPSERVE
1271	*
1272	* @returns VINF_SUCCESS or VERR_TCP_SERVER_STOP.
1273	*/
1274	/static/ DECLCALLBACK(int)
1275	Console::i_teleporterTrgServeConnection(RTSOCKET hSocket, void *pvUser)
1276	{
1277	TeleporterStateTrg pState = (TeleporterStateTrg )pvUser;
1278	pState->mhSocket = hSocket;
1279
1280	/*
1281	* Disable Nagle and say hello.
1282	*/
1283	int vrc = RTTcpSetSendCoalescing(pState->mhSocket, false /fEnable/);
1284	AssertRC(vrc);
1285	vrc = RTTcpWrite(hSocket, g_szWelcome, sizeof(g_szWelcome) - 1);
1286	if (RT_FAILURE(vrc))
1287	{
1288	LogRel(("Teleporter: Failed to write welcome message: %Rrc\n", vrc));
1289	return VINF_SUCCESS;
1290	}
1291
1292	/*
1293	* Password (includes '\n', see i_teleporterTrg).
1294	*/
1295	const char *pszPassword = pState->mstrPassword.c_str();
1296	unsigned off = 0;
1297	while (pszPassword[off])
1298	{
1299	char ch;
1300	vrc = RTTcpRead(hSocket, &ch, sizeof(ch), NULL);
1301	if ( RT_FAILURE(vrc)
1302	\|\| pszPassword[off] != ch)
1303	{
1304	if (RT_FAILURE(vrc))
1305	LogRel(("Teleporter: Password read failure (off=%u): %Rrc\n", off, vrc));
1306	else
1307	{
1308	/* Must read the whole password before NACK'ing it. */
1309	size_t const cchMaxRead = RT_ALIGN_Z(pState->mstrPassword.length() * 3, _1K);
1310	while (off < cchMaxRead && RT_SUCCESS(vrc) && ch != '\n')
1311	{
1312	vrc = RTTcpRead(hSocket, &ch, sizeof(ch), NULL);
1313	off++;
1314	}
1315	LogRel(("Teleporter: Invalid password\n"));
1316	}
1317	RTThreadSleep(RTRandU32Ex(64, 1024)); /* stagger retries */
1318	teleporterTcpWriteNACK(pState, VERR_AUTHENTICATION_FAILURE);
1319	return VINF_SUCCESS;
1320	}
1321	off++;
1322	}
1323	vrc = teleporterTcpWriteACK(pState);
1324	if (RT_FAILURE(vrc))
1325	return VINF_SUCCESS;
1326
1327	/*
1328	* Update the progress bar, with peer name if available.
1329	*/
1330	HRESULT hrc;
1331	RTNETADDR Addr;
1332	vrc = RTTcpGetPeerAddress(hSocket, &Addr);
1333	if (RT_SUCCESS(vrc))
1334	{
1335	LogRel(("Teleporter: Incoming VM from %RTnaddr!\n", &Addr));
1336	hrc = pState->mptrProgress->SetNextOperation(BstrFmt(tr("Teleporting VM from %RTnaddr"), &Addr).raw(), 8);
1337	}
1338	else
1339	{
1340	LogRel(("Teleporter: Incoming VM!\n"));
1341	hrc = pState->mptrProgress->SetNextOperation(Bstr(tr("Teleporting VM")).raw(), 8);
1342	}
1343	AssertMsg(SUCCEEDED(hrc) \|\| hrc == E_FAIL, ("%Rhrc\n", hrc));
1344
1345	/*
1346	* Stop the server and cancel the timeout timer.
1347	*
1348	* Note! After this point we must return VERR_TCP_SERVER_STOP, while prior
1349	* to it we must not return that value!
1350	*/
1351	RTTcpServerShutdown(pState->mhServer);
1352	RTTimerLRDestroy(*pState->mphTimerLR);
1353	*pState->mphTimerLR = NIL_RTTIMERLR;
1354
1355	/*
1356	* Command processing loop.
1357	*/
1358	bool fDone = false;
1359	for (;;)
1360	{
1361	char szCmd[128];
1362	vrc = teleporterTcpReadLine(pState, szCmd, sizeof(szCmd));
1363	if (RT_FAILURE(vrc))
1364	break;
1365
1366	if (!strcmp(szCmd, "load"))
1367	{
1368	vrc = teleporterTcpWriteACK(pState);
1369	if (RT_FAILURE(vrc))
1370	break;
1371
1372	int vrc2 = pState->mpVMM->pfnVMR3AtErrorRegister(pState->mpUVM, Console::i_genericVMSetErrorCallback,
1373	&pState->mErrorText);
1374	AssertRC(vrc2);
1375	RTSocketRetain(pState->mhSocket); /* For concurrent access by I/O thread and EMT. */
1376	pState->moffStream = 0;
1377
1378	void pvUser2 = static_cast<void >(static_cast<TeleporterState *>(pState));
1379	vrc = pState->mpVMM->pfnVMR3LoadFromStream(pState->mpUVM,
1380	&g_teleporterTcpOps, pvUser2,
1381	teleporterProgressCallback, pvUser2,
1382	true /fTeleporting/);
1383
1384	RTSocketRelease(pState->mhSocket);
1385	vrc2 = pState->mpVMM->pfnVMR3AtErrorDeregister(pState->mpUVM, Console::i_genericVMSetErrorCallback, &pState->mErrorText);
1386	AssertRC(vrc2);
1387
1388	if (RT_FAILURE(vrc))
1389	{
1390	LogRel(("Teleporter: VMR3LoadFromStream -> %Rrc\n", vrc));
1391	teleporterTcpWriteNACK(pState, vrc, pState->mErrorText.c_str());
1392	break;
1393	}
1394
1395	/* The EOS might not have been read, make sure it is. */
1396	pState->mfStopReading = false;
1397	size_t cbRead;
1398	vrc = teleporterTcpOpRead(pvUser2, pState->moffStream, szCmd, 1, &cbRead);
1399	if (vrc != VERR_EOF)
1400	{
1401	LogRel(("Teleporter: Draining teleporterTcpOpRead -> %Rrc\n", vrc));
1402	teleporterTcpWriteNACK(pState, vrc);
1403	break;
1404	}
1405
1406	vrc = teleporterTcpWriteACK(pState);
1407	}
1408	else if (!strcmp(szCmd, "cancel"))
1409	{
1410	/* Don't ACK this. */
1411	LogRel(("Teleporter: Received cancel command.\n"));
1412	vrc = VERR_SSM_CANCELLED;
1413	}
1414	else if (!strcmp(szCmd, "lock-media"))
1415	{
1416	hrc = pState->mpControl->LockMedia();
1417	if (SUCCEEDED(hrc))
1418	{
1419	pState->mfLockedMedia = true;
1420	vrc = teleporterTcpWriteACK(pState);
1421	}
1422	else
1423	{
1424	vrc = VERR_FILE_LOCK_FAILED;
1425	teleporterTcpWriteNACK(pState, vrc);
1426	}
1427	}
1428	else if ( !strcmp(szCmd, "hand-over-resume")
1429	\|\| !strcmp(szCmd, "hand-over-paused"))
1430	{
1431	/*
1432	* Point of no return.
1433	*
1434	* Note! Since we cannot tell whether a VMR3Resume failure is
1435	* destructive for the source or not, we have little choice
1436	* but to ACK it first and take any failures locally.
1437	*
1438	* Ideally, we should try resume it first and then ACK (or
1439	* NACK) the request since this would reduce latency and
1440	* make it possible to recover from some VMR3Resume failures.
1441	*/
1442	if ( SUCCEEDED(pState->mptrProgress->NotifyPointOfNoReturn())
1443	&& pState->mfLockedMedia)
1444	{
1445	vrc = teleporterTcpWriteACK(pState);
1446	if (RT_SUCCESS(vrc))
1447	{
1448	if (!strcmp(szCmd, "hand-over-resume"))
1449	vrc = pState->mpVMM->pfnVMR3Resume(pState->mpUVM, VMRESUMEREASON_TELEPORTED);
1450	else
1451	pState->mptrConsole->i_setMachineState(MachineState_Paused);
1452	fDone = true;
1453	break;
1454	}
1455	}
1456	else
1457	{
1458	vrc = pState->mfLockedMedia ? VERR_WRONG_ORDER : VERR_SSM_CANCELLED;
1459	teleporterTcpWriteNACK(pState, vrc);
1460	}
1461	}
1462	else
1463	{
1464	LogRel(("Teleporter: Unknown command '%s' (%.*Rhxs)\n", szCmd, strlen(szCmd), szCmd));
1465	vrc = VERR_NOT_IMPLEMENTED;
1466	teleporterTcpWriteNACK(pState, vrc);
1467	}
1468
1469	if (RT_FAILURE(vrc))
1470	break;
1471	}
1472
1473	if (RT_SUCCESS(vrc) && !fDone)
1474	vrc = VERR_WRONG_ORDER;
1475	if (RT_FAILURE(vrc))
1476	teleporterTrgUnlockMedia(pState);
1477
1478	pState->mRc = vrc;
1479	pState->mhSocket = NIL_RTSOCKET;
1480	LogFlowFunc(("returns mRc=%Rrc\n", vrc));
1481	return VERR_TCP_SERVER_STOP;
1482	}
1483

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

source: vbox/trunk/src/VBox/Main/src-client/ConsoleImplTeleporter.cpp@ 98278

Download in other formats: