have a seek mark. */
i_stream_compress(stream);
}
- if (stream->buffer_size < stream->max_buffer_size)
+ if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
}
/* if we already have max_buffer_size amount of data, fail here */
i_stream_compress(stream);
- if (stream->pos >= stream->max_buffer_size)
+ if (stream->pos >= i_stream_get_max_buffer_size(&stream->istream))
return -2;
/* allocate enough space for the old data and the new
decompressed chunk. we don't know the original compressed size,
have a seek mark. */
i_stream_compress(stream);
}
- if (stream->buffer_size < stream->max_buffer_size)
+ if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
have a seek mark. */
i_stream_compress(stream);
}
- if (stream->buffer_size < stream->max_buffer_size)
+ if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
if (fstream->istream.parent == NULL) {
input = fs_read_stream(fstream->file,
- fstream->istream.max_buffer_size);
+ i_stream_get_max_buffer_size(&stream->istream));
i_stream_init_parent(stream, input);
i_stream_unref(&input);
}
*retry_r = FALSE;
- if (stream->pos - stream->skip >= stream->max_buffer_size)
+ if (stream->pos - stream->skip >= i_stream_get_max_buffer_size(&stream->istream))
return -2;
if (astream->failed) {
struct message_block block;
size_t old_size, new_size;
- if (stream->pos - stream->skip >= stream->max_buffer_size)
+ if (stream->pos - stream->skip >= i_stream_get_max_buffer_size(&stream->istream))
return -2;
old_size = stream->pos - stream->skip;
{
struct message_header_line *hdr;
uoff_t highwater_offset;
+ size_t max_buffer_size;
ssize_t ret, ret2;
int hdr_ret;
}
}
- if (mstream->hdr_buf->used >= mstream->istream.max_buffer_size)
+ max_buffer_size = i_stream_get_max_buffer_size(&mstream->istream.istream);
+ if (mstream->hdr_buf->used >= max_buffer_size)
return -2;
while ((hdr_ret = message_parse_header_next(mstream->hdr_ctx,
break;
}
}
- if (mstream->hdr_buf->used >= mstream->istream.max_buffer_size)
+ if (mstream->hdr_buf->used >= max_buffer_size)
break;
}
if (mstream->hdr_buf->used > 0) {
struct qp_decoder_istream *bstream =
(struct qp_decoder_istream *)stream;
const unsigned char *data;
- size_t size, error_pos;
+ size_t size, error_pos, max_buffer_size;
const char *error;
int ret;
+ max_buffer_size = i_stream_get_max_buffer_size(&stream->istream);
for (;;) {
/* remove skipped data from buffer */
if (stream->skip > 0) {
stream->buffer = bstream->buf->data;
i_assert(stream->pos <= bstream->buf->used);
- if (stream->pos >= bstream->istream.max_buffer_size) {
+ if (stream->pos >= max_buffer_size) {
/* stream buffer still at maximum */
return -2;
}
/* only return up to max_buffer_size bytes, even when buffer
actually has more, as not to confuse the caller */
- new_pos = I_MIN
- (bstream->buf->used, bstream->istream.max_buffer_size);
+ new_pos = I_MIN(bstream->buf->used, max_buffer_size);
bytes = new_pos - stream->pos;
stream->pos = new_pos;
struct ssl_istream *sstream = (struct ssl_istream *)stream;
struct ssl_iostream *ssl_io = sstream->ssl_io;
unsigned char buffer[IO_BLOCK_SIZE];
+ size_t max_buffer_size = i_stream_get_max_buffer_size(&stream->istream);
size_t orig_max_buffer_size = stream->max_buffer_size;
size_t size;
ssize_t ret, total_ret;
return -1;
}
- if (stream->pos >= stream->max_buffer_size) {
+ if (stream->pos >= max_buffer_size) {
i_stream_compress(stream);
- if (stream->pos >= stream->max_buffer_size)
+ if (stream->pos >= max_buffer_size)
return -2;
}
if (!i_stream_try_alloc(stream, 1, &size))
i_unreached();
- if (stream->pos + size > stream->max_buffer_size) {
- i_assert(stream->max_buffer_size > stream->pos);
- size = stream->max_buffer_size - stream->pos;
+ if (stream->pos + size > max_buffer_size) {
+ i_assert(max_buffer_size > stream->pos);
+ size = max_buffer_size - stream->pos;
}
while ((ret = SSL_read(ssl_io->ssl,
i_assert(stream->skip <= stream->pos);
- if (stream->pos - stream->skip >= tstream->istream.max_buffer_size)
+ if (stream->pos - stream->skip >= tstream->istream.max_buffer_size) {
+ i_assert(stream->skip != stream->pos);
return -2;
+ }
if (tstream->max_pos < stream->pos) {
/* we seeked past the end of file. */
/* we either read something or we're at EOF */
last_stream = cstream->input[cstream->cur_idx+1] == NULL;
if (ret == -1 && !last_stream) {
- if (stream->pos - stream->skip >= stream->max_buffer_size)
+ if (stream->pos - stream->skip >= i_stream_get_max_buffer_size(&stream->istream))
return -2;
i_stream_concat_read_next(cstream);
/* if any of the streams isn't blocking or seekable, set ourself also
nonblocking/nonseekable */
for (count = 0; input[count] != NULL; count++) {
- size_t cur_max = input[count]->real_stream->max_buffer_size;
+ size_t cur_max = i_stream_get_max_buffer_size(input[count]);
if (cur_max > max_buffer_size)
max_buffer_size = cur_max;
void i_stream_grow_buffer(struct istream_private *stream, size_t bytes)
{
- size_t old_size;
-
- i_assert(stream->max_buffer_size > 0);
+ size_t old_size, max_size;
old_size = stream->buffer_size;
else
stream->buffer_size = nearest_power(stream->buffer_size);
- if (stream->buffer_size > stream->max_buffer_size)
- stream->buffer_size = stream->max_buffer_size;
+ max_size = i_stream_get_max_buffer_size(&stream->istream);
+ i_assert(max_size > 0);
+ if (stream->buffer_size > max_size)
+ stream->buffer_size = max_size;
if (stream->buffer_size <= old_size)
stream->buffer_size = old_size;
if (stream->skip > 0) {
/* remove the unused bytes from beginning of buffer */
i_stream_compress(stream);
- } else if (stream->buffer_size < stream->max_buffer_size) {
+ } else if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream)) {
/* buffer is full - grow it */
i_stream_grow_buffer(stream, I_STREAM_MIN_SIZE);
}