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.2

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: 
1.1.1.2 ! misho      19: /* 
        !            20:  * This file is part of Quagga.
        !            21:  *
        !            22:  * Quagga is free software; you can redistribute it and/or modify it
        !            23:  * under the terms of the GNU General Public License as published by the
        !            24:  * Free Software Foundation; either version 2, or (at your option) any
        !            25:  * later version.
        !            26:  *
        !            27:  * Quagga is distributed in the hope that it will be useful, but
        !            28:  * WITHOUT ANY WARRANTY; without even the implied warranty of
        !            29:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            30:  * General Public License for more details.
        !            31:  *
        !            32:  * You should have received a copy of the GNU General Public License
        !            33:  * along with Quagga; see the file COPYING.  If not, write to the Free
        !            34:  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
        !            35:  * 02111-1307, USA.  
        !            36:  */
1.1       misho      37: 
                     38: #include <zebra.h>
                     39: 
                     40: #ifndef HAVE_SNPRINTF
                     41: /*
                     42:  * snprint() is a real basic wrapper around the standard sprintf()
                     43:  * without any bounds checking
                     44:  */
                     45: int
                     46: snprintf(char *str, size_t size, const char *format, ...)
                     47: {
                     48:   va_list args;
                     49: 
                     50:   va_start (args, format);
                     51: 
                     52:   return vsprintf (str, format, args);
                     53: }
                     54: #endif
                     55: 
                     56: #ifndef HAVE_STRLCPY
                     57: /**
                     58:  * Like strncpy but does not 0 fill the buffer and always null 
                     59:  * terminates.
                     60:  *
                     61:  * @param bufsize is the size of the destination buffer.
                     62:  *
                     63:  * @return index of the terminating byte.
                     64:  **/
                     65: size_t
                     66: strlcpy(char *d, const char *s, size_t bufsize)
                     67: {
                     68:        size_t len = strlen(s);
                     69:        size_t ret = len;
                     70:        if (bufsize > 0) {
                     71:                if (len >= bufsize)
                     72:                        len = bufsize-1;
                     73:                memcpy(d, s, len);
                     74:                d[len] = 0;
                     75:        }
                     76:        return ret;
                     77: }
                     78: #endif
                     79: 
                     80: #ifndef HAVE_STRLCAT
                     81: /**
                     82:  * Like strncat() but does not 0 fill the buffer and always null 
                     83:  * terminates.
                     84:  *
                     85:  * @param bufsize length of the buffer, which should be one more than
                     86:  * the maximum resulting string length.
                     87:  **/
                     88: size_t
                     89: strlcat(char *d, const char *s, size_t bufsize)
                     90: {
                     91:        size_t len1 = strlen(d);
                     92:        size_t len2 = strlen(s);
                     93:        size_t ret = len1 + len2;
                     94: 
                     95:        if (len1 < bufsize - 1) {
                     96:                if (len2 >= bufsize - len1)
                     97:                        len2 = bufsize - len1 - 1;
                     98:                memcpy(d+len1, s, len2);
                     99:                d[len1+len2] = 0;
                    100:        }
                    101:        return ret;
                    102: }
                    103: #endif
                    104: 
                    105: #ifndef HAVE_STRNLEN
                    106: size_t
                    107: strnlen(const char *s, size_t maxlen)
                    108: {
                    109:   const char *p;
                    110:   return (p = (const char *)memchr(s, '\0', maxlen)) ? (size_t)(p-s) : maxlen;
                    111: }
                    112: #endif
                    113: 
                    114: #ifndef HAVE_STRNDUP
                    115: char *
                    116: strndup (const char *s, size_t maxlen)
                    117: {
                    118:     size_t len = strnlen (s, maxlen);
                    119:     char *new = (char *) malloc (len + 1);
                    120: 
                    121:     if (new == NULL)
                    122:       return NULL;
                    123: 
                    124:     new[len] = '\0';
                    125:     return (char *) memcpy (new, s, len);
                    126: }
                    127: #endif