]> git.proxmox.com Git - mirror_edk2.git/blame - NetworkPkg/UefiPxeBcDxe/PxeBcDhcp6.c
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix for exit was specified in the startup script.
[mirror_edk2.git] / NetworkPkg / UefiPxeBcDxe / PxeBcDhcp6.c
CommitLineData
a3bcde70
HT		 1/** @file\r
2 Functions implementation related with DHCPv6 for UefiPxeBc Driver.\r
3\r
4 Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>\r
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/**\r
20 Parse out a DHCPv6 option by OptTag, and find the position in buffer.\r
21\r
22 @param[in] Buffer The pointer to the option buffer.\r
23 @param[in] Length Length of the option buffer.\r
24 @param[in] OptTag The required option tag.\r
25\r
26 @retval NULL Failed to parse the required option.\r
27 @retval Others The postion of the required option in buffer.\r
28\r
29**/\r
30EFI_DHCP6_PACKET_OPTION *\r
31PxeBcParseDhcp6Options (\r
32 IN UINT8 *Buffer,\r
33 IN UINT32 Length,\r
34 IN UINT16 OptTag\r
35 )\r
36{\r
37 EFI_DHCP6_PACKET_OPTION *Option;\r
38 UINT32 Offset;\r
39\r
40 Option = (EFI_DHCP6_PACKET_OPTION *) Buffer;\r
41 Offset = 0;\r
42\r
43 //\r
44 // OpLen and OpCode here are both stored in network order.\r
45 //\r
46 while (Offset < Length) {\r
47\r
48 if (NTOHS (Option->OpCode) == OptTag) {\r
49\r
50 return Option;\r
51 }\r
52\r
53 Offset += (NTOHS(Option->OpLen) + 4);\r
54 Option = (EFI_DHCP6_PACKET_OPTION *) (Buffer + Offset);\r
55 }\r
56\r
57 return NULL;\r
58}\r
59\r
60\r
61/**\r
62 Build the options buffer for the DHCPv6 request packet.\r
63\r
64 @param[in] Private The pointer to PxeBc private data.\r
65 @param[out] OptList The pointer to the option pointer array.\r
66 @param[in] Buffer The pointer to the buffer to contain the option list.\r
67\r
68 @return Index The count of the built-in options.\r
69\r
70**/\r
71UINT32\r
72PxeBcBuildDhcp6Options (\r
73 IN PXEBC_PRIVATE_DATA *Private,\r
74 OUT EFI_DHCP6_PACKET_OPTION **OptList,\r
75 IN UINT8 *Buffer\r
76 )\r
77{\r
78 PXEBC_DHCP6_OPTION_ENTRY OptEnt;\r
79 UINT32 Index;\r
80 UINT16 Value;\r
81\r
82 Index = 0;\r
83 OptList[0] = (EFI_DHCP6_PACKET_OPTION *) Buffer;\r
84\r
85 //\r
86 // Append client option request option\r
87 //\r
88 OptList[Index]->OpCode = HTONS (PXEBC_DHCP6_OPT_ORO);\r
89 OptList[Index]->OpLen = HTONS (4);\r
90 OptEnt.Oro = (PXEBC_DHCP6_OPTION_ORO *) OptList[Index]->Data;\r
91 OptEnt.Oro->OpCode[0] = HTONS(PXEBC_DHCP6_OPT_BOOT_FILE_URL);\r
92 OptEnt.Oro->OpCode[1] = HTONS(PXEBC_DHCP6_OPT_BOOT_FILE_PARAM);\r
93 Index++;\r
94 OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);\r
95\r
96 //\r
97 // Append client network device interface option\r
98 //\r
99 OptList[Index]->OpCode = HTONS (PXEBC_DHCP6_OPT_UNDI);\r
100 OptList[Index]->OpLen = HTONS ((UINT16) sizeof (PXEBC_DHCP6_OPTION_UNDI));\r
101 OptEnt.Undi = (PXEBC_DHCP6_OPTION_UNDI *) OptList[Index]->Data;\r
102\r
103 if (Private->Nii != NULL) {\r
104 OptEnt.Undi->Type = Private->Nii->Type;\r
105 OptEnt.Undi->MajorVer = Private->Nii->MajorVer;\r
106 OptEnt.Undi->MinorVer = Private->Nii->MinorVer;\r
107 } else {\r
108 OptEnt.Undi->Type = DEFAULT_UNDI_TYPE;\r
109 OptEnt.Undi->MajorVer = DEFAULT_UNDI_MAJOR;\r
110 OptEnt.Undi->MinorVer = DEFAULT_UNDI_MINOR;\r
111 }\r
112\r
113 OptEnt.Undi->Reserved = 0;\r
114 Index++;\r
115 OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);\r
116\r
117 //\r
118 // Append client system architecture option\r
119 //\r
120 OptList[Index]->OpCode = HTONS (PXEBC_DHCP6_OPT_ARCH);\r
121 OptList[Index]->OpLen = HTONS ((UINT16) sizeof (PXEBC_DHCP6_OPTION_ARCH));\r
122 OptEnt.Arch = (PXEBC_DHCP6_OPTION_ARCH *) OptList[Index]->Data;\r
123 Value = HTONS (EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE);\r
124 CopyMem (&OptEnt.Arch->Type, &Value, sizeof (UINT16));\r
125 Index++;\r
126 OptList[Index] = GET_NEXT_DHCP6_OPTION (OptList[Index - 1]);\r
127\r
128 //\r
129 // Append vendor class option to store the PXE class identifier.\r
130 //\r
131 OptList[Index]->OpCode = HTONS (PXEBC_DHCP6_OPT_VENDOR_CLASS);\r
132 OptList[Index]->OpLen = HTONS ((UINT16) sizeof (PXEBC_DHCP6_OPTION_VENDOR_CLASS));\r
133 OptEnt.VendorClass = (PXEBC_DHCP6_OPTION_VENDOR_CLASS *) OptList[Index]->Data;\r
134 OptEnt.VendorClass->Vendor = HTONL (PXEBC_DHCP6_ENTERPRISE_NUM);\r
135 OptEnt.VendorClass->ClassLen = HTONS ((UINT16) sizeof (PXEBC_CLASS_ID));\r
136 CopyMem (\r
137 &OptEnt.VendorClass->ClassId,\r
138 DEFAULT_CLASS_ID_DATA,\r
139 sizeof (PXEBC_CLASS_ID)\r
140 );\r
141 PxeBcUintnToAscDecWithFormat (\r
142 EFI_PXE_CLIENT_SYSTEM_ARCHITECTURE,\r
143 OptEnt.VendorClass->ClassId.ArchitectureType,\r
144 sizeof (OptEnt.VendorClass->ClassId.ArchitectureType)\r
145 );\r
146\r
147 if (Private->Nii != NULL) {\r
148 CopyMem (\r
149 OptEnt.VendorClass->ClassId.InterfaceName,\r
150 Private->Nii->StringId,\r
151 sizeof (OptEnt.VendorClass->ClassId.InterfaceName)\r
152 );\r
153 PxeBcUintnToAscDecWithFormat (\r
154 Private->Nii->MajorVer,\r
155 OptEnt.VendorClass->ClassId.UndiMajor,\r
156 sizeof (OptEnt.VendorClass->ClassId.UndiMajor)\r
157 );\r
158 PxeBcUintnToAscDecWithFormat (\r
159 Private->Nii->MinorVer,\r
160 OptEnt.VendorClass->ClassId.UndiMinor,\r
161 sizeof (OptEnt.VendorClass->ClassId.UndiMinor)\r
162 );\r
163 }\r
164\r
165 Index++;\r
166\r
167 return Index;\r
168}\r
169\r
170\r
171/**\r
172 Cache the DHCPv6 packet.\r
173\r
174 @param[in] Dst The pointer to the cache buffer for DHCPv6 packet.\r
175 @param[in] Src The pointer to the DHCPv6 packet to be cached.\r
176\r
177**/\r
178VOID\r
179PxeBcCacheDhcp6Packet (\r
180 IN EFI_DHCP6_PACKET *Dst,\r
181 IN EFI_DHCP6_PACKET *Src\r
182 )\r
183{\r
184 ASSERT (Dst->Size >= Src->Length);\r
185\r
186 CopyMem (&Dst->Dhcp6, &Src->Dhcp6, Src->Length);\r
187 Dst->Length = Src->Length;\r
188}\r
189\r
190\r
191/**\r
192 Free all the nodes in the list for boot file.\r
193\r
194 @param[in] Head The pointer to the head of list.\r
195\r
196**/\r
197VOID\r
198PxeBcFreeBootFileOption (\r
199 IN LIST_ENTRY *Head\r
200 )\r
201{\r
202 LIST_ENTRY *Entry;\r
203 LIST_ENTRY *NextEntry;\r
204 PXEBC_DHCP6_OPTION_NODE *Node;\r
205\r
206 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, Head) {\r
207 Node = NET_LIST_USER_STRUCT (Entry, PXEBC_DHCP6_OPTION_NODE, Link);\r
208 RemoveEntryList (Entry);\r
209 FreePool (Node);\r
210 }\r
211}\r
212\r
213\r
214/**\r
215 Parse the Boot File URL option.\r
216\r
217 @param[out] FileName The pointer to the boot file name.\r
218 @param[in, out] SrvAddr The pointer to the boot server address.\r
219 @param[in] BootFile The pointer to the boot file URL option data.\r
220 @param[in] Length The length of the boot file URL option data.\r
221\r
222 @retval EFI_ABORTED User cancel operation.\r
223 @retval EFI_SUCCESS Selected the boot menu successfully.\r
224 @retval EFI_NOT_READY Read the input key from the keybroad has not finish.\r
225\r
226**/\r
227EFI_STATUS\r
228PxeBcExtractBootFileUrl (\r
229 OUT UINT8 **FileName,\r
230 IN OUT EFI_IPv6_ADDRESS *SrvAddr,\r
231 IN CHAR8 *BootFile,\r
232 IN UINT16 Length\r
233 )\r
234{\r
235 UINT16 PrefixLen;\r
236 UINT8 *BootFileNamePtr;\r
237 UINT8 *BootFileName;\r
238 UINT16 BootFileNameLen;\r
239 CHAR8 *TmpStr;\r
240 CHAR8 *ServerAddressOption;\r
241 CHAR8 *ServerAddress;\r
242 EFI_STATUS Status;\r
243\r
244 //\r
245 // The format of the Boot File URL option is:\r
246 //\r
247 // 0 1 2 3\r
248 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\r
249 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
250 // | OPT_BOOTFILE_URL | option-len |\r
251 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
252 // | |\r
253 // . bootfile-url (variable length) .\r
254 // | |\r
255 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\r
256 //\r
257\r
258 //\r
c01fa590 259 // Based upon RFC 5970 and UEFI 2.3 Errata D specification, bootfile-url format\r
260 // is tftp://[SERVER_ADDRESS]/BOOTFILE_NAME\r
a3bcde70
HT		 261 // As an example where the BOOTFILE_NAME is the EFI loader and\r
262 // SERVER_ADDRESS is the ASCII encoding of an IPV6 address.\r
263 //\r
264 PrefixLen = (UINT16) AsciiStrLen (PXEBC_DHCP6_BOOT_FILE_URL_PREFIX);\r
265\r
266 if (Length <= PrefixLen ||\r
267 CompareMem (BootFile, PXEBC_DHCP6_BOOT_FILE_URL_PREFIX, PrefixLen) != 0) {\r
268 return EFI_NOT_FOUND;\r
269 }\r
270\r
271 BootFile = BootFile + PrefixLen;\r
272 Length = (UINT16) (Length - PrefixLen);\r
273\r
274 TmpStr = (CHAR8 *) AllocateZeroPool (Length + 1);\r
275 if (TmpStr == NULL) {\r
276 return EFI_OUT_OF_RESOURCES;\r
277 }\r
278\r
279 CopyMem (TmpStr, BootFile, Length);\r
280 TmpStr[Length] = '\0';\r
281\r
282 //\r
283 // Get the part of SERVER_ADDRESS string.\r
284 //\r
285 ServerAddressOption = TmpStr;\r
286 if (*ServerAddressOption != PXEBC_ADDR_START_DELIMITER) {\r
287 FreePool (TmpStr);\r
288 return EFI_INVALID_PARAMETER;\r
289 }\r
290\r
291 ServerAddressOption ++;\r
292 ServerAddress = ServerAddressOption;\r
293 while (*ServerAddress != '\0' && *ServerAddress != PXEBC_ADDR_END_DELIMITER) {\r
294 ServerAddress++;\r
295 }\r
296\r
297 if (*ServerAddress != PXEBC_ADDR_END_DELIMITER) {\r
298 FreePool (TmpStr);\r
299 return EFI_INVALID_PARAMETER;\r
300 }\r
301\r
302 *ServerAddress = '\0';\r
303\r
304 //\r
305 // Convert the string of server address to Ipv6 address format and store it.\r
306 //\r
307 Status = NetLibAsciiStrToIp6 (ServerAddressOption, SrvAddr);\r
308 if (EFI_ERROR (Status)) {\r
309 FreePool (TmpStr);\r
310 return Status;\r
311 }\r
312\r
313 //\r
314 // Get the part of BOOTFILE_NAME string.\r
315 //\r
316 BootFileNamePtr = (UINT8*)((UINTN)ServerAddress + 1);\r
317 if (*BootFileNamePtr != PXEBC_TFTP_URL_SEPARATOR) {\r
318 FreePool (TmpStr);\r
319 return EFI_INVALID_PARAMETER;\r
320 }\r
321\r
322 ++BootFileNamePtr;\r
323 BootFileNameLen = (UINT16)(Length - (UINT16) ((UINTN)BootFileNamePtr - (UINTN)TmpStr) + 1);\r
324 if (BootFileNameLen != 0 || FileName != NULL) {\r
325 BootFileName = (UINT8 *) AllocateZeroPool (BootFileNameLen);\r
326 if (BootFileName == NULL) {\r
327 FreePool (TmpStr);\r
328 return EFI_OUT_OF_RESOURCES;\r
329 }\r
330\r
331 CopyMem (BootFileName, BootFileNamePtr, BootFileNameLen);\r
332 BootFileName[BootFileNameLen - 1] = '\0';\r
333 *FileName = BootFileName;\r
334 }\r
335\r
336\r
337 FreePool (TmpStr);\r
338\r
339 return EFI_SUCCESS;\r
340}\r
341\r
342\r
343/**\r
344 Parse the Boot File Parameter option.\r
345\r
346 @param[in] BootFilePara The pointer to boot file parameter option data.\r
347 @param[out] BootFileSize The pointer to the parsed boot file size.\r
348\r
349 @retval EFI_SUCCESS Successfully obtained the boot file size from parameter option.\r
350 @retval EFI_NOT_FOUND Failed to extract the boot file size from parameter option.\r
351\r
352**/\r
353EFI_STATUS\r
354PxeBcExtractBootFileParam (\r
355 IN CHAR8 *BootFilePara,\r
356 OUT UINT16 *BootFileSize\r
357 )\r
358{\r
359 UINT16 Length;\r
360 UINT8 Index;\r
361 UINT8 Digit;\r
362 UINT32 Size;\r
363\r
364 CopyMem (&Length, BootFilePara, sizeof (UINT16));\r
365 Length = NTOHS (Length);\r
366\r
367 //\r
368 // The BootFile Size should be 1~5 byte ASCII strings\r
369 //\r
370 if (Length < 1 || Length > 5) {\r
371 return EFI_NOT_FOUND;\r
372 }\r
373\r
374 //\r
375 // Extract the value of BootFile Size.\r
376 //\r
377 BootFilePara = BootFilePara + sizeof (UINT16);\r
378 Size = 0;\r
379 for (Index = 0; Index < Length; Index++) {\r
380 if (EFI_ERROR (PxeBcUniHexToUint8 (&Digit, *(BootFilePara + Index)))) {\r
381 return EFI_NOT_FOUND;\r
382 }\r
383\r
384 Size = (Size + Digit) * 10;\r
385 }\r
386\r
387 Size = Size / 10;\r
388 if (Size > PXEBC_DHCP6_MAX_BOOT_FILE_SIZE) {\r
389 return EFI_NOT_FOUND;\r
390 }\r
391\r
392 *BootFileSize = (UINT16) Size;\r
393 return EFI_SUCCESS;\r
394}\r
395\r
396\r
397/**\r
398 Parse the cached DHCPv6 packet, including all the options.\r
399\r
400 @param[in] Cache6 The pointer to a cached DHCPv6 packet.\r
401\r
402 @retval EFI_SUCCESS Parsed the DHCPv6 packet successfully.\r
403 @retval EFI_DEVICE_ERROR Failed to parse and invalid the packet.\r
404\r
405**/\r
406EFI_STATUS\r
407PxeBcParseDhcp6Packet (\r
408 IN PXEBC_DHCP6_PACKET_CACHE *Cache6\r
409 )\r
410{\r
411 EFI_DHCP6_PACKET *Offer;\r
412 EFI_DHCP6_PACKET_OPTION **Options;\r
413 EFI_DHCP6_PACKET_OPTION *Option;\r
414 PXEBC_OFFER_TYPE OfferType;\r
415 BOOLEAN IsProxyOffer;\r
416 BOOLEAN IsPxeOffer;\r
417 UINT32 Offset;\r
418 UINT32 Length;\r
419 UINT32 EnterpriseNum;\r
420\r
421 IsProxyOffer = TRUE;\r
422 IsPxeOffer = FALSE;\r
423 Offer = &Cache6->Packet.Offer;\r
424 Options = Cache6->OptList;\r
425\r
426 ZeroMem (Cache6->OptList, sizeof (Cache6->OptList));\r
427\r
428 Option = (EFI_DHCP6_PACKET_OPTION *) (Offer->Dhcp6.Option);\r
429 Offset = 0;\r
430 Length = GET_DHCP6_OPTION_SIZE (Offer);\r
431\r
432 //\r
433 // OpLen and OpCode here are both stored in network order, since they are from original packet.\r
434 //\r
435 while (Offset < Length) {\r
436\r
437 if (NTOHS (Option->OpCode) == PXEBC_DHCP6_OPT_IA_NA) {\r
438 Options[PXEBC_DHCP6_IDX_IA_NA] = Option;\r
439 } else if (NTOHS (Option->OpCode) == PXEBC_DHCP6_OPT_BOOT_FILE_URL) {\r
440 //\r
441 // The server sends this option to inform the client about an URL to a boot file.\r
442 //\r
443 Options[PXEBC_DHCP6_IDX_BOOT_FILE_URL] = Option;\r
444 } else if (NTOHS (Option->OpCode) == PXEBC_DHCP6_OPT_BOOT_FILE_PARAM) {\r
445 Options[PXEBC_DHCP6_IDX_BOOT_FILE_PARAM] = Option;\r
446 } else if (NTOHS (Option->OpCode) == PXEBC_DHCP6_OPT_VENDOR_CLASS) {\r
447 Options[PXEBC_DHCP6_IDX_VENDOR_CLASS] = Option;\r
448 }\r
449\r
450 Offset += (NTOHS (Option->OpLen) + 4);\r
451 Option = (EFI_DHCP6_PACKET_OPTION *) (Offer->Dhcp6.Option + Offset);\r
452 }\r
453\r
454 //\r
455 // The offer with assigned client address is a proxy offer.\r
456 // An ia_na option, embeded with valid ia_addr option and a status_code of success.\r
457 //\r
458 Option = Options[PXEBC_DHCP6_IDX_IA_NA];\r
459 if (Option != NULL && NTOHS(Option->OpLen) >= 12) {\r
460 Option = PxeBcParseDhcp6Options (\r
461 Option->Data + 12,\r
462 NTOHS (Option->OpLen),\r
463 PXEBC_DHCP6_OPT_STATUS_CODE\r
464 );\r
465 if (Option != NULL && Option->Data[0] == 0) {\r
466 IsProxyOffer = FALSE;\r
467 }\r
468 }\r
469\r
470 //\r
471 // The offer with "PXEClient" is a pxe offer.\r
472 //\r
473 Option = Options[PXEBC_DHCP6_IDX_VENDOR_CLASS];\r
474 EnterpriseNum = PXEBC_DHCP6_ENTERPRISE_NUM;\r
475 if (Option != NULL &&\r
476 NTOHS(Option->OpLen) >= 13 &&\r
477 CompareMem (Option->Data, &EnterpriseNum, sizeof (UINT32)) == 0 &&\r
478 CompareMem (&Option->Data[4], DEFAULT_CLASS_ID_DATA, 9) == 0) {\r
479 IsPxeOffer = TRUE;\r
480 }\r
481\r
482 //\r
483 // Determine offer type of the dhcp6 packet.\r
484 //\r
485 if (IsPxeOffer) {\r
486 //\r
487 // It's a binl offer only with PXEClient.\r
488 //\r
489 OfferType = IsProxyOffer ? PxeOfferTypeProxyBinl : PxeOfferTypeDhcpBinl;\r
490 } else {\r
491 //\r
492 // It's a dhcp only offer, which is a pure dhcp6 offer packet.\r
493 //\r
494 OfferType = PxeOfferTypeDhcpOnly;\r
495 }\r
496\r
497 Cache6->OfferType = OfferType;\r
498\r
499 return EFI_SUCCESS;\r
500}\r
501\r
502\r
503/**\r
504 Cache the DHCPv6 ack packet, and parse it on demand.\r
505\r
506 @param[in] Private The pointer to PxeBc private data.\r
507 @param[in] Ack The pointer to the DHCPv6 ack packet.\r
508 @param[in] Verified If TRUE, parse the ACK packet and store info into mode data.\r
509\r
510**/\r
511VOID\r
512PxeBcCopyDhcp6Ack (\r
513 IN PXEBC_PRIVATE_DATA *Private,\r
514 IN EFI_DHCP6_PACKET *Ack,\r
515 IN BOOLEAN Verified\r
516 )\r
517{\r
518 EFI_PXE_BASE_CODE_MODE *Mode;\r
519\r
520 Mode = Private->PxeBc.Mode;\r
521\r
522 PxeBcCacheDhcp6Packet (&Private->DhcpAck.Dhcp6.Packet.Ack, Ack);\r
523\r
524 if (Verified) {\r
525 //\r
526 // Parse the ack packet and store it into mode data if needed.\r
527 //\r
528 PxeBcParseDhcp6Packet (&Private->DhcpAck.Dhcp6);\r
529 CopyMem (&Mode->DhcpAck.Dhcpv6, &Ack->Dhcp6, Ack->Length);\r
530 Mode->DhcpAckReceived = TRUE;\r
531 }\r
532}\r
533\r
534\r
535/**\r
536 Cache the DHCPv6 proxy offer packet according to the received order.\r
537\r
538 @param[in] Private The pointer to PxeBc private data.\r
539 @param[in] OfferIndex The received order of offer packets.\r
540\r
541**/\r
542VOID\r
543PxeBcCopyDhcp6Proxy (\r
544 IN PXEBC_PRIVATE_DATA *Private,\r
545 IN UINT32 OfferIndex\r
546 )\r
547{\r
548 EFI_PXE_BASE_CODE_MODE *Mode;\r
549 EFI_DHCP6_PACKET *Offer;\r
550\r
551 ASSERT (OfferIndex < Private->OfferNum);\r
552 ASSERT (OfferIndex < PXEBC_OFFER_MAX_NUM);\r
553\r
554 Mode = Private->PxeBc.Mode;\r
555 Offer = &Private->OfferBuffer[OfferIndex].Dhcp6.Packet.Offer;\r
556\r
557 //\r
558 // Cache the proxy offer packet and parse it.\r
559 //\r
560 PxeBcCacheDhcp6Packet (&Private->ProxyOffer.Dhcp6.Packet.Offer, Offer);\r
561 PxeBcParseDhcp6Packet (&Private->ProxyOffer.Dhcp6);\r
562\r
563 //\r
564 // Store this packet into mode data.\r
565 //\r
566 CopyMem (&Mode->ProxyOffer.Dhcpv6, &Offer->Dhcp6, Offer->Length);\r
567 Mode->ProxyOfferReceived = TRUE;\r
568}\r
569\r
570\r
571/**\r
572 Retry to request bootfile name by the BINL offer.\r
573\r
574 @param[in] Private The pointer to PxeBc private data.\r
575 @param[in] Index The received order of offer packets.\r
576\r
577 @retval EFI_SUCCESS Successfully retried a request for the bootfile name.\r
578 @retval EFI_DEVICE_ERROR Failed to retry the bootfile name.\r
579\r
580**/\r
581EFI_STATUS\r
582PxeBcRetryDhcp6Binl (\r
583 IN PXEBC_PRIVATE_DATA *Private,\r
584 IN UINT32 Index\r
585 )\r
586{\r
587 EFI_PXE_BASE_CODE_MODE *Mode;\r
588 PXEBC_DHCP6_PACKET_CACHE *Offer;\r
589 PXEBC_DHCP6_PACKET_CACHE *Cache6;\r
590 EFI_IP_ADDRESS ServerIp;\r
591 EFI_STATUS Status;\r
592\r
593 ASSERT (Index < PXEBC_OFFER_MAX_NUM);\r
594 ASSERT (Private->OfferBuffer[Index].Dhcp6.OfferType == PxeOfferTypeDhcpBinl ||\r
595 Private->OfferBuffer[Index].Dhcp6.OfferType == PxeOfferTypeProxyBinl);\r
596\r
597 Mode = Private->PxeBc.Mode;\r
598 Private->IsDoDiscover = FALSE;\r
599 Offer = &Private->OfferBuffer[Index].Dhcp6;\r
600\r
601 ASSERT (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);\r
602 //\r
603 // Parse out the next server address from the last offer, and store it\r
604 //\r
605 Status = PxeBcExtractBootFileUrl (\r
606 NULL,\r
607 &ServerIp.v6,\r
608 (CHAR8 *) (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->Data),\r
609 NTOHS (Offer->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL]->OpLen)\r
610 );\r
611 if (EFI_ERROR (Status)) {\r
612 return Status;\r
613 }\r
614\r
615 //\r
616 // Retry Dhcp6Binl again for the bootfile, and the reply cached into Private->ProxyOffer.\r
617 //\r
618 Status = PxeBcDhcp6Discover (\r
619 Private,\r
620 0,\r
621 NULL,\r
622 FALSE,\r
623 &ServerIp\r
624 );\r
625 if (EFI_ERROR (Status)) {\r
626 return Status;\r
627 }\r
628\r
629 Cache6 = &Private->ProxyOffer.Dhcp6;\r
630 Status = PxeBcParseDhcp6Packet (Cache6);\r
631 if (EFI_ERROR (Status)) {\r
632 return Status;\r
633 }\r
634\r
635 if (Cache6->OfferType != PxeOfferTypeProxyPxe10 &&\r
636 Cache6->OfferType != PxeOfferTypeProxyWfm11a &&\r
637 Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] == NULL) {\r
638 //\r
639 // This BINL ack doesn't have discovery option set or multicast option set\r
640 // or bootfile name specified.\r
641 //\r
642 return EFI_DEVICE_ERROR;\r
643 }\r
644\r
645 Mode->ProxyOfferReceived = TRUE;\r
646 CopyMem (\r
647 &Mode->ProxyOffer.Dhcpv6,\r
648 &Cache6->Packet.Offer.Dhcp6,\r
649 Cache6->Packet.Offer.Length\r
650 );\r
651\r
652 return EFI_SUCCESS;\r
653}\r
654\r
655\r
656/**\r
657 Cache all the received DHCPv6 offers, and set OfferIndex and OfferCount.\r
658\r
659 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
660 @param[in] RcvdOffer The pointer to the received offer packet.\r
661\r
662**/\r
663VOID\r
664PxeBcCacheDhcp6Offer (\r
665 IN PXEBC_PRIVATE_DATA *Private,\r
666 IN EFI_DHCP6_PACKET *RcvdOffer\r
667 )\r
668{\r
669 PXEBC_DHCP6_PACKET_CACHE *Cache6;\r
670 EFI_DHCP6_PACKET *Offer;\r
671 PXEBC_OFFER_TYPE OfferType;\r
672\r
673 Cache6 = &Private->OfferBuffer[Private->OfferNum].Dhcp6;\r
674 Offer = &Cache6->Packet.Offer;\r
675\r
676 //\r
677 // Cache the content of DHCPv6 packet firstly.\r
678 //\r
679 PxeBcCacheDhcp6Packet (Offer, RcvdOffer);\r
680\r
681 //\r
682 // Validate the DHCPv6 packet, and parse the options and offer type.\r
683 //\r
684 if (EFI_ERROR (PxeBcParseDhcp6Packet (Cache6))) {\r
685 return ;\r
686 }\r
687\r
688 //\r
689 // Determine whether cache the current offer by type, and record OfferIndex and OfferCount.\r
690 //\r
691 OfferType = Cache6->OfferType;\r
692 ASSERT (OfferType < PxeOfferTypeMax);\r
693 ASSERT (Private->OfferCount[OfferType] < PXEBC_OFFER_MAX_NUM);\r
694\r
695 if (IS_PROXY_OFFER (OfferType)) {\r
696 //\r
697 // It's a proxy offer without yiaddr, including PXE10, WFM11a or BINL offer.\r
698 //\r
699 Private->IsProxyRecved = TRUE;\r
700\r
701 if (OfferType == PxeOfferTypeProxyBinl) {\r
702 //\r
703 // Cache all proxy BINL offers.\r
704 //\r
705 Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
706 Private->OfferCount[OfferType]++;\r
707 } else if (Private->OfferCount[OfferType] > 0) {\r
708 //\r
709 // Only cache the first PXE10/WFM11a offer, and discard the others.\r
710 //\r
711 Private->OfferIndex[OfferType][0] = Private->OfferNum;\r
712 Private->OfferCount[OfferType] = 1;\r
713 } else {\r
714 return;\r
715 }\r
716 } else {\r
717 //\r
718 // It's a DHCPv6 offer with yiaddr, and cache them all.\r
719 //\r
720 Private->OfferIndex[OfferType][Private->OfferCount[OfferType]] = Private->OfferNum;\r
721 Private->OfferCount[OfferType]++;\r
722 }\r
723\r
724 Private->OfferNum++;\r
725}\r
726\r
727\r
728/**\r
729 Select an DHCPv6 offer, and record SelectIndex and SelectProxyType.\r
730\r
731 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
732\r
733**/\r
734VOID\r
735PxeBcSelectDhcp6Offer (\r
736 IN PXEBC_PRIVATE_DATA *Private\r
737 )\r
738{\r
739 UINT32 Index;\r
740 UINT32 OfferIndex;\r
741 PXEBC_OFFER_TYPE OfferType;\r
742\r
743 Private->SelectIndex = 0;\r
744\r
745 if (Private->IsOfferSorted) {\r
746 //\r
747 // Select offer by default policy.\r
748 //\r
749 if (Private->OfferCount[PxeOfferTypeDhcpPxe10] > 0) {\r
750 //\r
751 // 1. DhcpPxe10 offer\r
752 //\r
753 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpPxe10][0] + 1;\r
754\r
755 } else if (Private->OfferCount[PxeOfferTypeDhcpWfm11a] > 0) {\r
756 //\r
757 // 2. DhcpWfm11a offer\r
758 //\r
759 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpWfm11a][0] + 1;\r
760\r
761 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
762 Private->OfferCount[PxeOfferTypeProxyPxe10] > 0) {\r
763 //\r
764 // 3. DhcpOnly offer and ProxyPxe10 offer.\r
765 //\r
766 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
767 Private->SelectProxyType = PxeOfferTypeProxyPxe10;\r
768\r
769 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
770 Private->OfferCount[PxeOfferTypeProxyWfm11a] > 0) {\r
771 //\r
772 // 4. DhcpOnly offer and ProxyWfm11a offer.\r
773 //\r
774 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
775 Private->SelectProxyType = PxeOfferTypeProxyWfm11a;\r
776\r
777 } else if (Private->OfferCount[PxeOfferTypeDhcpBinl] > 0) {\r
778 //\r
779 // 5. DhcpBinl offer.\r
780 //\r
781 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpBinl][0] + 1;\r
782\r
783 } else if (Private->OfferCount[PxeOfferTypeDhcpOnly] > 0 &&\r
784 Private->OfferCount[PxeOfferTypeProxyBinl] > 0) {\r
785 //\r
786 // 6. DhcpOnly offer and ProxyBinl offer.\r
787 //\r
788 Private->SelectIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][0] + 1;\r
789 Private->SelectProxyType = PxeOfferTypeProxyBinl;\r
790\r
791 } else {\r
792 //\r
793 // 7. DhcpOnly offer with bootfilename.\r
794 //\r
795 for (Index = 0; Index < Private->OfferCount[PxeOfferTypeDhcpOnly]; Index++) {\r
796 OfferIndex = Private->OfferIndex[PxeOfferTypeDhcpOnly][Index];\r
797 if (Private->OfferBuffer[OfferIndex].Dhcp6.OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL) {\r
798 Private->SelectIndex = OfferIndex + 1;\r
799 break;\r
800 }\r
801 }\r
802 }\r
803 } else {\r
804 //\r
805 // Select offer by received order.\r
806 //\r
807 for (Index = 0; Index < Private->OfferNum; Index++) {\r
808\r
809 OfferType = Private->OfferBuffer[Index].Dhcp6.OfferType;\r
810\r
811 if (IS_PROXY_OFFER (OfferType)) {\r
812 //\r
813 // Skip proxy offers\r
814 //\r
815 continue;\r
816 }\r
817\r
818 if (!Private->IsProxyRecved &&\r
819 OfferType == PxeOfferTypeDhcpOnly &&\r
820 Private->OfferBuffer[Index].Dhcp6.OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] == NULL) {\r
821 //\r
822 // Skip if DhcpOnly offer without any other proxy offers or bootfilename.\r
823 //\r
824 continue;\r
825 }\r
826\r
827 Private->SelectIndex = Index + 1;\r
828 break;\r
829 }\r
830 }\r
831}\r
832\r
833\r
834/**\r
835 Handle the DHCPv6 offer packet.\r
836\r
837 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
838\r
839 @retval EFI_SUCCESS Handled the DHCPv6 offer packet successfully.\r
840 @retval EFI_NO_RESPONSE No response to the following request packet.\r
841\r
842**/\r
843EFI_STATUS\r
844PxeBcHandleDhcp6Offer (\r
845 IN PXEBC_PRIVATE_DATA *Private\r
846 )\r
847{\r
848 PXEBC_DHCP6_PACKET_CACHE *Cache6;\r
849 EFI_STATUS Status;\r
850 PXEBC_OFFER_TYPE OfferType;\r
851 UINT32 ProxyIndex;\r
852 UINT32 SelectIndex;\r
853 UINT32 Index;\r
854\r
855 ASSERT (Private->SelectIndex > 0);\r
856 SelectIndex = (UINT32) (Private->SelectIndex - 1);\r
857 ASSERT (SelectIndex < PXEBC_OFFER_MAX_NUM);\r
858 Cache6 = &Private->OfferBuffer[SelectIndex].Dhcp6;\r
859 Status = EFI_SUCCESS;\r
860\r
861 if (Cache6->OfferType == PxeOfferTypeDhcpBinl) {\r
862 //\r
863 // DhcpBinl offer is selected, so need try to request bootfilename by this offer.\r
864 //\r
865 if (EFI_ERROR (PxeBcRetryDhcp6Binl (Private, SelectIndex))) {\r
866 Status = EFI_NO_RESPONSE;\r
867 }\r
868 } else if (Cache6->OfferType == PxeOfferTypeDhcpOnly) {\r
869\r
870 if (Private->IsProxyRecved) {\r
871 //\r
872 // DhcpOnly offer is selected, so need try to request bootfilename.\r
873 //\r
874 ProxyIndex = 0;\r
875 if (Private->IsOfferSorted) {\r
876 //\r
877 // The proxy offer should be determined if select by default policy.\r
878 // IsOfferSorted means all offers are labeled by OfferIndex.\r
879 //\r
880 ASSERT (Private->OfferCount[Private->SelectProxyType] > 0);\r
881\r
882 if (Private->SelectProxyType == PxeOfferTypeProxyBinl) {\r
883 //\r
884 // Try all the cached ProxyBinl offer one by one to request bootfilename.\r
885 //\r
886 for (Index = 0; Index < Private->OfferCount[Private->SelectProxyType]; Index++) {\r
887\r
888 ProxyIndex = Private->OfferIndex[Private->SelectProxyType][Index];\r
889 if (!EFI_ERROR (PxeBcRetryDhcp6Binl (Private, ProxyIndex))) {\r
890 break;\r
891 }\r
892 }\r
893 if (Index == Private->OfferCount[Private->SelectProxyType]) {\r
894 Status = EFI_NO_RESPONSE;\r
895 }\r
896 } else {\r
897 //\r
898 // For other proxy offers (pxe10 or wfm11a), only one is buffered.\r
899 //\r
900 ProxyIndex = Private->OfferIndex[Private->SelectProxyType][0];\r
901 }\r
902 } else {\r
903 //\r
904 // The proxy offer should not be determined if select by received order.\r
905 //\r
906 Status = EFI_NO_RESPONSE;\r
907\r
908 for (Index = 0; Index < Private->OfferNum; Index++) {\r
909\r
910 OfferType = Private->OfferBuffer[Index].Dhcp6.OfferType;\r
911\r
912 if (!IS_PROXY_OFFER (OfferType)) {\r
913 //\r
914 // Skip non proxy dhcp offers.\r
915 //\r
916 continue;\r
917 }\r
918\r
919 if (OfferType == PxeOfferTypeProxyBinl) {\r
920 //\r
921 // Try all the cached ProxyBinl offer one by one to request bootfilename.\r
922 //\r
923 if (EFI_ERROR (PxeBcRetryDhcp6Binl (Private, Index))) {\r
924 continue;\r
925 }\r
926 }\r
927\r
928 Private->SelectProxyType = OfferType;\r
929 ProxyIndex = Index;\r
930 Status = EFI_SUCCESS;\r
931 break;\r
932 }\r
933 }\r
934\r
935 if (!EFI_ERROR (Status) && Private->SelectProxyType != PxeOfferTypeProxyBinl) {\r
936 //\r
937 // Success to try to request by a ProxyPxe10 or ProxyWfm11a offer, copy and parse it.\r
938 //\r
939 PxeBcCopyDhcp6Proxy (Private, ProxyIndex);\r
940 }\r
941 } else {\r
942 //\r
943 // Othewise, the bootfilename must be included in DhcpOnly offer.\r
944 //\r
945 ASSERT (Cache6->OptList[PXEBC_DHCP6_IDX_BOOT_FILE_URL] != NULL);\r
946 }\r
947 }\r
948\r
949 if (!EFI_ERROR (Status)) {\r
950 //\r
951 // All PXE boot information is ready by now.\r
952 //\r
953 PxeBcCopyDhcp6Ack (Private, &Private->DhcpAck.Dhcp6.Packet.Ack, TRUE);\r
954 Private->PxeBc.Mode->DhcpDiscoverValid = TRUE;\r
955 }\r
956\r
957 return Status;\r
958}\r
959\r
960\r
961/**\r
962 Unregister the address by Ip6Config protocol.\r
963\r
964 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
965\r
966**/\r
967VOID\r
968PxeBcUnregisterIp6Address (\r
969 IN PXEBC_PRIVATE_DATA *Private\r
970 )\r
971{\r
972 if (Private->Ip6Policy != PXEBC_IP6_POLICY_MAX) {\r
973 //\r
974 // PXE driver change the policy of IP6 driver, it's a chance to recover.\r
975 // Keep the point and there is no enough requirements to do recovery.\r
976 //\r
977 }\r
978}\r
979\r
980\r
981/**\r
982 Register the ready address by Ip6Config protocol.\r
983\r
984 @param[in] Private The pointer to PXEBC_PRIVATE_DATA.\r
985 @param[in] Address The pointer to the ready address.\r
986\r
987 @retval EFI_SUCCESS Registered the address succesfully.\r
988 @retval Others Failed to register the address.\r
989\r
990**/\r
991EFI_STATUS\r
992PxeBcRegisterIp6Address (\r
993 IN PXEBC_PRIVATE_DATA *Private,\r
994 IN EFI_IPv6_ADDRESS *Address\r
995 )\r
996{\r
997 EFI_IP6_PROTOCOL *Ip6;\r
998 EFI_IP6_CONFIG_PROTOCOL *Ip6Cfg;\r
999 EFI_IP6_CONFIG_POLICY Policy;\r
1000 EFI_IP6_CONFIG_MANUAL_ADDRESS CfgAddr;\r
1001 UINTN DataSize;\r
1002 EFI_EVENT TimeOutEvt;\r
1003 EFI_EVENT MappedEvt;\r
1004 EFI_STATUS Status;\r
1005\r
1006 Status = EFI_SUCCESS;\r
1007 TimeOutEvt = NULL;\r
1008 MappedEvt = NULL;\r
1009 DataSize = sizeof (EFI_IP6_CONFIG_POLICY);\r
1010 Ip6Cfg = Private->Ip6Cfg;\r
1011 Ip6 = Private->Ip6;\r
1012\r
1013 ZeroMem (&CfgAddr, sizeof (EFI_IP6_CONFIG_MANUAL_ADDRESS));\r
1014 CopyMem (&CfgAddr.Address, Address, sizeof (EFI_IPv6_ADDRESS));\r
1015\r
1016 //\r
1017 // Get and store the current policy of IP6 driver.\r
1018 //\r
1019 Status = Ip6Cfg->GetData (\r
1020 Ip6Cfg,\r
1021 Ip6ConfigDataTypePolicy,\r
1022 &DataSize,\r
1023 &Private->Ip6Policy\r
1024 );\r
1025 if (EFI_ERROR (Status)) {\r
1026 goto ON_EXIT;\r
1027 }\r
1028\r
1029 //\r
1030 // There is no channel between IP6 and PXE driver about address setting,\r
1031 // so it has to set the new address by Ip6ConfigProtocol manually.\r
1032 //\r
1033 Policy = Ip6ConfigPolicyManual;\r
1034 Status = Ip6Cfg->SetData (\r
1035 Ip6Cfg,\r
1036 Ip6ConfigDataTypePolicy,\r
1037 sizeof(EFI_IP6_CONFIG_POLICY),\r
1038 &Policy\r
1039 );\r
1040 if (EFI_ERROR (Status)) {\r
1041 //\r
1042 // There is no need to recover later.\r
1043 //\r
1044 Private->Ip6Policy = PXEBC_IP6_POLICY_MAX;\r
1045 goto ON_EXIT;\r
1046 }\r
1047\r
1048 //\r
1049 // Create a timer as setting address timeout event since DAD in IP6 driver.\r
1050 //\r
1051 Status = gBS->CreateEvent (\r
1052 EVT_TIMER,\r
1053 TPL_CALLBACK,\r
1054 NULL,\r
1055 NULL,\r
1056 &TimeOutEvt\r
1057 );\r
1058 if (EFI_ERROR (Status)) {\r
1059 goto ON_EXIT;\r
1060 }\r
1061\r
1062 //\r
1063 // Create a notify event to set address flag when DAD if IP6 driver succeeded.\r
1064 //\r
1065 Status = gBS->CreateEvent (\r
1066 EVT_NOTIFY_SIGNAL,\r
1067 TPL_NOTIFY,\r
1068 PxeBcCommonNotify,\r
1069 &Private->IsAddressOk,\r
1070 &MappedEvt\r
1071 );\r
1072 if (EFI_ERROR (Status)) {\r
1073 goto ON_EXIT;\r
1074 }\r
1075\r
1076 Status = Ip6Cfg->RegisterDataNotify (\r
1077 Ip6Cfg,\r
1078 Ip6ConfigDataTypeManualAddress,\r
1079 MappedEvt\r
1080 );\r
1081 if (EFI_ERROR(Status)) {\r
1082 goto ON_EXIT;\r
1083 }\r
1084\r
1085 Status = Ip6Cfg->SetData (\r
1086 Ip6Cfg,\r
1087 Ip6ConfigDataTypeManualAddress,\r
1088 sizeof(EFI_IP6_CONFIG_MANUAL_ADDRESS),\r
1089 &CfgAddr\r
1090 );\r
1091 if (EFI_ERROR(Status) && Status != EFI_NOT_READY) {\r
1092 goto ON_EXIT;\r
1093 }\r
1094\r
1095 //\r
1096 // Start the 5 secondes timer to wait for setting address.\r
1097 //\r
1098 Status = EFI_NO_MAPPING;\r
1099 gBS->SetTimer (TimeOutEvt, TimerRelative, PXEBC_DHCP6_MAPPING_TIMEOUT);\r
1100\r
1101 while (EFI_ERROR (gBS->CheckEvent (TimeOutEvt))) {\r
1102 Ip6->Poll (Ip6);\r
1103 if (Private->IsAddressOk) {\r
1104 Status = EFI_SUCCESS;\r
1105 break;\r
1106 }\r
1107 }\r
1108\r
1109ON_EXIT:\r
1110 if (MappedEvt != NULL) {\r
1111 Ip6Cfg->UnregisterDataNotify (\r
1112 Ip6Cfg,\r
1113 Ip6ConfigDataTypeManualAddress,\r
1114 MappedEvt\r
1115 );\r
1116 gBS->CloseEvent (MappedEvt);\r
1117 }\r
1118 if (TimeOutEvt != NULL) {\r
1119 gBS->CloseEvent (TimeOutEvt);\r
1120 }\r
1121 return Status;\r
1122}\r
1123\r
1124\r
1125/**\r
1126 EFI_DHCP6_CALLBACK is provided by the consumer of the EFI DHCPv6 Protocol driver\r
1127 to intercept events that occurred in the configuration process.\r
1128\r
1129 @param[in] This The pointer to the EFI DHCPv6 Protocol.\r
1130 @param[in] Context The pointer to the context set by EFI_DHCP6_PROTOCOL.Configure().\r
1131 @param[in] CurrentState The current operational state of the EFI DHCPv Protocol driver.\r
1132 @param[in] Dhcp6Event The event that occurs in the current state, which usually means a\r
1133 state transition.\r
1134 @param[in] Packet The DHCPv6 packet that is going to be sent or was already received.\r
1135 @param[out] NewPacket The packet that is used to replace the Packet above.\r
1136\r
1137 @retval EFI_SUCCESS Told the EFI DHCPv6 Protocol driver to continue the DHCP process.\r
1138 @retval EFI_NOT_READY Only used in the Dhcp6Selecting state. The EFI DHCPv6 Protocol\r
1139 driver will continue to wait for more packets.\r
1140 @retval EFI_ABORTED Told the EFI DHCPv6 Protocol driver to abort the current process.\r
1141\r
1142**/\r
1143EFI_STATUS\r
1144EFIAPI\r
1145PxeBcDhcp6CallBack (\r
1146 IN EFI_DHCP6_PROTOCOL *This,\r
1147 IN VOID *Context,\r
1148 IN EFI_DHCP6_STATE CurrentState,\r
1149 IN EFI_DHCP6_EVENT Dhcp6Event,\r
1150 IN EFI_DHCP6_PACKET *Packet,\r
1151 OUT EFI_DHCP6_PACKET **NewPacket OPTIONAL\r
1152 )\r
1153{\r
1154 PXEBC_PRIVATE_DATA *Private;\r
1155 EFI_PXE_BASE_CODE_MODE *Mode;\r
1156 EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL *Callback;\r
1157 EFI_DHCP6_PACKET *SelectAd;\r
1158 EFI_STATUS Status;\r
1159 BOOLEAN Received;\r
1160\r
1161 if ((Dhcp6Event != Dhcp6RcvdAdvertise) &&\r
1162 (Dhcp6Event != Dhcp6SelectAdvertise) &&\r
1163 (Dhcp6Event != Dhcp6SendSolicit) &&\r
1164 (Dhcp6Event != Dhcp6SendRequest) &&\r
1165 (Dhcp6Event != Dhcp6RcvdReply)) {\r
1166 return EFI_SUCCESS;\r
1167 }\r
1168\r
1169 ASSERT (Packet != NULL);\r
1170\r
1171 Private = (PXEBC_PRIVATE_DATA *) Context;\r
1172 Mode = Private->PxeBc.Mode;\r
1173 Callback = Private->PxeBcCallback;\r
1174\r
1175 //\r
1176 // Callback to user when any traffic ocurred if has.\r
1177 //\r
1178 if (Dhcp6Event != Dhcp6SelectAdvertise && Callback != NULL) {\r
1179 Received = (BOOLEAN) (Dhcp6Event == Dhcp6RcvdAdvertise || Dhcp6Event == Dhcp6RcvdReply);\r
1180 Status = Callback->Callback (\r
1181 Callback,\r
1182 Private->Function,\r
1183 Received,\r
1184 Packet->Length,\r
1185 (EFI_PXE_BASE_CODE_PACKET *) &Packet->Dhcp6\r
1186 );\r
1187 if (Status != EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE) {\r
1188 return EFI_ABORTED;\r
1189 }\r
1190 }\r
1191\r
1192 Status = EFI_SUCCESS;\r
1193\r
1194 switch (Dhcp6Event) {\r
1195\r
1196 case Dhcp6SendSolicit:\r
1197 //\r
1198 // Cache the dhcp discover packet to mode data directly.\r
1199 //\r
1200 CopyMem (&Mode->DhcpDiscover.Dhcpv4, &Packet->Dhcp6, Packet->Length);\r
1201 break;\r
1202\r
1203 case Dhcp6RcvdAdvertise:\r
1204 Status = EFI_NOT_READY;\r
1205 if (Private->OfferNum < PXEBC_OFFER_MAX_NUM) {\r
1206 //\r
1207 // Cache the dhcp offers to OfferBuffer[] for select later, and record\r
1208 // the OfferIndex and OfferCount.\r
1209 //\r
1210 PxeBcCacheDhcp6Offer (Private, Packet);\r
1211 }\r
1212 break;\r
1213\r
1214 case Dhcp6SendRequest:\r
1215 //\r
1216 // Store the request packet as seed packet for discover.\r
1217 //\r
1218 if (Private->Dhcp6Request != NULL) {\r
1219 FreePool (Private->Dhcp6Request);\r
1220 }\r
1221 Private->Dhcp6Request = AllocateZeroPool (Packet->Size);\r
1222 if (Private->Dhcp6Request != NULL) {\r
1223 CopyMem (Private->Dhcp6Request, Packet, Packet->Size);\r
1224 }\r
1225 break;\r
1226\r
1227 case Dhcp6SelectAdvertise:\r
1228 //\r
1229 // Select offer by the default policy or by order, and record the SelectIndex\r
1230 // and SelectProxyType.\r
1231 //\r
1232 PxeBcSelectDhcp6Offer (Private);\r
1233\r
1234 if (Private->SelectIndex == 0) {\r
1235 Status = EFI_ABORTED;\r
1236 } else {\r
1237 ASSERT (NewPacket != NULL);\r
1238 SelectAd = &Private->OfferBuffer[Private->SelectIndex - 1].Dhcp6.Packet.Offer;\r
1239 *NewPacket = AllocateZeroPool (SelectAd->Size);\r
1240 ASSERT (*NewPacket != NULL);\r
1241 CopyMem (*NewPacket, SelectAd, SelectAd->Size);\r
1242 }\r
1243 break;\r
1244\r
1245 case Dhcp6RcvdReply:\r
1246 //\r
1247 // Cache the dhcp ack to Private->Dhcp6Ack, but it's not the final ack in mode data\r
1248 // without verification.\r
1249 //\r
1250 ASSERT (Private->SelectIndex != 0);\r
1251 PxeBcCopyDhcp6Ack (Private, Packet, FALSE);\r
1252 break;\r
1253\r
1254 default:\r
1255 ASSERT (0);\r
1256 }\r
1257\r
1258 return Status;\r
1259}\r
1260\r
1261\r
1262/**\r
1263 Build and send out the request packet for the bootfile, and parse the reply.\r
1264\r
1265 @param[in] Private The pointer to PxeBc private data.\r
1266 @param[in] Type PxeBc option boot item type.\r
1267 @param[in] Layer The pointer to option boot item layer.\r
1268 @param[in] UseBis Use BIS or not.\r
1269 @param[in] DestIp The pointer to the server address.\r
1270\r
1271 @retval EFI_SUCCESS Successfully discovered the boot file.\r
1272 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.\r
1273 @retval EFI_NOT_FOUND Can't get the PXE reply packet.\r
1274 @retval Others Failed to discover the boot file.\r
1275\r
1276**/\r
1277EFI_STATUS\r
1278PxeBcDhcp6Discover (\r
1279 IN PXEBC_PRIVATE_DATA *Private,\r
1280 IN UINT16 Type,\r
1281 IN UINT16 *Layer,\r
1282 IN BOOLEAN UseBis,\r
1283 IN EFI_IP_ADDRESS *DestIp\r
1284 )\r
1285{\r
1286 EFI_PXE_BASE_CODE_UDP_PORT SrcPort;\r
1287 EFI_PXE_BASE_CODE_UDP_PORT DestPort;\r
1288 EFI_PXE_BASE_CODE_MODE *Mode;\r
1289 EFI_PXE_BASE_CODE_PROTOCOL *PxeBc;\r
1290 EFI_PXE_BASE_CODE_DHCPV6_PACKET *Discover;\r
1291 UINTN DiscoverLen;\r
1292 EFI_DHCP6_PACKET *Request;\r
1293 UINTN RequestLen;\r
1294 EFI_DHCP6_PACKET *Reply;\r
1295 UINT8 *RequestOpt;\r
1296 UINT8 *DiscoverOpt;\r
1297 UINTN ReadSize;\r
1298 UINT16 OpFlags;\r
1299 UINT16 OpCode;\r
1300 UINT16 OpLen;\r
1301 UINT32 Xid;\r
1302 EFI_STATUS Status;\r
1303\r
1304 PxeBc = &Private->PxeBc;\r
1305 Mode = PxeBc->Mode;\r
1306 Request = Private->Dhcp6Request;\r
1307 SrcPort = PXEBC_BS_DISCOVER_PORT;\r
1308 DestPort = PXEBC_BS_DISCOVER_PORT;\r
1309 OpFlags = 0;\r
1310\r
1311 if (!UseBis && Layer != NULL) {\r
1312 *Layer &= EFI_PXE_BASE_CODE_BOOT_LAYER_MASK;\r
1313 }\r
1314\r
1315 if (Request == NULL) {\r
1316 return EFI_DEVICE_ERROR;\r
1317 }\r
1318\r
1319 Discover = AllocateZeroPool (sizeof (EFI_PXE_BASE_CODE_DHCPV6_PACKET));\r
1320 if (Discover == NULL) {\r
1321 return EFI_OUT_OF_RESOURCES;\r
1322 }\r
1323\r
1324 //\r
1325 // Build the discover packet by the cached request packet before.\r
1326 //\r
1327 Xid = NET_RANDOM (NetRandomInitSeed ());\r
1328 Discover->TransactionId = HTONL (Xid);\r
1329 Discover->MessageType = Request->Dhcp6.Header.MessageType;\r
1330 RequestOpt = Request->Dhcp6.Option;\r
1331 DiscoverOpt = Discover->DhcpOptions;\r
1332 DiscoverLen = sizeof (EFI_DHCP6_HEADER);\r
1333 RequestLen = DiscoverLen;\r
1334\r
1335 while (RequestLen < Request->Length) {\r
1336 OpCode = NTOHS (((EFI_DHCP6_PACKET_OPTION *) RequestOpt)->OpCode);\r
1337 OpLen = NTOHS (((EFI_DHCP6_PACKET_OPTION *) RequestOpt)->OpLen);\r
1338 if (OpCode != EFI_DHCP6_IA_TYPE_NA &&\r
1339 OpCode != EFI_DHCP6_IA_TYPE_TA) {\r
1340 //\r
1341 // Copy all the options except IA option.\r
1342 //\r
1343 CopyMem (DiscoverOpt, RequestOpt, OpLen + 4);\r
1344 DiscoverOpt += (OpLen + 4);\r
1345 DiscoverLen += (OpLen + 4);\r
1346 }\r
1347 RequestOpt += (OpLen + 4);\r
1348 RequestLen += (OpLen + 4);\r
1349 }\r
1350\r
1351 Status = PxeBc->UdpWrite (\r
1352 PxeBc,\r
1353 OpFlags,\r
1354 &Private->ServerIp,\r
1355 &DestPort,\r
1356 NULL,\r
1357 &Private->StationIp,\r
1358 &SrcPort,\r
1359 NULL,\r
1360 NULL,\r
1361 &DiscoverLen,\r
1362 (VOID *) Discover\r
1363 );\r
1364 if (EFI_ERROR (Status)) {\r
1365 return Status;\r
1366 }\r
1367\r
1368 //\r
1369 // Cache the right PXE reply packet here, set valid flag later.\r
1370 // Especially for PXE discover packet, store it into mode data here.\r
1371 //\r
1372 if (Private->IsDoDiscover) {\r
1373 CopyMem (&Mode->PxeDiscover.Dhcpv6, Discover, DiscoverLen);\r
1374 Reply = &Private->PxeReply.Dhcp6.Packet.Ack;\r
1375 } else {\r
1376 Reply = &Private->ProxyOffer.Dhcp6.Packet.Offer;\r
1377 }\r
1378 ReadSize = (UINTN) Reply->Size;\r
1379\r
1380 Status = PxeBc->UdpRead (\r
1381 PxeBc,\r
1382 OpFlags,\r
1383 &Private->StationIp,\r
1384 &SrcPort,\r
1385 &Private->ServerIp,\r
1386 &DestPort,\r
1387 NULL,\r
1388 NULL,\r
1389 &ReadSize,\r
1390 (VOID *) &Reply->Dhcp6\r
1391 );\r
1392 if (EFI_ERROR (Status)) {\r
1393 return Status;\r
1394 }\r
1395\r
1396 return EFI_SUCCESS;\r
1397}\r
1398\r
1399\r
1400/**\r
1401 Start the DHCPv6 S.A.R.R. process to acquire the IPv6 address and other PXE boot information.\r
1402\r
1403 @param[in] Private The pointer to PxeBc private data.\r
1404 @param[in] Dhcp6 The pointer to the EFI_DHCP6_PROTOCOL\r
1405\r
1406 @retval EFI_SUCCESS The S.A.R.R. process successfully finished.\r
1407 @retval Others Failed to finish the S.A.R.R. process.\r
1408\r
1409**/\r
1410EFI_STATUS\r
1411PxeBcDhcp6Sarr (\r
1412 IN PXEBC_PRIVATE_DATA *Private,\r
1413 IN EFI_DHCP6_PROTOCOL *Dhcp6\r
1414 )\r
1415{\r
1416 EFI_PXE_BASE_CODE_MODE *PxeMode;\r
1417 EFI_DHCP6_CONFIG_DATA Config;\r
1418 EFI_DHCP6_MODE_DATA Mode;\r
1419 EFI_DHCP6_RETRANSMISSION *Retransmit;\r
1420 EFI_DHCP6_PACKET_OPTION *OptList[PXEBC_DHCP6_OPTION_MAX_NUM];\r
1421 UINT8 Buffer[PXEBC_DHCP6_OPTION_MAX_SIZE];\r
1422 UINT32 OptCount;\r
1423 EFI_STATUS Status;\r
1424\r
1425 Status = EFI_SUCCESS;\r
1426 PxeMode = Private->PxeBc.Mode;\r
1427\r
1428 //\r
1429 // Build option list for the request packet.\r
1430 //\r
1431 OptCount = PxeBcBuildDhcp6Options (Private, OptList, Buffer);\r
1432 ASSERT (OptCount> 0);\r
1433\r
1434 Retransmit = AllocateZeroPool (sizeof (EFI_DHCP6_RETRANSMISSION));\r
1435 if (Retransmit == NULL) {\r
1436 return EFI_OUT_OF_RESOURCES;\r
1437 }\r
1438\r
1439 ZeroMem (&Mode, sizeof (EFI_DHCP6_MODE_DATA));\r
1440 ZeroMem (&Config, sizeof (EFI_DHCP6_CONFIG_DATA));\r
1441\r
1442 Config.OptionCount = OptCount;\r
1443 Config.OptionList = OptList;\r
1444 Config.Dhcp6Callback = PxeBcDhcp6CallBack;\r
1445 Config.CallbackContext = Private;\r
1446 Config.IaInfoEvent = NULL;\r
1447 Config.RapidCommit = FALSE;\r
1448 Config.ReconfigureAccept = FALSE;\r
1449 Config.IaDescriptor.IaId = 1;\r
1450 Config.IaDescriptor.Type = EFI_DHCP6_IA_TYPE_NA;\r
1451 Config.SolicitRetransmission = Retransmit;\r
1452 Retransmit->Irt = 4;\r
1453 Retransmit->Mrc = 4;\r
1454 Retransmit->Mrt = 32;\r
1455 Retransmit->Mrd = 60;\r
1456\r
1457 //\r
1458 // Configure the DHCPv6 instance for PXE boot.\r
1459 //\r
1460 Status = Dhcp6->Configure (Dhcp6, &Config);\r
1461 if (EFI_ERROR (Status)) {\r
1462 FreePool (Retransmit);\r
1463 return Status;\r
1464 }\r
1465\r
1466 //\r
1467 // Initialize the record fields for DHCPv6 offer in private data.\r
1468 //\r
1469 Private->IsProxyRecved = FALSE;\r
1470 Private->OfferNum = 0;\r
1471 Private->SelectIndex = 0;\r
1472 ZeroMem (Private->OfferCount, sizeof (Private->OfferCount));\r
1473 ZeroMem (Private->OfferIndex, sizeof (Private->OfferIndex));\r
1474\r
1475\r
1476 //\r
1477 // Start DHCPv6 S.A.R.R. process to acquire IPv6 address.\r
1478 //\r
1479 Status = Dhcp6->Start (Dhcp6);\r
1480 if (EFI_ERROR (Status)) {\r
1481 if (Status == EFI_ICMP_ERROR) {\r
1482 PxeMode->IcmpErrorReceived = TRUE;\r
1483 }\r
1484 Dhcp6->Configure (Dhcp6, NULL);\r
1485 return Status;\r
1486 }\r
1487\r
1488 //\r
1489 // Get the acquired IPv6 address and store them.\r
1490 //\r
1491 Status = Dhcp6->GetModeData (Dhcp6, &Mode, NULL);\r
1492 if (EFI_ERROR (Status)) {\r
1493 Dhcp6->Stop (Dhcp6);\r
1494 return Status;\r
1495 }\r
1496\r
1497 ASSERT (Mode.Ia->State == Dhcp6Bound);\r
1498 CopyMem (&Private->StationIp.v6, &Mode.Ia->IaAddress[0].IpAddress, sizeof (EFI_IPv6_ADDRESS));\r
1499 CopyMem (&PxeMode->StationIp.v6, &Private->StationIp.v6, sizeof (EFI_IPv6_ADDRESS));\r
1500\r
1501 Status = PxeBcRegisterIp6Address (Private, &Private->StationIp.v6);\r
1502 if (EFI_ERROR (Status)) {\r
1503 Dhcp6->Stop (Dhcp6);\r
1504 return Status;\r
1505 }\r
1506\r
1507 Status = PxeBcFlushStaionIp (Private, &Private->StationIp, NULL);\r
1508 if (EFI_ERROR (Status)) {\r
1509 PxeBcUnregisterIp6Address (Private);\r
1510 Dhcp6->Stop (Dhcp6);\r
1511 return Status;\r
1512 }\r
1513\r
1514 //\r
1515 // Check the selected offer whether BINL retry is needed.\r
1516 //\r
1517 Status = PxeBcHandleDhcp6Offer (Private);\r
1518 if (EFI_ERROR (Status)) {\r
1519 PxeBcUnregisterIp6Address (Private);\r
1520 Dhcp6->Stop (Dhcp6);\r
1521 return Status;\r
1522 }\r
1523\r
1524 AsciiPrint ("\n Station IP address is ");\r
1525\r
1526 PxeBcShowIp6Addr (&Private->StationIp.v6);\r
1527\r
1528 return EFI_SUCCESS;\r
1529}\r
1530\r
EFI Development Kit II mirror for PVE