tditest.c File Reference

#include <tditest.h>
#include <pseh/pseh2.h>

Include dependency graph for tditest.c:

Go to the source code of this file.

Functions
NTSTATUS	TdiCall (PIRP Irp, PDEVICE_OBJECT DeviceObject, PIO_STATUS_BLOCK IoStatusBlock, BOOLEAN CanCancel)
NTSTATUS	TdiOpenDevice (PWSTR Protocol, ULONG EaLength, PFILE_FULL_EA_INFORMATION EaInfo, PHANDLE Handle, PFILE_OBJECT *Object)
NTSTATUS	TdiCloseDevice (HANDLE Handle, PFILE_OBJECT FileObject)
NTSTATUS	TdiOpenTransport (PWSTR Protocol, USHORT Port, PHANDLE Transport, PFILE_OBJECT *TransportObject)
NTSTATUS	TdiQueryDeviceControl (PFILE_OBJECT FileObject, ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength, PULONG Return)
	Queries a device for information.
NTSTATUS	TdiQueryInformationEx (PFILE_OBJECT FileObject, ULONG Entity, ULONG Instance, ULONG Class, ULONG Type, ULONG Id, PVOID OutputBuffer, PULONG OutputLength)
NTSTATUS	TdiQueryAddress (PFILE_OBJECT FileObject, PULONG Address)
NTSTATUS	TdiSendDatagram (PFILE_OBJECT TransportObject, USHORT Port, ULONG Address, PVOID Buffer, ULONG BufferSize)
NTSTATUS	TdiReceiveDatagram (PFILE_OBJECT TransportObject, USHORT Port, PULONG Address, PUCHAR Buffer, PULONG BufferSize)
VOID	TdiSendThread (PVOID Context)
VOID	TdiReceiveThread (PVOID Context)
VOID	TdiOpenThread (PVOID Context)
VOID	TdiUnload (PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)

Variables
HANDLE	TdiTransport = 0
PFILE_OBJECT	TdiTransportObject = NULL
ULONG	LocalAddress
BOOLEAN	OpenError
KEVENT	StopEvent
HANDLE	SendThread
HANDLE	ReceiveThread

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 889 of file tditest.c.

{
    KEVENT Event;
    NTSTATUS Status;
    WORK_QUEUE_ITEM WorkItem;
 
    KeInitializeEvent(&StopEvent, NotificationEvent, FALSE);
 
    /* Call TdiOpenThread() */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
    ExInitializeWorkItem(&WorkItem, (PWORKER_THREAD_ROUTINE)TdiOpenThread, &Event);
    ExQueueWorkItem(&WorkItem, DelayedWorkQueue);
    KeWaitForSingleObject(&Event, Executive, KernelMode, TRUE, NULL);
 
    /* Create a UDP send thread that sends a dgram every 2 seconds */
    Status = PsCreateSystemThread(
        &SendThread,                      /* Thread handle */
        0,                                /* Desired access */
        NULL,                             /* Object attributes */
        NULL,                             /* Process handle */
        NULL,                             /* Client id */
        (PKSTART_ROUTINE)TdiSendThread,   /* Start routine */
        NULL);                            /* Start context */
 
    if (!NT_SUCCESS(Status))
        {
            TDI_DbgPrint(MIN_TRACE, ("PsCreateSystemThread() failed for send thread (Status = 0x%X).\n", Status));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    /* Create a UDP receive thread */
    Status = PsCreateSystemThread(
        &ReceiveThread,                       /* Thread handle */
        0,                                    /* Desired access */
        NULL,                                 /* Object attributes */
        NULL,                                 /* Process handle */
        NULL,                                 /* Client id */
        (PKSTART_ROUTINE)TdiReceiveThread,    /* Start routine */
        NULL);                                /* Start context */
 
    if (!NT_SUCCESS(Status))
        {
            TDI_DbgPrint(MIN_TRACE, ("PsCreateSystemThread() failed for receive thread (Status = 0x%X).\n", Status));
            ZwClose(SendThread);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    DriverObject->DriverUnload = (PDRIVER_UNLOAD)TdiUnload;
 
    return STATUS_SUCCESS;
}

TdiCall()

NTSTATUS TdiCall	(	PIRP	Irp,
		PDEVICE_OBJECT	DeviceObject,
		PIO_STATUS_BLOCK	IoStatusBlock,
		BOOLEAN	CanCancel
	)

Definition at line 32 of file tditest.c.

{
    KEVENT Event;
    PKEVENT Events[2];
    NTSTATUS Status;
    Events[0] = &StopEvent;
    Events[1] = &Event;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
    Irp->UserEvent = &Event;
    Irp->UserIosb  = IoStatusBlock;
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)
        {
            if (CanCancel)
                {
                    Status = KeWaitForMultipleObjects(2, (PVOID)Events, WaitAny, Executive, KernelMode, FALSE, NULL, NULL);
 
                    if (KeReadStateEvent(&StopEvent) != 0)
                        {
                            if (IoCancelIrp(Irp))
                                {
                                    TDI_DbgPrint(MAX_TRACE, ("Cancelled IRP.\n"));
                                }
                            else
                                {
                                    TDI_DbgPrint(MIN_TRACE, ("Could not cancel IRP.\n"));
                                }
                            return STATUS_CANCELLED;
                        }
                }
            else
                Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        }
 
    return (Status == STATUS_SUCCESS)? IoStatusBlock->Status : STATUS_SUCCESS;
}

Referenced by TdiQueryDeviceControl(), TdiReceiveDatagram(), and TdiSendDatagram().

TdiCloseDevice()

NTSTATUS TdiCloseDevice	(	HANDLE	Handle,
		PFILE_OBJECT	FileObject
	)

Definition at line 158 of file tditest.c.

{
    if (FileObject)
        ObDereferenceObject(FileObject);
 
    if (Handle)
        ZwClose(Handle);
 
    return STATUS_SUCCESS;
}

Referenced by TdiUnload().

TdiOpenDevice()

NTSTATUS TdiOpenDevice	(	PWSTR	Protocol,
		ULONG	EaLength,
		PFILE_FULL_EA_INFORMATION	EaInfo,
		PHANDLE	Handle,
		PFILE_OBJECT *	Object
	)

Definition at line 89 of file tditest.c.

{
    OBJECT_ATTRIBUTES Attr;
    IO_STATUS_BLOCK Iosb;
    UNICODE_STRING Name;
    NTSTATUS Status;
 
    RtlInitUnicodeString(&Name, Protocol);
    InitializeObjectAttributes(
        &Attr,                   /* Attribute buffer */
        &Name,                   /* Device name */
        OBJ_CASE_INSENSITIVE,    /* Attributes */
        NULL,                    /* Root directory */
        NULL);                   /* Security descriptor */
 
    Status = ZwCreateFile(
        Handle,                               /* Return file handle */
        GENERIC_READ | GENERIC_WRITE,         /* Desired access */
        &Attr,                                /* Object attributes */
        &Iosb,                                /* IO status */
        0,                                    /* Initial allocation size */
        FILE_ATTRIBUTE_NORMAL,                /* File attributes */
        FILE_SHARE_READ | FILE_SHARE_WRITE,   /* Share access */
        FILE_OPEN_IF,                         /* Create disposition */
        0,                                    /* Create options */
        EaInfo,                               /* EA buffer */
        EaLength);                            /* EA length */
 
    if (NT_SUCCESS(Status))
        {
            Status  = ObReferenceObjectByHandle(
                *Handle,                        /* Handle to open file */
                GENERIC_READ | GENERIC_WRITE,   /* Access mode */
                NULL,                           /* Object type */
                KernelMode,                     /* Access mode */
                (PVOID*)Object,                 /* Pointer to object */
                NULL);                          /* Handle information */
 
            if (!NT_SUCCESS(Status))
                {
                    TDI_DbgPrint(MIN_TRACE, ("ObReferenceObjectByHandle() failed with status (0x%X).\n", Status));
                    ZwClose(*Handle);
                }
        }
    else
        {
            TDI_DbgPrint(MIN_TRACE, ("ZwCreateFile() failed with status (0x%X)\n", Status));
        }
 
    return Status;
}

Referenced by TdiOpenTransport().

TdiOpenThread()

VOID TdiOpenThread

(

PVOID

Context

)

Definition at line 816 of file tditest.c.

{
    NTSTATUS Status;
 
    TDI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    OpenError = TRUE;
 
    Status = TdiOpenTransport(UDP_DEVICE_NAME, TEST_PORT, &TdiTransport, &TdiTransportObject);
 
    if (NT_SUCCESS(Status))
        {
            Status = TdiQueryAddress(TdiTransportObject, &LocalAddress);
 
            if (NT_SUCCESS(Status))
                {
                    OpenError = FALSE;
                    DbgPrint("Using local IP address 0x%X\n", LocalAddress);
                }
            else
                {
                    TDI_DbgPrint(MIN_TRACE, ("Unable to determine local IP address.\n"));
                }
            }
    else
        TDI_DbgPrint(MIN_TRACE, ("Cannot open transport (Status = 0x%X).\n", Status));
 
    TDI_DbgPrint(MAX_TRACE, ("Setting close event.\n"));
 
    KeSetEvent((PKEVENT)Context, 0, FALSE);
 
    TDI_DbgPrint(MIN_TRACE, ("Leaving.\n"));
}

Referenced by DriverEntry().

TdiOpenTransport()

NTSTATUS TdiOpenTransport	(	PWSTR	Protocol,
		USHORT	Port,
		PHANDLE	Transport,
		PFILE_OBJECT *	TransportObject
	)

Definition at line 172 of file tditest.c.

{
    PFILE_FULL_EA_INFORMATION EaInfo;
    PTA_IP_ADDRESS Address;
    NTSTATUS Status;
    ULONG EaLength;
 
    /* EaName must be 0-termed, even though TDI_TRANSPORT_ADDRESS_LENGTH does *not* include the 0 */
    EaLength = sizeof(FILE_FULL_EA_INFORMATION) + TDI_TRANSPORT_ADDRESS_LENGTH + sizeof(TA_IP_ADDRESS) + 1;
    EaInfo = (PFILE_FULL_EA_INFORMATION)ExAllocatePool(NonPagedPool, EaLength);
 
    if (!EaInfo)
        {
            TDI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    RtlZeroMemory(EaInfo, EaLength);
 
    EaInfo->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
 
    /* don't copy the 0; we have already zeroed it */
    RtlCopyMemory(EaInfo->EaName, TdiTransportAddress, TDI_TRANSPORT_ADDRESS_LENGTH);
 
    EaInfo->EaValueLength = sizeof(TA_IP_ADDRESS);
    Address = (PTA_IP_ADDRESS)(EaInfo->EaName + TDI_TRANSPORT_ADDRESS_LENGTH + 1); // 0-term
    Address->TAAddressCount                 = 1;
    Address->Address[0].AddressLength       = TDI_ADDRESS_LENGTH_IP;
    Address->Address[0].AddressType         = TDI_ADDRESS_TYPE_IP;
    Address->Address[0].Address[0].sin_port = WH2N(Port);
    Address->Address[0].Address[0].in_addr  = 0;
 
    Status = TdiOpenDevice(Protocol, EaLength, EaInfo, Transport, TransportObject);
 
    ExFreePool(EaInfo);
 
    return Status;
}

Referenced by TdiOpenThread().

TdiQueryAddress()

NTSTATUS TdiQueryAddress	(	PFILE_OBJECT	FileObject,
		PULONG	Address
	)

Definition at line 319 of file tditest.c.

{
    ULONG i;
    TDIEntityID *Entities;
    ULONG EntityCount;
    ULONG EntityType;
    IPSNMP_INFO SnmpInfo;
    PIPADDR_ENTRY IpAddress;
    ULONG BufferSize;
    NTSTATUS Status = STATUS_SUCCESS;
 
    TDI_DbgPrint(MAX_TRACE, ("Called\n"));
 
    BufferSize = sizeof(TDIEntityID) * 20;
    Entities   = (TDIEntityID*)ExAllocatePool(NonPagedPool, BufferSize);
 
    if (!Entities)
        {
            TDI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    /* Query device for supported entities */
    Status = TdiQueryInformationEx(
        FileObject,          /* File object */
        GENERIC_ENTITY,      /* Entity */
        TL_INSTANCE,         /* Instance */
        INFO_CLASS_GENERIC,  /* Entity class */
        INFO_TYPE_PROVIDER,  /* Entity type */
        ENTITY_LIST_ID,      /* Entity id */
        Entities,            /* Output buffer */
        &BufferSize);        /* Output buffer size */
 
    if (!NT_SUCCESS(Status))
        {
            TDI_DbgPrint(MIN_TRACE, ("Unable to get list of supported entities (Status = 0x%X).\n", Status));
            ExFreePool(Entities);
            return Status;
        }
 
    /* Locate an IP entity */
    EntityCount = BufferSize / sizeof(TDIEntityID);
 
    TDI_DbgPrint(MAX_TRACE, ("EntityCount = %d\n", EntityCount));
 
    for (i = 0; i < EntityCount; i++)
        {
            if (Entities[i].tei_entity == CL_NL_ENTITY)
                {
                    /* Query device for entity type */
                    BufferSize = sizeof(EntityType);
                    Status = TdiQueryInformationEx(
                        FileObject,                  /* File object */
                        CL_NL_ENTITY,                /* Entity */
                        Entities[i].tei_instance,    /* Instance */
                        INFO_CLASS_GENERIC,          /* Entity class */
                        INFO_TYPE_PROVIDER,          /* Entity type */
                        ENTITY_TYPE_ID,              /* Entity id */
                        &EntityType,                 /* Output buffer */
                        &BufferSize);                /* Output buffer size */
 
                    if (!NT_SUCCESS(Status) || (EntityType != CL_NL_IP))
                        {
                            TDI_DbgPrint(MIN_TRACE, ("Unable to get entity of type IP (Status = 0x%X).\n", Status));
                            break;
                        }
 
                    /* Query device for SNMP information */
                    BufferSize = sizeof(SnmpInfo);
                    Status = TdiQueryInformationEx(
                        FileObject,                  /* File object */
                        CL_NL_ENTITY,                /* Entity */
                        Entities[i].tei_instance,    /* Instance */
                        INFO_CLASS_PROTOCOL,         /* Entity class */
                        INFO_TYPE_PROVIDER,          /* Entity type */
                        IP_MIB_STATS_ID,             /* Entity id */
                        &SnmpInfo,                   /* Output buffer */
                        &BufferSize);                /* Output buffer size */
 
                    if (!NT_SUCCESS(Status) || (SnmpInfo.NumAddr == 0))
                        {
                            TDI_DbgPrint(MIN_TRACE, ("Unable to get SNMP information or no IP addresses available (Status = 0x%X).\n", Status));
                            break;
                        }
 
                    /* Query device for all IP addresses */
                    if (SnmpInfo.NumAddr != 0)
                        {
                            BufferSize = SnmpInfo.NumAddr * sizeof(IPADDR_ENTRY);
                            IpAddress = (PIPADDR_ENTRY)ExAllocatePool(NonPagedPool, BufferSize);
                            if (!IpAddress)
                                {
                                    TDI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
                                    break;
                                }
 
                        Status = TdiQueryInformationEx(
                            FileObject,                  /* File object */
                            CL_NL_ENTITY,                /* Entity */
                            Entities[i].tei_instance,    /* Instance */
                            INFO_CLASS_PROTOCOL,         /* Entity class */
                            INFO_TYPE_PROVIDER,          /* Entity type */
                            IP_MIB_ADDRTABLE_ENTRY_ID,   /* Entity id */
                            IpAddress,                   /* Output buffer */
                            &BufferSize);                /* Output buffer size */
 
                        if (!NT_SUCCESS(Status))
                            {
                                TDI_DbgPrint(MIN_TRACE, ("Unable to get IP address (Status = 0x%X).\n", Status));
                                ExFreePool(IpAddress);
                                break;
                            }
 
                        if (SnmpInfo.NumAddr != 1)
                            {
                                /* Skip loopback address */
                                *Address = DN2H(((PIPADDR_ENTRY)((PUCHAR)IpAddress + sizeof(IPADDR_ENTRY)))->Addr);
                            }
                        else
                            {
                                /* Select the first address returned */
                                *Address = DN2H(IpAddress->Addr);
                            }
                                ExFreePool(IpAddress);
 
                        }
                    else
                        {
                            Status = STATUS_UNSUCCESSFUL;
                            break;
                    }
            }
    }
 
    ExFreePool(Entities);
 
    TDI_DbgPrint(MAX_TRACE, ("Leaving\n"));
 
    return Status;
}

Referenced by TdiOpenThread().

TdiQueryDeviceControl()

NTSTATUS TdiQueryDeviceControl	(	PFILE_OBJECT	FileObject,
		ULONG	IoControlCode,
		PVOID	InputBuffer,
		ULONG	InputBufferLength,
		PVOID	OutputBuffer,
		ULONG	OutputBufferLength,
		PULONG	Return
	)

Queries a device for information.

Parameters

FileObject	= Pointer to file object
IoControlCode	= I/O control code
InputBuffer	= Pointer to buffer with input data
InputBufferLength	= Length of InputBuffer
OutputBuffer	= Address of buffer to place output data
OutputBufferLength	= Length of OutputBuffer

Returns

Status of operation

Definition at line 226 of file tditest.c.

{
    PDEVICE_OBJECT DeviceObject;
    PIO_STACK_LOCATION IoStack;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    PIRP Irp;
 
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    Irp = IoBuildDeviceIoControlRequest(IoControlCode, DeviceObject, InputBuffer, InputBufferLength, OutputBuffer,
        OutputBufferLength, FALSE, NULL, NULL);
 
    if (!Irp)
        {
            TDI_DbgPrint(MIN_TRACE, ("IoBuildDeviceIoControlRequest() failed.\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    IoStack               = IoGetNextIrpStackLocation(Irp);
    IoStack->DeviceObject = DeviceObject;
    IoStack->FileObject   = FileObject;
    Status = TdiCall(Irp, DeviceObject, &Iosb, FALSE);
 
    if (Return)
        *Return = Iosb.Information;
 
    return Status;
}

Referenced by TdiQueryInformationEx().

TdiQueryInformationEx()

NTSTATUS TdiQueryInformationEx	(	PFILE_OBJECT	FileObject,
		ULONG	Entity,
		ULONG	Instance,
		ULONG	Class,
		ULONG	Type,
		ULONG	Id,
		PVOID	OutputBuffer,
		PULONG	OutputLength
	)

Definition at line 275 of file tditest.c.

{
    TCP_REQUEST_QUERY_INFORMATION_EX QueryInfo;
 
    RtlZeroMemory(&QueryInfo, sizeof(TCP_REQUEST_QUERY_INFORMATION_EX));
    QueryInfo.ID.toi_entity.tei_entity   = Entity;
    QueryInfo.ID.toi_entity.tei_instance = Instance;
    QueryInfo.ID.toi_class = Class;
    QueryInfo.ID.toi_type  = Type;
    QueryInfo.ID.toi_id    = Id;
 
    return TdiQueryDeviceControl(
        FileObject,                                /* Transport/connection object */
        IOCTL_TCP_QUERY_INFORMATION_EX,            /* Control code */
        &QueryInfo,                                /* Input buffer */
        sizeof(TCP_REQUEST_QUERY_INFORMATION_EX),  /* Input buffer length */
        OutputBuffer,                              /* Output buffer */
        *OutputLength,                             /* Output buffer length */
        OutputLength);                             /* Return information */
}

Referenced by TdiQueryAddress().

TdiReceiveDatagram()

NTSTATUS TdiReceiveDatagram	(	PFILE_OBJECT	TransportObject,
		USHORT	Port,
		PULONG	Address,
		PUCHAR	Buffer,
		PULONG	BufferSize
	)

Definition at line 579 of file tditest.c.

{
    PTDI_CONNECTION_INFORMATION ReceiveInfo;
    PTDI_CONNECTION_INFORMATION ReturnInfo;
    PTA_IP_ADDRESS ReturnAddress;
    PDEVICE_OBJECT DeviceObject;
    PTDI_ADDRESS_IP IpAddress;
    IO_STATUS_BLOCK Iosb;
    PVOID MdlBuffer;
    NTSTATUS Status;
    PIRP Irp;
    PMDL Mdl;
 
    DeviceObject = IoGetRelatedDeviceObject(TransportObject);
    if (!DeviceObject)
        return STATUS_INVALID_PARAMETER;
 
    ReceiveInfo = (PTDI_CONNECTION_INFORMATION) ExAllocatePool(NonPagedPool,
        sizeof(TDI_CONNECTION_INFORMATION) +
        sizeof(TDI_CONNECTION_INFORMATION) +
        sizeof(TA_IP_ADDRESS));
 
    if (!ReceiveInfo)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    MdlBuffer = ExAllocatePool(PagedPool, *BufferSize);
    if (!MdlBuffer)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlZeroMemory(ReceiveInfo, sizeof(TDI_CONNECTION_INFORMATION) + sizeof(TDI_CONNECTION_INFORMATION) +
        sizeof(TA_IP_ADDRESS));
 
    RtlCopyMemory(MdlBuffer, Buffer, *BufferSize);
 
    /* Receive from any address */
    ReceiveInfo->RemoteAddressLength = 0;
    ReceiveInfo->RemoteAddress       = NULL;
 
    ReturnInfo = (PTDI_CONNECTION_INFORMATION) ((PUCHAR)ReceiveInfo + sizeof(TDI_CONNECTION_INFORMATION));
    ReturnInfo->RemoteAddressLength = sizeof(TA_IP_ADDRESS);
    ReturnInfo->RemoteAddress       = ((PUCHAR)ReturnInfo + sizeof(TDI_CONNECTION_INFORMATION));
 
    ReturnAddress = (PTA_IP_ADDRESS)(ReturnInfo->RemoteAddress);
    ReturnAddress->TAAddressCount           = 1;
    ReturnAddress->Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
    ReturnAddress->Address[0].AddressType   = TDI_ADDRESS_TYPE_IP;
 
    IpAddress = (PTDI_ADDRESS_IP)(ReturnAddress->Address[0].Address);
    IpAddress->sin_port = WH2N(Port);
    IpAddress->in_addr  = DH2N(LocalAddress);
 
    Irp = TdiBuildInternalDeviceControlIrp(
        TDI_RECEIVE_DATAGRAM,    /* Sub function */
        DeviceObject,            /* Device object */
        TransportObject,         /* File object */
        NULL,                    /* Event */
        NULL);                   /* Return buffer */
 
    if (!Irp)
        {
            ExFreePool(MdlBuffer);
            ExFreePool(ReceiveInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    Mdl = IoAllocateMdl(
        MdlBuffer,      /* Virtual address */
        *BufferSize,    /* Length of buffer */
        FALSE,          /* Not secondary */
        FALSE,          /* Don't charge quota */
        NULL);          /* Don't use IRP */
 
    if (!Mdl)
        {
            IoFreeIrp(Irp);
            ExFreePool(MdlBuffer);
            ExFreePool(ReceiveInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    _SEH2_TRY
    {
        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        TDI_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
        IoFreeMdl(Mdl);
        IoFreeIrp(Irp);
        ExFreePool(MdlBuffer);
        ExFreePool(ReceiveInfo);
        _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES);
    } _SEH2_END;
 
    TdiBuildReceiveDatagram(
        Irp,                    /* I/O Request Packet */
        DeviceObject,           /* Device object */
        TransportObject,        /* File object */
        NULL,                   /* Completion routine */
        NULL,                   /* Completion context */
        Mdl,                    /* Data buffer */
        *BufferSize,            /* Size of data buffer */
        ReceiveInfo,            /* Connection information */
        ReturnInfo,             /* Connection information */
        TDI_RECEIVE_NORMAL);    /* Flags */
 
    Status = TdiCall(Irp, DeviceObject, &Iosb, TRUE);
 
    if (NT_SUCCESS(Status))
        {
            RtlCopyMemory(Buffer, MdlBuffer, Iosb.Information);
            *BufferSize = Iosb.Information;
            *Address    = DN2H(IpAddress->in_addr);
        }
 
    ExFreePool(MdlBuffer);
    ExFreePool(ReceiveInfo);
 
    return Status;
}

Referenced by TdiReceiveThread().

TdiReceiveThread()

VOID TdiReceiveThread

(

PVOID

Context

)

Definition at line 770 of file tditest.c.

{
    ULONG Address;
    UCHAR Data[40];
    ULONG Size;
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!OpenError)
        {
            while (NT_SUCCESS(Status))
                {
                    Size = sizeof(Data);
                    RtlZeroMemory(Data, Size);
 
                    Status = TdiReceiveDatagram(TdiTransportObject, TEST_PORT, &Address, Data, &Size);
 
                    if (NT_SUCCESS(Status))
                        {
                            DbgPrint("Received data - '%s'\n", Data);
                        }
                    else
                        if (Status != STATUS_CANCELLED)
                            {
                                TDI_DbgPrint(MIN_TRACE, ("Receive error (Status = 0x%X).\n", Status));
                            }
                        else
                            {
                                TDI_DbgPrint(MAX_TRACE, ("IRP was cancelled.\n"));
                            }
                }
        }
 
    TDI_DbgPrint(MAX_TRACE, ("Terminating receive thread...\n"));
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by DriverEntry().

TdiSendDatagram()

NTSTATUS TdiSendDatagram	(	PFILE_OBJECT	TransportObject,
		USHORT	Port,
		ULONG	Address,
		PVOID	Buffer,
		ULONG	BufferSize
	)

Definition at line 471 of file tditest.c.

{
    PIRP Irp;
    PMDL Mdl;
    PDEVICE_OBJECT DeviceObject;
    PTDI_CONNECTION_INFORMATION ConnectInfo;
    PTA_IP_ADDRESS TA;
    PTDI_ADDRESS_IP IpAddress;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    DeviceObject = IoGetRelatedDeviceObject(TransportObject);
    ConnectInfo  = (PTDI_CONNECTION_INFORMATION)
        ExAllocatePool(NonPagedPool,
        sizeof(TDI_CONNECTION_INFORMATION) +
        sizeof(TA_IP_ADDRESS));
 
    if (!ConnectInfo)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlZeroMemory(ConnectInfo, sizeof(TDI_CONNECTION_INFORMATION) + sizeof(TA_IP_ADDRESS));
 
    ConnectInfo->RemoteAddressLength = sizeof(TA_IP_ADDRESS);
    ConnectInfo->RemoteAddress       = ((PUCHAR)ConnectInfo + sizeof(TDI_CONNECTION_INFORMATION));
 
    TA = (PTA_IP_ADDRESS)(ConnectInfo->RemoteAddress);
    TA->TAAddressCount           = 1;
    TA->Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
    TA->Address[0].AddressType   = TDI_ADDRESS_TYPE_IP;
    IpAddress           = (PTDI_ADDRESS_IP)(TA->Address[0].Address);
    IpAddress->sin_port = WH2N(Port);
    IpAddress->in_addr  = DH2N(Address);
    Irp = TdiBuildInternalDeviceControlIrp(
        TDI_SEND_DATAGRAM,   /* Sub function */
        DeviceObject,        /* Device object */
        TransportObject,     /* File object */
        NULL,                /* Event */
        NULL);               /* Return buffer */
 
    if (!Irp)
        {
            TDI_DbgPrint(MIN_TRACE, ("TdiBuildInternalDeviceControlIrp() failed.\n"));
            ExFreePool(ConnectInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    Mdl = IoAllocateMdl(
        Buffer,     /* Virtual address of buffer */
        BufferSize, /* Length of buffer */
        FALSE,      /* Not secondary */
        FALSE,      /* Don't charge quota */
        NULL);      /* Don't use IRP */
 
    if (!Mdl)
        {
            TDI_DbgPrint(MIN_TRACE, ("IoAllocateMdl() failed.\n"));
            IoFreeIrp(Irp);
            ExFreePool(ConnectInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
    _SEH2_TRY
    {
        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        TDI_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
        IoFreeMdl(Mdl);
        IoFreeIrp(Irp);
        ExFreePool(ConnectInfo);
        _SEH2_YIELD(return STATUS_UNSUCCESSFUL);
    } _SEH2_END;
 
    TdiBuildSendDatagram(
        Irp,               /* I/O Request Packet */
        DeviceObject,      /* Device object */
        TransportObject,   /* File object */
        NULL,              /* Completion routine */
        NULL,              /* Completion context */
        Mdl,               /* Descriptor for data buffer */
        BufferSize,        /* Size of data to send */
        ConnectInfo);      /* Connection information */
 
    Status = TdiCall(Irp, DeviceObject, &Iosb, FALSE);
 
    ExFreePool(ConnectInfo);
 
    return Status;
}

Referenced by TdiSendThread().

TdiSendThread()

VOID TdiSendThread

(

PVOID

Context

)

Definition at line 717 of file tditest.c.

{
    KEVENT Event;
    PKEVENT Events[2];
    LARGE_INTEGER Timeout;
    NTSTATUS Status = STATUS_SUCCESS;
    UCHAR Data[40]  = "Testing one, two, three, ...";
 
    if (!OpenError)
        {
            Timeout.QuadPart = 10000000L;           /* Second factor */
            Timeout.QuadPart *= 2;                  /* Number of seconds */
            Timeout.QuadPart = -(Timeout.QuadPart); /* Relative time */
 
            KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
            Events[0] = &StopEvent;
            Events[1] = &Event;
 
            while (NT_SUCCESS(Status))
                {
                    /* Wait until timeout or stop flag is set */
                    KeWaitForMultipleObjects( 2, (PVOID)Events, WaitAny, Executive, KernelMode, FALSE, &Timeout, NULL);
 
                    if (KeReadStateEvent(&StopEvent) != 0)
                        {
                            TDI_DbgPrint(MAX_TRACE, ("Received terminate signal...\n"));
                            break;
                        }
 
                    DbgPrint("Sending data - '%s'\n", Data);
 
                    Status = TdiSendDatagram(TdiTransportObject, TEST_PORT, LocalAddress, Data, sizeof(Data));
 
                    if (!NT_SUCCESS(Status))
                        DbgPrint("Failed sending data (Status = 0x%X)\n", Status);
                }
        }
 
    TDI_DbgPrint(MAX_TRACE, ("Terminating send thread...\n"));
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by DriverEntry().

TdiUnload()

VOID TdiUnload

(

PDRIVER_OBJECT

DriverObject

)

Definition at line 857 of file tditest.c.

{
    PVOID ReceiveThreadObject = 0;
    PVOID SendThreadObject = 0;
 
    TDI_DbgPrint(MAX_TRACE, ("Setting stop flag\n"));
 
    /* Get pointers to the thread objects */
    ObReferenceObjectByHandle(SendThread, THREAD_ALL_ACCESS, NULL, KernelMode, &SendThreadObject, NULL);
    ObReferenceObjectByHandle(ReceiveThread, THREAD_ALL_ACCESS, NULL, KernelMode, &ReceiveThreadObject, NULL);
 
    KeSetEvent(&StopEvent, 0, FALSE);
 
    /* Wait for send thread to stop */
    KeWaitForSingleObject(SendThreadObject, Executive, KernelMode, FALSE, NULL);
 
    /* Wait for receive thread to stop */
    KeWaitForSingleObject(ReceiveThreadObject, Executive, KernelMode, FALSE, NULL);
 
    /* Close device */
    TdiCloseDevice(TdiTransport, TdiTransportObject);
}

Referenced by DriverEntry().

Variable Documentation

LocalAddress

ULONG LocalAddress

Definition at line 26 of file tditest.c.

OpenError

BOOLEAN OpenError

Definition at line 27 of file tditest.c.

Referenced by TdiOpenThread(), TdiReceiveThread(), and TdiSendThread().

ReceiveThread

HANDLE ReceiveThread

Definition at line 30 of file tditest.c.

Referenced by DriverEntry(), and TdiUnload().

SendThread

HANDLE SendThread

Definition at line 29 of file tditest.c.

Referenced by DriverEntry(), and TdiUnload().

StopEvent

KEVENT StopEvent

Definition at line 28 of file tditest.c.

Referenced by DriverEntry(), TdiCall(), TdiSendThread(), and TdiUnload().

TdiTransport

HANDLE TdiTransport = 0

Definition at line 24 of file tditest.c.

Referenced by TdiOpenThread(), and TdiUnload().

TdiTransportObject

PFILE_OBJECT TdiTransportObject = NULL

Definition at line 25 of file tditest.c.

Referenced by TdiOpenThread(), TdiReceiveThread(), TdiSendThread(), and TdiUnload().