void fz_write_buffer_byte(fz_context *ctx, fz_buffer *buf, int val)
{
if (buf->len > buf->cap)
fz_grow_buffer(ctx, buf);
buf->data[buf->len++] = val;
buf->unused_bits = 0;
}
fz_buffer *
fz_read_best(fz_stream *stm, int initial, int *truncated)
{
fz_buffer *buf = NULL;
int n;
fz_context *ctx = stm->ctx;
fz_var(buf);
if (truncated)
*truncated = 0;
fz_try(ctx)
{
if (initial < 1024)
initial = 1024;
buf = fz_new_buffer(ctx, initial+1);
while (1)
{
if (buf->len == buf->cap)
fz_grow_buffer(ctx, buf);
if (buf->len >= MIN_BOMB && buf->len / 200 > initial)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "compression bomb detected");
}
n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
if (n == 0)
break;
buf->len += n;
}
}
fz_catch(ctx)
{
if (fz_caught(ctx) == FZ_ERROR_TRYLATER)
{
fz_drop_buffer(ctx, buf);
fz_rethrow(ctx);
}
if (truncated)
{
*truncated = 1;
}
else
{
fz_drop_buffer(ctx, buf);
fz_rethrow(ctx);
}
}
return buf;
}
static void
fz_buffer_printf(fz_context *ctx, fz_buffer *buffer, char *fmt, ...)
{
int count;
va_list args;
va_start(args, fmt);
retry_larger_buffer:
count = _vsnprintf(buffer->data + buffer->len, buffer->cap - buffer->len, fmt, args);
if (count < 0 || count >= buffer->cap - buffer->len)
{
fz_grow_buffer(ctx, buffer);
goto retry_larger_buffer;
}
buffer->len += count;
va_end(args);
}
fz_buffer *
fz_read_all(fz_stream *stm, int initial)
{
fz_buffer *buf = NULL;
int n;
fz_context *ctx = stm->ctx;
try
{
if (initial < 1024)
initial = 1024;
buf = fz_new_buffer(ctx, initial+1);
while (1)
{
if (buf->len == buf->cap)
fz_grow_buffer(ctx, buf);
if (buf->len >= MIN_BOMB && buf->len / 200 > initial)
{
throw("compression bomb detected");
}
n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
if (n == 0)
break;
buf->len += n;
}
}
catch(...)
{
fz_drop_buffer(ctx, buf);
throw("");
}
fz_trim_buffer(ctx, buf);
return buf;
}
static int
next_leech(fz_context *ctx, fz_stream *stm, size_t max)
{
fz_leech *state = stm->state;
fz_buffer *buffer = state->buffer;
size_t n = fz_available(ctx, state->chain, max);
if (n > max)
n = max;
while (buffer->cap < buffer->len + n)
{
fz_grow_buffer(ctx, state->buffer);
}
memcpy(buffer->data + buffer->len, state->chain->rp, n);
stm->rp = buffer->data + buffer->len;
stm->wp = buffer->data + buffer->len + n;
state->chain->rp += n;
buffer->len += n;
if (n == 0)
return EOF;
return *stm->rp++;
}
