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     ! 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