/**
* Sanitizes the file name component so that unsupported characters
* will be replaced by an underscore ("_").
*
* @return IPRT status code.
* @param pszPath Path to sanitize.
* @param cbPath Size (in bytes) of path to sanitize.
*/
int SharedClipboardPathSanitizeFilename(char *pszPath, size_t cbPath)
{
int rc = VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
RT_NOREF1(cbPath);
/* Replace out characters not allowed on Windows platforms, put in by RTTimeSpecToString(). */
/** @todo Use something like RTPathSanitize() if available later some time. */
static const RTUNICP s_uszValidRangePairs[] =
{
' ', ' ',
'(', ')',
'-', '.',
'0', '9',
'A', 'Z',
'a', 'z',
'_', '_',
0xa0, 0xd7af,
'\0'
};
ssize_t cReplaced = RTStrPurgeComplementSet(pszPath, s_uszValidRangePairs, '_' /* chReplacement */);
if (cReplaced < 0)
rc = VERR_INVALID_UTF8_ENCODING;
#else
RT_NOREF2(pszPath, cbPath);
#endif
return rc;
}
BOOL WINAPI DllMain(HINSTANCE hDLLInst,
DWORD fdwReason,
LPVOID lpvReserved)
{
BOOL fReturn = TRUE;
RT_NOREF2(hDLLInst, lpvReserved);
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
//RTR3InitDll(RTR3INIT_FLAGS_UNOBTRUSIVE);
D3DKMTLoad();
break;
case DLL_PROCESS_DETACH:
/// @todo RTR3Term();
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
default:
break;
}
return fReturn;
}
/* Event rate throttling timer to emulate the auxiliary device sampling rate.
*/
static DECLCALLBACK(void) ps2mThrottleTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
{
RT_NOREF2(pDevIns, pTimer);
PPS2M pThis = (PS2M *)pvUser;
uint32_t uHaveEvents;
/* Grab the lock to avoid races with PutEvent(). */
int rc = PDMCritSectEnter(pThis->pCritSectR3, VERR_SEM_BUSY);
AssertReleaseRC(rc);
#if 0
/* If the input queue is not empty, restart the timer. */
#else
/* If more movement is accumulated, report it and restart the timer. */
uHaveEvents = pThis->iAccumX | pThis->iAccumY | pThis->iAccumZ | (pThis->fCurrB != pThis->fReportedB);
LogFlowFunc(("Have%s events\n", uHaveEvents ? "" : " no"));
if (uHaveEvents)
#endif
{
/* Report accumulated data, poke the KBC, and start the timer. */
ps2mReportAccumulatedEvents(pThis, (GeneriQ *)&pThis->evtQ, true);
KBCUpdateInterrupts(pThis->pParent);
TMTimerSetMillies(pThis->CTX_SUFF(pThrottleTimer), pThis->uThrottleDelay);
}
else
pThis->fThrottleActive = false;
PDMCritSectLeave(pThis->pCritSectR3);
}
/**
* @copydoc FNPDMTHREADWAKEUPINT
*/
static DECLCALLBACK(int) pdmR3NsTxWakeUp(PVM pVM, PPDMTHREAD pThread)
{
RT_NOREF2(pVM, pThread);
LogFlow(("pdmR3NsTxWakeUp: pShaper=%p\n", pThread->pvUser));
/* Nothing to do */
return VINF_SUCCESS;
}
void PS2MRelocate(PPS2M pThis, RTGCINTPTR offDelta, PPDMDEVINS pDevIns)
{
RT_NOREF2(pDevIns, offDelta);
LogFlowFunc(("Relocating PS2M\n"));
pThis->pDelayTimerRC = TMTimerRCPtr(pThis->pDelayTimerR3);
pThis->pThrottleTimerRC = TMTimerRCPtr(pThis->pThrottleTimerR3);
}
static void WINAPI vgsvcWinMain(DWORD argc, LPTSTR *argv)
{
RT_NOREF2(argc, argv);
VGSvcVerbose(2, "Registering service control handler ...\n");
if (g_pfnRegisterServiceCtrlHandlerExA)
g_hWinServiceStatus = g_pfnRegisterServiceCtrlHandlerExA(VBOXSERVICE_NAME, vgsvcWinCtrlHandlerNt5Plus, NULL);
else
g_hWinServiceStatus = RegisterServiceCtrlHandlerA(VBOXSERVICE_NAME, vgsvcWinCtrlHandlerNt4);
if (g_hWinServiceStatus != NULL)
{
VGSvcVerbose(2, "Service control handler registered.\n");
vgsvcWinStart();
}
else
{
DWORD dwErr = GetLastError();
switch (dwErr)
{
case ERROR_INVALID_NAME:
VGSvcError("Invalid service name!\n");
break;
case ERROR_SERVICE_DOES_NOT_EXIST:
VGSvcError("Service does not exist!\n");
break;
default:
VGSvcError("Could not register service control handle! Error: %ld\n", dwErr);
break;
}
}
}
static DECLCALLBACK(int) extCallback (uint32_t u32Function, uint32_t u32Format, void *pvData, uint32_t cbData)
{
RT_NOREF2(pvData, cbData);
if (g_pClient != NULL)
{
switch (u32Function)
{
case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
{
LogRelFlow(("ANNOUNCE: g_fReadingData = %d\n", g_fReadingData));
if (g_fReadingData)
{
g_fDelayedAnnouncement = true;
g_u32DelayedFormats = u32Format;
}
else
{
vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Format);
}
} break;
case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
{
vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
} break;
default:
return VERR_NOT_SUPPORTED;
}
}
return VINF_SUCCESS;
}
/** @copydoc VDIMAGEBACKEND::pfnGetComment */
static DECLCALLBACK(int) rawGetComment(void *pBackendData, char *pszComment,
size_t cbComment)
{
RT_NOREF2(pszComment, cbComment);
LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
AssertPtrReturn(pImage, VERR_VD_NOT_OPENED);
LogFlowFunc(("returns %Rrc comment='%s'\n", VERR_NOT_SUPPORTED, pszComment));
return VERR_NOT_SUPPORTED;
}
/* The auxiliary device is specified to take up to about 500 milliseconds. We need
* to delay sending the result to the host for at least a tiny little while.
*/
static DECLCALLBACK(void) ps2mDelayTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
{
RT_NOREF2(pDevIns, pTimer);
PPS2M pThis = (PS2M *)pvUser;
LogFlowFunc(("Delay timer: cmd %02X\n", pThis->u8CurrCmd));
Assert(pThis->u8CurrCmd == ACMD_RESET);
ps2mReset(pThis);
/// @todo Might want a PS2MCompleteCommand() to push last response, clear command, and kick the KBC...
/* Give the KBC a kick. */
KBCUpdateInterrupts(pThis->pParent);
}
tstVMMConfigConstructor(PUVM pUVM, PVM pVM, void *pvUser)
{
RT_NOREF2(pUVM, pvUser);
int rc = CFGMR3ConstructDefaultTree(pVM);
if (RT_SUCCESS(rc))
{
PCFGMNODE pRoot = CFGMR3GetRoot(pVM);
if (g_cCpus < 2)
{
rc = CFGMR3InsertInteger(pRoot, "HMEnabled", false);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertInteger(pRoot,\"HMEnabled\",) -> %Rrc\n", rc), rc);
}
else if (g_cCpus > 1)
{
CFGMR3RemoveValue(pRoot, "NumCPUs");
rc = CFGMR3InsertInteger(pRoot, "NumCPUs", g_cCpus);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertInteger(pRoot,\"NumCPUs\",) -> %Rrc\n", rc), rc);
CFGMR3RemoveValue(pRoot, "HwVirtExtForced");
rc = CFGMR3InsertInteger(pRoot, "HwVirtExtForced", true);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertInteger(pRoot,\"HwVirtExtForced\",) -> %Rrc\n", rc), rc);
PCFGMNODE pHwVirtExt = CFGMR3GetChild(pRoot, "HWVirtExt");
CFGMR3RemoveNode(pHwVirtExt);
rc = CFGMR3InsertNode(pRoot, "HWVirtExt", &pHwVirtExt);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertNode(pRoot,\"HWVirtExt\",) -> %Rrc\n", rc), rc);
rc = CFGMR3InsertInteger(pHwVirtExt, "Enabled", true);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertInteger(pHwVirtExt,\"Enabled\",) -> %Rrc\n", rc), rc);
rc = CFGMR3InsertInteger(pHwVirtExt, "64bitEnabled", false);
RTTESTI_CHECK_MSG_RET(RT_SUCCESS(rc),
("CFGMR3InsertInteger(pHwVirtExt,\"64bitEnabled\",) -> %Rrc\n", rc), rc);
}
}
return rc;
}
int __cdecl main(int argc, char **argv)
{
RT_NOREF2(argc, argv);
return VBoxNetLwfUninstall();
}
int SharedClipboardPathSanitize(char *pszPath, size_t cbPath)
{
/** @todo */
RT_NOREF2(pszPath, cbPath);
return VINF_SUCCESS;
}
/**
* @interface_method_impl{PDMDEVREG,pfnConstruct}
*/
static DECLCALLBACK(int) gimdevR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
{
PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
RT_NOREF2(iInstance, pCfg);
Assert(iInstance == 0);
PGIMDEV pThis = PDMINS_2_DATA(pDevIns, PGIMDEV);
/*
* Initialize relevant state bits.
*/
pThis->pDevInsR3 = pDevIns;
pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
/*
* Get debug setup requirements from GIM.
*/
PVM pVM = PDMDevHlpGetVM(pDevIns);
int rc = GIMR3GetDebugSetup(pVM, &pThis->DbgSetup);
if ( RT_SUCCESS(rc)
&& pThis->DbgSetup.cbDbgRecvBuf > 0)
{
/*
* Attach the stream driver for the debug connection.
*/
PPDMISTREAM pDbgDrvStream = NULL;
pThis->IDbgBase.pfnQueryInterface = gimdevR3QueryInterface;
rc = PDMDevHlpDriverAttach(pDevIns, GIMDEV_DEBUG_LUN, &pThis->IDbgBase, &pThis->pDbgDrvBase, "GIM Debug Port");
if (RT_SUCCESS(rc))
{
pDbgDrvStream = PDMIBASE_QUERY_INTERFACE(pThis->pDbgDrvBase, PDMISTREAM);
if (pDbgDrvStream)
LogRel(("GIMDev: LUN#%u: Debug port configured\n", GIMDEV_DEBUG_LUN));
else
{
LogRel(("GIMDev: LUN#%u: No unit\n", GIMDEV_DEBUG_LUN));
rc = VERR_INTERNAL_ERROR_2;
}
}
else
{
pThis->pDbgDrvBase = NULL;
LogRel(("GIMDev: LUN#%u: No debug port configured! rc=%Rrc\n", GIMDEV_DEBUG_LUN, rc));
}
if (!pDbgDrvStream)
{
Assert(rc != VINF_SUCCESS);
return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
N_("Debug port configuration expected when GIM configured with debugging support"));
}
void *pvDbgRecvBuf = RTMemAllocZ(pThis->DbgSetup.cbDbgRecvBuf);
if (RT_UNLIKELY(!pvDbgRecvBuf))
{
LogRel(("GIMDev: Failed to alloc %u bytes for debug receive buffer\n", pThis->DbgSetup.cbDbgRecvBuf));
return VERR_NO_MEMORY;
}
/*
* Update the shared debug struct.
*/
pThis->Dbg.pDbgDrvStream = pDbgDrvStream;
pThis->Dbg.pvDbgRecvBuf = pvDbgRecvBuf;
pThis->Dbg.cbDbgRecvBufRead = 0;
pThis->Dbg.fDbgRecvBufRead = false;
/*
* Create the sempahore and the debug receive thread itself.
*/
rc = RTSemEventMultiCreate(&pThis->Dbg.hDbgRecvThreadSem);
if (RT_SUCCESS(rc))
{
rc = RTThreadCreate(&pThis->hDbgRecvThread, gimDevR3DbgRecvThread, pDevIns, 0 /*cbStack*/, RTTHREADTYPE_IO,
RTTHREADFLAGS_WAITABLE, "GIMDebugRecv");
if (RT_FAILURE(rc))
{
RTSemEventMultiDestroy(pThis->Dbg.hDbgRecvThreadSem);
pThis->Dbg.hDbgRecvThreadSem = NIL_RTSEMEVENTMULTI;
RTMemFree(pThis->Dbg.pvDbgRecvBuf);
pThis->Dbg.pvDbgRecvBuf = NULL;
return rc;
}
}
else
return rc;
}
/*
* Register this device with the GIM component.
*/
GIMR3GimDeviceRegister(pVM, pDevIns, pThis->DbgSetup.cbDbgRecvBuf ? &pThis->Dbg : NULL);
/*
* Get the MMIO2 regions from the GIM provider.
*/
uint32_t cRegions = 0;
PGIMMMIO2REGION pRegionsR3 = GIMR3GetMmio2Regions(pVM, &cRegions);
if ( cRegions
&& pRegionsR3)
{
/*
* Register the MMIO2 regions.
*/
PGIMMMIO2REGION pCur = pRegionsR3;
for (uint32_t i = 0; i < cRegions; i++, pCur++)
{
Assert(!pCur->fRegistered);
rc = PDMDevHlpMMIO2Register(pDevIns, NULL, pCur->iRegion, pCur->cbRegion, 0 /* fFlags */, &pCur->pvPageR3,
pCur->szDescription);
if (RT_FAILURE(rc))
return rc;
pCur->fRegistered = true;
#if defined(VBOX_WITH_2X_4GB_ADDR_SPACE)
RTR0PTR pR0Mapping = 0;
rc = PDMDevHlpMMIO2MapKernel(pDevIns, NULL, pCur->iRegion, 0 /* off */, pCur->cbRegion, pCur->szDescription,
&pR0Mapping);
AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMapMMIO2IntoR0(%#x,) -> %Rrc\n", pCur->cbRegion, rc), rc);
pCur->pvPageR0 = pR0Mapping;
#else
pCur->pvPageR0 = (RTR0PTR)pCur->pvPageR3;
#endif
/*
* Map into RC if required.
*/
if (pCur->fRCMapping)
{
RTRCPTR pRCMapping = 0;
rc = PDMDevHlpMMHyperMapMMIO2(pDevIns, NULL, pCur->iRegion, 0 /* off */, pCur->cbRegion, pCur->szDescription,
&pRCMapping);
AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMMHyperMapMMIO2(%#x,) -> %Rrc\n", pCur->cbRegion, rc), rc);
pCur->pvPageRC = pRCMapping;
}
else
pCur->pvPageRC = NIL_RTRCPTR;
LogRel(("GIMDev: Registered %s\n", pCur->szDescription));
}
}
/** @todo Register SSM: PDMDevHlpSSMRegister(). */
/** @todo Register statistics: STAM_REG(). */
/** @todo Register DBGFInfo: PDMDevHlpDBGFInfoRegister(). */
return VINF_SUCCESS;
}
/**
* Worker for rtDbgSymCacheAddDebugFile that adds PDBs to the cace.
*
* @returns IPRT status code
* @param pszPath The path to the PDB file.
* @param pCfg The configuration.
* @param hFile Handle to the file.
*/
static int rtDbgSymCacheAddDebugPdb(const char *pszPath, PCRTDBGSYMCACHEADDCFG pCfg, RTFILE hFile)
{
RT_NOREF2(pCfg, hFile);
return RTMsgErrorRc(VERR_NOT_IMPLEMENTED, "PDB support not implemented: '%s'", pszPath);
}
static RTEXITCODE gzipListFile(PRTVFSIOSTREAM phVfsSrc, PCRTGZIPCMDOPTS pOpts)
{
RT_NOREF2(phVfsSrc, pOpts);
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Listing has not been implemented");
}
tstVMREQConfigConstructor(PUVM pUVM, PVM pVM, void *pvUser)
{
RT_NOREF2(pUVM, pvUser);
return CFGMR3ConstructDefaultTree(pVM);
}