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