NTSTATUS
MemRegStoreFindNodeValue(
IN PMEMREG_NODE hDbNode,
IN PCWSTR Name,
OUT PMEMREG_VALUE *phValue)
{
NTSTATUS status = 0;
DWORD valueIndex = 0;
BOOLEAN bFoundValue = FALSE;
if (!Name)
{
Name = (PCWSTR) L"";
}
for (valueIndex=0; valueIndex<hDbNode->ValuesLen; valueIndex++)
{
if (LwRtlWC16StringIsEqual(Name, hDbNode->Values[valueIndex]->Name, FALSE))
{
bFoundValue = TRUE;
break;
}
}
if (bFoundValue)
{
*phValue = hDbNode->Values[valueIndex];
}
else
{
status = STATUS_OBJECT_NAME_NOT_FOUND;
}
return status;
}
VOID
SqliteCacheDeleteDbKeyInfo_inlock(
IN PCWSTR pwszKeyName
)
{
NTSTATUS status = 0;
REG_HASH_ITERATOR hashIterator;
REG_HASH_ENTRY* pHashEntry = NULL;
PREG_DB_KEY pRegKey = NULL;
int iCount = 0;
status = RegHashGetValue(gRegDbKeyList.pKeyList,
(PCVOID)pwszKeyName,
(PVOID*)&pRegKey);
if (STATUS_OBJECT_NAME_NOT_FOUND == status)
{
return;
}
RegHashGetIterator(gRegDbKeyList.pKeyList, &hashIterator);
for (iCount = 0; (pHashEntry = RegHashNext(&hashIterator)) != NULL; iCount++)
{
if (LwRtlWC16StringIsEqual((PCWSTR)pHashEntry->pKey, pwszKeyName, FALSE))
{
RegHashRemoveKey(gRegDbKeyList.pKeyList, pHashEntry->pKey);
break;
}
}
return;
}
DWORD
LsaPstoreSetPasswordInfoW(
IN PLSA_MACHINE_PASSWORD_INFO_W PasswordInfo
)
{
DWORD dwError = 0;
int EE = 0;
PLSA_PSTORE_BACKEND_STATE backendState = NULL;
PWSTR defaultDnsDomainName = NULL;
BOOLEAN isDefaultDomain = FALSE;
dwError = LsaPstorepCheckPasswordInfoW(PasswordInfo);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
dwError = LsaPstorepEnsureInitialized(&backendState);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
// Returns NULL if no default is set.
dwError = LsaPstoreGetDefaultDomainW(&defaultDnsDomainName);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
dwError = LsaPstorepBackendSetPasswordInfoW(backendState, PasswordInfo);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
if (!defaultDnsDomainName)
{
// TODO-Perhaps ignore error here?
dwError = LsaPstoreSetDefaultDomainW(PasswordInfo->Account.DnsDomainName);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
isDefaultDomain = TRUE;
}
else
{
isDefaultDomain = LwRtlWC16StringIsEqual(
defaultDnsDomainName,
PasswordInfo->Account.DnsDomainName,
TRUE);
}
if (isDefaultDomain)
{
dwError = LsaPstorepCallPluginSetPasswordInfo(PasswordInfo);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
}
cleanup:
LSA_PSTORE_FREE(&defaultDnsDomainName);
LSA_PSTORE_LOG_LEAVE_ERROR_EE(dwError, EE);
return dwError;
}
static
NTSTATUS
RdrIsInPlaceRename(
PRDR_CCB pFile,
PFILE_RENAME_INFORMATION pRenameInfo,
PBOOLEAN pbIsInPlace
)
{
NTSTATUS status = STATUS_SUCCESS;
PWSTR pwszShare = NULL;
PWSTR pwszFile = NULL;
PWSTR pwszExisting = NULL;
PWSTR pwszNew = NULL;
status = RdrConvertPath(
pRenameInfo->FileName,
NULL,
&pwszShare,
&pwszFile
);
BAIL_ON_NT_STATUS(status);
status = LwRtlWC16StringAllocatePrintfW(
&pwszNew,
L"%ws%ws",
pwszShare,
pwszFile);
BAIL_ON_NT_STATUS(status);
status = LwRtlWC16StringDuplicate(&pwszExisting, pFile->pwszCanonicalPath);
BAIL_ON_NT_STATUS(status);
RdrTrimLastPathElement(pwszNew);
RdrTrimLastPathElement(pwszExisting);
*pbIsInPlace = LwRtlWC16StringIsEqual(pwszNew, pwszExisting, FALSE);
cleanup:
RTL_FREE(&pwszShare);
RTL_FREE(&pwszFile);
RTL_FREE(&pwszExisting);
RTL_FREE(&pwszNew);
return status;
error:
*pbIsInPlace = FALSE;
goto cleanup;
}
static
DWORD
MapBuiltinNameToSid(
PSID *ppSid,
PCWSTR pwszName
)
{
DWORD dwError = 0;
union
{
SID sid;
BYTE buffer[SID_MAX_SIZE];
} Sid;
ULONG SidSize = sizeof(Sid.buffer);
PWSTR pwszEveryone = NULL;
dwError = LwNtStatusToWin32Error(
RtlWC16StringAllocateFromCString(
&pwszEveryone,
"Everyone"));
BAIL_ON_SRVSVC_ERROR(dwError);
if (LwRtlWC16StringIsEqual(pwszName, pwszEveryone, FALSE))
{
dwError = LwNtStatusToWin32Error(
RtlCreateWellKnownSid(
WinWorldSid,
NULL,
&Sid.sid,
&SidSize));
}
BAIL_ON_SRVSVC_ERROR(dwError);
dwError = LwNtStatusToWin32Error(
RtlDuplicateSid(ppSid, &Sid.sid));
cleanup:
LW_RTL_FREE(&pwszEveryone);
return dwError;
error:
goto cleanup;
}
DWORD
LwSmTableGetEntry(
PCWSTR pwszName,
PSM_TABLE_ENTRY* ppEntry
)
{
DWORD dwError = 0;
BOOL bLocked = FALSE;
PSM_LINK pLink = NULL;
PSM_TABLE_ENTRY pEntry = NULL;
LOCK(bLocked, gServiceTable.pLock);
for (pLink = LwSmLinkBegin(&gServiceTable.entries);
LwSmLinkValid(&gServiceTable.entries, pLink);
pLink = LwSmLinkNext(pLink))
{
pEntry = STRUCT_FROM_MEMBER(pLink, SM_TABLE_ENTRY, link);
if (LwRtlWC16StringIsEqual(pEntry->pInfo->pwszName, pwszName, TRUE))
{
pEntry->dwRefCount++;
*ppEntry = pEntry;
goto cleanup;
}
}
dwError = LW_ERROR_NO_SUCH_SERVICE;
BAIL_ON_ERROR(dwError);
cleanup:
UNLOCK(bLocked, gServiceTable.pLock);
return dwError;
error:
*ppEntry = NULL;
goto cleanup;
}
NTSTATUS
MemRegStoreFindNode(
IN PMEMREG_NODE hDbNode,
IN PCWSTR Name,
OUT PMEMREG_NODE *pphNode)
{
NTSTATUS status = 0;
DWORD nodeIndex = 0;
BOOLEAN bFoundNode = FALSE;
BAIL_ON_NT_STATUS(status);
if (!Name)
{
Name = (PCWSTR) L"";
}
for (nodeIndex=0; nodeIndex<hDbNode->NodesLen; nodeIndex++)
{
if (hDbNode->SubNodes[nodeIndex] &&
LwRtlWC16StringIsEqual(Name, hDbNode->SubNodes[nodeIndex]->Name, FALSE))
{
bFoundNode = TRUE;
break;
}
}
if (bFoundNode)
{
*pphNode = hDbNode->SubNodes[nodeIndex];
}
else
{
status = STATUS_OBJECT_NAME_NOT_FOUND;
}
cleanup:
return status;
error:
goto cleanup;
}
NTSTATUS
MemRegStoreDeleteNodeValue(
IN PMEMREG_NODE hDbNode,
IN PCWSTR Name)
{
NTSTATUS status = 0;
BOOLEAN bFoundValue = FALSE;
BOOLEAN bValueDeleted = FALSE;
DWORD valueIndex = 0;
if (!Name)
{
Name = (PCWSTR) L"";
}
for (valueIndex=0; valueIndex<hDbNode->ValuesLen; valueIndex++)
{
if (LwRtlWC16StringIsEqual(Name, hDbNode->Values[valueIndex]->Name, FALSE))
{
bFoundValue = TRUE;
break;
}
}
if (bFoundValue)
{
if (hDbNode->Values[valueIndex]->Data)
{
LWREG_SAFE_FREE_MEMORY(hDbNode->Values[valueIndex]->Data);
hDbNode->Values[valueIndex]->DataLen = 0;
bValueDeleted = TRUE;
}
if (hDbNode->Values[valueIndex]->Attributes.ValueType == 0)
{
if (valueIndex+1 < hDbNode->ValuesLen)
{
memmove(
&hDbNode->Values[valueIndex],
&hDbNode->Values[valueIndex+1],
(hDbNode->ValuesLen - valueIndex - 1) * sizeof(PMEMREG_VALUE));
}
hDbNode->Values[hDbNode->ValuesLen-1] = NULL;
hDbNode->ValuesLen--;
if (hDbNode->ValuesLen == 0)
{
LWREG_SAFE_FREE_MEMORY(hDbNode->Values);
hDbNode->Values = NULL;
}
}
else
{
if (!bValueDeleted)
{
status = STATUS_CANNOT_DELETE;
}
}
}
else
{
status = STATUS_OBJECT_NAME_NOT_FOUND;
}
return status;
}
static
NTSTATUS
SrvProtocolProcessCandidateTree2(
PVOID pKey,
PVOID pData,
PVOID pUserData,
PBOOLEAN pbContinue
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PLWIO_SRV_TREE_2 pTree = (PLWIO_SRV_TREE_2)pData;
PSRV_PROTOCOL_CONNECTION_ENUM_QUERY pConnectionEnumQuery =
(PSRV_PROTOCOL_CONNECTION_ENUM_QUERY)pUserData;
BOOLEAN bInTreeLock = FALSE;
if (pConnectionEnumQuery->pwszShareName)
{
if (!LwRtlWC16StringIsEqual(pConnectionEnumQuery->pwszShareName,
pTree->pShareInfo->pwszName,
FALSE))
{
pTree = NULL;
}
}
if (pTree)
{
if (pConnectionEnumQuery->iEntryIndex < pConnectionEnumQuery->iResumeIndex)
{
pConnectionEnumQuery->iEntryIndex++;
pTree = NULL; // Skip
}
}
if (pTree)
{
ULONG ulBytesUsed = 0;
ULONG ulConnId = 0;
ULONG ulShareType = 0;
ULONG ulTotalOpenFileCount = 0;
ULONG ulTotalNumUsers = 0;
ULONG ulConnectedTime = 0;
PWSTR pwszUserName = NULL;
PWSTR pwszNetName = NULL;
PLWIO_SRV_SESSION_2 pSession = pTree->pSession;
LWIO_LOCK_RWMUTEX_SHARED(bInTreeLock, &pTree->mutex);
ulConnId = pTree->resource.ulResourceId;
ulShareType = (ULONG)pTree->pShareInfo->Service;
if (pConnectionEnumQuery->ulInfoLevel == 1)
{
ulTotalOpenFileCount = pTree->ulNumOpenFiles;
/*
* There's only one user per connection in user-level security
*/
ulTotalNumUsers = 1;
ulConnectedTime = (pConnectionEnumQuery->llCurTime -
pSession->llBirthTime)
/WIRE_FACTOR_SECS_TO_HUNDREDS_OF_NANOSECS;
pwszUserName = pSession->pwszClientPrincipalName;
if (!pConnectionEnumQuery->pwszShareName)
{
pwszNetName = pTree->pShareInfo->pwszName;
}
else
{
pwszNetName = pConnectionEnumQuery->pwszClientHost;
}
}
switch (pConnectionEnumQuery->ulInfoLevel)
{
case 0:
ntStatus = SrvProtocolProcessConnection_level_0(
ulConnId,
pConnectionEnumQuery->pBuffer,
pConnectionEnumQuery->ulBufferSize,
&ulBytesUsed);
break;
case 1:
ntStatus = SrvProtocolProcessSession_level_1(
ulConnId,
ulShareType,
ulTotalOpenFileCount,
ulTotalNumUsers,
ulConnectedTime,
pwszUserName,
pwszNetName,
pConnectionEnumQuery->pBuffer,
pConnectionEnumQuery->ulBufferSize,
&ulBytesUsed);
break;
default:
ntStatus = STATUS_INVALID_INFO_CLASS;
break;
}
BAIL_ON_NT_STATUS(ntStatus);
if (pConnectionEnumQuery->ulEntriesRead > 0 &&
(pConnectionEnumQuery->ulPreferredMaxLength <
pConnectionEnumQuery->ulBytesUsed + ulBytesUsed))
{
ntStatus = STATUS_END_OF_FILE;
BAIL_ON_NT_STATUS(ntStatus);
}
pConnectionEnumQuery->pBuffer += ulBytesUsed;
pConnectionEnumQuery->ulBufferSize -= ulBytesUsed;
pConnectionEnumQuery->ulBytesUsed += ulBytesUsed;
pConnectionEnumQuery->iEntryIndex++;
pConnectionEnumQuery->ulEntriesRead++;
}
*pbContinue = TRUE;
cleanup:
LWIO_UNLOCK_RWMUTEX(bInTreeLock, &pTree->mutex);
return ntStatus;
error:
*pbContinue = FALSE;
goto cleanup;
}
DWORD
LsaPstoreDeletePasswordInfoW(
IN OPTIONAL PCWSTR DnsDomainName
)
{
DWORD dwError = 0;
int EE = 0;
PLSA_PSTORE_BACKEND_STATE backendState = NULL;
PWSTR defaultDnsDomainName = NULL;
BOOLEAN isDefaultDomain = FALSE;
PLSA_MACHINE_PASSWORD_INFO_W passwordInfo = NULL;
PCWSTR actualDnsDomainName = NULL;
dwError = LsaPstorepEnsureInitialized(&backendState);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
// Returns NULL if no default is found.
dwError = LsaPstoreGetDefaultDomainW(&defaultDnsDomainName);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
actualDnsDomainName = DnsDomainName ? DnsDomainName : defaultDnsDomainName;
if (defaultDnsDomainName)
{
if (DnsDomainName)
{
isDefaultDomain = LwRtlWC16StringIsEqual(
defaultDnsDomainName,
DnsDomainName,
TRUE);
}
else
{
isDefaultDomain = TRUE;
}
}
if (isDefaultDomain)
{
// Get information for plugin, but ignore error since best effort.
dwError = LsaPstorepBackendGetPasswordInfoW(
backendState,
defaultDnsDomainName,
&passwordInfo);
dwError = 0;
}
if (actualDnsDomainName)
{
dwError = LsaPstorepBackendDeletePasswordInfoW(
backendState,
actualDnsDomainName);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
}
if (isDefaultDomain)
{
// Ignore error as LSASS can recover
dwError = LsaPstoreSetDefaultDomainW(NULL);
dwError = 0;
// TODO-Use defaultDnsDomainName if no passwordInfo available.
dwError = LsaPstorepCallPluginDeletePasswordInfo(
passwordInfo ? &passwordInfo->Account : NULL);
GOTO_CLEANUP_ON_WINERROR_EE(dwError, EE);
}
cleanup:
LW_RTL_FREE(&defaultDnsDomainName);
LSA_PSTORE_FREE_PASSWORD_INFO_W(&passwordInfo);
LSA_PSTORE_LOG_LEAVE_ERROR_EE(dwError, EE);
return dwError;
}
