]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/UefiPxeBcDxe/PxeBcSupport.c
projects / mirror_edk2.git / blob
? search:


88ae7b6a7a145c18097ef3ba9f55a4b8d75eb6bc
[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcSupport.c
1 /** @file
2 Support functions implementation for UefiPxeBc Driver.
3
4 Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
5
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php.
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "PxeBcImpl.h"
17
18
19 /**
20 Flush the previous configration using the new station Ip address.
21
22 @param[in] Private The pointer to the PxeBc private data.
23 @param[in] StationIp The pointer to the station Ip address.
24 @param[in] SubnetMask The pointer to the subnet mask address for v4.
25
26 @retval EFI_SUCCESS Successfully flushed the previous configuration.
27 @retval Others Failed to flush using the new station Ip.
28
29 **/
30 EFI_STATUS
31 PxeBcFlushStationIp (
32 PXEBC_PRIVATE_DATA *Private,
33 EFI_IP_ADDRESS *StationIp,
34 EFI_IP_ADDRESS *SubnetMask OPTIONAL
35 )
36 {
37 EFI_PXE_BASE_CODE_MODE *Mode;
38 EFI_STATUS Status;
39
40 ASSERT (StationIp != NULL);
41
42 Mode = Private->PxeBc.Mode;
43 Status = EFI_SUCCESS;
44
45 if (Mode->UsingIpv6) {
46
47 CopyMem (&Private->Udp6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
48 CopyMem (&Private->Ip6CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
49
50 //
51 // Reconfigure the Ip6 instance to capture background ICMP6 packets with new station Ip address.
52 //
53 Private->Ip6->Cancel (Private->Ip6, &Private->Icmp6Token);
54 Private->Ip6->Configure (Private->Ip6, NULL);
55
56 Status = Private->Ip6->Configure (Private->Ip6, &Private->Ip6CfgData);
57 if (EFI_ERROR (Status)) {
58 goto ON_EXIT;
59 }
60
61 Status = Private->Ip6->Receive (Private->Ip6, &Private->Icmp6Token);
62 } else {
63 ASSERT (SubnetMask != NULL);
64 CopyMem (&Private->Udp4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));
65 CopyMem (&Private->Udp4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));
66 CopyMem (&Private->Ip4CfgData.StationAddress, StationIp, sizeof (EFI_IPv4_ADDRESS));
67 CopyMem (&Private->Ip4CfgData.SubnetMask, SubnetMask, sizeof (EFI_IPv4_ADDRESS));
68
69 //
70 // Reconfigure the Ip4 instance to capture background ICMP packets with new station Ip address.
71 //
72 Private->Ip4->Cancel (Private->Ip4, &Private->IcmpToken);
73 Private->Ip4->Configure (Private->Ip4, NULL);
74
75 Status = Private->Ip4->Configure (Private->Ip4, &Private->Ip4CfgData);
76 if (EFI_ERROR (Status)) {
77 goto ON_EXIT;
78 }
79
80 Status = Private->Ip4->Receive (Private->Ip4, &Private->IcmpToken);
81 }
82
83 ON_EXIT:
84 return Status;
85 }
86
87
88 /**
89 Notify the callback function when an event is triggered.
90
91 @param[in] Event The triggered event.
92 @param[in] Context The opaque parameter to the function.
93
94 **/
95 VOID
96 EFIAPI
97 PxeBcCommonNotify (
98 IN EFI_EVENT Event,
99 IN VOID *Context
100 )
101 {
102 *((BOOLEAN *) Context) = TRUE;
103 }
104
105
106 /**
107 Do arp resolution from arp cache in PxeBcMode.
108
109 @param Mode The pointer to EFI_PXE_BASE_CODE_MODE.
110 @param Ip4Addr The Ip4 address for resolution.
111 @param MacAddress The resoluted MAC address if the resolution is successful.
112 The value is undefined if the resolution fails.
113
114 @retval TRUE Found an matched entry.
115 @retval FALSE Did not find a matched entry.
116
117 **/
118 BOOLEAN
119 PxeBcCheckArpCache (
120 IN EFI_PXE_BASE_CODE_MODE *Mode,
121 IN EFI_IPv4_ADDRESS *Ip4Addr,
122 OUT EFI_MAC_ADDRESS *MacAddress
123 )
124 {
125 UINT32 Index;
126
127 ASSERT (!Mode->UsingIpv6);
128
129 //
130 // Check whether the current Arp cache in mode data contains this information or not.
131 //
132 for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {
133 if (EFI_IP4_EQUAL (&Mode->ArpCache[Index].IpAddr.v4, Ip4Addr)) {
134 CopyMem (
135 MacAddress,
136 &Mode->ArpCache[Index].MacAddr,
137 sizeof (EFI_MAC_ADDRESS)
138 );
139 return TRUE;
140 }
141 }
142
143 return FALSE;
144 }
145
146
147 /**
148 Update the arp cache periodically.
149
150 @param Event The pointer to EFI_PXE_BC_PROTOCOL.
151 @param Context Context of the timer event.
152
153 **/
154 VOID
155 EFIAPI
156 PxeBcArpCacheUpdate (
157 IN EFI_EVENT Event,
158 IN VOID *Context
159 )
160 {
161 PXEBC_PRIVATE_DATA *Private;
162 EFI_PXE_BASE_CODE_MODE *Mode;
163 EFI_ARP_FIND_DATA *ArpEntry;
164 UINT32 EntryLength;
165 UINT32 EntryCount;
166 UINT32 Index;
167 EFI_STATUS Status;
168
169 Private = (PXEBC_PRIVATE_DATA *) Context;
170 Mode = Private->PxeBc.Mode;
171
172 ASSERT (!Mode->UsingIpv6);
173
174 //
175 // Get the current Arp cache from Arp driver.
176 //
177 Status = Private->Arp->Find (
178 Private->Arp,
179 TRUE,
180 NULL,
181 &EntryLength,
182 &EntryCount,
183 &ArpEntry,
184 TRUE
185 );
186 if (EFI_ERROR (Status)) {
187 return;
188 }
189
190 //
191 // Update the Arp cache in mode data.
192 //
193 Mode->ArpCacheEntries = MIN (EntryCount, EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES);
194
195 for (Index = 0; Index < Mode->ArpCacheEntries; Index++) {
196 CopyMem (
197 &Mode->ArpCache[Index].IpAddr,
198 ArpEntry + 1,
199 ArpEntry->SwAddressLength
200 );
201 CopyMem (
202 &Mode->ArpCache[Index].MacAddr,
203 (UINT8 *) (ArpEntry + 1) + ArpEntry->SwAddressLength,
204 ArpEntry->HwAddressLength
205 );
206 ArpEntry = (EFI_ARP_FIND_DATA *) ((UINT8 *) ArpEntry + EntryLength);
207 }
208 }
209
210
211 /**
212 Notify function to handle the received ICMP message in DPC.
213
214 @param Context The PXEBC private data.
215
216 **/
217 VOID
218 EFIAPI
219 PxeBcIcmpErrorDpcHandle (
220 IN VOID *Context
221 )
222 {
223 EFI_STATUS Status;
224 EFI_IP4_RECEIVE_DATA *RxData;
225 EFI_IP4_PROTOCOL *Ip4;
226 PXEBC_PRIVATE_DATA *Private;
227 EFI_PXE_BASE_CODE_MODE *Mode;
228 UINT8 Type;
229 UINTN Index;
230 UINT32 CopiedLen;
231 UINT8 *IcmpError;
232
233 Private = (PXEBC_PRIVATE_DATA *) Context;
234 Mode = &Private->Mode;
235 Status = Private->IcmpToken.Status;
236 RxData = Private->IcmpToken.Packet.RxData;
237 Ip4 = Private->Ip4;
238
239 ASSERT (!Mode->UsingIpv6);
240
241 if (Status == EFI_ABORTED) {
242 //
243 // It's triggered by user cancellation.
244 //
245 return;
246 }
247
248 if (RxData == NULL) {
249 goto ON_EXIT;
250 }
251
252 if (Status != EFI_ICMP_ERROR) {
253 //
254 // The return status should be recognized as EFI_ICMP_ERROR.
255 //
256 gBS->SignalEvent (RxData->RecycleSignal);
257 goto ON_EXIT;
258 }
259
260 if (EFI_IP4 (RxData->Header->SourceAddress) != 0 &&
261 !NetIp4IsUnicast (EFI_NTOHL (RxData->Header->SourceAddress), 0)) {
262 //
263 // The source address of the received packet should be a valid unicast address.
264 //
265 gBS->SignalEvent (RxData->RecycleSignal);
266 goto ON_EXIT;
267 }
268
269 if (!EFI_IP4_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v4)) {
270 //
271 // The destination address of the received packet should be equal to the host address.
272 //
273 gBS->SignalEvent (RxData->RecycleSignal);
274 goto ON_EXIT;
275 }
276
277 if (RxData->Header->Protocol != EFI_IP_PROTO_ICMP) {
278 //
279 // The protocol value in the header of the receveid packet should be EFI_IP_PROTO_ICMP.
280 //
281 gBS->SignalEvent (RxData->RecycleSignal);
282 goto ON_EXIT;
283 }
284
285 Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
286
287 if (Type != ICMP_DEST_UNREACHABLE &&
288 Type != ICMP_SOURCE_QUENCH &&
289 Type != ICMP_REDIRECT &&
290 Type != ICMP_TIME_EXCEEDED &&
291 Type != ICMP_PARAMETER_PROBLEM) {
292 //
293 // The type of the receveid ICMP message should be ICMP_ERROR_MESSAGE.
294 //
295 gBS->SignalEvent (RxData->RecycleSignal);
296 goto ON_EXIT;
297 }
298
299 //
300 // Copy the right ICMP error message into mode data.
301 //
302 CopiedLen = 0;
303 IcmpError = (UINT8 *) &Mode->IcmpError;
304
305 for (Index = 0; Index < RxData->FragmentCount; Index++) {
306 CopiedLen += RxData->FragmentTable[Index].FragmentLength;
307 if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {
308 CopyMem (
309 IcmpError,
310 RxData->FragmentTable[Index].FragmentBuffer,
311 RxData->FragmentTable[Index].FragmentLength
312 );
313 } else {
314 CopyMem (
315 IcmpError,
316 RxData->FragmentTable[Index].FragmentBuffer,
317 CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)
318 );
319 }
320 IcmpError += CopiedLen;
321 }
322
323 ON_EXIT:
324 Private->IcmpToken.Status = EFI_NOT_READY;
325 Ip4->Receive (Ip4, &Private->IcmpToken);
326 }
327
328
329 /**
330 Callback function to update the latest ICMP6 error message.
331
332 @param Event The event signalled.
333 @param Context The context passed in using the event notifier.
334
335 **/
336 VOID
337 EFIAPI
338 PxeBcIcmpErrorUpdate (
339 IN EFI_EVENT Event,
340 IN VOID *Context
341 )
342 {
343 QueueDpc (TPL_CALLBACK, PxeBcIcmpErrorDpcHandle, Context);
344 }
345
346
347 /**
348 Notify function to handle the received ICMP6 message in DPC.
349
350 @param Context The PXEBC private data.
351
352 **/
353 VOID
354 EFIAPI
355 PxeBcIcmp6ErrorDpcHandle (
356 IN VOID *Context
357 )
358 {
359 PXEBC_PRIVATE_DATA *Private;
360 EFI_IP6_RECEIVE_DATA *RxData;
361 EFI_IP6_PROTOCOL *Ip6;
362 EFI_PXE_BASE_CODE_MODE *Mode;
363 EFI_STATUS Status;
364 UINTN Index;
365 UINT8 Type;
366 UINT32 CopiedLen;
367 UINT8 *Icmp6Error;
368
369 Private = (PXEBC_PRIVATE_DATA *) Context;
370 Mode = &Private->Mode;
371 Status = Private->Icmp6Token.Status;
372 RxData = Private->Icmp6Token.Packet.RxData;
373 Ip6 = Private->Ip6;
374
375 ASSERT (Mode->UsingIpv6);
376
377 if (Status == EFI_ABORTED) {
378 //
379 // It's triggered by user cancellation.
380 //
381 return;
382 }
383
384 if (RxData == NULL) {
385 goto ON_EXIT;
386 }
387
388 if (Status != EFI_ICMP_ERROR) {
389 //
390 // The return status should be recognized as EFI_ICMP_ERROR.
391 //
392 gBS->SignalEvent (RxData->RecycleSignal);
393 goto ON_EXIT;
394 }
395
396 if (!NetIp6IsValidUnicast (&RxData->Header->SourceAddress)) {
397 //
398 // The source address of the received packet should be a valid unicast address.
399 //
400 gBS->SignalEvent (RxData->RecycleSignal);
401 goto ON_EXIT;
402 }
403
404 if (!NetIp6IsUnspecifiedAddr (&Mode->StationIp.v6) &&
405 !EFI_IP6_EQUAL (&RxData->Header->DestinationAddress, &Mode->StationIp.v6)) {
406 //
407 // The destination address of the received packet should be equal to the host address.
408 //
409 gBS->SignalEvent (RxData->RecycleSignal);
410 goto ON_EXIT;
411 }
412
413 if (RxData->Header->NextHeader != IP6_ICMP) {
414 //
415 // The nextheader in the header of the receveid packet should be IP6_ICMP.
416 //
417 gBS->SignalEvent (RxData->RecycleSignal);
418 goto ON_EXIT;
419 }
420
421 Type = *((UINT8 *) RxData->FragmentTable[0].FragmentBuffer);
422
423 if (Type != ICMP_V6_DEST_UNREACHABLE &&
424 Type != ICMP_V6_PACKET_TOO_BIG &&
425 Type != ICMP_V6_PACKET_TOO_BIG &&
426 Type != ICMP_V6_PARAMETER_PROBLEM) {
427 //
428 // The type of the receveid packet should be an ICMP6 error message.
429 //
430 gBS->SignalEvent (RxData->RecycleSignal);
431 goto ON_EXIT;
432 }
433
434 //
435 // Copy the right ICMP6 error message into mode data.
436 //
437 CopiedLen = 0;
438 Icmp6Error = (UINT8 *) &Mode->IcmpError;
439
440 for (Index = 0; Index < RxData->FragmentCount; Index++) {
441 CopiedLen += RxData->FragmentTable[Index].FragmentLength;
442 if (CopiedLen <= sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)) {
443 CopyMem (
444 Icmp6Error,
445 RxData->FragmentTable[Index].FragmentBuffer,
446 RxData->FragmentTable[Index].FragmentLength
447 );
448 } else {
449 CopyMem (
450 Icmp6Error,
451 RxData->FragmentTable[Index].FragmentBuffer,
452 CopiedLen - sizeof (EFI_PXE_BASE_CODE_ICMP_ERROR)
453 );
454 }
455 Icmp6Error += CopiedLen;
456 }
457
458 ON_EXIT:
459 Private->Icmp6Token.Status = EFI_NOT_READY;
460 Ip6->Receive (Ip6, &Private->Icmp6Token);
461 }
462
463
464 /**
465 Callback function to update the latest ICMP6 error message.
466
467 @param Event The event signalled.
468 @param Context The context passed in using the event notifier.
469
470 **/
471 VOID
472 EFIAPI
473 PxeBcIcmp6ErrorUpdate (
474 IN EFI_EVENT Event,
475 IN VOID *Context
476 )
477 {
478 QueueDpc (TPL_CALLBACK, PxeBcIcmp6ErrorDpcHandle, Context);
479 }
480
481
482 /**
483 This function is to configure a UDPv4 instance for UdpWrite.
484
485 @param[in] Udp4 The pointer to EFI_UDP4_PROTOCOL.
486 @param[in] StationIp The pointer to the station address.
487 @param[in] SubnetMask The pointer to the subnet mask.
488 @param[in] Gateway The pointer to the gateway address.
489 @param[in, out] SrcPort The pointer to the source port.
490 @param[in] DoNotFragment If TRUE, fragment is not enabled.
491 Otherwise, fragment is enabled.
492
493 @retval EFI_SUCCESS Successfully configured this instance.
494 @retval Others Failed to configure this instance.
495
496 **/
497 EFI_STATUS
498 PxeBcConfigUdp4Write (
499 IN EFI_UDP4_PROTOCOL *Udp4,
500 IN EFI_IPv4_ADDRESS *StationIp,
501 IN EFI_IPv4_ADDRESS *SubnetMask,
502 IN EFI_IPv4_ADDRESS *Gateway,
503 IN OUT UINT16 *SrcPort,
504 IN BOOLEAN DoNotFragment
505 )
506 {
507 EFI_UDP4_CONFIG_DATA Udp4CfgData;
508 EFI_STATUS Status;
509
510 ZeroMem (&Udp4CfgData, sizeof (Udp4CfgData));
511
512 Udp4CfgData.TransmitTimeout = PXEBC_DEFAULT_LIFETIME;
513 Udp4CfgData.ReceiveTimeout = PXEBC_DEFAULT_LIFETIME;
514 Udp4CfgData.TypeOfService = DEFAULT_ToS;
515 Udp4CfgData.TimeToLive = DEFAULT_TTL;
516 Udp4CfgData.AllowDuplicatePort = TRUE;
517 Udp4CfgData.DoNotFragment = DoNotFragment;
518
519 CopyMem (&Udp4CfgData.StationAddress, StationIp, sizeof (*StationIp));
520 CopyMem (&Udp4CfgData.SubnetMask, SubnetMask, sizeof (*SubnetMask));
521
522 Udp4CfgData.StationPort = *SrcPort;
523
524 //
525 // Reset the UDPv4 instance.
526 //
527 Udp4->Configure (Udp4, NULL);
528
529 Status = Udp4->Configure (Udp4, &Udp4CfgData);
530 if (!EFI_ERROR (Status) && !EFI_IP4_EQUAL (Gateway, &mZeroIp4Addr)) {
531 //
532 // The basic configuration is OK, need to add the default route entry
533 //
534 Status = Udp4->Routes (Udp4, FALSE, &mZeroIp4Addr, &mZeroIp4Addr, Gateway);
535 if (EFI_ERROR (Status)) {
536 Udp4->Configure (Udp4, NULL);
537 }
538 }
539
540 if (!EFI_ERROR (Status) && *SrcPort == 0) {
541 Udp4->GetModeData (Udp4, &Udp4CfgData, NULL, NULL, NULL);
542 *SrcPort = Udp4CfgData.StationPort;
543 }
544
545 return Status;
546 }
547
548
549 /**
550 This function is to configure a UDPv6 instance for UdpWrite.
551
552 @param[in] Udp6 The pointer to EFI_UDP6_PROTOCOL.
553 @param[in] StationIp The pointer to the station address.
554 @param[in, out] SrcPort The pointer to the source port.
555
556 @retval EFI_SUCCESS Successfully configured this instance.
557 @retval Others Failed to configure this instance.
558
559 **/
560 EFI_STATUS
561 PxeBcConfigUdp6Write (
562 IN EFI_UDP6_PROTOCOL *Udp6,
563 IN EFI_IPv6_ADDRESS *StationIp,
564 IN OUT UINT16 *SrcPort
565 )
566 {
567 EFI_UDP6_CONFIG_DATA CfgData;
568 EFI_STATUS Status;
569
570 ZeroMem (&CfgData, sizeof (EFI_UDP6_CONFIG_DATA));
571
572 CfgData.ReceiveTimeout = PXEBC_DEFAULT_LIFETIME;
573 CfgData.TransmitTimeout = PXEBC_DEFAULT_LIFETIME;
574 CfgData.HopLimit = PXEBC_DEFAULT_HOPLIMIT;
575 CfgData.AllowDuplicatePort = TRUE;
576 CfgData.StationPort = *SrcPort;
577
578 CopyMem (&CfgData.StationAddress, StationIp, sizeof (EFI_IPv6_ADDRESS));
579
580 //
581 // Reset the UDPv6 instance.
582 //
583 Udp6->Configure (Udp6, NULL);
584
585 Status = Udp6->Configure (Udp6, &CfgData);
586 if (EFI_ERROR (Status)) {
587 return Status;
588 }
589
590 if (!EFI_ERROR (Status) && *SrcPort == 0) {
591 Udp6->GetModeData (Udp6, &CfgData, NULL, NULL, NULL);
592 *SrcPort = CfgData.StationPort;
593 }
594
595 return Status;
596 }
597
598
599 /**
600 This function is to configure a UDPv4 instance for UdpWrite.
601
602 @param[in] Udp4 The pointer to EFI_UDP4_PROTOCOL.
603 @param[in] Session The pointer to the UDP4 session data.
604 @param[in] TimeoutEvent The event for timeout.
605 @param[in] Gateway The pointer to the gateway address.
606 @param[in] HeaderSize An optional field which may be set to the length of a header
607 at HeaderPtr to be prefixed to the data at BufferPtr.
608 @param[in] HeaderPtr If HeaderSize is not NULL, a pointer to a header to be
609 prefixed to the data at BufferPtr.
610 @param[in] BufferSize A pointer to the size of the data at BufferPtr.
611 @param[in] BufferPtr A pointer to the data to be written.
612
613 @retval EFI_SUCCESS Successfully send out data using Udp4Write.
614 @retval Others Failed to send out data.
615
616 **/
617 EFI_STATUS
618 PxeBcUdp4Write (
619 IN EFI_UDP4_PROTOCOL *Udp4,
620 IN EFI_UDP4_SESSION_DATA *Session,
621 IN EFI_EVENT TimeoutEvent,
622 IN EFI_IPv4_ADDRESS *Gateway OPTIONAL,
623 IN UINTN *HeaderSize OPTIONAL,
624 IN VOID *HeaderPtr OPTIONAL,
625 IN UINTN *BufferSize,
626 IN VOID *BufferPtr
627 )
628 {
629 EFI_UDP4_COMPLETION_TOKEN Token;
630 EFI_UDP4_TRANSMIT_DATA *TxData;
631 UINT32 TxLength;
632 UINT32 FragCount;
633 UINT32 DataLength;
634 BOOLEAN IsDone;
635 EFI_STATUS Status;
636
637 //
638 // Arrange one fragment buffer for data, and another fragment buffer for header if has.
639 //
640 FragCount = (HeaderSize != NULL) ? 2 : 1;
641 TxLength = sizeof (EFI_UDP4_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP4_FRAGMENT_DATA);
642 TxData = (EFI_UDP4_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
643 if (TxData == NULL) {
644 return EFI_OUT_OF_RESOURCES;
645 }
646
647 TxData->FragmentCount = FragCount;
648 TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
649 TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
650 DataLength = (UINT32) *BufferSize;
651
652 if (HeaderSize != NULL) {
653 TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
654 TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
655 DataLength += (UINT32) *HeaderSize;
656 }
657
658 if (Gateway != NULL) {
659 TxData->GatewayAddress = Gateway;
660 }
661
662 TxData->UdpSessionData = Session;
663 TxData->DataLength = DataLength;
664 Token.Packet.TxData = TxData;
665 Token.Status = EFI_NOT_READY;
666 IsDone = FALSE;
667
668 Status = gBS->CreateEvent (
669 EVT_NOTIFY_SIGNAL,
670 TPL_NOTIFY,
671 PxeBcCommonNotify,
672 &IsDone,
673 &Token.Event
674 );
675 if (EFI_ERROR (Status)) {
676 goto ON_EXIT;
677 }
678
679 Status = Udp4->Transmit (Udp4, &Token);
680 if (EFI_ERROR (Status)) {
681 goto ON_EXIT;
682 }
683
684 //
685 // Poll the UDPv6 read instance if no packet received and no timeout triggered.
686 //
687 while (!IsDone &&
688 Token.Status == EFI_NOT_READY &&
689 EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
690 Udp4->Poll (Udp4);
691 }
692
693 Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;
694
695 ON_EXIT:
696 if (Token.Event != NULL) {
697 gBS->CloseEvent (Token.Event);
698 }
699 FreePool (TxData);
700
701 return Status;
702 }
703
704
705 /**
706 This function is to configure a UDPv4 instance for UdpWrite.
707
708 @param[in] Udp6 The pointer to EFI_UDP6_PROTOCOL.
709 @param[in] Session The pointer to the UDP6 session data.
710 @param[in] TimeoutEvent The event for timeout.
711 @param[in] HeaderSize An optional field which may be set to the length of a header
712 at HeaderPtr to be prefixed to the data at BufferPtr.
713 @param[in] HeaderPtr If HeaderSize is not NULL, a pointer to a header to be
714 prefixed to the data at BufferPtr.
715 @param[in] BufferSize A pointer to the size of the data at BufferPtr.
716 @param[in] BufferPtr A pointer to the data to be written.
717
718 @retval EFI_SUCCESS Successfully sent out data using Udp6Write.
719 @retval Others Failed to send out data.
720
721 **/
722 EFI_STATUS
723 PxeBcUdp6Write (
724 IN EFI_UDP6_PROTOCOL *Udp6,
725 IN EFI_UDP6_SESSION_DATA *Session,
726 IN EFI_EVENT TimeoutEvent,
727 IN UINTN *HeaderSize OPTIONAL,
728 IN VOID *HeaderPtr OPTIONAL,
729 IN UINTN *BufferSize,
730 IN VOID *BufferPtr
731 )
732 {
733 EFI_UDP6_COMPLETION_TOKEN Token;
734 EFI_UDP6_TRANSMIT_DATA *TxData;
735 UINT32 TxLength;
736 UINT32 FragCount;
737 UINT32 DataLength;
738 BOOLEAN IsDone;
739 EFI_STATUS Status;
740
741 //
742 // Arrange one fragment buffer for data, and another fragment buffer for header if has.
743 //
744 FragCount = (HeaderSize != NULL) ? 2 : 1;
745 TxLength = sizeof (EFI_UDP6_TRANSMIT_DATA) + (FragCount - 1) * sizeof (EFI_UDP6_FRAGMENT_DATA);
746 TxData = (EFI_UDP6_TRANSMIT_DATA *) AllocateZeroPool (TxLength);
747 if (TxData == NULL) {
748 return EFI_OUT_OF_RESOURCES;
749 }
750
751 TxData->FragmentCount = FragCount;
752 TxData->FragmentTable[FragCount - 1].FragmentLength = (UINT32) *BufferSize;
753 TxData->FragmentTable[FragCount - 1].FragmentBuffer = BufferPtr;
754 DataLength = (UINT32) *BufferSize;
755
756 if (HeaderSize != NULL) {
757 TxData->FragmentTable[0].FragmentLength = (UINT32) *HeaderSize;
758 TxData->FragmentTable[0].FragmentBuffer = HeaderPtr;
759 DataLength += (UINT32) *HeaderSize;
760 }
761
762 TxData->UdpSessionData = Session;
763 TxData->DataLength = DataLength;
764 Token.Packet.TxData = TxData;
765 Token.Status = EFI_NOT_READY;
766 IsDone = FALSE;
767
768 Status = gBS->CreateEvent (
769 EVT_NOTIFY_SIGNAL,
770 TPL_NOTIFY,
771 PxeBcCommonNotify,
772 &IsDone,
773 &Token.Event
774 );
775 if (EFI_ERROR (Status)) {
776 goto ON_EXIT;
777 }
778
779 Status = Udp6->Transmit (Udp6, &Token);
780 if (EFI_ERROR (Status)) {
781 goto ON_EXIT;
782 }
783
784 //
785 // Poll the UDPv6 read instance if no packet received and no timeout triggered.
786 //
787 while (!IsDone &&
788 Token.Status == EFI_NOT_READY &&
789 EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
790 Udp6->Poll (Udp6);
791 }
792
793 Status = (Token.Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token.Status;
794
795 ON_EXIT:
796 if (Token.Event != NULL) {
797 gBS->CloseEvent (Token.Event);
798 }
799 FreePool (TxData);
800
801 return Status;
802 }
803
804
805 /**
806 Check the received packet using the Ip filter.
807
808 @param[in] Mode The pointer to the mode data of PxeBc.
809 @param[in] Session The pointer to the current UDPv4 session.
810 @param[in] OpFlags Operation flag for UdpRead/UdpWrite.
811
812 @retval TRUE Passed the Ip filter successfully.
813 @retval FALSE Failed to pass the Ip filter.
814
815 **/
816 BOOLEAN
817 PxeBcCheckByIpFilter (
818 IN EFI_PXE_BASE_CODE_MODE *Mode,
819 IN VOID *Session,
820 IN UINT16 OpFlags
821 )
822 {
823 EFI_IP_ADDRESS DestinationIp;
824 UINTN Index;
825
826 if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER) == 0) {
827 return TRUE;
828 }
829
830 if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS) != 0) {
831 return TRUE;
832 }
833
834 //
835 // Convert the destination address in session data to host order.
836 //
837 if (Mode->UsingIpv6) {
838 CopyMem (
839 &DestinationIp,
840 &((EFI_UDP6_SESSION_DATA *) Session)->DestinationAddress,
841 sizeof (EFI_IPv6_ADDRESS)
842 );
843 NTOHLLL (&DestinationIp.v6);
844 } else {
845 ZeroMem (&DestinationIp, sizeof (EFI_IP_ADDRESS));
846 CopyMem (
847 &DestinationIp,
848 &((EFI_UDP4_SESSION_DATA *) Session)->DestinationAddress,
849 sizeof (EFI_IPv4_ADDRESS)
850 );
851 EFI_NTOHL (DestinationIp);
852 }
853
854 if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST) != 0 &&
855 (IP4_IS_MULTICAST (DestinationIp.Addr[0]) ||
856 IP6_IS_MULTICAST (&DestinationIp))) {
857 return TRUE;
858 }
859
860 if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST) != 0 &&
861 IP4_IS_LOCAL_BROADCAST (DestinationIp.Addr[0])) {
862 ASSERT (!Mode->UsingIpv6);
863 return TRUE;
864 }
865
866 if ((Mode->IpFilter.Filters & EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP) != 0 &&
867 (EFI_IP4_EQUAL (&Mode->StationIp.v4, &DestinationIp) ||
868 EFI_IP6_EQUAL (&Mode->StationIp.v6, &DestinationIp))) {
869 //
870 // Matched if the dest address is equal to the station address.
871 //
872 return TRUE;
873 }
874
875 for (Index = 0; Index < Mode->IpFilter.IpCnt; Index++) {
876 ASSERT (Index < EFI_PXE_BASE_CODE_MAX_IPCNT);
877 if (EFI_IP4_EQUAL (&Mode->IpFilter.IpList[Index].v4, &DestinationIp) ||
878 EFI_IP6_EQUAL (&Mode->IpFilter.IpList[Index].v6, &DestinationIp)) {
879 //
880 // Matched if the dest address is equal to any of address in the filter list.
881 //
882 return TRUE;
883 }
884 }
885
886 return FALSE;
887 }
888
889
890 /**
891 Filter the received packet using the destination Ip.
892
893 @param[in] Mode The pointer to the mode data of PxeBc.
894 @param[in] Session The pointer to the current UDPv4 session.
895 @param[in, out] DestIp The pointer to the destination Ip address.
896 @param[in] OpFlags Operation flag for UdpRead/UdpWrite.
897
898 @retval TRUE Passed the IPv4 filter successfully.
899 @retval FALSE Failed to pass the IPv4 filter.
900
901 **/
902 BOOLEAN
903 PxeBcCheckByDestIp (
904 IN EFI_PXE_BASE_CODE_MODE *Mode,
905 IN VOID *Session,
906 IN OUT EFI_IP_ADDRESS *DestIp,
907 IN UINT16 OpFlags
908 )
909 {
910 if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP) != 0) {
911 //
912 // Copy the destination address from the received packet if accept any.
913 //
914 if (DestIp != NULL) {
915 if (Mode->UsingIpv6) {
916 CopyMem (
917 DestIp,
918 &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress,
919 sizeof (EFI_IPv6_ADDRESS)
920 );
921 } else {
922 ZeroMem (DestIp, sizeof (EFI_IP_ADDRESS));
923 CopyMem (
924 DestIp,
925 &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress,
926 sizeof (EFI_IPv4_ADDRESS)
927 );
928 }
929
930 }
931 return TRUE;
932 } else if (DestIp != NULL &&
933 (EFI_IP4_EQUAL (DestIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
934 EFI_IP6_EQUAL (DestIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress))) {
935 //
936 // The destination address in the received packet is matched if present.
937 //
938 return TRUE;
939 } else if (EFI_IP4_EQUAL (&Mode->StationIp, &((EFI_UDP4_SESSION_DATA *)Session)->DestinationAddress) ||
940 EFI_IP6_EQUAL (&Mode->StationIp, &((EFI_UDP6_SESSION_DATA *)Session)->DestinationAddress)) {
941 //
942 // The destination address in the received packet is equal to the host address.
943 //
944 return TRUE;
945 }
946
947 return FALSE;
948 }
949
950
951 /**
952 Check the received packet using the destination port.
953
954 @param[in] Mode The pointer to the mode data of PxeBc.
955 @param[in] Session The pointer to the current UDPv4 session.
956 @param[in, out] DestPort The pointer to the destination port.
957 @param[in] OpFlags Operation flag for UdpRead/UdpWrite.
958
959 @retval TRUE Passed the IPv4 filter successfully.
960 @retval FALSE Failed to pass the IPv4 filter.
961
962 **/
963 BOOLEAN
964 PxeBcCheckByDestPort (
965 IN EFI_PXE_BASE_CODE_MODE *Mode,
966 IN VOID *Session,
967 IN OUT UINT16 *DestPort,
968 IN UINT16 OpFlags
969 )
970 {
971 UINT16 Port;
972
973 if (Mode->UsingIpv6) {
974 Port = ((EFI_UDP6_SESSION_DATA *) Session)->DestinationPort;
975 } else {
976 Port = ((EFI_UDP4_SESSION_DATA *) Session)->DestinationPort;
977 }
978
979 if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT) != 0) {
980 //
981 // Return the destination port in the received packet if accept any.
982 //
983 if (DestPort != NULL) {
984 *DestPort = Port;
985 }
986 return TRUE;
987 } else if (DestPort != NULL && *DestPort == Port) {
988 //
989 // The destination port in the received packet is matched if present.
990 //
991 return TRUE;
992 }
993
994 return FALSE;
995 }
996
997
998 /**
999 Filter the received packet using the source Ip.
1000
1001 @param[in] Mode The pointer to the mode data of PxeBc.
1002 @param[in] Session The pointer to the current UDPv4 session.
1003 @param[in, out] SrcIp The pointer to the source Ip address.
1004 @param[in] OpFlags Operation flag for UdpRead/UdpWrite.
1005
1006 @retval TRUE Passed the IPv4 filter successfully.
1007 @retval FALSE Failed to pass the IPv4 filter.
1008
1009 **/
1010 BOOLEAN
1011 PxeBcFilterBySrcIp (
1012 IN EFI_PXE_BASE_CODE_MODE *Mode,
1013 IN VOID *Session,
1014 IN OUT EFI_IP_ADDRESS *SrcIp,
1015 IN UINT16 OpFlags
1016 )
1017 {
1018 if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP) != 0) {
1019 //
1020 // Copy the source address from the received packet if accept any.
1021 //
1022 if (SrcIp != NULL) {
1023 if (Mode->UsingIpv6) {
1024 CopyMem (
1025 SrcIp,
1026 &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress,
1027 sizeof (EFI_IPv6_ADDRESS)
1028 );
1029 } else {
1030 ZeroMem (SrcIp, sizeof (EFI_IP_ADDRESS));
1031 CopyMem (
1032 SrcIp,
1033 &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress,
1034 sizeof (EFI_IPv4_ADDRESS)
1035 );
1036 }
1037
1038 }
1039 return TRUE;
1040 } else if (SrcIp != NULL &&
1041 (EFI_IP4_EQUAL (SrcIp, &((EFI_UDP4_SESSION_DATA *)Session)->SourceAddress) ||
1042 EFI_IP6_EQUAL (SrcIp, &((EFI_UDP6_SESSION_DATA *)Session)->SourceAddress))) {
1043 //
1044 // The source address in the received packet is matched if present.
1045 //
1046 return TRUE;
1047 }
1048
1049 return FALSE;
1050 }
1051
1052
1053 /**
1054 Filter the received packet using the source port.
1055
1056 @param[in] Mode The pointer to the mode data of PxeBc.
1057 @param[in] Session The pointer to the current UDPv4 session.
1058 @param[in, out] SrcPort The pointer to the source port.
1059 @param[in] OpFlags Operation flag for UdpRead/UdpWrite.
1060
1061 @retval TRUE Passed the IPv4 filter successfully.
1062 @retval FALSE Failed to pass the IPv4 filter.
1063
1064 **/
1065 BOOLEAN
1066 PxeBcFilterBySrcPort (
1067 IN EFI_PXE_BASE_CODE_MODE *Mode,
1068 IN VOID *Session,
1069 IN OUT UINT16 *SrcPort,
1070 IN UINT16 OpFlags
1071 )
1072 {
1073 UINT16 Port;
1074
1075 if (Mode->UsingIpv6) {
1076 Port = ((EFI_UDP6_SESSION_DATA *) Session)->SourcePort;
1077 } else {
1078 Port = ((EFI_UDP4_SESSION_DATA *) Session)->SourcePort;
1079 }
1080
1081 if ((OpFlags & EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT) != 0) {
1082 //
1083 // Return the source port in the received packet if accept any.
1084 //
1085 if (SrcPort != NULL) {
1086 *SrcPort = Port;
1087 }
1088 return TRUE;
1089 } else if (SrcPort != NULL && *SrcPort == Port) {
1090 //
1091 // The source port in the received packet is matched if present.
1092 //
1093 return TRUE;
1094 }
1095
1096 return FALSE;
1097 }
1098
1099
1100 /**
1101 This function is to receive packet using Udp4Read.
1102
1103 @param[in] Udp4 The pointer to EFI_UDP4_PROTOCOL.
1104 @param[in] Token The pointer to EFI_UDP4_COMPLETION_TOKEN.
1105 @param[in] Mode The pointer to EFI_PXE_BASE_CODE_MODE.
1106 @param[in] TimeoutEvent The event for timeout.
1107 @param[in] OpFlags The UDP operation flags.
1108 @param[in] IsDone The pointer to the IsDone flag.
1109 @param[out] IsMatched The pointer to the IsMatched flag.
1110 @param[in, out] DestIp The pointer to the destination address.
1111 @param[in, out] DestPort The pointer to the destination port.
1112 @param[in, out] SrcIp The pointer to the source address.
1113 @param[in, out] SrcPort The pointer to the source port.
1114
1115 @retval EFI_SUCCESS Successfully read the data using Udp4.
1116 @retval Others Failed to send out data.
1117
1118 **/
1119 EFI_STATUS
1120 PxeBcUdp4Read (
1121 IN EFI_UDP4_PROTOCOL *Udp4,
1122 IN EFI_UDP4_COMPLETION_TOKEN *Token,
1123 IN EFI_PXE_BASE_CODE_MODE *Mode,
1124 IN EFI_EVENT TimeoutEvent,
1125 IN UINT16 OpFlags,
1126 IN BOOLEAN *IsDone,
1127 OUT BOOLEAN *IsMatched,
1128 IN OUT EFI_IP_ADDRESS *DestIp OPTIONAL,
1129 IN OUT EFI_PXE_BASE_CODE_UDP_PORT *DestPort OPTIONAL,
1130 IN OUT EFI_IP_ADDRESS *SrcIp OPTIONAL,
1131 IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort OPTIONAL
1132 )
1133 {
1134 EFI_UDP4_RECEIVE_DATA *RxData;
1135 EFI_UDP4_SESSION_DATA *Session;
1136 EFI_STATUS Status;
1137
1138 Token->Status = EFI_NOT_READY;
1139 *IsDone = FALSE;
1140
1141 Status = Udp4->Receive (Udp4, Token);
1142 if (EFI_ERROR (Status)) {
1143 return Status;
1144 }
1145
1146 //
1147 // Poll the UDPv6 read instance if no packet received and no timeout triggered.
1148 //
1149 while (!(*IsDone) &&
1150 Token->Status == EFI_NOT_READY &&
1151 EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1152 //
1153 // Poll the token utill reply/ICMPv6 error message received or timeout.
1154 //
1155 Udp4->Poll (Udp4);
1156 if (Token->Status == EFI_ICMP_ERROR ||
1157 Token->Status == EFI_NETWORK_UNREACHABLE ||
1158 Token->Status == EFI_HOST_UNREACHABLE ||
1159 Token->Status == EFI_PROTOCOL_UNREACHABLE ||
1160 Token->Status == EFI_PORT_UNREACHABLE) {
1161 break;
1162 }
1163 }
1164
1165 Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;
1166
1167 if (!EFI_ERROR (Status)) {
1168 //
1169 // check whether this packet matches the filters
1170 //
1171 RxData = Token->Packet.RxData;
1172 Session = &RxData->UdpSession;
1173
1174 *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
1175
1176 if (*IsMatched) {
1177 *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);
1178 }
1179
1180 if (*IsMatched) {
1181 *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);
1182 }
1183
1184 if (*IsMatched) {
1185 *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);
1186 }
1187
1188 if (*IsMatched) {
1189 *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);
1190 }
1191
1192 if (!(*IsMatched)) {
1193 //
1194 // Recycle the receiving buffer if not matched.
1195 //
1196 gBS->SignalEvent (RxData->RecycleSignal);
1197 }
1198 }
1199
1200 return Status;
1201 }
1202
1203
1204 /**
1205 This function is to receive packets using Udp6Read.
1206
1207 @param[in] Udp6 The pointer to EFI_UDP6_PROTOCOL.
1208 @param[in] Token The pointer to EFI_UDP6_COMPLETION_TOKEN.
1209 @param[in] Mode The pointer to EFI_PXE_BASE_CODE_MODE.
1210 @param[in] TimeoutEvent The event for timeout.
1211 @param[in] OpFlags The UDP operation flags.
1212 @param[in] IsDone The pointer to the IsDone flag.
1213 @param[out] IsMatched The pointer to the IsMatched flag.
1214 @param[in, out] DestIp The pointer to the destination address.
1215 @param[in, out] DestPort The pointer to the destination port.
1216 @param[in, out] SrcIp The pointer to the source address.
1217 @param[in, out] SrcPort The pointer to the source port.
1218
1219 @retval EFI_SUCCESS Successfully read data using Udp6.
1220 @retval Others Failed to send out data.
1221
1222 **/
1223 EFI_STATUS
1224 PxeBcUdp6Read (
1225 IN EFI_UDP6_PROTOCOL *Udp6,
1226 IN EFI_UDP6_COMPLETION_TOKEN *Token,
1227 IN EFI_PXE_BASE_CODE_MODE *Mode,
1228 IN EFI_EVENT TimeoutEvent,
1229 IN UINT16 OpFlags,
1230 IN BOOLEAN *IsDone,
1231 OUT BOOLEAN *IsMatched,
1232 IN OUT EFI_IP_ADDRESS *DestIp OPTIONAL,
1233 IN OUT EFI_PXE_BASE_CODE_UDP_PORT *DestPort OPTIONAL,
1234 IN OUT EFI_IP_ADDRESS *SrcIp OPTIONAL,
1235 IN OUT EFI_PXE_BASE_CODE_UDP_PORT *SrcPort OPTIONAL
1236 )
1237 {
1238 EFI_UDP6_RECEIVE_DATA *RxData;
1239 EFI_UDP6_SESSION_DATA *Session;
1240 EFI_STATUS Status;
1241
1242 Token->Status = EFI_NOT_READY;
1243 *IsDone = FALSE;
1244
1245 Status = Udp6->Receive (Udp6, Token);
1246 if (EFI_ERROR (Status)) {
1247 return Status;
1248 }
1249
1250 //
1251 // Poll the UDPv6 read instance if no packet received and no timeout triggered.
1252 //
1253 while (!(*IsDone) &&
1254 Token->Status == EFI_NOT_READY &&
1255 EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1256 //
1257 // Poll the token utill reply/ICMPv6 error message received or timeout.
1258 //
1259 Udp6->Poll (Udp6);
1260 if (Token->Status == EFI_ICMP_ERROR ||
1261 Token->Status == EFI_NETWORK_UNREACHABLE ||
1262 Token->Status == EFI_HOST_UNREACHABLE ||
1263 Token->Status == EFI_PROTOCOL_UNREACHABLE ||
1264 Token->Status == EFI_PORT_UNREACHABLE) {
1265 break;
1266 }
1267 }
1268
1269 Status = (Token->Status == EFI_NOT_READY) ? EFI_TIMEOUT : Token->Status;
1270
1271 if (!EFI_ERROR (Status)) {
1272 //
1273 // check whether this packet matches the filters
1274 //
1275 RxData = Token->Packet.RxData;
1276 Session = &RxData->UdpSession;
1277
1278 *IsMatched = PxeBcCheckByIpFilter (Mode, Session, OpFlags);
1279
1280 if (*IsMatched) {
1281 *IsMatched = PxeBcCheckByDestIp (Mode, Session, DestIp, OpFlags);
1282 }
1283
1284 if (*IsMatched) {
1285 *IsMatched = PxeBcCheckByDestPort (Mode, Session, DestPort, OpFlags);
1286 }
1287
1288 if (*IsMatched) {
1289 *IsMatched = PxeBcFilterBySrcIp (Mode, Session, SrcIp, OpFlags);
1290 }
1291
1292 if (*IsMatched) {
1293 *IsMatched = PxeBcFilterBySrcPort (Mode, Session, SrcPort, OpFlags);
1294 }
1295
1296 if (!(*IsMatched)) {
1297 //
1298 // Recycle the receiving buffer if not matched.
1299 //
1300 gBS->SignalEvent (RxData->RecycleSignal);
1301 }
1302 }
1303
1304 return Status;
1305 }
1306
1307
1308 /**
1309 This function is to display the IPv4 address.
1310
1311 @param[in] Ip The pointer to the IPv4 address.
1312
1313 **/
1314 VOID
1315 PxeBcShowIp4Addr (
1316 IN EFI_IPv4_ADDRESS *Ip
1317 )
1318 {
1319 UINTN Index;
1320
1321 for (Index = 0; Index < 4; Index++) {
1322 AsciiPrint ("%d", Ip->Addr[Index]);
1323 if (Index < 3) {
1324 AsciiPrint (".");
1325 }
1326 }
1327 }
1328
1329
1330 /**
1331 This function is to display the IPv6 address.
1332
1333 @param[in] Ip The pointer to the IPv6 address.
1334
1335 **/
1336 VOID
1337 PxeBcShowIp6Addr (
1338 IN EFI_IPv6_ADDRESS *Ip
1339 )
1340 {
1341 UINTN Index;
1342
1343 for (Index = 0; Index < 16; Index++) {
1344
1345 if (Ip->Addr[Index] != 0) {
1346 AsciiPrint ("%x", Ip->Addr[Index]);
1347 }
1348 Index++;
1349 if (Index > 15) {
1350 return;
1351 }
1352 if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) {
1353 AsciiPrint ("0");
1354 }
1355 AsciiPrint ("%x", Ip->Addr[Index]);
1356 if (Index < 15) {
1357 AsciiPrint (":");
1358 }
1359 }
1360 }
1361
1362
1363 /**
1364 This function is to convert UINTN to ASCII string with the required formatting.
1365
1366 @param[in] Number Numeric value to be converted.
1367 @param[in] Buffer The pointer to the buffer for ASCII string.
1368 @param[in] Length The length of the required format.
1369
1370 **/
1371 VOID
1372 PxeBcUintnToAscDecWithFormat (
1373 IN UINTN Number,
1374 IN UINT8 *Buffer,
1375 IN INTN Length
1376 )
1377 {
1378 UINTN Remainder;
1379
1380 while (Length > 0) {
1381 Length--;
1382 Remainder = Number % 10;
1383 Number /= 10;
1384 Buffer[Length] = (UINT8) ('0' + Remainder);
1385 }
1386 }
1387
1388
1389 /**
1390 This function is to convert a UINTN to a ASCII string, and return the
1391 actual length of the buffer.
1392
1393 @param[in] Number Numeric value to be converted.
1394 @param[in] Buffer The pointer to the buffer for ASCII string.
1395
1396 @return Length The actual length of the ASCII string.
1397
1398 **/
1399 UINTN
1400 PxeBcUintnToAscDec (
1401 IN UINTN Number,
1402 IN UINT8 *Buffer
1403 )
1404 {
1405 UINTN Index;
1406 UINTN Length;
1407 CHAR8 TempStr[64];
1408
1409 Index = 63;
1410 TempStr[Index] = 0;
1411
1412 do {
1413 Index--;
1414 TempStr[Index] = (CHAR8) ('0' + (Number % 10));
1415 Number = (UINTN) (Number / 10);
1416 } while (Number != 0);
1417
1418 AsciiStrCpy ((CHAR8 *) Buffer, &TempStr[Index]);
1419
1420 Length = AsciiStrLen ((CHAR8 *) Buffer);
1421
1422 return Length;
1423 }
1424
1425
1426 /**
1427 This function is to convert unicode hex number to a UINT8.
1428
1429 @param[out] Digit The converted UINT8 for output.
1430 @param[in] Char The unicode hex number to be converted.
1431
1432 @retval EFI_SUCCESS Successfully converted the unicode hex.
1433 @retval EFI_INVALID_PARAMETER Failed to convert the unicode hex.
1434
1435 **/
1436 EFI_STATUS
1437 PxeBcUniHexToUint8 (
1438 OUT UINT8 *Digit,
1439 IN CHAR16 Char
1440 )
1441 {
1442 if ((Char >= L'0') && (Char <= L'9')) {
1443 *Digit = (UINT8) (Char - L'0');
1444 return EFI_SUCCESS;
1445 }
1446
1447 if ((Char >= L'A') && (Char <= L'F')) {
1448 *Digit = (UINT8) (Char - L'A' + 0x0A);
1449 return EFI_SUCCESS;
1450 }
1451
1452 if ((Char >= L'a') && (Char <= L'f')) {
1453 *Digit = (UINT8) (Char - L'a' + 0x0A);
1454 return EFI_SUCCESS;
1455 }
1456
1457 return EFI_INVALID_PARAMETER;
1458 }
1459
1460 /**
1461 Calculate the elapsed time.
1462
1463 @param[in] Private The pointer to PXE private data
1464
1465 **/
1466 VOID
1467 CalcElapsedTime (
1468 IN PXEBC_PRIVATE_DATA *Private
1469 )
1470 {
1471 EFI_TIME Time;
1472 UINT64 CurrentStamp;
1473 UINT64 ElapsedTimeValue;
1474
1475 //
1476 // Generate a time stamp of the centiseconds from 1900/1/1, assume 30day/month.
1477 //
1478 ZeroMem (&Time, sizeof (EFI_TIME));
1479 gRT->GetTime (&Time, NULL);
1480 CurrentStamp = (UINT64)
1481 (
1482 ((((((Time.Year - 1900) * 360 +
1483 (Time.Month - 1)) * 30 +
1484 (Time.Day - 1)) * 24 + Time.Hour) * 60 +
1485 Time.Minute) * 60 + Time.Second) * 100
1486 + DivU64x32(Time.Nanosecond, 10000000)
1487 );
1488
1489 //
1490 // Sentinel value of 0 means that this is the first DHCP packet that we are
1491 // sending and that we need to initialize the value. First DHCP Solicit
1492 // gets 0 elapsed-time. Otherwise, calculate based on StartTime.
1493 //
1494 if (Private->ElapsedTime == 0) {
1495 Private->ElapsedTime = CurrentStamp;
1496 } else {
1497 ElapsedTimeValue = CurrentStamp - Private->ElapsedTime;
1498
1499 //
1500 // If elapsed time cannot fit in two bytes, set it to 0xffff.
1501 //
1502 if (ElapsedTimeValue > 0xffff) {
1503 ElapsedTimeValue = 0xffff;
1504 }
1505 //
1506 // Save the elapsed time
1507 //
1508 Private->ElapsedTime = ElapsedTimeValue;
1509 }
1510 }
1511
EFI Development Kit II mirror for PVE