3 EFI_REGULAR_EXPRESSION_PROTOCOL Implementation
5 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
7 SPDX-License-Identifier: BSD-2-Clause-Patent
11 #include "RegularExpressionDxe.h"
14 EFI_REGEX_SYNTAX_TYPE
*CONST mSupportedSyntaxes
[] = {
15 &gEfiRegexSyntaxTypePosixExtendedGuid
,
16 &gEfiRegexSyntaxTypePerlGuid
20 EFI_REGULAR_EXPRESSION_PROTOCOL mProtocolInstance
= {
21 RegularExpressionMatch
,
22 RegularExpressionGetInfo
25 #define CHAR16_ENCODING ONIG_ENCODING_UTF16_LE
28 Call the Oniguruma regex match API.
30 Same parameters as RegularExpressionMatch, except SyntaxType is required.
32 @param String A pointer to a NULL terminated string to match against the
33 regular expression string specified by Pattern.
35 @param Pattern A pointer to a NULL terminated string that represents the
37 @param SyntaxType A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
38 regular expression syntax type to use. May be NULL in which
39 case the function will use its default regular expression
42 @param Result On return, points to TRUE if String fully matches against
43 the regular expression Pattern using the regular expression
44 SyntaxType. Otherwise, points to FALSE.
46 @param Captures A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
47 the captured groups in the event of a match. The full
48 sub-string match is put in Captures[0], and the results of N
49 capturing groups are put in Captures[1:N]. If Captures is
50 NULL, then this function doesn't allocate the memory for the
51 array and does not build up the elements. It only returns the
52 number of matching patterns in CapturesCount. If Captures is
53 not NULL, this function returns a pointer to an array and
54 builds up the elements in the array. CapturesCount is also
55 updated to the number of matching patterns found. It is the
56 caller's responsibility to free the memory pool in Captures
57 and in each CapturePtr in the array elements.
59 @param CapturesCount On output, CapturesCount is the number of matching patterns
60 found in String. Zero means no matching patterns were found
63 @retval EFI_SUCCESS Regex compilation and match completed successfully.
64 @retval EFI_DEVICE_ERROR Regex compilation failed.
72 IN EFI_REGEX_SYNTAX_TYPE
*SyntaxType
,
74 OUT EFI_REGEX_CAPTURE
**Captures OPTIONAL
,
75 OUT UINTN
*CapturesCount
79 OnigSyntaxType
*OnigSyntax
;
82 OnigErrorInfo ErrorInfo
;
83 OnigUChar ErrorMessage
[ONIG_MAX_ERROR_MESSAGE_LEN
];
91 // Detemine the internal syntax type
93 OnigSyntax
= ONIG_SYNTAX_DEFAULT
;
94 if (CompareGuid (SyntaxType
, &gEfiRegexSyntaxTypePosixExtendedGuid
)) {
95 OnigSyntax
= ONIG_SYNTAX_POSIX_EXTENDED
;
96 } else if (CompareGuid (SyntaxType
, &gEfiRegexSyntaxTypePerlGuid
)) {
97 OnigSyntax
= ONIG_SYNTAX_PERL
;
99 DEBUG ((DEBUG_ERROR
, "Unsupported regex syntax - using default\n"));
100 return EFI_UNSUPPORTED
;
106 Start
= (OnigUChar
*)Pattern
;
107 OnigResult
= onig_new (
110 Start
+ onigenc_str_bytelen_null (CHAR16_ENCODING
, Start
),
117 if (OnigResult
!= ONIG_NORMAL
) {
118 onig_error_code_to_str (ErrorMessage
, OnigResult
, &ErrorInfo
);
119 DEBUG ((DEBUG_ERROR
, "Regex compilation failed: %a\n", ErrorMessage
));
120 return EFI_DEVICE_ERROR
;
126 Start
= (OnigUChar
*)String
;
127 Region
= onig_region_new ();
128 if (Region
== NULL
) {
129 onig_free (OnigRegex
);
130 return EFI_OUT_OF_RESOURCES
;
133 OnigResult
= onig_search (
136 Start
+ onigenc_str_bytelen_null (CHAR16_ENCODING
, Start
),
138 Start
+ onigenc_str_bytelen_null (CHAR16_ENCODING
, Start
),
143 if (OnigResult
>= 0) {
147 if (OnigResult
!= ONIG_MISMATCH
) {
148 onig_error_code_to_str (ErrorMessage
, OnigResult
);
149 DEBUG ((DEBUG_ERROR
, "Regex match failed: %a\n", ErrorMessage
));
150 onig_region_free (Region
, 1);
151 onig_free (OnigRegex
);
152 return EFI_DEVICE_ERROR
;
157 // If successful, copy out the region (capture) information
159 if (*Result
&& (Captures
!= NULL
)) {
160 *CapturesCount
= Region
->num_regs
;
161 *Captures
= AllocateZeroPool (*CapturesCount
* sizeof (**Captures
));
162 if (*Captures
!= NULL
) {
163 for (Index
= 0; Index
< *CapturesCount
; ++Index
) {
165 // Region beg/end values represent bytes, not characters
167 (*Captures
)[Index
].Length
= (Region
->end
[Index
] - Region
->beg
[Index
]) / sizeof (CHAR16
);
168 (*Captures
)[Index
].CapturePtr
= AllocateCopyPool (
169 ((*Captures
)[Index
].Length
) * sizeof (CHAR16
),
170 (CHAR16
*)((UINTN
)String
+ Region
->beg
[Index
])
172 if ((*Captures
)[Index
].CapturePtr
== NULL
) {
173 Status
= EFI_OUT_OF_RESOURCES
;
178 if (EFI_ERROR (Status
)) {
179 for (Index
= 0; Index
< *CapturesCount
; ++Index
) {
180 if ((*Captures
)[Index
].CapturePtr
!= NULL
) {
181 FreePool ((CHAR16
*)(*Captures
)[Index
].CapturePtr
);
185 FreePool (*Captures
);
190 onig_region_free (Region
, 1);
191 onig_free (OnigRegex
);
197 Returns information about the regular expression syntax types supported
198 by the implementation.
200 @param This A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL
203 @param RegExSyntaxTypeListSize On input, the size in bytes of RegExSyntaxTypeList.
204 On output with a return code of EFI_SUCCESS, the
205 size in bytes of the data returned in
206 RegExSyntaxTypeList. On output with a return code
207 of EFI_BUFFER_TOO_SMALL, the size of
208 RegExSyntaxTypeList required to obtain the list.
210 @param RegExSyntaxTypeList A caller-allocated memory buffer filled by the
211 driver with one EFI_REGEX_SYNTAX_TYPE element
212 for each supported Regular expression syntax
213 type. The list must not change across multiple
214 calls to the same driver. The first syntax
215 type in the list is the default type for the
218 @retval EFI_SUCCESS The regular expression syntax types list
219 was returned successfully.
220 @retval EFI_UNSUPPORTED The service is not supported by this driver.
221 @retval EFI_DEVICE_ERROR The list of syntax types could not be
222 retrieved due to a hardware or firmware error.
223 @retval EFI_BUFFER_TOO_SMALL The buffer RegExSyntaxTypeList is too small
225 @retval EFI_INVALID_PARAMETER RegExSyntaxTypeListSize is NULL
230 RegularExpressionGetInfo (
231 IN EFI_REGULAR_EXPRESSION_PROTOCOL
*This
,
232 IN OUT UINTN
*RegExSyntaxTypeListSize
,
233 OUT EFI_REGEX_SYNTAX_TYPE
*RegExSyntaxTypeList
239 if ((This
== NULL
) || (RegExSyntaxTypeListSize
== NULL
)) {
240 return EFI_INVALID_PARAMETER
;
243 if ((*RegExSyntaxTypeListSize
!= 0) && (RegExSyntaxTypeList
== NULL
)) {
244 return EFI_INVALID_PARAMETER
;
247 SyntaxSize
= ARRAY_SIZE (mSupportedSyntaxes
) * sizeof (**mSupportedSyntaxes
);
249 if (*RegExSyntaxTypeListSize
< SyntaxSize
) {
250 *RegExSyntaxTypeListSize
= SyntaxSize
;
251 return EFI_BUFFER_TOO_SMALL
;
254 for (Index
= 0; Index
< ARRAY_SIZE (mSupportedSyntaxes
); ++Index
) {
255 CopyMem (&RegExSyntaxTypeList
[Index
], mSupportedSyntaxes
[Index
], sizeof (**mSupportedSyntaxes
));
258 *RegExSyntaxTypeListSize
= SyntaxSize
;
264 Checks if the input string matches to the regular expression pattern.
266 @param This A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL instance.
267 Type EFI_REGULAR_EXPRESSION_PROTOCOL is defined in Section
270 @param String A pointer to a NULL terminated string to match against the
271 regular expression string specified by Pattern.
273 @param Pattern A pointer to a NULL terminated string that represents the
276 @param SyntaxType A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
277 regular expression syntax type to use. May be NULL in which
278 case the function will use its default regular expression
281 @param Result On return, points to TRUE if String fully matches against
282 the regular expression Pattern using the regular expression
283 SyntaxType. Otherwise, points to FALSE.
285 @param Captures A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
286 the captured groups in the event of a match. The full
287 sub-string match is put in Captures[0], and the results of N
288 capturing groups are put in Captures[1:N]. If Captures is
289 NULL, then this function doesn't allocate the memory for the
290 array and does not build up the elements. It only returns the
291 number of matching patterns in CapturesCount. If Captures is
292 not NULL, this function returns a pointer to an array and
293 builds up the elements in the array. CapturesCount is also
294 updated to the number of matching patterns found. It is the
295 caller's responsibility to free the memory pool in Captures
296 and in each CapturePtr in the array elements.
298 @param CapturesCount On output, CapturesCount is the number of matching patterns
299 found in String. Zero means no matching patterns were found
302 @retval EFI_SUCCESS The regular expression string matching
303 completed successfully.
304 @retval EFI_UNSUPPORTED The regular expression syntax specified by
305 SyntaxType is not supported by this driver.
306 @retval EFI_DEVICE_ERROR The regular expression string matching
307 failed due to a hardware or firmware error.
308 @retval EFI_INVALID_PARAMETER String, Pattern, Result, or CapturesCountis
314 RegularExpressionMatch (
315 IN EFI_REGULAR_EXPRESSION_PROTOCOL
*This
,
318 IN EFI_REGEX_SYNTAX_TYPE
*SyntaxType OPTIONAL
,
320 OUT EFI_REGEX_CAPTURE
**Captures OPTIONAL
,
321 OUT UINTN
*CapturesCount
328 if ((This
== NULL
) || (String
== NULL
) || (Pattern
== NULL
) || (Result
== NULL
) || (CapturesCount
== NULL
)) {
329 return EFI_INVALID_PARAMETER
;
333 // Figure out which syntax to use
335 if (SyntaxType
== NULL
) {
336 SyntaxType
= mSupportedSyntaxes
[0];
339 for (Index
= 0; Index
< ARRAY_SIZE (mSupportedSyntaxes
); ++Index
) {
340 if (CompareGuid (SyntaxType
, mSupportedSyntaxes
[Index
])) {
347 return EFI_UNSUPPORTED
;
351 Status
= OnigurumaMatch (String
, Pattern
, SyntaxType
, Result
, Captures
, CapturesCount
);
357 Entry point for RegularExpressionDxe.
359 @param ImageHandle Image handle this driver.
360 @param SystemTable Pointer to SystemTable.
362 @retval Status Whether this function complete successfully.
367 RegularExpressionDxeEntry (
368 IN EFI_HANDLE ImageHandle
,
369 IN EFI_SYSTEM_TABLE
*SystemTable
374 Status
= gBS
->InstallMultipleProtocolInterfaces (
376 &gEfiRegularExpressionProtocolGuid
,