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