str_util.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: str_util.c 1.5 2018/08/23 13:07:16 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Meinberg Library module providing portable, safe string functions.
 *
 * -----------------------------------------------------------------------
 *  $Log: str_util.c $
 *  Revision 1.5  2018/08/23 13:07:16  martin
 *  Moved the snprintf() safety checks to new inline functions that
 *  can also be used called from specific kernel mode functions.
 *  Unified variable naming.
 *  More common __attribute__ syntax.
 *  Revision 1.4  2018/06/25 13:22:42  martin
 *  Many functios return int rather than size_t, like standard
 *  library functions.
 *  do_str_copy_safe() now returns the number of chars copied.
 *  Revision 1.3  2016/10/24 08:10:04  thomas-b
 *  Fixed counter var check in mbg_memcpy_reversed
 *  Revision 1.2  2016/08/05 12:31:04  martin
 *  New functions mbg_memcpy() and mbg_memcpy_reversed().
 *  Moved string trim functions from cfg_util module here.
 *  Fixed some compiler warnings.
 *  Revision 1.1  2015/08/25 15:57:21  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _STR_UTIL
 #include <str_util.h>
#undef _STR_UTIL

#include <stdio.h>
#include <string.h>


#if defined( MBG_TGT_WIN32 ) && !defined( MBG_TGT_CVI )
  #define mbg_vsnprintf _vsnprintf
#else
  #define mbg_vsnprintf vsnprintf
#endif


#if defined( MBG_TGT_DOS )

static /*HDR*/
// Under DOS we use the Borland C/C++ v3.1 compiler by default, which
// doesn't provide a vsnprintf() function, so we use a simple replacement
// here. Since we share most of the source code between several target
// systems we assume that if our code works properly for other targets
// which really provide a vsnprintf() function then it also works properly
// under DOS. ;-)
int vsnprintf( char *s, size_t max_len, const char *fmt, va_list args )
{
  (void) max_len;  // quiet compiler warning "not used"

  return vsprintf( s, fmt, args );

}  // vsnprintf

#endif



/*HDR*/
__attribute__( ( format( printf, 3, 0 ) ) )
int vsnprintf_safe( char *s, size_t max_len, const char *fmt, va_list args )
{
  size_t n;

  if ( !mbg_buffer_specs_valid( s, max_len ) )
    return 0;     // nothing to do anyway

  n = mbg_vsnprintf( s, max_len, fmt, args );

  // Do some common checks to avoid subsequent buffer overflows, etc.
  return mbg_chk_snprint_results( n, s, max_len );

}  // vsnprintf_safe



/*HDR*/
__attribute__( ( format( printf, 3, 4 ) ) )
int snprintf_safe( char *s, size_t max_len, const char * fmt, ... )
{
  va_list args;
  int len;

  va_start( args, fmt );
  len = vsnprintf_safe( s, max_len, fmt, args );
  va_end( args);

  return len;

}  // snprintf_safe



static __mbg_inline
/* (explicitly excluded from doxygen)
 * @brief A portable, safe implementation of a copy function
 *
 * This is the basic function used to implemment ::strncpy_safe and
 * ::sn_cpy_safe. This function takes care that the copied string
 * is always terminated by 0, but any remaining buffer space
 * is *not* filled up with '0' characters.
 *
 * @param[out]     dst  Pointer to the output buffer
 * @param[in]      src  Pointer to the input buffer
 * @param[in]      n    Number of characters to copy at most
 * @param[in,out]  p_i  Pointer to a counter variable
 *
 * @return  The number of characters copied.
 *
 * @see ::vsnprintf_safe
 * @see ::snprintf_safe
 * @see ::strncpy_safe
 * @see ::sn_cpy_str_safe
 * @see ::sn_cpy_char_safe
 */
size_t do_str_copy_safe( char *dst, const char *src, size_t n )
{
  size_t i = 0;

  if ( n > 0 )
  {
    for (;;)
    {
      *dst = *src;

      if ( *dst == 0 )
        break;         // just copied the terminating 0, done

      if ( --n == 0 )  // no more space left in buffer
      {
        *dst = 0;      // force terminating 0
        break;
      }

      i++;             // count normal characters
      src++;
      dst++;
    }
  }

  return i;

}  // do_str_copy_safe



/*HDR*/
char *strncpy_safe( char *dst, const char *src, size_t max_len )
{
  do_str_copy_safe( dst, src, max_len );

  return dst;

}  // strncpy_safe



/*HDR*/
int sn_cpy_str_safe( char *dst, size_t max_len, const char *src )
{
  size_t n = do_str_copy_safe( dst, src, max_len );

  return _int_from_size_t( n );

}  // sn_cpy_str_safe



/*HDR*/
int sn_cpy_char_safe( char *dst, size_t max_len, char c )
{
  size_t n;
  char tmp_str[2];

  tmp_str[0] = c;
  tmp_str[1] = 0;

  n = do_str_copy_safe( dst, tmp_str, max_len );

  return _int_from_size_t( n );

}  // sn_cpy_char_safe



/*HDR*/
void trim_trailing_whitespace( char *s )
{
  char *cp;

  // set all trailing spaces to 0
  for ( cp = &s[strlen( s )]; cp > s;  )
  {
    --cp;

    if ( *cp >= ' ' )
      break;

    *cp = 0;
  }

}  // trim_trailing_whitespace



/*HDR*/
void trim_leading_whitespace( char *s )
{
  char *srcp;
  char *dstp;

  // Search the first non-space character.
  for ( srcp = s; *srcp; srcp++ )
    if ( *srcp > ' ' )
      break;

  // If there are leading spaces then srcp now
  // points behind the beginning of the string,
  // otherwise there's nothing to do.
  if ( srcp > s )
  {
    // Copy the remaining string.
    dstp = s;

    while ( *srcp )
      *dstp++ = *srcp++;

    *dstp = 0;
  }

}  // trim_leading_whitespace



/*HDR*/
void trim_whitespace( char *s )
{
  trim_trailing_whitespace( s );
  trim_leading_whitespace( s );

}  // trim_whitespace



/*HDR*/
void mbg_memcpy( void *dst, const void *src, size_t n_bytes )
{
  uint8_t *dstp = (uint8_t *) dst;
  uint8_t *srcp = (uint8_t *) src;

  while ( n_bytes-- )
    *dstp++ = *srcp++;

}  // mbg_memcpy



/*HDR*/
void mbg_memcpy_reversed( void *dst, const void *src, size_t n_bytes )
{
  if ( n_bytes )  // just to be sure it isn't 0
  {
    uint8_t *dstp = ( (uint8_t *) dst ) + n_bytes;
    uint8_t *srcp = ( (uint8_t *) src ) + n_bytes;

    while ( n_bytes-- )
      *(--dstp) = *(--srcp);
  }

}  // mbg_memcpy_reversed