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);
195 #undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
197 /* F_OK unused: if stat() cannot find it... */
199 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
200 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
201 # define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
204 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
205 # ifdef I_SYS_SECURITY
206 # include <sys/security.h>
210 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
213 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
217 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
219 # define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
223 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
224 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
225 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
228 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
230 const Uid_t ruid = getuid();
231 const Uid_t euid = geteuid();
232 const Gid_t rgid = getgid();
233 const Gid_t egid = getegid();
236 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
237 Perl_croak(aTHX_ "switching effective uid is not implemented");
240 if (setreuid(euid, ruid))
243 if (setresuid(euid, ruid, (Uid_t)-1))
246 /* diag_listed_as: entering effective %s failed */
247 Perl_croak(aTHX_ "entering effective uid failed");
250 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
251 Perl_croak(aTHX_ "switching effective gid is not implemented");
254 if (setregid(egid, rgid))
257 if (setresgid(egid, rgid, (Gid_t)-1))
260 /* diag_listed_as: entering effective %s failed */
261 Perl_croak(aTHX_ "entering effective gid failed");
264 res = access(path, mode);
267 if (setreuid(ruid, euid))
270 if (setresuid(ruid, euid, (Uid_t)-1))
273 /* diag_listed_as: leaving effective %s failed */
274 Perl_croak(aTHX_ "leaving effective uid failed");
277 if (setregid(rgid, egid))
280 if (setresgid(rgid, egid, (Gid_t)-1))
283 /* diag_listed_as: leaving effective %s failed */
284 Perl_croak(aTHX_ "leaving effective gid failed");
288 # define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
295 const char * const tmps = POPpconstx;
296 const I32 gimme = GIMME_V;
297 const char *mode = "r";
300 if (PL_op->op_private & OPpOPEN_IN_RAW)
302 else if (PL_op->op_private & OPpOPEN_IN_CRLF)
304 fp = PerlProc_popen(tmps, mode);
306 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
308 PerlIO_apply_layers(aTHX_ fp,mode,type);
310 if (gimme == G_VOID) {
312 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
315 else if (gimme == G_SCALAR) {
316 ENTER_with_name("backtick");
318 PL_rs = &PL_sv_undef;
319 sv_setpvs(TARG, ""); /* note that this preserves previous buffer */
320 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
322 LEAVE_with_name("backtick");
328 SV * const sv = newSV(79);
329 if (sv_gets(sv, fp, 0) == NULL) {
334 if (SvLEN(sv) - SvCUR(sv) > 20) {
335 SvPV_shrink_to_cur(sv);
340 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
341 TAINT; /* "I believe that this is not gratuitous!" */
344 STATUS_NATIVE_CHILD_SET(-1);
345 if (gimme == G_SCALAR)
356 GV * const gv = (PL_op->op_flags & OPf_SPECIAL) ? NULL : (GV *)POPs;
360 /* make a copy of the pattern if it is gmagical, to ensure that magic
361 * is called once and only once */
362 if (SvGMAGICAL(TOPs)) TOPs = sv_2mortal(newSVsv(TOPs));
364 tryAMAGICunTARGETlist(iter_amg, (PL_op->op_flags & OPf_SPECIAL));
366 if (PL_op->op_flags & OPf_SPECIAL) {
367 /* call Perl-level glob function instead. Stack args are:
369 * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
378 /* Note that we only ever get here if File::Glob fails to load
379 * without at the same time croaking, for some reason, or if
380 * perl was built with PERL_EXTERNAL_GLOB */
382 ENTER_with_name("glob");
387 * The external globbing program may use things we can't control,
388 * so for security reasons we must assume the worst.
391 taint_proper(PL_no_security, "glob");
395 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
398 SAVESPTR(PL_rs); /* This is not permanent, either. */
399 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
402 *SvPVX(PL_rs) = '\n';
406 result = do_readline();
407 LEAVE_with_name("glob");
413 PL_last_in_gv = cGVOP_gv;
414 return do_readline();
424 do_join(TARG, &PL_sv_no, MARK, SP);
428 else if (SP == MARK) {
435 if (SvGMAGICAL(exsv)) exsv = sv_mortalcopy(exsv);
438 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
439 /* well-formed exception supplied */
442 SV * const errsv = ERRSV;
445 if (SvGMAGICAL(errsv)) {
446 exsv = sv_newmortal();
447 sv_setsv_nomg(exsv, errsv);
451 else if (SvPOKp(errsv) ? SvCUR(errsv) : SvNIOKp(errsv)) {
452 exsv = sv_newmortal();
453 sv_setsv_nomg(exsv, errsv);
454 sv_catpvs(exsv, "\t...caught");
457 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
460 if (SvROK(exsv) && !PL_warnhook)
461 Perl_warn(aTHX_ "%"SVf, SVfARG(exsv));
473 VMSISH_HUSHED || (PL_curcop->op_private & OPpHUSH_VMSISH);
475 if (SP - MARK != 1) {
477 do_join(TARG, &PL_sv_no, MARK, SP);
485 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
486 /* well-formed exception supplied */
489 SV * const errsv = ERRSV;
493 if (sv_isobject(exsv)) {
494 HV * const stash = SvSTASH(SvRV(exsv));
495 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
497 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
498 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
505 call_sv(MUTABLE_SV(GvCV(gv)),
506 G_SCALAR|G_EVAL|G_KEEPERR);
507 exsv = sv_mortalcopy(*PL_stack_sp--);
511 else if (SvPOK(errsv) && SvCUR(errsv)) {
512 exsv = sv_mortalcopy(errsv);
513 sv_catpvs(exsv, "\t...propagated");
516 exsv = newSVpvs_flags("Died", SVs_TEMP);
520 NOT_REACHED; /* NOTREACHED */
521 return NULL; /* avoid missing return from non-void function warning */
527 Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv,
528 const MAGIC *const mg, const U32 flags, U32 argc, ...)
533 PERL_ARGS_ASSERT_TIED_METHOD;
535 /* Ensure that our flag bits do not overlap. */
536 STATIC_ASSERT_STMT((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
537 STATIC_ASSERT_STMT((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
538 STATIC_ASSERT_STMT((TIED_METHOD_SAY & G_WANT) == 0);
540 PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
541 PUSHSTACKi(PERLSI_MAGIC);
542 EXTEND(SP, argc+1); /* object + args */
544 PUSHs(SvTIED_obj(sv, mg));
545 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
546 Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
550 const U32 mortalize_not_needed
551 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
553 va_start(args, argc);
555 SV *const arg = va_arg(args, SV *);
556 if(mortalize_not_needed)
565 ENTER_with_name("call_tied_method");
566 if (flags & TIED_METHOD_SAY) {
567 /* local $\ = "\n" */
568 SAVEGENERICSV(PL_ors_sv);
569 PL_ors_sv = newSVpvs("\n");
571 ret_args = call_sv(methname, (flags & G_WANT)|G_METHOD_NAMED);
576 if (ret_args) { /* copy results back to original stack */
577 EXTEND(sp, ret_args);
578 Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
582 LEAVE_with_name("call_tied_method");
586 #define tied_method0(a,b,c,d) \
587 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
588 #define tied_method1(a,b,c,d,e) \
589 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
590 #define tied_method2(a,b,c,d,e,f) \
591 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
604 GV * const gv = MUTABLE_GV(*++MARK);
606 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
607 DIE(aTHX_ PL_no_usym, "filehandle");
609 if ((io = GvIOp(gv))) {
611 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
614 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
615 "Opening dirhandle %"HEKf" also as a file",
616 HEKfARG(GvENAME_HEK(gv)));
618 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
620 /* Method's args are same as ours ... */
621 /* ... except handle is replaced by the object */
622 return Perl_tied_method(aTHX_ SV_CONST(OPEN), mark - 1, MUTABLE_SV(io), mg,
623 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
635 tmps = SvPV_const(sv, len);
636 ok = do_open6(gv, tmps, len, NULL, MARK+1, (SP-MARK));
639 PUSHi( (I32)PL_forkprocess );
640 else if (PL_forkprocess == 0) /* we are a new child */
651 MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
657 IO * const io = GvIO(gv);
659 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
661 return tied_method0(SV_CONST(CLOSE), SP, MUTABLE_SV(io), mg);
665 PUSHs(boolSV(do_close(gv, TRUE)));
677 GV * const wgv = MUTABLE_GV(POPs);
678 GV * const rgv = MUTABLE_GV(POPs);
680 assert (isGV_with_GP(rgv));
681 assert (isGV_with_GP(wgv));
684 do_close(rgv, FALSE);
688 do_close(wgv, FALSE);
690 if (PerlProc_pipe(fd) < 0)
693 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
694 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
695 IoOFP(rstio) = IoIFP(rstio);
696 IoIFP(wstio) = IoOFP(wstio);
697 IoTYPE(rstio) = IoTYPE_RDONLY;
698 IoTYPE(wstio) = IoTYPE_WRONLY;
700 if (!IoIFP(rstio) || !IoOFP(wstio)) {
702 PerlIO_close(IoIFP(rstio));
704 PerlLIO_close(fd[0]);
706 PerlIO_close(IoOFP(wstio));
708 PerlLIO_close(fd[1]);
711 #if defined(HAS_FCNTL) && defined(F_SETFD)
712 /* ensure close-on-exec */
713 if ((fcntl(fd[0], F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
714 (fcntl(fd[1], F_SETFD,fd[1] > PL_maxsysfd) < 0))
722 DIE(aTHX_ PL_no_func, "pipe");
736 gv = MUTABLE_GV(POPs);
740 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
742 return tied_method0(SV_CONST(FILENO), SP, MUTABLE_SV(io), mg);
745 if (io && IoDIRP(io)) {
746 #if defined(HAS_DIRFD) || defined(HAS_DIR_DD_FD)
747 PUSHi(my_dirfd(IoDIRP(io)));
749 #elif defined(ENOTSUP)
750 errno = ENOTSUP; /* Operation not supported */
752 #elif defined(EOPNOTSUPP)
753 errno = EOPNOTSUPP; /* Operation not supported on socket */
756 errno = EINVAL; /* Invalid argument */
761 if (!io || !(fp = IoIFP(io))) {
762 /* Can't do this because people seem to do things like
763 defined(fileno($foo)) to check whether $foo is a valid fh.
770 PUSHi(PerlIO_fileno(fp));
781 if (MAXARG < 1 || (!TOPs && !POPs)) {
782 anum = PerlLIO_umask(022);
783 /* setting it to 022 between the two calls to umask avoids
784 * to have a window where the umask is set to 0 -- meaning
785 * that another thread could create world-writeable files. */
787 (void)PerlLIO_umask(anum);
790 anum = PerlLIO_umask(POPi);
791 TAINT_PROPER("umask");
794 /* Only DIE if trying to restrict permissions on "user" (self).
795 * Otherwise it's harmless and more useful to just return undef
796 * since 'group' and 'other' concepts probably don't exist here. */
797 if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
798 DIE(aTHX_ "umask not implemented");
799 XPUSHs(&PL_sv_undef);
818 gv = MUTABLE_GV(POPs);
822 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
824 /* This takes advantage of the implementation of the varargs
825 function, which I don't think that the optimiser will be able to
826 figure out. Although, as it's a static function, in theory it
828 return Perl_tied_method(aTHX_ SV_CONST(BINMODE), SP, MUTABLE_SV(io), mg,
829 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
830 discp ? 1 : 0, discp);
834 if (!io || !(fp = IoIFP(io))) {
836 SETERRNO(EBADF,RMS_IFI);
843 const char *d = NULL;
846 d = SvPV_const(discp, len);
847 mode = mode_from_discipline(d, len);
848 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
849 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
850 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
871 const I32 markoff = MARK - PL_stack_base;
872 const char *methname;
873 int how = PERL_MAGIC_tied;
877 switch(SvTYPE(varsv)) {
881 methname = "TIEHASH";
882 if (HvLAZYDEL(varsv) && (entry = HvEITER((HV *)varsv))) {
883 HvLAZYDEL_off(varsv);
884 hv_free_ent((HV *)varsv, entry);
886 HvEITER_set(MUTABLE_HV(varsv), 0);
890 methname = "TIEARRAY";
891 if (!AvREAL(varsv)) {
893 Perl_croak(aTHX_ "Cannot tie unreifiable array");
894 av_clear((AV *)varsv);
901 if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
902 methname = "TIEHANDLE";
903 how = PERL_MAGIC_tiedscalar;
904 /* For tied filehandles, we apply tiedscalar magic to the IO
905 slot of the GP rather than the GV itself. AMS 20010812 */
907 GvIOp(varsv) = newIO();
908 varsv = MUTABLE_SV(GvIOp(varsv));
911 if (SvTYPE(varsv) == SVt_PVLV && LvTYPE(varsv) == 'y') {
912 vivify_defelem(varsv);
913 varsv = LvTARG(varsv);
917 methname = "TIESCALAR";
918 how = PERL_MAGIC_tiedscalar;
922 if (sv_isobject(*MARK)) { /* Calls GET magic. */
923 ENTER_with_name("call_TIE");
924 PUSHSTACKi(PERLSI_MAGIC);
926 EXTEND(SP,(I32)items);
930 call_method(methname, G_SCALAR);
933 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
934 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
935 * wrong error message, and worse case, supreme action at a distance.
936 * (Sorry obfuscation writers. You're not going to be given this one.)
938 stash = gv_stashsv(*MARK, 0);
939 if (!stash || !(gv = gv_fetchmethod(stash, methname))) {
940 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"",
941 methname, SVfARG(SvOK(*MARK) ? *MARK : &PL_sv_no));
943 ENTER_with_name("call_TIE");
944 PUSHSTACKi(PERLSI_MAGIC);
946 EXTEND(SP,(I32)items);
950 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
956 if (sv_isobject(sv)) {
957 sv_unmagic(varsv, how);
958 /* Croak if a self-tie on an aggregate is attempted. */
959 if (varsv == SvRV(sv) &&
960 (SvTYPE(varsv) == SVt_PVAV ||
961 SvTYPE(varsv) == SVt_PVHV))
963 "Self-ties of arrays and hashes are not supported");
964 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
966 LEAVE_with_name("call_TIE");
967 SP = PL_stack_base + markoff;
973 /* also used for: pp_dbmclose() */
980 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
981 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
983 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
986 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
987 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
989 if ((mg = SvTIED_mg(sv, how))) {
990 SV * const obj = SvRV(SvTIED_obj(sv, mg));
992 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
994 if (gv && isGV(gv) && (cv = GvCV(gv))) {
996 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
997 mXPUSHi(SvREFCNT(obj) - 1);
999 ENTER_with_name("call_UNTIE");
1000 call_sv(MUTABLE_SV(cv), G_VOID);
1001 LEAVE_with_name("call_UNTIE");
1004 else if (mg && SvREFCNT(obj) > 1) {
1005 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
1006 "untie attempted while %"UVuf" inner references still exist",
1007 (UV)SvREFCNT(obj) - 1 ) ;
1011 sv_unmagic(sv, how) ;
1020 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1021 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1023 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1026 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1027 !(sv = defelem_target(sv, NULL))) goto ret_undef;
1029 if ((mg = SvTIED_mg(sv, how))) {
1030 SETs(SvTIED_obj(sv, mg));
1031 return NORMAL; /* PUTBACK not needed, pp_tied never moves SP */
1045 HV * const hv = MUTABLE_HV(POPs);
1046 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1047 stash = gv_stashsv(sv, 0);
1048 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1050 require_pv("AnyDBM_File.pm");
1052 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1053 DIE(aTHX_ "No dbm on this machine");
1063 mPUSHu(O_RDWR|O_CREAT);
1067 if (!SvOK(right)) right = &PL_sv_no;
1071 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1074 if (!sv_isobject(TOPs)) {
1082 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1084 if (sv_isobject(TOPs))
1089 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1090 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1107 struct timeval timebuf;
1108 struct timeval *tbuf = &timebuf;
1111 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1116 # if BYTEORDER & 0xf0000
1117 # define ORDERBYTE (0x88888888 - BYTEORDER)
1119 # define ORDERBYTE (0x4444 - BYTEORDER)
1125 for (i = 1; i <= 3; i++) {
1126 SV * const sv = SP[i];
1130 if (SvREADONLY(sv)) {
1131 if (!(SvPOK(sv) && SvCUR(sv) == 0))
1132 Perl_croak_no_modify();
1134 else if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
1137 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1138 "Non-string passed as bitmask");
1139 SvPV_force_nomg_nolen(sv); /* force string conversion */
1146 /* little endians can use vecs directly */
1147 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1154 masksize = NFDBITS / NBBY;
1156 masksize = sizeof(long); /* documented int, everyone seems to use long */
1158 Zero(&fd_sets[0], 4, char*);
1161 # if SELECT_MIN_BITS == 1
1162 growsize = sizeof(fd_set);
1164 # if defined(__GLIBC__) && defined(__FD_SETSIZE)
1165 # undef SELECT_MIN_BITS
1166 # define SELECT_MIN_BITS __FD_SETSIZE
1168 /* If SELECT_MIN_BITS is greater than one we most probably will want
1169 * to align the sizes with SELECT_MIN_BITS/8 because for example
1170 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1171 * UNIX, Solaris, Darwin) the smallest quantum select() operates
1172 * on (sets/tests/clears bits) is 32 bits. */
1173 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1179 value = SvNV_nomg(sv);
1182 timebuf.tv_sec = (long)value;
1183 value -= (NV)timebuf.tv_sec;
1184 timebuf.tv_usec = (long)(value * 1000000.0);
1189 for (i = 1; i <= 3; i++) {
1191 if (!SvOK(sv) || SvCUR(sv) == 0) {
1198 Sv_Grow(sv, growsize);
1202 while (++j <= growsize) {
1206 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1208 Newx(fd_sets[i], growsize, char);
1209 for (offset = 0; offset < growsize; offset += masksize) {
1210 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1211 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1214 fd_sets[i] = SvPVX(sv);
1218 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1219 /* Can't make just the (void*) conditional because that would be
1220 * cpp #if within cpp macro, and not all compilers like that. */
1221 nfound = PerlSock_select(
1223 (Select_fd_set_t) fd_sets[1],
1224 (Select_fd_set_t) fd_sets[2],
1225 (Select_fd_set_t) fd_sets[3],
1226 (void*) tbuf); /* Workaround for compiler bug. */
1228 nfound = PerlSock_select(
1230 (Select_fd_set_t) fd_sets[1],
1231 (Select_fd_set_t) fd_sets[2],
1232 (Select_fd_set_t) fd_sets[3],
1235 for (i = 1; i <= 3; i++) {
1238 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1240 for (offset = 0; offset < growsize; offset += masksize) {
1241 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1242 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1244 Safefree(fd_sets[i]);
1251 if (GIMME_V == G_ARRAY && tbuf) {
1252 value = (NV)(timebuf.tv_sec) +
1253 (NV)(timebuf.tv_usec) / 1000000.0;
1258 DIE(aTHX_ "select not implemented");
1266 =for apidoc setdefout
1268 Sets PL_defoutgv, the default file handle for output, to the passed in
1269 typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference
1270 count of the passed in typeglob is increased by one, and the reference count
1271 of the typeglob that PL_defoutgv points to is decreased by one.
1277 Perl_setdefout(pTHX_ GV *gv)
1279 PERL_ARGS_ASSERT_SETDEFOUT;
1280 SvREFCNT_inc_simple_void_NN(gv);
1281 SvREFCNT_dec(PL_defoutgv);
1289 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1290 GV * egv = GvEGVx(PL_defoutgv);
1295 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1296 gvp = hv && HvENAME(hv)
1297 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1299 if (gvp && *gvp == egv) {
1300 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1304 mXPUSHs(newRV(MUTABLE_SV(egv)));
1308 if (!GvIO(newdefout))
1309 gv_IOadd(newdefout);
1310 setdefout(newdefout);
1320 MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1321 IO *const io = GvIO(gv);
1327 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1329 const U32 gimme = GIMME_V;
1330 Perl_tied_method(aTHX_ SV_CONST(GETC), SP, MUTABLE_SV(io), mg, gimme, 0);
1331 if (gimme == G_SCALAR) {
1333 SvSetMagicSV_nosteal(TARG, TOPs);
1338 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1339 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1341 SETERRNO(EBADF,RMS_IFI);
1345 sv_setpvs(TARG, " ");
1346 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1347 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1348 /* Find out how many bytes the char needs */
1349 Size_t len = UTF8SKIP(SvPVX_const(TARG));
1352 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1353 SvCUR_set(TARG,1+len);
1357 else SvUTF8_off(TARG);
1363 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1366 const I32 gimme = GIMME_V;
1368 PERL_ARGS_ASSERT_DOFORM;
1371 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1376 PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
1377 PUSHFORMAT(cx, retop);
1378 if (CvDEPTH(cv) >= 2) {
1379 PERL_STACK_OVERFLOW_CHECK();
1380 pad_push(CvPADLIST(cv), CvDEPTH(cv));
1383 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), CvDEPTH(cv));
1385 setdefout(gv); /* locally select filehandle so $% et al work */
1403 gv = MUTABLE_GV(POPs);
1420 tmpsv = sv_newmortal();
1421 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1422 DIE(aTHX_ "Undefined format \"%"SVf"\" called", SVfARG(tmpsv));
1424 IoFLAGS(io) &= ~IOf_DIDTOP;
1425 RETURNOP(doform(cv,gv,PL_op->op_next));
1431 GV * const gv = cxstack[cxstack_ix].blk_format.gv;
1432 IO * const io = GvIOp(gv);
1439 bool is_return = cBOOL(PL_op->op_type == OP_RETURN);
1441 if (is_return || !io || !(ofp = IoOFP(io)))
1444 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1445 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1447 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1448 PL_formtarget != PL_toptarget)
1452 if (!IoTOP_GV(io)) {
1455 if (!IoTOP_NAME(io)) {
1457 if (!IoFMT_NAME(io))
1458 IoFMT_NAME(io) = savepv(GvNAME(gv));
1459 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%"HEKf"_TOP",
1460 HEKfARG(GvNAME_HEK(gv))));
1461 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1462 if ((topgv && GvFORM(topgv)) ||
1463 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1464 IoTOP_NAME(io) = savesvpv(topname);
1466 IoTOP_NAME(io) = savepvs("top");
1468 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1469 if (!topgv || !GvFORM(topgv)) {
1470 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1473 IoTOP_GV(io) = topgv;
1475 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1476 I32 lines = IoLINES_LEFT(io);
1477 const char *s = SvPVX_const(PL_formtarget);
1478 if (lines <= 0) /* Yow, header didn't even fit!!! */
1480 while (lines-- > 0) {
1481 s = strchr(s, '\n');
1487 const STRLEN save = SvCUR(PL_formtarget);
1488 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1489 do_print(PL_formtarget, ofp);
1490 SvCUR_set(PL_formtarget, save);
1491 sv_chop(PL_formtarget, s);
1492 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1495 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1496 do_print(GvSV(gv_fetchpvs("\f", GV_ADD, SVt_PV)), ofp);
1497 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1499 PL_formtarget = PL_toptarget;
1500 IoFLAGS(io) |= IOf_DIDTOP;
1502 assert(fgv); /* IoTOP_GV(io) should have been set above */
1505 SV * const sv = sv_newmortal();
1506 gv_efullname4(sv, fgv, NULL, FALSE);
1507 DIE(aTHX_ "Undefined top format \"%"SVf"\" called", SVfARG(sv));
1509 return doform(cv, gv, PL_op);
1513 POPBLOCK(cx,PL_curpm);
1514 retop = cx->blk_sub.retop;
1516 SP = newsp; /* ignore retval of formline */
1520 /* XXX the semantics of doing 'return' in a format aren't documented.
1521 * Currently we ignore any args to 'return' and just return
1522 * a single undef in both scalar and list contexts
1524 PUSHs(&PL_sv_undef);
1525 else if (!io || !(fp = IoOFP(io))) {
1526 if (io && IoIFP(io))
1527 report_wrongway_fh(gv, '<');
1533 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1534 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1536 if (!do_print(PL_formtarget, fp))
1539 FmLINES(PL_formtarget) = 0;
1540 SvCUR_set(PL_formtarget, 0);
1541 *SvEND(PL_formtarget) = '\0';
1542 if (IoFLAGS(io) & IOf_FLUSH)
1543 (void)PerlIO_flush(fp);
1547 PL_formtarget = PL_bodytarget;
1548 PERL_UNUSED_VAR(gimme);
1554 dSP; dMARK; dORIGMARK;
1558 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1559 IO *const io = GvIO(gv);
1561 /* Treat empty list as "" */
1562 if (MARK == SP) XPUSHs(&PL_sv_no);
1565 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1567 if (MARK == ORIGMARK) {
1570 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1573 return Perl_tied_method(aTHX_ SV_CONST(PRINTF), mark - 1, MUTABLE_SV(io),
1575 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1582 SETERRNO(EBADF,RMS_IFI);
1585 else if (!(fp = IoOFP(io))) {
1587 report_wrongway_fh(gv, '<');
1588 else if (ckWARN(WARN_CLOSED))
1590 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1594 SV *sv = sv_newmortal();
1595 do_sprintf(sv, SP - MARK, MARK + 1);
1596 if (!do_print(sv, fp))
1599 if (IoFLAGS(io) & IOf_FLUSH)
1600 if (PerlIO_flush(fp) == EOF)
1609 PUSHs(&PL_sv_undef);
1616 const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1617 const int mode = POPi;
1618 SV * const sv = POPs;
1619 GV * const gv = MUTABLE_GV(POPs);
1622 /* Need TIEHANDLE method ? */
1623 const char * const tmps = SvPV_const(sv, len);
1624 if (do_open_raw(gv, tmps, len, mode, perm)) {
1625 IoLINES(GvIOp(gv)) = 0;
1629 PUSHs(&PL_sv_undef);
1635 /* also used for: pp_read() and pp_recv() (where supported) */
1639 dSP; dMARK; dORIGMARK; dTARGET;
1653 bool charstart = FALSE;
1654 STRLEN charskip = 0;
1656 GV * const gv = MUTABLE_GV(*++MARK);
1659 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1660 && gv && (io = GvIO(gv)) )
1662 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1664 return Perl_tied_method(aTHX_ SV_CONST(READ), mark - 1, MUTABLE_SV(io), mg,
1665 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1674 sv_setpvs(bufsv, "");
1675 length = SvIVx(*++MARK);
1677 DIE(aTHX_ "Negative length");
1680 offset = SvIVx(*++MARK);
1684 if (!io || !IoIFP(io)) {
1686 SETERRNO(EBADF,RMS_IFI);
1690 /* Note that fd can here validly be -1, don't check it yet. */
1691 fd = PerlIO_fileno(IoIFP(io));
1693 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1694 if (PL_op->op_type == OP_SYSREAD || PL_op->op_type == OP_RECV) {
1695 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
1696 "%s() is deprecated on :utf8 handles",
1699 buffer = SvPVutf8_force(bufsv, blen);
1700 /* UTF-8 may not have been set if they are all low bytes */
1705 buffer = SvPV_force(bufsv, blen);
1706 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
1708 if (DO_UTF8(bufsv)) {
1709 blen = sv_len_utf8_nomg(bufsv);
1718 if (PL_op->op_type == OP_RECV) {
1719 Sock_size_t bufsize;
1720 char namebuf[MAXPATHLEN];
1722 SETERRNO(EBADF,SS_IVCHAN);
1725 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
1726 bufsize = sizeof (struct sockaddr_in);
1728 bufsize = sizeof namebuf;
1730 #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1734 buffer = SvGROW(bufsv, (STRLEN)(length+1));
1735 /* 'offset' means 'flags' here */
1736 count = PerlSock_recvfrom(fd, buffer, length, offset,
1737 (struct sockaddr *)namebuf, &bufsize);
1740 /* MSG_TRUNC can give oversized count; quietly lose it */
1743 SvCUR_set(bufsv, count);
1744 *SvEND(bufsv) = '\0';
1745 (void)SvPOK_only(bufsv);
1749 /* This should not be marked tainted if the fp is marked clean */
1750 if (!(IoFLAGS(io) & IOf_UNTAINT))
1751 SvTAINTED_on(bufsv);
1753 #if defined(__CYGWIN__)
1754 /* recvfrom() on cygwin doesn't set bufsize at all for
1755 connected sockets, leaving us with trash in the returned
1756 name, so use the same test as the Win32 code to check if it
1757 wasn't set, and set it [perl #118843] */
1758 if (bufsize == sizeof namebuf)
1761 sv_setpvn(TARG, namebuf, bufsize);
1767 if (-offset > (SSize_t)blen)
1768 DIE(aTHX_ "Offset outside string");
1771 if (DO_UTF8(bufsv)) {
1772 /* convert offset-as-chars to offset-as-bytes */
1773 if (offset >= (SSize_t)blen)
1774 offset += SvCUR(bufsv) - blen;
1776 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1780 /* Reestablish the fd in case it shifted from underneath us. */
1781 fd = PerlIO_fileno(IoIFP(io));
1783 orig_size = SvCUR(bufsv);
1784 /* Allocating length + offset + 1 isn't perfect in the case of reading
1785 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1787 (should be 2 * length + offset + 1, or possibly something longer if
1788 IN_ENCODING Is true) */
1789 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
1790 if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1791 Zero(buffer+orig_size, offset-orig_size, char);
1793 buffer = buffer + offset;
1795 read_target = bufsv;
1797 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1798 concatenate it to the current buffer. */
1800 /* Truncate the existing buffer to the start of where we will be
1802 SvCUR_set(bufsv, offset);
1804 read_target = sv_newmortal();
1805 SvUPGRADE(read_target, SVt_PV);
1806 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1809 if (PL_op->op_type == OP_SYSREAD) {
1810 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1811 if (IoTYPE(io) == IoTYPE_SOCKET) {
1813 SETERRNO(EBADF,SS_IVCHAN);
1817 count = PerlSock_recv(fd, buffer, length, 0);
1823 SETERRNO(EBADF,RMS_IFI);
1827 count = PerlLIO_read(fd, buffer, length);
1832 count = PerlIO_read(IoIFP(io), buffer, length);
1833 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1834 if (count == 0 && PerlIO_error(IoIFP(io)))
1838 if (IoTYPE(io) == IoTYPE_WRONLY)
1839 report_wrongway_fh(gv, '>');
1842 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1843 *SvEND(read_target) = '\0';
1844 (void)SvPOK_only(read_target);
1845 if (fp_utf8 && !IN_BYTES) {
1846 /* Look at utf8 we got back and count the characters */
1847 const char *bend = buffer + count;
1848 while (buffer < bend) {
1850 skip = UTF8SKIP(buffer);
1853 if (buffer - charskip + skip > bend) {
1854 /* partial character - try for rest of it */
1855 length = skip - (bend-buffer);
1856 offset = bend - SvPVX_const(bufsv);
1868 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1869 provided amount read (count) was what was requested (length)
1871 if (got < wanted && count == length) {
1872 length = wanted - got;
1873 offset = bend - SvPVX_const(bufsv);
1876 /* return value is character count */
1880 else if (buffer_utf8) {
1881 /* Let svcatsv upgrade the bytes we read in to utf8.
1882 The buffer is a mortal so will be freed soon. */
1883 sv_catsv_nomg(bufsv, read_target);
1886 /* This should not be marked tainted if the fp is marked clean */
1887 if (!(IoFLAGS(io) & IOf_UNTAINT))
1888 SvTAINTED_on(bufsv);
1899 /* also used for: pp_send() where defined */
1903 dSP; dMARK; dORIGMARK; dTARGET;
1908 STRLEN orig_blen_bytes;
1909 const int op_type = PL_op->op_type;
1912 GV *const gv = MUTABLE_GV(*++MARK);
1913 IO *const io = GvIO(gv);
1916 if (op_type == OP_SYSWRITE && io) {
1917 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1919 if (MARK == SP - 1) {
1921 mXPUSHi(sv_len(sv));
1925 return Perl_tied_method(aTHX_ SV_CONST(WRITE), mark - 1, MUTABLE_SV(io), mg,
1926 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1936 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1938 if (io && IoIFP(io))
1939 report_wrongway_fh(gv, '<');
1942 SETERRNO(EBADF,RMS_IFI);
1945 fd = PerlIO_fileno(IoIFP(io));
1947 SETERRNO(EBADF,SS_IVCHAN);
1952 /* Do this first to trigger any overloading. */
1953 buffer = SvPV_const(bufsv, blen);
1954 orig_blen_bytes = blen;
1955 doing_utf8 = DO_UTF8(bufsv);
1957 if (PerlIO_isutf8(IoIFP(io))) {
1958 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
1959 "%s() is deprecated on :utf8 handles",
1961 if (!SvUTF8(bufsv)) {
1962 /* We don't modify the original scalar. */
1963 tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
1964 buffer = (char *) tmpbuf;
1968 else if (doing_utf8) {
1969 STRLEN tmplen = blen;
1970 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
1973 buffer = (char *) tmpbuf;
1977 assert((char *)result == buffer);
1978 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
1983 if (op_type == OP_SEND) {
1984 const int flags = SvIVx(*++MARK);
1987 char * const sockbuf = SvPVx(*++MARK, mlen);
1988 retval = PerlSock_sendto(fd, buffer, blen,
1989 flags, (struct sockaddr *)sockbuf, mlen);
1992 retval = PerlSock_send(fd, buffer, blen, flags);
1998 Size_t length = 0; /* This length is in characters. */
2004 /* The SV is bytes, and we've had to upgrade it. */
2005 blen_chars = orig_blen_bytes;
2007 /* The SV really is UTF-8. */
2008 /* Don't call sv_len_utf8 on a magical or overloaded
2009 scalar, as we might get back a different result. */
2010 blen_chars = sv_or_pv_len_utf8(bufsv, buffer, blen);
2017 length = blen_chars;
2019 #if Size_t_size > IVSIZE
2020 length = (Size_t)SvNVx(*++MARK);
2022 length = (Size_t)SvIVx(*++MARK);
2024 if ((SSize_t)length < 0) {
2026 DIE(aTHX_ "Negative length");
2031 offset = SvIVx(*++MARK);
2033 if (-offset > (IV)blen_chars) {
2035 DIE(aTHX_ "Offset outside string");
2037 offset += blen_chars;
2038 } else if (offset > (IV)blen_chars) {
2040 DIE(aTHX_ "Offset outside string");
2044 if (length > blen_chars - offset)
2045 length = blen_chars - offset;
2047 /* Here we convert length from characters to bytes. */
2048 if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
2049 /* Either we had to convert the SV, or the SV is magical, or
2050 the SV has overloading, in which case we can't or mustn't
2051 or mustn't call it again. */
2053 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
2054 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
2056 /* It's a real UTF-8 SV, and it's not going to change under
2057 us. Take advantage of any cache. */
2059 I32 len_I32 = length;
2061 /* Convert the start and end character positions to bytes.
2062 Remember that the second argument to sv_pos_u2b is relative
2064 sv_pos_u2b(bufsv, &start, &len_I32);
2071 buffer = buffer+offset;
2073 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2074 if (IoTYPE(io) == IoTYPE_SOCKET) {
2075 retval = PerlSock_send(fd, buffer, length, 0);
2080 /* See the note at doio.c:do_print about filesize limits. --jhi */
2081 retval = PerlLIO_write(fd, buffer, length);
2089 retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
2092 #if Size_t_size > IVSIZE
2112 * in Perl 5.12 and later, the additional parameter is a bitmask:
2115 * 2 = eof() <- ARGV magic
2117 * I'll rely on the compiler's trace flow analysis to decide whether to
2118 * actually assign this out here, or punt it into the only block where it is
2119 * used. Doing it out here is DRY on the condition logic.
2124 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
2130 if (PL_op->op_flags & OPf_SPECIAL) {
2131 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
2135 gv = PL_last_in_gv; /* eof */
2143 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2144 return tied_method1(SV_CONST(EOF), SP, MUTABLE_SV(io), mg, newSVuv(which));
2147 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2148 if (io && !IoIFP(io)) {
2149 if ((IoFLAGS(io) & IOf_START) && av_tindex(GvAVn(gv)) < 0) {
2152 IoFLAGS(io) &= ~IOf_START;
2153 do_open6(gv, "-", 1, NULL, NULL, 0);
2161 *svp = newSVpvs("-");
2163 else if (!nextargv(gv, FALSE))
2168 PUSHs(boolSV(do_eof(gv)));
2178 if (MAXARG != 0 && (TOPs || POPs))
2179 PL_last_in_gv = MUTABLE_GV(POPs);
2186 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2188 return tied_method0(SV_CONST(TELL), SP, MUTABLE_SV(io), mg);
2193 SETERRNO(EBADF,RMS_IFI);
2198 #if LSEEKSIZE > IVSIZE
2199 PUSHn( do_tell(gv) );
2201 PUSHi( do_tell(gv) );
2207 /* also used for: pp_seek() */
2212 const int whence = POPi;
2213 #if LSEEKSIZE > IVSIZE
2214 const Off_t offset = (Off_t)SvNVx(POPs);
2216 const Off_t offset = (Off_t)SvIVx(POPs);
2219 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2220 IO *const io = GvIO(gv);
2223 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2225 #if LSEEKSIZE > IVSIZE
2226 SV *const offset_sv = newSVnv((NV) offset);
2228 SV *const offset_sv = newSViv(offset);
2231 return tied_method2(SV_CONST(SEEK), SP, MUTABLE_SV(io), mg, offset_sv,
2236 if (PL_op->op_type == OP_SEEK)
2237 PUSHs(boolSV(do_seek(gv, offset, whence)));
2239 const Off_t sought = do_sysseek(gv, offset, whence);
2241 PUSHs(&PL_sv_undef);
2243 SV* const sv = sought ?
2244 #if LSEEKSIZE > IVSIZE
2249 : newSVpvn(zero_but_true, ZBTLEN);
2259 /* There seems to be no consensus on the length type of truncate()
2260 * and ftruncate(), both off_t and size_t have supporters. In
2261 * general one would think that when using large files, off_t is
2262 * at least as wide as size_t, so using an off_t should be okay. */
2263 /* XXX Configure probe for the length type of *truncate() needed XXX */
2266 #if Off_t_size > IVSIZE
2271 /* Checking for length < 0 is problematic as the type might or
2272 * might not be signed: if it is not, clever compilers will moan. */
2273 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2276 SV * const sv = POPs;
2281 if (PL_op->op_flags & OPf_SPECIAL
2282 ? (tmpgv = gv_fetchsv(sv, 0, SVt_PVIO), 1)
2283 : !!(tmpgv = MAYBE_DEREF_GV(sv)) ) {
2290 TAINT_PROPER("truncate");
2291 if (!(fp = IoIFP(io))) {
2295 int fd = PerlIO_fileno(fp);
2297 SETERRNO(EBADF,RMS_IFI);
2301 SETERRNO(EINVAL, LIB_INVARG);
2306 if (ftruncate(fd, len) < 0)
2308 if (my_chsize(fd, len) < 0)
2316 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2317 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2318 goto do_ftruncate_io;
2321 const char * const name = SvPV_nomg_const_nolen(sv);
2322 TAINT_PROPER("truncate");
2324 if (truncate(name, len) < 0)
2331 #if defined(USE_64_BIT_RAWIO) && defined(O_LARGEFILE)
2332 mode |= O_LARGEFILE; /* Transparently largefiley. */
2335 /* On open(), the Win32 CRT tries to seek around text
2336 * files using 32-bit offsets, which causes the open()
2337 * to fail on large files, so open in binary mode.
2341 tmpfd = PerlLIO_open(name, mode);
2346 if (my_chsize(tmpfd, len) < 0)
2348 PerlLIO_close(tmpfd);
2357 SETERRNO(EBADF,RMS_IFI);
2363 /* also used for: pp_fcntl() */
2368 SV * const argsv = POPs;
2369 const unsigned int func = POPu;
2371 GV * const gv = MUTABLE_GV(POPs);
2372 IO * const io = GvIOn(gv);
2378 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
2382 if (SvPOK(argsv) || !SvNIOK(argsv)) {
2385 s = SvPV_force(argsv, len);
2386 need = IOCPARM_LEN(func);
2388 s = Sv_Grow(argsv, need + 1);
2389 SvCUR_set(argsv, need);
2392 s[SvCUR(argsv)] = 17; /* a little sanity check here */
2395 retval = SvIV(argsv);
2396 s = INT2PTR(char*,retval); /* ouch */
2399 optype = PL_op->op_type;
2400 TAINT_PROPER(PL_op_desc[optype]);
2402 if (optype == OP_IOCTL)
2404 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2406 DIE(aTHX_ "ioctl is not implemented");
2410 DIE(aTHX_ "fcntl is not implemented");
2412 #if defined(OS2) && defined(__EMX__)
2413 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2415 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2419 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2421 if (s[SvCUR(argsv)] != 17)
2422 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2424 s[SvCUR(argsv)] = 0; /* put our null back */
2425 SvSETMAGIC(argsv); /* Assume it has changed */
2434 PUSHp(zero_but_true, ZBTLEN);
2445 const int argtype = POPi;
2446 GV * const gv = MUTABLE_GV(POPs);
2447 IO *const io = GvIO(gv);
2448 PerlIO *const fp = io ? IoIFP(io) : NULL;
2450 /* XXX Looks to me like io is always NULL at this point */
2452 (void)PerlIO_flush(fp);
2453 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2458 SETERRNO(EBADF,RMS_IFI);
2463 DIE(aTHX_ PL_no_func, "flock");
2474 const int protocol = POPi;
2475 const int type = POPi;
2476 const int domain = POPi;
2477 GV * const gv = MUTABLE_GV(POPs);
2478 IO * const io = GvIOn(gv);
2482 do_close(gv, FALSE);
2484 TAINT_PROPER("socket");
2485 fd = PerlSock_socket(domain, type, protocol);
2487 SETERRNO(EBADF,RMS_IFI);
2490 IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2491 IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2492 IoTYPE(io) = IoTYPE_SOCKET;
2493 if (!IoIFP(io) || !IoOFP(io)) {
2494 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2495 if (IoOFP(io)) PerlIO_close(IoOFP(io));
2496 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2499 #if defined(HAS_FCNTL) && defined(F_SETFD)
2500 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2510 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2513 const int protocol = POPi;
2514 const int type = POPi;
2515 const int domain = POPi;
2517 GV * const gv2 = MUTABLE_GV(POPs);
2518 IO * const io2 = GvIOn(gv2);
2519 GV * const gv1 = MUTABLE_GV(POPs);
2520 IO * const io1 = GvIOn(gv1);
2523 do_close(gv1, FALSE);
2525 do_close(gv2, FALSE);
2527 TAINT_PROPER("socketpair");
2528 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2530 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2531 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
2532 IoTYPE(io1) = IoTYPE_SOCKET;
2533 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2534 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
2535 IoTYPE(io2) = IoTYPE_SOCKET;
2536 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2537 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2538 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2539 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2540 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2541 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2542 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2545 #if defined(HAS_FCNTL) && defined(F_SETFD)
2546 /* ensure close-on-exec */
2547 if ((fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
2548 (fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd) < 0))
2554 DIE(aTHX_ PL_no_sock_func, "socketpair");
2560 /* also used for: pp_connect() */
2565 SV * const addrsv = POPs;
2566 /* OK, so on what platform does bind modify addr? */
2568 GV * const gv = MUTABLE_GV(POPs);
2569 IO * const io = GvIOn(gv);
2576 fd = PerlIO_fileno(IoIFP(io));
2580 addr = SvPV_const(addrsv, len);
2581 op_type = PL_op->op_type;
2582 TAINT_PROPER(PL_op_desc[op_type]);
2583 if ((op_type == OP_BIND
2584 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2585 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2593 SETERRNO(EBADF,SS_IVCHAN);
2600 const int backlog = POPi;
2601 GV * const gv = MUTABLE_GV(POPs);
2602 IO * const io = GvIOn(gv);
2607 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2614 SETERRNO(EBADF,SS_IVCHAN);
2622 char namebuf[MAXPATHLEN];
2623 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2624 Sock_size_t len = sizeof (struct sockaddr_in);
2626 Sock_size_t len = sizeof namebuf;
2628 GV * const ggv = MUTABLE_GV(POPs);
2629 GV * const ngv = MUTABLE_GV(POPs);
2632 IO * const gstio = GvIO(ggv);
2633 if (!gstio || !IoIFP(gstio))
2637 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2640 /* Some platforms indicate zero length when an AF_UNIX client is
2641 * not bound. Simulate a non-zero-length sockaddr structure in
2643 namebuf[0] = 0; /* sun_len */
2644 namebuf[1] = AF_UNIX; /* sun_family */
2652 do_close(ngv, FALSE);
2653 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2654 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2655 IoTYPE(nstio) = IoTYPE_SOCKET;
2656 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2657 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2658 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2659 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2662 #if defined(HAS_FCNTL) && defined(F_SETFD)
2663 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2667 #ifdef __SCO_VERSION__
2668 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2671 PUSHp(namebuf, len);
2675 report_evil_fh(ggv);
2676 SETERRNO(EBADF,SS_IVCHAN);
2686 const int how = POPi;
2687 GV * const gv = MUTABLE_GV(POPs);
2688 IO * const io = GvIOn(gv);
2693 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2698 SETERRNO(EBADF,SS_IVCHAN);
2703 /* also used for: pp_gsockopt() */
2708 const int optype = PL_op->op_type;
2709 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2710 const unsigned int optname = (unsigned int) POPi;
2711 const unsigned int lvl = (unsigned int) POPi;
2712 GV * const gv = MUTABLE_GV(POPs);
2713 IO * const io = GvIOn(gv);
2720 fd = PerlIO_fileno(IoIFP(io));
2726 (void)SvPOK_only(sv);
2730 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2733 /* XXX Configure test: does getsockopt set the length properly? */
2742 #if defined(__SYMBIAN32__)
2743 # define SETSOCKOPT_OPTION_VALUE_T void *
2745 # define SETSOCKOPT_OPTION_VALUE_T const char *
2747 /* XXX TODO: We need to have a proper type (a Configure probe,
2748 * etc.) for what the C headers think of the third argument of
2749 * setsockopt(), the option_value read-only buffer: is it
2750 * a "char *", or a "void *", const or not. Some compilers
2751 * don't take kindly to e.g. assuming that "char *" implicitly
2752 * promotes to a "void *", or to explicitly promoting/demoting
2753 * consts to non/vice versa. The "const void *" is the SUS
2754 * definition, but that does not fly everywhere for the above
2756 SETSOCKOPT_OPTION_VALUE_T buf;
2760 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2764 aint = (int)SvIV(sv);
2765 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2768 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2778 SETERRNO(EBADF,SS_IVCHAN);
2785 /* also used for: pp_getsockname() */
2790 const int optype = PL_op->op_type;
2791 GV * const gv = MUTABLE_GV(POPs);
2792 IO * const io = GvIOn(gv);
2800 sv = sv_2mortal(newSV(257));
2801 (void)SvPOK_only(sv);
2805 fd = PerlIO_fileno(IoIFP(io));
2809 case OP_GETSOCKNAME:
2810 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2813 case OP_GETPEERNAME:
2814 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2816 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2818 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";
2819 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2820 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2821 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2822 sizeof(u_short) + sizeof(struct in_addr))) {
2829 #ifdef BOGUS_GETNAME_RETURN
2830 /* Interactive Unix, getpeername() and getsockname()
2831 does not return valid namelen */
2832 if (len == BOGUS_GETNAME_RETURN)
2833 len = sizeof(struct sockaddr);
2842 SETERRNO(EBADF,SS_IVCHAN);
2851 /* also used for: pp_lstat() */
2862 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2863 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2864 if (PL_op->op_type == OP_LSTAT) {
2865 if (gv != PL_defgv) {
2866 do_fstat_warning_check:
2867 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2868 "lstat() on filehandle%s%"SVf,
2871 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2873 } else if (PL_laststype != OP_LSTAT)
2874 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2875 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2878 if (gv != PL_defgv) {
2882 PL_laststype = OP_STAT;
2883 PL_statgv = gv ? gv : (GV *)io;
2884 sv_setpvs(PL_statname, "");
2890 int fd = PerlIO_fileno(IoIFP(io));
2892 PL_laststatval = -1;
2893 SETERRNO(EBADF,RMS_IFI);
2895 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2898 } else if (IoDIRP(io)) {
2900 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2903 PL_laststatval = -1;
2906 else PL_laststatval = -1;
2907 if (PL_laststatval < 0 && !havefp) report_evil_fh(gv);
2910 if (PL_laststatval < 0) {
2916 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2917 io = MUTABLE_IO(SvRV(sv));
2918 if (PL_op->op_type == OP_LSTAT)
2919 goto do_fstat_warning_check;
2920 goto do_fstat_have_io;
2923 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2924 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2926 PL_laststype = PL_op->op_type;
2927 file = SvPV_nolen_const(PL_statname);
2928 if (PL_op->op_type == OP_LSTAT)
2929 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2931 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2932 if (PL_laststatval < 0) {
2933 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2934 /* PL_warn_nl is constant */
2935 GCC_DIAG_IGNORE(-Wformat-nonliteral);
2936 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2944 if (gimme != G_ARRAY) {
2945 if (gimme != G_VOID)
2946 XPUSHs(boolSV(max));
2952 mPUSHi(PL_statcache.st_dev);
2953 #if ST_INO_SIZE > IVSIZE
2954 mPUSHn(PL_statcache.st_ino);
2956 # if ST_INO_SIGN <= 0
2957 mPUSHi(PL_statcache.st_ino);
2959 mPUSHu(PL_statcache.st_ino);
2962 mPUSHu(PL_statcache.st_mode);
2963 mPUSHu(PL_statcache.st_nlink);
2965 sv_setuid(PUSHmortal, PL_statcache.st_uid);
2966 sv_setgid(PUSHmortal, PL_statcache.st_gid);
2968 #ifdef USE_STAT_RDEV
2969 mPUSHi(PL_statcache.st_rdev);
2971 PUSHs(newSVpvs_flags("", SVs_TEMP));
2973 #if Off_t_size > IVSIZE
2974 mPUSHn(PL_statcache.st_size);
2976 mPUSHi(PL_statcache.st_size);
2979 mPUSHn(PL_statcache.st_atime);
2980 mPUSHn(PL_statcache.st_mtime);
2981 mPUSHn(PL_statcache.st_ctime);
2983 mPUSHi(PL_statcache.st_atime);
2984 mPUSHi(PL_statcache.st_mtime);
2985 mPUSHi(PL_statcache.st_ctime);
2987 #ifdef USE_STAT_BLOCKS
2988 mPUSHu(PL_statcache.st_blksize);
2989 mPUSHu(PL_statcache.st_blocks);
2991 PUSHs(newSVpvs_flags("", SVs_TEMP));
2992 PUSHs(newSVpvs_flags("", SVs_TEMP));
2998 /* All filetest ops avoid manipulating the perl stack pointer in their main
2999 bodies (since commit d2c4d2d1e22d3125), and return using either
3000 S_ft_return_false() or S_ft_return_true(). These two helper functions are
3001 the only two which manipulate the perl stack. To ensure that no stack
3002 manipulation macros are used, the filetest ops avoid defining a local copy
3003 of the stack pointer with dSP. */
3005 /* If the next filetest is stacked up with this one
3006 (PL_op->op_private & OPpFT_STACKING), we leave
3007 the original argument on the stack for success,
3008 and skip the stacked operators on failure.
3009 The next few macros/functions take care of this.
3013 S_ft_return_false(pTHX_ SV *ret) {
3017 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
3021 if (PL_op->op_private & OPpFT_STACKING) {
3022 while (OP_IS_FILETEST(next->op_type)
3023 && next->op_private & OPpFT_STACKED)
3024 next = next->op_next;
3029 PERL_STATIC_INLINE OP *
3030 S_ft_return_true(pTHX_ SV *ret) {
3032 if (PL_op->op_flags & OPf_REF)
3033 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
3034 else if (!(PL_op->op_private & OPpFT_STACKING))
3040 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
3041 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
3042 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
3044 #define tryAMAGICftest_MG(chr) STMT_START { \
3045 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
3046 && PL_op->op_flags & OPf_KIDS) { \
3047 OP *next = S_try_amagic_ftest(aTHX_ chr); \
3048 if (next) return next; \
3053 S_try_amagic_ftest(pTHX_ char chr) {
3054 SV *const arg = *PL_stack_sp;
3057 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
3061 const char tmpchr = chr;
3062 SV * const tmpsv = amagic_call(arg,
3063 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
3064 ftest_amg, AMGf_unary);
3069 return SvTRUE(tmpsv)
3070 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3076 /* also used for: pp_fteexec() pp_fteread() pp_ftewrite() pp_ftrexec()
3082 /* Not const, because things tweak this below. Not bool, because there's
3083 no guarantee that OPpFT_ACCESS is <= CHAR_MAX */
3084 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3085 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3086 /* Giving some sort of initial value silences compilers. */
3088 int access_mode = R_OK;
3090 int access_mode = 0;
3093 /* access_mode is never used, but leaving use_access in makes the
3094 conditional compiling below much clearer. */
3097 Mode_t stat_mode = S_IRUSR;
3099 bool effective = FALSE;
3102 switch (PL_op->op_type) {
3103 case OP_FTRREAD: opchar = 'R'; break;
3104 case OP_FTRWRITE: opchar = 'W'; break;
3105 case OP_FTREXEC: opchar = 'X'; break;
3106 case OP_FTEREAD: opchar = 'r'; break;
3107 case OP_FTEWRITE: opchar = 'w'; break;
3108 case OP_FTEEXEC: opchar = 'x'; break;
3110 tryAMAGICftest_MG(opchar);
3112 switch (PL_op->op_type) {
3114 #if !(defined(HAS_ACCESS) && defined(R_OK))
3120 #if defined(HAS_ACCESS) && defined(W_OK)
3125 stat_mode = S_IWUSR;
3129 #if defined(HAS_ACCESS) && defined(X_OK)
3134 stat_mode = S_IXUSR;
3138 #ifdef PERL_EFF_ACCESS
3141 stat_mode = S_IWUSR;
3145 #ifndef PERL_EFF_ACCESS
3152 #ifdef PERL_EFF_ACCESS
3157 stat_mode = S_IXUSR;
3163 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3164 const char *name = SvPV_nolen(*PL_stack_sp);
3166 # ifdef PERL_EFF_ACCESS
3167 result = PERL_EFF_ACCESS(name, access_mode);
3169 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3175 result = access(name, access_mode);
3177 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3188 result = my_stat_flags(0);
3191 if (cando(stat_mode, effective, &PL_statcache))
3197 /* also used for: pp_ftatime() pp_ftctime() pp_ftmtime() pp_ftsize() */
3202 const int op_type = PL_op->op_type;
3206 case OP_FTIS: opchar = 'e'; break;
3207 case OP_FTSIZE: opchar = 's'; break;
3208 case OP_FTMTIME: opchar = 'M'; break;
3209 case OP_FTCTIME: opchar = 'C'; break;
3210 case OP_FTATIME: opchar = 'A'; break;
3212 tryAMAGICftest_MG(opchar);
3214 result = my_stat_flags(0);
3217 if (op_type == OP_FTIS)
3220 /* You can't dTARGET inside OP_FTIS, because you'll get
3221 "panic: pad_sv po" - the op is not flagged to have a target. */
3225 #if Off_t_size > IVSIZE
3226 sv_setnv(TARG, (NV)PL_statcache.st_size);
3228 sv_setiv(TARG, (IV)PL_statcache.st_size);
3233 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3237 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3241 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3245 return SvTRUE_nomg(TARG)
3246 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3251 /* also used for: pp_ftblk() pp_ftchr() pp_ftdir() pp_fteowned()
3252 * pp_ftfile() pp_ftpipe() pp_ftsgid() pp_ftsock()
3253 * pp_ftsuid() pp_ftsvtx() pp_ftzero() */
3260 switch (PL_op->op_type) {
3261 case OP_FTROWNED: opchar = 'O'; break;
3262 case OP_FTEOWNED: opchar = 'o'; break;
3263 case OP_FTZERO: opchar = 'z'; break;
3264 case OP_FTSOCK: opchar = 'S'; break;
3265 case OP_FTCHR: opchar = 'c'; break;
3266 case OP_FTBLK: opchar = 'b'; break;
3267 case OP_FTFILE: opchar = 'f'; break;
3268 case OP_FTDIR: opchar = 'd'; break;
3269 case OP_FTPIPE: opchar = 'p'; break;
3270 case OP_FTSUID: opchar = 'u'; break;
3271 case OP_FTSGID: opchar = 'g'; break;
3272 case OP_FTSVTX: opchar = 'k'; break;
3274 tryAMAGICftest_MG(opchar);
3276 /* I believe that all these three are likely to be defined on most every
3277 system these days. */
3279 if(PL_op->op_type == OP_FTSUID) {
3284 if(PL_op->op_type == OP_FTSGID) {
3289 if(PL_op->op_type == OP_FTSVTX) {
3294 result = my_stat_flags(0);
3297 switch (PL_op->op_type) {
3299 if (PL_statcache.st_uid == PerlProc_getuid())
3303 if (PL_statcache.st_uid == PerlProc_geteuid())
3307 if (PL_statcache.st_size == 0)
3311 if (S_ISSOCK(PL_statcache.st_mode))
3315 if (S_ISCHR(PL_statcache.st_mode))
3319 if (S_ISBLK(PL_statcache.st_mode))
3323 if (S_ISREG(PL_statcache.st_mode))
3327 if (S_ISDIR(PL_statcache.st_mode))
3331 if (S_ISFIFO(PL_statcache.st_mode))
3336 if (PL_statcache.st_mode & S_ISUID)
3342 if (PL_statcache.st_mode & S_ISGID)
3348 if (PL_statcache.st_mode & S_ISVTX)
3360 tryAMAGICftest_MG('l');
3361 result = my_lstat_flags(0);
3365 if (S_ISLNK(PL_statcache.st_mode))
3378 tryAMAGICftest_MG('t');
3380 if (PL_op->op_flags & OPf_REF)
3383 SV *tmpsv = *PL_stack_sp;
3384 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3385 name = SvPV_nomg(tmpsv, namelen);
3386 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3390 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3391 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3392 else if (name && isDIGIT(*name) && grok_atoUV(name, &uv, NULL) && uv <= PERL_INT_MAX)
3397 SETERRNO(EBADF,RMS_IFI);
3400 if (PerlLIO_isatty(fd))
3406 /* also used for: pp_ftbinary() */
3420 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3422 if (PL_op->op_flags & OPf_REF)
3424 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3429 gv = MAYBE_DEREF_GV_nomg(sv);
3433 if (gv == PL_defgv) {
3435 io = SvTYPE(PL_statgv) == SVt_PVIO
3439 goto really_filename;
3444 sv_setpvs(PL_statname, "");
3445 io = GvIO(PL_statgv);
3447 PL_laststatval = -1;
3448 PL_laststype = OP_STAT;
3449 if (io && IoIFP(io)) {
3451 if (! PerlIO_has_base(IoIFP(io)))
3452 DIE(aTHX_ "-T and -B not implemented on filehandles");
3453 fd = PerlIO_fileno(IoIFP(io));
3455 SETERRNO(EBADF,RMS_IFI);
3458 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3459 if (PL_laststatval < 0)
3461 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3462 if (PL_op->op_type == OP_FTTEXT)
3467 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3468 i = PerlIO_getc(IoIFP(io));
3470 (void)PerlIO_ungetc(IoIFP(io),i);
3472 /* null file is anything */
3475 len = PerlIO_get_bufsiz(IoIFP(io));
3476 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3477 /* sfio can have large buffers - limit to 512 */
3482 SETERRNO(EBADF,RMS_IFI);
3484 SETERRNO(EBADF,RMS_IFI);
3493 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3495 file = SvPVX_const(PL_statname);
3497 if (!(fp = PerlIO_open(file, "r"))) {
3499 PL_laststatval = -1;
3500 PL_laststype = OP_STAT;
3502 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3503 /* PL_warn_nl is constant */
3504 GCC_DIAG_IGNORE(-Wformat-nonliteral);
3505 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3510 PL_laststype = OP_STAT;
3511 fd = PerlIO_fileno(fp);
3513 (void)PerlIO_close(fp);
3514 SETERRNO(EBADF,RMS_IFI);
3517 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3518 if (PL_laststatval < 0) {
3519 (void)PerlIO_close(fp);
3520 SETERRNO(EBADF,RMS_IFI);
3523 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3524 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3525 (void)PerlIO_close(fp);
3527 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3528 FT_RETURNNO; /* special case NFS directories */
3529 FT_RETURNYES; /* null file is anything */
3534 /* now scan s to look for textiness */
3536 #if defined(DOSISH) || defined(USEMYBINMODE)
3537 /* ignore trailing ^Z on short files */
3538 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3543 if (! is_invariant_string((U8 *) s, len)) {
3546 /* Here contains a variant under UTF-8 . See if the entire string is
3547 * UTF-8. But the buffer may end in a partial character, so consider
3548 * it UTF-8 if the first non-UTF8 char is an ending partial */
3549 if (is_utf8_string_loc((U8 *) s, len, &ep)
3550 || ep + UTF8SKIP(ep) > (U8 *) (s + len))
3552 if (PL_op->op_type == OP_FTTEXT) {
3561 /* Here, is not UTF-8 or is entirely ASCII. Look through the buffer for
3562 * things that wouldn't be in ASCII text or rich ASCII text. Count these
3564 for (i = 0; i < len; i++, s++) {
3565 if (!*s) { /* null never allowed in text */
3569 #ifdef USE_LOCALE_CTYPE
3570 if (IN_LC_RUNTIME(LC_CTYPE)) {
3571 if ( isPRINT_LC(*s) || isSPACE_LC(*s)) {
3578 /* VT occurs so rarely in text, that we consider it odd */
3579 || (isSPACE_A(*s) && *s != VT_NATIVE)
3581 /* But there is a fair amount of backspaces and escapes in
3584 || *s == ESC_NATIVE)
3591 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3602 const char *tmps = NULL;
3606 SV * const sv = POPs;
3607 if (PL_op->op_flags & OPf_SPECIAL) {
3608 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3610 if (ckWARN(WARN_UNOPENED)) {
3611 Perl_warner(aTHX_ packWARN(WARN_UNOPENED),
3612 "chdir() on unopened filehandle %" SVf, sv);
3614 SETERRNO(EBADF,RMS_IFI);
3616 TAINT_PROPER("chdir");
3620 else if (!(gv = MAYBE_DEREF_GV(sv)))
3621 tmps = SvPV_nomg_const_nolen(sv);
3624 HV * const table = GvHVn(PL_envgv);
3627 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3628 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3630 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3634 tmps = SvPV_nolen_const(*svp);
3638 SETERRNO(EINVAL, LIB_INVARG);
3639 TAINT_PROPER("chdir");
3644 TAINT_PROPER("chdir");
3647 IO* const io = GvIO(gv);
3650 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3651 } else if (IoIFP(io)) {
3652 int fd = PerlIO_fileno(IoIFP(io));
3656 PUSHi(fchdir(fd) >= 0);
3666 DIE(aTHX_ PL_no_func, "fchdir");
3670 PUSHi( PerlDir_chdir(tmps) >= 0 );
3672 /* Clear the DEFAULT element of ENV so we'll get the new value
3674 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3681 SETERRNO(EBADF,RMS_IFI);
3688 /* also used for: pp_chmod() pp_kill() pp_unlink() pp_utime() */
3692 dSP; dMARK; dTARGET;
3693 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3704 char * const tmps = POPpx;
3705 TAINT_PROPER("chroot");
3706 PUSHi( chroot(tmps) >= 0 );
3709 DIE(aTHX_ PL_no_func, "chroot");
3717 const char * const tmps2 = POPpconstx;
3718 const char * const tmps = SvPV_nolen_const(TOPs);
3719 TAINT_PROPER("rename");
3721 anum = PerlLIO_rename(tmps, tmps2);
3723 if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) {
3724 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3727 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode))
3728 (void)UNLINK(tmps2);
3729 if (!(anum = link(tmps, tmps2)))
3730 anum = UNLINK(tmps);
3739 /* also used for: pp_symlink() */
3741 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3745 const int op_type = PL_op->op_type;
3749 if (op_type == OP_LINK)
3750 DIE(aTHX_ PL_no_func, "link");
3752 # ifndef HAS_SYMLINK
3753 if (op_type == OP_SYMLINK)
3754 DIE(aTHX_ PL_no_func, "symlink");
3758 const char * const tmps2 = POPpconstx;
3759 const char * const tmps = SvPV_nolen_const(TOPs);
3760 TAINT_PROPER(PL_op_desc[op_type]);
3762 # if defined(HAS_LINK)
3763 # if defined(HAS_SYMLINK)
3764 /* Both present - need to choose which. */
3765 (op_type == OP_LINK) ?
3766 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3768 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3769 PerlLIO_link(tmps, tmps2);
3772 # if defined(HAS_SYMLINK)
3773 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3774 symlink(tmps, tmps2);
3779 SETi( result >= 0 );
3784 /* also used for: pp_symlink() */
3789 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3799 char buf[MAXPATHLEN];
3804 /* NOTE: if the length returned by readlink() is sizeof(buf) - 1,
3805 * it is impossible to know whether the result was truncated. */
3806 len = readlink(tmps, buf, sizeof(buf) - 1);
3815 RETSETUNDEF; /* just pretend it's a normal file */
3819 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3821 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3823 char * const save_filename = filename;
3828 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3830 PERL_ARGS_ASSERT_DOONELINER;
3832 Newx(cmdline, size, char);
3833 my_strlcpy(cmdline, cmd, size);
3834 my_strlcat(cmdline, " ", size);
3835 for (s = cmdline + strlen(cmdline); *filename; ) {
3839 if (s - cmdline < size)
3840 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3841 myfp = PerlProc_popen(cmdline, "r");
3845 SV * const tmpsv = sv_newmortal();
3846 /* Need to save/restore 'PL_rs' ?? */
3847 s = sv_gets(tmpsv, myfp, 0);
3848 (void)PerlProc_pclose(myfp);
3852 #ifdef HAS_SYS_ERRLIST
3857 /* you don't see this */
3858 const char * const errmsg = Strerror(e) ;
3861 if (instr(s, errmsg)) {
3868 #define EACCES EPERM
3870 if (instr(s, "cannot make"))
3871 SETERRNO(EEXIST,RMS_FEX);
3872 else if (instr(s, "existing file"))
3873 SETERRNO(EEXIST,RMS_FEX);
3874 else if (instr(s, "ile exists"))
3875 SETERRNO(EEXIST,RMS_FEX);
3876 else if (instr(s, "non-exist"))
3877 SETERRNO(ENOENT,RMS_FNF);
3878 else if (instr(s, "does not exist"))
3879 SETERRNO(ENOENT,RMS_FNF);
3880 else if (instr(s, "not empty"))
3881 SETERRNO(EBUSY,SS_DEVOFFLINE);
3882 else if (instr(s, "cannot access"))
3883 SETERRNO(EACCES,RMS_PRV);
3885 SETERRNO(EPERM,RMS_PRV);
3888 else { /* some mkdirs return no failure indication */
3889 anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0);
3890 if (PL_op->op_type == OP_RMDIR)
3895 SETERRNO(EACCES,RMS_PRV); /* a guess */
3904 /* This macro removes trailing slashes from a directory name.
3905 * Different operating and file systems take differently to
3906 * trailing slashes. According to POSIX 1003.1 1996 Edition
3907 * any number of trailing slashes should be allowed.
3908 * Thusly we snip them away so that even non-conforming
3909 * systems are happy.
3910 * We should probably do this "filtering" for all
3911 * the functions that expect (potentially) directory names:
3912 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3913 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3915 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3916 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3919 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3920 (tmps) = savepvn((tmps), (len)); \
3930 const unsigned int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPu : 0777;
3932 TRIMSLASHES(tmps,len,copy);
3934 TAINT_PROPER("mkdir");
3936 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3940 SETi( dooneliner("mkdir", tmps) );
3941 oldumask = PerlLIO_umask(0);
3942 PerlLIO_umask(oldumask);
3943 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3958 TRIMSLASHES(tmps,len,copy);
3959 TAINT_PROPER("rmdir");
3961 SETi( PerlDir_rmdir(tmps) >= 0 );
3963 SETi( dooneliner("rmdir", tmps) );
3970 /* Directory calls. */
3974 #if defined(Direntry_t) && defined(HAS_READDIR)
3976 const char * const dirname = POPpconstx;
3977 GV * const gv = MUTABLE_GV(POPs);
3978 IO * const io = GvIOn(gv);
3980 if ((IoIFP(io) || IoOFP(io)))
3981 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
3982 "Opening filehandle %"HEKf" also as a directory",
3983 HEKfARG(GvENAME_HEK(gv)) );
3985 PerlDir_close(IoDIRP(io));
3986 if (!(IoDIRP(io) = PerlDir_open(dirname)))
3992 SETERRNO(EBADF,RMS_DIR);
3995 DIE(aTHX_ PL_no_dir_func, "opendir");
4001 #if !defined(Direntry_t) || !defined(HAS_READDIR)
4002 DIE(aTHX_ PL_no_dir_func, "readdir");
4004 #if !defined(I_DIRENT) && !defined(VMS)
4005 Direntry_t *readdir (DIR *);
4010 const I32 gimme = GIMME_V;
4011 GV * const gv = MUTABLE_GV(POPs);
4012 const Direntry_t *dp;
4013 IO * const io = GvIOn(gv);
4016 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4017 "readdir() attempted on invalid dirhandle %"HEKf,
4018 HEKfARG(GvENAME_HEK(gv)));
4023 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
4027 sv = newSVpvn(dp->d_name, dp->d_namlen);
4029 sv = newSVpv(dp->d_name, 0);
4031 if (!(IoFLAGS(io) & IOf_UNTAINT))
4034 } while (gimme == G_ARRAY);
4036 if (!dp && gimme != G_ARRAY)
4043 SETERRNO(EBADF,RMS_ISI);
4044 if (gimme == G_ARRAY)
4053 #if defined(HAS_TELLDIR) || defined(telldir)
4055 /* XXX does _anyone_ need this? --AD 2/20/1998 */
4056 /* XXX netbsd still seemed to.
4057 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
4058 --JHI 1999-Feb-02 */
4059 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
4060 long telldir (DIR *);
4062 GV * const gv = MUTABLE_GV(POPs);
4063 IO * const io = GvIOn(gv);
4066 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4067 "telldir() attempted on invalid dirhandle %"HEKf,
4068 HEKfARG(GvENAME_HEK(gv)));
4072 PUSHi( PerlDir_tell(IoDIRP(io)) );
4076 SETERRNO(EBADF,RMS_ISI);
4079 DIE(aTHX_ PL_no_dir_func, "telldir");
4085 #if defined(HAS_SEEKDIR) || defined(seekdir)
4087 const long along = POPl;
4088 GV * const gv = MUTABLE_GV(POPs);
4089 IO * const io = GvIOn(gv);
4092 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4093 "seekdir() attempted on invalid dirhandle %"HEKf,
4094 HEKfARG(GvENAME_HEK(gv)));
4097 (void)PerlDir_seek(IoDIRP(io), along);
4102 SETERRNO(EBADF,RMS_ISI);
4105 DIE(aTHX_ PL_no_dir_func, "seekdir");
4111 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4113 GV * const gv = MUTABLE_GV(POPs);
4114 IO * const io = GvIOn(gv);
4117 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4118 "rewinddir() attempted on invalid dirhandle %"HEKf,
4119 HEKfARG(GvENAME_HEK(gv)));
4122 (void)PerlDir_rewind(IoDIRP(io));
4126 SETERRNO(EBADF,RMS_ISI);
4129 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4135 #if defined(Direntry_t) && defined(HAS_READDIR)
4137 GV * const gv = MUTABLE_GV(POPs);
4138 IO * const io = GvIOn(gv);
4141 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4142 "closedir() attempted on invalid dirhandle %"HEKf,
4143 HEKfARG(GvENAME_HEK(gv)));
4146 #ifdef VOID_CLOSEDIR
4147 PerlDir_close(IoDIRP(io));
4149 if (PerlDir_close(IoDIRP(io)) < 0) {
4150 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4159 SETERRNO(EBADF,RMS_IFI);
4162 DIE(aTHX_ PL_no_dir_func, "closedir");
4166 /* Process control. */
4173 #ifdef HAS_SIGPROCMASK
4174 sigset_t oldmask, newmask;
4178 PERL_FLUSHALL_FOR_CHILD;
4179 #ifdef HAS_SIGPROCMASK
4180 sigfillset(&newmask);
4181 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4183 childpid = PerlProc_fork();
4184 if (childpid == 0) {
4188 for (sig = 1; sig < SIG_SIZE; sig++)
4189 PL_psig_pend[sig] = 0;
4191 #ifdef HAS_SIGPROCMASK
4194 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4201 #ifdef PERL_USES_PL_PIDSTATUS
4202 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4208 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4213 PERL_FLUSHALL_FOR_CHILD;
4214 childpid = PerlProc_fork();
4220 DIE(aTHX_ PL_no_func, "fork");
4227 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4232 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4233 childpid = wait4pid(-1, &argflags, 0);
4235 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4240 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4241 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4242 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4244 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4249 DIE(aTHX_ PL_no_func, "wait");
4255 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4257 const int optype = POPi;
4258 const Pid_t pid = TOPi;
4262 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4263 result = wait4pid(pid, &argflags, optype);
4265 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4270 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4271 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4272 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4274 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4279 DIE(aTHX_ PL_no_func, "waitpid");
4285 dSP; dMARK; dORIGMARK; dTARGET;
4286 #if defined(__LIBCATAMOUNT__)
4287 PL_statusvalue = -1;
4296 while (++MARK <= SP) {
4297 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4302 TAINT_PROPER("system");
4304 PERL_FLUSHALL_FOR_CHILD;
4305 #if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4310 #ifdef HAS_SIGPROCMASK
4311 sigset_t newset, oldset;
4314 if (PerlProc_pipe(pp) >= 0)
4316 #ifdef HAS_SIGPROCMASK
4317 sigemptyset(&newset);
4318 sigaddset(&newset, SIGCHLD);
4319 sigprocmask(SIG_BLOCK, &newset, &oldset);
4321 while ((childpid = PerlProc_fork()) == -1) {
4322 if (errno != EAGAIN) {
4327 PerlLIO_close(pp[0]);
4328 PerlLIO_close(pp[1]);
4330 #ifdef HAS_SIGPROCMASK
4331 sigprocmask(SIG_SETMASK, &oldset, NULL);
4338 Sigsave_t ihand,qhand; /* place to save signals during system() */
4342 PerlLIO_close(pp[1]);
4344 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4345 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4348 result = wait4pid(childpid, &status, 0);
4349 } while (result == -1 && errno == EINTR);
4351 #ifdef HAS_SIGPROCMASK
4352 sigprocmask(SIG_SETMASK, &oldset, NULL);
4354 (void)rsignal_restore(SIGINT, &ihand);
4355 (void)rsignal_restore(SIGQUIT, &qhand);
4357 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4358 do_execfree(); /* free any memory child malloced on fork */
4365 while (n < sizeof(int)) {
4366 n1 = PerlLIO_read(pp[0],
4367 (void*)(((char*)&errkid)+n),
4373 PerlLIO_close(pp[0]);
4374 if (n) { /* Error */
4375 if (n != sizeof(int))
4376 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4377 errno = errkid; /* Propagate errno from kid */
4378 STATUS_NATIVE_CHILD_SET(-1);
4381 XPUSHi(STATUS_CURRENT);
4384 #ifdef HAS_SIGPROCMASK
4385 sigprocmask(SIG_SETMASK, &oldset, NULL);
4388 PerlLIO_close(pp[0]);
4389 #if defined(HAS_FCNTL) && defined(F_SETFD)
4390 if (fcntl(pp[1], F_SETFD, FD_CLOEXEC) < 0)
4394 if (PL_op->op_flags & OPf_STACKED) {
4395 SV * const really = *++MARK;
4396 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4398 else if (SP - MARK != 1)
4399 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4401 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4405 #else /* ! FORK or VMS or OS/2 */
4408 if (PL_op->op_flags & OPf_STACKED) {
4409 SV * const really = *++MARK;
4410 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4411 value = (I32)do_aspawn(really, MARK, SP);
4413 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4416 else if (SP - MARK != 1) {
4417 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4418 value = (I32)do_aspawn(NULL, MARK, SP);
4420 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4424 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4426 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4428 STATUS_NATIVE_CHILD_SET(value);
4431 XPUSHi(result ? value : STATUS_CURRENT);
4432 #endif /* !FORK or VMS or OS/2 */
4439 dSP; dMARK; dORIGMARK; dTARGET;
4444 while (++MARK <= SP) {
4445 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4450 TAINT_PROPER("exec");
4452 PERL_FLUSHALL_FOR_CHILD;
4453 if (PL_op->op_flags & OPf_STACKED) {
4454 SV * const really = *++MARK;
4455 value = (I32)do_aexec(really, MARK, SP);
4457 else if (SP - MARK != 1)
4459 value = (I32)vms_do_aexec(NULL, MARK, SP);
4461 value = (I32)do_aexec(NULL, MARK, SP);
4465 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4467 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4480 XPUSHi( getppid() );
4483 DIE(aTHX_ PL_no_func, "getppid");
4493 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4496 pgrp = (I32)BSD_GETPGRP(pid);
4498 if (pid != 0 && pid != PerlProc_getpid())
4499 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4505 DIE(aTHX_ PL_no_func, "getpgrp");
4515 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4516 if (MAXARG > 0) pid = TOPs ? TOPi : 0;
4523 TAINT_PROPER("setpgrp");
4525 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4527 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4528 || (pid != 0 && pid != PerlProc_getpid()))
4530 DIE(aTHX_ "setpgrp can't take arguments");
4532 SETi( setpgrp() >= 0 );
4533 #endif /* USE_BSDPGRP */
4536 DIE(aTHX_ PL_no_func, "setpgrp");
4540 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4541 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4543 # define PRIORITY_WHICH_T(which) which
4548 #ifdef HAS_GETPRIORITY
4550 const int who = POPi;
4551 const int which = TOPi;
4552 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4555 DIE(aTHX_ PL_no_func, "getpriority");
4561 #ifdef HAS_SETPRIORITY
4563 const int niceval = POPi;
4564 const int who = POPi;
4565 const int which = TOPi;
4566 TAINT_PROPER("setpriority");
4567 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4570 DIE(aTHX_ PL_no_func, "setpriority");
4574 #undef PRIORITY_WHICH_T
4582 XPUSHn( time(NULL) );
4584 XPUSHi( time(NULL) );
4593 struct tms timesbuf;
4596 (void)PerlProc_times(×buf);
4598 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4599 if (GIMME_V == G_ARRAY) {
4600 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4601 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4602 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4610 if (GIMME_V == G_ARRAY) {
4617 DIE(aTHX_ "times not implemented");
4619 #endif /* HAS_TIMES */
4622 /* The 32 bit int year limits the times we can represent to these
4623 boundaries with a few days wiggle room to account for time zone
4626 /* Sat Jan 3 00:00:00 -2147481748 */
4627 #define TIME_LOWER_BOUND -67768100567755200.0
4628 /* Sun Dec 29 12:00:00 2147483647 */
4629 #define TIME_UPPER_BOUND 67767976233316800.0
4632 /* also used for: pp_localtime() */
4640 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4641 static const char * const dayname[] =
4642 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4643 static const char * const monname[] =
4644 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4645 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4647 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4650 when = (Time64_T)now;
4653 NV input = Perl_floor(POPn);
4654 const bool pl_isnan = Perl_isnan(input);
4655 when = (Time64_T)input;
4656 if (UNLIKELY(pl_isnan || when != input)) {
4657 /* diag_listed_as: gmtime(%f) too large */
4658 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4659 "%s(%.0" NVff ") too large", opname, input);
4667 if ( TIME_LOWER_BOUND > when ) {
4668 /* diag_listed_as: gmtime(%f) too small */
4669 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4670 "%s(%.0" NVff ") too small", opname, when);
4673 else if( when > TIME_UPPER_BOUND ) {
4674 /* diag_listed_as: gmtime(%f) too small */
4675 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4676 "%s(%.0" NVff ") too large", opname, when);
4680 if (PL_op->op_type == OP_LOCALTIME)
4681 err = Perl_localtime64_r(&when, &tmbuf);
4683 err = Perl_gmtime64_r(&when, &tmbuf);
4687 /* diag_listed_as: gmtime(%f) failed */
4688 /* XXX %lld broken for quads */
4690 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4691 "%s(%.0" NVff ") failed", opname, when);
4694 if (GIMME_V != G_ARRAY) { /* scalar context */
4701 Perl_sv_setpvf_mg(aTHX_ TARG, "%s %s %2d %02d:%02d:%02d %"IVdf,
4702 dayname[tmbuf.tm_wday],
4703 monname[tmbuf.tm_mon],
4708 (IV)tmbuf.tm_year + 1900);
4711 else { /* list context */
4717 mPUSHi(tmbuf.tm_sec);
4718 mPUSHi(tmbuf.tm_min);
4719 mPUSHi(tmbuf.tm_hour);
4720 mPUSHi(tmbuf.tm_mday);
4721 mPUSHi(tmbuf.tm_mon);
4722 mPUSHn(tmbuf.tm_year);
4723 mPUSHi(tmbuf.tm_wday);
4724 mPUSHi(tmbuf.tm_yday);
4725 mPUSHi(tmbuf.tm_isdst);
4734 /* alarm() takes an unsigned int number of seconds, and return the
4735 * unsigned int number of seconds remaining in the previous alarm
4736 * (alarms don't stack). Therefore negative return values are not
4740 /* Note that while the C library function alarm() as such has
4741 * no errors defined (or in other words, properly behaving client
4742 * code shouldn't expect any), alarm() being obsoleted by
4743 * setitimer() and often being implemented in terms of
4744 * setitimer(), can fail. */
4745 /* diag_listed_as: %s() with negative argument */
4746 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4747 "alarm() with negative argument");
4748 SETERRNO(EINVAL, LIB_INVARG);
4752 unsigned int retval = alarm(anum);
4753 if ((int)retval < 0) /* Strictly speaking "cannot happen". */
4759 DIE(aTHX_ PL_no_func, "alarm");
4770 (void)time(&lasttime);
4771 if (MAXARG < 1 || (!TOPs && !POPs))
4776 /* diag_listed_as: %s() with negative argument */
4777 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4778 "sleep() with negative argument");
4779 SETERRNO(EINVAL, LIB_INVARG);
4783 PerlProc_sleep((unsigned int)duration);
4787 XPUSHi(when - lasttime);
4791 /* Shared memory. */
4792 /* Merged with some message passing. */
4794 /* also used for: pp_msgrcv() pp_msgsnd() pp_semop() pp_shmread() */
4798 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4799 dSP; dMARK; dTARGET;
4800 const int op_type = PL_op->op_type;
4805 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4808 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4811 value = (I32)(do_semop(MARK, SP) >= 0);
4814 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4822 return Perl_pp_semget(aTHX);
4828 /* also used for: pp_msgget() pp_shmget() */
4832 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4833 dSP; dMARK; dTARGET;
4834 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4841 DIE(aTHX_ "System V IPC is not implemented on this machine");
4845 /* also used for: pp_msgctl() pp_shmctl() */
4849 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4850 dSP; dMARK; dTARGET;
4851 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4859 PUSHp(zero_but_true, ZBTLEN);
4863 return Perl_pp_semget(aTHX);
4867 /* I can't const this further without getting warnings about the types of
4868 various arrays passed in from structures. */
4870 S_space_join_names_mortal(pTHX_ char *const *array)
4874 PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL;
4877 target = newSVpvs_flags("", SVs_TEMP);
4879 sv_catpv(target, *array);
4882 sv_catpvs(target, " ");
4885 target = sv_mortalcopy(&PL_sv_no);
4890 /* Get system info. */
4892 /* also used for: pp_ghbyaddr() pp_ghbyname() */
4896 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4898 I32 which = PL_op->op_type;
4901 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4902 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4903 struct hostent *gethostbyname(Netdb_name_t);
4904 struct hostent *gethostent(void);
4906 struct hostent *hent = NULL;
4910 if (which == OP_GHBYNAME) {
4911 #ifdef HAS_GETHOSTBYNAME
4912 const char* const name = POPpbytex;
4913 hent = PerlSock_gethostbyname(name);
4915 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
4918 else if (which == OP_GHBYADDR) {
4919 #ifdef HAS_GETHOSTBYADDR
4920 const int addrtype = POPi;
4921 SV * const addrsv = POPs;
4923 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
4925 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
4927 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
4931 #ifdef HAS_GETHOSTENT
4932 hent = PerlSock_gethostent();
4934 DIE(aTHX_ PL_no_sock_func, "gethostent");
4937 #ifdef HOST_NOT_FOUND
4939 #ifdef USE_REENTRANT_API
4940 # ifdef USE_GETHOSTENT_ERRNO
4941 h_errno = PL_reentrant_buffer->_gethostent_errno;
4944 STATUS_UNIX_SET(h_errno);
4948 if (GIMME_V != G_ARRAY) {
4949 PUSHs(sv = sv_newmortal());
4951 if (which == OP_GHBYNAME) {
4953 sv_setpvn(sv, hent->h_addr, hent->h_length);
4956 sv_setpv(sv, (char*)hent->h_name);
4962 mPUSHs(newSVpv((char*)hent->h_name, 0));
4963 PUSHs(space_join_names_mortal(hent->h_aliases));
4964 mPUSHi(hent->h_addrtype);
4965 len = hent->h_length;
4968 for (elem = hent->h_addr_list; elem && *elem; elem++) {
4969 mXPUSHp(*elem, len);
4973 mPUSHp(hent->h_addr, len);
4975 PUSHs(sv_mortalcopy(&PL_sv_no));
4980 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4984 /* also used for: pp_gnbyaddr() pp_gnbyname() */
4988 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
4990 I32 which = PL_op->op_type;
4992 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
4993 struct netent *getnetbyaddr(Netdb_net_t, int);
4994 struct netent *getnetbyname(Netdb_name_t);
4995 struct netent *getnetent(void);
4997 struct netent *nent;
4999 if (which == OP_GNBYNAME){
5000 #ifdef HAS_GETNETBYNAME
5001 const char * const name = POPpbytex;
5002 nent = PerlSock_getnetbyname(name);
5004 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
5007 else if (which == OP_GNBYADDR) {
5008 #ifdef HAS_GETNETBYADDR
5009 const int addrtype = POPi;
5010 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
5011 nent = PerlSock_getnetbyaddr(addr, addrtype);
5013 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
5017 #ifdef HAS_GETNETENT
5018 nent = PerlSock_getnetent();
5020 DIE(aTHX_ PL_no_sock_func, "getnetent");
5023 #ifdef HOST_NOT_FOUND
5025 #ifdef USE_REENTRANT_API
5026 # ifdef USE_GETNETENT_ERRNO
5027 h_errno = PL_reentrant_buffer->_getnetent_errno;
5030 STATUS_UNIX_SET(h_errno);
5035 if (GIMME_V != G_ARRAY) {
5036 PUSHs(sv = sv_newmortal());
5038 if (which == OP_GNBYNAME)
5039 sv_setiv(sv, (IV)nent->n_net);
5041 sv_setpv(sv, nent->n_name);
5047 mPUSHs(newSVpv(nent->n_name, 0));
5048 PUSHs(space_join_names_mortal(nent->n_aliases));
5049 mPUSHi(nent->n_addrtype);
5050 mPUSHi(nent->n_net);
5055 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5060 /* also used for: pp_gpbyname() pp_gpbynumber() */
5064 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
5066 I32 which = PL_op->op_type;
5068 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
5069 struct protoent *getprotobyname(Netdb_name_t);
5070 struct protoent *getprotobynumber(int);
5071 struct protoent *getprotoent(void);
5073 struct protoent *pent;
5075 if (which == OP_GPBYNAME) {
5076 #ifdef HAS_GETPROTOBYNAME
5077 const char* const name = POPpbytex;
5078 pent = PerlSock_getprotobyname(name);
5080 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
5083 else if (which == OP_GPBYNUMBER) {
5084 #ifdef HAS_GETPROTOBYNUMBER
5085 const int number = POPi;
5086 pent = PerlSock_getprotobynumber(number);
5088 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
5092 #ifdef HAS_GETPROTOENT
5093 pent = PerlSock_getprotoent();
5095 DIE(aTHX_ PL_no_sock_func, "getprotoent");
5099 if (GIMME_V != G_ARRAY) {
5100 PUSHs(sv = sv_newmortal());
5102 if (which == OP_GPBYNAME)
5103 sv_setiv(sv, (IV)pent->p_proto);
5105 sv_setpv(sv, pent->p_name);
5111 mPUSHs(newSVpv(pent->p_name, 0));
5112 PUSHs(space_join_names_mortal(pent->p_aliases));
5113 mPUSHi(pent->p_proto);
5118 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5123 /* also used for: pp_gsbyname() pp_gsbyport() */
5127 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
5129 I32 which = PL_op->op_type;
5131 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
5132 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
5133 struct servent *getservbyport(int, Netdb_name_t);
5134 struct servent *getservent(void);
5136 struct servent *sent;
5138 if (which == OP_GSBYNAME) {
5139 #ifdef HAS_GETSERVBYNAME
5140 const char * const proto = POPpbytex;
5141 const char * const name = POPpbytex;
5142 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
5144 DIE(aTHX_ PL_no_sock_func, "getservbyname");
5147 else if (which == OP_GSBYPORT) {
5148 #ifdef HAS_GETSERVBYPORT
5149 const char * const proto = POPpbytex;
5150 unsigned short port = (unsigned short)POPu;
5151 port = PerlSock_htons(port);
5152 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
5154 DIE(aTHX_ PL_no_sock_func, "getservbyport");
5158 #ifdef HAS_GETSERVENT
5159 sent = PerlSock_getservent();
5161 DIE(aTHX_ PL_no_sock_func, "getservent");
5165 if (GIMME_V != G_ARRAY) {
5166 PUSHs(sv = sv_newmortal());
5168 if (which == OP_GSBYNAME) {
5169 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5172 sv_setpv(sv, sent->s_name);
5178 mPUSHs(newSVpv(sent->s_name, 0));
5179 PUSHs(space_join_names_mortal(sent->s_aliases));
5180 mPUSHi(PerlSock_ntohs(sent->s_port));
5181 mPUSHs(newSVpv(sent->s_proto, 0));
5186 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5191 /* also used for: pp_snetent() pp_sprotoent() pp_sservent() */
5196 const int stayopen = TOPi;
5197 switch(PL_op->op_type) {
5199 #ifdef HAS_SETHOSTENT
5200 PerlSock_sethostent(stayopen);
5202 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5205 #ifdef HAS_SETNETENT
5207 PerlSock_setnetent(stayopen);
5209 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5213 #ifdef HAS_SETPROTOENT
5214 PerlSock_setprotoent(stayopen);
5216 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5220 #ifdef HAS_SETSERVENT
5221 PerlSock_setservent(stayopen);
5223 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5231 /* also used for: pp_egrent() pp_enetent() pp_eprotoent() pp_epwent()
5232 * pp_eservent() pp_sgrent() pp_spwent() */
5237 switch(PL_op->op_type) {
5239 #ifdef HAS_ENDHOSTENT
5240 PerlSock_endhostent();
5242 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5246 #ifdef HAS_ENDNETENT
5247 PerlSock_endnetent();
5249 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5253 #ifdef HAS_ENDPROTOENT
5254 PerlSock_endprotoent();
5256 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5260 #ifdef HAS_ENDSERVENT
5261 PerlSock_endservent();
5263 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5267 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5270 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5274 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5277 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5281 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5284 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5288 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5291 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5300 /* also used for: pp_gpwnam() pp_gpwuid() */
5306 I32 which = PL_op->op_type;
5308 struct passwd *pwent = NULL;
5310 * We currently support only the SysV getsp* shadow password interface.
5311 * The interface is declared in <shadow.h> and often one needs to link
5312 * with -lsecurity or some such.
5313 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5316 * AIX getpwnam() is clever enough to return the encrypted password
5317 * only if the caller (euid?) is root.
5319 * There are at least three other shadow password APIs. Many platforms
5320 * seem to contain more than one interface for accessing the shadow
5321 * password databases, possibly for compatibility reasons.
5322 * The getsp*() is by far he simplest one, the other two interfaces
5323 * are much more complicated, but also very similar to each other.
5328 * struct pr_passwd *getprpw*();
5329 * The password is in
5330 * char getprpw*(...).ufld.fd_encrypt[]
5331 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5336 * struct es_passwd *getespw*();
5337 * The password is in
5338 * char *(getespw*(...).ufld.fd_encrypt)
5339 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5342 * struct userpw *getuserpw();
5343 * The password is in
5344 * char *(getuserpw(...)).spw_upw_passwd
5345 * (but the de facto standard getpwnam() should work okay)
5347 * Mention I_PROT here so that Configure probes for it.
5349 * In HP-UX for getprpw*() the manual page claims that one should include
5350 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5351 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5352 * and pp_sys.c already includes <shadow.h> if there is such.
5354 * Note that <sys/security.h> is already probed for, but currently
5355 * it is only included in special cases.
5357 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5358 * be preferred interface, even though also the getprpw*() interface
5359 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5360 * One also needs to call set_auth_parameters() in main() before
5361 * doing anything else, whether one is using getespw*() or getprpw*().
5363 * Note that accessing the shadow databases can be magnitudes
5364 * slower than accessing the standard databases.
5369 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5370 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5371 * the pw_comment is left uninitialized. */
5372 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5378 const char* const name = POPpbytex;
5379 pwent = getpwnam(name);
5385 pwent = getpwuid(uid);
5389 # ifdef HAS_GETPWENT
5391 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5392 if (pwent) pwent = getpwnam(pwent->pw_name);
5395 DIE(aTHX_ PL_no_func, "getpwent");
5401 if (GIMME_V != G_ARRAY) {
5402 PUSHs(sv = sv_newmortal());
5404 if (which == OP_GPWNAM)
5405 sv_setuid(sv, pwent->pw_uid);
5407 sv_setpv(sv, pwent->pw_name);
5413 mPUSHs(newSVpv(pwent->pw_name, 0));
5417 /* If we have getspnam(), we try to dig up the shadow
5418 * password. If we are underprivileged, the shadow
5419 * interface will set the errno to EACCES or similar,
5420 * and return a null pointer. If this happens, we will
5421 * use the dummy password (usually "*" or "x") from the
5422 * standard password database.
5424 * In theory we could skip the shadow call completely
5425 * if euid != 0 but in practice we cannot know which
5426 * security measures are guarding the shadow databases
5427 * on a random platform.
5429 * Resist the urge to use additional shadow interfaces.
5430 * Divert the urge to writing an extension instead.
5433 /* Some AIX setups falsely(?) detect some getspnam(), which
5434 * has a different API than the Solaris/IRIX one. */
5435 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5438 const struct spwd * const spwent = getspnam(pwent->pw_name);
5439 /* Save and restore errno so that
5440 * underprivileged attempts seem
5441 * to have never made the unsuccessful
5442 * attempt to retrieve the shadow password. */
5444 if (spwent && spwent->sp_pwdp)
5445 sv_setpv(sv, spwent->sp_pwdp);
5449 if (!SvPOK(sv)) /* Use the standard password, then. */
5450 sv_setpv(sv, pwent->pw_passwd);
5453 /* passwd is tainted because user himself can diddle with it.
5454 * admittedly not much and in a very limited way, but nevertheless. */
5457 sv_setuid(PUSHmortal, pwent->pw_uid);
5458 sv_setgid(PUSHmortal, pwent->pw_gid);
5460 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5461 * because of the poor interface of the Perl getpw*(),
5462 * not because there's some standard/convention saying so.
5463 * A better interface would have been to return a hash,
5464 * but we are accursed by our history, alas. --jhi. */
5466 mPUSHi(pwent->pw_change);
5469 mPUSHi(pwent->pw_quota);
5472 mPUSHs(newSVpv(pwent->pw_age, 0));
5474 /* I think that you can never get this compiled, but just in case. */
5475 PUSHs(sv_mortalcopy(&PL_sv_no));
5480 /* pw_class and pw_comment are mutually exclusive--.
5481 * see the above note for pw_change, pw_quota, and pw_age. */
5483 mPUSHs(newSVpv(pwent->pw_class, 0));
5486 mPUSHs(newSVpv(pwent->pw_comment, 0));
5488 /* I think that you can never get this compiled, but just in case. */
5489 PUSHs(sv_mortalcopy(&PL_sv_no));
5494 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5496 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5498 /* pw_gecos is tainted because user himself can diddle with it. */
5501 mPUSHs(newSVpv(pwent->pw_dir, 0));
5503 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5504 /* pw_shell is tainted because user himself can diddle with it. */
5508 mPUSHi(pwent->pw_expire);
5513 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5518 /* also used for: pp_ggrgid() pp_ggrnam() */
5524 const I32 which = PL_op->op_type;
5525 const struct group *grent;
5527 if (which == OP_GGRNAM) {
5528 const char* const name = POPpbytex;
5529 grent = (const struct group *)getgrnam(name);
5531 else if (which == OP_GGRGID) {
5533 const Gid_t gid = POPu;
5534 #elif Gid_t_sign == -1
5535 const Gid_t gid = POPi;
5537 # error "Unexpected Gid_t_sign"
5539 grent = (const struct group *)getgrgid(gid);
5543 grent = (struct group *)getgrent();
5545 DIE(aTHX_ PL_no_func, "getgrent");
5549 if (GIMME_V != G_ARRAY) {
5550 SV * const sv = sv_newmortal();
5554 if (which == OP_GGRNAM)
5555 sv_setgid(sv, grent->gr_gid);
5557 sv_setpv(sv, grent->gr_name);
5563 mPUSHs(newSVpv(grent->gr_name, 0));
5566 mPUSHs(newSVpv(grent->gr_passwd, 0));
5568 PUSHs(sv_mortalcopy(&PL_sv_no));
5571 sv_setgid(PUSHmortal, grent->gr_gid);
5573 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5574 /* In UNICOS/mk (_CRAYMPP) the multithreading
5575 * versions (getgrnam_r, getgrgid_r)
5576 * seem to return an illegal pointer
5577 * as the group members list, gr_mem.
5578 * getgrent() doesn't even have a _r version
5579 * but the gr_mem is poisonous anyway.
5580 * So yes, you cannot get the list of group
5581 * members if building multithreaded in UNICOS/mk. */
5582 PUSHs(space_join_names_mortal(grent->gr_mem));
5588 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5598 if (!(tmps = PerlProc_getlogin()))
5600 sv_setpv_mg(TARG, tmps);
5604 DIE(aTHX_ PL_no_func, "getlogin");
5608 /* Miscellaneous. */
5613 dSP; dMARK; dORIGMARK; dTARGET;
5614 I32 items = SP - MARK;
5615 unsigned long a[20];
5620 while (++MARK <= SP) {
5621 if (SvTAINTED(*MARK)) {
5627 TAINT_PROPER("syscall");
5630 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5631 * or where sizeof(long) != sizeof(char*). But such machines will
5632 * not likely have syscall implemented either, so who cares?
5634 while (++MARK <= SP) {
5635 if (SvNIOK(*MARK) || !i)
5636 a[i++] = SvIV(*MARK);
5637 else if (*MARK == &PL_sv_undef)
5640 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5646 DIE(aTHX_ "Too many args to syscall");
5648 DIE(aTHX_ "Too few args to syscall");
5650 retval = syscall(a[0]);
5653 retval = syscall(a[0],a[1]);
5656 retval = syscall(a[0],a[1],a[2]);
5659 retval = syscall(a[0],a[1],a[2],a[3]);
5662 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5665 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5668 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5671 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5678 DIE(aTHX_ PL_no_func, "syscall");
5682 #ifdef FCNTL_EMULATE_FLOCK
5684 /* XXX Emulate flock() with fcntl().
5685 What's really needed is a good file locking module.
5689 fcntl_emulate_flock(int fd, int operation)
5694 switch (operation & ~LOCK_NB) {
5696 flock.l_type = F_RDLCK;
5699 flock.l_type = F_WRLCK;
5702 flock.l_type = F_UNLCK;
5708 flock.l_whence = SEEK_SET;
5709 flock.l_start = flock.l_len = (Off_t)0;
5711 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5712 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5713 errno = EWOULDBLOCK;
5717 #endif /* FCNTL_EMULATE_FLOCK */
5719 #ifdef LOCKF_EMULATE_FLOCK
5721 /* XXX Emulate flock() with lockf(). This is just to increase
5722 portability of scripts. The calls are not completely
5723 interchangeable. What's really needed is a good file
5727 /* The lockf() constants might have been defined in <unistd.h>.
5728 Unfortunately, <unistd.h> causes troubles on some mixed
5729 (BSD/POSIX) systems, such as SunOS 4.1.3.
5731 Further, the lockf() constants aren't POSIX, so they might not be
5732 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5733 just stick in the SVID values and be done with it. Sigh.
5737 # define F_ULOCK 0 /* Unlock a previously locked region */
5740 # define F_LOCK 1 /* Lock a region for exclusive use */
5743 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5746 # define F_TEST 3 /* Test a region for other processes locks */
5750 lockf_emulate_flock(int fd, int operation)
5756 /* flock locks entire file so for lockf we need to do the same */
5757 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5758 if (pos > 0) /* is seekable and needs to be repositioned */
5759 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5760 pos = -1; /* seek failed, so don't seek back afterwards */
5763 switch (operation) {
5765 /* LOCK_SH - get a shared lock */
5767 /* LOCK_EX - get an exclusive lock */
5769 i = lockf (fd, F_LOCK, 0);
5772 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5773 case LOCK_SH|LOCK_NB:
5774 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5775 case LOCK_EX|LOCK_NB:
5776 i = lockf (fd, F_TLOCK, 0);
5778 if ((errno == EAGAIN) || (errno == EACCES))
5779 errno = EWOULDBLOCK;
5782 /* LOCK_UN - unlock (non-blocking is a no-op) */
5784 case LOCK_UN|LOCK_NB:
5785 i = lockf (fd, F_ULOCK, 0);
5788 /* Default - can't decipher operation */
5795 if (pos > 0) /* need to restore position of the handle */
5796 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5801 #endif /* LOCKF_EMULATE_FLOCK */
5804 * ex: set ts=8 sts=4 sw=4 et: