CryptoPkg: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / CryptoPkg / Library / BaseCryptLib / SysCall / CrtWrapper.c

/** @file\r
  C Run-Time Libraries (CRT) Wrapper Implementation for OpenSSL-based\r
  Cryptographic Library.\r
\r
Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <CrtLibSupport.h>\r
\r
int errno = 0;\r
\r
FILE  *stderr = NULL;\r
FILE  *stdin  = NULL;\r
FILE  *stdout = NULL;\r
\r
typedef\r
int\r
(*SORT_COMPARE)(\r
  IN  VOID  *Buffer1,\r
  IN  VOID  *Buffer2\r
  );\r
\r
//\r
// Duplicated from EDKII BaseSortLib for qsort() wrapper\r
//\r
STATIC\r
VOID\r
QuickSortWorker (\r
  IN OUT    VOID          *BufferToSort,\r
  IN CONST  UINTN         Count,\r
  IN CONST  UINTN         ElementSize,\r
  IN        SORT_COMPARE  CompareFunction,\r
  IN        VOID          *Buffer\r
  )\r
{\r
  VOID        *Pivot;\r
  UINTN       LoopCount;\r
  UINTN       NextSwapLocation;\r
\r
  ASSERT(BufferToSort    != NULL);\r
  ASSERT(CompareFunction != NULL);\r
  ASSERT(Buffer          != NULL);\r
\r
  if (Count < 2 || ElementSize  < 1) {\r
    return;\r
  }\r
\r
  NextSwapLocation = 0;\r
\r
  //\r
  // Pick a pivot (we choose last element)\r
  //\r
  Pivot = ((UINT8 *)BufferToSort + ((Count - 1) * ElementSize));\r
\r
  //\r
  // Now get the pivot such that all on "left" are below it\r
  // and everything "right" are above it\r
  //\r
  for (LoopCount = 0; LoopCount < Count - 1;  LoopCount++)\r
  {\r
    //\r
    // If the element is less than the pivot\r
    //\r
    if (CompareFunction ((VOID *)((UINT8 *)BufferToSort + ((LoopCount) * ElementSize)), Pivot) <= 0) {\r
      //\r
      // Swap\r
      //\r
      CopyMem (Buffer, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);\r
      CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), (UINT8 *)BufferToSort + ((LoopCount) * ElementSize), ElementSize);\r
      CopyMem ((UINT8 *)BufferToSort + ((LoopCount) * ElementSize), Buffer, ElementSize);\r
\r
      //\r
      // Increment NextSwapLocation\r
      //\r
      NextSwapLocation++;\r
    }\r
  }\r
  //\r
  // Swap pivot to its final position (NextSwapLocation)\r
  //\r
  CopyMem (Buffer, Pivot, ElementSize);\r
  CopyMem (Pivot, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);\r
  CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), Buffer, ElementSize);\r
\r
  //\r
  // Now recurse on 2 partial lists.  Neither of these will have the 'pivot' element.\r
  // IE list is sorted left half, pivot element, sorted right half...\r
  //\r
  QuickSortWorker (\r
    BufferToSort,\r
    NextSwapLocation,\r
    ElementSize,\r
    CompareFunction,\r
    Buffer\r
    );\r
\r
  QuickSortWorker (\r
    (UINT8 *)BufferToSort + (NextSwapLocation + 1) * ElementSize,\r
    Count - NextSwapLocation - 1,\r
    ElementSize,\r
    CompareFunction,\r
    Buffer\r
    );\r
\r
  return;\r
}\r
\r
//---------------------------------------------------------\r
// Standard C Run-time Library Interface Wrapper\r
//---------------------------------------------------------\r
\r
//\r
// -- String Manipulation Routines --\r
//\r
\r
/* Scan a string for the last occurrence of a character */\r
char *strrchr (const char *str, int c)\r
{\r
  char * save;\r
\r
  for (save = NULL; ; ++str) {\r
    if (*str == c) {\r
      save = (char *)str;\r
    }\r
    if (*str == 0) {\r
      return (save);\r
    }\r
  }\r
}\r
\r
/* Compare first n bytes of string s1 with string s2, ignoring case */\r
int strncasecmp (const char *s1, const char *s2, size_t n)\r
{\r
  int Val;\r
\r
  ASSERT(s1 != NULL);\r
  ASSERT(s2 != NULL);\r
\r
  if (n != 0) {\r
    do {\r
      Val = tolower(*s1) - tolower(*s2);\r
      if (Val != 0) {\r
        return Val;\r
      }\r
      ++s1;\r
      ++s2;\r
      if (*s1 == '\0') {\r
        break;\r
      }\r
    } while (--n != 0);\r
  }\r
  return 0;\r
}\r
\r
/* Read formatted data from a string */\r
int sscanf (const char *buffer, const char *format, ...)\r
{\r
  //\r
  // Null sscanf() function implementation to satisfy the linker, since\r
  // no direct functionality logic dependency in present UEFI cases.\r
  //\r
  return 0;\r
}\r
\r
/* Maps errnum to an error-message string */\r
char * strerror (int errnum)\r
{\r
  return NULL;\r
}\r
\r
/* Computes the length of the maximum initial segment of the string pointed to by s1\r
   which consists entirely of characters from the string pointed to by s2. */\r
size_t strspn (const char *s1 , const char *s2)\r
{\r
  UINT8   Map[32];\r
  UINT32  Index;\r
  size_t  Count;\r
\r
  for (Index = 0; Index < 32; Index++) {\r
    Map[Index] = 0;\r
  }\r
\r
  while (*s2) {\r
    Map[*s2 >> 3] |= (1 << (*s2 & 7));\r
    s2++;\r
  }\r
\r
  if (*s1) {\r
    Count = 0;\r
    while (Map[*s1 >> 3] & (1 << (*s1 & 7))) {\r
      Count++;\r
      s1++;\r
    }\r
\r
    return Count;\r
  }\r
\r
  return 0;\r
}\r
\r
/* Computes the length of the maximum initial segment of the string pointed to by s1\r
   which consists entirely of characters not from the string pointed to by s2. */\r
size_t strcspn (const char *s1, const char *s2)\r
{\r
  UINT8  Map[32];\r
  UINT32 Index;\r
  size_t Count;\r
\r
  for (Index = 0; Index < 32; Index++) {\r
    Map[Index] = 0;\r
  }\r
\r
  while (*s2) {\r
    Map[*s2 >> 3] |= (1 << (*s2 & 7));\r
    s2++;\r
  }\r
\r
  Map[0] |= 1;\r
\r
  Count   = 0;\r
  while (!(Map[*s1 >> 3] & (1 << (*s1 & 7)))) {\r
    Count ++;\r
    s1++;\r
  }\r
\r
  return Count;\r
}\r
\r
//\r
// -- Character Classification Routines --\r
//\r
\r
/* Determines if a particular character is a decimal-digit character */\r
int isdigit (int c)\r
{\r
  //\r
  // <digit> ::= [0-9]\r
  //\r
  return (('0' <= (c)) && ((c) <= '9'));\r
}\r
\r
/* Determine if an integer represents character that is a hex digit */\r
int isxdigit (int c)\r
{\r
  //\r
  // <hexdigit> ::= [0-9] | [a-f] | [A-F]\r
  //\r
  return ((('0' <= (c)) && ((c) <= '9')) ||\r
          (('a' <= (c)) && ((c) <= 'f')) ||\r
          (('A' <= (c)) && ((c) <= 'F')));\r
}\r
\r
/* Determines if a particular character represents a space character */\r
int isspace (int c)\r
{\r
  //\r
  // <space> ::= [ ]\r
  //\r
  return ((c) == ' ');\r
}\r
\r
/* Determine if a particular character is an alphanumeric character */\r
int isalnum (int c)\r
{\r
  //\r
  // <alnum> ::= [0-9] | [a-z] | [A-Z]\r
  //\r
  return ((('0' <= (c)) && ((c) <= '9')) ||\r
          (('a' <= (c)) && ((c) <= 'z')) ||\r
          (('A' <= (c)) && ((c) <= 'Z')));\r
}\r
\r
/* Determines if a particular character is in upper case */\r
int isupper (int c)\r
{\r
  //\r
  // <uppercase letter> := [A-Z]\r
  //\r
  return (('A' <= (c)) && ((c) <= 'Z'));\r
}\r
\r
//\r
// -- Data Conversion Routines --\r
//\r
\r
/* Convert strings to a long-integer value */\r
long strtol (const char *nptr, char **endptr, int base)\r
{\r
  //\r
  // Null strtol() function implementation to satisfy the linker, since there is\r
  // no direct functionality logic dependency in present UEFI cases.\r
  //\r
  return 0;\r
}\r
\r
/* Convert strings to an unsigned long-integer value */\r
unsigned long strtoul (const char *nptr, char **endptr, int base)\r
{\r
  //\r
  // Null strtoul() function implementation to satisfy the linker, since there is\r
  // no direct functionality logic dependency in present UEFI cases.\r
  //\r
  return 0;\r
}\r
\r
/* Convert character to lowercase */\r
int tolower (int c)\r
{\r
  if (('A' <= (c)) && ((c) <= 'Z')) {\r
    return (c - ('A' - 'a'));\r
  }\r
  return (c);\r
}\r
\r
//\r
// -- Searching and Sorting Routines --\r
//\r
\r
/* Performs a quick sort */\r
void qsort (void *base, size_t num, size_t width, int (*compare)(const void *, const void *))\r
{\r
  VOID  *Buffer;\r
\r
  ASSERT (base    != NULL);\r
  ASSERT (compare != NULL);\r
\r
  //\r
  // Use CRT-style malloc to cover BS and RT memory allocation.\r
  //\r
  Buffer = malloc (width);\r
  ASSERT (Buffer != NULL);\r
\r
  //\r
  // Re-use PerformQuickSort() function Implementation in EDKII BaseSortLib.\r
  //\r
  QuickSortWorker (base, (UINTN)num, (UINTN)width, (SORT_COMPARE)compare, Buffer);\r
\r
  free (Buffer);\r
  return;\r
}\r
\r
//\r
// -- Process and Environment Control Routines --\r
//\r
\r
/* Get a value from the current environment */\r
char *getenv (const char *varname)\r
{\r
  //\r
  // Null getenv() function implementation to satisfy the linker, since there is\r
  // no direct functionality logic dependency in present UEFI cases.\r
  //\r
  return NULL;\r
}\r
\r
/* Get a value from the current environment */\r
char *secure_getenv (const char *varname)\r
{\r
  //\r
  // Null secure_getenv() function implementation to satisfy the linker, since\r
  // there is no direct functionality logic dependency in present UEFI cases.\r
  //\r
  // From the secure_getenv() manual: 'just like getenv() except that it\r
  // returns NULL in cases where "secure execution" is required'.\r
  //\r
  return NULL;\r
}\r
\r
//\r
// -- Stream I/O Routines --\r
//\r
\r
/* Write data to a stream */\r
size_t fwrite (const void *buffer, size_t size, size_t count, FILE *stream)\r
{\r
  return 0;\r
}\r
\r
//\r
//  -- Dummy OpenSSL Support Routines --\r
//\r
\r
int BIO_printf (void *bio, const char *format, ...)\r
{\r
  return 0;\r
}\r
\r
int BIO_snprintf(char *buf, size_t n, const char *format, ...)\r
{\r
  return 0;\r
}\r
\r
#ifdef __GNUC__\r
\r
typedef\r
VOID\r
(EFIAPI *NoReturnFuncPtr)(\r
  VOID\r
  ) __attribute__((__noreturn__));\r
\r
STATIC\r
VOID\r
EFIAPI\r
NopFunction (\r
  VOID\r
  )\r
{\r
}\r
\r
void abort (void)\r
{\r
  NoReturnFuncPtr NoReturnFunc;\r
\r
  NoReturnFunc = (NoReturnFuncPtr) NopFunction;\r
\r
  NoReturnFunc ();\r
}\r
\r
#else\r
\r
void abort (void)\r
{\r
  // Do nothing\r
}\r
\r
#endif\r
\r
int fclose (FILE *f)\r
{\r
  return 0;\r
}\r
\r
FILE *fopen (const char *c, const char *m)\r
{\r
  return NULL;\r
}\r
\r
size_t fread (void *b, size_t c, size_t i, FILE *f)\r
{\r
  return 0;\r
}\r
\r
uid_t getuid (void)\r
{\r
  return 0;\r
}\r
\r
uid_t geteuid (void)\r
{\r
  return 0;\r
}\r
\r
gid_t getgid (void)\r
{\r
  return 0;\r
}\r
\r
gid_t getegid (void)\r
{\r
  return 0;\r
}\r
\r
int printf (char const *fmt, ...)\r
{\r
  return 0;\r
}\r