void CQuickConnect::OnSubmit()
{
String strHost;
unsigned short usPort;
if(!CMainMenu::GetHostAndPort(m_GUIElements.pIPEditBox->getText().c_str(), strHost, usPort))
{
g_pClient->GetGUI()->ShowMessageBox("You must enter a valid host and port.", "Error");
return;
}
// Get the password
String strPassword(m_GUIElements.pPasswordEditBox->getText().c_str());
// Set the ip, port and password
CVAR_SET_STRING("ip", strHost);
CVAR_SET_INTEGER("port", usPort);
CVAR_SET_STRING("pass", strPassword);
// Hide the quick connect window
SetVisible(false);
// Call the connect function
CMainMenu::GetSingleton()->OnConnect(strHost, usPort, strPassword);
}
/**
* GetDefaultPassword
*
*/
CString CAProjectData::GetDefaultPassword()
{
CString strPassword(_T("123456"));
CString strEncrypted;
long lResult;
HKEY hKey;
lResult = ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, DEFAULT_POU_PROT_REG_KEY, 0, KEY_READ, &hKey);
if (lResult != ERROR_SUCCESS)
{
return strPassword;
}
DWORD dwBufSize = _MAX_PATH;
DWORD dwType;
lResult = ::RegQueryValueEx(hKey, _T("DefPD"), NULL, &dwType, (unsigned char*)strEncrypted.GetBuffer(_MAX_PATH), &dwBufSize);
strEncrypted.ReleaseBuffer();
if (lResult != ERROR_SUCCESS)
{
//close the key
::RegCloseKey(hKey);
return strPassword;
}
//close the key
::RegCloseKey(hKey);
// now decrypt it
CString strDecrypted;
long lSize = strEncrypted.GetLength();
HRESULT hr = UTIL_DecryptString(strEncrypted, strDecrypted.GetBuffer(lSize), NULL);
strDecrypted.ReleaseBuffer();
ASSERT(hr == S_OK);
if(hr != S_OK)
{
return strPassword;
}
strPassword = strDecrypted;
return strPassword;
}
/**
* Start teleporter to the specified target.
*
* @returns COM status code.
*
* @param aHostname The name of the target host.
* @param aPort The TCP port number.
* @param aPassword The password.
* @param aMaxDowntime Max allowed "downtime" in milliseconds.
* @param aProgress Where to return the progress object.
*/
STDMETHODIMP
Console::Teleport(IN_BSTR aHostname, ULONG aPort, IN_BSTR aPassword, ULONG aMaxDowntime, IProgress **aProgress)
{
/*
* Validate parameters, check+hold object status, write lock the object
* and validate the state.
*/
CheckComArgOutPointerValid(aProgress);
CheckComArgStrNotEmptyOrNull(aHostname);
CheckComArgStrNotEmptyOrNull(aPassword);
CheckComArgExprMsg(aPort, aPort > 0 && aPort <= 65535, ("is %u", aPort));
CheckComArgExprMsg(aMaxDowntime, aMaxDowntime > 0, ("is %u", aMaxDowntime));
Utf8Str strPassword(aPassword);
if (!strPassword.isEmpty())
{
if (VBoxIsPasswordHashed(&strPassword))
return setError(E_INVALIDARG, tr("The specified password resembles a hashed password, expected plain text"));
VBoxHashPassword(&strPassword);
}
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock autoLock(this COMMA_LOCKVAL_SRC_POS);
LogFlowThisFunc(("mMachineState=%d\n", mMachineState));
switch (mMachineState)
{
case MachineState_Running:
case MachineState_Paused:
break;
default:
return setError(VBOX_E_INVALID_VM_STATE,
tr("Invalid machine state: %s (must be Running or Paused)"),
Global::stringifyMachineState(mMachineState));
}
/*
* Create a progress object, spawn a worker thread and change the state.
* Note! The thread won't start working until we release the lock.
*/
LogFlowThisFunc(("Initiating TELEPORT request...\n"));
ComObjPtr<Progress> ptrProgress;
HRESULT hrc = ptrProgress.createObject();
if (SUCCEEDED(hrc))
hrc = ptrProgress->init(static_cast<IConsole *>(this),
Bstr(tr("Teleporter")).raw(),
TRUE /*aCancelable*/);
if (FAILED(hrc))
return hrc;
TeleporterStateSrc *pState = new TeleporterStateSrc(this, mpUVM, ptrProgress, mMachineState);
pState->mstrPassword = strPassword;
pState->mstrHostname = aHostname;
pState->muPort = aPort;
pState->mcMsMaxDowntime = aMaxDowntime;
void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
ptrProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser);
int vrc = RTThreadCreate(NULL, Console::teleporterSrcThreadWrapper, (void *)pState, 0 /*cbStack*/,
RTTHREADTYPE_EMULATION, 0 /*fFlags*/, "Teleport");
if (RT_SUCCESS(vrc))
{
if (mMachineState == MachineState_Running)
hrc = setMachineState(MachineState_Teleporting);
else
hrc = setMachineState(MachineState_TeleportingPausedVM);
if (SUCCEEDED(hrc))
{
ptrProgress.queryInterfaceTo(aProgress);
mptrCancelableProgress = ptrProgress;
}
else
ptrProgress->Cancel();
}
else
{
ptrProgress->setCancelCallback(NULL, NULL);
delete pState;
hrc = setError(E_FAIL, tr("RTThreadCreate -> %Rrc"), vrc);
}
return hrc;
}
/**
* Creates a TCP server that listens for the source machine and passes control
* over to Console::teleporterTrgServeConnection().
*
* @returns VBox status code.
* @param pUVM The user-mode VM handle
* @param pMachine The IMachine for the virtual machine.
* @param pErrorMsg Pointer to the error string for VMSetError.
* @param fStartPaused Whether to start it in the Paused (true) or
* Running (false) state,
* @param pProgress Pointer to the progress object.
* @param pfPowerOffOnFailure Whether the caller should power off
* the VM on failure.
*
* @remarks The caller expects error information to be set on failure.
* @todo Check that all the possible failure paths sets error info...
*/
HRESULT
Console::teleporterTrg(PUVM pUVM, IMachine *pMachine, Utf8Str *pErrorMsg, bool fStartPaused,
Progress *pProgress, bool *pfPowerOffOnFailure)
{
LogThisFunc(("pUVM=%p pMachine=%p fStartPaused=%RTbool pProgress=%p\n", pUVM, pMachine, fStartPaused, pProgress));
*pfPowerOffOnFailure = true;
/*
* Get the config.
*/
ULONG uPort;
HRESULT hrc = pMachine->COMGETTER(TeleporterPort)(&uPort);
if (FAILED(hrc))
return hrc;
ULONG const uPortOrg = uPort;
Bstr bstrAddress;
hrc = pMachine->COMGETTER(TeleporterAddress)(bstrAddress.asOutParam());
if (FAILED(hrc))
return hrc;
Utf8Str strAddress(bstrAddress);
const char *pszAddress = strAddress.isEmpty() ? NULL : strAddress.c_str();
Bstr bstrPassword;
hrc = pMachine->COMGETTER(TeleporterPassword)(bstrPassword.asOutParam());
if (FAILED(hrc))
return hrc;
Utf8Str strPassword(bstrPassword);
strPassword.append('\n'); /* To simplify password checking. */
/*
* Create the TCP server.
*/
int vrc;
PRTTCPSERVER hServer;
if (uPort)
vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer);
else
{
for (int cTries = 10240; cTries > 0; cTries--)
{
uPort = RTRandU32Ex(cTries >= 8192 ? 49152 : 1024, 65534);
vrc = RTTcpServerCreateEx(pszAddress, uPort, &hServer);
if (vrc != VERR_NET_ADDRESS_IN_USE)
break;
}
if (RT_SUCCESS(vrc))
{
hrc = pMachine->COMSETTER(TeleporterPort)(uPort);
if (FAILED(hrc))
{
RTTcpServerDestroy(hServer);
return hrc;
}
}
}
if (RT_FAILURE(vrc))
return setError(E_FAIL, tr("RTTcpServerCreateEx failed with status %Rrc"), vrc);
/*
* Create a one-shot timer for timing out after 5 mins.
*/
RTTIMERLR hTimerLR;
vrc = RTTimerLRCreateEx(&hTimerLR, 0 /*ns*/, RTTIMER_FLAGS_CPU_ANY, teleporterDstTimeout, hServer);
if (RT_SUCCESS(vrc))
{
vrc = RTTimerLRStart(hTimerLR, 5*60*UINT64_C(1000000000) /*ns*/);
if (RT_SUCCESS(vrc))
{
/*
* Do the job, when it returns we're done.
*/
TeleporterStateTrg theState(this, pUVM, pProgress, pMachine, mControl, &hTimerLR, fStartPaused);
theState.mstrPassword = strPassword;
theState.mhServer = hServer;
void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(&theState));
if (pProgress->setCancelCallback(teleporterProgressCancelCallback, pvUser))
{
LogRel(("Teleporter: Waiting for incoming VM...\n"));
hrc = pProgress->SetNextOperation(Bstr(tr("Waiting for incoming VM")).raw(), 1);
if (SUCCEEDED(hrc))
{
vrc = RTTcpServerListen(hServer, Console::teleporterTrgServeConnection, &theState);
pProgress->setCancelCallback(NULL, NULL);
if (vrc == VERR_TCP_SERVER_STOP)
{
vrc = theState.mRc;
/* Power off the VM on failure unless the state callback
already did that. */
*pfPowerOffOnFailure = false;
if (RT_SUCCESS(vrc))
hrc = S_OK;
else
{
VMSTATE enmVMState = VMR3GetStateU(pUVM);
if ( enmVMState != VMSTATE_OFF
&& enmVMState != VMSTATE_POWERING_OFF)
*pfPowerOffOnFailure = true;
/* Set error. */
if (pErrorMsg->length())
hrc = setError(E_FAIL, "%s", pErrorMsg->c_str());
else
hrc = setError(E_FAIL, tr("Teleporation failed (%Rrc)"), vrc);
}
}
else if (vrc == VERR_TCP_SERVER_SHUTDOWN)
{
BOOL fCanceled = TRUE;
hrc = pProgress->COMGETTER(Canceled)(&fCanceled);
if (FAILED(hrc) || fCanceled)
hrc = setError(E_FAIL, tr("Teleporting canceled"));
else
hrc = setError(E_FAIL, tr("Teleporter timed out waiting for incoming connection"));
LogRel(("Teleporter: RTTcpServerListen aborted - %Rrc\n", vrc));
}
else
{
hrc = setError(E_FAIL, tr("Unexpected RTTcpServerListen status code %Rrc"), vrc);
LogRel(("Teleporter: Unexpected RTTcpServerListen rc: %Rrc\n", vrc));
}
}
else
LogThisFunc(("SetNextOperation failed, %Rhrc\n", hrc));
}
else
{
LogThisFunc(("Canceled - check point #1\n"));
hrc = setError(E_FAIL, tr("Teleporting canceled"));
}
}
else
hrc = setError(E_FAIL, "RTTimerLRStart -> %Rrc", vrc);
RTTimerLRDestroy(hTimerLR);
}
else
hrc = setError(E_FAIL, "RTTimerLRCreate -> %Rrc", vrc);
RTTcpServerDestroy(hServer);
/*
* If we change TeleporterPort above, set it back to it's original
* value before returning.
*/
if (uPortOrg != uPort)
{
ErrorInfoKeeper Eik;
pMachine->COMSETTER(TeleporterPort)(uPortOrg);
}
return hrc;
}
