]> git.proxmox.com Git - mirror_edk2.git/blame - NetworkPkg/UefiPxeBcDxe/PxeBcDhcp4.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Remove MOR check box feature. should not have a switch to turn off MOR.
[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcDhcp4.c
CommitLineData
a3bcde70
HT		 1/** @file\r
2 Functions implementation related with DHCPv4 for UefiPxeBc Driver.\r
3\r
19ddbb25 4 Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>\r
a3bcde70
HT		 5\r
6 This program and the accompanying materials\r
7 are licensed and made available under the terms and conditions of the BSD License\r
8 which accompanies this distribution. The full text of the license may be found at\r
9 http://opensource.org/licenses/bsd-license.php.\r
10\r
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13\r
14**/\r
15\r
16#include "PxeBcImpl.h"\r
17\r
18//\r
19// This is a map from the interested DHCP4 option tags' index to the tag value.\r
20//\r
21UINT8 mInterestedDhcp4Tags[PXEBC_DHCP4_TAG_INDEX_MAX] = {\r
22 PXEBC_DHCP4_TAG_BOOTFILE_LEN,\r
23 PXEBC_DHCP4_TAG_VENDOR,\r
24 PXEBC_DHCP4_TAG_OVERLOAD,\r
25 PXEBC_DHCP4_TAG_MSG_TYPE,\r
26 PXEBC_DHCP4_TAG_SERVER_ID,\r
27 PXEBC_DHCP4_TAG_CLASS_ID,\r
28 PXEBC_DHCP4_TAG_BOOTFILE\r
29};\r
30\r
31//\r
32// There are 4 times retries with the value of 4, 8, 16 and 32, refers to PXE2.1 spec.\r
33//\r
34UINT32 mPxeDhcpTimeout[4] = {4, 8, 16, 32};\r
35\r
36\r
37/**\r
38 Parse a certain dhcp4 option by OptTag in Buffer, and return with start pointer.\r
39\r
40 @param[in] Buffer Pointer to the option buffer.\r
41 @param[in] Length Length of the option buffer.\r
42 @param[in] OptTag Tag of the required option.\r
43\r
44 @retval NULL Failed to find the required option.\r
45 @retval Others The position of the required option.\r
46\r
47**/\r
48EFI_DHCP4_PACKET_OPTION *\r
49PxeBcParseDhcp4Options (\r
50 IN UINT8 *Buffer,\r
51 IN UINT32 Length,\r
52 IN UINT8 OptTag\r
53 )\r
54{\r
55 EFI_DHCP4_PACKET_OPTION *Option;\r
56 UINT32 Offset;\r
57\r
58 Option = (EFI_DHCP4_PACKET_OPTION *) Buffer;\r
59 Offset = 0;\r
60\r
61 while (Offset < Length && Option->OpCode != PXEBC_DHCP4_TAG_EOP) {\r
62\r
63 if (Option->OpCode == OptTag) {\r
64 //\r
65 // Found the required option.\r
66 //\r
67 return Option;\r
68 }\r
69\r
70 //\r
71 // Skip the current option to the next.\r
72 //\r
73 if (Option->OpCode == PXEBC_DHCP4_TAG_PAD) {\r
74 Offset++;\r
75 } else {\r
76 Offset += Option->Length + 2;\r
77 }\r
78\r
79 Option = (EFI_DHCP4_PACKET_OPTION *) (Buffer + Offset);\r
80 }\r
81\r
82 return NULL;\r
83}\r
84\r
85\r
86/**\r
87 Parse the PXE vender options and extract the information from them.\r
88\r
89 @param[in] Dhcp4Option Pointer to vendor options in buffer.\r
90 @param[in] VendorOption Pointer to structure to store information in vendor options.\r
91\r
92**/\r
93VOID\r
94PxeBcParseVendorOptions (\r
95 IN EFI_DHCP4_PACKET_OPTION *Dhcp4Option,\r
96 IN PXEBC_VENDOR_OPTION *VendorOption\r
97 )\r
98{\r
99 UINT32 *BitMap;\r
100 UINT8 VendorOptionLen;\r
101 EFI_DHCP4_PACKET_OPTION *PxeOption;\r
102 UINT8 Offset;\r
103\r
104 BitMap = VendorOption->BitMap;\r
105 VendorOptionLen = Dhcp4Option->Length;\r
106 PxeOption = (EFI_DHCP4_PACKET_OPTION *) &Dhcp4Option->Data[0];\r
107 Offset = 0;\r
108\r
109 ASSERT (PxeOption != NULL);\r
110\r
111 while ((Offset < VendorOptionLen) && (PxeOption->OpCode != PXEBC_DHCP4_TAG_EOP)) {\r
112 //\r
113 // Parse all the interesting PXE vendor options one by one.\r
114 //\r
115 switch (PxeOption->OpCode) {\r
116\r
117 case PXEBC_VENDOR_TAG_MTFTP_IP:\r
118\r
119 CopyMem (&VendorOption->MtftpIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));\r
120 break;\r
121\r
122 case PXEBC_VENDOR_TAG_MTFTP_CPORT:\r
123\r
124 CopyMem (&VendorOption->MtftpCPort, PxeOption->Data, sizeof (VendorOption->MtftpCPort));\r
125 break;\r
126\r
127 case PXEBC_VENDOR_TAG_MTFTP_SPORT:\r
128\r
129 CopyMem (&VendorOption->MtftpSPort, PxeOption->Data, sizeof (VendorOption->MtftpSPort));\r
130 break;\r
131\r
132 case PXEBC_VENDOR_TAG_MTFTP_TIMEOUT:\r
133\r
134 VendorOption->MtftpTimeout = *PxeOption->Data;\r
135 break;\r
136\r
137 case PXEBC_VENDOR_TAG_MTFTP_DELAY:\r
138\r
139 VendorOption->MtftpDelay = *PxeOption->Data;\r
140 break;\r
141\r
142 case PXEBC_VENDOR_TAG_DISCOVER_CTRL:\r
143\r
144 VendorOption->DiscoverCtrl = *PxeOption->Data;\r
145 break;\r
146\r
147 case PXEBC_VENDOR_TAG_DISCOVER_MCAST:\r
148\r
149 CopyMem (&VendorOption->DiscoverMcastIp, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));\r
150 break;\r
151\r
152 case PXEBC_VENDOR_TAG_BOOT_SERVERS:\r
153\r
154 VendorOption->BootSvrLen = PxeOption->Length;\r
155 VendorOption->BootSvr = (PXEBC_BOOT_SVR_ENTRY *) PxeOption->Data;\r
156 break;\r
157\r
158 case PXEBC_VENDOR_TAG_BOOT_MENU:\r
159\r
160 VendorOption->BootMenuLen = PxeOption->Length;\r
161 VendorOption->BootMenu = (PXEBC_BOOT_MENU_ENTRY *) PxeOption->Data;\r
162 break;\r
163\r
164 case PXEBC_VENDOR_TAG_MENU_PROMPT:\r
165\r
166 VendorOption->MenuPromptLen = PxeOption->Length;\r
167 VendorOption->MenuPrompt = (PXEBC_MENU_PROMPT *) PxeOption->Data;\r
168 break;\r
169\r
170 case PXEBC_VENDOR_TAG_MCAST_ALLOC:\r
171\r
172 CopyMem (&VendorOption->McastIpBase, PxeOption->Data, sizeof (EFI_IPv4_ADDRESS));\r
173 CopyMem (&VendorOption->McastIpBlock, PxeOption->Data + 4, sizeof (VendorOption->McastIpBlock));\r
174 CopyMem (&VendorOption->McastIpRange, PxeOption->Data + 6, sizeof (VendorOption->McastIpRange));\r
175 break;\r
176\r
177 case PXEBC_VENDOR_TAG_CREDENTIAL_TYPES:\r
178\r
179 VendorOption->CredTypeLen = PxeOption->Length;\r
180 VendorOption->CredType = (UINT32 *) PxeOption->Data;\r
181 break;\r
182\r
183 case PXEBC_VENDOR_TAG_BOOT_ITEM:\r
184\r
185 CopyMem (&VendorOption->BootSrvType, PxeOption->Data, sizeof (VendorOption->BootSrvType));\r
186 CopyMem (&VendorOption->BootSrvLayer, PxeOption->Data + 2, sizeof (VendorOption->BootSrvLayer));\r
187 break;\r
188\r
189 default:\r
190 //\r
191 // Not interesting PXE vendor options.\r
192 //\r
193 break;\r
194 }\r
195\r
196 //\r
197 // Set the bit map for the special PXE options.\r
198 //\r
199 SET_VENDOR_OPTION_BIT_MAP (BitMap, PxeOption->OpCode);\r
200\r
201 //\r
202 // Continue to the next option.\r
203 //\r
204 if (PxeOption->OpCode == PXEBC_DHCP4_TAG_PAD) {\r
205 Offset++;\r
206 } else {\r
207 Offset = (UINT8) (Offset + PxeOption->Length + 2);\r
208 }\r
209\r
210 PxeOption = (EFI_DHCP4_PACKET_OPTION *) (Dhcp4Option->Data + Offset);\r
211 }\r
212}\r
213\r
214\r
215/**\r
216 Build the options buffer for the DHCPv4 request packet.\r
217\r
218 @param[in] Private Pointer to PxeBc private data.\r
219 @param[out] OptList Pointer to the option pointer array.\r
220 @param[in] Buffer Pointer to the buffer to contain the option list.\r
221 @param[in] NeedMsgType If TRUE, it is necessary to include the Msg type option.\r
222 Otherwise, it is not necessary.\r
223\r
224 @return Index The count of the built-in options.\r
225\r
226**/\r
227UINT32\r
228PxeBcBuildDhcp4Options (\r
229 IN PXEBC_PRIVATE_DATA *Private,\r
230 OUT EFI_DHCP4_PACKET_OPTION **OptList,\r
231 IN UINT8 *Buffer,\r
232 IN BOOLEAN NeedMsgType\r
233 )\r
234{\r
235 UINT32 Index;\r
236 PXEBC_DHCP4_OPTION_ENTRY OptEnt;\r
237 UINT16 Value;\r
238\r
239 Index = 0;\r
240 OptList[0] = (EFI_DHCP4_PACKET_OPTION *) Buffer;\r
241\r
242 if (NeedMsgType) {\r
243 //\r
244 // Append message type.\r
245 //\r
246 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MSG_TYPE;\r
247 OptList[Index]->Length = 1;\r
248 OptEnt.Mesg = (PXEBC_DHCP4_OPTION_MESG *) OptList[Index]->Data;\r
249 OptEnt.Mesg->Type = PXEBC_DHCP4_MSG_TYPE_REQUEST;\r
250 Index++;\r
251 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
252\r
253 //\r
254 // Append max message size.\r
255 //\r
256 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_MAXMSG;\r
257 OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE);\r
258 OptEnt.MaxMesgSize = (PXEBC_DHCP4_OPTION_MAX_MESG_SIZE *) OptList[Index]->Data;\r
259 Value = NTOHS (PXEBC_DHCP4_PACKET_MAX_SIZE - 8);\r
260 CopyMem (&OptEnt.MaxMesgSize->Size, &Value, sizeof (UINT16));\r
261 Index++;\r
262 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
263 }\r
264\r
265 //\r
266 // Append parameter request list option.\r
267 //\r
268 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_PARA_LIST;\r
269 OptList[Index]->Length = 35;\r
270 OptEnt.Para = (PXEBC_DHCP4_OPTION_PARA *) OptList[Index]->Data;\r
271 OptEnt.Para->ParaList[0] = PXEBC_DHCP4_TAG_NETMASK;\r
272 OptEnt.Para->ParaList[1] = PXEBC_DHCP4_TAG_TIME_OFFSET;\r
273 OptEnt.Para->ParaList[2] = PXEBC_DHCP4_TAG_ROUTER;\r
274 OptEnt.Para->ParaList[3] = PXEBC_DHCP4_TAG_TIME_SERVER;\r
275 OptEnt.Para->ParaList[4] = PXEBC_DHCP4_TAG_NAME_SERVER;\r
276 OptEnt.Para->ParaList[5] = PXEBC_DHCP4_TAG_DNS_SERVER;\r
277 OptEnt.Para->ParaList[6] = PXEBC_DHCP4_TAG_HOSTNAME;\r
278 OptEnt.Para->ParaList[7] = PXEBC_DHCP4_TAG_BOOTFILE_LEN;\r
279 OptEnt.Para->ParaList[8] = PXEBC_DHCP4_TAG_DOMAINNAME;\r
280 OptEnt.Para->ParaList[9] = PXEBC_DHCP4_TAG_ROOTPATH;\r
281 OptEnt.Para->ParaList[10] = PXEBC_DHCP4_TAG_EXTEND_PATH;\r
282 OptEnt.Para->ParaList[11] = PXEBC_DHCP4_TAG_EMTU;\r
283 OptEnt.Para->ParaList[12] = PXEBC_DHCP4_TAG_TTL;\r
284 OptEnt.Para->ParaList[13] = PXEBC_DHCP4_TAG_BROADCAST;\r
285 OptEnt.Para->ParaList[14] = PXEBC_DHCP4_TAG_NIS_DOMAIN;\r
286 OptEnt.Para->ParaList[15] = PXEBC_DHCP4_TAG_NIS_SERVER;\r
287 OptEnt.Para->ParaList[16] = PXEBC_DHCP4_TAG_NTP_SERVER;\r
288 OptEnt.Para->ParaList[17] = PXEBC_DHCP4_TAG_VENDOR;\r
289 OptEnt.Para->ParaList[18] = PXEBC_DHCP4_TAG_REQUEST_IP;\r
290 OptEnt.Para->ParaList[19] = PXEBC_DHCP4_TAG_LEASE;\r
291 OptEnt.Para->ParaList[20] = PXEBC_DHCP4_TAG_SERVER_ID;\r
292 OptEnt.Para->ParaList[21] = PXEBC_DHCP4_TAG_T1;\r
293 OptEnt.Para->ParaList[22] = PXEBC_DHCP4_TAG_T2;\r
294 OptEnt.Para->ParaList[23] = PXEBC_DHCP4_TAG_CLASS_ID;\r
295 OptEnt.Para->ParaList[24] = PXEBC_DHCP4_TAG_TFTP;\r
296 OptEnt.Para->ParaList[25] = PXEBC_DHCP4_TAG_BOOTFILE;\r
297 OptEnt.Para->ParaList[26] = PXEBC_PXE_DHCP4_TAG_UUID;\r
298 OptEnt.Para->ParaList[27] = 0x80;\r
299 OptEnt.Para->ParaList[28] = 0x81;\r
300 OptEnt.Para->ParaList[29] = 0x82;\r
301 OptEnt.Para->ParaList[30] = 0x83;\r
302 OptEnt.Para->ParaList[31] = 0x84;\r
303 OptEnt.Para->ParaList[32] = 0x85;\r
304 OptEnt.Para->ParaList[33] = 0x86;\r
305 OptEnt.Para->ParaList[34] = 0x87;\r
306 Index++;\r
307 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
308\r
309 //\r
310 // Append UUID/Guid-based client identifier option\r
311 //\r
312 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UUID;\r
313 OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_UUID);\r
314 OptEnt.Uuid = (PXEBC_DHCP4_OPTION_UUID *) OptList[Index]->Data;\r
315 OptEnt.Uuid->Type = 0;\r
316 Index++;\r
317 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
318\r
19ddbb25 319 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) OptEnt.Uuid->Guid))) {\r
a3bcde70
HT		 320 //\r
321 // Zero the Guid to indicate NOT programable if failed to get system Guid.\r
322 //\r
323 ZeroMem (OptEnt.Uuid->Guid, sizeof (EFI_GUID));\r
324 }\r
325\r
326 //\r
327 // Append client network device interface option\r
328 //\r
329 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_UNDI;\r
330 OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_UNDI);\r
331 OptEnt.Undi = (PXEBC_DHCP4_OPTION_UNDI *) OptList[Index]->Data;\r
332\r
333 if (Private->Nii != NULL) {\r
334 OptEnt.Undi->Type = Private->Nii->Type;\r
335 OptEnt.Undi->MajorVer = Private->Nii->MajorVer;\r
336 OptEnt.Undi->MinorVer = Private->Nii->MinorVer;\r
337 } else {\r
338 OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;\r
339 OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;\r
340 OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;\r
341 }\r
342\r
343 Index++;\r
344 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
345\r
346 //\r
347 // Append client system architecture option\r
348 //\r
349 OptList[Index]->OpCode = PXEBC_PXE_DHCP4_TAG_ARCH;\r
350 OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_ARCH);\r
351 OptEnt.Arch = (PXEBC_DHCP4_OPTION_ARCH *) OptList[Index]->Data;\r
352 Value = HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE);\r
353 CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));\r
354 Index++;\r
355 OptList[Index] = GET_NEXT_DHCP_OPTION (OptList[Index - 1]);\r
356\r
357 //\r
358 // Append vendor class identify option\r
359 //\r
360 OptList[Index]->OpCode = PXEBC_DHCP4_TAG_CLASS_ID;\r
361 OptList[Index]->Length = (UINT8) sizeof (PXEBC_DHCP4_OPTION_CLID);\r
362 OptEnt.Clid = (PXEBC_DHCP4_OPTION_CLID *) OptList[Index]->Data;\r
363 CopyMem (\r
364 OptEnt.Clid,\r
365 DEFAULT_CLASS_ID_DATA,\r
366 sizeof (PXEBC_DHCP4_OPTION_CLID)\r
367 );\r
368 PxeBcUintnToAscDecWithFormat (\r
369 EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE,\r
370 OptEnt.Clid->ArchitectureType,\r
371 sizeof (OptEnt.Clid->ArchitectureType)\r
372 );\r
373\r
374 if (Private->Nii != NULL) {\r
375 CopyMem (OptEnt.Clid->InterfaceName, Private->Nii->StringId, sizeof (OptEnt.Clid->InterfaceName));\r
376 PxeBcUintnToAscDecWithFormat (Private->Nii->MajorVer, OptEnt.Clid->UndiMajor, sizeof (OptEnt.Clid->UndiMajor));\r
377 PxeBcUintnToAscDecWithFormat (Private->Nii->MinorVer, OptEnt.Clid->UndiMinor, sizeof (OptEnt.Clid->UndiMinor));\r
378 }\r
379\r
380 Index++;\r
381\r
382 return Index;\r
383}\r
384\r
385\r
386/**\r
387 Create a template DHCPv4 packet as a seed.\r
388\r
389 @param[out] Seed Pointer to the seed packet.\r
390 @param[in] Udp4 Pointer to EFI_UDP4_PROTOCOL.\r
391\r
392**/\r
393VOID\r
394PxeBcSeedDhcp4Packet (\r
395 OUT EFI_DHCP4_PACKET *Seed,\r
396 IN EFI_UDP4_PROTOCOL *Udp4\r
397 )\r
398{\r
399 EFI_SIMPLE_NETWORK_MODE Mode;\r
400 EFI_DHCP4_HEADER *Header;\r
401\r
402 //\r
403 // Get IfType and HwAddressSize from SNP mode data.\r
404 //\r
405 Udp4->GetModeData (Udp4, NULL, NULL, NULL, &Mode);\r
406\r
407 Seed->Size = sizeof (EFI_DHCP4_PACKET);\r
408 Seed->Length = sizeof (Seed->Dhcp4);\r
409 Header = &Seed->Dhcp4.Header;\r
410 ZeroMem (Header, sizeof (EFI_DHCP4_HEADER));\r
411 Header->OpCode = PXEBC_DHCP4_OPCODE_REQUEST;\r
412 Header->HwType = Mode.IfType;\r
413 Header->HwAddrLen = (UINT8) Mode.HwAddressSize;\r
414 CopyMem (Header->ClientHwAddr, &Mode.CurrentAddress, Header->HwAddrLen);\r
415\r
416 Seed->Dhcp4.Magik = PXEBC_DHCP4_MAGIC;\r
417 Seed->Dhcp4.Option[0] = PXEBC_DHCP4_TAG_EOP;\r
418}\r
419\r
420\r
421/**\r
422 Cache the DHCPv4 packet.\r
423\r
424 @param[in] Dst Pointer to the cache buffer for DHCPv4 packet.\r
425 @param[in] Src Pointer to the DHCPv4 packet to be cached.\r
426\r
427**/\r
428VOID\r
429PxeBcCacheDhcp4Packet (\r
430 IN EFI_DHCP4_PACKET *Dst,\r
431 IN EFI_DHCP4_PACKET *Src\r
432 )\r
433{\r
434 ASSERT (Dst->Size >= Src->Length);\r
435\r
436 CopyMem (&Dst->Dhcp4, &Src->Dhcp4, Src->Length);\r
437 Dst->Length = Src->Length;\r
438}\r
439\r
440\r
441/**\r
442 Parse the cached DHCPv4 packet, including all the options.\r
443\r
444 @param[in] Cache4 Pointer to cached DHCPv4 packet.\r
445\r
446 @retval EFI_SUCCESS Parsed the DHCPv4 packet successfully.\r
447 @retval EFI_DEVICE_ERROR Failed to parse and invalid packet.\r
448\r
449**/\r
450EFI_STATUS\r
451PxeBcParseDhcp4Packet (\r
452 IN PXEBC_DHCP4_PACKET_CACHE *Cache4\r
453 )\r
454{\r
455 EFI_DHCP4_PACKET *Offer;\r
456 EFI_DHCP4_PACKET_OPTION **Options;\r
457 EFI_DHCP4_PACKET_OPTION *Option;\r
458 PXEBC_OFFER_TYPE OfferType;\r
459 UINTN Index;\r
460 BOOLEAN IsProxyOffer;\r
461 BOOLEAN IsPxeOffer;\r
462 UINT8 *Ptr8;\r
463\r
464 IsProxyOffer = FALSE;\r
465 IsPxeOffer = FALSE;\r
466\r
467 ZeroMem (Cache4->OptList, sizeof (Cache4->OptList));\r
468 ZeroMem (&Cache4->VendorOpt, sizeof (Cache4->VendorOpt));\r
469\r
470 Offer = &Cache4->Packet.Offer;\r
471 Options = Cache4->OptList;\r
472\r
473 //\r
474 // Parse DHCPv4 options in this offer, and store the pointers.\r
475 //\r
476 for (Index = 0; Index < PXEBC_DHCP4_TAG_INDEX_MAX; Index++) {\r
477 Options[Index] = PxeBcParseDhcp4Options (\r
478 Offer->Dhcp4.Option,\r
479 GET_OPTION_BUFFER_LEN (Offer),\r
480 mInterestedDhcp4Tags[Index]\r
481 );\r
482 }\r
483\r
484 //\r
485 // The offer with "yiaddr" is a proxy offer.\r
486 //\r
487 if (Offer->Dhcp4.Header.YourAddr.Addr[0] == 0) {\r
488 IsProxyOffer = TRUE;\r
489 }\r
490\r
491 //\r
492 // The offer with "PXEClient" is a PXE offer.\r
493 //\r
494 Option = Options[PXEBC_DHCP4_TAG_INDEX_CLASS_ID];\r
495 if ((Option != NULL) && (Option->Length >= 9) &&\r
496 (CompareMem (Option->Data, DEFAULT_CLASS_ID_DATA, 9) == 0)) {\r
497 IsPxeOffer = TRUE;\r
498 }\r
499\r
500 //\r
501 // Parse PXE vendor options in this offer, and store the contents/pointers.\r
502 //\r
503 Option = Options[PXEBC_DHCP4_TAG_INDEX_VENDOR];\r
504 if (IsPxeOffer && Option != NULL) {\r
505 PxeBcParseVendorOptions (Option, &Cache4->VendorOpt);\r
506 }\r
507\r
508 //\r
509 // Check whether bootfilename and serverhostname overloaded, refers to rfc-2132 in details.\r
510 // If overloaded, parse the buffer as nested DHCPv4 options, or else just parse as bootfilename\r
511 // and serverhostname option.\r
512 //\r
513 Option = Options[PXEBC_DHCP4_TAG_INDEX_OVERLOAD];\r
514 if (Option != NULL && (Option->Data[0] & PXEBC_DHCP4_OVERLOAD_FILE) != 0) {\r
515\r
516 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = PxeBcParseDhcp4Options (\r
517 (UINT8 *) Offer->Dhcp4.Header.BootFileName,\r
518 sizeof (Offer->Dhcp4.Header.BootFileName),\r
519 PXEBC_DHCP4_TAG_BOOTFILE\r
520 );\r
521 //\r
522 // RFC 2132, Section 9.5 does not strictly state Bootfile name (option 67) is null\r
523 // terminated string. So force to append null terminated character at the end of string.\r
524 //\r
525 if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {\r
526 Ptr8 = (UINT8*)&Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Data[0];\r
527 Ptr8 += Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE]->Length;\r
528 *Ptr8 = '\0';\r
529 }\r
530\r
531 } else if ((Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) &&\r
532 (Offer->Dhcp4.Header.BootFileName[0] != 0)) {\r
533 //\r
534 // If the bootfile is not present and bootfilename is present in DHCPv4 packet, just parse it.\r
535 // Do not count dhcp option header here, or else will destory the serverhostname.\r
536 //\r
537 Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] = (EFI_DHCP4_PACKET_OPTION *)\r
538 (&Offer->Dhcp4.Header.BootFileName[0] -\r
539 OFFSET_OF (EFI_DHCP4_PACKET_OPTION, Data[0]));\r
540\r
541 }\r
542\r
543 //\r
544 // Determine offer type of the DHCPv4 packet.\r
545 //\r
546 Option = Options[PXEBC_DHCP4_TAG_INDEX_MSG_TYPE];\r
547 if (Option == NULL || Option->Data[0] == 0) {\r
548 //\r
549 // It's a Bootp offer.\r
550 //\r
551 OfferType = PxeOfferTypeBootp;\r
552\r
553 Option = Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE];\r
554 if (Option == NULL) {\r
555 //\r
556 // If the Bootp offer without bootfilename, discard it.\r
557 //\r
558 return EFI_DEVICE_ERROR;\r
559 }\r
560 } else {\r
561\r
562 if (IS_VALID_DISCOVER_VENDOR_OPTION (Cache4->VendorOpt.BitMap)) {\r
563 //\r
564 // It's a PXE10 offer with PXEClient and discover vendor option.\r
565 //\r
566 OfferType = IsProxyOffer ? PxeOfferTypeProxyPxe10 : PxeOfferTypeDhcpPxe10;\r
567 } else if (IS_VALID_MTFTP_VENDOR_OPTION (Cache4->VendorOpt.BitMap)) {\r
568 //\r
569 // It's a WFM11a offer with PXEClient and mtftp vendor option.\r
570 // But multi-cast download is not supported currently, so discard it.\r
571 //\r
572 return EFI_DEVICE_ERROR;\r
573 } else if (IsPxeOffer) {\r
574 //\r
575 // It's a BINL offer only with PXEClient.\r
576 //\r
577 OfferType = IsProxyOffer ? PxeOfferTypeProxyBinl : PxeOfferTypeDhcpBinl;\r
578 } else {\r
579 //\r
580 // It's a DHCPv4 only offer, which is a pure DHCPv4 offer packet.\r
581 //\r
582 OfferType = PxeOfferTypeDhcpOnly;\r
583 }\r
584 }\r
585\r
586 Cache4->OfferType = OfferType;\r
587\r
588 return EFI_SUCCESS;\r
589}\r
590\r
591\r
592/**\r
593 Cache the DHCPv4 ack packet, and parse it on demand.\r
594\r
595 @param[in] Private Pointer to PxeBc private data.\r
596 @param[in] Ack Pointer to the DHCPv4 ack packet.\r
597 @param[in] Verified If TRUE, parse the ACK packet and store info into mode data.\r
598\r
599**/\r
600VOID\r
601PxeBcCopyDhcp4Ack (\r
602 IN PXEBC_PRIVATE_DATA *Private,\r
603 IN EFI_DHCP4_PACKET *Ack,\r
604 IN BOOLEAN Verified\r
605 )\r
606{\r
607 EFI_PXE_BASE_CODE_MODE *Mode;\r
608\r
609 Mode = Private->PxeBc.Mode;\r
610\r
611 PxeBcCacheDhcp4Packet (&Private->DhcpAck.Dhcp4.Packet.Ack, Ack);\r
612\r
613 if (Verified) {\r
614 //\r
615 // Parse the ack packet and store it into mode data if needed.\r
616 //\r
617 PxeBcParseDhcp4Packet (&Private->DhcpAck.Dhcp4);\r
618 CopyMem (&Mode->DhcpAck.Dhcpv4, &Ack->Dhcp4, Ack->Length);\r
619 Mode->DhcpAckReceived = TRUE;\r
620 }\r
621}\r
622\r
623\r
624/**\r
625 Cache the DHCPv4 proxy offer packet according to the received order.\r
626\r
627 @param[in] Private Pointer to PxeBc private data.\r
628 @param[in] OfferIndex The received order of offer packets.\r
629\r
630**/\r
631VOID\r
632PxeBcCopyProxyOffer (\r
633 IN PXEBC_PRIVATE_DATA *Private,\r
634 IN UINT32 OfferIndex\r
635 )\r
636{\r
637 EFI_PXE_BASE_CODE_MODE *Mode;\r
638 EFI_DHCP4_PACKET *Offer;\r
639\r
640 ASSERT (OfferIndex < Private->OfferNum);\r
641 ASSERT (OfferIndex < PXEBC_OFFER_MAX_NUM);\r
642\r
643 Mode = Private->PxeBc.Mode;\r
644 Offer = &Private->OfferBuffer[OfferIndex].Dhcp4.Packet.Offer;\r
645\r
646 //\r
647 // Cache the proxy offer packet and parse it.\r
648 //\r
649 PxeBcCacheDhcp4Packet (&Private->ProxyOffer.Dhcp4.Packet.Offer, Offer);\r
650 PxeBcParseDhcp4Packet (&Private->ProxyOffer.Dhcp4);\r
651\r
652 //\r
653 // Store this packet into mode data.\r
654 //\r
655 CopyMem (&Mode->ProxyOffer.Dhcpv4, &Offer->Dhcp4, Offer->Length);\r
656 Mode->ProxyOfferReceived = TRUE;\r
657}\r
658\r
659\r
660/**\r
661 Retry to request bootfile name by the BINL offer.\r
662\r
663 @param[in] Private Pointer to PxeBc private data.\r
664 @param[in] Index The received order of offer packets.\r
665\r
666 @retval EFI_SUCCESS Successfully retried to request bootfile name.\r
667 @retval EFI_DEVICE_ERROR Failed to retry bootfile name.\r
668\r
669**/\r
670EFI_STATUS\r
671PxeBcRetryBinlOffer (\r
672 IN PXEBC_PRIVATE_DATA *Private,\r
673 IN UINT32 Index\r
674 )\r
675{\r
676 EFI_DHCP4_PACKET *Offer;\r
677 EFI_IP_ADDRESS ServerIp;\r
678 EFI_STATUS Status;\r
679 PXEBC_DHCP4_PACKET_CACHE *Cache4;\r
680 EFI_DHCP4_PACKET *Reply;\r
681\r
682 ASSERT (Index < PXEBC_OFFER_MAX_NUM);\r
683 ASSERT (Private->OfferBuffer[Index].Dhcp4.OfferType == PxeOfferTypeDhcpBinl ||\r
684 Private->OfferBuffer[Index].Dhcp4.OfferType == PxeOfferTypeProxyBinl);\r
685\r
686 Offer = &Private->OfferBuffer[Index].Dhcp4.Packet.Offer;\r
687\r
688 //\r
689 // Prefer to siaddr in header as next server address. If it's zero, then use option 54.\r
690 //\r
691 if (Offer->Dhcp4.Header.ServerAddr.Addr[0] == 0) {\r
692 CopyMem (\r
693 &ServerIp.Addr[0],\r
694 Private->OfferBuffer[Index].Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_SERVER_ID]->Data,\r
695 sizeof (EFI_IPv4_ADDRESS)\r
696 );\r
697 } else {\r
698 CopyMem (\r
699 &ServerIp.Addr[0],\r
700 &Offer->Dhcp4.Header.ServerAddr,\r
701 sizeof (EFI_IPv4_ADDRESS)\r
702 );\r
703 }\r
704\r
705 Private->IsDoDiscover = FALSE;\r
706 Cache4 = &Private->ProxyOffer.Dhcp4;\r
707 Reply = &Cache4->Packet.Offer;\r
708\r
709 //\r
710 // Send another request packet for bootfile name.\r
711 //\r
712 Status = PxeBcDhcp4Discover (\r
713 Private,\r
714 0,\r
715 NULL,\r
716 FALSE,\r
717 &ServerIp,\r
718 0,\r
719 NULL\r
720 );\r
721 if (EFI_ERROR (Status)) {\r
722 return Status;\r
723 }\r
724\r
725 //\r
726 // Parse the reply for the last request packet.\r
727 //\r
728 Status = PxeBcParseDhcp4Packet (Cache4);\r
729 if (EFI_ERROR (Status)) {\r
730 return Status;\r
731 }\r
732\r
733 if (Cache4->OfferType != PxeOfferTypeProxyPxe10 &&\r
734 Cache4->OfferType != PxeOfferTypeProxyWfm11a &&\r
735 Cache4->OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {\r
736 //\r
737 // This BINL ack doesn't have discovery option set or multicast option set\r
738 // or bootfile name specified.\r
739 //\r
740 return EFI_DEVICE_ERROR;\r
741 }\r
742\r
743 //\r
744 // Store the reply into mode data.\r
745 //\r
746 Private->PxeBc.Mode->ProxyOfferReceived = TRUE;\r
747 CopyMem (&Private->PxeBc.Mode->ProxyOffer.Dhcpv4, &Reply->Dhcp4, Reply->Length);\r
748\r
749 return EFI_SUCCESS;\r
750}\r
751\r
752\r
753/**\r
754 Cache all the received DHCPv4 offers, and set OfferIndex and OfferCount.\r
755\r
756 @param[in] Private Pointer to PxeBc private data.\r
757 @param[in] RcvdOffer Pointer to the received offer packet.\r
758\r
759**/\r
760VOID\r
761PxeBcCacheDhcp4Offer (\r
762 IN PXEBC_PRIVATE_DATA *Private,\r
763 IN EFI_DHCP4_PACKET *RcvdOffer\r
764 )\r
765{\r
766 PXEBC_DHCP4_PACKET_CACHE *Cache4;\r
767 EFI_DHCP4_PACKET *Offer;\r
768 PXEBC_OFFER_TYPE OfferType;\r
769\r
770 ASSERT (Private->OfferNum < PXEBC_OFFER_MAX_NUM);\r
771 Cache4 = &Private->OfferBuffer[Private->OfferNum].Dhcp4;\r
772 Offer = &Cache4->Packet.Offer;\r
773\r
774 //\r
775 // Cache the content of DHCPv4 packet firstly.\r
776 //\r
777 PxeBcCacheDhcp4Packet (Offer, RcvdOffer);\r
778\r
779 //\r
780 // Validate the DHCPv4 packet, and parse the options and offer type.\r
781 //\r
782 if (EFI_ERROR (PxeBcParseDhcp4Packet (Cache4))) {\r
783 return;\r
784 }\r
785\r
786 //\r
787 // Determine whether cache the current offer by type, and record OfferIndex and OfferCount.\r
788 //\r
789 OfferType = Cache4->OfferType;\r
790 ASSERT (OfferType < PxeOfferTypeMax);\r
791\r
792 if (OfferType == PxeOfferTypeBootp) {\r
793 //\r
794 // It's a Bootp offer, only cache the first one, and discard the others.\r
795 //\r
796 if (Private->OfferCount[OfferType] == 0) {\r
797 Private->OfferIndex[OfferType][0] = Private->OfferNum;\r
798 Private->OfferCount[OfferType] = 1;\r
799 } else {\r
800 return;\r
801 }\r
802 } else {\r
803 ASSERT (Private->OfferCount[OfferType] < PXEBC_OFFER_MAX_NUM);\r
804 if (IS_PROXY_DHCP_OFFER (Offer)) {\r
805 //\r
806 // It's a proxy offer without yiaddr, including PXE10, WFM11a or BINL offer.\r
807 //\r
808 Private->IsProxyRecved = TRUE;\r
809\r
810 if (OfferType == PxeOfferTypeProxyBinl) {\r
811 //\r
812 // Cache all proxy BINL offers.\r
813 //\r
814 Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
815 Private->OfferCount[OfferType]++;\r
816 } else if (Private->OfferCount[OfferType] > 0) {\r
817 //\r
818 // Only cache the first PXE10/WFM11a offer, and discard the others.\r
819 //\r
820 Private->OfferIndex[OfferType][0] = Private->OfferNum;\r
821 Private->OfferCount[OfferType] = 1;\r
822 } else {\r
823 return ;\r
824 }\r
825 } else {\r
826 //\r
827 // It's a DHCPv4 offer with yiaddr, and cache them all.\r
828 //\r
829 Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
830 Private->OfferCount[OfferType]++;\r
831 }\r
832 }\r
833\r
834 Private->OfferNum++;\r
835}\r
836\r
837\r
838/**\r
839 Select an DHCPv4 offer, and record SelectIndex and SelectProxyType.\r
840\r
841 @param[in] Private Pointer to PxeBc private data.\r
842\r
843**/\r
844VOID\r
845PxeBcSelectDhcp4Offer (\r
846 IN PXEBC_PRIVATE_DATA *Private\r
847 )\r
848{\r
849 UINT32 Index;\r
850 UINT32 OfferIndex;\r
851 EFI_DHCP4_PACKET *Offer;\r
852\r
853 Private->SelectIndex = 0;\r
854\r
855 if (Private->IsOfferSorted) {\r
856 //\r
857 // Select offer by default policy.\r
858 //\r
859 if (Private->OfferCount[PxeOfferTypeDhcpPxe10] > 0) {\r
860 //\r
861 // 1. DhcpPxe10 offer\r
862 //\r
863 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpPxe10][0] + 1;\r
864\r
865 } else if (Private->OfferCount[PxeOfferTypeDhcpWfm11a] > 0) {\r
866 //\r
867 // 2. DhcpWfm11a offer\r
868 //\r
869 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpWfm11a][0] + 1;\r
870\r
871 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
872 Private->OfferCount[PxeOfferTypeProxyPxe10] > 0) {\r
873 //\r
874 // 3. DhcpOnly offer and ProxyPxe10 offer.\r
875 //\r
876 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
877 Private->SelectProxyType = PxeOfferTypeProxyPxe10;\r
878\r
879 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
880 Private->OfferCount[PxeOfferTypeProxyWfm11a] > 0) {\r
881 //\r
882 // 4. DhcpOnly offer and ProxyWfm11a offer.\r
883 //\r
884 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
885 Private->SelectProxyType = PxeOfferTypeProxyWfm11a;\r
886\r
887 } else if (Private->OfferCount[PxeOfferTypeDhcpBinl] > 0) {\r
888 //\r
889 // 5. DhcpBinl offer.\r
890 //\r
891 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpBinl][0] + 1;\r
892\r
893 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
894 Private->OfferCount[PxeOfferTypeProxyBinl] > 0) {\r
895 //\r
896 // 6. DhcpOnly offer and ProxyBinl offer.\r
897 //\r
898 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
899 Private->SelectProxyType = PxeOfferTypeProxyBinl;\r
900\r
901 } else {\r
902 //\r
903 // 7. DhcpOnly offer with bootfilename.\r
904 //\r
905 for (Index = 0; Index < Private->OfferCount[PxeOfferTypeDhcpOnly]; Index++) {\r
906 OfferIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][Index];\r
907 if (Private->OfferBuffer[OfferIndex].Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {\r
908 Private->SelectIndex = OfferIndex + 1;\r
909 break;\r
910 }\r
911 }\r
912 //\r
913 // 8. Bootp offer with bootfilename.\r
914 //\r
915 OfferIndex = Private->OfferIndex[PxeOfferTypeBootp][0];\r
916 if (Private->SelectIndex == 0 &&\r
917 Private->OfferCount[PxeOfferTypeBootp] > 0 &&\r
918 Private->OfferBuffer[OfferIndex].Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] != NULL) {\r
919 Private->SelectIndex = OfferIndex + 1;\r
920 }\r
921 }\r
922 } else {\r
923 //\r
924 // Select offer by received order.\r
925 //\r
926 for (Index = 0; Index < Private->OfferNum; Index++) {\r
927\r
928 Offer = &Private->OfferBuffer[Index].Dhcp4.Packet.Offer;\r
929\r
930 if (IS_PROXY_DHCP_OFFER (Offer)) {\r
931 //\r
932 // Skip proxy offers\r
933 //\r
934 continue;\r
935 }\r
936\r
937 if (!Private->IsProxyRecved &&\r
938 Private->OfferBuffer[Index].Dhcp4.OfferType == PxeOfferTypeDhcpOnly &&\r
939 Private->OfferBuffer[Index].Dhcp4.OptList[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {\r
940 //\r
941 // Skip if DhcpOnly offer without any other proxy offers or bootfilename.\r
942 //\r
943 continue;\r
944 }\r
945\r
946 //\r
947 // Record the index of the select offer.\r
948 //\r
949 Private->SelectIndex = Index + 1;\r
950 break;\r
951 }\r
952 }\r
953}\r
954\r
955\r
956/**\r
957 Handle the DHCPv4 offer packet.\r
958\r
959 @param[in] Private Pointer to PxeBc private data.\r
960\r
961 @retval EFI_SUCCESS Handled the DHCPv4 offer packet successfully.\r
962 @retval EFI_NO_RESPONSE No response to the following request packet.\r
4496ff75 963 @retval EFI_NOT_FOUND No boot filename received.\r
a3bcde70
HT		 964\r
965**/\r
966EFI_STATUS\r
967PxeBcHandleDhcp4Offer (\r
968 IN PXEBC_PRIVATE_DATA *Private\r
969 )\r
970{\r
971 PXEBC_DHCP4_PACKET_CACHE *Cache4;\r
972 EFI_DHCP4_PACKET_OPTION **Options;\r
973 UINT32 Index;\r
974 EFI_DHCP4_PACKET *Offer;\r
975 PXEBC_OFFER_TYPE OfferType;\r
976 UINT32 ProxyIndex;\r
977 UINT32 SelectIndex;\r
978 EFI_STATUS Status;\r
979 EFI_PXE_BASE_CODE_MODE *Mode;\r
980 EFI_DHCP4_PACKET *Ack;\r
981\r
982 ASSERT (Private->SelectIndex > 0);\r
983 SelectIndex = (UINT32) (Private->SelectIndex - 1);\r
984 ASSERT (SelectIndex < PXEBC_OFFER_MAX_NUM);\r
985 Cache4 = &Private->OfferBuffer[SelectIndex].Dhcp4;\r
986 Options = Cache4->OptList;\r
987 Status = EFI_SUCCESS;\r
988\r
989 if (Cache4->OfferType == PxeOfferTypeDhcpBinl) {\r
990 //\r
991 // DhcpBinl offer is selected, so need try to request bootfilename by this offer.\r
992 //\r
993 if (EFI_ERROR (PxeBcRetryBinlOffer (Private, SelectIndex))) {\r
994 Status = EFI_NO_RESPONSE;\r
995 }\r
996 } else if (Cache4->OfferType == PxeOfferTypeDhcpOnly) {\r
997\r
998 if (Private->IsProxyRecved) {\r
999 //\r
1000 // DhcpOnly offer is selected, so need try to request bootfile name.\r
1001 //\r
1002 ProxyIndex = 0;\r
1003 if (Private->IsOfferSorted) {\r
1004 //\r
1005 // The proxy offer should be determined if select by default policy.\r
1006 // IsOfferSorted means all offers are labeled by OfferIndex.\r
1007 //\r
1008 ASSERT (Private->SelectProxyType < PxeOfferTypeMax);\r
1009 ASSERT (Private->OfferCount[Private->SelectProxyType] > 0);\r
1010\r
1011 if (Private->SelectProxyType == PxeOfferTypeProxyBinl) {\r
1012 //\r
1013 // Try all the cached ProxyBinl offer one by one to request bootfile name.\r
1014 //\r
1015 for (Index = 0; Index < Private->OfferCount[Private->SelectProxyType]; Index++) {\r
1016 ASSERT (Index < PXEBC_OFFER_MAX_NUM);\r
1017 ProxyIndex = Private->OfferIndex[Private->SelectProxyType][Index];\r
1018 if (!EFI_ERROR (PxeBcRetryBinlOffer (Private, ProxyIndex))) {\r
1019 break;\r
1020 }\r
1021 }\r
1022 if (Index == Private->OfferCount[Private->SelectProxyType]) {\r
1023 Status = EFI_NO_RESPONSE;\r
1024 }\r
1025 } else {\r
1026 //\r
1027 // For other proxy offers, only one is buffered.\r
1028 //\r
1029 ProxyIndex = Private->OfferIndex[Private->SelectProxyType][0];\r
1030 }\r
1031 } else {\r
1032 //\r
1033 // The proxy offer should not be determined if select by received order.\r
1034 //\r
1035 Status = EFI_NO_RESPONSE;\r
1036\r
1037 for (Index = 0; Index < Private->OfferNum; Index++) {\r
1038 ASSERT (Index < PXEBC_OFFER_MAX_NUM);\r
1039 Offer = &Private->OfferBuffer[Index].Dhcp4.Packet.Offer;\r
1040 OfferType = Private->OfferBuffer[Index].Dhcp4.OfferType;\r
1041 if (!IS_PROXY_DHCP_OFFER (Offer)) {\r
1042 //\r
1043 // Skip non proxy DHCPv4 offers.\r
1044 //\r
1045 continue;\r
1046 }\r
1047\r
1048 if (OfferType == PxeOfferTypeProxyBinl) {\r
1049 //\r
1050 // Try all the cached ProxyBinl offer one by one to request bootfile name.\r
1051 //\r
1052 if (EFI_ERROR (PxeBcRetryBinlOffer (Private, Index))) {\r
1053 continue;\r
1054 }\r
1055 }\r
1056\r
1057 Private->SelectProxyType = OfferType;\r
1058 ProxyIndex = Index;\r
1059 Status = EFI_SUCCESS;\r
1060 break;\r
1061 }\r
1062 }\r
1063\r
1064 if (!EFI_ERROR (Status) && Private->SelectProxyType != PxeOfferTypeProxyBinl) {\r
1065 //\r
1066 // Success to try to request by a ProxyPxe10 or ProxyWfm11a offer, copy and parse it.\r
1067 //\r
1068 PxeBcCopyProxyOffer (Private, ProxyIndex);\r
1069 }\r
1070 } else {\r
1071 //\r
1072 // Othewise, the bootfile name must be included in DhcpOnly offer.\r
1073 //\r
4496ff75 1074 if (Options[PXEBC_DHCP4_TAG_INDEX_BOOTFILE] == NULL) {\r
1075 Status = EFI_NOT_FOUND;\r
1076 }\r
a3bcde70
HT		 1077 }\r
1078 }\r
1079\r
1080 if (!EFI_ERROR (Status)) {\r
1081 //\r
1082 // All PXE boot information is ready by now.\r
1083 //\r
1084 Mode = Private->PxeBc.Mode;\r
1085 Offer = &Cache4->Packet.Offer;\r
1086 Ack = &Private->DhcpAck.Dhcp4.Packet.Ack;\r
1087 if (Cache4->OfferType == PxeOfferTypeBootp) {\r
1088 //\r
1089 // Bootp is a special case that only 2 packets involved instead of 4. So the bootp's reply\r
1090 // should be taken as ack.\r
1091 //\r
1092 Ack = Offer;\r
1093 }\r
1094\r
1095 PxeBcCopyDhcp4Ack (Private, Ack, TRUE);\r
1096 Mode->DhcpDiscoverValid = TRUE;\r
1097 }\r
1098\r
1099 return Status;\r
1100}\r
1101\r
1102\r
1103/**\r
1104 EFI_DHCP4_CALLBACK is provided by the consumer of the EFI DHCPv4 Protocol driver\r
1105 to intercept events that occurred in the configuration process.\r
1106\r
1107 @param[in] This Pointer to the EFI DHCPv4 Protocol.\r
1108 @param[in] Context Pointer to the context set by EFI_DHCP4_PROTOCOL.Configure().\r
1109 @param[in] CurrentState The current operational state of the EFI DHCPv4 Protocol driver.\r
1110 @param[in] Dhcp4Event The event that occurs in the current state, which usually means a\r
1111 state transition.\r
1112 @param[in] Packet The DHCPv4 packet that is going to be sent or already received.\r
1113 @param[out] NewPacket The packet that is used to replace the above Packet.\r
1114\r
1115 @retval EFI_SUCCESS Tells the EFI DHCPv4 Protocol driver to continue the DHCP process.\r
1116 @retval EFI_NOT_READY Only used in the Dhcp4Selecting state. The EFI DHCPv4 Protocol\r
1117 driver will continue to wait for more DHCPOFFER packets until the\r
1118 retry timeout expires.\r
1119 @retval EFI_ABORTED Tells the EFI DHCPv4 Protocol driver to abort the current process\r
1120 and return to the Dhcp4Init or Dhcp4InitReboot state.\r
1121\r
1122**/\r
1123EFI_STATUS\r
1124EFIAPI\r
1125PxeBcDhcp4CallBack (\r
1126 IN EFI_DHCP4_PROTOCOL *This,\r
1127 IN VOID *Context,\r
1128 IN EFI_DHCP4_STATE CurrentState,\r
1129 IN EFI_DHCP4_EVENT Dhcp4Event,\r
1130 IN EFI_DHCP4_PACKET *Packet OPTIONAL,\r
1131 OUT EFI_DHCP4_PACKET **NewPacket OPTIONAL\r
1132 )\r
1133{\r
1134 PXEBC_PRIVATE_DATA *Private;\r
1135 EFI_PXE_BASE_CODE_MODE *Mode;\r
1136 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;\r
1137 EFI_DHCP4_PACKET_OPTION *MaxMsgSize;\r
1138 UINT16 Value;\r
1139 EFI_STATUS Status;\r
1140 BOOLEAN Received;\r
1141\r
1142 if ((Dhcp4Event != Dhcp4RcvdOffer) &&\r
1143 (Dhcp4Event != Dhcp4SelectOffer) &&\r
1144 (Dhcp4Event != Dhcp4SendDiscover) &&\r
1145 (Dhcp4Event != Dhcp4RcvdAck)) {\r
1146 return EFI_SUCCESS;\r
1147 }\r
1148\r
1149 Private = (PXEBC_PRIVATE_DATA *) Context;\r
1150 Mode = Private->PxeBc.Mode;\r
1151 Callback = Private->PxeBcCallback;\r
1152\r
1153 //\r
1154 // Override the Maximum DHCP Message Size.\r
1155 //\r
1156 MaxMsgSize = PxeBcParseDhcp4Options (\r
1157 Packet->Dhcp4.Option,\r
1158 GET_OPTION_BUFFER_LEN (Packet),\r
1159 PXEBC_DHCP4_TAG_MAXMSG\r
1160 );\r
1161 if (MaxMsgSize != NULL) {\r
1162 Value = HTONS (PXEBC_DHCP4_PACKET_MAX_SIZE - 8);\r
1163 CopyMem (MaxMsgSize->Data, &Value, sizeof (Value));\r
1164 }\r
1165\r
1166 //\r
1167 // Callback to user if any packets sent or received.\r
1168 //\r
1169 if (Dhcp4Event != Dhcp4SelectOffer && Callback != NULL) {\r
1170 Received = (BOOLEAN) (Dhcp4Event == Dhcp4RcvdOffer || Dhcp4Event == Dhcp4RcvdAck);\r
1171 Status = Callback->Callback (\r
1172 Callback,\r
1173 Private->Function,\r
1174 Received,\r
1175 Packet->Length,\r
1176 (EFI_PXE_BASE_CODE_PACKET *) &Packet->Dhcp4\r
1177 );\r
1178 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {\r
1179 return EFI_ABORTED;\r
1180 }\r
1181 }\r
1182\r
1183 Status = EFI_SUCCESS;\r
1184\r
1185 switch (Dhcp4Event) {\r
1186\r
1187 case Dhcp4SendDiscover:\r
1188 //\r
1189 // Cache the DHCPv4 discover packet to mode data directly.\r
1190 // It need to check SendGuid as well as Dhcp4SendRequest.\r
1191 //\r
1192 CopyMem (&Mode->DhcpDiscover.Dhcpv4, &Packet->Dhcp4, Packet->Length);\r
1193\r
1194 case Dhcp4SendRequest:\r
1195 if (Mode->SendGUID) {\r
1196 //\r
1197 // Send the system Guid instead of the MAC address as the hardware address if required.\r
1198 //\r
19ddbb25 1199 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) Packet->Dhcp4.Header.ClientHwAddr))) {\r
a3bcde70
HT		 1200 //\r
1201 // Zero the Guid to indicate NOT programable if failed to get system Guid.\r
1202 //\r
1203 ZeroMem (Packet->Dhcp4.Header.ClientHwAddr, sizeof (EFI_GUID));\r
1204 }\r
1205 Packet->Dhcp4.Header.HwAddrLen = (UINT8) sizeof (EFI_GUID);\r
1206 }\r
1207 break;\r
1208\r
1209 case Dhcp4RcvdOffer:\r
1210 Status = EFI_NOT_READY;\r
1211 if (Private->OfferNum < PXEBC_OFFER_MAX_NUM) {\r
1212 //\r
1213 // Cache the DHCPv4 offers to OfferBuffer[] for select later, and record\r
1214 // the OfferIndex and OfferCount.\r
1215 //\r
1216 PxeBcCacheDhcp4Offer (Private, Packet);\r
1217 }\r
1218 break;\r
1219\r
1220 case Dhcp4SelectOffer:\r
1221 //\r
1222 // Select offer by the default policy or by order, and record the SelectIndex\r
1223 // and SelectProxyType.\r
1224 //\r
1225 PxeBcSelectDhcp4Offer (Private);\r
1226\r
1227 if (Private->SelectIndex == 0) {\r
1228 Status = EFI_ABORTED;\r
1229 } else {\r
1230 *NewPacket = &Private->OfferBuffer[Private->SelectIndex - 1].Dhcp4.Packet.Offer;\r
1231 }\r
1232 break;\r
1233\r
1234 case Dhcp4RcvdAck:\r
1235 //\r
1236 // Cache the DHCPv4 ack to Private->Dhcp4Ack, but it's not the final ack in mode data\r
1237 // without verification.\r
1238 //\r
1239 ASSERT (Private->SelectIndex != 0);\r
1240\r
1241 PxeBcCopyDhcp4Ack (Private, Packet, FALSE);\r
1242 break;\r
1243\r
1244 default:\r
1245 break;\r
1246 }\r
1247\r
1248 return Status;\r
1249}\r
1250\r
1251\r
1252/**\r
1253 Build and send out the request packet for the bootfile, and parse the reply.\r
1254\r
1255 @param[in] Private Pointer to PxeBc private data.\r
1256 @param[in] Type PxeBc option boot item type.\r
1257 @param[in] Layer Pointer to option boot item layer.\r
1258 @param[in] UseBis Use BIS or not.\r
1259 @param[in] DestIp Pointer to the server address.\r
1260 @param[in] IpCount The total count of the server address.\r
1261 @param[in] SrvList Pointer to EFI_PXE_BASE_CODE_SRVLIST.\r
1262\r
1263 @retval EFI_SUCCESS Successfully discovered boot file.\r
1264 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource.\r
1265 @retval EFI_NOT_FOUND Can't get the PXE reply packet.\r
1266 @retval Others Failed to discover boot file.\r
1267\r
1268**/\r
1269EFI_STATUS\r
1270PxeBcDhcp4Discover (\r
1271 IN PXEBC_PRIVATE_DATA *Private,\r
1272 IN UINT16 Type,\r
1273 IN UINT16 *Layer,\r
1274 IN BOOLEAN UseBis,\r
1275 IN EFI_IP_ADDRESS *DestIp,\r
1276 IN UINT16 IpCount,\r
1277 IN EFI_PXE_BASE_CODE_SRVLIST *SrvList\r
1278 )\r
1279{\r
1280 EFI_PXE_BASE_CODE_UDP_PORT Sport;\r
1281 EFI_PXE_BASE_CODE_MODE *Mode;\r
1282 EFI_DHCP4_PROTOCOL *Dhcp4;\r
1283 EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN Token;\r
1284 BOOLEAN IsBCast;\r
1285 EFI_STATUS Status;\r
1286 UINT16 RepIndex;\r
1287 UINT16 SrvIndex;\r
1288 UINT16 TryIndex;\r
1289 EFI_DHCP4_LISTEN_POINT ListenPoint;\r
1290 EFI_DHCP4_PACKET *Response;\r
1291 UINT8 Buffer[PXEBC_DHCP4_OPTION_MAX_SIZE];\r
1292 EFI_DHCP4_PACKET_OPTION *OptList[PXEBC_DHCP4_OPTION_MAX_NUM];\r
1293 UINT32 OptCount;\r
1294 EFI_DHCP4_PACKET_OPTION *PxeOpt;\r
1295 PXEBC_OPTION_BOOT_ITEM *PxeBootItem;\r
1296 UINT8 VendorOptLen;\r
1297 UINT32 Xid;\r
1298\r
1299 Mode = Private->PxeBc.Mode;\r
1300 Dhcp4 = Private->Dhcp4;\r
1301 Status = EFI_SUCCESS;\r
1302\r
1303 ZeroMem (&Token, sizeof (EFI_DHCP4_TRANSMIT_RECEIVE_TOKEN));\r
1304\r
1305 //\r
1306 // Use broadcast if destination address not specified.\r
1307 //\r
1308 if (DestIp == NULL) {\r
1309 Sport = PXEBC_DHCP4_S_PORT;\r
1310 IsBCast = TRUE;\r
1311 } else {\r
1312 Sport = PXEBC_BS_DISCOVER_PORT;\r
1313 IsBCast = FALSE;\r
1314 }\r
1315\r
1316 if (!UseBis && Layer != NULL) {\r
1317 *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;\r
1318 }\r
1319\r
1320 //\r
1321 // Build all the options for the request packet.\r
1322 //\r
1323 OptCount = PxeBcBuildDhcp4Options (Private, OptList, Buffer, TRUE);\r
1324\r
1325 if (Private->IsDoDiscover) {\r
1326 //\r
1327 // Add vendor option of PXE_BOOT_ITEM\r
1328 //\r
1329 VendorOptLen = (UINT8) ((sizeof (EFI_DHCP4_PACKET_OPTION) - 1) * 2 + sizeof (PXEBC_OPTION_BOOT_ITEM) + 1);\r
1330 OptList[OptCount] = AllocateZeroPool (VendorOptLen);\r
1331 if (OptList[OptCount] == NULL) {\r
1332 return EFI_OUT_OF_RESOURCES;\r
1333 }\r
1334\r
1335 OptList[OptCount]->OpCode = PXEBC_DHCP4_TAG_VENDOR;\r
1336 OptList[OptCount]->Length = (UINT8) (VendorOptLen - 2);\r
1337 PxeOpt = (EFI_DHCP4_PACKET_OPTION *) OptList[OptCount]->Data;\r
1338 PxeOpt->OpCode = PXEBC_VENDOR_TAG_BOOT_ITEM;\r
1339 PxeOpt->Length = (UINT8) sizeof (PXEBC_OPTION_BOOT_ITEM);\r
1340 PxeBootItem = (PXEBC_OPTION_BOOT_ITEM *) PxeOpt->Data;\r
1341 PxeBootItem->Type = HTONS (Type);\r
1342 PxeOpt->Data[PxeOpt->Length] = PXEBC_DHCP4_TAG_EOP;\r
1343\r
1344 if (Layer != NULL) {\r
1345 PxeBootItem->Layer = HTONS (*Layer);\r
1346 }\r
1347\r
1348 OptCount++;\r
1349 }\r
1350\r
1351 //\r
1352 // Build the request packet with seed packet and option list.\r
1353 //\r
1354 Status = Dhcp4->Build (\r
1355 Dhcp4,\r
1356 &Private->SeedPacket,\r
1357 0,\r
1358 NULL,\r
1359 OptCount,\r
1360 OptList,\r
1361 &Token.Packet\r
1362 );\r
1363 //\r
1364 // Free the vendor option of PXE_BOOT_ITEM.\r
1365 //\r
1366 if (Private->IsDoDiscover) {\r
1367 FreePool (OptList[OptCount - 1]);\r
1368 }\r
1369\r
1370 if (EFI_ERROR (Status)) {\r
1371 return Status;\r
1372 }\r
1373\r
1374 if (Mode->SendGUID) {\r
19ddbb25 1375 if (EFI_ERROR (NetLibGetSystemGuid ((EFI_GUID *) Token.Packet->Dhcp4.Header.ClientHwAddr))) {\r
a3bcde70
HT		 1376 //\r
1377 // Zero the Guid to indicate NOT programable if failed to get system Guid.\r
1378 //\r
1379 ZeroMem (Token.Packet->Dhcp4.Header.ClientHwAddr, sizeof (EFI_GUID));\r
1380 }\r
1381 Token.Packet->Dhcp4.Header.HwAddrLen = (UINT8) sizeof (EFI_GUID);\r
1382 }\r
1383\r
1384 //\r
1385 // Set fields of the token for the request packet.\r
1386 //\r
1387 Xid = NET_RANDOM (NetRandomInitSeed ());\r
1388 Token.Packet->Dhcp4.Header.Xid = HTONL (Xid);\r
1389 Token.Packet->Dhcp4.Header.Reserved = HTONS ((UINT16) ((IsBCast) ? 0x8000 : 0x0));\r
1390 CopyMem (&Token.Packet->Dhcp4.Header.ClientAddr, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));\r
1391\r
1392 Token.RemotePort = Sport;\r
1393\r
1394 if (IsBCast) {\r
1395 SetMem (&Token.RemoteAddress, sizeof (EFI_IPv4_ADDRESS), 0xff);\r
1396 } else {\r
1397 CopyMem (&Token.RemoteAddress, DestIp, sizeof (EFI_IPv4_ADDRESS));\r
1398 }\r
1399\r
1400 CopyMem (&Token.GatewayAddress, &Private->GatewayIp, sizeof (EFI_IPv4_ADDRESS));\r
1401\r
1402 if (!IsBCast) {\r
1403 Token.ListenPointCount = 1;\r
1404 Token.ListenPoints = &ListenPoint;\r
1405 Token.ListenPoints[0].ListenPort = PXEBC_BS_DISCOVER_PORT;\r
1406 CopyMem (&Token.ListenPoints[0].ListenAddress, &Private->StationIp, sizeof(EFI_IPv4_ADDRESS));\r
1407 CopyMem (&Token.ListenPoints[0].SubnetMask, &Private->SubnetMask, sizeof(EFI_IPv4_ADDRESS));\r
1408 }\r
1409\r
1410 //\r
1411 // Send out the request packet to discover the bootfile.\r
1412 //\r
1413 for (TryIndex = 1; TryIndex <= PXEBC_BOOT_REQUEST_RETRIES; TryIndex++) {\r
1414\r
1415 Token.TimeoutValue = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * TryIndex);\r
1416 Token.Packet->Dhcp4.Header.Seconds = (UINT16) (PXEBC_BOOT_REQUEST_TIMEOUT * (TryIndex - 1));\r
1417\r
1418 Status = Dhcp4->TransmitReceive (Dhcp4, &Token);\r
1419 if (Token.Status != EFI_TIMEOUT) {\r
1420 break;\r
1421 }\r
1422 }\r
1423\r
1424 if (TryIndex > PXEBC_BOOT_REQUEST_RETRIES) {\r
1425 //\r
1426 // No server response our PXE request\r
1427 //\r
1428 Status = EFI_TIMEOUT;\r
1429 }\r
1430\r
1431 if (!EFI_ERROR (Status)) {\r
1432\r
1433 RepIndex = 0;\r
1434 SrvIndex = 0;\r
1435 Response = Token.ResponseList;\r
1436 //\r
1437 // Find the right PXE Reply according to server address.\r
1438 //\r
1439 while (RepIndex < Token.ResponseCount) {\r
1440\r
1441 while (SrvIndex < IpCount) {\r
1442 if (SrvList[SrvIndex].AcceptAnyResponse) {\r
1443 break;\r
1444 }\r
1445 if ((SrvList[SrvIndex].Type == Type) &&\r
1446 EFI_IP4_EQUAL (&Response->Dhcp4.Header.ServerAddr, &Private->ServerIp)) {\r
1447 break;\r
1448 }\r
1449 SrvIndex++;\r
1450 }\r
1451\r
1452 if ((IpCount != SrvIndex) || (IpCount == 0)) {\r
1453 break;\r
1454 }\r
1455\r
1456 SrvIndex = 0;\r
1457 RepIndex++;\r
1458\r
1459 Response = (EFI_DHCP4_PACKET *) ((UINT8 *) Response + Response->Size);\r
1460 }\r
1461\r
1462 if (RepIndex < Token.ResponseCount) {\r
1463 //\r
1464 // Cache the right PXE reply packet here, set valid flag later.\r
1465 // Especially for PXE discover packet, store it into mode data here.\r
1466 //\r
1467 if (Private->IsDoDiscover) {\r
1468 PxeBcCacheDhcp4Packet (&Private->PxeReply.Dhcp4.Packet.Ack, Response);\r
1469 CopyMem (&Mode->PxeDiscover, &Token.Packet->Dhcp4, Token.Packet->Length);\r
1470 } else {\r
1471 PxeBcCacheDhcp4Packet (&Private->ProxyOffer.Dhcp4.Packet.Offer, Response);\r
1472 }\r
1473 } else {\r
1474 //\r
1475 // Not found the right PXE reply packet.\r
1476 //\r
1477 Status = EFI_NOT_FOUND;\r
1478 }\r
1479 if (Token.ResponseList != NULL) {\r
1480 FreePool (Token.ResponseList);\r
1481 }\r
1482 }\r
1483\r
1484 FreePool (Token.Packet);\r
1485 return Status;\r
1486}\r
1487\r
1488\r
1489/**\r
1490 Start the D.O.R.A DHCPv4 process to acquire the IPv4 address and other PXE boot information.\r
1491\r
1492 @param[in] Private Pointer to PxeBc private data.\r
1493 @param[in] Dhcp4 Pointer to the EFI_DHCP4_PROTOCOL\r
1494\r
1495 @retval EFI_SUCCESS The D.O.R.A process successfully finished.\r
1496 @retval Others Failed to finish the D.O.R.A process.\r
1497\r
1498**/\r
1499EFI_STATUS\r
1500PxeBcDhcp4Dora (\r
1501 IN PXEBC_PRIVATE_DATA *Private,\r
1502 IN EFI_DHCP4_PROTOCOL *Dhcp4\r
1503 )\r
1504{\r
1505 EFI_PXE_BASE_CODE_MODE *PxeMode;\r
1506 EFI_DHCP4_CONFIG_DATA Config;\r
1507 EFI_DHCP4_MODE_DATA Mode;\r
1508 EFI_DHCP4_PACKET_OPTION *OptList[PXEBC_DHCP4_OPTION_MAX_NUM];\r
1509 UINT8 Buffer[PXEBC_DHCP4_OPTION_MAX_SIZE];\r
1510 UINT32 OptCount;\r
1511 EFI_STATUS Status;\r
1512\r
1513 ASSERT (Dhcp4 != NULL);\r
1514\r
1515 Status = EFI_SUCCESS;\r
1516 PxeMode = Private->PxeBc.Mode;\r
1517\r
1518 //\r
1519 // Build option list for the request packet.\r
1520 //\r
1521 OptCount = PxeBcBuildDhcp4Options (Private, OptList, Buffer, FALSE);\r
1522 ASSERT (OptCount> 0);\r
1523\r
1524 ZeroMem (&Mode, sizeof (EFI_DHCP4_MODE_DATA));\r
1525 ZeroMem (&Config, sizeof (EFI_DHCP4_CONFIG_DATA));\r
1526\r
1527 Config.OptionCount = OptCount;\r
1528 Config.OptionList = OptList;\r
1529 Config.Dhcp4Callback = PxeBcDhcp4CallBack;\r
1530 Config.CallbackContext = Private;\r
1531 Config.DiscoverTryCount = PXEBC_DHCP_RETRIES;\r
1532 Config.DiscoverTimeout = mPxeDhcpTimeout;\r
1533\r
1534 //\r
1535 // Configure the DHCPv4 instance for PXE boot.\r
1536 //\r
1537 Status = Dhcp4->Configure (Dhcp4, &Config);\r
1538 if (EFI_ERROR (Status)) {\r
1539 goto ON_EXIT;\r
1540 }\r
1541\r
1542 //\r
1543 // Initialize the record fields for DHCPv4 offer in private data.\r
1544 //\r
1545 Private->IsProxyRecved = FALSE;\r
1546 Private->OfferNum = 0;\r
1547 ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));\r
1548 ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));\r
1549\r
1550 //\r
1551 // Start DHCPv4 D.O.R.A. process to acquire IPv4 address.\r
1552 //\r
1553 Status = Dhcp4->Start (Dhcp4, NULL);\r
1554 if (EFI_ERROR (Status)) {\r
1555 if (Status == EFI_ICMP_ERROR) {\r
1556 PxeMode->IcmpErrorReceived = TRUE;\r
1557 }\r
1558 goto ON_EXIT;\r
1559 }\r
1560\r
1561 //\r
1562 // Get the acquired IPv4 address and store them.\r
1563 //\r
1564 Status = Dhcp4->GetModeData (Dhcp4, &Mode);\r
1565 if (EFI_ERROR (Status)) {\r
1566 goto ON_EXIT;\r
1567 }\r
1568\r
1569 ASSERT (Mode.State == Dhcp4Bound);\r
1570\r
1571 CopyMem (&Private->StationIp, &Mode.ClientAddress, sizeof (EFI_IPv4_ADDRESS));\r
1572 CopyMem (&Private->SubnetMask, &Mode.SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
1573 CopyMem (&Private->GatewayIp, &Mode.RouterAddress, sizeof (EFI_IPv4_ADDRESS));\r
1574 CopyMem (&PxeMode->StationIp, &Private->StationIp, sizeof (EFI_IPv4_ADDRESS));\r
1575 CopyMem (&PxeMode->SubnetMask, &Private->SubnetMask, sizeof (EFI_IPv4_ADDRESS));\r
1576\r
1577 Status = PxeBcFlushStaionIp (Private, &Private->StationIp, &Private->SubnetMask);\r
1578 if (EFI_ERROR (Status)) {\r
1579 goto ON_EXIT;\r
1580 }\r
1581\r
1582 //\r
1583 // Check the selected offer whether BINL retry is needed.\r
1584 //\r
1585 Status = PxeBcHandleDhcp4Offer (Private);\r
1586\r
1587 AsciiPrint ("\n Station IP address is ");\r
1588\r
1589 PxeBcShowIp4Addr (&Private->StationIp.v4);\r
1590\r
1591ON_EXIT:\r
1592 if (EFI_ERROR (Status)) {\r
1593 Dhcp4->Stop (Dhcp4);\r
1594 Dhcp4->Configure (Dhcp4, NULL);\r
1595 } else {\r
1596 ZeroMem (&Config, sizeof (EFI_DHCP4_CONFIG_DATA));\r
1597 Dhcp4->Configure (Dhcp4, &Config);\r
1598 Private->IsAddressOk = TRUE;\r
1599 }\r
1600\r
1601 return Status;\r
1602}\r
EFI Development Kit II mirror for PVE