-#include "imio.h"
+#include "imager.h"
#include "iolayer.h"
+#include "imerror.h"
#include "log.h"
#include <stdlib.h>
#include <stdio.h>
#include <io.h>
#endif
#include <string.h>
+#include <errno.h>
+#include "imageri.h"
#define IOL_DEB(x)
+#define IOL_DEBs stderr
+#define IO_BUF_SIZE 8192
char *io_type_names[] = { "FDSEEK", "FDNOSEEK", "BUFFER", "CBSEEK", "CBNOSEEK", "BUFCHAIN" };
+typedef struct io_blink {
+ char buf[BBSIZ];
+ /* size_t cnt; */
+ size_t len; /* How large is this buffer = BBZIS for now */
+ struct io_blink *next;
+ struct io_blink *prev;
+} io_blink;
+
+
+typedef struct {
+ i_io_glue_t base;
+ int fd;
+} io_fdseek;
+
+typedef struct {
+ i_io_glue_t base;
+ char *data;
+ size_t len;
+ i_io_closebufp_t closecb; /* free memory mapped segment or decrement refcount */
+ void *closedata;
+} io_buffer;
+
+typedef struct {
+ i_io_glue_t base;
+ void *p; /* Callback data */
+ 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;
+
+#if 0
+typedef union {
+ io_type type;
+ io_fdseek fdseek;
+ io_buffer buffer;
+ io_cb cb;
+} io_obj;
+
+struct i_io_glue_t {
+ io_obj source;
+ int flags; /* Flags */
+ void *exdata; /* Pair specific data */
+ i_io_readp_t readcb;
+ i_io_writep_t writecb;
+ i_io_seekp_t seekcb;
+ i_io_closep_t closecb;
+ i_io_sizep_t sizecb;
+ i_io_destroyp_t destroycb;
+};
+#endif
+
+/* Structures that describe callback interfaces */
+
+typedef struct {
+ off_t offset;
+ off_t cpos;
+} io_ex_rseek;
+
+
+typedef struct {
+ off_t offset;
+ off_t cpos;
+ io_blink *head;
+ io_blink *tail;
+ io_blink *cp;
+} io_ex_fseek;
+
+
+typedef struct {
+ off_t offset; /* Offset of the source - not used */
+ off_t length; /* Total length of chain in bytes */
+ io_blink *head; /* Start of chain */
+ io_blink *tail; /* End of chain */
+ off_t tfill; /* End of stream in last link */
+ io_blink *cp; /* Current element of list */
+ off_t cpos; /* Offset within the current */
+ off_t gpos; /* Global position in stream */
+} io_ex_bchain;
+
+typedef struct {
+ off_t offset; /* Offset of the source - not used */
+ off_t cpos; /* Offset within the current */
+} io_ex_buffer;
+
+
+/* turn current offset, file length, whence and offset into a new offset */
+#define calc_seek_offset(curr_off, length, offset, whence) \
+ (((whence) == SEEK_SET) ? (offset) : \
+ ((whence) == SEEK_CUR) ? (curr_off) + (offset) : \
+ ((whence) == SEEK_END) ? (length) + (offset) : -1)
/*
=head1 NAME
io_glue *ig = io_new_fd( fileno(stdin) );
method = io_reqmeth( IOL_NOSEEK | IOL_MMAP ); // not implemented yet
- io_glue_commit_types(ig); // always assume IOL_SEEK for now
+
switch (method) {
case IOL_NOSEEK:
code that uses ig->readcb()
break;
}
- io_glue_DESTROY(ig);
+ io_glue_destroy(ig);
// and much more
=head1 DESCRIPTION
static ssize_t fd_read(io_glue *ig, void *buf, size_t count);
static ssize_t fd_write(io_glue *ig, const void *buf, size_t count);
static off_t fd_seek(io_glue *ig, off_t offset, int whence);
-static void fd_close(io_glue *ig);
+static int fd_close(io_glue *ig);
static ssize_t fd_size(io_glue *ig);
+static const char *my_strerror(int err);
/*
* Callbacks for sources that cannot seek
static
ssize_t
-realseek_read(io_glue *ig, void *buf, size_t count) {
- io_ex_rseek *ier = ig->exdata;
- void *p = ig->source.cb.p;
+realseek_read(io_glue *igo, void *buf, size_t count) {
+ io_cb *ig = (io_cb *)igo;
+ io_ex_rseek *ier = igo->exdata;
+ void *p = ig->p;
ssize_t rc = 0;
size_t bc = 0;
char *cbuf = buf;
- IOL_DEB( printf("realseek_read: fd = %d, ier->cpos = %ld, buf = %p, "
- "count = %d\n", fd, (long) ier->cpos, buf, count) );
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_read: buf = %p, count = %u\n",
+ buf, (unsigned)count) );
/* Is this a good idea? Would it be better to handle differently?
skip handling? */
- while( count!=bc && (rc = ig->source.cb.readcb(p,cbuf+bc,count-bc))>0 ) {
+ while( count!=bc && (rc = ig->readcb(p,cbuf+bc,count-bc))>0 ) {
bc+=rc;
}
ier->cpos += bc;
- IOL_DEB( printf("realseek_read: rc = %d, bc = %d\n", rc, bc) );
- return bc;
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_read: rc = %d, bc = %u\n", (int)rc, (unsigned)bc) );
+ return rc < 0 ? rc : bc;
}
static
ssize_t
-realseek_write(io_glue *ig, const void *buf, size_t count) {
- io_ex_rseek *ier = ig->exdata;
- void *p = ig->source.cb.p;
+realseek_write(io_glue *igo, const void *buf, size_t count) {
+ io_cb *ig = (io_cb *)igo;
+ io_ex_rseek *ier = igo->exdata;
+ void *p = ig->p;
ssize_t rc = 0;
size_t bc = 0;
char *cbuf = (char*)buf;
- IOL_DEB( printf("realseek_write: ig = %p, ier->cpos = %ld, buf = %p, "
- "count = %d\n", ig, (long) ier->cpos, buf, count) );
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_write: ig = %p, ier->cpos = %ld, buf = %p, "
+ "count = %u\n", ig, (long) ier->cpos, buf, (unsigned)count) );
/* Is this a good idea? Would it be better to handle differently?
skip handling? */
- while( count!=bc && (rc = ig->source.cb.writecb(p,cbuf+bc,count-bc))>0 ) {
+ while( count!=bc && (rc = ig->writecb(p,cbuf+bc,count-bc))>0 ) {
bc+=rc;
}
ier->cpos += bc;
- IOL_DEB( printf("realseek_write: rc = %d, bc = %d\n", rc, bc) );
- return bc;
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_write: rc = %d, bc = %u\n", (int)rc, (unsigned)bc) );
+ return rc < 0 ? rc : bc;
}
=cut */
static
-void
-realseek_close(io_glue *ig) {
+int
+realseek_close(io_glue *igo) {
+ io_cb *ig = (io_cb *)igo;
+
+ IOL_DEB(fprintf(IOL_DEBs, "realseek_close(%p)\n", ig));
mm_log((1, "realseek_close(ig %p)\n", ig));
- if (ig->source.cb.closecb)
- ig->source.cb.closecb(ig->source.cb.p);
+ if (ig->closecb)
+ return ig->closecb(ig->p);
+ else
+ return 0;
}
static
off_t
-realseek_seek(io_glue *ig, off_t offset, int whence) {
+realseek_seek(io_glue *igo, off_t offset, int whence) {
/* io_ex_rseek *ier = ig->exdata; Needed later */
- void *p = ig->source.cb.p;
- int rc;
- IOL_DEB( printf("realseek_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
- rc = ig->source.cb.seekcb(p, offset, whence);
+ io_cb *ig = (io_cb *)igo;
+ void *p = ig->p;
+ off_t rc;
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
+ rc = ig->seekcb(p, offset, whence);
- IOL_DEB( printf("realseek_seek: rc %ld\n", (long) rc) );
+ IOL_DEB( fprintf(IOL_DEBs, "realseek_seek: rc %ld\n", (long) rc) );
return rc;
/* FIXME: How about implementing this offset handling stuff? */
}
+static
+void
+realseek_destroy(io_glue *igo) {
+ io_cb *ig = (io_cb *)igo;
+ io_ex_rseek *ier = igo->exdata;
+
+ if (ig->destroycb)
+ ig->destroycb(ig->p);
+
+ myfree(ier);
+}
+
/*
* Callbacks for sources that are a fixed size buffer
*/
static
ssize_t
-buffer_read(io_glue *ig, void *buf, size_t count) {
- io_ex_buffer *ieb = ig->exdata;
+buffer_read(io_glue *igo, void *buf, size_t count) {
+ io_buffer *ig = (io_buffer *)igo;
+ io_ex_buffer *ieb = igo->exdata;
- IOL_DEB( printf("buffer_read: fd = %d, ier->cpos = %ld, buf = %p, count = %d\n", fd, (long) ier->cpos, buf, count) );
+ IOL_DEB( fprintf(IOL_DEBs, "buffer_read: ieb->cpos = %ld, buf = %p, count = %u\n", (long) ieb->cpos, buf, (unsigned)count) );
- if ( ieb->cpos+count > ig->source.buffer.len ) {
- mm_log((1,"buffer_read: short read: cpos=%d, len=%d, count=%d\n", ieb->cpos, ig->source.buffer.len));
- count = ig->source.buffer.len - ieb->cpos;
+ if ( ieb->cpos+count > ig->len ) {
+ mm_log((1,"buffer_read: short read: cpos=%ld, len=%ld, count=%ld\n", (long)ieb->cpos, (long)ig->len, (long)count));
+ count = ig->len - ieb->cpos;
}
- memcpy(buf, ig->source.buffer.data+ieb->cpos, count);
+ memcpy(buf, ig->data+ieb->cpos, count);
ieb->cpos += count;
- IOL_DEB( printf("buffer_read: rc = %d, count = %d\n", rc, count) );
+ IOL_DEB( fprintf(IOL_DEBs, "buffer_read: count = %ld\n", (long)count) );
return count;
}
*/
static
-void
+int
buffer_close(io_glue *ig) {
mm_log((1, "buffer_close(ig %p)\n", ig));
- /* FIXME: Do stuff here */
+
+ return 0;
}
static
off_t
-buffer_seek(io_glue *ig, off_t offset, int whence) {
- io_ex_buffer *ieb = ig->exdata;
- off_t reqpos = offset
- + (whence == SEEK_CUR)*ieb->cpos
- + (whence == SEEK_END)*ig->source.buffer.len;
+buffer_seek(io_glue *igo, off_t offset, int whence) {
+ io_buffer *ig = (io_buffer *)igo;
+ io_ex_buffer *ieb = igo->exdata;
+ off_t reqpos =
+ calc_seek_offset(ieb->cpos, ig->len, offset, whence);
- if (reqpos > ig->source.buffer.len) {
+ if (reqpos > ig->len) {
mm_log((1, "seeking out of readable range\n"));
return (off_t)-1;
}
+ if (reqpos < 0) {
+ i_push_error(0, "seek before beginning of file");
+ return (off_t)-1;
+ }
ieb->cpos = reqpos;
- IOL_DEB( printf("buffer_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
+ IOL_DEB( fprintf(IOL_DEBs, "buffer_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
return reqpos;
/* FIXME: How about implementing this offset handling stuff? */
}
-
+static
+void
+buffer_destroy(io_glue *igo) {
+ io_buffer *ig = (io_buffer *)igo;
+ io_ex_buffer *ieb = igo->exdata;
+
+ if (ig->closecb) {
+ mm_log((1,"calling close callback %p for io_buffer\n",
+ ig->closecb));
+ ig->closecb(ig->closedata);
+ }
+ myfree(ieb);
+}
char *cbuf = buf;
size_t sk;
- mm_log((1, "bufchain_read(ig %p, buf %p, count %ld)\n", ig, buf, count));
+ mm_log((1, "bufchain_read(ig %p, buf %p, count %ld)\n", ig, buf, (long)count));
while( scount ) {
int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
ieb->gpos += sk;
}
- mm_log((1, "bufchain_read: returning %d\n", count-scount));
+ mm_log((1, "bufchain_read: returning %ld\n", (long)(count-scount)));
return count-scount;
}
size_t ocount = count;
size_t sk;
- mm_log((1, "bufchain_write: ig = %p, buf = %p, count = %d\n", ig, buf, count));
+ mm_log((1, "bufchain_write: ig = %p, buf = %p, count = %ld\n", ig, buf, (long)count));
- IOL_DEB( printf("bufchain_write: ig = %p, ieb->cpos = %ld, buf = %p, count = %d\n", ig, (long) ieb->cpos, buf, count) );
+ IOL_DEB( fprintf(IOL_DEBs, "bufchain_write: ig = %p, ieb->cpos = %ld, buf = %p, count = %ld\n", ig, (long) ieb->cpos, buf, (long)count) );
while(count) {
- mm_log((2, "bufchain_write: - looping - count = %d\n", count));
+ mm_log((2, "bufchain_write: - looping - count = %ld\n", (long)count));
if (ieb->cp->len == ieb->cpos) {
- mm_log((1, "bufchain_write: cp->len == ieb->cpos = %d - advancing chain\n", (long) ieb->cpos));
+ mm_log((1, "bufchain_write: cp->len == ieb->cpos = %ld - advancing chain\n", (long) ieb->cpos));
io_bchain_advance(ieb);
}
*/
static
-void
+int
bufchain_close(io_glue *ig) {
mm_log((1, "bufchain_close(ig %p)\n",ig));
- IOL_DEB( printf("bufchain_close(ig %p)\n", ig) );
- /* FIXME: Commit a seek point here */
-
+ IOL_DEB( fprintf(IOL_DEBs, "bufchain_close(ig %p)\n", ig) );
+
+ return 0;
}
off_t
bufchain_seek(io_glue *ig, off_t offset, int whence) {
io_ex_bchain *ieb = ig->exdata;
- io_blink *ib = NULL;
int wrlen;
- off_t cof = 0;
- off_t scount = offset;
+ off_t scount = calc_seek_offset(ieb->gpos, ieb->length, offset, whence);
off_t sk;
- mm_log((1, "bufchain_seek(ig %p, offset %ld, whence %d)\n", ig, offset, whence));
-
- switch (whence) {
- case SEEK_SET: /* SEEK_SET = 0, From the top */
- ieb->cp = ieb->head;
- ieb->cpos = 0;
- ieb->gpos = 0;
-
- while( scount ) {
- int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
- if (clen == ieb->cpos) {
- if (ieb->cp == ieb->tail) break; /* EOF */
- ieb->cp = ieb->cp->next;
- ieb->cpos = 0;
- clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
- }
-
- sk = clen - ieb->cpos;
- sk = sk > scount ? scount : sk;
-
- scount -= sk;
- ieb->cpos += sk;
- ieb->gpos += sk;
- }
+ mm_log((1, "bufchain_seek(ig %p, offset %ld, whence %d)\n", ig, (long)offset, whence));
- wrlen = scount;
-
- if (wrlen > 0) {
- /*
- * extending file - get ieb into consistent state and then
- * call write which will get it to the correct position
- */
- char TB[BBSIZ];
- memset(TB, 0, BBSIZ);
- ieb->gpos = ieb->length;
- ieb->cpos = ieb->tfill;
-
- while(wrlen > 0) {
- ssize_t rc, wl = i_min(wrlen, BBSIZ);
- mm_log((1, "bufchain_seek: wrlen = %d, wl = %d\n", wrlen, wl));
- rc = bufchain_write( ig, TB, wl );
- if (rc != wl) m_fatal(0, "bufchain_seek: Unable to extend file\n");
- wrlen -= rc;
- }
+ if (scount < 0) {
+ i_push_error(0, "invalid whence supplied or seek before start of file");
+ return (off_t)-1;
+ }
+
+ ieb->cp = ieb->head;
+ ieb->cpos = 0;
+ ieb->gpos = 0;
+
+ while( scount ) {
+ int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
+ if (clen == ieb->cpos) {
+ if (ieb->cp == ieb->tail) break; /* EOF */
+ ieb->cp = ieb->cp->next;
+ ieb->cpos = 0;
+ clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
}
- break;
-
- case SEEK_CUR:
- m_fatal(123, "SEEK_CUR IS NOT IMPLEMENTED\n");
-
- /*
- case SEEK_CUR:
- ib = ieb->cp;
- if (cof < 0) {
- cof += ib->cpos;
- cpos = 0;
- while(cof < 0 && ib->prev) {
- ib = ib->prev;
- cof += ib->len;
- }
- */
+ sk = clen - ieb->cpos;
+ sk = sk > scount ? scount : sk;
- case SEEK_END: /* SEEK_END = 2 */
- if (cof>0) m_fatal(0, "bufchain_seek: SEEK_END + %d : Extending files via seek not supported!\n", cof);
+ scount -= sk;
+ ieb->cpos += sk;
+ ieb->gpos += sk;
+ }
+
+ wrlen = scount;
- ieb->cp = ieb->tail;
+ if (wrlen > 0) {
+ /*
+ * extending file - get ieb into consistent state and then
+ * call write which will get it to the correct position
+ */
+ char TB[BBSIZ];
+ memset(TB, 0, BBSIZ);
+ ieb->gpos = ieb->length;
ieb->cpos = ieb->tfill;
- if (cof<0) {
- cof += ieb->cpos;
- ieb->cpos = 0;
-
- while(cof<0 && ib->prev) {
- ib = ib->prev;
- cof += ib->len;
- }
-
- if (cof<0) m_fatal(0, "bufchain_seek: Tried to seek before start of file\n");
- ieb->gpos = ieb->length+offset;
- ieb->cpos = cof;
+ while(wrlen > 0) {
+ ssize_t rc, wl = i_min(wrlen, BBSIZ);
+ mm_log((1, "bufchain_seek: wrlen = %d, wl = %ld\n", wrlen, (long)wl));
+ rc = bufchain_write( ig, TB, wl );
+ if (rc != wl) i_fatal(0, "bufchain_seek: Unable to extend file\n");
+ wrlen -= rc;
}
- break;
- default:
- m_fatal(0, "bufchain_seek: Unhandled seek request: whence = %d\n", whence );
}
- mm_log((2, "bufchain_seek: returning ieb->gpos = %d\n", ieb->gpos));
+ mm_log((2, "bufchain_seek: returning ieb->gpos = %ld\n", (long)ieb->gpos));
return ieb->gpos;
}
+static
+void
+bufchain_destroy(io_glue *ig) {
+ io_ex_bchain *ieb = ig->exdata;
+ io_destroy_bufchain(ieb);
-
-
+ myfree(ieb);
+}
/*
* Methods for setting up data source
*/
+#if 0
/*
=item io_obj_setp_buffer(io, p, len)
=cut
*/
-void
-io_obj_setp_buffer(io_obj *io, char *p, size_t len, closebufp closecb, void *closedata) {
- io->buffer.type = BUFFER;
- io->buffer.data = p;
- io->buffer.len = len;
- io->buffer.closecb = closecb;
- io->buffer.closedata = closedata;
-}
-
-
-/*
-=item io_obj_setp_buchain(io)
-
-Sets an io_object for reading/writing from a buffer source
-
- io - io object that describes a source
- p - pointer to buffer
- len - length of buffer
-
-=cut
-*/
-
-void
-io_obj_setp_bufchain(io_obj *io) {
- io->type = BUFCHAIN;
-}
-
-
-/*
-=item io_obj_setp_cb2(io, p, readcb, writecb, seekcb, closecb, destroycb)
-
-Sets an io_object for reading from a source that uses callbacks
-
- io - io object that describes a source
- p - pointer to data for callbacks
- readcb - read callback to read from source
- writecb - write callback to write to source
- seekcb - seek callback to seek on source
- closecb - flush any pending data
- destroycb - release any extra resources
-
-=cut
-*/
-
-void
-io_obj_setp_cb2(io_obj *io, void *p, readl readcb, writel writecb, seekl seekcb, closel closecb, destroyl destroycb) {
- io->cb.type = CBSEEK;
- io->cb.p = p;
- io->cb.readcb = readcb;
- io->cb.writecb = writecb;
- io->cb.seekcb = seekcb;
- io->cb.closecb = closecb;
- io->cb.destroycb = destroycb;
-}
-
-void
-io_obj_setp_cb(io_obj *io, void *p, readl readcb, writel writecb,
- seekl seekcb) {
- io_obj_setp_cb2(io, p, readcb, writecb, seekcb, NULL, NULL);
-}
-
-/*
-=item io_glue_commit_types(ig)
-
-Creates buffers and initializes structures to read with the chosen interface.
-
- ig - io_glue object
-
-=cut
-*/
-
-void
-io_glue_commit_types(io_glue *ig) {
- io_type inn = ig->source.type;
-
- mm_log((1, "io_glue_commit_types(ig %p)\n", ig));
- mm_log((1, "io_glue_commit_types: source type %d (%s)\n", inn, io_type_names[inn]));
-
- if (ig->flags & 0x01) {
- mm_log((1, "io_glue_commit_types: type already set up\n"));
- return;
- }
-
- switch (inn) {
- case BUFCHAIN:
- {
- io_ex_bchain *ieb = mymalloc(sizeof(io_ex_bchain));
-
- ieb->offset = 0;
- ieb->length = 0;
- ieb->cpos = 0;
- ieb->gpos = 0;
- ieb->tfill = 0;
-
- ieb->head = io_blink_new();
- ieb->cp = ieb->head;
- ieb->tail = ieb->head;
-
- ig->exdata = ieb;
- ig->readcb = bufchain_read;
- ig->writecb = bufchain_write;
- ig->seekcb = bufchain_seek;
- ig->closecb = bufchain_close;
- }
- break;
- case CBSEEK:
- {
- io_ex_rseek *ier = mymalloc(sizeof(io_ex_rseek));
-
- ier->offset = 0;
- ier->cpos = 0;
-
- ig->exdata = ier;
- ig->readcb = realseek_read;
- ig->writecb = realseek_write;
- ig->seekcb = realseek_seek;
- ig->closecb = realseek_close;
- }
- break;
- case BUFFER:
- {
- io_ex_buffer *ieb = mymalloc(sizeof(io_ex_buffer));
- ieb->offset = 0;
- ieb->cpos = 0;
-
- ig->exdata = ieb;
- ig->readcb = buffer_read;
- ig->writecb = buffer_write;
- ig->seekcb = buffer_seek;
- ig->closecb = buffer_close;
- }
- break;
- case FDSEEK:
- {
- ig->exdata = NULL;
- ig->readcb = fd_read;
- ig->writecb = fd_write;
- ig->seekcb = fd_seek;
- ig->closecb = fd_close;
- break;
- }
- }
- ig->flags |= 0x01; /* indicate source has been setup already */
-}
-
-/*
-=item io_glue_gettypes(ig, reqmeth)
-
-Returns a set of compatible interfaces to read data with.
-
- ig - io_glue object
- reqmeth - request mask
-
-The request mask is a bit mask (of something that hasn't been implemented yet)
-of interfaces that it would like to read data from the source which the ig
-describes.
-
-=cut
-*/
-
-void
-io_glue_gettypes(io_glue *ig, int reqmeth) {
-
- ig = NULL;
- reqmeth = 0;
-
- /* FIXME: Implement this function! */
- /* if (ig->source.type =
- if (reqmeth & IO_BUFF) */
-
+static void
+io_obj_setp_buffer(io_buffer *io, char *p, size_t len, i_io_closebufp_t closecb,
+ void *closedata) {
}
+#endif
/*
=item io_new_bufchain()
io_glue *
io_new_bufchain() {
io_glue *ig;
+ io_ex_bchain *ieb = mymalloc(sizeof(io_ex_bchain));
+
mm_log((1, "io_new_bufchain()\n"));
+
ig = mymalloc(sizeof(io_glue));
memset(ig, 0, sizeof(*ig));
- io_obj_setp_bufchain(&ig->source);
- return ig;
-}
-
-
+ i_io_init(ig, BUFCHAIN, bufchain_read, bufchain_write, bufchain_seek);
+ ieb->offset = 0;
+ ieb->length = 0;
+ ieb->cpos = 0;
+ ieb->gpos = 0;
+ ieb->tfill = 0;
+
+ ieb->head = io_blink_new();
+ ieb->cp = ieb->head;
+ ieb->tail = ieb->head;
+
+ ig->exdata = ieb;
+ ig->closecb = bufchain_close;
+ ig->destroycb = bufchain_destroy;
+ return ig;
+}
/*
=item io_new_buffer(data, len)
*/
io_glue *
-io_new_buffer(char *data, size_t len, closebufp closecb, void *closedata) {
- io_glue *ig;
- mm_log((1, "io_new_buffer(data %p, len %d, closecb %p, closedata %p)\n", data, len, closecb, closedata));
- ig = mymalloc(sizeof(io_glue));
+io_new_buffer(char *data, size_t len, i_io_closebufp_t closecb, void *closedata) {
+ io_buffer *ig;
+ io_ex_buffer *ieb = mymalloc(sizeof(io_ex_buffer));
+
+ mm_log((1, "io_new_buffer(data %p, len %ld, closecb %p, closedata %p)\n", data, (long)len, closecb, closedata));
+
+ ig = mymalloc(sizeof(io_buffer));
memset(ig, 0, sizeof(*ig));
- io_obj_setp_buffer(&ig->source, data, len, closecb, closedata);
- ig->flags = 0;
- return ig;
+ i_io_init(&ig->base, BUFFER, buffer_read, buffer_write, buffer_seek);
+ ig->data = data;
+ ig->len = len;
+ ig->closecb = closecb;
+ ig->closedata = closedata;
+
+ ieb->offset = 0;
+ ieb->cpos = 0;
+
+ ig->base.exdata = ieb;
+ ig->base.closecb = buffer_close;
+ ig->base.destroycb = buffer_destroy;
+
+ return (io_glue *)ig;
}
io_glue *
io_new_fd(int fd) {
- io_glue *ig;
+ io_fdseek *ig;
+
mm_log((1, "io_new_fd(fd %d)\n", fd));
- ig = mymalloc(sizeof(io_glue));
+
+ ig = mymalloc(sizeof(io_fdseek));
memset(ig, 0, sizeof(*ig));
- ig->source.type = FDSEEK;
- ig->source.fdseek.fd = fd;
- ig->flags = 0;
-#if 0
-#ifdef _MSC_VER
- io_obj_setp_cb(&ig->source, (void*)fd, _read, _write, _lseek);
-#else
- io_obj_setp_cb(&ig->source, (void*)fd, read, write, lseek);
-#endif
-#endif
+ i_io_init(&ig->base, FDSEEK, fd_read, fd_write, fd_seek);
+ ig->fd = fd;
+
+ ig->base.closecb = fd_close;
+ ig->base.sizecb = fd_size;
+ ig->base.destroycb = NULL;
+
mm_log((1, "(%p) <- io_new_fd\n", ig));
- return ig;
+ return (io_glue *)ig;
}
-io_glue *io_new_cb(void *p, readl readcb, writel writecb, seekl seekcb,
- closel closecb, destroyl destroycb) {
- io_glue *ig;
+io_glue *io_new_cb(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;
+ io_ex_rseek *ier = mymalloc(sizeof(io_ex_rseek));
mm_log((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_glue));
+ ig = mymalloc(sizeof(io_cb));
memset(ig, 0, sizeof(*ig));
- io_obj_setp_cb2(&ig->source, p, readcb, writecb, seekcb, closecb, destroycb);
+ i_io_init(&ig->base, CBSEEK, realseek_read, realseek_write, realseek_seek);
mm_log((1, "(%p) <- io_new_cb\n", ig));
- return ig;
+ ier->offset = 0;
+ ier->cpos = 0;
+
+ ig->base.exdata = ier;
+ 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;
+
+ return (io_glue *)ig;
}
/*
off_t orgoff;
io_ex_bchain *ieb;
unsigned char *cc;
- io_type inn = ig->source.type;
+ io_type inn = ig->type;
if ( inn != BUFCHAIN ) {
- m_fatal(0, "io_slurp: called on a source that is not from a bufchain\n");
+ i_fatal(0, "io_slurp: called on a source that is not from a bufchain\n");
}
ieb = ig->exdata;
rc = bufchain_read(ig, cc, ieb->length);
if (rc != ieb->length)
- m_fatal(1, "io_slurp: bufchain_read returned an incomplete read: rc = %d, request was %d\n", rc, ieb->length);
+ i_fatal(1, "io_slurp: bufchain_read returned an incomplete read: rc = %d, request was %d\n", rc, ieb->length);
return rc;
}
=cut
*/
-static ssize_t fd_read(io_glue *ig, void *buf, size_t count) {
+static ssize_t fd_read(io_glue *igo, void *buf, size_t count) {
+ io_fdseek *ig = (io_fdseek *)igo;
+ ssize_t result;
#ifdef _MSC_VER
- return _read(ig->source.fdseek.fd, buf, count);
+ result = _read(ig->fd, buf, count);
#else
- return read(ig->source.fdseek.fd, buf, count);
+ result = read(ig->fd, buf, count);
#endif
+
+ /* 0 is valid - means EOF */
+ if (result < 0) {
+ i_push_errorf(0, "read() failure: %s (%d)", my_strerror(errno), errno);
+ }
+
+ return result;
}
-static ssize_t fd_write(io_glue *ig, const void *buf, size_t count) {
+static ssize_t fd_write(io_glue *igo, const void *buf, size_t count) {
+ io_fdseek *ig = (io_fdseek *)igo;
+ ssize_t result;
#ifdef _MSC_VER
- return _write(ig->source.fdseek.fd, buf, count);
+ result = _write(ig->fd, buf, count);
#else
- return write(ig->source.fdseek.fd, buf, count);
+ result = write(ig->fd, buf, count);
#endif
+
+ if (result <= 0) {
+ i_push_errorf(errno, "write() failure: %s (%d)", my_strerror(errno), errno);
+ }
+
+ return result;
}
-static off_t fd_seek(io_glue *ig, off_t offset, int whence) {
+static off_t fd_seek(io_glue *igo, off_t offset, int whence) {
+ io_fdseek *ig = (io_fdseek *)igo;
+ off_t result;
#ifdef _MSC_VER
- return _lseek(ig->source.fdseek.fd, offset, whence);
+ result = _lseek(ig->fd, offset, whence);
#else
- return lseek(ig->source.fdseek.fd, offset, whence);
+ result = lseek(ig->fd, offset, whence);
#endif
+
+ if (result == (off_t)-1) {
+ i_push_errorf(errno, "lseek() failure: %s (%d)", my_strerror(errno), errno);
+ }
+
+ return result;
}
-static void fd_close(io_glue *ig) {
+static int fd_close(io_glue *ig) {
/* no, we don't close it */
+ return 0;
}
static ssize_t fd_size(io_glue *ig) {
}
/*
-=item io_glue_DESTROY(ig)
+=item io_glue_destroy(ig)
A destructor method for io_glue objects. Should clean up all related buffers.
Might leave us with a dangling pointer issue on some buffers.
*/
void
-io_glue_DESTROY(io_glue *ig) {
- io_type inn = ig->source.type;
+io_glue_destroy(io_glue *ig) {
mm_log((1, "io_glue_DESTROY(ig %p)\n", ig));
+
+ if (ig->destroycb)
+ ig->destroycb(ig);
+
+ if (ig->buffer)
+ myfree(ig->buffer);
- switch (inn) {
- case BUFCHAIN:
- {
- io_ex_bchain *ieb = ig->exdata;
- io_destroy_bufchain(ieb);
- myfree(ieb);
+ myfree(ig);
+}
+
+/*
+=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) {
+ 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;
+
+ if (ig->err_code)
+ return 0;
+
+ while (work < buf_end && (rc = i_io_raw_read(ig, work, buf_end - work)) > 0) {
+ work += rc;
+ good = 1;
+ }
+
+ if (good) {
+ ig->read_ptr = buf_start;
+ ig->read_end = work;
+ }
+
+ return good;
+}
+
+/*
+=item i_iob_getc(ig)
+
+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->buffer)
+ i_io_setup_buffer(ig);
+
+ if (ig->err_code)
+ return EOF;
+
+ if (!ig->read_ptr || ig->read_ptr == ig->read_end) {
+ if (!i_io_read_fill(ig))
+ return EOF;
+ }
+
+ return *(ig->read_ptr++);
+}
+
+int
+i_io_peekc_imp(io_glue *ig) {
+ if (ig->write_ptr)
+ return EOF;
+
+ if (ig->err_code)
+ 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))
+ return EOF;
+ }
+
+ return *(ig->read_ptr);
+}
+
+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 (ig->write_ptr) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (write_ptr set)\n"));
+ return -1;
+ }
+
+ if (ig->err_code) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (err_code set: %d)\n", ig->err_code));
+ return -1;
+ }
+
+ if (!ig->buffer)
+ i_io_setup_buffer(ig);
+
+ if (!ig->read_ptr) {
+ if (!i_io_read_fill(ig)) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (read fill failed)\n"));
+ return -1;
}
- break;
- case CBSEEK:
- {
- io_ex_rseek *ier = ig->exdata;
- if (ig->source.cb.destroycb)
- ig->source.cb.destroycb(ig->source.cb.p);
- myfree(ier);
+ }
+
+ if (size > ig->read_end - ig->read_ptr)
+ size = ig->read_end - ig->read_ptr;
+
+ memcpy(buf, ig->read_ptr, size);
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => %d\n", (int)size));
+
+ return size;
+}
+
+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 = i_io_raw_write(ig, &buf, 1);
+ int result = write_result == 1 ? c : EOF;
+ IOL_DEB(fprintf(IOL_DEBs, " unbuffered: result %d\n", result));
+
+ return result;
+ }
+
+ if (ig->read_ptr)
+ return EOF;
+
+ if (ig->err_code)
+ 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;
+}
+
+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() => 0 (read_ptr set)\n"));
+ return -1;
+ }
+
+ if (ig->err_code) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => 0 (err_code set: %d)\n", ig->err_code));
+ return -1;
+ }
+
+ if (!ig->buffer)
+ 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 > 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;
}
- break;
- case BUFFER:
- {
- io_ex_buffer *ieb = ig->exdata;
- if (ig->source.buffer.closecb) {
- mm_log((1,"calling close callback %p for io_buffer\n", ig->source.buffer.closecb));
- ig->source.buffer.closecb(ig->source.buffer.closedata);
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d (raw read)\n", (int)read_total));
+
+ return read_total;
+ }
+ else if (size > 0) {
+ if (i_io_read_fill(ig)) {
+ 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->err_code) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => -1 (fill failure)\n"));
+ return -1;
}
- myfree(ieb);
}
- break;
- default:
- break;
}
- myfree(ig);
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d\n", (int)read_total));
+
+ return read_total;
+}
+
+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 = i_io_raw_write(ig, buf, size);
+
+ 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->err_code) {
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (err_code set: %d)\n", ig->err_code));
+ 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) {
+ if (!ig->err_code) {
+ ig->err_code = 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;
+}
+
+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)
+ i_io_flush(ig);
+
+ ig->read_ptr = ig->read_end = NULL;
+ ig->write_ptr = ig->write_end = NULL;
+ ig->err_code = 0;
+ ig->buf_eof = 0;
+
+ new_off = i_io_raw_seek(ig, offset, whence);
+ if (new_off < 0 && !ig->err_code)
+ ig->err_code = 1;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_seek() => %ld\n", (long)new_off));
+
+ return new_off;
}
+int
+i_io_flush(io_glue *ig) {
+ unsigned char *bufp;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_flush(%p)\n", ig));
+
+ /* 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) {
+ if (!ig->err_code) ig->err_code = 0;
+ return 0;
+ }
+
+ bufp += rc;
+ }
+
+ ig->write_ptr = ig->write_end = NULL;
+
+ return 1;
+}
+
+int
+i_io_close(io_glue *ig) {
+ int result = 0;
+
+ IOL_DEB(fprintf(IOL_DEBs, "i_io_close(%p)\n", ig));
+ 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_init(ig, readcb, writecb, seekcb)
+
+Do common initialization for io_glue objects.
+
+=cut
+*/
+
+void
+i_io_init(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->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->err_code = 0;
+ ig->buffered = 1;
+}
+
+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);
+ }
+ }
+}
+
+/*
+=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, " err_code: %d\n", ig->err_code);
+ fprintf(IOL_DEBs, " buffered: %d\n", ig->buffered);
+ }
+}
/*
=back
projects / imager.git / blobdiff