/** @file
  C Run-Time Libraries (CRT) Wrapper Implementation for OpenSSL-based
  Cryptographic Library.

Copyright (c) 2009 - 2017, Intel Corporation. All rights reserved.<BR>
SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <CrtLibSupport.h>

int  errno = 0;

FILE  *stderr = NULL;
FILE  *stdin  = NULL;
FILE  *stdout = NULL;

typedef
int
(*SORT_COMPARE)(
  IN  VOID  *Buffer1,
  IN  VOID  *Buffer2
  );

//
// Duplicated from EDKII BaseSortLib for qsort() wrapper
//
STATIC
VOID
QuickSortWorker (
  IN OUT    VOID          *BufferToSort,
  IN CONST  UINTN         Count,
  IN CONST  UINTN         ElementSize,
  IN        SORT_COMPARE  CompareFunction,
  IN        VOID          *Buffer
  )
{
  VOID   *Pivot;
  UINTN  LoopCount;
  UINTN  NextSwapLocation;

  ASSERT (BufferToSort    != NULL);
  ASSERT (CompareFunction != NULL);
  ASSERT (Buffer          != NULL);

  if ((Count < 2) || (ElementSize  < 1)) {
    return;
  }

  NextSwapLocation = 0;

  //
  // Pick a pivot (we choose last element)
  //
  Pivot = ((UINT8 *)BufferToSort + ((Count - 1) * ElementSize));

  //
  // Now get the pivot such that all on "left" are below it
  // and everything "right" are above it
  //
  for (LoopCount = 0; LoopCount < Count - 1; LoopCount++) {
    //
    // If the element is less than the pivot
    //
    if (CompareFunction ((VOID *)((UINT8 *)BufferToSort + ((LoopCount) * ElementSize)), Pivot) <= 0) {
      //
      // Swap
      //
      CopyMem (Buffer, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);
      CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), (UINT8 *)BufferToSort + ((LoopCount) * ElementSize), ElementSize);
      CopyMem ((UINT8 *)BufferToSort + ((LoopCount) * ElementSize), Buffer, ElementSize);

      //
      // Increment NextSwapLocation
      //
      NextSwapLocation++;
    }
  }

  //
  // Swap pivot to its final position (NextSwapLocation)
  //
  CopyMem (Buffer, Pivot, ElementSize);
  CopyMem (Pivot, (UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), ElementSize);
  CopyMem ((UINT8 *)BufferToSort + (NextSwapLocation * ElementSize), Buffer, ElementSize);

  //
  // Now recurse on 2 partial lists.  Neither of these will have the 'pivot' element.
  // IE list is sorted left half, pivot element, sorted right half...
  //
  QuickSortWorker (
    BufferToSort,
    NextSwapLocation,
    ElementSize,
    CompareFunction,
    Buffer
    );

  QuickSortWorker (
    (UINT8 *)BufferToSort + (NextSwapLocation + 1) * ElementSize,
    Count - NextSwapLocation - 1,
    ElementSize,
    CompareFunction,
    Buffer
    );

  return;
}

// ---------------------------------------------------------
// Standard C Run-time Library Interface Wrapper
// ---------------------------------------------------------

// Jief : functions we already have are commented out
//
// -- String Manipulation Routines --
//

//char *
//strchr (
//  const char  *str,
//  int         ch
//  )
//{
//  return ScanMem8 (str, AsciiStrSize (str), (UINT8)ch);
//}
//
///* Scan a string for the last occurrence of a character */
//char *
//strrchr (
//  const char  *str,
//  int         c
//  )
//{
//  char  *save;
//
//  for (save = NULL; ; ++str) {
//    if (*str == c) {
//      save = (char *)str;
//    }
//
//    if (*str == 0) {
//      return (save);
//    }
//  }
//}
//
///* Compare first n bytes of string s1 with string s2, ignoring case */
//int
//strncasecmp (
//  const char  *s1,
//  const char  *s2,
//  size_t      n
//  )
//{
//  int  Val;
//
//  ASSERT (s1 != NULL);
//  ASSERT (s2 != NULL);
//
//  if (n != 0) {
//    do {
//      Val = tolower (*s1) - tolower (*s2);
//      if (Val != 0) {
//        return Val;
//      }
//
//      ++s1;
//      ++s2;
//      if (*s1 == '\0') {
//        break;
//      }
//    } while (--n != 0);
//  }
//
//  return 0;
//}

/* Read formatted data from a string */
int
sscanf (
  const char  *buffer,
  const char  *format,
  ...
  )
{
  //
  // Null sscanf() function implementation to satisfy the linker, since
  // no direct functionality logic dependency in present UEFI cases.
  //
  return 0;
}

/* Maps errnum to an error-message string */
char *
strerror (
  int  errnum
  )
{
  return NULL;
}

///* Computes the length of the maximum initial segment of the string pointed to by s1
//   which consists entirely of characters from the string pointed to by s2. */
//size_t
//strspn (
//  const char  *s1,
//  const char  *s2
//  )
//{
//  UINT8   Map[32];
//  UINT32  Index;
//  size_t  Count;
//
//  for (Index = 0; Index < 32; Index++) {
//    Map[Index] = 0;
//  }
//
//  while (*s2) {
//    Map[*s2 >> 3] |= (1 << (*s2 & 7));
//    s2++;
//  }
//
//  if (*s1) {
//    Count = 0;
//    while (Map[*s1 >> 3] & (1 << (*s1 & 7))) {
//      Count++;
//      s1++;
//    }
//
//    return Count;
//  }
//
//  return 0;
//}
//
///* Computes the length of the maximum initial segment of the string pointed to by s1
//   which consists entirely of characters not from the string pointed to by s2. */
//size_t
//strcspn (
//  const char  *s1,
//  const char  *s2
//  )
//{
//  UINT8   Map[32];
//  UINT32  Index;
//  size_t  Count;
//
//  for (Index = 0; Index < 32; Index++) {
//    Map[Index] = 0;
//  }
//
//  while (*s2) {
//    Map[*s2 >> 3] |= (1 << (*s2 & 7));
//    s2++;
//  }
//
//  Map[0] |= 1;
//
//  Count = 0;
//  while (!(Map[*s1 >> 3] & (1 << (*s1 & 7)))) {
//    Count++;
//    s1++;
//  }
//
//  return Count;
//}
//
//char *
//strcpy (
//  char        *strDest,
//  const char  *strSource
//  )
//{
//  AsciiStrCpyS (strDest, MAX_STRING_SIZE, strSource);
//  return strDest;
//}
//
//int
//strcmp (
//  const char  *s1,
//  const char  *s2
//  )
//{
//  return (int)AsciiStrCmp (s1, s2);
//}
//
////
//// -- Character Classification Routines --
////
//
///* Determines if a particular character is a decimal-digit character */
//int
//isdigit (
//  int  c
//  )
//{
//  //
//  // <digit> ::= [0-9]
//  //
//  return (('0' <= (c)) && ((c) <= '9'));
//}
//
///* Determine if an integer represents character that is a hex digit */
//int
//isxdigit (
//  int  c
//  )
//{
//  //
//  // <hexdigit> ::= [0-9] | [a-f] | [A-F]
//  //
//  return ((('0' <= (c)) && ((c) <= '9')) ||
//          (('a' <= (c)) && ((c) <= 'f')) ||
//          (('A' <= (c)) && ((c) <= 'F')));
//}

/* Determines if a particular character represents a space character */
int
isspace (
  int  c
  )
{
  //
  // <space> ::= [ ]
  //
  return ((c) == ' ');
}

///* Determine if a particular character is an alphanumeric character */
//int
//isalnum (
//  int  c
//  )
//{
//  //
//  // <alnum> ::= [0-9] | [a-z] | [A-Z]
//  //
//  return ((('0' <= (c)) && ((c) <= '9')) ||
//          (('a' <= (c)) && ((c) <= 'z')) ||
//          (('A' <= (c)) && ((c) <= 'Z')));
//}
//
///* Determines if a particular character is in upper case */
//int
//isupper (
//  int  c
//  )
//{
//  //
//  // <uppercase letter> := [A-Z]
//  //
//  return (('A' <= (c)) && ((c) <= 'Z'));
//}

//
// -- Data Conversion Routines --
//

/* Convert strings to a long-integer value */
long
strtol (
  const char  *nptr,
  char        **endptr,
  int         base
  )
{
  //
  // Null strtol() function implementation to satisfy the linker, since there is
  // no direct functionality logic dependency in present UEFI cases.
  //
  return 0;
}

/* Convert strings to an unsigned long-integer value */
unsigned long
strtoul (
  const char  *nptr,
  char        **endptr,
  int         base
  )
{
  //
  // Null strtoul() function implementation to satisfy the linker, since there is
  // no direct functionality logic dependency in present UEFI cases.
  //
  return 0;
}

///* Convert character to lowercase */
//int
//tolower (
//  int  c
//  )
//{
//  if (('A' <= (c)) && ((c) <= 'Z')) {
//    return (c - ('A' - 'a'));
//  }
//
//  return (c);
//}

//
// -- Searching and Sorting Routines --
//

/* Performs a quick sort */
void
qsort (
  void *base,
  size_t num,
  size_t width,
  int ( *compare )(const void *, const void *)
  )
{
  VOID  *Buffer;

  ASSERT (base    != NULL);
  ASSERT (compare != NULL);

  //
  // Use CRT-style malloc to cover BS and RT memory allocation.
  //
  Buffer = CryptoPkg_BaseMemAllocation_malloc (width);
  ASSERT (Buffer != NULL);

  //
  // Re-use PerformQuickSort() function Implementation in EDKII BaseSortLib.
  //
  QuickSortWorker (base, (UINTN)num, (UINTN)width, (SORT_COMPARE)compare, Buffer);

  CryptoPkg_BaseMemAllocation_free (Buffer);
  return;
}

//
// -- Process and Environment Control Routines --
//

/* Get a value from the current environment */
char *
getenv (
  const char  *varname
  )
{
  //
  // Null getenv() function implementation to satisfy the linker, since there is
  // no direct functionality logic dependency in present UEFI cases.
  //
  return NULL;
}

///* Get a value from the current environment */
//char *
//secure_getenv (
//  const char  *varname
//  )
//{
//  //
//  // Null secure_getenv() function implementation to satisfy the linker, since
//  // there is no direct functionality logic dependency in present UEFI cases.
//  //
//  // From the secure_getenv() manual: 'just like getenv() except that it
//  // returns NULL in cases where "secure execution" is required'.
//  //
//  return NULL;
//}
//
////
//// -- Stream I/O Routines --
////
//
///* Write data to a stream */
//size_t
//fwrite (
//  const void  *buffer,
//  size_t      size,
//  size_t      count,
//  FILE        *stream
//  )
//{
//  return 0;
//}
//
//#ifdef __GNUC__
//
//typedef
//VOID
//(EFIAPI *NoReturnFuncPtr)(
//  VOID
//  ) __attribute__ ((__noreturn__));
//
//STATIC
//VOID
//EFIAPI
//NopFunction (
//  VOID
//  )
//{
//}
//
//void
//abort (
//  void
//  )
//{
//  NoReturnFuncPtr  NoReturnFunc;
//
//  NoReturnFunc = (NoReturnFuncPtr)NopFunction;
//
//  NoReturnFunc ();
//}
//
//#else
//
//void
//abort (
//  void
//  )
//{
//  // Do nothing
//}
//
//#endif
//
//int
//fclose (
//  FILE  *f
//  )
//{
//  return 0;
//}
//
//FILE *
//fopen (
//  const char  *c,
//  const char  *m
//  )
//{
//  return NULL;
//}
//
//size_t
//fread (
//  void    *b,
//  size_t  c,
//  size_t  i,
//  FILE    *f
//  )
//{
//  return 0;
//}
//
//uid_t
//getuid (
//  void
//  )
//{
//  return 0;
//}
//
//uid_t
//geteuid (
//  void
//  )
//{
//  return 0;
//}
//
//gid_t
//getgid (
//  void
//  )
//{
//  return 0;
//}
//
//gid_t
//getegid (
//  void
//  )
//{
//  return 0;
//}
//
//int
//printf (
//  char const  *fmt,
//  ...
//  )
//{
//  return 0;
//}