2 Function to validate, parse, process the DHCP options.
4 Copyright (c) 2006 - 2008, Intel Corporation.<BR>
5 All rights reserved. This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "Dhcp4Impl.h"
18 /// A list of the format of DHCP Options sorted by option tag
19 /// to validate a dhcp message. Refere the comments of the
20 /// DHCP_OPTION_FORMAT structure.
22 DHCP_OPTION_FORMAT DhcpOptionFormats
[] = {
23 {DHCP_TAG_NETMASK
, DHCP_OPTION_IP
, 1, 1 , TRUE
},
24 {DHCP_TAG_TIME_OFFSET
, DHCP_OPTION_INT32
, 1, 1 , FALSE
},
25 {DHCP_TAG_ROUTER
, DHCP_OPTION_IP
, 1, -1 , TRUE
},
26 {DHCP_TAG_TIME_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
27 {DHCP_TAG_NAME_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
28 {DHCP_TAG_DNS_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
29 {DHCP_TAG_LOG_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
30 {DHCP_TAG_COOKIE_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
31 {DHCP_TAG_LPR_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
32 {DHCP_TAG_IMPRESS_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
33 {DHCP_TAG_RL_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
34 {DHCP_TAG_HOSTNAME
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
35 {DHCP_TAG_BOOTFILE_LEN
, DHCP_OPTION_INT16
, 1, 1 , FALSE
},
36 {DHCP_TAG_DUMP
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
37 {DHCP_TAG_DOMAINNAME
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
38 {DHCP_TAG_SWAP_SERVER
, DHCP_OPTION_IP
, 1, 1 , FALSE
},
39 {DHCP_TAG_ROOTPATH
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
40 {DHCP_TAG_EXTEND_PATH
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
42 {DHCP_TAG_IPFORWARD
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
43 {DHCP_TAG_NONLOCAL_SRR
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
44 {DHCP_TAG_POLICY_SRR
, DHCP_OPTION_IPPAIR
, 1, -1 , FALSE
},
45 {DHCP_TAG_EMTU
, DHCP_OPTION_INT16
, 1, 1 , FALSE
},
46 {DHCP_TAG_TTL
, DHCP_OPTION_INT8
, 1, 1 , FALSE
},
47 {DHCP_TAG_PATHMTU_AGE
, DHCP_OPTION_INT32
, 1, 1 , FALSE
},
48 {DHCP_TAG_PATHMTU_PLATEAU
,DHCP_OPTION_INT16
, 1, -1 , FALSE
},
50 {DHCP_TAG_IFMTU
, DHCP_OPTION_INT16
, 1, 1 , FALSE
},
51 {DHCP_TAG_SUBNET_LOCAL
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
52 {DHCP_TAG_BROADCAST
, DHCP_OPTION_IP
, 1, 1 , FALSE
},
53 {DHCP_TAG_DISCOVER_MASK
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
54 {DHCP_TAG_SUPPLY_MASK
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
55 {DHCP_TAG_DISCOVER_ROUTE
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
56 {DHCP_TAG_ROUTER_SOLICIT
, DHCP_OPTION_IP
, 1, 1 , FALSE
},
57 {DHCP_TAG_STATIC_ROUTE
, DHCP_OPTION_IPPAIR
, 1, -1 , FALSE
},
59 {DHCP_TAG_TRAILER
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
60 {DHCP_TAG_ARPAGE
, DHCP_OPTION_INT32
, 1, 1 , FALSE
},
61 {DHCP_TAG_ETHER_ENCAP
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
63 {DHCP_TAG_TCP_TTL
, DHCP_OPTION_INT8
, 1, 1 , FALSE
},
64 {DHCP_TAG_KEEP_INTERVAL
, DHCP_OPTION_INT32
, 1, 1 , FALSE
},
65 {DHCP_TAG_KEEP_GARBAGE
, DHCP_OPTION_SWITCH
, 1, 1 , FALSE
},
67 {DHCP_TAG_NIS_DOMAIN
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
68 {DHCP_TAG_NIS_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
69 {DHCP_TAG_NTP_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
70 {DHCP_TAG_VENDOR
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
71 {DHCP_TAG_NBNS
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
72 {DHCP_TAG_NBDD
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
73 {DHCP_TAG_NBTYPE
, DHCP_OPTION_INT8
, 1, 1 , FALSE
},
74 {DHCP_TAG_NBSCOPE
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
75 {DHCP_TAG_XFONT
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
76 {DHCP_TAG_XDM
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
78 {DHCP_TAG_REQUEST_IP
, DHCP_OPTION_IP
, 1, 1 , FALSE
},
79 {DHCP_TAG_LEASE
, DHCP_OPTION_INT32
, 1, 1 , TRUE
},
80 {DHCP_TAG_OVERLOAD
, DHCP_OPTION_INT8
, 1, 1 , TRUE
},
81 {DHCP_TAG_TYPE
, DHCP_OPTION_INT8
, 1, 1 , TRUE
},
82 {DHCP_TAG_SERVER_ID
, DHCP_OPTION_IP
, 1, 1 , TRUE
},
83 {DHCP_TAG_PARA_LIST
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
84 {DHCP_TAG_MESSAGE
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
85 {DHCP_TAG_MAXMSG
, DHCP_OPTION_INT16
, 1, 1 , FALSE
},
86 {DHCP_TAG_T1
, DHCP_OPTION_INT32
, 1, 1 , TRUE
},
87 {DHCP_TAG_T2
, DHCP_OPTION_INT32
, 1, 1 , TRUE
},
88 {DHCP_TAG_VENDOR_CLASS
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
89 {DHCP_TAG_CLIENT_ID
, DHCP_OPTION_INT8
, 2, -1 , FALSE
},
91 {DHCP_TAG_NISPLUS
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
92 {DHCP_TAG_NISPLUS_SERVER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
94 {DHCP_TAG_TFTP
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
95 {DHCP_TAG_BOOTFILE
, DHCP_OPTION_INT8
, 1, -1 , FALSE
},
97 {DHCP_TAG_MOBILEIP
, DHCP_OPTION_IP
, 0, -1 , FALSE
},
98 {DHCP_TAG_SMTP
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
99 {DHCP_TAG_POP3
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
100 {DHCP_TAG_NNTP
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
101 {DHCP_TAG_WWW
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
102 {DHCP_TAG_FINGER
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
103 {DHCP_TAG_IRC
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
104 {DHCP_TAG_STTALK
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
105 {DHCP_TAG_STDA
, DHCP_OPTION_IP
, 1, -1 , FALSE
},
107 {DHCP_TAG_CLASSLESS_ROUTE
,DHCP_OPTION_INT8
, 5, -1 , FALSE
},
112 Binary search the DhcpOptionFormats array to find the format
113 information about a specific option.
115 @param[in] Tag The option's tag.
117 @return The point to the option's format, NULL if not found.
121 DhcpFindOptionFormat (
130 Right
= sizeof (DhcpOptionFormats
) / sizeof (DHCP_OPTION_FORMAT
) - 1;
132 while (Right
>= Left
) {
133 Middle
= (Left
+ Right
) / 2;
135 if (Tag
== DhcpOptionFormats
[Middle
].Tag
) {
136 return &DhcpOptionFormats
[Middle
];
139 if (Tag
< DhcpOptionFormats
[Middle
].Tag
) {
151 Validate whether a single DHCP option is valid according to its format.
153 @param[in] Format The option's format
154 @param[in] OptValue The value of the option
155 @param[in] Len The length of the option value
157 @retval TRUE The option is valid.
158 @retval FALSE Otherwise.
163 IN DHCP_OPTION_FORMAT
*Format
,
174 switch (Format
->Type
) {
175 case DHCP_OPTION_SWITCH
:
176 case DHCP_OPTION_INT8
:
180 case DHCP_OPTION_INT16
:
184 case DHCP_OPTION_INT32
:
189 case DHCP_OPTION_IPPAIR
:
197 // Validate that the option appears in the full units.
199 if ((Len
% Unit
) != 0) {
204 // Validate the occurance of the option unit is with in [MinOccur, MaxOccur]
208 if (((Format
->MinOccur
!= -1) && (Occur
< Format
->MinOccur
)) ||
209 ((Format
->MaxOccur
!= -1) && (Occur
> Format
->MaxOccur
))
215 // If the option is of type switch, only 0/1 are valid values.
217 if (Format
->Type
== DHCP_OPTION_SWITCH
) {
218 for (Index
= 0; Index
< Occur
; Index
++) {
219 if ((OptValue
[Index
] != 0) && (OptValue
[Index
] != 1)) {
230 Extract the client interested options, all the parameters are
231 converted to host byte order.
233 @param[in] Tag The DHCP option tag
234 @param[in] Len The length of the option
235 @param[in] Data The value of the DHCP option
236 @param[out] Para The variable to save the interested parameter
238 @retval EFI_SUCCESS The DHCP option is successfully extracted.
239 @retval EFI_INVALID_PARAMETER The DHCP option is mal-formated
247 OUT DHCP_PARAMETER
*Para
251 case DHCP_TAG_NETMASK
:
252 Para
->NetMask
= NetGetUint32 (Data
);
255 case DHCP_TAG_ROUTER
:
257 // Return the first router to consumer which is the preferred one
259 Para
->Router
= NetGetUint32 (Data
);
263 Para
->Lease
= NetGetUint32 (Data
);
266 case DHCP_TAG_OVERLOAD
:
267 Para
->Overload
= *Data
;
269 if ((Para
->Overload
< 1) || (Para
->Overload
> 3)) {
270 return EFI_INVALID_PARAMETER
;
275 Para
->DhcpType
= *Data
;
277 if ((Para
->DhcpType
< 1) || (Para
->DhcpType
> 9)) {
278 return EFI_INVALID_PARAMETER
;
282 case DHCP_TAG_SERVER_ID
:
283 Para
->ServerId
= NetGetUint32 (Data
);
287 Para
->T1
= NetGetUint32 (Data
);
291 Para
->T2
= NetGetUint32 (Data
);
300 Inspect all the options in a single buffer. DHCP options may be contained
301 in several buffers, such as the BOOTP options filed, boot file or server
302 name. Each option buffer is required to end with DHCP_TAG_EOP.
304 @param[in] Buffer The buffer which contains DHCP options
305 @param[in] BufLen The length of the buffer
306 @param[in] Check The callback function for each option found
307 @param[in] Context The opaque parameter for the Check
308 @param[out] Overload Variable to save the value of DHCP_TAG_OVERLOAD
311 @retval EFI_SUCCESS All the options are valid
312 @retval EFI_INVALID_PARAMETER The options are mal-formated.
316 DhcpIterateBufferOptions (
319 IN DHCP_CHECK_OPTION Check OPTIONAL
,
321 OUT UINT8
*Overload OPTIONAL
330 while (Cur
< BufLen
) {
333 if (Tag
== DHCP_TAG_PAD
) {
336 } else if (Tag
== DHCP_TAG_EOP
) {
343 return EFI_INVALID_PARAMETER
;
348 if (Cur
+ Len
> BufLen
) {
349 return EFI_INVALID_PARAMETER
;
352 if ((Tag
== DHCP_TAG_OVERLOAD
) && (Overload
!= NULL
)) {
354 return EFI_INVALID_PARAMETER
;
357 *Overload
= Buffer
[Cur
];
360 if ((Check
!= NULL
) && EFI_ERROR (Check (Tag
, Len
, Buffer
+ Cur
, Context
))) {
361 return EFI_INVALID_PARAMETER
;
368 // Each option buffer is expected to end with an EOP
370 return EFI_INVALID_PARAMETER
;
375 Iterate through a DHCP message to visit each option. First inspect
376 all the options in the OPTION field. Then if overloaded, inspect
377 the options in FILENAME and SERVERNAME fields. One option may be
378 encoded in several places. See RFC 3396 Encoding Long Options in DHCP
380 @param[in] Packet The DHCP packet to check the options for
381 @param[in] Check The callback function to be called for each option
383 @param[in] Context The opaque parameter for Check
385 @retval EFI_SUCCESS The DHCP packet's options are well formated
386 @retval EFI_INVALID_PARAMETER The DHCP packet's options are not well formated
391 IN EFI_DHCP4_PACKET
*Packet
,
392 IN DHCP_CHECK_OPTION Check OPTIONAL
,
401 Status
= DhcpIterateBufferOptions (
402 Packet
->Dhcp4
.Option
,
403 Packet
->Length
- sizeof (EFI_DHCP4_HEADER
) - sizeof (UINT32
),
409 if (EFI_ERROR (Status
)) {
413 if ((Overload
== DHCP_OVERLOAD_FILENAME
) || (Overload
== DHCP_OVERLOAD_BOTH
)) {
414 Status
= DhcpIterateBufferOptions (
415 (UINT8
*) Packet
->Dhcp4
.Header
.BootFileName
,
422 if (EFI_ERROR (Status
)) {
427 if ((Overload
== DHCP_OVERLOAD_SVRNAME
) || (Overload
== DHCP_OVERLOAD_BOTH
)) {
428 Status
= DhcpIterateBufferOptions (
429 (UINT8
*) Packet
->Dhcp4
.Header
.ServerName
,
436 if (EFI_ERROR (Status
)) {
446 Call back function to DhcpIterateOptions to compute each option's
447 length. It just adds the data length of all the occurances of this
448 Tag. Context is an array of 256 DHCP_OPTION_COUNT.
450 @param[in] Tag The current option to check
451 @param[in] Len The length of the option data
452 @param[in] Data The option data
453 @param[in] Context The context, which is a array of 256
456 @retval EFI_SUCCESS It always returns EFI_SUCCESS.
467 DHCP_OPTION_COUNT
*OpCount
;
469 OpCount
= (DHCP_OPTION_COUNT
*) Context
;
470 OpCount
[Tag
].Offset
= (UINT16
) (OpCount
[Tag
].Offset
+ Len
);
477 Call back function to DhcpIterateOptions to consolidate each option's
478 data. There are maybe several occurrence of the same option.
480 @param[in] Tag The option to consolidate its data
481 @param[in] Len The length of option data
482 @param[in] Data The data of the option's current occurance
483 @param[in] Context The context, which is DHCP_OPTION_CONTEXT. This
484 array is just a wrap to pass THREE parameters.
486 @retval EFI_SUCCESS It always returns EFI_SUCCESS
497 DHCP_OPTION_CONTEXT
*OptContext
;
498 DHCP_OPTION_COUNT
*OptCount
;
499 DHCP_OPTION
*Options
;
503 OptContext
= (DHCP_OPTION_CONTEXT
*) Context
;
505 OptCount
= OptContext
->OpCount
;
506 Index
= OptCount
[Tag
].Index
;
507 Options
= OptContext
->Options
;
508 Buf
= OptContext
->Buf
;
510 if (Options
[Index
].Data
== NULL
) {
511 Options
[Index
].Tag
= Tag
;
512 Options
[Index
].Data
= Buf
+ OptCount
[Tag
].Offset
;
515 CopyMem (Buf
+ OptCount
[Tag
].Offset
, Data
, Len
);
517 OptCount
[Tag
].Offset
= (UINT16
) (OptCount
[Tag
].Offset
+ Len
);
518 Options
[Index
].Len
= (UINT16
) (Options
[Index
].Len
+ Len
);
524 Parse the options of a DHCP packet. It supports RFC 3396: Encoding
525 Long Options in DHCP. That is, it will combine all the option value
526 of all the occurances of each option.
527 A little bit of implemenation:
528 It adopts the "Key indexed counting" algorithm. First, it allocates
529 an array of 256 DHCP_OPTION_COUNTs because DHCP option tag is encoded
530 as a UINT8. It then iterates the DHCP packet to get data length of
531 each option by calling DhcpIterOptions with DhcpGetOptionLen. Now, it
532 knows the number of present options and their length. It allocates a
533 array of DHCP_OPTION and a continuous buffer after the array to put
534 all the options' data. Each option's data is pointed to by the Data
535 field in DHCP_OPTION structure. At last, it call DhcpIterateOptions
536 with DhcpFillOption to fill each option's data to its position in the
539 @param[in] Packet The DHCP packet to parse the options
540 @param[out] Count The number of valid dhcp options present in the
542 @param[out] OptionPoint The array that contains the DHCP options. Caller
545 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory to parse the packet.
546 @retval EFI_INVALID_PARAMETER The options are mal-formated
547 @retval EFI_SUCCESS The options are parsed into OptionPoint
552 IN EFI_DHCP4_PACKET
*Packet
,
554 OUT DHCP_OPTION
**OptionPoint
557 DHCP_OPTION_CONTEXT Context
;
558 DHCP_OPTION
*Options
;
559 DHCP_OPTION_COUNT
*OptCount
;
565 ASSERT ((Count
!= NULL
) && (OptionPoint
!= NULL
));
568 // First compute how many options and how long each option is
569 // with the "Key indexed counting" algorithms.
571 OptCount
= AllocateZeroPool (DHCP_MAX_OPTIONS
* sizeof (DHCP_OPTION_COUNT
));
573 if (OptCount
== NULL
) {
574 return EFI_OUT_OF_RESOURCES
;
577 Status
= DhcpIterateOptions (Packet
, DhcpGetOptionLen
, OptCount
);
579 if (EFI_ERROR (Status
)) {
584 // Before the loop, Offset is the length of the option. After loop,
585 // OptCount[Index].Offset specifies the offset into the continuous
586 // option value buffer to put the data.
591 for (Index
= 0; Index
< DHCP_MAX_OPTIONS
; Index
++) {
592 if (OptCount
[Index
].Offset
!= 0) {
593 OptCount
[Index
].Index
= (UINT8
) OptNum
;
595 TotalLen
= (UINT16
) (TotalLen
+ OptCount
[Index
].Offset
);
596 OptCount
[Index
].Offset
= (UINT16
) (TotalLen
- OptCount
[Index
].Offset
);
610 // Allocate a buffer to hold the DHCP options, and after that, a
611 // continuous buffer to put all the options' data.
613 Options
= AllocateZeroPool (OptNum
* sizeof (DHCP_OPTION
) + TotalLen
);
615 if (Options
== NULL
) {
616 Status
= EFI_OUT_OF_RESOURCES
;
620 Context
.OpCount
= OptCount
;
621 Context
.Options
= Options
;
622 Context
.Buf
= (UINT8
*) (Options
+ OptNum
);
624 Status
= DhcpIterateOptions (Packet
, DhcpFillOption
, &Context
);
626 if (EFI_ERROR (Status
)) {
627 gBS
->FreePool (Options
);
631 *OptionPoint
= Options
;
634 gBS
->FreePool (OptCount
);
640 Validate the packet's options. If necessary, allocate
641 and fill in the interested parameters.
643 @param[in] Packet The packet to validate the options
644 @param[out] Para The variable to save the DHCP parameters.
646 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory to validate the packet.
647 @retval EFI_INVALID_PARAMETER The options are mal-formated
648 @retval EFI_SUCCESS The options are parsed into OptionPoint
652 DhcpValidateOptions (
653 IN EFI_DHCP4_PACKET
*Packet
,
654 OUT DHCP_PARAMETER
**Para OPTIONAL
657 DHCP_PARAMETER Parameter
;
658 DHCP_OPTION_FORMAT
*Format
;
659 DHCP_OPTION
*AllOption
;
671 Status
= DhcpParseOption (Packet
, &Count
, &AllOption
);
673 if (EFI_ERROR (Status
) || (Count
== 0)) {
678 ZeroMem (&Parameter
, sizeof (Parameter
));
680 for (Index
= 0; Index
< Count
; Index
++) {
681 Option
= &AllOption
[Index
];
684 // Find the format of the option then validate it.
686 Format
= DhcpFindOptionFormat (Option
->Tag
);
688 if (Format
== NULL
) {
692 if (!DhcpOptionIsValid (Format
, Option
->Data
, Option
->Len
)) {
693 Status
= EFI_INVALID_PARAMETER
;
698 // Get the client interested parameters
700 if (Format
->Alert
&& (Para
!= NULL
)) {
702 Status
= DhcpGetParameter (Option
->Tag
, Option
->Len
, Option
->Data
, &Parameter
);
704 if (EFI_ERROR (Status
)) {
710 if (Updated
&& (Para
!= NULL
)) {
711 if ((*Para
= AllocatePool (sizeof (DHCP_PARAMETER
))) == NULL
) {
712 Status
= EFI_OUT_OF_RESOURCES
;
716 CopyMem (*Para
, &Parameter
, sizeof (**Para
));
720 gBS
->FreePool (AllOption
);
727 Append an option to the memory, if the option is longer than
728 255 bytes, splits it into several options.
730 @param[out] Buf The buffer to append the option to
731 @param[in] Tag The option's tag
732 @param[in] DataLen The length of the option's data
733 @param[in] Data The option's data
735 @return The position to append the next option
749 ASSERT (DataLen
!= 0);
751 for (Index
= 0; Index
< (DataLen
+ 254) / 255; Index
++) {
752 Len
= MIN (255, DataLen
- Index
* 255);
755 *(Buf
++) = (UINT8
) Len
;
756 CopyMem (Buf
, Data
+ Index
* 255, Len
);
766 Build a new DHCP packet from a seed packet. Options may be deleted or
767 appended. The caller should free the NewPacket when finished using it.
769 @param[in] SeedPacket The seed packet to start with
770 @param[in] DeleteCount The number of options to delete
771 @param[in] DeleteList The options to delete from the packet
772 @param[in] AppendCount The number of options to append
773 @param[in] AppendList The options to append to the packet
774 @param[out] NewPacket The new packet, allocated and built by this
777 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory
778 @retval EFI_INVALID_PARAMETER The options in SeekPacket are mal-formated
779 @retval EFI_SUCCESS The packet is build.
784 IN EFI_DHCP4_PACKET
*SeedPacket
,
785 IN UINT32 DeleteCount
,
786 IN UINT8
*DeleteList OPTIONAL
,
787 IN UINT32 AppendCount
,
788 IN EFI_DHCP4_PACKET_OPTION
*AppendList
[] OPTIONAL
,
789 OUT EFI_DHCP4_PACKET
**NewPacket
793 DHCP_OPTION
*SeedOptions
;
794 EFI_DHCP4_PACKET
*Packet
;
802 // Use an array of DHCP_OPTION to mark the existance
803 // and position of each valid options.
805 Mark
= AllocatePool (sizeof (DHCP_OPTION
) * DHCP_MAX_OPTIONS
);
808 return EFI_OUT_OF_RESOURCES
;
811 for (Index
= 0; Index
< DHCP_MAX_OPTIONS
; Index
++) {
812 Mark
[Index
].Tag
= (UINT8
) Index
;
817 // Get list of the options from the seed packet, then put
818 // them to the mark array according to their tags.
821 Status
= DhcpParseOption (SeedPacket
, &Count
, &SeedOptions
);
823 if (EFI_ERROR (Status
)) {
827 for (Index
= 0; Index
< (UINT32
) Count
; Index
++) {
828 Mark
[SeedOptions
[Index
].Tag
] = SeedOptions
[Index
];
832 // Mark the option's length is zero if it is in the DeleteList.
834 for (Index
= 0; Index
< DeleteCount
; Index
++) {
835 Mark
[DeleteList
[Index
]].Len
= 0;
839 // Add or replace the option if it is in the append list.
841 for (Index
= 0; Index
< AppendCount
; Index
++) {
842 Mark
[AppendList
[Index
]->OpCode
].Len
= AppendList
[Index
]->Length
;
843 Mark
[AppendList
[Index
]->OpCode
].Data
= AppendList
[Index
]->Data
;
847 // compute the new packet length. No need to add 1 byte for
848 // EOP option since EFI_DHCP4_PACKET includes one extra byte
849 // for option. It is necessary to split the option if it is
850 // longer than 255 bytes.
852 Len
= sizeof (EFI_DHCP4_PACKET
);
854 for (Index
= 0; Index
< DHCP_MAX_OPTIONS
; Index
++) {
855 if (Mark
[Index
].Len
!= 0) {
856 Len
+= ((Mark
[Index
].Len
+ 254) / 255) * 2 + Mark
[Index
].Len
;
860 Status
= EFI_OUT_OF_RESOURCES
;
861 Packet
= (EFI_DHCP4_PACKET
*) AllocatePool (Len
);
863 if (Packet
== NULL
) {
869 CopyMem (&Packet
->Dhcp4
.Header
, &SeedPacket
->Dhcp4
.Header
, sizeof (Packet
->Dhcp4
.Header
));
870 Packet
->Dhcp4
.Magik
= DHCP_OPTION_MAGIC
;
871 Buf
= Packet
->Dhcp4
.Option
;
873 for (Index
= 0; Index
< DHCP_MAX_OPTIONS
; Index
++) {
874 if (Mark
[Index
].Len
!= 0) {
875 Buf
= DhcpAppendOption (Buf
, Mark
[Index
].Tag
, Mark
[Index
].Len
, Mark
[Index
].Data
);
879 *(Buf
++) = DHCP_TAG_EOP
;
880 Packet
->Length
= sizeof (EFI_DHCP4_HEADER
) + sizeof (UINT32
)
881 + (UINT32
) (Buf
- Packet
->Dhcp4
.Option
);
884 Status
= EFI_SUCCESS
;
887 if (SeedOptions
!= NULL
) {
888 gBS
->FreePool (SeedOptions
);
891 gBS
->FreePool (Mark
);