String.c

Go to the documentation of this file.

 
#include "BaseLibInternals.h"
 
UINTN
EFIAPI
StrLen (
  IN      CONST CHAR16  *String
  )
{
  UINTN  Length;
 
  ASSERT (String != NULL);
  ASSERT (((UINTN)String & BIT0) == 0);
 
  for (Length = 0; *String != L'\0'; String++, Length++) {
    //
    // If PcdMaximumUnicodeStringLength is not zero,
    // length should not more than PcdMaximumUnicodeStringLength
    //
    if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
      ASSERT (Length < PcdGet32 (PcdMaximumUnicodeStringLength));
    }
  }
 
  return Length;
}
 
UINTN
EFIAPI
StrSize (
  IN      CONST CHAR16  *String
  )
{
  return (StrLen (String) + 1) * sizeof (*String);
}
 
INTN
EFIAPI
StrCmp (
  IN      CONST CHAR16  *FirstString,
  IN      CONST CHAR16  *SecondString
  )
{
  //
  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength
  //
  ASSERT (StrSize (FirstString) != 0);
  ASSERT (StrSize (SecondString) != 0);
 
  while ((*FirstString != L'\0') && (*FirstString == *SecondString)) {
    FirstString++;
    SecondString++;
  }
 
  return *FirstString - *SecondString;
}
 
INTN
EFIAPI
StrnCmp (
  IN      CONST CHAR16  *FirstString,
  IN      CONST CHAR16  *SecondString,
  IN      UINTN         Length
  )
{
  if (Length == 0) {
    return 0;
  }
 
  //
  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.
  // Length tests are performed inside StrLen().
  //
  ASSERT (StrSize (FirstString) != 0);
  ASSERT (StrSize (SecondString) != 0);
 
  if (PcdGet32 (PcdMaximumUnicodeStringLength) != 0) {
    ASSERT (Length <= PcdGet32 (PcdMaximumUnicodeStringLength));
  }
 
  while ((*FirstString != L'\0') &&
         (*SecondString != L'\0') &&
         (*FirstString == *SecondString) &&
         (Length > 1))
  {
    FirstString++;
    SecondString++;
    Length--;
  }
 
  return *FirstString - *SecondString;
}
 
CHAR16 *
EFIAPI
StrStr (
  IN      CONST CHAR16  *String,
  IN      CONST CHAR16  *SearchString
  )
{
  CONST CHAR16  *FirstMatch;
  CONST CHAR16  *SearchStringTmp;
 
  //
  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.
  // Length tests are performed inside StrLen().
  //
  ASSERT (StrSize (String) != 0);
  ASSERT (StrSize (SearchString) != 0);
 
  if (*SearchString == L'\0') {
    return (CHAR16 *)String;
  }
 
  while (*String != L'\0') {
    SearchStringTmp = SearchString;
    FirstMatch      = String;
 
    while (  (*String == *SearchStringTmp)
          && (*String != L'\0'))
    {
      String++;
      SearchStringTmp++;
    }
 
    if (*SearchStringTmp == L'\0') {
      return (CHAR16 *)FirstMatch;
    }
 
    if (*String == L'\0') {
      return NULL;
    }
 
    String = FirstMatch + 1;
  }
 
  return NULL;
}
 
BOOLEAN
EFIAPI
InternalIsDecimalDigitCharacter (
  IN      CHAR16  Char
  )
{
  return (BOOLEAN)(Char >= L'0' && Char <= L'9');
}
 
CHAR16
EFIAPI
CharToUpper (
  IN      CHAR16  Char
  )
{
  if ((Char >= L'a') && (Char <= L'z')) {
    return (CHAR16)(Char - (L'a' - L'A'));
  }
 
  return Char;
}
 
UINTN
EFIAPI
InternalHexCharToUintn (
  IN      CHAR16  Char
  )
{
  if (InternalIsDecimalDigitCharacter (Char)) {
    return Char - L'0';
  }
 
  return (10 + CharToUpper (Char) - L'A');
}
 
BOOLEAN
EFIAPI
InternalIsHexaDecimalDigitCharacter (
  IN      CHAR16  Char
  )
{
  return (BOOLEAN)(InternalIsDecimalDigitCharacter (Char) ||
                   (Char >= L'A' && Char <= L'F') ||
                   (Char >= L'a' && Char <= L'f'));
}
 
UINTN
EFIAPI
StrDecimalToUintn (
  IN      CONST CHAR16  *String
  )
{
  UINTN  Result;
 
  if (RETURN_ERROR (StrDecimalToUintnS (String, (CHAR16 **)NULL, &Result))) {
    return MAX_UINTN;
  }
 
  return Result;
}
 
UINT64
EFIAPI
StrDecimalToUint64 (
  IN      CONST CHAR16  *String
  )
{
  UINT64  Result;
 
  if (RETURN_ERROR (StrDecimalToUint64S (String, (CHAR16 **)NULL, &Result))) {
    return MAX_UINT64;
  }
 
  return Result;
}
 
UINTN
EFIAPI
StrHexToUintn (
  IN      CONST CHAR16  *String
  )
{
  UINTN  Result;
 
  if (RETURN_ERROR (StrHexToUintnS (String, (CHAR16 **)NULL, &Result))) {
    return MAX_UINTN;
  }
 
  return Result;
}
 
UINT64
EFIAPI
StrHexToUint64 (
  IN      CONST CHAR16  *String
  )
{
  UINT64  Result;
 
  if (RETURN_ERROR (StrHexToUint64S (String, (CHAR16 **)NULL, &Result))) {
    return MAX_UINT64;
  }
 
  return Result;
}
 
BOOLEAN
EFIAPI
InternalAsciiIsDecimalDigitCharacter (
  IN      CHAR8  Char
  )
{
  return (BOOLEAN)(Char >= '0' && Char <= '9');
}
 
BOOLEAN
EFIAPI
InternalAsciiIsHexaDecimalDigitCharacter (
  IN      CHAR8  Char
  )
{
  return (BOOLEAN)(InternalAsciiIsDecimalDigitCharacter (Char) ||
                   (Char >= 'A' && Char <= 'F') ||
                   (Char >= 'a' && Char <= 'f'));
}
 
UINTN
EFIAPI
AsciiStrLen (
  IN      CONST CHAR8  *String
  )
{
  UINTN  Length;
 
  ASSERT (String != NULL);
 
  for (Length = 0; *String != '\0'; String++, Length++) {
    //
    // If PcdMaximumUnicodeStringLength is not zero,
    // length should not more than PcdMaximumUnicodeStringLength
    //
    if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
      ASSERT (Length < PcdGet32 (PcdMaximumAsciiStringLength));
    }
  }
 
  return Length;
}
 
UINTN
EFIAPI
AsciiStrSize (
  IN      CONST CHAR8  *String
  )
{
  return (AsciiStrLen (String) + 1) * sizeof (*String);
}
 
INTN
EFIAPI
AsciiStrCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString
  )
{
  //
  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
  //
  ASSERT (AsciiStrSize (FirstString));
  ASSERT (AsciiStrSize (SecondString));
 
  while ((*FirstString != '\0') && (*FirstString == *SecondString)) {
    FirstString++;
    SecondString++;
  }
 
  return *FirstString - *SecondString;
}
 
CHAR8
EFIAPI
AsciiCharToUpper (
  IN      CHAR8  Chr
  )
{
  return (UINT8)((Chr >= 'a' && Chr <= 'z') ? Chr - ('a' - 'A') : Chr);
}
 
UINTN
EFIAPI
InternalAsciiHexCharToUintn (
  IN      CHAR8  Char
  )
{
  if (InternalIsDecimalDigitCharacter (Char)) {
    return Char - '0';
  }
 
  return (10 + AsciiCharToUpper (Char) - 'A');
}
 
INTN
EFIAPI
AsciiStriCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString
  )
{
  CHAR8  UpperFirstString;
  CHAR8  UpperSecondString;
 
  //
  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
  //
  ASSERT (AsciiStrSize (FirstString));
  ASSERT (AsciiStrSize (SecondString));
 
  UpperFirstString  = AsciiCharToUpper (*FirstString);
  UpperSecondString = AsciiCharToUpper (*SecondString);
  while ((*FirstString != '\0') && (*SecondString != '\0') && (UpperFirstString == UpperSecondString)) {
    FirstString++;
    SecondString++;
    UpperFirstString  = AsciiCharToUpper (*FirstString);
    UpperSecondString = AsciiCharToUpper (*SecondString);
  }
 
  return UpperFirstString - UpperSecondString;
}
 
INTN
EFIAPI
AsciiStrnCmp (
  IN      CONST CHAR8  *FirstString,
  IN      CONST CHAR8  *SecondString,
  IN      UINTN        Length
  )
{
  if (Length == 0) {
    return 0;
  }
 
  //
  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
  //
  ASSERT (AsciiStrSize (FirstString));
  ASSERT (AsciiStrSize (SecondString));
 
  if (PcdGet32 (PcdMaximumAsciiStringLength) != 0) {
    ASSERT (Length <= PcdGet32 (PcdMaximumAsciiStringLength));
  }
 
  while ((*FirstString != '\0') &&
         (*SecondString != '\0') &&
         (*FirstString == *SecondString) &&
         (Length > 1))
  {
    FirstString++;
    SecondString++;
    Length--;
  }
 
  return *FirstString - *SecondString;
}
 
CHAR8 *
EFIAPI
AsciiStrStr (
  IN      CONST CHAR8  *String,
  IN      CONST CHAR8  *SearchString
  )
{
  CONST CHAR8  *FirstMatch;
  CONST CHAR8  *SearchStringTmp;
 
  //
  // ASSERT both strings are less long than PcdMaximumAsciiStringLength
  //
  ASSERT (AsciiStrSize (String) != 0);
  ASSERT (AsciiStrSize (SearchString) != 0);
 
  if (*SearchString == '\0') {
    return (CHAR8 *)String;
  }
 
  while (*String != '\0') {
    SearchStringTmp = SearchString;
    FirstMatch      = String;
 
    while (  (*String == *SearchStringTmp)
          && (*String != '\0'))
    {
      String++;
      SearchStringTmp++;
    }
 
    if (*SearchStringTmp == '\0') {
      return (CHAR8 *)FirstMatch;
    }
 
    if (*String == '\0') {
      return NULL;
    }
 
    String = FirstMatch + 1;
  }
 
  return NULL;
}
 
UINTN
EFIAPI
AsciiStrDecimalToUintn (
  IN      CONST CHAR8  *String
  )
{
  UINTN  Result;
 
  if (RETURN_ERROR (AsciiStrDecimalToUintnS (String, (CHAR8 **)NULL, &Result))) {
    return MAX_UINTN;
  }
 
  return Result;
}
 
UINT64
EFIAPI
AsciiStrDecimalToUint64 (
  IN      CONST CHAR8  *String
  )
{
  UINT64  Result;
 
  if (RETURN_ERROR (AsciiStrDecimalToUint64S (String, (CHAR8 **)NULL, &Result))) {
    return MAX_UINT64;
  }
 
  return Result;
}
 
UINTN
EFIAPI
AsciiStrHexToUintn (
  IN      CONST CHAR8  *String
  )
{
  UINTN  Result;
 
  if (RETURN_ERROR (AsciiStrHexToUintnS (String, (CHAR8 **)NULL, &Result))) {
    return MAX_UINTN;
  }
 
  return Result;
}
 
UINT64
EFIAPI
AsciiStrHexToUint64 (
  IN      CONST CHAR8  *String
  )
{
  UINT64  Result;
 
  if (RETURN_ERROR (AsciiStrHexToUint64S (String, (CHAR8 **)NULL, &Result))) {
    return MAX_UINT64;
  }
 
  return Result;
}
 
STATIC CHAR8  EncodingTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                "abcdefghijklmnopqrstuvwxyz"
                                "0123456789+/";
 
RETURN_STATUS
EFIAPI
Base64Encode (
  IN  CONST UINT8  *Source,
  IN        UINTN  SourceLength,
  OUT       CHAR8  *Destination   OPTIONAL,
  IN OUT    UINTN  *DestinationSize
  )
{
  UINTN  RequiredSize;
  UINTN  Left;
 
  //
  // Check pointers, and SourceLength is valid
  //
  if ((Source == NULL) || (DestinationSize == NULL)) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Allow for RFC 4648 test vector 1
  //
  if (SourceLength == 0) {
    if (*DestinationSize < 1) {
      *DestinationSize = 1;
      return RETURN_BUFFER_TOO_SMALL;
    }
 
    *DestinationSize = 1;
    *Destination     = '\0';
    return RETURN_SUCCESS;
  }
 
  //
  // Check if SourceLength or  DestinationSize is valid
  //
  if ((SourceLength >= (MAX_ADDRESS - (UINTN)Source)) || (*DestinationSize >= (MAX_ADDRESS - (UINTN)Destination))) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // 4 ascii per 3 bytes + NULL
  //
  RequiredSize = ((SourceLength + 2) / 3) * 4 + 1;
  if ((Destination == NULL) || (*DestinationSize < RequiredSize)) {
    *DestinationSize = RequiredSize;
    return RETURN_BUFFER_TOO_SMALL;
  }
 
  Left = SourceLength;
 
  //
  // Encode 24 bits (three bytes) into 4 ascii characters
  //
  while (Left >= 3) {
    *Destination++ = EncodingTable[(Source[0] & 0xfc) >> 2];
    *Destination++ = EncodingTable[((Source[0] & 0x03) << 4) + ((Source[1] & 0xf0) >> 4)];
    *Destination++ = EncodingTable[((Source[1] & 0x0f) << 2) + ((Source[2] & 0xc0) >> 6)];
    *Destination++ = EncodingTable[(Source[2] & 0x3f)];
    Left          -= 3;
    Source        += 3;
  }
 
  //
  // Handle the remainder, and add padding '=' characters as necessary.
  //
  switch (Left) {
    case 0:
 
      //
      // No bytes Left, done.
      //
      break;
    case 1:
 
      //
      // One more data byte, two pad characters
      //
      *Destination++ = EncodingTable[(Source[0] & 0xfc) >> 2];
      *Destination++ = EncodingTable[((Source[0] & 0x03) << 4)];
      *Destination++ = '=';
      *Destination++ = '=';
      break;
    case 2:
 
      //
      // Two more data bytes, and one pad character
      //
      *Destination++ = EncodingTable[(Source[0] & 0xfc) >> 2];
      *Destination++ = EncodingTable[((Source[0] & 0x03) << 4) + ((Source[1] & 0xf0) >> 4)];
      *Destination++ = EncodingTable[((Source[1] & 0x0f) << 2)];
      *Destination++ = '=';
      break;
  }
 
  //
  // Add terminating NULL
  //
  *Destination = '\0';
  return RETURN_SUCCESS;
}
 
RETURN_STATUS
EFIAPI
Base64Decode (
  IN     CONST CHAR8  *Source          OPTIONAL,
  IN     UINTN        SourceSize,
  OUT    UINT8        *Destination     OPTIONAL,
  IN OUT UINTN        *DestinationSize
  )
{
  BOOLEAN  PaddingMode;
  UINTN    SixBitGroupsConsumed;
  UINT32   Accumulator;
  UINTN    OriginalDestinationSize;
  UINTN    SourceIndex;
  CHAR8    SourceChar;
  UINT32   Base64Value;
  UINT8    DestinationOctet;
 
  if (DestinationSize == NULL) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Check Source array validity.
  //
  if (Source == NULL) {
    if (SourceSize > 0) {
      //
      // At least one CHAR8 element at NULL Source.
      //
      return RETURN_INVALID_PARAMETER;
    }
  } else if (SourceSize > MAX_ADDRESS - (UINTN)Source) {
    //
    // Non-NULL Source, but it wraps around.
    //
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Check Destination array validity.
  //
  if (Destination == NULL) {
    if (*DestinationSize > 0) {
      //
      // At least one UINT8 element at NULL Destination.
      //
      return RETURN_INVALID_PARAMETER;
    }
  } else if (*DestinationSize > MAX_ADDRESS - (UINTN)Destination) {
    //
    // Non-NULL Destination, but it wraps around.
    //
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Check for overlap.
  //
  if ((Source != NULL) && (Destination != NULL)) {
    //
    // Both arrays have been provided, and we know from earlier that each array
    // is valid in itself.
    //
    if ((UINTN)Source + SourceSize <= (UINTN)Destination) {
      //
      // Source array precedes Destination array, OK.
      //
    } else if ((UINTN)Destination + *DestinationSize <= (UINTN)Source) {
      //
      // Destination array precedes Source array, OK.
      //
    } else {
      //
      // Overlap.
      //
      return RETURN_INVALID_PARAMETER;
    }
  }
 
  //
  // Decoding loop setup.
  //
  PaddingMode             = FALSE;
  SixBitGroupsConsumed    = 0;
  Accumulator             = 0;
  OriginalDestinationSize = *DestinationSize;
  *DestinationSize        = 0;
 
  //
  // Decoding loop.
  //
  for (SourceIndex = 0; SourceIndex < SourceSize; SourceIndex++) {
    SourceChar = Source[SourceIndex];
 
    //
    // Whitespace is ignored at all positions (regardless of padding mode).
    //
    if ((SourceChar == '\t') || (SourceChar == '\n') || (SourceChar == '\v') ||
        (SourceChar == '\f') || (SourceChar == '\r') || (SourceChar == ' '))
    {
      continue;
    }
 
    //
    // If we're in padding mode, accept another padding character, as long as
    // that padding character completes the quantum. This completes case (2)
    // from RFC4648, Chapter 4. "Base 64 Encoding":
    //
    // (2) The final quantum of encoding input is exactly 8 bits; here, the
    //     final unit of encoded output will be two characters followed by two
    //     "=" padding characters.
    //
    if (PaddingMode) {
      if ((SourceChar == '=') && (SixBitGroupsConsumed == 3)) {
        SixBitGroupsConsumed = 0;
        continue;
      }
 
      return RETURN_INVALID_PARAMETER;
    }
 
    //
    // When not in padding mode, decode Base64Value based on RFC4648, "Table 1:
    // The Base 64 Alphabet".
    //
    if (('A' <= SourceChar) && (SourceChar <= 'Z')) {
      Base64Value = SourceChar - 'A';
    } else if (('a' <= SourceChar) && (SourceChar <= 'z')) {
      Base64Value = 26 + (SourceChar - 'a');
    } else if (('0' <= SourceChar) && (SourceChar <= '9')) {
      Base64Value = 52 + (SourceChar - '0');
    } else if (SourceChar == '+') {
      Base64Value = 62;
    } else if (SourceChar == '/') {
      Base64Value = 63;
    } else if (SourceChar == '=') {
      //
      // Enter padding mode.
      //
      PaddingMode = TRUE;
 
      if (SixBitGroupsConsumed == 2) {
        //
        // If we have consumed two 6-bit groups from the current quantum before
        // encountering the first padding character, then this is case (2) from
        // RFC4648, Chapter 4. "Base 64 Encoding". Bump SixBitGroupsConsumed,
        // and we'll enforce another padding character.
        //
        SixBitGroupsConsumed = 3;
      } else if (SixBitGroupsConsumed == 3) {
        //
        // If we have consumed three 6-bit groups from the current quantum
        // before encountering the first padding character, then this is case
        // (3) from RFC4648, Chapter 4. "Base 64 Encoding". The quantum is now
        // complete.
        //
        SixBitGroupsConsumed = 0;
      } else {
        //
        // Padding characters are not allowed at the first two positions of a
        // quantum.
        //
        return RETURN_INVALID_PARAMETER;
      }
 
      //
      // Wherever in a quantum we enter padding mode, we enforce the padding
      // bits pending in the accumulator -- from the last 6-bit group just
      // preceding the padding character -- to be zero. Refer to RFC4648,
      // Chapter 3.5. "Canonical Encoding".
      //
      if (Accumulator != 0) {
        return RETURN_INVALID_PARAMETER;
      }
 
      //
      // Advance to the next source character.
      //
      continue;
    } else {
      //
      // Other characters outside of the encoding alphabet are rejected.
      //
      return RETURN_INVALID_PARAMETER;
    }
 
    //
    // Feed the bits of the current 6-bit group of the quantum to the
    // accumulator.
    //
    Accumulator = (Accumulator << 6) | Base64Value;
    SixBitGroupsConsumed++;
    switch (SixBitGroupsConsumed) {
      case 1:
        //
        // No octet to spill after consuming the first 6-bit group of the
        // quantum; advance to the next source character.
        //
        continue;
      case 2:
        //
        // 12 bits accumulated (6 pending + 6 new); prepare for spilling an
        // octet. 4 bits remain pending.
        //
        DestinationOctet = (UINT8)(Accumulator >> 4);
        Accumulator     &= 0xF;
        break;
      case 3:
        //
        // 10 bits accumulated (4 pending + 6 new); prepare for spilling an
        // octet. 2 bits remain pending.
        //
        DestinationOctet = (UINT8)(Accumulator >> 2);
        Accumulator     &= 0x3;
        break;
      default:
        ASSERT (SixBitGroupsConsumed == 4);
        //
        // 8 bits accumulated (2 pending + 6 new); prepare for spilling an octet.
        // The quantum is complete, 0 bits remain pending.
        //
        DestinationOctet     = (UINT8)Accumulator;
        Accumulator          = 0;
        SixBitGroupsConsumed = 0;
        break;
    }
 
    //
    // Store the decoded octet if there's room left. Increment
    // (*DestinationSize) unconditionally.
    //
    if (*DestinationSize < OriginalDestinationSize) {
      ASSERT (Destination != NULL);
      Destination[*DestinationSize] = DestinationOctet;
    }
 
    (*DestinationSize)++;
 
    //
    // Advance to the next source character.
    //
  }
 
  //
  // If Source terminates mid-quantum, then Source is invalid.
  //
  if (SixBitGroupsConsumed != 0) {
    return RETURN_INVALID_PARAMETER;
  }
 
  //
  // Done.
  //
  if (*DestinationSize <= OriginalDestinationSize) {
    return RETURN_SUCCESS;
  }
 
  return RETURN_BUFFER_TOO_SMALL;
}
 
UINT8
EFIAPI
DecimalToBcd8 (
  IN      UINT8  Value
  )
{
  ASSERT (Value < 100);
  return (UINT8)(((Value / 10) << 4) | (Value % 10));
}
 
UINT8
EFIAPI
BcdToDecimal8 (
  IN      UINT8  Value
  )
{
  ASSERT (Value < 0xa0);
  ASSERT ((Value & 0xf) < 0xa);
  return (UINT8)((Value >> 4) * 10 + (Value & 0xf));
}