/**
* Calculates the decoded string length.
*
* @returns Number of chars (excluding the terminator).
* @param pszString The string to decode.
* @param cchMax The maximum string length (e.g. RTSTR_MAX).
*/
static size_t rtUriCalcDecodedLength(const char *pszString, size_t cchMax)
{
size_t cchDecoded;
if (pszString)
{
size_t cchSrcLeft = cchDecoded = RTStrNLen(pszString, cchMax);
while (cchSrcLeft-- > 0)
{
char const ch = *pszString++;
if (ch != '%')
{ /* typical */}
else if ( cchSrcLeft >= 2
&& RT_C_IS_XDIGIT(pszString[0])
&& RT_C_IS_XDIGIT(pszString[1]))
{
cchDecoded -= 2;
pszString += 2;
cchSrcLeft -= 2;
}
}
}
else
cchDecoded = 0;
return cchDecoded;
}
static void testDisas(const char *pszSub, uint8_t const *pabInstrs, uintptr_t uEndPtr, DISCPUMODE enmDisCpuMode)
{
RTTestISub(pszSub);
size_t const cbInstrs = uEndPtr - (uintptr_t)pabInstrs;
for (size_t off = 0; off < cbInstrs;)
{
uint32_t const cErrBefore = RTTestIErrorCount();
uint32_t cb = 1;
DISSTATE Dis;
char szOutput[256] = {0};
int rc = DISInstrToStr(&pabInstrs[off], enmDisCpuMode, &Dis, &cb, szOutput, sizeof(szOutput));
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
RTTESTI_CHECK(cb == Dis.cbInstr);
RTTESTI_CHECK(cb > 0);
RTTESTI_CHECK(cb <= 16);
RTStrStripR(szOutput);
RTTESTI_CHECK(szOutput[0]);
if (szOutput[0])
{
char *pszBytes = strchr(szOutput, '[');
RTTESTI_CHECK(pszBytes);
if (pszBytes)
{
RTTESTI_CHECK(pszBytes[-1] == ' ');
RTTESTI_CHECK(RT_C_IS_XDIGIT(pszBytes[1]));
RTTESTI_CHECK(pszBytes[cb * 3] == ']');
RTTESTI_CHECK(pszBytes[cb * 3 + 1] == ' ');
size_t cch = strlen(szOutput);
RTTESTI_CHECK(szOutput[cch - 1] != ',');
}
}
if (cErrBefore != RTTestIErrorCount())
RTTestIFailureDetails("rc=%Rrc, off=%#x (%u) cbInstr=%u enmDisCpuMode=%d\n",
rc, off, Dis.cbInstr, enmDisCpuMode);
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s\n", szOutput);
/* Check with size-only. */
uint32_t cbOnly = 1;
DISSTATE DisOnly;
rc = DISInstrWithPrefetchedBytes((uintptr_t)&pabInstrs[off], enmDisCpuMode, 0 /*fFilter - none */,
Dis.abInstr, Dis.cbCachedInstr, NULL, NULL, &DisOnly, &cbOnly);
RTTESTI_CHECK_RC(rc, VINF_SUCCESS);
RTTESTI_CHECK(cbOnly == DisOnly.cbInstr);
RTTESTI_CHECK_MSG(cbOnly == cb, ("%#x vs %#x\n", cbOnly, cb));
off += cb;
}
}
/**
* For converting the decomposition mappings field and similar.
*
* @returns Mapping array or NULL if none.
* @param psz The string to convert. Can be empty.
* @param pcEntries Where to store the number of entries.
* @param cMax The max number of entries.
*/
static PRTUNICP ToMapping(char *psz, unsigned *pcEntries, unsigned cMax)
{
PRTUNICP paCps = NULL;
unsigned cAlloc = 0;
unsigned i = 0;
/* Convert the code points. */
while (psz)
{
/* skip leading spaces */
while (RT_C_IS_BLANK(*psz))
psz++;
/* the end? */
if (!*psz)
break;
/* room left? */
if (i >= cMax)
{
ParseError("Too many mappings.\n");
break;
}
if (i >= cAlloc)
{
cAlloc += 4;
paCps = (PRTUNICP)realloc(paCps, cAlloc * sizeof(paCps[0]));
if (!paCps)
{
fprintf(stderr, "out of memory (%u)\n", (unsigned)(cAlloc * sizeof(paCps[0])));
exit(1);
}
}
/* Find the end. */
char *pszThis = psz;
while (RT_C_IS_XDIGIT(*psz))
psz++;
if (*psz && !RT_C_IS_BLANK(*psz))
ParseError("Malformed mappings.\n");
if (*psz)
*psz++ = '\0';
/* Convert to number and add it. */
paCps[i++] = ToNum(pszThis);
}
*pcEntries = i;
return paCps;
}
static void test3(void)
{
RTTestISub("> 127");
for (int ch = 128; ch < 2000000; ch++)
{
RTTESTI_CHECK(!RT_C_IS_CNTRL(ch));
RTTESTI_CHECK(!RT_C_IS_SPACE(ch));
RTTESTI_CHECK(!RT_C_IS_BLANK(ch));
RTTESTI_CHECK(!RT_C_IS_PRINT(ch));
RTTESTI_CHECK(!RT_C_IS_PUNCT(ch));
RTTESTI_CHECK(!RT_C_IS_GRAPH(ch));
RTTESTI_CHECK(!RT_C_IS_DIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_XDIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_ODIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_ALPHA(ch));
RTTESTI_CHECK(!RT_C_IS_UPPER(ch));
RTTESTI_CHECK(!RT_C_IS_LOWER(ch));
}
}
static void test2(void)
{
RTTestISub("< 0");
for (int ch = -1; ch > -2000000; ch--)
{
RTTESTI_CHECK(!RT_C_IS_CNTRL(ch));
RTTESTI_CHECK(!RT_C_IS_SPACE(ch));
RTTESTI_CHECK(!RT_C_IS_BLANK(ch));
RTTESTI_CHECK(!RT_C_IS_PRINT(ch));
RTTESTI_CHECK(!RT_C_IS_PUNCT(ch));
RTTESTI_CHECK(!RT_C_IS_GRAPH(ch));
RTTESTI_CHECK(!RT_C_IS_DIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_XDIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_ODIGIT(ch));
RTTESTI_CHECK(!RT_C_IS_ALPHA(ch));
RTTESTI_CHECK(!RT_C_IS_UPPER(ch));
RTTESTI_CHECK(!RT_C_IS_LOWER(ch));
}
}
/**
* Tries to parse out an address at the head of the string.
*
* @returns true if found address, false if not.
* @param psz Where to start parsing.
* @param pcchAddress Where to store the address length.
* @param pu64Address Where to store the address value.
*/
static bool TryParseAddress(const char *psz, size_t *pcchAddress, uint64_t *pu64Address)
{
const char *pszStart = psz;
/*
* Hex prefix?
*/
if (psz[0] == '0' && (psz[1] == 'x' || psz[1] == 'X'))
psz += 2;
/*
* How many hex digits? We want at least 4 and at most 16.
*/
size_t off = 0;
while (RT_C_IS_XDIGIT(psz[off]))
off++;
if (off < 4 || off > 16)
return false;
/*
* Check for separator (xxxxxxxx'yyyyyyyy).
*/
bool fHave64bitSep = off <= 8
&& psz[off] == '\''
&& RT_C_IS_XDIGIT(psz[off + 1])
&& RT_C_IS_XDIGIT(psz[off + 2])
&& RT_C_IS_XDIGIT(psz[off + 3])
&& RT_C_IS_XDIGIT(psz[off + 4])
&& RT_C_IS_XDIGIT(psz[off + 5])
&& RT_C_IS_XDIGIT(psz[off + 6])
&& RT_C_IS_XDIGIT(psz[off + 7])
&& RT_C_IS_XDIGIT(psz[off + 8])
&& !RT_C_IS_XDIGIT(psz[off + 9]);
if (fHave64bitSep)
{
uint32_t u32High;
int rc = RTStrToUInt32Ex(psz, NULL, 16, &u32High);
if (rc != VWRN_TRAILING_CHARS)
return false;
uint32_t u32Low;
rc = RTStrToUInt32Ex(&psz[off + 1], NULL, 16, &u32Low);
if ( rc != VINF_SUCCESS
&& rc != VWRN_TRAILING_SPACES
&& rc != VWRN_TRAILING_CHARS)
return false;
*pu64Address = RT_MAKE_U64(u32Low, u32High);
off += 1 + 8;
}
else
{
int rc = RTStrToUInt64Ex(psz, NULL, 16, pu64Address);
if ( rc != VINF_SUCCESS
&& rc != VWRN_TRAILING_SPACES
&& rc != VWRN_TRAILING_CHARS)
return false;
}
*pcchAddress = psz + off - pszStart;
return true;
}
int main(int argc, char **argv)
{
int rc = RTR3InitExe(argc, &argv, 0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Create an empty address space that we can load modules and stuff into
* as we parse the parameters.
*/
RTDBGAS hDbgAs;
rc = RTDbgAsCreate(&hDbgAs, 0, RTUINTPTR_MAX, "");
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDBgAsCreate -> %Rrc", rc);
/*
* Create a debugging configuration instance to work with so that we can
* make use of (i.e. test) path searching and such.
*/
RTDBGCFG hDbgCfg;
rc = RTDbgCfgCreate(&hDbgCfg, "IPRT", true /*fNativePaths*/);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgCfgCreate -> %Rrc", rc);
/*
* Parse arguments.
*/
static const RTGETOPTDEF s_aOptions[] =
{
{ "--input", 'i', RTGETOPT_REQ_STRING },
{ "--local-file", 'l', RTGETOPT_REQ_NOTHING },
{ "--cache-file", 'c', RTGETOPT_REQ_NOTHING },
{ "--pe-image", 'p', RTGETOPT_REQ_NOTHING },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
{ "--x86", '8', RTGETOPT_REQ_NOTHING },
{ "--amd64", '6', RTGETOPT_REQ_NOTHING },
{ "--whatever", '*', RTGETOPT_REQ_NOTHING },
};
PRTSTREAM pInput = g_pStdIn;
PRTSTREAM pOutput = g_pStdOut;
unsigned cVerbosityLevel = 0;
enum {
kOpenMethod_FromImage,
kOpenMethod_FromPeImage
} enmOpenMethod = kOpenMethod_FromImage;
bool fCacheFile = false;
RTLDRARCH enmArch = RTLDRARCH_WHATEVER;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, 0);
while ((rc = RTGetOpt(&GetState, &ValueUnion)))
{
switch (rc)
{
case 'i':
rc = RTStrmOpen(ValueUnion.psz, "r", &pInput);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to open '%s' for reading: %Rrc", ValueUnion.psz, rc);
break;
case 'c':
fCacheFile = true;
break;
case 'l':
fCacheFile = false;
break;
case 'p':
enmOpenMethod = kOpenMethod_FromPeImage;
break;
case 'v':
cVerbosityLevel++;
break;
case '8':
enmArch = RTLDRARCH_X86_32;
break;
case '6':
enmArch = RTLDRARCH_AMD64;
break;
case '*':
enmArch = RTLDRARCH_WHATEVER;
break;
case 'h':
RTPrintf("Usage: %s [options] <module> <address> [<module> <address> [..]]\n"
"\n"
"Options:\n"
" -i,--input=file\n"
" Specify a input file instead of standard input.\n"
" --pe-image\n"
" Use RTDbgModCreateFromPeImage to open the file."
" -v, --verbose\n"
" Display the address space before doing the filtering.\n"
" --amd64,--x86,--whatever\n"
" Selects the desired architecture.\n"
" -h, -?, --help\n"
" Display this help text and exit successfully.\n"
" -V, --version\n"
" Display the revision and exit successfully.\n"
, RTPathFilename(argv[0]));
return RTEXITCODE_SUCCESS;
case 'V':
RTPrintf("$Revision$\n");
return RTEXITCODE_SUCCESS;
case VINF_GETOPT_NOT_OPTION:
{
/* <module> <address> */
const char *pszModule = ValueUnion.psz;
rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_UINT64 | RTGETOPT_FLAG_HEX);
if (RT_FAILURE(rc))
return RTGetOptPrintError(rc, &ValueUnion);
uint64_t u64Address = ValueUnion.u64;
uint32_t cbImage = 0;
uint32_t uTimestamp = 0;
if (fCacheFile)
{
rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
if (RT_FAILURE(rc))
return RTGetOptPrintError(rc, &ValueUnion);
cbImage = ValueUnion.u32;
rc = RTGetOptFetchValue(&GetState, &ValueUnion, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_HEX);
if (RT_FAILURE(rc))
return RTGetOptPrintError(rc, &ValueUnion);
uTimestamp = ValueUnion.u32;
}
RTDBGMOD hMod;
if (enmOpenMethod == kOpenMethod_FromImage)
rc = RTDbgModCreateFromImage(&hMod, pszModule, NULL, enmArch, hDbgCfg);
else
rc = RTDbgModCreateFromPeImage(&hMod, pszModule, NULL, NIL_RTLDRMOD, cbImage, uTimestamp, hDbgCfg);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgModCreateFromImage(,%s,,) -> %Rrc", pszModule, rc);
rc = RTDbgAsModuleLink(hDbgAs, hMod, u64Address, 0 /* fFlags */);
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTDbgAsModuleLink(,%s,%llx,) -> %Rrc", pszModule, u64Address, rc);
break;
}
default:
return RTGetOptPrintError(rc, &ValueUnion);
}
}
/*
* Display the address space.
*/
if (cVerbosityLevel)
{
RTPrintf("*** Address Space Dump ***\n");
uint32_t cModules = RTDbgAsModuleCount(hDbgAs);
for (uint32_t iModule = 0; iModule < cModules; iModule++)
{
RTDBGMOD hDbgMod = RTDbgAsModuleByIndex(hDbgAs, iModule);
RTPrintf("Module #%u: %s\n", iModule, RTDbgModName(hDbgMod));
RTDBGASMAPINFO aMappings[128];
uint32_t cMappings = RT_ELEMENTS(aMappings);
rc = RTDbgAsModuleQueryMapByIndex(hDbgAs, iModule, &aMappings[0], &cMappings, 0 /*fFlags*/);
if (RT_SUCCESS(rc))
{
for (uint32_t iMapping = 0; iMapping < cMappings; iMapping++)
{
if (aMappings[iMapping].iSeg == NIL_RTDBGSEGIDX)
RTPrintf(" mapping #%u: %RTptr-%RTptr\n",
iMapping,
aMappings[iMapping].Address,
aMappings[iMapping].Address + RTDbgModImageSize(hDbgMod) - 1);
else
{
RTDBGSEGMENT SegInfo;
rc = RTDbgModSegmentByIndex(hDbgMod, aMappings[iMapping].iSeg, &SegInfo);
if (RT_SUCCESS(rc))
RTPrintf(" mapping #%u: %RTptr-%RTptr (segment #%u - '%s')",
iMapping,
aMappings[iMapping].Address,
aMappings[iMapping].Address + SegInfo.cb,
SegInfo.iSeg, SegInfo.szName);
else
RTPrintf(" mapping #%u: %RTptr-???????? (segment #%u)", iMapping, aMappings[iMapping].Address);
}
if (cVerbosityLevel > 1)
{
uint32_t cSymbols = RTDbgModSymbolCount(hDbgMod);
RTPrintf(" %u symbols\n", cSymbols);
for (uint32_t iSymbol = 0; iSymbol < cSymbols; iSymbol++)
{
RTDBGSYMBOL SymInfo;
rc = RTDbgModSymbolByOrdinal(hDbgMod, iSymbol, &SymInfo);
if (RT_SUCCESS(rc))
RTPrintf(" #%04u at %08x:%RTptr %05llx %s\n",
SymInfo.iOrdinal, SymInfo.iSeg, SymInfo.offSeg,
(uint64_t)SymInfo.cb, SymInfo.szName);
}
}
}
}
else
RTMsgError("RTDbgAsModuleQueryMapByIndex failed: %Rrc", rc);
RTDbgModRelease(hDbgMod);
}
RTPrintf("*** End of Address Space Dump ***\n");
}
/*
* Read text from standard input and see if there is anything we can translate.
*/
for (;;)
{
/* Get a line. */
char szLine[_64K];
rc = RTStrmGetLine(pInput, szLine, sizeof(szLine));
if (rc == VERR_EOF)
break;
if (RT_FAILURE(rc))
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrmGetLine() -> %Rrc\n", rc);
/*
* Search the line for potential addresses and replace them with
* symbols+offset.
*/
const char *pszStart = szLine;
const char *psz = szLine;
char ch;
while ((ch = *psz) != '\0')
{
size_t cchAddress;
uint64_t u64Address;
if ( ( ch == '0'
&& (psz[1] == 'x' || psz[1] == 'X')
&& TryParseAddress(psz, &cchAddress, &u64Address))
|| ( RT_C_IS_XDIGIT(ch)
&& TryParseAddress(psz, &cchAddress, &u64Address))
)
{
/* Print. */
psz += cchAddress;
if (pszStart != psz)
RTStrmWrite(pOutput, pszStart, psz - pszStart);
pszStart = psz;
/* Try get the module. */
RTUINTPTR uAddr;
RTDBGSEGIDX iSeg;
RTDBGMOD hDbgMod;
rc = RTDbgAsModuleByAddr(hDbgAs, u64Address, &hDbgMod, &uAddr, &iSeg);
if (RT_SUCCESS(rc))
{
if (iSeg != UINT32_MAX)
RTStrmPrintf(pOutput, "=[%s:%u", RTDbgModName(hDbgMod), iSeg);
else
RTStrmPrintf(pOutput, "=[%s", RTDbgModName(hDbgMod), iSeg);
/*
* Do we have symbols?
*/
RTDBGSYMBOL Symbol;
RTINTPTR offSym;
rc = RTDbgAsSymbolByAddr(hDbgAs, u64Address, RTDBGSYMADDR_FLAGS_LESS_OR_EQUAL, &offSym, &Symbol, NULL);
if (RT_SUCCESS(rc))
{
if (!offSym)
RTStrmPrintf(pOutput, "!%s", Symbol.szName);
else if (offSym > 0)
RTStrmPrintf(pOutput, "!%s+%#llx", Symbol.szName, offSym);
else
RTStrmPrintf(pOutput, "!%s-%#llx", Symbol.szName, -offSym);
}
else
RTStrmPrintf(pOutput, "+%#llx", u64Address - uAddr);
/*
* Do we have line numbers?
*/
RTDBGLINE Line;
RTINTPTR offLine;
rc = RTDbgAsLineByAddr(hDbgAs, u64Address, &offLine, &Line, NULL);
if (RT_SUCCESS(rc))
RTStrmPrintf(pOutput, " %Rbn(%u)", Line.szFilename, Line.uLineNo);
RTStrmPrintf(pOutput, "]");
RTDbgModRelease(hDbgMod);
}
}
else
psz++;
}
if (pszStart != psz)
RTStrmWrite(pOutput, pszStart, psz - pszStart);
RTStrmPutCh(pOutput, '\n');
}
return RTEXITCODE_SUCCESS;
}
RTDECL(int) RTManifestReadStandardEx(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos, char *pszErr, size_t cbErr)
{
/*
* Validate input.
*/
AssertPtrNull(pszErr);
if (pszErr && cbErr)
*pszErr = '\0';
RTMANIFESTINT *pThis = hManifest;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, VERR_INVALID_HANDLE);
/*
* Process the stream line by line.
*/
uint32_t iLine = 0;
for (;;)
{
/*
* Read a line from the input stream.
*/
iLine++;
char szLine[RTPATH_MAX + RTSHA512_DIGEST_LEN + 32];
int rc = rtManifestReadLine(hVfsIos, szLine, sizeof(szLine));
if (RT_FAILURE(rc))
{
if (rc == VERR_EOF)
return VINF_SUCCESS;
RTStrPrintf(pszErr, cbErr, "Error reading line #%u: %Rrc", iLine, rc);
return rc;
}
if (rc != VINF_SUCCESS)
{
RTStrPrintf(pszErr, cbErr, "Line number %u is too long", iLine);
return VERR_OUT_OF_RANGE;
}
/*
* Strip it and skip if empty.
*/
char *psz = RTStrStrip(szLine);
if (!*psz)
continue;
/*
* Read the attribute name.
*/
const char * const pszAttr = psz;
do
psz++;
while (!RT_C_IS_BLANK(*psz) && *psz);
if (*psz)
*psz++ = '\0';
/*
* The entry name is enclosed in parenthesis and followed by a '='.
*/
psz = RTStrStripL(psz);
if (*psz != '(')
{
RTStrPrintf(pszErr, cbErr, "Expected '(' after %zu on line %u", psz - szLine, iLine);
return VERR_PARSE_ERROR;
}
const char * const pszName = ++psz;
while (*psz)
{
if (*psz == ')')
{
char *psz2 = RTStrStripL(psz + 1);
if (*psz2 == '=')
{
*psz = '\0';
psz = psz2;
break;
}
}
psz++;
}
if (*psz != '=')
{
RTStrPrintf(pszErr, cbErr, "Expected ')=' at %zu on line %u", psz - szLine, iLine);
return VERR_PARSE_ERROR;
}
/*
* The value.
*/
psz = RTStrStrip(psz + 1);
const char * const pszValue = psz;
if (!*psz)
{
RTStrPrintf(pszErr, cbErr, "Expected value at %zu on line %u", psz - szLine, iLine);
return VERR_PARSE_ERROR;
}
/*
* Detect attribute type and sanity check the value.
*/
uint32_t fType = RTMANIFEST_ATTR_UNKNOWN;
static const struct
{
const char *pszAttr;
uint32_t fType;
unsigned cBits;
unsigned uBase;
} s_aDecAttrs[] =
{
{ "SIZE", RTMANIFEST_ATTR_SIZE, 64, 10}
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aDecAttrs); i++)
if (!strcmp(s_aDecAttrs[i].pszAttr, pszAttr))
{
fType = s_aDecAttrs[i].fType;
rc = RTStrToUInt64Full(pszValue, s_aDecAttrs[i].uBase, NULL);
if (rc != VINF_SUCCESS)
{
RTStrPrintf(pszErr, cbErr, "Malformed value ('%s') at %zu on line %u: %Rrc", pszValue, psz - szLine, iLine, rc);
return VERR_PARSE_ERROR;
}
break;
}
if (fType == RTMANIFEST_ATTR_UNKNOWN)
{
static const struct
{
const char *pszAttr;
uint32_t fType;
unsigned cchHex;
} s_aHexAttrs[] =
{
{ "MD5", RTMANIFEST_ATTR_MD5, RTMD5_DIGEST_LEN },
{ "SHA1", RTMANIFEST_ATTR_SHA1, RTSHA1_DIGEST_LEN },
{ "SHA256", RTMANIFEST_ATTR_SHA256, RTSHA256_DIGEST_LEN },
{ "SHA512", RTMANIFEST_ATTR_SHA512, RTSHA512_DIGEST_LEN }
};
for (unsigned i = 0; i < RT_ELEMENTS(s_aHexAttrs); i++)
if (!strcmp(s_aHexAttrs[i].pszAttr, pszAttr))
{
fType = s_aHexAttrs[i].fType;
for (unsigned off = 0; off < s_aHexAttrs[i].cchHex; off++)
if (!RT_C_IS_XDIGIT(pszValue[off]))
{
RTStrPrintf(pszErr, cbErr, "Expected hex digit at %zu on line %u (value '%s', pos %u)",
pszValue - szLine + off, iLine, pszValue, off);
return VERR_PARSE_ERROR;
}
break;
}
}
/*
* Finally, add it.
*/
rc = RTManifestEntrySetAttr(hManifest, pszName, pszAttr, pszValue, fType);
if (RT_FAILURE(rc))
{
RTStrPrintf(pszErr, cbErr, "RTManifestEntrySetAttr(,'%s','%s', '%s', %#x) failed on line %u: %Rrc",
pszName, pszAttr, pszValue, fType, iLine, rc);
return rc;
}
}
}
static int ParseUsbIds(PRTSTREAM pInStrm, const char *pszFile)
{
/*
* State data.
*/
VendorRecord vendor = { 0, 0, 0, "" };
/*
* Process the file line-by-line.
*
* The generic format is that we have top level entries (vendors) starting
* in position 0 with sub entries starting after one or more, depending on
* the level, tab characters.
*
* Specifically, the list of vendors and their products will always start
* with a vendor line followed by indented products. The first character
* on the vendor line is a hex digit (four in total) that makes up the
* vendor ID. The product lines equally starts with a 4 digit hex ID value.
*
* Other lists are assumed to have first lines that doesn't start with any
* lower case hex digit.
*/
uint32_t iLine = 0;;
for (;;)
{
char szLine[_4K];
int rc = RTStrmGetLine(pInStrm, szLine, sizeof(szLine));
if (RT_SUCCESS(rc))
{
iLine++;
/* Check for vendor line. */
char chType = szLine[0];
if ( RT_C_IS_XDIGIT(chType)
&& RT_C_IS_SPACE(szLine[4])
&& RT_C_IS_XDIGIT(szLine[1])
&& RT_C_IS_XDIGIT(szLine[2])
&& RT_C_IS_XDIGIT(szLine[3]) )
{
if (ParseAlias(szLine, vendor.vendorID, vendor.str) == 0)
g_vendors.push_back(vendor);
else
return RTMsgErrorExit((RTEXITCODE)ERROR_IN_PARSE_LINE,
"%s(%d): Error in parsing vendor line: '%s'", pszFile, iLine, szLine);
}
/* Check for product line. */
else if (szLine[0] == '\t' && vendor.vendorID != 0)
{
ProductRecord product = { 0, vendor.vendorID, 0, "" };
if (ParseAlias(&szLine[1], product.productID, product.str) == 0)
{
product.key = RT_MAKE_U32(product.productID, product.vendorID);
Assert(product.vendorID == vendor.vendorID);
g_products.push_back(product);
}
else
return RTMsgErrorExit((RTEXITCODE)ERROR_IN_PARSE_LINE, "Error in parsing product line: '%s'", szLine);
}
/* If not a blank or comment line, it is some other kind of data.
So, make sure the vendor ID is cleared so we don't try process
the sub-items of in some other list as products. */
else if ( chType != '#'
&& chType != '\0'
&& *RTStrStripL(szLine) != '\0')
vendor.vendorID = 0;
}
else if (rc == VERR_EOF)
return RTEXITCODE_SUCCESS;
else
return RTMsgErrorExit(RTEXITCODE_FAILURE, "RTStrmGetLine failed: %Rrc", rc);
}
}
static int rtUriParse(const char *pszUri, PRTURIPARSED pParsed)
{
/*
* Validate the input and clear the output.
*/
AssertPtrReturn(pParsed, VERR_INVALID_POINTER);
RT_ZERO(*pParsed);
pParsed->uAuthorityPort = UINT32_MAX;
AssertPtrReturn(pszUri, VERR_INVALID_POINTER);
size_t const cchUri = strlen(pszUri);
if (RT_LIKELY(cchUri >= 3)) { /* likely */ }
else return cchUri ? VERR_URI_TOO_SHORT : VERR_URI_EMPTY;
/*
* Validating escaped text sequences is much simpler if we know that
* that the base URI string is valid. Also, we don't necessarily trust
* the developer calling us to remember to do this.
*/
int rc = RTStrValidateEncoding(pszUri);
AssertRCReturn(rc, rc);
/*
* RFC-3986, section 3.1:
* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
*
* The scheme ends with a ':', which we also skip here.
*/
size_t off = 0;
char ch = pszUri[off++];
if (RT_LIKELY(RT_C_IS_ALPHA(ch))) { /* likely */ }
else return VERR_URI_INVALID_SCHEME;
for (;;)
{
ch = pszUri[off];
if (ch == ':')
break;
if (RT_LIKELY(RT_C_IS_ALNUM(ch) || ch == '.' || ch == '-' || ch == '+')) { /* likely */ }
else return VERR_URI_INVALID_SCHEME;
off++;
}
pParsed->cchScheme = off;
/* Require the scheme length to be at least two chars so we won't confuse
it with a path starting with a DOS drive letter specification. */
if (RT_LIKELY(off >= 2)) { /* likely */ }
else return VERR_URI_INVALID_SCHEME;
off++; /* (skip colon) */
/*
* Find the end of the path, we'll need this several times.
* Also, while we're potentially scanning the whole thing, check for '%'.
*/
size_t const offHash = RTStrOffCharOrTerm(&pszUri[off], '#') + off;
size_t const offQuestionMark = RTStrOffCharOrTerm(&pszUri[off], '?') + off;
if (memchr(pszUri, '%', cchUri) != NULL)
pParsed->fFlags |= RTURIPARSED_F_CONTAINS_ESCAPED_CHARS;
/*
* RFC-3986, section 3.2:
* The authority component is preceeded by a double slash ("//")...
*/
if ( pszUri[off] == '/'
&& pszUri[off + 1] == '/')
{
off += 2;
pParsed->offAuthority = pParsed->offAuthorityUsername = pParsed->offAuthorityPassword = pParsed->offAuthorityHost = off;
pParsed->fFlags |= RTURIPARSED_F_HAVE_AUTHORITY;
/*
* RFC-3986, section 3.2:
* ...and is terminated by the next slash ("/"), question mark ("?"),
* or number sign ("#") character, or by the end of the URI.
*/
const char *pszAuthority = &pszUri[off];
size_t cchAuthority = RTStrOffCharOrTerm(pszAuthority, '/');
cchAuthority = RT_MIN(cchAuthority, offHash - off);
cchAuthority = RT_MIN(cchAuthority, offQuestionMark - off);
pParsed->cchAuthority = cchAuthority;
/* The Authority can be empty, like for: file:///usr/bin/grep */
if (cchAuthority > 0)
{
pParsed->cchAuthorityHost = cchAuthority;
/*
* If there is a userinfo part, it is ended by a '@'.
*/
const char *pszAt = (const char *)memchr(pszAuthority, '@', cchAuthority);
if (pszAt)
{
size_t cchTmp = pszAt - pszAuthority;
pParsed->offAuthorityHost += cchTmp + 1;
pParsed->cchAuthorityHost -= cchTmp + 1;
/* If there is a password part, it's separated from the username with a colon. */
const char *pszColon = (const char *)memchr(pszAuthority, ':', cchTmp);
if (pszColon)
{
pParsed->cchAuthorityUsername = pszColon - pszAuthority;
pParsed->offAuthorityPassword = &pszColon[1] - pszUri;
pParsed->cchAuthorityPassword = pszAt - &pszColon[1];
}
else
{
pParsed->cchAuthorityUsername = cchTmp;
pParsed->offAuthorityPassword = off + cchTmp;
}
}
/*
* If there is a port part, its after the last colon in the host part.
*/
const char *pszColon = (const char *)memrchr(&pszUri[pParsed->offAuthorityHost], ':', pParsed->cchAuthorityHost);
if (pszColon)
{
size_t cchTmp = &pszUri[pParsed->offAuthorityHost + pParsed->cchAuthorityHost] - &pszColon[1];
pParsed->cchAuthorityHost -= cchTmp + 1;
pParsed->uAuthorityPort = 0;
while (cchTmp-- > 0)
{
ch = *++pszColon;
if ( RT_C_IS_DIGIT(ch)
&& pParsed->uAuthorityPort < UINT32_MAX / UINT32_C(10))
{
pParsed->uAuthorityPort *= 10;
pParsed->uAuthorityPort += ch - '0';
}
else
return VERR_URI_INVALID_PORT_NUMBER;
}
}
}
/* Skip past the authority. */
off += cchAuthority;
}
else
pParsed->offAuthority = pParsed->offAuthorityUsername = pParsed->offAuthorityPassword = pParsed->offAuthorityHost = off;
/*
* RFC-3986, section 3.3: Path
* The path is terminated by the first question mark ("?")
* or number sign ("#") character, or by the end of the URI.
*/
pParsed->offPath = off;
pParsed->cchPath = RT_MIN(offHash, offQuestionMark) - off;
off += pParsed->cchPath;
/*
* RFC-3986, section 3.4: Query
* The query component is indicated by the first question mark ("?")
* character and terminated by a number sign ("#") character or by the
* end of the URI.
*/
if ( off == offQuestionMark
&& off < cchUri)
{
Assert(pszUri[offQuestionMark] == '?');
pParsed->offQuery = ++off;
pParsed->cchQuery = offHash - off;
off = offHash;
}
else
{
Assert(!pszUri[offQuestionMark]);
pParsed->offQuery = off;
}
/*
* RFC-3986, section 3.5: Fragment
* A fragment identifier component is indicated by the presence of a
* number sign ("#") character and terminated by the end of the URI.
*/
if ( off == offHash
&& off < cchUri)
{
pParsed->offFragment = ++off;
pParsed->cchFragment = cchUri - off;
}
else
{
Assert(!pszUri[offHash]);
pParsed->offFragment = off;
}
/*
* If there are any escape sequences, validate them.
*
* This is reasonably simple as we already know that the string is valid UTF-8
* before they get decoded. Thus we only have to validate the escaped sequences.
*/
if (pParsed->fFlags & RTURIPARSED_F_CONTAINS_ESCAPED_CHARS)
{
const char *pchSrc = (const char *)memchr(pszUri, '%', cchUri);
AssertReturn(pchSrc, VERR_INTERNAL_ERROR);
do
{
char szUtf8Seq[8];
unsigned cchUtf8Seq = 0;
unsigned cchNeeded = 0;
size_t cchLeft = &pszUri[cchUri] - pchSrc;
do
{
if (cchLeft >= 3)
{
char chHigh = pchSrc[1];
char chLow = pchSrc[2];
if ( RT_C_IS_XDIGIT(chHigh)
&& RT_C_IS_XDIGIT(chLow))
{
uint8_t b = RT_C_IS_DIGIT(chHigh) ? chHigh - '0' : (chHigh & ~0x20) - 'A' + 10;
b <<= 4;
b |= RT_C_IS_DIGIT(chLow) ? chLow - '0' : (chLow & ~0x20) - 'A' + 10;
if (!(b & 0x80))
{
/* We don't want the string to be terminated prematurely. */
if (RT_LIKELY(b != 0)) { /* likely */ }
else return VERR_URI_ESCAPED_ZERO;
/* Check that we're not expecting more UTF-8 bytes. */
if (RT_LIKELY(cchNeeded == 0)) { /* likely */ }
else return VERR_URI_MISSING_UTF8_CONTINUATION_BYTE;
}
/* Are we waiting UTF-8 bytes? */
else if (cchNeeded > 0)
{
if (RT_LIKELY(!(b & 0x40))) { /* likely */ }
else return VERR_URI_INVALID_ESCAPED_UTF8_CONTINUATION_BYTE;
szUtf8Seq[cchUtf8Seq++] = (char)b;
if (--cchNeeded == 0)
{
szUtf8Seq[cchUtf8Seq] = '\0';
rc = RTStrValidateEncoding(szUtf8Seq);
if (RT_FAILURE(rc))
return VERR_URI_ESCAPED_CHARS_NOT_VALID_UTF8;
cchUtf8Seq = 0;
}
}
/* Start a new UTF-8 sequence. */
else
{
if ((b & 0xf8) == 0xf0)
cchNeeded = 3;
else if ((b & 0xf0) == 0xe0)
cchNeeded = 2;
else if ((b & 0xe0) == 0xc0)
cchNeeded = 1;
else
return VERR_URI_INVALID_ESCAPED_UTF8_LEAD_BYTE;
szUtf8Seq[0] = (char)b;
cchUtf8Seq = 1;
}
pchSrc += 3;
cchLeft -= 3;
}
else
return VERR_URI_INVALID_ESCAPE_SEQ;
}
else
return VERR_URI_INVALID_ESCAPE_SEQ;
} while (cchLeft > 0 && pchSrc[0] == '%');
/* Check that we're not expecting more UTF-8 bytes. */
if (RT_LIKELY(cchNeeded == 0)) { /* likely */ }
else return VERR_URI_MISSING_UTF8_CONTINUATION_BYTE;
/* next */
pchSrc = (const char *)memchr(pchSrc, '%', cchLeft);
} while (pchSrc);
}
pParsed->u32Magic = RTURIPARSED_MAGIC;
return VINF_SUCCESS;
}
/**
* Decodes a string into a buffer.
*
* @returns IPRT status code.
* @param pchSrc The source string.
* @param cchSrc The max number of bytes to decode in the source string.
* @param pszDst The destination buffer.
* @param cbDst The size of the buffer (including terminator).
*/
static int rtUriDecodeIntoBuffer(const char *pchSrc, size_t cchSrc, char *pszDst, size_t cbDst)
{
AssertPtrReturn(pchSrc, VERR_INVALID_POINTER);
AssertPtrReturn(pszDst, VERR_INVALID_POINTER);
/*
* Knowing that the pszString itself is valid UTF-8, we only have to
* validate the escape sequences.
*/
cchSrc = RTStrNLen(pchSrc, cchSrc);
while (cchSrc > 0)
{
const char *pchPct = (const char *)memchr(pchSrc, '%', cchSrc);
if (pchPct)
{
size_t cchBefore = pchPct - pchSrc;
AssertReturn(cchBefore + 1 < cbDst, VERR_BUFFER_OVERFLOW);
if (cchBefore)
{
memcpy(pszDst, pchSrc, cchBefore);
pszDst += cchBefore;
cbDst -= cchBefore;
pchSrc += cchBefore;
cchSrc -= cchBefore;
}
char chHigh, chLow;
if ( cchSrc >= 3
&& RT_C_IS_XDIGIT(chHigh = pchSrc[1])
&& RT_C_IS_XDIGIT(chLow = pchSrc[2]))
{
uint8_t b = RT_C_IS_DIGIT(chHigh) ? chHigh - '0' : (chHigh & ~0x20) - 'A' + 10;
b <<= 4;
b |= RT_C_IS_DIGIT(chLow) ? chLow - '0' : (chLow & ~0x20) - 'A' + 10;
*pszDst++ = (char)b;
pchSrc += 3;
cchSrc -= 3;
}
else
{
AssertFailed();
*pszDst++ = *pchSrc++;
cchSrc--;
}
cbDst -= 1;
}
else
{
AssertReturn(cchSrc < cbDst, VERR_BUFFER_OVERFLOW);
memcpy(pszDst, pchSrc, cchSrc);
pszDst += cchSrc;
cbDst -= cchSrc;
pchSrc += cchSrc;
cchSrc = 0;
break;
}
}
AssertReturn(cbDst > 0, VERR_BUFFER_OVERFLOW);
*pszDst = '\0';
return VINF_SUCCESS;
}
static char *rtUriPercentDecodeN(const char *pszString, size_t cchString)
{
AssertPtrReturn(pszString, NULL);
AssertReturn(memchr(pszString, '\0', cchString) == NULL, NULL);
/*
* The new string can only get smaller, so use the input length as a
* staring buffer size.
*/
char *pszDecoded = RTStrAlloc(cchString + 1);
if (pszDecoded)
{
/*
* Knowing that the pszString itself is valid UTF-8, we only have to
* validate the escape sequences.
*/
size_t cchLeft = cchString;
char const *pchSrc = pszString;
char *pchDst = pszDecoded;
while (cchLeft > 0)
{
const char *pchPct = (const char *)memchr(pchSrc, '%', cchLeft);
if (pchPct)
{
size_t cchBefore = pchPct - pchSrc;
if (cchBefore)
{
memcpy(pchDst, pchSrc, cchBefore);
pchDst += cchBefore;
pchSrc += cchBefore;
cchLeft -= cchBefore;
}
char chHigh, chLow;
if ( cchLeft >= 3
&& RT_C_IS_XDIGIT(chHigh = pchSrc[1])
&& RT_C_IS_XDIGIT(chLow = pchSrc[2]))
{
uint8_t b = RT_C_IS_DIGIT(chHigh) ? chHigh - '0' : (chHigh & ~0x20) - 'A' + 10;
b <<= 4;
b |= RT_C_IS_DIGIT(chLow) ? chLow - '0' : (chLow & ~0x20) - 'A' + 10;
*pchDst++ = (char)b;
pchSrc += 3;
cchLeft -= 3;
}
else
{
AssertFailed();
*pchDst++ = *pchSrc++;
cchLeft--;
}
}
else
{
memcpy(pchDst, pchSrc, cchLeft);
pchDst += cchLeft;
pchSrc += cchLeft;
cchLeft = 0;
break;
}
}
*pchDst = '\0';
/*
* If we've got lof space room in the result string, reallocate it.
*/
size_t cchDecoded = pchDst - pszDecoded;
Assert(cchDecoded <= cchString);
if (cchString - cchDecoded > 64)
RTStrRealloc(&pszDecoded, cchDecoded + 1);
}
return pszDecoded;
}
/**
* Probe the type of a symbol information file.
*
* @returns The file type.
* @param pFile File handle.
*/
SYMFILETYPE dbgfR3ModuleProbe(FILE *pFile)
{
char szHead[4096];
size_t cchHead = fread(szHead, 1, sizeof(szHead) - 1, pFile);
if (cchHead > 0)
{
szHead[cchHead] = '\0';
if (strstr(szHead, "Preferred load address is"))
return SYMFILETYPE_MS_MAP;
if ( strstr(szHead, "Archive member included because of")
|| strstr(szHead, "Memory Configuration")
|| strstr(szHead, "Linker script and memory map"))
return SYMFILETYPE_LD_MAP;
if ( RT_C_IS_XDIGIT(szHead[0])
&& RT_C_IS_XDIGIT(szHead[1])
&& RT_C_IS_XDIGIT(szHead[2])
&& RT_C_IS_XDIGIT(szHead[3])
&& RT_C_IS_XDIGIT(szHead[4])
&& RT_C_IS_XDIGIT(szHead[5])
&& RT_C_IS_XDIGIT(szHead[6])
&& RT_C_IS_XDIGIT(szHead[7])
&& szHead[8] == ' '
&& RT_C_IS_ALPHA(szHead[9])
&& szHead[10] == ' '
&& (RT_C_IS_ALPHA(szHead[11]) || szHead[11] == '_' || szHead[11] == '$')
)
return SYMFILETYPE_LINUX_SYSTEM_MAP;
if ( RT_C_IS_XDIGIT(szHead[0])
&& RT_C_IS_XDIGIT(szHead[1])
&& RT_C_IS_XDIGIT(szHead[2])
&& RT_C_IS_XDIGIT(szHead[3])
&& RT_C_IS_XDIGIT(szHead[4])
&& RT_C_IS_XDIGIT(szHead[5])
&& RT_C_IS_XDIGIT(szHead[6])
&& RT_C_IS_XDIGIT(szHead[7])
&& RT_C_IS_XDIGIT(szHead[8])
&& RT_C_IS_XDIGIT(szHead[9])
&& RT_C_IS_XDIGIT(szHead[10])
&& RT_C_IS_XDIGIT(szHead[11])
&& RT_C_IS_XDIGIT(szHead[12])
&& RT_C_IS_XDIGIT(szHead[13])
&& RT_C_IS_XDIGIT(szHead[14])
&& RT_C_IS_XDIGIT(szHead[15])
&& szHead[16] == ' '
&& RT_C_IS_ALPHA(szHead[17])
&& szHead[18] == ' '
&& (RT_C_IS_ALPHA(szHead[19]) || szHead[19] == '_' || szHead[19] == '$')
)
return SYMFILETYPE_LINUX_SYSTEM_MAP;
if (strstr(szHead, "Microsoft C/C++ MSF") == szHead)
return SYMFILETYPE_PDB;
if (strstr(szHead, "ELF") == szHead + 1)
return SYMFILETYPE_ELF;
if ( strstr(szHead, "MZ") == szHead
|| strstr(szHead, "PE") == szHead
|| strstr(szHead, "LE") == szHead
|| strstr(szHead, "LX") == szHead
|| strstr(szHead, "NE") == szHead)
return SYMFILETYPE_MZ;
if (strstr(szHead, "file format"))
return SYMFILETYPE_OBJDUMP;
}
return SYMFILETYPE_UNKNOWN;
}
