NetworkPkg/HttpBootDxe: fix typo in DHCPv4 packet parsing
[mirror_edk2.git] / NetworkPkg / HttpBootDxe / HttpBootDhcp4.c
1 /** @file
2 Functions implementation related with DHCPv4 for HTTP boot driver.
3
4 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials are licensed and made available under
6 the terms and conditions of the BSD License that accompanies this distribution.
7 The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php.
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "HttpBootDxe.h"
16
17 //
18 // This is a map from the interested DHCP4 option tags' index to the tag value.
19 //
20 UINT8 mInterestedDhcp4Tags[HTTP_BOOT_DHCP4_TAG_INDEX_MAX] = {
21 DHCP4_TAG_BOOTFILE_LEN,
22 DHCP4_TAG_OVERLOAD,
23 DHCP4_TAG_MSG_TYPE,
24 DHCP4_TAG_SERVER_ID,
25 DHCP4_TAG_VENDOR_CLASS_ID,
26 DHCP4_TAG_BOOTFILE,
27 DHCP4_TAG_DNS_SERVER
28 };
29
30 //
31 // There are 4 times retries with the value of 4, 8, 16 and 32, refers to UEFI 2.5 spec.
32 //
33 UINT32 mHttpDhcpTimeout[4] = {4, 8, 16, 32};
34
35 /**
36 Build the options buffer for the DHCPv4 request packet.
37
38 @param[in] Private Pointer to HTTP boot driver private data.
39 @param[out] OptList Pointer to the option pointer array.
40 @param[in] Buffer Pointer to the buffer to contain the option list.
41
42 @return Index The count of the built-in options.
43
44 **/
45 UINT32
46 HttpBootBuildDhcp4Options (
47 IN HTTP_BOOT_PRIVATE_DATA *Private,
48 OUT EFI_DHCP4_PACKET_OPTION **OptList,
49 IN UINT8 *Buffer
50 )
51 {
52 HTTP_BOOT_DHCP4_OPTION_ENTRY OptEnt;
53 UINT16 Value;
54 UINT32 Index;
55
56 Index = 0;
57 OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Buffer;
58
59 //
60 // Append parameter request list option.
61 //
62 OptList[Index]->OpCode = DHCP4_TAG_PARA_LIST;
63 OptList[Index]->Length = 27;
64 OptEnt.Para = (HTTP_BOOT_DHCP4_OPTION_PARA *) OptList[Index]->Data;
65 OptEnt.Para->ParaList[0] = DHCP4_TAG_NETMASK;
66 OptEnt.Para->ParaList[1] = DHCP4_TAG_TIME_OFFSET;
67 OptEnt.Para->ParaList[2] = DHCP4_TAG_ROUTER;
68 OptEnt.Para->ParaList[3] = DHCP4_TAG_TIME_SERVER;
69 OptEnt.Para->ParaList[4] = DHCP4_TAG_NAME_SERVER;
70 OptEnt.Para->ParaList[5] = DHCP4_TAG_DNS_SERVER;
71 OptEnt.Para->ParaList[6] = DHCP4_TAG_HOSTNAME;
72 OptEnt.Para->ParaList[7] = DHCP4_TAG_BOOTFILE_LEN;
73 OptEnt.Para->ParaList[8] = DHCP4_TAG_DOMAINNAME;
74 OptEnt.Para->ParaList[9] = DHCP4_TAG_ROOTPATH;
75 OptEnt.Para->ParaList[10] = DHCP4_TAG_EXTEND_PATH;
76 OptEnt.Para->ParaList[11] = DHCP4_TAG_EMTU;
77 OptEnt.Para->ParaList[12] = DHCP4_TAG_TTL;
78 OptEnt.Para->ParaList[13] = DHCP4_TAG_BROADCAST;
79 OptEnt.Para->ParaList[14] = DHCP4_TAG_NIS_DOMAIN;
80 OptEnt.Para->ParaList[15] = DHCP4_TAG_NIS_SERVER;
81 OptEnt.Para->ParaList[16] = DHCP4_TAG_NTP_SERVER;
82 OptEnt.Para->ParaList[17] = DHCP4_TAG_VENDOR;
83 OptEnt.Para->ParaList[18] = DHCP4_TAG_REQUEST_IP;
84 OptEnt.Para->ParaList[19] = DHCP4_TAG_LEASE;
85 OptEnt.Para->ParaList[20] = DHCP4_TAG_SERVER_ID;
86 OptEnt.Para->ParaList[21] = DHCP4_TAG_T1;
87 OptEnt.Para->ParaList[22] = DHCP4_TAG_T2;
88 OptEnt.Para->ParaList[23] = DHCP4_TAG_VENDOR_CLASS_ID;
89 OptEnt.Para->ParaList[25] = DHCP4_TAG_BOOTFILE;
90 OptEnt.Para->ParaList[26] = DHCP4_TAG_UUID;
91 Index++;
92 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
93
94 //
95 // Append UUID/Guid-based client identifier option
96 //
97 OptList[Index]->OpCode = DHCP4_TAG_UUID;
98 OptList[Index]->Length = (UINT8) sizeof (HTTP_BOOT_DHCP4_OPTION_UUID);
99 OptEnt.Uuid = (HTTP_BOOT_DHCP4_OPTION_UUID *) OptList[Index]->Data;
100 OptEnt.Uuid->Type = 0;
101 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) OptEnt.Uuid->Guid))) {
102 //
103 // Zero the Guid to indicate NOT programable if failed to get system Guid.
104 //
105 ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));
106 }
107 Index++;
108 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
109
110 //
111 // Append client network device interface option
112 //
113 OptList[Index]->OpCode = DHCP4_TAG_UNDI;
114 OptList[Index]->Length = (UINT8) sizeof (HTTP_BOOT_DHCP4_OPTION_UNDI);
115 OptEnt.Undi = (HTTP_BOOT_DHCP4_OPTION_UNDI *) OptList[Index]->Data;
116
117 if (Private->Nii != NULL) {
118 OptEnt.Undi->Type = Private->Nii->Type;
119 OptEnt.Undi->MajorVer = Private->Nii->MajorVer;
120 OptEnt.Undi->MinorVer = Private->Nii->MinorVer;
121 } else {
122 OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;
123 OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;
124 OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;
125 }
126
127 Index++;
128 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
129
130 //
131 // Append client system architecture option
132 //
133 OptList[Index]->OpCode = DHCP4_TAG_ARCH;
134 OptList[Index]->Length = (UINT8) sizeof (HTTP_BOOT_DHCP4_OPTION_ARCH);
135 OptEnt.Arch = (HTTP_BOOT_DHCP4_OPTION_ARCH *) OptList[Index]->Data;
136 Value = HTONS (EFI_HTTP_BOOT_CLIENT_SYSTEM_ARCHITECTURE);
137 CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));
138 Index++;
139 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);
140
141 //
142 // Append vendor class identify option
143 //
144 OptList[Index]->OpCode = DHCP4_TAG_VENDOR_CLASS_ID;
145 OptList[Index]->Length = (UINT8) sizeof (HTTP_BOOT_DHCP4_OPTION_CLID);
146 OptEnt.Clid = (HTTP_BOOT_DHCP4_OPTION_CLID *) OptList[Index]->Data;
147 CopyMem (
148 OptEnt.Clid,
149 DEFAULT_CLASS_ID_DATA,
150 sizeof (HTTP_BOOT_DHCP4_OPTION_CLID)
151 );
152 HttpBootUintnToAscDecWithFormat (
153 EFI_HTTP_BOOT_CLIENT_SYSTEM_ARCHITECTURE,
154 OptEnt.Clid->ArchitectureType,
155 sizeof (OptEnt.Clid->ArchitectureType)
156 );
157
158 if (Private->Nii != NULL) {
159 CopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));
160 HttpBootUintnToAscDecWithFormat (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));
161 HttpBootUintnToAscDecWithFormat (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));
162 }
163
164 Index++;
165
166 return Index;
167 }
168
169 /**
170 Parse a certain dhcp4 option by OptTag in Buffer, and return with start pointer.
171
172 @param[in] Buffer Pointer to the option buffer.
173 @param[in] Length Length of the option buffer.
174 @param[in] OptTag Tag of the required option.
175
176 @retval NULL Failed to find the required option.
177 @retval Others The position of the required option.
178
179 **/
180 EFI_DHCP4_PACKET_OPTION *
181 HttpBootParseDhcp4Options (
182 IN UINT8 *Buffer,
183 IN UINT32 Length,
184 IN UINT8 OptTag
185 )
186 {
187 EFI_DHCP4_PACKET_OPTION *Option;
188 UINT32 Offset;
189
190 Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;
191 Offset = 0;
192
193 while (Offset < Length && Option->OpCode != DHCP4_TAG_EOP) {
194
195 if (Option->OpCode == OptTag) {
196 //
197 // Found the required option.
198 //
199 return Option;
200 }
201
202 //
203 // Skip the current option to the next.
204 //
205 if (Option->OpCode == DHCP4_TAG_PAD) {
206 Offset++;
207 } else {
208 Offset += Option->Length + 2;
209 }
210
211 Option = (EFI_DHCP4_PACKET_OPTION *) (Buffer + Offset);
212 }
213
214 return NULL;
215 }
216
217 /**
218 Cache the DHCPv4 packet.
219
220 @param[in] Dst Pointer to the cache buffer for DHCPv4 packet.
221 @param[in] Src Pointer to the DHCPv4 packet to be cached.
222
223 @retval EFI_SUCCESS Packet is copied.
224 @retval EFI_BUFFER_TOO_SMALL Cache buffer is not big enough to hold the packet.
225
226 **/
227 EFI_STATUS
228 HttpBootCacheDhcp4Packet (
229 IN EFI_DHCP4_PACKET *Dst,
230 IN EFI_DHCP4_PACKET *Src
231 )
232 {
233 if (Dst->Size < Src->Length) {
234 return EFI_BUFFER_TOO_SMALL;
235 }
236
237 CopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);
238 Dst->Length = Src->Length;
239
240 return EFI_SUCCESS;
241 }
242
243 /**
244 Parse the cached DHCPv4 packet, including all the options.
245
246 @param[in] Cache4 Pointer to cached DHCPv4 packet.
247
248 @retval EFI_SUCCESS Parsed the DHCPv4 packet successfully.
249 @retval EFI_DEVICE_ERROR Failed to parse an invalid packet.
250
251 **/
252 EFI_STATUS
253 HttpBootParseDhcp4Packet (
254 IN HTTP_BOOT_DHCP4_PACKET_CACHE *Cache4
255 )
256 {
257 EFI_DHCP4_PACKET *Offer;
258 EFI_DHCP4_PACKET_OPTION **Options;
259 UINTN Index;
260 EFI_DHCP4_PACKET_OPTION *Option;
261 BOOLEAN IsProxyOffer;
262 BOOLEAN IsHttpOffer;
263 BOOLEAN IsDnsOffer;
264 BOOLEAN IpExpressedUri;
265 UINT8 *Ptr8;
266 EFI_STATUS Status;
267 HTTP_BOOT_OFFER_TYPE OfferType;
268 EFI_IPv4_ADDRESS IpAddr;
269 BOOLEAN FileFieldOverloaded;
270
271 IsDnsOffer = FALSE;
272 IpExpressedUri = FALSE;
273 IsProxyOffer = FALSE;
274 IsHttpOffer = FALSE;
275 FileFieldOverloaded = FALSE;
276
277 ZeroMem (Cache4->OptList, sizeof (Cache4->OptList));
278
279 Offer = &Cache4->Packet.Offer;
280 Options = Cache4->OptList;
281
282 //
283 // Parse DHCPv4 options in this offer, and store the pointers.
284 // First, try to parse DHCPv4 options from the DHCP optional parameters field.
285 //
286 for (Index = 0; Index < HTTP_BOOT_DHCP4_TAG_INDEX_MAX; Index++) {
287 Options[Index] = HttpBootParseDhcp4Options (
288 Offer->Dhcp4.Option,
289 GET_OPTION_BUFFER_LEN (Offer),
290 mInterestedDhcp4Tags[Index]
291 );
292 }
293 //
294 // Second, Check if bootfilename and serverhostname is overloaded to carry DHCP options refers to rfc-2132.
295 // If yes, try to parse options from the BootFileName field, then ServerName field.
296 //
297 Option = Options[HTTP_BOOT_DHCP4_TAG_INDEX_OVERLOAD];
298 if (Option != NULL) {
299 if ((Option->Data[0] & HTTP_BOOT_DHCP4_OVERLOAD_FILE) != 0) {
300 FileFieldOverloaded = TRUE;
301 for (Index = 0; Index < HTTP_BOOT_DHCP4_TAG_INDEX_MAX; Index++) {
302 if (Options[Index] == NULL) {
303 Options[Index] = HttpBootParseDhcp4Options (
304 (UINT8 *) Offer->Dhcp4.Header.BootFileName,
305 sizeof (Offer->Dhcp4.Header.BootFileName),
306 mInterestedDhcp4Tags[Index]
307 );
308 }
309 }
310 }
311 if ((Option->Data[0] & HTTP_BOOT_DHCP4_OVERLOAD_SERVER_NAME) != 0) {
312 for (Index = 0; Index < HTTP_BOOT_DHCP4_TAG_INDEX_MAX; Index++) {
313 if (Options[Index] == NULL) {
314 Options[Index] = HttpBootParseDhcp4Options (
315 (UINT8 *) Offer->Dhcp4.Header.ServerName,
316 sizeof (Offer->Dhcp4.Header.ServerName),
317 mInterestedDhcp4Tags[Index]
318 );
319 }
320 }
321 }
322 }
323
324 //
325 // The offer with "yiaddr" is a proxy offer.
326 //
327 if (Offer->Dhcp4.Header.YourAddr.Addr[0] == 0) {
328 IsProxyOffer = TRUE;
329 }
330
331 //
332 // The offer with "HTTPClient" is a Http offer.
333 //
334 Option = Options[HTTP_BOOT_DHCP4_TAG_INDEX_CLASS_ID];
335 if ((Option != NULL) && (Option->Length >= 10) &&
336 (CompareMem (Option->Data, DEFAULT_CLASS_ID_DATA, 10) == 0)) {
337 IsHttpOffer = TRUE;
338 }
339
340 //
341 // The offer with Domain Server is a DNS offer.
342 //
343 Option = Options[HTTP_BOOT_DHCP4_TAG_INDEX_DNS_SERVER];
344 if (Option != NULL) {
345 IsDnsOffer = TRUE;
346 }
347
348 //
349 // Parse boot file name:
350 // Boot URI information is provided thru 'file' field in DHCP Header or option 67.
351 // According to RFC 2132, boot file name should be read from DHCP option 67 (bootfile name) if present.
352 // Otherwise, read from boot file field in DHCP header.
353 //
354 if (Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {
355 //
356 // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null
357 // terminated string. So force to append null terminated character at the end of string.
358 //
359 Ptr8 = (UINT8*)&Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];
360 Ptr8 += Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE]->Length;
361 if (*(Ptr8 - 1) != '\0') {
362 *Ptr8 = '\0';
363 }
364 } else if (!FileFieldOverloaded && Offer->Dhcp4.Header.BootFileName[0] != 0) {
365 //
366 // If the bootfile is not present and bootfilename is present in DHCPv4 packet, just parse it.
367 // Do not count dhcp option header here, or else will destroy the serverhostname.
368 //
369 Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *)
370 (&Offer->Dhcp4.Header.BootFileName[0] -
371 OFFSET_OF (EFI_DHCP4_PACKET_OPTION, Data[0]));
372 }
373
374 //
375 // Http offer must have a boot URI.
376 //
377 if (IsHttpOffer && Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {
378 return EFI_DEVICE_ERROR;
379 }
380
381 //
382 // Try to retrieve the IP of HTTP server from URI.
383 //
384 if (IsHttpOffer) {
385 Status = HttpParseUrl (
386 (CHAR8*) Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE]->Data,
387 (UINT32) AsciiStrLen ((CHAR8*) Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE]->Data),
388 FALSE,
389 &Cache4->UriParser
390 );
391 if (EFI_ERROR (Status)) {
392 return EFI_DEVICE_ERROR;
393 }
394
395 Status = HttpUrlGetIp4 (
396 (CHAR8*) Options[HTTP_BOOT_DHCP4_TAG_INDEX_BOOTFILE]->Data,
397 Cache4->UriParser,
398 &IpAddr
399 );
400 IpExpressedUri = !EFI_ERROR (Status);
401 }
402
403 //
404 // Determine offer type of the DHCPv4 packet.
405 //
406 if (IsHttpOffer) {
407 if (IpExpressedUri) {
408 if (IsProxyOffer) {
409 OfferType = HttpOfferTypeProxyIpUri;
410 } else {
411 OfferType = IsDnsOffer ? HttpOfferTypeDhcpIpUriDns : HttpOfferTypeDhcpIpUri;
412 }
413 } else {
414 if (!IsProxyOffer) {
415 OfferType = IsDnsOffer ? HttpOfferTypeDhcpNameUriDns : HttpOfferTypeDhcpNameUri;
416 } else {
417 OfferType = HttpOfferTypeProxyNameUri;
418 }
419 }
420
421 } else {
422 if (!IsProxyOffer) {
423 OfferType = IsDnsOffer ? HttpOfferTypeDhcpDns : HttpOfferTypeDhcpOnly;
424 } else {
425 if (Cache4->UriParser != NULL) {
426 FreePool (Cache4->UriParser);
427 }
428 return EFI_DEVICE_ERROR;
429 }
430 }
431
432 Cache4->OfferType = OfferType;
433 return EFI_SUCCESS;
434 }
435
436 /**
437 Cache all the received DHCPv4 offers, and set OfferIndex and OfferCount.
438
439 @param[in] Private Pointer to HTTP boot driver private data.
440 @param[in] RcvdOffer Pointer to the received offer packet.
441
442 @retval EFI_SUCCESS Cache and parse the packet successfully.
443 @retval Others Operation failed.
444 **/
445 EFI_STATUS
446 HttpBootCacheDhcp4Offer (
447 IN HTTP_BOOT_PRIVATE_DATA *Private,
448 IN EFI_DHCP4_PACKET *RcvdOffer
449 )
450 {
451 HTTP_BOOT_DHCP4_PACKET_CACHE *Cache4;
452 EFI_DHCP4_PACKET *Offer;
453 HTTP_BOOT_OFFER_TYPE OfferType;
454 EFI_STATUS Status;
455
456 ASSERT (Private->OfferNum < HTTP_BOOT_OFFER_MAX_NUM);
457 Cache4 = &Private->OfferBuffer[Private->OfferNum].Dhcp4;
458 Offer = &Cache4->Packet.Offer;
459
460 //
461 // Cache the content of DHCPv4 packet firstly.
462 //
463 Status = HttpBootCacheDhcp4Packet (Offer, RcvdOffer);
464 if (EFI_ERROR (Status)) {
465 return Status;
466 }
467
468 //
469 // Validate the DHCPv4 packet, and parse the options and offer type.
470 //
471 if (EFI_ERROR (HttpBootParseDhcp4Packet (Cache4))) {
472 return EFI_ABORTED;
473 }
474
475 //
476 // Determine whether cache the current offer by type, and record OfferIndex and OfferCount.
477 //
478 OfferType = Cache4->OfferType;
479 ASSERT (OfferType < HttpOfferTypeMax);
480 ASSERT (Private->OfferCount[OfferType] < HTTP_BOOT_OFFER_MAX_NUM);
481 Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;
482 Private->OfferCount[OfferType]++;
483 Private->OfferNum++;
484
485 return EFI_SUCCESS;
486 }
487
488 /**
489 Select an DHCPv4 or DHCP6 offer, and record SelectIndex and SelectProxyType.
490
491 @param[in] Private Pointer to HTTP boot driver private data.
492
493 **/
494 VOID
495 HttpBootSelectDhcpOffer (
496 IN HTTP_BOOT_PRIVATE_DATA *Private
497 )
498 {
499 Private->SelectIndex = 0;
500 Private->SelectProxyType = HttpOfferTypeMax;
501
502 if (Private->FilePathUri != NULL) {
503 //
504 // We are in home environment, the URI is already specified.
505 // Just need to choose a DHCP offer.
506 // The offer with DNS server address takes priority here.
507 //
508 if (Private->OfferCount[HttpOfferTypeDhcpDns] > 0) {
509
510 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpDns][0] + 1;
511
512 } else if (Private->OfferCount[HttpOfferTypeDhcpIpUriDns] > 0) {
513
514 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpIpUriDns][0] + 1;
515
516 } else if (Private->OfferCount[HttpOfferTypeDhcpNameUriDns] > 0) {
517
518 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpNameUriDns][0] + 1;
519
520 } else if (Private->OfferCount[HttpOfferTypeDhcpOnly] > 0) {
521
522 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpOnly][0] + 1;
523
524 } else if (Private->OfferCount[HttpOfferTypeDhcpIpUri] > 0) {
525
526 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpIpUri][0] + 1;
527 }
528
529 } else {
530 //
531 // We are in corporate environment.
532 //
533 // Priority1: HttpOfferTypeDhcpIpUri or HttpOfferTypeDhcpIpUriDns
534 // Priority2: HttpOfferTypeDhcpNameUriDns
535 // Priority3: HttpOfferTypeDhcpOnly + HttpOfferTypeProxyIpUri
536 // Priority4: HttpOfferTypeDhcpDns + HttpOfferTypeProxyIpUri
537 // Priority5: HttpOfferTypeDhcpDns + HttpOfferTypeProxyNameUri
538 // Priority6: HttpOfferTypeDhcpDns + HttpOfferTypeDhcpNameUri
539 //
540 if (Private->OfferCount[HttpOfferTypeDhcpIpUri] > 0) {
541
542 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpIpUri][0] + 1;
543
544 } else if (Private->OfferCount[HttpOfferTypeDhcpIpUriDns] > 0) {
545
546 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpIpUriDns][0] + 1;
547
548 }else if (Private->OfferCount[HttpOfferTypeDhcpNameUriDns] > 0) {
549
550 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpNameUriDns][0] + 1;
551
552 } else if (Private->OfferCount[HttpOfferTypeDhcpOnly] > 0 &&
553 Private->OfferCount[HttpOfferTypeProxyIpUri] > 0) {
554
555 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpOnly][0] + 1;
556 Private->SelectProxyType = HttpOfferTypeProxyIpUri;
557
558 } else if (Private->OfferCount[HttpOfferTypeDhcpDns] > 0 &&
559 Private->OfferCount[HttpOfferTypeProxyIpUri] > 0) {
560
561 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpDns][0] + 1;
562 Private->SelectProxyType = HttpOfferTypeProxyIpUri;
563
564 } else if (Private->OfferCount[HttpOfferTypeDhcpDns] > 0 &&
565 Private->OfferCount[HttpOfferTypeProxyNameUri] > 0) {
566
567 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpDns][0] + 1;
568 Private->SelectProxyType = HttpOfferTypeProxyNameUri;
569
570 } else if (Private->OfferCount[HttpOfferTypeDhcpDns] > 0 &&
571 Private->OfferCount[HttpOfferTypeDhcpNameUri] > 0) {
572
573 Private->SelectIndex = Private->OfferIndex[HttpOfferTypeDhcpDns][0] + 1;
574 Private->SelectProxyType = HttpOfferTypeDhcpNameUri;
575 }
576 }
577 }
578
579
580 /**
581 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver
582 to intercept events that occurred in the configuration process.
583
584 @param[in] This Pointer to the EFI DHCPv4 Protocol.
585 @param[in] Context Pointer to the context set by EFI_DHCP4_PROTOCOL.Configure().
586 @param[in] CurrentState The current operational state of the EFI DHCPv4 Protocol driver.
587 @param[in] Dhcp4Event The event that occurs in the current state, which usually means a
588 state transition.
589 @param[in] Packet The DHCPv4 packet that is going to be sent or already received.
590 @param[out] NewPacket The packet that is used to replace the above Packet.
591
592 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.
593 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol
594 driver will continue to wait for more DHCPOFFER packets until the
595 retry timeout expires.
596 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process
597 and return to the Dhcp4Init or Dhcp4InitReboot state.
598
599 **/
600 EFI_STATUS
601 EFIAPI
602 HttpBootDhcp4CallBack (
603 IN EFI_DHCP4_PROTOCOL *This,
604 IN VOID *Context,
605 IN EFI_DHCP4_STATE CurrentState,
606 IN EFI_DHCP4_EVENT Dhcp4Event,
607 IN EFI_DHCP4_PACKET *Packet OPTIONAL,
608 OUT EFI_DHCP4_PACKET **NewPacket OPTIONAL
609 )
610 {
611 HTTP_BOOT_PRIVATE_DATA *Private;
612 EFI_DHCP4_PACKET_OPTION *MaxMsgSize;
613 UINT16 Value;
614 EFI_STATUS Status;
615 BOOLEAN Received;
616
617 if ((Dhcp4Event != Dhcp4SendDiscover) &&
618 (Dhcp4Event != Dhcp4RcvdOffer) &&
619 (Dhcp4Event != Dhcp4SendRequest) &&
620 (Dhcp4Event != Dhcp4RcvdAck) &&
621 (Dhcp4Event != Dhcp4SelectOffer)) {
622 return EFI_SUCCESS;
623 }
624
625 Private = (HTTP_BOOT_PRIVATE_DATA *) Context;
626
627 //
628 // Override the Maximum DHCP Message Size.
629 //
630 MaxMsgSize = HttpBootParseDhcp4Options (
631 Packet->Dhcp4.Option,
632 GET_OPTION_BUFFER_LEN (Packet),
633 DHCP4_TAG_MAXMSG
634 );
635 if (MaxMsgSize != NULL) {
636 Value = HTONS (HTTP_BOOT_DHCP4_PACKET_MAX_SIZE);
637 CopyMem (MaxMsgSize->Data, &Value, sizeof (Value));
638 }
639
640 //
641 // Callback to user if any packets sent or received.
642 //
643 if (Private->HttpBootCallback != NULL && Dhcp4Event != Dhcp4SelectOffer) {
644 Received = (BOOLEAN) (Dhcp4Event == Dhcp4RcvdOffer || Dhcp4Event == Dhcp4RcvdAck);
645 Status = Private->HttpBootCallback->Callback (
646 Private->HttpBootCallback,
647 HttpBootDhcp4,
648 Received,
649 Packet->Length,
650 &Packet->Dhcp4
651 );
652 if (EFI_ERROR (Status)) {
653 return EFI_ABORTED;
654 }
655 }
656
657 Status = EFI_SUCCESS;
658 switch (Dhcp4Event) {
659 case Dhcp4RcvdOffer:
660 Status = EFI_NOT_READY;
661 if (Packet->Length > HTTP_BOOT_DHCP4_PACKET_MAX_SIZE) {
662 //
663 // Ignore the incoming packets which exceed the maximum length.
664 //
665 break;
666 }
667 if (Private->OfferNum < HTTP_BOOT_OFFER_MAX_NUM) {
668 //
669 // Cache the DHCPv4 offers to OfferBuffer[] for select later, and record
670 // the OfferIndex and OfferCount.
671 // If error happens, just ignore this packet and continue to wait more offer.
672 //
673 HttpBootCacheDhcp4Offer (Private, Packet);
674 }
675 break;
676
677 case Dhcp4SelectOffer:
678 //
679 // Select offer according to the priority in UEFI spec, and record the SelectIndex
680 // and SelectProxyType.
681 //
682 HttpBootSelectDhcpOffer (Private);
683
684 if (Private->SelectIndex == 0) {
685 Status = EFI_ABORTED;
686 } else {
687 *NewPacket = &Private->OfferBuffer[Private->SelectIndex - 1].Dhcp4.Packet.Offer;
688 }
689 break;
690
691 default:
692 break;
693 }
694
695 return Status;
696 }
697
698 /**
699 This function will register the IPv4 gateway address to the network device.
700
701 @param[in] Private The pointer to HTTP_BOOT_PRIVATE_DATA.
702
703 @retval EFI_SUCCESS The new IP configuration has been configured successfully.
704 @retval Others Failed to configure the address.
705
706 **/
707 EFI_STATUS
708 HttpBootRegisterIp4Gateway (
709 IN HTTP_BOOT_PRIVATE_DATA *Private
710 )
711 {
712 EFI_STATUS Status;
713 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
714
715 ASSERT (!Private->UsingIpv6);
716
717 Ip4Config2 = Private->Ip4Config2;
718
719 //
720 // Configure the gateway if valid.
721 //
722 if (!EFI_IP4_EQUAL (&Private->GatewayIp, &mZeroIp4Addr)) {
723 Status = Ip4Config2->SetData (
724 Ip4Config2,
725 Ip4Config2DataTypeGateway,
726 sizeof (EFI_IPv4_ADDRESS),
727 &Private->GatewayIp
728 );
729 if (EFI_ERROR (Status)) {
730 return Status;
731 }
732 }
733
734 return EFI_SUCCESS;
735 }
736
737 /**
738 This function will register the default DNS addresses to the network device.
739
740 @param[in] Private The pointer to HTTP_BOOT_PRIVATE_DATA.
741 @param[in] DataLength Size of the buffer pointed to by DnsServerData in bytes.
742 @param[in] DnsServerData Point a list of DNS server address in an array
743 of EFI_IPv4_ADDRESS instances.
744
745 @retval EFI_SUCCESS The DNS configuration has been configured successfully.
746 @retval Others Failed to configure the address.
747
748 **/
749 EFI_STATUS
750 HttpBootRegisterIp4Dns (
751 IN HTTP_BOOT_PRIVATE_DATA *Private,
752 IN UINTN DataLength,
753 IN VOID *DnsServerData
754 )
755 {
756 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
757
758 ASSERT (!Private->UsingIpv6);
759
760 Ip4Config2 = Private->Ip4Config2;
761
762 return Ip4Config2->SetData (
763 Ip4Config2,
764 Ip4Config2DataTypeDnsServer,
765 DataLength,
766 DnsServerData
767 );
768 }
769
770
771 /**
772 This function will switch the IP4 configuration policy to Static.
773
774 @param[in] Private Pointer to HTTP boot driver private data.
775
776 @retval EFI_SUCCESS The policy is already configured to static.
777 @retval Others Other error as indicated..
778
779 **/
780 EFI_STATUS
781 HttpBootSetIp4Policy (
782 IN HTTP_BOOT_PRIVATE_DATA *Private
783 )
784 {
785 EFI_IP4_CONFIG2_POLICY Policy;
786 EFI_STATUS Status;
787 EFI_IP4_CONFIG2_PROTOCOL *Ip4Config2;
788 UINTN DataSize;
789
790 Ip4Config2 = Private->Ip4Config2;
791
792 DataSize = sizeof (EFI_IP4_CONFIG2_POLICY);
793 Status = Ip4Config2->GetData (
794 Ip4Config2,
795 Ip4Config2DataTypePolicy,
796 &DataSize,
797 &Policy
798 );
799 if (EFI_ERROR (Status)) {
800 return Status;
801 }
802
803 if (Policy != Ip4Config2PolicyStatic) {
804 Policy = Ip4Config2PolicyStatic;
805 Status= Ip4Config2->SetData (
806 Ip4Config2,
807 Ip4Config2DataTypePolicy,
808 sizeof (EFI_IP4_CONFIG2_POLICY),
809 &Policy
810 );
811 if (EFI_ERROR (Status)) {
812 return Status;
813 }
814 }
815
816 return EFI_SUCCESS;
817 }
818
819 /**
820 Start the D.O.R.A DHCPv4 process to acquire the IPv4 address and other Http boot information.
821
822 @param[in] Private Pointer to HTTP boot driver private data.
823
824 @retval EFI_SUCCESS The D.O.R.A process successfully finished.
825 @retval Others Failed to finish the D.O.R.A process.
826
827 **/
828 EFI_STATUS
829 HttpBootDhcp4Dora (
830 IN HTTP_BOOT_PRIVATE_DATA *Private
831 )
832 {
833 EFI_DHCP4_PROTOCOL *Dhcp4;
834 UINT32 OptCount;
835 EFI_DHCP4_PACKET_OPTION *OptList[HTTP_BOOT_DHCP4_OPTION_MAX_NUM];
836 UINT8 Buffer[HTTP_BOOT_DHCP4_OPTION_MAX_SIZE];
837 EFI_DHCP4_CONFIG_DATA Config;
838 EFI_STATUS Status;
839 EFI_DHCP4_MODE_DATA Mode;
840
841 Dhcp4 = Private->Dhcp4;
842 ASSERT (Dhcp4 != NULL);
843
844 Status = HttpBootSetIp4Policy (Private);
845 if (EFI_ERROR (Status)) {
846 return Status;
847 }
848
849 //
850 // Build option list for the request packet.
851 //
852 OptCount = HttpBootBuildDhcp4Options (Private, OptList, Buffer);
853 ASSERT (OptCount > 0);
854
855 ZeroMem (&Config, sizeof(Config));
856 Config.OptionCount = OptCount;
857 Config.OptionList = OptList;
858 Config.Dhcp4Callback = HttpBootDhcp4CallBack;
859 Config.CallbackContext = Private;
860 Config.DiscoverTryCount = HTTP_BOOT_DHCP_RETRIES;
861 Config.DiscoverTimeout = mHttpDhcpTimeout;
862
863 //
864 // Configure the DHCPv4 instance for HTTP boot.
865 //
866 Status = Dhcp4->Configure (Dhcp4, &Config);
867 if (EFI_ERROR (Status)) {
868 goto ON_EXIT;
869 }
870
871 //
872 // Initialize the record fields for DHCPv4 offer in private data.
873 //
874 Private->OfferNum = 0;
875 ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));
876 ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));
877
878 //
879 // Start DHCPv4 D.O.R.A. process to acquire IPv4 address.
880 //
881 Status = Dhcp4->Start (Dhcp4, NULL);
882 if (EFI_ERROR (Status)) {
883 goto ON_EXIT;
884 }
885
886 //
887 // Get the acquired IPv4 address and store them.
888 //
889 Status = Dhcp4->GetModeData (Dhcp4, &Mode);
890 if (EFI_ERROR (Status)) {
891 goto ON_EXIT;
892 }
893
894 ASSERT (Mode.State == Dhcp4Bound);
895 CopyMem (&Private->StationIp, &Mode.ClientAddress, sizeof (EFI_IPv4_ADDRESS));
896 CopyMem (&Private->SubnetMask, &Mode.SubnetMask, sizeof (EFI_IPv4_ADDRESS));
897 CopyMem (&Private->GatewayIp, &Mode.RouterAddress, sizeof (EFI_IPv4_ADDRESS));
898
899 Status = HttpBootRegisterIp4Gateway (Private);
900 if (EFI_ERROR (Status)) {
901 goto ON_EXIT;
902 }
903
904 AsciiPrint ("\n Station IP address is ");
905 HttpBootShowIp4Addr (&Private->StationIp.v4);
906 AsciiPrint ("\n");
907
908 ON_EXIT:
909 if (EFI_ERROR (Status)) {
910 Dhcp4->Stop (Dhcp4);
911 Dhcp4->Configure (Dhcp4, NULL);
912 } else {
913 ZeroMem (&Config, sizeof (EFI_DHCP4_CONFIG_DATA));
914 Dhcp4->Configure (Dhcp4, &Config);
915 }
916
917 return Status;
918 }