udp.c File Reference

#include "precomp.h"

Include dependency graph for udp.c:

Go to the source code of this file.

Functions
NTSTATUS	AddUDPHeaderIPv4 (PADDRESS_FILE AddrFile, PIP_ADDRESS RemoteAddress, USHORT RemotePort, PIP_ADDRESS LocalAddress, USHORT LocalPort, PIP_PACKET IPPacket, PVOID Data, UINT DataLength)
NTSTATUS	BuildUDPPacket (PADDRESS_FILE AddrFile, PIP_PACKET Packet, PIP_ADDRESS RemoteAddress, USHORT RemotePort, PIP_ADDRESS LocalAddress, USHORT LocalPort, PCHAR DataBuffer, UINT DataLen)
static BOOLEAN	UDPIsBroadcastAddress (_In_ PIP_ADDRESS Address)
	Checks whether an address is the limited broadcast address or the directed broadcast address of a non-loopback interface.
NTSTATUS	UDPSendDatagram (PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR BufferData, ULONG DataSize, PULONG DataUsed)
VOID	UDPReceive (PIP_INTERFACE Interface, PIP_PACKET IPPacket)
NTSTATUS	UDPStartup (VOID)
NTSTATUS	UDPShutdown (VOID)
UINT	UDPAllocatePort (UINT HintPort)
VOID	UDPFreePort (UINT Port)

Variables
BOOLEAN	UDPInitialized = FALSE
PORT_SET	UDPPorts

Function Documentation

AddUDPHeaderIPv4()

NTSTATUS AddUDPHeaderIPv4	(	PADDRESS_FILE	AddrFile,
		PIP_ADDRESS	RemoteAddress,
		USHORT	RemotePort,
		PIP_ADDRESS	LocalAddress,
		USHORT	LocalPort,
		PIP_PACKET	IPPacket,
		PVOID	Data,
		UINT	DataLength
	)

Definition at line 16 of file udp.c.

{
    PUDP_HEADER UDPHeader;
    NTSTATUS Status;
 
    TI_DbgPrint(MID_TRACE, ("Packet: %x NdisPacket %x\n",
                IPPacket, IPPacket->NdisPacket));
 
    Status = AddGenericHeaderIPv4
        ( AddrFile, RemoteAddress, RemotePort,
          LocalAddress, LocalPort,
          IPPacket, DataLength, IPPROTO_UDP,
          sizeof(UDP_HEADER), (PVOID *)&UDPHeader );
 
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Port values are already big-endian values */
    UDPHeader->SourcePort = LocalPort;
    UDPHeader->DestPort   = RemotePort;
    UDPHeader->Checksum   = 0;
    /* Length of UDP header and data */
    UDPHeader->Length     = WH2N(DataLength + sizeof(UDP_HEADER));
 
    TI_DbgPrint(MID_TRACE, ("Copying data (hdr %x data %x (%d))\n",
                IPPacket->Header, IPPacket->Data,
                (PCHAR)IPPacket->Data - (PCHAR)IPPacket->Header));
 
    RtlCopyMemory(IPPacket->Data, Data, DataLength);
 
    UDPHeader->Checksum = UDPv4ChecksumCalculate((PIPv4_HEADER)IPPacket->Header,
                                                 (PUCHAR)UDPHeader,
                                                 DataLength + sizeof(UDP_HEADER));
    UDPHeader->Checksum = WH2N(UDPHeader->Checksum);
 
    TI_DbgPrint(MID_TRACE, ("Packet: %d ip %d udp %d payload\n",
                (PCHAR)UDPHeader - (PCHAR)IPPacket->Header,
                (PCHAR)IPPacket->Data - (PCHAR)UDPHeader,
                DataLength));
 
    return STATUS_SUCCESS;
}

Referenced by BuildUDPPacket().

BuildUDPPacket()

NTSTATUS BuildUDPPacket	(	PADDRESS_FILE	AddrFile,
		PIP_PACKET	Packet,
		PIP_ADDRESS	RemoteAddress,
		USHORT	RemotePort,
		PIP_ADDRESS	LocalAddress,
		USHORT	LocalPort,
		PCHAR	DataBuffer,
		UINT	DataLen
	)

Definition at line 78 of file udp.c.

{
    NTSTATUS Status;
 
    TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
    /* FIXME: Assumes IPv4 */
    IPInitializePacket(Packet, IP_ADDRESS_V4);
 
    Packet->TotalSize = sizeof(IPv4_HEADER) + sizeof(UDP_HEADER) + DataLen;
 
    /* Prepare packet */
    Status = AllocatePacketWithBuffer(&Packet->NdisPacket,
                                      NULL,
                                      Packet->TotalSize );
 
    if( !NT_SUCCESS(Status) )
    {
        Packet->Free(Packet);
        return Status;
    }
 
    TI_DbgPrint(MID_TRACE, ("Allocated packet: %x\n", Packet->NdisPacket));
    TI_DbgPrint(MID_TRACE, ("Local Addr : %s\n", A2S(LocalAddress)));
    TI_DbgPrint(MID_TRACE, ("Remote Addr: %s\n", A2S(RemoteAddress)));
 
    switch (RemoteAddress->Type) {
        case IP_ADDRESS_V4:
            Status = AddUDPHeaderIPv4(AddrFile, RemoteAddress, RemotePort,
                                      LocalAddress, LocalPort, Packet, DataBuffer, DataLen);
            break;
        case IP_ADDRESS_V6:
            /* FIXME: Support IPv6 */
            TI_DbgPrint(MIN_TRACE, ("IPv6 UDP datagrams are not supported.\n"));
        default:
            Status = STATUS_UNSUCCESSFUL;
            break;
    }
    if (!NT_SUCCESS(Status)) {
        TI_DbgPrint(MIN_TRACE, ("Cannot add UDP header. Status = (0x%X)\n",
                                Status));
        Packet->Free(Packet);
        return Status;
    }
 
    TI_DbgPrint(MID_TRACE, ("Displaying packet\n"));
 
    DISPLAY_IP_PACKET(Packet);
 
    TI_DbgPrint(MID_TRACE, ("Leaving\n"));
 
    return STATUS_SUCCESS;
}

Referenced by UDPSendDatagram().

UDPAllocatePort()

UINT UDPAllocatePort

(

UINT

HintPort

)

Definition at line 452 of file udp.c.

                                      {
    if( HintPort ) {
        if( AllocatePort( &UDPPorts, HintPort ) ) return HintPort;
        else return (UINT)-1;
    } else return AllocatePortFromRange
               ( &UDPPorts, UDP_STARTING_PORT,
                 UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
}

Referenced by FileOpenAddress().

UDPFreePort()

VOID UDPFreePort

(

UINT

Port

)

Definition at line 461 of file udp.c.

                              {
    DeallocatePort( &UDPPorts, Port );
}

Referenced by AddrFileFree().

UDPIsBroadcastAddress()

static BOOLEAN UDPIsBroadcastAddress ( _In_ PIP_ADDRESS  Address )

static

Checks whether an address is the limited broadcast address or the directed broadcast address of a non-loopback interface.

Parameters

[in]

Address

Destination address to check.

Returns

TRUE if the address is a broadcast address, FALSE otherwise.

Definition at line 163 of file udp.c.

{
    BOOLEAN IsBroadcast = FALSE;
    KIRQL OldIrql;
    IF_LIST_ITER(CurrentIF);
 
    if (Address->Type != IP_ADDRESS_V4)
        return FALSE;
 
    if (Address->Address.IPv4Address == 0xFFFFFFFF)
        return TRUE;
 
    TcpipAcquireSpinLock(&InterfaceListLock, &OldIrql);
 
    ForEachInterface(CurrentIF) {
        if (CurrentIF != Loopback && AddrIsEqual(&CurrentIF->Broadcast, Address))
        {
            IsBroadcast = TRUE;
            break;
        }
    } EndFor(CurrentIF);
 
    TcpipReleaseSpinLock(&InterfaceListLock, OldIrql);
 
    return IsBroadcast;
}

Referenced by UDPSendDatagram().

UDPReceive()

VOID UDPReceive	(	PIP_INTERFACE	Interface,
		PIP_PACKET	IPPacket
	)

Definition at line 310 of file udp.c.

{
  AF_SEARCH SearchContext;
  PIPv4_HEADER IPv4Header;
  PADDRESS_FILE AddrFile;
  PUDP_HEADER UDPHeader;
  PIP_ADDRESS DstAddress, SrcAddress;
  UINT DataSize, i;
 
  TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 
  switch (IPPacket->Type) {
  /* IPv4 packet */
  case IP_ADDRESS_V4:
    IPv4Header = IPPacket->Header;
    DstAddress = &IPPacket->DstAddr;
    SrcAddress = &IPPacket->SrcAddr;
    break;
 
  /* IPv6 packet */
  case IP_ADDRESS_V6:
    TI_DbgPrint(MIN_TRACE, ("Discarded IPv6 UDP datagram (%i bytes).\n", IPPacket->TotalSize));
 
    /* FIXME: IPv6 is not supported */
    return;
 
  default:
    return;
  }
 
  UDPHeader = (PUDP_HEADER)IPPacket->Data;
 
  /* Calculate and validate UDP checksum */
  i = UDPv4ChecksumCalculate(IPv4Header,
                             (PUCHAR)UDPHeader,
                             WH2N(UDPHeader->Length));
  if (i != DH2N(0x0000FFFF) && UDPHeader->Checksum != 0)
  {
      TI_DbgPrint(MIN_TRACE, ("Bad checksum on packet received.\n"));
      return;
  }
 
  /* Sanity checks */
  i = WH2N(UDPHeader->Length);
  if ((i < sizeof(UDP_HEADER)) || (i > IPPacket->TotalSize - IPPacket->Position)) {
    /* Incorrect or damaged packet received, discard it */
    TI_DbgPrint(MIN_TRACE, ("Incorrect or damaged UDP packet received.\n"));
    return;
  }
 
  DataSize = i - sizeof(UDP_HEADER);
 
  /* Go to UDP data area */
  IPPacket->Data = (PVOID)((ULONG_PTR)IPPacket->Data + sizeof(UDP_HEADER));
 
  /* Locate a receive request on destination address file object
     and deliver the packet if one is found. If there is no receive
     request on the address file object, call the associated receive
     handler. If no receive handler is registered, drop the packet */
 
  AddrFile = AddrSearchFirst(DstAddress,
                             UDPHeader->DestPort,
                             IPPROTO_UDP,
                             &SearchContext);
  if (AddrFile) {
    do {
      DGDeliverData(AddrFile,
            SrcAddress,
                    DstAddress,
            UDPHeader->SourcePort,
            UDPHeader->DestPort,
                    IPPacket,
                    DataSize);
      DereferenceObject(AddrFile);
    } while ((AddrFile = AddrSearchNext(&SearchContext)) != NULL);
  } else {
    /* There are no open address files that will take this datagram */
    /* FIXME: IPv4 only */
    TI_DbgPrint(MID_TRACE, ("Cannot deliver IPv4 UDP datagram to address (0x%X).\n",
      DN2H(DstAddress->Address.IPv4Address)));
 
    /* FIXME: Send ICMP reply */
  }
  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
}

Referenced by UDPStartup().

UDPSendDatagram()

NTSTATUS UDPSendDatagram	(	PADDRESS_FILE	AddrFile,
		PTDI_CONNECTION_INFORMATION	ConnInfo,
		PCHAR	BufferData,
		ULONG	DataSize,
		PULONG	DataUsed
	)

Definition at line 191 of file udp.c.

{
    IP_PACKET Packet;
    PTA_IP_ADDRESS RemoteAddressTa = (PTA_IP_ADDRESS)ConnInfo->RemoteAddress;
    IP_ADDRESS RemoteAddress;
    IP_ADDRESS LocalAddress;
    USHORT RemotePort;
    NTSTATUS Status;
    PNEIGHBOR_CACHE_ENTRY NCE;
    IP_PACKET LoopPacket;
    PNEIGHBOR_CACHE_ENTRY LoopNCE = NULL;
 
    LockObject(AddrFile);
 
    TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n",
                           AddrFile, ConnInfo, BufferData, DataSize));
    TI_DbgPrint(MID_TRACE,("RemoteAddressTa: %x\n", RemoteAddressTa));
 
    switch( RemoteAddressTa->Address[0].AddressType ) {
    case TDI_ADDRESS_TYPE_IP:
        RemoteAddress.Type = IP_ADDRESS_V4;
        RemoteAddress.Address.IPv4Address =
            RemoteAddressTa->Address[0].Address[0].in_addr;
        RemotePort = RemoteAddressTa->Address[0].Address[0].sin_port;
        break;
 
    default:
        UnlockObject(AddrFile);
        return STATUS_UNSUCCESSFUL;
    }
 
    LocalAddress = AddrFile->Address;
    if (AddrIsUnspecified(&LocalAddress))
    {
        /* If the local address is unspecified (0),
         * then use the unicast address of the
         * interface we're sending over
         */
        if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
            UnlockObject(AddrFile);
            return STATUS_NETWORK_UNREACHABLE;
        }
 
        LocalAddress = NCE->Interface->Unicast;
    }
    else
    {
        if(!(NCE = NBLocateNeighbor( &LocalAddress, NULL ))) {
            UnlockObject(AddrFile);
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    Status = BuildUDPPacket( AddrFile,
                             &Packet,
                             &RemoteAddress,
                             RemotePort,
                             &LocalAddress,
                             AddrFile->Port,
                             BufferData,
                             DataSize );
 
    if (!NT_SUCCESS(Status))
    {
        UnlockObject(AddrFile);
        return Status;
    }
 
    /* NDIS does not loop broadcasts back to the sender, so deliver a local copy */
    if (Loopback != NULL &&
        NCE->Interface != Loopback &&
        UDPIsBroadcastAddress(&RemoteAddress))
    {
        LoopNCE = NBLocateNeighbor(&Loopback->Unicast, Loopback);
        if (LoopNCE != NULL &&
            !NT_SUCCESS(BuildUDPPacket(AddrFile,
                                       &LoopPacket,
                                       &RemoteAddress,
                                       RemotePort,
                                       &LocalAddress,
                                       AddrFile->Port,
                                       BufferData,
                                       DataSize)))
        {
            LoopNCE = NULL;
        }
    }
 
    UnlockObject(AddrFile);
 
    Status = IPSendDatagram(&Packet, NCE);
 
    if (LoopNCE != NULL)
        IPSendDatagram(&LoopPacket, LoopNCE);
 
    if (!NT_SUCCESS(Status))
        return Status;
 
    *DataUsed = DataSize;
 
    return STATUS_SUCCESS;
}

Referenced by FileOpenAddress().

UDPShutdown()

NTSTATUS UDPShutdown

(

VOID

)

Definition at line 431 of file udp.c.

{
  if (!UDPInitialized)
      return STATUS_SUCCESS;
 
  PortsShutdown( &UDPPorts );
 
  /* Deregister this protocol with IP layer */
  IPRegisterProtocol(IPPROTO_UDP, NULL);
 
  UDPInitialized = FALSE;
 
  return STATUS_SUCCESS;
}

Referenced by TiUnload().

UDPStartup()

NTSTATUS UDPStartup

(

VOID

)

Definition at line 406 of file udp.c.

{
  NTSTATUS Status;
 
  RtlZeroMemory(&UDPStats, sizeof(UDP_STATISTICS));
 
  Status = PortsStartup( &UDPPorts, 1, UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 
  if( !NT_SUCCESS(Status) ) return Status;
 
  /* Register this protocol with IP layer */
  IPRegisterProtocol(IPPROTO_UDP, UDPReceive);
 
  UDPInitialized = TRUE;
 
  return STATUS_SUCCESS;
}

Referenced by DriverEntry().

Variable Documentation

UDPInitialized

BOOLEAN UDPInitialized = FALSE

Definition at line 13 of file udp.c.

Referenced by UDPShutdown(), and UDPStartup().

UDPPorts

PORT_SET UDPPorts

Definition at line 14 of file udp.c.

Referenced by UDPAllocatePort(), UDPFreePort(), UDPShutdown(), and UDPStartup().