Return to str.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib

quagga

    1: /*
    2:  * zebra string function
    3:  *
    4:  * XXX This version of snprintf does not check bounds!
    5:  */
    6: 
    7: /*
    8:  The implementations of strlcpy and strlcat are copied from rsync (GPL):
    9:     Copyright (C) Andrew Tridgell 1998
   10:     Copyright (C) 2002 by Martin Pool
   11: 
   12:  Note that these are not terribly efficient, since they make more than one
   13:  pass over the argument strings.  At some point, they should be optimized.
   14:  
   15:  The implementation of strndup is copied from glibc-2.3.5:
   16:     Copyright (C) 1996, 1997, 1998, 2001, 2002 Free Software Foundation, Inc.
   17: */
   18: 
   19: 
   20: #include <zebra.h>
   21: 
   22: #ifndef HAVE_SNPRINTF
   23: /*
   24:  * snprint() is a real basic wrapper around the standard sprintf()
   25:  * without any bounds checking
   26:  */
   27: int
   28: snprintf(char *str, size_t size, const char *format, ...)
   29: {
   30:   va_list args;
   31: 
   32:   va_start (args, format);
   33: 
   34:   return vsprintf (str, format, args);
   35: }
   36: #endif
   37: 
   38: #ifndef HAVE_STRLCPY
   39: /**
   40:  * Like strncpy but does not 0 fill the buffer and always null 
   41:  * terminates.
   42:  *
   43:  * @param bufsize is the size of the destination buffer.
   44:  *
   45:  * @return index of the terminating byte.
   46:  **/
   47: size_t
   48: strlcpy(char *d, const char *s, size_t bufsize)
   49: {
   50: 	size_t len = strlen(s);
   51: 	size_t ret = len;
   52: 	if (bufsize > 0) {
   53: 		if (len >= bufsize)
   54: 			len = bufsize-1;
   55: 		memcpy(d, s, len);
   56: 		d[len] = 0;
   57: 	}
   58: 	return ret;
   59: }
   60: #endif
   61: 
   62: #ifndef HAVE_STRLCAT
   63: /**
   64:  * Like strncat() but does not 0 fill the buffer and always null 
   65:  * terminates.
   66:  *
   67:  * @param bufsize length of the buffer, which should be one more than
   68:  * the maximum resulting string length.
   69:  **/
   70: size_t
   71: strlcat(char *d, const char *s, size_t bufsize)
   72: {
   73: 	size_t len1 = strlen(d);
   74: 	size_t len2 = strlen(s);
   75: 	size_t ret = len1 + len2;
   76: 
   77: 	if (len1 < bufsize - 1) {
   78: 		if (len2 >= bufsize - len1)
   79: 			len2 = bufsize - len1 - 1;
   80: 		memcpy(d+len1, s, len2);
   81: 		d[len1+len2] = 0;
   82: 	}
   83: 	return ret;
   84: }
   85: #endif
   86: 
   87: #ifndef HAVE_STRNLEN
   88: size_t
   89: strnlen(const char *s, size_t maxlen)
   90: {
   91:   const char *p;
   92:   return (p = (const char *)memchr(s, '\0', maxlen)) ? (size_t)(p-s) : maxlen;
   93: }
   94: #endif
   95: 
   96: #ifndef HAVE_STRNDUP
   97: char *
   98: strndup (const char *s, size_t maxlen)
   99: {
  100:     size_t len = strnlen (s, maxlen);
  101:     char *new = (char *) malloc (len + 1);
  102: 
  103:     if (new == NULL)
  104:       return NULL;
  105: 
  106:     new[len] = '\0';
  107:     return (char *) memcpy (new, s, len);
  108: }
  109: #endif