global: Use buffer_get_writable_size() where possible

With 09539f3db increasing buffer's init_size with +1 some fts-icu unit tests
started failing. And in general it's better to use the writable size since
that provides the true size that can be used.

diff --git a/src/lib-fts/test-fts-icu.c b/src/lib-fts/test-fts-icu.c
index 6eab62015af33430f01f2d487b4521265397c573..f1748bd63cb08d7890b670c21fe13f3412c765a0 100644 (file)
--- a/src/lib-fts/test-fts-icu.c
+++ b/src/lib-fts/test-fts-icu.c
@@ -11,18 +11,17 @@
 
 static void test_fts_icu_utf8_to_utf16_ascii_resize(void)
 {
-       buffer_t *dest = buffer_create_dynamic(pool_datastack_create(), 5);
+       buffer_t *dest = buffer_create_dynamic(pool_datastack_create(), 4);
 
        test_begin("fts_icu_utf8_to_utf16 ascii resize");
-       /* dynamic buffers reserve +1 for str_c()'s NUL, so 5 -> 4 */
-       test_assert(buffer_get_size(dest) == 5);
+       test_assert(buffer_get_writable_size(dest) == 4);
        fts_icu_utf8_to_utf16(dest, "12");
        test_assert(dest->used == 4);
-       test_assert(buffer_get_size(dest) == 5);
+       test_assert(buffer_get_writable_size(dest) == 4);
 
        fts_icu_utf8_to_utf16(dest, "123");
        test_assert(dest->used == 6);
-       test_assert(buffer_get_size(dest) == 8);
+       test_assert(buffer_get_writable_size(dest) == 7);
 
        fts_icu_utf8_to_utf16(dest, "12345");
        test_assert(dest->used == 10);
@@ -38,7 +37,7 @@ static void test_fts_icu_utf8_to_utf16_32bit_resize(void)
        test_begin("fts_icu_utf8_to_utf16 32bit resize");
        for (i = 2; i <= 5; i++) {
                dest = buffer_create_dynamic(pool_datastack_create(), i);
-               test_assert(buffer_get_size(dest) == i);
+               test_assert(buffer_get_writable_size(dest) == i);
                fts_icu_utf8_to_utf16(dest, "\xF0\x90\x90\x80"); /* 0x10400 */
                test_assert(dest->used == 4);
        }
@@ -69,7 +68,7 @@ static void test_fts_icu_utf16_to_utf8_resize(void)
        test_begin("fts_icu_utf16_to_utf8 resize");
        for (i = 2; i <= 6; i++) {
                dest = t_str_new(i);
-               test_assert(buffer_get_size(dest) == i);
+               test_assert(buffer_get_writable_size(dest) == i);
                fts_icu_utf16_to_utf8(dest, &src, 1);
                test_assert(dest->used == 3);
                test_assert(strcmp(str_c(dest), UNICODE_REPLACEMENT_CHAR_UTF8) == 0);
@@ -131,7 +130,7 @@ static void test_fts_icu_translate_resize(void)
                buffer_set_used_size(src_utf16, 0);
                fts_icu_utf8_to_utf16(src_utf16, src_utf8);
                dest = buffer_create_dynamic(pool_datastack_create(), i);
-               test_assert(buffer_get_size(dest) == i);
+               test_assert(buffer_get_writable_size(dest) == i);
                test_assert(fts_icu_translate(dest, src_utf16->data,
                                              src_utf16->used/sizeof(UChar),
                                              translit, &error) == 0);
@@ -159,12 +158,12 @@ static void test_fts_icu_lcase_resize(void)
        unsigned int i;
 
        test_begin("fts_icu_lcase resize");
-       for (i = 2; i <= 4; i++) {
+       for (i = 1; i <= 3; i++) {
                dest = t_str_new(i);
-               test_assert(buffer_get_size(dest) == i);
+               test_assert(buffer_get_writable_size(dest) == i);
                fts_icu_lcase(dest, src);
                test_assert(strcmp(str_c(dest), "a\xC3\xA4") == 0);
-               test_assert(buffer_get_size(dest) == 4);
+               test_assert(buffer_get_writable_size(dest) == 3);
        }
 
        test_end();

diff --git a/src/lib-ssl-iostream/ostream-openssl.c b/src/lib-ssl-iostream/ostream-openssl.c
index 91fc4d9c994be2c7d6258342779b028f1997a8b2..4a8fe9ecb95fa74dd7692ae54789ae6556373e33 100644 (file)
--- a/src/lib-ssl-iostream/ostream-openssl.c
+++ b/src/lib-ssl-iostream/ostream-openssl.c
@@ -50,7 +50,7 @@ o_stream_ssl_buffer(struct ssl_ostream *sstream, const struct const_iovec *iov,
        if (sstream->ostream.max_buffer_size == 0) {
                /* we're requeted to use whatever space is available in
                   the buffer */
-               avail = buffer_get_size(sstream->buffer) - sstream->buffer->used;
+               avail = buffer_get_writable_size(sstream->buffer) - sstream->buffer->used;
        } else {
                avail = sstream->ostream.max_buffer_size > sstream->buffer->used ?
                        sstream->ostream.max_buffer_size - sstream->buffer->used : 0;

diff --git a/src/lib/aqueue.c b/src/lib/aqueue.c
index 26388bd68eef4d7aa3136cce241b2b7745274cb2..efddd10ed95c0da32e54e70963354c253da6de62 100644 (file)
--- a/src/lib/aqueue.c
+++ b/src/lib/aqueue.c
@@ -10,7 +10,7 @@ struct aqueue *aqueue_init(struct array *array)
 
        aqueue = i_new(struct aqueue, 1);
        aqueue->arr = array;
-       aqueue->area_size = buffer_get_size(aqueue->arr->buffer) /
+       aqueue->area_size = buffer_get_writable_size(aqueue->arr->buffer) /
                aqueue->arr->element_size;
        i_assert(aqueue->area_size > 0);
        return aqueue;
@@ -32,7 +32,7 @@ static void aqueue_grow(struct aqueue *aqueue)
 
        orig_area_size = aqueue->area_size;
        (void)array_append_space_i(aqueue->arr);
-       aqueue->area_size = buffer_get_size(aqueue->arr->buffer) /
+       aqueue->area_size = buffer_get_writable_size(aqueue->arr->buffer) /
                aqueue->arr->element_size;
        i_assert(orig_area_size < aqueue->area_size);
 

diff --git a/src/lib/str.c b/src/lib/str.c
index 4203432aced66e7e538247724ff35c8d9a355aec..8cfd5d207d6cf18505cfaffc0469f43be44ae4f3 100644 (file)
--- a/src/lib/str.c
+++ b/src/lib/str.c
@@ -153,11 +153,11 @@ void str_vprintfa(string_t *str, const char *fmt, va_list args)
        init_size += SNPRINTF_INITIAL_EXTRA_SIZE;
 
        /* @UNSAFE */
-       if (pos+init_size > buffer_get_size(str) &&
-           pos < buffer_get_size(str)) {
+       if (pos+init_size > buffer_get_writable_size(str) &&
+           pos < buffer_get_writable_size(str)) {
                /* avoid growing buffer larger if possible. this is also
                   required if buffer isn't dynamically growing. */
-               init_size = buffer_get_size(str)-pos;
+               init_size = buffer_get_writable_size(str)-pos;
        }
        tmp = buffer_get_space_unsafe(str, pos, init_size);
        ret = vsnprintf(tmp, init_size, fmt, args);