pp_sys.c

   1 /*    pp_sys.c
   2  *
   3  *    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   4  *    2004, 2005, 2006, 2007, 2008 by Larry Wall and others
   5  *
   6  *    You may distribute under the terms of either the GNU General Public
   7  *    License or the Artistic License, as specified in the README file.
   8  *
   9  */
  10
  11 /*
  12  * But only a short way ahead its floor and the walls on either side were
  13  * cloven by a great fissure, out of which the red glare came, now leaping
  14  * up, now dying down into darkness; and all the while far below there was
  15  * a rumour and a trouble as of great engines throbbing and labouring.
  16  *
  17  *     [p.945 of _The Lord of the Rings_, VI/iii: "Mount Doom"]
  18  */
  19
  20 /* This file contains system pp ("push/pop") functions that
  21  * execute the opcodes that make up a perl program. A typical pp function
  22  * expects to find its arguments on the stack, and usually pushes its
  23  * results onto the stack, hence the 'pp' terminology. Each OP structure
  24  * contains a pointer to the relevant pp_foo() function.
  25  *
  26  * By 'system', we mean ops which interact with the OS, such as pp_open().
  27  */
  28
  29 #include "EXTERN.h"
  30 #define PERL_IN_PP_SYS_C
  31 #include "perl.h"
  32 #include "time64.h"
  33 #include "time64.c"
  34
  35 #ifdef I_SHADOW
  36 /* Shadow password support for solaris - pdo@cs.umd.edu
  37  * Not just Solaris: at least HP-UX, IRIX, Linux.
  38  * The API is from SysV.
  39  *
  40  * There are at least two more shadow interfaces,
  41  * see the comments in pp_gpwent().
  42  *
  43  * --jhi */
  44 #   ifdef __hpux__
  45 /* There is a MAXINT coming from <shadow.h> <- <hpsecurity.h> <- <values.h>
  46  * and another MAXINT from "perl.h" <- <sys/param.h>. */
  47 #       undef MAXINT
  48 #   endif
  49 #   include <shadow.h>
  50 #endif
  51
  52 #ifdef I_SYS_RESOURCE
  53 # include <sys/resource.h>
  54 #endif
  55
  56 #ifdef NETWARE
  57 NETDB_DEFINE_CONTEXT
  58 #endif
  59
  60 #ifdef HAS_SELECT
  61 # ifdef I_SYS_SELECT
  62 #  include <sys/select.h>
  63 # endif
  64 #endif
  65
  66 /* XXX Configure test needed.
  67    h_errno might not be a simple 'int', especially for multi-threaded
  68    applications, see "extern int errno in perl.h".  Creating such
  69    a test requires taking into account the differences between
  70    compiling multithreaded and singlethreaded ($ccflags et al).
  71    HOST_NOT_FOUND is typically defined in <netdb.h>.
  72 */
  73 #if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
  74 extern int h_errno;
  75 #endif
  76
  77 #ifdef HAS_PASSWD
  78 # ifdef I_PWD
  79 #  include <pwd.h>
  80 # else
  81 #  if !defined(VMS)
  82     struct passwd *getpwnam (char *);
  83     struct passwd *getpwuid (Uid_t);
  84 #  endif
  85 # endif
  86 # ifdef HAS_GETPWENT
  87 #ifndef getpwent
  88   struct passwd *getpwent (void);
  89 #elif defined (VMS) && defined (my_getpwent)
  90   struct passwd *Perl_my_getpwent (pTHX);
  91 #endif
  92 # endif
  93 #endif
  94
  95 #ifdef HAS_GROUP
  96 # ifdef I_GRP
  97 #  include <grp.h>
  98 # else
  99     struct group *getgrnam (char *);
 100     struct group *getgrgid (Gid_t);
 101 # endif
 102 # ifdef HAS_GETGRENT
 103 #ifndef getgrent
 104     struct group *getgrent (void);
 105 #endif
 106 # endif
 107 #endif
 108
 109 #ifdef I_UTIME
 110 #  if defined(_MSC_VER) || defined(__MINGW32__)
 111 #    include <sys/utime.h>
 112 #  else
 113 #    include <utime.h>
 114 #  endif
 115 #endif
 116
 117 #ifdef HAS_CHSIZE
 118 # ifdef my_chsize  /* Probably #defined to Perl_my_chsize in embed.h */
 119 #   undef my_chsize
 120 # endif
 121 # define my_chsize PerlLIO_chsize
 122 #else
 123 # ifdef HAS_TRUNCATE
 124 #   define my_chsize PerlLIO_chsize
 125 # else
 126 I32 my_chsize(int fd, Off_t length);
 127 # endif
 128 #endif
 129
 130 #ifdef HAS_FLOCK
 131 #  define FLOCK flock
 132 #else /* no flock() */
 133
 134    /* fcntl.h might not have been included, even if it exists, because
 135       the current Configure only sets I_FCNTL if it's needed to pick up
 136       the *_OK constants.  Make sure it has been included before testing
 137       the fcntl() locking constants. */
 138 #  if defined(HAS_FCNTL) && !defined(I_FCNTL)
 139 #    include <fcntl.h>
 140 #  endif
 141
 142 #  if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK)
 143 #    define FLOCK fcntl_emulate_flock
 144 #    define FCNTL_EMULATE_FLOCK
 145 #  else /* no flock() or fcntl(F_SETLK,...) */
 146 #    ifdef HAS_LOCKF
 147 #      define FLOCK lockf_emulate_flock
 148 #      define LOCKF_EMULATE_FLOCK
 149 #    endif /* lockf */
 150 #  endif /* no flock() or fcntl(F_SETLK,...) */
 151
 152 #  ifdef FLOCK
 153      static int FLOCK (int, int);
 154
 155     /*
 156      * These are the flock() constants.  Since this sytems doesn't have
 157      * flock(), the values of the constants are probably not available.
 158      */
 159 #    ifndef LOCK_SH
 160 #      define LOCK_SH 1
 161 #    endif
 162 #    ifndef LOCK_EX
 163 #      define LOCK_EX 2
 164 #    endif
 165 #    ifndef LOCK_NB
 166 #      define LOCK_NB 4
 167 #    endif
 168 #    ifndef LOCK_UN
 169 #      define LOCK_UN 8
 170 #    endif
 171 #  endif /* emulating flock() */
 172
 173 #endif /* no flock() */
 174
 175 #define ZBTLEN 10
 176 static const char zero_but_true[ZBTLEN + 1] = "0 but true";
 177
 178 #if defined(I_SYS_ACCESS) && !defined(R_OK)
 179 #  include <sys/access.h>
 180 #endif
 181
 182 #if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
 183 #  define FD_CLOEXEC 1          /* NeXT needs this */
 184 #endif
 185
 186 #include "reentr.h"
 187
 188 #ifdef __Lynx__
 189 /* Missing protos on LynxOS */
 190 void sethostent(int);
 191 void endhostent(void);
 192 void setnetent(int);
 193 void endnetent(void);
 194 void setprotoent(int);
 195 void endprotoent(void);
 196 void setservent(int);
 197 void endservent(void);
 198 #endif
 199
 200 #undef PERL_EFF_ACCESS  /* EFFective uid/gid ACCESS */
 201
 202 /* F_OK unused: if stat() cannot find it... */
 203
 204 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
 205     /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
 206 #   define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
 207 #endif
 208
 209 #if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
 210 #   ifdef I_SYS_SECURITY
 211 #       include <sys/security.h>
 212 #   endif
 213 #   ifdef ACC_SELF
 214         /* HP SecureWare */
 215 #       define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
 216 #   else
 217         /* SCO */
 218 #       define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
 219 #   endif
 220 #endif
 221
 222 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
 223     /* AIX */
 224 #   define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
 225 #endif
 226
 227
 228 #if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS)    \
 229     && (defined(HAS_SETREUID) || defined(HAS_SETRESUID)         \
 230         || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
 231 /* The Hard Way. */
 232 STATIC int
 233 S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
 234 {
 235     const Uid_t ruid = getuid();
 236     const Uid_t euid = geteuid();
 237     const Gid_t rgid = getgid();
 238     const Gid_t egid = getegid();
 239     int res;
 240
 241 #if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
 242     Perl_croak(aTHX_ "switching effective uid is not implemented");
 243 #else
 244 #ifdef HAS_SETREUID
 245     if (setreuid(euid, ruid))
 246 #else
 247 #ifdef HAS_SETRESUID
 248     if (setresuid(euid, ruid, (Uid_t)-1))
 249 #endif
 250 #endif
 251         /* diag_listed_as: entering effective %s failed */
 252         Perl_croak(aTHX_ "entering effective uid failed");
 253 #endif
 254
 255 #if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
 256     Perl_croak(aTHX_ "switching effective gid is not implemented");
 257 #else
 258 #ifdef HAS_SETREGID
 259     if (setregid(egid, rgid))
 260 #else
 261 #ifdef HAS_SETRESGID
 262     if (setresgid(egid, rgid, (Gid_t)-1))
 263 #endif
 264 #endif
 265         /* diag_listed_as: entering effective %s failed */
 266         Perl_croak(aTHX_ "entering effective gid failed");
 267 #endif
 268
 269     res = access(path, mode);
 270
 271 #ifdef HAS_SETREUID
 272     if (setreuid(ruid, euid))
 273 #else
 274 #ifdef HAS_SETRESUID
 275     if (setresuid(ruid, euid, (Uid_t)-1))
 276 #endif
 277 #endif
 278         /* diag_listed_as: leaving effective %s failed */
 279         Perl_croak(aTHX_ "leaving effective uid failed");
 280
 281 #ifdef HAS_SETREGID
 282     if (setregid(rgid, egid))
 283 #else
 284 #ifdef HAS_SETRESGID
 285     if (setresgid(rgid, egid, (Gid_t)-1))
 286 #endif
 287 #endif
 288         /* diag_listed_as: leaving effective %s failed */
 289         Perl_croak(aTHX_ "leaving effective gid failed");
 290
 291     return res;
 292 }
 293 #   define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
 294 #endif
 295
 296 PP(pp_backtick)
 297 {
 298     dVAR; dSP; dTARGET;
 299     PerlIO *fp;
 300     const char * const tmps = POPpconstx;
 301     const I32 gimme = GIMME_V;
 302     const char *mode = "r";
 303
 304     TAINT_PROPER("``");
 305     if (PL_op->op_private & OPpOPEN_IN_RAW)
 306         mode = "rb";
 307     else if (PL_op->op_private & OPpOPEN_IN_CRLF)
 308         mode = "rt";
 309     fp = PerlProc_popen(tmps, mode);
 310     if (fp) {
 311         const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
 312         if (type && *type)
 313             PerlIO_apply_layers(aTHX_ fp,mode,type);
 314
 315         if (gimme == G_VOID) {
 316             char tmpbuf[256];
 317             while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
 318                 NOOP;
 319         }
 320         else if (gimme == G_SCALAR) {
 321             ENTER_with_name("backtick");
 322             SAVESPTR(PL_rs);
 323             PL_rs = &PL_sv_undef;
 324             sv_setpvs(TARG, "");        /* note that this preserves previous buffer */
 325             while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
 326                 NOOP;
 327             LEAVE_with_name("backtick");
 328             XPUSHs(TARG);
 329             SvTAINTED_on(TARG);
 330         }
 331         else {
 332             for (;;) {
 333                 SV * const sv = newSV(79);
 334                 if (sv_gets(sv, fp, 0) == NULL) {
 335                     SvREFCNT_dec(sv);
 336                     break;
 337                 }
 338                 mXPUSHs(sv);
 339                 if (SvLEN(sv) - SvCUR(sv) > 20) {
 340                     SvPV_shrink_to_cur(sv);
 341                 }
 342                 SvTAINTED_on(sv);
 343             }
 344         }
 345         STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
 346         TAINT;          /* "I believe that this is not gratuitous!" */
 347     }
 348     else {
 349         STATUS_NATIVE_CHILD_SET(-1);
 350         if (gimme == G_SCALAR)
 351             RETPUSHUNDEF;
 352     }
 353
 354     RETURN;
 355 }
 356
 357 PP(pp_glob)
 358 {
 359     dVAR;
 360     OP *result;
 361     dSP;
 362     /* make a copy of the pattern if it is gmagical, to ensure that magic
 363      * is called once and only once */
 364     if (SvGMAGICAL(TOPm1s)) TOPm1s = sv_2mortal(newSVsv(TOPm1s));
 365
 366     tryAMAGICunTARGET(iter_amg, -1, (PL_op->op_flags & OPf_SPECIAL));
 367
 368     if (PL_op->op_flags & OPf_SPECIAL) {
 369         /* call Perl-level glob function instead. Stack args are:
 370          * MARK, wildcard, csh_glob context index
 371          * and following OPs should be: gv(CORE::GLOBAL::glob), entersub
 372          * */
 373         return NORMAL;
 374     }
 375     /* stack args are: wildcard, gv(_GEN_n) */
 376
 377     if (PL_globhook) {
 378         SETs(GvSV(TOPs));
 379         PL_globhook(aTHX);
 380         return NORMAL;
 381     }
 382
 383     /* Note that we only ever get here if File::Glob fails to load
 384      * without at the same time croaking, for some reason, or if
 385      * perl was built with PERL_EXTERNAL_GLOB */
 386
 387     ENTER_with_name("glob");
 388
 389 #ifndef VMS
 390     if (PL_tainting) {
 391         /*
 392          * The external globbing program may use things we can't control,
 393          * so for security reasons we must assume the worst.
 394          */
 395         TAINT;
 396         taint_proper(PL_no_security, "glob");
 397     }
 398 #endif /* !VMS */
 399
 400     SAVESPTR(PL_last_in_gv);    /* We don't want this to be permanent. */
 401     PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
 402
 403     SAVESPTR(PL_rs);            /* This is not permanent, either. */
 404     PL_rs = newSVpvs_flags("\000", SVs_TEMP);
 405 #ifndef DOSISH
 406 #ifndef CSH
 407     *SvPVX(PL_rs) = '\n';
 408 #endif  /* !CSH */
 409 #endif  /* !DOSISH */
 410
 411     result = do_readline();
 412     LEAVE_with_name("glob");
 413     return result;
 414 }
 415
 416 PP(pp_rcatline)
 417 {
 418     dVAR;
 419     PL_last_in_gv = cGVOP_gv;
 420     return do_readline();
 421 }
 422
 423 PP(pp_warn)
 424 {
 425     dVAR; dSP; dMARK;
 426     SV *exsv;
 427     STRLEN len;
 428     if (SP - MARK > 1) {
 429         dTARGET;
 430         do_join(TARG, &PL_sv_no, MARK, SP);
 431         exsv = TARG;
 432         SP = MARK + 1;
 433     }
 434     else if (SP == MARK) {
 435         exsv = &PL_sv_no;
 436         EXTEND(SP, 1);
 437         SP = MARK + 1;
 438     }
 439     else {
 440         exsv = TOPs;
 441     }
 442
 443     if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
 444         /* well-formed exception supplied */
 445     }
 446     else if (SvROK(ERRSV)) {
 447         exsv = ERRSV;
 448     }
 449     else if (SvPOK(ERRSV) && SvCUR(ERRSV)) {
 450         exsv = sv_mortalcopy(ERRSV);
 451         sv_catpvs(exsv, "\t...caught");
 452     }
 453     else {
 454         exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
 455     }
 456     if (SvROK(exsv) && !PL_warnhook)
 457          Perl_warn(aTHX_ "%"SVf, SVfARG(exsv));
 458     else warn_sv(exsv);
 459     RETSETYES;
 460 }
 461
 462 PP(pp_die)
 463 {
 464     dVAR; dSP; dMARK;
 465     SV *exsv;
 466     STRLEN len;
 467 #ifdef VMS
 468     VMSISH_HUSHED  = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH);
 469 #endif
 470     if (SP - MARK != 1) {
 471         dTARGET;
 472         do_join(TARG, &PL_sv_no, MARK, SP);
 473         exsv = TARG;
 474         SP = MARK + 1;
 475     }
 476     else {
 477         exsv = TOPs;
 478     }
 479
 480     if (SvROK(exsv) || (SvPV_const(exsv, len), len)) {
 481         /* well-formed exception supplied */
 482     }
 483     else if (SvROK(ERRSV)) {
 484         exsv = ERRSV;
 485         if (sv_isobject(exsv)) {
 486             HV * const stash = SvSTASH(SvRV(exsv));
 487             GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
 488             if (gv) {
 489                 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
 490                 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
 491                 EXTEND(SP, 3);
 492                 PUSHMARK(SP);
 493                 PUSHs(exsv);
 494                 PUSHs(file);
 495                 PUSHs(line);
 496                 PUTBACK;
 497                 call_sv(MUTABLE_SV(GvCV(gv)),
 498                         G_SCALAR|G_EVAL|G_KEEPERR);
 499                 exsv = sv_mortalcopy(*PL_stack_sp--);
 500             }
 501         }
 502     }
 503     else if (SvPOK(ERRSV) && SvCUR(ERRSV)) {
 504         exsv = sv_mortalcopy(ERRSV);
 505         sv_catpvs(exsv, "\t...propagated");
 506     }
 507     else {
 508         exsv = newSVpvs_flags("Died", SVs_TEMP);
 509     }
 510     return die_sv(exsv);
 511 }
 512
 513 /* I/O. */
 514
 515 OP *
 516 Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv,
 517                  const MAGIC *const mg, const U32 flags, U32 argc, ...)
 518 {
 519     SV **orig_sp = sp;
 520     I32 ret_args;
 521
 522     PERL_ARGS_ASSERT_TIED_METHOD;
 523
 524     /* Ensure that our flag bits do not overlap.  */
 525     assert((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
 526     assert((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
 527     assert((TIED_METHOD_SAY & G_WANT) == 0);
 528
 529     PUTBACK; /* sp is at *foot* of args, so this pops args from old stack */
 530     PUSHSTACKi(PERLSI_MAGIC);
 531     EXTEND(SP, argc+1); /* object + args */
 532     PUSHMARK(sp);
 533     PUSHs(SvTIED_obj(sv, mg));
 534     if (flags & TIED_METHOD_ARGUMENTS_ON_STACK) {
 535         Copy(orig_sp + 2, sp + 1, argc, SV*); /* copy args to new stack */
 536         sp += argc;
 537     }
 538     else if (argc) {
 539         const U32 mortalize_not_needed
 540             = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
 541         va_list args;
 542         va_start(args, argc);
 543         do {
 544             SV *const arg = va_arg(args, SV *);
 545             if(mortalize_not_needed)
 546                 PUSHs(arg);
 547             else
 548                 mPUSHs(arg);
 549         } while (--argc);
 550         va_end(args);
 551     }
 552
 553     PUTBACK;
 554     ENTER_with_name("call_tied_method");
 555     if (flags & TIED_METHOD_SAY) {
 556         /* local $\ = "\n" */
 557         SAVEGENERICSV(PL_ors_sv);
 558         PL_ors_sv = newSVpvs("\n");
 559     }
 560     ret_args = call_method(methname, flags & G_WANT);
 561     SPAGAIN;
 562     orig_sp = sp;
 563     POPSTACK;
 564     SPAGAIN;
 565     if (ret_args) { /* copy results back to original stack */
 566         EXTEND(sp, ret_args);
 567         Copy(orig_sp - ret_args + 1, sp + 1, ret_args, SV*);
 568         sp += ret_args;
 569         PUTBACK;
 570     }
 571     LEAVE_with_name("call_tied_method");
 572     return NORMAL;
 573 }
 574
 575 #define tied_method0(a,b,c,d)           \
 576     Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
 577 #define tied_method1(a,b,c,d,e)         \
 578     Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
 579 #define tied_method2(a,b,c,d,e,f)       \
 580     Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
 581
 582 PP(pp_open)
 583 {
 584     dVAR; dSP;
 585     dMARK; dORIGMARK;
 586     dTARGET;
 587     SV *sv;
 588     IO *io;
 589     const char *tmps;
 590     STRLEN len;
 591     bool  ok;
 592
 593     GV * const gv = MUTABLE_GV(*++MARK);
 594
 595     if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
 596         DIE(aTHX_ PL_no_usym, "filehandle");
 597
 598     if ((io = GvIOp(gv))) {
 599         const MAGIC *mg;
 600         IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
 601
 602         if (IoDIRP(io))
 603             Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
 604                              "Opening dirhandle %"HEKf" also as a file",
 605                              HEKfARG(GvENAME_HEK(gv)));
 606
 607         mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
 608         if (mg) {
 609             /* Method's args are same as ours ... */
 610             /* ... except handle is replaced by the object */
 611             return Perl_tied_method(aTHX_ "OPEN", mark - 1, MUTABLE_SV(io), mg,
 612                                     G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
 613                                     sp - mark);
 614         }
 615     }
 616
 617     if (MARK < SP) {
 618         sv = *++MARK;
 619     }
 620     else {
 621         sv = GvSVn(gv);
 622     }
 623
 624     tmps = SvPV_const(sv, len);
 625     ok = do_openn(gv, tmps, len, FALSE, O_RDONLY, 0, NULL, MARK+1, (SP-MARK));
 626     SP = ORIGMARK;
 627     if (ok)
 628         PUSHi( (I32)PL_forkprocess );
 629     else if (PL_forkprocess == 0)               /* we are a new child */
 630         PUSHi(0);
 631     else
 632         RETPUSHUNDEF;
 633     RETURN;
 634 }
 635
 636 PP(pp_close)
 637 {
 638     dVAR; dSP;
 639     GV * const gv =
 640         MAXARG == 0 || (!TOPs && !POPs) ? PL_defoutgv : MUTABLE_GV(POPs);
 641
 642     if (MAXARG == 0)
 643         EXTEND(SP, 1);
 644
 645     if (gv) {
 646         IO * const io = GvIO(gv);
 647         if (io) {
 648             const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
 649             if (mg) {
 650                 return tied_method0("CLOSE", SP, MUTABLE_SV(io), mg);
 651             }
 652         }
 653     }
 654     PUSHs(boolSV(do_close(gv, TRUE)));
 655     RETURN;
 656 }
 657
 658 PP(pp_pipe_op)
 659 {
 660 #ifdef HAS_PIPE
 661     dVAR;
 662     dSP;
 663     register IO *rstio;
 664     register IO *wstio;
 665     int fd[2];
 666
 667     GV * const wgv = MUTABLE_GV(POPs);
 668     GV * const rgv = MUTABLE_GV(POPs);
 669
 670     if (!rgv || !wgv)
 671         goto badexit;
 672
 673     if (!isGV_with_GP(rgv) || !isGV_with_GP(wgv))
 674         DIE(aTHX_ PL_no_usym, "filehandle");
 675     rstio = GvIOn(rgv);
 676     wstio = GvIOn(wgv);
 677
 678     if (IoIFP(rstio))
 679         do_close(rgv, FALSE);
 680     if (IoIFP(wstio))
 681         do_close(wgv, FALSE);
 682
 683     if (PerlProc_pipe(fd) < 0)
 684         goto badexit;
 685
 686     IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
 687     IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
 688     IoOFP(rstio) = IoIFP(rstio);
 689     IoIFP(wstio) = IoOFP(wstio);
 690     IoTYPE(rstio) = IoTYPE_RDONLY;
 691     IoTYPE(wstio) = IoTYPE_WRONLY;
 692
 693     if (!IoIFP(rstio) || !IoOFP(wstio)) {
 694         if (IoIFP(rstio))
 695             PerlIO_close(IoIFP(rstio));
 696         else
 697             PerlLIO_close(fd[0]);
 698         if (IoOFP(wstio))
 699             PerlIO_close(IoOFP(wstio));
 700         else
 701             PerlLIO_close(fd[1]);
 702         goto badexit;
 703     }
 704 #if defined(HAS_FCNTL) && defined(F_SETFD)
 705     fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd);   /* ensure close-on-exec */
 706     fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd);   /* ensure close-on-exec */
 707 #endif
 708     RETPUSHYES;
 709
 710 badexit:
 711     RETPUSHUNDEF;
 712 #else
 713     DIE(aTHX_ PL_no_func, "pipe");
 714 #endif
 715 }
 716
 717 PP(pp_fileno)
 718 {
 719     dVAR; dSP; dTARGET;
 720     GV *gv;
 721     IO *io;
 722     PerlIO *fp;
 723     const MAGIC *mg;
 724
 725     if (MAXARG < 1)
 726         RETPUSHUNDEF;
 727     gv = MUTABLE_GV(POPs);
 728     io = GvIO(gv);
 729
 730     if (io
 731         && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
 732     {
 733         return tied_method0("FILENO", SP, MUTABLE_SV(io), mg);
 734     }
 735
 736     if (!io || !(fp = IoIFP(io))) {
 737         /* Can't do this because people seem to do things like
 738            defined(fileno($foo)) to check whether $foo is a valid fh.
 739
 740            report_evil_fh(gv);
 741             */
 742         RETPUSHUNDEF;
 743     }
 744
 745     PUSHi(PerlIO_fileno(fp));
 746     RETURN;
 747 }
 748
 749 PP(pp_umask)
 750 {
 751     dVAR;
 752     dSP;
 753 #ifdef HAS_UMASK
 754     dTARGET;
 755     Mode_t anum;
 756
 757     if (MAXARG < 1 || (!TOPs && !POPs)) {
 758         anum = PerlLIO_umask(022);
 759         /* setting it to 022 between the two calls to umask avoids
 760          * to have a window where the umask is set to 0 -- meaning
 761          * that another thread could create world-writeable files. */
 762         if (anum != 022)
 763             (void)PerlLIO_umask(anum);
 764     }
 765     else
 766         anum = PerlLIO_umask(POPi);
 767     TAINT_PROPER("umask");
 768     XPUSHi(anum);
 769 #else
 770     /* Only DIE if trying to restrict permissions on "user" (self).
 771      * Otherwise it's harmless and more useful to just return undef
 772      * since 'group' and 'other' concepts probably don't exist here. */
 773     if (MAXARG >= 1 && (TOPs||POPs) && (POPi & 0700))
 774         DIE(aTHX_ "umask not implemented");
 775     XPUSHs(&PL_sv_undef);
 776 #endif
 777     RETURN;
 778 }
 779
 780 PP(pp_binmode)
 781 {
 782     dVAR; dSP;
 783     GV *gv;
 784     IO *io;
 785     PerlIO *fp;
 786     SV *discp = NULL;
 787
 788     if (MAXARG < 1)
 789         RETPUSHUNDEF;
 790     if (MAXARG > 1) {
 791         discp = POPs;
 792     }
 793
 794     gv = MUTABLE_GV(POPs);
 795     io = GvIO(gv);
 796
 797     if (io) {
 798         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
 799         if (mg) {
 800             /* This takes advantage of the implementation of the varargs
 801                function, which I don't think that the optimiser will be able to
 802                figure out. Although, as it's a static function, in theory it
 803                could.  */
 804             return Perl_tied_method(aTHX_ "BINMODE", SP, MUTABLE_SV(io), mg,
 805                                     G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
 806                                     discp ? 1 : 0, discp);
 807         }
 808     }
 809
 810     if (!io || !(fp = IoIFP(io))) {
 811         report_evil_fh(gv);
 812         SETERRNO(EBADF,RMS_IFI);
 813         RETPUSHUNDEF;
 814     }
 815
 816     PUTBACK;
 817     {
 818         STRLEN len = 0;
 819         const char *d = NULL;
 820         int mode;
 821         if (discp)
 822             d = SvPV_const(discp, len);
 823         mode = mode_from_discipline(d, len);
 824         if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
 825             if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
 826                 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
 827                     SPAGAIN;
 828                     RETPUSHUNDEF;
 829                 }
 830             }
 831             SPAGAIN;
 832             RETPUSHYES;
 833         }
 834         else {
 835             SPAGAIN;
 836             RETPUSHUNDEF;
 837         }
 838     }
 839 }
 840
 841 PP(pp_tie)
 842 {
 843     dVAR; dSP; dMARK;
 844     HV* stash;
 845     GV *gv = NULL;
 846     SV *sv;
 847     const I32 markoff = MARK - PL_stack_base;
 848     const char *methname;
 849     int how = PERL_MAGIC_tied;
 850     U32 items;
 851     SV *varsv = *++MARK;
 852
 853     switch(SvTYPE(varsv)) {
 854         case SVt_PVHV:
 855             methname = "TIEHASH";
 856             HvEITER_set(MUTABLE_HV(varsv), 0);
 857             break;
 858         case SVt_PVAV:
 859             methname = "TIEARRAY";
 860             if (!AvREAL(varsv)) {
 861                 if (!AvREIFY(varsv))
 862                     Perl_croak(aTHX_ "Cannot tie unreifiable array");
 863                 av_clear((AV *)varsv);
 864                 AvREIFY_off(varsv);
 865                 AvREAL_on(varsv);
 866             }
 867             break;
 868         case SVt_PVGV:
 869         case SVt_PVLV:
 870             if (isGV_with_GP(varsv) && !SvFAKE(varsv)) {
 871                 methname = "TIEHANDLE";
 872                 how = PERL_MAGIC_tiedscalar;
 873                 /* For tied filehandles, we apply tiedscalar magic to the IO
 874                    slot of the GP rather than the GV itself. AMS 20010812 */
 875                 if (!GvIOp(varsv))
 876                     GvIOp(varsv) = newIO();
 877                 varsv = MUTABLE_SV(GvIOp(varsv));
 878                 break;
 879             }
 880             /* FALL THROUGH */
 881         default:
 882             methname = "TIESCALAR";
 883             how = PERL_MAGIC_tiedscalar;
 884             break;
 885     }
 886     items = SP - MARK++;
 887     if (sv_isobject(*MARK)) { /* Calls GET magic. */
 888         ENTER_with_name("call_TIE");
 889         PUSHSTACKi(PERLSI_MAGIC);
 890         PUSHMARK(SP);
 891         EXTEND(SP,(I32)items);
 892         while (items--)
 893             PUSHs(*MARK++);
 894         PUTBACK;
 895         call_method(methname, G_SCALAR);
 896     }
 897     else {
 898         /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
 899          * will attempt to invoke IO::File::TIEARRAY, with (best case) the
 900          * wrong error message, and worse case, supreme action at a distance.
 901          * (Sorry obfuscation writers. You're not going to be given this one.)
 902          */
 903        stash = gv_stashsv(*MARK, 0);
 904        if (!stash || !(gv = gv_fetchmethod(stash, methname))) {
 905             DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"",
 906                  methname, SVfARG(SvOK(*MARK) ? *MARK : &PL_sv_no));
 907         }
 908         ENTER_with_name("call_TIE");
 909         PUSHSTACKi(PERLSI_MAGIC);
 910         PUSHMARK(SP);
 911         EXTEND(SP,(I32)items);
 912         while (items--)
 913             PUSHs(*MARK++);
 914         PUTBACK;
 915         call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
 916     }
 917     SPAGAIN;
 918
 919     sv = TOPs;
 920     POPSTACK;
 921     if (sv_isobject(sv)) {
 922         sv_unmagic(varsv, how);
 923         /* Croak if a self-tie on an aggregate is attempted. */
 924         if (varsv == SvRV(sv) &&
 925             (SvTYPE(varsv) == SVt_PVAV ||
 926              SvTYPE(varsv) == SVt_PVHV))
 927             Perl_croak(aTHX_
 928                        "Self-ties of arrays and hashes are not supported");
 929         sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
 930     }
 931     LEAVE_with_name("call_TIE");
 932     SP = PL_stack_base + markoff;
 933     PUSHs(sv);
 934     RETURN;
 935 }
 936
 937 PP(pp_untie)
 938 {
 939     dVAR; dSP;
 940     MAGIC *mg;
 941     SV *sv = POPs;
 942     const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
 943                 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
 944
 945     if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
 946         RETPUSHYES;
 947
 948     if ((mg = SvTIED_mg(sv, how))) {
 949         SV * const obj = SvRV(SvTIED_obj(sv, mg));
 950         if (obj) {
 951             GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
 952             CV *cv;
 953             if (gv && isGV(gv) && (cv = GvCV(gv))) {
 954                PUSHMARK(SP);
 955                PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
 956                mXPUSHi(SvREFCNT(obj) - 1);
 957                PUTBACK;
 958                ENTER_with_name("call_UNTIE");
 959                call_sv(MUTABLE_SV(cv), G_VOID);
 960                LEAVE_with_name("call_UNTIE");
 961                SPAGAIN;
 962             }
 963             else if (mg && SvREFCNT(obj) > 1) {
 964                 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
 965                                "untie attempted while %"UVuf" inner references still exist",
 966                                (UV)SvREFCNT(obj) - 1 ) ;
 967             }
 968         }
 969     }
 970     sv_unmagic(sv, how) ;
 971     RETPUSHYES;
 972 }
 973
 974 PP(pp_tied)
 975 {
 976     dVAR;
 977     dSP;
 978     const MAGIC *mg;
 979     SV *sv = POPs;
 980     const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
 981                 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
 982
 983     if (isGV_with_GP(sv) && !SvFAKE(sv) && !(sv = MUTABLE_SV(GvIOp(sv))))
 984         RETPUSHUNDEF;
 985
 986     if ((mg = SvTIED_mg(sv, how))) {
 987         PUSHs(SvTIED_obj(sv, mg));
 988         RETURN;
 989     }
 990     RETPUSHUNDEF;
 991 }
 992
 993 PP(pp_dbmopen)
 994 {
 995     dVAR; dSP;
 996     dPOPPOPssrl;
 997     HV* stash;
 998     GV *gv = NULL;
 999
1000     HV * const hv = MUTABLE_HV(POPs);
1001     SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
1002     stash = gv_stashsv(sv, 0);
1003     if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
1004         PUTBACK;
1005         require_pv("AnyDBM_File.pm");
1006         SPAGAIN;
1007         if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
1008             DIE(aTHX_ "No dbm on this machine");
1009     }
1010
1011     ENTER;
1012     PUSHMARK(SP);
1013
1014     EXTEND(SP, 5);
1015     PUSHs(sv);
1016     PUSHs(left);
1017     if (SvIV(right))
1018         mPUSHu(O_RDWR|O_CREAT);
1019     else
1020     {
1021         mPUSHu(O_RDWR);
1022         if (!SvOK(right)) right = &PL_sv_no;
1023     }
1024     PUSHs(right);
1025     PUTBACK;
1026     call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1027     SPAGAIN;
1028
1029     if (!sv_isobject(TOPs)) {
1030         SP--;
1031         PUSHMARK(SP);
1032         PUSHs(sv);
1033         PUSHs(left);
1034         mPUSHu(O_RDONLY);
1035         PUSHs(right);
1036         PUTBACK;
1037         call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
1038         SPAGAIN;
1039     }
1040
1041     if (sv_isobject(TOPs)) {
1042         sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1043         sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
1044     }
1045     LEAVE;
1046     RETURN;
1047 }
1048
1049 PP(pp_sselect)
1050 {
1051 #ifdef HAS_SELECT
1052     dVAR; dSP; dTARGET;
1053     register I32 i;
1054     register I32 j;
1055     register char *s;
1056     register SV *sv;
1057     NV value;
1058     I32 maxlen = 0;
1059     I32 nfound;
1060     struct timeval timebuf;
1061     struct timeval *tbuf = &timebuf;
1062     I32 growsize;
1063     char *fd_sets[4];
1064 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1065         I32 masksize;
1066         I32 offset;
1067         I32 k;
1068
1069 #   if BYTEORDER & 0xf0000
1070 #       define ORDERBYTE (0x88888888 - BYTEORDER)
1071 #   else
1072 #       define ORDERBYTE (0x4444 - BYTEORDER)
1073 #   endif
1074
1075 #endif
1076
1077     SP -= 4;
1078     for (i = 1; i <= 3; i++) {
1079         SV * const sv = SP[i];
1080         SvGETMAGIC(sv);
1081         if (!SvOK(sv))
1082             continue;
1083         if (SvREADONLY(sv)) {
1084             if (SvIsCOW(sv))
1085                 sv_force_normal_flags(sv, 0);
1086             if (SvREADONLY(sv) && !(SvPOK(sv) && SvCUR(sv) == 0))
1087                 Perl_croak_no_modify(aTHX);
1088         }
1089         if (!SvPOK(sv)) {
1090             if (!SvPOKp(sv))
1091                 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1092                                     "Non-string passed as bitmask");
1093             SvPV_force_nomg_nolen(sv);  /* force string conversion */
1094         }
1095         j = SvCUR(sv);
1096         if (maxlen < j)
1097             maxlen = j;
1098     }
1099
1100 /* little endians can use vecs directly */
1101 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1102 #  ifdef NFDBITS
1103
1104 #    ifndef NBBY
1105 #     define NBBY 8
1106 #    endif
1107
1108     masksize = NFDBITS / NBBY;
1109 #  else
1110     masksize = sizeof(long);    /* documented int, everyone seems to use long */
1111 #  endif
1112     Zero(&fd_sets[0], 4, char*);
1113 #endif
1114
1115 #  if SELECT_MIN_BITS == 1
1116     growsize = sizeof(fd_set);
1117 #  else
1118 #   if defined(__GLIBC__) && defined(__FD_SETSIZE)
1119 #      undef SELECT_MIN_BITS
1120 #      define SELECT_MIN_BITS __FD_SETSIZE
1121 #   endif
1122     /* If SELECT_MIN_BITS is greater than one we most probably will want
1123      * to align the sizes with SELECT_MIN_BITS/8 because for example
1124      * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1125      * UNIX, Solaris, NeXT, Darwin) the smallest quantum select() operates
1126      * on (sets/tests/clears bits) is 32 bits.  */
1127     growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
1128 #  endif
1129
1130     sv = SP[4];
1131     if (SvOK(sv)) {
1132         value = SvNV(sv);
1133         if (value < 0.0)
1134             value = 0.0;
1135         timebuf.tv_sec = (long)value;
1136         value -= (NV)timebuf.tv_sec;
1137         timebuf.tv_usec = (long)(value * 1000000.0);
1138     }
1139     else
1140         tbuf = NULL;
1141
1142     for (i = 1; i <= 3; i++) {
1143         sv = SP[i];
1144         if (!SvOK(sv) || SvCUR(sv) == 0) {
1145             fd_sets[i] = 0;
1146             continue;
1147         }
1148         assert(SvPOK(sv));
1149         j = SvLEN(sv);
1150         if (j < growsize) {
1151             Sv_Grow(sv, growsize);
1152         }
1153         j = SvCUR(sv);
1154         s = SvPVX(sv) + j;
1155         while (++j <= growsize) {
1156             *s++ = '\0';
1157         }
1158
1159 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1160         s = SvPVX(sv);
1161         Newx(fd_sets[i], growsize, char);
1162         for (offset = 0; offset < growsize; offset += masksize) {
1163             for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1164                 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1165         }
1166 #else
1167         fd_sets[i] = SvPVX(sv);
1168 #endif
1169     }
1170
1171 #ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1172     /* Can't make just the (void*) conditional because that would be
1173      * cpp #if within cpp macro, and not all compilers like that. */
1174     nfound = PerlSock_select(
1175         maxlen * 8,
1176         (Select_fd_set_t) fd_sets[1],
1177         (Select_fd_set_t) fd_sets[2],
1178         (Select_fd_set_t) fd_sets[3],
1179         (void*) tbuf); /* Workaround for compiler bug. */
1180 #else
1181     nfound = PerlSock_select(
1182         maxlen * 8,
1183         (Select_fd_set_t) fd_sets[1],
1184         (Select_fd_set_t) fd_sets[2],
1185         (Select_fd_set_t) fd_sets[3],
1186         tbuf);
1187 #endif
1188     for (i = 1; i <= 3; i++) {
1189         if (fd_sets[i]) {
1190             sv = SP[i];
1191 #if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1192             s = SvPVX(sv);
1193             for (offset = 0; offset < growsize; offset += masksize) {
1194                 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1195                     s[(k % masksize) + offset] = fd_sets[i][j+offset];
1196             }
1197             Safefree(fd_sets[i]);
1198 #endif
1199             SvSETMAGIC(sv);
1200         }
1201     }
1202
1203     PUSHi(nfound);
1204     if (GIMME == G_ARRAY && tbuf) {
1205         value = (NV)(timebuf.tv_sec) +
1206                 (NV)(timebuf.tv_usec) / 1000000.0;
1207         mPUSHn(value);
1208     }
1209     RETURN;
1210 #else
1211     DIE(aTHX_ "select not implemented");
1212 #endif
1213 }
1214
1215 /*
1216 =for apidoc setdefout
1217
1218 Sets PL_defoutgv, the default file handle for output, to the passed in
1219 typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference
1220 count of the passed in typeglob is increased by one, and the reference count
1221 of the typeglob that PL_defoutgv points to is decreased by one.
1222
1223 =cut
1224 */
1225
1226 void
1227 Perl_setdefout(pTHX_ GV *gv)
1228 {
1229     dVAR;
1230     SvREFCNT_inc_simple_void(gv);
1231     SvREFCNT_dec(PL_defoutgv);
1232     PL_defoutgv = gv;
1233 }
1234
1235 PP(pp_select)
1236 {
1237     dVAR; dSP; dTARGET;
1238     HV *hv;
1239     GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
1240     GV * egv = GvEGVx(PL_defoutgv);
1241     GV * const *gvp;
1242
1243     if (!egv)
1244         egv = PL_defoutgv;
1245     hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
1246     gvp = hv && HvENAME(hv)
1247                 ? (GV**)hv_fetch(hv, GvNAME(egv), HEK_UTF8(GvNAME_HEK(egv)) ? -GvNAMELEN(egv) : GvNAMELEN(egv), FALSE)
1248                 : NULL;
1249     if (gvp && *gvp == egv) {
1250             gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
1251             XPUSHTARG;
1252     }
1253     else {
1254             mXPUSHs(newRV(MUTABLE_SV(egv)));
1255     }
1256
1257     if (newdefout) {
1258         if (!GvIO(newdefout))
1259             gv_IOadd(newdefout);
1260         setdefout(newdefout);
1261     }
1262
1263     RETURN;
1264 }
1265
1266 PP(pp_getc)
1267 {
1268     dVAR; dSP; dTARGET;
1269     GV * const gv =
1270         MAXARG==0 || (!TOPs && !POPs) ? PL_stdingv : MUTABLE_GV(POPs);
1271     IO *const io = GvIO(gv);
1272
1273     if (MAXARG == 0)
1274         EXTEND(SP, 1);
1275
1276     if (io) {
1277         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1278         if (mg) {
1279             const U32 gimme = GIMME_V;
1280             Perl_tied_method(aTHX_ "GETC", SP, MUTABLE_SV(io), mg, gimme, 0);
1281             if (gimme == G_SCALAR) {
1282                 SPAGAIN;
1283                 SvSetMagicSV_nosteal(TARG, TOPs);
1284             }
1285             return NORMAL;
1286         }
1287     }
1288     if (!gv || do_eof(gv)) { /* make sure we have fp with something */
1289         if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
1290             report_evil_fh(gv);
1291         SETERRNO(EBADF,RMS_IFI);
1292         RETPUSHUNDEF;
1293     }
1294     TAINT;
1295     sv_setpvs(TARG, " ");
1296     *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
1297     if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1298         /* Find out how many bytes the char needs */
1299         Size_t len = UTF8SKIP(SvPVX_const(TARG));
1300         if (len > 1) {
1301             SvGROW(TARG,len+1);
1302             len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1303             SvCUR_set(TARG,1+len);
1304         }
1305         SvUTF8_on(TARG);
1306     }
1307     PUSHTARG;
1308     RETURN;
1309 }
1310
1311 STATIC OP *
1312 S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
1313 {
1314     dVAR;
1315     register PERL_CONTEXT *cx;
1316     const I32 gimme = GIMME_V;
1317
1318     PERL_ARGS_ASSERT_DOFORM;
1319
1320     if (cv && CvCLONE(cv))
1321         cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1322
1323     ENTER;
1324     SAVETMPS;
1325
1326     PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
1327     PUSHFORMAT(cx, retop);
1328     SAVECOMPPAD();
1329     PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1);
1330
1331     setdefout(gv);          /* locally select filehandle so $% et al work */
1332     return CvSTART(cv);
1333 }
1334
1335 PP(pp_enterwrite)
1336 {
1337     dVAR;
1338     dSP;
1339     register GV *gv;
1340     register IO *io;
1341     GV *fgv;
1342     CV *cv = NULL;
1343     SV *tmpsv = NULL;
1344
1345     if (MAXARG == 0) {
1346         gv = PL_defoutgv;
1347         EXTEND(SP, 1);
1348     }
1349     else {
1350         gv = MUTABLE_GV(POPs);
1351         if (!gv)
1352             gv = PL_defoutgv;
1353     }
1354     io = GvIO(gv);
1355     if (!io) {
1356         RETPUSHNO;
1357     }
1358     if (IoFMT_GV(io))
1359         fgv = IoFMT_GV(io);
1360     else
1361         fgv = gv;
1362
1363     if (!fgv)
1364         goto not_a_format_reference;
1365
1366     cv = GvFORM(fgv);
1367     if (!cv) {
1368         tmpsv = sv_newmortal();
1369         gv_efullname4(tmpsv, fgv, NULL, FALSE);
1370         if (SvPOK(tmpsv) && *SvPV_nolen_const(tmpsv))
1371             DIE(aTHX_ "Undefined format \"%"SVf"\" called", SVfARG(tmpsv));
1372
1373         not_a_format_reference:
1374         DIE(aTHX_ "Not a format reference");
1375     }
1376     IoFLAGS(io) &= ~IOf_DIDTOP;
1377     return doform(cv,gv,PL_op->op_next);
1378 }
1379
1380 PP(pp_leavewrite)
1381 {
1382     dVAR; dSP;
1383     GV * const gv = cxstack[cxstack_ix].blk_format.gv;
1384     register IO * const io = GvIOp(gv);
1385     PerlIO *ofp;
1386     PerlIO *fp;
1387     SV **newsp;
1388     I32 gimme;
1389     register PERL_CONTEXT *cx;
1390     OP *retop;
1391
1392     if (!io || !(ofp = IoOFP(io)))
1393         goto forget_top;
1394
1395     DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
1396           (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
1397
1398     if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1399         PL_formtarget != PL_toptarget)
1400     {
1401         GV *fgv;
1402         CV *cv;
1403         if (!IoTOP_GV(io)) {
1404             GV *topgv;
1405
1406             if (!IoTOP_NAME(io)) {
1407                 SV *topname;
1408                 if (!IoFMT_NAME(io))
1409                     IoFMT_NAME(io) = savepv(GvNAME(gv));
1410                 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%"HEKf"_TOP",
1411                                         HEKfARG(GvNAME_HEK(gv))));
1412                 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
1413                 if ((topgv && GvFORM(topgv)) ||
1414                   !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
1415                     IoTOP_NAME(io) = savesvpv(topname);
1416                 else
1417                     IoTOP_NAME(io) = savepvs("top");
1418             }
1419             topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
1420             if (!topgv || !GvFORM(topgv)) {
1421                 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1422                 goto forget_top;
1423             }
1424             IoTOP_GV(io) = topgv;
1425         }
1426         if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear.  It still doesn't fit. */
1427             I32 lines = IoLINES_LEFT(io);
1428             const char *s = SvPVX_const(PL_formtarget);
1429             if (lines <= 0)             /* Yow, header didn't even fit!!! */
1430                 goto forget_top;
1431             while (lines-- > 0) {
1432                 s = strchr(s, '\n');
1433                 if (!s)
1434                     break;
1435                 s++;
1436             }
1437             if (s) {
1438                 const STRLEN save = SvCUR(PL_formtarget);
1439                 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
1440                 do_print(PL_formtarget, ofp);
1441                 SvCUR_set(PL_formtarget, save);
1442                 sv_chop(PL_formtarget, s);
1443                 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
1444             }
1445         }
1446         if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
1447             do_print(PL_formfeed, ofp);
1448         IoLINES_LEFT(io) = IoPAGE_LEN(io);
1449         IoPAGE(io)++;
1450         PL_formtarget = PL_toptarget;
1451         IoFLAGS(io) |= IOf_DIDTOP;
1452         fgv = IoTOP_GV(io);
1453         if (!fgv)
1454             DIE(aTHX_ "bad top format reference");
1455         cv = GvFORM(fgv);
1456         if (!cv) {
1457             SV * const sv = sv_newmortal();
1458             gv_efullname4(sv, fgv, NULL, FALSE);
1459             if (SvPOK(sv) && *SvPV_nolen_const(sv))
1460                 DIE(aTHX_ "Undefined top format \"%"SVf"\" called", SVfARG(sv));
1461             else
1462                 DIE(aTHX_ "Undefined top format called");
1463         }
1464         return doform(cv, gv, PL_op);
1465     }
1466
1467   forget_top:
1468     POPBLOCK(cx,PL_curpm);
1469     POPFORMAT(cx);
1470     retop = cx->blk_sub.retop;
1471     LEAVE;
1472
1473     fp = IoOFP(io);
1474     if (!fp) {
1475         if (IoIFP(io))
1476             report_wrongway_fh(gv, '<');
1477         else
1478             report_evil_fh(gv);
1479         PUSHs(&PL_sv_no);
1480     }
1481     else {
1482         if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
1483             Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
1484         }
1485         if (!do_print(PL_formtarget, fp))
1486             PUSHs(&PL_sv_no);
1487         else {
1488             FmLINES(PL_formtarget) = 0;
1489             SvCUR_set(PL_formtarget, 0);
1490             *SvEND(PL_formtarget) = '\0';
1491             if (IoFLAGS(io) & IOf_FLUSH)
1492                 (void)PerlIO_flush(fp);
1493             PUSHs(&PL_sv_yes);
1494         }
1495     }
1496     /* bad_ofp: */
1497     PL_formtarget = PL_bodytarget;
1498     PUTBACK;
1499     PERL_UNUSED_VAR(newsp);
1500     PERL_UNUSED_VAR(gimme);
1501     return retop;
1502 }
1503
1504 PP(pp_prtf)
1505 {
1506     dVAR; dSP; dMARK; dORIGMARK;
1507     PerlIO *fp;
1508     SV *sv;
1509
1510     GV * const gv
1511         = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
1512     IO *const io = GvIO(gv);
1513
1514     if (io) {
1515         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1516         if (mg) {
1517             if (MARK == ORIGMARK) {
1518                 MEXTEND(SP, 1);
1519                 ++MARK;
1520                 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1521                 ++SP;
1522             }
1523             return Perl_tied_method(aTHX_ "PRINTF", mark - 1, MUTABLE_SV(io),
1524                                     mg,
1525                                     G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1526                                     sp - mark);
1527         }
1528     }
1529
1530     sv = newSV(0);
1531     if (!io) {
1532         report_evil_fh(gv);
1533         SETERRNO(EBADF,RMS_IFI);
1534         goto just_say_no;
1535     }
1536     else if (!(fp = IoOFP(io))) {
1537         if (IoIFP(io))
1538             report_wrongway_fh(gv, '<');
1539         else if (ckWARN(WARN_CLOSED))
1540             report_evil_fh(gv);
1541         SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
1542         goto just_say_no;
1543     }
1544     else {
1545         do_sprintf(sv, SP - MARK, MARK + 1);
1546         if (!do_print(sv, fp))
1547             goto just_say_no;
1548
1549         if (IoFLAGS(io) & IOf_FLUSH)
1550             if (PerlIO_flush(fp) == EOF)
1551                 goto just_say_no;
1552     }
1553     SvREFCNT_dec(sv);
1554     SP = ORIGMARK;
1555     PUSHs(&PL_sv_yes);
1556     RETURN;
1557
1558   just_say_no:
1559     SvREFCNT_dec(sv);
1560     SP = ORIGMARK;
1561     PUSHs(&PL_sv_undef);
1562     RETURN;
1563 }
1564
1565 PP(pp_sysopen)
1566 {
1567     dVAR;
1568     dSP;
1569     const int perm = (MAXARG > 3 && (TOPs || POPs)) ? POPi : 0666;
1570     const int mode = POPi;
1571     SV * const sv = POPs;
1572     GV * const gv = MUTABLE_GV(POPs);
1573     STRLEN len;
1574
1575     /* Need TIEHANDLE method ? */
1576     const char * const tmps = SvPV_const(sv, len);
1577     /* FIXME? do_open should do const  */
1578     if (do_open(gv, tmps, len, TRUE, mode, perm, NULL)) {
1579         IoLINES(GvIOp(gv)) = 0;
1580         PUSHs(&PL_sv_yes);
1581     }
1582     else {
1583         PUSHs(&PL_sv_undef);
1584     }
1585     RETURN;
1586 }
1587
1588 PP(pp_sysread)
1589 {
1590     dVAR; dSP; dMARK; dORIGMARK; dTARGET;
1591     SSize_t offset;
1592     IO *io;
1593     char *buffer;
1594     STRLEN orig_size;
1595     SSize_t length;
1596     SSize_t count;
1597     SV *bufsv;
1598     STRLEN blen;
1599     int fp_utf8;
1600     int buffer_utf8;
1601     SV *read_target;
1602     Size_t got = 0;
1603     Size_t wanted;
1604     bool charstart = FALSE;
1605     STRLEN charskip = 0;
1606     STRLEN skip = 0;
1607
1608     GV * const gv = MUTABLE_GV(*++MARK);
1609     if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1610         && gv && (io = GvIO(gv)) )
1611     {
1612         const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1613         if (mg) {
1614             return Perl_tied_method(aTHX_ "READ", mark - 1, MUTABLE_SV(io), mg,
1615                                     G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1616                                     sp - mark);
1617         }
1618     }
1619
1620     if (!gv)
1621         goto say_undef;
1622     bufsv = *++MARK;
1623     if (! SvOK(bufsv))
1624         sv_setpvs(bufsv, "");
1625     length = SvIVx(*++MARK);
1626     SETERRNO(0,0);
1627     if (MARK < SP)
1628         offset = SvIVx(*++MARK);
1629     else
1630         offset = 0;
1631     io = GvIO(gv);
1632     if (!io || !IoIFP(io)) {
1633         report_evil_fh(gv);
1634         SETERRNO(EBADF,RMS_IFI);
1635         goto say_undef;
1636     }
1637     if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
1638         buffer = SvPVutf8_force(bufsv, blen);
1639         /* UTF-8 may not have been set if they are all low bytes */
1640         SvUTF8_on(bufsv);
1641         buffer_utf8 = 0;
1642     }
1643     else {
1644         buffer = SvPV_force(bufsv, blen);
1645         buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
1646     }
1647     if (length < 0)
1648         DIE(aTHX_ "Negative length");
1649     wanted = length;
1650
1651     charstart = TRUE;
1652     charskip  = 0;
1653     skip = 0;
1654
1655 #ifdef HAS_SOCKET
1656     if (PL_op->op_type == OP_RECV) {
1657         Sock_size_t bufsize;
1658         char namebuf[MAXPATHLEN];
1659 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__)
1660         bufsize = sizeof (struct sockaddr_in);
1661 #else
1662         bufsize = sizeof namebuf;
1663 #endif
1664 #ifdef OS2      /* At least Warp3+IAK: only the first byte of bufsize set */
1665         if (bufsize >= 256)
1666             bufsize = 255;
1667 #endif
1668         buffer = SvGROW(bufsv, (STRLEN)(length+1));
1669         /* 'offset' means 'flags' here */
1670         count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, offset,
1671                                   (struct sockaddr *)namebuf, &bufsize);
1672         if (count < 0)
1673             RETPUSHUNDEF;
1674         /* MSG_TRUNC can give oversized count; quietly lose it */
1675         if (count > length)
1676             count = length;
1677 #ifdef EPOC
1678         /* Bogus return without padding */
1679         bufsize = sizeof (struct sockaddr_in);
1680 #endif
1681         SvCUR_set(bufsv, count);
1682         *SvEND(bufsv) = '\0';
1683         (void)SvPOK_only(bufsv);
1684         if (fp_utf8)
1685             SvUTF8_on(bufsv);
1686         SvSETMAGIC(bufsv);
1687         /* This should not be marked tainted if the fp is marked clean */
1688         if (!(IoFLAGS(io) & IOf_UNTAINT))
1689             SvTAINTED_on(bufsv);
1690         SP = ORIGMARK;
1691         sv_setpvn(TARG, namebuf, bufsize);
1692         PUSHs(TARG);
1693         RETURN;
1694     }
1695 #endif
1696     if (DO_UTF8(bufsv)) {
1697         /* offset adjust in characters not bytes */
1698         blen = sv_len_utf8(bufsv);
1699     }
1700     if (offset < 0) {
1701         if (-offset > (SSize_t)blen)
1702             DIE(aTHX_ "Offset outside string");
1703         offset += blen;
1704     }
1705     if (DO_UTF8(bufsv)) {
1706         /* convert offset-as-chars to offset-as-bytes */
1707         if (offset >= (int)blen)
1708             offset += SvCUR(bufsv) - blen;
1709         else
1710             offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
1711     }
1712  more_bytes:
1713     orig_size = SvCUR(bufsv);
1714     /* Allocating length + offset + 1 isn't perfect in the case of reading
1715        bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1716        unduly.
1717        (should be 2 * length + offset + 1, or possibly something longer if
1718        PL_encoding is true) */
1719     buffer  = SvGROW(bufsv, (STRLEN)(length+offset+1));
1720     if (offset > 0 && offset > (SSize_t)orig_size) { /* Zero any newly allocated space */
1721         Zero(buffer+orig_size, offset-orig_size, char);
1722     }
1723     buffer = buffer + offset;
1724     if (!buffer_utf8) {
1725         read_target = bufsv;
1726     } else {
1727         /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1728            concatenate it to the current buffer.  */
1729
1730         /* Truncate the existing buffer to the start of where we will be
1731            reading to:  */
1732         SvCUR_set(bufsv, offset);
1733
1734         read_target = sv_newmortal();
1735         SvUPGRADE(read_target, SVt_PV);
1736         buffer = SvGROW(read_target, (STRLEN)(length + 1));
1737     }
1738
1739     if (PL_op->op_type == OP_SYSREAD) {
1740 #ifdef PERL_SOCK_SYSREAD_IS_RECV
1741         if (IoTYPE(io) == IoTYPE_SOCKET) {
1742             count = PerlSock_recv(PerlIO_fileno(IoIFP(io)),
1743                                    buffer, length, 0);
1744         }
1745         else
1746 #endif
1747         {
1748             count = PerlLIO_read(PerlIO_fileno(IoIFP(io)),
1749                                   buffer, length);
1750         }
1751     }
1752     else
1753 #ifdef HAS_SOCKET__bad_code_maybe
1754     if (IoTYPE(io) == IoTYPE_SOCKET) {
1755         Sock_size_t bufsize;
1756         char namebuf[MAXPATHLEN];
1757 #if defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)
1758         bufsize = sizeof (struct sockaddr_in);
1759 #else
1760         bufsize = sizeof namebuf;
1761 #endif
1762         count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, 0,
1763                           (struct sockaddr *)namebuf, &bufsize);
1764     }
1765     else
1766 #endif
1767     {
1768         count = PerlIO_read(IoIFP(io), buffer, length);
1769         /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1770         if (count == 0 && PerlIO_error(IoIFP(io)))
1771             count = -1;
1772     }
1773     if (count < 0) {
1774         if (IoTYPE(io) == IoTYPE_WRONLY)
1775             report_wrongway_fh(gv, '>');
1776         goto say_undef;
1777     }
1778     SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1779     *SvEND(read_target) = '\0';
1780     (void)SvPOK_only(read_target);
1781     if (fp_utf8 && !IN_BYTES) {
1782         /* Look at utf8 we got back and count the characters */
1783         const char *bend = buffer + count;
1784         while (buffer < bend) {
1785             if (charstart) {
1786                 skip = UTF8SKIP(buffer);
1787                 charskip = 0;
1788             }
1789             if (buffer - charskip + skip > bend) {
1790                 /* partial character - try for rest of it */
1791                 length = skip - (bend-buffer);
1792                 offset = bend - SvPVX_const(bufsv);
1793                 charstart = FALSE;
1794                 charskip += count;
1795                 goto more_bytes;
1796             }
1797             else {
1798                 got++;
1799                 buffer += skip;
1800                 charstart = TRUE;
1801                 charskip  = 0;
1802             }
1803         }
1804         /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1805            provided amount read (count) was what was requested (length)
1806          */
1807         if (got < wanted && count == length) {
1808             length = wanted - got;
1809             offset = bend - SvPVX_const(bufsv);
1810             goto more_bytes;
1811         }
1812         /* return value is character count */
1813         count = got;
1814         SvUTF8_on(bufsv);
1815     }
1816     else if (buffer_utf8) {
1817         /* Let svcatsv upgrade the bytes we read in to utf8.
1818            The buffer is a mortal so will be freed soon.  */
1819         sv_catsv_nomg(bufsv, read_target);
1820     }
1821     SvSETMAGIC(bufsv);
1822     /* This should not be marked tainted if the fp is marked clean */
1823     if (!(IoFLAGS(io) & IOf_UNTAINT))
1824         SvTAINTED_on(bufsv);
1825     SP = ORIGMARK;
1826     PUSHi(count);
1827     RETURN;
1828
1829   say_undef:
1830     SP = ORIGMARK;
1831     RETPUSHUNDEF;
1832 }
1833
1834 PP(pp_syswrite)
1835 {
1836     dVAR; dSP; dMARK; dORIGMARK; dTARGET;
1837     SV *bufsv;
1838     const char *buffer;
1839     SSize_t retval;
1840     STRLEN blen;
1841     STRLEN orig_blen_bytes;
1842     const int op_type = PL_op->op_type;
1843     bool doing_utf8;
1844     U8 *tmpbuf = NULL;
1845     GV *const gv = MUTABLE_GV(*++MARK);
1846     IO *const io = GvIO(gv);
1847
1848     if (op_type == OP_SYSWRITE && io) {
1849         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1850         if (mg) {
1851             if (MARK == SP - 1) {
1852                 SV *sv = *SP;
1853                 mXPUSHi(sv_len(sv));
1854                 PUTBACK;
1855             }
1856
1857             return Perl_tied_method(aTHX_ "WRITE", mark - 1, MUTABLE_SV(io), mg,
1858                                     G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1859                                     sp - mark);
1860         }
1861     }
1862     if (!gv)
1863         goto say_undef;
1864
1865     bufsv = *++MARK;
1866
1867     SETERRNO(0,0);
1868     if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
1869         retval = -1;
1870         if (io && IoIFP(io))
1871             report_wrongway_fh(gv, '<');
1872         else
1873             report_evil_fh(gv);
1874         SETERRNO(EBADF,RMS_IFI);
1875         goto say_undef;
1876     }
1877
1878     /* Do this first to trigger any overloading.  */
1879     buffer = SvPV_const(bufsv, blen);
1880     orig_blen_bytes = blen;
1881     doing_utf8 = DO_UTF8(bufsv);
1882
1883     if (PerlIO_isutf8(IoIFP(io))) {
1884         if (!SvUTF8(bufsv)) {
1885             /* We don't modify the original scalar.  */
1886             tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
1887             buffer = (char *) tmpbuf;
1888             doing_utf8 = TRUE;
1889         }
1890     }
1891     else if (doing_utf8) {
1892         STRLEN tmplen = blen;
1893         U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
1894         if (!doing_utf8) {
1895             tmpbuf = result;
1896             buffer = (char *) tmpbuf;
1897             blen = tmplen;
1898         }
1899         else {
1900             assert((char *)result == buffer);
1901             Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
1902         }
1903     }
1904
1905 #ifdef HAS_SOCKET
1906     if (op_type == OP_SEND) {
1907         const int flags = SvIVx(*++MARK);
1908         if (SP > MARK) {
1909             STRLEN mlen;
1910             char * const sockbuf = SvPVx(*++MARK, mlen);
1911             retval = PerlSock_sendto(PerlIO_fileno(IoIFP(io)), buffer, blen,
1912                                      flags, (struct sockaddr *)sockbuf, mlen);
1913         }
1914         else {
1915             retval
1916                 = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, blen, flags);
1917         }
1918     }
1919     else
1920 #endif
1921     {
1922         Size_t length = 0; /* This length is in characters.  */
1923         STRLEN blen_chars;
1924         IV offset;
1925
1926         if (doing_utf8) {
1927             if (tmpbuf) {
1928                 /* The SV is bytes, and we've had to upgrade it.  */
1929                 blen_chars = orig_blen_bytes;
1930             } else {
1931                 /* The SV really is UTF-8.  */
1932                 if (SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
1933                     /* Don't call sv_len_utf8 again because it will call magic
1934                        or overloading a second time, and we might get back a
1935                        different result.  */
1936                     blen_chars = utf8_length((U8*)buffer, (U8*)buffer + blen);
1937                 } else {
1938                     /* It's safe, and it may well be cached.  */
1939                     blen_chars = sv_len_utf8(bufsv);
1940                 }
1941             }
1942         } else {
1943             blen_chars = blen;
1944         }
1945
1946         if (MARK >= SP) {
1947             length = blen_chars;
1948         } else {
1949 #if Size_t_size > IVSIZE
1950             length = (Size_t)SvNVx(*++MARK);
1951 #else
1952             length = (Size_t)SvIVx(*++MARK);
1953 #endif
1954             if ((SSize_t)length < 0) {
1955                 Safefree(tmpbuf);
1956                 DIE(aTHX_ "Negative length");
1957             }
1958         }
1959
1960         if (MARK < SP) {
1961             offset = SvIVx(*++MARK);
1962             if (offset < 0) {
1963                 if (-offset > (IV)blen_chars) {
1964                     Safefree(tmpbuf);
1965                     DIE(aTHX_ "Offset outside string");
1966                 }
1967                 offset += blen_chars;
1968             } else if (offset > (IV)blen_chars) {
1969                 Safefree(tmpbuf);
1970                 DIE(aTHX_ "Offset outside string");
1971             }
1972         } else
1973             offset = 0;
1974         if (length > blen_chars - offset)
1975             length = blen_chars - offset;
1976         if (doing_utf8) {
1977             /* Here we convert length from characters to bytes.  */
1978             if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
1979                 /* Either we had to convert the SV, or the SV is magical, or
1980                    the SV has overloading, in which case we can't or mustn't
1981                    or mustn't call it again.  */
1982
1983                 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
1984                 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
1985             } else {
1986                 /* It's a real UTF-8 SV, and it's not going to change under
1987                    us.  Take advantage of any cache.  */
1988                 I32 start = offset;
1989                 I32 len_I32 = length;
1990
1991                 /* Convert the start and end character positions to bytes.
1992                    Remember that the second argument to sv_pos_u2b is relative
1993                    to the first.  */
1994                 sv_pos_u2b(bufsv, &start, &len_I32);
1995
1996                 buffer += start;
1997                 length = len_I32;
1998             }
1999         }
2000         else {
2001             buffer = buffer+offset;
2002         }
2003 #ifdef PERL_SOCK_SYSWRITE_IS_SEND
2004         if (IoTYPE(io) == IoTYPE_SOCKET) {
2005             retval = PerlSock_send(PerlIO_fileno(IoIFP(io)),
2006                                    buffer, length, 0);
2007         }
2008         else
2009 #endif
2010         {
2011             /* See the note at doio.c:do_print about filesize limits. --jhi */
2012             retval = PerlLIO_write(PerlIO_fileno(IoIFP(io)),
2013                                    buffer, length);
2014         }
2015     }
2016
2017     if (retval < 0)
2018         goto say_undef;
2019     SP = ORIGMARK;
2020     if (doing_utf8)
2021         retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
2022
2023     Safefree(tmpbuf);
2024 #if Size_t_size > IVSIZE
2025     PUSHn(retval);
2026 #else
2027     PUSHi(retval);
2028 #endif
2029     RETURN;
2030
2031   say_undef:
2032     Safefree(tmpbuf);
2033     SP = ORIGMARK;
2034     RETPUSHUNDEF;
2035 }
2036
2037 PP(pp_eof)
2038 {
2039     dVAR; dSP;
2040     GV *gv;
2041     IO *io;
2042     const MAGIC *mg;
2043     /*
2044      * in Perl 5.12 and later, the additional parameter is a bitmask:
2045      * 0 = eof
2046      * 1 = eof(FH)
2047      * 2 = eof()  <- ARGV magic
2048      *
2049      * I'll rely on the compiler's trace flow analysis to decide whether to
2050      * actually assign this out here, or punt it into the only block where it is
2051      * used. Doing it out here is DRY on the condition logic.
2052      */
2053     unsigned int which;
2054
2055     if (MAXARG) {
2056         gv = PL_last_in_gv = MUTABLE_GV(POPs);  /* eof(FH) */
2057         which = 1;
2058     }
2059     else {
2060         EXTEND(SP, 1);
2061
2062         if (PL_op->op_flags & OPf_SPECIAL) {
2063             gv = PL_last_in_gv = GvEGVx(PL_argvgv);     /* eof() - ARGV magic */
2064             which = 2;
2065         }
2066         else {
2067             gv = PL_last_in_gv;                 /* eof */
2068             which = 0;
2069         }
2070     }
2071
2072     if (!gv)
2073         RETPUSHNO;
2074
2075     if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
2076         return tied_method1("EOF", SP, MUTABLE_SV(io), mg, newSVuv(which));
2077     }
2078
2079     if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) {   /* eof() */
2080         if (io && !IoIFP(io)) {
2081             if ((IoFLAGS(io) & IOf_START) && av_len(GvAVn(gv)) < 0) {
2082                 IoLINES(io) = 0;
2083                 IoFLAGS(io) &= ~IOf_START;
2084                 do_open(gv, "-", 1, FALSE, O_RDONLY, 0, NULL);
2085                 if (GvSV(gv))
2086                     sv_setpvs(GvSV(gv), "-");
2087                 else
2088                     GvSV(gv) = newSVpvs("-");
2089                 SvSETMAGIC(GvSV(gv));
2090             }
2091             else if (!nextargv(gv))
2092                 RETPUSHYES;
2093         }
2094     }
2095
2096     PUSHs(boolSV(do_eof(gv)));
2097     RETURN;
2098 }
2099
2100 PP(pp_tell)
2101 {
2102     dVAR; dSP; dTARGET;
2103     GV *gv;
2104     IO *io;
2105
2106     if (MAXARG != 0 && (TOPs || POPs))
2107         PL_last_in_gv = MUTABLE_GV(POPs);
2108     else
2109         EXTEND(SP, 1);
2110     gv = PL_last_in_gv;
2111
2112     io = GvIO(gv);
2113     if (io) {
2114         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2115         if (mg) {
2116             return tied_method0("TELL", SP, MUTABLE_SV(io), mg);
2117         }
2118     }
2119     else if (!gv) {
2120         if (!errno)
2121             SETERRNO(EBADF,RMS_IFI);
2122         PUSHi(-1);
2123         RETURN;
2124     }
2125
2126 #if LSEEKSIZE > IVSIZE
2127     PUSHn( do_tell(gv) );
2128 #else
2129     PUSHi( do_tell(gv) );
2130 #endif
2131     RETURN;
2132 }
2133
2134 PP(pp_sysseek)
2135 {
2136     dVAR; dSP;
2137     const int whence = POPi;
2138 #if LSEEKSIZE > IVSIZE
2139     const Off_t offset = (Off_t)SvNVx(POPs);
2140 #else
2141     const Off_t offset = (Off_t)SvIVx(POPs);
2142 #endif
2143
2144     GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
2145     IO *const io = GvIO(gv);
2146
2147     if (io) {
2148         const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
2149         if (mg) {
2150 #if LSEEKSIZE > IVSIZE
2151             SV *const offset_sv = newSVnv((NV) offset);
2152 #else
2153             SV *const offset_sv = newSViv(offset);
2154 #endif
2155
2156             return tied_method2("SEEK", SP, MUTABLE_SV(io), mg, offset_sv,
2157                                 newSViv(whence));
2158         }
2159     }
2160
2161     if (PL_op->op_type == OP_SEEK)
2162         PUSHs(boolSV(do_seek(gv, offset, whence)));
2163     else {
2164         const Off_t sought = do_sysseek(gv, offset, whence);
2165         if (sought < 0)
2166             PUSHs(&PL_sv_undef);
2167         else {
2168             SV* const sv = sought ?
2169 #if LSEEKSIZE > IVSIZE
2170                 newSVnv((NV)sought)
2171 #else
2172                 newSViv(sought)
2173 #endif
2174                 : newSVpvn(zero_but_true, ZBTLEN);
2175             mPUSHs(sv);
2176         }
2177     }
2178     RETURN;
2179 }
2180
2181 PP(pp_truncate)
2182 {
2183     dVAR;
2184     dSP;
2185     /* There seems to be no consensus on the length type of truncate()
2186      * and ftruncate(), both off_t and size_t have supporters. In
2187      * general one would think that when using large files, off_t is
2188      * at least as wide as size_t, so using an off_t should be okay. */
2189     /* XXX Configure probe for the length type of *truncate() needed XXX */
2190     Off_t len;
2191
2192 #if Off_t_size > IVSIZE
2193     len = (Off_t)POPn;
2194 #else
2195     len = (Off_t)POPi;
2196 #endif
2197     /* Checking for length < 0 is problematic as the type might or
2198      * might not be signed: if it is not, clever compilers will moan. */
2199     /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
2200     SETERRNO(0,0);
2201     {
2202         SV * const sv = POPs;
2203         int result = 1;
2204         GV *tmpgv;
2205         IO *io;
2206
2207         if ((tmpgv = PL_op->op_flags & OPf_SPECIAL
2208                        ? gv_fetchsv(sv, 0, SVt_PVIO)
2209                        : MAYBE_DEREF_GV(sv) )) {
2210             io = GvIO(tmpgv);
2211             if (!io)
2212                 result = 0;
2213             else {
2214                 PerlIO *fp;
2215             do_ftruncate_io:
2216                 TAINT_PROPER("truncate");
2217                 if (!(fp = IoIFP(io))) {
2218                     result = 0;
2219                 }
2220                 else {
2221                     PerlIO_flush(fp);
2222 #ifdef HAS_TRUNCATE
2223                     if (ftruncate(PerlIO_fileno(fp), len) < 0)
2224 #else
2225                     if (my_chsize(PerlIO_fileno(fp), len) < 0)
2226 #endif
2227                         result = 0;
2228                 }
2229             }
2230         }
2231         else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2232                 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
2233                 goto do_ftruncate_io;
2234         }
2235         else {
2236             const char * const name = SvPV_nomg_const_nolen(sv);
2237             TAINT_PROPER("truncate");
2238 #ifdef HAS_TRUNCATE
2239             if (truncate(name, len) < 0)
2240                 result = 0;
2241 #else
2242             {
2243                 const int tmpfd = PerlLIO_open(name, O_RDWR);
2244
2245                 if (tmpfd < 0)
2246                     result = 0;
2247                 else {
2248                     if (my_chsize(tmpfd, len) < 0)
2249                         result = 0;
2250                     PerlLIO_close(tmpfd);
2251                 }
2252             }
2253 #endif
2254         }
2255
2256         if (result)
2257             RETPUSHYES;
2258         if (!errno)
2259             SETERRNO(EBADF,RMS_IFI);
2260         RETPUSHUNDEF;
2261     }
2262 }
2263
2264 PP(pp_ioctl)
2265 {
2266     dVAR; dSP; dTARGET;
2267     SV * const argsv = POPs;
2268     const unsigned int func = POPu;
2269     const int optype = PL_op->op_type;
2270     GV * const gv = MUTABLE_GV(POPs);
2271     IO * const io = gv ? GvIOn(gv) : NULL;
2272     char *s;
2273     IV retval;
2274
2275     if (!io || !argsv || !IoIFP(io)) {
2276         report_evil_fh(gv);
2277         SETERRNO(EBADF,RMS_IFI);        /* well, sort of... */
2278         RETPUSHUNDEF;
2279     }
2280
2281     if (SvPOK(argsv) || !SvNIOK(argsv)) {
2282         STRLEN len;
2283         STRLEN need;
2284         s = SvPV_force(argsv, len);
2285         need = IOCPARM_LEN(func);
2286         if (len < need) {
2287             s = Sv_Grow(argsv, need + 1);
2288             SvCUR_set(argsv, need);
2289         }
2290
2291         s[SvCUR(argsv)] = 17;   /* a little sanity check here */
2292     }
2293     else {
2294         retval = SvIV(argsv);
2295         s = INT2PTR(char*,retval);              /* ouch */
2296     }
2297
2298     TAINT_PROPER(PL_op_desc[optype]);
2299
2300     if (optype == OP_IOCTL)
2301 #ifdef HAS_IOCTL
2302         retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
2303 #else
2304         DIE(aTHX_ "ioctl is not implemented");
2305 #endif
2306     else
2307 #ifndef HAS_FCNTL
2308       DIE(aTHX_ "fcntl is not implemented");
2309 #else
2310 #if defined(OS2) && defined(__EMX__)
2311         retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
2312 #else
2313         retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
2314 #endif
2315 #endif
2316
2317 #if defined(HAS_IOCTL) || defined(HAS_FCNTL)
2318     if (SvPOK(argsv)) {
2319         if (s[SvCUR(argsv)] != 17)
2320             DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
2321                 OP_NAME(PL_op));
2322         s[SvCUR(argsv)] = 0;            /* put our null back */
2323         SvSETMAGIC(argsv);              /* Assume it has changed */
2324     }
2325
2326     if (retval == -1)
2327         RETPUSHUNDEF;
2328     if (retval != 0) {
2329         PUSHi(retval);
2330     }
2331     else {
2332         PUSHp(zero_but_true, ZBTLEN);
2333     }
2334 #endif
2335     RETURN;
2336 }
2337
2338 PP(pp_flock)
2339 {
2340 #ifdef FLOCK
2341     dVAR; dSP; dTARGET;
2342     I32 value;
2343     const int argtype = POPi;
2344     GV * const gv = (MAXARG == 0) ? PL_last_in_gv : MUTABLE_GV(POPs);
2345     IO *const io = GvIO(gv);
2346     PerlIO *const fp = io ? IoIFP(io) : NULL;
2347
2348     /* XXX Looks to me like io is always NULL at this point */
2349     if (fp) {
2350         (void)PerlIO_flush(fp);
2351         value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
2352     }
2353     else {
2354         report_evil_fh(gv);
2355         value = 0;
2356         SETERRNO(EBADF,RMS_IFI);
2357     }
2358     PUSHi(value);
2359     RETURN;
2360 #else
2361     DIE(aTHX_ PL_no_func, "flock()");
2362 #endif
2363 }
2364
2365 /* Sockets. */
2366
2367 #ifdef HAS_SOCKET
2368
2369 PP(pp_socket)
2370 {
2371     dVAR; dSP;
2372     const int protocol = POPi;
2373     const int type = POPi;
2374     const int domain = POPi;
2375     GV * const gv = MUTABLE_GV(POPs);
2376     register IO * const io = gv ? GvIOn(gv) : NULL;
2377     int fd;
2378
2379     if (!io) {
2380         report_evil_fh(gv);
2381         if (io && IoIFP(io))
2382             do_close(gv, FALSE);
2383         SETERRNO(EBADF,LIB_INVARG);
2384         RETPUSHUNDEF;
2385     }
2386
2387     if (IoIFP(io))
2388         do_close(gv, FALSE);
2389
2390     TAINT_PROPER("socket");
2391     fd = PerlSock_socket(domain, type, protocol);
2392     if (fd < 0)
2393         RETPUSHUNDEF;
2394     IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2395     IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2396     IoTYPE(io) = IoTYPE_SOCKET;
2397     if (!IoIFP(io) || !IoOFP(io)) {
2398         if (IoIFP(io)) PerlIO_close(IoIFP(io));
2399         if (IoOFP(io)) PerlIO_close(IoOFP(io));
2400         if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
2401         RETPUSHUNDEF;
2402     }
2403 #if defined(HAS_FCNTL) && defined(F_SETFD)
2404     fcntl(fd, F_SETFD, fd > PL_maxsysfd);       /* ensure close-on-exec */
2405 #endif
2406
2407 #ifdef EPOC
2408     setbuf( IoIFP(io), NULL); /* EPOC gets confused about sockets */
2409 #endif
2410
2411     RETPUSHYES;
2412 }
2413 #endif
2414
2415 PP(pp_sockpair)
2416 {
2417 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
2418     dVAR; dSP;
2419     const int protocol = POPi;
2420     const int type = POPi;
2421     const int domain = POPi;
2422     GV * const gv2 = MUTABLE_GV(POPs);
2423     GV * const gv1 = MUTABLE_GV(POPs);
2424     register IO * const io1 = gv1 ? GvIOn(gv1) : NULL;
2425     register IO * const io2 = gv2 ? GvIOn(gv2) : NULL;
2426     int fd[2];
2427
2428     if (!io1)
2429         report_evil_fh(gv1);
2430     if (!io2)
2431         report_evil_fh(gv2);
2432
2433     if (io1 && IoIFP(io1))
2434         do_close(gv1, FALSE);
2435     if (io2 && IoIFP(io2))
2436         do_close(gv2, FALSE);
2437
2438     if (!io1 || !io2)
2439         RETPUSHUNDEF;
2440
2441     TAINT_PROPER("socketpair");
2442     if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
2443         RETPUSHUNDEF;
2444     IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2445     IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
2446     IoTYPE(io1) = IoTYPE_SOCKET;
2447     IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2448     IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
2449     IoTYPE(io2) = IoTYPE_SOCKET;
2450     if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
2451         if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2452         if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
2453         if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
2454         if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2455         if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
2456         if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
2457         RETPUSHUNDEF;
2458     }
2459 #if defined(HAS_FCNTL) && defined(F_SETFD)
2460     fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd);   /* ensure close-on-exec */
2461     fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd);   /* ensure close-on-exec */
2462 #endif
2463
2464     RETPUSHYES;
2465 #else
2466     DIE(aTHX_ PL_no_sock_func, "socketpair");
2467 #endif
2468 }
2469
2470 #ifdef HAS_SOCKET
2471
2472 PP(pp_bind)
2473 {
2474     dVAR; dSP;
2475     SV * const addrsv = POPs;
2476     /* OK, so on what platform does bind modify addr?  */
2477     const char *addr;
2478     GV * const gv = MUTABLE_GV(POPs);
2479     register IO * const io = GvIOn(gv);
2480     STRLEN len;
2481     const int op_type = PL_op->op_type;
2482
2483     if (!io || !IoIFP(io))
2484         goto nuts;
2485
2486     addr = SvPV_const(addrsv, len);
2487     TAINT_PROPER(PL_op_desc[op_type]);
2488     if ((op_type == OP_BIND
2489          ? PerlSock_bind(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len)
2490          : PerlSock_connect(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len))
2491         >= 0)
2492         RETPUSHYES;
2493     else
2494         RETPUSHUNDEF;
2495
2496 nuts:
2497     report_evil_fh(gv);
2498     SETERRNO(EBADF,SS_IVCHAN);
2499     RETPUSHUNDEF;
2500 }
2501
2502 PP(pp_listen)
2503 {
2504     dVAR; dSP;
2505     const int backlog = POPi;
2506     GV * const gv = MUTABLE_GV(POPs);
2507     register IO * const io = gv ? GvIOn(gv) : NULL;
2508
2509     if (!io || !IoIFP(io))
2510         goto nuts;
2511
2512     if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
2513         RETPUSHYES;
2514     else
2515         RETPUSHUNDEF;
2516
2517 nuts:
2518     report_evil_fh(gv);
2519     SETERRNO(EBADF,SS_IVCHAN);
2520     RETPUSHUNDEF;
2521 }
2522
2523 PP(pp_accept)
2524 {
2525     dVAR; dSP; dTARGET;
2526     register IO *nstio;
2527     register IO *gstio;
2528     char namebuf[MAXPATHLEN];
2529 #if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__)
2530     Sock_size_t len = sizeof (struct sockaddr_in);
2531 #else
2532     Sock_size_t len = sizeof namebuf;
2533 #endif
2534     GV * const ggv = MUTABLE_GV(POPs);
2535     GV * const ngv = MUTABLE_GV(POPs);
2536     int fd;
2537
2538     if (!ngv)
2539         goto badexit;
2540     if (!ggv)
2541         goto nuts;
2542
2543     gstio = GvIO(ggv);
2544     if (!gstio || !IoIFP(gstio))
2545         goto nuts;
2546
2547     nstio = GvIOn(ngv);
2548     fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
2549 #if defined(OEMVS)
2550     if (len == 0) {
2551         /* Some platforms indicate zero length when an AF_UNIX client is
2552          * not bound. Simulate a non-zero-length sockaddr structure in
2553          * this case. */
2554         namebuf[0] = 0;        /* sun_len */
2555         namebuf[1] = AF_UNIX;  /* sun_family */
2556         len = 2;
2557     }
2558 #endif
2559
2560     if (fd < 0)
2561         goto badexit;
2562     if (IoIFP(nstio))
2563         do_close(ngv, FALSE);
2564     IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2565     IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
2566     IoTYPE(nstio) = IoTYPE_SOCKET;
2567     if (!IoIFP(nstio) || !IoOFP(nstio)) {
2568         if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2569         if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
2570         if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
2571         goto badexit;
2572     }
2573 #if defined(HAS_FCNTL) && defined(F_SETFD)
2574     fcntl(fd, F_SETFD, fd > PL_maxsysfd);       /* ensure close-on-exec */
2575 #endif
2576
2577 #ifdef EPOC
2578     len = sizeof (struct sockaddr_in); /* EPOC somehow truncates info */
2579     setbuf( IoIFP(nstio), NULL); /* EPOC gets confused about sockets */
2580 #endif
2581 #ifdef __SCO_VERSION__
2582     len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
2583 #endif
2584
2585     PUSHp(namebuf, len);
2586     RETURN;
2587
2588 nuts:
2589     report_evil_fh(ggv);
2590     SETERRNO(EBADF,SS_IVCHAN);
2591
2592 badexit:
2593     RETPUSHUNDEF;
2594
2595 }
2596
2597 PP(pp_shutdown)
2598 {
2599     dVAR; dSP; dTARGET;
2600     const int how = POPi;
2601     GV * const gv = MUTABLE_GV(POPs);
2602     register IO * const io = GvIOn(gv);
2603
2604     if (!io || !IoIFP(io))
2605         goto nuts;
2606
2607     PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
2608     RETURN;
2609
2610 nuts:
2611     report_evil_fh(gv);
2612     SETERRNO(EBADF,SS_IVCHAN);
2613     RETPUSHUNDEF;
2614 }
2615
2616 PP(pp_ssockopt)
2617 {
2618     dVAR; dSP;
2619     const int optype = PL_op->op_type;
2620     SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
2621     const unsigned int optname = (unsigned int) POPi;
2622     const unsigned int lvl = (unsigned int) POPi;
2623     GV * const gv = MUTABLE_GV(POPs);
2624     register IO * const io = GvIOn(gv);
2625     int fd;
2626     Sock_size_t len;
2627
2628     if (!io || !IoIFP(io))
2629         goto nuts;
2630
2631     fd = PerlIO_fileno(IoIFP(io));
2632     switch (optype) {
2633     case OP_GSOCKOPT:
2634         SvGROW(sv, 257);
2635         (void)SvPOK_only(sv);
2636         SvCUR_set(sv,256);
2637         *SvEND(sv) ='\0';
2638         len = SvCUR(sv);
2639         if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
2640             goto nuts2;
2641         SvCUR_set(sv, len);
2642         *SvEND(sv) ='\0';
2643         PUSHs(sv);
2644         break;
2645     case OP_SSOCKOPT: {
2646 #if defined(__SYMBIAN32__)
2647 # define SETSOCKOPT_OPTION_VALUE_T void *
2648 #else
2649 # define SETSOCKOPT_OPTION_VALUE_T const char *
2650 #endif
2651         /* XXX TODO: We need to have a proper type (a Configure probe,
2652          * etc.) for what the C headers think of the third argument of
2653          * setsockopt(), the option_value read-only buffer: is it
2654          * a "char *", or a "void *", const or not.  Some compilers
2655          * don't take kindly to e.g. assuming that "char *" implicitly
2656          * promotes to a "void *", or to explicitly promoting/demoting
2657          * consts to non/vice versa.  The "const void *" is the SUS
2658          * definition, but that does not fly everywhere for the above
2659          * reasons. */
2660             SETSOCKOPT_OPTION_VALUE_T buf;
2661             int aint;
2662             if (SvPOKp(sv)) {
2663                 STRLEN l;
2664                 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2665                 len = l;
2666             }
2667             else {
2668                 aint = (int)SvIV(sv);
2669                 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
2670                 len = sizeof(int);
2671             }
2672             if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
2673                 goto nuts2;
2674             PUSHs(&PL_sv_yes);
2675         }
2676         break;
2677     }
2678     RETURN;
2679
2680 nuts:
2681     report_evil_fh(gv);
2682     SETERRNO(EBADF,SS_IVCHAN);
2683 nuts2:
2684     RETPUSHUNDEF;
2685
2686 }
2687
2688 PP(pp_getpeername)
2689 {
2690     dVAR; dSP;
2691     const int optype = PL_op->op_type;
2692     GV * const gv = MUTABLE_GV(POPs);
2693     register IO * const io = GvIOn(gv);
2694     Sock_size_t len;
2695     SV *sv;
2696     int fd;
2697
2698     if (!io || !IoIFP(io))
2699         goto nuts;
2700
2701     sv = sv_2mortal(newSV(257));
2702     (void)SvPOK_only(sv);
2703     len = 256;
2704     SvCUR_set(sv, len);
2705     *SvEND(sv) ='\0';
2706     fd = PerlIO_fileno(IoIFP(io));
2707     switch (optype) {
2708     case OP_GETSOCKNAME:
2709         if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2710             goto nuts2;
2711         break;
2712     case OP_GETPEERNAME:
2713         if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
2714             goto nuts2;
2715 #if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2716         {
2717             static const char nowhere[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
2718             /* If the call succeeded, make sure we don't have a zeroed port/addr */
2719             if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2720                 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
2721                         sizeof(u_short) + sizeof(struct in_addr))) {
2722                 goto nuts2;
2723             }
2724         }
2725 #endif
2726         break;
2727     }
2728 #ifdef BOGUS_GETNAME_RETURN
2729     /* Interactive Unix, getpeername() and getsockname()
2730       does not return valid namelen */
2731     if (len == BOGUS_GETNAME_RETURN)
2732         len = sizeof(struct sockaddr);
2733 #endif
2734     SvCUR_set(sv, len);
2735     *SvEND(sv) ='\0';
2736     PUSHs(sv);
2737     RETURN;
2738
2739 nuts:
2740     report_evil_fh(gv);
2741     SETERRNO(EBADF,SS_IVCHAN);
2742 nuts2:
2743     RETPUSHUNDEF;
2744 }
2745
2746 #endif
2747
2748 /* Stat calls. */
2749
2750 PP(pp_stat)
2751 {
2752     dVAR;
2753     dSP;
2754     GV *gv = NULL;
2755     IO *io = NULL;
2756     I32 gimme;
2757     I32 max = 13;
2758     SV* sv;
2759
2760     if (PL_op->op_flags & OPf_REF ? (gv = cGVOP_gv, 1)
2761                                   : !!(sv=POPs, gv = MAYBE_DEREF_GV(sv))) {
2762         bool havefp;
2763         if (PL_op->op_type == OP_LSTAT) {
2764             if (gv != PL_defgv) {
2765             do_fstat_warning_check:
2766                 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2767                                "lstat() on filehandle%s%"SVf,
2768                                 gv ? " " : "",
2769                                 SVfARG(gv
2770                                         ? sv_2mortal(newSVhek(GvENAME_HEK(gv)))
2771                                         : &PL_sv_no));
2772             } else if (PL_laststype != OP_LSTAT)
2773                 /* diag_listed_as: The stat preceding %s wasn't an lstat */
2774                 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
2775         }
2776
2777         havefp = FALSE;
2778         if (gv != PL_defgv) {
2779           do_fstat_have_io:
2780             PL_laststype = OP_STAT;
2781             PL_statgv = gv ? gv : (GV *)io;
2782             sv_setpvs(PL_statname, "");
2783             if(gv) {
2784                 io = GvIO(gv);
2785             }
2786             if (io) {
2787                     if (IoIFP(io)) {
2788                         PL_laststatval =
2789                             PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache);
2790                         havefp = TRUE;
2791                     } else if (IoDIRP(io)) {
2792                         PL_laststatval =
2793                             PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
2794                         havefp = TRUE;
2795                     } else {
2796                         PL_laststatval = -1;
2797                     }
2798             }
2799         }
2800
2801         if (PL_laststatval < 0) {
2802             if (!havefp) report_evil_fh(gv);
2803             max = 0;
2804         }
2805     }
2806     else {
2807         if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
2808             io = MUTABLE_IO(SvRV(sv));
2809             if (PL_op->op_type == OP_LSTAT)
2810                 goto do_fstat_warning_check;
2811             goto do_fstat_have_io;
2812         }
2813
2814         sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
2815         PL_statgv = NULL;
2816         PL_laststype = PL_op->op_type;
2817         if (PL_op->op_type == OP_LSTAT)
2818             PL_laststatval = PerlLIO_lstat(SvPV_nolen_const(PL_statname), &PL_statcache);
2819         else
2820             PL_laststatval = PerlLIO_stat(SvPV_nolen_const(PL_statname), &PL_statcache);
2821         if (PL_laststatval < 0) {
2822             if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname), '\n'))
2823                 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
2824             max = 0;
2825         }
2826     }
2827
2828     gimme = GIMME_V;
2829     if (gimme != G_ARRAY) {
2830         if (gimme != G_VOID)
2831             XPUSHs(boolSV(max));
2832         RETURN;
2833     }
2834     if (max) {
2835         EXTEND(SP, max);
2836         EXTEND_MORTAL(max);
2837         mPUSHi(PL_statcache.st_dev);
2838 #if ST_INO_SIZE > IVSIZE
2839         mPUSHn(PL_statcache.st_ino);
2840 #else
2841 #   if ST_INO_SIGN <= 0
2842         mPUSHi(PL_statcache.st_ino);
2843 #   else
2844         mPUSHu(PL_statcache.st_ino);
2845 #   endif
2846 #endif
2847         mPUSHu(PL_statcache.st_mode);
2848         mPUSHu(PL_statcache.st_nlink);
2849 #if Uid_t_size > IVSIZE
2850         mPUSHn(PL_statcache.st_uid);
2851 #else
2852 #   if Uid_t_sign <= 0
2853         mPUSHi(PL_statcache.st_uid);
2854 #   else
2855         mPUSHu(PL_statcache.st_uid);
2856 #   endif
2857 #endif
2858 #if Gid_t_size > IVSIZE
2859         mPUSHn(PL_statcache.st_gid);
2860 #else
2861 #   if Gid_t_sign <= 0
2862         mPUSHi(PL_statcache.st_gid);
2863 #   else
2864         mPUSHu(PL_statcache.st_gid);
2865 #   endif
2866 #endif
2867 #ifdef USE_STAT_RDEV
2868         mPUSHi(PL_statcache.st_rdev);
2869 #else
2870         PUSHs(newSVpvs_flags("", SVs_TEMP));
2871 #endif
2872 #if Off_t_size > IVSIZE
2873         mPUSHn(PL_statcache.st_size);
2874 #else
2875         mPUSHi(PL_statcache.st_size);
2876 #endif
2877 #ifdef BIG_TIME
2878         mPUSHn(PL_statcache.st_atime);
2879         mPUSHn(PL_statcache.st_mtime);
2880         mPUSHn(PL_statcache.st_ctime);
2881 #else
2882         mPUSHi(PL_statcache.st_atime);
2883         mPUSHi(PL_statcache.st_mtime);
2884         mPUSHi(PL_statcache.st_ctime);
2885 #endif
2886 #ifdef USE_STAT_BLOCKS
2887         mPUSHu(PL_statcache.st_blksize);
2888         mPUSHu(PL_statcache.st_blocks);
2889 #else
2890         PUSHs(newSVpvs_flags("", SVs_TEMP));
2891         PUSHs(newSVpvs_flags("", SVs_TEMP));
2892 #endif
2893     }
2894     RETURN;
2895 }
2896
2897 #define tryAMAGICftest_MG(chr) STMT_START { \
2898         if ( (SvFLAGS(TOPs) & (SVf_ROK|SVs_GMG)) \
2899                 && PL_op->op_flags & OPf_KIDS    \
2900                 && S_try_amagic_ftest(aTHX_ chr)) \
2901             return NORMAL; \
2902     } STMT_END
2903
2904 STATIC bool
2905 S_try_amagic_ftest(pTHX_ char chr) {
2906     dVAR;
2907     dSP;
2908     SV* const arg = TOPs;
2909
2910     assert(chr != '?');
2911     SvGETMAGIC(arg);
2912
2913     if (SvAMAGIC(TOPs))
2914     {
2915         const char tmpchr = chr;
2916         SV * const tmpsv = amagic_call(arg,
2917                                 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
2918                                 ftest_amg, AMGf_unary);
2919
2920         if (!tmpsv)
2921             return FALSE;
2922
2923         SPAGAIN;
2924
2925         if (PL_op->op_private & OPpFT_STACKING) {
2926             if (SvTRUE(tmpsv))
2927                 /* leave the object alone */
2928                 return TRUE;
2929         }
2930
2931         SETs(tmpsv);
2932         PUTBACK;
2933         return TRUE;
2934     }
2935     return FALSE;
2936 }
2937
2938
2939 /* This macro is used by the stacked filetest operators :
2940  * if the previous filetest failed, short-circuit and pass its value.
2941  * Else, discard it from the stack and continue. --rgs
2942  */
2943 #define STACKED_FTEST_CHECK if (PL_op->op_private & OPpFT_STACKED) { \
2944         if (!SvTRUE(TOPs)) { RETURN; } \
2945         else { (void)POPs; PUTBACK; } \
2946     }
2947
2948 PP(pp_ftrread)
2949 {
2950     dVAR;
2951     I32 result;
2952     /* Not const, because things tweak this below. Not bool, because there's
2953        no guarantee that OPp_FT_ACCESS is <= CHAR_MAX  */
2954 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
2955     I32 use_access = PL_op->op_private & OPpFT_ACCESS;
2956     /* Giving some sort of initial value silences compilers.  */
2957 #  ifdef R_OK
2958     int access_mode = R_OK;
2959 #  else
2960     int access_mode = 0;
2961 #  endif
2962 #else
2963     /* access_mode is never used, but leaving use_access in makes the
2964        conditional compiling below much clearer.  */
2965     I32 use_access = 0;
2966 #endif
2967     Mode_t stat_mode = S_IRUSR;
2968
2969     bool effective = FALSE;
2970     char opchar = '?';
2971     dSP;
2972
2973     switch (PL_op->op_type) {
2974     case OP_FTRREAD:    opchar = 'R'; break;
2975     case OP_FTRWRITE:   opchar = 'W'; break;
2976     case OP_FTREXEC:    opchar = 'X'; break;
2977     case OP_FTEREAD:    opchar = 'r'; break;
2978     case OP_FTEWRITE:   opchar = 'w'; break;
2979     case OP_FTEEXEC:    opchar = 'x'; break;
2980     }
2981     tryAMAGICftest_MG(opchar);
2982
2983     STACKED_FTEST_CHECK;
2984
2985     switch (PL_op->op_type) {
2986     case OP_FTRREAD:
2987 #if !(defined(HAS_ACCESS) && defined(R_OK))
2988         use_access = 0;
2989 #endif
2990         break;
2991
2992     case OP_FTRWRITE:
2993 #if defined(HAS_ACCESS) && defined(W_OK)
2994         access_mode = W_OK;
2995 #else
2996         use_access = 0;
2997 #endif
2998         stat_mode = S_IWUSR;
2999         break;
3000
3001     case OP_FTREXEC:
3002 #if defined(HAS_ACCESS) && defined(X_OK)
3003         access_mode = X_OK;
3004 #else
3005         use_access = 0;
3006 #endif
3007         stat_mode = S_IXUSR;
3008         break;
3009
3010     case OP_FTEWRITE:
3011 #ifdef PERL_EFF_ACCESS
3012         access_mode = W_OK;
3013 #endif
3014         stat_mode = S_IWUSR;
3015         /* fall through */
3016
3017     case OP_FTEREAD:
3018 #ifndef PERL_EFF_ACCESS
3019         use_access = 0;
3020 #endif
3021         effective = TRUE;
3022         break;
3023
3024     case OP_FTEEXEC:
3025 #ifdef PERL_EFF_ACCESS
3026         access_mode = X_OK;
3027 #else
3028         use_access = 0;
3029 #endif
3030         stat_mode = S_IXUSR;
3031         effective = TRUE;
3032         break;
3033     }
3034
3035     if (use_access) {
3036 #if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
3037         const char *name = POPpx;
3038         if (effective) {
3039 #  ifdef PERL_EFF_ACCESS
3040             result = PERL_EFF_ACCESS(name, access_mode);
3041 #  else
3042             DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3043                 OP_NAME(PL_op));
3044 #  endif
3045         }
3046         else {
3047 #  ifdef HAS_ACCESS
3048             result = access(name, access_mode);
3049 #  else
3050             DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3051 #  endif
3052         }
3053         if (result == 0)
3054             RETPUSHYES;
3055         if (result < 0)
3056             RETPUSHUNDEF;
3057         RETPUSHNO;
3058 #endif
3059     }
3060
3061     result = my_stat_flags(0);
3062     SPAGAIN;
3063     if (result < 0)
3064         RETPUSHUNDEF;
3065     if (cando(stat_mode, effective, &PL_statcache))
3066         RETPUSHYES;
3067     RETPUSHNO;
3068 }
3069
3070 PP(pp_ftis)
3071 {
3072     dVAR;
3073     I32 result;
3074     const int op_type = PL_op->op_type;
3075     char opchar = '?';
3076     dSP;
3077
3078     switch (op_type) {
3079     case OP_FTIS:       opchar = 'e'; break;
3080     case OP_FTSIZE:     opchar = 's'; break;
3081     case OP_FTMTIME:    opchar = 'M'; break;
3082     case OP_FTCTIME:    opchar = 'C'; break;
3083     case OP_FTATIME:    opchar = 'A'; break;
3084     }
3085     tryAMAGICftest_MG(opchar);
3086
3087     STACKED_FTEST_CHECK;
3088
3089     result = my_stat_flags(0);
3090     SPAGAIN;
3091     if (result < 0)
3092         RETPUSHUNDEF;
3093     if (op_type == OP_FTIS)
3094         RETPUSHYES;
3095     {
3096         /* You can't dTARGET inside OP_FTIS, because you'll get
3097            "panic: pad_sv po" - the op is not flagged to have a target.  */
3098         dTARGET;
3099         switch (op_type) {
3100         case OP_FTSIZE:
3101 #if Off_t_size > IVSIZE
3102             PUSHn(PL_statcache.st_size);
3103 #else
3104             PUSHi(PL_statcache.st_size);
3105 #endif
3106             break;
3107         case OP_FTMTIME:
3108             PUSHn( (((NV)PL_basetime - PL_statcache.st_mtime)) / 86400.0 );
3109             break;
3110         case OP_FTATIME:
3111             PUSHn( (((NV)PL_basetime - PL_statcache.st_atime)) / 86400.0 );
3112             break;
3113         case OP_FTCTIME:
3114             PUSHn( (((NV)PL_basetime - PL_statcache.st_ctime)) / 86400.0 );
3115             break;
3116         }
3117     }
3118     RETURN;
3119 }
3120
3121 PP(pp_ftrowned)
3122 {
3123     dVAR;
3124     I32 result;
3125     char opchar = '?';
3126     dSP;
3127
3128     switch (PL_op->op_type) {
3129     case OP_FTROWNED:   opchar = 'O'; break;
3130     case OP_FTEOWNED:   opchar = 'o'; break;
3131     case OP_FTZERO:     opchar = 'z'; break;
3132     case OP_FTSOCK:     opchar = 'S'; break;
3133     case OP_FTCHR:      opchar = 'c'; break;
3134     case OP_FTBLK:      opchar = 'b'; break;
3135     case OP_FTFILE:     opchar = 'f'; break;
3136     case OP_FTDIR:      opchar = 'd'; break;
3137     case OP_FTPIPE:     opchar = 'p'; break;
3138     case OP_FTSUID:     opchar = 'u'; break;
3139     case OP_FTSGID:     opchar = 'g'; break;
3140     case OP_FTSVTX:     opchar = 'k'; break;
3141     }
3142     tryAMAGICftest_MG(opchar);
3143
3144     STACKED_FTEST_CHECK;
3145
3146     /* I believe that all these three are likely to be defined on most every
3147        system these days.  */
3148 #ifndef S_ISUID
3149     if(PL_op->op_type == OP_FTSUID) {
3150         if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3151             (void) POPs;
3152         RETPUSHNO;
3153     }
3154 #endif
3155 #ifndef S_ISGID
3156     if(PL_op->op_type == OP_FTSGID) {
3157         if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3158             (void) POPs;
3159         RETPUSHNO;
3160     }
3161 #endif
3162 #ifndef S_ISVTX
3163     if(PL_op->op_type == OP_FTSVTX) {
3164         if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3165             (void) POPs;
3166         RETPUSHNO;
3167     }
3168 #endif
3169
3170     result = my_stat_flags(0);
3171     SPAGAIN;
3172     if (result < 0)
3173         RETPUSHUNDEF;
3174     switch (PL_op->op_type) {
3175     case OP_FTROWNED:
3176         if (PL_statcache.st_uid == PL_uid)
3177             RETPUSHYES;
3178         break;
3179     case OP_FTEOWNED:
3180         if (PL_statcache.st_uid == PL_euid)
3181             RETPUSHYES;
3182         break;
3183     case OP_FTZERO:
3184         if (PL_statcache.st_size == 0)
3185             RETPUSHYES;
3186         break;
3187     case OP_FTSOCK:
3188         if (S_ISSOCK(PL_statcache.st_mode))
3189             RETPUSHYES;
3190         break;
3191     case OP_FTCHR:
3192         if (S_ISCHR(PL_statcache.st_mode))
3193             RETPUSHYES;
3194         break;
3195     case OP_FTBLK:
3196         if (S_ISBLK(PL_statcache.st_mode))
3197             RETPUSHYES;
3198         break;
3199     case OP_FTFILE:
3200         if (S_ISREG(PL_statcache.st_mode))
3201             RETPUSHYES;
3202         break;
3203     case OP_FTDIR:
3204         if (S_ISDIR(PL_statcache.st_mode))
3205             RETPUSHYES;
3206         break;
3207     case OP_FTPIPE:
3208         if (S_ISFIFO(PL_statcache.st_mode))
3209             RETPUSHYES;
3210         break;
3211 #ifdef S_ISUID
3212     case OP_FTSUID:
3213         if (PL_statcache.st_mode & S_ISUID)
3214             RETPUSHYES;
3215         break;
3216 #endif
3217 #ifdef S_ISGID
3218     case OP_FTSGID:
3219         if (PL_statcache.st_mode & S_ISGID)
3220             RETPUSHYES;
3221         break;
3222 #endif
3223 #ifdef S_ISVTX
3224     case OP_FTSVTX:
3225         if (PL_statcache.st_mode & S_ISVTX)
3226             RETPUSHYES;
3227         break;
3228 #endif
3229     }
3230     RETPUSHNO;
3231 }
3232
3233 PP(pp_ftlink)
3234 {
3235     dVAR;
3236     dSP;
3237     I32 result;
3238
3239     tryAMAGICftest_MG('l');
3240     STACKED_FTEST_CHECK;
3241     result = my_lstat_flags(0);
3242     SPAGAIN;
3243
3244     if (result < 0)
3245         RETPUSHUNDEF;
3246     if (S_ISLNK(PL_statcache.st_mode))
3247         RETPUSHYES;
3248     RETPUSHNO;
3249 }
3250
3251 PP(pp_fttty)
3252 {
3253     dVAR;
3254     dSP;
3255     int fd;
3256     GV *gv;
3257     char *name = NULL;
3258     STRLEN namelen;
3259
3260     tryAMAGICftest_MG('t');
3261
3262     STACKED_FTEST_CHECK;
3263
3264     if (PL_op->op_flags & OPf_REF)
3265         gv = cGVOP_gv;
3266     else {
3267       SV *tmpsv = POPs;
3268       if (!(gv = MAYBE_DEREF_GV_nomg(tmpsv))) {
3269         name = SvPV_nomg(tmpsv, namelen);
3270         gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3271       }
3272     }
3273
3274     if (GvIO(gv) && IoIFP(GvIOp(gv)))
3275         fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
3276     else if (name && isDIGIT(*name))
3277             fd = atoi(name);
3278     else
3279         RETPUSHUNDEF;
3280     if (PerlLIO_isatty(fd))
3281         RETPUSHYES;
3282     RETPUSHNO;
3283 }
3284
3285 #if defined(atarist) /* this will work with atariST. Configure will
3286                         make guesses for other systems. */
3287 # define FILE_base(f) ((f)->_base)
3288 # define FILE_ptr(f) ((f)->_ptr)
3289 # define FILE_cnt(f) ((f)->_cnt)
3290 # define FILE_bufsiz(f) ((f)->_cnt + ((f)->_ptr - (f)->_base))
3291 #endif
3292
3293 PP(pp_fttext)
3294 {
3295     dVAR;
3296     dSP;
3297     I32 i;
3298     I32 len;
3299     I32 odd = 0;
3300     STDCHAR tbuf[512];
3301     register STDCHAR *s;
3302     register IO *io;
3303     register SV *sv = NULL;
3304     GV *gv;
3305     PerlIO *fp;
3306
3307     tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
3308
3309     STACKED_FTEST_CHECK;
3310
3311     if (PL_op->op_flags & OPf_REF)
3312     {
3313         gv = cGVOP_gv;
3314         EXTEND(SP, 1);
3315     }
3316     else if (PL_op->op_private & OPpFT_STACKED)
3317         gv = PL_defgv;
3318     else sv = POPs, gv = MAYBE_DEREF_GV_nomg(sv);
3319
3320     if (gv) {
3321         if (gv == PL_defgv) {
3322             if (PL_statgv)
3323                 io = SvTYPE(PL_statgv) == SVt_PVIO
3324                     ? (IO *)PL_statgv
3325                     : GvIO(PL_statgv);
3326             else {
3327                 goto really_filename;
3328             }
3329         }
3330         else {
3331             PL_statgv = gv;
3332             sv_setpvs(PL_statname, "");
3333             io = GvIO(PL_statgv);
3334         }
3335         PL_laststatval = -1;
3336         PL_laststype = OP_STAT;
3337         if (io && IoIFP(io)) {
3338             if (! PerlIO_has_base(IoIFP(io)))
3339                 DIE(aTHX_ "-T and -B not implemented on filehandles");
3340             PL_laststatval = PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache);
3341             if (PL_laststatval < 0)
3342                 RETPUSHUNDEF;
3343             if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
3344                 if (PL_op->op_type == OP_FTTEXT)
3345                     RETPUSHNO;
3346                 else
3347                     RETPUSHYES;
3348             }
3349             if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
3350                 i = PerlIO_getc(IoIFP(io));
3351                 if (i != EOF)
3352                     (void)PerlIO_ungetc(IoIFP(io),i);
3353             }
3354             if (PerlIO_get_cnt(IoIFP(io)) <= 0) /* null file is anything */
3355                 RETPUSHYES;
3356             len = PerlIO_get_bufsiz(IoIFP(io));
3357             s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
3358             /* sfio can have large buffers - limit to 512 */
3359             if (len > 512)
3360                 len = 512;
3361         }
3362         else {
3363             SETERRNO(EBADF,RMS_IFI);
3364             report_evil_fh(gv);
3365             SETERRNO(EBADF,RMS_IFI);
3366             RETPUSHUNDEF;
3367         }
3368     }
3369     else {
3370         sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
3371       really_filename:
3372         PL_statgv = NULL;
3373         if (!(fp = PerlIO_open(SvPVX_const(PL_statname), "r"))) {
3374             if (!gv) {
3375                 PL_laststatval = -1;
3376                 PL_laststype = OP_STAT;
3377             }
3378             if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname),
3379                                                '\n'))
3380                 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
3381             RETPUSHUNDEF;
3382         }
3383         PL_laststype = OP_STAT;
3384         PL_laststatval = PerlLIO_fstat(PerlIO_fileno(fp), &PL_statcache);
3385         if (PL_laststatval < 0) {
3386             (void)PerlIO_close(fp);
3387             RETPUSHUNDEF;
3388         }
3389         PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
3390         len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3391         (void)PerlIO_close(fp);
3392         if (len <= 0) {
3393             if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
3394                 RETPUSHNO;              /* special case NFS directories */
3395             RETPUSHYES;         /* null file is anything */
3396         }
3397         s = tbuf;
3398     }
3399
3400     /* now scan s to look for textiness */
3401     /*   XXX ASCII dependent code */
3402
3403 #if defined(DOSISH) || defined(USEMYBINMODE)
3404     /* ignore trailing ^Z on short files */
3405     if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
3406         --len;
3407 #endif
3408
3409     for (i = 0; i < len; i++, s++) {
3410         if (!*s) {                      /* null never allowed in text */
3411             odd += len;
3412             break;
3413         }
3414 #ifdef EBCDIC
3415         else if (!(isPRINT(*s) || isSPACE(*s)))
3416             odd++;
3417 #else
3418         else if (*s & 128) {
3419 #ifdef USE_LOCALE
3420             if (IN_LOCALE_RUNTIME && isALPHA_LC(*s))
3421                 continue;
3422 #endif
3423             /* utf8 characters don't count as odd */
3424             if (UTF8_IS_START(*s)) {
3425                 int ulen = UTF8SKIP(s);
3426                 if (ulen < len - i) {
3427                     int j;
3428                     for (j = 1; j < ulen; j++) {
3429                         if (!UTF8_IS_CONTINUATION(s[j]))
3430                             goto not_utf8;
3431                     }
3432                     --ulen;     /* loop does extra increment */
3433                     s += ulen;
3434                     i += ulen;
3435                     continue;
3436                 }
3437             }
3438           not_utf8:
3439             odd++;
3440         }
3441         else if (*s < 32 &&
3442           *s != '\n' && *s != '\r' && *s != '\b' &&
3443           *s != '\t' && *s != '\f' && *s != 27)
3444             odd++;
3445 #endif
3446     }
3447
3448     if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
3449         RETPUSHNO;
3450     else
3451         RETPUSHYES;
3452 }
3453
3454 /* File calls. */
3455
3456 PP(pp_chdir)
3457 {
3458     dVAR; dSP; dTARGET;
3459     const char *tmps = NULL;
3460     GV *gv = NULL;
3461
3462     if( MAXARG == 1 ) {
3463         SV * const sv = POPs;
3464         if (PL_op->op_flags & OPf_SPECIAL) {
3465             gv = gv_fetchsv(sv, 0, SVt_PVIO);
3466         }
3467         else if (!(gv = MAYBE_DEREF_GV(sv)))
3468                 tmps = SvPV_nomg_const_nolen(sv);
3469     }
3470
3471     if( !gv && (!tmps || !*tmps) ) {
3472         HV * const table = GvHVn(PL_envgv);
3473         SV **svp;
3474
3475         if (    (svp = hv_fetchs(table, "HOME", FALSE))
3476              || (svp = hv_fetchs(table, "LOGDIR", FALSE))
3477 #ifdef VMS
3478              || (svp = hv_fetchs(table, "SYS$LOGIN", FALSE))
3479 #endif
3480            )
3481         {
3482             if( MAXARG == 1 )
3483                 deprecate("chdir('') or chdir(undef) as chdir()");
3484             tmps = SvPV_nolen_const(*svp);
3485         }
3486         else {
3487             PUSHi(0);
3488             TAINT_PROPER("chdir");
3489             RETURN;
3490         }
3491     }
3492
3493     TAINT_PROPER("chdir");
3494     if (gv) {
3495 #ifdef HAS_FCHDIR
3496         IO* const io = GvIO(gv);
3497         if (io) {
3498             if (IoDIRP(io)) {
3499                 PUSHi(fchdir(my_dirfd(IoDIRP(io))) >= 0);
3500             } else if (IoIFP(io)) {
3501                 PUSHi(fchdir(PerlIO_fileno(IoIFP(io))) >= 0);
3502             }
3503             else {
3504                 report_evil_fh(gv);
3505                 SETERRNO(EBADF, RMS_IFI);
3506                 PUSHi(0);
3507             }
3508         }
3509         else {
3510             report_evil_fh(gv);
3511             SETERRNO(EBADF,RMS_IFI);
3512             PUSHi(0);
3513         }
3514 #else
3515         DIE(aTHX_ PL_no_func, "fchdir");
3516 #endif
3517     }
3518     else
3519         PUSHi( PerlDir_chdir(tmps) >= 0 );
3520 #ifdef VMS
3521     /* Clear the DEFAULT element of ENV so we'll get the new value
3522      * in the future. */
3523     hv_delete(GvHVn(PL_envgv),"DEFAULT",7,G_DISCARD);
3524 #endif
3525     RETURN;
3526 }
3527
3528 PP(pp_chown)
3529 {
3530     dVAR; dSP; dMARK; dTARGET;
3531     const I32 value = (I32)apply(PL_op->op_type, MARK, SP);
3532
3533     SP = MARK;
3534     XPUSHi(value);
3535     RETURN;
3536 }
3537
3538 PP(pp_chroot)
3539 {
3540 #ifdef HAS_CHROOT
3541     dVAR; dSP; dTARGET;
3542     char * const tmps = POPpx;
3543     TAINT_PROPER("chroot");
3544     PUSHi( chroot(tmps) >= 0 );
3545     RETURN;
3546 #else
3547     DIE(aTHX_ PL_no_func, "chroot");
3548 #endif
3549 }
3550
3551 PP(pp_rename)
3552 {
3553     dVAR; dSP; dTARGET;
3554     int anum;
3555     const char * const tmps2 = POPpconstx;
3556     const char * const tmps = SvPV_nolen_const(TOPs);
3557     TAINT_PROPER("rename");
3558 #ifdef HAS_RENAME
3559     anum = PerlLIO_rename(tmps, tmps2);
3560 #else
3561     if (!(anum = PerlLIO_stat(tmps, &PL_statbuf))) {
3562         if (same_dirent(tmps2, tmps))   /* can always rename to same name */
3563             anum = 1;
3564         else {
3565             if (PL_euid || PerlLIO_stat(tmps2, &PL_statbuf) < 0 || !S_ISDIR(PL_statbuf.st_mode))
3566                 (void)UNLINK(tmps2);
3567             if (!(anum = link(tmps, tmps2)))
3568                 anum = UNLINK(tmps);
3569         }
3570     }
3571 #endif
3572     SETi( anum >= 0 );
3573     RETURN;
3574 }
3575
3576 #if defined(HAS_LINK) || defined(HAS_SYMLINK)
3577 PP(pp_link)
3578 {
3579     dVAR; dSP; dTARGET;
3580     const int op_type = PL_op->op_type;
3581     int result;
3582
3583 #  ifndef HAS_LINK
3584     if (op_type == OP_LINK)
3585         DIE(aTHX_ PL_no_func, "link");
3586 #  endif
3587 #  ifndef HAS_SYMLINK
3588     if (op_type == OP_SYMLINK)
3589         DIE(aTHX_ PL_no_func, "symlink");
3590 #  endif
3591
3592     {
3593         const char * const tmps2 = POPpconstx;
3594         const char * const tmps = SvPV_nolen_const(TOPs);
3595         TAINT_PROPER(PL_op_desc[op_type]);
3596         result =
3597 #  if defined(HAS_LINK)
3598 #    if defined(HAS_SYMLINK)
3599             /* Both present - need to choose which.  */
3600             (op_type == OP_LINK) ?
3601             PerlLIO_link(tmps, tmps2) : symlink(tmps, tmps2);
3602 #    else
3603     /* Only have link, so calls to pp_symlink will have DIE()d above.  */
3604         PerlLIO_link(tmps, tmps2);
3605 #    endif
3606 #  else
3607 #    if defined(HAS_SYMLINK)
3608     /* Only have symlink, so calls to pp_link will have DIE()d above.  */
3609         symlink(tmps, tmps2);
3610 #    endif
3611 #  endif
3612     }
3613
3614     SETi( result >= 0 );
3615     RETURN;
3616 }
3617 #else
3618 PP(pp_link)
3619 {
3620     /* Have neither.  */
3621     DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
3622 }
3623 #endif
3624
3625 PP(pp_readlink)
3626 {
3627     dVAR;
3628     dSP;
3629 #ifdef HAS_SYMLINK
3630     dTARGET;
3631     const char *tmps;
3632     char buf[MAXPATHLEN];
3633     int len;
3634
3635 #ifndef INCOMPLETE_TAINTS
3636     TAINT;
3637 #endif
3638     tmps = POPpconstx;
3639     len = readlink(tmps, buf, sizeof(buf) - 1);
3640     if (len < 0)
3641         RETPUSHUNDEF;
3642     PUSHp(buf, len);
3643     RETURN;
3644 #else
3645     EXTEND(SP, 1);
3646     RETSETUNDEF;                /* just pretend it's a normal file */
3647 #endif
3648 }
3649
3650 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
3651 STATIC int
3652 S_dooneliner(pTHX_ const char *cmd, const char *filename)
3653 {
3654     char * const save_filename = filename;
3655     char *cmdline;
3656     char *s;
3657     PerlIO *myfp;
3658     int anum = 1;
3659     Size_t size = strlen(cmd) + (strlen(filename) * 2) + 10;
3660
3661     PERL_ARGS_ASSERT_DOONELINER;
3662
3663     Newx(cmdline, size, char);
3664     my_strlcpy(cmdline, cmd, size);
3665     my_strlcat(cmdline, " ", size);
3666     for (s = cmdline + strlen(cmdline); *filename; ) {
3667         *s++ = '\\';
3668         *s++ = *filename++;
3669     }
3670     if (s - cmdline < size)
3671         my_strlcpy(s, " 2>&1", size - (s - cmdline));
3672     myfp = PerlProc_popen(cmdline, "r");
3673     Safefree(cmdline);
3674
3675     if (myfp) {
3676         SV * const tmpsv = sv_newmortal();
3677         /* Need to save/restore 'PL_rs' ?? */
3678         s = sv_gets(tmpsv, myfp, 0);
3679         (void)PerlProc_pclose(myfp);
3680         if (s != NULL) {
3681             int e;
3682             for (e = 1;
3683 #ifdef HAS_SYS_ERRLIST
3684                  e <= sys_nerr
3685 #endif
3686                  ; e++)
3687             {
3688                 /* you don't see this */
3689                 const char * const errmsg =
3690 #ifdef HAS_SYS_ERRLIST
3691                     sys_errlist[e]
3692 #else
3693                     strerror(e)
3694 #endif
3695                     ;
3696                 if (!errmsg)
3697                     break;
3698                 if (instr(s, errmsg)) {
3699                     SETERRNO(e,0);
3700                     return 0;
3701                 }
3702             }
3703             SETERRNO(0,0);
3704 #ifndef EACCES
3705 #define EACCES EPERM
3706 #endif
3707             if (instr(s, "cannot make"))
3708                 SETERRNO(EEXIST,RMS_FEX);
3709             else if (instr(s, "existing file"))
3710                 SETERRNO(EEXIST,RMS_FEX);
3711             else if (instr(s, "ile exists"))
3712                 SETERRNO(EEXIST,RMS_FEX);
3713             else if (instr(s, "non-exist"))
3714                 SETERRNO(ENOENT,RMS_FNF);
3715             else if (instr(s, "does not exist"))
3716                 SETERRNO(ENOENT,RMS_FNF);
3717             else if (instr(s, "not empty"))
3718                 SETERRNO(EBUSY,SS_DEVOFFLINE);
3719             else if (instr(s, "cannot access"))
3720                 SETERRNO(EACCES,RMS_PRV);
3721             else
3722                 SETERRNO(EPERM,RMS_PRV);
3723             return 0;
3724         }
3725         else {  /* some mkdirs return no failure indication */
3726             anum = (PerlLIO_stat(save_filename, &PL_statbuf) >= 0);
3727             if (PL_op->op_type == OP_RMDIR)
3728                 anum = !anum;
3729             if (anum)
3730                 SETERRNO(0,0);
3731             else
3732                 SETERRNO(EACCES,RMS_PRV);       /* a guess */
3733         }
3734         return anum;
3735     }
3736     else
3737         return 0;
3738 }
3739 #endif
3740
3741 /* This macro removes trailing slashes from a directory name.
3742  * Different operating and file systems take differently to
3743  * trailing slashes.  According to POSIX 1003.1 1996 Edition
3744  * any number of trailing slashes should be allowed.
3745  * Thusly we snip them away so that even non-conforming
3746  * systems are happy.
3747  * We should probably do this "filtering" for all
3748  * the functions that expect (potentially) directory names:
3749  * -d, chdir(), chmod(), chown(), chroot(), fcntl()?,
3750  * (mkdir()), opendir(), rename(), rmdir(), stat(). --jhi */
3751
3752 #define TRIMSLASHES(tmps,len,copy) (tmps) = SvPV_const(TOPs, (len)); \
3753     if ((len) > 1 && (tmps)[(len)-1] == '/') { \
3754         do { \
3755             (len)--; \
3756         } while ((len) > 1 && (tmps)[(len)-1] == '/'); \
3757         (tmps) = savepvn((tmps), (len)); \
3758         (copy) = TRUE; \
3759     }
3760
3761 PP(pp_mkdir)
3762 {
3763     dVAR; dSP; dTARGET;
3764     STRLEN len;
3765     const char *tmps;
3766     bool copy = FALSE;
3767     const int mode = (MAXARG > 1 && (TOPs||((void)POPs,0))) ? POPi : 0777;
3768
3769     TRIMSLASHES(tmps,len,copy);
3770
3771     TAINT_PROPER("mkdir");
3772 #ifdef HAS_MKDIR
3773     SETi( PerlDir_mkdir(tmps, mode) >= 0 );
3774 #else
3775     {
3776     int oldumask;
3777     SETi( dooneliner("mkdir", tmps) );
3778     oldumask = PerlLIO_umask(0);
3779     PerlLIO_umask(oldumask);
3780     PerlLIO_chmod(tmps, (mode & ~oldumask) & 0777);
3781     }
3782 #endif
3783     if (copy)
3784         Safefree(tmps);
3785     RETURN;
3786 }
3787
3788 PP(pp_rmdir)
3789 {
3790     dVAR; dSP; dTARGET;
3791     STRLEN len;
3792     const char *tmps;
3793     bool copy = FALSE;
3794
3795     TRIMSLASHES(tmps,len,copy);
3796     TAINT_PROPER("rmdir");
3797 #ifdef HAS_RMDIR
3798     SETi( PerlDir_rmdir(tmps) >= 0 );
3799 #else
3800     SETi( dooneliner("rmdir", tmps) );
3801 #endif
3802     if (copy)
3803         Safefree(tmps);
3804     RETURN;
3805 }
3806
3807 /* Directory calls. */
3808
3809 PP(pp_open_dir)
3810 {
3811 #if defined(Direntry_t) && defined(HAS_READDIR)
3812     dVAR; dSP;
3813     const char * const dirname = POPpconstx;
3814     GV * const gv = MUTABLE_GV(POPs);
3815     register IO * const io = GvIOn(gv);
3816
3817     if (!io)
3818         goto nope;
3819
3820     if ((IoIFP(io) || IoOFP(io)))
3821         Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
3822                          "Opening filehandle %"HEKf" also as a directory",
3823                              HEKfARG(GvENAME_HEK(gv)) );
3824     if (IoDIRP(io))
3825         PerlDir_close(IoDIRP(io));
3826     if (!(IoDIRP(io) = PerlDir_open(dirname)))
3827         goto nope;
3828
3829     RETPUSHYES;
3830 nope:
3831     if (!errno)
3832         SETERRNO(EBADF,RMS_DIR);
3833     RETPUSHUNDEF;
3834 #else
3835     DIE(aTHX_ PL_no_dir_func, "opendir");
3836 #endif
3837 }
3838
3839 PP(pp_readdir)
3840 {
3841 #if !defined(Direntry_t) || !defined(HAS_READDIR)
3842     DIE(aTHX_ PL_no_dir_func, "readdir");
3843 #else
3844 #if !defined(I_DIRENT) && !defined(VMS)
3845     Direntry_t *readdir (DIR *);
3846 #endif
3847     dVAR;
3848     dSP;
3849
3850     SV *sv;
3851     const I32 gimme = GIMME;
3852     GV * const gv = MUTABLE_GV(POPs);
3853     register const Direntry_t *dp;
3854     register IO * const io = GvIOn(gv);
3855
3856     if (!io || !IoDIRP(io)) {
3857         Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3858                        "readdir() attempted on invalid dirhandle %"HEKf,
3859                             HEKfARG(GvENAME_HEK(gv)));
3860         goto nope;
3861     }
3862
3863     do {
3864         dp = (Direntry_t *)PerlDir_read(IoDIRP(io));
3865         if (!dp)
3866             break;
3867 #ifdef DIRNAMLEN
3868         sv = newSVpvn(dp->d_name, dp->d_namlen);
3869 #else
3870         sv = newSVpv(dp->d_name, 0);
3871 #endif
3872 #ifndef INCOMPLETE_TAINTS
3873         if (!(IoFLAGS(io) & IOf_UNTAINT))
3874             SvTAINTED_on(sv);
3875 #endif
3876         mXPUSHs(sv);
3877     } while (gimme == G_ARRAY);
3878
3879     if (!dp && gimme != G_ARRAY)
3880         goto nope;
3881
3882     RETURN;
3883
3884 nope:
3885     if (!errno)
3886         SETERRNO(EBADF,RMS_ISI);
3887     if (GIMME == G_ARRAY)
3888         RETURN;
3889     else
3890         RETPUSHUNDEF;
3891 #endif
3892 }
3893
3894 PP(pp_telldir)
3895 {
3896 #if defined(HAS_TELLDIR) || defined(telldir)
3897     dVAR; dSP; dTARGET;
3898  /* XXX does _anyone_ need this? --AD 2/20/1998 */
3899  /* XXX netbsd still seemed to.
3900     XXX HAS_TELLDIR_PROTO is new style, NEED_TELLDIR_PROTO is old style.
3901     --JHI 1999-Feb-02 */
3902 # if !defined(HAS_TELLDIR_PROTO) || defined(NEED_TELLDIR_PROTO)
3903     long telldir (DIR *);
3904 # endif
3905     GV * const gv = MUTABLE_GV(POPs);
3906     register IO * const io = GvIOn(gv);
3907
3908     if (!io || !IoDIRP(io)) {
3909         Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3910                        "telldir() attempted on invalid dirhandle %"HEKf,
3911                             HEKfARG(GvENAME_HEK(gv)));
3912         goto nope;
3913     }
3914
3915     PUSHi( PerlDir_tell(IoDIRP(io)) );
3916     RETURN;
3917 nope:
3918     if (!errno)
3919         SETERRNO(EBADF,RMS_ISI);
3920     RETPUSHUNDEF;
3921 #else
3922     DIE(aTHX_ PL_no_dir_func, "telldir");
3923 #endif
3924 }
3925
3926 PP(pp_seekdir)
3927 {
3928 #if defined(HAS_SEEKDIR) || defined(seekdir)
3929     dVAR; dSP;
3930     const long along = POPl;
3931     GV * const gv = MUTABLE_GV(POPs);
3932     register IO * const io = GvIOn(gv);
3933
3934     if (!io || !IoDIRP(io)) {
3935         Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3936                        "seekdir() attempted on invalid dirhandle %"HEKf,
3937                                 HEKfARG(GvENAME_HEK(gv)));
3938         goto nope;
3939     }
3940     (void)PerlDir_seek(IoDIRP(io), along);
3941
3942     RETPUSHYES;
3943 nope:
3944     if (!errno)
3945         SETERRNO(EBADF,RMS_ISI);
3946     RETPUSHUNDEF;
3947 #else
3948     DIE(aTHX_ PL_no_dir_func, "seekdir");
3949 #endif
3950 }
3951
3952 PP(pp_rewinddir)
3953 {
3954 #if defined(HAS_REWINDDIR) || defined(rewinddir)
3955     dVAR; dSP;
3956     GV * const gv = MUTABLE_GV(POPs);
3957     register IO * const io = GvIOn(gv);
3958
3959     if (!io || !IoDIRP(io)) {
3960         Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3961                        "rewinddir() attempted on invalid dirhandle %"HEKf,
3962                                 HEKfARG(GvENAME_HEK(gv)));
3963         goto nope;
3964     }
3965     (void)PerlDir_rewind(IoDIRP(io));
3966     RETPUSHYES;
3967 nope:
3968     if (!errno)
3969         SETERRNO(EBADF,RMS_ISI);
3970     RETPUSHUNDEF;
3971 #else
3972     DIE(aTHX_ PL_no_dir_func, "rewinddir");
3973 #endif
3974 }
3975
3976 PP(pp_closedir)
3977 {
3978 #if defined(Direntry_t) && defined(HAS_READDIR)
3979     dVAR; dSP;
3980     GV * const gv = MUTABLE_GV(POPs);
3981     register IO * const io = GvIOn(gv);
3982
3983     if (!io || !IoDIRP(io)) {
3984         Perl_ck_warner(aTHX_ packWARN(WARN_IO),
3985                        "closedir() attempted on invalid dirhandle %"HEKf,
3986                                 HEKfARG(GvENAME_HEK(gv)));
3987         goto nope;
3988     }
3989 #ifdef VOID_CLOSEDIR
3990     PerlDir_close(IoDIRP(io));
3991 #else
3992     if (PerlDir_close(IoDIRP(io)) < 0) {
3993         IoDIRP(io) = 0; /* Don't try to close again--coredumps on SysV */
3994         goto nope;
3995     }
3996 #endif
3997     IoDIRP(io) = 0;
3998
3999     RETPUSHYES;
4000 nope:
4001     if (!errno)
4002         SETERRNO(EBADF,RMS_IFI);
4003     RETPUSHUNDEF;
4004 #else
4005     DIE(aTHX_ PL_no_dir_func, "closedir");
4006 #endif
4007 }
4008
4009 /* Process control. */
4010
4011 PP(pp_fork)
4012 {
4013 #ifdef HAS_FORK
4014     dVAR; dSP; dTARGET;
4015     Pid_t childpid;
4016
4017     EXTEND(SP, 1);
4018     PERL_FLUSHALL_FOR_CHILD;
4019     childpid = PerlProc_fork();
4020     if (childpid < 0)
4021         RETSETUNDEF;
4022     if (!childpid) {
4023 #ifdef THREADS_HAVE_PIDS
4024         PL_ppid = (IV)getppid();
4025 #endif
4026 #ifdef PERL_USES_PL_PIDSTATUS
4027         hv_clear(PL_pidstatus); /* no kids, so don't wait for 'em */
4028 #endif
4029     }
4030     PUSHi(childpid);
4031     RETURN;
4032 #else
4033 #  if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4034     dSP; dTARGET;
4035     Pid_t childpid;
4036
4037     EXTEND(SP, 1);
4038     PERL_FLUSHALL_FOR_CHILD;
4039     childpid = PerlProc_fork();
4040     if (childpid == -1)
4041         RETSETUNDEF;
4042     PUSHi(childpid);
4043     RETURN;
4044 #  else
4045     DIE(aTHX_ PL_no_func, "fork");
4046 #  endif
4047 #endif
4048 }
4049
4050 PP(pp_wait)
4051 {
4052 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4053     dVAR; dSP; dTARGET;
4054     Pid_t childpid;
4055     int argflags;
4056
4057     if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4058         childpid = wait4pid(-1, &argflags, 0);
4059     else {
4060         while ((childpid = wait4pid(-1, &argflags, 0)) == -1 &&
4061                errno == EINTR) {
4062           PERL_ASYNC_CHECK();
4063         }
4064     }
4065 #  if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4066     /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4067     STATUS_NATIVE_CHILD_SET((childpid && childpid != -1) ? argflags : -1);
4068 #  else
4069     STATUS_NATIVE_CHILD_SET((childpid > 0) ? argflags : -1);
4070 #  endif
4071     XPUSHi(childpid);
4072     RETURN;
4073 #else
4074     DIE(aTHX_ PL_no_func, "wait");
4075 #endif
4076 }
4077
4078 PP(pp_waitpid)
4079 {
4080 #if (!defined(DOSISH) || defined(OS2) || defined(WIN32)) && !defined(__LIBCATAMOUNT__)
4081     dVAR; dSP; dTARGET;
4082     const int optype = POPi;
4083     const Pid_t pid = TOPi;
4084     Pid_t result;
4085     int argflags;
4086
4087     if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
4088         result = wait4pid(pid, &argflags, optype);
4089     else {
4090         while ((result = wait4pid(pid, &argflags, optype)) == -1 &&
4091                errno == EINTR) {
4092           PERL_ASYNC_CHECK();
4093         }
4094     }
4095 #  if defined(USE_ITHREADS) && defined(PERL_IMPLICIT_SYS)
4096     /* 0 and -1 are both error returns (the former applies to WNOHANG case) */
4097     STATUS_NATIVE_CHILD_SET((result && result != -1) ? argflags : -1);
4098 #  else
4099     STATUS_NATIVE_CHILD_SET((result > 0) ? argflags : -1);
4100 #  endif
4101     SETi(result);
4102     RETURN;
4103 #else
4104     DIE(aTHX_ PL_no_func, "waitpid");
4105 #endif
4106 }
4107
4108 PP(pp_system)
4109 {
4110     dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4111 #if defined(__LIBCATAMOUNT__)
4112     PL_statusvalue = -1;
4113     SP = ORIGMARK;
4114     XPUSHi(-1);
4115 #else
4116     I32 value;
4117     int result;
4118
4119     if (PL_tainting) {
4120         TAINT_ENV();
4121         while (++MARK <= SP) {
4122             (void)SvPV_nolen_const(*MARK);      /* stringify for taint check */
4123             if (PL_tainted)
4124                 break;
4125         }
4126         MARK = ORIGMARK;
4127         TAINT_PROPER("system");
4128     }
4129     PERL_FLUSHALL_FOR_CHILD;
4130 #if (defined(HAS_FORK) || defined(AMIGAOS)) && !defined(VMS) && !defined(OS2) || defined(PERL_MICRO)
4131     {
4132         Pid_t childpid;
4133         int pp[2];
4134         I32 did_pipes = 0;
4135 #if (defined(HAS_SIGPROCMASK) && !defined(PERL_MICRO))
4136         sigset_t newset, oldset;
4137 #endif
4138
4139         if (PerlProc_pipe(pp) >= 0)
4140             did_pipes = 1;
4141 #if (defined(HAS_SIGPROCMASK) && !defined(PERL_MICRO))
4142         sigemptyset(&newset);
4143         sigaddset(&newset, SIGCHLD);
4144         sigprocmask(SIG_BLOCK, &newset, &oldset);
4145 #endif
4146         while ((childpid = PerlProc_fork()) == -1) {
4147             if (errno != EAGAIN) {
4148                 value = -1;
4149                 SP = ORIGMARK;
4150                 XPUSHi(value);
4151                 if (did_pipes) {
4152                     PerlLIO_close(pp[0]);
4153                     PerlLIO_close(pp[1]);
4154                 }
4155 #if (defined(HAS_SIGPROCMASK) && !defined(PERL_MICRO))
4156                 sigprocmask(SIG_SETMASK, &oldset, NULL);
4157 #endif
4158                 RETURN;
4159             }
4160             sleep(5);
4161         }
4162         if (childpid > 0) {
4163             Sigsave_t ihand,qhand; /* place to save signals during system() */
4164             int status;
4165
4166             if (did_pipes)
4167                 PerlLIO_close(pp[1]);
4168 #ifndef PERL_MICRO
4169             rsignal_save(SIGINT,  (Sighandler_t) SIG_IGN, &ihand);
4170             rsignal_save(SIGQUIT, (Sighandler_t) SIG_IGN, &qhand);
4171 #endif
4172             do {
4173                 result = wait4pid(childpid, &status, 0);
4174             } while (result == -1 && errno == EINTR);
4175 #ifndef PERL_MICRO
4176 #ifdef HAS_SIGPROCMASK
4177             sigprocmask(SIG_SETMASK, &oldset, NULL);
4178 #endif
4179             (void)rsignal_restore(SIGINT, &ihand);
4180             (void)rsignal_restore(SIGQUIT, &qhand);
4181 #endif
4182             STATUS_NATIVE_CHILD_SET(result == -1 ? -1 : status);
4183             do_execfree();      /* free any memory child malloced on fork */
4184             SP = ORIGMARK;
4185             if (did_pipes) {
4186                 int errkid;
4187                 unsigned n = 0;
4188                 SSize_t n1;
4189
4190                 while (n < sizeof(int)) {
4191                     n1 = PerlLIO_read(pp[0],
4192                                       (void*)(((char*)&errkid)+n),
4193                                       (sizeof(int)) - n);
4194                     if (n1 <= 0)
4195                         break;
4196                     n += n1;
4197                 }
4198                 PerlLIO_close(pp[0]);
4199                 if (n) {                        /* Error */
4200                     if (n != sizeof(int))
4201                         DIE(aTHX_ "panic: kid popen errno read, n=%u", n);
4202                     errno = errkid;             /* Propagate errno from kid */
4203                     STATUS_NATIVE_CHILD_SET(-1);
4204                 }
4205             }
4206             XPUSHi(STATUS_CURRENT);
4207             RETURN;
4208         }
4209 #if (defined(HAS_SIGPROCMASK) && !defined(PERL_MICRO))
4210         sigprocmask(SIG_SETMASK, &oldset, NULL);
4211 #endif
4212         if (did_pipes) {
4213             PerlLIO_close(pp[0]);
4214 #if defined(HAS_FCNTL) && defined(F_SETFD)
4215             fcntl(pp[1], F_SETFD, FD_CLOEXEC);
4216 #endif
4217         }
4218         if (PL_op->op_flags & OPf_STACKED) {
4219             SV * const really = *++MARK;
4220             value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
4221         }
4222         else if (SP - MARK != 1)
4223             value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
4224         else {
4225             value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
4226         }
4227         PerlProc__exit(-1);
4228     }
4229 #else /* ! FORK or VMS or OS/2 */
4230     PL_statusvalue = 0;
4231     result = 0;
4232     if (PL_op->op_flags & OPf_STACKED) {
4233         SV * const really = *++MARK;
4234 #  if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4235         value = (I32)do_aspawn(really, MARK, SP);
4236 #  else
4237         value = (I32)do_aspawn(really, (void **)MARK, (void **)SP);
4238 #  endif
4239     }
4240     else if (SP - MARK != 1) {
4241 #  if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__) || defined(__VMS)
4242         value = (I32)do_aspawn(NULL, MARK, SP);
4243 #  else
4244         value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
4245 #  endif
4246     }
4247     else {
4248         value = (I32)do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4249     }
4250     if (PL_statusvalue == -1)   /* hint that value must be returned as is */
4251         result = 1;
4252     STATUS_NATIVE_CHILD_SET(value);
4253     do_execfree();
4254     SP = ORIGMARK;
4255     XPUSHi(result ? value : STATUS_CURRENT);
4256 #endif /* !FORK or VMS or OS/2 */
4257 #endif
4258     RETURN;
4259 }
4260
4261 PP(pp_exec)
4262 {
4263     dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4264     I32 value;
4265
4266     if (PL_tainting) {
4267         TAINT_ENV();
4268         while (++MARK <= SP) {
4269             (void)SvPV_nolen_const(*MARK);      /* stringify for taint check */
4270             if (PL_tainted)
4271                 break;
4272         }
4273         MARK = ORIGMARK;
4274         TAINT_PROPER("exec");
4275     }
4276     PERL_FLUSHALL_FOR_CHILD;
4277     if (PL_op->op_flags & OPf_STACKED) {
4278         SV * const really = *++MARK;
4279         value = (I32)do_aexec(really, MARK, SP);
4280     }
4281     else if (SP - MARK != 1)
4282 #ifdef VMS
4283         value = (I32)vms_do_aexec(NULL, MARK, SP);
4284 #else
4285 #  ifdef __OPEN_VM
4286         {
4287            (void ) do_aspawn(NULL, MARK, SP);
4288            value = 0;
4289         }
4290 #  else
4291         value = (I32)do_aexec(NULL, MARK, SP);
4292 #  endif
4293 #endif
4294     else {
4295 #ifdef VMS
4296         value = (I32)vms_do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4297 #else
4298 #  ifdef __OPEN_VM
4299         (void) do_spawn(SvPVx_nolen(sv_mortalcopy(*SP)));
4300         value = 0;
4301 #  else
4302         value = (I32)do_exec(SvPVx_nolen(sv_mortalcopy(*SP)));
4303 #  endif
4304 #endif
4305     }
4306
4307     SP = ORIGMARK;
4308     XPUSHi(value);
4309     RETURN;
4310 }
4311
4312 PP(pp_getppid)
4313 {
4314 #ifdef HAS_GETPPID
4315     dVAR; dSP; dTARGET;
4316 #   ifdef THREADS_HAVE_PIDS
4317     if (PL_ppid != 1 && getppid() == 1)
4318         /* maybe the parent process has died. Refresh ppid cache */
4319         PL_ppid = 1;
4320     XPUSHi( PL_ppid );
4321 #   else
4322     XPUSHi( getppid() );
4323 #   endif
4324     RETURN;
4325 #else
4326     DIE(aTHX_ PL_no_func, "getppid");
4327 #endif
4328 }
4329
4330 PP(pp_getpgrp)
4331 {
4332 #ifdef HAS_GETPGRP
4333     dVAR; dSP; dTARGET;
4334     Pid_t pgrp;
4335     const Pid_t pid =
4336         (MAXARG < 1) ? 0 : TOPs ? SvIVx(POPs) : ((void)POPs, 0);
4337
4338 #ifdef BSD_GETPGRP
4339     pgrp = (I32)BSD_GETPGRP(pid);
4340 #else
4341     if (pid != 0 && pid != PerlProc_getpid())
4342         DIE(aTHX_ "POSIX getpgrp can't take an argument");
4343     pgrp = getpgrp();
4344 #endif
4345     XPUSHi(pgrp);
4346     RETURN;
4347 #else
4348     DIE(aTHX_ PL_no_func, "getpgrp()");
4349 #endif
4350 }
4351
4352 PP(pp_setpgrp)
4353 {
4354 #ifdef HAS_SETPGRP
4355     dVAR; dSP; dTARGET;
4356     Pid_t pgrp;
4357     Pid_t pid;
4358     pgrp = MAXARG == 2 && (TOPs||POPs) ? POPi : 0;
4359     if (MAXARG > 0) pid = TOPs && TOPi;
4360     else {
4361         pid = 0;
4362         XPUSHi(-1);
4363     }
4364
4365     TAINT_PROPER("setpgrp");
4366 #ifdef BSD_SETPGRP
4367     SETi( BSD_SETPGRP(pid, pgrp) >= 0 );
4368 #else
4369     if ((pgrp != 0 && pgrp != PerlProc_getpid())
4370         || (pid != 0 && pid != PerlProc_getpid()))
4371     {
4372         DIE(aTHX_ "setpgrp can't take arguments");
4373     }
4374     SETi( setpgrp() >= 0 );
4375 #endif /* USE_BSDPGRP */
4376     RETURN;
4377 #else
4378     DIE(aTHX_ PL_no_func, "setpgrp()");
4379 #endif
4380 }
4381
4382 #if defined(__GLIBC__) && ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3) || (__GLIBC__ > 2))
4383 #  define PRIORITY_WHICH_T(which) (__priority_which_t)which
4384 #else
4385 #  define PRIORITY_WHICH_T(which) which
4386 #endif
4387
4388 PP(pp_getpriority)
4389 {
4390 #ifdef HAS_GETPRIORITY
4391     dVAR; dSP; dTARGET;
4392     const int who = POPi;
4393     const int which = TOPi;
4394     SETi( getpriority(PRIORITY_WHICH_T(which), who) );
4395     RETURN;
4396 #else
4397     DIE(aTHX_ PL_no_func, "getpriority()");
4398 #endif
4399 }
4400
4401 PP(pp_setpriority)
4402 {
4403 #ifdef HAS_SETPRIORITY
4404     dVAR; dSP; dTARGET;
4405     const int niceval = POPi;
4406     const int who = POPi;
4407     const int which = TOPi;
4408     TAINT_PROPER("setpriority");
4409     SETi( setpriority(PRIORITY_WHICH_T(which), who, niceval) >= 0 );
4410     RETURN;
4411 #else
4412     DIE(aTHX_ PL_no_func, "setpriority()");
4413 #endif
4414 }
4415
4416 #undef PRIORITY_WHICH_T
4417
4418 /* Time calls. */
4419
4420 PP(pp_time)
4421 {
4422     dVAR; dSP; dTARGET;
4423 #ifdef BIG_TIME
4424     XPUSHn( time(NULL) );
4425 #else
4426     XPUSHi( time(NULL) );
4427 #endif
4428     RETURN;
4429 }
4430
4431 PP(pp_tms)
4432 {
4433 #ifdef HAS_TIMES
4434     dVAR;
4435     dSP;
4436     EXTEND(SP, 4);
4437 #ifndef VMS
4438     (void)PerlProc_times(&PL_timesbuf);
4439 #else
4440     (void)PerlProc_times((tbuffer_t *)&PL_timesbuf);  /* time.h uses different name for */
4441                                                    /* struct tms, though same data   */
4442                                                    /* is returned.                   */
4443 #endif
4444
4445     mPUSHn(((NV)PL_timesbuf.tms_utime)/(NV)PL_clocktick);
4446     if (GIMME == G_ARRAY) {
4447         mPUSHn(((NV)PL_timesbuf.tms_stime)/(NV)PL_clocktick);
4448         mPUSHn(((NV)PL_timesbuf.tms_cutime)/(NV)PL_clocktick);
4449         mPUSHn(((NV)PL_timesbuf.tms_cstime)/(NV)PL_clocktick);
4450     }
4451     RETURN;
4452 #else
4453 #   ifdef PERL_MICRO
4454     dSP;
4455     mPUSHn(0.0);
4456     EXTEND(SP, 4);
4457     if (GIMME == G_ARRAY) {
4458          mPUSHn(0.0);
4459          mPUSHn(0.0);
4460          mPUSHn(0.0);
4461     }
4462     RETURN;
4463 #   else
4464     DIE(aTHX_ "times not implemented");
4465 #   endif
4466 #endif /* HAS_TIMES */
4467 }
4468
4469 /* The 32 bit int year limits the times we can represent to these
4470    boundaries with a few days wiggle room to account for time zone
4471    offsets
4472 */
4473 /* Sat Jan  3 00:00:00 -2147481748 */
4474 #define TIME_LOWER_BOUND -67768100567755200.0
4475 /* Sun Dec 29 12:00:00  2147483647 */
4476 #define TIME_UPPER_BOUND  67767976233316800.0
4477
4478 PP(pp_gmtime)
4479 {
4480     dVAR;
4481     dSP;
4482     Time64_T when;
4483     struct TM tmbuf;
4484     struct TM *err;
4485     const char *opname = PL_op->op_type == OP_LOCALTIME ? "localtime" : "gmtime";
4486     static const char * const dayname[] =
4487         {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
4488     static const char * const monname[] =
4489         {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
4490          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
4491
4492     if (MAXARG < 1 || (!TOPs && ((void)POPs, 1))) {
4493         time_t now;
4494         (void)time(&now);
4495         when = (Time64_T)now;
4496     }
4497     else {
4498         NV input = Perl_floor(POPn);
4499         when = (Time64_T)input;
4500         if (when != input) {
4501             /* diag_listed_as: gmtime(%f) too large */
4502             Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4503                            "%s(%.0" NVff ") too large", opname, input);
4504         }
4505     }
4506
4507     if ( TIME_LOWER_BOUND > when ) {
4508         /* diag_listed_as: gmtime(%f) too small */
4509         Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4510                        "%s(%.0" NVff ") too small", opname, when);
4511         err = NULL;
4512     }
4513     else if( when > TIME_UPPER_BOUND ) {
4514         /* diag_listed_as: gmtime(%f) too small */
4515         Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4516                        "%s(%.0" NVff ") too large", opname, when);
4517         err = NULL;
4518     }
4519     else {
4520         if (PL_op->op_type == OP_LOCALTIME)
4521             err = S_localtime64_r(&when, &tmbuf);
4522         else
4523             err = S_gmtime64_r(&when, &tmbuf);
4524     }
4525
4526     if (err == NULL) {
4527         /* XXX %lld broken for quads */
4528         Perl_ck_warner(aTHX_ packWARN(WARN_OVERFLOW),
4529                        "%s(%.0" NVff ") failed", opname, when);
4530     }
4531
4532     if (GIMME != G_ARRAY) {     /* scalar context */
4533         SV *tsv;
4534         /* XXX newSVpvf()'s %lld type is broken, so cheat with a double */
4535         double year = (double)tmbuf.tm_year + 1900;
4536
4537         EXTEND(SP, 1);
4538         EXTEND_MORTAL(1);
4539         if (err == NULL)
4540             RETPUSHUNDEF;
4541
4542         tsv = Perl_newSVpvf(aTHX_ "%s %s %2d %02d:%02d:%02d %.0f",
4543                             dayname[tmbuf.tm_wday],
4544                             monname[tmbuf.tm_mon],
4545                             tmbuf.tm_mday,
4546                             tmbuf.tm_hour,
4547                             tmbuf.tm_min,
4548                             tmbuf.tm_sec,
4549                             year);
4550         mPUSHs(tsv);
4551     }
4552     else {                      /* list context */
4553         if ( err == NULL )
4554             RETURN;
4555
4556         EXTEND(SP, 9);
4557         EXTEND_MORTAL(9);
4558         mPUSHi(tmbuf.tm_sec);
4559         mPUSHi(tmbuf.tm_min);
4560         mPUSHi(tmbuf.tm_hour);
4561         mPUSHi(tmbuf.tm_mday);
4562         mPUSHi(tmbuf.tm_mon);
4563         mPUSHn(tmbuf.tm_year);
4564         mPUSHi(tmbuf.tm_wday);
4565         mPUSHi(tmbuf.tm_yday);
4566         mPUSHi(tmbuf.tm_isdst);
4567     }
4568     RETURN;
4569 }
4570
4571 PP(pp_alarm)
4572 {
4573 #ifdef HAS_ALARM
4574     dVAR; dSP; dTARGET;
4575     int anum;
4576     anum = POPi;
4577     anum = alarm((unsigned int)anum);
4578     if (anum < 0)
4579         RETPUSHUNDEF;
4580     PUSHi(anum);
4581     RETURN;
4582 #else
4583     DIE(aTHX_ PL_no_func, "alarm");
4584 #endif
4585 }
4586
4587 PP(pp_sleep)
4588 {
4589     dVAR; dSP; dTARGET;
4590     I32 duration;
4591     Time_t lasttime;
4592     Time_t when;
4593
4594     (void)time(&lasttime);
4595     if (MAXARG < 1 || (!TOPs && !POPs))
4596         PerlProc_pause();
4597     else {
4598         duration = POPi;
4599         PerlProc_sleep((unsigned int)duration);
4600     }
4601     (void)time(&when);
4602     XPUSHi(when - lasttime);
4603     RETURN;
4604 }
4605
4606 /* Shared memory. */
4607 /* Merged with some message passing. */
4608
4609 PP(pp_shmwrite)
4610 {
4611 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4612     dVAR; dSP; dMARK; dTARGET;
4613     const int op_type = PL_op->op_type;
4614     I32 value;
4615
4616     switch (op_type) {
4617     case OP_MSGSND:
4618         value = (I32)(do_msgsnd(MARK, SP) >= 0);
4619         break;
4620     case OP_MSGRCV:
4621         value = (I32)(do_msgrcv(MARK, SP) >= 0);
4622         break;
4623     case OP_SEMOP:
4624         value = (I32)(do_semop(MARK, SP) >= 0);
4625         break;
4626     default:
4627         value = (I32)(do_shmio(op_type, MARK, SP) >= 0);
4628         break;
4629     }
4630
4631     SP = MARK;
4632     PUSHi(value);
4633     RETURN;
4634 #else
4635     return Perl_pp_semget(aTHX);
4636 #endif
4637 }
4638
4639 /* Semaphores. */
4640
4641 PP(pp_semget)
4642 {
4643 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4644     dVAR; dSP; dMARK; dTARGET;
4645     const int anum = do_ipcget(PL_op->op_type, MARK, SP);
4646     SP = MARK;
4647     if (anum == -1)
4648         RETPUSHUNDEF;
4649     PUSHi(anum);
4650     RETURN;
4651 #else
4652     DIE(aTHX_ "System V IPC is not implemented on this machine");
4653 #endif
4654 }
4655
4656 PP(pp_semctl)
4657 {
4658 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
4659     dVAR; dSP; dMARK; dTARGET;
4660     const int anum = do_ipcctl(PL_op->op_type, MARK, SP);
4661     SP = MARK;
4662     if (anum == -1)
4663         RETSETUNDEF;
4664     if (anum != 0) {
4665         PUSHi(anum);
4666     }
4667     else {
4668         PUSHp(zero_but_true, ZBTLEN);
4669     }
4670     RETURN;
4671 #else
4672     return Perl_pp_semget(aTHX);
4673 #endif
4674 }
4675
4676 /* I can't const this further without getting warnings about the types of
4677    various arrays passed in from structures.  */
4678 static SV *
4679 S_space_join_names_mortal(pTHX_ char *const *array)
4680 {
4681     SV *target;
4682
4683     PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL;
4684
4685     if (array && *array) {
4686         target = newSVpvs_flags("", SVs_TEMP);
4687         while (1) {
4688             sv_catpv(target, *array);
4689             if (!*++array)
4690                 break;
4691             sv_catpvs(target, " ");
4692         }
4693     } else {
4694         target = sv_mortalcopy(&PL_sv_no);
4695     }
4696     return target;
4697 }
4698
4699 /* Get system info. */
4700
4701 PP(pp_ghostent)
4702 {
4703 #if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
4704     dVAR; dSP;
4705     I32 which = PL_op->op_type;
4706     register char **elem;
4707     register SV *sv;
4708 #ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
4709     struct hostent *gethostbyaddr(Netdb_host_t, Netdb_hlen_t, int);
4710     struct hostent *gethostbyname(Netdb_name_t);
4711     struct hostent *gethostent(void);
4712 #endif
4713     struct hostent *hent = NULL;
4714     unsigned long len;
4715
4716     EXTEND(SP, 10);
4717     if (which == OP_GHBYNAME) {
4718 #ifdef HAS_GETHOSTBYNAME
4719         const char* const name = POPpbytex;
4720         hent = PerlSock_gethostbyname(name);
4721 #else
4722         DIE(aTHX_ PL_no_sock_func, "gethostbyname");
4723 #endif
4724     }
4725     else if (which == OP_GHBYADDR) {
4726 #ifdef HAS_GETHOSTBYADDR
4727         const int addrtype = POPi;
4728         SV * const addrsv = POPs;
4729         STRLEN addrlen;
4730         const char *addr = (char *)SvPVbyte(addrsv, addrlen);
4731
4732         hent = PerlSock_gethostbyaddr(addr, (Netdb_hlen_t) addrlen, addrtype);
4733 #else
4734         DIE(aTHX_ PL_no_sock_func, "gethostbyaddr");
4735 #endif
4736     }
4737     else
4738 #ifdef HAS_GETHOSTENT
4739         hent = PerlSock_gethostent();
4740 #else
4741         DIE(aTHX_ PL_no_sock_func, "gethostent");
4742 #endif
4743
4744 #ifdef HOST_NOT_FOUND
4745         if (!hent) {
4746 #ifdef USE_REENTRANT_API
4747 #   ifdef USE_GETHOSTENT_ERRNO
4748             h_errno = PL_reentrant_buffer->_gethostent_errno;
4749 #   endif
4750 #endif
4751             STATUS_UNIX_SET(h_errno);
4752         }
4753 #endif
4754
4755     if (GIMME != G_ARRAY) {
4756         PUSHs(sv = sv_newmortal());
4757         if (hent) {
4758             if (which == OP_GHBYNAME) {
4759                 if (hent->h_addr)
4760                     sv_setpvn(sv, hent->h_addr, hent->h_length);
4761             }
4762             else
4763                 sv_setpv(sv, (char*)hent->h_name);
4764         }
4765         RETURN;
4766     }
4767
4768     if (hent) {
4769         mPUSHs(newSVpv((char*)hent->h_name, 0));
4770         PUSHs(space_join_names_mortal(hent->h_aliases));
4771         mPUSHi(hent->h_addrtype);
4772         len = hent->h_length;
4773         mPUSHi(len);
4774 #ifdef h_addr
4775         for (elem = hent->h_addr_list; elem && *elem; elem++) {
4776             mXPUSHp(*elem, len);
4777         }
4778 #else
4779         if (hent->h_addr)
4780             mPUSHp(hent->h_addr, len);
4781         else
4782             PUSHs(sv_mortalcopy(&PL_sv_no));
4783 #endif /* h_addr */
4784     }
4785     RETURN;
4786 #else
4787     DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4788 #endif
4789 }
4790
4791 PP(pp_gnetent)
4792 {
4793 #if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
4794     dVAR; dSP;
4795     I32 which = PL_op->op_type;
4796     register SV *sv;
4797 #ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
4798     struct netent *getnetbyaddr(Netdb_net_t, int);
4799     struct netent *getnetbyname(Netdb_name_t);
4800     struct netent *getnetent(void);
4801 #endif
4802     struct netent *nent;
4803
4804     if (which == OP_GNBYNAME){
4805 #ifdef HAS_GETNETBYNAME
4806         const char * const name = POPpbytex;
4807         nent = PerlSock_getnetbyname(name);
4808 #else
4809         DIE(aTHX_ PL_no_sock_func, "getnetbyname");
4810 #endif
4811     }
4812     else if (which == OP_GNBYADDR) {
4813 #ifdef HAS_GETNETBYADDR
4814         const int addrtype = POPi;
4815         const Netdb_net_t addr = (Netdb_net_t) (U32)POPu;
4816         nent = PerlSock_getnetbyaddr(addr, addrtype);
4817 #else
4818         DIE(aTHX_ PL_no_sock_func, "getnetbyaddr");
4819 #endif
4820     }
4821     else
4822 #ifdef HAS_GETNETENT
4823         nent = PerlSock_getnetent();
4824 #else
4825         DIE(aTHX_ PL_no_sock_func, "getnetent");
4826 #endif
4827
4828 #ifdef HOST_NOT_FOUND
4829         if (!nent) {
4830 #ifdef USE_REENTRANT_API
4831 #   ifdef USE_GETNETENT_ERRNO
4832              h_errno = PL_reentrant_buffer->_getnetent_errno;
4833 #   endif
4834 #endif
4835             STATUS_UNIX_SET(h_errno);
4836         }
4837 #endif
4838
4839     EXTEND(SP, 4);
4840     if (GIMME != G_ARRAY) {
4841         PUSHs(sv = sv_newmortal());
4842         if (nent) {
4843             if (which == OP_GNBYNAME)
4844                 sv_setiv(sv, (IV)nent->n_net);
4845             else
4846                 sv_setpv(sv, nent->n_name);
4847         }
4848         RETURN;
4849     }
4850
4851     if (nent) {
4852         mPUSHs(newSVpv(nent->n_name, 0));
4853         PUSHs(space_join_names_mortal(nent->n_aliases));
4854         mPUSHi(nent->n_addrtype);
4855         mPUSHi(nent->n_net);
4856     }
4857
4858     RETURN;
4859 #else
4860     DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4861 #endif
4862 }
4863
4864 PP(pp_gprotoent)
4865 {
4866 #if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
4867     dVAR; dSP;
4868     I32 which = PL_op->op_type;
4869     register SV *sv;
4870 #ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
4871     struct protoent *getprotobyname(Netdb_name_t);
4872     struct protoent *getprotobynumber(int);
4873     struct protoent *getprotoent(void);
4874 #endif
4875     struct protoent *pent;
4876
4877     if (which == OP_GPBYNAME) {
4878 #ifdef HAS_GETPROTOBYNAME
4879         const char* const name = POPpbytex;
4880         pent = PerlSock_getprotobyname(name);
4881 #else
4882         DIE(aTHX_ PL_no_sock_func, "getprotobyname");
4883 #endif
4884     }
4885     else if (which == OP_GPBYNUMBER) {
4886 #ifdef HAS_GETPROTOBYNUMBER
4887         const int number = POPi;
4888         pent = PerlSock_getprotobynumber(number);
4889 #else
4890         DIE(aTHX_ PL_no_sock_func, "getprotobynumber");
4891 #endif
4892     }
4893     else
4894 #ifdef HAS_GETPROTOENT
4895         pent = PerlSock_getprotoent();
4896 #else
4897         DIE(aTHX_ PL_no_sock_func, "getprotoent");
4898 #endif
4899
4900     EXTEND(SP, 3);
4901     if (GIMME != G_ARRAY) {
4902         PUSHs(sv = sv_newmortal());
4903         if (pent) {
4904             if (which == OP_GPBYNAME)
4905                 sv_setiv(sv, (IV)pent->p_proto);
4906             else
4907                 sv_setpv(sv, pent->p_name);
4908         }
4909         RETURN;
4910     }
4911
4912     if (pent) {
4913         mPUSHs(newSVpv(pent->p_name, 0));
4914         PUSHs(space_join_names_mortal(pent->p_aliases));
4915         mPUSHi(pent->p_proto);
4916     }
4917
4918     RETURN;
4919 #else
4920     DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4921 #endif
4922 }
4923
4924 PP(pp_gservent)
4925 {
4926 #if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
4927     dVAR; dSP;
4928     I32 which = PL_op->op_type;
4929     register SV *sv;
4930 #ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
4931     struct servent *getservbyname(Netdb_name_t, Netdb_name_t);
4932     struct servent *getservbyport(int, Netdb_name_t);
4933     struct servent *getservent(void);
4934 #endif
4935     struct servent *sent;
4936
4937     if (which == OP_GSBYNAME) {
4938 #ifdef HAS_GETSERVBYNAME
4939         const char * const proto = POPpbytex;
4940         const char * const name = POPpbytex;
4941         sent = PerlSock_getservbyname(name, (proto && !*proto) ? NULL : proto);
4942 #else
4943         DIE(aTHX_ PL_no_sock_func, "getservbyname");
4944 #endif
4945     }
4946     else if (which == OP_GSBYPORT) {
4947 #ifdef HAS_GETSERVBYPORT
4948         const char * const proto = POPpbytex;
4949         unsigned short port = (unsigned short)POPu;
4950 #ifdef HAS_HTONS
4951         port = PerlSock_htons(port);
4952 #endif
4953         sent = PerlSock_getservbyport(port, (proto && !*proto) ? NULL : proto);
4954 #else
4955         DIE(aTHX_ PL_no_sock_func, "getservbyport");
4956 #endif
4957     }
4958     else
4959 #ifdef HAS_GETSERVENT
4960         sent = PerlSock_getservent();
4961 #else
4962         DIE(aTHX_ PL_no_sock_func, "getservent");
4963 #endif
4964
4965     EXTEND(SP, 4);
4966     if (GIMME != G_ARRAY) {
4967         PUSHs(sv = sv_newmortal());
4968         if (sent) {
4969             if (which == OP_GSBYNAME) {
4970 #ifdef HAS_NTOHS
4971                 sv_setiv(sv, (IV)PerlSock_ntohs(sent->s_port));
4972 #else
4973                 sv_setiv(sv, (IV)(sent->s_port));
4974 #endif
4975             }
4976             else
4977                 sv_setpv(sv, sent->s_name);
4978         }
4979         RETURN;
4980     }
4981
4982     if (sent) {
4983         mPUSHs(newSVpv(sent->s_name, 0));
4984         PUSHs(space_join_names_mortal(sent->s_aliases));
4985 #ifdef HAS_NTOHS
4986         mPUSHi(PerlSock_ntohs(sent->s_port));
4987 #else
4988         mPUSHi(sent->s_port);
4989 #endif
4990         mPUSHs(newSVpv(sent->s_proto, 0));
4991     }
4992
4993     RETURN;
4994 #else
4995     DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
4996 #endif
4997 }
4998
4999 PP(pp_shostent)
5000 {
5001     dVAR; dSP;
5002     const int stayopen = TOPi;
5003     switch(PL_op->op_type) {
5004     case OP_SHOSTENT:
5005 #ifdef HAS_SETHOSTENT
5006         PerlSock_sethostent(stayopen);
5007 #else
5008         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5009 #endif
5010         break;
5011 #ifdef HAS_SETNETENT
5012     case OP_SNETENT:
5013         PerlSock_setnetent(stayopen);
5014 #else
5015         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5016 #endif
5017         break;
5018     case OP_SPROTOENT:
5019 #ifdef HAS_SETPROTOENT
5020         PerlSock_setprotoent(stayopen);
5021 #else
5022         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5023 #endif
5024         break;
5025     case OP_SSERVENT:
5026 #ifdef HAS_SETSERVENT
5027         PerlSock_setservent(stayopen);
5028 #else
5029         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5030 #endif
5031         break;
5032     }
5033     RETSETYES;
5034 }
5035
5036 PP(pp_ehostent)
5037 {
5038     dVAR; dSP;
5039     switch(PL_op->op_type) {
5040     case OP_EHOSTENT:
5041 #ifdef HAS_ENDHOSTENT
5042         PerlSock_endhostent();
5043 #else
5044         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5045 #endif
5046         break;
5047     case OP_ENETENT:
5048 #ifdef HAS_ENDNETENT
5049         PerlSock_endnetent();
5050 #else
5051         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5052 #endif
5053         break;
5054     case OP_EPROTOENT:
5055 #ifdef HAS_ENDPROTOENT
5056         PerlSock_endprotoent();
5057 #else
5058         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5059 #endif
5060         break;
5061     case OP_ESERVENT:
5062 #ifdef HAS_ENDSERVENT
5063         PerlSock_endservent();
5064 #else
5065         DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
5066 #endif
5067         break;
5068     case OP_SGRENT:
5069 #if defined(HAS_GROUP) && defined(HAS_SETGRENT)
5070         setgrent();
5071 #else
5072         DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5073 #endif
5074         break;
5075     case OP_EGRENT:
5076 #if defined(HAS_GROUP) && defined(HAS_ENDGRENT)
5077         endgrent();
5078 #else
5079         DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5080 #endif
5081         break;
5082     case OP_SPWENT:
5083 #if defined(HAS_PASSWD) && defined(HAS_SETPWENT)
5084         setpwent();
5085 #else
5086         DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5087 #endif
5088         break;
5089     case OP_EPWENT:
5090 #if defined(HAS_PASSWD) && defined(HAS_ENDPWENT)
5091         endpwent();
5092 #else
5093         DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5094 #endif
5095         break;
5096     }
5097     EXTEND(SP,1);
5098     RETPUSHYES;
5099 }
5100
5101 PP(pp_gpwent)
5102 {
5103 #ifdef HAS_PASSWD
5104     dVAR; dSP;
5105     I32 which = PL_op->op_type;
5106     register SV *sv;
5107     struct passwd *pwent  = NULL;
5108     /*
5109      * We currently support only the SysV getsp* shadow password interface.
5110      * The interface is declared in <shadow.h> and often one needs to link
5111      * with -lsecurity or some such.
5112      * This interface is used at least by Solaris, HP-UX, IRIX, and Linux.
5113      * (and SCO?)
5114      *
5115      * AIX getpwnam() is clever enough to return the encrypted password
5116      * only if the caller (euid?) is root.
5117      *
5118      * There are at least three other shadow password APIs.  Many platforms
5119      * seem to contain more than one interface for accessing the shadow
5120      * password databases, possibly for compatibility reasons.
5121      * The getsp*() is by far he simplest one, the other two interfaces
5122      * are much more complicated, but also very similar to each other.
5123      *
5124      * <sys/types.h>
5125      * <sys/security.h>
5126      * <prot.h>
5127      * struct pr_passwd *getprpw*();
5128      * The password is in
5129      * char getprpw*(...).ufld.fd_encrypt[]
5130      * Mention HAS_GETPRPWNAM here so that Configure probes for it.
5131      *
5132      * <sys/types.h>
5133      * <sys/security.h>
5134      * <prot.h>
5135      * struct es_passwd *getespw*();
5136      * The password is in
5137      * char *(getespw*(...).ufld.fd_encrypt)
5138      * Mention HAS_GETESPWNAM here so that Configure probes for it.
5139      *
5140      * <userpw.h> (AIX)
5141      * struct userpw *getuserpw();
5142      * The password is in
5143      * char *(getuserpw(...)).spw_upw_passwd
5144      * (but the de facto standard getpwnam() should work okay)
5145      *
5146      * Mention I_PROT here so that Configure probes for it.
5147      *
5148      * In HP-UX for getprpw*() the manual page claims that one should include
5149      * <hpsecurity.h> instead of <sys/security.h>, but that is not needed
5150      * if one includes <shadow.h> as that includes <hpsecurity.h>,
5151      * and pp_sys.c already includes <shadow.h> if there is such.
5152      *
5153      * Note that <sys/security.h> is already probed for, but currently
5154      * it is only included in special cases.
5155      *
5156      * In Digital UNIX/Tru64 if using the getespw*() (which seems to be
5157      * be preferred interface, even though also the getprpw*() interface
5158      * is available) one needs to link with -lsecurity -ldb -laud -lm.
5159      * One also needs to call set_auth_parameters() in main() before
5160      * doing anything else, whether one is using getespw*() or getprpw*().
5161      *
5162      * Note that accessing the shadow databases can be magnitudes
5163      * slower than accessing the standard databases.
5164      *
5165      * --jhi
5166      */
5167
5168 #   if defined(__CYGWIN__) && defined(USE_REENTRANT_API)
5169     /* Cygwin 1.5.3-1 has buggy getpwnam_r() and getpwuid_r():
5170      * the pw_comment is left uninitialized. */
5171     PL_reentrant_buffer->_pwent_struct.pw_comment = NULL;
5172 #   endif
5173
5174     switch (which) {
5175     case OP_GPWNAM:
5176       {
5177         const char* const name = POPpbytex;
5178         pwent  = getpwnam(name);
5179       }
5180       break;
5181     case OP_GPWUID:
5182       {
5183         Uid_t uid = POPi;
5184         pwent = getpwuid(uid);
5185       }
5186         break;
5187     case OP_GPWENT:
5188 #   ifdef HAS_GETPWENT
5189         pwent  = getpwent();
5190 #ifdef POSIX_BC   /* In some cases pw_passwd has invalid addresses */
5191         if (pwent) pwent = getpwnam(pwent->pw_name);
5192 #endif
5193 #   else
5194         DIE(aTHX_ PL_no_func, "getpwent");
5195 #   endif
5196         break;
5197     }
5198
5199     EXTEND(SP, 10);
5200     if (GIMME != G_ARRAY) {
5201         PUSHs(sv = sv_newmortal());
5202         if (pwent) {
5203             if (which == OP_GPWNAM)
5204 #   if Uid_t_sign <= 0
5205                 sv_setiv(sv, (IV)pwent->pw_uid);
5206 #   else
5207                 sv_setuv(sv, (UV)pwent->pw_uid);
5208 #   endif
5209             else
5210                 sv_setpv(sv, pwent->pw_name);
5211         }
5212         RETURN;
5213     }
5214
5215     if (pwent) {
5216         mPUSHs(newSVpv(pwent->pw_name, 0));
5217
5218         sv = newSViv(0);
5219         mPUSHs(sv);
5220         /* If we have getspnam(), we try to dig up the shadow
5221          * password.  If we are underprivileged, the shadow
5222          * interface will set the errno to EACCES or similar,
5223          * and return a null pointer.  If this happens, we will
5224          * use the dummy password (usually "*" or "x") from the
5225          * standard password database.
5226          *
5227          * In theory we could skip the shadow call completely
5228          * if euid != 0 but in practice we cannot know which
5229          * security measures are guarding the shadow databases
5230          * on a random platform.
5231          *
5232          * Resist the urge to use additional shadow interfaces.
5233          * Divert the urge to writing an extension instead.
5234          *
5235          * --jhi */
5236         /* Some AIX setups falsely(?) detect some getspnam(), which
5237          * has a different API than the Solaris/IRIX one. */
5238 #   if defined(HAS_GETSPNAM) && !defined(_AIX)
5239         {
5240             dSAVE_ERRNO;
5241             const struct spwd * const spwent = getspnam(pwent->pw_name);
5242                           /* Save and restore errno so that
5243                            * underprivileged attempts seem
5244                            * to have never made the unsuccessful
5245                            * attempt to retrieve the shadow password. */
5246             RESTORE_ERRNO;
5247             if (spwent && spwent->sp_pwdp)
5248                 sv_setpv(sv, spwent->sp_pwdp);
5249         }
5250 #   endif
5251 #   ifdef PWPASSWD
5252         if (!SvPOK(sv)) /* Use the standard password, then. */
5253             sv_setpv(sv, pwent->pw_passwd);
5254 #   endif
5255
5256 #   ifndef INCOMPLETE_TAINTS
5257         /* passwd is tainted because user himself can diddle with it.
5258          * admittedly not much and in a very limited way, but nevertheless. */
5259         SvTAINTED_on(sv);
5260 #   endif
5261
5262 #   if Uid_t_sign <= 0
5263         mPUSHi(pwent->pw_uid);
5264 #   else
5265         mPUSHu(pwent->pw_uid);
5266 #   endif
5267
5268 #   if Uid_t_sign <= 0
5269         mPUSHi(pwent->pw_gid);
5270 #   else
5271         mPUSHu(pwent->pw_gid);
5272 #   endif
5273         /* pw_change, pw_quota, and pw_age are mutually exclusive--
5274          * because of the poor interface of the Perl getpw*(),
5275          * not because there's some standard/convention saying so.
5276          * A better interface would have been to return a hash,
5277          * but we are accursed by our history, alas. --jhi.  */
5278 #   ifdef PWCHANGE
5279         mPUSHi(pwent->pw_change);
5280 #   else
5281 #       ifdef PWQUOTA
5282         mPUSHi(pwent->pw_quota);
5283 #       else
5284 #           ifdef PWAGE
5285         mPUSHs(newSVpv(pwent->pw_age, 0));
5286 #           else
5287         /* I think that you can never get this compiled, but just in case.  */
5288         PUSHs(sv_mortalcopy(&PL_sv_no));
5289 #           endif
5290 #       endif
5291 #   endif
5292
5293         /* pw_class and pw_comment are mutually exclusive--.
5294          * see the above note for pw_change, pw_quota, and pw_age. */
5295 #   ifdef PWCLASS
5296         mPUSHs(newSVpv(pwent->pw_class, 0));
5297 #   else
5298 #       ifdef PWCOMMENT
5299         mPUSHs(newSVpv(pwent->pw_comment, 0));
5300 #       else
5301         /* I think that you can never get this compiled, but just in case.  */
5302         PUSHs(sv_mortalcopy(&PL_sv_no));
5303 #       endif
5304 #   endif
5305
5306 #   ifdef PWGECOS
5307         PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_gecos, 0)));
5308 #   else
5309         PUSHs(sv = sv_mortalcopy(&PL_sv_no));
5310 #   endif
5311 #   ifndef INCOMPLETE_TAINTS
5312         /* pw_gecos is tainted because user himself can diddle with it. */
5313         SvTAINTED_on(sv);
5314 #   endif
5315
5316         mPUSHs(newSVpv(pwent->pw_dir, 0));
5317
5318         PUSHs(sv = sv_2mortal(newSVpv(pwent->pw_shell, 0)));
5319 #   ifndef INCOMPLETE_TAINTS
5320         /* pw_shell is tainted because user himself can diddle with it. */
5321         SvTAINTED_on(sv);
5322 #   endif
5323
5324 #   ifdef PWEXPIRE
5325         mPUSHi(pwent->pw_expire);
5326 #   endif
5327     }
5328     RETURN;
5329 #else
5330     DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5331 #endif
5332 }
5333
5334 PP(pp_ggrent)
5335 {
5336 #ifdef HAS_GROUP
5337     dVAR; dSP;
5338     const I32 which = PL_op->op_type;
5339     const struct group *grent;
5340
5341     if (which == OP_GGRNAM) {
5342         const char* const name = POPpbytex;
5343         grent = (const struct group *)getgrnam(name);
5344     }
5345     else if (which == OP_GGRGID) {
5346         const Gid_t gid = POPi;
5347         grent = (const struct group *)getgrgid(gid);
5348     }
5349     else
5350 #ifdef HAS_GETGRENT
5351         grent = (struct group *)getgrent();
5352 #else
5353         DIE(aTHX_ PL_no_func, "getgrent");
5354 #endif
5355
5356     EXTEND(SP, 4);
5357     if (GIMME != G_ARRAY) {
5358         SV * const sv = sv_newmortal();
5359
5360         PUSHs(sv);
5361         if (grent) {
5362             if (which == OP_GGRNAM)
5363 #if Gid_t_sign <= 0
5364                 sv_setiv(sv, (IV)grent->gr_gid);
5365 #else
5366                 sv_setuv(sv, (UV)grent->gr_gid);
5367 #endif
5368             else
5369                 sv_setpv(sv, grent->gr_name);
5370         }
5371         RETURN;
5372     }
5373
5374     if (grent) {
5375         mPUSHs(newSVpv(grent->gr_name, 0));
5376
5377 #ifdef GRPASSWD
5378         mPUSHs(newSVpv(grent->gr_passwd, 0));
5379 #else
5380         PUSHs(sv_mortalcopy(&PL_sv_no));
5381 #endif
5382
5383 #if Gid_t_sign <= 0
5384         mPUSHi(grent->gr_gid);
5385 #else
5386         mPUSHu(grent->gr_gid);
5387 #endif
5388
5389 #if !(defined(_CRAYMPP) && defined(USE_REENTRANT_API))
5390         /* In UNICOS/mk (_CRAYMPP) the multithreading
5391          * versions (getgrnam_r, getgrgid_r)
5392          * seem to return an illegal pointer
5393          * as the group members list, gr_mem.
5394          * getgrent() doesn't even have a _r version
5395          * but the gr_mem is poisonous anyway.
5396          * So yes, you cannot get the list of group
5397          * members if building multithreaded in UNICOS/mk. */
5398         PUSHs(space_join_names_mortal(grent->gr_mem));
5399 #endif
5400     }
5401
5402     RETURN;
5403 #else
5404     DIE(aTHX_ PL_no_func, PL_op_desc[PL_op->op_type]);
5405 #endif
5406 }
5407
5408 PP(pp_getlogin)
5409 {
5410 #ifdef HAS_GETLOGIN
5411     dVAR; dSP; dTARGET;
5412     char *tmps;
5413     EXTEND(SP, 1);
5414     if (!(tmps = PerlProc_getlogin()))
5415         RETPUSHUNDEF;
5416     sv_setpv_mg(TARG, tmps);
5417     PUSHs(TARG);
5418     RETURN;
5419 #else
5420     DIE(aTHX_ PL_no_func, "getlogin");
5421 #endif
5422 }
5423
5424 /* Miscellaneous. */
5425
5426 PP(pp_syscall)
5427 {
5428 #ifdef HAS_SYSCALL
5429     dVAR; dSP; dMARK; dORIGMARK; dTARGET;
5430     register I32 items = SP - MARK;
5431     unsigned long a[20];
5432     register I32 i = 0;
5433     I32 retval = -1;
5434
5435     if (PL_tainting) {
5436         while (++MARK <= SP) {
5437             if (SvTAINTED(*MARK)) {
5438                 TAINT;
5439                 break;
5440             }
5441         }
5442         MARK = ORIGMARK;
5443         TAINT_PROPER("syscall");
5444     }
5445
5446     /* This probably won't work on machines where sizeof(long) != sizeof(int)
5447      * or where sizeof(long) != sizeof(char*).  But such machines will
5448      * not likely have syscall implemented either, so who cares?
5449      */
5450     while (++MARK <= SP) {
5451         if (SvNIOK(*MARK) || !i)
5452             a[i++] = SvIV(*MARK);
5453         else if (*MARK == &PL_sv_undef)
5454             a[i++] = 0;
5455         else
5456             a[i++] = (unsigned long)SvPV_force_nolen(*MARK);
5457         if (i > 15)
5458             break;
5459     }
5460     switch (items) {
5461     default:
5462         DIE(aTHX_ "Too many args to syscall");
5463     case 0:
5464         DIE(aTHX_ "Too few args to syscall");
5465     case 1:
5466         retval = syscall(a[0]);
5467         break;
5468     case 2:
5469         retval = syscall(a[0],a[1]);
5470         break;
5471     case 3:
5472         retval = syscall(a[0],a[1],a[2]);
5473         break;
5474     case 4:
5475         retval = syscall(a[0],a[1],a[2],a[3]);
5476         break;
5477     case 5:
5478         retval = syscall(a[0],a[1],a[2],a[3],a[4]);
5479         break;
5480     case 6:
5481         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5]);
5482         break;
5483     case 7:
5484         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
5485         break;
5486     case 8:
5487         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
5488         break;
5489 #ifdef atarist
5490     case 9:
5491         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]);
5492         break;
5493     case 10:
5494         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);
5495         break;
5496     case 11:
5497         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
5498           a[10]);
5499         break;
5500     case 12:
5501         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
5502           a[10],a[11]);
5503         break;
5504     case 13:
5505         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
5506           a[10],a[11],a[12]);
5507         break;
5508     case 14:
5509         retval = syscall(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9],
5510           a[10],a[11],a[12],a[13]);
5511         break;
5512 #endif /* atarist */
5513     }
5514     SP = ORIGMARK;
5515     PUSHi(retval);
5516     RETURN;
5517 #else
5518     DIE(aTHX_ PL_no_func, "syscall");
5519 #endif
5520 }
5521
5522 #ifdef FCNTL_EMULATE_FLOCK
5523
5524 /*  XXX Emulate flock() with fcntl().
5525     What's really needed is a good file locking module.
5526 */
5527
5528 static int
5529 fcntl_emulate_flock(int fd, int operation)
5530 {
5531     int res;
5532     struct flock flock;
5533
5534     switch (operation & ~LOCK_NB) {
5535     case LOCK_SH:
5536         flock.l_type = F_RDLCK;
5537         break;
5538     case LOCK_EX:
5539         flock.l_type = F_WRLCK;
5540         break;
5541     case LOCK_UN:
5542         flock.l_type = F_UNLCK;
5543         break;
5544     default:
5545         errno = EINVAL;
5546         return -1;
5547     }
5548     flock.l_whence = SEEK_SET;
5549     flock.l_start = flock.l_len = (Off_t)0;
5550
5551     res = fcntl(fd, (operation & LOCK_NB) ? F_SETLK : F_SETLKW, &flock);
5552     if (res == -1 && ((errno == EAGAIN) || (errno == EACCES)))
5553         errno = EWOULDBLOCK;
5554     return res;
5555 }
5556
5557 #endif /* FCNTL_EMULATE_FLOCK */
5558
5559 #ifdef LOCKF_EMULATE_FLOCK
5560
5561 /*  XXX Emulate flock() with lockf().  This is just to increase
5562     portability of scripts.  The calls are not completely
5563     interchangeable.  What's really needed is a good file
5564     locking module.
5565 */
5566
5567 /*  The lockf() constants might have been defined in <unistd.h>.
5568     Unfortunately, <unistd.h> causes troubles on some mixed
5569     (BSD/POSIX) systems, such as SunOS 4.1.3.
5570
5571    Further, the lockf() constants aren't POSIX, so they might not be
5572    visible if we're compiling with _POSIX_SOURCE defined.  Thus, we'll
5573    just stick in the SVID values and be done with it.  Sigh.
5574 */
5575
5576 # ifndef F_ULOCK
5577 #  define F_ULOCK       0       /* Unlock a previously locked region */
5578 # endif
5579 # ifndef F_LOCK
5580 #  define F_LOCK        1       /* Lock a region for exclusive use */
5581 # endif
5582 # ifndef F_TLOCK
5583 #  define F_TLOCK       2       /* Test and lock a region for exclusive use */
5584 # endif
5585 # ifndef F_TEST
5586 #  define F_TEST        3       /* Test a region for other processes locks */
5587 # endif
5588
5589 static int
5590 lockf_emulate_flock(int fd, int operation)
5591 {
5592     int i;
5593     Off_t pos;
5594     dSAVE_ERRNO;
5595
5596     /* flock locks entire file so for lockf we need to do the same      */
5597     pos = PerlLIO_lseek(fd, (Off_t)0, SEEK_CUR);    /* get pos to restore later */
5598     if (pos > 0)        /* is seekable and needs to be repositioned     */
5599         if (PerlLIO_lseek(fd, (Off_t)0, SEEK_SET) < 0)
5600             pos = -1;   /* seek failed, so don't seek back afterwards   */
5601     RESTORE_ERRNO;
5602
5603     switch (operation) {
5604
5605         /* LOCK_SH - get a shared lock */
5606         case LOCK_SH:
5607         /* LOCK_EX - get an exclusive lock */
5608         case LOCK_EX:
5609             i = lockf (fd, F_LOCK, 0);
5610             break;
5611
5612         /* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
5613         case LOCK_SH|LOCK_NB:
5614         /* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
5615         case LOCK_EX|LOCK_NB:
5616             i = lockf (fd, F_TLOCK, 0);
5617             if (i == -1)
5618                 if ((errno == EAGAIN) || (errno == EACCES))
5619                     errno = EWOULDBLOCK;
5620             break;
5621
5622         /* LOCK_UN - unlock (non-blocking is a no-op) */
5623         case LOCK_UN:
5624         case LOCK_UN|LOCK_NB:
5625             i = lockf (fd, F_ULOCK, 0);
5626             break;
5627
5628         /* Default - can't decipher operation */
5629         default:
5630             i = -1;
5631             errno = EINVAL;
5632             break;
5633     }
5634
5635     if (pos > 0)      /* need to restore position of the handle */
5636         PerlLIO_lseek(fd, pos, SEEK_SET);       /* ignore error here    */
5637
5638     return (i);
5639 }
5640
5641 #endif /* LOCKF_EMULATE_FLOCK */
5642
5643 /*
5644  * Local variables:
5645  * c-indentation-style: bsd
5646  * c-basic-offset: 4
5647  * indent-tabs-mode: t
5648  * End:
5649  *
5650  * ex: set ts=8 sts=4 sw=4 noet:
5651  */