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
SrvTree2FileRelease(
PVOID pFile
)
{
SrvFile2Release((PLWIO_SRV_FILE_2)pFile);
}
static
VOID
SrvFreeNotifyRequestState_SMB_V2(
PSRV_NOTIFY_REQUEST_STATE_SMB_V2 pNotifyRequestState
)
{
if (pNotifyRequestState->pFile)
{
SrvFile2Release(pNotifyRequestState->pFile);
}
SrvFreeMemory(pNotifyRequestState);
}
static
VOID
SrvTree2RundownFileList(
PLWIO_SRV_FILE_2 pRundownList
)
{
while (pRundownList)
{
PLWIO_SRV_FILE_2 pFile = pRundownList;
pRundownList = pFile->pRundownNext;
SrvFile2Rundown(pFile);
SrvFile2Release(pFile);
}
}
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);
}
NTSTATUS
SrvProcessFlush_SMB_V2(
PSRV_EXEC_CONTEXT pExecContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PLWIO_SRV_CONNECTION pConnection = pExecContext->pConnection;
PSRV_PROTOCOL_EXEC_CONTEXT pCtxProtocol = pExecContext->pProtocolContext;
PSRV_EXEC_CONTEXT_SMB_V2 pCtxSmb2 = pCtxProtocol->pSmb2Context;
PSRV_FLUSH_STATE_SMB_V2 pFlushState = NULL;
PLWIO_SRV_SESSION_2 pSession = NULL;
PLWIO_SRV_TREE_2 pTree = NULL;
PLWIO_SRV_FILE_2 pFile = NULL;
BOOLEAN bInLock = FALSE;
pFlushState = (PSRV_FLUSH_STATE_SMB_V2)pCtxSmb2->hState;
if (pFlushState)
{
InterlockedIncrement(&pFlushState->refCount);
}
else
{
ULONG iMsg = pCtxSmb2->iMsg;
PSRV_MESSAGE_SMB_V2 pSmbRequest = &pCtxSmb2->pRequests[iMsg];
PSMB2_FID pFid = NULL; // Do not free
ntStatus = SrvConnection2FindSession_SMB_V2(
pCtxSmb2,
pConnection,
pSmbRequest->pHeader->ullSessionId,
&pSession);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvSetStatSession2Info(pExecContext, pSession);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvSession2FindTree_SMB_V2(
pCtxSmb2,
pSession,
pSmbRequest->pHeader->ulTid,
&pTree);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SMB2UnmarshalFlushRequest(pSmbRequest, &pFid);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvTree2FindFile_SMB_V2(
pCtxSmb2,
pTree,
pFid,
LwIsSetFlag(
pSmbRequest->pHeader->ulFlags,
SMB2_FLAGS_RELATED_OPERATION),
&pFile);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvBuildFlushState_SMB_V2(
pFid,
pFile,
&pFlushState);
BAIL_ON_NT_STATUS(ntStatus);
pCtxSmb2->hState = pFlushState;
InterlockedIncrement(&pFlushState->refCount);
pCtxSmb2->pfnStateRelease = &SrvReleaseFlushStateHandle_SMB_V2;
}
LWIO_LOCK_MUTEX(bInLock, &pFlushState->mutex);
switch (pFlushState->stage)
{
case SRV_FLUSH_STAGE_SMB_V2_INITIAL:
pFlushState->stage = SRV_FLUSH_STAGE_SMB_V2_FLUSH_COMPLETED;
SrvPrepareFlushStateAsync_SMB_V2(pFlushState, pExecContext);
ntStatus = IoFlushBuffersFile(
pFlushState->pFile->hFile,
pFlushState->pAcb,
&pFlushState->ioStatusBlock);
BAIL_ON_NT_STATUS(ntStatus);
SrvReleaseFlushStateAsync_SMB_V2(pFlushState); // completed synchronously
// intentional fall through
case SRV_FLUSH_STAGE_SMB_V2_FLUSH_COMPLETED:
ntStatus = pFlushState->ioStatusBlock.Status;
BAIL_ON_NT_STATUS(ntStatus);
pFlushState->stage = SRV_FLUSH_STAGE_SMB_V2_BUILD_RESPONSE;
// intentional fall through
case SRV_FLUSH_STAGE_SMB_V2_BUILD_RESPONSE:
ntStatus = SrvBuildFlushResponse_SMB_V2(pExecContext);
BAIL_ON_NT_STATUS(ntStatus);
pFlushState->stage = SRV_FLUSH_STAGE_SMB_V2_DONE;
// intentional fall through
case SRV_FLUSH_STAGE_SMB_V2_DONE:
break;
}
cleanup:
if (pFile)
{
SrvFile2Release(pFile);
}
if (pTree)
{
SrvTree2Release(pTree);
}
if (pSession)
{
SrvSession2Release(pSession);
}
if (pFlushState)
{
LWIO_UNLOCK_MUTEX(bInLock, &pFlushState->mutex);
SrvReleaseFlushState_SMB_V2(pFlushState);
}
return ntStatus;
error:
switch (ntStatus)
{
case STATUS_PENDING:
// TODO: Add an indicator to the file object to trigger a
// cleanup if the connection gets closed and all the
// files involved have to be closed
break;
default:
if (pFlushState)
{
SrvReleaseFlushStateAsync_SMB_V2(pFlushState);
}
break;
}
goto cleanup;
}
NTSTATUS
SrvProcessGetInfo_SMB_V2(
PSRV_EXEC_CONTEXT pExecContext
)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
PLWIO_SRV_CONNECTION pConnection = pExecContext->pConnection;
PSRV_PROTOCOL_EXEC_CONTEXT pCtxProtocol = pExecContext->pProtocolContext;
PSRV_EXEC_CONTEXT_SMB_V2 pCtxSmb2 = pCtxProtocol->pSmb2Context;
PSRV_GET_INFO_STATE_SMB_V2 pGetInfoState = NULL;
PLWIO_SRV_SESSION_2 pSession = NULL;
PLWIO_SRV_TREE_2 pTree = NULL;
PLWIO_SRV_FILE_2 pFile = NULL;
BOOLEAN bInLock = FALSE;
pGetInfoState = (PSRV_GET_INFO_STATE_SMB_V2)pCtxSmb2->hState;
if (pGetInfoState)
{
InterlockedIncrement(&pGetInfoState->refCount);
}
else
{
ULONG iMsg = pCtxSmb2->iMsg;
PSRV_MESSAGE_SMB_V2 pSmbRequest = &pCtxSmb2->pRequests[iMsg];
PSMB2_GET_INFO_REQUEST_HEADER pRequestHeader = NULL; // Do not free
PBYTE pInputBuffer = NULL;
ULONG ulInputBufferLength = 0;
ntStatus = SrvConnection2FindSession_SMB_V2(
pCtxSmb2,
pConnection,
pSmbRequest->pHeader->ullSessionId,
&pSession);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvSetStatSession2Info(pExecContext, pSession);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvSession2FindTree_SMB_V2(
pCtxSmb2,
pSession,
pSmbRequest->pHeader->ulTid,
&pTree);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SMB2UnmarshalGetInfoRequest(
pSmbRequest,
&pRequestHeader,
&pInputBuffer,
&ulInputBufferLength);
BAIL_ON_NT_STATUS(ntStatus);
SRV_LOG_DEBUG(
pExecContext->pLogContext,
SMB_PROTOCOL_VERSION_2,
pSmbRequest->pHeader->command,
"Get Info request params: "
"command(%u),uid(%llu),cmd-seq(%llu),pid(%u),tid(%u),"
"credits(%u),flags(0x%x),chain-offset(%u),"
"file-id(persistent:0x%x,volatile:0x%x),"
"info-class(0x%x),info-type(0x%x),flags(0x%x),"
"input-buffer-length(%u),input-buffer-offset(%u),"
"output-buffer-length(%u),additional-info(%u)",
pSmbRequest->pHeader->command,
(long long)pSmbRequest->pHeader->ullSessionId,
(long long)pSmbRequest->pHeader->ullCommandSequence,
pSmbRequest->pHeader->ulPid,
pSmbRequest->pHeader->ulTid,
pSmbRequest->pHeader->usCredits,
pSmbRequest->pHeader->ulFlags,
pSmbRequest->pHeader->ulChainOffset,
(long long)pRequestHeader->fid.ullPersistentId,
(long long)pRequestHeader->fid.ullVolatileId,
pRequestHeader->ucInfoClass,
pRequestHeader->ucInfoType,
pRequestHeader->ulFlags,
pRequestHeader->ulInputBufferLen,
pRequestHeader->usInputBufferOffset,
pRequestHeader->ulOutputBufferLen,
pRequestHeader->ulAdditionalInfo);
ntStatus = SrvTree2FindFile_SMB_V2(
pCtxSmb2,
pTree,
&pRequestHeader->fid,
&pFile);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvBuildGetInfoState_SMB_V2(
pRequestHeader,
pFile,
pInputBuffer,
ulInputBufferLength,
&pGetInfoState);
BAIL_ON_NT_STATUS(ntStatus);
pCtxSmb2->hState = pGetInfoState;
InterlockedIncrement(&pGetInfoState->refCount);
pCtxSmb2->pfnStateRelease = &SrvReleaseGetInfoStateHandle_SMB_V2;
}
LWIO_LOCK_MUTEX(bInLock, &pGetInfoState->mutex);
switch (pGetInfoState->stage)
{
case SRV_GET_INFO_STAGE_SMB_V2_INITIAL:
pGetInfoState->stage = SRV_GET_INFO_STAGE_SMB_V2_ATTEMPT_IO;
// Intentional fall through
case SRV_GET_INFO_STAGE_SMB_V2_ATTEMPT_IO:
ntStatus = SrvQueryInfo_SMB_V2(pExecContext);
BAIL_ON_NT_STATUS(ntStatus);
pGetInfoState->stage = SRV_GET_INFO_STAGE_SMB_V2_BUILD_RESPONSE;
// Intentional fall through
case SRV_GET_INFO_STAGE_SMB_V2_BUILD_RESPONSE:
ntStatus = SrvBuildGetInfoResponse_SMB_V2(pExecContext);
BAIL_ON_NT_STATUS(ntStatus);
pGetInfoState->stage = SRV_GET_INFO_STAGE_SMB_V2_DONE;
// Intentional fall through
case SRV_GET_INFO_STAGE_SMB_V2_DONE:
break;
}
cleanup:
if (pFile)
{
SrvFile2Release(pFile);
}
if (pTree)
{
SrvTree2Release(pTree);
}
if (pSession)
{
SrvSession2Release(pSession);
}
if (pGetInfoState)
{
LWIO_UNLOCK_MUTEX(bInLock, &pGetInfoState->mutex);
SrvReleaseGetInfoState_SMB_V2(pGetInfoState);
}
return ntStatus;
error:
switch (ntStatus)
{
case STATUS_PENDING:
// TODO: Add an indicator to the file object to trigger a
// cleanup if the connection gets closed and all the
// files involved have to be closed
break;
default:
if (pGetInfoState)
{
SrvReleaseGetInfoStateAsync_SMB_V2(pGetInfoState);
}
break;
}
goto cleanup;
}
NTSTATUS
SrvTree2CreateFile(
PLWIO_SRV_TREE_2 pTree,
PWSTR pwszFilename,
PIO_FILE_HANDLE phFile,
PIO_FILE_NAME* ppFilename,
ACCESS_MASK desiredAccess,
LONG64 allocationSize,
FILE_ATTRIBUTES fileAttributes,
FILE_SHARE_FLAGS shareAccess,
FILE_CREATE_DISPOSITION createDisposition,
FILE_CREATE_OPTIONS createOptions,
PLWIO_SRV_FILE_2* ppFile
)
{
NTSTATUS ntStatus = 0;
BOOLEAN bInLock = FALSE;
PLWIO_SRV_FILE_2 pFile = NULL;
SMB2_FID fid = {0};
LWIO_LOCK_RWMUTEX_EXCLUSIVE(bInLock, &pTree->mutex);
if (SrvTree2IsRundown_inlock(pTree))
{
ntStatus = STATUS_INVALID_HANDLE;
BAIL_ON_NT_STATUS(ntStatus);
}
ntStatus = SrvTree2AcquireFileId_inlock(
pTree,
&fid);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvFile2Create(
pTree,
&fid,
pwszFilename,
phFile,
ppFilename,
desiredAccess,
allocationSize,
fileAttributes,
shareAccess,
createDisposition,
createOptions,
&pFile);
BAIL_ON_NT_STATUS(ntStatus);
ntStatus = SrvTree2AddFile_inlock(pTree, pFile);
BAIL_ON_NT_STATUS(ntStatus);
SrvFile2BlockIdleTimeout(pFile);
*ppFile = pFile;
cleanup:
LWIO_UNLOCK_RWMUTEX(bInLock, &pTree->mutex);
return ntStatus;
error:
LWIO_UNLOCK_RWMUTEX(bInLock, &pTree->mutex);
*ppFile = NULL;
if (pFile)
{
SrvFile2Rundown(pFile);
SrvFile2Release(pFile);
}
goto cleanup;
}
