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