dsl_cpe_safec_wrapper.h

/******************************************************************************

                     Copyright 2018 - 2019 Intel Corporation

  For licensing information, see the file 'LICENSE' in the root folder of
  this software module.

******************************************************************************/

#ifndef _SAFEC_WRAPPER_H
#define _SAFEC_WRAPPER_H

#if defined (SAFEC_SUPPORT) && (SAFEC_SUPPORT == 3)
#include "safe_mem_lib.h"
#include "safe_str_lib.h"

#define cpe_control_memcpy_s memcpy_s
#define cpe_control_memset_s memset_s
#define cpe_control_strncpy_s strncpy_s
#define cpe_control_strnlen_s strnlen_s
#define cpe_control_strtok_s strtok_s
#define cpe_control_strcat_s strcat_s
#define cpe_control_vsnprintf_s vsnprintf_s

/* snprintf_s symbol is not exported in SafeC lib */
static int cpe_control_snprintf_s(char *dest,
                                  size_t dmax,
                                  const char *fmt,
                                  ...)
{
   va_list arg;
   int retVal;

   va_start(arg, fmt);
   retVal = vsnprintf_s(dest, dmax, fmt, arg);
   va_end(arg);

   return retVal;
}

#else

#warning "Safe C library is not available!"

#include <stddef.h>     /* size_t */
#include <stdarg.h>     /* va_list */
#include "drv_dsl_cpe_api_error.h"

static __inline__ size_t safec_wrapper_min(size_t a, size_t b)
{
   return a > b ? b : a;
}

#define cpe_control_memcpy_s(dest, destsz, src, srcsz) memcpy(dest, src, safec_wrapper_min(destsz,srcsz))
#define cpe_control_memset_s(dest, destsz, src, srcsz) memset(dest, src, safec_wrapper_min(destsz,srcsz))
#define cpe_control_strncpy_s(dest, destsz, src, srcsz) strncpy(dest, src, safec_wrapper_min(destsz,srcsz))

static size_t cpe_control_strnlen_s(const char *str,
                                    size_t smax)
{
   /* preconditions */
   if ((str == NULL) ||
       (smax == 0))
   {
      return 0;
   }

   /* main algorithm */
   size_t size = 0;

   for (const char *tmp = str; size < smax && *tmp != '\0'; ++size, ++tmp)
      ;

   return size;
}

static char *cpe_control_strtok_s(char *dest,
                                  size_t *dmax,
                                  const char *delim,
                                  char **ptr)
{
   /* preconditions */
   if ((delim == NULL) ||
      (ptr == NULL) ||
      (dmax == NULL) ||
      (*dmax == 0))
   {
      return NULL;
   }

   if ((dest == NULL) &&
       (*ptr == NULL))
   {
      return NULL;
   }

   /* special handling of function init call */
   if (dest != NULL)
   {
      *ptr = dest;
   }

   /* checking declared string length */
   if (cpe_control_strnlen_s(*ptr, (1 + *dmax)) >= *dmax)
   {
      return NULL;
   }

   /* main algorithm */
   char *pTmp;
   size_t nTmpSize = 0;

   pTmp = strtok(*ptr, delim);
   nTmpSize = cpe_control_strnlen_s(pTmp, *dmax);

   /* "+1" constant size of found delimiter */
   *dmax -= (nTmpSize+1);

   /* move after found delimitier */
   for (size_t i = 0; i <= nTmpSize; ++i, ++(*ptr))
      ;

   return pTmp;
}

static int cpe_control_pipe_strcat_s(char *dest,
                                     size_t destsz,
                                     char *src)
{
   /* preconditions */
   if ((dest == NULL) ||
       (src == NULL) ||
       (destsz == 0))
   {
      return -1;
   }

   if ((dest < src) &&
       (dest + destsz > src))
   {
      return -1;
   }

   const char* tmp = dest;

   for (; tmp <= (dest + destsz) && *tmp != '\0'; ++tmp)
      ;

   if (tmp >= (dest + destsz))
   {
      return -1;
   }

   /* main algorithm */
   strcat(dest, src);

   return 0;
}

static int cpe_control_snprintf_s(char *dest,
                                  size_t dmax,
                                  const char *fmt,
                                  ...)
{
   /* preconditions */
   if ((dest == NULL) ||
       (fmt == NULL) ||
       (dmax == 0))
   {
      return -1;
   }

   /* main algorithm */
   va_list arg;
   int retVal;

   va_start(arg, fmt);
   retVal = DSL_CPE_vsnprintf(dest, dmax, fmt, arg);
   va_end(arg);

   return retVal;
}

static int cpe_control_vsnprintf_s(char *dest,
                                   size_t dmax,
                                   const char *fmt,
                                   va_list vlist)
{
   /* preconditions */
   if ((dest == NULL) ||
       (fmt == NULL) ||
       (dmax == 0))
   {
      return -1;
   }

   /* main algorithm */
   return DSL_CPE_vsnprintf(dest, dmax, fmt, vlist);
}

#endif /* defined (SAFEC_SUPPORT) && (SAFEC_SUPPORT == 3) */

#endif /* _SAFEC_WRAPPER_H */