Return to str.c CVS log

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

Annotation of embedaddon/quagga/lib/str.c, revision 1.1.1.1

1.1       misho       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