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