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