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