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     return STATUS_SUCCESS;
 239 }
 240
 241
 242 VOID UDPReceive(PIP_INTERFACE Interface, PIP_PACKET IPPacket)
 243 /*
 244  * FUNCTION: Receives and queues a UDP datagram
 245  * ARGUMENTS:
 246  *     NTE      = Pointer to net table entry which the packet was received on
 247 *     IPPacket = Pointer to an IP packet that was received
 248 * NOTES:
 249 *     This is the low level interface for receiving UDP datagrams. It strips
 250 *     the UDP header from a packet and delivers the data to anyone that wants it
 251 */
 252 {
 253   AF_SEARCH SearchContext;
 254   PIPv4_HEADER IPv4Header;
 255   PADDRESS_FILE AddrFile;
 256   PUDP_HEADER UDPHeader;
 257   PIP_ADDRESS DstAddress, SrcAddress;
 258   UINT DataSize, i;
 259
 260   TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 261
 262   switch (IPPacket->Type) {
 263   /* IPv4 packet */
 264   case IP_ADDRESS_V4:
 265     IPv4Header = IPPacket->Header;
 266     DstAddress = &IPPacket->DstAddr;
 267     SrcAddress = &IPPacket->SrcAddr;
 268     break;
 269
 270   /* IPv6 packet */
 271   case IP_ADDRESS_V6:
 272     TI_DbgPrint(MIN_TRACE, ("Discarded IPv6 UDP datagram (%i bytes).\n", IPPacket->TotalSize));
 273
 274     /* FIXME: IPv6 is not supported */
 275     return;
 276
 277   default:
 278     return;
 279   }
 280
 281   UDPHeader = (PUDP_HEADER)IPPacket->Data;
 282
 283   /* Calculate and validate UDP checksum */
 284   i = UDPv4ChecksumCalculate(IPv4Header,
 285                              (PUCHAR)UDPHeader,
 286                              WH2N(UDPHeader->Length));
 287   if (i != DH2N(0x0000FFFF) && UDPHeader->Checksum != 0)
 288   {
 289       TI_DbgPrint(MIN_TRACE, ("Bad checksum on packet received.\n"));
 290       return;
 291   }
 292
 293   /* Sanity checks */
 294   i = WH2N(UDPHeader->Length);
 295   if ((i < sizeof(UDP_HEADER)) || (i > IPPacket->TotalSize - IPPacket->Position)) {
 296     /* Incorrect or damaged packet received, discard it */
 297     TI_DbgPrint(MIN_TRACE, ("Incorrect or damaged UDP packet received.\n"));
 298     return;
 299   }
 300
 301   DataSize = i - sizeof(UDP_HEADER);
 302
 303   /* Go to UDP data area */
 304   IPPacket->Data = (PVOID)((ULONG_PTR)IPPacket->Data + sizeof(UDP_HEADER));
 305
 306   /* Locate a receive request on destination address file object
 307      and deliver the packet if one is found. If there is no receive
 308      request on the address file object, call the associated receive
 309      handler. If no receive handler is registered, drop the packet */
 310
 311   AddrFile = AddrSearchFirst(DstAddress,
 312                              UDPHeader->DestPort,
 313                              IPPROTO_UDP,
 314                              &SearchContext);
 315   if (AddrFile) {
 316     do {
 317       DGDeliverData(AddrFile,
 318                     SrcAddress,
 319                     DstAddress,
 320                     UDPHeader->SourcePort,
 321                     UDPHeader->DestPort,
 322                     IPPacket,
 323                     DataSize);
 324     } while ((AddrFile = AddrSearchNext(&SearchContext)) != NULL);
 325   } else {
 326     /* There are no open address files that will take this datagram */
 327     /* FIXME: IPv4 only */
 328     TI_DbgPrint(MID_TRACE, ("Cannot deliver IPv4 UDP datagram to address (0x%X).\n",
 329       DN2H(DstAddress->Address.IPv4Address)));
 330
 331     /* FIXME: Send ICMP reply */
 332   }
 333   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 334 }
 335
 336
 337 NTSTATUS UDPStartup(
 338   VOID)
 339 /*
 340  * FUNCTION: Initializes the UDP subsystem
 341  * RETURNS:
 342  *     Status of operation
 343  */
 344 {
 345   NTSTATUS Status;
 346
 347 #ifdef __NTDRIVER__
 348   RtlZeroMemory(&UDPStats, sizeof(UDP_STATISTICS));
 349 #endif
 350
 351   Status = PortsStartup( &UDPPorts, 1, UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 352
 353   if( !NT_SUCCESS(Status) ) return Status;
 354
 355   /* Register this protocol with IP layer */
 356   IPRegisterProtocol(IPPROTO_UDP, UDPReceive);
 357
 358   UDPInitialized = TRUE;
 359
 360   return STATUS_SUCCESS;
 361 }
 362
 363
 364 NTSTATUS UDPShutdown(
 365   VOID)
 366 /*
 367  * FUNCTION: Shuts down the UDP subsystem
 368  * RETURNS:
 369  *     Status of operation
 370  */
 371 {
 372   if (!UDPInitialized)
 373       return STATUS_SUCCESS;
 374
 375   PortsShutdown( &UDPPorts );
 376
 377   /* Deregister this protocol with IP layer */
 378   IPRegisterProtocol(IPPROTO_UDP, NULL);
 379
 380   UDPInitialized = FALSE;
 381
 382   return STATUS_SUCCESS;
 383 }
 384
 385 UINT UDPAllocatePort( UINT HintPort ) {
 386     if( HintPort ) {
 387         if( AllocatePort( &UDPPorts, HintPort ) ) return HintPort;
 388         else return (UINT)-1;
 389     } else return AllocatePortFromRange
 390                ( &UDPPorts, UDP_STARTING_PORT,
 391                  UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 392 }
 393
 394 VOID UDPFreePort( UINT Port ) {
 395     DeallocatePort( &UDPPorts, Port );
 396 }
 397
 398 /* EOF */