3 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
4 * 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * But only a short way ahead its floor and the walls on either side were
13 * cloven by a great fissure, out of which the red glare came, now leaping
14 * up, now dying down into darkness; and all the while far below there was
15 * a rumour and a trouble as of great engines throbbing and labouring.
17 * [p.945 of _The Lord of the Rings_, VI/iii: "Mount Doom"]
20 /* This file contains system pp ("push/pop") functions that
21 * execute the opcodes that make up a perl program. A typical pp function
22 * expects to find its arguments on the stack, and usually pushes its
23 * results onto the stack, hence the 'pp' terminology. Each OP structure
24 * contains a pointer to the relevant pp_foo() function.
26 * By 'system', we mean ops which interact with the OS, such as pp_open().
30 #define PERL_IN_PP_SYS_C
35 /* Shadow password support for solaris - pdo@cs.umd.edu
36 * Not just Solaris: at least HP-UX, IRIX, Linux.
37 * The API is from SysV.
39 * There are at least two more shadow interfaces,
40 * see the comments in pp_gpwent().
44 /* There is a MAXINT coming from <shadow.h> <- <hpsecurity.h> <- <values.h>
45 * and another MAXINT from "perl.h" <- <sys/param.h>. */
52 # include <sys/resource.h>
61 # include <sys/select.h>
65 /* XXX Configure test needed.
66 h_errno might not be a simple 'int', especially for multi-threaded
67 applications, see "extern int errno in perl.h". Creating such
68 a test requires taking into account the differences between
69 compiling multithreaded and singlethreaded ($ccflags et al).
70 HOST_NOT_FOUND is typically defined in <netdb.h>.
72 #if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
80 struct passwd *getpwnam (char *);
81 struct passwd *getpwuid (Uid_t);
85 struct passwd *getpwent (void);
86 # elif defined (VMS) && defined (my_getpwent)
87 struct passwd *Perl_my_getpwent (pTHX);
96 struct group *getgrnam (char *);
97 struct group *getgrgid (Gid_t);
101 struct group *getgrent (void);
107 # if defined(_MSC_VER) || defined(__MINGW32__)
108 # include <sys/utime.h>
115 # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */
118 # define my_chsize PerlLIO_chsize
119 #elif defined(HAS_TRUNCATE)
120 # define my_chsize PerlLIO_chsize
122 I32 my_chsize(int fd, Off_t length);
127 #else /* no flock() */
129 /* fcntl.h might not have been included, even if it exists, because
130 the current Configure only sets I_FCNTL if it's needed to pick up
131 the *_OK constants. Make sure it has been included before testing
132 the fcntl() locking constants. */
133 # if defined(HAS_FCNTL) && !defined(I_FCNTL)
137 # if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK)
138 # define FLOCK fcntl_emulate_flock
139 # define FCNTL_EMULATE_FLOCK
140 # elif defined(HAS_LOCKF)
141 # define FLOCK lockf_emulate_flock
142 # define LOCKF_EMULATE_FLOCK
146 static int FLOCK (int, int);
149 * These are the flock() constants. Since this sytems doesn't have
150 * flock(), the values of the constants are probably not available.
164 # endif /* emulating flock() */
166 #endif /* no flock() */
169 static const char zero_but_true[ZBTLEN + 1] = "0 but true";
171 #if defined(I_SYS_ACCESS) && !defined(R_OK)
172 # include <sys/access.h>
178 /* Missing protos on LynxOS */
179 void sethostent(int);
180 void endhostent(void);
182 void endnetent(void);
183 void setprotoent(int);
184 void endprotoent(void);
185 void setservent(int);
186 void endservent(void);
190 # include "amigaos4/amigaio.h"
193 #undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
195 /* F_OK unused: if stat() cannot find it... */
197 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
198 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
199 # define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
202 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
203 # ifdef I_SYS_SECURITY
204 # include <sys/security.h>
208 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
211 # define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
215 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
216 /* AIX's accessx() doesn't declare its argument const, unlike every other platform */
217 # define PERL_EFF_ACCESS(p,f) (accessx((char*)(p), (f), ACC_SELF))
221 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
222 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
223 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
226 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
228 const Uid_t ruid = getuid();
229 const Uid_t euid = geteuid();
230 const Gid_t rgid = getgid();
231 const Gid_t egid = getegid();
234 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
235 Perl_croak(aTHX_ "switching effective uid is not implemented");
238 if (setreuid(euid, ruid))
239 # elif defined(HAS_SETRESUID)
240 if (setresuid(euid, ruid, (Uid_t)-1))
242 /* diag_listed_as: entering effective %s failed */
243 Perl_croak(aTHX_ "entering effective uid failed");
246 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
247 Perl_croak(aTHX_ "switching effective gid is not implemented");
250 if (setregid(egid, rgid))
251 # elif defined(HAS_SETRESGID)
252 if (setresgid(egid, rgid, (Gid_t)-1))
254 /* diag_listed_as: entering effective %s failed */
255 Perl_croak(aTHX_ "entering effective gid failed");
258 res = access(path, mode);
261 if (setreuid(ruid, euid))
262 #elif defined(HAS_SETRESUID)
263 if (setresuid(ruid, euid, (Uid_t)-1))
265 /* diag_listed_as: leaving effective %s failed */
266 Perl_croak(aTHX_ "leaving effective uid failed");
269 if (setregid(rgid, egid))
270 #elif defined(HAS_SETRESGID)
271 if (setresgid(rgid, egid, (Gid_t)-1))
273 /* diag_listed_as: leaving effective %s failed */
274 Perl_croak(aTHX_ "leaving effective gid failed");
278 # define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
285 const char * const tmps = POPpconstx;
286 const U8 gimme = GIMME_V;
287 const char *mode = "r";
290 if (PL_op->op_private & OPpOPEN_IN_RAW)
292 else if (PL_op->op_private & OPpOPEN_IN_CRLF)
294 fp = PerlProc_popen(tmps, mode);
296 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
298 PerlIO_apply_layers(aTHX_ fp,mode,type);
300 if (gimme == G_VOID) {
302 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
305 else if (gimme == G_SCALAR) {
306 ENTER_with_name("backtick");
308 PL_rs = &PL_sv_undef;
309 SvPVCLEAR(TARG); /* note that this preserves previous buffer */
310 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
312 LEAVE_with_name("backtick");
318 SV * const sv = newSV(79);
319 if (sv_gets(sv, fp, 0) == NULL) {
324 if (SvLEN(sv) - SvCUR(sv) > 20) {
325 SvPV_shrink_to_cur(sv);
330 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
331 TAINT; /* "I believe that this is not gratuitous!" */
334 STATUS_NATIVE_CHILD_SET(-1);
335 if (gimme == G_SCALAR)
346 GV * const gv = (PL_op->op_flags & OPf_SPECIAL) ? NULL : (GV *)POPs;
350 /* make a copy of the pattern if it is gmagical, to ensure that magic
351 * is called once and only once */
352 if (SvGMAGICAL(TOPs)) TOPs = sv_2mortal(newSVsv(TOPs));
354 tryAMAGICunTARGETlist(iter_amg, (PL_op->op_flags & OPf_SPECIAL));
356 if (PL_op->op_flags & OPf_SPECIAL) {
357 /* call Perl-level glob function instead. Stack args are:
359 * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
368 /* Note that we only ever get here if File::Glob fails to load
369 * without at the same time croaking, for some reason, or if
370 * perl was built with PERL_EXTERNAL_GLOB */
372 ENTER_with_name("glob");
377 * The external globbing program may use things we can't control,
378 * so for security reasons we must assume the worst.
381 taint_proper(PL_no_security, "glob");
385 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
388 SAVESPTR(PL_rs); /* This is not permanent, either. */
389 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
392 *SvPVX(PL_rs) = '\n';
396 result = do_readline();
397 LEAVE_with_name("glob");
403 PL_last_in_gv = cGVOP_gv;
404 return do_readline();
414 do_join(TARG, &PL_sv_no, MARK, SP);
418 else if (SP == MARK) {
425 if (SvGMAGICAL(exsv)) exsv = sv_mortalcopy(exsv);
428 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
429 /* well-formed exception supplied */
432 SV * const errsv = ERRSV;
435 if (SvGMAGICAL(errsv)) {
436 exsv = sv_newmortal();
437 sv_setsv_nomg(exsv, errsv);
441 else if (SvPOKp(errsv) ? SvCUR(errsv) : SvNIOKp(errsv)) {
442 exsv = sv_newmortal();
443 sv_setsv_nomg(exsv, errsv);
444 sv_catpvs(exsv, "\t...caught");
447 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
450 if (SvROK(exsv) && !PL_warnhook)
451 Perl_warn(aTHX_ "%" SVf, SVfARG(exsv));
463 VMSISH_HUSHED || (PL_curcop->op_private & OPpHUSH_VMSISH);
465 if (SP - MARK != 1) {
467 do_join(TARG, &PL_sv_no, MARK, SP);
475 if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
476 /* well-formed exception supplied */
479 SV * const errsv = ERRSV;
483 if (sv_isobject(exsv)) {
484 HV * const stash = SvSTASH(SvRV(exsv));
485 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
487 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
488 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
495 call_sv(MUTABLE_SV(GvCV(gv)),
496 G_SCALAR|G_EVAL|G_KEEPERR);
497 exsv = sv_mortalcopy(*PL_stack_sp--);
501 else if (SvOK(errsv) && (SvPV_nomg(errsv,len), len)) {
502 exsv = sv_mortalcopy(errsv);
503 sv_catpvs(exsv, "\t...propagated");
506 exsv = newSVpvs_flags("Died", SVs_TEMP);
510 NOT_REACHED; /* NOTREACHED */
511 return NULL; /* avoid missing return from non-void function warning */
517 Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv,
518 const MAGIC *const mg, const U32 flags, U32 argc, ...)
524 PERL_ARGS_ASSERT_TIED_METHOD;
526 /* Ensure that our flag bits do not overlap. */
527 STATIC_ASSERT_STMT((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
528 STATIC_ASSERT_STMT((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
529 STATIC_ASSERT_STMT((TIED_METHOD_SAY & G_WANT) == 0);
531 PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
532 PUSHSTACKi(PERLSI_MAGIC);
533 /* extend for object + args. If argc might wrap/truncate when cast
534 * to SSize_t and incremented, set to -1, which will trigger a panic in
536 * The weird way this is written is because g++ is dumb enough to
537 * warn "comparison is always false" on something like:
539 * sizeof(a) >= sizeof(b) && a >= B_t_MAX -1
541 * (where the LH condition is false)
544 (argc > (sizeof(argc) >= sizeof(SSize_t) ? SSize_t_MAX - 1 : argc))
545 ? -1 : (SSize_t)argc + 1;
546 EXTEND(SP, extend_size);
548 PUSHs(SvTIED_obj(sv, mg));
549 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
550 Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
554 const U32 mortalize_not_needed
555 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
557 va_start(args, argc);
559 SV *const arg = va_arg(args, SV *);
560 if(mortalize_not_needed)
569 ENTER_with_name("call_tied_method");
570 if (flags & TIED_METHOD_SAY) {
571 /* local $\ = "\n" */
572 SAVEGENERICSV(PL_ors_sv);
573 PL_ors_sv = newSVpvs("\n");
575 ret_args = call_sv(methname, (flags & G_WANT)|G_METHOD_NAMED);
580 if (ret_args) { /* copy results back to original stack */
581 EXTEND(sp, ret_args);
582 Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
586 LEAVE_with_name("call_tied_method");
590 #define tied_method0(a,b,c,d) \
591 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
592 #define tied_method1(a,b,c,d,e) \
593 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
594 #define tied_method2(a,b,c,d,e,f) \
595 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
608 GV * const gv = MUTABLE_GV(*++MARK);
610 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
611 DIE(aTHX_ PL_no_usym, "filehandle");
613 if ((io = GvIOp(gv))) {
615 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
618 Perl_croak(aTHX_ "Cannot open %" HEKf " as a filehandle: it is already open as a dirhandle",
619 HEKfARG(GvENAME_HEK(gv)));
621 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
623 /* Method's args are same as ours ... */
624 /* ... except handle is replaced by the object */
625 return Perl_tied_method(aTHX_ SV_CONST(OPEN), mark - 1, MUTABLE_SV(io), mg,
626 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
638 tmps = SvPV_const(sv, len);
639 ok = do_open6(gv, tmps, len, NULL, MARK+1, (SP-MARK));
642 PUSHi( (I32)PL_forkprocess );
643 else if (PL_forkprocess == 0) /* we are a new child */
653 /* pp_coreargs pushes a NULL to indicate no args passed to
656 MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
662 IO * const io = GvIO(gv);
664 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
666 return tied_method0(SV_CONST(CLOSE), SP, MUTABLE_SV(io), mg);
670 PUSHs(boolSV(do_close(gv, TRUE)));
682 GV * const wgv = MUTABLE_GV(POPs);
683 GV * const rgv = MUTABLE_GV(POPs);
687 do_close(rgv, FALSE);
691 do_close(wgv, FALSE);
693 if (PerlProc_pipe_cloexec(fd) < 0)
696 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r" PIPE_OPEN_MODE);
697 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w" PIPE_OPEN_MODE);
698 IoOFP(rstio) = IoIFP(rstio);
699 IoIFP(wstio) = IoOFP(wstio);
700 IoTYPE(rstio) = IoTYPE_RDONLY;
701 IoTYPE(wstio) = IoTYPE_WRONLY;
703 if (!IoIFP(rstio) || !IoOFP(wstio)) {
705 PerlIO_close(IoIFP(rstio));
707 PerlLIO_close(fd[0]);
709 PerlIO_close(IoOFP(wstio));
711 PerlLIO_close(fd[1]);
719 DIE(aTHX_ PL_no_func, "pipe");
733 gv = MUTABLE_GV(POPs);
737 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
739 return tied_method0(SV_CONST(FILENO), SP, MUTABLE_SV(io), mg);
742 if (io && IoDIRP(io)) {
743 #if defined(HAS_DIRFD) || defined(HAS_DIR_DD_FD)
744 PUSHi(my_dirfd(IoDIRP(io)));
746 #elif defined(ENOTSUP)
747 errno = ENOTSUP; /* Operation not supported */
749 #elif defined(EOPNOTSUPP)
750 errno = EOPNOTSUPP; /* Operation not supported on socket */
753 errno = EINVAL; /* Invalid argument */
758 if (!io || !(fp = IoIFP(io))) {
759 /* Can't do this because people seem to do things like
760 defined(fileno($foo)) to check whether $foo is a valid fh.
767 PUSHi(PerlIO_fileno(fp));
778 if (MAXARG < 1 || (!TOPs && !POPs)) {
779 anum = PerlLIO_umask(022);
780 /* setting it to 022 between the two calls to umask avoids
781 * to have a window where the umask is set to 0 -- meaning
782 * that another thread could create world-writeable files. */
784 (void)PerlLIO_umask(anum);
787 anum = PerlLIO_umask(POPi);
788 TAINT_PROPER("umask");
791 /* Only DIE if trying to restrict permissions on "user" (self).
792 * Otherwise it's harmless and more useful to just return undef
793 * since 'group' and 'other' concepts probably don't exist here. */
794 if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
795 DIE(aTHX_ "umask not implemented");
796 XPUSHs(&PL_sv_undef);
815 gv = MUTABLE_GV(POPs);
819 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
821 /* This takes advantage of the implementation of the varargs
822 function, which I don't think that the optimiser will be able to
823 figure out. Although, as it's a static function, in theory it
825 return Perl_tied_method(aTHX_ SV_CONST(BINMODE), SP, MUTABLE_SV(io), mg,
826 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
827 discp ? 1 : 0, discp);
831 if (!io || !(fp = IoIFP(io))) {
833 SETERRNO(EBADF,RMS_IFI);
840 const char *d = NULL;
843 d = SvPV_const(discp, len);
844 mode = mode_from_discipline(d, len);
845 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
846 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
847 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
868 const I32 markoff = MARK - PL_stack_base;
869 const char *methname;
870 int how = PERL_MAGIC_tied;
874 switch(SvTYPE(varsv)) {
878 methname = "TIEHASH";
879 if (HvLAZYDEL(varsv) && (entry = HvEITER((HV *)varsv))) {
880 HvLAZYDEL_off(varsv);
881 hv_free_ent((HV *)varsv, entry);
883 HvEITER_set(MUTABLE_HV(varsv), 0);
887 methname = "TIEARRAY";
888 if (!AvREAL(varsv)) {
890 Perl_croak(aTHX_ "Cannot tie unreifiable array");
891 av_clear((AV *)varsv);
898 if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
899 methname = "TIEHANDLE";
900 how = PERL_MAGIC_tiedscalar;
901 /* For tied filehandles, we apply tiedscalar magic to the IO
902 slot of the GP rather than the GV itself. AMS 20010812 */
904 GvIOp(varsv) = newIO();
905 varsv = MUTABLE_SV(GvIOp(varsv));
908 if (SvTYPE(varsv) == SVt_PVLV && LvTYPE(varsv) == 'y') {
909 vivify_defelem(varsv);
910 varsv = LvTARG(varsv);
914 methname = "TIESCALAR";
915 how = PERL_MAGIC_tiedscalar;
919 if (sv_isobject(*MARK)) { /* Calls GET magic. */
920 ENTER_with_name("call_TIE");
921 PUSHSTACKi(PERLSI_MAGIC);
923 EXTEND(SP,(I32)items);
927 call_method(methname, G_SCALAR);
930 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
931 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
932 * wrong error message, and worse case, supreme action at a distance.
933 * (Sorry obfuscation writers. You're not going to be given this one.)
935 stash = gv_stashsv(*MARK, 0);
938 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\"",
939 methname, SVfARG(*MARK));
940 else if (isGV(*MARK)) {
941 /* If the glob doesn't name an existing package, using
942 * SVfARG(*MARK) would yield "*Foo::Bar" or *main::Foo. So
943 * generate the name for the error message explicitly. */
944 SV *stashname = sv_2mortal(newSV(0));
945 gv_fullname4(stashname, (GV *) *MARK, NULL, FALSE);
946 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\"",
947 methname, SVfARG(stashname));
950 SV *stashname = !SvPOK(*MARK) ? &PL_sv_no
951 : SvCUR(*MARK) ? *MARK
952 : sv_2mortal(newSVpvs("main"));
953 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" SVf "\""
954 " (perhaps you forgot to load \"%" SVf "\"?)",
955 methname, SVfARG(stashname), SVfARG(stashname));
958 else if (!(gv = gv_fetchmethod(stash, methname))) {
959 /* The effective name can only be NULL for stashes that have
960 * been deleted from the symbol table, which this one can't
961 * be, since we just looked it up by name.
963 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%" HEKf "\"",
964 methname, HvENAME_HEK_NN(stash));
966 ENTER_with_name("call_TIE");
967 PUSHSTACKi(PERLSI_MAGIC);
969 EXTEND(SP,(I32)items);
973 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
979 if (sv_isobject(sv)) {
980 sv_unmagic(varsv, how);
981 /* Croak if a self-tie on an aggregate is attempted. */
982 if (varsv == SvRV(sv) &&
983 (SvTYPE(varsv) == SVt_PVAV ||
984 SvTYPE(varsv) == SVt_PVHV))
986 "Self-ties of arrays and hashes are not supported");
987 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
989 LEAVE_with_name("call_TIE");
990 SP = PL_stack_base + markoff;
996 /* also used for: pp_dbmclose() */
1003 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1004 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1006 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1009 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1010 !(sv = defelem_target(sv, NULL))) RETPUSHUNDEF;
1012 if ((mg = SvTIED_mg(sv, how))) {
1013 SV * const obj = SvRV(SvTIED_obj(sv, mg));
1014 if (obj && SvSTASH(obj)) {
1015 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
1017 if (gv && isGV(gv) && (cv = GvCV(gv))) {
1019 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
1020 mXPUSHi(SvREFCNT(obj) - 1);
1022 ENTER_with_name("call_UNTIE");
1023 call_sv(MUTABLE_SV(cv), G_VOID);
1024 LEAVE_with_name("call_UNTIE");
1027 else if (mg && SvREFCNT(obj) > 1) {
1028 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
1029 "untie attempted while %" UVuf " inner references still exist",
1030 (UV)SvREFCNT(obj) - 1 ) ;
1034 sv_unmagic(sv, how) ;
1043 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
1044 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
1046 if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
1049 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y' &&
1050 !(sv = defelem_target(sv, NULL))) goto ret_undef;
1052 if ((mg = SvTIED_mg(sv, how))) {
1053 SETs(SvTIED_obj(sv, mg));
1054 return NORMAL; /* PUTBACK not needed, pp_tied never moves SP */
1068 HV * const hv = MUTABLE_HV(POPs);
1069 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1070 stash = gv_stashsv(sv, 0);
1071 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1073 require_pv("AnyDBM_File.pm");
1075 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1076 DIE(aTHX_ "No dbm on this machine");
1086 mPUSHu(O_RDWR|O_CREAT);
1090 if (!SvOK(right)) right = &PL_sv_no;
1094 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1097 if (!sv_isobject(TOPs)) {
1105 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1107 if (sv_isobject(TOPs))
1112 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1113 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1130 struct timeval timebuf;
1131 struct timeval *tbuf = &timebuf;
1135 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1140 # if BYTEORDER & 0xf0000
1141 # define ORDERBYTE (0x88888888 - BYTEORDER)
1143 # define ORDERBYTE (0x4444 - BYTEORDER)
1149 for (i = 1; i <= 3; i++) {
1150 SV * const sv = svs[i] = SP[i];
1154 if (SvREADONLY(sv)) {
1155 if (!(SvPOK(sv) && SvCUR(sv) == 0))
1156 Perl_croak_no_modify();
1158 else if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
1161 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1162 "Non-string passed as bitmask");
1163 if (SvGAMAGIC(sv)) {
1164 svs[i] = sv_newmortal();
1165 sv_copypv_nomg(svs[i], sv);
1168 SvPV_force_nomg_nolen(sv); /* force string conversion */
1175 /* little endians can use vecs directly */
1176 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1183 masksize = NFDBITS / NBBY;
1185 masksize = sizeof(long); /* documented int, everyone seems to use long */
1187 Zero(&fd_sets[0], 4, char*);
1190 # if SELECT_MIN_BITS == 1
1191 growsize = sizeof(fd_set);
1193 # if defined(__GLIBC__) && defined(__FD_SETSIZE)
1194 # undef SELECT_MIN_BITS
1195 # define SELECT_MIN_BITS __FD_SETSIZE
1197 /* If SELECT_MIN_BITS is greater than one we most probably will want
1198 * to align the sizes with SELECT_MIN_BITS/8 because for example
1199 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1200 * UNIX, Solaris, Darwin) the smallest quantum select() operates
1201 * on (sets/tests/clears bits) is 32 bits. */
1202 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1208 value = SvNV_nomg(sv);
1211 timebuf.tv_sec = (long)value;
1212 value -= (NV)timebuf.tv_sec;
1213 timebuf.tv_usec = (long)(value * 1000000.0);
1218 for (i = 1; i <= 3; i++) {
1220 if (!SvOK(sv) || SvCUR(sv) == 0) {
1227 Sv_Grow(sv, growsize);
1231 while (++j <= growsize) {
1235 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1237 Newx(fd_sets[i], growsize, char);
1238 for (offset = 0; offset < growsize; offset += masksize) {
1239 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1240 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1243 fd_sets[i] = SvPVX(sv);
1247 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1248 /* Can't make just the (void*) conditional because that would be
1249 * cpp #if within cpp macro, and not all compilers like that. */
1250 nfound = PerlSock_select(
1252 (Select_fd_set_t) fd_sets[1],
1253 (Select_fd_set_t) fd_sets[2],
1254 (Select_fd_set_t) fd_sets[3],
1255 (void*) tbuf); /* Workaround for compiler bug. */
1257 nfound = PerlSock_select(
1259 (Select_fd_set_t) fd_sets[1],
1260 (Select_fd_set_t) fd_sets[2],
1261 (Select_fd_set_t) fd_sets[3],
1264 for (i = 1; i <= 3; i++) {
1267 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1269 for (offset = 0; offset < growsize; offset += masksize) {
1270 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1271 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1273 Safefree(fd_sets[i]);
1276 SvSetMagicSV(SP[i], sv);
1283 if (GIMME_V == G_ARRAY && tbuf) {
1284 value = (NV)(timebuf.tv_sec) +
1285 (NV)(timebuf.tv_usec) / 1000000.0;
1290 DIE(aTHX_ "select not implemented");
1298 =for apidoc setdefout
1300 Sets C<PL_defoutgv>, the default file handle for output, to the passed in
1301 typeglob. As C<PL_defoutgv> "owns" a reference on its typeglob, the reference
1302 count of the passed in typeglob is increased by one, and the reference count
1303 of the typeglob that C<PL_defoutgv> points to is decreased by one.
1309 Perl_setdefout(pTHX_ GV *gv)
1311 GV *oldgv = PL_defoutgv;
1313 PERL_ARGS_ASSERT_SETDEFOUT;
1315 SvREFCNT_inc_simple_void_NN(gv);
1317 SvREFCNT_dec(oldgv);
1324 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1325 GV * egv = GvEGVx(PL_defoutgv);
1330 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1331 gvp = hv && HvENAME(hv)
1332 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1334 if (gvp && *gvp == egv) {
1335 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1339 mXPUSHs(newRV(MUTABLE_SV(egv)));
1343 if (!GvIO(newdefout))
1344 gv_IOadd(newdefout);
1345 setdefout(newdefout);
1354 /* pp_coreargs pushes a NULL to indicate no args passed to
1357 MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1358 IO *const io = GvIO(gv);
1364 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1366 const U8 gimme = GIMME_V;
1367 Perl_tied_method(aTHX_ SV_CONST(GETC), SP, MUTABLE_SV(io), mg, gimme, 0);
1368 if (gimme == G_SCALAR) {
1370 SvSetMagicSV_nosteal(TARG, TOPs);
1375 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1376 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1378 SETERRNO(EBADF,RMS_IFI);
1382 sv_setpvs(TARG, " ");
1383 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1384 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1385 /* Find out how many bytes the char needs */
1386 Size_t len = UTF8SKIP(SvPVX_const(TARG));
1389 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1390 SvCUR_set(TARG,1+len);
1394 else SvUTF8_off(TARG);
1400 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1403 const U8 gimme = GIMME_V;
1405 PERL_ARGS_ASSERT_DOFORM;
1408 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1410 cx = cx_pushblock(CXt_FORMAT, gimme, PL_stack_sp, PL_savestack_ix);
1411 cx_pushformat(cx, cv, retop, gv);
1412 if (CvDEPTH(cv) >= 2)
1413 pad_push(CvPADLIST(cv), CvDEPTH(cv));
1414 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), CvDEPTH(cv));
1416 setdefout(gv); /* locally select filehandle so $% et al work */
1433 gv = MUTABLE_GV(POPs);
1450 SV * const tmpsv = sv_newmortal();
1451 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1452 DIE(aTHX_ "Undefined format \"%" SVf "\" called", SVfARG(tmpsv));
1454 IoFLAGS(io) &= ~IOf_DIDTOP;
1455 RETURNOP(doform(cv,gv,PL_op->op_next));
1461 GV * const gv = CX_CUR()->blk_format.gv;
1462 IO * const io = GvIOp(gv);
1467 bool is_return = cBOOL(PL_op->op_type == OP_RETURN);
1469 if (is_return || !io || !(ofp = IoOFP(io)))
1472 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1473 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1475 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1476 PL_formtarget != PL_toptarget)
1480 if (!IoTOP_GV(io)) {
1483 if (!IoTOP_NAME(io)) {
1485 if (!IoFMT_NAME(io))
1486 IoFMT_NAME(io) = savepv(GvNAME(gv));
1487 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%" HEKf "_TOP",
1488 HEKfARG(GvNAME_HEK(gv))));
1489 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1490 if ((topgv && GvFORM(topgv)) ||
1491 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1492 IoTOP_NAME(io) = savesvpv(topname);
1494 IoTOP_NAME(io) = savepvs("top");
1496 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1497 if (!topgv || !GvFORM(topgv)) {
1498 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1501 IoTOP_GV(io) = topgv;
1503 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1504 I32 lines = IoLINES_LEFT(io);
1505 const char *s = SvPVX_const(PL_formtarget);
1506 const char *e = SvEND(PL_formtarget);
1507 if (lines <= 0) /* Yow, header didn't even fit!!! */
1509 while (lines-- > 0) {
1510 s = (char *) memchr(s, '\n', e - s);
1516 const STRLEN save = SvCUR(PL_formtarget);
1517 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1518 do_print(PL_formtarget, ofp);
1519 SvCUR_set(PL_formtarget, save);
1520 sv_chop(PL_formtarget, s);
1521 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1524 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1525 do_print(GvSV(gv_fetchpvs("\f", GV_ADD, SVt_PV)), ofp);
1526 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1528 PL_formtarget = PL_toptarget;
1529 IoFLAGS(io) |= IOf_DIDTOP;
1531 assert(fgv); /* IoTOP_GV(io) should have been set above */
1534 SV * const sv = sv_newmortal();
1535 gv_efullname4(sv, fgv, NULL, FALSE);
1536 DIE(aTHX_ "Undefined top format \"%" SVf "\" called", SVfARG(sv));
1538 return doform(cv, gv, PL_op);
1543 assert(CxTYPE(cx) == CXt_FORMAT);
1544 SP = PL_stack_base + cx->blk_oldsp; /* ignore retval of formline */
1548 retop = cx->blk_sub.retop;
1554 /* XXX the semantics of doing 'return' in a format aren't documented.
1555 * Currently we ignore any args to 'return' and just return
1556 * a single undef in both scalar and list contexts
1558 PUSHs(&PL_sv_undef);
1559 else if (!io || !(fp = IoOFP(io))) {
1560 if (io && IoIFP(io))
1561 report_wrongway_fh(gv, '<');
1567 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1568 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1570 if (!do_print(PL_formtarget, fp))
1573 FmLINES(PL_formtarget) = 0;
1574 SvCUR_set(PL_formtarget, 0);
1575 *SvEND(PL_formtarget) = '\0';
1576 if (IoFLAGS(io) & IOf_FLUSH)
1577 (void)PerlIO_flush(fp);
1581 PL_formtarget = PL_bodytarget;
1587 dSP; dMARK; dORIGMARK;
1591 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1592 IO *const io = GvIO(gv);
1594 /* Treat empty list as "" */
1595 if (MARK == SP) XPUSHs(&PL_sv_no);
1598 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1600 if (MARK == ORIGMARK) {
1603 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1606 return Perl_tied_method(aTHX_ SV_CONST(PRINTF), mark - 1, MUTABLE_SV(io),
1608 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1615 SETERRNO(EBADF,RMS_IFI);
1618 else if (!(fp = IoOFP(io))) {
1620 report_wrongway_fh(gv, '<');
1621 else if (ckWARN(WARN_CLOSED))
1623 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1627 SV *sv = sv_newmortal();
1628 do_sprintf(sv, SP - MARK, MARK + 1);
1629 if (!do_print(sv, fp))
1632 if (IoFLAGS(io) & IOf_FLUSH)
1633 if (PerlIO_flush(fp) == EOF)
1642 PUSHs(&PL_sv_undef);
1649 const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1650 const int mode = POPi;
1651 SV * const sv = POPs;
1652 GV * const gv = MUTABLE_GV(POPs);
1655 /* Need TIEHANDLE method ? */
1656 const char * const tmps = SvPV_const(sv, len);
1657 if (do_open_raw(gv, tmps, len, mode, perm, NULL)) {
1658 IoLINES(GvIOp(gv)) = 0;
1662 PUSHs(&PL_sv_undef);
1668 /* also used for: pp_read() and pp_recv() (where supported) */
1672 dSP; dMARK; dORIGMARK; dTARGET;
1686 bool charstart = FALSE;
1687 STRLEN charskip = 0;
1689 GV * const gv = MUTABLE_GV(*++MARK);
1692 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1693 && gv && (io = GvIO(gv)) )
1695 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1697 return Perl_tied_method(aTHX_ SV_CONST(READ), mark - 1, MUTABLE_SV(io), mg,
1698 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1708 length = SvIVx(*++MARK);
1710 DIE(aTHX_ "Negative length");
1713 offset = SvIVx(*++MARK);
1717 if (!io || !IoIFP(io)) {
1719 SETERRNO(EBADF,RMS_IFI);
1723 /* Note that fd can here validly be -1, don't check it yet. */
1724 fd = PerlIO_fileno(IoIFP(io));
1726 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1727 if (PL_op->op_type == OP_SYSREAD || PL_op->op_type == OP_RECV) {
1729 "%s() isn't allowed on :utf8 handles",
1732 buffer = SvPVutf8_force(bufsv, blen);
1733 /* UTF-8 may not have been set if they are all low bytes */
1738 buffer = SvPV_force(bufsv, blen);
1739 buffer_utf8 = DO_UTF8(bufsv);
1741 if (DO_UTF8(bufsv)) {
1742 blen = sv_len_utf8_nomg(bufsv);
1751 if (PL_op->op_type == OP_RECV) {
1752 Sock_size_t bufsize;
1753 char namebuf[MAXPATHLEN];
1755 SETERRNO(EBADF,SS_IVCHAN);
1758 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
1759 bufsize = sizeof (struct sockaddr_in);
1761 bufsize = sizeof namebuf;
1763 #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1767 buffer = SvGROW(bufsv, (STRLEN)(length+1));
1768 /* 'offset' means 'flags' here */
1769 count = PerlSock_recvfrom(fd, buffer, length, offset,
1770 (struct sockaddr *)namebuf, &bufsize);
1773 /* MSG_TRUNC can give oversized count; quietly lose it */
1776 SvCUR_set(bufsv, count);
1777 *SvEND(bufsv) = '\0';
1778 (void)SvPOK_only(bufsv);
1782 /* This should not be marked tainted if the fp is marked clean */
1783 if (!(IoFLAGS(io) & IOf_UNTAINT))
1784 SvTAINTED_on(bufsv);
1786 #if defined(__CYGWIN__)
1787 /* recvfrom() on cygwin doesn't set bufsize at all for
1788 connected sockets, leaving us with trash in the returned
1789 name, so use the same test as the Win32 code to check if it
1790 wasn't set, and set it [perl #118843] */
1791 if (bufsize == sizeof namebuf)
1794 sv_setpvn(TARG, namebuf, bufsize);
1800 if (-offset > (SSize_t)blen)
1801 DIE(aTHX_ "Offset outside string");
1804 if (DO_UTF8(bufsv)) {
1805 /* convert offset-as-chars to offset-as-bytes */
1806 if (offset >= (SSize_t)blen)
1807 offset += SvCUR(bufsv) - blen;
1809 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1813 /* Reestablish the fd in case it shifted from underneath us. */
1814 fd = PerlIO_fileno(IoIFP(io));
1816 orig_size = SvCUR(bufsv);
1817 /* Allocating length + offset + 1 isn't perfect in the case of reading
1818 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1820 (should be 2 * length + offset + 1, or possibly something longer if
1821 IN_ENCODING Is true) */
1822 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
1823 if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1824 Zero(buffer+orig_size, offset-orig_size, char);
1826 buffer = buffer + offset;
1828 read_target = bufsv;
1830 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1831 concatenate it to the current buffer. */
1833 /* Truncate the existing buffer to the start of where we will be
1835 SvCUR_set(bufsv, offset);
1837 read_target = sv_newmortal();
1838 SvUPGRADE(read_target, SVt_PV);
1839 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1842 if (PL_op->op_type == OP_SYSREAD) {
1843 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1844 if (IoTYPE(io) == IoTYPE_SOCKET) {
1846 SETERRNO(EBADF,SS_IVCHAN);
1850 count = PerlSock_recv(fd, buffer, length, 0);
1856 SETERRNO(EBADF,RMS_IFI);
1860 count = PerlLIO_read(fd, buffer, length);
1865 count = PerlIO_read(IoIFP(io), buffer, length);
1866 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1867 if (count == 0 && PerlIO_error(IoIFP(io)))
1871 if (IoTYPE(io) == IoTYPE_WRONLY)
1872 report_wrongway_fh(gv, '>');
1875 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1876 *SvEND(read_target) = '\0';
1877 (void)SvPOK_only(read_target);
1878 if (fp_utf8 && !IN_BYTES) {
1879 /* Look at utf8 we got back and count the characters */
1880 const char *bend = buffer + count;
1881 while (buffer < bend) {
1883 skip = UTF8SKIP(buffer);
1886 if (buffer - charskip + skip > bend) {
1887 /* partial character - try for rest of it */
1888 length = skip - (bend-buffer);
1889 offset = bend - SvPVX_const(bufsv);
1901 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1902 provided amount read (count) was what was requested (length)
1904 if (got < wanted && count == length) {
1905 length = wanted - got;
1906 offset = bend - SvPVX_const(bufsv);
1909 /* return value is character count */
1913 else if (buffer_utf8) {
1914 /* Let svcatsv upgrade the bytes we read in to utf8.
1915 The buffer is a mortal so will be freed soon. */
1916 sv_catsv_nomg(bufsv, read_target);
1919 /* This should not be marked tainted if the fp is marked clean */
1920 if (!(IoFLAGS(io) & IOf_UNTAINT))
1921 SvTAINTED_on(bufsv);
1932 /* also used for: pp_send() where defined */
1936 dSP; dMARK; dORIGMARK; dTARGET;
1941 const int op_type = PL_op->op_type;
1944 GV *const gv = MUTABLE_GV(*++MARK);
1945 IO *const io = GvIO(gv);
1948 if (op_type == OP_SYSWRITE && io) {
1949 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1951 if (MARK == SP - 1) {
1953 mXPUSHi(sv_len(sv));
1957 return Perl_tied_method(aTHX_ SV_CONST(WRITE), mark - 1, MUTABLE_SV(io), mg,
1958 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1968 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1970 if (io && IoIFP(io))
1971 report_wrongway_fh(gv, '<');
1974 SETERRNO(EBADF,RMS_IFI);
1977 fd = PerlIO_fileno(IoIFP(io));
1979 SETERRNO(EBADF,SS_IVCHAN);
1984 /* Do this first to trigger any overloading. */
1985 buffer = SvPV_const(bufsv, blen);
1986 doing_utf8 = DO_UTF8(bufsv);
1988 if (PerlIO_isutf8(IoIFP(io))) {
1990 "%s() isn't allowed on :utf8 handles",
1993 else if (doing_utf8) {
1994 STRLEN tmplen = blen;
1995 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
1998 buffer = (char *) tmpbuf;
2002 assert((char *)result == buffer);
2003 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
2008 if (op_type == OP_SEND) {
2009 const int flags = SvIVx(*++MARK);
2012 char * const sockbuf = SvPVx(*++MARK, mlen);
2013 retval = PerlSock_sendto(fd, buffer, blen,
2014 flags, (struct sockaddr *)sockbuf, mlen);
2017 retval = PerlSock_send(fd, buffer, blen, flags);
2023 Size_t length = 0; /* This length is in characters. */
2029 #if Size_t_size > IVSIZE
2030 length = (Size_t)SvNVx(*++MARK);
2032 length = (Size_t)SvIVx(*++MARK);
2034 if ((SSize_t)length < 0) {
2036 DIE(aTHX_ "Negative length");
2041 offset = SvIVx(*++MARK);
2043 if (-offset > (IV)blen) {
2045 DIE(aTHX_ "Offset outside string");
2048 } else if (offset > (IV)blen) {
2050 DIE(aTHX_ "Offset outside string");
2054 if (length > blen - offset)
2055 length = blen - offset;
2056 buffer = buffer+offset;
2058 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2059 if (IoTYPE(io) == IoTYPE_SOCKET) {
2060 retval = PerlSock_send(fd, buffer, length, 0);
2065 /* See the note at doio.c:do_print about filesize limits. --jhi */
2066 retval = PerlLIO_write(fd, buffer, length);
2075 #if Size_t_size > IVSIZE
2095 * in Perl 5.12 and later, the additional parameter is a bitmask:
2098 * 2 = eof() <- ARGV magic
2100 * I'll rely on the compiler's trace flow analysis to decide whether to
2101 * actually assign this out here, or punt it into the only block where it is
2102 * used. Doing it out here is DRY on the condition logic.
2107 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
2113 if (PL_op->op_flags & OPf_SPECIAL) {
2114 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
2118 gv = PL_last_in_gv; /* eof */
2126 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2127 return tied_method1(SV_CONST(EOF), SP, MUTABLE_SV(io), mg, newSVuv(which));
2130 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2131 if (io && !IoIFP(io)) {
2132 if ((IoFLAGS(io) & IOf_START) && av_tindex(GvAVn(gv)) < 0) {
2135 IoFLAGS(io) &= ~IOf_START;
2136 do_open6(gv, "-", 1, NULL, NULL, 0);
2144 *svp = newSVpvs("-");
2146 else if (!nextargv(gv, FALSE))
2151 PUSHs(boolSV(do_eof(gv)));
2161 if (MAXARG != 0 && (TOPs || POPs))
2162 PL_last_in_gv = MUTABLE_GV(POPs);
2169 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2171 return tied_method0(SV_CONST(TELL), SP, MUTABLE_SV(io), mg);
2176 SETERRNO(EBADF,RMS_IFI);
2181 #if LSEEKSIZE > IVSIZE
2182 PUSHn( (NV)do_tell(gv) );
2184 PUSHi( (IV)do_tell(gv) );
2190 /* also used for: pp_seek() */
2195 const int whence = POPi;
2196 #if LSEEKSIZE > IVSIZE
2197 const Off_t offset = (Off_t)SvNVx(POPs);
2199 const Off_t offset = (Off_t)SvIVx(POPs);
2202 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2203 IO *const io = GvIO(gv);
2206 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2208 #if LSEEKSIZE > IVSIZE
2209 SV *const offset_sv = newSVnv((NV) offset);
2211 SV *const offset_sv = newSViv(offset);
2214 return tied_method2(SV_CONST(SEEK), SP, MUTABLE_SV(io), mg, offset_sv,
2219 if (PL_op->op_type == OP_SEEK)
2220 PUSHs(boolSV(do_seek(gv, offset, whence)));
2222 const Off_t sought = do_sysseek(gv, offset, whence);
2224 PUSHs(&PL_sv_undef);
2226 SV* const sv = sought ?
2227 #if LSEEKSIZE > IVSIZE
2232 : newSVpvn(zero_but_true, ZBTLEN);
2242 /* There seems to be no consensus on the length type of truncate()
2243 * and ftruncate(), both off_t and size_t have supporters. In
2244 * general one would think that when using large files, off_t is
2245 * at least as wide as size_t, so using an off_t should be okay. */
2246 /* XXX Configure probe for the length type of *truncate() needed XXX */
2249 #if Off_t_size > IVSIZE
2254 /* Checking for length < 0 is problematic as the type might or
2255 * might not be signed: if it is not, clever compilers will moan. */
2256 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2259 SV * const sv = POPs;
2264 if (PL_op->op_flags & OPf_SPECIAL
2265 ? (tmpgv = gv_fetchsv(sv, 0, SVt_PVIO), 1)
2266 : !!(tmpgv = MAYBE_DEREF_GV(sv)) ) {
2273 TAINT_PROPER("truncate");
2274 if (!(fp = IoIFP(io))) {
2278 int fd = PerlIO_fileno(fp);
2280 SETERRNO(EBADF,RMS_IFI);
2284 SETERRNO(EINVAL, LIB_INVARG);
2289 if (ftruncate(fd, len) < 0)
2291 if (my_chsize(fd, len) < 0)
2299 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2300 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2301 goto do_ftruncate_io;
2304 const char * const name = SvPV_nomg_const_nolen(sv);
2305 TAINT_PROPER("truncate");
2307 if (truncate(name, len) < 0)
2314 #if defined(USE_64_BIT_RAWIO) && defined(O_LARGEFILE)
2315 mode |= O_LARGEFILE; /* Transparently largefiley. */
2318 /* On open(), the Win32 CRT tries to seek around text
2319 * files using 32-bit offsets, which causes the open()
2320 * to fail on large files, so open in binary mode.
2324 tmpfd = PerlLIO_open_cloexec(name, mode);
2329 if (my_chsize(tmpfd, len) < 0)
2331 PerlLIO_close(tmpfd);
2340 SETERRNO(EBADF,RMS_IFI);
2346 /* also used for: pp_fcntl() */
2351 SV * const argsv = POPs;
2352 const unsigned int func = POPu;
2354 GV * const gv = MUTABLE_GV(POPs);
2355 IO * const io = GvIOn(gv);
2361 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
2365 if (SvPOK(argsv) || !SvNIOK(argsv)) {
2368 s = SvPV_force(argsv, len);
2369 need = IOCPARM_LEN(func);
2371 s = Sv_Grow(argsv, need + 1);
2372 SvCUR_set(argsv, need);
2375 s[SvCUR(argsv)] = 17; /* a little sanity check here */
2378 retval = SvIV(argsv);
2379 s = INT2PTR(char*,retval); /* ouch */
2382 optype = PL_op->op_type;
2383 TAINT_PROPER(PL_op_desc[optype]);
2385 if (optype == OP_IOCTL)
2387 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2389 DIE(aTHX_ "ioctl is not implemented");
2393 DIE(aTHX_ "fcntl is not implemented");
2394 #elif defined(OS2) && defined(__EMX__)
2395 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2397 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2400 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2402 if (s[SvCUR(argsv)] != 17)
2403 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2405 s[SvCUR(argsv)] = 0; /* put our null back */
2406 SvSETMAGIC(argsv); /* Assume it has changed */
2415 PUSHp(zero_but_true, ZBTLEN);
2426 const int argtype = POPi;
2427 GV * const gv = MUTABLE_GV(POPs);
2428 IO *const io = GvIO(gv);
2429 PerlIO *const fp = io ? IoIFP(io) : NULL;
2431 /* XXX Looks to me like io is always NULL at this point */
2433 (void)PerlIO_flush(fp);
2434 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2439 SETERRNO(EBADF,RMS_IFI);
2444 DIE(aTHX_ PL_no_func, "flock");
2455 const int protocol = POPi;
2456 const int type = POPi;
2457 const int domain = POPi;
2458 GV * const gv = MUTABLE_GV(POPs);
2459 IO * const io = GvIOn(gv);
2463 do_close(gv, FALSE);
2465 TAINT_PROPER("socket");
2466 fd = PerlSock_socket_cloexec(domain, type, protocol);
2470 IoIFP(io) = PerlIO_fdopen(fd, "r" SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2471 IoOFP(io) = PerlIO_fdopen(fd, "w" SOCKET_OPEN_MODE);
2472 IoTYPE(io) = IoTYPE_SOCKET;
2473 if (!IoIFP(io) || !IoOFP(io)) {
2474 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2475 if (IoOFP(io)) PerlIO_close(IoOFP(io));
2476 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2486 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2489 const int protocol = POPi;
2490 const int type = POPi;
2491 const int domain = POPi;
2493 GV * const gv2 = MUTABLE_GV(POPs);
2494 IO * const io2 = GvIOn(gv2);
2495 GV * const gv1 = MUTABLE_GV(POPs);
2496 IO * const io1 = GvIOn(gv1);
2499 do_close(gv1, FALSE);
2501 do_close(gv2, FALSE);
2503 TAINT_PROPER("socketpair");
2504 if (PerlSock_socketpair_cloexec(domain, type, protocol, fd) < 0)
2506 IoIFP(io1) = PerlIO_fdopen(fd[0], "r" SOCKET_OPEN_MODE);
2507 IoOFP(io1) = PerlIO_fdopen(fd[0], "w" SOCKET_OPEN_MODE);
2508 IoTYPE(io1) = IoTYPE_SOCKET;
2509 IoIFP(io2) = PerlIO_fdopen(fd[1], "r" SOCKET_OPEN_MODE);
2510 IoOFP(io2) = PerlIO_fdopen(fd[1], "w" SOCKET_OPEN_MODE);
2511 IoTYPE(io2) = IoTYPE_SOCKET;
2512 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2513 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2514 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2515 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2516 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2517 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2518 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2524 DIE(aTHX_ PL_no_sock_func, "socketpair");
2530 /* also used for: pp_connect() */
2535 SV * const addrsv = POPs;
2536 /* OK, so on what platform does bind modify addr? */
2538 GV * const gv = MUTABLE_GV(POPs);
2539 IO * const io = GvIOn(gv);
2546 fd = PerlIO_fileno(IoIFP(io));
2550 addr = SvPV_const(addrsv, len);
2551 op_type = PL_op->op_type;
2552 TAINT_PROPER(PL_op_desc[op_type]);
2553 if ((op_type == OP_BIND
2554 ? PerlSock_bind(fd, (struct sockaddr *)addr, len)
2555 : PerlSock_connect(fd, (struct sockaddr *)addr, len))
2563 SETERRNO(EBADF,SS_IVCHAN);
2570 const int backlog = POPi;
2571 GV * const gv = MUTABLE_GV(POPs);
2572 IO * const io = GvIOn(gv);
2577 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2584 SETERRNO(EBADF,SS_IVCHAN);
2592 char namebuf[MAXPATHLEN];
2593 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(__QNXNTO__)
2594 Sock_size_t len = sizeof (struct sockaddr_in);
2596 Sock_size_t len = sizeof namebuf;
2598 GV * const ggv = MUTABLE_GV(POPs);
2599 GV * const ngv = MUTABLE_GV(POPs);
2602 IO * const gstio = GvIO(ggv);
2603 if (!gstio || !IoIFP(gstio))
2607 fd = PerlSock_accept_cloexec(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2610 /* Some platforms indicate zero length when an AF_UNIX client is
2611 * not bound. Simulate a non-zero-length sockaddr structure in
2613 namebuf[0] = 0; /* sun_len */
2614 namebuf[1] = AF_UNIX; /* sun_family */
2622 do_close(ngv, FALSE);
2623 IoIFP(nstio) = PerlIO_fdopen(fd, "r" SOCKET_OPEN_MODE);
2624 IoOFP(nstio) = PerlIO_fdopen(fd, "w" SOCKET_OPEN_MODE);
2625 IoTYPE(nstio) = IoTYPE_SOCKET;
2626 if (!IoIFP(nstio) || !IoOFP(nstio)) {
2627 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2628 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2629 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2633 #ifdef __SCO_VERSION__
2634 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2637 PUSHp(namebuf, len);
2641 report_evil_fh(ggv);
2642 SETERRNO(EBADF,SS_IVCHAN);
2652 const int how = POPi;
2653 GV * const gv = MUTABLE_GV(POPs);
2654 IO * const io = GvIOn(gv);
2659 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2664 SETERRNO(EBADF,SS_IVCHAN);
2669 /* also used for: pp_gsockopt() */
2674 const int optype = PL_op->op_type;
2675 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2676 const unsigned int optname = (unsigned int) POPi;
2677 const unsigned int lvl = (unsigned int) POPi;
2678 GV * const gv = MUTABLE_GV(POPs);
2679 IO * const io = GvIOn(gv);
2686 fd = PerlIO_fileno(IoIFP(io));
2692 (void)SvPOK_only(sv);
2696 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2699 /* XXX Configure test: does getsockopt set the length properly? */
2708 #if defined(__SYMBIAN32__)
2709 # define SETSOCKOPT_OPTION_VALUE_T void *
2711 # define SETSOCKOPT_OPTION_VALUE_T const char *
2713 /* XXX TODO: We need to have a proper type (a Configure probe,
2714 * etc.) for what the C headers think of the third argument of
2715 * setsockopt(), the option_value read-only buffer: is it
2716 * a "char *", or a "void *", const or not. Some compilers
2717 * don't take kindly to e.g. assuming that "char *" implicitly
2718 * promotes to a "void *", or to explicitly promoting/demoting
2719 * consts to non/vice versa. The "const void *" is the SUS
2720 * definition, but that does not fly everywhere for the above
2722 SETSOCKOPT_OPTION_VALUE_T buf;
2726 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2730 aint = (int)SvIV(sv);
2731 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2734 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2744 SETERRNO(EBADF,SS_IVCHAN);
2751 /* also used for: pp_getsockname() */
2756 const int optype = PL_op->op_type;
2757 GV * const gv = MUTABLE_GV(POPs);
2758 IO * const io = GvIOn(gv);
2766 #ifdef HAS_SOCKADDR_STORAGE
2767 len = sizeof(struct sockaddr_storage);
2771 sv = sv_2mortal(newSV(len+1));
2772 (void)SvPOK_only(sv);
2775 fd = PerlIO_fileno(IoIFP(io));
2779 case OP_GETSOCKNAME:
2780 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2783 case OP_GETPEERNAME:
2784 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2786 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2788 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";
2789 /* If the call succeeded, make sure we don't have a zeroed port/addr */
2790 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2791 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2792 sizeof(u_short) + sizeof(struct in_addr))) {
2799 #ifdef BOGUS_GETNAME_RETURN
2800 /* Interactive Unix, getpeername() and getsockname()
2801 does not return valid namelen */
2802 if (len == BOGUS_GETNAME_RETURN)
2803 len = sizeof(struct sockaddr);
2812 SETERRNO(EBADF,SS_IVCHAN);
2821 /* also used for: pp_lstat() */
2832 if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2833 : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2834 if (PL_op->op_type == OP_LSTAT) {
2835 if (gv != PL_defgv) {
2836 do_fstat_warning_check:
2837 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2838 "lstat() on filehandle%s%" SVf,
2841 ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2843 } else if (PL_laststype != OP_LSTAT)
2844 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2845 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2848 if (gv == PL_defgv) {
2849 if (PL_laststatval < 0)
2850 SETERRNO(EBADF,RMS_IFI);
2853 PL_laststype = OP_STAT;
2854 PL_statgv = gv ? gv : (GV *)io;
2855 SvPVCLEAR(PL_statname);
2861 int fd = PerlIO_fileno(IoIFP(io));
2864 PL_laststatval = -1;
2865 SETERRNO(EBADF,RMS_IFI);
2867 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
2869 } else if (IoDIRP(io)) {
2871 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2874 PL_laststatval = -1;
2875 SETERRNO(EBADF,RMS_IFI);
2879 PL_laststatval = -1;
2880 SETERRNO(EBADF,RMS_IFI);
2884 if (PL_laststatval < 0) {
2892 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2893 io = MUTABLE_IO(SvRV(sv));
2894 if (PL_op->op_type == OP_LSTAT)
2895 goto do_fstat_warning_check;
2896 goto do_fstat_have_io;
2898 SvTAINTED_off(PL_statname); /* previous tainting irrelevant */
2899 temp = SvPV_nomg_const(sv, len);
2900 sv_setpv(PL_statname, temp);
2902 PL_laststype = PL_op->op_type;
2903 file = SvPV_nolen_const(PL_statname);
2904 if (!IS_SAFE_PATHNAME(temp, len, OP_NAME(PL_op))) {
2905 PL_laststatval = -1;
2907 else if (PL_op->op_type == OP_LSTAT)
2908 PL_laststatval = PerlLIO_lstat(file, &PL_statcache);
2910 PL_laststatval = PerlLIO_stat(file, &PL_statcache);
2911 if (PL_laststatval < 0) {
2912 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
2913 /* PL_warn_nl is constant */
2914 GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral);
2915 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2916 GCC_DIAG_RESTORE_STMT;
2923 if (gimme != G_ARRAY) {
2924 if (gimme != G_VOID)
2925 XPUSHs(boolSV(max));
2931 mPUSHi(PL_statcache.st_dev);
2934 * We try to represent st_ino as a native IV or UV where
2935 * possible, but fall back to a decimal string where
2936 * necessary. The code to generate these decimal strings
2937 * is quite obtuse, because (a) we're portable to non-POSIX
2938 * platforms where st_ino might be signed; (b) we didn't
2939 * necessarily detect at Configure time whether st_ino is
2940 * signed; (c) we're portable to non-POSIX platforms where
2941 * ino_t isn't defined, so have no name for the type of
2942 * st_ino; and (d) sprintf() doesn't necessarily support
2943 * integers as large as st_ino.
2947 CLANG_DIAG_IGNORE_STMT(-Wtautological-compare);
2948 GCC_DIAG_IGNORE_STMT(-Wtype-limits);
2949 neg = PL_statcache.st_ino < 0;
2950 GCC_DIAG_RESTORE_STMT;
2951 CLANG_DIAG_RESTORE_STMT;
2953 s.st_ino = (IV)PL_statcache.st_ino;
2954 if (LIKELY(s.st_ino == PL_statcache.st_ino)) {
2957 char buf[sizeof(s.st_ino)*3+1], *p;
2958 s.st_ino = PL_statcache.st_ino;
2959 for (p = buf + sizeof(buf); p != buf+1; ) {
2961 t.st_ino = s.st_ino / 10;
2962 *--p = '0' + (int)(t.st_ino*10 - s.st_ino);
2963 s.st_ino = t.st_ino;
2968 mPUSHp(p, buf+sizeof(buf) - p);
2971 s.st_ino = (UV)PL_statcache.st_ino;
2972 if (LIKELY(s.st_ino == PL_statcache.st_ino)) {
2975 char buf[sizeof(s.st_ino)*3], *p;
2976 s.st_ino = PL_statcache.st_ino;
2977 for (p = buf + sizeof(buf); p != buf; ) {
2979 t.st_ino = s.st_ino / 10;
2980 *--p = '0' + (int)(s.st_ino - t.st_ino*10);
2981 s.st_ino = t.st_ino;
2985 mPUSHp(p, buf+sizeof(buf) - p);
2989 mPUSHu(PL_statcache.st_mode);
2990 mPUSHu(PL_statcache.st_nlink);
2992 sv_setuid(PUSHmortal, PL_statcache.st_uid);
2993 sv_setgid(PUSHmortal, PL_statcache.st_gid);
2995 #ifdef USE_STAT_RDEV
2996 mPUSHi(PL_statcache.st_rdev);
2998 PUSHs(newSVpvs_flags("", SVs_TEMP));
3000 #if Off_t_size > IVSIZE
3001 mPUSHn(PL_statcache.st_size);
3003 mPUSHi(PL_statcache.st_size);
3006 mPUSHn(PL_statcache.st_atime);
3007 mPUSHn(PL_statcache.st_mtime);
3008 mPUSHn(PL_statcache.st_ctime);
3010 mPUSHi(PL_statcache.st_atime);
3011 mPUSHi(PL_statcache.st_mtime);
3012 mPUSHi(PL_statcache.st_ctime);
3014 #ifdef USE_STAT_BLOCKS
3015 mPUSHu(PL_statcache.st_blksize);
3016 mPUSHu(PL_statcache.st_blocks);
3018 PUSHs(newSVpvs_flags("", SVs_TEMP));
3019 PUSHs(newSVpvs_flags("", SVs_TEMP));
3025 /* All filetest ops avoid manipulating the perl stack pointer in their main
3026 bodies (since commit d2c4d2d1e22d3125), and return using either
3027 S_ft_return_false() or S_ft_return_true(). These two helper functions are
3028 the only two which manipulate the perl stack. To ensure that no stack
3029 manipulation macros are used, the filetest ops avoid defining a local copy
3030 of the stack pointer with dSP. */
3032 /* If the next filetest is stacked up with this one
3033 (PL_op->op_private & OPpFT_STACKING), we leave
3034 the original argument on the stack for success,
3035 and skip the stacked operators on failure.
3036 The next few macros/functions take care of this.
3040 S_ft_return_false(pTHX_ SV *ret) {
3044 if (PL_op->op_flags & OPf_REF) XPUSHs(ret);
3048 if (PL_op->op_private & OPpFT_STACKING) {
3049 while (next && OP_IS_FILETEST(next->op_type)
3050 && next->op_private & OPpFT_STACKED)
3051 next = next->op_next;
3056 PERL_STATIC_INLINE OP *
3057 S_ft_return_true(pTHX_ SV *ret) {
3059 if (PL_op->op_flags & OPf_REF)
3060 XPUSHs(PL_op->op_private & OPpFT_STACKING ? (SV *)cGVOP_gv : (ret));
3061 else if (!(PL_op->op_private & OPpFT_STACKING))
3067 #define FT_RETURNNO return S_ft_return_false(aTHX_ &PL_sv_no)
3068 #define FT_RETURNUNDEF return S_ft_return_false(aTHX_ &PL_sv_undef)
3069 #define FT_RETURNYES return S_ft_return_true(aTHX_ &PL_sv_yes)
3071 #define tryAMAGICftest_MG(chr) STMT_START { \
3072 if ( (SvFLAGS(*PL_stack_sp) & (SVf_ROK|SVs_GMG)) \
3073 && PL_op->op_flags & OPf_KIDS) { \
3074 OP *next = S_try_amagic_ftest(aTHX_ chr); \
3075 if (next) return next; \
3080 S_try_amagic_ftest(pTHX_ char chr) {
3081 SV *const arg = *PL_stack_sp;
3084 if (!(PL_op->op_private & OPpFT_STACKING)) SvGETMAGIC(arg);
3088 const char tmpchr = chr;
3089 SV * const tmpsv = amagic_call(arg,
3090 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
3091 ftest_amg, AMGf_unary);
3096 return SvTRUE(tmpsv)
3097 ? S_ft_return_true(aTHX_ tmpsv) : S_ft_return_false(aTHX_ tmpsv);
3103 /* also used for: pp_fteexec() pp_fteread() pp_ftewrite() pp_ftrexec()
3109 /* Not const, because things tweak this below. Not bool, because there's
3110 no guarantee that OPpFT_ACCESS is <= CHAR_MAX */
3111 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3112 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
3113 /* Giving some sort of initial value silences compilers. */
3115 int access_mode = R_OK;
3117 int access_mode = 0;
3120 /* access_mode is never used, but leaving use_access in makes the
3121 conditional compiling below much clearer. */
3124 Mode_t stat_mode = S_IRUSR;
3126 bool effective = FALSE;
3129 switch (PL_op->op_type) {
3130 case OP_FTRREAD: opchar = 'R'; break;
3131 case OP_FTRWRITE: opchar = 'W'; break;
3132 case OP_FTREXEC: opchar = 'X'; break;
3133 case OP_FTEREAD: opchar = 'r'; break;
3134 case OP_FTEWRITE: opchar = 'w'; break;
3135 case OP_FTEEXEC: opchar = 'x'; break;
3137 tryAMAGICftest_MG(opchar);
3139 switch (PL_op->op_type) {
3141 #if !(defined(HAS_ACCESS) && defined(R_OK))
3147 #if defined(HAS_ACCESS) && defined(W_OK)
3152 stat_mode = S_IWUSR;
3156 #if defined(HAS_ACCESS) && defined(X_OK)
3161 stat_mode = S_IXUSR;
3165 #ifdef PERL_EFF_ACCESS
3168 stat_mode = S_IWUSR;
3172 #ifndef PERL_EFF_ACCESS
3179 #ifdef PERL_EFF_ACCESS
3184 stat_mode = S_IXUSR;
3190 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3192 const char *name = SvPV(*PL_stack_sp, len);
3193 if (!IS_SAFE_PATHNAME(name, len, OP_NAME(PL_op))) {
3196 else if (effective) {
3197 # ifdef PERL_EFF_ACCESS
3198 result = PERL_EFF_ACCESS(name, access_mode);
3200 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3206 result = access(name, access_mode);
3208 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3219 result = my_stat_flags(0);
3222 if (cando(stat_mode, effective, &PL_statcache))
3228 /* also used for: pp_ftatime() pp_ftctime() pp_ftmtime() pp_ftsize() */
3233 const int op_type = PL_op->op_type;
3237 case OP_FTIS: opchar = 'e'; break;
3238 case OP_FTSIZE: opchar = 's'; break;
3239 case OP_FTMTIME: opchar = 'M'; break;
3240 case OP_FTCTIME: opchar = 'C'; break;
3241 case OP_FTATIME: opchar = 'A'; break;
3243 tryAMAGICftest_MG(opchar);
3245 result = my_stat_flags(0);
3248 if (op_type == OP_FTIS)
3251 /* You can't dTARGET inside OP_FTIS, because you'll get
3252 "panic: pad_sv po" - the op is not flagged to have a target. */
3256 #if Off_t_size > IVSIZE
3257 sv_setnv(TARG, (NV)PL_statcache.st_size);
3259 sv_setiv(TARG, (IV)PL_statcache.st_size);
3264 ((NV)PL_basetime - PL_statcache.st_mtime) / 86400.0 );
3268 ((NV)PL_basetime - PL_statcache.st_atime) / 86400.0 );
3272 ((NV)PL_basetime - PL_statcache.st_ctime) / 86400.0 );
3276 return SvTRUE_nomg_NN(TARG)
3277 ? S_ft_return_true(aTHX_ TARG) : S_ft_return_false(aTHX_ TARG);
3282 /* also used for: pp_ftblk() pp_ftchr() pp_ftdir() pp_fteowned()
3283 * pp_ftfile() pp_ftpipe() pp_ftsgid() pp_ftsock()
3284 * pp_ftsuid() pp_ftsvtx() pp_ftzero() */
3291 switch (PL_op->op_type) {
3292 case OP_FTROWNED: opchar = 'O'; break;
3293 case OP_FTEOWNED: opchar = 'o'; break;
3294 case OP_FTZERO: opchar = 'z'; break;
3295 case OP_FTSOCK: opchar = 'S'; break;
3296 case OP_FTCHR: opchar = 'c'; break;
3297 case OP_FTBLK: opchar = 'b'; break;
3298 case OP_FTFILE: opchar = 'f'; break;
3299 case OP_FTDIR: opchar = 'd'; break;
3300 case OP_FTPIPE: opchar = 'p'; break;
3301 case OP_FTSUID: opchar = 'u'; break;
3302 case OP_FTSGID: opchar = 'g'; break;
3303 case OP_FTSVTX: opchar = 'k'; break;
3305 tryAMAGICftest_MG(opchar);
3307 result = my_stat_flags(0);
3310 switch (PL_op->op_type) {
3312 if (PL_statcache.st_uid == PerlProc_getuid())
3316 if (PL_statcache.st_uid == PerlProc_geteuid())
3320 if (PL_statcache.st_size == 0)
3324 if (S_ISSOCK(PL_statcache.st_mode))
3328 if (S_ISCHR(PL_statcache.st_mode))
3332 if (S_ISBLK(PL_statcache.st_mode))
3336 if (S_ISREG(PL_statcache.st_mode))
3340 if (S_ISDIR(PL_statcache.st_mode))
3344 if (S_ISFIFO(PL_statcache.st_mode))
3349 if (PL_statcache.st_mode & S_ISUID)
3355 if (PL_statcache.st_mode & S_ISGID)
3361 if (PL_statcache.st_mode & S_ISVTX)
3373 tryAMAGICftest_MG('l');
3374 result = my_lstat_flags(0);
3378 if (S_ISLNK(PL_statcache.st_mode))
3391 tryAMAGICftest_MG('t');
3393 if (PL_op->op_flags & OPf_REF)
3396 SV *tmpsv = *PL_stack_sp;
3397 if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3398 name = SvPV_nomg(tmpsv, namelen);
3399 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3403 if (GvIO(gv) && IoIFP(GvIOp(gv)))
3404 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3405 else if (name && isDIGIT(*name) && grok_atoUV(name, &uv, NULL) && uv <= PERL_INT_MAX)
3410 SETERRNO(EBADF,RMS_IFI);
3413 if (PerlLIO_isatty(fd))
3419 /* also used for: pp_ftbinary() */
3432 const U8 * first_variant;
3434 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3436 if (PL_op->op_flags & OPf_REF)
3438 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
3443 gv = MAYBE_DEREF_GV_nomg(sv);
3447 if (gv == PL_defgv) {
3449 io = SvTYPE(PL_statgv) == SVt_PVIO
3453 goto really_filename;
3458 SvPVCLEAR(PL_statname);
3459 io = GvIO(PL_statgv);
3461 PL_laststatval = -1;
3462 PL_laststype = OP_STAT;
3463 if (io && IoIFP(io)) {
3465 if (! PerlIO_has_base(IoIFP(io)))
3466 DIE(aTHX_ "-T and -B not implemented on filehandles");
3467 fd = PerlIO_fileno(IoIFP(io));
3469 SETERRNO(EBADF,RMS_IFI);
3472 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3473 if (PL_laststatval < 0)
3475 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3476 if (PL_op->op_type == OP_FTTEXT)
3481 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3482 i = PerlIO_getc(IoIFP(io));
3484 (void)PerlIO_ungetc(IoIFP(io),i);
3486 /* null file is anything */
3489 len = PerlIO_get_bufsiz(IoIFP(io));
3490 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3491 /* sfio can have large buffers - limit to 512 */
3496 SETERRNO(EBADF,RMS_IFI);
3498 SETERRNO(EBADF,RMS_IFI);
3509 temp = SvPV_nomg_const(sv, temp_len);
3510 sv_setpv(PL_statname, temp);
3511 if (!IS_SAFE_PATHNAME(temp, temp_len, OP_NAME(PL_op))) {
3512 PL_laststatval = -1;
3513 PL_laststype = OP_STAT;
3517 file = SvPVX_const(PL_statname);
3519 if (!(fp = PerlIO_open(file, "r"))) {
3521 PL_laststatval = -1;
3522 PL_laststype = OP_STAT;
3524 if (ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
3525 /* PL_warn_nl is constant */
3526 GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral);
3527 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3528 GCC_DIAG_RESTORE_STMT;
3532 PL_laststype = OP_STAT;
3533 fd = PerlIO_fileno(fp);
3535 (void)PerlIO_close(fp);
3536 SETERRNO(EBADF,RMS_IFI);
3539 PL_laststatval = PerlLIO_fstat(fd, &PL_statcache);
3540 if (PL_laststatval < 0) {
3542 (void)PerlIO_close(fp);
3546 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3547 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3548 (void)PerlIO_close(fp);
3550 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3551 FT_RETURNNO; /* special case NFS directories */
3552 FT_RETURNYES; /* null file is anything */
3557 /* now scan s to look for textiness */
3559 #if defined(DOSISH) || defined(USEMYBINMODE)
3560 /* ignore trailing ^Z on short files */
3561 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3566 if (! is_utf8_invariant_string_loc((U8 *) s, len, &first_variant)) {
3568 /* Here contains a variant under UTF-8 . See if the entire string is
3570 if (is_utf8_fixed_width_buf_flags(first_variant,
3571 len - ((char *) first_variant - (char *) s),
3574 if (PL_op->op_type == OP_FTTEXT) {
3583 /* Here, is not UTF-8 or is entirely ASCII. Look through the buffer for
3584 * things that wouldn't be in ASCII text or rich ASCII text. Count these
3586 for (i = 0; i < len; i++, s++) {
3587 if (!*s) { /* null never allowed in text */
3591 #ifdef USE_LOCALE_CTYPE
3592 if (IN_LC_RUNTIME(LC_CTYPE)) {
3593 if ( isPRINT_LC(*s) || isSPACE_LC(*s)) {
3600 /* VT occurs so rarely in text, that we consider it odd */
3601 || (isSPACE_A(*s) && *s != VT_NATIVE)
3603 /* But there is a fair amount of backspaces and escapes in
3606 || *s == ESC_NATIVE)
3613 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3624 const char *tmps = NULL;
3628 SV * const sv = POPs;
3629 if (PL_op->op_flags & OPf_SPECIAL) {
3630 gv = gv_fetchsv(sv, 0, SVt_PVIO);
3632 if (ckWARN(WARN_UNOPENED)) {
3633 Perl_warner(aTHX_ packWARN(WARN_UNOPENED),
3634 "chdir() on unopened filehandle %" SVf, sv);
3636 SETERRNO(EBADF,RMS_IFI);
3638 TAINT_PROPER("chdir");
3642 else if (!(gv = MAYBE_DEREF_GV(sv)))
3643 tmps = SvPV_nomg_const_nolen(sv);
3646 HV * const table = GvHVn(PL_envgv);
3650 if ( (svp = hv_fetchs(table, "HOME", FALSE))
3651 || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3653 || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3657 tmps = SvPV_nolen_const(*svp);
3661 SETERRNO(EINVAL, LIB_INVARG);
3662 TAINT_PROPER("chdir");
3667 TAINT_PROPER("chdir");
3670 IO* const io = GvIO(gv);
3673 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3674 } else if (IoIFP(io)) {
3675 int fd = PerlIO_fileno(IoIFP(io));
3679 PUSHi(fchdir(fd) >= 0);
3689 DIE(aTHX_ PL_no_func, "fchdir");
3693 PUSHi( PerlDir_chdir(tmps) >= 0 );
3695 /* Clear the DEFAULT element of ENV so we'll get the new value
3697 hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3704 SETERRNO(EBADF,RMS_IFI);
3711 /* also used for: pp_chmod() pp_kill() pp_unlink() pp_utime() */
3715 dSP; dMARK; dTARGET;
3716 const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3727 char * const tmps = POPpx;
3728 TAINT_PROPER("chroot");
3729 PUSHi( chroot(tmps) >= 0 );
3732 DIE(aTHX_ PL_no_func, "chroot");
3743 const char * const tmps2 = POPpconstx;
3744 const char * const tmps = SvPV_nolen_const(TOPs);
3745 TAINT_PROPER("rename");
3747 anum = PerlLIO_rename(tmps, tmps2);
3749 if (!(anum = PerlLIO_stat(tmps, &statbuf))) {
3750 if (same_dirent(tmps2, tmps)) /* can always rename to same name */
3753 if (PerlProc_geteuid() || PerlLIO_stat(tmps2, &statbuf) < 0 || !S_ISDIR(statbuf.st_mode))
3754 (void)UNLINK(tmps2);
3755 if (!(anum = link(tmps, tmps2)))
3756 anum = UNLINK(tmps);
3765 /* also used for: pp_symlink() */
3767 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3771 const int op_type = PL_op->op_type;
3775 if (op_type == OP_LINK)
3776 DIE(aTHX_ PL_no_func, "link");
3778 # ifndef HAS_SYMLINK
3779 if (op_type == OP_SYMLINK)
3780 DIE(aTHX_ PL_no_func, "symlink");
3784 const char * const tmps2 = POPpconstx;
3785 const char * const tmps = SvPV_nolen_const(TOPs);
3786 TAINT_PROPER(PL_op_desc[op_type]);
3788 # if defined(HAS_LINK) && defined(HAS_SYMLINK)
3789 /* Both present - need to choose which. */
3790 (op_type == OP_LINK) ?
3791 PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3792 # elif defined(HAS_LINK)
3793 /* Only have link, so calls to pp_symlink will have DIE()d above. */
3794 PerlLIO_link(tmps, tmps2);
3795 # elif defined(HAS_SYMLINK)
3796 /* Only have symlink, so calls to pp_link will have DIE()d above. */
3797 symlink(tmps, tmps2);
3801 SETi( result >= 0 );
3806 /* also used for: pp_symlink() */
3811 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3821 char buf[MAXPATHLEN];
3826 /* NOTE: if the length returned by readlink() is sizeof(buf) - 1,
3827 * it is impossible to know whether the result was truncated. */
3828 len = readlink(tmps, buf, sizeof(buf) - 1);
3836 RETSETUNDEF; /* just pretend it's a normal file */
3840 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3842 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3844 char * const save_filename = filename;
3849 Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3851 PERL_ARGS_ASSERT_DOONELINER;
3853 Newx(cmdline, size, char);
3854 my_strlcpy(cmdline, cmd, size);
3855 my_strlcat(cmdline, " ", size);
3856 for (s = cmdline + strlen(cmdline); *filename; ) {
3860 if (s - cmdline < size)
3861 my_strlcpy(s, " 2>&1", size - (s - cmdline));
3862 myfp = PerlProc_popen(cmdline, "r");
3866 SV * const tmpsv = sv_newmortal();
3867 /* Need to save/restore 'PL_rs' ?? */
3868 s = sv_gets(tmpsv, myfp, 0);
3869 (void)PerlProc_pclose(myfp);
3873 #ifdef HAS_SYS_ERRLIST
3878 /* you don't see this */
3879 const char * const errmsg = Strerror(e) ;
3882 if (instr(s, errmsg)) {
3889 #define EACCES EPERM
3891 if (instr(s, "cannot make"))
3892 SETERRNO(EEXIST,RMS_FEX);
3893 else if (instr(s, "existing file"))
3894 SETERRNO(EEXIST,RMS_FEX);
3895 else if (instr(s, "ile exists"))
3896 SETERRNO(EEXIST,RMS_FEX);
3897 else if (instr(s, "non-exist"))
3898 SETERRNO(ENOENT,RMS_FNF);
3899 else if (instr(s, "does not exist"))
3900 SETERRNO(ENOENT,RMS_FNF);
3901 else if (instr(s, "not empty"))
3902 SETERRNO(EBUSY,SS_DEVOFFLINE);
3903 else if (instr(s, "cannot access"))
3904 SETERRNO(EACCES,RMS_PRV);
3906 SETERRNO(EPERM,RMS_PRV);
3909 else { /* some mkdirs return no failure indication */
3911 anum = (PerlLIO_stat(save_filename, &statbuf) >= 0);
3912 if (PL_op->op_type == OP_RMDIR)
3917 SETERRNO(EACCES,RMS_PRV); /* a guess */
3926 /* This macro removes trailing slashes from a directory name.
3927 * Different operating and file systems take differently to
3928 * trailing slashes. According to POSIX 1003.1 1996 Edition
3929 * any number of trailing slashes should be allowed.
3930 * Thusly we snip them away so that even non-conforming
3931 * systems are happy.
3932 * We should probably do this "filtering" for all
3933 * the functions that expect (potentially) directory names:
3934 * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3935 * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3937 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3938 if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3941 } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3942 (tmps) = savepvn((tmps), (len)); \
3952 const unsigned int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPu : 0777;
3954 TRIMSLASHES(tmps,len,copy);
3956 TAINT_PROPER("mkdir");
3958 SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3962 SETi( dooneliner("mkdir", tmps) );
3963 oldumask = PerlLIO_umask(0);
3964 PerlLIO_umask(oldumask);
3965 PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3980 TRIMSLASHES(tmps,len,copy);
3981 TAINT_PROPER("rmdir");
3983 SETi( PerlDir_rmdir(tmps) >= 0 );
3985 SETi( dooneliner("rmdir", tmps) );
3992 /* Directory calls. */
3996 #if defined(Direntry_t) && defined(HAS_READDIR)
3998 const char * const dirname = POPpconstx;
3999 GV * const gv = MUTABLE_GV(POPs);
4000 IO * const io = GvIOn(gv);
4002 if ((IoIFP(io) || IoOFP(io)))
4003 Perl_croak(aTHX_ "Cannot open %" HEKf " as a dirhandle: it is already open as a filehandle",
4004 HEKfARG(GvENAME_HEK(gv)));
4006 PerlDir_close(IoDIRP(io));
4007 if (!(IoDIRP(io) = PerlDir_open(dirname)))
4013 SETERRNO(EBADF,RMS_DIR);
4016 DIE(aTHX_ PL_no_dir_func, "opendir");
4022 #if !defined(Direntry_t) || !defined(HAS_READDIR)
4023 DIE(aTHX_ PL_no_dir_func, "readdir");
4025 #if !defined(I_DIRENT) && !defined(VMS)
4026 Direntry_t *readdir (DIR *);
4031 const U8 gimme = GIMME_V;
4032 GV * const gv = MUTABLE_GV(POPs);
4033 const Direntry_t *dp;
4034 IO * const io = GvIOn(gv);
4037 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4038 "readdir() attempted on invalid dirhandle %" HEKf,
4039 HEKfARG(GvENAME_HEK(gv)));
4044 dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
4048 sv = newSVpvn(dp->d_name, dp->d_namlen);
4050 sv = newSVpv(dp->d_name, 0);
4052 if (!(IoFLAGS(io) & IOf_UNTAINT))
4055 } while (gimme == G_ARRAY);
4057 if (!dp && gimme != G_ARRAY)
4064 SETERRNO(EBADF,RMS_ISI);
4065 if (gimme == G_ARRAY)
4074 #if defined(HAS_TELLDIR) || defined(telldir)
4076 /* XXX does _anyone_ need this? --AD 2/20/1998 */
4077 /* XXX netbsd still seemed to.
4078 XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
4079 --JHI 1999-Feb-02 */
4080 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
4081 long telldir (DIR *);
4083 GV * const gv = MUTABLE_GV(POPs);
4084 IO * const io = GvIOn(gv);
4087 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4088 "telldir() attempted on invalid dirhandle %" HEKf,
4089 HEKfARG(GvENAME_HEK(gv)));
4093 PUSHi( PerlDir_tell(IoDIRP(io)) );
4097 SETERRNO(EBADF,RMS_ISI);
4100 DIE(aTHX_ PL_no_dir_func, "telldir");
4106 #if defined(HAS_SEEKDIR) || defined(seekdir)
4108 const long along = POPl;
4109 GV * const gv = MUTABLE_GV(POPs);
4110 IO * const io = GvIOn(gv);
4113 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4114 "seekdir() attempted on invalid dirhandle %" HEKf,
4115 HEKfARG(GvENAME_HEK(gv)));
4118 (void)PerlDir_seek(IoDIRP(io), along);
4123 SETERRNO(EBADF,RMS_ISI);
4126 DIE(aTHX_ PL_no_dir_func, "seekdir");
4132 #if defined(HAS_REWINDDIR) || defined(rewinddir)
4134 GV * const gv = MUTABLE_GV(POPs);
4135 IO * const io = GvIOn(gv);
4138 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4139 "rewinddir() attempted on invalid dirhandle %" HEKf,
4140 HEKfARG(GvENAME_HEK(gv)));
4143 (void)PerlDir_rewind(IoDIRP(io));
4147 SETERRNO(EBADF,RMS_ISI);
4150 DIE(aTHX_ PL_no_dir_func, "rewinddir");
4156 #if defined(Direntry_t) && defined(HAS_READDIR)
4158 GV * const gv = MUTABLE_GV(POPs);
4159 IO * const io = GvIOn(gv);
4162 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
4163 "closedir() attempted on invalid dirhandle %" HEKf,
4164 HEKfARG(GvENAME_HEK(gv)));
4167 #ifdef VOID_CLOSEDIR
4168 PerlDir_close(IoDIRP(io));
4170 if (PerlDir_close(IoDIRP(io)) < 0) {
4171 IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
4180 SETERRNO(EBADF,RMS_IFI);
4183 DIE(aTHX_ PL_no_dir_func, "closedir");
4187 /* Process control. */
4194 #ifdef HAS_SIGPROCMASK
4195 sigset_t oldmask, newmask;
4199 PERL_FLUSHALL_FOR_CHILD;
4200 #ifdef HAS_SIGPROCMASK
4201 sigfillset(&newmask);
4202 sigprocmask(SIG_SETMASK, &newmask, &oldmask);
4204 childpid = PerlProc_fork();
4205 if (childpid == 0) {
4209 for (sig = 1; sig < SIG_SIZE; sig++)
4210 PL_psig_pend[sig] = 0;
4212 #ifdef HAS_SIGPROCMASK
4215 sigprocmask(SIG_SETMASK, &oldmask, NULL);
4222 #ifdef PERL_USES_PL_PIDSTATUS
4223 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4228 #elif (defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)) || defined(__amigaos4__)
4233 PERL_FLUSHALL_FOR_CHILD;
4234 childpid = PerlProc_fork();
4240 DIE(aTHX_ PL_no_func, "fork");
4246 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4251 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4252 childpid = wait4pid(-1, &argflags, 0);
4254 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4259 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4260 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4261 STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4263 STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4268 DIE(aTHX_ PL_no_func, "wait");
4274 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4276 const int optype = POPi;
4277 const Pid_t pid = TOPi;
4281 result = amigaos_waitpid(aTHX_ optype, pid, &argflags);
4282 STATUS_NATIVE_CHILD_SET((result >= 0) ? argflags : -1);
4283 result = result == 0 ? pid : -1;
4287 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4288 result = wait4pid(pid, &argflags, optype);
4290 while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4295 # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4296 /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4297 STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4299 STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4301 # endif /* __amigaos4__ */
4305 DIE(aTHX_ PL_no_func, "waitpid");
4311 dSP; dMARK; dORIGMARK; dTARGET;
4312 #if defined(__LIBCATAMOUNT__)
4313 PL_statusvalue = -1;
4318 # ifdef __amigaos4__
4324 while (++MARK <= SP) {
4325 SV *origsv = *MARK, *copysv;
4329 #if defined(WIN32) || defined(__VMS)
4331 * Because of a nasty platform-specific variation on the meaning
4332 * of arguments to this op, we must preserve numeric arguments
4333 * as numeric, not just retain the string value.
4335 if (SvNIOK(origsv) || SvNIOKp(origsv)) {
4336 copysv = newSV_type(SVt_PVNV);
4338 if (SvPOK(origsv) || SvPOKp(origsv)) {
4339 pv = SvPV_nomg(origsv, len);
4340 sv_setpvn(copysv, pv, len);
4343 if (SvIOK(origsv) || SvIOKp(origsv))
4344 SvIV_set(copysv, SvIVX(origsv));
4345 if (SvNOK(origsv) || SvNOKp(origsv))
4346 SvNV_set(copysv, SvNVX(origsv));
4347 SvFLAGS(copysv) |= SvFLAGS(origsv) &
4348 (SVf_IOK|SVf_NOK|SVf_POK|SVp_IOK|SVp_NOK|SVp_POK|
4349 SVf_UTF8|SVf_IVisUV);
4353 pv = SvPV_nomg(origsv, len);
4354 copysv = newSVpvn_flags(pv, len,
4355 (SvFLAGS(origsv) & SVf_UTF8) | SVs_TEMP);
4363 TAINT_PROPER("system");
4365 PERL_FLUSHALL_FOR_CHILD;
4366 #if (defined(HAS_FORK) || defined(__amigaos4__)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4369 struct UserData userdata;
4376 bool child_success = FALSE;
4377 #ifdef HAS_SIGPROCMASK
4378 sigset_t newset, oldset;
4381 if (PerlProc_pipe_cloexec(pp) >= 0)
4384 amigaos_fork_set_userdata(aTHX_
4390 pthread_create(&proc,NULL,amigaos_system_child,(void *)&userdata);
4391 child_success = proc > 0;
4393 #ifdef HAS_SIGPROCMASK
4394 sigemptyset(&newset);
4395 sigaddset(&newset, SIGCHLD);
4396 sigprocmask(SIG_BLOCK, &newset, &oldset);
4398 while ((childpid = PerlProc_fork()) == -1) {
4399 if (errno != EAGAIN) {
4404 PerlLIO_close(pp[0]);
4405 PerlLIO_close(pp[1]);
4407 #ifdef HAS_SIGPROCMASK
4408 sigprocmask(SIG_SETMASK, &oldset, NULL);
4414 child_success = childpid > 0;
4416 if (child_success) {
4417 Sigsave_t ihand,qhand; /* place to save signals during system() */
4420 #ifndef __amigaos4__
4422 PerlLIO_close(pp[1]);
4425 rsignal_save(SIGINT, (Sighandler_t) SIG_IGN, &ihand);
4426 rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4429 result = pthread_join(proc, (void **)&status);
4432 result = wait4pid(childpid, &status, 0);
4433 } while (result == -1 && errno == EINTR);
4436 #ifdef HAS_SIGPROCMASK
4437 sigprocmask(SIG_SETMASK, &oldset, NULL);
4439 (void)rsignal_restore(SIGINT, &ihand);
4440 (void)rsignal_restore(SIGQUIT, &qhand);
4442 STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4448 while (n < sizeof(int)) {
4449 const SSize_t n1 = PerlLIO_read(pp[0],
4450 (void*)(((char*)&errkid)+n),
4456 PerlLIO_close(pp[0]);
4457 if (n) { /* Error */
4458 if (n != sizeof(int))
4459 DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4460 errno = errkid; /* Propagate errno from kid */
4462 /* The pipe always has something in it
4463 * so n alone is not enough. */
4467 STATUS_NATIVE_CHILD_SET(-1);
4471 XPUSHi(STATUS_CURRENT);
4474 #ifndef __amigaos4__
4475 #ifdef HAS_SIGPROCMASK
4476 sigprocmask(SIG_SETMASK, &oldset, NULL);
4479 PerlLIO_close(pp[0]);
4480 if (PL_op->op_flags & OPf_STACKED) {
4481 SV * const really = *++MARK;
4482 value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4484 else if (SP - MARK != 1)
4485 value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4487 value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4489 #endif /* __amigaos4__ */
4492 #else /* ! FORK or VMS or OS/2 */
4495 if (PL_op->op_flags & OPf_STACKED) {
4496 SV * const really = *++MARK;
4497 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4498 value = (I32)do_aspawn(really, MARK, SP);
4500 value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4503 else if (SP - MARK != 1) {
4504 # if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4505 value = (I32)do_aspawn(NULL, MARK, SP);
4507 value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4511 value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4513 if (PL_statusvalue == -1) /* hint that value must be returned as is */
4515 STATUS_NATIVE_CHILD_SET(value);
4517 XPUSHi(result ? value : STATUS_CURRENT);
4518 #endif /* !FORK or VMS or OS/2 */
4525 dSP; dMARK; dORIGMARK; dTARGET;
4530 while (++MARK <= SP) {
4531 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */
4536 TAINT_PROPER("exec");
4539 PERL_FLUSHALL_FOR_CHILD;
4540 if (PL_op->op_flags & OPf_STACKED) {
4541 SV * const really = *++MARK;
4542 value = (I32)do_aexec(really, MARK, SP);
4544 else if (SP - MARK != 1)
4546 value = (I32)vms_do_aexec(NULL, MARK, SP);
4548 value = (I32)do_aexec(NULL, MARK, SP);
4552 value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4554 value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4566 XPUSHi( getppid() );
4569 DIE(aTHX_ PL_no_func, "getppid");
4579 (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4582 pgrp = (I32)BSD_GETPGRP(pid);
4584 if (pid != 0 && pid != PerlProc_getpid())
4585 DIE(aTHX_ "POSIX getpgrp can't take an argument");
4591 DIE(aTHX_ PL_no_func, "getpgrp");
4601 pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4602 if (MAXARG > 0) pid = TOPs ? TOPi : 0;
4609 TAINT_PROPER("setpgrp");
4611 SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4613 if ((pgrp != 0 && pgrp != PerlProc_getpid())
4614 || (pid != 0 && pid != PerlProc_getpid()))
4616 DIE(aTHX_ "setpgrp can't take arguments");
4618 SETi( setpgrp() >= 0 );
4619 #endif /* USE_BSDPGRP */
4622 DIE(aTHX_ PL_no_func, "setpgrp");
4627 * The glibc headers typedef __priority_which_t to an enum under C, but
4628 * under C++, it keeps it as int. -Wc++-compat doesn't know this, so we
4629 * need to explicitly cast it to shut up the warning.
4631 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4632 # define PRIORITY_WHICH_T(which) (__priority_which_t)which
4634 # define PRIORITY_WHICH_T(which) which
4639 #ifdef HAS_GETPRIORITY
4641 const int who = POPi;
4642 const int which = TOPi;
4643 SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4646 DIE(aTHX_ PL_no_func, "getpriority");
4652 #ifdef HAS_SETPRIORITY
4654 const int niceval = POPi;
4655 const int who = POPi;
4656 const int which = TOPi;
4657 TAINT_PROPER("setpriority");
4658 SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4661 DIE(aTHX_ PL_no_func, "setpriority");
4665 #undef PRIORITY_WHICH_T
4673 XPUSHn( (NV)time(NULL) );
4675 XPUSHu( (UV)time(NULL) );
4684 struct tms timesbuf;
4687 (void)PerlProc_times(×buf);
4689 mPUSHn(((NV)timesbuf.tms_utime)/(NV)PL_clocktick);
4690 if (GIMME_V == G_ARRAY) {
4691 mPUSHn(((NV)timesbuf.tms_stime)/(NV)PL_clocktick);
4692 mPUSHn(((NV)timesbuf.tms_cutime)/(NV)PL_clocktick);
4693 mPUSHn(((NV)timesbuf.tms_cstime)/(NV)PL_clocktick);
4696 #elif defined(PERL_MICRO)
4700 if (GIMME_V == G_ARRAY) {
4707 DIE(aTHX_ "times not implemented");
4708 #endif /* HAS_TIMES */
4711 /* The 32 bit int year limits the times we can represent to these
4712 boundaries with a few days wiggle room to account for time zone
4715 /* Sat Jan 3 00:00:00 -2147481748 */
4716 #define TIME_LOWER_BOUND -67768100567755200.0
4717 /* Sun Dec 29 12:00:00 2147483647 */
4718 #define TIME_UPPER_BOUND 67767976233316800.0
4721 /* also used for: pp_localtime() */
4729 const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4730 static const char * const dayname[] =
4731 {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4732 static const char * const monname[] =
4733 {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4734 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4736 if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4739 when = (Time64_T)now;
4742 NV input = Perl_floor(POPn);
4743 const bool pl_isnan = Perl_isnan(input);
4744 when = (Time64_T)input;
4745 if (UNLIKELY(pl_isnan || when != input)) {
4746 /* diag_listed_as: gmtime(%f) too large */
4747 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4748 "%s(%.0" NVff ") too large", opname, input);
4756 if ( TIME_LOWER_BOUND > when ) {
4757 /* diag_listed_as: gmtime(%f) too small */
4758 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4759 "%s(%.0" NVff ") too small", opname, when);
4762 else if( when > TIME_UPPER_BOUND ) {
4763 /* diag_listed_as: gmtime(%f) too small */
4764 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4765 "%s(%.0" NVff ") too large", opname, when);
4769 if (PL_op->op_type == OP_LOCALTIME)
4770 err = Perl_localtime64_r(&when, &tmbuf);
4772 err = Perl_gmtime64_r(&when, &tmbuf);
4776 /* diag_listed_as: gmtime(%f) failed */
4777 /* XXX %lld broken for quads */
4779 Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4780 "%s(%.0" NVff ") failed", opname, when);
4783 if (GIMME_V != G_ARRAY) { /* scalar context */
4790 Perl_sv_setpvf_mg(aTHX_ TARG, "%s %s %2d %02d:%02d:%02d %" IVdf,
4791 dayname[tmbuf.tm_wday],
4792 monname[tmbuf.tm_mon],
4797 (IV)tmbuf.tm_year + 1900);
4800 else { /* list context */
4806 mPUSHi(tmbuf.tm_sec);
4807 mPUSHi(tmbuf.tm_min);
4808 mPUSHi(tmbuf.tm_hour);
4809 mPUSHi(tmbuf.tm_mday);
4810 mPUSHi(tmbuf.tm_mon);
4811 mPUSHn(tmbuf.tm_year);
4812 mPUSHi(tmbuf.tm_wday);
4813 mPUSHi(tmbuf.tm_yday);
4814 mPUSHi(tmbuf.tm_isdst);
4823 /* alarm() takes an unsigned int number of seconds, and return the
4824 * unsigned int number of seconds remaining in the previous alarm
4825 * (alarms don't stack). Therefore negative return values are not
4829 /* Note that while the C library function alarm() as such has
4830 * no errors defined (or in other words, properly behaving client
4831 * code shouldn't expect any), alarm() being obsoleted by
4832 * setitimer() and often being implemented in terms of
4833 * setitimer(), can fail. */
4834 /* diag_listed_as: %s() with negative argument */
4835 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4836 "alarm() with negative argument");
4837 SETERRNO(EINVAL, LIB_INVARG);
4841 unsigned int retval = alarm(anum);
4842 if ((int)retval < 0) /* Strictly speaking "cannot happen". */
4848 DIE(aTHX_ PL_no_func, "alarm");
4858 (void)time(&lasttime);
4859 if (MAXARG < 1 || (!TOPs && !POPs))
4862 const I32 duration = POPi;
4864 /* diag_listed_as: %s() with negative argument */
4865 Perl_ck_warner_d(aTHX_ packWARN(WARN_MISC),
4866 "sleep() with negative argument");
4867 SETERRNO(EINVAL, LIB_INVARG);
4868 XPUSHs(&PL_sv_zero);
4871 PerlProc_sleep((unsigned int)duration);
4875 XPUSHu((UV)(when - lasttime));
4879 /* Shared memory. */
4880 /* Merged with some message passing. */
4882 /* also used for: pp_msgrcv() pp_msgsnd() pp_semop() pp_shmread() */
4886 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4887 dSP; dMARK; dTARGET;
4888 const int op_type = PL_op->op_type;
4893 value = (I32)(do_msgsnd(MARK, SP) >= 0);
4896 value = (I32)(do_msgrcv(MARK, SP) >= 0);
4899 value = (I32)(do_semop(MARK, SP) >= 0);
4902 value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4910 return Perl_pp_semget(aTHX);
4916 /* also used for: pp_msgget() pp_shmget() */
4920 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4921 dSP; dMARK; dTARGET;
4922 const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4929 DIE(aTHX_ "System V IPC is not implemented on this machine");
4933 /* also used for: pp_msgctl() pp_shmctl() */
4937 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4938 dSP; dMARK; dTARGET;
4939 const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4947 PUSHp(zero_but_true, ZBTLEN);
4951 return Perl_pp_semget(aTHX);
4955 /* I can't const this further without getting warnings about the types of
4956 various arrays passed in from structures. */
4958 S_space_join_names_mortal(pTHX_ char *const *array)
4962 if (array && *array) {
4963 target = newSVpvs_flags("", SVs_TEMP);
4965 sv_catpv(target, *array);
4968 sv_catpvs(target, " ");
4971 target = sv_mortalcopy(&PL_sv_no);
4976 /* Get system info. */
4978 /* also used for: pp_ghbyaddr() pp_ghbyname() */
4982 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4984 I32 which = PL_op->op_type;
4987 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4988 struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4989 struct hostent *gethostbyname(Netdb_name_t);
4990 struct hostent *gethostent(void);
4992 struct hostent *hent = NULL;
4996 if (which == OP_GHBYNAME) {
4997 #ifdef HAS_GETHOSTBYNAME
4998 const char* const name = POPpbytex;
4999 hent = PerlSock_gethostbyname(name);
5001 DIE(aTHX_ PL_no_sock_func, "gethostbyname");
5004 else if (which == OP_GHBYADDR) {
5005 #ifdef HAS_GETHOSTBYADDR
5006 const int addrtype = POPi;
5007 SV * const addrsv = POPs;
5009 const char *addr = (char *)SvPVbyte(addrsv, addrlen);
5011 hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
5013 DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
5017 #ifdef HAS_GETHOSTENT
5018 hent = PerlSock_gethostent();
5020 DIE(aTHX_ PL_no_sock_func, "gethostent");
5023 #ifdef HOST_NOT_FOUND
5025 #ifdef USE_REENTRANT_API
5026 # ifdef USE_GETHOSTENT_ERRNO
5027 h_errno = PL_reentrant_buffer->_gethostent_errno;
5030 STATUS_UNIX_SET(h_errno);
5034 if (GIMME_V != G_ARRAY) {
5035 PUSHs(sv = sv_newmortal());
5037 if (which == OP_GHBYNAME) {
5039 sv_setpvn(sv, hent->h_addr, hent->h_length);
5042 sv_setpv(sv, (char*)hent->h_name);
5048 mPUSHs(newSVpv((char*)hent->h_name, 0));
5049 PUSHs(space_join_names_mortal(hent->h_aliases));
5050 mPUSHi(hent->h_addrtype);
5051 len = hent->h_length;
5054 for (elem = hent->h_addr_list; elem && *elem; elem++) {
5055 mXPUSHp(*elem, len);
5059 mPUSHp(hent->h_addr, len);
5061 PUSHs(sv_mortalcopy(&PL_sv_no));
5066 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5070 /* also used for: pp_gnbyaddr() pp_gnbyname() */
5074 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
5076 I32 which = PL_op->op_type;
5078 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
5079 struct netent *getnetbyaddr(Netdb_net_t, int);
5080 struct netent *getnetbyname(Netdb_name_t);
5081 struct netent *getnetent(void);
5083 struct netent *nent;
5085 if (which == OP_GNBYNAME){
5086 #ifdef HAS_GETNETBYNAME
5087 const char * const name = POPpbytex;
5088 nent = PerlSock_getnetbyname(name);
5090 DIE(aTHX_ PL_no_sock_func, "getnetbyname");
5093 else if (which == OP_GNBYADDR) {
5094 #ifdef HAS_GETNETBYADDR
5095 const int addrtype = POPi;
5096 const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
5097 nent = PerlSock_getnetbyaddr(addr, addrtype);
5099 DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
5103 #ifdef HAS_GETNETENT
5104 nent = PerlSock_getnetent();
5106 DIE(aTHX_ PL_no_sock_func, "getnetent");
5109 #ifdef HOST_NOT_FOUND
5111 #ifdef USE_REENTRANT_API
5112 # ifdef USE_GETNETENT_ERRNO
5113 h_errno = PL_reentrant_buffer->_getnetent_errno;
5116 STATUS_UNIX_SET(h_errno);
5121 if (GIMME_V != G_ARRAY) {
5122 PUSHs(sv = sv_newmortal());
5124 if (which == OP_GNBYNAME)
5125 sv_setiv(sv, (IV)nent->n_net);
5127 sv_setpv(sv, nent->n_name);
5133 mPUSHs(newSVpv(nent->n_name, 0));
5134 PUSHs(space_join_names_mortal(nent->n_aliases));
5135 mPUSHi(nent->n_addrtype);
5136 mPUSHi(nent->n_net);
5141 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5146 /* also used for: pp_gpbyname() pp_gpbynumber() */
5150 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
5152 I32 which = PL_op->op_type;
5154 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
5155 struct protoent *getprotobyname(Netdb_name_t);
5156 struct protoent *getprotobynumber(int);
5157 struct protoent *getprotoent(void);
5159 struct protoent *pent;
5161 if (which == OP_GPBYNAME) {
5162 #ifdef HAS_GETPROTOBYNAME
5163 const char* const name = POPpbytex;
5164 pent = PerlSock_getprotobyname(name);
5166 DIE(aTHX_ PL_no_sock_func, "getprotobyname");
5169 else if (which == OP_GPBYNUMBER) {
5170 #ifdef HAS_GETPROTOBYNUMBER
5171 const int number = POPi;
5172 pent = PerlSock_getprotobynumber(number);
5174 DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
5178 #ifdef HAS_GETPROTOENT
5179 pent = PerlSock_getprotoent();
5181 DIE(aTHX_ PL_no_sock_func, "getprotoent");
5185 if (GIMME_V != G_ARRAY) {
5186 PUSHs(sv = sv_newmortal());
5188 if (which == OP_GPBYNAME)
5189 sv_setiv(sv, (IV)pent->p_proto);
5191 sv_setpv(sv, pent->p_name);
5197 mPUSHs(newSVpv(pent->p_name, 0));
5198 PUSHs(space_join_names_mortal(pent->p_aliases));
5199 mPUSHi(pent->p_proto);
5204 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5209 /* also used for: pp_gsbyname() pp_gsbyport() */
5213 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
5215 I32 which = PL_op->op_type;
5217 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
5218 struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
5219 struct servent *getservbyport(int, Netdb_name_t);
5220 struct servent *getservent(void);
5222 struct servent *sent;
5224 if (which == OP_GSBYNAME) {
5225 #ifdef HAS_GETSERVBYNAME
5226 const char * const proto = POPpbytex;
5227 const char * const name = POPpbytex;
5228 sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
5230 DIE(aTHX_ PL_no_sock_func, "getservbyname");
5233 else if (which == OP_GSBYPORT) {
5234 #ifdef HAS_GETSERVBYPORT
5235 const char * const proto = POPpbytex;
5236 unsigned short port = (unsigned short)POPu;
5237 port = PerlSock_htons(port);
5238 sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
5240 DIE(aTHX_ PL_no_sock_func, "getservbyport");
5244 #ifdef HAS_GETSERVENT
5245 sent = PerlSock_getservent();
5247 DIE(aTHX_ PL_no_sock_func, "getservent");
5251 if (GIMME_V != G_ARRAY) {
5252 PUSHs(sv = sv_newmortal());
5254 if (which == OP_GSBYNAME) {
5255 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
5258 sv_setpv(sv, sent->s_name);
5264 mPUSHs(newSVpv(sent->s_name, 0));
5265 PUSHs(space_join_names_mortal(sent->s_aliases));
5266 mPUSHi(PerlSock_ntohs(sent->s_port));
5267 mPUSHs(newSVpv(sent->s_proto, 0));
5272 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5277 /* also used for: pp_snetent() pp_sprotoent() pp_sservent() */
5282 const int stayopen = TOPi;
5283 switch(PL_op->op_type) {
5285 #ifdef HAS_SETHOSTENT
5286 PerlSock_sethostent(stayopen);
5288 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5292 #ifdef HAS_SETNETENT
5293 PerlSock_setnetent(stayopen);
5295 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5299 #ifdef HAS_SETPROTOENT
5300 PerlSock_setprotoent(stayopen);
5302 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5306 #ifdef HAS_SETSERVENT
5307 PerlSock_setservent(stayopen);
5309 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5317 /* also used for: pp_egrent() pp_enetent() pp_eprotoent() pp_epwent()
5318 * pp_eservent() pp_sgrent() pp_spwent() */
5323 switch(PL_op->op_type) {
5325 #ifdef HAS_ENDHOSTENT
5326 PerlSock_endhostent();
5328 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5332 #ifdef HAS_ENDNETENT
5333 PerlSock_endnetent();
5335 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5339 #ifdef HAS_ENDPROTOENT
5340 PerlSock_endprotoent();
5342 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5346 #ifdef HAS_ENDSERVENT
5347 PerlSock_endservent();
5349 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5353 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5356 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5360 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5363 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5367 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5370 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5374 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5377 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5386 /* also used for: pp_gpwnam() pp_gpwuid() */
5392 I32 which = PL_op->op_type;
5394 struct passwd *pwent = NULL;
5396 * We currently support only the SysV getsp* shadow password interface.
5397 * The interface is declared in <shadow.h> and often one needs to link
5398 * with -lsecurity or some such.
5399 * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5402 * AIX getpwnam() is clever enough to return the encrypted password
5403 * only if the caller (euid?) is root.
5405 * There are at least three other shadow password APIs. Many platforms
5406 * seem to contain more than one interface for accessing the shadow
5407 * password databases, possibly for compatibility reasons.
5408 * The getsp*() is by far he simplest one, the other two interfaces
5409 * are much more complicated, but also very similar to each other.
5414 * struct pr_passwd *getprpw*();
5415 * The password is in
5416 * char getprpw*(...).ufld.fd_encrypt[]
5417 * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5422 * struct es_passwd *getespw*();
5423 * The password is in
5424 * char *(getespw*(...).ufld.fd_encrypt)
5425 * Mention HAS_GETESPWNAM here so that Configure probes for it.
5428 * struct userpw *getuserpw();
5429 * The password is in
5430 * char *(getuserpw(...)).spw_upw_passwd
5431 * (but the de facto standard getpwnam() should work okay)
5433 * Mention I_PROT here so that Configure probes for it.
5435 * In HP-UX for getprpw*() the manual page claims that one should include
5436 * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5437 * if one includes <shadow.h> as that includes <hpsecurity.h>,
5438 * and pp_sys.c already includes <shadow.h> if there is such.
5440 * Note that <sys/security.h> is already probed for, but currently
5441 * it is only included in special cases.
5443 * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5444 * the preferred interface, even though also the getprpw*() interface
5445 * is available) one needs to link with -lsecurity -ldb -laud -lm.
5446 * One also needs to call set_auth_parameters() in main() before
5447 * doing anything else, whether one is using getespw*() or getprpw*().
5449 * Note that accessing the shadow databases can be magnitudes
5450 * slower than accessing the standard databases.
5455 # if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5456 /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5457 * the pw_comment is left uninitialized. */
5458 PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5464 const char* const name = POPpbytex;
5465 pwent = getpwnam(name);
5471 pwent = getpwuid(uid);
5475 # ifdef HAS_GETPWENT
5477 #ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */
5478 if (pwent) pwent = getpwnam(pwent->pw_name);
5481 DIE(aTHX_ PL_no_func, "getpwent");
5487 if (GIMME_V != G_ARRAY) {
5488 PUSHs(sv = sv_newmortal());
5490 if (which == OP_GPWNAM)
5491 sv_setuid(sv, pwent->pw_uid);
5493 sv_setpv(sv, pwent->pw_name);
5499 mPUSHs(newSVpv(pwent->pw_name, 0));
5503 /* If we have getspnam(), we try to dig up the shadow
5504 * password. If we are underprivileged, the shadow
5505 * interface will set the errno to EACCES or similar,
5506 * and return a null pointer. If this happens, we will
5507 * use the dummy password (usually "*" or "x") from the
5508 * standard password database.
5510 * In theory we could skip the shadow call completely
5511 * if euid != 0 but in practice we cannot know which
5512 * security measures are guarding the shadow databases
5513 * on a random platform.
5515 * Resist the urge to use additional shadow interfaces.
5516 * Divert the urge to writing an extension instead.
5519 /* Some AIX setups falsely(?) detect some getspnam(), which
5520 * has a different API than the Solaris/IRIX one. */
5521 # if defined(HAS_GETSPNAM) && !defined(_AIX)
5524 const struct spwd * const spwent = getspnam(pwent->pw_name);
5525 /* Save and restore errno so that
5526 * underprivileged attempts seem
5527 * to have never made the unsuccessful
5528 * attempt to retrieve the shadow password. */
5530 if (spwent && spwent->sp_pwdp)
5531 sv_setpv(sv, spwent->sp_pwdp);
5535 if (!SvPOK(sv)) /* Use the standard password, then. */
5536 sv_setpv(sv, pwent->pw_passwd);
5539 /* passwd is tainted because user himself can diddle with it.
5540 * admittedly not much and in a very limited way, but nevertheless. */
5543 sv_setuid(PUSHmortal, pwent->pw_uid);
5544 sv_setgid(PUSHmortal, pwent->pw_gid);
5546 /* pw_change, pw_quota, and pw_age are mutually exclusive--
5547 * because of the poor interface of the Perl getpw*(),
5548 * not because there's some standard/convention saying so.
5549 * A better interface would have been to return a hash,
5550 * but we are accursed by our history, alas. --jhi. */
5552 mPUSHi(pwent->pw_change);
5553 # elif defined(PWQUOTA)
5554 mPUSHi(pwent->pw_quota);
5555 # elif defined(PWAGE)
5556 mPUSHs(newSVpv(pwent->pw_age, 0));
5558 /* I think that you can never get this compiled, but just in case. */
5559 PUSHs(sv_mortalcopy(&PL_sv_no));
5562 /* pw_class and pw_comment are mutually exclusive--.
5563 * see the above note for pw_change, pw_quota, and pw_age. */
5565 mPUSHs(newSVpv(pwent->pw_class, 0));
5566 # elif defined(PWCOMMENT)
5567 mPUSHs(newSVpv(pwent->pw_comment, 0));
5569 /* I think that you can never get this compiled, but just in case. */
5570 PUSHs(sv_mortalcopy(&PL_sv_no));
5574 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5576 PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5578 /* pw_gecos is tainted because user himself can diddle with it. */
5581 mPUSHs(newSVpv(pwent->pw_dir, 0));
5583 PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5584 /* pw_shell is tainted because user himself can diddle with it. */
5588 mPUSHi(pwent->pw_expire);
5593 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5598 /* also used for: pp_ggrgid() pp_ggrnam() */
5604 const I32 which = PL_op->op_type;
5605 const struct group *grent;
5607 if (which == OP_GGRNAM) {
5608 const char* const name = POPpbytex;
5609 grent = (const struct group *)getgrnam(name);
5611 else if (which == OP_GGRGID) {
5613 const Gid_t gid = POPu;
5614 #elif Gid_t_sign == -1
5615 const Gid_t gid = POPi;
5617 # error "Unexpected Gid_t_sign"
5619 grent = (const struct group *)getgrgid(gid);
5623 grent = (struct group *)getgrent();
5625 DIE(aTHX_ PL_no_func, "getgrent");
5629 if (GIMME_V != G_ARRAY) {
5630 SV * const sv = sv_newmortal();
5634 if (which == OP_GGRNAM)
5635 sv_setgid(sv, grent->gr_gid);
5637 sv_setpv(sv, grent->gr_name);
5643 mPUSHs(newSVpv(grent->gr_name, 0));
5646 mPUSHs(newSVpv(grent->gr_passwd, 0));
5648 PUSHs(sv_mortalcopy(&PL_sv_no));
5651 sv_setgid(PUSHmortal, grent->gr_gid);
5653 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5654 /* In UNICOS/mk (_CRAYMPP) the multithreading
5655 * versions (getgrnam_r, getgrgid_r)
5656 * seem to return an illegal pointer
5657 * as the group members list, gr_mem.
5658 * getgrent() doesn't even have a _r version
5659 * but the gr_mem is poisonous anyway.
5660 * So yes, you cannot get the list of group
5661 * members if building multithreaded in UNICOS/mk. */
5662 PUSHs(space_join_names_mortal(grent->gr_mem));
5668 DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5678 if (!(tmps = PerlProc_getlogin()))
5680 sv_setpv_mg(TARG, tmps);
5684 DIE(aTHX_ PL_no_func, "getlogin");
5688 /* Miscellaneous. */
5693 dSP; dMARK; dORIGMARK; dTARGET;
5694 I32 items = SP - MARK;
5695 unsigned long a[20];
5700 while (++MARK <= SP) {
5701 if (SvTAINTED(*MARK)) {
5707 TAINT_PROPER("syscall");
5710 /* This probably won't work on machines where sizeof(long) != sizeof(int)
5711 * or where sizeof(long) != sizeof(char*). But such machines will
5712 * not likely have syscall implemented either, so who cares?
5714 while (++MARK <= SP) {
5715 if (SvNIOK(*MARK) || !i)
5716 a[i++] = SvIV(*MARK);
5717 else if (*MARK == &PL_sv_undef)
5720 a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5726 DIE(aTHX_ "Too many args to syscall");
5728 DIE(aTHX_ "Too few args to syscall");
5730 retval = syscall(a[0]);
5733 retval = syscall(a[0],a[1]);
5736 retval = syscall(a[0],a[1],a[2]);
5739 retval = syscall(a[0],a[1],a[2],a[3]);
5742 retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5745 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5748 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5751 retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5758 DIE(aTHX_ PL_no_func, "syscall");
5762 #ifdef FCNTL_EMULATE_FLOCK
5764 /* XXX Emulate flock() with fcntl().
5765 What's really needed is a good file locking module.
5769 fcntl_emulate_flock(int fd, int operation)
5774 switch (operation & ~LOCK_NB) {
5776 flock.l_type = F_RDLCK;
5779 flock.l_type = F_WRLCK;
5782 flock.l_type = F_UNLCK;
5788 flock.l_whence = SEEK_SET;
5789 flock.l_start = flock.l_len = (Off_t)0;
5791 res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5792 if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5793 errno = EWOULDBLOCK;
5797 #endif /* FCNTL_EMULATE_FLOCK */
5799 #ifdef LOCKF_EMULATE_FLOCK
5801 /* XXX Emulate flock() with lockf(). This is just to increase
5802 portability of scripts. The calls are not completely
5803 interchangeable. What's really needed is a good file
5807 /* The lockf() constants might have been defined in <unistd.h>.
5808 Unfortunately, <unistd.h> causes troubles on some mixed
5809 (BSD/POSIX) systems, such as SunOS 4.1.3.
5811 Further, the lockf() constants aren't POSIX, so they might not be
5812 visible if we're compiling with _POSIX_SOURCE defined. Thus, we'll
5813 just stick in the SVID values and be done with it. Sigh.
5817 # define F_ULOCK 0 /* Unlock a previously locked region */
5820 # define F_LOCK 1 /* Lock a region for exclusive use */
5823 # define F_TLOCK 2 /* Test and lock a region for exclusive use */
5826 # define F_TEST 3 /* Test a region for other processes locks */
5830 lockf_emulate_flock(int fd, int operation)
5836 /* flock locks entire file so for lockf we need to do the same */
5837 pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR); /* get pos to restore later */
5838 if (pos > 0) /* is seekable and needs to be repositioned */
5839 if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5840 pos = -1; /* seek failed, so don't seek back afterwards */
5843 switch (operation) {
5845 /* LOCK_SH - get a shared lock */
5847 /* LOCK_EX - get an exclusive lock */
5849 i = lockf (fd, F_LOCK, 0);
5852 /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5853 case LOCK_SH|LOCK_NB:
5854 /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5855 case LOCK_EX|LOCK_NB:
5856 i = lockf (fd, F_TLOCK, 0);
5858 if ((errno == EAGAIN) || (errno == EACCES))
5859 errno = EWOULDBLOCK;
5862 /* LOCK_UN - unlock (non-blocking is a no-op) */
5864 case LOCK_UN|LOCK_NB:
5865 i = lockf (fd, F_ULOCK, 0);
5868 /* Default - can't decipher operation */
5875 if (pos > 0) /* need to restore position of the handle */
5876 PerlLIO_lseek(fd, pos, SEEK_SET); /* ignore error here */
5881 #endif /* LOCKF_EMULATE_FLOCK */
5884 * ex: set ts=8 sts=4 sw=4 et: