DWORD
LsaNssComputeUserStringLength(
PLSA_USER_INFO_0 pUserInfo
)
{
DWORD dwLength = 0;
if (!LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszName)) {
dwLength += strlen(pUserInfo->pszName) + 1;
}
if (!LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszPasswd)) {
dwLength += strlen(pUserInfo->pszPasswd) + 1;
}
if (!LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszShell)) {
dwLength += strlen(pUserInfo->pszShell) + 1;
}
if (!LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszGecos)) {
dwLength += strlen(pUserInfo->pszGecos) + 1;
}
if (!LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszHomedir)) {
dwLength += strlen(pUserInfo->pszHomedir) + 1;
}
return dwLength;
}
DWORD
SamrSrvConfigGetHomedirTemplate(
PSTR *ppszHomedirTemplate
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszHomedirTemplate = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gSamrSrvConfig.pszHomedirTemplate)) {
goto cleanup;
}
dwError = LwAllocateString(gSamrSrvConfig.pszHomedirTemplate,
&pszHomedirTemplate);
BAIL_ON_LSA_ERROR(dwError);
*ppszHomedirTemplate = pszHomedirTemplate;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
DWORD
SamrSrvConfigGetDefaultLoginShell(
PSTR *ppszDefaultLoginShell
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszDefaultLoginShell = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gSamrSrvConfig.pszDefaultLoginShell)) {
goto cleanup;
}
dwError = LwAllocateString(gSamrSrvConfig.pszDefaultLoginShell,
&pszDefaultLoginShell);
BAIL_ON_LSA_ERROR(dwError);
*ppszDefaultLoginShell = pszDefaultLoginShell;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
VOID
PrintUserInfo_2(
PLSA_USER_INFO_2 pUserInfo,
BOOLEAN bCheckUserInList,
BOOLEAN bAllowedLogon
)
{
fprintf(stdout, "User info (Level-2):\n");
fprintf(stdout, "====================\n");
fprintf(stdout, "Name: %s\n", LW_PRINTF_STRING(pUserInfo->pszName));
fprintf(stdout, "UPN: %s\n", LW_PRINTF_STRING(pUserInfo->pszUPN));
fprintf(stdout, "Generated UPN: %s\n", LW_PRINTF_YES_NO(pUserInfo->bIsGeneratedUPN));
fprintf(stdout, "DN: %s\n",
LW_IS_NULL_OR_EMPTY_STR(pUserInfo->pszDN) ? "<null>" : pUserInfo->pszDN);
fprintf(stdout, "Uid: %u\n", (unsigned int)pUserInfo->uid);
fprintf(stdout, "Gid: %u\n", (unsigned int)pUserInfo->gid);
fprintf(stdout, "Gecos: %s\n", LW_PRINTF_STRING(pUserInfo->pszGecos));
fprintf(stdout, "Shell: %s\n", LW_PRINTF_STRING(pUserInfo->pszShell));
fprintf(stdout, "Home dir: %s\n", LW_PRINTF_STRING(pUserInfo->pszHomedir));
fprintf(stdout, "LMHash length: %u\n", pUserInfo->dwLMHashLen);
fprintf(stdout, "NTHash length: %u\n", pUserInfo->dwNTHashLen);
fprintf(stdout, "Local User: %s\n", LW_PRINTF_YES_NO(pUserInfo->bIsLocalUser));
fprintf(stdout, "Account disabled (or locked): %s\n", LW_PRINTF_TRUE_FALSE(pUserInfo->bAccountDisabled));
fprintf(stdout, "Account Expired: %s\n", LW_PRINTF_TRUE_FALSE(pUserInfo->bAccountExpired));
fprintf(stdout, "Password never expires: %s\n", LW_PRINTF_TRUE_FALSE(pUserInfo->bPasswordNeverExpires));
fprintf(stdout, "Password Expired: %s\n", LW_PRINTF_TRUE_FALSE(pUserInfo->bPasswordExpired));
fprintf(stdout, "Prompt for password change: %s\n", LW_PRINTF_YES_NO(pUserInfo->bPromptPasswordChange));
fprintf(stdout, "User can change password: %s\n", LW_PRINTF_YES_NO(pUserInfo->bUserCanChangePassword));
fprintf(stdout, "Days till password expires: %u\n", pUserInfo->dwDaysToPasswordExpiry);
if (bCheckUserInList)
{
fprintf(stdout, "Logon restriction: %s\n", LW_PRINTF_YES_NO(bAllowedLogon));
}
fprintf(stdout, "\n");
}
DWORD
UpLocalCfgNameValuePair(
PCSTR pszName,
PCSTR pszValue,
PVOID pData,
PBOOLEAN pbContinue
)
{
DWORD dwError = 0;
DWORD iHandler = 0;
DWORD nHandlers = sizeof(gLocalCfgHandlers)/sizeof(gLocalCfgHandlers[0]);
if (!LW_IS_NULL_OR_EMPTY_STR(pszName))
{
for (; iHandler < nHandlers; iHandler++)
{
if (!strcasecmp(gLocalCfgHandlers[iHandler].pszId, pszName))
{
gLocalCfgHandlers[iHandler].pfnHandler(
(PLOCAL_CONFIG)pData,
pszName,
pszValue);
break;
}
}
}
*pbContinue = TRUE;
return dwError;
}
static
DWORD
LsaAdBatchMarshalUserInfoFixShell(
IN PLSA_AD_PROVIDER_STATE pState,
IN OUT PSTR* ppszShell
)
{
DWORD dwError = 0;
PSTR pszShell = *ppszShell;
if (LW_IS_NULL_OR_EMPTY_STR(pszShell))
{
dwError = AD_GetUnprovisionedModeShell(
pState,
&pszShell);
BAIL_ON_LSA_ERROR(dwError);
BAIL_ON_INVALID_STRING(pszShell);
}
cleanup:
*ppszShell = pszShell;
return dwError;
error:
goto cleanup;
}
static
DWORD
LocalCfgSetSkeletonDirs(
PLOCAL_CONFIG pConfig,
PCSTR pszName,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszSkelDirs = NULL;
if (!LW_IS_NULL_OR_EMPTY_STR(pszValue))
{
dwError = LwAllocateString(
pszValue,
&pszSkelDirs);
BAIL_ON_UP_ERROR(dwError);
}
LW_SAFE_FREE_STRING(pConfig->pszSkelDirs);
pConfig->pszSkelDirs = pszSkelDirs;
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszSkelDirs);
goto cleanup;
}
DWORD
AD_GetHomedirPrefixPath(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszPath
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszHomedirPrefixPath = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszHomedirPrefix))
{
dwError = LwAllocateString(
pState->config.pszHomedirPrefix,
&pszHomedirPrefixPath
);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszPath = pszHomedirPrefixPath;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszPath = NULL;
goto cleanup;
}
DWORD
AD_GetUnprovisionedModeShell(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszUnprovisionedModeShell
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszUnprovisionedModeShell = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszShell))
{
dwError = LwAllocateString(
pState->config.pszShell,
&pszUnprovisionedModeShell);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszUnprovisionedModeShell = pszUnprovisionedModeShell;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszUnprovisionedModeShell = NULL;
goto cleanup;
}
BOOLEAN
LsaSrvIsPrivilegeNameValid(
PCSTR pszPrivilegeName
)
{
BOOLEAN Valid = FALSE;
PSTR ppszPrefixes[] = LSA_PRIVILEGE_VALID_PREFIXES;
DWORD i = 0;
PSTR pszPref = NULL;
if (!LW_IS_NULL_OR_EMPTY_STR(pszPrivilegeName))
{
for (i = 0;
!Valid && i < sizeof(ppszPrefixes)/sizeof(ppszPrefixes[0]);
i++)
{
LwStrStr(pszPrivilegeName,
ppszPrefixes[i],
&pszPref);
if (pszPrivilegeName == pszPref)
{
Valid = TRUE;
}
}
}
return Valid;
}
DWORD
WkssSrvConfigGetLsaLpcSocketPath(
PSTR *ppszLsaLpcSocketPath
)
{
DWORD dwError = 0;
BOOL bLocked = 0;
PSTR pszLpcSocketPath = NULL;
GLOBAL_DATA_LOCK(bLocked);
if (LW_IS_NULL_OR_EMPTY_STR(gWkssSrvConfig.pszLsaLpcSocketPath)) {
goto cleanup;
}
dwError = LwAllocateString(gWkssSrvConfig.pszLsaLpcSocketPath,
&pszLpcSocketPath);
BAIL_ON_LSA_ERROR(dwError);
*ppszLsaLpcSocketPath = pszLpcSocketPath;
cleanup:
GLOBAL_DATA_UNLOCK(bLocked);
return dwError;
error:
goto cleanup;
}
DWORD
LsaPamConfigNameValuePair(
PCSTR pszName,
PCSTR pszValue,
PVOID pData,
PBOOLEAN pbContinue
)
{
DWORD dwError = 0;
if (!LW_IS_NULL_OR_EMPTY_STR(pszName))
{
DWORD iHandler = 0;
DWORD nHandlers = sizeof(gConfigHandlers)/sizeof(gConfigHandlers[0]);
for (; iHandler < nHandlers; iHandler++)
{
if (!strcasecmp(gConfigHandlers[iHandler].pszId, pszName))
{
PLSA_PAM_CONFIG pConfig = (PLSA_PAM_CONFIG)pData;
gConfigHandlers[iHandler].pfnHandler(
pConfig,
pszName,
pszValue);
break;
}
}
}
*pbContinue = TRUE;
return dwError;
}
static
VOID
PrintGroupInfo_1(
PLSA_GROUP_INFO_1 pGroupInfo
)
{
PSTR* ppszMembers = NULL;
fprintf(stdout, "Group info (Level-1):\n");
fprintf(stdout, "====================\n");
fprintf(stdout, "Name: %s\n", LW_PRINTF_STRING(pGroupInfo->pszName));
fprintf(stdout, "Gid: %u\n", (unsigned int)pGroupInfo->gid);
fprintf(stdout, "SID: %s\n", LW_PRINTF_STRING(pGroupInfo->pszSid));
fprintf(stdout, "Members:\n");
ppszMembers = pGroupInfo->ppszMembers;
if (ppszMembers)
{
while (!LW_IS_NULL_OR_EMPTY_STR(*ppszMembers))
{
fprintf(stdout, " %s\n", *ppszMembers);
ppszMembers++;
}
}
fprintf(stdout, "\n");
}
static
DWORD
LsaPam_SetConfig_UserNotAllowedError(
PLSA_PAM_CONFIG pConfig,
PCSTR pszName,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszMessage = NULL;
if (!LW_IS_NULL_OR_EMPTY_STR(pszValue))
{
dwError = LwAllocateString(
pszValue,
&pszMessage);
BAIL_ON_UP_ERROR(dwError);
LW_SAFE_FREE_STRING(pConfig->pszAccessDeniedMessage);
pConfig->pszAccessDeniedMessage = pszMessage;
}
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszMessage);
goto cleanup;
}
DWORD
LsaSrvGetPrefixPath(
PSTR* ppszPath
)
{
DWORD dwError = 0;
PSTR pszPath = NULL;
BOOLEAN bInLock = FALSE;
LSA_LOCK_SERVERINFO(bInLock);
if (LW_IS_NULL_OR_EMPTY_STR(gpServerInfo->szPrefixPath)) {
dwError = LW_ERROR_INVALID_PREFIX_PATH;
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateString(gpServerInfo->szPrefixPath, &pszPath);
BAIL_ON_LSA_ERROR(dwError);
*ppszPath = pszPath;
cleanup:
LSA_UNLOCK_SERVERINFO(bInLock);
return dwError;
error:
LW_SAFE_FREE_STRING(pszPath);
*ppszPath = NULL;
goto cleanup;
}
DWORD
LsaCheckInvalidRpcServer(
PVOID pSymbol,
PCSTR pszLibPath
)
{
DWORD dwError = 0;
PCSTR pszError = NULL;
if (pSymbol == NULL) {
LSA_LOG_ERROR("Ignoring invalid rpc server at path [%s]",
(pszLibPath ? pszLibPath : "(unknown)"));
pszError = dlerror();
if (!LW_IS_NULL_OR_EMPTY_STR(pszError)) {
LSA_LOG_ERROR("%s", pszError);
}
dwError = LW_ERROR_INVALID_RPC_SERVER;
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
AD_GetUserDomainPrefix(
PLSA_AD_PROVIDER_STATE pState,
PSTR* ppszPath
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszValue = NULL;
ENTER_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
if (!LW_IS_NULL_OR_EMPTY_STR(pState->config.pszUserDomainPrefix))
{
dwError = LwAllocateString(
pState->config.pszUserDomainPrefix,
&pszValue
);
BAIL_ON_LSA_ERROR(dwError);
}
else if (pState->pProviderData &&
!LW_IS_NULL_OR_EMPTY_STR(pState->pProviderData->szShortDomain))
{
dwError = LwAllocateString(
pState->pProviderData->szShortDomain,
&pszValue
);
BAIL_ON_LSA_ERROR(dwError);
}
LwStrToUpper(pszValue);
*ppszPath = pszValue;
cleanup:
LEAVE_AD_CONFIG_RW_READER_LOCK(bInLock, pState);
return dwError;
error:
*ppszPath = NULL;
goto cleanup;
}
static
DWORD
LocalCfgSetHomedirPrefix(
PLOCAL_CONFIG pConfig,
PCSTR pszName,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszHomedirPrefix = NULL;
if (LW_IS_NULL_OR_EMPTY_STR(pszValue))
{
goto error;
}
dwError = LwAllocateString(pszValue, &pszHomedirPrefix);
BAIL_ON_LSA_ERROR(dwError);
LwStripWhitespace(pszHomedirPrefix, TRUE, TRUE);
if (LW_IS_NULL_OR_EMPTY_STR(pszHomedirPrefix))
{
goto error;
}
if (*pszHomedirPrefix != '/')
{
LSA_LOG_ERROR("Invalid home directory prefix [%s]", pszHomedirPrefix);
goto error;
}
LW_SAFE_FREE_STRING(pConfig->pszHomedirPrefix);
pConfig->pszHomedirPrefix = pszHomedirPrefix;
pszHomedirPrefix = NULL;
cleanup:
return dwError;
error:
LW_SAFE_FREE_STRING(pszHomedirPrefix);
goto cleanup;
}
static
DWORD
LsaAdBatchMarshalUserInfoFixLocalWindowsHomeFolder(
IN PLSA_AD_PROVIDER_STATE pState,
IN OUT PSTR* ppszLocalWindowsHomeFolder,
IN PCSTR pszNetbiosDomainName,
IN PCSTR pszSamAccountName
)
{
DWORD dwError = 0;
PSTR pszLocalWindowsHomeFolder = *ppszLocalWindowsHomeFolder;
PSTR pszNewLocalWindowsHomeFolder = NULL;
if (LW_IS_NULL_OR_EMPTY_STR(pszLocalWindowsHomeFolder))
{
dwError = AD_GetUnprovisionedModeRemoteHomeDirTemplate(
pState,
&pszLocalWindowsHomeFolder);
BAIL_ON_LSA_ERROR(dwError);
}
if (pszLocalWindowsHomeFolder == NULL)
{
dwError = LwAllocateString("", &pszLocalWindowsHomeFolder);
BAIL_ON_LSA_ERROR(dwError);
}
else if (strstr(pszLocalWindowsHomeFolder, "%"))
{
dwError = AD_BuildHomeDirFromTemplate(
pState,
pszLocalWindowsHomeFolder,
pszNetbiosDomainName,
pszSamAccountName,
&pszNewLocalWindowsHomeFolder);
if (dwError)
{
// If we encounter a problem with fixing up the shell, leave the user object with the actual
// value stored in AD and log the problem.
LSA_LOG_INFO("While processing information for user (%s), an invalid remote homedir value was detected (homedir: '%s')",
LSA_SAFE_LOG_STRING(pszSamAccountName),
LSA_SAFE_LOG_STRING(pszLocalWindowsHomeFolder));
dwError = 0;
goto cleanup;
}
LW_SAFE_FREE_STRING(pszLocalWindowsHomeFolder);
LSA_XFER_STRING(pszNewLocalWindowsHomeFolder, pszLocalWindowsHomeFolder);
}
LwStrCharReplace(pszLocalWindowsHomeFolder, ' ', '_');
cleanup:
*ppszLocalWindowsHomeFolder = pszLocalWindowsHomeFolder;
return dwError;
error:
goto cleanup;
}
VOID
RegPrintError(
IN OPTIONAL PCSTR pszErrorPrefix,
IN DWORD dwError
)
{
PCSTR pszUseErrorPrefix = NULL;
size_t size = 0;
PSTR pszErrorString = NULL;
PCSTR pszWinError = NULL;
if (dwError)
{
pszUseErrorPrefix = pszErrorPrefix;
if (!pszUseErrorPrefix)
{
pszUseErrorPrefix = "LWREG ERROR: ";
}
size = LwRegGetErrorString(dwError, NULL, 0);
if (size)
{
pszErrorString = malloc(size);
if (pszErrorString)
{
LwRegGetErrorString(dwError, pszErrorString, size);
}
}
pszWinError = LW_PRINTF_STRING(RegWin32ExtErrorToName(dwError));
if (!pszWinError)
{
pszWinError = "";
}
if (LW_IS_NULL_OR_EMPTY_STR(pszErrorString))
{
fprintf(stderr,
"%s (error = %u%s%s)\n",
pszUseErrorPrefix,
dwError,
*pszWinError ? " - " : "",
pszWinError);
}
else
{
fprintf(stderr,
"%s (error = %u%s%s)\n%s\n",
pszUseErrorPrefix,
dwError,
*pszWinError ? " - " : "",
pszWinError,
pszErrorString);
}
}
LWREG_SAFE_FREE_STRING(pszErrorString);
}
DWORD
LsaSELinuxManageHomeDir(
PCSTR pszHomeDir
)
{
DWORD dwError = 0;
PCSTR pszSemanageFormat = "semanage fcontext -a -e /home %s";
PSTR pszRootHomeDir = NULL;
PSTR pszSemanageExecute = NULL;
int systemresult = 0;
dwError = LsaGetDirectoryFromPath(pszHomeDir, &pszRootHomeDir);
BAIL_ON_LSA_ERROR(dwError);
if (LW_IS_NULL_OR_EMPTY_STR(pszRootHomeDir))
{
dwError = LW_ERROR_INVALID_PREFIX_PATH;
BAIL_ON_LSA_ERROR(dwError);
}
if (pszRootHomeDir[0] != '/')
{
dwError = LW_ERROR_INVALID_PREFIX_PATH;
BAIL_ON_LSA_ERROR(dwError);
}
if (pszRootHomeDir[1] == '\0')
{
dwError = LW_ERROR_INVALID_PREFIX_PATH;
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateStringPrintf(
&pszSemanageExecute,
pszSemanageFormat,
pszRootHomeDir);
BAIL_ON_LSA_ERROR(dwError);
systemresult = system(pszSemanageExecute);
if (systemresult < 0)
{
dwError = LwMapErrnoToLwError(errno);
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
LW_SAFE_FREE_STRING(pszRootHomeDir);
LW_SAFE_FREE_STRING(pszSemanageExecute);
return dwError;
error:
goto cleanup;
}
void
LwStrToLower(
PSTR pszString
)
{
if (LW_IS_NULL_OR_EMPTY_STR(pszString))
return;
while (*pszString != '\0') {
*pszString = tolower((int)*pszString);
pszString++;
}
}
DWORD
LsaAdBatchGatherPseudoObjectDefaultSchema(
IN OUT PLSA_AD_BATCH_ITEM pItem,
IN LSA_AD_BATCH_OBJECT_TYPE ObjectType,
IN OUT OPTIONAL PSTR* ppszSid,
IN HANDLE hDirectory,
IN LDAPMessage* pMessage
)
{
DWORD dwError = 0;
dwError = LsaAdBatchGatherObjectType(pItem, ObjectType);
BAIL_ON_LSA_ERROR(dwError);
if (!pItem->pszSid)
{
if (ppszSid)
{
LSA_XFER_STRING(*ppszSid, pItem->pszSid);
}
else
{
dwError = ADLdap_GetObjectSid(hDirectory, pMessage, &pItem->pszSid);
BAIL_ON_LSA_ERROR(dwError);
}
}
if (LW_IS_NULL_OR_EMPTY_STR(pItem->pszSid))
{
dwError = LW_ERROR_DATA_ERROR;
BAIL_ON_LSA_ERROR(dwError);
}
if (!IsSetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_HAVE_PSEUDO))
{
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_HAVE_PSEUDO);
dwError = LsaAdBatchGatherSchemaMode(
pItem,
hDirectory,
pMessage);
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
return dwError;
error:
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_ERROR);
goto cleanup;
}
static
VOID
PrintGroupInfo_1(
PLSA_GROUP_INFO_1 pGroupInfo,
BOOLEAN bPrintKeys,
BOOLEAN bIndexById
)
{
PSTR* ppszMembers = NULL;
if (bPrintKeys)
{
if (bIndexById)
{
printf("%u ", (unsigned int)pGroupInfo->gid);
}
else
{
printf("%s ", pGroupInfo->pszName);
}
}
printf("%s:%s:%u:",
YPCAT_SAFE_LOG_STRING(pGroupInfo->pszName),
YPCAT_SAFE_LOG_STRING(pGroupInfo->pszPasswd),
(unsigned int)pGroupInfo->gid);
ppszMembers = pGroupInfo->ppszMembers;
if (ppszMembers)
{
DWORD iMember = 0;
while (!LW_IS_NULL_OR_EMPTY_STR(*ppszMembers))
{
if (iMember)
{
printf(",%s", *ppszMembers);
}
else
{
printf("%s", *ppszMembers);
}
iMember++;
ppszMembers++;
}
}
printf("\n");
}
DWORD
LsaGetErrorMessageForLoggingEvent(
DWORD dwErrCode,
PSTR* ppszErrorMsg)
{
DWORD dwErrorBufferSize = 0;
DWORD dwError = 0;
DWORD dwLen = 0;
PSTR pszErrorMsg = NULL;
PSTR pszErrorBuffer = NULL;
dwErrorBufferSize = LwGetErrorString(dwErrCode, NULL, 0);
if (!dwErrorBufferSize)
goto cleanup;
dwError = LwAllocateMemory(
dwErrorBufferSize,
(PVOID*)&pszErrorBuffer);
BAIL_ON_LSA_ERROR(dwError);
dwLen = LwGetErrorString(dwErrCode, pszErrorBuffer, dwErrorBufferSize);
if ((dwLen == dwErrorBufferSize) && !LW_IS_NULL_OR_EMPTY_STR(pszErrorBuffer))
{
dwError = LwAllocateStringPrintf(
&pszErrorMsg,
"Error: %s [error code: %u]",
pszErrorBuffer,
dwErrCode);
BAIL_ON_LSA_ERROR(dwError);
}
*ppszErrorMsg = pszErrorMsg;
cleanup:
LW_SAFE_FREE_STRING(pszErrorBuffer);
return dwError;
error:
LW_SAFE_FREE_STRING(pszErrorMsg);
*ppszErrorMsg = NULL;
goto cleanup;
}
// This can be called when a DB lock and active key list lock are both held
NTSTATUS
SqliteDeleteKeyInternal_inlock_inDblock(
IN HANDLE handle,
IN PCWSTR pwszKeyName
)
{
NTSTATUS status = STATUS_SUCCESS;
PWSTR pwszParentKeyName = NULL;
PREG_KEY_HANDLE pKeyHandle = NULL;
// Do not free
PREG_KEY_CONTEXT pKeyCtx = NULL;
status = SqliteDeleteActiveKey_inlock((PCWSTR)pwszKeyName);
BAIL_ON_NT_STATUS(status);
status = SqliteOpenKeyInternal_inlock_inDblock(handle,
pwszKeyName,
0,
&pKeyHandle);
BAIL_ON_NT_STATUS(status);
BAIL_ON_NT_INVALID_POINTER(pKeyHandle);
pKeyCtx = pKeyHandle->pKey;
BAIL_ON_INVALID_KEY_CONTEXT(pKeyCtx);
// Delete all the values of this key
status = RegDbDeleteKey_inlock(ghCacheConnection, pKeyCtx->qwId, pKeyCtx->qwSdId, pwszKeyName);
BAIL_ON_NT_STATUS(status);
status = SqliteGetParentKeyName(pwszKeyName, '\\',&pwszParentKeyName);
BAIL_ON_NT_STATUS(status);
if (!LW_IS_NULL_OR_EMPTY_STR(pwszParentKeyName))
{
SqliteCacheResetParentKeySubKeyInfo_inlock(pwszParentKeyName);
}
cleanup:
SqliteSafeFreeKeyHandle_inlock(pKeyHandle);
LWREG_SAFE_FREE_MEMORY(pwszParentKeyName);
return status;
error:
goto cleanup;
}
static
DWORD
LsaAdBatchGatherPseudoSid(
OUT PSTR* ppszSid,
IN PAD_PROVIDER_DATA pProviderData,
IN OPTIONAL DWORD dwKeywordValuesCount,
IN OPTIONAL PSTR* ppszKeywordValues,
IN HANDLE hDirectory,
IN LDAPMessage* pMessage
)
{
DWORD dwError = 0;
PSTR pszSid = NULL;
if (LsaAdBatchIsDefaultSchemaMode(pProviderData))
{
dwError = ADLdap_GetObjectSid(hDirectory, pMessage, &pszSid);
BAIL_ON_LSA_ERROR(dwError);
}
else
{
PCSTR pszSidFromKeywords = NULL;
LSA_ASSERT(ppszKeywordValues);
pszSidFromKeywords = LsaAdBatchFindKeywordAttributeStatic(
dwKeywordValuesCount,
ppszKeywordValues,
AD_LDAP_BACKLINK_PSEUDO_TAG);
if (LW_IS_NULL_OR_EMPTY_STR(pszSidFromKeywords))
{
dwError = LW_ERROR_INVALID_SID;
BAIL_ON_LSA_ERROR(dwError);
}
dwError = LwAllocateString(pszSidFromKeywords, &pszSid);
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
*ppszSid = pszSid;
return dwError;
error:
LW_SAFE_FREE_STRING(pszSid);
goto cleanup;
}
void
LwStrnToUpper(
PSTR pszString,
DWORD dwLen
)
{
if (!LW_IS_NULL_OR_EMPTY_STR(pszString))
{
DWORD iCh = 0;
while ((iCh++ < dwLen) && *pszString != '\0')
{
*pszString = toupper((int)*pszString);
pszString++;
}
}
}
static
DWORD
GetErrorMessage(
DWORD dwErrCode,
PSTR* ppszErrorMsg)
{
DWORD dwError = 0;
DWORD dwErrorBufferSize = 0;
DWORD dwLen = 0;
PSTR pszErrorMsg = NULL;
PSTR pszErrorBuffer = NULL;
dwErrorBufferSize = LwGetErrorString(dwErrCode, NULL, 0);
if(!dwErrorBufferSize)
goto cleanup;
dwError = LwAllocateMemory(
dwErrorBufferSize,
OUT_PPVOID(&pszErrorBuffer));
BAIL_ON_UP_ERROR(dwError);
dwLen = LwGetErrorString(dwErrCode, pszErrorBuffer, dwErrorBufferSize);
if ((dwLen == dwErrorBufferSize) && !LW_IS_NULL_OR_EMPTY_STR(pszErrorBuffer))
{
dwError = LwAllocateStringPrintf(
&pszErrorMsg,
"Error: %s [error code: %d]", pszErrorBuffer,
dwErrCode);
BAIL_ON_UP_ERROR(dwError);
}
*ppszErrorMsg = pszErrorMsg;
cleanup:
LW_SAFE_FREE_MEMORY(pszErrorBuffer);
return dwError;
error:
LW_SAFE_FREE_STRING(pszErrorMsg);
*ppszErrorMsg = NULL;
goto cleanup;
}
void
RegStripWhitespace(
PSTR pszString,
BOOLEAN bLeading,
BOOLEAN bTrailing
)
{
if (LW_IS_NULL_OR_EMPTY_STR(pszString))
return;
if (bLeading) {
RegStripLeadingWhitespace(pszString);
}
if (bTrailing) {
RegStripTrailingWhitespace(pszString);
}
}
