/**
* Validates the user specified name.
*
* @returns IPRT status code.
* @param pszName The name to validate.
* @param fNative Whether it's a native name or a portable name.
*/
static int rtLocalIpcPosixValidateName(const char *pszName, bool fNative)
{
AssertPtrReturn(pszName, VERR_INVALID_POINTER);
AssertReturn(*pszName, VERR_INVALID_NAME);
if (!fNative)
{
for (;;)
{
char ch = *pszName++;
if (!ch)
break;
AssertReturn(!RT_C_IS_CNTRL(ch), VERR_INVALID_NAME);
AssertReturn((unsigned)ch < 0x80, VERR_INVALID_NAME);
AssertReturn(ch != '\\', VERR_INVALID_NAME);
AssertReturn(ch != '/', VERR_INVALID_NAME);
}
}
else
{
int rc = RTStrValidateEncoding(pszName);
AssertRCReturn(rc, rc);
}
return VINF_SUCCESS;
}
/*
* Input file parsing.
*/
static int ParseAlias(char *pszLine, size_t& id, std::string& desc)
{
/* First there's a hexadeciman number. */
uint32_t uVal;
char *pszNext;
int rc = RTStrToUInt32Ex(pszLine, &pszNext, 16, &uVal);
if ( rc == VWRN_TRAILING_CHARS
|| rc == VWRN_TRAILING_SPACES
|| rc == VINF_SUCCESS)
{
/* Skip the whipespace following it and at the end of the line. */
pszNext = RTStrStripL(pszNext);
if (*pszNext != '\0')
{
rc = RTStrValidateEncoding(pszNext);
if (RT_SUCCESS(rc))
{
size_t cchDesc = strlen(pszNext);
if (cchDesc <= USB_ID_DATABASE_MAX_STRING)
{
id = uVal;
desc = pszNext;
g_cbRawStrings += cchDesc + 1;
return RTEXITCODE_SUCCESS;
}
RTMsgError("String to long: %zu", cchDesc);
}
else
RTMsgError("Invalid encoding: '%s' (rc=%Rrc)", pszNext, rc);
}
else
RTMsgError("Error parsing '%s'", pszLine);
}
else
RTMsgError("Error converting number at the start of '%s': %Rrc", pszLine, rc);
return ERROR_IN_PARSE_LINE;
}
RTDECL(int) RTUriFilePathEx(const char *pszUri, uint32_t fPathStyle, char **ppszPath, size_t cbPath, size_t *pcchPath)
{
/*
* Validate and adjust input.
*/
if (pcchPath)
{
AssertPtrReturn(pcchPath, VERR_INVALID_POINTER);
*pcchPath = ~(size_t)0;
}
AssertPtrReturn(ppszPath, VERR_INVALID_POINTER);
AssertReturn(!(fPathStyle & ~RTPATH_STR_F_STYLE_MASK) && fPathStyle != RTPATH_STR_F_STYLE_RESERVED, VERR_INVALID_FLAGS);
if (fPathStyle == RTPATH_STR_F_STYLE_HOST)
fPathStyle = RTPATH_STYLE;
AssertPtrReturn(pszUri, VERR_INVALID_POINTER);
/*
* Check that this is a file URI.
*/
if (RTStrNICmp(pszUri, RT_STR_TUPLE("file:")) == 0)
{ /* likely */ }
else
return VERR_URI_NOT_FILE_SCHEME;
/*
* We may have a number of variations here, mostly thanks to
* various windows software. First the canonical variations:
* - file:///C:/Windows/System32/kernel32.dll
* - file:///C|/Windows/System32/kernel32.dll
* - file:///C:%5CWindows%5CSystem32%5Ckernel32.dll
* - file://localhost/C:%5CWindows%5CSystem32%5Ckernel32.dll
* - file://cifsserver.dev/systemshare%5CWindows%5CSystem32%5Ckernel32.dll
* - file://cifsserver.dev:139/systemshare%5CWindows%5CSystem32%5Ckernel32.dll (not quite sure here, but whatever)
*
* Legacy variant without any slashes after the schema:
* - file:C:/Windows/System32/kernel32.dll
* - file:C|/Windows/System32%5Ckernel32.dll
* - file:~/.bashrc
* \--path-/
*
* Legacy variant with exactly one slashes after the schema:
* - file:/C:/Windows/System32%5Ckernel32.dll
* - file:/C|/Windows/System32/kernel32.dll
* - file:/usr/bin/env
* \---path---/
*
* Legacy variant with two slashes after the schema and an unescaped DOS path:
* - file://C:/Windows/System32\kernel32.dll (**)
* - file://C|/Windows/System32\kernel32.dll
* \---path---------------------/
* -- authority, with ':' as non-working port separator
*
* Legacy variant with exactly four slashes after the schema and an unescaped DOS path.
* - file:////C:/Windows\System32\user32.dll
*
* Legacy variant with four or more slashes after the schema and an unescaped UNC path:
* - file:////cifsserver.dev/systemshare/System32%\kernel32.dll
* - file://///cifsserver.dev/systemshare/System32\kernel32.dll
* \---path--------------------------------------------/
*
* The the two unescaped variants shouldn't be handed to rtUriParse, which
* is good as we cannot actually handle the one marked by (**). So, handle
* those two special when parsing.
*/
RTURIPARSED Parsed;
int rc;
size_t cSlashes = 0;
while (pszUri[5 + cSlashes] == '/')
cSlashes++;
if ( (cSlashes == 2 || cSlashes == 4)
&& RT_C_IS_ALPHA(pszUri[5 + cSlashes])
&& (pszUri[5 + cSlashes + 1] == ':' || pszUri[5 + cSlashes + 1] == '|'))
{
RT_ZERO(Parsed); /* RTURIPARSED_F_CONTAINS_ESCAPED_CHARS is now clear. */
Parsed.offPath = 5 + cSlashes;
Parsed.cchPath = strlen(&pszUri[Parsed.offPath]);
rc = RTStrValidateEncoding(&pszUri[Parsed.offPath]);
}
else if (cSlashes >= 4)
{
RT_ZERO(Parsed);
Parsed.fFlags = cSlashes > 4 ? RTURIPARSED_F_CONTAINS_ESCAPED_CHARS : 0;
Parsed.offPath = 5 + cSlashes - 2;
Parsed.cchPath = strlen(&pszUri[Parsed.offPath]);
rc = RTStrValidateEncoding(&pszUri[Parsed.offPath]);
}
else
rc = rtUriParse(pszUri, &Parsed);
if (RT_SUCCESS(rc))
{
/*
* Ignore localhost as hostname (it's implicit).
*/
static char const s_szLocalhost[] = "localhost";
if ( Parsed.cchAuthorityHost == sizeof(s_szLocalhost) - 1U
&& RTStrNICmp(&pszUri[Parsed.offAuthorityHost], RT_STR_TUPLE(s_szLocalhost)) == 0)
{
Parsed.cchAuthorityHost = 0;
Parsed.cchAuthority = 0;
}
/*
* Ignore leading path slash/separator if we detect a DOS drive letter
* and we don't have a host name.
*/
if ( Parsed.cchPath >= 3
&& Parsed.cchAuthorityHost == 0
&& pszUri[Parsed.offPath] == '/' /* Leading path slash/separator. */
&& ( pszUri[Parsed.offPath + 2] == ':' /* Colon after drive letter. */
|| pszUri[Parsed.offPath + 2] == '|') /* Colon alternative. */
&& RT_C_IS_ALPHA(pszUri[Parsed.offPath + 1]) ) /* Drive letter. */
{
Parsed.offPath++;
Parsed.cchPath--;
}
/*
* Calculate the size of the encoded result.
*
* Since we're happily returning "C:/Windows/System32/kernel.dll"
* style paths when the caller requested UNIX style paths, we will
* return straight UNC paths too ("//cifsserver/share/dir/file").
*/
size_t cchDecodedHost = 0;
size_t cbResult;
if (Parsed.fFlags & RTURIPARSED_F_CONTAINS_ESCAPED_CHARS)
{
cchDecodedHost = rtUriCalcDecodedLength(&pszUri[Parsed.offAuthorityHost], Parsed.cchAuthorityHost);
cbResult = cchDecodedHost + rtUriCalcDecodedLength(&pszUri[Parsed.offPath], Parsed.cchPath) + 1;
}
else
{
cchDecodedHost = 0;
cbResult = Parsed.cchAuthorityHost + Parsed.cchPath + 1;
}
if (pcchPath)
*pcchPath = cbResult - 1;
if (cbResult > 1)
{
/*
* Prepare the necessary buffer space for the result.
*/
char *pszDst;
char *pszFreeMe = NULL;
if (!cbPath || *ppszPath == NULL)
{
cbPath = RT_MAX(cbPath, cbResult);
*ppszPath = pszFreeMe = pszDst = RTStrAlloc(cbPath);
AssertReturn(pszDst, VERR_NO_STR_MEMORY);
}
else if (cbResult <= cbPath)
pszDst = *ppszPath;
else
return VERR_BUFFER_OVERFLOW;
/*
* Compose the result.
*/
if (Parsed.fFlags & RTURIPARSED_F_CONTAINS_ESCAPED_CHARS)
{
rc = rtUriDecodeIntoBuffer(&pszUri[Parsed.offAuthorityHost],Parsed.cchAuthorityHost,
pszDst, cchDecodedHost + 1);
Assert(RT_SUCCESS(rc) && strlen(pszDst) == cchDecodedHost);
if (RT_SUCCESS(rc))
rc = rtUriDecodeIntoBuffer(&pszUri[Parsed.offPath], Parsed.cchPath,
&pszDst[cchDecodedHost], cbResult - cchDecodedHost);
Assert(RT_SUCCESS(rc) && strlen(pszDst) == cbResult - 1);
}
else
{
memcpy(pszDst, &pszUri[Parsed.offAuthorityHost], Parsed.cchAuthorityHost);
memcpy(&pszDst[Parsed.cchAuthorityHost], &pszUri[Parsed.offPath], Parsed.cchPath);
pszDst[cbResult - 1] = '\0';
}
if (RT_SUCCESS(rc))
{
/*
* Convert colon DOS driver letter colon alternative.
* We do this regardless of the desired path style.
*/
if ( RT_C_IS_ALPHA(pszDst[0])
&& pszDst[1] == '|')
pszDst[1] = ':';
/*
* Fix slashes.
*/
if (fPathStyle == RTPATH_STR_F_STYLE_DOS)
RTPathChangeToDosSlashes(pszDst, true);
else if (fPathStyle == RTPATH_STR_F_STYLE_UNIX)
RTPathChangeToUnixSlashes(pszDst, true); /** @todo not quite sure how this actually makes sense... */
else
AssertFailed();
return rc;
}
/* bail out */
RTStrFree(pszFreeMe);
}
else
rc = VERR_PATH_ZERO_LENGTH;
}
return 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;
}
