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