utils.c

   1 /* usmb - mount SMB shares via FUSE and Samba
   2  * Copyright (C) 2006-2010 Geoff Johnstone
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 3 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include "config.h"
  18 #include <assert.h>
  19 #include <errno.h>
  20 #include <limits.h>
  21 #include <stdarg.h>
  22 #include <stddef.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "utils.h"
  27
  28
  29
  30 #define INIT_LEN 256
  31 char * concat_strings (int num, ...)
  32 {
  33   va_list ap;
  34
  35   char *base, *out;
  36
  37   base = out = malloc (INIT_LEN);
  38   if (NULL == base)
  39     return NULL;
  40
  41   size_t buff_size = INIT_LEN;
  42
  43   va_start (ap, num);
  44   for (int i = 0; i < num; ++i)
  45   {
  46     const char *next = va_arg (ap, const char *);
  47     assert (NULL != next);
  48
  49     size_t next_len = strlen (next);
  50     /*LINTED*/
  51     size_t required = (out - base) + next_len + 1;
  52
  53     if (buff_size < required)
  54     {
  55       while (buff_size < required)
  56       {
  57         size_t dbl_len = buff_size * 2;
  58         if (dbl_len < buff_size)
  59         {
  60           free (base);
  61           va_end (ap);
  62           return NULL;
  63         }
  64
  65         buff_size = dbl_len;
  66       }
  67
  68       /*LINTED*/
  69       ptrdiff_t diff = out - base;
  70
  71       char *newbase = realloc (base, buff_size);
  72       if (NULL == newbase)
  73       {
  74         free (base);
  75         va_end (ap);
  76         return NULL;
  77       }
  78
  79       base = newbase;
  80       out = base + diff;
  81     }
  82
  83     memcpy (out, next, next_len);
  84     out += next_len;
  85   }
  86   va_end (ap);
  87
  88   *out = '\0';
  89   return base;
  90 }
  91
  92
  93 char * xstrdup (const char *in)
  94 {
  95   char *out = NULL;
  96
  97   if (NULL != in)
  98   {
  99     size_t len = strlen (in) + 1;
 100
 101     if ((out = malloc (len)))
 102       memcpy (out, in, len);
 103   }
 104
 105   return out;
 106 }
 107
 108
 109 // the const here lets us pass a pointer to const
 110 void xfree (const void *ptr)
 111 {
 112   if (NULL != ptr)
 113     free ((void *)ptr);
 114 }
 115
 116
 117 void clear_and_free (char *ptr)
 118 {
 119   if (NULL != ptr)
 120   {
 121     for (char *pch = ptr; '\0' != *pch; ++pch)
 122       *pch = '\0';
 123
 124     free (ptr);
 125   }
 126 }
 127
 128
 129 void free_errno (const void *ptr)
 130 {
 131   int err = errno;
 132   free ((void *)ptr);
 133   errno = err;
 134 }
 135
 136
 137 void xfree_errno (const void *ptr)
 138 {
 139   int err = errno;
 140   xfree (ptr);
 141   errno = err;
 142 }
 143
 144
 145 bool bsnprintf (char *str, size_t size, const char *format, ...)
 146 {
 147   va_list ap;
 148   bool ret;
 149
 150   va_start (ap, format);
 151   ret = bvsnprintf (str, size, format, ap);
 152   va_end (ap);
 153
 154   return ret;
 155 }
 156
 157
 158 bool bvsnprintf (char *str, size_t size, const char *format, va_list ap)
 159 {
 160   int ret;
 161
 162   assert (NULL != str);
 163   assert (NULL != format);
 164
 165   ret = vsnprintf (str, size, format, ap);
 166
 167   return ((ret >= 0) && ((size_t)ret < size));
 168 }
 169
 170
 171 bool baprintf (char **out, const char *format, ...)
 172 {
 173   va_list ap;
 174   bool ret;
 175
 176   va_start (ap, format);
 177   ret = bvaprintf (out, format, ap);
 178   va_end (ap);
 179
 180   return ret;
 181 }
 182
 183
 184 bool bvaprintf (char **out, const char *format, va_list ap)
 185 {
 186   assert (NULL != out);
 187   assert (NULL != format);
 188   *out = NULL;
 189
 190   int bytes = vsnprintf (NULL, 0, format, ap);
 191   if ((1 > bytes) || (INT_MAX == bytes))
 192     return false;
 193
 194   ++bytes;  // '\0'.
 195
 196   if (bytes != (int)(size_t)bytes)
 197     return false;
 198
 199   *out = malloc ((size_t)bytes);
 200   if (NULL == *out)
 201     return false;
 202
 203   if (!bvsnprintf (*out, bytes, format, ap))
 204   {
 205     free (*out);
 206     *out = NULL;
 207     return false;
 208   }
 209
 210   return true;
 211 }
 212