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>
185 /* Missing protos on LynxOS */
186 void sethostent(int);
187 void endhostent(void);
189 void endnetent(void);
190 void setprotoent(int);
191 void endprotoent(void);
192 void setservent(int);
193 void endservent(void);
196 #undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
198 /* F_OK unused: if stat() cannot find it... */
200 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
201 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
202 # define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
205 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
206 # ifdef I_SYS_SECURITY
207 # include <sys/security.h>
211 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
214 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
218 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
220 # define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
224 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
225 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
226 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
229 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
231 const Uid_t ruid = getuid();
232 const Uid_t euid = geteuid();
233 const Gid_t rgid = getgid();
234 const Gid_t egid = getegid();
237 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
238 Perl_croak(aTHX_ "switching effective uid is not implemented");
241 if (setreuid(euid, ruid))
244 if (setresuid(euid, ruid, (Uid_t)-1))
247 /* diag_listed_as: entering effective %s failed */
248 Perl_croak(aTHX_ "entering effective uid failed");
251 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
252 Perl_croak(aTHX_ "switching effective gid is not implemented");
255 if (setregid(egid, rgid))
258 if (setresgid(egid, rgid, (Gid_t)-1))
261 /* diag_listed_as: entering effective %s failed */
262 Perl_croak(aTHX_ "entering effective gid failed");
265 res = access(path, mode);
268 if (setreuid(ruid, euid))
271 if (setresuid(ruid, euid, (Uid_t)-1))
274 /* diag_listed_as: leaving effective %s failed */
275 Perl_croak(aTHX_ "leaving effective uid failed");
278 if (setregid(rgid, egid))
281 if (setresgid(rgid, egid, (Gid_t)-1))
284 /* diag_listed_as: leaving effective %s failed */
285 Perl_croak(aTHX_ "leaving effective gid failed");
289 # define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
296 const char * const tmps = POPpconstx;
297 const I32 gimme = GIMME_V;
298 const char *mode = "r";
301 if (PL_op->op_private & OPpOPEN_IN_RAW)
303 else if (PL_op->op_private & OPpOPEN_IN_CRLF)
305 fp = PerlProc_popen(tmps, mode);
307 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
309 PerlIO_apply_layers(aTHX_ fp,mode,type);
311 if (gimme == G_VOID) {
313 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
316 else if (gimme == G_SCALAR) {
317 ENTER_with_name("backtick");
319 PL_rs = &PL_sv_undef;
320 sv_setpvs(TARG, ""); /* note that this preserves previous buffer */
321 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
323 LEAVE_with_name("backtick");
329 SV * const sv = newSV(79);
330 if (sv_gets(sv, fp, 0) == NULL) {
335 if (SvLEN(sv) - SvCUR(sv) > 20) {
336 SvPV_shrink_to_cur(sv);
341 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
342 TAINT; /* "I believe that this is not gratuitous!" */
345 STATUS_NATIVE_CHILD_SET(-1);
346 if (gimme == G_SCALAR)
357 GV * const gv = (PL_op->op_flags & OPf_SPECIAL) ? NULL : (GV *)POPs;
361 /* make a copy of the pattern if it is gmagical, to ensure that magic
362 * is called once and only once */
363 if (SvGMAGICAL(TOPs)) TOPs = sv_2mortal(newSVsv(TOPs));
365 tryAMAGICunTARGETlist(iter_amg, (PL_op->op_flags & OPf_SPECIAL));
367 if (PL_op->op_flags & OPf_SPECIAL) {
368 /* call Perl-level glob function instead. Stack args are:
370 * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
379 /* Note that we only ever get here if File::Glob fails to load
380 * without at the same time croaking, for some reason, or if
381 * perl was built with PERL_EXTERNAL_GLOB */
383 ENTER_with_name("glob");
388 * The external globbing program may use things we can't control,
389 * so for security reasons we must assume the worst.
392 taint_proper(PL_no_security, "glob");
396 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
399 SAVESPTR(PL_rs); /* This is not permanent, either. */
400 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
403 *SvPVX(PL_rs) = '\n';
407 result = do_readline();
408 LEAVE_with_name("glob");
414 PL_last_in_gv = cGVOP_gv;
415 return do_readline();
425 do_join(TARG, &PL_sv_no, MARK, SP);
429 else if (SP == MARK) {
436 if (SvGMAGICAL(exsv)) exsv = sv_mortalcopy(exsv);
439 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
440 /* well-formed exception supplied */
443 SV * const errsv = ERRSV;
446 if (SvGMAGICAL(errsv)) {
447 exsv = sv_newmortal();
448 sv_setsv_nomg(exsv, errsv);
452 else if (SvPOKp(errsv) ? SvCUR(errsv) : SvNIOKp(errsv)) {
453 exsv = sv_newmortal();
454 sv_setsv_nomg(exsv, errsv);
455 sv_catpvs(exsv, "\t...caught");
458 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
461 if (SvROK(exsv) && !PL_warnhook)
462 Perl_warn(aTHX_ "%"SVf, SVfARG(exsv));
474 VMSISH_HUSHED || (PL_curcop->op_private & OPpHUSH_VMSISH);
476 if (SP - MARK != 1) {
478 do_join(TARG, &PL_sv_no, MARK, SP);
486 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
487 /* well-formed exception supplied */
490 SV * const errsv = ERRSV;
494 if (sv_isobject(exsv)) {
495 HV * const stash = SvSTASH(SvRV(exsv));
496 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
498 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
499 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
506 call_sv(MUTABLE_SV(GvCV(gv)),
507 G_SCALAR|G_EVAL|G_KEEPERR);
508 exsv = sv_mortalcopy(*PL_stack_sp--);
512 else if (SvPOK(errsv) && SvCUR(errsv)) {
513 exsv = sv_mortalcopy(errsv);
514 sv_catpvs(exsv, "\t...propagated");
517 exsv = newSVpvs_flags("Died", SVs_TEMP);
521 NOT_REACHED; /* NOTREACHED */
522 return NULL; /* avoid missing return from non-void function warning */
528 Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv,
529 const MAGIC *const mg, const U32 flags, U32 argc, ...)
534 PERL_ARGS_ASSERT_TIED_METHOD;
536 /* Ensure that our flag bits do not overlap. */
537 STATIC_ASSERT_STMT((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
538 STATIC_ASSERT_STMT((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
539 STATIC_ASSERT_STMT((TIED_METHOD_SAY & G_WANT) == 0);
541 PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
542 PUSHSTACKi(PERLSI_MAGIC);
543 EXTEND(SP, argc+1); /* object + args */
545 PUSHs(SvTIED_obj(sv, mg));
546 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
547 Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
551 const U32 mortalize_not_needed
552 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
554 va_start(args, argc);
556 SV *const arg = va_arg(args, SV *);
557 if(mortalize_not_needed)
566 ENTER_with_name("call_tied_method");
567 if (flags & TIED_METHOD_SAY) {
568 /* local $\ = "\n" */
569 SAVEGENERICSV(PL_ors_sv);
570 PL_ors_sv = newSVpvs("\n");
572 ret_args = call_sv(methname, (flags & G_WANT)|G_METHOD_NAMED);
577 if (ret_args) { /* copy results back to original stack */
578 EXTEND(sp, ret_args);
579 Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
583 LEAVE_with_name("call_tied_method");
587 #define tied_method0(a,b,c,d) \
588 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
589 #define tied_method1(a,b,c,d,e) \
590 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
591 #define tied_method2(a,b,c,d,e,f) \
592 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
605 GV * const gv = MUTABLE_GV(*++MARK);
607 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
608 DIE(aTHX_ PL_no_usym, "filehandle");
610 if ((io = GvIOp(gv))) {
612 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
615 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
616 "Opening dirhandle %"HEKf" also as a file",
617 HEKfARG(GvENAME_HEK(gv)));
619 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
621 /* Method's args are same as ours ... */
622 /* ... except handle is replaced by the object */
623 return Perl_tied_method(aTHX_ SV_CONST(OPEN), mark - 1, MUTABLE_SV(io), mg,
624 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
636 tmps = SvPV_const(sv, len);
637 ok = do_open6(gv, tmps, len, NULL, MARK+1, (SP-MARK));
640 PUSHi( (I32)PL_forkprocess );
641 else if (PL_forkprocess == 0) /* we are a new child */
652 MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
658 IO * const io = GvIO(gv);
660 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
662 return tied_method0(SV_CONST(CLOSE), SP, MUTABLE_SV(io), mg);
666 PUSHs(boolSV(do_close(gv, TRUE)));
678 GV * const wgv = MUTABLE_GV(POPs);
679 GV * const rgv = MUTABLE_GV(POPs);
681 assert (isGV_with_GP(rgv));
682 assert (isGV_with_GP(wgv));
685 do_close(rgv, FALSE);
689 do_close(wgv, FALSE);
691 if (PerlProc_pipe(fd) < 0)
694 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
695 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
696 IoOFP(rstio) = IoIFP(rstio);
697 IoIFP(wstio) = IoOFP(wstio);
698 IoTYPE(rstio) = IoTYPE_RDONLY;
699 IoTYPE(wstio) = IoTYPE_WRONLY;
701 if (!IoIFP(rstio) || !IoOFP(wstio)) {
703 PerlIO_close(IoIFP(rstio));
705 PerlLIO_close(fd[0]);
707 PerlIO_close(IoOFP(wstio));
709 PerlLIO_close(fd[1]);
712 #if defined(HAS_FCNTL) && defined(F_SETFD)
713 /* ensure close-on-exec */
714 if ((fcntl(fd[0], F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
715 (fcntl(fd[1], F_SETFD,fd[1] > PL_maxsysfd) < 0))
723 DIE(aTHX_ PL_no_func, "pipe");
737 gv = MUTABLE_GV(POPs);
741 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
743 return tied_method0(SV_CONST(FILENO), SP, MUTABLE_SV(io), mg);
746 if (io && IoDIRP(io)) {
747 #if defined(HAS_DIRFD) || defined(HAS_DIR_DD_FD)
748 PUSHi(my_dirfd(IoDIRP(io)));
750 #elif defined(ENOTSUP)
751 errno = ENOTSUP; /* Operation not supported */
753 #elif defined(EOPNOTSUPP)
754 errno = EOPNOTSUPP; /* Operation not supported on socket */
757 errno = EINVAL; /* Invalid argument */
762 if (!io || !(fp = IoIFP(io))) {
763 /* Can't do this because people seem to do things like
764 defined(fileno($foo)) to check whether $foo is a valid fh.
771 PUSHi(PerlIO_fileno(fp));
782 if (MAXARG < 1 || (!TOPs && !POPs)) {
783 anum = PerlLIO_umask(022);
784 /* setting it to 022 between the two calls to umask avoids
785 * to have a window where the umask is set to 0 -- meaning
786 * that another thread could create world-writeable files. */
788 (void)PerlLIO_umask(anum);
791 anum = PerlLIO_umask(POPi);
792 TAINT_PROPER("umask");
795 /* Only DIE if trying to restrict permissions on "user" (self).
796 * Otherwise it's harmless and more useful to just return undef
797 * since 'group' and 'other' concepts probably don't exist here. */
798 if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
799 DIE(aTHX_ "umask not implemented");
800 XPUSHs(&PL_sv_undef);
819 gv = MUTABLE_GV(POPs);
823 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
825 /* This takes advantage of the implementation of the varargs
826 function, which I don't think that the optimiser will be able to
827 figure out. Although, as it's a static function, in theory it
829 return Perl_tied_method(aTHX_ SV_CONST(BINMODE), SP, MUTABLE_SV(io), mg,
830 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
831 discp ? 1 : 0, discp);
835 if (!io || !(fp = IoIFP(io))) {
837 SETERRNO(EBADF,RMS_IFI);
844 const char *d = NULL;
847 d = SvPV_const(discp, len);
848 mode = mode_from_discipline(d, len);
849 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
850 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
851 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
872 const I32 markoff = MARK - PL_stack_base;
873 const char *methname;
874 int how = PERL_MAGIC_tied;
878 switch(SvTYPE(varsv)) {
882 methname = "TIEHASH";
883 if (HvLAZYDEL(varsv) && (entry = HvEITER((HV *)varsv))) {
884 HvLAZYDEL_off(varsv);
885 hv_free_ent((HV *)varsv, entry);
887 HvEITER_set(MUTABLE_HV(varsv), 0);
891 methname = "TIEARRAY";
892 if (!AvREAL(varsv)) {
894 Perl_croak(aTHX_ "Cannot tie unreifiable array");
895 av_clear((AV *)varsv);
902 if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
903 methname = "TIEHANDLE";
904 how = PERL_MAGIC_tiedscalar;
905 /* For tied filehandles, we apply tiedscalar magic to the IO
906 slot of the GP rather than the GV itself. AMS 20010812 */
908 GvIOp(varsv) = newIO();
909 varsv = MUTABLE_SV(GvIOp(varsv));
912 if (SvTYPE(varsv) == SVt_PVLV && LvTYPE(varsv) == 'y') {
913 vivify_defelem(varsv);
914 varsv = LvTARG(varsv);
918 methname = "TIESCALAR";
919 how = PERL_MAGIC_tiedscalar;
923 if (sv_isobject(*MARK)) { /* Calls GET magic. */
924 ENTER_with_name("call_TIE");
925 PUSHSTACKi(PERLSI_MAGIC);
927 EXTEND(SP,(I32)items);
931 call_method(methname, G_SCALAR);
934 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
935 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
936 * wrong error message, and worse case, supreme action at a distance.
937 * (Sorry obfuscation writers. You're not going to be given this one.)
939 stash = gv_stashsv(*MARK, 0);
940 if (!stash || !(gv = gv_fetchmethod(stash, methname))) {
941 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"",
942 methname, SVfARG(SvOK(*MARK) ? *MARK : &PL_sv_no));
944 ENTER_with_name("call_TIE");
945 PUSHSTACKi(PERLSI_MAGIC);
947 EXTEND(SP,(I32)items);
951 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
957 if (sv_isobject(sv)) {
958 sv_unmagic(varsv, how);
959 /* Croak if a self-tie on an aggregate is attempted. */
960 if (varsv == SvRV(sv) &&
961 (SvTYPE(varsv) == SVt_PVAV ||
962 SvTYPE(varsv) == SVt_PVHV))
964 "Self-ties of arrays and hashes are not supported");
965 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
967 LEAVE_with_name("call_TIE");
968 SP = PL_stack_base + markoff;
974 /* also used for: pp_dbmclose() */
981 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
982 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
984 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
987 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
988 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
990 if ((mg = SvTIED_mg(sv, how))) {
991 SV * const obj = SvRV(SvTIED_obj(sv, mg));
993 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
995 if (gv && isGV(gv) && (cv = GvCV(gv))) {
997 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
998 mXPUSHi(SvREFCNT(obj) - 1);
1000 ENTER_with_name("call_UNTIE");
1001 call_sv(MUTABLE_SV(cv), G_VOID);
1002 LEAVE_with_name("call_UNTIE");
1005 else if (mg && SvREFCNT(obj) > 1) {
1006 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
1007 "untie attempted while %"UVuf" inner references still exist",
1008 (UV)SvREFCNT(obj) - 1 ) ;
1012 sv_unmagic(sv, how) ;
1021 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1022 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1024 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1027 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1028 !(sv = defelem_target(sv, NULL))) goto ret_undef;
1030 if ((mg = SvTIED_mg(sv, how))) {
1031 SETs(SvTIED_obj(sv, mg));
1032 return NORMAL; /* PUTBACK not needed, pp_tied never moves SP */
1046 HV * const hv = MUTABLE_HV(POPs);
1047 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1048 stash = gv_stashsv(sv, 0);
1049 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1051 require_pv("AnyDBM_File.pm");
1053 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1054 DIE(aTHX_ "No dbm on this machine");
1064 mPUSHu(O_RDWR|O_CREAT);
1068 if (!SvOK(right)) right = &PL_sv_no;
1072 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1075 if (!sv_isobject(TOPs)) {
1083 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1087 if (sv_isobject(TOPs)) {
1088 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1089 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1106 struct timeval timebuf;
1107 struct timeval *tbuf = &timebuf;
1110 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1115 # if BYTEORDER & 0xf0000
1116 # define ORDERBYTE (0x88888888 - BYTEORDER)
1118 # define ORDERBYTE (0x4444 - BYTEORDER)
1124 for (i = 1; i <= 3; i++) {
1125 SV * const sv = SP[i];
1129 if (SvREADONLY(sv)) {
1130 if (!(SvPOK(sv) && SvCUR(sv) == 0))
1131 Perl_croak_no_modify();
1133 else if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
1136 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1137 "Non-string passed as bitmask");
1138 SvPV_force_nomg_nolen(sv); /* force string conversion */
1145 /* little endians can use vecs directly */
1146 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1153 masksize = NFDBITS / NBBY;
1155 masksize = sizeof(long); /* documented int, everyone seems to use long */
1157 Zero(&fd_sets[0], 4, char*);
1160 # if SELECT_MIN_BITS == 1
1161 growsize = sizeof(fd_set);
1163 # if defined(__GLIBC__) && defined(__FD_SETSIZE)
1164 # undef SELECT_MIN_BITS
1165 # define SELECT_MIN_BITS __FD_SETSIZE
1167 /* If SELECT_MIN_BITS is greater than one we most probably will want
1168 * to align the sizes with SELECT_MIN_BITS/8 because for example
1169 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1170 * UNIX, Solaris, Darwin) the smallest quantum select() operates
1171 * on (sets/tests/clears bits) is 32 bits. */
1172 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1178 value = SvNV_nomg(sv);
1181 timebuf.tv_sec = (long)value;
1182 value -= (NV)timebuf.tv_sec;
1183 timebuf.tv_usec = (long)(value * 1000000.0);
1188 for (i = 1; i <= 3; i++) {
1190 if (!SvOK(sv) || SvCUR(sv) == 0) {
1197 Sv_Grow(sv, growsize);
1201 while (++j <= growsize) {
1205 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1207 Newx(fd_sets[i], growsize, char);
1208 for (offset = 0; offset < growsize; offset += masksize) {
1209 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1210 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1213 fd_sets[i] = SvPVX(sv);
1217 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1218 /* Can't make just the (void*) conditional because that would be
1219 * cpp #if within cpp macro, and not all compilers like that. */
1220 nfound = PerlSock_select(
1222 (Select_fd_set_t) fd_sets[1],
1223 (Select_fd_set_t) fd_sets[2],
1224 (Select_fd_set_t) fd_sets[3],
1225 (void*) tbuf); /* Workaround for compiler bug. */
1227 nfound = PerlSock_select(
1229 (Select_fd_set_t) fd_sets[1],
1230 (Select_fd_set_t) fd_sets[2],
1231 (Select_fd_set_t) fd_sets[3],
1234 for (i = 1; i <= 3; i++) {
1237 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1239 for (offset = 0; offset < growsize; offset += masksize) {
1240 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1241 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1243 Safefree(fd_sets[i]);
1250 if (GIMME == G_ARRAY && tbuf) {
1251 value = (NV)(timebuf.tv_sec) +
1252 (NV)(timebuf.tv_usec) / 1000000.0;
1257 DIE(aTHX_ "select not implemented");
1265 =for apidoc setdefout
1267 Sets PL_defoutgv, the default file handle for output, to the passed in
1268 typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference
1269 count of the passed in typeglob is increased by one, and the reference count
1270 of the typeglob that PL_defoutgv points to is decreased by one.
1276 Perl_setdefout(pTHX_ GV *gv)
1278 PERL_ARGS_ASSERT_SETDEFOUT;
1279 SvREFCNT_inc_simple_void_NN(gv);
1280 SvREFCNT_dec(PL_defoutgv);
1288 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1289 GV * egv = GvEGVx(PL_defoutgv);
1294 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1295 gvp = hv && HvENAME(hv)
1296 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1298 if (gvp && *gvp == egv) {
1299 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1303 mXPUSHs(newRV(MUTABLE_SV(egv)));
1307 if (!GvIO(newdefout))
1308 gv_IOadd(newdefout);
1309 setdefout(newdefout);
1319 MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1320 IO *const io = GvIO(gv);
1326 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1328 const U32 gimme = GIMME_V;
1329 Perl_tied_method(aTHX_ SV_CONST(GETC), SP, MUTABLE_SV(io), mg, gimme, 0);
1330 if (gimme == G_SCALAR) {
1332 SvSetMagicSV_nosteal(TARG, TOPs);
1337 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1338 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1340 SETERRNO(EBADF,RMS_IFI);
1344 sv_setpvs(TARG, " ");
1345 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1346 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1347 /* Find out how many bytes the char needs */
1348 Size_t len = UTF8SKIP(SvPVX_const(TARG));
1351 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1352 SvCUR_set(TARG,1+len);
1356 else SvUTF8_off(TARG);
1362 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1365 const I32 gimme = GIMME_V;
1367 PERL_ARGS_ASSERT_DOFORM;
1370 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1375 PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
1376 PUSHFORMAT(cx, retop);
1377 if (CvDEPTH(cv) >= 2) {
1378 PERL_STACK_OVERFLOW_CHECK();
1379 pad_push(CvPADLIST(cv), CvDEPTH(cv));
1382 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), CvDEPTH(cv));
1384 setdefout(gv); /* locally select filehandle so $% et al work */
1402 gv = MUTABLE_GV(POPs);
1419 tmpsv = sv_newmortal();
1420 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1421 DIE(aTHX_ "Undefined format \"%"SVf"\" called", SVfARG(tmpsv));
1423 IoFLAGS(io) &= ~IOf_DIDTOP;
1424 RETURNOP(doform(cv,gv,PL_op->op_next));
1430 GV * const gv = cxstack[cxstack_ix].blk_format.gv;
1431 IO * const io = GvIOp(gv);
1439 if (!io || !(ofp = IoOFP(io)))
1442 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1443 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1445 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1446 PL_formtarget != PL_toptarget)
1450 if (!IoTOP_GV(io)) {
1453 if (!IoTOP_NAME(io)) {
1455 if (!IoFMT_NAME(io))
1456 IoFMT_NAME(io) = savepv(GvNAME(gv));
1457 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%"HEKf"_TOP",
1458 HEKfARG(GvNAME_HEK(gv))));
1459 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1460 if ((topgv && GvFORM(topgv)) ||
1461 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1462 IoTOP_NAME(io) = savesvpv(topname);
1464 IoTOP_NAME(io) = savepvs("top");
1466 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1467 if (!topgv || !GvFORM(topgv)) {
1468 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1471 IoTOP_GV(io) = topgv;
1473 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1474 I32 lines = IoLINES_LEFT(io);
1475 const char *s = SvPVX_const(PL_formtarget);
1476 if (lines <= 0) /* Yow, header didn't even fit!!! */
1478 while (lines-- > 0) {
1479 s = strchr(s, '\n');
1485 const STRLEN save = SvCUR(PL_formtarget);
1486 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1487 do_print(PL_formtarget, ofp);
1488 SvCUR_set(PL_formtarget, save);
1489 sv_chop(PL_formtarget, s);
1490 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1493 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1494 do_print(GvSV(gv_fetchpvs("\f", GV_ADD, SVt_PV)), ofp);
1495 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1497 PL_formtarget = PL_toptarget;
1498 IoFLAGS(io) |= IOf_DIDTOP;
1500 assert(fgv); /* IoTOP_GV(io) should have been set above */
1503 SV * const sv = sv_newmortal();
1504 gv_efullname4(sv, fgv, NULL, FALSE);
1505 DIE(aTHX_ "Undefined top format \"%"SVf"\" called", SVfARG(sv));
1507 return doform(cv, gv, PL_op);
1511 POPBLOCK(cx,PL_curpm);
1512 retop = cx->blk_sub.retop;
1514 SP = newsp; /* ignore retval of formline */
1517 if (!io || !(fp = IoOFP(io))) {
1518 if (io && IoIFP(io))
1519 report_wrongway_fh(gv, '<');
1525 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1526 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1528 if (!do_print(PL_formtarget, fp))
1531 FmLINES(PL_formtarget) = 0;
1532 SvCUR_set(PL_formtarget, 0);
1533 *SvEND(PL_formtarget) = '\0';
1534 if (IoFLAGS(io) & IOf_FLUSH)
1535 (void)PerlIO_flush(fp);
1539 PL_formtarget = PL_bodytarget;
1540 PERL_UNUSED_VAR(gimme);
1546 dSP; dMARK; dORIGMARK;
1550 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1551 IO *const io = GvIO(gv);
1553 /* Treat empty list as "" */
1554 if (MARK == SP) XPUSHs(&PL_sv_no);
1557 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1559 if (MARK == ORIGMARK) {
1562 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1565 return Perl_tied_method(aTHX_ SV_CONST(PRINTF), mark - 1, MUTABLE_SV(io),
1567 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1574 SETERRNO(EBADF,RMS_IFI);
1577 else if (!(fp = IoOFP(io))) {
1579 report_wrongway_fh(gv, '<');
1580 else if (ckWARN(WARN_CLOSED))
1582 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1586 SV *sv = sv_newmortal();
1587 do_sprintf(sv, SP - MARK, MARK + 1);
1588 if (!do_print(sv, fp))
1591 if (IoFLAGS(io) & IOf_FLUSH)
1592 if (PerlIO_flush(fp) == EOF)
1601 PUSHs(&PL_sv_undef);
1608 const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1609 const int mode = POPi;
1610 SV * const sv = POPs;
1611 GV * const gv = MUTABLE_GV(POPs);
1614 /* Need TIEHANDLE method ? */
1615 const char * const tmps = SvPV_const(sv, len);
1616 if (do_open_raw(gv, tmps, len, mode, perm)) {
1617 IoLINES(GvIOp(gv)) = 0;
1621 PUSHs(&PL_sv_undef);
1627 /* also used for: pp_read() and pp_recv() (where supported) */
1631 dSP; dMARK; dORIGMARK; dTARGET;
1645 bool charstart = FALSE;
1646 STRLEN charskip = 0;
1648 GV * const gv = MUTABLE_GV(*++MARK);
1651 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1652 && gv && (io = GvIO(gv)) )
1654 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1656 return Perl_tied_method(aTHX_ SV_CONST(READ), mark - 1, MUTABLE_SV(io), mg,
1657 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1666 sv_setpvs(bufsv, "");
1667 length = SvIVx(*++MARK);
1669 DIE(aTHX_ "Negative length");
1672 offset = SvIVx(*++MARK);
1676 if (!io || !IoIFP(io)) {
1678 SETERRNO(EBADF,RMS_IFI);
1682 /* Note that fd can here validly be -1, don't check it yet. */
1683 fd = PerlIO_fileno(IoIFP(io));
1685 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1686 buffer = SvPVutf8_force(bufsv, blen);
1687 /* UTF-8 may not have been set if they are all low bytes */
1692 buffer = SvPV_force(bufsv, blen);
1693 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
1695 if (DO_UTF8(bufsv)) {
1696 blen = sv_len_utf8_nomg(bufsv);
1705 if (PL_op->op_type == OP_RECV) {
1706 Sock_size_t bufsize;
1707 char namebuf[MAXPATHLEN];
1709 SETERRNO(EBADF,SS_IVCHAN);
1712 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
1713 bufsize = sizeof (struct sockaddr_in);
1715 bufsize = sizeof namebuf;
1717 #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1721 buffer = SvGROW(bufsv, (STRLEN)(length+1));
1722 /* 'offset' means 'flags' here */
1723 count = PerlSock_recvfrom(fd, buffer, length, offset,
1724 (struct sockaddr *)namebuf, &bufsize);
1727 /* MSG_TRUNC can give oversized count; quietly lose it */
1730 SvCUR_set(bufsv, count);
1731 *SvEND(bufsv) = '\0';
1732 (void)SvPOK_only(bufsv);
1736 /* This should not be marked tainted if the fp is marked clean */
1737 if (!(IoFLAGS(io) & IOf_UNTAINT))
1738 SvTAINTED_on(bufsv);
1740 #if defined(__CYGWIN__)
1741 /* recvfrom() on cygwin doesn't set bufsize at all for
1742 connected sockets, leaving us with trash in the returned
1743 name, so use the same test as the Win32 code to check if it
1744 wasn't set, and set it [perl #118843] */
1745 if (bufsize == sizeof namebuf)
1748 sv_setpvn(TARG, namebuf, bufsize);
1754 if (-offset > (SSize_t)blen)
1755 DIE(aTHX_ "Offset outside string");
1758 if (DO_UTF8(bufsv)) {
1759 /* convert offset-as-chars to offset-as-bytes */
1760 if (offset >= (SSize_t)blen)
1761 offset += SvCUR(bufsv) - blen;
1763 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1767 /* Reestablish the fd in case it shifted from underneath us. */
1768 fd = PerlIO_fileno(IoIFP(io));
1770 orig_size = SvCUR(bufsv);
1771 /* Allocating length + offset + 1 isn't perfect in the case of reading
1772 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1774 (should be 2 * length + offset + 1, or possibly something longer if
1775 IN_ENCODING Is true) */
1776 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
1777 if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1778 Zero(buffer+orig_size, offset-orig_size, char);
1780 buffer = buffer + offset;
1782 read_target = bufsv;
1784 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1785 concatenate it to the current buffer. */
1787 /* Truncate the existing buffer to the start of where we will be
1789 SvCUR_set(bufsv, offset);
1791 read_target = sv_newmortal();
1792 SvUPGRADE(read_target, SVt_PV);
1793 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1796 if (PL_op->op_type == OP_SYSREAD) {
1797 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1798 if (IoTYPE(io) == IoTYPE_SOCKET) {
1800 SETERRNO(EBADF,SS_IVCHAN);
1804 count = PerlSock_recv(fd, buffer, length, 0);
1810 SETERRNO(EBADF,RMS_IFI);
1814 count = PerlLIO_read(fd, buffer, length);
1819 count = PerlIO_read(IoIFP(io), buffer, length);
1820 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1821 if (count == 0 && PerlIO_error(IoIFP(io)))
1825 if (IoTYPE(io) == IoTYPE_WRONLY)
1826 report_wrongway_fh(gv, '>');
1829 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1830 *SvEND(read_target) = '\0';
1831 (void)SvPOK_only(read_target);
1832 if (fp_utf8 && !IN_BYTES) {
1833 /* Look at utf8 we got back and count the characters */
1834 const char *bend = buffer + count;
1835 while (buffer < bend) {
1837 skip = UTF8SKIP(buffer);
1840 if (buffer - charskip + skip > bend) {
1841 /* partial character - try for rest of it */
1842 length = skip - (bend-buffer);
1843 offset = bend - SvPVX_const(bufsv);
1855 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1856 provided amount read (count) was what was requested (length)
1858 if (got < wanted && count == length) {
1859 length = wanted - got;
1860 offset = bend - SvPVX_const(bufsv);
1863 /* return value is character count */
1867 else if (buffer_utf8) {
1868 /* Let svcatsv upgrade the bytes we read in to utf8.
1869 The buffer is a mortal so will be freed soon. */
1870 sv_catsv_nomg(bufsv, read_target);
1873 /* This should not be marked tainted if the fp is marked clean */
1874 if (!(IoFLAGS(io) & IOf_UNTAINT))
1875 SvTAINTED_on(bufsv);
1886 /* also used for: pp_send() where defined */
1890 dSP; dMARK; dORIGMARK; dTARGET;
1895 STRLEN orig_blen_bytes;
1896 const int op_type = PL_op->op_type;
1899 GV *const gv = MUTABLE_GV(*++MARK);
1900 IO *const io = GvIO(gv);
1903 if (op_type == OP_SYSWRITE && io) {
1904 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1906 if (MARK == SP - 1) {
1908 mXPUSHi(sv_len(sv));
1912 return Perl_tied_method(aTHX_ SV_CONST(WRITE), mark - 1, MUTABLE_SV(io), mg,
1913 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1923 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1925 if (io && IoIFP(io))
1926 report_wrongway_fh(gv, '<');
1929 SETERRNO(EBADF,RMS_IFI);
1932 fd = PerlIO_fileno(IoIFP(io));
1934 SETERRNO(EBADF,SS_IVCHAN);
1939 /* Do this first to trigger any overloading. */
1940 buffer = SvPV_const(bufsv, blen);
1941 orig_blen_bytes = blen;
1942 doing_utf8 = DO_UTF8(bufsv);
1944 if (PerlIO_isutf8(IoIFP(io))) {
1945 if (!SvUTF8(bufsv)) {
1946 /* We don't modify the original scalar. */
1947 tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
1948 buffer = (char *) tmpbuf;
1952 else if (doing_utf8) {
1953 STRLEN tmplen = blen;
1954 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
1957 buffer = (char *) tmpbuf;
1961 assert((char *)result == buffer);
1962 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
1967 if (op_type == OP_SEND) {
1968 const int flags = SvIVx(*++MARK);
1971 char * const sockbuf = SvPVx(*++MARK, mlen);
1972 retval = PerlSock_sendto(fd, buffer, blen,
1973 flags, (struct sockaddr *)sockbuf, mlen);
1976 retval = PerlSock_send(fd, buffer, blen, flags);
1982 Size_t length = 0; /* This length is in characters. */
1988 /* The SV is bytes, and we've had to upgrade it. */
1989 blen_chars = orig_blen_bytes;
1991 /* The SV really is UTF-8. */
1992 /* Don't call sv_len_utf8 on a magical or overloaded
1993 scalar, as we might get back a different result. */
1994 blen_chars = sv_or_pv_len_utf8(bufsv, buffer, blen);
2001 length = blen_chars;
2003 #if Size_t_size > IVSIZE
2004 length = (Size_t)SvNVx(*++MARK);
2006 length = (Size_t)SvIVx(*++MARK);
2008 if ((SSize_t)length < 0) {
2010 DIE(aTHX_ "Negative length");
2015 offset = SvIVx(*++MARK);
2017 if (-offset > (IV)blen_chars) {
2019 DIE(aTHX_ "Offset outside string");
2021 offset += blen_chars;
2022 } else if (offset > (IV)blen_chars) {
2024 DIE(aTHX_ "Offset outside string");
2028 if (length > blen_chars - offset)
2029 length = blen_chars - offset;
2031 /* Here we convert length from characters to bytes. */
2032 if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
2033 /* Either we had to convert the SV, or the SV is magical, or
2034 the SV has overloading, in which case we can't or mustn't
2035 or mustn't call it again. */
2037 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
2038 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
2040 /* It's a real UTF-8 SV, and it's not going to change under
2041 us. Take advantage of any cache. */
2043 I32 len_I32 = length;
2045 /* Convert the start and end character positions to bytes.
2046 Remember that the second argument to sv_pos_u2b is relative
2048 sv_pos_u2b(bufsv, &start, &len_I32);
2055 buffer = buffer+offset;
2057 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2058 if (IoTYPE(io) == IoTYPE_SOCKET) {
2059 retval = PerlSock_send(fd, buffer, length, 0);
2064 /* See the note at doio.c:do_print about filesize limits. --jhi */
2065 retval = PerlLIO_write(fd, buffer, length);
2073 retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
2076 #if Size_t_size > IVSIZE
2096 * in Perl 5.12 and later, the additional parameter is a bitmask:
2099 * 2 = eof() <- ARGV magic
2101 * I'll rely on the compiler's trace flow analysis to decide whether to
2102 * actually assign this out here, or punt it into the only block where it is
2103 * used. Doing it out here is DRY on the condition logic.
2108 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
2114 if (PL_op->op_flags & OPf_SPECIAL) {
2115 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
2119 gv = PL_last_in_gv; /* eof */
2127 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2128 return tied_method1(SV_CONST(EOF), SP, MUTABLE_SV(io), mg, newSVuv(which));
2131 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2132 if (io && !IoIFP(io)) {
2133 if ((IoFLAGS(io) & IOf_START) && av_tindex(GvAVn(gv)) < 0) {
2136 IoFLAGS(io) &= ~IOf_START;
2137 do_open6(gv, "-", 1, NULL, NULL, 0);
2145 *svp = newSVpvs("-");
2147 else if (!nextargv(gv, FALSE))
2152 PUSHs(boolSV(do_eof(gv)));
2162 if (MAXARG != 0 && (TOPs || POPs))
2163 PL_last_in_gv = MUTABLE_GV(POPs);
2170 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2172 return tied_method0(SV_CONST(TELL), SP, MUTABLE_SV(io), mg);
2177 SETERRNO(EBADF,RMS_IFI);
2182 #if LSEEKSIZE > IVSIZE
2183 PUSHn( do_tell(gv) );
2185 PUSHi( do_tell(gv) );
2191 /* also used for: pp_seek() */
2196 const int whence = POPi;
2197 #if LSEEKSIZE > IVSIZE
2198 const Off_t offset = (Off_t)SvNVx(POPs);
2200 const Off_t offset = (Off_t)SvIVx(POPs);
2203 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2204 IO *const io = GvIO(gv);
2207 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2209 #if LSEEKSIZE > IVSIZE
2210 SV *const offset_sv = newSVnv((NV) offset);
2212 SV *const offset_sv = newSViv(offset);
2215 return tied_method2(SV_CONST(SEEK), SP, MUTABLE_SV(io), mg, offset_sv,
2220 if (PL_op->op_type == OP_SEEK)
2221 PUSHs(boolSV(do_seek(gv, offset, whence)));
2223 const Off_t sought = do_sysseek(gv, offset, whence);
2225 PUSHs(&PL_sv_undef);
2227 SV* const sv = sought ?
2228 #if LSEEKSIZE > IVSIZE
2233 : newSVpvn(zero_but_true, ZBTLEN);
2243 /* There seems to be no consensus on the length type of truncate()
2244 * and ftruncate(), both off_t and size_t have supporters. In
2245 * general one would think that when using large files, off_t is
2246 * at least as wide as size_t, so using an off_t should be okay. */
2247 /* XXX Configure probe for the length type of *truncate() needed XXX */
2250 #if Off_t_size > IVSIZE
2255 /* Checking for length < 0 is problematic as the type might or
2256 * might not be signed: if it is not, clever compilers will moan. */
2257 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2260 SV * const sv = POPs;
2265 if (PL_op->op_flags & OPf_SPECIAL
2266 ? (tmpgv = gv_fetchsv(sv, 0, SVt_PVIO), 1)
2267 : !!(tmpgv = MAYBE_DEREF_GV(sv)) ) {
2274 TAINT_PROPER("truncate");
2275 if (!(fp = IoIFP(io))) {
2279 int fd = PerlIO_fileno(fp);
2281 SETERRNO(EBADF,RMS_IFI);
2286 if (ftruncate(fd, len) < 0)
2288 if (my_chsize(fd, len) < 0)
2295 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2296 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2297 goto do_ftruncate_io;
2300 const char * const name = SvPV_nomg_const_nolen(sv);
2301 TAINT_PROPER("truncate");
2303 if (truncate(name, len) < 0)
2307 const int tmpfd = PerlLIO_open(name, O_RDWR);
2310 SETERRNO(EBADF,RMS_IFI);
2313 if (my_chsize(tmpfd, len) < 0)
2315 PerlLIO_close(tmpfd);
2324 SETERRNO(EBADF,RMS_IFI);
2330 /* also used for: pp_fcntl() */
2335 SV * const argsv = POPs;
2336 const unsigned int func = POPu;
2338 GV * const gv = MUTABLE_GV(POPs);
2339 IO * const io = GvIOn(gv);
2345 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
2349 if (SvPOK(argsv) || !SvNIOK(argsv)) {
2352 s = SvPV_force(argsv, len);
2353 need = IOCPARM_LEN(func);
2355 s = Sv_Grow(argsv, need + 1);
2356 SvCUR_set(argsv, need);
2359 s[SvCUR(argsv)] = 17; /* a little sanity check here */
2362 retval = SvIV(argsv);
2363 s = INT2PTR(char*,retval); /* ouch */
2366 optype = PL_op->op_type;
2367 TAINT_PROPER(PL_op_desc[optype]);
2369 if (optype == OP_IOCTL)
2371 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2373 DIE(aTHX_ "ioctl is not implemented");
2377 DIE(aTHX_ "fcntl is not implemented");
2379 #if defined(OS2) && defined(__EMX__)
2380 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2382 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2386 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2388 if (s[SvCUR(argsv)] != 17)
2389 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2391 s[SvCUR(argsv)] = 0; /* put our null back */
2392 SvSETMAGIC(argsv); /* Assume it has changed */
2401 PUSHp(zero_but_true, ZBTLEN);
2412 const int argtype = POPi;
2413 GV * const gv = MUTABLE_GV(POPs);
2414 IO *const io = GvIO(gv);
2415 PerlIO *const fp = io ? IoIFP(io) : NULL;
2417 /* XXX Looks to me like io is always NULL at this point */
2419 (void)PerlIO_flush(fp);
2420 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2425 SETERRNO(EBADF,RMS_IFI);
2430 DIE(aTHX_ PL_no_func, "flock");
2441 const int protocol = POPi;
2442 const int type = POPi;
2443 const int domain = POPi;
2444 GV * const gv = MUTABLE_GV(POPs);
2445 IO * const io = GvIOn(gv);
2449 do_close(gv, FALSE);
2451 TAINT_PROPER("socket");
2452 fd = PerlSock_socket(domain, type, protocol);
2454 SETERRNO(EBADF,RMS_IFI);
2457 IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2458 IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2459 IoTYPE(io) = IoTYPE_SOCKET;
2460 if (!IoIFP(io) || !IoOFP(io)) {
2461 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2462 if (IoOFP(io)) PerlIO_close(IoOFP(io));
2463 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2466 #if defined(HAS_FCNTL) && defined(F_SETFD)
2467 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2477 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2480 const int protocol = POPi;
2481 const int type = POPi;
2482 const int domain = POPi;
2484 GV * const gv2 = MUTABLE_GV(POPs);
2485 IO * const io2 = GvIOn(gv2);
2486 GV * const gv1 = MUTABLE_GV(POPs);
2487 IO * const io1 = GvIOn(gv1);
2490 do_close(gv1, FALSE);
2492 do_close(gv2, FALSE);
2494 TAINT_PROPER("socketpair");
2495 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2497 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2498 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
2499 IoTYPE(io1) = IoTYPE_SOCKET;
2500 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2501 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
2502 IoTYPE(io2) = IoTYPE_SOCKET;
2503 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2504 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2505 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2506 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2507 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2508 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2509 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2512 #if defined(HAS_FCNTL) && defined(F_SETFD)
2513 /* ensure close-on-exec */
2514 if ((fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd) < 0) ||
2515 (fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd) < 0))
2521 DIE(aTHX_ PL_no_sock_func, "socketpair");
2527 /* also used for: pp_connect() */
2532 SV * const addrsv = POPs;
2533 /* OK, so on what platform does bind modify addr? */
2535 GV * const gv = MUTABLE_GV(POPs);
2536 IO * const io = GvIOn(gv);
2543 fd = PerlIO_fileno(IoIFP(io));
2547 addr = SvPV_const(addrsv, len);
2548 op_type = PL_op->op_type;
2549 TAINT_PROPER(PL_op_desc[op_type]);
2550 if ((op_type == OP_BIND
2551 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2552 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2560 SETERRNO(EBADF,SS_IVCHAN);
2567 const int backlog = POPi;
2568 GV * const gv = MUTABLE_GV(POPs);
2569 IO * const io = GvIOn(gv);
2574 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2581 SETERRNO(EBADF,SS_IVCHAN);
2589 char namebuf[MAXPATHLEN];
2590 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2591 Sock_size_t len = sizeof (struct sockaddr_in);
2593 Sock_size_t len = sizeof namebuf;
2595 GV * const ggv = MUTABLE_GV(POPs);
2596 GV * const ngv = MUTABLE_GV(POPs);
2599 IO * const gstio = GvIO(ggv);
2600 if (!gstio || !IoIFP(gstio))
2604 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2607 /* Some platforms indicate zero length when an AF_UNIX client is
2608 * not bound. Simulate a non-zero-length sockaddr structure in
2610 namebuf[0] = 0; /* sun_len */
2611 namebuf[1] = AF_UNIX; /* sun_family */
2619 do_close(ngv, FALSE);
2620 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2621 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2622 IoTYPE(nstio) = IoTYPE_SOCKET;
2623 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2624 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2625 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2626 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2629 #if defined(HAS_FCNTL) && defined(F_SETFD)
2630 if (fcntl(fd, F_SETFD, fd > PL_maxsysfd) < 0) /* ensure close-on-exec */
2634 #ifdef __SCO_VERSION__
2635 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2638 PUSHp(namebuf, len);
2642 report_evil_fh(ggv);
2643 SETERRNO(EBADF,SS_IVCHAN);
2653 const int how = POPi;
2654 GV * const gv = MUTABLE_GV(POPs);
2655 IO * const io = GvIOn(gv);
2660 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2665 SETERRNO(EBADF,SS_IVCHAN);
2670 /* also used for: pp_gsockopt() */
2675 const int optype = PL_op->op_type;
2676 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2677 const unsigned int optname = (unsigned int) POPi;
2678 const unsigned int lvl = (unsigned int) POPi;
2679 GV * const gv = MUTABLE_GV(POPs);
2680 IO * const io = GvIOn(gv);
2687 fd = PerlIO_fileno(IoIFP(io));
2693 (void)SvPOK_only(sv);
2697 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2700 /* XXX Configure test: does getsockopt set the length properly? */
2709 #if defined(__SYMBIAN32__)
2710 # define SETSOCKOPT_OPTION_VALUE_T void *
2712 # define SETSOCKOPT_OPTION_VALUE_T const char *
2714 /* XXX TODO: We need to have a proper type (a Configure probe,
2715 * etc.) for what the C headers think of the third argument of
2716 * setsockopt(), the option_value read-only buffer: is it
2717 * a "char *", or a "void *", const or not. Some compilers
2718 * don't take kindly to e.g. assuming that "char *" implicitly
2719 * promotes to a "void *", or to explicitly promoting/demoting
2720 * consts to non/vice versa. The "const void *" is the SUS
2721 * definition, but that does not fly everywhere for the above
2723 SETSOCKOPT_OPTION_VALUE_T buf;
2727 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2731 aint = (int)SvIV(sv);
2732 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2735 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2745 SETERRNO(EBADF,SS_IVCHAN);
2752 /* also used for: pp_getsockname() */
2757 const int optype = PL_op->op_type;
2758 GV * const gv = MUTABLE_GV(POPs);
2759 IO * const io = GvIOn(gv);
2767 sv = sv_2mortal(newSV(257));
2768 (void)SvPOK_only(sv);
2772 fd = PerlIO_fileno(IoIFP(io));
2776 case OP_GETSOCKNAME:
2777 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2780 case OP_GETPEERNAME:
2781 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2783 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2785 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";
2786 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2787 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2788 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2789 sizeof(u_short) + sizeof(struct in_addr))) {
2796 #ifdef BOGUS_GETNAME_RETURN
2797 /* Interactive Unix, getpeername() and getsockname()
2798 does not return valid namelen */
2799 if (len == BOGUS_GETNAME_RETURN)
2800 len = sizeof(struct sockaddr);
2809 SETERRNO(EBADF,SS_IVCHAN);
2818 /* also used for: pp_lstat() */
2829 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2830 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2831 if (PL_op->op_type == OP_LSTAT) {
2832 if (gv != PL_defgv) {
2833 do_fstat_warning_check:
2834 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2835 "lstat() on filehandle%s%"SVf,
2838 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2840 } else if (PL_laststype != OP_LSTAT)
2841 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2842 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2845 if (gv != PL_defgv) {
2849 PL_laststype = OP_STAT;
2850 PL_statgv = gv ? gv : (GV *)io;
2851 sv_setpvs(PL_statname, "");
2857 int fd = PerlIO_fileno(IoIFP(io));
2859 PL_laststatval = -1;
2860 SETERRNO(EBADF,RMS_IFI);
2862 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2865 } else if (IoDIRP(io)) {
2867 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2870 PL_laststatval = -1;
2873 else PL_laststatval = -1;
2874 if (PL_laststatval < 0 && !havefp) report_evil_fh(gv);
2877 if (PL_laststatval < 0) {
2883 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2884 io = MUTABLE_IO(SvRV(sv));
2885 if (PL_op->op_type == OP_LSTAT)
2886 goto do_fstat_warning_check;
2887 goto do_fstat_have_io;
2890 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2891 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2893 PL_laststype = PL_op->op_type;
2894 file = SvPV_nolen_const(PL_statname);
2895 if (PL_op->op_type == OP_LSTAT)
2896 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2898 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2899 if (PL_laststatval < 0) {
2900 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2901 /* PL_warn_nl is constant */
2902 GCC_DIAG_IGNORE(-Wformat-nonliteral);
2903 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2911 if (gimme != G_ARRAY) {
2912 if (gimme != G_VOID)
2913 XPUSHs(boolSV(max));
2919 mPUSHi(PL_statcache.st_dev);
2920 #if ST_INO_SIZE > IVSIZE
2921 mPUSHn(PL_statcache.st_ino);
2923 # if ST_INO_SIGN <= 0
2924 mPUSHi(PL_statcache.st_ino);
2926 mPUSHu(PL_statcache.st_ino);
2929 mPUSHu(PL_statcache.st_mode);
2930 mPUSHu(PL_statcache.st_nlink);
2932 sv_setuid(PUSHmortal, PL_statcache.st_uid);
2933 sv_setgid(PUSHmortal, PL_statcache.st_gid);
2935 #ifdef USE_STAT_RDEV
2936 mPUSHi(PL_statcache.st_rdev);
2938 PUSHs(newSVpvs_flags("", SVs_TEMP));
2940 #if Off_t_size > IVSIZE
2941 mPUSHn(PL_statcache.st_size);
2943 mPUSHi(PL_statcache.st_size);
2946 mPUSHn(PL_statcache.st_atime);
2947 mPUSHn(PL_statcache.st_mtime);
2948 mPUSHn(PL_statcache.st_ctime);
2950 mPUSHi(PL_statcache.st_atime);
2951 mPUSHi(PL_statcache.st_mtime);
2952 mPUSHi(PL_statcache.st_ctime);
2954 #ifdef USE_STAT_BLOCKS
2955 mPUSHu(PL_statcache.st_blksize);
2956 mPUSHu(PL_statcache.st_blocks);
2958 PUSHs(newSVpvs_flags("", SVs_TEMP));
2959 PUSHs(newSVpvs_flags("", SVs_TEMP));
2965 /* All filetest ops avoid manipulating the perl stack pointer in their main
2966 bodies (since commit d2c4d2d1e22d3125), and return using either
2967 S_ft_return_false() or S_ft_return_true(). These two helper functions are
2968 the only two which manipulate the perl stack. To ensure that no stack
2969 manipulation macros are used, the filetest ops avoid defining a local copy
2970 of the stack pointer with dSP. */
2972 /* If the next filetest is stacked up with this one
2973 (PL_op->op_private & OPpFT_STACKING), we leave
2974 the original argument on the stack for success,
2975 and skip the stacked operators on failure.
2976 The next few macros/functions take care of this.
2980 S_ft_return_false(pTHX_ SV *ret) {
2984 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
2988 if (PL_op->op_private & OPpFT_STACKING) {
2989 while (OP_IS_FILETEST(next->op_type)
2990 && next->op_private & OPpFT_STACKED)
2991 next = next->op_next;
2996 PERL_STATIC_INLINE OP *
2997 S_ft_return_true(pTHX_ SV *ret) {
2999 if (PL_op->op_flags & OPf_REF)
3000 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
3001 else if (!(PL_op->op_private & OPpFT_STACKING))
3007 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
3008 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
3009 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
3011 #define tryAMAGICftest_MG(chr) STMT_START { \
3012 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
3013 && PL_op->op_flags & OPf_KIDS) { \
3014 OP *next = S_try_amagic_ftest(aTHX_ chr); \
3015 if (next) return next; \
3020 S_try_amagic_ftest(pTHX_ char chr) {
3021 SV *const arg = *PL_stack_sp;
3024 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
3028 const char tmpchr = chr;
3029 SV * const tmpsv = amagic_call(arg,
3030 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
3031 ftest_amg, AMGf_unary);
3036 return SvTRUE(tmpsv)
3037 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3043 /* also used for: pp_fteexec() pp_fteread() pp_ftewrite() pp_ftrexec()
3049 /* Not const, because things tweak this below. Not bool, because there's
3050 no guarantee that OPpFT_ACCESS is <= CHAR_MAX */
3051 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3052 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3053 /* Giving some sort of initial value silences compilers. */
3055 int access_mode = R_OK;
3057 int access_mode = 0;
3060 /* access_mode is never used, but leaving use_access in makes the
3061 conditional compiling below much clearer. */
3064 Mode_t stat_mode = S_IRUSR;
3066 bool effective = FALSE;
3069 switch (PL_op->op_type) {
3070 case OP_FTRREAD: opchar = 'R'; break;
3071 case OP_FTRWRITE: opchar = 'W'; break;
3072 case OP_FTREXEC: opchar = 'X'; break;
3073 case OP_FTEREAD: opchar = 'r'; break;
3074 case OP_FTEWRITE: opchar = 'w'; break;
3075 case OP_FTEEXEC: opchar = 'x'; break;
3077 tryAMAGICftest_MG(opchar);
3079 switch (PL_op->op_type) {
3081 #if !(defined(HAS_ACCESS) && defined(R_OK))
3087 #if defined(HAS_ACCESS) && defined(W_OK)
3092 stat_mode = S_IWUSR;
3096 #if defined(HAS_ACCESS) && defined(X_OK)
3101 stat_mode = S_IXUSR;
3105 #ifdef PERL_EFF_ACCESS
3108 stat_mode = S_IWUSR;
3112 #ifndef PERL_EFF_ACCESS
3119 #ifdef PERL_EFF_ACCESS
3124 stat_mode = S_IXUSR;
3130 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3131 const char *name = SvPV_nolen(*PL_stack_sp);
3133 # ifdef PERL_EFF_ACCESS
3134 result = PERL_EFF_ACCESS(name, access_mode);
3136 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3142 result = access(name, access_mode);
3144 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3155 result = my_stat_flags(0);
3158 if (cando(stat_mode, effective, &PL_statcache))
3164 /* also used for: pp_ftatime() pp_ftctime() pp_ftmtime() pp_ftsize() */
3169 const int op_type = PL_op->op_type;
3173 case OP_FTIS: opchar = 'e'; break;
3174 case OP_FTSIZE: opchar = 's'; break;
3175 case OP_FTMTIME: opchar = 'M'; break;
3176 case OP_FTCTIME: opchar = 'C'; break;
3177 case OP_FTATIME: opchar = 'A'; break;
3179 tryAMAGICftest_MG(opchar);
3181 result = my_stat_flags(0);
3184 if (op_type == OP_FTIS)
3187 /* You can't dTARGET inside OP_FTIS, because you'll get
3188 "panic: pad_sv po" - the op is not flagged to have a target. */
3192 #if Off_t_size > IVSIZE
3193 sv_setnv(TARG, (NV)PL_statcache.st_size);
3195 sv_setiv(TARG, (IV)PL_statcache.st_size);
3200 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3204 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3208 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3212 return SvTRUE_nomg(TARG)
3213 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3218 /* also used for: pp_ftblk() pp_ftchr() pp_ftdir() pp_fteowned()
3219 * pp_ftfile() pp_ftpipe() pp_ftsgid() pp_ftsock()
3220 * pp_ftsuid() pp_ftsvtx() pp_ftzero() */
3227 switch (PL_op->op_type) {
3228 case OP_FTROWNED: opchar = 'O'; break;
3229 case OP_FTEOWNED: opchar = 'o'; break;
3230 case OP_FTZERO: opchar = 'z'; break;
3231 case OP_FTSOCK: opchar = 'S'; break;
3232 case OP_FTCHR: opchar = 'c'; break;
3233 case OP_FTBLK: opchar = 'b'; break;
3234 case OP_FTFILE: opchar = 'f'; break;
3235 case OP_FTDIR: opchar = 'd'; break;
3236 case OP_FTPIPE: opchar = 'p'; break;
3237 case OP_FTSUID: opchar = 'u'; break;
3238 case OP_FTSGID: opchar = 'g'; break;
3239 case OP_FTSVTX: opchar = 'k'; break;
3241 tryAMAGICftest_MG(opchar);
3243 /* I believe that all these three are likely to be defined on most every
3244 system these days. */
3246 if(PL_op->op_type == OP_FTSUID) {
3251 if(PL_op->op_type == OP_FTSGID) {
3256 if(PL_op->op_type == OP_FTSVTX) {
3261 result = my_stat_flags(0);
3264 switch (PL_op->op_type) {
3266 if (PL_statcache.st_uid == PerlProc_getuid())
3270 if (PL_statcache.st_uid == PerlProc_geteuid())
3274 if (PL_statcache.st_size == 0)
3278 if (S_ISSOCK(PL_statcache.st_mode))
3282 if (S_ISCHR(PL_statcache.st_mode))
3286 if (S_ISBLK(PL_statcache.st_mode))
3290 if (S_ISREG(PL_statcache.st_mode))
3294 if (S_ISDIR(PL_statcache.st_mode))
3298 if (S_ISFIFO(PL_statcache.st_mode))
3303 if (PL_statcache.st_mode & S_ISUID)
3309 if (PL_statcache.st_mode & S_ISGID)
3315 if (PL_statcache.st_mode & S_ISVTX)
3327 tryAMAGICftest_MG('l');
3328 result = my_lstat_flags(0);
3332 if (S_ISLNK(PL_statcache.st_mode))
3344 tryAMAGICftest_MG('t');
3346 if (PL_op->op_flags & OPf_REF)
3349 SV *tmpsv = *PL_stack_sp;
3350 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3351 name = SvPV_nomg(tmpsv, namelen);
3352 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3356 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3357 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3358 else if (name && isDIGIT(*name))
3359 fd = grok_atou(name, NULL);
3363 SETERRNO(EBADF,RMS_IFI);
3366 if (PerlLIO_isatty(fd))
3372 /* also used for: pp_ftbinary() */
3386 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3388 if (PL_op->op_flags & OPf_REF)
3390 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3395 gv = MAYBE_DEREF_GV_nomg(sv);
3399 if (gv == PL_defgv) {
3401 io = SvTYPE(PL_statgv) == SVt_PVIO
3405 goto really_filename;
3410 sv_setpvs(PL_statname, "");
3411 io = GvIO(PL_statgv);
3413 PL_laststatval = -1;
3414 PL_laststype = OP_STAT;
3415 if (io && IoIFP(io)) {
3417 if (! PerlIO_has_base(IoIFP(io)))
3418 DIE(aTHX_ "-T and -B not implemented on filehandles");
3419 fd = PerlIO_fileno(IoIFP(io));
3421 SETERRNO(EBADF,RMS_IFI);
3424 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3425 if (PL_laststatval < 0)
3427 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3428 if (PL_op->op_type == OP_FTTEXT)
3433 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3434 i = PerlIO_getc(IoIFP(io));
3436 (void)PerlIO_ungetc(IoIFP(io),i);
3438 /* null file is anything */
3441 len = PerlIO_get_bufsiz(IoIFP(io));
3442 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3443 /* sfio can have large buffers - limit to 512 */
3448 SETERRNO(EBADF,RMS_IFI);
3450 SETERRNO(EBADF,RMS_IFI);
3459 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3461 file = SvPVX_const(PL_statname);
3463 if (!(fp = PerlIO_open(file, "r"))) {
3465 PL_laststatval = -1;
3466 PL_laststype = OP_STAT;
3468 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3469 /* PL_warn_nl is constant */
3470 GCC_DIAG_IGNORE(-Wformat-nonliteral);
3471 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3476 PL_laststype = OP_STAT;
3477 fd = PerlIO_fileno(fp);
3479 (void)PerlIO_close(fp);
3480 SETERRNO(EBADF,RMS_IFI);
3483 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3484 if (PL_laststatval < 0) {
3485 (void)PerlIO_close(fp);
3486 SETERRNO(EBADF,RMS_IFI);
3489 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3490 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3491 (void)PerlIO_close(fp);
3493 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3494 FT_RETURNNO; /* special case NFS directories */
3495 FT_RETURNYES; /* null file is anything */
3500 /* now scan s to look for textiness */
3502 #if defined(DOSISH) || defined(USEMYBINMODE)
3503 /* ignore trailing ^Z on short files */
3504 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3509 if (! is_invariant_string((U8 *) s, len)) {
3512 /* Here contains a variant under UTF-8 . See if the entire string is
3513 * UTF-8. But the buffer may end in a partial character, so consider
3514 * it UTF-8 if the first non-UTF8 char is an ending partial */
3515 if (is_utf8_string_loc((U8 *) s, len, &ep)
3516 || ep + UTF8SKIP(ep) > (U8 *) (s + len))
3518 if (PL_op->op_type == OP_FTTEXT) {
3527 /* Here, is not UTF-8 or is entirely ASCII. Look through the buffer for
3528 * things that wouldn't be in ASCII text or rich ASCII text. Count these
3530 for (i = 0; i < len; i++, s++) {
3531 if (!*s) { /* null never allowed in text */
3535 #ifdef USE_LOCALE_CTYPE
3536 if (IN_LC_RUNTIME(LC_CTYPE)) {
3537 if ( isPRINT_LC(*s) || isSPACE_LC(*s)) {
3544 /* VT occurs so rarely in text, that we consider it odd */
3545 || (isSPACE_A(*s) && *s != VT_NATIVE)
3547 /* But there is a fair amount of backspaces and escapes in
3550 || *s == ESC_NATIVE)
3557 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3568 const char *tmps = NULL;
3572 SV * const sv = POPs;
3573 if (PL_op->op_flags & OPf_SPECIAL) {
3574 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3576 else if (!(gv = MAYBE_DEREF_GV(sv)))
3577 tmps = SvPV_nomg_const_nolen(sv);
3580 if( !gv && (!tmps || !*tmps) ) {
3581 HV * const table = GvHVn(PL_envgv);
3584 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3585 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3587 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3592 deprecate("chdir('') or chdir(undef) as chdir()");
3593 tmps = SvPV_nolen_const(*svp);
3597 TAINT_PROPER("chdir");
3602 TAINT_PROPER("chdir");
3605 IO* const io = GvIO(gv);
3608 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3609 } else if (IoIFP(io)) {
3610 int fd = PerlIO_fileno(IoIFP(io));
3614 PUSHi(fchdir(fd) >= 0);
3624 DIE(aTHX_ PL_no_func, "fchdir");
3628 PUSHi( PerlDir_chdir(tmps) >= 0 );
3630 /* Clear the DEFAULT element of ENV so we'll get the new value
3632 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3638 SETERRNO(EBADF,RMS_IFI);
3644 /* also used for: pp_chmod() pp_kill() pp_unlink() pp_utime() */
3648 dSP; dMARK; dTARGET;
3649 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3660 char * const tmps = POPpx;
3661 TAINT_PROPER("chroot");
3662 PUSHi( chroot(tmps) >= 0 );
3665 DIE(aTHX_ PL_no_func, "chroot");
3673 const char * const tmps2 = POPpconstx;
3674 const char * const tmps = SvPV_nolen_const(TOPs);
3675 TAINT_PROPER("rename");
3677 anum = PerlLIO_rename(tmps, tmps2);
3679 if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) {
3680 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3683 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode))
3684 (void)UNLINK(tmps2);
3685 if (!(anum = link(tmps, tmps2)))
3686 anum = UNLINK(tmps);
3695 /* also used for: pp_symlink() */
3697 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3701 const int op_type = PL_op->op_type;
3705 if (op_type == OP_LINK)
3706 DIE(aTHX_ PL_no_func, "link");
3708 # ifndef HAS_SYMLINK
3709 if (op_type == OP_SYMLINK)
3710 DIE(aTHX_ PL_no_func, "symlink");
3714 const char * const tmps2 = POPpconstx;
3715 const char * const tmps = SvPV_nolen_const(TOPs);
3716 TAINT_PROPER(PL_op_desc[op_type]);
3718 # if defined(HAS_LINK)
3719 # if defined(HAS_SYMLINK)
3720 /* Both present - need to choose which. */
3721 (op_type == OP_LINK) ?
3722 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3724 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3725 PerlLIO_link(tmps, tmps2);
3728 # if defined(HAS_SYMLINK)
3729 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3730 symlink(tmps, tmps2);
3735 SETi( result >= 0 );
3740 /* also used for: pp_symlink() */
3745 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3755 char buf[MAXPATHLEN];
3760 /* NOTE: if the length returned by readlink() is sizeof(buf) - 1,
3761 * it is impossible to know whether the result was truncated. */
3762 len = readlink(tmps, buf, sizeof(buf) - 1);
3771 RETSETUNDEF; /* just pretend it's a normal file */
3775 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3777 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3779 char * const save_filename = filename;
3784 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3786 PERL_ARGS_ASSERT_DOONELINER;
3788 Newx(cmdline, size, char);
3789 my_strlcpy(cmdline, cmd, size);
3790 my_strlcat(cmdline, " ", size);
3791 for (s = cmdline + strlen(cmdline); *filename; ) {
3795 if (s - cmdline < size)
3796 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3797 myfp = PerlProc_popen(cmdline, "r");
3801 SV * const tmpsv = sv_newmortal();
3802 /* Need to save/restore 'PL_rs' ?? */
3803 s = sv_gets(tmpsv, myfp, 0);
3804 (void)PerlProc_pclose(myfp);
3808 #ifdef HAS_SYS_ERRLIST
3813 /* you don't see this */
3814 const char * const errmsg = Strerror(e) ;
3817 if (instr(s, errmsg)) {
3824 #define EACCES EPERM
3826 if (instr(s, "cannot make"))
3827 SETERRNO(EEXIST,RMS_FEX);
3828 else if (instr(s, "existing file"))
3829 SETERRNO(EEXIST,RMS_FEX);
3830 else if (instr(s, "ile exists"))
3831 SETERRNO(EEXIST,RMS_FEX);
3832 else if (instr(s, "non-exist"))
3833 SETERRNO(ENOENT,RMS_FNF);
3834 else if (instr(s, "does not exist"))
3835 SETERRNO(ENOENT,RMS_FNF);
3836 else if (instr(s, "not empty"))
3837 SETERRNO(EBUSY,SS_DEVOFFLINE);
3838 else if (instr(s, "cannot access"))
3839 SETERRNO(EACCES,RMS_PRV);
3841 SETERRNO(EPERM,RMS_PRV);
3844 else { /* some mkdirs return no failure indication */
3845 anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0);
3846 if (PL_op->op_type == OP_RMDIR)
3851 SETERRNO(EACCES,RMS_PRV); /* a guess */
3860 /* This macro removes trailing slashes from a directory name.
3861 * Different operating and file systems take differently to
3862 * trailing slashes. According to POSIX 1003.1 1996 Edition
3863 * any number of trailing slashes should be allowed.
3864 * Thusly we snip them away so that even non-conforming
3865 * systems are happy.
3866 * We should probably do this "filtering" for all
3867 * the functions that expect (potentially) directory names:
3868 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3869 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3871 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3872 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3875 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3876 (tmps) = savepvn((tmps), (len)); \
3886 const int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPi : 0777;
3888 TRIMSLASHES(tmps,len,copy);
3890 TAINT_PROPER("mkdir");
3892 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3896 SETi( dooneliner("mkdir", tmps) );
3897 oldumask = PerlLIO_umask(0);
3898 PerlLIO_umask(oldumask);
3899 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3914 TRIMSLASHES(tmps,len,copy);
3915 TAINT_PROPER("rmdir");
3917 SETi( PerlDir_rmdir(tmps) >= 0 );
3919 SETi( dooneliner("rmdir", tmps) );
3926 /* Directory calls. */
3930 #if defined(Direntry_t) && defined(HAS_READDIR)
3932 const char * const dirname = POPpconstx;
3933 GV * const gv = MUTABLE_GV(POPs);
3934 IO * const io = GvIOn(gv);
3936 if ((IoIFP(io) || IoOFP(io)))
3937 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
3938 "Opening filehandle %"HEKf" also as a directory",
3939 HEKfARG(GvENAME_HEK(gv)) );
3941 PerlDir_close(IoDIRP(io));
3942 if (!(IoDIRP(io) = PerlDir_open(dirname)))
3948 SETERRNO(EBADF,RMS_DIR);
3951 DIE(aTHX_ PL_no_dir_func, "opendir");
3957 #if !defined(Direntry_t) || !defined(HAS_READDIR)
3958 DIE(aTHX_ PL_no_dir_func, "readdir");
3960 #if !defined(I_DIRENT) && !defined(VMS)
3961 Direntry_t *readdir (DIR *);
3966 const I32 gimme = GIMME;
3967 GV * const gv = MUTABLE_GV(POPs);
3968 const Direntry_t *dp;
3969 IO * const io = GvIOn(gv);
3972 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3973 "readdir() attempted on invalid dirhandle %"HEKf,
3974 HEKfARG(GvENAME_HEK(gv)));
3979 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
3983 sv = newSVpvn(dp->d_name, dp->d_namlen);
3985 sv = newSVpv(dp->d_name, 0);
3987 if (!(IoFLAGS(io) & IOf_UNTAINT))
3990 } while (gimme == G_ARRAY);
3992 if (!dp && gimme != G_ARRAY)
3999 SETERRNO(EBADF,RMS_ISI);
4000 if (GIMME == G_ARRAY)
4009 #if defined(HAS_TELLDIR) || defined(telldir)
4011 /* XXX does _anyone_ need this? --AD 2/20/1998 */
4012 /* XXX netbsd still seemed to.
4013 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
4014 --JHI 1999-Feb-02 */
4015 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
4016 long telldir (DIR *);
4018 GV * const gv = MUTABLE_GV(POPs);
4019 IO * const io = GvIOn(gv);
4022 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4023 "telldir() attempted on invalid dirhandle %"HEKf,
4024 HEKfARG(GvENAME_HEK(gv)));
4028 PUSHi( PerlDir_tell(IoDIRP(io)) );
4032 SETERRNO(EBADF,RMS_ISI);
4035 DIE(aTHX_ PL_no_dir_func, "telldir");
4041 #if defined(HAS_SEEKDIR) || defined(seekdir)
4043 const long along = POPl;
4044 GV * const gv = MUTABLE_GV(POPs);
4045 IO * const io = GvIOn(gv);
4048 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4049 "seekdir() attempted on invalid dirhandle %"HEKf,
4050 HEKfARG(GvENAME_HEK(gv)));
4053 (void)PerlDir_seek(IoDIRP(io), along);
4058 SETERRNO(EBADF,RMS_ISI);
4061 DIE(aTHX_ PL_no_dir_func, "seekdir");
4067 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4069 GV * const gv = MUTABLE_GV(POPs);
4070 IO * const io = GvIOn(gv);
4073 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4074 "rewinddir() attempted on invalid dirhandle %"HEKf,
4075 HEKfARG(GvENAME_HEK(gv)));
4078 (void)PerlDir_rewind(IoDIRP(io));
4082 SETERRNO(EBADF,RMS_ISI);
4085 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4091 #if defined(Direntry_t) && defined(HAS_READDIR)
4093 GV * const gv = MUTABLE_GV(POPs);
4094 IO * const io = GvIOn(gv);
4097 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4098 "closedir() attempted on invalid dirhandle %"HEKf,
4099 HEKfARG(GvENAME_HEK(gv)));
4102 #ifdef VOID_CLOSEDIR
4103 PerlDir_close(IoDIRP(io));
4105 if (PerlDir_close(IoDIRP(io)) < 0) {
4106 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4115 SETERRNO(EBADF,RMS_IFI);
4118 DIE(aTHX_ PL_no_dir_func, "closedir");
4122 /* Process control. */
4129 #ifdef HAS_SIGPROCMASK
4130 sigset_t oldmask, newmask;
4134 PERL_FLUSHALL_FOR_CHILD;
4135 #ifdef HAS_SIGPROCMASK
4136 sigfillset(&newmask);
4137 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4139 childpid = PerlProc_fork();
4140 if (childpid == 0) {
4144 for (sig = 1; sig < SIG_SIZE; sig++)
4145 PL_psig_pend[sig] = 0;
4147 #ifdef HAS_SIGPROCMASK
4150 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4157 #ifdef PERL_USES_PL_PIDSTATUS
4158 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4164 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4169 PERL_FLUSHALL_FOR_CHILD;
4170 childpid = PerlProc_fork();
4176 DIE(aTHX_ PL_no_func, "fork");
4183 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4188 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4189 childpid = wait4pid(-1, &argflags, 0);
4191 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4196 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4197 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4198 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4200 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4205 DIE(aTHX_ PL_no_func, "wait");
4211 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4213 const int optype = POPi;
4214 const Pid_t pid = TOPi;
4218 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4219 result = wait4pid(pid, &argflags, optype);
4221 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4226 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4227 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4228 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4230 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4235 DIE(aTHX_ PL_no_func, "waitpid");
4241 dSP; dMARK; dORIGMARK; dTARGET;
4242 #if defined(__LIBCATAMOUNT__)
4243 PL_statusvalue = -1;
4252 while (++MARK <= SP) {
4253 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4258 TAINT_PROPER("system");
4260 PERL_FLUSHALL_FOR_CHILD;
4261 #if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4266 #ifdef HAS_SIGPROCMASK
4267 sigset_t newset, oldset;
4270 if (PerlProc_pipe(pp) >= 0)
4272 #ifdef HAS_SIGPROCMASK
4273 sigemptyset(&newset);
4274 sigaddset(&newset, SIGCHLD);
4275 sigprocmask(SIG_BLOCK, &newset, &oldset);
4277 while ((childpid = PerlProc_fork()) == -1) {
4278 if (errno != EAGAIN) {
4283 PerlLIO_close(pp[0]);
4284 PerlLIO_close(pp[1]);
4286 #ifdef HAS_SIGPROCMASK
4287 sigprocmask(SIG_SETMASK, &oldset, NULL);
4294 Sigsave_t ihand,qhand; /* place to save signals during system() */
4298 PerlLIO_close(pp[1]);
4300 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4301 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4304 result = wait4pid(childpid, &status, 0);
4305 } while (result == -1 && errno == EINTR);
4307 #ifdef HAS_SIGPROCMASK
4308 sigprocmask(SIG_SETMASK, &oldset, NULL);
4310 (void)rsignal_restore(SIGINT, &ihand);
4311 (void)rsignal_restore(SIGQUIT, &qhand);
4313 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4314 do_execfree(); /* free any memory child malloced on fork */
4321 while (n < sizeof(int)) {
4322 n1 = PerlLIO_read(pp[0],
4323 (void*)(((char*)&errkid)+n),
4329 PerlLIO_close(pp[0]);
4330 if (n) { /* Error */
4331 if (n != sizeof(int))
4332 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4333 errno = errkid; /* Propagate errno from kid */
4334 STATUS_NATIVE_CHILD_SET(-1);
4337 XPUSHi(STATUS_CURRENT);
4340 #ifdef HAS_SIGPROCMASK
4341 sigprocmask(SIG_SETMASK, &oldset, NULL);
4344 PerlLIO_close(pp[0]);
4345 #if defined(HAS_FCNTL) && defined(F_SETFD)
4346 if (fcntl(pp[1], F_SETFD, FD_CLOEXEC) < 0)
4350 if (PL_op->op_flags & OPf_STACKED) {
4351 SV * const really = *++MARK;
4352 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4354 else if (SP - MARK != 1)
4355 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4357 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4361 #else /* ! FORK or VMS or OS/2 */
4364 if (PL_op->op_flags & OPf_STACKED) {
4365 SV * const really = *++MARK;
4366 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4367 value = (I32)do_aspawn(really, MARK, SP);
4369 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4372 else if (SP - MARK != 1) {
4373 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4374 value = (I32)do_aspawn(NULL, MARK, SP);
4376 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4380 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4382 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4384 STATUS_NATIVE_CHILD_SET(value);
4387 XPUSHi(result ? value : STATUS_CURRENT);
4388 #endif /* !FORK or VMS or OS/2 */
4395 dSP; dMARK; dORIGMARK; dTARGET;
4400 while (++MARK <= SP) {
4401 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4406 TAINT_PROPER("exec");
4408 PERL_FLUSHALL_FOR_CHILD;
4409 if (PL_op->op_flags & OPf_STACKED) {
4410 SV * const really = *++MARK;
4411 value = (I32)do_aexec(really, MARK, SP);
4413 else if (SP - MARK != 1)
4415 value = (I32)vms_do_aexec(NULL, MARK, SP);
4417 value = (I32)do_aexec(NULL, MARK, SP);
4421 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4423 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4436 XPUSHi( getppid() );
4439 DIE(aTHX_ PL_no_func, "getppid");
4449 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4452 pgrp = (I32)BSD_GETPGRP(pid);
4454 if (pid != 0 && pid != PerlProc_getpid())
4455 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4461 DIE(aTHX_ PL_no_func, "getpgrp");
4471 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4472 if (MAXARG > 0) pid = TOPs ? TOPi : 0;
4479 TAINT_PROPER("setpgrp");
4481 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4483 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4484 || (pid != 0 && pid != PerlProc_getpid()))
4486 DIE(aTHX_ "setpgrp can't take arguments");
4488 SETi( setpgrp() >= 0 );
4489 #endif /* USE_BSDPGRP */
4492 DIE(aTHX_ PL_no_func, "setpgrp");
4496 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4497 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4499 # define PRIORITY_WHICH_T(which) which
4504 #ifdef HAS_GETPRIORITY
4506 const int who = POPi;
4507 const int which = TOPi;
4508 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4511 DIE(aTHX_ PL_no_func, "getpriority");
4517 #ifdef HAS_SETPRIORITY
4519 const int niceval = POPi;
4520 const int who = POPi;
4521 const int which = TOPi;
4522 TAINT_PROPER("setpriority");
4523 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4526 DIE(aTHX_ PL_no_func, "setpriority");
4530 #undef PRIORITY_WHICH_T
4538 XPUSHn( time(NULL) );
4540 XPUSHi( time(NULL) );
4549 struct tms timesbuf;
4552 (void)PerlProc_times(×buf);
4554 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4555 if (GIMME == G_ARRAY) {
4556 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4557 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4558 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4566 if (GIMME == G_ARRAY) {
4573 DIE(aTHX_ "times not implemented");
4575 #endif /* HAS_TIMES */
4578 /* The 32 bit int year limits the times we can represent to these
4579 boundaries with a few days wiggle room to account for time zone
4582 /* Sat Jan 3 00:00:00 -2147481748 */
4583 #define TIME_LOWER_BOUND -67768100567755200.0
4584 /* Sun Dec 29 12:00:00 2147483647 */
4585 #define TIME_UPPER_BOUND 67767976233316800.0
4588 /* also used for: pp_localtime() */
4596 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4597 static const char * const dayname[] =
4598 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4599 static const char * const monname[] =
4600 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4601 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4603 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4606 when = (Time64_T)now;
4609 NV input = Perl_floor(POPn);
4610 when = (Time64_T)input;
4611 if (when != input) {
4612 /* diag_listed_as: gmtime(%f) too large */
4613 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4614 "%s(%.0" NVff ") too large", opname, input);
4618 if ( TIME_LOWER_BOUND > when ) {
4619 /* diag_listed_as: gmtime(%f) too small */
4620 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4621 "%s(%.0" NVff ") too small", opname, when);
4624 else if( when > TIME_UPPER_BOUND ) {
4625 /* diag_listed_as: gmtime(%f) too small */
4626 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4627 "%s(%.0" NVff ") too large", opname, when);
4631 if (PL_op->op_type == OP_LOCALTIME)
4632 err = S_localtime64_r(&when, &tmbuf);
4634 err = S_gmtime64_r(&when, &tmbuf);
4638 /* diag_listed_as: gmtime(%f) failed */
4639 /* XXX %lld broken for quads */
4640 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4641 "%s(%.0" NVff ") failed", opname, when);
4644 if (GIMME != G_ARRAY) { /* scalar context */
4650 mPUSHs(Perl_newSVpvf(aTHX_ "%s %s %2d %02d:%02d:%02d %"IVdf,
4651 dayname[tmbuf.tm_wday],
4652 monname[tmbuf.tm_mon],
4657 (IV)tmbuf.tm_year + 1900));
4660 else { /* list context */
4666 mPUSHi(tmbuf.tm_sec);
4667 mPUSHi(tmbuf.tm_min);
4668 mPUSHi(tmbuf.tm_hour);
4669 mPUSHi(tmbuf.tm_mday);
4670 mPUSHi(tmbuf.tm_mon);
4671 mPUSHn(tmbuf.tm_year);
4672 mPUSHi(tmbuf.tm_wday);
4673 mPUSHi(tmbuf.tm_yday);
4674 mPUSHi(tmbuf.tm_isdst);
4685 anum = alarm((unsigned int)anum);
4691 DIE(aTHX_ PL_no_func, "alarm");
4702 (void)time(&lasttime);
4703 if (MAXARG < 1 || (!TOPs && !POPs))
4707 PerlProc_sleep((unsigned int)duration);
4710 XPUSHi(when - lasttime);
4714 /* Shared memory. */
4715 /* Merged with some message passing. */
4717 /* also used for: pp_msgrcv() pp_msgsnd() pp_semop() pp_shmread() */
4721 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4722 dSP; dMARK; dTARGET;
4723 const int op_type = PL_op->op_type;
4728 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4731 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4734 value = (I32)(do_semop(MARK, SP) >= 0);
4737 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4745 return Perl_pp_semget(aTHX);
4751 /* also used for: pp_msgget() pp_shmget() */
4755 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4756 dSP; dMARK; dTARGET;
4757 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4764 DIE(aTHX_ "System V IPC is not implemented on this machine");
4768 /* also used for: pp_msgctl() pp_shmctl() */
4772 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4773 dSP; dMARK; dTARGET;
4774 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4782 PUSHp(zero_but_true, ZBTLEN);
4786 return Perl_pp_semget(aTHX);
4790 /* I can't const this further without getting warnings about the types of
4791 various arrays passed in from structures. */
4793 S_space_join_names_mortal(pTHX_ char *const *array)
4797 PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL;
4799 if (array && *array) {
4800 target = newSVpvs_flags("", SVs_TEMP);
4802 sv_catpv(target, *array);
4805 sv_catpvs(target, " ");
4808 target = sv_mortalcopy(&PL_sv_no);
4813 /* Get system info. */
4815 /* also used for: pp_ghbyaddr() pp_ghbyname() */
4819 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4821 I32 which = PL_op->op_type;
4824 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4825 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4826 struct hostent *gethostbyname(Netdb_name_t);
4827 struct hostent *gethostent(void);
4829 struct hostent *hent = NULL;
4833 if (which == OP_GHBYNAME) {
4834 #ifdef HAS_GETHOSTBYNAME
4835 const char* const name = POPpbytex;
4836 hent = PerlSock_gethostbyname(name);
4838 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
4841 else if (which == OP_GHBYADDR) {
4842 #ifdef HAS_GETHOSTBYADDR
4843 const int addrtype = POPi;
4844 SV * const addrsv = POPs;
4846 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
4848 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
4850 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
4854 #ifdef HAS_GETHOSTENT
4855 hent = PerlSock_gethostent();
4857 DIE(aTHX_ PL_no_sock_func, "gethostent");
4860 #ifdef HOST_NOT_FOUND
4862 #ifdef USE_REENTRANT_API
4863 # ifdef USE_GETHOSTENT_ERRNO
4864 h_errno = PL_reentrant_buffer->_gethostent_errno;
4867 STATUS_UNIX_SET(h_errno);
4871 if (GIMME != G_ARRAY) {
4872 PUSHs(sv = sv_newmortal());
4874 if (which == OP_GHBYNAME) {
4876 sv_setpvn(sv, hent->h_addr, hent->h_length);
4879 sv_setpv(sv, (char*)hent->h_name);
4885 mPUSHs(newSVpv((char*)hent->h_name, 0));
4886 PUSHs(space_join_names_mortal(hent->h_aliases));
4887 mPUSHi(hent->h_addrtype);
4888 len = hent->h_length;
4891 for (elem = hent->h_addr_list; elem && *elem; elem++) {
4892 mXPUSHp(*elem, len);
4896 mPUSHp(hent->h_addr, len);
4898 PUSHs(sv_mortalcopy(&PL_sv_no));
4903 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4907 /* also used for: pp_gnbyaddr() pp_gnbyname() */
4911 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
4913 I32 which = PL_op->op_type;
4915 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
4916 struct netent *getnetbyaddr(Netdb_net_t, int);
4917 struct netent *getnetbyname(Netdb_name_t);
4918 struct netent *getnetent(void);
4920 struct netent *nent;
4922 if (which == OP_GNBYNAME){
4923 #ifdef HAS_GETNETBYNAME
4924 const char * const name = POPpbytex;
4925 nent = PerlSock_getnetbyname(name);
4927 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
4930 else if (which == OP_GNBYADDR) {
4931 #ifdef HAS_GETNETBYADDR
4932 const int addrtype = POPi;
4933 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
4934 nent = PerlSock_getnetbyaddr(addr, addrtype);
4936 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
4940 #ifdef HAS_GETNETENT
4941 nent = PerlSock_getnetent();
4943 DIE(aTHX_ PL_no_sock_func, "getnetent");
4946 #ifdef HOST_NOT_FOUND
4948 #ifdef USE_REENTRANT_API
4949 # ifdef USE_GETNETENT_ERRNO
4950 h_errno = PL_reentrant_buffer->_getnetent_errno;
4953 STATUS_UNIX_SET(h_errno);
4958 if (GIMME != G_ARRAY) {
4959 PUSHs(sv = sv_newmortal());
4961 if (which == OP_GNBYNAME)
4962 sv_setiv(sv, (IV)nent->n_net);
4964 sv_setpv(sv, nent->n_name);
4970 mPUSHs(newSVpv(nent->n_name, 0));
4971 PUSHs(space_join_names_mortal(nent->n_aliases));
4972 mPUSHi(nent->n_addrtype);
4973 mPUSHi(nent->n_net);
4978 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4983 /* also used for: pp_gpbyname() pp_gpbynumber() */
4987 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
4989 I32 which = PL_op->op_type;
4991 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
4992 struct protoent *getprotobyname(Netdb_name_t);
4993 struct protoent *getprotobynumber(int);
4994 struct protoent *getprotoent(void);
4996 struct protoent *pent;
4998 if (which == OP_GPBYNAME) {
4999 #ifdef HAS_GETPROTOBYNAME
5000 const char* const name = POPpbytex;
5001 pent = PerlSock_getprotobyname(name);
5003 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
5006 else if (which == OP_GPBYNUMBER) {
5007 #ifdef HAS_GETPROTOBYNUMBER
5008 const int number = POPi;
5009 pent = PerlSock_getprotobynumber(number);
5011 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
5015 #ifdef HAS_GETPROTOENT
5016 pent = PerlSock_getprotoent();
5018 DIE(aTHX_ PL_no_sock_func, "getprotoent");
5022 if (GIMME != G_ARRAY) {
5023 PUSHs(sv = sv_newmortal());
5025 if (which == OP_GPBYNAME)
5026 sv_setiv(sv, (IV)pent->p_proto);
5028 sv_setpv(sv, pent->p_name);
5034 mPUSHs(newSVpv(pent->p_name, 0));
5035 PUSHs(space_join_names_mortal(pent->p_aliases));
5036 mPUSHi(pent->p_proto);
5041 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5046 /* also used for: pp_gsbyname() pp_gsbyport() */
5050 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
5052 I32 which = PL_op->op_type;
5054 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
5055 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
5056 struct servent *getservbyport(int, Netdb_name_t);
5057 struct servent *getservent(void);
5059 struct servent *sent;
5061 if (which == OP_GSBYNAME) {
5062 #ifdef HAS_GETSERVBYNAME
5063 const char * const proto = POPpbytex;
5064 const char * const name = POPpbytex;
5065 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
5067 DIE(aTHX_ PL_no_sock_func, "getservbyname");
5070 else if (which == OP_GSBYPORT) {
5071 #ifdef HAS_GETSERVBYPORT
5072 const char * const proto = POPpbytex;
5073 unsigned short port = (unsigned short)POPu;
5074 port = PerlSock_htons(port);
5075 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
5077 DIE(aTHX_ PL_no_sock_func, "getservbyport");
5081 #ifdef HAS_GETSERVENT
5082 sent = PerlSock_getservent();
5084 DIE(aTHX_ PL_no_sock_func, "getservent");
5088 if (GIMME != G_ARRAY) {
5089 PUSHs(sv = sv_newmortal());
5091 if (which == OP_GSBYNAME) {
5092 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5095 sv_setpv(sv, sent->s_name);
5101 mPUSHs(newSVpv(sent->s_name, 0));
5102 PUSHs(space_join_names_mortal(sent->s_aliases));
5103 mPUSHi(PerlSock_ntohs(sent->s_port));
5104 mPUSHs(newSVpv(sent->s_proto, 0));
5109 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5114 /* also used for: pp_snetent() pp_sprotoent() pp_sservent() */
5119 const int stayopen = TOPi;
5120 switch(PL_op->op_type) {
5122 #ifdef HAS_SETHOSTENT
5123 PerlSock_sethostent(stayopen);
5125 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5128 #ifdef HAS_SETNETENT
5130 PerlSock_setnetent(stayopen);
5132 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5136 #ifdef HAS_SETPROTOENT
5137 PerlSock_setprotoent(stayopen);
5139 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5143 #ifdef HAS_SETSERVENT
5144 PerlSock_setservent(stayopen);
5146 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5154 /* also used for: pp_egrent() pp_enetent() pp_eprotoent() pp_epwent()
5155 * pp_eservent() pp_sgrent() pp_spwent() */
5160 switch(PL_op->op_type) {
5162 #ifdef HAS_ENDHOSTENT
5163 PerlSock_endhostent();
5165 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5169 #ifdef HAS_ENDNETENT
5170 PerlSock_endnetent();
5172 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5176 #ifdef HAS_ENDPROTOENT
5177 PerlSock_endprotoent();
5179 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5183 #ifdef HAS_ENDSERVENT
5184 PerlSock_endservent();
5186 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5190 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5193 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5197 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5200 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5204 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5207 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5211 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5214 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5223 /* also used for: pp_gpwnam() pp_gpwuid() */
5229 I32 which = PL_op->op_type;
5231 struct passwd *pwent = NULL;
5233 * We currently support only the SysV getsp* shadow password interface.
5234 * The interface is declared in <shadow.h> and often one needs to link
5235 * with -lsecurity or some such.
5236 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5239 * AIX getpwnam() is clever enough to return the encrypted password
5240 * only if the caller (euid?) is root.
5242 * There are at least three other shadow password APIs. Many platforms
5243 * seem to contain more than one interface for accessing the shadow
5244 * password databases, possibly for compatibility reasons.
5245 * The getsp*() is by far he simplest one, the other two interfaces
5246 * are much more complicated, but also very similar to each other.
5251 * struct pr_passwd *getprpw*();
5252 * The password is in
5253 * char getprpw*(...).ufld.fd_encrypt[]
5254 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5259 * struct es_passwd *getespw*();
5260 * The password is in
5261 * char *(getespw*(...).ufld.fd_encrypt)
5262 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5265 * struct userpw *getuserpw();
5266 * The password is in
5267 * char *(getuserpw(...)).spw_upw_passwd
5268 * (but the de facto standard getpwnam() should work okay)
5270 * Mention I_PROT here so that Configure probes for it.
5272 * In HP-UX for getprpw*() the manual page claims that one should include
5273 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5274 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5275 * and pp_sys.c already includes <shadow.h> if there is such.
5277 * Note that <sys/security.h> is already probed for, but currently
5278 * it is only included in special cases.
5280 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5281 * be preferred interface, even though also the getprpw*() interface
5282 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5283 * One also needs to call set_auth_parameters() in main() before
5284 * doing anything else, whether one is using getespw*() or getprpw*().
5286 * Note that accessing the shadow databases can be magnitudes
5287 * slower than accessing the standard databases.
5292 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5293 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5294 * the pw_comment is left uninitialized. */
5295 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5301 const char* const name = POPpbytex;
5302 pwent = getpwnam(name);
5308 pwent = getpwuid(uid);
5312 # ifdef HAS_GETPWENT
5314 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5315 if (pwent) pwent = getpwnam(pwent->pw_name);
5318 DIE(aTHX_ PL_no_func, "getpwent");
5324 if (GIMME != G_ARRAY) {
5325 PUSHs(sv = sv_newmortal());
5327 if (which == OP_GPWNAM)
5328 sv_setuid(sv, pwent->pw_uid);
5330 sv_setpv(sv, pwent->pw_name);
5336 mPUSHs(newSVpv(pwent->pw_name, 0));
5340 /* If we have getspnam(), we try to dig up the shadow
5341 * password. If we are underprivileged, the shadow
5342 * interface will set the errno to EACCES or similar,
5343 * and return a null pointer. If this happens, we will
5344 * use the dummy password (usually "*" or "x") from the
5345 * standard password database.
5347 * In theory we could skip the shadow call completely
5348 * if euid != 0 but in practice we cannot know which
5349 * security measures are guarding the shadow databases
5350 * on a random platform.
5352 * Resist the urge to use additional shadow interfaces.
5353 * Divert the urge to writing an extension instead.
5356 /* Some AIX setups falsely(?) detect some getspnam(), which
5357 * has a different API than the Solaris/IRIX one. */
5358 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5361 const struct spwd * const spwent = getspnam(pwent->pw_name);
5362 /* Save and restore errno so that
5363 * underprivileged attempts seem
5364 * to have never made the unsuccessful
5365 * attempt to retrieve the shadow password. */
5367 if (spwent && spwent->sp_pwdp)
5368 sv_setpv(sv, spwent->sp_pwdp);
5372 if (!SvPOK(sv)) /* Use the standard password, then. */
5373 sv_setpv(sv, pwent->pw_passwd);
5376 /* passwd is tainted because user himself can diddle with it.
5377 * admittedly not much and in a very limited way, but nevertheless. */
5380 sv_setuid(PUSHmortal, pwent->pw_uid);
5381 sv_setgid(PUSHmortal, pwent->pw_gid);
5383 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5384 * because of the poor interface of the Perl getpw*(),
5385 * not because there's some standard/convention saying so.
5386 * A better interface would have been to return a hash,
5387 * but we are accursed by our history, alas. --jhi. */
5389 mPUSHi(pwent->pw_change);
5392 mPUSHi(pwent->pw_quota);
5395 mPUSHs(newSVpv(pwent->pw_age, 0));
5397 /* I think that you can never get this compiled, but just in case. */
5398 PUSHs(sv_mortalcopy(&PL_sv_no));
5403 /* pw_class and pw_comment are mutually exclusive--.
5404 * see the above note for pw_change, pw_quota, and pw_age. */
5406 mPUSHs(newSVpv(pwent->pw_class, 0));
5409 mPUSHs(newSVpv(pwent->pw_comment, 0));
5411 /* I think that you can never get this compiled, but just in case. */
5412 PUSHs(sv_mortalcopy(&PL_sv_no));
5417 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5419 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5421 /* pw_gecos is tainted because user himself can diddle with it. */
5424 mPUSHs(newSVpv(pwent->pw_dir, 0));
5426 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5427 /* pw_shell is tainted because user himself can diddle with it. */
5431 mPUSHi(pwent->pw_expire);
5436 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5441 /* also used for: pp_ggrgid() pp_ggrnam() */
5447 const I32 which = PL_op->op_type;
5448 const struct group *grent;
5450 if (which == OP_GGRNAM) {
5451 const char* const name = POPpbytex;
5452 grent = (const struct group *)getgrnam(name);
5454 else if (which == OP_GGRGID) {
5455 const Gid_t gid = POPi;
5456 grent = (const struct group *)getgrgid(gid);
5460 grent = (struct group *)getgrent();
5462 DIE(aTHX_ PL_no_func, "getgrent");
5466 if (GIMME != G_ARRAY) {
5467 SV * const sv = sv_newmortal();
5471 if (which == OP_GGRNAM)
5472 sv_setgid(sv, grent->gr_gid);
5474 sv_setpv(sv, grent->gr_name);
5480 mPUSHs(newSVpv(grent->gr_name, 0));
5483 mPUSHs(newSVpv(grent->gr_passwd, 0));
5485 PUSHs(sv_mortalcopy(&PL_sv_no));
5488 sv_setgid(PUSHmortal, grent->gr_gid);
5490 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5491 /* In UNICOS/mk (_CRAYMPP) the multithreading
5492 * versions (getgrnam_r, getgrgid_r)
5493 * seem to return an illegal pointer
5494 * as the group members list, gr_mem.
5495 * getgrent() doesn't even have a _r version
5496 * but the gr_mem is poisonous anyway.
5497 * So yes, you cannot get the list of group
5498 * members if building multithreaded in UNICOS/mk. */
5499 PUSHs(space_join_names_mortal(grent->gr_mem));
5505 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5515 if (!(tmps = PerlProc_getlogin()))
5517 sv_setpv_mg(TARG, tmps);
5521 DIE(aTHX_ PL_no_func, "getlogin");
5525 /* Miscellaneous. */
5530 dSP; dMARK; dORIGMARK; dTARGET;
5531 I32 items = SP - MARK;
5532 unsigned long a[20];
5537 while (++MARK <= SP) {
5538 if (SvTAINTED(*MARK)) {
5544 TAINT_PROPER("syscall");
5547 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5548 * or where sizeof(long) != sizeof(char*). But such machines will
5549 * not likely have syscall implemented either, so who cares?
5551 while (++MARK <= SP) {
5552 if (SvNIOK(*MARK) || !i)
5553 a[i++] = SvIV(*MARK);
5554 else if (*MARK == &PL_sv_undef)
5557 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5563 DIE(aTHX_ "Too many args to syscall");
5565 DIE(aTHX_ "Too few args to syscall");
5567 retval = syscall(a[0]);
5570 retval = syscall(a[0],a[1]);
5573 retval = syscall(a[0],a[1],a[2]);
5576 retval = syscall(a[0],a[1],a[2],a[3]);
5579 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5582 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5585 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5588 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5595 DIE(aTHX_ PL_no_func, "syscall");
5599 #ifdef FCNTL_EMULATE_FLOCK
5601 /* XXX Emulate flock() with fcntl().
5602 What's really needed is a good file locking module.
5606 fcntl_emulate_flock(int fd, int operation)
5611 switch (operation & ~LOCK_NB) {
5613 flock.l_type = F_RDLCK;
5616 flock.l_type = F_WRLCK;
5619 flock.l_type = F_UNLCK;
5625 flock.l_whence = SEEK_SET;
5626 flock.l_start = flock.l_len = (Off_t)0;
5628 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5629 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5630 errno = EWOULDBLOCK;
5634 #endif /* FCNTL_EMULATE_FLOCK */
5636 #ifdef LOCKF_EMULATE_FLOCK
5638 /* XXX Emulate flock() with lockf(). This is just to increase
5639 portability of scripts. The calls are not completely
5640 interchangeable. What's really needed is a good file
5644 /* The lockf() constants might have been defined in <unistd.h>.
5645 Unfortunately, <unistd.h> causes troubles on some mixed
5646 (BSD/POSIX) systems, such as SunOS 4.1.3.
5648 Further, the lockf() constants aren't POSIX, so they might not be
5649 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5650 just stick in the SVID values and be done with it. Sigh.
5654 # define F_ULOCK 0 /* Unlock a previously locked region */
5657 # define F_LOCK 1 /* Lock a region for exclusive use */
5660 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5663 # define F_TEST 3 /* Test a region for other processes locks */
5667 lockf_emulate_flock(int fd, int operation)
5673 /* flock locks entire file so for lockf we need to do the same */
5674 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5675 if (pos > 0) /* is seekable and needs to be repositioned */
5676 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5677 pos = -1; /* seek failed, so don't seek back afterwards */
5680 switch (operation) {
5682 /* LOCK_SH - get a shared lock */
5684 /* LOCK_EX - get an exclusive lock */
5686 i = lockf (fd, F_LOCK, 0);
5689 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5690 case LOCK_SH|LOCK_NB:
5691 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5692 case LOCK_EX|LOCK_NB:
5693 i = lockf (fd, F_TLOCK, 0);
5695 if ((errno == EAGAIN) || (errno == EACCES))
5696 errno = EWOULDBLOCK;
5699 /* LOCK_UN - unlock (non-blocking is a no-op) */
5701 case LOCK_UN|LOCK_NB:
5702 i = lockf (fd, F_ULOCK, 0);
5705 /* Default - can't decipher operation */
5712 if (pos > 0) /* need to restore position of the handle */
5713 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5718 #endif /* LOCKF_EMULATE_FLOCK */
5722 * c-indentation-style: bsd
5724 * indent-tabs-mode: nil
5727 * ex: set ts=8 sts=4 sw=4 et: