switch to using size_t and i_img_dim strictly
[imager.git] / iolayer.c
1 #include "imager.h"
2 #include "iolayer.h"
3 #include "imerror.h"
4 #include "log.h"
5 #include <stdlib.h>
6 #include <stdio.h>
7 #ifdef _MSC_VER
8 #include <io.h>
9 #endif
10 #include <string.h>
11 #include <errno.h>
12 #include "imageri.h"
13
14 #define IOL_DEB(x)
15
16
17 char *io_type_names[] = { "FDSEEK", "FDNOSEEK", "BUFFER", "CBSEEK", "CBNOSEEK", "BUFCHAIN" };
18
19 typedef struct io_blink {
20   char buf[BBSIZ];
21   /* size_t cnt; */
22   size_t len;                   /* How large is this buffer = BBZIS for now */
23   struct io_blink *next;
24   struct io_blink *prev;
25 } io_blink;
26
27
28 /* Structures that describe callback interfaces */
29
30 typedef struct {
31   off_t offset;
32   off_t cpos;
33 } io_ex_rseek;
34
35
36 typedef struct {
37   off_t offset;
38   off_t cpos;
39   io_blink *head;
40   io_blink *tail;
41   io_blink *cp;
42 } io_ex_fseek;
43
44
45 typedef struct {
46   off_t offset;                 /* Offset of the source - not used */
47   off_t length;                 /* Total length of chain in bytes */
48   io_blink *head;               /* Start of chain */
49   io_blink *tail;               /* End of chain */
50   off_t tfill;                  /* End of stream in last link */
51   io_blink *cp;                 /* Current element of list */
52   off_t cpos;                   /* Offset within the current */
53   off_t gpos;                   /* Global position in stream */
54 } io_ex_bchain;
55
56 typedef struct {
57   off_t offset;                 /* Offset of the source - not used */
58   off_t cpos;                   /* Offset within the current */
59 } io_ex_buffer;
60
61 static void io_obj_setp_buffer(io_obj *io, char *p, size_t len, i_io_closebufp_t closecb, void *closedata);
62 static void io_obj_setp_cb2     (io_obj *io, void *p, i_io_readl_t readcb, i_io_writel_t writecb, i_io_seekl_t seekcb, i_io_closel_t closecb, i_io_destroyl_t destroycb);
63
64 /* turn current offset, file length, whence and offset into a new offset */
65 #define calc_seek_offset(curr_off, length, offset, whence) \
66   (((whence) == SEEK_SET) ? (offset) : \
67    ((whence) == SEEK_CUR) ? (curr_off) + (offset) : \
68    ((whence) == SEEK_END) ? (length) + (offset) : -1)
69
70 /*
71 =head1 NAME
72
73 iolayer.c - encapsulates different source of data into a single framework.
74
75 =head1 SYNOPSIS
76
77   io_glue *ig = io_new_fd( fileno(stdin) );
78   method = io_reqmeth( IOL_NOSEEK | IOL_MMAP ); // not implemented yet
79   io_glue_commit_types(ig);                     // always assume IOL_SEEK for now
80   switch (method) {
81   case IOL_NOSEEK:
82     code that uses ig->readcb()
83     to read data goes here.
84     break;
85   case IOL_MMAP:
86     code that uses ig->readcb()
87     to read data goes here.
88     break;
89   }  
90
91   io_glue_destroy(ig);
92   // and much more
93
94 =head1 DESCRIPTION
95
96 iolayer.c implements the basic functions to create and destroy io_glue
97 objects for Imager.  The typical usage pattern for data sources is:
98
99    1. Create the source (io_new_fd)
100    2. Define how you want to get data from it (io_reqmeth)
101    3. read from it using the interface requested (ig->readdb, ig->mmapcb)
102    4. Close the source, which 
103       shouldn't really close the underlying source. (io_glue DESTROY)
104
105 =head1 FUNCTION REFERENCE
106
107 Some of these functions are internal.
108
109 =over
110
111 =cut
112 */
113
114 static ssize_t fd_read(io_glue *ig, void *buf, size_t count);
115 static ssize_t fd_write(io_glue *ig, const void *buf, size_t count);
116 static off_t fd_seek(io_glue *ig, off_t offset, int whence);
117 static int fd_close(io_glue *ig);
118 static ssize_t fd_size(io_glue *ig);
119 static const char *my_strerror(int err);
120
121 /*
122  * Callbacks for sources that cannot seek
123  */
124
125 /* fakeseek_read: read method for when emulating a seekable source
126 static
127 ssize_t
128 fakeseek_read(io_glue *ig, void *buf, size_t count) {
129   io_ex_fseek *exdata = ig->exdata; 
130   return 0;
131 }
132 */
133
134
135
136 /*
137  * Callbacks for sources that can seek 
138  */
139
140 /*
141 =item realseek_read(ig, buf, count)
142
143 Does the reading from a source that can be seeked on
144
145    ig    - io_glue object
146    buf   - buffer to return data in
147    count - number of bytes to read into buffer max
148
149 =cut
150 */
151
152 static
153 ssize_t 
154 realseek_read(io_glue *ig, void *buf, size_t count) {
155   io_ex_rseek *ier = ig->exdata;
156   void *p          = ig->source.cb.p;
157   ssize_t       rc = 0;
158   size_t        bc = 0;
159   char       *cbuf = buf;
160
161   IOL_DEB( printf("realseek_read:  buf = %p, count = %d\n", 
162                   buf, count) );
163   /* Is this a good idea? Would it be better to handle differently?
164      skip handling? */
165   while( count!=bc && (rc = ig->source.cb.readcb(p,cbuf+bc,count-bc))>0 ) {
166     bc+=rc;
167   }
168   
169   ier->cpos += bc;
170   IOL_DEB( printf("realseek_read: rc = %d, bc = %d\n", rc, bc) );
171   return rc < 0 ? rc : bc;
172 }
173
174
175 /*
176 =item realseek_write(ig, buf, count)
177
178 Does the writing to a 'source' that can be seeked on
179
180    ig    - io_glue object
181    buf   - buffer that contains data
182    count - number of bytes to write
183
184 =cut
185 */
186
187 static
188 ssize_t 
189 realseek_write(io_glue *ig, const void *buf, size_t count) {
190   io_ex_rseek *ier = ig->exdata;
191   void          *p = ig->source.cb.p;
192   ssize_t       rc = 0;
193   size_t        bc = 0;
194   char       *cbuf = (char*)buf; 
195   
196   IOL_DEB( printf("realseek_write: ig = %p, ier->cpos = %ld, buf = %p, "
197                   "count = %d\n", ig, (long) ier->cpos, buf, count) );
198
199   /* Is this a good idea? Would it be better to handle differently? 
200      skip handling? */
201   while( count!=bc && (rc = ig->source.cb.writecb(p,cbuf+bc,count-bc))>0 ) {
202     bc+=rc;
203   }
204
205   ier->cpos += bc;
206   IOL_DEB( printf("realseek_write: rc = %d, bc = %d\n", rc, bc) );
207   return rc < 0 ? rc : bc;
208 }
209
210
211 /*
212 =item realseek_close(ig)
213
214 Closes a source that can be seeked on.  Not sure if this should be an
215 actual close or not.  Does nothing for now.  Should be fixed.
216
217    ig - data source
218
219 =cut */
220
221 static
222 int
223 realseek_close(io_glue *ig) {
224   mm_log((1, "realseek_close(ig %p)\n", ig));
225   if (ig->source.cb.closecb)
226     return ig->source.cb.closecb(ig->source.cb.p);
227   else
228     return 0;
229 }
230
231
232 /* realseek_seek(ig, offset, whence)
233
234 Implements seeking for a source that is seekable, the purpose of having this is to be able to
235 have an offset into a file that is different from what the underlying library thinks.
236
237    ig     - data source
238    offset - offset into stream
239    whence - whence argument a la lseek
240
241 =cut
242 */
243
244 static
245 off_t
246 realseek_seek(io_glue *ig, off_t offset, int whence) {
247   /*  io_ex_rseek *ier = ig->exdata; Needed later */
248   void *p = ig->source.cb.p;
249   off_t rc;
250   IOL_DEB( printf("realseek_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
251   rc = ig->source.cb.seekcb(p, offset, whence);
252
253   IOL_DEB( printf("realseek_seek: rc %ld\n", (long) rc) );
254   return rc;
255   /* FIXME: How about implementing this offset handling stuff? */
256 }
257
258 static
259 void
260 realseek_destroy(io_glue *ig) {
261   io_ex_rseek *ier = ig->exdata;
262
263   if (ig->source.cb.destroycb)
264     ig->source.cb.destroycb(ig->source.cb.p);
265
266   myfree(ier);
267 }
268
269 /*
270  * Callbacks for sources that are a fixed size buffer
271  */
272
273 /*
274 =item buffer_read(ig, buf, count)
275
276 Does the reading from a buffer source
277
278    ig    - io_glue object
279    buf   - buffer to return data in
280    count - number of bytes to read into buffer max
281
282 =cut
283 */
284
285 static
286 ssize_t 
287 buffer_read(io_glue *ig, void *buf, size_t count) {
288   io_ex_buffer *ieb = ig->exdata;
289
290   IOL_DEB( printf("buffer_read: ieb->cpos = %ld, buf = %p, count = %d\n", (long) ieb->cpos, buf, count) );
291
292   if ( ieb->cpos+count > ig->source.buffer.len ) {
293     mm_log((1,"buffer_read: short read: cpos=%ld, len=%ld, count=%ld\n", (long)ieb->cpos, (long)ig->source.buffer.len, (long)count));
294     count = ig->source.buffer.len - ieb->cpos;
295   }
296   
297   memcpy(buf, ig->source.buffer.data+ieb->cpos, count);
298   ieb->cpos += count;
299   IOL_DEB( printf("buffer_read: count = %ld\n", (long)count) );
300   return count;
301 }
302
303
304 /*
305 =item buffer_write(ig, buf, count)
306
307 Does nothing, returns -1
308
309    ig    - io_glue object
310    buf   - buffer that contains data
311    count - number of bytes to write
312
313 =cut
314 */
315
316 static
317 ssize_t 
318 buffer_write(io_glue *ig, const void *buf, size_t count) {
319   mm_log((1, "buffer_write called, this method should never be called.\n"));
320   return -1;
321 }
322
323
324 /*
325 =item buffer_close(ig)
326
327 Closes a source that can be seeked on.  Not sure if this should be an actual close
328 or not.  Does nothing for now.  Should be fixed.
329
330    ig - data source
331
332 =cut
333 */
334
335 static
336 int
337 buffer_close(io_glue *ig) {
338   mm_log((1, "buffer_close(ig %p)\n", ig));
339
340   return 0;
341 }
342
343
344 /* buffer_seek(ig, offset, whence)
345
346 Implements seeking for a buffer source.
347
348    ig     - data source
349    offset - offset into stream
350    whence - whence argument a la lseek
351
352 =cut
353 */
354
355 static
356 off_t
357 buffer_seek(io_glue *ig, off_t offset, int whence) {
358   io_ex_buffer *ieb = ig->exdata;
359   off_t reqpos = 
360     calc_seek_offset(ieb->cpos, ig->source.buffer.len, offset, whence);
361   
362   if (reqpos > ig->source.buffer.len) {
363     mm_log((1, "seeking out of readable range\n"));
364     return (off_t)-1;
365   }
366   if (reqpos < 0) {
367     i_push_error(0, "seek before beginning of file");
368     return (off_t)-1;
369   }
370   
371   ieb->cpos = reqpos;
372   IOL_DEB( printf("buffer_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
373
374   return reqpos;
375   /* FIXME: How about implementing this offset handling stuff? */
376 }
377
378 static
379 void
380 buffer_destroy(io_glue *ig) {
381   io_ex_buffer *ieb = ig->exdata;
382
383   if (ig->source.buffer.closecb) {
384     mm_log((1,"calling close callback %p for io_buffer\n", 
385             ig->source.buffer.closecb));
386     ig->source.buffer.closecb(ig->source.buffer.closedata);
387   }
388   myfree(ieb);
389 }
390
391
392
393 /*
394  * Callbacks for sources that are a chain of variable sized buffers
395  */
396
397
398
399 /* Helper functions for buffer chains */
400
401 static
402 io_blink*
403 io_blink_new(void) {
404   io_blink *ib;
405
406   mm_log((1, "io_blink_new()\n"));
407
408   ib = mymalloc(sizeof(io_blink));
409
410   ib->next = NULL;
411   ib->prev = NULL;
412   ib->len  = BBSIZ;
413
414   memset(&ib->buf, 0, ib->len);
415   return ib;
416 }
417
418
419
420 /*
421 =item io_bchain_advance(ieb)
422
423 Advances the buffer chain to the next link - extending if
424 necessary.  Also adjusts the cpos and tfill counters as needed.
425
426    ieb   - buffer chain object
427
428 =cut
429 */
430
431 static
432 void
433 io_bchain_advance(io_ex_bchain *ieb) {
434   if (ieb->cp->next == NULL) {
435     ieb->tail = io_blink_new();
436     ieb->tail->prev = ieb->cp;
437     ieb->cp->next   = ieb->tail;
438
439     ieb->tfill = 0; /* Only set this if we added a new slice */
440   }
441   ieb->cp    = ieb->cp->next;
442   ieb->cpos  = 0;
443 }
444
445
446
447 /*
448 =item io_bchain_destroy()
449
450 frees all resources used by a buffer chain.
451
452 =cut
453 */
454
455 void
456 io_destroy_bufchain(io_ex_bchain *ieb) {
457   io_blink *cp;
458   mm_log((1, "io_destroy_bufchain(ieb %p)\n", ieb));
459   cp = ieb->head;
460   
461   while(cp) {
462     io_blink *t = cp->next;
463     myfree(cp);
464     cp = t;
465   }
466 }
467
468
469
470
471 /*
472
473 static
474 void
475 bufchain_dump(io_ex_bchain *ieb) {
476   mm_log((1, "  buf_chain_dump(ieb %p)\n"));
477   mm_log((1, "  buf_chain_dump: ieb->offset = %d\n", ieb->offset));
478   mm_log((1, "  buf_chain_dump: ieb->length = %d\n", ieb->length));
479   mm_log((1, "  buf_chain_dump: ieb->head   = %p\n", ieb->head  ));
480   mm_log((1, "  buf_chain_dump: ieb->tail   = %p\n", ieb->tail  ));
481   mm_log((1, "  buf_chain_dump: ieb->tfill  = %d\n", ieb->tfill ));
482   mm_log((1, "  buf_chain_dump: ieb->cp     = %p\n", ieb->cp    ));
483   mm_log((1, "  buf_chain_dump: ieb->cpos   = %d\n", ieb->cpos  ));
484   mm_log((1, "  buf_chain_dump: ieb->gpos   = %d\n", ieb->gpos  ));
485 }
486 */
487
488 /*
489  * TRUE if lengths are NOT equal
490  */
491
492 /*
493 static
494 void
495 chainlencert( io_glue *ig ) {
496   int clen;
497   int cfl           = 0;
498   size_t csize      = 0;
499   size_t cpos       = 0;
500   io_ex_bchain *ieb = ig->exdata;
501   io_blink *cp      = ieb->head;
502   
503
504   if (ieb->gpos > ieb->length) mm_log((1, "BBAR : ieb->gpos = %d, ieb->length = %d\n", ieb->gpos, ieb->length));
505
506   while(cp) {
507     clen = (cp == ieb->tail) ? ieb->tfill : cp->len;
508     if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
509     if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
510     
511     if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
512     if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
513     
514     if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
515     if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
516
517     if (cp == ieb->cp) {
518       cfl = 1;
519       cpos += ieb->cpos;
520     }
521
522     if (!cfl) cpos += clen;
523
524     csize += clen;
525     cp     = cp->next;
526   }
527   if (( csize != ieb->length )) mm_log((1, "BAR : csize = %d, ieb->length = %d\n", csize, ieb->length));
528   if (( cpos  != ieb->gpos   )) mm_log((1, "BAR : cpos  = %d, ieb->gpos   = %d\n", cpos,  ieb->gpos  ));
529 }
530
531
532 static
533 void
534 chaincert( io_glue *ig) {
535   size_t csize   = 0;
536   io_ex_bchain *ieb = ig->exdata;
537   io_blink *cp   = ieb->head;
538   
539   mm_log((1, "Chain verification.\n"));
540
541   mm_log((1, "  buf_chain_dump: ieb->offset = %d\n", ieb->offset));
542   mm_log((1, "  buf_chain_dump: ieb->length = %d\n", ieb->length));
543   mm_log((1, "  buf_chain_dump: ieb->head   = %p\n", ieb->head  ));
544   mm_log((1, "  buf_chain_dump: ieb->tail   = %p\n", ieb->tail  ));
545   mm_log((1, "  buf_chain_dump: ieb->tfill  = %d\n", ieb->tfill ));
546   mm_log((1, "  buf_chain_dump: ieb->cp     = %p\n", ieb->cp    ));
547   mm_log((1, "  buf_chain_dump: ieb->cpos   = %d\n", ieb->cpos  ));
548   mm_log((1, "  buf_chain_dump: ieb->gpos   = %d\n", ieb->gpos  ));
549
550   while(cp) {
551     int clen = cp == ieb->tail ? ieb->tfill : cp->len;
552     mm_log((1, "link: %p <- %p -> %p\n", cp->prev, cp, cp->next));
553     if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
554     if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
555     
556     if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
557     if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
558     
559     if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
560     if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
561
562     csize += clen;
563     cp     = cp->next;
564   }
565
566   mm_log((1, "csize = %d %s ieb->length = %d\n", csize, csize == ieb->length ? "==" : "!=", ieb->length));
567 }
568 */
569
570
571
572
573
574
575
576
577
578
579
580 /*
581 =item bufchain_read(ig, buf, count)
582
583 Does the reading from a source that can be seeked on
584
585    ig    - io_glue object
586    buf   - buffer to return data in
587    count - number of bytes to read into buffer max
588
589 =cut
590 */
591
592 static
593 ssize_t 
594 bufchain_read(io_glue *ig, void *buf, size_t count) {
595   io_ex_bchain *ieb = ig->exdata;
596   size_t     scount = count;
597   char        *cbuf = buf;
598   size_t         sk;
599
600   mm_log((1, "bufchain_read(ig %p, buf %p, count %ld)\n", ig, buf, (long)count));
601
602   while( scount ) {
603     int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
604     if (clen == ieb->cpos) {
605       if (ieb->cp == ieb->tail) break; /* EOF */
606       ieb->cp = ieb->cp->next;
607       ieb->cpos = 0;
608       clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
609     }
610
611     sk = clen - ieb->cpos;
612     sk = sk > scount ? scount : sk;
613
614     memcpy(&cbuf[count-scount], &ieb->cp->buf[ieb->cpos], sk);
615     scount    -= sk;
616     ieb->cpos += sk;
617     ieb->gpos += sk;
618   }
619
620   mm_log((1, "bufchain_read: returning %ld\n", (long)(count-scount)));
621   return count-scount;
622 }
623
624
625
626
627
628 /*
629 =item bufchain_write(ig, buf, count)
630
631 Does the writing to a 'source' that can be seeked on
632
633    ig    - io_glue object
634    buf   - buffer that contains data
635    count - number of bytes to write
636
637 =cut
638 */
639
640 static
641 ssize_t
642 bufchain_write(io_glue *ig, const void *buf, size_t count) {
643   char *cbuf = (char *)buf;
644   io_ex_bchain *ieb = ig->exdata;
645   size_t         ocount = count;
646   size_t         sk;
647
648   mm_log((1, "bufchain_write: ig = %p, buf = %p, count = %ld\n", ig, buf, (long)count));
649
650   IOL_DEB( printf("bufchain_write: ig = %p, ieb->cpos = %ld, buf = %p, count = %ld\n", ig, (long) ieb->cpos, buf, (long)count) );
651   
652   while(count) {
653     mm_log((2, "bufchain_write: - looping - count = %ld\n", (long)count));
654     if (ieb->cp->len == ieb->cpos) {
655       mm_log((1, "bufchain_write: cp->len == ieb->cpos = %ld - advancing chain\n", (long) ieb->cpos));
656       io_bchain_advance(ieb);
657     }
658
659     sk = ieb->cp->len - ieb->cpos;
660     sk = sk > count ? count : sk;
661     memcpy(&ieb->cp->buf[ieb->cpos], &cbuf[ocount-count], sk);
662
663     if (ieb->cp == ieb->tail) {
664       int extend = ieb->cpos + sk - ieb->tfill;
665       mm_log((2, "bufchain_write: extending tail by %d\n", extend));
666       if (extend > 0) {
667         ieb->length += extend;
668         ieb->tfill  += extend;
669       }
670     }
671
672     ieb->cpos += sk;
673     ieb->gpos += sk;
674     count     -= sk;
675   }
676   return ocount;
677 }
678
679 /*
680 =item bufchain_close(ig)
681
682 Closes a source that can be seeked on.  Not sure if this should be an actual close
683 or not.  Does nothing for now.  Should be fixed.
684
685    ig - data source
686
687 =cut
688 */
689
690 static
691 int
692 bufchain_close(io_glue *ig) {
693   mm_log((1, "bufchain_close(ig %p)\n",ig));
694   IOL_DEB( printf("bufchain_close(ig %p)\n", ig) );
695
696   return 0;  
697 }
698
699
700 /* bufchain_seek(ig, offset, whence)
701
702 Implements seeking for a source that is seekable, the purpose of having this is to be able to
703 have an offset into a file that is different from what the underlying library thinks.
704
705    ig     - data source
706    offset - offset into stream
707    whence - whence argument a la lseek
708
709 =cut
710 */
711
712 static
713 off_t
714 bufchain_seek(io_glue *ig, off_t offset, int whence) {
715   io_ex_bchain *ieb = ig->exdata;
716   int wrlen;
717
718   off_t scount = calc_seek_offset(ieb->gpos, ieb->length, offset, whence);
719   off_t sk;
720
721   mm_log((1, "bufchain_seek(ig %p, offset %ld, whence %d)\n", ig, (long)offset, whence));
722
723   if (scount < 0) {
724     i_push_error(0, "invalid whence supplied or seek before start of file");
725     return (off_t)-1;
726   }
727
728   ieb->cp   = ieb->head;
729   ieb->cpos = 0;
730   ieb->gpos = 0;
731   
732   while( scount ) {
733     int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
734     if (clen == ieb->cpos) {
735       if (ieb->cp == ieb->tail) break; /* EOF */
736       ieb->cp = ieb->cp->next;
737       ieb->cpos = 0;
738       clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
739     }
740     
741     sk = clen - ieb->cpos;
742     sk = sk > scount ? scount : sk;
743     
744     scount    -= sk;
745     ieb->cpos += sk;
746     ieb->gpos += sk;
747   }
748   
749   wrlen = scount;
750
751   if (wrlen > 0) { 
752     /*
753      * extending file - get ieb into consistent state and then
754      * call write which will get it to the correct position 
755      */
756     char TB[BBSIZ];
757     memset(TB, 0, BBSIZ);
758     ieb->gpos = ieb->length;
759     ieb->cpos = ieb->tfill;
760     
761     while(wrlen > 0) {
762       ssize_t rc, wl = i_min(wrlen, BBSIZ);
763       mm_log((1, "bufchain_seek: wrlen = %d, wl = %ld\n", wrlen, (long)wl));
764       rc = bufchain_write( ig, TB, wl );
765       if (rc != wl) i_fatal(0, "bufchain_seek: Unable to extend file\n");
766       wrlen -= rc;
767     }
768   }
769
770   mm_log((2, "bufchain_seek: returning ieb->gpos = %ld\n", (long)ieb->gpos));
771   return ieb->gpos;
772 }
773
774 static
775 void
776 bufchain_destroy(io_glue *ig) {
777   io_ex_bchain *ieb = ig->exdata;
778
779   io_destroy_bufchain(ieb);
780
781   myfree(ieb);
782 }
783
784 /*
785  * Methods for setting up data source
786  */
787
788 /*
789 =item io_obj_setp_buffer(io, p, len)
790
791 Sets an io_object for reading from a buffer source
792
793    io  - io object that describes a source
794    p   - pointer to buffer
795    len - length of buffer
796
797 =cut
798 */
799
800 static void
801 io_obj_setp_buffer(io_obj *io, char *p, size_t len, i_io_closebufp_t closecb, 
802                    void *closedata) {
803   io->buffer.type      = BUFFER;
804   io->buffer.data      = p;
805   io->buffer.len       = len;
806   io->buffer.closecb   = closecb;
807   io->buffer.closedata = closedata;
808 }
809
810
811
812 /*
813 =item io_obj_setp_cb2(io, p, readcb, writecb, seekcb, closecb, destroycb)
814
815 Sets an io_object for reading from a source that uses callbacks
816
817    io      - io object that describes a source
818    p         - pointer to data for callbacks
819    readcb    - read callback to read from source
820    writecb   - write callback to write to source
821    seekcb    - seek callback to seek on source
822    closecb   - flush any pending data
823    destroycb - release any extra resources
824
825 =cut
826 */
827
828 static void
829 io_obj_setp_cb2(io_obj *io, void *p, i_io_readl_t readcb, i_io_writel_t writecb, i_io_seekl_t seekcb, i_io_closel_t closecb, i_io_destroyl_t destroycb) {
830   io->cb.type      = CBSEEK;
831   io->cb.p         = p;
832   io->cb.readcb    = readcb;
833   io->cb.writecb   = writecb;
834   io->cb.seekcb    = seekcb;
835   io->cb.closecb   = closecb;
836   io->cb.destroycb = destroycb;
837 }
838
839 /*
840 =item io_glue_commit_types(ig)
841
842 This is now effectively a no-op.
843
844 =cut
845 */
846
847 void
848 io_glue_commit_types(io_glue *ig) {
849   io_type      inn = ig->source.type;
850
851   mm_log((1, "io_glue_commit_types(ig %p)\n", ig));
852   mm_log((1, "io_glue_commit_types: source type %d (%s)\n", inn, io_type_names[inn]));
853
854   if (ig->flags & 0x01) {
855     mm_log((1, "io_glue_commit_types: type already set up\n"));
856     return;
857   }
858
859   ig->flags |= 0x01; /* indicate source has been setup already */
860 }
861
862 /*
863 =item io_glue_gettypes(ig, reqmeth)
864
865 Returns a set of compatible interfaces to read data with.
866
867   ig      - io_glue object
868   reqmeth - request mask
869
870 The request mask is a bit mask (of something that hasn't been implemented yet)
871 of interfaces that it would like to read data from the source which the ig
872 describes.
873
874 =cut
875 */
876
877 void
878 io_glue_gettypes(io_glue *ig, int reqmeth) {
879
880   ig = NULL;
881   reqmeth = 0;
882   
883   /* FIXME: Implement this function! */
884   /* if (ig->source.type = 
885      if (reqmeth & IO_BUFF) */ 
886
887 }
888
889
890 /*
891 =item io_new_bufchain()
892
893 returns a new io_glue object that has the 'empty' source and but can
894 be written to and read from later (like a pseudo file).
895
896 =cut
897 */
898
899 io_glue *
900 io_new_bufchain() {
901   io_glue *ig;
902   io_ex_bchain *ieb = mymalloc(sizeof(io_ex_bchain));
903
904   mm_log((1, "io_new_bufchain()\n"));
905
906   ig = mymalloc(sizeof(io_glue));
907   memset(ig, 0, sizeof(*ig));
908   ig->source.type = BUFCHAIN;
909
910   ieb->offset = 0;
911   ieb->length = 0;
912   ieb->cpos   = 0;
913   ieb->gpos   = 0;
914   ieb->tfill  = 0;
915   
916   ieb->head   = io_blink_new();
917   ieb->cp     = ieb->head;
918   ieb->tail   = ieb->head;
919   
920   ig->exdata    = ieb;
921   ig->readcb    = bufchain_read;
922   ig->writecb   = bufchain_write;
923   ig->seekcb    = bufchain_seek;
924   ig->closecb   = bufchain_close;
925   ig->destroycb = bufchain_destroy;
926
927   return ig;
928 }
929
930 /*
931 =item io_new_buffer(data, len)
932
933 Returns a new io_glue object that has the source defined as reading
934 from specified buffer.  Note that the buffer is not copied.
935
936    data - buffer to read from
937    len - length of buffer
938
939 =cut
940 */
941
942 io_glue *
943 io_new_buffer(char *data, size_t len, i_io_closebufp_t closecb, void *closedata) {
944   io_glue *ig;
945   io_ex_buffer *ieb = mymalloc(sizeof(io_ex_buffer));
946   
947   mm_log((1, "io_new_buffer(data %p, len %ld, closecb %p, closedata %p)\n", data, (long)len, closecb, closedata));
948
949   ig = mymalloc(sizeof(io_glue));
950   memset(ig, 0, sizeof(*ig));
951   io_obj_setp_buffer(&ig->source, data, len, closecb, closedata);
952   ig->flags = 0;
953
954   ieb->offset = 0;
955   ieb->cpos   = 0;
956   
957   ig->exdata    = ieb;
958   ig->readcb    = buffer_read;
959   ig->writecb   = buffer_write;
960   ig->seekcb    = buffer_seek;
961   ig->closecb   = buffer_close;
962   ig->destroycb = buffer_destroy;
963
964   return ig;
965 }
966
967
968 /*
969 =item io_new_fd(fd)
970
971 returns a new io_glue object that has the source defined as reading
972 from specified filedescriptor.  Note that the the interface to recieving
973 data from the io_glue callbacks hasn't been done yet.
974
975    fd - file descriptor to read/write from
976
977 =cut
978 */
979
980 io_glue *
981 io_new_fd(int fd) {
982   io_glue *ig;
983
984   mm_log((1, "io_new_fd(fd %d)\n", fd));
985
986   ig = mymalloc(sizeof(io_glue));
987   memset(ig, 0, sizeof(*ig));
988   ig->source.type = FDSEEK;
989   ig->source.fdseek.fd = fd;
990   ig->flags = 0;
991
992   ig->exdata    = NULL;
993   ig->readcb    = fd_read;
994   ig->writecb   = fd_write;
995   ig->seekcb    = fd_seek;
996   ig->closecb   = fd_close;
997   ig->sizecb    = fd_size;
998   ig->destroycb = NULL;
999       
1000   mm_log((1, "(%p) <- io_new_fd\n", ig));
1001   return ig;
1002 }
1003
1004 io_glue *io_new_cb(void *p, i_io_readl_t readcb, i_io_writel_t writecb, 
1005                    i_io_seekl_t seekcb, i_io_closel_t closecb, 
1006                    i_io_destroyl_t destroycb) {
1007   io_glue *ig;
1008   io_ex_rseek *ier = mymalloc(sizeof(io_ex_rseek));
1009
1010   mm_log((1, "io_new_cb(p %p, readcb %p, writecb %p, seekcb %p, closecb %p, "
1011           "destroycb %p)\n", p, readcb, writecb, seekcb, closecb, destroycb));
1012   ig = mymalloc(sizeof(io_glue));
1013   memset(ig, 0, sizeof(*ig));
1014   io_obj_setp_cb2(&ig->source, p, readcb, writecb, seekcb, closecb, destroycb);
1015   mm_log((1, "(%p) <- io_new_cb\n", ig));
1016
1017   ier->offset = 0;
1018   ier->cpos   = 0;
1019   
1020   ig->exdata    = ier;
1021   ig->readcb    = realseek_read;
1022   ig->writecb   = realseek_write;
1023   ig->seekcb    = realseek_seek;
1024   ig->closecb   = realseek_close;
1025   ig->destroycb = realseek_destroy;
1026
1027   return ig;
1028 }
1029
1030 /*
1031 =item io_slurp(ig)
1032
1033 Takes the source that the io_glue is bound to and allocates space
1034 for a return buffer and returns the entire content in a single buffer.
1035 Note: This only works for io_glue objects that contain a bufchain.  It
1036 is usefull for saving to scalars and such.
1037
1038    ig - io_glue object
1039    c  - pointer to a pointer to where data should be copied to
1040
1041 =cut
1042 */
1043
1044 size_t
1045 io_slurp(io_glue *ig, unsigned char **c) {
1046   ssize_t rc;
1047   off_t orgoff;
1048   io_ex_bchain *ieb;
1049   unsigned char *cc;
1050   io_type inn = ig->source.type;
1051   
1052   if ( inn != BUFCHAIN ) {
1053     i_fatal(0, "io_slurp: called on a source that is not from a bufchain\n");
1054   }
1055
1056   ieb = ig->exdata;
1057   cc = *c = mymalloc( ieb->length );
1058   
1059   orgoff = ieb->gpos;
1060   
1061   bufchain_seek(ig, 0, SEEK_SET);
1062   
1063   rc = bufchain_read(ig, cc, ieb->length);
1064
1065   if (rc != ieb->length)
1066     i_fatal(1, "io_slurp: bufchain_read returned an incomplete read: rc = %d, request was %d\n", rc, ieb->length);
1067
1068   return rc;
1069 }
1070
1071 /*
1072 =item fd_read(ig, buf, count)
1073
1074 =cut
1075 */
1076 static ssize_t fd_read(io_glue *ig, void *buf, size_t count) {
1077   ssize_t result;
1078 #ifdef _MSC_VER
1079   result = _read(ig->source.fdseek.fd, buf, count);
1080 #else
1081   result = read(ig->source.fdseek.fd, buf, count);
1082 #endif
1083
1084   /* 0 is valid - means EOF */
1085   if (result < 0) {
1086     i_push_errorf(0, "read() failure: %s (%d)", my_strerror(errno), errno);
1087   }
1088
1089   return result;
1090 }
1091
1092 static ssize_t fd_write(io_glue *ig, const void *buf, size_t count) {
1093   ssize_t result;
1094 #ifdef _MSC_VER
1095   result = _write(ig->source.fdseek.fd, buf, count);
1096 #else
1097   result = write(ig->source.fdseek.fd, buf, count);
1098 #endif
1099
1100   if (result <= 0) {
1101     i_push_errorf(errno, "write() failure: %s (%d)", my_strerror(errno), errno);
1102   }
1103
1104   return result;
1105 }
1106
1107 static off_t fd_seek(io_glue *ig, off_t offset, int whence) {
1108   off_t result;
1109 #ifdef _MSC_VER
1110   result = _lseek(ig->source.fdseek.fd, offset, whence);
1111 #else
1112   result = lseek(ig->source.fdseek.fd, offset, whence);
1113 #endif
1114
1115   if (result == (off_t)-1) {
1116     i_push_errorf(errno, "lseek() failure: %s (%d)", my_strerror(errno), errno);
1117   }
1118
1119   return result;
1120 }
1121
1122 static int fd_close(io_glue *ig) {
1123   /* no, we don't close it */
1124   return 0;
1125 }
1126
1127 static ssize_t fd_size(io_glue *ig) {
1128   mm_log((1, "fd_size(ig %p) unimplemented\n", ig));
1129   
1130   return -1;
1131 }
1132
1133 /*
1134 =item io_glue_destroy(ig)
1135
1136 A destructor method for io_glue objects.  Should clean up all related buffers.
1137 Might leave us with a dangling pointer issue on some buffers.
1138
1139    ig - io_glue object to destroy.
1140
1141 =cut
1142 */
1143
1144 void
1145 io_glue_destroy(io_glue *ig) {
1146   mm_log((1, "io_glue_DESTROY(ig %p)\n", ig));
1147
1148   if (ig->destroycb)
1149     ig->destroycb(ig);
1150   
1151   myfree(ig);
1152 }
1153
1154 /*
1155 =back
1156
1157 =head1 INTERNAL FUNCTIONS
1158
1159 =over
1160
1161 =item my_strerror
1162
1163 Calls strerror() and ensures we don't return NULL.
1164
1165 On some platforms it's possible for strerror() to return NULL, this
1166 wrapper ensures we only get non-NULL values.
1167
1168 =cut
1169 */
1170
1171 static
1172 const char *my_strerror(int err) {
1173   const char *result = strerror(err);
1174
1175   if (!result)
1176     result = "Unknown error";
1177
1178   return result;
1179 }
1180
1181 /*
1182 =back
1183
1184 =head1 AUTHOR
1185
1186 Arnar M. Hrafnkelsson <addi@umich.edu>
1187
1188 =head1 SEE ALSO
1189
1190 Imager(3)
1191
1192 =cut
1193 */