static
VOID
SrvNotifyStateFree(
PSRV_CHANGE_NOTIFY_STATE_SMB_V1 pNotifyState
)
{
if (pNotifyState->pAcb && pNotifyState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pNotifyState->pAcb->AsyncCancelContext);
}
if (pNotifyState->pConnection)
{
SrvConnectionRelease(pNotifyState->pConnection);
}
if (pNotifyState->pBuffer)
{
SrvFreeMemory(pNotifyState->pBuffer);
}
if (pNotifyState->pMutex)
{
pthread_mutex_destroy(&pNotifyState->mutex);
}
SrvFreeMemory(pNotifyState);
}
static
VOID
SrvExecuteFlushAsyncCB_SMB_V2(
PVOID pContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSRV_EXEC_CONTEXT pExecContext = (PSRV_EXEC_CONTEXT)pContext;
PSRV_PROTOCOL_EXEC_CONTEXT pProtocolContext = pExecContext->pProtocolContext;
PSRV_FLUSH_STATE_SMB_V2 pFlushState = NULL;
BOOLEAN bInLock = FALSE;
pFlushState =
(PSRV_FLUSH_STATE_SMB_V2)pProtocolContext->pSmb2Context->hState;
LWIO_LOCK_MUTEX(bInLock, &pFlushState->mutex);
if (pFlushState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(&pFlushState->pAcb->AsyncCancelContext);
}
pFlushState->pAcb = NULL;
LWIO_UNLOCK_MUTEX(bInLock, &pFlushState->mutex);
ntStatus = SrvProdConsEnqueue(gProtocolGlobals_SMB_V2.pWorkQueue, pContext);
if (ntStatus != STATUS_SUCCESS)
{
LWIO_LOG_ERROR("Failed to enqueue execution context [status:0x%x]",
ntStatus);
SrvReleaseExecContext(pExecContext);
}
}
VOID
SrvReleaseGetInfoStateAsync_SMB_V2(
PSRV_GET_INFO_STATE_SMB_V2 pGetInfoState
)
{
if (pGetInfoState->pAcb)
{
pGetInfoState->acb.Callback = NULL;
if (pGetInfoState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext = (PSRV_EXEC_CONTEXT)pGetInfoState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pGetInfoState->pAcb->CallbackContext = NULL;
}
if (pGetInfoState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pGetInfoState->pAcb->AsyncCancelContext);
}
pGetInfoState->pAcb = NULL;
}
}
static
VOID
SrvFreeGetInfoState_SMB_V2(
PSRV_GET_INFO_STATE_SMB_V2 pGetInfoState
)
{
if (pGetInfoState->pAcb && pGetInfoState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pGetInfoState->pAcb->AsyncCancelContext);
}
if (pGetInfoState->pData2)
{
SrvFreeMemory(pGetInfoState->pData2);
}
if (pGetInfoState->pFile)
{
SrvFile2Release(pGetInfoState->pFile);
}
if (pGetInfoState->pMutex)
{
pthread_mutex_destroy(&pGetInfoState->mutex);
}
SrvFreeMemory(pGetInfoState);
}
static
VOID
SrvReleaseOpenStateAsync(
PSRV_OPEN_STATE_SMB_V1 pOpenState
)
{
if (pOpenState->pAcb)
{
pOpenState->acb.Callback = NULL;
if (pOpenState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext = (PSRV_EXEC_CONTEXT)pOpenState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pOpenState->pAcb->CallbackContext = NULL;
}
if (pOpenState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pOpenState->pAcb->AsyncCancelContext);
}
pOpenState->pAcb = NULL;
}
}
static
VOID
SrvExecuteGetInfoAsyncCB_SMB_V2(
PVOID pContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSRV_EXEC_CONTEXT pExecContext = (PSRV_EXEC_CONTEXT)pContext;
PSRV_PROTOCOL_EXEC_CONTEXT pProtocolContext = pExecContext->pProtocolContext;
PSRV_GET_INFO_STATE_SMB_V2 pGetInfoState = NULL;
BOOLEAN bInLock = FALSE;
pGetInfoState =
(PSRV_GET_INFO_STATE_SMB_V2)pProtocolContext->pSmb2Context->hState;
LWIO_LOCK_MUTEX(bInLock, &pGetInfoState->mutex);
if (pGetInfoState->pAcb && pGetInfoState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(&pGetInfoState->pAcb->AsyncCancelContext);
}
pGetInfoState->pAcb = NULL;
LWIO_UNLOCK_MUTEX(bInLock, &pGetInfoState->mutex);
ntStatus = SrvProtocolExecute(pExecContext);
// (!NT_SUCCESS(ntStatus)) - Error has already been logged
SrvReleaseExecContext(pExecContext);
return;
}
static
VOID
SrvReleaseFlushStateAsync_SMB_V2(
PSRV_FLUSH_STATE_SMB_V2 pFlushState
)
{
if (pFlushState->pAcb)
{
pFlushState->acb.Callback = NULL;
if (pFlushState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext =
(PSRV_EXEC_CONTEXT)pFlushState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pFlushState->pAcb->CallbackContext = NULL;
}
if (pFlushState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pFlushState->pAcb->AsyncCancelContext);
}
pFlushState->pAcb = NULL;
}
}
VOID
SrvReleaseDeleteStateAsync(
PSRV_DELETE_STATE_SMB_V1 pDeleteState
)
{
if (pDeleteState->pAcb)
{
pDeleteState->acb.Callback = NULL;
if (pDeleteState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext = (PSRV_EXEC_CONTEXT)pDeleteState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pDeleteState->pAcb->CallbackContext = NULL;
}
if (pDeleteState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pDeleteState->pAcb->AsyncCancelContext);
}
pDeleteState->pAcb = NULL;
}
}
static
VOID
SrvReleaseRenameStateAsync(
PSRV_RENAME_STATE_SMB_V1 pRenameState
)
{
if (pRenameState->pAcb)
{
pRenameState->acb.Callback = NULL;
if (pRenameState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext =
(PSRV_EXEC_CONTEXT)pRenameState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pRenameState->pAcb->CallbackContext = NULL;
}
if (pRenameState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pRenameState->pAcb->AsyncCancelContext);
}
pRenameState->pAcb = NULL;
}
}
VOID
SrvReleaseNotifyStateAsync(
PSRV_CHANGE_NOTIFY_STATE_SMB_V1 pNotifyState
)
{
if (pNotifyState->pAcb)
{
pNotifyState->acb.Callback = NULL;
if (pNotifyState->pAcb->CallbackContext)
{
InterlockedDecrement(&pNotifyState->refCount);
pNotifyState->pAcb->CallbackContext = NULL;
}
if (pNotifyState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pNotifyState->pAcb->AsyncCancelContext);
}
pNotifyState->pAcb = NULL;
}
}
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
SrvReleaseCheckdirStateAsync(
PSRV_CHECKDIR_STATE_SMB_V1 pCheckdirState
)
{
if (pCheckdirState->pAcb)
{
pCheckdirState->acb.Callback = NULL;
if (pCheckdirState->pAcb->CallbackContext)
{
PSRV_EXEC_CONTEXT pExecContext = NULL;
pExecContext =
(PSRV_EXEC_CONTEXT)pCheckdirState->pAcb->CallbackContext;
SrvReleaseExecContext(pExecContext);
pCheckdirState->pAcb->CallbackContext = NULL;
}
if (pCheckdirState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pCheckdirState->pAcb->AsyncCancelContext);
}
pCheckdirState->pAcb = NULL;
}
}
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
SrvCancelNotifyState_SMB_V2_inlock(
PSRV_NOTIFY_STATE_SMB_V2 pNotifyState
)
{
if (pNotifyState->pAcb && pNotifyState->pAcb->AsyncCancelContext)
{
IoCancelAsyncCancelContext(pNotifyState->pAcb->AsyncCancelContext);
IoDereferenceAsyncCancelContext(
&pNotifyState->pAcb->AsyncCancelContext);
}
}
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
SrvFreeFlushState_SMB_V2(
PSRV_FLUSH_STATE_SMB_V2 pFlushState
)
{
if (pFlushState->pAcb && pFlushState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pFlushState->pAcb->AsyncCancelContext);
}
if (pFlushState->pFile)
{
SrvFile2Release(pFlushState->pFile);
}
if (pFlushState->pMutex)
{
pthread_mutex_destroy(&pFlushState->mutex);
}
SrvFreeMemory(pFlushState);
}
static
VOID
SrvNotifyAsyncCB(
PVOID pContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PSRV_EXEC_CONTEXT pExecContext = NULL;
BOOLEAN bInLock = FALSE;
PSRV_CHANGE_NOTIFY_STATE_SMB_V1 pNotifyState =
(PSRV_CHANGE_NOTIFY_STATE_SMB_V1)pContext;
LWIO_LOCK_MUTEX(bInLock, &pNotifyState->mutex);
if (pNotifyState->pAcb->AsyncCancelContext)
{
IoDereferenceAsyncCancelContext(
&pNotifyState->pAcb->AsyncCancelContext);
}
pNotifyState->pAcb = NULL;
LWIO_UNLOCK_MUTEX(bInLock, &pNotifyState->mutex);
ntStatus = SrvNotifyBuildExecContext(
pNotifyState,
&pExecContext);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvProdConsEnqueue(
gProtocolGlobals_SMB_V1.pWorkQueue,
pExecContext);
BAIL_ON_NT_STATUS(ntStatus);
pExecContext = NULL;
cleanup:
LWIO_UNLOCK_MUTEX(bInLock, &pNotifyState->mutex);
if (pNotifyState)
{
SrvNotifyStateRelease(pNotifyState);
}
if (pExecContext)
{
SrvReleaseExecContext(pExecContext);
}
return;
error:
LWIO_LOG_ERROR("Error: Failed processing change notify call back "
"[status:0x%x]",
ntStatus);
// TODO: indicate error on file handle somehow
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
IopContinueAsyncCloseFile(
IN PIO_FILE_OBJECT FileHandle,
IN OPTIONAL PIO_ASYNC_COMPLETE_CALLBACK Callback,
IN OPTIONAL PVOID CallbackContext,
OUT PIO_STATUS_BLOCK IoStatusBlock
)
{
NTSTATUS status = STATUS_SUCCESS;
int EE = 0;
PIRP pIrp = NULL;
IO_ASYNC_CONTROL_BLOCK asyncControlBlock = { 0 };
PIO_ASYNC_CONTROL_BLOCK useAsyncControlBlock = NULL;
BOOLEAN isOpen = FALSE;
//
// If the create never completed successfully, we do not want
// to send a CLOSE IRP.
//
// TODO -- There is probably still a small race window
// wrt create and device rundown. The fix may involve
// changing when IopFileObjectRemoveDispatched() is called
// from IopIrpCompleteInternal() so that it is called
// after the switch on the IRP type.
IopFileObjectLock(FileHandle);
isOpen = IsSetFlag(FileHandle->Flags, FILE_OBJECT_FLAG_CREATE_DONE);
IopFileObjectUnlock(FileHandle);
if (!isOpen)
{
status = STATUS_SUCCESS;
GOTO_CLEANUP_EE(EE);
}
//
// The file was actually opened, so do rest of close cleanup.
//
status = IopFileObjectGetCloseIrp(FileHandle, &pIrp);
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
status = IopIrpAttach(pIrp, IRP_TYPE_CLOSE, FileHandle);
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
if (Callback)
{
asyncControlBlock.Callback = Callback;
asyncControlBlock.CallbackContext = CallbackContext;
useAsyncControlBlock = &asyncControlBlock;
}
status = IopIrpDispatch(
pIrp,
useAsyncControlBlock,
IoStatusBlock);
if (STATUS_PENDING == status)
{
IoDereferenceAsyncCancelContext(&asyncControlBlock.AsyncCancelContext);
}
GOTO_CLEANUP_ON_STATUS_EE(status, EE);
cleanup:
IopIrpDereference(&pIrp);
if (!useAsyncControlBlock && IoStatusBlock && (STATUS_PENDING != status))
{
IO_STATUS_BLOCK ioStatusBlock = { 0 };
ioStatusBlock.Status = status;
*IoStatusBlock = ioStatusBlock;
}
IO_LOG_LEAVE_ON_STATUS_EE(status, EE);
return status;
}
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);
}
