/**
* Writes the properties that won't change while the service is running.
*
* Errors are ignored.
*/
static void vboxserviceVMInfoWriteFixedProperties(void)
{
/*
* First get OS information that won't change.
*/
char szInfo[256];
int rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Product",
"%s", RT_FAILURE(rc) ? "" : szInfo);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Release",
"%s", RT_FAILURE(rc) ? "" : szInfo);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/Version",
"%s", RT_FAILURE(rc) ? "" : szInfo);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestInfo/OS/ServicePack",
"%s", RT_FAILURE(rc) ? "" : szInfo);
/*
* Retrieve version information about Guest Additions and installed files (components).
*/
char *pszAddVer;
char *pszAddVerExt;
char *pszAddRev;
rc = VbglR3GetAdditionsVersion(&pszAddVer, &pszAddVerExt, &pszAddRev);
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Version",
"%s", RT_FAILURE(rc) ? "" : pszAddVer);
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/VersionExt",
"%s", RT_FAILURE(rc) ? "" : pszAddVerExt);
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/Revision",
"%s", RT_FAILURE(rc) ? "" : pszAddRev);
if (RT_SUCCESS(rc))
{
RTStrFree(pszAddVer);
RTStrFree(pszAddVerExt);
RTStrFree(pszAddRev);
}
#ifdef RT_OS_WINDOWS
/*
* Do windows specific properties.
*/
char *pszInstDir;
rc = VbglR3GetAdditionsInstallationPath(&pszInstDir);
VBoxServiceWritePropF(g_uVMInfoGuestPropSvcClientID, "/VirtualBox/GuestAdd/InstallDir",
"%s", RT_FAILURE(rc) ? "" : pszInstDir);
if (RT_SUCCESS(rc))
RTStrFree(pszInstDir);
VBoxServiceWinGetComponentVersions(g_uVMInfoGuestPropSvcClientID);
#endif
}
/** Really ugly hack to shut up a silly check in AppKit. */
static void ShutUpAppKit(void)
{
/* Check for Snow Leopard or higher */
char szInfo[64];
int rc = RTSystemQueryOSInfo (RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
if ( RT_SUCCESS (rc)
&& szInfo[0] == '1') /* higher than 1x.x.x */
{
/*
* Find issetguid() and make it always return 0 by modifying the code.
*/
void *addr = dlsym(RTLD_DEFAULT, "issetugid");
int rc = mprotect((void *)((uintptr_t)addr & ~(uintptr_t)0xfff), 0x2000, PROT_WRITE|PROT_READ|PROT_EXEC);
if (!rc)
ASMAtomicWriteU32((volatile uint32_t *)addr, 0xccc3c031); /* xor eax, eax; ret; int3 */
}
}
/** Reports our current status to the SCM. */
static BOOL vboxServiceWinSetStatus(DWORD dwStatus, DWORD dwCheckPoint)
{
if (g_hWinServiceStatus == NULL) /* Program could be in testing mode, so no service environment available. */
return FALSE;
VBoxServiceVerbose(2, "Setting service status to: %ld\n", dwStatus);
g_dwWinServiceLastStatus = dwStatus;
SERVICE_STATUS ss;
RT_ZERO(ss);
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ss.dwCurrentState = dwStatus;
/* Don't accept controls when in start pending state. */
if (ss.dwCurrentState != SERVICE_START_PENDING)
{
ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
#ifndef TARGET_NT4
/* Don't use SERVICE_ACCEPT_SESSIONCHANGE on Windows 2000.
* This makes SCM angry. */
char szOSVersion[32];
int rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE,
szOSVersion, sizeof(szOSVersion));
if (RT_SUCCESS(rc))
{
if (RTStrVersionCompare(szOSVersion, "5.1") >= 0)
ss.dwControlsAccepted |= SERVICE_ACCEPT_SESSIONCHANGE;
}
else
VBoxServiceError("Error determining OS version, rc=%Rrc\n", rc);
#endif
}
ss.dwWin32ExitCode = NO_ERROR;
ss.dwServiceSpecificExitCode = 0; /* Not used */
ss.dwCheckPoint = dwCheckPoint;
ss.dwWaitHint = 3000;
BOOL fStatusSet = SetServiceStatus(g_hWinServiceStatus, &ss);
if (!fStatusSet)
VBoxServiceError("Error reporting service status=%ld (controls=%x, checkpoint=%ld) to SCM: %ld\n",
dwStatus, ss.dwControlsAccepted, dwCheckPoint, GetLastError());
return fStatusSet;
}
/** Check if the host kernel supports VT-x or not.
*
* Older Linux kernels clear the VMXE bit in the CR4 register (function
* tlb_flush_all()) leading to a host kernel panic.
*/
int suplibOsQueryVTxSupported(void)
{
char szBuf[256];
int rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szBuf, sizeof(szBuf));
if (RT_SUCCESS(rc))
{
char *pszNext;
uint32_t uA, uB, uC;
rc = RTStrToUInt32Ex(szBuf, &pszNext, 10, &uA);
if ( RT_SUCCESS(rc)
&& *pszNext == '.')
{
/*
* new version number scheme starting with Linux 3.0
*/
if (uA >= 3)
return VINF_SUCCESS;
rc = RTStrToUInt32Ex(pszNext+1, &pszNext, 10, &uB);
if ( RT_SUCCESS(rc)
&& *pszNext == '.')
{
rc = RTStrToUInt32Ex(pszNext+1, &pszNext, 10, &uC);
if (RT_SUCCESS(rc))
{
uint32_t uLinuxVersion = (uA << 16) + (uB << 8) + uC;
if (uLinuxVersion >= (2 << 16) + (6 << 8) + 13)
return VINF_SUCCESS;
}
}
}
}
return VERR_SUPDRV_KERNEL_TOO_OLD_FOR_VTX;
}
/**
* Release logger callback.
*
* @return IPRT status code.
* @param pLoggerRelease
* @param enmPhase
* @param pfnLog
*/
static void VBoxServiceLogHeaderFooter(PRTLOGGER pLoggerRelease, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
{
/* Some introductory information. */
static RTTIMESPEC s_TimeSpec;
char szTmp[256];
if (enmPhase == RTLOGPHASE_BEGIN)
RTTimeNow(&s_TimeSpec);
RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
switch (enmPhase)
{
case RTLOGPHASE_BEGIN:
{
pfnLog(pLoggerRelease,
"VBoxService %s r%s (verbosity: %d) %s (%s %s) release log\n"
"Log opened %s\n",
RTBldCfgVersion(), RTBldCfgRevisionStr(), g_cVerbosity, VBOX_BUILD_TARGET,
__DATE__, __TIME__, szTmp);
int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Version: %s\n", szTmp);
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pLoggerRelease, "OS Service Pack: %s\n", szTmp);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
pfnLog(pLoggerRelease,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
break;
}
case RTLOGPHASE_PREROTATE:
pfnLog(pLoggerRelease, "Log rotated - Log started %s\n", szTmp);
break;
case RTLOGPHASE_POSTROTATE:
pfnLog(pLoggerRelease, "Log continuation - Log started %s\n", szTmp);
break;
case RTLOGPHASE_END:
pfnLog(pLoggerRelease, "End of log file - Log started %s\n", szTmp);
break;
default:
/* nothing */
;
}
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTSystemQueryOsInfo", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
/*
* Simple stuff.
*/
char szInfo[_4K];
rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "PRODUCT: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "RELEASE: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "VERSION: \"%s\", rc=%Rrc\n", szInfo, rc);
rc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szInfo, sizeof(szInfo));
RTTestIPrintf(RTTESTLVL_ALWAYS, "SERVICE_PACK: \"%s\", rc=%Rrc\n", szInfo, rc);
uint64_t cbTotal;
rc = RTSystemQueryTotalRam(&cbTotal);
RTTestIPrintf(RTTESTLVL_ALWAYS, "Total RAM: %'RU64 Bytes (%RU64 KB, %RU64 MB)\n",
cbTotal, cbTotal / _1K, cbTotal / _1M);
uint64_t cbAvailable;
rc = RTSystemQueryAvailableRam(&cbAvailable);
RTTestIPrintf(RTTESTLVL_ALWAYS, "Available RAM: %'RU64 Bytes (%RU64 KB, %RU64 MB)\n",
cbAvailable, cbAvailable / _1K, cbAvailable / _1M);
/*
* Check that unsupported stuff is terminated correctly.
*/
for (int i = RTSYSOSINFO_INVALID + 1; i < RTSYSOSINFO_END; i++)
{
memset(szInfo, ' ', sizeof(szInfo));
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if ( rc == VERR_NOT_SUPPORTED
&& szInfo[0] != '\0')
RTTestIFailed("level=%d; unterminated buffer on VERR_NOT_SUPPORTED\n", i);
else if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
RTTESTI_CHECK(RTStrEnd(szInfo, sizeof(szInfo)) != NULL);
else if (rc != VERR_NOT_SUPPORTED)
RTTestIFailed("level=%d unexpected rc=%Rrc\n", i, rc);
}
/*
* Check buffer overflow
*/
RTAssertSetQuiet(true);
RTAssertSetMayPanic(false);
for (int i = RTSYSDMISTR_INVALID + 1; i < RTSYSDMISTR_END; i++)
{
RTTESTI_CHECK_RC(RTSystemQueryDmiString((RTSYSDMISTR)i, szInfo, 0), VERR_INVALID_PARAMETER);
/* Get the length of the info and check that we get overflow errors for
everything less that it. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, sizeof(szInfo));
if (RT_FAILURE(rc))
continue;
size_t const cchInfo = strlen(szInfo);
for (size_t cch = 1; cch < sizeof(szInfo) && cch < cchInfo; cch++)
{
memset(szInfo, 0x7f, sizeof(szInfo));
RTTESTI_CHECK_RC(RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cch), VERR_BUFFER_OVERFLOW);
/* check the padding. */
for (size_t off = cch; off < sizeof(szInfo); off++)
if (szInfo[off] != 0x7f)
{
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu, off=%zu: Wrote too much!\n", i, rc, cch, off);
break;
}
/* check for zero terminator. */
if (!RTStrEnd(szInfo, cch))
RTTestIFailed("level=%d, rc=%Rrc, cch=%zu: Buffer not terminated!\n", i, rc, cch);
}
/* Check that the exact length works. */
rc = RTSystemQueryOSInfo((RTSYSOSINFO)i, szInfo, cchInfo + 1);
if (rc != VINF_SUCCESS)
RTTestIFailed("level=%d: rc=%Rrc when specifying exactly right buffer length (%zu)\n", i, rc, cchInfo + 1);
}
return RTTestSummaryAndDestroy(hTest);
}
static int vboxInitLogging(const char *pszFilename, bool bGenNameSuffix)
{
PRTLOGGER loggerRelease;
static const char * const s_apszGroups[] = VBOX_LOGGROUP_NAMES;
RTUINT fFlags = RTLOGFLAGS_PREFIX_TIME_PROG;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fFlags |= RTLOGFLAGS_USECRLF;
#endif
char szError[RTPATH_MAX + 128] = "";
const char * pszFilenameFmt;
RTLOGDEST enmLogDest;
if(pszFilename)
{
if(bGenNameSuffix)
pszFilenameFmt = "%s.%ld.log";
else
pszFilenameFmt = "%s";
enmLogDest = RTLOGDEST_FILE;
}
else
{
pszFilenameFmt = NULL;
enmLogDest = RTLOGDEST_STDOUT;
}
int vrc = RTLogCreateEx(&loggerRelease, fFlags, "all",
"VBOX_RELEASE_LOG", RT_ELEMENTS(s_apszGroups), s_apszGroups, enmLogDest,
NULL /* pfnBeginEnd */, 0 /* cHistory */, 0 /* cbHistoryFileMax */, 0 /* uHistoryTimeMax */,
szError, sizeof(szError), pszFilenameFmt, pszFilename, RTTimeMilliTS());
if (RT_SUCCESS(vrc))
{
/* some introductory information */
RTTIMESPEC timeSpec;
char szTmp[256];
RTTimeSpecToString(RTTimeNow(&timeSpec), szTmp, sizeof(szTmp));
RTLogRelLogger(loggerRelease, 0, ~0U,
"VBoxTestGL %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
"EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
#endif
"Log opened %s\n",
VBOX_VERSION_STRING, RTBldCfgRevision(), VBOX_BUILD_TARGET,
__DATE__, __TIME__, szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Version: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
RTLogRelLogger(loggerRelease, 0, ~0U, "OS Service Pack: %s\n", szTmp);
// RTLogRelLogger(loggerRelease, 0, ~0U, "Host RAM: %uMB RAM, available: %uMB\n",
// uHostRamMb, uHostRamAvailMb);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
RTLogRelLogger(loggerRelease, 0, ~0U,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
/* register this logger as the release logger */
RTLogRelSetDefaultInstance(loggerRelease);
return VINF_SUCCESS;
}
return vrc;
}
static void vboxHeaderFooter(PRTLOGGER pReleaseLogger, RTLOGPHASE enmPhase, PFNRTLOGPHASEMSG pfnLog)
{
/* some introductory information */
static RTTIMESPEC s_TimeSpec;
char szTmp[256];
if (enmPhase == RTLOGPHASE_BEGIN)
RTTimeNow(&s_TimeSpec);
RTTimeSpecToString(&s_TimeSpec, szTmp, sizeof(szTmp));
switch (enmPhase)
{
case RTLOGPHASE_BEGIN:
{
bool fOldBuffered = RTLogSetBuffering(pReleaseLogger, true /*fBuffered*/);
pfnLog(pReleaseLogger,
"VirtualBox %s %s r%u %s (%s %s) release log\n"
#ifdef VBOX_BLEEDING_EDGE
"EXPERIMENTAL build " VBOX_BLEEDING_EDGE "\n"
#endif
"Log opened %s\n",
g_pszLogEntity, VBOX_VERSION_STRING, RTBldCfgRevision(),
RTBldCfgTargetDotArch(), __DATE__, __TIME__, szTmp);
int vrc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Product: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Release: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Version: %s\n", szTmp);
vrc = RTSystemQueryOSInfo(RTSYSOSINFO_SERVICE_PACK, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "OS Service Pack: %s\n", szTmp);
vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_NAME, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "DMI Product Name: %s\n", szTmp);
vrc = RTSystemQueryDmiString(RTSYSDMISTR_PRODUCT_VERSION, szTmp, sizeof(szTmp));
if (RT_SUCCESS(vrc) || vrc == VERR_BUFFER_OVERFLOW)
pfnLog(pReleaseLogger, "DMI Product Version: %s\n", szTmp);
uint64_t cbHostRam = 0, cbHostRamAvail = 0;
vrc = RTSystemQueryTotalRam(&cbHostRam);
if (RT_SUCCESS(vrc))
vrc = RTSystemQueryAvailableRam(&cbHostRamAvail);
if (RT_SUCCESS(vrc))
pfnLog(pReleaseLogger, "Host RAM: %lluMB RAM, available: %lluMB\n",
cbHostRam / _1M, cbHostRamAvail / _1M);
/* the package type is interesting for Linux distributions */
char szExecName[RTPATH_MAX];
char *pszExecName = RTProcGetExecutablePath(szExecName, sizeof(szExecName));
pfnLog(pReleaseLogger,
"Executable: %s\n"
"Process ID: %u\n"
"Package type: %s"
#ifdef VBOX_OSE
" (OSE)"
#endif
"\n",
pszExecName ? pszExecName : "unknown",
RTProcSelf(),
VBOX_PACKAGE_STRING);
RTLogSetBuffering(pReleaseLogger, fOldBuffered);
break;
}
case RTLOGPHASE_PREROTATE:
pfnLog(pReleaseLogger, "Log rotated - Log started %s\n", szTmp);
break;
case RTLOGPHASE_POSTROTATE:
pfnLog(pReleaseLogger, "Log continuation - Log started %s\n", szTmp);
break;
case RTLOGPHASE_END:
pfnLog(pReleaseLogger, "End of log file - Log started %s\n", szTmp);
break;
default:
/* nothing */;
}
}
DECLHIDDEN(int) VUSBSnifferCreate(PVUSBSNIFFER phSniffer, uint32_t fFlags,
const char *pszCaptureFilename, const char *pszDesc)
{
int rc = VINF_SUCCESS;
PVUSBSNIFFERINT pThis = NULL;
pThis = (PVUSBSNIFFERINT)RTMemAllocZ(sizeof(VUSBSNIFFERINT));
if (pThis)
{
pThis->hFile = NIL_RTFILE;
pThis->cbBlockCur = 0;
pThis->cbBlockMax = 0;
pThis->pbBlockData = NULL;
pThis->hMtx = NIL_RTSEMFASTMUTEX;
rc = RTSemFastMutexCreate(&pThis->hMtx);
if (RT_SUCCESS(rc))
{
rc = RTFileOpen(&pThis->hFile, pszCaptureFilename, RTFILE_O_DENY_NONE | RTFILE_O_CREATE_REPLACE | RTFILE_O_WRITE | RTFILE_O_READ);
if (RT_SUCCESS(rc))
{
/* Write header and link type blocks. */
DumpFileShb Shb;
Shb.Hdr.u32BlockType = DUMPFILE_SHB_BLOCK_TYPE;
Shb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
Shb.u32ByteOrderMagic = DUMPFILE_SHB_BYTE_ORDER_MAGIC;
Shb.u16VersionMajor = DUMPFILE_SHB_VERSION_MAJOR;
Shb.u16VersionMinor = DUMPFILE_SHB_VERSION_MINOR;
Shb.u64SectionLength = UINT64_C(0xffffffffffffffff); /* -1 */
/* Write the blocks. */
rc = vusbSnifferBlockNew(pThis, &Shb.Hdr, sizeof(Shb));
if (RT_SUCCESS(rc))
{
const char *pszOpt = RTBldCfgTargetDotArch();
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_HARDWARE, pszOpt, strlen(pszOpt) + 1);
}
if (RT_SUCCESS(rc))
{
char szTmp[512];
size_t cbTmp = sizeof(szTmp);
RT_ZERO(szTmp);
/* Build the OS code. */
rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, cbTmp);
if (RT_SUCCESS(rc))
{
size_t cb = strlen(szTmp);
szTmp[cb] = ' ';
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, &szTmp[cb + 1], cbTmp - (cb + 1));
if (RT_SUCCESS(rc))
{
cb = strlen(szTmp);
szTmp[cb] = ' ';
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, &szTmp[cb + 1], cbTmp - (cb + 1));
}
}
if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_OS, szTmp, strlen(szTmp) + 1);
else
rc = VINF_SUCCESS; /* Skip OS code if building the string failed. */
}
if (RT_SUCCESS(rc))
{
/** @todo: Add product info. */
}
if (RT_SUCCESS(rc))
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
if (RT_SUCCESS(rc))
rc = vusbSnifferBlockCommit(pThis);
/* Write Interface descriptor block. */
if (RT_SUCCESS(rc))
{
DumpFileIdb Idb;
Idb.Hdr.u32BlockType = DUMPFILE_IDB_BLOCK_TYPE;
Idb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
Idb.u16LinkType = DUMPFILE_IDB_LINK_TYPE_USB_LINUX_MMAPED;
Idb.u16Reserved = 0;
Idb.u32SnapLen = UINT32_C(0xffffffff);
rc = vusbSnifferBlockNew(pThis, &Idb.Hdr, sizeof(Idb));
if (RT_SUCCESS(rc))
{
uint8_t u8TsResolution = 9; /* Nano second resolution. */
/* Add timestamp resolution option. */
rc = vusbSnifferAddOption(pThis, DUMPFILE_IDB_OPTION_TS_RESOLUTION,
&u8TsResolution, sizeof(u8TsResolution));
}
if (RT_SUCCESS(rc))
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
if (RT_SUCCESS(rc))
rc = vusbSnifferBlockCommit(pThis);
}
if (RT_SUCCESS(rc))
{
*phSniffer = pThis;
return VINF_SUCCESS;
}
RTFileClose(pThis->hFile);
pThis->hFile = NIL_RTFILE;
RTFileDelete(pszCaptureFilename);
}
RTSemFastMutexDestroy(pThis->hMtx);
pThis->hMtx = NIL_RTSEMFASTMUTEX;
}
RTMemFree(pThis);
}
else
rc = VERR_NO_MEMORY;
return rc;
}
/** @copydoc VUSBSNIFFERFMT::pfnInit */
static DECLCALLBACK(int) vusbSnifferFmtPcanNgInit(PVUSBSNIFFERFMTINT pThis, PVUSBSNIFFERSTRM pStrm)
{
int rc = VINF_SUCCESS;
pThis->pStrm = pStrm;
pThis->cbBlockCur = 0;
pThis->cbBlockMax = 0;
pThis->pbBlockData = NULL;
/* Write header and link type blocks. */
DumpFileShb Shb;
Shb.Hdr.u32BlockType = DUMPFILE_SHB_BLOCK_TYPE;
Shb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
Shb.u32ByteOrderMagic = DUMPFILE_SHB_BYTE_ORDER_MAGIC;
Shb.u16VersionMajor = DUMPFILE_SHB_VERSION_MAJOR;
Shb.u16VersionMinor = DUMPFILE_SHB_VERSION_MINOR;
Shb.u64SectionLength = UINT64_C(0xffffffffffffffff); /* -1 */
/* Write the blocks. */
rc = vusbSnifferBlockNew(pThis, &Shb.Hdr, sizeof(Shb));
if (RT_SUCCESS(rc))
{
const char *pszOpt = RTBldCfgTargetDotArch();
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_HARDWARE, pszOpt, strlen(pszOpt) + 1);
}
if (RT_SUCCESS(rc))
{
char szTmp[512];
size_t cbTmp = sizeof(szTmp);
RT_ZERO(szTmp);
/* Build the OS code. */
rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szTmp, cbTmp);
if (RT_SUCCESS(rc))
{
size_t cb = strlen(szTmp);
szTmp[cb] = ' ';
rc = RTSystemQueryOSInfo(RTSYSOSINFO_RELEASE, &szTmp[cb + 1], cbTmp - (cb + 1));
if (RT_SUCCESS(rc))
{
cb = strlen(szTmp);
szTmp[cb] = ' ';
rc = RTSystemQueryOSInfo(RTSYSOSINFO_VERSION, &szTmp[cb + 1], cbTmp - (cb + 1));
}
}
if (RT_SUCCESS(rc) || rc == VERR_BUFFER_OVERFLOW)
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_OS, szTmp, strlen(szTmp) + 1);
else
rc = VINF_SUCCESS; /* Skip OS code if building the string failed. */
}
if (RT_SUCCESS(rc))
{
/** @todo: Add product info. */
}
if (RT_SUCCESS(rc))
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
if (RT_SUCCESS(rc))
rc = vusbSnifferBlockCommit(pThis);
/* Write Interface descriptor block. */
if (RT_SUCCESS(rc))
{
DumpFileIdb Idb;
Idb.Hdr.u32BlockType = DUMPFILE_IDB_BLOCK_TYPE;
Idb.Hdr.u32BlockTotalLength = 0; /* Filled out by lower layer. */
Idb.u16LinkType = DUMPFILE_IDB_LINK_TYPE_USB_LINUX_MMAPED;
Idb.u16Reserved = 0;
Idb.u32SnapLen = UINT32_C(0xffffffff);
rc = vusbSnifferBlockNew(pThis, &Idb.Hdr, sizeof(Idb));
if (RT_SUCCESS(rc))
{
uint8_t u8TsResolution = 9; /* Nano second resolution. */
/* Add timestamp resolution option. */
rc = vusbSnifferAddOption(pThis, DUMPFILE_IDB_OPTION_TS_RESOLUTION,
&u8TsResolution, sizeof(u8TsResolution));
}
if (RT_SUCCESS(rc))
rc = vusbSnifferAddOption(pThis, DUMPFILE_OPTION_CODE_END, NULL, 0);
if (RT_SUCCESS(rc))
rc = vusbSnifferBlockCommit(pThis);
}
if ( RT_FAILURE(rc)
&& pThis->pbBlockData)
RTMemFree(pThis->pbBlockData);
return rc;
}
