3 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 * 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * But only a short way ahead its floor and the walls on either side were
13 * cloven by a great fissure, out of which the red glare came, now leaping
14 * up, now dying down into darkness; and all the while far below there was
15 * a rumour and a trouble as of great engines throbbing and labouring.
17 * [p.945 of _The Lord of the Rings_, VI/iii: "Mount Doom"]
20 /* This file contains system pp ("push/pop") functions that
21 * execute the opcodes that make up a perl program. A typical pp function
22 * expects to find its arguments on the stack, and usually pushes its
23 * results onto the stack, hence the 'pp' terminology. Each OP structure
24 * contains a pointer to the relevant pp_foo() function.
26 * By 'system', we mean ops which interact with the OS, such as pp_open().
30 #define PERL_IN_PP_SYS_C
35 /* Shadow password support for solaris - pdo@cs.umd.edu
36 * Not just Solaris: at least HP-UX, IRIX, Linux.
37 * The API is from SysV.
39 * There are at least two more shadow interfaces,
40 * see the comments in pp_gpwent().
44 /* There is a MAXINT coming from <shadow.h> <- <hpsecurity.h> <- <values.h>
45 * and another MAXINT from "perl.h" <- <sys/param.h>. */
52 # include <sys/resource.h>
61 # include <sys/select.h>
65 /* XXX Configure test needed.
66 h_errno might not be a simple 'int', especially for multi-threaded
67 applications, see "extern int errno in perl.h". Creating such
68 a test requires taking into account the differences between
69 compiling multithreaded and singlethreaded ($ccflags et al).
70 HOST_NOT_FOUND is typically defined in <netdb.h>.
72 #if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
81 struct passwd *getpwnam (char *);
82 struct passwd *getpwuid (Uid_t);
87 struct passwd *getpwent (void);
88 #elif defined (VMS) && defined (my_getpwent)
89 struct passwd *Perl_my_getpwent (pTHX);
98 struct group *getgrnam (char *);
99 struct group *getgrgid (Gid_t);
103 struct group *getgrent (void);
109 # if defined(_MSC_VER) || defined(__MINGW32__)
110 # include <sys/utime.h>
117 # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */
120 # define my_chsize PerlLIO_chsize
123 # define my_chsize PerlLIO_chsize
125 I32 my_chsize(int fd, Off_t length);
131 #else /* no flock() */
133 /* fcntl.h might not have been included, even if it exists, because
134 the current Configure only sets I_FCNTL if it's needed to pick up
135 the *_OK constants. Make sure it has been included before testing
136 the fcntl() locking constants. */
137 # if defined(HAS_FCNTL) && !defined(I_FCNTL)
141 # if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK)
142 # define FLOCK fcntl_emulate_flock
143 # define FCNTL_EMULATE_FLOCK
144 # else /* no flock() or fcntl(F_SETLK,...) */
146 # define FLOCK lockf_emulate_flock
147 # define LOCKF_EMULATE_FLOCK
149 # endif /* no flock() or fcntl(F_SETLK,...) */
152 static int FLOCK (int, int);
155 * These are the flock() constants. Since this sytems doesn't have
156 * flock(), the values of the constants are probably not available.
170 # endif /* emulating flock() */
172 #endif /* no flock() */
175 static const char zero_but_true[ZBTLEN + 1] = "0 but true";
177 #if defined(I_SYS_ACCESS) && !defined(R_OK)
178 # include <sys/access.h>
184 /* Missing protos on LynxOS */
185 void sethostent(int);
186 void endhostent(void);
188 void endnetent(void);
189 void setprotoent(int);
190 void endprotoent(void);
191 void setservent(int);
192 void endservent(void);
196 # include "amigaos4/amigaio.h"
199 #undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
201 /* F_OK unused: if stat() cannot find it... */
203 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
204 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
205 # define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
208 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
209 # ifdef I_SYS_SECURITY
210 # include <sys/security.h>
214 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
217 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
221 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
223 # define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
227 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
228 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
229 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
232 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
234 const Uid_t ruid = getuid();
235 const Uid_t euid = geteuid();
236 const Gid_t rgid = getgid();
237 const Gid_t egid = getegid();
240 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
241 Perl_croak(aTHX_ "switching effective uid is not implemented");
244 if (setreuid(euid, ruid))
247 if (setresuid(euid, ruid, (Uid_t)-1))
250 /* diag_listed_as: entering effective %s failed */
251 Perl_croak(aTHX_ "entering effective uid failed");
254 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
255 Perl_croak(aTHX_ "switching effective gid is not implemented");
258 if (setregid(egid, rgid))
261 if (setresgid(egid, rgid, (Gid_t)-1))
264 /* diag_listed_as: entering effective %s failed */
265 Perl_croak(aTHX_ "entering effective gid failed");
268 res = access(path, mode);
271 if (setreuid(ruid, euid))
274 if (setresuid(ruid, euid, (Uid_t)-1))
277 /* diag_listed_as: leaving effective %s failed */
278 Perl_croak(aTHX_ "leaving effective uid failed");
281 if (setregid(rgid, egid))
284 if (setresgid(rgid, egid, (Gid_t)-1))
287 /* diag_listed_as: leaving effective %s failed */
288 Perl_croak(aTHX_ "leaving effective gid failed");
292 # define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
299 const char * const tmps = POPpconstx;
300 const U8 gimme = GIMME_V;
301 const char *mode = "r";
304 if (PL_op->op_private & OPpOPEN_IN_RAW)
306 else if (PL_op->op_private & OPpOPEN_IN_CRLF)
308 fp = PerlProc_popen(tmps, mode);
310 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
312 PerlIO_apply_layers(aTHX_ fp,mode,type);
314 if (gimme == G_VOID) {
316 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
319 else if (gimme == G_SCALAR) {
320 ENTER_with_name("backtick");
322 PL_rs = &PL_sv_undef;
323 SvPVCLEAR(TARG); /* note that this preserves previous buffer */
324 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
326 LEAVE_with_name("backtick");
332 SV * const sv = newSV(79);
333 if (sv_gets(sv, fp, 0) == NULL) {
338 if (SvLEN(sv) - SvCUR(sv) > 20) {
339 SvPV_shrink_to_cur(sv);
344 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
345 TAINT; /* "I believe that this is not gratuitous!" */
348 STATUS_NATIVE_CHILD_SET(-1);
349 if (gimme == G_SCALAR)
360 GV * const gv = (PL_op->op_flags & OPf_SPECIAL) ? NULL : (GV *)POPs;
364 /* make a copy of the pattern if it is gmagical, to ensure that magic
365 * is called once and only once */
366 if (SvGMAGICAL(TOPs)) TOPs = sv_2mortal(newSVsv(TOPs));
368 tryAMAGICunTARGETlist(iter_amg, (PL_op->op_flags & OPf_SPECIAL));
370 if (PL_op->op_flags & OPf_SPECIAL) {
371 /* call Perl-level glob function instead. Stack args are:
373 * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
382 /* Note that we only ever get here if File::Glob fails to load
383 * without at the same time croaking, for some reason, or if
384 * perl was built with PERL_EXTERNAL_GLOB */
386 ENTER_with_name("glob");
391 * The external globbing program may use things we can't control,
392 * so for security reasons we must assume the worst.
395 taint_proper(PL_no_security, "glob");
399 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
402 SAVESPTR(PL_rs); /* This is not permanent, either. */
403 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
406 *SvPVX(PL_rs) = '\n';
410 result = do_readline();
411 LEAVE_with_name("glob");
417 PL_last_in_gv = cGVOP_gv;
418 return do_readline();
428 do_join(TARG, &PL_sv_no, MARK, SP);
432 else if (SP == MARK) {
439 if (SvGMAGICAL(exsv)) exsv = sv_mortalcopy(exsv);
442 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
443 /* well-formed exception supplied */
446 SV * const errsv = ERRSV;
449 if (SvGMAGICAL(errsv)) {
450 exsv = sv_newmortal();
451 sv_setsv_nomg(exsv, errsv);
455 else if (SvPOKp(errsv) ? SvCUR(errsv) : SvNIOKp(errsv)) {
456 exsv = sv_newmortal();
457 sv_setsv_nomg(exsv, errsv);
458 sv_catpvs(exsv, "\t...caught");
461 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
464 if (SvROK(exsv) && !PL_warnhook)
465 Perl_warn(aTHX_ "%" SVf, SVfARG(exsv));
477 VMSISH_HUSHED || (PL_curcop->op_private & OPpHUSH_VMSISH);
479 if (SP - MARK != 1) {
481 do_join(TARG, &PL_sv_no, MARK, SP);
489 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
490 /* well-formed exception supplied */
493 SV * const errsv = ERRSV;
497 if (sv_isobject(exsv)) {
498 HV * const stash = SvSTASH(SvRV(exsv));
499 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
501 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
502 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
509 call_sv(MUTABLE_SV(GvCV(gv)),
510 G_SCALAR|G_EVAL|G_KEEPERR);
511 exsv = sv_mortalcopy(*PL_stack_sp--);
515 else if (SvPOK(errsv) && SvCUR(errsv)) {
516 exsv = sv_mortalcopy(errsv);
517 sv_catpvs(exsv, "\t...propagated");
520 exsv = newSVpvs_flags("Died", SVs_TEMP);
524 NOT_REACHED; /* NOTREACHED */
525 return NULL; /* avoid missing return from non-void function warning */
531 Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv,
532 const MAGIC *const mg, const U32 flags, U32 argc, ...)
538 PERL_ARGS_ASSERT_TIED_METHOD;
540 /* Ensure that our flag bits do not overlap. */
541 STATIC_ASSERT_STMT((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
542 STATIC_ASSERT_STMT((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
543 STATIC_ASSERT_STMT((TIED_METHOD_SAY & G_WANT) == 0);
545 PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
546 PUSHSTACKi(PERLSI_MAGIC);
547 /* extend for object + args. If argc might wrap/truncate when cast
548 * to SSize_t and incremented, set to -1, which will trigger a panic in
550 * The weird way this is written is because g++ is dumb enough to
551 * warn "comparison is always false" on something like:
553 * sizeof(a) >= sizeof(b) && a >= B_t_MAX -1
555 * (where the LH condition is false)
558 (argc > (sizeof(argc) >= sizeof(SSize_t) ? SSize_t_MAX - 1 : argc))
559 ? -1 : (SSize_t)argc + 1;
560 EXTEND(SP, extend_size);
562 PUSHs(SvTIED_obj(sv, mg));
563 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
564 Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
568 const U32 mortalize_not_needed
569 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
571 va_start(args, argc);
573 SV *const arg = va_arg(args, SV *);
574 if(mortalize_not_needed)
583 ENTER_with_name("call_tied_method");
584 if (flags & TIED_METHOD_SAY) {
585 /* local $\ = "\n" */
586 SAVEGENERICSV(PL_ors_sv);
587 PL_ors_sv = newSVpvs("\n");
589 ret_args = call_sv(methname, (flags & G_WANT)|G_METHOD_NAMED);
594 if (ret_args) { /* copy results back to original stack */
595 EXTEND(sp, ret_args);
596 Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
600 LEAVE_with_name("call_tied_method");
604 #define tied_method0(a,b,c,d) \
605 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
606 #define tied_method1(a,b,c,d,e) \
607 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
608 #define tied_method2(a,b,c,d,e,f) \
609 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
622 GV * const gv = MUTABLE_GV(*++MARK);
624 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
625 DIE(aTHX_ PL_no_usym, "filehandle");
627 if ((io = GvIOp(gv))) {
629 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
632 Perl_croak(aTHX_ "Cannot open %" HEKf " as a filehandle: it is already open as a dirhandle",
633 HEKfARG(GvENAME_HEK(gv)));
635 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
637 /* Method's args are same as ours ... */
638 /* ... except handle is replaced by the object */
639 return Perl_tied_method(aTHX_ SV_CONST(OPEN), mark - 1, MUTABLE_SV(io), mg,
640 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
652 tmps = SvPV_const(sv, len);
653 ok = do_open6(gv, tmps, len, NULL, MARK+1, (SP-MARK));
656 PUSHi( (I32)PL_forkprocess );
657 else if (PL_forkprocess == 0) /* we are a new child */
668 MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
674 IO * const io = GvIO(gv);
676 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
678 return tied_method0(SV_CONST(CLOSE), SP, MUTABLE_SV(io), mg);
682 PUSHs(boolSV(do_close(gv, TRUE)));
694 GV * const wgv = MUTABLE_GV(POPs);
695 GV * const rgv = MUTABLE_GV(POPs);
699 do_close(rgv, FALSE);
703 do_close(wgv, FALSE);
705 if (PerlProc_pipe(fd) < 0)
708 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r" PIPE_OPEN_MODE);
709 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w" PIPE_OPEN_MODE);
710 IoOFP(rstio) = IoIFP(rstio);
711 IoIFP(wstio) = IoOFP(wstio);
712 IoTYPE(rstio) = IoTYPE_RDONLY;
713 IoTYPE(wstio) = IoTYPE_WRONLY;
715 if (!IoIFP(rstio) || !IoOFP(wstio)) {
717 PerlIO_close(IoIFP(rstio));
719 PerlLIO_close(fd[0]);
721 PerlIO_close(IoOFP(wstio));
723 PerlLIO_close(fd[1]);
726 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
727 /* ensure close-on-exec */
728 if ((fd[0] > PL_maxsysfd && fcntl(fd[0], F_SETFD, FD_CLOEXEC) < 0) ||
729 (fd[1] > PL_maxsysfd && fcntl(fd[1], F_SETFD, FD_CLOEXEC) < 0))
737 DIE(aTHX_ PL_no_func, "pipe");
751 gv = MUTABLE_GV(POPs);
755 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
757 return tied_method0(SV_CONST(FILENO), SP, MUTABLE_SV(io), mg);
760 if (io && IoDIRP(io)) {
761 #if defined(HAS_DIRFD) || defined(HAS_DIR_DD_FD)
762 PUSHi(my_dirfd(IoDIRP(io)));
764 #elif defined(ENOTSUP)
765 errno = ENOTSUP; /* Operation not supported */
767 #elif defined(EOPNOTSUPP)
768 errno = EOPNOTSUPP; /* Operation not supported on socket */
771 errno = EINVAL; /* Invalid argument */
776 if (!io || !(fp = IoIFP(io))) {
777 /* Can't do this because people seem to do things like
778 defined(fileno($foo)) to check whether $foo is a valid fh.
785 PUSHi(PerlIO_fileno(fp));
796 if (MAXARG < 1 || (!TOPs && !POPs)) {
797 anum = PerlLIO_umask(022);
798 /* setting it to 022 between the two calls to umask avoids
799 * to have a window where the umask is set to 0 -- meaning
800 * that another thread could create world-writeable files. */
802 (void)PerlLIO_umask(anum);
805 anum = PerlLIO_umask(POPi);
806 TAINT_PROPER("umask");
809 /* Only DIE if trying to restrict permissions on "user" (self).
810 * Otherwise it's harmless and more useful to just return undef
811 * since 'group' and 'other' concepts probably don't exist here. */
812 if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
813 DIE(aTHX_ "umask not implemented");
814 XPUSHs(&PL_sv_undef);
833 gv = MUTABLE_GV(POPs);
837 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
839 /* This takes advantage of the implementation of the varargs
840 function, which I don't think that the optimiser will be able to
841 figure out. Although, as it's a static function, in theory it
843 return Perl_tied_method(aTHX_ SV_CONST(BINMODE), SP, MUTABLE_SV(io), mg,
844 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
845 discp ? 1 : 0, discp);
849 if (!io || !(fp = IoIFP(io))) {
851 SETERRNO(EBADF,RMS_IFI);
858 const char *d = NULL;
861 d = SvPV_const(discp, len);
862 mode = mode_from_discipline(d, len);
863 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
864 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
865 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
886 const I32 markoff = MARK - PL_stack_base;
887 const char *methname;
888 int how = PERL_MAGIC_tied;
892 switch(SvTYPE(varsv)) {
896 methname = "TIEHASH";
897 if (HvLAZYDEL(varsv) && (entry = HvEITER((HV *)varsv))) {
898 HvLAZYDEL_off(varsv);
899 hv_free_ent((HV *)varsv, entry);
901 HvEITER_set(MUTABLE_HV(varsv), 0);
905 methname = "TIEARRAY";
906 if (!AvREAL(varsv)) {
908 Perl_croak(aTHX_ "Cannot tie unreifiable array");
909 av_clear((AV *)varsv);
916 if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
917 methname = "TIEHANDLE";
918 how = PERL_MAGIC_tiedscalar;
919 /* For tied filehandles, we apply tiedscalar magic to the IO
920 slot of the GP rather than the GV itself. AMS 20010812 */
922 GvIOp(varsv) = newIO();
923 varsv = MUTABLE_SV(GvIOp(varsv));
926 if (SvTYPE(varsv) == SVt_PVLV && LvTYPE(varsv) == 'y') {
927 vivify_defelem(varsv);
928 varsv = LvTARG(varsv);
932 methname = "TIESCALAR";
933 how = PERL_MAGIC_tiedscalar;
937 if (sv_isobject(*MARK)) { /* Calls GET magic. */
938 ENTER_with_name("call_TIE");
939 PUSHSTACKi(PERLSI_MAGIC);
941 EXTEND(SP,(I32)items);
945 call_method(methname, G_SCALAR);
948 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
949 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
950 * wrong error message, and worse case, supreme action at a distance.
951 * (Sorry obfuscation writers. You're not going to be given this one.)
953 stash = gv_stashsv(*MARK, 0);
956 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\"",
957 methname, SVfARG(*MARK));
958 else if (isGV(*MARK)) {
959 /* If the glob doesn't name an existing package, using
960 * SVfARG(*MARK) would yield "*Foo::Bar" or *main::Foo. So
961 * generate the name for the error message explicitly. */
962 SV *stashname = sv_2mortal(newSV(0));
963 gv_fullname4(stashname, (GV *) *MARK, NULL, FALSE);
964 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\"",
965 methname, SVfARG(stashname));
968 SV *stashname = !SvPOK(*MARK) ? &PL_sv_no
969 : SvCUR(*MARK) ? *MARK
970 : sv_2mortal(newSVpvs("main"));
971 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\""
972 " (perhaps you forgot to load \"%" SVf "\"?)",
973 methname, SVfARG(stashname), SVfARG(stashname));
976 else if (!(gv = gv_fetchmethod(stash, methname))) {
977 /* The effective name can only be NULL for stashes that have
978 * been deleted from the symbol table, which this one can't
979 * be, since we just looked it up by name.
981 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" HEKf "\"",
982 methname, HvENAME_HEK_NN(stash));
984 ENTER_with_name("call_TIE");
985 PUSHSTACKi(PERLSI_MAGIC);
987 EXTEND(SP,(I32)items);
991 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
997 if (sv_isobject(sv)) {
998 sv_unmagic(varsv, how);
999 /* Croak if a self-tie on an aggregate is attempted. */
1000 if (varsv == SvRV(sv) &&
1001 (SvTYPE(varsv) == SVt_PVAV ||
1002 SvTYPE(varsv) == SVt_PVHV))
1004 "Self-ties of arrays and hashes are not supported");
1005 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
1007 LEAVE_with_name("call_TIE");
1008 SP = PL_stack_base + markoff;
1014 /* also used for: pp_dbmclose() */
1021 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1022 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1024 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1027 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1028 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
1030 if ((mg = SvTIED_mg(sv, how))) {
1031 SV * const obj = SvRV(SvTIED_obj(sv, mg));
1033 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
1035 if (gv && isGV(gv) && (cv = GvCV(gv))) {
1037 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
1038 mXPUSHi(SvREFCNT(obj) - 1);
1040 ENTER_with_name("call_UNTIE");
1041 call_sv(MUTABLE_SV(cv), G_VOID);
1042 LEAVE_with_name("call_UNTIE");
1045 else if (mg && SvREFCNT(obj) > 1) {
1046 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
1047 "untie attempted while %" UVuf " inner references still exist",
1048 (UV)SvREFCNT(obj) - 1 ) ;
1052 sv_unmagic(sv, how) ;
1061 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1062 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1064 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1067 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1068 !(sv = defelem_target(sv, NULL))) goto ret_undef;
1070 if ((mg = SvTIED_mg(sv, how))) {
1071 SETs(SvTIED_obj(sv, mg));
1072 return NORMAL; /* PUTBACK not needed, pp_tied never moves SP */
1086 HV * const hv = MUTABLE_HV(POPs);
1087 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1088 stash = gv_stashsv(sv, 0);
1089 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1091 require_pv("AnyDBM_File.pm");
1093 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1094 DIE(aTHX_ "No dbm on this machine");
1104 mPUSHu(O_RDWR|O_CREAT);
1108 if (!SvOK(right)) right = &PL_sv_no;
1112 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1115 if (!sv_isobject(TOPs)) {
1123 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1125 if (sv_isobject(TOPs))
1130 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1131 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1148 struct timeval timebuf;
1149 struct timeval *tbuf = &timebuf;
1153 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1158 # if BYTEORDER & 0xf0000
1159 # define ORDERBYTE (0x88888888 - BYTEORDER)
1161 # define ORDERBYTE (0x4444 - BYTEORDER)
1167 for (i = 1; i <= 3; i++) {
1168 SV * const sv = svs[i] = SP[i];
1172 if (SvREADONLY(sv)) {
1173 if (!(SvPOK(sv) && SvCUR(sv) == 0))
1174 Perl_croak_no_modify();
1176 else if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
1179 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1180 "Non-string passed as bitmask");
1181 if (SvGAMAGIC(sv)) {
1182 svs[i] = sv_newmortal();
1183 sv_copypv_nomg(svs[i], sv);
1186 SvPV_force_nomg_nolen(sv); /* force string conversion */
1193 /* little endians can use vecs directly */
1194 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1201 masksize = NFDBITS / NBBY;
1203 masksize = sizeof(long); /* documented int, everyone seems to use long */
1205 Zero(&fd_sets[0], 4, char*);
1208 # if SELECT_MIN_BITS == 1
1209 growsize = sizeof(fd_set);
1211 # if defined(__GLIBC__) && defined(__FD_SETSIZE)
1212 # undef SELECT_MIN_BITS
1213 # define SELECT_MIN_BITS __FD_SETSIZE
1215 /* If SELECT_MIN_BITS is greater than one we most probably will want
1216 * to align the sizes with SELECT_MIN_BITS/8 because for example
1217 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1218 * UNIX, Solaris, Darwin) the smallest quantum select() operates
1219 * on (sets/tests/clears bits) is 32 bits. */
1220 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1226 value = SvNV_nomg(sv);
1229 timebuf.tv_sec = (long)value;
1230 value -= (NV)timebuf.tv_sec;
1231 timebuf.tv_usec = (long)(value * 1000000.0);
1236 for (i = 1; i <= 3; i++) {
1238 if (!SvOK(sv) || SvCUR(sv) == 0) {
1245 Sv_Grow(sv, growsize);
1249 while (++j <= growsize) {
1253 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1255 Newx(fd_sets[i], growsize, char);
1256 for (offset = 0; offset < growsize; offset += masksize) {
1257 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1258 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1261 fd_sets[i] = SvPVX(sv);
1265 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1266 /* Can't make just the (void*) conditional because that would be
1267 * cpp #if within cpp macro, and not all compilers like that. */
1268 nfound = PerlSock_select(
1270 (Select_fd_set_t) fd_sets[1],
1271 (Select_fd_set_t) fd_sets[2],
1272 (Select_fd_set_t) fd_sets[3],
1273 (void*) tbuf); /* Workaround for compiler bug. */
1275 nfound = PerlSock_select(
1277 (Select_fd_set_t) fd_sets[1],
1278 (Select_fd_set_t) fd_sets[2],
1279 (Select_fd_set_t) fd_sets[3],
1282 for (i = 1; i <= 3; i++) {
1285 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1287 for (offset = 0; offset < growsize; offset += masksize) {
1288 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1289 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1291 Safefree(fd_sets[i]);
1294 SvSetMagicSV(SP[i], sv);
1301 if (GIMME_V == G_ARRAY && tbuf) {
1302 value = (NV)(timebuf.tv_sec) +
1303 (NV)(timebuf.tv_usec) / 1000000.0;
1308 DIE(aTHX_ "select not implemented");
1316 =for apidoc setdefout
1318 Sets C<PL_defoutgv>, the default file handle for output, to the passed in
1319 typeglob. As C<PL_defoutgv> "owns" a reference on its typeglob, the reference
1320 count of the passed in typeglob is increased by one, and the reference count
1321 of the typeglob that C<PL_defoutgv> points to is decreased by one.
1327 Perl_setdefout(pTHX_ GV *gv)
1329 GV *oldgv = PL_defoutgv;
1331 PERL_ARGS_ASSERT_SETDEFOUT;
1333 SvREFCNT_inc_simple_void_NN(gv);
1335 SvREFCNT_dec(oldgv);
1342 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1343 GV * egv = GvEGVx(PL_defoutgv);
1348 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1349 gvp = hv && HvENAME(hv)
1350 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1352 if (gvp && *gvp == egv) {
1353 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1357 mXPUSHs(newRV(MUTABLE_SV(egv)));
1361 if (!GvIO(newdefout))
1362 gv_IOadd(newdefout);
1363 setdefout(newdefout);
1373 MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1374 IO *const io = GvIO(gv);
1380 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1382 const U8 gimme = GIMME_V;
1383 Perl_tied_method(aTHX_ SV_CONST(GETC), SP, MUTABLE_SV(io), mg, gimme, 0);
1384 if (gimme == G_SCALAR) {
1386 SvSetMagicSV_nosteal(TARG, TOPs);
1391 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1392 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1394 SETERRNO(EBADF,RMS_IFI);
1398 sv_setpvs(TARG, " ");
1399 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1400 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1401 /* Find out how many bytes the char needs */
1402 Size_t len = UTF8SKIP(SvPVX_const(TARG));
1405 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1406 SvCUR_set(TARG,1+len);
1410 else SvUTF8_off(TARG);
1416 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1419 const U8 gimme = GIMME_V;
1421 PERL_ARGS_ASSERT_DOFORM;
1424 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1426 cx = cx_pushblock(CXt_FORMAT, gimme, PL_stack_sp, PL_savestack_ix);
1427 cx_pushformat(cx, cv, retop, gv);
1428 if (CvDEPTH(cv) >= 2)
1429 pad_push(CvPADLIST(cv), CvDEPTH(cv));
1430 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), CvDEPTH(cv));
1432 setdefout(gv); /* locally select filehandle so $% et al work */
1449 gv = MUTABLE_GV(POPs);
1466 SV * const tmpsv = sv_newmortal();
1467 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1468 DIE(aTHX_ "Undefined format \"%" SVf "\" called", SVfARG(tmpsv));
1470 IoFLAGS(io) &= ~IOf_DIDTOP;
1471 RETURNOP(doform(cv,gv,PL_op->op_next));
1477 GV * const gv = CX_CUR()->blk_format.gv;
1478 IO * const io = GvIOp(gv);
1483 bool is_return = cBOOL(PL_op->op_type == OP_RETURN);
1485 if (is_return || !io || !(ofp = IoOFP(io)))
1488 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1489 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1491 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1492 PL_formtarget != PL_toptarget)
1496 if (!IoTOP_GV(io)) {
1499 if (!IoTOP_NAME(io)) {
1501 if (!IoFMT_NAME(io))
1502 IoFMT_NAME(io) = savepv(GvNAME(gv));
1503 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%" HEKf "_TOP",
1504 HEKfARG(GvNAME_HEK(gv))));
1505 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1506 if ((topgv && GvFORM(topgv)) ||
1507 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1508 IoTOP_NAME(io) = savesvpv(topname);
1510 IoTOP_NAME(io) = savepvs("top");
1512 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1513 if (!topgv || !GvFORM(topgv)) {
1514 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1517 IoTOP_GV(io) = topgv;
1519 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1520 I32 lines = IoLINES_LEFT(io);
1521 const char *s = SvPVX_const(PL_formtarget);
1522 if (lines <= 0) /* Yow, header didn't even fit!!! */
1524 while (lines-- > 0) {
1525 s = strchr(s, '\n');
1531 const STRLEN save = SvCUR(PL_formtarget);
1532 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1533 do_print(PL_formtarget, ofp);
1534 SvCUR_set(PL_formtarget, save);
1535 sv_chop(PL_formtarget, s);
1536 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1539 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1540 do_print(GvSV(gv_fetchpvs("\f", GV_ADD, SVt_PV)), ofp);
1541 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1543 PL_formtarget = PL_toptarget;
1544 IoFLAGS(io) |= IOf_DIDTOP;
1546 assert(fgv); /* IoTOP_GV(io) should have been set above */
1549 SV * const sv = sv_newmortal();
1550 gv_efullname4(sv, fgv, NULL, FALSE);
1551 DIE(aTHX_ "Undefined top format \"%" SVf "\" called", SVfARG(sv));
1553 return doform(cv, gv, PL_op);
1558 assert(CxTYPE(cx) == CXt_FORMAT);
1559 SP = PL_stack_base + cx->blk_oldsp; /* ignore retval of formline */
1563 retop = cx->blk_sub.retop;
1569 /* XXX the semantics of doing 'return' in a format aren't documented.
1570 * Currently we ignore any args to 'return' and just return
1571 * a single undef in both scalar and list contexts
1573 PUSHs(&PL_sv_undef);
1574 else if (!io || !(fp = IoOFP(io))) {
1575 if (io && IoIFP(io))
1576 report_wrongway_fh(gv, '<');
1582 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1583 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1585 if (!do_print(PL_formtarget, fp))
1588 FmLINES(PL_formtarget) = 0;
1589 SvCUR_set(PL_formtarget, 0);
1590 *SvEND(PL_formtarget) = '\0';
1591 if (IoFLAGS(io) & IOf_FLUSH)
1592 (void)PerlIO_flush(fp);
1596 PL_formtarget = PL_bodytarget;
1602 dSP; dMARK; dORIGMARK;
1606 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1607 IO *const io = GvIO(gv);
1609 /* Treat empty list as "" */
1610 if (MARK == SP) XPUSHs(&PL_sv_no);
1613 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1615 if (MARK == ORIGMARK) {
1618 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1621 return Perl_tied_method(aTHX_ SV_CONST(PRINTF), mark - 1, MUTABLE_SV(io),
1623 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1630 SETERRNO(EBADF,RMS_IFI);
1633 else if (!(fp = IoOFP(io))) {
1635 report_wrongway_fh(gv, '<');
1636 else if (ckWARN(WARN_CLOSED))
1638 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1642 SV *sv = sv_newmortal();
1643 do_sprintf(sv, SP - MARK, MARK + 1);
1644 if (!do_print(sv, fp))
1647 if (IoFLAGS(io) & IOf_FLUSH)
1648 if (PerlIO_flush(fp) == EOF)
1657 PUSHs(&PL_sv_undef);
1664 const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1665 const int mode = POPi;
1666 SV * const sv = POPs;
1667 GV * const gv = MUTABLE_GV(POPs);
1670 /* Need TIEHANDLE method ? */
1671 const char * const tmps = SvPV_const(sv, len);
1672 if (do_open_raw(gv, tmps, len, mode, perm, NULL)) {
1673 IoLINES(GvIOp(gv)) = 0;
1677 PUSHs(&PL_sv_undef);
1683 /* also used for: pp_read() and pp_recv() (where supported) */
1687 dSP; dMARK; dORIGMARK; dTARGET;
1701 bool charstart = FALSE;
1702 STRLEN charskip = 0;
1704 GV * const gv = MUTABLE_GV(*++MARK);
1707 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1708 && gv && (io = GvIO(gv)) )
1710 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1712 return Perl_tied_method(aTHX_ SV_CONST(READ), mark - 1, MUTABLE_SV(io), mg,
1713 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1723 length = SvIVx(*++MARK);
1725 DIE(aTHX_ "Negative length");
1728 offset = SvIVx(*++MARK);
1732 if (!io || !IoIFP(io)) {
1734 SETERRNO(EBADF,RMS_IFI);
1738 /* Note that fd can here validly be -1, don't check it yet. */
1739 fd = PerlIO_fileno(IoIFP(io));
1741 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1742 if (PL_op->op_type == OP_SYSREAD || PL_op->op_type == OP_RECV) {
1743 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
1744 "%s() is deprecated on :utf8 handles. "
1745 "This will be a fatal error in Perl 5.30",
1748 buffer = SvPVutf8_force(bufsv, blen);
1749 /* UTF-8 may not have been set if they are all low bytes */
1754 buffer = SvPV_force(bufsv, blen);
1755 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
1757 if (DO_UTF8(bufsv)) {
1758 blen = sv_len_utf8_nomg(bufsv);
1767 if (PL_op->op_type == OP_RECV) {
1768 Sock_size_t bufsize;
1769 char namebuf[MAXPATHLEN];
1771 SETERRNO(EBADF,SS_IVCHAN);
1774 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
1775 bufsize = sizeof (struct sockaddr_in);
1777 bufsize = sizeof namebuf;
1779 #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1783 buffer = SvGROW(bufsv, (STRLEN)(length+1));
1784 /* 'offset' means 'flags' here */
1785 count = PerlSock_recvfrom(fd, buffer, length, offset,
1786 (struct sockaddr *)namebuf, &bufsize);
1789 /* MSG_TRUNC can give oversized count; quietly lose it */
1792 SvCUR_set(bufsv, count);
1793 *SvEND(bufsv) = '\0';
1794 (void)SvPOK_only(bufsv);
1798 /* This should not be marked tainted if the fp is marked clean */
1799 if (!(IoFLAGS(io) & IOf_UNTAINT))
1800 SvTAINTED_on(bufsv);
1802 #if defined(__CYGWIN__)
1803 /* recvfrom() on cygwin doesn't set bufsize at all for
1804 connected sockets, leaving us with trash in the returned
1805 name, so use the same test as the Win32 code to check if it
1806 wasn't set, and set it [perl #118843] */
1807 if (bufsize == sizeof namebuf)
1810 sv_setpvn(TARG, namebuf, bufsize);
1816 if (-offset > (SSize_t)blen)
1817 DIE(aTHX_ "Offset outside string");
1820 if (DO_UTF8(bufsv)) {
1821 /* convert offset-as-chars to offset-as-bytes */
1822 if (offset >= (SSize_t)blen)
1823 offset += SvCUR(bufsv) - blen;
1825 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1829 /* Reestablish the fd in case it shifted from underneath us. */
1830 fd = PerlIO_fileno(IoIFP(io));
1832 orig_size = SvCUR(bufsv);
1833 /* Allocating length + offset + 1 isn't perfect in the case of reading
1834 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1836 (should be 2 * length + offset + 1, or possibly something longer if
1837 IN_ENCODING Is true) */
1838 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
1839 if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1840 Zero(buffer+orig_size, offset-orig_size, char);
1842 buffer = buffer + offset;
1844 read_target = bufsv;
1846 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1847 concatenate it to the current buffer. */
1849 /* Truncate the existing buffer to the start of where we will be
1851 SvCUR_set(bufsv, offset);
1853 read_target = sv_newmortal();
1854 SvUPGRADE(read_target, SVt_PV);
1855 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1858 if (PL_op->op_type == OP_SYSREAD) {
1859 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1860 if (IoTYPE(io) == IoTYPE_SOCKET) {
1862 SETERRNO(EBADF,SS_IVCHAN);
1866 count = PerlSock_recv(fd, buffer, length, 0);
1872 SETERRNO(EBADF,RMS_IFI);
1876 count = PerlLIO_read(fd, buffer, length);
1881 count = PerlIO_read(IoIFP(io), buffer, length);
1882 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1883 if (count == 0 && PerlIO_error(IoIFP(io)))
1887 if (IoTYPE(io) == IoTYPE_WRONLY)
1888 report_wrongway_fh(gv, '>');
1891 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1892 *SvEND(read_target) = '\0';
1893 (void)SvPOK_only(read_target);
1894 if (fp_utf8 && !IN_BYTES) {
1895 /* Look at utf8 we got back and count the characters */
1896 const char *bend = buffer + count;
1897 while (buffer < bend) {
1899 skip = UTF8SKIP(buffer);
1902 if (buffer - charskip + skip > bend) {
1903 /* partial character - try for rest of it */
1904 length = skip - (bend-buffer);
1905 offset = bend - SvPVX_const(bufsv);
1917 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1918 provided amount read (count) was what was requested (length)
1920 if (got < wanted && count == length) {
1921 length = wanted - got;
1922 offset = bend - SvPVX_const(bufsv);
1925 /* return value is character count */
1929 else if (buffer_utf8) {
1930 /* Let svcatsv upgrade the bytes we read in to utf8.
1931 The buffer is a mortal so will be freed soon. */
1932 sv_catsv_nomg(bufsv, read_target);
1935 /* This should not be marked tainted if the fp is marked clean */
1936 if (!(IoFLAGS(io) & IOf_UNTAINT))
1937 SvTAINTED_on(bufsv);
1948 /* also used for: pp_send() where defined */
1952 dSP; dMARK; dORIGMARK; dTARGET;
1957 STRLEN orig_blen_bytes;
1958 const int op_type = PL_op->op_type;
1961 GV *const gv = MUTABLE_GV(*++MARK);
1962 IO *const io = GvIO(gv);
1965 if (op_type == OP_SYSWRITE && io) {
1966 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1968 if (MARK == SP - 1) {
1970 mXPUSHi(sv_len(sv));
1974 return Perl_tied_method(aTHX_ SV_CONST(WRITE), mark - 1, MUTABLE_SV(io), mg,
1975 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1985 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1987 if (io && IoIFP(io))
1988 report_wrongway_fh(gv, '<');
1991 SETERRNO(EBADF,RMS_IFI);
1994 fd = PerlIO_fileno(IoIFP(io));
1996 SETERRNO(EBADF,SS_IVCHAN);
2001 /* Do this first to trigger any overloading. */
2002 buffer = SvPV_const(bufsv, blen);
2003 orig_blen_bytes = blen;
2004 doing_utf8 = DO_UTF8(bufsv);
2006 if (PerlIO_isutf8(IoIFP(io))) {
2007 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
2008 "%s() is deprecated on :utf8 handles. "
2009 "This will be a fatal error in Perl 5.30",
2011 if (!SvUTF8(bufsv)) {
2012 /* We don't modify the original scalar. */
2013 tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
2014 buffer = (char *) tmpbuf;
2018 else if (doing_utf8) {
2019 STRLEN tmplen = blen;
2020 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
2023 buffer = (char *) tmpbuf;
2027 assert((char *)result == buffer);
2028 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
2033 if (op_type == OP_SEND) {
2034 const int flags = SvIVx(*++MARK);
2037 char * const sockbuf = SvPVx(*++MARK, mlen);
2038 retval = PerlSock_sendto(fd, buffer, blen,
2039 flags, (struct sockaddr *)sockbuf, mlen);
2042 retval = PerlSock_send(fd, buffer, blen, flags);
2048 Size_t length = 0; /* This length is in characters. */
2054 /* The SV is bytes, and we've had to upgrade it. */
2055 blen_chars = orig_blen_bytes;
2057 /* The SV really is UTF-8. */
2058 /* Don't call sv_len_utf8 on a magical or overloaded
2059 scalar, as we might get back a different result. */
2060 blen_chars = sv_or_pv_len_utf8(bufsv, buffer, blen);
2067 length = blen_chars;
2069 #if Size_t_size > IVSIZE
2070 length = (Size_t)SvNVx(*++MARK);
2072 length = (Size_t)SvIVx(*++MARK);
2074 if ((SSize_t)length < 0) {
2076 DIE(aTHX_ "Negative length");
2081 offset = SvIVx(*++MARK);
2083 if (-offset > (IV)blen_chars) {
2085 DIE(aTHX_ "Offset outside string");
2087 offset += blen_chars;
2088 } else if (offset > (IV)blen_chars) {
2090 DIE(aTHX_ "Offset outside string");
2094 if (length > blen_chars - offset)
2095 length = blen_chars - offset;
2097 /* Here we convert length from characters to bytes. */
2098 if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
2099 /* Either we had to convert the SV, or the SV is magical, or
2100 the SV has overloading, in which case we can't or mustn't
2101 or mustn't call it again. */
2103 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
2104 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
2106 /* It's a real UTF-8 SV, and it's not going to change under
2107 us. Take advantage of any cache. */
2109 I32 len_I32 = length;
2111 /* Convert the start and end character positions to bytes.
2112 Remember that the second argument to sv_pos_u2b is relative
2114 sv_pos_u2b(bufsv, &start, &len_I32);
2121 buffer = buffer+offset;
2123 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2124 if (IoTYPE(io) == IoTYPE_SOCKET) {
2125 retval = PerlSock_send(fd, buffer, length, 0);
2130 /* See the note at doio.c:do_print about filesize limits. --jhi */
2131 retval = PerlLIO_write(fd, buffer, length);
2139 retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
2142 #if Size_t_size > IVSIZE
2162 * in Perl 5.12 and later, the additional parameter is a bitmask:
2165 * 2 = eof() <- ARGV magic
2167 * I'll rely on the compiler's trace flow analysis to decide whether to
2168 * actually assign this out here, or punt it into the only block where it is
2169 * used. Doing it out here is DRY on the condition logic.
2174 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
2180 if (PL_op->op_flags & OPf_SPECIAL) {
2181 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
2185 gv = PL_last_in_gv; /* eof */
2193 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2194 return tied_method1(SV_CONST(EOF), SP, MUTABLE_SV(io), mg, newSVuv(which));
2197 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2198 if (io && !IoIFP(io)) {
2199 if ((IoFLAGS(io) & IOf_START) && av_tindex(GvAVn(gv)) < 0) {
2202 IoFLAGS(io) &= ~IOf_START;
2203 do_open6(gv, "-", 1, NULL, NULL, 0);
2211 *svp = newSVpvs("-");
2213 else if (!nextargv(gv, FALSE))
2218 PUSHs(boolSV(do_eof(gv)));
2228 if (MAXARG != 0 && (TOPs || POPs))
2229 PL_last_in_gv = MUTABLE_GV(POPs);
2236 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2238 return tied_method0(SV_CONST(TELL), SP, MUTABLE_SV(io), mg);
2243 SETERRNO(EBADF,RMS_IFI);
2248 #if LSEEKSIZE > IVSIZE
2249 PUSHn( do_tell(gv) );
2251 PUSHi( do_tell(gv) );
2257 /* also used for: pp_seek() */
2262 const int whence = POPi;
2263 #if LSEEKSIZE > IVSIZE
2264 const Off_t offset = (Off_t)SvNVx(POPs);
2266 const Off_t offset = (Off_t)SvIVx(POPs);
2269 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2270 IO *const io = GvIO(gv);
2273 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2275 #if LSEEKSIZE > IVSIZE
2276 SV *const offset_sv = newSVnv((NV) offset);
2278 SV *const offset_sv = newSViv(offset);
2281 return tied_method2(SV_CONST(SEEK), SP, MUTABLE_SV(io), mg, offset_sv,
2286 if (PL_op->op_type == OP_SEEK)
2287 PUSHs(boolSV(do_seek(gv, offset, whence)));
2289 const Off_t sought = do_sysseek(gv, offset, whence);
2291 PUSHs(&PL_sv_undef);
2293 SV* const sv = sought ?
2294 #if LSEEKSIZE > IVSIZE
2299 : newSVpvn(zero_but_true, ZBTLEN);
2309 /* There seems to be no consensus on the length type of truncate()
2310 * and ftruncate(), both off_t and size_t have supporters. In
2311 * general one would think that when using large files, off_t is
2312 * at least as wide as size_t, so using an off_t should be okay. */
2313 /* XXX Configure probe for the length type of *truncate() needed XXX */
2316 #if Off_t_size > IVSIZE
2321 /* Checking for length < 0 is problematic as the type might or
2322 * might not be signed: if it is not, clever compilers will moan. */
2323 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2326 SV * const sv = POPs;
2331 if (PL_op->op_flags & OPf_SPECIAL
2332 ? (tmpgv = gv_fetchsv(sv, 0, SVt_PVIO), 1)
2333 : !!(tmpgv = MAYBE_DEREF_GV(sv)) ) {
2340 TAINT_PROPER("truncate");
2341 if (!(fp = IoIFP(io))) {
2345 int fd = PerlIO_fileno(fp);
2347 SETERRNO(EBADF,RMS_IFI);
2351 SETERRNO(EINVAL, LIB_INVARG);
2356 if (ftruncate(fd, len) < 0)
2358 if (my_chsize(fd, len) < 0)
2366 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2367 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2368 goto do_ftruncate_io;
2371 const char * const name = SvPV_nomg_const_nolen(sv);
2372 TAINT_PROPER("truncate");
2374 if (truncate(name, len) < 0)
2381 #if defined(USE_64_BIT_RAWIO) && defined(O_LARGEFILE)
2382 mode |= O_LARGEFILE; /* Transparently largefiley. */
2385 /* On open(), the Win32 CRT tries to seek around text
2386 * files using 32-bit offsets, which causes the open()
2387 * to fail on large files, so open in binary mode.
2391 tmpfd = PerlLIO_open(name, mode);
2396 if (my_chsize(tmpfd, len) < 0)
2398 PerlLIO_close(tmpfd);
2407 SETERRNO(EBADF,RMS_IFI);
2413 /* also used for: pp_fcntl() */
2418 SV * const argsv = POPs;
2419 const unsigned int func = POPu;
2421 GV * const gv = MUTABLE_GV(POPs);
2422 IO * const io = GvIOn(gv);
2428 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
2432 if (SvPOK(argsv) || !SvNIOK(argsv)) {
2435 s = SvPV_force(argsv, len);
2436 need = IOCPARM_LEN(func);
2438 s = Sv_Grow(argsv, need + 1);
2439 SvCUR_set(argsv, need);
2442 s[SvCUR(argsv)] = 17; /* a little sanity check here */
2445 retval = SvIV(argsv);
2446 s = INT2PTR(char*,retval); /* ouch */
2449 optype = PL_op->op_type;
2450 TAINT_PROPER(PL_op_desc[optype]);
2452 if (optype == OP_IOCTL)
2454 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2456 DIE(aTHX_ "ioctl is not implemented");
2460 DIE(aTHX_ "fcntl is not implemented");
2462 #if defined(OS2) && defined(__EMX__)
2463 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2465 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2469 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2471 if (s[SvCUR(argsv)] != 17)
2472 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2474 s[SvCUR(argsv)] = 0; /* put our null back */
2475 SvSETMAGIC(argsv); /* Assume it has changed */
2484 PUSHp(zero_but_true, ZBTLEN);
2495 const int argtype = POPi;
2496 GV * const gv = MUTABLE_GV(POPs);
2497 IO *const io = GvIO(gv);
2498 PerlIO *const fp = io ? IoIFP(io) : NULL;
2500 /* XXX Looks to me like io is always NULL at this point */
2502 (void)PerlIO_flush(fp);
2503 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2508 SETERRNO(EBADF,RMS_IFI);
2513 DIE(aTHX_ PL_no_func, "flock");
2524 const int protocol = POPi;
2525 const int type = POPi;
2526 const int domain = POPi;
2527 GV * const gv = MUTABLE_GV(POPs);
2528 IO * const io = GvIOn(gv);
2532 do_close(gv, FALSE);
2534 TAINT_PROPER("socket");
2535 fd = PerlSock_socket(domain, type, protocol);
2539 IoIFP(io) = PerlIO_fdopen(fd, "r" SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2540 IoOFP(io) = PerlIO_fdopen(fd, "w" SOCKET_OPEN_MODE);
2541 IoTYPE(io) = IoTYPE_SOCKET;
2542 if (!IoIFP(io) || !IoOFP(io)) {
2543 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2544 if (IoOFP(io)) PerlIO_close(IoOFP(io));
2545 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2548 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
2549 /* ensure close-on-exec */
2550 if (fd > PL_maxsysfd && fcntl(fd, F_SETFD, FD_CLOEXEC) < 0)
2560 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2563 const int protocol = POPi;
2564 const int type = POPi;
2565 const int domain = POPi;
2567 GV * const gv2 = MUTABLE_GV(POPs);
2568 IO * const io2 = GvIOn(gv2);
2569 GV * const gv1 = MUTABLE_GV(POPs);
2570 IO * const io1 = GvIOn(gv1);
2573 do_close(gv1, FALSE);
2575 do_close(gv2, FALSE);
2577 TAINT_PROPER("socketpair");
2578 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2580 IoIFP(io1) = PerlIO_fdopen(fd[0], "r" SOCKET_OPEN_MODE);
2581 IoOFP(io1) = PerlIO_fdopen(fd[0], "w" SOCKET_OPEN_MODE);
2582 IoTYPE(io1) = IoTYPE_SOCKET;
2583 IoIFP(io2) = PerlIO_fdopen(fd[1], "r" SOCKET_OPEN_MODE);
2584 IoOFP(io2) = PerlIO_fdopen(fd[1], "w" SOCKET_OPEN_MODE);
2585 IoTYPE(io2) = IoTYPE_SOCKET;
2586 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2587 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2588 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2589 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2590 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2591 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2592 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2595 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
2596 /* ensure close-on-exec */
2597 if ((fd[0] > PL_maxsysfd && fcntl(fd[0], F_SETFD, FD_CLOEXEC) < 0) ||
2598 (fd[1] > PL_maxsysfd && fcntl(fd[1], F_SETFD, FD_CLOEXEC) < 0))
2604 DIE(aTHX_ PL_no_sock_func, "socketpair");
2610 /* also used for: pp_connect() */
2615 SV * const addrsv = POPs;
2616 /* OK, so on what platform does bind modify addr? */
2618 GV * const gv = MUTABLE_GV(POPs);
2619 IO * const io = GvIOn(gv);
2626 fd = PerlIO_fileno(IoIFP(io));
2630 addr = SvPV_const(addrsv, len);
2631 op_type = PL_op->op_type;
2632 TAINT_PROPER(PL_op_desc[op_type]);
2633 if ((op_type == OP_BIND
2634 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2635 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2643 SETERRNO(EBADF,SS_IVCHAN);
2650 const int backlog = POPi;
2651 GV * const gv = MUTABLE_GV(POPs);
2652 IO * const io = GvIOn(gv);
2657 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2664 SETERRNO(EBADF,SS_IVCHAN);
2672 char namebuf[MAXPATHLEN];
2673 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2674 Sock_size_t len = sizeof (struct sockaddr_in);
2676 Sock_size_t len = sizeof namebuf;
2678 GV * const ggv = MUTABLE_GV(POPs);
2679 GV * const ngv = MUTABLE_GV(POPs);
2682 IO * const gstio = GvIO(ggv);
2683 if (!gstio || !IoIFP(gstio))
2687 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2690 /* Some platforms indicate zero length when an AF_UNIX client is
2691 * not bound. Simulate a non-zero-length sockaddr structure in
2693 namebuf[0] = 0; /* sun_len */
2694 namebuf[1] = AF_UNIX; /* sun_family */
2702 do_close(ngv, FALSE);
2703 IoIFP(nstio) = PerlIO_fdopen(fd, "r" SOCKET_OPEN_MODE);
2704 IoOFP(nstio) = PerlIO_fdopen(fd, "w" SOCKET_OPEN_MODE);
2705 IoTYPE(nstio) = IoTYPE_SOCKET;
2706 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2707 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2708 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2709 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2712 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
2713 /* ensure close-on-exec */
2714 if (fd > PL_maxsysfd && fcntl(fd, F_SETFD, FD_CLOEXEC) < 0)
2718 #ifdef __SCO_VERSION__
2719 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2722 PUSHp(namebuf, len);
2726 report_evil_fh(ggv);
2727 SETERRNO(EBADF,SS_IVCHAN);
2737 const int how = POPi;
2738 GV * const gv = MUTABLE_GV(POPs);
2739 IO * const io = GvIOn(gv);
2744 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2749 SETERRNO(EBADF,SS_IVCHAN);
2754 /* also used for: pp_gsockopt() */
2759 const int optype = PL_op->op_type;
2760 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2761 const unsigned int optname = (unsigned int) POPi;
2762 const unsigned int lvl = (unsigned int) POPi;
2763 GV * const gv = MUTABLE_GV(POPs);
2764 IO * const io = GvIOn(gv);
2771 fd = PerlIO_fileno(IoIFP(io));
2777 (void)SvPOK_only(sv);
2781 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2784 /* XXX Configure test: does getsockopt set the length properly? */
2793 #if defined(__SYMBIAN32__)
2794 # define SETSOCKOPT_OPTION_VALUE_T void *
2796 # define SETSOCKOPT_OPTION_VALUE_T const char *
2798 /* XXX TODO: We need to have a proper type (a Configure probe,
2799 * etc.) for what the C headers think of the third argument of
2800 * setsockopt(), the option_value read-only buffer: is it
2801 * a "char *", or a "void *", const or not. Some compilers
2802 * don't take kindly to e.g. assuming that "char *" implicitly
2803 * promotes to a "void *", or to explicitly promoting/demoting
2804 * consts to non/vice versa. The "const void *" is the SUS
2805 * definition, but that does not fly everywhere for the above
2807 SETSOCKOPT_OPTION_VALUE_T buf;
2811 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2815 aint = (int)SvIV(sv);
2816 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2819 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2829 SETERRNO(EBADF,SS_IVCHAN);
2836 /* also used for: pp_getsockname() */
2841 const int optype = PL_op->op_type;
2842 GV * const gv = MUTABLE_GV(POPs);
2843 IO * const io = GvIOn(gv);
2851 sv = sv_2mortal(newSV(257));
2852 (void)SvPOK_only(sv);
2856 fd = PerlIO_fileno(IoIFP(io));
2860 case OP_GETSOCKNAME:
2861 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2864 case OP_GETPEERNAME:
2865 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2867 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2869 static const char nowhere[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
2870 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2871 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2872 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2873 sizeof(u_short) + sizeof(struct in_addr))) {
2880 #ifdef BOGUS_GETNAME_RETURN
2881 /* Interactive Unix, getpeername() and getsockname()
2882 does not return valid namelen */
2883 if (len == BOGUS_GETNAME_RETURN)
2884 len = sizeof(struct sockaddr);
2893 SETERRNO(EBADF,SS_IVCHAN);
2902 /* also used for: pp_lstat() */
2913 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2914 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2915 if (PL_op->op_type == OP_LSTAT) {
2916 if (gv != PL_defgv) {
2917 do_fstat_warning_check:
2918 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2919 "lstat() on filehandle%s%" SVf,
2922 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2924 } else if (PL_laststype != OP_LSTAT)
2925 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2926 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2929 if (gv != PL_defgv) {
2933 PL_laststype = OP_STAT;
2934 PL_statgv = gv ? gv : (GV *)io;
2935 SvPVCLEAR(PL_statname);
2941 int fd = PerlIO_fileno(IoIFP(io));
2943 PL_laststatval = -1;
2944 SETERRNO(EBADF,RMS_IFI);
2946 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2949 } else if (IoDIRP(io)) {
2951 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2954 PL_laststatval = -1;
2957 else PL_laststatval = -1;
2958 if (PL_laststatval < 0 && !havefp) report_evil_fh(gv);
2961 if (PL_laststatval < 0) {
2967 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2968 io = MUTABLE_IO(SvRV(sv));
2969 if (PL_op->op_type == OP_LSTAT)
2970 goto do_fstat_warning_check;
2971 goto do_fstat_have_io;
2974 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2975 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2977 PL_laststype = PL_op->op_type;
2978 file = SvPV_nolen_const(PL_statname);
2979 if (PL_op->op_type == OP_LSTAT)
2980 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2982 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2983 if (PL_laststatval < 0) {
2984 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2985 /* PL_warn_nl is constant */
2986 GCC_DIAG_IGNORE(-Wformat-nonliteral);
2987 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2995 if (gimme != G_ARRAY) {
2996 if (gimme != G_VOID)
2997 XPUSHs(boolSV(max));
3003 mPUSHi(PL_statcache.st_dev);
3004 #if ST_INO_SIZE > IVSIZE
3005 mPUSHn(PL_statcache.st_ino);
3007 # if ST_INO_SIGN <= 0
3008 mPUSHi(PL_statcache.st_ino);
3010 mPUSHu(PL_statcache.st_ino);
3013 mPUSHu(PL_statcache.st_mode);
3014 mPUSHu(PL_statcache.st_nlink);
3016 sv_setuid(PUSHmortal, PL_statcache.st_uid);
3017 sv_setgid(PUSHmortal, PL_statcache.st_gid);
3019 #ifdef USE_STAT_RDEV
3020 mPUSHi(PL_statcache.st_rdev);
3022 PUSHs(newSVpvs_flags("", SVs_TEMP));
3024 #if Off_t_size > IVSIZE
3025 mPUSHn(PL_statcache.st_size);
3027 mPUSHi(PL_statcache.st_size);
3030 mPUSHn(PL_statcache.st_atime);
3031 mPUSHn(PL_statcache.st_mtime);
3032 mPUSHn(PL_statcache.st_ctime);
3034 mPUSHi(PL_statcache.st_atime);
3035 mPUSHi(PL_statcache.st_mtime);
3036 mPUSHi(PL_statcache.st_ctime);
3038 #ifdef USE_STAT_BLOCKS
3039 mPUSHu(PL_statcache.st_blksize);
3040 mPUSHu(PL_statcache.st_blocks);
3042 PUSHs(newSVpvs_flags("", SVs_TEMP));
3043 PUSHs(newSVpvs_flags("", SVs_TEMP));
3049 /* All filetest ops avoid manipulating the perl stack pointer in their main
3050 bodies (since commit d2c4d2d1e22d3125), and return using either
3051 S_ft_return_false() or S_ft_return_true(). These two helper functions are
3052 the only two which manipulate the perl stack. To ensure that no stack
3053 manipulation macros are used, the filetest ops avoid defining a local copy
3054 of the stack pointer with dSP. */
3056 /* If the next filetest is stacked up with this one
3057 (PL_op->op_private & OPpFT_STACKING), we leave
3058 the original argument on the stack for success,
3059 and skip the stacked operators on failure.
3060 The next few macros/functions take care of this.
3064 S_ft_return_false(pTHX_ SV *ret) {
3068 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
3072 if (PL_op->op_private & OPpFT_STACKING) {
3073 while (OP_IS_FILETEST(next->op_type)
3074 && next->op_private & OPpFT_STACKED)
3075 next = next->op_next;
3080 PERL_STATIC_INLINE OP *
3081 S_ft_return_true(pTHX_ SV *ret) {
3083 if (PL_op->op_flags & OPf_REF)
3084 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
3085 else if (!(PL_op->op_private & OPpFT_STACKING))
3091 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
3092 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
3093 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
3095 #define tryAMAGICftest_MG(chr) STMT_START { \
3096 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
3097 && PL_op->op_flags & OPf_KIDS) { \
3098 OP *next = S_try_amagic_ftest(aTHX_ chr); \
3099 if (next) return next; \
3104 S_try_amagic_ftest(pTHX_ char chr) {
3105 SV *const arg = *PL_stack_sp;
3108 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
3112 const char tmpchr = chr;
3113 SV * const tmpsv = amagic_call(arg,
3114 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
3115 ftest_amg, AMGf_unary);
3120 return SvTRUE(tmpsv)
3121 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3127 /* also used for: pp_fteexec() pp_fteread() pp_ftewrite() pp_ftrexec()
3133 /* Not const, because things tweak this below. Not bool, because there's
3134 no guarantee that OPpFT_ACCESS is <= CHAR_MAX */
3135 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3136 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3137 /* Giving some sort of initial value silences compilers. */
3139 int access_mode = R_OK;
3141 int access_mode = 0;
3144 /* access_mode is never used, but leaving use_access in makes the
3145 conditional compiling below much clearer. */
3148 Mode_t stat_mode = S_IRUSR;
3150 bool effective = FALSE;
3153 switch (PL_op->op_type) {
3154 case OP_FTRREAD: opchar = 'R'; break;
3155 case OP_FTRWRITE: opchar = 'W'; break;
3156 case OP_FTREXEC: opchar = 'X'; break;
3157 case OP_FTEREAD: opchar = 'r'; break;
3158 case OP_FTEWRITE: opchar = 'w'; break;
3159 case OP_FTEEXEC: opchar = 'x'; break;
3161 tryAMAGICftest_MG(opchar);
3163 switch (PL_op->op_type) {
3165 #if !(defined(HAS_ACCESS) && defined(R_OK))
3171 #if defined(HAS_ACCESS) && defined(W_OK)
3176 stat_mode = S_IWUSR;
3180 #if defined(HAS_ACCESS) && defined(X_OK)
3185 stat_mode = S_IXUSR;
3189 #ifdef PERL_EFF_ACCESS
3192 stat_mode = S_IWUSR;
3196 #ifndef PERL_EFF_ACCESS
3203 #ifdef PERL_EFF_ACCESS
3208 stat_mode = S_IXUSR;
3214 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3215 const char *name = SvPV_nolen(*PL_stack_sp);
3217 # ifdef PERL_EFF_ACCESS
3218 result = PERL_EFF_ACCESS(name, access_mode);
3220 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3226 result = access(name, access_mode);
3228 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3239 result = my_stat_flags(0);
3242 if (cando(stat_mode, effective, &PL_statcache))
3248 /* also used for: pp_ftatime() pp_ftctime() pp_ftmtime() pp_ftsize() */
3253 const int op_type = PL_op->op_type;
3257 case OP_FTIS: opchar = 'e'; break;
3258 case OP_FTSIZE: opchar = 's'; break;
3259 case OP_FTMTIME: opchar = 'M'; break;
3260 case OP_FTCTIME: opchar = 'C'; break;
3261 case OP_FTATIME: opchar = 'A'; break;
3263 tryAMAGICftest_MG(opchar);
3265 result = my_stat_flags(0);
3268 if (op_type == OP_FTIS)
3271 /* You can't dTARGET inside OP_FTIS, because you'll get
3272 "panic: pad_sv po" - the op is not flagged to have a target. */
3276 #if Off_t_size > IVSIZE
3277 sv_setnv(TARG, (NV)PL_statcache.st_size);
3279 sv_setiv(TARG, (IV)PL_statcache.st_size);
3284 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3288 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3292 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3296 return SvTRUE_nomg(TARG)
3297 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3302 /* also used for: pp_ftblk() pp_ftchr() pp_ftdir() pp_fteowned()
3303 * pp_ftfile() pp_ftpipe() pp_ftsgid() pp_ftsock()
3304 * pp_ftsuid() pp_ftsvtx() pp_ftzero() */
3311 switch (PL_op->op_type) {
3312 case OP_FTROWNED: opchar = 'O'; break;
3313 case OP_FTEOWNED: opchar = 'o'; break;
3314 case OP_FTZERO: opchar = 'z'; break;
3315 case OP_FTSOCK: opchar = 'S'; break;
3316 case OP_FTCHR: opchar = 'c'; break;
3317 case OP_FTBLK: opchar = 'b'; break;
3318 case OP_FTFILE: opchar = 'f'; break;
3319 case OP_FTDIR: opchar = 'd'; break;
3320 case OP_FTPIPE: opchar = 'p'; break;
3321 case OP_FTSUID: opchar = 'u'; break;
3322 case OP_FTSGID: opchar = 'g'; break;
3323 case OP_FTSVTX: opchar = 'k'; break;
3325 tryAMAGICftest_MG(opchar);
3327 /* I believe that all these three are likely to be defined on most every
3328 system these days. */
3330 if(PL_op->op_type == OP_FTSUID) {
3335 if(PL_op->op_type == OP_FTSGID) {
3340 if(PL_op->op_type == OP_FTSVTX) {
3345 result = my_stat_flags(0);
3348 switch (PL_op->op_type) {
3350 if (PL_statcache.st_uid == PerlProc_getuid())
3354 if (PL_statcache.st_uid == PerlProc_geteuid())
3358 if (PL_statcache.st_size == 0)
3362 if (S_ISSOCK(PL_statcache.st_mode))
3366 if (S_ISCHR(PL_statcache.st_mode))
3370 if (S_ISBLK(PL_statcache.st_mode))
3374 if (S_ISREG(PL_statcache.st_mode))
3378 if (S_ISDIR(PL_statcache.st_mode))
3382 if (S_ISFIFO(PL_statcache.st_mode))
3387 if (PL_statcache.st_mode & S_ISUID)
3393 if (PL_statcache.st_mode & S_ISGID)
3399 if (PL_statcache.st_mode & S_ISVTX)
3411 tryAMAGICftest_MG('l');
3412 result = my_lstat_flags(0);
3416 if (S_ISLNK(PL_statcache.st_mode))
3429 tryAMAGICftest_MG('t');
3431 if (PL_op->op_flags & OPf_REF)
3434 SV *tmpsv = *PL_stack_sp;
3435 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3436 name = SvPV_nomg(tmpsv, namelen);
3437 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3441 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3442 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3443 else if (name && isDIGIT(*name) && grok_atoUV(name, &uv, NULL) && uv <= PERL_INT_MAX)
3448 SETERRNO(EBADF,RMS_IFI);
3451 if (PerlLIO_isatty(fd))
3457 /* also used for: pp_ftbinary() */
3471 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3473 if (PL_op->op_flags & OPf_REF)
3475 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3480 gv = MAYBE_DEREF_GV_nomg(sv);
3484 if (gv == PL_defgv) {
3486 io = SvTYPE(PL_statgv) == SVt_PVIO
3490 goto really_filename;
3495 SvPVCLEAR(PL_statname);
3496 io = GvIO(PL_statgv);
3498 PL_laststatval = -1;
3499 PL_laststype = OP_STAT;
3500 if (io && IoIFP(io)) {
3502 if (! PerlIO_has_base(IoIFP(io)))
3503 DIE(aTHX_ "-T and -B not implemented on filehandles");
3504 fd = PerlIO_fileno(IoIFP(io));
3506 SETERRNO(EBADF,RMS_IFI);
3509 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3510 if (PL_laststatval < 0)
3512 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3513 if (PL_op->op_type == OP_FTTEXT)
3518 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3519 i = PerlIO_getc(IoIFP(io));
3521 (void)PerlIO_ungetc(IoIFP(io),i);
3523 /* null file is anything */
3526 len = PerlIO_get_bufsiz(IoIFP(io));
3527 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3528 /* sfio can have large buffers - limit to 512 */
3533 SETERRNO(EBADF,RMS_IFI);
3535 SETERRNO(EBADF,RMS_IFI);
3544 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3546 file = SvPVX_const(PL_statname);
3548 if (!(fp = PerlIO_open(file, "r"))) {
3550 PL_laststatval = -1;
3551 PL_laststype = OP_STAT;
3553 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3554 /* PL_warn_nl is constant */
3555 GCC_DIAG_IGNORE(-Wformat-nonliteral);
3556 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3561 PL_laststype = OP_STAT;
3562 fd = PerlIO_fileno(fp);
3564 (void)PerlIO_close(fp);
3565 SETERRNO(EBADF,RMS_IFI);
3568 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3569 if (PL_laststatval < 0) {
3571 (void)PerlIO_close(fp);
3575 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3576 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3577 (void)PerlIO_close(fp);
3579 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3580 FT_RETURNNO; /* special case NFS directories */
3581 FT_RETURNYES; /* null file is anything */
3586 /* now scan s to look for textiness */
3588 #if defined(DOSISH) || defined(USEMYBINMODE)
3589 /* ignore trailing ^Z on short files */
3590 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3595 if (! is_utf8_invariant_string((U8 *) s, len)) {
3597 /* Here contains a variant under UTF-8 . See if the entire string is
3599 if (is_utf8_fixed_width_buf_flags((U8 *) s, len, 0)) {
3600 if (PL_op->op_type == OP_FTTEXT) {
3609 /* Here, is not UTF-8 or is entirely ASCII. Look through the buffer for
3610 * things that wouldn't be in ASCII text or rich ASCII text. Count these
3612 for (i = 0; i < len; i++, s++) {
3613 if (!*s) { /* null never allowed in text */
3617 #ifdef USE_LOCALE_CTYPE
3618 if (IN_LC_RUNTIME(LC_CTYPE)) {
3619 if ( isPRINT_LC(*s) || isSPACE_LC(*s)) {
3626 /* VT occurs so rarely in text, that we consider it odd */
3627 || (isSPACE_A(*s) && *s != VT_NATIVE)
3629 /* But there is a fair amount of backspaces and escapes in
3632 || *s == ESC_NATIVE)
3639 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3650 const char *tmps = NULL;
3654 SV * const sv = POPs;
3655 if (PL_op->op_flags & OPf_SPECIAL) {
3656 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3658 if (ckWARN(WARN_UNOPENED)) {
3659 Perl_warner(aTHX_ packWARN(WARN_UNOPENED),
3660 "chdir() on unopened filehandle %" SVf, sv);
3662 SETERRNO(EBADF,RMS_IFI);
3664 TAINT_PROPER("chdir");
3668 else if (!(gv = MAYBE_DEREF_GV(sv)))
3669 tmps = SvPV_nomg_const_nolen(sv);
3672 HV * const table = GvHVn(PL_envgv);
3676 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3677 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3679 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3683 tmps = SvPV_nolen_const(*svp);
3687 SETERRNO(EINVAL, LIB_INVARG);
3688 TAINT_PROPER("chdir");
3693 TAINT_PROPER("chdir");
3696 IO* const io = GvIO(gv);
3699 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3700 } else if (IoIFP(io)) {
3701 int fd = PerlIO_fileno(IoIFP(io));
3705 PUSHi(fchdir(fd) >= 0);
3715 DIE(aTHX_ PL_no_func, "fchdir");
3719 PUSHi( PerlDir_chdir(tmps) >= 0 );
3721 /* Clear the DEFAULT element of ENV so we'll get the new value
3723 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3730 SETERRNO(EBADF,RMS_IFI);
3737 /* also used for: pp_chmod() pp_kill() pp_unlink() pp_utime() */
3741 dSP; dMARK; dTARGET;
3742 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3753 char * const tmps = POPpx;
3754 TAINT_PROPER("chroot");
3755 PUSHi( chroot(tmps) >= 0 );
3758 DIE(aTHX_ PL_no_func, "chroot");
3769 const char * const tmps2 = POPpconstx;
3770 const char * const tmps = SvPV_nolen_const(TOPs);
3771 TAINT_PROPER("rename");
3773 anum = PerlLIO_rename(tmps, tmps2);
3775 if (!(anum = PerlLIO_stat(tmps, &statbuf))) {
3776 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3779 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &statbuf) < 0 || !S_ISDIR(statbuf.st_mode))
3780 (void)UNLINK(tmps2);
3781 if (!(anum = link(tmps, tmps2)))
3782 anum = UNLINK(tmps);
3791 /* also used for: pp_symlink() */
3793 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3797 const int op_type = PL_op->op_type;
3801 if (op_type == OP_LINK)
3802 DIE(aTHX_ PL_no_func, "link");
3804 # ifndef HAS_SYMLINK
3805 if (op_type == OP_SYMLINK)
3806 DIE(aTHX_ PL_no_func, "symlink");
3810 const char * const tmps2 = POPpconstx;
3811 const char * const tmps = SvPV_nolen_const(TOPs);
3812 TAINT_PROPER(PL_op_desc[op_type]);
3814 # if defined(HAS_LINK)
3815 # if defined(HAS_SYMLINK)
3816 /* Both present - need to choose which. */
3817 (op_type == OP_LINK) ?
3818 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3820 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3821 PerlLIO_link(tmps, tmps2);
3824 # if defined(HAS_SYMLINK)
3825 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3826 symlink(tmps, tmps2);
3831 SETi( result >= 0 );
3836 /* also used for: pp_symlink() */
3841 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3851 char buf[MAXPATHLEN];
3856 /* NOTE: if the length returned by readlink() is sizeof(buf) - 1,
3857 * it is impossible to know whether the result was truncated. */
3858 len = readlink(tmps, buf, sizeof(buf) - 1);
3867 RETSETUNDEF; /* just pretend it's a normal file */
3871 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3873 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3875 char * const save_filename = filename;
3880 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3882 PERL_ARGS_ASSERT_DOONELINER;
3884 Newx(cmdline, size, char);
3885 my_strlcpy(cmdline, cmd, size);
3886 my_strlcat(cmdline, " ", size);
3887 for (s = cmdline + strlen(cmdline); *filename; ) {
3891 if (s - cmdline < size)
3892 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3893 myfp = PerlProc_popen(cmdline, "r");
3897 SV * const tmpsv = sv_newmortal();
3898 /* Need to save/restore 'PL_rs' ?? */
3899 s = sv_gets(tmpsv, myfp, 0);
3900 (void)PerlProc_pclose(myfp);
3904 #ifdef HAS_SYS_ERRLIST
3909 /* you don't see this */
3910 const char * const errmsg = Strerror(e) ;
3913 if (instr(s, errmsg)) {
3920 #define EACCES EPERM
3922 if (instr(s, "cannot make"))
3923 SETERRNO(EEXIST,RMS_FEX);
3924 else if (instr(s, "existing file"))
3925 SETERRNO(EEXIST,RMS_FEX);
3926 else if (instr(s, "ile exists"))
3927 SETERRNO(EEXIST,RMS_FEX);
3928 else if (instr(s, "non-exist"))
3929 SETERRNO(ENOENT,RMS_FNF);
3930 else if (instr(s, "does not exist"))
3931 SETERRNO(ENOENT,RMS_FNF);
3932 else if (instr(s, "not empty"))
3933 SETERRNO(EBUSY,SS_DEVOFFLINE);
3934 else if (instr(s, "cannot access"))
3935 SETERRNO(EACCES,RMS_PRV);
3937 SETERRNO(EPERM,RMS_PRV);
3940 else { /* some mkdirs return no failure indication */
3942 anum = (PerlLIO_stat(save_filename, &statbuf) >= 0);
3943 if (PL_op->op_type == OP_RMDIR)
3948 SETERRNO(EACCES,RMS_PRV); /* a guess */
3957 /* This macro removes trailing slashes from a directory name.
3958 * Different operating and file systems take differently to
3959 * trailing slashes. According to POSIX 1003.1 1996 Edition
3960 * any number of trailing slashes should be allowed.
3961 * Thusly we snip them away so that even non-conforming
3962 * systems are happy.
3963 * We should probably do this "filtering" for all
3964 * the functions that expect (potentially) directory names:
3965 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3966 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3968 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3969 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3972 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3973 (tmps) = savepvn((tmps), (len)); \
3983 const unsigned int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPu : 0777;
3985 TRIMSLASHES(tmps,len,copy);
3987 TAINT_PROPER("mkdir");
3989 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3993 SETi( dooneliner("mkdir", tmps) );
3994 oldumask = PerlLIO_umask(0);
3995 PerlLIO_umask(oldumask);
3996 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
4011 TRIMSLASHES(tmps,len,copy);
4012 TAINT_PROPER("rmdir");
4014 SETi( PerlDir_rmdir(tmps) >= 0 );
4016 SETi( dooneliner("rmdir", tmps) );
4023 /* Directory calls. */
4027 #if defined(Direntry_t) && defined(HAS_READDIR)
4029 const char * const dirname = POPpconstx;
4030 GV * const gv = MUTABLE_GV(POPs);
4031 IO * const io = GvIOn(gv);
4033 if ((IoIFP(io) || IoOFP(io)))
4034 Perl_croak(aTHX_ "Cannot open %" HEKf " as a dirhandle: it is already open as a filehandle",
4035 HEKfARG(GvENAME_HEK(gv)));
4037 PerlDir_close(IoDIRP(io));
4038 if (!(IoDIRP(io) = PerlDir_open(dirname)))
4044 SETERRNO(EBADF,RMS_DIR);
4047 DIE(aTHX_ PL_no_dir_func, "opendir");
4053 #if !defined(Direntry_t) || !defined(HAS_READDIR)
4054 DIE(aTHX_ PL_no_dir_func, "readdir");
4056 #if !defined(I_DIRENT) && !defined(VMS)
4057 Direntry_t *readdir (DIR *);
4062 const U8 gimme = GIMME_V;
4063 GV * const gv = MUTABLE_GV(POPs);
4064 const Direntry_t *dp;
4065 IO * const io = GvIOn(gv);
4068 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4069 "readdir() attempted on invalid dirhandle %" HEKf,
4070 HEKfARG(GvENAME_HEK(gv)));
4075 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
4079 sv = newSVpvn(dp->d_name, dp->d_namlen);
4081 sv = newSVpv(dp->d_name, 0);
4083 if (!(IoFLAGS(io) & IOf_UNTAINT))
4086 } while (gimme == G_ARRAY);
4088 if (!dp && gimme != G_ARRAY)
4095 SETERRNO(EBADF,RMS_ISI);
4096 if (gimme == G_ARRAY)
4105 #if defined(HAS_TELLDIR) || defined(telldir)
4107 /* XXX does _anyone_ need this? --AD 2/20/1998 */
4108 /* XXX netbsd still seemed to.
4109 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
4110 --JHI 1999-Feb-02 */
4111 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
4112 long telldir (DIR *);
4114 GV * const gv = MUTABLE_GV(POPs);
4115 IO * const io = GvIOn(gv);
4118 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4119 "telldir() attempted on invalid dirhandle %" HEKf,
4120 HEKfARG(GvENAME_HEK(gv)));
4124 PUSHi( PerlDir_tell(IoDIRP(io)) );
4128 SETERRNO(EBADF,RMS_ISI);
4131 DIE(aTHX_ PL_no_dir_func, "telldir");
4137 #if defined(HAS_SEEKDIR) || defined(seekdir)
4139 const long along = POPl;
4140 GV * const gv = MUTABLE_GV(POPs);
4141 IO * const io = GvIOn(gv);
4144 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4145 "seekdir() attempted on invalid dirhandle %" HEKf,
4146 HEKfARG(GvENAME_HEK(gv)));
4149 (void)PerlDir_seek(IoDIRP(io), along);
4154 SETERRNO(EBADF,RMS_ISI);
4157 DIE(aTHX_ PL_no_dir_func, "seekdir");
4163 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4165 GV * const gv = MUTABLE_GV(POPs);
4166 IO * const io = GvIOn(gv);
4169 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4170 "rewinddir() attempted on invalid dirhandle %" HEKf,
4171 HEKfARG(GvENAME_HEK(gv)));
4174 (void)PerlDir_rewind(IoDIRP(io));
4178 SETERRNO(EBADF,RMS_ISI);
4181 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4187 #if defined(Direntry_t) && defined(HAS_READDIR)
4189 GV * const gv = MUTABLE_GV(POPs);
4190 IO * const io = GvIOn(gv);
4193 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4194 "closedir() attempted on invalid dirhandle %" HEKf,
4195 HEKfARG(GvENAME_HEK(gv)));
4198 #ifdef VOID_CLOSEDIR
4199 PerlDir_close(IoDIRP(io));
4201 if (PerlDir_close(IoDIRP(io)) < 0) {
4202 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4211 SETERRNO(EBADF,RMS_IFI);
4214 DIE(aTHX_ PL_no_dir_func, "closedir");
4218 /* Process control. */
4225 #ifdef HAS_SIGPROCMASK
4226 sigset_t oldmask, newmask;
4230 PERL_FLUSHALL_FOR_CHILD;
4231 #ifdef HAS_SIGPROCMASK
4232 sigfillset(&newmask);
4233 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4235 childpid = PerlProc_fork();
4236 if (childpid == 0) {
4240 for (sig = 1; sig < SIG_SIZE; sig++)
4241 PL_psig_pend[sig] = 0;
4243 #ifdef HAS_SIGPROCMASK
4246 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4253 #ifdef PERL_USES_PL_PIDSTATUS
4254 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4260 # if (defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)) || defined(__amigaos4__)
4265 PERL_FLUSHALL_FOR_CHILD;
4266 childpid = PerlProc_fork();
4272 DIE(aTHX_ PL_no_func, "fork");
4279 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4284 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4285 childpid = wait4pid(-1, &argflags, 0);
4287 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4292 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4293 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4294 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4296 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4301 DIE(aTHX_ PL_no_func, "wait");
4307 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4309 const int optype = POPi;
4310 const Pid_t pid = TOPi;
4314 result = amigaos_waitpid(aTHX_ optype, pid, &argflags);
4315 STATUS_NATIVE_CHILD_SET((result >= 0) ? argflags : -1);
4316 result = result == 0 ? pid : -1;
4320 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4321 result = wait4pid(pid, &argflags, optype);
4323 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4328 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4329 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4330 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4332 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4334 # endif /* __amigaos4__ */
4338 DIE(aTHX_ PL_no_func, "waitpid");
4344 dSP; dMARK; dORIGMARK; dTARGET;
4345 #if defined(__LIBCATAMOUNT__)
4346 PL_statusvalue = -1;
4351 # ifdef __amigaos4__
4359 while (++MARK <= SP) {
4360 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4365 TAINT_PROPER("system");
4367 PERL_FLUSHALL_FOR_CHILD;
4368 #if (defined(HAS_FORK) || defined(__amigaos4__)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4371 struct UserData userdata;
4378 bool child_success = FALSE;
4379 #ifdef HAS_SIGPROCMASK
4380 sigset_t newset, oldset;
4383 if (PerlProc_pipe(pp) >= 0)
4386 amigaos_fork_set_userdata(aTHX_
4392 pthread_create(&proc,NULL,amigaos_system_child,(void *)&userdata);
4393 child_success = proc > 0;
4395 #ifdef HAS_SIGPROCMASK
4396 sigemptyset(&newset);
4397 sigaddset(&newset, SIGCHLD);
4398 sigprocmask(SIG_BLOCK, &newset, &oldset);
4400 while ((childpid = PerlProc_fork()) == -1) {
4401 if (errno != EAGAIN) {
4406 PerlLIO_close(pp[0]);
4407 PerlLIO_close(pp[1]);
4409 #ifdef HAS_SIGPROCMASK
4410 sigprocmask(SIG_SETMASK, &oldset, NULL);
4416 child_success = childpid > 0;
4418 if (child_success) {
4419 Sigsave_t ihand,qhand; /* place to save signals during system() */
4422 #ifndef __amigaos4__
4424 PerlLIO_close(pp[1]);
4427 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4428 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4431 result = pthread_join(proc, (void **)&status);
4434 result = wait4pid(childpid, &status, 0);
4435 } while (result == -1 && errno == EINTR);
4438 #ifdef HAS_SIGPROCMASK
4439 sigprocmask(SIG_SETMASK, &oldset, NULL);
4441 (void)rsignal_restore(SIGINT, &ihand);
4442 (void)rsignal_restore(SIGQUIT, &qhand);
4444 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4445 do_execfree(); /* free any memory child malloced on fork */
4451 while (n < sizeof(int)) {
4452 const SSize_t n1 = PerlLIO_read(pp[0],
4453 (void*)(((char*)&errkid)+n),
4459 PerlLIO_close(pp[0]);
4460 if (n) { /* Error */
4461 if (n != sizeof(int))
4462 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4463 errno = errkid; /* Propagate errno from kid */
4465 /* The pipe always has something in it
4466 * so n alone is not enough. */
4470 STATUS_NATIVE_CHILD_SET(-1);
4474 XPUSHi(STATUS_CURRENT);
4477 #ifndef __amigaos4__
4478 #ifdef HAS_SIGPROCMASK
4479 sigprocmask(SIG_SETMASK, &oldset, NULL);
4482 PerlLIO_close(pp[0]);
4483 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
4484 if (fcntl(pp[1], F_SETFD, FD_CLOEXEC) < 0)
4488 if (PL_op->op_flags & OPf_STACKED) {
4489 SV * const really = *++MARK;
4490 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4492 else if (SP - MARK != 1)
4493 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4495 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4497 #endif /* __amigaos4__ */
4500 #else /* ! FORK or VMS or OS/2 */
4503 if (PL_op->op_flags & OPf_STACKED) {
4504 SV * const really = *++MARK;
4505 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4506 value = (I32)do_aspawn(really, MARK, SP);
4508 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4511 else if (SP - MARK != 1) {
4512 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4513 value = (I32)do_aspawn(NULL, MARK, SP);
4515 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4519 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4521 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4523 STATUS_NATIVE_CHILD_SET(value);
4526 XPUSHi(result ? value : STATUS_CURRENT);
4527 #endif /* !FORK or VMS or OS/2 */
4534 dSP; dMARK; dORIGMARK; dTARGET;
4539 while (++MARK <= SP) {
4540 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4545 TAINT_PROPER("exec");
4548 PERL_FLUSHALL_FOR_CHILD;
4549 if (PL_op->op_flags & OPf_STACKED) {
4550 SV * const really = *++MARK;
4551 value = (I32)do_aexec(really, MARK, SP);
4553 else if (SP - MARK != 1)
4555 value = (I32)vms_do_aexec(NULL, MARK, SP);
4557 value = (I32)do_aexec(NULL, MARK, SP);
4561 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4563 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4575 XPUSHi( getppid() );
4578 DIE(aTHX_ PL_no_func, "getppid");
4588 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4591 pgrp = (I32)BSD_GETPGRP(pid);
4593 if (pid != 0 && pid != PerlProc_getpid())
4594 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4600 DIE(aTHX_ PL_no_func, "getpgrp");
4610 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4611 if (MAXARG > 0) pid = TOPs ? TOPi : 0;
4618 TAINT_PROPER("setpgrp");
4620 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4622 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4623 || (pid != 0 && pid != PerlProc_getpid()))
4625 DIE(aTHX_ "setpgrp can't take arguments");
4627 SETi( setpgrp() >= 0 );
4628 #endif /* USE_BSDPGRP */
4631 DIE(aTHX_ PL_no_func, "setpgrp");
4635 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4636 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4638 # define PRIORITY_WHICH_T(which) which
4643 #ifdef HAS_GETPRIORITY
4645 const int who = POPi;
4646 const int which = TOPi;
4647 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4650 DIE(aTHX_ PL_no_func, "getpriority");
4656 #ifdef HAS_SETPRIORITY
4658 const int niceval = POPi;
4659 const int who = POPi;
4660 const int which = TOPi;
4661 TAINT_PROPER("setpriority");
4662 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4665 DIE(aTHX_ PL_no_func, "setpriority");
4669 #undef PRIORITY_WHICH_T
4677 XPUSHn( time(NULL) );
4679 XPUSHi( time(NULL) );
4688 struct tms timesbuf;
4691 (void)PerlProc_times(×buf);
4693 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4694 if (GIMME_V == G_ARRAY) {
4695 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4696 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4697 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4705 if (GIMME_V == G_ARRAY) {
4712 DIE(aTHX_ "times not implemented");
4714 #endif /* HAS_TIMES */
4717 /* The 32 bit int year limits the times we can represent to these
4718 boundaries with a few days wiggle room to account for time zone
4721 /* Sat Jan 3 00:00:00 -2147481748 */
4722 #define TIME_LOWER_BOUND -67768100567755200.0
4723 /* Sun Dec 29 12:00:00 2147483647 */
4724 #define TIME_UPPER_BOUND 67767976233316800.0
4727 /* also used for: pp_localtime() */
4735 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4736 static const char * const dayname[] =
4737 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4738 static const char * const monname[] =
4739 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4740 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4742 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4745 when = (Time64_T)now;
4748 NV input = Perl_floor(POPn);
4749 const bool pl_isnan = Perl_isnan(input);
4750 when = (Time64_T)input;
4751 if (UNLIKELY(pl_isnan || when != input)) {
4752 /* diag_listed_as: gmtime(%f) too large */
4753 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4754 "%s(%.0" NVff ") too large", opname, input);
4762 if ( TIME_LOWER_BOUND > when ) {
4763 /* diag_listed_as: gmtime(%f) too small */
4764 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4765 "%s(%.0" NVff ") too small", opname, when);
4768 else if( when > TIME_UPPER_BOUND ) {
4769 /* diag_listed_as: gmtime(%f) too small */
4770 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4771 "%s(%.0" NVff ") too large", opname, when);
4775 if (PL_op->op_type == OP_LOCALTIME)
4776 err = Perl_localtime64_r(&when, &tmbuf);
4778 err = Perl_gmtime64_r(&when, &tmbuf);
4782 /* diag_listed_as: gmtime(%f) failed */
4783 /* XXX %lld broken for quads */
4785 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4786 "%s(%.0" NVff ") failed", opname, when);
4789 if (GIMME_V != G_ARRAY) { /* scalar context */
4796 Perl_sv_setpvf_mg(aTHX_ TARG, "%s %s %2d %02d:%02d:%02d %" IVdf,
4797 dayname[tmbuf.tm_wday],
4798 monname[tmbuf.tm_mon],
4803 (IV)tmbuf.tm_year + 1900);
4806 else { /* list context */
4812 mPUSHi(tmbuf.tm_sec);
4813 mPUSHi(tmbuf.tm_min);
4814 mPUSHi(tmbuf.tm_hour);
4815 mPUSHi(tmbuf.tm_mday);
4816 mPUSHi(tmbuf.tm_mon);
4817 mPUSHn(tmbuf.tm_year);
4818 mPUSHi(tmbuf.tm_wday);
4819 mPUSHi(tmbuf.tm_yday);
4820 mPUSHi(tmbuf.tm_isdst);
4829 /* alarm() takes an unsigned int number of seconds, and return the
4830 * unsigned int number of seconds remaining in the previous alarm
4831 * (alarms don't stack). Therefore negative return values are not
4835 /* Note that while the C library function alarm() as such has
4836 * no errors defined (or in other words, properly behaving client
4837 * code shouldn't expect any), alarm() being obsoleted by
4838 * setitimer() and often being implemented in terms of
4839 * setitimer(), can fail. */
4840 /* diag_listed_as: %s() with negative argument */
4841 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4842 "alarm() with negative argument");
4843 SETERRNO(EINVAL, LIB_INVARG);
4847 unsigned int retval = alarm(anum);
4848 if ((int)retval < 0) /* Strictly speaking "cannot happen". */
4854 DIE(aTHX_ PL_no_func, "alarm");
4864 (void)time(&lasttime);
4865 if (MAXARG < 1 || (!TOPs && !POPs))
4868 const I32 duration = POPi;
4870 /* diag_listed_as: %s() with negative argument */
4871 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4872 "sleep() with negative argument");
4873 SETERRNO(EINVAL, LIB_INVARG);
4877 PerlProc_sleep((unsigned int)duration);
4881 XPUSHi(when - lasttime);
4885 /* Shared memory. */
4886 /* Merged with some message passing. */
4888 /* also used for: pp_msgrcv() pp_msgsnd() pp_semop() pp_shmread() */
4892 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4893 dSP; dMARK; dTARGET;
4894 const int op_type = PL_op->op_type;
4899 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4902 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4905 value = (I32)(do_semop(MARK, SP) >= 0);
4908 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4916 return Perl_pp_semget(aTHX);
4922 /* also used for: pp_msgget() pp_shmget() */
4926 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4927 dSP; dMARK; dTARGET;
4928 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4935 DIE(aTHX_ "System V IPC is not implemented on this machine");
4939 /* also used for: pp_msgctl() pp_shmctl() */
4943 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4944 dSP; dMARK; dTARGET;
4945 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4953 PUSHp(zero_but_true, ZBTLEN);
4957 return Perl_pp_semget(aTHX);
4961 /* I can't const this further without getting warnings about the types of
4962 various arrays passed in from structures. */
4964 S_space_join_names_mortal(pTHX_ char *const *array)
4968 if (array && *array) {
4969 target = newSVpvs_flags("", SVs_TEMP);
4971 sv_catpv(target, *array);
4974 sv_catpvs(target, " ");
4977 target = sv_mortalcopy(&PL_sv_no);
4982 /* Get system info. */
4984 /* also used for: pp_ghbyaddr() pp_ghbyname() */
4988 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4990 I32 which = PL_op->op_type;
4993 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4994 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4995 struct hostent *gethostbyname(Netdb_name_t);
4996 struct hostent *gethostent(void);
4998 struct hostent *hent = NULL;
5002 if (which == OP_GHBYNAME) {
5003 #ifdef HAS_GETHOSTBYNAME
5004 const char* const name = POPpbytex;
5005 hent = PerlSock_gethostbyname(name);
5007 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
5010 else if (which == OP_GHBYADDR) {
5011 #ifdef HAS_GETHOSTBYADDR
5012 const int addrtype = POPi;
5013 SV * const addrsv = POPs;
5015 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
5017 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
5019 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
5023 #ifdef HAS_GETHOSTENT
5024 hent = PerlSock_gethostent();
5026 DIE(aTHX_ PL_no_sock_func, "gethostent");
5029 #ifdef HOST_NOT_FOUND
5031 #ifdef USE_REENTRANT_API
5032 # ifdef USE_GETHOSTENT_ERRNO
5033 h_errno = PL_reentrant_buffer->_gethostent_errno;
5036 STATUS_UNIX_SET(h_errno);
5040 if (GIMME_V != G_ARRAY) {
5041 PUSHs(sv = sv_newmortal());
5043 if (which == OP_GHBYNAME) {
5045 sv_setpvn(sv, hent->h_addr, hent->h_length);
5048 sv_setpv(sv, (char*)hent->h_name);
5054 mPUSHs(newSVpv((char*)hent->h_name, 0));
5055 PUSHs(space_join_names_mortal(hent->h_aliases));
5056 mPUSHi(hent->h_addrtype);
5057 len = hent->h_length;
5060 for (elem = hent->h_addr_list; elem && *elem; elem++) {
5061 mXPUSHp(*elem, len);
5065 mPUSHp(hent->h_addr, len);
5067 PUSHs(sv_mortalcopy(&PL_sv_no));
5072 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5076 /* also used for: pp_gnbyaddr() pp_gnbyname() */
5080 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
5082 I32 which = PL_op->op_type;
5084 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
5085 struct netent *getnetbyaddr(Netdb_net_t, int);
5086 struct netent *getnetbyname(Netdb_name_t);
5087 struct netent *getnetent(void);
5089 struct netent *nent;
5091 if (which == OP_GNBYNAME){
5092 #ifdef HAS_GETNETBYNAME
5093 const char * const name = POPpbytex;
5094 nent = PerlSock_getnetbyname(name);
5096 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
5099 else if (which == OP_GNBYADDR) {
5100 #ifdef HAS_GETNETBYADDR
5101 const int addrtype = POPi;
5102 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
5103 nent = PerlSock_getnetbyaddr(addr, addrtype);
5105 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
5109 #ifdef HAS_GETNETENT
5110 nent = PerlSock_getnetent();
5112 DIE(aTHX_ PL_no_sock_func, "getnetent");
5115 #ifdef HOST_NOT_FOUND
5117 #ifdef USE_REENTRANT_API
5118 # ifdef USE_GETNETENT_ERRNO
5119 h_errno = PL_reentrant_buffer->_getnetent_errno;
5122 STATUS_UNIX_SET(h_errno);
5127 if (GIMME_V != G_ARRAY) {
5128 PUSHs(sv = sv_newmortal());
5130 if (which == OP_GNBYNAME)
5131 sv_setiv(sv, (IV)nent->n_net);
5133 sv_setpv(sv, nent->n_name);
5139 mPUSHs(newSVpv(nent->n_name, 0));
5140 PUSHs(space_join_names_mortal(nent->n_aliases));
5141 mPUSHi(nent->n_addrtype);
5142 mPUSHi(nent->n_net);
5147 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5152 /* also used for: pp_gpbyname() pp_gpbynumber() */
5156 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
5158 I32 which = PL_op->op_type;
5160 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
5161 struct protoent *getprotobyname(Netdb_name_t);
5162 struct protoent *getprotobynumber(int);
5163 struct protoent *getprotoent(void);
5165 struct protoent *pent;
5167 if (which == OP_GPBYNAME) {
5168 #ifdef HAS_GETPROTOBYNAME
5169 const char* const name = POPpbytex;
5170 pent = PerlSock_getprotobyname(name);
5172 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
5175 else if (which == OP_GPBYNUMBER) {
5176 #ifdef HAS_GETPROTOBYNUMBER
5177 const int number = POPi;
5178 pent = PerlSock_getprotobynumber(number);
5180 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
5184 #ifdef HAS_GETPROTOENT
5185 pent = PerlSock_getprotoent();
5187 DIE(aTHX_ PL_no_sock_func, "getprotoent");
5191 if (GIMME_V != G_ARRAY) {
5192 PUSHs(sv = sv_newmortal());
5194 if (which == OP_GPBYNAME)
5195 sv_setiv(sv, (IV)pent->p_proto);
5197 sv_setpv(sv, pent->p_name);
5203 mPUSHs(newSVpv(pent->p_name, 0));
5204 PUSHs(space_join_names_mortal(pent->p_aliases));
5205 mPUSHi(pent->p_proto);
5210 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5215 /* also used for: pp_gsbyname() pp_gsbyport() */
5219 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
5221 I32 which = PL_op->op_type;
5223 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
5224 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
5225 struct servent *getservbyport(int, Netdb_name_t);
5226 struct servent *getservent(void);
5228 struct servent *sent;
5230 if (which == OP_GSBYNAME) {
5231 #ifdef HAS_GETSERVBYNAME
5232 const char * const proto = POPpbytex;
5233 const char * const name = POPpbytex;
5234 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
5236 DIE(aTHX_ PL_no_sock_func, "getservbyname");
5239 else if (which == OP_GSBYPORT) {
5240 #ifdef HAS_GETSERVBYPORT
5241 const char * const proto = POPpbytex;
5242 unsigned short port = (unsigned short)POPu;
5243 port = PerlSock_htons(port);
5244 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
5246 DIE(aTHX_ PL_no_sock_func, "getservbyport");
5250 #ifdef HAS_GETSERVENT
5251 sent = PerlSock_getservent();
5253 DIE(aTHX_ PL_no_sock_func, "getservent");
5257 if (GIMME_V != G_ARRAY) {
5258 PUSHs(sv = sv_newmortal());
5260 if (which == OP_GSBYNAME) {
5261 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5264 sv_setpv(sv, sent->s_name);
5270 mPUSHs(newSVpv(sent->s_name, 0));
5271 PUSHs(space_join_names_mortal(sent->s_aliases));
5272 mPUSHi(PerlSock_ntohs(sent->s_port));
5273 mPUSHs(newSVpv(sent->s_proto, 0));
5278 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5283 /* also used for: pp_snetent() pp_sprotoent() pp_sservent() */
5288 const int stayopen = TOPi;
5289 switch(PL_op->op_type) {
5291 #ifdef HAS_SETHOSTENT
5292 PerlSock_sethostent(stayopen);
5294 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5297 #ifdef HAS_SETNETENT
5299 PerlSock_setnetent(stayopen);
5301 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5305 #ifdef HAS_SETPROTOENT
5306 PerlSock_setprotoent(stayopen);
5308 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5312 #ifdef HAS_SETSERVENT
5313 PerlSock_setservent(stayopen);
5315 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5323 /* also used for: pp_egrent() pp_enetent() pp_eprotoent() pp_epwent()
5324 * pp_eservent() pp_sgrent() pp_spwent() */
5329 switch(PL_op->op_type) {
5331 #ifdef HAS_ENDHOSTENT
5332 PerlSock_endhostent();
5334 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5338 #ifdef HAS_ENDNETENT
5339 PerlSock_endnetent();
5341 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5345 #ifdef HAS_ENDPROTOENT
5346 PerlSock_endprotoent();
5348 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5352 #ifdef HAS_ENDSERVENT
5353 PerlSock_endservent();
5355 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5359 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5362 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5366 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5369 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5373 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5376 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5380 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5383 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5392 /* also used for: pp_gpwnam() pp_gpwuid() */
5398 I32 which = PL_op->op_type;
5400 struct passwd *pwent = NULL;
5402 * We currently support only the SysV getsp* shadow password interface.
5403 * The interface is declared in <shadow.h> and often one needs to link
5404 * with -lsecurity or some such.
5405 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5408 * AIX getpwnam() is clever enough to return the encrypted password
5409 * only if the caller (euid?) is root.
5411 * There are at least three other shadow password APIs. Many platforms
5412 * seem to contain more than one interface for accessing the shadow
5413 * password databases, possibly for compatibility reasons.
5414 * The getsp*() is by far he simplest one, the other two interfaces
5415 * are much more complicated, but also very similar to each other.
5420 * struct pr_passwd *getprpw*();
5421 * The password is in
5422 * char getprpw*(...).ufld.fd_encrypt[]
5423 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5428 * struct es_passwd *getespw*();
5429 * The password is in
5430 * char *(getespw*(...).ufld.fd_encrypt)
5431 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5434 * struct userpw *getuserpw();
5435 * The password is in
5436 * char *(getuserpw(...)).spw_upw_passwd
5437 * (but the de facto standard getpwnam() should work okay)
5439 * Mention I_PROT here so that Configure probes for it.
5441 * In HP-UX for getprpw*() the manual page claims that one should include
5442 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5443 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5444 * and pp_sys.c already includes <shadow.h> if there is such.
5446 * Note that <sys/security.h> is already probed for, but currently
5447 * it is only included in special cases.
5449 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5450 * be preferred interface, even though also the getprpw*() interface
5451 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5452 * One also needs to call set_auth_parameters() in main() before
5453 * doing anything else, whether one is using getespw*() or getprpw*().
5455 * Note that accessing the shadow databases can be magnitudes
5456 * slower than accessing the standard databases.
5461 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5462 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5463 * the pw_comment is left uninitialized. */
5464 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5470 const char* const name = POPpbytex;
5471 pwent = getpwnam(name);
5477 pwent = getpwuid(uid);
5481 # ifdef HAS_GETPWENT
5483 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5484 if (pwent) pwent = getpwnam(pwent->pw_name);
5487 DIE(aTHX_ PL_no_func, "getpwent");
5493 if (GIMME_V != G_ARRAY) {
5494 PUSHs(sv = sv_newmortal());
5496 if (which == OP_GPWNAM)
5497 sv_setuid(sv, pwent->pw_uid);
5499 sv_setpv(sv, pwent->pw_name);
5505 mPUSHs(newSVpv(pwent->pw_name, 0));
5509 /* If we have getspnam(), we try to dig up the shadow
5510 * password. If we are underprivileged, the shadow
5511 * interface will set the errno to EACCES or similar,
5512 * and return a null pointer. If this happens, we will
5513 * use the dummy password (usually "*" or "x") from the
5514 * standard password database.
5516 * In theory we could skip the shadow call completely
5517 * if euid != 0 but in practice we cannot know which
5518 * security measures are guarding the shadow databases
5519 * on a random platform.
5521 * Resist the urge to use additional shadow interfaces.
5522 * Divert the urge to writing an extension instead.
5525 /* Some AIX setups falsely(?) detect some getspnam(), which
5526 * has a different API than the Solaris/IRIX one. */
5527 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5530 const struct spwd * const spwent = getspnam(pwent->pw_name);
5531 /* Save and restore errno so that
5532 * underprivileged attempts seem
5533 * to have never made the unsuccessful
5534 * attempt to retrieve the shadow password. */
5536 if (spwent && spwent->sp_pwdp)
5537 sv_setpv(sv, spwent->sp_pwdp);
5541 if (!SvPOK(sv)) /* Use the standard password, then. */
5542 sv_setpv(sv, pwent->pw_passwd);
5545 /* passwd is tainted because user himself can diddle with it.
5546 * admittedly not much and in a very limited way, but nevertheless. */
5549 sv_setuid(PUSHmortal, pwent->pw_uid);
5550 sv_setgid(PUSHmortal, pwent->pw_gid);
5552 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5553 * because of the poor interface of the Perl getpw*(),
5554 * not because there's some standard/convention saying so.
5555 * A better interface would have been to return a hash,
5556 * but we are accursed by our history, alas. --jhi. */
5558 mPUSHi(pwent->pw_change);
5561 mPUSHi(pwent->pw_quota);
5564 mPUSHs(newSVpv(pwent->pw_age, 0));
5566 /* I think that you can never get this compiled, but just in case. */
5567 PUSHs(sv_mortalcopy(&PL_sv_no));
5572 /* pw_class and pw_comment are mutually exclusive--.
5573 * see the above note for pw_change, pw_quota, and pw_age. */
5575 mPUSHs(newSVpv(pwent->pw_class, 0));
5578 mPUSHs(newSVpv(pwent->pw_comment, 0));
5580 /* I think that you can never get this compiled, but just in case. */
5581 PUSHs(sv_mortalcopy(&PL_sv_no));
5586 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5588 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5590 /* pw_gecos is tainted because user himself can diddle with it. */
5593 mPUSHs(newSVpv(pwent->pw_dir, 0));
5595 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5596 /* pw_shell is tainted because user himself can diddle with it. */
5600 mPUSHi(pwent->pw_expire);
5605 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5610 /* also used for: pp_ggrgid() pp_ggrnam() */
5616 const I32 which = PL_op->op_type;
5617 const struct group *grent;
5619 if (which == OP_GGRNAM) {
5620 const char* const name = POPpbytex;
5621 grent = (const struct group *)getgrnam(name);
5623 else if (which == OP_GGRGID) {
5625 const Gid_t gid = POPu;
5626 #elif Gid_t_sign == -1
5627 const Gid_t gid = POPi;
5629 # error "Unexpected Gid_t_sign"
5631 grent = (const struct group *)getgrgid(gid);
5635 grent = (struct group *)getgrent();
5637 DIE(aTHX_ PL_no_func, "getgrent");
5641 if (GIMME_V != G_ARRAY) {
5642 SV * const sv = sv_newmortal();
5646 if (which == OP_GGRNAM)
5647 sv_setgid(sv, grent->gr_gid);
5649 sv_setpv(sv, grent->gr_name);
5655 mPUSHs(newSVpv(grent->gr_name, 0));
5658 mPUSHs(newSVpv(grent->gr_passwd, 0));
5660 PUSHs(sv_mortalcopy(&PL_sv_no));
5663 sv_setgid(PUSHmortal, grent->gr_gid);
5665 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5666 /* In UNICOS/mk (_CRAYMPP) the multithreading
5667 * versions (getgrnam_r, getgrgid_r)
5668 * seem to return an illegal pointer
5669 * as the group members list, gr_mem.
5670 * getgrent() doesn't even have a _r version
5671 * but the gr_mem is poisonous anyway.
5672 * So yes, you cannot get the list of group
5673 * members if building multithreaded in UNICOS/mk. */
5674 PUSHs(space_join_names_mortal(grent->gr_mem));
5680 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5690 if (!(tmps = PerlProc_getlogin()))
5692 sv_setpv_mg(TARG, tmps);
5696 DIE(aTHX_ PL_no_func, "getlogin");
5700 /* Miscellaneous. */
5705 dSP; dMARK; dORIGMARK; dTARGET;
5706 I32 items = SP - MARK;
5707 unsigned long a[20];
5712 while (++MARK <= SP) {
5713 if (SvTAINTED(*MARK)) {
5719 TAINT_PROPER("syscall");
5722 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5723 * or where sizeof(long) != sizeof(char*). But such machines will
5724 * not likely have syscall implemented either, so who cares?
5726 while (++MARK <= SP) {
5727 if (SvNIOK(*MARK) || !i)
5728 a[i++] = SvIV(*MARK);
5729 else if (*MARK == &PL_sv_undef)
5732 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5738 DIE(aTHX_ "Too many args to syscall");
5740 DIE(aTHX_ "Too few args to syscall");
5742 retval = syscall(a[0]);
5745 retval = syscall(a[0],a[1]);
5748 retval = syscall(a[0],a[1],a[2]);
5751 retval = syscall(a[0],a[1],a[2],a[3]);
5754 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5757 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5760 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5763 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5770 DIE(aTHX_ PL_no_func, "syscall");
5774 #ifdef FCNTL_EMULATE_FLOCK
5776 /* XXX Emulate flock() with fcntl().
5777 What's really needed is a good file locking module.
5781 fcntl_emulate_flock(int fd, int operation)
5786 switch (operation & ~LOCK_NB) {
5788 flock.l_type = F_RDLCK;
5791 flock.l_type = F_WRLCK;
5794 flock.l_type = F_UNLCK;
5800 flock.l_whence = SEEK_SET;
5801 flock.l_start = flock.l_len = (Off_t)0;
5803 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5804 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5805 errno = EWOULDBLOCK;
5809 #endif /* FCNTL_EMULATE_FLOCK */
5811 #ifdef LOCKF_EMULATE_FLOCK
5813 /* XXX Emulate flock() with lockf(). This is just to increase
5814 portability of scripts. The calls are not completely
5815 interchangeable. What's really needed is a good file
5819 /* The lockf() constants might have been defined in <unistd.h>.
5820 Unfortunately, <unistd.h> causes troubles on some mixed
5821 (BSD/POSIX) systems, such as SunOS 4.1.3.
5823 Further, the lockf() constants aren't POSIX, so they might not be
5824 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5825 just stick in the SVID values and be done with it. Sigh.
5829 # define F_ULOCK 0 /* Unlock a previously locked region */
5832 # define F_LOCK 1 /* Lock a region for exclusive use */
5835 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5838 # define F_TEST 3 /* Test a region for other processes locks */
5842 lockf_emulate_flock(int fd, int operation)
5848 /* flock locks entire file so for lockf we need to do the same */
5849 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5850 if (pos > 0) /* is seekable and needs to be repositioned */
5851 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5852 pos = -1; /* seek failed, so don't seek back afterwards */
5855 switch (operation) {
5857 /* LOCK_SH - get a shared lock */
5859 /* LOCK_EX - get an exclusive lock */
5861 i = lockf (fd, F_LOCK, 0);
5864 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5865 case LOCK_SH|LOCK_NB:
5866 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5867 case LOCK_EX|LOCK_NB:
5868 i = lockf (fd, F_TLOCK, 0);
5870 if ((errno == EAGAIN) || (errno == EACCES))
5871 errno = EWOULDBLOCK;
5874 /* LOCK_UN - unlock (non-blocking is a no-op) */
5876 case LOCK_UN|LOCK_NB:
5877 i = lockf (fd, F_ULOCK, 0);
5880 /* Default - can't decipher operation */
5887 if (pos > 0) /* need to restore position of the handle */
5888 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5893 #endif /* LOCKF_EMULATE_FLOCK */
5896 * ex: set ts=8 sts=4 sw=4 et: