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