Re: Change 33556: [PATCH] borg parent.pm
[perl.git] / perlio.c
1 /*
2  * perlio.c
3  * Copyright (c) 1996-2006, Nick Ing-Simmons
4  * Copyright (c) 2006, 2007, Larry Wall and others
5  *
6  * You may distribute under the terms of either the GNU General Public License
7  * or the Artistic License, as specified in the README file.
8  */
9
10 /*
11  * Hour after hour for nearly three weary days he had jogged up and down,
12  * over passes, and through long dales, and across many streams.
13  */
14
15 /* This file contains the functions needed to implement PerlIO, which
16  * is Perl's private replacement for the C stdio library. This is used
17  * by default unless you compile with -Uuseperlio or run with
18  * PERLIO=:stdio (but don't do this unless you know what you're doing)
19  */
20
21 /*
22  * If we have ActivePerl-like PERL_IMPLICIT_SYS then we need a dTHX to get
23  * at the dispatch tables, even when we do not need it for other reasons.
24  * Invent a dSYS macro to abstract this out
25  */
26 #ifdef PERL_IMPLICIT_SYS
27 #define dSYS dTHX
28 #else
29 #define dSYS dNOOP
30 #endif
31
32 #define VOIDUSED 1
33 #ifdef PERL_MICRO
34 #   include "uconfig.h"
35 #else
36 #   ifndef USE_CROSS_COMPILE
37 #       include "config.h"
38 #   else
39 #       include "xconfig.h"
40 #   endif
41 #endif
42
43 #define PERLIO_NOT_STDIO 0
44 #if !defined(PERLIO_IS_STDIO) && !defined(USE_SFIO)
45 /*
46  * #define PerlIO FILE
47  */
48 #endif
49 /*
50  * This file provides those parts of PerlIO abstraction
51  * which are not #defined in perlio.h.
52  * Which these are depends on various Configure #ifdef's
53  */
54
55 #include "EXTERN.h"
56 #define PERL_IN_PERLIO_C
57 #include "perl.h"
58
59 #ifdef PERL_IMPLICIT_CONTEXT
60 #undef dSYS
61 #define dSYS dTHX
62 #endif
63
64 #include "XSUB.h"
65
66 #ifdef __Lynx__
67 /* Missing proto on LynxOS */
68 int mkstemp(char*);
69 #endif
70
71 /* Call the callback or PerlIOBase, and return failure. */
72 #define Perl_PerlIO_or_Base(f, callback, base, failure, args)   \
73         if (PerlIOValid(f)) {                                   \
74                 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
75                 if (tab && tab->callback)                       \
76                         return (*tab->callback) args;           \
77                 else                                            \
78                         return PerlIOBase_ ## base args;        \
79         }                                                       \
80         else                                                    \
81                 SETERRNO(EBADF, SS_IVCHAN);                     \
82         return failure
83
84 /* Call the callback or fail, and return failure. */
85 #define Perl_PerlIO_or_fail(f, callback, failure, args)         \
86         if (PerlIOValid(f)) {                                   \
87                 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
88                 if (tab && tab->callback)                       \
89                         return (*tab->callback) args;           \
90                 SETERRNO(EINVAL, LIB_INVARG);                   \
91         }                                                       \
92         else                                                    \
93                 SETERRNO(EBADF, SS_IVCHAN);                     \
94         return failure
95
96 /* Call the callback or PerlIOBase, and be void. */
97 #define Perl_PerlIO_or_Base_void(f, callback, base, args)       \
98         if (PerlIOValid(f)) {                                   \
99                 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
100                 if (tab && tab->callback)                       \
101                         (*tab->callback) args;                  \
102                 else                                            \
103                         PerlIOBase_ ## base args;               \
104         }                                                       \
105         else                                                    \
106                 SETERRNO(EBADF, SS_IVCHAN)
107
108 /* Call the callback or fail, and be void. */
109 #define Perl_PerlIO_or_fail_void(f, callback, args)             \
110         if (PerlIOValid(f)) {                                   \
111                 const PerlIO_funcs * const tab = PerlIOBase(f)->tab;\
112                 if (tab && tab->callback)                       \
113                         (*tab->callback) args;                  \
114                 else                                            \
115                         SETERRNO(EINVAL, LIB_INVARG);           \
116         }                                                       \
117         else                                                    \
118                 SETERRNO(EBADF, SS_IVCHAN)
119
120 #if defined(__osf__) && _XOPEN_SOURCE < 500
121 extern int   fseeko(FILE *, off_t, int);
122 extern off_t ftello(FILE *);
123 #endif
124
125 #ifndef USE_SFIO
126
127 EXTERN_C int perlsio_binmode(FILE *fp, int iotype, int mode);
128
129 int
130 perlsio_binmode(FILE *fp, int iotype, int mode)
131 {
132     /*
133      * This used to be contents of do_binmode in doio.c
134      */
135 #ifdef DOSISH
136 #  if defined(atarist) || defined(__MINT__)
137     PERL_UNUSED_ARG(iotype);
138     if (!fflush(fp)) {
139         if (mode & O_BINARY)
140             ((FILE *) fp)->_flag |= _IOBIN;
141         else
142             ((FILE *) fp)->_flag &= ~_IOBIN;
143         return 1;
144     }
145     return 0;
146 #  else
147     dTHX;
148     PERL_UNUSED_ARG(iotype);
149 #ifdef NETWARE
150     if (PerlLIO_setmode(fp, mode) != -1) {
151 #else
152     if (PerlLIO_setmode(fileno(fp), mode) != -1) {
153 #endif
154 #    if defined(WIN32) && defined(__BORLANDC__)
155         /*
156          * The translation mode of the stream is maintained independent 
157 of
158          * the translation mode of the fd in the Borland RTL (heavy
159          * digging through their runtime sources reveal).  User has to 
160 set
161          * the mode explicitly for the stream (though they don't 
162 document
163          * this anywhere). GSAR 97-5-24
164          */
165         fseek(fp, 0L, 0);
166         if (mode & O_BINARY)
167             fp->flags |= _F_BIN;
168         else
169             fp->flags &= ~_F_BIN;
170 #    endif
171         return 1;
172     }
173     else
174         return 0;
175 #  endif
176 #else
177 #  if defined(USEMYBINMODE)
178     dTHX;
179 #    if defined(__CYGWIN__)
180     PERL_UNUSED_ARG(iotype);
181 #    endif
182     if (my_binmode(fp, iotype, mode) != FALSE)
183         return 1;
184     else
185         return 0;
186 #  else
187     PERL_UNUSED_ARG(fp);
188     PERL_UNUSED_ARG(iotype);
189     PERL_UNUSED_ARG(mode);
190     return 1;
191 #  endif
192 #endif
193 }
194 #endif /* sfio */
195
196 #ifndef O_ACCMODE
197 #define O_ACCMODE 3             /* Assume traditional implementation */
198 #endif
199
200 int
201 PerlIO_intmode2str(int rawmode, char *mode, int *writing)
202 {
203     const int result = rawmode & O_ACCMODE;
204     int ix = 0;
205     int ptype;
206     switch (result) {
207     case O_RDONLY:
208         ptype = IoTYPE_RDONLY;
209         break;
210     case O_WRONLY:
211         ptype = IoTYPE_WRONLY;
212         break;
213     case O_RDWR:
214     default:
215         ptype = IoTYPE_RDWR;
216         break;
217     }
218     if (writing)
219         *writing = (result != O_RDONLY);
220
221     if (result == O_RDONLY) {
222         mode[ix++] = 'r';
223     }
224 #ifdef O_APPEND
225     else if (rawmode & O_APPEND) {
226         mode[ix++] = 'a';
227         if (result != O_WRONLY)
228             mode[ix++] = '+';
229     }
230 #endif
231     else {
232         if (result == O_WRONLY)
233             mode[ix++] = 'w';
234         else {
235             mode[ix++] = 'r';
236             mode[ix++] = '+';
237         }
238     }
239     if (rawmode & O_BINARY)
240         mode[ix++] = 'b';
241     mode[ix] = '\0';
242     return ptype;
243 }
244
245 #ifndef PERLIO_LAYERS
246 int
247 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
248 {
249     if (!names || !*names
250         || strEQ(names, ":crlf")
251         || strEQ(names, ":raw")
252         || strEQ(names, ":bytes")
253        ) {
254         return 0;
255     }
256     Perl_croak(aTHX_ "Cannot apply \"%s\" in non-PerlIO perl", names);
257     /*
258      * NOTREACHED
259      */
260     return -1;
261 }
262
263 void
264 PerlIO_destruct(pTHX)
265 {
266 }
267
268 int
269 PerlIO_binmode(pTHX_ PerlIO *fp, int iotype, int mode, const char *names)
270 {
271 #ifdef USE_SFIO
272     PERL_UNUSED_ARG(iotype);
273     PERL_UNUSED_ARG(mode);
274     PERL_UNUSED_ARG(names);
275     return 1;
276 #else
277     return perlsio_binmode(fp, iotype, mode);
278 #endif
279 }
280
281 PerlIO *
282 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
283 {
284 #if defined(PERL_MICRO) || defined(__SYMBIAN32__)
285     return NULL;
286 #else
287 #ifdef PERL_IMPLICIT_SYS
288     return PerlSIO_fdupopen(f);
289 #else
290 #ifdef WIN32
291     return win32_fdupopen(f);
292 #else
293     if (f) {
294         const int fd = PerlLIO_dup(PerlIO_fileno(f));
295         if (fd >= 0) {
296             char mode[8];
297 #ifdef DJGPP
298             const int omode = djgpp_get_stream_mode(f);
299 #else
300             const int omode = fcntl(fd, F_GETFL);
301 #endif
302             PerlIO_intmode2str(omode,mode,NULL);
303             /* the r+ is a hack */
304             return PerlIO_fdopen(fd, mode);
305         }
306         return NULL;
307     }
308     else {
309         SETERRNO(EBADF, SS_IVCHAN);
310     }
311 #endif
312     return NULL;
313 #endif
314 #endif
315 }
316
317
318 /*
319  * De-mux PerlIO_openn() into fdopen, freopen and fopen type entries
320  */
321
322 PerlIO *
323 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
324              int imode, int perm, PerlIO *old, int narg, SV **args)
325 {
326     if (narg) {
327         if (narg > 1) {
328             Perl_croak(aTHX_ "More than one argument to open");
329         }
330         if (*args == &PL_sv_undef)
331             return PerlIO_tmpfile();
332         else {
333             const char *name = SvPV_nolen_const(*args);
334             if (*mode == IoTYPE_NUMERIC) {
335                 fd = PerlLIO_open3(name, imode, perm);
336                 if (fd >= 0)
337                     return PerlIO_fdopen(fd, mode + 1);
338             }
339             else if (old) {
340                 return PerlIO_reopen(name, mode, old);
341             }
342             else {
343                 return PerlIO_open(name, mode);
344             }
345         }
346     }
347     else {
348         return PerlIO_fdopen(fd, (char *) mode);
349     }
350     return NULL;
351 }
352
353 XS(XS_PerlIO__Layer__find)
354 {
355     dXSARGS;
356     if (items < 2)
357         Perl_croak(aTHX_ "Usage class->find(name[,load])");
358     else {
359         const char * const name = SvPV_nolen_const(ST(1));
360         ST(0) = (strEQ(name, "crlf")
361                  || strEQ(name, "raw")) ? &PL_sv_yes : &PL_sv_undef;
362         XSRETURN(1);
363     }
364 }
365
366
367 void
368 Perl_boot_core_PerlIO(pTHX)
369 {
370     newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
371 }
372
373 #endif
374
375
376 #ifdef PERLIO_IS_STDIO
377
378 void
379 PerlIO_init(pTHX)
380 {
381     PERL_UNUSED_CONTEXT;
382     /*
383      * Does nothing (yet) except force this file to be included in perl
384      * binary. That allows this file to force inclusion of other functions
385      * that may be required by loadable extensions e.g. for
386      * FileHandle::tmpfile
387      */
388 }
389
390 #undef PerlIO_tmpfile
391 PerlIO *
392 PerlIO_tmpfile(void)
393 {
394     return tmpfile();
395 }
396
397 #else                           /* PERLIO_IS_STDIO */
398
399 #ifdef USE_SFIO
400
401 #undef HAS_FSETPOS
402 #undef HAS_FGETPOS
403
404 /*
405  * This section is just to make sure these functions get pulled in from
406  * libsfio.a
407  */
408
409 #undef PerlIO_tmpfile
410 PerlIO *
411 PerlIO_tmpfile(void)
412 {
413     return sftmp(0);
414 }
415
416 void
417 PerlIO_init(pTHX)
418 {
419     PERL_UNUSED_CONTEXT;
420     /*
421      * Force this file to be included in perl binary. Which allows this
422      * file to force inclusion of other functions that may be required by
423      * loadable extensions e.g. for FileHandle::tmpfile
424      */
425
426     /*
427      * Hack sfio does its own 'autoflush' on stdout in common cases. Flush
428      * results in a lot of lseek()s to regular files and lot of small
429      * writes to pipes.
430      */
431     sfset(sfstdout, SF_SHARE, 0);
432 }
433
434 /* This is not the reverse of PerlIO_exportFILE(), PerlIO_releaseFILE() is. */
435 PerlIO *
436 PerlIO_importFILE(FILE *stdio, const char *mode)
437 {
438     const int fd = fileno(stdio);
439     if (!mode || !*mode) {
440         mode = "r+";
441     }
442     return PerlIO_fdopen(fd, mode);
443 }
444
445 FILE *
446 PerlIO_findFILE(PerlIO *pio)
447 {
448     const int fd = PerlIO_fileno(pio);
449     FILE * const f = fdopen(fd, "r+");
450     PerlIO_flush(pio);
451     if (!f && errno == EINVAL)
452         f = fdopen(fd, "w");
453     if (!f && errno == EINVAL)
454         f = fdopen(fd, "r");
455     return f;
456 }
457
458
459 #else                           /* USE_SFIO */
460 /*======================================================================================*/
461 /*
462  * Implement all the PerlIO interface ourselves.
463  */
464
465 #include "perliol.h"
466
467 /*
468  * We _MUST_ have <unistd.h> if we are using lseek() and may have large
469  * files
470  */
471 #ifdef I_UNISTD
472 #include <unistd.h>
473 #endif
474 #ifdef HAS_MMAP
475 #include <sys/mman.h>
476 #endif
477
478 void
479 PerlIO_debug(const char *fmt, ...)
480 {
481     va_list ap;
482     dSYS;
483     va_start(ap, fmt);
484     if (!PL_perlio_debug_fd) {
485         if (!PL_tainting && PL_uid == PL_euid && PL_gid == PL_egid) {
486             const char * const s = PerlEnv_getenv("PERLIO_DEBUG");
487             if (s && *s)
488                 PL_perlio_debug_fd
489                     = PerlLIO_open3(s, O_WRONLY | O_CREAT | O_APPEND, 0666);
490             else
491                 PL_perlio_debug_fd = -1;
492         } else {
493             /* tainting or set*id, so ignore the environment, and ensure we
494                skip these tests next time through.  */
495             PL_perlio_debug_fd = -1;
496         }
497     }
498     if (PL_perlio_debug_fd > 0) {
499         dTHX;
500 #ifdef USE_ITHREADS
501         const char * const s = CopFILE(PL_curcop);
502         /* Use fixed buffer as sv_catpvf etc. needs SVs */
503         char buffer[1024];
504         const STRLEN len1 = my_snprintf(buffer, sizeof(buffer), "%.40s:%" IVdf " ", s ? s : "(none)", (IV) CopLINE(PL_curcop));
505         const STRLEN len2 = my_vsnprintf(buffer + len1, sizeof(buffer) - len1, fmt, ap);
506         PerlLIO_write(PL_perlio_debug_fd, buffer, len1 + len2);
507 #else
508         const char *s = CopFILE(PL_curcop);
509         STRLEN len;
510         SV * const sv = Perl_newSVpvf(aTHX_ "%s:%" IVdf " ", s ? s : "(none)",
511                                       (IV) CopLINE(PL_curcop));
512         Perl_sv_vcatpvf(aTHX_ sv, fmt, &ap);
513
514         s = SvPV_const(sv, len);
515         PerlLIO_write(PL_perlio_debug_fd, s, len);
516         SvREFCNT_dec(sv);
517 #endif
518     }
519     va_end(ap);
520 }
521
522 /*--------------------------------------------------------------------------------------*/
523
524 /*
525  * Inner level routines
526  */
527
528 /*
529  * Table of pointers to the PerlIO structs (malloc'ed)
530  */
531 #define PERLIO_TABLE_SIZE 64
532
533 PerlIO *
534 PerlIO_allocate(pTHX)
535 {
536     dVAR;
537     /*
538      * Find a free slot in the table, allocating new table as necessary
539      */
540     PerlIO **last;
541     PerlIO *f;
542     last = &PL_perlio;
543     while ((f = *last)) {
544         int i;
545         last = (PerlIO **) (f);
546         for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
547             if (!*++f) {
548                 return f;
549             }
550         }
551     }
552     Newxz(f,PERLIO_TABLE_SIZE,PerlIO);
553     if (!f) {
554         return NULL;
555     }
556     *last = f;
557     return f + 1;
558 }
559
560 #undef PerlIO_fdupopen
561 PerlIO *
562 PerlIO_fdupopen(pTHX_ PerlIO *f, CLONE_PARAMS *param, int flags)
563 {
564     if (PerlIOValid(f)) {
565         const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
566         PerlIO_debug("fdupopen f=%p param=%p\n",(void*)f,(void*)param);
567         if (tab && tab->Dup)
568              return (*tab->Dup)(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
569         else {
570              return PerlIOBase_dup(aTHX_ PerlIO_allocate(aTHX), f, param, flags);
571         }
572     }
573     else
574          SETERRNO(EBADF, SS_IVCHAN);
575
576     return NULL;
577 }
578
579 void
580 PerlIO_cleantable(pTHX_ PerlIO **tablep)
581 {
582     PerlIO * const table = *tablep;
583     if (table) {
584         int i;
585         PerlIO_cleantable(aTHX_(PerlIO **) & (table[0]));
586         for (i = PERLIO_TABLE_SIZE - 1; i > 0; i--) {
587             PerlIO * const f = table + i;
588             if (*f) {
589                 PerlIO_close(f);
590             }
591         }
592         Safefree(table);
593         *tablep = NULL;
594     }
595 }
596
597
598 PerlIO_list_t *
599 PerlIO_list_alloc(pTHX)
600 {
601     PerlIO_list_t *list;
602     PERL_UNUSED_CONTEXT;
603     Newxz(list, 1, PerlIO_list_t);
604     list->refcnt = 1;
605     return list;
606 }
607
608 void
609 PerlIO_list_free(pTHX_ PerlIO_list_t *list)
610 {
611     if (list) {
612         if (--list->refcnt == 0) {
613             if (list->array) {
614                 IV i;
615                 for (i = 0; i < list->cur; i++) {
616                     if (list->array[i].arg)
617                         SvREFCNT_dec(list->array[i].arg);
618                 }
619                 Safefree(list->array);
620             }
621             Safefree(list);
622         }
623     }
624 }
625
626 void
627 PerlIO_list_push(pTHX_ PerlIO_list_t *list, PerlIO_funcs *funcs, SV *arg)
628 {
629     dVAR;
630     PerlIO_pair_t *p;
631     PERL_UNUSED_CONTEXT;
632
633     if (list->cur >= list->len) {
634         list->len += 8;
635         if (list->array)
636             Renew(list->array, list->len, PerlIO_pair_t);
637         else
638             Newx(list->array, list->len, PerlIO_pair_t);
639     }
640     p = &(list->array[list->cur++]);
641     p->funcs = funcs;
642     if ((p->arg = arg)) {
643         SvREFCNT_inc_simple_void_NN(arg);
644     }
645 }
646
647 PerlIO_list_t *
648 PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param)
649 {
650     PerlIO_list_t *list = NULL;
651     if (proto) {
652         int i;
653         list = PerlIO_list_alloc(aTHX);
654         for (i=0; i < proto->cur; i++) {
655             SV *arg = proto->array[i].arg;
656 #ifdef sv_dup
657             if (arg && param)
658                 arg = sv_dup(arg, param);
659 #else
660             PERL_UNUSED_ARG(param);
661 #endif
662             PerlIO_list_push(aTHX_ list, proto->array[i].funcs, arg);
663         }
664     }
665     return list;
666 }
667
668 void
669 PerlIO_clone(pTHX_ PerlInterpreter *proto, CLONE_PARAMS *param)
670 {
671 #ifdef USE_ITHREADS
672     PerlIO **table = &proto->Iperlio;
673     PerlIO *f;
674     PL_perlio = NULL;
675     PL_known_layers = PerlIO_clone_list(aTHX_ proto->Iknown_layers, param);
676     PL_def_layerlist = PerlIO_clone_list(aTHX_ proto->Idef_layerlist, param);
677     PerlIO_allocate(aTHX); /* root slot is never used */
678     PerlIO_debug("Clone %p from %p\n",(void*)aTHX,(void*)proto);
679     while ((f = *table)) {
680             int i;
681             table = (PerlIO **) (f++);
682             for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
683                 if (*f) {
684                     (void) fp_dup(f, 0, param);
685                 }
686                 f++;
687             }
688         }
689 #else
690     PERL_UNUSED_CONTEXT;
691     PERL_UNUSED_ARG(proto);
692     PERL_UNUSED_ARG(param);
693 #endif
694 }
695
696 void
697 PerlIO_destruct(pTHX)
698 {
699     dVAR;
700     PerlIO **table = &PL_perlio;
701     PerlIO *f;
702 #ifdef USE_ITHREADS
703     PerlIO_debug("Destruct %p\n",(void*)aTHX);
704 #endif
705     while ((f = *table)) {
706         int i;
707         table = (PerlIO **) (f++);
708         for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
709             PerlIO *x = f;
710             const PerlIOl *l;
711             while ((l = *x)) {
712                 if (l->tab->kind & PERLIO_K_DESTRUCT) {
713                     PerlIO_debug("Destruct popping %s\n", l->tab->name);
714                     PerlIO_flush(x);
715                     PerlIO_pop(aTHX_ x);
716                 }
717                 else {
718                     x = PerlIONext(x);
719                 }
720             }
721             f++;
722         }
723     }
724 }
725
726 void
727 PerlIO_pop(pTHX_ PerlIO *f)
728 {
729     const PerlIOl *l = *f;
730     if (l) {
731         PerlIO_debug("PerlIO_pop f=%p %s\n", (void*)f, l->tab->name);
732         if (l->tab->Popped) {
733             /*
734              * If popped returns non-zero do not free its layer structure
735              * it has either done so itself, or it is shared and still in
736              * use
737              */
738             if ((*l->tab->Popped) (aTHX_ f) != 0)
739                 return;
740         }
741         *f = l->next;
742         Safefree(l);
743     }
744 }
745
746 /* Return as an array the stack of layers on a filehandle.  Note that
747  * the stack is returned top-first in the array, and there are three
748  * times as many array elements as there are layers in the stack: the
749  * first element of a layer triplet is the name, the second one is the
750  * arguments, and the third one is the flags. */
751
752 AV *
753 PerlIO_get_layers(pTHX_ PerlIO *f)
754 {
755     dVAR;
756     AV * const av = newAV();
757
758     if (PerlIOValid(f)) {
759         PerlIOl *l = PerlIOBase(f);
760
761         while (l) {
762             /* There is some collusion in the implementation of
763                XS_PerlIO_get_layers - it knows that name and flags are
764                generated as fresh SVs here, and takes advantage of that to
765                "copy" them by taking a reference. If it changes here, it needs
766                to change there too.  */
767             SV * const name = l->tab && l->tab->name ?
768             newSVpv(l->tab->name, 0) : &PL_sv_undef;
769             SV * const arg = l->tab && l->tab->Getarg ?
770             (*l->tab->Getarg)(aTHX_ &l, 0, 0) : &PL_sv_undef;
771             av_push(av, name);
772             av_push(av, arg);
773             av_push(av, newSViv((IV)l->flags));
774             l = l->next;
775         }
776     }
777
778     return av;
779 }
780
781 /*--------------------------------------------------------------------------------------*/
782 /*
783  * XS Interface for perl code
784  */
785
786 PerlIO_funcs *
787 PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
788 {
789     dVAR;
790     IV i;
791     if ((SSize_t) len <= 0)
792         len = strlen(name);
793     for (i = 0; i < PL_known_layers->cur; i++) {
794         PerlIO_funcs * const f = PL_known_layers->array[i].funcs;
795         if (memEQ(f->name, name, len) && f->name[len] == 0) {
796             PerlIO_debug("%.*s => %p\n", (int) len, name, (void*)f);
797             return f;
798         }
799     }
800     if (load && PL_subname && PL_def_layerlist
801         && PL_def_layerlist->cur >= 2) {
802         if (PL_in_load_module) {
803             Perl_croak(aTHX_ "Recursive call to Perl_load_module in PerlIO_find_layer");
804             return NULL;
805         } else {
806             SV * const pkgsv = newSVpvs("PerlIO");
807             SV * const layer = newSVpvn(name, len);
808             CV * const cv    = Perl_get_cvn_flags(aTHX_ STR_WITH_LEN("PerlIO::Layer::NoWarnings"), 0);
809             ENTER;
810             SAVEINT(PL_in_load_module);
811             if (cv) {
812                 SAVEGENERICSV(PL_warnhook);
813                 PL_warnhook = (SV *) (SvREFCNT_inc_simple_NN(cv));
814             }
815             PL_in_load_module++;
816             /*
817              * The two SVs are magically freed by load_module
818              */
819             Perl_load_module(aTHX_ 0, pkgsv, NULL, layer, NULL);
820             PL_in_load_module--;
821             LEAVE;
822             return PerlIO_find_layer(aTHX_ name, len, 0);
823         }
824     }
825     PerlIO_debug("Cannot find %.*s\n", (int) len, name);
826     return NULL;
827 }
828
829 #ifdef USE_ATTRIBUTES_FOR_PERLIO
830
831 static int
832 perlio_mg_set(pTHX_ SV *sv, MAGIC *mg)
833 {
834     if (SvROK(sv)) {
835         IO * const io = GvIOn((GV *) SvRV(sv));
836         PerlIO * const ifp = IoIFP(io);
837         PerlIO * const ofp = IoOFP(io);
838         Perl_warn(aTHX_ "set %" SVf " %p %p %p",
839                   SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
840     }
841     return 0;
842 }
843
844 static int
845 perlio_mg_get(pTHX_ SV *sv, MAGIC *mg)
846 {
847     if (SvROK(sv)) {
848         IO * const io = GvIOn((GV *) SvRV(sv));
849         PerlIO * const ifp = IoIFP(io);
850         PerlIO * const ofp = IoOFP(io);
851         Perl_warn(aTHX_ "get %" SVf " %p %p %p",
852                   SVfARG(sv), (void*)io, (void*)ifp, (void*)ofp);
853     }
854     return 0;
855 }
856
857 static int
858 perlio_mg_clear(pTHX_ SV *sv, MAGIC *mg)
859 {
860     Perl_warn(aTHX_ "clear %" SVf, SVfARG(sv));
861     return 0;
862 }
863
864 static int
865 perlio_mg_free(pTHX_ SV *sv, MAGIC *mg)
866 {
867     Perl_warn(aTHX_ "free %" SVf, SVfARG(sv));
868     return 0;
869 }
870
871 MGVTBL perlio_vtab = {
872     perlio_mg_get,
873     perlio_mg_set,
874     NULL,                       /* len */
875     perlio_mg_clear,
876     perlio_mg_free
877 };
878
879 XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
880 {
881     dXSARGS;
882     SV * const sv = SvRV(ST(1));
883     AV * const av = newAV();
884     MAGIC *mg;
885     int count = 0;
886     int i;
887     sv_magic(sv, (SV *) av, PERL_MAGIC_ext, NULL, 0);
888     SvRMAGICAL_off(sv);
889     mg = mg_find(sv, PERL_MAGIC_ext);
890     mg->mg_virtual = &perlio_vtab;
891     mg_magical(sv);
892     Perl_warn(aTHX_ "attrib %" SVf, SVfARG(sv));
893     for (i = 2; i < items; i++) {
894         STRLEN len;
895         const char * const name = SvPV_const(ST(i), len);
896         SV * const layer = PerlIO_find_layer(aTHX_ name, len, 1);
897         if (layer) {
898             av_push(av, SvREFCNT_inc_simple_NN(layer));
899         }
900         else {
901             ST(count) = ST(i);
902             count++;
903         }
904     }
905     SvREFCNT_dec(av);
906     XSRETURN(count);
907 }
908
909 #endif                          /* USE_ATTIBUTES_FOR_PERLIO */
910
911 SV *
912 PerlIO_tab_sv(pTHX_ PerlIO_funcs *tab)
913 {
914     HV * const stash = gv_stashpvs("PerlIO::Layer", GV_ADD);
915     SV * const sv = sv_bless(newRV_noinc(newSViv(PTR2IV(tab))), stash);
916     return sv;
917 }
918
919 XS(XS_PerlIO__Layer__NoWarnings)
920 {
921     /* This is used as a %SIG{__WARN__} handler to supress warnings
922        during loading of layers.
923      */
924     dVAR;
925     dXSARGS;
926     PERL_UNUSED_ARG(cv);
927     if (items)
928         PerlIO_debug("warning:%s\n",SvPV_nolen_const(ST(0)));
929     XSRETURN(0);
930 }
931
932 XS(XS_PerlIO__Layer__find)
933 {
934     dVAR;
935     dXSARGS;
936     PERL_UNUSED_ARG(cv);
937     if (items < 2)
938         Perl_croak(aTHX_ "Usage class->find(name[,load])");
939     else {
940         STRLEN len;
941         const char * const name = SvPV_const(ST(1), len);
942         const bool load = (items > 2) ? SvTRUE(ST(2)) : 0;
943         PerlIO_funcs * const layer = PerlIO_find_layer(aTHX_ name, len, load);
944         ST(0) =
945             (layer) ? sv_2mortal(PerlIO_tab_sv(aTHX_ layer)) :
946             &PL_sv_undef;
947         XSRETURN(1);
948     }
949 }
950
951 void
952 PerlIO_define_layer(pTHX_ PerlIO_funcs *tab)
953 {
954     dVAR;
955     if (!PL_known_layers)
956         PL_known_layers = PerlIO_list_alloc(aTHX);
957     PerlIO_list_push(aTHX_ PL_known_layers, tab, NULL);
958     PerlIO_debug("define %s %p\n", tab->name, (void*)tab);
959 }
960
961 int
962 PerlIO_parse_layers(pTHX_ PerlIO_list_t *av, const char *names)
963 {
964     dVAR;
965     if (names) {
966         const char *s = names;
967         while (*s) {
968             while (isSPACE(*s) || *s == ':')
969                 s++;
970             if (*s) {
971                 STRLEN llen = 0;
972                 const char *e = s;
973                 const char *as = NULL;
974                 STRLEN alen = 0;
975                 if (!isIDFIRST(*s)) {
976                     /*
977                      * Message is consistent with how attribute lists are
978                      * passed. Even though this means "foo : : bar" is
979                      * seen as an invalid separator character.
980                      */
981                     const char q = ((*s == '\'') ? '"' : '\'');
982                     if (ckWARN(WARN_LAYER))
983                         Perl_warner(aTHX_ packWARN(WARN_LAYER),
984                               "Invalid separator character %c%c%c in PerlIO layer specification %s",
985                               q, *s, q, s);
986                     SETERRNO(EINVAL, LIB_INVARG);
987                     return -1;
988                 }
989                 do {
990                     e++;
991                 } while (isALNUM(*e));
992                 llen = e - s;
993                 if (*e == '(') {
994                     int nesting = 1;
995                     as = ++e;
996                     while (nesting) {
997                         switch (*e++) {
998                         case ')':
999                             if (--nesting == 0)
1000                                 alen = (e - 1) - as;
1001                             break;
1002                         case '(':
1003                             ++nesting;
1004                             break;
1005                         case '\\':
1006                             /*
1007                              * It's a nul terminated string, not allowed
1008                              * to \ the terminating null. Anything other
1009                              * character is passed over.
1010                              */
1011                             if (*e++) {
1012                                 break;
1013                             }
1014                             /*
1015                              * Drop through
1016                              */
1017                         case '\0':
1018                             e--;
1019                             if (ckWARN(WARN_LAYER))
1020                                 Perl_warner(aTHX_ packWARN(WARN_LAYER),
1021                                       "Argument list not closed for PerlIO layer \"%.*s\"",
1022                                       (int) (e - s), s);
1023                             return -1;
1024                         default:
1025                             /*
1026                              * boring.
1027                              */
1028                             break;
1029                         }
1030                     }
1031                 }
1032                 if (e > s) {
1033                     PerlIO_funcs * const layer =
1034                         PerlIO_find_layer(aTHX_ s, llen, 1);
1035                     if (layer) {
1036                         SV *arg = NULL;
1037                         if (as)
1038                             arg = newSVpvn(as, alen);
1039                         PerlIO_list_push(aTHX_ av, layer,
1040                                          (arg) ? arg : &PL_sv_undef);
1041                         if (arg)
1042                             SvREFCNT_dec(arg);
1043                     }
1044                     else {
1045                         if (ckWARN(WARN_LAYER))
1046                             Perl_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"%.*s\"",
1047                                   (int) llen, s);
1048                         return -1;
1049                     }
1050                 }
1051                 s = e;
1052             }
1053         }
1054     }
1055     return 0;
1056 }
1057
1058 void
1059 PerlIO_default_buffer(pTHX_ PerlIO_list_t *av)
1060 {
1061     dVAR;
1062     PERLIO_FUNCS_DECL(*tab) = &PerlIO_perlio;
1063 #ifdef PERLIO_USING_CRLF
1064     tab = &PerlIO_crlf;
1065 #else
1066     if (PerlIO_stdio.Set_ptrcnt)
1067         tab = &PerlIO_stdio;
1068 #endif
1069     PerlIO_debug("Pushing %s\n", tab->name);
1070     PerlIO_list_push(aTHX_ av, PerlIO_find_layer(aTHX_ tab->name, 0, 0),
1071                      &PL_sv_undef);
1072 }
1073
1074 SV *
1075 PerlIO_arg_fetch(PerlIO_list_t *av, IV n)
1076 {
1077     return av->array[n].arg;
1078 }
1079
1080 PerlIO_funcs *
1081 PerlIO_layer_fetch(pTHX_ PerlIO_list_t *av, IV n, PerlIO_funcs *def)
1082 {
1083     if (n >= 0 && n < av->cur) {
1084         PerlIO_debug("Layer %" IVdf " is %s\n", n,
1085                      av->array[n].funcs->name);
1086         return av->array[n].funcs;
1087     }
1088     if (!def)
1089         Perl_croak(aTHX_ "panic: PerlIO layer array corrupt");
1090     return def;
1091 }
1092
1093 IV
1094 PerlIOPop_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1095 {
1096     PERL_UNUSED_ARG(mode);
1097     PERL_UNUSED_ARG(arg);
1098     PERL_UNUSED_ARG(tab);
1099     if (PerlIOValid(f)) {
1100         PerlIO_flush(f);
1101         PerlIO_pop(aTHX_ f);
1102         return 0;
1103     }
1104     return -1;
1105 }
1106
1107 PERLIO_FUNCS_DECL(PerlIO_remove) = {
1108     sizeof(PerlIO_funcs),
1109     "pop",
1110     0,
1111     PERLIO_K_DUMMY | PERLIO_K_UTF8,
1112     PerlIOPop_pushed,
1113     NULL,
1114     NULL,
1115     NULL,
1116     NULL,
1117     NULL,
1118     NULL,
1119     NULL,
1120     NULL,
1121     NULL,
1122     NULL,
1123     NULL,
1124     NULL,
1125     NULL,                       /* flush */
1126     NULL,                       /* fill */
1127     NULL,
1128     NULL,
1129     NULL,
1130     NULL,
1131     NULL,                       /* get_base */
1132     NULL,                       /* get_bufsiz */
1133     NULL,                       /* get_ptr */
1134     NULL,                       /* get_cnt */
1135     NULL,                       /* set_ptrcnt */
1136 };
1137
1138 PerlIO_list_t *
1139 PerlIO_default_layers(pTHX)
1140 {
1141     dVAR;
1142     if (!PL_def_layerlist) {
1143         const char * const s = (PL_tainting) ? NULL : PerlEnv_getenv("PERLIO");
1144         PERLIO_FUNCS_DECL(*osLayer) = &PerlIO_unix;
1145         PL_def_layerlist = PerlIO_list_alloc(aTHX);
1146         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_unix));
1147 #if defined(WIN32)
1148         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_win32));
1149 #if 0
1150         osLayer = &PerlIO_win32;
1151 #endif
1152 #endif
1153         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_raw));
1154         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_perlio));
1155         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_stdio));
1156         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_crlf));
1157 #ifdef HAS_MMAP
1158         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_mmap));
1159 #endif
1160         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_utf8));
1161         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_remove));
1162         PerlIO_define_layer(aTHX_ PERLIO_FUNCS_CAST(&PerlIO_byte));
1163         PerlIO_list_push(aTHX_ PL_def_layerlist,
1164                          PerlIO_find_layer(aTHX_ osLayer->name, 0, 0),
1165                          &PL_sv_undef);
1166         if (s) {
1167             PerlIO_parse_layers(aTHX_ PL_def_layerlist, s);
1168         }
1169         else {
1170             PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1171         }
1172     }
1173     if (PL_def_layerlist->cur < 2) {
1174         PerlIO_default_buffer(aTHX_ PL_def_layerlist);
1175     }
1176     return PL_def_layerlist;
1177 }
1178
1179 void
1180 Perl_boot_core_PerlIO(pTHX)
1181 {
1182 #ifdef USE_ATTRIBUTES_FOR_PERLIO
1183     newXS("io::MODIFY_SCALAR_ATTRIBUTES", XS_io_MODIFY_SCALAR_ATTRIBUTES,
1184           __FILE__);
1185 #endif
1186     newXS("PerlIO::Layer::find", XS_PerlIO__Layer__find, __FILE__);
1187     newXS("PerlIO::Layer::NoWarnings", XS_PerlIO__Layer__NoWarnings, __FILE__);
1188 }
1189
1190 PerlIO_funcs *
1191 PerlIO_default_layer(pTHX_ I32 n)
1192 {
1193     dVAR;
1194     PerlIO_list_t * const av = PerlIO_default_layers(aTHX);
1195     if (n < 0)
1196         n += av->cur;
1197     return PerlIO_layer_fetch(aTHX_ av, n, PERLIO_FUNCS_CAST(&PerlIO_stdio));
1198 }
1199
1200 #define PerlIO_default_top() PerlIO_default_layer(aTHX_ -1)
1201 #define PerlIO_default_btm() PerlIO_default_layer(aTHX_ 0)
1202
1203 void
1204 PerlIO_stdstreams(pTHX)
1205 {
1206     dVAR;
1207     if (!PL_perlio) {
1208         PerlIO_allocate(aTHX);
1209         PerlIO_fdopen(0, "Ir" PERLIO_STDTEXT);
1210         PerlIO_fdopen(1, "Iw" PERLIO_STDTEXT);
1211         PerlIO_fdopen(2, "Iw" PERLIO_STDTEXT);
1212     }
1213 }
1214
1215 PerlIO *
1216 PerlIO_push(pTHX_ PerlIO *f, PERLIO_FUNCS_DECL(*tab), const char *mode, SV *arg)
1217 {
1218     if (tab->fsize != sizeof(PerlIO_funcs)) {
1219       mismatch:
1220         Perl_croak(aTHX_ "Layer does not match this perl");
1221     }
1222     if (tab->size) {
1223         PerlIOl *l;
1224         if (tab->size < sizeof(PerlIOl)) {
1225             goto mismatch;
1226         }
1227         /* Real layer with a data area */
1228         if (f) {
1229             char *temp;
1230             Newxz(temp, tab->size, char);
1231             l = (PerlIOl*)temp;
1232             if (l) {
1233                 l->next = *f;
1234                 l->tab = (PerlIO_funcs*) tab;
1235                 *f = l;
1236                 PerlIO_debug("PerlIO_push f=%p %s %s %p\n",
1237                              (void*)f, tab->name,
1238                              (mode) ? mode : "(Null)", (void*)arg);
1239                 if (*l->tab->Pushed &&
1240                     (*l->tab->Pushed)
1241                       (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1242                     PerlIO_pop(aTHX_ f);
1243                     return NULL;
1244                 }
1245             }
1246             else
1247                 return NULL;
1248         }
1249     }
1250     else if (f) {
1251         /* Pseudo-layer where push does its own stack adjust */
1252         PerlIO_debug("PerlIO_push f=%p %s %s %p\n", (void*)f, tab->name,
1253                      (mode) ? mode : "(Null)", (void*)arg);
1254         if (tab->Pushed &&
1255             (*tab->Pushed) (aTHX_ f, mode, arg, (PerlIO_funcs*) tab) != 0) {
1256              return NULL;
1257         }
1258     }
1259     return f;
1260 }
1261
1262 IV
1263 PerlIOBase_binmode(pTHX_ PerlIO *f)
1264 {
1265    if (PerlIOValid(f)) {
1266         /* Is layer suitable for raw stream ? */
1267         if (PerlIOBase(f)->tab->kind & PERLIO_K_RAW) {
1268             /* Yes - turn off UTF-8-ness, to undo UTF-8 locale effects */
1269             PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1270         }
1271         else {
1272             /* Not suitable - pop it */
1273             PerlIO_pop(aTHX_ f);
1274         }
1275         return 0;
1276    }
1277    return -1;
1278 }
1279
1280 IV
1281 PerlIORaw_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1282 {
1283     PERL_UNUSED_ARG(mode);
1284     PERL_UNUSED_ARG(arg);
1285     PERL_UNUSED_ARG(tab);
1286
1287     if (PerlIOValid(f)) {
1288         PerlIO *t;
1289         const PerlIOl *l;
1290         PerlIO_flush(f);
1291         /*
1292          * Strip all layers that are not suitable for a raw stream
1293          */
1294         t = f;
1295         while (t && (l = *t)) {
1296             if (l->tab->Binmode) {
1297                 /* Has a handler - normal case */
1298                 if ((*l->tab->Binmode)(aTHX_ f) == 0) {
1299                     if (*t == l) {
1300                         /* Layer still there - move down a layer */
1301                         t = PerlIONext(t);
1302                     }
1303                 }
1304                 else {
1305                     return -1;
1306                 }
1307             }
1308             else {
1309                 /* No handler - pop it */
1310                 PerlIO_pop(aTHX_ t);
1311             }
1312         }
1313         if (PerlIOValid(f)) {
1314             PerlIO_debug(":raw f=%p :%s\n", (void*)f, PerlIOBase(f)->tab->name);
1315             return 0;
1316         }
1317     }
1318     return -1;
1319 }
1320
1321 int
1322 PerlIO_apply_layera(pTHX_ PerlIO *f, const char *mode,
1323                     PerlIO_list_t *layers, IV n, IV max)
1324 {
1325     int code = 0;
1326     while (n < max) {
1327         PerlIO_funcs * const tab = PerlIO_layer_fetch(aTHX_ layers, n, NULL);
1328         if (tab) {
1329             if (!PerlIO_push(aTHX_ f, tab, mode, PerlIOArg)) {
1330                 code = -1;
1331                 break;
1332             }
1333         }
1334         n++;
1335     }
1336     return code;
1337 }
1338
1339 int
1340 PerlIO_apply_layers(pTHX_ PerlIO *f, const char *mode, const char *names)
1341 {
1342     int code = 0;
1343     if (f && names) {
1344         PerlIO_list_t * const layers = PerlIO_list_alloc(aTHX);
1345         code = PerlIO_parse_layers(aTHX_ layers, names);
1346         if (code == 0) {
1347             code = PerlIO_apply_layera(aTHX_ f, mode, layers, 0, layers->cur);
1348         }
1349         PerlIO_list_free(aTHX_ layers);
1350     }
1351     return code;
1352 }
1353
1354
1355 /*--------------------------------------------------------------------------------------*/
1356 /*
1357  * Given the abstraction above the public API functions
1358  */
1359
1360 int
1361 PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
1362 {
1363     PerlIO_debug("PerlIO_binmode f=%p %s %c %x %s\n", (void*)f,
1364                  (PerlIOBase(f)) ? PerlIOBase(f)->tab->name : "(Null)",
1365                  iotype, mode, (names) ? names : "(Null)");
1366
1367     if (names) {
1368         /* Do not flush etc. if (e.g.) switching encodings.
1369            if a pushed layer knows it needs to flush lower layers
1370            (for example :unix which is never going to call them)
1371            it can do the flush when it is pushed.
1372          */
1373         return PerlIO_apply_layers(aTHX_ f, NULL, names) == 0 ? TRUE : FALSE;
1374     }
1375     else {
1376         /* Fake 5.6 legacy of using this call to turn ON O_TEXT */
1377 #ifdef PERLIO_USING_CRLF
1378         /* Legacy binmode only has meaning if O_TEXT has a value distinct from
1379            O_BINARY so we can look for it in mode.
1380          */
1381         if (!(mode & O_BINARY)) {
1382             /* Text mode */
1383             /* FIXME?: Looking down the layer stack seems wrong,
1384                but is a way of reaching past (say) an encoding layer
1385                to flip CRLF-ness of the layer(s) below
1386              */
1387             while (*f) {
1388                 /* Perhaps we should turn on bottom-most aware layer
1389                    e.g. Ilya's idea that UNIX TTY could serve
1390                  */
1391                 if (PerlIOBase(f)->tab->kind & PERLIO_K_CANCRLF) {
1392                     if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
1393                         /* Not in text mode - flush any pending stuff and flip it */
1394                         PerlIO_flush(f);
1395                         PerlIOBase(f)->flags |= PERLIO_F_CRLF;
1396                     }
1397                     /* Only need to turn it on in one layer so we are done */
1398                     return TRUE;
1399                 }
1400                 f = PerlIONext(f);
1401             }
1402             /* Not finding a CRLF aware layer presumably means we are binary
1403                which is not what was requested - so we failed
1404                We _could_ push :crlf layer but so could caller
1405              */
1406             return FALSE;
1407         }
1408 #endif
1409         /* Legacy binmode is now _defined_ as being equivalent to pushing :raw
1410            So code that used to be here is now in PerlIORaw_pushed().
1411          */
1412         return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL) ? TRUE : FALSE;
1413     }
1414 }
1415
1416 int
1417 PerlIO__close(pTHX_ PerlIO *f)
1418 {
1419     if (PerlIOValid(f)) {
1420         PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1421         if (tab && tab->Close)
1422             return (*tab->Close)(aTHX_ f);
1423         else
1424             return PerlIOBase_close(aTHX_ f);
1425     }
1426     else {
1427         SETERRNO(EBADF, SS_IVCHAN);
1428         return -1;
1429     }
1430 }
1431
1432 int
1433 Perl_PerlIO_close(pTHX_ PerlIO *f)
1434 {
1435     const int code = PerlIO__close(aTHX_ f);
1436     while (PerlIOValid(f)) {
1437         PerlIO_pop(aTHX_ f);
1438     }
1439     return code;
1440 }
1441
1442 int
1443 Perl_PerlIO_fileno(pTHX_ PerlIO *f)
1444 {
1445     dVAR;
1446      Perl_PerlIO_or_Base(f, Fileno, fileno, -1, (aTHX_ f));
1447 }
1448
1449
1450 static PerlIO_funcs *
1451 PerlIO_layer_from_ref(pTHX_ SV *sv)
1452 {
1453     dVAR;
1454     /*
1455      * For any scalar type load the handler which is bundled with perl
1456      */
1457     if (SvTYPE(sv) < SVt_PVAV) {
1458         PerlIO_funcs *f = PerlIO_find_layer(aTHX_ STR_WITH_LEN("scalar"), 1);
1459         /* This isn't supposed to happen, since PerlIO::scalar is core,
1460          * but could happen anyway in smaller installs or with PAR */
1461         if (!f && ckWARN(WARN_LAYER))
1462             Perl_warner(aTHX_ packWARN(WARN_LAYER), "Unknown PerlIO layer \"scalar\"");
1463         return f;
1464     }
1465
1466     /*
1467      * For other types allow if layer is known but don't try and load it
1468      */
1469     switch (SvTYPE(sv)) {
1470     case SVt_PVAV:
1471         return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Array"), 0);
1472     case SVt_PVHV:
1473         return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Hash"), 0);
1474     case SVt_PVCV:
1475         return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Code"), 0);
1476     case SVt_PVGV:
1477         return PerlIO_find_layer(aTHX_ STR_WITH_LEN("Glob"), 0);
1478     default:
1479         return NULL;
1480     }
1481 }
1482
1483 PerlIO_list_t *
1484 PerlIO_resolve_layers(pTHX_ const char *layers,
1485                       const char *mode, int narg, SV **args)
1486 {
1487     dVAR;
1488     PerlIO_list_t *def = PerlIO_default_layers(aTHX);
1489     int incdef = 1;
1490     if (!PL_perlio)
1491         PerlIO_stdstreams(aTHX);
1492     if (narg) {
1493         SV * const arg = *args;
1494         /*
1495          * If it is a reference but not an object see if we have a handler
1496          * for it
1497          */
1498         if (SvROK(arg) && !sv_isobject(arg)) {
1499             PerlIO_funcs * const handler = PerlIO_layer_from_ref(aTHX_ SvRV(arg));
1500             if (handler) {
1501                 def = PerlIO_list_alloc(aTHX);
1502                 PerlIO_list_push(aTHX_ def, handler, &PL_sv_undef);
1503                 incdef = 0;
1504             }
1505             /*
1506              * Don't fail if handler cannot be found :via(...) etc. may do
1507              * something sensible else we will just stringfy and open
1508              * resulting string.
1509              */
1510         }
1511     }
1512     if (!layers || !*layers)
1513         layers = Perl_PerlIO_context_layers(aTHX_ mode);
1514     if (layers && *layers) {
1515         PerlIO_list_t *av;
1516         if (incdef) {
1517             av = PerlIO_clone_list(aTHX_ def, NULL);
1518         }
1519         else {
1520             av = def;
1521         }
1522         if (PerlIO_parse_layers(aTHX_ av, layers) == 0) {
1523              return av;
1524         }
1525         else {
1526             PerlIO_list_free(aTHX_ av);
1527             return NULL;
1528         }
1529     }
1530     else {
1531         if (incdef)
1532             def->refcnt++;
1533         return def;
1534     }
1535 }
1536
1537 PerlIO *
1538 PerlIO_openn(pTHX_ const char *layers, const char *mode, int fd,
1539              int imode, int perm, PerlIO *f, int narg, SV **args)
1540 {
1541     dVAR;
1542     if (!f && narg == 1 && *args == &PL_sv_undef) {
1543         if ((f = PerlIO_tmpfile())) {
1544             if (!layers || !*layers)
1545                 layers = Perl_PerlIO_context_layers(aTHX_ mode);
1546             if (layers && *layers)
1547                 PerlIO_apply_layers(aTHX_ f, mode, layers);
1548         }
1549     }
1550     else {
1551         PerlIO_list_t *layera;
1552         IV n;
1553         PerlIO_funcs *tab = NULL;
1554         if (PerlIOValid(f)) {
1555             /*
1556              * This is "reopen" - it is not tested as perl does not use it
1557              * yet
1558              */
1559             PerlIOl *l = *f;
1560             layera = PerlIO_list_alloc(aTHX);
1561             while (l) {
1562                 SV *arg = NULL;
1563                 if (l->tab->Getarg)
1564                     arg = (*l->tab->Getarg) (aTHX_ &l, NULL, 0);
1565                 PerlIO_list_push(aTHX_ layera, l->tab,
1566                                  (arg) ? arg : &PL_sv_undef);
1567                 if (arg)
1568                     SvREFCNT_dec(arg);
1569                 l = *PerlIONext(&l);
1570             }
1571         }
1572         else {
1573             layera = PerlIO_resolve_layers(aTHX_ layers, mode, narg, args);
1574             if (!layera) {
1575                 return NULL;
1576             }
1577         }
1578         /*
1579          * Start at "top" of layer stack
1580          */
1581         n = layera->cur - 1;
1582         while (n >= 0) {
1583             PerlIO_funcs * const t = PerlIO_layer_fetch(aTHX_ layera, n, NULL);
1584             if (t && t->Open) {
1585                 tab = t;
1586                 break;
1587             }
1588             n--;
1589         }
1590         if (tab) {
1591             /*
1592              * Found that layer 'n' can do opens - call it
1593              */
1594             if (narg > 1 && !(tab->kind & PERLIO_K_MULTIARG)) {
1595                 Perl_croak(aTHX_ "More than one argument to open(,':%s')",tab->name);
1596             }
1597             PerlIO_debug("openn(%s,'%s','%s',%d,%x,%o,%p,%d,%p)\n",
1598                          tab->name, layers ? layers : "(Null)", mode, fd,
1599                          imode, perm, (void*)f, narg, (void*)args);
1600             if (tab->Open)
1601                  f = (*tab->Open) (aTHX_ tab, layera, n, mode, fd, imode, perm,
1602                                    f, narg, args);
1603             else {
1604                  SETERRNO(EINVAL, LIB_INVARG);
1605                  f = NULL;
1606             }
1607             if (f) {
1608                 if (n + 1 < layera->cur) {
1609                     /*
1610                      * More layers above the one that we used to open -
1611                      * apply them now
1612                      */
1613                     if (PerlIO_apply_layera(aTHX_ f, mode, layera, n + 1, layera->cur) != 0) {
1614                         /* If pushing layers fails close the file */
1615                         PerlIO_close(f);
1616                         f = NULL;
1617                     }
1618                 }
1619             }
1620         }
1621         PerlIO_list_free(aTHX_ layera);
1622     }
1623     return f;
1624 }
1625
1626
1627 SSize_t
1628 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
1629 {
1630      PERL_ARGS_ASSERT_PERLIO_READ;
1631
1632      Perl_PerlIO_or_Base(f, Read, read, -1, (aTHX_ f, vbuf, count));
1633 }
1634
1635 SSize_t
1636 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1637 {
1638      PERL_ARGS_ASSERT_PERLIO_UNREAD;
1639
1640      Perl_PerlIO_or_Base(f, Unread, unread, -1, (aTHX_ f, vbuf, count));
1641 }
1642
1643 SSize_t
1644 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
1645 {
1646      PERL_ARGS_ASSERT_PERLIO_WRITE;
1647
1648      Perl_PerlIO_or_fail(f, Write, -1, (aTHX_ f, vbuf, count));
1649 }
1650
1651 int
1652 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
1653 {
1654      Perl_PerlIO_or_fail(f, Seek, -1, (aTHX_ f, offset, whence));
1655 }
1656
1657 Off_t
1658 Perl_PerlIO_tell(pTHX_ PerlIO *f)
1659 {
1660      Perl_PerlIO_or_fail(f, Tell, -1, (aTHX_ f));
1661 }
1662
1663 int
1664 Perl_PerlIO_flush(pTHX_ PerlIO *f)
1665 {
1666     dVAR;
1667     if (f) {
1668         if (*f) {
1669             const PerlIO_funcs *tab = PerlIOBase(f)->tab;
1670
1671             if (tab && tab->Flush)
1672                 return (*tab->Flush) (aTHX_ f);
1673             else
1674                  return 0; /* If no Flush defined, silently succeed. */
1675         }
1676         else {
1677             PerlIO_debug("Cannot flush f=%p\n", (void*)f);
1678             SETERRNO(EBADF, SS_IVCHAN);
1679             return -1;
1680         }
1681     }
1682     else {
1683         /*
1684          * Is it good API design to do flush-all on NULL, a potentially
1685          * errorneous input? Maybe some magical value (PerlIO*
1686          * PERLIO_FLUSH_ALL = (PerlIO*)-1;)? Yes, stdio does similar
1687          * things on fflush(NULL), but should we be bound by their design
1688          * decisions? --jhi
1689          */
1690         PerlIO **table = &PL_perlio;
1691         int code = 0;
1692         while ((f = *table)) {
1693             int i;
1694             table = (PerlIO **) (f++);
1695             for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1696                 if (*f && PerlIO_flush(f) != 0)
1697                     code = -1;
1698                 f++;
1699             }
1700         }
1701         return code;
1702     }
1703 }
1704
1705 void
1706 PerlIOBase_flush_linebuf(pTHX)
1707 {
1708     dVAR;
1709     PerlIO **table = &PL_perlio;
1710     PerlIO *f;
1711     while ((f = *table)) {
1712         int i;
1713         table = (PerlIO **) (f++);
1714         for (i = 1; i < PERLIO_TABLE_SIZE; i++) {
1715             if (*f
1716                 && (PerlIOBase(f)->
1717                     flags & (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1718                 == (PERLIO_F_LINEBUF | PERLIO_F_CANWRITE))
1719                 PerlIO_flush(f);
1720             f++;
1721         }
1722     }
1723 }
1724
1725 int
1726 Perl_PerlIO_fill(pTHX_ PerlIO *f)
1727 {
1728      Perl_PerlIO_or_fail(f, Fill, -1, (aTHX_ f));
1729 }
1730
1731 int
1732 PerlIO_isutf8(PerlIO *f)
1733 {
1734      if (PerlIOValid(f))
1735           return (PerlIOBase(f)->flags & PERLIO_F_UTF8) != 0;
1736      else
1737           SETERRNO(EBADF, SS_IVCHAN);
1738
1739      return -1;
1740 }
1741
1742 int
1743 Perl_PerlIO_eof(pTHX_ PerlIO *f)
1744 {
1745      Perl_PerlIO_or_Base(f, Eof, eof, -1, (aTHX_ f));
1746 }
1747
1748 int
1749 Perl_PerlIO_error(pTHX_ PerlIO *f)
1750 {
1751      Perl_PerlIO_or_Base(f, Error, error, -1, (aTHX_ f));
1752 }
1753
1754 void
1755 Perl_PerlIO_clearerr(pTHX_ PerlIO *f)
1756 {
1757      Perl_PerlIO_or_Base_void(f, Clearerr, clearerr, (aTHX_ f));
1758 }
1759
1760 void
1761 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f)
1762 {
1763      Perl_PerlIO_or_Base_void(f, Setlinebuf, setlinebuf, (aTHX_ f));
1764 }
1765
1766 int
1767 PerlIO_has_base(PerlIO *f)
1768 {
1769      if (PerlIOValid(f)) {
1770           const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1771
1772           if (tab)
1773                return (tab->Get_base != NULL);
1774           SETERRNO(EINVAL, LIB_INVARG);
1775      }
1776      else
1777           SETERRNO(EBADF, SS_IVCHAN);
1778
1779      return 0;
1780 }
1781
1782 int
1783 PerlIO_fast_gets(PerlIO *f)
1784 {
1785     if (PerlIOValid(f) && (PerlIOBase(f)->flags & PERLIO_F_FASTGETS)) {
1786          const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1787
1788          if (tab)
1789               return (tab->Set_ptrcnt != NULL);
1790          SETERRNO(EINVAL, LIB_INVARG);
1791     }
1792     else
1793          SETERRNO(EBADF, SS_IVCHAN);
1794
1795     return 0;
1796 }
1797
1798 int
1799 PerlIO_has_cntptr(PerlIO *f)
1800 {
1801     if (PerlIOValid(f)) {
1802         const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1803
1804         if (tab)
1805              return (tab->Get_ptr != NULL && tab->Get_cnt != NULL);
1806           SETERRNO(EINVAL, LIB_INVARG);
1807     }
1808     else
1809          SETERRNO(EBADF, SS_IVCHAN);
1810
1811     return 0;
1812 }
1813
1814 int
1815 PerlIO_canset_cnt(PerlIO *f)
1816 {
1817     if (PerlIOValid(f)) {
1818           const PerlIO_funcs * const tab = PerlIOBase(f)->tab;
1819
1820           if (tab)
1821                return (tab->Set_ptrcnt != NULL);
1822           SETERRNO(EINVAL, LIB_INVARG);
1823     }
1824     else
1825          SETERRNO(EBADF, SS_IVCHAN);
1826
1827     return 0;
1828 }
1829
1830 STDCHAR *
1831 Perl_PerlIO_get_base(pTHX_ PerlIO *f)
1832 {
1833      Perl_PerlIO_or_fail(f, Get_base, NULL, (aTHX_ f));
1834 }
1835
1836 int
1837 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
1838 {
1839      Perl_PerlIO_or_fail(f, Get_bufsiz, -1, (aTHX_ f));
1840 }
1841
1842 STDCHAR *
1843 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f)
1844 {
1845      Perl_PerlIO_or_fail(f, Get_ptr, NULL, (aTHX_ f));
1846 }
1847
1848 int
1849 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
1850 {
1851      Perl_PerlIO_or_fail(f, Get_cnt, -1, (aTHX_ f));
1852 }
1853
1854 void
1855 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt)
1856 {
1857      Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, NULL, cnt));
1858 }
1859
1860 void
1861 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, int cnt)
1862 {
1863      Perl_PerlIO_or_fail_void(f, Set_ptrcnt, (aTHX_ f, ptr, cnt));
1864 }
1865
1866
1867 /*--------------------------------------------------------------------------------------*/
1868 /*
1869  * utf8 and raw dummy layers
1870  */
1871
1872 IV
1873 PerlIOUtf8_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
1874 {
1875     PERL_UNUSED_CONTEXT;
1876     PERL_UNUSED_ARG(mode);
1877     PERL_UNUSED_ARG(arg);
1878     if (PerlIOValid(f)) {
1879         if (tab->kind & PERLIO_K_UTF8)
1880             PerlIOBase(f)->flags |= PERLIO_F_UTF8;
1881         else
1882             PerlIOBase(f)->flags &= ~PERLIO_F_UTF8;
1883         return 0;
1884     }
1885     return -1;
1886 }
1887
1888 PERLIO_FUNCS_DECL(PerlIO_utf8) = {
1889     sizeof(PerlIO_funcs),
1890     "utf8",
1891     0,
1892     PERLIO_K_DUMMY | PERLIO_K_UTF8,
1893     PerlIOUtf8_pushed,
1894     NULL,
1895     NULL,
1896     NULL,
1897     NULL,
1898     NULL,
1899     NULL,
1900     NULL,
1901     NULL,
1902     NULL,
1903     NULL,
1904     NULL,
1905     NULL,
1906     NULL,                       /* flush */
1907     NULL,                       /* fill */
1908     NULL,
1909     NULL,
1910     NULL,
1911     NULL,
1912     NULL,                       /* get_base */
1913     NULL,                       /* get_bufsiz */
1914     NULL,                       /* get_ptr */
1915     NULL,                       /* get_cnt */
1916     NULL,                       /* set_ptrcnt */
1917 };
1918
1919 PERLIO_FUNCS_DECL(PerlIO_byte) = {
1920     sizeof(PerlIO_funcs),
1921     "bytes",
1922     0,
1923     PERLIO_K_DUMMY,
1924     PerlIOUtf8_pushed,
1925     NULL,
1926     NULL,
1927     NULL,
1928     NULL,
1929     NULL,
1930     NULL,
1931     NULL,
1932     NULL,
1933     NULL,
1934     NULL,
1935     NULL,
1936     NULL,
1937     NULL,                       /* flush */
1938     NULL,                       /* fill */
1939     NULL,
1940     NULL,
1941     NULL,
1942     NULL,
1943     NULL,                       /* get_base */
1944     NULL,                       /* get_bufsiz */
1945     NULL,                       /* get_ptr */
1946     NULL,                       /* get_cnt */
1947     NULL,                       /* set_ptrcnt */
1948 };
1949
1950 PerlIO *
1951 PerlIORaw_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
1952                IV n, const char *mode, int fd, int imode, int perm,
1953                PerlIO *old, int narg, SV **args)
1954 {
1955     PerlIO_funcs * const tab = PerlIO_default_btm();
1956     PERL_UNUSED_ARG(self);
1957     if (tab && tab->Open)
1958          return (*tab->Open) (aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
1959                               old, narg, args);
1960     SETERRNO(EINVAL, LIB_INVARG);
1961     return NULL;
1962 }
1963
1964 PERLIO_FUNCS_DECL(PerlIO_raw) = {
1965     sizeof(PerlIO_funcs),
1966     "raw",
1967     0,
1968     PERLIO_K_DUMMY,
1969     PerlIORaw_pushed,
1970     PerlIOBase_popped,
1971     PerlIORaw_open,
1972     NULL,
1973     NULL,
1974     NULL,
1975     NULL,
1976     NULL,
1977     NULL,
1978     NULL,
1979     NULL,
1980     NULL,
1981     NULL,
1982     NULL,                       /* flush */
1983     NULL,                       /* fill */
1984     NULL,
1985     NULL,
1986     NULL,
1987     NULL,
1988     NULL,                       /* get_base */
1989     NULL,                       /* get_bufsiz */
1990     NULL,                       /* get_ptr */
1991     NULL,                       /* get_cnt */
1992     NULL,                       /* set_ptrcnt */
1993 };
1994 /*--------------------------------------------------------------------------------------*/
1995 /*--------------------------------------------------------------------------------------*/
1996 /*
1997  * "Methods" of the "base class"
1998  */
1999
2000 IV
2001 PerlIOBase_fileno(pTHX_ PerlIO *f)
2002 {
2003     return PerlIOValid(f) ? PerlIO_fileno(PerlIONext(f)) : -1;
2004 }
2005
2006 char *
2007 PerlIO_modestr(PerlIO * f, char *buf)
2008 {
2009     char *s = buf;
2010     if (PerlIOValid(f)) {
2011         const IV flags = PerlIOBase(f)->flags;
2012         if (flags & PERLIO_F_APPEND) {
2013             *s++ = 'a';
2014             if (flags & PERLIO_F_CANREAD) {
2015                 *s++ = '+';
2016             }
2017         }
2018         else if (flags & PERLIO_F_CANREAD) {
2019             *s++ = 'r';
2020             if (flags & PERLIO_F_CANWRITE)
2021                 *s++ = '+';
2022         }
2023         else if (flags & PERLIO_F_CANWRITE) {
2024             *s++ = 'w';
2025             if (flags & PERLIO_F_CANREAD) {
2026                 *s++ = '+';
2027             }
2028         }
2029 #ifdef PERLIO_USING_CRLF
2030         if (!(flags & PERLIO_F_CRLF))
2031             *s++ = 'b';
2032 #endif
2033     }
2034     *s = '\0';
2035     return buf;
2036 }
2037
2038
2039 IV
2040 PerlIOBase_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2041 {
2042     PerlIOl * const l = PerlIOBase(f);
2043     PERL_UNUSED_CONTEXT;
2044     PERL_UNUSED_ARG(arg);
2045
2046     l->flags &= ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE |
2047                   PERLIO_F_TRUNCATE | PERLIO_F_APPEND);
2048     if (tab->Set_ptrcnt != NULL)
2049         l->flags |= PERLIO_F_FASTGETS;
2050     if (mode) {
2051         if (*mode == IoTYPE_NUMERIC || *mode == IoTYPE_IMPLICIT)
2052             mode++;
2053         switch (*mode++) {
2054         case 'r':
2055             l->flags |= PERLIO_F_CANREAD;
2056             break;
2057         case 'a':
2058             l->flags |= PERLIO_F_APPEND | PERLIO_F_CANWRITE;
2059             break;
2060         case 'w':
2061             l->flags |= PERLIO_F_TRUNCATE | PERLIO_F_CANWRITE;
2062             break;
2063         default:
2064             SETERRNO(EINVAL, LIB_INVARG);
2065             return -1;
2066         }
2067         while (*mode) {
2068             switch (*mode++) {
2069             case '+':
2070                 l->flags |= PERLIO_F_CANREAD | PERLIO_F_CANWRITE;
2071                 break;
2072             case 'b':
2073                 l->flags &= ~PERLIO_F_CRLF;
2074                 break;
2075             case 't':
2076                 l->flags |= PERLIO_F_CRLF;
2077                 break;
2078             default:
2079                 SETERRNO(EINVAL, LIB_INVARG);
2080                 return -1;
2081             }
2082         }
2083     }
2084     else {
2085         if (l->next) {
2086             l->flags |= l->next->flags &
2087                 (PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_TRUNCATE |
2088                  PERLIO_F_APPEND);
2089         }
2090     }
2091 #if 0
2092     PerlIO_debug("PerlIOBase_pushed f=%p %s %s fl=%08" UVxf " (%s)\n",
2093                  (void*)f, PerlIOBase(f)->tab->name, (omode) ? omode : "(Null)",
2094                  l->flags, PerlIO_modestr(f, temp));
2095 #endif
2096     return 0;
2097 }
2098
2099 IV
2100 PerlIOBase_popped(pTHX_ PerlIO *f)
2101 {
2102     PERL_UNUSED_CONTEXT;
2103     PERL_UNUSED_ARG(f);
2104     return 0;
2105 }
2106
2107 SSize_t
2108 PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2109 {
2110     /*
2111      * Save the position as current head considers it
2112      */
2113     const Off_t old = PerlIO_tell(f);
2114     PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
2115     PerlIOSelf(f, PerlIOBuf)->posn = old;
2116     return PerlIOBuf_unread(aTHX_ f, vbuf, count);
2117 }
2118
2119 SSize_t
2120 PerlIOBase_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2121 {
2122     STDCHAR *buf = (STDCHAR *) vbuf;
2123     if (f) {
2124         if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD)) {
2125             PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2126             SETERRNO(EBADF, SS_IVCHAN);
2127             return 0;
2128         }
2129         while (count > 0) {
2130          get_cnt:
2131           {
2132             SSize_t avail = PerlIO_get_cnt(f);
2133             SSize_t take = 0;
2134             if (avail > 0)
2135                 take = ((SSize_t)count < avail) ? (SSize_t)count : avail;
2136             if (take > 0) {
2137                 STDCHAR *ptr = PerlIO_get_ptr(f);
2138                 Copy(ptr, buf, take, STDCHAR);
2139                 PerlIO_set_ptrcnt(f, ptr + take, (avail -= take));
2140                 count -= take;
2141                 buf += take;
2142                 if (avail == 0)         /* set_ptrcnt could have reset avail */
2143                     goto get_cnt;
2144             }
2145             if (count > 0 && avail <= 0) {
2146                 if (PerlIO_fill(f) != 0)
2147                     break;
2148             }
2149           }
2150         }
2151         return (buf - (STDCHAR *) vbuf);
2152     }
2153     return 0;
2154 }
2155
2156 IV
2157 PerlIOBase_noop_ok(pTHX_ PerlIO *f)
2158 {
2159     PERL_UNUSED_CONTEXT;
2160     PERL_UNUSED_ARG(f);
2161     return 0;
2162 }
2163
2164 IV
2165 PerlIOBase_noop_fail(pTHX_ PerlIO *f)
2166 {
2167     PERL_UNUSED_CONTEXT;
2168     PERL_UNUSED_ARG(f);
2169     return -1;
2170 }
2171
2172 IV
2173 PerlIOBase_close(pTHX_ PerlIO *f)
2174 {
2175     IV code = -1;
2176     if (PerlIOValid(f)) {
2177         PerlIO *n = PerlIONext(f);
2178         code = PerlIO_flush(f);
2179         PerlIOBase(f)->flags &=
2180            ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2181         while (PerlIOValid(n)) {
2182             const PerlIO_funcs * const tab = PerlIOBase(n)->tab;
2183             if (tab && tab->Close) {
2184                 if ((*tab->Close)(aTHX_ n) != 0)
2185                     code = -1;
2186                 break;
2187             }
2188             else {
2189                 PerlIOBase(n)->flags &=
2190                     ~(PERLIO_F_CANREAD | PERLIO_F_CANWRITE | PERLIO_F_OPEN);
2191             }
2192             n = PerlIONext(n);
2193         }
2194     }
2195     else {
2196         SETERRNO(EBADF, SS_IVCHAN);
2197     }
2198     return code;
2199 }
2200
2201 IV
2202 PerlIOBase_eof(pTHX_ PerlIO *f)
2203 {
2204     PERL_UNUSED_CONTEXT;
2205     if (PerlIOValid(f)) {
2206         return (PerlIOBase(f)->flags & PERLIO_F_EOF) != 0;
2207     }
2208     return 1;
2209 }
2210
2211 IV
2212 PerlIOBase_error(pTHX_ PerlIO *f)
2213 {
2214     PERL_UNUSED_CONTEXT;
2215     if (PerlIOValid(f)) {
2216         return (PerlIOBase(f)->flags & PERLIO_F_ERROR) != 0;
2217     }
2218     return 1;
2219 }
2220
2221 void
2222 PerlIOBase_clearerr(pTHX_ PerlIO *f)
2223 {
2224     if (PerlIOValid(f)) {
2225         PerlIO * const n = PerlIONext(f);
2226         PerlIOBase(f)->flags &= ~(PERLIO_F_ERROR | PERLIO_F_EOF);
2227         if (PerlIOValid(n))
2228             PerlIO_clearerr(n);
2229     }
2230 }
2231
2232 void
2233 PerlIOBase_setlinebuf(pTHX_ PerlIO *f)
2234 {
2235     PERL_UNUSED_CONTEXT;
2236     if (PerlIOValid(f)) {
2237         PerlIOBase(f)->flags |= PERLIO_F_LINEBUF;
2238     }
2239 }
2240
2241 SV *
2242 PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
2243 {
2244     if (!arg)
2245         return NULL;
2246 #ifdef sv_dup
2247     if (param) {
2248         arg = sv_dup(arg, param);
2249         SvREFCNT_inc_simple_void_NN(arg);
2250         return arg;
2251     }
2252     else {
2253         return newSVsv(arg);
2254     }
2255 #else
2256     PERL_UNUSED_ARG(param);
2257     return newSVsv(arg);
2258 #endif
2259 }
2260
2261 PerlIO *
2262 PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2263 {
2264     PerlIO * const nexto = PerlIONext(o);
2265     if (PerlIOValid(nexto)) {
2266         const PerlIO_funcs * const tab = PerlIOBase(nexto)->tab;
2267         if (tab && tab->Dup)
2268             f = (*tab->Dup)(aTHX_ f, nexto, param, flags);
2269         else
2270             f = PerlIOBase_dup(aTHX_ f, nexto, param, flags);
2271     }
2272     if (f) {
2273         PerlIO_funcs * const self = PerlIOBase(o)->tab;
2274         SV *arg = NULL;
2275         char buf[8];
2276         PerlIO_debug("PerlIOBase_dup %s f=%p o=%p param=%p\n",
2277                      self->name, (void*)f, (void*)o, (void*)param);
2278         if (self->Getarg)
2279             arg = (*self->Getarg)(aTHX_ o, param, flags);
2280         f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
2281         if (PerlIOBase(o)->flags & PERLIO_F_UTF8)
2282             PerlIOBase(f)->flags |= PERLIO_F_UTF8;
2283         if (arg)
2284             SvREFCNT_dec(arg);
2285     }
2286     return f;
2287 }
2288
2289 /* PL_perlio_fd_refcnt[] is in intrpvar.h */
2290
2291 /* Must be called with PL_perlio_mutex locked. */
2292 static void
2293 S_more_refcounted_fds(pTHX_ const int new_fd) {
2294     dVAR;
2295     const int old_max = PL_perlio_fd_refcnt_size;
2296     const int new_max = 16 + (new_fd & ~15);
2297     int *new_array;
2298
2299     PerlIO_debug("More fds - old=%d, need %d, new=%d\n",
2300                  old_max, new_fd, new_max);
2301
2302     if (new_fd < old_max) {
2303         return;
2304     }
2305
2306     assert (new_max > new_fd);
2307
2308     /* Use plain realloc() since we need this memory to be really
2309      * global and visible to all the interpreters and/or threads. */
2310     new_array = (int*) realloc(PL_perlio_fd_refcnt, new_max * sizeof(int));
2311
2312     if (!new_array) {
2313 #ifdef USE_ITHREADS
2314         MUTEX_UNLOCK(&PL_perlio_mutex);
2315 #endif
2316         /* Can't use PerlIO to write as it allocates memory */
2317         PerlLIO_write(PerlIO_fileno(Perl_error_log),
2318                       PL_no_mem, strlen(PL_no_mem));
2319         my_exit(1);
2320     }
2321
2322     PL_perlio_fd_refcnt_size = new_max;
2323     PL_perlio_fd_refcnt = new_array;
2324
2325     PerlIO_debug("Zeroing %p, %d\n",
2326                  (void*)(new_array + old_max),
2327                  new_max - old_max);
2328
2329     Zero(new_array + old_max, new_max - old_max, int);
2330 }
2331
2332
2333 void
2334 PerlIO_init(pTHX)
2335 {
2336     /* MUTEX_INIT(&PL_perlio_mutex) is done in PERL_SYS_INIT3(). */
2337     PERL_UNUSED_CONTEXT;
2338 }
2339
2340 void
2341 PerlIOUnix_refcnt_inc(int fd)
2342 {
2343     dTHX;
2344     if (fd >= 0) {
2345         dVAR;
2346
2347 #ifdef USE_ITHREADS
2348         MUTEX_LOCK(&PL_perlio_mutex);
2349 #endif
2350         if (fd >= PL_perlio_fd_refcnt_size)
2351             S_more_refcounted_fds(aTHX_ fd);
2352
2353         PL_perlio_fd_refcnt[fd]++;
2354         if (PL_perlio_fd_refcnt[fd] <= 0) {
2355             Perl_croak(aTHX_ "refcnt_inc: fd %d: %d <= 0\n",
2356                        fd, PL_perlio_fd_refcnt[fd]);
2357         }
2358         PerlIO_debug("refcnt_inc: fd %d refcnt=%d\n",
2359                      fd, PL_perlio_fd_refcnt[fd]);
2360
2361 #ifdef USE_ITHREADS
2362         MUTEX_UNLOCK(&PL_perlio_mutex);
2363 #endif
2364     } else {
2365         Perl_croak(aTHX_ "refcnt_inc: fd %d < 0\n", fd);
2366     }
2367 }
2368
2369 int
2370 PerlIOUnix_refcnt_dec(int fd)
2371 {
2372     dTHX;
2373     int cnt = 0;
2374     if (fd >= 0) {
2375         dVAR;
2376 #ifdef USE_ITHREADS
2377         MUTEX_LOCK(&PL_perlio_mutex);
2378 #endif
2379         if (fd >= PL_perlio_fd_refcnt_size) {
2380             Perl_croak(aTHX_ "refcnt_dec: fd %d >= refcnt_size %d\n",
2381                        fd, PL_perlio_fd_refcnt_size);
2382         }
2383         if (PL_perlio_fd_refcnt[fd] <= 0) {
2384             Perl_croak(aTHX_ "refcnt_dec: fd %d: %d <= 0\n",
2385                        fd, PL_perlio_fd_refcnt[fd]);
2386         }
2387         cnt = --PL_perlio_fd_refcnt[fd];
2388         PerlIO_debug("refcnt_dec: fd %d refcnt=%d\n", fd, cnt);
2389 #ifdef USE_ITHREADS
2390         MUTEX_UNLOCK(&PL_perlio_mutex);
2391 #endif
2392     } else {
2393         Perl_croak(aTHX_ "refcnt_dec: fd %d < 0\n", fd);
2394     }
2395     return cnt;
2396 }
2397
2398 void
2399 PerlIO_cleanup(pTHX)
2400 {
2401     dVAR;
2402     int i;
2403 #ifdef USE_ITHREADS
2404     PerlIO_debug("Cleanup layers for %p\n",(void*)aTHX);
2405 #else
2406     PerlIO_debug("Cleanup layers\n");
2407 #endif
2408
2409     /* Raise STDIN..STDERR refcount so we don't close them */
2410     for (i=0; i < 3; i++)
2411         PerlIOUnix_refcnt_inc(i);
2412     PerlIO_cleantable(aTHX_ &PL_perlio);
2413     /* Restore STDIN..STDERR refcount */
2414     for (i=0; i < 3; i++)
2415         PerlIOUnix_refcnt_dec(i);
2416
2417     if (PL_known_layers) {
2418         PerlIO_list_free(aTHX_ PL_known_layers);
2419         PL_known_layers = NULL;
2420     }
2421     if (PL_def_layerlist) {
2422         PerlIO_list_free(aTHX_ PL_def_layerlist);
2423         PL_def_layerlist = NULL;
2424     }
2425 }
2426
2427 void PerlIO_teardown(void) /* Call only from PERL_SYS_TERM(). */
2428 {
2429     dVAR;
2430 #if 0
2431 /* XXX we can't rely on an interpreter being present at this late stage,
2432    XXX so we can't use a function like PerlLIO_write that relies on one
2433    being present (at least in win32) :-(.
2434    Disable for now.
2435 */
2436 #ifdef DEBUGGING
2437     {
2438         /* By now all filehandles should have been closed, so any
2439          * stray (non-STD-)filehandles indicate *possible* (PerlIO)
2440          * errors. */
2441 #define PERLIO_TEARDOWN_MESSAGE_BUF_SIZE 64
2442 #define PERLIO_TEARDOWN_MESSAGE_FD 2
2443         char buf[PERLIO_TEARDOWN_MESSAGE_BUF_SIZE];
2444         int i;
2445         for (i = 3; i < PL_perlio_fd_refcnt_size; i++) {
2446             if (PL_perlio_fd_refcnt[i]) {
2447                 const STRLEN len =
2448                     my_snprintf(buf, sizeof(buf),
2449                                 "PerlIO_teardown: fd %d refcnt=%d\n",
2450                                 i, PL_perlio_fd_refcnt[i]);
2451                 PerlLIO_write(PERLIO_TEARDOWN_MESSAGE_FD, buf, len);
2452             }
2453         }
2454     }
2455 #endif
2456 #endif
2457     /* Not bothering with PL_perlio_mutex since by now
2458      * all the interpreters are gone. */
2459     if (PL_perlio_fd_refcnt_size /* Assuming initial size of zero. */
2460         && PL_perlio_fd_refcnt) {
2461         free(PL_perlio_fd_refcnt); /* To match realloc() in S_more_refcounted_fds(). */
2462         PL_perlio_fd_refcnt = NULL;
2463         PL_perlio_fd_refcnt_size = 0;
2464     }
2465 }
2466
2467 /*--------------------------------------------------------------------------------------*/
2468 /*
2469  * Bottom-most level for UNIX-like case
2470  */
2471
2472 typedef struct {
2473     struct _PerlIO base;        /* The generic part */
2474     int fd;                     /* UNIX like file descriptor */
2475     int oflags;                 /* open/fcntl flags */
2476 } PerlIOUnix;
2477
2478 int
2479 PerlIOUnix_oflags(const char *mode)
2480 {
2481     int oflags = -1;
2482     if (*mode == IoTYPE_IMPLICIT || *mode == IoTYPE_NUMERIC)
2483         mode++;
2484     switch (*mode) {
2485     case 'r':
2486         oflags = O_RDONLY;
2487         if (*++mode == '+') {
2488             oflags = O_RDWR;
2489             mode++;
2490         }
2491         break;
2492
2493     case 'w':
2494         oflags = O_CREAT | O_TRUNC;
2495         if (*++mode == '+') {
2496             oflags |= O_RDWR;
2497             mode++;
2498         }
2499         else
2500             oflags |= O_WRONLY;
2501         break;
2502
2503     case 'a':
2504         oflags = O_CREAT | O_APPEND;
2505         if (*++mode == '+') {
2506             oflags |= O_RDWR;
2507             mode++;
2508         }
2509         else
2510             oflags |= O_WRONLY;
2511         break;
2512     }
2513     if (*mode == 'b') {
2514         oflags |= O_BINARY;
2515         oflags &= ~O_TEXT;
2516         mode++;
2517     }
2518     else if (*mode == 't') {
2519         oflags |= O_TEXT;
2520         oflags &= ~O_BINARY;
2521         mode++;
2522     }
2523     /*
2524      * Always open in binary mode
2525      */
2526     oflags |= O_BINARY;
2527     if (*mode || oflags == -1) {
2528         SETERRNO(EINVAL, LIB_INVARG);
2529         oflags = -1;
2530     }
2531     return oflags;
2532 }
2533
2534 IV
2535 PerlIOUnix_fileno(pTHX_ PerlIO *f)
2536 {
2537     PERL_UNUSED_CONTEXT;
2538     return PerlIOSelf(f, PerlIOUnix)->fd;
2539 }
2540
2541 static void
2542 PerlIOUnix_setfd(pTHX_ PerlIO *f, int fd, int imode)
2543 {
2544     PerlIOUnix * const s = PerlIOSelf(f, PerlIOUnix);
2545 #if defined(WIN32)
2546     Stat_t st;
2547     if (PerlLIO_fstat(fd, &st) == 0) {
2548         if (!S_ISREG(st.st_mode)) {
2549             PerlIO_debug("%d is not regular file\n",fd);
2550             PerlIOBase(f)->flags |= PERLIO_F_NOTREG;
2551         }
2552         else {
2553             PerlIO_debug("%d _is_ a regular file\n",fd);
2554         }
2555     }
2556 #endif
2557     s->fd = fd;
2558     s->oflags = imode;
2559     PerlIOUnix_refcnt_inc(fd);
2560     PERL_UNUSED_CONTEXT;
2561 }
2562
2563 IV
2564 PerlIOUnix_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2565 {
2566     IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2567     if (*PerlIONext(f)) {
2568         /* We never call down so do any pending stuff now */
2569         PerlIO_flush(PerlIONext(f));
2570         /*
2571          * XXX could (or should) we retrieve the oflags from the open file
2572          * handle rather than believing the "mode" we are passed in? XXX
2573          * Should the value on NULL mode be 0 or -1?
2574          */
2575         PerlIOUnix_setfd(aTHX_ f, PerlIO_fileno(PerlIONext(f)),
2576                          mode ? PerlIOUnix_oflags(mode) : -1);
2577     }
2578     PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2579
2580     return code;
2581 }
2582
2583 IV
2584 PerlIOUnix_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
2585 {
2586     const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2587     Off_t new_loc;
2588     PERL_UNUSED_CONTEXT;
2589     if (PerlIOBase(f)->flags & PERLIO_F_NOTREG) {
2590 #ifdef  ESPIPE
2591         SETERRNO(ESPIPE, LIB_INVARG);
2592 #else
2593         SETERRNO(EINVAL, LIB_INVARG);
2594 #endif
2595         return -1;
2596     }
2597     new_loc = PerlLIO_lseek(fd, offset, whence);
2598     if (new_loc == (Off_t) - 1)
2599         return -1;
2600     PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
2601     return  0;
2602 }
2603
2604 PerlIO *
2605 PerlIOUnix_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2606                 IV n, const char *mode, int fd, int imode,
2607                 int perm, PerlIO *f, int narg, SV **args)
2608 {
2609     if (PerlIOValid(f)) {
2610         if (PerlIOBase(f)->flags & PERLIO_F_OPEN)
2611             (*PerlIOBase(f)->tab->Close)(aTHX_ f);
2612     }
2613     if (narg > 0) {
2614         if (*mode == IoTYPE_NUMERIC)
2615             mode++;
2616         else {
2617             imode = PerlIOUnix_oflags(mode);
2618             perm = 0666;
2619         }
2620         if (imode != -1) {
2621             const char *path = SvPV_nolen_const(*args);
2622             fd = PerlLIO_open3(path, imode, perm);
2623         }
2624     }
2625     if (fd >= 0) {
2626         if (*mode == IoTYPE_IMPLICIT)
2627             mode++;
2628         if (!f) {
2629             f = PerlIO_allocate(aTHX);
2630         }
2631         if (!PerlIOValid(f)) {
2632             if (!(f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2633                 return NULL;
2634             }
2635         }
2636         PerlIOUnix_setfd(aTHX_ f, fd, imode);
2637         PerlIOBase(f)->flags |= PERLIO_F_OPEN;
2638         if (*mode == IoTYPE_APPEND)
2639             PerlIOUnix_seek(aTHX_ f, 0, SEEK_END);
2640         return f;
2641     }
2642     else {
2643         if (f) {
2644             NOOP;
2645             /*
2646              * FIXME: pop layers ???
2647              */
2648         }
2649         return NULL;
2650     }
2651 }
2652
2653 PerlIO *
2654 PerlIOUnix_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
2655 {
2656     const PerlIOUnix * const os = PerlIOSelf(o, PerlIOUnix);
2657     int fd = os->fd;
2658     if (flags & PERLIO_DUP_FD) {
2659         fd = PerlLIO_dup(fd);
2660     }
2661     if (fd >= 0) {
2662         f = PerlIOBase_dup(aTHX_ f, o, param, flags);
2663         if (f) {
2664             /* If all went well overwrite fd in dup'ed lay with the dup()'ed fd */
2665             PerlIOUnix_setfd(aTHX_ f, fd, os->oflags);
2666             return f;
2667         }
2668     }
2669     return NULL;
2670 }
2671
2672
2673 SSize_t
2674 PerlIOUnix_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
2675 {
2676     dVAR;
2677     const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2678 #ifdef PERLIO_STD_SPECIAL
2679     if (fd == 0)
2680         return PERLIO_STD_IN(fd, vbuf, count);
2681 #endif
2682     if (!(PerlIOBase(f)->flags & PERLIO_F_CANREAD) ||
2683          PerlIOBase(f)->flags & (PERLIO_F_EOF|PERLIO_F_ERROR)) {
2684         return 0;
2685     }
2686     while (1) {
2687         const SSize_t len = PerlLIO_read(fd, vbuf, count);
2688         if (len >= 0 || errno != EINTR) {
2689             if (len < 0) {
2690                 if (errno != EAGAIN) {
2691                     PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2692                 }
2693             }
2694             else if (len == 0 && count != 0) {
2695                 PerlIOBase(f)->flags |= PERLIO_F_EOF;
2696                 SETERRNO(0,0);
2697             }
2698             return len;
2699         }
2700         PERL_ASYNC_CHECK();
2701     }
2702     /*NOTREACHED*/
2703 }
2704
2705 SSize_t
2706 PerlIOUnix_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
2707 {
2708     dVAR;
2709     const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2710 #ifdef PERLIO_STD_SPECIAL
2711     if (fd == 1 || fd == 2)
2712         return PERLIO_STD_OUT(fd, vbuf, count);
2713 #endif
2714     while (1) {
2715         const SSize_t len = PerlLIO_write(fd, vbuf, count);
2716         if (len >= 0 || errno != EINTR) {
2717             if (len < 0) {
2718                 if (errno != EAGAIN) {
2719                     PerlIOBase(f)->flags |= PERLIO_F_ERROR;
2720                 }
2721             }
2722             return len;
2723         }
2724         PERL_ASYNC_CHECK();
2725     }
2726     /*NOTREACHED*/
2727 }
2728
2729 Off_t
2730 PerlIOUnix_tell(pTHX_ PerlIO *f)
2731 {
2732     PERL_UNUSED_CONTEXT;
2733
2734     return PerlLIO_lseek(PerlIOSelf(f, PerlIOUnix)->fd, 0, SEEK_CUR);
2735 }
2736
2737
2738 IV
2739 PerlIOUnix_close(pTHX_ PerlIO *f)
2740 {
2741     dVAR;
2742     const int fd = PerlIOSelf(f, PerlIOUnix)->fd;
2743     int code = 0;
2744     if (PerlIOBase(f)->flags & PERLIO_F_OPEN) {
2745         if (PerlIOUnix_refcnt_dec(fd) > 0) {
2746             PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2747             return 0;
2748         }
2749     }
2750     else {
2751         SETERRNO(EBADF,SS_IVCHAN);
2752         return -1;
2753     }
2754     while (PerlLIO_close(fd) != 0) {
2755         if (errno != EINTR) {
2756             code = -1;
2757             break;
2758         }
2759         PERL_ASYNC_CHECK();
2760     }
2761     if (code == 0) {
2762         PerlIOBase(f)->flags &= ~PERLIO_F_OPEN;
2763     }
2764     return code;
2765 }
2766
2767 PERLIO_FUNCS_DECL(PerlIO_unix) = {
2768     sizeof(PerlIO_funcs),
2769     "unix",
2770     sizeof(PerlIOUnix),
2771     PERLIO_K_RAW,
2772     PerlIOUnix_pushed,
2773     PerlIOBase_popped,
2774     PerlIOUnix_open,
2775     PerlIOBase_binmode,         /* binmode */
2776     NULL,
2777     PerlIOUnix_fileno,
2778     PerlIOUnix_dup,
2779     PerlIOUnix_read,
2780     PerlIOBase_unread,
2781     PerlIOUnix_write,
2782     PerlIOUnix_seek,
2783     PerlIOUnix_tell,
2784     PerlIOUnix_close,
2785     PerlIOBase_noop_ok,         /* flush */
2786     PerlIOBase_noop_fail,       /* fill */
2787     PerlIOBase_eof,
2788     PerlIOBase_error,
2789     PerlIOBase_clearerr,
2790     PerlIOBase_setlinebuf,
2791     NULL,                       /* get_base */
2792     NULL,                       /* get_bufsiz */
2793     NULL,                       /* get_ptr */
2794     NULL,                       /* get_cnt */
2795     NULL,                       /* set_ptrcnt */
2796 };
2797
2798 /*--------------------------------------------------------------------------------------*/
2799 /*
2800  * stdio as a layer
2801  */
2802
2803 #if defined(VMS) && !defined(STDIO_BUFFER_WRITABLE)
2804 /* perl5.8 - This ensures the last minute VMS ungetc fix is not
2805    broken by the last second glibc 2.3 fix
2806  */
2807 #define STDIO_BUFFER_WRITABLE
2808 #endif
2809
2810
2811 typedef struct {
2812     struct _PerlIO base;
2813     FILE *stdio;                /* The stream */
2814 } PerlIOStdio;
2815
2816 IV
2817 PerlIOStdio_fileno(pTHX_ PerlIO *f)
2818 {
2819     PERL_UNUSED_CONTEXT;
2820
2821     if (PerlIOValid(f)) {
2822         FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
2823         if (s)
2824             return PerlSIO_fileno(s);
2825     }
2826     errno = EBADF;
2827     return -1;
2828 }
2829
2830 char *
2831 PerlIOStdio_mode(const char *mode, char *tmode)
2832 {
2833     char * const ret = tmode;
2834     if (mode) {
2835         while (*mode) {
2836             *tmode++ = *mode++;
2837         }
2838     }
2839 #if defined(PERLIO_USING_CRLF) || defined(__CYGWIN__)
2840     *tmode++ = 'b';
2841 #endif
2842     *tmode = '\0';
2843     return ret;
2844 }
2845
2846 IV
2847 PerlIOStdio_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
2848 {
2849     PerlIO *n;
2850     if (PerlIOValid(f) && PerlIOValid(n = PerlIONext(f))) {
2851         PerlIO_funcs * const toptab = PerlIOBase(n)->tab;
2852         if (toptab == tab) {
2853             /* Top is already stdio - pop self (duplicate) and use original */
2854             PerlIO_pop(aTHX_ f);
2855             return 0;
2856         } else {
2857             const int fd = PerlIO_fileno(n);
2858             char tmode[8];
2859             FILE *stdio;
2860             if (fd >= 0 && (stdio  = PerlSIO_fdopen(fd,
2861                             mode = PerlIOStdio_mode(mode, tmode)))) {
2862                 PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2863                 /* We never call down so do any pending stuff now */
2864                 PerlIO_flush(PerlIONext(f));
2865             }
2866             else {
2867                 return -1;
2868             }
2869         }
2870     }
2871     return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
2872 }
2873
2874
2875 PerlIO *
2876 PerlIO_importFILE(FILE *stdio, const char *mode)
2877 {
2878     dTHX;
2879     PerlIO *f = NULL;
2880     if (stdio) {
2881         PerlIOStdio *s;
2882         if (!mode || !*mode) {
2883             /* We need to probe to see how we can open the stream
2884                so start with read/write and then try write and read
2885                we dup() so that we can fclose without loosing the fd.
2886
2887                Note that the errno value set by a failing fdopen
2888                varies between stdio implementations.
2889              */
2890             const int fd = PerlLIO_dup(fileno(stdio));
2891             FILE *f2 = PerlSIO_fdopen(fd, (mode = "r+"));
2892             if (!f2) {
2893                 f2 = PerlSIO_fdopen(fd, (mode = "w"));
2894             }
2895             if (!f2) {
2896                 f2 = PerlSIO_fdopen(fd, (mode = "r"));
2897             }
2898             if (!f2) {
2899                 /* Don't seem to be able to open */
2900                 PerlLIO_close(fd);
2901                 return f;
2902             }
2903             fclose(f2);
2904         }
2905         if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
2906             s = PerlIOSelf(f, PerlIOStdio);
2907             s->stdio = stdio;
2908             PerlIOUnix_refcnt_inc(fileno(stdio));
2909         }
2910     }
2911     return f;
2912 }
2913
2914 PerlIO *
2915 PerlIOStdio_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
2916                  IV n, const char *mode, int fd, int imode,
2917                  int perm, PerlIO *f, int narg, SV **args)
2918 {
2919     char tmode[8];
2920     if (PerlIOValid(f)) {
2921         const char * const path = SvPV_nolen_const(*args);
2922         PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
2923         FILE *stdio;
2924         PerlIOUnix_refcnt_dec(fileno(s->stdio));
2925         stdio = PerlSIO_freopen(path, (mode = PerlIOStdio_mode(mode, tmode)),
2926                             s->stdio);
2927         if (!s->stdio)
2928             return NULL;
2929         s->stdio = stdio;
2930         PerlIOUnix_refcnt_inc(fileno(s->stdio));
2931         return f;
2932     }
2933     else {
2934         if (narg > 0) {
2935             const char * const path = SvPV_nolen_const(*args);
2936             if (*mode == IoTYPE_NUMERIC) {
2937                 mode++;
2938                 fd = PerlLIO_open3(path, imode, perm);
2939             }
2940             else {
2941                 FILE *stdio;
2942                 bool appended = FALSE;
2943 #ifdef __CYGWIN__
2944                 /* Cygwin wants its 'b' early. */
2945                 appended = TRUE;
2946                 mode = PerlIOStdio_mode(mode, tmode);
2947 #endif
2948                 stdio = PerlSIO_fopen(path, mode);
2949                 if (stdio) {
2950                     if (!f) {
2951                         f = PerlIO_allocate(aTHX);
2952                     }
2953                     if (!appended)
2954                         mode = PerlIOStdio_mode(mode, tmode);
2955                     f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg);
2956                     if (f) {
2957                         PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2958                         PerlIOUnix_refcnt_inc(fileno(stdio));
2959                     } else {
2960                         PerlSIO_fclose(stdio);
2961                     }
2962                     return f;
2963                 }
2964                 else {
2965                     return NULL;
2966                 }
2967             }
2968         }
2969         if (fd >= 0) {
2970             FILE *stdio = NULL;
2971             int init = 0;
2972             if (*mode == IoTYPE_IMPLICIT) {
2973                 init = 1;
2974                 mode++;
2975             }
2976             if (init) {
2977                 switch (fd) {
2978                 case 0:
2979                     stdio = PerlSIO_stdin;
2980                     break;
2981                 case 1:
2982                     stdio = PerlSIO_stdout;
2983                     break;
2984                 case 2:
2985                     stdio = PerlSIO_stderr;
2986                     break;
2987                 }
2988             }
2989             else {
2990                 stdio = PerlSIO_fdopen(fd, mode =
2991                                        PerlIOStdio_mode(mode, tmode));
2992             }
2993             if (stdio) {
2994                 if (!f) {
2995                     f = PerlIO_allocate(aTHX);
2996                 }
2997                 if ((f = PerlIO_push(aTHX_ f, self, mode, PerlIOArg))) {
2998                     PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
2999                     PerlIOUnix_refcnt_inc(fileno(stdio));
3000                 }
3001                 return f;
3002             }
3003         }
3004     }
3005     return NULL;
3006 }
3007
3008 PerlIO *
3009 PerlIOStdio_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
3010 {
3011     /* This assumes no layers underneath - which is what
3012        happens, but is not how I remember it. NI-S 2001/10/16
3013      */
3014     if ((f = PerlIOBase_dup(aTHX_ f, o, param, flags))) {
3015         FILE *stdio = PerlIOSelf(o, PerlIOStdio)->stdio;
3016         const int fd = fileno(stdio);
3017         char mode[8];
3018         if (flags & PERLIO_DUP_FD) {
3019             const int dfd = PerlLIO_dup(fileno(stdio));
3020             if (dfd >= 0) {
3021                 stdio = PerlSIO_fdopen(dfd, PerlIO_modestr(o,mode));
3022                 goto set_this;
3023             }
3024             else {
3025                 NOOP;
3026                 /* FIXME: To avoid messy error recovery if dup fails
3027                    re-use the existing stdio as though flag was not set
3028                  */
3029             }
3030         }
3031         stdio = PerlSIO_fdopen(fd, PerlIO_modestr(o,mode));
3032     set_this:
3033         PerlIOSelf(f, PerlIOStdio)->stdio = stdio;
3034         PerlIOUnix_refcnt_inc(fileno(stdio));
3035     }
3036     return f;
3037 }
3038
3039 static int
3040 PerlIOStdio_invalidate_fileno(pTHX_ FILE *f)
3041 {
3042     PERL_UNUSED_CONTEXT;
3043
3044     /* XXX this could use PerlIO_canset_fileno() and
3045      * PerlIO_set_fileno() support from Configure
3046      */
3047 #  if defined(__UCLIBC__)
3048     /* uClibc must come before glibc because it defines __GLIBC__ as well. */
3049     f->__filedes = -1;
3050     return 1;
3051 #  elif defined(__GLIBC__)
3052     /* There may be a better way for GLIBC:
3053         - libio.h defines a flag to not close() on cleanup
3054      */ 
3055     f->_fileno = -1;
3056     return 1;
3057 #  elif defined(__sun__)
3058     PERL_UNUSED_ARG(f);
3059     return 0;
3060 #  elif defined(__hpux)
3061     f->__fileH = 0xff;
3062     f->__fileL = 0xff;
3063     return 1;
3064    /* Next one ->_file seems to be a reasonable fallback, i.e. if
3065       your platform does not have special entry try this one.
3066       [For OSF only have confirmation for Tru64 (alpha)
3067       but assume other OSFs will be similar.]
3068     */
3069 #  elif defined(_AIX) || defined(__osf__) || defined(__irix__)
3070     f->_file = -1;
3071     return 1;
3072 #  elif defined(__FreeBSD__)
3073     /* There may be a better way on FreeBSD:
3074         - we could insert a dummy func in the _close function entry
3075         f->_close = (int (*)(void *)) dummy_close;
3076      */
3077     f->_file = -1;
3078     return 1;
3079 #  elif defined(__OpenBSD__)
3080     /* There may be a better way on OpenBSD:
3081         - we could insert a dummy func in the _close function entry
3082         f->_close = (int (*)(void *)) dummy_close;
3083      */
3084     f->_file = -1;
3085     return 1;
3086 #  elif defined(__EMX__)
3087     /* f->_flags &= ~_IOOPEN; */        /* Will leak stream->_buffer */
3088     f->_handle = -1;
3089     return 1;
3090 #  elif defined(__CYGWIN__)
3091     /* There may be a better way on CYGWIN:
3092         - we could insert a dummy func in the _close function entry
3093         f->_close = (int (*)(void *)) dummy_close;
3094      */
3095     f->_file = -1;
3096     return 1;
3097 #  elif defined(WIN32)
3098 #    if defined(__BORLANDC__)
3099     f->fd = PerlLIO_dup(fileno(f));
3100 #    elif defined(UNDER_CE)
3101     /* WIN_CE does not have access to FILE internals, it hardly has FILE
3102        structure at all
3103      */
3104 #    else
3105     f->_file = -1;
3106 #    endif
3107     return 1;
3108 #  else
3109 #if 0
3110     /* Sarathy's code did this - we fall back to a dup/dup2 hack
3111        (which isn't thread safe) instead
3112      */
3113 #    error "Don't know how to set FILE.fileno on your platform"
3114 #endif
3115     PERL_UNUSED_ARG(f);
3116     return 0;
3117 #  endif
3118 }
3119
3120 IV
3121 PerlIOStdio_close(pTHX_ PerlIO *f)
3122 {
3123     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3124     if (!stdio) {
3125         errno = EBADF;
3126         return -1;
3127     }
3128     else {
3129         const int fd = fileno(stdio);
3130         int invalidate = 0;
3131         IV result = 0;
3132         int saveerr = 0;
3133         int dupfd = -1;
3134 #ifdef SOCKS5_VERSION_NAME
3135         /* Socks lib overrides close() but stdio isn't linked to
3136            that library (though we are) - so we must call close()
3137            on sockets on stdio's behalf.
3138          */
3139         int optval;
3140         Sock_size_t optlen = sizeof(int);
3141         if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (void *) &optval, &optlen) == 0)
3142             invalidate = 1;
3143 #endif
3144         if (PerlIOUnix_refcnt_dec(fd) > 0) /* File descriptor still in use */
3145             invalidate = 1;
3146         if (invalidate) {
3147             /* For STD* handles, don't close stdio, since we shared the FILE *, too. */
3148             if (stdio == stdin) /* Some stdios are buggy fflush-ing inputs */
3149                 return 0;
3150             if (stdio == stdout || stdio == stderr)
3151                 return PerlIO_flush(f);
3152             /* Tricky - must fclose(stdio) to free memory but not close(fd)
3153                Use Sarathy's trick from maint-5.6 to invalidate the
3154                fileno slot of the FILE *
3155             */
3156             result = PerlIO_flush(f);
3157             saveerr = errno;
3158             invalidate = PerlIOStdio_invalidate_fileno(aTHX_ stdio);
3159             if (!invalidate) {
3160 #ifdef USE_ITHREADS
3161                 MUTEX_LOCK(&PL_perlio_mutex);
3162                 /* Right. We need a mutex here because for a brief while we
3163                    will have the situation that fd is actually closed. Hence if
3164                    a second thread were to get into this block, its dup() would
3165                    likely return our fd as its dupfd. (after all, it is closed)
3166                    Then if we get to the dup2() first, we blat the fd back
3167                    (messing up its temporary as a side effect) only for it to
3168                    then close its dupfd (== our fd) in its close(dupfd) */
3169
3170                 /* There is, of course, a race condition, that any other thread
3171                    trying to input/output/whatever on this fd will be stuffed
3172                    for the duration of this little manoeuvrer. Perhaps we
3173                    should hold an IO mutex for the duration of every IO
3174                    operation if we know that invalidate doesn't work on this
3175                    platform, but that would suck, and could kill performance.
3176
3177                    Except that correctness trumps speed.
3178                    Advice from klortho #11912. */
3179 #endif
3180                 dupfd = PerlLIO_dup(fd);
3181 #ifdef USE_ITHREADS
3182                 if (dupfd < 0) {
3183                     MUTEX_UNLOCK(&PL_perlio_mutex);
3184                     /* Oh cXap. This isn't going to go well. Not sure if we can
3185                        recover from here, or if closing this particular FILE *
3186                        is a good idea now.  */
3187                 }
3188 #endif
3189             }
3190         }
3191         result = PerlSIO_fclose(stdio);
3192         /* We treat error from stdio as success if we invalidated
3193            errno may NOT be expected EBADF
3194          */
3195         if (invalidate && result != 0) {
3196             errno = saveerr;
3197             result = 0;
3198         }
3199 #ifdef SOCKS5_VERSION_NAME
3200         /* in SOCKS' case, let close() determine return value */
3201         result = close(fd);
3202 #endif
3203         if (dupfd >= 0) {
3204             PerlLIO_dup2(dupfd,fd);
3205             PerlLIO_close(dupfd);
3206 #ifdef USE_ITHREADS
3207             MUTEX_UNLOCK(&PL_perlio_mutex);
3208 #endif
3209         }
3210         return result;
3211     }
3212 }
3213
3214 SSize_t
3215 PerlIOStdio_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3216 {
3217     dVAR;
3218     FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3219     SSize_t got = 0;
3220     for (;;) {
3221         if (count == 1) {
3222             STDCHAR *buf = (STDCHAR *) vbuf;
3223             /*
3224              * Perl is expecting PerlIO_getc() to fill the buffer Linux's
3225              * stdio does not do that for fread()
3226              */
3227             const int ch = PerlSIO_fgetc(s);
3228             if (ch != EOF) {
3229                 *buf = ch;
3230                 got = 1;
3231             }
3232         }
3233         else
3234             got = PerlSIO_fread(vbuf, 1, count, s);
3235         if (got == 0 && PerlSIO_ferror(s))
3236             got = -1;
3237         if (got >= 0 || errno != EINTR)
3238             break;
3239         PERL_ASYNC_CHECK();
3240         SETERRNO(0,0);  /* just in case */
3241     }
3242     return got;
3243 }
3244
3245 SSize_t
3246 PerlIOStdio_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3247 {
3248     SSize_t unread = 0;
3249     FILE * const s = PerlIOSelf(f, PerlIOStdio)->stdio;
3250
3251 #ifdef STDIO_BUFFER_WRITABLE
3252     if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3253         STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3254         STDCHAR *base = PerlIO_get_base(f);
3255         SSize_t cnt   = PerlIO_get_cnt(f);
3256         STDCHAR *ptr  = PerlIO_get_ptr(f);
3257         SSize_t avail = ptr - base;
3258         if (avail > 0) {
3259             if (avail > count) {
3260                 avail = count;
3261             }
3262             ptr -= avail;
3263             Move(buf-avail,ptr,avail,STDCHAR);
3264             count -= avail;
3265             unread += avail;
3266             PerlIO_set_ptrcnt(f,ptr,cnt+avail);
3267             if (PerlSIO_feof(s) && unread >= 0)
3268                 PerlSIO_clearerr(s);
3269         }
3270     }
3271     else
3272 #endif
3273     if (PerlIO_has_cntptr(f)) {
3274         /* We can get pointer to buffer but not its base
3275            Do ungetc() but check chars are ending up in the
3276            buffer
3277          */
3278         STDCHAR *eptr = (STDCHAR*)PerlSIO_get_ptr(s);
3279         STDCHAR *buf = ((STDCHAR *) vbuf) + count;
3280         while (count > 0) {
3281             const int ch = *--buf & 0xFF;
3282             if (ungetc(ch,s) != ch) {
3283                 /* ungetc did not work */
3284                 break;
3285             }
3286             if ((STDCHAR*)PerlSIO_get_ptr(s) != --eptr || ((*eptr & 0xFF) != ch)) {
3287                 /* Did not change pointer as expected */
3288                 fgetc(s);  /* get char back again */
3289                 break;
3290             }
3291             /* It worked ! */
3292             count--;
3293             unread++;
3294         }
3295     }
3296
3297     if (count > 0) {
3298         unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3299     }
3300     return unread;
3301 }
3302
3303 SSize_t
3304 PerlIOStdio_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3305 {
3306     dVAR;
3307     SSize_t got;
3308     for (;;) {
3309         got = PerlSIO_fwrite(vbuf, 1, count,
3310                               PerlIOSelf(f, PerlIOStdio)->stdio);
3311         if (got >= 0 || errno != EINTR)
3312             break;
3313         PERL_ASYNC_CHECK();
3314         SETERRNO(0,0);  /* just in case */
3315     }
3316     return got;
3317 }
3318
3319 IV
3320 PerlIOStdio_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
3321 {
3322     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3323     PERL_UNUSED_CONTEXT;
3324
3325     return PerlSIO_fseek(stdio, offset, whence);
3326 }
3327
3328 Off_t
3329 PerlIOStdio_tell(pTHX_ PerlIO *f)
3330 {
3331     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3332     PERL_UNUSED_CONTEXT;
3333
3334     return PerlSIO_ftell(stdio);
3335 }
3336
3337 IV
3338 PerlIOStdio_flush(pTHX_ PerlIO *f)
3339 {
3340     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3341     PERL_UNUSED_CONTEXT;
3342
3343     if (PerlIOBase(f)->flags & PERLIO_F_CANWRITE) {
3344         return PerlSIO_fflush(stdio);
3345     }
3346     else {
3347         NOOP;
3348 #if 0
3349         /*
3350          * FIXME: This discards ungetc() and pre-read stuff which is not
3351          * right if this is just a "sync" from a layer above Suspect right
3352          * design is to do _this_ but not have layer above flush this
3353          * layer read-to-read
3354          */
3355         /*
3356          * Not writeable - sync by attempting a seek
3357          */
3358         const int err = errno;
3359         if (PerlSIO_fseek(stdio, (Off_t) 0, SEEK_CUR) != 0)
3360             errno = err;
3361 #endif
3362     }
3363     return 0;
3364 }
3365
3366 IV
3367 PerlIOStdio_eof(pTHX_ PerlIO *f)
3368 {
3369     PERL_UNUSED_CONTEXT;
3370
3371     return PerlSIO_feof(PerlIOSelf(f, PerlIOStdio)->stdio);
3372 }
3373
3374 IV
3375 PerlIOStdio_error(pTHX_ PerlIO *f)
3376 {
3377     PERL_UNUSED_CONTEXT;
3378
3379     return PerlSIO_ferror(PerlIOSelf(f, PerlIOStdio)->stdio);
3380 }
3381
3382 void
3383 PerlIOStdio_clearerr(pTHX_ PerlIO *f)
3384 {
3385     PERL_UNUSED_CONTEXT;
3386
3387     PerlSIO_clearerr(PerlIOSelf(f, PerlIOStdio)->stdio);
3388 }
3389
3390 void
3391 PerlIOStdio_setlinebuf(pTHX_ PerlIO *f)
3392 {
3393     PERL_UNUSED_CONTEXT;
3394
3395 #ifdef HAS_SETLINEBUF
3396     PerlSIO_setlinebuf(PerlIOSelf(f, PerlIOStdio)->stdio);
3397 #else
3398     PerlSIO_setvbuf(PerlIOSelf(f, PerlIOStdio)->stdio, NULL, _IOLBF, 0);
3399 #endif
3400 }
3401
3402 #ifdef FILE_base
3403 STDCHAR *
3404 PerlIOStdio_get_base(pTHX_ PerlIO *f)
3405 {
3406     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3407     return (STDCHAR*)PerlSIO_get_base(stdio);
3408 }
3409
3410 Size_t
3411 PerlIOStdio_get_bufsiz(pTHX_ PerlIO *f)
3412 {
3413     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3414     return PerlSIO_get_bufsiz(stdio);
3415 }
3416 #endif
3417
3418 #ifdef USE_STDIO_PTR
3419 STDCHAR *
3420 PerlIOStdio_get_ptr(pTHX_ PerlIO *f)
3421 {
3422     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3423     return (STDCHAR*)PerlSIO_get_ptr(stdio);
3424 }
3425
3426 SSize_t
3427 PerlIOStdio_get_cnt(pTHX_ PerlIO *f)
3428 {
3429     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3430     return PerlSIO_get_cnt(stdio);
3431 }
3432
3433 void
3434 PerlIOStdio_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
3435 {
3436     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3437     if (ptr != NULL) {
3438 #ifdef STDIO_PTR_LVALUE
3439         PerlSIO_set_ptr(stdio, ptr); /* LHS STDCHAR* cast non-portable */
3440 #ifdef STDIO_PTR_LVAL_SETS_CNT
3441         assert(PerlSIO_get_cnt(stdio) == (cnt));
3442 #endif
3443 #if (!defined(STDIO_PTR_LVAL_NOCHANGE_CNT))
3444         /*
3445          * Setting ptr _does_ change cnt - we are done
3446          */
3447         return;
3448 #endif
3449 #else                           /* STDIO_PTR_LVALUE */
3450         PerlProc_abort();
3451 #endif                          /* STDIO_PTR_LVALUE */
3452     }
3453     /*
3454      * Now (or only) set cnt
3455      */
3456 #ifdef STDIO_CNT_LVALUE
3457     PerlSIO_set_cnt(stdio, cnt);
3458 #else                           /* STDIO_CNT_LVALUE */
3459 #if (defined(STDIO_PTR_LVALUE) && defined(STDIO_PTR_LVAL_SETS_CNT))
3460     PerlSIO_set_ptr(stdio,
3461                     PerlSIO_get_ptr(stdio) + (PerlSIO_get_cnt(stdio) -
3462                                               cnt));
3463 #else                           /* STDIO_PTR_LVAL_SETS_CNT */
3464     PerlProc_abort();
3465 #endif                          /* STDIO_PTR_LVAL_SETS_CNT */
3466 #endif                          /* STDIO_CNT_LVALUE */
3467 }
3468
3469
3470 #endif
3471
3472 IV
3473 PerlIOStdio_fill(pTHX_ PerlIO *f)
3474 {
3475     FILE * const stdio = PerlIOSelf(f, PerlIOStdio)->stdio;
3476     int c;
3477     PERL_UNUSED_CONTEXT;
3478
3479     /*
3480      * fflush()ing read-only streams can cause trouble on some stdio-s
3481      */
3482     if ((PerlIOBase(f)->flags & PERLIO_F_CANWRITE)) {
3483         if (PerlSIO_fflush(stdio) != 0)
3484             return EOF;
3485     }
3486     for (;;) {
3487         c = PerlSIO_fgetc(stdio);
3488         if (c != EOF)
3489             break;
3490         if (! PerlSIO_ferror(stdio) || errno != EINTR)
3491             return EOF;
3492         PERL_ASYNC_CHECK();
3493         SETERRNO(0,0);
3494     }
3495
3496 #if (defined(STDIO_PTR_LVALUE) && (defined(STDIO_CNT_LVALUE) || defined(STDIO_PTR_LVAL_SETS_CNT)))
3497
3498 #ifdef STDIO_BUFFER_WRITABLE
3499     if (PerlIO_fast_gets(f) && PerlIO_has_base(f)) {
3500         /* Fake ungetc() to the real buffer in case system's ungetc
3501            goes elsewhere
3502          */
3503         STDCHAR *base = (STDCHAR*)PerlSIO_get_base(stdio);
3504         SSize_t cnt   = PerlSIO_get_cnt(stdio);
3505         STDCHAR *ptr  = (STDCHAR*)PerlSIO_get_ptr(stdio);
3506         if (ptr == base+1) {
3507             *--ptr = (STDCHAR) c;
3508             PerlIOStdio_set_ptrcnt(aTHX_ f,ptr,cnt+1);
3509             if (PerlSIO_feof(stdio))
3510                 PerlSIO_clearerr(stdio);
3511             return 0;
3512         }
3513     }
3514     else
3515 #endif
3516     if (PerlIO_has_cntptr(f)) {
3517         STDCHAR ch = c;
3518         if (PerlIOStdio_unread(aTHX_ f,&ch,1) == 1) {
3519             return 0;
3520         }
3521     }
3522 #endif
3523
3524 #if defined(VMS)
3525     /* An ungetc()d char is handled separately from the regular
3526      * buffer, so we stuff it in the buffer ourselves.
3527      * Should never get called as should hit code above
3528      */
3529     *(--((*stdio)->_ptr)) = (unsigned char) c;
3530     (*stdio)->_cnt++;
3531 #else
3532     /* If buffer snoop scheme above fails fall back to
3533        using ungetc().
3534      */
3535     if (PerlSIO_ungetc(c, stdio) != c)
3536         return EOF;
3537 #endif
3538     return 0;
3539 }
3540
3541
3542
3543 PERLIO_FUNCS_DECL(PerlIO_stdio) = {
3544     sizeof(PerlIO_funcs),
3545     "stdio",
3546     sizeof(PerlIOStdio),
3547     PERLIO_K_BUFFERED|PERLIO_K_RAW,
3548     PerlIOStdio_pushed,
3549     PerlIOBase_popped,
3550     PerlIOStdio_open,
3551     PerlIOBase_binmode,         /* binmode */
3552     NULL,
3553     PerlIOStdio_fileno,
3554     PerlIOStdio_dup,
3555     PerlIOStdio_read,
3556     PerlIOStdio_unread,
3557     PerlIOStdio_write,
3558     PerlIOStdio_seek,
3559     PerlIOStdio_tell,
3560     PerlIOStdio_close,
3561     PerlIOStdio_flush,
3562     PerlIOStdio_fill,
3563     PerlIOStdio_eof,
3564     PerlIOStdio_error,
3565     PerlIOStdio_clearerr,
3566     PerlIOStdio_setlinebuf,
3567 #ifdef FILE_base
3568     PerlIOStdio_get_base,
3569     PerlIOStdio_get_bufsiz,
3570 #else
3571     NULL,
3572     NULL,
3573 #endif
3574 #ifdef USE_STDIO_PTR
3575     PerlIOStdio_get_ptr,
3576     PerlIOStdio_get_cnt,
3577 #   if defined(HAS_FAST_STDIO) && defined(USE_FAST_STDIO)
3578     PerlIOStdio_set_ptrcnt,
3579 #   else
3580     NULL,
3581 #   endif /* HAS_FAST_STDIO && USE_FAST_STDIO */
3582 #else
3583     NULL,
3584     NULL,
3585     NULL,
3586 #endif /* USE_STDIO_PTR */
3587 };
3588
3589 /* Note that calls to PerlIO_exportFILE() are reversed using
3590  * PerlIO_releaseFILE(), not importFILE. */
3591 FILE *
3592 PerlIO_exportFILE(PerlIO * f, const char *mode)
3593 {
3594     dTHX;
3595     FILE *stdio = NULL;
3596     if (PerlIOValid(f)) {
3597         char buf[8];
3598         PerlIO_flush(f);
3599         if (!mode || !*mode) {
3600             mode = PerlIO_modestr(f, buf);
3601         }
3602         stdio = PerlSIO_fdopen(PerlIO_fileno(f), mode);
3603         if (stdio) {
3604             PerlIOl *l = *f;
3605             PerlIO *f2;
3606             /* De-link any lower layers so new :stdio sticks */
3607             *f = NULL;
3608             if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
3609                 PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
3610                 s->stdio = stdio;
3611                 PerlIOUnix_refcnt_inc(fileno(stdio));
3612                 /* Link previous lower layers under new one */
3613                 *PerlIONext(f) = l;
3614             }
3615             else {
3616                 /* restore layers list */
3617                 *f = l;
3618             }
3619         }
3620     }
3621     return stdio;
3622 }
3623
3624
3625 FILE *
3626 PerlIO_findFILE(PerlIO *f)
3627 {
3628     PerlIOl *l = *f;
3629     FILE *stdio;
3630     while (l) {
3631         if (l->tab == &PerlIO_stdio) {
3632             PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3633             return s->stdio;
3634         }
3635         l = *PerlIONext(&l);
3636     }
3637     /* Uses fallback "mode" via PerlIO_modestr() in PerlIO_exportFILE */
3638     /* However, we're not really exporting a FILE * to someone else (who
3639        becomes responsible for closing it, or calling PerlIO_releaseFILE())
3640        So we need to undo its refernce count increase on the underlying file
3641        descriptor. We have to do this, because if the loop above returns you
3642        the FILE *, then *it* didn't increase any reference count. So there's
3643        only one way to be consistent. */
3644     stdio = PerlIO_exportFILE(f, NULL);
3645     if (stdio) {
3646         const int fd = fileno(stdio);
3647         if (fd >= 0)
3648             PerlIOUnix_refcnt_dec(fd);
3649     }
3650     return stdio;
3651 }
3652
3653 /* Use this to reverse PerlIO_exportFILE calls. */
3654 void
3655 PerlIO_releaseFILE(PerlIO *p, FILE *f)
3656 {
3657     dVAR;
3658     PerlIOl *l;
3659     while ((l = *p)) {
3660         if (l->tab == &PerlIO_stdio) {
3661             PerlIOStdio *s = PerlIOSelf(&l, PerlIOStdio);
3662             if (s->stdio == f) {
3663                 dTHX;
3664                 const int fd = fileno(f);
3665                 if (fd >= 0)
3666                     PerlIOUnix_refcnt_dec(fd);
3667                 PerlIO_pop(aTHX_ p);
3668                 return;
3669             }
3670         }
3671         p = PerlIONext(p);
3672     }
3673     return;
3674 }
3675
3676 /*--------------------------------------------------------------------------------------*/
3677 /*
3678  * perlio buffer layer
3679  */
3680
3681 IV
3682 PerlIOBuf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
3683 {
3684     PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
3685     const int fd = PerlIO_fileno(f);
3686     if (fd >= 0 && PerlLIO_isatty(fd)) {
3687         PerlIOBase(f)->flags |= PERLIO_F_LINEBUF | PERLIO_F_TTY;
3688     }
3689     if (*PerlIONext(f)) {
3690         const Off_t posn = PerlIO_tell(PerlIONext(f));
3691         if (posn != (Off_t) - 1) {
3692             b->posn = posn;
3693         }
3694     }
3695     return PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
3696 }
3697
3698 PerlIO *
3699 PerlIOBuf_open(pTHX_ PerlIO_funcs *self, PerlIO_list_t *layers,
3700                IV n, const char *mode, int fd, int imode, int perm,
3701                PerlIO *f, int narg, SV **args)
3702 {
3703     if (PerlIOValid(f)) {
3704         PerlIO *next = PerlIONext(f);
3705         PerlIO_funcs *tab =
3706              PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIOBase(next)->tab);
3707         if (tab && tab->Open)
3708              next =
3709                   (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3710                                next, narg, args);
3711         if (!next || (*PerlIOBase(f)->tab->Pushed) (aTHX_ f, mode, PerlIOArg, self) != 0) {
3712             return NULL;
3713         }
3714     }
3715     else {
3716         PerlIO_funcs *tab = PerlIO_layer_fetch(aTHX_ layers, n - 1, PerlIO_default_btm());
3717         int init = 0;
3718         if (*mode == IoTYPE_IMPLICIT) {
3719             init = 1;
3720             /*
3721              * mode++;
3722              */
3723         }
3724         if (tab && tab->Open)
3725              f = (*tab->Open)(aTHX_ tab, layers, n - 1, mode, fd, imode, perm,
3726                               f, narg, args);
3727         else
3728              SETERRNO(EINVAL, LIB_INVARG);
3729         if (f) {
3730             if (PerlIO_push(aTHX_ f, self, mode, PerlIOArg) == 0) {
3731                 /*
3732                  * if push fails during open, open fails. close will pop us.
3733                  */
3734                 PerlIO_close (f);
3735                 return NULL;
3736             } else {
3737                 fd = PerlIO_fileno(f);
3738                 if (init && fd == 2) {
3739                     /*
3740                      * Initial stderr is unbuffered
3741                      */
3742                     PerlIOBase(f)->flags |= PERLIO_F_UNBUF;
3743                 }
3744 #ifdef PERLIO_USING_CRLF
3745 #  ifdef PERLIO_IS_BINMODE_FD
3746                 if (PERLIO_IS_BINMODE_FD(fd))
3747                     PerlIO_binmode(aTHX_ f,  '<'/*not used*/, O_BINARY, NULL);
3748                 else
3749 #  endif
3750                 /*
3751                  * do something about failing setmode()? --jhi
3752                  */
3753                 PerlLIO_setmode(fd, O_BINARY);
3754 #endif
3755             }
3756         }
3757     }
3758     return f;
3759 }
3760
3761 /*
3762  * This "flush" is akin to sfio's sync in that it handles files in either
3763  * read or write state.  For write state, we put the postponed data through
3764  * the next layers.  For read state, we seek() the next layers to the
3765  * offset given by current position in the buffer, and discard the buffer
3766  * state (XXXX supposed to be for seek()able buffers only, but now it is done
3767  * in any case?).  Then the pass the stick further in chain.
3768  */
3769 IV
3770 PerlIOBuf_flush(pTHX_ PerlIO *f)
3771 {
3772     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3773     int code = 0;
3774     PerlIO *n = PerlIONext(f);
3775     if (PerlIOBase(f)->flags & PERLIO_F_WRBUF) {
3776         /*
3777          * write() the buffer
3778          */
3779         const STDCHAR *buf = b->buf;
3780         const STDCHAR *p = buf;
3781         while (p < b->ptr) {
3782             SSize_t count = PerlIO_write(n, p, b->ptr - p);
3783             if (count > 0) {
3784                 p += count;
3785             }
3786             else if (count < 0 || PerlIO_error(n)) {
3787                 PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3788                 code = -1;
3789                 break;
3790             }
3791         }
3792         b->posn += (p - buf);
3793     }
3794     else if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3795         STDCHAR *buf = PerlIO_get_base(f);
3796         /*
3797          * Note position change
3798          */
3799         b->posn += (b->ptr - buf);
3800         if (b->ptr < b->end) {
3801             /* We did not consume all of it - try and seek downstream to
3802                our logical position
3803              */
3804             if (PerlIOValid(n) && PerlIO_seek(n, b->posn, SEEK_SET) == 0) {
3805                 /* Reload n as some layers may pop themselves on seek */
3806                 b->posn = PerlIO_tell(n = PerlIONext(f));
3807             }
3808             else {
3809                 /* Seek failed (e.g. pipe or tty). Do NOT clear buffer or pre-read
3810                    data is lost for good - so return saying "ok" having undone
3811                    the position adjust
3812                  */
3813                 b->posn -= (b->ptr - buf);
3814                 return code;
3815             }
3816         }
3817     }
3818     b->ptr = b->end = b->buf;
3819     PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
3820     /* We check for Valid because of dubious decision to make PerlIO_flush(NULL) flush all */
3821     if (PerlIOValid(n) && PerlIO_flush(n) != 0)
3822         code = -1;
3823     return code;
3824 }
3825
3826 /* This discards the content of the buffer after b->ptr, and rereads
3827  * the buffer from the position off in the layer downstream; here off
3828  * is at offset corresponding to b->ptr - b->buf.
3829  */
3830 IV
3831 PerlIOBuf_fill(pTHX_ PerlIO *f)
3832 {
3833     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3834     PerlIO *n = PerlIONext(f);
3835     SSize_t avail;
3836     /*
3837      * Down-stream flush is defined not to loose read data so is harmless.
3838      * we would not normally be fill'ing if there was data left in anycase.
3839      */
3840     if (PerlIO_flush(f) != 0)   /* XXXX Check that its seek() succeeded?! */
3841         return -1;
3842     if (PerlIOBase(f)->flags & PERLIO_F_TTY)
3843         PerlIOBase_flush_linebuf(aTHX);
3844
3845     if (!b->buf)
3846         PerlIO_get_base(f);     /* allocate via vtable */
3847
3848     assert(b->buf); /* The b->buf does get allocated via the vtable system. */
3849
3850     b->ptr = b->end = b->buf;
3851
3852     if (!PerlIOValid(n)) {
3853         PerlIOBase(f)->flags |= PERLIO_F_EOF;
3854         return -1;
3855     }
3856
3857     if (PerlIO_fast_gets(n)) {
3858         /*
3859          * Layer below is also buffered. We do _NOT_ want to call its
3860          * ->Read() because that will loop till it gets what we asked for
3861          * which may hang on a pipe etc. Instead take anything it has to
3862          * hand, or ask it to fill _once_.
3863          */
3864         avail = PerlIO_get_cnt(n);
3865         if (avail <= 0) {
3866             avail = PerlIO_fill(n);
3867             if (avail == 0)
3868                 avail = PerlIO_get_cnt(n);
3869             else {
3870                 if (!PerlIO_error(n) && PerlIO_eof(n))
3871                     avail = 0;
3872             }
3873         }
3874         if (avail > 0) {
3875             STDCHAR *ptr = PerlIO_get_ptr(n);
3876             const SSize_t cnt = avail;
3877             if (avail > (SSize_t)b->bufsiz)
3878                 avail = b->bufsiz;
3879             Copy(ptr, b->buf, avail, STDCHAR);
3880             PerlIO_set_ptrcnt(n, ptr + avail, cnt - avail);
3881         }
3882     }
3883     else {
3884         avail = PerlIO_read(n, b->ptr, b->bufsiz);
3885     }
3886     if (avail <= 0) {
3887         if (avail == 0)
3888             PerlIOBase(f)->flags |= PERLIO_F_EOF;
3889         else
3890             PerlIOBase(f)->flags |= PERLIO_F_ERROR;
3891         return -1;
3892     }
3893     b->end = b->buf + avail;
3894     PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3895     return 0;
3896 }
3897
3898 SSize_t
3899 PerlIOBuf_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
3900 {
3901     if (PerlIOValid(f)) {
3902         const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3903         if (!b->ptr)
3904             PerlIO_get_base(f);
3905         return PerlIOBase_read(aTHX_ f, vbuf, count);
3906     }
3907     return 0;
3908 }
3909
3910 SSize_t
3911 PerlIOBuf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3912 {
3913     const STDCHAR *buf = (const STDCHAR *) vbuf + count;
3914     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3915     SSize_t unread = 0;
3916     SSize_t avail;
3917     if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
3918         PerlIO_flush(f);
3919     if (!b->buf)
3920         PerlIO_get_base(f);
3921     if (b->buf) {
3922         if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3923             /*
3924              * Buffer is already a read buffer, we can overwrite any chars
3925              * which have been read back to buffer start
3926              */
3927             avail = (b->ptr - b->buf);
3928         }
3929         else {
3930             /*
3931              * Buffer is idle, set it up so whole buffer is available for
3932              * unread
3933              */
3934             avail = b->bufsiz;
3935             b->end = b->buf + avail;
3936             b->ptr = b->end;
3937             PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
3938             /*
3939              * Buffer extends _back_ from where we are now
3940              */
3941             b->posn -= b->bufsiz;
3942         }
3943         if (avail > (SSize_t) count) {
3944             /*
3945              * If we have space for more than count, just move count
3946              */
3947             avail = count;
3948         }
3949         if (avail > 0) {
3950             b->ptr -= avail;
3951             buf -= avail;
3952             /*
3953              * In simple stdio-like ungetc() case chars will be already
3954              * there
3955              */
3956             if (buf != b->ptr) {
3957                 Copy(buf, b->ptr, avail, STDCHAR);
3958             }
3959             count -= avail;
3960             unread += avail;
3961             PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
3962         }
3963     }
3964     if (count > 0) {
3965         unread += PerlIOBase_unread(aTHX_ f, vbuf, count);
3966     }
3967     return unread;
3968 }
3969
3970 SSize_t
3971 PerlIOBuf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
3972 {
3973     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
3974     const STDCHAR *buf = (const STDCHAR *) vbuf;
3975     const STDCHAR *flushptr = buf;
3976     Size_t written = 0;
3977     if (!b->buf)
3978         PerlIO_get_base(f);
3979     if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
3980         return 0;
3981     if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
3982         if (PerlIO_flush(f) != 0) {
3983             return 0;
3984         }
3985     }   
3986     if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
3987         flushptr = buf + count;
3988         while (flushptr > buf && *(flushptr - 1) != '\n')
3989             --flushptr;
3990     }
3991     while (count > 0) {
3992         SSize_t avail = b->bufsiz - (b->ptr - b->buf);
3993         if ((SSize_t) count < avail)
3994             avail = count;
3995         if (flushptr > buf && flushptr <= buf + avail)
3996             avail = flushptr - buf;
3997         PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
3998         if (avail) {
3999             Copy(buf, b->ptr, avail, STDCHAR);
4000             count -= avail;
4001             buf += avail;
4002             written += avail;
4003             b->ptr += avail;
4004             if (buf == flushptr)
4005                 PerlIO_flush(f);
4006         }
4007         if (b->ptr >= (b->buf + b->bufsiz))
4008             PerlIO_flush(f);
4009     }
4010     if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4011         PerlIO_flush(f);
4012     return written;
4013 }
4014
4015 IV
4016 PerlIOBuf_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4017 {
4018     IV code;
4019     if ((code = PerlIO_flush(f)) == 0) {
4020         PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4021         code = PerlIO_seek(PerlIONext(f), offset, whence);
4022         if (code == 0) {
4023             PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4024             b->posn = PerlIO_tell(PerlIONext(f));
4025         }
4026     }
4027     return code;
4028 }
4029
4030 Off_t
4031 PerlIOBuf_tell(pTHX_ PerlIO *f)
4032 {
4033     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4034     /*
4035      * b->posn is file position where b->buf was read, or will be written
4036      */
4037     Off_t posn = b->posn;
4038     if ((PerlIOBase(f)->flags & PERLIO_F_APPEND) &&
4039         (PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4040 #if 1
4041         /* As O_APPEND files are normally shared in some sense it is better
4042            to flush :
4043          */     
4044         PerlIO_flush(f);
4045 #else   
4046         /* when file is NOT shared then this is sufficient */
4047         PerlIO_seek(PerlIONext(f),0, SEEK_END);
4048 #endif
4049         posn = b->posn = PerlIO_tell(PerlIONext(f));
4050     }
4051     if (b->buf) {
4052         /*
4053          * If buffer is valid adjust position by amount in buffer
4054          */
4055         posn += (b->ptr - b->buf);
4056     }
4057     return posn;
4058 }
4059
4060 IV
4061 PerlIOBuf_popped(pTHX_ PerlIO *f)
4062 {
4063     const IV code = PerlIOBase_popped(aTHX_ f);
4064     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4065     if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4066         Safefree(b->buf);
4067     }
4068     b->ptr = b->end = b->buf = NULL;
4069     PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4070     return code;
4071 }
4072
4073 IV
4074 PerlIOBuf_close(pTHX_ PerlIO *f)
4075 {
4076     const IV code = PerlIOBase_close(aTHX_ f);
4077     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4078     if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4079         Safefree(b->buf);
4080     }
4081     b->ptr = b->end = b->buf = NULL;
4082     PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4083     return code;
4084 }
4085
4086 STDCHAR *
4087 PerlIOBuf_get_ptr(pTHX_ PerlIO *f)
4088 {
4089     const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4090     if (!b->buf)
4091         PerlIO_get_base(f);
4092     return b->ptr;
4093 }
4094
4095 SSize_t
4096 PerlIOBuf_get_cnt(pTHX_ PerlIO *f)
4097 {
4098     const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4099     if (!b->buf)
4100         PerlIO_get_base(f);
4101     if (PerlIOBase(f)->flags & PERLIO_F_RDBUF)
4102         return (b->end - b->ptr);
4103     return 0;
4104 }
4105
4106 STDCHAR *
4107 PerlIOBuf_get_base(pTHX_ PerlIO *f)
4108 {
4109     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4110     PERL_UNUSED_CONTEXT;
4111
4112     if (!b->buf) {
4113         if (!b->bufsiz)
4114             b->bufsiz = 4096;
4115         b->buf = Newxz(b->buf,b->bufsiz, STDCHAR);
4116         if (!b->buf) {
4117             b->buf = (STDCHAR *) & b->oneword;
4118             b->bufsiz = sizeof(b->oneword);
4119         }
4120         b->end = b->ptr = b->buf;
4121     }
4122     return b->buf;
4123 }
4124
4125 Size_t
4126 PerlIOBuf_bufsiz(pTHX_ PerlIO *f)
4127 {
4128     const PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4129     if (!b->buf)
4130         PerlIO_get_base(f);
4131     return (b->end - b->buf);
4132 }
4133
4134 void
4135 PerlIOBuf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4136 {
4137     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4138 #ifndef DEBUGGING
4139     PERL_UNUSED_ARG(cnt);
4140 #endif
4141     if (!b->buf)
4142         PerlIO_get_base(f);
4143     b->ptr = ptr;
4144     assert(PerlIO_get_cnt(f) == cnt);
4145     assert(b->ptr >= b->buf);
4146     PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4147 }
4148
4149 PerlIO *
4150 PerlIOBuf_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
4151 {
4152  return PerlIOBase_dup(aTHX_ f, o, param, flags);
4153 }
4154
4155
4156
4157 PERLIO_FUNCS_DECL(PerlIO_perlio) = {
4158     sizeof(PerlIO_funcs),
4159     "perlio",
4160     sizeof(PerlIOBuf),
4161     PERLIO_K_BUFFERED|PERLIO_K_RAW,
4162     PerlIOBuf_pushed,
4163     PerlIOBuf_popped,
4164     PerlIOBuf_open,
4165     PerlIOBase_binmode,         /* binmode */
4166     NULL,
4167     PerlIOBase_fileno,
4168     PerlIOBuf_dup,
4169     PerlIOBuf_read,
4170     PerlIOBuf_unread,
4171     PerlIOBuf_write,
4172     PerlIOBuf_seek,
4173     PerlIOBuf_tell,
4174     PerlIOBuf_close,
4175     PerlIOBuf_flush,
4176     PerlIOBuf_fill,
4177     PerlIOBase_eof,
4178     PerlIOBase_error,
4179     PerlIOBase_clearerr,
4180     PerlIOBase_setlinebuf,
4181     PerlIOBuf_get_base,
4182     PerlIOBuf_bufsiz,
4183     PerlIOBuf_get_ptr,
4184     PerlIOBuf_get_cnt,
4185     PerlIOBuf_set_ptrcnt,
4186 };
4187
4188 /*--------------------------------------------------------------------------------------*/
4189 /*
4190  * Temp layer to hold unread chars when cannot do it any other way
4191  */
4192
4193 IV
4194 PerlIOPending_fill(pTHX_ PerlIO *f)
4195 {
4196     /*
4197      * Should never happen
4198      */
4199     PerlIO_flush(f);
4200     return 0;
4201 }
4202
4203 IV
4204 PerlIOPending_close(pTHX_ PerlIO *f)
4205 {
4206     /*
4207      * A tad tricky - flush pops us, then we close new top
4208      */
4209     PerlIO_flush(f);
4210     return PerlIO_close(f);
4211 }
4212
4213 IV
4214 PerlIOPending_seek(pTHX_ PerlIO *f, Off_t offset, int whence)
4215 {
4216     /*
4217      * A tad tricky - flush pops us, then we seek new top
4218      */
4219     PerlIO_flush(f);
4220     return PerlIO_seek(f, offset, whence);
4221 }
4222
4223
4224 IV
4225 PerlIOPending_flush(pTHX_ PerlIO *f)
4226 {
4227     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4228     if (b->buf && b->buf != (STDCHAR *) & b->oneword) {
4229         Safefree(b->buf);
4230         b->buf = NULL;
4231     }
4232     PerlIO_pop(aTHX_ f);
4233     return 0;
4234 }
4235
4236 void
4237 PerlIOPending_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4238 {
4239     if (cnt <= 0) {
4240         PerlIO_flush(f);
4241     }
4242     else {
4243         PerlIOBuf_set_ptrcnt(aTHX_ f, ptr, cnt);
4244     }
4245 }
4246
4247 IV
4248 PerlIOPending_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4249 {
4250     const IV code = PerlIOBase_pushed(aTHX_ f, mode, arg, tab);
4251     PerlIOl * const l = PerlIOBase(f);
4252     /*
4253      * Our PerlIO_fast_gets must match what we are pushed on, or sv_gets()
4254      * etc. get muddled when it changes mid-string when we auto-pop.
4255      */
4256     l->flags = (l->flags & ~(PERLIO_F_FASTGETS | PERLIO_F_UTF8)) |
4257         (PerlIOBase(PerlIONext(f))->
4258          flags & (PERLIO_F_FASTGETS | PERLIO_F_UTF8));
4259     return code;
4260 }
4261
4262 SSize_t
4263 PerlIOPending_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
4264 {
4265     SSize_t avail = PerlIO_get_cnt(f);
4266     SSize_t got = 0;
4267     if ((SSize_t)count < avail)
4268         avail = count;
4269     if (avail > 0)
4270         got = PerlIOBuf_read(aTHX_ f, vbuf, avail);
4271     if (got >= 0 && got < (SSize_t)count) {
4272         const SSize_t more =
4273             PerlIO_read(f, ((STDCHAR *) vbuf) + got, count - got);
4274         if (more >= 0 || got == 0)
4275             got += more;
4276     }
4277     return got;
4278 }
4279
4280 PERLIO_FUNCS_DECL(PerlIO_pending) = {
4281     sizeof(PerlIO_funcs),
4282     "pending",
4283     sizeof(PerlIOBuf),
4284     PERLIO_K_BUFFERED|PERLIO_K_RAW,  /* not sure about RAW here */
4285     PerlIOPending_pushed,
4286     PerlIOBuf_popped,
4287     NULL,
4288     PerlIOBase_binmode,         /* binmode */
4289     NULL,
4290     PerlIOBase_fileno,
4291     PerlIOBuf_dup,
4292     PerlIOPending_read,
4293     PerlIOBuf_unread,
4294     PerlIOBuf_write,
4295     PerlIOPending_seek,
4296     PerlIOBuf_tell,
4297     PerlIOPending_close,
4298     PerlIOPending_flush,
4299     PerlIOPending_fill,
4300     PerlIOBase_eof,
4301     PerlIOBase_error,
4302     PerlIOBase_clearerr,
4303     PerlIOBase_setlinebuf,
4304     PerlIOBuf_get_base,
4305     PerlIOBuf_bufsiz,
4306     PerlIOBuf_get_ptr,
4307     PerlIOBuf_get_cnt,
4308     PerlIOPending_set_ptrcnt,
4309 };
4310
4311
4312
4313 /*--------------------------------------------------------------------------------------*/
4314 /*
4315  * crlf - translation On read translate CR,LF to "\n" we do this by
4316  * overriding ptr/cnt entries to hand back a line at a time and keeping a
4317  * record of which nl we "lied" about. On write translate "\n" to CR,LF
4318  *
4319  * c->nl points on the first byte of CR LF pair when it is temporarily
4320  * replaced by LF, or to the last CR of the buffer.  In the former case
4321  * the caller thinks that the buffer ends at c->nl + 1, in the latter
4322  * that it ends at c->nl; these two cases can be distinguished by
4323  * *c->nl.  c->nl is set during _getcnt() call, and unset during
4324  * _unread() and _flush() calls.
4325  * It only matters for read operations.
4326  */
4327
4328 typedef struct {
4329     PerlIOBuf base;             /* PerlIOBuf stuff */
4330     STDCHAR *nl;                /* Position of crlf we "lied" about in the
4331                                  * buffer */
4332 } PerlIOCrlf;
4333
4334 /* Inherit the PERLIO_F_UTF8 flag from previous layer.
4335  * Otherwise the :crlf layer would always revert back to
4336  * raw mode.
4337  */
4338 static void
4339 S_inherit_utf8_flag(PerlIO *f)
4340 {
4341     PerlIO *g = PerlIONext(f);
4342     if (PerlIOValid(g)) {
4343         if (PerlIOBase(g)->flags & PERLIO_F_UTF8) {
4344             PerlIOBase(f)->flags |= PERLIO_F_UTF8;
4345         }
4346     }
4347 }
4348
4349 IV
4350 PerlIOCrlf_pushed(pTHX_ PerlIO *f, const char *mode, SV *arg, PerlIO_funcs *tab)
4351 {
4352     IV code;
4353     PerlIOBase(f)->flags |= PERLIO_F_CRLF;
4354     code = PerlIOBuf_pushed(aTHX_ f, mode, arg, tab);
4355 #if 0
4356     PerlIO_debug("PerlIOCrlf_pushed f=%p %s %s fl=%08" UVxf "\n",
4357                  (void*)f, PerlIOBase(f)->tab->name, (mode) ? mode : "(Null)",
4358                  PerlIOBase(f)->flags);
4359 #endif
4360     {
4361       /* Enable the first CRLF capable layer you can find, but if none
4362        * found, the one we just pushed is fine.  This results in at
4363        * any given moment at most one CRLF-capable layer being enabled
4364        * in the whole layer stack. */
4365          PerlIO *g = PerlIONext(f);
4366          while (PerlIOValid(g)) {
4367               PerlIOl *b = PerlIOBase(g);
4368               if (b && b->tab == &PerlIO_crlf) {
4369                    if (!(b->flags & PERLIO_F_CRLF))
4370                         b->flags |= PERLIO_F_CRLF;
4371                    S_inherit_utf8_flag(g);
4372                    PerlIO_pop(aTHX_ f);
4373                    return code;
4374               }           
4375               g = PerlIONext(g);
4376          }
4377     }
4378     S_inherit_utf8_flag(f);
4379     return code;
4380 }
4381
4382
4383 SSize_t
4384 PerlIOCrlf_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4385 {
4386     PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4387     if (c->nl) {        /* XXXX Shouldn't it be done only if b->ptr > c->nl? */
4388         *(c->nl) = 0xd;
4389         c->nl = NULL;
4390     }
4391     if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4392         return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4393     else {
4394         const STDCHAR *buf = (const STDCHAR *) vbuf + count;
4395         PerlIOBuf *b = PerlIOSelf(f, PerlIOBuf);
4396         SSize_t unread = 0;
4397         if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4398             PerlIO_flush(f);
4399         if (!b->buf)
4400             PerlIO_get_base(f);
4401         if (b->buf) {
4402             if (!(PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4403                 b->end = b->ptr = b->buf + b->bufsiz;
4404                 PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4405                 b->posn -= b->bufsiz;
4406             }
4407             while (count > 0 && b->ptr > b->buf) {
4408                 const int ch = *--buf;
4409                 if (ch == '\n') {
4410                     if (b->ptr - 2 >= b->buf) {
4411                         *--(b->ptr) = 0xa;
4412                         *--(b->ptr) = 0xd;
4413                         unread++;
4414                         count--;
4415                     }
4416                     else {
4417                     /* If b->ptr - 1 == b->buf, we are undoing reading 0xa */
4418                         *--(b->ptr) = 0xa;      /* Works even if 0xa == '\r' */
4419                         unread++;
4420                         count--;
4421                     }
4422                 }
4423                 else {
4424                     *--(b->ptr) = ch;
4425                     unread++;
4426                     count--;
4427                 }
4428             }
4429         }
4430         return unread;
4431     }
4432 }
4433
4434 /* XXXX This code assumes that buffer size >=2, but does not check it... */
4435 SSize_t
4436 PerlIOCrlf_get_cnt(pTHX_ PerlIO *f)
4437 {
4438     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4439     if (!b->buf)
4440         PerlIO_get_base(f);
4441     if (PerlIOBase(f)->flags & PERLIO_F_RDBUF) {
4442         PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4443         if ((PerlIOBase(f)->flags & PERLIO_F_CRLF) && (!c->nl || *c->nl == 0xd)) {
4444             STDCHAR *nl = (c->nl) ? c->nl : b->ptr;
4445           scan:
4446             while (nl < b->end && *nl != 0xd)
4447                 nl++;
4448             if (nl < b->end && *nl == 0xd) {
4449               test:
4450                 if (nl + 1 < b->end) {
4451                     if (nl[1] == 0xa) {
4452                         *nl = '\n';
4453                         c->nl = nl;
4454                     }
4455                     else {
4456                         /*
4457                          * Not CR,LF but just CR
4458                          */
4459                         nl++;
4460                         goto scan;
4461                     }
4462                 }
4463                 else {
4464                     /*
4465                      * Blast - found CR as last char in buffer
4466                      */
4467
4468                     if (b->ptr < nl) {
4469                         /*
4470                          * They may not care, defer work as long as
4471                          * possible
4472                          */
4473                         c->nl = nl;
4474                         return (nl - b->ptr);
4475                     }
4476                     else {
4477                         int code;
4478                         b->ptr++;       /* say we have read it as far as
4479                                          * flush() is concerned */
4480                         b->buf++;       /* Leave space in front of buffer */
4481                         /* Note as we have moved buf up flush's
4482                            posn += ptr-buf
4483                            will naturally make posn point at CR
4484                          */
4485                         b->bufsiz--;    /* Buffer is thus smaller */
4486                         code = PerlIO_fill(f);  /* Fetch some more */
4487                         b->bufsiz++;    /* Restore size for next time */
4488                         b->buf--;       /* Point at space */
4489                         b->ptr = nl = b->buf;   /* Which is what we hand
4490                                                  * off */
4491                         *nl = 0xd;      /* Fill in the CR */
4492                         if (code == 0)
4493                             goto test;  /* fill() call worked */
4494                         /*
4495                          * CR at EOF - just fall through
4496                          */
4497                         /* Should we clear EOF though ??? */
4498                     }
4499                 }
4500             }
4501         }
4502         return (((c->nl) ? (c->nl + 1) : b->end) - b->ptr);
4503     }
4504     return 0;
4505 }
4506
4507 void
4508 PerlIOCrlf_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR * ptr, SSize_t cnt)
4509 {
4510     PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4511     PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4512     if (!b->buf)
4513         PerlIO_get_base(f);
4514     if (!ptr) {
4515         if (c->nl) {
4516             ptr = c->nl + 1;
4517             if (ptr == b->end && *c->nl == 0xd) {
4518                 /* Defered CR at end of buffer case - we lied about count */
4519                 ptr--;
4520             }
4521         }
4522         else {
4523             ptr = b->end;
4524         }
4525         ptr -= cnt;
4526     }
4527     else {
4528         NOOP;
4529 #if 0
4530         /*
4531          * Test code - delete when it works ...
4532          */
4533         IV flags = PerlIOBase(f)->flags;
4534         STDCHAR *chk = (c->nl) ? (c->nl+1) : b->end;
4535         if (ptr+cnt == c->nl && c->nl+1 == b->end && *c->nl == 0xd) {
4536           /* Defered CR at end of buffer case - we lied about count */
4537           chk--;
4538         }
4539         chk -= cnt;
4540
4541         if (ptr != chk ) {
4542             Perl_croak(aTHX_ "ptr wrong %p != %p fl=%08" UVxf
4543                        " nl=%p e=%p for %d", (void*)ptr, (void*)chk,
4544                        flags, c->nl, b->end, cnt);
4545         }
4546 #endif
4547     }
4548     if (c->nl) {
4549         if (ptr > c->nl) {
4550             /*
4551              * They have taken what we lied about
4552              */
4553             *(c->nl) = 0xd;
4554             c->nl = NULL;
4555             ptr++;
4556         }
4557     }
4558     b->ptr = ptr;
4559     PerlIOBase(f)->flags |= PERLIO_F_RDBUF;
4560 }
4561
4562 SSize_t
4563 PerlIOCrlf_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4564 {
4565     if (!(PerlIOBase(f)->flags & PERLIO_F_CRLF))
4566         return PerlIOBuf_write(aTHX_ f, vbuf, count);
4567     else {
4568         PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4569         const STDCHAR *buf = (const STDCHAR *) vbuf;
4570         const STDCHAR * const ebuf = buf + count;
4571         if (!b->buf)
4572             PerlIO_get_base(f);
4573         if (!(PerlIOBase(f)->flags & PERLIO_F_CANWRITE))
4574             return 0;
4575         while (buf < ebuf) {
4576             const STDCHAR * const eptr = b->buf + b->bufsiz;
4577             PerlIOBase(f)->flags |= PERLIO_F_WRBUF;
4578             while (buf < ebuf && b->ptr < eptr) {
4579                 if (*buf == '\n') {
4580                     if ((b->ptr + 2) > eptr) {
4581                         /*
4582                          * Not room for both
4583                          */
4584                         PerlIO_flush(f);
4585                         break;
4586                     }
4587                     else {
4588                         *(b->ptr)++ = 0xd;      /* CR */
4589                         *(b->ptr)++ = 0xa;      /* LF */
4590                         buf++;
4591                         if (PerlIOBase(f)->flags & PERLIO_F_LINEBUF) {
4592                             PerlIO_flush(f);
4593                             break;
4594                         }
4595                     }
4596                 }
4597                 else {
4598                     *(b->ptr)++ = *buf++;
4599                 }
4600                 if (b->ptr >= eptr) {
4601                     PerlIO_flush(f);
4602                     break;
4603                 }
4604             }
4605         }
4606         if (PerlIOBase(f)->flags & PERLIO_F_UNBUF)
4607             PerlIO_flush(f);
4608         return (buf - (STDCHAR *) vbuf);
4609     }
4610 }
4611
4612 IV
4613 PerlIOCrlf_flush(pTHX_ PerlIO *f)
4614 {
4615     PerlIOCrlf * const c = PerlIOSelf(f, PerlIOCrlf);
4616     if (c->nl) {
4617         *(c->nl) = 0xd;
4618         c->nl = NULL;
4619     }
4620     return PerlIOBuf_flush(aTHX_ f);
4621 }
4622
4623 IV
4624 PerlIOCrlf_binmode(pTHX_ PerlIO *f)
4625 {
4626     if ((PerlIOBase(f)->flags & PERLIO_F_CRLF)) {
4627         /* In text mode - flush any pending stuff and flip it */
4628         PerlIOBase(f)->flags &= ~PERLIO_F_CRLF;
4629 #ifndef PERLIO_USING_CRLF
4630         /* CRLF is unusual case - if this is just the :crlf layer pop it */
4631         if (PerlIOBase(f)->tab == &PerlIO_crlf) {
4632                 PerlIO_pop(aTHX_ f);
4633         }
4634 #endif
4635     }
4636     return 0;
4637 }
4638
4639 PERLIO_FUNCS_DECL(PerlIO_crlf) = {
4640     sizeof(PerlIO_funcs),
4641     "crlf",
4642     sizeof(PerlIOCrlf),
4643     PERLIO_K_BUFFERED | PERLIO_K_CANCRLF | PERLIO_K_RAW,
4644     PerlIOCrlf_pushed,
4645     PerlIOBuf_popped,         /* popped */
4646     PerlIOBuf_open,
4647     PerlIOCrlf_binmode,       /* binmode */
4648     NULL,
4649     PerlIOBase_fileno,
4650     PerlIOBuf_dup,
4651     PerlIOBuf_read,             /* generic read works with ptr/cnt lies */
4652     PerlIOCrlf_unread,          /* Put CR,LF in buffer for each '\n' */
4653     PerlIOCrlf_write,           /* Put CR,LF in buffer for each '\n' */
4654     PerlIOBuf_seek,
4655     PerlIOBuf_tell,
4656     PerlIOBuf_close,
4657     PerlIOCrlf_flush,
4658     PerlIOBuf_fill,
4659     PerlIOBase_eof,
4660     PerlIOBase_error,
4661     PerlIOBase_clearerr,
4662     PerlIOBase_setlinebuf,
4663     PerlIOBuf_get_base,
4664     PerlIOBuf_bufsiz,
4665     PerlIOBuf_get_ptr,
4666     PerlIOCrlf_get_cnt,
4667     PerlIOCrlf_set_ptrcnt,
4668 };
4669
4670 #ifdef HAS_MMAP
4671 /*--------------------------------------------------------------------------------------*/
4672 /*
4673  * mmap as "buffer" layer
4674  */
4675
4676 typedef struct {
4677     PerlIOBuf base;             /* PerlIOBuf stuff */
4678     Mmap_t mptr;                /* Mapped address */
4679     Size_t len;                 /* mapped length */
4680     STDCHAR *bbuf;              /* malloced buffer if map fails */
4681 } PerlIOMmap;
4682
4683 IV
4684 PerlIOMmap_map(pTHX_ PerlIO *f)
4685 {
4686     dVAR;
4687     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4688     const IV flags = PerlIOBase(f)->flags;
4689     IV code = 0;
4690     if (m->len)
4691         abort();
4692     if (flags & PERLIO_F_CANREAD) {
4693         PerlIOBuf * const b = PerlIOSelf(f, PerlIOBuf);
4694         const int fd = PerlIO_fileno(f);
4695         Stat_t st;
4696         code = Fstat(fd, &st);
4697         if (code == 0 && S_ISREG(st.st_mode)) {
4698             SSize_t len = st.st_size - b->posn;
4699             if (len > 0) {
4700                 Off_t posn;
4701                 if (PL_mmap_page_size <= 0)
4702                   Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
4703                              PL_mmap_page_size);
4704                 if (b->posn < 0) {
4705                     /*
4706                      * This is a hack - should never happen - open should
4707                      * have set it !
4708                      */
4709                     b->posn = PerlIO_tell(PerlIONext(f));
4710                 }
4711                 posn = (b->posn / PL_mmap_page_size) * PL_mmap_page_size;
4712                 len = st.st_size - posn;
4713                 m->mptr = (Mmap_t)mmap(NULL, len, PROT_READ, MAP_SHARED, fd, posn);
4714                 if (m->mptr && m->mptr != (Mmap_t) - 1) {
4715 #if 0 && defined(HAS_MADVISE) && defined(MADV_SEQUENTIAL)
4716                     madvise(m->mptr, len, MADV_SEQUENTIAL);
4717 #endif
4718 #if 0 && defined(HAS_MADVISE) && defined(MADV_WILLNEED)
4719                     madvise(m->mptr, len, MADV_WILLNEED);
4720 #endif
4721                     PerlIOBase(f)->flags =
4722                         (flags & ~PERLIO_F_EOF) | PERLIO_F_RDBUF;
4723                     b->end = ((STDCHAR *) m->mptr) + len;
4724                     b->buf = ((STDCHAR *) m->mptr) + (b->posn - posn);
4725                     b->ptr = b->buf;
4726                     m->len = len;
4727                 }
4728                 else {
4729                     b->buf = NULL;
4730                 }
4731             }
4732             else {
4733                 PerlIOBase(f)->flags =
4734                     flags | PERLIO_F_EOF | PERLIO_F_RDBUF;
4735                 b->buf = NULL;
4736                 b->ptr = b->end = b->ptr;
4737                 code = -1;
4738             }
4739         }
4740     }
4741     return code;
4742 }
4743
4744 IV
4745 PerlIOMmap_unmap(pTHX_ PerlIO *f)
4746 {
4747     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4748     IV code = 0;
4749     if (m->len) {
4750         PerlIOBuf * const b = &m->base;
4751         if (b->buf) {
4752             /* The munmap address argument is tricky: depending on the
4753              * standard it is either "void *" or "caddr_t" (which is
4754              * usually "char *" (signed or unsigned).  If we cast it
4755              * to "void *", those that have it caddr_t and an uptight
4756              * C++ compiler, will freak out.  But casting it as char*
4757              * should work.  Maybe.  (Using Mmap_t figured out by
4758              * Configure doesn't always work, apparently.) */
4759             code = munmap((char*)m->mptr, m->len);
4760             b->buf = NULL;
4761             m->len = 0;
4762             m->mptr = NULL;
4763             if (PerlIO_seek(PerlIONext(f), b->posn, SEEK_SET) != 0)
4764                 code = -1;
4765         }
4766         b->ptr = b->end = b->buf;
4767         PerlIOBase(f)->flags &= ~(PERLIO_F_RDBUF | PERLIO_F_WRBUF);
4768     }
4769     return code;
4770 }
4771
4772 STDCHAR *
4773 PerlIOMmap_get_base(pTHX_ PerlIO *f)
4774 {
4775     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4776     PerlIOBuf * const b = &m->base;
4777     if (b->buf && (PerlIOBase(f)->flags & PERLIO_F_RDBUF)) {
4778         /*
4779          * Already have a readbuffer in progress
4780          */
4781         return b->buf;
4782     }
4783     if (b->buf) {
4784         /*
4785          * We have a write buffer or flushed PerlIOBuf read buffer
4786          */
4787         m->bbuf = b->buf;       /* save it in case we need it again */
4788         b->buf = NULL;          /* Clear to trigger below */
4789     }
4790     if (!b->buf) {
4791         PerlIOMmap_map(aTHX_ f);        /* Try and map it */
4792         if (!b->buf) {
4793             /*
4794              * Map did not work - recover PerlIOBuf buffer if we have one
4795              */
4796             b->buf = m->bbuf;
4797         }
4798     }
4799     b->ptr = b->end = b->buf;
4800     if (b->buf)
4801         return b->buf;
4802     return PerlIOBuf_get_base(aTHX_ f);
4803 }
4804
4805 SSize_t
4806 PerlIOMmap_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4807 {
4808     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4809     PerlIOBuf * const b = &m->base;
4810     if (PerlIOBase(f)->flags & PERLIO_F_WRBUF)
4811         PerlIO_flush(f);
4812     if (b->ptr && (b->ptr - count) >= b->buf
4813         && memEQ(b->ptr - count, vbuf, count)) {
4814         b->ptr -= count;
4815         PerlIOBase(f)->flags &= ~PERLIO_F_EOF;
4816         return count;
4817     }
4818     if (m->len) {
4819         /*
4820          * Loose the unwritable mapped buffer
4821          */
4822         PerlIO_flush(f);
4823         /*
4824          * If flush took the "buffer" see if we have one from before
4825          */
4826         if (!b->buf && m->bbuf)
4827             b->buf = m->bbuf;
4828         if (!b->buf) {
4829             PerlIOBuf_get_base(aTHX_ f);
4830             m->bbuf = b->buf;
4831         }
4832     }
4833     return PerlIOBuf_unread(aTHX_ f, vbuf, count);
4834 }
4835
4836 SSize_t
4837 PerlIOMmap_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
4838 {
4839     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4840     PerlIOBuf * const b = &m->base;
4841
4842     if (!b->buf || !(PerlIOBase(f)->flags & PERLIO_F_WRBUF)) {
4843         /*
4844          * No, or wrong sort of, buffer
4845          */
4846         if (m->len) {
4847             if (PerlIOMmap_unmap(aTHX_ f) != 0)
4848                 return 0;
4849         }
4850         /*
4851          * If unmap took the "buffer" see if we have one from before
4852          */
4853         if (!b->buf && m->bbuf)
4854             b->buf = m->bbuf;
4855         if (!b->buf) {
4856             PerlIOBuf_get_base(aTHX_ f);
4857             m->bbuf = b->buf;
4858         }
4859     }
4860     return PerlIOBuf_write(aTHX_ f, vbuf, count);
4861 }
4862
4863 IV
4864 PerlIOMmap_flush(pTHX_ PerlIO *f)
4865 {
4866     PerlIOMmap * const m = PerlIOSelf(f, PerlIOMmap);
4867     PerlIOBuf * const b = &m->base;
4868     IV code = PerlIOBuf_flush(aTHX_ f);
4869     /*
4870      * Now we are "synced" at PerlIOBuf level
4871      */
4872     if (b->buf) {
4873         if (m->len) {
4874             /*
4875              * Unmap the buffer
4876              */
4877             if (PerlIOMmap_unmap(aTHX_ f) != 0)
4878                 code = -1;
4879         }
4880         else {
4881             /*
4882              * We seem to have a PerlIOBuf buffer which was not mapped
4883              * remember it in case we need one later
4884              */
4885             m->bbuf = b->buf;
4886         }