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) && defined(FD_CLOEXEC)
712 /* ensure close-on-exec */
713 if ((fd[0] > PL_maxsysfd && fcntl(fd[0], F_SETFD, FD_CLOEXEC) < 0) ||
714 (fd[1] > PL_maxsysfd && fcntl(fd[1], F_SETFD, FD_CLOEXEC) < 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 C<PL_defoutgv>, the default file handle for output, to the passed in
1269 typeglob. As C<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 C<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) && defined(FD_CLOEXEC)
2500 /* ensure close-on-exec */
2501 if (fd > PL_maxsysfd && fcntl(fd, F_SETFD, FD_CLOEXEC) < 0)
2511 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2514 const int protocol = POPi;
2515 const int type = POPi;
2516 const int domain = POPi;
2518 GV * const gv2 = MUTABLE_GV(POPs);
2519 IO * const io2 = GvIOn(gv2);
2520 GV * const gv1 = MUTABLE_GV(POPs);
2521 IO * const io1 = GvIOn(gv1);
2524 do_close(gv1, FALSE);
2526 do_close(gv2, FALSE);
2528 TAINT_PROPER("socketpair");
2529 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2531 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2532 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
2533 IoTYPE(io1) = IoTYPE_SOCKET;
2534 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2535 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
2536 IoTYPE(io2) = IoTYPE_SOCKET;
2537 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2538 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2539 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2540 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2541 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2542 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2543 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2546 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
2547 /* ensure close-on-exec */
2548 if ((fd[0] > PL_maxsysfd && fcntl(fd[0], F_SETFD, FD_CLOEXEC) < 0) ||
2549 (fd[1] > PL_maxsysfd && fcntl(fd[1], F_SETFD, FD_CLOEXEC) < 0))
2555 DIE(aTHX_ PL_no_sock_func, "socketpair");
2561 /* also used for: pp_connect() */
2566 SV * const addrsv = POPs;
2567 /* OK, so on what platform does bind modify addr? */
2569 GV * const gv = MUTABLE_GV(POPs);
2570 IO * const io = GvIOn(gv);
2577 fd = PerlIO_fileno(IoIFP(io));
2581 addr = SvPV_const(addrsv, len);
2582 op_type = PL_op->op_type;
2583 TAINT_PROPER(PL_op_desc[op_type]);
2584 if ((op_type == OP_BIND
2585 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2586 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2594 SETERRNO(EBADF,SS_IVCHAN);
2601 const int backlog = POPi;
2602 GV * const gv = MUTABLE_GV(POPs);
2603 IO * const io = GvIOn(gv);
2608 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2615 SETERRNO(EBADF,SS_IVCHAN);
2623 char namebuf[MAXPATHLEN];
2624 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2625 Sock_size_t len = sizeof (struct sockaddr_in);
2627 Sock_size_t len = sizeof namebuf;
2629 GV * const ggv = MUTABLE_GV(POPs);
2630 GV * const ngv = MUTABLE_GV(POPs);
2633 IO * const gstio = GvIO(ggv);
2634 if (!gstio || !IoIFP(gstio))
2638 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2641 /* Some platforms indicate zero length when an AF_UNIX client is
2642 * not bound. Simulate a non-zero-length sockaddr structure in
2644 namebuf[0] = 0; /* sun_len */
2645 namebuf[1] = AF_UNIX; /* sun_family */
2653 do_close(ngv, FALSE);
2654 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2655 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2656 IoTYPE(nstio) = IoTYPE_SOCKET;
2657 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2658 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2659 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2660 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2663 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
2664 /* ensure close-on-exec */
2665 if (fd > PL_maxsysfd && fcntl(fd, F_SETFD, FD_CLOEXEC) < 0)
2669 #ifdef __SCO_VERSION__
2670 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2673 PUSHp(namebuf, len);
2677 report_evil_fh(ggv);
2678 SETERRNO(EBADF,SS_IVCHAN);
2688 const int how = POPi;
2689 GV * const gv = MUTABLE_GV(POPs);
2690 IO * const io = GvIOn(gv);
2695 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2700 SETERRNO(EBADF,SS_IVCHAN);
2705 /* also used for: pp_gsockopt() */
2710 const int optype = PL_op->op_type;
2711 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2712 const unsigned int optname = (unsigned int) POPi;
2713 const unsigned int lvl = (unsigned int) POPi;
2714 GV * const gv = MUTABLE_GV(POPs);
2715 IO * const io = GvIOn(gv);
2722 fd = PerlIO_fileno(IoIFP(io));
2728 (void)SvPOK_only(sv);
2732 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2735 /* XXX Configure test: does getsockopt set the length properly? */
2744 #if defined(__SYMBIAN32__)
2745 # define SETSOCKOPT_OPTION_VALUE_T void *
2747 # define SETSOCKOPT_OPTION_VALUE_T const char *
2749 /* XXX TODO: We need to have a proper type (a Configure probe,
2750 * etc.) for what the C headers think of the third argument of
2751 * setsockopt(), the option_value read-only buffer: is it
2752 * a "char *", or a "void *", const or not. Some compilers
2753 * don't take kindly to e.g. assuming that "char *" implicitly
2754 * promotes to a "void *", or to explicitly promoting/demoting
2755 * consts to non/vice versa. The "const void *" is the SUS
2756 * definition, but that does not fly everywhere for the above
2758 SETSOCKOPT_OPTION_VALUE_T buf;
2762 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2766 aint = (int)SvIV(sv);
2767 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2770 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2780 SETERRNO(EBADF,SS_IVCHAN);
2787 /* also used for: pp_getsockname() */
2792 const int optype = PL_op->op_type;
2793 GV * const gv = MUTABLE_GV(POPs);
2794 IO * const io = GvIOn(gv);
2802 sv = sv_2mortal(newSV(257));
2803 (void)SvPOK_only(sv);
2807 fd = PerlIO_fileno(IoIFP(io));
2811 case OP_GETSOCKNAME:
2812 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2815 case OP_GETPEERNAME:
2816 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2818 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2820 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";
2821 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2822 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2823 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2824 sizeof(u_short) + sizeof(struct in_addr))) {
2831 #ifdef BOGUS_GETNAME_RETURN
2832 /* Interactive Unix, getpeername() and getsockname()
2833 does not return valid namelen */
2834 if (len == BOGUS_GETNAME_RETURN)
2835 len = sizeof(struct sockaddr);
2844 SETERRNO(EBADF,SS_IVCHAN);
2853 /* also used for: pp_lstat() */
2864 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2865 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2866 if (PL_op->op_type == OP_LSTAT) {
2867 if (gv != PL_defgv) {
2868 do_fstat_warning_check:
2869 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2870 "lstat() on filehandle%s%"SVf,
2873 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2875 } else if (PL_laststype != OP_LSTAT)
2876 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2877 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2880 if (gv != PL_defgv) {
2884 PL_laststype = OP_STAT;
2885 PL_statgv = gv ? gv : (GV *)io;
2886 sv_setpvs(PL_statname, "");
2892 int fd = PerlIO_fileno(IoIFP(io));
2894 PL_laststatval = -1;
2895 SETERRNO(EBADF,RMS_IFI);
2897 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2900 } else if (IoDIRP(io)) {
2902 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2905 PL_laststatval = -1;
2908 else PL_laststatval = -1;
2909 if (PL_laststatval < 0 && !havefp) report_evil_fh(gv);
2912 if (PL_laststatval < 0) {
2918 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2919 io = MUTABLE_IO(SvRV(sv));
2920 if (PL_op->op_type == OP_LSTAT)
2921 goto do_fstat_warning_check;
2922 goto do_fstat_have_io;
2925 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2926 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2928 PL_laststype = PL_op->op_type;
2929 file = SvPV_nolen_const(PL_statname);
2930 if (PL_op->op_type == OP_LSTAT)
2931 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2933 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2934 if (PL_laststatval < 0) {
2935 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2936 /* PL_warn_nl is constant */
2937 GCC_DIAG_IGNORE(-Wformat-nonliteral);
2938 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2946 if (gimme != G_ARRAY) {
2947 if (gimme != G_VOID)
2948 XPUSHs(boolSV(max));
2954 mPUSHi(PL_statcache.st_dev);
2955 #if ST_INO_SIZE > IVSIZE
2956 mPUSHn(PL_statcache.st_ino);
2958 # if ST_INO_SIGN <= 0
2959 mPUSHi(PL_statcache.st_ino);
2961 mPUSHu(PL_statcache.st_ino);
2964 mPUSHu(PL_statcache.st_mode);
2965 mPUSHu(PL_statcache.st_nlink);
2967 sv_setuid(PUSHmortal, PL_statcache.st_uid);
2968 sv_setgid(PUSHmortal, PL_statcache.st_gid);
2970 #ifdef USE_STAT_RDEV
2971 mPUSHi(PL_statcache.st_rdev);
2973 PUSHs(newSVpvs_flags("", SVs_TEMP));
2975 #if Off_t_size > IVSIZE
2976 mPUSHn(PL_statcache.st_size);
2978 mPUSHi(PL_statcache.st_size);
2981 mPUSHn(PL_statcache.st_atime);
2982 mPUSHn(PL_statcache.st_mtime);
2983 mPUSHn(PL_statcache.st_ctime);
2985 mPUSHi(PL_statcache.st_atime);
2986 mPUSHi(PL_statcache.st_mtime);
2987 mPUSHi(PL_statcache.st_ctime);
2989 #ifdef USE_STAT_BLOCKS
2990 mPUSHu(PL_statcache.st_blksize);
2991 mPUSHu(PL_statcache.st_blocks);
2993 PUSHs(newSVpvs_flags("", SVs_TEMP));
2994 PUSHs(newSVpvs_flags("", SVs_TEMP));
3000 /* All filetest ops avoid manipulating the perl stack pointer in their main
3001 bodies (since commit d2c4d2d1e22d3125), and return using either
3002 S_ft_return_false() or S_ft_return_true(). These two helper functions are
3003 the only two which manipulate the perl stack. To ensure that no stack
3004 manipulation macros are used, the filetest ops avoid defining a local copy
3005 of the stack pointer with dSP. */
3007 /* If the next filetest is stacked up with this one
3008 (PL_op->op_private & OPpFT_STACKING), we leave
3009 the original argument on the stack for success,
3010 and skip the stacked operators on failure.
3011 The next few macros/functions take care of this.
3015 S_ft_return_false(pTHX_ SV *ret) {
3019 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
3023 if (PL_op->op_private & OPpFT_STACKING) {
3024 while (OP_IS_FILETEST(next->op_type)
3025 && next->op_private & OPpFT_STACKED)
3026 next = next->op_next;
3031 PERL_STATIC_INLINE OP *
3032 S_ft_return_true(pTHX_ SV *ret) {
3034 if (PL_op->op_flags & OPf_REF)
3035 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
3036 else if (!(PL_op->op_private & OPpFT_STACKING))
3042 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
3043 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
3044 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
3046 #define tryAMAGICftest_MG(chr) STMT_START { \
3047 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
3048 && PL_op->op_flags & OPf_KIDS) { \
3049 OP *next = S_try_amagic_ftest(aTHX_ chr); \
3050 if (next) return next; \
3055 S_try_amagic_ftest(pTHX_ char chr) {
3056 SV *const arg = *PL_stack_sp;
3059 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
3063 const char tmpchr = chr;
3064 SV * const tmpsv = amagic_call(arg,
3065 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
3066 ftest_amg, AMGf_unary);
3071 return SvTRUE(tmpsv)
3072 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3078 /* also used for: pp_fteexec() pp_fteread() pp_ftewrite() pp_ftrexec()
3084 /* Not const, because things tweak this below. Not bool, because there's
3085 no guarantee that OPpFT_ACCESS is <= CHAR_MAX */
3086 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3087 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3088 /* Giving some sort of initial value silences compilers. */
3090 int access_mode = R_OK;
3092 int access_mode = 0;
3095 /* access_mode is never used, but leaving use_access in makes the
3096 conditional compiling below much clearer. */
3099 Mode_t stat_mode = S_IRUSR;
3101 bool effective = FALSE;
3104 switch (PL_op->op_type) {
3105 case OP_FTRREAD: opchar = 'R'; break;
3106 case OP_FTRWRITE: opchar = 'W'; break;
3107 case OP_FTREXEC: opchar = 'X'; break;
3108 case OP_FTEREAD: opchar = 'r'; break;
3109 case OP_FTEWRITE: opchar = 'w'; break;
3110 case OP_FTEEXEC: opchar = 'x'; break;
3112 tryAMAGICftest_MG(opchar);
3114 switch (PL_op->op_type) {
3116 #if !(defined(HAS_ACCESS) && defined(R_OK))
3122 #if defined(HAS_ACCESS) && defined(W_OK)
3127 stat_mode = S_IWUSR;
3131 #if defined(HAS_ACCESS) && defined(X_OK)
3136 stat_mode = S_IXUSR;
3140 #ifdef PERL_EFF_ACCESS
3143 stat_mode = S_IWUSR;
3147 #ifndef PERL_EFF_ACCESS
3154 #ifdef PERL_EFF_ACCESS
3159 stat_mode = S_IXUSR;
3165 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3166 const char *name = SvPV_nolen(*PL_stack_sp);
3168 # ifdef PERL_EFF_ACCESS
3169 result = PERL_EFF_ACCESS(name, access_mode);
3171 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3177 result = access(name, access_mode);
3179 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3190 result = my_stat_flags(0);
3193 if (cando(stat_mode, effective, &PL_statcache))
3199 /* also used for: pp_ftatime() pp_ftctime() pp_ftmtime() pp_ftsize() */
3204 const int op_type = PL_op->op_type;
3208 case OP_FTIS: opchar = 'e'; break;
3209 case OP_FTSIZE: opchar = 's'; break;
3210 case OP_FTMTIME: opchar = 'M'; break;
3211 case OP_FTCTIME: opchar = 'C'; break;
3212 case OP_FTATIME: opchar = 'A'; break;
3214 tryAMAGICftest_MG(opchar);
3216 result = my_stat_flags(0);
3219 if (op_type == OP_FTIS)
3222 /* You can't dTARGET inside OP_FTIS, because you'll get
3223 "panic: pad_sv po" - the op is not flagged to have a target. */
3227 #if Off_t_size > IVSIZE
3228 sv_setnv(TARG, (NV)PL_statcache.st_size);
3230 sv_setiv(TARG, (IV)PL_statcache.st_size);
3235 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3239 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3243 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3247 return SvTRUE_nomg(TARG)
3248 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3253 /* also used for: pp_ftblk() pp_ftchr() pp_ftdir() pp_fteowned()
3254 * pp_ftfile() pp_ftpipe() pp_ftsgid() pp_ftsock()
3255 * pp_ftsuid() pp_ftsvtx() pp_ftzero() */
3262 switch (PL_op->op_type) {
3263 case OP_FTROWNED: opchar = 'O'; break;
3264 case OP_FTEOWNED: opchar = 'o'; break;
3265 case OP_FTZERO: opchar = 'z'; break;
3266 case OP_FTSOCK: opchar = 'S'; break;
3267 case OP_FTCHR: opchar = 'c'; break;
3268 case OP_FTBLK: opchar = 'b'; break;
3269 case OP_FTFILE: opchar = 'f'; break;
3270 case OP_FTDIR: opchar = 'd'; break;
3271 case OP_FTPIPE: opchar = 'p'; break;
3272 case OP_FTSUID: opchar = 'u'; break;
3273 case OP_FTSGID: opchar = 'g'; break;
3274 case OP_FTSVTX: opchar = 'k'; break;
3276 tryAMAGICftest_MG(opchar);
3278 /* I believe that all these three are likely to be defined on most every
3279 system these days. */
3281 if(PL_op->op_type == OP_FTSUID) {
3286 if(PL_op->op_type == OP_FTSGID) {
3291 if(PL_op->op_type == OP_FTSVTX) {
3296 result = my_stat_flags(0);
3299 switch (PL_op->op_type) {
3301 if (PL_statcache.st_uid == PerlProc_getuid())
3305 if (PL_statcache.st_uid == PerlProc_geteuid())
3309 if (PL_statcache.st_size == 0)
3313 if (S_ISSOCK(PL_statcache.st_mode))
3317 if (S_ISCHR(PL_statcache.st_mode))
3321 if (S_ISBLK(PL_statcache.st_mode))
3325 if (S_ISREG(PL_statcache.st_mode))
3329 if (S_ISDIR(PL_statcache.st_mode))
3333 if (S_ISFIFO(PL_statcache.st_mode))
3338 if (PL_statcache.st_mode & S_ISUID)
3344 if (PL_statcache.st_mode & S_ISGID)
3350 if (PL_statcache.st_mode & S_ISVTX)
3362 tryAMAGICftest_MG('l');
3363 result = my_lstat_flags(0);
3367 if (S_ISLNK(PL_statcache.st_mode))
3380 tryAMAGICftest_MG('t');
3382 if (PL_op->op_flags & OPf_REF)
3385 SV *tmpsv = *PL_stack_sp;
3386 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3387 name = SvPV_nomg(tmpsv, namelen);
3388 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3392 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3393 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3394 else if (name && isDIGIT(*name) && grok_atoUV(name, &uv, NULL) && uv <= PERL_INT_MAX)
3399 SETERRNO(EBADF,RMS_IFI);
3402 if (PerlLIO_isatty(fd))
3408 /* also used for: pp_ftbinary() */
3422 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3424 if (PL_op->op_flags & OPf_REF)
3426 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3431 gv = MAYBE_DEREF_GV_nomg(sv);
3435 if (gv == PL_defgv) {
3437 io = SvTYPE(PL_statgv) == SVt_PVIO
3441 goto really_filename;
3446 sv_setpvs(PL_statname, "");
3447 io = GvIO(PL_statgv);
3449 PL_laststatval = -1;
3450 PL_laststype = OP_STAT;
3451 if (io && IoIFP(io)) {
3453 if (! PerlIO_has_base(IoIFP(io)))
3454 DIE(aTHX_ "-T and -B not implemented on filehandles");
3455 fd = PerlIO_fileno(IoIFP(io));
3457 SETERRNO(EBADF,RMS_IFI);
3460 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3461 if (PL_laststatval < 0)
3463 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3464 if (PL_op->op_type == OP_FTTEXT)
3469 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3470 i = PerlIO_getc(IoIFP(io));
3472 (void)PerlIO_ungetc(IoIFP(io),i);
3474 /* null file is anything */
3477 len = PerlIO_get_bufsiz(IoIFP(io));
3478 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3479 /* sfio can have large buffers - limit to 512 */
3484 SETERRNO(EBADF,RMS_IFI);
3486 SETERRNO(EBADF,RMS_IFI);
3495 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3497 file = SvPVX_const(PL_statname);
3499 if (!(fp = PerlIO_open(file, "r"))) {
3501 PL_laststatval = -1;
3502 PL_laststype = OP_STAT;
3504 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3505 /* PL_warn_nl is constant */
3506 GCC_DIAG_IGNORE(-Wformat-nonliteral);
3507 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3512 PL_laststype = OP_STAT;
3513 fd = PerlIO_fileno(fp);
3515 (void)PerlIO_close(fp);
3516 SETERRNO(EBADF,RMS_IFI);
3519 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3520 if (PL_laststatval < 0) {
3521 (void)PerlIO_close(fp);
3522 SETERRNO(EBADF,RMS_IFI);
3525 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3526 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3527 (void)PerlIO_close(fp);
3529 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3530 FT_RETURNNO; /* special case NFS directories */
3531 FT_RETURNYES; /* null file is anything */
3536 /* now scan s to look for textiness */
3538 #if defined(DOSISH) || defined(USEMYBINMODE)
3539 /* ignore trailing ^Z on short files */
3540 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3545 if (! is_invariant_string((U8 *) s, len)) {
3548 /* Here contains a variant under UTF-8 . See if the entire string is
3549 * UTF-8. But the buffer may end in a partial character, so consider
3550 * it UTF-8 if the first non-UTF8 char is an ending partial */
3551 if (is_utf8_string_loc((U8 *) s, len, &ep)
3552 || ep + UTF8SKIP(ep) > (U8 *) (s + len))
3554 if (PL_op->op_type == OP_FTTEXT) {
3563 /* Here, is not UTF-8 or is entirely ASCII. Look through the buffer for
3564 * things that wouldn't be in ASCII text or rich ASCII text. Count these
3566 for (i = 0; i < len; i++, s++) {
3567 if (!*s) { /* null never allowed in text */
3571 #ifdef USE_LOCALE_CTYPE
3572 if (IN_LC_RUNTIME(LC_CTYPE)) {
3573 if ( isPRINT_LC(*s) || isSPACE_LC(*s)) {
3580 /* VT occurs so rarely in text, that we consider it odd */
3581 || (isSPACE_A(*s) && *s != VT_NATIVE)
3583 /* But there is a fair amount of backspaces and escapes in
3586 || *s == ESC_NATIVE)
3593 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3604 const char *tmps = NULL;
3608 SV * const sv = POPs;
3609 if (PL_op->op_flags & OPf_SPECIAL) {
3610 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3612 if (ckWARN(WARN_UNOPENED)) {
3613 Perl_warner(aTHX_ packWARN(WARN_UNOPENED),
3614 "chdir() on unopened filehandle %" SVf, sv);
3616 SETERRNO(EBADF,RMS_IFI);
3618 TAINT_PROPER("chdir");
3622 else if (!(gv = MAYBE_DEREF_GV(sv)))
3623 tmps = SvPV_nomg_const_nolen(sv);
3626 HV * const table = GvHVn(PL_envgv);
3629 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3630 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3632 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3636 tmps = SvPV_nolen_const(*svp);
3640 SETERRNO(EINVAL, LIB_INVARG);
3641 TAINT_PROPER("chdir");
3646 TAINT_PROPER("chdir");
3649 IO* const io = GvIO(gv);
3652 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3653 } else if (IoIFP(io)) {
3654 int fd = PerlIO_fileno(IoIFP(io));
3658 PUSHi(fchdir(fd) >= 0);
3668 DIE(aTHX_ PL_no_func, "fchdir");
3672 PUSHi( PerlDir_chdir(tmps) >= 0 );
3674 /* Clear the DEFAULT element of ENV so we'll get the new value
3676 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3683 SETERRNO(EBADF,RMS_IFI);
3690 /* also used for: pp_chmod() pp_kill() pp_unlink() pp_utime() */
3694 dSP; dMARK; dTARGET;
3695 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3706 char * const tmps = POPpx;
3707 TAINT_PROPER("chroot");
3708 PUSHi( chroot(tmps) >= 0 );
3711 DIE(aTHX_ PL_no_func, "chroot");
3719 const char * const tmps2 = POPpconstx;
3720 const char * const tmps = SvPV_nolen_const(TOPs);
3721 TAINT_PROPER("rename");
3723 anum = PerlLIO_rename(tmps, tmps2);
3725 if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) {
3726 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3729 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode))
3730 (void)UNLINK(tmps2);
3731 if (!(anum = link(tmps, tmps2)))
3732 anum = UNLINK(tmps);
3741 /* also used for: pp_symlink() */
3743 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3747 const int op_type = PL_op->op_type;
3751 if (op_type == OP_LINK)
3752 DIE(aTHX_ PL_no_func, "link");
3754 # ifndef HAS_SYMLINK
3755 if (op_type == OP_SYMLINK)
3756 DIE(aTHX_ PL_no_func, "symlink");
3760 const char * const tmps2 = POPpconstx;
3761 const char * const tmps = SvPV_nolen_const(TOPs);
3762 TAINT_PROPER(PL_op_desc[op_type]);
3764 # if defined(HAS_LINK)
3765 # if defined(HAS_SYMLINK)
3766 /* Both present - need to choose which. */
3767 (op_type == OP_LINK) ?
3768 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3770 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3771 PerlLIO_link(tmps, tmps2);
3774 # if defined(HAS_SYMLINK)
3775 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3776 symlink(tmps, tmps2);
3781 SETi( result >= 0 );
3786 /* also used for: pp_symlink() */
3791 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3801 char buf[MAXPATHLEN];
3806 /* NOTE: if the length returned by readlink() is sizeof(buf) - 1,
3807 * it is impossible to know whether the result was truncated. */
3808 len = readlink(tmps, buf, sizeof(buf) - 1);
3817 RETSETUNDEF; /* just pretend it's a normal file */
3821 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3823 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3825 char * const save_filename = filename;
3830 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3832 PERL_ARGS_ASSERT_DOONELINER;
3834 Newx(cmdline, size, char);
3835 my_strlcpy(cmdline, cmd, size);
3836 my_strlcat(cmdline, " ", size);
3837 for (s = cmdline + strlen(cmdline); *filename; ) {
3841 if (s - cmdline < size)
3842 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3843 myfp = PerlProc_popen(cmdline, "r");
3847 SV * const tmpsv = sv_newmortal();
3848 /* Need to save/restore 'PL_rs' ?? */
3849 s = sv_gets(tmpsv, myfp, 0);
3850 (void)PerlProc_pclose(myfp);
3854 #ifdef HAS_SYS_ERRLIST
3859 /* you don't see this */
3860 const char * const errmsg = Strerror(e) ;
3863 if (instr(s, errmsg)) {
3870 #define EACCES EPERM
3872 if (instr(s, "cannot make"))
3873 SETERRNO(EEXIST,RMS_FEX);
3874 else if (instr(s, "existing file"))
3875 SETERRNO(EEXIST,RMS_FEX);
3876 else if (instr(s, "ile exists"))
3877 SETERRNO(EEXIST,RMS_FEX);
3878 else if (instr(s, "non-exist"))
3879 SETERRNO(ENOENT,RMS_FNF);
3880 else if (instr(s, "does not exist"))
3881 SETERRNO(ENOENT,RMS_FNF);
3882 else if (instr(s, "not empty"))
3883 SETERRNO(EBUSY,SS_DEVOFFLINE);
3884 else if (instr(s, "cannot access"))
3885 SETERRNO(EACCES,RMS_PRV);
3887 SETERRNO(EPERM,RMS_PRV);
3890 else { /* some mkdirs return no failure indication */
3891 anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0);
3892 if (PL_op->op_type == OP_RMDIR)
3897 SETERRNO(EACCES,RMS_PRV); /* a guess */
3906 /* This macro removes trailing slashes from a directory name.
3907 * Different operating and file systems take differently to
3908 * trailing slashes. According to POSIX 1003.1 1996 Edition
3909 * any number of trailing slashes should be allowed.
3910 * Thusly we snip them away so that even non-conforming
3911 * systems are happy.
3912 * We should probably do this "filtering" for all
3913 * the functions that expect (potentially) directory names:
3914 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3915 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3917 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3918 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3921 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3922 (tmps) = savepvn((tmps), (len)); \
3932 const unsigned int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPu : 0777;
3934 TRIMSLASHES(tmps,len,copy);
3936 TAINT_PROPER("mkdir");
3938 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3942 SETi( dooneliner("mkdir", tmps) );
3943 oldumask = PerlLIO_umask(0);
3944 PerlLIO_umask(oldumask);
3945 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3960 TRIMSLASHES(tmps,len,copy);
3961 TAINT_PROPER("rmdir");
3963 SETi( PerlDir_rmdir(tmps) >= 0 );
3965 SETi( dooneliner("rmdir", tmps) );
3972 /* Directory calls. */
3976 #if defined(Direntry_t) && defined(HAS_READDIR)
3978 const char * const dirname = POPpconstx;
3979 GV * const gv = MUTABLE_GV(POPs);
3980 IO * const io = GvIOn(gv);
3982 if ((IoIFP(io) || IoOFP(io)))
3983 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
3984 "Opening filehandle %"HEKf" also as a directory",
3985 HEKfARG(GvENAME_HEK(gv)) );
3987 PerlDir_close(IoDIRP(io));
3988 if (!(IoDIRP(io) = PerlDir_open(dirname)))
3994 SETERRNO(EBADF,RMS_DIR);
3997 DIE(aTHX_ PL_no_dir_func, "opendir");
4003 #if !defined(Direntry_t) || !defined(HAS_READDIR)
4004 DIE(aTHX_ PL_no_dir_func, "readdir");
4006 #if !defined(I_DIRENT) && !defined(VMS)
4007 Direntry_t *readdir (DIR *);
4012 const I32 gimme = GIMME_V;
4013 GV * const gv = MUTABLE_GV(POPs);
4014 const Direntry_t *dp;
4015 IO * const io = GvIOn(gv);
4018 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4019 "readdir() attempted on invalid dirhandle %"HEKf,
4020 HEKfARG(GvENAME_HEK(gv)));
4025 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
4029 sv = newSVpvn(dp->d_name, dp->d_namlen);
4031 sv = newSVpv(dp->d_name, 0);
4033 if (!(IoFLAGS(io) & IOf_UNTAINT))
4036 } while (gimme == G_ARRAY);
4038 if (!dp && gimme != G_ARRAY)
4045 SETERRNO(EBADF,RMS_ISI);
4046 if (gimme == G_ARRAY)
4055 #if defined(HAS_TELLDIR) || defined(telldir)
4057 /* XXX does _anyone_ need this? --AD 2/20/1998 */
4058 /* XXX netbsd still seemed to.
4059 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
4060 --JHI 1999-Feb-02 */
4061 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
4062 long telldir (DIR *);
4064 GV * const gv = MUTABLE_GV(POPs);
4065 IO * const io = GvIOn(gv);
4068 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4069 "telldir() attempted on invalid dirhandle %"HEKf,
4070 HEKfARG(GvENAME_HEK(gv)));
4074 PUSHi( PerlDir_tell(IoDIRP(io)) );
4078 SETERRNO(EBADF,RMS_ISI);
4081 DIE(aTHX_ PL_no_dir_func, "telldir");
4087 #if defined(HAS_SEEKDIR) || defined(seekdir)
4089 const long along = POPl;
4090 GV * const gv = MUTABLE_GV(POPs);
4091 IO * const io = GvIOn(gv);
4094 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4095 "seekdir() attempted on invalid dirhandle %"HEKf,
4096 HEKfARG(GvENAME_HEK(gv)));
4099 (void)PerlDir_seek(IoDIRP(io), along);
4104 SETERRNO(EBADF,RMS_ISI);
4107 DIE(aTHX_ PL_no_dir_func, "seekdir");
4113 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4115 GV * const gv = MUTABLE_GV(POPs);
4116 IO * const io = GvIOn(gv);
4119 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4120 "rewinddir() attempted on invalid dirhandle %"HEKf,
4121 HEKfARG(GvENAME_HEK(gv)));
4124 (void)PerlDir_rewind(IoDIRP(io));
4128 SETERRNO(EBADF,RMS_ISI);
4131 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4137 #if defined(Direntry_t) && defined(HAS_READDIR)
4139 GV * const gv = MUTABLE_GV(POPs);
4140 IO * const io = GvIOn(gv);
4143 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4144 "closedir() attempted on invalid dirhandle %"HEKf,
4145 HEKfARG(GvENAME_HEK(gv)));
4148 #ifdef VOID_CLOSEDIR
4149 PerlDir_close(IoDIRP(io));
4151 if (PerlDir_close(IoDIRP(io)) < 0) {
4152 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4161 SETERRNO(EBADF,RMS_IFI);
4164 DIE(aTHX_ PL_no_dir_func, "closedir");
4168 /* Process control. */
4175 #ifdef HAS_SIGPROCMASK
4176 sigset_t oldmask, newmask;
4180 PERL_FLUSHALL_FOR_CHILD;
4181 #ifdef HAS_SIGPROCMASK
4182 sigfillset(&newmask);
4183 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4185 childpid = PerlProc_fork();
4186 if (childpid == 0) {
4190 for (sig = 1; sig < SIG_SIZE; sig++)
4191 PL_psig_pend[sig] = 0;
4193 #ifdef HAS_SIGPROCMASK
4196 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4203 #ifdef PERL_USES_PL_PIDSTATUS
4204 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4210 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4215 PERL_FLUSHALL_FOR_CHILD;
4216 childpid = PerlProc_fork();
4222 DIE(aTHX_ PL_no_func, "fork");
4229 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4234 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4235 childpid = wait4pid(-1, &argflags, 0);
4237 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4242 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4243 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4244 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4246 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4251 DIE(aTHX_ PL_no_func, "wait");
4257 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4259 const int optype = POPi;
4260 const Pid_t pid = TOPi;
4264 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4265 result = wait4pid(pid, &argflags, optype);
4267 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4272 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4273 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4274 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4276 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4281 DIE(aTHX_ PL_no_func, "waitpid");
4287 dSP; dMARK; dORIGMARK; dTARGET;
4288 #if defined(__LIBCATAMOUNT__)
4289 PL_statusvalue = -1;
4298 while (++MARK <= SP) {
4299 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4304 TAINT_PROPER("system");
4306 PERL_FLUSHALL_FOR_CHILD;
4307 #if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4312 #ifdef HAS_SIGPROCMASK
4313 sigset_t newset, oldset;
4316 if (PerlProc_pipe(pp) >= 0)
4318 #ifdef HAS_SIGPROCMASK
4319 sigemptyset(&newset);
4320 sigaddset(&newset, SIGCHLD);
4321 sigprocmask(SIG_BLOCK, &newset, &oldset);
4323 while ((childpid = PerlProc_fork()) == -1) {
4324 if (errno != EAGAIN) {
4329 PerlLIO_close(pp[0]);
4330 PerlLIO_close(pp[1]);
4332 #ifdef HAS_SIGPROCMASK
4333 sigprocmask(SIG_SETMASK, &oldset, NULL);
4340 Sigsave_t ihand,qhand; /* place to save signals during system() */
4344 PerlLIO_close(pp[1]);
4346 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4347 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4350 result = wait4pid(childpid, &status, 0);
4351 } while (result == -1 && errno == EINTR);
4353 #ifdef HAS_SIGPROCMASK
4354 sigprocmask(SIG_SETMASK, &oldset, NULL);
4356 (void)rsignal_restore(SIGINT, &ihand);
4357 (void)rsignal_restore(SIGQUIT, &qhand);
4359 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4360 do_execfree(); /* free any memory child malloced on fork */
4367 while (n < sizeof(int)) {
4368 n1 = PerlLIO_read(pp[0],
4369 (void*)(((char*)&errkid)+n),
4375 PerlLIO_close(pp[0]);
4376 if (n) { /* Error */
4377 if (n != sizeof(int))
4378 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4379 errno = errkid; /* Propagate errno from kid */
4380 STATUS_NATIVE_CHILD_SET(-1);
4383 XPUSHi(STATUS_CURRENT);
4386 #ifdef HAS_SIGPROCMASK
4387 sigprocmask(SIG_SETMASK, &oldset, NULL);
4390 PerlLIO_close(pp[0]);
4391 #if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
4392 if (fcntl(pp[1], F_SETFD, FD_CLOEXEC) < 0)
4396 if (PL_op->op_flags & OPf_STACKED) {
4397 SV * const really = *++MARK;
4398 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4400 else if (SP - MARK != 1)
4401 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4403 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4407 #else /* ! FORK or VMS or OS/2 */
4410 if (PL_op->op_flags & OPf_STACKED) {
4411 SV * const really = *++MARK;
4412 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4413 value = (I32)do_aspawn(really, MARK, SP);
4415 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4418 else if (SP - MARK != 1) {
4419 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4420 value = (I32)do_aspawn(NULL, MARK, SP);
4422 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4426 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4428 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4430 STATUS_NATIVE_CHILD_SET(value);
4433 XPUSHi(result ? value : STATUS_CURRENT);
4434 #endif /* !FORK or VMS or OS/2 */
4441 dSP; dMARK; dORIGMARK; dTARGET;
4446 while (++MARK <= SP) {
4447 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4452 TAINT_PROPER("exec");
4454 PERL_FLUSHALL_FOR_CHILD;
4455 if (PL_op->op_flags & OPf_STACKED) {
4456 SV * const really = *++MARK;
4457 value = (I32)do_aexec(really, MARK, SP);
4459 else if (SP - MARK != 1)
4461 value = (I32)vms_do_aexec(NULL, MARK, SP);
4463 value = (I32)do_aexec(NULL, MARK, SP);
4467 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4469 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4482 XPUSHi( getppid() );
4485 DIE(aTHX_ PL_no_func, "getppid");
4495 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4498 pgrp = (I32)BSD_GETPGRP(pid);
4500 if (pid != 0 && pid != PerlProc_getpid())
4501 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4507 DIE(aTHX_ PL_no_func, "getpgrp");
4517 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4518 if (MAXARG > 0) pid = TOPs ? TOPi : 0;
4525 TAINT_PROPER("setpgrp");
4527 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4529 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4530 || (pid != 0 && pid != PerlProc_getpid()))
4532 DIE(aTHX_ "setpgrp can't take arguments");
4534 SETi( setpgrp() >= 0 );
4535 #endif /* USE_BSDPGRP */
4538 DIE(aTHX_ PL_no_func, "setpgrp");
4542 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4543 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4545 # define PRIORITY_WHICH_T(which) which
4550 #ifdef HAS_GETPRIORITY
4552 const int who = POPi;
4553 const int which = TOPi;
4554 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4557 DIE(aTHX_ PL_no_func, "getpriority");
4563 #ifdef HAS_SETPRIORITY
4565 const int niceval = POPi;
4566 const int who = POPi;
4567 const int which = TOPi;
4568 TAINT_PROPER("setpriority");
4569 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4572 DIE(aTHX_ PL_no_func, "setpriority");
4576 #undef PRIORITY_WHICH_T
4584 XPUSHn( time(NULL) );
4586 XPUSHi( time(NULL) );
4595 struct tms timesbuf;
4598 (void)PerlProc_times(×buf);
4600 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4601 if (GIMME_V == G_ARRAY) {
4602 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4603 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4604 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4612 if (GIMME_V == G_ARRAY) {
4619 DIE(aTHX_ "times not implemented");
4621 #endif /* HAS_TIMES */
4624 /* The 32 bit int year limits the times we can represent to these
4625 boundaries with a few days wiggle room to account for time zone
4628 /* Sat Jan 3 00:00:00 -2147481748 */
4629 #define TIME_LOWER_BOUND -67768100567755200.0
4630 /* Sun Dec 29 12:00:00 2147483647 */
4631 #define TIME_UPPER_BOUND 67767976233316800.0
4634 /* also used for: pp_localtime() */
4642 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4643 static const char * const dayname[] =
4644 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4645 static const char * const monname[] =
4646 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4647 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4649 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4652 when = (Time64_T)now;
4655 NV input = Perl_floor(POPn);
4656 const bool pl_isnan = Perl_isnan(input);
4657 when = (Time64_T)input;
4658 if (UNLIKELY(pl_isnan || when != input)) {
4659 /* diag_listed_as: gmtime(%f) too large */
4660 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4661 "%s(%.0" NVff ") too large", opname, input);
4669 if ( TIME_LOWER_BOUND > when ) {
4670 /* diag_listed_as: gmtime(%f) too small */
4671 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4672 "%s(%.0" NVff ") too small", opname, when);
4675 else if( when > TIME_UPPER_BOUND ) {
4676 /* diag_listed_as: gmtime(%f) too small */
4677 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4678 "%s(%.0" NVff ") too large", opname, when);
4682 if (PL_op->op_type == OP_LOCALTIME)
4683 err = Perl_localtime64_r(&when, &tmbuf);
4685 err = Perl_gmtime64_r(&when, &tmbuf);
4689 /* diag_listed_as: gmtime(%f) failed */
4690 /* XXX %lld broken for quads */
4692 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4693 "%s(%.0" NVff ") failed", opname, when);
4696 if (GIMME_V != G_ARRAY) { /* scalar context */
4703 Perl_sv_setpvf_mg(aTHX_ TARG, "%s %s %2d %02d:%02d:%02d %"IVdf,
4704 dayname[tmbuf.tm_wday],
4705 monname[tmbuf.tm_mon],
4710 (IV)tmbuf.tm_year + 1900);
4713 else { /* list context */
4719 mPUSHi(tmbuf.tm_sec);
4720 mPUSHi(tmbuf.tm_min);
4721 mPUSHi(tmbuf.tm_hour);
4722 mPUSHi(tmbuf.tm_mday);
4723 mPUSHi(tmbuf.tm_mon);
4724 mPUSHn(tmbuf.tm_year);
4725 mPUSHi(tmbuf.tm_wday);
4726 mPUSHi(tmbuf.tm_yday);
4727 mPUSHi(tmbuf.tm_isdst);
4736 /* alarm() takes an unsigned int number of seconds, and return the
4737 * unsigned int number of seconds remaining in the previous alarm
4738 * (alarms don't stack). Therefore negative return values are not
4742 /* Note that while the C library function alarm() as such has
4743 * no errors defined (or in other words, properly behaving client
4744 * code shouldn't expect any), alarm() being obsoleted by
4745 * setitimer() and often being implemented in terms of
4746 * setitimer(), can fail. */
4747 /* diag_listed_as: %s() with negative argument */
4748 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4749 "alarm() with negative argument");
4750 SETERRNO(EINVAL, LIB_INVARG);
4754 unsigned int retval = alarm(anum);
4755 if ((int)retval < 0) /* Strictly speaking "cannot happen". */
4761 DIE(aTHX_ PL_no_func, "alarm");
4772 (void)time(&lasttime);
4773 if (MAXARG < 1 || (!TOPs && !POPs))
4778 /* diag_listed_as: %s() with negative argument */
4779 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4780 "sleep() with negative argument");
4781 SETERRNO(EINVAL, LIB_INVARG);
4785 PerlProc_sleep((unsigned int)duration);
4789 XPUSHi(when - lasttime);
4793 /* Shared memory. */
4794 /* Merged with some message passing. */
4796 /* also used for: pp_msgrcv() pp_msgsnd() pp_semop() pp_shmread() */
4800 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4801 dSP; dMARK; dTARGET;
4802 const int op_type = PL_op->op_type;
4807 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4810 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4813 value = (I32)(do_semop(MARK, SP) >= 0);
4816 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4824 return Perl_pp_semget(aTHX);
4830 /* also used for: pp_msgget() pp_shmget() */
4834 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4835 dSP; dMARK; dTARGET;
4836 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4843 DIE(aTHX_ "System V IPC is not implemented on this machine");
4847 /* also used for: pp_msgctl() pp_shmctl() */
4851 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4852 dSP; dMARK; dTARGET;
4853 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4861 PUSHp(zero_but_true, ZBTLEN);
4865 return Perl_pp_semget(aTHX);
4869 /* I can't const this further without getting warnings about the types of
4870 various arrays passed in from structures. */
4872 S_space_join_names_mortal(pTHX_ char *const *array)
4876 PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL;
4879 target = newSVpvs_flags("", SVs_TEMP);
4881 sv_catpv(target, *array);
4884 sv_catpvs(target, " ");
4887 target = sv_mortalcopy(&PL_sv_no);
4892 /* Get system info. */
4894 /* also used for: pp_ghbyaddr() pp_ghbyname() */
4898 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4900 I32 which = PL_op->op_type;
4903 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4904 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4905 struct hostent *gethostbyname(Netdb_name_t);
4906 struct hostent *gethostent(void);
4908 struct hostent *hent = NULL;
4912 if (which == OP_GHBYNAME) {
4913 #ifdef HAS_GETHOSTBYNAME
4914 const char* const name = POPpbytex;
4915 hent = PerlSock_gethostbyname(name);
4917 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
4920 else if (which == OP_GHBYADDR) {
4921 #ifdef HAS_GETHOSTBYADDR
4922 const int addrtype = POPi;
4923 SV * const addrsv = POPs;
4925 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
4927 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
4929 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
4933 #ifdef HAS_GETHOSTENT
4934 hent = PerlSock_gethostent();
4936 DIE(aTHX_ PL_no_sock_func, "gethostent");
4939 #ifdef HOST_NOT_FOUND
4941 #ifdef USE_REENTRANT_API
4942 # ifdef USE_GETHOSTENT_ERRNO
4943 h_errno = PL_reentrant_buffer->_gethostent_errno;
4946 STATUS_UNIX_SET(h_errno);
4950 if (GIMME_V != G_ARRAY) {
4951 PUSHs(sv = sv_newmortal());
4953 if (which == OP_GHBYNAME) {
4955 sv_setpvn(sv, hent->h_addr, hent->h_length);
4958 sv_setpv(sv, (char*)hent->h_name);
4964 mPUSHs(newSVpv((char*)hent->h_name, 0));
4965 PUSHs(space_join_names_mortal(hent->h_aliases));
4966 mPUSHi(hent->h_addrtype);
4967 len = hent->h_length;
4970 for (elem = hent->h_addr_list; elem && *elem; elem++) {
4971 mXPUSHp(*elem, len);
4975 mPUSHp(hent->h_addr, len);
4977 PUSHs(sv_mortalcopy(&PL_sv_no));
4982 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4986 /* also used for: pp_gnbyaddr() pp_gnbyname() */
4990 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
4992 I32 which = PL_op->op_type;
4994 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
4995 struct netent *getnetbyaddr(Netdb_net_t, int);
4996 struct netent *getnetbyname(Netdb_name_t);
4997 struct netent *getnetent(void);
4999 struct netent *nent;
5001 if (which == OP_GNBYNAME){
5002 #ifdef HAS_GETNETBYNAME
5003 const char * const name = POPpbytex;
5004 nent = PerlSock_getnetbyname(name);
5006 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
5009 else if (which == OP_GNBYADDR) {
5010 #ifdef HAS_GETNETBYADDR
5011 const int addrtype = POPi;
5012 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
5013 nent = PerlSock_getnetbyaddr(addr, addrtype);
5015 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
5019 #ifdef HAS_GETNETENT
5020 nent = PerlSock_getnetent();
5022 DIE(aTHX_ PL_no_sock_func, "getnetent");
5025 #ifdef HOST_NOT_FOUND
5027 #ifdef USE_REENTRANT_API
5028 # ifdef USE_GETNETENT_ERRNO
5029 h_errno = PL_reentrant_buffer->_getnetent_errno;
5032 STATUS_UNIX_SET(h_errno);
5037 if (GIMME_V != G_ARRAY) {
5038 PUSHs(sv = sv_newmortal());
5040 if (which == OP_GNBYNAME)
5041 sv_setiv(sv, (IV)nent->n_net);
5043 sv_setpv(sv, nent->n_name);
5049 mPUSHs(newSVpv(nent->n_name, 0));
5050 PUSHs(space_join_names_mortal(nent->n_aliases));
5051 mPUSHi(nent->n_addrtype);
5052 mPUSHi(nent->n_net);
5057 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5062 /* also used for: pp_gpbyname() pp_gpbynumber() */
5066 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
5068 I32 which = PL_op->op_type;
5070 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
5071 struct protoent *getprotobyname(Netdb_name_t);
5072 struct protoent *getprotobynumber(int);
5073 struct protoent *getprotoent(void);
5075 struct protoent *pent;
5077 if (which == OP_GPBYNAME) {
5078 #ifdef HAS_GETPROTOBYNAME
5079 const char* const name = POPpbytex;
5080 pent = PerlSock_getprotobyname(name);
5082 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
5085 else if (which == OP_GPBYNUMBER) {
5086 #ifdef HAS_GETPROTOBYNUMBER
5087 const int number = POPi;
5088 pent = PerlSock_getprotobynumber(number);
5090 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
5094 #ifdef HAS_GETPROTOENT
5095 pent = PerlSock_getprotoent();
5097 DIE(aTHX_ PL_no_sock_func, "getprotoent");
5101 if (GIMME_V != G_ARRAY) {
5102 PUSHs(sv = sv_newmortal());
5104 if (which == OP_GPBYNAME)
5105 sv_setiv(sv, (IV)pent->p_proto);
5107 sv_setpv(sv, pent->p_name);
5113 mPUSHs(newSVpv(pent->p_name, 0));
5114 PUSHs(space_join_names_mortal(pent->p_aliases));
5115 mPUSHi(pent->p_proto);
5120 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5125 /* also used for: pp_gsbyname() pp_gsbyport() */
5129 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
5131 I32 which = PL_op->op_type;
5133 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
5134 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
5135 struct servent *getservbyport(int, Netdb_name_t);
5136 struct servent *getservent(void);
5138 struct servent *sent;
5140 if (which == OP_GSBYNAME) {
5141 #ifdef HAS_GETSERVBYNAME
5142 const char * const proto = POPpbytex;
5143 const char * const name = POPpbytex;
5144 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
5146 DIE(aTHX_ PL_no_sock_func, "getservbyname");
5149 else if (which == OP_GSBYPORT) {
5150 #ifdef HAS_GETSERVBYPORT
5151 const char * const proto = POPpbytex;
5152 unsigned short port = (unsigned short)POPu;
5153 port = PerlSock_htons(port);
5154 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
5156 DIE(aTHX_ PL_no_sock_func, "getservbyport");
5160 #ifdef HAS_GETSERVENT
5161 sent = PerlSock_getservent();
5163 DIE(aTHX_ PL_no_sock_func, "getservent");
5167 if (GIMME_V != G_ARRAY) {
5168 PUSHs(sv = sv_newmortal());
5170 if (which == OP_GSBYNAME) {
5171 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5174 sv_setpv(sv, sent->s_name);
5180 mPUSHs(newSVpv(sent->s_name, 0));
5181 PUSHs(space_join_names_mortal(sent->s_aliases));
5182 mPUSHi(PerlSock_ntohs(sent->s_port));
5183 mPUSHs(newSVpv(sent->s_proto, 0));
5188 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5193 /* also used for: pp_snetent() pp_sprotoent() pp_sservent() */
5198 const int stayopen = TOPi;
5199 switch(PL_op->op_type) {
5201 #ifdef HAS_SETHOSTENT
5202 PerlSock_sethostent(stayopen);
5204 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5207 #ifdef HAS_SETNETENT
5209 PerlSock_setnetent(stayopen);
5211 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5215 #ifdef HAS_SETPROTOENT
5216 PerlSock_setprotoent(stayopen);
5218 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5222 #ifdef HAS_SETSERVENT
5223 PerlSock_setservent(stayopen);
5225 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5233 /* also used for: pp_egrent() pp_enetent() pp_eprotoent() pp_epwent()
5234 * pp_eservent() pp_sgrent() pp_spwent() */
5239 switch(PL_op->op_type) {
5241 #ifdef HAS_ENDHOSTENT
5242 PerlSock_endhostent();
5244 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5248 #ifdef HAS_ENDNETENT
5249 PerlSock_endnetent();
5251 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5255 #ifdef HAS_ENDPROTOENT
5256 PerlSock_endprotoent();
5258 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5262 #ifdef HAS_ENDSERVENT
5263 PerlSock_endservent();
5265 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5269 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5272 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5276 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5279 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5283 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5286 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5290 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5293 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5302 /* also used for: pp_gpwnam() pp_gpwuid() */
5308 I32 which = PL_op->op_type;
5310 struct passwd *pwent = NULL;
5312 * We currently support only the SysV getsp* shadow password interface.
5313 * The interface is declared in <shadow.h> and often one needs to link
5314 * with -lsecurity or some such.
5315 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5318 * AIX getpwnam() is clever enough to return the encrypted password
5319 * only if the caller (euid?) is root.
5321 * There are at least three other shadow password APIs. Many platforms
5322 * seem to contain more than one interface for accessing the shadow
5323 * password databases, possibly for compatibility reasons.
5324 * The getsp*() is by far he simplest one, the other two interfaces
5325 * are much more complicated, but also very similar to each other.
5330 * struct pr_passwd *getprpw*();
5331 * The password is in
5332 * char getprpw*(...).ufld.fd_encrypt[]
5333 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5338 * struct es_passwd *getespw*();
5339 * The password is in
5340 * char *(getespw*(...).ufld.fd_encrypt)
5341 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5344 * struct userpw *getuserpw();
5345 * The password is in
5346 * char *(getuserpw(...)).spw_upw_passwd
5347 * (but the de facto standard getpwnam() should work okay)
5349 * Mention I_PROT here so that Configure probes for it.
5351 * In HP-UX for getprpw*() the manual page claims that one should include
5352 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5353 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5354 * and pp_sys.c already includes <shadow.h> if there is such.
5356 * Note that <sys/security.h> is already probed for, but currently
5357 * it is only included in special cases.
5359 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5360 * be preferred interface, even though also the getprpw*() interface
5361 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5362 * One also needs to call set_auth_parameters() in main() before
5363 * doing anything else, whether one is using getespw*() or getprpw*().
5365 * Note that accessing the shadow databases can be magnitudes
5366 * slower than accessing the standard databases.
5371 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5372 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5373 * the pw_comment is left uninitialized. */
5374 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5380 const char* const name = POPpbytex;
5381 pwent = getpwnam(name);
5387 pwent = getpwuid(uid);
5391 # ifdef HAS_GETPWENT
5393 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5394 if (pwent) pwent = getpwnam(pwent->pw_name);
5397 DIE(aTHX_ PL_no_func, "getpwent");
5403 if (GIMME_V != G_ARRAY) {
5404 PUSHs(sv = sv_newmortal());
5406 if (which == OP_GPWNAM)
5407 sv_setuid(sv, pwent->pw_uid);
5409 sv_setpv(sv, pwent->pw_name);
5415 mPUSHs(newSVpv(pwent->pw_name, 0));
5419 /* If we have getspnam(), we try to dig up the shadow
5420 * password. If we are underprivileged, the shadow
5421 * interface will set the errno to EACCES or similar,
5422 * and return a null pointer. If this happens, we will
5423 * use the dummy password (usually "*" or "x") from the
5424 * standard password database.
5426 * In theory we could skip the shadow call completely
5427 * if euid != 0 but in practice we cannot know which
5428 * security measures are guarding the shadow databases
5429 * on a random platform.
5431 * Resist the urge to use additional shadow interfaces.
5432 * Divert the urge to writing an extension instead.
5435 /* Some AIX setups falsely(?) detect some getspnam(), which
5436 * has a different API than the Solaris/IRIX one. */
5437 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5440 const struct spwd * const spwent = getspnam(pwent->pw_name);
5441 /* Save and restore errno so that
5442 * underprivileged attempts seem
5443 * to have never made the unsuccessful
5444 * attempt to retrieve the shadow password. */
5446 if (spwent && spwent->sp_pwdp)
5447 sv_setpv(sv, spwent->sp_pwdp);
5451 if (!SvPOK(sv)) /* Use the standard password, then. */
5452 sv_setpv(sv, pwent->pw_passwd);
5455 /* passwd is tainted because user himself can diddle with it.
5456 * admittedly not much and in a very limited way, but nevertheless. */
5459 sv_setuid(PUSHmortal, pwent->pw_uid);
5460 sv_setgid(PUSHmortal, pwent->pw_gid);
5462 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5463 * because of the poor interface of the Perl getpw*(),
5464 * not because there's some standard/convention saying so.
5465 * A better interface would have been to return a hash,
5466 * but we are accursed by our history, alas. --jhi. */
5468 mPUSHi(pwent->pw_change);
5471 mPUSHi(pwent->pw_quota);
5474 mPUSHs(newSVpv(pwent->pw_age, 0));
5476 /* I think that you can never get this compiled, but just in case. */
5477 PUSHs(sv_mortalcopy(&PL_sv_no));
5482 /* pw_class and pw_comment are mutually exclusive--.
5483 * see the above note for pw_change, pw_quota, and pw_age. */
5485 mPUSHs(newSVpv(pwent->pw_class, 0));
5488 mPUSHs(newSVpv(pwent->pw_comment, 0));
5490 /* I think that you can never get this compiled, but just in case. */
5491 PUSHs(sv_mortalcopy(&PL_sv_no));
5496 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5498 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5500 /* pw_gecos is tainted because user himself can diddle with it. */
5503 mPUSHs(newSVpv(pwent->pw_dir, 0));
5505 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5506 /* pw_shell is tainted because user himself can diddle with it. */
5510 mPUSHi(pwent->pw_expire);
5515 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5520 /* also used for: pp_ggrgid() pp_ggrnam() */
5526 const I32 which = PL_op->op_type;
5527 const struct group *grent;
5529 if (which == OP_GGRNAM) {
5530 const char* const name = POPpbytex;
5531 grent = (const struct group *)getgrnam(name);
5533 else if (which == OP_GGRGID) {
5535 const Gid_t gid = POPu;
5536 #elif Gid_t_sign == -1
5537 const Gid_t gid = POPi;
5539 # error "Unexpected Gid_t_sign"
5541 grent = (const struct group *)getgrgid(gid);
5545 grent = (struct group *)getgrent();
5547 DIE(aTHX_ PL_no_func, "getgrent");
5551 if (GIMME_V != G_ARRAY) {
5552 SV * const sv = sv_newmortal();
5556 if (which == OP_GGRNAM)
5557 sv_setgid(sv, grent->gr_gid);
5559 sv_setpv(sv, grent->gr_name);
5565 mPUSHs(newSVpv(grent->gr_name, 0));
5568 mPUSHs(newSVpv(grent->gr_passwd, 0));
5570 PUSHs(sv_mortalcopy(&PL_sv_no));
5573 sv_setgid(PUSHmortal, grent->gr_gid);
5575 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5576 /* In UNICOS/mk (_CRAYMPP) the multithreading
5577 * versions (getgrnam_r, getgrgid_r)
5578 * seem to return an illegal pointer
5579 * as the group members list, gr_mem.
5580 * getgrent() doesn't even have a _r version
5581 * but the gr_mem is poisonous anyway.
5582 * So yes, you cannot get the list of group
5583 * members if building multithreaded in UNICOS/mk. */
5584 PUSHs(space_join_names_mortal(grent->gr_mem));
5590 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5600 if (!(tmps = PerlProc_getlogin()))
5602 sv_setpv_mg(TARG, tmps);
5606 DIE(aTHX_ PL_no_func, "getlogin");
5610 /* Miscellaneous. */
5615 dSP; dMARK; dORIGMARK; dTARGET;
5616 I32 items = SP - MARK;
5617 unsigned long a[20];
5622 while (++MARK <= SP) {
5623 if (SvTAINTED(*MARK)) {
5629 TAINT_PROPER("syscall");
5632 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5633 * or where sizeof(long) != sizeof(char*). But such machines will
5634 * not likely have syscall implemented either, so who cares?
5636 while (++MARK <= SP) {
5637 if (SvNIOK(*MARK) || !i)
5638 a[i++] = SvIV(*MARK);
5639 else if (*MARK == &PL_sv_undef)
5642 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5648 DIE(aTHX_ "Too many args to syscall");
5650 DIE(aTHX_ "Too few args to syscall");
5652 retval = syscall(a[0]);
5655 retval = syscall(a[0],a[1]);
5658 retval = syscall(a[0],a[1],a[2]);
5661 retval = syscall(a[0],a[1],a[2],a[3]);
5664 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5667 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5670 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5673 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5680 DIE(aTHX_ PL_no_func, "syscall");
5684 #ifdef FCNTL_EMULATE_FLOCK
5686 /* XXX Emulate flock() with fcntl().
5687 What's really needed is a good file locking module.
5691 fcntl_emulate_flock(int fd, int operation)
5696 switch (operation & ~LOCK_NB) {
5698 flock.l_type = F_RDLCK;
5701 flock.l_type = F_WRLCK;
5704 flock.l_type = F_UNLCK;
5710 flock.l_whence = SEEK_SET;
5711 flock.l_start = flock.l_len = (Off_t)0;
5713 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5714 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5715 errno = EWOULDBLOCK;
5719 #endif /* FCNTL_EMULATE_FLOCK */
5721 #ifdef LOCKF_EMULATE_FLOCK
5723 /* XXX Emulate flock() with lockf(). This is just to increase
5724 portability of scripts. The calls are not completely
5725 interchangeable. What's really needed is a good file
5729 /* The lockf() constants might have been defined in <unistd.h>.
5730 Unfortunately, <unistd.h> causes troubles on some mixed
5731 (BSD/POSIX) systems, such as SunOS 4.1.3.
5733 Further, the lockf() constants aren't POSIX, so they might not be
5734 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5735 just stick in the SVID values and be done with it. Sigh.
5739 # define F_ULOCK 0 /* Unlock a previously locked region */
5742 # define F_LOCK 1 /* Lock a region for exclusive use */
5745 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5748 # define F_TEST 3 /* Test a region for other processes locks */
5752 lockf_emulate_flock(int fd, int operation)
5758 /* flock locks entire file so for lockf we need to do the same */
5759 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5760 if (pos > 0) /* is seekable and needs to be repositioned */
5761 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5762 pos = -1; /* seek failed, so don't seek back afterwards */
5765 switch (operation) {
5767 /* LOCK_SH - get a shared lock */
5769 /* LOCK_EX - get an exclusive lock */
5771 i = lockf (fd, F_LOCK, 0);
5774 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5775 case LOCK_SH|LOCK_NB:
5776 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5777 case LOCK_EX|LOCK_NB:
5778 i = lockf (fd, F_TLOCK, 0);
5780 if ((errno == EAGAIN) || (errno == EACCES))
5781 errno = EWOULDBLOCK;
5784 /* LOCK_UN - unlock (non-blocking is a no-op) */
5786 case LOCK_UN|LOCK_NB:
5787 i = lockf (fd, F_ULOCK, 0);
5790 /* Default - can't decipher operation */
5797 if (pos > 0) /* need to restore position of the handle */
5798 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5803 #endif /* LOCKF_EMULATE_FLOCK */
5806 * ex: set ts=8 sts=4 sw=4 et: