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
36 /* Shadow password support for solaris - pdo@cs.umd.edu
37 * Not just Solaris: at least HP-UX, IRIX, Linux.
38 * The API is from SysV.
40 * There are at least two more shadow interfaces,
41 * see the comments in pp_gpwent().
45 /* There is a MAXINT coming from <shadow.h> <- <hpsecurity.h> <- <values.h>
46 * and another MAXINT from "perl.h" <- <sys/param.h>. */
53 # include <sys/resource.h>
62 # include <sys/select.h>
66 /* XXX Configure test needed.
67 h_errno might not be a simple 'int', especially for multi-threaded
68 applications, see "extern int errno in perl.h". Creating such
69 a test requires taking into account the differences between
70 compiling multithreaded and singlethreaded ($ccflags et al).
71 HOST_NOT_FOUND is typically defined in <netdb.h>.
73 #if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
82 struct passwd *getpwnam (char *);
83 struct passwd *getpwuid (Uid_t);
88 struct passwd *getpwent (void);
89 #elif defined (VMS) && defined (my_getpwent)
90 struct passwd *Perl_my_getpwent (pTHX);
99 struct group *getgrnam (char *);
100 struct group *getgrgid (Gid_t);
104 struct group *getgrent (void);
110 # if defined(_MSC_VER) || defined(__MINGW32__)
111 # include <sys/utime.h>
118 # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */
121 # define my_chsize PerlLIO_chsize
124 # define my_chsize PerlLIO_chsize
126 I32 my_chsize(int fd, Off_t length);
132 #else /* no flock() */
134 /* fcntl.h might not have been included, even if it exists, because
135 the current Configure only sets I_FCNTL if it's needed to pick up
136 the *_OK constants. Make sure it has been included before testing
137 the fcntl() locking constants. */
138 # if defined(HAS_FCNTL) && !defined(I_FCNTL)
142 # if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK)
143 # define FLOCK fcntl_emulate_flock
144 # define FCNTL_EMULATE_FLOCK
145 # else /* no flock() or fcntl(F_SETLK,...) */
147 # define FLOCK lockf_emulate_flock
148 # define LOCKF_EMULATE_FLOCK
150 # endif /* no flock() or fcntl(F_SETLK,...) */
153 static int FLOCK (int, int);
156 * These are the flock() constants. Since this sytems doesn't have
157 * flock(), the values of the constants are probably not available.
171 # endif /* emulating flock() */
173 #endif /* no flock() */
176 static const char zero_but_true[ZBTLEN + 1] = "0 but true";
178 #if defined(I_SYS_ACCESS) && !defined(R_OK)
179 # include <sys/access.h>
182 #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
183 # define FD_CLOEXEC 1 /* NeXT needs this */
189 /* Missing protos on LynxOS */
190 void sethostent(int);
191 void endhostent(void);
193 void endnetent(void);
194 void setprotoent(int);
195 void endprotoent(void);
196 void setservent(int);
197 void endservent(void);
200 #undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
202 /* F_OK unused: if stat() cannot find it... */
204 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
205 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
206 # define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
209 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
210 # ifdef I_SYS_SECURITY
211 # include <sys/security.h>
215 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
218 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
222 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
224 # define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
228 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
229 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
230 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
233 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
235 const Uid_t ruid = getuid();
236 const Uid_t euid = geteuid();
237 const Gid_t rgid = getgid();
238 const Gid_t egid = getegid();
241 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
242 Perl_croak(aTHX_ "switching effective uid is not implemented");
245 if (setreuid(euid, ruid))
248 if (setresuid(euid, ruid, (Uid_t)-1))
251 /* diag_listed_as: entering effective %s failed */
252 Perl_croak(aTHX_ "entering effective uid failed");
255 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
256 Perl_croak(aTHX_ "switching effective gid is not implemented");
259 if (setregid(egid, rgid))
262 if (setresgid(egid, rgid, (Gid_t)-1))
265 /* diag_listed_as: entering effective %s failed */
266 Perl_croak(aTHX_ "entering effective gid failed");
269 res = access(path, mode);
272 if (setreuid(ruid, euid))
275 if (setresuid(ruid, euid, (Uid_t)-1))
278 /* diag_listed_as: leaving effective %s failed */
279 Perl_croak(aTHX_ "leaving effective uid failed");
282 if (setregid(rgid, egid))
285 if (setresgid(rgid, egid, (Gid_t)-1))
288 /* diag_listed_as: leaving effective %s failed */
289 Perl_croak(aTHX_ "leaving effective gid failed");
293 # define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
300 const char * const tmps = POPpconstx;
301 const I32 gimme = GIMME_V;
302 const char *mode = "r";
305 if (PL_op->op_private & OPpOPEN_IN_RAW)
307 else if (PL_op->op_private & OPpOPEN_IN_CRLF)
309 fp = PerlProc_popen(tmps, mode);
311 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
313 PerlIO_apply_layers(aTHX_ fp,mode,type);
315 if (gimme == G_VOID) {
317 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
320 else if (gimme == G_SCALAR) {
321 ENTER_with_name("backtick");
323 PL_rs = &PL_sv_undef;
324 sv_setpvs(TARG, ""); /* note that this preserves previous buffer */
325 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
327 LEAVE_with_name("backtick");
333 SV * const sv = newSV(79);
334 if (sv_gets(sv, fp, 0) == NULL) {
339 if (SvLEN(sv) - SvCUR(sv) > 20) {
340 SvPV_shrink_to_cur(sv);
345 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
346 TAINT; /* "I believe that this is not gratuitous!" */
349 STATUS_NATIVE_CHILD_SET(-1);
350 if (gimme == G_SCALAR)
362 GV * const gv = (PL_op->op_flags & OPf_SPECIAL) ? NULL : (GV *)POPs;
366 /* make a copy of the pattern if it is gmagical, to ensure that magic
367 * is called once and only once */
368 if (SvGMAGICAL(TOPs)) TOPs = sv_2mortal(newSVsv(TOPs));
370 tryAMAGICunTARGETlist(iter_amg, (PL_op->op_flags & OPf_SPECIAL));
372 if (PL_op->op_flags & OPf_SPECIAL) {
373 /* call Perl-level glob function instead. Stack args are:
375 * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
384 /* Note that we only ever get here if File::Glob fails to load
385 * without at the same time croaking, for some reason, or if
386 * perl was built with PERL_EXTERNAL_GLOB */
388 ENTER_with_name("glob");
393 * The external globbing program may use things we can't control,
394 * so for security reasons we must assume the worst.
397 taint_proper(PL_no_security, "glob");
401 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
404 SAVESPTR(PL_rs); /* This is not permanent, either. */
405 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
408 *SvPVX(PL_rs) = '\n';
412 result = do_readline();
413 LEAVE_with_name("glob");
420 PL_last_in_gv = cGVOP_gv;
421 return do_readline();
431 do_join(TARG, &PL_sv_no, MARK, SP);
435 else if (SP == MARK) {
442 if (SvGMAGICAL(exsv)) exsv = sv_mortalcopy(exsv);
445 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
446 /* well-formed exception supplied */
449 SV * const errsv = ERRSV;
452 if (SvGMAGICAL(errsv)) {
453 exsv = sv_newmortal();
454 sv_setsv_nomg(exsv, errsv);
458 else if (SvPOKp(errsv) ? SvCUR(errsv) : SvNIOKp(errsv)) {
459 exsv = sv_newmortal();
460 sv_setsv_nomg(exsv, errsv);
461 sv_catpvs(exsv, "\t...caught");
464 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
467 if (SvROK(exsv) && !PL_warnhook)
468 Perl_warn(aTHX_ "%"SVf, SVfARG(exsv));
480 VMSISH_HUSHED || (PL_curcop->op_private & OPpHUSH_VMSISH);
482 if (SP - MARK != 1) {
484 do_join(TARG, &PL_sv_no, MARK, SP);
492 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
493 /* well-formed exception supplied */
496 SV * const errsv = ERRSV;
500 if (sv_isobject(exsv)) {
501 HV * const stash = SvSTASH(SvRV(exsv));
502 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
504 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
505 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
512 call_sv(MUTABLE_SV(GvCV(gv)),
513 G_SCALAR|G_EVAL|G_KEEPERR);
514 exsv = sv_mortalcopy(*PL_stack_sp--);
518 else if (SvPOK(errsv) && SvCUR(errsv)) {
519 exsv = sv_mortalcopy(errsv);
520 sv_catpvs(exsv, "\t...propagated");
523 exsv = newSVpvs_flags("Died", SVs_TEMP);
532 Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv,
533 const MAGIC *const mg, const U32 flags, U32 argc, ...)
538 PERL_ARGS_ASSERT_TIED_METHOD;
540 /* Ensure that our flag bits do not overlap. */
541 assert((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
542 assert((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
543 assert((TIED_METHOD_SAY & G_WANT) == 0);
545 PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
546 PUSHSTACKi(PERLSI_MAGIC);
547 EXTEND(SP, argc+1); /* object + args */
549 PUSHs(SvTIED_obj(sv, mg));
550 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
551 Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
555 const U32 mortalize_not_needed
556 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
558 va_start(args, argc);
560 SV *const arg = va_arg(args, SV *);
561 if(mortalize_not_needed)
570 ENTER_with_name("call_tied_method");
571 if (flags & TIED_METHOD_SAY) {
572 /* local $\ = "\n" */
573 SAVEGENERICSV(PL_ors_sv);
574 PL_ors_sv = newSVpvs("\n");
576 ret_args = call_sv(methname, (flags & G_WANT)|G_METHOD_NAMED);
581 if (ret_args) { /* copy results back to original stack */
582 EXTEND(sp, ret_args);
583 Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
587 LEAVE_with_name("call_tied_method");
591 #define tied_method0(a,b,c,d) \
592 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
593 #define tied_method1(a,b,c,d,e) \
594 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
595 #define tied_method2(a,b,c,d,e,f) \
596 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
609 GV * const gv = MUTABLE_GV(*++MARK);
611 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
612 DIE(aTHX_ PL_no_usym, "filehandle");
614 if ((io = GvIOp(gv))) {
616 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
619 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
620 "Opening dirhandle %"HEKf" also as a file",
621 HEKfARG(GvENAME_HEK(gv)));
623 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
625 /* Method's args are same as ours ... */
626 /* ... except handle is replaced by the object */
627 return Perl_tied_method(aTHX_ SV_CONST(OPEN), mark - 1, MUTABLE_SV(io), mg,
628 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
640 tmps = SvPV_const(sv, len);
641 ok = do_open6(gv, tmps, len, NULL, MARK+1, (SP-MARK));
644 PUSHi( (I32)PL_forkprocess );
645 else if (PL_forkprocess == 0) /* we are a new child */
656 MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
662 IO * const io = GvIO(gv);
664 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
666 return tied_method0(SV_CONST(CLOSE), SP, MUTABLE_SV(io), mg);
670 PUSHs(boolSV(do_close(gv, TRUE)));
683 GV * const wgv = MUTABLE_GV(POPs);
684 GV * const rgv = MUTABLE_GV(POPs);
686 assert (isGV_with_GP(rgv));
687 assert (isGV_with_GP(wgv));
690 do_close(rgv, FALSE);
694 do_close(wgv, FALSE);
696 if (PerlProc_pipe(fd) < 0)
699 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
700 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
701 IoOFP(rstio) = IoIFP(rstio);
702 IoIFP(wstio) = IoOFP(wstio);
703 IoTYPE(rstio) = IoTYPE_RDONLY;
704 IoTYPE(wstio) = IoTYPE_WRONLY;
706 if (!IoIFP(rstio) || !IoOFP(wstio)) {
708 PerlIO_close(IoIFP(rstio));
710 PerlLIO_close(fd[0]);
712 PerlIO_close(IoOFP(wstio));
714 PerlLIO_close(fd[1]);
717 #if defined(HAS_FCNTL) && defined(F_SETFD)
718 /* ensure close-on-exec */
719 if ((fcntl(fd[0], F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
720 (fcntl(fd[1], F_SETFD,fd[1] > PL_maxsysfd) < 0))
728 DIE(aTHX_ PL_no_func, "pipe");
742 gv = MUTABLE_GV(POPs);
746 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
748 return tied_method0(SV_CONST(FILENO), SP, MUTABLE_SV(io), mg);
751 if (!io || !(fp = IoIFP(io))) {
752 /* Can't do this because people seem to do things like
753 defined(fileno($foo)) to check whether $foo is a valid fh.
760 PUSHi(PerlIO_fileno(fp));
772 if (MAXARG < 1 || (!TOPs && !POPs)) {
773 anum = PerlLIO_umask(022);
774 /* setting it to 022 between the two calls to umask avoids
775 * to have a window where the umask is set to 0 -- meaning
776 * that another thread could create world-writeable files. */
778 (void)PerlLIO_umask(anum);
781 anum = PerlLIO_umask(POPi);
782 TAINT_PROPER("umask");
785 /* Only DIE if trying to restrict permissions on "user" (self).
786 * Otherwise it's harmless and more useful to just return undef
787 * since 'group' and 'other' concepts probably don't exist here. */
788 if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
789 DIE(aTHX_ "umask not implemented");
790 XPUSHs(&PL_sv_undef);
809 gv = MUTABLE_GV(POPs);
813 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
815 /* This takes advantage of the implementation of the varargs
816 function, which I don't think that the optimiser will be able to
817 figure out. Although, as it's a static function, in theory it
819 return Perl_tied_method(aTHX_ SV_CONST(BINMODE), SP, MUTABLE_SV(io), mg,
820 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
821 discp ? 1 : 0, discp);
825 if (!io || !(fp = IoIFP(io))) {
827 SETERRNO(EBADF,RMS_IFI);
834 const char *d = NULL;
837 d = SvPV_const(discp, len);
838 mode = mode_from_discipline(d, len);
839 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
840 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
841 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
862 const I32 markoff = MARK - PL_stack_base;
863 const char *methname;
864 int how = PERL_MAGIC_tied;
868 switch(SvTYPE(varsv)) {
872 methname = "TIEHASH";
873 if (HvLAZYDEL(varsv) && (entry = HvEITER((HV *)varsv))) {
874 HvLAZYDEL_off(varsv);
875 hv_free_ent((HV *)varsv, entry);
877 HvEITER_set(MUTABLE_HV(varsv), 0);
881 methname = "TIEARRAY";
882 if (!AvREAL(varsv)) {
884 Perl_croak(aTHX_ "Cannot tie unreifiable array");
885 av_clear((AV *)varsv);
892 if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
893 methname = "TIEHANDLE";
894 how = PERL_MAGIC_tiedscalar;
895 /* For tied filehandles, we apply tiedscalar magic to the IO
896 slot of the GP rather than the GV itself. AMS 20010812 */
898 GvIOp(varsv) = newIO();
899 varsv = MUTABLE_SV(GvIOp(varsv));
902 if (SvTYPE(varsv) == SVt_PVLV && LvTYPE(varsv) == 'y') {
903 vivify_defelem(varsv);
904 varsv = LvTARG(varsv);
908 methname = "TIESCALAR";
909 how = PERL_MAGIC_tiedscalar;
913 if (sv_isobject(*MARK)) { /* Calls GET magic. */
914 ENTER_with_name("call_TIE");
915 PUSHSTACKi(PERLSI_MAGIC);
917 EXTEND(SP,(I32)items);
921 call_method(methname, G_SCALAR);
924 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
925 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
926 * wrong error message, and worse case, supreme action at a distance.
927 * (Sorry obfuscation writers. You're not going to be given this one.)
929 stash = gv_stashsv(*MARK, 0);
930 if (!stash || !(gv = gv_fetchmethod(stash, methname))) {
931 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"",
932 methname, SVfARG(SvOK(*MARK) ? *MARK : &PL_sv_no));
934 ENTER_with_name("call_TIE");
935 PUSHSTACKi(PERLSI_MAGIC);
937 EXTEND(SP,(I32)items);
941 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
947 if (sv_isobject(sv)) {
948 sv_unmagic(varsv, how);
949 /* Croak if a self-tie on an aggregate is attempted. */
950 if (varsv == SvRV(sv) &&
951 (SvTYPE(varsv) == SVt_PVAV ||
952 SvTYPE(varsv) == SVt_PVHV))
954 "Self-ties of arrays and hashes are not supported");
955 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
957 LEAVE_with_name("call_TIE");
958 SP = PL_stack_base + markoff;
968 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
969 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
971 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
974 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
975 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
977 if ((mg = SvTIED_mg(sv, how))) {
978 SV * const obj = SvRV(SvTIED_obj(sv, mg));
980 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
982 if (gv && isGV(gv) && (cv = GvCV(gv))) {
984 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
985 mXPUSHi(SvREFCNT(obj) - 1);
987 ENTER_with_name("call_UNTIE");
988 call_sv(MUTABLE_SV(cv), G_VOID);
989 LEAVE_with_name("call_UNTIE");
992 else if (mg && SvREFCNT(obj) > 1) {
993 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
994 "untie attempted while %"UVuf" inner references still exist",
995 (UV)SvREFCNT(obj) - 1 ) ;
999 sv_unmagic(sv, how) ;
1009 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1010 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1012 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1015 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1016 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
1018 if ((mg = SvTIED_mg(sv, how))) {
1019 PUSHs(SvTIED_obj(sv, mg));
1032 HV * const hv = MUTABLE_HV(POPs);
1033 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1034 stash = gv_stashsv(sv, 0);
1035 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1037 require_pv("AnyDBM_File.pm");
1039 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1040 DIE(aTHX_ "No dbm on this machine");
1050 mPUSHu(O_RDWR|O_CREAT);
1054 if (!SvOK(right)) right = &PL_sv_no;
1058 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1061 if (!sv_isobject(TOPs)) {
1069 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1073 if (sv_isobject(TOPs)) {
1074 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1075 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1092 struct timeval timebuf;
1093 struct timeval *tbuf = &timebuf;
1096 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1101 # if BYTEORDER & 0xf0000
1102 # define ORDERBYTE (0x88888888 - BYTEORDER)
1104 # define ORDERBYTE (0x4444 - BYTEORDER)
1110 for (i = 1; i <= 3; i++) {
1111 SV * const sv = SP[i];
1115 if (SvREADONLY(sv)) {
1116 if (!(SvPOK(sv) && SvCUR(sv) == 0))
1117 Perl_croak_no_modify();
1119 else if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
1122 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1123 "Non-string passed as bitmask");
1124 SvPV_force_nomg_nolen(sv); /* force string conversion */
1131 /* little endians can use vecs directly */
1132 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1139 masksize = NFDBITS / NBBY;
1141 masksize = sizeof(long); /* documented int, everyone seems to use long */
1143 Zero(&fd_sets[0], 4, char*);
1146 # if SELECT_MIN_BITS == 1
1147 growsize = sizeof(fd_set);
1149 # if defined(__GLIBC__) && defined(__FD_SETSIZE)
1150 # undef SELECT_MIN_BITS
1151 # define SELECT_MIN_BITS __FD_SETSIZE
1153 /* If SELECT_MIN_BITS is greater than one we most probably will want
1154 * to align the sizes with SELECT_MIN_BITS/8 because for example
1155 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1156 * UNIX, Solaris, NeXT, Darwin) the smallest quantum select() operates
1157 * on (sets/tests/clears bits) is 32 bits. */
1158 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1164 value = SvNV_nomg(sv);
1167 timebuf.tv_sec = (long)value;
1168 value -= (NV)timebuf.tv_sec;
1169 timebuf.tv_usec = (long)(value * 1000000.0);
1174 for (i = 1; i <= 3; i++) {
1176 if (!SvOK(sv) || SvCUR(sv) == 0) {
1183 Sv_Grow(sv, growsize);
1187 while (++j <= growsize) {
1191 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1193 Newx(fd_sets[i], growsize, char);
1194 for (offset = 0; offset < growsize; offset += masksize) {
1195 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1196 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1199 fd_sets[i] = SvPVX(sv);
1203 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1204 /* Can't make just the (void*) conditional because that would be
1205 * cpp #if within cpp macro, and not all compilers like that. */
1206 nfound = PerlSock_select(
1208 (Select_fd_set_t) fd_sets[1],
1209 (Select_fd_set_t) fd_sets[2],
1210 (Select_fd_set_t) fd_sets[3],
1211 (void*) tbuf); /* Workaround for compiler bug. */
1213 nfound = PerlSock_select(
1215 (Select_fd_set_t) fd_sets[1],
1216 (Select_fd_set_t) fd_sets[2],
1217 (Select_fd_set_t) fd_sets[3],
1220 for (i = 1; i <= 3; i++) {
1223 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1225 for (offset = 0; offset < growsize; offset += masksize) {
1226 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1227 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1229 Safefree(fd_sets[i]);
1236 if (GIMME == G_ARRAY && tbuf) {
1237 value = (NV)(timebuf.tv_sec) +
1238 (NV)(timebuf.tv_usec) / 1000000.0;
1243 DIE(aTHX_ "select not implemented");
1248 =for apidoc setdefout
1250 Sets PL_defoutgv, the default file handle for output, to the passed in
1251 typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference
1252 count of the passed in typeglob is increased by one, and the reference count
1253 of the typeglob that PL_defoutgv points to is decreased by one.
1259 Perl_setdefout(pTHX_ GV *gv)
1262 PERL_ARGS_ASSERT_SETDEFOUT;
1263 SvREFCNT_inc_simple_void_NN(gv);
1264 SvREFCNT_dec(PL_defoutgv);
1272 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1273 GV * egv = GvEGVx(PL_defoutgv);
1278 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1279 gvp = hv && HvENAME(hv)
1280 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1282 if (gvp && *gvp == egv) {
1283 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1287 mXPUSHs(newRV(MUTABLE_SV(egv)));
1291 if (!GvIO(newdefout))
1292 gv_IOadd(newdefout);
1293 setdefout(newdefout);
1303 MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1304 IO *const io = GvIO(gv);
1310 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1312 const U32 gimme = GIMME_V;
1313 Perl_tied_method(aTHX_ SV_CONST(GETC), SP, MUTABLE_SV(io), mg, gimme, 0);
1314 if (gimme == G_SCALAR) {
1316 SvSetMagicSV_nosteal(TARG, TOPs);
1321 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1322 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1324 SETERRNO(EBADF,RMS_IFI);
1328 sv_setpvs(TARG, " ");
1329 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1330 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1331 /* Find out how many bytes the char needs */
1332 Size_t len = UTF8SKIP(SvPVX_const(TARG));
1335 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1336 SvCUR_set(TARG,1+len);
1340 else SvUTF8_off(TARG);
1346 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1350 const I32 gimme = GIMME_V;
1352 PERL_ARGS_ASSERT_DOFORM;
1355 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1360 PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
1361 PUSHFORMAT(cx, retop);
1362 if (CvDEPTH(cv) >= 2) {
1363 PERL_STACK_OVERFLOW_CHECK();
1364 pad_push(CvPADLIST(cv), CvDEPTH(cv));
1367 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), CvDEPTH(cv));
1369 setdefout(gv); /* locally select filehandle so $% et al work */
1388 gv = MUTABLE_GV(POPs);
1405 tmpsv = sv_newmortal();
1406 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1407 DIE(aTHX_ "Undefined format \"%"SVf"\" called", SVfARG(tmpsv));
1409 IoFLAGS(io) &= ~IOf_DIDTOP;
1410 RETURNOP(doform(cv,gv,PL_op->op_next));
1416 GV * const gv = cxstack[cxstack_ix].blk_format.gv;
1417 IO * const io = GvIOp(gv);
1425 if (!io || !(ofp = IoOFP(io)))
1428 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1429 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1431 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1432 PL_formtarget != PL_toptarget)
1436 if (!IoTOP_GV(io)) {
1439 if (!IoTOP_NAME(io)) {
1441 if (!IoFMT_NAME(io))
1442 IoFMT_NAME(io) = savepv(GvNAME(gv));
1443 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%"HEKf"_TOP",
1444 HEKfARG(GvNAME_HEK(gv))));
1445 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1446 if ((topgv && GvFORM(topgv)) ||
1447 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1448 IoTOP_NAME(io) = savesvpv(topname);
1450 IoTOP_NAME(io) = savepvs("top");
1452 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1453 if (!topgv || !GvFORM(topgv)) {
1454 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1457 IoTOP_GV(io) = topgv;
1459 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1460 I32 lines = IoLINES_LEFT(io);
1461 const char *s = SvPVX_const(PL_formtarget);
1462 if (lines <= 0) /* Yow, header didn't even fit!!! */
1464 while (lines-- > 0) {
1465 s = strchr(s, '\n');
1471 const STRLEN save = SvCUR(PL_formtarget);
1472 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1473 do_print(PL_formtarget, ofp);
1474 SvCUR_set(PL_formtarget, save);
1475 sv_chop(PL_formtarget, s);
1476 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1479 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1480 do_print(GvSV(gv_fetchpvs("\f", GV_ADD, SVt_PV)), ofp);
1481 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1483 PL_formtarget = PL_toptarget;
1484 IoFLAGS(io) |= IOf_DIDTOP;
1486 assert(fgv); /* IoTOP_GV(io) should have been set above */
1489 SV * const sv = sv_newmortal();
1490 gv_efullname4(sv, fgv, NULL, FALSE);
1491 DIE(aTHX_ "Undefined top format \"%"SVf"\" called", SVfARG(sv));
1493 return doform(cv, gv, PL_op);
1497 POPBLOCK(cx,PL_curpm);
1498 retop = cx->blk_sub.retop;
1500 SP = newsp; /* ignore retval of formline */
1503 if (!io || !(fp = IoOFP(io))) {
1504 if (io && IoIFP(io))
1505 report_wrongway_fh(gv, '<');
1511 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1512 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1514 if (!do_print(PL_formtarget, fp))
1517 FmLINES(PL_formtarget) = 0;
1518 SvCUR_set(PL_formtarget, 0);
1519 *SvEND(PL_formtarget) = '\0';
1520 if (IoFLAGS(io) & IOf_FLUSH)
1521 (void)PerlIO_flush(fp);
1525 PL_formtarget = PL_bodytarget;
1526 PERL_UNUSED_VAR(gimme);
1532 dVAR; dSP; dMARK; dORIGMARK;
1536 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1537 IO *const io = GvIO(gv);
1539 /* Treat empty list as "" */
1540 if (MARK == SP) XPUSHs(&PL_sv_no);
1543 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1545 if (MARK == ORIGMARK) {
1548 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1551 return Perl_tied_method(aTHX_ SV_CONST(PRINTF), mark - 1, MUTABLE_SV(io),
1553 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1560 SETERRNO(EBADF,RMS_IFI);
1563 else if (!(fp = IoOFP(io))) {
1565 report_wrongway_fh(gv, '<');
1566 else if (ckWARN(WARN_CLOSED))
1568 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1572 SV *sv = sv_newmortal();
1573 do_sprintf(sv, SP - MARK, MARK + 1);
1574 if (!do_print(sv, fp))
1577 if (IoFLAGS(io) & IOf_FLUSH)
1578 if (PerlIO_flush(fp) == EOF)
1587 PUSHs(&PL_sv_undef);
1595 const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1596 const int mode = POPi;
1597 SV * const sv = POPs;
1598 GV * const gv = MUTABLE_GV(POPs);
1601 /* Need TIEHANDLE method ? */
1602 const char * const tmps = SvPV_const(sv, len);
1603 if (do_open_raw(gv, tmps, len, mode, perm)) {
1604 IoLINES(GvIOp(gv)) = 0;
1608 PUSHs(&PL_sv_undef);
1615 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
1629 bool charstart = FALSE;
1630 STRLEN charskip = 0;
1632 GV * const gv = MUTABLE_GV(*++MARK);
1635 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1636 && gv && (io = GvIO(gv)) )
1638 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1640 return Perl_tied_method(aTHX_ SV_CONST(READ), mark - 1, MUTABLE_SV(io), mg,
1641 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1650 sv_setpvs(bufsv, "");
1651 length = SvIVx(*++MARK);
1653 DIE(aTHX_ "Negative length");
1656 offset = SvIVx(*++MARK);
1660 if (!io || !IoIFP(io)) {
1662 SETERRNO(EBADF,RMS_IFI);
1666 /* Note that fd can here validly be -1, don't check it yet. */
1667 fd = PerlIO_fileno(IoIFP(io));
1669 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1670 buffer = SvPVutf8_force(bufsv, blen);
1671 /* UTF-8 may not have been set if they are all low bytes */
1676 buffer = SvPV_force(bufsv, blen);
1677 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
1679 if (DO_UTF8(bufsv)) {
1680 blen = sv_len_utf8_nomg(bufsv);
1689 if (PL_op->op_type == OP_RECV) {
1690 Sock_size_t bufsize;
1691 char namebuf[MAXPATHLEN];
1693 SETERRNO(EBADF,SS_IVCHAN);
1696 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
1697 bufsize = sizeof (struct sockaddr_in);
1699 bufsize = sizeof namebuf;
1701 #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1705 buffer = SvGROW(bufsv, (STRLEN)(length+1));
1706 /* 'offset' means 'flags' here */
1707 count = PerlSock_recvfrom(fd, buffer, length, offset,
1708 (struct sockaddr *)namebuf, &bufsize);
1711 /* MSG_TRUNC can give oversized count; quietly lose it */
1714 SvCUR_set(bufsv, count);
1715 *SvEND(bufsv) = '\0';
1716 (void)SvPOK_only(bufsv);
1720 /* This should not be marked tainted if the fp is marked clean */
1721 if (!(IoFLAGS(io) & IOf_UNTAINT))
1722 SvTAINTED_on(bufsv);
1724 #if defined(__CYGWIN__)
1725 /* recvfrom() on cygwin doesn't set bufsize at all for
1726 connected sockets, leaving us with trash in the returned
1727 name, so use the same test as the Win32 code to check if it
1728 wasn't set, and set it [perl #118843] */
1729 if (bufsize == sizeof namebuf)
1732 sv_setpvn(TARG, namebuf, bufsize);
1738 if (-offset > (SSize_t)blen)
1739 DIE(aTHX_ "Offset outside string");
1742 if (DO_UTF8(bufsv)) {
1743 /* convert offset-as-chars to offset-as-bytes */
1744 if (offset >= (SSize_t)blen)
1745 offset += SvCUR(bufsv) - blen;
1747 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1751 /* Reestablish the fd in case it shifted from underneath us. */
1752 fd = PerlIO_fileno(IoIFP(io));
1754 orig_size = SvCUR(bufsv);
1755 /* Allocating length + offset + 1 isn't perfect in the case of reading
1756 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1758 (should be 2 * length + offset + 1, or possibly something longer if
1759 PL_encoding is true) */
1760 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
1761 if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1762 Zero(buffer+orig_size, offset-orig_size, char);
1764 buffer = buffer + offset;
1766 read_target = bufsv;
1768 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1769 concatenate it to the current buffer. */
1771 /* Truncate the existing buffer to the start of where we will be
1773 SvCUR_set(bufsv, offset);
1775 read_target = sv_newmortal();
1776 SvUPGRADE(read_target, SVt_PV);
1777 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1780 if (PL_op->op_type == OP_SYSREAD) {
1781 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1782 if (IoTYPE(io) == IoTYPE_SOCKET) {
1784 SETERRNO(EBADF,SS_IVCHAN);
1788 count = PerlSock_recv(fd, buffer, length, 0);
1794 SETERRNO(EBADF,RMS_IFI);
1798 count = PerlLIO_read(fd, buffer, length);
1803 count = PerlIO_read(IoIFP(io), buffer, length);
1804 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1805 if (count == 0 && PerlIO_error(IoIFP(io)))
1809 if (IoTYPE(io) == IoTYPE_WRONLY)
1810 report_wrongway_fh(gv, '>');
1813 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1814 *SvEND(read_target) = '\0';
1815 (void)SvPOK_only(read_target);
1816 if (fp_utf8 && !IN_BYTES) {
1817 /* Look at utf8 we got back and count the characters */
1818 const char *bend = buffer + count;
1819 while (buffer < bend) {
1821 skip = UTF8SKIP(buffer);
1824 if (buffer - charskip + skip > bend) {
1825 /* partial character - try for rest of it */
1826 length = skip - (bend-buffer);
1827 offset = bend - SvPVX_const(bufsv);
1839 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1840 provided amount read (count) was what was requested (length)
1842 if (got < wanted && count == length) {
1843 length = wanted - got;
1844 offset = bend - SvPVX_const(bufsv);
1847 /* return value is character count */
1851 else if (buffer_utf8) {
1852 /* Let svcatsv upgrade the bytes we read in to utf8.
1853 The buffer is a mortal so will be freed soon. */
1854 sv_catsv_nomg(bufsv, read_target);
1857 /* This should not be marked tainted if the fp is marked clean */
1858 if (!(IoFLAGS(io) & IOf_UNTAINT))
1859 SvTAINTED_on(bufsv);
1871 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
1876 STRLEN orig_blen_bytes;
1877 const int op_type = PL_op->op_type;
1880 GV *const gv = MUTABLE_GV(*++MARK);
1881 IO *const io = GvIO(gv);
1884 if (op_type == OP_SYSWRITE && io) {
1885 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1887 if (MARK == SP - 1) {
1889 mXPUSHi(sv_len(sv));
1893 return Perl_tied_method(aTHX_ SV_CONST(WRITE), mark - 1, MUTABLE_SV(io), mg,
1894 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1904 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1906 if (io && IoIFP(io))
1907 report_wrongway_fh(gv, '<');
1910 SETERRNO(EBADF,RMS_IFI);
1913 fd = PerlIO_fileno(IoIFP(io));
1915 SETERRNO(EBADF,SS_IVCHAN);
1920 /* Do this first to trigger any overloading. */
1921 buffer = SvPV_const(bufsv, blen);
1922 orig_blen_bytes = blen;
1923 doing_utf8 = DO_UTF8(bufsv);
1925 if (PerlIO_isutf8(IoIFP(io))) {
1926 if (!SvUTF8(bufsv)) {
1927 /* We don't modify the original scalar. */
1928 tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
1929 buffer = (char *) tmpbuf;
1933 else if (doing_utf8) {
1934 STRLEN tmplen = blen;
1935 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
1938 buffer = (char *) tmpbuf;
1942 assert((char *)result == buffer);
1943 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
1948 if (op_type == OP_SEND) {
1949 const int flags = SvIVx(*++MARK);
1952 char * const sockbuf = SvPVx(*++MARK, mlen);
1953 retval = PerlSock_sendto(fd, buffer, blen,
1954 flags, (struct sockaddr *)sockbuf, mlen);
1957 retval = PerlSock_send(fd, buffer, blen, flags);
1963 Size_t length = 0; /* This length is in characters. */
1969 /* The SV is bytes, and we've had to upgrade it. */
1970 blen_chars = orig_blen_bytes;
1972 /* The SV really is UTF-8. */
1973 /* Don't call sv_len_utf8 on a magical or overloaded
1974 scalar, as we might get back a different result. */
1975 blen_chars = sv_or_pv_len_utf8(bufsv, buffer, blen);
1982 length = blen_chars;
1984 #if Size_t_size > IVSIZE
1985 length = (Size_t)SvNVx(*++MARK);
1987 length = (Size_t)SvIVx(*++MARK);
1989 if ((SSize_t)length < 0) {
1991 DIE(aTHX_ "Negative length");
1996 offset = SvIVx(*++MARK);
1998 if (-offset > (IV)blen_chars) {
2000 DIE(aTHX_ "Offset outside string");
2002 offset += blen_chars;
2003 } else if (offset > (IV)blen_chars) {
2005 DIE(aTHX_ "Offset outside string");
2009 if (length > blen_chars - offset)
2010 length = blen_chars - offset;
2012 /* Here we convert length from characters to bytes. */
2013 if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
2014 /* Either we had to convert the SV, or the SV is magical, or
2015 the SV has overloading, in which case we can't or mustn't
2016 or mustn't call it again. */
2018 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
2019 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
2021 /* It's a real UTF-8 SV, and it's not going to change under
2022 us. Take advantage of any cache. */
2024 I32 len_I32 = length;
2026 /* Convert the start and end character positions to bytes.
2027 Remember that the second argument to sv_pos_u2b is relative
2029 sv_pos_u2b(bufsv, &start, &len_I32);
2036 buffer = buffer+offset;
2038 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2039 if (IoTYPE(io) == IoTYPE_SOCKET) {
2040 retval = PerlSock_send(fd, buffer, length, 0);
2045 /* See the note at doio.c:do_print about filesize limits. --jhi */
2046 retval = PerlLIO_write(fd, buffer, length);
2054 retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
2057 #if Size_t_size > IVSIZE
2077 * in Perl 5.12 and later, the additional parameter is a bitmask:
2080 * 2 = eof() <- ARGV magic
2082 * I'll rely on the compiler's trace flow analysis to decide whether to
2083 * actually assign this out here, or punt it into the only block where it is
2084 * used. Doing it out here is DRY on the condition logic.
2089 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
2095 if (PL_op->op_flags & OPf_SPECIAL) {
2096 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
2100 gv = PL_last_in_gv; /* eof */
2108 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2109 return tied_method1(SV_CONST(EOF), SP, MUTABLE_SV(io), mg, newSVuv(which));
2112 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2113 if (io && !IoIFP(io)) {
2114 if ((IoFLAGS(io) & IOf_START) && av_tindex(GvAVn(gv)) < 0) {
2116 IoFLAGS(io) &= ~IOf_START;
2117 do_open6(gv, "-", 1, NULL, NULL, 0);
2119 sv_setpvs(GvSV(gv), "-");
2121 GvSV(gv) = newSVpvs("-");
2122 SvSETMAGIC(GvSV(gv));
2124 else if (!nextargv(gv))
2129 PUSHs(boolSV(do_eof(gv)));
2139 if (MAXARG != 0 && (TOPs || POPs))
2140 PL_last_in_gv = MUTABLE_GV(POPs);
2147 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2149 return tied_method0(SV_CONST(TELL), SP, MUTABLE_SV(io), mg);
2154 SETERRNO(EBADF,RMS_IFI);
2159 #if LSEEKSIZE > IVSIZE
2160 PUSHn( do_tell(gv) );
2162 PUSHi( do_tell(gv) );
2170 const int whence = POPi;
2171 #if LSEEKSIZE > IVSIZE
2172 const Off_t offset = (Off_t)SvNVx(POPs);
2174 const Off_t offset = (Off_t)SvIVx(POPs);
2177 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2178 IO *const io = GvIO(gv);
2181 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2183 #if LSEEKSIZE > IVSIZE
2184 SV *const offset_sv = newSVnv((NV) offset);
2186 SV *const offset_sv = newSViv(offset);
2189 return tied_method2(SV_CONST(SEEK), SP, MUTABLE_SV(io), mg, offset_sv,
2194 if (PL_op->op_type == OP_SEEK)
2195 PUSHs(boolSV(do_seek(gv, offset, whence)));
2197 const Off_t sought = do_sysseek(gv, offset, whence);
2199 PUSHs(&PL_sv_undef);
2201 SV* const sv = sought ?
2202 #if LSEEKSIZE > IVSIZE
2207 : newSVpvn(zero_but_true, ZBTLEN);
2218 /* There seems to be no consensus on the length type of truncate()
2219 * and ftruncate(), both off_t and size_t have supporters. In
2220 * general one would think that when using large files, off_t is
2221 * at least as wide as size_t, so using an off_t should be okay. */
2222 /* XXX Configure probe for the length type of *truncate() needed XXX */
2225 #if Off_t_size > IVSIZE
2230 /* Checking for length < 0 is problematic as the type might or
2231 * might not be signed: if it is not, clever compilers will moan. */
2232 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2235 SV * const sv = POPs;
2240 if (PL_op->op_flags & OPf_SPECIAL
2241 ? (tmpgv = gv_fetchsv(sv, 0, SVt_PVIO), 1)
2242 : !!(tmpgv = MAYBE_DEREF_GV(sv)) ) {
2249 TAINT_PROPER("truncate");
2250 if (!(fp = IoIFP(io))) {
2254 int fd = PerlIO_fileno(fp);
2256 SETERRNO(EBADF,RMS_IFI);
2261 if (ftruncate(fd, len) < 0)
2263 if (my_chsize(fd, len) < 0)
2270 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2271 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2272 goto do_ftruncate_io;
2275 const char * const name = SvPV_nomg_const_nolen(sv);
2276 TAINT_PROPER("truncate");
2278 if (truncate(name, len) < 0)
2282 const int tmpfd = PerlLIO_open(name, O_RDWR);
2285 SETERRNO(EBADF,RMS_IFI);
2288 if (my_chsize(tmpfd, len) < 0)
2290 PerlLIO_close(tmpfd);
2299 SETERRNO(EBADF,RMS_IFI);
2307 SV * const argsv = POPs;
2308 const unsigned int func = POPu;
2310 GV * const gv = MUTABLE_GV(POPs);
2311 IO * const io = GvIOn(gv);
2317 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
2321 if (SvPOK(argsv) || !SvNIOK(argsv)) {
2324 s = SvPV_force(argsv, len);
2325 need = IOCPARM_LEN(func);
2327 s = Sv_Grow(argsv, need + 1);
2328 SvCUR_set(argsv, need);
2331 s[SvCUR(argsv)] = 17; /* a little sanity check here */
2334 retval = SvIV(argsv);
2335 s = INT2PTR(char*,retval); /* ouch */
2338 optype = PL_op->op_type;
2339 TAINT_PROPER(PL_op_desc[optype]);
2341 if (optype == OP_IOCTL)
2343 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2345 DIE(aTHX_ "ioctl is not implemented");
2349 DIE(aTHX_ "fcntl is not implemented");
2351 #if defined(OS2) && defined(__EMX__)
2352 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2354 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2358 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2360 if (s[SvCUR(argsv)] != 17)
2361 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2363 s[SvCUR(argsv)] = 0; /* put our null back */
2364 SvSETMAGIC(argsv); /* Assume it has changed */
2373 PUSHp(zero_but_true, ZBTLEN);
2384 const int argtype = POPi;
2385 GV * const gv = MUTABLE_GV(POPs);
2386 IO *const io = GvIO(gv);
2387 PerlIO *const fp = io ? IoIFP(io) : NULL;
2389 /* XXX Looks to me like io is always NULL at this point */
2391 (void)PerlIO_flush(fp);
2392 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2397 SETERRNO(EBADF,RMS_IFI);
2402 DIE(aTHX_ PL_no_func, "flock()");
2413 const int protocol = POPi;
2414 const int type = POPi;
2415 const int domain = POPi;
2416 GV * const gv = MUTABLE_GV(POPs);
2417 IO * const io = GvIOn(gv);
2421 do_close(gv, FALSE);
2423 TAINT_PROPER("socket");
2424 fd = PerlSock_socket(domain, type, protocol);
2426 SETERRNO(EBADF,RMS_IFI);
2429 IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2430 IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2431 IoTYPE(io) = IoTYPE_SOCKET;
2432 if (!IoIFP(io) || !IoOFP(io)) {
2433 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2434 if (IoOFP(io)) PerlIO_close(IoOFP(io));
2435 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2438 #if defined(HAS_FCNTL) && defined(F_SETFD)
2439 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2449 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2452 const int protocol = POPi;
2453 const int type = POPi;
2454 const int domain = POPi;
2456 GV * const gv2 = MUTABLE_GV(POPs);
2457 IO * const io2 = GvIOn(gv2);
2458 GV * const gv1 = MUTABLE_GV(POPs);
2459 IO * const io1 = GvIOn(gv1);
2462 do_close(gv1, FALSE);
2464 do_close(gv2, FALSE);
2466 TAINT_PROPER("socketpair");
2467 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2469 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2470 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
2471 IoTYPE(io1) = IoTYPE_SOCKET;
2472 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2473 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
2474 IoTYPE(io2) = IoTYPE_SOCKET;
2475 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2476 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2477 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2478 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2479 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2480 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2481 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2484 #if defined(HAS_FCNTL) && defined(F_SETFD)
2485 /* ensure close-on-exec */
2486 if ((fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
2487 (fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd) < 0))
2493 DIE(aTHX_ PL_no_sock_func, "socketpair");
2502 SV * const addrsv = POPs;
2503 /* OK, so on what platform does bind modify addr? */
2505 GV * const gv = MUTABLE_GV(POPs);
2506 IO * const io = GvIOn(gv);
2513 fd = PerlIO_fileno(IoIFP(io));
2517 addr = SvPV_const(addrsv, len);
2518 op_type = PL_op->op_type;
2519 TAINT_PROPER(PL_op_desc[op_type]);
2520 if ((op_type == OP_BIND
2521 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2522 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2530 SETERRNO(EBADF,SS_IVCHAN);
2537 const int backlog = POPi;
2538 GV * const gv = MUTABLE_GV(POPs);
2539 IO * const io = GvIOn(gv);
2544 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2551 SETERRNO(EBADF,SS_IVCHAN);
2559 char namebuf[MAXPATHLEN];
2560 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2561 Sock_size_t len = sizeof (struct sockaddr_in);
2563 Sock_size_t len = sizeof namebuf;
2565 GV * const ggv = MUTABLE_GV(POPs);
2566 GV * const ngv = MUTABLE_GV(POPs);
2569 IO * const gstio = GvIO(ggv);
2570 if (!gstio || !IoIFP(gstio))
2574 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2577 /* Some platforms indicate zero length when an AF_UNIX client is
2578 * not bound. Simulate a non-zero-length sockaddr structure in
2580 namebuf[0] = 0; /* sun_len */
2581 namebuf[1] = AF_UNIX; /* sun_family */
2589 do_close(ngv, FALSE);
2590 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2591 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2592 IoTYPE(nstio) = IoTYPE_SOCKET;
2593 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2594 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2595 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2596 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2599 #if defined(HAS_FCNTL) && defined(F_SETFD)
2600 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2604 #ifdef __SCO_VERSION__
2605 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2608 PUSHp(namebuf, len);
2612 report_evil_fh(ggv);
2613 SETERRNO(EBADF,SS_IVCHAN);
2623 const int how = POPi;
2624 GV * const gv = MUTABLE_GV(POPs);
2625 IO * const io = GvIOn(gv);
2630 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2635 SETERRNO(EBADF,SS_IVCHAN);
2642 const int optype = PL_op->op_type;
2643 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2644 const unsigned int optname = (unsigned int) POPi;
2645 const unsigned int lvl = (unsigned int) POPi;
2646 GV * const gv = MUTABLE_GV(POPs);
2647 IO * const io = GvIOn(gv);
2654 fd = PerlIO_fileno(IoIFP(io));
2660 (void)SvPOK_only(sv);
2664 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2671 #if defined(__SYMBIAN32__)
2672 # define SETSOCKOPT_OPTION_VALUE_T void *
2674 # define SETSOCKOPT_OPTION_VALUE_T const char *
2676 /* XXX TODO: We need to have a proper type (a Configure probe,
2677 * etc.) for what the C headers think of the third argument of
2678 * setsockopt(), the option_value read-only buffer: is it
2679 * a "char *", or a "void *", const or not. Some compilers
2680 * don't take kindly to e.g. assuming that "char *" implicitly
2681 * promotes to a "void *", or to explicitly promoting/demoting
2682 * consts to non/vice versa. The "const void *" is the SUS
2683 * definition, but that does not fly everywhere for the above
2685 SETSOCKOPT_OPTION_VALUE_T buf;
2689 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2693 aint = (int)SvIV(sv);
2694 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2697 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2707 SETERRNO(EBADF,SS_IVCHAN);
2716 const int optype = PL_op->op_type;
2717 GV * const gv = MUTABLE_GV(POPs);
2718 IO * const io = GvIOn(gv);
2726 sv = sv_2mortal(newSV(257));
2727 (void)SvPOK_only(sv);
2731 fd = PerlIO_fileno(IoIFP(io));
2735 case OP_GETSOCKNAME:
2736 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2739 case OP_GETPEERNAME:
2740 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2742 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2744 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";
2745 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2746 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2747 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2748 sizeof(u_short) + sizeof(struct in_addr))) {
2755 #ifdef BOGUS_GETNAME_RETURN
2756 /* Interactive Unix, getpeername() and getsockname()
2757 does not return valid namelen */
2758 if (len == BOGUS_GETNAME_RETURN)
2759 len = sizeof(struct sockaddr);
2768 SETERRNO(EBADF,SS_IVCHAN);
2787 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2788 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2789 if (PL_op->op_type == OP_LSTAT) {
2790 if (gv != PL_defgv) {
2791 do_fstat_warning_check:
2792 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2793 "lstat() on filehandle%s%"SVf,
2796 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2798 } else if (PL_laststype != OP_LSTAT)
2799 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2800 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2803 if (gv != PL_defgv) {
2807 PL_laststype = OP_STAT;
2808 PL_statgv = gv ? gv : (GV *)io;
2809 sv_setpvs(PL_statname, "");
2815 int fd = PerlIO_fileno(IoIFP(io));
2817 PL_laststatval = -1;
2818 SETERRNO(EBADF,RMS_IFI);
2820 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2823 } else if (IoDIRP(io)) {
2825 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2828 PL_laststatval = -1;
2831 else PL_laststatval = -1;
2832 if (PL_laststatval < 0 && !havefp) report_evil_fh(gv);
2835 if (PL_laststatval < 0) {
2841 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2842 io = MUTABLE_IO(SvRV(sv));
2843 if (PL_op->op_type == OP_LSTAT)
2844 goto do_fstat_warning_check;
2845 goto do_fstat_have_io;
2848 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2849 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2851 PL_laststype = PL_op->op_type;
2852 file = SvPV_nolen_const(PL_statname);
2853 if (PL_op->op_type == OP_LSTAT)
2854 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2856 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2857 if (PL_laststatval < 0) {
2858 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2859 /* PL_warn_nl is constant */
2860 GCC_DIAG_IGNORE(-Wformat-nonliteral);
2861 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2869 if (gimme != G_ARRAY) {
2870 if (gimme != G_VOID)
2871 XPUSHs(boolSV(max));
2877 mPUSHi(PL_statcache.st_dev);
2878 #if ST_INO_SIZE > IVSIZE
2879 mPUSHn(PL_statcache.st_ino);
2881 # if ST_INO_SIGN <= 0
2882 mPUSHi(PL_statcache.st_ino);
2884 mPUSHu(PL_statcache.st_ino);
2887 mPUSHu(PL_statcache.st_mode);
2888 mPUSHu(PL_statcache.st_nlink);
2890 sv_setuid(PUSHmortal, PL_statcache.st_uid);
2891 sv_setgid(PUSHmortal, PL_statcache.st_gid);
2893 #ifdef USE_STAT_RDEV
2894 mPUSHi(PL_statcache.st_rdev);
2896 PUSHs(newSVpvs_flags("", SVs_TEMP));
2898 #if Off_t_size > IVSIZE
2899 mPUSHn(PL_statcache.st_size);
2901 mPUSHi(PL_statcache.st_size);
2904 mPUSHn(PL_statcache.st_atime);
2905 mPUSHn(PL_statcache.st_mtime);
2906 mPUSHn(PL_statcache.st_ctime);
2908 mPUSHi(PL_statcache.st_atime);
2909 mPUSHi(PL_statcache.st_mtime);
2910 mPUSHi(PL_statcache.st_ctime);
2912 #ifdef USE_STAT_BLOCKS
2913 mPUSHu(PL_statcache.st_blksize);
2914 mPUSHu(PL_statcache.st_blocks);
2916 PUSHs(newSVpvs_flags("", SVs_TEMP));
2917 PUSHs(newSVpvs_flags("", SVs_TEMP));
2923 /* All filetest ops avoid manipulating the perl stack pointer in their main
2924 bodies (since commit d2c4d2d1e22d3125), and return using either
2925 S_ft_return_false() or S_ft_return_true(). These two helper functions are
2926 the only two which manipulate the perl stack. To ensure that no stack
2927 manipulation macros are used, the filetest ops avoid defining a local copy
2928 of the stack pointer with dSP. */
2930 /* If the next filetest is stacked up with this one
2931 (PL_op->op_private & OPpFT_STACKING), we leave
2932 the original argument on the stack for success,
2933 and skip the stacked operators on failure.
2934 The next few macros/functions take care of this.
2938 S_ft_return_false(pTHX_ SV *ret) {
2942 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
2946 if (PL_op->op_private & OPpFT_STACKING) {
2947 while (OP_IS_FILETEST(next->op_type)
2948 && next->op_private & OPpFT_STACKED)
2949 next = next->op_next;
2954 PERL_STATIC_INLINE OP *
2955 S_ft_return_true(pTHX_ SV *ret) {
2957 if (PL_op->op_flags & OPf_REF)
2958 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
2959 else if (!(PL_op->op_private & OPpFT_STACKING))
2965 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
2966 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
2967 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
2969 #define tryAMAGICftest_MG(chr) STMT_START { \
2970 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
2971 && PL_op->op_flags & OPf_KIDS) { \
2972 OP *next = S_try_amagic_ftest(aTHX_ chr); \
2973 if (next) return next; \
2978 S_try_amagic_ftest(pTHX_ char chr) {
2980 SV *const arg = *PL_stack_sp;
2983 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
2987 const char tmpchr = chr;
2988 SV * const tmpsv = amagic_call(arg,
2989 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
2990 ftest_amg, AMGf_unary);
2995 return SvTRUE(tmpsv)
2996 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3006 /* Not const, because things tweak this below. Not bool, because there's
3007 no guarantee that OPp_FT_ACCESS is <= CHAR_MAX */
3008 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3009 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3010 /* Giving some sort of initial value silences compilers. */
3012 int access_mode = R_OK;
3014 int access_mode = 0;
3017 /* access_mode is never used, but leaving use_access in makes the
3018 conditional compiling below much clearer. */
3021 Mode_t stat_mode = S_IRUSR;
3023 bool effective = FALSE;
3026 switch (PL_op->op_type) {
3027 case OP_FTRREAD: opchar = 'R'; break;
3028 case OP_FTRWRITE: opchar = 'W'; break;
3029 case OP_FTREXEC: opchar = 'X'; break;
3030 case OP_FTEREAD: opchar = 'r'; break;
3031 case OP_FTEWRITE: opchar = 'w'; break;
3032 case OP_FTEEXEC: opchar = 'x'; break;
3034 tryAMAGICftest_MG(opchar);
3036 switch (PL_op->op_type) {
3038 #if !(defined(HAS_ACCESS) && defined(R_OK))
3044 #if defined(HAS_ACCESS) && defined(W_OK)
3049 stat_mode = S_IWUSR;
3053 #if defined(HAS_ACCESS) && defined(X_OK)
3058 stat_mode = S_IXUSR;
3062 #ifdef PERL_EFF_ACCESS
3065 stat_mode = S_IWUSR;
3069 #ifndef PERL_EFF_ACCESS
3076 #ifdef PERL_EFF_ACCESS
3081 stat_mode = S_IXUSR;
3087 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3088 const char *name = SvPV_nolen(*PL_stack_sp);
3090 # ifdef PERL_EFF_ACCESS
3091 result = PERL_EFF_ACCESS(name, access_mode);
3093 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3099 result = access(name, access_mode);
3101 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3112 result = my_stat_flags(0);
3115 if (cando(stat_mode, effective, &PL_statcache))
3124 const int op_type = PL_op->op_type;
3128 case OP_FTIS: opchar = 'e'; break;
3129 case OP_FTSIZE: opchar = 's'; break;
3130 case OP_FTMTIME: opchar = 'M'; break;
3131 case OP_FTCTIME: opchar = 'C'; break;
3132 case OP_FTATIME: opchar = 'A'; break;
3134 tryAMAGICftest_MG(opchar);
3136 result = my_stat_flags(0);
3139 if (op_type == OP_FTIS)
3142 /* You can't dTARGET inside OP_FTIS, because you'll get
3143 "panic: pad_sv po" - the op is not flagged to have a target. */
3147 #if Off_t_size > IVSIZE
3148 sv_setnv(TARG, (NV)PL_statcache.st_size);
3150 sv_setiv(TARG, (IV)PL_statcache.st_size);
3155 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3159 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3163 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3167 return SvTRUE_nomg(TARG)
3168 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3178 switch (PL_op->op_type) {
3179 case OP_FTROWNED: opchar = 'O'; break;
3180 case OP_FTEOWNED: opchar = 'o'; break;
3181 case OP_FTZERO: opchar = 'z'; break;
3182 case OP_FTSOCK: opchar = 'S'; break;
3183 case OP_FTCHR: opchar = 'c'; break;
3184 case OP_FTBLK: opchar = 'b'; break;
3185 case OP_FTFILE: opchar = 'f'; break;
3186 case OP_FTDIR: opchar = 'd'; break;
3187 case OP_FTPIPE: opchar = 'p'; break;
3188 case OP_FTSUID: opchar = 'u'; break;
3189 case OP_FTSGID: opchar = 'g'; break;
3190 case OP_FTSVTX: opchar = 'k'; break;
3192 tryAMAGICftest_MG(opchar);
3194 /* I believe that all these three are likely to be defined on most every
3195 system these days. */
3197 if(PL_op->op_type == OP_FTSUID) {
3202 if(PL_op->op_type == OP_FTSGID) {
3207 if(PL_op->op_type == OP_FTSVTX) {
3212 result = my_stat_flags(0);
3215 switch (PL_op->op_type) {
3217 if (PL_statcache.st_uid == PerlProc_getuid())
3221 if (PL_statcache.st_uid == PerlProc_geteuid())
3225 if (PL_statcache.st_size == 0)
3229 if (S_ISSOCK(PL_statcache.st_mode))
3233 if (S_ISCHR(PL_statcache.st_mode))
3237 if (S_ISBLK(PL_statcache.st_mode))
3241 if (S_ISREG(PL_statcache.st_mode))
3245 if (S_ISDIR(PL_statcache.st_mode))
3249 if (S_ISFIFO(PL_statcache.st_mode))
3254 if (PL_statcache.st_mode & S_ISUID)
3260 if (PL_statcache.st_mode & S_ISGID)
3266 if (PL_statcache.st_mode & S_ISVTX)
3279 tryAMAGICftest_MG('l');
3280 result = my_lstat_flags(0);
3284 if (S_ISLNK(PL_statcache.st_mode))
3297 tryAMAGICftest_MG('t');
3299 if (PL_op->op_flags & OPf_REF)
3302 SV *tmpsv = *PL_stack_sp;
3303 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3304 name = SvPV_nomg(tmpsv, namelen);
3305 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3309 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3310 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3311 else if (name && isDIGIT(*name))
3316 SETERRNO(EBADF,RMS_IFI);
3319 if (PerlLIO_isatty(fd))
3337 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3339 if (PL_op->op_flags & OPf_REF)
3341 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3346 gv = MAYBE_DEREF_GV_nomg(sv);
3350 if (gv == PL_defgv) {
3352 io = SvTYPE(PL_statgv) == SVt_PVIO
3356 goto really_filename;
3361 sv_setpvs(PL_statname, "");
3362 io = GvIO(PL_statgv);
3364 PL_laststatval = -1;
3365 PL_laststype = OP_STAT;
3366 if (io && IoIFP(io)) {
3368 if (! PerlIO_has_base(IoIFP(io)))
3369 DIE(aTHX_ "-T and -B not implemented on filehandles");
3370 fd = PerlIO_fileno(IoIFP(io));
3372 SETERRNO(EBADF,RMS_IFI);
3375 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3376 if (PL_laststatval < 0)
3378 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3379 if (PL_op->op_type == OP_FTTEXT)
3384 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3385 i = PerlIO_getc(IoIFP(io));
3387 (void)PerlIO_ungetc(IoIFP(io),i);
3389 /* null file is anything */
3392 len = PerlIO_get_bufsiz(IoIFP(io));
3393 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3394 /* sfio can have large buffers - limit to 512 */
3399 SETERRNO(EBADF,RMS_IFI);
3401 SETERRNO(EBADF,RMS_IFI);
3410 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3412 file = SvPVX_const(PL_statname);
3414 if (!(fp = PerlIO_open(file, "r"))) {
3416 PL_laststatval = -1;
3417 PL_laststype = OP_STAT;
3419 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3420 /* PL_warn_nl is constant */
3421 GCC_DIAG_IGNORE(-Wformat-nonliteral);
3422 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3427 PL_laststype = OP_STAT;
3428 fd = PerlIO_fileno(fp);
3430 (void)PerlIO_close(fp);
3431 SETERRNO(EBADF,RMS_IFI);
3434 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3435 if (PL_laststatval < 0) {
3436 (void)PerlIO_close(fp);
3437 SETERRNO(EBADF,RMS_IFI);
3440 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3441 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3442 (void)PerlIO_close(fp);
3444 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3445 FT_RETURNNO; /* special case NFS directories */
3446 FT_RETURNYES; /* null file is anything */
3451 /* now scan s to look for textiness */
3452 /* XXX ASCII dependent code */
3454 #if defined(DOSISH) || defined(USEMYBINMODE)
3455 /* ignore trailing ^Z on short files */
3456 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3460 for (i = 0; i < len; i++, s++) {
3461 if (!*s) { /* null never allowed in text */
3466 else if (!(isPRINT(*s) || isSPACE(*s)))
3469 else if (*s & 128) {
3471 if (IN_LOCALE_RUNTIME && isALPHA_LC(*s))
3474 /* utf8 characters don't count as odd */
3475 if (UTF8_IS_START(*s)) {
3476 int ulen = UTF8SKIP(s);
3477 if (ulen < len - i) {
3479 for (j = 1; j < ulen; j++) {
3480 if (!UTF8_IS_CONTINUATION(s[j]))
3483 --ulen; /* loop does extra increment */
3493 *s != '\n' && *s != '\r' && *s != '\b' &&
3494 *s != '\t' && *s != '\f' && *s != 27)
3499 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3510 const char *tmps = NULL;
3514 SV * const sv = POPs;
3515 if (PL_op->op_flags & OPf_SPECIAL) {
3516 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3518 else if (!(gv = MAYBE_DEREF_GV(sv)))
3519 tmps = SvPV_nomg_const_nolen(sv);
3522 if( !gv && (!tmps || !*tmps) ) {
3523 HV * const table = GvHVn(PL_envgv);
3526 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3527 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3529 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3534 deprecate("chdir('') or chdir(undef) as chdir()");
3535 tmps = SvPV_nolen_const(*svp);
3539 TAINT_PROPER("chdir");
3544 TAINT_PROPER("chdir");
3547 IO* const io = GvIO(gv);
3550 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3551 } else if (IoIFP(io)) {
3552 int fd = PerlIO_fileno(IoIFP(io));
3556 PUSHi(fchdir(fd) >= 0);
3566 DIE(aTHX_ PL_no_func, "fchdir");
3570 PUSHi( PerlDir_chdir(tmps) >= 0 );
3572 /* Clear the DEFAULT element of ENV so we'll get the new value
3574 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3580 SETERRNO(EBADF,RMS_IFI);
3587 dVAR; dSP; dMARK; dTARGET;
3588 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3599 char * const tmps = POPpx;
3600 TAINT_PROPER("chroot");
3601 PUSHi( chroot(tmps) >= 0 );
3604 DIE(aTHX_ PL_no_func, "chroot");
3612 const char * const tmps2 = POPpconstx;
3613 const char * const tmps = SvPV_nolen_const(TOPs);
3614 TAINT_PROPER("rename");
3616 anum = PerlLIO_rename(tmps, tmps2);
3618 if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) {
3619 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3622 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode))
3623 (void)UNLINK(tmps2);
3624 if (!(anum = link(tmps, tmps2)))
3625 anum = UNLINK(tmps);
3633 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3637 const int op_type = PL_op->op_type;
3641 if (op_type == OP_LINK)
3642 DIE(aTHX_ PL_no_func, "link");
3644 # ifndef HAS_SYMLINK
3645 if (op_type == OP_SYMLINK)
3646 DIE(aTHX_ PL_no_func, "symlink");
3650 const char * const tmps2 = POPpconstx;
3651 const char * const tmps = SvPV_nolen_const(TOPs);
3652 TAINT_PROPER(PL_op_desc[op_type]);
3654 # if defined(HAS_LINK)
3655 # if defined(HAS_SYMLINK)
3656 /* Both present - need to choose which. */
3657 (op_type == OP_LINK) ?
3658 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3660 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3661 PerlLIO_link(tmps, tmps2);
3664 # if defined(HAS_SYMLINK)
3665 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3666 symlink(tmps, tmps2);
3671 SETi( result >= 0 );
3678 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3689 char buf[MAXPATHLEN];
3694 len = readlink(tmps, buf, sizeof(buf) - 1);
3701 RETSETUNDEF; /* just pretend it's a normal file */
3705 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3707 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3709 char * const save_filename = filename;
3714 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3716 PERL_ARGS_ASSERT_DOONELINER;
3718 Newx(cmdline, size, char);
3719 my_strlcpy(cmdline, cmd, size);
3720 my_strlcat(cmdline, " ", size);
3721 for (s = cmdline + strlen(cmdline); *filename; ) {
3725 if (s - cmdline < size)
3726 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3727 myfp = PerlProc_popen(cmdline, "r");
3731 SV * const tmpsv = sv_newmortal();
3732 /* Need to save/restore 'PL_rs' ?? */
3733 s = sv_gets(tmpsv, myfp, 0);
3734 (void)PerlProc_pclose(myfp);
3738 #ifdef HAS_SYS_ERRLIST
3743 /* you don't see this */
3744 const char * const errmsg = Strerror(e) ;
3747 if (instr(s, errmsg)) {
3754 #define EACCES EPERM
3756 if (instr(s, "cannot make"))
3757 SETERRNO(EEXIST,RMS_FEX);
3758 else if (instr(s, "existing file"))
3759 SETERRNO(EEXIST,RMS_FEX);
3760 else if (instr(s, "ile exists"))
3761 SETERRNO(EEXIST,RMS_FEX);
3762 else if (instr(s, "non-exist"))
3763 SETERRNO(ENOENT,RMS_FNF);
3764 else if (instr(s, "does not exist"))
3765 SETERRNO(ENOENT,RMS_FNF);
3766 else if (instr(s, "not empty"))
3767 SETERRNO(EBUSY,SS_DEVOFFLINE);
3768 else if (instr(s, "cannot access"))
3769 SETERRNO(EACCES,RMS_PRV);
3771 SETERRNO(EPERM,RMS_PRV);
3774 else { /* some mkdirs return no failure indication */
3775 anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0);
3776 if (PL_op->op_type == OP_RMDIR)
3781 SETERRNO(EACCES,RMS_PRV); /* a guess */
3790 /* This macro removes trailing slashes from a directory name.
3791 * Different operating and file systems take differently to
3792 * trailing slashes. According to POSIX 1003.1 1996 Edition
3793 * any number of trailing slashes should be allowed.
3794 * Thusly we snip them away so that even non-conforming
3795 * systems are happy.
3796 * We should probably do this "filtering" for all
3797 * the functions that expect (potentially) directory names:
3798 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3799 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3801 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3802 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3805 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3806 (tmps) = savepvn((tmps), (len)); \
3816 const int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPi : 0777;
3818 TRIMSLASHES(tmps,len,copy);
3820 TAINT_PROPER("mkdir");
3822 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3826 SETi( dooneliner("mkdir", tmps) );
3827 oldumask = PerlLIO_umask(0);
3828 PerlLIO_umask(oldumask);
3829 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3844 TRIMSLASHES(tmps,len,copy);
3845 TAINT_PROPER("rmdir");
3847 SETi( PerlDir_rmdir(tmps) >= 0 );
3849 SETi( dooneliner("rmdir", tmps) );
3856 /* Directory calls. */
3860 #if defined(Direntry_t) && defined(HAS_READDIR)
3862 const char * const dirname = POPpconstx;
3863 GV * const gv = MUTABLE_GV(POPs);
3864 IO * const io = GvIOn(gv);
3866 if ((IoIFP(io) || IoOFP(io)))
3867 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
3868 "Opening filehandle %"HEKf" also as a directory",
3869 HEKfARG(GvENAME_HEK(gv)) );
3871 PerlDir_close(IoDIRP(io));
3872 if (!(IoDIRP(io) = PerlDir_open(dirname)))
3878 SETERRNO(EBADF,RMS_DIR);
3881 DIE(aTHX_ PL_no_dir_func, "opendir");
3887 #if !defined(Direntry_t) || !defined(HAS_READDIR)
3888 DIE(aTHX_ PL_no_dir_func, "readdir");
3890 #if !defined(I_DIRENT) && !defined(VMS)
3891 Direntry_t *readdir (DIR *);
3897 const I32 gimme = GIMME;
3898 GV * const gv = MUTABLE_GV(POPs);
3899 const Direntry_t *dp;
3900 IO * const io = GvIOn(gv);
3903 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3904 "readdir() attempted on invalid dirhandle %"HEKf,
3905 HEKfARG(GvENAME_HEK(gv)));
3910 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
3914 sv = newSVpvn(dp->d_name, dp->d_namlen);
3916 sv = newSVpv(dp->d_name, 0);
3918 if (!(IoFLAGS(io) & IOf_UNTAINT))
3921 } while (gimme == G_ARRAY);
3923 if (!dp && gimme != G_ARRAY)
3930 SETERRNO(EBADF,RMS_ISI);
3931 if (GIMME == G_ARRAY)
3940 #if defined(HAS_TELLDIR) || defined(telldir)
3942 /* XXX does _anyone_ need this? --AD 2/20/1998 */
3943 /* XXX netbsd still seemed to.
3944 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
3945 --JHI 1999-Feb-02 */
3946 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
3947 long telldir (DIR *);
3949 GV * const gv = MUTABLE_GV(POPs);
3950 IO * const io = GvIOn(gv);
3953 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3954 "telldir() attempted on invalid dirhandle %"HEKf,
3955 HEKfARG(GvENAME_HEK(gv)));
3959 PUSHi( PerlDir_tell(IoDIRP(io)) );
3963 SETERRNO(EBADF,RMS_ISI);
3966 DIE(aTHX_ PL_no_dir_func, "telldir");
3972 #if defined(HAS_SEEKDIR) || defined(seekdir)
3974 const long along = POPl;
3975 GV * const gv = MUTABLE_GV(POPs);
3976 IO * const io = GvIOn(gv);
3979 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3980 "seekdir() attempted on invalid dirhandle %"HEKf,
3981 HEKfARG(GvENAME_HEK(gv)));
3984 (void)PerlDir_seek(IoDIRP(io), along);
3989 SETERRNO(EBADF,RMS_ISI);
3992 DIE(aTHX_ PL_no_dir_func, "seekdir");
3998 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4000 GV * const gv = MUTABLE_GV(POPs);
4001 IO * const io = GvIOn(gv);
4004 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4005 "rewinddir() attempted on invalid dirhandle %"HEKf,
4006 HEKfARG(GvENAME_HEK(gv)));
4009 (void)PerlDir_rewind(IoDIRP(io));
4013 SETERRNO(EBADF,RMS_ISI);
4016 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4022 #if defined(Direntry_t) && defined(HAS_READDIR)
4024 GV * const gv = MUTABLE_GV(POPs);
4025 IO * const io = GvIOn(gv);
4028 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4029 "closedir() attempted on invalid dirhandle %"HEKf,
4030 HEKfARG(GvENAME_HEK(gv)));
4033 #ifdef VOID_CLOSEDIR
4034 PerlDir_close(IoDIRP(io));
4036 if (PerlDir_close(IoDIRP(io)) < 0) {
4037 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4046 SETERRNO(EBADF,RMS_IFI);
4049 DIE(aTHX_ PL_no_dir_func, "closedir");
4053 /* Process control. */
4060 #ifdef HAS_SIGPROCMASK
4061 sigset_t oldmask, newmask;
4065 PERL_FLUSHALL_FOR_CHILD;
4066 #ifdef HAS_SIGPROCMASK
4067 sigfillset(&newmask);
4068 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4070 childpid = PerlProc_fork();
4071 if (childpid == 0) {
4075 for (sig = 1; sig < SIG_SIZE; sig++)
4076 PL_psig_pend[sig] = 0;
4078 #ifdef HAS_SIGPROCMASK
4081 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4088 #ifdef PERL_USES_PL_PIDSTATUS
4089 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4095 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4100 PERL_FLUSHALL_FOR_CHILD;
4101 childpid = PerlProc_fork();
4107 DIE(aTHX_ PL_no_func, "fork");
4114 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4119 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4120 childpid = wait4pid(-1, &argflags, 0);
4122 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4127 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4128 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4129 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4131 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4136 DIE(aTHX_ PL_no_func, "wait");
4142 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4144 const int optype = POPi;
4145 const Pid_t pid = TOPi;
4149 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4150 result = wait4pid(pid, &argflags, optype);
4152 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4157 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4158 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4159 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4161 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4166 DIE(aTHX_ PL_no_func, "waitpid");
4172 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4173 #if defined(__LIBCATAMOUNT__)
4174 PL_statusvalue = -1;
4183 while (++MARK <= SP) {
4184 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4189 TAINT_PROPER("system");
4191 PERL_FLUSHALL_FOR_CHILD;
4192 #if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4197 #ifdef HAS_SIGPROCMASK
4198 sigset_t newset, oldset;
4201 if (PerlProc_pipe(pp) >= 0)
4203 #ifdef HAS_SIGPROCMASK
4204 sigemptyset(&newset);
4205 sigaddset(&newset, SIGCHLD);
4206 sigprocmask(SIG_BLOCK, &newset, &oldset);
4208 while ((childpid = PerlProc_fork()) == -1) {
4209 if (errno != EAGAIN) {
4214 PerlLIO_close(pp[0]);
4215 PerlLIO_close(pp[1]);
4217 #ifdef HAS_SIGPROCMASK
4218 sigprocmask(SIG_SETMASK, &oldset, NULL);
4225 Sigsave_t ihand,qhand; /* place to save signals during system() */
4229 PerlLIO_close(pp[1]);
4231 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4232 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4235 result = wait4pid(childpid, &status, 0);
4236 } while (result == -1 && errno == EINTR);
4238 #ifdef HAS_SIGPROCMASK
4239 sigprocmask(SIG_SETMASK, &oldset, NULL);
4241 (void)rsignal_restore(SIGINT, &ihand);
4242 (void)rsignal_restore(SIGQUIT, &qhand);
4244 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4245 do_execfree(); /* free any memory child malloced on fork */
4252 while (n < sizeof(int)) {
4253 n1 = PerlLIO_read(pp[0],
4254 (void*)(((char*)&errkid)+n),
4260 PerlLIO_close(pp[0]);
4261 if (n) { /* Error */
4262 if (n != sizeof(int))
4263 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4264 errno = errkid; /* Propagate errno from kid */
4265 STATUS_NATIVE_CHILD_SET(-1);
4268 XPUSHi(STATUS_CURRENT);
4271 #ifdef HAS_SIGPROCMASK
4272 sigprocmask(SIG_SETMASK, &oldset, NULL);
4275 PerlLIO_close(pp[0]);
4276 #if defined(HAS_FCNTL) && defined(F_SETFD)
4277 if (fcntl(pp[1], F_SETFD, FD_CLOEXEC) < 0)
4281 if (PL_op->op_flags & OPf_STACKED) {
4282 SV * const really = *++MARK;
4283 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4285 else if (SP - MARK != 1)
4286 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4288 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4292 #else /* ! FORK or VMS or OS/2 */
4295 if (PL_op->op_flags & OPf_STACKED) {
4296 SV * const really = *++MARK;
4297 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4298 value = (I32)do_aspawn(really, MARK, SP);
4300 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4303 else if (SP - MARK != 1) {
4304 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4305 value = (I32)do_aspawn(NULL, MARK, SP);
4307 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4311 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4313 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4315 STATUS_NATIVE_CHILD_SET(value);
4318 XPUSHi(result ? value : STATUS_CURRENT);
4319 #endif /* !FORK or VMS or OS/2 */
4326 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4331 while (++MARK <= SP) {
4332 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4337 TAINT_PROPER("exec");
4339 PERL_FLUSHALL_FOR_CHILD;
4340 if (PL_op->op_flags & OPf_STACKED) {
4341 SV * const really = *++MARK;
4342 value = (I32)do_aexec(really, MARK, SP);
4344 else if (SP - MARK != 1)
4346 value = (I32)vms_do_aexec(NULL, MARK, SP);
4348 value = (I32)do_aexec(NULL, MARK, SP);
4352 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4354 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4367 XPUSHi( getppid() );
4370 DIE(aTHX_ PL_no_func, "getppid");
4380 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4383 pgrp = (I32)BSD_GETPGRP(pid);
4385 if (pid != 0 && pid != PerlProc_getpid())
4386 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4392 DIE(aTHX_ PL_no_func, "getpgrp()");
4402 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4403 if (MAXARG > 0) pid = TOPs && TOPi;
4409 TAINT_PROPER("setpgrp");
4411 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4413 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4414 || (pid != 0 && pid != PerlProc_getpid()))
4416 DIE(aTHX_ "setpgrp can't take arguments");
4418 SETi( setpgrp() >= 0 );
4419 #endif /* USE_BSDPGRP */
4422 DIE(aTHX_ PL_no_func, "setpgrp()");
4426 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4427 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4429 # define PRIORITY_WHICH_T(which) which
4434 #ifdef HAS_GETPRIORITY
4436 const int who = POPi;
4437 const int which = TOPi;
4438 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4441 DIE(aTHX_ PL_no_func, "getpriority()");
4447 #ifdef HAS_SETPRIORITY
4449 const int niceval = POPi;
4450 const int who = POPi;
4451 const int which = TOPi;
4452 TAINT_PROPER("setpriority");
4453 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4456 DIE(aTHX_ PL_no_func, "setpriority()");
4460 #undef PRIORITY_WHICH_T
4468 XPUSHn( time(NULL) );
4470 XPUSHi( time(NULL) );
4480 struct tms timesbuf;
4483 (void)PerlProc_times(×buf);
4485 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4486 if (GIMME == G_ARRAY) {
4487 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4488 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4489 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4497 if (GIMME == G_ARRAY) {
4504 DIE(aTHX_ "times not implemented");
4506 #endif /* HAS_TIMES */
4509 /* The 32 bit int year limits the times we can represent to these
4510 boundaries with a few days wiggle room to account for time zone
4513 /* Sat Jan 3 00:00:00 -2147481748 */
4514 #define TIME_LOWER_BOUND -67768100567755200.0
4515 /* Sun Dec 29 12:00:00 2147483647 */
4516 #define TIME_UPPER_BOUND 67767976233316800.0
4525 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4526 static const char * const dayname[] =
4527 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4528 static const char * const monname[] =
4529 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4530 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4532 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4535 when = (Time64_T)now;
4538 NV input = Perl_floor(POPn);
4539 when = (Time64_T)input;
4540 if (when != input) {
4541 /* diag_listed_as: gmtime(%f) too large */
4542 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4543 "%s(%.0" NVff ") too large", opname, input);
4547 if ( TIME_LOWER_BOUND > when ) {
4548 /* diag_listed_as: gmtime(%f) too small */
4549 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4550 "%s(%.0" NVff ") too small", opname, when);
4553 else if( when > TIME_UPPER_BOUND ) {
4554 /* diag_listed_as: gmtime(%f) too small */
4555 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4556 "%s(%.0" NVff ") too large", opname, when);
4560 if (PL_op->op_type == OP_LOCALTIME)
4561 err = S_localtime64_r(&when, &tmbuf);
4563 err = S_gmtime64_r(&when, &tmbuf);
4567 /* diag_listed_as: gmtime(%f) failed */
4568 /* XXX %lld broken for quads */
4569 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4570 "%s(%.0" NVff ") failed", opname, when);
4573 if (GIMME != G_ARRAY) { /* scalar context */
4579 mPUSHs(Perl_newSVpvf(aTHX_ "%s %s %2d %02d:%02d:%02d %.0f",
4580 dayname[tmbuf.tm_wday],
4581 monname[tmbuf.tm_mon],
4586 /* XXX newSVpvf()'s %lld type is broken,
4587 * so cheat with a double */
4588 (double)tmbuf.tm_year + 1900));
4591 else { /* list context */
4597 mPUSHi(tmbuf.tm_sec);
4598 mPUSHi(tmbuf.tm_min);
4599 mPUSHi(tmbuf.tm_hour);
4600 mPUSHi(tmbuf.tm_mday);
4601 mPUSHi(tmbuf.tm_mon);
4602 mPUSHn(tmbuf.tm_year);
4603 mPUSHi(tmbuf.tm_wday);
4604 mPUSHi(tmbuf.tm_yday);
4605 mPUSHi(tmbuf.tm_isdst);
4616 anum = alarm((unsigned int)anum);
4622 DIE(aTHX_ PL_no_func, "alarm");
4633 (void)time(&lasttime);
4634 if (MAXARG < 1 || (!TOPs && !POPs))
4638 PerlProc_sleep((unsigned int)duration);
4641 XPUSHi(when - lasttime);
4645 /* Shared memory. */
4646 /* Merged with some message passing. */
4650 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4651 dVAR; dSP; dMARK; dTARGET;
4652 const int op_type = PL_op->op_type;
4657 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4660 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4663 value = (I32)(do_semop(MARK, SP) >= 0);
4666 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4674 return Perl_pp_semget(aTHX);
4682 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4683 dVAR; dSP; dMARK; dTARGET;
4684 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4691 DIE(aTHX_ "System V IPC is not implemented on this machine");
4697 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4698 dVAR; dSP; dMARK; dTARGET;
4699 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4707 PUSHp(zero_but_true, ZBTLEN);
4711 return Perl_pp_semget(aTHX);
4715 /* I can't const this further without getting warnings about the types of
4716 various arrays passed in from structures. */
4718 S_space_join_names_mortal(pTHX_ char *const *array)
4722 PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL;
4724 if (array && *array) {
4725 target = newSVpvs_flags("", SVs_TEMP);
4727 sv_catpv(target, *array);
4730 sv_catpvs(target, " ");
4733 target = sv_mortalcopy(&PL_sv_no);
4738 /* Get system info. */
4742 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4744 I32 which = PL_op->op_type;
4747 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4748 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4749 struct hostent *gethostbyname(Netdb_name_t);
4750 struct hostent *gethostent(void);
4752 struct hostent *hent = NULL;
4756 if (which == OP_GHBYNAME) {
4757 #ifdef HAS_GETHOSTBYNAME
4758 const char* const name = POPpbytex;
4759 hent = PerlSock_gethostbyname(name);
4761 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
4764 else if (which == OP_GHBYADDR) {
4765 #ifdef HAS_GETHOSTBYADDR
4766 const int addrtype = POPi;
4767 SV * const addrsv = POPs;
4769 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
4771 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
4773 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
4777 #ifdef HAS_GETHOSTENT
4778 hent = PerlSock_gethostent();
4780 DIE(aTHX_ PL_no_sock_func, "gethostent");
4783 #ifdef HOST_NOT_FOUND
4785 #ifdef USE_REENTRANT_API
4786 # ifdef USE_GETHOSTENT_ERRNO
4787 h_errno = PL_reentrant_buffer->_gethostent_errno;
4790 STATUS_UNIX_SET(h_errno);
4794 if (GIMME != G_ARRAY) {
4795 PUSHs(sv = sv_newmortal());
4797 if (which == OP_GHBYNAME) {
4799 sv_setpvn(sv, hent->h_addr, hent->h_length);
4802 sv_setpv(sv, (char*)hent->h_name);
4808 mPUSHs(newSVpv((char*)hent->h_name, 0));
4809 PUSHs(space_join_names_mortal(hent->h_aliases));
4810 mPUSHi(hent->h_addrtype);
4811 len = hent->h_length;
4814 for (elem = hent->h_addr_list; elem && *elem; elem++) {
4815 mXPUSHp(*elem, len);
4819 mPUSHp(hent->h_addr, len);
4821 PUSHs(sv_mortalcopy(&PL_sv_no));
4826 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4832 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
4834 I32 which = PL_op->op_type;
4836 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
4837 struct netent *getnetbyaddr(Netdb_net_t, int);
4838 struct netent *getnetbyname(Netdb_name_t);
4839 struct netent *getnetent(void);
4841 struct netent *nent;
4843 if (which == OP_GNBYNAME){
4844 #ifdef HAS_GETNETBYNAME
4845 const char * const name = POPpbytex;
4846 nent = PerlSock_getnetbyname(name);
4848 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
4851 else if (which == OP_GNBYADDR) {
4852 #ifdef HAS_GETNETBYADDR
4853 const int addrtype = POPi;
4854 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
4855 nent = PerlSock_getnetbyaddr(addr, addrtype);
4857 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
4861 #ifdef HAS_GETNETENT
4862 nent = PerlSock_getnetent();
4864 DIE(aTHX_ PL_no_sock_func, "getnetent");
4867 #ifdef HOST_NOT_FOUND
4869 #ifdef USE_REENTRANT_API
4870 # ifdef USE_GETNETENT_ERRNO
4871 h_errno = PL_reentrant_buffer->_getnetent_errno;
4874 STATUS_UNIX_SET(h_errno);
4879 if (GIMME != G_ARRAY) {
4880 PUSHs(sv = sv_newmortal());
4882 if (which == OP_GNBYNAME)
4883 sv_setiv(sv, (IV)nent->n_net);
4885 sv_setpv(sv, nent->n_name);
4891 mPUSHs(newSVpv(nent->n_name, 0));
4892 PUSHs(space_join_names_mortal(nent->n_aliases));
4893 mPUSHi(nent->n_addrtype);
4894 mPUSHi(nent->n_net);
4899 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4905 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
4907 I32 which = PL_op->op_type;
4909 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
4910 struct protoent *getprotobyname(Netdb_name_t);
4911 struct protoent *getprotobynumber(int);
4912 struct protoent *getprotoent(void);
4914 struct protoent *pent;
4916 if (which == OP_GPBYNAME) {
4917 #ifdef HAS_GETPROTOBYNAME
4918 const char* const name = POPpbytex;
4919 pent = PerlSock_getprotobyname(name);
4921 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
4924 else if (which == OP_GPBYNUMBER) {
4925 #ifdef HAS_GETPROTOBYNUMBER
4926 const int number = POPi;
4927 pent = PerlSock_getprotobynumber(number);
4929 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
4933 #ifdef HAS_GETPROTOENT
4934 pent = PerlSock_getprotoent();
4936 DIE(aTHX_ PL_no_sock_func, "getprotoent");
4940 if (GIMME != G_ARRAY) {
4941 PUSHs(sv = sv_newmortal());
4943 if (which == OP_GPBYNAME)
4944 sv_setiv(sv, (IV)pent->p_proto);
4946 sv_setpv(sv, pent->p_name);
4952 mPUSHs(newSVpv(pent->p_name, 0));
4953 PUSHs(space_join_names_mortal(pent->p_aliases));
4954 mPUSHi(pent->p_proto);
4959 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4965 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
4967 I32 which = PL_op->op_type;
4969 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
4970 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
4971 struct servent *getservbyport(int, Netdb_name_t);
4972 struct servent *getservent(void);
4974 struct servent *sent;
4976 if (which == OP_GSBYNAME) {
4977 #ifdef HAS_GETSERVBYNAME
4978 const char * const proto = POPpbytex;
4979 const char * const name = POPpbytex;
4980 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
4982 DIE(aTHX_ PL_no_sock_func, "getservbyname");
4985 else if (which == OP_GSBYPORT) {
4986 #ifdef HAS_GETSERVBYPORT
4987 const char * const proto = POPpbytex;
4988 unsigned short port = (unsigned short)POPu;
4989 port = PerlSock_htons(port);
4990 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
4992 DIE(aTHX_ PL_no_sock_func, "getservbyport");
4996 #ifdef HAS_GETSERVENT
4997 sent = PerlSock_getservent();
4999 DIE(aTHX_ PL_no_sock_func, "getservent");
5003 if (GIMME != G_ARRAY) {
5004 PUSHs(sv = sv_newmortal());
5006 if (which == OP_GSBYNAME) {
5007 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5010 sv_setpv(sv, sent->s_name);
5016 mPUSHs(newSVpv(sent->s_name, 0));
5017 PUSHs(space_join_names_mortal(sent->s_aliases));
5018 mPUSHi(PerlSock_ntohs(sent->s_port));
5019 mPUSHs(newSVpv(sent->s_proto, 0));
5024 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5031 const int stayopen = TOPi;
5032 switch(PL_op->op_type) {
5034 #ifdef HAS_SETHOSTENT
5035 PerlSock_sethostent(stayopen);
5037 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5040 #ifdef HAS_SETNETENT
5042 PerlSock_setnetent(stayopen);
5044 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5048 #ifdef HAS_SETPROTOENT
5049 PerlSock_setprotoent(stayopen);
5051 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5055 #ifdef HAS_SETSERVENT
5056 PerlSock_setservent(stayopen);
5058 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5068 switch(PL_op->op_type) {
5070 #ifdef HAS_ENDHOSTENT
5071 PerlSock_endhostent();
5073 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5077 #ifdef HAS_ENDNETENT
5078 PerlSock_endnetent();
5080 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5084 #ifdef HAS_ENDPROTOENT
5085 PerlSock_endprotoent();
5087 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5091 #ifdef HAS_ENDSERVENT
5092 PerlSock_endservent();
5094 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5098 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5101 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5105 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5108 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5112 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5115 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5119 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5122 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5134 I32 which = PL_op->op_type;
5136 struct passwd *pwent = NULL;
5138 * We currently support only the SysV getsp* shadow password interface.
5139 * The interface is declared in <shadow.h> and often one needs to link
5140 * with -lsecurity or some such.
5141 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5144 * AIX getpwnam() is clever enough to return the encrypted password
5145 * only if the caller (euid?) is root.
5147 * There are at least three other shadow password APIs. Many platforms
5148 * seem to contain more than one interface for accessing the shadow
5149 * password databases, possibly for compatibility reasons.
5150 * The getsp*() is by far he simplest one, the other two interfaces
5151 * are much more complicated, but also very similar to each other.
5156 * struct pr_passwd *getprpw*();
5157 * The password is in
5158 * char getprpw*(...).ufld.fd_encrypt[]
5159 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5164 * struct es_passwd *getespw*();
5165 * The password is in
5166 * char *(getespw*(...).ufld.fd_encrypt)
5167 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5170 * struct userpw *getuserpw();
5171 * The password is in
5172 * char *(getuserpw(...)).spw_upw_passwd
5173 * (but the de facto standard getpwnam() should work okay)
5175 * Mention I_PROT here so that Configure probes for it.
5177 * In HP-UX for getprpw*() the manual page claims that one should include
5178 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5179 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5180 * and pp_sys.c already includes <shadow.h> if there is such.
5182 * Note that <sys/security.h> is already probed for, but currently
5183 * it is only included in special cases.
5185 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5186 * be preferred interface, even though also the getprpw*() interface
5187 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5188 * One also needs to call set_auth_parameters() in main() before
5189 * doing anything else, whether one is using getespw*() or getprpw*().
5191 * Note that accessing the shadow databases can be magnitudes
5192 * slower than accessing the standard databases.
5197 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5198 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5199 * the pw_comment is left uninitialized. */
5200 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5206 const char* const name = POPpbytex;
5207 pwent = getpwnam(name);
5213 pwent = getpwuid(uid);
5217 # ifdef HAS_GETPWENT
5219 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5220 if (pwent) pwent = getpwnam(pwent->pw_name);
5223 DIE(aTHX_ PL_no_func, "getpwent");
5229 if (GIMME != G_ARRAY) {
5230 PUSHs(sv = sv_newmortal());
5232 if (which == OP_GPWNAM)
5233 sv_setuid(sv, pwent->pw_uid);
5235 sv_setpv(sv, pwent->pw_name);
5241 mPUSHs(newSVpv(pwent->pw_name, 0));
5245 /* If we have getspnam(), we try to dig up the shadow
5246 * password. If we are underprivileged, the shadow
5247 * interface will set the errno to EACCES or similar,
5248 * and return a null pointer. If this happens, we will
5249 * use the dummy password (usually "*" or "x") from the
5250 * standard password database.
5252 * In theory we could skip the shadow call completely
5253 * if euid != 0 but in practice we cannot know which
5254 * security measures are guarding the shadow databases
5255 * on a random platform.
5257 * Resist the urge to use additional shadow interfaces.
5258 * Divert the urge to writing an extension instead.
5261 /* Some AIX setups falsely(?) detect some getspnam(), which
5262 * has a different API than the Solaris/IRIX one. */
5263 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5266 const struct spwd * const spwent = getspnam(pwent->pw_name);
5267 /* Save and restore errno so that
5268 * underprivileged attempts seem
5269 * to have never made the unsuccessful
5270 * attempt to retrieve the shadow password. */
5272 if (spwent && spwent->sp_pwdp)
5273 sv_setpv(sv, spwent->sp_pwdp);
5277 if (!SvPOK(sv)) /* Use the standard password, then. */
5278 sv_setpv(sv, pwent->pw_passwd);
5281 /* passwd is tainted because user himself can diddle with it.
5282 * admittedly not much and in a very limited way, but nevertheless. */
5285 sv_setuid(PUSHmortal, pwent->pw_uid);
5286 sv_setgid(PUSHmortal, pwent->pw_gid);
5288 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5289 * because of the poor interface of the Perl getpw*(),
5290 * not because there's some standard/convention saying so.
5291 * A better interface would have been to return a hash,
5292 * but we are accursed by our history, alas. --jhi. */
5294 mPUSHi(pwent->pw_change);
5297 mPUSHi(pwent->pw_quota);
5300 mPUSHs(newSVpv(pwent->pw_age, 0));
5302 /* I think that you can never get this compiled, but just in case. */
5303 PUSHs(sv_mortalcopy(&PL_sv_no));
5308 /* pw_class and pw_comment are mutually exclusive--.
5309 * see the above note for pw_change, pw_quota, and pw_age. */
5311 mPUSHs(newSVpv(pwent->pw_class, 0));
5314 mPUSHs(newSVpv(pwent->pw_comment, 0));
5316 /* I think that you can never get this compiled, but just in case. */
5317 PUSHs(sv_mortalcopy(&PL_sv_no));
5322 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5324 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5326 /* pw_gecos is tainted because user himself can diddle with it. */
5329 mPUSHs(newSVpv(pwent->pw_dir, 0));
5331 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5332 /* pw_shell is tainted because user himself can diddle with it. */
5336 mPUSHi(pwent->pw_expire);
5341 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5349 const I32 which = PL_op->op_type;
5350 const struct group *grent;
5352 if (which == OP_GGRNAM) {
5353 const char* const name = POPpbytex;
5354 grent = (const struct group *)getgrnam(name);
5356 else if (which == OP_GGRGID) {
5357 const Gid_t gid = POPi;
5358 grent = (const struct group *)getgrgid(gid);
5362 grent = (struct group *)getgrent();
5364 DIE(aTHX_ PL_no_func, "getgrent");
5368 if (GIMME != G_ARRAY) {
5369 SV * const sv = sv_newmortal();
5373 if (which == OP_GGRNAM)
5374 sv_setgid(sv, grent->gr_gid);
5376 sv_setpv(sv, grent->gr_name);
5382 mPUSHs(newSVpv(grent->gr_name, 0));
5385 mPUSHs(newSVpv(grent->gr_passwd, 0));
5387 PUSHs(sv_mortalcopy(&PL_sv_no));
5390 sv_setgid(PUSHmortal, grent->gr_gid);
5392 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5393 /* In UNICOS/mk (_CRAYMPP) the multithreading
5394 * versions (getgrnam_r, getgrgid_r)
5395 * seem to return an illegal pointer
5396 * as the group members list, gr_mem.
5397 * getgrent() doesn't even have a _r version
5398 * but the gr_mem is poisonous anyway.
5399 * So yes, you cannot get the list of group
5400 * members if building multithreaded in UNICOS/mk. */
5401 PUSHs(space_join_names_mortal(grent->gr_mem));
5407 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5417 if (!(tmps = PerlProc_getlogin()))
5419 sv_setpv_mg(TARG, tmps);
5423 DIE(aTHX_ PL_no_func, "getlogin");
5427 /* Miscellaneous. */
5432 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
5433 I32 items = SP - MARK;
5434 unsigned long a[20];
5439 while (++MARK <= SP) {
5440 if (SvTAINTED(*MARK)) {
5446 TAINT_PROPER("syscall");
5449 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5450 * or where sizeof(long) != sizeof(char*). But such machines will
5451 * not likely have syscall implemented either, so who cares?
5453 while (++MARK <= SP) {
5454 if (SvNIOK(*MARK) || !i)
5455 a[i++] = SvIV(*MARK);
5456 else if (*MARK == &PL_sv_undef)
5459 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5465 DIE(aTHX_ "Too many args to syscall");
5467 DIE(aTHX_ "Too few args to syscall");
5469 retval = syscall(a[0]);
5472 retval = syscall(a[0],a[1]);
5475 retval = syscall(a[0],a[1],a[2]);
5478 retval = syscall(a[0],a[1],a[2],a[3]);
5481 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5484 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5487 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5490 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5497 DIE(aTHX_ PL_no_func, "syscall");
5501 #ifdef FCNTL_EMULATE_FLOCK
5503 /* XXX Emulate flock() with fcntl().
5504 What's really needed is a good file locking module.
5508 fcntl_emulate_flock(int fd, int operation)
5513 switch (operation & ~LOCK_NB) {
5515 flock.l_type = F_RDLCK;
5518 flock.l_type = F_WRLCK;
5521 flock.l_type = F_UNLCK;
5527 flock.l_whence = SEEK_SET;
5528 flock.l_start = flock.l_len = (Off_t)0;
5530 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5531 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5532 errno = EWOULDBLOCK;
5536 #endif /* FCNTL_EMULATE_FLOCK */
5538 #ifdef LOCKF_EMULATE_FLOCK
5540 /* XXX Emulate flock() with lockf(). This is just to increase
5541 portability of scripts. The calls are not completely
5542 interchangeable. What's really needed is a good file
5546 /* The lockf() constants might have been defined in <unistd.h>.
5547 Unfortunately, <unistd.h> causes troubles on some mixed
5548 (BSD/POSIX) systems, such as SunOS 4.1.3.
5550 Further, the lockf() constants aren't POSIX, so they might not be
5551 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5552 just stick in the SVID values and be done with it. Sigh.
5556 # define F_ULOCK 0 /* Unlock a previously locked region */
5559 # define F_LOCK 1 /* Lock a region for exclusive use */
5562 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5565 # define F_TEST 3 /* Test a region for other processes locks */
5569 lockf_emulate_flock(int fd, int operation)
5575 /* flock locks entire file so for lockf we need to do the same */
5576 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5577 if (pos > 0) /* is seekable and needs to be repositioned */
5578 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5579 pos = -1; /* seek failed, so don't seek back afterwards */
5582 switch (operation) {
5584 /* LOCK_SH - get a shared lock */
5586 /* LOCK_EX - get an exclusive lock */
5588 i = lockf (fd, F_LOCK, 0);
5591 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5592 case LOCK_SH|LOCK_NB:
5593 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5594 case LOCK_EX|LOCK_NB:
5595 i = lockf (fd, F_TLOCK, 0);
5597 if ((errno == EAGAIN) || (errno == EACCES))
5598 errno = EWOULDBLOCK;
5601 /* LOCK_UN - unlock (non-blocking is a no-op) */
5603 case LOCK_UN|LOCK_NB:
5604 i = lockf (fd, F_ULOCK, 0);
5607 /* Default - can't decipher operation */
5614 if (pos > 0) /* need to restore position of the handle */
5615 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5620 #endif /* LOCKF_EMULATE_FLOCK */
5624 * c-indentation-style: bsd
5626 * indent-tabs-mode: nil
5629 * ex: set ts=8 sts=4 sw=4 et: