This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
In opcode.h, use the alias macros in PL_ppaddr[]
[perl5.git] / pp_sys.c
CommitLineData
a0d0e21e
LW
1/* pp_sys.c
2 *
fdf8c088 3 * Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
1129b882 4 * 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
a0d0e21e
LW
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.
4ac71550
TC
16 *
17 * [p.945 of _The Lord of the Rings_, VI/iii: "Mount Doom"]
a0d0e21e
LW
18 */
19
166f8a29
DM
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
a0d0e21e 29#include "EXTERN.h"
864dbfa3 30#define PERL_IN_PP_SYS_C
a0d0e21e 31#include "perl.h"
d95a2ea5
CB
32#include "time64.h"
33#include "time64.c"
a0d0e21e 34
f1066039
JH
35#ifdef I_SHADOW
36/* Shadow password support for solaris - pdo@cs.umd.edu
37 * Not just Solaris: at least HP-UX, IRIX, Linux.
3813c136
JH
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__
c529f79d 45/* There is a MAXINT coming from <shadow.h> <- <hpsecurity.h> <- <values.h>
301e8125 46 * and another MAXINT from "perl.h" <- <sys/param.h>. */
3813c136
JH
47# undef MAXINT
48# endif
49# include <shadow.h>
8c0bfa08
PB
50#endif
51
76c32331
PP
52#ifdef I_SYS_WAIT
53# include <sys/wait.h>
54#endif
55
56#ifdef I_SYS_RESOURCE
57# include <sys/resource.h>
16d20bd9 58#endif
a0d0e21e 59
2986a63f
JH
60#ifdef NETWARE
61NETDB_DEFINE_CONTEXT
62#endif
63
a0d0e21e 64#ifdef HAS_SELECT
1e743fda
JH
65# ifdef I_SYS_SELECT
66# include <sys/select.h>
67# endif
a0d0e21e 68#endif
a0d0e21e 69
dc45a647
MB
70/* XXX Configure test needed.
71 h_errno might not be a simple 'int', especially for multi-threaded
5ff3f7a4
GS
72 applications, see "extern int errno in perl.h". Creating such
73 a test requires taking into account the differences between
74 compiling multithreaded and singlethreaded ($ccflags et al).
75 HOST_NOT_FOUND is typically defined in <netdb.h>.
dc45a647 76*/
cb50131a 77#if defined(HOST_NOT_FOUND) && !defined(h_errno) && !defined(__CYGWIN__)
a0d0e21e
LW
78extern int h_errno;
79#endif
80
81#ifdef HAS_PASSWD
82# ifdef I_PWD
83# include <pwd.h>
84# else
fd8cd3a3 85# if !defined(VMS)
20ce7b12
GS
86 struct passwd *getpwnam (char *);
87 struct passwd *getpwuid (Uid_t);
fd8cd3a3 88# endif
a0d0e21e 89# endif
28e8609d 90# ifdef HAS_GETPWENT
10bc17b6 91#ifndef getpwent
20ce7b12 92 struct passwd *getpwent (void);
c2a8f790 93#elif defined (VMS) && defined (my_getpwent)
9fa802f3 94 struct passwd *Perl_my_getpwent (pTHX);
10bc17b6 95#endif
28e8609d 96# endif
a0d0e21e
LW
97#endif
98
99#ifdef HAS_GROUP
100# ifdef I_GRP
101# include <grp.h>
102# else
20ce7b12
GS
103 struct group *getgrnam (char *);
104 struct group *getgrgid (Gid_t);
a0d0e21e 105# endif
28e8609d 106# ifdef HAS_GETGRENT
10bc17b6 107#ifndef getgrent
20ce7b12 108 struct group *getgrent (void);
10bc17b6 109#endif
28e8609d 110# endif
a0d0e21e
LW
111#endif
112
113#ifdef I_UTIME
3730b96e 114# if defined(_MSC_VER) || defined(__MINGW32__)
3fe9a6f1
PP
115# include <sys/utime.h>
116# else
117# include <utime.h>
118# endif
a0d0e21e 119#endif
a0d0e21e 120
cbdc8872 121#ifdef HAS_CHSIZE
cd52b7b2
PP
122# ifdef my_chsize /* Probably #defined to Perl_my_chsize in embed.h */
123# undef my_chsize
124# endif
72cc7e2a 125# define my_chsize PerlLIO_chsize
27da23d5
JH
126#else
127# ifdef HAS_TRUNCATE
128# define my_chsize PerlLIO_chsize
129# else
130I32 my_chsize(int fd, Off_t length);
131# endif
cbdc8872
PP
132#endif
133
ff68c719
PP
134#ifdef HAS_FLOCK
135# define FLOCK flock
136#else /* no flock() */
137
36477c24
PP
138 /* fcntl.h might not have been included, even if it exists, because
139 the current Configure only sets I_FCNTL if it's needed to pick up
140 the *_OK constants. Make sure it has been included before testing
141 the fcntl() locking constants. */
142# if defined(HAS_FCNTL) && !defined(I_FCNTL)
143# include <fcntl.h>
144# endif
145
9d9004a9 146# if defined(HAS_FCNTL) && defined(FCNTL_CAN_LOCK)
ff68c719
PP
147# define FLOCK fcntl_emulate_flock
148# define FCNTL_EMULATE_FLOCK
149# else /* no flock() or fcntl(F_SETLK,...) */
150# ifdef HAS_LOCKF
151# define FLOCK lockf_emulate_flock
152# define LOCKF_EMULATE_FLOCK
153# endif /* lockf */
154# endif /* no flock() or fcntl(F_SETLK,...) */
155
156# ifdef FLOCK
20ce7b12 157 static int FLOCK (int, int);
ff68c719
PP
158
159 /*
160 * These are the flock() constants. Since this sytems doesn't have
161 * flock(), the values of the constants are probably not available.
162 */
163# ifndef LOCK_SH
164# define LOCK_SH 1
165# endif
166# ifndef LOCK_EX
167# define LOCK_EX 2
168# endif
169# ifndef LOCK_NB
170# define LOCK_NB 4
171# endif
172# ifndef LOCK_UN
173# define LOCK_UN 8
174# endif
175# endif /* emulating flock() */
176
177#endif /* no flock() */
55497cff 178
85ab1d1d 179#define ZBTLEN 10
27da23d5 180static const char zero_but_true[ZBTLEN + 1] = "0 but true";
85ab1d1d 181
5ff3f7a4
GS
182#if defined(I_SYS_ACCESS) && !defined(R_OK)
183# include <sys/access.h>
184#endif
185
c529f79d
CB
186#if defined(HAS_FCNTL) && defined(F_SETFD) && !defined(FD_CLOEXEC)
187# define FD_CLOEXEC 1 /* NeXT needs this */
188#endif
189
a4af207c
JH
190#include "reentr.h"
191
9cffb111
OS
192#ifdef __Lynx__
193/* Missing protos on LynxOS */
194void sethostent(int);
195void endhostent(void);
196void setnetent(int);
197void endnetent(void);
198void setprotoent(int);
199void endprotoent(void);
200void setservent(int);
201void endservent(void);
202#endif
203
faee0e31 204#undef PERL_EFF_ACCESS /* EFFective uid/gid ACCESS */
5ff3f7a4
GS
205
206/* F_OK unused: if stat() cannot find it... */
207
d7558cad 208#if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) && defined(EFF_ONLY_OK) && !defined(NO_EFF_ONLY_OK)
c955f117 209 /* Digital UNIX (when the EFF_ONLY_OK gets fixed), UnixWare */
d7558cad 210# define PERL_EFF_ACCESS(p,f) (access((p), (f) | EFF_ONLY_OK))
5ff3f7a4
GS
211#endif
212
d7558cad 213#if !defined(PERL_EFF_ACCESS) && defined(HAS_EACCESS)
3813c136 214# ifdef I_SYS_SECURITY
5ff3f7a4
GS
215# include <sys/security.h>
216# endif
c955f117
JH
217# ifdef ACC_SELF
218 /* HP SecureWare */
d7558cad 219# define PERL_EFF_ACCESS(p,f) (eaccess((p), (f), ACC_SELF))
c955f117
JH
220# else
221 /* SCO */
d7558cad 222# define PERL_EFF_ACCESS(p,f) (eaccess((p), (f)))
c955f117 223# endif
5ff3f7a4
GS
224#endif
225
d7558cad 226#if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESSX) && defined(ACC_SELF)
c955f117 227 /* AIX */
d7558cad 228# define PERL_EFF_ACCESS(p,f) (accessx((p), (f), ACC_SELF))
5ff3f7a4
GS
229#endif
230
d7558cad
NC
231
232#if !defined(PERL_EFF_ACCESS) && defined(HAS_ACCESS) \
327c3667
GS
233 && (defined(HAS_SETREUID) || defined(HAS_SETRESUID) \
234 || defined(HAS_SETREGID) || defined(HAS_SETRESGID))
5ff3f7a4 235/* The Hard Way. */
327c3667 236STATIC int
7f4774ae 237S_emulate_eaccess(pTHX_ const char* path, Mode_t mode)
ba106d47 238{
c4420975
AL
239 const Uid_t ruid = getuid();
240 const Uid_t euid = geteuid();
241 const Gid_t rgid = getgid();
242 const Gid_t egid = getegid();
5ff3f7a4
GS
243 int res;
244
5ff3f7a4 245#if !defined(HAS_SETREUID) && !defined(HAS_SETRESUID)
cea2e8a9 246 Perl_croak(aTHX_ "switching effective uid is not implemented");
5ff3f7a4
GS
247#else
248#ifdef HAS_SETREUID
249 if (setreuid(euid, ruid))
250#else
251#ifdef HAS_SETRESUID
252 if (setresuid(euid, ruid, (Uid_t)-1))
253#endif
254#endif
cea2e8a9 255 Perl_croak(aTHX_ "entering effective uid failed");
5ff3f7a4
GS
256#endif
257
258#if !defined(HAS_SETREGID) && !defined(HAS_SETRESGID)
cea2e8a9 259 Perl_croak(aTHX_ "switching effective gid is not implemented");
5ff3f7a4
GS
260#else
261#ifdef HAS_SETREGID
262 if (setregid(egid, rgid))
263#else
264#ifdef HAS_SETRESGID
265 if (setresgid(egid, rgid, (Gid_t)-1))
266#endif
267#endif
cea2e8a9 268 Perl_croak(aTHX_ "entering effective gid failed");
5ff3f7a4
GS
269#endif
270
271 res = access(path, mode);
272
273#ifdef HAS_SETREUID
274 if (setreuid(ruid, euid))
275#else
276#ifdef HAS_SETRESUID
277 if (setresuid(ruid, euid, (Uid_t)-1))
278#endif
279#endif
cea2e8a9 280 Perl_croak(aTHX_ "leaving effective uid failed");
5ff3f7a4
GS
281
282#ifdef HAS_SETREGID
283 if (setregid(rgid, egid))
284#else
285#ifdef HAS_SETRESGID
286 if (setresgid(rgid, egid, (Gid_t)-1))
287#endif
288#endif
cea2e8a9 289 Perl_croak(aTHX_ "leaving effective gid failed");
5ff3f7a4
GS
290
291 return res;
292}
d6864606 293# define PERL_EFF_ACCESS(p,f) (S_emulate_eaccess(aTHX_ (p), (f)))
5ff3f7a4
GS
294#endif
295
a0d0e21e
LW
296PP(pp_backtick)
297{
97aff369 298 dVAR; dSP; dTARGET;
760ac839 299 PerlIO *fp;
1b6737cc 300 const char * const tmps = POPpconstx;
f54cb97a 301 const I32 gimme = GIMME_V;
e1ec3a88 302 const char *mode = "r";
54310121 303
a0d0e21e 304 TAINT_PROPER("``");
16fe6d59
GS
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";
2fbb330f 309 fp = PerlProc_popen(tmps, mode);
a0d0e21e 310 if (fp) {
11bcd5da 311 const char * const type = Perl_PerlIO_context_layers(aTHX_ NULL);
ac27b0f5
NIS
312 if (type && *type)
313 PerlIO_apply_layers(aTHX_ fp,mode,type);
314
54310121 315 if (gimme == G_VOID) {
96827780
MB
316 char tmpbuf[256];
317 while (PerlIO_read(fp, tmpbuf, sizeof tmpbuf) > 0)
a79db61d 318 NOOP;
54310121
PP
319 }
320 else if (gimme == G_SCALAR) {
d343c3ef 321 ENTER_with_name("backtick");
75af1a9c 322 SAVESPTR(PL_rs);
fa326138 323 PL_rs = &PL_sv_undef;
76f68e9b 324 sv_setpvs(TARG, ""); /* note that this preserves previous buffer */
bd61b366 325 while (sv_gets(TARG, fp, SvCUR(TARG)) != NULL)
a79db61d 326 NOOP;
d343c3ef 327 LEAVE_with_name("backtick");
a0d0e21e 328 XPUSHs(TARG);
aa689395 329 SvTAINTED_on(TARG);
a0d0e21e
LW
330 }
331 else {
a0d0e21e 332 for (;;) {
561b68a9 333 SV * const sv = newSV(79);
bd61b366 334 if (sv_gets(sv, fp, 0) == NULL) {
a0d0e21e
LW
335 SvREFCNT_dec(sv);
336 break;
337 }
6e449a3a 338 mXPUSHs(sv);
a0d0e21e 339 if (SvLEN(sv) - SvCUR(sv) > 20) {
1da4ca5f 340 SvPV_shrink_to_cur(sv);
a0d0e21e 341 }
aa689395 342 SvTAINTED_on(sv);
a0d0e21e
LW
343 }
344 }
2fbb330f 345 STATUS_NATIVE_CHILD_SET(PerlProc_pclose(fp));
aa689395 346 TAINT; /* "I believe that this is not gratuitous!" */
a0d0e21e
LW
347 }
348 else {
37038d91 349 STATUS_NATIVE_CHILD_SET(-1);
54310121 350 if (gimme == G_SCALAR)
a0d0e21e
LW
351 RETPUSHUNDEF;
352 }
353
354 RETURN;
355}
356
357PP(pp_glob)
358{
27da23d5 359 dVAR;
a0d0e21e 360 OP *result;
9426e1a5
DM
361 dSP;
362 /* make a copy of the pattern, to ensure that magic is called once
363 * and only once */
364 TOPm1s = sv_2mortal(newSVsv(TOPm1s));
365
366 tryAMAGICunTARGET(iter_amg, -1, (PL_op->op_flags & OPf_SPECIAL));
d1bea3d8
DM
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
f5284f61 377
71686f12
GS
378 /* Note that we only ever get here if File::Glob fails to load
379 * without at the same time croaking, for some reason, or if
380 * perl was built with PERL_EXTERNAL_GLOB */
381
d343c3ef 382 ENTER_with_name("glob");
a0d0e21e 383
c90c0ff4 384#ifndef VMS
3280af22 385 if (PL_tainting) {
7bac28a0
PP
386 /*
387 * The external globbing program may use things we can't control,
388 * so for security reasons we must assume the worst.
389 */
390 TAINT;
22c35a8c 391 taint_proper(PL_no_security, "glob");
7bac28a0 392 }
c90c0ff4 393#endif /* !VMS */
7bac28a0 394
3280af22 395 SAVESPTR(PL_last_in_gv); /* We don't want this to be permanent. */
159b6efe 396 PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
a0d0e21e 397
3280af22 398 SAVESPTR(PL_rs); /* This is not permanent, either. */
84bafc02 399 PL_rs = newSVpvs_flags("\000", SVs_TEMP);
c07a80fd
PP
400#ifndef DOSISH
401#ifndef CSH
6b88bc9c 402 *SvPVX(PL_rs) = '\n';
a0d0e21e 403#endif /* !CSH */
55497cff 404#endif /* !DOSISH */
c07a80fd 405
a0d0e21e 406 result = do_readline();
d343c3ef 407 LEAVE_with_name("glob");
a0d0e21e
LW
408 return result;
409}
410
a0d0e21e
LW
411PP(pp_rcatline)
412{
97aff369 413 dVAR;
146174a9 414 PL_last_in_gv = cGVOP_gv;
a0d0e21e
LW
415 return do_readline();
416}
417
418PP(pp_warn)
419{
97aff369 420 dVAR; dSP; dMARK;
c5df3096
Z
421 SV *exsv;
422 const char *pv;
06bf62c7 423 STRLEN len;
b59aed67 424 if (SP - MARK > 1) {
a0d0e21e 425 dTARGET;
3280af22 426 do_join(TARG, &PL_sv_no, MARK, SP);
c5df3096 427 exsv = TARG;
a0d0e21e
LW
428 SP = MARK + 1;
429 }
b59aed67 430 else if (SP == MARK) {
c5df3096 431 exsv = &PL_sv_no;
b59aed67 432 EXTEND(SP, 1);
83f957ec 433 SP = MARK + 1;
b59aed67 434 }
a0d0e21e 435 else {
c5df3096 436 exsv = TOPs;
a0d0e21e 437 }
06bf62c7 438
c5df3096
Z
439 if (SvROK(exsv) || (pv = SvPV_const(exsv, len), len)) {
440 /* well-formed exception supplied */
441 }
442 else if (SvROK(ERRSV)) {
443 exsv = ERRSV;
444 }
445 else if (SvPOK(ERRSV) && SvCUR(ERRSV)) {
446 exsv = sv_mortalcopy(ERRSV);
447 sv_catpvs(exsv, "\t...caught");
448 }
449 else {
450 exsv = newSVpvs_flags("Warning: something's wrong", SVs_TEMP);
451 }
452 warn_sv(exsv);
a0d0e21e
LW
453 RETSETYES;
454}
455
456PP(pp_die)
457{
97aff369 458 dVAR; dSP; dMARK;
c5df3096
Z
459 SV *exsv;
460 const char *pv;
06bf62c7 461 STRLEN len;
96e176bf
CL
462#ifdef VMS
463 VMSISH_HUSHED = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH);
464#endif
a0d0e21e
LW
465 if (SP - MARK != 1) {
466 dTARGET;
3280af22 467 do_join(TARG, &PL_sv_no, MARK, SP);
c5df3096 468 exsv = TARG;
a0d0e21e
LW
469 SP = MARK + 1;
470 }
471 else {
c5df3096 472 exsv = TOPs;
a0d0e21e 473 }
c5df3096
Z
474
475 if (SvROK(exsv) || (pv = SvPV_const(exsv, len), len)) {
476 /* well-formed exception supplied */
477 }
478 else if (SvROK(ERRSV)) {
479 exsv = ERRSV;
480 if (sv_isobject(exsv)) {
481 HV * const stash = SvSTASH(SvRV(exsv));
482 GV * const gv = gv_fetchmethod(stash, "PROPAGATE");
483 if (gv) {
484 SV * const file = sv_2mortal(newSVpv(CopFILE(PL_curcop),0));
485 SV * const line = sv_2mortal(newSVuv(CopLINE(PL_curcop)));
486 EXTEND(SP, 3);
487 PUSHMARK(SP);
488 PUSHs(exsv);
489 PUSHs(file);
490 PUSHs(line);
491 PUTBACK;
492 call_sv(MUTABLE_SV(GvCV(gv)),
493 G_SCALAR|G_EVAL|G_KEEPERR);
494 exsv = sv_mortalcopy(*PL_stack_sp--);
05423cc9 495 }
4e6ea2c3 496 }
a0d0e21e 497 }
c5df3096
Z
498 else if (SvPOK(ERRSV) && SvCUR(ERRSV)) {
499 exsv = sv_mortalcopy(ERRSV);
500 sv_catpvs(exsv, "\t...propagated");
501 }
502 else {
503 exsv = newSVpvs_flags("Died", SVs_TEMP);
504 }
9fed9930 505 return die_sv(exsv);
a0d0e21e
LW
506}
507
508/* I/O. */
509
d682515d
NC
510OP *
511Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv,
512 const MAGIC *const mg, const U32 flags, U32 argc, ...)
6bcca55b 513{
d682515d 514 PERL_ARGS_ASSERT_TIED_METHOD;
6bcca55b
NC
515
516 /* Ensure that our flag bits do not overlap. */
d682515d
NC
517 assert((TIED_METHOD_MORTALIZE_NOT_NEEDED & G_WANT) == 0);
518 assert((TIED_METHOD_ARGUMENTS_ON_STACK & G_WANT) == 0);
94bc412f 519 assert((TIED_METHOD_SAY & G_WANT) == 0);
6bcca55b
NC
520
521 PUSHMARK(sp);
d682515d
NC
522 PUSHs(SvTIED_obj(sv, mg));
523 if (flags & TIED_METHOD_ARGUMENTS_ON_STACK)
1a8c1d59
NC
524 sp += argc;
525 else if (argc) {
d682515d
NC
526 const U32 mortalize_not_needed
527 = flags & TIED_METHOD_MORTALIZE_NOT_NEEDED;
6bcca55b 528 va_list args;
0d5509eb 529 va_start(args, argc);
6bcca55b
NC
530 do {
531 SV *const arg = va_arg(args, SV *);
532 if(mortalize_not_needed)
533 PUSHs(arg);
534 else
535 mPUSHs(arg);
536 } while (--argc);
537 va_end(args);
538 }
539
540 PUTBACK;
d682515d 541 ENTER_with_name("call_tied_method");
94bc412f
NC
542 if (flags & TIED_METHOD_SAY) {
543 /* local $\ = "\n" */
544 SAVEGENERICSV(PL_ors_sv);
545 PL_ors_sv = newSVpvs("\n");
546 }
6bcca55b 547 call_method(methname, flags & G_WANT);
d682515d 548 LEAVE_with_name("call_tied_method");
6bcca55b
NC
549 return NORMAL;
550}
551
d682515d
NC
552#define tied_method0(a,b,c,d) \
553 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,0)
554#define tied_method1(a,b,c,d,e) \
555 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,1,e)
556#define tied_method2(a,b,c,d,e,f) \
557 Perl_tied_method(aTHX_ a,b,c,d,G_SCALAR,2,e,f)
6bcca55b 558
a0d0e21e
LW
559PP(pp_open)
560{
27da23d5 561 dVAR; dSP;
a567e93b
NIS
562 dMARK; dORIGMARK;
563 dTARGET;
a0d0e21e 564 SV *sv;
5b468f54 565 IO *io;
5c144d81 566 const char *tmps;
a0d0e21e 567 STRLEN len;
a567e93b 568 bool ok;
a0d0e21e 569
159b6efe 570 GV * const gv = MUTABLE_GV(*++MARK);
c4420975 571
13be902c 572 if (!isGV(gv) && !(SvTYPE(gv) == SVt_PVLV && isGV_with_GP(gv)))
cea2e8a9 573 DIE(aTHX_ PL_no_usym, "filehandle");
abc718f2 574
a79db61d 575 if ((io = GvIOp(gv))) {
a5e1d062 576 const MAGIC *mg;
36477c24 577 IoFLAGS(GvIOp(gv)) &= ~IOf_UNTAINT;
853846ea 578
a2a5de95 579 if (IoDIRP(io))
d1d15184
NC
580 Perl_ck_warner_d(aTHX_ packWARN2(WARN_IO, WARN_DEPRECATED),
581 "Opening dirhandle %s also as a file",
582 GvENAME(gv));
abc718f2 583
ad64d0ec 584 mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
c4420975
AL
585 if (mg) {
586 /* Method's args are same as ours ... */
587 /* ... except handle is replaced by the object */
d682515d
NC
588 return Perl_tied_method(aTHX_ "OPEN", mark - 1, MUTABLE_SV(io), mg,
589 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
590 sp - mark);
c4420975 591 }
4592e6ca
NIS
592 }
593
a567e93b
NIS
594 if (MARK < SP) {
595 sv = *++MARK;
596 }
597 else {
35a08ec7 598 sv = GvSVn(gv);
a567e93b
NIS
599 }
600
5c144d81 601 tmps = SvPV_const(sv, len);
4608196e 602 ok = do_openn(gv, tmps, len, FALSE, O_RDONLY, 0, NULL, MARK+1, (SP-MARK));
a567e93b
NIS
603 SP = ORIGMARK;
604 if (ok)
3280af22
NIS
605 PUSHi( (I32)PL_forkprocess );
606 else if (PL_forkprocess == 0) /* we are a new child */
a0d0e21e
LW
607 PUSHi(0);
608 else
609 RETPUSHUNDEF;
610 RETURN;
611}
612
613PP(pp_close)
614{
27da23d5 615 dVAR; dSP;
159b6efe 616 GV * const gv = (MAXARG == 0) ? PL_defoutgv : MUTABLE_GV(POPs);
1d603a67 617
2addaaf3
NC
618 if (MAXARG == 0)
619 EXTEND(SP, 1);
620
a79db61d
AL
621 if (gv) {
622 IO * const io = GvIO(gv);
623 if (io) {
a5e1d062 624 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 625 if (mg) {
d682515d 626 return tied_method0("CLOSE", SP, MUTABLE_SV(io), mg);
a79db61d
AL
627 }
628 }
1d603a67 629 }
54310121 630 PUSHs(boolSV(do_close(gv, TRUE)));
a0d0e21e
LW
631 RETURN;
632}
633
634PP(pp_pipe_op)
635{
a0d0e21e 636#ifdef HAS_PIPE
97aff369 637 dVAR;
9cad6237 638 dSP;
a0d0e21e
LW
639 register IO *rstio;
640 register IO *wstio;
641 int fd[2];
642
159b6efe
NC
643 GV * const wgv = MUTABLE_GV(POPs);
644 GV * const rgv = MUTABLE_GV(POPs);
a0d0e21e
LW
645
646 if (!rgv || !wgv)
647 goto badexit;
648
6e592b3a 649 if (!isGV_with_GP(rgv) || !isGV_with_GP(wgv))
cea2e8a9 650 DIE(aTHX_ PL_no_usym, "filehandle");
a0d0e21e
LW
651 rstio = GvIOn(rgv);
652 wstio = GvIOn(wgv);
653
654 if (IoIFP(rstio))
655 do_close(rgv, FALSE);
656 if (IoIFP(wstio))
657 do_close(wgv, FALSE);
658
6ad3d225 659 if (PerlProc_pipe(fd) < 0)
a0d0e21e
LW
660 goto badexit;
661
460c8493
IZ
662 IoIFP(rstio) = PerlIO_fdopen(fd[0], "r"PIPE_OPEN_MODE);
663 IoOFP(wstio) = PerlIO_fdopen(fd[1], "w"PIPE_OPEN_MODE);
b5ac89c3 664 IoOFP(rstio) = IoIFP(rstio);
a0d0e21e 665 IoIFP(wstio) = IoOFP(wstio);
50952442
JH
666 IoTYPE(rstio) = IoTYPE_RDONLY;
667 IoTYPE(wstio) = IoTYPE_WRONLY;
a0d0e21e
LW
668
669 if (!IoIFP(rstio) || !IoOFP(wstio)) {
a79db61d
AL
670 if (IoIFP(rstio))
671 PerlIO_close(IoIFP(rstio));
672 else
673 PerlLIO_close(fd[0]);
674 if (IoOFP(wstio))
675 PerlIO_close(IoOFP(wstio));
676 else
677 PerlLIO_close(fd[1]);
a0d0e21e
LW
678 goto badexit;
679 }
4771b018
GS
680#if defined(HAS_FCNTL) && defined(F_SETFD)
681 fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd); /* ensure close-on-exec */
682 fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd); /* ensure close-on-exec */
683#endif
a0d0e21e
LW
684 RETPUSHYES;
685
686badexit:
687 RETPUSHUNDEF;
688#else
cea2e8a9 689 DIE(aTHX_ PL_no_func, "pipe");
a0d0e21e
LW
690#endif
691}
692
693PP(pp_fileno)
694{
27da23d5 695 dVAR; dSP; dTARGET;
a0d0e21e
LW
696 GV *gv;
697 IO *io;
760ac839 698 PerlIO *fp;
a5e1d062 699 const MAGIC *mg;
4592e6ca 700
a0d0e21e
LW
701 if (MAXARG < 1)
702 RETPUSHUNDEF;
159b6efe 703 gv = MUTABLE_GV(POPs);
9c9f25b8 704 io = GvIO(gv);
4592e6ca 705
9c9f25b8 706 if (io
ad64d0ec 707 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
5b468f54 708 {
d682515d 709 return tied_method0("FILENO", SP, MUTABLE_SV(io), mg);
4592e6ca
NIS
710 }
711
9c9f25b8 712 if (!io || !(fp = IoIFP(io))) {
c289d2f7
JH
713 /* Can't do this because people seem to do things like
714 defined(fileno($foo)) to check whether $foo is a valid fh.
51087808
NC
715
716 report_evil_fh(gv);
c289d2f7 717 */
a0d0e21e 718 RETPUSHUNDEF;
c289d2f7
JH
719 }
720
760ac839 721 PUSHi(PerlIO_fileno(fp));
a0d0e21e
LW
722 RETURN;
723}
724
725PP(pp_umask)
726{
97aff369 727 dVAR;
27da23d5 728 dSP;
d7e492a4 729#ifdef HAS_UMASK
27da23d5 730 dTARGET;
761237fe 731 Mode_t anum;
a0d0e21e 732
a0d0e21e 733 if (MAXARG < 1) {
b0b546b3
GA
734 anum = PerlLIO_umask(022);
735 /* setting it to 022 between the two calls to umask avoids
736 * to have a window where the umask is set to 0 -- meaning
737 * that another thread could create world-writeable files. */
738 if (anum != 022)
739 (void)PerlLIO_umask(anum);
a0d0e21e
LW
740 }
741 else
6ad3d225 742 anum = PerlLIO_umask(POPi);
a0d0e21e
LW
743 TAINT_PROPER("umask");
744 XPUSHi(anum);
745#else
a0288114 746 /* Only DIE if trying to restrict permissions on "user" (self).
eec2d3df
GS
747 * Otherwise it's harmless and more useful to just return undef
748 * since 'group' and 'other' concepts probably don't exist here. */
749 if (MAXARG >= 1 && (POPi & 0700))
cea2e8a9 750 DIE(aTHX_ "umask not implemented");
6b88bc9c 751 XPUSHs(&PL_sv_undef);
a0d0e21e
LW
752#endif
753 RETURN;
754}
755
756PP(pp_binmode)
757{
27da23d5 758 dVAR; dSP;
a0d0e21e
LW
759 GV *gv;
760 IO *io;
760ac839 761 PerlIO *fp;
a0714e2c 762 SV *discp = NULL;
a0d0e21e
LW
763
764 if (MAXARG < 1)
765 RETPUSHUNDEF;
60382766 766 if (MAXARG > 1) {
16fe6d59 767 discp = POPs;
60382766 768 }
a0d0e21e 769
159b6efe 770 gv = MUTABLE_GV(POPs);
9c9f25b8 771 io = GvIO(gv);
4592e6ca 772
9c9f25b8 773 if (io) {
a5e1d062 774 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 775 if (mg) {
bc0c81ca
NC
776 /* This takes advantage of the implementation of the varargs
777 function, which I don't think that the optimiser will be able to
778 figure out. Although, as it's a static function, in theory it
779 could. */
d682515d
NC
780 return Perl_tied_method(aTHX_ "BINMODE", SP, MUTABLE_SV(io), mg,
781 G_SCALAR|TIED_METHOD_MORTALIZE_NOT_NEEDED,
782 discp ? 1 : 0, discp);
a79db61d 783 }
4592e6ca 784 }
a0d0e21e 785
9c9f25b8 786 if (!io || !(fp = IoIFP(io))) {
51087808 787 report_evil_fh(gv);
b5fe5ca2 788 SETERRNO(EBADF,RMS_IFI);
50f846a7
SC
789 RETPUSHUNDEF;
790 }
a0d0e21e 791
40d98b49 792 PUTBACK;
f0a78170 793 {
a79b25b7
VP
794 STRLEN len = 0;
795 const char *d = NULL;
796 int mode;
797 if (discp)
798 d = SvPV_const(discp, len);
799 mode = mode_from_discipline(d, len);
f0a78170
NC
800 if (PerlIO_binmode(aTHX_ fp, IoTYPE(io), mode, d)) {
801 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) {
802 if (!PerlIO_binmode(aTHX_ IoOFP(io), IoTYPE(io), mode, d)) {
803 SPAGAIN;
804 RETPUSHUNDEF;
805 }
806 }
807 SPAGAIN;
808 RETPUSHYES;
809 }
810 else {
811 SPAGAIN;
812 RETPUSHUNDEF;
38af81ff 813 }
40d98b49 814 }
a0d0e21e
LW
815}
816
817PP(pp_tie)
818{
27da23d5 819 dVAR; dSP; dMARK;
a0d0e21e 820 HV* stash;
07822e36 821 GV *gv = NULL;
a0d0e21e 822 SV *sv;
1df70142 823 const I32 markoff = MARK - PL_stack_base;
e1ec3a88 824 const char *methname;
14befaf4 825 int how = PERL_MAGIC_tied;
e336de0d 826 U32 items;
c4420975 827 SV *varsv = *++MARK;
a0d0e21e 828
6b05c17a
NIS
829 switch(SvTYPE(varsv)) {
830 case SVt_PVHV:
831 methname = "TIEHASH";
85fbaab2 832 HvEITER_set(MUTABLE_HV(varsv), 0);
6b05c17a
NIS
833 break;
834 case SVt_PVAV:
835 methname = "TIEARRAY";
836 break;
837 case SVt_PVGV:
13be902c 838 case SVt_PVLV:
7850f4d6 839 if (isGV_with_GP(varsv)) {
7c7df812
FC
840 if (SvFAKE(varsv) && !(GvFLAGS(varsv) & GVf_TIEWARNED)) {
841 deprecate("tie on a handle without *");
842 GvFLAGS(varsv) |= GVf_TIEWARNED;
843 }
6e592b3a
BM
844 methname = "TIEHANDLE";
845 how = PERL_MAGIC_tiedscalar;
846 /* For tied filehandles, we apply tiedscalar magic to the IO
847 slot of the GP rather than the GV itself. AMS 20010812 */
848 if (!GvIOp(varsv))
849 GvIOp(varsv) = newIO();
ad64d0ec 850 varsv = MUTABLE_SV(GvIOp(varsv));
6e592b3a
BM
851 break;
852 }
853 /* FALL THROUGH */
6b05c17a
NIS
854 default:
855 methname = "TIESCALAR";
14befaf4 856 how = PERL_MAGIC_tiedscalar;
6b05c17a
NIS
857 break;
858 }
e336de0d 859 items = SP - MARK++;
a91d1d42 860 if (sv_isobject(*MARK)) { /* Calls GET magic. */
d343c3ef 861 ENTER_with_name("call_TIE");
e788e7d3 862 PUSHSTACKi(PERLSI_MAGIC);
e336de0d 863 PUSHMARK(SP);
eb160463 864 EXTEND(SP,(I32)items);
e336de0d
GS
865 while (items--)
866 PUSHs(*MARK++);
867 PUTBACK;
864dbfa3 868 call_method(methname, G_SCALAR);
301e8125 869 }
6b05c17a 870 else {
086d2913
NC
871 /* Can't use call_method here, else this: fileno FOO; tie @a, "FOO"
872 * will attempt to invoke IO::File::TIEARRAY, with (best case) the
873 * wrong error message, and worse case, supreme action at a distance.
874 * (Sorry obfuscation writers. You're not going to be given this one.)
6b05c17a 875 */
a91d1d42
VP
876 STRLEN len;
877 const char *name = SvPV_nomg_const(*MARK, len);
878 stash = gv_stashpvn(name, len, 0);
6b05c17a 879 if (!stash || !(gv = gv_fetchmethod(stash, methname))) {
35c1215d 880 DIE(aTHX_ "Can't locate object method \"%s\" via package \"%"SVf"\"",
a91d1d42 881 methname, SVfARG(SvOK(*MARK) ? *MARK : &PL_sv_no));
6b05c17a 882 }
d343c3ef 883 ENTER_with_name("call_TIE");
e788e7d3 884 PUSHSTACKi(PERLSI_MAGIC);
e336de0d 885 PUSHMARK(SP);
eb160463 886 EXTEND(SP,(I32)items);
e336de0d
GS
887 while (items--)
888 PUSHs(*MARK++);
889 PUTBACK;
ad64d0ec 890 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
6b05c17a 891 }
a0d0e21e
LW
892 SPAGAIN;
893
894 sv = TOPs;
d3acc0f7 895 POPSTACK;
a0d0e21e 896 if (sv_isobject(sv)) {
33c27489 897 sv_unmagic(varsv, how);
ae21d580 898 /* Croak if a self-tie on an aggregate is attempted. */
b881518d 899 if (varsv == SvRV(sv) &&
d87ebaca
YST
900 (SvTYPE(varsv) == SVt_PVAV ||
901 SvTYPE(varsv) == SVt_PVHV))
ae21d580
JH
902 Perl_croak(aTHX_
903 "Self-ties of arrays and hashes are not supported");
a0714e2c 904 sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
a0d0e21e 905 }
d343c3ef 906 LEAVE_with_name("call_TIE");
3280af22 907 SP = PL_stack_base + markoff;
a0d0e21e
LW
908 PUSHs(sv);
909 RETURN;
910}
911
912PP(pp_untie)
913{
27da23d5 914 dVAR; dSP;
5b468f54 915 MAGIC *mg;
33c27489 916 SV *sv = POPs;
1df70142 917 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
14befaf4 918 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
55497cff 919
7c7df812
FC
920 if (isGV_with_GP(sv)) {
921 if (SvFAKE(sv) && !(GvFLAGS(sv) & GVf_TIEWARNED)) {
922 deprecate("untie on a handle without *");
923 GvFLAGS(sv) |= GVf_TIEWARNED;
924 }
925 if (!(sv = MUTABLE_SV(GvIOp(sv))))
5b468f54 926 RETPUSHYES;
7c7df812 927 }
5b468f54 928
65eba18f 929 if ((mg = SvTIED_mg(sv, how))) {
1b6737cc 930 SV * const obj = SvRV(SvTIED_obj(sv, mg));
fa2b88e0 931 if (obj) {
c4420975 932 GV * const gv = gv_fetchmethod_autoload(SvSTASH(obj), "UNTIE", FALSE);
0bd48802 933 CV *cv;
c4420975 934 if (gv && isGV(gv) && (cv = GvCV(gv))) {
fa2b88e0 935 PUSHMARK(SP);
c33ef3ac 936 PUSHs(SvTIED_obj(MUTABLE_SV(gv), mg));
6e449a3a 937 mXPUSHi(SvREFCNT(obj) - 1);
fa2b88e0 938 PUTBACK;
d343c3ef 939 ENTER_with_name("call_UNTIE");
ad64d0ec 940 call_sv(MUTABLE_SV(cv), G_VOID);
d343c3ef 941 LEAVE_with_name("call_UNTIE");
fa2b88e0
JS
942 SPAGAIN;
943 }
a2a5de95
NC
944 else if (mg && SvREFCNT(obj) > 1) {
945 Perl_ck_warner(aTHX_ packWARN(WARN_UNTIE),
946 "untie attempted while %"UVuf" inner references still exist",
947 (UV)SvREFCNT(obj) - 1 ) ;
c4420975 948 }
cbdc8872
PP
949 }
950 }
38193a09 951 sv_unmagic(sv, how) ;
55497cff 952 RETPUSHYES;
a0d0e21e
LW
953}
954
c07a80fd
PP
955PP(pp_tied)
956{
97aff369 957 dVAR;
39644a26 958 dSP;
1b6737cc 959 const MAGIC *mg;
33c27489 960 SV *sv = POPs;
1df70142 961 const char how = (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV)
14befaf4 962 ? PERL_MAGIC_tied : PERL_MAGIC_tiedscalar;
5b468f54 963
7c7df812
FC
964 if (isGV_with_GP(sv)) {
965 if (SvFAKE(sv) && !(GvFLAGS(sv) & GVf_TIEWARNED)) {
966 deprecate("tied on a handle without *");
967 GvFLAGS(sv) |= GVf_TIEWARNED;
968 }
969 if (!(sv = MUTABLE_SV(GvIOp(sv))))
5b468f54 970 RETPUSHUNDEF;
7c7df812 971 }
c07a80fd 972
155aba94 973 if ((mg = SvTIED_mg(sv, how))) {
33c27489
GS
974 SV *osv = SvTIED_obj(sv, mg);
975 if (osv == mg->mg_obj)
976 osv = sv_mortalcopy(osv);
977 PUSHs(osv);
978 RETURN;
c07a80fd 979 }
c07a80fd
PP
980 RETPUSHUNDEF;
981}
982
a0d0e21e
LW
983PP(pp_dbmopen)
984{
27da23d5 985 dVAR; dSP;
a0d0e21e
LW
986 dPOPPOPssrl;
987 HV* stash;
07822e36 988 GV *gv = NULL;
a0d0e21e 989
85fbaab2 990 HV * const hv = MUTABLE_HV(POPs);
84bafc02 991 SV * const sv = newSVpvs_flags("AnyDBM_File", SVs_TEMP);
da51bb9b 992 stash = gv_stashsv(sv, 0);
8ebc5c01 993 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH"))) {
a0d0e21e 994 PUTBACK;
864dbfa3 995 require_pv("AnyDBM_File.pm");
a0d0e21e 996 SPAGAIN;
eff494dd 997 if (!stash || !(gv = gv_fetchmethod(stash, "TIEHASH")))
cea2e8a9 998 DIE(aTHX_ "No dbm on this machine");
a0d0e21e
LW
999 }
1000
57d3b86d 1001 ENTER;
924508f0 1002 PUSHMARK(SP);
6b05c17a 1003
924508f0 1004 EXTEND(SP, 5);
a0d0e21e
LW
1005 PUSHs(sv);
1006 PUSHs(left);
1007 if (SvIV(right))
6e449a3a 1008 mPUSHu(O_RDWR|O_CREAT);
a0d0e21e 1009 else
6e449a3a 1010 mPUSHu(O_RDWR);
a0d0e21e 1011 PUSHs(right);
57d3b86d 1012 PUTBACK;
ad64d0ec 1013 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
a0d0e21e
LW
1014 SPAGAIN;
1015
1016 if (!sv_isobject(TOPs)) {
924508f0
GS
1017 SP--;
1018 PUSHMARK(SP);
a0d0e21e
LW
1019 PUSHs(sv);
1020 PUSHs(left);
6e449a3a 1021 mPUSHu(O_RDONLY);
a0d0e21e 1022 PUSHs(right);
a0d0e21e 1023 PUTBACK;
ad64d0ec 1024 call_sv(MUTABLE_SV(GvCV(gv)), G_SCALAR);
a0d0e21e
LW
1025 SPAGAIN;
1026 }
1027
6b05c17a 1028 if (sv_isobject(TOPs)) {
ad64d0ec
NC
1029 sv_unmagic(MUTABLE_SV(hv), PERL_MAGIC_tied);
1030 sv_magic(MUTABLE_SV(hv), TOPs, PERL_MAGIC_tied, NULL, 0);
6b05c17a 1031 }
a0d0e21e
LW
1032 LEAVE;
1033 RETURN;
1034}
1035
a0d0e21e
LW
1036PP(pp_sselect)
1037{
a0d0e21e 1038#ifdef HAS_SELECT
97aff369 1039 dVAR; dSP; dTARGET;
a0d0e21e
LW
1040 register I32 i;
1041 register I32 j;
1042 register char *s;
1043 register SV *sv;
65202027 1044 NV value;
a0d0e21e
LW
1045 I32 maxlen = 0;
1046 I32 nfound;
1047 struct timeval timebuf;
1048 struct timeval *tbuf = &timebuf;
1049 I32 growsize;
1050 char *fd_sets[4];
1051#if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1052 I32 masksize;
1053 I32 offset;
1054 I32 k;
1055
1056# if BYTEORDER & 0xf0000
1057# define ORDERBYTE (0x88888888 - BYTEORDER)
1058# else
1059# define ORDERBYTE (0x4444 - BYTEORDER)
1060# endif
1061
1062#endif
1063
1064 SP -= 4;
1065 for (i = 1; i <= 3; i++) {
c4420975 1066 SV * const sv = SP[i];
15547071
GA
1067 if (!SvOK(sv))
1068 continue;
1069 if (SvREADONLY(sv)) {
729c079f
NC
1070 if (SvIsCOW(sv))
1071 sv_force_normal_flags(sv, 0);
15547071 1072 if (SvREADONLY(sv) && !(SvPOK(sv) && SvCUR(sv) == 0))
6ad8f254 1073 Perl_croak_no_modify(aTHX);
729c079f 1074 }
4ef2275c 1075 if (!SvPOK(sv)) {
a2a5de95 1076 Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Non-string passed as bitmask");
4ef2275c
GA
1077 SvPV_force_nolen(sv); /* force string conversion */
1078 }
729c079f 1079 j = SvCUR(sv);
a0d0e21e
LW
1080 if (maxlen < j)
1081 maxlen = j;
1082 }
1083
5ff3f7a4 1084/* little endians can use vecs directly */
e366b469 1085#if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
5ff3f7a4 1086# ifdef NFDBITS
a0d0e21e 1087
5ff3f7a4
GS
1088# ifndef NBBY
1089# define NBBY 8
1090# endif
a0d0e21e
LW
1091
1092 masksize = NFDBITS / NBBY;
5ff3f7a4 1093# else
a0d0e21e 1094 masksize = sizeof(long); /* documented int, everyone seems to use long */
5ff3f7a4 1095# endif
a0d0e21e
LW
1096 Zero(&fd_sets[0], 4, char*);
1097#endif
1098
ad517f75
MHM
1099# if SELECT_MIN_BITS == 1
1100 growsize = sizeof(fd_set);
1101# else
1102# if defined(__GLIBC__) && defined(__FD_SETSIZE)
1103# undef SELECT_MIN_BITS
1104# define SELECT_MIN_BITS __FD_SETSIZE
1105# endif
e366b469
PG
1106 /* If SELECT_MIN_BITS is greater than one we most probably will want
1107 * to align the sizes with SELECT_MIN_BITS/8 because for example
1108 * in many little-endian (Intel, Alpha) systems (Linux, OS/2, Digital
1109 * UNIX, Solaris, NeXT, Darwin) the smallest quantum select() operates
1110 * on (sets/tests/clears bits) is 32 bits. */
1111 growsize = maxlen + (SELECT_MIN_BITS/8 - (maxlen % (SELECT_MIN_BITS/8)));
e366b469
PG
1112# endif
1113
a0d0e21e
LW
1114 sv = SP[4];
1115 if (SvOK(sv)) {
1116 value = SvNV(sv);
1117 if (value < 0.0)
1118 value = 0.0;
1119 timebuf.tv_sec = (long)value;
65202027 1120 value -= (NV)timebuf.tv_sec;
a0d0e21e
LW
1121 timebuf.tv_usec = (long)(value * 1000000.0);
1122 }
1123 else
4608196e 1124 tbuf = NULL;
a0d0e21e
LW
1125
1126 for (i = 1; i <= 3; i++) {
1127 sv = SP[i];
15547071 1128 if (!SvOK(sv) || SvCUR(sv) == 0) {
a0d0e21e
LW
1129 fd_sets[i] = 0;
1130 continue;
1131 }
4ef2275c 1132 assert(SvPOK(sv));
a0d0e21e
LW
1133 j = SvLEN(sv);
1134 if (j < growsize) {
1135 Sv_Grow(sv, growsize);
a0d0e21e 1136 }
c07a80fd
PP
1137 j = SvCUR(sv);
1138 s = SvPVX(sv) + j;
1139 while (++j <= growsize) {
1140 *s++ = '\0';
1141 }
1142
a0d0e21e
LW
1143#if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1144 s = SvPVX(sv);
a02a5408 1145 Newx(fd_sets[i], growsize, char);
a0d0e21e
LW
1146 for (offset = 0; offset < growsize; offset += masksize) {
1147 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1148 fd_sets[i][j+offset] = s[(k % masksize) + offset];
1149 }
1150#else
1151 fd_sets[i] = SvPVX(sv);
1152#endif
1153 }
1154
dc4c69d9
JH
1155#ifdef PERL_IRIX5_SELECT_TIMEVAL_VOID_CAST
1156 /* Can't make just the (void*) conditional because that would be
1157 * cpp #if within cpp macro, and not all compilers like that. */
1158 nfound = PerlSock_select(
1159 maxlen * 8,
1160 (Select_fd_set_t) fd_sets[1],
1161 (Select_fd_set_t) fd_sets[2],
1162 (Select_fd_set_t) fd_sets[3],
1163 (void*) tbuf); /* Workaround for compiler bug. */
1164#else
6ad3d225 1165 nfound = PerlSock_select(
a0d0e21e
LW
1166 maxlen * 8,
1167 (Select_fd_set_t) fd_sets[1],
1168 (Select_fd_set_t) fd_sets[2],
1169 (Select_fd_set_t) fd_sets[3],
1170 tbuf);
dc4c69d9 1171#endif
a0d0e21e
LW
1172 for (i = 1; i <= 3; i++) {
1173 if (fd_sets[i]) {
1174 sv = SP[i];
1175#if BYTEORDER != 0x1234 && BYTEORDER != 0x12345678
1176 s = SvPVX(sv);
1177 for (offset = 0; offset < growsize; offset += masksize) {
1178 for (j = 0, k=ORDERBYTE; j < masksize; j++, (k >>= 4))
1179 s[(k % masksize) + offset] = fd_sets[i][j+offset];
1180 }
1181 Safefree(fd_sets[i]);
1182#endif
1183 SvSETMAGIC(sv);
1184 }
1185 }
1186
4189264e 1187 PUSHi(nfound);
a0d0e21e 1188 if (GIMME == G_ARRAY && tbuf) {
65202027
DS
1189 value = (NV)(timebuf.tv_sec) +
1190 (NV)(timebuf.tv_usec) / 1000000.0;
6e449a3a 1191 mPUSHn(value);
a0d0e21e
LW
1192 }
1193 RETURN;
1194#else
cea2e8a9 1195 DIE(aTHX_ "select not implemented");
a0d0e21e
LW
1196#endif
1197}
1198
8226a3d7
NC
1199/*
1200=for apidoc setdefout
1201
1202Sets PL_defoutgv, the default file handle for output, to the passed in
1203typeglob. As PL_defoutgv "owns" a reference on its typeglob, the reference
1204count of the passed in typeglob is increased by one, and the reference count
1205of the typeglob that PL_defoutgv points to is decreased by one.
1206
1207=cut
1208*/
1209
4633a7c4 1210void
864dbfa3 1211Perl_setdefout(pTHX_ GV *gv)
4633a7c4 1212{
97aff369 1213 dVAR;
b37c2d43 1214 SvREFCNT_inc_simple_void(gv);
ef8d46e8 1215 SvREFCNT_dec(PL_defoutgv);
3280af22 1216 PL_defoutgv = gv;
4633a7c4
LW
1217}
1218
a0d0e21e
LW
1219PP(pp_select)
1220{
97aff369 1221 dVAR; dSP; dTARGET;
4633a7c4 1222 HV *hv;
159b6efe 1223 GV * const newdefout = (PL_op->op_private > 0) ? (MUTABLE_GV(POPs)) : NULL;
099be4f1 1224 GV * egv = GvEGVx(PL_defoutgv);
4633a7c4 1225
4633a7c4 1226 if (!egv)
3280af22 1227 egv = PL_defoutgv;
099be4f1 1228 hv = isGV_with_GP(egv) ? GvSTASH(egv) : NULL;
4633a7c4 1229 if (! hv)
3280af22 1230 XPUSHs(&PL_sv_undef);
4633a7c4 1231 else {
c4420975 1232 GV * const * const gvp = (GV**)hv_fetch(hv, GvNAME(egv), GvNAMELEN(egv), FALSE);
f86702cc 1233 if (gvp && *gvp == egv) {
bd61b366 1234 gv_efullname4(TARG, PL_defoutgv, NULL, TRUE);
f86702cc
PP
1235 XPUSHTARG;
1236 }
1237 else {
ad64d0ec 1238 mXPUSHs(newRV(MUTABLE_SV(egv)));
f86702cc 1239 }
4633a7c4
LW
1240 }
1241
1242 if (newdefout) {
ded8aa31
GS
1243 if (!GvIO(newdefout))
1244 gv_IOadd(newdefout);
4633a7c4
LW
1245 setdefout(newdefout);
1246 }
1247
a0d0e21e
LW
1248 RETURN;
1249}
1250
1251PP(pp_getc)
1252{
27da23d5 1253 dVAR; dSP; dTARGET;
159b6efe 1254 GV * const gv = (MAXARG==0) ? PL_stdingv : MUTABLE_GV(POPs);
9c9f25b8 1255 IO *const io = GvIO(gv);
2ae324a7 1256
ac3697cd
NC
1257 if (MAXARG == 0)
1258 EXTEND(SP, 1);
1259
9c9f25b8 1260 if (io) {
a5e1d062 1261 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 1262 if (mg) {
0240605e 1263 const U32 gimme = GIMME_V;
d682515d 1264 Perl_tied_method(aTHX_ "GETC", SP, MUTABLE_SV(io), mg, gimme, 0);
0240605e
NC
1265 if (gimme == G_SCALAR) {
1266 SPAGAIN;
a79db61d 1267 SvSetMagicSV_nosteal(TARG, TOPs);
0240605e
NC
1268 }
1269 return NORMAL;
a79db61d 1270 }
2ae324a7 1271 }
90133b69 1272 if (!gv || do_eof(gv)) { /* make sure we have fp with something */
51087808 1273 if (!io || (!IoIFP(io) && IoTYPE(io) != IoTYPE_WRONLY))
831e4cc3 1274 report_evil_fh(gv);
b5fe5ca2 1275 SETERRNO(EBADF,RMS_IFI);
a0d0e21e 1276 RETPUSHUNDEF;
90133b69 1277 }
bbce6d69 1278 TAINT;
76f68e9b 1279 sv_setpvs(TARG, " ");
9bc64814 1280 *SvPVX(TARG) = PerlIO_getc(IoIFP(GvIOp(gv))); /* should never be EOF */
7d59b7e4
NIS
1281 if (PerlIO_isutf8(IoIFP(GvIOp(gv)))) {
1282 /* Find out how many bytes the char needs */
aa07b2f6 1283 Size_t len = UTF8SKIP(SvPVX_const(TARG));
7d59b7e4
NIS
1284 if (len > 1) {
1285 SvGROW(TARG,len+1);
1286 len = PerlIO_read(IoIFP(GvIOp(gv)),SvPVX(TARG)+1,len-1);
1287 SvCUR_set(TARG,1+len);
1288 }
1289 SvUTF8_on(TARG);
1290 }
a0d0e21e
LW
1291 PUSHTARG;
1292 RETURN;
1293}
1294
76e3520e 1295STATIC OP *
cea2e8a9 1296S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
a0d0e21e 1297{
27da23d5 1298 dVAR;
c09156bb 1299 register PERL_CONTEXT *cx;
f54cb97a 1300 const I32 gimme = GIMME_V;
a0d0e21e 1301
7918f24d
NC
1302 PERL_ARGS_ASSERT_DOFORM;
1303
7b190374
NC
1304 if (cv && CvCLONE(cv))
1305 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
1306
a0d0e21e
LW
1307 ENTER;
1308 SAVETMPS;
1309
146174a9 1310 PUSHBLOCK(cx, CXt_FORMAT, PL_stack_sp);
10067d9a 1311 PUSHFORMAT(cx, retop);
fd617465
DM
1312 SAVECOMPPAD();
1313 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1);
a0d0e21e 1314
4633a7c4 1315 setdefout(gv); /* locally select filehandle so $% et al work */
a0d0e21e
LW
1316 return CvSTART(cv);
1317}
1318
1319PP(pp_enterwrite)
1320{
97aff369 1321 dVAR;
39644a26 1322 dSP;
a0d0e21e
LW
1323 register GV *gv;
1324 register IO *io;
1325 GV *fgv;
07822e36
JH
1326 CV *cv = NULL;
1327 SV *tmpsv = NULL;
a0d0e21e 1328
2addaaf3 1329 if (MAXARG == 0) {
3280af22 1330 gv = PL_defoutgv;
2addaaf3
NC
1331 EXTEND(SP, 1);
1332 }
a0d0e21e 1333 else {
159b6efe 1334 gv = MUTABLE_GV(POPs);
a0d0e21e 1335 if (!gv)
3280af22 1336 gv = PL_defoutgv;
a0d0e21e 1337 }
a0d0e21e
LW
1338 io = GvIO(gv);
1339 if (!io) {
1340 RETPUSHNO;
1341 }
1342 if (IoFMT_GV(io))
1343 fgv = IoFMT_GV(io);
1344 else
1345 fgv = gv;
1346
a79db61d
AL
1347 if (!fgv)
1348 goto not_a_format_reference;
1349
a0d0e21e 1350 cv = GvFORM(fgv);
a0d0e21e 1351 if (!cv) {
f4a7049d 1352 const char *name;
10edeb5d 1353 tmpsv = sv_newmortal();
f4a7049d
NC
1354 gv_efullname4(tmpsv, fgv, NULL, FALSE);
1355 name = SvPV_nolen_const(tmpsv);
1356 if (name && *name)
1357 DIE(aTHX_ "Undefined format \"%s\" called", name);
a79db61d
AL
1358
1359 not_a_format_reference:
cea2e8a9 1360 DIE(aTHX_ "Not a format reference");
a0d0e21e 1361 }
44a8e56a 1362 IoFLAGS(io) &= ~IOf_DIDTOP;
533c011a 1363 return doform(cv,gv,PL_op->op_next);
a0d0e21e
LW
1364}
1365
1366PP(pp_leavewrite)
1367{
27da23d5 1368 dVAR; dSP;
f9c764c5 1369 GV * const gv = cxstack[cxstack_ix].blk_format.gv;
1b6737cc 1370 register IO * const io = GvIOp(gv);
8b8cacda 1371 PerlIO *ofp;
760ac839 1372 PerlIO *fp;
8772537c
AL
1373 SV **newsp;
1374 I32 gimme;
c09156bb 1375 register PERL_CONTEXT *cx;
8f89e5a9 1376 OP *retop;
a0d0e21e 1377
8b8cacda 1378 if (!io || !(ofp = IoOFP(io)))
1379 goto forget_top;
1380
760ac839 1381 DEBUG_f(PerlIO_printf(Perl_debug_log, "left=%ld, todo=%ld\n",
3280af22 1382 (long)IoLINES_LEFT(io), (long)FmLINES(PL_formtarget)));
8b8cacda 1383
3280af22
NIS
1384 if (IoLINES_LEFT(io) < FmLINES(PL_formtarget) &&
1385 PL_formtarget != PL_toptarget)
a0d0e21e 1386 {
4633a7c4
LW
1387 GV *fgv;
1388 CV *cv;
a0d0e21e
LW
1389 if (!IoTOP_GV(io)) {
1390 GV *topgv;
a0d0e21e
LW
1391
1392 if (!IoTOP_NAME(io)) {
1b6737cc 1393 SV *topname;
a0d0e21e
LW
1394 if (!IoFMT_NAME(io))
1395 IoFMT_NAME(io) = savepv(GvNAME(gv));
0bd0581c 1396 topname = sv_2mortal(Perl_newSVpvf(aTHX_ "%s_TOP", GvNAME(gv)));
f776e3cd 1397 topgv = gv_fetchsv(topname, 0, SVt_PVFM);
748a9306 1398 if ((topgv && GvFORM(topgv)) ||
fafc274c 1399 !gv_fetchpvs("top", GV_NOTQUAL, SVt_PVFM))
2e0de35c 1400 IoTOP_NAME(io) = savesvpv(topname);
a0d0e21e 1401 else
89529cee 1402 IoTOP_NAME(io) = savepvs("top");
a0d0e21e 1403 }
f776e3cd 1404 topgv = gv_fetchpv(IoTOP_NAME(io), 0, SVt_PVFM);
a0d0e21e 1405 if (!topgv || !GvFORM(topgv)) {
b929a54b 1406 IoLINES_LEFT(io) = IoPAGE_LEN(io);
a0d0e21e
LW
1407 goto forget_top;
1408 }
1409 IoTOP_GV(io) = topgv;
1410 }
748a9306
LW
1411 if (IoFLAGS(io) & IOf_DIDTOP) { /* Oh dear. It still doesn't fit. */
1412 I32 lines = IoLINES_LEFT(io);
504618e9 1413 const char *s = SvPVX_const(PL_formtarget);
8e07c86e
AD
1414 if (lines <= 0) /* Yow, header didn't even fit!!! */
1415 goto forget_top;
748a9306
LW
1416 while (lines-- > 0) {
1417 s = strchr(s, '\n');
1418 if (!s)
1419 break;
1420 s++;
1421 }
1422 if (s) {
f54cb97a 1423 const STRLEN save = SvCUR(PL_formtarget);
aa07b2f6 1424 SvCUR_set(PL_formtarget, s - SvPVX_const(PL_formtarget));
d75029d0
NIS
1425 do_print(PL_formtarget, ofp);
1426 SvCUR_set(PL_formtarget, save);
3280af22
NIS
1427 sv_chop(PL_formtarget, s);
1428 FmLINES(PL_formtarget) -= IoLINES_LEFT(io);
748a9306
LW
1429 }
1430 }
a0d0e21e 1431 if (IoLINES_LEFT(io) >= 0 && IoPAGE(io) > 0)
d75029d0 1432 do_print(PL_formfeed, ofp);
a0d0e21e
LW
1433 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1434 IoPAGE(io)++;
3280af22 1435 PL_formtarget = PL_toptarget;
748a9306 1436 IoFLAGS(io) |= IOf_DIDTOP;
4633a7c4
LW
1437 fgv = IoTOP_GV(io);
1438 if (!fgv)
cea2e8a9 1439 DIE(aTHX_ "bad top format reference");
4633a7c4 1440 cv = GvFORM(fgv);
1df70142
AL
1441 if (!cv) {
1442 SV * const sv = sv_newmortal();
b464bac0 1443 const char *name;
bd61b366 1444 gv_efullname4(sv, fgv, NULL, FALSE);
e62f0680 1445 name = SvPV_nolen_const(sv);
2dd78f96 1446 if (name && *name)
0e528f24
JH
1447 DIE(aTHX_ "Undefined top format \"%s\" called", name);
1448 else
1449 DIE(aTHX_ "Undefined top format called");
4633a7c4 1450 }
0e528f24 1451 return doform(cv, gv, PL_op);
a0d0e21e
LW
1452 }
1453
1454 forget_top:
3280af22 1455 POPBLOCK(cx,PL_curpm);
a0d0e21e 1456 POPFORMAT(cx);
8f89e5a9 1457 retop = cx->blk_sub.retop;
a0d0e21e
LW
1458 LEAVE;
1459
1460 fp = IoOFP(io);
1461 if (!fp) {
7716c5c5
NC
1462 if (IoIFP(io))
1463 report_wrongway_fh(gv, '<');
c521cf7c 1464 else
7716c5c5 1465 report_evil_fh(gv);
3280af22 1466 PUSHs(&PL_sv_no);
a0d0e21e
LW
1467 }
1468 else {
3280af22 1469 if ((IoLINES_LEFT(io) -= FmLINES(PL_formtarget)) < 0) {
a2a5de95 1470 Perl_ck_warner(aTHX_ packWARN(WARN_IO), "page overflow");
a0d0e21e 1471 }
d75029d0 1472 if (!do_print(PL_formtarget, fp))
3280af22 1473 PUSHs(&PL_sv_no);
a0d0e21e 1474 else {
3280af22
NIS
1475 FmLINES(PL_formtarget) = 0;
1476 SvCUR_set(PL_formtarget, 0);
1477 *SvEND(PL_formtarget) = '\0';
a0d0e21e 1478 if (IoFLAGS(io) & IOf_FLUSH)
760ac839 1479 (void)PerlIO_flush(fp);
3280af22 1480 PUSHs(&PL_sv_yes);
a0d0e21e
LW
1481 }
1482 }
9cbac4c7 1483 /* bad_ofp: */
3280af22 1484 PL_formtarget = PL_bodytarget;
a0d0e21e 1485 PUTBACK;
29033a8a
SH
1486 PERL_UNUSED_VAR(newsp);
1487 PERL_UNUSED_VAR(gimme);
8f89e5a9 1488 return retop;
a0d0e21e
LW
1489}
1490
1491PP(pp_prtf)
1492{
27da23d5 1493 dVAR; dSP; dMARK; dORIGMARK;
760ac839 1494 PerlIO *fp;
26db47c4 1495 SV *sv;
a0d0e21e 1496
159b6efe
NC
1497 GV * const gv
1498 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
9c9f25b8 1499 IO *const io = GvIO(gv);
46fc3d4c 1500
9c9f25b8 1501 if (io) {
a5e1d062 1502 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d
AL
1503 if (mg) {
1504 if (MARK == ORIGMARK) {
1505 MEXTEND(SP, 1);
1506 ++MARK;
1507 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
1508 ++SP;
1509 }
d682515d
NC
1510 return Perl_tied_method(aTHX_ "PRINTF", mark - 1, MUTABLE_SV(io),
1511 mg,
1512 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1513 sp - mark);
a79db61d 1514 }
46fc3d4c
PP
1515 }
1516
561b68a9 1517 sv = newSV(0);
9c9f25b8 1518 if (!io) {
51087808 1519 report_evil_fh(gv);
93189314 1520 SETERRNO(EBADF,RMS_IFI);
a0d0e21e
LW
1521 goto just_say_no;
1522 }
1523 else if (!(fp = IoOFP(io))) {
7716c5c5
NC
1524 if (IoIFP(io))
1525 report_wrongway_fh(gv, '<');
1526 else if (ckWARN(WARN_CLOSED))
1527 report_evil_fh(gv);
93189314 1528 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
a0d0e21e
LW
1529 goto just_say_no;
1530 }
1531 else {
20ee07fb
RGS
1532 if (SvTAINTED(MARK[1]))
1533 TAINT_PROPER("printf");
a0d0e21e
LW
1534 do_sprintf(sv, SP - MARK, MARK + 1);
1535 if (!do_print(sv, fp))
1536 goto just_say_no;
1537
1538 if (IoFLAGS(io) & IOf_FLUSH)
760ac839 1539 if (PerlIO_flush(fp) == EOF)
a0d0e21e
LW
1540 goto just_say_no;
1541 }
1542 SvREFCNT_dec(sv);
1543 SP = ORIGMARK;
3280af22 1544 PUSHs(&PL_sv_yes);
a0d0e21e
LW
1545 RETURN;
1546
1547 just_say_no:
1548 SvREFCNT_dec(sv);
1549 SP = ORIGMARK;
3280af22 1550 PUSHs(&PL_sv_undef);
a0d0e21e
LW
1551 RETURN;
1552}
1553
c07a80fd
PP
1554PP(pp_sysopen)
1555{
97aff369 1556 dVAR;
39644a26 1557 dSP;
1df70142
AL
1558 const int perm = (MAXARG > 3) ? POPi : 0666;
1559 const int mode = POPi;
1b6737cc 1560 SV * const sv = POPs;
159b6efe 1561 GV * const gv = MUTABLE_GV(POPs);
1b6737cc 1562 STRLEN len;
c07a80fd 1563
4592e6ca 1564 /* Need TIEHANDLE method ? */
1b6737cc 1565 const char * const tmps = SvPV_const(sv, len);
e62f0680 1566 /* FIXME? do_open should do const */
4608196e 1567 if (do_open(gv, tmps, len, TRUE, mode, perm, NULL)) {
c07a80fd 1568 IoLINES(GvIOp(gv)) = 0;
3280af22 1569 PUSHs(&PL_sv_yes);
c07a80fd
PP
1570 }
1571 else {
3280af22 1572 PUSHs(&PL_sv_undef);
c07a80fd
PP
1573 }
1574 RETURN;
1575}
1576
a0d0e21e
LW
1577PP(pp_sysread)
1578{
27da23d5 1579 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
a0d0e21e 1580 int offset;
a0d0e21e
LW
1581 IO *io;
1582 char *buffer;
5b54f415 1583 SSize_t length;
eb5c063a 1584 SSize_t count;
1e422769 1585 Sock_size_t bufsize;
748a9306 1586 SV *bufsv;
a0d0e21e 1587 STRLEN blen;
eb5c063a 1588 int fp_utf8;
1dd30107
NC
1589 int buffer_utf8;
1590 SV *read_target;
eb5c063a
NIS
1591 Size_t got = 0;
1592 Size_t wanted;
1d636c13 1593 bool charstart = FALSE;
87330c3c
JH
1594 STRLEN charskip = 0;
1595 STRLEN skip = 0;
a0d0e21e 1596
159b6efe 1597 GV * const gv = MUTABLE_GV(*++MARK);
5b468f54 1598 if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD)
1b6737cc 1599 && gv && (io = GvIO(gv)) )
137443ea 1600 {
a5e1d062 1601 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1b6737cc 1602 if (mg) {
d682515d
NC
1603 return Perl_tied_method(aTHX_ "READ", mark - 1, MUTABLE_SV(io), mg,
1604 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1605 sp - mark);
1b6737cc 1606 }
2ae324a7
PP
1607 }
1608
a0d0e21e
LW
1609 if (!gv)
1610 goto say_undef;
748a9306 1611 bufsv = *++MARK;
ff68c719 1612 if (! SvOK(bufsv))
76f68e9b 1613 sv_setpvs(bufsv, "");
a0d0e21e 1614 length = SvIVx(*++MARK);
748a9306 1615 SETERRNO(0,0);
a0d0e21e
LW
1616 if (MARK < SP)
1617 offset = SvIVx(*++MARK);
1618 else
1619 offset = 0;
1620 io = GvIO(gv);
b5fe5ca2 1621 if (!io || !IoIFP(io)) {
51087808 1622 report_evil_fh(gv);
b5fe5ca2 1623 SETERRNO(EBADF,RMS_IFI);
a0d0e21e 1624 goto say_undef;
b5fe5ca2 1625 }
0064a8a9 1626 if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) {
7d59b7e4 1627 buffer = SvPVutf8_force(bufsv, blen);
1e54db1a 1628 /* UTF-8 may not have been set if they are all low bytes */
eb5c063a 1629 SvUTF8_on(bufsv);
9b9d7ce8 1630 buffer_utf8 = 0;
7d59b7e4
NIS
1631 }
1632 else {
1633 buffer = SvPV_force(bufsv, blen);
1dd30107 1634 buffer_utf8 = !IN_BYTES && SvUTF8(bufsv);
7d59b7e4
NIS
1635 }
1636 if (length < 0)
1637 DIE(aTHX_ "Negative length");
eb5c063a 1638 wanted = length;
7d59b7e4 1639
d0965105
JH
1640 charstart = TRUE;
1641 charskip = 0;
87330c3c 1642 skip = 0;
d0965105 1643
a0d0e21e 1644#ifdef HAS_SOCKET
533c011a 1645 if (PL_op->op_type == OP_RECV) {
46fc3d4c 1646 char namebuf[MAXPATHLEN];
17a8c7ba 1647#if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__)
490ab354
JH
1648 bufsize = sizeof (struct sockaddr_in);
1649#else
46fc3d4c 1650 bufsize = sizeof namebuf;
490ab354 1651#endif
abf95952
IZ
1652#ifdef OS2 /* At least Warp3+IAK: only the first byte of bufsize set */
1653 if (bufsize >= 256)
1654 bufsize = 255;
1655#endif
eb160463 1656 buffer = SvGROW(bufsv, (STRLEN)(length+1));
bbce6d69 1657 /* 'offset' means 'flags' here */
eb5c063a 1658 count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, offset,
10edeb5d 1659 (struct sockaddr *)namebuf, &bufsize);
eb5c063a 1660 if (count < 0)
a0d0e21e 1661 RETPUSHUNDEF;
8eb023a9
DM
1662 /* MSG_TRUNC can give oversized count; quietly lose it */
1663 if (count > length)
1664 count = length;
4107cc59
OF
1665#ifdef EPOC
1666 /* Bogus return without padding */
1667 bufsize = sizeof (struct sockaddr_in);
1668#endif
eb5c063a 1669 SvCUR_set(bufsv, count);
748a9306
LW
1670 *SvEND(bufsv) = '\0';
1671 (void)SvPOK_only(bufsv);
eb5c063a
NIS
1672 if (fp_utf8)
1673 SvUTF8_on(bufsv);
748a9306 1674 SvSETMAGIC(bufsv);
aac0dd9a 1675 /* This should not be marked tainted if the fp is marked clean */
bbce6d69
PP
1676 if (!(IoFLAGS(io) & IOf_UNTAINT))
1677 SvTAINTED_on(bufsv);
a0d0e21e 1678 SP = ORIGMARK;
46fc3d4c 1679 sv_setpvn(TARG, namebuf, bufsize);
a0d0e21e
LW
1680 PUSHs(TARG);
1681 RETURN;
1682 }
1683#else
911d147d 1684 if (PL_op->op_type == OP_RECV)
cea2e8a9 1685 DIE(aTHX_ PL_no_sock_func, "recv");
a0d0e21e 1686#endif
eb5c063a
NIS
1687 if (DO_UTF8(bufsv)) {
1688 /* offset adjust in characters not bytes */
1689 blen = sv_len_utf8(bufsv);
7d59b7e4 1690 }
bbce6d69 1691 if (offset < 0) {
eb160463 1692 if (-offset > (int)blen)
cea2e8a9 1693 DIE(aTHX_ "Offset outside string");
bbce6d69
PP
1694 offset += blen;
1695 }
eb5c063a
NIS
1696 if (DO_UTF8(bufsv)) {
1697 /* convert offset-as-chars to offset-as-bytes */
6960c29a
CH
1698 if (offset >= (int)blen)
1699 offset += SvCUR(bufsv) - blen;
1700 else
1701 offset = utf8_hop((U8 *)buffer,offset) - (U8 *) buffer;
eb5c063a
NIS
1702 }
1703 more_bytes:
cd52b7b2 1704 bufsize = SvCUR(bufsv);
1dd30107
NC
1705 /* Allocating length + offset + 1 isn't perfect in the case of reading
1706 bytes from a byte file handle into a UTF8 buffer, but it won't harm us
1707 unduly.
1708 (should be 2 * length + offset + 1, or possibly something longer if
1709 PL_encoding is true) */
eb160463 1710 buffer = SvGROW(bufsv, (STRLEN)(length+offset+1));
27da23d5 1711 if (offset > 0 && (Sock_size_t)offset > bufsize) { /* Zero any newly allocated space */
cd52b7b2
PP
1712 Zero(buffer+bufsize, offset-bufsize, char);
1713 }
eb5c063a 1714 buffer = buffer + offset;
1dd30107
NC
1715 if (!buffer_utf8) {
1716 read_target = bufsv;
1717 } else {
1718 /* Best to read the bytes into a new SV, upgrade that to UTF8, then
1719 concatenate it to the current buffer. */
1720
1721 /* Truncate the existing buffer to the start of where we will be
1722 reading to: */
1723 SvCUR_set(bufsv, offset);
1724
1725 read_target = sv_newmortal();
862a34c6 1726 SvUPGRADE(read_target, SVt_PV);
fe2774ed 1727 buffer = SvGROW(read_target, (STRLEN)(length + 1));
1dd30107 1728 }
eb5c063a 1729
533c011a 1730 if (PL_op->op_type == OP_SYSREAD) {
a7092146 1731#ifdef PERL_SOCK_SYSREAD_IS_RECV
50952442 1732 if (IoTYPE(io) == IoTYPE_SOCKET) {
eb5c063a
NIS
1733 count = PerlSock_recv(PerlIO_fileno(IoIFP(io)),
1734 buffer, length, 0);
a7092146
GS
1735 }
1736 else
1737#endif
1738 {
eb5c063a
NIS
1739 count = PerlLIO_read(PerlIO_fileno(IoIFP(io)),
1740 buffer, length);
a7092146 1741 }
a0d0e21e
LW
1742 }
1743 else
1744#ifdef HAS_SOCKET__bad_code_maybe
50952442 1745 if (IoTYPE(io) == IoTYPE_SOCKET) {
46fc3d4c 1746 char namebuf[MAXPATHLEN];
490ab354
JH
1747#if defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)
1748 bufsize = sizeof (struct sockaddr_in);
1749#else
46fc3d4c 1750 bufsize = sizeof namebuf;
490ab354 1751#endif
eb5c063a 1752 count = PerlSock_recvfrom(PerlIO_fileno(IoIFP(io)), buffer, length, 0,
46fc3d4c 1753 (struct sockaddr *)namebuf, &bufsize);
a0d0e21e
LW
1754 }
1755 else
1756#endif
3b02c43c 1757 {
eb5c063a
NIS
1758 count = PerlIO_read(IoIFP(io), buffer, length);
1759 /* PerlIO_read() - like fread() returns 0 on both error and EOF */
1760 if (count == 0 && PerlIO_error(IoIFP(io)))
1761 count = -1;
3b02c43c 1762 }
eb5c063a 1763 if (count < 0) {
7716c5c5 1764 if (IoTYPE(io) == IoTYPE_WRONLY)
a5390457 1765 report_wrongway_fh(gv, '>');
a0d0e21e 1766 goto say_undef;
af8c498a 1767 }
aa07b2f6 1768 SvCUR_set(read_target, count+(buffer - SvPVX_const(read_target)));
1dd30107
NC
1769 *SvEND(read_target) = '\0';
1770 (void)SvPOK_only(read_target);
0064a8a9 1771 if (fp_utf8 && !IN_BYTES) {
eb5c063a 1772 /* Look at utf8 we got back and count the characters */
1df70142 1773 const char *bend = buffer + count;
eb5c063a 1774 while (buffer < bend) {
d0965105
JH
1775 if (charstart) {
1776 skip = UTF8SKIP(buffer);
1777 charskip = 0;
1778 }
1779 if (buffer - charskip + skip > bend) {
eb5c063a
NIS
1780 /* partial character - try for rest of it */
1781 length = skip - (bend-buffer);
aa07b2f6 1782 offset = bend - SvPVX_const(bufsv);
d0965105
JH
1783 charstart = FALSE;
1784 charskip += count;
eb5c063a
NIS
1785 goto more_bytes;
1786 }
1787 else {
1788 got++;
1789 buffer += skip;
d0965105
JH
1790 charstart = TRUE;
1791 charskip = 0;
eb5c063a
NIS
1792 }
1793 }
1794 /* If we have not 'got' the number of _characters_ we 'wanted' get some more
1795 provided amount read (count) was what was requested (length)
1796 */
1797 if (got < wanted && count == length) {
d0965105 1798 length = wanted - got;
aa07b2f6 1799 offset = bend - SvPVX_const(bufsv);
eb5c063a
NIS
1800 goto more_bytes;
1801 }
1802 /* return value is character count */
1803 count = got;
1804 SvUTF8_on(bufsv);
1805 }
1dd30107
NC
1806 else if (buffer_utf8) {
1807 /* Let svcatsv upgrade the bytes we read in to utf8.
1808 The buffer is a mortal so will be freed soon. */
1809 sv_catsv_nomg(bufsv, read_target);
1810 }
748a9306 1811 SvSETMAGIC(bufsv);
aac0dd9a 1812 /* This should not be marked tainted if the fp is marked clean */
bbce6d69
PP
1813 if (!(IoFLAGS(io) & IOf_UNTAINT))
1814 SvTAINTED_on(bufsv);
a0d0e21e 1815 SP = ORIGMARK;
eb5c063a 1816 PUSHi(count);
a0d0e21e
LW
1817 RETURN;
1818
1819 say_undef:
1820 SP = ORIGMARK;
1821 RETPUSHUNDEF;
1822}
1823
a0d0e21e
LW
1824PP(pp_send)
1825{
27da23d5 1826 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
748a9306 1827 SV *bufsv;
83003860 1828 const char *buffer;
8c99d73e 1829 SSize_t retval;
a0d0e21e 1830 STRLEN blen;
c9cb0f41 1831 STRLEN orig_blen_bytes;
64a1bc8e 1832 const int op_type = PL_op->op_type;
c9cb0f41
NC
1833 bool doing_utf8;
1834 U8 *tmpbuf = NULL;
159b6efe 1835 GV *const gv = MUTABLE_GV(*++MARK);
91472ad4
NC
1836 IO *const io = GvIO(gv);
1837
1838 if (op_type == OP_SYSWRITE && io) {
a5e1d062 1839 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 1840 if (mg) {
a79db61d 1841 if (MARK == SP - 1) {
c8834ab7
TC
1842 SV *sv = *SP;
1843 mXPUSHi(sv_len(sv));
a79db61d
AL
1844 PUTBACK;
1845 }
1846
d682515d
NC
1847 return Perl_tied_method(aTHX_ "WRITE", mark - 1, MUTABLE_SV(io), mg,
1848 G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK,
1849 sp - mark);
64a1bc8e 1850 }
1d603a67 1851 }
a0d0e21e
LW
1852 if (!gv)
1853 goto say_undef;
64a1bc8e 1854
748a9306 1855 bufsv = *++MARK;
64a1bc8e 1856
748a9306 1857 SETERRNO(0,0);
cf167416 1858 if (!io || !IoIFP(io) || IoTYPE(io) == IoTYPE_RDONLY) {
8c99d73e 1859 retval = -1;
51087808
NC
1860 if (io && IoIFP(io))
1861 report_wrongway_fh(gv, '<');
1862 else
1863 report_evil_fh(gv);
b5fe5ca2 1864 SETERRNO(EBADF,RMS_IFI);
7d59b7e4
NIS
1865 goto say_undef;
1866 }
1867
c9cb0f41
NC
1868 /* Do this first to trigger any overloading. */
1869 buffer = SvPV_const(bufsv, blen);
1870 orig_blen_bytes = blen;
1871 doing_utf8 = DO_UTF8(bufsv);
1872
7d59b7e4 1873 if (PerlIO_isutf8(IoIFP(io))) {
6aa2f6a7 1874 if (!SvUTF8(bufsv)) {
c9cb0f41
NC
1875 /* We don't modify the original scalar. */
1876 tmpbuf = bytes_to_utf8((const U8*) buffer, &blen);
1877 buffer = (char *) tmpbuf;
1878 doing_utf8 = TRUE;
1879 }
a0d0e21e 1880 }
c9cb0f41
NC
1881 else if (doing_utf8) {
1882 STRLEN tmplen = blen;
a79db61d 1883 U8 * const result = bytes_from_utf8((const U8*) buffer, &tmplen, &doing_utf8);
c9cb0f41
NC
1884 if (!doing_utf8) {
1885 tmpbuf = result;
1886 buffer = (char *) tmpbuf;
1887 blen = tmplen;
1888 }
1889 else {
1890 assert((char *)result == buffer);
1891 Perl_croak(aTHX_ "Wide character in %s", OP_DESC(PL_op));
1892 }
7d59b7e4
NIS
1893 }
1894
e2712234
NC
1895 if (op_type == OP_SEND) {
1896#ifdef HAS_SOCKET
1897 const int flags = SvIVx(*++MARK);
1898 if (SP > MARK) {
1899 STRLEN mlen;
1900 char * const sockbuf = SvPVx(*++MARK, mlen);
1901 retval = PerlSock_sendto(PerlIO_fileno(IoIFP(io)), buffer, blen,
1902 flags, (struct sockaddr *)sockbuf, mlen);
1903 }
1904 else {
1905 retval
1906 = PerlSock_send(PerlIO_fileno(IoIFP(io)), buffer, blen, flags);
1907 }
1908#else
1909 DIE(aTHX_ PL_no_sock_func, "send");
1910#endif
1911 } else {
c9cb0f41
NC
1912 Size_t length = 0; /* This length is in characters. */
1913 STRLEN blen_chars;
7d59b7e4 1914 IV offset;
c9cb0f41
NC
1915
1916 if (doing_utf8) {
1917 if (tmpbuf) {
1918 /* The SV is bytes, and we've had to upgrade it. */
1919 blen_chars = orig_blen_bytes;
1920 } else {
1921 /* The SV really is UTF-8. */
1922 if (SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
1923 /* Don't call sv_len_utf8 again because it will call magic
1924 or overloading a second time, and we might get back a
1925 different result. */
9a206dfd 1926 blen_chars = utf8_length((U8*)buffer, (U8*)buffer + blen);
c9cb0f41
NC
1927 } else {
1928 /* It's safe, and it may well be cached. */
1929 blen_chars = sv_len_utf8(bufsv);
1930 }
1931 }
1932 } else {
1933 blen_chars = blen;
1934 }
1935
1936 if (MARK >= SP) {
1937 length = blen_chars;
1938 } else {
1939#if Size_t_size > IVSIZE
1940 length = (Size_t)SvNVx(*++MARK);
1941#else
1942 length = (Size_t)SvIVx(*++MARK);
1943#endif
4b0c4b6f
NC
1944 if ((SSize_t)length < 0) {
1945 Safefree(tmpbuf);
c9cb0f41 1946 DIE(aTHX_ "Negative length");
4b0c4b6f 1947 }
7d59b7e4 1948 }
c9cb0f41 1949
bbce6d69 1950 if (MARK < SP) {
a0d0e21e 1951 offset = SvIVx(*++MARK);
bbce6d69 1952 if (offset < 0) {
4b0c4b6f
NC
1953 if (-offset > (IV)blen_chars) {
1954 Safefree(tmpbuf);
cea2e8a9 1955 DIE(aTHX_ "Offset outside string");
4b0c4b6f 1956 }
c9cb0f41 1957 offset += blen_chars;
3c946528 1958 } else if (offset > (IV)blen_chars) {
4b0c4b6f 1959 Safefree(tmpbuf);
cea2e8a9 1960 DIE(aTHX_ "Offset outside string");
4b0c4b6f 1961 }
bbce6d69 1962 } else
a0d0e21e 1963 offset = 0;
c9cb0f41
NC
1964 if (length > blen_chars - offset)
1965 length = blen_chars - offset;
1966 if (doing_utf8) {
1967 /* Here we convert length from characters to bytes. */
1968 if (tmpbuf || SvGMAGICAL(bufsv) || SvAMAGIC(bufsv)) {
1969 /* Either we had to convert the SV, or the SV is magical, or
1970 the SV has overloading, in which case we can't or mustn't
1971 or mustn't call it again. */
1972
1973 buffer = (const char*)utf8_hop((const U8 *)buffer, offset);
1974 length = utf8_hop((U8 *)buffer, length) - (U8 *)buffer;
1975 } else {
1976 /* It's a real UTF-8 SV, and it's not going to change under
1977 us. Take advantage of any cache. */
1978 I32 start = offset;
1979 I32 len_I32 = length;
1980
1981 /* Convert the start and end character positions to bytes.
1982 Remember that the second argument to sv_pos_u2b is relative
1983 to the first. */
1984 sv_pos_u2b(bufsv, &start, &len_I32);
1985
1986 buffer += start;
1987 length = len_I32;
1988 }
7d59b7e4
NIS
1989 }
1990 else {
1991 buffer = buffer+offset;
1992 }
a7092146 1993#ifdef PERL_SOCK_SYSWRITE_IS_SEND
50952442 1994 if (IoTYPE(io) == IoTYPE_SOCKET) {
8c99d73e 1995 retval = PerlSock_send(PerlIO_fileno(IoIFP(io)),
7d59b7e4 1996 buffer, length, 0);
a7092146
GS
1997 }
1998 else
1999#endif
2000 {
94e4c244 2001 /* See the note at doio.c:do_print about filesize limits. --jhi */
8c99d73e 2002 retval = PerlLIO_write(PerlIO_fileno(IoIFP(io)),
7d59b7e4 2003 buffer, length);
a7092146 2004 }
a0d0e21e 2005 }
c9cb0f41 2006
8c99d73e 2007 if (retval < 0)
a0d0e21e
LW
2008 goto say_undef;
2009 SP = ORIGMARK;
c9cb0f41 2010 if (doing_utf8)
f36eea10 2011 retval = utf8_length((U8*)buffer, (U8*)buffer + retval);
4b0c4b6f 2012
a79db61d 2013 Safefree(tmpbuf);
8c99d73e
GS
2014#if Size_t_size > IVSIZE
2015 PUSHn(retval);
2016#else
2017 PUSHi(retval);
2018#endif
a0d0e21e
LW
2019 RETURN;
2020
2021 say_undef:
a79db61d 2022 Safefree(tmpbuf);
a0d0e21e
LW
2023 SP = ORIGMARK;
2024 RETPUSHUNDEF;
2025}
2026
a0d0e21e
LW
2027PP(pp_eof)
2028{
27da23d5 2029 dVAR; dSP;
a0d0e21e 2030 GV *gv;
32e65323 2031 IO *io;
a5e1d062 2032 const MAGIC *mg;
bc0c81ca
NC
2033 /*
2034 * in Perl 5.12 and later, the additional parameter is a bitmask:
2035 * 0 = eof
2036 * 1 = eof(FH)
2037 * 2 = eof() <- ARGV magic
2038 *
2039 * I'll rely on the compiler's trace flow analysis to decide whether to
2040 * actually assign this out here, or punt it into the only block where it is
2041 * used. Doing it out here is DRY on the condition logic.
2042 */
2043 unsigned int which;
a0d0e21e 2044
bc0c81ca 2045 if (MAXARG) {
32e65323 2046 gv = PL_last_in_gv = MUTABLE_GV(POPs); /* eof(FH) */
bc0c81ca
NC
2047 which = 1;
2048 }
b5f55170
NC
2049 else {
2050 EXTEND(SP, 1);
2051
bc0c81ca 2052 if (PL_op->op_flags & OPf_SPECIAL) {
b5f55170 2053 gv = PL_last_in_gv = GvEGVx(PL_argvgv); /* eof() - ARGV magic */
bc0c81ca
NC
2054 which = 2;
2055 }
2056 else {
b5f55170 2057 gv = PL_last_in_gv; /* eof */
bc0c81ca
NC
2058 which = 0;
2059 }
b5f55170 2060 }
32e65323
CS
2061
2062 if (!gv)
2063 RETPUSHNO;
2064
2065 if ((io = GvIO(gv)) && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar))) {
d682515d 2066 return tied_method1("EOF", SP, MUTABLE_SV(io), mg, newSVuv(which));
146174a9 2067 }
4592e6ca 2068
32e65323
CS
2069 if (!MAXARG && (PL_op->op_flags & OPf_SPECIAL)) { /* eof() */
2070 if (io && !IoIFP(io)) {
2071 if ((IoFLAGS(io) & IOf_START) && av_len(GvAVn(gv)) < 0) {
2072 IoLINES(io) = 0;
2073 IoFLAGS(io) &= ~IOf_START;
2074 do_open(gv, "-", 1, FALSE, O_RDONLY, 0, NULL);
2075 if (GvSV(gv))
2076 sv_setpvs(GvSV(gv), "-");
2077 else
2078 GvSV(gv) = newSVpvs("-");
2079 SvSETMAGIC(GvSV(gv));
2080 }
2081 else if (!nextargv(gv))
2082 RETPUSHYES;
6136c704 2083 }
4592e6ca
NIS
2084 }
2085
32e65323 2086 PUSHs(boolSV(do_eof(gv)));
a0d0e21e
LW
2087 RETURN;
2088}
2089
2090PP(pp_tell)
2091{
27da23d5 2092 dVAR; dSP; dTARGET;
301e8125 2093 GV *gv;
5b468f54 2094 IO *io;
a0d0e21e 2095
c4420975 2096 if (MAXARG != 0)
159b6efe 2097 PL_last_in_gv = MUTABLE_GV(POPs);
ac3697cd
NC
2098 else
2099 EXTEND(SP, 1);
c4420975 2100 gv = PL_last_in_gv;
4592e6ca 2101
9c9f25b8
NC
2102 io = GvIO(gv);
2103 if (io) {
a5e1d062 2104 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 2105 if (mg) {
d682515d 2106 return tied_method0("TELL", SP, MUTABLE_SV(io), mg);
a79db61d 2107 }
4592e6ca 2108 }
f4817f32 2109 else if (!gv) {
f03173f2
RGS
2110 if (!errno)
2111 SETERRNO(EBADF,RMS_IFI);
2112 PUSHi(-1);
2113 RETURN;
2114 }
4592e6ca 2115
146174a9
CB
2116#if LSEEKSIZE > IVSIZE
2117 PUSHn( do_tell(gv) );
2118#else
a0d0e21e 2119 PUSHi( do_tell(gv) );
146174a9 2120#endif
a0d0e21e
LW
2121 RETURN;
2122}
2123
137443ea
PP
2124PP(pp_sysseek)
2125{
27da23d5 2126 dVAR; dSP;
1df70142 2127 const int whence = POPi;
146174a9 2128#if LSEEKSIZE > IVSIZE
7452cf6a 2129 const Off_t offset = (Off_t)SvNVx(POPs);
146174a9 2130#else
7452cf6a 2131 const Off_t offset = (Off_t)SvIVx(POPs);
146174a9 2132#endif
a0d0e21e 2133
159b6efe 2134 GV * const gv = PL_last_in_gv = MUTABLE_GV(POPs);
9c9f25b8 2135 IO *const io = GvIO(gv);
4592e6ca 2136
9c9f25b8 2137 if (io) {
a5e1d062 2138 const MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
a79db61d 2139 if (mg) {
cb50131a 2140#if LSEEKSIZE > IVSIZE
74f0b550 2141 SV *const offset_sv = newSVnv((NV) offset);
cb50131a 2142#else
74f0b550 2143 SV *const offset_sv = newSViv(offset);
cb50131a 2144#endif
bc0c81ca 2145
d682515d
NC
2146 return tied_method2("SEEK", SP, MUTABLE_SV(io), mg, offset_sv,
2147 newSViv(whence));
a79db61d 2148 }
4592e6ca
NIS
2149 }
2150
533c011a 2151 if (PL_op->op_type == OP_SEEK)
8903cb82
PP
2152 PUSHs(boolSV(do_seek(gv, offset, whence)));
2153 else {
0bcc34c2 2154 const Off_t sought = do_sysseek(gv, offset, whence);
b448e4fe 2155 if (sought < 0)
146174a9
CB
2156 PUSHs(&PL_sv_undef);
2157 else {
7452cf6a 2158 SV* const sv = sought ?
146174a9 2159#if LSEEKSIZE > IVSIZE
b448e4fe 2160 newSVnv((NV)sought)
146174a9 2161#else
b448e4fe 2162 newSViv(sought)
146174a9
CB
2163#endif
2164 : newSVpvn(zero_but_true, ZBTLEN);
6e449a3a 2165 mPUSHs(sv);
146174a9 2166 }
8903cb82 2167 }
a0d0e21e
LW
2168 RETURN;
2169}
2170
2171PP(pp_truncate)
2172{
97aff369 2173 dVAR;
39644a26 2174 dSP;
8c99d73e
GS
2175 /* There seems to be no consensus on the length type of truncate()
2176 * and ftruncate(), both off_t and size_t have supporters. In
2177 * general one would think that when using large files, off_t is
2178 * at least as wide as size_t, so using an off_t should be okay. */
2179 /* XXX Configure probe for the length type of *truncate() needed XXX */
0bcc34c2 2180 Off_t len;
a0d0e21e 2181
25342a55 2182#if Off_t_size > IVSIZE
0bcc34c2 2183 len = (Off_t)POPn;
8c99d73e 2184#else
0bcc34c2 2185 len = (Off_t)POPi;
8c99d73e
GS
2186#endif
2187 /* Checking for length < 0 is problematic as the type might or
301e8125 2188 * might not be signed: if it is not, clever compilers will moan. */
8c99d73e 2189 /* XXX Configure probe for the signedness of the length type of *truncate() needed? XXX */
748a9306 2190 SETERRNO(0,0);
d05c1ba0 2191 {
d05c1ba0
JH
2192 int result = 1;
2193 GV *tmpgv;
090bf15b
SR
2194 IO *io;
2195
d05c1ba0 2196 if (PL_op->op_flags & OPf_SPECIAL) {
f776e3cd 2197 tmpgv = gv_fetchsv(POPs, 0, SVt_PVIO);
d05c1ba0 2198
090bf15b 2199 do_ftruncate_gv:
9c9f25b8
NC
2200 io = GvIO(tmpgv);
2201 if (!io)
090bf15b 2202 result = 0;
d05c1ba0 2203 else {
090bf15b 2204 PerlIO *fp;
090bf15b
SR
2205 do_ftruncate_io:
2206 TAINT_PROPER("truncate");
2207 if (!(fp = IoIFP(io))) {
2208 result = 0;
2209 }
2210 else {
2211 PerlIO_flush(fp);
cbdc8872 2212#ifdef HAS_TRUNCATE
090bf15b 2213 if (ftruncate(PerlIO_fileno(fp), len) < 0)
301e8125 2214#else
090bf15b 2215 if (my_chsize(PerlIO_fileno(fp), len) < 0)
cbdc8872 2216#endif
090bf15b
SR
2217 result = 0;
2218 }
d05c1ba0 2219 }
cbdc8872 2220 }
d05c1ba0 2221 else {
7452cf6a 2222 SV * const sv = POPs;
83003860 2223 const char *name;
7a5fd60d 2224
6e592b3a 2225 if (isGV_with_GP(sv)) {
159b6efe 2226 tmpgv = MUTABLE_GV(sv); /* *main::FRED for example */
090bf15b 2227 goto do_ftruncate_gv;
d05c1ba0 2228 }
6e592b3a 2229 else if (SvROK(sv) && isGV_with_GP(SvRV(sv))) {
159b6efe 2230 tmpgv = MUTABLE_GV(SvRV(sv)); /* \*main::FRED for example */
090bf15b
SR
2231 goto do_ftruncate_gv;
2232 }
2233 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
a45c7426 2234 io = MUTABLE_IO(SvRV(sv)); /* *main::FRED{IO} for example */
090bf15b 2235 goto do_ftruncate_io;
d05c1ba0 2236 }
1e422769 2237
83003860 2238 name = SvPV_nolen_const(sv);
d05c1ba0 2239 TAINT_PROPER("truncate");
cbdc8872 2240#ifdef HAS_TRUNCATE
d05c1ba0
JH
2241 if (truncate(name, len) < 0)
2242 result = 0;
cbdc8872 2243#else
d05c1ba0 2244 {
7452cf6a 2245 const int tmpfd = PerlLIO_open(name, O_RDWR);
d05c1ba0 2246
7452cf6a 2247 if (tmpfd < 0)
cbdc8872 2248 result = 0;
d05c1ba0
JH
2249 else {
2250 if (my_chsize(tmpfd, len) < 0)
2251 result = 0;
2252 PerlLIO_close(tmpfd);
2253 }
cbdc8872 2254 }
a0d0e21e 2255#endif
d05c1ba0 2256 }
a0d0e21e 2257
d05c1ba0
JH
2258 if (result)
2259 RETPUSHYES;
2260 if (!errno)
93189314 2261 SETERRNO(EBADF,RMS_IFI);
d05c1ba0
JH
2262 RETPUSHUNDEF;
2263 }
a0d0e21e
LW
2264}
2265
a0d0e21e
LW
2266PP(pp_ioctl)
2267{
97aff369 2268 dVAR; dSP; dTARGET;
7452cf6a 2269 SV * const argsv = POPs;
1df70142 2270 const unsigned int func = POPu;
e1ec3a88 2271 const int optype = PL_op->op_type;
159b6efe 2272 GV * const gv = MUTABLE_GV(POPs);
4608196e 2273 IO * const io = gv ? GvIOn(gv) : NULL;
a0d0e21e 2274 char *s;
324aa91a 2275 IV retval;
a0d0e21e 2276
748a9306 2277 if (!io || !argsv || !IoIFP(io)) {
51087808 2278 report_evil_fh(gv);
93189314 2279 SETERRNO(EBADF,RMS_IFI); /* well, sort of... */
a0d0e21e
LW
2280 RETPUSHUNDEF;
2281 }
2282
748a9306 2283 if (SvPOK(argsv) || !SvNIOK(argsv)) {
a0d0e21e 2284 STRLEN len;
324aa91a 2285 STRLEN need;
748a9306 2286 s = SvPV_force(argsv, len);
324aa91a
HF
2287 need = IOCPARM_LEN(func);
2288 if (len < need) {
2289 s = Sv_Grow(argsv, need + 1);
2290 SvCUR_set(argsv, need);
a0d0e21e
LW
2291 }
2292
748a9306 2293 s[SvCUR(argsv)] = 17; /* a little sanity check here */
a0d0e21e
LW
2294 }
2295 else {
748a9306 2296 retval = SvIV(argsv);
c529f79d 2297 s = INT2PTR(char*,retval); /* ouch */
a0d0e21e
LW
2298 }
2299
ed4b2e6b 2300 TAINT_PROPER(PL_op_desc[optype]);
a0d0e21e
LW
2301
2302 if (optype == OP_IOCTL)
2303#ifdef HAS_IOCTL
76e3520e 2304 retval = PerlLIO_ioctl(PerlIO_fileno(IoIFP(io)), func, s);
a0d0e21e 2305#else
cea2e8a9 2306 DIE(aTHX_ "ioctl is not implemented");
a0d0e21e
LW
2307#endif
2308 else
c214f4ad
B
2309#ifndef HAS_FCNTL
2310 DIE(aTHX_ "fcntl is not implemented");
2311#else
55497cff 2312#if defined(OS2) && defined(__EMX__)
760ac839 2313 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, (int)s);
55497cff 2314#else
760ac839 2315 retval = fcntl(PerlIO_fileno(IoIFP(io)), func, s);
301e8125 2316#endif
6652bd42 2317#endif
a0d0e21e 2318
6652bd42 2319#if defined(HAS_IOCTL) || defined(HAS_FCNTL)
748a9306
LW
2320 if (SvPOK(argsv)) {
2321 if (s[SvCUR(argsv)] != 17)
cea2e8a9 2322 DIE(aTHX_ "Possible memory corruption: %s overflowed 3rd argument",
53e06cf0 2323 OP_NAME(PL_op));
748a9306
LW
2324 s[SvCUR(argsv)] = 0; /* put our null back */
2325 SvSETMAGIC(argsv); /* Assume it has changed */
a0d0e21e
LW
2326 }
2327
2328 if (retval == -1)
2329 RETPUSHUNDEF;
2330 if (retval != 0) {
2331 PUSHi(retval);
2332 }
2333 else {
8903cb82 2334 PUSHp(zero_but_true, ZBTLEN);
a0d0e21e 2335 }
4808266b 2336#endif
c214f4ad 2337 RETURN;
a0d0e21e
LW
2338}
2339
2340PP(pp_flock)
2341{
9cad6237 2342#ifdef FLOCK
97aff369 2343 dVAR; dSP; dTARGET;
a0d0e21e 2344 I32 value;
7452cf6a 2345 const int argtype = POPi;
159b6efe 2346 GV * const gv = (MAXARG == 0) ? PL_last_in_gv : MUTABLE_GV(POPs);
9c9f25b8
NC
2347 IO *const io = GvIO(gv);
2348 PerlIO *const fp = io ? IoIFP(io) : NULL;
16d20bd9 2349
0bcc34c2 2350 /* XXX Looks to me like io is always NULL at this point */
a0d0e21e 2351 if (fp) {
68dc0745 2352 (void)PerlIO_flush(fp);
76e3520e 2353 value = (I32)(PerlLIO_flock(PerlIO_fileno(fp), argtype) >= 0);
a0d0e21e 2354 }
cb50131a 2355 else {
51087808 2356 report_evil_fh(gv);
a0d0e21e 2357 value = 0;
93189314 2358 SETERRNO(EBADF,RMS_IFI);
cb50131a 2359 }
a0d0e21e
LW
2360 PUSHi(value);
2361 RETURN;
2362#else
cea2e8a9 2363 DIE(aTHX_ PL_no_func, "flock()");
a0d0e21e
LW
2364#endif
2365}
2366
2367/* Sockets. */
2368
2369PP(pp_socket)
2370{
a0d0e21e 2371#ifdef HAS_SOCKET
97aff369 2372 dVAR; dSP;
7452cf6a
AL
2373 const int protocol = POPi;
2374 const int type = POPi;
2375 const int domain = POPi;
159b6efe 2376 GV * const gv = MUTABLE_GV(POPs);
7452cf6a 2377 register IO * const io = gv ? GvIOn(gv) : NULL;
a0d0e21e
LW
2378 int fd;
2379
9c9f25b8 2380 if (!io) {
51087808 2381 report_evil_fh(gv);
5ee74a84 2382 if (io && IoIFP(io))
c289d2f7 2383 do_close(gv, FALSE);
93189314 2384 SETERRNO(EBADF,LIB_INVARG);
a0d0e21e
LW
2385 RETPUSHUNDEF;
2386 }
2387
57171420
BS
2388 if (IoIFP(io))
2389 do_close(gv, FALSE);
2390
a0d0e21e 2391 TAINT_PROPER("socket");
6ad3d225 2392 fd = PerlSock_socket(domain, type, protocol);
a0d0e21e
LW
2393 if (fd < 0)
2394 RETPUSHUNDEF;
460c8493
IZ
2395 IoIFP(io) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE); /* stdio gets confused about sockets */
2396 IoOFP(io) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
50952442 2397 IoTYPE(io) = IoTYPE_SOCKET;
a0d0e21e 2398 if (!IoIFP(io) || !IoOFP(io)) {
760ac839
LW
2399 if (IoIFP(io)) PerlIO_close(IoIFP(io));
2400 if (IoOFP(io)) PerlIO_close(IoOFP(io));
6ad3d225 2401 if (!IoIFP(io) && !IoOFP(io)) PerlLIO_close(fd);
a0d0e21e
LW
2402 RETPUSHUNDEF;
2403 }
8d2a6795
GS
2404#if defined(HAS_FCNTL) && defined(F_SETFD)
2405 fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */
2406#endif
a0d0e21e 2407
d5ff79b3
OF
2408#ifdef EPOC
2409 setbuf( IoIFP(io), NULL); /* EPOC gets confused about sockets */
2410#endif
2411
a0d0e21e
LW
2412 RETPUSHYES;
2413#else
cea2e8a9 2414 DIE(aTHX_ PL_no_sock_func, "socket");
a0d0e21e
LW
2415#endif
2416}
2417
2418PP(pp_sockpair)
2419{
c95c94b1 2420#if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET))
97aff369 2421 dVAR; dSP;
7452cf6a
AL
2422 const int protocol = POPi;
2423 const int type = POPi;
2424 const int domain = POPi;
159b6efe
NC
2425 GV * const gv2 = MUTABLE_GV(POPs);
2426 GV * const gv1 = MUTABLE_GV(POPs);
7452cf6a
AL
2427 register IO * const io1 = gv1 ? GvIOn(gv1) : NULL;
2428 register IO * const io2 = gv2 ? GvIOn(gv2) : NULL;
a0d0e21e
LW
2429 int fd[2];
2430
9c9f25b8
NC
2431 if (!io1)
2432 report_evil_fh(gv1);
2433 if (!io2)
2434 report_evil_fh(gv2);
a0d0e21e 2435
46d2cc54 2436 if (io1 && IoIFP(io1))
dc0d0a5f 2437 do_close(gv1, FALSE);
46d2cc54 2438 if (io2 && IoIFP(io2))
dc0d0a5f 2439 do_close(gv2, FALSE);
57171420 2440
46d2cc54
NC
2441 if (!io1 || !io2)
2442 RETPUSHUNDEF;
2443
a0d0e21e 2444 TAINT_PROPER("socketpair");
6ad3d225 2445 if (PerlSock_socketpair(domain, type, protocol, fd) < 0)
a0d0e21e 2446 RETPUSHUNDEF;
460c8493
IZ
2447 IoIFP(io1) = PerlIO_fdopen(fd[0], "r"SOCKET_OPEN_MODE);
2448 IoOFP(io1) = PerlIO_fdopen(fd[0], "w"SOCKET_OPEN_MODE);
50952442 2449 IoTYPE(io1) = IoTYPE_SOCKET;
460c8493
IZ
2450 IoIFP(io2) = PerlIO_fdopen(fd[1], "r"SOCKET_OPEN_MODE);
2451 IoOFP(io2) = PerlIO_fdopen(fd[1], "w"SOCKET_OPEN_MODE);
50952442 2452 IoTYPE(io2) = IoTYPE_SOCKET;
a0d0e21e 2453 if (!IoIFP(io1) || !IoOFP(io1) || !IoIFP(io2) || !IoOFP(io2)) {
760ac839
LW
2454 if (IoIFP(io1)) PerlIO_close(IoIFP(io1));
2455 if (IoOFP(io1)) PerlIO_close(IoOFP(io1));
6ad3d225 2456 if (!IoIFP(io1) && !IoOFP(io1)) PerlLIO_close(fd[0]);
760ac839
LW
2457 if (IoIFP(io2)) PerlIO_close(IoIFP(io2));
2458 if (IoOFP(io2)) PerlIO_close(IoOFP(io2));
6ad3d225 2459 if (!IoIFP(io2) && !IoOFP(io2)) PerlLIO_close(fd[1]);
a0d0e21e
LW
2460 RETPUSHUNDEF;
2461 }
8d2a6795
GS
2462#if defined(HAS_FCNTL) && defined(F_SETFD)
2463 fcntl(fd[0],F_SETFD,fd[0] > PL_maxsysfd); /* ensure close-on-exec */
2464 fcntl(fd[1],F_SETFD,fd[1] > PL_maxsysfd); /* ensure close-on-exec */
2465#endif
a0d0e21e
LW
2466
2467 RETPUSHYES;
2468#else
cea2e8a9 2469 DIE(aTHX_ PL_no_sock_func, "socketpair");
a0d0e21e
LW
2470#endif
2471}
2472
2473PP(pp_bind)
2474{
a0d0e21e 2475#ifdef HAS_SOCKET
97aff369 2476 dVAR; dSP;
7452cf6a 2477 SV * const addrsv = POPs;
349d4f2f
NC
2478 /* OK, so on what platform does bind modify addr? */
2479 const char *addr;
159b6efe 2480 GV * const gv = MUTABLE_GV(POPs);
7452cf6a 2481 register IO * const io = GvIOn(gv);
a0d0e21e 2482 STRLEN len;
32b81f04 2483 const int op_type = PL_op->op_type;
a0d0e21e
LW
2484
2485 if (!io || !IoIFP(io))
2486 goto nuts;
2487
349d4f2f 2488 addr = SvPV_const(addrsv, len);
32b81f04
NC
2489 TAINT_PROPER(PL_op_desc[op_type]);
2490 if ((op_type == OP_BIND
2491 ? PerlSock_bind(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len)
2492 : PerlSock_connect(PerlIO_fileno(IoIFP(io)), (struct sockaddr *)addr, len))
2493 >= 0)
a0d0e21e
LW
2494 RETPUSHYES;
2495 else
2496 RETPUSHUNDEF;
2497
2498nuts:
fbcda526 2499 report_evil_fh(gv);
93189314 2500 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2501 RETPUSHUNDEF;
2502#else
32b81f04 2503 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
a0d0e21e
LW
2504#endif
2505}
2506
2507PP(pp_listen)
2508{
a0d0e21e 2509#ifdef HAS_SOCKET
97aff369 2510 dVAR; dSP;
7452cf6a 2511 const int backlog = POPi;
159b6efe 2512 GV * const gv = MUTABLE_GV(POPs);
7452cf6a 2513 register IO * const io = gv ? GvIOn(gv) : NULL;
a0d0e21e 2514
9c9f25b8 2515 if (!io || !IoIFP(io))
a0d0e21e
LW
2516 goto nuts;
2517
6ad3d225 2518 if (PerlSock_listen(PerlIO_fileno(IoIFP(io)), backlog) >= 0)
a0d0e21e
LW
2519 RETPUSHYES;
2520 else
2521 RETPUSHUNDEF;
2522
2523nuts:
fbcda526 2524 report_evil_fh(gv);
93189314 2525 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2526 RETPUSHUNDEF;
2527#else
cea2e8a9 2528 DIE(aTHX_ PL_no_sock_func, "listen");
a0d0e21e
LW
2529#endif
2530}
2531
2532PP(pp_accept)
2533{
a0d0e21e 2534#ifdef HAS_SOCKET
97aff369 2535 dVAR; dSP; dTARGET;
a0d0e21e
LW
2536 register IO *nstio;
2537 register IO *gstio;
93d47a36
JH
2538 char namebuf[MAXPATHLEN];
2539#if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE) || defined(__QNXNTO__)
2540 Sock_size_t len = sizeof (struct sockaddr_in);
2541#else
2542 Sock_size_t len = sizeof namebuf;
2543#endif
159b6efe
NC
2544 GV * const ggv = MUTABLE_GV(POPs);
2545 GV * const ngv = MUTABLE_GV(POPs);
a0d0e21e
LW
2546 int fd;
2547
a0d0e21e
LW
2548 if (!ngv)
2549 goto badexit;
2550 if (!ggv)
2551 goto nuts;
2552
2553 gstio = GvIO(ggv);
2554 if (!gstio || !IoIFP(gstio))
2555 goto nuts;
2556
2557 nstio = GvIOn(ngv);
93d47a36 2558 fd = PerlSock_accept(PerlIO_fileno(IoIFP(gstio)), (struct sockaddr *) namebuf, &len);
e294cc5d
JH
2559#if defined(OEMVS)
2560 if (len == 0) {
2561 /* Some platforms indicate zero length when an AF_UNIX client is
2562 * not bound. Simulate a non-zero-length sockaddr structure in
2563 * this case. */
2564 namebuf[0] = 0; /* sun_len */
2565 namebuf[1] = AF_UNIX; /* sun_family */
2566 len = 2;
2567 }
2568#endif
2569
a0d0e21e
LW
2570 if (fd < 0)
2571 goto badexit;
a70048fb
AB
2572 if (IoIFP(nstio))
2573 do_close(ngv, FALSE);
460c8493
IZ
2574 IoIFP(nstio) = PerlIO_fdopen(fd, "r"SOCKET_OPEN_MODE);
2575 IoOFP(nstio) = PerlIO_fdopen(fd, "w"SOCKET_OPEN_MODE);
50952442 2576 IoTYPE(nstio) = IoTYPE_SOCKET;
a0d0e21e 2577 if (!IoIFP(nstio) || !IoOFP(nstio)) {
760ac839
LW
2578 if (IoIFP(nstio)) PerlIO_close(IoIFP(nstio));
2579 if (IoOFP(nstio)) PerlIO_close(IoOFP(nstio));
6ad3d225 2580 if (!IoIFP(nstio) && !IoOFP(nstio)) PerlLIO_close(fd);
a0d0e21e
LW
2581 goto badexit;
2582 }
8d2a6795
GS
2583#if defined(HAS_FCNTL) && defined(F_SETFD)
2584 fcntl(fd, F_SETFD, fd > PL_maxsysfd); /* ensure close-on-exec */
2585#endif
a0d0e21e 2586
ed79a026 2587#ifdef EPOC
93d47a36 2588 len = sizeof (struct sockaddr_in); /* EPOC somehow truncates info */
a9f1f6b0 2589 setbuf( IoIFP(nstio), NULL); /* EPOC gets confused about sockets */
ed79a026 2590#endif
381c1bae 2591#ifdef __SCO_VERSION__
93d47a36 2592 len = sizeof (struct sockaddr_in); /* OpenUNIX 8 somehow truncates info */
381c1bae 2593#endif
ed79a026 2594
93d47a36 2595 PUSHp(namebuf, len);
a0d0e21e
LW
2596 RETURN;
2597
2598nuts:
fbcda526 2599 report_evil_fh(ggv);
93189314 2600 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2601
2602badexit:
2603 RETPUSHUNDEF;
2604
2605#else
cea2e8a9 2606 DIE(aTHX_ PL_no_sock_func, "accept");
a0d0e21e
LW
2607#endif
2608}
2609
2610PP(pp_shutdown)
2611{
a0d0e21e 2612#ifdef HAS_SOCKET
97aff369 2613 dVAR; dSP; dTARGET;
7452cf6a 2614 const int how = POPi;
159b6efe 2615 GV * const gv = MUTABLE_GV(POPs);
7452cf6a 2616 register IO * const io = GvIOn(gv);
a0d0e21e
LW
2617
2618 if (!io || !IoIFP(io))
2619 goto nuts;
2620
6ad3d225 2621 PUSHi( PerlSock_shutdown(PerlIO_fileno(IoIFP(io)), how) >= 0 );
a0d0e21e
LW
2622 RETURN;
2623
2624nuts:
fbcda526 2625 report_evil_fh(gv);
93189314 2626 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2627 RETPUSHUNDEF;
2628#else
cea2e8a9 2629 DIE(aTHX_ PL_no_sock_func, "shutdown");
a0d0e21e
LW
2630#endif
2631}
2632
a0d0e21e
LW
2633PP(pp_ssockopt)
2634{
a0d0e21e 2635#ifdef HAS_SOCKET
97aff369 2636 dVAR; dSP;
7452cf6a 2637 const int optype = PL_op->op_type;
561b68a9 2638 SV * const sv = (optype == OP_GSOCKOPT) ? sv_2mortal(newSV(257)) : POPs;
7452cf6a
AL
2639 const unsigned int optname = (unsigned int) POPi;
2640 const unsigned int lvl = (unsigned int) POPi;
159b6efe 2641 GV * const gv = MUTABLE_GV(POPs);
7452cf6a 2642 register IO * const io = GvIOn(gv);
a0d0e21e 2643 int fd;
1e422769 2644 Sock_size_t len;
a0d0e21e 2645
a0d0e21e
LW
2646 if (!io || !IoIFP(io))
2647 goto nuts;
2648
760ac839 2649 fd = PerlIO_fileno(IoIFP(io));
a0d0e21e
LW
2650 switch (optype) {
2651 case OP_GSOCKOPT:
748a9306 2652 SvGROW(sv, 257);
a0d0e21e 2653 (void)SvPOK_only(sv);
748a9306
LW
2654 SvCUR_set(sv,256);
2655 *SvEND(sv) ='\0';
1e422769 2656 len = SvCUR(sv);
6ad3d225 2657 if (PerlSock_getsockopt(fd, lvl, optname, SvPVX(sv), &len) < 0)
a0d0e21e 2658 goto nuts2;
1e422769 2659 SvCUR_set(sv, len);
748a9306 2660 *SvEND(sv) ='\0';
a0d0e21e
LW
2661 PUSHs(sv);
2662 break;
2663 case OP_SSOCKOPT: {
1215b447
JH
2664#if defined(__SYMBIAN32__)
2665# define SETSOCKOPT_OPTION_VALUE_T void *
2666#else
2667# define SETSOCKOPT_OPTION_VALUE_T const char *
2668#endif
2669 /* XXX TODO: We need to have a proper type (a Configure probe,
2670 * etc.) for what the C headers think of the third argument of
2671 * setsockopt(), the option_value read-only buffer: is it
2672 * a "char *", or a "void *", const or not. Some compilers
2673 * don't take kindly to e.g. assuming that "char *" implicitly
2674 * promotes to a "void *", or to explicitly promoting/demoting
2675 * consts to non/vice versa. The "const void *" is the SUS
2676 * definition, but that does not fly everywhere for the above
2677 * reasons. */
2678 SETSOCKOPT_OPTION_VALUE_T buf;
1e422769
PP
2679 int aint;
2680 if (SvPOKp(sv)) {
2d8e6c8d 2681 STRLEN l;
1215b447 2682 buf = (SETSOCKOPT_OPTION_VALUE_T) SvPV_const(sv, l);
2d8e6c8d 2683 len = l;
1e422769 2684 }
56ee1660 2685 else {
a0d0e21e 2686 aint = (int)SvIV(sv);
1215b447 2687 buf = (SETSOCKOPT_OPTION_VALUE_T) &aint;
a0d0e21e
LW
2688 len = sizeof(int);
2689 }
6ad3d225 2690 if (PerlSock_setsockopt(fd, lvl, optname, buf, len) < 0)
a0d0e21e 2691 goto nuts2;
3280af22 2692 PUSHs(&PL_sv_yes);
a0d0e21e
LW
2693 }
2694 break;
2695 }
2696 RETURN;
2697
2698nuts:
fbcda526 2699 report_evil_fh(gv);
93189314 2700 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2701nuts2:
2702 RETPUSHUNDEF;
2703
2704#else
af51a00e 2705 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
a0d0e21e
LW
2706#endif
2707}
2708
a0d0e21e
LW
2709PP(pp_getpeername)
2710{
a0d0e21e 2711#ifdef HAS_SOCKET
97aff369 2712 dVAR; dSP;
7452cf6a 2713 const int optype = PL_op->op_type;
159b6efe 2714 GV * const gv = MUTABLE_GV(POPs);
7452cf6a
AL
2715 register IO * const io = GvIOn(gv);
2716 Sock_size_t len;
a0d0e21e
LW
2717 SV *sv;
2718 int fd;
a0d0e21e
LW
2719
2720 if (!io || !IoIFP(io))
2721 goto nuts;
2722
561b68a9 2723 sv = sv_2mortal(newSV(257));
748a9306 2724 (void)SvPOK_only(sv);
1e422769
PP
2725 len = 256;
2726 SvCUR_set(sv, len);
748a9306 2727 *SvEND(sv) ='\0';
760ac839 2728 fd = PerlIO_fileno(IoIFP(io));
a0d0e21e
LW
2729 switch (optype) {
2730 case OP_GETSOCKNAME:
6ad3d225 2731 if (PerlSock_getsockname(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
a0d0e21e
LW
2732 goto nuts2;
2733 break;
2734 case OP_GETPEERNAME:
6ad3d225 2735 if (PerlSock_getpeername(fd, (struct sockaddr *)SvPVX(sv), &len) < 0)
a0d0e21e 2736 goto nuts2;
490ab354
JH
2737#if defined(VMS_DO_SOCKETS) && defined (DECCRTL_SOCKETS)
2738 {
2739 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";
2740 /* If the call succeeded, make sure we don't have a zeroed port/addr */
349d4f2f 2741 if (((struct sockaddr *)SvPVX_const(sv))->sa_family == AF_INET &&
2fbb330f 2742 !memcmp(SvPVX_const(sv) + sizeof(u_short), nowhere,
490ab354 2743 sizeof(u_short) + sizeof(struct in_addr))) {
301e8125 2744 goto nuts2;
490ab354
JH
2745 }
2746 }
2747#endif
a0d0e21e
LW
2748 break;
2749 }
13826f2c
CS
2750#ifdef BOGUS_GETNAME_RETURN
2751 /* Interactive Unix, getpeername() and getsockname()
2752 does not return valid namelen */
1e422769
PP
2753 if (len == BOGUS_GETNAME_RETURN)
2754 len = sizeof(struct sockaddr);
13826f2c 2755#endif
1e422769 2756 SvCUR_set(sv, len);
748a9306 2757 *SvEND(sv) ='\0';
a0d0e21e
LW
2758 PUSHs(sv);
2759 RETURN;
2760
2761nuts:
fbcda526 2762 report_evil_fh(gv);
93189314 2763 SETERRNO(EBADF,SS_IVCHAN);
a0d0e21e
LW
2764nuts2:
2765 RETPUSHUNDEF;
2766
2767#else
af51a00e 2768 DIE(aTHX_ PL_no_sock_func, PL_op_desc[PL_op->op_type]);
a0d0e21e
LW
2769#endif
2770}
2771
2772/* Stat calls. */
2773
a0d0e21e
LW
2774PP(pp_stat)
2775{
97aff369 2776 dVAR;
39644a26 2777 dSP;
10edeb5d 2778 GV *gv = NULL;
ad02613c 2779 IO *io;
54310121 2780 I32 gimme;
a0d0e21e
LW
2781 I32 max = 13;
2782
533c011a 2783 if (PL_op->op_flags & OPf_REF) {
2dd78f96 2784 gv = cGVOP_gv;
8a4e5b40 2785 if (PL_op->op_type == OP_LSTAT) {
5d3e98de 2786 if (gv != PL_defgv) {
5d329e6e 2787 do_fstat_warning_check:
a2a5de95
NC
2788 Perl_ck_warner(aTHX_ packWARN(WARN_IO),
2789 "lstat() on filehandle %s", gv ? GvENAME(gv) : "");
5d3e98de 2790 } else if (PL_laststype != OP_LSTAT)
8a4e5b40 2791 Perl_croak(aTHX_ "The stat preceding lstat() wasn't an lstat");
8a4e5b40
DD
2792 }
2793
748a9306 2794 do_fstat:
2dd78f96 2795 if (gv != PL_defgv) {
3280af22 2796 PL_laststype = OP_STAT;
2dd78f96 2797 PL_statgv = gv;
76f68e9b 2798 sv_setpvs(PL_statname, "");
5228a96c 2799 if(gv) {
ad02613c
SP
2800 io = GvIO(gv);
2801 do_fstat_have_io:
5228a96c
SP
2802 if (io) {
2803 if (IoIFP(io)) {
2804 PL_laststatval =
2805 PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache);
2806 } else if (IoDIRP(io)) {
5228a96c 2807 PL_laststatval =
3497a01f 2808 PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache);
5228a96c
SP
2809 } else {
2810 PL_laststatval = -1;
2811 }
2812 }
2813 }
2814 }
2815
9ddeeac9 2816 if (PL_laststatval < 0) {
51087808 2817 report_evil_fh(gv);
a0d0e21e 2818 max = 0;
9ddeeac9 2819 }
a0d0e21e
LW
2820 }
2821 else {
7452cf6a 2822 SV* const sv = POPs;
6e592b3a 2823 if (isGV_with_GP(sv)) {
159b6efe 2824 gv = MUTABLE_GV(sv);
748a9306 2825 goto do_fstat;
6e592b3a 2826 } else if(SvROK(sv) && isGV_with_GP(SvRV(sv))) {
159b6efe 2827 gv = MUTABLE_GV(SvRV(sv));
ad02613c
SP
2828 if (PL_op->op_type == OP_LSTAT)
2829 goto do_fstat_warning_check;
2830 goto do_fstat;
2831 } else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
a45c7426 2832 io = MUTABLE_IO(SvRV(sv));
ad02613c
SP
2833 if (PL_op->op_type == OP_LSTAT)
2834 goto do_fstat_warning_check;
2835 goto do_fstat_have_io;
2836 }
2837
0510663f 2838 sv_setpv(PL_statname, SvPV_nolen_const(sv));
a0714e2c 2839 PL_statgv = NULL;
533c011a
NIS
2840 PL_laststype = PL_op->op_type;
2841 if (PL_op->op_type == OP_LSTAT)
0510663f 2842 PL_laststatval = PerlLIO_lstat(SvPV_nolen_const(PL_statname), &PL_statcache);
a0d0e21e 2843 else
0510663f 2844 PL_laststatval = PerlLIO_stat(SvPV_nolen_const(PL_statname), &PL_statcache);
3280af22 2845 if (PL_laststatval < 0) {
0510663f 2846 if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname), '\n'))
9014280d 2847 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
a0d0e21e
LW
2848 max = 0;
2849 }
2850 }
2851
54310121
PP
2852 gimme = GIMME_V;
2853 if (gimme != G_ARRAY) {
2854 if (gimme != G_VOID)
2855 XPUSHs(boolSV(max));
2856 RETURN;
a0d0e21e
LW
2857 }
2858 if (max) {
36477c24
PP
2859 EXTEND(SP, max);
2860 EXTEND_MORTAL(max);
6e449a3a
MHM
2861 mPUSHi(PL_statcache.st_dev);
2862 mPUSHi(PL_statcache.st_ino);
2863 mPUSHu(PL_statcache.st_mode);
2864 mPUSHu(PL_statcache.st_nlink);
146174a9 2865#if Uid_t_size > IVSIZE
6e449a3a 2866 mPUSHn(PL_statcache.st_uid);
146174a9 2867#else
23dcd6c8 2868# if Uid_t_sign <= 0
6e449a3a 2869 mPUSHi(PL_statcache.st_uid);
23dcd6c8 2870# else
6e449a3a 2871 mPUSHu(PL_statcache.st_uid);
23dcd6c8 2872# endif
146174a9 2873#endif
301e8125 2874#if Gid_t_size > IVSIZE
6e449a3a 2875 mPUSHn(PL_statcache.st_gid);
146174a9 2876#else
23dcd6c8 2877# if Gid_t_sign <= 0
6e449a3a 2878 mPUSHi(PL_statcache.st_gid);
23dcd6c8 2879# else
6e449a3a 2880 mPUSHu(PL_statcache.st_gid);
23dcd6c8 2881# endif
146174a9 2882#endif
cbdc8872 2883#ifdef USE_STAT_RDEV
6e449a3a 2884 mPUSHi(PL_statcache.st_rdev);
cbdc8872 2885#else
84bafc02 2886 PUSHs(newSVpvs_flags("", SVs_TEMP));
cbdc8872 2887#endif
146174a9 2888#if Off_t_size > IVSIZE
6e449a3a 2889 mPUSHn(PL_statcache.st_size);
146174a9 2890#else
6e449a3a 2891 mPUSHi(PL_statcache.st_size);
146174a9 2892#endif
cbdc8872 2893#ifdef BIG_TIME
6e449a3a
MHM
2894 mPUSHn(PL_statcache.st_atime);
2895 mPUSHn(PL_statcache.st_mtime);
2896 mPUSHn(PL_statcache.st_ctime);
cbdc8872 2897#else
6e449a3a
MHM
2898 mPUSHi(PL_statcache.st_atime);
2899 mPUSHi(PL_statcache.st_mtime);
2900 mPUSHi(PL_statcache.st_ctime);
cbdc8872 2901#endif
a0d0e21e 2902#ifdef USE_STAT_BLOCKS
6e449a3a
MHM
2903 mPUSHu(PL_statcache.st_blksize);
2904 mPUSHu(PL_statcache.st_blocks);
a0d0e21e 2905#else
84bafc02
NC
2906 PUSHs(newSVpvs_flags("", SVs_TEMP));
2907 PUSHs(newSVpvs_flags("", SVs_TEMP));
a0d0e21e
LW
2908#endif
2909 }
2910 RETURN;
2911}
2912
6f1401dc
DM
2913#define tryAMAGICftest_MG(chr) STMT_START { \
2914 if ( (SvFLAGS(TOPs) & (SVf_ROK|SVs_GMG)) \
2915 && S_try_amagic_ftest(aTHX_ chr)) \
2916 return NORMAL; \
2917 } STMT_END
2918
2919STATIC bool
2920S_try_amagic_ftest(pTHX_ char chr) {
2921 dVAR;
2922 dSP;
2923 SV* const arg = TOPs;
2924
2925 assert(chr != '?');
2926 SvGETMAGIC(arg);
2927
2928 if ((PL_op->op_flags & OPf_KIDS)
2929 && SvAMAGIC(TOPs))
2930 {
2931 const char tmpchr = chr;
2932 const OP *next;
2933 SV * const tmpsv = amagic_call(arg,
2934 newSVpvn_flags(&tmpchr, 1, SVs_TEMP),
2935 ftest_amg, AMGf_unary);
2936
2937 if (!tmpsv)
2938 return FALSE;
2939
2940 SPAGAIN;
2941
2942 next = PL_op->op_next;
2943 if (next->op_type >= OP_FTRREAD &&
2944 next->op_type <= OP_FTBINARY &&
2945 next->op_private & OPpFT_STACKED
2946 ) {
2947 if (SvTRUE(tmpsv))
2948 /* leave the object alone */
2949 return TRUE;
2950 }
2951
2952 SETs(tmpsv);
2953 PUTBACK;
2954 return TRUE;
2955 }
2956 return FALSE;
2957}
2958
2959
fbb0b3b3
RGS
2960/* This macro is used by the stacked filetest operators :
2961 * if the previous filetest failed, short-circuit and pass its value.
2962 * Else, discard it from the stack and continue. --rgs
2963 */
2964#define STACKED_FTEST_CHECK if (PL_op->op_private & OPpFT_STACKED) { \
d724f706 2965 if (!SvTRUE(TOPs)) { RETURN; } \
fbb0b3b3
RGS
2966 else { (void)POPs; PUTBACK; } \
2967 }
2968
a0d0e21e
LW
2969PP(pp_ftrread)
2970{
97aff369 2971 dVAR;
9cad6237 2972 I32 result;
af9e49b4
NC
2973 /* Not const, because things tweak this below. Not bool, because there's
2974 no guarantee that OPp_FT_ACCESS is <= CHAR_MAX */
2975#if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
2976 I32 use_access = PL_op->op_private & OPpFT_ACCESS;
2977 /* Giving some sort of initial value silences compilers. */
2978# ifdef R_OK
2979 int access_mode = R_OK;
2980# else
2981 int access_mode = 0;
2982# endif
5ff3f7a4 2983#else
af9e49b4
NC
2984 /* access_mode is never used, but leaving use_access in makes the
2985 conditional compiling below much clearer. */
2986 I32 use_access = 0;
5ff3f7a4 2987#endif
2dcac756 2988 Mode_t stat_mode = S_IRUSR;
a0d0e21e 2989
af9e49b4 2990 bool effective = FALSE;
07fe7c6a 2991 char opchar = '?';
2a3ff820 2992 dSP;
af9e49b4 2993
7fb13887
BM
2994 switch (PL_op->op_type) {
2995 case OP_FTRREAD: opchar = 'R'; break;
2996 case OP_FTRWRITE: opchar = 'W'; break;
2997 case OP_FTREXEC: opchar = 'X'; break;
2998 case OP_FTEREAD: opchar = 'r'; break;
2999 case OP_FTEWRITE: opchar = 'w'; break;
3000 case OP_FTEEXEC: opchar = 'x'; break;
3001 }
6f1401dc 3002 tryAMAGICftest_MG(opchar);
7fb13887 3003
fbb0b3b3 3004 STACKED_FTEST_CHECK;
af9e49b4
NC
3005
3006 switch (PL_op->op_type) {
3007 case OP_FTRREAD:
3008#if !(defined(HAS_ACCESS) && defined(R_OK))
3009 use_access = 0;
3010#endif
3011 break;
3012
3013 case OP_FTRWRITE:
5ff3f7a4 3014#if defined(HAS_ACCESS) && defined(W_OK)
af9e49b4 3015 access_mode = W_OK;
5ff3f7a4 3016#else
af9e49b4 3017 use_access = 0;
5ff3f7a4 3018#endif
af9e49b4
NC
3019 stat_mode = S_IWUSR;
3020 break;
a0d0e21e 3021
af9e49b4 3022 case OP_FTREXEC:
5ff3f7a4 3023#if defined(HAS_ACCESS) && defined(X_OK)
af9e49b4 3024 access_mode = X_OK;
5ff3f7a4 3025#else
af9e49b4 3026 use_access = 0;
5ff3f7a4 3027#endif
af9e49b4
NC
3028 stat_mode = S_IXUSR;
3029 break;
a0d0e21e 3030
af9e49b4 3031 case OP_FTEWRITE:
faee0e31 3032#ifdef PERL_EFF_ACCESS
af9e49b4 3033 access_mode = W_OK;
5ff3f7a4 3034#endif
af9e49b4 3035 stat_mode = S_IWUSR;
7fb13887 3036 /* fall through */
a0d0e21e 3037
af9e49b4
NC
3038 case OP_FTEREAD:
3039#ifndef PERL_EFF_ACCESS
3040 use_access = 0;
3041#endif
3042 effective = TRUE;
3043 break;
3044
af9e49b4 3045 case OP_FTEEXEC:
faee0e31 3046#ifdef PERL_EFF_ACCESS
b376053d 3047 access_mode = X_OK;
5ff3f7a4 3048#else
af9e49b4 3049 use_access = 0;
5ff3f7a4 3050#endif
af9e49b4
NC
3051 stat_mode = S_IXUSR;
3052 effective = TRUE;
3053 break;
3054 }
a0d0e21e 3055
af9e49b4
NC
3056 if (use_access) {
3057#if defined(HAS_ACCESS) || defined (PERL_EFF_ACCESS)
2c2f35ab 3058 const char *name = POPpx;
af9e49b4
NC
3059 if (effective) {
3060# ifdef PERL_EFF_ACCESS
3061 result = PERL_EFF_ACCESS(name, access_mode);
3062# else
3063 DIE(aTHX_ "panic: attempt to call PERL_EFF_ACCESS in %s",
3064 OP_NAME(PL_op));
3065# endif
3066 }
3067 else {
3068# ifdef HAS_ACCESS
3069 result = access(name, access_mode);
3070# else
3071 DIE(aTHX_ "panic: attempt to call access() in %s", OP_NAME(PL_op));
3072# endif
3073 }
5ff3f7a4
GS
3074 if (result == 0)
3075 RETPUSHYES;
3076 if (result < 0)
3077 RETPUSHUNDEF;
3078 RETPUSHNO;
af9e49b4 3079#endif
22865c03 3080 }
af9e49b4 3081
40c852de 3082 result = my_stat_flags(0);
22865c03 3083 SPAGAIN;
a0d0e21e
LW
3084 if (result < 0)
3085 RETPUSHUNDEF;
af9e49b4 3086 if (cando(stat_mode, effective, &PL_statcache))
a0d0e21e
LW
3087 RETPUSHYES;
3088 RETPUSHNO;
3089}
3090
3091PP(pp_ftis)
3092{
97aff369 3093 dVAR;
fbb0b3b3 3094 I32 result;
d7f0a2f4 3095 const int op_type = PL_op->op_type;
07fe7c6a 3096 char opchar = '?';
2a3ff820 3097 dSP;
07fe7c6a
BM
3098
3099 switch (op_type) {
3100 case OP_FTIS: opchar = 'e'; break;
3101 case OP_FTSIZE: opchar = 's'; break;
3102 case OP_FTMTIME: opchar = 'M'; break;
3103 case OP_FTCTIME: opchar = 'C'; break;
3104 case OP_FTATIME: opchar = 'A'; break;
3105 }
6f1401dc 3106 tryAMAGICftest_MG(opchar);
07fe7c6a 3107
fbb0b3b3 3108 STACKED_FTEST_CHECK;
7fb13887 3109
40c852de 3110 result = my_stat_flags(0);
fbb0b3b3 3111 SPAGAIN;
a0d0e21e
LW
3112 if (result < 0)
3113 RETPUSHUNDEF;
d7f0a2f4
NC
3114 if (op_type == OP_FTIS)
3115 RETPUSHYES;
957b0e1d 3116 {
d7f0a2f4
NC
3117 /* You can't dTARGET inside OP_FTIS, because you'll get
3118 "panic: pad_sv po" - the op is not flagged to have a target. */
957b0e1d 3119 dTARGET;
d7f0a2f4 3120 switch (op_type) {
957b0e1d
NC
3121 case OP_FTSIZE:
3122#if Off_t_size > IVSIZE
3123 PUSHn(PL_statcache.st_size);
3124#else
3125 PUSHi(PL_statcache.st_size);
3126#endif
3127 break;
3128 case OP_FTMTIME:
3129 PUSHn( (((NV)PL_basetime - PL_statcache.st_mtime)) / 86400.0 );
3130 break;
3131 case OP_FTATIME:
3132 PUSHn( (((NV)PL_basetime - PL_statcache.st_atime)) / 86400.0 );
3133 break;
3134 case OP_FTCTIME:
3135 PUSHn( (((NV)PL_basetime - PL_statcache.st_ctime)) / 86400.0 );
3136 break;
3137 }
3138 }
3139 RETURN;
a0d0e21e
LW
3140}
3141
a0d0e21e
LW
3142PP(pp_ftrowned)
3143{
97aff369 3144 dVAR;
fbb0b3b3 3145 I32 result;
07fe7c6a 3146 char opchar = '?';
2a3ff820 3147 dSP;
17ad201a 3148
7fb13887
BM
3149 switch (PL_op->op_type) {
3150 case OP_FTROWNED: opchar = 'O'; break;
3151 case OP_FTEOWNED: opchar = 'o'; break;
3152 case OP_FTZERO: opchar = 'z'; break;
3153 case OP_FTSOCK: opchar = 'S'; break;
3154 case OP_FTCHR: opchar = 'c'; break;
3155 case OP_FTBLK: opchar = 'b'; break;
3156 case OP_FTFILE: opchar = 'f'; break;
3157 case OP_FTDIR: opchar = 'd'; break;
3158 case OP_FTPIPE: opchar = 'p'; break;
3159 case OP_FTSUID: opchar = 'u'; break;
3160 case OP_FTSGID: opchar = 'g'; break;
3161 case OP_FTSVTX: opchar = 'k'; break;
3162 }
6f1401dc 3163 tryAMAGICftest_MG(opchar);
7fb13887 3164
1b0124a7
JD
3165 STACKED_FTEST_CHECK;
3166
17ad201a
NC
3167 /* I believe that all these three are likely to be defined on most every
3168 system these days. */
3169#ifndef S_ISUID
c410dd6a 3170 if(PL_op->op_type == OP_FTSUID) {
1b0124a7
JD
3171 if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3172 (void) POPs;
17ad201a 3173 RETPUSHNO;
c410dd6a 3174 }
17ad201a
NC
3175#endif
3176#ifndef S_ISGID
c410dd6a 3177 if(PL_op->op_type == OP_FTSGID) {
1b0124a7
JD
3178 if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3179 (void) POPs;
17ad201a 3180 RETPUSHNO;
c410dd6a 3181 }
17ad201a
NC
3182#endif
3183#ifndef S_ISVTX
c410dd6a 3184 if(PL_op->op_type == OP_FTSVTX) {
1b0124a7
JD
3185 if ((PL_op->op_flags & OPf_REF) == 0 && (PL_op->op_private & OPpFT_STACKED) == 0)
3186 (void) POPs;
17ad201a 3187 RETPUSHNO;
c410dd6a 3188 }
17ad201a
NC
3189#endif
3190
40c852de 3191 result = my_stat_flags(0);
fbb0b3b3 3192 SPAGAIN;
a0d0e21e
LW
3193 if (result < 0)
3194 RETPUSHUNDEF;
f1cb2d48
NC
3195 switch (PL_op->op_type) {
3196 case OP_FTROWNED:
9ab9fa88 3197 if (PL_statcache.st_uid == PL_uid)
f1cb2d48
NC
3198 RETPUSHYES;
3199 break;
3200 case OP_FTEOWNED:
3201 if (PL_statcache.st_uid == PL_euid)
3202 RETPUSHYES;
3203 break;
3204 case OP_FTZERO:
3205 if (PL_statcache.st_size == 0)
3206 RETPUSHYES;
3207 break;
3208 case OP_FTSOCK:
3209 if (S_ISSOCK(PL_statcache.st_mode))
3210 RETPUSHYES;
3211 break;
3212 case OP_FTCHR:
3213 if (S_ISCHR(PL_statcache.st_mode))
3214 RETPUSHYES;
3215 break;
3216 case OP_FTBLK:
3217 if (S_ISBLK(PL_statcache.st_mode))
3218 RETPUSHYES;
3219 break;
3220 case OP_FTFILE:
3221 if (S_ISREG(PL_statcache.st_mode))
3222 RETPUSHYES;
3223 break;
3224 case OP_FTDIR:
3225 if (S_ISDIR(PL_statcache.st_mode))
3226 RETPUSHYES;
3227 break;
3228 case OP_FTPIPE:
3229 if (S_ISFIFO(PL_statcache.st_mode))
3230 RETPUSHYES;
3231 break;
a0d0e21e 3232#ifdef S_ISUID
17ad201a
NC
3233 case OP_FTSUID:
3234 if (PL_statcache.st_mode & S_ISUID)
3235 RETPUSHYES;
3236 break;
a0d0e21e 3237#endif
a0d0e21e 3238#ifdef S_ISGID
17ad201a
NC
3239 case OP_FTSGID:
3240 if (PL_statcache.st_mode & S_ISGID)
3241 RETPUSHYES;
3242 break;
3243#endif
3244#ifdef S_ISVTX
3245 case OP_FTSVTX:
3246 if (PL_statcache.st_mode & S_ISVTX)
3247 RETPUSHYES;
3248 break;
a0d0e21e 3249#endif
17ad201a 3250 }
a0d0e21e
LW
3251 RETPUSHNO;
3252}
3253
17ad201a 3254PP(pp_ftlink)
a0d0e21e 3255{
97aff369 3256 dVAR;
39644a26 3257 dSP;
500ff13f 3258 I32 result;
07fe7c6a 3259
6f1401dc 3260 tryAMAGICftest_MG('l');
40c852de 3261 result = my_lstat_flags(0);
500ff13f
BM
3262 SPAGAIN;
3263
a0d0e21e
LW
3264 if (result < 0)
3265 RETPUSHUNDEF;
17ad201a 3266 if (S_ISLNK(PL_statcache.st_mode))
a0d0e21e 3267 RETPUSHYES;
a0d0e21e
LW
3268 RETPUSHNO;
3269}
3270
3271PP(pp_fttty)
3272{
97aff369 3273 dVAR;
39644a26 3274 dSP;
a0d0e21e
LW
3275 int fd;
3276 GV *gv;
a0714e2c 3277 SV *tmpsv = NULL;
0784aae0 3278 char *name = NULL;
40c852de 3279 STRLEN namelen;
fb73857a 3280
6f1401dc 3281 tryAMAGICftest_MG('t');
07fe7c6a 3282
fbb0b3b3
RGS
3283 STACKED_FTEST_CHECK;
3284
533c011a 3285 if (PL_op->op_flags & OPf_REF)
146174a9 3286 gv = cGVOP_gv;
13be902c 3287 else if (isGV_with_GP(TOPs))
159b6efe 3288 gv = MUTABLE_GV(POPs);
fb73857a 3289 else if (SvROK(TOPs) && isGV(SvRV(TOPs)))
159b6efe 3290 gv = MUTABLE_GV(SvRV(POPs));
40c852de
DM
3291 else {
3292 tmpsv = POPs;
3293 name = SvPV_nomg(tmpsv, namelen);
3294 gv = gv_fetchpvn_flags(name, namelen, SvUTF8(tmpsv), SVt_PVIO);
3295 }
fb73857a 3296
a0d0e21e 3297 if (GvIO(gv) && IoIFP(GvIOp(gv)))
760ac839 3298 fd = PerlIO_fileno(IoIFP(GvIOp(gv)));
7a5fd60d 3299 else if (tmpsv && SvOK(tmpsv)) {
40c852de
DM
3300 if (isDIGIT(*name))
3301 fd = atoi(name);
7a5fd60d
NC
3302 else
3303 RETPUSHUNDEF;
3304 }
a0d0e21e
LW
3305 else
3306 RETPUSHUNDEF;
6ad3d225 3307 if (PerlLIO_isatty(fd))
a0d0e21e
LW
3308 RETPUSHYES;
3309 RETPUSHNO;
3310}
3311
16d20bd9
AD
3312#if defined(atarist) /* this will work with atariST. Configure will
3313 make guesses for other systems. */
3314# define FILE_base(f) ((f)->_base)
3315# define FILE_ptr(f) ((f)->_ptr)
3316# define FILE_cnt(f) ((f)->_cnt)
3317# define FILE_bufsiz(f) ((f)->_cnt + ((f)->_ptr - (f)->_base))
a0d0e21e
LW
3318#endif
3319
3320PP(pp_fttext)
3321{
97aff369 3322 dVAR;
39644a26 3323 dSP;
a0d0e21e
LW
3324 I32 i;
3325 I32 len;
3326 I32 odd = 0;
3327 STDCHAR tbuf[512];
3328 register STDCHAR *s;
3329 register IO *io;
5f05dabc
PP
3330 register SV *sv;
3331 GV *gv;
146174a9 3332 PerlIO *fp;
a0d0e21e 3333
6f1401dc 3334 tryAMAGICftest_MG(PL_op->op_type == OP_FTTEXT ? 'T' : 'B');
07fe7c6a 3335
fbb0b3b3
RGS
3336 STACKED_FTEST_CHECK;
3337
533c011a 3338 if (PL_op->op_flags & OPf_REF)
146174a9 3339 gv = cGVOP_gv;
13be902c 3340 else if (isGV_with_GP(TOPs))
159b6efe 3341 gv = MUTABLE_GV(POPs);
5f05dabc 3342 else if (SvROK(TOPs) && isGV(SvRV(TOPs)))
159b6efe 3343 gv = MUTABLE_GV(SvRV(POPs));
5f05dabc 3344 else
a0714e2c 3345 gv = NULL;
5f05dabc
PP
3346
3347 if (gv) {
a0d0e21e 3348 EXTEND(SP, 1);
3280af22
NIS
3349 if (gv == PL_defgv) {
3350 if (PL_statgv)
3351 io = GvIO(PL_statgv);
a0d0e21e 3352 else {
3280af22 3353 sv = PL_statname;
a0d0e21e
LW
3354 goto really_filename;
3355 }
3356 }
3357 else {
3280af22
NIS
3358 PL_statgv = gv;
3359 PL_laststatval = -1;
76f68e9b 3360 sv_setpvs(PL_statname, "");
3280af22 3361 io = GvIO(PL_statgv);
a0d0e21e
LW
3362 }
3363 if (io && IoIFP(io)) {
5f05dabc 3364 if (! PerlIO_has_base(IoIFP(io)))
cea2e8a9 3365 DIE(aTHX_ "-T and -B not implemented on filehandles");
3280af22
NIS
3366 PL_laststatval = PerlLIO_fstat(PerlIO_fileno(IoIFP(io)), &PL_statcache);
3367 if (PL_laststatval < 0)
5f05dabc 3368 RETPUSHUNDEF;
9cbac4c7 3369 if (S_ISDIR(PL_statcache.st_mode)) { /* handle NFS glitch */
533c011a 3370 if (PL_op->op_type == OP_FTTEXT)
a0d0e21e
LW
3371 RETPUSHNO;
3372 else
3373 RETPUSHYES;
9cbac4c7 3374 }
a20bf0c3 3375 if (PerlIO_get_cnt(IoIFP(io)) <= 0) {
760ac839 3376 i = PerlIO_getc(IoIFP(io));
a0d0e21e 3377 if (i != EOF)
760ac839 3378 (void)PerlIO_ungetc(IoIFP(io),i);
a0d0e21e 3379 }
a20bf0c3 3380 if (PerlIO_get_cnt(IoIFP(io)) <= 0) /* null file is anything */
a0d0e21e 3381 RETPUSHYES;
a20bf0c3
JH
3382 len = PerlIO_get_bufsiz(IoIFP(io));
3383 s = (STDCHAR *) PerlIO_get_base(IoIFP(io));
760ac839
LW
3384 /* sfio can have large buffers - limit to 512 */
3385 if (len > 512)
3386 len = 512;
a0d0e21e
LW
3387 }
3388 else {
51087808 3389 report_evil_fh(cGVOP_gv);
93189314 3390 SETERRNO(EBADF,RMS_IFI);
a0d0e21e
LW
3391 RETPUSHUNDEF;
3392 }
3393 }
3394 else {
3395 sv = POPs;
5f05dabc 3396 really_filename:
a0714e2c 3397 PL_statgv = NULL;
5c9aa243 3398 PL_laststype = OP_STAT;
40c852de 3399 sv_setpv(PL_statname, SvPV_nomg_const_nolen(sv));
aa07b2f6 3400 if (!(fp = PerlIO_open(SvPVX_const(PL_statname), "r"))) {
349d4f2f
NC
3401 if (ckWARN(WARN_NEWLINE) && strchr(SvPV_nolen_const(PL_statname),
3402 '\n'))
9014280d 3403 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
a0d0e21e
LW
3404 RETPUSHUNDEF;
3405 }
146174a9
CB
3406 PL_laststatval = PerlLIO_fstat(PerlIO_fileno(fp), &PL_statcache);
3407 if (PL_laststatval < 0) {
3408 (void)PerlIO_close(fp);
5f05dabc 3409 RETPUSHUNDEF;
146174a9 3410 }
bd61b366 3411 PerlIO_binmode(aTHX_ fp, '<', O_BINARY, NULL);
146174a9
CB
3412 len = PerlIO_read(fp, tbuf, sizeof(tbuf));
3413 (void)PerlIO_close(fp);
a0d0e21e 3414 if (len <= 0) {
533c011a 3415 if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
a0d0e21e
LW
3416 RETPUSHNO; /* special case NFS directories */
3417 RETPUSHYES; /* null file is anything */
3418 }
3419 s = tbuf;
3420 }
3421
3422 /* now scan s to look for textiness */
4633a7c4 3423 /* XXX ASCII dependent code */
a0d0e21e 3424
146174a9
CB
3425#if defined(DOSISH) || defined(USEMYBINMODE)
3426 /* ignore trailing ^Z on short files */
58c0efa5 3427 if (len && len < (I32)sizeof(tbuf) && tbuf[len-1] == 26)
146174a9
CB
3428 --len;
3429#endif
3430
a0d0e21e
LW
3431 for (i = 0; i < len; i++, s++) {
3432 if (!*s) { /* null never allowed in text */
3433 odd += len;