VOID
IopFileObjectFree(
IN OUT PIO_FILE_OBJECT* ppFileObject
)
{
PIO_FILE_OBJECT pFileObject = *ppFileObject;
if (pFileObject)
{
LWIO_ASSERT(LwListIsEmpty(&pFileObject->IrpList));
IopIrpFreeZctIrpList(pFileObject);
IopDeviceLock(pFileObject->pDevice);
LwListRemove(&pFileObject->DeviceLinks);
IopDeviceUnlock(pFileObject->pDevice);
IopDeviceDereference(&pFileObject->pDevice);
LwRtlCleanupConditionVariable(&pFileObject->Rundown.Condition);
LwRtlCleanupMutex(&pFileObject->Mutex);
LwRtlUnicodeStringFree(&pFileObject->FileName);
IopIrpDereference(&pFileObject->pCloseIrp);
IoMemoryFree(pFileObject);
*ppFileObject = NULL;
}
}
NTSTATUS
PvfsListRemoveItem(
PPVFS_LIST pList,
PLW_LIST_LINKS pItem
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
BAIL_ON_INVALID_PTR(pList, ntError);
BAIL_ON_INVALID_PTR(pItem, ntError);
if (PvfsListIsEmpty(pList))
{
ntError = STATUS_NOT_FOUND;
BAIL_ON_NT_STATUS(ntError);
}
LwListRemove(pItem);
pList->CurrentSize--;
ntError = STATUS_SUCCESS;
cleanup:
return ntError;
error:
goto cleanup;
}
NTSTATUS
NpfsClientCloseHandle(
PNPFS_CCB pCCB
)
{
NTSTATUS ntStatus = 0;
PNPFS_PIPE pPipe = NULL;
PNPFS_CCB pSCB = NULL;
PLW_LIST_LINKS pLink = NULL;
PNPFS_IRP_CONTEXT pReadContext = NULL;
pPipe = pCCB->pPipe;
ENTER_MUTEX(&pPipe->PipeMutex);
pSCB = pPipe->pSCB;
pPipe->PipeClientState = PIPE_CLIENT_CLOSED;
while (pSCB && !LwListIsEmpty(&pSCB->ReadIrpList))
{
pLink = pSCB->ReadIrpList.Next;
LwListRemove(pLink);
pReadContext = LW_STRUCT_FROM_FIELD(pLink, NPFS_IRP_CONTEXT, Link);
NpfsServerCompleteReadFile(pSCB, pReadContext);
}
pthread_cond_signal(&pPipe->PipeCondition);
if (pPipe->PipeServerState == PIPE_SERVER_CLOSED)
{
ntStatus = NpfsFreePipeContext(pPipe);
BAIL_ON_NT_STATUS(ntStatus);
}
error:
pPipe->pCCB = NULL;
LEAVE_MUTEX(&pPipe->PipeMutex);
NpfsReleaseCCB(pCCB);
return(ntStatus);
}
static
VOID
IopIrpFree(
IN OUT PIRP* ppIrp
)
{
PIRP pIrp = *ppIrp;
if (pIrp)
{
PIRP_INTERNAL irpInternal = IopIrpGetInternal(pIrp);
LWIO_ASSERT(0 == irpInternal->ReferenceCount);
LWIO_ASSERT(STATUS_PENDING != pIrp->IoStatusBlock.Status);
switch (pIrp->Type)
{
case IRP_TYPE_CREATE:
case IRP_TYPE_CREATE_NAMED_PIPE:
IoSecurityDereferenceSecurityContext(&pIrp->Args.Create.SecurityContext);
RtlUnicodeStringFree(&pIrp->Args.Create.FileName.Name);
break;
case IRP_TYPE_QUERY_DIRECTORY:
if (pIrp->Args.QueryDirectory.FileSpec)
{
LwRtlUnicodeStringFree(&pIrp->Args.QueryDirectory.FileSpec->Pattern);
IO_FREE(&pIrp->Args.QueryDirectory.FileSpec);
}
break;
default:
break;
}
// Note that the parent (FO) lock is already held
// by IopIrpDereference().
// Might not be in the list if IRP creation failed.
if (irpInternal->FileObjectLinks.Next)
{
LwListRemove(&irpInternal->FileObjectLinks);
}
IopFileObjectDereference(&pIrp->FileHandle);
IoMemoryFree(pIrp);
*ppIrp = NULL;
}
}
LW_LIST_LINKS*
LwListRemoveBefore(
IN LW_LIST_LINKS* Head
)
{
LW_LIST_LINKS* element = Head->Prev;
if (element != Head)
{
LwListRemove(element);
}
else
{
element = NULL;
}
return element;
}
LW_LIST_LINKS*
LwListRemoveAfter(
IN LW_LIST_LINKS* Head
)
{
LW_LIST_LINKS* element = Head->Next;
if (element != Head)
{
LwListRemove(element);
}
else
{
element = NULL;
}
return element;
}
PIRP
IopIrpLoadZctIrp(
IN OUT PIO_FILE_OBJECT pFileObject,
IN PVOID pCompletionContext
)
{
PIRP pIrp = (PIRP) pCompletionContext;
PIRP_INTERNAL irpInternal = IopIrpGetInternal(pIrp);
LWIO_ASSERT(pIrp->Args.ReadWrite.ZctCompletionContext);
LWIO_ASSERT(irpInternal->CancelLinks.Next && irpInternal->CancelLinks.Prev);
IopFileObjectLock(pFileObject);
LwListRemove(&irpInternal->CancelLinks);
IopFileObjectUnlock(pFileObject);
RtlZeroMemory(&irpInternal->CancelLinks, sizeof(irpInternal->CancelLinks));
return pIrp;
}
VOID
RdrContinueContextList(
PLW_LIST_LINKS pList,
NTSTATUS status,
PVOID pParam
)
{
PRDR_OP_CONTEXT pContext = NULL;
PLW_LIST_LINKS pLink = NULL;
PLW_LIST_LINKS pNext = NULL;
for (pLink = pList->Next; pLink != pList; pLink = pNext)
{
pNext = pLink->Next;
pContext = LW_STRUCT_FROM_FIELD(pLink, RDR_OP_CONTEXT, Link);
LwListRemove(pLink);
if (RdrContinueContext(pContext, status, pParam))
{
LwListInsertBefore(pNext, pLink);
}
}
}
VOID
NpfsReleaseFCB(
PNPFS_FCB pFCB
)
{
BOOLEAN bFreeFCB = FALSE;
ENTER_WRITER_RW_LOCK(&gServerLock);
if (InterlockedDecrement(&pFCB->lRefCount) == 0)
{
LwListRemove(&pFCB->link);
bFreeFCB = TRUE;
}
LEAVE_WRITER_RW_LOCK(&gServerLock);
if (bFreeFCB)
{
NpfsFreeFCB(pFCB);
}
return;
}
NTSTATUS
NpfsClientWriteFile_Connected(
PNPFS_CCB pCCB,
PNPFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntStatus = 0;
PNPFS_PIPE pPipe = NULL;
PNPFS_CCB pSCB = NULL;
PVOID pBuffer = NULL;
ULONG Length = 0;
ULONG ulBytesTransferred = 0;
PLW_LIST_LINKS pLink = NULL;
PNPFS_IRP_CONTEXT pReadContext = NULL;
switch (pIrpContext->pIrp->Type)
{
case IRP_TYPE_FS_CONTROL:
pBuffer = pIrpContext->pIrp->Args.IoFsControl.InputBuffer;
Length = pIrpContext->pIrp->Args.IoFsControl.InputBufferLength;
break;
default:
pBuffer = pIrpContext->pIrp->Args.ReadWrite.Buffer;
Length = pIrpContext->pIrp->Args.ReadWrite.Length;
break;
}
pPipe = pCCB->pPipe;
pSCB = pPipe->pSCB;
ntStatus = NpfsEnqueueBuffer(
&pSCB->mdlList,
pBuffer,
Length,
&ulBytesTransferred);
BAIL_ON_NT_STATUS(ntStatus);
while (!LwListIsEmpty(&pSCB->ReadIrpList) &&
!NpfsMdlListIsEmpty(&pSCB->mdlList))
{
pLink = pSCB->ReadIrpList.Next;
LwListRemove(pLink);
pReadContext = LW_STRUCT_FROM_FIELD(pLink, NPFS_IRP_CONTEXT, Link);
NpfsServerCompleteReadFile(pSCB, pReadContext);
}
pthread_cond_signal(&pPipe->PipeCondition);
pIrpContext->pIrp->IoStatusBlock.BytesTransferred = ulBytesTransferred;
error:
pIrpContext->pIrp->IoStatusBlock.Status = ntStatus;
return(ntStatus);
}
