lib/drivers/ip/transport/udp/udp.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS TCP/IP protocol driver
   4  * FILE:        transport/udp/udp.c
   5  * PURPOSE:     User Datagram Protocol routines
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/08-2000 Created
   9  */
  10
  11 #include "precomp.h"
  12
  13 BOOLEAN UDPInitialized = FALSE;
  14 PORT_SET UDPPorts;
  15
  16 NTSTATUS AddUDPHeaderIPv4(
  17     PADDRESS_FILE AddrFile,
  18     PIP_ADDRESS RemoteAddress,
  19     USHORT RemotePort,
  20     PIP_ADDRESS LocalAddress,
  21     USHORT LocalPort,
  22     PIP_PACKET IPPacket,
  23     PVOID Data,
  24     UINT DataLength)
  25 /*
  26  * FUNCTION: Adds an IPv4 and UDP header to an IP packet
  27  * ARGUMENTS:
  28  *     SendRequest  = Pointer to send request
  29  *     LocalAddress = Pointer to our local address
  30  *     LocalPort    = The port we send this datagram from
  31  *     IPPacket     = Pointer to IP packet
  32  * RETURNS:
  33  *     Status of operation
  34  */
  35 {
  36     PUDP_HEADER UDPHeader;
  37     NTSTATUS Status;
  38
  39     TI_DbgPrint(MID_TRACE, ("Packet: %x NdisPacket %x\n",
  40                             IPPacket, IPPacket->NdisPacket));
  41
  42     Status = AddGenericHeaderIPv4
  43         ( AddrFile, RemoteAddress, RemotePort,
  44           LocalAddress, LocalPort,
  45           IPPacket, DataLength, IPPROTO_UDP,
  46           sizeof(UDP_HEADER), (PVOID *)&UDPHeader );
  47
  48     if (!NT_SUCCESS(Status))
  49         return Status;
  50
  51     /* Port values are already big-endian values */
  52     UDPHeader->SourcePort = LocalPort;
  53     UDPHeader->DestPort   = RemotePort;
  54     UDPHeader->Checksum   = 0;
  55     /* Length of UDP header and data */
  56     UDPHeader->Length     = WH2N(DataLength + sizeof(UDP_HEADER));
  57
  58     TI_DbgPrint(MID_TRACE, ("Copying data (hdr %x data %x (%d))\n",
  59                             IPPacket->Header, IPPacket->Data,
  60                             (PCHAR)IPPacket->Data - (PCHAR)IPPacket->Header));
  61
  62     RtlCopyMemory(IPPacket->Data, Data, DataLength);
  63
  64     UDPHeader->Checksum = UDPv4ChecksumCalculate((PIPv4_HEADER)IPPacket->Header,
  65                                                  (PUCHAR)UDPHeader,
  66                                                  DataLength + sizeof(UDP_HEADER));
  67     UDPHeader->Checksum = WH2N(UDPHeader->Checksum);
  68
  69     TI_DbgPrint(MID_TRACE, ("Packet: %d ip %d udp %d payload\n",
  70                             (PCHAR)UDPHeader - (PCHAR)IPPacket->Header,
  71                             (PCHAR)IPPacket->Data - (PCHAR)UDPHeader,
  72                             DataLength));
  73
  74     return STATUS_SUCCESS;
  75 }
  76
  77
  78 NTSTATUS BuildUDPPacket(
  79     PADDRESS_FILE AddrFile,
  80     PIP_PACKET Packet,
  81     PIP_ADDRESS RemoteAddress,
  82     USHORT RemotePort,
  83     PIP_ADDRESS LocalAddress,
  84     USHORT LocalPort,
  85     PCHAR DataBuffer,
  86     UINT DataLen )
  87 /*
  88  * FUNCTION: Builds an UDP packet
  89  * ARGUMENTS:
  90  *     Context      = Pointer to context information (DATAGRAM_SEND_REQUEST)
  91  *     LocalAddress = Pointer to our local address
  92  *     LocalPort    = The port we send this datagram from
  93  *     IPPacket     = Address of pointer to IP packet
  94  * RETURNS:
  95  *     Status of operation
  96  */
  97 {
  98     NTSTATUS Status;
  99
 100     TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 101
 102     /* FIXME: Assumes IPv4 */
 103     IPInitializePacket(Packet, IP_ADDRESS_V4);
 104
 105     Packet->TotalSize = sizeof(IPv4_HEADER) + sizeof(UDP_HEADER) + DataLen;
 106
 107     /* Prepare packet */
 108     Status = AllocatePacketWithBuffer( &Packet->NdisPacket,
 109                                        NULL,
 110                                        Packet->TotalSize );
 111
 112     if( !NT_SUCCESS(Status) ) return Status;
 113
 114     TI_DbgPrint(MID_TRACE, ("Allocated packet: %x\n", Packet->NdisPacket));
 115     TI_DbgPrint(MID_TRACE, ("Local Addr : %s\n", A2S(LocalAddress)));
 116     TI_DbgPrint(MID_TRACE, ("Remote Addr: %s\n", A2S(RemoteAddress)));
 117
 118     switch (RemoteAddress->Type) {
 119     case IP_ADDRESS_V4:
 120         Status = AddUDPHeaderIPv4(AddrFile, RemoteAddress, RemotePort,
 121                                   LocalAddress, LocalPort, Packet, DataBuffer, DataLen);
 122         break;
 123     case IP_ADDRESS_V6:
 124         /* FIXME: Support IPv6 */
 125         TI_DbgPrint(MIN_TRACE, ("IPv6 UDP datagrams are not supported.\n"));
 126     default:
 127         Status = STATUS_UNSUCCESSFUL;
 128         break;
 129     }
 130     if (!NT_SUCCESS(Status)) {
 131         TI_DbgPrint(MIN_TRACE, ("Cannot add UDP header. Status = (0x%X)\n",
 132                                 Status));
 133         FreeNdisPacket(Packet->NdisPacket);
 134         return Status;
 135     }
 136
 137     TI_DbgPrint(MID_TRACE, ("Displaying packet\n"));
 138
 139     DISPLAY_IP_PACKET(Packet);
 140
 141     TI_DbgPrint(MID_TRACE, ("Leaving\n"));
 142
 143     return STATUS_SUCCESS;
 144 }
 145
 146 VOID UDPSendPacketComplete
 147 ( PVOID Context, PNDIS_PACKET Packet, NDIS_STATUS Status ) {
 148     FreeNdisPacket( Packet );
 149 }
 150
 151 NTSTATUS UDPSendDatagram(
 152     PADDRESS_FILE AddrFile,
 153     PTDI_CONNECTION_INFORMATION ConnInfo,
 154     PCHAR BufferData,
 155     ULONG DataSize,
 156     PULONG DataUsed )
 157 /*
 158  * FUNCTION: Sends an UDP datagram to a remote address
 159  * ARGUMENTS:
 160  *     Request   = Pointer to TDI request
 161  *     ConnInfo  = Pointer to connection information
 162  *     Buffer    = Pointer to NDIS buffer with data
 163  *     DataSize  = Size in bytes of data to be sent
 164  * RETURNS:
 165  *     Status of operation
 166  */
 167 {
 168     IP_PACKET Packet;
 169     PTA_IP_ADDRESS RemoteAddressTa = (PTA_IP_ADDRESS)ConnInfo->RemoteAddress;
 170     IP_ADDRESS RemoteAddress;
 171     IP_ADDRESS LocalAddress;
 172     USHORT RemotePort;
 173     NTSTATUS Status;
 174     PNEIGHBOR_CACHE_ENTRY NCE;
 175     KIRQL OldIrql;
 176
 177     LockObject(AddrFile, &OldIrql);
 178
 179     TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n",
 180                                                    AddrFile, ConnInfo, BufferData, DataSize));
 181     TI_DbgPrint(MID_TRACE,("RemoteAddressTa: %x\n", RemoteAddressTa));
 182
 183     switch( RemoteAddressTa->Address[0].AddressType ) {
 184     case TDI_ADDRESS_TYPE_IP:
 185                 RemoteAddress.Type = IP_ADDRESS_V4;
 186                 RemoteAddress.Address.IPv4Address =
 187                         RemoteAddressTa->Address[0].Address[0].in_addr;
 188                 RemotePort = RemoteAddressTa->Address[0].Address[0].sin_port;
 189                 break;
 190
 191     default:
 192                 UnlockObject(AddrFile, OldIrql);
 193                 return STATUS_UNSUCCESSFUL;
 194     }
 195
 196     LocalAddress = AddrFile->Address;
 197     if (AddrIsUnspecified(&LocalAddress))
 198     {
 199         /* If the local address is unspecified (0),
 200          * then use the unicast address of the
 201          * interface we're sending over
 202          */
 203         if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
 204              UnlockObject(AddrFile, OldIrql);
 205              return STATUS_NETWORK_UNREACHABLE;
 206         }
 207
 208         LocalAddress = NCE->Interface->Unicast;
 209     }
 210     else
 211     {
 212         if(!(NCE = NBLocateNeighbor( &LocalAddress ))) {
 213              UnlockObject(AddrFile, OldIrql);
 214              return STATUS_INVALID_PARAMETER;
 215         }
 216     }
 217
 218     Status = BuildUDPPacket( AddrFile,
 219                                                          &Packet,
 220                                                          &RemoteAddress,
 221                                                          RemotePort,
 222                                                          &LocalAddress,
 223                                                          AddrFile->Port,
 224                                                          BufferData,
 225                                                          DataSize );
 226
 227     UnlockObject(AddrFile, OldIrql);
 228
 229     if( !NT_SUCCESS(Status) )
 230                 return Status;
 231
 232     if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, UDPSendPacketComplete, NULL )))
 233     {
 234         FreeNdisPacket(Packet.NdisPacket);
 235         return Status;
 236     }
 237
 238     *DataUsed = DataSize;
 239
 240     return STATUS_SUCCESS;
 241 }
 242
 243
 244 VOID UDPReceive(PIP_INTERFACE Interface, PIP_PACKET IPPacket)
 245 /*
 246  * FUNCTION: Receives and queues a UDP datagram
 247  * ARGUMENTS:
 248  *     NTE      = Pointer to net table entry which the packet was received on
 249 *     IPPacket = Pointer to an IP packet that was received
 250 * NOTES:
 251 *     This is the low level interface for receiving UDP datagrams. It strips
 252 *     the UDP header from a packet and delivers the data to anyone that wants it
 253 */
 254 {
 255   AF_SEARCH SearchContext;
 256   PIPv4_HEADER IPv4Header;
 257   PADDRESS_FILE AddrFile;
 258   PUDP_HEADER UDPHeader;
 259   PIP_ADDRESS DstAddress, SrcAddress;
 260   UINT DataSize, i;
 261
 262   TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 263
 264   switch (IPPacket->Type) {
 265   /* IPv4 packet */
 266   case IP_ADDRESS_V4:
 267     IPv4Header = IPPacket->Header;
 268     DstAddress = &IPPacket->DstAddr;
 269     SrcAddress = &IPPacket->SrcAddr;
 270     break;
 271
 272   /* IPv6 packet */
 273   case IP_ADDRESS_V6:
 274     TI_DbgPrint(MIN_TRACE, ("Discarded IPv6 UDP datagram (%i bytes).\n", IPPacket->TotalSize));
 275
 276     /* FIXME: IPv6 is not supported */
 277     return;
 278
 279   default:
 280     return;
 281   }
 282
 283   UDPHeader = (PUDP_HEADER)IPPacket->Data;
 284
 285   /* Calculate and validate UDP checksum */
 286   i = UDPv4ChecksumCalculate(IPv4Header,
 287                              (PUCHAR)UDPHeader,
 288                              WH2N(UDPHeader->Length));
 289   if (i != DH2N(0x0000FFFF) && UDPHeader->Checksum != 0)
 290   {
 291       TI_DbgPrint(MIN_TRACE, ("Bad checksum on packet received.\n"));
 292       return;
 293   }
 294
 295   /* Sanity checks */
 296   i = WH2N(UDPHeader->Length);
 297   if ((i < sizeof(UDP_HEADER)) || (i > IPPacket->TotalSize - IPPacket->Position)) {
 298     /* Incorrect or damaged packet received, discard it */
 299     TI_DbgPrint(MIN_TRACE, ("Incorrect or damaged UDP packet received.\n"));
 300     return;
 301   }
 302
 303   DataSize = i - sizeof(UDP_HEADER);
 304
 305   /* Go to UDP data area */
 306   IPPacket->Data = (PVOID)((ULONG_PTR)IPPacket->Data + sizeof(UDP_HEADER));
 307
 308   /* Locate a receive request on destination address file object
 309      and deliver the packet if one is found. If there is no receive
 310      request on the address file object, call the associated receive
 311      handler. If no receive handler is registered, drop the packet */
 312
 313   AddrFile = AddrSearchFirst(DstAddress,
 314                              UDPHeader->DestPort,
 315                              IPPROTO_UDP,
 316                              &SearchContext);
 317   if (AddrFile) {
 318     do {
 319       DGDeliverData(AddrFile,
 320                     SrcAddress,
 321                     DstAddress,
 322                     UDPHeader->SourcePort,
 323                     UDPHeader->DestPort,
 324                     IPPacket,
 325                     DataSize);
 326     } while ((AddrFile = AddrSearchNext(&SearchContext)) != NULL);
 327   } else {
 328     /* There are no open address files that will take this datagram */
 329     /* FIXME: IPv4 only */
 330     TI_DbgPrint(MID_TRACE, ("Cannot deliver IPv4 UDP datagram to address (0x%X).\n",
 331       DN2H(DstAddress->Address.IPv4Address)));
 332
 333     /* FIXME: Send ICMP reply */
 334   }
 335   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 336 }
 337
 338
 339 NTSTATUS UDPStartup(
 340   VOID)
 341 /*
 342  * FUNCTION: Initializes the UDP subsystem
 343  * RETURNS:
 344  *     Status of operation
 345  */
 346 {
 347   NTSTATUS Status;
 348
 349 #ifdef __NTDRIVER__
 350   RtlZeroMemory(&UDPStats, sizeof(UDP_STATISTICS));
 351 #endif
 352
 353   Status = PortsStartup( &UDPPorts, 1, UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 354
 355   if( !NT_SUCCESS(Status) ) return Status;
 356
 357   /* Register this protocol with IP layer */
 358   IPRegisterProtocol(IPPROTO_UDP, UDPReceive);
 359
 360   UDPInitialized = TRUE;
 361
 362   return STATUS_SUCCESS;
 363 }
 364
 365
 366 NTSTATUS UDPShutdown(
 367   VOID)
 368 /*
 369  * FUNCTION: Shuts down the UDP subsystem
 370  * RETURNS:
 371  *     Status of operation
 372  */
 373 {
 374   if (!UDPInitialized)
 375       return STATUS_SUCCESS;
 376
 377   PortsShutdown( &UDPPorts );
 378
 379   /* Deregister this protocol with IP layer */
 380   IPRegisterProtocol(IPPROTO_UDP, NULL);
 381
 382   UDPInitialized = FALSE;
 383
 384   return STATUS_SUCCESS;
 385 }
 386
 387 UINT UDPAllocatePort( UINT HintPort ) {
 388     if( HintPort ) {
 389         if( AllocatePort( &UDPPorts, HintPort ) ) return HintPort;
 390         else return (UINT)-1;
 391     } else return AllocatePortFromRange
 392                ( &UDPPorts, UDP_STARTING_PORT,
 393                  UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 394 }
 395
 396 VOID UDPFreePort( UINT Port ) {
 397     DeallocatePort( &UDPPorts, Port );
 398 }
 399
 400 /* EOF */