935 lines
27 KiB
C++
935 lines
27 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// Module: pins.c
|
|
//
|
|
// Description:
|
|
//
|
|
//
|
|
//@@BEGIN_MSINTERNAL
|
|
// Development Team:
|
|
// S.Mohanraj
|
|
//
|
|
// History: Date Author Comment
|
|
//
|
|
// To Do: Date Author Comment
|
|
//
|
|
//@@END_MSINTERNAL
|
|
//
|
|
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
|
|
// KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
|
// IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
|
|
// PURPOSE.
|
|
//
|
|
// Copyright (c) 1996-1999 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
#include "common.h"
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
static const WCHAR AllocatorTypeName[] = KSSTRING_Allocator;
|
|
static const WCHAR ClockTypeName[] = KSSTRING_Clock;
|
|
|
|
DEFINE_KSCREATE_DISPATCH_TABLE(PinCreateItems)
|
|
{
|
|
DEFINE_KSCREATE_ITEM(AllocatorDispatchCreate, AllocatorTypeName, 0),
|
|
DEFINE_KSCREATE_ITEM(CClockInstance::ClockDispatchCreate, ClockTypeName, 0),
|
|
};
|
|
|
|
DEFINE_KSDISPATCH_TABLE(
|
|
PinDispatchTable,
|
|
CPinInstance::PinDispatchIoControl, // Ioctl
|
|
DispatchInvalidDeviceRequest, // Read
|
|
CInstance::DispatchForwardIrp, // Write
|
|
DispatchInvalidDeviceRequest, // Flush
|
|
CPinInstance::PinDispatchClose, // Close
|
|
DispatchInvalidDeviceRequest, // QuerySecurity
|
|
DispatchInvalidDeviceRequest, // SetSeturity
|
|
DispatchFastIoDeviceControlFailure, // FastDeviceIoControl
|
|
DispatchFastReadFailure, // FastRead
|
|
DispatchFastWriteFailure // FastWrite
|
|
);
|
|
|
|
DEFINE_KSPROPERTY_TABLE(SysaudioPinPropertyHandlers) {
|
|
DEFINE_KSPROPERTY_ITEM(
|
|
KSPROPERTY_SYSAUDIO_TOPOLOGY_CONNECTION_INDEX, // idProperty
|
|
GetTopologyConnectionIndex, // pfnGetHandler
|
|
sizeof(KSPROPERTY), // cbMinGetPropertyInput
|
|
sizeof(ULONG), // cbMinGetDataInput
|
|
NULL, // pfnSetHandler
|
|
NULL, // Values
|
|
0, // RelationsCount
|
|
NULL, // Relations
|
|
NULL, // SupportHandler
|
|
0 // SerializedSize
|
|
),
|
|
DEFINE_KSPROPERTY_ITEM(
|
|
KSPROPERTY_SYSAUDIO_ATTACH_VIRTUAL_SOURCE, // idProperty
|
|
NULL, // pfnGetHandler
|
|
sizeof(SYSAUDIO_ATTACH_VIRTUAL_SOURCE), // cbMinGetPropertyInput
|
|
0, // cbMinGetDataInput
|
|
AttachVirtualSource, // pfnSetHandler
|
|
NULL, // Values
|
|
0, // RelationsCount
|
|
NULL, // Relations
|
|
NULL, // SupportHandler
|
|
0 // SerializedSize
|
|
),
|
|
DEFINE_KSPROPERTY_ITEM(
|
|
KSPROPERTY_SYSAUDIO_PIN_VOLUME_NODE, // idProperty
|
|
GetPinVolumeNode, // pfnGetHandler
|
|
sizeof(KSPROPERTY), // cbMinGetPropertyInput
|
|
sizeof(ULONG), // cbMinGetDataInput
|
|
NULL, // pfnSetHandler
|
|
NULL, // Values
|
|
0, // RelationsCount
|
|
NULL, // Relations
|
|
NULL, // SupportHandler
|
|
0 // SerializedSize
|
|
),
|
|
};
|
|
|
|
DEFINE_KSPROPERTY_TABLE(PinConnectionHandlers) {
|
|
DEFINE_KSPROPERTY_ITEM(
|
|
KSPROPERTY_CONNECTION_STATE, // idProperty
|
|
CPinInstance::PinStateHandler, // pfnGetHandler
|
|
sizeof(KSPROPERTY), // cbMinGetPropertyInput
|
|
sizeof(ULONG), // cbMinGetDataInput
|
|
CPinInstance::PinStateHandler, // pfnSetHandler
|
|
NULL, // Values
|
|
0, // RelationsCount
|
|
NULL, // Relations
|
|
NULL, // SupportHandler
|
|
0 // SerializedSize
|
|
)
|
|
};
|
|
|
|
DEFINE_KSPROPERTY_TABLE (AudioPinPropertyHandlers)
|
|
{
|
|
DEFINE_KSPROPERTY_ITEM(
|
|
KSPROPERTY_AUDIO_VOLUMELEVEL,
|
|
PinVirtualPropertyHandler,
|
|
sizeof(KSNODEPROPERTY_AUDIO_CHANNEL),
|
|
sizeof(LONG),
|
|
PinVirtualPropertyHandler,
|
|
&PropertyValuesVolume,
|
|
0,
|
|
NULL,
|
|
(PFNKSHANDLER)PinVirtualPropertySupportHandler,
|
|
0
|
|
)
|
|
};
|
|
|
|
DEFINE_KSPROPERTY_SET_TABLE(PinPropertySet)
|
|
{
|
|
DEFINE_KSPROPERTY_SET(
|
|
&KSPROPSETID_Connection, // Set
|
|
SIZEOF_ARRAY(PinConnectionHandlers), // PropertiesCount
|
|
PinConnectionHandlers, // PropertyItem
|
|
0, // FastIoCount
|
|
NULL // FastIoTable
|
|
),
|
|
DEFINE_KSPROPERTY_SET(
|
|
&KSPROPSETID_Sysaudio_Pin, // Set
|
|
SIZEOF_ARRAY(SysaudioPinPropertyHandlers), // PropertiesCount
|
|
SysaudioPinPropertyHandlers, // PropertyItem
|
|
0, // FastIoCount
|
|
NULL // FastIoTable
|
|
),
|
|
DEFINE_KSPROPERTY_SET(
|
|
&KSPROPSETID_Audio, // Set
|
|
SIZEOF_ARRAY(AudioPinPropertyHandlers), // PropertiesCount
|
|
AudioPinPropertyHandlers, // PropertyItem
|
|
0, // FastIoCount
|
|
NULL // FastIoTable
|
|
)
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
//---------------------------------------------------------------------------
|
|
|
|
CPinInstance::CPinInstance(
|
|
IN PPARENT_INSTANCE pParentInstance
|
|
) : CInstance(pParentInstance)
|
|
{
|
|
}
|
|
|
|
CPinInstance::~CPinInstance(
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance;
|
|
|
|
Assert(this);
|
|
Assert(pFilterInstance);
|
|
DPF1(100, "~CPinInstance: %08x", this);
|
|
if(pStartNodeInstance != NULL) {
|
|
pGraphNodeInstance = pFilterInstance->pGraphNodeInstance;
|
|
if(pGraphNodeInstance != NULL) {
|
|
Assert(pGraphNodeInstance);
|
|
ASSERT(PinId < pGraphNodeInstance->cPins);
|
|
ASSERT(pGraphNodeInstance->pacPinInstances != NULL);
|
|
ASSERT(pGraphNodeInstance->pacPinInstances[PinId].CurrentCount > 0);
|
|
|
|
pGraphNodeInstance->pacPinInstances[PinId].CurrentCount--;
|
|
}
|
|
else {
|
|
DPF2(10, "~CPinInstance PI %08x FI %08x no GNI",
|
|
this,
|
|
pFilterInstance);
|
|
}
|
|
pStartNodeInstance->Destroy();
|
|
}
|
|
else {
|
|
DPF2(10, "~CPinInstance PI %08x FI %08x no SNI",
|
|
this,
|
|
pFilterInstance);
|
|
}
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::PinDispatchCreate(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance;
|
|
PPIN_INSTANCE pPinInstance = NULL;
|
|
PKSPIN_CONNECT pPinConnect = NULL;
|
|
NTSTATUS Status;
|
|
|
|
::GrabMutex();
|
|
|
|
Status = GetRelatedGraphNodeInstance(pIrp, &pGraphNodeInstance);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
Assert(pGraphNodeInstance);
|
|
ASSERT(pGraphNodeInstance->pacPinInstances != NULL);
|
|
ASSERT(pGraphNodeInstance->paPinDescriptors != NULL);
|
|
|
|
//
|
|
// Get the PinConnect structure from KS.
|
|
// This function will copy creation parameters to pPinConnect.
|
|
// Also do a basic connectibility testing by comparing KSDATAFORMAT of
|
|
// pin descriptors and the request.
|
|
//
|
|
Status = KsValidateConnectRequest(
|
|
pIrp,
|
|
pGraphNodeInstance->cPins,
|
|
pGraphNodeInstance->paPinDescriptors,
|
|
&pPinConnect);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
#ifdef DEBUG
|
|
DPF1(60, "PinDispatchCreate: KsValidateConnectReq FAILED %08x", Status);
|
|
if(pPinConnect != NULL) {
|
|
DumpPinConnect(60, pPinConnect);
|
|
}
|
|
#endif
|
|
goto exit;
|
|
}
|
|
ASSERT(pPinConnect->PinId < pGraphNodeInstance->cPins);
|
|
|
|
#ifdef DEBUG
|
|
DPF(60, "PinDispatchCreate:");
|
|
DumpPinConnect(60, pPinConnect);
|
|
#endif
|
|
// Check the pin instance count
|
|
if(!pGraphNodeInstance->IsPinInstances(pPinConnect->PinId)) {
|
|
DPF4(60, "PinDispatchCreate: not enough ins GNI %08x #%d C %d P %d",
|
|
pGraphNodeInstance,
|
|
pPinConnect->PinId,
|
|
pGraphNodeInstance->pacPinInstances[pPinConnect->PinId].CurrentCount,
|
|
pGraphNodeInstance->pacPinInstances[pPinConnect->PinId].PossibleCount);
|
|
Status = STATUS_DEVICE_BUSY;
|
|
goto exit;
|
|
}
|
|
|
|
// Allocate per pin instance data
|
|
pPinInstance = new PIN_INSTANCE(
|
|
&pGraphNodeInstance->pFilterInstance->ParentInstance);
|
|
if(pPinInstance == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto exit;
|
|
}
|
|
// Setup the pin's instance data
|
|
pPinInstance->ulVolumeNodeNumber = MAXULONG;
|
|
pPinInstance->pFilterInstance = pGraphNodeInstance->pFilterInstance;
|
|
pPinInstance->PinId = pPinConnect->PinId;
|
|
|
|
Status = pPinInstance->DispatchCreate(
|
|
pIrp,
|
|
(UTIL_PFN)PinDispatchCreateKP,
|
|
pPinConnect,
|
|
SIZEOF_ARRAY(PinCreateItems),
|
|
PinCreateItems,
|
|
&PinDispatchTable);
|
|
|
|
pPinConnect->PinId = pPinInstance->PinId;
|
|
if(!NT_SUCCESS(Status)) {
|
|
#ifdef DEBUG
|
|
DPF1(60, "PinDispatchCreate: FAILED: %08x ", Status);
|
|
DumpPinConnect(60, pPinConnect);
|
|
#endif
|
|
goto exit;
|
|
}
|
|
// Increment the reference count on this pin
|
|
ASSERT(pPinInstance->pStartNodeInstance != NULL);
|
|
ASSERT(pGraphNodeInstance->pacPinInstances != NULL);
|
|
pGraphNodeInstance->pacPinInstances[pPinInstance->PinId].CurrentCount++;
|
|
exit:
|
|
if(!NT_SUCCESS(Status)) {
|
|
delete pPinInstance;
|
|
}
|
|
::ReleaseMutex();
|
|
|
|
pIrp->IoStatus.Status = Status;
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::PinDispatchCreateKP(
|
|
PPIN_INSTANCE pPinInstance,
|
|
PKSPIN_CONNECT pPinConnect
|
|
)
|
|
{
|
|
PWAVEFORMATEX pWaveFormatExRequested = NULL;
|
|
PFILTER_INSTANCE pFilterInstance;
|
|
PSTART_NODE pStartNode;
|
|
NTSTATUS Status;
|
|
|
|
Assert(pPinInstance);
|
|
pFilterInstance = pPinInstance->pFilterInstance;
|
|
Assert(pFilterInstance);
|
|
ASSERT(pPinInstance->PinId < pFilterInstance->pGraphNodeInstance->cPins);
|
|
ASSERT(pPinConnect->PinId < pFilterInstance->pGraphNodeInstance->cPins);
|
|
|
|
|
|
if(IsEqualGUID(
|
|
&PKSDATAFORMAT(pPinConnect + 1)->Specifier,
|
|
&KSDATAFORMAT_SPECIFIER_WAVEFORMATEX)) {
|
|
pWaveFormatExRequested =
|
|
&PKSDATAFORMAT_WAVEFORMATEX(pPinConnect + 1)->WaveFormatEx;
|
|
}
|
|
else if(IsEqualGUID(
|
|
&PKSDATAFORMAT(pPinConnect + 1)->Specifier,
|
|
&KSDATAFORMAT_SPECIFIER_DSOUND)) {
|
|
pWaveFormatExRequested =
|
|
&PKSDATAFORMAT_DSOUND(pPinConnect + 1)->BufferDesc.WaveFormatEx;
|
|
}
|
|
|
|
if(pWaveFormatExRequested != NULL) {
|
|
// Fix SampleSize if zero
|
|
if(PKSDATAFORMAT(pPinConnect + 1)->SampleSize == 0) {
|
|
PKSDATAFORMAT(pPinConnect + 1)->SampleSize =
|
|
pWaveFormatExRequested->nBlockAlign;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Try each start node until success
|
|
//
|
|
Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
|
|
//
|
|
// First loop through all the start nodes which are not marked SECONDPASS
|
|
// and try to create a StartNodeInstance
|
|
//
|
|
FOR_EACH_LIST_ITEM(
|
|
pFilterInstance->pGraphNodeInstance->aplstStartNode[pPinInstance->PinId],
|
|
pStartNode) {
|
|
|
|
Assert(pStartNode);
|
|
Assert(pFilterInstance);
|
|
|
|
if(pStartNode->ulFlags & STARTNODE_FLAGS_SECONDPASS) {
|
|
continue;
|
|
}
|
|
|
|
if(pFilterInstance->pGraphNodeInstance->IsGraphValid(
|
|
pStartNode,
|
|
pPinInstance->PinId)) {
|
|
|
|
Status = CStartNodeInstance::Create(
|
|
pPinInstance,
|
|
pStartNode,
|
|
pPinConnect,
|
|
pWaveFormatExRequested,
|
|
NULL);
|
|
if(NT_SUCCESS(Status)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
//
|
|
// If first pass failed to create an instance try all the second pass
|
|
// StartNodes in the list. This is being done for creating paths with no GFX
|
|
// because we created a path with AEC and no GFX earlier.
|
|
//
|
|
FOR_EACH_LIST_ITEM(
|
|
pFilterInstance->pGraphNodeInstance->aplstStartNode[pPinInstance->PinId],
|
|
pStartNode) {
|
|
|
|
Assert(pStartNode);
|
|
Assert(pFilterInstance);
|
|
|
|
if((pStartNode->ulFlags & STARTNODE_FLAGS_SECONDPASS) == 0) {
|
|
continue;
|
|
}
|
|
|
|
if(pFilterInstance->pGraphNodeInstance->IsGraphValid(
|
|
pStartNode,
|
|
pPinInstance->PinId)) {
|
|
|
|
Status = CStartNodeInstance::Create(
|
|
pPinInstance,
|
|
pStartNode,
|
|
pPinConnect,
|
|
pWaveFormatExRequested,
|
|
NULL);
|
|
|
|
if(NT_SUCCESS(Status)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
} END_EACH_LIST_ITEM
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
}
|
|
Status = pPinInstance->SetNextFileObject(
|
|
pPinInstance->pStartNodeInstance->pPinNodeInstance->hPin);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::PinDispatchClose(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
{
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PPIN_INSTANCE pPinInstance;
|
|
|
|
::GrabMutex();
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation( pIrp );
|
|
pPinInstance = (PPIN_INSTANCE)pIrpStack->FileObject->FsContext;
|
|
Assert(pPinInstance);
|
|
pIrpStack->FileObject->FsContext = NULL;
|
|
delete pPinInstance;
|
|
|
|
::ReleaseMutex();
|
|
|
|
pIrp->IoStatus.Status = STATUS_SUCCESS;
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::PinDispatchIoControl(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PIRP pIrp
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
PSTART_NODE_INSTANCE pStartNodeInstance;
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PKSPROPERTY pProperty = NULL;
|
|
PPIN_INSTANCE pPinInstance;
|
|
BOOL fProperty = FALSE;
|
|
ULONG ulFlags = 0;
|
|
|
|
#ifdef DEBUG
|
|
DumpIoctl(pIrp, "Pin");
|
|
#endif
|
|
|
|
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
|
|
switch(pIrpStack->Parameters.DeviceIoControl.IoControlCode) {
|
|
case IOCTL_KS_PROPERTY:
|
|
fProperty = TRUE;
|
|
break;
|
|
|
|
case IOCTL_KS_ENABLE_EVENT:
|
|
case IOCTL_KS_DISABLE_EVENT:
|
|
case IOCTL_KS_METHOD:
|
|
break;
|
|
|
|
default:
|
|
return(DispatchForwardIrp(pDeviceObject, pIrp));
|
|
}
|
|
|
|
::GrabMutex();
|
|
|
|
pPinInstance = (PPIN_INSTANCE)pIrpStack->FileObject->FsContext;
|
|
Status = pPinInstance->GetStartNodeInstance(&pStartNodeInstance);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
Assert(pPinInstance->pFilterInstance);
|
|
Assert(pPinInstance->pFilterInstance->pGraphNodeInstance);
|
|
|
|
if(pIrpStack->Parameters.DeviceIoControl.InputBufferLength >=
|
|
sizeof(KSPROPERTY)) {
|
|
|
|
__try {
|
|
if(pIrp->AssociatedIrp.SystemBuffer == NULL) {
|
|
pProperty = (PKSPROPERTY)
|
|
(pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
// Validate the pointers if the client is not trusted.
|
|
if(pIrp->RequestorMode != KernelMode) {
|
|
ProbeForWrite(
|
|
pProperty,
|
|
pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
|
|
sizeof(BYTE));
|
|
}
|
|
}
|
|
else {
|
|
pProperty =
|
|
(PKSPROPERTY)((PUCHAR)pIrp->AssociatedIrp.SystemBuffer +
|
|
((pIrpStack->Parameters.DeviceIoControl.OutputBufferLength +
|
|
FILE_QUAD_ALIGNMENT) & ~FILE_QUAD_ALIGNMENT));
|
|
}
|
|
ulFlags = pProperty->Flags;
|
|
|
|
}
|
|
__except (EXCEPTION_EXECUTE_HANDLER) {
|
|
Trap();
|
|
Status = GetExceptionCode();
|
|
DPF1(5, "PinDispatchIoControl: Exception %08x", Status);
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// This check allows the actual node or filter return the set's
|
|
// supported, etc. instead of always return only the sets sysaudio
|
|
// supports.
|
|
//
|
|
if(ulFlags & KSPROPERTY_TYPE_TOPOLOGY) {
|
|
if(fProperty) {
|
|
if((ulFlags & (KSPROPERTY_TYPE_GET |
|
|
KSPROPERTY_TYPE_SET |
|
|
KSPROPERTY_TYPE_BASICSUPPORT)) == 0) {
|
|
|
|
// NOTE: ForwardIrpNode releases gMutex
|
|
return(ForwardIrpNode(
|
|
pIrp,
|
|
pProperty,
|
|
pPinInstance->pFilterInstance,
|
|
pPinInstance));
|
|
}
|
|
}
|
|
else {
|
|
// NOTE: ForwardIrpNode releases gMutex
|
|
return(ForwardIrpNode(
|
|
pIrp,
|
|
pProperty,
|
|
pPinInstance->pFilterInstance,
|
|
pPinInstance));
|
|
}
|
|
}
|
|
}
|
|
|
|
switch(pIrpStack->Parameters.DeviceIoControl.IoControlCode) {
|
|
case IOCTL_KS_PROPERTY:
|
|
|
|
Status = KsPropertyHandler(
|
|
pIrp,
|
|
SIZEOF_ARRAY(PinPropertySet),
|
|
(PKSPROPERTY_SET)PinPropertySet);
|
|
|
|
if(Status != STATUS_NOT_FOUND &&
|
|
Status != STATUS_PROPSET_NOT_FOUND) {
|
|
break;
|
|
}
|
|
// Fall through if property not found
|
|
|
|
case IOCTL_KS_ENABLE_EVENT:
|
|
case IOCTL_KS_DISABLE_EVENT:
|
|
case IOCTL_KS_METHOD:
|
|
|
|
// NOTE: ForwardIrpNode releases gMutex
|
|
return(ForwardIrpNode(
|
|
pIrp,
|
|
NULL,
|
|
pPinInstance->pFilterInstance,
|
|
pPinInstance));
|
|
|
|
default:
|
|
ASSERT(FALSE); // Can't happen because of above switch
|
|
}
|
|
exit:
|
|
::ReleaseMutex();
|
|
|
|
pIrp->IoStatus.Status = Status;
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return(Status);
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::PinStateHandler
|
|
(
|
|
IN PIRP pIrp,
|
|
IN PKSPROPERTY pProperty,
|
|
IN OUT PKSSTATE pState
|
|
)
|
|
{
|
|
PSTART_NODE_INSTANCE pStartNodeInstance;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
#ifdef DEBUG
|
|
extern PSZ apszStates[];
|
|
#endif
|
|
Status = ::GetStartNodeInstance(pIrp, &pStartNodeInstance);
|
|
if(!NT_SUCCESS(Status)) {
|
|
Trap();
|
|
goto exit;
|
|
}
|
|
if(pProperty->Flags & KSPROPERTY_TYPE_GET) {
|
|
*pState = pStartNodeInstance->CurrentState;
|
|
pIrp->IoStatus.Information = sizeof(KSSTATE);
|
|
if(*pState == KSSTATE_PAUSE) {
|
|
if(pStartNodeInstance->pPinNodeInstance->
|
|
pPinNode->pPinInfo->DataFlow == KSPIN_DATAFLOW_OUT) {
|
|
Status = STATUS_NO_DATA_DETECTED;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
ASSERT(pProperty->Flags & KSPROPERTY_TYPE_SET);
|
|
|
|
DPF3(90, "PinStateHandler from %s to %s - SNI: %08x",
|
|
apszStates[pStartNodeInstance->CurrentState],
|
|
apszStates[*pState],
|
|
pStartNodeInstance);
|
|
|
|
Status = pStartNodeInstance->SetState(*pState, 0);
|
|
if(!NT_SUCCESS(Status)) {
|
|
DPF1(90, "PinStateHandler FAILED: %08x", Status);
|
|
goto exit;
|
|
}
|
|
|
|
}
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
NTSTATUS
|
|
GetRelatedStartNodeInstance(
|
|
IN PIRP pIrp,
|
|
OUT PSTART_NODE_INSTANCE *ppStartNodeInstance
|
|
)
|
|
{
|
|
return(((PPIN_INSTANCE)IoGetCurrentIrpStackLocation(pIrp)->FileObject->
|
|
RelatedFileObject->FsContext)->GetStartNodeInstance(ppStartNodeInstance));
|
|
}
|
|
|
|
NTSTATUS
|
|
GetStartNodeInstance(
|
|
IN PIRP pIrp,
|
|
OUT PSTART_NODE_INSTANCE *ppStartNodeInstance
|
|
)
|
|
{
|
|
return(((PPIN_INSTANCE)IoGetCurrentIrpStackLocation(pIrp)->FileObject->
|
|
FsContext)->GetStartNodeInstance(ppStartNodeInstance));
|
|
}
|
|
|
|
NTSTATUS
|
|
CPinInstance::GetStartNodeInstance(
|
|
OUT PSTART_NODE_INSTANCE *ppStartNodeInstance
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
if(this == NULL || pStartNodeInstance == NULL) {
|
|
DPF(60, "GetStartNodeInstance: pStartNodeInstance == NULL");
|
|
Status = STATUS_NO_SUCH_DEVICE;
|
|
goto exit;
|
|
}
|
|
Assert(this);
|
|
*ppStartNodeInstance = pStartNodeInstance;
|
|
exit:
|
|
return(Status);
|
|
}
|
|
|
|
#pragma LOCKED_CODE
|
|
#pragma LOCKED_DATA
|
|
|
|
// NOTE: ForwardIrpNode releases gMutex
|
|
|
|
NTSTATUS
|
|
ForwardIrpNode(
|
|
IN PIRP pIrp,
|
|
IN OPTIONAL PKSPROPERTY pProperty, // already validated or NULL
|
|
IN PFILTER_INSTANCE pFilterInstance,
|
|
IN OPTIONAL PPIN_INSTANCE pPinInstance
|
|
)
|
|
{
|
|
PGRAPH_NODE_INSTANCE pGraphNodeInstance;
|
|
PFILE_OBJECT pFileObject = NULL;
|
|
PIO_STACK_LOCATION pIrpStack;
|
|
PKSEVENTDATA pEventData;
|
|
ULONG OriginalNodeId;
|
|
NTSTATUS Status;
|
|
|
|
Assert(pFilterInstance);
|
|
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
|
|
Status = pFilterInstance->GetGraphNodeInstance(&pGraphNodeInstance);
|
|
if(!NT_SUCCESS(Status)) {
|
|
goto exit;
|
|
}
|
|
Assert(pGraphNodeInstance);
|
|
|
|
if(pPinInstance != NULL) {
|
|
pFileObject = pPinInstance->GetNextFileObject();
|
|
}
|
|
|
|
__try {
|
|
if(pIrpStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSNODEPROPERTY) &&
|
|
pIrpStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_DISABLE_EVENT) {
|
|
|
|
if(pProperty == NULL) {
|
|
if(pIrp->AssociatedIrp.SystemBuffer == NULL) {
|
|
Trap();
|
|
pProperty = (PKSPROPERTY)
|
|
(pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer);
|
|
|
|
// Validate the pointers if the client is not trusted.
|
|
if(pIrp->RequestorMode != KernelMode) {
|
|
ProbeForWrite(
|
|
pProperty,
|
|
pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
|
|
sizeof(BYTE));
|
|
}
|
|
}
|
|
else {
|
|
pProperty = (PKSPROPERTY)
|
|
((PUCHAR)pIrp->AssociatedIrp.SystemBuffer +
|
|
((pIrpStack->Parameters.DeviceIoControl.OutputBufferLength +
|
|
FILE_QUAD_ALIGNMENT) & ~FILE_QUAD_ALIGNMENT));
|
|
}
|
|
}
|
|
|
|
ASSERT(!IsEqualGUID(&pProperty->Set, &KSPROPSETID_Sysaudio));
|
|
ASSERT(!IsEqualGUID(&pProperty->Set, &KSEVENTSETID_Sysaudio));
|
|
|
|
if(pProperty->Flags & KSPROPERTY_TYPE_TOPOLOGY) {
|
|
|
|
OriginalNodeId = ((PKSNODEPROPERTY)pProperty)->NodeId;
|
|
|
|
if(pPinInstance == NULL) {
|
|
Status = pGraphNodeInstance->
|
|
GetTopologyNodeFileObject(
|
|
&pFileObject,
|
|
OriginalNodeId);
|
|
}
|
|
else {
|
|
Status = pPinInstance->pStartNodeInstance->
|
|
GetTopologyNodeFileObject(
|
|
&pFileObject,
|
|
OriginalNodeId);
|
|
}
|
|
if(!NT_SUCCESS(Status)) {
|
|
DPF1(100,
|
|
"ForwardIrpNode: GetTopologyNodeFileObject FAILED %08x",
|
|
Status);
|
|
goto exit;
|
|
}
|
|
|
|
// Put real node number in input buffer
|
|
((PKSNODEPROPERTY)pProperty)->NodeId = pGraphNodeInstance->
|
|
papTopologyNode[OriginalNodeId]->ulRealNodeNumber;
|
|
}
|
|
}
|
|
else {
|
|
//
|
|
// If it is DisableEvent && if it is of type DPC. We look into the
|
|
// Reserved field of KSEVENTDATA to extract the original node on
|
|
// which the event was enabled (The high bit is set if we ever
|
|
// stashed a NodeId in there).
|
|
//
|
|
if(pIrpStack->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_KS_DISABLE_EVENT) {
|
|
|
|
if(pIrpStack->Parameters.DeviceIoControl.InputBufferLength >=
|
|
sizeof(KSEVENTDATA)) {
|
|
pEventData = (PKSEVENTDATA)
|
|
pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
|
|
|
|
if(pIrp->RequestorMode != KernelMode) {
|
|
ProbeForWrite(
|
|
pEventData,
|
|
pIrpStack->Parameters.DeviceIoControl.InputBufferLength,
|
|
sizeof (BYTE));
|
|
}
|
|
|
|
OriginalNodeId = ULONG(pEventData->Dpc.Reserved);
|
|
|
|
if((pEventData->NotificationType == KSEVENTF_DPC) &&
|
|
(OriginalNodeId & 0x80000000)) {
|
|
|
|
OriginalNodeId = OriginalNodeId & 0x7fffffff;
|
|
|
|
if(pPinInstance == NULL) {
|
|
Status = pGraphNodeInstance->
|
|
GetTopologyNodeFileObject(
|
|
&pFileObject,
|
|
OriginalNodeId);
|
|
}
|
|
else {
|
|
Status = pPinInstance->pStartNodeInstance->
|
|
GetTopologyNodeFileObject(
|
|
&pFileObject,
|
|
OriginalNodeId);
|
|
}
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
DPF1(100,
|
|
"ForwardIrpNode: GetTopologyNodeFileObject FAILED %08x",
|
|
Status);
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
Trap();
|
|
Status = GetExceptionCode();
|
|
DPF1(5, "ForwardIrpNode: Exception %08x", Status);
|
|
goto exit;
|
|
}
|
|
|
|
if(pFileObject == NULL) {
|
|
Status = STATUS_NOT_FOUND;
|
|
DPF1(100, "ForwardIrpNode: Property not forwarded: %08x", pProperty);
|
|
goto exit;
|
|
}
|
|
pIrpStack->FileObject = pFileObject;
|
|
|
|
//
|
|
// If it was EnableEvent we stash away pointer to KSEVENTDATA, so that we
|
|
// can stash the NodeID into it after we call the next driver on the stack
|
|
//
|
|
KPROCESSOR_MODE RequestorMode;
|
|
|
|
if((pProperty != NULL) &&
|
|
(pIrpStack->Parameters.DeviceIoControl.IoControlCode ==
|
|
IOCTL_KS_ENABLE_EVENT) &&
|
|
!(pProperty->Flags & KSEVENT_TYPE_BASICSUPPORT) &&
|
|
(pProperty->Flags & KSPROPERTY_TYPE_TOPOLOGY) &&
|
|
(pProperty->Flags & KSEVENT_TYPE_ENABLE)) {
|
|
pEventData = (PKSEVENTDATA) pIrp->UserBuffer;
|
|
RequestorMode = pIrp->RequestorMode;
|
|
}
|
|
else {
|
|
pEventData = NULL;
|
|
}
|
|
|
|
IoSkipCurrentIrpStackLocation(pIrp);
|
|
AssertFileObject(pIrpStack->FileObject);
|
|
Status = IoCallDriver(IoGetRelatedDeviceObject(pFileObject), pIrp);
|
|
|
|
//
|
|
// Stash away the Node id in EventData
|
|
//
|
|
__try {
|
|
if (pEventData != NULL) {
|
|
if (RequestorMode == UserMode) {
|
|
ProbeForWrite(pEventData, sizeof(KSEVENTDATA), sizeof(BYTE));
|
|
}
|
|
|
|
if (pEventData->NotificationType == KSEVENTF_DPC) {
|
|
pEventData->Dpc.Reserved = OriginalNodeId | 0x80000000;
|
|
}
|
|
}
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
Trap();
|
|
Status = GetExceptionCode();
|
|
DPF1(5, "ForwardIrpNode: Exception %08x", Status);
|
|
}
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
DPF1(100, "ForwardIrpNode: Status %08x", Status);
|
|
}
|
|
|
|
::ReleaseMutex();
|
|
return(Status);
|
|
|
|
exit:
|
|
::ReleaseMutex();
|
|
|
|
pIrp->IoStatus.Status = Status;
|
|
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
#ifdef DEBUG
|
|
|
|
extern PSZ apszStates[];
|
|
|
|
ENUMFUNC
|
|
CPinInstance::Dump(
|
|
)
|
|
{
|
|
Assert(this);
|
|
// .siv
|
|
if(ulDebugFlags & (DEBUG_FLAGS_VERBOSE | DEBUG_FLAGS_OBJECT)) {
|
|
dprintf("PI: %08x FI %08x SNI %08x ulVNN %08x PinId %d\n",
|
|
this,
|
|
pFilterInstance,
|
|
pStartNodeInstance,
|
|
ulVolumeNodeNumber,
|
|
PinId);
|
|
CInstance::Dump();
|
|
ParentInstance.Dump();
|
|
}
|
|
else {
|
|
dprintf(" Fr: Sysaudio\n PinId: %d\n", PinId);
|
|
}
|
|
if(ulDebugFlags & DEBUG_FLAGS_INSTANCE) {
|
|
if(pStartNodeInstance != NULL) {
|
|
pStartNodeInstance->Dump();
|
|
}
|
|
}
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
ENUMFUNC
|
|
CPinInstance::DumpAddress(
|
|
)
|
|
{
|
|
if(this != NULL) {
|
|
Assert(this);
|
|
dprintf(" %08x", this);
|
|
}
|
|
return(STATUS_CONTINUE);
|
|
}
|
|
|
|
#endif
|
|
|
|
//---------------------------------------------------------------------------
|
|
// End of File: pins.c
|
|
//---------------------------------------------------------------------------
|