From 65f8253336680bf2b3387796b6d08b6de69fca21 Mon Sep 17 00:00:00 2001 From: Daniel Stenberg Date: Tue, 24 Jun 2025 09:15:45 +0200 Subject: [PATCH] bufq: remove the unused Curl_bufq_unwrite function Follow-up to 02edae54e8 Closes #17730 --- docs/internals/BUFQ.md | 11 ------- lib/bufq.c | 69 ------------------------------------------ lib/bufq.h | 6 ---- tests/unit/unit2601.c | 35 --------------------- 4 files changed, 121 deletions(-) diff --git a/docs/internals/BUFQ.md b/docs/internals/BUFQ.md index ac7051834d..6028711d2c 100644 --- a/docs/internals/BUFQ.md +++ b/docs/internals/BUFQ.md @@ -76,17 +76,6 @@ void Curl_bufq_skip(struct bufq *q, size_t amount); This removes `amount` number of bytes from the `bufq`. -## unwrite - -It is possible to undo writes by calling: - -``` -CURLcode Curl_bufq_unwrite(struct bufq *q, size_t len); -``` - -This removes `len` bytes from the end of the bufq again. When removing more -bytes than are present, CURLE_AGAIN is returned and bufq is cleared. - ## lifetime `bufq` is initialized and freed similar to the `dynbuf` module. Code using diff --git a/lib/bufq.c b/lib/bufq.c index 724d62f31c..15c35cef7b 100644 --- a/lib/bufq.c +++ b/lib/bufq.c @@ -86,23 +86,6 @@ static size_t chunk_read(struct buf_chunk *chunk, } } -static size_t chunk_unwrite(struct buf_chunk *chunk, size_t len) -{ - size_t n = chunk->w_offset - chunk->r_offset; - DEBUGASSERT(chunk->w_offset >= chunk->r_offset); - if(!n) { - return 0; - } - else if(n <= len) { - chunk->r_offset = chunk->w_offset = 0; - return n; - } - else { - chunk->w_offset -= len; - return len; - } -} - static ssize_t chunk_slurpn(struct buf_chunk *chunk, size_t max_len, Curl_bufq_reader *reader, void *reader_ctx, CURLcode *err) @@ -357,49 +340,6 @@ static void prune_head(struct bufq *q) } } -static struct buf_chunk *chunk_prev(struct buf_chunk *head, - struct buf_chunk *chunk) -{ - while(head) { - if(head == chunk) - return NULL; - if(head->next == chunk) - return head; - head = head->next; - } - return NULL; -} - -static void prune_tail(struct bufq *q) -{ - struct buf_chunk *chunk; - - while(q->tail && chunk_is_empty(q->tail)) { - chunk = q->tail; - q->tail = chunk_prev(q->head, chunk); - if(q->tail) - q->tail->next = NULL; - if(q->head == chunk) - q->head = q->tail; - if(q->pool) { - bufcp_put(q->pool, chunk); - --q->chunk_count; - } - else if((q->chunk_count > q->max_chunks) || - (q->opts & BUFQ_OPT_NO_SPARES)) { - /* SOFT_LIMIT allowed us more than max. free spares until - * we are at max again. Or free them if we are configured - * to not use spares. */ - free(chunk); - --q->chunk_count; - } - else { - chunk->next = q->spare; - q->spare = chunk; - } - } -} - static struct buf_chunk *get_non_full_tail(struct bufq *q) { struct buf_chunk *chunk; @@ -465,15 +405,6 @@ CURLcode Curl_bufq_cwrite(struct bufq *q, return result; } -CURLcode Curl_bufq_unwrite(struct bufq *q, size_t len) -{ - while(len && q->tail) { - len -= chunk_unwrite(q->tail, len); - prune_tail(q); - } - return len ? CURLE_AGAIN : CURLE_OK; -} - ssize_t Curl_bufq_read(struct bufq *q, unsigned char *buf, size_t len, CURLcode *err) { diff --git a/lib/bufq.h b/lib/bufq.h index 60059deb30..665af593f5 100644 --- a/lib/bufq.h +++ b/lib/bufq.h @@ -174,12 +174,6 @@ CURLcode Curl_bufq_cwrite(struct bufq *q, const char *buf, size_t len, size_t *pnwritten); -/** - * Remove `len` bytes from the end of the buffer queue again. - * Returns CURLE_AGAIN if less than `len` bytes were in the queue. - */ -CURLcode Curl_bufq_unwrite(struct bufq *q, size_t len); - /** * Read buf from the start of the buffer queue. The buf is copied * and the amount of copied bytes is returned. diff --git a/tests/unit/unit2601.c b/tests/unit/unit2601.c index 41395186f0..8dd79d2d97 100644 --- a/tests/unit/unit2601.c +++ b/tests/unit/unit2601.c @@ -199,41 +199,6 @@ static void check_bufq(size_t pool_spares, } fail_unless(nread == nwritten, "did not get the same out as put in"); - /* CHECK bufq_unwrite: write a string repeatedly into the second chunk. - * bufq_unwrite() 1 byte. Read strings again and check for content. - * We had a bug that unwrite used the head chunk instead of tail, which - * did corrupt the read values. */ - if(TRUE) { - const unsigned char buf[] = "0123456789--"; - size_t roffset; - Curl_bufq_reset(&q); - while(Curl_bufq_len(&q) < chunk_size) { - n = Curl_bufq_write(&q, buf, sizeof(buf), &result); - fail_unless(n > 0 && (size_t)n == sizeof(buf), "write incomplete"); - if(result) - break; - } - result = Curl_bufq_unwrite(&q, 1); - roffset = 0; - while(!Curl_bufq_is_empty(&q)) { - unsigned char rbuf[sizeof(buf)]; - n = Curl_bufq_read(&q, rbuf, sizeof(rbuf), &result); - fail_unless(n > 0, "read should work"); - if(result) - break; - if(n != sizeof(rbuf)) { - fail_unless(Curl_bufq_is_empty(&q), "should be last read"); - } - if(memcmp(buf, rbuf, n)) { - curl_mfprintf(stderr, "at offset %zu expected '%.*s', got '%.*s'\n", - roffset, (int)n, buf, (int)n, rbuf); - fail("read buf content wrong"); - } - roffset += n; - } - Curl_bufq_reset(&q); - } - dump_bufq(&q, "at end of test"); Curl_bufq_free(&q); if(pool_spares > 0) -- 2.47.2