wsutil/wmem/wmem_strbuf.c

   1 /* wmem_strbuf.c
   2  * Wireshark Memory Manager String Buffer
   3  * Copyright 2012, Evan Huus <eapache@gmail.com>
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  */
  11
  12 #include "config.h"
  13 #include "wmem_strbuf.h"
  14
  15 #include <stdio.h>
  16 #include <errno.h>
  17
  18 #include "wmem-int.h"
  19 #include "wmem_strutl.h"
  20
  21 #include <wsutil/unicode-utils.h>
  22
  23 #define DEFAULT_MINIMUM_SIZE 16
  24
  25 /* _ROOM accounts for the null-terminator, _RAW_ROOM does not.
  26  * Some functions need one, some functions need the other. */
  27 #define WMEM_STRBUF_ROOM(S) ((S)->alloc_size - (S)->len - 1)
  28 #define WMEM_STRBUF_RAW_ROOM(S) ((S)->alloc_size - (S)->len)
  29
  30 wmem_strbuf_t *
  31 wmem_strbuf_new_sized(wmem_allocator_t *allocator,
  32                       size_t alloc_size)
  33 {
  34     wmem_strbuf_t *strbuf;
  35
  36     strbuf = wmem_new(allocator, wmem_strbuf_t);
  37
  38     strbuf->allocator = allocator;
  39     strbuf->len       = 0;
  40     strbuf->alloc_size = alloc_size ? alloc_size : DEFAULT_MINIMUM_SIZE;
  41
  42     strbuf->str    = (char *)wmem_alloc(strbuf->allocator, strbuf->alloc_size);
  43     strbuf->str[0] = '\0';
  44
  45     return strbuf;
  46 }
  47
  48 wmem_strbuf_t *
  49 wmem_strbuf_new_len(wmem_allocator_t *allocator, const char *str, size_t len)
  50 {
  51     wmem_strbuf_t *strbuf;
  52     size_t          alloc_size;
  53
  54     alloc_size = DEFAULT_MINIMUM_SIZE;
  55
  56     /* +1 for the null-terminator */
  57     while (alloc_size < (len + 1)) {
  58         alloc_size *= 2;
  59     }
  60
  61     strbuf = wmem_strbuf_new_sized(allocator, alloc_size);
  62
  63     if (str && len > 0) {
  64         ws_assert(strbuf->alloc_size >= len + 1);
  65         memcpy(strbuf->str, str, len);
  66         strbuf->str[len] = '\0';
  67         strbuf->len = len;
  68     }
  69
  70     return strbuf;
  71 }
  72
  73 wmem_strbuf_t *
  74 wmem_strbuf_new(wmem_allocator_t *allocator, const char *str)
  75 {
  76     return wmem_strbuf_new_len(allocator, str, str ? strlen(str) : 0);
  77 }
  78
  79 wmem_strbuf_t *
  80 wmem_strbuf_dup(wmem_allocator_t *allocator, const wmem_strbuf_t *src)
  81 {
  82     wmem_strbuf_t *new;
  83
  84     new = wmem_strbuf_new_sized(allocator, src->alloc_size);
  85     new->len = src->len;
  86     memcpy(new->str, src->str, new->len);
  87     new->str[new->len] = '\0';
  88     return new;
  89 }
  90
  91 /* grows the allocated size of the wmem_strbuf_t. If max_size is set, then
  92  * not guaranteed to grow by the full amount to_add */
  93 static inline void
  94 wmem_strbuf_grow(wmem_strbuf_t *strbuf, const size_t to_add)
  95 {
  96     size_t  new_alloc_len, new_len;
  97
  98     /* short-circuit for efficiency if we have room already; greatly speeds up
  99      * repeated calls to wmem_strbuf_append_c and others which grow a little bit
 100      * at a time.
 101      */
 102     if (WMEM_STRBUF_ROOM(strbuf) >= to_add) {
 103         return;
 104     }
 105
 106     new_alloc_len = strbuf->alloc_size;
 107     new_len = strbuf->len + to_add;
 108
 109     /* +1 for the null-terminator */
 110     while (new_alloc_len < (new_len + 1)) {
 111         new_alloc_len *= 2;
 112     }
 113
 114     if (new_alloc_len == strbuf->alloc_size) {
 115         return;
 116     }
 117
 118     strbuf->str = (char *)wmem_realloc(strbuf->allocator, strbuf->str, new_alloc_len);
 119
 120     strbuf->alloc_size = new_alloc_len;
 121 }
 122
 123 void
 124 wmem_strbuf_append(wmem_strbuf_t *strbuf, const char *str)
 125 {
 126     size_t append_len;
 127
 128     if (!str || str[0] == '\0') {
 129         return;
 130     }
 131
 132     append_len = strlen(str);
 133     wmem_strbuf_grow(strbuf, append_len);
 134
 135     ws_assert(WMEM_STRBUF_RAW_ROOM(strbuf) >= append_len + 1);
 136     memcpy(&strbuf->str[strbuf->len], str, append_len);
 137     strbuf->len += append_len;
 138     strbuf->str[strbuf->len] = '\0';
 139 }
 140
 141 void
 142 wmem_strbuf_append_len(wmem_strbuf_t *strbuf, const char *str, size_t append_len)
 143 {
 144
 145     if (!append_len || !str) {
 146         return;
 147     }
 148
 149     wmem_strbuf_grow(strbuf, append_len);
 150
 151     memcpy(&strbuf->str[strbuf->len], str, append_len);
 152     strbuf->len += append_len;
 153     strbuf->str[strbuf->len] = '\0';
 154 }
 155
 156 static inline
 157 int _strbuf_vsnprintf(wmem_strbuf_t *strbuf, const char *format, va_list ap)
 158 {
 159     int want_len;
 160     char *buffer = &strbuf->str[strbuf->len];
 161     size_t buffer_size = WMEM_STRBUF_RAW_ROOM(strbuf);
 162
 163     want_len = vsnprintf(buffer, buffer_size, format, ap);
 164     if (want_len < 0) {
 165         /* Error. */
 166         g_warning("%s: vsnprintf: (%d) %s", G_STRFUNC, want_len, g_strerror(errno));
 167         return -1;
 168     }
 169     if ((size_t)want_len < buffer_size) {
 170         /* Success. */
 171         strbuf->len += want_len;
 172         return 0;
 173     }
 174
 175     /* Not enough space in buffer, output was truncated. */
 176     strbuf->str[strbuf->len] = '\0'; /* Reset. */
 177
 178     return want_len; /* Length (not including terminating null) that would be written
 179                         if there was enough space in buffer. */
 180 }
 181
 182 void
 183 wmem_strbuf_append_vprintf(wmem_strbuf_t *strbuf, const char *fmt, va_list ap)
 184 {
 185     int want_len;
 186     va_list ap2;
 187
 188     va_copy(ap2, ap);
 189     /* Try to write buffer, check if output fits. */
 190     want_len = _strbuf_vsnprintf(strbuf, fmt, ap2);
 191     va_end(ap2);
 192     if (want_len <= 0)
 193         return;
 194
 195     /* Resize buffer and try again. */
 196     wmem_strbuf_grow(strbuf, want_len);
 197     want_len = _strbuf_vsnprintf(strbuf, fmt, ap);
 198     /* Second time must succeed or error out. */
 199     ws_assert(want_len <= 0);
 200 }
 201
 202 void
 203 wmem_strbuf_append_printf(wmem_strbuf_t *strbuf, const char *format, ...)
 204 {
 205     va_list ap;
 206
 207     va_start(ap, format);
 208     wmem_strbuf_append_vprintf(strbuf, format, ap);
 209     va_end(ap);
 210 }
 211
 212 void
 213 wmem_strbuf_append_c(wmem_strbuf_t *strbuf, const char c)
 214 {
 215     wmem_strbuf_grow(strbuf, 1);
 216
 217     strbuf->str[strbuf->len] = c;
 218     strbuf->len++;
 219     strbuf->str[strbuf->len] = '\0';
 220 }
 221
 222 void
 223 wmem_strbuf_append_c_count(wmem_strbuf_t *strbuf, const char c, size_t count)
 224 {
 225     wmem_strbuf_grow(strbuf, count);
 226
 227     while (count-- > 0) {
 228         strbuf->str[strbuf->len++] = c;
 229     }
 230     strbuf->str[strbuf->len] = '\0';
 231 }
 232
 233 void
 234 wmem_strbuf_append_unichar(wmem_strbuf_t *strbuf, const gunichar c)
 235 {
 236     char buf[6];
 237     size_t charlen;
 238
 239     charlen = g_unichar_to_utf8(c, buf);
 240
 241     wmem_strbuf_grow(strbuf, charlen);
 242
 243     memcpy(&strbuf->str[strbuf->len], buf, charlen);
 244     strbuf->len += charlen;
 245     strbuf->str[strbuf->len] = '\0';
 246 }
 247
 248 void
 249 wmem_strbuf_append_unichar_validated(wmem_strbuf_t *strbuf, const gunichar c)
 250 {
 251     if (g_unichar_validate(c)) {
 252         wmem_strbuf_append_unichar(strbuf, c);
 253     } else {
 254         wmem_strbuf_append_unichar(strbuf, UNICODE_REPLACEMENT_CHARACTER);
 255     }
 256 }
 257
 258 static const char hex[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
 259                               '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 260
 261 #define HEX_CODELEN 4
 262
 263 void
 264 wmem_strbuf_append_hex(wmem_strbuf_t *strbuf, uint8_t ch)
 265 {
 266     wmem_strbuf_grow(strbuf, HEX_CODELEN * 1);
 267
 268     strbuf->str[strbuf->len++] = '\\';
 269     strbuf->str[strbuf->len++] = 'x';
 270     strbuf->str[strbuf->len++] = hex[(ch >> 4) & 0xF];
 271     strbuf->str[strbuf->len++] = hex[(ch >> 0) & 0xF];
 272     strbuf->str[strbuf->len] = '\0';
 273 }
 274
 275 #define BMP_CODELEN 6
 276
 277 static inline
 278 void append_hex_bmp(wmem_strbuf_t *strbuf, gunichar ch)
 279 {
 280     wmem_strbuf_grow(strbuf, BMP_CODELEN * 1);
 281
 282     strbuf->str[strbuf->len++] = '\\';
 283     strbuf->str[strbuf->len++] = 'u';
 284     strbuf->str[strbuf->len++] = hex[(ch >> 12) & 0xF];
 285     strbuf->str[strbuf->len++] = hex[(ch >>  8) & 0xF];
 286     strbuf->str[strbuf->len++] = hex[(ch >>  4) & 0xF];
 287     strbuf->str[strbuf->len++] = hex[(ch >>  0) & 0xF];
 288     strbuf->str[strbuf->len] = '\0';
 289 }
 290
 291 #define ANY_CODELEN 10
 292
 293 static inline
 294 void append_hex_any(wmem_strbuf_t *strbuf, gunichar ch)
 295 {
 296     wmem_strbuf_grow(strbuf, ANY_CODELEN * 1);
 297
 298     strbuf->str[strbuf->len++] = '\\';
 299     strbuf->str[strbuf->len++] = 'U';
 300     strbuf->str[strbuf->len++] = hex[(ch >> 28) & 0xF];
 301     strbuf->str[strbuf->len++] = hex[(ch >> 24) & 0xF];
 302     strbuf->str[strbuf->len++] = hex[(ch >> 20) & 0xF];
 303     strbuf->str[strbuf->len++] = hex[(ch >> 16) & 0xF];
 304     strbuf->str[strbuf->len++] = hex[(ch >> 12) & 0xF];
 305     strbuf->str[strbuf->len++] = hex[(ch >>  8) & 0xF];
 306     strbuf->str[strbuf->len++] = hex[(ch >>  4) & 0xF];
 307     strbuf->str[strbuf->len++] = hex[(ch >>  0) & 0xF];
 308     strbuf->str[strbuf->len] = '\0';
 309 }
 310
 311 size_t
 312 wmem_strbuf_append_hex_unichar(wmem_strbuf_t *strbuf, gunichar ch)
 313 {
 314     if (ch <= 0x7f) {
 315         wmem_strbuf_append_hex(strbuf, (uint8_t)ch);
 316         return HEX_CODELEN;
 317     }
 318     if (ch <= 0xffff) {
 319         append_hex_bmp(strbuf, ch);
 320         return BMP_CODELEN;
 321     }
 322     append_hex_any(strbuf, ch);
 323     return ANY_CODELEN;
 324 }
 325
 326 void
 327 wmem_strbuf_truncate(wmem_strbuf_t *strbuf, const size_t len)
 328 {
 329     if (len >= strbuf->len) {
 330         return;
 331     }
 332
 333     strbuf->str[len] = '\0';
 334     strbuf->len = len;
 335 }
 336
 337 const char *
 338 wmem_strbuf_get_str(const wmem_strbuf_t *strbuf)
 339 {
 340     return strbuf->str;
 341 }
 342
 343 size_t
 344 wmem_strbuf_get_len(const wmem_strbuf_t *strbuf)
 345 {
 346     return strbuf->len;
 347 }
 348
 349 static inline int
 350 _memcmp_len(const void *s1, size_t s1_len, const void *s2, size_t s2_len)
 351 {
 352     size_t len;
 353     int cmp;
 354
 355     len = MIN(s1_len, s2_len);
 356     if ((cmp = memcmp(s1, s2, len)) != 0)
 357         return cmp;
 358     if (s1_len < s2_len)
 359         return -1;
 360     if (s1_len > s2_len)
 361         return 1;
 362     return 0;
 363 }
 364
 365 WS_DLL_PUBLIC
 366 int
 367 wmem_strbuf_strcmp(const wmem_strbuf_t *sb1, const wmem_strbuf_t *sb2)
 368 {
 369     return _memcmp_len(sb1->str, sb1->len, sb2->str, sb2->len);
 370 }
 371
 372 const char *
 373 wmem_strbuf_strstr(const wmem_strbuf_t *haystack, const wmem_strbuf_t *needle)
 374 {
 375     return ws_memmem(haystack->str, haystack->len, needle->str, needle->len);
 376 }
 377
 378 /* Truncates the allocated memory down to the minimal amount, frees the header
 379  * structure, and returns a non-const pointer to the raw string. The
 380  * wmem_strbuf_t structure cannot be used after this is called.
 381  */
 382 char *
 383 wmem_strbuf_finalize(wmem_strbuf_t *strbuf)
 384 {
 385     if (strbuf == NULL)
 386         return NULL;
 387
 388     char *ret = (char *)wmem_realloc(strbuf->allocator, strbuf->str, strbuf->len+1);
 389
 390     wmem_free(strbuf->allocator, strbuf);
 391
 392     return ret;
 393 }
 394
 395 void
 396 wmem_strbuf_destroy(wmem_strbuf_t *strbuf)
 397 {
 398     if (strbuf == NULL)
 399         return;
 400
 401     wmem_free(strbuf->allocator, strbuf->str);
 402     wmem_free(strbuf->allocator, strbuf);
 403 }
 404
 405 static bool
 406 string_utf8_validate(const char *str, ssize_t max_len, const char **endpptr)
 407 {
 408     bool valid;
 409     const char *endp;
 410
 411     if (max_len <= 0) {
 412         if (endpptr) {
 413             *endpptr = str;
 414         }
 415         return true;
 416     }
 417
 418     valid = g_utf8_validate(str, max_len, &endp);
 419
 420     if (valid || *endp != '\0') {
 421         if (endpptr) {
 422             *endpptr = endp;
 423         }
 424         return valid;
 425     }
 426
 427     /* Invalid because of a nul byte. Skip nuls and continue. */
 428     max_len -= endp - str;
 429     str = endp;
 430     while (max_len > 0 && *str == '\0') {
 431         str++;
 432         max_len--;
 433     }
 434     return string_utf8_validate(str, max_len, endpptr);
 435 }
 436
 437 /* g_utf8_validate() returns false in the string contains embedded NUL
 438  * bytes. We accept \x00 as valid and work around that to validate the
 439  * entire len bytes. */
 440 bool
 441 wmem_strbuf_utf8_validate(wmem_strbuf_t *strbuf, const char **endpptr)
 442 {
 443     return string_utf8_validate(strbuf->str, strbuf->len, endpptr);
 444 }
 445
 446 void
 447 wmem_strbuf_utf8_make_valid(wmem_strbuf_t *strbuf)
 448 {
 449     wmem_strbuf_t *tmp = ws_utf8_make_valid_strbuf(strbuf->allocator, strbuf->str, strbuf->len);
 450
 451     wmem_free(strbuf->allocator, strbuf->str);
 452     strbuf->str = tmp->str;
 453     strbuf->len = tmp->len;
 454     strbuf->alloc_size = tmp->alloc_size;
 455
 456     wmem_free(strbuf->allocator, tmp);
 457 }
 458
 459 /*
 460  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 461  *
 462  * Local variables:
 463  * c-basic-offset: 4
 464  * tab-width: 8
 465  * indent-tabs-mode: nil
 466  * End:
 467  *
 468  * vi: set shiftwidth=4 tabstop=8 expandtab:
 469  * :indentSize=4:tabSize=8:noTabs=true:
 470  */