main.c File Reference

#include "precomp.h"
#include <dispatch.h>
#include <fileobjs.h>

Include dependency graph for main.c:

Go to the source code of this file.

Functions
VOID	TiWriteErrorLog (PDRIVER_OBJECT DriverContext, NTSTATUS ErrorCode, ULONG UniqueErrorValue, NTSTATUS FinalStatus, PWSTR String, ULONG DumpDataCount, PULONG DumpData)
NTSTATUS	TiCreateFileObject (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	TiCloseFileObject (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	TiDispatchOpenClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	TiDispatchInternal (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	TiDispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
	Dispatch routine for IRP_MJ_DEVICE_CONTROL requests.
VOID NTAPI	TiUnload (PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	DriverEntry (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
VOID NTAPI	IPAddInterface (ULONG Unknown0, ULONG Unknown1, ULONG Unknown2, ULONG Unknown3, ULONG Unknown4)
VOID NTAPI	IPDelInterface (ULONG Unknown0)
VOID NTAPI	LookupRoute (ULONG Unknown0, ULONG Unknown1)

Variables
PDEVICE_OBJECT	TCPDeviceObject = NULL
PDEVICE_OBJECT	UDPDeviceObject = NULL
PDEVICE_OBJECT	IPDeviceObject = NULL
PDEVICE_OBJECT	RawIPDeviceObject = NULL
NDIS_HANDLE	GlobalPacketPool = NULL
NDIS_HANDLE	GlobalBufferPool = NULL
KSPIN_LOCK	EntityListLock
TDIEntityInfo *	EntityList = NULL
ULONG	EntityCount = 0
ULONG	EntityMax = 0
UDP_STATISTICS	UDPStats
KTIMER	IPTimer
KDPC	IPTimeoutDpc

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	PDRIVER_OBJECT	DriverObject,
		PUNICODE_STRING	RegistryPath
	)

Definition at line 626 of file main.c.

{
    NTSTATUS Status;
    UNICODE_STRING strIpDeviceName = RTL_CONSTANT_STRING(DD_IP_DEVICE_NAME);
    UNICODE_STRING strRawDeviceName = RTL_CONSTANT_STRING(DD_RAWIP_DEVICE_NAME);
    UNICODE_STRING strUdpDeviceName = RTL_CONSTANT_STRING(DD_UDP_DEVICE_NAME);
    UNICODE_STRING strTcpDeviceName = RTL_CONSTANT_STRING(DD_TCP_DEVICE_NAME);
    UNICODE_STRING strNdisDeviceName = RTL_CONSTANT_STRING(TCPIP_PROTOCOL_NAME);
    NDIS_STATUS NdisStatus;
    LARGE_INTEGER DueTime;
 
    TI_DbgPrint(MAX_TRACE, ("[TCPIP, DriverEntry] Called\n"));
 
    /* TdiInitialize() ? */
 
    /* FIXME: Create symbolic links in Win32 namespace */
 
    /* Initialize our periodic timer and its associated DPC object. When the
        timer expires, the IPTimeout deferred procedure call (DPC) is queued */
    KeInitializeDpc(&IPTimeoutDpc, IPTimeoutDpcFn, NULL);
    KeInitializeTimer(&IPTimer);
 
    /* Create IP device object */
    Status = IoCreateDevice(DriverObject, 0, &strIpDeviceName,
        FILE_DEVICE_NETWORK, 0, FALSE, &IPDeviceObject);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Failed to create IP device object. Status (0x%X).\n", Status));
        TiUnload(DriverObject);
        return Status;
    }
 
    ChewInit( IPDeviceObject );
 
    /* Create RawIP device object */
    Status = IoCreateDevice(DriverObject, 0, &strRawDeviceName,
        FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status));
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Create UDP device object */
    Status = IoCreateDevice(DriverObject, 0, &strUdpDeviceName,
        FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status));
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Create TCP device object */
    Status = IoCreateDevice(DriverObject, 0, &strTcpDeviceName,
        FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status));
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Setup network layer and transport layer entities */
    KeInitializeSpinLock(&EntityListLock);
    EntityList = ExAllocatePoolWithTag(NonPagedPool,
                                       sizeof(TDIEntityID) * MAX_TDI_ENTITIES,
                                       TDI_ENTITY_TAG );
    if (!EntityList) {
        TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        TiUnload(DriverObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    EntityCount = 0;
    EntityMax   = MAX_TDI_ENTITIES;
 
    /* Allocate NDIS packet descriptors */
    NdisAllocatePacketPoolEx(&NdisStatus, &GlobalPacketPool, 500, 1500, sizeof(PACKET_CONTEXT));
    if (NdisStatus != NDIS_STATUS_SUCCESS) {
        TiUnload(DriverObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Allocate NDIS buffer descriptors */
    NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 2000);
    if (NdisStatus != NDIS_STATUS_SUCCESS) {
        TiUnload(DriverObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Initialize address file list and protecting spin lock */
    InitializeListHead(&AddressFileListHead);
    KeInitializeSpinLock(&AddressFileListLock);
 
    /* Initialize connection endpoint list and protecting spin lock */
    InitializeListHead(&ConnectionEndpointListHead);
    KeInitializeSpinLock(&ConnectionEndpointListLock);
 
    /* Initialize interface list and protecting spin lock */
    InitializeListHead(&InterfaceListHead);
    KeInitializeSpinLock(&InterfaceListLock);
 
    /* Initialize network level protocol subsystem */
    IPStartup(RegistryPath);
 
    /* Initialize transport level protocol subsystems */
    Status = RawIPStartup();
    if( !NT_SUCCESS(Status) ) {
        TiUnload(DriverObject);
        return Status;
    }
 
    Status = UDPStartup();
    if( !NT_SUCCESS(Status) ) {
        TiUnload(DriverObject);
        return Status;
    }
 
    Status = TCPStartup();
    if( !NT_SUCCESS(Status) ) {
        TiUnload(DriverObject);
        return Status;
    }
 
    Status = ICMPStartup();
    if( !NT_SUCCESS(Status) ) {
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Use direct I/O */
    IPDeviceObject->Flags    |= DO_DIRECT_IO;
    RawIPDeviceObject->Flags |= DO_DIRECT_IO;
    UDPDeviceObject->Flags   |= DO_DIRECT_IO;
    TCPDeviceObject->Flags   |= DO_DIRECT_IO;
 
    /* Initialize the driver object with this driver's entry points */
    DriverObject->MajorFunction[IRP_MJ_CREATE]  = TiDispatchOpenClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]   = TiDispatchOpenClose;
    DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = TiDispatchInternal;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = TiDispatch;
 
    DriverObject->DriverUnload = TiUnload;
 
    /* Open loopback adapter */
    Status = LoopRegisterAdapter(NULL, NULL);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status));
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Register protocol with NDIS */
    /* This used to be IP_DEVICE_NAME but the DDK says it has to match your entry in the SCM */
    Status = LANRegisterProtocol(&strNdisDeviceName);
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE,("Failed to register protocol with NDIS; status 0x%x\n", Status));
        TiWriteErrorLog(
        DriverObject,
        EVENT_TRANSPORT_REGISTER_FAILED,
        TI_ERROR_DRIVERENTRY,
        Status,
        NULL,
        0,
        NULL);
        TiUnload(DriverObject);
        return Status;
    }
 
    /* Start the periodic timer with an initial and periodic
        relative expiration time of IP_TIMEOUT milliseconds */
    DueTime.QuadPart = -(LONGLONG)IP_TIMEOUT * 10000;
    KeSetTimerEx(&IPTimer, DueTime, IP_TIMEOUT, &IPTimeoutDpc);
 
    TI_DbgPrint(MAX_TRACE, ("[TCPIP, DriverEntry] Finished\n"));
 
 
    return STATUS_SUCCESS;
}

IPAddInterface()

VOID NTAPI IPAddInterface	(	ULONG	Unknown0,
		ULONG	Unknown1,
		ULONG	Unknown2,
		ULONG	Unknown3,
		ULONG	Unknown4
	)

Definition at line 815 of file main.c.

{
    UNIMPLEMENTED;
}

IPDelInterface()

VOID NTAPI IPDelInterface

(

ULONG

Unknown0

)

Definition at line 827 of file main.c.

{
    UNIMPLEMENTED;
}

LookupRoute()

VOID NTAPI LookupRoute	(	ULONG	Unknown0,
		ULONG	Unknown1
	)

Definition at line 835 of file main.c.

{
    UNIMPLEMENTED;
}

TiCloseFileObject()

NTSTATUS TiCloseFileObject	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 284 of file main.c.

{
    PIO_STACK_LOCATION IrpSp;
    PTRANSPORT_CONTEXT Context;
    TDI_REQUEST Request;
    NTSTATUS Status;
 
    IrpSp   = IoGetCurrentIrpStackLocation(Irp);
    Context = IrpSp->FileObject->FsContext;
    if (!Context)
    {
        TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    switch ((ULONG_PTR)IrpSp->FileObject->FsContext2)
    {
        case TDI_TRANSPORT_ADDRESS_FILE:
            Request.Handle.AddressHandle = Context->Handle.AddressHandle;
            Status = FileCloseAddress(&Request);
            break;
 
        case TDI_CONNECTION_FILE:
            Request.Handle.ConnectionContext = Context->Handle.ConnectionContext;
            Status = FileCloseConnection(&Request);
            break;
 
        case TDI_CONTROL_CHANNEL_FILE:
            Request.Handle.ControlChannel = Context->Handle.ControlChannel;
            Status = FileCloseControlChannel(&Request);
            break;
 
        default:
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    if (NT_SUCCESS(Status))
        ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
 
    Irp->IoStatus.Status = Status;
 
    return Irp->IoStatus.Status;
}

Referenced by TiDispatchOpenClose().

TiCreateFileObject()

NTSTATUS TiCreateFileObject	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 109 of file main.c.

{
    PFILE_FULL_EA_INFORMATION EaInfo;
    PTRANSPORT_CONTEXT Context;
    PIO_STACK_LOCATION IrpSp;
    PTA_IP_ADDRESS Address;
    TDI_REQUEST Request;
    PVOID ClientContext;
    NTSTATUS Status;
    ULONG Protocol;
    BOOLEAN Shared;
 
    TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
 
    EaInfo = Irp->AssociatedIrp.SystemBuffer;
 
    /* Parameter check */
    /* No EA information means that we're opening for SET/QUERY_INFORMATION
    * style calls. */
 
    /* Allocate resources here. We release them again if something failed */
    Context = ExAllocatePoolWithTag(NonPagedPool, sizeof(TRANSPORT_CONTEXT),
                                    TRANS_CONTEXT_TAG);
    if (!Context)
    {
        TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Context->CancelIrps = FALSE;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
    IrpSp->FileObject->FsContext = Context;
    Request.RequestContext       = Irp;
 
    /* Branch to the right handler */
    if (EaInfo &&
        (EaInfo->EaNameLength == TDI_TRANSPORT_ADDRESS_LENGTH) &&
        (RtlCompareMemory(&EaInfo->EaName, TdiTransportAddress,
        TDI_TRANSPORT_ADDRESS_LENGTH) == TDI_TRANSPORT_ADDRESS_LENGTH))
    {
        /* This is a request to open an address */
 
 
        /* XXX This should probably be done in IoCreateFile() */
        /* Parameter checks */
 
        Address = (PTA_IP_ADDRESS)(EaInfo->EaName + EaInfo->EaNameLength + 1); //0-term
 
        if ((EaInfo->EaValueLength < sizeof(TA_IP_ADDRESS)) ||
            (Address->TAAddressCount != 1) ||
            (Address->Address[0].AddressLength < TDI_ADDRESS_LENGTH_IP) ||
            (Address->Address[0].AddressType != TDI_ADDRESS_TYPE_IP))
        {
            TI_DbgPrint(MIN_TRACE, ("Parameters are invalid:\n"));
            TI_DbgPrint(MIN_TRACE, ("AddressCount: %d\n", Address->TAAddressCount));
            if( Address->TAAddressCount == 1 )
            {
                TI_DbgPrint(MIN_TRACE, ("AddressLength: %u\n",
                            Address->Address[0].AddressLength));
                TI_DbgPrint(MIN_TRACE, ("AddressType: %u\n",
                            Address->Address[0].AddressType));
            }
 
            ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
            return STATUS_INVALID_PARAMETER;
        }
 
        /* Open address file object */
 
        /* Protocol depends on device object so find the protocol */
        if (DeviceObject == TCPDeviceObject)
            Protocol = IPPROTO_TCP;
        else if (DeviceObject == UDPDeviceObject)
            Protocol = IPPROTO_UDP;
        else if (DeviceObject == IPDeviceObject)
            Protocol = IPPROTO_RAW;
        else if (DeviceObject == RawIPDeviceObject)
        {
            Status = TiGetProtocolNumber(&IrpSp->FileObject->FileName, &Protocol);
            if (!NT_SUCCESS(Status))
            {
                TI_DbgPrint(MIN_TRACE, ("Raw IP protocol number is invalid.\n"));
                ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
                return STATUS_INVALID_PARAMETER;
            }
        }
        else
        {
            TI_DbgPrint(MIN_TRACE, ("Invalid device object at (0x%X).\n", DeviceObject));
            ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
            return STATUS_INVALID_PARAMETER;
        }
 
        Shared = (IrpSp->Parameters.Create.ShareAccess != 0);
 
        Status = FileOpenAddress(&Request, Address, Protocol, Shared, NULL);
        if (NT_SUCCESS(Status))
        {
            IrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
            Context->Handle.AddressHandle = Request.Handle.AddressHandle;
        }
 
    }
    else if (EaInfo &&
            (EaInfo->EaNameLength == TDI_CONNECTION_CONTEXT_LENGTH) &&
            (RtlCompareMemory
            (&EaInfo->EaName, TdiConnectionContext,
            TDI_CONNECTION_CONTEXT_LENGTH) ==
            TDI_CONNECTION_CONTEXT_LENGTH))
    {
        /* This is a request to open a connection endpoint */
 
        /* Parameter checks */
 
        if (EaInfo->EaValueLength < sizeof(PVOID))
        {
            TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
            ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
            return STATUS_INVALID_PARAMETER;
        }
 
        /* Can only do connection oriented communication using TCP */
 
        if (DeviceObject != TCPDeviceObject)
        {
            TI_DbgPrint(MIN_TRACE, ("Bad device object.\n"));
            ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
            return STATUS_INVALID_PARAMETER;
        }
 
        ClientContext = *((PVOID*)(EaInfo->EaName + EaInfo->EaNameLength));
 
        /* Open connection endpoint file object */
 
        Status = FileOpenConnection(&Request, ClientContext);
        if (NT_SUCCESS(Status))
        {
            IrpSp->FileObject->FsContext2 = (PVOID)TDI_CONNECTION_FILE;
            Context->Handle.ConnectionContext = Request.Handle.ConnectionContext;
        }
    }
    else
    {
        /* This is a request to open a control connection */
        Status = FileOpenControlChannel(&Request);
        if (NT_SUCCESS(Status))
        {
            IrpSp->FileObject->FsContext2 = (PVOID)TDI_CONTROL_CHANNEL_FILE;
            Context->Handle.ControlChannel = Request.Handle.ControlChannel;
        }
    }
 
    if (!NT_SUCCESS(Status))
        ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
 
    TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 
    Irp->IoStatus.Status = Status;
    return Status;
}

Referenced by TiDispatchOpenClose().

TiDispatch()

NTSTATUS NTAPI TiDispatch	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Dispatch routine for IRP_MJ_DEVICE_CONTROL requests.

Parameters

[in]	DeviceObject	Pointer to a device object for this driver
[in]	Irp	Pointer to a I/O request packet

Returns

Status of the operation

Definition at line 488 of file main.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    TI_DbgPrint(DEBUG_IRP, ("[TCPIP, TiDispatch] Called. IRP is at (0x%X).\n", Irp));
 
    Irp->IoStatus.Information = 0;
 
#if 0
    Status = TdiMapUserRequest(DeviceObject, Irp, IrpSp);
    if (NT_SUCCESS(Status))
    {
        TiDispatchInternal(DeviceObject, Irp);
        Status = STATUS_PENDING;
    }
    else
    {
#else
    if (TRUE) {
#endif
        /* See if this request is TCP/IP specific */
        switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
        {
            case IOCTL_TCP_QUERY_INFORMATION_EX:
                TI_DbgPrint(MIN_TRACE, ("TCP_QUERY_INFORMATION_EX\n"));
                Status = DispTdiQueryInformationEx(Irp, IrpSp);
                break;
 
            case IOCTL_TCP_SET_INFORMATION_EX:
                TI_DbgPrint(MIN_TRACE, ("TCP_SET_INFORMATION_EX\n"));
                Status = DispTdiSetInformationEx(Irp, IrpSp);
                break;
 
            case IOCTL_SET_IP_ADDRESS:
                TI_DbgPrint(MIN_TRACE, ("SET_IP_ADDRESS\n"));
                Status = DispTdiSetIPAddress(Irp, IrpSp);
                break;
 
            case IOCTL_DELETE_IP_ADDRESS:
                TI_DbgPrint(MIN_TRACE, ("DELETE_IP_ADDRESS\n"));
                Status = DispTdiDeleteIPAddress(Irp, IrpSp);
                break;
 
            case IOCTL_QUERY_IP_HW_ADDRESS:
                TI_DbgPrint(MIN_TRACE, ("QUERY_IP_HW_ADDRESS\n"));
                Status = DispTdiQueryIpHwAddress(DeviceObject, Irp, IrpSp);
                break;
 
            case IOCTL_ICMP_ECHO_REQUEST:
                TI_DbgPrint(MIN_TRACE, ("ICMP_ECHO_REQUEST\n"));
                Status = DispEchoRequest(DeviceObject, Irp, IrpSp);
                break;
 
            default:
                TI_DbgPrint(MIN_TRACE, ("Unknown IOCTL 0x%X\n",
                    IrpSp->Parameters.DeviceIoControl.IoControlCode));
                Status = STATUS_NOT_IMPLEMENTED;
                break;
        }
    }
 
    TI_DbgPrint(DEBUG_IRP, ("[TCPIP, TiDispatch] Leaving. Status = (0x%X).\n", Status));
 
    return IRPFinish(Irp, Status);
}

Referenced by DriverEntry().

TiDispatchInternal()

NTSTATUS NTAPI TiDispatchInternal	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 374 of file main.c.

{
    NTSTATUS Status;
    BOOLEAN Complete = TRUE;
    PIO_STACK_LOCATION IrpSp;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    TI_DbgPrint(DEBUG_IRP, ("[TCPIP, TiDispatchInternal] Called. DeviceObject is at (0x%X), IRP is at (0x%X) MN (%d).\n",
        DeviceObject, Irp, IrpSp->MinorFunction));
 
    Irp->IoStatus.Status      = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    switch (IrpSp->MinorFunction) {
    case TDI_RECEIVE:
        Status = DispTdiReceive(Irp);
        Complete = FALSE;
        break;
 
    case TDI_RECEIVE_DATAGRAM:
        Status = DispTdiReceiveDatagram(Irp);
        Complete = FALSE;
        break;
 
    case TDI_SEND:
        Status = DispTdiSend(Irp);
        Complete = FALSE; /* Completed in DispTdiSend */
        break;
 
    case TDI_SEND_DATAGRAM:
        Status = DispTdiSendDatagram(Irp);
        Complete = FALSE;
        break;
 
  case TDI_ACCEPT:
    Status = DispTdiAccept(Irp);
    break;
 
    case TDI_LISTEN:
        Status = DispTdiListen(Irp);
        Complete = FALSE;
        break;
 
    case TDI_CONNECT:
        Status = DispTdiConnect(Irp);
        Complete = FALSE; /* Completed by the TCP event handler */
        break;
 
    case TDI_DISCONNECT:
        Status = DispTdiDisconnect(Irp);
        Complete = FALSE;
        break;
 
    case TDI_ASSOCIATE_ADDRESS:
        Status = DispTdiAssociateAddress(Irp);
        break;
 
    case TDI_DISASSOCIATE_ADDRESS:
        Status = DispTdiDisassociateAddress(Irp);
        break;
 
    case TDI_QUERY_INFORMATION:
        Status = DispTdiQueryInformation(DeviceObject, Irp);
        break;
 
    case TDI_SET_INFORMATION:
        Status = DispTdiSetInformation(Irp);
        break;
 
    case TDI_SET_EVENT_HANDLER:
        Status = DispTdiSetEventHandler(Irp);
        break;
 
    case TDI_ACTION:
        Status = STATUS_SUCCESS;
        break;
 
    /* An unsupported IOCTL code was submitted */
    default:
        Status = STATUS_INVALID_DEVICE_REQUEST;
    }
 
    TI_DbgPrint(DEBUG_IRP, ("[TCPIP, TiDispatchInternal] Leaving. Status = (0x%X).\n", Status));
 
    if( Complete )
        IRPFinish( Irp, Status );
 
    return Status;
}

Referenced by DriverEntry(), and TiDispatch().

TiDispatchOpenClose()

NTSTATUS NTAPI TiDispatchOpenClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 333 of file main.c.

{
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS Status;
 
//  DbgPrint("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp);
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    switch (IrpSp->MajorFunction) {
    /* Open an address file, connection endpoint, or control connection */
    case IRP_MJ_CREATE:
        Status = TiCreateFileObject(DeviceObject, Irp);
        break;
 
    /* Close an address file, connection endpoint, or control connection */
    case IRP_MJ_CLOSE:
        Status = TiCloseFileObject(DeviceObject, Irp);
        break;
 
     default:
        Status = STATUS_INVALID_DEVICE_REQUEST;
    }
 
    //DbgPrint("Leaving. Status is (0x%X)\n", Status);
 
    return IRPFinish( Irp, Status );
}

Referenced by DriverEntry().

TiUnload()

VOID NTAPI TiUnload

(

PDRIVER_OBJECT

DriverObject

)

Definition at line 560 of file main.c.

{
#if DBG
  KIRQL OldIrql;
 
    TcpipAcquireSpinLock(&AddressFileListLock, &OldIrql);
    if (!IsListEmpty(&AddressFileListHead)) {
        TI_DbgPrint(MIN_TRACE, ("[TCPIP, TiUnload] Called. Open address file objects exists.\n"));
    }
    TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
#endif
    /* Cancel timer */
    KeCancelTimer(&IPTimer);
 
    /* Unregister loopback adapter */
    LoopUnregisterAdapter(NULL);
 
    /* Unregister protocol with NDIS */
    LANUnregisterProtocol();
 
    /* Shutdown transport level protocol subsystems */
    TCPShutdown();
    UDPShutdown();
    RawIPShutdown();
    ICMPShutdown();
 
    /* Shutdown network level protocol subsystem */
    IPShutdown();
 
    /* Free NDIS buffer descriptors */
    if (GlobalBufferPool)
        NdisFreeBufferPool(GlobalBufferPool);
 
    /* Free NDIS packet descriptors */
    if (GlobalPacketPool)
        NdisFreePacketPool(GlobalPacketPool);
 
    /* Release all device objects */
 
    if (TCPDeviceObject)
        IoDeleteDevice(TCPDeviceObject);
 
    if (UDPDeviceObject)
        IoDeleteDevice(UDPDeviceObject);
 
    if (RawIPDeviceObject)
        IoDeleteDevice(RawIPDeviceObject);
 
    if (IPDeviceObject) {
        ChewShutdown();
        IoDeleteDevice(IPDeviceObject);
    }
 
    if (EntityList)
        ExFreePoolWithTag(EntityList, TDI_ENTITY_TAG);
 
    TI_DbgPrint(MAX_TRACE, ("[TCPIP, TiUnload] Leaving.\n"));
}

Referenced by DriverEntry().

TiWriteErrorLog()

VOID TiWriteErrorLog	(	PDRIVER_OBJECT	DriverContext,
		NTSTATUS	ErrorCode,
		ULONG	UniqueErrorValue,
		NTSTATUS	FinalStatus,
		PWSTR	String,
		ULONG	DumpDataCount,
		PULONG	DumpData
	)

Definition at line 32 of file main.c.

{
    PIO_ERROR_LOG_PACKET LogEntry;
    UCHAR EntrySize;
    ULONG StringSize;
    PUCHAR pString;
    static WCHAR DriverName[] = L"TCP/IP";
 
    EntrySize = sizeof(IO_ERROR_LOG_PACKET) +
        (DumpDataCount * sizeof(ULONG)) + sizeof(DriverName);
 
    if (String) {
        StringSize = (wcslen(String) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
        EntrySize += (UCHAR)StringSize;
    }
 
    /* Fail if the required error log entry is too large */
    if (EntrySize > ERROR_LOG_MAXIMUM_SIZE)
        return;
 
    LogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(DriverContext, EntrySize);
    if (!LogEntry)
        return;
 
    LogEntry->MajorFunctionCode = -1;
    LogEntry->RetryCount        = -1;
    LogEntry->DumpDataSize      = (USHORT)(DumpDataCount * sizeof(ULONG));
    LogEntry->NumberOfStrings   = (String == NULL) ? 1 : 2;
    LogEntry->StringOffset      = sizeof(IO_ERROR_LOG_PACKET) + (DumpDataCount * sizeof(ULONG));
    LogEntry->EventCategory     = 0;
    LogEntry->ErrorCode         = ErrorCode;
    LogEntry->UniqueErrorValue  = UniqueErrorValue;
    LogEntry->FinalStatus       = FinalStatus;
    LogEntry->SequenceNumber    = -1;
    LogEntry->IoControlCode     = 0;
 
    if (DumpDataCount)
        RtlCopyMemory(LogEntry->DumpData, DumpData, DumpDataCount * sizeof(ULONG));
 
    pString = ((PUCHAR)LogEntry) + LogEntry->StringOffset;
    RtlCopyMemory(pString, DriverName, sizeof(DriverName));
    pString += sizeof(DriverName);
 
    if (String)
        RtlCopyMemory(pString, String, StringSize);
 
    IoWriteErrorLogEntry(LogEntry);
}

Referenced by DriverEntry().

Variable Documentation

EntityCount

ULONG EntityCount = 0

Definition at line 24 of file main.c.

Referenced by AddEntity(), DriverEntry(), GetContext(), InfoTdiQueryEntityType(), InfoTdiQueryGetAddrTable(), InfoTdiQueryGetRouteTable(), InfoTdiQueryListEntities(), RemoveEntityByContext(), START_TEST(), TdiQueryAddress(), and WSHNotify().

EntityList

TDIEntityInfo* EntityList = NULL

Definition at line 23 of file main.c.

Referenced by AddEntity(), DriverEntry(), GetContext(), InfoTdiQueryEntityType(), InfoTdiQueryGetAddrTable(), InfoTdiQueryGetRouteTable(), InfoTdiQueryListEntities(), RemoveEntityByContext(), and TiUnload().

EntityListLock

KSPIN_LOCK EntityListLock

Definition at line 22 of file main.c.

Referenced by AddEntity(), DriverEntry(), GetContext(), InfoTdiQueryEntityType(), InfoTdiQueryGetAddrTable(), InfoTdiQueryGetRouteTable(), InfoTdiQueryListEntities(), and RemoveEntityByContext().

EntityMax

ULONG EntityMax = 0

Definition at line 25 of file main.c.

Referenced by DriverEntry().

GlobalBufferPool

NDIS_HANDLE GlobalBufferPool = NULL

Definition at line 21 of file main.c.

Referenced by DriverEntry(), and TiUnload().

GlobalPacketPool

NDIS_HANDLE GlobalPacketPool = NULL

Definition at line 20 of file main.c.

Referenced by DriverEntry(), and TiUnload().

IPDeviceObject

PDEVICE_OBJECT IPDeviceObject = NULL

Definition at line 18 of file main.c.

Referenced by DriverEntry(), TiCreateFileObject(), and TiUnload().

IPTimeoutDpc

KDPC IPTimeoutDpc

Definition at line 30 of file main.c.

Referenced by DriverEntry().

IPTimer

KTIMER IPTimer

Definition at line 29 of file main.c.

Referenced by DriverEntry(), and TiUnload().

RawIPDeviceObject

PDEVICE_OBJECT RawIPDeviceObject = NULL

Definition at line 19 of file main.c.

Referenced by DriverEntry(), TiCreateFileObject(), and TiUnload().

TCPDeviceObject

PDEVICE_OBJECT TCPDeviceObject = NULL

Definition at line 16 of file main.c.

Referenced by DriverEntry(), TCPAllocateConnectionEndpoint(), TiCreateFileObject(), and TiUnload().

UDPDeviceObject

PDEVICE_OBJECT UDPDeviceObject = NULL

Definition at line 17 of file main.c.

Referenced by DriverEntry(), TiCreateFileObject(), and TiUnload().

UDPStats

UDP_STATISTICS UDPStats

Definition at line 26 of file main.c.

Referenced by RawIPStartup(), and UDPStartup().