int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_UINT32 },
{ "--num-pages", 'n', RTGETOPT_REQ_UINT32 },
{ "--page-at-a-time", 'c', RTGETOPT_REQ_UINT32 },
{ "--page-file", 'f', RTGETOPT_REQ_STRING },
{ "--offset", 'o', RTGETOPT_REQ_UINT64 },
};
const char *pszPageFile = NULL;
uint64_t offPageFile = 0;
uint32_t cIterations = 1;
uint32_t cPagesAtATime = 1;
RTGETOPTUNION Val;
RTGETOPTSTATE State;
int rc = RTGetOptInit(&State, argc, argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), 1, 0);
AssertRCReturn(rc, 1);
while ((rc = RTGetOpt(&State, &Val)))
{
switch (rc)
{
case 'n':
g_cPages = Val.u32;
if (g_cPages * PAGE_SIZE * 4 / (PAGE_SIZE * 4) != g_cPages)
return Error("The specified page count is too high: %#x (%#llx bytes)\n", g_cPages, (uint64_t)g_cPages * PAGE_SHIFT);
if (g_cPages < 1)
return Error("The specified page count is too low: %#x\n", g_cPages);
break;
case 'i':
cIterations = Val.u32;
if (cIterations < 1)
return Error("The number of iterations must be 1 or higher\n");
break;
case 'c':
cPagesAtATime = Val.u32;
if (cPagesAtATime < 1 || cPagesAtATime > 10240)
return Error("The specified pages-at-a-time count is out of range: %#x\n", cPagesAtATime);
break;
case 'f':
pszPageFile = Val.psz;
break;
case 'o':
offPageFile = Val.u64;
break;
case 'O':
offPageFile = Val.u64 * PAGE_SIZE;
break;
case 'h':
RTPrintf("syntax: tstCompressionBenchmark [options]\n"
"\n"
"Options:\n"
" -h, --help\n"
" Show this help page\n"
" -i, --iterations <num>\n"
" The number of iterations.\n"
" -n, --num-pages <pages>\n"
" The number of pages.\n"
" -c, --pages-at-a-time <pages>\n"
" Number of pages at a time.\n"
" -f, --page-file <filename>\n"
" File or device to read the page from. The default\n"
" is to generate some garbage.\n"
" -o, --offset <file-offset>\n"
" Offset into the page file to start reading at.\n");
return 0;
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return 0;
default:
return RTGetOptPrintError(rc, &Val);
}
}
g_cbPages = g_cPages * PAGE_SIZE;
uint64_t cbTotal = (uint64_t)g_cPages * PAGE_SIZE * cIterations;
uint64_t cbTotalKB = cbTotal / _1K;
if (cbTotal / cIterations != g_cbPages)
return Error("cPages * cIterations -> overflow\n");
/*
* Gather the test memory.
*/
if (pszPageFile)
{
size_t cbFile;
rc = RTFileReadAllEx(pszPageFile, offPageFile, g_cbPages, RTFILE_RDALL_O_DENY_NONE, (void **)&g_pabSrc, &cbFile);
if (RT_FAILURE(rc))
return Error("Error reading %zu bytes from %s at %llu: %Rrc\n", g_cbPages, pszPageFile, offPageFile, rc);
if (cbFile != g_cbPages)
return Error("Error reading %zu bytes from %s at %llu: got %zu bytes\n", g_cbPages, pszPageFile, offPageFile, cbFile);
}
else
{
g_pabSrc = (uint8_t *)RTMemAlloc(g_cbPages);
if (g_pabSrc)
{
/* Just fill it with something - warn about the low quality of the something. */
RTPrintf("tstCompressionBenchmark: WARNING! No input file was specified so the source\n"
"buffer will be filled with generated data of questionable quality.\n");
#ifdef RT_OS_LINUX
RTPrintf("To get real RAM on linux: sudo dd if=/dev/mem ... \n");
#endif
uint8_t *pb = g_pabSrc;
uint8_t *pbEnd = &g_pabSrc[g_cbPages];
for (; pb != pbEnd; pb += 16)
{
char szTmp[17];
RTStrPrintf(szTmp, sizeof(szTmp), "aaaa%08Xzzzz", (uint32_t)(uintptr_t)pb);
memcpy(pb, szTmp, 16);
}
}
}
g_pabDecompr = (uint8_t *)RTMemAlloc(g_cbPages);
g_cbComprAlloc = RT_MAX(g_cbPages * 2, 256 * PAGE_SIZE);
g_pabCompr = (uint8_t *)RTMemAlloc(g_cbComprAlloc);
if (!g_pabSrc || !g_pabDecompr || !g_pabCompr)
return Error("failed to allocate memory buffers (g_cPages=%#x)\n", g_cPages);
/*
* Double loop compressing and uncompressing the data, where the outer does
* the specified number of iterations while the inner applies the different
* compression algorithms.
*/
struct
{
/** The time spent decompressing. */
uint64_t cNanoDecompr;
/** The time spent compressing. */
uint64_t cNanoCompr;
/** The size of the compressed data. */
uint64_t cbCompr;
/** First error. */
int rc;
/** The compression style: block or stream. */
bool fBlock;
/** Compression type. */
RTZIPTYPE enmType;
/** Compression level. */
RTZIPLEVEL enmLevel;
/** Method name. */
const char *pszName;
} aTests[] =
{
{ 0, 0, 0, VINF_SUCCESS, false, RTZIPTYPE_STORE, RTZIPLEVEL_DEFAULT, "RTZip/Store" },
{ 0, 0, 0, VINF_SUCCESS, false, RTZIPTYPE_LZF, RTZIPLEVEL_DEFAULT, "RTZip/LZF" },
/* { 0, 0, 0, VINF_SUCCESS, false, RTZIPTYPE_ZLIB, RTZIPLEVEL_DEFAULT, "RTZip/zlib" }, - slow plus it randomly hits VERR_GENERAL_FAILURE atm. */
{ 0, 0, 0, VINF_SUCCESS, true, RTZIPTYPE_STORE, RTZIPLEVEL_DEFAULT, "RTZipBlock/Store" },
{ 0, 0, 0, VINF_SUCCESS, true, RTZIPTYPE_LZF, RTZIPLEVEL_DEFAULT, "RTZipBlock/LZF" },
{ 0, 0, 0, VINF_SUCCESS, true, RTZIPTYPE_LZJB, RTZIPLEVEL_DEFAULT, "RTZipBlock/LZJB" },
{ 0, 0, 0, VINF_SUCCESS, true, RTZIPTYPE_LZO, RTZIPLEVEL_DEFAULT, "RTZipBlock/LZO" },
};
RTPrintf("tstCompressionBenchmark: TESTING..");
for (uint32_t i = 0; i < cIterations; i++)
{
for (uint32_t j = 0; j < RT_ELEMENTS(aTests); j++)
{
if (RT_FAILURE(aTests[j].rc))
continue;
memset(g_pabCompr, 0xaa, g_cbComprAlloc);
memset(g_pabDecompr, 0xcc, g_cbPages);
g_cbCompr = 0;
g_offComprIn = 0;
RTPrintf("."); RTStrmFlush(g_pStdOut);
/*
* Compress it.
*/
uint64_t NanoTS = RTTimeNanoTS();
if (aTests[j].fBlock)
{
size_t cbLeft = g_cbComprAlloc;
uint8_t const *pbSrcPage = g_pabSrc;
uint8_t *pbDstPage = g_pabCompr;
for (size_t iPage = 0; iPage < g_cPages; iPage += cPagesAtATime)
{
AssertBreakStmt(cbLeft > PAGE_SIZE * 4, aTests[j].rc = rc = VERR_BUFFER_OVERFLOW);
uint32_t *pcb = (uint32_t *)pbDstPage;
pbDstPage += sizeof(uint32_t);
cbLeft -= sizeof(uint32_t);
size_t cbSrc = RT_MIN(g_cPages - iPage, cPagesAtATime) * PAGE_SIZE;
size_t cbDst;
rc = RTZipBlockCompress(aTests[j].enmType, aTests[j].enmLevel, 0 /*fFlags*/,
pbSrcPage, cbSrc,
pbDstPage, cbLeft, &cbDst);
if (RT_FAILURE(rc))
{
Error("RTZipBlockCompress failed for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
break;
}
*pcb = (uint32_t)cbDst;
cbLeft -= cbDst;
pbDstPage += cbDst;
pbSrcPage += cbSrc;
}
if (RT_FAILURE(rc))
continue;
g_cbCompr = pbDstPage - g_pabCompr;
}
else
{
PRTZIPCOMP pZipComp;
rc = RTZipCompCreate(&pZipComp, NULL, ComprOutCallback, aTests[j].enmType, aTests[j].enmLevel);
if (RT_FAILURE(rc))
{
Error("Failed to create the compressor for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
continue;
}
uint8_t const *pbSrcPage = g_pabSrc;
for (size_t iPage = 0; iPage < g_cPages; iPage += cPagesAtATime)
{
size_t cb = RT_MIN(g_cPages - iPage, cPagesAtATime) * PAGE_SIZE;
rc = RTZipCompress(pZipComp, pbSrcPage, cb);
if (RT_FAILURE(rc))
{
Error("RTZipCompress failed for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
break;
}
pbSrcPage += cb;
}
if (RT_FAILURE(rc))
continue;
rc = RTZipCompFinish(pZipComp);
if (RT_FAILURE(rc))
{
Error("RTZipCompFinish failed for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
break;
}
RTZipCompDestroy(pZipComp);
}
NanoTS = RTTimeNanoTS() - NanoTS;
aTests[j].cbCompr += g_cbCompr;
aTests[j].cNanoCompr += NanoTS;
/*
* Decompress it.
*/
NanoTS = RTTimeNanoTS();
if (aTests[j].fBlock)
{
uint8_t const *pbSrcPage = g_pabCompr;
size_t cbLeft = g_cbCompr;
uint8_t *pbDstPage = g_pabDecompr;
for (size_t iPage = 0; iPage < g_cPages; iPage += cPagesAtATime)
{
size_t cbDst = RT_MIN(g_cPages - iPage, cPagesAtATime) * PAGE_SIZE;
size_t cbSrc = *(uint32_t *)pbSrcPage;
pbSrcPage += sizeof(uint32_t);
cbLeft -= sizeof(uint32_t);
rc = RTZipBlockDecompress(aTests[j].enmType, 0 /*fFlags*/,
pbSrcPage, cbSrc, &cbSrc,
pbDstPage, cbDst, &cbDst);
if (RT_FAILURE(rc))
{
Error("RTZipBlockDecompress failed for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
break;
}
pbDstPage += cbDst;
cbLeft -= cbSrc;
pbSrcPage += cbSrc;
}
if (RT_FAILURE(rc))
continue;
}
else
{
PRTZIPDECOMP pZipDecomp;
rc = RTZipDecompCreate(&pZipDecomp, NULL, DecomprInCallback);
if (RT_FAILURE(rc))
{
Error("Failed to create the decompressor for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
continue;
}
uint8_t *pbDstPage = g_pabDecompr;
for (size_t iPage = 0; iPage < g_cPages; iPage += cPagesAtATime)
{
size_t cb = RT_MIN(g_cPages - iPage, cPagesAtATime) * PAGE_SIZE;
rc = RTZipDecompress(pZipDecomp, pbDstPage, cb, NULL);
if (RT_FAILURE(rc))
{
Error("RTZipDecompress failed for '%s' (#%u): %Rrc\n", aTests[j].pszName, j, rc);
aTests[j].rc = rc;
break;
}
pbDstPage += cb;
}
RTZipDecompDestroy(pZipDecomp);
if (RT_FAILURE(rc))
continue;
}
NanoTS = RTTimeNanoTS() - NanoTS;
aTests[j].cNanoDecompr += NanoTS;
if (memcmp(g_pabDecompr, g_pabSrc, g_cbPages))
{
Error("The compressed data doesn't match the source for '%s' (%#u)\n", aTests[j].pszName, j);
aTests[j].rc = VERR_BAD_EXE_FORMAT;
continue;
}
}
}
if (RT_SUCCESS(rc))
RTPrintf("\n");
/*
* Report the results.
*/
rc = 0;
RTPrintf("tstCompressionBenchmark: BEGIN RESULTS\n");
RTPrintf("%-20s Compression Decompression\n", "");
RTPrintf("%-20s In Out Ratio Size In Out\n", "Method");
RTPrintf("%.20s-----------------------------------------------------------------------------------------\n", "---------------------------------------------");
for (uint32_t j = 0; j < RT_ELEMENTS(aTests); j++)
{
if (RT_SUCCESS(aTests[j].rc))
{
unsigned uComprSpeedIn = (unsigned)(cbTotalKB / (long double)aTests[j].cNanoCompr * 1000000000.0);
unsigned uComprSpeedOut = (unsigned)(aTests[j].cbCompr / (long double)aTests[j].cNanoCompr * 1000000000.0 / 1024);
unsigned uRatio = (unsigned)(aTests[j].cbCompr / cIterations * 100 / g_cbPages);
unsigned uDecomprSpeedIn = (unsigned)(aTests[j].cbCompr / (long double)aTests[j].cNanoDecompr * 1000000000.0 / 1024);
unsigned uDecomprSpeedOut = (unsigned)(cbTotalKB / (long double)aTests[j].cNanoDecompr * 1000000000.0);
RTPrintf("%-20s %'9u KB/s %'9u KB/s %3u%% %'11llu bytes %'9u KB/s %'9u KB/s",
aTests[j].pszName,
uComprSpeedIn, uComprSpeedOut, uRatio, aTests[j].cbCompr / cIterations,
uDecomprSpeedIn, uDecomprSpeedOut);
#if 0
RTPrintf(" [%'14llu / %'14llu ns]\n",
aTests[j].cNanoCompr / cIterations,
aTests[j].cNanoDecompr / cIterations);
#else
RTPrintf("\n");
#endif
}
else
{
RTPrintf("%-20s: %Rrc\n", aTests[j].pszName, aTests[j].rc);
rc = 1;
}
}
if (pszPageFile)
RTPrintf("Input: %'10zu pages from '%s' starting at offset %'lld (%#llx)\n"
" %'11zu bytes\n",
g_cPages, pszPageFile, offPageFile, offPageFile, g_cbPages);
else
RTPrintf("Input: %'10zu pages of generated rubbish %'11zu bytes\n",
g_cPages, g_cbPages);
/*
* Count zero pages in the data set.
*/
size_t cZeroPages = 0;
for (size_t iPage = 0; iPage < g_cPages; iPage++)
{
if (!ASMMemIsAllU32(&g_pabSrc[iPage * PAGE_SIZE], PAGE_SIZE, 0))
cZeroPages++;
}
RTPrintf(" %'10zu zero pages (%u %%)\n", cZeroPages, cZeroPages * 100 / g_cPages);
/*
* A little extension to the test, benchmark relevant CRCs.
*/
RTPrintf("\n"
"tstCompressionBenchmark: Hash/CRC - All In One\n");
tstBenchmarkCRCsAllInOne(g_pabSrc, g_cbPages);
RTPrintf("\n"
"tstCompressionBenchmark: Hash/CRC - Page by Page\n");
tstBenchmarkCRCsPageByPage(g_pabSrc, g_cbPages);
RTPrintf("\n"
"tstCompressionBenchmark: Hash/CRC - Zero Page Digest\n");
static uint8_t s_abZeroPg[PAGE_SIZE];
RT_ZERO(s_abZeroPg);
tstBenchmarkCRCsAllInOne(s_abZeroPg, PAGE_SIZE);
RTPrintf("\n"
"tstCompressionBenchmark: Hash/CRC - Zero Half Page Digest\n");
tstBenchmarkCRCsAllInOne(s_abZeroPg, PAGE_SIZE / 2);
RTPrintf("tstCompressionBenchmark: END RESULTS\n");
return rc;
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--halt", 'H', RTGETOPT_REQ_NOTHING },
{ "--poweroff", 'p', RTGETOPT_REQ_NOTHING },
{ "--reboot", 'r', RTGETOPT_REQ_NOTHING },
{ "--force", 'f', RTGETOPT_REQ_NOTHING },
{ "--delay", 'd', RTGETOPT_REQ_UINT32 },
{ "--message", 'm', RTGETOPT_REQ_STRING }
};
const char *pszMsg = "RTShutdown";
RTMSINTERVAL cMsDelay = 0;
uint32_t fFlags = RTSYSTEM_SHUTDOWN_POWER_OFF | RTSYSTEM_SHUTDOWN_PLANNED;
RTGETOPTSTATE GetState;
rc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
for (;;)
{
RTGETOPTUNION ValueUnion;
rc = RTGetOpt(&GetState, &ValueUnion);
if (rc == 0)
break;
switch (rc)
{
case 'H': fFlags = (fFlags & ~RTSYSTEM_SHUTDOWN_ACTION_MASK) | RTSYSTEM_SHUTDOWN_HALT; break;
case 'p': fFlags = (fFlags & ~RTSYSTEM_SHUTDOWN_ACTION_MASK) | RTSYSTEM_SHUTDOWN_POWER_OFF_HALT; break;
case 'r': fFlags = (fFlags & ~RTSYSTEM_SHUTDOWN_ACTION_MASK) | RTSYSTEM_SHUTDOWN_REBOOT; break;
case 'f': fFlags |= RTSYSTEM_SHUTDOWN_FORCE; break;
case 'd': cMsDelay = ValueUnion.u32; break;
case 'm': pszMsg = ValueUnion.psz; break;
case 'h':
RTPrintf("Usage: RTShutdown [-H|-p|-r] [-f] [-d <milliseconds>] [-m <msg>]\n");
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* Do the deed.
*/
rc = RTSystemShutdown(cMsDelay, fFlags, pszMsg);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTSystemShutdown(%u, %#x, \"%s\") returned %Rrc\n", cMsDelay, fFlags, pszMsg, rc);
return RTEXITCODE_SUCCESS;
}
int main(int argc, char **argv)
{
/*
* Init.
*/
int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Process arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--keep", 'k', RTGETOPT_REQ_NOTHING },
{ "--no-keep", 'n', RTGETOPT_REQ_NOTHING },
};
bool fKeepLoaded = false;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case VINF_GETOPT_NOT_OPTION:
{
void *pvImageBase;
RTERRINFOSTATIC ErrInfo;
RTErrInfoInitStatic(&ErrInfo);
rc = SUPR3LoadModule(ValueUnion.psz, RTPathFilename(ValueUnion.psz), &pvImageBase, &ErrInfo.Core);
if (RT_FAILURE(rc))
{
RTMsgError("%Rrc when attempting to load '%s': %s\n", rc, ValueUnion.psz, ErrInfo.Core.pszMsg);
return 1;
}
RTPrintf("Loaded '%s' at %p\n", ValueUnion.psz, pvImageBase);
if (!fKeepLoaded)
{
rc = SUPR3FreeModule(pvImageBase);
if (RT_FAILURE(rc))
{
RTMsgError("%Rrc when attempting to load '%s'\n", rc, ValueUnion.psz);
return 1;
}
}
break;
}
case 'k':
fKeepLoaded = true;
break;
case 'n':
fKeepLoaded = false;
break;
case 'h':
RTPrintf("%s [mod1 [mod2...]]\n", argv[0]);
return 1;
case 'V':
RTPrintf("$Revision: 102121 $\n");
return 0;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
return 0;
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
/*
* Parse args
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_INT32 },
{ "--hex", 'h', RTGETOPT_REQ_NOTHING },
{ "--decimal", 'd', RTGETOPT_REQ_NOTHING },
{ "--spin", 's', RTGETOPT_REQ_NOTHING }
};
uint32_t cIterations = 40;
bool fHex = true;
bool fSpin = false;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'i':
cIterations = ValueUnion.u32;
break;
case 'd':
fHex = false;
break;
case 'h':
fHex = true;
break;
case 's':
fSpin = true;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
/*
* Init
*/
PSUPDRVSESSION pSession = NIL_RTR0PTR;
int rc = SUPR3Init(&pSession);
if (RT_SUCCESS(rc))
{
if (g_pSUPGlobalInfoPage)
{
RTPrintf("tstGIP-2: cCpus=%d u32UpdateHz=%RU32 u32UpdateIntervalNS=%RU32 u64NanoTSLastUpdateHz=%RX64 u32Mode=%d (%s) u32Version=%#x\n",
g_pSUPGlobalInfoPage->cCpus,
g_pSUPGlobalInfoPage->u32UpdateHz,
g_pSUPGlobalInfoPage->u32UpdateIntervalNS,
g_pSUPGlobalInfoPage->u64NanoTSLastUpdateHz,
g_pSUPGlobalInfoPage->u32Mode,
g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC ? "sync"
: g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_ASYNC_TSC ? "async"
: "???",
g_pSUPGlobalInfoPage->u32Version);
RTPrintf(fHex
? "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz TSC Interval History...\n"
: "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz TSC Interval History...\n");
static SUPGIPCPU s_aaCPUs[2][256];
for (uint32_t i = 0; i < cIterations; i++)
{
/* copy the data */
memcpy(&s_aaCPUs[i & 1][0], &g_pSUPGlobalInfoPage->aCPUs[0], g_pSUPGlobalInfoPage->cCpus * sizeof(g_pSUPGlobalInfoPage->aCPUs[0]));
/* display it & find something to spin on. */
uint32_t u32TransactionId = 0;
uint32_t volatile *pu32TransactionId = NULL;
for (unsigned iCpu = 0; iCpu < g_pSUPGlobalInfoPage->cCpus; iCpu++)
if ( g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz > 0
&& g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz != _4G + 1)
{
PSUPGIPCPU pPrevCpu = &s_aaCPUs[!(i & 1)][iCpu];
PSUPGIPCPU pCpu = &s_aaCPUs[i & 1][iCpu];
RTPrintf(fHex
? "tstGIP-2: %4d/%d: %016llx %09llx %016llx %08x %d %08x %15llu %08x %08x %08x %08x %08x %08x %08x %08x (%d)\n"
: "tstGIP-2: %4d/%d: %016llu %09llu %016llu %010u %d %010u %15llu %08x %08x %08x %08x %08x %08x %08x %08x (%d)\n",
i, iCpu,
pCpu->u64NanoTS,
i ? pCpu->u64NanoTS - pPrevCpu->u64NanoTS : 0,
pCpu->u64TSC,
pCpu->u32UpdateIntervalTSC,
pCpu->iTSCHistoryHead,
pCpu->u32TransactionId,
pCpu->u64CpuHz,
pCpu->au32TSCHistory[0],
pCpu->au32TSCHistory[1],
pCpu->au32TSCHistory[2],
pCpu->au32TSCHistory[3],
pCpu->au32TSCHistory[4],
pCpu->au32TSCHistory[5],
pCpu->au32TSCHistory[6],
pCpu->au32TSCHistory[7],
pCpu->cErrors);
if (!pu32TransactionId)
{
pu32TransactionId = &g_pSUPGlobalInfoPage->aCPUs[iCpu].u32TransactionId;
u32TransactionId = pCpu->u32TransactionId;
}
}
/* wait a bit / spin */
if (!fSpin)
RTThreadSleep(9);
else
while (u32TransactionId == *pu32TransactionId)
/* nop */;
}
}
else
{
RTPrintf("tstGIP-2: g_pSUPGlobalInfoPage is NULL\n");
rc = -1;
}
SUPR3Term(false /*fForced*/);
}
else
RTPrintf("tstGIP-2: SUPR3Init failed: %Rrc\n", rc);
return !!rc;
}
/**
* Wipes free space on one or more volumes by creating large files.
*/
static RTEXITCODE handlerWipeFreeSpace(int argc, char **argv)
{
/*
* Parse arguments.
*/
const char *apszDefFiles[2] = { "./wipefree.spc", NULL };
bool fAll = false;
uint32_t u32Filler = UINT32_C(0xf6f6f6f6);
uint64_t cbMinLeftOpt = _32M;
static RTGETOPTDEF const s_aOptions[] =
{
{ "--all", 'a', RTGETOPT_REQ_NOTHING },
{ "--filler", 'f', RTGETOPT_REQ_UINT32 },
{ "--min-free", 'm', RTGETOPT_REQ_UINT64 },
};
RTGETOPTSTATE State;
RTGetOptInit(&State, argc, argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
RTGETOPTUNION ValueUnion;
int chOpt;
while ( (chOpt = RTGetOpt(&State, &ValueUnion)) != 0
&& chOpt != VINF_GETOPT_NOT_OPTION)
{
switch (chOpt)
{
case 'a':
fAll = true;
break;
case 'f':
u32Filler = ValueUnion.u32;
break;
case 'm':
cbMinLeftOpt = ValueUnion.u64;
break;
case 'h':
RTPrintf("usage: wipefrespace [options] [filename1 [..]]\n"
"\n"
"Options:\n"
" -a, --all\n"
" Try do the free space wiping on all seemingly relevant file systems.\n"
" Changes the meaning of the filenames "
" This is not yet implemented\n"
" -p, --filler <32-bit value>\n"
" What to fill the blocks we write with.\n"
" Default: 0xf6f6f6f6\n"
" -m, --min-free <64-bit byte count>\n"
" Specifies when to stop in terms of free disk space (in bytes).\n"
" Default: 32MB\n"
"\n"
"Zero or more names of files to do the free space wiping thru can be given.\n"
"When --all is NOT used, each of the files are used to do free space wiping on\n"
"the volume they will live on. However, when --all is in effect the files are\n"
"appended to the volume mountpoints and only the first that can be created will\n"
"be used. Files (used ones) will be removed when done.\n"
"\n"
"If no filename is given, the default is: %s\n"
, apszDefFiles[0]);
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(chOpt, &ValueUnion);
}
}
char **papszFiles;
if (chOpt == 0)
papszFiles = (char **)apszDefFiles;
else
papszFiles = RTGetOptNonOptionArrayPtr(&State);
/*
* Allocate and prep a memory which we'll write over and over again.
*/
uint32_t cbFiller = _2M;
uint32_t *pu32Filler = (uint32_t *)RTMemPageAlloc(cbFiller);
while (!pu32Filler)
{
cbFiller <<= 1;
if (cbFiller >= _4K)
pu32Filler = (uint32_t *)RTMemPageAlloc(cbFiller);
else
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTMemPageAlloc failed for sizes between 4KB and 2MB!\n");
}
for (uint32_t i = 0; i < cbFiller / sizeof(pu32Filler[0]); i++)
pu32Filler[i] = u32Filler;
/*
* Do the requested work.
*/
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
if (!fAll)
{
for (uint32_t iFile = 0; papszFiles[iFile] != NULL; iFile++)
{
RTEXITCODE rcExit2 = doOneFreeSpaceWipe(papszFiles[iFile], pu32Filler, cbFiller, cbMinLeftOpt);
if (rcExit2 != RTEXITCODE_SUCCESS && rcExit == RTEXITCODE_SUCCESS)
rcExit = rcExit2;
}
}
else
{
/*
* Reject --all for now.
*/
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "The --all option is not yet implemented!\n");
}
RTMemPageFree(pu32Filler, cbFiller);
return rcExit;
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
const char * const argv0 = RTPathFilename(argv[0]);
/* options */
uint64_t uAddress = 0;
uint64_t uHighlightAddr = UINT64_MAX;
ASMSTYLE enmStyle = kAsmStyle_Default;
UNDEFOPHANDLING enmUndefOp = kUndefOp_Fail;
bool fListing = true;
DISCPUMODE enmCpuMode = CPUMODE_32BIT;
RTFOFF off = 0;
RTFOFF cbMax = _1G;
bool fHexBytes = false;
/*
* Parse arguments.
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--address", 'a', RTGETOPT_REQ_UINT64 },
{ "--cpumode", 'c', RTGETOPT_REQ_UINT32 },
{ "--bytes", 'b', RTGETOPT_REQ_INT64 },
{ "--listing", 'l', RTGETOPT_REQ_NOTHING },
{ "--no-listing", 'L', RTGETOPT_REQ_NOTHING },
{ "--offset", 'o', RTGETOPT_REQ_INT64 },
{ "--style", 's', RTGETOPT_REQ_STRING },
{ "--undef-op", 'u', RTGETOPT_REQ_STRING },
{ "--hex-bytes", 'x', RTGETOPT_REQ_NOTHING },
};
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
while ( (ch = RTGetOpt(&GetState, &ValueUnion))
&& ch != VINF_GETOPT_NOT_OPTION)
{
switch (ch)
{
case 'a':
uAddress = ValueUnion.u64;
break;
case 'b':
cbMax = ValueUnion.i64;
break;
case 'c':
if (ValueUnion.u32 == 16)
enmCpuMode = CPUMODE_16BIT;
else if (ValueUnion.u32 == 32)
enmCpuMode = CPUMODE_32BIT;
else if (ValueUnion.u32 == 64)
enmCpuMode = CPUMODE_64BIT;
else
{
RTStrmPrintf(g_pStdErr, "%s: Invalid CPU mode value %RU32\n", argv0, ValueUnion.u32);
return 1;
}
break;
case 'h':
return Usage(argv0);
case 'l':
fListing = true;
break;
case 'L':
fListing = false;
break;
case 'o':
off = ValueUnion.i64;
break;
case 's':
if (!strcmp(ValueUnion.psz, "default"))
enmStyle = kAsmStyle_Default;
else if (!strcmp(ValueUnion.psz, "yasm"))
enmStyle = kAsmStyle_yasm;
else if (!strcmp(ValueUnion.psz, "masm"))
{
enmStyle = kAsmStyle_masm;
RTStrmPrintf(g_pStdErr, "%s: masm style isn't implemented yet\n", argv0);
return 1;
}
else
{
RTStrmPrintf(g_pStdErr, "%s: unknown assembly style: %s\n", argv0, ValueUnion.psz);
return 1;
}
break;
case 'u':
if (!strcmp(ValueUnion.psz, "fail"))
enmUndefOp = kUndefOp_Fail;
else if (!strcmp(ValueUnion.psz, "all"))
enmUndefOp = kUndefOp_All;
else if (!strcmp(ValueUnion.psz, "db"))
enmUndefOp = kUndefOp_DefineByte;
else
{
RTStrmPrintf(g_pStdErr, "%s: unknown undefined opcode handling method: %s\n", argv0, ValueUnion.psz);
return 1;
}
break;
case 'x':
fHexBytes = true;
break;
case 'V':
RTPrintf("$Revision: $\n");
return 0;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
int iArg = GetState.iNext - 1; /** @todo Not pretty, add RTGetOptInit flag for this. */
if (iArg >= argc)
return Usage(argv0);
int rc = VINF_SUCCESS;
if (fHexBytes)
{
/*
* Convert the remaining arguments from a hex byte string into
* a buffer that we disassemble.
*/
size_t cb = 0;
uint8_t *pb = NULL;
for ( ; iArg < argc; iArg++)
{
char ch2;
const char *psz = argv[iArg];
while (*psz)
{
/** @todo this stuff belongs in IPRT, same stuff as mac address reading. Could be reused for IPv6 with a different item size.*/
/* skip white space, and for the benefit of linux panics '<' and '>'. */
while (RT_C_IS_SPACE(ch2 = *psz) || ch2 == '<' || ch2 == '>')
{
if (ch2 == '<')
uHighlightAddr = uAddress + cb;
psz++;
}
if (!ch2)
break;
/* one digit followed by a space or EOS, or two digits. */
int iNum = HexDigitToNum(*psz++);
if (iNum == -1)
return 1;
if (!RT_C_IS_SPACE(ch2 = *psz) && ch2 != '\0' && ch2 != '>')
{
int iDigit = HexDigitToNum(*psz++);
if (iDigit == -1)
return 1;
iNum = iNum * 16 + iDigit;
}
/* add the byte */
if (!(cb % 4 /*64*/))
{
pb = (uint8_t *)RTMemRealloc(pb, cb + 64);
if (!pb)
{
RTPrintf("%s: error: RTMemRealloc failed\n", argv[0]);
return 1;
}
}
pb[cb++] = (uint8_t)iNum;
}
}
/*
* Disassemble it.
*/
rc = MyDisasmBlock(argv0, enmCpuMode, uAddress, uHighlightAddr, pb, cb, enmStyle, fListing, enmUndefOp);
}
else
{
/*
* Process the files.
*/
for ( ; iArg < argc; iArg++)
{
/*
* Read the file into memory.
*/
void *pvFile;
size_t cbFile;
rc = RTFileReadAllEx(argv[iArg], off, cbMax, RTFILE_RDALL_O_DENY_NONE, &pvFile, &cbFile);
if (RT_FAILURE(rc))
{
RTStrmPrintf(g_pStdErr, "%s: %s: %Rrc\n", argv0, argv[iArg], rc);
break;
}
/*
* Disassemble it.
*/
rc = MyDisasmBlock(argv0, enmCpuMode, uAddress, uHighlightAddr, (uint8_t *)pvFile, cbFile, enmStyle, fListing, enmUndefOp);
if (RT_FAILURE(rc))
break;
}
}
return RT_SUCCESS(rc) ? 0 : 1;
}
/**
* Handler for the 'add-trusted-publisher' command.
*/
static RTEXITCODE cmdAddTrustedPublisher(int argc, char **argv)
{
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--root", 'r', RTGETOPT_REQ_STRING },
};
const char *pszRootCert = NULL;
const char *pszTrustedCert = NULL;
int rc;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((rc = RTGetOpt(&GetState, &ValueUnion)))
{
switch (rc)
{
case 'h':
RTPrintf("Usage: VBoxCertUtil add-trusted-publisher [--root <root-cert>] <trusted-cert>\n");
break;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
case 'r':
if (pszRootCert)
return RTMsgErrorExit(RTEXITCODE_SUCCESS,
"You've already specified '%s' as root certificate.",
pszRootCert);
pszRootCert = ValueUnion.psz;
break;
case VINF_GETOPT_NOT_OPTION:
if (pszTrustedCert)
return RTMsgErrorExit(RTEXITCODE_SUCCESS,
"You've already specified '%s' as trusted certificate.",
pszTrustedCert);
pszTrustedCert = ValueUnion.psz;
break;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
if (!pszTrustedCert)
return RTMsgErrorExit(RTEXITCODE_SUCCESS, "No trusted certificate specified.");
/*
* Do the job.
*/
/** @todo The root-cert part needs to be made more flexible. */
if ( pszRootCert
&& !addCertToStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, "Root", pszRootCert, CERT_STORE_ADD_NEW))
return RTEXITCODE_FAILURE;
if (!addCertToStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, "TrustedPublisher", pszTrustedCert, CERT_STORE_ADD_NEW))
return RTEXITCODE_FAILURE;
if (g_cVerbosityLevel > 0)
{
if (pszRootCert)
RTMsgInfo("Successfully added '%s' as root and '%s' as trusted publisher", pszRootCert, pszTrustedCert);
else
RTMsgInfo("Successfully added '%s' as trusted publisher", pszTrustedCert);
}
return RTEXITCODE_SUCCESS;
}
RTDECL(RTEXITCODE) RTPathRmCmd(unsigned cArgs, char **papszArgs)
{
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
/* operations */
{ "--dirs-and-more", 'd', RTGETOPT_REQ_NOTHING },
{ "--force", 'f', RTGETOPT_REQ_NOTHING },
{ "--prompt", 'i', RTGETOPT_REQ_NOTHING },
{ "--prompt-once", 'I', RTGETOPT_REQ_NOTHING },
{ "--interactive", RTPATHRMCMD_OPT_INTERACTIVE, RTGETOPT_REQ_STRING },
{ "--one-file-system", RTPATHRMCMD_OPT_ONE_FILE_SYSTEM, RTGETOPT_REQ_NOTHING },
{ "--preserve-root", RTPATHRMCMD_OPT_PRESERVE_ROOT, RTGETOPT_REQ_NOTHING },
{ "--no-preserve-root", RTPATHRMCMD_OPT_NO_PRESERVE_ROOT, RTGETOPT_REQ_NOTHING },
{ "--recursive", 'R', RTGETOPT_REQ_NOTHING },
{ "--recursive", 'r', RTGETOPT_REQ_NOTHING },
{ "--safe-delete", 'P', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
/* IPRT extensions */
{ "--machine-readable", RTPATHRMCMD_OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING },
{ "--machinereadable", RTPATHRMCMD_OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING }, /* bad long option style */
};
RTGETOPTSTATE GetState;
int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOpt failed: %Rrc", rc);
RTPATHRMCMDOPTS Opts;
RT_ZERO(Opts);
Opts.fPreserveRoot = true;
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_NONE;
RTGETOPTUNION ValueUnion;
while ( (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
&& rc != VINF_GETOPT_NOT_OPTION)
{
switch (rc)
{
case 'd':
Opts.fDirsAndOther = true;
break;
case 'f':
Opts.fForce = true;
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_NONE;
break;
case 'i':
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_ALL;
break;
case 'I':
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_ONCE;
break;
case RTPATHRMCMD_OPT_INTERACTIVE:
if (!strcmp(ValueUnion.psz, "always"))
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_ALL;
else if (!strcmp(ValueUnion.psz, "once"))
Opts.enmInteractive = RTPATHRMCMDINTERACTIVE_ONCE;
else
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown --interactive option value: '%s'\n", ValueUnion.psz);
break;
case RTPATHRMCMD_OPT_ONE_FILE_SYSTEM:
Opts.fOneFileSystem = true;
break;
case RTPATHRMCMD_OPT_PRESERVE_ROOT:
Opts.fPreserveRoot = true;
break;
case RTPATHRMCMD_OPT_NO_PRESERVE_ROOT:
Opts.fPreserveRoot = false;
break;
case 'R':
case 'r':
Opts.fRecursive = true;
Opts.fDirsAndOther = true;
break;
case 'P':
Opts.fSafeDelete = true;
break;
case 'v':
Opts.fVerbose = true;
break;
case RTPATHRMCMD_OPT_MACHINE_READABLE:
Opts.fMachineReadable = true;
break;
case 'h':
RTPrintf("Usage: to be written\nOption dump:\n");
for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++)
if (RT_C_IS_PRINT(s_aOptions[i].iShort))
RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
else
RTPrintf(" %s\n", s_aOptions[i].pszLong);
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* Options we don't support.
*/
if (Opts.fOneFileSystem)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "The --one-file-system option is not yet implemented.\n");
if (Opts.enmInteractive != RTPATHRMCMDINTERACTIVE_NONE)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "The -i, -I and --interactive options are not implemented yet.\n");
/*
* No files means error.
*/
if (rc != VINF_GETOPT_NOT_OPTION && !Opts.fForce)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "No files or directories specified.\n");
/*
* Machine readable init + header.
*/
if (Opts.fMachineReadable)
{
rc = RTStrmSetMode(g_pStdOut, true /*fBinary*/, false /*fCurrentCodeSet*/);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrmSetMode failed: %Rrc.\n", rc);
static const char s_achHeader[] = "hdr_id=rm\0hdr_ver=1";
RTStrmWrite(g_pStdOut, s_achHeader, sizeof(s_achHeader));
}
/*
* Delete the specified files/dirs/whatever.
*/
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
while (rc == VINF_GETOPT_NOT_OPTION)
{
rc = rtPathRmOne(&Opts, ValueUnion.psz);
if (RT_FAILURE(rc))
rcExit = RTEXITCODE_FAILURE;
/* next */
rc = RTGetOpt(&GetState, &ValueUnion);
}
if (rc != 0)
rcExit = RTGetOptPrintError(rc, &ValueUnion);
/*
* Terminate the machine readable stuff.
*/
if (Opts.fMachineReadable)
{
RTStrmWrite(g_pStdOut, "\0\0\0", 4);
rc = RTStrmFlush(g_pStdOut);
if (RT_FAILURE(rc) && rcExit == RTEXITCODE_SUCCESS)
rcExit = RTEXITCODE_FAILURE;
}
return rcExit;
}
/**
* Parses the options.
*
* @returns RTEXITCODE_SUCCESS on success.
* @param argc Argument count .
* @param argv Argument vector.
* @param pfExit Set to @c true if we should exit.
*/
static RTEXITCODE ParseOptions(int argc, char **argv, bool *pfExit)
{
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--only", 'o', RTGETOPT_REQ_STRING },
{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
};
bool fAll = true;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0 /* fFlags */);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch(ch)
{
case 'o':
{
uint32_t i;
if (fAll)
{
fAll = false;
for (i = 0; i < RT_ELEMENTS(g_aModules); i++)
g_aModules[i].fPreload = false;
}
i = RT_ELEMENTS(g_aModules);
while (i-- > 0)
if (!strcmp(ValueUnion.psz, g_aModules[i].pszName))
{
g_aModules[i].fPreload = true;
break;
}
if (i > RT_ELEMENTS(g_aModules))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "No known module '%s'", ValueUnion.psz);
break;
}
case 'v':
g_cVerbose++;
break;
case 'q':
g_cVerbose = 0;
break;
case 'h':
RTPrintf(VBOX_PRODUCT " VMM ring-0 Module Preloader Version " VBOX_VERSION_STRING
"(C) 2005-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
"All rights reserved.\n"
"\n"
"Usage: VBoxVMMPreload [-hqvV] [-o|--only <mod>]\n"
"\n");
*pfExit = true;
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
*pfExit = true;
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
return RTEXITCODE_SUCCESS;
}
static RTEXITCODE HandleExtractExeSignerCert(int cArgs, char **papszArgs)
{
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--ber", 'b', RTGETOPT_REQ_NOTHING },
{ "--cer", 'c', RTGETOPT_REQ_NOTHING },
{ "--der", 'd', RTGETOPT_REQ_NOTHING },
{ "--exe", 'e', RTGETOPT_REQ_STRING },
{ "--output", 'o', RTGETOPT_REQ_STRING },
};
const char *pszExe = NULL;
const char *pszOut = NULL;
RTLDRARCH enmLdrArch = RTLDRARCH_WHATEVER;
uint32_t fCursorFlags = RTASN1CURSOR_FLAGS_DER;
RTGETOPTSTATE GetState;
int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
AssertRCReturn(rc, RTEXITCODE_FAILURE);
RTGETOPTUNION ValueUnion;
int ch;
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'e': pszExe = ValueUnion.psz; break;
case 'o': pszOut = ValueUnion.psz; break;
case 'b': fCursorFlags = 0; break;
case 'c': fCursorFlags = RTASN1CURSOR_FLAGS_CER; break;
case 'd': fCursorFlags = RTASN1CURSOR_FLAGS_DER; break;
case 'V': return HandleVersion(cArgs, papszArgs);
case 'h': return HelpExtractExeSignerCert(g_pStdOut, RTSIGNTOOLHELP_FULL);
case VINF_GETOPT_NOT_OPTION:
if (!pszExe)
pszExe = ValueUnion.psz;
else if (!pszOut)
pszOut = ValueUnion.psz;
else
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Too many file arguments: %s", ValueUnion.psz);
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
if (!pszExe)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "No executable given.");
if (!pszOut)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "No output file given.");
if (RTPathExists(pszOut))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "The output file '%s' exists.", pszOut);
/*
* Do it.
*/
/* Open the executable image and query the PKCS7 info. */
RTLDRMOD hLdrMod;
rc = RTLdrOpen(pszExe, RTLDR_O_FOR_VALIDATION, enmLdrArch, &hLdrMod);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Error opening executable image '%s': %Rrc", pszExe, rc);
RTEXITCODE rcExit = RTEXITCODE_FAILURE;
#ifdef DEBUG
size_t cbBuf = 64;
#else
size_t cbBuf = _512K;
#endif
void *pvBuf = RTMemAlloc(cbBuf);
size_t cbRet = 0;
rc = RTLdrQueryPropEx(hLdrMod, RTLDRPROP_PKCS7_SIGNED_DATA, NULL /*pvBits*/, pvBuf, cbBuf, &cbRet);
if (rc == VERR_BUFFER_OVERFLOW && cbRet < _4M && cbRet > 0)
{
RTMemFree(pvBuf);
cbBuf = cbRet;
pvBuf = RTMemAlloc(cbBuf);
rc = RTLdrQueryPropEx(hLdrMod, RTLDRPROP_PKCS7_SIGNED_DATA, NULL /*pvBits*/, pvBuf, cbBuf, &cbRet);
}
if (RT_SUCCESS(rc))
{
static RTERRINFOSTATIC s_StaticErrInfo;
RTErrInfoInitStatic(&s_StaticErrInfo);
/*
* Decode the output.
*/
RTASN1CURSORPRIMARY PrimaryCursor;
RTAsn1CursorInitPrimary(&PrimaryCursor, pvBuf, (uint32_t)cbRet, &s_StaticErrInfo.Core,
&g_RTAsn1DefaultAllocator, fCursorFlags, "exe");
RTCRPKCS7CONTENTINFO Pkcs7Ci;
rc = RTCrPkcs7ContentInfo_DecodeAsn1(&PrimaryCursor.Cursor, 0, &Pkcs7Ci, "pkcs7");
if (RT_SUCCESS(rc))
{
if (RTCrPkcs7ContentInfo_IsSignedData(&Pkcs7Ci))
{
PCRTCRPKCS7SIGNEDDATA pSd = Pkcs7Ci.u.pSignedData;
if (pSd->SignerInfos.cItems == 1)
{
PCRTCRPKCS7ISSUERANDSERIALNUMBER pISN = &pSd->SignerInfos.paItems[0].IssuerAndSerialNumber;
PCRTCRX509CERTIFICATE pCert;
pCert = RTCrPkcs7SetOfCerts_FindX509ByIssuerAndSerialNumber(&pSd->Certificates,
&pISN->Name, &pISN->SerialNumber);
if (pCert)
{
/*
* Write it out.
*/
RTFILE hFile;
rc = RTFileOpen(&hFile, pszOut, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE);
if (RT_SUCCESS(rc))
{
uint32_t cbCert = pCert->SeqCore.Asn1Core.cbHdr + pCert->SeqCore.Asn1Core.cb;
rc = RTFileWrite(hFile, pCert->SeqCore.Asn1Core.uData.pu8 - pCert->SeqCore.Asn1Core.cbHdr,
cbCert, NULL);
if (RT_SUCCESS(rc))
{
rc = RTFileClose(hFile);
if (RT_SUCCESS(rc))
{
hFile = NIL_RTFILE;
rcExit = RTEXITCODE_SUCCESS;
RTMsgInfo("Successfully wrote %u bytes to '%s'", cbCert, pszOut);
}
else
RTMsgError("RTFileClose failed: %Rrc", rc);
}
else
RTMsgError("RTFileWrite failed: %Rrc", rc);
RTFileClose(hFile);
}
else
RTMsgError("Error opening '%s': %Rrc", pszOut, rc);
}
else
RTMsgError("Certificate not found.");
}
else
RTMsgError("SignerInfo count: %u", pSd->SignerInfos.cItems);
}
else
RTMsgError("No PKCS7 content: ContentType=%s", Pkcs7Ci.ContentType.szObjId);
RTAsn1VtDelete(&Pkcs7Ci.SeqCore.Asn1Core);
}
else
RTMsgError("RTPkcs7ContentInfoDecodeAsn1 failed: %Rrc - %s", rc, s_StaticErrInfo.szMsg);
}
else
RTMsgError("RTLDRPROP_PKCS7_SIGNED_DATA failed on '%s': %Rrc", pszExe, rc);
RTMemFree(pvBuf);
rc = RTLdrClose(hLdrMod);
if (RT_FAILURE(rc))
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTLdrClose failed: %Rrc\n", rc);
return rcExit;
}
int main(int cArgs, char **apszArgs)
{
int rc = RTR3InitExe(cArgs, &apszArgs, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
enum
{
OPTION_FORMAT = 1,
OPTION_COMMAND,
OPTION_ARGUMENTS,
OPTION_DESCRIPTION,
OPTION_SERVICE_NAME,
OPTION_ONE_SHOT,
OPTION_STOP_COMMAND,
OPTION_STOP_ARGUMENTS,
OPTION_STATUS_COMMAND,
OPTION_STATUS_ARGUMENTS
};
static const RTGETOPTDEF s_aOptions[] =
{
{ "--format", OPTION_FORMAT,
RTGETOPT_REQ_STRING },
{ "--command", OPTION_COMMAND,
RTGETOPT_REQ_STRING },
{ "--arguments", OPTION_ARGUMENTS,
RTGETOPT_REQ_STRING },
{ "--description", OPTION_DESCRIPTION,
RTGETOPT_REQ_STRING },
{ "--service-name", OPTION_SERVICE_NAME,
RTGETOPT_REQ_STRING },
{ "--one-shot", OPTION_ONE_SHOT,
RTGETOPT_REQ_NOTHING },
{ "--stop-command", OPTION_STOP_COMMAND,
RTGETOPT_REQ_STRING },
{ "--stop-arguments", OPTION_STOP_ARGUMENTS,
RTGETOPT_REQ_STRING },
{ "--status-command", OPTION_STATUS_COMMAND,
RTGETOPT_REQ_STRING },
{ "--status-arguments", OPTION_STATUS_ARGUMENTS,
RTGETOPT_REQ_STRING }
};
int ch;
struct SERVICEPARAMETERS Parameters = { FORMAT_NONE };
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, cArgs, apszArgs, s_aOptions,
RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'h':
showUsage(apszArgs[0]);
return RTEXITCODE_SUCCESS;
break;
case 'V':
showLogo();
return RTEXITCODE_SUCCESS;
break;
case OPTION_FORMAT:
if (errorIfSet("--format",
Parameters.enmFormat != FORMAT_NONE))
return(RTEXITCODE_SYNTAX);
Parameters.enmFormat
= getFormat("--format", ValueUnion.psz);
if (Parameters.enmFormat == FORMAT_NONE)
return(RTEXITCODE_SYNTAX);
break;
case OPTION_COMMAND:
if (errorIfSet("--command", Parameters.pcszCommand))
return(RTEXITCODE_SYNTAX);
Parameters.pcszCommand = ValueUnion.psz;
if (!checkAbsoluteFilePath("--command",
Parameters.pcszCommand))
return(RTEXITCODE_SYNTAX);
break;
case OPTION_ARGUMENTS:
if (errorIfSet("--arguments",
Parameters.pcszArguments))
return(RTEXITCODE_SYNTAX);
/* Quoting will be checked while writing out the string. */
Parameters.pcszArguments = ValueUnion.psz;
break;
case OPTION_DESCRIPTION:
if (errorIfSet("--description",
Parameters.pcszDescription))
return(RTEXITCODE_SYNTAX);
Parameters.pcszDescription = ValueUnion.psz;
if (!checkPrintable("--description",
Parameters.pcszDescription))
return(RTEXITCODE_SYNTAX);
break;
case OPTION_SERVICE_NAME:
if (errorIfSet("--service-name",
Parameters.pcszServiceName))
return(RTEXITCODE_SYNTAX);
Parameters.pcszServiceName = ValueUnion.psz;
if (!checkGraphic("--service-name",
Parameters.pcszServiceName))
return(RTEXITCODE_SYNTAX);
break;
case OPTION_ONE_SHOT:
Parameters.fOneShot = true;
break;
case OPTION_STOP_COMMAND:
if (errorIfSet("--stop-command",
Parameters.pcszStopCommand))
return(RTEXITCODE_SYNTAX);
Parameters.pcszStopCommand = ValueUnion.psz;
if (!checkAbsoluteFilePath("--stop-command",
Parameters.pcszStopCommand))
return(RTEXITCODE_SYNTAX);
break;
case OPTION_STOP_ARGUMENTS:
if (errorIfSet("--stop-arguments",
Parameters.pcszStopArguments))
return(RTEXITCODE_SYNTAX);
/* Quoting will be checked while writing out the string. */
Parameters.pcszStopArguments = ValueUnion.psz;
break;
case OPTION_STATUS_COMMAND:
if (errorIfSet("--status-command",
Parameters.pcszStatusCommand))
return(RTEXITCODE_SYNTAX);
Parameters.pcszStatusCommand = ValueUnion.psz;
if (!checkAbsoluteFilePath("--status-command",
Parameters.pcszStatusCommand))
return(RTEXITCODE_SYNTAX);
break;
case OPTION_STATUS_ARGUMENTS:
if (errorIfSet("--status-arguments",
Parameters.pcszStatusArguments))
return(RTEXITCODE_SYNTAX);
/* Quoting will be checked while writing out the string. */
Parameters.pcszStatusArguments = ValueUnion.psz;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
if (Parameters.enmFormat == FORMAT_NONE)
{
RTStrmPrintf(g_pStdErr, "--format must be specified.\n");
return(RTEXITCODE_SYNTAX);
}
if (Parameters.pcszArguments && !Parameters.pcszCommand)
{
RTStrmPrintf(g_pStdErr, "--arguments requires --command to be specified.\n");
return(RTEXITCODE_SYNTAX);
}
if (Parameters.pcszStopArguments && !Parameters.pcszStopCommand)
{
RTStrmPrintf(g_pStdErr, "--stop-arguments requires --stop-command to be specified.\n");
return(RTEXITCODE_SYNTAX);
}
if (Parameters.pcszStatusArguments && !Parameters.pcszStatusCommand)
{
RTStrmPrintf(g_pStdErr, "--status-arguments requires --status-command to be specified.\n");
return(RTEXITCODE_SYNTAX);
}
return createServiceFile(&Parameters)
? RTEXITCODE_SUCCESS
: RTEXITCODE_FAILURE;
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Parse arguments.
*/
static RTGETOPTDEF const s_aOptions[] =
{
{ "--manifest", 'm', RTGETOPT_REQ_STRING },
{ "--java", 'j', RTGETOPT_REQ_NOTHING },
{ "--chdir", 'C', RTGETOPT_REQ_STRING },
{ "--attribute", 'a', RTGETOPT_REQ_STRING },
{ "--verify", 'v', RTGETOPT_REQ_NOTHING },
};
bool fVerify = false;
bool fStdFormat = true;
const char *pszManifest = NULL;
const char *pszChDir = NULL;
uint32_t fAttr = RTMANIFEST_ATTR_UNKNOWN;
RTGETOPTSTATE GetState;
rc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOptInit failed: %Rrc", rc);
RTGETOPTUNION ValueUnion;
while ( (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
&& rc != VINF_GETOPT_NOT_OPTION)
{
switch (rc)
{
case 'a':
{
static struct
{
const char *pszAttr;
uint32_t fAttr;
} s_aAttributes[] =
{
{ "size", RTMANIFEST_ATTR_SIZE },
{ "md5", RTMANIFEST_ATTR_MD5 },
{ "sha1", RTMANIFEST_ATTR_SHA1 },
{ "sha256", RTMANIFEST_ATTR_SHA256 },
{ "sha512", RTMANIFEST_ATTR_SHA512 }
};
uint32_t fThisAttr = RTMANIFEST_ATTR_UNKNOWN;
for (unsigned i = 0; i < RT_ELEMENTS(s_aAttributes); i++)
if (!RTStrICmp(s_aAttributes[i].pszAttr, ValueUnion.psz))
{
fThisAttr = s_aAttributes[i].fAttr;
break;
}
if (fThisAttr == RTMANIFEST_ATTR_UNKNOWN)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown attribute type '%s'", ValueUnion.psz);
if (fAttr == RTMANIFEST_ATTR_UNKNOWN)
fAttr = fThisAttr;
else
fAttr |= fThisAttr;
break;
}
case 'j':
fStdFormat = false;
break;
case 'm':
if (pszManifest)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Only one manifest can be specified");
pszManifest = ValueUnion.psz;
break;
case 'v':
fVerify = true;
break;
case 'C':
if (pszChDir)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Only one directory change can be specified");
pszChDir = ValueUnion.psz;
break;
case 'h':
RTPrintf("Usage: %s [--manifest <file>] [--chdir <dir>] [--attribute <attrib-name> [..]] <files>\n"
" or %s --verify [--manifest <file>] [--chdir <dir>]\n"
"\n"
"attrib-name: size, md5, sha1, sha256 or sha512\n"
, RTProcShortName(), RTProcShortName());
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* Take action.
*/
RTEXITCODE rcExit;
if (!fVerify)
{
if (rc != VINF_GETOPT_NOT_OPTION)
RTMsgWarning("No files specified, the manifest will be empty.");
if (fAttr == RTMANIFEST_ATTR_UNKNOWN)
fAttr = RTMANIFEST_ATTR_SIZE | RTMANIFEST_ATTR_MD5
| RTMANIFEST_ATTR_SHA1 | RTMANIFEST_ATTR_SHA256 | RTMANIFEST_ATTR_SHA512;
rcExit = rtManifestDoCreate(pszManifest, fStdFormat, pszChDir, fAttr, &GetState, &ValueUnion, rc);
}
else
{
if (rc == VINF_GETOPT_NOT_OPTION)
return RTMsgErrorExit(RTEXITCODE_SYNTAX,
"No files should be specified when verifying a manifest (--verfiy), "
"only a manifest via the --manifest option");
if (fAttr != RTMANIFEST_ATTR_UNKNOWN)
return RTMsgErrorExit(RTEXITCODE_SYNTAX,
"The --attribute (-a) option does not combine with --verify (-v)");
rcExit = rtManifestDoVerify(pszManifest, fStdFormat, pszChDir);
}
return rcExit;
}
/**
* Create a manifest from the specified input files.
*
* @returns Program exit code, failures with error message.
* @param pszManifest The name of the output manifest file. NULL if
* it should be written to standard output.
* @param fStdFormat Whether to expect standard format (true) or
* java format (false).
* @param pszChDir The directory to change into before processing
* the file arguments.
* @param fAttr The file attributes to put in the manifest.
* @param pGetState The RTGetOpt state.
* @param pUnion What the last RTGetOpt() call returned.
* @param chOpt What the last RTGetOpt() call returned.
*/
static RTEXITCODE rtManifestDoCreate(const char *pszManifest, bool fStdFormat, const char *pszChDir, uint32_t fAttr,
PRTGETOPTSTATE pGetState, PRTGETOPTUNION pUnion, int chOpt)
{
/*
* Open the manifest file.
*/
int rc;
RTVFSIOSTREAM hVfsIos;
if (!pszManifest)
{
rc = RTVfsIoStrmFromStdHandle(RTHANDLESTD_OUTPUT, RTFILE_O_WRITE, false /*fLeaveOpen*/, &hVfsIos);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to prepare standard output for writing: %Rrc", rc);
}
else
{
const char *pszError;
rc = RTVfsChainOpenIoStream(pszManifest, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE,
&hVfsIos, &pszError);
if (RT_FAILURE(rc))
{
if (pszError && *pszError)
return RTMsgErrorExit(RTEXITCODE_FAILURE,
"RTVfsChainOpenIoStream failed with rc=%Rrc:\n"
" '%s'\n",
" %*s^\n",
rc, pszManifest, pszError - pszManifest, "");
return RTMsgErrorExit(RTEXITCODE_FAILURE,
"Failed with %Rrc opening the manifest '%s'", rc, pszManifest);
}
}
/*
* Create the internal manifest.
*/
RTMANIFEST hManifest;
rc = RTManifestCreate(0 /*fFlags*/, &hManifest);
if (RT_SUCCESS(rc))
{
/*
* Change directory and start processing the specified files.
*/
if (pszChDir)
{
rc = RTPathSetCurrent(pszChDir);
if (RT_FAILURE(rc))
RTMsgError("Failed to change directory to '%s': %Rrc", pszChDir, rc);
}
if (RT_SUCCESS(rc))
{
while (chOpt == VINF_GETOPT_NOT_OPTION)
{
rc = rtManifestAddFileToManifest(hManifest, pUnion->psz, fAttr);
if (RT_FAILURE(rc))
break;
/* next */
chOpt = RTGetOpt(pGetState, pUnion);
}
if (RT_SUCCESS(rc) && chOpt != 0)
{
RTGetOptPrintError(chOpt, pUnion);
rc = chOpt < 0 ? chOpt : -chOpt;
}
}
/*
* Write the manifest.
*/
if (RT_SUCCESS(rc))
{
if (fStdFormat)
{
rc = RTManifestWriteStandard(hManifest, hVfsIos);
if (RT_FAILURE(rc))
RTMsgError("RTManifestWriteStandard failed: %Rrc", rc);
}
else
{
RTMsgError("Support for Java manifest files is not implemented yet");
rc = VERR_NOT_IMPLEMENTED;
}
}
RTManifestRelease(hManifest);
}
RTVfsIoStrmRelease(hVfsIos);
return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
}
RTDECL(RTEXITCODE) RTZipUnzipCmd(unsigned cArgs, char **papszArgs)
{
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
/* options */
{ NULL, 'c', RTGETOPT_REQ_NOTHING }, /* extract files to stdout/stderr */
{ NULL, 'd', RTGETOPT_REQ_STRING }, /* extract files to this directory */
{ NULL, 'l', RTGETOPT_REQ_NOTHING }, /* list archive files (short format) */
{ NULL, 'p', RTGETOPT_REQ_NOTHING }, /* extract files to stdout */
{ NULL, 't', RTGETOPT_REQ_NOTHING }, /* test archive files */
{ NULL, 'v', RTGETOPT_REQ_NOTHING }, /* verbose */
/* modifiers */
{ NULL, 'a', RTGETOPT_REQ_NOTHING }, /* convert text files */
{ NULL, 'b', RTGETOPT_REQ_NOTHING }, /* no conversion, treat as binary */
{ NULL, 'D', RTGETOPT_REQ_NOTHING }, /* don't restore timestamps for directories
(and files) */
};
RTGETOPTSTATE GetState;
int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOpt failed: %Rrc", rc);
RTZIPUNZIPCMDOPS Opts;
RT_ZERO(Opts);
RTGETOPTUNION ValueUnion;
while ( (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
&& rc != VINF_GETOPT_NOT_OPTION)
{
switch (rc)
{
case 'd':
if (Opts.pszDirectory)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "You may only specify -d once");
Opts.pszDirectory = ValueUnion.psz;
break;
case 'D':
if (!Opts.fNoModTimeDirectories)
Opts.fNoModTimeDirectories = true; /* -D */
else
Opts.fNoModTimeFiles = true; /* -DD */
break;
case 'l':
case 't': /* treat 'test' like 'list' */
if (Opts.iOperation)
return RTMsgErrorExit(RTEXITCODE_SYNTAX,
"Conflicting unzip operation (%s already set, now %s)",
Opts.pszOperation, ValueUnion.pDef->pszLong);
Opts.iOperation = rc;
Opts.pszOperation = ValueUnion.pDef->pszLong;
break;
case 'v':
Opts.fVerbose = true;
break;
default:
Opts.pszFile = ValueUnion.psz;
return RTGetOptPrintError(rc, &ValueUnion);
}
}
if (rc == VINF_GETOPT_NOT_OPTION)
{
Assert((unsigned)GetState.iNext - 1 <= cArgs);
Opts.pszFile = papszArgs[GetState.iNext - 1];
if ((unsigned)GetState.iNext <= cArgs)
{
Opts.papszFiles = (const char * const *)&papszArgs[GetState.iNext];
Opts.cFiles = cArgs - GetState.iNext;
}
}
RTFOFF cBytes = 0;
uint32_t cFiles = 0;
switch (Opts.iOperation)
{
case 'l':
{
RTPrintf(" Length Date Time Name\n"
"--------- ---------- ----- ----\n");
RTEXITCODE rcExit = rtZipUnzipDoWithMembers(&Opts, rtZipUnzipCmdListCallback, &cFiles, &cBytes);
RTPrintf("--------- -------\n"
"%9RU64 %u file%s\n",
cBytes, cFiles, cFiles != 1 ? "s" : "");
return rcExit;
}
default:
return rtZipUnzipDoWithMembers(&Opts, rtZipUnzipCmdExtractCallback, &cFiles, &cBytes);
}
return RTEXITCODE_SUCCESS;
}
int main(int argc, char **argv)
{
RTEXITCODE rcExit = RTTestInitAndCreate("tstRTPrfIO", &g_hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(g_hTest);
/*
* Parse arguments
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--test-dir", 'd', RTGETOPT_REQ_STRING },
};
bool fFileOpenCloseTest = true;
bool fFileWriteByteTest = true;
bool fPathQueryInfoTest = true;
//bool fFileTests = true;
//bool fDirTests = true;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'd':
g_pszTestDir = ValueUnion.psz;
break;
case 'V':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "$Revision: 100874 $\n");
return RTTestSummaryAndDestroy(g_hTest);
case 'h':
RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "usage: testname [-d <testdir>]\n");
return RTTestSummaryAndDestroy(g_hTest);
default:
RTTestFailed(g_hTest, "invalid argument");
RTGetOptPrintError(ch, &ValueUnion);
return RTTestSummaryAndDestroy(g_hTest);
}
}
/*
* Set up and check the prerequisites.
*/
RTTESTI_CHECK_RC(RTPathJoin(g_szTestFile1, sizeof(g_szTestFile1), g_pszTestDir, "tstRTPrfIO-TestFile1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szTestDir1, sizeof(g_szTestDir1), g_pszTestDir, "tstRTPrfIO-TestDir1"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingFile, sizeof(g_szNotExitingFile), g_pszTestDir, "tstRTPrfIO-nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDir, sizeof(g_szNotExitingDir), g_pszTestDir, "tstRTPrfIO-nonexistent-dir"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTPathJoin(g_szNotExitingDirFile, sizeof(g_szNotExitingDirFile), g_szNotExitingDir, "nonexistent-file"), VINF_SUCCESS);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
if (RTPathExists(g_szTestDir1))
RTTestFailed(g_hTest, "The primary test directory (%s) already exist, please remove it", g_szTestDir1);
if (RTPathExists(g_szTestFile1))
RTTestFailed(g_hTest, "The primary test file (%s) already exist, please remove it", g_szTestFile1);
if (RTPathExists(g_szNotExitingFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingFile);
if (RTPathExists(g_szNotExitingDir))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDir);
if (RTPathExists(g_szNotExitingDirFile))
RTTestFailed(g_hTest, "'%s' exists, remove it", g_szNotExitingDirFile);
/*
* Do the testing.
*/
if (RTTestIErrorCount() == 0)
{
#if 1
if (fPathQueryInfoTest)
benchmarkPathQueryInfo();
if (fFileOpenCloseTest)
benchmarkFileOpenClose();
#endif
if (fFileWriteByteTest)
benchmarkFileWriteByte();
//if (fFileTests)
// benchmarkFile();
//if (fDirTests)
// benchmarkDir();
/*
* Cleanup.
*/
RTFileDelete(g_szTestFile1);
RTDirRemoveRecursive(g_szTestDir1, 0);
RTTESTI_CHECK(RTDirExists(g_pszTestDir));
RTTESTI_CHECK(!RTPathExists(g_szTestDir1));
RTTESTI_CHECK(!RTPathExists(g_szTestFile1));
}
return RTTestSummaryAndDestroy(g_hTest);
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
static const RTGETOPTDEF s_aOptions[] =
{
{ "--samples-per-sec", 's', RTGETOPT_REQ_UINT32 },
{ "--period-in-samples", 'p', RTGETOPT_REQ_UINT32 },
{ "--bufsize-in-samples", 'b', RTGETOPT_REQ_UINT32 },
{ "--total-duration-in-secs", 'd', RTGETOPT_REQ_UINT32 }
};
RTGETOPTSTATE State;
RTGetOptInit(&State, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
RTGETOPTUNION ValueUnion;
int chOpt;
while ((chOpt = RTGetOpt(&State, &ValueUnion)) != 0)
{
switch (chOpt)
{
case 's': g_cSamplesPerSec = ValueUnion.u32; break;
case 'p': g_cSamplesPerPeriod = ValueUnion.u32; break;
case 'b': g_cSamplesInBuffer = ValueUnion.u32; break;
case 'd': g_rdSecDuration = ValueUnion.u32; break;
case 'h':
RTPrintf("usage: ntPlayToneWaveX.exe\n"
"[-s|--samples-per-sec]\n"
"[-p|--period-in-samples]\n"
"[-b|--bufsize-in-samples]\n"
"[-d|--total-duration-in-secs]\n"
"\n"
"Plays sine tone using ancient waveX API\n");
return 0;
default:
return RTGetOptPrintError(chOpt, &ValueUnion);
}
}
WAVEFORMATEX waveFormatEx = { 0 };
MMRESULT mmresult;
waveFormatEx.wFormatTag = WAVE_FORMAT_PCM;
waveFormatEx.nChannels = 2;
waveFormatEx.nSamplesPerSec = g_cSamplesPerSec;
waveFormatEx.wBitsPerSample = 16;
waveFormatEx.nBlockAlign = g_cbSample = waveFormatEx.nChannels * waveFormatEx.wBitsPerSample / 8;
waveFormatEx.nAvgBytesPerSec = waveFormatEx.nBlockAlign * waveFormatEx.nSamplesPerSec;
waveFormatEx.cbSize = 0;
g_hWavEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
mmresult = waveOutOpen(&g_hWaveOut, WAVE_MAPPER, &waveFormatEx, (DWORD_PTR)g_hWavEvent, NULL, CALLBACK_EVENT);
if (mmresult != MMSYSERR_NOERROR)
{
RTMsgError("waveOutOpen failed with 0x%X\n", mmresult);
return -1;
}
uint32_t ui32SamplesToPlayTotal = (uint32_t)(g_rdSecDuration * g_cSamplesPerSec);
uint32_t ui32SamplesToPlay = ui32SamplesToPlayTotal;
uint32_t ui32SamplesPlayed = 0;
uint32_t ui32SamplesForWavBuf;
WAVEHDR waveHdr1 = {0}, waveHdr2 = {0}, *pWaveHdr, *pWaveHdrPlaying, *pWaveHdrWaiting;
uint32_t i, k;
DWORD res;
int16_t *i16Samples1 = (int16_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_cSamplesInBuffer * g_cbSample);
int16_t *i16Samples2 = (int16_t *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, g_cSamplesInBuffer * g_cbSample);
k = 0; // This is discrete time really!!!
for (i = 0; i < g_cSamplesInBuffer; i++, k++)
{
i16Samples1[2 * i] = (uint16_t)(10000.0 * sin(2.0 * M_PI * k / g_cSamplesPerPeriod));
i16Samples1[2 * i + 1] = i16Samples1[2 * i];
}
ui32SamplesForWavBuf = min(ui32SamplesToPlay, g_cSamplesInBuffer);
waveHdr1.lpData = (LPSTR)i16Samples1;
waveHdr1.dwBufferLength = ui32SamplesForWavBuf * g_cbSample;
waveHdr1.dwFlags = 0;
waveHdr1.dwLoops = 0;
ui32SamplesToPlay -= ui32SamplesForWavBuf;
ui32SamplesPlayed += ui32SamplesForWavBuf;
pWaveHdrPlaying = &waveHdr1;
mmresult = waveOutPrepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
mmresult = waveOutWrite(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
//RTMsgInfo("waveOutWrite completes with %d\n", mmresult);
res = WaitForSingleObject(g_hWavEvent, INFINITE);
//RTMsgInfo("WaitForSingleObject completes with %d\n\n", res);
waveHdr2.lpData = (LPSTR)i16Samples2;
waveHdr2.dwBufferLength = 0;
waveHdr2.dwFlags = 0;
waveHdr2.dwLoops = 0;
pWaveHdrWaiting = &waveHdr2;
while (ui32SamplesToPlay > 0)
{
int16_t *i16Samples = (int16_t *)pWaveHdrWaiting->lpData;
for (i = 0; i < g_cSamplesInBuffer; i++, k++)
{
i16Samples[2 * i] = (uint16_t)(10000.0 * sin(2.0 * M_PI * k / g_cSamplesPerPeriod));
i16Samples[2 * i + 1] = i16Samples[2 * i];
}
ui32SamplesForWavBuf = min(ui32SamplesToPlay, g_cSamplesInBuffer);
pWaveHdrWaiting->dwBufferLength = ui32SamplesForWavBuf * g_cbSample;
pWaveHdrWaiting->dwFlags = 0;
pWaveHdrWaiting->dwLoops = 0;
ui32SamplesToPlay -= ui32SamplesForWavBuf;
ui32SamplesPlayed += ui32SamplesForWavBuf;
mmresult = waveOutPrepareHeader(g_hWaveOut, pWaveHdrWaiting, sizeof(WAVEHDR));
mmresult = waveOutWrite(g_hWaveOut, pWaveHdrWaiting, sizeof(WAVEHDR));
//RTMsgInfo("waveOutWrite completes with %d\n", mmresult);
res = WaitForSingleObject(g_hWavEvent, INFINITE);
//RTMsgInfo("WaitForSingleObject completes with %d\n\n", res);
mmresult = waveOutUnprepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR));
//RTMsgInfo("waveOutUnprepareHeader completes with %d\n", mmresult);
pWaveHdr = pWaveHdrWaiting;
pWaveHdrWaiting = pWaveHdrPlaying;
pWaveHdrPlaying = pWaveHdr;
}
while (mmresult = waveOutUnprepareHeader(g_hWaveOut, pWaveHdrPlaying, sizeof(WAVEHDR)))
{
//Expecting WAVERR_STILLPLAYING
//RTMsgInfo("waveOutUnprepareHeader failed with 0x%X\n", mmresult);
Sleep(100);
}
if (mmresult == MMSYSERR_NOERROR)
{
waveOutClose(g_hWaveOut);
}
HeapFree(GetProcessHeap(), 0, i16Samples1);
HeapFree(GetProcessHeap(), 0, i16Samples2);
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
RTDIGESTTYPE enmDigestType = RTDIGESTTYPE_INVALID;
const char *pszDigestType = "NotSpecified";
enum
{
kMethod_Full,
kMethod_Block,
kMethod_File,
kMethod_CVAS
} enmMethod = kMethod_Block;
uint64_t offStart = 0;
uint64_t cbMax = UINT64_MAX;
bool fTestcase = false;
static const RTGETOPTDEF s_aOptions[] =
{
{ "--type", 't', RTGETOPT_REQ_STRING },
{ "--method", 'm', RTGETOPT_REQ_STRING },
{ "--help", 'h', RTGETOPT_REQ_NOTHING },
{ "--length", 'l', RTGETOPT_REQ_UINT64 },
{ "--offset", 'o', RTGETOPT_REQ_UINT64 },
{ "--testcase", 'x', RTGETOPT_REQ_NOTHING },
};
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 't':
if (!RTStrICmp(ValueUnion.psz, "crc32"))
{
pszDigestType = "CRC32";
enmDigestType = RTDIGESTTYPE_CRC32;
}
else if (!RTStrICmp(ValueUnion.psz, "crc64"))
{
pszDigestType = "CRC64";
enmDigestType = RTDIGESTTYPE_CRC64;
}
else if (!RTStrICmp(ValueUnion.psz, "md2"))
{
pszDigestType = "MD2";
enmDigestType = RTDIGESTTYPE_MD2;
}
else if (!RTStrICmp(ValueUnion.psz, "md5"))
{
pszDigestType = "MD5";
enmDigestType = RTDIGESTTYPE_MD5;
}
else if (!RTStrICmp(ValueUnion.psz, "sha1"))
{
pszDigestType = "SHA-1";
enmDigestType = RTDIGESTTYPE_SHA1;
}
else if (!RTStrICmp(ValueUnion.psz, "sha224"))
{
pszDigestType = "SHA-224";
enmDigestType = RTDIGESTTYPE_SHA224;
}
else if (!RTStrICmp(ValueUnion.psz, "sha256"))
{
pszDigestType = "SHA-256";
enmDigestType = RTDIGESTTYPE_SHA256;
}
else if (!RTStrICmp(ValueUnion.psz, "sha384"))
{
pszDigestType = "SHA-384";
enmDigestType = RTDIGESTTYPE_SHA384;
}
else if (!RTStrICmp(ValueUnion.psz, "sha512"))
{
pszDigestType = "SHA-512";
enmDigestType = RTDIGESTTYPE_SHA512;
}
else if (!RTStrICmp(ValueUnion.psz, "sha512/224"))
{
pszDigestType = "SHA-512/224";
enmDigestType = RTDIGESTTYPE_SHA512T224;
}
else if (!RTStrICmp(ValueUnion.psz, "sha512/256"))
{
pszDigestType = "SHA-512/256";
enmDigestType = RTDIGESTTYPE_SHA512T256;
}
else
{
Error("Invalid digest type: %s\n", ValueUnion.psz);
return 1;
}
break;
case 'm':
if (!RTStrICmp(ValueUnion.psz, "full"))
enmMethod = kMethod_Full;
else if (!RTStrICmp(ValueUnion.psz, "block"))
enmMethod = kMethod_Block;
else if (!RTStrICmp(ValueUnion.psz, "file"))
enmMethod = kMethod_File;
else if (!RTStrICmp(ValueUnion.psz, "cvas"))
enmMethod = kMethod_CVAS;
else
{
Error("Invalid digest method: %s\n", ValueUnion.psz);
return 1;
}
break;
case 'l':
cbMax = ValueUnion.u64;
break;
case 'o':
offStart = ValueUnion.u64;
break;
case 'x':
fTestcase = true;
break;
case 'h':
RTPrintf("usage: tstRTDigest -t <digest-type> [-o <offset>] [-l <length>] [-x] file [file2 [..]]\n");
return 1;
case VINF_GETOPT_NOT_OPTION:
{
if (enmDigestType == RTDIGESTTYPE_INVALID)
return Error("No digest type was specified\n");
switch (enmMethod)
{
case kMethod_Full:
return Error("Full file method is not implemented\n");
case kMethod_File:
if (offStart != 0 || cbMax != UINT64_MAX)
return Error("The -l and -o options do not work with the 'file' method.");
switch (enmDigestType)
{
case RTDIGESTTYPE_SHA1:
{
char *pszDigest;
int rc = RTSha1DigestFromFile(ValueUnion.psz, &pszDigest, NULL, NULL);
if (RT_FAILURE(rc))
return Error("RTSha1Digest(%s,) -> %Rrc\n", ValueUnion.psz, rc);
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
RTStrFree(pszDigest);
break;
}
case RTDIGESTTYPE_SHA256:
{
char *pszDigest;
int rc = RTSha256DigestFromFile(ValueUnion.psz, &pszDigest, NULL, NULL);
if (RT_FAILURE(rc))
return Error("RTSha256Digest(%s,) -> %Rrc\n", ValueUnion.psz, rc);
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
RTStrFree(pszDigest);
break;
}
default:
return Error("The file method isn't implemented for this digest\n");
}
break;
case kMethod_Block:
{
RTFILE hFile;
int rc = RTFileOpen(&hFile, ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(rc))
return Error("RTFileOpen(,%s,) -> %Rrc\n", ValueUnion.psz, rc);
if (offStart != 0)
{
rc = RTFileSeek(hFile, offStart, RTFILE_SEEK_BEGIN, NULL);
if (RT_FAILURE(rc))
return Error("RTFileSeek(%s,%ull) -> %Rrc\n", ValueUnion.psz, offStart, rc);
}
uint64_t cbMaxLeft = cbMax;
size_t cbRead;
uint8_t abBuf[_64K];
char *pszDigest = (char *)&abBuf[0];
switch (enmDigestType)
{
case RTDIGESTTYPE_CRC32:
{
uint32_t uCRC32 = RTCrc32Start();
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
uCRC32 = RTCrc32Process(uCRC32, abBuf, cbRead);
}
uCRC32 = RTCrc32Finish(uCRC32);
RTStrPrintf(pszDigest, sizeof(abBuf), "%08RX32", uCRC32);
break;
}
case RTDIGESTTYPE_CRC64:
{
uint64_t uCRC64 = RTCrc64Start();
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
uCRC64 = RTCrc64Process(uCRC64, abBuf, cbRead);
}
uCRC64 = RTCrc64Finish(uCRC64);
RTStrPrintf(pszDigest, sizeof(abBuf), "%016RX64", uCRC64);
break;
}
case RTDIGESTTYPE_MD2:
{
RTMD2CONTEXT Ctx;
RTMd2Init(&Ctx);
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
RTMd2Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTMD2_HASH_SIZE];
RTMd2Final(&Ctx, abDigest);
RTMd2ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case RTDIGESTTYPE_MD5:
{
RTMD5CONTEXT Ctx;
RTMd5Init(&Ctx);
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
RTMd5Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTMD5HASHSIZE];
RTMd5Final(abDigest, &Ctx);
RTMd5ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case RTDIGESTTYPE_SHA1:
{
RTSHA1CONTEXT Ctx;
RTSha1Init(&Ctx);
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha1Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA1_HASH_SIZE];
RTSha1Final(&Ctx, abDigest);
RTSha1ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case RTDIGESTTYPE_SHA256:
{
RTSHA256CONTEXT Ctx;
RTSha256Init(&Ctx);
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha256Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA256_HASH_SIZE];
RTSha256Final(&Ctx, abDigest);
RTSha256ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case RTDIGESTTYPE_SHA512:
{
RTSHA512CONTEXT Ctx;
RTSha512Init(&Ctx);
for (;;)
{
rc = MyReadFile(hFile, abBuf, sizeof(abBuf), &cbRead, &cbMaxLeft);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha512Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA512_HASH_SIZE];
RTSha512Final(&Ctx, abDigest);
RTSha512ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
default:
return Error("Internal error #1\n");
}
RTFileClose(hFile);
if (RT_FAILURE(rc) && rc != VERR_EOF)
{
RTPrintf("Partial: %s %s\n", pszDigest, ValueUnion.psz);
return Error("RTFileRead(%s) -> %Rrc\n", ValueUnion.psz, rc);
}
if (!fTestcase)
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
else if (offStart)
RTPrintf(" { &g_abRandom72KB[%#4llx], %5llu, \"%s\", \"%s %llu bytes @%llu\" },\n",
offStart, cbMax - cbMaxLeft, pszDigest, pszDigestType, offStart, cbMax - cbMaxLeft);
else
RTPrintf(" { &g_abRandom72KB[0], %5llu, \"%s\", \"%s %llu bytes\" },\n",
cbMax - cbMaxLeft, pszDigest, pszDigestType, cbMax - cbMaxLeft);
break;
}
/*
* Process a SHS response file:
* http://csrc.nist.gov/groups/STM/cavp/index.html#03
*/
case kMethod_CVAS:
{
RTCRDIGEST hDigest;
int rc = RTCrDigestCreateByType(&hDigest, enmDigestType);
if (RT_FAILURE(rc))
return Error("Failed to create digest calculator for %s: %Rrc", pszDigestType, rc);
uint32_t const cbDigest = RTCrDigestGetHashSize(hDigest);
if (!cbDigest || cbDigest >= _1K)
return Error("Unexpected hash size: %#x\n", cbDigest);
PRTSTREAM pFile;
rc = RTStrmOpen(ValueUnion.psz, "r", &pFile);
if (RT_FAILURE(rc))
return Error("Failed to open CVAS file '%s': %Rrc", ValueUnion.psz, rc);
/*
* Parse the input file.
* ASSUME order: Len, Msg, MD.
*/
static char s_szLine[_256K];
char *psz;
uint32_t cPassed = 0;
uint32_t cErrors = 0;
uint32_t iLine = 1;
for (;;)
{
psz = MyGetNextSignificantLine(pFile, s_szLine, sizeof(s_szLine), &iLine, &rc);
if (!psz)
break;
/* Skip [L = 20] stuff. */
if (*psz == '[')
continue;
/* Message length. */
uint64_t cMessageBits;
if (RTStrNICmp(psz, RT_STR_TUPLE("Len =")))
return Error("%s(%d): Expected 'Len =' found '%.10s...'", ValueUnion.psz, iLine, psz);
psz = RTStrStripL(psz + 5);
rc = RTStrToUInt64Full(psz, 0, &cMessageBits);
if (rc != VINF_SUCCESS)
return Error("%s(%d): Error parsing length '%s': %Rrc\n", ValueUnion.psz, iLine, psz, rc);
/* The message text. */
psz = MyGetNextSignificantLine(pFile, s_szLine, sizeof(s_szLine), &iLine, &rc);
if (!psz)
return Error("%s(%d): Expected message text not EOF.", ValueUnion.psz, iLine);
if (RTStrNICmp(psz, RT_STR_TUPLE("Msg =")))
return Error("%s(%d): Expected 'Msg =' found '%.10s...'", ValueUnion.psz, iLine, psz);
psz = RTStrStripL(psz + 5);
size_t const cbMessage = (cMessageBits + 7) / 8;
static uint8_t s_abMessage[sizeof(s_szLine) / 2];
if (cbMessage > 0)
{
rc = RTStrConvertHexBytes(psz, s_abMessage, cbMessage, 0 /*fFlags*/);
if (rc != VINF_SUCCESS)
return Error("%s(%d): Error parsing message '%.10s...': %Rrc\n",
ValueUnion.psz, iLine, psz, rc);
}
/* The message digest. */
psz = MyGetNextSignificantLine(pFile, s_szLine, sizeof(s_szLine), &iLine, &rc);
if (!psz)
return Error("%s(%d): Expected message digest not EOF.", ValueUnion.psz, iLine);
if (RTStrNICmp(psz, RT_STR_TUPLE("MD =")))
return Error("%s(%d): Expected 'MD =' found '%.10s...'", ValueUnion.psz, iLine, psz);
psz = RTStrStripL(psz + 4);
static uint8_t s_abExpectedDigest[_1K];
rc = RTStrConvertHexBytes(psz, s_abExpectedDigest, cbDigest, 0 /*fFlags*/);
if (rc != VINF_SUCCESS)
return Error("%s(%d): Error parsing message digest '%.10s...': %Rrc\n",
ValueUnion.psz, iLine, psz, rc);
/*
* Do the testing.
*/
rc = RTCrDigestReset(hDigest);
if (rc != VINF_SUCCESS)
return Error("RTCrDigestReset failed: %Rrc", rc);
rc = RTCrDigestUpdate(hDigest, s_abMessage, cbMessage);
if (rc != VINF_SUCCESS)
return Error("RTCrDigestUpdate failed: %Rrc", rc);
static uint8_t s_abActualDigest[_1K];
rc = RTCrDigestFinal(hDigest, s_abActualDigest, cbDigest);
if (rc != VINF_SUCCESS)
return Error("RTCrDigestFinal failed: %Rrc", rc);
if (memcmp(s_abActualDigest, s_abExpectedDigest, cbDigest) == 0)
cPassed++;
else
{
Error("%s(%d): Message digest mismatch. Expected %.*RThxs, got %.*RThxs.",
ValueUnion.psz, iLine, cbDigest, s_abExpectedDigest, cbDigest, s_abActualDigest);
cErrors++;
}
}
RTStrmClose(pFile);
if (cErrors > 0)
return Error("Failed: %u error%s (%u passed)", cErrors, cErrors == 1 ? "" : "s", cPassed);
RTPrintf("Passed %u test%s.\n", cPassed, cPassed == 1 ? "" : "s");
if (RT_FAILURE(rc))
return Error("Failed: %Rrc", rc);
break;
}
default:
return Error("Internal error #2\n");
}
break;
}
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
return 0;
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--ascii", 'a', RTGETOPT_REQ_NOTHING },
{ "--stdout", 'c', RTGETOPT_REQ_NOTHING },
{ "--to-stdout", 'c', RTGETOPT_REQ_NOTHING },
{ "--decompress", 'd', RTGETOPT_REQ_NOTHING },
{ "--uncompress", 'd', RTGETOPT_REQ_NOTHING },
{ "--force", 'f', RTGETOPT_REQ_NOTHING },
{ "--list", 'l', RTGETOPT_REQ_NOTHING },
{ "--no-name", 'n', RTGETOPT_REQ_NOTHING },
{ "--name", 'N', RTGETOPT_REQ_NOTHING },
{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
{ "--recursive", 'r', RTGETOPT_REQ_NOTHING },
{ "--suffix", 'S', RTGETOPT_REQ_STRING },
{ "--test", 't', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
{ "--fast", '1', RTGETOPT_REQ_NOTHING },
{ "-1", '1', RTGETOPT_REQ_NOTHING },
{ "-2", '2', RTGETOPT_REQ_NOTHING },
{ "-3", '3', RTGETOPT_REQ_NOTHING },
{ "-4", '4', RTGETOPT_REQ_NOTHING },
{ "-5", '5', RTGETOPT_REQ_NOTHING },
{ "-6", '6', RTGETOPT_REQ_NOTHING },
{ "-7", '7', RTGETOPT_REQ_NOTHING },
{ "-8", '8', RTGETOPT_REQ_NOTHING },
{ "-9", '9', RTGETOPT_REQ_NOTHING },
{ "--best", '9', RTGETOPT_REQ_NOTHING }
};
bool fAscii = false;
bool fStdOut = false;
bool fDecompress = false;
bool fForce = false;
bool fList = false;
bool fName = true;
bool fQuiet = false;
bool fRecursive = false;
const char *pszSuff = ".gz";
bool fTest = false;
unsigned uLevel = 6;
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
unsigned cProcessed = 0;
RTVFSIOSTREAM hVfsStdOut= NIL_RTVFSIOSTREAM;
RTGETOPTSTATE GetState;
rc = RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
for (;;)
{
RTGETOPTUNION ValueUnion;
rc = RTGetOpt(&GetState, &ValueUnion);
switch (rc)
{
case 0:
{
/*
* If we've processed any files we're done. Otherwise take
* input from stdin and write the output to stdout.
*/
if (cProcessed > 0)
return rcExit;
#if 0
rc = RTVfsFileFromRTFile(1,
RTFILE_O_WRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
true /*fLeaveOpen*/,
&hVfsOut);
if (!fForce && isStdHandleATty(fDecompress ? 0 : 1))
return RTMsgErrorExit(RTEXITCODE_SYNTAX,
"Yeah, right. I'm not %s any compressed data %s the terminal without --force.\n",
fDecompress ? "reading" : "writing",
fDecompress ? "from" : "to");
#else
rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "reading from standard input has not yet been implemented");
#endif
return rcExit;
}
case VINF_GETOPT_NOT_OPTION:
{
if (!*pszSuff && !fStdOut)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --suffix option specified an empty string");
if (!fStdOut && RTVfsChainIsSpec(ValueUnion.psz))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Must use standard out with VFS chain specifications");
RTEXITCODE rcExit2;
if (fList)
rcExit2 = gzipListFile(ValueUnion.psz, fForce);
else if (fTest)
rcExit2 = gzipTestFile(ValueUnion.psz, fForce);
else if (fDecompress)
rcExit2 = gzipDecompressFile(ValueUnion.psz, fStdOut, fForce, &hVfsStdOut);
else
rcExit2 = gzipCompressFile(ValueUnion.psz, fStdOut, fForce, &hVfsStdOut);
if (rcExit2 != RTEXITCODE_SUCCESS)
rcExit = rcExit2;
cProcessed++;
break;
}
case 'a':
fAscii = true;
break;
case 'c':
fStdOut = true;
break;
case 'd':
fDecompress = true;
break;
case 'f':
fForce = true;
break;
case 'l':
fList = true;
break;
case 'n':
fName = false;
break;
case 'N':
fName = true;
break;
case 'q':
fQuiet = true;
break;
case 'r':
fRecursive = true;
break;
case 'S':
pszSuff = ValueUnion.psz;
break;
case 't':
fTest = true;
break;
case 'v':
fQuiet = false;
break;
case '1':
uLevel = 1;
break;
case '2':
uLevel = 2;
break;
case '3':
uLevel = 3;
break;
case '4':
uLevel = 4;
break;
case '5':
uLevel = 5;
break;
case '6':
uLevel = 6;
break;
case '7':
uLevel = 7;
break;
case '8':
uLevel = 8;
break;
case '9':
uLevel = 9;
break;
case 'h':
RTPrintf("Usage: to be written\nOption dump:\n");
for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++)
RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
/*
* Options are mandatory.
*/
if (argc <= 1)
return usage();
/*
* Parse the options.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--flags", 'f', RTGETOPT_REQ_STRING },
{ "--groups", 'g', RTGETOPT_REQ_STRING },
{ "--dest", 'd', RTGETOPT_REQ_STRING },
{ "--what", 'o', RTGETOPT_REQ_STRING },
{ "--which", 'l', RTGETOPT_REQ_STRING },
};
const char *pszFlags = "";
const char *pszGroups = "";
const char *pszDest = "";
SUPLOGGER enmWhich = SUPLOGGER_DEBUG;
enum
{
kSupLoggerCtl_Set, kSupLoggerCtl_Create, kSupLoggerCtl_Destroy
} enmWhat = kSupLoggerCtl_Set;
int ch;
int i = 1;
RTGETOPTUNION Val;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &Val)))
{
switch (ch)
{
case 'f':
pszFlags = Val.psz;
break;
case 'g':
pszGroups = Val.psz;
break;
case 'd':
pszDest = Val.psz;
break;
case 'o':
if (!strcmp(Val.psz, "set"))
enmWhat = kSupLoggerCtl_Set;
else if (!strcmp(Val.psz, "create"))
enmWhat = kSupLoggerCtl_Create;
else if (!strcmp(Val.psz, "destroy"))
enmWhat = kSupLoggerCtl_Destroy;
else
{
RTStrmPrintf(g_pStdErr, "SUPLoggerCtl: error: Unknown operation '%s'.\n", Val.psz);
return 1;
}
break;
case 'l':
if (!strcmp(Val.psz, "debug"))
enmWhich = SUPLOGGER_DEBUG;
else if (!strcmp(Val.psz, "release"))
enmWhich = SUPLOGGER_RELEASE;
else
{
RTStrmPrintf(g_pStdErr, "SUPLoggerCtl: error: Unknown logger '%s'.\n", Val.psz);
return 1;
}
break;
case 'h':
return usage();
case 'V':
RTPrintf("%sr%s\n", RTBldCfgVersion(), RTBldCfgRevisionStr());
return 0;
case VINF_GETOPT_NOT_OPTION:
RTStrmPrintf(g_pStdErr, "SUPLoggerCtl: error: Unexpected argument '%s'.\n", Val.psz);
return 1;
default:
return RTGetOptPrintError(ch, &Val);
}
}
/*
* Do the requested job.
*/
int rc;
switch (enmWhat)
{
case kSupLoggerCtl_Set:
rc = SUPR3LoggerSettings(enmWhich, pszFlags, pszGroups, pszDest);
break;
case kSupLoggerCtl_Create:
rc = SUPR3LoggerCreate(enmWhich, pszFlags, pszGroups, pszDest);
break;
case kSupLoggerCtl_Destroy:
rc = SUPR3LoggerDestroy(enmWhich);
break;
default:
rc = VERR_INTERNAL_ERROR;
break;
}
if (RT_SUCCESS(rc))
RTPrintf("SUPLoggerCtl: Success\n");
else
RTStrmPrintf(g_pStdErr, "SUPLoggerCtl: error: rc=%Rrc\n", rc);
return RT_SUCCESS(rc) ? 0 : 1;
}
/**
* Parse the arguments.
*
* @returns 0 on success, fully bitched exit code on failure.
*
* @param argc Argument count.
* @param argv Argument vector.
*
* @todo r=bird: The --help and --version options shall not return a
* non-zero exit code. So, this method need to grow some
* complexity. I'm to blame for that blunder :/
*/
int VBoxNetBaseService::parseArgs(int argc, char **argv)
{
RTGETOPTSTATE State;
PRTGETOPTDEF paOptionArray = getOptionsPtr();
int rc = RTGetOptInit(&State, argc, argv, paOptionArray, m->m_vecOptionDefs.size(), 0, 0 /*fFlags*/);
AssertRCReturn(rc, 49);
#if 0
/* default initialization */
m_enmTrunkType = kIntNetTrunkType_WhateverNone;
#endif
Log2(("BaseService: parseArgs enter\n"));
for (;;)
{
RTGETOPTUNION Val;
rc = RTGetOpt(&State, &Val);
if (!rc)
break;
switch (rc)
{
case 'N': // --name
m->m_ServiceName = Val.psz;
break;
case 'n': // --network
m->m_NetworkName = Val.psz;
break;
case 't': //--trunk-name
m->m_TrunkName = Val.psz;
break;
case 'T': //--trunk-type
if (!strcmp(Val.psz, "none"))
m->m_enmTrunkType = kIntNetTrunkType_None;
else if (!strcmp(Val.psz, "whatever"))
m->m_enmTrunkType = kIntNetTrunkType_WhateverNone;
else if (!strcmp(Val.psz, "netflt"))
m->m_enmTrunkType = kIntNetTrunkType_NetFlt;
else if (!strcmp(Val.psz, "netadp"))
m->m_enmTrunkType = kIntNetTrunkType_NetAdp;
else if (!strcmp(Val.psz, "srvnat"))
m->m_enmTrunkType = kIntNetTrunkType_SrvNat;
else
{
RTStrmPrintf(g_pStdErr, "Invalid trunk type '%s'\n", Val.psz);
return RTEXITCODE_SYNTAX;
}
break;
case 'a': // --mac-address
m->m_MacAddress = Val.MacAddr;
break;
case 'i': // --ip-address
m->m_Ipv4Address = Val.IPv4Addr;
break;
case 'm': // --netmask
m->m_Ipv4Netmask = Val.IPv4Addr;
break;
case 'v': // --verbose
m->m_cVerbosity++;
break;
case 'V': // --version (missed)
RTPrintf("%sr%u\n", RTBldCfgVersion(), RTBldCfgRevision());
return 1; /** @todo this exit code is wrong, of course. :/ */
case 'M': // --need-main
m->m_fNeedMain = true;
break;
case 'h': // --help (missed)
RTPrintf("%s Version %sr%u\n"
"(C) 2009-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
"All rights reserved.\n"
"\n"
"Usage: %s <options>\n"
"\n"
"Options:\n",
RTProcShortName(),
RTBldCfgVersion(),
RTBldCfgRevision(),
RTProcShortName());
for (unsigned int i = 0; i < m->m_vecOptionDefs.size(); i++)
RTPrintf(" -%c, %s\n", m->m_vecOptionDefs[i]->iShort, m->m_vecOptionDefs[i]->pszLong);
usage(); /* to print Service Specific usage */
return 1; /** @todo this exit code is wrong, of course. :/ */
default:
{
int rc1 = parseOpt(rc, Val);
if (RT_FAILURE(rc1))
{
RTEXITCODE rcExit = RTGetOptPrintError(rc, &Val);
RTPrintf("Use --help for more information.\n");
return rcExit;
}
break;
}
}
}
RTMemFree(paOptionArray);
return RTEXITCODE_SUCCESS;
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Parse arguments up to the command and pass it on to the command handlers.
*/
typedef enum
{
VCUACTION_ADD_TRUSTED_PUBLISHER = 1000,
VCUACTION_REMOVE_TRUSTED_PUBLISHER,
VCUACTION_DISPLAY_ALL,
VCUACTION_END
} VCUACTION;
static const RTGETOPTDEF s_aOptions[] =
{
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
{ "add-trusted-publisher", VCUACTION_ADD_TRUSTED_PUBLISHER, RTGETOPT_REQ_NOTHING },
{ "remove-trusted-publisher", VCUACTION_REMOVE_TRUSTED_PUBLISHER, RTGETOPT_REQ_NOTHING },
{ "display-all", VCUACTION_DISPLAY_ALL, RTGETOPT_REQ_NOTHING },
};
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((rc = RTGetOpt(&GetState, &ValueUnion)))
{
switch (rc)
{
case 'v':
g_cVerbosityLevel++;
break;
case 'q':
if (g_cVerbosityLevel > 0)
g_cVerbosityLevel--;
break;
case 'h':
showUsage(argv[0]);
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
case VCUACTION_ADD_TRUSTED_PUBLISHER:
return cmdAddTrustedPublisher(argc - GetState.iNext + 1, argv + GetState.iNext - 1);
case VCUACTION_REMOVE_TRUSTED_PUBLISHER:
return cmdRemoveTrustedPublisher(argc - GetState.iNext + 1, argv + GetState.iNext - 1);
case VCUACTION_DISPLAY_ALL:
return cmdDisplayAll(argc - GetState.iNext + 1, argv + GetState.iNext - 1);
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
RTMsgError("Missing command...");
showUsage(argv[0]);
return RTEXITCODE_SYNTAX;
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
enum
{
kDigestType_NotSpecified,
kDigestType_CRC32,
kDigestType_CRC64,
kDigestType_MD5,
kDigestType_SHA1,
kDigestType_SHA256,
kDigestType_SHA512
} enmDigestType = kDigestType_NotSpecified;
enum
{
kMethod_Full,
kMethod_Block,
kMethod_File
} enmMethod = kMethod_Block;
static const RTGETOPTDEF s_aOptions[] =
{
{ "--type", 't', RTGETOPT_REQ_STRING },
{ "--method", 'm', RTGETOPT_REQ_STRING },
{ "--help", 'h', RTGETOPT_REQ_NOTHING },
};
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 't':
if (!RTStrICmp(ValueUnion.psz, "crc32"))
enmDigestType = kDigestType_CRC32;
else if (!RTStrICmp(ValueUnion.psz, "crc64"))
enmDigestType = kDigestType_CRC64;
else if (!RTStrICmp(ValueUnion.psz, "md5"))
enmDigestType = kDigestType_MD5;
else if (!RTStrICmp(ValueUnion.psz, "sha1"))
enmDigestType = kDigestType_SHA1;
else if (!RTStrICmp(ValueUnion.psz, "sha256"))
enmDigestType = kDigestType_SHA256;
else if (!RTStrICmp(ValueUnion.psz, "sha512"))
enmDigestType = kDigestType_SHA512;
else
{
Error("Invalid digest type: %s\n", ValueUnion.psz);
return 1;
}
break;
case 'm':
if (!RTStrICmp(ValueUnion.psz, "full"))
enmMethod = kMethod_Full;
else if (!RTStrICmp(ValueUnion.psz, "block"))
enmMethod = kMethod_Block;
else if (!RTStrICmp(ValueUnion.psz, "file"))
enmMethod = kMethod_File;
else
{
Error("Invalid digest method: %s\n", ValueUnion.psz);
return 1;
}
break;
case 'h':
RTPrintf("syntax: tstRTDigest -t <digest-type> file [file2 [..]]\n");
return 1;
case VINF_GETOPT_NOT_OPTION:
{
if (enmDigestType == kDigestType_NotSpecified)
return Error("No digest type was specified\n");
switch (enmMethod)
{
case kMethod_Full:
return Error("Full file method is not implemented\n");
case kMethod_File:
switch (enmDigestType)
{
case kDigestType_SHA1:
{
char *pszDigest;
int rc = RTSha1DigestFromFile(ValueUnion.psz, &pszDigest, NULL, NULL);
if (RT_FAILURE(rc))
return Error("RTSha1Digest(%s,) -> %Rrc\n", ValueUnion.psz, rc);
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
RTStrFree(pszDigest);
break;
}
case kDigestType_SHA256:
{
char *pszDigest;
int rc = RTSha256DigestFromFile(ValueUnion.psz, &pszDigest, NULL, NULL);
if (RT_FAILURE(rc))
return Error("RTSha256Digest(%s,) -> %Rrc\n", ValueUnion.psz, rc);
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
RTStrFree(pszDigest);
break;
}
default:
return Error("The file method isn't implemented for this digest\n");
}
break;
case kMethod_Block:
{
RTFILE hFile;
int rc = RTFileOpen(&hFile, ValueUnion.psz, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
if (RT_FAILURE(rc))
return Error("RTFileOpen(,%s,) -> %Rrc\n", ValueUnion.psz, rc);
size_t cbRead;
uint8_t abBuf[_64K];
char *pszDigest = (char *)&abBuf[0];
switch (enmDigestType)
{
case kDigestType_CRC32:
{
uint32_t uCRC32 = RTCrc32Start();
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
uCRC32 = RTCrc32Process(uCRC32, abBuf, cbRead);
}
uCRC32 = RTCrc32Finish(uCRC32);
RTStrPrintf(pszDigest, sizeof(abBuf), "%08RX32", uCRC32);
break;
}
case kDigestType_CRC64:
{
uint64_t uCRC64 = RTCrc64Start();
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
uCRC64 = RTCrc64Process(uCRC64, abBuf, cbRead);
}
uCRC64 = RTCrc64Finish(uCRC64);
RTStrPrintf(pszDigest, sizeof(abBuf), "%016RX64", uCRC64);
break;
}
case kDigestType_MD5:
{
RTMD5CONTEXT Ctx;
RTMd5Init(&Ctx);
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
RTMd5Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTMD5HASHSIZE];
RTMd5Final(abDigest, &Ctx);
RTMd5ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case kDigestType_SHA1:
{
RTSHA1CONTEXT Ctx;
RTSha1Init(&Ctx);
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha1Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA1_HASH_SIZE];
RTSha1Final(&Ctx, abDigest);
RTSha1ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case kDigestType_SHA256:
{
RTSHA256CONTEXT Ctx;
RTSha256Init(&Ctx);
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha256Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA256_HASH_SIZE];
RTSha256Final(&Ctx, abDigest);
RTSha256ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
case kDigestType_SHA512:
{
RTSHA512CONTEXT Ctx;
RTSha512Init(&Ctx);
for (;;)
{
rc = RTFileRead(hFile, abBuf, sizeof(abBuf), &cbRead);
if (RT_FAILURE(rc) || !cbRead)
break;
RTSha512Update(&Ctx, abBuf, cbRead);
}
uint8_t abDigest[RTSHA512_HASH_SIZE];
RTSha512Final(&Ctx, abDigest);
RTSha512ToString(abDigest, pszDigest, sizeof(abBuf));
break;
}
default:
return Error("Internal error #1\n");
}
RTFileClose(hFile);
if (RT_FAILURE(rc) && rc != VERR_EOF)
{
RTPrintf("Partial: %s %s\n", pszDigest, ValueUnion.psz);
return Error("RTFileRead(%s) -> %Rrc\n", ValueUnion.psz, rc);
}
RTPrintf("%s %s\n", pszDigest, ValueUnion.psz);
break;
}
default:
return Error("Internal error #2\n");
}
break;
}
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
return 0;
}
static RTEXITCODE RTCmdRmDir(unsigned cArgs, char **papszArgs)
{
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
/* operations */
{ "--parents", 'p', RTGETOPT_REQ_NOTHING },
{ "--ignore-fail-on-non-empty", 'F', RTGETOPT_REQ_NOTHING },
{ "--ignore-non-existing", 'E', RTGETOPT_REQ_NOTHING },
{ "--always-use-vfs-chain-api", 'A', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
};
RTGETOPTSTATE GetState;
int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTGetOpt failed: %Rrc", rc);
RTCMDRMDIROPTS Opts;
Opts.fVerbose = false;
Opts.fParents = false;
Opts.fIgnoreNotEmpty = false;
Opts.fIgnoreNonExisting = false;
Opts.fAlwaysUseChainApi = false;
RTGETOPTUNION ValueUnion;
while ( (rc = RTGetOpt(&GetState, &ValueUnion)) != 0
&& rc != VINF_GETOPT_NOT_OPTION)
{
switch (rc)
{
case 'p':
Opts.fParents = true;
break;
case 'v':
Opts.fVerbose = true;
break;
case 'A':
Opts.fAlwaysUseChainApi = true;
break;
case 'E':
Opts.fIgnoreNonExisting = true;
break;
case 'F':
Opts.fIgnoreNotEmpty = true;
break;
case 'h':
RTPrintf("Usage: %s [options] <dir> [..]\n"
"\n"
"Removes empty directories.\n"
"\n"
"Options:\n"
" -p, --parent\n"
" Remove specified parent directories too.\n"
" -F, --ignore-fail-on-non-empty\n"
" Do not fail if a directory is not empty, just ignore it.\n"
" This is really handy with the -p option.\n"
" -E, --ignore-non-existing\n"
" Do not fail if a specified directory is not there.\n"
" -v, --verbose\n"
" Tell which directories get remove.\n"
" -A, --always-use-vfs-chain-api\n"
" Always use the VFS API.\n"
, papszArgs[0]);
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* No files means error.
*/
if (rc != VINF_GETOPT_NOT_OPTION)
return RTMsgErrorExit(RTEXITCODE_FAILURE, "No directories specified.\n");
/*
* Work thru the specified dirs.
*/
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
while (rc == VINF_GETOPT_NOT_OPTION)
{
if (Opts.fParents)
rc = rtCmdRmDirOneWithParents(&Opts, ValueUnion.psz);
else
rc = rtCmdRmDirOne(&Opts, ValueUnion.psz);
if (RT_FAILURE(rc))
rcExit = RTEXITCODE_FAILURE;
/* next */
rc = RTGetOpt(&GetState, &ValueUnion);
}
if (rc != 0)
rcExit = RTGetOptPrintError(rc, &ValueUnion);
return rcExit;
}
/**
* Entry point.
*/
extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
{
/*
* Init runtime and the test environment.
*/
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, RTR3INIT_FLAGS_SUPLIB, "tstVMM", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--cpus", 'c', RTGETOPT_REQ_UINT8 },
{ "--test", 't', RTGETOPT_REQ_STRING },
};
enum
{
kTstVMMTest_VMM, kTstVMMTest_TM, kTstVMMTest_MSRs
} enmTestOpt = kTstVMMTest_VMM;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'c':
g_cCpus = ValueUnion.u8;
break;
case 't':
if (!strcmp("vmm", ValueUnion.psz))
enmTestOpt = kTstVMMTest_VMM;
else if (!strcmp("tm", ValueUnion.psz))
enmTestOpt = kTstVMMTest_TM;
else if (!strcmp("msr", ValueUnion.psz) || !strcmp("msrs", ValueUnion.psz))
enmTestOpt = kTstVMMTest_MSRs;
else
{
RTPrintf("tstVMM: unknown test: '%s'\n", ValueUnion.psz);
return 1;
}
break;
case 'h':
RTPrintf("usage: tstVMM [--cpus|-c cpus] [--test <vmm|tm|msr>]\n");
return 1;
case 'V':
RTPrintf("$Revision: 94787 $\n");
return 0;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
/*
* Create the test VM.
*/
RTPrintf(TESTCASE ": Initializing...\n");
PVM pVM;
PUVM pUVM;
int rc = VMR3Create(g_cCpus, NULL, NULL, NULL, tstVMMConfigConstructor, NULL, &pVM, &pUVM);
if (RT_SUCCESS(rc))
{
PDMR3LdrEnumModules(pVM, tstVMMLdrEnum, NULL);
RTStrmFlush(g_pStdOut);
RTThreadSleep(256);
/*
* Do the requested testing.
*/
switch (enmTestOpt)
{
case kTstVMMTest_VMM:
{
RTTestSub(hTest, "VMM");
rc = VMR3ReqCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)VMMDoTest, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
STAMR3Dump(pUVM, "*");
break;
}
case kTstVMMTest_TM:
{
RTTestSub(hTest, "TM");
for (VMCPUID idCpu = 1; idCpu < g_cCpus; idCpu++)
{
rc = VMR3ReqCallNoWaitU(pUVM, idCpu, (PFNRT)tstTMWorker, 2, pVM, hTest);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3ReqCall failed: rc=%Rrc\n", rc);
}
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)tstTMWorker, 2, pVM, hTest);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoTest failed: rc=%Rrc\n", rc);
STAMR3Dump(pUVM, "*");
break;
}
case kTstVMMTest_MSRs:
{
RTTestSub(hTest, "MSRs");
if (g_cCpus == 1)
{
rc = VMR3ReqCallWaitU(pUVM, 0 /*idDstCpu*/, (PFNRT)VMMDoBruteForceMsrs, 1, pVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMMDoBruteForceMsrs failed: rc=%Rrc\n", rc);
}
else
RTTestFailed(hTest, "The MSR test can only be run with one VCpu!\n");
break;
}
}
/*
* Cleanup.
*/
rc = VMR3PowerOff(pUVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3PowerOff failed: rc=%Rrc\n", rc);
rc = VMR3Destroy(pUVM);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "VMR3Destroy failed: rc=%Rrc\n", rc);
VMR3ReleaseUVM(pUVM);
}
else
RTTestFailed(hTest, "VMR3Create failed: rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
/**
* A mini GZIP program.
*
* @returns Program exit code.
*
* @param cArgs The number of arguments.
* @param papszArgs The argument vector. (Note that this may be
* reordered, so the memory must be writable.)
*/
RTEXITCODE RTZipGzipCmd(unsigned cArgs, char **papszArgs)
{
/*
* Parse the command line.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--ascii", 'a', RTGETOPT_REQ_NOTHING },
{ "--stdout", 'c', RTGETOPT_REQ_NOTHING },
{ "--to-stdout", 'c', RTGETOPT_REQ_NOTHING },
{ "--decompress", 'd', RTGETOPT_REQ_NOTHING },
{ "--uncompress", 'd', RTGETOPT_REQ_NOTHING },
{ "--force", 'f', RTGETOPT_REQ_NOTHING },
{ "--keep", 'k', RTGETOPT_REQ_NOTHING },
{ "--list", 'l', RTGETOPT_REQ_NOTHING },
{ "--no-name", 'n', RTGETOPT_REQ_NOTHING },
{ "--name", 'N', RTGETOPT_REQ_NOTHING },
{ "--quiet", 'q', RTGETOPT_REQ_NOTHING },
{ "--recursive", 'r', RTGETOPT_REQ_NOTHING },
{ "--suffix", 'S', RTGETOPT_REQ_STRING },
{ "--test", 't', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
{ "--fast", '1', RTGETOPT_REQ_NOTHING },
{ "-1", '1', RTGETOPT_REQ_NOTHING },
{ "-2", '2', RTGETOPT_REQ_NOTHING },
{ "-3", '3', RTGETOPT_REQ_NOTHING },
{ "-4", '4', RTGETOPT_REQ_NOTHING },
{ "-5", '5', RTGETOPT_REQ_NOTHING },
{ "-6", '6', RTGETOPT_REQ_NOTHING },
{ "-7", '7', RTGETOPT_REQ_NOTHING },
{ "-8", '8', RTGETOPT_REQ_NOTHING },
{ "-9", '9', RTGETOPT_REQ_NOTHING },
{ "--best", '9', RTGETOPT_REQ_NOTHING }
};
RTGZIPCMDOPTS Opts;
Opts.fAscii = false;
Opts.fStdOut = false;
Opts.fDecompress = false;
Opts.fForce = false;
Opts.fKeep = false;
Opts.fList = false;
Opts.fName = true;
Opts.fQuiet = false;
Opts.fRecursive = false;
Opts.pszSuff = ".gz";
Opts.fTest = false;
Opts.uLevel = 6;
RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
unsigned cProcessed = 0;
RTVFSIOSTREAM hVfsStdOut= NIL_RTVFSIOSTREAM;
RTGETOPTSTATE GetState;
int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1,
RTGETOPTINIT_FLAGS_OPTS_FIRST);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "RTGetOptInit: %Rrc", rc);
for (;;)
{
RTGETOPTUNION ValueUnion;
int chOpt = RTGetOpt(&GetState, &ValueUnion);
switch (chOpt)
{
case 0:
/*
* If we've processed any files we're done. Otherwise take
* input from stdin and write the output to stdout.
*/
if (cProcessed > 0)
return rcExit;
ValueUnion.psz = "-";
Opts.fStdOut = true;
/* Fall thru. */
case VINF_GETOPT_NOT_OPTION:
{
if (!*Opts.pszSuff && !Opts.fStdOut)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --suffix option specified an empty string");
if (!Opts.fStdOut && RTVfsChainIsSpec(ValueUnion.psz))
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Must use standard out with VFS chain specifications");
if (Opts.fName)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --name option has not yet been implemented. Use --no-name.");
if (Opts.fAscii)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --ascii option has not yet been implemented.");
if (Opts.fRecursive)
return RTMsgErrorExit(RTEXITCODE_SYNTAX, "The --recursive option has not yet been implemented.");
/* Open the input file. */
RTVFSIOSTREAM hVfsSrc;
RTEXITCODE rcExit2 = gzipOpenInput(ValueUnion.psz, &Opts, &hVfsSrc);
if (rcExit2 == RTEXITCODE_SUCCESS)
{
if (Opts.fList)
rcExit2 = gzipListFile(&hVfsSrc, &Opts);
else if (Opts.fTest)
rcExit2 = gzipTestFile(&hVfsSrc, &Opts);
else
{
RTVFSIOSTREAM hVfsDst;
rcExit2 = gzipOpenOutput(ValueUnion.psz, &Opts, &hVfsDst);
if (rcExit2 == RTEXITCODE_SUCCESS)
{
if (Opts.fDecompress)
rcExit2 = gzipDecompressFile(&hVfsSrc, &Opts, &hVfsDst);
else
rcExit2 = gzipCompressFile(&hVfsSrc, &Opts, &hVfsDst);
RTVfsIoStrmRelease(hVfsDst);
}
}
RTVfsIoStrmRelease(hVfsSrc);
}
if (rcExit2 != RTEXITCODE_SUCCESS)
rcExit = rcExit2;
cProcessed++;
break;
}
case 'a': Opts.fAscii = true; break;
case 'c':
Opts.fStdOut = true;
Opts.fKeep = true;
break;
case 'd': Opts.fDecompress = true; break;
case 'f': Opts.fForce = true; break;
case 'k': Opts.fKeep = true; break;
case 'l': Opts.fList = true; break;
case 'n': Opts.fName = false; break;
case 'N': Opts.fName = true; break;
case 'q': Opts.fQuiet = true; break;
case 'r': Opts.fRecursive = true; break;
case 'S': Opts.pszSuff = ValueUnion.psz; break;
case 't': Opts.fTest = true; break;
case 'v': Opts.fQuiet = false; break;
case '1': Opts.uLevel = 1; break;
case '2': Opts.uLevel = 2; break;
case '3': Opts.uLevel = 3; break;
case '4': Opts.uLevel = 4; break;
case '5': Opts.uLevel = 5; break;
case '6': Opts.uLevel = 6; break;
case '7': Opts.uLevel = 7; break;
case '8': Opts.uLevel = 8; break;
case '9': Opts.uLevel = 9; break;
case 'h':
RTPrintf("Usage: to be written\nOption dump:\n");
for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++)
RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong);
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision());
return RTEXITCODE_SUCCESS;
default:
return RTGetOptPrintError(chOpt, &ValueUnion);
}
}
}
/**
* Parse the arguments.
*
* @returns 0 on success, fully bitched exit code on failure.
*
* @param argc Argument count.
* @param argv Argument vector.
*/
int VBoxNetBaseService::parseArgs(int argc, char **argv)
{
RTGETOPTSTATE State;
PRTGETOPTDEF paOptionArray = getOptionsPtr();
int rc = RTGetOptInit(&State, argc, argv, paOptionArray, m_vecOptionDefs.size(), 0, 0 /*fFlags*/);
AssertRCReturn(rc, 49);
#if 0
/* default initialization */
m_enmTrunkType = kIntNetTrunkType_WhateverNone;
#endif
Log2(("BaseService: parseArgs enter\n"));
for (;;)
{
RTGETOPTUNION Val;
rc = RTGetOpt(&State, &Val);
if (!rc)
break;
switch (rc)
{
case 'N':
m_Name = Val.psz;
break;
case 'n':
m_Network = Val.psz;
break;
case 't':
m_TrunkName = Val.psz;
break;
case 'T':
if (!strcmp(Val.psz, "none"))
m_enmTrunkType = kIntNetTrunkType_None;
else if (!strcmp(Val.psz, "whatever"))
m_enmTrunkType = kIntNetTrunkType_WhateverNone;
else if (!strcmp(Val.psz, "netflt"))
m_enmTrunkType = kIntNetTrunkType_NetFlt;
else if (!strcmp(Val.psz, "netadp"))
m_enmTrunkType = kIntNetTrunkType_NetAdp;
else if (!strcmp(Val.psz, "srvnat"))
m_enmTrunkType = kIntNetTrunkType_SrvNat;
else
{
RTStrmPrintf(g_pStdErr, "Invalid trunk type '%s'\n", Val.psz);
return 1;
}
break;
case 'a':
m_MacAddress = Val.MacAddr;
break;
case 'i':
m_Ipv4Address = Val.IPv4Addr;
break;
case 'm':
m_Ipv4Netmask = Val.IPv4Addr;
break;
case 'v':
m_cVerbosity++;
break;
case 'V':
RTPrintf("%sr%u\n", RTBldCfgVersion(), RTBldCfgRevision());
return 1;
case 'h':
RTPrintf("VBoxNetDHCP Version %s\n"
"(C) 2009-" VBOX_C_YEAR " " VBOX_VENDOR "\n"
"All rights reserved.\n"
"\n"
"Usage: VBoxNetDHCP <options>\n"
"\n"
"Options:\n",
RTBldCfgVersion());
for (unsigned int i = 0; i < m_vecOptionDefs.size(); i++)
RTPrintf(" -%c, %s\n", m_vecOptionDefs[i]->iShort, m_vecOptionDefs[i]->pszLong);
usage(); /* to print Service Specific usage */
return 1;
default:
int rc1 = parseOpt(rc, Val);
if (RT_FAILURE(rc1))
{
rc = RTGetOptPrintError(rc, &Val);
RTPrintf("Use --help for more information.\n");
return rc;
}
}
}
RTMemFree(paOptionArray);
return rc;
}
