RegularExpressionDxe.c

Go to the documentation of this file.

 
#include "RegularExpressionDxe.h"
 
STATIC
EFI_REGEX_SYNTAX_TYPE *CONST  mSupportedSyntaxes[] = {
  &gEfiRegexSyntaxTypePosixExtendedGuid,
  &gEfiRegexSyntaxTypePerlGuid
};
 
STATIC
EFI_REGULAR_EXPRESSION_PROTOCOL  mProtocolInstance = {
  RegularExpressionMatch,
  RegularExpressionGetInfo
};
 
#define CHAR16_ENCODING  ONIG_ENCODING_UTF16_LE
 
STATIC
EFI_STATUS
OnigurumaMatch (
  IN  CHAR16                 *String,
  IN  CHAR16                 *Pattern,
  IN  EFI_REGEX_SYNTAX_TYPE  *SyntaxType,
  OUT BOOLEAN                *Result,
  OUT EFI_REGEX_CAPTURE      **Captures      OPTIONAL,
  OUT UINTN                  *CapturesCount
  )
{
  regex_t         *OnigRegex;
  OnigSyntaxType  *OnigSyntax;
  OnigRegion      *Region;
  INT32           OnigResult;
  OnigErrorInfo   ErrorInfo;
  OnigUChar       ErrorMessage[ONIG_MAX_ERROR_MESSAGE_LEN];
  UINT32          Index;
  OnigUChar       *Start;
  EFI_STATUS      Status;
 
  Status = EFI_SUCCESS;
 
  //
  // Detemine the internal syntax type
  //
  OnigSyntax = ONIG_SYNTAX_DEFAULT;
  if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePosixExtendedGuid)) {
    OnigSyntax = ONIG_SYNTAX_POSIX_EXTENDED;
  } else if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePerlGuid)) {
    OnigSyntax = ONIG_SYNTAX_PERL;
  } else {
    DEBUG ((DEBUG_ERROR, "Unsupported regex syntax - using default\n"));
    return EFI_UNSUPPORTED;
  }
 
  //
  // Compile pattern
  //
  Start      = (OnigUChar *)Pattern;
  OnigResult = onig_new (
                 &OnigRegex,
                 Start,
                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
                 ONIG_OPTION_DEFAULT,
                 CHAR16_ENCODING,
                 OnigSyntax,
                 &ErrorInfo
                 );
 
  if (OnigResult != ONIG_NORMAL) {
    onig_error_code_to_str (ErrorMessage, OnigResult, &ErrorInfo);
    DEBUG ((DEBUG_ERROR, "Regex compilation failed: %a\n", ErrorMessage));
    return EFI_DEVICE_ERROR;
  }
 
  //
  // Try to match
  //
  Start  = (OnigUChar *)String;
  Region = onig_region_new ();
  if (Region == NULL) {
    onig_free (OnigRegex);
    return EFI_OUT_OF_RESOURCES;
  }
 
  OnigResult = onig_search (
                 OnigRegex,
                 Start,
                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
                 Start,
                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
                 Region,
                 ONIG_OPTION_NONE
                 );
 
  if (OnigResult >= 0) {
    *Result = TRUE;
  } else {
    *Result = FALSE;
    if (OnigResult != ONIG_MISMATCH) {
      onig_error_code_to_str (ErrorMessage, OnigResult);
      DEBUG ((DEBUG_ERROR, "Regex match failed: %a\n", ErrorMessage));
      onig_region_free (Region, 1);
      onig_free (OnigRegex);
      return EFI_DEVICE_ERROR;
    }
  }
 
  //
  // If successful, copy out the region (capture) information
  //
  if (*Result && (Captures != NULL)) {
    *CapturesCount = Region->num_regs;
    *Captures      = AllocateZeroPool (*CapturesCount * sizeof (**Captures));
    if (*Captures != NULL) {
      for (Index = 0; Index < *CapturesCount; ++Index) {
        //
        // Region beg/end values represent bytes, not characters
        //
        (*Captures)[Index].Length     = (Region->end[Index] - Region->beg[Index]) / sizeof (CHAR16);
        (*Captures)[Index].CapturePtr = AllocateCopyPool (
                                          ((*Captures)[Index].Length) * sizeof (CHAR16),
                                          (CHAR16 *)((UINTN)String + Region->beg[Index])
                                          );
        if ((*Captures)[Index].CapturePtr == NULL) {
          Status = EFI_OUT_OF_RESOURCES;
          break;
        }
      }
 
      if (EFI_ERROR (Status)) {
        for (Index = 0; Index < *CapturesCount; ++Index) {
          if ((*Captures)[Index].CapturePtr != NULL) {
            FreePool ((CHAR16 *)(*Captures)[Index].CapturePtr);
          }
        }
 
        FreePool (*Captures);
      }
    }
  }
 
  onig_region_free (Region, 1);
  onig_free (OnigRegex);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RegularExpressionGetInfo (
  IN     EFI_REGULAR_EXPRESSION_PROTOCOL  *This,
  IN OUT UINTN                            *RegExSyntaxTypeListSize,
  OUT    EFI_REGEX_SYNTAX_TYPE            *RegExSyntaxTypeList
  )
{
  UINTN  SyntaxSize;
  UINTN  Index;
 
  if ((This == NULL) || (RegExSyntaxTypeListSize == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((*RegExSyntaxTypeListSize != 0) && (RegExSyntaxTypeList == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  SyntaxSize = ARRAY_SIZE (mSupportedSyntaxes) * sizeof (**mSupportedSyntaxes);
 
  if (*RegExSyntaxTypeListSize < SyntaxSize) {
    *RegExSyntaxTypeListSize = SyntaxSize;
    return EFI_BUFFER_TOO_SMALL;
  }
 
  for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
    CopyMem (&RegExSyntaxTypeList[Index], mSupportedSyntaxes[Index], sizeof (**mSupportedSyntaxes));
  }
 
  *RegExSyntaxTypeListSize = SyntaxSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
RegularExpressionMatch (
  IN  EFI_REGULAR_EXPRESSION_PROTOCOL  *This,
  IN  CHAR16                           *String,
  IN  CHAR16                           *Pattern,
  IN  EFI_REGEX_SYNTAX_TYPE            *SyntaxType  OPTIONAL,
  OUT BOOLEAN                          *Result,
  OUT EFI_REGEX_CAPTURE                **Captures  OPTIONAL,
  OUT UINTN                            *CapturesCount
  )
{
  EFI_STATUS  Status;
  UINT32      Index;
  BOOLEAN     Supported;
 
  if ((This == NULL) || (String == NULL) || (Pattern == NULL) || (Result == NULL) || (CapturesCount == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Figure out which syntax to use
  //
  if (SyntaxType == NULL) {
    SyntaxType = mSupportedSyntaxes[0];
  } else {
    Supported = FALSE;
    for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
      if (CompareGuid (SyntaxType, mSupportedSyntaxes[Index])) {
        Supported = TRUE;
        break;
      }
    }
 
    if (!Supported) {
      return EFI_UNSUPPORTED;
    }
  }
 
  Status = OnigurumaMatch (String, Pattern, SyntaxType, Result, Captures, CapturesCount);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
RegularExpressionDxeEntry (
  IN  EFI_HANDLE        ImageHandle,
  IN  EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &ImageHandle,
                  &gEfiRegularExpressionProtocolGuid,
                  &mProtocolInstance,
                  NULL
                  );
 
  return Status;
}