ndisuio.h File Reference

#include <ndis.h>
#include <nuiouser.h>

Include dependency graph for ndisuio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_NDISUIO_ADAPTER_CONTEXT
struct	_NDISUIO_OPEN_ENTRY
struct	_NDISUIO_PACKET_ENTRY

Macros
#define	NDIS_MAJOR_VERSION   5
#define	NDIS_MINOR_VERSION   0

Typedefs
typedef struct _NDISUIO_ADAPTER_CONTEXT	NDISUIO_ADAPTER_CONTEXT
typedef struct _NDISUIO_ADAPTER_CONTEXT *	PNDISUIO_ADAPTER_CONTEXT
typedef struct _NDISUIO_OPEN_ENTRY	NDISUIO_OPEN_ENTRY
typedef struct _NDISUIO_OPEN_ENTRY *	PNDISUIO_OPEN_ENTRY
typedef struct _NDISUIO_PACKET_ENTRY	NDISUIO_PACKET_ENTRY
typedef struct _NDISUIO_PACKET_ENTRY *	PNDISUIO_PACKET_ENTRY

Functions
NTSTATUS NTAPI	NduDispatchCreate (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	NduDispatchClose (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	NduDispatchDeviceControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NDIS_STATUS	AllocateAndChainBuffer (PNDISUIO_ADAPTER_CONTEXT AdapterContext, PNDIS_PACKET Packet, PVOID Buffer, ULONG BufferSize, BOOLEAN Front)
PNDIS_PACKET	CreatePacketFromPoolBuffer (PNDISUIO_ADAPTER_CONTEXT AdapterContext, PVOID Buffer, ULONG BufferSize)
VOID	CleanupAndFreePacket (PNDIS_PACKET Packet, BOOLEAN FreePool)
PNDISUIO_ADAPTER_CONTEXT	FindAdapterContextByName (PNDIS_STRING DeviceName)
VOID	ReferenceAdapterContext (PNDISUIO_ADAPTER_CONTEXT AdapterContext)
VOID	DereferenceAdapterContextWithOpenEntry (PNDISUIO_ADAPTER_CONTEXT AdapterContext, PNDISUIO_OPEN_ENTRY OpenEntry)
VOID NTAPI	NduOpenAdapterComplete (NDIS_HANDLE ProtocolBindingContext, NDIS_STATUS Status, NDIS_STATUS OpenStatus)
VOID NTAPI	NduCloseAdapterComplete (NDIS_HANDLE ProtocolBindingContext, NDIS_STATUS Status)
NDIS_STATUS NTAPI	NduNetPnPEvent (NDIS_HANDLE ProtocolBindingContext, PNET_PNP_EVENT NetPnPEvent)
VOID NTAPI	NduSendComplete (NDIS_HANDLE ProtocolBindingContext, PNDIS_PACKET Packet, NDIS_STATUS Status)
VOID NTAPI	NduTransferDataComplete (NDIS_HANDLE ProtocolBindingContext, PNDIS_PACKET Packet, NDIS_STATUS Status, UINT BytesTransferred)
VOID NTAPI	NduResetComplete (NDIS_HANDLE ProtocolBindingContext, NDIS_STATUS Status)
VOID NTAPI	NduRequestComplete (NDIS_HANDLE ProtocolBindingContext, PNDIS_REQUEST NdisRequest, NDIS_STATUS Status)
NDIS_STATUS NTAPI	NduReceive (NDIS_HANDLE ProtocolBindingContext, NDIS_HANDLE MacReceiveContext, PVOID HeaderBuffer, UINT HeaderBufferSize, PVOID LookAheadBuffer, UINT LookaheadBufferSize, UINT PacketSize)
VOID NTAPI	NduReceiveComplete (NDIS_HANDLE ProtocolBindingContext)
VOID NTAPI	NduStatus (NDIS_HANDLE ProtocolBindingContext, NDIS_STATUS GeneralStatus, PVOID StatusBuffer, UINT StatusBufferSize)
VOID NTAPI	NduStatusComplete (NDIS_HANDLE ProtocolBindingContext)
VOID NTAPI	NduBindAdapter (PNDIS_STATUS Status, NDIS_HANDLE BindContext, PNDIS_STRING DeviceName, PVOID SystemSpecific1, PVOID SystemSpecific2)
VOID NTAPI	NduUnbindAdapter (PNDIS_STATUS Status, NDIS_HANDLE ProtocolBindingContext, NDIS_HANDLE UnbindContext)
NTSTATUS NTAPI	NduDispatchRead (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	NduDispatchWrite (PDEVICE_OBJECT DeviceObject, PIRP Irp)

Variables
PDEVICE_OBJECT	GlobalDeviceObject
NDIS_HANDLE	GlobalProtocolHandle
LIST_ENTRY	GlobalAdapterList
KSPIN_LOCK	GlobalAdapterListLock

Macro Definition Documentation

NDIS_MAJOR_VERSION

#define NDIS_MAJOR_VERSION   5

Definition at line 78 of file ndisuio.h.

NDIS_MINOR_VERSION

#define NDIS_MINOR_VERSION   0

Definition at line 79 of file ndisuio.h.

Typedef Documentation

NDISUIO_ADAPTER_CONTEXT

typedef struct _NDISUIO_ADAPTER_CONTEXT NDISUIO_ADAPTER_CONTEXT

NDISUIO_OPEN_ENTRY

typedef struct _NDISUIO_OPEN_ENTRY NDISUIO_OPEN_ENTRY

NDISUIO_PACKET_ENTRY

typedef struct _NDISUIO_PACKET_ENTRY NDISUIO_PACKET_ENTRY

PNDISUIO_ADAPTER_CONTEXT

typedef struct _NDISUIO_ADAPTER_CONTEXT * PNDISUIO_ADAPTER_CONTEXT

PNDISUIO_OPEN_ENTRY

typedef struct _NDISUIO_OPEN_ENTRY * PNDISUIO_OPEN_ENTRY

PNDISUIO_PACKET_ENTRY

typedef struct _NDISUIO_PACKET_ENTRY * PNDISUIO_PACKET_ENTRY

Function Documentation

AllocateAndChainBuffer()

NDIS_STATUS AllocateAndChainBuffer	(	PNDISUIO_ADAPTER_CONTEXT	AdapterContext,
		PNDIS_PACKET	Packet,
		PVOID	Buffer,
		ULONG	BufferSize,
		BOOLEAN	Front
	)

Definition at line 15 of file misc.c.

{
    NDIS_STATUS Status;
    PNDIS_BUFFER NdisBuffer;
 
    /* Allocate the NDIS buffer mapping the pool */
    NdisAllocateBuffer(&Status,
                       &NdisBuffer,
                       AdapterContext->BufferPoolHandle,
                       Buffer,
                       BufferSize);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        DPRINT1("No free buffer descriptors\n");
        return Status;
    }
 
    if (Front)
    {
        /* Chain the buffer to front */
        NdisChainBufferAtFront(Packet, NdisBuffer);
    }
    else
    {
        /* Chain the buffer to back */
        NdisChainBufferAtBack(Packet, NdisBuffer);
    }
 
    /* Return success */
    return NDIS_STATUS_SUCCESS;
}

Referenced by CreatePacketFromPoolBuffer().

CleanupAndFreePacket()

VOID CleanupAndFreePacket	(	PNDIS_PACKET	Packet,
		BOOLEAN	FreePool
	)

Definition at line 83 of file misc.c.

{
    PNDIS_BUFFER Buffer;
    PVOID Data;
    ULONG Length;
 
    /* Free each buffer and its backing pool memory */
    while (TRUE)
    {
        /* Unchain each buffer */
        NdisUnchainBufferAtFront(Packet, &Buffer);
        if (!Buffer)
            break;
 
        /* Get the backing memory */
        NdisQueryBuffer(Buffer, &Data, &Length);
 
        /* Free the buffer */
        NdisFreeBuffer(Buffer);
 
        if (FreePool)
        {
            /* Free the backing memory */
            ExFreePool(Data);
        }
    }
 
    /* Free the packet descriptor */
    NdisFreePacket(Packet);
}

Referenced by NduDispatchWrite(), and NduReceive().

CreatePacketFromPoolBuffer()

PNDIS_PACKET CreatePacketFromPoolBuffer	(	PNDISUIO_ADAPTER_CONTEXT	AdapterContext,
		PVOID	Buffer,
		ULONG	BufferSize
	)

Definition at line 52 of file misc.c.

{
    PNDIS_PACKET Packet;
    NDIS_STATUS Status;
 
    /* Allocate a packet descriptor */
    NdisAllocatePacket(&Status,
                       &Packet,
                       AdapterContext->PacketPoolHandle);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        DPRINT1("No free packet descriptors\n");
        return NULL;
    }
 
    /* Use the helper to chain the buffer */
    Status = AllocateAndChainBuffer(AdapterContext, Packet,
                                    Buffer, BufferSize, TRUE);
    if (Status != NDIS_STATUS_SUCCESS)
    {
        NdisFreePacket(Packet);
        return NULL;
    }
 
    /* Return the packet */
    return Packet;
}

Referenced by NduDispatchWrite(), and NduReceive().

DereferenceAdapterContextWithOpenEntry()

VOID DereferenceAdapterContextWithOpenEntry	(	PNDISUIO_ADAPTER_CONTEXT	AdapterContext,
		PNDISUIO_OPEN_ENTRY	OpenEntry
	)

Definition at line 149 of file misc.c.

{
    KIRQL OldIrql;
 
    /* Lock the adapter context */
    KeAcquireSpinLock(&AdapterContext->Spinlock, &OldIrql);
 
    /* Decrement the open count */
    AdapterContext->OpenCount--;
 
    /* Cleanup the open entry if we were given one */
    if (OpenEntry != NULL)
    {
        /* Remove the open entry */
        RemoveEntryList(&OpenEntry->ListEntry);
 
        /* Invalidate the FO */
        OpenEntry->FileObject->FsContext = NULL;
        OpenEntry->FileObject->FsContext2 = NULL;
 
        /* Free the open entry */
        ExFreePool(OpenEntry);
    }
 
    /* Release the adapter context lock */
    KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
}

Referenced by NduDispatchClose(), and OpenDeviceReadWrite().

FindAdapterContextByName()

PNDISUIO_ADAPTER_CONTEXT FindAdapterContextByName

(

PNDIS_STRING

DeviceName

)

Definition at line 115 of file misc.c.

{
    KIRQL OldIrql;
    PLIST_ENTRY CurrentEntry;
    PNDISUIO_ADAPTER_CONTEXT AdapterContext;
 
    KeAcquireSpinLock(&GlobalAdapterListLock, &OldIrql);
    CurrentEntry = GlobalAdapterList.Flink;
    while (CurrentEntry != &GlobalAdapterList)
    {
        AdapterContext = CONTAINING_RECORD(CurrentEntry, NDISUIO_ADAPTER_CONTEXT, ListEntry);
 
        /* Check if the device name matches */
        if (RtlEqualUnicodeString(&AdapterContext->DeviceName, DeviceName, TRUE))
        {
            KeReleaseSpinLock(&GlobalAdapterListLock, OldIrql);
            return AdapterContext;
        }
 
        CurrentEntry = CurrentEntry->Flink;
    }
    KeReleaseSpinLock(&GlobalAdapterListLock, OldIrql);
 
    return NULL;
}

Referenced by OpenDeviceReadWrite().

NduBindAdapter()

VOID NTAPI NduBindAdapter	(	PNDIS_STATUS	Status,
		NDIS_HANDLE	BindContext,
		PNDIS_STRING	DeviceName,
		PVOID	SystemSpecific1,
		PVOID	SystemSpecific2
	)

Definition at line 538 of file protocol.c.

{
    /* Use our helper function to create a context for this adapter */
    *Status = BindAdapterByName(DeviceName);
}

Referenced by DriverEntry().

NduCloseAdapterComplete()

VOID NTAPI NduCloseAdapterComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		NDIS_STATUS	Status
	)

Definition at line 31 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter close completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduDispatchClose()

NTSTATUS NTAPI NduDispatchClose	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 40 of file createclose.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
    PNDISUIO_OPEN_ENTRY OpenEntry = IrpSp->FileObject->FsContext2;
 
    ASSERT(DeviceObject == GlobalDeviceObject);
 
    DPRINT("Closing file object 0x%x\n", IrpSp->FileObject);
 
    /* Check if this handle was ever associated with an adapter */
    if (AdapterContext != NULL)
    {
        ASSERT(OpenEntry != NULL);
 
        DPRINT("Removing binding to adapter %wZ\n", &AdapterContext->DeviceName);
 
        /* Call the our helper */
        DereferenceAdapterContextWithOpenEntry(AdapterContext, OpenEntry);
    }
 
    /* Completed */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    /* Return success */
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

NduDispatchCreate()

NTSTATUS NTAPI NduDispatchCreate	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 16 of file createclose.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    ASSERT(DeviceObject == GlobalDeviceObject);
 
    DPRINT("Created file object 0x%x\n", IrpSp->FileObject);
 
    /* This is associated with an adapter during IOCTL_NDISUIO_OPEN_(WRITE_)DEVICE */
    IrpSp->FileObject->FsContext = NULL;
    IrpSp->FileObject->FsContext2 = NULL;
 
    /* Completed successfully */
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = FILE_OPENED;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    /* Return success */
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

NduDispatchDeviceControl()

NTSTATUS NTAPI NduDispatchDeviceControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 469 of file ioctl.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PNDISUIO_OPEN_ENTRY OpenEntry;
 
    ASSERT(DeviceObject == GlobalDeviceObject);
 
    /* Handle open IOCTLs first */
    switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
    {
        case IOCTL_NDISUIO_OPEN_DEVICE:
            return OpenDeviceReadWrite(Irp, IrpSp);
#if 0
        case IOCTL_NDISUIO_OPEN_WRITE_DEVICE:
            return OpenDeviceWrite(Irp, IrpSp);
#endif
        case IOCTL_NDISUIO_BIND_WAIT:
            return WaitForBind(Irp, IrpSp);
 
        case IOCTL_NDISUIO_QUERY_BINDING:
            return QueryBinding(Irp, IrpSp);
 
        default:
            /* Fail if this file object has no adapter associated */
            if (IrpSp->FileObject->FsContext == NULL)
            {
                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                Irp->IoStatus.Information = 0;
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
                return STATUS_INVALID_PARAMETER;
            }
 
            /* Now handle write IOCTLs */
            switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
            {
                case IOCTL_NDISUIO_SET_OID_VALUE:
                    return SetAdapterOid(Irp, IrpSp);
 
                default:
                    /* Check that we have read permissions */
                    OpenEntry = IrpSp->FileObject->FsContext2;
                    if (OpenEntry->WriteOnly)
                    {
                        Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                        Irp->IoStatus.Information = 0;
                        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
                        return STATUS_INVALID_PARAMETER;
                    }
 
                    switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
                    {
#if 0
                        case IOCTL_CANCEL_READ:
                            return CancelPacketRead(Irp, IrpSp);
#endif
 
                        case IOCTL_NDISUIO_QUERY_OID_VALUE:
                            return QueryAdapterOid(Irp, IrpSp);
 
                        default:
                            DPRINT1("Unimplemented\n");
                            Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
                            Irp->IoStatus.Information = 0;
                            IoCompleteRequest(Irp, IO_NO_INCREMENT);
                            return STATUS_NOT_IMPLEMENTED;
                    }
            }
            break;
    }
}

Referenced by DriverEntry().

NduDispatchRead()

NTSTATUS NTAPI NduDispatchRead	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 42 of file readwrite.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
    PNDISUIO_OPEN_ENTRY OpenEntry = IrpSp->FileObject->FsContext2;
    KIRQL OldIrql, OldCancelIrql;
    NTSTATUS Status;
    PLIST_ENTRY ListEntry;
    PNDISUIO_PACKET_ENTRY PacketEntry = NULL;
    ULONG BytesCopied = 0;
 
    ASSERT(DeviceObject == GlobalDeviceObject);
 
    if (OpenEntry->WriteOnly)
    {
        Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Make the read cancellable */
    IoAcquireCancelSpinLock(&OldCancelIrql);
    IoSetCancelRoutine(Irp, ReadIrpCancel);
    if (Irp->Cancel)
    {
        IoReleaseCancelSpinLock(OldCancelIrql);
 
        /* Indicate a 0 byte read */
        Irp->IoStatus.Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = 0;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
        return STATUS_SUCCESS;
    }
    IoReleaseCancelSpinLock(OldCancelIrql);
 
    while (TRUE)
    {
        KeAcquireSpinLock(&AdapterContext->Spinlock, &OldIrql);
 
        /* Check if we have a packet */
        if (IsListEmpty(&AdapterContext->PacketList))
        {
            KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
 
            /* Wait for a packet (in the context of the calling user thread) */
            Status = KeWaitForSingleObject(&AdapterContext->PacketReadEvent,
                                           UserRequest,
                                           UserMode,
                                           TRUE,
                                           NULL);
            if (Status != STATUS_SUCCESS)
            {
                /* Remove the cancel routine */
                IoAcquireCancelSpinLock(&OldCancelIrql);
                IoSetCancelRoutine(Irp, NULL);
                IoReleaseCancelSpinLock(OldCancelIrql);
 
                break;
            }
        }
        else
        {
            /* Remove the cancel routine */
            IoAcquireCancelSpinLock(&OldCancelIrql);
            IoSetCancelRoutine(Irp, NULL);
            IoReleaseCancelSpinLock(OldCancelIrql);
 
            /* Remove the first packet in the list */
            ListEntry = RemoveHeadList(&AdapterContext->PacketList);
            PacketEntry = CONTAINING_RECORD(ListEntry, NDISUIO_PACKET_ENTRY, ListEntry);
 
            /* Release the adapter lock */
            KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
 
            /* And we're done with this loop */
            Status = STATUS_SUCCESS;
            break;
        }
    }
 
    /* Check if we got a packet */
    if (PacketEntry != NULL)
    {
        /* Find the right amount of bytes to copy */
        BytesCopied = PacketEntry->PacketLength;
        if (BytesCopied > IrpSp->Parameters.Read.Length)
            BytesCopied = IrpSp->Parameters.Read.Length;
 
        /* Copy the packet */
        RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,
                      &PacketEntry->PacketData[0],
                      BytesCopied);
 
        /* Free the packet entry */
        ExFreePool(PacketEntry);
    }
    else
    {
        /* Something failed */
        BytesCopied = 0;
    }
 
    /* Complete the IRP */
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = BytesCopied;
    IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 
    return Status;
}

Referenced by DriverEntry().

NduDispatchWrite()

NTSTATUS NTAPI NduDispatchWrite	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 158 of file readwrite.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
    PNDIS_PACKET Packet;
    NDIS_STATUS Status;
    ULONG BytesCopied = 0;
 
    ASSERT(DeviceObject == GlobalDeviceObject);
 
    /* Create a packet and buffer descriptor for this user buffer */
    Packet = CreatePacketFromPoolBuffer(AdapterContext,
                                        Irp->AssociatedIrp.SystemBuffer,
                                        IrpSp->Parameters.Write.Length);
    if (Packet)
    {
        /* Send it via NDIS */
        NdisSend(&Status,
                 AdapterContext->BindingHandle,
                 Packet);
 
        /* Wait for the send */
        if (Status == NDIS_STATUS_PENDING)
        {
            KeWaitForSingleObject(&AdapterContext->AsyncEvent,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            Status = AdapterContext->AsyncStatus;
        }
 
        /* Check if it succeeded */
        if (Status == NDIS_STATUS_SUCCESS)
            BytesCopied = IrpSp->Parameters.Write.Length;
 
        CleanupAndFreePacket(Packet, FALSE);
    }
    else
    {
        /* No memory */
        Status = STATUS_NO_MEMORY;
    }
 
    /* Complete the IRP */
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = BytesCopied;
    IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 
    return Status;
}

Referenced by DriverEntry().

NduNetPnPEvent()

NDIS_STATUS NTAPI NduNetPnPEvent	(	NDIS_HANDLE	ProtocolBindingContext,
		PNET_PNP_EVENT	NetPnPEvent
	)

Definition at line 45 of file protocol.c.

{
    PNDIS_DEVICE_POWER_STATE PowerState;
 
    DPRINT("NetPnPEvent\n");
 
    switch (NetPnPEvent->NetEvent)
    {
        case NetEventQueryRemoveDevice:
            /* Nothing to do */
            DPRINT1("NetPnPEvent: QueryRemoveDevice\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventSetPower:
            ASSERT(NetPnPEvent->BufferLength >= sizeof(*PowerState));
 
            PowerState = NetPnPEvent->Buffer;
            switch (*PowerState)
            {
                case NdisDeviceStateD0:
                    DPRINT1("NetPnPEvent: SetPower D0\n");
                    return NDIS_STATUS_SUCCESS;
 
                default:
                    DPRINT1("NetPnPEvent: SetPower state %d not supported\n", *PowerState);
                    return NDIS_STATUS_FAILURE;
            }
 
        case NetEventQueryPower:
            DPRINT1("NetPnPEvent: QueryPower\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventCancelRemoveDevice:
            DPRINT1("NetPnPEvent: CancelRemoveDevice\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventReconfigure:
            DPRINT1("NetPnPEvent: Reconfigure\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventBindList:
            DPRINT1("NetPnPEvent: BindList\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventBindsComplete:
            DPRINT("NetPnPEvent: BindsComplete\n");
            return NDIS_STATUS_SUCCESS;
 
        case NetEventPnPCapabilities:
            DPRINT1("NetPnPEvent: PnPCapabilities\n");
            return NDIS_STATUS_SUCCESS;
 
        default:
            DPRINT1("NetPnPEvent unimplemented for net event 0x%x\n", NetPnPEvent->NetEvent);
            return NDIS_STATUS_FAILURE;
    }
}

Referenced by DriverEntry().

NduOpenAdapterComplete()

VOID NTAPI NduOpenAdapterComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		NDIS_STATUS	Status,
		NDIS_STATUS	OpenStatus
	)

Definition at line 16 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter open completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduReceive()

NDIS_STATUS NTAPI NduReceive	(	NDIS_HANDLE	ProtocolBindingContext,
		NDIS_HANDLE	MacReceiveContext,
		PVOID	HeaderBuffer,
		UINT	HeaderBufferSize,
		PVOID	LookAheadBuffer,
		UINT	LookaheadBufferSize,
		UINT	PacketSize
	)

Definition at line 166 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
    PNDISUIO_PACKET_ENTRY PacketEntry;
    PVOID PacketBuffer;
    PNDIS_PACKET Packet;
    NDIS_STATUS Status;
    UINT BytesTransferred;
 
    DPRINT("Received a %d byte packet\n", PacketSize);
 
    /* Discard if nobody is waiting for it */
    if (AdapterContext->OpenCount == 0)
        return NDIS_STATUS_NOT_ACCEPTED;
 
    /* Allocate a buffer to hold the packet data and header */
    PacketBuffer = ExAllocatePool(NonPagedPool, PacketSize + HeaderBufferSize);
    if (!PacketBuffer)
        return NDIS_STATUS_NOT_ACCEPTED;
 
    /* Allocate the packet descriptor and buffer */
    Packet = CreatePacketFromPoolBuffer(AdapterContext,
                                        (PUCHAR)PacketBuffer + HeaderBufferSize,
                                        PacketSize);
    if (!Packet)
    {
        ExFreePool(PacketBuffer);
        return NDIS_STATUS_NOT_ACCEPTED;
    }
 
    /* Transfer the packet data into our data buffer */
    if (LookaheadBufferSize == PacketSize)
    {
        NdisCopyLookaheadData((PVOID)((PUCHAR)PacketBuffer + HeaderBufferSize),
                              LookAheadBuffer,
                              PacketSize,
                              AdapterContext->MacOptions);
        BytesTransferred = PacketSize;
    }
    else
    {
        NdisTransferData(&Status,
                         AdapterContext->BindingHandle,
                         MacReceiveContext,
                         0,
                         PacketSize,
                         Packet,
                         &BytesTransferred);
        if (Status == NDIS_STATUS_PENDING)
        {
            KeWaitForSingleObject(&AdapterContext->AsyncEvent,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            Status = AdapterContext->AsyncStatus;
        }
        if (Status != NDIS_STATUS_SUCCESS)
        {
            DPRINT1("Failed to transfer data with status 0x%x\n", Status);
            CleanupAndFreePacket(Packet, FALSE);
            ExFreePool(PacketBuffer);
            return NDIS_STATUS_NOT_ACCEPTED;
        }
    }
 
    /* Copy the header data */
    RtlCopyMemory(PacketBuffer, HeaderBuffer, HeaderBufferSize);
 
    /* Free the packet descriptor and buffers
       but not the pool because we still need it */
    CleanupAndFreePacket(Packet, FALSE);
 
    /* Allocate a packet entry from pool */
    PacketEntry = ExAllocatePool(NonPagedPool, sizeof(NDISUIO_PACKET_ENTRY) + BytesTransferred + HeaderBufferSize - 1);
    if (!PacketEntry)
    {
        ExFreePool(PacketBuffer);
        return NDIS_STATUS_RESOURCES;
    }
 
    /* Initialize the packet entry and copy in packet data */
    PacketEntry->PacketLength = BytesTransferred + HeaderBufferSize;
    RtlCopyMemory(PacketEntry->PacketData, PacketBuffer, PacketEntry->PacketLength);
 
    /* Free the old buffer */
    ExFreePool(PacketBuffer);
 
    /* Insert the packet on the adapter's packet list */
    ExInterlockedInsertTailList(&AdapterContext->PacketList,
                                &PacketEntry->ListEntry,
                                &AdapterContext->Spinlock);
 
    /* Signal the read event */
    KeSetEvent(&AdapterContext->PacketReadEvent,
               IO_NETWORK_INCREMENT,
               FALSE);
 
    return NDIS_STATUS_SUCCESS;
}

Referenced by DriverEntry().

NduReceiveComplete()

VOID NTAPI NduReceiveComplete

(

NDIS_HANDLE

ProtocolBindingContext

)

Definition at line 275 of file protocol.c.

{
    /* No op */
}

Referenced by DriverEntry().

NduRequestComplete()

VOID NTAPI NduRequestComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		PNDIS_REQUEST	NdisRequest,
		NDIS_STATUS	Status
	)

Definition at line 151 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter request completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduResetComplete()

VOID NTAPI NduResetComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		NDIS_STATUS	Status
	)

Definition at line 137 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter reset completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduSendComplete()

VOID NTAPI NduSendComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		PNDIS_PACKET	Packet,
		NDIS_STATUS	Status
	)

Definition at line 106 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter send completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduStatus()

VOID NTAPI NduStatus	(	NDIS_HANDLE	ProtocolBindingContext,
		NDIS_STATUS	GeneralStatus,
		PVOID	StatusBuffer,
		UINT	StatusBufferSize
	)

Definition at line 282 of file protocol.c.

{
    /* FIXME: Implement status tracking */
}

Referenced by DriverEntry().

NduStatusComplete()

VOID NTAPI NduStatusComplete

(

NDIS_HANDLE

ProtocolBindingContext

)

Definition at line 292 of file protocol.c.

{
    /* FIXME: Implement status tracking */
}

Referenced by DriverEntry().

NduTransferDataComplete()

VOID NTAPI NduTransferDataComplete	(	NDIS_HANDLE	ProtocolBindingContext,
		PNDIS_PACKET	Packet,
		NDIS_STATUS	Status,
		UINT	BytesTransferred
	)

Definition at line 121 of file protocol.c.

{
    PNDISUIO_ADAPTER_CONTEXT AdapterContext = ProtocolBindingContext;
 
    DPRINT("Asynchronous adapter transfer completed\n");
 
    /* Store the final status and signal the event */
    AdapterContext->AsyncStatus = Status;
    KeSetEvent(&AdapterContext->AsyncEvent, IO_NO_INCREMENT, FALSE);
}

Referenced by DriverEntry().

NduUnbindAdapter()

VOID NTAPI NduUnbindAdapter	(	PNDIS_STATUS	Status,
		NDIS_HANDLE	ProtocolBindingContext,
		NDIS_HANDLE	UnbindContext
	)

Definition at line 550 of file protocol.c.

{
    /* This is forced unbind. UnbindAdapterByContext() will take care of
     * invalidating file handles pointer to this adapter for us */
    *Status = UnbindAdapterByContext(ProtocolBindingContext);
}

Referenced by DriverEntry().

ReferenceAdapterContext()

VOID ReferenceAdapterContext

(

PNDISUIO_ADAPTER_CONTEXT

AdapterContext

)

Definition at line 142 of file misc.c.

{
    /* Increment the open count */
    AdapterContext->OpenCount++;
}

Referenced by OpenDeviceReadWrite().

Variable Documentation

GlobalAdapterList

LIST_ENTRY GlobalAdapterList

extern

Definition at line 17 of file main.c.

Referenced by BindAdapterByName(), DriverEntry(), FindAdapterContextByName(), and QueryBinding().

GlobalAdapterListLock

KSPIN_LOCK GlobalAdapterListLock

extern

Definition at line 16 of file main.c.

Referenced by BindAdapterByName(), DriverEntry(), FindAdapterContextByName(), QueryBinding(), and UnbindAdapterByContext().

GlobalDeviceObject

PDEVICE_OBJECT GlobalDeviceObject

extern

Definition at line 14 of file main.c.

Referenced by DriverEntry(), NduDispatchClose(), NduDispatchCreate(), NduDispatchDeviceControl(), NduDispatchRead(), and NduDispatchWrite().

GlobalProtocolHandle

NDIS_HANDLE GlobalProtocolHandle

extern

Definition at line 15 of file main.c.

Referenced by BindAdapterByName(), and DriverEntry().