Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-24 17:34:57 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Start implementing object bag support functions

Browse source 
- Implement KsCreateDevice, KsAddDevice, KsInitializeDriver
- Add KsDefaultForwardIrp stub

svn path=/trunk/; revision=39104
This commit is contained in:
Johannes Anderwald 2009-01-26 10:05:46 +00:00
parent 7685b6a1a8
commit 5284f4a283
10 changed files with 389 additions and 17 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
reactos/drivers/ksfilter/ks/bag.c Normal file
View file

@ -0,0 +1,58 @@
#include <ntddk.h>
#include <debug.h>
#include <ks.h>
#if 0
typedef struct
{
LIST_ENTRY Entry;
PVOID Item;
PFNKSFREE Free;
LONG ReferenceCount;
}KSOBJECT_BAG_ENTRY;
typedef struct
{
LIST_ENTRY ListHead;
KMUTEX Lock;
}KSOBJECT_BAG_IMPL;
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsAddItemToObjectBag(
IN KSOBJECT_BAG ObjectBag,
IN PVOID Item,
IN PFNKSFREE Free OPTIONAL)
{
KSOBJECT_BAG_ENTRY * Entry;
KSOBJECT_BAG_IMPL * Bag = (KSOBJECT_BAG_IMPL)ObjectBag;
Entry = ExAllocatePool(NonPagedPool, sizeof(KSOBJECT_BAG_ENTRY));
if (!Entry)
return STATUS_INSUFFICIENT_RESOURCES;
Entry->Free = Free;
Entry->Item = Item;
InsertTailList(&Bag->ListHead, &Entry->Entry);
return STATUS_SUCCESS;
}
KSDDKAPI
ULONG
NTAPI
KsRemoveItemFromObjectBag(
IN KSOBJECT_BAG ObjectBag,
IN PVOID Item,
IN BOOLEAN Free)
{
KSOBJECT_BAG_IMPL * Bag = (KSOBJECT_BAG_IMPL)ObjectBag;
}
#endif

22
reactos/drivers/ksfilter/ks/clocks.c
View file

@ -6,6 +6,11 @@
#include <debug.h>
#include <ks.h>
typedef struct
{
}KS_DEFAULT_CLOCK;
/*
@unimplemented
*/
@ -27,19 +32,28 @@ KsCreateDefaultClock(
IN PIRP Irp,
IN PKSDEFAULTCLOCK DefaultClock)
{
UNIMPLEMENTED;
NTSTATUS Status;
PKSCLOCK_CREATE ClockCreate;
Status = KsValidateClockCreateRequest(Irp, &ClockCreate);
if (!NT_SUCCESS(Status))
return Status;
// ExAllocatePoolWithTag(NonPagedPool, sizeof(KS_DEFAULT_CLOCK), 0);
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
@implemented
*/
KSDDKAPI NTSTATUS NTAPI
KsAllocateDefaultClock(
OUT PKSDEFAULTCLOCK* DefaultClock)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
return KsAllocateDefaultClockEx(DefaultClock, NULL, NULL, NULL, NULL, NULL, 0);
}
/*

34
reactos/drivers/ksfilter/ks/device.c Normal file
View file

@ -0,0 +1,34 @@
#include <ntddk.h>
#include <debug.h>
#include <ks.h>
#include "ksiface.h"
#include "ksfunc.h"
typedef struct
{
IKsDeviceVtbl *lpVtbl;
LONG ref;
}IKsDeviceImpl;
NTSTATUS
NTAPI
NewIKsDevice(IKsDevice** OutDevice)
{
IKsDeviceImpl * This;
This = ExAllocatePoolWithTag(NonPagedPool, sizeof(IKsDeviceImpl), 0x12345678); //FIX TAG
if (!This)
return STATUS_INSUFFICIENT_RESOURCES;
This->ref = 1;
//This->lpVtbl = &vt_IKsDevice;
*OutDevice = (IKsDevice*)This;
return STATUS_SUCCESS;
}

143
reactos/drivers/ksfilter/ks/driver.c Normal file
View file

@ -0,0 +1,143 @@
#include <ntddk.h>
#include <debug.h>
#include <ks.h>
#include "ksfunc.h"
/*
@unimplemented
*/
KSDDKAPI
PKSDEVICE
NTAPI
KsGetDeviceForDeviceObject(
IN PDEVICE_OBJECT FunctionalDeviceObject)
{
return NULL;
}
/*
@unimplemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsInitializeDevice(
IN PDEVICE_OBJECT FunctionalDeviceObject,
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PDEVICE_OBJECT NextDeviceObject,
IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL)
{
return STATUS_UNSUCCESSFUL;
}
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsCreateDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL,
IN ULONG ExtensionSize OPTIONAL,
OUT PKSDEVICE* Device OPTIONAL)
{
NTSTATUS Status = STATUS_DEVICE_REMOVED;
PDEVICE_OBJECT FunctionalDeviceObject= NULL;
PDEVICE_OBJECT OldHighestDeviceObject;
if (!ExtensionSize)
ExtensionSize = sizeof(PVOID);
Status = IoCreateDevice(DriverObject, ExtensionSize, NULL, FILE_DEVICE_KS, FILE_DEVICE_SECURE_OPEN, FALSE, &FunctionalDeviceObject);
if (!NT_SUCCESS(Status))
return Status;
OldHighestDeviceObject = IoAttachDeviceToDeviceStack(FunctionalDeviceObject, PhysicalDeviceObject);
if (OldHighestDeviceObject)
{
Status = KsInitializeDevice(FunctionalDeviceObject, PhysicalDeviceObject, OldHighestDeviceObject, Descriptor);
}
if (!NT_SUCCESS(Status))
{
if (OldHighestDeviceObject)
IoDetachDevice(OldHighestDeviceObject);
IoDeleteDevice(FunctionalDeviceObject);
return Status;
}
if (Device)
{
*Device = KsGetDeviceForDeviceObject(FunctionalDeviceObject);
}
return Status;
}
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsAddDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject)
{
PKSDEVICE_DESCRIPTOR *DriverObjectExtension;
PKSDEVICE_DESCRIPTOR Descriptor = NULL;
DriverObjectExtension = IoGetDriverObjectExtension(DriverObject, (PVOID)KsAddDevice);
if (DriverObjectExtension)
{
Descriptor = *DriverObjectExtension;
}
return KsCreateDevice(DriverObject, PhysicalDeviceObject, Descriptor, 0, NULL);
}
/*
@implemented
*/
KSDDKAPI
NTSTATUS
NTAPI
KsInitializeDriver(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
IN const KSDEVICE_DESCRIPTOR *Descriptor OPTIONAL
)
{
PKSDEVICE_DESCRIPTOR *DriverObjectExtension;
NTSTATUS Status;
if (Descriptor)
{
Status = IoAllocateDriverObjectExtension(DriverObject, (PVOID)KsAddDevice, sizeof(PKSDEVICE_DESCRIPTOR), (PVOID*)&DriverObjectExtension);
if (NT_SUCCESS(Status))
{
*DriverObjectExtension = (KSDEVICE_DESCRIPTOR*)Descriptor;
}
}
/* Setting our IRP handlers */
//DriverObject->MajorFunction[IRP_MJ_CREATE] = KspDispatch;
//DriverObject->MajorFunction[IRP_MJ_PNP] = KspDispatch;
//DriverObject->MajorFunction[IRP_MJ_POWER] = KspDispatch;
/* The driver-supplied AddDevice */
DriverObject->DriverExtension->AddDevice = KsAddDevice;
/* KS handles these */
DPRINT1("Setting KS function handlers\n");
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CLOSE);
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_DEVICE_CONTROL);
return STATUS_SUCCESS;
}

13
reactos/drivers/ksfilter/ks/irp.c
View file

@ -678,3 +678,16 @@ KsWriteFile(
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI NTSTATUS NTAPI
KsDefaultForwardIrp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}

3
reactos/drivers/ksfilter/ks/ks.rbuild
View file

@ -12,6 +12,9 @@
<define name="_COMDDK_" />
<file>ks.rc</file>
<file>allocators.c</file>
<file>bag.c</file>
<file>device.c</file>
<file>driver.c</file>
<file>clocks.c</file>
<file>connectivity.c</file>
<file>events.c</file>

1
reactos/drivers/ksfilter/ks/ks.spec
View file

@ -44,6 +44,7 @@
@ stdcall KsHandleSizedListQuery(ptr long long ptr)
@ stdcall KsAcquireResetValue(ptr ptr)
@ stdcall KsDefaultForwardIrp(ptr ptr)
@ stdcall KsAddIrpToCancelableQueue(ptr ptr ptr long ptr)
@ stdcall KsAddObjectCreateItemToDeviceHeader(ptr ptr ptr wstr ptr)
@ stdcall KsAddObjectCreateItemToObjectHeader(ptr ptr ptr wstr ptr)

17
reactos/drivers/ksfilter/ks/ksfunc.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef KSFUNC_H__
#define KSFUNC_H__
#include "ksiface.h"
NTSTATUS
NTAPI
NewIKsDevice(IKsDevice** OutDevice);
#endif

101
reactos/drivers/ksfilter/ks/ksiface.h Normal file
View file

@ -0,0 +1,101 @@
#ifndef KSIFACE_H__
#define KSIFACE_H__
#include <ntddk.h>
#include <ks.h>
/*****************************************************************************
* IKsFilterFactory
*****************************************************************************
*/
#undef INTERFACE
#define INTERFACE IKsFilterFactory
struct KSFILTERFACTORY;
DECLARE_INTERFACE_(IKsFilterFactory, IUnknown)
{
//DEFINE_ABSTRACT_UNKNOWN()
STDMETHOD_(struct KSFILTERFACTORY*,GetStruct)(THIS) PURE;
STDMETHOD_(NTSTATUS,SetDeviceClassesState)(THIS_
IN ULONG Unknown1,
IN BOOLEAN Enable)PURE;
};
/*****************************************************************************
* IKsPowerNotify
*****************************************************************************
*/
#undef INTERFACE
#define INTERFACE IKsPowerNotify
DECLARE_INTERFACE_(IKsPowerNotify, IUnknown)
{
//DEFINE_ABSTRACT_UNKNOWN()
STDMETHOD_(ULONG,Sleep)(THIS_
IN DEVICE_POWER_STATE State) PURE;
STDMETHOD_(ULONG,Wake)(THIS) PURE;
};
/*****************************************************************************
* IKsDevice
*****************************************************************************
*/
#undef INTERFACE
#define INTERFACE IKsDevice
struct KSIOBJECTBAG;
struct KSPOWER_ENTRY;
DECLARE_INTERFACE_(IKsDevice, IUnknown)
{
//DEFINE_ABSTRACT_UNKNOWN()
STDMETHOD_(struct KSDEVICE*,GetStruct)(THIS) PURE;
STDMETHOD_(NTSTATUS, InitializeObjectBag)(THIS_
IN struct KSIOBJECTBAG *Bag,
IN KMUTANT * Mutant) PURE;
STDMETHOD_(ULONG,AcquireDevice)(THIS) PURE;
STDMETHOD_(ULONG,ReleaseDevice)(THIS) PURE;
STDMETHOD_(VOID, GetAdapterObject)(THIS_
IN PADAPTER_OBJECT Object,
IN PULONG Unknown1,
IN PULONG Unknown2) PURE;
STDMETHOD_(VOID, AddPowerEntry)(THIS_
IN struct KSPOWER_ENTRY * Entry,
IN struct IKsPowerNotify* Notify)PURE;
STDMETHOD_(VOID, RemovePowerEntry)(THIS_
IN struct KSPOWER_ENTRY * Entry)PURE;
STDMETHOD_(NTSTATUS, PinStateChange)(THIS_
IN KSPIN Pin,
IN PIRP Irp,
IN KSSTATE OldState,
IN KSSTATE NewState)PURE;
STDMETHOD_(NTSTATUS, ArbitrateAdapterChannel)(THIS_
IN ULONG ControlCode,
IN IO_ALLOCATION_ACTION Action,
IN PVOID Context)PURE;
STDMETHOD_(NTSTATUS, CheckIoCapability)(THIS_
IN ULONG Unknown)PURE;
};
#endif

14
reactos/drivers/ksfilter/ks/misc.c
View file

@ -218,17 +218,5 @@ KsSynchronousIoControlDevice(
return STATUS_UNSUCCESSFUL;
}
/*
@unimplemented
*/
KSDDKAPI NTSTATUS NTAPI
KsInitializeDriver(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
IN const KSDEVICE_DESCRIPTOR *Descriptor OPTIONAL
)
{
UNIMPLEMENTED;
return STATUS_UNSUCCESSFUL;
}