//===------- string.cpp - CStdLib Runtime functions for <string.h> --------===//
// 
//                          The SAFECode Compiler
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
// 
//===----------------------------------------------------------------------===//
//
// This file provides CStdLib runtime wrapper versions of functions found in
// <string.h>.
//
//===----------------------------------------------------------------------===//


#include "CStdLib.h"

//
// The following functions have CStdLib wrapper versions in this file:
//  - stpcpy
//  - strchr
//  - strrchr
//  - strstr
//  - strcasestr
//  - strcat
//  - strncat
//  - strpbrk
//  - strcmp
//  - memcpy
//  - memmove
//  - mempcpy
//  - memset
//  - strcpy
//  - strlen
//  - strncpy
//  - strnlen
//  - strncmp
//  - memcmp
//  - strspn
//  - strcspn
//  - memchr
//  - memccpy
//


/*
 * pool_stpcpy()
 *
 * This is the non-debug version of pool_stpcpy_debug().
 *
 */
char *
pool_stpcpy(DebugPoolTy *dstPool,
            DebugPoolTy *srcPool,
            char *dst,
            const char *src,
            const uint8_t complete) {
  return pool_stpcpy_debug(dstPool, srcPool, dst, src, complete,
    DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace stpcpy()
 *
 * Copies the string src to dst and returns a pointer
 * to the nul terminator of dst.
 * 
 * Attempts to verify the following:
 *  - src is nul terminated within memory object bounds
 *  - src and dst do not overlap
 *  - dst is long enough to hold src.
 *
 * @param   dstPool    Pool handle for destination string's pool
 * @param   srcPool    Pool handle for destination string's pool
 * @param   dst        Pointer to destination of copy operation
 * @param   src        Pointer to string to copy
 * @param   complete   Completeness bitwise vector
 * @param   TAG        Tag information for debug
 * @param   SRC_INFO   Source and line number information
 * @return             Returns a pointer to the nul-terminator of dst.
 *
 */
char *
pool_stpcpy_debug(DebugPoolTy *dstPool,
                  DebugPoolTy *srcPool,
                  char *dst,
                  const char *src,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {
  void *dstBegin = NULL, *dstEnd = NULL, *srcBegin = NULL, *srcEnd = NULL;
  size_t srcLen = 0;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound, srcFound;

  // Find the destination and source strings in their pools.
  if (!(dstFound = pool_find(dstPool, dst, dstBegin, dstEnd))
        && dstComplete) {
    std::cout << "Could not find destination object in pool!\n";
    LOAD_STORE_VIOLATION(dst, dstPool, SRC_INFO_ARGS);
  }
  if (!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
        && srcComplete) {
    std::cout << "Could not find source object in pool\n";
    LOAD_STORE_VIOLATION(src, srcPool, SRC_INFO_ARGS);
  }

  // Check if source is terminated.
  if (srcFound && !isTerminated(src, srcEnd, srcLen)) {
    std::cout << "Source string not terminated within bounds!\n";
    C_LIBRARY_VIOLATION(src, srcPool, "stpcpy", SRC_INFO_ARGS);
  }

  // The remainder of the checks require both objects to be found.
  if (dstFound && srcFound) {
    // Check for overlap of objects.
    if (isOverlapped(dst, &dst[srcLen], src, &src[srcLen])) {
      std::cout << "Copying overlapping strings has undefined behavior!\n";
      C_LIBRARY_VIOLATION(dst, dstPool, "stpcpy", SRC_INFO_ARGS);
    }
    // dstLen is the maximum length string that dst can hold.
    size_t dstLen = (char *) dstEnd - dst;
    // Check for overflow of dst.
    if (srcLen > dstLen) {
      std::cout << "Destination object too short to hold string!\n";
      WRITE_VIOLATION(dst, dstPool, dstLen, srcLen, SRC_INFO_ARGS);
    }
  }

  return stpcpy(dst, src);
}


/*
 * pool_strchr()
 *
 * This is the non-debug version of pool_strchr_debug().
 *
 */
char *
pool_strchr(DebugPoolTy *sp, const char *s, int c, const uint8_t complete) {
  return pool_strchr_debug(sp, s, c, complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strchr(), debug version
 *
 * Returns pointer to the first instance of the given character in the string, or
 * NULL if not found.
 *
 * Ensures the following:
 *  - string argument points to a valid string
 *
 * @param   sPool     Pool handle for string
 * @param   s         String pointer
 * @param   c         Character to find
 * @param   complete  Completeness bitwise vector
 * @param   TAG       Tag information for debug
 * @param   SRC_INFO  Source and line number information
 * @return  Pointer to first instance of c in s or NULL
 *
 */
char *
pool_strchr_debug(DebugPoolTy *sPool,
                  const char *s,
                  int c,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {
  validStringCheck(s, sPool, ARG1_COMPLETE(complete), "strchr", SRC_INFO_ARGS);
  return strchr((char*)s, c);
}


/*
 * pool_strrchr()
 *
 * This is the non-debug version of pool_strchr_debug().
 *
 */
char *
pool_strrchr(DebugPoolTy *sPool,
             const char *s,
             int c,
             const uint8_t complete) {
  return pool_strrchr_debug(sPool, s, c, complete, DEFAULT_TAG,
    DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strrchr()
 *
 * @param   sPool  Pool handle for string
 * @param   s      String pointer
 * @param   c      Character to find
 * @return  Pointer to last instance of c in s or NULL
 */
char *
pool_strrchr_debug(DebugPoolTy *sPool,
                   const char *s,
                   int c,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO) {
  validStringCheck(s, sPool, ARG1_COMPLETE(complete), "strrchr", SRC_INFO_ARGS);
  return strrchr((char*)s, c);
}


/*
 * pool_strstr()
 *
 * This is the non-debug version of pool_strstr_debug().
 *
 */
char *
pool_strstr(DebugPoolTy *s1Pool,
            DebugPoolTy *s2Pool,
            const char *s1,
            const char *s2,
            const uint8_t complete) {
  return pool_strstr_debug(s1Pool, s2Pool, s1, s2, complete, DEFAULT_TAG,
    DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strstr(), debug version
 *
 * Searches for the first occurence of the substring s2 in s1.
 * Returns a pointer to the discovered substring, or NULL if not found.
 *
 * Attempts to verify that s1 and s2 are valid strings terminated within
 * their memory objects' boundaries.
 *
 * @param   s1Pool    Pool handle for s1
 * @param   s2Pool    Pool handle for s2
 * @param   s1        Pointer to string to be searched
 * @param   s2        Pointer to substring to search for
 * @param   complete  Completeness bitwise vector
 * @param   TAG       Tag information for debug
 * @param   SRC_INFO  Source and line number information for debug
 * @retrun            Returns a pointer to the first instance of s2 in s1,
 *                    or NULL if none exists.
 *
 */
char *
pool_strstr_debug(DebugPoolTy *s1Pool,
                  DebugPoolTy *s2Pool,
                  const char *s1,
                  const char *s2,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {
  validStringCheck(s1, s1Pool, ARG1_COMPLETE(complete), "strstr",
    SRC_INFO_ARGS);
  validStringCheck(s2, s2Pool, ARG2_COMPLETE(complete), "strstr",
    SRC_INFO_ARGS);
  return strstr((char*)s1, s2);
}


/*
 * pool_strcasestr()
 *
 * This is the non-debug version of pool_strcasestr_debug().
 *
 */
char *
pool_strcasestr(DebugPoolTy *s1Pool,
                DebugPoolTy *s2Pool,
                const char *s1,
                const char *s2,
                const uint8_t complete) {
  return pool_strcasestr_debug(s1Pool, s2Pool, s1, s2, complete, DEFAULT_TAG,
    DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strcasestr(), debug version
 *
 * Searches for the first occurence of the substring s2 in s1, case
 * insensitively.
 * Returns a pointer to the discovered substring, or NULL if not found.
 *
 * Attempts to verify that s1 and s2 are valid strings terminated within
 * their memory objects' boundaries.
 *
 * @param   s1Pool    Pool handle for s1
 * @param   s2Pool    Pool handle for s2
 * @param   s1        Pointer to string to be searched
 * @param   s2        Pointer to substring to search for
 * @param   complete  Completeness bitwise vector
 * @param   TAG       Tag information for debug
 * @param   SRC_INFO  Source and line number information for debug
 * @retrun            Returns a pointer to the first instance of s2 in s1,
 *                    disregarding case, or NULL if none exists.
 *
 */
char *
pool_strcasestr_debug(DebugPoolTy *s1Pool,
                      DebugPoolTy *s2Pool,
                      const char *s1,
                      const char *s2,
                      const uint8_t complete,
                      TAG,
                      SRC_INFO) {
  validStringCheck(s1, s1Pool, ARG1_COMPLETE(complete), "strcasestr",
    SRC_INFO_ARGS);
  validStringCheck(s2, s2Pool, ARG2_COMPLETE(complete), "strcasestr",
    SRC_INFO_ARGS);
  return strcasestr((char*)s1, s2);
}


/*
 * pool_strcat()
 *
 * This is the non-debug version of pool_strcat_debug().
 *
 */
char *
pool_strcat(DebugPoolTy *dp,
            DebugPoolTy *sp,
            char *d,
            const char *s,
            const unsigned char c) {
  return pool_strcat_debug(dp, sp, d, s, c, DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strcat(), debug version
 *
 * Appends the source string to the end of the destination string.
 * Attempts to verify the following:
 *  - source and destination pointers point to valid strings
 *  - the destination string's object has enough space to hold the
 *    concatenation in memory.
 *
 * @param  dp    Pool handle for destination string
 * @param  sp    Pool handle for source string
 * @param  d     Pointer to the destination string
 * @param  s     Pointer to the source string
 * @param  c     Bitwise vector holding completeness information
 *               for source and destination strings
 * @param  TAG   Tag information for debug
 * @param  SRC_INFO Source and line number information.
 * @return       This returns the pointer to the destination string.
 *
 */
char *
pool_strcat_debug(DebugPoolTy *dstPool,
                  DebugPoolTy *srcPool,
                  char *dst,
                  const char *src,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {
  size_t srcLen = 0, dstLen = 0, maxLen, catLen;
  void *dstBegin = NULL, *dstEnd = NULL;
  void *srcBegin = NULL, *srcEnd = NULL;
  char *dstNulPosition;
  bool terminated = true;
  bool srcObjFound, dstObjFound;
  const bool srcComplete = ARG1_COMPLETE(complete);
  const bool dstComplete = ARG2_COMPLETE(complete);

  // Find the strings' memory objects in the pool.
  if (!(srcObjFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd)) &&
      srcComplete) {
    std::cout << "Destination string not found in pool\n";
    LOAD_STORE_VIOLATION(dstBegin, dstPool, SRC_INFO_ARGS);
  }
  if (!(dstObjFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd)) &&
      dstComplete) {
    std::cout << "Source string not found in pool!\n";
    LOAD_STORE_VIOLATION(srcBegin, srcPool, SRC_INFO_ARGS);
  }

  // Check if both src and dst are terminated, if they were found in their pool.
  if (dstObjFound && !isTerminated(dst, dstEnd, dstLen)) {
    terminated = false;
    std::cout << "Destination not terminated within bounds\n";
    C_LIBRARY_VIOLATION(dst, dstPool, "strcat", SRC_INFO_ARGS);
  }
  if (srcObjFound && !isTerminated(src, srcEnd, srcLen)) {
    terminated = false;
    std::cout << "Source not terminated within bounds\n";
    C_LIBRARY_VIOLATION(src, srcPool, "strcat", SRC_INFO_ARGS);
  }

  // The remainder of the checks require both memory objects to have been found
  // in the pool.
  if (srcObjFound && dstObjFound) {

    // If both src and dst are terminated, check for string overlap.
    // Overlap occurs exactly when they share the same nul terminator in memory.
    if (terminated && &dst[dstLen] == &src[srcLen]) {
      std::cout << "Concatenating overlapping strings is undefined\n";
      C_LIBRARY_VIOLATION(dst, dstPool, "strcat", SRC_INFO_ARGS);
    }

    // maxLen is the maximum length string dst can hold without going out of bounds
    maxLen  = (char *) dstEnd - dst;
    // catLen is the length of the string resulting from concatenation.
    catLen  = srcLen + dstLen;

    // Check if the concatenation writes out of bounds.
    if (catLen > maxLen) {
      std::cout << "Concatenation violated destination bounds!\n";
      WRITE_VIOLATION(dstBegin, dstPool, maxLen + 1, catLen + 1, SRC_INFO_ARGS);
    }

    // Append at the end of dst so concatenation doesn't have to scan dst again.
    dstNulPosition = &dst[dstLen];
    strncat(dstNulPosition, src, srcLen);
    return dst;
  }
  else
    return strcat(dst, src);
}


/*
 * pool_strncat()
 *
 * This is the non-debug version of pool_strncat_debug().
 *
 */
char *
pool_strncat(DebugPoolTy *dstPool,
             DebugPoolTy *srcPool,
             char *dst,
             const char *src,
             size_t n,
             const uint8_t complete)
{
  return pool_strncat_debug(dstPool, srcPool, dst, src, n, complete,
    DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strncat()
 *
 * Appends at most n characters of src onto the end of the string dst
 * and then adds a nul terminator.
 *
 * Checks for the following:
 *  - src and dst are non-null
 *  - dst is terminated
 *  - dst has enough space to hold the whole concatention
 *  - src and dst do not overlap
 *  - if src is unterminated, the first n characters of src fall within
 *    the boundaries of src.
 *
 * @param  dstPool  Pool handle for destination string
 * @param  srcPool  Pool handle for source string
 * @param  dst      Destination string pointer
 * @param  src      Source string pointer
 * @param  n        Number of characters to copy over
 * @param  complete Completeness bitwise vector
 * @param  TAG      Tag debug information
 * @param  SRC_INFO Source and line number information
 * @return          Destination string pointer
 *
 */
char *
pool_strncat_debug(DebugPoolTy *dstPool,
                   DebugPoolTy *srcPool,
                   char *dst,
                   const char *src,
                   size_t n,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO) {
  void *dstBegin = NULL, *dstEnd = NULL;
  void *srcBegin = NULL, *srcEnd = NULL;
  size_t dstLen = 0, srcLen = 0, maxLen, catLen, srcAmt;
  char *dstNulPosition;
  bool dst_terminated = true;
  bool srcObjFound, dstObjFound;
  const bool srcComplete = ARG1_COMPLETE(complete);
  const bool dstComplete = ARG2_COMPLETE(complete);
 
  // Retrieve destination and source string memory objects from pool.
  if (!(dstObjFound = pool_find(dstPool, (void *) dst, dstBegin, dstEnd)) &&
      dstComplete) {
    std::cout << "Destination string not found in pool!\n";  
    LOAD_STORE_VIOLATION(dstBegin, dstPool, SRC_INFO_ARGS);
  }
  if (!(srcObjFound = pool_find(srcPool, (void *) src, srcBegin, srcEnd)) &&
      srcComplete) {
    std::cout << "Source string not found in pool!\n";  
    LOAD_STORE_VIOLATION(srcBegin, srcPool, SRC_INFO_ARGS);
  }

  // Check if dst is nul terminated.
  if (dstObjFound && !isTerminated(dst, dstEnd, dstLen)) {
    dst_terminated = false;
    std::cout << "String not terminated within bounds\n";
    C_LIBRARY_VIOLATION(dst, dstPool, "strncat", SRC_INFO_ARGS);
  }

  // According to POSIX, src doesn't have to be nul-terminated.
  // If it isn't, ensure strncat that doesn't read beyond the bounds of src.
  if (srcObjFound && !isTerminated(src, srcEnd, srcLen) && srcLen < n) {
    std::cout << "Source object too small\n";
    OOB_VIOLATION(src, srcPool, src, srcLen, SRC_INFO_ARGS);
  }

  // The remaining checks require destination and source objects to be found.
  if (srcObjFound && dstObjFound) {

    // Determine the amount of characters to be copied over from src.
    // This is either n or the length of src, whichever is smaller.
    srcAmt = std::min(srcLen, n);

    // Check for undefined behavior due to overlapping objects.
    // Overlap occurs when the characters to be copied from src
    // end inside the dst string.
    if (dst_terminated && dst < &src[srcAmt] && &src[srcAmt] <= &dst[dstLen]) {
      std::cout << "Concatenating overlapping objects is undefined\n";
      C_LIBRARY_VIOLATION(dst, dstPool, "strncat", SRC_INFO_ARGS);
    }

    // maxLen is the maximum length string dst can hold without overflowing.
    maxLen = (char *) dstEnd - dst;
    // catLen is the length of the string resulting from the concatenation.
    catLen = srcAmt + dstLen;

    // Check if the copy operation would go beyong the bounds of dst.
    if (catLen > maxLen) {
      std::cout << "Concatenation violated destination bounds!\n";
      WRITE_VIOLATION(dst, dstPool, 1+maxLen, 1+catLen, SRC_INFO_ARGS);
    }

    // Start concatenation the end of dst so strncat() doesn't have to scan dst
    // all over again.
    dstNulPosition = &dst[dstLen];
    strncat(dstNulPosition, src, srcAmt);

    // strncat() the returns destination string.
    return dst;
  }
  else
    return strncat(dst, src, n);
}


/*
 * pool_strpbrk()
 *
 * This is the non-debug version of pool_strpbrk_debug().
 *
 */
char *
pool_strpbrk(DebugPoolTy *sp,
             DebugPoolTy *ap,
             const char *s,
             const char *a,
             const uint8_t complete) {
  return pool_strpbrk_debug(sp, ap, s, a, complete,
    DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strpbrk()
 *
 * Searches for the first instance in s of any character in a, and returns a
 * pointer to that instance, or returns NULL if no instance was found.
 *
 * Attempts to verify that both s and a are valid strings terminated within
 * their memory objects' boundaries.
 *
 * @param   sPool  Pool handle for source string
 * @param   aPool  Pool handle for accept string
 * @param   s      String pointer
 * @param   a      Pointer to string of characters to find
 * @return  Pointer to first instance in s of some character in s, or NULL
 */
char *
pool_strpbrk_debug(DebugPoolTy *sPool,
                   DebugPoolTy *aPool,
                   const char *s,
                   const char *a,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO) {
  validStringCheck(s, sPool, ARG1_COMPLETE(complete), "strpbrk",
    DEFAULT_SRC_INFO);
  validStringCheck(a, aPool, ARG2_COMPLETE(complete), "strpbrk",
    DEFAULT_SRC_INFO);
  return strpbrk((char*)s, a);
}


int
pool_strcmp(DebugPoolTy *s1p,
            DebugPoolTy *s2p, 
            const char *s1, 
            const char *s2,
            const uint8_t complete){
  return pool_strcmp_debug(s1p,s2p,s1,s2,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strcmp()
 *
 * @param   str1Pool Pool handle for str1
 * @param   str2Pool Pool handle for str2
 * @param   str1     c string to be compared
 * @param   str2     c string to be compared
 * @return  
 */
int
pool_strcmp_debug(DebugPoolTy *str1Pool,
                  DebugPoolTy *str2Pool, 
                  const char *str1, 
                  const char *str2,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {

  size_t str1Size = 0, str2Size = 0;
  void *str1Begin =(void*)str1, *str1End = NULL, *str2Begin = (void*)str2, *str2End = NULL;

  const bool str1Complete = ARG1_COMPLETE(complete);
  const bool str2Complete = ARG2_COMPLETE(complete);
  bool str1ObjFound, str2ObjFound;

  if (!(str1ObjFound = pool_find(str1Pool, (void*)str1, str1Begin, str1End))
      && str1Complete) {
    std::cout << "String 1 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }
  if (!(str2ObjFound = pool_find(str2Pool, (void*)str2, str2Begin, str2End))
      && str2Complete) {
    std::cout << "String 2 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }

  // Check if strings are terminated.
  if (str1ObjFound && !isTerminated(str1, str1End, str1Size)) {
    std::cout << "String 1 not terminated within bounds!\n";
    OOB_VIOLATION(str1Begin, str1Pool, str1Begin, str1Size, SRC_INFO_ARGS);
  }
  if (str2ObjFound && !isTerminated(str2, str2End, str2Size)) {
    std::cout << "String 2 not terminated within bounds!\n";
    OOB_VIOLATION(str2Begin, str2Pool, str2Begin, str2Size, SRC_INFO_ARGS);
  }

  return strcmp(str1, str2);
}


/**
 * Secure runtime wrapper function to replace memcpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Destination memory area
 */
void *
pool_memcpy(DebugPoolTy *dstPool, 
            DebugPoolTy *srcPool, 
            void *dst, 
            const void *src, 
            size_t n,
            const uint8_t complete) {
  return pool_memcpy_debug(dstPool,srcPool,dst,src, n,complete,DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace memcpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Destination memory area
 */
void *
pool_memcpy_debug(DebugPoolTy *dstPool, 
                  DebugPoolTy *srcPool, 
                  void *dst, 
                  const void *src, 
                  size_t n,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO){

  size_t dstSize = 0, srcSize = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound = false, srcFound = false;

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd)) && dstComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd)) && srcComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  // Calculate the maximum number of bytes to copy.
  dstSize = (char *)dstEnd - (char *)dst + 1;
  srcSize = (char *)srcEnd - (char *)src + 1;

  // The remainder of the checks require the objects to have been located in
  // their pools.
  if (dstFound && srcFound){
    if (n > srcSize || n > dstSize){
      std::cout << "Cannot copy more bytes than the size of the source!\n";
      WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
    }

    if(isOverlapped(dst,(const char*)dst+n-1,src,(const char*)src+n-1)){ 
      std::cout<<"Two memory objects overlap each other!/n";
      LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
    }
  }

  memcpy(dst, src, n);

  return dst;
}


/**
 * Secure runtime wrapper function to replace memmove()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Destination memory area
 */
void *
pool_memmove(DebugPoolTy *dstPool, 
             DebugPoolTy *srcPool, 
             void *dst, 
             const void *src, 
             size_t n,
             const uint8_t complete) {
  return pool_memmove_debug(dstPool,srcPool,dst,src, n,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace memmove()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Destination memory area
 */
void *
pool_memmove_debug(DebugPoolTy *dstPool, 
                   DebugPoolTy *srcPool, 
                   void *dst, 
                   const void *src, 
                   size_t n,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO){

  size_t dstSize = 0, srcSize = 0, stop = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL;

  //assert(dstPool && srcPool && dst && src && "Null pool parameters!");
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound, srcFound;

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd))
     && dstComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
     && srcComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  if (dstFound && srcFound)
  {
    // Calculate the maximum number of bytes to copy.
    dstSize = (char *)dstEnd - (char *)dst + 1;
    srcSize = (char *)srcEnd - (char *)src + 1;
    stop = std::min(n, srcSize);
    if (n > srcSize || n > dstSize) {
      std::cout << "Cannot copy more bytes than the size of the source!\n";
      WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
    }
  }

  memmove(dst, src, stop);

  return dst;
}

#if !defined(__APPLE__)
/**
 * Secure runtime wrapper function to replace mempcpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Byte following the last written byte
 */
void *
pool_mempcpy(DebugPoolTy *dstPool, 
             DebugPoolTy *srcPool, 
             void *dst, 
             const void *src, 
             size_t n,
             const uint8_t complete) {
  return pool_mempcpy_debug(dstPool,srcPool,dst,src, n,complete,DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace mempcpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   n        Maximum number of bytes to copy
 * @return  Byte following the last written byte
 */
void *
pool_mempcpy_debug(DebugPoolTy *dstPool, 
                   DebugPoolTy *srcPool, 
                   void *dst, 
                   const void *src, 
                   size_t n,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO){

  size_t dstSize = 0, srcSize = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound, srcFound;

  // assert(dstPool && srcPool && dst && src && "Null pool parameters!");

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd))
     && dstComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
     && srcComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  if (dstFound && srcFound)
  {
    // Calculate the maximum number of bytes to copy.
    dstSize = (char *)dstEnd - (char *)dst + 1;
    srcSize = (char *)srcEnd - (char *)src + 1;
    // Check that copy size is too big
    if (n > srcSize || n > dstSize) {
      std::cout << "Cannot copy more bytes than the size of the source!\n";
      WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
    }
    // Check if two memory object overlap
    if(isOverlapped(dst,(const char*)dst+n-1,src,(const char*)src+n-1)){ 
      std::cout<<"Two memory objects overlap each other!/n";
      LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
    }
  }
 
  return  mempcpy(dst, src, n);
}
#endif


/**
 * Secure runtime wrapper function to replace memset()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      String pointer
 * @param   c           an int value to be set
 * @param   n           number of bytes to be set
 * @return  Pointer to memory area
 */
void *pool_memset(DebugPoolTy *stringPool, 
             void *string, 
             int c, 
             size_t n,
             const uint8_t complete) {
  return pool_memset_debug(stringPool, string, c, n,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);

}


/**
 * Secure runtime wrapper function to replace memset()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      String pointer
 * @param   c           an int value to be set
 * @param   n           number of bytes to be set
 * @return  Pointer to memory area
 */
void *
pool_memset_debug(DebugPoolTy *stringPool, 
                  void *string, 
                  int c, 
                  size_t n,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO){
  size_t stringSize = 0;
  void *stringBegin = string, *stringEnd = NULL;
  const bool objComplete = ARG1_COMPLETE(complete);
  bool objFound;

  assert(stringPool && string && "Null pool parameters!");

  //// Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(objFound = pool_find(stringPool, (void*)string, stringBegin, stringEnd))
     && objComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(string,stringPool, SRC_INFO_ARGS);
  }

  stringSize = (char *)stringEnd - (char *)string + 1;
  if (objFound && n > stringSize) {
    std::cout << "Cannot write more bytes than the size of the destination string!\n";
    WRITE_VIOLATION(stringBegin, stringPool, stringSize, 0, SRC_INFO_ARGS);
  }
  return memset(string, c, n);
}


/**
 * Secure runtime wrapper function to replace strcpy()
 *
 * @param   dstPool  Pool handle for destination buffer
 * @param   srcPool  Pool handle for source string
 * @param   dst      Destination string pointer
 * @param   src      Source string pointer
 * @return  Destination string pointer
 */
char *
pool_strcpy(DebugPoolTy *dstPool, 
            DebugPoolTy *srcPool, 
            char *dst, 
            const char *src, 
            const uint8_t complete) {
  return pool_strcpy_debug(dstPool, srcPool, dst, src, complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace strcpy()
 *
 * @param   dstPool  Pool handle for destination buffer
 * @param   srcPool  Pool handle for source string
 * @param   dst      Destination string pointer
 * @param   src      Source string pointer
 * @return  Destination string pointer
 */
char *
pool_strcpy_debug(DebugPoolTy *dstPool, 
                  DebugPoolTy *srcPool, 
                  char *dst, 
                  const char *src, 
                  const uint8_t complete, 
                  TAG,
                  SRC_INFO) {
  size_t dstSize = 0, srcSize = 0, len = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound, srcFound;

  // Ensure all valid pointers.
  // assert(dstPool && srcPool && dst && src && "Null pool parameters!");
  
  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd))
     && dstComplete) {
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
     && srcComplete) {
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  // Calculate the maximum number of bytes to copy.
  dstSize = (char *)dstEnd - (char *)dst + 1;
  srcSize = (char *)srcEnd - (char *)src + 1;
  if (srcFound)
  {
    len = strnlen(src,srcSize);

    if (len == srcSize) {
      std::cout << "Source string is not NULL terminated!\n";
      OOB_VIOLATION(src,srcPool,src,len,SRC_INFO_ARGS);
    }

    if (dstFound)
    {
      if (len+1 > dstSize) {
        std::cout << "Cannot copy more bytes than the size of the source!\n";
        WRITE_VIOLATION(dstBegin, dstPool, dstSize, srcSize, SRC_INFO_ARGS);
      }

      if(isOverlapped(dst,(const char*)dst+len,src,(const char*)src+len)){ 
        std::cout<<"Two memory objects overlap each other!\n";
        LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
      }
    }
  }

  strncpy(dst, src, len+1);

  return dst;
}


/**
 * Secure runtime wrapper function to replace strlen()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      String pointer
 * @return  Length of the string
 */
size_t
pool_strlen(DebugPoolTy *stringPool, 
            const char *string, 
            const uint8_t complete) {
  return pool_strlen_debug(stringPool, string, 
    complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}

/**
 * Secure runtime wrapper function to replace strlen()
 *
 * @param   strPool  Pool handle for the string
 * @param   str      String pointer
 * @return  Length of the string
 */
size_t
pool_strlen_debug(DebugPoolTy *strPool, 
                  const char *str, 
                  const uint8_t complete, 
                  TAG, 
                  SRC_INFO) {
  const bool strComplete = ARG1_COMPLETE(complete);
  bool strFound;
  size_t len = 0;
  void *strBegin = 0, *strEnd = 0;

  if (!(strFound = pool_find(strPool, (void *) str, strBegin, strEnd)) &&
      strComplete)
  {
    LOAD_STORE_VIOLATION(str, strPool, SRC_INFO_ARGS);
  }
  if (strFound)
  {
    if (!isTerminated(str, strEnd, len))
      C_LIBRARY_VIOLATION(str, strPool, "strlen", SRC_INFO_ARGS);
    else
      return len;
  }
  return strlen(str);
}

//// FIXME: WHen it is tested, compiled program outputs "Illegal Instruction"
/**
 * Secure runtime wrapper function to replace strncpy()
 *
 * @param   dstPool  Pool handle for destination buffer
 * @param   srcPool  Pool handle for source string
 * @param   dst      Destination string pointer
 * @param   src      Source string pointer
 * @param   n        Maximum number of bytes to copy
 * @return  Destination string pointer
 */
char *
pool_strncpy(DebugPoolTy *dstPool, 
             DebugPoolTy *srcPool, 
             char *dst, 
             const char *src, 
             size_t n,
             const uint8_t complete){
  return pool_strncpy_debug(dstPool,srcPool,dst,src, n,
    complete,DEFAULT_TAG, DEFAULT_SRC_INFO);
}

/**
 * Secure runtime wrapper function to replace strncpy()
 *
 * @param   dstPool  Pool handle for destination buffer
 * @param   srcPool  Pool handle for source string
 * @param   dst      Destination string pointer
 * @param   src      Source string pointer
 * @param   n        Maximum number of bytes to copy
 * @return  Destination string pointer
 */
char *
pool_strncpy_debug(DebugPoolTy *dstPool, 
                   DebugPoolTy *srcPool, 
                   char *dst, 
                   const char *src, 
                   size_t n, 
                   const uint8_t complete, 
                   TAG, 
                   SRC_INFO){
  size_t dstSize = 0, srcSize = 0, stop = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);
  bool dstFound, srcFound;

  // assert(dstPool && srcPool && dst && src && "Null pool parameters!");

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd)) &&
     dstComplete) {
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
     && srcComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  // Calculate the maximum number of bytes to copy.
  dstSize = (char *)dstEnd - (char *)dst + 1;
  srcSize = (char *)srcEnd - (char *)src + 1;
  stop = strnlen(src,srcSize);
  // If source string is not bounded and copy length is longer than the source object
  // Behavior is undefined
  if (srcFound && stop==srcSize && n > srcSize) {
    std::cout << "String is not bounded and copy length is out of bound!\n";
    WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
  }
  // Check if destination will be overflowed
  if (dstFound && n > dstSize) {
    std::cout << "Cannot copy more bytes than the size of the source!\n";
    WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
  }
  // Check if two strings are over lapped
  if(srcFound && dstFound &&
     isOverlapped(dst,(const char*)dst+stop-1,src,(const char*)src+stop-1)){ 
    std::cout<<"Two memory objects overlap each other!/n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  // Copy string 
  strncpy_asm(dst, src, stop+1);
  // Check whether result string is NULL terminated
  // FIXME: Is this necessary?
  if(dstFound && !isTerminated(dst,dstEnd,stop)){
    std::cout<<"NULL terminator is not copied!\n";
    OOB_VIOLATION(dst,dstPool,dst,stop,SRC_INFO_ARGS);
  }
  // Pad with zeros
  memset(dst+stop+1,0,n-stop-1);

  return dst;
}

/**
 * Secure runtime wrapper function to replace strnlen()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      String pointer
 * @return  Length of the string
 */
size_t
pool_strnlen(DebugPoolTy *stringPool, 
             const char *string, 
             size_t maxlen,
             const uint8_t complete) {
  return pool_strnlen_debug(stringPool, string, maxlen, 
    complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}

/**
 * Secure runtime wrapper function to replace strnlen()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      String pointer
 * @return  Length of the string
 */
size_t
pool_strnlen_debug(DebugPoolTy *stringPool, 
                   const char *string, 
                   size_t maxlen, 
                   const uint8_t complete, 
                   TAG, 
                   SRC_INFO) {
  size_t len = 0, difflen = 0;
  void *stringBegin = (char *)string, *stringEnd = NULL;
  const bool strComplete = ARG1_COMPLETE(complete);
  bool strFound;

  // assert(stringPool && string && "Null pool parameters!");
  // Retrieve string from the pool
  if(!(strFound = pool_find(stringPool, (void*)string, stringBegin, stringEnd))
     && strComplete) {
    std::cout<<"String not found in pool!\n";
    LOAD_STORE_VIOLATION(string,stringPool, SRC_INFO_ARGS);
  }

  difflen = (char *)stringEnd - (char *)string +1;
  len = strnlen(string, difflen);
  // If the string is not terminated within range and maxlen is bigger than object size
  if(strFound && maxlen > len && len==difflen){
    std::cout<<"String is not bounded!\n";
    OOB_VIOLATION(string,stringPool,string,difflen,SRC_INFO_ARGS);
  }
  return len;
}

/**
 * Secure runtime wrapper function to replace strncmp()
 *
 * @param   str1Pool Pool handle for string1
 * @param   str2Pool Pool handle for string2
 * @param   num      Maximum number of chars to compare
 * @param   str1     string1 to be compared
 * @param   str2     string2 to be compared
 * @return  position of first different character, or 0 it they are the same
 */
int
pool_strncmp(DebugPoolTy *s1p,
             DebugPoolTy *s2p, 
             const char *s1, 
             const char *s2,
             size_t num,
             const uint8_t complete){
  return pool_strncmp_debug(s1p,s2p,s1,s2,num,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}

/**
 * Secure runtime wrapper function to replace strncmp()
 *
 * @param   str1Pool Pool handle for string1
 * @param   str2Pool Pool handle for string2
 * @param   num      Maximum number of chars to compare
 * @param   str1     string1 to be compared
 * @param   str2     string2 to be compared
 * @return  position of first different character, or 0 it they are the same
 */
int
pool_strncmp_debug(DebugPoolTy *str1Pool,
                   DebugPoolTy *str2Pool, 
                   const char *str1, 
                   const char *str2,
                   size_t num,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO) {

  size_t str1Size = 0, str2Size = 0;
  void *str1Begin =(void*)str1, *str1End = NULL, *str2Begin = (void*)str2, *str2End = NULL;
  const bool str1Complete = ARG1_COMPLETE(complete);
  const bool str2Complete = ARG2_COMPLETE(complete);
  bool str1Found, str2Found;

  // assert(str1Pool && str2Pool && str2 && str1 && "Null pool parameters!");

  if (!(str1Found = pool_find(str1Pool, (void*)str1, str1Begin, str1End))
      && str1Complete) {
    std::cout << "String 1 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }
  if (!(str2Found = pool_find(str2Pool, (void*)str2, str2Begin, str2End))
      && str2Complete) {
    std::cout << "String 2 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }

  str1Size = (char*) str1End - str1+1;
  str2Size = (char*) str2End - str2+1;  

  if (str1Found && str1Size<num) {
    std::cout << "Possible read out of bound in string1!\n";
    OOB_VIOLATION(str1Begin, str1Pool, str1Begin, str1Size, SRC_INFO_ARGS);
  }
  if (str2Found && str2Size<num) {
    std::cout << "Possible read out of bound in string2!\n";
    OOB_VIOLATION(str2Begin, str2Pool, str2Begin, str2Size, SRC_INFO_ARGS);
  }

  return strncmp(str1, str2,num);
}

/**
 * Secure runtime wrapper function to replace memcmp()
 *
 * @param   str1Pool Pool handle for memory object1
 * @param   str2Pool Pool handle for memory object1
 * @param   num      Maximum number of bytes to compare
 * @param   str1     memory object1 to be compared
 * @param   str2     memory object2 to be compared
 * @return  position of first different character, or 0 it they are the same
 */
int
pool_memcmp(DebugPoolTy *s1p,
            DebugPoolTy *s2p, 
            const void *s1, 
            const void *s2,
            size_t num,
            const uint8_t complete){
  return pool_memcmp_debug(s1p,s2p,s1,s2,num,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}

/**
 * Secure runtime wrapper function to replace memcmp()
 *
 * @param   str1Pool Pool handle for memory object1
 * @param   str2Pool Pool handle for memory object1
 * @param   num      Maximum number of bytes to compare
 * @param   str1     memory object1 to be compared
 * @param   str2     memory object2 to be compared
 * @return  position of first different character, or 0 it they are the same
 */
int
pool_memcmp_debug(DebugPoolTy *str1Pool,
                  DebugPoolTy *str2Pool, 
                  const void *str1, 
                  const void *str2,
                  size_t num,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {

  size_t str1Size = 0, str2Size = 0;
  void *str1Begin =(void*)str1, *str1End = NULL, *str2Begin = (void*)str2, *str2End = NULL;
  const bool str1Complete = ARG1_COMPLETE(complete);
  const bool str2Complete = ARG2_COMPLETE(complete);
  bool str1Found, str2Found;

  // assert(str1Pool && str2Pool && str2 && str1 && "Null pool parameters!");

  if (!(str1Found = pool_find(str1Pool, (void*)str1, str1Begin, str1End))
      && str1Complete) {
    std::cout << "String 1 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }
  if (!(str2Found = pool_find(str2Pool, (void*)str2, str2Begin, str2End))
      && str2Complete) {
    std::cout << "String 2 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }

  str1Size = (char*) str1End - (char*)str1+1;
  str2Size = (char*) str2End - (char*)str2+1;  

  if (str1Found && str1Size<num) {
    std::cout << "Possible read out of bound in string1!\n";
    OOB_VIOLATION(str1Begin, str1Pool, str1Begin, str1Size, SRC_INFO_ARGS);
  }
  if (str2Found && str2Size<num) {
    std::cout << "Possible read out of bound in string2!\n";
    OOB_VIOLATION(str2Begin, str2Pool, str2Begin, str2Size, SRC_INFO_ARGS);
  }

  return memcmp(str1, str2,num);
}

/**
 * Secure runtime wrapper function to replace strspn()
 *
 * @param   str1Pool Pool handle for str1
 * @param   str2Pool Pool handle for str2
 * @param   str1     c string to be scanned
 * @param   str2     c string consisted of matching characters
 * @return  length if initial portion of str1, which consists of 
 *          characters only from str2.
 */
int
pool_strspn(DebugPoolTy *s1p,
            DebugPoolTy *s2p, 
            const char *s1, 
            const char *s2,
            const uint8_t complete){

  return pool_strspn_debug(s1p,s2p,s1,s2,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}
/**
 * Secure runtime wrapper function to replace strspn()
 *
 * @param   str1Pool Pool handle for str1
 * @param   str2Pool Pool handle for str2
 * @param   str1     c string to be compared
 * @param   str2     c string to be compared
 * @return  length if initial portion of str1, which consists of 
 *          characters only from str2.
 */
int
pool_strspn_debug(DebugPoolTy *str1Pool,
                  DebugPoolTy *str2Pool, 
                  const char *str1, 
                  const char *str2,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO) {

  size_t str1Size = 0, str2Size = 0;
  void *str1Begin =(void*)str1, *str1End = NULL, *str2Begin = (void*)str2, *str2End = NULL;
  const bool str1Complete = ARG1_COMPLETE(complete);
  const bool str2Complete = ARG2_COMPLETE(complete);
  bool str1Found, str2Found;

  // assert(str1Pool && str2Pool && str2 && str1 && "Null pool parameters!");

  if (!(str1Found = pool_find(str1Pool, (void*)str1, str1Begin, str1End))
      && str1Complete) {
    std::cout << "String 1 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }
  if (!(str2Found = pool_find(str2Pool, (void*)str2, str2Begin, str2End))
      && str2Complete) {
    std::cout << "String 2 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }

  // Check if strings are terminated.
  if (str1Found && !isTerminated(str1, str1End, str1Size)) {
    std::cout << "String 1 not terminated within bounds!\n";
    OOB_VIOLATION(str1Begin, str1Pool, str1Begin, str1Size, SRC_INFO_ARGS);
  }
  if (str2Found && !isTerminated(str2, str2End, str2Size)) {
    std::cout << "String 2 not terminated within bounds!\n";
    OOB_VIOLATION(str2Begin, str2Pool, str2Begin, str2Size, SRC_INFO_ARGS);
  }

  return strspn(str1, str2);
}

/**
 * Secure runtime wrapper function to replace strcspn()
 *
 * @param   str1Pool Pool handle for str1
 * @param   str2Pool Pool handle for str2
 * @param   str1     c string to be scanned
 * @param   str2     c string consisted of matching characters
 * @return  length if initial portion of str1, which does not 
 *          consist of any characters from str2.
 */
int pool_strcspn(DebugPoolTy *s1p,
          DebugPoolTy *s2p, 
                const char *s1, 
                const char *s2,
                const uint8_t complete){

  return pool_strcspn_debug(s1p,s2p,s1,s2,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);
}
/**
 * Secure runtime wrapper function to replace strcspn()
 *
 * @param   str1Pool Pool handle for str1
 * @param   str2Pool Pool handle for str2
 * @param   str1     c string to be compared
 * @param   str2     c string to be compared
 * @return  length if initial portion of str1, which does not 
 *          consist of any characters from str2.
 */
int pool_strcspn_debug(DebugPoolTy *str1Pool,
                       DebugPoolTy *str2Pool, 
                       const char *str1, 
                       const char *str2,
                       const uint8_t complete,
                       TAG,
                       SRC_INFO) {

  size_t str1Size = 0, str2Size = 0;
  void *str1Begin =(void*)str1, *str1End = NULL, *str2Begin = (void*)str2, *str2End = NULL;
  const bool str1Complete = ARG1_COMPLETE(complete);
  const bool str2Complete = ARG2_COMPLETE(complete);
  bool str1Found, str2Found;

  // assert(str1Pool && str2Pool && str2 && str1 && "Null pool parameters!");

  if (!(str1Found = pool_find(str1Pool, (void*)str1, str1Begin, str1End))
      && str1Complete) {
    std::cout << "String 1 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }
  if (!(str2Found = pool_find(str2Pool, (void*)str2, str2Begin, str2End))
      && str2Complete) {
    std::cout << "String 2 not found in pool!\n";
    LOAD_STORE_VIOLATION(str1Begin, str1Pool, SRC_INFO_ARGS);
  }

  // Check if strings are terminated.
  if (str1Found && !isTerminated(str1, str1End, str1Size)) {
    std::cout << "String 1 not terminated within bounds!\n";
    OOB_VIOLATION(str1Begin, str1Pool, str1Begin, str1Size, SRC_INFO_ARGS);
  }
  if (str2Found && !isTerminated(str2, str2End, str2Size)) {
    std::cout << "String 2 not terminated within bounds!\n";
    OOB_VIOLATION(str2Begin, str2Pool, str2Begin, str2Size, SRC_INFO_ARGS);
  }

  return strcspn(str1, str2);
}

/**
 * Secure runtime wrapper function to replace memchr()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      Memory object
 * @param   c           An int value to be found
 * @param   n           Number of bytes to search in
 * @return  Pointer to position where c is first found
 */
void *
pool_memchr(DebugPoolTy *stringPool, 
            void *string, 
            int c, 
            size_t n,
            const uint8_t complete) {
  return pool_memchr_debug(stringPool, string, c, n,complete, DEFAULT_TAG, DEFAULT_SRC_INFO);

}
/**
 * Secure runtime wrapper function to replace memchr()
 *
 * @param   stringPool  Pool handle for the string
 * @param   string      Memory object
 * @param   c           An int value to be found
 * @param   n           Number of bytes to search in
 * @return  Pointer to position where c is first found
 */
void *
pool_memchr_debug(DebugPoolTy *stringPool, 
                  void *string, int c, 
                  size_t n,
                  const uint8_t complete,
                  TAG,
                  SRC_INFO){
  size_t stringSize = 0;
  void *stringBegin = string, *stringEnd = NULL, *stop= NULL;
  const bool strComplete = ARG1_COMPLETE(complete);
  bool strFound;

  //assert(stringPool && string && "Null pool parameters!");

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(strFound = pool_find(stringPool, (void*)string, stringBegin, stringEnd))
     && strComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(string,stringPool, SRC_INFO_ARGS);
  }

  if (strFound)
  {
    stringSize = (char *)stringEnd - (char *)string + 1;
    stop = memchr(string,c,stringSize);
    if (stop && (char*)stop<(char*)string+std::min(n,stringSize))
      return stop;
    else {
      std::cout << "Possible read out of bound in memory object!\n";
      OOB_VIOLATION(stringBegin, stringPool, stringBegin, stringSize, SRC_INFO_ARGS);
      return NULL;
    }
  }
  else
    return memchr(string, c, n);
}

/**
 * Secure runtime wrapper function to replace memccpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   c        It stops copying when it sees this char
 * @param   n        Maximum number of bytes to copy
 * @return           A pointer to the first byte after c in dst or, 
 *                   If c was not found in the first n bytes of s2, it returns a null pointer.
 */
void *
pool_memccpy(DebugPoolTy *dstPool, 
             DebugPoolTy *srcPool, 
             void *dst, 
             const void *src, 
             char c,
             size_t n,
             const uint8_t complete) {
  return pool_memccpy_debug(dstPool,srcPool,dst,src, c, n,complete,DEFAULT_TAG, DEFAULT_SRC_INFO);
}


/**
 * Secure runtime wrapper function to replace memccpy()
 *
 * @param   dstPool  Pool handle for destination memory area
 * @param   srcPool  Pool handle for source memory area
 * @param   dst      Destination memory area
 * @param   src      Source memory area
 * @param   c        It stops copying when it sees this char
 * @param   n        Maximum number of bytes to copy
 * @return           A pointer to the first byte after c in dst or, 
 *                   If c was not found in the first n bytes of s2, it returns a null pointer.
 */
void *
pool_memccpy_debug(DebugPoolTy *dstPool, 
                   DebugPoolTy *srcPool, 
                   void *dst, 
                   const void *src, 
                   char c,
                   size_t n,
                   const uint8_t complete,
                   TAG,
                   SRC_INFO){

  size_t dstSize = 0, srcSize = 0;
  void *dstBegin = dst, *dstEnd = NULL, *srcBegin = (char *)src, *srcEnd = NULL, *stop = NULL;
  const bool dstComplete = ARG1_COMPLETE(complete);
  const bool srcComplete = ARG2_COMPLETE(complete);

  bool dstFound, srcFound;

  //assert(dstPool && srcPool && dst && src && "Null pool parameters!");

  // Retrieve both the destination and source buffer's bounds from the pool handle.
  if(!(dstFound = pool_find(dstPool, (void*)dst, dstBegin, dstEnd))
     && dstComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
  }
  if(!(srcFound = pool_find(srcPool, (void*)src, srcBegin, srcEnd))
     && srcComplete){
    std::cout<<"Memory object not found in pool!\n";
    LOAD_STORE_VIOLATION(src,srcPool, SRC_INFO_ARGS);
  }

  if (dstFound && srcFound)
  {
    // Calculate the maximum number of bytes to copy.
    dstSize = (char *)dstEnd - (char *)dst + 1;
    srcSize = (char *)srcEnd - (char *)src + 1;
    stop= memchr((void*)src,c,srcSize);
    if(!stop){
      
      if (n > srcSize) {
        std::cout << "Cannot copy more bytes than the size of the source!\n";
        WRITE_VIOLATION(srcBegin, srcPool, dstSize, srcSize, SRC_INFO_ARGS);
      }

      if (n >dstSize) {
        std::cout << "Cannot copy more bytes than the size of the destination!\n";
        WRITE_VIOLATION(dstBegin, dstPool, dstSize, srcSize, SRC_INFO_ARGS);
      }

      if(isOverlapped(dst,(const char*)dst+n-1,src,(const char*)src+n-1)){ 
        std::cout<<"Two memory objects overlap each other!/n";
        LOAD_STORE_VIOLATION(dst,dstPool, SRC_INFO_ARGS);
      }
    }
    
    if((size_t)((char*)stop-(char*)src+1)>dstSize){
      std::cout << "Cannot copy more bytes than the size of the destination!\n";
      WRITE_VIOLATION(dstBegin, dstPool, dstSize, srcSize, SRC_INFO_ARGS);
    }
  }

  memccpy(dst, src, c, n);

  return dst;
}