[rt #74875] add unshipped test for unclosed pod in C sources
[imager.git] / iolayer.c
CommitLineData
ed60e785 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
ed60e785
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/*
abffffed
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
abffffed 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
abffffed
TC
165Also callable as C<io_new_bufchain()>.
166
6d5c85a2
TC
167=cut
168*/
169
170io_glue *
ed60e785 171im_io_new_bufchain(pIMCTX) {
6d5c85a2
TC
172 io_glue *ig;
173 io_ex_bchain *ieb = mymalloc(sizeof(io_ex_bchain));
174
ed60e785 175 im_log((aIMCTX, 1, "io_new_bufchain()\n"));
6d5c85a2
TC
176
177 ig = mymalloc(sizeof(io_glue));
178 memset(ig, 0, sizeof(*ig));
ed60e785 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
ed60e785
TC
195 im_context_refinc(aIMCTX, "im_io_new_bufchain");
196
6d5c85a2 197 return ig;
02d1d628 198}
6d5c85a2
TC
199
200/*
abffffed
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
abffffed 209 ctx - an Imager context object
6d5c85a2
TC
210 data - buffer to read from
211 length - length of buffer
212
abffffed
TC
213Also callable as C<io_new_buffer(data, length>.
214
6d5c85a2 215=cut
02d1d628
AMH
216*/
217
6d5c85a2 218io_glue *
ed60e785 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
ed60e785 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));
ed60e785 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
ed60e785
TC
237 im_context_refinc(aIMCTX, "im_io_new_bufchain");
238
6d5c85a2
TC
239 return (io_glue *)ig;
240}
02d1d628
AMH
241
242
243/*
abffffed
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
abffffed 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
abffffed
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 *
ed60e785 262im_io_new_fd(pIMCTX, int fd) {
6d5c85a2
TC
263 io_fdseek *ig;
264
ed60e785 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));
ed60e785 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;
ed60e785 275 im_context_refinc(aIMCTX, "im_io_new_bufchain");
6d5c85a2 276
ed60e785 277 im_log((aIMCTX, 1, "(%p) <- io_new_fd\n", ig));
6d5c85a2
TC
278 return (io_glue *)ig;
279}
02d1d628
AMH
280
281/*
abffffed
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
abffffed
TC
321Also callable as C<io_new_cb(p, readcb, writecb, seekcb, closecb,
322destroycb)>.
323
02d1d628
AMH
324=cut
325*/
326
6d5c85a2 327io_glue *
ed60e785 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
ed60e785 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));
ed60e785
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;
ed60e785
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)
abffffed 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 ) {
2038f6ce
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
2038f6ce
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)
abffffed 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) {
ed60e785
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);
ed60e785
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) {
ed60e785 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
ed60e785 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;
ed60e785 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
d701a5e7
TC
1190 /* there should always be buffer space the first time around, but
1191 avoid a compiler warning here */
1192 rc = -1;
6d5c85a2
TC
1193 while (work < buf_end && (rc = i_io_raw_read(ig, work, buf_end - work)) > 0) {
1194 work += rc;
1195 good = 1;
1196 if (needed < rc)
1197 break;
1198
1199 needed -= rc;
1200 }
1201
1202 if (rc < 0) {
1203 ig->error = 1;
1204 IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc %d, setting error\n",
1205 (int)rc));
1206 }
1207 else if (rc == 0) {
1208 ig->buf_eof = 1;
1209 IOL_DEB(fprintf(IOL_DEBs, " i_io_read_fill -> rc 0, setting eof\n"));
1210 }
1211
1212 if (good) {
1213 ig->read_ptr = buf_start;
1214 ig->read_end = work;
1215 }
1216
1217 IOL_DEB(fprintf(IOL_DEBs, "i_io_read_fill => %d, %u buffered\n", good,
1218 (unsigned)(ig->read_end - ig->read_ptr)));
1219 return good;
1220}
1221
1222/*
1223=item dump_data(start, end, bias)
1224
1225Hex dump the data between C<start> and C<end>.
1226
1227If there is more than a pleasing amount of data, either dump the
1228beginning (C<bias == 0>) or dump the end C(<bias != 0>) of the range.
1229
1230=cut
1231*/
1232
1233static void
1234dump_data(unsigned char *start, unsigned char *end, int bias) {
1235 unsigned char *p;
1236 size_t count = end - start;
1237
1238 if (start == end) {
1239 fprintf(IOL_DEBs, "(empty)");
1240 return;
1241 }
1242
1243 if (count > 15) {
1244 if (bias) {
1245 fprintf(IOL_DEBs, "... ");
1246 start = end - 14;
1247 }
1248 else {
1249 end = start + 14;
1250 }
1251
1252 for (p = start; p < end; ++p) {
1253 fprintf(IOL_DEBs, " %02x", *p);
1254 }
1255 putc(' ', IOL_DEBs);
1256 putc('<', IOL_DEBs);
1257 for (p = start; p < end; ++p) {
1258 if (*p < ' ' || *p > '~')
1259 putc('.', IOL_DEBs);
1260 else
1261 putc(*p, IOL_DEBs);
1262 }
1263 putc('>', IOL_DEBs);
1264 if (!bias)
1265 fprintf(IOL_DEBs, " ...");
1266 }
1267 else {
1268 for (p = start; p < end; ++p) {
1269 fprintf(IOL_DEBs, " %02x", *p);
1270 }
1271 putc(' ', IOL_DEBs);
1272 for (p = start; p < end; ++p) {
1273 if (*p < ' ' || *p > '~')
1274 putc('.', IOL_DEBs);
1275 else
1276 putc(*p, IOL_DEBs);
1277 }
1278 }
1279}
1280
1281/*
1282 * Callbacks for sources that cannot seek
1283 */
1284
1285/*
1286 * Callbacks for sources that can seek
1287 */
1288
1289/*
1290=item realseek_read(ig, buf, count)
1291
1292Does the reading from a source that can be seeked on
1293
1294 ig - io_glue object
1295 buf - buffer to return data in
1296 count - number of bytes to read into buffer max
1297
1298=cut
1299*/
1300
1301static
1302ssize_t
1303realseek_read(io_glue *igo, void *buf, size_t count) {
1304 io_cb *ig = (io_cb *)igo;
1305 void *p = ig->p;
1306 ssize_t rc = 0;
1307
1308 IOL_DEB( fprintf(IOL_DEBs, "realseek_read: buf = %p, count = %u\n",
1309 buf, (unsigned)count) );
1310 rc = ig->readcb(p,buf,count);
1311
1312 IOL_DEB( fprintf(IOL_DEBs, "realseek_read: rc = %d\n", (int)rc) );
1313
1314 return rc;
02d1d628
AMH
1315}
1316
1317
1318/*
1319=item realseek_write(ig, buf, count)
1320
1321Does the writing to a 'source' that can be seeked on
1322
1323 ig - io_glue object
1324 buf - buffer that contains data
1325 count - number of bytes to write
1326
1327=cut
1328*/
1329
1330static
1331ssize_t
6d5c85a2
TC
1332realseek_write(io_glue *igo, const void *buf, size_t count) {
1333 io_cb *ig = (io_cb *)igo;
1334 void *p = ig->p;
02d1d628
AMH
1335 ssize_t rc = 0;
1336 size_t bc = 0;
1337 char *cbuf = (char*)buf;
1338
6d5c85a2
TC
1339 IOL_DEB( fprintf(IOL_DEBs, "realseek_write: ig = %p, buf = %p, "
1340 "count = %u\n", ig, buf, (unsigned)count) );
02d1d628 1341
10461f9a
TC
1342 /* Is this a good idea? Would it be better to handle differently?
1343 skip handling? */
6d5c85a2 1344 while( count!=bc && (rc = ig->writecb(p,cbuf+bc,count-bc))>0 ) {
10461f9a
TC
1345 bc+=rc;
1346 }
02d1d628 1347
6d5c85a2 1348 IOL_DEB( fprintf(IOL_DEBs, "realseek_write: rc = %d, bc = %u\n", (int)rc, (unsigned)bc) );
1f6c1c10 1349 return rc < 0 ? rc : bc;
02d1d628
AMH
1350}
1351
1352
1353/*
1354=item realseek_close(ig)
1355
10461f9a
TC
1356Closes a source that can be seeked on. Not sure if this should be an
1357actual close or not. Does nothing for now. Should be fixed.
02d1d628
AMH
1358
1359 ig - data source
1360
10461f9a 1361=cut */
02d1d628
AMH
1362
1363static
2b405c9e 1364int
6d5c85a2
TC
1365realseek_close(io_glue *igo) {
1366 io_cb *ig = (io_cb *)igo;
ed60e785 1367 dIMCTXio(igo);
6d5c85a2
TC
1368
1369 IOL_DEB(fprintf(IOL_DEBs, "realseek_close(%p)\n", ig));
ed60e785 1370 im_log((aIMCTX,1, "realseek_close(ig %p)\n", ig));
6d5c85a2
TC
1371 if (ig->closecb)
1372 return ig->closecb(ig->p);
2b405c9e
TC
1373 else
1374 return 0;
02d1d628
AMH
1375}
1376
1377
12db268a
TC
1378/*
1379=item realseek_seek(ig, offset, whence)
02d1d628
AMH
1380
1381Implements seeking for a source that is seekable, the purpose of having this is to be able to
1382have an offset into a file that is different from what the underlying library thinks.
1383
1384 ig - data source
1385 offset - offset into stream
1386 whence - whence argument a la lseek
1387
1388=cut
1389*/
1390
1391static
1392off_t
6d5c85a2
TC
1393realseek_seek(io_glue *igo, off_t offset, int whence) {
1394 io_cb *ig = (io_cb *)igo;
1395 void *p = ig->p;
8d14daab 1396 off_t rc;
6d5c85a2
TC
1397 IOL_DEB( fprintf(IOL_DEBs, "realseek_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
1398 rc = ig->seekcb(p, offset, whence);
02d1d628 1399
6d5c85a2 1400 IOL_DEB( fprintf(IOL_DEBs, "realseek_seek: rc %ld\n", (long) rc) );
02d1d628
AMH
1401 return rc;
1402 /* FIXME: How about implementing this offset handling stuff? */
1403}
1404
d16420e9
TC
1405static
1406void
6d5c85a2
TC
1407realseek_destroy(io_glue *igo) {
1408 io_cb *ig = (io_cb *)igo;
d16420e9 1409
6d5c85a2
TC
1410 if (ig->destroycb)
1411 ig->destroycb(ig->p);
d16420e9
TC
1412}
1413
4dfa5522
AMH
1414/*
1415 * Callbacks for sources that are a fixed size buffer
1416 */
1417
1418/*
1419=item buffer_read(ig, buf, count)
1420
1421Does the reading from a buffer source
1422
1423 ig - io_glue object
1424 buf - buffer to return data in
1425 count - number of bytes to read into buffer max
1426
1427=cut
1428*/
1429
1430static
1431ssize_t
6d5c85a2
TC
1432buffer_read(io_glue *igo, void *buf, size_t count) {
1433 io_buffer *ig = (io_buffer *)igo;
4dfa5522 1434
6d5c85a2 1435 IOL_DEB( fprintf(IOL_DEBs, "buffer_read: ig->cpos = %ld, buf = %p, count = %u\n", (long) ig->cpos, buf, (unsigned)count) );
4dfa5522 1436
6d5c85a2 1437 if ( ig->cpos+count > ig->len ) {
ed60e785
TC
1438 dIMCTXio(igo);
1439 im_log((aIMCTX, 1,"buffer_read: short read: cpos=%ld, len=%ld, count=%ld\n", (long)ig->cpos, (long)ig->len, (long)count));
6d5c85a2 1440 count = ig->len - ig->cpos;
4dfa5522
AMH
1441 }
1442
6d5c85a2
TC
1443 memcpy(buf, ig->data+ig->cpos, count);
1444 ig->cpos += count;
1445 IOL_DEB( fprintf(IOL_DEBs, "buffer_read: count = %ld\n", (long)count) );
4dfa5522
AMH
1446 return count;
1447}
1448
1449
1450/*
1451=item buffer_write(ig, buf, count)
1452
1453Does nothing, returns -1
1454
1455 ig - io_glue object
1456 buf - buffer that contains data
1457 count - number of bytes to write
1458
1459=cut
1460*/
1461
1462static
1463ssize_t
1464buffer_write(io_glue *ig, const void *buf, size_t count) {
ed60e785
TC
1465 dIMCTXio(ig);
1466 im_log((aIMCTX, 1, "buffer_write called, this method should never be called.\n"));
4dfa5522
AMH
1467 return -1;
1468}
1469
1470
1471/*
1472=item buffer_close(ig)
1473
1474Closes a source that can be seeked on. Not sure if this should be an actual close
1475or not. Does nothing for now. Should be fixed.
1476
1477 ig - data source
1478
1479=cut
1480*/
1481
1482static
2b405c9e 1483int
4dfa5522 1484buffer_close(io_glue *ig) {
ed60e785
TC
1485 dIMCTXio(ig);
1486 im_log((aIMCTX, 1, "buffer_close(ig %p)\n", ig));
2b405c9e
TC
1487
1488 return 0;
4dfa5522
AMH
1489}
1490
1491
12db268a
TC
1492/*
1493=item buffer_seek(ig, offset, whence)
4dfa5522
AMH
1494
1495Implements seeking for a buffer source.
1496
1497 ig - data source
1498 offset - offset into stream
1499 whence - whence argument a la lseek
1500
1501=cut
1502*/
1503
1504static
1505off_t
6d5c85a2
TC
1506buffer_seek(io_glue *igo, off_t offset, int whence) {
1507 io_buffer *ig = (io_buffer *)igo;
eda1622c 1508 off_t reqpos =
6d5c85a2 1509 calc_seek_offset(ig->cpos, ig->len, offset, whence);
4dfa5522 1510
6d5c85a2 1511 if (reqpos > ig->len) {
ed60e785
TC
1512 dIMCTXio(igo);
1513 im_log((aIMCTX, 1, "seeking out of readable range\n"));
4dfa5522
AMH
1514 return (off_t)-1;
1515 }
eda1622c 1516 if (reqpos < 0) {
ed60e785 1517 dIMCTXio(igo);
eda1622c
TC
1518 i_push_error(0, "seek before beginning of file");
1519 return (off_t)-1;
1520 }
4dfa5522 1521
6d5c85a2
TC
1522 ig->cpos = reqpos;
1523 IOL_DEB( fprintf(IOL_DEBs, "buffer_seek(ig %p, offset %ld, whence %d)\n", ig, (long) offset, whence) );
4dfa5522
AMH
1524
1525 return reqpos;
1526 /* FIXME: How about implementing this offset handling stuff? */
1527}
1528
d16420e9
TC
1529static
1530void
6d5c85a2
TC
1531buffer_destroy(io_glue *igo) {
1532 io_buffer *ig = (io_buffer *)igo;
4dfa5522 1533
6d5c85a2 1534 if (ig->closecb) {
ed60e785
TC
1535 dIMCTXio(igo);
1536 im_log((aIMCTX, 1,"calling close callback %p for io_buffer\n",
6d5c85a2
TC
1537 ig->closecb));
1538 ig->closecb(ig->closedata);
d16420e9 1539 }
d16420e9 1540}
4dfa5522
AMH
1541
1542
1543
02d1d628
AMH
1544/*
1545 * Callbacks for sources that are a chain of variable sized buffers
1546 */
1547
1548
1549
1550/* Helper functions for buffer chains */
1551
1552static
1553io_blink*
faa9b3e7 1554io_blink_new(void) {
02d1d628
AMH
1555 io_blink *ib;
1556
ed60e785
TC
1557#if 0
1558 im_log((aIMCTX, 1, "io_blink_new()\n"));
1559#endif
02d1d628
AMH
1560
1561 ib = mymalloc(sizeof(io_blink));
1562
1563 ib->next = NULL;
1564 ib->prev = NULL;
1565 ib->len = BBSIZ;
1566
1567 memset(&ib->buf, 0, ib->len);
1568 return ib;
1569}
1570
1571
1572
1573/*
1574=item io_bchain_advance(ieb)
1575
1576Advances the buffer chain to the next link - extending if
1577necessary. Also adjusts the cpos and tfill counters as needed.
1578
1579 ieb - buffer chain object
1580
1581=cut
1582*/
1583
1584static
1585void
1586io_bchain_advance(io_ex_bchain *ieb) {
1587 if (ieb->cp->next == NULL) {
1588 ieb->tail = io_blink_new();
1589 ieb->tail->prev = ieb->cp;
1590 ieb->cp->next = ieb->tail;
1591
1592 ieb->tfill = 0; /* Only set this if we added a new slice */
1593 }
1594 ieb->cp = ieb->cp->next;
1595 ieb->cpos = 0;
1596}
1597
1598
c3cc977e
AMH
1599
1600/*
1601=item io_bchain_destroy()
1602
1603frees all resources used by a buffer chain.
1604
1605=cut
1606*/
1607
6d5c85a2 1608static void
c3cc977e 1609io_destroy_bufchain(io_ex_bchain *ieb) {
4dfa5522 1610 io_blink *cp;
ed60e785 1611#if 0
4dfa5522 1612 mm_log((1, "io_destroy_bufchain(ieb %p)\n", ieb));
ed60e785 1613#endif
4dfa5522
AMH
1614 cp = ieb->head;
1615
c3cc977e
AMH
1616 while(cp) {
1617 io_blink *t = cp->next;
4dfa5522 1618 myfree(cp);
c3cc977e
AMH
1619 cp = t;
1620 }
1621}
1622
1623
1624
1625
02d1d628
AMH
1626/*
1627
1628static
1629void
1630bufchain_dump(io_ex_bchain *ieb) {
1631 mm_log((1, " buf_chain_dump(ieb %p)\n"));
1632 mm_log((1, " buf_chain_dump: ieb->offset = %d\n", ieb->offset));
1633 mm_log((1, " buf_chain_dump: ieb->length = %d\n", ieb->length));
1634 mm_log((1, " buf_chain_dump: ieb->head = %p\n", ieb->head ));
1635 mm_log((1, " buf_chain_dump: ieb->tail = %p\n", ieb->tail ));
1636 mm_log((1, " buf_chain_dump: ieb->tfill = %d\n", ieb->tfill ));
1637 mm_log((1, " buf_chain_dump: ieb->cp = %p\n", ieb->cp ));
1638 mm_log((1, " buf_chain_dump: ieb->cpos = %d\n", ieb->cpos ));
1639 mm_log((1, " buf_chain_dump: ieb->gpos = %d\n", ieb->gpos ));
1640}
1641*/
1642
1643/*
1644 * TRUE if lengths are NOT equal
1645 */
1646
1647/*
1648static
1649void
1650chainlencert( io_glue *ig ) {
1651 int clen;
1652 int cfl = 0;
1653 size_t csize = 0;
1654 size_t cpos = 0;
1655 io_ex_bchain *ieb = ig->exdata;
1656 io_blink *cp = ieb->head;
1657
1658
1659 if (ieb->gpos > ieb->length) mm_log((1, "BBAR : ieb->gpos = %d, ieb->length = %d\n", ieb->gpos, ieb->length));
1660
1661 while(cp) {
1662 clen = (cp == ieb->tail) ? ieb->tfill : cp->len;
1663 if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
1664 if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
1665
1666 if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
1667 if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
1668
1669 if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
1670 if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
1671
1672 if (cp == ieb->cp) {
1673 cfl = 1;
1674 cpos += ieb->cpos;
1675 }
1676
1677 if (!cfl) cpos += clen;
1678
1679 csize += clen;
1680 cp = cp->next;
1681 }
1682 if (( csize != ieb->length )) mm_log((1, "BAR : csize = %d, ieb->length = %d\n", csize, ieb->length));
1683 if (( cpos != ieb->gpos )) mm_log((1, "BAR : cpos = %d, ieb->gpos = %d\n", cpos, ieb->gpos ));
1684}
1685
1686
1687static
1688void
1689chaincert( io_glue *ig) {
1690 size_t csize = 0;
1691 io_ex_bchain *ieb = ig->exdata;
1692 io_blink *cp = ieb->head;
1693
1694 mm_log((1, "Chain verification.\n"));
1695
1696 mm_log((1, " buf_chain_dump: ieb->offset = %d\n", ieb->offset));
1697 mm_log((1, " buf_chain_dump: ieb->length = %d\n", ieb->length));
1698 mm_log((1, " buf_chain_dump: ieb->head = %p\n", ieb->head ));
1699 mm_log((1, " buf_chain_dump: ieb->tail = %p\n", ieb->tail ));
1700 mm_log((1, " buf_chain_dump: ieb->tfill = %d\n", ieb->tfill ));
1701 mm_log((1, " buf_chain_dump: ieb->cp = %p\n", ieb->cp ));
1702 mm_log((1, " buf_chain_dump: ieb->cpos = %d\n", ieb->cpos ));
1703 mm_log((1, " buf_chain_dump: ieb->gpos = %d\n", ieb->gpos ));
1704
1705 while(cp) {
1706 int clen = cp == ieb->tail ? ieb->tfill : cp->len;
1707 mm_log((1, "link: %p <- %p -> %p\n", cp->prev, cp, cp->next));
1708 if (ieb->head == cp && cp->prev) mm_log((1, "Head of chain has a non null prev\n"));
1709 if (ieb->tail == cp && cp->next) mm_log((1, "Tail of chain has a non null next\n"));
1710
1711 if (ieb->head != cp && !cp->prev) mm_log((1, "Middle of chain has a null prev\n"));
1712 if (ieb->tail != cp && !cp->next) mm_log((1, "Middle of chain has a null next\n"));
1713
1714 if (cp->prev && cp->prev->next != cp) mm_log((1, "%p = cp->prev->next != cp\n", cp->prev->next));
1715 if (cp->next && cp->next->prev != cp) mm_log((1, "%p cp->next->prev != cp\n", cp->next->prev));
1716
1717 csize += clen;
1718 cp = cp->next;
1719 }
1720
1721 mm_log((1, "csize = %d %s ieb->length = %d\n", csize, csize == ieb->length ? "==" : "!=", ieb->length));
1722}
1723*/
1724
02d1d628
AMH
1725/*
1726=item bufchain_read(ig, buf, count)
1727
1728Does the reading from a source that can be seeked on
1729
1730 ig - io_glue object
1731 buf - buffer to return data in
1732 count - number of bytes to read into buffer max
1733
1734=cut
1735*/
1736
1737static
1738ssize_t
1739bufchain_read(io_glue *ig, void *buf, size_t count) {
1740 io_ex_bchain *ieb = ig->exdata;
1741 size_t scount = count;
1742 char *cbuf = buf;
1743 size_t sk;
ed60e785 1744 dIMCTXio(ig);
02d1d628 1745
ed60e785 1746 im_log((aIMCTX, 1, "bufchain_read(ig %p, buf %p, count %ld)\n", ig, buf, (long)count));
02d1d628
AMH
1747
1748 while( scount ) {
1749 int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1750 if (clen == ieb->cpos) {
1751 if (ieb->cp == ieb->tail) break; /* EOF */
1752 ieb->cp = ieb->cp->next;
1753 ieb->cpos = 0;
1754 clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1755 }
1756
1757 sk = clen - ieb->cpos;
1758 sk = sk > scount ? scount : sk;
1759
1760 memcpy(&cbuf[count-scount], &ieb->cp->buf[ieb->cpos], sk);
1761 scount -= sk;
1762 ieb->cpos += sk;
1763 ieb->gpos += sk;
1764 }
1765
ed60e785 1766 im_log((aIMCTX, 1, "bufchain_read: returning %ld\n", (long)(count-scount)));
02d1d628
AMH
1767 return count-scount;
1768}
1769
1770
1771
1772
1773
1774/*
1775=item bufchain_write(ig, buf, count)
1776
1777Does the writing to a 'source' that can be seeked on
1778
1779 ig - io_glue object
1780 buf - buffer that contains data
1781 count - number of bytes to write
1782
1783=cut
1784*/
1785
1786static
1787ssize_t
1788bufchain_write(io_glue *ig, const void *buf, size_t count) {
1789 char *cbuf = (char *)buf;
1790 io_ex_bchain *ieb = ig->exdata;
1791 size_t ocount = count;
1792 size_t sk;
ed60e785 1793 dIMCTXio(ig);
02d1d628 1794
ed60e785 1795 im_log((aIMCTX, 1, "bufchain_write: ig = %p, buf = %p, count = %ld\n", ig, buf, (long)count));
02d1d628 1796
6d5c85a2 1797 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
1798
1799 while(count) {
ed60e785 1800 im_log((aIMCTX, 2, "bufchain_write: - looping - count = %ld\n", (long)count));
02d1d628 1801 if (ieb->cp->len == ieb->cpos) {
ed60e785 1802 im_log((aIMCTX, 1, "bufchain_write: cp->len == ieb->cpos = %ld - advancing chain\n", (long) ieb->cpos));
02d1d628
AMH
1803 io_bchain_advance(ieb);
1804 }
1805
1806 sk = ieb->cp->len - ieb->cpos;
1807 sk = sk > count ? count : sk;
1808 memcpy(&ieb->cp->buf[ieb->cpos], &cbuf[ocount-count], sk);
1809
1810 if (ieb->cp == ieb->tail) {
1811 int extend = ieb->cpos + sk - ieb->tfill;
ed60e785 1812 im_log((aIMCTX, 2, "bufchain_write: extending tail by %d\n", extend));
02d1d628
AMH
1813 if (extend > 0) {
1814 ieb->length += extend;
1815 ieb->tfill += extend;
1816 }
1817 }
1818
1819 ieb->cpos += sk;
1820 ieb->gpos += sk;
1821 count -= sk;
1822 }
1823 return ocount;
1824}
1825
1826/*
1827=item bufchain_close(ig)
1828
1829Closes a source that can be seeked on. Not sure if this should be an actual close
1830or not. Does nothing for now. Should be fixed.
1831
1832 ig - data source
1833
1834=cut
1835*/
1836
1837static
2b405c9e 1838int
02d1d628 1839bufchain_close(io_glue *ig) {
ed60e785
TC
1840 dIMCTXio(ig);
1841 im_log((aIMCTX, 1, "bufchain_close(ig %p)\n",ig));
6d5c85a2 1842 IOL_DEB( fprintf(IOL_DEBs, "bufchain_close(ig %p)\n", ig) );
2b405c9e
TC
1843
1844 return 0;
02d1d628
AMH
1845}
1846
1847
12db268a
TC
1848/*
1849=item bufchain_seek(ig, offset, whence)
02d1d628
AMH
1850
1851Implements seeking for a source that is seekable, the purpose of having this is to be able to
1852have an offset into a file that is different from what the underlying library thinks.
1853
1854 ig - data source
1855 offset - offset into stream
1856 whence - whence argument a la lseek
1857
1858=cut
1859*/
1860
1861static
1862off_t
1863bufchain_seek(io_glue *ig, off_t offset, int whence) {
1864 io_ex_bchain *ieb = ig->exdata;
02d1d628
AMH
1865 int wrlen;
1866
eda1622c 1867 off_t scount = calc_seek_offset(ieb->gpos, ieb->length, offset, whence);
02d1d628 1868 off_t sk;
ed60e785 1869 dIMCTXio(ig);
02d1d628 1870
ed60e785 1871 im_log((aIMCTX, 1, "bufchain_seek(ig %p, offset %ld, whence %d)\n", ig, (long)offset, whence));
02d1d628 1872
eda1622c
TC
1873 if (scount < 0) {
1874 i_push_error(0, "invalid whence supplied or seek before start of file");
1875 return (off_t)-1;
1876 }
02d1d628 1877
eda1622c
TC
1878 ieb->cp = ieb->head;
1879 ieb->cpos = 0;
1880 ieb->gpos = 0;
1881
1882 while( scount ) {
1883 int clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
1884 if (clen == ieb->cpos) {
1885 if (ieb->cp == ieb->tail) break; /* EOF */
1886 ieb->cp = ieb->cp->next;
1887 ieb->cpos = 0;
1888 clen = (ieb->cp == ieb->tail) ? ieb->tfill : ieb->cp->len;
02d1d628
AMH
1889 }
1890
eda1622c
TC
1891 sk = clen - ieb->cpos;
1892 sk = sk > scount ? scount : sk;
02d1d628 1893
eda1622c
TC
1894 scount -= sk;
1895 ieb->cpos += sk;
1896 ieb->gpos += sk;
1897 }
1898
1899 wrlen = scount;
02d1d628 1900
eda1622c
TC
1901 if (wrlen > 0) {
1902 /*
1903 * extending file - get ieb into consistent state and then
1904 * call write which will get it to the correct position
1905 */
1906 char TB[BBSIZ];
1907 memset(TB, 0, BBSIZ);
1908 ieb->gpos = ieb->length;
02d1d628
AMH
1909 ieb->cpos = ieb->tfill;
1910
eda1622c
TC
1911 while(wrlen > 0) {
1912 ssize_t rc, wl = i_min(wrlen, BBSIZ);
ed60e785 1913 im_log((aIMCTX, 1, "bufchain_seek: wrlen = %d, wl = %ld\n", wrlen, (long)wl));
eda1622c 1914 rc = bufchain_write( ig, TB, wl );
2038f6ce 1915 if (rc != wl) im_fatal(aIMCTX, 0, "bufchain_seek: Unable to extend file\n");
eda1622c 1916 wrlen -= rc;
02d1d628 1917 }
02d1d628
AMH
1918 }
1919
ed60e785 1920 im_log((aIMCTX, 2, "bufchain_seek: returning ieb->gpos = %ld\n", (long)ieb->gpos));
02d1d628
AMH
1921 return ieb->gpos;
1922}
1923
d16420e9
TC
1924static
1925void
1926bufchain_destroy(io_glue *ig) {
1927 io_ex_bchain *ieb = ig->exdata;
02d1d628 1928
d16420e9 1929 io_destroy_bufchain(ieb);
02d1d628 1930
d16420e9
TC
1931 myfree(ieb);
1932}
02d1d628 1933
10461f9a
TC
1934/*
1935=item fd_read(ig, buf, count)
1936
6d5c85a2
TC
1937Read callback for file descriptor IO objects.
1938
10461f9a
TC
1939=cut
1940*/
6d5c85a2
TC
1941static ssize_t fd_read(io_glue *igo, void *buf, size_t count) {
1942 io_fdseek *ig = (io_fdseek *)igo;
5f8f8e17 1943 ssize_t result;
10461f9a 1944#ifdef _MSC_VER
6d5c85a2 1945 result = _read(ig->fd, buf, count);
10461f9a 1946#else
6d5c85a2 1947 result = read(ig->fd, buf, count);
10461f9a 1948#endif
5f8f8e17 1949
6d5c85a2
TC
1950 IOL_DEB(fprintf(IOL_DEBs, "fd_read(%p, %p, %u) => %d\n", ig, buf,
1951 (unsigned)count, (int)result));
1952
5f8f8e17
TC
1953 /* 0 is valid - means EOF */
1954 if (result < 0) {
ed60e785
TC
1955 dIMCTXio(igo);
1956 im_push_errorf(aIMCTX, 0, "read() failure: %s (%d)", my_strerror(errno), errno);
5f8f8e17
TC
1957 }
1958
1959 return result;
10461f9a
TC
1960}
1961
6d5c85a2
TC
1962static ssize_t fd_write(io_glue *igo, const void *buf, size_t count) {
1963 io_fdseek *ig = (io_fdseek *)igo;
2691d220 1964 ssize_t result;
10461f9a 1965#ifdef _MSC_VER
6d5c85a2 1966 result = _write(ig->fd, buf, count);
10461f9a 1967#else
6d5c85a2 1968 result = write(ig->fd, buf, count);
10461f9a 1969#endif
2691d220 1970
6d5c85a2
TC
1971 IOL_DEB(fprintf(IOL_DEBs, "fd_write(%p, %p, %u) => %d\n", ig, buf,
1972 (unsigned)count, (int)result));
1973
2691d220 1974 if (result <= 0) {
ed60e785
TC
1975 dIMCTXio(igo);
1976 im_push_errorf(aIMCTX, errno, "write() failure: %s (%d)", my_strerror(errno), errno);
2691d220
TC
1977 }
1978
1979 return result;
10461f9a
TC
1980}
1981
6d5c85a2
TC
1982static off_t fd_seek(io_glue *igo, off_t offset, int whence) {
1983 io_fdseek *ig = (io_fdseek *)igo;
2691d220 1984 off_t result;
10461f9a 1985#ifdef _MSC_VER
6d5c85a2 1986 result = _lseek(ig->fd, offset, whence);
10461f9a 1987#else
6d5c85a2 1988 result = lseek(ig->fd, offset, whence);
10461f9a 1989#endif
2691d220
TC
1990
1991 if (result == (off_t)-1) {
ed60e785
TC
1992 dIMCTXio(igo);
1993 im_push_errorf(aIMCTX, errno, "lseek() failure: %s (%d)", my_strerror(errno), errno);
2691d220
TC
1994 }
1995
1996 return result;
10461f9a
TC
1997}
1998
2b405c9e 1999static int fd_close(io_glue *ig) {
10461f9a 2000 /* no, we don't close it */
2b405c9e 2001 return 0;
10461f9a
TC
2002}
2003
2004static ssize_t fd_size(io_glue *ig) {
ed60e785
TC
2005 dIMCTXio(ig);
2006 im_log((aIMCTX, 1, "fd_size(ig %p) unimplemented\n", ig));
10461f9a
TC
2007
2008 return -1;
2009}
02d1d628 2010
b8c2033e
AMH
2011
2012/*
2013=back
2014
2015=head1 AUTHOR
2016
2017Arnar M. Hrafnkelsson <addi@umich.edu>
2018
2019=head1 SEE ALSO
2020
2021Imager(3)
2022
2023=cut
2024*/