RedfishCrtLib.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/RedfishCrtLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/SortLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
 
int   errno            = 0;
char  errnum_message[] = "We don't support to map errnum to the error message on edk2 Redfish\n";
 
// This is required to keep VC++ happy if you use floating-point
int  _fltused = 1;
 
int
isalnum (
  int  c
  )
{
  //
  // <alnum> ::= [0-9] | [a-z] | [A-Z]
  //
  return ((('0' <= (c)) && ((c) <= '9')) ||
          (('a' <= (c)) && ((c) <= 'z')) ||
          (('A' <= (c)) && ((c) <= 'Z')));
}
 
int
isdchar (
  int  c
  )
{
  //
  // [0-9] | [e +-.]
  //
  return ((('0' <= (c)) && ((c) <= '9')) ||
          (c == 'e') || (c == 'E') ||
          (c == '+') || (c == '-') ||
          (c == '.'));
}
 
int
isspace (
  int  c
  )
{
  //
  // <space> ::= [ ]
  //
  return ((c) == ' ') || ((c) == '\t') || ((c) == '\r') || ((c) == '\n') || ((c) == '\v')  || ((c) == '\f');
}
 
void *
malloc (
  size_t  size
  )
{
  return AllocatePool ((UINTN)size);
}
 
void
free (
  void  *ptr
  )
{
  //
  // In Standard C, free() handles a null pointer argument transparently. This
  // is not true of FreePool() below, so protect it.
  //
  if (ptr != NULL) {
    FreePool (ptr);
  }
}
 
char *
strdup (
  const char  *str
  )
{
  size_t  len;
  char    *copy;
 
  len = strlen (str) + 1;
  if ((copy = malloc (len)) == NULL) {
    return (NULL);
  }
 
  memcpy (copy, str, len);
  return (copy);
}
 
int
toupper (
  IN  int  c
  )
{
  if ((c >= 'a') && (c <= 'z')) {
    c = c - ('a' - 'A');
  }
 
  return c;
}
 
int
Digit2Val (
  int  c
  )
{
  if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))) {
    /* If c is one of [A-Za-z]... */
    c = toupper (c) - 7;   // Adjust so 'A' is ('9' + 1)
  }
 
  return c - '0';   // Value returned is between 0 and 35, inclusive.
}
 
long long
strtoll (
  const char  *nptr,
  char        **endptr,
  int         base
  )
{
  const char  *pEnd;
  long long   Result = 0;
  long long   Previous;
  int         temp;
  BOOLEAN     Negative = FALSE;
 
  pEnd = nptr;
 
  if ((base < 0) || (base == 1) || (base > 36)) {
    if (endptr != NULL) {
      *endptr = NULL;
    }
 
    return 0;
  }
 
  // Skip leading spaces.
  while (isspace (*nptr)) {
    ++nptr;
  }
 
  // Process Subject sequence: optional sign followed by digits.
  if (*nptr == '+') {
    Negative = FALSE;
    ++nptr;
  } else if (*nptr == '-') {
    Negative = TRUE;
    ++nptr;
  }
 
  if (*nptr == '0') {
    /* Might be Octal or Hex */
    if (toupper (nptr[1]) == 'X') {
      /* Looks like Hex */
      if ((base == 0) || (base == 16)) {
        nptr += 2;  /* Skip the "0X"      */
        base  = 16; /* In case base was 0 */
      }
    } else {
      /* Looks like Octal */
      if ((base == 0) || (base == 8)) {
        ++nptr;     /* Skip the leading "0" */
        base = 8;   /* In case base was 0   */
      }
    }
  }
 
  if (base == 0) {
    /* If still zero then must be decimal */
    base = 10;
  }
 
  if (*nptr  == '0') {
    for ( ; *nptr == '0'; ++nptr) {
      /* Skip any remaining leading zeros */
    }
 
    pEnd = nptr;
  }
 
  while ( isalnum (*nptr) && ((temp = Digit2Val (*nptr)) < base)) {
    Previous = Result;
    Result   = MultS64x64 (Result, base) + (long long int)temp;
    if ( Result <= Previous) {
      // Detect Overflow
      if (Negative) {
        Result = LLONG_MIN;
      } else {
        Result = LLONG_MAX;
      }
 
      Negative = FALSE;
      errno    = ERANGE;
      break;
    }
 
    pEnd = ++nptr;
  }
 
  if (Negative) {
    Result = -Result;
  }
 
  // Save pointer to final sequence
  if (endptr != NULL) {
    *endptr = (char *)pEnd;
  }
 
  return Result;
}
 
long
strtol (
  const char  *nptr,
  char        **endptr,
  int         base
  )
{
  const char  *pEnd;
  long        Result = 0;
  long        Previous;
  int         temp;
  BOOLEAN     Negative = FALSE;
 
  pEnd = nptr;
 
  if ((base < 0) || (base == 1) || (base > 36)) {
    if (endptr != NULL) {
      *endptr = NULL;
    }
 
    return 0;
  }
 
  // Skip leading spaces.
  while (isspace (*nptr)) {
    ++nptr;
  }
 
  // Process Subject sequence: optional sign followed by digits.
  if (*nptr == '+') {
    Negative = FALSE;
    ++nptr;
  } else if (*nptr == '-') {
    Negative = TRUE;
    ++nptr;
  }
 
  if (*nptr == '0') {
    /* Might be Octal or Hex */
    if (toupper (nptr[1]) == 'X') {
      /* Looks like Hex */
      if ((base == 0) || (base == 16)) {
        nptr += 2;  /* Skip the "0X"      */
        base  = 16; /* In case base was 0 */
      }
    } else {
      /* Looks like Octal */
      if ((base == 0) || (base == 8)) {
        ++nptr;     /* Skip the leading "0" */
        base = 8;   /* In case base was 0   */
      }
    }
  }
 
  if (base == 0) {
    /* If still zero then must be decimal */
    base = 10;
  }
 
  if (*nptr  == '0') {
    for ( ; *nptr == '0'; ++nptr) {
      /* Skip any remaining leading zeros */
    }
 
    pEnd = nptr;
  }
 
  while ( isalnum (*nptr) && ((temp = Digit2Val (*nptr)) < base)) {
    Previous = Result;
    Result   = (Result * base) + (long int)temp;
    if ( Result <= Previous) {
      // Detect Overflow
      if (Negative) {
        Result = LONG_MIN;
      } else {
        Result = LONG_MAX;
      }
 
      Negative = FALSE;
      errno    = ERANGE;
      break;
    }
 
    pEnd = ++nptr;
  }
 
  if (Negative) {
    Result = -Result;
  }
 
  // Save pointer to final sequence
  if (endptr != NULL) {
    *endptr = (char *)pEnd;
  }
 
  return Result;
}
 
unsigned long long
strtoull (
  const char  *nptr,
  char        **endptr,
  int         base
  )
{
  const char          *pEnd;
  unsigned long long  Result = 0;
  unsigned long long  Previous;
  int                 temp;
 
  pEnd = nptr;
 
  if ((base < 0) || (base == 1) || (base > 36)) {
    if (endptr != NULL) {
      *endptr = NULL;
    }
 
    return 0;
  }
 
  // Skip leading spaces.
  while (isspace (*nptr)) {
    ++nptr;
  }
 
  // Process Subject sequence: optional + sign followed by digits.
  if (*nptr == '+') {
    ++nptr;
  }
 
  if (*nptr == '0') {
    /* Might be Octal or Hex */
    if (toupper (nptr[1]) == 'X') {
      /* Looks like Hex */
      if ((base == 0) || (base == 16)) {
        nptr += 2;  /* Skip the "0X"      */
        base  = 16; /* In case base was 0 */
      }
    } else {
      /* Looks like Octal */
      if ((base == 0) || (base == 8)) {
        ++nptr;     /* Skip the leading "0" */
        base = 8;   /* In case base was 0   */
      }
    }
  }
 
  if (base == 0) {
    /* If still zero then must be decimal */
    base = 10;
  }
 
  if (*nptr  == '0') {
    for ( ; *nptr == '0'; ++nptr) {
      /* Skip any remaining leading zeros */
    }
 
    pEnd = nptr;
  }
 
  while ( isalnum (*nptr) && ((temp = Digit2Val (*nptr)) < base)) {
    Previous = Result;
    Result   = DivU64x32 (Result, base) + (unsigned long long)temp;
    if ( Result < Previous) {
      // If we overflowed
      Result = ULLONG_MAX;
      errno  = ERANGE;
      break;
    }
 
    pEnd = ++nptr;
  }
 
  // Save pointer to final sequence
  if (endptr != NULL) {
    *endptr = (char *)pEnd;
  }
 
  return Result;
}
 
double
strtod (
  const char *__restrict  nptr,
  char **__restrict       endptr
  )
{
  UINTN  Data;
  UINTN  StrLen;
 
  Data   = 0;
  StrLen = 0;
 
  if (nptr == NULL) {
    return (double)0;
  }
 
  AsciiStrDecimalToUintnS (nptr, NULL, &Data);
  DEBUG ((DEBUG_WARN, "%a: \"%a\" We don't support double type on edk2 yet. Only integer part is returned: %d\n", __func__, nptr, Data));
 
  //
  // Force endptr to the last position of nptr because caller may
  // check endptr and raise assertion. We don't support floating
  // number in edk2 so this prevents unecessary assertion from happening.
  //
  if (endptr != NULL) {
    StrLen  = AsciiStrLen (nptr);
    *endptr = (char *__restrict)nptr + StrLen;
  }
 
  return (double)Data;
}
 
static UINT8  BitMask[] = {
  0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
};
 
#define WHICH8(c)     ((unsigned char)(c) >> 3)
#define WHICH_BIT(c)  (BitMask[((c) & 0x7)])
#define BITMAP64  ((UINT64 *)bitmap)
 
static
void
BuildBitmap (
  unsigned char  *bitmap,
  const char     *s2,
  int            n
  )
{
  unsigned char  bit;
  int            index;
 
  // Initialize bitmap.  Bit 0 is always 1 which corresponds to '\0'
  for (BITMAP64[0] = index = 1; index < n; index++) {
    BITMAP64[index] = 0;
  }
 
  // Set bits in bitmap corresponding to the characters in s2
  for ( ; *s2 != '\0'; s2++) {
    index         = WHICH8 (*s2);
    bit           = WHICH_BIT (*s2);
    bitmap[index] = bitmap[index] | bit;
  }
}
 
char *
strpbrk (
  const char  *s1,
  const char  *s2
  )
{
  UINT8  bitmap[(((UCHAR_MAX + 1) / CHAR_BIT) + (CHAR_BIT - 1)) & ~7U];
  UINT8  bit;
  int    index;
 
  BuildBitmap (bitmap, s2, sizeof (bitmap) / sizeof (UINT64));
 
  for ( ; *s1 != '\0'; ++s1) {
    index = WHICH8 (*s1);
    bit   = WHICH_BIT (*s1);
    if ((bitmap[index] & bit) != 0) {
      return (char *)s1;
    }
  }
 
  return NULL;
}
 
char *
strerror (
  int  errnum
  )
{
  return errnum_message;
}
 
void *
calloc (
  size_t  Num,
  size_t  Size
  )
{
  void    *RetVal;
  size_t  NumSize;
 
  NumSize = Num * Size;
  RetVal  = NULL;
  if (NumSize != 0) {
    RetVal = malloc (NumSize);
    if ( RetVal != NULL) {
      (VOID)ZeroMem (RetVal, NumSize);
    }
  }
 
  DEBUG ((DEBUG_POOL, "0x%p = calloc(%d, %d)\n", RetVal, Num, Size));
 
  return RetVal;
}
 
//
//  The arrays give the cumulative number of days up to the first of the
//  month number used as the index (1 -> 12) for regular and leap years.
//  The value at index 13 is for the whole year.
//
UINTN  CumulativeDays[2][14] = {
  {
    0,
    0,
    31,
    31 + 28,
    31 + 28 + 31,
    31 + 28 + 31 + 30,
    31 + 28 + 31 + 30 + 31,
    31 + 28 + 31 + 30 + 31 + 30,
    31 + 28 + 31 + 30 + 31 + 30 + 31,
    31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
    31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
    31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
    31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
    31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31
  },
  {
    0,
    0,
    31,
    31 + 29,
    31 + 29 + 31,
    31 + 29 + 31 + 30,
    31 + 29 + 31 + 30 + 31,
    31 + 29 + 31 + 30 + 31 + 30,
    31 + 29 + 31 + 30 + 31 + 30 + 31,
    31 + 29 + 31 + 30 + 31 + 30 + 31 + 31,
    31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
    31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
    31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
    31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30 + 31
  }
};
 
#define IsLeap(y)  (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
#define SECSPERMIN   (60)
#define SECSPERHOUR  (60 * 60)
#define SECSPERDAY   (24 * SECSPERHOUR)
 
time_t
time (
  time_t  *timer
  )
{
  EFI_TIME  Time;
  time_t    CalTime;
  UINTN     Year;
 
  //
  // Get the current time and date information
  //
  gRT->GetTime (&Time, NULL);
 
  //
  // Years Handling
  // UTime should now be set to 00:00:00 on Jan 1 of the current year.
  //
  for (Year = 1970, CalTime = 0; Year != Time.Year; Year++) {
    CalTime = CalTime + (time_t)(CumulativeDays[IsLeap (Year)][13] * SECSPERDAY);
  }
 
  //
  // Add in number of seconds for current Month, Day, Hour, Minute, Seconds, and TimeZone adjustment
  //
  CalTime = CalTime +
            (time_t)((Time.TimeZone != EFI_UNSPECIFIED_TIMEZONE) ? (Time.TimeZone * 60) : 0) +
            (time_t)(CumulativeDays[IsLeap (Time.Year)][Time.Month] * SECSPERDAY) +
            (time_t)(((Time.Day > 0) ? Time.Day - 1 : 0) * SECSPERDAY) +
            (time_t)(Time.Hour * SECSPERHOUR) +
            (time_t)(Time.Minute * 60) +
            (time_t)Time.Second;
 
  if (timer != NULL) {
    *timer = CalTime;
  }
 
  return CalTime;
}
 
void
qsort (
  void *base,
  size_t num,
  size_t width,
  int ( *compare )(const void *, const void *)
  )
{
  ASSERT (base    != NULL);
  ASSERT (compare != NULL);
 
  PerformQuickSort (base, (UINTN)num, (UINTN)width, (SORT_COMPARE)compare);
  return;
}
 
int
fgetc (
  FILE  *_File
  )
{
  return EOF;
}
 
FILE *
fopen (
  const char  *filename,
  const char  *mode
  )
{
  return NULL;
}
 
size_t
fread (
  void    *ptr,
  size_t  size,
  size_t  count,
  FILE    *stream
  )
{
  return 0;
}
 
size_t
fwrite (
  const void  *ptr,
  size_t      size,
  size_t      count,
  FILE        *stream
  )
{
  return 0;
}
 
int
fclose (
  FILE  *stream
  )
{
  return EOF;
}
 
int
fprintf (
  FILE        *stream,
  const char  *format,
  ...
  )
{
  return -1;
}
 
BOOLEAN
CheckFormatingString (
  IN     CONST CHAR8  *FormatString,
  IN OUT UINTN        *CurrentPosition,
  IN     UINTN        StrLength
  )
{
  CHAR8  FormatStringParamater;
 
  while (*(FormatString + *CurrentPosition) != 's') {
    //
    // Loop until reach character 's' if the formating string is
    // compliant with "[flags][width][.precision][length]" format for
    // the string specifier.
    //
    FormatStringParamater = *(FormatString + *CurrentPosition);
    if ((FormatStringParamater != '-') &&
        (FormatStringParamater != '+') &&
        (FormatStringParamater != '*') &&
        (FormatStringParamater != '.') &&
        !(((UINTN)FormatStringParamater >= (UINTN)'0') && ((UINTN)FormatStringParamater <= (UINTN)'9'))
        )
    {
      return FALSE;
    }
 
    (*CurrentPosition)++;
    if (*CurrentPosition >= StrLength) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
CHAR8 *
ReplaceUnicodeToAsciiStrFormat (
  IN CONST CHAR8  *FormatString
  )
{
  UINTN    FormatStrSize;
  UINTN    FormatStrIndex;
  UINTN    FormatStrSpecifier;
  BOOLEAN  PercentageMark;
  CHAR8    *TempFormatBuffer;
  BOOLEAN  IsFormatString;
 
  //
  // Error checking.
  //
  if (FormatString == NULL) {
    return NULL;
  }
 
  FormatStrSize = AsciiStrSize (FormatString);
  if (FormatStrSize == 0) {
    return NULL;
  }
 
  TempFormatBuffer = AllocatePool (FormatStrSize); // Allocate memory for the
                                                   // new string.
  if (TempFormatBuffer == NULL) {
    return NULL;
  }
 
  //
  // Clone *FormatString but replace "%s" wih "%a".
  // "%%" is not considered as the format tag.
  //
  PercentageMark = FALSE;
  FormatStrIndex = 0;
  while (FormatStrIndex < FormatStrSize) {
    if (PercentageMark == TRUE) {
      //
      // Previous character is "%".
      //
      PercentageMark = FALSE;
      if (*(FormatString + FormatStrIndex) != '%') {
        // Check if this is double "%".
        FormatStrSpecifier = FormatStrIndex;
        //
        // Check if this is the formating string specifier.
        //
        IsFormatString = CheckFormatingString (FormatString, &FormatStrSpecifier, FormatStrSize);
        if ((FormatStrSpecifier - FormatStrIndex) != 0) {
          CopyMem (
            (VOID *)(TempFormatBuffer + FormatStrIndex),
            (VOID *)(FormatString + FormatStrIndex),
            FormatStrSpecifier - FormatStrIndex
            );
        }
 
        FormatStrIndex = FormatStrSpecifier;
        if (IsFormatString == TRUE) {
          //
          // Replace 's' with 'a' which is printed in ASCII
          // format on edk2 environment.
          //
          *(TempFormatBuffer + FormatStrSpecifier) = 'a';
          FormatStrIndex++;
        }
 
        continue;
      }
 
      goto ContinueCheck;
    }
 
    if (*(FormatString + FormatStrIndex) == '%') {
      //
      // This character is "%", set the flag.
      //
      PercentageMark = TRUE;
    }
 
ContinueCheck:
    //
    // Clone character to the new string and advance FormatStrIndex
    // to process next character.
    //
    *(TempFormatBuffer + FormatStrIndex) = *(FormatString + FormatStrIndex);
    FormatStrIndex++;
  }
 
  return TempFormatBuffer;
}
 
UINTN
EFIAPI
RedfishAsciiVSPrint (
  OUT CHAR8        *StartOfBuffer,
  IN  UINTN        BufferSize,
  IN  CONST CHAR8  *FormatString,
  IN  VA_LIST      Marker
  )
{
  CHAR8  *TempFormatBuffer;
  UINTN  LenStrProduced;
 
  //
  // Looking for "%s" in the format string and replace it
  // with "%a" for printing ASCII code characters on edk2
  // environment.
  //
  TempFormatBuffer = ReplaceUnicodeToAsciiStrFormat (FormatString);
  if (TempFormatBuffer == NULL) {
    return 0;
  }
 
  LenStrProduced = AsciiVSPrint (StartOfBuffer, BufferSize, (CONST CHAR8 *)TempFormatBuffer, Marker);
  FreePool (TempFormatBuffer);
  return LenStrProduced;
}
 
UINTN
EFIAPI
RedfishAsciiSPrint (
  OUT CHAR8        *StartOfBuffer,
  IN  UINTN        BufferSize,
  IN  CONST CHAR8  *FormatString,
  ...
  )
{
  VA_LIST  Marker;
  UINTN    LenStrProduced;
 
  VA_START (Marker, FormatString);
  LenStrProduced = RedfishAsciiVSPrint (StartOfBuffer, BufferSize, FormatString, Marker);
  return LenStrProduced;
}