static
VOID
SrvFreeRenameState(
PSRV_RENAME_STATE_SMB_V1 pRenameState
)
{
if (pRenameState->pAcb && pRenameState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pRenameState->pAcb->AsyncCancelContext);
}
if (pRenameState->pDirEcpList)
{
IoRtlEcpListFree(&pRenameState->pDirEcpList);
}
if (pRenameState->pFileEcpList)
{
IoRtlEcpListFree(&pRenameState->pFileEcpList);
}
// TODO: Free the following if set
// pSecurityDescriptor;
// pSecurityQOS;
if (pRenameState->oldName.FileName)
{
SrvFreeMemory(pRenameState->oldName.FileName);
}
if (pRenameState->dirPath.FileName)
{
SrvFreeMemory(pRenameState->dirPath.FileName);
}
if (pRenameState->hDir)
{
IoCloseFile(pRenameState->hDir);
}
if (pRenameState->hFile)
{
IoCloseFile(pRenameState->hFile);
}
if (pRenameState->pData)
{
SrvFreeMemory(pRenameState->pData);
}
if (pRenameState->pMutex)
{
pthread_mutex_destroy(&pRenameState->mutex);
}
SrvFreeMemory(pRenameState);
}
static
VOID
SrvFreeCheckdirState(
PSRV_CHECKDIR_STATE_SMB_V1 pCheckdirState
)
{
if (pCheckdirState->pAcb && pCheckdirState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pCheckdirState->pAcb->AsyncCancelContext);
}
if (pCheckdirState->pEcpList)
{
IoRtlEcpListFree(&pCheckdirState->pEcpList);
}
// TODO: Free the following if set
// pSecurityDescriptor;
// pSecurityQOS;
SRV_FREE_UNICODE_STRING(&pCheckdirState->fileName.Name);
if (pCheckdirState->hFile)
{
IoCloseFile(pCheckdirState->hFile);
}
if (pCheckdirState->pMutex)
{
pthread_mutex_destroy(&pCheckdirState->mutex);
}
SrvFreeMemory(pCheckdirState);
}
static
VOID
SrvFinderFreeSearchSpace(
IN PSRV_SEARCH_SPACE pSearchSpace
)
{
if (pSearchSpace->pMutex)
{
pthread_mutex_destroy(&pSearchSpace->mutex);
}
if (pSearchSpace->hFile)
{
IoCloseFile(pSearchSpace->hFile);
}
if (pSearchSpace->pFileInfo)
{
SrvFreeMemory(pSearchSpace->pFileInfo);
}
if (pSearchSpace->pwszSearchPattern)
{
LwIoFreeMemory(pSearchSpace->pwszSearchPattern);
}
SrvFreeMemory(pSearchSpace);
}
static
VOID
SrvTree2Free(
PLWIO_SRV_TREE_2 pTree
)
{
LWIO_LOG_DEBUG("Freeing tree [object:0x%x][tid:%u]",
pTree,
pTree->ulTid);
// Cannot be in the parent since parent would have a reference.
LWIO_ASSERT(!SrvTree2IsInParent_inlock(pTree));
if (pTree->pMutex)
{
pthread_rwlock_destroy(&pTree->mutex);
pTree->pMutex = NULL;
}
if (pTree->pFileCollection)
{
LwRtlRBTreeFree(pTree->pFileCollection);
}
if (pTree->hFile)
{
IoCloseFile(pTree->hFile);
}
if (pTree->pShareInfo)
{
SrvShareReleaseInfo(pTree->pShareInfo);
}
if (pTree->resource.ulResourceId)
{
PSRV_RESOURCE pResource = NULL;
SrvElementsUnregisterResource(pTree->resource.ulResourceId,
&pResource);
pTree->resource.ulResourceId = 0;
}
// Release parent at the end
if (pTree->pSession)
{
SrvSession2Release(pTree->pSession);
}
SrvFreeMemory(pTree);
}
static
VOID
SrvFreeOpenState(
PSRV_OPEN_STATE_SMB_V1 pOpenState
)
{
if (pOpenState->pAcb && pOpenState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pOpenState->pAcb->AsyncCancelContext);
}
if (pOpenState->pEcpList)
{
IoRtlEcpListFree(&pOpenState->pEcpList);
}
// TODO: Free the following if set
// pSecurityDescriptor;
// pSecurityQOS;
if (pOpenState->pFilename)
{
SRV_FREE_UNICODE_STRING(&pOpenState->pFilename->Name);
SrvFreeMemory(pOpenState->pFilename);
}
if (pOpenState->hFile)
{
IoCloseFile(pOpenState->hFile);
}
if (pOpenState->pFile)
{
SrvFileResetOplockState(pOpenState->pFile);
SrvFileRundown(pOpenState->pFile);
SrvFileRelease(pOpenState->pFile);
}
if (pOpenState->pTree)
{
SrvTreeRelease(pOpenState->pTree);
}
if (pOpenState->pMutex)
{
pthread_mutex_destroy(&pOpenState->mutex);
}
SrvFreeMemory(pOpenState);
}
static
VOID
SrvTreeFree(
PLWIO_SRV_TREE pTree
)
{
LWIO_LOG_DEBUG("Freeing tree [object:0x%x][tid:%u]",
pTree,
pTree->tid);
if (pTree->pMutex)
{
pthread_rwlock_destroy(&pTree->mutex);
pTree->pMutex = NULL;
}
if (pTree->pFileCollection)
{
LwRtlRBTreeFree(pTree->pFileCollection);
}
if (pTree->pAsyncStateCollection)
{
LwRtlRBTreeFree(pTree->pAsyncStateCollection);
}
if (pTree->hFile)
{
IoCloseFile(pTree->hFile);
}
if (pTree->pShareInfo)
{
SrvShareReleaseInfo(pTree->pShareInfo);
}
SrvFreeMemory(pTree);
}
static
NTSTATUS
SrvCreateDefaultSharePath(
PWSTR pwszDefaultSharePath
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSECURITY_DESCRIPTOR_RELATIVE pRelSecDesc = NULL;
IO_FILE_HANDLE hFile = NULL;
IO_STATUS_BLOCK ioStatusBlock = {0};
IO_FILE_NAME filename = {0};
PIO_CREATE_SECURITY_CONTEXT pSecContext = NULL;
ntStatus = SrvBuildDefaultShareSID(&pRelSecDesc);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = IoSecurityCreateSecurityContextFromUidGid(
&pSecContext,
0,
0,
NULL);
BAIL_ON_NT_STATUS(ntStatus);
filename.FileName = pwszDefaultSharePath;
ntStatus = IoCreateFile(
&hFile,
NULL,
&ioStatusBlock,
pSecContext,
&filename,
pRelSecDesc,
NULL, /* Security QOS */
FILE_LIST_DIRECTORY | FILE_ADD_SUBDIRECTORY,
0, /* Allocation Size */
FILE_ATTRIBUTE_NORMAL, /* File Attributes */
0, /* No Sharing */
FILE_OPEN_IF,
FILE_DIRECTORY_FILE,
NULL, /* Extended Attributes */
0, /* EA Length */
NULL); /* ECP List */
BAIL_ON_NT_STATUS(ntStatus);
cleanup:
if (hFile)
{
IoCloseFile(hFile);
}
if (pRelSecDesc)
{
SrvFreeMemory(pRelSecDesc);
}
IoSecurityDereferenceSecurityContext(&pSecContext);
return ntStatus;
error:
goto cleanup;
}
NTSTATUS
SrvFinderCreateSearchSpace(
IN IO_FILE_HANDLE hRootFileHandle,
IN PSRV_SHARE_INFO pShareInfo,
IN PIO_CREATE_SECURITY_CONTEXT pIoSecurityContext,
IN HANDLE hFinderRepository,
IN PWSTR pwszFilesystemPath,
IN PWSTR pwszSearchPattern,
IN SMB_FILE_ATTRIBUTES usSearchAttrs,
IN USHORT usFlags,
IN ULONG ulSearchStorageType,
IN SMB_INFO_LEVEL infoLevel,
IN BOOLEAN bUseLongFilenames,
IN ACCESS_MASK accessMask,
OUT PHANDLE phFinder,
OUT PUSHORT pusSearchId
)
{
NTSTATUS ntStatus = 0;
IO_FILE_HANDLE hFile = NULL;
IO_STATUS_BLOCK ioStatusBlock = {0};
IO_FILE_NAME fileName = {0};
PVOID pSecurityDescriptor = NULL;
PVOID pSecurityQOS = NULL;
PSRV_FINDER_REPOSITORY pFinderRepository = NULL;
PSRV_SEARCH_SPACE pSearchSpace = NULL;
USHORT usCandidateSearchId = 0;
BOOLEAN bFound = FALSE;
BOOLEAN bInLock = FALSE;
PIO_ECP_LIST pEcpList = NULL;
FILE_CREATE_OPTIONS createOptions = 0;
pFinderRepository = (PSRV_FINDER_REPOSITORY)hFinderRepository;
fileName.RootFileHandle = hRootFileHandle;
ntStatus = LwRtlUnicodeStringInitEx(&fileName.Name, pwszFilesystemPath);
BAIL_ON_NT_STATUS(ntStatus);
if (pShareInfo->Flags & SHARE_INFO_FLAG_ABE_ENABLED)
{
ntStatus = IoRtlEcpListAllocate(&pEcpList);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvIoPrepareAbeEcpList(pEcpList);
BAIL_ON_NT_STATUS(ntStatus);
}
if (usFlags & SMB_FIND_WITH_BACKUP_INTENT)
{
createOptions |= FILE_OPEN_FOR_BACKUP_INTENT;
}
ntStatus = SrvIoCreateFile(
pShareInfo,
&hFile,
NULL,
&ioStatusBlock,
pIoSecurityContext,
&fileName,
pSecurityDescriptor,
pSecurityQOS,
accessMask,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
FILE_OPEN,
createOptions,
NULL, /* EA Buffer */
0, /* EA Length */
pEcpList);
BAIL_ON_NT_STATUS(ntStatus);
LWIO_LOCK_MUTEX(bInLock, &pFinderRepository->mutex);
usCandidateSearchId = pFinderRepository->usNextSearchId;
do
{
PSRV_SEARCH_SPACE pSearchSpace = NULL;
// 0 is not a valid search id
if (!usCandidateSearchId || (usCandidateSearchId == UINT16_MAX))
{
usCandidateSearchId = 1;
}
ntStatus = LwRtlRBTreeFind(
pFinderRepository->pSearchSpaceCollection,
&usCandidateSearchId,
(PVOID*)&pSearchSpace);
if (ntStatus == STATUS_NOT_FOUND)
{
ntStatus = STATUS_SUCCESS;
bFound = TRUE;
}
else
{
usCandidateSearchId++;
}
BAIL_ON_NT_STATUS(ntStatus);
} while ((usCandidateSearchId != pFinderRepository->usNextSearchId) && !bFound);
if (!bFound)
{
ntStatus = STATUS_TOO_MANY_OPENED_FILES;
BAIL_ON_NT_STATUS(ntStatus);
}
ntStatus = SrvAllocateMemory(
sizeof(SRV_SEARCH_SPACE),
(PVOID*)&pSearchSpace);
BAIL_ON_NT_STATUS(ntStatus);
pSearchSpace->refCount = 1;
pthread_mutex_init(&pSearchSpace->mutex, NULL);
pSearchSpace->pMutex = &pSearchSpace->mutex;
pSearchSpace->usSearchId = usCandidateSearchId;
ntStatus = LwRtlRBTreeAdd(
pFinderRepository->pSearchSpaceCollection,
&pSearchSpace->usSearchId,
pSearchSpace);
BAIL_ON_NT_STATUS(ntStatus);
pSearchSpace->hFile = hFile;
hFile = NULL;
pSearchSpace->infoLevel = infoLevel;
pSearchSpace->usSearchAttrs = usSearchAttrs;
pSearchSpace->ulSearchStorageType = ulSearchStorageType;
pSearchSpace->bUseLongFilenames = bUseLongFilenames;
ntStatus = SrvAllocateStringW(
pwszSearchPattern,
&pSearchSpace->pwszSearchPattern);
BAIL_ON_NT_STATUS(ntStatus);
InterlockedIncrement(&pSearchSpace->refCount);
pFinderRepository->usNextSearchId = usCandidateSearchId + 1;
*phFinder = pSearchSpace;
*pusSearchId = usCandidateSearchId;
cleanup:
LWIO_UNLOCK_MUTEX(bInLock, &pFinderRepository->mutex);
if (pEcpList)
{
IoRtlEcpListFree(&pEcpList);
}
return ntStatus;
error:
*phFinder = NULL;
*pusSearchId = 0;
if (pSearchSpace)
{
SrvFinderReleaseSearchSpace(pSearchSpace);
}
if (hFile)
{
IoCloseFile(hFile);
}
goto cleanup;
}
static
VOID
SrvFreeDeleteState(
PSRV_DELETE_STATE_SMB_V1 pDeleteState
)
{
if (pDeleteState->pAcb && pDeleteState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pDeleteState->pAcb->AsyncCancelContext);
}
if (pDeleteState->pEcpList)
{
IoRtlEcpListFree(&pDeleteState->pEcpList);
}
if (pDeleteState->hSearchSpace)
{
NTSTATUS ntStatus2 = 0;
ntStatus2 = SrvFinderCloseSearchSpace(
pDeleteState->pSession->hFinderRepository,
pDeleteState->usSearchId);
if (ntStatus2)
{
LWIO_LOG_ERROR("Failed to close search space [Id:%d][code:%d]",
pDeleteState->usSearchId,
ntStatus2);
}
SrvFinderReleaseSearchSpace(pDeleteState->hSearchSpace);
}
if (pDeleteState->pTree)
{
SrvTreeRelease(pDeleteState->pTree);
}
if (pDeleteState->pSession)
{
SrvSessionRelease(pDeleteState->pSession);
}
if (pDeleteState->pwszFilesystemPath)
{
SrvFreeMemory(pDeleteState->pwszFilesystemPath);
}
if (pDeleteState->pwszSearchPattern2)
{
SrvFreeMemory(pDeleteState->pwszSearchPattern2);
}
if (pDeleteState->hFile)
{
IoCloseFile(pDeleteState->hFile);
}
if (pDeleteState->pData)
{
SrvFreeMemory(pDeleteState->pData);
}
SRV_FREE_UNICODE_STRING(&pDeleteState->fileName.Name);
if (pDeleteState->pMutex)
{
pthread_mutex_destroy(&pDeleteState->mutex);
}
SrvFreeMemory(pDeleteState);
}
static
NTSTATUS
SrvDeleteSingleFile(
PSRV_EXEC_CONTEXT pExecContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSRV_PROTOCOL_EXEC_CONTEXT pCtxProtocol = pExecContext->pProtocolContext;
PSRV_EXEC_CONTEXT_SMB_V1 pCtxSmb1 = pCtxProtocol->pSmb1Context;
PSRV_DELETE_STATE_SMB_V1 pDeleteState = NULL;
wchar16_t wszDot[] = {'.', 0};
pDeleteState = (PSRV_DELETE_STATE_SMB_V1)pCtxSmb1->hState;
if (!pDeleteState->bPendingCreate)
{
if ((SMBWc16sCmp(pDeleteState->pwszSearchPattern2, wszDot) == 0))
{
ntStatus = STATUS_OBJECT_NAME_INVALID;
BAIL_ON_NT_STATUS(ntStatus);
}
ntStatus = SrvBuildFilePath(
pDeleteState->pwszFilesystemPath,
pDeleteState->pwszSearchPattern2,
&pDeleteState->fileName.Name);
BAIL_ON_NT_STATUS(ntStatus);
pDeleteState->fileName.RootFileHandle = pDeleteState->pTree->hFile;
SrvPrepareDeleteStateAsync(pDeleteState, pExecContext);
pDeleteState->bPendingCreate = TRUE;
ntStatus = SrvIoCreateFile(
pDeleteState->pTree->pShareInfo,
&pDeleteState->hFile,
pDeleteState->pAcb,
&pDeleteState->ioStatusBlock,
pDeleteState->pSession->pIoSecurityContext,
&pDeleteState->fileName,
pDeleteState->pSecurityDescriptor,
pDeleteState->pSecurityQOS,
DELETE,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_NO_SHARE,
FILE_OPEN,
FILE_DELETE_ON_CLOSE|FILE_NON_DIRECTORY_FILE,
NULL,
0,
pDeleteState->pEcpList);
BAIL_ON_NT_STATUS(ntStatus);
SrvReleaseDeleteStateAsync(pDeleteState); // completed sync
}
pDeleteState->bPendingCreate = FALSE;
ntStatus = pDeleteState->ioStatusBlock.Status;
BAIL_ON_NT_STATUS(ntStatus);
if (pDeleteState->hFile)
{
IoCloseFile(pDeleteState->hFile);
pDeleteState->hFile = NULL;
}
cleanup:
return ntStatus;
error:
/* Have to do some error mapping here to match WinXP */
switch (ntStatus)
{
case STATUS_PENDING:
case STATUS_ACCESS_DENIED:
case STATUS_FILE_IS_A_DIRECTORY:
case STATUS_SHARING_VIOLATION:
case STATUS_OBJECT_NAME_INVALID:
break;
case STATUS_OBJECT_NAME_NOT_FOUND:
case STATUS_NO_SUCH_FILE:
ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
break;
default:
ntStatus = STATUS_CANNOT_DELETE;
break;
}
goto cleanup;
}
static
NTSTATUS
SrvDeleteFiles(
PSRV_EXEC_CONTEXT pExecContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSRV_PROTOCOL_EXEC_CONTEXT pCtxProtocol = pExecContext->pProtocolContext;
PSRV_EXEC_CONTEXT_SMB_V1 pCtxSmb1 = pCtxProtocol->pSmb1Context;
PSRV_DELETE_STATE_SMB_V1 pDeleteState = NULL;
PWSTR pwszFilename = NULL;
wchar16_t wszDot[] = {'.', 0};
pDeleteState = (PSRV_DELETE_STATE_SMB_V1)pCtxSmb1->hState;
if (pDeleteState->bPendingCreate)
{
pDeleteState->bPendingCreate = FALSE;
ntStatus = pDeleteState->ioStatusBlock.Status;
BAIL_ON_NT_STATUS(ntStatus);
IoCloseFile(pDeleteState->hFile);
pDeleteState->hFile = NULL;
pDeleteState->bDeletedFile = TRUE;
pDeleteState->iResult++;
}
for (;;)
{
for ( ;
pDeleteState->iResult < pDeleteState->usSearchResultCount;
pDeleteState->iResult++)
{
BOOLEAN bEligibleForDelete = FALSE;
FILE_ATTRIBUTES ulIncludeAttributes = 0;
if (!pDeleteState->pResult)
{
pDeleteState->pResult =
(PSMB_FIND_FILE_BOTH_DIRECTORY_INFO_HEADER)pDeleteState->pData;
}
else if (pDeleteState->pResult->NextEntryOffset)
{
PBYTE pTmp = (PBYTE)pDeleteState->pResult +
pDeleteState->pResult->NextEntryOffset;
pDeleteState->pResult =
(PSMB_FIND_FILE_BOTH_DIRECTORY_INFO_HEADER)pTmp;
}
else
{
ntStatus = STATUS_INTERNAL_ERROR;
BAIL_ON_NT_STATUS(ntStatus);
}
if (pwszFilename)
{
SrvFreeMemory(pwszFilename);
pwszFilename = NULL;
}
ulIncludeAttributes =
SMB_FILE_ATTRIBUTES_TO_NATIVE(pDeleteState->usSearchAttributes);
bEligibleForDelete =
(IsSetFlag(pDeleteState->pResult->FileAttributes,
ulIncludeAttributes & (FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM))) ||
(!IsSetFlag(pDeleteState->pResult->FileAttributes,
(FILE_ATTRIBUTE_DIRECTORY |
FILE_ATTRIBUTE_HIDDEN |
FILE_ATTRIBUTE_SYSTEM)));
if (!bEligibleForDelete)
{
if (!pDeleteState->bPathHasWildCards)
{
if ((SMBWc16sCmp(pDeleteState->pwszSearchPattern2, wszDot) == 0))
{
ntStatus = STATUS_OBJECT_NAME_INVALID;
}
else if (IsSetFlag(pDeleteState->pResult->FileAttributes,
FILE_ATTRIBUTE_DIRECTORY))
{
ntStatus = STATUS_FILE_IS_A_DIRECTORY;
}
else
{
ntStatus = STATUS_NO_SUCH_FILE;
}
BAIL_ON_NT_STATUS(ntStatus);
}
continue;
}
if (pDeleteState->bUseLongFilenames)
{
ntStatus = SrvAllocateMemory(
pDeleteState->pResult->FileNameLength + sizeof(wchar16_t),
(PVOID*)&pwszFilename);
BAIL_ON_NT_STATUS(ntStatus);
memcpy((PBYTE)pwszFilename,
(PBYTE)pDeleteState->pResult->FileName,
pDeleteState->pResult->FileNameLength);
}
else
{
ntStatus = SrvAllocateMemory(
pDeleteState->pResult->ShortNameLength + sizeof(wchar16_t),
(PVOID*)&pwszFilename);
BAIL_ON_NT_STATUS(ntStatus);
memcpy((PBYTE)pwszFilename,
(PBYTE)pDeleteState->pResult->ShortName,
pDeleteState->pResult->ShortNameLength);
}
if (SMBWc16sCmp(pwszFilename, wszDot) == 0)
{
ntStatus = STATUS_OBJECT_NAME_INVALID;
BAIL_ON_NT_STATUS(ntStatus);
}
SRV_FREE_UNICODE_STRING(&pDeleteState->fileName.Name);
ntStatus = SrvBuildFilePath(
pDeleteState->pwszFilesystemPath,
pwszFilename,
&pDeleteState->fileName.Name);
BAIL_ON_NT_STATUS(ntStatus);
pDeleteState->fileName.RootFileHandle = pDeleteState->pTree->hFile;
SrvPrepareDeleteStateAsync(pDeleteState, pExecContext);
pDeleteState->bPendingCreate = TRUE;
ntStatus = SrvIoCreateFile(
pDeleteState->pTree->pShareInfo,
&pDeleteState->hFile,
pDeleteState->pAcb,
&pDeleteState->ioStatusBlock,
pDeleteState->pSession->pIoSecurityContext,
&pDeleteState->fileName,
pDeleteState->pSecurityDescriptor,
pDeleteState->pSecurityQOS,
DELETE,
0,
FILE_ATTRIBUTE_NORMAL,
FILE_NO_SHARE,
FILE_OPEN,
FILE_DELETE_ON_CLOSE|FILE_NON_DIRECTORY_FILE,
NULL,
0,
pDeleteState->pEcpList);
BAIL_ON_NT_STATUS(ntStatus);
SrvReleaseDeleteStateAsync(pDeleteState); // completed sync
pDeleteState->bPendingCreate = FALSE;
IoCloseFile(pDeleteState->hFile);
pDeleteState->hFile = NULL;
pDeleteState->bDeletedFile = TRUE;
}
if (pDeleteState->bEndOfSearch)
{
break;
}
if (pDeleteState->pData)
{
SrvFreeMemory(pDeleteState->pData);
pDeleteState->pData = NULL;
}
pDeleteState->iResult = 0;
pDeleteState->pResult = NULL;
ntStatus = SrvFinderGetSearchResults(
pDeleteState->hSearchSpace,
FALSE, /* bReturnSingleEntry */
FALSE, /* bRestartScan */
10, /* Desired search count */
UINT16_MAX, /* Max data count */
pDeleteState->usDataOffset,
&pDeleteState->pData,
&pDeleteState->usDataLen,
&pDeleteState->usSearchResultCount,
&pDeleteState->bEndOfSearch);
if (ntStatus == STATUS_NO_MORE_MATCHES)
{
ntStatus = STATUS_ASSERTION_FAILURE;
BAIL_ON_NT_STATUS(ntStatus);
}
if (ntStatus == STATUS_NO_SUCH_FILE)
{
ntStatus = STATUS_SUCCESS;
break;
}
}
if (!pDeleteState->bDeletedFile)
{
if (pDeleteState->bPathHasWildCards)
{
ntStatus = STATUS_NO_SUCH_FILE;
}
else
{
ntStatus = STATUS_OBJECT_NAME_NOT_FOUND;
}
BAIL_ON_NT_STATUS(ntStatus);
}
cleanup:
if (pwszFilename)
{
SrvFreeMemory(pwszFilename);
}
return ntStatus;
error:
/* Have to do some error mapping here to match WinXP */
switch (ntStatus)
{
case STATUS_PENDING:
case STATUS_ACCESS_DENIED:
case STATUS_FILE_IS_A_DIRECTORY:
case STATUS_SHARING_VIOLATION:
case STATUS_OBJECT_NAME_NOT_FOUND:
case STATUS_OBJECT_NAME_INVALID:
case STATUS_NO_SUCH_FILE:
break;
default:
ntStatus = STATUS_CANNOT_DELETE;
break;
}
goto cleanup;
}
static
VOID
SrvFreeOpenState(
PSRV_OPEN_STATE_SMB_V1 pOpenState
)
{
if (pOpenState->pAcb && pOpenState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pOpenState->pAcb->AsyncCancelContext);
}
if (pOpenState->pEcpList)
{
IoRtlEcpListFree(&pOpenState->pEcpList);
}
// TODO: Free the following if set
// pSecurityDescriptor;
// pSecurityQOS;
if (pOpenState->pFilename)
{
if (pOpenState->pFilename->FileName)
{
SrvFreeMemory(pOpenState->pFilename->FileName);
}
SrvFreeMemory(pOpenState->pFilename);
}
if (pOpenState->hFile)
{
IoCloseFile(pOpenState->hFile);
}
if (pOpenState->bRemoveFileFromTree)
{
NTSTATUS ntStatus2 = 0;
SrvFileResetOplockState(pOpenState->pFile);
ntStatus2 = SrvTreeRemoveFile(
pOpenState->pTree,
pOpenState->pFile->fid);
if (ntStatus2)
{
LWIO_LOG_ERROR("Failed to remove file from tree [Tid:%d][Fid:%d][code:%d]",
pOpenState->pTree->tid,
pOpenState->pFile->fid,
ntStatus2);
}
}
if (pOpenState->pFile)
{
SrvFileRelease(pOpenState->pFile);
}
if (pOpenState->pTree)
{
SrvTreeRelease(pOpenState->pTree);
}
if (pOpenState->pMutex)
{
pthread_mutex_destroy(&pOpenState->mutex);
}
SrvFreeMemory(pOpenState);
}
