Line data    Source code

       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           6 : strlcpy(char *d, const char *s, size_t bufsize)
      49             : {
      50           6 :         size_t len = strlen(s);
      51           6 :         size_t ret = len;
      52           6 :         if (bufsize > 0) {
      53           6 :                 if (len >= bufsize)
      54           0 :                         len = bufsize-1;
      55           6 :                 memcpy(d, s, len);
      56           6 :                 d[len] = 0;
      57             :         }
      58           6 :         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          40 : strlcat(char *d, const char *s, size_t bufsize)
      72             : {
      73          40 :         size_t len1 = strlen(d);
      74          40 :         size_t len2 = strlen(s);
      75          40 :         size_t ret = len1 + len2;
      76             : 
      77          40 :         if (len1 < bufsize - 1) {
      78          40 :                 if (len2 >= bufsize - len1)
      79           0 :                         len2 = bufsize - len1 - 1;
      80          40 :                 memcpy(d+len1, s, len2);
      81          40 :                 d[len1+len2] = 0;
      82             :         }
      83          40 :         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