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); } }