src/utils/strbuf.c

   1 /*
   2  * SysDB - src/utils/strbuf.c
   3  * Copyright (C) 2012 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "utils/strbuf.h"
  29
  30 #include <assert.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <stdarg.h>
  35 #include <string.h>
  36
  37 /*
  38  * private data structures
  39  */
  40
  41 struct sdb_strbuf {
  42         char  *string;
  43         size_t size;
  44         size_t pos;
  45 };
  46
  47 /*
  48  * private helper functions
  49  */
  50
  51 static int
  52 strbuf_resize(sdb_strbuf_t *strbuf, size_t new_size)
  53 {
  54         char *tmp;
  55
  56         if (new_size <= strbuf->size)
  57                 return 0;
  58
  59         tmp = realloc(strbuf->string, new_size);
  60         if (! tmp)
  61                 return -1;
  62
  63         strbuf->string = tmp;
  64         strbuf->size = new_size;
  65         return 0;
  66 } /* strbuf_resize */
  67
  68 /*
  69  * public API
  70  */
  71
  72 sdb_strbuf_t *
  73 sdb_strbuf_create(size_t size)
  74 {
  75         sdb_strbuf_t *strbuf;
  76
  77         strbuf = calloc(1, sizeof(*strbuf));
  78         if (! strbuf)
  79                 return NULL;
  80
  81         strbuf->string = NULL;
  82         if (size) {
  83                 strbuf->string = malloc(size);
  84                 if (! strbuf->string) {
  85                         free(strbuf);
  86                         return NULL;
  87                 }
  88
  89                 strbuf->string[0] = '\0';
  90         }
  91
  92         strbuf->size = size;
  93         strbuf->pos  = 0;
  94
  95         return strbuf;
  96 } /* sdb_strbuf_create */
  97
  98 void
  99 sdb_strbuf_destroy(sdb_strbuf_t *strbuf)
 100 {
 101         if (! strbuf)
 102                 return;
 103
 104         if (strbuf->string)
 105                 free(strbuf->string);
 106         free(strbuf);
 107 } /* sdb_strbuf_destroy */
 108
 109 ssize_t
 110 sdb_strbuf_vappend(sdb_strbuf_t *strbuf, const char *fmt, va_list ap)
 111 {
 112         va_list aq;
 113         int status;
 114
 115         if ((! strbuf) || (! fmt))
 116                 return -1;
 117
 118         assert((strbuf->size == 0) || (strbuf->string[strbuf->pos] == '\0'));
 119
 120         if (strbuf->pos >= strbuf->size)
 121                 /* use some arbitrary but somewhat reasonable default */
 122                 if (strbuf_resize(strbuf, strbuf->size ? 2 * strbuf->size : 64))
 123                         return -1;
 124
 125         assert(strbuf->size && strbuf->string);
 126         assert(strbuf->pos < strbuf->size);
 127
 128         /* 'ap' is invalid after calling vsnprintf; thus copy before using it */
 129         va_copy(aq, ap);
 130         status = vsnprintf(strbuf->string + strbuf->pos,
 131                         strbuf->size - strbuf->pos, fmt, ap);
 132
 133         if (status < 0) {
 134                 va_end(aq);
 135                 return status;
 136         }
 137
 138         if ((size_t)status >= strbuf->size - strbuf->pos) {
 139                 strbuf_resize(strbuf, (size_t)status + 1);
 140
 141                 /* reset string and try again */
 142                 strbuf->string[strbuf->pos] = '\0';
 143                 status = (int)sdb_strbuf_vappend(strbuf, fmt, aq);
 144         }
 145         else
 146                 strbuf->pos += (size_t)status;
 147
 148         va_end(aq);
 149         return (ssize_t)status;
 150 } /* sdb_strbuf_vappend */
 151
 152 ssize_t
 153 sdb_strbuf_append(sdb_strbuf_t *strbuf, const char *fmt, ...)
 154 {
 155         va_list ap;
 156         ssize_t status;
 157
 158         va_start(ap, fmt);
 159         status = sdb_strbuf_vappend(strbuf, fmt, ap);
 160         va_end(ap);
 161
 162         return status;
 163 } /* sdb_strbuf_append */
 164
 165 ssize_t
 166 sdb_strbuf_vsprintf(sdb_strbuf_t *strbuf, const char *fmt, va_list ap)
 167 {
 168         if (! strbuf)
 169                 return -1;
 170
 171         if (strbuf->size) {
 172                 strbuf->string[0] = '\0';
 173                 strbuf->pos = 0;
 174         }
 175
 176         return sdb_strbuf_vappend(strbuf, fmt, ap);
 177 } /* sdb_strbuf_vsprintf */
 178
 179 ssize_t
 180 sdb_strbuf_sprintf(sdb_strbuf_t *strbuf, const char *fmt, ...)
 181 {
 182         va_list ap;
 183         ssize_t status;
 184
 185         va_start(ap, fmt);
 186         status = sdb_strbuf_vsprintf(strbuf, fmt, ap);
 187         va_end(ap);
 188
 189         return status;
 190 } /* sdb_strbuf_sprintf */
 191
 192 ssize_t
 193 sdb_strbuf_memappend(sdb_strbuf_t *strbuf, const void *data, size_t n)
 194 {
 195         if ((! strbuf) || (! data))
 196                 return -1;
 197
 198         assert((strbuf->size == 0) || (strbuf->string[strbuf->pos] == '\0'));
 199
 200         if (strbuf->pos + n + 1 >= strbuf->size) {
 201                 size_t newsize = strbuf->size * 2;
 202
 203                 if (! newsize)
 204                         newsize = 64;
 205                 while (strbuf->pos + n + 1 >= newsize)
 206                         newsize *= 2;
 207
 208                 if (strbuf_resize(strbuf, newsize))
 209                         return -1;
 210         }
 211
 212         assert(strbuf->size && strbuf->string);
 213         assert(strbuf->pos < strbuf->size);
 214
 215         memcpy((void *)(strbuf->string + strbuf->pos), data, n);
 216         strbuf->pos += n;
 217         strbuf->string[strbuf->pos] = '\0';
 218
 219         return (ssize_t)n;
 220 } /* sdb_strbuf_memappend */
 221
 222 ssize_t
 223 sdb_strbuf_memcpy(sdb_strbuf_t *strbuf, const void *data, size_t n)
 224 {
 225         if ((! strbuf) || (! data))
 226                 return -1;
 227
 228         if (strbuf->size) {
 229                 strbuf->string[0] = '\0';
 230                 strbuf->pos = 0;
 231         }
 232
 233         return sdb_strbuf_memappend(strbuf, data, n);
 234 } /* sdb_strbuf_memcpy */
 235
 236 ssize_t
 237 sdb_strbuf_chomp(sdb_strbuf_t *strbuf)
 238 {
 239         ssize_t ret = 0;
 240
 241         if (! strbuf)
 242                 return -1;
 243
 244         assert((!strbuf->size) || (strbuf->pos < strbuf->size));
 245         assert(strbuf->pos <= strbuf->size);
 246
 247         while ((strbuf->pos > 0)
 248                         && (strbuf->string[strbuf->pos - 1] == '\n')) {
 249                 --strbuf->pos;
 250                 strbuf->string[strbuf->pos] = '\0';
 251                 ++ret;
 252         }
 253
 254         return ret;
 255 } /* sdb_strbuf_chomp */
 256
 257 const char *
 258 sdb_strbuf_string(sdb_strbuf_t *strbuf)
 259 {
 260         if (! strbuf)
 261                 return NULL;
 262         if (! strbuf->size)
 263                 return "";
 264         return strbuf->string;
 265 } /* sdb_strbuf_string */
 266
 267 size_t
 268 sdb_strbuf_len(sdb_strbuf_t *strbuf)
 269 {
 270         if (! strbuf)
 271                 return 0;
 272         return strbuf->pos;
 273 } /* sdb_strbuf_string */
 274
 275 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 276