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 }