Logo Search packages:      
Sourcecode: batv-milter version File versions  Download package

strl.c

/*
 * Copyright (c) 1999-2002 Sendmail, Inc. and its suppliers.
 *    All rights reserved.
 *
 * By using this file, you agree to the terms and conditions set
 * forth in the LICENSE file which can be found at the top level of
 * the sendmail distribution.
 *
 */

#include <sm/gen.h>
SM_RCSID("@(#)$Id: strl.c,v 1.31 2002/01/20 01:41:25 gshapiro Exp $")
#include <sm/config.h>
#include <sm/string.h>

/*
**  Notice: this file is used by libmilter. Please try to avoid
**    using libsm specific functions.
*/

/*
**  XXX the type of the length parameter has been changed
**  from size_t to ssize_t to avoid theoretical problems with negative
**  numbers passed into these functions.
**  The real solution to this problem is to make sure that this doesn't
**  happen, but for now we'll use this workaround.
*/

/*
**  SM_STRLCPY -- size bounded string copy
**
**    This is a bounds-checking variant of strcpy.
**    If size > 0, copy up to size-1 characters from the nul terminated
**    string src to dst, nul terminating the result.  If size == 0,
**    the dst buffer is not modified.
**    Additional note: this function has been "tuned" to run fast and tested
**    as such (versus versions in some OS's libc).
**
**    The result is strlen(src).  You can detect truncation (not all
**    of the characters in the source string were copied) using the
**    following idiom:
**
**          char *s, buf[BUFSIZ];
**          ...
**          if (sm_strlcpy(buf, s, sizeof(buf)) >= sizeof(buf))
**                goto overflow;
**
**    Parameters:
**          dst -- destination buffer
**          src -- source string
**          size -- size of destination buffer
**
**    Returns:
**          strlen(src)
*/

size_t
sm_strlcpy(dst, src, size)
      register char *dst;
      register const char *src;
      ssize_t size;
{
      register ssize_t i;

      if (size-- <= 0)
            return strlen(src);
      for (i = 0; i < size && (dst[i] = src[i]) != 0; i++)
            continue;
      dst[i] = '\0';
      if (src[i] == '\0')
            return i;
      else
            return i + strlen(src + i);
}

/*
**  SM_STRLCAT -- size bounded string concatenation
**
**    This is a bounds-checking variant of strcat.
**    If strlen(dst) < size, then append at most size - strlen(dst) - 1
**    characters from the source string to the destination string,
**    nul terminating the result.  Otherwise, dst is not modified.
**
**    The result is the initial length of dst + the length of src.
**    You can detect overflow (not all of the characters in the
**    source string were copied) using the following idiom:
**
**          char *s, buf[BUFSIZ];
**          ...
**          if (sm_strlcat(buf, s, sizeof(buf)) >= sizeof(buf))
**                goto overflow;
**
**    Parameters:
**          dst -- nul-terminated destination string buffer
**          src -- nul-terminated source string
**          size -- size of destination buffer
**
**    Returns:
**          total length of the string tried to create
**          (= initial length of dst + length of src)
*/

size_t
sm_strlcat(dst, src, size)
      register char *dst;
      register const char *src;
      ssize_t size;
{
      register ssize_t i, j, o;

      o = strlen(dst);
      if (size < o + 1)
            return o + strlen(src);
      size -= o + 1;
      for (i = 0, j = o; i < size && (dst[j] = src[i]) != 0; i++, j++)
            continue;
      dst[j] = '\0';
      if (src[i] == '\0')
            return j;
      else
            return j + strlen(src + i);
}
/*
**  SM_STRLCAT2 -- append two strings to dst obeying length and
**          '\0' terminate it
**
**          strlcat2 will append at most len - strlen(dst) - 1 chars.
**          terminates with '\0' if len > 0
**          dst = dst "+" src1 "+" src2
**          use this instead of sm_strlcat(dst,src1); sm_strlcat(dst,src2);
**          for better speed.
**
**    Parameters:
**          dst -- "destination" string.
**          src1 -- "from" string 1.
**          src2 -- "from" string 2.
**          len -- max. length of "destination" string.
**
**    Returns:
**          total length of the string tried to create
**          (= initial length of dst + length of src)
**          if this is greater than len then an overflow would have
**          occurred.
**
*/

size_t
sm_strlcat2(dst, src1, src2, len)
      register char *dst;
      register const char *src1;
      register const char *src2;
      ssize_t len;
{
      register ssize_t i, j, o;

      /* current size of dst */
      o = strlen(dst);

      /* max. size is less than current? */
      if (len < o + 1)
            return o + strlen(src1) + strlen(src2);

      len -= o + 1;     /* space left in dst */

      /* copy the first string; i: index in src1; j: index in dst */
      for (i = 0, j = o; i < len && (dst[j] = src1[i]) != 0; i++, j++)
            continue;

      /* src1: end reached? */
      if (src1[i] != '\0')
      {
            /* no: terminate dst; there is space since i < len */
            dst[j] = '\0';
            return j + strlen(src1 + i) + strlen(src2);
      }

      len -= i;   /* space left in dst */

      /* copy the second string; i: index in src2; j: index in dst */
      for (i = 0; i < len && (dst[j] = src2[i]) != 0; i++, j++)
            continue;
      dst[j] = '\0';    /* terminate dst; there is space since i < len */
      if (src2[i] == '\0')
            return j;
      else
            return j + strlen(src2 + i);
}

/*
**  SM_STRLCPYN -- concatenate n strings and assign the result to dst
**          while obeying length and '\0' terminate it
**
**          dst = src1 "+" src2 "+" ...
**          use this instead of sm_snprintf() for string values
**          and repeated sm_strlc*() calls for better speed.
**
**    Parameters:
**          dst -- "destination" string.
**          len -- max. length of "destination" string.
**          n -- number of strings
**          strings...
**
**    Returns:
**          total length of the string tried to create
**          (= initial length of dst + length of src)
**          if this is greater than len then an overflow would have
**          occurred.
*/

size_t
#ifdef __STDC__
sm_strlcpyn(char *dst, ssize_t len, int n, ...)
#else /* __STDC__ */
sm_strlcpyn(dst, len, n, va_alist)
      register char *dst;
      ssize_t len;
      int n;
      va_dcl
#endif /* __STDC__ */
{
      register ssize_t i, j;
      char *str;
      SM_VA_LOCAL_DECL

      SM_VA_START(ap, n);

      if (len-- <= 0) /* This allows space for the terminating '\0' */
      {
            i = 0;
            while (n-- > 0)
                  i += strlen(SM_VA_ARG(ap, char *));
            SM_VA_END(ap);
            return i;
      }

      j = 0;      /* index in dst */

      /* loop through all source strings */
      while (n-- > 0)
      {
            str = SM_VA_ARG(ap, char *);

            /* copy string; i: index in str; j: index in dst */
            for (i = 0; j < len && (dst[j] = str[i]) != 0; i++, j++)
                  continue;

            /* str: end reached? */
            if (str[i] != '\0')
            {
                  /* no: terminate dst; there is space since j < len */
                  dst[j] = '\0';
                  j += strlen(str + i);
                  while (n-- > 0)
                        j += strlen(SM_VA_ARG(ap, char *));
                  SM_VA_END(ap);
                  return j;
            }
      }
      SM_VA_END(ap);

      dst[j] = '\0';    /* terminate dst; there is space since j < len */
      return j;
}

#if 0
/*
**  SM_STRLAPP -- append string if it fits into buffer.
**
**    If size > 0, copy up to size-1 characters from the nul terminated
**    string src to dst, nul terminating the result.  If size == 0,
**    the dst buffer is not modified.
**
**    This routine is useful for appending strings in a loop, e.g, instead of
**    s = buf;
**    for (ptr, ptr != NULL, ptr = next->ptr)
**    {
**          (void) sm_strlcpy(s, ptr->string, sizeof buf - (s - buf));
**          s += strlen(s);
**    }
**    replace the loop body with:
**          if (!sm_strlapp(*s, ptr->string, sizeof buf - (s - buf)))
**                break;
**    it's faster...
**
**    XXX interface isn't completely clear (yet), hence this code is
**    not available.
**
**
**    Parameters:
**          dst -- (pointer to) destination buffer
**          src -- source string
**          size -- size of destination buffer
**
**    Returns:
**          true if strlen(src) < size
**
**    Side Effects:
**          modifies dst if append succeeds (enough space).
*/

bool
sm_strlapp(dst, src, size)
      register char **dst;
      register const char *src;
      ssize_t size;
{
      register size_t i;

      if (size-- <= 0)
            return false;
      for (i = 0; i < size && ((*dst)[i] = src[i]) != '\0'; i++)
            continue;
      (*dst)[i] = '\0';
      if (src[i] == '\0')
      {
            *dst += i;
            return true;
      }

      /* undo */
      (*dst)[0] = '\0';
      return false;
}
#endif /* 0 */

Generated by  Doxygen 1.6.0   Back to index