]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/Network/UefiPxeBcDxe/PxeBcDhcp.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
1. Import UEFI PxeBc module in MdeModulePkg
[mirror_edk2.git] / MdeModulePkg / Universal / Network / UefiPxeBcDxe / PxeBcDhcp.c
1 /** @file
2
3 Copyright (c) 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 PxeBcDhcp.c
15
16 Abstract:
17
18 Support for PxeBc dhcp functions
19
20
21 **/
22
23
24 #include "PxeBcImpl.h"
25
26 //
27 // This is a map from the interested DHCP4 option tags' index to the tag value.
28 //
29 UINT8 mInterestedDhcp4Tags[PXEBC_DHCP4_TAG_INDEX_MAX] = {
30 PXEBC_DHCP4_TAG_BOOTFILE_LEN,
31 PXEBC_DHCP4_TAG_VENDOR,
32 PXEBC_DHCP4_TAG_OVERLOAD,
33 PXEBC_DHCP4_TAG_MSG_TYPE,
34 PXEBC_DHCP4_TAG_SERVER_ID,
35 PXEBC_DHCP4_TAG_CLASS_ID,
36 PXEBC_DHCP4_TAG_BOOTFILE
37 };
38
39
40 /**
41 GC_NOTO: Add function description
42
43 @param Seed GC_NOTO: add argument description
44 @param Udp4 GC_NOTO: add argument description
45
46 @return GC_NOTO: add return values
47
48 **/
49 VOID
50 PxeBcInitSeedPacket (
51 IN EFI_DHCP4_PACKET *Seed,
52 IN EFI_UDP4_PROTOCOL *Udp4
53 )
54 {
55 EFI_SIMPLE_NETWORK_MODE Mode;
56 EFI_DHCP4_HEADER *Header;
57
58 Udp4->GetModeData (Udp4, NULL, NULL, NULL, &Mode);
59
60 Seed->Size = sizeof (EFI_DHCP4_PACKET);
61 Seed->Length = sizeof (Seed->Dhcp4);
62
63 Header = &Seed->Dhcp4.Header;
64
65 NetZeroMem (Header, sizeof (EFI_DHCP4_HEADER));
66 Header->OpCode = PXEBC_DHCP4_OPCODE_REQUEST;
67 Header->HwType = Mode.IfType;
68 Header->HwAddrLen = (UINT8) Mode.HwAddressSize;
69 NetCopyMem (Header->ClientHwAddr, &Mode.CurrentAddress, Header->HwAddrLen);
70
71 Seed->Dhcp4.Magik = PXEBC_DHCP4_MAGIC;
72 Seed->Dhcp4.Option[0] = PXEBC_DHCP4_TAG_EOP;
73 }
74
75
76 /**
77 GC_NOTO: Add function description
78
79 @param Dst GC_NOTO: add argument description
80 @param Src GC_NOTO: add argument description
81
82 @return GC_NOTO: add return values
83
84 **/
85 VOID
86 PxeBcCopyEfiDhcp4Packet (
87 IN EFI_DHCP4_PACKET *Dst,
88 IN EFI_DHCP4_PACKET *Src
89 )
90 {
91 ASSERT (Dst->Size >= Src->Length);
92
93 NetCopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);
94 Dst->Length = Src->Length;
95 }
96
97
98 /**
99 GC_NOTO: Add function description
100
101 @param Private GC_NOTO: add argument description
102 @param OfferIndex GC_NOTO: add argument description
103
104 @return GC_NOTO: add return values
105
106 **/
107 VOID
108 PxeBcCopyProxyOffer (
109 IN PXEBC_PRIVATE_DATA *Private,
110 IN UINT32 OfferIndex
111 )
112 {
113 EFI_PXE_BASE_CODE_MODE *Mode;
114 EFI_DHCP4_PACKET *Offer;
115
116 ASSERT (OfferIndex < Private->NumOffers);
117
118 Mode = Private->PxeBc.Mode;
119 Offer = &Private->Dhcp4Offers[OfferIndex].Packet.Offer;
120
121 PxeBcCopyEfiDhcp4Packet (&Private->ProxyOffer.Packet.Offer, Offer);
122 NetCopyMem (&Mode->ProxyOffer, &Offer->Dhcp4, Offer->Length);
123 Mode->ProxyOfferReceived = TRUE;
124
125 PxeBcParseCachedDhcpPacket (&Private->ProxyOffer);
126 }
127
128
129 /**
130 Parse the cached dhcp packet.
131
132 @param CachedPacket Pointer to cached dhcp packet
133
134 @return TRUE : Success to parse and validation
135 @return FALSE : Fail to parse or validation
136
137 **/
138 BOOLEAN
139 PxeBcParseCachedDhcpPacket (
140 IN PXEBC_CACHED_DHCP4_PACKET *CachedPacket
141 )
142 {
143 EFI_DHCP4_PACKET *Offer;
144 EFI_DHCP4_PACKET_OPTION **Options;
145 EFI_DHCP4_PACKET_OPTION *Option;
146 UINT8 OfferType;
147 UINTN Index;
148
149 CachedPacket->IsPxeOffer = FALSE;
150 NetZeroMem (CachedPacket->Dhcp4Option, sizeof (CachedPacket->Dhcp4Option));
151 NetZeroMem (&CachedPacket->PxeVendorOption, sizeof (CachedPacket->PxeVendorOption));
152
153 Offer = &CachedPacket->Packet.Offer;
154 Options = CachedPacket->Dhcp4Option;
155
156 //
157 // Parse interested dhcp options and store their pointers in CachedPacket->Dhcp4Option.
158 //
159 for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {
160 Options[Index] = PxeBcParseExtendOptions (
161 Offer->Dhcp4.Option,
162 GET_OPTION_BUFFER_LEN (Offer),
163 mInterestedDhcp4Tags[Index]
164 );
165 }
166
167 //
168 // Check whether is an offer with PXEClient or not.
169 //
170 Option = Options[PXEBC_DHCP4_TAG_INDEX_CLASS_ID];
171 if ((Option != NULL) && (Option->Length >= 9) &&
172 (NetCompareMem (Option->Data, DEFAULT_CLASS_ID_DATA, 9) == 0)) {
173
174 CachedPacket->IsPxeOffer = TRUE;
175 }
176
177 //
178 // Parse pxe vendor options and store their content/pointers in CachedPacket->PxeVendorOption.
179 //
180 Option = Options[PXEBC_DHCP4_TAG_INDEX_VENDOR];
181 if (CachedPacket->IsPxeOffer && (Option != NULL)) {
182
183 if (!PxeBcParseVendorOptions (Option, &CachedPacket->PxeVendorOption)) {
184 return FALSE;
185 }
186 }
187
188 //
189 // Check whether bootfilename/serverhostname overloaded (See details in dhcp spec).
190 // If overloaded, parse this buffer as nested dhcp options, or just parse bootfilename/
191 // serverhostname option.
192 //
193 Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];
194 if ((Option != NULL) && (Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE)) {
195
196 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseExtendOptions (
197 (UINT8 *) Offer->Dhcp4.Header.BootFileName,
198 sizeof (Offer->Dhcp4.Header.BootFileName),
199 PXEBC_DHCP4_TAG_BOOTFILE
200 );
201
202 } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&
203 (Offer->Dhcp4.Header.BootFileName[0] != 0)) {
204 //
205 // If the bootfile is not present and bootfilename is present in dhcp packet, just parse it.
206 // And do not count dhcp option header, or else will destory the serverhostname.
207 //
208 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *) (&Offer->Dhcp4.Header.BootFileName[0] -
209 EFI_FIELD_OFFSET (EFI_DHCP4_PACKET_OPTION, Data[0]));
210
211 }
212
213 //
214 // Determine offer type of the dhcp packet.
215 //
216 Option = Options[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE];
217 if ((Option == NULL) || (Option->Data[0] == 0)) {
218 //
219 // It's a bootp offer
220 //
221 Option = CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE];
222 if (Option == NULL) {
223 //
224 // bootp offer without bootfilename, discard it.
225 //
226 return FALSE;
227 }
228
229 OfferType = DHCP4_PACKET_TYPE_BOOTP;
230
231 } else {
232
233 if (IS_VALID_DISCOVER_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
234 //
235 // It's a pxe10 offer with PXEClient and discover vendor option.
236 //
237 OfferType = DHCP4_PACKET_TYPE_PXE10;
238 } else if (IS_VALID_MTFTP_VENDOR_OPTION (CachedPacket->PxeVendorOption.BitMap)) {
239 //
240 // It's a wfm11a offer with PXEClient and mtftp vendor option, and
241 // return false since mtftp not supported currently.
242 //
243 return FALSE;
244 #if 0
245 //
246 // WFM11A, make sure bootfile is present
247 //
248 if (CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {
249 //
250 // Discard this offer.
251 //
252 return ;
253 }
254
255 OfferType = DHCP4_PACKET_TYPE_WFM11A;
256 #endif
257 } else {
258 //
259 // If the binl offer with only PXEClient.
260 //
261 OfferType = (UINT8) ((CachedPacket->IsPxeOffer) ? DHCP4_PACKET_TYPE_BINL : DHCP4_PACKET_TYPE_DHCP_ONLY);
262 }
263 }
264
265 CachedPacket->OfferType = OfferType;
266
267 return TRUE;
268 }
269
270
271 /**
272 GC_NOTO: Add function description
273
274 @param Private GC_NOTO: add argument description
275 @param Index GC_NOTO: add argument description
276
277 @return GC_NOTO: add return values
278
279 **/
280 BOOLEAN
281 PxeBcTryBinl (
282 IN PXEBC_PRIVATE_DATA *Private,
283 IN UINT32 Index
284 )
285 {
286 EFI_DHCP4_PACKET *Offer;
287 EFI_IP_ADDRESS ServerIp;
288 EFI_STATUS Status;
289 PXEBC_CACHED_DHCP4_PACKET *CachedPacket;
290 EFI_DHCP4_PACKET *Reply;
291
292 ASSERT (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL);
293
294 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
295 if (Offer->Dhcp4.Header.ServerAddr.Addr[0] == 0) {
296 //
297 // next server ip address is zero, use server id option instead.
298 //
299 NetCopyMem (
300 &ServerIp.Addr[0],
301 Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,
302 sizeof (EFI_IPv4_ADDRESS)
303 );
304 } else {
305 //
306 // use next server ip address.
307 //
308 NetCopyMem (&ServerIp.Addr[0], &Offer->Dhcp4.Header.ServerAddr, sizeof (EFI_IPv4_ADDRESS));
309 }
310
311 CachedPacket = &Private->ProxyOffer;
312 Reply = &CachedPacket->Packet.Offer;
313
314 Status = PxeBcDiscvBootService (
315 Private,
316 0,
317 NULL,
318 FALSE,
319 &ServerIp,
320 0,
321 NULL,
322 FALSE,
323 Reply
324 );
325 if (EFI_ERROR (Status)) {
326 return FALSE;
327 }
328
329 if (!PxeBcParseCachedDhcpPacket (CachedPacket)) {
330 return FALSE;
331 }
332
333 if ((CachedPacket->OfferType != DHCP4_PACKET_TYPE_PXE10) &&
334 (CachedPacket->Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {
335 //
336 // This BINL ack doesn't have discovery options set or bootfile name
337 // specified.
338 //
339 return FALSE;
340 }
341
342 Private->PxeBc.Mode->ProxyOfferReceived = TRUE;
343 NetCopyMem (&Private->PxeBc.Mode->ProxyOffer, &Reply->Dhcp4, Reply->Length);
344
345 return TRUE;
346 }
347
348
349 /**
350 GC_NOTO: Add function description
351
352 @param Private GC_NOTO: add argument description
353 @param OfferIndex GC_NOTO: add argument description
354
355 @return GC_NOTO: add return values
356
357 **/
358 BOOLEAN
359 PxeBcTryBinlProxy (
360 IN PXEBC_PRIVATE_DATA *Private,
361 OUT UINT32 *OfferIndex
362 )
363 {
364 UINT32 Index;
365
366 for (Index = 0; Index < Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]; Index++) {
367
368 *OfferIndex = Private->BinlIndex[Index];
369 //
370 // Try this BINL proxy offer
371 //
372 if (PxeBcTryBinl (Private, *OfferIndex)) {
373 return TRUE;
374 }
375 }
376
377 return FALSE;
378 }
379
380
381 /**
382 GC_NOTO: Add function description
383
384 @param Private GC_NOTO: add argument description
385
386 @return GC_NOTO: add return values
387
388 **/
389 EFI_STATUS
390 PxeBcCheckSelectedOffer (
391 IN PXEBC_PRIVATE_DATA *Private
392 )
393 {
394 PXEBC_CACHED_DHCP4_PACKET *SelectedOffer;
395 EFI_DHCP4_PACKET_OPTION **Options;
396 UINT32 Index;
397 EFI_DHCP4_PACKET *Offer;
398 UINT32 ProxyOfferIndex;
399 EFI_STATUS Status;
400 EFI_PXE_BASE_CODE_MODE *Mode;
401 EFI_DHCP4_PACKET *Ack;
402
403 ASSERT (Private->SelectedOffer != 0);
404
405 Status = EFI_SUCCESS;
406 SelectedOffer = &Private->Dhcp4Offers[Private->SelectedOffer - 1];
407 Options = SelectedOffer->Dhcp4Option;
408
409 if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BINL) {
410 //
411 // The addresses are acquired from a BINL dhcp offer, try BINL to get
412 // the bootfile name
413 //
414 if (!PxeBcTryBinl (Private, Private->SelectedOffer - 1)) {
415 Status = EFI_NO_RESPONSE;
416 }
417 } else if ((SelectedOffer->OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&
418 (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL)) {
419 //
420 // The selected offer to finish the D.O.R.A. is a DHCP only offer and
421 // bootfile name is not provided in this offer, we need try proxy offers
422 // to get the bootfile name or the discovery info
423 //
424 ProxyOfferIndex = Private->NumOffers;
425
426 if (Private->SortOffers) {
427 //
428 // Choose proxy offer from the type we stored during DHCP offer selection
429 //
430 ASSERT (Private->ProxyIndex[Private->ProxyOfferType] > 0);
431
432 if (Private->ProxyOfferType == DHCP4_PACKET_TYPE_BINL) {
433 //
434 // We buffer all received BINL proxy offers, try them all one by one
435 //
436 if (!PxeBcTryBinlProxy (Private, &ProxyOfferIndex)) {
437 Status = EFI_NO_RESPONSE;
438 }
439 } else {
440 //
441 // For other types, only one proxy offer is buffered.
442 //
443 ProxyOfferIndex = Private->ProxyIndex[Private->ProxyOfferType] - 1;
444 }
445 } else {
446 //
447 // Choose proxy offer in the received order.
448 //
449 Status = EFI_NO_RESPONSE;
450
451 for (Index = 0; Index < Private->NumOffers; Index++) {
452
453 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
454 if (!IS_PROXY_DHCP_OFFER (Offer)) {
455 //
456 // Skip non proxy dhcp offers.
457 //
458 continue;
459 }
460
461 if (Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_BINL) {
462 //
463 // Try BINL
464 //
465 if (!PxeBcTryBinl (Private, Index)) {
466 //
467 // Failed, skip to the next offer
468 //
469 continue;
470 }
471 }
472
473 Status = EFI_SUCCESS;
474 break;
475 }
476 }
477
478 if (!EFI_ERROR (Status) && (Private->ProxyOfferType != DHCP4_PACKET_TYPE_BINL)) {
479 //
480 // Copy the proxy offer to Mode and set the flag
481 //
482 PxeBcCopyProxyOffer (Private, ProxyOfferIndex);
483 }
484 }
485
486 if (!EFI_ERROR (Status)) {
487 //
488 // Everything is OK, set the flag and copy the DHCP packets.
489 //
490 Mode = Private->PxeBc.Mode;
491 Offer = &SelectedOffer->Packet.Offer;
492
493 //
494 // The discover packet is already copied, just set flag here.
495 //
496 Mode->DhcpDiscoverValid = TRUE;
497
498 Ack = &Private->Dhcp4Ack.Packet.Ack;
499 if (SelectedOffer->OfferType == DHCP4_PACKET_TYPE_BOOTP) {
500 //
501 // Other type of ACK is already cached. Bootp is special that we should
502 // use the bootp reply as the ACK and put it into the DHCP_ONLY buffer.
503 //
504 PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Offer);
505 }
506
507 PxeBcParseCachedDhcpPacket (&Private->Dhcp4Ack);
508
509 Mode->DhcpAckReceived = TRUE;
510
511 //
512 // Copy the dhcp ack.
513 //
514 NetCopyMem (&Mode->DhcpAck, &Ack->Dhcp4, Ack->Length);
515 }
516
517 return Status;
518 }
519
520
521 /**
522 GC_NOTO: Add function description
523
524 @param Private GC_NOTO: add argument description
525 @param RcvdOffer GC_NOTO: add argument description
526
527 @return GC_NOTO: add return values
528
529 **/
530 VOID
531 PxeBcCacheDhcpOffer (
532 IN PXEBC_PRIVATE_DATA *Private,
533 IN EFI_DHCP4_PACKET *RcvdOffer
534 )
535 {
536 PXEBC_CACHED_DHCP4_PACKET *CachedOffer;
537 EFI_DHCP4_PACKET *Offer;
538 UINT8 OfferType;
539
540 CachedOffer = &Private->Dhcp4Offers[Private->NumOffers];
541 Offer = &CachedOffer->Packet.Offer;
542
543 //
544 // Cache the orignal dhcp packet
545 //
546 PxeBcCopyEfiDhcp4Packet (Offer, RcvdOffer);
547
548 //
549 // Parse and validate the options (including dhcp option and vendor option)
550 //
551 if (!PxeBcParseCachedDhcpPacket (CachedOffer)) {
552 return ;
553 }
554
555 OfferType = CachedOffer->OfferType;
556
557 if (OfferType == DHCP4_PACKET_TYPE_BOOTP) {
558
559 if (Private->BootpIndex != 0) {
560 //
561 // Only cache the first bootp offer, discard others.
562 //
563 return ;
564 } else {
565 //
566 // Take as a dhcp only offer, but record index specifically.
567 //
568 Private->BootpIndex = Private->NumOffers + 1;
569 }
570 } else {
571
572 if (IS_PROXY_DHCP_OFFER (Offer)) {
573 //
574 // It's a proxy dhcp offer with no your address, including pxe10, wfm11a or binl offer.
575 //
576 if (OfferType == DHCP4_PACKET_TYPE_BINL) {
577 //
578 // Cache all binl offers.
579 //
580 Private->BinlIndex[Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]] = Private->NumOffers;
581 Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL]++;
582 } else if (Private->ProxyIndex[OfferType] != 0) {
583 //
584 // Only cache the first pxe10/wfm11a offers each, discard the others.
585 //
586 return ;
587 } else {
588 //
589 // Record index of the proxy dhcp offer with type other than binl.
590 //
591 Private->ProxyIndex[OfferType] = Private->NumOffers + 1;
592 }
593 } else {
594 //
595 // It's a dhcp offer with your address.
596 //
597 Private->OfferIndex[OfferType][Private->ServerCount[OfferType]] = Private->NumOffers;
598 Private->ServerCount[OfferType]++;
599 }
600 }
601
602 //
603 // Count the accepted offers.
604 //
605 Private->NumOffers++;
606 }
607
608
609 /**
610 GC_NOTO: Add function description
611
612 @param Private GC_NOTO: add argument description
613
614 @return GC_NOTO: add return values
615
616 **/
617 VOID
618 PxeBcSelectOffer (
619 IN PXEBC_PRIVATE_DATA *Private
620 )
621 {
622 UINT32 Index;
623 UINT32 OfferIndex;
624 EFI_DHCP4_PACKET *Offer;
625 BOOLEAN GotProxyOffer;
626
627 Private->SelectedOffer = 0;
628
629 if (Private->SortOffers) {
630 //
631 // Select offer according to the priority
632 //
633 if (Private->ServerCount[DHCP4_PACKET_TYPE_PXE10] > 0) {
634 //
635 // DHCP with PXE10
636 //
637 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_PXE10][0] + 1;
638
639 } else if (Private->ServerCount[DHCP4_PACKET_TYPE_WFM11A] > 0) {
640 //
641 // DHCP with WfM
642 //
643 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_WFM11A][0] + 1;
644
645 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_PXE10] > 0) &&
646 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
647 ) {
648 //
649 // DHCP only and proxy DHCP with PXE10
650 //
651 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
652 Private->ProxyOfferType = DHCP4_PACKET_TYPE_PXE10;
653
654 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_WFM11A] > 0) &&
655 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
656 ) {
657 //
658 // DHCP only and proxy DHCP with WfM
659 //
660 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
661 Private->ProxyOfferType = DHCP4_PACKET_TYPE_WFM11A;
662
663 } else if (Private->ServerCount[DHCP4_PACKET_TYPE_BINL] > 0) {
664 //
665 // DHCP with BINL
666 //
667 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_BINL][0] + 1;
668
669 } else if ((Private->ProxyIndex[DHCP4_PACKET_TYPE_BINL] > 0) &&
670 (Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY] > 0)
671 ) {
672 //
673 // DHCP only and proxy DHCP with BINL
674 //
675 Private->SelectedOffer = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][0] + 1;
676 Private->ProxyOfferType = DHCP4_PACKET_TYPE_BINL;
677
678 } else {
679 //
680 // Try offers with bootfile
681 //
682 for (Index = 0; Index < Private->ServerCount[DHCP4_PACKET_TYPE_DHCP_ONLY]; Index++) {
683 //
684 // Select the first DHCP only offer with bootfile
685 //
686 OfferIndex = Private->OfferIndex[DHCP4_PACKET_TYPE_DHCP_ONLY][Index];
687 if (Private->Dhcp4Offers[OfferIndex].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
688 Private->SelectedOffer = OfferIndex + 1;
689 break;
690 }
691 }
692
693 if (Private->SelectedOffer == 0) {
694 //
695 // Select the Bootp reply with bootfile if any
696 //
697 Private->SelectedOffer = Private->BootpIndex;
698 }
699 }
700 } else {
701 //
702 // Try the offers in the received order.
703 //
704 GotProxyOffer = FALSE;
705 for (Index = 0; Index < DHCP4_PACKET_TYPE_MAX; Index++) {
706
707 GotProxyOffer = (BOOLEAN) (Private->ProxyIndex[Index] > 0);
708 if (GotProxyOffer) {
709 break;
710 }
711 }
712
713 for (Index = 0; Index < Private->NumOffers; Index++) {
714
715 Offer = &Private->Dhcp4Offers[Index].Packet.Offer;
716
717 if (IS_PROXY_DHCP_OFFER (Offer)) {
718 //
719 // Skip proxy offers
720 //
721 continue;
722 }
723
724 if ((Private->Dhcp4Offers[Index].OfferType == DHCP4_PACKET_TYPE_DHCP_ONLY) &&
725 ((!GotProxyOffer) && (Private->Dhcp4Offers[Index].Dhcp4Option[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL))) {
726 //
727 // DHCP only offer but no proxy offer received and no bootfile option in this offer
728 //
729 continue;
730 }
731
732 Private->SelectedOffer = Index + 1;
733 break;
734 }
735 }
736 }
737
738
739 /**
740 GC_NOTO: Add function description
741
742 @param This GC_NOTO: add argument description
743 @param Context GC_NOTO: add argument description
744 @param CurrentState GC_NOTO: add argument description
745 @param Dhcp4Event GC_NOTO: add argument description
746 @param Packet GC_NOTO: add argument description
747 @param NewPacket GC_NOTO: add argument description
748
749 @retval EFI_SUCCESS GC_NOTO: Add description for return value
750 @retval EFI_ABORTED GC_NOTO: Add description for return value
751
752 **/
753 EFI_STATUS
754 PxeBcDhcpCallBack (
755 IN EFI_DHCP4_PROTOCOL * This,
756 IN VOID *Context,
757 IN EFI_DHCP4_STATE CurrentState,
758 IN EFI_DHCP4_EVENT Dhcp4Event,
759 IN EFI_DHCP4_PACKET * Packet OPTIONAL,
760 OUT EFI_DHCP4_PACKET **NewPacket OPTIONAL
761 )
762 {
763 PXEBC_PRIVATE_DATA *Private;
764 EFI_PXE_BASE_CODE_MODE *Mode;
765 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;
766 EFI_DHCP4_PACKET_OPTION *MaxMsgSize;
767 UINT16 Value;
768 EFI_STATUS Status;
769 BOOLEAN Received;
770
771 if ((Dhcp4Event != Dhcp4RcvdOffer) &&
772 (Dhcp4Event != Dhcp4SelectOffer) &&
773 (Dhcp4Event != Dhcp4SendDiscover) &&
774 (Dhcp4Event != Dhcp4RcvdAck)) {
775 return EFI_SUCCESS;
776 }
777
778 Private = (PXEBC_PRIVATE_DATA *) Context;
779 Mode = Private->PxeBc.Mode;
780 Callback = Private->PxeBcCallback;
781
782 //
783 // Override the Maximum DHCP Message Size.
784 //
785 MaxMsgSize = PxeBcParseExtendOptions (
786 Packet->Dhcp4.Option,
787 GET_OPTION_BUFFER_LEN (Packet),
788 PXEBC_DHCP4_TAG_MAXMSG
789 );
790 if (MaxMsgSize != NULL) {
791 Value = HTONS (PXEBC_DHCP4_MAX_PACKET_SIZE);
792 NetCopyMem (MaxMsgSize->Data, &Value, sizeof (Value));
793 }
794
795 if ((Dhcp4Event != Dhcp4SelectOffer) && (Callback != NULL)) {
796 Received = (BOOLEAN) ((Dhcp4Event == Dhcp4RcvdOffer) || (Dhcp4Event == Dhcp4RcvdAck));
797 Status = Callback->Callback (
798 Callback,
799 Private->Function,
800 Received,
801 Packet->Length,
802 (EFI_PXE_BASE_CODE_PACKET *) &Packet->Dhcp4
803 );
804 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {
805 return EFI_ABORTED;
806 }
807 }
808
809 Status = EFI_SUCCESS;
810
811 switch (Dhcp4Event) {
812
813 case Dhcp4SendDiscover:
814 //
815 // Cache the dhcp discover packet, of which some information will be used later.
816 //
817 NetCopyMem (Mode->DhcpDiscover.Raw, &Packet->Dhcp4, Packet->Length);
818
819 break;
820
821 case Dhcp4RcvdOffer:
822 Status = EFI_NOT_READY;
823 if (Private->NumOffers < PXEBC_MAX_OFFER_NUM) {
824 //
825 // Cache the dhcp offers in Private->Dhcp4Offers[]
826 //
827 PxeBcCacheDhcpOffer (Private, Packet);
828 }
829
830 break;
831
832 case Dhcp4SelectOffer:
833 //
834 // Select an offer, if succeeded, Private->SelectedOffer points to
835 // the index of the selected one.
836 //
837 PxeBcSelectOffer (Private);
838
839 if (Private->SelectedOffer == 0) {
840 Status = EFI_ABORTED;
841 } else {
842 *NewPacket = &Private->Dhcp4Offers[Private->SelectedOffer - 1].Packet.Offer;
843 }
844
845 break;
846
847 case Dhcp4RcvdAck:
848 //
849 // Cache Ack
850 //
851 ASSERT (Private->SelectedOffer != 0);
852
853 PxeBcCopyEfiDhcp4Packet (&Private->Dhcp4Ack.Packet.Ack, Packet);
854 break;
855 }
856
857 return Status;
858 }
859
860
861 /**
862 GC_NOTO: Add function description
863
864 @param Private GC_NOTO: add argument description
865 @param OptList GC_NOTO: add argument description
866 @param IsDhcpDiscover GC_NOTO: add argument description
867
868 @return GC_NOTO: add return values
869
870 **/
871 UINT32
872 PxeBcBuildDhcpOptions (
873 IN PXEBC_PRIVATE_DATA *Private,
874 IN EFI_DHCP4_PACKET_OPTION **OptList,
875 IN BOOLEAN IsDhcpDiscover
876 )
877 {
878 UINT32 Index;
879 PXEBC_DHCP4_OPTION_ENTRY OptEnt;
880 UINT16 Value;
881 CHAR8 *SystemSerialNumber;
882
883 Index = 0;
884 OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Private->OptionBuffer;
885
886 if (!IsDhcpDiscover) {
887 //
888 // Append message type.
889 //
890 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MSG_TYPE;
891 OptList[Index]->Length = 1;
892 OptEnt.Mesg = (PXEBC_DHCP4_OPTION_MESG *) OptList[Index]->Data;
893 OptEnt.Mesg->Type = PXEBC_DHCP4_MSG_TYPE_REQUEST;
894 Index++;
895 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
896
897 //
898 // Append max message size.
899 //
900 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MAXMSG;
901 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);
902 OptEnt.MaxMesgSize = (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE *) OptList[Index]->Data;
903 Value = NTOHS (PXEBC_DHCP4_MAX_PACKET_SIZE);
904 NetCopyMem (&OptEnt.MaxMesgSize->Size, &Value, sizeof (UINT16));
905 Index++;
906 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
907 }
908 //
909 // Parameter request list option.
910 //
911 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_PARA_LIST;
912 OptList[Index]->Length = 35;
913 OptEnt.Para = (PXEBC_DHCP4_OPTION_PARA *) OptList[Index]->Data;
914 OptEnt.Para->ParaList[0] = PXEBC_DHCP4_TAG_NETMASK;
915 OptEnt.Para->ParaList[1] = PXEBC_DHCP4_TAG_TIME_OFFSET;
916 OptEnt.Para->ParaList[2] = PXEBC_DHCP4_TAG_ROUTER;
917 OptEnt.Para->ParaList[3] = PXEBC_DHCP4_TAG_TIME_SERVER;
918 OptEnt.Para->ParaList[4] = PXEBC_DHCP4_TAG_NAME_SERVER;
919 OptEnt.Para->ParaList[5] = PXEBC_DHCP4_TAG_DNS_SERVER;
920 OptEnt.Para->ParaList[6] = PXEBC_DHCP4_TAG_HOSTNAME;
921 OptEnt.Para->ParaList[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN;
922 OptEnt.Para->ParaList[8] = PXEBC_DHCP4_TAG_DOMAINNAME;
923 OptEnt.Para->ParaList[9] = PXEBC_DHCP4_TAG_ROOTPATH;
924 OptEnt.Para->ParaList[10] = PXEBC_DHCP4_TAG_EXTEND_PATH;
925 OptEnt.Para->ParaList[11] = PXEBC_DHCP4_TAG_EMTU;
926 OptEnt.Para->ParaList[12] = PXEBC_DHCP4_TAG_TTL;
927 OptEnt.Para->ParaList[13] = PXEBC_DHCP4_TAG_BROADCAST;
928 OptEnt.Para->ParaList[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN;
929 OptEnt.Para->ParaList[15] = PXEBC_DHCP4_TAG_NIS_SERVER;
930 OptEnt.Para->ParaList[16] = PXEBC_DHCP4_TAG_NTP_SERVER;
931 OptEnt.Para->ParaList[17] = PXEBC_DHCP4_TAG_VENDOR;
932 OptEnt.Para->ParaList[18] = PXEBC_DHCP4_TAG_REQUEST_IP;
933 OptEnt.Para->ParaList[19] = PXEBC_DHCP4_TAG_LEASE;
934 OptEnt.Para->ParaList[20] = PXEBC_DHCP4_TAG_SERVER_ID;
935 OptEnt.Para->ParaList[21] = PXEBC_DHCP4_TAG_T1;
936 OptEnt.Para->ParaList[22] = PXEBC_DHCP4_TAG_T2;
937 OptEnt.Para->ParaList[23] = PXEBC_DHCP4_TAG_CLASS_ID;
938 OptEnt.Para->ParaList[24] = PXEBC_DHCP4_TAG_TFTP;
939 OptEnt.Para->ParaList[25] = PXEBC_DHCP4_TAG_BOOTFILE;
940 OptEnt.Para->ParaList[26] = PXEBC_PXE_DHCP4_TAG_UUID;
941 OptEnt.Para->ParaList[27] = 0x80;
942 OptEnt.Para->ParaList[28] = 0x81;
943 OptEnt.Para->ParaList[29] = 0x82;
944 OptEnt.Para->ParaList[30] = 0x83;
945 OptEnt.Para->ParaList[31] = 0x84;
946 OptEnt.Para->ParaList[32] = 0x85;
947 OptEnt.Para->ParaList[33] = 0x86;
948 OptEnt.Para->ParaList[34] = 0x87;
949 Index++;
950 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
951
952 //
953 // Append UUID/Guid-based client identifier option
954 //
955 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UUID;
956 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UUID);
957 OptEnt.Uuid = (PXEBC_DHCP4_OPTION_UUID *) OptList[Index]->Data;
958 OptEnt.Uuid->Type = 0;
959 Index++;
960 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
961
962 if (EFI_ERROR (GetSmbiosSystemGuidAndSerialNumber ((EFI_GUID *) OptEnt.Uuid->Guid, &SystemSerialNumber))) {
963 //
964 // GUID not yet set - send all 0xff's to show programable (via SetVariable)
965 // SetMem(DHCPV4_OPTIONS_BUFFER.DhcpPlatformId.Guid, sizeof(EFI_GUID), 0xff);
966 // GUID not yet set - send all 0's to show not programable
967 //
968 ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));
969 }
970
971 //
972 // Append client network device interface option
973 //
974 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UNDI;
975 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_UNDI);
976 OptEnt.Undi = (PXEBC_DHCP4_OPTION_UNDI *) OptList[Index]->Data;
977 OptEnt.Undi->Type = Private->Nii->Type;
978 OptEnt.Undi->MajorVer = Private->Nii->MajorVer;
979 OptEnt.Undi->MinorVer = Private->Nii->MinorVer;
980
981 Index++;
982 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
983
984 //
985 // Append client system architecture option
986 //
987 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_ARCH;
988 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_ARCH);
989 OptEnt.Arch = (PXEBC_DHCP4_OPTION_ARCH *) OptList[Index]->Data;
990 Value = HTONS (SYS_ARCH);
991 NetCopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));
992 Index++;
993 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
994
995 //
996 // Append client system architecture option
997 //
998 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_CLASS_ID;
999 OptList[Index]->Length = sizeof (PXEBC_DHCP4_OPTION_CLID);
1000 OptEnt.Clid = (PXEBC_DHCP4_OPTION_CLID *) OptList[Index]->Data;
1001 NetCopyMem (OptEnt.Clid, DEFAULT_CLASS_ID_DATA, sizeof (PXEBC_DHCP4_OPTION_CLID));
1002 CvtNum (SYS_ARCH, OptEnt.Clid->ArchitectureType, sizeof (OptEnt.Clid->ArchitectureType));
1003 NetCopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));
1004 CvtNum (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));
1005 CvtNum (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));
1006 Index++;
1007
1008 return Index;
1009 }
1010
1011
1012 /**
1013 GC_NOTO: Add function description
1014
1015 @param Private GC_NOTO: add argument description
1016 @param Type GC_NOTO: add argument description
1017 @param Layer GC_NOTO: add argument description
1018 @param UseBis GC_NOTO: add argument description
1019 @param DestIp GC_NOTO: add argument description
1020 @param IpCount GC_NOTO: add argument description
1021 @param SrvList GC_NOTO: add argument description
1022 @param IsDiscv GC_NOTO: add argument description
1023 @param Reply GC_NOTO: add argument description
1024
1025 @retval EFI_OUT_OF_RESOURCES GC_NOTO: Add description for return value
1026
1027 **/
1028 EFI_STATUS
1029 PxeBcDiscvBootService (
1030 IN PXEBC_PRIVATE_DATA * Private,
1031 IN UINT16 Type,
1032 IN UINT16 *Layer,
1033 IN BOOLEAN UseBis,
1034 IN EFI_IP_ADDRESS * DestIp,
1035 IN UINT16 IpCount,
1036 IN EFI_PXE_BASE_CODE_SRVLIST * SrvList,
1037 IN BOOLEAN IsDiscv,
1038 OUT EFI_DHCP4_PACKET * Reply OPTIONAL
1039 )
1040 {
1041 EFI_PXE_BASE_CODE_UDP_PORT Sport;
1042 EFI_PXE_BASE_CODE_MODE *Mode;
1043 EFI_DHCP4_PROTOCOL *Dhcp4;
1044 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token;
1045 BOOLEAN IsBCast;
1046 EFI_STATUS Status;
1047 UINT16 RepIndex;
1048 UINT16 SrvIndex;
1049 UINT16 TryIndex;
1050 EFI_DHCP4_LISTEN_POINT ListenPoint;
1051 EFI_DHCP4_PACKET *Response;
1052 EFI_DHCP4_PACKET_OPTION *OptList[PXEBC_DHCP4_MAX_OPTION_NUM];
1053 UINT32 OptCount;
1054 EFI_DHCP4_PACKET_OPTION *PxeOpt;
1055 PXEBC_OPTION_BOOT_ITEM *PxeBootItem;
1056 UINT8 VendorOptLen;
1057
1058 Mode = Private->PxeBc.Mode;
1059 Dhcp4 = Private->Dhcp4;
1060 Status = EFI_SUCCESS;
1061
1062 ZeroMem (&Token, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN));
1063
1064 if (DestIp == NULL) {
1065 Sport = PXEBC_DHCP4_S_PORT;
1066 IsBCast = TRUE;
1067 } else {
1068 Sport = PXEBC_BS_DISCOVER_PORT;
1069 IsBCast = FALSE;
1070 }
1071
1072 if (!UseBis && Layer != NULL) {
1073 *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;
1074 }
1075
1076 OptCount = PxeBcBuildDhcpOptions (Private, OptList, FALSE);
1077
1078 if (IsDiscv) {
1079 //
1080 // Add vendor option of PXE_BOOT_ITEM
1081 //
1082 VendorOptLen = (sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1;
1083 OptList[OptCount] = NetAllocatePool (VendorOptLen);
1084 if (OptList[OptCount] == NULL) {
1085 return EFI_OUT_OF_RESOURCES;
1086 }
1087
1088 OptList[OptCount]->OpCode = PXEBC_DHCP4_TAG_VENDOR;
1089 OptList[OptCount]->Length = (UINT8) (VendorOptLen - 2);
1090 PxeOpt = (EFI_DHCP4_PACKET_OPTION *) OptList[OptCount]->Data;
1091 PxeOpt->OpCode = PXEBC_VENDOR_TAG_BOOT_ITEM;
1092 PxeOpt->Length = sizeof (PXEBC_OPTION_BOOT_ITEM);
1093 PxeBootItem = (PXEBC_OPTION_BOOT_ITEM *) PxeOpt->Data;
1094 PxeBootItem->Type = HTONS (Type);
1095 PxeBootItem->Layer = HTONS (*Layer);
1096 PxeOpt->Data[PxeOpt->Length] = PXEBC_DHCP4_TAG_EOP;
1097
1098 OptCount++;
1099 }
1100
1101 Status = Dhcp4->Build (Dhcp4, &Private->SeedPacket, 0, NULL, OptCount, OptList, &Token.Packet);
1102
1103 if (IsDiscv) {
1104 NetFreePool (OptList[OptCount - 1]);
1105 }
1106
1107 if (EFI_ERROR (Status)) {
1108 return Status;
1109 }
1110
1111 Token.Packet->Dhcp4.Header.Xid = NET_RANDOM (NetRandomInitSeed ());
1112 Token.Packet->Dhcp4.Header.Reserved = (UINT16) ((IsBCast) ? 0xf000 : 0x0);
1113 NetCopyMem (&Token.Packet->Dhcp4.Header.ClientAddr, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));
1114
1115 Token.RemotePort = Sport;
1116
1117 if (DestIp == NULL) {
1118 NetSetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);
1119 } else {
1120 NetCopyMem (&Token.RemoteAddress, DestIp, sizeof (EFI_IPv4_ADDRESS));
1121 }
1122
1123 NetCopyMem (&Token.GatewayAddress, &Private->GatewayIp, sizeof (EFI_IPv4_ADDRESS));
1124
1125 if (!IsBCast) {
1126 Token.ListenPointCount = 1;
1127 Token.ListenPoints = &ListenPoint;
1128 Token.ListenPoints[0].ListenPort = PXEBC_BS_DISCOVER_PORT;
1129 NetCopyMem (&Token.ListenPoints[0].ListenAddress, &Private->StationIp, sizeof(EFI_IPv4_ADDRESS));
1130 NetCopyMem (&Token.ListenPoints[0].SubnetMask, &Private->SubnetMask, sizeof(EFI_IPv4_ADDRESS));
1131 }
1132 //
1133 // Send Pxe Discover
1134 //
1135 for (TryIndex = 1; TryIndex <= PXEBC_BOOT_REQUEST_RETRIES; TryIndex++) {
1136
1137 Token.TimeoutValue = PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex;
1138
1139 Status = Dhcp4->TransmitReceive (Dhcp4, &Token);
1140
1141 if (Token.Status != EFI_TIMEOUT) {
1142 break;
1143 }
1144 }
1145
1146 if (!EFI_ERROR (Status)) {
1147 //
1148 // Find Pxe Reply
1149 //
1150 RepIndex = 0;
1151 SrvIndex = 0;
1152 Response = Token.ResponseList;
1153
1154 while (RepIndex < Token.ResponseCount) {
1155
1156 while (SrvIndex < IpCount) {
1157
1158 if (SrvList[SrvIndex].AcceptAnyResponse) {
1159 break;
1160 }
1161
1162 if ((SrvList[SrvIndex].Type == Type) && EFI_IP4_EQUAL (&(Response->Dhcp4.Header.ServerAddr), &(Private->ServerIp))) {
1163 break;
1164 }
1165
1166 SrvIndex++;
1167 }
1168
1169 if ((IpCount != SrvIndex) || (IpCount == 0)) {
1170 break;
1171 }
1172
1173 SrvIndex = 0;
1174 RepIndex++;
1175
1176 Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);
1177 }
1178
1179 if (RepIndex < Token.ResponseCount) {
1180
1181 if (Reply != NULL) {
1182 PxeBcCopyEfiDhcp4Packet (Reply, Response);
1183 }
1184
1185 if (IsDiscv) {
1186 NetCopyMem (&(Mode->PxeDiscover), &(Token.Packet->Dhcp4), Token.Packet->Length);
1187 Mode->PxeDiscoverValid = TRUE;
1188
1189 NetCopyMem (Mode->PxeReply.Raw, &Response->Dhcp4, Response->Length);
1190 Mode->PxeReplyReceived = TRUE;
1191 }
1192 } else {
1193 Status = EFI_NOT_FOUND;
1194 }
1195
1196 //
1197 // free the responselist
1198 //
1199 NetFreePool (Token.ResponseList);
1200 }
1201 //
1202 // Free the dhcp packet
1203 //
1204 NetFreePool (Token.Packet);
1205
1206 return Status;
1207 }
1208
1209
1210 /**
1211 GC_NOTO: Add function description
1212
1213 @param Buffer GC_NOTO: add argument description
1214 @param Length GC_NOTO: add argument description
1215 @param OptTag GC_NOTO: add argument description
1216
1217 @return GC_NOTO: add return values
1218
1219 **/
1220 EFI_DHCP4_PACKET_OPTION *
1221 PxeBcParseExtendOptions (
1222 IN UINT8 *Buffer,
1223 IN UINT32 Length,
1224 IN UINT8 OptTag
1225 )
1226 {
1227 EFI_DHCP4_PACKET_OPTION *Option;
1228 UINT32 Offset;
1229
1230 Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;
1231 Offset = 0;
1232
1233 while (Offset < Length && Option->OpCode != PXEBC_DHCP4_TAG_EOP) {
1234
1235 if (Option->OpCode == OptTag) {
1236
1237 return Option;
1238 }
1239
1240 if (Option->OpCode == PXEBC_DHCP4_TAG_PAD) {
1241 Offset++;
1242 } else {
1243 Offset += Option->Length + 2;
1244 }
1245
1246 Option = (EFI_DHCP4_PACKET_OPTION *) (Buffer + Offset);
1247 }
1248
1249 return NULL;
1250 }
1251
1252
1253 /**
1254 This function is to parse and check vendor options.
1255
1256 @param Dhcp4Option Pointer to dhcp options
1257 @param VendorOption Pointer to vendor options
1258
1259 @return TRUE : Valid vendor options
1260 @return FALSE : Invalid vendor options
1261
1262 **/
1263 BOOLEAN
1264 PxeBcParseVendorOptions (
1265 IN EFI_DHCP4_PACKET_OPTION *Dhcp4Option,
1266 IN PXEBC_VENDOR_OPTION *VendorOption
1267 )
1268 {
1269 UINT32 *BitMap;
1270 UINT8 VendorOptionLen;
1271 EFI_DHCP4_PACKET_OPTION *PxeOption;
1272 UINT8 Offset;
1273
1274 BitMap = VendorOption->BitMap;
1275 VendorOptionLen = Dhcp4Option->Length;
1276 PxeOption = (EFI_DHCP4_PACKET_OPTION *) &Dhcp4Option->Data[0];
1277 Offset = 0;
1278
1279 while ((Offset < VendorOptionLen) && (PxeOption->OpCode != PXEBC_DHCP4_TAG_EOP)) {
1280 //
1281 // Parse every Vendor Option and set its BitMap
1282 //
1283 switch (PxeOption->OpCode) {
1284
1285 case PXEBC_VENDOR_TAG_MTFTP_IP:
1286
1287 NetCopyMem (&VendorOption->MtftpIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1288 break;
1289
1290 case PXEBC_VENDOR_TAG_MTFTP_CPORT:
1291
1292 NetCopyMem (&VendorOption->MtftpCPort, PxeOption->Data, sizeof (VendorOption->MtftpCPort));
1293 break;
1294
1295 case PXEBC_VENDOR_TAG_MTFTP_SPORT:
1296
1297 NetCopyMem (&VendorOption->MtftpSPort, PxeOption->Data, sizeof (VendorOption->MtftpSPort));
1298 break;
1299
1300 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT:
1301
1302 VendorOption->MtftpTimeout = *PxeOption->Data;
1303 break;
1304
1305 case PXEBC_VENDOR_TAG_MTFTP_DELAY:
1306
1307 VendorOption->MtftpDelay = *PxeOption->Data;
1308 break;
1309
1310 case PXEBC_VENDOR_TAG_DISCOVER_CTRL:
1311
1312 VendorOption->DiscoverCtrl = *PxeOption->Data;
1313 break;
1314
1315 case PXEBC_VENDOR_TAG_DISCOVER_MCAST:
1316
1317 NetCopyMem (&VendorOption->DiscoverMcastIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1318 break;
1319
1320 case PXEBC_VENDOR_TAG_BOOT_SERVERS:
1321
1322 VendorOption->BootSvrLen = PxeOption->Length;
1323 VendorOption->BootSvr = (PXEBC_BOOT_SVR_ENTRY *) PxeOption->Data;
1324 break;
1325
1326 case PXEBC_VENDOR_TAG_BOOT_MENU:
1327
1328 VendorOption->BootMenuLen = PxeOption->Length;
1329 VendorOption->BootMenu = (PXEBC_BOOT_MENU_ENTRY *) PxeOption->Data;
1330 break;
1331
1332 case PXEBC_VENDOR_TAG_MENU_PROMPT:
1333
1334 VendorOption->MenuPromptLen = PxeOption->Length;
1335 VendorOption->MenuPrompt = (PXEBC_MENU_PROMPT *) PxeOption->Data;
1336 break;
1337
1338 case PXEBC_VENDOR_TAG_MCAST_ALLOC:
1339
1340 NetCopyMem (&VendorOption->McastIpBase, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));
1341 NetCopyMem (&VendorOption->McastIpBlock, PxeOption->Data + 4, sizeof (VendorOption->McastIpBlock));
1342 NetCopyMem (&VendorOption->McastIpRange, PxeOption->Data + 6, sizeof (VendorOption->McastIpRange));
1343 break;
1344
1345 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES:
1346
1347 VendorOption->CredTypeLen = PxeOption->Length;
1348 VendorOption->CredType = (UINT32 *) PxeOption->Data;
1349 break;
1350
1351 case PXEBC_VENDOR_TAG_BOOT_ITEM:
1352
1353 NetCopyMem (&VendorOption->BootSrvType, PxeOption->Data, sizeof (VendorOption->BootSrvType));
1354 NetCopyMem (&VendorOption->BootSrvLayer, PxeOption->Data + 2, sizeof (VendorOption->BootSrvLayer));
1355 break;
1356 }
1357
1358 SET_VENDOR_OPTION_BIT_MAP (BitMap, PxeOption->OpCode);
1359
1360 if (PxeOption->OpCode == PXEBC_DHCP4_TAG_PAD) {
1361 Offset++;
1362 } else {
1363 Offset = (UINT8) (Offset + PxeOption->Length + 2);
1364 }
1365
1366 PxeOption = (EFI_DHCP4_PACKET_OPTION *) (Dhcp4Option->Data + Offset);
1367 }
1368
1369 //
1370 // FixMe, return falas if invalid of any vendor option
1371 //
1372
1373 return TRUE;
1374 }
1375
1376
1377 /**
1378 GC_NOTO: Add function description
1379
1380 @param Str GC_NOTO: add argument description
1381 @param Len GC_NOTO: add argument description
1382
1383 @return GC_NOTO: add return values
1384
1385 **/
1386 VOID
1387 PxeBcDisplayBootItem (
1388 IN UINT8 *Str,
1389 IN UINT8 Len
1390 )
1391 {
1392 UINT8 Tmp;
1393
1394 Len = (UINT8) MIN (70, Len);
1395 Tmp = Str[Len];
1396 Str[Len] = 0;
1397 AsciiPrint ("%a \n", Str);
1398 Str[Len] = Tmp;
1399 }
1400
1401
1402 /**
1403 GC_NOTO: Add function description
1404
1405 @param Private GC_NOTO: add argument description
1406
1407 @retval EFI_SUCCESS GC_NOTO: Add description for return value
1408 @retval EFI_TIMEOUT GC_NOTO: Add description for return value
1409
1410 **/
1411 EFI_STATUS
1412 PxeBcSelectBootPrompt (
1413 IN PXEBC_PRIVATE_DATA *Private
1414 )
1415 {
1416 PXEBC_CACHED_DHCP4_PACKET *Packet;
1417 PXEBC_VENDOR_OPTION *VendorOpt;
1418 EFI_EVENT TimeoutEvent;
1419 EFI_EVENT DescendEvent;
1420 EFI_INPUT_KEY InputKey;
1421 EFI_STATUS Status;
1422 UINT8 Timeout;
1423 UINT8 *Prompt;
1424 UINT8 PromptLen;
1425 INT32 SecCol;
1426 INT32 SecRow;
1427
1428 TimeoutEvent = NULL;
1429 DescendEvent = NULL;
1430
1431 if (Private->PxeBc.Mode->ProxyOfferReceived) {
1432
1433 Packet = &Private->ProxyOffer;
1434 } else {
1435
1436 Packet = &Private->Dhcp4Ack;
1437 }
1438
1439 if (Packet->OfferType != DHCP4_PACKET_TYPE_PXE10) {
1440 return EFI_NOT_FOUND;
1441 }
1442
1443 VendorOpt = &Packet->PxeVendorOption;
1444
1445 if (!IS_VALID_BOOT_PROMPT (VendorOpt->BitMap)) {
1446 return EFI_SUCCESS;
1447 }
1448
1449 Timeout = VendorOpt->MenuPrompt->Timeout;
1450 Prompt = VendorOpt->MenuPrompt->Prompt;
1451 PromptLen = (UINT8) (VendorOpt->MenuPromptLen - 1);
1452
1453 if (Timeout == 0) {
1454 return EFI_SUCCESS;
1455 }
1456
1457 if (Timeout == 255) {
1458 return EFI_TIMEOUT;
1459 }
1460
1461 Status = gBS->CreateEvent (
1462 EVT_TIMER,
1463 TPL_CALLBACK,
1464 NULL,
1465 NULL,
1466 &TimeoutEvent
1467 );
1468
1469 if (EFI_ERROR (Status)) {
1470 return Status;
1471 }
1472
1473 Status = gBS->SetTimer (
1474 TimeoutEvent,
1475 TimerRelative,
1476 Timeout * TICKS_PER_SECOND
1477 );
1478
1479 if (EFI_ERROR (Status)) {
1480 goto ON_EXIT;
1481 }
1482
1483 Status = gBS->CreateEvent (
1484 EVT_TIMER,
1485 TPL_CALLBACK,
1486 NULL,
1487 NULL,
1488 &DescendEvent
1489 );
1490
1491 if (EFI_ERROR (Status)) {
1492 goto ON_EXIT;
1493 }
1494
1495 Status = gBS->SetTimer (
1496 DescendEvent,
1497 TimerPeriodic,
1498 TICKS_PER_SECOND
1499 );
1500
1501 if (EFI_ERROR (Status)) {
1502 goto ON_EXIT;
1503 }
1504
1505 SecCol = gST->ConOut->Mode->CursorColumn;
1506 SecRow = gST->ConOut->Mode->CursorRow;
1507
1508 PxeBcDisplayBootItem (Prompt, PromptLen);
1509
1510 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
1511 AsciiPrint ("(%d) ", Timeout--);
1512
1513 while (EFI_ERROR (gBS->CheckEvent (TimeoutEvent))) {
1514
1515 if (!EFI_ERROR (gBS->CheckEvent (DescendEvent))) {
1516 gST->ConOut->SetCursorPosition (gST->ConOut, SecCol + PromptLen, SecRow);
1517 AsciiPrint ("(%d) ", Timeout--);
1518 }
1519
1520 if (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
1521
1522 gBS->Stall (10 * TICKS_PER_MS);
1523 continue;
1524 }
1525
1526 if (InputKey.ScanCode == 0) {
1527
1528 switch (InputKey.UnicodeChar) {
1529 case CTRL ('c'):
1530 Status = EFI_ABORTED;
1531 break;
1532
1533 case CTRL ('m'):
1534 case 'm':
1535 case 'M':
1536 Status = EFI_TIMEOUT;
1537 break;
1538
1539 default:
1540 continue;
1541 }
1542 } else {
1543
1544 switch (InputKey.ScanCode) {
1545 case SCAN_F8:
1546 Status = EFI_TIMEOUT;
1547 break;
1548
1549 case SCAN_ESC:
1550 Status = EFI_ABORTED;
1551 break;
1552
1553 default:
1554 continue;
1555 }
1556 }
1557
1558 break;
1559 }
1560
1561 gST->ConOut->SetCursorPosition (gST->ConOut, 0 , SecRow + 1);
1562
1563 ON_EXIT:
1564
1565 if (DescendEvent != NULL) {
1566 gBS->CloseEvent (DescendEvent);
1567 }
1568
1569 if (TimeoutEvent != NULL) {
1570 gBS->CloseEvent (TimeoutEvent);
1571 }
1572
1573 return Status;
1574 }
1575
1576
1577 /**
1578 GC_NOTO: Add function description
1579
1580 @param Private GC_NOTO: add argument description
1581 @param Type GC_NOTO: add argument description
1582
1583 @retval EFI_ABORTED GC_NOTO: Add description for return value
1584 @retval EFI_SUCCESS GC_NOTO: Add description for return value
1585
1586 **/
1587 EFI_STATUS
1588 PxeBcSelectBootMenu (
1589 IN PXEBC_PRIVATE_DATA *Private,
1590 OUT UINT16 *Type,
1591 IN BOOLEAN UseDefaultItem
1592 )
1593 {
1594 PXEBC_CACHED_DHCP4_PACKET *Packet;
1595 PXEBC_VENDOR_OPTION *VendorOpt;
1596 EFI_INPUT_KEY InputKey;
1597 UINT8 MenuSize;
1598 UINT8 MenuNum;
1599 INT32 TopRow;
1600 UINT16 Select;
1601 UINT16 LastSelect;
1602 UINT8 Index;
1603 BOOLEAN Finish;
1604 CHAR8 Blank[70];
1605 PXEBC_BOOT_MENU_ENTRY *MenuItem;
1606 PXEBC_BOOT_MENU_ENTRY *MenuArray[PXEBC_MAX_MENU_NUM];
1607
1608 Finish = FALSE;
1609 Select = 1;
1610 Index = 0;
1611 *Type = 0;
1612
1613 if (Private->PxeBc.Mode->ProxyOfferReceived) {
1614
1615 Packet = &Private->ProxyOffer;
1616 } else {
1617
1618 Packet = &Private->Dhcp4Ack;
1619 }
1620
1621 ASSERT (Packet->OfferType == DHCP4_PACKET_TYPE_PXE10);
1622
1623 VendorOpt = &Packet->PxeVendorOption;
1624
1625 if (!IS_VALID_BOOT_MENU (VendorOpt->BitMap)) {
1626 return EFI_SUCCESS;
1627 }
1628
1629 SetMem (Blank, sizeof(Blank), ' ');
1630
1631 MenuSize = VendorOpt->BootMenuLen;
1632 MenuItem = VendorOpt->BootMenu;
1633
1634 while (MenuSize > 0) {
1635 MenuArray[Index] = MenuItem;
1636 MenuSize = (UINT8) (MenuSize - (MenuItem->DescLen + 3));
1637 MenuItem = (PXEBC_BOOT_MENU_ENTRY *) ((UINT8 *) MenuItem + MenuItem->DescLen + 3);
1638 Index++;
1639 }
1640
1641 if (UseDefaultItem) {
1642 *Type = NTOHS (MenuArray[0]->Type);
1643 return EFI_SUCCESS;
1644 }
1645
1646 MenuNum = Index;
1647
1648 for (Index = 0; Index < MenuNum; Index++) {
1649 PxeBcDisplayBootItem (MenuArray[Index]->DescStr, MenuArray[Index]->DescLen);
1650 }
1651
1652 TopRow = gST->ConOut->Mode->CursorRow - MenuNum;
1653
1654 do {
1655 //
1656 // highlight selected row
1657 //
1658 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_BLACK, EFI_LIGHTGRAY));
1659 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + Select);
1660 Blank[MenuArray[Select]->DescLen] = 0;
1661 AsciiPrint ("%a\r", Blank);
1662 PxeBcDisplayBootItem (MenuArray[Select]->DescStr, MenuArray[Select]->DescLen);
1663 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
1664 LastSelect = Select;
1665
1666 while (gST->ConIn->ReadKeyStroke (gST->ConIn, &InputKey) == EFI_NOT_READY) {
1667 gBS->Stall (10 * TICKS_PER_MS);
1668 }
1669
1670 if (!InputKey.ScanCode) {
1671 switch (InputKey.UnicodeChar) {
1672 case CTRL ('c'):
1673 InputKey.ScanCode = SCAN_ESC;
1674 break;
1675
1676 case CTRL ('j'): /* linefeed */
1677 case CTRL ('m'): /* return */
1678 Finish = TRUE;
1679 break;
1680
1681 case CTRL ('i'): /* tab */
1682 case ' ':
1683 case 'd':
1684 case 'D':
1685 InputKey.ScanCode = SCAN_DOWN;
1686 break;
1687
1688 case CTRL ('h'): /* backspace */
1689 case 'u':
1690 case 'U':
1691 InputKey.ScanCode = SCAN_UP;
1692 break;
1693
1694 default:
1695 InputKey.ScanCode = 0;
1696 }
1697 }
1698
1699 switch (InputKey.ScanCode) {
1700 case SCAN_LEFT:
1701 case SCAN_UP:
1702 if (Select) {
1703 --Select;
1704 }
1705
1706 break;
1707
1708 case SCAN_DOWN:
1709 case SCAN_RIGHT:
1710 if (++Select == MenuNum) {
1711 --Select;
1712 }
1713
1714 break;
1715
1716 case SCAN_PAGE_UP:
1717 case SCAN_HOME:
1718 Select = 0;
1719 break;
1720
1721 case SCAN_PAGE_DOWN:
1722 case SCAN_END:
1723 Select = (UINT16) (MenuNum - 1);
1724 break;
1725
1726 case SCAN_ESC:
1727 return EFI_ABORTED;
1728 }
1729
1730 /* unhighlight last selected row */
1731 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
1732 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + LastSelect);
1733 Blank[MenuArray[LastSelect]->DescLen] = 0;
1734 AsciiPrint ("%a\r", Blank);
1735 PxeBcDisplayBootItem (MenuArray[LastSelect]->DescStr, MenuArray[LastSelect]->DescLen);
1736 gST->ConOut->SetCursorPosition (gST->ConOut, 0, TopRow + MenuNum);
1737 } while (!Finish);
1738
1739 //
1740 // Swap the byte order
1741 //
1742 *Type = NTOHS (MenuArray[Select]->Type);
1743
1744 return EFI_SUCCESS;
1745 }
1746
EFI Development Kit II mirror for PVE