VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Udp4Dxe/Udp4Impl.c@ 106129

Last change on this file since 106129 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 51.5 KB
Line 
1/** @file
2 The implementation of the Udp4 protocol.
3
4Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Udp4Impl.h"
10
11UINT16 mUdp4RandomPort;
12
13/**
14 This function checks and timeouts the I/O datagrams holding by the corresponding
15 service context.
16
17 @param[in] Event The event this function registered to.
18 @param[in] Context The context data registered during the creation of
19 the Event.
20
21**/
22VOID
23EFIAPI
24Udp4CheckTimeout (
25 IN EFI_EVENT Event,
26 IN VOID *Context
27 );
28
29/**
30 This function finds the udp instance by the specified <Address, Port> pair.
31
32 @param[in] InstanceList Pointer to the head of the list linking the udp
33 instances.
34 @param[in] Address Pointer to the specified IPv4 address.
35 @param[in] Port The udp port number.
36
37 @retval TRUE The specified <Address, Port> pair is found.
38 @retval FALSE Otherwise.
39
40**/
41BOOLEAN
42Udp4FindInstanceByPort (
43 IN LIST_ENTRY *InstanceList,
44 IN EFI_IPv4_ADDRESS *Address,
45 IN UINT16 Port
46 );
47
48/**
49 This function is the packet transmitting notify function registered to the IpIo
50 interface. It's called to signal the udp TxToken when IpIo layer completes the
51 transmitting of the udp datagram.
52
53 @param[in] Status The completion status of the output udp datagram.
54 @param[in] Context Pointer to the context data.
55 @param[in] Sender Specify a pointer of EFI_IP4_PROTOCOL for sending.
56 @param[in] NotifyData Pointer to the notify data.
57
58**/
59VOID
60EFIAPI
61Udp4DgramSent (
62 IN EFI_STATUS Status,
63 IN VOID *Context,
64 IN IP_IO_IP_PROTOCOL Sender,
65 IN VOID *NotifyData
66 );
67
68/**
69 This function processes the received datagram passed up by the IpIo layer.
70
71 @param[in] Status The status of this udp datagram.
72 @param[in] IcmpError The IcmpError code, only available when Status is
73 EFI_ICMP_ERROR.
74 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA.
75 @param[in] Packet Pointer to the NET_BUF containing the received udp
76 datagram.
77 @param[in] Context Pointer to the context data.
78
79**/
80VOID
81EFIAPI
82Udp4DgramRcvd (
83 IN EFI_STATUS Status,
84 IN UINT8 IcmpError,
85 IN EFI_NET_SESSION_DATA *NetSession,
86 IN NET_BUF *Packet,
87 IN VOID *Context
88 );
89
90/**
91 This function cancels the token specified by Arg in the Map. This is a callback
92 used by Udp4InstanceCancelToken().
93
94 @param[in] Map Pointer to the NET_MAP.
95 @param[in] Item Pointer to the NET_MAP_ITEM.
96 @param[in] Arg Pointer to the token to be cancelled, if NULL,
97 the token specified by Item is cancelled.
98
99 @retval EFI_SUCCESS The token is cancelled if Arg is NULL or the token
100 is not the same as that in the Item if Arg is not
101 NULL.
102 @retval EFI_ABORTED Arg is not NULL, and the token specified by Arg is
103 cancelled.
104
105**/
106EFI_STATUS
107EFIAPI
108Udp4CancelTokens (
109 IN NET_MAP *Map,
110 IN NET_MAP_ITEM *Item,
111 IN VOID *Arg OPTIONAL
112 );
113
114/**
115 This function matches the received udp datagram with the Instance.
116
117 @param[in] Instance Pointer to the udp instance context data.
118 @param[in] Udp4Session Pointer to the EFI_UDP4_SESSION_DATA abstracted
119 from the received udp datagram.
120
121 @retval TRUE The udp datagram matches the receiving requirements of the
122 udp Instance.
123 @retval FALSE Otherwise.
124
125**/
126BOOLEAN
127Udp4MatchDgram (
128 IN UDP4_INSTANCE_DATA *Instance,
129 IN EFI_UDP4_SESSION_DATA *Udp4Session
130 );
131
132/**
133 This function removes the Wrap specified by Context and release relevant resources.
134
135 @param[in] Event The Event this notify function registered to.
136 @param[in] Context Pointer to the context data.
137
138**/
139VOID
140EFIAPI
141Udp4RecycleRxDataWrap (
142 IN EFI_EVENT Event,
143 IN VOID *Context
144 );
145
146/**
147 This function wraps the Packet and the RxData.
148
149 @param[in] Instance Pointer to the instance context data.
150 @param[in] Packet Pointer to the buffer containing the received
151 datagram.
152 @param[in] RxData Pointer to the EFI_UDP4_RECEIVE_DATA of this
153 datagram.
154
155 @return Pointer to the structure wrapping the RxData and the Packet.
156
157**/
158UDP4_RXDATA_WRAP *
159Udp4WrapRxData (
160 IN UDP4_INSTANCE_DATA *Instance,
161 IN NET_BUF *Packet,
162 IN EFI_UDP4_RECEIVE_DATA *RxData
163 );
164
165/**
166 This function enqueues the received datagram into the instances' receiving queues.
167
168 @param[in] Udp4Service Pointer to the udp service context data.
169 @param[in] Packet Pointer to the buffer containing the received
170 datagram.
171 @param[in] RxData Pointer to the EFI_UDP4_RECEIVE_DATA of this
172 datagram.
173
174 @return The times this datagram is enqueued.
175
176**/
177UINTN
178Udp4EnqueueDgram (
179 IN UDP4_SERVICE_DATA *Udp4Service,
180 IN NET_BUF *Packet,
181 IN EFI_UDP4_RECEIVE_DATA *RxData
182 );
183
184/**
185 This function delivers the datagrams enqueued in the instances.
186
187 @param[in] Udp4Service Pointer to the udp service context data.
188
189**/
190VOID
191Udp4DeliverDgram (
192 IN UDP4_SERVICE_DATA *Udp4Service
193 );
194
195/**
196 This function demultiplexes the received udp datagram to the appropriate instances.
197
198 @param[in] Udp4Service Pointer to the udp service context data.
199 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA abstracted from
200 the received datagram.
201 @param[in] Packet Pointer to the buffer containing the received udp
202 datagram.
203
204**/
205VOID
206Udp4Demultiplex (
207 IN UDP4_SERVICE_DATA *Udp4Service,
208 IN EFI_NET_SESSION_DATA *NetSession,
209 IN NET_BUF *Packet
210 );
211
212/**
213 This function handles the received Icmp Error message and demultiplexes it to the
214 instance.
215
216 @param[in] Udp4Service Pointer to the udp service context data.
217 @param[in] IcmpError The icmp error code.
218 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA abstracted
219 from the received Icmp Error packet.
220 @param[in] Packet Pointer to the Icmp Error packet.
221
222**/
223VOID
224Udp4IcmpHandler (
225 IN UDP4_SERVICE_DATA *Udp4Service,
226 IN UINT8 IcmpError,
227 IN EFI_NET_SESSION_DATA *NetSession,
228 IN NET_BUF *Packet
229 );
230
231/**
232 This function builds and sends out a icmp port unreachable message.
233
234 @param[in] IpIo Pointer to the IP_IO instance.
235 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA of the packet
236 causes this icmp error message.
237 @param[in] Udp4Header Pointer to the udp header of the datagram causes
238 this icmp error message.
239
240**/
241VOID
242Udp4SendPortUnreach (
243 IN IP_IO *IpIo,
244 IN EFI_NET_SESSION_DATA *NetSession,
245 IN VOID *Udp4Header
246 );
247
248/**
249 Create the Udp service context data.
250
251 @param[in, out] Udp4Service Pointer to the UDP4_SERVICE_DATA.
252 @param[in] ImageHandle The image handle of this udp4 driver.
253 @param[in] ControllerHandle The controller handle this udp4 driver binds on.
254
255 @retval EFI_SUCCESS The udp4 service context data is created and
256 initialized.
257 @retval EFI_OUT_OF_RESOURCES Cannot allocate memory.
258 @retval other Other error occurs.
259
260**/
261EFI_STATUS
262Udp4CreateService (
263 IN OUT UDP4_SERVICE_DATA *Udp4Service,
264 IN EFI_HANDLE ImageHandle,
265 IN EFI_HANDLE ControllerHandle
266 )
267{
268 EFI_STATUS Status;
269 IP_IO_OPEN_DATA OpenData;
270 EFI_IP4_CONFIG_DATA *Ip4ConfigData;
271
272 ZeroMem (Udp4Service, sizeof (UDP4_SERVICE_DATA));
273
274 Udp4Service->Signature = UDP4_SERVICE_DATA_SIGNATURE;
275 Udp4Service->ServiceBinding = mUdp4ServiceBinding;
276 Udp4Service->ImageHandle = ImageHandle;
277 Udp4Service->ControllerHandle = ControllerHandle;
278 Udp4Service->ChildrenNumber = 0;
279
280 InitializeListHead (&Udp4Service->ChildrenList);
281
282 //
283 // Create the IpIo for this service context.
284 //
285 Udp4Service->IpIo = IpIoCreate (ImageHandle, ControllerHandle, IP_VERSION_4);
286 if (Udp4Service->IpIo == NULL) {
287 return EFI_OUT_OF_RESOURCES;
288 }
289
290 //
291 // Set the OpenData used to open the IpIo.
292 //
293 Ip4ConfigData = &OpenData.IpConfigData.Ip4CfgData;
294 CopyMem (Ip4ConfigData, &mIp4IoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA));
295 Ip4ConfigData->AcceptBroadcast = TRUE;
296 OpenData.RcvdContext = (VOID *)Udp4Service;
297 OpenData.SndContext = NULL;
298 OpenData.PktRcvdNotify = Udp4DgramRcvd;
299 OpenData.PktSentNotify = Udp4DgramSent;
300
301 //
302 // Configure and start the IpIo.
303 //
304 Status = IpIoOpen (Udp4Service->IpIo, &OpenData);
305 if (EFI_ERROR (Status)) {
306 goto ON_ERROR;
307 }
308
309 //
310 // Create the event for Udp timeout checking.
311 //
312 Status = gBS->CreateEvent (
313 EVT_TIMER | EVT_NOTIFY_SIGNAL,
314 TPL_CALLBACK,
315 Udp4CheckTimeout,
316 Udp4Service,
317 &Udp4Service->TimeoutEvent
318 );
319 if (EFI_ERROR (Status)) {
320 goto ON_ERROR;
321 }
322
323 //
324 // Start the timeout timer event.
325 //
326 Status = gBS->SetTimer (
327 Udp4Service->TimeoutEvent,
328 TimerPeriodic,
329 UDP4_TIMEOUT_INTERVAL
330 );
331 if (EFI_ERROR (Status)) {
332 goto ON_ERROR;
333 }
334
335 return EFI_SUCCESS;
336
337ON_ERROR:
338
339 if (Udp4Service->TimeoutEvent != NULL) {
340 gBS->CloseEvent (Udp4Service->TimeoutEvent);
341 }
342
343 IpIoDestroy (Udp4Service->IpIo);
344
345 return Status;
346}
347
348/**
349 Clean the Udp service context data.
350
351 @param[in] Udp4Service Pointer to the UDP4_SERVICE_DATA.
352
353**/
354VOID
355Udp4CleanService (
356 IN UDP4_SERVICE_DATA *Udp4Service
357 )
358{
359 //
360 // Cancel the TimeoutEvent timer.
361 //
362 gBS->SetTimer (Udp4Service->TimeoutEvent, TimerCancel, 0);
363
364 //
365 // Close the TimeoutEvent timer.
366 //
367 gBS->CloseEvent (Udp4Service->TimeoutEvent);
368
369 //
370 // Destroy the IpIo.
371 //
372 IpIoDestroy (Udp4Service->IpIo);
373}
374
375/**
376 This function checks and timeouts the I/O datagrams holding by the corresponding
377 service context.
378
379 @param[in] Event The event this function registered to.
380 @param[in] Context The context data registered during the creation of
381 the Event.
382
383**/
384VOID
385EFIAPI
386Udp4CheckTimeout (
387 IN EFI_EVENT Event,
388 IN VOID *Context
389 )
390{
391 UDP4_SERVICE_DATA *Udp4Service;
392 LIST_ENTRY *Entry;
393 UDP4_INSTANCE_DATA *Instance;
394 LIST_ENTRY *WrapEntry;
395 LIST_ENTRY *NextEntry;
396 UDP4_RXDATA_WRAP *Wrap;
397
398 Udp4Service = (UDP4_SERVICE_DATA *)Context;
399 NET_CHECK_SIGNATURE (Udp4Service, UDP4_SERVICE_DATA_SIGNATURE);
400
401 NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
402 //
403 // Iterate all the instances belonging to this service context.
404 //
405 Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
406 NET_CHECK_SIGNATURE (Instance, UDP4_INSTANCE_DATA_SIGNATURE);
407
408 if (!Instance->Configured || (Instance->ConfigData.ReceiveTimeout == 0)) {
409 //
410 // Skip this instance if it's not configured or no receive timeout.
411 //
412 continue;
413 }
414
415 NET_LIST_FOR_EACH_SAFE (WrapEntry, NextEntry, &Instance->RcvdDgramQue) {
416 //
417 // Iterate all the rxdatas belonging to this udp instance.
418 //
419 Wrap = NET_LIST_USER_STRUCT (WrapEntry, UDP4_RXDATA_WRAP, Link);
420
421 //
422 // TimeoutTick unit is microsecond, MNP_TIMEOUT_CHECK_INTERVAL unit is 100ns.
423 //
424 if (Wrap->TimeoutTick < (UDP4_TIMEOUT_INTERVAL / 10)) {
425 //
426 // Remove this RxData if it timeouts.
427 //
428 Udp4RecycleRxDataWrap (NULL, (VOID *)Wrap);
429 } else {
430 Wrap->TimeoutTick -= (UDP4_TIMEOUT_INTERVAL / 10);
431 }
432 }
433 }
434}
435
436/**
437 This function initializes the new created udp instance.
438
439 @param[in] Udp4Service Pointer to the UDP4_SERVICE_DATA.
440 @param[in, out] Instance Pointer to the un-initialized UDP4_INSTANCE_DATA.
441
442**/
443VOID
444Udp4InitInstance (
445 IN UDP4_SERVICE_DATA *Udp4Service,
446 IN OUT UDP4_INSTANCE_DATA *Instance
447 )
448{
449 //
450 // Set the signature.
451 //
452 Instance->Signature = UDP4_INSTANCE_DATA_SIGNATURE;
453
454 //
455 // Init the lists.
456 //
457 InitializeListHead (&Instance->Link);
458 InitializeListHead (&Instance->RcvdDgramQue);
459 InitializeListHead (&Instance->DeliveredDgramQue);
460
461 //
462 // Init the NET_MAPs.
463 //
464 NetMapInit (&Instance->TxTokens);
465 NetMapInit (&Instance->RxTokens);
466 NetMapInit (&Instance->McastIps);
467
468 //
469 // Save the pointer to the UDP4_SERVICE_DATA, and initialize other members.
470 //
471 Instance->Udp4Service = Udp4Service;
472 CopyMem (&Instance->Udp4Proto, &mUdp4Protocol, sizeof (Instance->Udp4Proto));
473 Instance->IcmpError = EFI_SUCCESS;
474 Instance->Configured = FALSE;
475 Instance->IsNoMapping = FALSE;
476 Instance->InDestroy = FALSE;
477}
478
479/**
480 This function cleans the udp instance.
481
482 @param[in] Instance Pointer to the UDP4_INSTANCE_DATA to clean.
483
484**/
485VOID
486Udp4CleanInstance (
487 IN UDP4_INSTANCE_DATA *Instance
488 )
489{
490 NetMapClean (&Instance->McastIps);
491 NetMapClean (&Instance->RxTokens);
492 NetMapClean (&Instance->TxTokens);
493}
494
495/**
496 This function finds the udp instance by the specified <Address, Port> pair.
497
498 @param[in] InstanceList Pointer to the head of the list linking the udp
499 instances.
500 @param[in] Address Pointer to the specified IPv4 address.
501 @param[in] Port The udp port number.
502
503 @retval TRUE The specified <Address, Port> pair is found.
504 @retval FALSE Otherwise.
505
506**/
507BOOLEAN
508Udp4FindInstanceByPort (
509 IN LIST_ENTRY *InstanceList,
510 IN EFI_IPv4_ADDRESS *Address,
511 IN UINT16 Port
512 )
513{
514 LIST_ENTRY *Entry;
515 UDP4_INSTANCE_DATA *Instance;
516 EFI_UDP4_CONFIG_DATA *ConfigData;
517
518 NET_LIST_FOR_EACH (Entry, InstanceList) {
519 //
520 // Iterate all the udp instances.
521 //
522 Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
523 ConfigData = &Instance->ConfigData;
524
525 if (!Instance->Configured || ConfigData->AcceptAnyPort) {
526 //
527 // If the instance is not configured or the configdata of the instance indicates
528 // this instance accepts any port, skip it.
529 //
530 continue;
531 }
532
533 if (EFI_IP4_EQUAL (&ConfigData->StationAddress, Address) &&
534 (ConfigData->StationPort == Port))
535 {
536 //
537 // if both the address and the port are the same, return TRUE.
538 //
539 return TRUE;
540 }
541 }
542
543 //
544 // return FALSE when matching fails.
545 //
546 return FALSE;
547}
548
549/**
550 This function tries to bind the udp instance according to the configured port
551 allocation strategy.
552
553 @param[in] InstanceList Pointer to the head of the list linking the udp
554 instances.
555 @param[in, out] ConfigData Pointer to the ConfigData of the instance to be
556 bound. ConfigData->StationPort will be assigned
557 with an available port value on success.
558
559 @retval EFI_SUCCESS The bound operation is completed successfully.
560 @retval EFI_ACCESS_DENIED The <Address, Port> specified by the ConfigData is
561 already used by other instance.
562 @retval EFI_OUT_OF_RESOURCES No available port resources.
563
564**/
565EFI_STATUS
566Udp4Bind (
567 IN LIST_ENTRY *InstanceList,
568 IN OUT EFI_UDP4_CONFIG_DATA *ConfigData
569 )
570{
571 EFI_IPv4_ADDRESS *StationAddress;
572 UINT16 StartPort;
573
574 if (ConfigData->AcceptAnyPort) {
575 return EFI_SUCCESS;
576 }
577
578 StationAddress = &ConfigData->StationAddress;
579
580 if (ConfigData->StationPort != 0) {
581 if (!ConfigData->AllowDuplicatePort &&
582 Udp4FindInstanceByPort (InstanceList, StationAddress, ConfigData->StationPort))
583 {
584 //
585 // Do not allow duplicate port and the port is already used by other instance.
586 //
587 return EFI_ACCESS_DENIED;
588 }
589 } else {
590 //
591 // select a random port for this instance;
592 //
593
594 if (ConfigData->AllowDuplicatePort) {
595 //
596 // Just pick up the random port if the instance allows duplicate port.
597 //
598 ConfigData->StationPort = mUdp4RandomPort;
599 } else {
600 StartPort = mUdp4RandomPort;
601
602 while (Udp4FindInstanceByPort (InstanceList, StationAddress, mUdp4RandomPort)) {
603 mUdp4RandomPort++;
604 if (mUdp4RandomPort == 0) {
605 mUdp4RandomPort = UDP4_PORT_KNOWN;
606 }
607
608 if (mUdp4RandomPort == StartPort) {
609 //
610 // No available port.
611 //
612 return EFI_OUT_OF_RESOURCES;
613 }
614 }
615
616 ConfigData->StationPort = mUdp4RandomPort;
617 }
618
619 mUdp4RandomPort++;
620 if (mUdp4RandomPort == 0) {
621 mUdp4RandomPort = UDP4_PORT_KNOWN;
622 }
623 }
624
625 return EFI_SUCCESS;
626}
627
628/**
629 This function is used to check whether the NewConfigData has any un-reconfigurable
630 parameters changed compared to the OldConfigData.
631
632 @param[in] OldConfigData Pointer to the current ConfigData the udp instance
633 uses.
634 @param[in] NewConfigData Pointer to the new ConfigData.
635
636 @retval TRUE The instance is reconfigurable.
637 @retval FALSE Otherwise.
638
639**/
640BOOLEAN
641Udp4IsReconfigurable (
642 IN EFI_UDP4_CONFIG_DATA *OldConfigData,
643 IN EFI_UDP4_CONFIG_DATA *NewConfigData
644 )
645{
646 if ((NewConfigData->AcceptAnyPort != OldConfigData->AcceptAnyPort) ||
647 (NewConfigData->AcceptBroadcast != OldConfigData->AcceptBroadcast) ||
648 (NewConfigData->AcceptPromiscuous != OldConfigData->AcceptPromiscuous) ||
649 (NewConfigData->AllowDuplicatePort != OldConfigData->AllowDuplicatePort)
650 )
651 {
652 //
653 // The receiving filter parameters cannot be changed.
654 //
655 return FALSE;
656 }
657
658 if ((!NewConfigData->AcceptAnyPort) &&
659 (NewConfigData->StationPort != OldConfigData->StationPort)
660 )
661 {
662 //
663 // The port is not changeable.
664 //
665 return FALSE;
666 }
667
668 if (!NewConfigData->AcceptPromiscuous) {
669 if (NewConfigData->UseDefaultAddress != OldConfigData->UseDefaultAddress) {
670 //
671 // The NewConfigData differs to the old one on the UseDefaultAddress.
672 //
673 return FALSE;
674 }
675
676 if (!NewConfigData->UseDefaultAddress &&
677 (!EFI_IP4_EQUAL (&NewConfigData->StationAddress, &OldConfigData->StationAddress) ||
678 !EFI_IP4_EQUAL (&NewConfigData->SubnetMask, &OldConfigData->SubnetMask))
679 )
680 {
681 //
682 // If the instance doesn't use the default address, and the new address or
683 // new subnet mask is different from the old values.
684 //
685 return FALSE;
686 }
687 }
688
689 if (!EFI_IP4_EQUAL (&NewConfigData->RemoteAddress, &OldConfigData->RemoteAddress)) {
690 //
691 // The remoteaddress is not the same.
692 //
693 return FALSE;
694 }
695
696 if (!EFI_IP4_EQUAL (&NewConfigData->RemoteAddress, &mZeroIp4Addr) &&
697 (NewConfigData->RemotePort != OldConfigData->RemotePort)
698 )
699 {
700 //
701 // The RemotePort differs if it's designated in the configdata.
702 //
703 return FALSE;
704 }
705
706 //
707 // All checks pass, return TRUE.
708 //
709 return TRUE;
710}
711
712/**
713 This function builds the Ip4 configdata from the Udp4ConfigData.
714
715 @param[in] Udp4ConfigData Pointer to the EFI_UDP4_CONFIG_DATA.
716 @param[in, out] Ip4ConfigData Pointer to the EFI_IP4_CONFIG_DATA.
717
718**/
719VOID
720Udp4BuildIp4ConfigData (
721 IN EFI_UDP4_CONFIG_DATA *Udp4ConfigData,
722 IN OUT EFI_IP4_CONFIG_DATA *Ip4ConfigData
723 )
724{
725 CopyMem (Ip4ConfigData, &mIp4IoDefaultIpConfigData, sizeof (*Ip4ConfigData));
726
727 Ip4ConfigData->DefaultProtocol = EFI_IP_PROTO_UDP;
728 Ip4ConfigData->AcceptBroadcast = Udp4ConfigData->AcceptBroadcast;
729 Ip4ConfigData->AcceptPromiscuous = Udp4ConfigData->AcceptPromiscuous;
730 Ip4ConfigData->UseDefaultAddress = Udp4ConfigData->UseDefaultAddress;
731 CopyMem (&Ip4ConfigData->StationAddress, &Udp4ConfigData->StationAddress, sizeof (EFI_IPv4_ADDRESS));
732 CopyMem (&Ip4ConfigData->SubnetMask, &Udp4ConfigData->SubnetMask, sizeof (EFI_IPv4_ADDRESS));
733
734 //
735 // use the -1 magic number to disable the receiving process of the ip instance.
736 //
737 Ip4ConfigData->ReceiveTimeout = (UINT32)(-1);
738}
739
740/**
741 This function validates the TxToken, it returns the error code according to the spec.
742
743 @param[in] Instance Pointer to the udp instance context data.
744 @param[in] TxToken Pointer to the token to be checked.
745
746 @retval EFI_SUCCESS The TxToken is valid.
747 @retval EFI_INVALID_PARAMETER One or more of the following are TRUE: This is
748 NULL. Token is NULL. Token.Event is NULL.
749 Token.Packet.TxData is NULL.
750 Token.Packet.TxData.FragmentCount is zero.
751 Token.Packet.TxData.DataLength is not equal to the
752 sum of fragment lengths. One or more of the
753 Token.Packet.TxData.FragmentTable[].
754 FragmentLength fields is zero. One or more of the
755 Token.Packet.TxData.FragmentTable[].
756 FragmentBuffer fields is NULL.
757 Token.Packet.TxData. GatewayAddress is not a
758 unicast IPv4 address if it is not NULL. One or
759 more IPv4 addresses in Token.Packet.TxData.
760 UdpSessionData are not valid unicast IPv4
761 addresses if the UdpSessionData is not NULL.
762 @retval EFI_BAD_BUFFER_SIZE The data length is greater than the maximum UDP
763 packet size.
764
765**/
766EFI_STATUS
767Udp4ValidateTxToken (
768 IN UDP4_INSTANCE_DATA *Instance,
769 IN EFI_UDP4_COMPLETION_TOKEN *TxToken
770 )
771{
772 EFI_UDP4_TRANSMIT_DATA *TxData;
773 UINT32 Index;
774 UINT32 TotalLen;
775 EFI_UDP4_CONFIG_DATA *ConfigData;
776 EFI_UDP4_SESSION_DATA *UdpSessionData;
777 IP4_ADDR SourceAddress;
778 IP4_ADDR GatewayAddress;
779
780 if (TxToken->Event == NULL) {
781 return EFI_INVALID_PARAMETER;
782 }
783
784 TxData = TxToken->Packet.TxData;
785
786 if ((TxData == NULL) || (TxData->FragmentCount == 0)) {
787 return EFI_INVALID_PARAMETER;
788 }
789
790 TotalLen = 0;
791 for (Index = 0; Index < TxData->FragmentCount; Index++) {
792 if ((TxData->FragmentTable[Index].FragmentBuffer == NULL) ||
793 (TxData->FragmentTable[Index].FragmentLength == 0))
794 {
795 //
796 // if the FragmentBuffer is NULL or the FragmentLeng is zero.
797 //
798 return EFI_INVALID_PARAMETER;
799 }
800
801 TotalLen += TxData->FragmentTable[Index].FragmentLength;
802 }
803
804 if (TotalLen != TxData->DataLength) {
805 //
806 // The TotalLen calculated by adding all the FragmentLeng doesn't equal to the
807 // DataLength.
808 //
809 return EFI_INVALID_PARAMETER;
810 }
811
812 if (TxData->GatewayAddress != NULL) {
813 CopyMem (&GatewayAddress, TxData->GatewayAddress, sizeof (IP4_ADDR));
814
815 if (!Instance->ConfigData.UseDefaultAddress &&
816 (EFI_NTOHL (Instance->ConfigData.SubnetMask) != 0) &&
817 !NetIp4IsUnicast (NTOHL (GatewayAddress), EFI_NTOHL (Instance->ConfigData.SubnetMask)))
818 {
819 //
820 // The specified GatewayAddress is not a unicast IPv4 address while it's not 0.
821 //
822 return EFI_INVALID_PARAMETER;
823 }
824 }
825
826 ConfigData = &Instance->ConfigData;
827 UdpSessionData = TxData->UdpSessionData;
828
829 if (UdpSessionData != NULL) {
830 CopyMem (&SourceAddress, &UdpSessionData->SourceAddress, sizeof (IP4_ADDR));
831
832 if ((SourceAddress != 0) &&
833 !Instance->ConfigData.UseDefaultAddress &&
834 (EFI_NTOHL (Instance->ConfigData.SubnetMask) != 0) &&
835 !NetIp4IsUnicast (HTONL (SourceAddress), EFI_NTOHL (Instance->ConfigData.SubnetMask)))
836 {
837 //
838 // Check whether SourceAddress is a valid IPv4 address in case it's not zero.
839 // The configured station address is used if SourceAddress is zero.
840 //
841 return EFI_INVALID_PARAMETER;
842 }
843
844 if ((UdpSessionData->DestinationPort == 0) && (ConfigData->RemotePort == 0)) {
845 //
846 // Ambiguous, no available DestinationPort for this token.
847 //
848 return EFI_INVALID_PARAMETER;
849 }
850
851 if (EFI_IP4_EQUAL (&UdpSessionData->DestinationAddress, &mZeroIp4Addr)) {
852 //
853 // The DestinationAddress specified in the UdpSessionData is 0.
854 //
855 return EFI_INVALID_PARAMETER;
856 }
857 } else if (EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &mZeroIp4Addr)) {
858 //
859 // the configured RemoteAddress is all zero, and the user doesn't override the
860 // destination address.
861 //
862 return EFI_INVALID_PARAMETER;
863 }
864
865 if (TxData->DataLength > UDP4_MAX_DATA_SIZE) {
866 return EFI_BAD_BUFFER_SIZE;
867 }
868
869 return EFI_SUCCESS;
870}
871
872/**
873 This function checks whether the specified Token duplicates with the one in the Map.
874
875 @param[in] Map Pointer to the NET_MAP.
876 @param[in] Item Pointer to the NET_MAP_ITEM contain the pointer to
877 the Token.
878 @param[in] Context Pointer to the Token to be checked.
879
880 @retval EFI_SUCCESS The Token specified by Context differs from the
881 one in the Item.
882 @retval EFI_ACCESS_DENIED The Token duplicates with the one in the Item.
883
884**/
885EFI_STATUS
886EFIAPI
887Udp4TokenExist (
888 IN NET_MAP *Map,
889 IN NET_MAP_ITEM *Item,
890 IN VOID *Context
891 )
892{
893 EFI_UDP4_COMPLETION_TOKEN *Token;
894 EFI_UDP4_COMPLETION_TOKEN *TokenInItem;
895
896 Token = (EFI_UDP4_COMPLETION_TOKEN *)Context;
897 TokenInItem = (EFI_UDP4_COMPLETION_TOKEN *)Item->Key;
898
899 if ((Token == TokenInItem) || (Token->Event == TokenInItem->Event)) {
900 //
901 // The Token duplicates with the TokenInItem in case either the two pointers are the
902 // same or the Events of these two tokens are the same.
903 //
904 return EFI_ACCESS_DENIED;
905 }
906
907 return EFI_SUCCESS;
908}
909
910/**
911 This function calculates the checksum for the Packet, utilizing the pre-calculated
912 pseudo HeadSum to reduce some overhead.
913
914 @param[in] Packet Pointer to the NET_BUF contains the udp datagram.
915 @param[in] HeadSum Checksum of the pseudo header except the length
916 field.
917
918 @retval The 16-bit checksum of this udp datagram.
919
920**/
921UINT16
922Udp4Checksum (
923 IN NET_BUF *Packet,
924 IN UINT16 HeadSum
925 )
926{
927 UINT16 Checksum;
928
929 Checksum = NetbufChecksum (Packet);
930 Checksum = NetAddChecksum (Checksum, HeadSum);
931
932 Checksum = NetAddChecksum (Checksum, HTONS ((UINT16)Packet->TotalSize));
933
934 return (UINT16) ~Checksum;
935}
936
937/**
938 This function removes the specified Token from the TokenMap.
939
940 @param[in, out] TokenMap Pointer to the NET_MAP containing the tokens.
941 @param[in] Token Pointer to the Token to be removed.
942
943 @retval EFI_SUCCESS The specified Token is removed from the TokenMap.
944 @retval EFI_NOT_FOUND The specified Token is not found in the TokenMap.
945
946**/
947EFI_STATUS
948Udp4RemoveToken (
949 IN OUT NET_MAP *TokenMap,
950 IN EFI_UDP4_COMPLETION_TOKEN *Token
951 )
952{
953 NET_MAP_ITEM *Item;
954
955 //
956 // Find the Token first.
957 //
958 Item = NetMapFindKey (TokenMap, (VOID *)Token);
959
960 if (Item != NULL) {
961 //
962 // Remove the token if it's found in the map.
963 //
964 NetMapRemoveItem (TokenMap, Item, NULL);
965
966 return EFI_SUCCESS;
967 }
968
969 return EFI_NOT_FOUND;
970}
971
972/**
973 This function is the packet transmitting notify function registered to the IpIo
974 interface. It's called to signal the udp TxToken when IpIo layer completes the
975 transmitting of the udp datagram.
976
977 @param[in] Status The completion status of the output udp datagram.
978 @param[in] Context Pointer to the context data.
979 @param[in] Sender Specify a pointer of EFI_IP4_PROTOCOL for sending.
980 @param[in] NotifyData Pointer to the notify data.
981
982**/
983VOID
984EFIAPI
985Udp4DgramSent (
986 IN EFI_STATUS Status,
987 IN VOID *Context,
988 IN IP_IO_IP_PROTOCOL Sender,
989 IN VOID *NotifyData
990 )
991{
992 UDP4_INSTANCE_DATA *Instance;
993 EFI_UDP4_COMPLETION_TOKEN *Token;
994
995 Instance = (UDP4_INSTANCE_DATA *)Context;
996 Token = (EFI_UDP4_COMPLETION_TOKEN *)NotifyData;
997
998 if (Udp4RemoveToken (&Instance->TxTokens, Token) == EFI_SUCCESS) {
999 //
1000 // The token may be cancelled. Only signal it if the remove operation succeeds.
1001 //
1002 Token->Status = Status;
1003 gBS->SignalEvent (Token->Event);
1004 DispatchDpc ();
1005 }
1006}
1007
1008/**
1009 This function processes the received datagram passed up by the IpIo layer.
1010
1011 @param[in] Status The status of this udp datagram.
1012 @param[in] IcmpError The IcmpError code, only available when Status is
1013 EFI_ICMP_ERROR.
1014 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA.
1015 @param[in] Packet Pointer to the NET_BUF containing the received udp
1016 datagram.
1017 @param[in] Context Pointer to the context data.
1018
1019**/
1020VOID
1021EFIAPI
1022Udp4DgramRcvd (
1023 IN EFI_STATUS Status,
1024 IN UINT8 IcmpError,
1025 IN EFI_NET_SESSION_DATA *NetSession,
1026 IN NET_BUF *Packet,
1027 IN VOID *Context
1028 )
1029{
1030 NET_CHECK_SIGNATURE (Packet, NET_BUF_SIGNATURE);
1031
1032 //
1033 // IpIo only passes received packets with Status EFI_SUCCESS or EFI_ICMP_ERROR.
1034 //
1035 if (Status == EFI_SUCCESS) {
1036 //
1037 // Demultiplex the received datagram.
1038 //
1039 Udp4Demultiplex ((UDP4_SERVICE_DATA *)Context, NetSession, Packet);
1040 } else {
1041 //
1042 // Handle the ICMP_ERROR packet.
1043 //
1044 Udp4IcmpHandler ((UDP4_SERVICE_DATA *)Context, IcmpError, NetSession, Packet);
1045 }
1046
1047 //
1048 // Dispatch the DPC queued by the NotifyFunction of the rx token's events
1049 // which are signaled with received data.
1050 //
1051 DispatchDpc ();
1052}
1053
1054/**
1055 This function removes the multicast group specified by Arg from the Map.
1056
1057 @param[in, out] Map Pointer to the NET_MAP.
1058 @param[in] Item Pointer to the NET_MAP_ITEM.
1059 @param[in] Arg Pointer to the Arg, it's the pointer to a
1060 multicast IPv4 Address.
1061
1062 @retval EFI_SUCCESS The multicast address is removed.
1063 @retval EFI_ABORTED The specified multicast address is removed and the
1064 Arg is not NULL.
1065
1066**/
1067EFI_STATUS
1068EFIAPI
1069Udp4LeaveGroup (
1070 IN OUT NET_MAP *Map,
1071 IN NET_MAP_ITEM *Item,
1072 IN VOID *Arg OPTIONAL
1073 )
1074{
1075 EFI_IPv4_ADDRESS *McastIp;
1076
1077 McastIp = Arg;
1078
1079 if ((McastIp != NULL) && (!EFI_IP4_EQUAL (McastIp, &(Item->Key)))) {
1080 //
1081 // McastIp is not NULL and the multicast address contained in the Item
1082 // is not the same as McastIp.
1083 //
1084 return EFI_SUCCESS;
1085 }
1086
1087 //
1088 // Remove this Item.
1089 //
1090 NetMapRemoveItem (Map, Item, NULL);
1091
1092 if (McastIp != NULL) {
1093 //
1094 // Return EFI_ABORTED in case McastIp is not NULL to terminate the iteration.
1095 //
1096 return EFI_ABORTED;
1097 }
1098
1099 return EFI_SUCCESS;
1100}
1101
1102/**
1103 This function cancels the token specified by Arg in the Map. This is a callback
1104 used by Udp4InstanceCancelToken().
1105
1106 @param[in] Map Pointer to the NET_MAP.
1107 @param[in] Item Pointer to the NET_MAP_ITEM.
1108 @param[in] Arg Pointer to the token to be cancelled, if NULL,
1109 the token specified by Item is cancelled.
1110
1111 @retval EFI_SUCCESS The token is cancelled if Arg is NULL or the token
1112 is not the same as that in the Item if Arg is not
1113 NULL.
1114 @retval EFI_ABORTED Arg is not NULL, and the token specified by Arg is
1115 cancelled.
1116
1117**/
1118EFI_STATUS
1119EFIAPI
1120Udp4CancelTokens (
1121 IN NET_MAP *Map,
1122 IN NET_MAP_ITEM *Item,
1123 IN VOID *Arg OPTIONAL
1124 )
1125{
1126 EFI_UDP4_COMPLETION_TOKEN *TokenToCancel;
1127 NET_BUF *Packet;
1128 IP_IO *IpIo;
1129
1130 if ((Arg != NULL) && (Item->Key != Arg)) {
1131 return EFI_SUCCESS;
1132 }
1133
1134 if (Item->Value != NULL) {
1135 //
1136 // If the token is a transmit token, the corresponding Packet is recorded in
1137 // Item->Value, invoke IpIo to cancel this packet first. The IpIoCancelTxToken
1138 // will invoke Udp4DgramSent, the token will be signaled and this Item will
1139 // be removed from the Map there.
1140 //
1141 Packet = (NET_BUF *)(Item->Value);
1142 IpIo = (IP_IO *)(*((UINTN *)&Packet->ProtoData[0]));
1143
1144 IpIoCancelTxToken (IpIo, Packet);
1145 } else {
1146 //
1147 // The token is a receive token. Abort it and remove it from the Map.
1148 //
1149 TokenToCancel = (EFI_UDP4_COMPLETION_TOKEN *)Item->Key;
1150 NetMapRemoveItem (Map, Item, NULL);
1151
1152 TokenToCancel->Status = EFI_ABORTED;
1153 gBS->SignalEvent (TokenToCancel->Event);
1154 }
1155
1156 if (Arg != NULL) {
1157 return EFI_ABORTED;
1158 }
1159
1160 return EFI_SUCCESS;
1161}
1162
1163/**
1164 This function removes all the Wrap datas in the RcvdDgramQue.
1165
1166 @param[in] Instance Pointer to the udp instance context data.
1167
1168**/
1169VOID
1170Udp4FlushRcvdDgram (
1171 IN UDP4_INSTANCE_DATA *Instance
1172 )
1173{
1174 UDP4_RXDATA_WRAP *Wrap;
1175
1176 while (!IsListEmpty (&Instance->RcvdDgramQue)) {
1177 //
1178 // Iterate all the Wraps in the RcvdDgramQue.
1179 //
1180 Wrap = NET_LIST_HEAD (&Instance->RcvdDgramQue, UDP4_RXDATA_WRAP, Link);
1181
1182 //
1183 // The Wrap will be removed from the RcvdDgramQue by this function call.
1184 //
1185 Udp4RecycleRxDataWrap (NULL, (VOID *)Wrap);
1186 }
1187}
1188
1189/**
1190 Cancel Udp4 tokens from the Udp4 instance.
1191
1192 @param[in] Instance Pointer to the udp instance context data.
1193 @param[in] Token Pointer to the token to be canceled, if NULL, all
1194 tokens in this instance will be cancelled.
1195
1196 @retval EFI_SUCCESS The Token is cancelled.
1197 @retval EFI_NOT_FOUND The Token is not found.
1198
1199**/
1200EFI_STATUS
1201Udp4InstanceCancelToken (
1202 IN UDP4_INSTANCE_DATA *Instance,
1203 IN EFI_UDP4_COMPLETION_TOKEN *Token OPTIONAL
1204 )
1205{
1206 EFI_STATUS Status;
1207
1208 //
1209 // Cancel this token from the TxTokens map.
1210 //
1211 Status = NetMapIterate (&Instance->TxTokens, Udp4CancelTokens, Token);
1212
1213 if ((Token != NULL) && (Status == EFI_ABORTED)) {
1214 //
1215 // If Token isn't NULL and Status is EFI_ABORTED, the token is cancelled from
1216 // the TxTokens, just return success.
1217 //
1218 return EFI_SUCCESS;
1219 }
1220
1221 //
1222 // Try to cancel this token from the RxTokens map in condition either the Token
1223 // is NULL or the specified Token is not in TxTokens.
1224 //
1225 Status = NetMapIterate (&Instance->RxTokens, Udp4CancelTokens, Token);
1226
1227 if ((Token != NULL) && (Status == EFI_SUCCESS)) {
1228 //
1229 // If Token isn't NULL and Status is EFI_SUCCESS, the token is neither in the
1230 // TxTokens nor the RxTokens, or say, it's not found.
1231 //
1232 return EFI_NOT_FOUND;
1233 }
1234
1235 ASSERT (
1236 (Token != NULL) || ( (0 == NetMapGetCount (&Instance->TxTokens))
1237 && (0 == NetMapGetCount (&Instance->RxTokens)))
1238 );
1239
1240 return EFI_SUCCESS;
1241}
1242
1243/**
1244 This function matches the received udp datagram with the Instance.
1245
1246 @param[in] Instance Pointer to the udp instance context data.
1247 @param[in] Udp4Session Pointer to the EFI_UDP4_SESSION_DATA abstracted
1248 from the received udp datagram.
1249
1250 @retval TRUE The udp datagram matches the receiving requirements of the
1251 udp Instance.
1252 @retval FALSE Otherwise.
1253
1254**/
1255BOOLEAN
1256Udp4MatchDgram (
1257 IN UDP4_INSTANCE_DATA *Instance,
1258 IN EFI_UDP4_SESSION_DATA *Udp4Session
1259 )
1260{
1261 EFI_UDP4_CONFIG_DATA *ConfigData;
1262 IP4_ADDR Destination;
1263
1264 ConfigData = &Instance->ConfigData;
1265
1266 if (ConfigData->AcceptPromiscuous) {
1267 //
1268 // Always matches if this instance is in the promiscuous state.
1269 //
1270 return TRUE;
1271 }
1272
1273 if ((!ConfigData->AcceptAnyPort && (Udp4Session->DestinationPort != ConfigData->StationPort)) ||
1274 ((ConfigData->RemotePort != 0) && (Udp4Session->SourcePort != ConfigData->RemotePort))
1275 )
1276 {
1277 //
1278 // The local port or the remote port doesn't match.
1279 //
1280 return FALSE;
1281 }
1282
1283 if (!EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &mZeroIp4Addr) &&
1284 !EFI_IP4_EQUAL (&ConfigData->RemoteAddress, &Udp4Session->SourceAddress)
1285 )
1286 {
1287 //
1288 // This datagram doesn't come from the instance's specified sender.
1289 //
1290 return FALSE;
1291 }
1292
1293 if (EFI_IP4_EQUAL (&ConfigData->StationAddress, &mZeroIp4Addr) ||
1294 EFI_IP4_EQUAL (&Udp4Session->DestinationAddress, &ConfigData->StationAddress)
1295 )
1296 {
1297 //
1298 // The instance is configured to receive datagrams destined to any station IP or
1299 // the destination address of this datagram matches the configured station IP.
1300 //
1301 return TRUE;
1302 }
1303
1304 CopyMem (&Destination, &Udp4Session->DestinationAddress, sizeof (IP4_ADDR));
1305
1306 if (IP4_IS_LOCAL_BROADCAST (Destination) && ConfigData->AcceptBroadcast) {
1307 //
1308 // The instance is configured to receive broadcast and this is a broadcast packet.
1309 //
1310 return TRUE;
1311 }
1312
1313 if (IP4_IS_MULTICAST (NTOHL (Destination)) &&
1314 (NetMapFindKey (&Instance->McastIps, (VOID *)(UINTN)Destination) != NULL)
1315 )
1316 {
1317 //
1318 // It's a multicast packet and the multicast address is accepted by this instance.
1319 //
1320 return TRUE;
1321 }
1322
1323 return FALSE;
1324}
1325
1326/**
1327 This function removes the Wrap specified by Context and release relevant resources.
1328
1329 @param[in] Event The Event this notify function registered to.
1330 @param[in] Context Pointer to the context data.
1331
1332**/
1333VOID
1334EFIAPI
1335Udp4RecycleRxDataWrap (
1336 IN EFI_EVENT Event,
1337 IN VOID *Context
1338 )
1339{
1340 UDP4_RXDATA_WRAP *Wrap;
1341
1342 Wrap = (UDP4_RXDATA_WRAP *)Context;
1343
1344 //
1345 // Remove the Wrap from the list it belongs to.
1346 //
1347 RemoveEntryList (&Wrap->Link);
1348
1349 //
1350 // Free the Packet associated with this Wrap.
1351 //
1352 NetbufFree (Wrap->Packet);
1353
1354 //
1355 // Close the event.
1356 //
1357 gBS->CloseEvent (Wrap->RxData.RecycleSignal);
1358
1359 FreePool (Wrap);
1360}
1361
1362/**
1363 This function wraps the Packet and the RxData.
1364
1365 @param[in] Instance Pointer to the instance context data.
1366 @param[in] Packet Pointer to the buffer containing the received
1367 datagram.
1368 @param[in] RxData Pointer to the EFI_UDP4_RECEIVE_DATA of this
1369 datagram.
1370
1371 @return Pointer to the structure wrapping the RxData and the Packet.
1372
1373**/
1374UDP4_RXDATA_WRAP *
1375Udp4WrapRxData (
1376 IN UDP4_INSTANCE_DATA *Instance,
1377 IN NET_BUF *Packet,
1378 IN EFI_UDP4_RECEIVE_DATA *RxData
1379 )
1380{
1381 EFI_STATUS Status;
1382 UDP4_RXDATA_WRAP *Wrap;
1383
1384 //
1385 // Allocate buffer for the Wrap.
1386 //
1387 Wrap = AllocatePool (
1388 sizeof (UDP4_RXDATA_WRAP) +
1389 (Packet->BlockOpNum - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA)
1390 );
1391 if (Wrap == NULL) {
1392 return NULL;
1393 }
1394
1395 InitializeListHead (&Wrap->Link);
1396
1397 CopyMem (&Wrap->RxData, RxData, sizeof (Wrap->RxData));
1398
1399 //
1400 // Create the Recycle event.
1401 //
1402 Status = gBS->CreateEvent (
1403 EVT_NOTIFY_SIGNAL,
1404 TPL_NOTIFY,
1405 Udp4RecycleRxDataWrap,
1406 Wrap,
1407 &Wrap->RxData.RecycleSignal
1408 );
1409 if (EFI_ERROR (Status)) {
1410 FreePool (Wrap);
1411 return NULL;
1412 }
1413
1414 Wrap->Packet = Packet;
1415 Wrap->TimeoutTick = Instance->ConfigData.ReceiveTimeout;
1416
1417 return Wrap;
1418}
1419
1420/**
1421 This function enqueues the received datagram into the instances' receiving queues.
1422
1423 @param[in] Udp4Service Pointer to the udp service context data.
1424 @param[in] Packet Pointer to the buffer containing the received
1425 datagram.
1426 @param[in] RxData Pointer to the EFI_UDP4_RECEIVE_DATA of this
1427 datagram.
1428
1429 @return The times this datagram is enqueued.
1430
1431**/
1432UINTN
1433Udp4EnqueueDgram (
1434 IN UDP4_SERVICE_DATA *Udp4Service,
1435 IN NET_BUF *Packet,
1436 IN EFI_UDP4_RECEIVE_DATA *RxData
1437 )
1438{
1439 LIST_ENTRY *Entry;
1440 UDP4_INSTANCE_DATA *Instance;
1441 UDP4_RXDATA_WRAP *Wrap;
1442 UINTN Enqueued;
1443
1444 Enqueued = 0;
1445
1446 NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
1447 //
1448 // Iterate the instances.
1449 //
1450 Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
1451
1452 if (!Instance->Configured) {
1453 continue;
1454 }
1455
1456 if (Udp4MatchDgram (Instance, &RxData->UdpSession)) {
1457 //
1458 // Wrap the RxData and put this Wrap into the instances RcvdDgramQue.
1459 //
1460 Wrap = Udp4WrapRxData (Instance, Packet, RxData);
1461 if (Wrap == NULL) {
1462 continue;
1463 }
1464
1465 NET_GET_REF (Packet);
1466
1467 InsertTailList (&Instance->RcvdDgramQue, &Wrap->Link);
1468
1469 Enqueued++;
1470 }
1471 }
1472
1473 return Enqueued;
1474}
1475
1476/**
1477 This function delivers the received datagrams for the specified instance.
1478
1479 @param[in] Instance Pointer to the instance context data.
1480
1481**/
1482VOID
1483Udp4InstanceDeliverDgram (
1484 IN UDP4_INSTANCE_DATA *Instance
1485 )
1486{
1487 UDP4_RXDATA_WRAP *Wrap;
1488 EFI_UDP4_COMPLETION_TOKEN *Token;
1489 NET_BUF *Dup;
1490 EFI_UDP4_RECEIVE_DATA *RxData;
1491 EFI_TPL OldTpl;
1492
1493 if (!IsListEmpty (&Instance->RcvdDgramQue) &&
1494 !NetMapIsEmpty (&Instance->RxTokens))
1495 {
1496 Wrap = NET_LIST_HEAD (&Instance->RcvdDgramQue, UDP4_RXDATA_WRAP, Link);
1497
1498 if (NET_BUF_SHARED (Wrap->Packet)) {
1499 //
1500 // Duplicate the Packet if it is shared between instances.
1501 //
1502 Dup = NetbufDuplicate (Wrap->Packet, NULL, 0);
1503 if (Dup == NULL) {
1504 return;
1505 }
1506
1507 NetbufFree (Wrap->Packet);
1508
1509 Wrap->Packet = Dup;
1510 }
1511
1512 NetListRemoveHead (&Instance->RcvdDgramQue);
1513
1514 Token = (EFI_UDP4_COMPLETION_TOKEN *)NetMapRemoveHead (&Instance->RxTokens, NULL);
1515
1516 //
1517 // Build the FragmentTable and set the FragmentCount in RxData.
1518 //
1519 RxData = &Wrap->RxData;
1520 RxData->FragmentCount = Wrap->Packet->BlockOpNum;
1521
1522 NetbufBuildExt (
1523 Wrap->Packet,
1524 (NET_FRAGMENT *)RxData->FragmentTable,
1525 &RxData->FragmentCount
1526 );
1527
1528 Token->Status = EFI_SUCCESS;
1529 Token->Packet.RxData = &Wrap->RxData;
1530
1531 OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
1532 InsertTailList (&Instance->DeliveredDgramQue, &Wrap->Link);
1533 gBS->RestoreTPL (OldTpl);
1534
1535 gBS->SignalEvent (Token->Event);
1536 }
1537}
1538
1539/**
1540 This function delivers the datagrams enqueued in the instances.
1541
1542 @param[in] Udp4Service Pointer to the udp service context data.
1543
1544**/
1545VOID
1546Udp4DeliverDgram (
1547 IN UDP4_SERVICE_DATA *Udp4Service
1548 )
1549{
1550 LIST_ENTRY *Entry;
1551 UDP4_INSTANCE_DATA *Instance;
1552
1553 NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
1554 //
1555 // Iterate the instances.
1556 //
1557 Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
1558
1559 if (!Instance->Configured) {
1560 continue;
1561 }
1562
1563 //
1564 // Deliver the datagrams of this instance.
1565 //
1566 Udp4InstanceDeliverDgram (Instance);
1567 }
1568}
1569
1570/**
1571 This function demultiplexes the received udp datagram to the appropriate instances.
1572
1573 @param[in] Udp4Service Pointer to the udp service context data.
1574 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA abstracted from
1575 the received datagram.
1576 @param[in] Packet Pointer to the buffer containing the received udp
1577 datagram.
1578
1579**/
1580VOID
1581Udp4Demultiplex (
1582 IN UDP4_SERVICE_DATA *Udp4Service,
1583 IN EFI_NET_SESSION_DATA *NetSession,
1584 IN NET_BUF *Packet
1585 )
1586{
1587 EFI_UDP_HEADER *Udp4Header;
1588 UINT16 HeadSum;
1589 EFI_UDP4_RECEIVE_DATA RxData;
1590 EFI_UDP4_SESSION_DATA *Udp4Session;
1591 UINTN Enqueued;
1592
1593 if (Packet->TotalSize < sizeof (EFI_UDP_HEADER)) {
1594 NetbufFree (Packet);
1595 return;
1596 }
1597
1598 //
1599 // Get the datagram header from the packet buffer.
1600 //
1601 Udp4Header = (EFI_UDP_HEADER *)NetbufGetByte (Packet, 0, NULL);
1602 ASSERT (Udp4Header != NULL);
1603
1604 if (Udp4Header->Checksum != 0) {
1605 //
1606 // check the checksum.
1607 //
1608 HeadSum = NetPseudoHeadChecksum (
1609 NetSession->Source.Addr[0],
1610 NetSession->Dest.Addr[0],
1611 EFI_IP_PROTO_UDP,
1612 0
1613 );
1614
1615 if (Udp4Checksum (Packet, HeadSum) != 0) {
1616 //
1617 // Wrong checksum.
1618 //
1619 NetbufFree (Packet);
1620 return;
1621 }
1622 }
1623
1624 Udp4Session = &RxData.UdpSession;
1625 Udp4Session->SourcePort = NTOHS (Udp4Header->SrcPort);
1626 Udp4Session->DestinationPort = NTOHS (Udp4Header->DstPort);
1627
1628 CopyMem (&Udp4Session->SourceAddress, &NetSession->Source, sizeof (EFI_IPv4_ADDRESS));
1629 CopyMem (&Udp4Session->DestinationAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
1630
1631 //
1632 // Trim the UDP header.
1633 //
1634 NetbufTrim (Packet, UDP4_HEADER_SIZE, TRUE);
1635
1636 RxData.DataLength = (UINT32)Packet->TotalSize;
1637
1638 //
1639 // Try to enqueue this datagram into the instances.
1640 //
1641 Enqueued = Udp4EnqueueDgram (Udp4Service, Packet, &RxData);
1642
1643 if (Enqueued == 0) {
1644 //
1645 // Send the port unreachable ICMP packet before we free this NET_BUF
1646 //
1647 Udp4SendPortUnreach (Udp4Service->IpIo, NetSession, Udp4Header);
1648 }
1649
1650 //
1651 // Try to free the packet before deliver it.
1652 //
1653 NetbufFree (Packet);
1654
1655 if (Enqueued > 0) {
1656 //
1657 // Deliver the datagram.
1658 //
1659 Udp4DeliverDgram (Udp4Service);
1660 }
1661}
1662
1663/**
1664 This function builds and sends out a icmp port unreachable message.
1665
1666 @param[in] IpIo Pointer to the IP_IO instance.
1667 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA of the packet
1668 causes this icmp error message.
1669 @param[in] Udp4Header Pointer to the udp header of the datagram causes
1670 this icmp error message.
1671
1672**/
1673VOID
1674Udp4SendPortUnreach (
1675 IN IP_IO *IpIo,
1676 IN EFI_NET_SESSION_DATA *NetSession,
1677 IN VOID *Udp4Header
1678 )
1679{
1680 NET_BUF *Packet;
1681 UINT32 Len;
1682 IP4_ICMP_ERROR_HEAD *IcmpErrHdr;
1683 EFI_IP4_HEADER *IpHdr;
1684 UINT8 *Ptr;
1685 IP_IO_OVERRIDE Override;
1686 IP_IO_IP_INFO *IpSender;
1687
1688 IpSender = IpIoFindSender (&IpIo, NetSession->IpVersion, &NetSession->Dest);
1689 if (IpSender == NULL) {
1690 //
1691 // No appropriate sender, since we cannot send out the ICMP message through
1692 // the default zero station address IP instance, abort.
1693 //
1694 return;
1695 }
1696
1697 IpHdr = NetSession->IpHdr.Ip4Hdr;
1698
1699 //
1700 // Calculate the required length of the icmp error message.
1701 //
1702 Len = sizeof (IP4_ICMP_ERROR_HEAD) + (EFI_IP4_HEADER_LEN (IpHdr) -
1703 sizeof (IP4_HEAD)) + ICMP_ERROR_PACKET_LENGTH;
1704
1705 //
1706 // Allocate buffer for the icmp error message.
1707 //
1708 Packet = NetbufAlloc (Len);
1709 if (Packet == NULL) {
1710 return;
1711 }
1712
1713 //
1714 // Allocate space for the IP4_ICMP_ERROR_HEAD.
1715 //
1716 IcmpErrHdr = (IP4_ICMP_ERROR_HEAD *)NetbufAllocSpace (Packet, Len, FALSE);
1717 ASSERT (IcmpErrHdr != NULL);
1718
1719 //
1720 // Set the required fields for the icmp port unreachable message.
1721 //
1722 IcmpErrHdr->Head.Type = ICMP_TYPE_UNREACH;
1723 IcmpErrHdr->Head.Code = ICMP_CODE_UNREACH_PORT;
1724 IcmpErrHdr->Head.Checksum = 0;
1725 IcmpErrHdr->Fourth = 0;
1726
1727 //
1728 // Copy the IP header of the datagram tragged the error.
1729 //
1730 CopyMem (&IcmpErrHdr->IpHead, IpHdr, EFI_IP4_HEADER_LEN (IpHdr));
1731
1732 //
1733 // Copy the UDP header.
1734 //
1735 Ptr = (UINT8 *)&IcmpErrHdr->IpHead + EFI_IP4_HEADER_LEN (IpHdr);
1736 CopyMem (Ptr, Udp4Header, ICMP_ERROR_PACKET_LENGTH);
1737
1738 //
1739 // Calculate the checksum.
1740 //
1741 IcmpErrHdr->Head.Checksum = (UINT16) ~(NetbufChecksum (Packet));
1742
1743 //
1744 // Fill the override data.
1745 //
1746 Override.Ip4OverrideData.DoNotFragment = FALSE;
1747 Override.Ip4OverrideData.TypeOfService = 0;
1748 Override.Ip4OverrideData.TimeToLive = 255;
1749 Override.Ip4OverrideData.Protocol = EFI_IP_PROTO_ICMP;
1750
1751 CopyMem (&Override.Ip4OverrideData.SourceAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
1752 ZeroMem (&Override.Ip4OverrideData.GatewayAddress, sizeof (EFI_IPv4_ADDRESS));
1753
1754 //
1755 // Send out this icmp packet.
1756 //
1757 IpIoSend (IpIo, Packet, IpSender, NULL, NULL, &NetSession->Source, &Override);
1758
1759 NetbufFree (Packet);
1760}
1761
1762/**
1763 This function handles the received Icmp Error message and demultiplexes it to the
1764 instance.
1765
1766 @param[in] Udp4Service Pointer to the udp service context data.
1767 @param[in] IcmpError The icmp error code.
1768 @param[in] NetSession Pointer to the EFI_NET_SESSION_DATA abstracted
1769 from the received Icmp Error packet.
1770 @param[in] Packet Pointer to the Icmp Error packet.
1771
1772**/
1773VOID
1774Udp4IcmpHandler (
1775 IN UDP4_SERVICE_DATA *Udp4Service,
1776 IN UINT8 IcmpError,
1777 IN EFI_NET_SESSION_DATA *NetSession,
1778 IN NET_BUF *Packet
1779 )
1780{
1781 EFI_UDP_HEADER *Udp4Header;
1782 EFI_UDP4_SESSION_DATA Udp4Session;
1783 LIST_ENTRY *Entry;
1784 UDP4_INSTANCE_DATA *Instance;
1785
1786 if (Packet->TotalSize < sizeof (EFI_UDP_HEADER)) {
1787 NetbufFree (Packet);
1788 return;
1789 }
1790
1791 Udp4Header = (EFI_UDP_HEADER *)NetbufGetByte (Packet, 0, NULL);
1792 ASSERT (Udp4Header != NULL);
1793
1794 CopyMem (&Udp4Session.SourceAddress, &NetSession->Source, sizeof (EFI_IPv4_ADDRESS));
1795 CopyMem (&Udp4Session.DestinationAddress, &NetSession->Dest, sizeof (EFI_IPv4_ADDRESS));
1796
1797 Udp4Session.SourcePort = NTOHS (Udp4Header->DstPort);
1798 Udp4Session.DestinationPort = NTOHS (Udp4Header->SrcPort);
1799
1800 NET_LIST_FOR_EACH (Entry, &Udp4Service->ChildrenList) {
1801 //
1802 // Iterate all the instances.
1803 //
1804 Instance = NET_LIST_USER_STRUCT (Entry, UDP4_INSTANCE_DATA, Link);
1805
1806 if (!Instance->Configured) {
1807 continue;
1808 }
1809
1810 if (Udp4MatchDgram (Instance, &Udp4Session)) {
1811 //
1812 // Translate the Icmp Error code according to the udp spec.
1813 //
1814 Instance->IcmpError = IpIoGetIcmpErrStatus (IcmpError, IP_VERSION_4, NULL, NULL);
1815
1816 if (IcmpError > ICMP_ERR_UNREACH_PORT) {
1817 Instance->IcmpError = EFI_ICMP_ERROR;
1818 }
1819
1820 //
1821 // Notify the instance with the received Icmp Error.
1822 //
1823 Udp4ReportIcmpError (Instance);
1824
1825 break;
1826 }
1827 }
1828
1829 NetbufFree (Packet);
1830}
1831
1832/**
1833 This function reports the received ICMP error.
1834
1835 @param[in] Instance Pointer to the udp instance context data.
1836
1837**/
1838VOID
1839Udp4ReportIcmpError (
1840 IN UDP4_INSTANCE_DATA *Instance
1841 )
1842{
1843 EFI_UDP4_COMPLETION_TOKEN *Token;
1844
1845 if (NetMapIsEmpty (&Instance->RxTokens)) {
1846 //
1847 // There are no receive tokens to deliver the ICMP error.
1848 //
1849 return;
1850 }
1851
1852 if (EFI_ERROR (Instance->IcmpError)) {
1853 //
1854 // Try to get a RxToken from the RxTokens map.
1855 //
1856 Token = (EFI_UDP4_COMPLETION_TOKEN *)NetMapRemoveHead (&Instance->RxTokens, NULL);
1857
1858 if (Token != NULL) {
1859 //
1860 // Report the error through the Token.
1861 //
1862 Token->Status = Instance->IcmpError;
1863 gBS->SignalEvent (Token->Event);
1864
1865 //
1866 // Clear the IcmpError.
1867 //
1868 Instance->IcmpError = EFI_SUCCESS;
1869 }
1870 }
1871}
1872
1873/**
1874 This function is a dummy ext-free function for the NET_BUF created for the output
1875 udp datagram.
1876
1877 @param[in] Context Pointer to the context data.
1878
1879**/
1880VOID
1881EFIAPI
1882Udp4NetVectorExtFree (
1883 VOID *Context
1884 )
1885{
1886}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette