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
LwNtCreateNamedPipeComplete(
PVOID pParam
)
{
PCREATEPIPE_CONTEXT pContext = (PCREATEPIPE_CONTEXT) pParam;
pContext->pChain->Callback(pContext->pChain->CallbackContext);
IoRtlEcpListFree(&pContext->pEcpList);
RTL_FREE(&pContext);
}
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);
}
NTSTATUS
LwNtCreateNamedPipeFile(
OUT PIO_FILE_HANDLE FileHandle,
IN OUT OPTIONAL PIO_ASYNC_CONTROL_BLOCK AsyncControlBlock,
OUT PIO_STATUS_BLOCK IoStatusBlock,
IN PIO_FILE_NAME FileName,
IN OPTIONAL PVOID SecurityDescriptor, // TBD
IN OPTIONAL PVOID SecurityQualityOfService, // TBD
IN ACCESS_MASK DesiredAccess,
IN FILE_SHARE_FLAGS ShareAccess,
IN FILE_CREATE_DISPOSITION CreateDisposition,
IN FILE_CREATE_OPTIONS CreateOptions,
IN FILE_PIPE_TYPE_MASK NamedPipeType,
IN FILE_PIPE_READ_MODE_MASK ReadMode,
IN FILE_PIPE_COMPLETION_MODE_MASK CompletionMode,
IN ULONG MaximumInstances,
IN ULONG InboundQuota,
IN ULONG OutboundQuota,
IN OPTIONAL PLONG64 DefaultTimeout
)
{
NTSTATUS status = 0;
int EE = 0;
PIO_ECP_LIST ecpList = NULL;
PIO_ECP_NAMED_PIPE pPipeParams = NULL;
PCREATEPIPE_CONTEXT pContext = NULL;
status = RTL_ALLOCATE(&pPipeParams, IO_ECP_NAMED_PIPE, sizeof(*pPipeParams));
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
status = IoRtlEcpListAllocate(&ecpList);
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
pPipeParams->NamedPipeType = NamedPipeType;
pPipeParams->ReadMode = ReadMode;
pPipeParams->CompletionMode = CompletionMode;
pPipeParams->MaximumInstances = MaximumInstances;
pPipeParams->InboundQuota = InboundQuota;
pPipeParams->OutboundQuota = OutboundQuota;
if (DefaultTimeout)
{
pPipeParams->DefaultTimeout = *DefaultTimeout;
pPipeParams->HaveDefaultTimeout = TRUE;
}
status = IoRtlEcpListInsert(ecpList,
IO_ECP_TYPE_NAMED_PIPE,
pPipeParams,
sizeof(*pPipeParams),
LwRtlMemoryFree);
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
pPipeParams = NULL;
if (AsyncControlBlock)
{
status = RTL_ALLOCATE(&pContext, CREATEPIPE_CONTEXT, sizeof(*pContext));
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
pContext->pEcpList = ecpList;
pContext->pChain = AsyncControlBlock;
pContext->AsyncControl.Callback = LwNtCreateNamedPipeComplete;
pContext->AsyncControl.CallbackContext = pContext;
AsyncControlBlock = &pContext->AsyncControl;
}
status = NtCreateFile(
FileHandle,
AsyncControlBlock,
IoStatusBlock,
FileName,
SecurityDescriptor,
SecurityQualityOfService,
DesiredAccess,
0,
0,
ShareAccess,
CreateDisposition,
CreateOptions,
NULL,
0,
ecpList,
NULL);
if (pContext)
{
pContext->pChain->AsyncCancelContext = pContext->AsyncControl.AsyncCancelContext;
}
cleanup:
if (status != STATUS_PENDING)
{
if (pContext)
{
IoRtlEcpListFree(&pContext->pEcpList);
RTL_FREE(&pContext);
}
else
{
IoRtlEcpListFree(&ecpList);
}
IoStatusBlock->Status = status;
RTL_FREE(&pPipeParams);
}
LOG_LEAVE_IF_STATUS_EE(status, EE);
return status;
}
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
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);
}
