/**
* @interface_method_impl{FNPDMDRVREQHANDLERR0}
*/
PDMBOTHCBDECL(int) drvR0HostParallelReqHandler(PPDMDRVINS pDrvIns, uint32_t uOperation, uint64_t u64Arg)
{
int rc;
LogFlowFuncEnter();
/* I have included break after each case. Need to work on this. */
switch ((DRVHOSTPARALLELR0OP)uOperation)
{
case DRVHOSTPARALLELR0OP_READ:
rc = drvR0HostParallelReqRead(pDrvIns, u64Arg);
break;
case DRVHOSTPARALLELR0OP_READSTATUS:
rc = drvR0HostParallelReqReadStatus(pDrvIns, u64Arg);
break;
case DRVHOSTPARALLELR0OP_READCONTROL:
rc = drvR0HostParallelReqReadControl(pDrvIns, u64Arg);
break;
case DRVHOSTPARALLELR0OP_WRITE:
rc = drvR0HostParallelReqWrite(pDrvIns, u64Arg);
break;
case DRVHOSTPARALLELR0OP_WRITECONTROL:
rc = drvR0HostParallelReqWriteControl(pDrvIns, u64Arg);
break;
case DRVHOSTPARALLELR0OP_SETPORTDIRECTION:
rc = drvR0HostParallelReqSetPortDir(pDrvIns, u64Arg);
break;
default: /* not supported */
rc = VERR_NOT_SUPPORTED;
}
LogFlowFuncLeave();
return rc;
}
DECLINLINE(int) pftpSessionOpenFile(PNATState pData, PTFTPSESSION pTftpSession, PRTFILE pSessionFile)
{
char aszSessionFileName[TFTP_FILENAME_MAX];
size_t cbSessionFileName;
int rc = VINF_SUCCESS;
LogFlowFuncEnter();
cbSessionFileName = RTStrPrintf(aszSessionFileName, TFTP_FILENAME_MAX, "%s/%s",
tftp_prefix, pTftpSession->pszFilename);
if (cbSessionFileName >= TFTP_FILENAME_MAX)
{
LogFlowFuncLeaveRC(VERR_INTERNAL_ERROR);
return VERR_INTERNAL_ERROR;
}
LogFunc(("aszSessionFileName: %s\n", aszSessionFileName));
if (!RTFileExists(aszSessionFileName))
{
LogFlowFuncLeaveRC(VERR_FILE_NOT_FOUND);
return VERR_FILE_NOT_FOUND;
}
rc = RTFileOpen(pSessionFile, aszSessionFileName, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
LogFlowFuncLeaveRC(rc);
return rc;
}
GuestDnD::~GuestDnD(void)
{
LogFlowFuncEnter();
if (m_pResponse)
delete m_pResponse;
}
static EFI_STATUS fsw_efi_ReMount(IN FSW_VOLUME_DATA *pVolume,
IN EFI_HANDLE ControllerHandle,
EFI_DISK_IO *pDiskIo,
EFI_BLOCK_IO *pBlockIo)
{
EFI_STATUS Status;
LogFlowFuncEnter();
pVolume->Signature = FSW_VOLUME_DATA_SIGNATURE;
pVolume->Handle = ControllerHandle;
pVolume->DiskIo = pDiskIo;
pVolume->MediaId = pBlockIo->Media->MediaId;
pVolume->LastIOStatus = EFI_SUCCESS;
// mount the filesystem
Status = fsw_efi_map_status(fsw_mount(pVolume, &fsw_efi_host_table,
&FSW_FSTYPE_TABLE_NAME(FSTYPE), &pVolume->vol),
pVolume);
LogFlowFuncMarkVar(Status, "%r");
if (!EFI_ERROR(Status)) {
// register the SimpleFileSystem protocol
pVolume->FileSystem.Revision = EFI_FILE_IO_INTERFACE_REVISION;
pVolume->FileSystem.OpenVolume = fsw_efi_FileSystem_OpenVolume;
Status = BS->InstallMultipleProtocolInterfaces(&ControllerHandle,
&PROTO_NAME(SimpleFileSystemProtocol), &pVolume->FileSystem,
NULL);
if (EFI_ERROR(Status))
Print(L"Fsw ERROR: InstallMultipleProtocolInterfaces returned %x\n", Status);
}
LogFlowFuncLeaveRC(Status);
return Status;
}
int UIDnDHandler::dragStart(ulong screenID)
{
int rc;
#ifdef VBOX_WITH_DRAG_AND_DROP_GH
NOREF(screenID);
LogFlowFuncEnter();
/* Sanity checks. */
if ( !m_dataSource.lstFormats.size()
|| m_dataSource.defaultAction == KDnDAction_Ignore
|| !m_dataSource.vecActions.size())
{
return VERR_INVALID_PARAMETER;
}
setOpMode(DNDMODE_GUESTTOHOST);
rc = dragStartInternal(m_dataSource.lstFormats,
toQtDnDAction(m_dataSource.defaultAction), toQtDnDActions(m_dataSource.vecActions));
#else /* !VBOX_WITH_DRAG_AND_DROP_GH */
NOREF(screenID);
rc = VERR_NOT_SUPPORTED;
#endif /* VBOX_WITH_DRAG_AND_DROP_GH */
LogFlowFuncLeaveRC(rc);
return rc;
}
void UIDnDHandler::reset(void)
{
LogFlowFuncEnter();
m_fDataRetrieved = false;
m_fIsPending = false;
setOpMode(DNDMODE_UNKNOWN);
}
EFI_STATUS EFIAPI fsw_efi_DriverBinding_Start(IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath)
{
EFI_STATUS Status;
EFI_BLOCK_IO *BlockIo;
EFI_DISK_IO *DiskIo;
FSW_VOLUME_DATA *Volume;
LogFlowFuncEnter();
// open consumed protocols
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(BlockIoProtocol),
(VOID **) &BlockIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL); // NOTE: we only want to look at the MediaId
if (EFI_ERROR(Status)) {
LogFlowFuncLeaveRC(Status);
return Status;
}
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
(VOID **) &DiskIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_BY_DRIVER);
if (EFI_ERROR(Status)) {
LogFlowFuncLeaveRC(Status);
return Status;
}
// allocate volume structure
Volume = AllocateZeroPool(sizeof(FSW_VOLUME_DATA));
Status = fsw_efi_ReMount(Volume, ControllerHandle, DiskIo, BlockIo);
// on errors, close the opened protocols
if (EFI_ERROR(Status)) {
if (Volume->vol != NULL)
fsw_unmount(Volume->vol);
FreePool(Volume);
#if 0
if (Status == EFI_MEDIA_CHANGED)
Status = fsw_efi_ReMount(Volume, ControllerHandle, DiskIo, BlockIo);
else
#endif
BS->CloseProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
This->DriverBindingHandle,
ControllerHandle);
}
LogFlowFuncLeaveRC(Status);
return Status;
}
/**
* Instantiates and starts the services.
*
* @returns VBox status code. Done bitching on failure.
*/
int supSvcCreateAndStartServices(void)
{
LogFlowFuncEnter();
/*
* Validate that all services are in the NotCreated state.
*/
unsigned i;
for (i = 0; i < RT_ELEMENTS(g_aServices); i++)
if (g_aServices[i].enmState != kSupSvcServiceState_NotCreated)
{
supSvcLogError("service %s in state %d, expected state %d (NotCreated)",
g_aServices[i].pszName, g_aServices[i].enmState, kSupSvcServiceState_NotCreated);
return VERR_WRONG_ORDER;
}
/*
* Create all the services, then start them.
*/
int rc = VINF_SUCCESS;
for (i = 0; i < RT_ELEMENTS(g_aServices); i++)
{
void *pvInstance = NULL;
int rc = g_aServices[i].pfnCreate(&pvInstance);
if (RT_FAILURE(rc))
{
Log(("supSvcCreateAndStartServices: %s -> %Rrc\n", g_aServices[i].pszName, rc));
break;
}
g_aServices[i].pvInstance = pvInstance;
g_aServices[i].enmState = kSupSvcServiceState_Paused;
}
if (RT_SUCCESS(rc))
{
for (i = 0; i < RT_ELEMENTS(g_aServices); i++)
{
g_aServices[i].pfnStart(g_aServices[i].pvInstance);
g_aServices[i].enmState = kSupSvcServiceState_Running;
}
}
else
{
/*
* Destroy any services we managed to instantiate.
*/
while (i-- > 0)
{
g_aServices[i].pfnStopAndDestroy(g_aServices[i].pvInstance, false /* fRunning */);
g_aServices[i].pvInstance = NULL;
g_aServices[i].enmState = kSupSvcServiceState_NotCreated;
}
}
LogFlow(("supSvcCreateAndStartServices: returns %Rrc\n", rc));
return rc;
}
/**
* Handle the 'create' action.
*
* @returns 0 or 1.
* @param argc The action argument count.
* @param argv The action argument vector.
*/
static int supSvcWinRunIt(int argc, char **argv)
{
LogFlowFuncEnter();
/*
* Initialize release logging.
*/
/** @todo release logging of the system-wide service. */
/*
* Parse the arguments.
*/
static const RTOPTIONDEF s_aOptions[] =
{
{ "--dummy", 'd', RTGETOPT_REQ_NOTHING }
};
int iArg = 0;
int ch;
RTGETOPTUNION Value;
while ((ch = RTGetOpt(argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), &iArg, &Value)))
switch (ch)
{
default: return supSvcDisplayGetOptError("runit", ch, argc, argv, iArg, &Value);
}
if (iArg != argc)
return supSvcDisplayTooManyArgsError("runit", argc, argv, iArg);
/*
* Register the service with the service control manager
* and start dispatching requests from it (all done by the API).
*/
static SERVICE_TABLE_ENTRY const s_aServiceStartTable[] =
{
{ SUPSVC_SERVICE_NAME, supSvcWinServiceMain },
{ NULL, NULL}
};
if (StartServiceCtrlDispatcher(&s_aServiceStartTable[0]))
{
LogFlowFuncLeave();
return 0; /* told to quit, so quit. */
}
DWORD err = GetLastError();
switch (err)
{
case ERROR_FAILED_SERVICE_CONTROLLER_CONNECT:
supSvcDisplayError("Cannot run a service from the command line. Use the 'start' action to start it the right way.\n");
break;
default:
supSvcLogError("StartServiceCtrlDispatcher failed, err=%d", err);
break;
}
return 1;
}
/** VM IPC mutex holder thread */
DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
{
LogFlowFuncEnter();
Assert (pvUser);
void **data = (void **) pvUser;
Utf8Str ipcId = (BSTR)data[0];
RTSEMEVENT finishSem = (RTSEMEVENT)data[1];
LogFlowFunc (("ipcId='%s', finishSem=%p\n", ipcId.raw(), finishSem));
HMTX ipcMutex = NULLHANDLE;
APIRET arc = ::DosOpenMutexSem ((PSZ) ipcId.raw(), &ipcMutex);
AssertMsg (arc == NO_ERROR, ("cannot open IPC mutex, arc=%ld\n", arc));
if (arc == NO_ERROR)
{
/* grab the mutex */
LogFlowFunc (("grabbing IPC mutex...\n"));
arc = ::DosRequestMutexSem (ipcMutex, SEM_IMMEDIATE_RETURN);
AssertMsg (arc == NO_ERROR, ("cannot grab IPC mutex, arc=%ld\n", arc));
if (arc == NO_ERROR)
{
/* store the answer */
data[2] = (void*)true;
/* signal we're done */
int vrc = RTThreadUserSignal (Thread);
AssertRC(vrc);
/* wait until we're signaled to release the IPC mutex */
LogFlowFunc (("waiting for termination signal..\n"));
vrc = RTSemEventWait (finishSem, RT_INDEFINITE_WAIT);
Assert (arc == ERROR_INTERRUPT || ERROR_TIMEOUT);
/* release the IPC mutex */
LogFlowFunc (("releasing IPC mutex...\n"));
arc = ::DosReleaseMutexSem (ipcMutex);
AssertMsg (arc == NO_ERROR, ("cannot release mutex, arc=%ld\n", arc));
}
::DosCloseMutexSem (ipcMutex);
}
/* store the answer */
data[1] = (void*)false;
/* signal we're done */
int vrc = RTThreadUserSignal (Thread);
AssertRC(vrc);
LogFlowFuncLeave();
return 0;
}
HRESULT VFSExplorer::i_deleteS3(TaskVFSExplorer *aTask)
{
LogFlowFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
HRESULT rc = S_OK;
RTS3 hS3 = NULL;
float fPercentStep = 100.0f / aTask->filenames.size();
try
{
int vrc = RTS3Create(&hS3, m->strUsername.c_str(), m->strPassword.c_str(),
m->strHostname.c_str(), "virtualbox-agent/" VBOX_VERSION_STRING);
if (RT_FAILURE(vrc))
throw setError(E_FAIL, tr ("Can't open S3 storage service (%Rrc)"), vrc);
RTS3SetProgressCallback(hS3, VFSExplorer::TaskVFSExplorer::uploadProgress, &aTask);
std::list<Utf8Str>::const_iterator it;
size_t i = 0;
for (it = aTask->filenames.begin();
it != aTask->filenames.end();
++it, ++i)
{
vrc = RTS3DeleteKey(hS3, m->strBucket.c_str(), (*it).c_str());
if (RT_FAILURE(vrc))
throw setError(VBOX_E_FILE_ERROR, tr ("Can't delete file '%s' (%Rrc)"), (*it).c_str(), vrc);
if (aTask->progress)
aTask->progress->SetCurrentOperationProgress((ULONG)(fPercentStep * i));
}
}
catch(HRESULT aRC)
{
rc = aRC;
}
aTask->rc = rc;
if (hS3 != NULL)
RTS3Destroy(hS3);
if (!aTask->progress.isNull())
aTask->progress->i_notifyComplete(rc);
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
void VBoxDnDDropTarget::reset(void)
{
LogFlowFuncEnter();
if (mpvData)
{
RTMemFree(mpvData);
mpvData = NULL;
}
mcbData = 0;
RT_ZERO(mFormatEtc);
mFormats = "";
}
/**
* Checks if it's possible to stop the services.
*
* @returns VBox status code, done bitching on failure.
*/
int supSvcTryStopServices(void)
{
LogFlowFuncEnter();
/*
* Check that the services are all created and count the running ones.
*/
unsigned i;
unsigned cRunning = 0;
for (i = 0; i < RT_ELEMENTS(g_aServices); i++)
if (g_aServices[i].enmState == kSupSvcServiceState_Running)
cRunning++;
else if (g_aServices[i].enmState == kSupSvcServiceState_NotCreated)
{
supSvcLogError("service %s in state %d (NotCreated), expected pause or running",
g_aServices[i].pszName, g_aServices[i].enmState, kSupSvcServiceState_NotCreated);
return VERR_WRONG_ORDER;
}
if (!cRunning)
return VINF_SUCCESS; /* all stopped, nothing to do. */
Assert(cRunning == RT_ELEMENTS(g_aServices)); /* all or nothing */
/*
* Try stop them in reverse of start order.
*/
int rc = VINF_SUCCESS;
i = RT_ELEMENTS(g_aServices);
while (i-- > 0)
{
rc = g_aServices[i].pfnTryStop(g_aServices[i].pvInstance);
if (RT_FAILURE(rc))
{
Log(("supSvcTryStopServices: %s -> %Rrc\n", g_aServices[i].pszName, rc));
break;
}
g_aServices[i].enmState = kSupSvcServiceState_Paused;
}
if (RT_FAILURE(rc))
{
/* Failed, restart the ones we succeeded in stopping. */
while (++i < RT_ELEMENTS(g_aServices))
{
g_aServices[i].pfnStart(g_aServices[i].pvInstance);
g_aServices[i].enmState = kSupSvcServiceState_Running;
}
}
LogFlow(("supSvcTryStopServices: returns %Rrc\n", rc));
return rc;
}
/**
* Implementation code for the "create base" task.
* Used as function for execution from a standalone thread.
*/
void handler()
{
LogFlowFuncEnter();
try
{
mRC = executeTask(); /* (destructor picks up mRC, see above) */
LogFlowFunc(("rc=%Rhrc\n", mRC));
}
catch (...)
{
LogRel(("Some exception in the function MediumIO::StreamTask:handler()\n"));
}
LogFlowFuncLeave();
}
/* static */
DECLCALLBACK(int) VFSExplorer::TaskVFSExplorer::taskThread(RTTHREAD /* aThread */, void *pvUser)
{
std::auto_ptr<TaskVFSExplorer> task(static_cast<TaskVFSExplorer*>(pvUser));
AssertReturn(task.get(), VERR_GENERAL_FAILURE);
VFSExplorer *pVFSExplorer = task->pVFSExplorer;
LogFlowFuncEnter();
LogFlowFunc(("VFSExplorer %p\n", pVFSExplorer));
HRESULT rc = S_OK;
switch(task->taskType)
{
case TaskVFSExplorer::Update:
{
if (pVFSExplorer->m->storageType == VFSType_File)
rc = pVFSExplorer->i_updateFS(task.get());
else if (pVFSExplorer->m->storageType == VFSType_S3)
#ifdef VBOX_WITH_S3
rc = pVFSExplorer->i_updateS3(task.get());
#else
rc = VERR_NOT_IMPLEMENTED;
#endif
break;
}
case TaskVFSExplorer::Delete:
{
if (pVFSExplorer->m->storageType == VFSType_File)
rc = pVFSExplorer->i_deleteFS(task.get());
else if (pVFSExplorer->m->storageType == VFSType_S3)
#ifdef VBOX_WITH_S3
rc = pVFSExplorer->i_deleteS3(task.get());
#else
rc = VERR_NOT_IMPLEMENTED;
#endif
break;
}
default:
AssertMsgFailed(("Invalid task type %u specified!\n", task->taskType));
break;
}
LogFlowFunc(("rc=%Rhrc\n", rc)); NOREF(rc);
LogFlowFuncLeave();
return VINF_SUCCESS;
}
int GuestCtrlCallback::Init(eVBoxGuestCtrlCallbackType enmType)
{
LogFlowFuncEnter();
AssertReturn(enmType > VBOXGUESTCTRLCALLBACKTYPE_UNKNOWN, VERR_INVALID_PARAMETER);
Assert((pvData == NULL) && !cbData);
switch (enmType)
{
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_START:
{
pvData = (PCALLBACKDATAEXECSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECSTATUS));
AssertPtrReturn(pvData, VERR_NO_MEMORY);
RT_BZERO(pvData, sizeof(CALLBACKDATAEXECSTATUS));
cbData = sizeof(CALLBACKDATAEXECSTATUS);
break;
}
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_OUTPUT:
{
pvData = (PCALLBACKDATAEXECOUT)RTMemAlloc(sizeof(CALLBACKDATAEXECOUT));
AssertPtrReturn(pvData, VERR_NO_MEMORY);
RT_BZERO(pvData, sizeof(CALLBACKDATAEXECOUT));
cbData = sizeof(CALLBACKDATAEXECOUT);
break;
}
case VBOXGUESTCTRLCALLBACKTYPE_EXEC_INPUT_STATUS:
{
PCALLBACKDATAEXECINSTATUS pData = (PCALLBACKDATAEXECINSTATUS)RTMemAlloc(sizeof(CALLBACKDATAEXECINSTATUS));
AssertPtrReturn(pData, VERR_NO_MEMORY);
RT_BZERO(pData, sizeof(CALLBACKDATAEXECINSTATUS));
cbData = sizeof(CALLBACKDATAEXECINSTATUS);
break;
}
default:
AssertMsgFailed(("Unknown callback type specified (%d)\n", enmType));
break;
}
int rc = GuestCtrlEvent::Init();
if (RT_SUCCESS(rc))
mType = enmType;
LogFlowFuncLeaveRC(rc);
return rc;
}
int GuestCtrlEvent::Wait(ULONG uTimeoutMS)
{
LogFlowFuncEnter();
AssertReturn(hEventSem != NIL_RTSEMEVENT, VERR_CANCELLED);
RTMSINTERVAL msInterval = uTimeoutMS;
if (!uTimeoutMS)
msInterval = RT_INDEFINITE_WAIT;
int rc = RTSemEventWait(hEventSem, msInterval);
if (RT_SUCCESS(rc))
ASMAtomicWriteBool(&fCompleted, true);
LogFlowFuncLeaveRC(rc);
return rc;
}
GuestDnD::GuestDnD(const ComObjPtr<Guest> &pGuest)
: m_pGuest(pGuest)
{
LogFlowFuncEnter();
m_pResponse = new GuestDnDResponse(pGuest);
/* List of supported default MIME types. */
LogRel2(("DnD: Supported default host formats:\n"));
const com::Utf8Str arrEntries[] = { VBOX_DND_FORMATS_DEFAULT };
for (size_t i = 0; i < RT_ELEMENTS(arrEntries); i++)
{
m_strDefaultFormats.push_back(arrEntries[i]);
LogRel2(("DnD: \t%s\n", arrEntries[i].c_str()));
}
}
VBoxNetLwipNAT::VBoxNetLwipNAT(SOCKET icmpsock4, SOCKET icmpsock6) : VBoxNetBaseService("VBoxNetNAT", "nat-network")
{
LogFlowFuncEnter();
m_ProxyOptions.ipv6_enabled = 0;
m_ProxyOptions.ipv6_defroute = 0;
m_ProxyOptions.icmpsock4 = icmpsock4;
m_ProxyOptions.icmpsock6 = icmpsock6;
m_ProxyOptions.tftp_root = NULL;
m_ProxyOptions.src4 = NULL;
m_ProxyOptions.src6 = NULL;
RT_ZERO(m_src4);
RT_ZERO(m_src6);
m_src4.sin_family = AF_INET;
m_src6.sin6_family = AF_INET6;
#if HAVE_SA_LEN
m_src4.sin_len = sizeof(m_src4);
m_src6.sin6_len = sizeof(m_src6);
#endif
m_ProxyOptions.nameservers = NULL;
m_LwipNetIf.name[0] = 'N';
m_LwipNetIf.name[1] = 'T';
RTMAC mac;
mac.au8[0] = 0x52;
mac.au8[1] = 0x54;
mac.au8[2] = 0;
mac.au8[3] = 0x12;
mac.au8[4] = 0x35;
mac.au8[5] = 0;
setMacAddress(mac);
RTNETADDRIPV4 address;
address.u = RT_MAKE_U32_FROM_U8( 10, 0, 2, 2); // NB: big-endian
setIpv4Address(address);
address.u = RT_H2N_U32_C(0xffffff00);
setIpv4Netmask(address);
fDontLoadRulesOnStartup = false;
for(unsigned int i = 0; i < RT_ELEMENTS(g_aGetOptDef); ++i)
addCommandLineOption(&g_aGetOptDef[i]);
LogFlowFuncLeave();
}
/** VM IPC mutex holder thread */
DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
{
LogFlowFuncEnter();
Assert (pvUser);
void **data = (void **) pvUser;
BSTR sessionId = (BSTR)data[0];
HANDLE initDoneSem = (HANDLE)data[1];
HANDLE ipcMutex = ::OpenMutex (MUTEX_ALL_ACCESS, FALSE, sessionId);
AssertMsg (ipcMutex, ("cannot open IPC mutex, err=%d\n", ::GetLastError()));
if (ipcMutex)
{
/* grab the mutex */
DWORD wrc = ::WaitForSingleObject (ipcMutex, 0);
AssertMsg (wrc == WAIT_OBJECT_0, ("cannot grab IPC mutex, err=%d\n", wrc));
if (wrc == WAIT_OBJECT_0)
{
HANDLE finishSem = ::CreateEvent (NULL, FALSE, FALSE, NULL);
AssertMsg (finishSem, ("cannot create event sem, err=%d\n", ::GetLastError()));
if (finishSem)
{
data[2] = (void*)finishSem;
/* signal we're done with init */
::SetEvent (initDoneSem);
/* wait until we're signaled to release the IPC mutex */
::WaitForSingleObject (finishSem, INFINITE);
/* release the IPC mutex */
LogFlow (("IPCMutexHolderThread(): releasing IPC mutex...\n"));
BOOL success = ::ReleaseMutex (ipcMutex);
AssertMsg (success, ("cannot release mutex, err=%d\n", ::GetLastError()));
::CloseHandle (ipcMutex);
::CloseHandle (finishSem);
}
}
}
/* signal we're done */
::SetEvent (initDoneSem);
LogFlowFuncLeave();
return 0;
}
HRESULT VFSExplorer::i_deleteFS(TaskVFSExplorer *aTask)
{
LogFlowFuncEnter();
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
AutoWriteLock appLock(this COMMA_LOCKVAL_SRC_POS);
HRESULT rc = S_OK;
float fPercentStep = 100.0f / aTask->filenames.size();
try
{
char szPath[RTPATH_MAX];
std::list<Utf8Str>::const_iterator it;
size_t i = 0;
for (it = aTask->filenames.begin();
it != aTask->filenames.end();
++it, ++i)
{
int vrc = RTPathJoin(szPath, sizeof(szPath), m->strPath.c_str(), (*it).c_str());
if (RT_FAILURE(vrc))
throw setError(E_FAIL, tr("Internal Error (%Rrc)"), vrc);
vrc = RTFileDelete(szPath);
if (RT_FAILURE(vrc))
throw setError(VBOX_E_FILE_ERROR, tr("Can't delete file '%s' (%Rrc)"), szPath, vrc);
if (aTask->progress)
aTask->progress->SetCurrentOperationProgress((ULONG)(fPercentStep * i));
}
}
catch(HRESULT aRC)
{
rc = aRC;
}
aTask->rc = rc;
if (!aTask->progress.isNull())
aTask->progress->i_notifyComplete(rc);
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
DECLCALLBACK(int) VBoxSeamlessInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
{
LogFlowFuncEnter();
PVBOXSEAMLESSCONTEXT pCtx = &g_Ctx; /* Only one instance at the moment. */
AssertPtr(pCtx);
pCtx->pEnv = pEnv;
pCtx->hModHook = NIL_RTLDRMOD;
OSVERSIONINFO OSinfo;
OSinfo.dwOSVersionInfoSize = sizeof (OSinfo);
GetVersionEx (&OSinfo);
int rc;
/* We have to jump out here when using NT4, otherwise it complains about
a missing API function "UnhookWinEvent" used by the dynamically loaded VBoxHook.dll below */
if (OSinfo.dwMajorVersion <= 4) /* Windows NT 4.0 or older */
{
Log(("VBoxTray: VBoxSeamlessInit: Windows NT 4.0 or older not supported!\n"));
rc = VERR_NOT_SUPPORTED;
}
else
{
/* Will fail if SetWinEventHook is not present (version < NT4 SP6 apparently) */
rc = RTLdrLoadAppPriv(VBOXHOOK_DLL_NAME, &pCtx->hModHook);
if (RT_SUCCESS(rc))
{
*(PFNRT *)&pCtx->pfnVBoxHookInstallWindowTracker = RTLdrGetFunction(pCtx->hModHook, "VBoxHookInstallWindowTracker");
*(PFNRT *)&pCtx->pfnVBoxHookRemoveWindowTracker = RTLdrGetFunction(pCtx->hModHook, "VBoxHookRemoveWindowTracker");
/* rc should contain success status */
AssertRC(rc); /** @todo r=andy Makes no sense here!? */
VBoxSeamlessSetSupported(TRUE);
*ppInstance = pCtx;
}
else
LogFlowFunc(("Unable to load %s, rc=%Rrc\n", VBOXHOOK_DLL_NAME, rc));
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* @interface_method_impl(PDMINVRAM,pfnFlushNvramStorage)
*/
DECLCALLBACK(int) drvNvram_pfnFlushNvramStorage(PPDMINVRAM pInterface)
{
int rc = VINF_SUCCESS;
LogFlowFuncEnter();
PNVRAM pThis = RT_FROM_MEMBER(pInterface, NVRAM, INvram);
if (!pThis->fPermanentSave)
{
LogFlowFuncLeaveRC(rc);
return rc;
}
for (int idxVariable = 0; idxVariable < pThis->cLoadedVariables; ++idxVariable)
{
drvNvram_pfnStoreNvramValue(pInterface, idxVariable, NULL, NULL, 0, NULL, 0);
}
LogFlowFuncLeaveRC(rc);
return rc;
}
static DECLCALLBACK(int) drvHostALSAAudioInit(PPDMIHOSTAUDIO pInterface)
{
NOREF(pInterface);
LogFlowFuncEnter();
int rc = audioLoadAlsaLib();
if (RT_FAILURE(rc))
LogRel(("ALSA: Failed to load the ALSA shared library, rc=%Rrc\n", rc));
else
{
#ifdef DEBUG
snd_lib_error_set_handler(drvHostALSAAudioErrorHandler);
#endif
}
return rc;
}
static UINT32 VBoxWriteNVRAMDoOp(UINT32 u32Operation)
{
UINT32 u32Rc;
LogFlowFuncEnter();
LogFlowFuncMarkVar(u32Operation, "%x");
VBoxWriteNVRAMU32Param(EFI_VM_VARIABLE_OP_START, u32Operation);
while ((u32Rc = ASMInU32(EFI_VARIABLE_OP)) == EFI_VARIABLE_OP_STATUS_BSY)
{
#if 0
MicroSecondDelay (400);
#endif
/* @todo: sleep here. bird: won't ever happen, so don't bother. */
}
LogFlowFuncMarkVar(u32Rc, "%x");
LogFlowFuncLeave();
return u32Rc;
}
DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
{
LogFlowFuncEnter();
PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */
AssertPtr(pCtx);
if (pCtx->pEnv)
{
/* Clipboard was already initialized. 2 or more instances are not supported. */
return VERR_NOT_SUPPORTED;
}
if (VbglR3AutoLogonIsRemoteSession())
{
/* Do not use clipboard for remote sessions. */
LogRel(("Clipboard: Clipboard has been disabled for a remote session\n"));
return VERR_NOT_SUPPORTED;
}
RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));
pCtx->pEnv = pEnv;
/* Check that new Clipboard API is available */
VBoxClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI);
int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);
if (RT_SUCCESS(rc))
{
rc = vboxClipboardCreateWindow(pCtx);
if (RT_SUCCESS(rc))
{
*ppInstance = pCtx;
}
else
{
VbglR3ClipboardDisconnect(pCtx->u32ClientID);
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
void VBoxSeamlessDestroy(void *pInstance)
{
LogFlowFuncEnter();
PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;
AssertPtr(pCtx);
VBoxSeamlessSetSupported(FALSE);
/* Inform the host that we no longer support the seamless window mode. */
if (pCtx->pfnVBoxHookRemoveWindowTracker)
pCtx->pfnVBoxHookRemoveWindowTracker();
if (pCtx->hModHook != NIL_RTLDRMOD)
{
RTLdrClose(pCtx->hModHook);
pCtx->hModHook = NIL_RTLDRMOD;
}
return;
}
/**
* Stops and destroys the services.
*/
void supSvcStopAndDestroyServices(void)
{
LogFlowFuncEnter();
/*
* Stop and destroy the service in reverse of start order.
*/
unsigned i = RT_ELEMENTS(g_aServices);
while (i-- > 0)
if (g_aServices[i].enmState != kSupSvcServiceState_NotCreated)
{
g_aServices[i].pfnStopAndDestroy(g_aServices[i].pvInstance,
g_aServices[i].enmState == kSupSvcServiceState_Running);
g_aServices[i].pvInstance = NULL;
g_aServices[i].enmState = kSupSvcServiceState_NotCreated;
}
LogFlowFuncLeave();
}
EFI_STATUS EFIAPI fsw_efi_DriverBinding_Supported(IN EFI_DRIVER_BINDING_PROTOCOL *This,
IN EFI_HANDLE ControllerHandle,
IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath)
{
EFI_STATUS Status;
EFI_DISK_IO *DiskIo;
// we check for both DiskIO and BlockIO protocols
// first, open DiskIO
LogFlowFuncEnter();
LogFlowFuncMarkDP(RemainingDevicePath);
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
(VOID **) &DiskIo,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_GET_PROTOCOL);
if (EFI_ERROR(Status))
{
LogFlowFuncLeaveRC(Status);
return Status;
}
// we were just checking, close it again
BS->CloseProtocol(ControllerHandle,
&PROTO_NAME(DiskIoProtocol),
This->DriverBindingHandle,
ControllerHandle);
// next, check BlockIO without actually opening it
Status = BS->OpenProtocol(ControllerHandle,
&PROTO_NAME(BlockIoProtocol),
NULL,
This->DriverBindingHandle,
ControllerHandle,
EFI_OPEN_PROTOCOL_TEST_PROTOCOL);
LogFlowFuncLeaveRC(Status);
return Status;
}
/* static */
DECLCALLBACK(int) GuestTask::taskThread(RTTHREAD /* aThread */, void *pvUser)
{
std::auto_ptr<GuestTask> task(static_cast<GuestTask*>(pvUser));
AssertReturn(task.get(), VERR_GENERAL_FAILURE);
ComObjPtr<Guest> pGuest = task->pGuest;
LogFlowFuncEnter();
HRESULT rc = S_OK;
switch (task->taskType)
{
#ifdef VBOX_WITH_GUEST_CONTROL
case TaskType_CopyFileToGuest:
{
rc = pGuest->taskCopyFileToGuest(task.get());
break;
}
case TaskType_CopyFileFromGuest:
{
rc = pGuest->taskCopyFileFromGuest(task.get());
break;
}
case TaskType_UpdateGuestAdditions:
{
rc = pGuest->taskUpdateGuestAdditions(task.get());
break;
}
#endif
default:
AssertMsgFailed(("Invalid task type %u specified!\n", task->taskType));
break;
}
LogFlowFunc(("rc=%Rhrc\n", rc));
LogFlowFuncLeave();
return VINF_SUCCESS;
}
