lib/dpkg/varbuf.c

   1 /*
   2  * libdpkg - Debian packaging suite library routines
   3  * varbuf.c - variable length expandable buffer handling
   4  *
   5  * Copyright © 1994,1995 Ian Jackson <ijackson@chiark.greenend.org.uk>
   6  * Copyright © 2008-2015 Guillem Jover <guillem@debian.org>
   7  *
   8  * This is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <compat.h>
  24
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28
  29 #include <dpkg/i18n.h>
  30 #include <dpkg/dpkg.h>
  31 #include <dpkg/dpkg-db.h>
  32
  33 struct varbuf *
  34 varbuf_new(size_t size)
  35 {
  36         struct varbuf *v;
  37
  38         v = m_malloc(sizeof(*v));
  39         varbuf_init(v, size);
  40
  41         return v;
  42 }
  43
  44 void
  45 varbuf_init(struct varbuf *v, size_t size)
  46 {
  47         v->used = 0;
  48         v->size = size;
  49         if (size)
  50                 v->buf = m_malloc(size);
  51         else
  52                 v->buf = NULL;
  53 }
  54
  55 void
  56 varbuf_grow(struct varbuf *v, size_t need_size)
  57 {
  58         size_t new_size;
  59
  60         /* Make sure the varbuf is in a sane state. */
  61         if (v->size < v->used)
  62                 internerr("varbuf used(%zu) > size(%zu)", v->used, v->size);
  63
  64         /* Check if we already have enough room. */
  65         if ((v->size - v->used) >= need_size)
  66                 return;
  67
  68         /* Check if we overflow. */
  69         new_size = (v->size + need_size) * 2;
  70         if (new_size < v->size)
  71                 ohshit(_("cannot grow varbuf to size %zu; it would overflow"),
  72                        need_size);
  73
  74         v->size = new_size;
  75         v->buf = m_realloc(v->buf, v->size);
  76 }
  77
  78 void
  79 varbuf_trunc(struct varbuf *v, size_t used_size)
  80 {
  81         /* Make sure the caller does not claim more than available. */
  82         if (v->size < used_size)
  83                 internerr("varbuf new_used(%zu) > size(%zu)", used_size, v->size);
  84
  85         v->used = used_size;
  86 }
  87
  88 void
  89 varbuf_reset(struct varbuf *v)
  90 {
  91         v->used = 0;
  92 }
  93
  94 const char *
  95 varbuf_get_str(struct varbuf *v)
  96 {
  97         varbuf_end_str(v);
  98
  99         return v->buf;
 100 }
 101
 102 void
 103 varbuf_add_varbuf(struct varbuf *v, const struct varbuf *other)
 104 {
 105         varbuf_grow(v, other->used);
 106         memcpy(v->buf + v->used, other->buf, other->used);
 107         v->used += other->used;
 108 }
 109
 110 void
 111 varbuf_add_char(struct varbuf *v, int c)
 112 {
 113         varbuf_grow(v, 1);
 114         v->buf[v->used++] = c;
 115 }
 116
 117 void
 118 varbuf_dup_char(struct varbuf *v, int c, size_t n)
 119 {
 120         if (n == 0)
 121                 return;
 122         varbuf_grow(v, n);
 123         memset(v->buf + v->used, c, n);
 124         v->used += n;
 125 }
 126
 127 void
 128 varbuf_map_char(struct varbuf *v, int c_src, int c_dst)
 129 {
 130         size_t i;
 131
 132         for (i = 0; i < v->used; i++)
 133                 if (v->buf[i] == c_src)
 134                         v->buf[i] = c_dst;
 135 }
 136
 137 void
 138 varbuf_add_dir(struct varbuf *v, const char *dirname)
 139 {
 140         varbuf_add_str(v, dirname);
 141         if (v->used == 0 || v->buf[v->used - 1] != '/')
 142                 varbuf_add_char(v, '/');
 143 }
 144
 145 void
 146 varbuf_add_buf(struct varbuf *v, const void *s, size_t size)
 147 {
 148         if (size == 0)
 149                 return;
 150         varbuf_grow(v, size);
 151         memcpy(v->buf + v->used, s, size);
 152         v->used += size;
 153 }
 154
 155 void
 156 varbuf_end_str(struct varbuf *v)
 157 {
 158         varbuf_grow(v, 1);
 159         v->buf[v->used] = '\0';
 160 }
 161
 162 int
 163 varbuf_vprintf(struct varbuf *v, const char *fmt, va_list args)
 164 {
 165         va_list args_copy;
 166         int needed, r;
 167
 168         va_copy(args_copy, args);
 169         needed = vsnprintf(NULL, 0, fmt, args_copy);
 170         va_end(args_copy);
 171
 172         if (needed < 0)
 173                 ohshite(_("error formatting string into varbuf variable"));
 174
 175         varbuf_grow(v, needed + 1);
 176
 177         r = vsnprintf(v->buf + v->used, needed + 1, fmt, args);
 178         if (r < 0)
 179                 ohshite(_("error formatting string into varbuf variable"));
 180
 181         v->used += r;
 182
 183         return r;
 184 }
 185
 186 int
 187 varbuf_printf(struct varbuf *v, const char *fmt, ...)
 188 {
 189         int r;
 190         va_list args;
 191
 192         va_start(args, fmt);
 193         r = varbuf_vprintf(v, fmt, args);
 194         va_end(args);
 195
 196         return r;
 197 }
 198
 199 void
 200 varbuf_snapshot(struct varbuf *v, struct varbuf_state *vs)
 201 {
 202         vs->v = v;
 203         vs->used = v->used;
 204 }
 205
 206 void
 207 varbuf_rollback(struct varbuf_state *vs)
 208 {
 209         varbuf_trunc(vs->v, vs->used);
 210 }
 211
 212 size_t
 213 varbuf_rollback_len(struct varbuf_state *vs)
 214 {
 215         if (vs->used > vs->v->used)
 216                 internerr("varbuf state_used(%zu) > used(%zu)",
 217                           vs->used, vs->v->used);
 218         return vs->v->used - vs->used;
 219 }
 220
 221 const char *
 222 varbuf_rollback_start(struct varbuf_state *vs)
 223 {
 224         if (vs->v->buf == NULL) {
 225                 if (vs->used)
 226                         internerr("varbuf buf(NULL) state_used(%zu) > 0",
 227                                   vs->used);
 228                 /* XXX: Ideally this would be handled by varbuf always having
 229                  * a valid buf or switching all users to the getter, but for
 230                  * now this will do. */
 231                 return "";
 232         }
 233         return vs->v->buf + vs->used;
 234 }
 235
 236 char *
 237 varbuf_detach(struct varbuf *v)
 238 {
 239         char *buf = v->buf;
 240
 241         v->buf = NULL;
 242         v->size = 0;
 243         v->used = 0;
 244
 245         return buf;
 246 }
 247
 248 void
 249 varbuf_destroy(struct varbuf *v)
 250 {
 251         free(v->buf);
 252         v->buf = NULL;
 253         v->size = 0;
 254         v->used = 0;
 255 }
 256
 257 void
 258 varbuf_free(struct varbuf *v)
 259 {
 260         free(v->buf);
 261         free(v);
 262 }