+io_glue *
+im_io_new_cb(pIMCTX, void *p, i_io_readl_t readcb, i_io_writel_t writecb,
+ i_io_seekl_t seekcb, i_io_closel_t closecb,
+ i_io_destroyl_t destroycb) {
+ io_cb *ig;
+
+ im_log((aIMCTX, 1, "io_new_cb(p %p, readcb %p, writecb %p, seekcb %p, closecb %p, "
+ "destroycb %p)\n", p, readcb, writecb, seekcb, closecb, destroycb));
+ ig = mymalloc(sizeof(io_cb));
+ memset(ig, 0, sizeof(*ig));
+ i_io_init(aIMCTX, &ig->base, CBSEEK, realseek_read, realseek_write, realseek_seek);
+ im_log((aIMCTX, 1, "(%p) <- io_new_cb\n", ig));
+
+ ig->base.closecb = realseek_close;
+ ig->base.destroycb = realseek_destroy;
+
+ ig->p = p;
+ ig->readcb = readcb;
+ ig->writecb = writecb;
+ ig->seekcb = seekcb;
+ ig->closecb = closecb;
+ ig->destroycb = destroycb;
+
+ im_context_refinc(aIMCTX, "im_io_new_bufchain");
+
+ return (io_glue *)ig;
+}
+
+/*
+=item io_slurp(ig, c)
+X<io_slurp API>
+=category I/O Layers
+
+Takes the source that the io_glue is bound to and allocates space for
+a return buffer and returns the entire content in a single buffer.
+Note: This only works for io_glue objects created by
+io_new_bufchain(). It is useful for saving to scalars and such.
+
+ ig - io_glue object
+ c - pointer to a pointer to where data should be copied to
+
+ char *data;
+ size_t size = io_slurp(ig, &data);
+ ... do something with the data ...
+ myfree(data);
+
+io_slurp() will abort the program if the supplied I/O layer is not
+from io_new_bufchain().
+
+=cut
+*/
+
+size_t
+io_slurp(io_glue *ig, unsigned char **c) {
+ ssize_t rc;
+ io_ex_bchain *ieb;
+ unsigned char *cc;
+ io_type inn = ig->type;
+
+ if ( inn != BUFCHAIN ) {
+ dIMCTXio(ig);
+ im_fatal(aIMCTX, 0, "io_slurp: called on a source that is not from a bufchain\n");
+ }
+
+ ieb = ig->exdata;
+ cc = *c = mymalloc( ieb->length );
+
+ bufchain_seek(ig, 0, SEEK_SET);
+
+ rc = bufchain_read(ig, cc, ieb->length);
+
+ if (rc != ieb->length) {
+ dIMCTXio(ig);
+ im_fatal(aIMCTX,1, "io_slurp: bufchain_read returned an incomplete read: rc = %d, request was %d\n", rc, ieb->length);
+ }
+
+ return rc;
+}
+
+/*
+=item io_glue_destroy(ig)
+X<io_glue_destroy API>
+=category I/O Layers
+=order 90
+=synopsis io_glue_destroy(ig);
+
+Destroy an io_glue objects. Should clean up all related buffers.
+
+ ig - io_glue object to destroy.
+
+=cut
+*/
+
+void
+io_glue_destroy(io_glue *ig) {
+ dIMCTXio(ig);
+ im_log((aIMCTX, 1, "io_glue_DESTROY(ig %p)\n", ig));
+
+ if (ig->destroycb)
+ ig->destroycb(ig);
+
+ if (ig->buffer)
+ myfree(ig->buffer);
+
+ myfree(ig);
+
+ im_context_refdec(aIMCTX, "io_glue_destroy");
+}
+
+/*
+=item i_io_getc(ig)
+=category I/O Layers
+
+A macro to read a single byte from a buffered I/O glue object.
+
+Returns EOF on failure, or a byte.
+
+=cut
+*/
+
+int
+i_io_getc_imp(io_glue *ig) {
+ if (ig->write_ptr)
+ return EOF;
+
+ if (ig->error || ig->buf_eof)
+ return EOF;
+
+ if (!ig->buffered) {
+ unsigned char buf;
+ ssize_t rc = i_io_raw_read(ig, &buf, 1);
+ if (rc > 0) {
+ return buf;
+ }
+ else if (rc == 0) {
+ ig->buf_eof = 1;
+ return EOF;
+ }
+ else {
+ ig->error = 1;
+ return EOF;
+ }
+ }
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if (!ig->read_ptr || ig->read_ptr == ig->read_end) {
+ if (!i_io_read_fill(ig, 1))
+ return EOF;
+ }
+
+ return *(ig->read_ptr++);
+}
+
+/*
+=item i_io_peekc(ig)
+=category I/O Layers
+
+Read the next character from the stream without advancing the stream.
+
+On error or end of file, return EOF.
+
+For unbuffered streams a single character buffer will be setup.
+
+=cut
+*/
+
+int
+i_io_peekc_imp(io_glue *ig) {
+ if (ig->write_ptr)
+ return EOF;
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if (!ig->buffered) {
+ ssize_t rc = i_io_raw_read(ig, ig->buffer, 1);
+ if (rc > 0) {
+ ig->read_ptr = ig->buffer;
+ ig->read_end = ig->buffer + 1;
+ return *(ig->buffer);
+ }
+ else if (rc == 0) {
+ ig->buf_eof = 1;
+ return EOF;
+ }
+ else {
+ ig->error = 1;
+ return EOF;
+ }
+ }
+
+ if (!ig->read_ptr || ig->read_ptr == ig->read_end) {
+ if (ig->error || ig->buf_eof)
+ return EOF;
+
+ if (!i_io_read_fill(ig, 1))
+ return EOF;
+ }
+
+ return *(ig->read_ptr);
+}
+
+/*
+=item i_io_peekn(ig, buffer, size)
+=category I/O Layers
+=synopsis ssize_t count = i_io_peekn(ig, buffer, sizeof(buffer));
+
+Buffer at least C<size> (at most C<< ig->buf_size >> bytes of data
+from the stream and return C<size> bytes of it to the caller in
+C<buffer>.
+
+This ignores the buffered state of the stream, and will always setup
+buffering if needed.
+
+If no C<type> parameter is provided to Imager::read() or
+Imager::read_multi(), Imager will call C<i_io_peekn()> when probing
+for the file format.
+
+Returns -1 on error, 0 if there is no data before EOF, or the number
+of bytes read into C<buffer>.
+
+=cut
+*/
+
+ssize_t
+i_io_peekn(io_glue *ig, void *buf, size_t size) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn(%p, %p, %d)\n", ig, buf, (int)size));
+
+ if (size == 0) {
+ dIMCTXio(ig);
+ i_push_error(0, "peekn size must be positive");
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (zero size)\n"));
+ return -1;
+ }
+
+ if (ig->write_ptr) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (write_ptr set)\n"));
+ return -1;
+ }
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if ((!ig->read_ptr || size > ig->read_end - ig->read_ptr)
+ && !(ig->buf_eof || ig->error)) {
+ i_io_read_fill(ig, size);
+ }
+
+ if (size > ig->read_end - ig->read_ptr)
+ size = ig->read_end - ig->read_ptr;
+
+ if (size)
+ memcpy(buf, ig->read_ptr, size);
+ else if (ig->buf_eof) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => 0 (eof)\n"));
+ return 0;
+ }
+ else if (ig->error) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (error)\n"));
+ return -1;
+ }
+ else {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() - size 0 but not eof or error!\n"));
+ return -1;
+ }
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => %d\n", (int)size));
+
+ return size;
+}
+
+/*
+=item i_io_putc(ig, c)
+=category I/O Layers
+
+Write a single character to the stream.
+
+On success return c, on error returns EOF
+
+=cut
+*/
+
+int
+i_io_putc_imp(io_glue *ig, int c) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_putc_imp(%p, %d)\n", ig, c));
+
+ if (!ig->buffered) {
+ char buf = c;
+ ssize_t write_result;
+ int result = c;
+
+ if (ig->error)
+ return EOF;
+
+ write_result = i_io_raw_write(ig, &buf, 1);
+ if (write_result != 1) {
+ ig->error = 1;
+ result = EOF;
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered putc() failed, setting error mode\n"));
+ }
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered: result %d\n", result));
+
+ return result;
+ }
+
+ if (ig->read_ptr)
+ return EOF;
+
+ if (ig->error)
+ return EOF;
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if (ig->write_ptr && ig->write_ptr == ig->write_end) {
+ if (!i_io_flush(ig))
+ return EOF;
+ }
+
+ i_io_start_write(ig);
+
+ *(ig->write_ptr)++ = c;
+
+ return (unsigned char)c;
+}
+
+/*
+=item i_io_read(io, buffer, size)
+=category I/O Layers
+
+Read up to C<size> bytes from the stream C<io> into C<buffer>.
+
+Returns the number of bytes read. Returns 0 on end of file. Returns
+-1 on error.
+
+=cut
+*/
+
+ssize_t
+i_io_read(io_glue *ig, void *buf, size_t size) {
+ unsigned char *pbuf = buf;
+ ssize_t read_total = 0;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read(%p, %p, %u)\n", ig, buf, (unsigned)size));
+
+ if (ig->write_ptr) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => -1 (write_ptr set)\n"));
+ return -1;
+ }
+
+ if (!ig->buffer && ig->buffered)
+ i_io_setup_buffer(ig);
+
+ if (ig->read_ptr && ig->read_ptr < ig->read_end) {
+ size_t alloc = ig->read_end - ig->read_ptr;
+
+ if (alloc > size)
+ alloc = size;
+
+ memcpy(pbuf, ig->read_ptr, alloc);
+ ig->read_ptr += alloc;
+ pbuf += alloc;
+ size -= alloc;
+ read_total += alloc;
+ }
+
+ if (size > 0 && !(ig->error || ig->buf_eof)) {
+ if (!ig->buffered || size > ig->buf_size) {
+ ssize_t rc;
+
+ while (size > 0 && (rc = i_io_raw_read(ig, pbuf, size)) > 0) {
+ size -= rc;
+ pbuf += rc;
+ read_total += rc;
+ }
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d (raw read)\n", (int)read_total));
+
+ if (rc < 0)
+ ig->error = 1;
+ else if (rc == 0)
+ ig->buf_eof = 1;
+
+ if (!read_total)
+ return rc;
+ }
+ else {
+ if (i_io_read_fill(ig, size)) {
+ size_t alloc = ig->read_end - ig->read_ptr;
+ if (alloc > size)
+ alloc = size;
+
+ memcpy(pbuf, ig->read_ptr, alloc);
+ ig->read_ptr += alloc;
+ pbuf += alloc;
+ size -= alloc;
+ read_total += alloc;
+ }
+ else {
+ if (!read_total && ig->error) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => -1 (fill failure)\n"));
+ return -1;
+ }
+ }
+ }
+ }
+
+ if (!read_total && ig->error)
+ read_total = -1;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d\n", (int)read_total));
+
+ return read_total;
+}
+
+/*
+=item i_io_write(io, buffer, size)
+=category I/O Layers
+=synopsis ssize_t result = i_io_write(io, buffer, size)
+
+Write to the given I/O stream.
+
+Returns the number of bytes written.
+
+=cut
+*/
+
+ssize_t
+i_io_write(io_glue *ig, const void *buf, size_t size) {
+ const unsigned char *pbuf = buf;
+ size_t write_count = 0;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write(%p, %p, %u)\n", ig, buf, (unsigned)size));
+
+ if (!ig->buffered) {
+ ssize_t result;
+
+ if (ig->error) {
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered, error state\n"));
+ return -1;
+ }
+
+ result = i_io_raw_write(ig, buf, size);
+
+ if (result != size) {
+ ig->error = 1;
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered, setting error flag\n"));
+ }
+
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered, result: %d\n", (int)result));
+
+ return result;
+ }
+
+ if (ig->read_ptr) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (read_ptr set)\n"));
+ return -1;
+ }
+
+ if (ig->error) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (error)\n"));
+ return -1;
+ }
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if (!ig->write_ptr)
+ i_io_start_write(ig);
+
+ if (ig->write_ptr && ig->write_ptr + size <= ig->write_end) {
+ size_t alloc = ig->write_end - ig->write_ptr;
+ if (alloc > size)
+ alloc = size;
+ memcpy(ig->write_ptr, pbuf, alloc);
+ write_count += alloc;
+ size -= alloc;
+ pbuf += alloc;
+ ig->write_ptr += alloc;
+ }
+
+ if (size) {
+ if (!i_io_flush(ig)) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => %d (i_io_flush failure)\n", (int)write_count));
+ return write_count ? write_count : -1;
+ }
+
+ i_io_start_write(ig);
+
+ if (size > ig->buf_size) {
+ ssize_t rc;
+ while (size > 0 && (rc = i_io_raw_write(ig, pbuf, size)) > 0) {
+ write_count += rc;
+ pbuf += rc;
+ size -= rc;
+ }
+ if (rc <= 0) {
+ ig->error = 1;
+ if (!write_count) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (direct write failure)\n"));
+ return -1;
+ }
+ }
+ }
+ else {
+ memcpy(ig->write_ptr, pbuf, size);
+ write_count += size;
+ ig->write_ptr += size;
+ }
+ }
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => %d\n", (int)write_count));
+
+ return write_count;
+}
+
+/*
+=item i_io_seek(io, offset, whence)
+=category I/O Layers
+
+Seek within the stream.
+
+Acts like perl's seek.
+
+=cut
+ */
+
+off_t
+i_io_seek(io_glue *ig, off_t offset, int whence) {
+ off_t new_off;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_seek(%p, %ld, %d)\n", ig, (long)offset, whence));
+
+ if (ig->write_ptr && ig->write_ptr != ig->write_end) {
+ if (!i_io_flush(ig))
+ return (off_t)(-1);
+ }
+
+ if (whence == SEEK_CUR && ig->read_ptr && ig->read_ptr != ig->read_end)
+ offset -= ig->read_end - ig->read_ptr;
+
+ ig->read_ptr = ig->read_end = NULL;
+ ig->write_ptr = ig->write_end = NULL;
+ ig->error = 0;
+ ig->buf_eof = 0;
+
+ new_off = i_io_raw_seek(ig, offset, whence);
+ if (new_off < 0)
+ ig->error = 1;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_seek() => %ld\n", (long)new_off));
+
+ return new_off;
+}
+
+/*
+=item i_io_flush(io)
+=category I/O Layers
+
+Flush any buffered output.
+
+Returns true on success,
+
+=cut
+*/
+
+int
+i_io_flush(io_glue *ig) {
+ unsigned char *bufp;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_flush(%p)\n", ig));
+
+ if (ig->error) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 0 (error set)\n", ig));
+ return 0;
+ }
+
+ /* nothing to do */
+ if (!ig->write_ptr)
+ return 1;
+
+ bufp = ig->buffer;
+ while (bufp < ig->write_ptr) {
+ ssize_t rc = i_io_raw_write(ig, bufp, ig->write_ptr - bufp);
+ if (rc <= 0) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 0 (write error)\n", ig));
+ ig->error = 1;
+ return 0;
+ }
+
+ bufp += rc;
+ }
+
+ ig->write_ptr = ig->write_end = NULL;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 1\n", ig));
+
+ return 1;
+}
+
+/*
+=item i_io_close(io)
+=category I/O Layers
+
+Flush any pending output and perform the close action for the stream.
+
+Returns 0 on success.
+
+=cut
+*/
+
+int
+i_io_close(io_glue *ig) {
+ int result = 0;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_close(%p)\n", ig));
+ if (ig->error)
+ result = -1;
+
+ if (ig->write_ptr && !i_io_flush(ig))
+ result = -1;
+
+ if (i_io_raw_close(ig))
+ result = -1;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_close() => %d\n", result));
+
+ return result;
+}
+
+/*
+=item i_io_gets(ig, buffer, size, end_of_line)
+=category I/O Layers
+=synopsis char buffer[BUFSIZ]
+=synopsis ssize_t len = i_io_gets(buffer, sizeof(buffer), '\n');
+
+Read up to C<size>-1 bytes from the stream C<ig> into C<buffer>.
+
+If the byte C<end_of_line> is seen then no further bytes will be read.
+
+Returns the number of bytes read.
+
+Always C<NUL> terminates the buffer.
+
+=cut
+*/
+
+ssize_t
+i_io_gets(io_glue *ig, char *buffer, size_t size, int eol) {
+ ssize_t read_count = 0;
+ if (size < 2)
+ return 0;
+ --size; /* room for nul */
+ while (size > 0) {
+ int byte = i_io_getc(ig);
+ if (byte == EOF)
+ break;
+ *buffer++ = byte;
+ ++read_count;
+ if (byte == eol)
+ break;
+ --size;
+ }
+ *buffer++ = '\0';
+
+ return read_count;
+}
+
+/*
+=item i_io_init(ig, readcb, writecb, seekcb)
+
+Do common initialization for io_glue objects.
+
+=cut
+*/
+
+static void
+i_io_init(pIMCTX, io_glue *ig, int type, i_io_readp_t readcb, i_io_writep_t writecb,
+ i_io_seekp_t seekcb) {
+ ig->type = type;
+ ig->exdata = NULL;
+ ig->readcb = readcb;
+ ig->writecb = writecb;
+ ig->seekcb = seekcb;
+ ig->closecb = NULL;
+ ig->sizecb = NULL;
+ ig->destroycb = NULL;
+ ig->context = aIMCTX;
+
+ ig->buffer = NULL;
+ ig->read_ptr = NULL;
+ ig->read_end = NULL;
+ ig->write_ptr = NULL;
+ ig->write_end = NULL;
+ ig->buf_size = IO_BUF_SIZE;
+ ig->buf_eof = 0;
+ ig->error = 0;
+ ig->buffered = 1;
+}
+
+/*
+=item i_io_set_buffered(io, buffered)
+=category I/O Layers
+
+Set the buffering mode of the stream.
+
+If you switch buffering off on a stream with buffering on:
+
+=over
+
+=item *
+
+any buffered output will be flushed.
+
+=item *
+
+any existing buffered input will be consumed before reads become
+unbuffered.
+
+=back
+
+Returns true on success. This may fail if any buffered output cannot
+be flushed.
+
+=cut
+*/
+
+int
+i_io_set_buffered(io_glue *ig, int buffered) {
+ if (!buffered && ig->write_ptr) {
+ if (!i_io_flush(ig)) {
+ ig->error = 1;
+ return 0;
+ }
+ }
+ ig->buffered = buffered;
+
+ return 1;
+}
+
+/*
+=item i_io_dump(ig)
+
+Dump the base fields of an io_glue object to stdout.
+
+=cut
+*/
+void
+i_io_dump(io_glue *ig, int flags) {
+ fprintf(IOL_DEBs, "ig %p:\n", ig);
+ fprintf(IOL_DEBs, " type: %d\n", ig->type);
+ fprintf(IOL_DEBs, " exdata: %p\n", ig->exdata);
+ if (flags & I_IO_DUMP_CALLBACKS) {
+ fprintf(IOL_DEBs, " readcb: %p\n", ig->readcb);
+ fprintf(IOL_DEBs, " writecb: %p\n", ig->writecb);
+ fprintf(IOL_DEBs, " seekcb: %p\n", ig->seekcb);
+ fprintf(IOL_DEBs, " closecb: %p\n", ig->closecb);
+ fprintf(IOL_DEBs, " sizecb: %p\n", ig->sizecb);
+ }
+ if (flags & I_IO_DUMP_BUFFER) {
+ fprintf(IOL_DEBs, " buffer: %p\n", ig->buffer);
+ fprintf(IOL_DEBs, " read_ptr: %p\n", ig->read_ptr);
+ if (ig->read_ptr) {
+ fprintf(IOL_DEBs, " ");
+ dump_data(ig->read_ptr, ig->read_end, 0);
+ putc('\n', IOL_DEBs);
+ }
+ fprintf(IOL_DEBs, " read_end: %p\n", ig->read_end);
+ fprintf(IOL_DEBs, " write_ptr: %p\n", ig->write_ptr);
+ if (ig->write_ptr) {
+ fprintf(IOL_DEBs, " ");
+ dump_data(ig->buffer, ig->write_ptr, 1);
+ putc('\n', IOL_DEBs);
+ }
+ fprintf(IOL_DEBs, " write_end: %p\n", ig->write_end);
+ fprintf(IOL_DEBs, " buf_size: %u\n", (unsigned)(ig->buf_size));
+ }
+ if (flags & I_IO_DUMP_STATUS) {
+ fprintf(IOL_DEBs, " buf_eof: %d\n", ig->buf_eof);
+ fprintf(IOL_DEBs, " error: %d\n", ig->error);
+ fprintf(IOL_DEBs, " buffered: %d\n", ig->buffered);
+ }
+}
+
+/*
+=back
+
+=head1 INTERNAL FUNCTIONS
+
+=over
+
+=item my_strerror
+
+Calls strerror() and ensures we don't return NULL.
+
+On some platforms it's possible for strerror() to return NULL, this
+wrapper ensures we only get non-NULL values.
+
+=cut
+*/
+
+static
+const char *my_strerror(int err) {
+ const char *result = strerror(err);
+
+ if (!result)
+ result = "Unknown error";
+
+ return result;
+}
+
+static void
+i_io_setup_buffer(io_glue *ig) {
+ ig->buffer = mymalloc(ig->buf_size);
+}
+
+static void
+i_io_start_write(io_glue *ig) {
+ ig->write_ptr = ig->buffer;
+ ig->write_end = ig->buffer + ig->buf_size;
+}
+
+static int
+i_io_read_fill(io_glue *ig, ssize_t needed) {
+ unsigned char *buf_end = ig->buffer + ig->buf_size;
+ unsigned char *buf_start = ig->buffer;
+ unsigned char *work = ig->buffer;
+ ssize_t rc;
+ int good = 0;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill(%p, %d)\n", ig, (int)needed));
+
+ /* these conditions may be unused, callers should also be checking them */
+ if (ig->error || ig->buf_eof)
+ return 0;
+
+ if (needed > ig->buf_size)
+ needed = ig->buf_size;
+
+ if (ig->read_ptr && ig->read_ptr < ig->read_end) {
+ size_t kept = ig->read_end - ig->read_ptr;
+
+ if (needed < kept) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill(%u) -> 1 (already have enough)\n", (unsigned)needed));
+ return 1;
+ }
+
+ if (ig->read_ptr != ig->buffer)
+ memmove(ig->buffer, ig->read_ptr, kept);
+
+ good = 1; /* we have *something* available to read */
+ work = buf_start + kept;
+ needed -= kept;
+ }
+ else {
+ work = ig->buffer;
+ }
+
+ /* there should always be buffer space the first time around, but
+ avoid a compiler warning here */
+ rc = -1;
+ while (work < buf_end && (rc = i_io_raw_read(ig, work, buf_end - work)) > 0) {
+ work += rc;
+ good = 1;
+ if (needed < rc)
+ break;
+
+ needed -= rc;
+ }
+
+ if (rc < 0) {
+ ig->error = 1;
+ IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc %d, setting error\n",
+ (int)rc));
+ }
+ else if (rc == 0) {
+ ig->buf_eof = 1;
+ IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc 0, setting eof\n"));
+ }
+
+ if (good) {
+ ig->read_ptr = buf_start;
+ ig->read_end = work;
+ }
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill => %d, %u buffered\n", good,
+ (unsigned)(ig->read_end - ig->read_ptr)));
+ return good;
+}
+
+/*
+=item dump_data(start, end, bias)
+
+Hex dump the data between C<start> and C<end>.
+
+If there is more than a pleasing amount of data, either dump the
+beginning (C<bias == 0>) or dump the end C(<bias != 0>) of the range.
+
+=cut
+*/
+
+static void
+dump_data(unsigned char *start, unsigned char *end, int bias) {
+ unsigned char *p;
+ size_t count = end - start;
+
+ if (start == end) {
+ fprintf(IOL_DEBs, "(empty)");
+ return;
+ }
+
+ if (count > 15) {
+ if (bias) {
+ fprintf(IOL_DEBs, "... ");
+ start = end - 14;
+ }
+ else {
+ end = start + 14;
+ }
+
+ for (p = start; p < end; ++p) {
+ fprintf(IOL_DEBs, " %02x", *p);
+ }
+ putc(' ', IOL_DEBs);
+ putc('<', IOL_DEBs);
+ for (p = start; p < end; ++p) {
+ if (*p < ' ' || *p > '~')
+ putc('.', IOL_DEBs);
+ else
+ putc(*p, IOL_DEBs);
+ }
+ putc('>', IOL_DEBs);
+ if (!bias)
+ fprintf(IOL_DEBs, " ...");
+ }
+ else {
+ for (p = start; p < end; ++p) {
+ fprintf(IOL_DEBs, " %02x", *p);
+ }
+ putc(' ', IOL_DEBs);
+ for (p = start; p < end; ++p) {
+ if (*p < ' ' || *p > '~')
+ putc('.', IOL_DEBs);
+ else
+ putc(*p, IOL_DEBs);
+ }
+ }
+}
+
+/*
+ * Callbacks for sources that cannot seek
+ */
+
+/*
+ * Callbacks for sources that can seek
+ */
+
+/*
+=item realseek_read(ig, buf, count)
+
+Does the reading from a source that can be seeked on
+
+ ig - io_glue object
+ buf - buffer to return data in
+ count - number of bytes to read into buffer max
+
+=cut
+*/
+
+static
+ssize_t
+realseek_read(io_glue *igo, void *buf, size_t count) {
+ io_cb *ig = (io_cb *)igo;
+ void *p = ig->p;
+ ssize_t rc = 0;
projects / imager.git / blobdiff