tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-07-28 08:04:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

RedfishPkg/RedfishCrtLib: Redfish C runtime library

Browse Source 
Redfish CRT library is currently used by edk2 JsonLib
(open source jansson project) and edk2 RedfishLib
(libredfish open source project). Redfish CrtLib library
provides the necessary C runtime equivalent edk2 functions
for open source projects.

Signed-off-by: Abner Chang <abner.chang@hpe.com>

Cc: Leif Lindholm <leif@nuviainc.com>
Cc: Nickle Wang <nickle.wang@hpe.com>
Cc: Peter O'Hanley <peter.ohanley@hpe.com>
Reviewed-by: Nickle Wang <nickle.wang@hpe.com>
Acked-by: Leif Lindholm <leif@nuviainc.com>
Reviewed-by: Michael D Kinney <michael.d.kinney@intel.com>
This commit is contained in:
Abner Chang 2020-12-04 12:30:05 +08:00 committed by mergify[bot]
parent a88731d545
commit 6e9233f968
19 changed files with 1310 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
RedfishPkg/PrivateInclude/Crt/assert.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_ASSERT_H_
#define REDFISH_CRT_ASSERT_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/errno.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_ERRNO_H_
#define REDFISH_CRT_ERRNO_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/limits.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_LIMITS_H_
#define REDFISH_CRT_LIMITS_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/math.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_MATH_H_
#define REDFISH_CRT_MATH_H_
#include <Library/RedfishCrtLib.h>
#endif

15
RedfishPkg/PrivateInclude/Crt/stdarg.h Normal file
View File

@ -0,0 +1,15 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_STDARG_H_
#define REDFISH_CRT_STDARG_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/stddef.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_STDDEF_H_
#define REDFISH_CRT_STDDEF_H_
#include <Library/RedfishCrtLib.h>
#endif

15
RedfishPkg/PrivateInclude/Crt/stdio.h Normal file
View File

@ -0,0 +1,15 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_STDIO_H_
#define REDFISH_CRT_STDIO_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/stdlib.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_STDLIB_H_
#define REDFISH_CRT_STDLIB_H_
#include <Library/RedfishCrtLib.h>
#endif

16
RedfishPkg/PrivateInclude/Crt/string.h Normal file
View File

@ -0,0 +1,16 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_STRING_H_
#define REDFISH_CRT_STRING_H_
#include <Library/RedfishCrtLib.h>
#endif

15
RedfishPkg/PrivateInclude/Crt/sys/time.h Normal file
View File

@ -0,0 +1,15 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_SYS_TIME_H_
#define REDFISH_CRT_SYS_TIME_H_
#include <Library/RedfishCrtLib.h>
#endif

15
RedfishPkg/PrivateInclude/Crt/sys/types.h Normal file
View File

@ -0,0 +1,15 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_SYS_TYPES_H_
#define REDFISH_CRT_SYS_TYPES_H_
#include <Library/RedfishCrtLib.h>
#endif

15
RedfishPkg/PrivateInclude/Crt/time.h Normal file
View File

@ -0,0 +1,15 @@
/** @file
Include file to support building the third-party jansson library.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_TIME_H_
#define REDFISH_CRT_TIME_H_
#include <Library/RedfishCrtLib.h>
#endif

242
RedfishPkg/PrivateInclude/Library/RedfishCrtLib.h Normal file
View File

@ -0,0 +1,242 @@
/** @file
Redfish CRT wrapper functions.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef REDFISH_CRT_LIB_H_
#define REDFISH_CRT_LIB_H_
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/PrintLib.h>
#define MAX_STRING_SIZE 0x10000000
// Minimum value for an object of type long long int.
#define LLONG_MIN MIN_INT64
// Maximum value for an object of type long long int.
#define LLONG_MAX MAX_INT64
// We dont support double on edk2
#define HUGE_VAL 0
#if defined(MDE_CPU_X64) || defined(MDE_CPU_AARCH64) || defined(MDE_CPU_RISCV64)
//
// With GCC we would normally use SIXTY_FOUR_BIT_LONG, but MSVC needs
// SIXTY_FOUR_BIT, because 'long' is 32-bit and only 'long long' is
// 64-bit. Since using 'long long' works fine on GCC too, just do that.
//
#define SIXTY_FOUR_BIT
#elif defined(MDE_CPU_IA32) || defined(MDE_CPU_ARM) || defined(MDE_CPU_EBC)
#define THIRTY_TWO_BIT
#endif
//
// Map all va_xxxx elements to VA_xxx defined in MdePkg/Include/Base.h
//
#if !defined(__CC_ARM) // if va_list is not already defined
#define va_list VA_LIST
#define va_arg VA_ARG
#define va_start VA_START
#define va_end VA_END
#else // __CC_ARM
#define va_start(Marker, Parameter) __va_start(Marker, Parameter)
#define va_arg(Marker, TYPE) __va_arg(Marker, TYPE)
#define va_end(Marker) ((void)0)
#endif
//
// Definitions for global constants used by CRT library routines
//
#define INT_MAX MAX_INT32 /* Maximum (signed) int value */
#define LONG_MAX 0X7FFFFFFFL /* max value for a long */
#define LONG_MIN (-LONG_MAX-1) /* min value for a long */
#define ULONG_MAX 0xFFFFFFFF /* Maximum unsigned long value */
#define CHAR_BIT 8 /* Number of bits in a char */
// Maximum value for an object of type unsigned long long int.
#define ULLONG_MAX 0xFFFFFFFFFFFFFFFFULL // 2^64 - 1
// Maximum value for an object of type unsigned char.
#define UCHAR_MAX 255 // 2^8 - 1
//
// Basic types mapping
//
typedef UINTN size_t;
typedef INTN ssize_t;
typedef INT32 time_t;
typedef UINT8 __uint8_t;
typedef UINT8 sa_family_t;
typedef UINT32 uid_t;
typedef UINT32 gid_t;
typedef INT32 int32_t;
typedef UINT32 uint32_t;
typedef UINT16 uint16_t;
typedef UINT8 uint8_t;
typedef enum {false, true} bool;
//
// File operations are not required for EFI building,
// so FILE is mapped to VOID * to pass build
//
typedef VOID *FILE;
/**
This is the Redfish version of CRT snprintf function, this function replaces "%s" to
"%a" before invoking AsciiSPrint(). That is becasue "%s" is unicode base on edk2
environment however "%s" is ascii code base on snprintf().
See definitions of AsciiSPrint() for the details.
@param StartOfBuffer A pointer to the output buffer for the produced Null-terminated
ASCII string.
@param BufferSize The size, in bytes, of the output buffer specified by StartOfBuffer.
@param FormatString A Null-terminated ASCII format string.
@param ... Variable argument list whose contents are accessed based on the
format string specified by FormatString.
@return The number of ASCII characters in the produced output buffer not including the
Null-terminator. Zero means no string is produced or the error happens.
**/
UINTN
EFIAPI
RedfishAsciiSPrint (
OUT CHAR8 *StartOfBuffer,
IN UINTN BufferSize,
IN CONST CHAR8 *FormatString,
...
);
/**
This is the Redfish version of CRT vsnprintf function, this function replaces "%s" to
"%a" before invoking AsciiVSPrint(). That is because "%s" is unicode base on edk2
environment however "%s" is ascii code base on vsnprintf().
See definitions of AsciiVSPrint() for the details.
@param StartOfBuffer A pointer to the output buffer for the produced Null-terminated
ASCII string.
@param BufferSize The size, in bytes, of the output buffer specified by StartOfBuffer.
@param FormatString A Null-terminated ASCII format string.
@param Marker VA_LIST marker for the variable argument list.
@return The number of ASCII characters in the produced output buffer not including the
Null-terminator.
**/
UINTN
EFIAPI
RedfishAsciiVSPrint (
OUT CHAR8 *StartOfBuffer,
IN UINTN BufferSize,
IN CONST CHAR8 *FormatString,
IN VA_LIST Marker
);
//
// Global variables
//
extern int errno;
extern FILE *stderr;
//
// Function prototypes of CRT Library routines
//
void *malloc (size_t);
void *realloc (void *, size_t);
void *calloc (size_t Num, size_t Size);
void free (void *);
void *memset (void *, int, size_t);
int memcmp (const void *, const void *, size_t);
int isdigit (int);
int isspace (int);
int tolower (int);
int isupper (int);
int isxdigit (int);
int isalnum (int);
void *memcpy (void *, const void *, size_t);
void *memset (void *, int, size_t);
void *memchr (const void *, int, size_t);
int memcmp (const void *, const void *, size_t);
void *memmove (void *, const void *, size_t);
int strcmp (const char *, const char *);
int strncmp (const char *, const char *, size_t);
char *strcpy (char *, const char *);
size_t strlen (const char *);
char *strcat (char *, const char *);
char *strchr (const char *, int);
int strcasecmp (const char *, const char *);
int strncasecmp (const char *, const char *, size_t);
char *strncpy (char *, size_t, const char *, size_t);
int strncmp (const char *, const char *, size_t);
char *strrchr (const char *, int);
unsigned long strtoul (const char *, char **, int);
char * strstr (const char *s1 , const char *s2);
long strtol (const char *, char **, int);
char *strerror (int);
size_t strspn (const char *, const char *);
char * strdup (const char *str);
char * strpbrk (const char *s1, const char *s2);
unsigned long long strtoull(const char * nptr, char ** endptr, int base);
long long strtoll (const char * nptr, char ** endptr, int base);
long strtol (const char * nptr, char ** endptr, int base);
double strtod (const char * __restrict nptr, char ** __restrict endptr);
size_t strcspn (const char *, const char *);
int printf (const char *, ...);
int sscanf (const char *, const char *, ...);
FILE *fopen (const char *, const char *);
size_t fread (void *, size_t, size_t, FILE *);
size_t fwrite (const void *, size_t, size_t, FILE *);
int fclose (FILE *);
int fprintf (FILE *, const char *, ...);
int fgetc (FILE * _File);
uid_t getuid (void);
uid_t geteuid (void);
gid_t getgid (void);
gid_t getegid (void);
void qsort (void *, size_t, size_t, int (*)(const void *, const void *));
char *getenv (const char *);
#if defined(__GNUC__) && (__GNUC__ >= 2)
void abort (void) __attribute__((__noreturn__));
#else
void abort (void);
#endif
int toupper (int);
int Digit2Val (int);
time_t time (time_t *);
//
// Macros that directly map functions to BaseLib, BaseMemoryLib, and DebugLib functions
//
#define strcmp AsciiStrCmp
#define memcpy(dest,source,count) CopyMem(dest,source,(UINTN)(count))
#define memset(dest,ch,count) SetMem(dest,(UINTN)(count),(UINT8)(ch))
#define memchr(buf,ch,count) ScanMem8(buf,(UINTN)(count),(UINT8)ch)
#define memcmp(buf1,buf2,count) (int)(CompareMem(buf1,buf2,(UINTN)(count)))
#define memmove(dest,source,count) CopyMem(dest,source,(UINTN)(count))
#define strlen(str) (size_t)(AsciiStrnLenS(str,MAX_STRING_SIZE))
#define strcpy(strDest,strSource) AsciiStrCpyS(strDest,(strlen(strSource)+1),strSource)
#define strncpy(strDest,strSource,count) AsciiStrnCpyS(strDest,(UINTN)count,strSource,(UINTN)count)
#define strncpys(strDest, DestLen, strSource,count) AsciiStrnCpyS(strDest,DestLen,strSource,(UINTN)count)
#define strcat(strDest,strSource) AsciiStrCatS(strDest,(strlen(strSource)+strlen(strDest)+1),strSource)
#define strchr(str,ch) ScanMem8((VOID *)(str),AsciiStrSize(str),(UINT8)ch)
#define strcasecmp(str1,str2) (int)AsciiStriCmp(str1,str2)
#define strstr(s1,s2) AsciiStrStr(s1,s2)
#define snprintf(buf,len,...) RedfishAsciiSPrint(buf,len,__VA_ARGS__)
#define vsnprintf(buf,len,format,marker) RedfishAsciiVSPrint((buf),(len),(format),(marker))
#define assert(expression) ASSERT(expression)
#define offsetof(type,member) OFFSET_OF(type,member)
#define EOF (-1)
extern int errno;
#define ERANGE 34 /* 34 Result too large */
#endif

809
RedfishPkg/PrivateLibrary/RedfishCrtLib/RedfishCrtLib.c Normal file
View File

@ -0,0 +1,809 @@
/** @file
CRT wrapper functions for system call,the string operation functions
are remodeled after edk2-libc.
Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
(C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#include <Uefi.h>
#include <Library/RedfishCrtLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/SortLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
int errno = 0;
/**
Determine if a particular character is an alphanumeric character
@return Returns 1 if c is an alphanumeric character, otherwise returns 0.
**/
int isalnum (int c)
{
//
// <alnum> ::= [0-9] | [a-z] | [A-Z]
//
return ((('0' <= (c)) && ((c) <= '9')) ||
(('a' <= (c)) && ((c) <= 'z')) ||
(('A' <= (c)) && ((c) <= 'Z')));
}
/**
Determine if a particular character is a digital character
@return Returns 1 if c is an digital character, otherwise returns 0.
**/
int isdchar (int c)
{
//
// [0-9] | [e +-.]
//
return ((('0' <= (c)) && ((c) <= '9')) ||
(c == 'e') || (c == 'E') ||
(c == '+') || (c == '-') ||
(c == '.'));
}
/**
Determine if a particular character is a space character
@return Returns 1 if c is a space character
**/
int isspace (int c)
{
//
// <space> ::= [ ]
//
return ((c) == ' ') || ((c) == '\t') || ((c) == '\r') || ((c) == '\n') || ((c) == '\v') || ((c) == '\f');
}
/**
Allocates memory blocks
*/
void *malloc (size_t size)
{
return AllocatePool ((UINTN) size);
}
/**
De-allocates or frees a memory block
*/
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);
}
}
/**
NetBSD Compatibility Function strdup creates a duplicate copy of a string.
@return Returns the pointer to duplicated string.
**/
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);
}
/** The toupper function converts a lowercase letter to a corresponding
uppercase letter.
@param[in] c The character to be converted.
@return If the argument is a character for which islower is true and
there are one or more corresponding characters, as specified by
the current locale, for which isupper is true, the toupper
function returns one of the corresponding characters (always the
same one for any given locale); otherwise, the argument is
returned unchanged.
**/
int
toupper(
IN int c
)
{
if ( (c >= 'a') && (c <= 'z') ) {
c = c - ('a' - 'A');
}
return c;
}
/**
Digit to a value.
@return Returns the value of digit.
**/
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.
}
/** The strtoll function converts the initial portion of the string pointed to
by nptr to long long int representation.
See the description for strtol for more information.
@return The strtoll function returns the converted value, if any. If no
conversion could be performed, zero is returned. If the correct
value is outside the range of representable values, LLONG_MIN or
LLONG_MAX is returned (according to the sign of the value, if any),
and the value of the macro ERANGE is stored in errno.
**/
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;
}
/** The strtol, strtoll, strtoul, and strtoull functions convert the initial
portion of the string pointed to by nptr to long int, long long int,
unsigned long int, and unsigned long long int representation, respectively.
First, they decompose the input string into three parts: an initial,
possibly empty, sequence of white-space characters (as specified by the
isspace function), a subject sequence resembling an integer represented in
some radix determined by the value of base, and a final string of one or
more unrecognized characters, including the terminating null character of
the input string. Then, they attempt to convert the subject sequence to an
integer, and return the result.
If the value of base is zero, the expected form of the subject sequence is
that of an integer constant, optionally preceded
by a plus or minus sign, but not including an integer suffix. If the value
of base is between 2 and 36 (inclusive), the expected form of the subject
sequence is a sequence of letters and digits representing an integer with
the radix specified by base, optionally preceded by a plus or minus sign,
but not including an integer suffix. The letters from a (or A) through z
(or Z) are ascribed the values 10 through 35; only letters and digits whose
ascribed values are less than that of base are permitted. If the value of
base is 16, the characters 0x or 0X may optionally precede the sequence of
letters and digits, following the sign if present.
The subject sequence is defined as the longest initial subsequence of the
input string, starting with the first non-white-space character, that is of
the expected form. The subject sequence contains no characters if the input
string is empty or consists entirely of white space, or if the first
non-white-space character is other than a sign or a permissible letter or digit.
If the subject sequence has the expected form and the value of base is
zero, the sequence of characters starting with the first digit is
interpreted as an integer constant. If the subject sequence has the
expected form and the value of base is between 2 and 36, it is used as the
base for conversion, ascribing to each letter its value as given above. If
the subject sequence begins with a minus sign, the value resulting from the
conversion is negated (in the return type). A pointer to the final string
is stored in the object pointed to by endptr, provided that endptr is
not a null pointer.
In other than the "C" locale, additional locale-specific subject sequence
forms may be accepted.
If the subject sequence is empty or does not have the expected form, no
conversion is performed; the value of nptr is stored in the object pointed
to by endptr, provided that endptr is not a null pointer.
@return The strtol, strtoll, strtoul, and strtoull functions return the
converted value, if any. If no conversion could be performed, zero
is returned. If the correct value is outside the range of
representable values, LONG_MIN, LONG_MAX, LLONG_MIN, LLONG_MAX,
ULONG_MAX, or ULLONG_MAX is returned (according to the return type
and sign of the value, if any), and the value of the macro ERANGE
is stored in errno.
**/
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;
}
/** The strtoull function converts the initial portion of the string pointed to
by nptr to unsigned long long int representation.
See the description for strtol for more information.
@return The strtoull function returns the converted value, if any. If no
conversion could be performed, zero is returned. If the correct
value is outside the range of representable values, ULLONG_MAX is
returned and the value of the macro ERANGE is stored in errno.
**/
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;
}
/**
edk2 Jansson port does not support doubles, simply return 0.
These conversion functions convert the initial portion of the string
pointed to by nptr to double, float, and long double representation,
respectively.
The strtod(), strtof(), and strtold() functions return the converted
value, if any.
If endptr is not NULL, a pointer to the character after the last charac-
ter used in the conversion is stored in the location referenced by
endptr.
If no conversion is performed, zero is returned and the value of nptr is
stored in the location referenced by endptr.
If the correct value would cause overflow, plus or minus HUGE_VAL,
HUGE_VALF, or HUGE_VALL is returned (according to the sign and type of
the return value), and ERANGE is stored in errno. If the correct value
would cause underflow, zero is returned and ERANGE is stored in errno.
@return Return 0.
**/
double
strtod (const char * __restrict nptr, char ** __restrict endptr) {
DEBUG((DEBUG_INFO, "We don't supprot double type on edk2 yet!"));
ASSERT(FALSE);
return (double)0;
}
/**
Allocate and zero-initialize array.
**/
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)
/**
Get the system time as seconds elapsed since midnight, January 1, 1970.
**/
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;
}
/**
Performs a quick sort
**/
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;
}
/**
Get character from stream, we don't support file operastion on edk2 JSON library.
@return Returns the character currently pointed by the internal file position indicator of the specified stream
**/
int fgetc(FILE * _File){
return 0;
}
/**
This function check if this is the formating string specifier.
@param[in] FormatString A Null-terminated ASCII format string.
@param[in,out] CurrentPosition The starting position at the given string to check for
"[flags][width][.precision][length]s" string specifier.
@param[in] StrLength Maximum string length.
@return BOOLEAN TRUE means this is the formating string specifier. CurrentPosition is
returned at the position of "s".
FALSE means this is not the formating string specifier.. CurrentPosition is
returned at the position of failed character.
**/
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;
}
/**
This function clones *FormatString however replaces "%s" with "%a" in the
returned string.
@param[in] A Null-terminated ASCII format string.
@return The new format string. Caller has to free the memory of this string
using FreePool().
**/
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;
}
/**
This is the Redfish version of CRT vsnprintf function, this function replaces "%s" to
"%a" before invoking AsciiVSPrint(). That is because "%s" is unicode base on edk2
environment however "%s" is ascii code base on vsnprintf().
See definitions of AsciiVSPrint() for the details.
@param StartOfBuffer A pointer to the output buffer for the produced Null-terminated
ASCII string.
@param BufferSize The size, in bytes, of the output buffer specified by StartOfBuffer.
@param FormatString A Null-terminated ASCII format string.
@param Marker VA_LIST marker for the variable argument list.
@return The number of ASCII characters in the produced output buffer not including the
Null-terminator.
**/
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;
}
/**
This is the Redfish version of CRT snprintf function, this function replaces "%s" to
"%a" before invoking AsciiSPrint(). That is because "%s" is unicode base on edk2
environment however "%s" is ascii code base on snprintf().
See definitions of AsciiSPrint() for the details.
@param StartOfBuffer A pointer to the output buffer for the produced Null-terminated
ASCII string.
@param BufferSize The size, in bytes, of the output buffer specified by StartOfBuffer.
@param FormatString A Null-terminated ASCII format string.
@param ... Variable argument list whose contents are accessed based on the
format string specified by FormatString.
@return The number of ASCII characters in the produced output buffer not including the
Null-terminator.
**/
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;
}

38
RedfishPkg/PrivateLibrary/RedfishCrtLib/RedfishCrtLib.inf Normal file
View File

@ -0,0 +1,38 @@
## @file
# Redfish C Runtime Library for opensource projects.
#
# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>
# (C) Copyright 2020 Hewlett Packard Enterprise Development LP<BR>
#
# SPDX-License-Identifier: BSD-2-Clause-Patent
#
##
[Defines]
INF_VERSION = 0x0001001b
BASE_NAME = RedfishCrtLib
FILE_GUID = 8263B8AC-D021-425D-B337-3EC96F5DC19B
MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0
LIBRARY_CLASS = RedfishCrtLib|DXE_DRIVER UEFI_APPLICATION UEFI_DRIVER
#
# VALID_ARCHITECTURES = IA32 X64 ARM AARCH64 RISCV64
#
[Sources]
RedfishCrtLib.c
[LibraryClasses]
BaseLib
BaseSortLib
DebugLib
MemoryAllocationLib
UefiRuntimeServicesTableLib
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
RedfishPkg/RedfishPkg.dec

2
RedfishPkg/RedfishLibs.dsc.inc
View File

@ -13,5 +13,7 @@
!if $(REDFISH_ENABLE) == TRUE !if $(REDFISH_ENABLE) == TRUE
RestExLib|RedfishPkg/Library/DxeRestExLib/DxeRestExLib.inf RestExLib|RedfishPkg/Library/DxeRestExLib/DxeRestExLib.inf
Ucs2Utf8Lib|RedfishPkg/Library/BaseUcs2Utf8Lib/BaseUcs2Utf8Lib.inf Ucs2Utf8Lib|RedfishPkg/Library/BaseUcs2Utf8Lib/BaseUcs2Utf8Lib.inf
BaseSortLib|MdeModulePkg/Library/BaseSortLib/BaseSortLib.inf
RedfishCrtLib|RedfishPkg/PrivateLibrary/RedfishCrtLib/RedfishCrtLib.inf
!endif !endif

19
RedfishPkg/RedfishPkg.ci.yaml
View File

@ -17,6 +17,25 @@
], ],
## Both file path and directory path are accepted. ## Both file path and directory path are accepted.
"IgnoreFiles": [ "IgnoreFiles": [
## Below are files incorporated with open source which are
## not edk2 coding standard compliant.
##
## EDK2 CRT library which is not edk2 coding
## standard compliant.
## C runtime library for RedfishPkg modules
"PrivateInclude/Crt/sys",
"PrivateInclude/Crt/assert.h",
"PrivateInclude/Crt/errno.h",
"PrivateInclude/Crt/limits.h",
"PrivateInclude/Crt/math.h",
"PrivateInclude/Crt/stdarg.h",
"PrivateInclude/Crt/stddef.h",
"PrivateInclude/Crt/stdio.h",
"PrivateInclude/Crt/stdlib.h",
"PrivateInclude/Crt/string.h",
"PrivateInclude/Crt/time.h",
"PrivateInclude/Library/RedfishCrtLib.h",
"PrivateLibrary/RedfishCrtLib/RedfishCrtLib.c"
] ]
}, },
"CompilerPlugin": { "CompilerPlugin": {

12
RedfishPkg/RedfishPkg.dec
View File

@ -16,10 +16,15 @@
[Includes] [Includes]
Include Include
[Includes.Common.Private]
PrivateInclude # Private header files for C RTL.
PrivateInclude/Crt # Private header files for C RTL.
[LibraryClasses] [LibraryClasses]
## @libraryclass Platform Redfish Host Interface Library ## @libraryclass Platform Redfish Host Interface Library
# Platform implementation-specific Redfish Host Interface. # Platform implementation-specific Redfish Host Interface.
RedfishPlatformHostInterfaceLib|Include/Library/RedfishHostInterfaceLib.h RedfishPlatformHostInterfaceLib|Include/Library/RedfishHostInterfaceLib.h
## @libraryclass This library provides UCS2 to UTF8 manipulation ## @libraryclass This library provides UCS2 to UTF8 manipulation
# functions. # functions.
# #
@ -33,6 +38,13 @@
# This library is only intended to be used by UEFI network stack modules. # This library is only intended to be used by UEFI network stack modules.
RestExLib|Include/Library/RestExLib.h RestExLib|Include/Library/RestExLib.h
[LibraryClasses.Common.Private]
## @libraryclass Provides the private C runtime library functions.
# CRT library is currently used by edk2 JsonLib (open source
# jansson project) and edk2 RedfishLib (libredfish open source
# project).
RedfishCrtLib|PrivateInclude/Library/RedfishCrtLib.h
[Protocols] [Protocols]
## Include/Protocol/RedfishDiscover.h ## Include/Protocol/RedfishDiscover.h
gEfiRedfishDiscoverProtocolGuid = { 0x5db12509, 0x4550, 0x4347, { 0x96, 0xb3, 0x73, 0xc0, 0xff, 0x6e, 0x86, 0x9f }} gEfiRedfishDiscoverProtocolGuid = { 0x5db12509, 0x4550, 0x4347, { 0x96, 0xb3, 0x73, 0xc0, 0xff, 0x6e, 0x86, 0x9f }}

1
RedfishPkg/RedfishPkg.dsc
View File

@ -51,5 +51,6 @@
RedfishPkg/Library/PlatformCredentialLibNull/PlatformCredentialLibNull.inf RedfishPkg/Library/PlatformCredentialLibNull/PlatformCredentialLibNull.inf
RedfishPkg/Library/DxeRestExLib/DxeRestExLib.inf RedfishPkg/Library/DxeRestExLib/DxeRestExLib.inf
RedfishPkg/Library/BaseUcs2Utf8Lib/BaseUcs2Utf8Lib.inf RedfishPkg/Library/BaseUcs2Utf8Lib/BaseUcs2Utf8Lib.inf
RedfishPkg/PrivateLibrary/RedfishCrtLib/RedfishCrtLib.inf
!include RedfishPkg/Redfish.dsc.inc !include RedfishPkg/Redfish.dsc.inc