datagram.h File Reference

#include <titypes.h>

Include dependency graph for datagram.h:

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

Go to the source code of this file.

Functions
NTSTATUS	DGReceiveDatagram (PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR Buffer, ULONG ReceiveLength, ULONG ReceiveFlags, PTDI_CONNECTION_INFORMATION ReturnInfo, PULONG BytesReceived, PDATAGRAM_COMPLETION_ROUTINE Complete, PVOID Context, PIRP Irp)
BOOLEAN	DGRemoveIRP (PADDRESS_FILE AddrFile, PIRP Irp)
VOID	DGDeliverData (PADDRESS_FILE AddrFile, PIP_ADDRESS SrcAddress, PIP_ADDRESS DstAddress, USHORT SrcPort, USHORT DstPort, PIP_PACKET IPPacket, UINT DataSize)

Function Documentation

DGDeliverData()

VOID DGDeliverData	(	PADDRESS_FILE	AddrFile,
		PIP_ADDRESS	SrcAddress,
		PIP_ADDRESS	DstAddress,
		USHORT	SrcPort,
		USHORT	DstPort,
		PIP_PACKET	IPPacket,
		UINT	DataSize
	)

Definition at line 52 of file datagram.c.

{
    LONG AddressLength;
    PVOID SourceAddress;
    ULONG BytesTaken;
    NTSTATUS Status;
    PVOID DataBuffer;
 
    TI_DbgPrint(MIN_TRACE, ("Called.\n"));
 
    LockObject(AddrFile);
 
    if (AddrFile->Protocol == IPPROTO_UDP)
    {
        DataBuffer = IPPacket->Data;
    }
    else if (AddrFile->HeaderIncl)
    {
        DataBuffer = IPPacket->Header;
    }
    else
    {
        DataBuffer = IPPacket->Data;
        DataSize -= IPPacket->HeaderSize;
    }
 
    if (!IsListEmpty(&AddrFile->ReceiveQueue))
    {
        PLIST_ENTRY CurrentEntry;
        PDATAGRAM_RECEIVE_REQUEST Current = NULL;
        PTA_IP_ADDRESS RTAIPAddress;
 
        TI_DbgPrint(MAX_TRACE, ("There is a receive request.\n"));
 
        /* Search receive request list to find a match */
        CurrentEntry = AddrFile->ReceiveQueue.Flink;
        while (CurrentEntry != &AddrFile->ReceiveQueue)
        {
            Current = CONTAINING_RECORD(CurrentEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry);
            CurrentEntry = CurrentEntry->Flink;
            if (DstPort == AddrFile->Port &&
               (AddrIsEqual(DstAddress, &AddrFile->Address) ||
                AddrIsUnspecified(&AddrFile->Address) ||
                AddrIsUnspecified(DstAddress)))
            {
 
                /* Remove the request from the queue */
                RemoveEntryList(&Current->ListEntry);
 
                TI_DbgPrint(MAX_TRACE, ("Suitable receive request found.\n"));
 
                TI_DbgPrint(MAX_TRACE,
                           ("Target Buffer: %x, Source Buffer: %x, Size %d\n",
                            Current->Buffer, DataBuffer, DataSize));
 
                /* Copy the data into buffer provided by the user */
                RtlCopyMemory(Current->Buffer,
                     DataBuffer,
                     MIN(Current->BufferSize, DataSize));
 
                RTAIPAddress = (PTA_IP_ADDRESS)Current->ReturnInfo->RemoteAddress;
                RTAIPAddress->TAAddressCount = 1;
                RTAIPAddress->Address->AddressType = TDI_ADDRESS_TYPE_IP;
                RTAIPAddress->Address->AddressLength = TDI_ADDRESS_LENGTH_IP;
                RTAIPAddress->Address->Address->sin_port = SrcPort;
                RTAIPAddress->Address->Address->in_addr = SrcAddress->Address.IPv4Address;
                RtlZeroMemory(RTAIPAddress->Address->Address->sin_zero, 8);
 
                TI_DbgPrint(MAX_TRACE, ("(A: %08x) Addr %08x Port %04x\n",
                            RTAIPAddress,
                            SrcAddress->Address.IPv4Address, SrcPort));
 
                ReferenceObject(AddrFile);
                UnlockObject(AddrFile);
 
                /* Complete the receive request */
                if (Current->BufferSize < DataSize)
                    Current->Complete(Current->Context, STATUS_BUFFER_OVERFLOW, Current->BufferSize);
                else
                    Current->Complete(Current->Context, STATUS_SUCCESS, DataSize);
 
                LockObject(AddrFile);
                DereferenceObject(AddrFile);
            }
        }
 
        UnlockObject(AddrFile);
    }
    else if (AddrFile->RegisteredReceiveDatagramHandler)
    {
        PTDI_IND_RECEIVE_DATAGRAM ReceiveHandler = AddrFile->ReceiveDatagramHandler;
        PVOID HandlerContext = AddrFile->ReceiveDatagramHandlerContext;
        PVOID OptionsData = NULL;
        INT32 OptionsSize = 0;
 
        TI_DbgPrint(MAX_TRACE, ("Calling receive event handler.\n"));
 
        if (SrcAddress->Type == IP_ADDRESS_V4)
        {
            AddressLength = sizeof(IPv4_RAW_ADDRESS);
            SourceAddress = &SrcAddress->Address.IPv4Address;
            OptionsSize = IPPacket->HeaderSize - sizeof(IPv4_HEADER);
            if (OptionsSize > 0)
            {
                OptionsData = (PUCHAR)IPPacket->Header + sizeof(IPv4_HEADER);
            }
        }
        else /* (Address->Type == IP_ADDRESS_V6) */
        {
            AddressLength = sizeof(IPv6_RAW_ADDRESS);
            SourceAddress = SrcAddress->Address.IPv6Address;
        }
 
        ReferenceObject(AddrFile);
        UnlockObject(AddrFile);
 
        TI_DbgPrint(MIN_TRACE, ("OptionsSize %d DataSize: %u\n", OptionsSize, DataSize));
 
        Status = (*ReceiveHandler)(HandlerContext,
            AddressLength,
            SourceAddress,
            OptionsSize,
            OptionsData,
            TDI_RECEIVE_ENTIRE_MESSAGE,
            DataSize,
            DataSize,
            &BytesTaken,
            DataBuffer,
            NULL);
 
        if (STATUS_SUCCESS != Status)
            TI_DbgPrint(MAX_TRACE, ("receive handler signaled failure with Status 0x%x\n", Status));
 
        DereferenceObject(AddrFile);
    }
    else
    {
        UnlockObject(AddrFile);
        TI_DbgPrint(MAX_TRACE, ("Discarding datagram.\n"));
    }
 
    TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
}

Referenced by RawIpReceive(), and UDPReceive().

DGReceiveDatagram()

NTSTATUS DGReceiveDatagram	(	PADDRESS_FILE	AddrFile,
		PTDI_CONNECTION_INFORMATION	ConnInfo,
		PCHAR	Buffer,
		ULONG	ReceiveLength,
		ULONG	ReceiveFlags,
		PTDI_CONNECTION_INFORMATION	ReturnInfo,
		PULONG	BytesReceived,
		PDATAGRAM_COMPLETION_ROUTINE	Complete,
		PVOID	Context,
		PIRP	Irp
	)

Definition at line 226 of file datagram.c.

{
    NTSTATUS Status;
    PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
 
    TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    LockObject(AddrFile);
 
    ReceiveRequest = ExAllocatePoolWithTag(NonPagedPool, sizeof(DATAGRAM_RECEIVE_REQUEST),
                                           DATAGRAM_RECV_TAG);
    if (ReceiveRequest)
    {
    /* Initialize a receive request */
 
    /* Extract the remote address filter from the request (if any) */
    if ((ConnInfo->RemoteAddressLength != 0) &&
        (ConnInfo->RemoteAddress))
        {
        Status = AddrGetAddress(ConnInfo->RemoteAddress,
                    &ReceiveRequest->RemoteAddress,
                    &ReceiveRequest->RemotePort);
        if (!NT_SUCCESS(Status))
            {
        ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG);
            UnlockObject(AddrFile);
        return Status;
            }
    }
    else
        {
        ReceiveRequest->RemotePort = 0;
        AddrInitIPv4(&ReceiveRequest->RemoteAddress, 0);
        }
 
    IoMarkIrpPending(Irp);
 
    ReceiveRequest->ReturnInfo = ReturnInfo;
    ReceiveRequest->Buffer = BufferData;
    ReceiveRequest->BufferSize = ReceiveLength;
    ReceiveRequest->UserComplete = Complete;
    ReceiveRequest->UserContext = Context;
    ReceiveRequest->Complete =
        (PDATAGRAM_COMPLETION_ROUTINE)DGReceiveComplete;
    ReceiveRequest->Context = ReceiveRequest;
        ReceiveRequest->AddressFile = AddrFile;
        ReceiveRequest->Irp = Irp;
 
    /* Queue receive request */
    InsertTailList(&AddrFile->ReceiveQueue, &ReceiveRequest->ListEntry);
 
    TI_DbgPrint(MAX_TRACE, ("Leaving (pending %08x).\n", ReceiveRequest));
 
    UnlockObject(AddrFile);
 
    return STATUS_PENDING;
    }
    else
    {
    UnlockObject(AddrFile);
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    TI_DbgPrint(MAX_TRACE, ("Leaving with errors (0x%X).\n", Status));
 
    return Status;
}

Referenced by DispTdiReceiveDatagram().

DGRemoveIRP()

BOOLEAN DGRemoveIRP	(	PADDRESS_FILE	AddrFile,
		PIRP	Irp
	)

Definition at line 13 of file datagram.c.

{
    PLIST_ENTRY ListEntry;
    PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
    BOOLEAN Found = FALSE;
 
    TI_DbgPrint(MAX_TRACE, ("Called (Cancel IRP %08x for file %08x).\n",
                            Irp, AddrFile));
 
    LockObject(AddrFile);
 
    for( ListEntry = AddrFile->ReceiveQueue.Flink;
         ListEntry != &AddrFile->ReceiveQueue;
         ListEntry = ListEntry->Flink )
    {
        ReceiveRequest = CONTAINING_RECORD
            (ListEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry);
 
        TI_DbgPrint(MAX_TRACE, ("Request: %08x?\n", ReceiveRequest));
 
        if (ReceiveRequest->Irp == Irp)
        {
            RemoveEntryList(&ReceiveRequest->ListEntry);
            ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG);
            Found = TRUE;
            break;
        }
    }
 
    UnlockObject(AddrFile);
 
    TI_DbgPrint(MAX_TRACE, ("Done.\n"));
 
    return Found;
}

Referenced by DispCancelRequest().