Merge the I/O buffering branch
[imager.git] / iolayer.c
1 #include "imager.h"
2 #include "iolayer.h"
3 #include "imerror.h"
4 #include "log.h"
5 #include <stdlib.h>
6 #include <stdio.h>
7 #ifdef _MSC_VER
8 #include <io.h>
9 #endif
10 #include <string.h>
11 #include <errno.h>
12 #include "imageri.h"
13
14 #define IOL_DEB(x)
15 #define IOL_DEBs stderr
16
17 #define IO_BUF_SIZE 8192
18
19 char *io_type_names[] = { "FDSEEK", "FDNOSEEK", "BUFFER", "CBSEEK", "CBNOSEEK", "BUFCHAIN" };
20
21 typedef struct io_blink {
22   char buf[BBSIZ];
23   /* size_t cnt; */
24   size_t len;                   /* How large is this buffer = BBZIS for now */
25   struct io_blink *next;
26   struct io_blink *prev;
27 } io_blink;
28
29
30 typedef struct {
31   i_io_glue_t   base;
32   int           fd;
33 } io_fdseek;
34
35 typedef struct {
36   i_io_glue_t   base;
37   const char    *data;
38   size_t        len;
39   i_io_closebufp_t     closecb;        /* free memory mapped segment or decrement refcount */
40   void          *closedata;
41   off_t cpos;
42 } io_buffer;
43
44 typedef struct {
45   i_io_glue_t   base;
46   void          *p;             /* Callback data */
47   i_io_readl_t  readcb;
48   i_io_writel_t writecb;
49   i_io_seekl_t  seekcb;
50   i_io_closel_t closecb;
51   i_io_destroyl_t      destroycb;
52 } io_cb;
53
54 typedef struct {
55   off_t offset;                 /* Offset of the source - not used */
56   off_t length;                 /* Total length of chain in bytes */
57   io_blink *head;               /* Start of chain */
58   io_blink *tail;               /* End of chain */
59   off_t tfill;                  /* End of stream in last link */
60   io_blink *cp;                 /* Current element of list */
61   off_t cpos;                   /* Offset within the current */
62   off_t gpos;                   /* Global position in stream */
63 } io_ex_bchain;
64
65 /* turn current offset, file length, whence and offset into a new offset */
66 #define calc_seek_offset(curr_off, length, offset, whence) \
67   (((whence) == SEEK_SET) ? (offset) : \
68    ((whence) == SEEK_CUR) ? (curr_off) + (offset) : \
69    ((whence) == SEEK_END) ? (length) + (offset) : -1)
70
71 /*
72 =head1 NAME
73
74 iolayer.c - encapsulates different source of data into a single framework.
75
76 =head1 SYNOPSIS
77
78   io_glue *ig = io_new_fd( fileno(stdin) );
79   method = io_reqmeth( IOL_NOSEEK | IOL_MMAP ); // not implemented yet
80
81   switch (method) {
82   case IOL_NOSEEK:
83     code that uses ig->readcb()
84     to read data goes here.
85     break;
86   case IOL_MMAP:
87     code that uses ig->readcb()
88     to read data goes here.
89     break;
90   }  
91
92   io_glue_destroy(ig);
93   // and much more
94
95 =head1 DESCRIPTION
96
97 iolayer.c implements the basic functions to create and destroy io_glue
98 objects for Imager.  The typical usage pattern for data sources is:
99
100    1. Create the source (io_new_fd)
101    2. Define how you want to get data from it (io_reqmeth)
102    3. read from it using the interface requested (ig->readdb, ig->mmapcb)
103    4. Close the source, which 
104       shouldn't really close the underlying source. (io_glue DESTROY)
105
106 =head1 FUNCTION REFERENCE
107
108 Some of these functions are internal.
109
110 =over
111
112 =cut
113 */
114
115 static void
116 i_io_init(io_glue *ig, int type, i_io_readp_t readcb, i_io_writep_t writecb,
117           i_io_seekp_t seekcb);
118
119 static ssize_t fd_read(io_glue *ig, void *buf, size_t count);
120 static ssize_t fd_write(io_glue *ig, const void *buf, size_t count);
121 static off_t fd_seek(io_glue *ig, off_t offset, int whence);
122 static int fd_close(io_glue *ig);
123 static ssize_t fd_size(io_glue *ig);
124 static const char *my_strerror(int err);
125 static void i_io_setup_buffer(io_glue *ig);
126 static void
127 i_io_start_write(io_glue *ig);
128 static int
129 i_io_read_fill(io_glue *ig, ssize_t needed);
130 static void
131 dump_data(unsigned char *start, unsigned char *end, int bias);
132 static ssize_t realseek_read(io_glue *igo, void *buf, size_t count);
133 static ssize_t realseek_write(io_glue *igo, const void *buf, size_t count);
134 static int realseek_close(io_glue *igo);
135 static off_t realseek_seek(io_glue *igo, off_t offset, int whence);
136 static void realseek_destroy(io_glue *igo);
137 static ssize_t buffer_read(io_glue *igo, void *buf, size_t count);
138 static ssize_t buffer_write(io_glue *ig, const void *buf, size_t count);
139 static int buffer_close(io_glue *ig);
140 static off_t buffer_seek(io_glue *igo, off_t offset, int whence);
141 static void buffer_destroy(io_glue *igo);
142 static io_blink*io_blink_new(void);
143 static void io_bchain_advance(io_ex_bchain *ieb);
144 static void io_destroy_bufchain(io_ex_bchain *ieb);
145 static ssize_t bufchain_read(io_glue *ig, void *buf, size_t count);
146 static ssize_t bufchain_write(io_glue *ig, const void *buf, size_t count);
147 static int bufchain_close(io_glue *ig);
148 static off_t bufchain_seek(io_glue *ig, off_t offset, int whence);
149 static void bufchain_destroy(io_glue *ig);
150
151 /*
152  * Methods for setting up data source
153  */
154
155 /*
156 =item io_new_bufchain()
157 =order 10
158 =category I/O Layers
159
160 returns a new io_glue object that has the 'empty' source and but can
161 be written to and read from later (like a pseudo file).
162
163 =cut
164 */
165
166 io_glue *
167 io_new_bufchain() {
168   io_glue *ig;
169   io_ex_bchain *ieb = mymalloc(sizeof(io_ex_bchain));
170
171   mm_log((1, "io_new_bufchain()\n"));
172
173   ig = mymalloc(sizeof(io_glue));
174   memset(ig, 0, sizeof(*ig));
175   i_io_init(ig, BUFCHAIN, bufchain_read, bufchain_write, bufchain_seek);
176
177   ieb->offset = 0;
178   ieb->length = 0;
179   ieb->cpos   = 0;
180   ieb->gpos   = 0;
181   ieb->tfill  = 0;
182   
183   ieb->head   = io_blink_new();
184   ieb->cp     = ieb->head;
185   ieb->tail   = ieb->head;
186   
187   ig->exdata    = ieb;
188   ig->closecb   = bufchain_close;
189   ig->destroycb = bufchain_destroy;
190
191   return ig;
192 }
193
194 /*
195 =item io_new_buffer(data, length)
196 =order 10
197 =category I/O Layers
198
199 Returns a new io_glue object that has the source defined as reading
200 from specified buffer.  Note that the buffer is not copied.
201
202    data - buffer to read from
203    length - length of buffer
204
205 =cut
206 */
207
208 io_glue *
209 io_new_buffer(const char *data, size_t len, i_io_closebufp_t closecb, void *closedata) {
210   io_buffer *ig;
211   
212   mm_log((1, "io_new_buffer(data %p, len %ld, closecb %p, closedata %p)\n", data, (long)len, closecb, closedata));
213
214   ig = mymalloc(sizeof(io_buffer));
215   memset(ig, 0, sizeof(*ig));
216   i_io_init(&ig->base, BUFFER, buffer_read, buffer_write, buffer_seek);
217   ig->data      = data;
218   ig->len       = len;
219   ig->closecb   = closecb;
220   ig->closedata = closedata;
221
222   ig->cpos   = 0;
223   
224   ig->base.closecb   = buffer_close;
225   ig->base.destroycb = buffer_destroy;
226
227   return (io_glue *)ig;
228 }
229
230
231 /*
232 =item io_new_fd(fd)
233 =order 10
234 =category I/O Layers
235
236 returns a new io_glue object that has the source defined as reading
237 from specified file descriptor.  Note that the the interface to receiving
238 data from the io_glue callbacks hasn't been done yet.
239
240    fd - file descriptor to read/write from
241
242 =cut
243 */
244
245 io_glue *
246 io_new_fd(int fd) {
247   io_fdseek *ig;
248
249   mm_log((1, "io_new_fd(fd %d)\n", fd));
250
251   ig = mymalloc(sizeof(io_fdseek));
252   memset(ig, 0, sizeof(*ig));
253   i_io_init(&ig->base, FDSEEK, fd_read, fd_write, fd_seek);
254   ig->fd = fd;
255
256   ig->base.closecb   = fd_close;
257   ig->base.sizecb    = fd_size;
258   ig->base.destroycb = NULL;
259
260   mm_log((1, "(%p) <- io_new_fd\n", ig));
261   return (io_glue *)ig;
262 }
263
264 /*
265 =item io_new_cb(p, read_cb, write_cb, seek_cb, close_cb, destroy_cb)
266 =category I/O Layers
267 =order 10
268
269 Create a new I/O layer object that calls your supplied callbacks.
270
271 In general the callbacks should behave like the corresponding POSIX
272 primitives.
273
274 =over
275
276 =item *
277
278 C<read_cb>(p, buffer, length) should read up to C<length> bytes into
279 C<buffer> and return the number of bytes read.  At end of file, return
280 0.  On error, return -1.
281
282 =item *
283
284 C<write_cb>(p, buffer, length) should write up to C<length> bytes from
285 C<buffer> and return the number of bytes written.  A return value <= 0
286 will be treated as an error.
287
288 =item *
289
290 C<seekcb>(p, offset, whence) should seek and return the new offset.
291
292 =item *
293
294 C<close_cb>(p) should return 0 on success, -1 on failure.
295
296 =item *
297
298 C<destroy_cb>(p) should release any memory specific to your callback
299 handlers.
300
301 =back
302
303 =cut
304 */
305
306 io_glue *
307 io_new_cb(void *p, i_io_readl_t readcb, i_io_writel_t writecb, 
308           i_io_seekl_t seekcb, i_io_closel_t closecb, 
309           i_io_destroyl_t destroycb) {
310   io_cb *ig;
311
312   mm_log((1, "io_new_cb(p %p, readcb %p, writecb %p, seekcb %p, closecb %p, "
313           "destroycb %p)\n", p, readcb, writecb, seekcb, closecb, destroycb));
314   ig = mymalloc(sizeof(io_cb));
315   memset(ig, 0, sizeof(*ig));
316   i_io_init(&ig->base, CBSEEK, realseek_read, realseek_write, realseek_seek);
317   mm_log((1, "(%p) <- io_new_cb\n", ig));
318
319   ig->base.closecb   = realseek_close;
320   ig->base.destroycb = realseek_destroy;
321
322   ig->p         = p;
323   ig->readcb    = readcb;
324   ig->writecb   = writecb;
325   ig->seekcb    = seekcb;
326   ig->closecb   = closecb;
327   ig->destroycb = destroycb;
328
329   return (io_glue *)ig;
330 }
331
332 /*
333 =item io_slurp(ig, c)
334 =category I/O Layers
335
336 Takes the source that the io_glue is bound to and allocates space for
337 a return buffer and returns the entire content in a single buffer.
338 Note: This only works for io_glue objects created by
339 io_new_bufchain().  It is useful for saving to scalars and such.
340
341    ig - io_glue object
342    c  - pointer to a pointer to where data should be copied to
343
344   char *data;
345   size_t size = io_slurp(ig, &data);
346   ... do something with the data ...
347   myfree(data);
348
349 io_slurp() will abort the program if the supplied I/O layer is not
350 from io_new_bufchain().
351
352 =cut
353 */
354
355 size_t
356 io_slurp(io_glue *ig, unsigned char **c) {
357   ssize_t rc;
358   off_t orgoff;
359   io_ex_bchain *ieb;
360   unsigned char *cc;
361   io_type inn = ig->type;
362   
363   if ( inn != BUFCHAIN ) {
364     i_fatal(0, "io_slurp: called on a source that is not from a bufchain\n");
365   }
366
367   ieb = ig->exdata;
368   cc = *c = mymalloc( ieb->length );
369   
370   orgoff = ieb->gpos;
371   
372   bufchain_seek(ig, 0, SEEK_SET);
373   
374   rc = bufchain_read(ig, cc, ieb->length);
375
376   if (rc != ieb->length)
377     i_fatal(1, "io_slurp: bufchain_read returned an incomplete read: rc = %d, request was %d\n", rc, ieb->length);
378
379   return rc;
380 }
381
382 /*
383 =item io_glue_destroy(ig)
384 =category I/O Layers
385 =order 90
386 =synopsis io_glue_destroy(ig);
387
388 Destroy an io_glue objects.  Should clean up all related buffers.
389
390    ig - io_glue object to destroy.
391
392 =cut
393 */
394
395 void
396 io_glue_destroy(io_glue *ig) {
397   mm_log((1, "io_glue_DESTROY(ig %p)\n", ig));
398
399   if (ig->destroycb)
400     ig->destroycb(ig);
401
402   if (ig->buffer)
403     myfree(ig->buffer);
404   
405   myfree(ig);
406 }
407
408 /*
409 =item i_io_getc(ig)
410 =category I/O Layers
411
412 A macro to read a single byte from a buffered I/O glue object.
413
414 Returns EOF on failure, or a byte.
415
416 =cut
417 */
418
419 int
420 i_io_getc_imp(io_glue *ig) {
421   if (ig->write_ptr)
422     return EOF;
423   
424   if (ig->error || ig->buf_eof)
425     return EOF;
426   
427   if (!ig->buffered) {
428     unsigned char buf;
429     ssize_t rc = i_io_raw_read(ig, &buf, 1);
430     if (rc > 0) {
431       return buf;
432     }
433     else if (rc == 0) {
434       ig->buf_eof = 1;
435       return EOF;
436     }
437     else {
438       ig->error = 1;
439       return EOF;
440     }
441   }
442
443   if (!ig->buffer)
444     i_io_setup_buffer(ig);
445   
446   if (!ig->read_ptr || ig->read_ptr == ig->read_end) {
447     if (!i_io_read_fill(ig, 1))
448       return EOF;
449   }
450   
451   return *(ig->read_ptr++);
452 }
453
454 /*
455 =item i_io_peekc(ig)
456 =category I/O Layers
457
458 Read the next character from the stream without advancing the stream.
459
460 On error or end of file, return EOF.
461
462 For unbuffered streams a single character buffer will be setup.
463
464 =cut
465 */
466
467 int
468 i_io_peekc_imp(io_glue *ig) {
469   if (ig->write_ptr)
470     return EOF;
471
472   if (!ig->buffer)
473     i_io_setup_buffer(ig);
474
475   if (!ig->buffered) {
476     ssize_t rc = i_io_raw_read(ig, ig->buffer, 1);
477     if (rc > 0) {
478       ig->read_ptr = ig->buffer;
479       ig->read_end = ig->buffer + 1;
480       return *(ig->buffer);
481     }
482     else if (rc == 0) {
483       ig->buf_eof = 1;
484       return EOF;
485     }
486     else {
487       ig->error = 1;
488       return EOF;
489     }
490   }
491
492   if (!ig->read_ptr || ig->read_ptr == ig->read_end) {
493     if (ig->error || ig->buf_eof)
494       return EOF;
495     
496     if (!i_io_read_fill(ig, 1))
497       return EOF;
498   }
499
500   return *(ig->read_ptr);
501 }
502
503 /*
504 =item i_io_peekn(ig, buffer, size)
505 =category I/O Layers
506 =synopsis ssize_t count = i_io_peekn(ig, buffer, sizeof(buffer));
507
508 Buffer at least C<size> (at most C<< ig->buf_size >> bytes of data
509 from the stream and return C<size> bytes of it to the caller in
510 C<buffer>.
511
512 This ignores the buffered state of the stream, and will always setup
513 buffering if needed.
514
515 If no C<type> parameter is provided to Imager::read() or
516 Imager::read_multi(), Imager will call C<i_io_peekn()> when probing
517 for the file format.
518
519 Returns -1 on error, 0 if there is no data before EOF, or the number
520 of bytes read into C<buffer>.
521
522 =cut
523 */
524
525 ssize_t
526 i_io_peekn(io_glue *ig, void *buf, size_t size) {
527   IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn(%p, %p, %d)\n", ig, buf, (int)size));
528
529   if (size == 0) {
530     i_push_error(0, "peekn size must be positive");
531     IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (zero size)\n"));
532     return -1;
533   }
534
535   if (ig->write_ptr) {
536     IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (write_ptr set)\n"));
537     return -1;
538   }
539
540   if (!ig->buffer)
541     i_io_setup_buffer(ig);
542
543   if ((!ig->read_ptr || size > ig->read_end - ig->read_ptr)
544       && !(ig->buf_eof || ig->error)) {
545     i_io_read_fill(ig, size);
546   }
547   
548   if (size > ig->read_end - ig->read_ptr)
549     size = ig->read_end - ig->read_ptr;
550
551   if (size)
552     memcpy(buf, ig->read_ptr, size);
553   else if (ig->buf_eof) {
554     IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => 0 (eof)\n"));
555     return 0;
556   }
557   else if (ig->error) {
558     IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => -1 (error)\n"));
559     return -1;
560   }
561   else {
562     IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() - size 0 but not eof or error!\n"));
563     return -1;
564   }
565
566   IOL_DEB(fprintf(IOL_DEBs, "i_io_peekn() => %d\n", (int)size));
567
568   return size;
569 }
570
571 /*
572 =item i_io_putc(ig, c)
573 =category I/O Layers
574
575 Write a single character to the stream.
576
577 On success return c, on error returns EOF
578
579 =cut
580 */
581
582 int
583 i_io_putc_imp(io_glue *ig, int c) {
584   IOL_DEB(fprintf(IOL_DEBs, "i_io_putc_imp(%p, %d)\n", ig, c));
585
586   if (!ig->buffered) {
587     char buf = c;
588     ssize_t write_result;
589
590     if (ig->error)
591       return EOF;
592
593     write_result = i_io_raw_write(ig, &buf, 1);
594     int result = c;
595     if (write_result != 1) {
596       ig->error = 1;
597       result = EOF;
598       IOL_DEB(fprintf(IOL_DEBs, "  unbuffered putc() failed, setting error mode\n"));
599     }
600     IOL_DEB(fprintf(IOL_DEBs, "  unbuffered: result %d\n", result));
601
602     return result;
603   }
604
605   if (ig->read_ptr)
606     return EOF;
607
608   if (ig->error)
609     return EOF;
610
611   if (!ig->buffer)
612     i_io_setup_buffer(ig);
613
614   if (ig->write_ptr && ig->write_ptr == ig->write_end) {
615     if (!i_io_flush(ig))
616       return EOF;
617   }
618
619   i_io_start_write(ig);
620
621   *(ig->write_ptr)++ = c;
622
623   return (unsigned char)c;
624 }
625
626 /*
627 =item i_io_read(io, buffer, size)
628 =category I/O Layers
629
630 Read up to C<size> bytes from the stream C<io> into C<buffer>.
631
632 Returns the number of bytes read.  Returns 0 on end of file.  Returns
633 -1 on error.
634
635 =cut
636 */
637
638 ssize_t
639 i_io_read(io_glue *ig, void *buf, size_t size) {
640   unsigned char *pbuf = buf;
641   ssize_t read_total = 0;
642
643   IOL_DEB(fprintf(IOL_DEBs, "i_io_read(%p, %p, %u)\n", ig, buf, (unsigned)size));
644
645   if (ig->write_ptr) {
646     IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => -1 (write_ptr set)\n"));
647     return -1;
648   }
649
650   if (!ig->buffer && ig->buffered)
651     i_io_setup_buffer(ig);
652
653   if (ig->read_ptr && ig->read_ptr < ig->read_end) {
654     size_t alloc = ig->read_end - ig->read_ptr;
655     
656     if (alloc > size)
657       alloc = size;
658
659     memcpy(pbuf, ig->read_ptr, alloc);
660     ig->read_ptr += alloc;
661     pbuf += alloc;
662     size -= alloc;
663     read_total += alloc;
664   }
665
666   if (size > 0 && !(ig->error || ig->buf_eof)) {
667     if (!ig->buffered || size > ig->buf_size) {
668       ssize_t rc;
669       
670       while (size > 0 && (rc = i_io_raw_read(ig, pbuf, size)) > 0) {
671         size -= rc;
672         pbuf += rc;
673         read_total += rc;
674       }
675       
676       IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d (raw read)\n", (int)read_total));
677
678       if (rc < 0)
679         ig->error = 1;
680       else if (rc == 0)
681         ig->buf_eof = 1;
682
683       if (!read_total)
684         return rc;
685     }
686     else {
687       if (i_io_read_fill(ig, size)) {
688         size_t alloc = ig->read_end - ig->read_ptr;
689         if (alloc > size)
690           alloc = size;
691         
692         memcpy(pbuf, ig->read_ptr, alloc);
693         ig->read_ptr += alloc;
694         pbuf += alloc;
695         size -= alloc;
696         read_total += alloc;
697       }
698       else {
699         if (!read_total && ig->error) {
700           IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => -1 (fill failure)\n"));
701           return -1;
702         }
703       }
704     }
705   }
706
707   if (!read_total && ig->error)
708     read_total = -1;
709
710   IOL_DEB(fprintf(IOL_DEBs, "i_io_read() => %d\n", (int)read_total));
711
712   return read_total;
713 }
714
715 /*
716 =item i_io_write(io, buffer, size)
717 =category I/O Layers
718 =synopsis ssize_t result = i_io_write(io, buffer, size)
719
720 Write to the given I/O stream.
721
722 Returns the number of bytes written.
723
724 =cut
725 */
726
727 ssize_t
728 i_io_write(io_glue *ig, const void *buf, size_t size) {
729   const unsigned char *pbuf = buf;
730   size_t write_count = 0;
731
732   IOL_DEB(fprintf(IOL_DEBs, "i_io_write(%p, %p, %u)\n", ig, buf, (unsigned)size));
733
734   if (!ig->buffered) {
735     ssize_t result;
736
737     if (ig->error) {
738       IOL_DEB(fprintf(IOL_DEBs, "  unbuffered, error state\n"));
739       return -1;
740     }
741
742     result = i_io_raw_write(ig, buf, size);
743
744     if (result != size) {
745       ig->error = 1;
746       IOL_DEB(fprintf(IOL_DEBs, "  unbuffered, setting error flag\n"));
747     }
748
749     IOL_DEB(fprintf(IOL_DEBs, "  unbuffered, result: %d\n", (int)result));
750
751     return result;
752   }
753
754   if (ig->read_ptr) {
755     IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (read_ptr set)\n"));
756     return -1;
757   }
758
759   if (ig->error) {
760     IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (error)\n"));
761     return -1;
762   }
763
764   if (!ig->buffer)
765     i_io_setup_buffer(ig);
766
767   if (!ig->write_ptr)
768     i_io_start_write(ig);
769
770   if (ig->write_ptr && ig->write_ptr + size <= ig->write_end) {
771     size_t alloc = ig->write_end - ig->write_ptr;
772     if (alloc > size)
773       alloc = size;
774     memcpy(ig->write_ptr, pbuf, alloc);
775     write_count += alloc;
776     size -= alloc;
777     pbuf += alloc;
778     ig->write_ptr += alloc;
779   }
780
781   if (size) {
782     if (!i_io_flush(ig)) {
783       IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => %d (i_io_flush failure)\n", (int)write_count));
784       return write_count ? write_count : -1;
785     }
786
787     i_io_start_write(ig);
788     
789     if (size > ig->buf_size) {
790       ssize_t rc;
791       while (size > 0 && (rc = i_io_raw_write(ig, pbuf, size)) > 0) {
792         write_count += rc;
793         pbuf += rc;
794         size -= rc;
795       }
796       if (rc <= 0) {
797         ig->error = 1;
798         if (!write_count) {
799           IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => -1 (direct write failure)\n"));
800           return -1;
801         }
802       }
803     }
804     else {
805       memcpy(ig->write_ptr, pbuf, size);
806       write_count += size;
807       ig->write_ptr += size;
808     }
809   }
810
811   IOL_DEB(fprintf(IOL_DEBs, "i_io_write() => %d\n", (int)write_count));
812
813   return write_count;
814 }
815
816 /*
817 =item i_io_seek(io, offset, whence)
818 =category I/O Layers
819
820 Seek within the stream.
821
822 Acts like perl's seek.
823
824 =cut
825  */
826
827 off_t
828 i_io_seek(io_glue *ig, off_t offset, int whence) {
829   off_t new_off;
830
831   IOL_DEB(fprintf(IOL_DEBs, "i_io_seek(%p, %ld, %d)\n", ig, (long)offset, whence));
832
833   if (ig->write_ptr && ig->write_ptr != ig->write_end) {
834     if (!i_io_flush(ig))
835       return (off_t)(-1);
836   }
837
838   if (whence == SEEK_CUR && ig->read_ptr && ig->read_ptr != ig->read_end)
839     offset -= ig->read_end - ig->read_ptr;
840
841   ig->read_ptr = ig->read_end = NULL;
842   ig->write_ptr = ig->write_end = NULL;
843   ig->error = 0;
844   ig->buf_eof = 0;
845   
846   new_off = i_io_raw_seek(ig, offset, whence);
847   if (new_off < 0)
848     ig->error = 1;
849
850   IOL_DEB(fprintf(IOL_DEBs, "i_io_seek() => %ld\n", (long)new_off));
851
852   return new_off;
853 }
854
855 /*
856 =item i_io_flush(io)
857 =category I/O Layers
858
859 Flush any buffered output.
860
861 Returns true on success,
862
863 =cut
864 */
865
866 int
867 i_io_flush(io_glue *ig) {
868   unsigned char *bufp;
869
870   IOL_DEB(fprintf(IOL_DEBs, "i_io_flush(%p)\n", ig));
871
872   if (ig->error) {
873     IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 0 (error set)\n", ig));
874     return 0;
875   }
876
877   /* nothing to do */
878   if (!ig->write_ptr)
879     return 1;
880
881   bufp = ig->buffer;
882   while (bufp < ig->write_ptr) {
883     ssize_t rc = i_io_raw_write(ig, bufp, ig->write_ptr - bufp);
884     if (rc <= 0) {
885       IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 0 (write error)\n", ig));
886       ig->error = 1;
887       return 0;
888     }
889     
890     bufp += rc;
891   }
892
893   ig->write_ptr = ig->write_end = NULL;
894
895   IOL_DEB(fprintf(IOL_DEBs, "i_io_flush() => 1\n", ig));
896
897   return 1;
898 }
899
900 /*
901 =item i_io_close(io)
902 =category I/O Layers
903
904 Flush any pending output and perform the close action for the stream.
905
906 Returns 0 on success.
907
908 =cut
909 */
910
911 int
912 i_io_close(io_glue *ig) {
913   int result = 0;
914
915   IOL_DEB(fprintf(IOL_DEBs, "i_io_close(%p)\n", ig));
916   if (ig->error)
917     result = -1;
918
919   if (ig->write_ptr && !i_io_flush(ig))
920     result = -1;
921
922   if (i_io_raw_close(ig))
923     result = -1;
924
925   IOL_DEB(fprintf(IOL_DEBs, "i_io_close() => %d\n", result));
926
927   return result;
928 }
929
930 /*
931 =item i_io_gets(ig, buffer, size, end_of_line)
932 =category I/O Layers
933 =synopsis char buffer[BUFSIZ]
934 =synopsis ssize_t len = i_io_gets(buffer, sizeof(buffer), '\n');
935
936 Read up to C<size>-1 bytes from the stream C<ig> into C<buffer>.
937
938 If the byte C<end_of_line> is seen then no further bytes will be read.
939
940 Returns the number of bytes read.
941
942 Always C<NUL> terminates the buffer.
943
944 =cut
945 */
946
947 ssize_t
948 i_io_gets(io_glue *ig, char *buffer, size_t size, int eol) {
949   ssize_t read_count = 0;
950   if (size < 2)
951     return 0;
952   --size; /* room for nul */
953   while (size > 0) {
954     int byte = i_io_getc(ig);
955     if (byte == EOF)
956       break;
957     *buffer++ = byte;
958     ++read_count;
959     if (byte == eol)
960       break;
961     --size;
962   }
963   *buffer++ = '\0';
964
965   return read_count;
966 }
967
968 /*
969 =item i_io_init(ig, readcb, writecb, seekcb)
970
971 Do common initialization for io_glue objects.
972
973 =cut
974 */
975
976 static void
977 i_io_init(io_glue *ig, int type, i_io_readp_t readcb, i_io_writep_t writecb,
978           i_io_seekp_t seekcb) {
979   ig->type = type;
980   ig->exdata = NULL;
981   ig->readcb = readcb;
982   ig->writecb = writecb;
983   ig->seekcb = seekcb;
984   ig->closecb = NULL;
985   ig->sizecb = NULL;
986   ig->destroycb = NULL;
987
988   ig->buffer = NULL;
989   ig->read_ptr = NULL;
990   ig->read_end = NULL;
991   ig->write_ptr = NULL;
992   ig->write_end = NULL;
993   ig->buf_size = IO_BUF_SIZE;
994   ig->buf_eof = 0;
995   ig->error = 0;
996   ig->buffered = 1;
997 }
998
999 /*
1000 =item i_io_set_buffered(io, buffered)
1001 =category I/O Layers
1002
1003 Set the buffering mode of the stream.
1004
1005 If you switch buffering off on a stream with buffering on:
1006
1007 =over
1008
1009 =item *
1010
1011 any buffered output will be flushed.
1012
1013 =item *
1014
1015 any existing buffered input will be consumed before reads become
1016 unbuffered.
1017
1018 =back
1019
1020 Returns true on success.  This may fail if any buffered output cannot
1021 be flushed.
1022
1023 =cut
1024 */
1025
1026 int
1027 i_io_set_buffered(io_glue *ig, int buffered) {
1028   if (!buffered && ig->write_ptr) {
1029     if (!i_io_flush(ig)) {
1030       ig->error = 1;
1031       return 0;
1032     }
1033   }
1034   ig->buffered = buffered;
1035
1036   return 1;
1037 }
1038
1039 /*
1040 =item i_io_dump(ig)
1041
1042 Dump the base fields of an io_glue object to stdout.
1043
1044 =cut
1045 */
1046 void
1047 i_io_dump(io_glue *ig, int flags) {
1048   fprintf(IOL_DEBs, "ig %p:\n", ig);
1049   fprintf(IOL_DEBs, "  type: %d\n", ig->type);  
1050   fprintf(IOL_DEBs, "  exdata: %p\n", ig->exdata);
1051   if (flags & I_IO_DUMP_CALLBACKS) {
1052     fprintf(IOL_DEBs, "  readcb: %p\n", ig->readcb);
1053     fprintf(IOL_DEBs, "  writecb: %p\n", ig->writecb);
1054     fprintf(IOL_DEBs, "  seekcb: %p\n", ig->seekcb);
1055     fprintf(IOL_DEBs, "  closecb: %p\n", ig->closecb);
1056     fprintf(IOL_DEBs, "  sizecb: %p\n", ig->sizecb);
1057   }
1058   if (flags & I_IO_DUMP_BUFFER) {
1059     fprintf(IOL_DEBs, "  buffer: %p\n", ig->buffer);
1060     fprintf(IOL_DEBs, "  read_ptr: %p\n", ig->read_ptr);
1061     if (ig->read_ptr) {
1062       fprintf(IOL_DEBs, "    ");
1063       dump_data(ig->read_ptr, ig->read_end, 0);
1064       putc('\n', IOL_DEBs);
1065     }
1066     fprintf(IOL_DEBs, "  read_end: %p\n", ig->read_end);
1067     fprintf(IOL_DEBs, "  write_ptr: %p\n", ig->write_ptr);
1068     if (ig->write_ptr) {
1069       fprintf(IOL_DEBs, "    ");
1070       dump_data(ig->buffer, ig->write_ptr, 1);
1071       putc('\n', IOL_DEBs);
1072     }
1073     fprintf(IOL_DEBs, "  write_end: %p\n", ig->write_end);
1074     fprintf(IOL_DEBs, "  buf_size: %u\n", (unsigned)(ig->buf_size));
1075   }
1076   if (flags & I_IO_DUMP_STATUS) {
1077     fprintf(IOL_DEBs, "  buf_eof: %d\n", ig->buf_eof);
1078     fprintf(IOL_DEBs, "  error: %d\n", ig->error);
1079     fprintf(IOL_DEBs, "  buffered: %d\n", ig->buffered);
1080   }
1081 }
1082
1083 /*
1084 =back
1085
1086 =head1 INTERNAL FUNCTIONS
1087
1088 =over
1089
1090 =item my_strerror
1091
1092 Calls strerror() and ensures we don't return NULL.
1093
1094 On some platforms it's possible for strerror() to return NULL, this
1095 wrapper ensures we only get non-NULL values.
1096
1097 =cut
1098 */
1099
1100 static
1101 const char *my_strerror(int err) {
1102   const char *result = strerror(err);
1103   
1104   if (!result)
1105     result = "Unknown error";
1106   
1107   return result;
1108 }
1109
1110 static void
1111 i_io_setup_buffer(io_glue *ig) {
1112   ig->buffer = mymalloc(ig->buf_size);
1113 }
1114
1115 static void
1116 i_io_start_write(io_glue *ig) {
1117   ig->write_ptr = ig->buffer;
1118   ig->write_end = ig->buffer + ig->buf_size;
1119 }
1120
1121 static int
1122 i_io_read_fill(io_glue *ig, ssize_t needed) {
1123   unsigned char *buf_end = ig->buffer + ig->buf_size;
1124   unsigned char *buf_start = ig->buffer;
1125   unsigned char *work = ig->buffer;
1126   ssize_t rc;
1127   int good = 0;
1128
1129   IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill(%p, %d)\n", ig, (int)needed));
1130
1131   /* these conditions may be unused, callers should also be checking them */
1132   if (ig->error || ig->buf_eof)
1133     return 0;
1134
1135   if (needed > ig->buf_size)
1136     needed = ig->buf_size;
1137
1138   if (ig->read_ptr && ig->read_ptr < ig->read_end) {
1139     size_t kept = ig->read_end - ig->read_ptr;
1140
1141     if (needed < kept) {
1142       IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill(%u) -> 1 (already have enough)\n", (unsigned)needed));
1143       return 1;
1144     }
1145
1146     if (ig->read_ptr != ig->buffer)
1147       memmove(ig->buffer, ig->read_ptr, kept);
1148
1149     good = 1; /* we have *something* available to read */
1150     work = buf_start + kept;
1151     needed -= kept;
1152   }
1153   else {
1154     work = ig->buffer;
1155   }
1156
1157   while (work < buf_end && (rc = i_io_raw_read(ig, work, buf_end - work)) > 0) {
1158     work += rc;
1159     good = 1;
1160     if (needed < rc)
1161       break;
1162
1163     needed -= rc;
1164   }
1165
1166   if (rc < 0) {
1167     ig->error = 1;
1168     IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc %d, setting error\n",
1169                     (int)rc));
1170   }
1171   else if (rc == 0) {
1172     ig->buf_eof = 1;
1173     IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc 0, setting eof\n"));
1174   }
1175
1176   if (good) {
1177     ig->read_ptr = buf_start;
1178     ig->read_end = work;
1179   }
1180   
1181   IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill => %d, %u buffered\n", good,
1182                   (unsigned)(ig->read_end - ig->read_ptr)));
1183   return good;
1184 }
1185
1186 /*
1187 =item dump_data(start, end, bias)
1188
1189 Hex dump the data between C<start> and C<end>.
1190
1191 If there is more than a pleasing amount of data, either dump the
1192 beginning (C<bias == 0>) or dump the end C(<bias != 0>) of the range.
1193
1194 =cut
1195 */
1196
1197 static void
1198 dump_data(unsigned char *start, unsigned char *end, int bias) {
1199   unsigned char *p;
1200   size_t count = end - start;
1201
1202   if (start == end) {
1203     fprintf(IOL_DEBs, "(empty)");
1204     return;
1205   }
1206
1207   if (count > 15) {
1208     if (bias) {
1209       fprintf(IOL_DEBs, "... ");
1210       start = end - 14;
1211     }
1212     else {
1213       end = start + 14;
1214     }
1215       
1216     for (p = start; p < end; ++p) {
1217       fprintf(IOL_DEBs, " %02x", *p);
1218     }
1219     putc(' ', IOL_DEBs);
1220     putc('<', IOL_DEBs);
1221     for (p = start; p < end; ++p) {
1222       if (*p < ' ' || *p > '~')
1223         putc('.', IOL_DEBs);
1224       else
1225         putc(*p, IOL_DEBs);
1226     }
1227     putc('>', IOL_DEBs);
1228     if (!bias)
1229       fprintf(IOL_DEBs, " ...");
1230   }
1231   else {
1232     for (p = start; p < end; ++p) {
1233       fprintf(IOL_DEBs, " %02x", *p);
1234     }
1235     putc(' ', IOL_DEBs);
1236     for (p = start; p < end; ++p) {
1237       if (*p < ' ' || *p > '~')
1238         putc('.', IOL_DEBs);
1239       else
1240         putc(*p, IOL_DEBs);
1241     }
1242   }
1243 }
1244
1245 /*
1246  * Callbacks for sources that cannot seek
1247  */
1248
1249 /*
1250  * Callbacks for sources that can seek 
1251  */
1252
1253 /*
1254 =item realseek_read(ig, buf, count)
1255
1256 Does the reading from a source that can be seeked on
1257
1258    ig    - io_glue object
1259    buf   - buffer to return data in
1260    count - number of bytes to read into buffer max
1261
1262 =cut
1263 */
1264
1265 static
1266 ssize_t 
1267 realseek_read(io_glue *igo, void *buf, size_t count) {
1268   io_cb        *ig = (io_cb *)igo;
1269   void *p          = ig->p;
1270   ssize_t       rc = 0;
1271
1272   IOL_DEB( fprintf(IOL_DEBs, "realseek_read:  buf = %p, count = %u\n", 
1273                    buf, (unsigned)count) );
1274   rc = ig->readcb(p,buf,count);
1275
1276   IOL_DEB( fprintf(IOL_DEBs, "realseek_read: rc = %d\n", (int)rc) );
1277
1278   return rc;
1279 }
1280
1281
1282 /*
1283 =item realseek_write(ig, buf, count)
1284
1285 Does the writing to a 'source' that can be seeked on
1286
1287    ig    - io_glue object
1288    buf   - buffer that contains data
1289    count - number of bytes to write
1290
1291 =cut
1292 */
1293
1294 static
1295 ssize_t 
1296 realseek_write(io_glue *igo, const void *buf, size_t count) {
1297   io_cb        *ig = (io_cb *)igo;
1298   void          *p = ig->p;
1299   ssize_t       rc = 0;
1300   size_t        bc = 0;
1301   char       *cbuf = (char*)buf; 
1302   
1303   IOL_DEB( fprintf(IOL_DEBs, "realseek_write: ig = %p, buf = %p, "
1304                    "count = %u\n", ig, buf, (unsigned)count) );
1305
1306   /* Is this a good idea? Would it be better to handle differently? 
1307      skip handling? */
1308   while( count!=bc && (rc = ig->writecb(p,cbuf+bc,count-bc))>0 ) {
1309     bc+=rc;
1310   }
1311
1312   IOL_DEB( fprintf(IOL_DEBs, "realseek_write: rc = %d, bc = %u\n", (int)rc, (unsigned)bc) );
1313   return rc < 0 ? rc : bc;
1314 }
1315
1316
1317 /*
1318 =item realseek_close(ig)
1319
1320 Closes a source that can be seeked on.  Not sure if this should be an
1321 actual close or not.  Does nothing for now.  Should be fixed.
1322
1323    ig - data source
1324
1325 =cut */
1326
1327 static
1328 int
1329 realseek_close(io_glue *igo) {
1330   io_cb *ig = (io_cb *)igo;
1331
1332   IOL_DEB(fprintf(IOL_DEBs, "realseek_close(%p)\n", ig));
1333   mm_log((1, "realseek_close(ig %p)\n", ig));
1334   if (ig->closecb)
1335     return ig->closecb(ig->p);
1336   else
1337     return 0;
1338 }
1339
1340
1341 /* realseek_seek(ig, offset, whence)
1342
1343 Implements seeking for a source that is seekable, the purpose of having this is to be able to
1344 have an offset into a file that is different from what the underlying library thinks.
1345
1346    ig     - data source
1347    offset - offset into stream
1348    whence - whence argument a la lseek
1349
1350 =cut
1351 */
1352
1353 static
1354 off_t
1355 realseek_seek(io_glue *igo, off_t offset, int whence) {
1356   io_cb *ig = (io_cb *)igo;
1357   void *p = ig->p;
1358   off_t rc;
1359   IOL_DEB( fprintf(IOL_DEBs, "realseek_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
1360   rc = ig->seekcb(p, offset, whence);
1361
1362   IOL_DEB( fprintf(IOL_DEBs, "realseek_seek: rc %ld\n", (long) rc) );
1363   return rc;
1364   /* FIXME: How about implementing this offset handling stuff? */
1365 }
1366
1367 static
1368 void
1369 realseek_destroy(io_glue *igo) {
1370   io_cb *ig = (io_cb *)igo;
1371
1372   if (ig->destroycb)
1373     ig->destroycb(ig->p);
1374 }
1375
1376 /*
1377  * Callbacks for sources that are a fixed size buffer
1378  */
1379
1380 /*
1381 =item buffer_read(ig, buf, count)
1382
1383 Does the reading from a buffer source
1384
1385    ig    - io_glue object
1386    buf   - buffer to return data in
1387    count - number of bytes to read into buffer max
1388
1389 =cut
1390 */
1391
1392 static
1393 ssize_t 
1394 buffer_read(io_glue *igo, void *buf, size_t count) {
1395   io_buffer *ig = (io_buffer *)igo;
1396
1397   IOL_DEB( fprintf(IOL_DEBs, "buffer_read: ig->cpos = %ld, buf = %p, count = %u\n", (long) ig->cpos, buf, (unsigned)count) );
1398
1399   if ( ig->cpos+count > ig->len ) {
1400     mm_log((1,"buffer_read: short read: cpos=%ld, len=%ld, count=%ld\n", (long)ig->cpos, (long)ig->len, (long)count));
1401     count = ig->len - ig->cpos;
1402   }
1403   
1404   memcpy(buf, ig->data+ig->cpos, count);
1405   ig->cpos += count;
1406   IOL_DEB( fprintf(IOL_DEBs, "buffer_read: count = %ld\n", (long)count) );
1407   return count;
1408 }
1409
1410
1411 /*
1412 =item buffer_write(ig, buf, count)
1413
1414 Does nothing, returns -1
1415
1416    ig    - io_glue object
1417    buf   - buffer that contains data
1418    count - number of bytes to write
1419
1420 =cut
1421 */
1422
1423 static
1424 ssize_t 
1425 buffer_write(io_glue *ig, const void *buf, size_t count) {
1426   mm_log((1, "buffer_write called, this method should never be called.\n"));
1427   return -1;
1428 }
1429
1430
1431 /*
1432 =item buffer_close(ig)
1433
1434 Closes a source that can be seeked on.  Not sure if this should be an actual close
1435 or not.  Does nothing for now.  Should be fixed.
1436
1437    ig - data source
1438
1439 =cut
1440 */
1441
1442 static
1443 int
1444 buffer_close(io_glue *ig) {
1445   mm_log((1, "buffer_close(ig %p)\n", ig));
1446
1447   return 0;
1448 }
1449
1450
1451 /* buffer_seek(ig, offset, whence)
1452
1453 Implements seeking for a buffer source.
1454
1455    ig     - data source
1456    offset - offset into stream
1457    whence - whence argument a la lseek
1458
1459 =cut
1460 */
1461
1462 static
1463 off_t
1464 buffer_seek(io_glue *igo, off_t offset, int whence) {
1465   io_buffer *ig = (io_buffer *)igo;
1466   off_t reqpos = 
1467     calc_seek_offset(ig->cpos, ig->len, offset, whence);
1468   
1469   if (reqpos > ig->len) {
1470     mm_log((1, "seeking out of readable range\n"));
1471     return (off_t)-1;
1472   }
1473   if (reqpos < 0) {
1474     i_push_error(0, "seek before beginning of file");
1475     return (off_t)-1;
1476   }
1477   
1478   ig->cpos = reqpos;
1479   IOL_DEB( fprintf(IOL_DEBs, "buffer_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
1480
1481   return reqpos;
1482   /* FIXME: How about implementing this offset handling stuff? */
1483 }
1484
1485 static
1486 void
1487 buffer_destroy(io_glue *igo) {
1488   io_buffer *ig = (io_buffer *)igo;
1489
1490   if (ig->closecb) {
1491     mm_log((1,"calling close callback %p for io_buffer\n", 
1492             ig->closecb));
1493     ig->closecb(ig->closedata);
1494   }
1495 }
1496
1497
1498
1499 /*
1500  * Callbacks for sources that are a chain of variable sized buffers
1501  */
1502
1503
1504
1505 /* Helper functions for buffer chains */
1506
1507 static
1508 io_blink*
1509 io_blink_new(void) {
1510   io_blink *ib;
1511
1512   mm_log((1, "io_blink_new()\n"));
1513
1514   ib = mymalloc(sizeof(io_blink));
1515
1516   ib->next = NULL;
1517   ib->prev = NULL;
1518   ib->len  = BBSIZ;
1519
1520   memset(&ib->buf, 0, ib->len);
1521   return ib;
1522 }
1523
1524
1525
1526 /*
1527 =item io_bchain_advance(ieb)
1528
1529 Advances the buffer chain to the next link - extending if
1530 necessary.  Also adjusts the cpos and tfill counters as needed.
1531
1532    ieb   - buffer chain object
1533
1534 =cut
1535 */
1536
1537 static
1538 void
1539 io_bchain_advance(io_ex_bchain *ieb) {
1540   if (ieb->cp->next == NULL) {
1541     ieb->tail = io_blink_new();
1542     ieb->tail->prev = ieb->cp;
1543     ieb->cp->next   = ieb->tail;
1544
1545     ieb->tfill = 0; /* Only set this if we added a new slice */
1546   }
1547   ieb->cp    = ieb->cp->next;
1548   ieb->cpos  = 0;
1549 }
1550
1551
1552
1553 /*
1554 =item io_bchain_destroy()
1555
1556 frees all resources used by a buffer chain.
1557
1558 =cut
1559 */
1560
1561 static void
1562 io_destroy_bufchain(io_ex_bchain *ieb) {
1563   io_blink *cp;
1564   mm_log((1, "io_destroy_bufchain(ieb %p)\n", ieb));
1565   cp = ieb->head;
1566   
1567   while(cp) {
1568     io_blink *t = cp->next;
1569     myfree(cp);
1570     cp = t;
1571   }
1572 }
1573
1574
1575
1576
1577 /*
1578
1579 static
1580 void
1581 bufchain_dump(io_ex_bchain *ieb) {
1582   mm_log((1, "  buf_chain_dump(ieb %p)\n"));
1583   mm_log((1, "  buf_chain_dump: ieb->offset = %d\n", ieb->offset));
1584   mm_log((1, "  buf_chain_dump: ieb->length = %d\n", ieb->length));
1585   mm_log((1, "  buf_chain_dump: ieb->head   = %p\n", ieb->head  ));
1586   mm_log((1, "  buf_chain_dump: ieb->tail   = %p\n", ieb->tail  ));
1587   mm_log((1, "  buf_chain_dump: ieb->tfill  = %d\n", ieb->tfill ));
1588   mm_log((1, "  buf_chain_dump: ieb->cp     = %p\n", ieb->cp    ));
1589   mm_log((1, "  buf_chain_dump: ieb->cpos   = %d\n", ieb->cpos  ));
1590   mm_log((1, "  buf_chain_dump: ieb->gpos   = %d\n", ieb->gpos  ));
1591 }
1592 */
1593
1594 /*
1595  * TRUE if lengths are NOT equal
1596  */
1597
1598 /*
1599 static
1600 void
1601 chainlencert( io_glue *ig ) {
1602   int clen;
1603   int cfl           = 0;
1604   size_t csize      = 0;
1605   size_t cpos       = 0;
1606   io_ex_bchain *ieb = ig->exdata;
1607   io_blink *cp      = ieb->head;
1608   
1609
1610   if (ieb->gpos > ieb->length) mm_log((1, "BBAR : ieb->gpos = %d, ieb->length = %d\n", ieb->gpos, ieb->length));
1611
1612   while(cp) {
1613     clen = (cp == ieb->tail) ? ieb->tfill : cp->len;
1614     if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
1615     if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
1616     
1617     if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
1618     if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
1619     
1620     if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
1621     if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
1622
1623     if (cp == ieb->cp) {
1624       cfl = 1;
1625       cpos += ieb->cpos;
1626     }
1627
1628     if (!cfl) cpos += clen;
1629
1630     csize += clen;
1631     cp     = cp->next;
1632   }
1633   if (( csize != ieb->length )) mm_log((1, "BAR : csize = %d, ieb->length = %d\n", csize, ieb->length));
1634   if (( cpos  != ieb->gpos   )) mm_log((1, "BAR : cpos  = %d, ieb->gpos   = %d\n", cpos,  ieb->gpos  ));
1635 }
1636
1637
1638 static
1639 void
1640 chaincert( io_glue *ig) {
1641   size_t csize   = 0;
1642   io_ex_bchain *ieb = ig->exdata;
1643   io_blink *cp   = ieb->head;
1644   
1645   mm_log((1, "Chain verification.\n"));
1646
1647   mm_log((1, "  buf_chain_dump: ieb->offset = %d\n", ieb->offset));
1648   mm_log((1, "  buf_chain_dump: ieb->length = %d\n", ieb->length));
1649   mm_log((1, "  buf_chain_dump: ieb->head   = %p\n", ieb->head  ));
1650   mm_log((1, "  buf_chain_dump: ieb->tail   = %p\n", ieb->tail  ));
1651   mm_log((1, "  buf_chain_dump: ieb->tfill  = %d\n", ieb->tfill ));
1652   mm_log((1, "  buf_chain_dump: ieb->cp     = %p\n", ieb->cp    ));
1653   mm_log((1, "  buf_chain_dump: ieb->cpos   = %d\n", ieb->cpos  ));
1654   mm_log((1, "  buf_chain_dump: ieb->gpos   = %d\n", ieb->gpos  ));
1655
1656   while(cp) {
1657     int clen = cp == ieb->tail ? ieb->tfill : cp->len;
1658     mm_log((1, "link: %p <- %p -> %p\n", cp->prev, cp, cp->next));
1659     if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
1660     if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
1661     
1662     if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
1663     if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
1664     
1665     if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
1666     if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
1667
1668     csize += clen;
1669     cp     = cp->next;
1670   }
1671
1672   mm_log((1, "csize = %d %s ieb->length = %d\n", csize, csize == ieb->length ? "==" : "!=", ieb->length));
1673 }
1674 */
1675
1676 /*
1677 =item bufchain_read(ig, buf, count)
1678
1679 Does the reading from a source that can be seeked on
1680
1681    ig    - io_glue object
1682    buf   - buffer to return data in
1683    count - number of bytes to read into buffer max
1684
1685 =cut
1686 */
1687
1688 static
1689 ssize_t 
1690 bufchain_read(io_glue *ig, void *buf, size_t count) {
1691   io_ex_bchain *ieb = ig->exdata;
1692   size_t     scount = count;
1693   char        *cbuf = buf;
1694   size_t         sk;
1695
1696   mm_log((1, "bufchain_read(ig %p, buf %p, count %ld)\n", ig, buf, (long)count));
1697
1698   while( scount ) {
1699     int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1700     if (clen == ieb->cpos) {
1701       if (ieb->cp == ieb->tail) break; /* EOF */
1702       ieb->cp = ieb->cp->next;
1703       ieb->cpos = 0;
1704       clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1705     }
1706
1707     sk = clen - ieb->cpos;
1708     sk = sk > scount ? scount : sk;
1709
1710     memcpy(&cbuf[count-scount], &ieb->cp->buf[ieb->cpos], sk);
1711     scount    -= sk;
1712     ieb->cpos += sk;
1713     ieb->gpos += sk;
1714   }
1715
1716   mm_log((1, "bufchain_read: returning %ld\n", (long)(count-scount)));
1717   return count-scount;
1718 }
1719
1720
1721
1722
1723
1724 /*
1725 =item bufchain_write(ig, buf, count)
1726
1727 Does the writing to a 'source' that can be seeked on
1728
1729    ig    - io_glue object
1730    buf   - buffer that contains data
1731    count - number of bytes to write
1732
1733 =cut
1734 */
1735
1736 static
1737 ssize_t
1738 bufchain_write(io_glue *ig, const void *buf, size_t count) {
1739   char *cbuf = (char *)buf;
1740   io_ex_bchain *ieb = ig->exdata;
1741   size_t         ocount = count;
1742   size_t         sk;
1743
1744   mm_log((1, "bufchain_write: ig = %p, buf = %p, count = %ld\n", ig, buf, (long)count));
1745
1746   IOL_DEB( fprintf(IOL_DEBs, "bufchain_write: ig = %p, ieb->cpos = %ld, buf = %p, count = %ld\n", ig, (long) ieb->cpos, buf, (long)count) );
1747   
1748   while(count) {
1749     mm_log((2, "bufchain_write: - looping - count = %ld\n", (long)count));
1750     if (ieb->cp->len == ieb->cpos) {
1751       mm_log((1, "bufchain_write: cp->len == ieb->cpos = %ld - advancing chain\n", (long) ieb->cpos));
1752       io_bchain_advance(ieb);
1753     }
1754
1755     sk = ieb->cp->len - ieb->cpos;
1756     sk = sk > count ? count : sk;
1757     memcpy(&ieb->cp->buf[ieb->cpos], &cbuf[ocount-count], sk);
1758
1759     if (ieb->cp == ieb->tail) {
1760       int extend = ieb->cpos + sk - ieb->tfill;
1761       mm_log((2, "bufchain_write: extending tail by %d\n", extend));
1762       if (extend > 0) {
1763         ieb->length += extend;
1764         ieb->tfill  += extend;
1765       }
1766     }
1767
1768     ieb->cpos += sk;
1769     ieb->gpos += sk;
1770     count     -= sk;
1771   }
1772   return ocount;
1773 }
1774
1775 /*
1776 =item bufchain_close(ig)
1777
1778 Closes a source that can be seeked on.  Not sure if this should be an actual close
1779 or not.  Does nothing for now.  Should be fixed.
1780
1781    ig - data source
1782
1783 =cut
1784 */
1785
1786 static
1787 int
1788 bufchain_close(io_glue *ig) {
1789   mm_log((1, "bufchain_close(ig %p)\n",ig));
1790   IOL_DEB( fprintf(IOL_DEBs, "bufchain_close(ig %p)\n", ig) );
1791
1792   return 0;  
1793 }
1794
1795
1796 /* bufchain_seek(ig, offset, whence)
1797
1798 Implements seeking for a source that is seekable, the purpose of having this is to be able to
1799 have an offset into a file that is different from what the underlying library thinks.
1800
1801    ig     - data source
1802    offset - offset into stream
1803    whence - whence argument a la lseek
1804
1805 =cut
1806 */
1807
1808 static
1809 off_t
1810 bufchain_seek(io_glue *ig, off_t offset, int whence) {
1811   io_ex_bchain *ieb = ig->exdata;
1812   int wrlen;
1813
1814   off_t scount = calc_seek_offset(ieb->gpos, ieb->length, offset, whence);
1815   off_t sk;
1816
1817   mm_log((1, "bufchain_seek(ig %p, offset %ld, whence %d)\n", ig, (long)offset, whence));
1818
1819   if (scount < 0) {
1820     i_push_error(0, "invalid whence supplied or seek before start of file");
1821     return (off_t)-1;
1822   }
1823
1824   ieb->cp   = ieb->head;
1825   ieb->cpos = 0;
1826   ieb->gpos = 0;
1827   
1828   while( scount ) {
1829     int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1830     if (clen == ieb->cpos) {
1831       if (ieb->cp == ieb->tail) break; /* EOF */
1832       ieb->cp = ieb->cp->next;
1833       ieb->cpos = 0;
1834       clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1835     }
1836     
1837     sk = clen - ieb->cpos;
1838     sk = sk > scount ? scount : sk;
1839     
1840     scount    -= sk;
1841     ieb->cpos += sk;
1842     ieb->gpos += sk;
1843   }
1844   
1845   wrlen = scount;
1846
1847   if (wrlen > 0) { 
1848     /*
1849      * extending file - get ieb into consistent state and then
1850      * call write which will get it to the correct position 
1851      */
1852     char TB[BBSIZ];
1853     memset(TB, 0, BBSIZ);
1854     ieb->gpos = ieb->length;
1855     ieb->cpos = ieb->tfill;
1856     
1857     while(wrlen > 0) {
1858       ssize_t rc, wl = i_min(wrlen, BBSIZ);
1859       mm_log((1, "bufchain_seek: wrlen = %d, wl = %ld\n", wrlen, (long)wl));
1860       rc = bufchain_write( ig, TB, wl );
1861       if (rc != wl) i_fatal(0, "bufchain_seek: Unable to extend file\n");
1862       wrlen -= rc;
1863     }
1864   }
1865
1866   mm_log((2, "bufchain_seek: returning ieb->gpos = %ld\n", (long)ieb->gpos));
1867   return ieb->gpos;
1868 }
1869
1870 static
1871 void
1872 bufchain_destroy(io_glue *ig) {
1873   io_ex_bchain *ieb = ig->exdata;
1874
1875   io_destroy_bufchain(ieb);
1876
1877   myfree(ieb);
1878 }
1879
1880 /*
1881 =item fd_read(ig, buf, count)
1882
1883 Read callback for file descriptor IO objects.
1884
1885 =cut
1886 */
1887 static ssize_t fd_read(io_glue *igo, void *buf, size_t count) {
1888   io_fdseek *ig = (io_fdseek *)igo;
1889   ssize_t result;
1890 #ifdef _MSC_VER
1891   result = _read(ig->fd, buf, count);
1892 #else
1893   result = read(ig->fd, buf, count);
1894 #endif
1895
1896   IOL_DEB(fprintf(IOL_DEBs, "fd_read(%p, %p, %u) => %d\n", ig, buf,
1897                   (unsigned)count, (int)result));
1898
1899   /* 0 is valid - means EOF */
1900   if (result < 0) {
1901     i_push_errorf(0, "read() failure: %s (%d)", my_strerror(errno), errno);
1902   }
1903
1904   return result;
1905 }
1906
1907 static ssize_t fd_write(io_glue *igo, const void *buf, size_t count) {
1908   io_fdseek *ig = (io_fdseek *)igo;
1909   ssize_t result;
1910 #ifdef _MSC_VER
1911   result = _write(ig->fd, buf, count);
1912 #else
1913   result = write(ig->fd, buf, count);
1914 #endif
1915
1916   IOL_DEB(fprintf(IOL_DEBs, "fd_write(%p, %p, %u) => %d\n", ig, buf,
1917                   (unsigned)count, (int)result));
1918
1919   if (result <= 0) {
1920     i_push_errorf(errno, "write() failure: %s (%d)", my_strerror(errno), errno);
1921   }
1922
1923   return result;
1924 }
1925
1926 static off_t fd_seek(io_glue *igo, off_t offset, int whence) {
1927   io_fdseek *ig = (io_fdseek *)igo;
1928   off_t result;
1929 #ifdef _MSC_VER
1930   result = _lseek(ig->fd, offset, whence);
1931 #else
1932   result = lseek(ig->fd, offset, whence);
1933 #endif
1934
1935   if (result == (off_t)-1) {
1936     i_push_errorf(errno, "lseek() failure: %s (%d)", my_strerror(errno), errno);
1937   }
1938
1939   return result;
1940 }
1941
1942 static int fd_close(io_glue *ig) {
1943   /* no, we don't close it */
1944   return 0;
1945 }
1946
1947 static ssize_t fd_size(io_glue *ig) {
1948   mm_log((1, "fd_size(ig %p) unimplemented\n", ig));
1949   
1950   return -1;
1951 }
1952
1953
1954 /*
1955 =back
1956
1957 =head1 AUTHOR
1958
1959 Arnar M. Hrafnkelsson <addi@umich.edu>
1960
1961 =head1 SEE ALSO
1962
1963 Imager(3)
1964
1965 =cut
1966 */