X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pp_sys.c;h=877d0a084d4dbe5481bc5a6e519c23cc56b76228;hb=11906ba08fed929f780ea3e503eb89c0955fb2d8;hp=b63101d6d8741b6c05cdba95d6af776895ff95d8;hpb=6dce6b70b85ef184fc8b4432d2436d1be5f0b117;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pp_sys.c b/pp_sys.c index b63101d..877d0a0 100644 --- a/pp_sys.c +++ b/pp_sys.c @@ -1,6 +1,6 @@ /* pp_sys.c * - * Copyright (c) 1991-1999, Larry Wall + * Copyright (c) 1991-2003, Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -21,17 +21,22 @@ #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. --jhi */ -#include -#endif - -/* XXX If this causes problems, set i_unistd=undef in the hint file. */ -#ifdef I_UNISTD -# include + * 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 HAS_SYSCALL -#ifdef __cplusplus +#ifdef HAS_SYSCALL +#ifdef __cplusplus extern "C" int syscall(unsigned long,...); #endif #endif @@ -44,25 +49,14 @@ extern "C" int syscall(unsigned long,...); # include #endif -#if defined(HAS_SOCKET) && !defined(VMS) /* VMS handles sockets via vmsish.h */ -# include -# if defined(USE_SOCKS) && defined(I_SOCKS) -# include -# endif -# ifdef I_NETDB -# include -# endif -# ifndef ENOTSOCK -# ifdef I_NET_ERRNO -# include -# endif -# endif +#ifdef NETWARE +NETDB_DEFINE_CONTEXT #endif #ifdef HAS_SELECT -#ifdef I_SYS_SELECT -#include -#endif +# ifdef I_SYS_SELECT +# include +# endif #endif /* XXX Configure test needed. @@ -72,7 +66,7 @@ extern "C" int syscall(unsigned long,...); compiling multithreaded and singlethreaded ($ccflags et al). HOST_NOT_FOUND is typically defined in . */ -#if defined(HOST_NOT_FOUND) && !defined(h_errno) +#if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__) extern int h_errno; #endif @@ -80,11 +74,17 @@ extern int h_errno; # 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 @@ -96,7 +96,9 @@ extern int h_errno; struct group *getgrgid (Gid_t); # endif # ifdef HAS_GETGRENT +#ifndef getgrent struct group *getgrent (void); +#endif # endif #endif @@ -107,26 +109,6 @@ extern int h_errno; # include # endif #endif -#ifdef I_FCNTL -#include -#endif -#ifdef I_SYS_FILE -#include -#endif - -/* Put this after #includes because fork and vfork prototypes may conflict. */ -#ifndef HAS_VFORK -# define vfork fork -#endif - -/* Put this after #includes because defines _XOPEN_*. */ -#ifndef Sock_size_t -# if _XOPEN_VERSION >= 5 || defined(_XOPEN_SOURCE_EXTENDED) || defined(__GLIBC__) -# define Sock_size_t Size_t -# else -# define Sock_size_t int -# endif -#endif #ifdef HAS_CHSIZE # ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */ @@ -147,7 +129,7 @@ extern int h_errno; # include # endif -# if defined(HAS_FCNTL) && defined(F_SETLK) && defined (F_SETLKW) +# if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK) # define FLOCK fcntl_emulate_flock # define FCNTL_EMULATE_FLOCK # else /* no flock() or fcntl(F_SETLK,...) */ @@ -187,6 +169,12 @@ static char zero_but_true[ZBTLEN + 1] = "0 but true"; # include #endif +#if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC) +# define FD_CLOEXEC 1 /* NeXT needs this */ +#endif + +#include "reentr.h" + #undef PERL_EFF_ACCESS_R_OK /* EFFective uid/gid ACCESS R_OK */ #undef PERL_EFF_ACCESS_W_OK #undef PERL_EFF_ACCESS_X_OK @@ -201,10 +189,9 @@ static char zero_but_true[ZBTLEN + 1] = "0 but true"; #endif #if !defined(PERL_EFF_ACCESS_R_OK) && defined(HAS_EACCESS) -# if defined(I_SYS_SECURITY) +# ifdef I_SYS_SECURITY # include # endif - /* XXX Configure test needed for eaccess */ # ifdef ACC_SELF /* HP SecureWare */ # define PERL_EFF_ACCESS_R_OK(p) (eaccess((p), R_OK, ACC_SELF)) @@ -230,7 +217,7 @@ static char zero_but_true[ZBTLEN + 1] = "0 but true"; || defined(HAS_SETREGID) || defined(HAS_SETRESGID)) /* The Hard Way. */ STATIC int -S_emulate_eaccess(pTHX_ const char* path, int mode) +S_emulate_eaccess(pTHX_ const char* path, Mode_t mode) { Uid_t ruid = getuid(); Uid_t euid = geteuid(); @@ -238,7 +225,7 @@ S_emulate_eaccess(pTHX_ const char* path, int mode) Gid_t egid = getegid(); int res; - MUTEX_LOCK(&PL_cred_mutex); + LOCK_CRED_MUTEX; #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID) Perl_croak(aTHX_ "switching effective uid is not implemented"); #else @@ -284,7 +271,7 @@ S_emulate_eaccess(pTHX_ const char* path, int mode) #endif #endif Perl_croak(aTHX_ "leaving effective gid failed"); - MUTEX_UNLOCK(&PL_cred_mutex); + UNLOCK_CRED_MUTEX; return res; } @@ -294,8 +281,11 @@ S_emulate_eaccess(pTHX_ const char* path, int mode) #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, int mode) +S_emulate_eaccess(pTHX_ const char* path, Mode_t mode) { Perl_croak(aTHX_ "switching effective uid is not implemented"); /*NOTREACHED*/ @@ -305,15 +295,27 @@ S_emulate_eaccess(pTHX_ const char* path, int mode) PP(pp_backtick) { - djSP; dTARGET; + dSP; dTARGET; PerlIO *fp; STRLEN n_a; char *tmps = POPpx; I32 gimme = GIMME_V; + char *mode = "r"; TAINT_PROPER("``"); - fp = PerlProc_popen(tmps, "r"); + if (PL_op->op_private & OPpOPEN_IN_RAW) + mode = "rb"; + else if (PL_op->op_private & OPpOPEN_IN_CRLF) + mode = "rt"; + fp = PerlProc_popen(tmps, mode); if (fp) { + char *type = NULL; + if (PL_curcop->cop_io) { + type = SvPV_nolen(PL_curcop->cop_io); + } + if (type && *type) + PerlIO_apply_layers(aTHX_ fp,mode,type); + if (gimme == G_VOID) { char tmpbuf[256]; while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0) @@ -321,10 +323,13 @@ PP(pp_backtick) ; } else if (gimme == G_SCALAR) { + SV *oldrs = PL_rs; + PL_rs = &PL_sv_undef; sv_setpv(TARG, ""); /* note that this preserves previous buffer */ while (sv_gets(TARG, fp, SvCUR(TARG)) != Nullch) /*SUPPRESS 530*/ ; + PL_rs = oldrs; XPUSHs(TARG); SvTAINTED_on(TARG); } @@ -362,6 +367,10 @@ PP(pp_glob) OP *result; 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 */ + ENTER; #ifndef VMS @@ -391,24 +400,15 @@ PP(pp_glob) return result; } -#if 0 /* XXX never used! */ -PP(pp_indread) -{ - STRLEN n_a; - PL_last_in_gv = gv_fetchpv(SvPVx(GvSV((GV*)(*PL_stack_sp--)), n_a), TRUE,SVt_PVIO); - return do_readline(); -} -#endif - PP(pp_rcatline) { - PL_last_in_gv = cGVOP->op_gv; + PL_last_in_gv = cGVOP_gv; return do_readline(); } PP(pp_warn) { - djSP; dMARK; + dSP; dMARK; SV *tmpsv; char *tmps; STRLEN len; @@ -433,17 +433,20 @@ PP(pp_warn) if (!tmps || !len) tmpsv = sv_2mortal(newSVpvn("Warning: something's wrong", 26)); - Perl_warn(aTHX_ "%_", tmpsv); + Perl_warn(aTHX_ "%"SVf, tmpsv); RETSETYES; } PP(pp_die) { - djSP; dMARK; + dSP; dMARK; char *tmps; SV *tmpsv; STRLEN len; bool multiarg = 0; +#ifdef VMS + VMSISH_HUSHED = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH); +#endif if (SP - MARK != 1) { dTARGET; do_join(TARG, &PL_sv_no, MARK, SP); @@ -454,7 +457,7 @@ PP(pp_die) } else { tmpsv = TOPs; - tmps = SvROK(tmpsv) ? Nullch : SvPV(tmpsv, len); + tmps = SvROK(tmpsv) ? Nullch : SvPV(tmpsv, len); } if (!tmps || !len) { SV *error = ERRSV; @@ -466,8 +469,8 @@ PP(pp_die) HV *stash = SvSTASH(SvRV(error)); GV *gv = gv_fetchmethod(stash, "PROPAGATE"); if (gv) { - SV *file = sv_2mortal(newSVsv(GvSV(PL_curcop->cop_filegv))); - SV *line = sv_2mortal(newSViv(PL_curcop->cop_line)); + SV *file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0)); + SV *line = sv_2mortal(newSVuv(CopLINE(PL_curcop))); EXTEND(SP, 3); PUSHMARK(SP); PUSHs(error); @@ -479,7 +482,7 @@ PP(pp_die) sv_setsv(error,*PL_stack_sp--); } } - DIE(aTHX_ Nullch); + DIE(aTHX_ Nullformat); } else { if (SvPOK(error) && SvCUR(error)) @@ -491,60 +494,35 @@ PP(pp_die) if (!tmps || !len) tmpsv = sv_2mortal(newSVpvn("Died", 4)); - DIE(aTHX_ "%_", tmpsv); + DIE(aTHX_ "%"SVf, tmpsv); } /* I/O. */ PP(pp_open) { - djSP; dTARGET; + dSP; + dMARK; dORIGMARK; + dTARGET; GV *gv; SV *sv; - SV *name; - I32 have_name = 0; + IO *io; char *tmps; STRLEN len; MAGIC *mg; + bool ok; - if (MAXARG > 2) { - name = POPs; - have_name = 1; - } - if (MAXARG > 1) - sv = POPs; - if (!isGV(TOPs)) - DIE(aTHX_ PL_no_usym, "filehandle"); - if (MAXARG <= 1) - sv = GvSV(TOPs); - gv = (GV*)POPs; + gv = (GV *)*++MARK; if (!isGV(gv)) DIE(aTHX_ PL_no_usym, "filehandle"); - if (GvIOp(gv)) + if ((io = GvIOp(gv))) IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT; -#if 0 /* no undef means tmpfile() yet */ - if (sv == &PL_sv_undef) { -#ifdef PerlIO - PerlIO *fp = PerlIO_tmpfile(); -#else - PerlIO *fp = tmpfile(); -#endif - if (fp != Nullfp && do_open(gv, "+>&", 3, FALSE, 0, 0, fp)) - PUSHi( (I32)PL_forkprocess ); - else - RETPUSHUNDEF; - RETURN; - } -#endif /* no undef means tmpfile() yet */ - - - if (mg = SvTIED_mg((SV*)gv, 'q')) { - PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); - XPUSHs(sv); - if (have_name) - XPUSHs(name); + if (io && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { + /* Method's args are same as ours ... */ + /* ... except handle is replaced by the object */ + *MARK-- = SvTIED_obj((SV*)io, mg); + PUSHMARK(MARK); PUTBACK; ENTER; call_method("OPEN", G_SCALAR); @@ -553,8 +531,17 @@ PP(pp_open) RETURN; } + if (MARK < SP) { + sv = *++MARK; + } + else { + sv = GvSV(gv); + } + tmps = SvPV(sv, len); - if (do_open9(gv, tmps, len, FALSE, O_RDONLY, 0, Nullfp, name, have_name)) + ok = do_openn(gv, tmps, len, FALSE, O_RDONLY, 0, Nullfp, MARK+1, (SP-MARK)); + SP = ORIGMARK; + if (ok) PUSHi( (I32)PL_forkprocess ); else if (PL_forkprocess == 0) /* we are a new child */ PUSHi(0); @@ -565,8 +552,9 @@ PP(pp_open) PP(pp_close) { - djSP; + dSP; GV *gv; + IO *io; MAGIC *mg; if (MAXARG == 0) @@ -574,9 +562,11 @@ PP(pp_close) else gv = (GV*)POPs; - if (mg = SvTIED_mg((SV*)gv, 'q')) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); PUTBACK; ENTER; call_method("CLOSE", G_SCALAR); @@ -591,8 +581,8 @@ PP(pp_close) PP(pp_pipe_op) { - djSP; #ifdef HAS_PIPE + dSP; GV *rgv; GV *wgv; register IO *rstio; @@ -618,11 +608,12 @@ PP(pp_pipe_op) if (PerlProc_pipe(fd) < 0) goto badexit; - IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"); - IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"); + IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPESOCK_MODE); + IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPESOCK_MODE); + IoOFP(rstio) = IoIFP(rstio); IoIFP(wstio) = IoOFP(wstio); - IoTYPE(rstio) = '<'; - IoTYPE(wstio) = '>'; + IoTYPE(rstio) = IoTYPE_RDONLY; + IoTYPE(wstio) = IoTYPE_WRONLY; if (!IoIFP(rstio) || !IoOFP(wstio)) { if (IoIFP(rstio)) PerlIO_close(IoIFP(rstio)); @@ -646,7 +637,7 @@ badexit: PP(pp_fileno) { - djSP; dTARGET; + dSP; dTARGET; GV *gv; IO *io; PerlIO *fp; @@ -656,9 +647,11 @@ PP(pp_fileno) RETPUSHUNDEF; gv = (GV*)POPs; - if (gv && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); PUTBACK; ENTER; call_method("FILENO", G_SCALAR); @@ -667,18 +660,25 @@ PP(pp_fileno) RETURN; } - if (!gv || !(io = GvIO(gv)) || !(fp = IoIFP(io))) + 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); + */ RETPUSHUNDEF; + } + PUSHi(PerlIO_fileno(fp)); RETURN; } PP(pp_umask) { - djSP; dTARGET; + dSP; dTARGET; +#ifdef HAS_UMASK Mode_t anum; -#ifdef HAS_UMASK if (MAXARG < 1) { anum = PerlLIO_umask(0); (void)PerlLIO_umask(anum); @@ -700,20 +700,28 @@ PP(pp_umask) PP(pp_binmode) { - djSP; + dSP; GV *gv; IO *io; PerlIO *fp; MAGIC *mg; + SV *discp = Nullsv; if (MAXARG < 1) RETPUSHUNDEF; + if (MAXARG > 1) { + discp = POPs; + } - gv = (GV*)POPs; + gv = (GV*)POPs; - if (gv && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); + if (discp) + XPUSHs(discp); PUTBACK; ENTER; call_method("BINMODE", G_SCALAR); @@ -723,19 +731,28 @@ PP(pp_binmode) } EXTEND(SP, 1); - if (!(io = GvIO(gv)) || !(fp = IoIFP(io))) - RETPUSHUNDEF; + if (!(io = GvIO(gv)) || !(fp = IoIFP(io))) { + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); + RETPUSHUNDEF; + } - if (do_binmode(fp,IoTYPE(io),TRUE)) + PUTBACK; + if (PerlIO_binmode(aTHX_ fp,IoTYPE(io),mode_from_discipline(discp), + (discp) ? SvPV_nolen(discp) : Nullch)) { + SPAGAIN; RETPUSHYES; - else + } + else { + SPAGAIN; RETPUSHUNDEF; + } } - PP(pp_tie) { - djSP; + dSP; dMARK; SV *varsv; HV* stash; @@ -743,25 +760,35 @@ PP(pp_tie) SV *sv; I32 markoff = MARK - PL_stack_base; char *methname; - int how = 'P'; + int how = PERL_MAGIC_tied; U32 items; - STRLEN n_a; varsv = *++MARK; switch(SvTYPE(varsv)) { case SVt_PVHV: methname = "TIEHASH"; + HvEITER((HV *)varsv) = Null(HE *); break; case SVt_PVAV: methname = "TIEARRAY"; break; case SVt_PVGV: +#ifdef GV_UNIQUE_CHECK + if (GvUNIQUE((GV*)varsv)) { + Perl_croak(aTHX_ "Attempt to tie unique GV"); + } +#endif methname = "TIEHANDLE"; - how = 'q'; + 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 */ + if (!GvIOp(varsv)) + GvIOp(varsv) = newIO(); + varsv = (SV *)GvIOp(varsv); break; default: methname = "TIESCALAR"; - how = 'q'; + how = PERL_MAGIC_tiedscalar; break; } items = SP - MARK++; @@ -769,25 +796,25 @@ PP(pp_tie) ENTER; PUSHSTACKi(PERLSI_MAGIC); PUSHMARK(SP); - EXTEND(SP,items); + 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 ? */ stash = gv_stashsv(*MARK, FALSE); if (!stash || !(gv = gv_fetchmethod(stash, methname))) { - DIE(aTHX_ "Can't locate object method \"%s\" via package \"%s\"", - methname, SvPV(*MARK,n_a)); + DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"", + methname, *MARK); } ENTER; PUSHSTACKi(PERLSI_MAGIC); PUSHMARK(SP); - EXTEND(SP,items); + EXTEND(SP,(I32)items); while (items--) PUSHs(*MARK++); PUTBACK; @@ -799,6 +826,12 @@ PP(pp_tie) POPSTACK; if (sv_isobject(sv)) { sv_unmagic(varsv, how); + /* Croak if a self-tie on an aggregate is attempted. */ + if (varsv == SvRV(sv) && + (SvTYPE(varsv) == SVt_PVAV || + SvTYPE(varsv) == SVt_PVHV)) + Perl_croak(aTHX_ + "Self-ties of arrays and hashes are not supported"); sv_magic(varsv, (SvRV(sv) == varsv ? Nullsv : sv), how, Nullch, 0); } LEAVE; @@ -809,32 +842,55 @@ PP(pp_tie) PP(pp_untie) { - djSP; + dSP; + MAGIC *mg; SV *sv = POPs; - char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) ? 'P' : 'q'; - - if (ckWARN(WARN_UNTIE)) { - MAGIC * mg ; - if (mg = SvTIED_mg(sv, how)) { - if (mg && SvREFCNT(SvRV(mg->mg_obj)) > 1) - Perl_warner(aTHX_ WARN_UNTIE, - "untie attempted while %lu inner references still exist", - (unsigned long)SvREFCNT(SvRV(mg->mg_obj)) - 1 ) ; + char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) + ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar; + + if (SvTYPE(sv) == SVt_PVGV && !(sv = (SV *)GvIOp(sv))) + RETPUSHYES; + + if ((mg = SvTIED_mg(sv, how))) { + SV *obj = SvRV(mg->mg_obj); + GV *gv; + CV *cv = NULL; + if (obj) { + if ((gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE)) && + isGV(gv) && (cv = GvCV(gv))) { + PUSHMARK(SP); + XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(sv_2mortal(newSViv(SvREFCNT(obj)-1))); + PUTBACK; + ENTER; + call_sv((SV *)cv, G_VOID); + LEAVE; + SPAGAIN; + } + else if (ckWARN(WARN_UNTIE)) { + if (mg && SvREFCNT(obj) > 1) + Perl_warner(aTHX_ packWARN(WARN_UNTIE), + "untie attempted while %"UVuf" inner references still exist", + (UV)SvREFCNT(obj) - 1 ) ; + } } + sv_unmagic(sv, how) ; } - - sv_unmagic(sv, how); RETPUSHYES; } PP(pp_tied) { - djSP; - SV *sv = POPs; - char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) ? 'P' : 'q'; + dSP; MAGIC *mg; + SV *sv = POPs; + char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) + ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar; + + if (SvTYPE(sv) == SVt_PVGV && !(sv = (SV *)GvIOp(sv))) + RETPUSHUNDEF; - if (mg = SvTIED_mg(sv, how)) { + if ((mg = SvTIED_mg(sv, how))) { SV *osv = SvTIED_obj(sv, mg); if (osv == mg->mg_obj) osv = sv_mortalcopy(osv); @@ -846,7 +902,7 @@ PP(pp_tied) PP(pp_dbmopen) { - djSP; + dSP; HV *hv; dPOPPOPssrl; HV* stash; @@ -873,9 +929,9 @@ PP(pp_dbmopen) PUSHs(sv); PUSHs(left); if (SvIV(right)) - PUSHs(sv_2mortal(newSViv(O_RDWR|O_CREAT))); + PUSHs(sv_2mortal(newSVuv(O_RDWR|O_CREAT))); else - PUSHs(sv_2mortal(newSViv(O_RDWR))); + PUSHs(sv_2mortal(newSVuv(O_RDWR))); PUSHs(right); PUTBACK; call_sv((SV*)GvCV(gv), G_SCALAR); @@ -886,7 +942,7 @@ PP(pp_dbmopen) PUSHMARK(SP); PUSHs(sv); PUSHs(left); - PUSHs(sv_2mortal(newSViv(O_RDONLY))); + PUSHs(sv_2mortal(newSVuv(O_RDONLY))); PUSHs(right); PUTBACK; call_sv((SV*)GvCV(gv), G_SCALAR); @@ -894,8 +950,8 @@ PP(pp_dbmopen) } if (sv_isobject(TOPs)) { - sv_unmagic((SV *) hv, 'P'); - sv_magic((SV*)hv, TOPs, 'P', Nullch, 0); + sv_unmagic((SV *) hv, PERL_MAGIC_tied); + sv_magic((SV*)hv, TOPs, PERL_MAGIC_tied, Nullch, 0); } LEAVE; RETURN; @@ -908,8 +964,8 @@ PP(pp_dbmclose) PP(pp_sselect) { - djSP; dTARGET; #ifdef HAS_SELECT + dSP; dTARGET; register I32 i; register I32 j; register char *s; @@ -945,18 +1001,7 @@ PP(pp_sselect) } /* little endians can use vecs directly */ -#if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678 -# if SELECT_MIN_BITS > 1 - /* 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, Rhapsody) the smallest quantum select() operates - * on (sets/tests/clears bits) is 32 bits. */ - growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8))); -# else - growsize = sizeof(fd_set); -# endif -# else +#if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678 # ifdef NFDBITS # ifndef NBBY @@ -967,10 +1012,20 @@ PP(pp_sselect) # else masksize = sizeof(long); /* documented int, everyone seems to use long */ # endif - growsize = maxlen + (masksize - (maxlen % masksize)); Zero(&fd_sets[0], 4, char*); #endif +# if SELECT_MIN_BITS > 1 + /* 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. */ + growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8))); +# else + growsize = sizeof(fd_set); +# endif + sv = SP[4]; if (SvOK(sv)) { value = SvNV(sv); @@ -1013,12 +1068,23 @@ PP(pp_sselect) #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 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 for (i = 1; i <= 3; i++) { if (fd_sets[i]) { sv = SP[i]; @@ -1050,7 +1116,6 @@ PP(pp_sselect) void Perl_setdefout(pTHX_ GV *gv) { - dTHR; if (gv) (void)SvREFCNT_inc(gv); if (PL_defoutgv) @@ -1060,7 +1125,7 @@ Perl_setdefout(pTHX_ GV *gv) PP(pp_select) { - djSP; dTARGET; + dSP; dTARGET; GV *newdefout, *egv; HV *hv; @@ -1075,7 +1140,7 @@ PP(pp_select) else { GV **gvp = (GV**)hv_fetch(hv, GvNAME(egv), GvNAMELEN(egv), FALSE); if (gvp && *gvp == egv) { - gv_efullname3(TARG, PL_defoutgv, Nullch); + gv_efullname4(TARG, PL_defoutgv, Nullch, TRUE); XPUSHTARG; } else { @@ -1094,21 +1159,22 @@ PP(pp_select) PP(pp_getc) { - djSP; dTARGET; + dSP; dTARGET; GV *gv; + IO *io = NULL; MAGIC *mg; - if (MAXARG <= 0) + if (MAXARG == 0) gv = PL_stdingv; else gv = (GV*)POPs; - if (!gv) - gv = PL_argvgv; - if (mg = SvTIED_mg((SV*)gv, 'q')) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { I32 gimme = GIMME_V; PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); PUTBACK; ENTER; call_method("GETC", gimme); @@ -1118,11 +1184,26 @@ PP(pp_getc) SvSetMagicSV_nosteal(TARG, TOPs); RETURN; } - if (!gv || do_eof(gv)) /* make sure we have fp with something */ + if (!gv || do_eof(gv)) { /* make sure we have fp with something */ + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED) + && (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); RETPUSHUNDEF; + } TAINT; sv_setpv(TARG, " "); *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */ + if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) { + /* Find out how many bytes the char needs */ + Size_t len = UTF8SKIP(SvPVX(TARG)); + if (len > 1) { + SvGROW(TARG,len+1); + len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1); + SvCUR_set(TARG,1+len); + } + SvUTF8_on(TARG); + } PUSHTARG; RETURN; } @@ -1135,20 +1216,16 @@ PP(pp_read) STATIC OP * S_doform(pTHX_ CV *cv, GV *gv, OP *retop) { - dTHR; register PERL_CONTEXT *cx; I32 gimme = GIMME_V; - AV* padlist = CvPADLIST(cv); - SV** svp = AvARRAY(padlist); ENTER; SAVETMPS; push_return(retop); - PUSHBLOCK(cx, CXt_SUB, PL_stack_sp); + PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp); PUSHFORMAT(cx); - SAVESPTR(PL_curpad); - PL_curpad = AvARRAY((AV*)svp[1]); + PAD_SET_CUR(CvPADLIST(cv), 1); setdefout(gv); /* locally select filehandle so $% et al work */ return CvSTART(cv); @@ -1156,7 +1233,7 @@ S_doform(pTHX_ CV *cv, GV *gv, OP *retop) PP(pp_enterwrite) { - djSP; + dSP; register GV *gv; register IO *io; GV *fgv; @@ -1181,11 +1258,14 @@ PP(pp_enterwrite) cv = GvFORM(fgv); if (!cv) { + char *name = NULL; if (fgv) { SV *tmpsv = sv_newmortal(); - gv_efullname3(tmpsv, fgv, Nullch); - DIE(aTHX_ "Undefined format \"%s\" called",SvPVX(tmpsv)); + gv_efullname4(tmpsv, fgv, Nullch, FALSE); + name = SvPV_nolen(tmpsv); } + if (name && *name) + DIE(aTHX_ "Undefined format \"%s\" called", name); DIE(aTHX_ "Not a format reference"); } if (CvCLONE(cv)) @@ -1197,7 +1277,7 @@ PP(pp_enterwrite) PP(pp_leavewrite) { - djSP; + dSP; GV *gv = cxstack[cxstack_ix].blk_sub.gv; register IO *io = GvIOp(gv); PerlIO *ofp = IoOFP(io); @@ -1208,6 +1288,8 @@ PP(pp_leavewrite) DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n", (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget))); + if (!io || !ofp) + goto forget_top; if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) && PL_formtarget != PL_toptarget) { @@ -1247,13 +1329,16 @@ PP(pp_leavewrite) s++; } if (s) { - PerlIO_write(ofp, SvPVX(PL_formtarget), s - SvPVX(PL_formtarget)); + STRLEN save = SvCUR(PL_formtarget); + SvCUR_set(PL_formtarget, s - SvPVX(PL_formtarget)); + do_print(PL_formtarget, ofp); + SvCUR_set(PL_formtarget, save); sv_chop(PL_formtarget, s); FmLINES(PL_formtarget) -= IoLINES_LEFT(io); } } if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0) - PerlIO_write(ofp, SvPVX(PL_formfeed), SvCUR(PL_formfeed)); + do_print(PL_formfeed, ofp); IoLINES_LEFT(io) = IoPAGE_LEN(io); IoPAGE(io)++; PL_formtarget = PL_toptarget; @@ -1262,10 +1347,19 @@ PP(pp_leavewrite) if (!fgv) DIE(aTHX_ "bad top format reference"); cv = GvFORM(fgv); - if (!cv) { - SV *tmpsv = sv_newmortal(); - gv_efullname3(tmpsv, fgv, Nullch); - DIE(aTHX_ "Undefined top format \"%s\" called",SvPVX(tmpsv)); + { + char *name = NULL; + if (!cv) { + SV *sv = sv_newmortal(); + gv_efullname4(sv, fgv, Nullch, FALSE); + name = SvPV_nolen(sv); + } + if (name && *name) + DIE(aTHX_ "Undefined top format \"%s\" called",name); + /* why no: + else + DIE(aTHX_ "Undefined top format called"); + ?*/ } if (CvCLONE(cv)) cv = (CV*)sv_2mortal((SV*)cv_clone(cv)); @@ -1280,25 +1374,19 @@ PP(pp_leavewrite) fp = IoOFP(io); if (!fp) { if (ckWARN2(WARN_CLOSED,WARN_IO)) { - SV* sv = sv_newmortal(); - gv_efullname3(sv, gv, Nullch); if (IoIFP(io)) - Perl_warner(aTHX_ WARN_IO, - "Filehandle %s opened only for input", - SvPV_nolen(sv)); + report_evil_fh(gv, io, OP_phoney_INPUT_ONLY); else if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, - "Write on closed filehandle %s", SvPV_nolen(sv)); + report_evil_fh(gv, io, PL_op->op_type); } PUSHs(&PL_sv_no); } else { if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) { if (ckWARN(WARN_IO)) - Perl_warner(aTHX_ WARN_IO, "page overflow"); + Perl_warner(aTHX_ packWARN(WARN_IO), "page overflow"); } - if (!PerlIO_write(ofp, SvPVX(PL_formtarget), SvCUR(PL_formtarget)) || - PerlIO_error(fp)) + if (!do_print(PL_formtarget, fp)) PUSHs(&PL_sv_no); else { FmLINES(PL_formtarget) = 0; @@ -1309,6 +1397,7 @@ PP(pp_leavewrite) PUSHs(&PL_sv_yes); } } + /* bad_ofp: */ PL_formtarget = PL_bodytarget; PUTBACK; return pop_return(); @@ -1316,20 +1405,21 @@ PP(pp_leavewrite) PP(pp_prtf) { - djSP; dMARK; dORIGMARK; + dSP; dMARK; dORIGMARK; GV *gv; IO *io; PerlIO *fp; SV *sv; MAGIC *mg; - STRLEN n_a; if (PL_op->op_flags & OPf_STACKED) gv = (GV*)*++MARK; else gv = PL_defoutgv; - if (mg = SvTIED_mg((SV*)gv, 'q')) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { if (MARK == ORIGMARK) { MEXTEND(SP, 1); ++MARK; @@ -1337,7 +1427,7 @@ PP(pp_prtf) ++SP; } PUSHMARK(MARK - 1); - *MARK = SvTIED_obj((SV*)gv, mg); + *MARK = SvTIED_obj((SV*)io, mg); PUTBACK; ENTER; call_method("PRINTF", G_SCALAR); @@ -1351,26 +1441,19 @@ PP(pp_prtf) sv = NEWSV(0,0); if (!(io = GvIO(gv))) { - if (ckWARN(WARN_UNOPENED)) { - gv_efullname3(sv, gv, Nullch); - Perl_warner(aTHX_ WARN_UNOPENED, - "Filehandle %s never opened", SvPV(sv,n_a)); - } - SETERRNO(EBADF,RMS$_IFI); + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); goto just_say_no; } else if (!(fp = IoOFP(io))) { if (ckWARN2(WARN_CLOSED,WARN_IO)) { - gv_efullname3(sv, gv, Nullch); if (IoIFP(io)) - Perl_warner(aTHX_ WARN_IO, - "Filehandle %s opened only for input", - SvPV(sv,n_a)); + report_evil_fh(gv, io, OP_phoney_INPUT_ONLY); else if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, - "printf on closed filehandle %s", SvPV(sv,n_a)); + report_evil_fh(gv, io, PL_op->op_type); } - SETERRNO(EBADF,IoIFP(io)?RMS$_FAC:RMS$_IFI); + SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI); goto just_say_no; } else { @@ -1396,7 +1479,7 @@ PP(pp_prtf) PP(pp_sysopen) { - djSP; + dSP; GV *gv; SV *sv; char *tmps; @@ -1426,25 +1509,33 @@ PP(pp_sysopen) PP(pp_sysread) { - djSP; dMARK; dORIGMARK; dTARGET; + dSP; dMARK; dORIGMARK; dTARGET; int offset; GV *gv; IO *io; char *buffer; SSize_t length; + SSize_t count; Sock_size_t bufsize; SV *bufsv; STRLEN blen; MAGIC *mg; + int fp_utf8; + Size_t got = 0; + Size_t wanted; + bool charstart = FALSE; + STRLEN charskip = 0; + STRLEN skip = 0; gv = (GV*)*++MARK; - if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD) && - (mg = SvTIED_mg((SV*)gv, 'q'))) + if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD) + && gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { SV *sv; PUSHMARK(MARK-1); - *MARK = SvTIED_obj((SV*)gv, mg); + *MARK = SvTIED_obj((SV*)io, mg); ENTER; call_method("READ", G_SCALAR); LEAVE; @@ -1460,22 +1551,39 @@ PP(pp_sysread) bufsv = *++MARK; if (! SvOK(bufsv)) sv_setpvn(bufsv, "", 0); - buffer = SvPV_force(bufsv, blen); length = SvIVx(*++MARK); - if (length < 0) - DIE(aTHX_ "Negative length"); SETERRNO(0,0); if (MARK < SP) offset = SvIVx(*++MARK); else offset = 0; io = GvIO(gv); - if (!io || !IoIFP(io)) + if (!io || !IoIFP(io)) { + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); goto say_undef; + } + if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) { + buffer = SvPVutf8_force(bufsv, blen); + /* UTF8 may not have been set if they are all low bytes */ + SvUTF8_on(bufsv); + } + else { + buffer = SvPV_force(bufsv, blen); + } + if (length < 0) + DIE(aTHX_ "Negative length"); + wanted = length; + + charstart = TRUE; + charskip = 0; + skip = 0; + #ifdef HAS_SOCKET if (PL_op->op_type == OP_RECV) { char namebuf[MAXPATHLEN]; -#if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) +#if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__) bufsize = sizeof (struct sockaddr_in); #else bufsize = sizeof namebuf; @@ -1484,19 +1592,21 @@ PP(pp_sysread) if (bufsize >= 256) bufsize = 255; #endif -#ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */ - if (bufsize >= 256) - bufsize = 255; -#endif - buffer = SvGROW(bufsv, length+1); + buffer = SvGROW(bufsv, (STRLEN)(length+1)); /* 'offset' means 'flags' here */ - length = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, offset, + count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, offset, (struct sockaddr *)namebuf, &bufsize); - if (length < 0) + if (count < 0) RETPUSHUNDEF; - SvCUR_set(bufsv, length); +#ifdef EPOC + /* Bogus return without padding */ + bufsize = sizeof (struct sockaddr_in); +#endif + SvCUR_set(bufsv, count); *SvEND(bufsv) = '\0'; (void)SvPOK_only(bufsv); + if (fp_utf8) + SvUTF8_on(bufsv); SvSETMAGIC(bufsv); /* This should not be marked tainted if the fp is marked clean */ if (!(IoFLAGS(io) & IOf_UNTAINT)) @@ -1510,69 +1620,109 @@ PP(pp_sysread) if (PL_op->op_type == OP_RECV) DIE(aTHX_ PL_no_sock_func, "recv"); #endif + if (DO_UTF8(bufsv)) { + /* offset adjust in characters not bytes */ + blen = sv_len_utf8(bufsv); + } if (offset < 0) { - if (-offset > blen) + if (-offset > (int)blen) DIE(aTHX_ "Offset outside string"); offset += blen; } + if (DO_UTF8(bufsv)) { + /* convert offset-as-chars to offset-as-bytes */ + offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer; + } + more_bytes: bufsize = SvCUR(bufsv); - buffer = SvGROW(bufsv, length+offset+1); + buffer = SvGROW(bufsv, (STRLEN)(length+offset+1)); if (offset > bufsize) { /* Zero any newly allocated space */ Zero(buffer+bufsize, offset-bufsize, char); } + buffer = buffer + offset; + if (PL_op->op_type == OP_SYSREAD) { #ifdef PERL_SOCK_SYSREAD_IS_RECV - if (IoTYPE(io) == 's') { - length = PerlSock_recv(PerlIO_fileno(IoIFP(io)), - buffer+offset, length, 0); + if (IoTYPE(io) == IoTYPE_SOCKET) { + count = PerlSock_recv(PerlIO_fileno(IoIFP(io)), + buffer, length, 0); } else #endif { - length = PerlLIO_read(PerlIO_fileno(IoIFP(io)), - buffer+offset, length); + count = PerlLIO_read(PerlIO_fileno(IoIFP(io)), + buffer, length); } } else #ifdef HAS_SOCKET__bad_code_maybe - if (IoTYPE(io) == 's') { + 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 - length = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer+offset, length, 0, + count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, 0, (struct sockaddr *)namebuf, &bufsize); } else #endif { - length = PerlIO_read(IoIFP(io), buffer+offset, length); - /* fread() returns 0 on both error and EOF */ - if (length == 0 && PerlIO_error(IoIFP(io))) - length = -1; - } - if (length < 0) { - if (IoTYPE(io) == '>' || IoIFP(io) == PerlIO_stdout() - || IoIFP(io) == PerlIO_stderr()) - { - SV* sv = sv_newmortal(); - gv_efullname3(sv, gv, Nullch); - Perl_warner(aTHX_ WARN_IO, "Filehandle %s opened only for output", - SvPV_nolen(sv)); - } + count = PerlIO_read(IoIFP(io), buffer, length); + /* PerlIO_read() - like fread() returns 0 on both error and EOF */ + if (count == 0 && PerlIO_error(IoIFP(io))) + count = -1; + } + if (count < 0) { + if ((IoTYPE(io) == IoTYPE_WRONLY) && ckWARN(WARN_IO)) + report_evil_fh(gv, io, OP_phoney_OUTPUT_ONLY); goto say_undef; } - SvCUR_set(bufsv, length+offset); + SvCUR_set(bufsv, count+(buffer - SvPVX(bufsv))); *SvEND(bufsv) = '\0'; (void)SvPOK_only(bufsv); + if (fp_utf8 && !IN_BYTES) { + /* Look at utf8 we got back and count the characters */ + char *bend = buffer + count; + while (buffer < bend) { + if (charstart) { + skip = UTF8SKIP(buffer); + charskip = 0; + } + if (buffer - charskip + skip > bend) { + /* partial character - try for rest of it */ + length = skip - (bend-buffer); + offset = bend - SvPVX(bufsv); + charstart = FALSE; + charskip += count; + goto more_bytes; + } + else { + got++; + buffer += skip; + charstart = TRUE; + 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) + */ + if (got < wanted && count == length) { + length = wanted - got; + offset = bend - SvPVX(bufsv); + goto more_bytes; + } + /* return value is character count */ + count = got; + SvUTF8_on(bufsv); + } SvSETMAGIC(bufsv); /* This should not be marked tainted if the fp is marked clean */ if (!(IoFLAGS(io) & IOf_UNTAINT)) SvTAINTED_on(bufsv); SP = ORIGMARK; - PUSHi(length); + PUSHi(count); RETURN; say_undef: @@ -1582,7 +1732,7 @@ PP(pp_sysread) PP(pp_syswrite) { - djSP; + dSP; int items = (SP - PL_stack_base) - TOPMARK; if (items == 2) { SV *sv; @@ -1596,22 +1746,25 @@ PP(pp_syswrite) PP(pp_send) { - djSP; dMARK; dORIGMARK; dTARGET; + dSP; dMARK; dORIGMARK; dTARGET; GV *gv; IO *io; - int offset; SV *bufsv; char *buffer; - int length; + Size_t length; + SSize_t retval; STRLEN blen; MAGIC *mg; gv = (GV*)*++MARK; - if (PL_op->op_type == OP_SYSWRITE && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (PL_op->op_type == OP_SYSWRITE + && gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { SV *sv; PUSHMARK(MARK-1); - *MARK = SvTIED_obj((SV*)gv, mg); + *MARK = SvTIED_obj((SV*)io, mg); ENTER; call_method("WRITE", G_SCALAR); LEAVE; @@ -1624,44 +1777,68 @@ PP(pp_send) if (!gv) goto say_undef; bufsv = *++MARK; - buffer = SvPV(bufsv, blen); - length = SvIVx(*++MARK); - if (length < 0) +#if Size_t_size > IVSIZE + length = (Size_t)SvNVx(*++MARK); +#else + length = (Size_t)SvIVx(*++MARK); +#endif + if ((SSize_t)length < 0) DIE(aTHX_ "Negative length"); SETERRNO(0,0); io = GvIO(gv); if (!io || !IoIFP(io)) { - length = -1; - if (ckWARN(WARN_CLOSED)) { - if (PL_op->op_type == OP_SYSWRITE) - Perl_warner(aTHX_ WARN_CLOSED, "Syswrite on closed filehandle"); - else - Perl_warner(aTHX_ WARN_CLOSED, "Send on closed socket"); - } + retval = -1; + if (ckWARN(WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); + goto say_undef; + } + + if (PerlIO_isutf8(IoIFP(io))) { + buffer = SvPVutf8(bufsv, blen); + } + else { + if (DO_UTF8(bufsv)) + sv_utf8_downgrade(bufsv, FALSE); + buffer = SvPV(bufsv, blen); } - else if (PL_op->op_type == OP_SYSWRITE) { + + if (PL_op->op_type == OP_SYSWRITE) { + IV offset; + if (DO_UTF8(bufsv)) { + /* length and offset are in chars */ + blen = sv_len_utf8(bufsv); + } if (MARK < SP) { offset = SvIVx(*++MARK); if (offset < 0) { - if (-offset > blen) + if (-offset > (IV)blen) DIE(aTHX_ "Offset outside string"); offset += blen; - } else if (offset >= blen && blen > 0) + } else if (offset >= (IV)blen && blen > 0) DIE(aTHX_ "Offset outside string"); } else offset = 0; if (length > blen - offset) length = blen - offset; + if (DO_UTF8(bufsv)) { + buffer = (char*)utf8_hop((U8 *)buffer, offset); + length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer; + } + else { + buffer = buffer+offset; + } #ifdef PERL_SOCK_SYSWRITE_IS_SEND - if (IoTYPE(io) == 's') { - length = PerlSock_send(PerlIO_fileno(IoIFP(io)), - buffer+offset, length, 0); + if (IoTYPE(io) == IoTYPE_SOCKET) { + retval = PerlSock_send(PerlIO_fileno(IoIFP(io)), + buffer, length, 0); } else #endif { - length = PerlLIO_write(PerlIO_fileno(IoIFP(io)), - buffer+offset, length); + /* See the note at doio.c:do_print about filesize limits. --jhi */ + retval = PerlLIO_write(PerlIO_fileno(IoIFP(io)), + buffer, length); } } #ifdef HAS_SOCKET @@ -1669,20 +1846,27 @@ PP(pp_send) char *sockbuf; STRLEN mlen; sockbuf = SvPVx(*++MARK, mlen); - length = PerlSock_sendto(PerlIO_fileno(IoIFP(io)), buffer, blen, length, - (struct sockaddr *)sockbuf, mlen); + /* length is really flags */ + retval = PerlSock_sendto(PerlIO_fileno(IoIFP(io)), buffer, blen, + length, (struct sockaddr *)sockbuf, mlen); } else - length = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, blen, length); - + /* length is really flags */ + retval = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, blen, length); #else else DIE(aTHX_ PL_no_sock_func, "send"); #endif - if (length < 0) + if (retval < 0) goto say_undef; SP = ORIGMARK; - PUSHi(length); + if (DO_UTF8(bufsv)) + retval = utf8_length((U8*)buffer, (U8*)buffer + retval); +#if Size_t_size > IVSIZE + PUSHn(retval); +#else + PUSHi(retval); +#endif RETURN; say_undef: @@ -1697,18 +1881,39 @@ PP(pp_recv) PP(pp_eof) { - djSP; + dSP; GV *gv; + IO *io; MAGIC *mg; - if (MAXARG <= 0) - gv = PL_last_in_gv; + if (MAXARG == 0) { + if (PL_op->op_flags & OPf_SPECIAL) { /* eof() */ + IO *io; + gv = PL_last_in_gv = GvEGV(PL_argvgv); + io = GvIO(gv); + if (io && !IoIFP(io)) { + if ((IoFLAGS(io) & IOf_START) && av_len(GvAVn(gv)) < 0) { + IoLINES(io) = 0; + IoFLAGS(io) &= ~IOf_START; + do_open(gv, "-", 1, FALSE, O_RDONLY, 0, Nullfp); + sv_setpvn(GvSV(gv), "-", 1); + SvSETMAGIC(GvSV(gv)); + } + else if (!nextargv(gv)) + RETPUSHYES; + } + } + else + gv = PL_last_in_gv; /* eof */ + } else - gv = PL_last_in_gv = (GV*)POPs; + gv = PL_last_in_gv = (GV*)POPs; /* eof(FH) */ - if (gv && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); PUTBACK; ENTER; call_method("EOF", G_SCALAR); @@ -1723,18 +1928,21 @@ PP(pp_eof) PP(pp_tell) { - djSP; dTARGET; - GV *gv; + dSP; dTARGET; + GV *gv; + IO *io; MAGIC *mg; - if (MAXARG <= 0) + if (MAXARG == 0) gv = PL_last_in_gv; else gv = PL_last_in_gv = (GV*)POPs; - if (gv && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); + XPUSHs(SvTIED_obj((SV*)io, mg)); PUTBACK; ENTER; call_method("TELL", G_SCALAR); @@ -1743,7 +1951,11 @@ PP(pp_tell) RETURN; } +#if LSEEKSIZE > IVSIZE + PUSHn( do_tell(gv) ); +#else PUSHi( do_tell(gv) ); +#endif RETURN; } @@ -1754,19 +1966,30 @@ PP(pp_seek) PP(pp_sysseek) { - djSP; + dSP; GV *gv; + IO *io; int whence = POPi; - Off_t offset = POPl; +#if LSEEKSIZE > IVSIZE + Off_t offset = (Off_t)SvNVx(POPs); +#else + Off_t offset = (Off_t)SvIVx(POPs); +#endif MAGIC *mg; gv = PL_last_in_gv = (GV*)POPs; - if (gv && (mg = SvTIED_mg((SV*)gv, 'q'))) { + if (gv && (io = GvIO(gv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) + { PUSHMARK(SP); - XPUSHs(SvTIED_obj((SV*)gv, mg)); - XPUSHs(sv_2mortal(newSViv((IV) offset))); - XPUSHs(sv_2mortal(newSViv((IV) whence))); + XPUSHs(SvTIED_obj((SV*)io, mg)); +#if LSEEKSIZE > IVSIZE + XPUSHs(sv_2mortal(newSVnv((NV) offset))); +#else + XPUSHs(sv_2mortal(newSViv(offset))); +#endif + XPUSHs(sv_2mortal(newSViv(whence))); PUTBACK; ENTER; call_method("SEEK", G_SCALAR); @@ -1778,74 +2001,117 @@ PP(pp_sysseek) if (PL_op->op_type == OP_SEEK) PUSHs(boolSV(do_seek(gv, offset, whence))); else { - Off_t n = do_sysseek(gv, offset, whence); - PUSHs((n < 0) ? &PL_sv_undef - : sv_2mortal(n ? newSViv((IV)n) - : newSVpvn(zero_but_true, ZBTLEN))); + Off_t sought = do_sysseek(gv, offset, whence); + if (sought < 0) + PUSHs(&PL_sv_undef); + else { + SV* sv = sought ? +#if LSEEKSIZE > IVSIZE + newSVnv((NV)sought) +#else + newSViv(sought) +#endif + : newSVpvn(zero_but_true, ZBTLEN); + PUSHs(sv_2mortal(sv)); + } } RETURN; } PP(pp_truncate) { - djSP; - Off_t len = (Off_t)POPn; - int result = 1; - GV *tmpgv; - STRLEN n_a; + 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 */ + Off_t len; +#if Off_t_size > IVSIZE + 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 */ SETERRNO(0,0); #if defined(HAS_TRUNCATE) || defined(HAS_CHSIZE) || defined(F_FREESP) - if (PL_op->op_flags & OPf_SPECIAL) { - tmpgv = gv_fetchpv(POPpx, FALSE, SVt_PVIO); - do_ftruncate: - TAINT_PROPER("truncate"); - if (!GvIO(tmpgv) || !IoIFP(GvIOp(tmpgv)) || + { + STRLEN n_a; + int result = 1; + GV *tmpgv; + IO *io; + + if (PL_op->op_flags & OPf_SPECIAL) { + tmpgv = gv_fetchpv(POPpx, FALSE, SVt_PVIO); + + do_ftruncate_gv: + if (!GvIO(tmpgv)) + result = 0; + else { + PerlIO *fp; + io = GvIOp(tmpgv); + do_ftruncate_io: + TAINT_PROPER("truncate"); + if (!(fp = IoIFP(io))) { + result = 0; + } + else { + PerlIO_flush(fp); #ifdef HAS_TRUNCATE - ftruncate(PerlIO_fileno(IoIFP(GvIOn(tmpgv))), len) < 0) -#else - my_chsize(PerlIO_fileno(IoIFP(GvIOn(tmpgv))), len) < 0) + if (ftruncate(PerlIO_fileno(fp), len) < 0) +#else + if (my_chsize(PerlIO_fileno(fp), len) < 0) #endif - result = 0; - } - else { - SV *sv = POPs; - char *name; - STRLEN n_a; - - if (SvTYPE(sv) == SVt_PVGV) { - tmpgv = (GV*)sv; /* *main::FRED for example */ - goto do_ftruncate; - } - else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) { - tmpgv = (GV*) SvRV(sv); /* \*main::FRED for example */ - goto do_ftruncate; + result = 0; + } + } } + else { + SV *sv = POPs; + char *name; + + if (SvTYPE(sv) == SVt_PVGV) { + tmpgv = (GV*)sv; /* *main::FRED for example */ + goto do_ftruncate_gv; + } + else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) { + tmpgv = (GV*) SvRV(sv); /* \*main::FRED for example */ + goto do_ftruncate_gv; + } + else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) { + io = (IO*) SvRV(sv); /* *main::FRED{IO} for example */ + goto do_ftruncate_io; + } - name = SvPV(sv, n_a); - TAINT_PROPER("truncate"); + name = SvPV(sv, n_a); + TAINT_PROPER("truncate"); #ifdef HAS_TRUNCATE - if (truncate(name, len) < 0) - result = 0; + 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) + { + int tmpfd; + + if ((tmpfd = PerlLIO_open(name, O_RDWR)) < 0) result = 0; - PerlLIO_close(tmpfd); + else { + if (my_chsize(tmpfd, len) < 0) + result = 0; + PerlLIO_close(tmpfd); + } } - } #endif - } + } - if (result) - RETPUSHYES; - if (!errno) - SETERRNO(EBADF,RMS$_IFI); - RETPUSHUNDEF; + if (result) + RETPUSHYES; + if (!errno) + SETERRNO(EBADF,RMS_IFI); + RETPUSHUNDEF; + } #else DIE(aTHX_ "truncate not implemented"); #endif @@ -1858,17 +2124,19 @@ PP(pp_fcntl) PP(pp_ioctl) { - djSP; dTARGET; + dSP; dTARGET; SV *argsv = POPs; - unsigned int func = U_I(POPn); + unsigned int func = POPu; int optype = PL_op->op_type; char *s; IV retval; GV *gv = (GV*)POPs; - IO *io = GvIOn(gv); + IO *io = gv ? GvIOn(gv) : 0; if (!io || !argsv || !IoIFP(io)) { - SETERRNO(EBADF,RMS$_IFI); /* well, sort of... */ + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,RMS_IFI); /* well, sort of... */ RETPUSHUNDEF; } @@ -1886,7 +2154,7 @@ PP(pp_ioctl) } else { retval = SvIV(argsv); - s = (char*)retval; /* ouch */ + s = INT2PTR(char*,retval); /* ouch */ } TAINT_PROPER(optype == OP_IOCTL ? "ioctl" : "fcntl"); @@ -1898,20 +2166,19 @@ PP(pp_ioctl) DIE(aTHX_ "ioctl is not implemented"); #endif else -#ifdef HAS_FCNTL +#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 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s); -#endif -#else - DIE(aTHX_ "fcntl is not implemented"); #endif if (SvPOK(argsv)) { if (s[SvCUR(argsv)] != 17) DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument", - PL_op_name[optype]); + OP_NAME(PL_op)); s[SvCUR(argsv)] = 0; /* put our null back */ SvSETMAGIC(argsv); /* Assume it has changed */ } @@ -1924,33 +2191,41 @@ PP(pp_ioctl) else { PUSHp(zero_but_true, ZBTLEN); } +#endif RETURN; } PP(pp_flock) { - djSP; dTARGET; +#ifdef FLOCK + dSP; dTARGET; I32 value; int argtype; GV *gv; + IO *io = NULL; PerlIO *fp; -#ifdef FLOCK argtype = POPi; - if (MAXARG <= 0) + if (MAXARG == 0) gv = PL_last_in_gv; else gv = (GV*)POPs; - if (gv && GvIO(gv)) - fp = IoIFP(GvIOp(gv)); - else + if (gv && (io = GvIO(gv))) + fp = IoIFP(io); + else { fp = Nullfp; + io = NULL; + } if (fp) { (void)PerlIO_flush(fp); value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0); } - else + else { + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, io, PL_op->op_type); value = 0; + SETERRNO(EBADF,RMS_IFI); + } PUSHi(value); RETURN; #else @@ -1962,8 +2237,8 @@ PP(pp_flock) PP(pp_socket) { - djSP; #ifdef HAS_SOCKET + dSP; GV *gv; register IO *io; int protocol = POPi; @@ -1972,13 +2247,17 @@ PP(pp_socket) int fd; gv = (GV*)POPs; - - if (!gv) { - SETERRNO(EBADF,LIB$_INVARG); + io = gv ? GvIOn(gv) : NULL; + + 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; } - io = GvIOn(gv); if (IoIFP(io)) do_close(gv, FALSE); @@ -1986,15 +2265,22 @@ PP(pp_socket) fd = PerlSock_socket(domain, type, protocol); if (fd < 0) RETPUSHUNDEF; - IoIFP(io) = PerlIO_fdopen(fd, "r"); /* stdio gets confused about sockets */ - IoOFP(io) = PerlIO_fdopen(fd, "w"); - IoTYPE(io) = 's'; + IoIFP(io) = PerlIO_fdopen(fd, "r"PIPESOCK_MODE); /* stdio gets confused about sockets */ + IoOFP(io) = PerlIO_fdopen(fd, "w"PIPESOCK_MODE); + IoTYPE(io) = IoTYPE_SOCKET; 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) + fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */ +#endif + +#ifdef EPOC + setbuf( IoIFP(io), NULL); /* EPOC gets confused about sockets */ +#endif RETPUSHYES; #else @@ -2004,8 +2290,8 @@ PP(pp_socket) PP(pp_sockpair) { - djSP; -#ifdef HAS_SOCKETPAIR +#if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET)) + dSP; GV *gv1; GV *gv2; register IO *io1; @@ -2017,11 +2303,22 @@ PP(pp_sockpair) gv2 = (GV*)POPs; gv1 = (GV*)POPs; - if (!gv1 || !gv2) + io1 = gv1 ? GvIOn(gv1) : NULL; + io2 = gv2 ? GvIOn(gv2) : NULL; + 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; + } - io1 = GvIOn(gv1); - io2 = GvIOn(gv2); if (IoIFP(io1)) do_close(gv1, FALSE); if (IoIFP(io2)) @@ -2030,12 +2327,12 @@ PP(pp_sockpair) TAINT_PROPER("socketpair"); if (PerlSock_socketpair(domain, type, protocol, fd) < 0) RETPUSHUNDEF; - IoIFP(io1) = PerlIO_fdopen(fd[0], "r"); - IoOFP(io1) = PerlIO_fdopen(fd[0], "w"); - IoTYPE(io1) = 's'; - IoIFP(io2) = PerlIO_fdopen(fd[1], "r"); - IoOFP(io2) = PerlIO_fdopen(fd[1], "w"); - IoTYPE(io2) = 's'; + IoIFP(io1) = PerlIO_fdopen(fd[0], "r"PIPESOCK_MODE); + IoOFP(io1) = PerlIO_fdopen(fd[0], "w"PIPESOCK_MODE); + IoTYPE(io1) = IoTYPE_SOCKET; + IoIFP(io2) = PerlIO_fdopen(fd[1], "r"PIPESOCK_MODE); + IoOFP(io2) = PerlIO_fdopen(fd[1], "w"PIPESOCK_MODE); + IoTYPE(io2) = IoTYPE_SOCKET; if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) { if (IoIFP(io1)) PerlIO_close(IoIFP(io1)); if (IoOFP(io1)) PerlIO_close(IoOFP(io1)); @@ -2045,6 +2342,10 @@ PP(pp_sockpair) if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]); RETPUSHUNDEF; } +#if defined(HAS_FCNTL) && defined(F_SETFD) + fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd); /* ensure close-on-exec */ + fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd); /* ensure close-on-exec */ +#endif RETPUSHYES; #else @@ -2054,11 +2355,11 @@ PP(pp_sockpair) PP(pp_bind) { - djSP; #ifdef HAS_SOCKET + dSP; #ifdef MPE /* Requires PRIV mode to bind() to ports < 1024 */ - extern GETPRIVMODE(); - extern GETUSERMODE(); + extern void GETPRIVMODE(); + extern void GETUSERMODE(); #endif SV *addrsv = POPs; char *addr; @@ -2103,8 +2404,8 @@ PP(pp_bind) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "bind() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,SS_IVCHAN); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "bind"); @@ -2113,8 +2414,8 @@ nuts: PP(pp_connect) { - djSP; #ifdef HAS_SOCKET + dSP; SV *addrsv = POPs; char *addr; GV *gv = (GV*)POPs; @@ -2133,8 +2434,8 @@ PP(pp_connect) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "connect() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,SS_IVCHAN); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "connect"); @@ -2143,13 +2444,13 @@ nuts: PP(pp_listen) { - djSP; #ifdef HAS_SOCKET + dSP; int backlog = POPi; GV *gv = (GV*)POPs; - register IO *io = GvIOn(gv); + register IO *io = gv ? GvIOn(gv) : NULL; - if (!io || !IoIFP(io)) + if (!gv || !io || !IoIFP(io)) goto nuts; if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0) @@ -2159,8 +2460,8 @@ PP(pp_listen) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "listen() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,SS_IVCHAN); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "listen"); @@ -2169,8 +2470,8 @@ nuts: PP(pp_accept) { - djSP; dTARGET; #ifdef HAS_SOCKET + dSP; dTARGET; GV *ngv; GV *ggv; register IO *nstio; @@ -2192,29 +2493,36 @@ PP(pp_accept) goto nuts; nstio = GvIOn(ngv); - if (IoIFP(nstio)) - do_close(ngv, FALSE); - fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *)&saddr, &len); if (fd < 0) goto badexit; - IoIFP(nstio) = PerlIO_fdopen(fd, "r"); - IoOFP(nstio) = PerlIO_fdopen(fd, "w"); - IoTYPE(nstio) = 's'; + if (IoIFP(nstio)) + do_close(ngv, FALSE); + IoIFP(nstio) = PerlIO_fdopen(fd, "r"PIPESOCK_MODE); + IoOFP(nstio) = PerlIO_fdopen(fd, "w"PIPESOCK_MODE); + IoTYPE(nstio) = IoTYPE_SOCKET; 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) + fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */ +#endif + +#ifdef EPOC + len = sizeof saddr; /* EPOC somehow truncates info */ + setbuf( IoIFP(nstio), NULL); /* EPOC gets confused about sockets */ +#endif PUSHp((char *)&saddr, len); RETURN; nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "accept() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(ggv, ggv ? GvIO(ggv) : 0, PL_op->op_type); + SETERRNO(EBADF,SS_IVCHAN); badexit: RETPUSHUNDEF; @@ -2226,8 +2534,8 @@ badexit: PP(pp_shutdown) { - djSP; dTARGET; #ifdef HAS_SOCKET + dSP; dTARGET; int how = POPi; GV *gv = (GV*)POPs; register IO *io = GvIOn(gv); @@ -2240,8 +2548,8 @@ PP(pp_shutdown) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "shutdown() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, PL_op->op_type); + SETERRNO(EBADF,SS_IVCHAN); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_sock_func, "shutdown"); @@ -2259,8 +2567,8 @@ PP(pp_gsockopt) PP(pp_ssockopt) { - djSP; #ifdef HAS_SOCKET + dSP; int optype = PL_op->op_type; SV *sv; int fd; @@ -2319,8 +2627,8 @@ PP(pp_ssockopt) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "[gs]etsockopt() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, optype); + SETERRNO(EBADF,SS_IVCHAN); nuts2: RETPUSHUNDEF; @@ -2340,8 +2648,8 @@ PP(pp_getsockname) PP(pp_getpeername) { - djSP; #ifdef HAS_SOCKET + dSP; int optype = PL_op->op_type; SV *sv; int fd; @@ -2373,7 +2681,7 @@ PP(pp_getpeername) if (((struct sockaddr *)SvPVX(sv))->sa_family == AF_INET && !memcmp((char *)SvPVX(sv) + sizeof(u_short), nowhere, sizeof(u_short) + sizeof(struct in_addr))) { - goto nuts2; + goto nuts2; } } #endif @@ -2392,8 +2700,8 @@ PP(pp_getpeername) nuts: if (ckWARN(WARN_CLOSED)) - Perl_warner(aTHX_ WARN_CLOSED, "get{sock, peer}name() on closed fd"); - SETERRNO(EBADF,SS$_IVCHAN); + report_evil_fh(gv, io, optype); + SETERRNO(EBADF,SS_IVCHAN); nuts2: RETPUSHUNDEF; @@ -2411,33 +2719,48 @@ PP(pp_lstat) PP(pp_stat) { - djSP; - GV *tmpgv; + dSP; + GV *gv; I32 gimme; I32 max = 13; STRLEN n_a; if (PL_op->op_flags & OPf_REF) { - tmpgv = cGVOP->op_gv; + gv = cGVOP_gv; + if (PL_op->op_type == OP_LSTAT) { + if (gv != PL_defgv) { + if (ckWARN(WARN_IO)) + Perl_warner(aTHX_ packWARN(WARN_IO), + "lstat() on filehandle %s", GvENAME(gv)); + } else if (PL_laststype != OP_LSTAT) + Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat"); + } + do_fstat: - if (tmpgv != PL_defgv) { + if (gv != PL_defgv) { PL_laststype = OP_STAT; - PL_statgv = tmpgv; + PL_statgv = gv; sv_setpv(PL_statname, ""); - PL_laststatval = (GvIO(tmpgv) && IoIFP(GvIOp(tmpgv)) - ? PerlLIO_fstat(PerlIO_fileno(IoIFP(GvIOn(tmpgv))), &PL_statcache) : -1); + PL_laststatval = (GvIO(gv) && IoIFP(GvIOp(gv)) + ? PerlLIO_fstat(PerlIO_fileno(IoIFP(GvIOn(gv))), &PL_statcache) : -1); } - if (PL_laststatval < 0) + if (PL_laststatval < 0) { + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) + report_evil_fh(gv, GvIO(gv), PL_op->op_type); max = 0; + } } else { SV* sv = POPs; if (SvTYPE(sv) == SVt_PVGV) { - tmpgv = (GV*)sv; + gv = (GV*)sv; goto do_fstat; } else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV) { - tmpgv = (GV*)SvRV(sv); + gv = (GV*)SvRV(sv); + if (PL_op->op_type == OP_LSTAT && ckWARN(WARN_IO)) + Perl_warner(aTHX_ packWARN(WARN_IO), + "lstat() on filehandle %s", GvENAME(gv)); goto do_fstat; } sv_setpv(PL_statname, SvPV(sv,n_a)); @@ -2451,7 +2774,7 @@ PP(pp_stat) PL_laststatval = PerlLIO_stat(SvPV(PL_statname, n_a), &PL_statcache); if (PL_laststatval < 0) { if (ckWARN(WARN_NEWLINE) && strchr(SvPV(PL_statname, n_a), '\n')) - Perl_warner(aTHX_ WARN_NEWLINE, PL_warn_nl, "stat"); + Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat"); max = 0; } } @@ -2465,30 +2788,50 @@ PP(pp_stat) if (max) { EXTEND(SP, max); EXTEND_MORTAL(max); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_dev))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_ino))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_mode))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_nlink))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_uid))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_gid))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_dev))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_ino))); + PUSHs(sv_2mortal(newSVuv(PL_statcache.st_mode))); + 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 + 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 + PUSHs(sv_2mortal(newSVuv(PL_statcache.st_gid))); +# endif +#endif #ifdef USE_STAT_RDEV - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_rdev))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_rdev))); #else PUSHs(sv_2mortal(newSVpvn("", 0))); #endif - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_size))); +#if Off_t_size > IVSIZE + 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((U32)PL_statcache.st_atime))); - PUSHs(sv_2mortal(newSVnv((U32)PL_statcache.st_mtime))); - PUSHs(sv_2mortal(newSVnv((U32)PL_statcache.st_ctime))); + 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 - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_atime))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_mtime))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_ctime))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_atime))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_mtime))); + PUSHs(sv_2mortal(newSViv(PL_statcache.st_ctime))); #endif #ifdef USE_STAT_BLOCKS - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_blksize))); - PUSHs(sv_2mortal(newSViv((I32)PL_statcache.st_blocks))); + PUSHs(sv_2mortal(newSVuv(PL_statcache.st_blksize))); + PUSHs(sv_2mortal(newSVuv(PL_statcache.st_blocks))); #else PUSHs(sv_2mortal(newSVpvn("", 0))); PUSHs(sv_2mortal(newSVpvn("", 0))); @@ -2500,7 +2843,7 @@ PP(pp_stat) PP(pp_ftrread) { I32 result; - djSP; + dSP; #if defined(HAS_ACCESS) && defined(R_OK) STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2527,7 +2870,7 @@ PP(pp_ftrread) PP(pp_ftrwrite) { I32 result; - djSP; + dSP; #if defined(HAS_ACCESS) && defined(W_OK) STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2554,7 +2897,7 @@ PP(pp_ftrwrite) PP(pp_ftrexec) { I32 result; - djSP; + dSP; #if defined(HAS_ACCESS) && defined(X_OK) STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2581,7 +2924,7 @@ PP(pp_ftrexec) PP(pp_fteread) { I32 result; - djSP; + dSP; #ifdef PERL_EFF_ACCESS_R_OK STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2608,7 +2951,7 @@ PP(pp_fteread) PP(pp_ftewrite) { I32 result; - djSP; + dSP; #ifdef PERL_EFF_ACCESS_W_OK STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2635,7 +2978,7 @@ PP(pp_ftewrite) PP(pp_fteexec) { I32 result; - djSP; + dSP; #ifdef PERL_EFF_ACCESS_X_OK STRLEN n_a; if ((PL_hints & HINT_FILETEST_ACCESS) && SvPOK(TOPs)) { @@ -2662,7 +3005,7 @@ PP(pp_fteexec) PP(pp_ftis) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; RETPUSHYES; @@ -2676,10 +3019,11 @@ PP(pp_fteowned) PP(pp_ftrowned) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; - if (PL_statcache.st_uid == (PL_op->op_type == OP_FTEOWNED ? PL_euid : PL_uid) ) + if (PL_statcache.st_uid == (PL_op->op_type == OP_FTEOWNED ? + PL_euid : PL_uid) ) RETPUSHYES; RETPUSHNO; } @@ -2687,10 +3031,10 @@ PP(pp_ftrowned) PP(pp_ftzero) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; - if (!PL_statcache.st_size) + if (PL_statcache.st_size == 0) RETPUSHYES; RETPUSHNO; } @@ -2698,47 +3042,51 @@ PP(pp_ftzero) PP(pp_ftsize) { I32 result = my_stat(); - djSP; dTARGET; + dSP; dTARGET; if (result < 0) RETPUSHUNDEF; +#if Off_t_size > IVSIZE + PUSHn(PL_statcache.st_size); +#else PUSHi(PL_statcache.st_size); +#endif RETURN; } PP(pp_ftmtime) { I32 result = my_stat(); - djSP; dTARGET; + dSP; dTARGET; if (result < 0) RETPUSHUNDEF; - PUSHn( ((I32)PL_basetime - (I32)PL_statcache.st_mtime) / 86400.0 ); + PUSHn( (PL_basetime - PL_statcache.st_mtime) / 86400.0 ); RETURN; } PP(pp_ftatime) { I32 result = my_stat(); - djSP; dTARGET; + dSP; dTARGET; if (result < 0) RETPUSHUNDEF; - PUSHn( ((I32)PL_basetime - (I32)PL_statcache.st_atime) / 86400.0 ); + PUSHn( (PL_basetime - PL_statcache.st_atime) / 86400.0 ); RETURN; } PP(pp_ftctime) { I32 result = my_stat(); - djSP; dTARGET; + dSP; dTARGET; if (result < 0) RETPUSHUNDEF; - PUSHn( ((I32)PL_basetime - (I32)PL_statcache.st_ctime) / 86400.0 ); + PUSHn( (PL_basetime - PL_statcache.st_ctime) / 86400.0 ); RETURN; } PP(pp_ftsock) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISSOCK(PL_statcache.st_mode)) @@ -2749,7 +3097,7 @@ PP(pp_ftsock) PP(pp_ftchr) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISCHR(PL_statcache.st_mode)) @@ -2760,7 +3108,7 @@ PP(pp_ftchr) PP(pp_ftblk) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISBLK(PL_statcache.st_mode)) @@ -2771,7 +3119,7 @@ PP(pp_ftblk) PP(pp_ftfile) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISREG(PL_statcache.st_mode)) @@ -2782,7 +3130,7 @@ PP(pp_ftfile) PP(pp_ftdir) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISDIR(PL_statcache.st_mode)) @@ -2793,7 +3141,7 @@ PP(pp_ftdir) PP(pp_ftpipe) { I32 result = my_stat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISFIFO(PL_statcache.st_mode)) @@ -2804,7 +3152,7 @@ PP(pp_ftpipe) PP(pp_ftlink) { I32 result = my_lstat(); - djSP; + dSP; if (result < 0) RETPUSHUNDEF; if (S_ISLNK(PL_statcache.st_mode)) @@ -2814,7 +3162,7 @@ PP(pp_ftlink) PP(pp_ftsuid) { - djSP; + dSP; #ifdef S_ISUID I32 result = my_stat(); SPAGAIN; @@ -2828,7 +3176,7 @@ PP(pp_ftsuid) PP(pp_ftsgid) { - djSP; + dSP; #ifdef S_ISGID I32 result = my_stat(); SPAGAIN; @@ -2842,7 +3190,7 @@ PP(pp_ftsgid) PP(pp_ftsvtx) { - djSP; + dSP; #ifdef S_ISVTX I32 result = my_stat(); SPAGAIN; @@ -2856,14 +3204,14 @@ PP(pp_ftsvtx) PP(pp_fttty) { - djSP; + dSP; int fd; GV *gv; char *tmps = Nullch; STRLEN n_a; if (PL_op->op_flags & OPf_REF) - gv = cGVOP->op_gv; + gv = cGVOP_gv; else if (isGV(TOPs)) gv = (GV*)POPs; else if (SvROK(TOPs) && isGV(SvRV(TOPs))) @@ -2892,7 +3240,7 @@ PP(pp_fttty) PP(pp_fttext) { - djSP; + dSP; I32 i; I32 len; I32 odd = 0; @@ -2902,9 +3250,10 @@ PP(pp_fttext) register SV *sv; GV *gv; STRLEN n_a; + PerlIO *fp; if (PL_op->op_flags & OPf_REF) - gv = cGVOP->op_gv; + gv = cGVOP_gv; else if (isGV(TOPs)) gv = (GV*)POPs; else if (SvROK(TOPs) && isGV(SvRV(TOPs))) @@ -2934,11 +3283,12 @@ PP(pp_fttext) PL_laststatval = PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache); if (PL_laststatval < 0) RETPUSHUNDEF; - if (S_ISDIR(PL_statcache.st_mode)) /* handle NFS glitch */ + if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */ if (PL_op->op_type == OP_FTTEXT) RETPUSHNO; else RETPUSHYES; + } if (PerlIO_get_cnt(IoIFP(io)) <= 0) { i = PerlIO_getc(IoIFP(io)); if (i != EOF) @@ -2953,10 +3303,11 @@ PP(pp_fttext) len = 512; } else { - if (ckWARN(WARN_UNOPENED)) - Perl_warner(aTHX_ WARN_UNOPENED, "Test on unopened file <%s>", - GvENAME(cGVOP->op_gv)); - SETERRNO(EBADF,RMS$_IFI); + if (ckWARN2(WARN_UNOPENED,WARN_CLOSED)) { + gv = cGVOP_gv; + report_evil_fh(gv, GvIO(gv), PL_op->op_type); + } + SETERRNO(EBADF,RMS_IFI); RETPUSHUNDEF; } } @@ -2965,22 +3316,21 @@ PP(pp_fttext) really_filename: PL_statgv = Nullgv; PL_laststatval = -1; + PL_laststype = OP_STAT; sv_setpv(PL_statname, SvPV(sv, n_a)); -#ifdef HAS_OPEN3 - i = PerlLIO_open3(SvPV(sv, n_a), O_RDONLY, 0); -#else - i = PerlLIO_open(SvPV(sv, n_a), 0); -#endif - if (i < 0) { + if (!(fp = PerlIO_open(SvPVX(PL_statname), "r"))) { if (ckWARN(WARN_NEWLINE) && strchr(SvPV(sv, n_a), '\n')) - Perl_warner(aTHX_ WARN_NEWLINE, PL_warn_nl, "open"); + Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open"); RETPUSHUNDEF; } - PL_laststatval = PerlLIO_fstat(i, &PL_statcache); - if (PL_laststatval < 0) + PL_laststatval = PerlLIO_fstat(PerlIO_fileno(fp), &PL_statcache); + if (PL_laststatval < 0) { + (void)PerlIO_close(fp); RETPUSHUNDEF; - len = PerlLIO_read(i, tbuf, 512); - (void)PerlLIO_close(i); + } + PerlIO_binmode(aTHX_ fp, '<', O_BINARY, Nullch); + len = PerlIO_read(fp, tbuf, sizeof(tbuf)); + (void)PerlIO_close(fp); if (len <= 0) { if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT) RETPUSHNO; /* special case NFS directories */ @@ -2992,17 +3342,44 @@ PP(pp_fttext) /* 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 + for (i = 0; i < len; i++, s++) { if (!*s) { /* null never allowed in text */ odd += len; break; } #ifdef EBCDIC - else if (!(isPRINT(*s) || isSPACE(*s))) + else if (!(isPRINT(*s) || isSPACE(*s))) odd++; #else - else if (*s & 128) + 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++; + } else if (*s < 32 && *s != '\n' && *s != '\r' && *s != '\b' && *s != '\t' && *s != '\f' && *s != 27) @@ -3025,32 +3402,35 @@ PP(pp_ftbinary) PP(pp_chdir) { - djSP; dTARGET; + dSP; dTARGET; char *tmps; SV **svp; STRLEN n_a; - if (MAXARG < 1) - tmps = Nullch; + if( MAXARG == 1 ) + tmps = POPpx; else - tmps = POPpx; - if (!tmps || !*tmps) { - svp = hv_fetch(GvHVn(PL_envgv), "HOME", 4, FALSE); - if (svp) - tmps = SvPV(*svp, n_a); - } - if (!tmps || !*tmps) { - svp = hv_fetch(GvHVn(PL_envgv), "LOGDIR", 6, FALSE); - if (svp) - tmps = SvPV(*svp, n_a); - } + tmps = 0; + + if( !tmps || !*tmps ) { + if ( (svp = hv_fetch(GvHVn(PL_envgv), "HOME", 4, FALSE)) + || (svp = hv_fetch(GvHVn(PL_envgv), "LOGDIR", 6, FALSE)) #ifdef VMS - if (!tmps || !*tmps) { - svp = hv_fetch(GvHVn(PL_envgv), "SYS$LOGIN", 9, FALSE); - if (svp) - tmps = SvPV(*svp, n_a); - } + || (svp = hv_fetch(GvHVn(PL_envgv), "SYS$LOGIN", 9, FALSE)) #endif + ) + { + if( MAXARG == 1 ) + deprecate("chdir('') or chdir(undef) as chdir()"); + tmps = SvPV(*svp, n_a); + } + else { + PUSHi(0); + TAINT_PROPER("chdir"); + RETURN; + } + } + TAINT_PROPER("chdir"); PUSHi( PerlDir_chdir(tmps) >= 0 ); #ifdef VMS @@ -3063,25 +3443,24 @@ PP(pp_chdir) PP(pp_chown) { - djSP; dMARK; dTARGET; - I32 value; #ifdef HAS_CHOWN - value = (I32)apply(PL_op->op_type, MARK, SP); + dSP; dMARK; dTARGET; + I32 value = (I32)apply(PL_op->op_type, MARK, SP); + SP = MARK; PUSHi(value); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function chown"); + DIE(aTHX_ PL_no_func, "chown"); #endif } PP(pp_chroot) { - djSP; dTARGET; - char *tmps; #ifdef HAS_CHROOT + dSP; dTARGET; STRLEN n_a; - tmps = POPpx; + char *tmps = POPpx; TAINT_PROPER("chroot"); PUSHi( chroot(tmps) >= 0 ); RETURN; @@ -3092,7 +3471,7 @@ PP(pp_chroot) PP(pp_unlink) { - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value; value = (I32)apply(PL_op->op_type, MARK, SP); SP = MARK; @@ -3102,7 +3481,7 @@ PP(pp_unlink) PP(pp_chmod) { - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value; value = (I32)apply(PL_op->op_type, MARK, SP); SP = MARK; @@ -3112,7 +3491,7 @@ PP(pp_chmod) PP(pp_utime) { - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value; value = (I32)apply(PL_op->op_type, MARK, SP); SP = MARK; @@ -3122,7 +3501,7 @@ PP(pp_utime) PP(pp_rename) { - djSP; dTARGET; + dSP; dTARGET; int anum; STRLEN n_a; @@ -3149,23 +3528,23 @@ PP(pp_rename) PP(pp_link) { - djSP; dTARGET; #ifdef HAS_LINK + dSP; dTARGET; STRLEN n_a; char *tmps2 = POPpx; char *tmps = SvPV(TOPs, n_a); TAINT_PROPER("link"); - SETi( link(tmps, tmps2) >= 0 ); + SETi( PerlLIO_link(tmps, tmps2) >= 0 ); + RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function link"); + DIE(aTHX_ PL_no_func, "link"); #endif - RETURN; } PP(pp_symlink) { - djSP; dTARGET; #ifdef HAS_SYMLINK + dSP; dTARGET; STRLEN n_a; char *tmps2 = POPpx; char *tmps = SvPV(TOPs, n_a); @@ -3179,8 +3558,9 @@ PP(pp_symlink) PP(pp_readlink) { - djSP; dTARGET; + dSP; #ifdef HAS_SYMLINK + dTARGET; char *tmps; char buf[MAXPATHLEN]; int len; @@ -3190,7 +3570,7 @@ PP(pp_readlink) TAINT; #endif tmps = POPpx; - len = readlink(tmps, buf, sizeof buf); + len = readlink(tmps, buf, sizeof(buf) - 1); EXTEND(SP, 1); if (len < 0) RETPUSHUNDEF; @@ -3256,21 +3636,21 @@ S_dooneliner(pTHX_ char *cmd, char *filename) #define EACCES EPERM #endif if (instr(s, "cannot make")) - SETERRNO(EEXIST,RMS$_FEX); + SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "existing file")) - SETERRNO(EEXIST,RMS$_FEX); + SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "ile exists")) - SETERRNO(EEXIST,RMS$_FEX); + SETERRNO(EEXIST,RMS_FEX); else if (instr(s, "non-exist")) - SETERRNO(ENOENT,RMS$_FNF); + SETERRNO(ENOENT,RMS_FNF); else if (instr(s, "does not exist")) - SETERRNO(ENOENT,RMS$_FNF); + SETERRNO(ENOENT,RMS_FNF); else if (instr(s, "not empty")) - SETERRNO(EBUSY,SS$_DEVOFFLINE); + SETERRNO(EBUSY,SS_DEVOFFLINE); else if (instr(s, "cannot access")) - SETERRNO(EACCES,RMS$_PRV); + SETERRNO(EACCES,RMS_PRV); else - SETERRNO(EPERM,RMS$_PRV); + SETERRNO(EPERM,RMS_PRV); return 0; } else { /* some mkdirs return no failure indication */ @@ -3280,7 +3660,7 @@ S_dooneliner(pTHX_ char *cmd, char *filename) if (anum) SETERRNO(0,0); else - SETERRNO(EACCES,RMS$_PRV); /* a guess */ + SETERRNO(EACCES,RMS_PRV); /* a guess */ } return anum; } @@ -3289,15 +3669,43 @@ S_dooneliner(pTHX_ char *cmd, char *filename) } #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(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) { - djSP; dTARGET; - int mode = POPi; + dSP; dTARGET; + int mode; #ifndef HAS_MKDIR int oldumask; #endif - STRLEN n_a; - char *tmps = SvPV(TOPs, n_a); + STRLEN len; + char *tmps; + bool copy = FALSE; + + if (MAXARG > 1) + mode = POPi; + else + mode = 0777; + + TRIMSLASHES(tmps,len,copy); TAINT_PROPER("mkdir"); #ifdef HAS_MKDIR @@ -3308,22 +3716,27 @@ PP(pp_mkdir) PerlLIO_umask(oldumask); PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777); #endif + if (copy) + Safefree(tmps); RETURN; } PP(pp_rmdir) { - djSP; dTARGET; + dSP; dTARGET; + STRLEN len; char *tmps; - STRLEN n_a; + bool copy = FALSE; - tmps = POPpx; + TRIMSLASHES(tmps,len,copy); TAINT_PROPER("rmdir"); #ifdef HAS_RMDIR - XPUSHi( PerlDir_rmdir(tmps) >= 0 ); + SETi( PerlDir_rmdir(tmps) >= 0 ); #else - XPUSHi( dooneliner("rmdir", tmps) ); + SETi( dooneliner("rmdir", tmps) ); #endif + if (copy) + Safefree(tmps); RETURN; } @@ -3331,8 +3744,8 @@ PP(pp_rmdir) PP(pp_open_dir) { - djSP; #if defined(Direntry_t) && defined(HAS_READDIR) + dSP; STRLEN n_a; char *dirname = POPpx; GV *gv = (GV*)POPs; @@ -3349,7 +3762,7 @@ PP(pp_open_dir) RETPUSHYES; nope: if (!errno) - SETERRNO(EBADF,RMS$_DIR); + SETERRNO(EBADF,RMS_DIR); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "opendir"); @@ -3358,9 +3771,9 @@ nope: PP(pp_readdir) { - djSP; #if defined(Direntry_t) && defined(HAS_READDIR) -#ifndef I_DIRENT + dSP; +#if !defined(I_DIRENT) && !defined(VMS) Direntry_t *readdir (DIR *); #endif register Direntry_t *dp; @@ -3373,14 +3786,15 @@ PP(pp_readdir) if (GIMME == G_ARRAY) { /*SUPPRESS 560*/ - while (dp = (Direntry_t *)PerlDir_read(IoDIRP(io))) { + while ((dp = (Direntry_t *)PerlDir_read(IoDIRP(io)))) { #ifdef DIRNAMLEN sv = newSVpvn(dp->d_name, dp->d_namlen); #else sv = newSVpv(dp->d_name, 0); #endif #ifndef INCOMPLETE_TAINTS - SvTAINTED_on(sv); + if (!(IoFLAGS(io) & IOf_UNTAINT)) + SvTAINTED_on(sv); #endif XPUSHs(sv_2mortal(sv)); } @@ -3394,7 +3808,8 @@ PP(pp_readdir) sv = newSVpv(dp->d_name, 0); #endif #ifndef INCOMPLETE_TAINTS - SvTAINTED_on(sv); + if (!(IoFLAGS(io) & IOf_UNTAINT)) + SvTAINTED_on(sv); #endif XPUSHs(sv_2mortal(sv)); } @@ -3402,7 +3817,7 @@ PP(pp_readdir) nope: if (!errno) - SETERRNO(EBADF,RMS$_ISI); + SETERRNO(EBADF,RMS_ISI); if (GIMME == G_ARRAY) RETURN; else @@ -3414,8 +3829,8 @@ nope: PP(pp_telldir) { - djSP; dTARGET; #if defined(HAS_TELLDIR) || defined(telldir) + 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. @@ -3433,7 +3848,7 @@ PP(pp_telldir) RETURN; nope: if (!errno) - SETERRNO(EBADF,RMS$_ISI); + SETERRNO(EBADF,RMS_ISI); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "telldir"); @@ -3442,8 +3857,8 @@ nope: PP(pp_seekdir) { - djSP; #if defined(HAS_SEEKDIR) || defined(seekdir) + dSP; long along = POPl; GV *gv = (GV*)POPs; register IO *io = GvIOn(gv); @@ -3456,7 +3871,7 @@ PP(pp_seekdir) RETPUSHYES; nope: if (!errno) - SETERRNO(EBADF,RMS$_ISI); + SETERRNO(EBADF,RMS_ISI); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "seekdir"); @@ -3465,8 +3880,8 @@ nope: PP(pp_rewinddir) { - djSP; #if defined(HAS_REWINDDIR) || defined(rewinddir) + dSP; GV *gv = (GV*)POPs; register IO *io = GvIOn(gv); @@ -3477,7 +3892,7 @@ PP(pp_rewinddir) RETPUSHYES; nope: if (!errno) - SETERRNO(EBADF,RMS$_ISI); + SETERRNO(EBADF,RMS_ISI); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "rewinddir"); @@ -3486,8 +3901,8 @@ nope: PP(pp_closedir) { - djSP; #if defined(Direntry_t) && defined(HAS_READDIR) + dSP; GV *gv = (GV*)POPs; register IO *io = GvIOn(gv); @@ -3507,7 +3922,7 @@ PP(pp_closedir) RETPUSHYES; nope: if (!errno) - SETERRNO(EBADF,RMS$_IFI); + SETERRNO(EBADF,RMS_IFI); RETPUSHUNDEF; #else DIE(aTHX_ PL_no_dir_func, "closedir"); @@ -3519,175 +3934,252 @@ nope: PP(pp_fork) { #ifdef HAS_FORK - djSP; dTARGET; + dSP; dTARGET; Pid_t childpid; GV *tmpgv; EXTEND(SP, 1); PERL_FLUSHALL_FOR_CHILD; - childpid = fork(); + childpid = PerlProc_fork(); if (childpid < 0) RETSETUNDEF; if (!childpid) { /*SUPPRESS 560*/ - if (tmpgv = gv_fetchpv("$", TRUE, SVt_PV)) - sv_setiv(GvSV(tmpgv), (IV)getpid()); + if ((tmpgv = gv_fetchpv("$", TRUE, SVt_PV))) { + SvREADONLY_off(GvSV(tmpgv)); + sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid()); + SvREADONLY_on(GvSV(tmpgv)); + } +#ifdef THREADS_HAVE_PIDS + PL_ppid = (IV)getppid(); +#endif hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */ } PUSHi(childpid); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function fork"); +# 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) { -#if !defined(DOSISH) || defined(OS2) || defined(WIN32) - djSP; dTARGET; +#if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(MACOS_TRADITIONAL) + dSP; dTARGET; Pid_t childpid; int argflags; - childpid = wait4pid(-1, &argflags, 0); + if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) + childpid = wait4pid(-1, &argflags, 0); + else { + 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 STATUS_NATIVE_SET((childpid > 0) ? argflags : -1); +# endif XPUSHi(childpid); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function wait"); + DIE(aTHX_ PL_no_func, "wait"); #endif } PP(pp_waitpid) { -#if !defined(DOSISH) || defined(OS2) || defined(WIN32) - djSP; dTARGET; +#if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(MACOS_TRADITIONAL) + dSP; dTARGET; Pid_t childpid; int optype; int argflags; optype = POPi; childpid = TOPi; - childpid = wait4pid(childpid, &argflags, optype); + if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) + childpid = wait4pid(childpid, &argflags, optype); + else { + while ((childpid = wait4pid(childpid, &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((childpid && childpid != -1) ? argflags : -1); +# else STATUS_NATIVE_SET((childpid > 0) ? argflags : -1); +# endif SETi(childpid); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function waitpid"); + DIE(aTHX_ PL_no_func, "waitpid"); #endif } PP(pp_system) { - djSP; dMARK; dORIGMARK; dTARGET; + dSP; dMARK; dORIGMARK; dTARGET; I32 value; - Pid_t childpid; - int result; - int status; - Sigsave_t ihand,qhand; /* place to save signals during system() */ STRLEN n_a; + int result; I32 did_pipes = 0; - int pp[2]; - if (SP - MARK == 1) { - if (PL_tainting) { - char *junk = SvPV(TOPs, n_a); - TAINT_ENV(); - TAINT_PROPER("system"); + if (PL_tainting) { + TAINT_ENV(); + while (++MARK <= SP) { + (void)SvPV_nolen(*MARK); /* stringify for taint check */ + if (PL_tainted) + break; } + MARK = ORIGMARK; + TAINT_PROPER("system"); } PERL_FLUSHALL_FOR_CHILD; -#if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) - if (PerlProc_pipe(pp) >= 0) - did_pipes = 1; - while ((childpid = vfork()) == -1) { - if (errno != EAGAIN) { - value = -1; +#if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO) + { + Pid_t childpid; + int pp[2]; + + if (PerlProc_pipe(pp) >= 0) + did_pipes = 1; + while ((childpid = PerlProc_fork()) == -1) { + if (errno != EAGAIN) { + value = -1; + SP = ORIGMARK; + PUSHi(value); + if (did_pipes) { + PerlLIO_close(pp[0]); + PerlLIO_close(pp[1]); + } + RETURN; + } + sleep(5); + } + if (childpid > 0) { + Sigsave_t ihand,qhand; /* place to save signals during system() */ + int status; + + if (did_pipes) + PerlLIO_close(pp[1]); +#ifndef PERL_MICRO + rsignal_save(SIGINT, SIG_IGN, &ihand); + rsignal_save(SIGQUIT, SIG_IGN, &qhand); +#endif + do { + result = wait4pid(childpid, &status, 0); + } while (result == -1 && errno == EINTR); +#ifndef PERL_MICRO + (void)rsignal_restore(SIGINT, &ihand); + (void)rsignal_restore(SIGQUIT, &qhand); +#endif + STATUS_NATIVE_SET(result == -1 ? -1 : status); + do_execfree(); /* free any memory child malloced on fork */ SP = ORIGMARK; - PUSHi(value); if (did_pipes) { + int errkid; + int n = 0, n1; + + while (n < sizeof(int)) { + n1 = PerlLIO_read(pp[0], + (void*)(((char*)&errkid)+n), + (sizeof(int)) - n); + if (n1 <= 0) + break; + n += n1; + } PerlLIO_close(pp[0]); - PerlLIO_close(pp[1]); + if (n) { /* Error */ + if (n != sizeof(int)) + DIE(aTHX_ "panic: kid popen errno read"); + errno = errkid; /* Propagate errno from kid */ + STATUS_CURRENT = -1; + } } + PUSHi(STATUS_CURRENT); RETURN; } - sleep(5); - } - if (childpid > 0) { - if (did_pipes) - PerlLIO_close(pp[1]); - rsignal_save(SIGINT, SIG_IGN, &ihand); - rsignal_save(SIGQUIT, SIG_IGN, &qhand); - do { - result = wait4pid(childpid, &status, 0); - } while (result == -1 && errno == EINTR); - (void)rsignal_restore(SIGINT, &ihand); - (void)rsignal_restore(SIGQUIT, &qhand); - STATUS_NATIVE_SET(result == -1 ? -1 : status); - do_execfree(); /* free any memory child malloced on vfork */ - SP = ORIGMARK; if (did_pipes) { - int errkid; - int n = 0, n1; - - while (n < sizeof(int)) { - n1 = PerlLIO_read(pp[0], - (void*)(((char*)&errkid)+n), - (sizeof(int)) - n); - if (n1 <= 0) - break; - n += n1; - } PerlLIO_close(pp[0]); - if (n) { /* Error */ - if (n != sizeof(int)) - Perl_croak(aTHX_ "panic: kid popen errno read"); - errno = errkid; /* Propagate errno from kid */ - STATUS_CURRENT = -1; - } - } - PUSHi(STATUS_CURRENT); - RETURN; - } - if (did_pipes) { - PerlLIO_close(pp[0]); #if defined(HAS_FCNTL) && defined(F_SETFD) - fcntl(pp[1], F_SETFD, FD_CLOEXEC); + fcntl(pp[1], F_SETFD, FD_CLOEXEC); #endif + } + if (PL_op->op_flags & OPf_STACKED) { + SV *really = *++MARK; + value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes); + } + else if (SP - MARK != 1) + value = (I32)do_aexec5(Nullsv, MARK, SP, pp[1], did_pipes); + else { + value = (I32)do_exec3(SvPVx(sv_mortalcopy(*SP), n_a), pp[1], did_pipes); + } + PerlProc__exit(-1); } - if (PL_op->op_flags & OPf_STACKED) { - SV *really = *++MARK; - value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes); - } - else if (SP - MARK != 1) - value = (I32)do_aexec5(Nullsv, MARK, SP, pp[1], did_pipes); - else { - value = (I32)do_exec3(SvPVx(sv_mortalcopy(*SP), n_a), pp[1], did_pipes); - } - PerlProc__exit(-1); #else /* ! FORK or VMS or OS/2 */ + PL_statusvalue = 0; + result = 0; if (PL_op->op_flags & OPf_STACKED) { SV *really = *++MARK; +# ifdef WIN32 + value = (I32)do_aspawn(really, MARK, SP); +# else value = (I32)do_aspawn(really, (void **)MARK, (void **)SP); +# endif } - else if (SP - MARK != 1) + else if (SP - MARK != 1) { +# ifdef WIN32 + value = (I32)do_aspawn(Nullsv, MARK, SP); +# else value = (I32)do_aspawn(Nullsv, (void **)MARK, (void **)SP); +# endif + } else { value = (I32)do_spawn(SvPVx(sv_mortalcopy(*SP), n_a)); } + if (PL_statusvalue == -1) /* hint that value must be returned as is */ + result = 1; STATUS_NATIVE_SET(value); do_execfree(); SP = ORIGMARK; - PUSHi(STATUS_CURRENT); + PUSHi(result ? value : STATUS_CURRENT); #endif /* !FORK or VMS */ RETURN; } PP(pp_exec) { - djSP; dMARK; dORIGMARK; dTARGET; + dSP; dMARK; dORIGMARK; dTARGET; I32 value; STRLEN n_a; + if (PL_tainting) { + TAINT_ENV(); + while (++MARK <= SP) { + (void)SvPV_nolen(*MARK); /* stringify for taint check */ + if (PL_tainted) + break; + } + MARK = ORIGMARK; + TAINT_PROPER("exec"); + } PERL_FLUSHALL_FOR_CHILD; if (PL_op->op_flags & OPf_STACKED) { SV *really = *++MARK; @@ -3707,11 +4199,6 @@ PP(pp_exec) # endif #endif else { - if (PL_tainting) { - char *junk = SvPV(*SP, n_a); - TAINT_ENV(); - TAINT_PROPER("exec"); - } #ifdef VMS value = (I32)vms_do_exec(SvPVx(sv_mortalcopy(*SP), n_a)); #else @@ -3723,6 +4210,7 @@ PP(pp_exec) # endif #endif } + SP = ORIGMARK; PUSHi(value); RETURN; @@ -3730,23 +4218,27 @@ PP(pp_exec) PP(pp_kill) { - djSP; dMARK; dTARGET; - I32 value; #ifdef HAS_KILL + dSP; dMARK; dTARGET; + I32 value; value = (I32)apply(PL_op->op_type, MARK, SP); SP = MARK; PUSHi(value); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function kill"); + DIE(aTHX_ PL_no_func, "kill"); #endif } PP(pp_getppid) { #ifdef HAS_GETPPID - djSP; dTARGET; + dSP; dTARGET; +# ifdef THREADS_HAVE_PIDS + XPUSHi( PL_ppid ); +# else XPUSHi( getppid() ); +# endif RETURN; #else DIE(aTHX_ PL_no_func, "getppid"); @@ -3756,22 +4248,22 @@ PP(pp_getppid) PP(pp_getpgrp) { #ifdef HAS_GETPGRP - djSP; dTARGET; - int pid; - I32 value; + dSP; dTARGET; + Pid_t pid; + Pid_t pgrp; if (MAXARG < 1) pid = 0; else pid = SvIVx(POPs); #ifdef BSD_GETPGRP - value = (I32)BSD_GETPGRP(pid); + pgrp = (I32)BSD_GETPGRP(pid); #else - if (pid != 0 && pid != getpid()) + if (pid != 0 && pid != PerlProc_getpid()) DIE(aTHX_ "POSIX getpgrp can't take an argument"); - value = (I32)getpgrp(); + pgrp = getpgrp(); #endif - XPUSHi(value); + XPUSHi(pgrp); RETURN; #else DIE(aTHX_ PL_no_func, "getpgrp()"); @@ -3781,9 +4273,9 @@ PP(pp_getpgrp) PP(pp_setpgrp) { #ifdef HAS_SETPGRP - djSP; dTARGET; - int pgrp; - int pid; + dSP; dTARGET; + Pid_t pgrp; + Pid_t pid; if (MAXARG < 2) { pgrp = 0; pid = 0; @@ -3797,8 +4289,11 @@ PP(pp_setpgrp) #ifdef BSD_SETPGRP SETi( BSD_SETPGRP(pid, pgrp) >= 0 ); #else - if ((pgrp != 0 && pgrp != getpid()) || (pid != 0 && pid != getpid())) - DIE(aTHX_ "POSIX setpgrp can't take an argument"); + if ((pgrp != 0 && pgrp != PerlProc_getpid()) + || (pid != 0 && pid != PerlProc_getpid())) + { + DIE(aTHX_ "setpgrp can't take arguments"); + } SETi( setpgrp() >= 0 ); #endif /* USE_BSDPGRP */ RETURN; @@ -3809,12 +4304,10 @@ PP(pp_setpgrp) PP(pp_getpriority) { - djSP; dTARGET; - int which; - int who; #ifdef HAS_GETPRIORITY - who = POPi; - which = TOPi; + dSP; dTARGET; + int who = POPi; + int which = TOPi; SETi( getpriority(which, who) ); RETURN; #else @@ -3824,14 +4317,11 @@ PP(pp_getpriority) PP(pp_setpriority) { - djSP; dTARGET; - int which; - int who; - int niceval; #ifdef HAS_SETPRIORITY - niceval = POPi; - who = POPi; - which = TOPi; + dSP; dTARGET; + int niceval = POPi; + int who = POPi; + int which = TOPi; TAINT_PROPER("setpriority"); SETi( setpriority(which, who, niceval) >= 0 ); RETURN; @@ -3844,7 +4334,7 @@ PP(pp_setpriority) PP(pp_time) { - djSP; dTARGET; + dSP; dTARGET; #ifdef BIG_TIME XPUSHn( time(Null(Time_t*)) ); #else @@ -3853,31 +4343,11 @@ PP(pp_time) RETURN; } -/* XXX The POSIX name is CLK_TCK; it is to be preferred - to HZ. Probably. For now, assume that if the system - defines HZ, it does so correctly. (Will this break - on VMS?) - Probably we ought to use _sysconf(_SC_CLK_TCK), if - it's supported. --AD 9/96. -*/ - -#ifndef HZ -# ifdef CLK_TCK -# define HZ CLK_TCK -# else -# define HZ 60 -# endif -#endif - PP(pp_tms) { - djSP; - -#ifndef HAS_TIMES - DIE(aTHX_ "times not implemented"); -#else +#ifdef HAS_TIMES + dSP; EXTEND(SP, 4); - #ifndef VMS (void)PerlProc_times(&PL_timesbuf); #else @@ -3886,13 +4356,15 @@ PP(pp_tms) /* is returned. */ #endif - PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_utime)/HZ))); + PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_utime)/(NV)PL_clocktick))); if (GIMME == G_ARRAY) { - PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_stime)/HZ))); - PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_cutime)/HZ))); - PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_cstime)/HZ))); + PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_stime)/(NV)PL_clocktick))); + PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_cutime)/(NV)PL_clocktick))); + PUSHs(sv_2mortal(newSVnv(((NV)PL_timesbuf.tms_cstime)/(NV)PL_clocktick))); } RETURN; +#else + DIE(aTHX_ "times not implemented"); #endif /* HAS_TIMES */ } @@ -3903,7 +4375,7 @@ PP(pp_localtime) PP(pp_gmtime) { - djSP; + dSP; Time_t when; struct tm *tmbuf; static char *dayname[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"}; @@ -3924,57 +4396,58 @@ PP(pp_gmtime) else tmbuf = gmtime(&when); - EXTEND(SP, 9); - EXTEND_MORTAL(9); if (GIMME != G_ARRAY) { - dTARGET; SV *tsv; + EXTEND(SP, 1); + EXTEND_MORTAL(1); if (!tmbuf) RETPUSHUNDEF; tsv = Perl_newSVpvf(aTHX_ "%s %s %2d %02d:%02d:%02d %d", - dayname[tmbuf->tm_wday], - monname[tmbuf->tm_mon], - tmbuf->tm_mday, - tmbuf->tm_hour, - tmbuf->tm_min, - tmbuf->tm_sec, - tmbuf->tm_year + 1900); + dayname[tmbuf->tm_wday], + monname[tmbuf->tm_mon], + tmbuf->tm_mday, + tmbuf->tm_hour, + tmbuf->tm_min, + tmbuf->tm_sec, + tmbuf->tm_year + 1900); PUSHs(sv_2mortal(tsv)); } else if (tmbuf) { - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_sec))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_min))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_hour))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_mday))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_mon))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_year))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_wday))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_yday))); - PUSHs(sv_2mortal(newSViv((I32)tmbuf->tm_isdst))); + EXTEND(SP, 9); + EXTEND_MORTAL(9); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_sec))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_min))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_hour))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_mday))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_mon))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_year))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_wday))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_yday))); + PUSHs(sv_2mortal(newSViv(tmbuf->tm_isdst))); } RETURN; } PP(pp_alarm) { - djSP; dTARGET; - int anum; #ifdef HAS_ALARM + dSP; dTARGET; + int anum; anum = POPi; anum = alarm((unsigned int)anum); EXTEND(SP, 1); if (anum < 0) RETPUSHUNDEF; - PUSHi((I32)anum); + PUSHi(anum); RETURN; #else - DIE(aTHX_ PL_no_func, "Unsupported function alarm"); + DIE(aTHX_ PL_no_func, "alarm"); #endif } PP(pp_sleep) { - djSP; dTARGET; + dSP; dTARGET; I32 duration; Time_t lasttime; Time_t when; @@ -4011,7 +4484,7 @@ PP(pp_shmread) PP(pp_shmwrite) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value = (I32)(do_shmio(PL_op->op_type, MARK, SP) >= 0); SP = MARK; PUSHi(value); @@ -4036,7 +4509,7 @@ PP(pp_msgctl) PP(pp_msgsnd) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value = (I32)(do_msgsnd(MARK, SP) >= 0); SP = MARK; PUSHi(value); @@ -4049,7 +4522,7 @@ PP(pp_msgsnd) PP(pp_msgrcv) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value = (I32)(do_msgrcv(MARK, SP) >= 0); SP = MARK; PUSHi(value); @@ -4064,7 +4537,7 @@ PP(pp_msgrcv) PP(pp_semget) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; int anum = do_ipcget(PL_op->op_type, MARK, SP); SP = MARK; if (anum == -1) @@ -4079,7 +4552,7 @@ PP(pp_semget) PP(pp_semctl) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; int anum = do_ipcctl(PL_op->op_type, MARK, SP); SP = MARK; if (anum == -1) @@ -4099,7 +4572,7 @@ PP(pp_semctl) PP(pp_semop) { #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) - djSP; dMARK; dTARGET; + dSP; dMARK; dTARGET; I32 value = (I32)(do_semop(MARK, SP) >= 0); SP = MARK; PUSHi(value); @@ -4131,33 +4604,35 @@ PP(pp_ghbyaddr) PP(pp_ghostent) { - djSP; #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT) + dSP; I32 which = PL_op->op_type; register char **elem; register SV *sv; #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */ - struct hostent *PerlSock_gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int); - struct hostent *PerlSock_gethostbyname(Netdb_name_t); - struct hostent *PerlSock_gethostent(void); + struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int); + struct hostent *gethostbyname(Netdb_name_t); + struct hostent *gethostent(void); #endif struct hostent *hent; unsigned long len; STRLEN n_a; EXTEND(SP, 10); - if (which == OP_GHBYNAME) + if (which == OP_GHBYNAME) { #ifdef HAS_GETHOSTBYNAME - hent = PerlSock_gethostbyname(POPpx); + char* name = POPpbytex; + hent = PerlSock_gethostbyname(name); #else DIE(aTHX_ PL_no_sock_func, "gethostbyname"); #endif + } else if (which == OP_GHBYADDR) { #ifdef HAS_GETHOSTBYADDR int addrtype = POPi; SV *addrsv = POPs; STRLEN addrlen; - Netdb_host_t addr = (Netdb_host_t) SvPV(addrsv, addrlen); + Netdb_host_t addr = (Netdb_host_t) SvPVbyte(addrsv, addrlen); hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype); #else @@ -4172,8 +4647,14 @@ PP(pp_ghostent) #endif #ifdef HOST_NOT_FOUND - if (!hent) - STATUS_NATIVE_SET(h_errno); + if (!hent) { +#ifdef USE_REENTRANT_API +# ifdef USE_GETHOSTENT_ERRNO + h_errno = PL_reentrant_buffer->_gethostent_errno; +# endif +#endif + STATUS_NATIVE_SET(h_errno); + } #endif if (GIMME != G_ARRAY) { @@ -4240,29 +4721,31 @@ PP(pp_gnbyaddr) PP(pp_gnetent) { - djSP; #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT) + dSP; I32 which = PL_op->op_type; register char **elem; register SV *sv; #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */ - struct netent *PerlSock_getnetbyaddr(Netdb_net_t, int); - struct netent *PerlSock_getnetbyname(Netdb_name_t); - struct netent *PerlSock_getnetent(void); + struct netent *getnetbyaddr(Netdb_net_t, int); + struct netent *getnetbyname(Netdb_name_t); + struct netent *getnetent(void); #endif struct netent *nent; STRLEN n_a; - if (which == OP_GNBYNAME) + if (which == OP_GNBYNAME){ #ifdef HAS_GETNETBYNAME - nent = PerlSock_getnetbyname(POPpx); + char *name = POPpbytex; + nent = PerlSock_getnetbyname(name); #else DIE(aTHX_ PL_no_sock_func, "getnetbyname"); #endif + } else if (which == OP_GNBYADDR) { #ifdef HAS_GETNETBYADDR int addrtype = POPi; - Netdb_net_t addr = (Netdb_net_t) U_L(POPn); + Netdb_net_t addr = (Netdb_net_t) (U32)POPu; nent = PerlSock_getnetbyaddr(addr, addrtype); #else DIE(aTHX_ PL_no_sock_func, "getnetbyaddr"); @@ -4275,6 +4758,17 @@ PP(pp_gnetent) DIE(aTHX_ PL_no_sock_func, "getnetent"); #endif +#ifdef HOST_NOT_FOUND + if (!nent) { +#ifdef USE_REENTRANT_API +# ifdef USE_GETNETENT_ERRNO + h_errno = PL_reentrant_buffer->_getnetent_errno; +# endif +#endif + STATUS_NATIVE_SET(h_errno); + } +#endif + EXTEND(SP, 4); if (GIMME != G_ARRAY) { PUSHs(sv = sv_newmortal()); @@ -4328,31 +4822,35 @@ PP(pp_gpbynumber) PP(pp_gprotoent) { - djSP; #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT) + dSP; I32 which = PL_op->op_type; register char **elem; - register SV *sv; + register SV *sv; #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */ - struct protoent *PerlSock_getprotobyname(Netdb_name_t); - struct protoent *PerlSock_getprotobynumber(int); - struct protoent *PerlSock_getprotoent(void); + struct protoent *getprotobyname(Netdb_name_t); + struct protoent *getprotobynumber(int); + struct protoent *getprotoent(void); #endif struct protoent *pent; STRLEN n_a; - if (which == OP_GPBYNAME) + if (which == OP_GPBYNAME) { #ifdef HAS_GETPROTOBYNAME - pent = PerlSock_getprotobyname(POPpx); + char* name = POPpbytex; + pent = PerlSock_getprotobyname(name); #else DIE(aTHX_ PL_no_sock_func, "getprotobyname"); #endif - else if (which == OP_GPBYNUMBER) + } + else if (which == OP_GPBYNUMBER) { #ifdef HAS_GETPROTOBYNUMBER - pent = PerlSock_getprotobynumber(POPi); + int number = POPi; + pent = PerlSock_getprotobynumber(number); #else - DIE(aTHX_ PL_no_sock_func, "getprotobynumber"); + DIE(aTHX_ PL_no_sock_func, "getprotobynumber"); #endif + } else #ifdef HAS_GETPROTOENT pent = PerlSock_getprotoent(); @@ -4411,23 +4909,23 @@ PP(pp_gsbyport) PP(pp_gservent) { - djSP; #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT) + dSP; I32 which = PL_op->op_type; register char **elem; register SV *sv; #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */ - struct servent *PerlSock_getservbyname(Netdb_name_t, Netdb_name_t); - struct servent *PerlSock_getservbyport(int, Netdb_name_t); - struct servent *PerlSock_getservent(void); + struct servent *getservbyname(Netdb_name_t, Netdb_name_t); + struct servent *getservbyport(int, Netdb_name_t); + struct servent *getservent(void); #endif struct servent *sent; STRLEN n_a; if (which == OP_GSBYNAME) { #ifdef HAS_GETSERVBYNAME - char *proto = POPpx; - char *name = POPpx; + char *proto = POPpbytex; + char *name = POPpbytex; if (proto && !*proto) proto = Nullch; @@ -4439,8 +4937,11 @@ PP(pp_gservent) } else if (which == OP_GSBYPORT) { #ifdef HAS_GETSERVBYPORT - char *proto = POPpx; - unsigned short port = POPu; + char *proto = POPpbytex; + unsigned short port = (unsigned short)POPu; + + if (proto && !*proto) + proto = Nullch; #ifdef HAS_HTONS port = PerlSock_htons(port); @@ -4501,8 +5002,8 @@ PP(pp_gservent) PP(pp_shostent) { - djSP; #ifdef HAS_SETHOSTENT + dSP; PerlSock_sethostent(TOPi); RETSETYES; #else @@ -4512,8 +5013,8 @@ PP(pp_shostent) PP(pp_snetent) { - djSP; #ifdef HAS_SETNETENT + dSP; PerlSock_setnetent(TOPi); RETSETYES; #else @@ -4523,8 +5024,8 @@ PP(pp_snetent) PP(pp_sprotoent) { - djSP; #ifdef HAS_SETPROTOENT + dSP; PerlSock_setprotoent(TOPi); RETSETYES; #else @@ -4534,8 +5035,8 @@ PP(pp_sprotoent) PP(pp_sservent) { - djSP; #ifdef HAS_SETSERVENT + dSP; PerlSock_setservent(TOPi); RETSETYES; #else @@ -4545,8 +5046,8 @@ PP(pp_sservent) PP(pp_ehostent) { - djSP; #ifdef HAS_ENDHOSTENT + dSP; PerlSock_endhostent(); EXTEND(SP,1); RETPUSHYES; @@ -4557,8 +5058,8 @@ PP(pp_ehostent) PP(pp_enetent) { - djSP; #ifdef HAS_ENDNETENT + dSP; PerlSock_endnetent(); EXTEND(SP,1); RETPUSHYES; @@ -4569,8 +5070,8 @@ PP(pp_enetent) PP(pp_eprotoent) { - djSP; #ifdef HAS_ENDPROTOENT + dSP; PerlSock_endprotoent(); EXTEND(SP,1); RETPUSHYES; @@ -4581,8 +5082,8 @@ PP(pp_eprotoent) PP(pp_eservent) { - djSP; #ifdef HAS_ENDSERVENT + dSP; PerlSock_endservent(); EXTEND(SP,1); RETPUSHYES; @@ -4611,46 +5112,101 @@ PP(pp_gpwuid) PP(pp_gpwent) { - djSP; -#if defined(HAS_PASSWD) && defined(HAS_GETPWENT) +#ifdef HAS_PASSWD + dSP; I32 which = PL_op->op_type; register SV *sv; - struct passwd *pwent; STRLEN n_a; -#if defined(HAS_GETSPENT) || defined(HAS_GETSPNAM) - struct spwd *spwent = NULL; -#endif - - if (which == OP_GPWNAM) - pwent = getpwnam(POPpx); - else if (which == OP_GPWUID) - pwent = getpwuid(POPi); - else - pwent = (struct passwd *)getpwent(); + struct passwd *pwent = NULL; + /* + * We currently support only the SysV getsp* shadow password interface. + * The interface is declared in and often one needs to link + * with -lsecurity or some such. + * This interface is used at least by Solaris, HP-UX, IRIX, and Linux. + * (and SCO?) + * + * AIX getpwnam() is clever enough to return the encrypted password + * only if the caller (euid?) is root. + * + * There are at least two other shadow password APIs. Many platforms + * seem to contain more than one interface for accessing the shadow + * password databases, possibly for compatibility reasons. + * The getsp*() is by far he simplest one, the other two interfaces + * are much more complicated, but also very similar to each other. + * + * + * + * + * struct pr_passwd *getprpw*(); + * The password is in + * char getprpw*(...).ufld.fd_encrypt[] + * Mention HAS_GETPRPWNAM here so that Configure probes for it. + * + * + * + * + * struct es_passwd *getespw*(); + * The password is in + * char *(getespw*(...).ufld.fd_encrypt) + * Mention HAS_GETESPWNAM here so that Configure probes for it. + * + * Mention I_PROT here so that Configure probes for it. + * + * In HP-UX for getprpw*() the manual page claims that one should include + * instead of , but that is not needed + * if one includes as that includes , + * and pp_sys.c already includes if there is such. + * + * Note that is already probed for, but currently + * it is only included in special cases. + * + * In Digital UNIX/Tru64 if using the getespw*() (which seems to be + * be preferred interface, even though also the getprpw*() interface + * is available) one needs to link with -lsecurity -ldb -laud -lm. + * One also needs to call set_auth_parameters() in main() before + * doing anything else, whether one is using getespw*() or getprpw*(). + * + * Note that accessing the shadow databases can be magnitudes + * slower than accessing the standard databases. + * + * --jhi + */ -#ifdef HAS_GETSPNAM - if (which == OP_GPWNAM) { - if (pwent) - spwent = getspnam(pwent->pw_name); - } -# ifdef HAS_GETSPUID /* AFAIK there isn't any anywhere. --jhi */ - else if (which == OP_GPWUID) { - if (pwent) - spwent = getspnam(pwent->pw_name); - } -# endif -# ifdef HAS_GETSPENT - else - spwent = (struct spwd *)getspent(); -# endif + switch (which) { + case OP_GPWNAM: + { + char* name = POPpbytex; + pwent = getpwnam(name); + } + break; + case OP_GPWUID: + { + Uid_t uid = POPi; + pwent = getpwuid(uid); + } + break; + case OP_GPWENT: +# ifdef HAS_GETPWENT + pwent = getpwent(); +#ifdef POSIX_BC /* In some cases pw_passwd has invalid addresses */ + if (pwent) pwent = getpwnam(pwent->pw_name); #endif +# else + DIE(aTHX_ PL_no_func, "getpwent"); +# endif + break; + } EXTEND(SP, 10); if (GIMME != G_ARRAY) { PUSHs(sv = sv_newmortal()); if (pwent) { if (which == OP_GPWNAM) +# if Uid_t_sign <= 0 sv_setiv(sv, (IV)pwent->pw_uid); +# else + sv_setuv(sv, (UV)pwent->pw_uid); +# endif else sv_setpv(sv, pwent->pw_name); } @@ -4662,66 +5218,114 @@ PP(pp_gpwent) sv_setpv(sv, pwent->pw_name); PUSHs(sv = sv_mortalcopy(&PL_sv_no)); -#ifdef PWPASSWD -# if defined(HAS_GETSPENT) || defined(HAS_GETSPNAM) - if (spwent) - sv_setpv(sv, spwent->sp_pwdp); - else - sv_setpv(sv, pwent->pw_passwd); -# else - sv_setpv(sv, pwent->pw_passwd); + SvPOK_off(sv); + /* If we have getspnam(), we try to dig up the shadow + * password. If we are underprivileged, the shadow + * interface will set the errno to EACCES or similar, + * and return a null pointer. If this happens, we will + * use the dummy password (usually "*" or "x") from the + * standard password database. + * + * In theory we could skip the shadow call completely + * if euid != 0 but in practice we cannot know which + * security measures are guarding the shadow databases + * on a random platform. + * + * Resist the urge to use additional shadow interfaces. + * Divert the urge to writing an extension instead. + * + * --jhi */ +# ifdef HAS_GETSPNAM + { + struct spwd *spwent; + int saverrno; /* Save and restore errno so that + * underprivileged attempts seem + * to have never made the unsccessful + * attempt to retrieve the shadow password. */ + + saverrno = errno; + spwent = getspnam(pwent->pw_name); + errno = saverrno; + if (spwent && spwent->sp_pwdp) + sv_setpv(sv, spwent->sp_pwdp); + } +# endif +# ifdef PWPASSWD + if (!SvPOK(sv)) /* Use the standard password, then. */ + sv_setpv(sv, pwent->pw_passwd); +# endif + +# ifndef INCOMPLETE_TAINTS + /* passwd is tainted because user himself can diddle with it. + * admittedly not much and in a very limited way, but nevertheless. */ + SvTAINTED_on(sv); # endif -#endif PUSHs(sv = sv_mortalcopy(&PL_sv_no)); +# if Uid_t_sign <= 0 sv_setiv(sv, (IV)pwent->pw_uid); +# else + sv_setuv(sv, (UV)pwent->pw_uid); +# endif PUSHs(sv = sv_mortalcopy(&PL_sv_no)); +# if Uid_t_sign <= 0 sv_setiv(sv, (IV)pwent->pw_gid); - - /* pw_change, pw_quota, and pw_age are mutually exclusive. */ +# else + sv_setuv(sv, (UV)pwent->pw_gid); +# endif + /* pw_change, pw_quota, and pw_age are mutually exclusive-- + * because of the poor interface of the Perl getpw*(), + * not because there's some standard/convention saying so. + * A better interface would have been to return a hash, + * but we are accursed by our history, alas. --jhi. */ PUSHs(sv = sv_mortalcopy(&PL_sv_no)); -#ifdef PWCHANGE +# ifdef PWCHANGE sv_setiv(sv, (IV)pwent->pw_change); -#else -# ifdef PWQUOTA - sv_setiv(sv, (IV)pwent->pw_quota); # else -# ifdef PWAGE +# ifdef PWQUOTA + sv_setiv(sv, (IV)pwent->pw_quota); +# else +# ifdef PWAGE sv_setpv(sv, pwent->pw_age); +# endif # endif # endif -#endif - /* pw_class and pw_comment are mutually exclusive. */ + /* pw_class and pw_comment are mutually exclusive--. + * see the above note for pw_change, pw_quota, and pw_age. */ PUSHs(sv = sv_mortalcopy(&PL_sv_no)); -#ifdef PWCLASS +# ifdef PWCLASS sv_setpv(sv, pwent->pw_class); -#else -# ifdef PWCOMMENT +# else +# ifdef PWCOMMENT sv_setpv(sv, pwent->pw_comment); +# endif # endif -#endif PUSHs(sv = sv_mortalcopy(&PL_sv_no)); -#ifdef PWGECOS +# ifdef PWGECOS sv_setpv(sv, pwent->pw_gecos); -#endif -#ifndef INCOMPLETE_TAINTS +# endif +# ifndef INCOMPLETE_TAINTS /* pw_gecos is tainted because user himself can diddle with it. */ SvTAINTED_on(sv); -#endif +# endif PUSHs(sv = sv_mortalcopy(&PL_sv_no)); sv_setpv(sv, pwent->pw_dir); PUSHs(sv = sv_mortalcopy(&PL_sv_no)); sv_setpv(sv, pwent->pw_shell); +# ifndef INCOMPLETE_TAINTS + /* pw_shell is tainted because user himself can diddle with it. */ + SvTAINTED_on(sv); +# endif -#ifdef PWEXPIRE +# ifdef PWEXPIRE PUSHs(sv = sv_mortalcopy(&PL_sv_no)); sv_setiv(sv, (IV)pwent->pw_expire); -#endif +# endif } RETURN; #else @@ -4731,12 +5335,9 @@ PP(pp_gpwent) PP(pp_spwent) { - djSP; -#if defined(HAS_PASSWD) && defined(HAS_SETPWENT) && !defined(CYGWIN) +#if defined(HAS_PASSWD) && defined(HAS_SETPWENT) + dSP; setpwent(); -# ifdef HAS_SETSPENT - setspent(); -# endif RETPUSHYES; #else DIE(aTHX_ PL_no_func, "setpwent"); @@ -4745,12 +5346,9 @@ PP(pp_spwent) PP(pp_epwent) { - djSP; #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT) + dSP; endpwent(); -# ifdef HAS_ENDSPENT - endspent(); -# endif RETPUSHYES; #else DIE(aTHX_ PL_no_func, "endpwent"); @@ -4777,20 +5375,28 @@ PP(pp_ggrgid) PP(pp_ggrent) { - djSP; -#if defined(HAS_GROUP) && defined(HAS_GETGRENT) +#ifdef HAS_GROUP + dSP; I32 which = PL_op->op_type; register char **elem; register SV *sv; struct group *grent; STRLEN n_a; - if (which == OP_GGRNAM) - grent = (struct group *)getgrnam(POPpx); - else if (which == OP_GGRGID) - grent = (struct group *)getgrgid(POPi); + if (which == OP_GGRNAM) { + char* name = POPpbytex; + grent = (struct group *)getgrnam(name); + } + else if (which == OP_GGRGID) { + Gid_t gid = POPi; + grent = (struct group *)getgrgid(gid); + } else +#ifdef HAS_GETGRENT grent = (struct group *)getgrent(); +#else + DIE(aTHX_ PL_no_func, "getgrent"); +#endif EXTEND(SP, 4); if (GIMME != G_ARRAY) { @@ -4816,12 +5422,22 @@ PP(pp_ggrent) PUSHs(sv = sv_mortalcopy(&PL_sv_no)); sv_setiv(sv, (IV)grent->gr_gid); +#if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API)) PUSHs(sv = sv_mortalcopy(&PL_sv_no)); + /* In UNICOS/mk (_CRAYMPP) the multithreading + * versions (getgrnam_r, getgrgid_r) + * seem to return an illegal pointer + * as the group members list, gr_mem. + * getgrent() doesn't even have a _r version + * but the gr_mem is poisonous anyway. + * So yes, you cannot get the list of group + * members if building multithreaded in UNICOS/mk. */ for (elem = grent->gr_mem; elem && *elem; elem++) { sv_catpv(sv, *elem); if (elem[1]) sv_catpvn(sv, " ", 1); } +#endif } RETURN; @@ -4832,8 +5448,8 @@ PP(pp_ggrent) PP(pp_sgrent) { - djSP; #if defined(HAS_GROUP) && defined(HAS_SETGRENT) + dSP; setgrent(); RETPUSHYES; #else @@ -4843,8 +5459,8 @@ PP(pp_sgrent) PP(pp_egrent) { - djSP; #if defined(HAS_GROUP) && defined(HAS_ENDGRENT) + dSP; endgrent(); RETPUSHYES; #else @@ -4854,8 +5470,8 @@ PP(pp_egrent) PP(pp_getlogin) { - djSP; dTARGET; #ifdef HAS_GETLOGIN + dSP; dTARGET; char *tmps; EXTEND(SP, 1); if (!(tmps = PerlProc_getlogin())) @@ -4872,12 +5488,11 @@ PP(pp_getlogin) PP(pp_syscall) { #ifdef HAS_SYSCALL - djSP; dMARK; dORIGMARK; dTARGET; + dSP; dMARK; dORIGMARK; dTARGET; register I32 items = SP - MARK; unsigned long a[20]; register I32 i = 0; I32 retval = -1; - MAGIC *mg; STRLEN n_a; if (PL_tainting) { @@ -4900,7 +5515,7 @@ PP(pp_syscall) a[i++] = SvIV(*MARK); else if (*MARK == &PL_sv_undef) a[i++] = 0; - else + else a[i++] = (unsigned long)SvPV_force(*MARK, n_a); if (i > 15) break; @@ -4968,7 +5583,7 @@ PP(pp_syscall) } #ifdef FCNTL_EMULATE_FLOCK - + /* XXX Emulate flock() with fcntl(). What's really needed is a good file locking module. */ @@ -4977,7 +5592,7 @@ static int fcntl_emulate_flock(int fd, int operation) { struct flock flock; - + switch (operation & ~LOCK_NB) { case LOCK_SH: flock.l_type = F_RDLCK; @@ -4993,8 +5608,8 @@ fcntl_emulate_flock(int fd, int operation) return -1; } flock.l_whence = SEEK_SET; - flock.l_start = flock.l_len = 0L; - + flock.l_start = flock.l_len = (Off_t)0; + return fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock); }