MdeModulePkg: Delete useless case code
[mirror_edk2.git] / MdeModulePkg / Universal / RegularExpressionDxe / RegularExpressionDxe.c
1 /** @file
2
3 EFI_REGULAR_EXPRESSION_PROTOCOL Implementation
4
5 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
6
7 This program and the accompanying materials are licensed and made available
8 under the terms and conditions of the BSD License that accompanies this
9 distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php.
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
13 WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include "RegularExpressionDxe.h"
18
19 STATIC
20 EFI_REGEX_SYNTAX_TYPE * CONST mSupportedSyntaxes[] = {
21 &gEfiRegexSyntaxTypePosixExtendedGuid,
22 &gEfiRegexSyntaxTypePerlGuid
23 };
24
25 STATIC
26 EFI_REGULAR_EXPRESSION_PROTOCOL mProtocolInstance = {
27 RegularExpressionMatch,
28 RegularExpressionGetInfo
29 };
30
31
32
33 #define CHAR16_ENCODING ONIG_ENCODING_UTF16_LE
34
35 /**
36 Call the Oniguruma regex match API.
37
38 Same parameters as RegularExpressionMatch, except SyntaxType is required.
39
40 @param String A pointer to a NULL terminated string to match against the
41 regular expression string specified by Pattern.
42
43 @param Pattern A pointer to a NULL terminated string that represents the
44 regular expression.
45 @param SyntaxType A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
46 regular expression syntax type to use. May be NULL in which
47 case the function will use its default regular expression
48 syntax type.
49
50 @param Result On return, points to TRUE if String fully matches against
51 the regular expression Pattern using the regular expression
52 SyntaxType. Otherwise, points to FALSE.
53
54 @param Captures A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
55 the captured groups in the event of a match. The full
56 sub-string match is put in Captures[0], and the results of N
57 capturing groups are put in Captures[1:N]. If Captures is
58 NULL, then this function doesn't allocate the memory for the
59 array and does not build up the elements. It only returns the
60 number of matching patterns in CapturesCount. If Captures is
61 not NULL, this function returns a pointer to an array and
62 builds up the elements in the array. CapturesCount is also
63 updated to the number of matching patterns found. It is the
64 caller's responsibility to free the memory pool in Captures
65 and in each CapturePtr in the array elements.
66
67 @param CapturesCount On output, CapturesCount is the number of matching patterns
68 found in String. Zero means no matching patterns were found
69 in the string.
70
71 @retval EFI_SUCCESS Regex compilation and match completed successfully.
72 @retval EFI_DEVICE_ERROR Regex compilation failed.
73
74 **/
75 STATIC
76 EFI_STATUS
77 OnigurumaMatch (
78 IN CHAR16 *String,
79 IN CHAR16 *Pattern,
80 IN EFI_REGEX_SYNTAX_TYPE *SyntaxType,
81 OUT BOOLEAN *Result,
82 OUT EFI_REGEX_CAPTURE **Captures, OPTIONAL
83 OUT UINTN *CapturesCount
84 )
85 {
86 regex_t *OnigRegex;
87 OnigSyntaxType *OnigSyntax;
88 OnigRegion *Region;
89 INT32 OnigResult;
90 OnigErrorInfo ErrorInfo;
91 OnigUChar ErrorMessage[ONIG_MAX_ERROR_MESSAGE_LEN];
92 UINT32 Index;
93 OnigUChar *Start;
94 EFI_STATUS Status;
95
96
97 Status = EFI_SUCCESS;
98
99 //
100 // Detemine the internal syntax type
101 //
102 OnigSyntax = ONIG_SYNTAX_DEFAULT;
103 if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePosixExtendedGuid)) {
104 OnigSyntax = ONIG_SYNTAX_POSIX_EXTENDED;
105 } else if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePerlGuid)) {
106 OnigSyntax = ONIG_SYNTAX_PERL;
107 } else {
108 DEBUG ((DEBUG_ERROR, "Unsupported regex syntax - using default\n"));
109 return EFI_UNSUPPORTED;
110 }
111
112 //
113 // Compile pattern
114 //
115 Start = (OnigUChar*)Pattern;
116 OnigResult = onig_new (
117 &OnigRegex,
118 Start,
119 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
120 ONIG_OPTION_DEFAULT,
121 CHAR16_ENCODING,
122 OnigSyntax,
123 &ErrorInfo
124 );
125
126 if (OnigResult != ONIG_NORMAL) {
127 onig_error_code_to_str (ErrorMessage, OnigResult, &ErrorInfo);
128 DEBUG ((DEBUG_ERROR, "Regex compilation failed: %a\n", ErrorMessage));
129 return EFI_DEVICE_ERROR;
130 }
131
132 //
133 // Try to match
134 //
135 Start = (OnigUChar*)String;
136 Region = onig_region_new ();
137 if (Region == NULL) {
138 onig_free (OnigRegex);
139 return EFI_OUT_OF_RESOURCES;
140 }
141 OnigResult = onig_search (
142 OnigRegex,
143 Start,
144 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
145 Start,
146 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
147 Region,
148 ONIG_OPTION_NONE
149 );
150
151 if (OnigResult >= 0) {
152 *Result = TRUE;
153 } else {
154 *Result = FALSE;
155 if (OnigResult != ONIG_MISMATCH) {
156 onig_error_code_to_str (ErrorMessage, OnigResult);
157 DEBUG ((DEBUG_ERROR, "Regex match failed: %a\n", ErrorMessage));
158 onig_region_free (Region, 1);
159 onig_free (OnigRegex);
160 return EFI_DEVICE_ERROR;
161 }
162 }
163
164 //
165 // If successful, copy out the region (capture) information
166 //
167 if (*Result && Captures != NULL) {
168 *CapturesCount = Region->num_regs;
169 *Captures = AllocateZeroPool (*CapturesCount * sizeof(**Captures));
170 if (*Captures != NULL) {
171 for (Index = 0; Index < *CapturesCount; ++Index) {
172 //
173 // Region beg/end values represent bytes, not characters
174 //
175 (*Captures)[Index].Length = (Region->end[Index] - Region->beg[Index]) / sizeof(CHAR16);
176 (*Captures)[Index].CapturePtr = AllocateCopyPool (
177 ((*Captures)[Index].Length) * sizeof (CHAR16),
178 (CHAR16*)((UINTN)String + Region->beg[Index])
179 );
180 if ((*Captures)[Index].CapturePtr == NULL) {
181 Status = EFI_OUT_OF_RESOURCES;
182 break;
183 }
184 }
185
186 if (EFI_ERROR (Status)) {
187 for (Index = 0; Index < *CapturesCount; ++Index) {
188 if ((*Captures)[Index].CapturePtr != NULL) {
189 FreePool ((CHAR16*)(*Captures)[Index].CapturePtr);
190 }
191 }
192 FreePool (*Captures);
193 }
194 }
195 }
196
197 onig_region_free (Region, 1);
198 onig_free (OnigRegex);
199
200 return Status;
201 }
202
203 /**
204 Returns information about the regular expression syntax types supported
205 by the implementation.
206
207 @param This A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL
208 instance.
209
210 @param RegExSyntaxTypeListSize On input, the size in bytes of RegExSyntaxTypeList.
211 On output with a return code of EFI_SUCCESS, the
212 size in bytes of the data returned in
213 RegExSyntaxTypeList. On output with a return code
214 of EFI_BUFFER_TOO_SMALL, the size of
215 RegExSyntaxTypeList required to obtain the list.
216
217 @param RegExSyntaxTypeList A caller-allocated memory buffer filled by the
218 driver with one EFI_REGEX_SYNTAX_TYPE element
219 for each supported Regular expression syntax
220 type. The list must not change across multiple
221 calls to the same driver. The first syntax
222 type in the list is the default type for the
223 driver.
224
225 @retval EFI_SUCCESS The regular expression syntax types list
226 was returned successfully.
227 @retval EFI_UNSUPPORTED The service is not supported by this driver.
228 @retval EFI_DEVICE_ERROR The list of syntax types could not be
229 retrieved due to a hardware or firmware error.
230 @retval EFI_BUFFER_TOO_SMALL The buffer RegExSyntaxTypeList is too small
231 to hold the result.
232 @retval EFI_INVALID_PARAMETER RegExSyntaxTypeListSize is NULL
233
234 **/
235 EFI_STATUS
236 EFIAPI
237 RegularExpressionGetInfo (
238 IN EFI_REGULAR_EXPRESSION_PROTOCOL *This,
239 IN OUT UINTN *RegExSyntaxTypeListSize,
240 OUT EFI_REGEX_SYNTAX_TYPE *RegExSyntaxTypeList
241 )
242 {
243 UINTN SyntaxSize;
244 UINTN Index;
245
246 if (This == NULL || RegExSyntaxTypeListSize == NULL) {
247 return EFI_INVALID_PARAMETER;
248 }
249
250 if (*RegExSyntaxTypeListSize != 0 && RegExSyntaxTypeList == NULL) {
251 return EFI_INVALID_PARAMETER;
252 }
253
254 SyntaxSize = ARRAY_SIZE (mSupportedSyntaxes) * sizeof(**mSupportedSyntaxes);
255
256 if (*RegExSyntaxTypeListSize < SyntaxSize) {
257 *RegExSyntaxTypeListSize = SyntaxSize;
258 return EFI_BUFFER_TOO_SMALL;
259 }
260
261 for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
262 CopyMem (&RegExSyntaxTypeList[Index], mSupportedSyntaxes[Index], sizeof(**mSupportedSyntaxes));
263 }
264 *RegExSyntaxTypeListSize = SyntaxSize;
265
266 return EFI_SUCCESS;
267 }
268
269 /**
270 Checks if the input string matches to the regular expression pattern.
271
272 @param This A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL instance.
273 Type EFI_REGULAR_EXPRESSION_PROTOCOL is defined in Section
274 XYZ.
275
276 @param String A pointer to a NULL terminated string to match against the
277 regular expression string specified by Pattern.
278
279 @param Pattern A pointer to a NULL terminated string that represents the
280 regular expression.
281
282 @param SyntaxType A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
283 regular expression syntax type to use. May be NULL in which
284 case the function will use its default regular expression
285 syntax type.
286
287 @param Result On return, points to TRUE if String fully matches against
288 the regular expression Pattern using the regular expression
289 SyntaxType. Otherwise, points to FALSE.
290
291 @param Captures A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
292 the captured groups in the event of a match. The full
293 sub-string match is put in Captures[0], and the results of N
294 capturing groups are put in Captures[1:N]. If Captures is
295 NULL, then this function doesn't allocate the memory for the
296 array and does not build up the elements. It only returns the
297 number of matching patterns in CapturesCount. If Captures is
298 not NULL, this function returns a pointer to an array and
299 builds up the elements in the array. CapturesCount is also
300 updated to the number of matching patterns found. It is the
301 caller's responsibility to free the memory pool in Captures
302 and in each CapturePtr in the array elements.
303
304 @param CapturesCount On output, CapturesCount is the number of matching patterns
305 found in String. Zero means no matching patterns were found
306 in the string.
307
308 @retval EFI_SUCCESS The regular expression string matching
309 completed successfully.
310 @retval EFI_UNSUPPORTED The regular expression syntax specified by
311 SyntaxType is not supported by this driver.
312 @retval EFI_DEVICE_ERROR The regular expression string matching
313 failed due to a hardware or firmware error.
314 @retval EFI_INVALID_PARAMETER String, Pattern, Result, or CapturesCountis
315 NULL.
316
317 **/
318 EFI_STATUS
319 EFIAPI
320 RegularExpressionMatch (
321 IN EFI_REGULAR_EXPRESSION_PROTOCOL *This,
322 IN CHAR16 *String,
323 IN CHAR16 *Pattern,
324 IN EFI_REGEX_SYNTAX_TYPE *SyntaxType, OPTIONAL
325 OUT BOOLEAN *Result,
326 OUT EFI_REGEX_CAPTURE **Captures, OPTIONAL
327 OUT UINTN *CapturesCount
328 )
329 {
330 EFI_STATUS Status;
331 UINT32 Index;
332 BOOLEAN Supported;
333
334 if (This == NULL || String == NULL || Pattern == NULL || Result == NULL || CapturesCount == NULL) {
335 return EFI_INVALID_PARAMETER;
336 }
337
338 //
339 // Figure out which syntax to use
340 //
341 if (SyntaxType == NULL) {
342 SyntaxType = mSupportedSyntaxes[0];
343 } else {
344 Supported = FALSE;
345 for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
346 if (CompareGuid (SyntaxType, mSupportedSyntaxes[Index])) {
347 Supported = TRUE;
348 break;
349 }
350 }
351 if (!Supported) {
352 return EFI_UNSUPPORTED;
353 }
354 }
355
356 Status = OnigurumaMatch (String, Pattern, SyntaxType, Result, Captures, CapturesCount);
357
358 return Status;
359 }
360
361 /**
362 Entry point for RegularExpressionDxe.
363
364 @param ImageHandle Image handle this driver.
365 @param SystemTable Pointer to SystemTable.
366
367 @retval Status Whether this function complete successfully.
368
369 **/
370 EFI_STATUS
371 EFIAPI
372 RegularExpressionDxeEntry (
373 IN EFI_HANDLE ImageHandle,
374 IN EFI_SYSTEM_TABLE *SystemTable
375 )
376 {
377 EFI_STATUS Status;
378
379 Status = gBS->InstallMultipleProtocolInterfaces (
380 &ImageHandle,
381 &gEfiRegularExpressionProtocolGuid,
382 &mProtocolInstance,
383 NULL
384 );
385
386 return Status;
387 }