/**
* Get name component from UPN, Domain\User string, or NAME=VALUE pair.
*
* @param logonName Name to parse.
* @return Name component (Dynamically allocated.)
*/
PSTR GetNameComp(IN PSTR logonName) {
DWORD dwError = 0;
PSTR name = NULL;
int i;
if(!logonName) {
goto cleanup;
}
for(i = 0; i < strlen(logonName); ++i) {
if(logonName[i] == '\\') {
dwError = LwStrDupOrNull(logonName + i + 1, &name);
ADT_BAIL_ON_ALLOC_FAILURE_NP(!dwError);
goto cleanup;
}
}
for(i = 0; i < strlen(logonName); ++i) {
if(logonName[i] == '@') {
dwError = LwStrndup(logonName, i, &name);
ADT_BAIL_ON_ALLOC_FAILURE_NP(!dwError);
goto cleanup;
}
}
for(i = 0; i < strlen(logonName); ++i) {
if(logonName[i] == '=') {
dwError = LwStrndup(logonName + i + 1, strlen(logonName + i + 1), &name);
ADT_BAIL_ON_ALLOC_FAILURE_NP(!dwError);
goto cleanup;
}
}
for(i = 0; i < strlen(logonName); ++i) {
if(logonName[i] == '/') {
dwError = LwAllocateMemory(sizeof(CHAR) * (i + 1), OUT_PPVOID(&name));
ADT_BAIL_ON_ALLOC_FAILURE_NP(!dwError);
strncpy(name, (PCSTR) logonName, i);
goto cleanup;
}
}
dwError = LwStrDupOrNull(logonName, &name);
ADT_BAIL_ON_ALLOC_FAILURE_NP(!dwError);
cleanup:
return name;
error:
goto cleanup;
}
DWORD
LsaGetDirectoryFromPath(
IN PCSTR pszPath,
OUT PSTR* ppszDir
)
{
PCSTR pszLastSlash = NULL;
PSTR pszDir = NULL;
DWORD dwError = 0;
BAIL_ON_INVALID_POINTER(pszPath);
pszLastSlash = strrchr(pszPath, '/');
if (pszLastSlash == pszPath)
{
//Include the trailing / since this is the root directory ( / )
pszLastSlash++;
}
if (pszLastSlash == NULL)
{
dwError = LwAllocateString(
".",
&pszDir);
BAIL_ON_LSA_ERROR(dwError);
}
else
{
dwError = LwStrndup(
pszPath,
pszLastSlash - pszPath,
&pszDir);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszDir = pszDir;
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszDir);
*ppszDir = NULL;
goto cleanup;
}
static
DWORD
EVTStringSplit(
PCSTR pszInput,
PDWORD pdwCount,
PSTR** pppszArray
)
{
DWORD dwError = 0;
DWORD dwCount = 0;
PCSTR pszStart = NULL;
PCSTR pszEnd = NULL;
PSTR* ppszArray = NULL;
PSTR pszAdd = NULL;
for (pszStart = pszInput; *pszStart != 0; pszStart++)
{
if (*pszStart == ',') dwCount++;
}
dwCount++;
dwError = LwAllocateMemory(
(dwCount+1)*sizeof(PCSTR),
(PVOID *)&ppszArray);
dwCount = 0;
pszStart = pszInput;
while (TRUE)
{
pszEnd = strchr(pszStart, ',');
if ( pszEnd )
{
dwError = LwStrndup(
pszStart,
pszEnd - pszStart,
&pszAdd);
BAIL_ON_EVT_ERROR(dwError);
}
else
{
dwError = LwAllocateString(
pszStart,
&pszAdd);
BAIL_ON_EVT_ERROR(dwError);
}
LwStripWhitespace(pszAdd, TRUE, TRUE);
if (pszAdd[0])
{
ppszArray[dwCount++] = pszAdd;
pszAdd = NULL;
}
else
{
LW_SAFE_FREE_STRING(pszAdd);
}
if (pszEnd)
{
pszStart = pszEnd + 1;
}
else
{
break;
}
}
*pppszArray = ppszArray;
*pdwCount = dwCount;
cleanup:
LW_SAFE_FREE_STRING(pszAdd);
return dwError;
error:
LwFreeStringArray(
ppszArray,
dwCount);
goto cleanup;
}
DWORD
LsaNISGetNicknames(
PCSTR pszNicknameFilePath,
PDLINKEDLIST* ppNicknameList
)
{
typedef enum
{
NIS_NICKNAME_ALIAS = 0,
NIS_NICKNAME_NAME
} NISNicknameTokenType;
DWORD dwError = 0;
PDLINKEDLIST pNicknameList = NULL;
BOOLEAN bFileExists = FALSE;
PLSA_NIS_NICKNAME pNickname = NULL;
FILE* fp = NULL;
NISNicknameTokenType nextTokenType = NIS_NICKNAME_ALIAS;
dwError = LsaCheckFileExists(
pszNicknameFilePath,
&bFileExists);
BAIL_ON_LSA_ERROR(dwError);
if (!bFileExists)
{
dwError = ERROR_FILE_NOT_FOUND;
BAIL_ON_LSA_ERROR(dwError);
}
fp = fopen(pszNicknameFilePath, "r");
if (!fp)
{
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LSA_ERROR(dwError);
}
while (1)
{
CHAR szBuf[1024+1];
PSTR pszToken = NULL;
PCSTR pszDelim = " \t\r\n";
szBuf[0] = '\0';
if (fgets(szBuf, 1024, fp) == NULL)
{
if (feof(fp))
{
break;
}
else
{
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LSA_ERROR(dwError);
}
}
LwStripWhitespace(szBuf, TRUE, TRUE);
if (!szBuf[0] || (szBuf[0] == '#'))
{
// skip comments
continue;
}
if ((pszToken = strchr(szBuf, '#')))
{
// Skip trailing comments
*pszToken = '\0';
}
pszToken = szBuf;
if (nextTokenType == NIS_NICKNAME_ALIAS)
{
size_t stLen = 0;
stLen = strcspn(pszToken, pszDelim);
if (!stLen)
{
dwError = LW_ERROR_INTERNAL;
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateMemory(
sizeof(LSA_NIS_NICKNAME),
(PVOID*)&pNickname);
BAIL_ON_LSA_ERROR(dwError);
dwError = LwStrndup(
pszToken,
stLen,
&pNickname->pszMapAlias);
BAIL_ON_LSA_ERROR(dwError);
// Skip token
pszToken += stLen;
stLen = strspn(pszToken, pszDelim);
if (stLen)
{
// Skip delimiter
pszToken += stLen;
}
nextTokenType = NIS_NICKNAME_NAME;
}
// The name might appear on the same line
// Or it might appear on the next line
if (nextTokenType == NIS_NICKNAME_NAME)
{
if (LW_IS_NULL_OR_EMPTY_STR(pszToken))
{
continue;
}
// The rest of the line is the name
// we already removed trailing comments
dwError = LwAllocateString(
pszToken,
&pNickname->pszMapName);
BAIL_ON_LSA_ERROR(dwError);
dwError = LsaDLinkedListAppend(
&pNicknameList,
pNickname);
BAIL_ON_LSA_ERROR(dwError);
pNickname = NULL;
nextTokenType = NIS_NICKNAME_ALIAS;
}
}
*ppNicknameList = pNicknameList;
cleanup:
if (fp)
{
fclose(fp);
}
if (pNickname)
{
LsaNISFreeNickname(pNickname);
}
return dwError;
error:
*ppNicknameList = NULL;
if (pNicknameList)
{
LsaNISFreeNicknameList(pNicknameList);
}
goto cleanup;
}
static
DWORD
ParseTraceFlagArray(
PCSTR pszArg,
PLSA_TRACE_INFO* ppTraceFlagArray,
PDWORD pdwNumFlags
)
{
DWORD dwError = 0;
DWORD dwNumFlags = 0;
DWORD iFlag = 0;
size_t sFlagLen = 0;
PCSTR pszInput = pszArg;
PLSA_TRACE_INFO pTraceFlagArray = NULL;
PSTR pszFlagAndValue = NULL;
PSTR pszFlag = NULL;
if (*pszArg == ',')
{
fprintf(stderr, "Error: Invalid argument [%s]\n", pszArg);
dwError = LW_ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(dwError);
}
// Figure out how many flags there are
while ((sFlagLen = strcspn(pszInput, ",")) != 0)
{
size_t sDelimiterLen = 0;
pszInput += sFlagLen;
sDelimiterLen = strspn(pszInput, ",");
pszInput += sDelimiterLen;
dwNumFlags++;
}
dwError = LwAllocateMemory(
dwNumFlags * sizeof(LSA_TRACE_INFO),
(PVOID*)&pTraceFlagArray);
BAIL_ON_LSA_ERROR(dwError);
pszInput = pszArg;
while ((sFlagLen = strcspn(pszInput, ",")) != 0)
{
size_t sDelimiterLen = 0;
PCSTR pszIndex = NULL;
LW_SAFE_FREE_STRING(pszFlagAndValue);
dwError = LwStrndup(
pszInput,
sFlagLen,
&pszFlagAndValue);
BAIL_ON_LSA_ERROR(dwError);
if (!(pszIndex = strchr(pszFlagAndValue, ':')) ||
LW_IS_NULL_OR_EMPTY_STR(pszIndex+1) ||
(strcmp(pszIndex+1, "0") && strcmp(pszIndex + 1, "1")))
{
fprintf(stderr,
"Error: Invalid value specified for trace flag [%s]\n",
pszFlagAndValue);
dwError = LW_ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(dwError);
}
else if (pszIndex == pszFlagAndValue)
{
fprintf(stderr,
"Error: No name specified for trace flag [%s]\n",
pszFlagAndValue);
dwError = LW_ERROR_INVALID_PARAMETER;
BAIL_ON_LSA_ERROR(dwError);
}
else
{
PLSA_TRACE_INFO pTraceFlag = NULL;
LW_SAFE_FREE_STRING(pszFlag);
dwError = LwStrndup(
pszFlagAndValue,
(pszIndex - pszFlagAndValue),
&pszFlag);
BAIL_ON_LSA_ERROR(dwError);
pTraceFlag = &pTraceFlagArray[iFlag];
dwError = ParseTraceFlag(
pszFlag,
&pTraceFlag->dwTraceFlag);
BAIL_ON_LSA_ERROR(dwError);
pTraceFlag->bStatus = atoi(pszIndex + 1);
}
pszInput += sFlagLen;
sDelimiterLen = strspn(pszInput, ",");
pszInput += sDelimiterLen;
iFlag++;
}
*ppTraceFlagArray = pTraceFlagArray;
*pdwNumFlags = dwNumFlags;
cleanup:
LW_SAFE_FREE_STRING(pszFlag);
LW_SAFE_FREE_STRING(pszFlagAndValue);
return dwError;
error:
*ppTraceFlagArray = NULL;
*pdwNumFlags = 0;
LW_SAFE_FREE_MEMORY(pTraceFlagArray);
goto cleanup;
}
/*
The following are two example URIs and their component parts:
foo://example.com:8042/over/there?name=ferret#nose
\_/ \______________/\_________/ \_________/ \__/
| | | | |
scheme authority path query fragment
| _____________________|__
/ \ / \
urn:example:animal:ferret:nose
*/
DWORD
LwURILdapDecode(
PCSTR pszURI,
PSTR *ppszScheme,
PSTR *ppszAuthority,
PSTR *ppszPath
)
{
DWORD dwError = 0;
PCSTR pszSchemeStart = NULL;
PCSTR pszAuthorityStart = NULL;
PCSTR pszPathStart = NULL;
PCSTR pszIter = NULL;
PSTR pszScheme = NULL;
PSTR pszAuthority = NULL;
PSTR pszPath = NULL;
PSTR pszPathURLDecode = NULL;
pszSchemeStart = pszIter = pszURI;
if (('a' <= *pszIter && *pszIter <= 'z') ||
('A' <= *pszIter && *pszIter <= 'Z'))
{
while (('a' <= *pszIter && *pszIter <= 'z') ||
('A' <= *pszIter && *pszIter <= 'Z') ||
('0' <= *pszIter && *pszIter <= '0') ||
*pszIter == '+' ||
*pszIter == '-' ||
*pszIter == '.' )
{
pszIter++;
}
dwError = LwStrndup(
pszSchemeStart,
pszIter - pszSchemeStart,
&pszScheme);
BAIL_ON_LW_ERROR(dwError);
}
else
{
dwError = LW_ERROR_INTERNAL;
BAIL_ON_LW_ERROR(dwError);
}
if (pszIter[0] != ':' ||
pszIter[1] != '/' ||
pszIter[2] != '/')
{
dwError = LW_ERROR_INTERNAL;
BAIL_ON_LW_ERROR(dwError);
}
pszIter += 3;
pszAuthorityStart = pszIter;
while (*pszIter != '\0' && *pszIter != '/')
{
pszIter++;
}
if (pszAuthorityStart != pszIter)
{
dwError = LwStrndup(
pszAuthorityStart,
pszIter - pszAuthorityStart,
&pszAuthority);
BAIL_ON_LW_ERROR(dwError);
}
else
{
dwError = LW_ERROR_INTERNAL;
BAIL_ON_LW_ERROR(dwError);
}
if (*pszIter)
{
pszIter++; // Move past separator
pszPathStart = pszIter;
while (*pszIter)
{
pszIter++;
}
if (pszPathStart != pszIter)
{
dwError = LwStrndup(
pszPathStart,
pszIter - pszPathStart,
&pszPath);
BAIL_ON_LW_ERROR(dwError);
dwError = LwURLDecodeString(pszPath, &pszPathURLDecode);
BAIL_ON_LW_ERROR(dwError);
}
else
{
dwError = LW_ERROR_INTERNAL;
BAIL_ON_LW_ERROR(dwError);
}
}
if (ppszScheme)
{
*ppszScheme = pszScheme;
pszScheme = NULL;
}
if (ppszAuthority)
{
*ppszAuthority = pszAuthority;
pszAuthority = NULL;
}
if (ppszPath)
{
*ppszPath = pszPathURLDecode;
pszPathURLDecode = NULL;
}
cleanup:
LW_SAFE_FREE_STRING(pszScheme);
LW_SAFE_FREE_STRING(pszAuthority);
LW_SAFE_FREE_STRING(pszPath);
LW_SAFE_FREE_STRING(pszPathURLDecode);
return dwError;
error:
goto cleanup;
}
