/* pp_sys.c * * Copyright (C) 1995, 1996, 1997, 1998, 1999, * 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ /* * But only a short way ahead its floor and the walls on either side were * cloven by a great fissure, out of which the red glare came, now leaping * up, now dying down into darkness; and all the while far below there was * a rumour and a trouble as of great engines throbbing and labouring. */ /* This file contains system pp ("push/pop") functions that * execute the opcodes that make up a perl program. A typical pp function * expects to find its arguments on the stack, and usually pushes its * results onto the stack, hence the 'pp' terminology. Each OP structure * contains a pointer to the relevant pp_foo() function. * * By 'system', we mean ops which interact with the OS, such as pp_open(). */ #include "EXTERN.h" #define PERL_IN_PP_SYS_C #include "perl.h" #ifdef I_SHADOW /* Shadow password support for solaris - pdo@cs.umd.edu * Not just Solaris: at least HP-UX, IRIX, Linux. * The API is from SysV. * * There are at least two more shadow interfaces, * see the comments in pp_gpwent(). * * --jhi */ # ifdef __hpux__ /* There is a MAXINT coming from <- <- * and another MAXINT from "perl.h" <- . */ # undef MAXINT # endif # include #endif #ifdef I_SYS_WAIT # include #endif #ifdef I_SYS_RESOURCE # include #endif #ifdef NETWARE NETDB_DEFINE_CONTEXT #endif #ifdef HAS_SELECT # ifdef I_SYS_SELECT # include # endif #endif /* XXX Configure test needed. h_errno might not be a simple 'int', especially for multi-threaded applications, see "extern int errno in perl.h". Creating such a test requires taking into account the differences between compiling multithreaded and singlethreaded ($ccflags et al). HOST_NOT_FOUND is typically defined in . */ #if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__) extern int h_errno; #endif #ifdef HAS_PASSWD # ifdef I_PWD # include # else # if !defined(VMS) struct passwd *getpwnam (char *); struct passwd *getpwuid (Uid_t); # endif # endif # ifdef HAS_GETPWENT #ifndef getpwent struct passwd *getpwent (void); #elif defined (VMS) && defined (my_getpwent) struct passwd *Perl_my_getpwent (void); #endif # endif #endif #ifdef HAS_GROUP # ifdef I_GRP # include # else struct group *getgrnam (char *); struct group *getgrgid (Gid_t); # endif # ifdef HAS_GETGRENT #ifndef getgrent struct group *getgrent (void); #endif # endif #endif #ifdef I_UTIME # if defined(_MSC_VER) || defined(__MINGW32__) # include # else # include # endif #endif #ifdef HAS_CHSIZE # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */ # undef my_chsize # endif # define my_chsize PerlLIO_chsize #else # ifdef HAS_TRUNCATE # define my_chsize PerlLIO_chsize # else I32 my_chsize(int fd, Off_t length); # endif #endif #ifdef HAS_FLOCK # define FLOCK flock #else /* no flock() */ /* fcntl.h might not have been included, even if it exists, because the current Configure only sets I_FCNTL if it's needed to pick up the *_OK constants. Make sure it has been included before testing the fcntl() locking constants. */ # if defined(HAS_FCNTL) && !defined(I_FCNTL) # include # endif # if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK) # define FLOCK fcntl_emulate_flock # define FCNTL_EMULATE_FLOCK # else /* no flock() or fcntl(F_SETLK,...) */ # ifdef HAS_LOCKF # define FLOCK lockf_emulate_flock # define LOCKF_EMULATE_FLOCK # endif /* lockf */ # endif /* no flock() or fcntl(F_SETLK,...) */ # ifdef FLOCK static int FLOCK (int, int); /* * These are the flock() constants. Since this sytems doesn't have * flock(), the values of the constants are probably not available. */ # ifndef LOCK_SH # define LOCK_SH 1 # endif # ifndef LOCK_EX # define LOCK_EX 2 # endif # ifndef LOCK_NB # define LOCK_NB 4 # endif # ifndef LOCK_UN # define LOCK_UN 8 # endif # endif /* emulating flock() */ #endif /* no flock() */ #define ZBTLEN 10 static const char zero_but_true[ZBTLEN + 1] = "0 but true"; #if defined(I_SYS_ACCESS) && !defined(R_OK) # include #endif #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC) # define FD_CLOEXEC 1 /* NeXT needs this */ #endif #include "reentr.h" #ifdef __Lynx__ /* Missing protos on LynxOS */ void sethostent(int); void endhostent(void); void setnetent(int); void endnetent(void); void setprotoent(int); void endprotoent(void); void setservent(int); void endservent(void); #endif #undef PERL_EFF_ACCESS_R_OK /* EFFective uid/gid ACCESS R_OK */ #undef PERL_EFF_ACCESS_W_OK #undef PERL_EFF_ACCESS_X_OK /* AIX 5.2 and below use mktime for localtime, and defines the edge case * for time 0x7fffffff to be valid only in UTC. AIX 5.3 provides localtime64 * available in the 32bit environment, which could warrant Configure * checks in the future. */ #ifdef _AIX #define LOCALTIME_EDGECASE_BROKEN #endif /* F_OK unused: if stat() cannot find it... */ #if !defined(PERL_EFF_ACCESS_R_OK) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK) /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */ # define PERL_EFF_ACCESS_R_OK(p) (access((p), R_OK | EFF_ONLY_OK)) # define PERL_EFF_ACCESS_W_OK(p) (access((p), W_OK | EFF_ONLY_OK)) # define PERL_EFF_ACCESS_X_OK(p) (access((p), X_OK | EFF_ONLY_OK)) #endif #if !defined(PERL_EFF_ACCESS_R_OK) && defined(HAS_EACCESS) # ifdef I_SYS_SECURITY # include # endif # ifdef ACC_SELF /* HP SecureWare */ # define PERL_EFF_ACCESS_R_OK(p) (eaccess((p), R_OK, ACC_SELF)) # define PERL_EFF_ACCESS_W_OK(p) (eaccess((p), W_OK, ACC_SELF)) # define PERL_EFF_ACCESS_X_OK(p) (eaccess((p), X_OK, ACC_SELF)) # else /* SCO */ # define PERL_EFF_ACCESS_R_OK(p) (eaccess((p), R_OK)) # define PERL_EFF_ACCESS_W_OK(p) (eaccess((p), W_OK)) # define PERL_EFF_ACCESS_X_OK(p) (eaccess((p), X_OK)) # endif #endif #if !defined(PERL_EFF_ACCESS_R_OK) && defined(HAS_ACCESSX) && defined(ACC_SELF) /* AIX */ # define PERL_EFF_ACCESS_R_OK(p) (accessx((p), R_OK, ACC_SELF)) # define PERL_EFF_ACCESS_W_OK(p) (accessx((p), W_OK, ACC_SELF)) # define PERL_EFF_ACCESS_X_OK(p) (accessx((p), X_OK, ACC_SELF)) #endif #if !defined(PERL_EFF_ACCESS_R_OK) && defined(HAS_ACCESS) \ && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \ || defined(HAS_SETREGID) || defined(HAS_SETRESGID)) /* The Hard Way. */ STATIC int S_emulate_eaccess(pTHX_ const char* path, Mode_t mode) ###### { ###### Uid_t ruid = getuid(); ###### Uid_t euid = geteuid(); ###### Gid_t rgid = getgid(); ###### Gid_t egid = getegid(); ###### int res; LOCK_CRED_MUTEX; #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID) Perl_croak(aTHX_ "switching effective uid is not implemented"); #else #ifdef HAS_SETREUID ###### if (setreuid(euid, ruid)) #else #ifdef HAS_SETRESUID if (setresuid(euid, ruid, (Uid_t)-1)) #endif #endif ###### Perl_croak(aTHX_ "entering effective uid failed"); #endif #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID) Perl_croak(aTHX_ "switching effective gid is not implemented"); #else #ifdef HAS_SETREGID ###### if (setregid(egid, rgid)) #else #ifdef HAS_SETRESGID if (setresgid(egid, rgid, (Gid_t)-1)) #endif #endif ###### Perl_croak(aTHX_ "entering effective gid failed"); #endif ###### res = access(path, mode); #ifdef HAS_SETREUID ###### if (setreuid(ruid, euid)) #else #ifdef HAS_SETRESUID if (setresuid(ruid, euid, (Uid_t)-1)) #endif #endif ###### Perl_croak(aTHX_ "leaving effective uid failed"); #ifdef HAS_SETREGID ###### if (setregid(rgid, egid)) #else #ifdef HAS_SETRESGID if (setresgid(rgid, egid, (Gid_t)-1)) #endif #endif ###### Perl_croak(aTHX_ "leaving effective gid failed"); UNLOCK_CRED_MUTEX; ###### return res; } # define PERL_EFF_ACCESS_R_OK(p) (emulate_eaccess((p), R_OK)) # define PERL_EFF_ACCESS_W_OK(p) (emulate_eaccess((p), W_OK)) # define PERL_EFF_ACCESS_X_OK(p) (emulate_eaccess((p), X_OK)) #endif #if !defined(PERL_EFF_ACCESS_R_OK) /* With it or without it: anyway you get a warning: either that it is unused, or it is declared static and never defined. */ STATIC int S_emulate_eaccess(pTHX_ const char* path, Mode_t mode) { (void)path; (void)mode; Perl_croak(aTHX_ "switching effective uid is not implemented"); /*NOTREACHED*/ return -1; } #endif PP(pp_backtick) 3155 { 3155 dSP; dTARGET; 3155 PerlIO *fp; 3155 const char * const tmps = POPpconstx; 3155 const I32 gimme = GIMME_V; 3155 const char *mode = "r"; 3155 TAINT_PROPER("``"); 3154 if (PL_op->op_private & OPpOPEN_IN_RAW) ###### mode = "rb"; 3154 else if (PL_op->op_private & OPpOPEN_IN_CRLF) ###### mode = "rt"; 3154 fp = PerlProc_popen((char*)tmps, (char *)mode); 3146 if (fp) { 3145 const char *type = NULL; 3145 if (PL_curcop->cop_io) { ###### type = SvPV_nolen_const(PL_curcop->cop_io); } 3145 if (type && *type) ###### PerlIO_apply_layers(aTHX_ fp,mode,type); 3145 if (gimme == G_VOID) { 17 char tmpbuf[256]; 17 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0) ; } 3136 else if (gimme == G_SCALAR) { 1926 ENTER; 1926 SAVESPTR(PL_rs); 1926 PL_rs = &PL_sv_undef; 1926 sv_setpvn(TARG, "", 0); /* note that this preserves previous buffer */ 3676 while (sv_gets(TARG, fp, SvCUR(TARG)) != Nullch) ; 1925 LEAVE; 1925 XPUSHs(TARG); 1925 SvTAINTED_on(TARG); } else { 8862 for (;;) { 8862 SV * const sv = NEWSV(56, 79); 8862 if (sv_gets(sv, fp, 0) == Nullch) { 1210 SvREFCNT_dec(sv); ###### break; } 7652 XPUSHs(sv_2mortal(sv)); 7652 if (SvLEN(sv) - SvCUR(sv) > 20) { 6431 SvPV_shrink_to_cur(sv); } 7652 SvTAINTED_on(sv); } } 3144 STATUS_NATIVE_SET(PerlProc_pclose(fp)); 3144 TAINT; /* "I believe that this is not gratuitous!" */ } else { 1 STATUS_NATIVE_SET(-1); 1 if (gimme == G_SCALAR) ###### RETPUSHUNDEF; } 3145 RETURN; } PP(pp_glob) 3 { dVAR; 3 OP *result; 3 tryAMAGICunTARGET(iter, -1); /* Note that we only ever get here if File::Glob fails to load * without at the same time croaking, for some reason, or if * perl was built with PERL_EXTERNAL_GLOB */ 3 ENTER; #ifndef VMS 3 if (PL_tainting) { /* * The external globbing program may use things we can't control, * so for security reasons we must assume the worst. */ ###### TAINT; ###### taint_proper(PL_no_security, "glob"); } #endif /* !VMS */ 3 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */ 3 PL_last_in_gv = (GV*)*PL_stack_sp--; 3 SAVESPTR(PL_rs); /* This is not permanent, either. */ 3 PL_rs = sv_2mortal(newSVpvn("\000", 1)); #ifndef DOSISH #ifndef CSH *SvPVX(PL_rs) = '\n'; #endif /* !CSH */ #endif /* !DOSISH */ 3 result = do_readline(); 3 LEAVE; 3 return result; } PP(pp_rcatline) 165 { 165 PL_last_in_gv = cGVOP_gv; 165 return do_readline(); } PP(pp_warn) 300 { 300 dSP; dMARK; 300 SV *tmpsv; 300 const char *tmps; 300 STRLEN len; 300 if (SP - MARK != 1) { 21 dTARGET; 21 do_join(TARG, &PL_sv_no, MARK, SP); 21 tmpsv = TARG; 21 SP = MARK + 1; } else { 279 tmpsv = TOPs; } 300 tmps = SvPV_const(tmpsv, len); 300 if ((!tmps || !len) && PL_errgv) { 9 SV * const error = ERRSV; 9 SvUPGRADE(error, SVt_PV); 9 if (SvPOK(error) && SvCUR(error)) ###### sv_catpv(error, "\t...caught"); 9 tmpsv = error; 9 tmps = SvPV_const(tmpsv, len); } 300 if (!tmps || !len) 9 tmpsv = sv_2mortal(newSVpvn("Warning: something's wrong", 26)); 300 Perl_warn(aTHX_ "%"SVf, tmpsv); 295 RETSETYES; } PP(pp_die) 1065 { 1065 dSP; dMARK; 1065 const char *tmps; 1065 SV *tmpsv; 1065 STRLEN len; 1065 bool multiarg = 0; #ifdef VMS VMSISH_HUSHED = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH); #endif 1065 if (SP - MARK != 1) { 57 dTARGET; 57 do_join(TARG, &PL_sv_no, MARK, SP); 57 tmpsv = TARG; 57 tmps = SvPV_const(tmpsv, len); 57 multiarg = 1; 57 SP = MARK + 1; } else { 1008 tmpsv = TOPs; 1008 tmps = SvROK(tmpsv) ? Nullch : SvPV_const(tmpsv, len); } 1065 if (!tmps || !len) { 86 SV *error = ERRSV; 86 SvUPGRADE(error, SVt_PV); 86 if (multiarg ? SvROK(error) : SvROK(tmpsv)) { 6 if (!multiarg) 4 SvSetSV(error,tmpsv); 2 else if (sv_isobject(error)) { 1 HV *stash = SvSTASH(SvRV(error)); 1 GV *gv = gv_fetchmethod(stash, "PROPAGATE"); 1 if (gv) { 1 SV *file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0)); 1 SV *line = sv_2mortal(newSVuv(CopLINE(PL_curcop))); 1 EXTEND(SP, 3); 1 PUSHMARK(SP); 1 PUSHs(error); 1 PUSHs(file); 1 PUSHs(line); 1 PUTBACK; 1 call_sv((SV*)GvCV(gv), G_SCALAR|G_EVAL|G_KEEPERR); 1 sv_setsv(error,*PL_stack_sp--); } } 6 DIE_NULL; } else { 80 if (SvPOK(error) && SvCUR(error)) ###### sv_catpv(error, "\t...propagated"); 80 tmpsv = error; 80 tmps = SvPV_const(tmpsv, len); } } 1059 if (!tmps || !len) 80 tmpsv = sv_2mortal(newSVpvn("Died", 4)); 1059 DIE(aTHX_ "%"SVf, tmpsv); } /* I/O. */ PP(pp_open) 18839 { 18839 dVAR; dSP; 18839 dMARK; dORIGMARK; 18839 dTARGET; 18839 GV *gv; 18839 SV *sv; 18839 IO *io; 18839 const char *tmps; 18839 STRLEN len; 18839 MAGIC *mg; 18839 bool ok; 18839 gv = (GV *)*++MARK; 18839 if (!isGV(gv)) ###### DIE(aTHX_ PL_no_usym, "filehandle"); 18839 if ((io = GvIOp(gv))) 14243 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT; 18839 if (io && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { /* Method's args are same as ours ... */ /* ... except handle is replaced by the object */ 2 *MARK-- = SvTIED_obj((SV*)io, mg); 2 PUSHMARK(MARK); 2 PUTBACK; 2 ENTER; 2 call_method("OPEN", G_SCALAR); 2 LEAVE; 2 SPAGAIN; 2 RETURN; } 18837 if (MARK < SP) { 18827 sv = *++MARK; } else { 10 sv = GvSVn(gv); } 18837 tmps = SvPV_const(sv, len); 18837 ok = do_openn(gv, (char *)tmps, len, FALSE, O_RDONLY, 0, Nullfp, MARK+1, (SP-MARK)); 18851 SP = ORIGMARK; 18851 if (ok) 18120 PUSHi( (I32)PL_forkprocess ); 731 else if (PL_forkprocess == 0) /* we are a new child */ 23 PUSHi(0); else 708 RETPUSHUNDEF; 18143 RETURN; } PP(pp_close) 18183 { 18183 dVAR; dSP; 18183 GV *gv; 18183 IO *io; 18183 MAGIC *mg; 18183 if (MAXARG == 0) ###### gv = PL_defoutgv; else 18183 gv = (GV*)POPs; 18183 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 9 PUSHMARK(SP); 9 XPUSHs(SvTIED_obj((SV*)io, mg)); 9 PUTBACK; 9 ENTER; 9 call_method("CLOSE", G_SCALAR); 9 LEAVE; 9 SPAGAIN; 9 RETURN; } 18174 EXTEND(SP, 1); 18174 PUSHs(boolSV(do_close(gv, TRUE))); 18173 RETURN; } PP(pp_pipe_op) 69 { #ifdef HAS_PIPE 69 dSP; 69 GV *rgv; 69 GV *wgv; 69 register IO *rstio; 69 register IO *wstio; 69 int fd[2]; 69 wgv = (GV*)POPs; 69 rgv = (GV*)POPs; 69 if (!rgv || !wgv) ###### goto badexit; 69 if (SvTYPE(rgv) != SVt_PVGV || SvTYPE(wgv) != SVt_PVGV) ###### DIE(aTHX_ PL_no_usym, "filehandle"); 69 rstio = GvIOn(rgv); 69 wstio = GvIOn(wgv); 69 if (IoIFP(rstio)) 4 do_close(rgv, FALSE); 69 if (IoIFP(wstio)) 6 do_close(wgv, FALSE); 69 if (PerlProc_pipe(fd) < 0) ###### goto badexit; 69 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE); 69 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE); 69 IoOFP(rstio) = IoIFP(rstio); 69 IoIFP(wstio) = IoOFP(wstio); 69 IoTYPE(rstio) = IoTYPE_RDONLY; 69 IoTYPE(wstio) = IoTYPE_WRONLY; 69 if (!IoIFP(rstio) || !IoOFP(wstio)) { ###### if (IoIFP(rstio)) PerlIO_close(IoIFP(rstio)); ###### else PerlLIO_close(fd[0]); ###### if (IoOFP(wstio)) PerlIO_close(IoOFP(wstio)); ###### else PerlLIO_close(fd[1]); ###### goto badexit; } #if defined(HAS_FCNTL) && defined(F_SETFD) 69 fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd); /* ensure close-on-exec */ 69 fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd); /* ensure close-on-exec */ #endif 69 RETPUSHYES; badexit: ###### RETPUSHUNDEF; #else DIE(aTHX_ PL_no_func, "pipe"); #endif } PP(pp_fileno) 311 { 311 dVAR; dSP; dTARGET; 311 GV *gv; 311 IO *io; 311 PerlIO *fp; 311 MAGIC *mg; 311 if (MAXARG < 1) ###### RETPUSHUNDEF; 311 gv = (GV*)POPs; 311 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { ###### PUSHMARK(SP); ###### XPUSHs(SvTIED_obj((SV*)io, mg)); ###### PUTBACK; ###### ENTER; ###### call_method("FILENO", G_SCALAR); ###### LEAVE; ###### SPAGAIN; ###### RETURN; } 311 if (!gv || !(io = GvIO(gv)) || !(fp = IoIFP(io))) { /* Can't do this because people seem to do things like defined(fileno($foo)) to check whether $foo is a valid fh. if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) report_evil_fh(gv, io, PL_op->op_type); */ 34 RETPUSHUNDEF; } 277 PUSHi(PerlIO_fileno(fp)); 277 RETURN; } PP(pp_umask) 139 { 139 dSP; #ifdef HAS_UMASK 139 dTARGET; 139 Mode_t anum; 139 if (MAXARG < 1) { 47 anum = PerlLIO_umask(0); 47 (void)PerlLIO_umask(anum); } else 92 anum = PerlLIO_umask(POPi); 139 TAINT_PROPER("umask"); 139 XPUSHi(anum); #else /* Only DIE if trying to restrict permissions on "user" (self). * Otherwise it's harmless and more useful to just return undef * since 'group' and 'other' concepts probably don't exist here. */ if (MAXARG >= 1 && (POPi & 0700)) DIE(aTHX_ "umask not implemented"); XPUSHs(&PL_sv_undef); #endif 139 RETURN; } PP(pp_binmode) 11018 { 11018 dVAR; dSP; 11018 GV *gv; 11018 IO *io; 11018 PerlIO *fp; 11018 MAGIC *mg; 11018 SV *discp = Nullsv; 11018 if (MAXARG < 1) ###### RETPUSHUNDEF; 11018 if (MAXARG > 1) { 972 discp = POPs; } 11018 gv = (GV*)POPs; 11018 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 1 PUSHMARK(SP); 1 XPUSHs(SvTIED_obj((SV*)io, mg)); 1 if (discp) ###### XPUSHs(discp); 1 PUTBACK; 1 ENTER; 1 call_method("BINMODE", G_SCALAR); 1 LEAVE; 1 SPAGAIN; 1 RETURN; } 11017 EXTEND(SP, 1); 11017 if (!(io = GvIO(gv)) || !(fp = IoIFP(io))) { 3 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); 3 SETERRNO(EBADF,RMS_IFI); 3 RETPUSHUNDEF; } 11014 PUTBACK; 11014 if (PerlIO_binmode(aTHX_ fp,IoTYPE(io),mode_from_discipline(discp), (discp) ? SvPV_nolen_const(discp) : Nullch)) { 11012 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) { 8 if (!PerlIO_binmode(aTHX_ IoOFP(io),IoTYPE(io), mode_from_discipline(discp), (discp) ? SvPV_nolen_const(discp) : Nullch)) { ###### SPAGAIN; ###### RETPUSHUNDEF; } } 11012 SPAGAIN; 11012 RETPUSHYES; } else { 2 SPAGAIN; 2 RETPUSHUNDEF; } } PP(pp_tie) 5331 { 5331 dVAR; dSP; dMARK; 5331 SV *varsv; 5331 HV* stash; 5331 GV *gv; 5331 SV *sv; 5331 const I32 markoff = MARK - PL_stack_base; 5331 const char *methname; 5331 int how = PERL_MAGIC_tied; 5331 U32 items; 5331 varsv = *++MARK; 5331 switch(SvTYPE(varsv)) { case SVt_PVHV: 1836 methname = "TIEHASH"; 1836 HvEITER_set((HV *)varsv, 0); 1836 break; case SVt_PVAV: 3035 methname = "TIEARRAY"; 3035 break; case SVt_PVGV: #ifdef GV_UNIQUE_CHECK if (GvUNIQUE((GV*)varsv)) { Perl_croak(aTHX_ "Attempt to tie unique GV"); } #endif 260 methname = "TIEHANDLE"; 260 how = PERL_MAGIC_tiedscalar; /* For tied filehandles, we apply tiedscalar magic to the IO slot of the GP rather than the GV itself. AMS 20010812 */ 260 if (!GvIOp(varsv)) 118 GvIOp(varsv) = newIO(); 260 varsv = (SV *)GvIOp(varsv); 260 break; default: 200 methname = "TIESCALAR"; 200 how = PERL_MAGIC_tiedscalar; 5331 break; } 5331 items = SP - MARK++; 5331 if (sv_isobject(*MARK)) { ###### ENTER; ###### PUSHSTACKi(PERLSI_MAGIC); ###### PUSHMARK(SP); ###### EXTEND(SP,(I32)items); ###### while (items--) ###### PUSHs(*MARK++); ###### PUTBACK; ###### call_method(methname, G_SCALAR); } else { /* Not clear why we don't call call_method here too. * perhaps to get different error message ? */ 5331 stash = gv_stashsv(*MARK, FALSE); 5331 if (!stash || !(gv = gv_fetchmethod(stash, methname))) { 1 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"", methname, *MARK); } 5330 ENTER; 5330 PUSHSTACKi(PERLSI_MAGIC); 5330 PUSHMARK(SP); 5330 EXTEND(SP,(I32)items); 15607 while (items--) 10277 PUSHs(*MARK++); 5330 PUTBACK; 5330 call_sv((SV*)GvCV(gv), G_SCALAR); } 5326 SPAGAIN; 5326 sv = TOPs; 5326 POPSTACK; 5326 if (sv_isobject(sv)) { 5320 sv_unmagic(varsv, how); /* Croak if a self-tie on an aggregate is attempted. */ 5320 if (varsv == SvRV(sv) && (SvTYPE(varsv) == SVt_PVAV || SvTYPE(varsv) == SVt_PVHV)) 1 Perl_croak(aTHX_ "Self-ties of arrays and hashes are not supported"); 5319 sv_magic(varsv, (SvRV(sv) == varsv ? Nullsv : sv), how, Nullch, 0); } 5325 LEAVE; 5325 SP = PL_stack_base + markoff; 5325 PUSHs(sv); 5325 RETURN; } PP(pp_untie) 3193 { 3193 dVAR; dSP; 3193 MAGIC *mg; 3193 SV *sv = POPs; 3193 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) 3193 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar; 3193 if (SvTYPE(sv) == SVt_PVGV && !(sv = (SV *)GvIOp(sv))) ###### RETPUSHYES; 3193 if ((mg = SvTIED_mg(sv, how))) { 3111 SV * const obj = SvRV(SvTIED_obj(sv, mg)); 3111 GV *gv; 3111 CV *cv = NULL; 3111 if (obj) { 3110 if ((gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE)) && isGV(gv) && (cv = GvCV(gv))) { 49 PUSHMARK(SP); 49 XPUSHs(SvTIED_obj((SV*)gv, mg)); 49 XPUSHs(sv_2mortal(newSViv(SvREFCNT(obj)-1))); 49 PUTBACK; 49 ENTER; 49 call_sv((SV *)cv, G_VOID); 49 LEAVE; 49 SPAGAIN; } 3061 else if (ckWARN(WARN_UNTIE)) { 64 if (mg && SvREFCNT(obj) > 1) 4 Perl_warner(aTHX_ packWARN(WARN_UNTIE), "untie attempted while %"UVuf" inner references still exist", (UV)SvREFCNT(obj) - 1 ) ; } } } 3193 sv_unmagic(sv, how) ; 3193 RETPUSHYES; } PP(pp_tied) 1088 { 1088 dSP; 1088 const MAGIC *mg; 1088 SV *sv = POPs; 1088 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) 1088 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar; 1088 if (SvTYPE(sv) == SVt_PVGV && !(sv = (SV *)GvIOp(sv))) 3 RETPUSHUNDEF; 1085 if ((mg = SvTIED_mg(sv, how))) { 792 SV *osv = SvTIED_obj(sv, mg); 792 if (osv == mg->mg_obj) 792 osv = sv_mortalcopy(osv); 792 PUSHs(osv); 792 RETURN; } 293 RETPUSHUNDEF; } PP(pp_dbmopen) 1 { 1 dVAR; dSP; 1 dPOPPOPssrl; 1 HV* stash; 1 GV *gv; 1 SV *sv; 1 HV * const hv = (HV*)POPs; 1 sv = sv_mortalcopy(&PL_sv_no); 1 sv_setpv(sv, "AnyDBM_File"); 1 stash = gv_stashsv(sv, FALSE); 1 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) { ###### PUTBACK; ###### require_pv("AnyDBM_File.pm"); ###### SPAGAIN; ###### if (!(gv = gv_fetchmethod(stash, "TIEHASH"))) ###### DIE(aTHX_ "No dbm on this machine"); } 1 ENTER; 1 PUSHMARK(SP); 1 EXTEND(SP, 5); 1 PUSHs(sv); 1 PUSHs(left); 1 if (SvIV(right)) 1 PUSHs(sv_2mortal(newSVuv(O_RDWR|O_CREAT))); else ###### PUSHs(sv_2mortal(newSVuv(O_RDWR))); 1 PUSHs(right); 1 PUTBACK; 1 call_sv((SV*)GvCV(gv), G_SCALAR); 1 SPAGAIN; 1 if (!sv_isobject(TOPs)) { ###### SP--; ###### PUSHMARK(SP); ###### PUSHs(sv); ###### PUSHs(left); ###### PUSHs(sv_2mortal(newSVuv(O_RDONLY))); ###### PUSHs(right); ###### PUTBACK; ###### call_sv((SV*)GvCV(gv), G_SCALAR); ###### SPAGAIN; } 1 if (sv_isobject(TOPs)) { 1 sv_unmagic((SV *) hv, PERL_MAGIC_tied); 1 sv_magic((SV*)hv, TOPs, PERL_MAGIC_tied, Nullch, 0); } 1 LEAVE; 1 RETURN; } PP(pp_dbmclose) 1 { 1 return pp_untie(); } PP(pp_sselect) 65 { #ifdef HAS_SELECT 65 dSP; dTARGET; 65 register I32 i; 65 register I32 j; 65 register char *s; 65 register SV *sv; 65 NV value; 65 I32 maxlen = 0; 65 I32 nfound; 65 struct timeval timebuf; 65 struct timeval *tbuf = &timebuf; 65 I32 growsize; 65 char *fd_sets[4]; #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678 I32 masksize; I32 offset; I32 k; # if BYTEORDER & 0xf0000 # define ORDERBYTE (0x88888888 - BYTEORDER) # else # define ORDERBYTE (0x4444 - BYTEORDER) # endif #endif 65 SP -= 4; 254 for (i = 1; i <= 3; i++) { 192 SV *sv = SP[i]; 192 if (SvOK(sv) && SvREADONLY(sv)) { 3 if (SvIsCOW(sv)) ###### sv_force_normal_flags(sv, 0); 3 if (SvREADONLY(sv)) 3 DIE(aTHX_ PL_no_modify); } 189 if (!SvPOK(sv)) 125 continue; 64 j = SvCUR(sv); 64 if (maxlen < j) 54 maxlen = j; } /* little endians can use vecs directly */ #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678 # ifdef NFDBITS # ifndef NBBY # define NBBY 8 # endif masksize = NFDBITS / NBBY; # else masksize = sizeof(long); /* documented int, everyone seems to use long */ # endif Zero(&fd_sets[0], 4, char*); #endif # if SELECT_MIN_BITS == 1 growsize = sizeof(fd_set); # else # if defined(__GLIBC__) && defined(__FD_SETSIZE) # undef SELECT_MIN_BITS # define SELECT_MIN_BITS __FD_SETSIZE # endif /* If SELECT_MIN_BITS is greater than one we most probably will want * to align the sizes with SELECT_MIN_BITS/8 because for example * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital * UNIX, Solaris, NeXT, Darwin) the smallest quantum select() operates * on (sets/tests/clears bits) is 32 bits. */ 62 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8))); # endif 62 sv = SP[4]; 62 if (SvOK(sv)) { 41 value = SvNV(sv); 41 if (value < 0.0) ###### value = 0.0; 41 timebuf.tv_sec = (long)value; 41 value -= (NV)timebuf.tv_sec; 41 timebuf.tv_usec = (long)(value * 1000000.0); } else 21 tbuf = Null(struct timeval*); 248 for (i = 1; i <= 3; i++) { 186 sv = SP[i]; 186 if (!SvOK(sv)) { 125 fd_sets[i] = 0; 125 continue; } 61 else if (!SvPOK(sv)) ###### SvPV_force_nolen(sv); /* force string conversion */ 61 j = SvLEN(sv); 61 if (j < growsize) { 29 Sv_Grow(sv, growsize); } 61 j = SvCUR(sv); 61 s = SvPVX(sv) + j; 7814 while (++j <= growsize) { 7753 *s++ = '\0'; } #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678 s = SvPVX(sv); New(403, fd_sets[i], growsize, char); for (offset = 0; offset < growsize; offset += masksize) { for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4)) fd_sets[i][j+offset] = s[(k % masksize) + offset]; } #else 61 fd_sets[i] = SvPVX(sv); #endif } #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST /* Can't make just the (void*) conditional because that would be * cpp #if within cpp macro, and not all compilers like that. */ nfound = PerlSock_select( maxlen * 8, (Select_fd_set_t) fd_sets[1], (Select_fd_set_t) fd_sets[2], (Select_fd_set_t) fd_sets[3], (void*) tbuf); /* Workaround for compiler bug. */ #else 62 nfound = PerlSock_select( maxlen * 8, (Select_fd_set_t) fd_sets[1], (Select_fd_set_t) fd_sets[2], (Select_fd_set_t) fd_sets[3], tbuf); #endif 248 for (i = 1; i <= 3; i++) { 186 if (fd_sets[i]) { 61 sv = SP[i]; #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678 s = SvPVX(sv); for (offset = 0; offset < growsize; offset += masksize) { for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4)) s[(k % masksize) + offset] = fd_sets[i][j+offset]; } Safefree(fd_sets[i]); #endif 61 SvSETMAGIC(sv); } } 62 if (nfound == -1) 2 PUSHs(&PL_sv_undef); else 60 PUSHi(nfound); 62 if (GIMME == G_ARRAY && tbuf) { ###### value = (NV)(timebuf.tv_sec) + (NV)(timebuf.tv_usec) / 1000000.0; ###### PUSHs(sv = sv_mortalcopy(&PL_sv_no)); ###### sv_setnv(sv, value); } 62 RETURN; #else DIE(aTHX_ "select not implemented"); #endif } void Perl_setdefout(pTHX_ GV *gv) 18403 { 18403 if (gv) 13854 (void)SvREFCNT_inc(gv); 18403 if (PL_defoutgv) 13900 SvREFCNT_dec(PL_defoutgv); 18403 PL_defoutgv = gv; } PP(pp_select) 9193 { 9193 dSP; dTARGET; 9193 GV *egv; 9193 HV *hv; 9193 GV * const newdefout = (PL_op->op_private > 0) ? ((GV *) POPs) : (GV *) NULL; 9193 egv = GvEGV(PL_defoutgv); 9193 if (!egv) 5 egv = PL_defoutgv; 9193 hv = GvSTASH(egv); 9193 if (! hv) ###### XPUSHs(&PL_sv_undef); else { 9193 GV ** const gvp = (GV**)hv_fetch(hv, GvNAME(egv), GvNAMELEN(egv), FALSE); 9193 if (gvp && *gvp == egv) { 6139 gv_efullname4(TARG, PL_defoutgv, Nullch, TRUE); 6139 XPUSHTARG; } else { 3054 XPUSHs(sv_2mortal(newRV((SV*)egv))); } } 9193 if (newdefout) { 9069 if (!GvIO(newdefout)) 36 gv_IOadd(newdefout); 9069 setdefout(newdefout); } 9193 RETURN; } PP(pp_getc) 317 { 317 dVAR; dSP; dTARGET; 317 IO *io = NULL; 317 MAGIC *mg; 317 GV * const gv = (MAXARG==0) ? PL_stdingv : (GV*)POPs; 317 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 299 const I32 gimme = GIMME_V; 299 PUSHMARK(SP); 299 XPUSHs(SvTIED_obj((SV*)io, mg)); 299 PUTBACK; 299 ENTER; 299 call_method("GETC", gimme); 299 LEAVE; 299 SPAGAIN; 299 if (gimme == G_SCALAR) 299 SvSetMagicSV_nosteal(TARG, TOPs); 299 RETURN; } 18 if (!gv || do_eof(gv)) { /* make sure we have fp with something */ 7 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED) && (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))) 3 report_evil_fh(gv, io, PL_op->op_type); 7 SETERRNO(EBADF,RMS_IFI); 7 RETPUSHUNDEF; } 11 TAINT; 11 sv_setpvn(TARG, " ", 1); 11 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */ 11 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) { /* Find out how many bytes the char needs */ 3 Size_t len = UTF8SKIP(SvPVX_const(TARG)); 3 if (len > 1) { 2 SvGROW(TARG,len+1); 2 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1); 2 SvCUR_set(TARG,1+len); } 3 SvUTF8_on(TARG); } 11 PUSHTARG; 11 RETURN; } PP(pp_read) 12679 { 12679 return pp_sysread(); } STATIC OP * S_doform(pTHX_ CV *cv, GV *gv, OP *retop) 131 { dVAR; 131 register PERL_CONTEXT *cx; 131 const I32 gimme = GIMME_V; 131 ENTER; 131 SAVETMPS; 131 PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp); 131 PUSHFORMAT(cx); 131 cx->blk_sub.retop = retop; 131 SAVECOMPPAD(); 131 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1); 131 setdefout(gv); /* locally select filehandle so $% et al work */ 131 return CvSTART(cv); } PP(pp_enterwrite) 123 { 123 dSP; 123 register GV *gv; 123 register IO *io; 123 GV *fgv; 123 CV *cv; 123 if (MAXARG == 0) 33 gv = PL_defoutgv; else { 90 gv = (GV*)POPs; 90 if (!gv) ###### gv = PL_defoutgv; } 123 EXTEND(SP, 1); 123 io = GvIO(gv); 123 if (!io) { ###### RETPUSHNO; } 123 if (IoFMT_GV(io)) 8 fgv = IoFMT_GV(io); else 115 fgv = gv; 123 cv = GvFORM(fgv); 123 if (!cv) { ###### if (fgv) { ###### SV * const tmpsv = sv_newmortal(); ###### const char *name; ###### gv_efullname4(tmpsv, fgv, Nullch, FALSE); ###### name = SvPV_nolen_const(tmpsv); ###### if (name && *name) ###### DIE(aTHX_ "Undefined format \"%s\" called", name); } ###### DIE(aTHX_ "Not a format reference"); } 123 if (CvCLONE(cv)) 35 cv = (CV*)sv_2mortal((SV*)cv_clone(cv)); 123 IoFLAGS(io) &= ~IOf_DIDTOP; 123 return doform(cv,gv,PL_op->op_next); } PP(pp_leavewrite) 138 { 138 dVAR; dSP; 138 GV * const gv = cxstack[cxstack_ix].blk_sub.gv; 138 register IO * const io = GvIOp(gv); 138 PerlIO * const ofp = IoOFP(io); 138 PerlIO *fp; 138 SV **newsp; 138 I32 gimme; 138 register PERL_CONTEXT *cx; DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n", 138 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget))); 138 if (!io || !ofp) 67 goto forget_top; 71 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) && PL_formtarget != PL_toptarget) { 36 GV *fgv; 36 CV *cv; 36 if (!IoTOP_GV(io)) { 28 GV *topgv; 28 if (!IoTOP_NAME(io)) { 27 SV *topname; 27 if (!IoFMT_NAME(io)) 25 IoFMT_NAME(io) = savepv(GvNAME(gv)); 27 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%s_TOP", GvNAME(gv))); 27 topgv = gv_fetchsv(topname, FALSE, SVt_PVFM); 27 if ((topgv && GvFORM(topgv)) || !gv_fetchpv("top",FALSE,SVt_PVFM)) 27 IoTOP_NAME(io) = savesvpv(topname); else ###### IoTOP_NAME(io) = savepvn("top", 3); } 28 topgv = gv_fetchpv(IoTOP_NAME(io),FALSE, SVt_PVFM); 28 if (!topgv || !GvFORM(topgv)) { 26 IoLINES_LEFT(io) = IoPAGE_LEN(io); 26 goto forget_top; } 2 IoTOP_GV(io) = topgv; } 10 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */ 5 I32 lines = IoLINES_LEFT(io); 5 const char *s = SvPVX_const(PL_formtarget); 5 if (lines <= 0) /* Yow, header didn't even fit!!! */ 2 goto forget_top; 12 while (lines-- > 0) { 9 s = strchr(s, '\n'); 9 if (!s) ###### break; 9 s++; } 3 if (s) { 3 const STRLEN save = SvCUR(PL_formtarget); 3 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget)); 3 do_print(PL_formtarget, ofp); 3 SvCUR_set(PL_formtarget, save); 3 sv_chop(PL_formtarget, s); 3 FmLINES(PL_formtarget) -= IoLINES_LEFT(io); } } 8 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0) 4 do_print(PL_formfeed, ofp); 8 IoLINES_LEFT(io) = IoPAGE_LEN(io); 8 IoPAGE(io)++; 8 PL_formtarget = PL_toptarget; 8 IoFLAGS(io) |= IOf_DIDTOP; 8 fgv = IoTOP_GV(io); 8 if (!fgv) ###### DIE(aTHX_ "bad top format reference"); 8 cv = GvFORM(fgv); 8 if (!cv) { ###### SV * const sv = sv_newmortal(); ###### const char *name; ###### gv_efullname4(sv, fgv, Nullch, FALSE); ###### name = SvPV_nolen_const(sv); ###### if (name && *name) ###### DIE(aTHX_ "Undefined top format \"%s\" called",name); } /* why no: else DIE(aTHX_ "Undefined top format called"); ?*/ 8 if (CvCLONE(cv)) 5 cv = (CV*)sv_2mortal((SV*)cv_clone(cv)); 8 return doform(cv,gv,PL_op); } forget_top: 130 POPBLOCK(cx,PL_curpm); 130 POPFORMAT(cx); 130 LEAVE; 130 fp = IoOFP(io); 130 if (!fp) { 67 if (ckWARN2(WARN_CLOSED,WARN_IO)) { 3 if (IoIFP(io)) 1 report_evil_fh(gv, io, OP_phoney_INPUT_ONLY); 2 else if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); } 67 PUSHs(&PL_sv_no); } else { 63 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) { 3 if (ckWARN(WARN_IO)) 1 Perl_warner(aTHX_ packWARN(WARN_IO), "page overflow"); } 63 if (!do_print(PL_formtarget, fp)) ###### PUSHs(&PL_sv_no); else { 63 FmLINES(PL_formtarget) = 0; 63 SvCUR_set(PL_formtarget, 0); 63 *SvEND(PL_formtarget) = '\0'; 63 if (IoFLAGS(io) & IOf_FLUSH) 11 (void)PerlIO_flush(fp); 63 PUSHs(&PL_sv_yes); } } /* bad_ofp: */ 130 PL_formtarget = PL_bodytarget; 130 PUTBACK; 130 PERL_UNUSED_VAR(newsp); 130 PERL_UNUSED_VAR(gimme); 130 return cx->blk_sub.retop; } PP(pp_prtf) 225658 { 225658 dVAR; dSP; dMARK; dORIGMARK; 225658 GV *gv; 225658 IO *io; 225658 PerlIO *fp; 225658 SV *sv; 225658 MAGIC *mg; 225658 if (PL_op->op_flags & OPf_STACKED) 223210 gv = (GV*)*++MARK; else 2448 gv = PL_defoutgv; 225658 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 36 if (MARK == ORIGMARK) { 32 MEXTEND(SP, 1); 32 ++MARK; 32 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*); 32 ++SP; } 36 PUSHMARK(MARK - 1); 36 *MARK = SvTIED_obj((SV*)io, mg); 36 PUTBACK; 36 ENTER; 36 call_method("PRINTF", G_SCALAR); 36 LEAVE; 36 SPAGAIN; 36 MARK = ORIGMARK + 1; 36 *MARK = *SP; 36 SP = MARK; 36 RETURN; } 225622 sv = NEWSV(0,0); 225622 if (!(io = GvIO(gv))) { 2 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) 1 report_evil_fh(gv, io, PL_op->op_type); 2 SETERRNO(EBADF,RMS_IFI); 2 goto just_say_no; } 225620 else if (!(fp = IoOFP(io))) { 6 if (ckWARN2(WARN_CLOSED,WARN_IO)) { 3 if (IoIFP(io)) 1 report_evil_fh(gv, io, OP_phoney_INPUT_ONLY); 2 else if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); } 6 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI); 6 goto just_say_no; } else { 225614 do_sprintf(sv, SP - MARK, MARK + 1); 225614 if (!do_print(sv, fp)) ###### goto just_say_no; 225614 if (IoFLAGS(io) & IOf_FLUSH) 1954 if (PerlIO_flush(fp) == EOF) ###### goto just_say_no; } 225614 SvREFCNT_dec(sv); 225614 SP = ORIGMARK; 225614 PUSHs(&PL_sv_yes); 225614 RETURN; just_say_no: 8 SvREFCNT_dec(sv); 8 SP = ORIGMARK; 8 PUSHs(&PL_sv_undef); 8 RETURN; } PP(pp_sysopen) 3037 { 3037 dSP; 3037 const int perm = (MAXARG > 3) ? POPi : 0666; 3037 const int mode = POPi; 3037 SV * const sv = POPs; 3037 GV * const gv = (GV *)POPs; 3037 STRLEN len; /* Need TIEHANDLE method ? */ 3037 const char * const tmps = SvPV_const(sv, len); /* FIXME? do_open should do const */ 3037 if (do_open(gv, (char*)tmps, len, TRUE, mode, perm, Nullfp)) { 3017 IoLINES(GvIOp(gv)) = 0; 3017 PUSHs(&PL_sv_yes); } else { 5 PUSHs(&PL_sv_undef); } 3022 RETURN; } PP(pp_sysread) 13096 { 13096 dVAR; dSP; dMARK; dORIGMARK; dTARGET; 13096 int offset; 13096 IO *io; 13096 char *buffer; 13096 SSize_t length; 13096 SSize_t count; 13096 Sock_size_t bufsize; 13096 SV *bufsv; 13096 STRLEN blen; 13096 int fp_utf8; 13096 int buffer_utf8; 13096 SV *read_target; 13096 Size_t got = 0; 13096 Size_t wanted; 13096 bool charstart = FALSE; 13096 STRLEN charskip = 0; 13096 STRLEN skip = 0; 13096 GV * const gv = (GV*)*++MARK; 13096 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD) && gv && (io = GvIO(gv)) ) { 13088 const MAGIC * mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar); 13088 if (mg) { 133 SV *sv; 133 PUSHMARK(MARK-1); 133 *MARK = SvTIED_obj((SV*)io, mg); 133 ENTER; 133 call_method("READ", G_SCALAR); 133 LEAVE; 133 SPAGAIN; 133 sv = POPs; 133 SP = ORIGMARK; 133 PUSHs(sv); 133 RETURN; } } 12963 if (!gv) ###### goto say_undef; 12963 bufsv = *++MARK; 12963 if (! SvOK(bufsv)) 11160 sv_setpvn(bufsv, "", 0); 12963 length = SvIVx(*++MARK); 12963 SETERRNO(0,0); 12963 if (MARK < SP) 1293 offset = SvIVx(*++MARK); else 11670 offset = 0; 12963 io = GvIO(gv); 12963 if (!io || !IoIFP(io)) { 9 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) 4 report_evil_fh(gv, io, PL_op->op_type); 9 SETERRNO(EBADF,RMS_IFI); 9 goto say_undef; } 12954 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) { 791 buffer = SvPVutf8_force(bufsv, blen); /* UTF-8 may not have been set if they are all low bytes */ 791 SvUTF8_on(bufsv); 791 buffer_utf8 = 0; } else { 12163 buffer = SvPV_force(bufsv, blen); 12163 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv); } 12954 if (length < 0) 1 DIE(aTHX_ "Negative length"); 12953 wanted = length; 12953 charstart = TRUE; 12953 charskip = 0; 12953 skip = 0; #ifdef HAS_SOCKET 12953 if (PL_op->op_type == OP_RECV) { 4 char namebuf[MAXPATHLEN]; #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__) bufsize = sizeof (struct sockaddr_in); #else 4 bufsize = sizeof namebuf; #endif #ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */ if (bufsize >= 256) bufsize = 255; #endif 4 buffer = SvGROW(bufsv, (STRLEN)(length+1)); /* 'offset' means 'flags' here */ 4 count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, offset, (struct sockaddr *)namebuf, &bufsize); 4 if (count < 0) 1 RETPUSHUNDEF; #ifdef EPOC /* Bogus return without padding */ bufsize = sizeof (struct sockaddr_in); #endif 3 SvCUR_set(bufsv, count); 3 *SvEND(bufsv) = '\0'; 3 (void)SvPOK_only(bufsv); 3 if (fp_utf8) ###### SvUTF8_on(bufsv); 3 SvSETMAGIC(bufsv); /* This should not be marked tainted if the fp is marked clean */ 3 if (!(IoFLAGS(io) & IOf_UNTAINT)) 3 SvTAINTED_on(bufsv); 3 SP = ORIGMARK; 3 sv_setpvn(TARG, namebuf, bufsize); 3 PUSHs(TARG); 3 RETURN; } #else if (PL_op->op_type == OP_RECV) DIE(aTHX_ PL_no_sock_func, "recv"); #endif 12949 if (DO_UTF8(bufsv)) { /* offset adjust in characters not bytes */ 1047 blen = sv_len_utf8(bufsv); } 12949 if (offset < 0) { 642 if (-offset > (int)blen) 1 DIE(aTHX_ "Offset outside string"); 641 offset += blen; } 12948 if (DO_UTF8(bufsv)) { /* convert offset-as-chars to offset-as-bytes */ 1047 if (offset >= (int)blen) 131 offset += SvCUR(bufsv) - blen; else 916 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer; } more_bytes: 13762 bufsize = SvCUR(bufsv); /* Allocating length + offset + 1 isn't perfect in the case of reading bytes from a byte file handle into a UTF8 buffer, but it won't harm us unduly. (should be 2 * length + offset + 1, or possibly something longer if PL_encoding is true) */ 13762 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1)); 13762 if (offset > 0 && (Sock_size_t)offset > bufsize) { /* Zero any newly allocated space */ 162 Zero(buffer+bufsize, offset-bufsize, char); } 13762 buffer = buffer + offset; 13762 if (!buffer_utf8) { 13506 read_target = bufsv; } else { /* Best to read the bytes into a new SV, upgrade that to UTF8, then concatenate it to the current buffer. */ /* Truncate the existing buffer to the start of where we will be reading to: */ 256 SvCUR_set(bufsv, offset); 256 read_target = sv_newmortal(); 256 SvUPGRADE(read_target, SVt_PV); 256 buffer = SvGROW(read_target, (STRLEN)(length + 1)); } 13762 if (PL_op->op_type == OP_SYSREAD) { #ifdef PERL_SOCK_SYSREAD_IS_RECV if (IoTYPE(io) == IoTYPE_SOCKET) { count = PerlSock_recv(PerlIO_fileno(IoIFP(io)), buffer, length, 0); } else #endif { 414 count = PerlLIO_read(PerlIO_fileno(IoIFP(io)), buffer, length); } } else #ifdef HAS_SOCKET__bad_code_maybe if (IoTYPE(io) == IoTYPE_SOCKET) { char namebuf[MAXPATHLEN]; #if defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS) bufsize = sizeof (struct sockaddr_in); #else bufsize = sizeof namebuf; #endif count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, 0, (struct sockaddr *)namebuf, &bufsize); } else #endif { 13348 count = PerlIO_read(IoIFP(io), buffer, length); /* PerlIO_read() - like fread() returns 0 on both error and EOF */ 13348 if (count == 0 && PerlIO_error(IoIFP(io))) ###### count = -1; } 13762 if (count < 0) { 14 if ((IoTYPE(io) == IoTYPE_WRONLY) && ckWARN(WARN_IO)) 1 report_evil_fh(gv, io, OP_phoney_OUTPUT_ONLY); 1 goto say_undef; } 13748 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target))); 13748 *SvEND(read_target) = '\0'; 13748 (void)SvPOK_only(read_target); 13748 if (fp_utf8 && !IN_BYTES) { /* Look at utf8 we got back and count the characters */ 1605 const char *bend = buffer + count; 3165 while (buffer < bend) { 1957 if (charstart) { 1560 skip = UTF8SKIP(buffer); 1560 charskip = 0; } 1957 if (buffer - charskip + skip > bend) { /* partial character - try for rest of it */ 397 length = skip - (bend-buffer); 397 offset = bend - SvPVX_const(bufsv); 397 charstart = FALSE; 397 charskip += count; 397 goto more_bytes; } else { 1560 got++; 1560 buffer += skip; 1560 charstart = TRUE; 1560 charskip = 0; } } /* If we have not 'got' the number of _characters_ we 'wanted' get some more provided amount read (count) was what was requested (length) */ 1208 if (got < wanted && count == length) { 417 length = wanted - got; 417 offset = bend - SvPVX_const(bufsv); 417 goto more_bytes; } /* return value is character count */ 791 count = got; 791 SvUTF8_on(bufsv); } 12143 else if (buffer_utf8) { /* Let svcatsv upgrade the bytes we read in to utf8. The buffer is a mortal so will be freed soon. */ 256 sv_catsv_nomg(bufsv, read_target); } 12934 SvSETMAGIC(bufsv); /* This should not be marked tainted if the fp is marked clean */ 12934 if (!(IoFLAGS(io) & IOf_UNTAINT)) 12934 SvTAINTED_on(bufsv); 12934 SP = ORIGMARK; 12934 PUSHi(count); 12934 RETURN; say_undef: 23 SP = ORIGMARK; 23 RETPUSHUNDEF; } PP(pp_syswrite) 488 { 488 dVAR; dSP; 488 const int items = (SP - PL_stack_base) - TOPMARK; 488 if (items == 2) { 252 SV *sv; 252 EXTEND(SP, 1); 252 sv = sv_2mortal(newSViv(sv_len(*SP))); 252 PUSHs(sv); 252 PUTBACK; } 488 return pp_send(); } PP(pp_send) 497 { 497 dVAR; dSP; dMARK; dORIGMARK; dTARGET; 497 GV *gv; 497 IO *io; 497 SV *bufsv; 497 const char *buffer; 497 Size_t length; 497 SSize_t retval; 497 STRLEN blen; 497 MAGIC *mg; 497 gv = (GV*)*++MARK; 497 if (PL_op->op_type == OP_SYSWRITE && gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 167 SV *sv; 167 PUSHMARK(MARK-1); 167 *MARK = SvTIED_obj((SV*)io, mg); 167 ENTER; 167 call_method("WRITE", G_SCALAR); 167 LEAVE; 167 SPAGAIN; 167 sv = POPs; 167 SP = ORIGMARK; 167 PUSHs(sv); 167 RETURN; } 330 if (!gv) ###### goto say_undef; 330 bufsv = *++MARK; #if Size_t_size > IVSIZE length = (Size_t)SvNVx(*++MARK); #else 330 length = (Size_t)SvIVx(*++MARK); #endif 330 if ((SSize_t)length < 0) 1 DIE(aTHX_ "Negative length"); 329 SETERRNO(0,0); 329 io = GvIO(gv); 329 if (!io || !IoIFP(io)) { 9 retval = -1; 9 if (ckWARN(WARN_CLOSED)) 4 report_evil_fh(gv, io, PL_op->op_type); 9 SETERRNO(EBADF,RMS_IFI); 9 goto say_undef; } 320 if (PerlIO_isutf8(IoIFP(io))) { 8 if (!SvUTF8(bufsv)) { 3 bufsv = sv_2mortal(newSVsv(bufsv)); 3 buffer = sv_2pvutf8(bufsv, &blen); } else 5 buffer = SvPV_const(bufsv, blen); } else { 312 if (DO_UTF8(bufsv)) { /* Not modifying source SV, so making a temporary copy. */ ###### bufsv = sv_2mortal(newSVsv(bufsv)); ###### sv_utf8_downgrade(bufsv, FALSE); } 312 buffer = SvPV_const(bufsv, blen); } 320 if (PL_op->op_type == OP_SYSWRITE) { 315 IV offset; 315 if (DO_UTF8(bufsv)) { /* length and offset are in chars */ 8 blen = sv_len_utf8(bufsv); } 315 if (MARK < SP) { 205 offset = SvIVx(*++MARK); 205 if (offset < 0) { 2 if (-offset > (IV)blen) 1 DIE(aTHX_ "Offset outside string"); 1 offset += blen; 203 } else if (offset >= (IV)blen && blen > 0) 1 DIE(aTHX_ "Offset outside string"); } else 110 offset = 0; 313 if (length > blen - offset) 2 length = blen - offset; 313 if (DO_UTF8(bufsv)) { 8 buffer = (const char*)utf8_hop((const U8 *)buffer, offset); 8 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer; } else { 305 buffer = buffer+offset; } #ifdef PERL_SOCK_SYSWRITE_IS_SEND if (IoTYPE(io) == IoTYPE_SOCKET) { retval = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, length, 0); } else #endif { /* See the note at doio.c:do_print about filesize limits. --jhi */ 313 retval = PerlLIO_write(PerlIO_fileno(IoIFP(io)), buffer, length); } } #ifdef HAS_SOCKET 5 else if (SP > MARK) { 2 STRLEN mlen; 2 char * const sockbuf = SvPVx(*++MARK, mlen); /* length is really flags */ 2 retval = PerlSock_sendto(PerlIO_fileno(IoIFP(io)), buffer, blen, length, (struct sockaddr *)sockbuf, mlen); } else /* length is really flags */ 3 retval = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, blen, length); #else else DIE(aTHX_ PL_no_sock_func, "send"); #endif 318 if (retval < 0) 1 goto say_undef; 317 SP = ORIGMARK; 317 if (DO_UTF8(bufsv)) 8 retval = utf8_length((U8*)buffer, (U8*)buffer + retval); #if Size_t_size > IVSIZE PUSHn(retval); #else 317 PUSHi(retval); #endif 317 RETURN; say_undef: 10 SP = ORIGMARK; 10 RETPUSHUNDEF; } PP(pp_recv) 4 { 4 return pp_sysread(); } PP(pp_eof) 1535 { 1535 dVAR; dSP; 1535 GV *gv; 1535 IO *io; 1535 MAGIC *mg; 1535 if (MAXARG == 0) { 812 if (PL_op->op_flags & OPf_SPECIAL) { /* eof() */ 9 IO *io; 9 gv = PL_last_in_gv = GvEGV(PL_argvgv); 9 io = GvIO(gv); 9 if (io && !IoIFP(io)) { 3 if ((IoFLAGS(io) & IOf_START) && av_len(GvAVn(gv)) < 0) { 2 IoLINES(io) = 0; 2 IoFLAGS(io) &= ~IOf_START; 2 do_open(gv, (char *)"-", 1, FALSE, O_RDONLY, 0, Nullfp); 2 sv_setpvn(GvSV(gv), "-", 1); 2 SvSETMAGIC(GvSV(gv)); } 1 else if (!nextargv(gv)) ###### RETPUSHYES; } } else 803 gv = PL_last_in_gv; /* eof */ } else 723 gv = PL_last_in_gv = (GV*)POPs; /* eof(FH) */ 1535 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 5 PUSHMARK(SP); 5 XPUSHs(SvTIED_obj((SV*)io, mg)); 5 PUTBACK; 5 ENTER; 5 call_method("EOF", G_SCALAR); 5 LEAVE; 5 SPAGAIN; 5 RETURN; } 1530 PUSHs(boolSV(!gv || do_eof(gv))); 1530 RETURN; } PP(pp_tell) 5579 { 5579 dVAR; dSP; dTARGET; 5579 GV *gv; 5579 IO *io; 5579 MAGIC *mg; 5579 if (MAXARG == 0) 9 gv = PL_last_in_gv; else 5570 gv = PL_last_in_gv = (GV*)POPs; 5579 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 187 PUSHMARK(SP); 187 XPUSHs(SvTIED_obj((SV*)io, mg)); 187 PUTBACK; 187 ENTER; 187 call_method("TELL", G_SCALAR); 1 LEAVE; 1 SPAGAIN; 1 RETURN; } #if LSEEKSIZE > IVSIZE 5392 PUSHn( do_tell(gv) ); #else PUSHi( do_tell(gv) ); #endif 5392 RETURN; } PP(pp_seek) 29042 { 29042 return pp_sysseek(); } PP(pp_sysseek) 29085 { 29085 dVAR; dSP; 29085 GV *gv; 29085 IO *io; 29085 const int whence = POPi; #if LSEEKSIZE > IVSIZE 29085 Off_t offset = (Off_t)SvNVx(POPs); #else Off_t offset = (Off_t)SvIVx(POPs); #endif 29085 MAGIC *mg; 29085 gv = PL_last_in_gv = (GV*)POPs; 29085 if (gv && (io = GvIO(gv)) && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { 1 PUSHMARK(SP); 1 XPUSHs(SvTIED_obj((SV*)io, mg)); #if LSEEKSIZE > IVSIZE 1 XPUSHs(sv_2mortal(newSVnv((NV) offset))); #else XPUSHs(sv_2mortal(newSViv(offset))); #endif 1 XPUSHs(sv_2mortal(newSViv(whence))); 1 PUTBACK; 1 ENTER; 1 call_method("SEEK", G_SCALAR); 1 LEAVE; 1 SPAGAIN; 1 RETURN; } 29084 if (PL_op->op_type == OP_SEEK) 29041 PUSHs(boolSV(do_seek(gv, offset, whence))); else { 43 Off_t sought = do_sysseek(gv, offset, whence); 43 if (sought < 0) 6 PUSHs(&PL_sv_undef); else { 37 SV* sv = sought ? #if LSEEKSIZE > IVSIZE newSVnv((NV)sought) #else newSViv(sought) #endif 37 : newSVpvn(zero_but_true, ZBTLEN); 37 PUSHs(sv_2mortal(sv)); } } 29084 RETURN; } PP(pp_truncate) 2242 { 2242 dSP; /* There seems to be no consensus on the length type of truncate() * and ftruncate(), both off_t and size_t have supporters. In * general one would think that when using large files, off_t is * at least as wide as size_t, so using an off_t should be okay. */ /* XXX Configure probe for the length type of *truncate() needed XXX */ 2242 Off_t len; #if Off_t_size > IVSIZE 2242 len = (Off_t)POPn; #else len = (Off_t)POPi; #endif /* Checking for length < 0 is problematic as the type might or * might not be signed: if it is not, clever compilers will moan. */ /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */ 2242 SETERRNO(0,0); { 2242 int result = 1; 2242 GV *tmpgv; 2242 IO *io; 2242 if (PL_op->op_flags & OPf_SPECIAL) { 3 tmpgv = gv_fetchsv(POPs, FALSE, SVt_PVIO); do_ftruncate_gv: 2238 if (!GvIO(tmpgv)) ###### result = 0; else { 2238 PerlIO *fp; 2238 io = GvIOp(tmpgv); do_ftruncate_io: 2239 TAINT_PROPER("truncate"); 2239 if (!(fp = IoIFP(io))) { ###### result = 0; } else { 2239 PerlIO_flush(fp); #ifdef HAS_TRUNCATE 2239 if (ftruncate(PerlIO_fileno(fp), len) < 0) #else if (my_chsize(PerlIO_fileno(fp), len) < 0) #endif ###### result = 0; } } } else { 2239 SV *sv = POPs; 2239 const char *name; 2239 if (SvTYPE(sv) == SVt_PVGV) { ###### tmpgv = (GV*)sv; /* *main::FRED for example */ ###### goto do_ftruncate_gv; } 2239 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) { 2235 tmpgv = (GV*) SvRV(sv); /* \*main::FRED for example */ 2235 goto do_ftruncate_gv; } 4 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) { 1 io = (IO*) SvRV(sv); /* *main::FRED{IO} for example */ 1 goto do_ftruncate_io; } 3 name = SvPV_nolen_const(sv); 3 TAINT_PROPER("truncate"); #ifdef HAS_TRUNCATE 2 if (truncate(name, len) < 0) ###### result = 0; #else { int tmpfd; if ((tmpfd = PerlLIO_open(name, O_RDWR)) < 0) result = 0; else { if (my_chsize(tmpfd, len) < 0) result = 0; PerlLIO_close(tmpfd); } } #endif } 2241 if (result) 2241 RETPUSHYES; ###### if (!errno) ###### SETERRNO(EBADF,RMS_IFI); ###### RETPUSHUNDEF; } } PP(pp_fcntl) 71 { 71 return pp_ioctl(); } PP(pp_ioctl) 72 { 72 dSP; dTARGET; 72 SV *argsv = POPs; 72 const unsigned int func = POPu; 72 const int optype = PL_op->op_type; 72 char *s; 72 IV retval; 72 GV *gv = (GV*)POPs; 72 IO *io = gv ? GvIOn(gv) : 0; 72 if (!io || !argsv || !IoIFP(io)) { ###### if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) ###### report_evil_fh(gv, io, PL_op->op_type); ###### SETERRNO(EBADF,RMS_IFI); /* well, sort of... */ ###### RETPUSHUNDEF; } 72 if (SvPOK(argsv) || !SvNIOK(argsv)) { 2 STRLEN len; 2 STRLEN need; 2 s = SvPV_force(argsv, len); 2 need = IOCPARM_LEN(func); 2 if (len < need) { ###### s = Sv_Grow(argsv, need + 1); ###### SvCUR_set(argsv, need); } 2 s[SvCUR(argsv)] = 17; /* a little sanity check here */ } else { 70 retval = SvIV(argsv); 70 s = INT2PTR(char*,retval); /* ouch */ } 72 TAINT_PROPER(optype == OP_IOCTL ? "ioctl" : "fcntl"); 70 if (optype == OP_IOCTL) #ifdef HAS_IOCTL ###### retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s); #else DIE(aTHX_ "ioctl is not implemented"); #endif else #ifndef HAS_FCNTL DIE(aTHX_ "fcntl is not implemented"); #else #if defined(OS2) && defined(__EMX__) retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s); #else 70 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s); #endif #endif #if defined(HAS_IOCTL) || defined(HAS_FCNTL) 70 if (SvPOK(argsv)) { ###### if (s[SvCUR(argsv)] != 17) ###### DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument", OP_NAME(PL_op)); ###### s[SvCUR(argsv)] = 0; /* put our null back */ ###### SvSETMAGIC(argsv); /* Assume it has changed */ } 70 if (retval == -1) ###### RETPUSHUNDEF; 70 if (retval != 0) { 35 PUSHi(retval); } else { 35 PUSHp(zero_but_true, ZBTLEN); } #endif 70 RETURN; } PP(pp_flock) 14 { #ifdef FLOCK 14 dSP; dTARGET; 14 I32 value; 14 int argtype; 14 GV *gv; 14 IO *io = NULL; 14 PerlIO *fp; 14 argtype = POPi; 14 if (MAXARG == 0) ###### gv = PL_last_in_gv; else 14 gv = (GV*)POPs; 14 if (gv && (io = GvIO(gv))) 11 fp = IoIFP(io); else { 3 fp = Nullfp; 3 io = NULL; } 14 if (fp) { 5 (void)PerlIO_flush(fp); 5 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0); } else { 9 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) 4 report_evil_fh(gv, io, PL_op->op_type); 9 value = 0; 9 SETERRNO(EBADF,RMS_IFI); } 14 PUSHi(value); 14 RETURN; #else DIE(aTHX_ PL_no_func, "flock()"); #endif } /* Sockets. */ PP(pp_socket) 50 { #ifdef HAS_SOCKET 50 dSP; 50 GV *gv; 50 register IO *io; 50 int protocol = POPi; 50 int type = POPi; 50 int domain = POPi; 50 int fd; 50 gv = (GV*)POPs; 50 io = gv ? GvIOn(gv) : NULL; 50 if (!gv || !io) { ###### if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) ###### report_evil_fh(gv, io, PL_op->op_type); ###### if (IoIFP(io)) ###### do_close(gv, FALSE); ###### SETERRNO(EBADF,LIB_INVARG); ###### RETPUSHUNDEF; } 50 if (IoIFP(io)) 3 do_close(gv, FALSE); 50 TAINT_PROPER("socket"); 50 fd = PerlSock_socket(domain, type, protocol); 50 if (fd < 0) 1 RETPUSHUNDEF; 49 IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */ 49 IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE); 49 IoTYPE(io) = IoTYPE_SOCKET; 49 if (!IoIFP(io) || !IoOFP(io)) { ###### if (IoIFP(io)) PerlIO_close(IoIFP(io)); ###### if (IoOFP(io)) PerlIO_close(IoOFP(io)); ###### if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd); ###### RETPUSHUNDEF; } #if defined(HAS_FCNTL) && defined(F_SETFD) 49 fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */ #endif #ifdef EPOC setbuf( IoIFP(io), NULL); /* EPOC gets confused about sockets */ #endif 49 RETPUSHYES; #else DIE(aTHX_ PL_no_sock_func, "socket"); #endif } PP(pp_sockpair) 4 { #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET)) 4 dSP; 4 GV *gv1; 4 GV *gv2; 4 register IO *io1; 4 register IO *io2; 4 int protocol = POPi; 4 int type = POPi; 4 int domain = POPi; 4 int fd[2]; 4 gv2 = (GV*)POPs; 4 gv1 = (GV*)POPs; 4 io1 = gv1 ? GvIOn(gv1) : NULL; 4 io2 = gv2 ? GvIOn(gv2) : NULL; 4 if (!gv1 || !gv2 || !io1 || !io2) { ###### if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) { ###### if (!gv1 || !io1) ###### report_evil_fh(gv1, io1, PL_op->op_type); ###### if (!gv2 || !io2) ###### report_evil_fh(gv1, io2, PL_op->op_type); } ###### if (IoIFP(io1)) ###### do_close(gv1, FALSE); ###### if (IoIFP(io2)) ###### do_close(gv2, FALSE); ###### RETPUSHUNDEF; } 4 if (IoIFP(io1)) ###### do_close(gv1, FALSE); 4 if (IoIFP(io2)) ###### do_close(gv2, FALSE); 4 TAINT_PROPER("socketpair"); 4 if (PerlSock_socketpair(domain, type, protocol, fd) < 0) 2 RETPUSHUNDEF; 2 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE); 2 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE); 2 IoTYPE(io1) = IoTYPE_SOCKET; 2 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE); 2 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE); 2 IoTYPE(io2) = IoTYPE_SOCKET; 2 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) { ###### if (IoIFP(io1)) PerlIO_close(IoIFP(io1)); ###### if (IoOFP(io1)) PerlIO_close(IoOFP(io1)); ###### if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]); ###### if (IoIFP(io2)) PerlIO_close(IoIFP(io2)); ###### if (IoOFP(io2)) PerlIO_close(IoOFP(io2)); ###### if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]); ###### RETPUSHUNDEF; } #if defined(HAS_FCNTL) && defined(F_SETFD) 2 fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd); /* ensure close-on-exec */ 2 fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd); /* ensure close-on-exec */ #endif 2 RETPUSHYES; #else DIE(aTHX_ PL_no_sock_func, "socketpair"); #endif } PP(pp_bind) 14 { #ifdef HAS_SOCKET 14 dSP; #ifdef MPE /* Requires PRIV mode to bind() to ports < 1024 */ extern void GETPRIVMODE(); extern void GETUSERMODE(); #endif 14 SV *addrsv = POPs; /* OK, so on what platform does bind modify addr? */ 14 const char *addr; 14 GV *gv = (GV*)POPs; 14 register IO *io = GvIOn(gv); 14 STRLEN len; 14 int bind_ok = 0; #ifdef MPE int mpeprivmode = 0; #endif 14 if (!io || !IoIFP(io)) 4 goto nuts; 10 addr = SvPV_const(addrsv, len); 10 TAINT_PROPER("bind"); #ifdef MPE /* Deal with MPE bind() peculiarities */ if (((struct sockaddr *)addr)->sa_family == AF_INET) { /* The address *MUST* stupidly be zero. */ ((struct sockaddr_in *)addr)->sin_addr.s_addr = INADDR_ANY; /* PRIV mode is required to bind() to ports < 1024. */ if (((struct sockaddr_in *)addr)->sin_port < 1024 && ((struct sockaddr_in *)addr)->sin_port > 0) { GETPRIVMODE(); /* If this fails, we are aborted by MPE/iX. */ mpeprivmode = 1; } } #endif /* MPE */ 10 if (PerlSock_bind(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len) >= 0) 10 bind_ok = 1; #ifdef MPE /* Switch back to USER mode */ if (mpeprivmode) GETUSERMODE(); #endif /* MPE */ 10 if (bind_ok) 10 RETPUSHYES; else ###### RETPUSHUNDEF; nuts: 4 if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); 4 SETERRNO(EBADF,SS_IVCHAN); 4 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "bind"); #endif } PP(pp_connect) 40 { #ifdef HAS_SOCKET 40 dSP; 40 SV *addrsv = POPs; 40 const char *addr; 40 GV *gv = (GV*)POPs; 40 register IO *io = GvIOn(gv); 40 STRLEN len; 40 if (!io || !IoIFP(io)) 4 goto nuts; 36 addr = SvPV_const(addrsv, len); 36 TAINT_PROPER("connect"); 36 if (PerlSock_connect(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len) >= 0) 12 RETPUSHYES; else 24 RETPUSHUNDEF; nuts: 4 if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); 4 SETERRNO(EBADF,SS_IVCHAN); 4 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "connect"); #endif } PP(pp_listen) 11 { #ifdef HAS_SOCKET 11 dSP; 11 int backlog = POPi; 11 GV *gv = (GV*)POPs; 11 register IO *io = gv ? GvIOn(gv) : NULL; 11 if (!gv || !io || !IoIFP(io)) 4 goto nuts; 7 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0) 7 RETPUSHYES; else ###### RETPUSHUNDEF; nuts: 4 if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); 4 SETERRNO(EBADF,SS_IVCHAN); 4 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "listen"); #endif } PP(pp_accept) 13 { #ifdef HAS_SOCKET 13 dSP; dTARGET; 13 GV *ngv; 13 GV *ggv; 13 register IO *nstio; 13 register IO *gstio; 13 char namebuf[MAXPATHLEN]; #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__) Sock_size_t len = sizeof (struct sockaddr_in); #else 13 Sock_size_t len = sizeof namebuf; #endif 13 int fd; 13 ggv = (GV*)POPs; 13 ngv = (GV*)POPs; 13 if (!ngv) ###### goto badexit; 13 if (!ggv) ###### goto nuts; 13 gstio = GvIO(ggv); 13 if (!gstio || !IoIFP(gstio)) 3 goto nuts; 9 nstio = GvIOn(ngv); 9 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len); 9 if (fd < 0) ###### goto badexit; 9 if (IoIFP(nstio)) ###### do_close(ngv, FALSE); 9 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); 9 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE); 9 IoTYPE(nstio) = IoTYPE_SOCKET; 9 if (!IoIFP(nstio) || !IoOFP(nstio)) { ###### if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio)); ###### if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio)); ###### if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd); ###### goto badexit; } #if defined(HAS_FCNTL) && defined(F_SETFD) 9 fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */ #endif #ifdef EPOC len = sizeof (struct sockaddr_in); /* EPOC somehow truncates info */ setbuf( IoIFP(nstio), NULL); /* EPOC gets confused about sockets */ #endif #ifdef __SCO_VERSION__ len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */ #endif 9 PUSHp(namebuf, len); 9 RETURN; nuts: 4 if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(ggv, ggv ? GvIO(ggv) : 0, PL_op->op_type); 4 SETERRNO(EBADF,SS_IVCHAN); badexit: 4 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "accept"); #endif } PP(pp_shutdown) 6 { #ifdef HAS_SOCKET 6 dSP; dTARGET; 6 int how = POPi; 6 GV *gv = (GV*)POPs; 6 register IO *io = GvIOn(gv); 6 if (!io || !IoIFP(io)) 4 goto nuts; 2 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 ); 2 RETURN; nuts: 4 if (ckWARN(WARN_CLOSED)) 2 report_evil_fh(gv, io, PL_op->op_type); 4 SETERRNO(EBADF,SS_IVCHAN); 4 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "shutdown"); #endif } PP(pp_gsockopt) 4 { #ifdef HAS_SOCKET 4 return pp_ssockopt(); #else DIE(aTHX_ PL_no_sock_func, "getsockopt"); #endif } PP(pp_ssockopt) 8 { #ifdef HAS_SOCKET 8 dSP; 8 int optype = PL_op->op_type; 8 SV *sv; 8 int fd; 8 unsigned int optname; 8 unsigned int lvl; 8 GV *gv; 8 register IO *io; 8 Sock_size_t len; 8 if (optype == OP_GSOCKOPT) 4 sv = sv_2mortal(NEWSV(22, 257)); else 4 sv = POPs; 8 optname = (unsigned int) POPi; 8 lvl = (unsigned int) POPi; 8 gv = (GV*)POPs; 8 io = GvIOn(gv); 8 if (!io || !IoIFP(io)) 8 goto nuts; ###### fd = PerlIO_fileno(IoIFP(io)); ###### switch (optype) { case OP_GSOCKOPT: ###### SvGROW(sv, 257); ###### (void)SvPOK_only(sv); ###### SvCUR_set(sv,256); ###### *SvEND(sv) ='\0'; ###### len = SvCUR(sv); ###### if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0) ###### goto nuts2; ###### SvCUR_set(sv, len); ###### *SvEND(sv) ='\0'; ###### PUSHs(sv); ###### break; case OP_SSOCKOPT: { ###### const char *buf; ###### int aint; ###### if (SvPOKp(sv)) { ###### STRLEN l; ###### buf = SvPV_const(sv, l); ###### len = l; } else { ###### aint = (int)SvIV(sv); ###### buf = (const char*)&aint; ###### len = sizeof(int); } ###### if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0) ###### goto nuts2; ###### PUSHs(&PL_sv_yes); } break; } ###### RETURN; nuts: 8 if (ckWARN(WARN_CLOSED)) 4 report_evil_fh(gv, io, optype); 8 SETERRNO(EBADF,SS_IVCHAN); nuts2: 8 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "setsockopt"); #endif } PP(pp_getsockname) 14 { #ifdef HAS_SOCKET 14 return pp_getpeername(); #else DIE(aTHX_ PL_no_sock_func, "getsockname"); #endif } PP(pp_getpeername) 42 { #ifdef HAS_SOCKET 42 dSP; 42 int optype = PL_op->op_type; 42 SV *sv; 42 int fd; 42 GV *gv = (GV*)POPs; 42 register IO *io = GvIOn(gv); 42 Sock_size_t len; 42 if (!io || !IoIFP(io)) 8 goto nuts; 34 sv = sv_2mortal(NEWSV(22, 257)); 34 (void)SvPOK_only(sv); 34 len = 256; 34 SvCUR_set(sv, len); 34 *SvEND(sv) ='\0'; 34 fd = PerlIO_fileno(IoIFP(io)); 34 switch (optype) { case OP_GETSOCKNAME: 10 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0) ###### goto nuts2; 24 break; case OP_GETPEERNAME: 24 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0) 15 goto nuts2; #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS) { 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"; /* If the call succeeded, make sure we don't have a zeroed port/addr */ if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET && !memcmp((char *)SvPVX_const(sv) + sizeof(u_short), nowhere, sizeof(u_short) + sizeof(struct in_addr))) { goto nuts2; } } #endif 19 break; } #ifdef BOGUS_GETNAME_RETURN /* Interactive Unix, getpeername() and getsockname() does not return valid namelen */ if (len == BOGUS_GETNAME_RETURN) len = sizeof(struct sockaddr); #endif 19 SvCUR_set(sv, len); 19 *SvEND(sv) ='\0'; 19 PUSHs(sv); 19 RETURN; nuts: 8 if (ckWARN(WARN_CLOSED)) 4 report_evil_fh(gv, io, optype); 8 SETERRNO(EBADF,SS_IVCHAN); nuts2: 23 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "getpeername"); #endif } /* Stat calls. */ PP(pp_lstat) 9689 { 9689 return pp_stat(); } PP(pp_stat) 11125 { 11125 dSP; 11125 GV *gv; 11125 I32 gimme; 11125 I32 max = 13; 11125 if (PL_op->op_flags & OPf_REF) { 17 gv = cGVOP_gv; 17 if (PL_op->op_type == OP_LSTAT) { 5 if (gv != PL_defgv) { 2 if (ckWARN(WARN_IO)) 1 Perl_warner(aTHX_ packWARN(WARN_IO), "lstat() on filehandle %s", GvENAME(gv)); 3 } else if (PL_laststype != OP_LSTAT) 2 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat"); } do_fstat: 57 if (gv != PL_defgv) { 53 PL_laststype = OP_STAT; 53 PL_statgv = gv; 53 sv_setpvn(PL_statname, "", 0); 53 PL_laststatval = (GvIO(gv) && IoIFP(GvIOp(gv)) ? PerlLIO_fstat(PerlIO_fileno(IoIFP(GvIOn(gv))), &PL_statcache) : -1); } 57 if (PL_laststatval < 0) { 7 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) 3 report_evil_fh(gv, GvIO(gv), PL_op->op_type); 7 max = 0; } } else { 11108 SV* sv = POPs; 11108 if (SvTYPE(sv) == SVt_PVGV) { 6 gv = (GV*)sv; 6 goto do_fstat; } 11102 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) { 36 gv = (GV*)SvRV(sv); 36 if (PL_op->op_type == OP_LSTAT && ckWARN(WARN_IO)) 1 Perl_warner(aTHX_ packWARN(WARN_IO), "lstat() on filehandle %s", GvENAME(gv)); 1 goto do_fstat; } 11066 sv_setpv(PL_statname, SvPV_nolen_const(sv)); 11066 PL_statgv = Nullgv; 11066 PL_laststype = PL_op->op_type; 11066 if (PL_op->op_type == OP_LSTAT) 9682 PL_laststatval = PerlLIO_lstat(SvPV_nolen_const(PL_statname), &PL_statcache); else 1384 PL_laststatval = PerlLIO_stat(SvPV_nolen_const(PL_statname), &PL_statcache); 11066 if (PL_laststatval < 0) { 211 if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname), '\n')) 3 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat"); 211 max = 0; } } 11123 gimme = GIMME_V; 11123 if (gimme != G_ARRAY) { 82 if (gimme != G_VOID) 1 XPUSHs(boolSV(max)); 82 RETURN; } 11041 if (max) { 10842 EXTEND(SP, max); 10842 EXTEND_MORTAL(max); 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_dev))); 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_ino))); 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_mode))); 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_nlink))); #if Uid_t_size > IVSIZE PUSHs(sv_2mortal(newSVnv(PL_statcache.st_uid))); #else # if Uid_t_sign <= 0 PUSHs(sv_2mortal(newSViv(PL_statcache.st_uid))); # else 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_uid))); # endif #endif #if Gid_t_size > IVSIZE PUSHs(sv_2mortal(newSVnv(PL_statcache.st_gid))); #else # if Gid_t_sign <= 0 PUSHs(sv_2mortal(newSViv(PL_statcache.st_gid))); # else 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_gid))); # endif #endif #ifdef USE_STAT_RDEV 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_rdev))); #else PUSHs(sv_2mortal(newSVpvn("", 0))); #endif #if Off_t_size > IVSIZE 10842 PUSHs(sv_2mortal(newSVnv((NV)PL_statcache.st_size))); #else PUSHs(sv_2mortal(newSViv(PL_statcache.st_size))); #endif #ifdef BIG_TIME PUSHs(sv_2mortal(newSVnv(PL_statcache.st_atime))); PUSHs(sv_2mortal(newSVnv(PL_statcache.st_mtime))); PUSHs(sv_2mortal(newSVnv(PL_statcache.st_ctime))); #else 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_atime))); 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_mtime))); 10842 PUSHs(sv_2mortal(newSViv(PL_statcache.st_ctime))); #endif #ifdef USE_STAT_BLOCKS 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_blksize))); 10842 PUSHs(sv_2mortal(newSVuv(PL_statcache.st_blocks))); #else PUSHs(sv_2mortal(newSVpvn("", 0))); PUSHs(sv_2mortal(newSVpvn("", 0))); #endif } 11041 RETURN; } /* This macro is used by the stacked filetest operators : * if the previous filetest failed, short-circuit and pass its value. * Else, discard it from the stack and continue. --rgs */ #define STACKED_FTEST_CHECK if (PL_op->op_private & OPpFT_STACKED) { \ if (TOPs == &PL_sv_no || TOPs == &PL_sv_undef) { RETURN; } \ else { (void)POPs; PUTBACK; } \ } PP(pp_ftrread) 1 { 1 I32 result; 1 dSP; 1 STACKED_FTEST_CHECK; #if defined(HAS_ACCESS) && defined(R_OK) 1 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = access(POPpx, R_OK); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 1 result = my_stat(); #else result = my_stat(); #endif 1 SPAGAIN; 1 if (result < 0) 1 RETPUSHUNDEF; ###### if (cando(S_IRUSR, 0, &PL_statcache)) ###### RETPUSHYES; ###### RETPUSHNO; } PP(pp_ftrwrite) 1 { 1 I32 result; 1 dSP; 1 STACKED_FTEST_CHECK; #if defined(HAS_ACCESS) && defined(W_OK) 1 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = access(POPpx, W_OK); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 1 result = my_stat(); #else result = my_stat(); #endif 1 SPAGAIN; 1 if (result < 0) 1 RETPUSHUNDEF; ###### if (cando(S_IWUSR, 0, &PL_statcache)) ###### RETPUSHYES; ###### RETPUSHNO; } PP(pp_ftrexec) 1 { 1 I32 result; 1 dSP; 1 STACKED_FTEST_CHECK; #if defined(HAS_ACCESS) && defined(X_OK) 1 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = access(POPpx, X_OK); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 1 result = my_stat(); #else result = my_stat(); #endif 1 SPAGAIN; 1 if (result < 0) 1 RETPUSHUNDEF; ###### if (cando(S_IXUSR, 0, &PL_statcache)) ###### RETPUSHYES; ###### RETPUSHNO; } PP(pp_fteread) 1618 { 1618 I32 result; 1618 dSP; 1618 STACKED_FTEST_CHECK; #ifdef PERL_EFF_ACCESS_R_OK 1618 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = PERL_EFF_ACCESS_R_OK(POPpx); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 1618 result = my_stat(); #else result = my_stat(); #endif 1618 SPAGAIN; 1618 if (result < 0) 27 RETPUSHUNDEF; 1591 if (cando(S_IRUSR, 1, &PL_statcache)) 1590 RETPUSHYES; 1 RETPUSHNO; } PP(pp_ftewrite) 150 { 150 I32 result; 150 dSP; 150 STACKED_FTEST_CHECK; #ifdef PERL_EFF_ACCESS_W_OK 150 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = PERL_EFF_ACCESS_W_OK(POPpx); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 150 result = my_stat(); #else result = my_stat(); #endif 150 SPAGAIN; 150 if (result < 0) 53 RETPUSHUNDEF; 97 if (cando(S_IWUSR, 1, &PL_statcache)) 92 RETPUSHYES; 5 RETPUSHNO; } PP(pp_fteexec) 3758 { 3758 I32 result; 3758 dSP; 3758 STACKED_FTEST_CHECK; #ifdef PERL_EFF_ACCESS_X_OK 3758 if ((PL_op->op_private & OPpFT_ACCESS) && SvPOK(TOPs)) { ###### result = PERL_EFF_ACCESS_X_OK(POPpx); ###### if (result == 0) ###### RETPUSHYES; ###### if (result < 0) ###### RETPUSHUNDEF; ###### RETPUSHNO; } else 3758 result = my_stat(); #else result = my_stat(); #endif 3757 SPAGAIN; 3757 if (result < 0) 2946 RETPUSHUNDEF; 811 if (cando(S_IXUSR, 1, &PL_statcache)) 805 RETPUSHYES; 6 RETPUSHNO; } PP(pp_ftis) 3450 { 3450 I32 result; 3450 dSP; 3450 STACKED_FTEST_CHECK; 3448 result = my_stat(); 3448 SPAGAIN; 3448 if (result < 0) 1126 RETPUSHUNDEF; 2322 RETPUSHYES; } PP(pp_fteowned) 2 { 2 return pp_ftrowned(); } PP(pp_ftrowned) 3 { 3 I32 result; 3 dSP; 3 STACKED_FTEST_CHECK; 3 result = my_stat(); 3 SPAGAIN; 3 if (result < 0) 2 RETPUSHUNDEF; 1 if (PL_statcache.st_uid == (PL_op->op_type == OP_FTEOWNED ? PL_euid : PL_uid) ) 1 RETPUSHYES; ###### RETPUSHNO; } PP(pp_ftzero) 9 { 9 I32 result; 9 dSP; 9 STACKED_FTEST_CHECK; 9 result = my_stat(); 9 SPAGAIN; 9 if (result < 0) 1 RETPUSHUNDEF; 8 if (PL_statcache.st_size == 0) 3 RETPUSHYES; 5 RETPUSHNO; } PP(pp_ftsize) 4920 { 4920 I32 result; 4920 dSP; dTARGET; 4920 STACKED_FTEST_CHECK; 4920 result = my_stat(); 4920 SPAGAIN; 4920 if (result < 0) 62 RETPUSHUNDEF; #if Off_t_size > IVSIZE 4858 PUSHn(PL_statcache.st_size); #else PUSHi(PL_statcache.st_size); #endif 4858 RETURN; } PP(pp_ftmtime) 51 { 51 I32 result; 51 dSP; dTARGET; 51 STACKED_FTEST_CHECK; 51 result = my_stat(); 51 SPAGAIN; 51 if (result < 0) 1 RETPUSHUNDEF; 50 PUSHn( (((NV)PL_basetime - PL_statcache.st_mtime)) / 86400.0 ); 50 RETURN; } PP(pp_ftatime) 3 { 3 I32 result; 3 dSP; dTARGET; 3 STACKED_FTEST_CHECK; 3 result = my_stat(); 3 SPAGAIN; 3 if (result < 0) 1 RETPUSHUNDEF; 2 PUSHn( (((NV)PL_basetime - PL_statcache.st_atime)) / 86400.0 ); 2 RETURN; } PP(pp_ftctime) 3 { 3 I32 result; 3 dSP; dTARGET; 3 STACKED_FTEST_CHECK; 3 result = my_stat(); 3 SPAGAIN; 3 if (result < 0) 1 RETPUSHUNDEF; 2 PUSHn( (((NV)PL_basetime - PL_statcache.st_ctime)) / 86400.0 ); 2 RETURN; } PP(pp_ftsock) 7570 { 7570 I32 result; 7570 dSP; 7570 STACKED_FTEST_CHECK; 7570 result = my_stat(); 7570 SPAGAIN; 7570 if (result < 0) 1 RETPUSHUNDEF; 7569 if (S_ISSOCK(PL_statcache.st_mode)) 3 RETPUSHYES; 7566 RETPUSHNO; } PP(pp_ftchr) 7574 { 7574 I32 result; 7574 dSP; 7574 STACKED_FTEST_CHECK; 7574 result = my_stat(); 7574 SPAGAIN; 7574 if (result < 0) 1 RETPUSHUNDEF; 7573 if (S_ISCHR(PL_statcache.st_mode)) 2121 RETPUSHYES; 5452 RETPUSHNO; } PP(pp_ftblk) 7569 { 7569 I32 result; 7569 dSP; 7569 STACKED_FTEST_CHECK; 7569 result = my_stat(); 7569 SPAGAIN; 7569 if (result < 0) 1 RETPUSHUNDEF; 7568 if (S_ISBLK(PL_statcache.st_mode)) 5422 RETPUSHYES; 2146 RETPUSHNO; } PP(pp_ftfile) 5184 { 5184 I32 result; 5184 dSP; 5184 STACKED_FTEST_CHECK; 5181 result = my_stat(); 5181 SPAGAIN; 5181 if (result < 0) 2346 RETPUSHUNDEF; 2835 if (S_ISREG(PL_statcache.st_mode)) 2667 RETPUSHYES; 168 RETPUSHNO; } PP(pp_ftdir) 15197 { 15197 I32 result; 15197 dSP; 15197 STACKED_FTEST_CHECK; 15197 result = my_stat(); 15197 SPAGAIN; 15197 if (result < 0) 2513 RETPUSHUNDEF; 12684 if (S_ISDIR(PL_statcache.st_mode)) 6932 RETPUSHYES; 5752 RETPUSHNO; } PP(pp_ftpipe) 1 { 1 I32 result; 1 dSP; 1 STACKED_FTEST_CHECK; 1 result = my_stat(); 1 SPAGAIN; 1 if (result < 0) 1 RETPUSHUNDEF; ###### if (S_ISFIFO(PL_statcache.st_mode)) ###### RETPUSHYES; ###### RETPUSHNO; } PP(pp_ftlink) 383 { 383 I32 result = my_lstat(); 381 dSP; 381 if (result < 0) 6 RETPUSHUNDEF; 375 if (S_ISLNK(PL_statcache.st_mode)) 21 RETPUSHYES; 354 RETPUSHNO; } PP(pp_ftsuid) 124 { 124 dSP; #ifdef S_ISUID 124 I32 result; 124 STACKED_FTEST_CHECK; 124 result = my_stat(); 124 SPAGAIN; 124 if (result < 0) 1 RETPUSHUNDEF; 123 if (PL_statcache.st_mode & S_ISUID) 1 RETPUSHYES; #endif 122 RETPUSHNO; } PP(pp_ftsgid) 1 { 1 dSP; #ifdef S_ISGID 1 I32 result; 1 STACKED_FTEST_CHECK; 1 result = my_stat(); 1 SPAGAIN; 1 if (result < 0) 1 RETPUSHUNDEF; ###### if (PL_statcache.st_mode & S_ISGID) ###### RETPUSHYES; #endif ###### RETPUSHNO; } PP(pp_ftsvtx) 2 { 2 dSP; #ifdef S_ISVTX 2 I32 result; 2 STACKED_FTEST_CHECK; 2 result = my_stat(); 2 SPAGAIN; 2 if (result < 0) ###### RETPUSHUNDEF; 2 if (PL_statcache.st_mode & S_ISVTX) 2 RETPUSHYES; #endif ###### RETPUSHNO; } PP(pp_fttty) 1079 { 1079 dSP; 1079 int fd; 1079 GV *gv; 1079 SV *tmpsv = Nullsv; 1079 STACKED_FTEST_CHECK; 1079 if (PL_op->op_flags & OPf_REF) 1078 gv = cGVOP_gv; 1 else if (isGV(TOPs)) ###### gv = (GV*)POPs; 1 else if (SvROK(TOPs) && isGV(SvRV(TOPs))) ###### gv = (GV*)SvRV(POPs); else 1 gv = gv_fetchsv(tmpsv = POPs, FALSE, SVt_PVIO); 1079 if (GvIO(gv) && IoIFP(GvIOp(gv))) 1075 fd = PerlIO_fileno(IoIFP(GvIOp(gv))); 4 else if (tmpsv && SvOK(tmpsv)) { ###### const char *tmps = SvPV_nolen_const(tmpsv); ###### if (isDIGIT(*tmps)) ###### fd = atoi(tmps); else ###### RETPUSHUNDEF; } else 4 RETPUSHUNDEF; 1075 if (PerlLIO_isatty(fd)) 1018 RETPUSHYES; 57 RETPUSHNO; } #if defined(atarist) /* this will work with atariST. Configure will make guesses for other systems. */ # define FILE_base(f) ((f)->_base) # define FILE_ptr(f) ((f)->_ptr) # define FILE_cnt(f) ((f)->_cnt) # define FILE_bufsiz(f) ((f)->_cnt + ((f)->_ptr - (f)->_base)) #endif PP(pp_fttext) 271 { 271 dSP; 271 I32 i; 271 I32 len; 271 I32 odd = 0; 271 STDCHAR tbuf[512]; 271 register STDCHAR *s; 271 register IO *io; 271 register SV *sv; 271 GV *gv; 271 PerlIO *fp; 271 STACKED_FTEST_CHECK; 271 if (PL_op->op_flags & OPf_REF) 20 gv = cGVOP_gv; 251 else if (isGV(TOPs)) ###### gv = (GV*)POPs; 251 else if (SvROK(TOPs) && isGV(SvRV(TOPs))) ###### gv = (GV*)SvRV(POPs); else 251 gv = Nullgv; 271 if (gv) { 20 EXTEND(SP, 1); 20 if (gv == PL_defgv) { 5 if (PL_statgv) ###### io = GvIO(PL_statgv); else { 5 sv = PL_statname; 5 goto really_filename; } } else { 15 PL_statgv = gv; 15 PL_laststatval = -1; 15 sv_setpvn(PL_statname, "", 0); 15 io = GvIO(PL_statgv); } 15 if (io && IoIFP(io)) { 11 if (! PerlIO_has_base(IoIFP(io))) ###### DIE(aTHX_ "-T and -B not implemented on filehandles"); 11 PL_laststatval = PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache); 11 if (PL_laststatval < 0) ###### RETPUSHUNDEF; 11 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */ ###### if (PL_op->op_type == OP_FTTEXT) ###### RETPUSHNO; else ###### RETPUSHYES; } 11 if (PerlIO_get_cnt(IoIFP(io)) <= 0) { 4 i = PerlIO_getc(IoIFP(io)); 4 if (i != EOF) 2 (void)PerlIO_ungetc(IoIFP(io),i); } 11 if (PerlIO_get_cnt(IoIFP(io)) <= 0) /* null file is anything */ 2 RETPUSHYES; 9 len = PerlIO_get_bufsiz(IoIFP(io)); 9 s = (STDCHAR *) PerlIO_get_base(IoIFP(io)); /* sfio can have large buffers - limit to 512 */ 9 if (len > 512) 9 len = 512; } else { 4 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) { 2 gv = cGVOP_gv; 2 report_evil_fh(gv, GvIO(gv), PL_op->op_type); } 4 SETERRNO(EBADF,RMS_IFI); 4 RETPUSHUNDEF; } } else { 251 sv = POPs; really_filename: 256 PL_statgv = Nullgv; 256 PL_laststype = OP_STAT; 256 sv_setpv(PL_statname, SvPV_nolen_const(sv)); 256 if (!(fp = PerlIO_open(SvPVX_const(PL_statname), "r"))) { 5 if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname), '\n')) 1 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open"); 5 RETPUSHUNDEF; } 251 PL_laststatval = PerlLIO_fstat(PerlIO_fileno(fp), &PL_statcache); 251 if (PL_laststatval < 0) { ###### (void)PerlIO_close(fp); ###### RETPUSHUNDEF; } 251 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, Nullch); 251 len = PerlIO_read(fp, tbuf, sizeof(tbuf)); 251 (void)PerlIO_close(fp); 251 if (len <= 0) { 2 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT) ###### RETPUSHNO; /* special case NFS directories */ 2 RETPUSHYES; /* null file is anything */ } 249 s = tbuf; } /* now scan s to look for textiness */ /* XXX ASCII dependent code */ #if defined(DOSISH) || defined(USEMYBINMODE) /* ignore trailing ^Z on short files */ if (len && len < sizeof(tbuf) && tbuf[len-1] == 26) --len; #endif 125972 for (i = 0; i < len; i++, s++) { 125718 if (!*s) { /* null never allowed in text */ 4 odd += len; 4 break; } #ifdef EBCDIC else if (!(isPRINT(*s) || isSPACE(*s))) odd++; #else 125714 else if (*s & 128) { #ifdef USE_LOCALE ###### if (IN_LOCALE_RUNTIME && isALPHA_LC(*s)) ###### continue; #endif /* utf8 characters don't count as odd */ ###### if (UTF8_IS_START(*s)) { ###### int ulen = UTF8SKIP(s); ###### if (ulen < len - i) { ###### int j; ###### for (j = 1; j < ulen; j++) { ###### if (!UTF8_IS_CONTINUATION(s[j])) ###### goto not_utf8; } ###### --ulen; /* loop does extra increment */ ###### s += ulen; ###### i += ulen; ###### continue; } } not_utf8: ###### odd++; } 125714 else if (*s < 32 && *s != '\n' && *s != '\r' && *s != '\b' && *s != '\t' && *s != '\f' && *s != 27) 6 odd++; #endif } 258 if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */ 7 RETPUSHNO; else 251 RETPUSHYES; } PP(pp_ftbinary) 12 { 12 return pp_fttext(); } /* File calls. */ PP(pp_chdir) 6705 { 6705 dSP; dTARGET; 6705 const char *tmps; 6705 SV **svp; 6705 if( MAXARG == 1 ) 6701 tmps = POPpconstx; else 4 tmps = 0; 6705 if( !tmps || !*tmps ) { 8 if ( (svp = hv_fetch(GvHVn(PL_envgv), "HOME", 4, FALSE)) || (svp = hv_fetch(GvHVn(PL_envgv), "LOGDIR", 6, FALSE)) #ifdef VMS || (svp = hv_fetch(GvHVn(PL_envgv), "SYS$LOGIN", 9, FALSE)) #endif ) { 6 if( MAXARG == 1 ) 4 deprecate("chdir('') or chdir(undef) as chdir()"); 6 tmps = SvPV_nolen_const(*svp); } else { 2 PUSHi(0); 2 TAINT_PROPER("chdir"); 2 RETURN; } } 6703 TAINT_PROPER("chdir"); 6699 PUSHi( PerlDir_chdir(tmps) >= 0 ); #ifdef VMS /* Clear the DEFAULT element of ENV so we'll get the new value * in the future. */ hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD); #endif 6699 RETURN; } PP(pp_chown) 2 { #ifdef HAS_CHOWN 2 dSP; dMARK; dTARGET; 2 I32 value = (I32)apply(PL_op->op_type, MARK, SP); 1 SP = MARK; 1 PUSHi(value); 1 RETURN; #else DIE(aTHX_ PL_no_func, "chown"); #endif } PP(pp_chroot) 1 { #ifdef HAS_CHROOT 1 dSP; dTARGET; 1 char *tmps = POPpx; 1 TAINT_PROPER("chroot"); ###### PUSHi( chroot(tmps) >= 0 ); ###### RETURN; #else DIE(aTHX_ PL_no_func, "chroot"); #endif } PP(pp_unlink) 1952 { 1952 dSP; dMARK; dTARGET; 1952 I32 value; 1952 value = (I32)apply(PL_op->op_type, MARK, SP); 1951 SP = MARK; 1951 PUSHi(value); 1951 RETURN; } PP(pp_chmod) 891 { 891 dSP; dMARK; dTARGET; 891 I32 value; 891 value = (I32)apply(PL_op->op_type, MARK, SP); 890 SP = MARK; 890 PUSHi(value); 890 RETURN; } PP(pp_utime) 233 { 233 dSP; dMARK; dTARGET; 233 I32 value; 233 value = (I32)apply(PL_op->op_type, MARK, SP); 232 SP = MARK; 232 PUSHi(value); 232 RETURN; } PP(pp_rename) 133 { 133 dSP; dTARGET; 133 int anum; 133 const char *tmps2 = POPpconstx; 133 const char *tmps = SvPV_nolen_const(TOPs); 133 TAINT_PROPER("rename"); #ifdef HAS_RENAME 132 anum = PerlLIO_rename(tmps, tmps2); #else if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) { if (same_dirent(tmps2, tmps)) /* can always rename to same name */ anum = 1; else { if (PL_euid || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode)) (void)UNLINK(tmps2); if (!(anum = link(tmps, tmps2))) anum = UNLINK(tmps); } } #endif 132 SETi( anum >= 0 ); 132 RETURN; } PP(pp_link) 24 { #ifdef HAS_LINK 24 dSP; dTARGET; 24 const char *tmps2 = POPpconstx; 24 const char *tmps = SvPV_nolen_const(TOPs); 24 TAINT_PROPER("link"); 23 SETi( PerlLIO_link(tmps, tmps2) >= 0 ); 23 RETURN; #else DIE(aTHX_ PL_no_func, "link"); #endif } PP(pp_symlink) 16 { #ifdef HAS_SYMLINK 16 dSP; dTARGET; 16 const char *tmps2 = POPpconstx; 16 const char *tmps = SvPV_nolen_const(TOPs); 16 TAINT_PROPER("symlink"); 15 SETi( symlink(tmps, tmps2) >= 0 ); 15 RETURN; #else DIE(aTHX_ PL_no_func, "symlink"); #endif } PP(pp_readlink) 26 { 26 dSP; #ifdef HAS_SYMLINK 26 dTARGET; 26 const char *tmps; 26 char buf[MAXPATHLEN]; 26 int len; #ifndef INCOMPLETE_TAINTS 26 TAINT; #endif 26 tmps = POPpconstx; 26 len = readlink(tmps, buf, sizeof(buf) - 1); 26 EXTEND(SP, 1); 26 if (len < 0) 5 RETPUSHUNDEF; 21 PUSHp(buf, len); 21 RETURN; #else EXTEND(SP, 1); RETSETUNDEF; /* just pretend it's a normal file */ #endif } #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) { char * const save_filename = filename; char *cmdline; char *s; PerlIO *myfp; int anum = 1; New(666, cmdline, strlen(cmd) + (strlen(filename) * 2) + 10, char); strcpy(cmdline, cmd); strcat(cmdline, " "); for (s = cmdline + strlen(cmdline); *filename; ) { *s++ = '\\'; *s++ = *filename++; } strcpy(s, " 2>&1"); myfp = PerlProc_popen(cmdline, "r"); Safefree(cmdline); if (myfp) { SV *tmpsv = sv_newmortal(); /* Need to save/restore 'PL_rs' ?? */ s = sv_gets(tmpsv, myfp, 0); (void)PerlProc_pclose(myfp); if (s != Nullch) { int e; for (e = 1; #ifdef HAS_SYS_ERRLIST e <= sys_nerr #endif ; e++) { /* you don't see this */ char *errmsg = #ifdef HAS_SYS_ERRLIST sys_errlist[e] #else strerror(e) #endif ; if (!errmsg) break; if (instr(s, errmsg)) { SETERRNO(e,0); return 0; } } SETERRNO(0,0); #ifndef EACCES #define EACCES EPERM #endif if (instr(s, "cannot make")) SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "existing file")) SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "ile exists")) SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "non-exist")) SETERRNO(ENOENT,RMS_FNF); else if (instr(s, "does not exist")) SETERRNO(ENOENT,RMS_FNF); else if (instr(s, "not empty")) SETERRNO(EBUSY,SS_DEVOFFLINE); else if (instr(s, "cannot access")) SETERRNO(EACCES,RMS_PRV); else SETERRNO(EPERM,RMS_PRV); return 0; } else { /* some mkdirs return no failure indication */ anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0); if (PL_op->op_type == OP_RMDIR) anum = !anum; if (anum) SETERRNO(0,0); else SETERRNO(EACCES,RMS_PRV); /* a guess */ } return anum; } else return 0; } #endif /* This macro removes trailing slashes from a directory name. * Different operating and file systems take differently to * trailing slashes. According to POSIX 1003.1 1996 Edition * any number of trailing slashes should be allowed. * Thusly we snip them away so that even non-conforming * systems are happy. * We should probably do this "filtering" for all * the functions that expect (potentially) directory names: * -d, chdir(), chmod(), chown(), chroot(), fcntl()?, * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */ #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \ if ((len) > 1 && (tmps)[(len)-1] == '/') { \ do { \ (len)--; \ } while ((len) > 1 && (tmps)[(len)-1] == '/'); \ (tmps) = savepvn((tmps), (len)); \ (copy) = TRUE; \ } PP(pp_mkdir) 743 { 743 dSP; dTARGET; 743 int mode; #ifndef HAS_MKDIR int oldumask; #endif 743 STRLEN len; 743 const char *tmps; 743 bool copy = FALSE; 743 if (MAXARG > 1) 725 mode = POPi; else 18 mode = 0777; 743 TRIMSLASHES(tmps,len,copy); 743 TAINT_PROPER("mkdir"); #ifdef HAS_MKDIR 742 SETi( PerlDir_mkdir(tmps, mode) >= 0 ); #else SETi( dooneliner("mkdir", tmps) ); oldumask = PerlLIO_umask(0); PerlLIO_umask(oldumask); PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777); #endif 742 if (copy) 1 Safefree(tmps); 742 RETURN; } PP(pp_rmdir) 356 { 356 dSP; dTARGET; 356 STRLEN len; 356 const char *tmps; 356 bool copy = FALSE; 356 TRIMSLASHES(tmps,len,copy); 356 TAINT_PROPER("rmdir"); #ifdef HAS_RMDIR 355 SETi( PerlDir_rmdir(tmps) >= 0 ); #else SETi( dooneliner("rmdir", tmps) ); #endif 355 if (copy) 1 Safefree(tmps); 355 RETURN; } /* Directory calls. */ PP(pp_open_dir) 6606 { #if defined(Direntry_t) && defined(HAS_READDIR) 6606 dSP; 6606 const char *dirname = POPpconstx; 6606 GV *gv = (GV*)POPs; 6606 register IO *io = GvIOn(gv); 6606 if (!io) ###### goto nope; 6606 if (IoDIRP(io)) 4 PerlDir_close(IoDIRP(io)); 6606 if (!(IoDIRP(io) = PerlDir_open(dirname))) 3 goto nope; 6603 RETPUSHYES; nope: 3 if (!errno) ###### SETERRNO(EBADF,RMS_DIR); 3 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "opendir"); #endif } PP(pp_readdir) 6789 { #if !defined(Direntry_t) || !defined(HAS_READDIR) DIE(aTHX_ PL_no_dir_func, "readdir"); #else #if !defined(I_DIRENT) && !defined(VMS) Direntry_t *readdir (DIR *); #endif 6789 dSP; 6789 SV *sv; 6789 const I32 gimme = GIMME; 6789 GV *gv = (GV *)POPs; 6789 register Direntry_t *dp; 6789 register IO *io = GvIOn(gv); 6789 if (!io || !IoDIRP(io)) 2 goto nope; 71030 do { 71030 dp = (Direntry_t *)PerlDir_read(IoDIRP(io)); 71030 if (!dp) 4456 break; #ifdef DIRNAMLEN sv = newSVpvn(dp->d_name, dp->d_namlen); #else 66574 sv = newSVpv(dp->d_name, 0); #endif #ifndef INCOMPLETE_TAINTS 66574 if (!(IoFLAGS(io) & IOf_UNTAINT)) 66574 SvTAINTED_on(sv); #endif 66574 XPUSHs(sv_2mortal(sv)); 66574 } while (gimme == G_ARRAY); 6787 if (!dp && gimme != G_ARRAY) 25 goto nope; 6762 RETURN; nope: 27 if (!errno) 13 SETERRNO(EBADF,RMS_ISI); 27 if (GIMME == G_ARRAY) ###### RETURN; else 27 RETPUSHUNDEF; #endif } PP(pp_telldir) 2 { #if defined(HAS_TELLDIR) || defined(telldir) 2 dVAR; dSP; dTARGET; /* XXX does _anyone_ need this? --AD 2/20/1998 */ /* XXX netbsd still seemed to. XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style. --JHI 1999-Feb-02 */ # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO) long telldir (DIR *); # endif 2 GV *gv = (GV*)POPs; 2 register IO *io = GvIOn(gv); 2 if (!io || !IoDIRP(io)) 2 goto nope; ###### PUSHi( PerlDir_tell(IoDIRP(io)) ); ###### RETURN; nope: 2 if (!errno) 1 SETERRNO(EBADF,RMS_ISI); 2 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "telldir"); #endif } PP(pp_seekdir) ###### { #if defined(HAS_SEEKDIR) || defined(seekdir) ###### dSP; ###### long along = POPl; ###### GV *gv = (GV*)POPs; ###### register IO *io = GvIOn(gv); ###### if (!io || !IoDIRP(io)) ###### goto nope; ###### (void)PerlDir_seek(IoDIRP(io), along); ###### RETPUSHYES; nope: ###### if (!errno) ###### SETERRNO(EBADF,RMS_ISI); ###### RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "seekdir"); #endif } PP(pp_rewinddir) 7 { #if defined(HAS_REWINDDIR) || defined(rewinddir) 7 dSP; 7 GV *gv = (GV*)POPs; 7 register IO *io = GvIOn(gv); 7 if (!io || !IoDIRP(io)) 2 goto nope; 5 (void)PerlDir_rewind(IoDIRP(io)); 5 RETPUSHYES; nope: 2 if (!errno) 2 SETERRNO(EBADF,RMS_ISI); 2 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "rewinddir"); #endif } PP(pp_closedir) 4726 { #if defined(Direntry_t) && defined(HAS_READDIR) 4726 dSP; 4726 GV *gv = (GV*)POPs; 4726 register IO *io = GvIOn(gv); 4726 if (!io || !IoDIRP(io)) 140 goto nope; #ifdef VOID_CLOSEDIR PerlDir_close(IoDIRP(io)); #else 4586 if (PerlDir_close(IoDIRP(io)) < 0) { ###### IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */ ###### goto nope; } #endif 4586 IoDIRP(io) = 0; 4586 RETPUSHYES; nope: 140 if (!errno) ###### SETERRNO(EBADF,RMS_IFI); 140 RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "closedir"); #endif } /* Process control. */ PP(pp_fork) 83 { #ifdef HAS_FORK 83 dSP; dTARGET; 83 Pid_t childpid; 83 GV *tmpgv; 83 EXTEND(SP, 1); 83 PERL_FLUSHALL_FOR_CHILD; 83 childpid = PerlProc_fork(); 164 if (childpid < 0) ###### RETSETUNDEF; 164 if (!childpid) { 81 if ((tmpgv = gv_fetchpv("$", TRUE, SVt_PV))) { 81 SvREADONLY_off(GvSV(tmpgv)); 81 sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid()); 81 SvREADONLY_on(GvSV(tmpgv)); } #ifdef THREADS_HAVE_PIDS PL_ppid = (IV)getppid(); #endif 81 hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */ } 164 PUSHi(childpid); 164 RETURN; #else # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS) dSP; dTARGET; Pid_t childpid; EXTEND(SP, 1); PERL_FLUSHALL_FOR_CHILD; childpid = PerlProc_fork(); if (childpid == -1) RETSETUNDEF; PUSHi(childpid); RETURN; # else DIE(aTHX_ PL_no_func, "fork"); # endif #endif } PP(pp_wait) 28 { #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(MACOS_TRADITIONAL) 28 dSP; dTARGET; 28 Pid_t childpid; 28 int argflags; 28 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) ###### childpid = wait4pid(-1, &argflags, 0); else { 28 while ((childpid = wait4pid(-1, &argflags, 0)) == -1 && errno == EINTR) { ###### PERL_ASYNC_CHECK(); } } # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS) /* 0 and -1 are both error returns (the former applies to WNOHANG case) */ STATUS_NATIVE_SET((childpid && childpid != -1) ? argflags : -1); # else 28 STATUS_NATIVE_SET((childpid > 0) ? argflags : -1); # endif 28 XPUSHi(childpid); 28 RETURN; #else DIE(aTHX_ PL_no_func, "wait"); #endif } PP(pp_waitpid) 26 { #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(MACOS_TRADITIONAL) 26 dSP; dTARGET; 26 Pid_t pid; 26 Pid_t result; 26 int optype; 26 int argflags; 26 optype = POPi; 26 pid = TOPi; 26 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) ###### result = wait4pid(pid, &argflags, optype); else { 26 while ((result = wait4pid(pid, &argflags, optype)) == -1 && errno == EINTR) { ###### PERL_ASYNC_CHECK(); } } # if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS) /* 0 and -1 are both error returns (the former applies to WNOHANG case) */ STATUS_NATIVE_SET((result && result != -1) ? argflags : -1); # else 26 STATUS_NATIVE_SET((result > 0) ? argflags : -1); # endif 26 SETi(result); 26 RETURN; #else DIE(aTHX_ PL_no_func, "waitpid"); #endif } PP(pp_system) 107 { 107 dSP; dMARK; dORIGMARK; dTARGET; 107 I32 value; 107 int result; 107 if (PL_tainting) { 10 TAINT_ENV(); 11 while (++MARK <= SP) { 10 (void)SvPV_nolen_const(*MARK); /* stringify for taint check */ 10 if (PL_tainted) 7 break; } 7 MARK = ORIGMARK; 7 TAINT_PROPER("system"); } 98 PERL_FLUSHALL_FOR_CHILD; #if (defined(HAS_FORK) ||