This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
regcomp.c: Under /l any < 256 char can match any other
[perl5.git] / doio.c
CommitLineData
a0d0e21e 1/* doio.c
a687059c 2 *
1129b882
NC		 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
a687059c 5 *
6e21c824
LW		 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.
a687059c 8 *
a0d0e21e
LW		 9 */
10
11/*
4ac71550
TC		 12 * Far below them they saw the white waters pour into a foaming bowl, and
13 * then swirl darkly about a deep oval basin in the rocks, until they found
14 * their way out again through a narrow gate, and flowed away, fuming and
15 * chattering, into calmer and more level reaches.
16 *
17 * [p.684 of _The Lord of the Rings_, IV/vi: "The Forbidden Pool"]
a687059c
LW		 18 */
19
166f8a29
DM		 20/* This file contains functions that do the actual I/O on behalf of ops.
21 * For example, pp_print() calls the do_print() function in this file for
22 * each argument needing printing.
23 */
24
a687059c 25#include "EXTERN.h"
864dbfa3 26#define PERL_IN_DOIO_C
a687059c
LW		 27#include "perl.h"
28
fe14fcc3 29#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
aec308ec 30#ifndef HAS_SEM
c2ab57d4 31#include <sys/ipc.h>
aec308ec 32#endif
fe14fcc3 33#ifdef HAS_MSG
c2ab57d4 34#include <sys/msg.h>
e5d73d77 35#endif
fe14fcc3 36#ifdef HAS_SHM
c2ab57d4 37#include <sys/shm.h>
a0d0e21e 38# ifndef HAS_SHMAT_PROTOTYPE
20ce7b12 39 extern Shmat_t shmat (int, char *, int);
a0d0e21e 40# endif
c2ab57d4 41#endif
e5d73d77 42#endif
c2ab57d4 43
663a0e37 44#ifdef I_UTIME
3730b96e 45# if defined(_MSC_VER) || defined(__MINGW32__)
3fe9a6f1 46# include <sys/utime.h>
47# else
48# include <utime.h>
49# endif
663a0e37 50#endif
85aff577 51
85aff577
CS		 52#ifdef O_EXCL
53# define OPEN_EXCL O_EXCL
54#else
55# define OPEN_EXCL 0
56#endif
a687059c 57
0c19750d
SP		 58#define PERL_MODE_MAX 8
59#define PERL_FLAGS_MAX 10
60
76121258 61#include <signal.h>
76121258 62
74df577f 63void
1cdb2692 64Perl_setfd_cloexec(int fd)
74df577f
Z		 65{
66 assert(fd >= 0);
f9821aff 67#if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
74df577f 68 (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
f9821aff 69#endif
74df577f
Z		 70}
71
72void
1cdb2692 73Perl_setfd_inhexec(int fd)
74df577f
Z		 74{
75 assert(fd >= 0);
76#if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC)
77 (void) fcntl(fd, F_SETFD, 0);
78#endif
79}
80
81void
884fc2d3
Z		 82Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd)
83{
84 assert(fd >= 0);
85 if(fd > PL_maxsysfd)
86 setfd_cloexec(fd);
87}
88
89void
74df577f
Z		 90Perl_setfd_inhexec_for_sysfd(pTHX_ int fd)
91{
92 assert(fd >= 0);
93 if(fd <= PL_maxsysfd)
94 setfd_inhexec(fd);
95}
884fc2d3
Z		 96void
97Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd)
98{
99 assert(fd >= 0);
100 if(fd <= PL_maxsysfd)
101 setfd_inhexec(fd);
102 else
103 setfd_cloexec(fd);
104}
105
74df577f
Z		 106
107#define DO_GENOPEN_THEN_CLOEXEC(GENOPEN_NORMAL, GENSETFD_CLOEXEC) \
f9821aff
Z		 108 do { \
109 int res = (GENOPEN_NORMAL); \
74df577f 110 if(LIKELY(res != -1)) GENSETFD_CLOEXEC; \
f9821aff
Z		 111 return res; \
112 } while(0)
113#if defined(HAS_FCNTL) && defined(F_SETFD) && defined(FD_CLOEXEC) && \
114 defined(F_GETFD)
115enum { CLOEXEC_EXPERIMENT, CLOEXEC_AT_OPEN, CLOEXEC_AFTER_OPEN };
116# define DO_GENOPEN_EXPERIMENTING_CLOEXEC(TESTFD, GENOPEN_CLOEXEC, \
74df577f 117 GENOPEN_NORMAL, GENSETFD_CLOEXEC) \
f9821aff
Z		 118 do { \
119 static int strategy = CLOEXEC_EXPERIMENT; \
120 switch (strategy) { \
121 case CLOEXEC_EXPERIMENT: default: { \
122 int res = (GENOPEN_CLOEXEC), eno; \
123 if (LIKELY(res != -1)) { \
124 int fdflags = fcntl((TESTFD), F_GETFD); \
125 if (LIKELY(fdflags != -1) && \
126 LIKELY(fdflags & FD_CLOEXEC)) { \
127 strategy = CLOEXEC_AT_OPEN; \
128 } else { \
129 strategy = CLOEXEC_AFTER_OPEN; \
74df577f 130 GENSETFD_CLOEXEC; \
f9821aff
Z		 131 } \
132 } else if (UNLIKELY((eno = errno) == EINVAL || \
133 eno == ENOSYS)) { \
134 res = (GENOPEN_NORMAL); \
135 if (LIKELY(res != -1)) { \
136 strategy = CLOEXEC_AFTER_OPEN; \
74df577f 137 GENSETFD_CLOEXEC; \
f9821aff
Z		 138 } else if (!LIKELY((eno = errno) == EINVAL || \
139 eno == ENOSYS)) { \
140 strategy = CLOEXEC_AFTER_OPEN; \
141 } \
142 } \
143 return res; \
144 } \
145 case CLOEXEC_AT_OPEN: \
146 return (GENOPEN_CLOEXEC); \
147 case CLOEXEC_AFTER_OPEN: \
74df577f 148 DO_GENOPEN_THEN_CLOEXEC(GENOPEN_NORMAL, GENSETFD_CLOEXEC); \
f9821aff
Z		 149 } \
150 } while(0)
151#else
152# define DO_GENOPEN_EXPERIMENTING_CLOEXEC(TESTFD, GENOPEN_CLOEXEC, \
74df577f
Z		 153 GENOPEN_NORMAL, GENSETFD_CLOEXEC) \
154 DO_GENOPEN_THEN_CLOEXEC(GENOPEN_NORMAL, GENSETFD_CLOEXEC)
f9821aff
Z		 155#endif
156
157#define DO_ONEOPEN_THEN_CLOEXEC(ONEOPEN_NORMAL) \
158 do { \
159 int fd; \
160 DO_GENOPEN_THEN_CLOEXEC(fd = (ONEOPEN_NORMAL), \
74df577f 161 setfd_cloexec(fd)); \
f9821aff
Z		 162 } while(0)
163#define DO_ONEOPEN_EXPERIMENTING_CLOEXEC(ONEOPEN_CLOEXEC, ONEOPEN_NORMAL) \
164 do { \
165 int fd; \
166 DO_GENOPEN_EXPERIMENTING_CLOEXEC(fd, fd = (ONEOPEN_CLOEXEC), \
74df577f 167 fd = (ONEOPEN_NORMAL), setfd_cloexec(fd)); \
f9821aff
Z		 168 } while(0)
169
74df577f 170#define DO_PIPESETFD_CLOEXEC(PIPEFD) \
f9821aff 171 do { \
74df577f
Z		 172 setfd_cloexec((PIPEFD)[0]); \
173 setfd_cloexec((PIPEFD)[1]); \
f9821aff
Z		 174 } while(0)
175#define DO_PIPEOPEN_THEN_CLOEXEC(PIPEFD, PIPEOPEN_NORMAL) \
74df577f 176 DO_GENOPEN_THEN_CLOEXEC(PIPEOPEN_NORMAL, DO_PIPESETFD_CLOEXEC(PIPEFD))
f9821aff
Z		 177#define DO_PIPEOPEN_EXPERIMENTING_CLOEXEC(PIPEFD, PIPEOPEN_CLOEXEC, \
178 PIPEOPEN_NORMAL) \
179 DO_GENOPEN_EXPERIMENTING_CLOEXEC((PIPEFD)[0], PIPEOPEN_CLOEXEC, \
74df577f 180 PIPEOPEN_NORMAL, DO_PIPESETFD_CLOEXEC(PIPEFD))
f9821aff
Z		 181
182int
183Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd)
184{
185#if !defined(PERL_IMPLICIT_SYS) && defined(F_DUPFD_CLOEXEC)
186 /*
187 * struct IPerlLIO doesn't cover fcntl(), and there's no clear way
188 * to extend it, so for the time being this just isn't available on
189 * PERL_IMPLICIT_SYS builds.
190 */
191 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
192 fcntl(oldfd, F_DUPFD_CLOEXEC, 0),
193 PerlLIO_dup(oldfd));
194#else
195 DO_ONEOPEN_THEN_CLOEXEC(PerlLIO_dup(oldfd));
196#endif
197}
198
199int
200Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd)
201{
202#if !defined(PERL_IMPLICIT_SYS) && defined(HAS_DUP3) && defined(O_CLOEXEC)
203 /*
204 * struct IPerlLIO doesn't cover dup3(), and there's no clear way
205 * to extend it, so for the time being this just isn't available on
206 * PERL_IMPLICIT_SYS builds.
207 */
208 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
209 dup3(oldfd, newfd, O_CLOEXEC),
210 PerlLIO_dup2(oldfd, newfd));
211#else
212 DO_ONEOPEN_THEN_CLOEXEC(PerlLIO_dup2(oldfd, newfd));
213#endif
214}
215
216int
217Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag)
218{
219 PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC;
220#if defined(O_CLOEXEC)
221 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
222 PerlLIO_open(file, flag | O_CLOEXEC),
223 PerlLIO_open(file, flag));
224#else
225 DO_ONEOPEN_THEN_CLOEXEC(PerlLIO_open(file, flag));
226#endif
227}
228
229int
230Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm)
231{
232 PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC;
233#if defined(O_CLOEXEC)
234 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
235 PerlLIO_open3(file, flag | O_CLOEXEC, perm),
236 PerlLIO_open3(file, flag, perm));
237#else
238 DO_ONEOPEN_THEN_CLOEXEC(PerlLIO_open3(file, flag, perm));
239#endif
240}
241
1cdb2692
Z		 242int
243Perl_my_mkstemp_cloexec(char *templte)
244{
245 PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC;
246#if defined(O_CLOEXEC)
247 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
248 Perl_my_mkostemp(templte, O_CLOEXEC),
249 Perl_my_mkstemp(templte));
250#else
251 DO_ONEOPEN_THEN_CLOEXEC(Perl_my_mkstemp(templte));
252#endif
253}
254
f9821aff
Z		 255#ifdef HAS_PIPE
256int
257Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd)
258{
259 PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC;
260 /*
261 * struct IPerlProc doesn't cover pipe2(), and there's no clear way
262 * to extend it, so for the time being this just isn't available on
263 * PERL_IMPLICIT_SYS builds.
264 */
265# if !defined(PERL_IMPLICIT_SYS) && defined(HAS_PIPE2) && defined(O_CLOEXEC)
266 DO_PIPEOPEN_EXPERIMENTING_CLOEXEC(pipefd,
267 pipe2(pipefd, O_CLOEXEC),
268 PerlProc_pipe(pipefd));
269# else
270 DO_PIPEOPEN_THEN_CLOEXEC(pipefd, PerlProc_pipe(pipefd));
271# endif
272}
273#endif
274
275#ifdef HAS_SOCKET
276
277int
278Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol)
279{
280# if defined(SOCK_CLOEXEC)
281 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
282 PerlSock_socket(domain, type | SOCK_CLOEXEC, protocol),
283 PerlSock_socket(domain, type, protocol));
284# else
285 DO_ONEOPEN_THEN_CLOEXEC(PerlSock_socket(domain, type, protocol));
286# endif
287}
288
289int
290Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr,
291 Sock_size_t *addrlen)
292{
293# if !defined(PERL_IMPLICIT_SYS) && \
294 defined(HAS_ACCEPT4) && defined(SOCK_CLOEXEC)
295 /*
296 * struct IPerlSock doesn't cover accept4(), and there's no clear
297 * way to extend it, so for the time being this just isn't available
298 * on PERL_IMPLICIT_SYS builds.
299 */
300 DO_ONEOPEN_EXPERIMENTING_CLOEXEC(
301 accept4(listenfd, addr, addrlen, SOCK_CLOEXEC),
302 PerlSock_accept(listenfd, addr, addrlen));
303# else
304 DO_ONEOPEN_THEN_CLOEXEC(PerlSock_accept(listenfd, addr, addrlen));
305# endif
306}
307
308#endif
309
310#if defined (HAS_SOCKETPAIR) || \
311 (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && \
312 defined(AF_INET) && defined(PF_INET))
313int
314Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol,
315 int *pairfd)
316{
317 PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC;
318# ifdef SOCK_CLOEXEC
319 DO_PIPEOPEN_EXPERIMENTING_CLOEXEC(pairfd,
320 PerlSock_socketpair(domain, type | SOCK_CLOEXEC, protocol, pairfd),
321 PerlSock_socketpair(domain, type, protocol, pairfd));
322# else
323 DO_PIPEOPEN_THEN_CLOEXEC(pairfd,
324 PerlSock_socketpair(domain, type, protocol, pairfd));
325# endif
326}
327#endif
328
a2b41d5c
NC		 329static IO *
330S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp,
331 int *savefd, char *savetype)
a567e93b 332{
eb578fdb 333 IO * const io = GvIOn(gv);
a687059c 334
a2b41d5c
NC		 335 PERL_ARGS_ASSERT_OPENN_SETUP;
336
337 *saveifp = NULL;
338 *saveofp = NULL;
339 *savefd = -1;
340 *savetype = IoTYPE_CLOSED;
7918f24d 341
b931b1d9 342 Zero(mode,sizeof(mode),char);
3280af22 343 PL_forkprocess = 1; /* assume true if no fork */
c07a80fd 344
b931b1d9 345 /* If currently open - close before we re-open */
a0d0e21e 346 if (IoIFP(io)) {
ee518936
NIS		 347 if (IoTYPE(io) == IoTYPE_STD) {
348 /* This is a clone of one of STD* handles */
ee518936 349 }
26297fe9
NC		 350 else {
351 const int old_fd = PerlIO_fileno(IoIFP(io));
352
353 if (old_fd >= 0 && old_fd <= PL_maxsysfd) {
354 /* This is one of the original STD* handles */
a2b41d5c
NC		 355 *saveifp = IoIFP(io);
356 *saveofp = IoOFP(io);
357 *savetype = IoTYPE(io);
358 *savefd = old_fd;
26297fe9
NC		 359 }
360 else {
361 int result;
362
363 if (IoTYPE(io) == IoTYPE_PIPE)
364 result = PerlProc_pclose(IoIFP(io));
365 else if (IoIFP(io) != IoOFP(io)) {
366 if (IoOFP(io)) {
367 result = PerlIO_close(IoOFP(io));
368 PerlIO_close(IoIFP(io)); /* clear stdio, fd already closed */
369 }
370 else
371 result = PerlIO_close(IoIFP(io));
372 }
373 else
374 result = PerlIO_close(IoIFP(io));
375
376 if (result == EOF && old_fd > PL_maxsysfd) {
377 /* Why is this not Perl_warn*() call ? */
378 PerlIO_printf(Perl_error_log,
147e3846
KW		 379 "Warning: unable to close filehandle %" HEKf
380 " properly.\n",
26297fe9
NC		 381 HEKfARG(GvENAME_HEK(gv))
382 );
383 }
384 }
385 }
4608196e 386 IoOFP(io) = IoIFP(io) = NULL;
a687059c 387 }
a2b41d5c
NC		 388 return io;
389}
390
391bool
392Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw,
393 int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp,
394 I32 num_svs)
395{
4b451737
NC		 396 PERL_ARGS_ASSERT_DO_OPENN;
397
398 if (as_raw) {
399 /* sysopen style args, i.e. integer mode and permissions */
400
401 if (num_svs != 0) {
402 Perl_croak(aTHX_ "panic: sysopen with multiple args, num_svs=%ld",
403 (long) num_svs);
404 }
7e30e49f 405 return do_open_raw(gv, oname, len, rawmode, rawperm, NULL);
4b451737
NC		 406 }
407 return do_open6(gv, oname, len, supplied_fp, svp, num_svs);
408}
409
410bool
411Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len,
7e30e49f 412 int rawmode, int rawperm, Stat_t *statbufp)
4b451737 413{
a2b41d5c
NC		 414 PerlIO *saveifp;
415 PerlIO *saveofp;
416 int savefd;
417 char savetype;
418 char mode[PERL_MODE_MAX]; /* file mode ("r\0", "rb\0", "ab\0" etc.) */
419 IO * const io = openn_setup(gv, mode, &saveifp, &saveofp, &savefd, &savetype);
420 int writing = 0;
421 PerlIO *fp;
a2b41d5c 422
4b451737 423 PERL_ARGS_ASSERT_DO_OPEN_RAW;
c07a80fd 424
4b451737
NC		 425 /* For ease of blame back to 5.000, keep the existing indenting. */
426 {
b931b1d9 427 /* sysopen style args, i.e. integer mode and permissions */
ee518936 428 STRLEN ix = 0;
e1ec3a88 429 const int appendtrunc =
3dccc55c 430 0
d1da7611 431#ifdef O_APPEND /* Not fully portable. */
3dccc55c 432 |O_APPEND
d1da7611
JH		 433#endif
434#ifdef O_TRUNC /* Not fully portable. */
3dccc55c 435 |O_TRUNC
d1da7611 436#endif
3dccc55c 437 ;
6867be6d 438 const int modifyingmode = O_WRONLY|O_RDWR|O_CREAT|appendtrunc;
3dccc55c 439 int ismodifying;
9229bf8d 440 SV *namesv;
3dccc55c 441
3dccc55c
JH		 442 /* It's not always
443
444 O_RDONLY 0
445 O_WRONLY 1
446 O_RDWR 2
447
448 It might be (in OS/390 and Mac OS Classic it is)
449
450 O_WRONLY 1
451 O_RDONLY 2
452 O_RDWR 3
453
454 This means that simple & with O_RDWR would look
455 like O_RDONLY is present. Therefore we have to
456 be more careful.
457 */
458 if ((ismodifying = (rawmode & modifyingmode))) {
459 if ((ismodifying & O_WRONLY) == O_WRONLY ||
460 (ismodifying & O_RDWR) == O_RDWR ||
461 (ismodifying & (O_CREAT|appendtrunc)))
462 TAINT_PROPER("sysopen");
463 }
3b6c1aba 464 mode[ix++] = IoTYPE_NUMERIC; /* Marker to openn to use numeric "sysopen" */
b931b1d9 465
09458382 466#if defined(USE_64_BIT_RAWIO) && defined(O_LARGEFILE)
b94c04ac 467 rawmode |= O_LARGEFILE; /* Transparently largefiley. */
5ff3f7a4
GS		 468#endif
469
06c7082d 470 IoTYPE(io) = PerlIO_intmode2str(rawmode, &mode[ix], &writing);
ee518936 471
59cd0e26 472 namesv = newSVpvn_flags(oname, len, SVs_TEMP);
4b451737 473 fp = PerlIO_openn(aTHX_ NULL, mode, -1, rawmode, rawperm, NULL, 1, &namesv);
a687059c 474 }
4b451737 475 return openn_cleanup(gv, io, fp, mode, oname, saveifp, saveofp, savefd,
7e30e49f 476 savetype, writing, 0, NULL, statbufp);
4b451737
NC		 477}
478
479bool
480Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len,
481 PerlIO *supplied_fp, SV **svp, U32 num_svs)
482{
4b451737
NC		 483 PerlIO *saveifp;
484 PerlIO *saveofp;
485 int savefd;
486 char savetype;
487 char mode[PERL_MODE_MAX]; /* file mode ("r\0", "rb\0", "ab\0" etc.) */
488 IO * const io = openn_setup(gv, mode, &saveifp, &saveofp, &savefd, &savetype);
489 int writing = 0;
490 PerlIO *fp;
491 bool was_fdopen = FALSE;
492 char *type = NULL;
493
494 PERL_ARGS_ASSERT_DO_OPEN6;
495
496 /* For ease of blame back to 5.000, keep the existing indenting. */
497 {
b931b1d9 498 /* Regular (non-sys) open */
2fbb330f 499 char *name;
faecd977 500 STRLEN olen = len;
b931b1d9
NIS		 501 char *tend;
502 int dodup = 0;
c564b489
NC		 503 bool in_raw = 0, in_crlf = 0, out_raw = 0, out_crlf = 0;
504
505 /* Collect default raw/crlf info from the op */
506 if (PL_op && PL_op->op_type == OP_OPEN) {
507 /* set up IO layers */
508 const U8 flags = PL_op->op_private;
509 in_raw = (flags & OPpOPEN_IN_RAW);
510 in_crlf = (flags & OPpOPEN_IN_CRLF);
511 out_raw = (flags & OPpOPEN_OUT_RAW);
512 out_crlf = (flags & OPpOPEN_OUT_CRLF);
513 }
c07a80fd 514
2fbb330f 515 type = savepvn(oname, len);
b931b1d9 516 tend = type+len;
faecd977 517 SAVEFREEPV(type);
eb649f83
AMS		 518
519 /* Lose leading and trailing white space */
294b3b39
AL		 520 while (isSPACE(*type))
521 type++;
eb649f83
AMS		 522 while (tend > type && isSPACE(tend[-1]))
523 *--tend = '\0';
524
6170680b 525 if (num_svs) {
41188aa0
TC		 526 const char *p;
527 STRLEN nlen = 0;
c2be40b1 528 /* New style explicit name, type is just mode and layer info */
9a869a14 529#ifdef USE_STDIO
9a73c0b8 530 if (SvROK(*svp) && !memchr(oname, '&', len)) {
9a869a14
RGS		 531 if (ckWARN(WARN_IO))
532 Perl_warner(aTHX_ packWARN(WARN_IO),
533 "Can't open a reference");
93189314 534 SETERRNO(EINVAL, LIB_INVARG);
a6fc70e5 535 fp = NULL;
9a869a14
RGS		 536 goto say_false;
537 }
538#endif /* USE_STDIO */
41188aa0
TC		 539 p = (SvOK(*svp) || SvGMAGICAL(*svp)) ? SvPV(*svp, nlen) : NULL;
540
a6fc70e5
NC		 541 if (p && !IS_SAFE_PATHNAME(p, nlen, "open")) {
542 fp = NULL;
c8028aa6 543 goto say_false;
a6fc70e5 544 }
c8028aa6 545
41188aa0
TC		 546 name = p ? savepvn(p, nlen) : savepvs("");
547
faecd977 548 SAVEFREEPV(name);
6170680b 549 }
faecd977 550 else {
faecd977 551 name = type;
b931b1d9 552 len = tend-type;
faecd977 553 }
6170680b 554 IoTYPE(io) = *type;
516a5887 555 if ((*type == IoTYPE_RDWR) && /* scary */
01a8ea99 556 (*(type+1) == IoTYPE_RDONLY || *(type+1) == IoTYPE_WRONLY) &&
516a5887 557 ((!num_svs || (tend > type+1 && tend[-1] != IoTYPE_PIPE)))) {
c2be40b1 558 TAINT_PROPER("open");
6170680b 559 mode[1] = *type++;
c07a80fd 560 writing = 1;
a687059c 561 }
c07a80fd 562
9f37169a 563 if (*type == IoTYPE_PIPE) {
b931b1d9
NIS		 564 if (num_svs) {
565 if (type[1] != IoTYPE_STD) {
c2be40b1 566 unknown_open_mode:
b931b1d9
NIS		 567 Perl_croak(aTHX_ "Unknown open() mode '%.*s'", (int)olen, oname);
568 }
569 type++;
6170680b 570 }
294b3b39
AL		 571 do {
572 type++;
573 } while (isSPACE(*type));
faecd977 574 if (!num_svs) {
6170680b 575 name = type;
b931b1d9 576 len = tend-type;
faecd977 577 }
4a7d1889
NIS		 578 if (*name == '\0') {
579 /* command is missing 19990114 */
06eaf0bc 580 if (ckWARN(WARN_PIPE))
9014280d 581 Perl_warner(aTHX_ packWARN(WARN_PIPE), "Missing command in piped open");
06eaf0bc 582 errno = EPIPE;
a6fc70e5 583 fp = NULL;
06eaf0bc
GS		 584 goto say_false;
585 }
f27977c3 586 if (!(*name == '-' && name[1] == '\0') || num_svs)
c07a80fd 587 TAINT_ENV();
588 TAINT_PROPER("piped open");
b931b1d9 589 if (!num_svs && name[len-1] == '|') {
faecd977 590 name[--len] = '\0' ;
599cee73 591 if (ckWARN(WARN_PIPE))
9014280d 592 Perl_warner(aTHX_ packWARN(WARN_PIPE), "Can't open bidirectional pipe");
7b8d334a 593 }
a1d180c4 594 mode[0] = 'w';
c07a80fd 595 writing = 1;
0c19750d 596 if (out_raw)
5686ee58 597 mode[1] = 'b';
0c19750d 598 else if (out_crlf)
5686ee58 599 mode[1] = 't';
4a7d1889
NIS		 600 if (num_svs > 1) {
601 fp = PerlProc_popen_list(mode, num_svs, svp);
602 }
603 else {
604 fp = PerlProc_popen(name,mode);
605 }
1771866f
NIS		 606 if (num_svs) {
607 if (*type) {
608 if (PerlIO_apply_layers(aTHX_ fp, mode, type) != 0) {
a6fc70e5 609 fp = NULL;
1771866f
NIS		 610 goto say_false;
611 }
612 }
613 }
c2be40b1 614 } /* IoTYPE_PIPE */
9f37169a 615 else if (*type == IoTYPE_WRONLY) {
c07a80fd 616 TAINT_PROPER("open");
6170680b 617 type++;
9f37169a
JH		 618 if (*type == IoTYPE_WRONLY) {
619 /* Two IoTYPE_WRONLYs in a row make for an IoTYPE_APPEND. */
50952442 620 mode[0] = IoTYPE(io) = IoTYPE_APPEND;
6170680b 621 type++;
a0d0e21e 622 }
ee518936 623 else {
c07a80fd 624 mode[0] = 'w';
ee518936 625 }
c07a80fd 626 writing = 1;
627
0c19750d 628 if (out_raw)
5686ee58 629 mode[1] = 'b';
0c19750d 630 else if (out_crlf)
5686ee58 631 mode[1] = 't';
6170680b 632 if (*type == '&') {
c07a80fd 633 duplicity:
ecdeb87c 634 dodup = PERLIO_DUP_FD;
e620cd72
NIS		 635 type++;
636 if (*type == '=') {
c07a80fd 637 dodup = 0;
e620cd72 638 type++;
4a7d1889 639 }
ee518936 640 if (!num_svs && !*type && supplied_fp) {
4a7d1889 641 /* "<+&" etc. is used by typemaps */
c07a80fd 642 fp = supplied_fp;
ee518936 643 }
a0d0e21e 644 else {
35da51f7 645 PerlIO *that_fp = NULL;
b4464d55 646 int wanted_fd;
22ff3130 647 UV uv;
e620cd72 648 if (num_svs > 1) {
fe13d51d 649 /* diag_listed_as: More than one argument to '%s' open */
e620cd72
NIS		 650 Perl_croak(aTHX_ "More than one argument to '%c&' open",IoTYPE(io));
651 }
294b3b39
AL		 652 while (isSPACE(*type))
653 type++;
f90b7232
FC		 654 if (num_svs && (
655 SvIOK(*svp)
656 || (SvPOKp(*svp) && looks_like_number(*svp))
657 )) {
b4464d55 658 wanted_fd = SvUV(*svp);
24a7a40d 659 num_svs = 0;
ee518936 660 }
22ff3130
HS		 661 else if (isDIGIT(*type)
662 && grok_atoUV(type, &uv, NULL)
663 && uv <= INT_MAX
664 ) {
665 wanted_fd = (int)uv;
e620cd72 666 }
c07a80fd 667 else {
e1ec3a88 668 const IO* thatio;
e620cd72
NIS		 669 if (num_svs) {
670 thatio = sv_2io(*svp);
671 }
672 else {
35da51f7 673 GV * const thatgv = gv_fetchpvn_flags(type, tend - type,
90e5519e 674 0, SVt_PVIO);
e620cd72
NIS		 675 thatio = GvIO(thatgv);
676 }
c07a80fd 677 if (!thatio) {
6e21c824 678#ifdef EINVAL
93189314 679 SETERRNO(EINVAL,SS_IVCHAN);
6e21c824 680#endif
a6fc70e5 681 fp = NULL;
c07a80fd 682 goto say_false;
683 }
f4e789af 684 if ((that_fp = IoIFP(thatio))) {
7211d486
JH		 685 /* Flush stdio buffer before dup. --mjd
686 * Unfortunately SEEK_CURing 0 seems to
687 * be optimized away on most platforms;
688 * only Solaris and Linux seem to flush
689 * on that. --jhi */
7211d486
JH		 690 /* On the other hand, do all platforms
691 * take gracefully to flushing a read-only
692 * filehandle? Perhaps we should do
693 * fsetpos(src)+fgetpos(dst)? --nik */
ecdeb87c 694 PerlIO_flush(that_fp);
b4464d55 695 wanted_fd = PerlIO_fileno(that_fp);
0759c907
JH		 696 /* When dup()ing STDIN, STDOUT or STDERR
697 * explicitly set appropriate access mode */
f4e789af
NC		 698 if (that_fp == PerlIO_stdout()
699 || that_fp == PerlIO_stderr())
0759c907 700 IoTYPE(io) = IoTYPE_WRONLY;
f4e789af 701 else if (that_fp == PerlIO_stdin())
0759c907
JH		 702 IoTYPE(io) = IoTYPE_RDONLY;
703 /* When dup()ing a socket, say result is
704 * one as well */
705 else if (IoTYPE(thatio) == IoTYPE_SOCKET)
50952442 706 IoTYPE(io) = IoTYPE_SOCKET;
c07a80fd 707 }
0c9375a5
TC		 708 else {
709 SETERRNO(EBADF, RMS_IFI);
710 fp = NULL;
711 goto say_false;
712 }
a0d0e21e 713 }
ee518936 714 if (!num_svs)
bd61b366 715 type = NULL;
ecdeb87c
NIS		 716 if (that_fp) {
717 fp = PerlIO_fdupopen(aTHX_ that_fp, NULL, dodup);
718 }
719 else {
c07a80fd 720 if (dodup)
884fc2d3 721 wanted_fd = PerlLIO_dup_cloexec(wanted_fd);
ecdeb87c
NIS		 722 else
723 was_fdopen = TRUE;
b4464d55
NC		 724 if (!(fp = PerlIO_openn(aTHX_ type,mode,wanted_fd,0,0,NULL,num_svs,svp))) {
725 if (dodup && wanted_fd >= 0)
726 PerlLIO_close(wanted_fd);
ecdeb87c 727 }
faecd977 728 }
c07a80fd 729 }
ee518936 730 } /* & */
c07a80fd 731 else {
294b3b39
AL		 732 while (isSPACE(*type))
733 type++;
b931b1d9 734 if (*type == IoTYPE_STD && (!type[1] || isSPACE(type[1]) || type[1] == ':')) {
b931b1d9 735 type++;
760ac839 736 fp = PerlIO_stdout();
50952442 737 IoTYPE(io) = IoTYPE_STD;
7cf31beb 738 if (num_svs > 1) {
fe13d51d 739 /* diag_listed_as: More than one argument to '%s' open */
7cf31beb
NIS		 740 Perl_croak(aTHX_ "More than one argument to '>%c' open",IoTYPE_STD);
741 }
c07a80fd 742 }
743 else {
9229bf8d
NC		 744 if (num_svs) {
745 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,num_svs,svp);
746 }
747 else {
748 SV *namesv = newSVpvn_flags(type, tend - type, SVs_TEMP);
bd61b366 749 type = NULL;
9229bf8d 750 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,1,&namesv);
ee518936 751 }
c07a80fd 752 }
ee518936 753 } /* !& */
7e72d509
JH		 754 if (!fp && type && *type && *type != ':' && !isIDFIRST(*type))
755 goto unknown_open_mode;
c2be40b1 756 } /* IoTYPE_WRONLY */
9f37169a 757 else if (*type == IoTYPE_RDONLY) {
294b3b39
AL		 758 do {
759 type++;
760 } while (isSPACE(*type));
bf38876a 761 mode[0] = 'r';
0c19750d 762 if (in_raw)
5686ee58 763 mode[1] = 'b';
0c19750d 764 else if (in_crlf)
5686ee58 765 mode[1] = 't';
6170680b 766 if (*type == '&') {
bf38876a 767 goto duplicity;
6170680b 768 }
b931b1d9 769 if (*type == IoTYPE_STD && (!type[1] || isSPACE(type[1]) || type[1] == ':')) {
b931b1d9 770 type++;
760ac839 771 fp = PerlIO_stdin();
50952442 772 IoTYPE(io) = IoTYPE_STD;
7cf31beb 773 if (num_svs > 1) {
fe13d51d 774 /* diag_listed_as: More than one argument to '%s' open */
7cf31beb
NIS		 775 Perl_croak(aTHX_ "More than one argument to '<%c' open",IoTYPE_STD);
776 }
a687059c 777 }
ee518936 778 else {
9229bf8d
NC		 779 if (num_svs) {
780 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,num_svs,svp);
781 }
782 else {
783 SV *namesv = newSVpvn_flags(type, tend - type, SVs_TEMP);
bd61b366 784 type = NULL;
9229bf8d 785 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,1,&namesv);
ee518936 786 }
ee518936 787 }
7e72d509
JH		 788 if (!fp && type && *type && *type != ':' && !isIDFIRST(*type))
789 goto unknown_open_mode;
c2be40b1
JH		 790 } /* IoTYPE_RDONLY */
791 else if ((num_svs && /* '-|...' or '...|' */
792 type[0] == IoTYPE_STD && type[1] == IoTYPE_PIPE) ||
b931b1d9 793 (!num_svs && tend > type+1 && tend[-1] == IoTYPE_PIPE)) {
6170680b 794 if (num_svs) {
b931b1d9 795 type += 2; /* skip over '-|' */
6170680b
IZ		 796 }
797 else {
b931b1d9
NIS		 798 *--tend = '\0';
799 while (tend > type && isSPACE(tend[-1]))
800 *--tend = '\0';
a6e20a40
AL		 801 for (; isSPACE(*type); type++)
802 ;
6170680b 803 name = type;
b931b1d9 804 len = tend-type;
6170680b 805 }
4a7d1889
NIS		 806 if (*name == '\0') {
807 /* command is missing 19990114 */
06eaf0bc 808 if (ckWARN(WARN_PIPE))
9014280d 809 Perl_warner(aTHX_ packWARN(WARN_PIPE), "Missing command in piped open");
06eaf0bc 810 errno = EPIPE;
a6fc70e5 811 fp = NULL;
06eaf0bc
GS		 812 goto say_false;
813 }
770526c1 814 if (!(*name == '-' && name[1] == '\0') || num_svs)
79072805
LW		 815 TAINT_ENV();
816 TAINT_PROPER("piped open");
a1d180c4 817 mode[0] = 'r';
0c19750d 818
0c19750d 819 if (in_raw)
5686ee58 820 mode[1] = 'b';
0c19750d 821 else if (in_crlf)
5686ee58 822 mode[1] = 't';
0c19750d 823
4a7d1889
NIS		 824 if (num_svs > 1) {
825 fp = PerlProc_popen_list(mode,num_svs,svp);
826 }
e620cd72 827 else {
4a7d1889
NIS		 828 fp = PerlProc_popen(name,mode);
829 }
50952442 830 IoTYPE(io) = IoTYPE_PIPE;
1771866f 831 if (num_svs) {
294b3b39
AL		 832 while (isSPACE(*type))
833 type++;
1771866f
NIS		 834 if (*type) {
835 if (PerlIO_apply_layers(aTHX_ fp, mode, type) != 0) {
a6fc70e5 836 fp = NULL;
1771866f
NIS		 837 goto say_false;
838 }
839 }
840 }
a687059c 841 }
c2be40b1 842 else { /* layer(Args) */
6170680b 843 if (num_svs)
c2be40b1 844 goto unknown_open_mode;
6170680b 845 name = type;
50952442 846 IoTYPE(io) = IoTYPE_RDONLY;
a6e20a40
AL		 847 for (; isSPACE(*name); name++)
848 ;
88b61e10 849 mode[0] = 'r';
0c19750d 850
0c19750d 851 if (in_raw)
5686ee58 852 mode[1] = 'b';
0c19750d 853 else if (in_crlf)
5686ee58 854 mode[1] = 't';
0c19750d 855
770526c1 856 if (*name == '-' && name[1] == '\0') {
760ac839 857 fp = PerlIO_stdin();
50952442 858 IoTYPE(io) = IoTYPE_STD;
a687059c 859 }
16fe6d59 860 else {
9229bf8d
NC		 861 if (num_svs) {
862 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,num_svs,svp);
863 }
864 else {
865 SV *namesv = newSVpvn_flags(type, tend - type, SVs_TEMP);
bd61b366 866 type = NULL;
9229bf8d 867 fp = PerlIO_openn(aTHX_ type,mode,-1,0,0,NULL,1,&namesv);
ee518936 868 }
16fe6d59 869 }
a687059c
LW		 870 }
871 }
a6fc70e5
NC		 872
873 say_false:
874 return openn_cleanup(gv, io, fp, mode, oname, saveifp, saveofp, savefd,
7e30e49f 875 savetype, writing, was_fdopen, type, NULL);
a6fc70e5
NC		 876}
877
878/* Yes, this is ugly, but it's private, and I don't see a cleaner way to
879 simplify the two-headed public interface of do_openn. */
880static bool
881S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname,
882 PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype,
7e30e49f 883 int writing, bool was_fdopen, const char *type, Stat_t *statbufp)
a6fc70e5
NC		 884{
885 int fd;
7e30e49f 886 Stat_t statbuf;
a6fc70e5
NC		 887
888 PERL_ARGS_ASSERT_OPENN_CLEANUP;
889
b1234259
JH		 890 Zero(&statbuf, 1, Stat_t);
891
bee1dbe2 892 if (!fp) {
ce44635a 893 if (IoTYPE(io) == IoTYPE_RDONLY && ckWARN(WARN_NEWLINE)
7cb3f959 894 && should_warn_nl(oname)
ce44635a 895
041457d9 896 )
5d37acd6 897 {
7347ee54 898 GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral); /* PL_warn_nl is constant */
9014280d 899 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "open");
7347ee54 900 GCC_DIAG_RESTORE_STMT;
5d37acd6 901 }
6e21c824 902 goto say_false;
bee1dbe2 903 }
a00b5bd3
NIS		 904
905 if (ckWARN(WARN_IO)) {
906 if ((IoTYPE(io) == IoTYPE_RDONLY) &&
907 (fp == PerlIO_stdout() || fp == PerlIO_stderr())) {
9014280d 908 Perl_warner(aTHX_ packWARN(WARN_IO),
147e3846 909 "Filehandle STD%s reopened as %" HEKf
d0c0e7dd 910 " only for input",
97828cef 911 ((fp == PerlIO_stdout()) ? "OUT" : "ERR"),
d0c0e7dd 912 HEKfARG(GvENAME_HEK(gv)));
a00b5bd3 913 }
ee518936 914 else if ((IoTYPE(io) == IoTYPE_WRONLY) && fp == PerlIO_stdin()) {
9014280d 915 Perl_warner(aTHX_ packWARN(WARN_IO),
147e3846 916 "Filehandle STDIN reopened as %" HEKf " only for output",
d0c0e7dd
FC		 917 HEKfARG(GvENAME_HEK(gv))
918 );
a00b5bd3
NIS		 919 }
920 }
921
e99cca91 922 fd = PerlIO_fileno(fp);
375ed12a
JH		 923 /* Do NOT do: "if (fd < 0) goto say_false;" here. If there is no
924 * fd assume it isn't a socket - this covers PerlIO::scalar -
925 * otherwise unless we "know" the type probe for socket-ness.
e99cca91
NIS		 926 */
927 if (IoTYPE(io) && IoTYPE(io) != IoTYPE_PIPE && IoTYPE(io) != IoTYPE_STD && fd >= 0) {
7e30e49f 928 if (PerlLIO_fstat(fd,&statbuf) < 0) {
e99cca91
NIS		 929 /* If PerlIO claims to have fd we had better be able to fstat() it. */
930 (void) PerlIO_close(fp);
6e21c824 931 goto say_false;
a687059c 932 }
7114a2d2 933#ifndef PERL_MICRO
7e30e49f 934 if (S_ISSOCK(statbuf.st_mode))
50952442 935 IoTYPE(io) = IoTYPE_SOCKET; /* in case a socket was passed in to us */
99b89507
LW		 936#ifdef HAS_SOCKET
937 else if (
7e30e49f 938 !(statbuf.st_mode & S_IFMT)
0759c907
JH		 939 && IoTYPE(io) != IoTYPE_WRONLY /* Dups of STD* filehandles already have */
940 && IoTYPE(io) != IoTYPE_RDONLY /* type so they aren't marked as sockets */
941 ) { /* on OS's that return 0 on fstat()ed pipe */
e99cca91
NIS		 942 char tmpbuf[256];
943 Sock_size_t buflen = sizeof tmpbuf;
944 if (PerlSock_getsockname(fd, (struct sockaddr *)tmpbuf, &buflen) >= 0
945 || errno != ENOTSOCK)
946 IoTYPE(io) = IoTYPE_SOCKET; /* some OS's return 0 on fstat()ed socket */
947 /* but some return 0 for streams too, sigh */
99b89507 948 }
e99cca91 949#endif /* HAS_SOCKET */
7114a2d2 950#endif /* !PERL_MICRO */
a687059c 951 }
e99cca91
NIS		 952
953 /* Eeek - FIXME !!!
954 * If this is a standard handle we discard all the layer stuff
955 * and just dup the fd into whatever was on the handle before !
956 */
957
6e21c824 958 if (saveifp) { /* must use old fp? */
f5b9d040 959 /* If fd is less that PL_maxsysfd i.e. STDIN..STDERR
24c23ab4 960 then dup the new fileno down
f5b9d040 961 */
6e21c824 962 if (saveofp) {
f5b9d040 963 PerlIO_flush(saveofp); /* emulate PerlIO_close() */
6e21c824 964 if (saveofp != saveifp) { /* was a socket? */
760ac839 965 PerlIO_close(saveofp);
6e21c824
LW		 966 }
967 }
6e60e805 968 if (savefd != fd) {
e934609f 969 /* Still a small can-of-worms here if (say) PerlIO::scalar
ecdeb87c
NIS		 970 is assigned to (say) STDOUT - for now let dup2() fail
971 and provide the error
972 */
375ed12a
JH		 973 if (fd < 0) {
974 SETERRNO(EBADF,RMS_IFI);
975 goto say_false;
976 } else if (PerlLIO_dup2(fd, savefd) < 0) {
bd4a5668
NIS		 977 (void)PerlIO_close(fp);
978 goto say_false;
979 }
d082dcd6 980#ifdef VMS
6e60e805 981 if (savefd != PerlIO_fileno(PerlIO_stdin())) {
d0e2cf63
AMS		 982 char newname[FILENAME_MAX+1];
983 if (PerlIO_getname(fp, newname)) {
984 if (fd == PerlIO_fileno(PerlIO_stdout()))
0db50132 985 vmssetuserlnm("SYS$OUTPUT", newname);
d0e2cf63 986 if (fd == PerlIO_fileno(PerlIO_stderr()))
0db50132 987 vmssetuserlnm("SYS$ERROR", newname);
d0e2cf63 988 }
d082dcd6
JH		 989 }
990#endif
d0e2cf63
AMS		 991
992#if !defined(WIN32)
993 /* PL_fdpid isn't used on Windows, so avoid this useless work.
994 * XXX Probably the same for a lot of other places. */
995 {
996 Pid_t pid;
997 SV *sv;
998
d0e2cf63 999 sv = *av_fetch(PL_fdpid,fd,TRUE);
862a34c6 1000 SvUPGRADE(sv, SVt_IV);
d0e2cf63 1001 pid = SvIVX(sv);
45977657 1002 SvIV_set(sv, 0);
d0e2cf63 1003 sv = *av_fetch(PL_fdpid,savefd,TRUE);
862a34c6 1004 SvUPGRADE(sv, SVt_IV);
45977657 1005 SvIV_set(sv, pid);
d0e2cf63
AMS		 1006 }
1007#endif
1008
e212fc47
AMS		 1009 if (was_fdopen) {
1010 /* need to close fp without closing underlying fd */
1011 int ofd = PerlIO_fileno(fp);
884fc2d3 1012 int dupfd = ofd >= 0 ? PerlLIO_dup_cloexec(ofd) : -1;
375ed12a
JH		 1013 if (ofd < 0 || dupfd < 0) {
1014 if (dupfd >= 0)
1015 PerlLIO_close(dupfd);
1016 goto say_false;
1017 }
e212fc47 1018 PerlIO_close(fp);
884fc2d3
Z		 1019 PerlLIO_dup2_cloexec(dupfd, ofd);
1020 setfd_inhexec_for_sysfd(ofd);
e212fc47 1021 PerlLIO_close(dupfd);
ecdeb87c 1022 }
e212fc47
AMS		 1023 else
1024 PerlIO_close(fp);
6e21c824
LW		 1025 }
1026 fp = saveifp;
760ac839 1027 PerlIO_clearerr(fp);
e99cca91 1028 fd = PerlIO_fileno(fp);
6e21c824 1029 }
8990e307 1030 IoIFP(io) = fp;
b931b1d9 1031
684bef36 1032 IoFLAGS(io) &= ~IOf_NOLINE;
bf38876a 1033 if (writing) {
50952442 1034 if (IoTYPE(io) == IoTYPE_SOCKET
7e30e49f 1035 || (IoTYPE(io) == IoTYPE_WRONLY && fd >= 0 && S_ISCHR(statbuf.st_mode)) ) {
a33cf58c 1036 char *s = mode;
3b6c1aba
JH		 1037 if (*s == IoTYPE_IMPLICIT || *s == IoTYPE_NUMERIC)
1038 s++;
a33cf58c 1039 *s = 'w';
7c491510 1040 if (!(IoOFP(io) = PerlIO_openn(aTHX_ type,s,fd,0,0,NULL,0,NULL))) {
760ac839 1041 PerlIO_close(fp);
6e21c824 1042 goto say_false;
fe14fcc3 1043 }
1462b684
LW		 1044 }
1045 else
8990e307 1046 IoOFP(io) = fp;
bf38876a 1047 }
7e30e49f
DIM		 1048 if (statbufp)
1049 *statbufp = statbuf;
1050
a687059c 1051 return TRUE;
6e21c824 1052
7b52d656 1053 say_false:
8990e307
LW		 1054 IoIFP(io) = saveifp;
1055 IoOFP(io) = saveofp;
1056 IoTYPE(io) = savetype;
6e21c824 1057 return FALSE;
a687059c
LW		 1058}
1059
e0d4aead
TC		 1060/* Open a temp file in the same directory as an original name.
1061*/
1062
1063static bool
1064S_openindirtemp(pTHX_ GV *gv, SV *orig_name, SV *temp_out_name) {
1065 int fd;
1066 PerlIO *fp;
1067 const char *p = SvPV_nolen(orig_name);
1068 const char *sep;
1069
1070 /* look for the last directory separator */
1071 sep = strrchr(p, '/');
1072
1073#ifdef DOSISH
1074 {
1075 const char *sep2;
1076 if ((sep2 = strrchr(sep ? sep : p, '\\')))
1077 sep = sep2;
1078 }
1079#endif
1080#ifdef VMS
1081 if (!sep) {
1082 const char *openp = strchr(p, '[');
1083 if (openp)
1084 sep = strchr(openp, ']');
1085 else {
1086 sep = strchr(p, ':');
1087 }
1088 }
1089#endif
1090 if (sep) {
1091 sv_setpvn(temp_out_name, p, sep - p + 1);
1092 sv_catpvs(temp_out_name, "XXXXXXXX");
1093 }
1094 else
1095 sv_setpvs(temp_out_name, "XXXXXXXX");
1096
026633c6
JH		 1097 {
1098 int old_umask = umask(0177);
884fc2d3 1099 fd = Perl_my_mkstemp_cloexec(SvPVX(temp_out_name));
026633c6
JH		 1100 umask(old_umask);
1101 }
e0d4aead
TC		 1102
1103 if (fd < 0)
1104 return FALSE;
1105
1106 fp = PerlIO_fdopen(fd, "w+");
1107 if (!fp)
1108 return FALSE;
1109
1110 return do_openn(gv, "+>&", 3, 0, 0, 0, fp, NULL, 0);
1111}
1112
733612e0 1113#if defined(HAS_UNLINKAT) && defined(HAS_RENAMEAT) && defined(HAS_FCHMODAT) && \
c3fcee07
JK		 1114 (defined(HAS_DIRFD) || defined(HAS_DIR_DD_FD)) && !defined(NO_USE_ATFUNCTIONS) && \
1115 defined(HAS_LINKAT)
733612e0
TC		 1116# define ARGV_USE_ATFUNCTIONS
1117#endif
1118
1b4d0d79
TC		 1119/* Win32 doesn't necessarily return useful information
1120 * in st_dev, st_ino.
1121 */
184f90dc
TC		 1122#ifndef DOSISH
1123# define ARGV_USE_STAT_INO
1b4d0d79
TC		 1124#endif
1125
e0d4aead
TC		 1126#define ARGVMG_BACKUP_NAME 0
1127#define ARGVMG_TEMP_NAME 1
1128#define ARGVMG_ORIG_NAME 2
1129#define ARGVMG_ORIG_MODE 3
05df5c88 1130#define ARGVMG_ORIG_PID 4
bb082417 1131
bb082417
TC		 1132/* we store the entire stat_t since the ino_t and dev_t values might
1133 not fit in an IV. I could have created a new structure and
1134 transferred them across, but this seemed too much effort for very
1135 little win.
184f90dc
TC		 1136
1137 We store it even when the *at() functions are available, since
1138 while the C runtime might have definitions for these functions, the
1139 operating system or a specific filesystem might not implement them.
1140 eg. NetBSD 6 implements linkat() but only where the fds are AT_FDCWD.
bb082417 1141 */
184f90dc
TC		 1142#ifdef ARGV_USE_STAT_INO
1143# define ARGVMG_ORIG_CWD_STAT 5
1144#endif
1145
1146#ifdef ARGV_USE_ATFUNCTIONS
1147# define ARGVMG_ORIG_DIRP 6
1148#endif
1149
1150#ifdef ENOTSUP
1151#define NotSupported(e) ((e) == ENOSYS || (e) == ENOTSUP)
1152#else
1153#define NotSupported(e) ((e) == ENOSYS)
bb082417 1154#endif
e0d4aead
TC		 1155
1156static int
d0405818 1157S_argvout_free(pTHX_ SV *io, MAGIC *mg) {
d0405818 1158 PERL_UNUSED_ARG(io);
e0d4aead
TC		 1159
1160 /* note this can be entered once the file has been
1161 successfully deleted too */
d0405818
TC		 1162 assert(IoTYPE(io) != IoTYPE_PIPE);
1163
8ab93df0
TC		 1164 /* mg_obj can be NULL if a thread is created with the handle open, in which
1165 case we leave any clean up to the parent thread */
3d5e9c11 1166 if (mg->mg_obj) {
733612e0
TC		 1167#ifdef ARGV_USE_ATFUNCTIONS
1168 SV **dir_psv;
1169 DIR *dir;
3d5e9c11
TC		 1170
1171 dir_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_DIRP, FALSE);
1172 assert(dir_psv && *dir_psv && SvIOK(*dir_psv));
1173 dir = INT2PTR(DIR *, SvIV(*dir_psv));
733612e0 1174#endif
3d5e9c11 1175 if (IoIFP(io)) {
85d2f7ca
TC		 1176 if (PL_phase == PERL_PHASE_DESTRUCT && PL_statusvalue == 0) {
1177 (void)argvout_final(mg, (IO*)io, FALSE);
1178 }
1179 else {
1180 SV **pid_psv;
1181 PerlIO *iop = IoIFP(io);
05df5c88 1182
85d2f7ca 1183 assert(SvTYPE(mg->mg_obj) == SVt_PVAV);
05df5c88 1184
85d2f7ca 1185 pid_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_PID, FALSE);
05df5c88 1186
85d2f7ca 1187 assert(pid_psv && *pid_psv);
05df5c88 1188
85d2f7ca
TC		 1189 if (SvIV(*pid_psv) == (IV)PerlProc_getpid()) {
1190 /* if we get here the file hasn't been closed explicitly by the
1191 user and hadn't been closed implicitly by nextargv(), so
1192 abandon the edit */
1193 SV **temp_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_TEMP_NAME, FALSE);
1194 const char *temp_pv = SvPVX(*temp_psv);
184f90dc 1195
85d2f7ca
TC		 1196 assert(temp_psv && *temp_psv && SvPOK(*temp_psv));
1197 (void)PerlIO_close(iop);
1198 IoIFP(io) = IoOFP(io) = NULL;
733612e0 1199#ifdef ARGV_USE_ATFUNCTIONS
85d2f7ca
TC		 1200 if (dir) {
1201 if (unlinkat(my_dirfd(dir), temp_pv, 0) < 0 &&
1202 NotSupported(errno))
1203 (void)UNLINK(temp_pv);
1204 }
733612e0 1205#else
85d2f7ca 1206 (void)UNLINK(temp_pv);
733612e0 1207#endif
85d2f7ca 1208 }
3d5e9c11 1209 }
05df5c88 1210 }
3d5e9c11
TC		 1211#ifdef ARGV_USE_ATFUNCTIONS
1212 if (dir)
1213 closedir(dir);
1214#endif
e0d4aead
TC		 1215 }
1216
1217 return 0;
1218}
1219
8ab93df0
TC		 1220static int
1221S_argvout_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *param) {
1222 PERL_UNUSED_ARG(param);
1223
1224 /* ideally we could just remove the magic from the SV but we don't get the SV here */
1225 SvREFCNT_dec(mg->mg_obj);
1226 mg->mg_obj = NULL;
1227
1228 return 0;
1229}
1230
e0d4aead
TC		 1231/* Magic of this type has an AV containing the following:
1232 0: name of the backup file (if any)
1233 1: name of the temp output file
1234 2: name of the original file
1235 3: file mode of the original file
05df5c88
TC		 1236 4: pid of the process we opened at, to prevent doing the renaming
1237 etc in both the child and the parent after a fork
733612e0 1238
184f90dc
TC		 1239If we have useful inode/device ids in stat_t we also keep:
1240 5: a stat of the original current working directory
1241
733612e0 1242If we have unlinkat(), renameat(), fchmodat(), dirfd() we also keep:
184f90dc 1243 6: the DIR * for the current directory when we open the file, stored as an IV
e0d4aead
TC		 1244 */
1245
1246static const MGVTBL argvout_vtbl =
1247 {
1248 NULL, /* svt_get */
1249 NULL, /* svt_set */
1250 NULL, /* svt_len */
1251 NULL, /* svt_clear */
1252 S_argvout_free, /* svt_free */
1253 NULL, /* svt_copy */
8ab93df0
TC		 1254 S_argvout_dup, /* svt_dup */
1255 NULL /* svt_local */
e0d4aead
TC		 1256 };
1257
760ac839 1258PerlIO *
157fb5a1 1259Perl_nextargv(pTHX_ GV *gv, bool nomagicopen)
a687059c 1260{
2d03de9c 1261 IO * const io = GvIOp(gv);
502aca56 1262 SV *const old_out_name = PL_inplace ? newSVsv(GvSV(gv)) : NULL;
fe14fcc3 1263
7918f24d
NC		 1264 PERL_ARGS_ASSERT_NEXTARGV;
1265
502aca56
TC		 1266 if (old_out_name)
1267 SAVEFREESV(old_out_name);
1268
3280af22 1269 if (!PL_argvoutgv)
fafc274c 1270 PL_argvoutgv = gv_fetchpvs("ARGVOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
5513c2cf 1271 if (io && (IoFLAGS(io) & (IOf_ARGV|IOf_START)) == (IOf_ARGV|IOf_START)) {
18708f5a 1272 IoFLAGS(io) &= ~IOf_START;
7a1c5554 1273 if (PL_inplace) {
294b3b39 1274 assert(PL_defoutgv);
29a861e7
NC		 1275 Perl_av_create_and_push(aTHX_ &PL_argvout_stack,
1276 SvREFCNT_inc_simple_NN(PL_defoutgv));
7a1c5554 1277 }
18708f5a 1278 }
e0d4aead
TC		 1279
1280 {
1281 IO * const io = GvIOp(PL_argvoutgv);
1282 if (io && IoIFP(io) && old_out_name) {
1283 do_close(PL_argvoutgv, FALSE);
1284 }
fe14fcc3 1285 }
e0d4aead 1286
c797f2d8 1287 PL_lastfd = -1;
3280af22 1288 PL_filemode = 0;
5c501b37 1289 if (!GvAV(gv))
4608196e 1290 return NULL;
b9f2b683 1291 while (av_tindex(GvAV(gv)) >= 0) {
85aff577 1292 STRLEN oldlen;
1fa0529f 1293 SV *const sv = av_shift(GvAV(gv));
8990e307 1294 SAVEFREESV(sv);
4bac9ae4 1295 SvTAINTED_off(GvSVn(gv)); /* previous tainting irrelevant */
e203899d 1296 sv_setsv(GvSVn(gv),sv);
79072805 1297 SvSETMAGIC(GvSV(gv));
3280af22 1298 PL_oldname = SvPVx(GvSV(gv), oldlen);
d8015975 1299 if (LIKELY(!PL_inplace)) {
157fb5a1
RGS		 1300 if (nomagicopen
1301 ? do_open6(gv, "<", 1, NULL, &GvSV(gv), 1)
1302 : do_open6(gv, PL_oldname, oldlen, NULL, NULL, 0)
1303 ) {
d8015975
NC		 1304 return IoIFP(GvIOp(gv));
1305 }
1306 }
1307 else {
7e30e49f 1308 Stat_t statbuf;
d8015975
NC		 1309 /* This very long block ends with return IoIFP(GvIOp(gv));
1310 Both this block and the block above fall through on open
1311 failure to the warning code, and then the while loop above tries
1312 the next entry. */
7e30e49f 1313 if (do_open_raw(gv, PL_oldname, oldlen, O_RDONLY, 0, &statbuf)) {
1fa0529f
NC		 1314#ifndef FLEXFILENAMES
1315 int filedev;
1316 int fileino;
1317#endif
733612e0
TC		 1318#ifdef ARGV_USE_ATFUNCTIONS
1319 DIR *curdir;
1320#endif
1fa0529f
NC		 1321 Uid_t fileuid;
1322 Gid_t filegid;
e0d4aead
TC		 1323 AV *magic_av = NULL;
1324 SV *temp_name_sv = NULL;
8ab93df0 1325 MAGIC *mg;
1fa0529f 1326
79072805 1327 TAINT_PROPER("inplace open");
3280af22 1328 if (oldlen == 1 && *PL_oldname == '-') {
fafc274c
NC		 1329 setdefout(gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL,
1330 SVt_PVIO));
a0d0e21e 1331 return IoIFP(GvIOp(gv));
c623bd54 1332 }
99b89507 1333#ifndef FLEXFILENAMES
7e30e49f
DIM		 1334 filedev = statbuf.st_dev;
1335 fileino = statbuf.st_ino;
99b89507 1336#endif
7e30e49f
DIM		 1337 PL_filemode = statbuf.st_mode;
1338 fileuid = statbuf.st_uid;
1339 filegid = statbuf.st_gid;
3280af22 1340 if (!S_ISREG(PL_filemode)) {
9b387841
NC		 1341 Perl_ck_warner_d(aTHX_ packWARN(WARN_INPLACE),
1342 "Can't do inplace edit: %s is not a regular file",
1343 PL_oldname );
79072805 1344 do_close(gv,FALSE);
c623bd54
LW		 1345 continue;
1346 }
e0d4aead 1347 magic_av = newAV();
c9930541 1348 if (*PL_inplace && strNE(PL_inplace, "*")) {
2d03de9c 1349 const char *star = strchr(PL_inplace, '*');
2d259d92 1350 if (star) {
2d03de9c 1351 const char *begin = PL_inplace;
8062ff11 1352 SvPVCLEAR(sv);
2d259d92
CK		 1353 do {
1354 sv_catpvn(sv, begin, star - begin);
3280af22 1355 sv_catpvn(sv, PL_oldname, oldlen);
2d259d92
CK		 1356 begin = ++star;
1357 } while ((star = strchr(begin, '*')));
3d66d7bb
GS		 1358 if (*begin)
1359 sv_catpv(sv,begin);
2d259d92
CK		 1360 }
1361 else {
3280af22 1362 sv_catpv(sv,PL_inplace);
2d259d92 1363 }
c623bd54 1364#ifndef FLEXFILENAMES
7e30e49f
DIM		 1365 if ((PerlLIO_stat(SvPVX_const(sv),&statbuf) >= 0
1366 && statbuf.st_dev == filedev
1367 && statbuf.st_ino == fileino)
39e571d4 1368#ifdef DJGPP
5f74f29c 1369 || ((_djstat_fail_bits & _STFAIL_TRUENAME)!=0)
39e571d4 1370#endif
f248d071
GS		 1371 )
1372 {
9b387841 1373 Perl_ck_warner_d(aTHX_ packWARN(WARN_INPLACE),
147e3846
KW		 1374 "Can't do inplace edit: %"
1375 SVf " would not be unique",
9b387841 1376 SVfARG(sv));
e0d4aead 1377 goto cleanup_argv;
c623bd54 1378 }
ff8e2863 1379#endif
e0d4aead 1380 av_store(magic_av, ARGVMG_BACKUP_NAME, newSVsv(sv));
a687059c
LW		 1381 }
1382
30fc4309 1383 sv_setpvn(sv,PL_oldname,oldlen);
748a9306 1384 SETERRNO(0,0); /* in case sprintf set errno */
e0d4aead
TC		 1385 temp_name_sv = newSV(0);
1386 if (!S_openindirtemp(aTHX_ PL_argvoutgv, GvSV(gv), temp_name_sv)) {
1387 SvREFCNT_dec(temp_name_sv);
1388 /* diag_listed_as: Can't do inplace edit on %s: %s */
1389 Perl_ck_warner_d(aTHX_ packWARN(WARN_INPLACE), "Can't do inplace edit on %s: Cannot make temp name: %s",
9b387841 1390 PL_oldname, Strerror(errno) );
e0d4aead
TC		 1391#ifndef FLEXFILENAMES
1392 cleanup_argv:
1393#endif
1394 do_close(gv,FALSE);
1395 SvREFCNT_dec(magic_av);
1396 continue;
fe14fcc3 1397 }
e0d4aead
TC		 1398 av_store(magic_av, ARGVMG_TEMP_NAME, temp_name_sv);
1399 av_store(magic_av, ARGVMG_ORIG_NAME, newSVsv(sv));
1400 av_store(magic_av, ARGVMG_ORIG_MODE, newSVuv(PL_filemode));
05df5c88 1401 av_store(magic_av, ARGVMG_ORIG_PID, newSViv((IV)PerlProc_getpid()));
1b4d0d79 1402#if defined(ARGV_USE_ATFUNCTIONS)
733612e0
TC		 1403 curdir = opendir(".");
1404 av_store(magic_av, ARGVMG_ORIG_DIRP, newSViv(PTR2IV(curdir)));
1b4d0d79 1405#elif defined(ARGV_USE_STAT_INO)
bb082417
TC		 1406 if (PerlLIO_stat(".", &statbuf) >= 0) {
1407 av_store(magic_av, ARGVMG_ORIG_CWD_STAT,
1408 newSVpvn((char *)&statbuf, sizeof(statbuf)));
1409 }
733612e0 1410#endif
3280af22 1411 setdefout(PL_argvoutgv);
dddabd86 1412 sv_setsv(GvSVn(PL_argvoutgv), temp_name_sv);
8ab93df0
TC		 1413 mg = sv_magicext((SV*)GvIOp(PL_argvoutgv), (SV*)magic_av, PERL_MAGIC_uvar, &argvout_vtbl, NULL, 0);
1414 mg->mg_flags |= MGf_DUP;
e0d4aead 1415 SvREFCNT_dec(magic_av);
3280af22 1416 PL_lastfd = PerlIO_fileno(IoIFP(GvIOp(PL_argvoutgv)));
375ed12a 1417 if (PL_lastfd >= 0) {
45a23732 1418 (void)PerlLIO_fstat(PL_lastfd,&statbuf);
fe14fcc3 1419#ifdef HAS_FCHMOD
375ed12a 1420 (void)fchmod(PL_lastfd,PL_filemode);
a687059c 1421#else
375ed12a 1422 (void)PerlLIO_chmod(PL_oldname,PL_filemode);
a687059c 1423#endif
45a23732 1424 if (fileuid != statbuf.st_uid || filegid != statbuf.st_gid) {
b469f1e0 1425 /* XXX silently ignore failures */
fe14fcc3 1426#ifdef HAS_FCHOWN
b469f1e0 1427 PERL_UNUSED_RESULT(fchown(PL_lastfd,fileuid,filegid));
4009c3ff 1428#elif defined(HAS_CHOWN)
b469f1e0 1429 PERL_UNUSED_RESULT(PerlLIO_chown(PL_oldname,fileuid,filegid));
a687059c 1430#endif
375ed12a 1431 }
fe14fcc3 1432 }
d8015975 1433 return IoIFP(GvIOp(gv));
a687059c 1434 }
d8015975
NC		 1435 } /* successful do_open_raw(), PL_inplace non-NULL */
1436
1437 if (ckWARN_d(WARN_INPLACE)) {
1438 const int eno = errno;
7e30e49f 1439 Stat_t statbuf;
45a23732
DD		 1440 if (PerlLIO_stat(PL_oldname, &statbuf) >= 0
1441 && !S_ISREG(statbuf.st_mode)) {
d8015975
NC		 1442 Perl_warner(aTHX_ packWARN(WARN_INPLACE),
1443 "Can't do inplace edit: %s is not a regular file",
1444 PL_oldname);
1445 }
1446 else {
1447 Perl_warner(aTHX_ packWARN(WARN_INPLACE), "Can't open %s: %s",
1448 PL_oldname, Strerror(eno));
1449 }
4d61ec05 1450 }
a687059c 1451 }
18708f5a
GS		 1452 if (io && (IoFLAGS(io) & IOf_ARGV))
1453 IoFLAGS(io) |= IOf_START;
3280af22 1454 if (PL_inplace) {
7a1c5554
GS		 1455 if (io && (IoFLAGS(io) & IOf_ARGV)
1456 && PL_argvout_stack && AvFILLp(PL_argvout_stack) >= 0)
1457 {
159b6efe 1458 GV * const oldout = MUTABLE_GV(av_pop(PL_argvout_stack));
18708f5a 1459 setdefout(oldout);
8e217d4a 1460 SvREFCNT_dec_NN(oldout);
4608196e 1461 return NULL;
18708f5a 1462 }
fafc274c 1463 setdefout(gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO));
a687059c 1464 }
4608196e 1465 return NULL;
a687059c
LW		 1466}
1467
84dbe61c 1468#ifdef ARGV_USE_ATFUNCTIONS
a3c63a94 1469# if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
84dbe61c
TC		 1470
1471/* FreeBSD 11 renameat() mis-behaves strangely with absolute paths in cases where the
1472 * equivalent rename() succeeds
1473 */
1474static int
1475S_my_renameat(int olddfd, const char *oldpath, int newdfd, const char *newpath) {
1476 /* this is intended only for use in Perl_do_close() */
1477 assert(olddfd == newdfd);
1478 assert(PERL_FILE_IS_ABSOLUTE(oldpath) == PERL_FILE_IS_ABSOLUTE(newpath));
1479 if (PERL_FILE_IS_ABSOLUTE(oldpath)) {
1480 return PerlLIO_rename(oldpath, newpath);
1481 }
1482 else {
1483 return renameat(olddfd, oldpath, newdfd, newpath);
1484 }
1485}
1486
1487# else
1488# define S_my_renameat(dh1, pv1, dh2, pv2) renameat((dh1), (pv1), (dh2), (pv2))
a3c63a94 1489# endif /* if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) */
84dbe61c
TC		 1490#endif
1491
184f90dc 1492static bool
848643a9 1493S_dir_unchanged(pTHX_ const char *orig_pv, MAGIC *mg) {
184f90dc
TC		 1494 Stat_t statbuf;
1495
1496#ifdef ARGV_USE_STAT_INO
1497 SV **stat_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_CWD_STAT, FALSE);
1498 Stat_t *orig_cwd_stat = stat_psv && *stat_psv ? (Stat_t *)SvPVX(*stat_psv) : NULL;
1499
1500 /* if the path is absolute the possible moving of cwd (which the file
1501 might be in) isn't our problem.
1502 This code tries to be reasonably balanced about detecting a changed
1503 CWD, if we have the information needed to check that curdir has changed, we
1504 check it
1505 */
1506 if (!PERL_FILE_IS_ABSOLUTE(orig_pv)
1507 && orig_cwd_stat
1508 && PerlLIO_stat(".", &statbuf) >= 0
1509 && ( statbuf.st_dev != orig_cwd_stat->st_dev
1510 || statbuf.st_ino != orig_cwd_stat->st_ino)) {
1511 Perl_croak(aTHX_ "Cannot complete in-place edit of %s: %s",
1512 orig_pv, "Current directory has changed");
1513 }
1514#else
1515 SV **temp_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_TEMP_NAME, FALSE);
1516
1517 /* Some platforms don't have useful st_ino etc, so just
1518 check we can see the work file.
1519 */
1520 if (!PERL_FILE_IS_ABSOLUTE(orig_pv)
1521 && PerlLIO_stat(SvPVX(*temp_psv), &statbuf) < 0) {
3c67ad9b 1522 Perl_croak(aTHX_ "Cannot complete in-place edit of %s: %s",
a06de4dc 1523 orig_pv,
184f90dc
TC		 1524 "Work file is missing - did you change directory?");
1525 }
1526#endif
1527
1528 return TRUE;
1529}
1530
848643a9
TC		 1531#define dir_unchanged(orig_psv, mg) \
1532 S_dir_unchanged(aTHX_ (orig_psv), (mg))
184f90dc 1533
404395d2
TC		 1534STATIC bool
1535S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool not_implicit) {
1193dd27 1536 bool retval;
a687059c 1537
404395d2
TC		 1538 /* ensure args are checked before we start using them */
1539 PERL_ARGS_ASSERT_ARGVOUT_FINAL;
1540
1541 {
e0d4aead
TC		 1542 /* handle to an in-place edit work file */
1543 SV **back_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_BACKUP_NAME, FALSE);
1544 SV **temp_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_TEMP_NAME, FALSE);
1545 /* PL_oldname may have been modified by a nested ARGV use at this point */
1546 SV **orig_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_NAME, FALSE);
1547 SV **mode_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_MODE, FALSE);
05df5c88 1548 SV **pid_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_PID, FALSE);
1b4d0d79 1549#if defined(ARGV_USE_ATFUNCTIONS)
05df5c88 1550 SV **dir_psv = av_fetch((AV*)mg->mg_obj, ARGVMG_ORIG_DIRP, FALSE);
733612e0
TC		 1551 DIR *dir;
1552 int dfd;
1b4d0d79 1553#endif
e0d4aead
TC		 1554 UV mode;
1555 int fd;
1556
1557 const char *orig_pv;
1558
1559 assert(temp_psv && *temp_psv);
1560 assert(orig_psv && *orig_psv);
1561 assert(mode_psv && *mode_psv);
05df5c88 1562 assert(pid_psv && *pid_psv);
733612e0
TC		 1563#ifdef ARGV_USE_ATFUNCTIONS
1564 assert(dir_psv && *dir_psv);
1565 dir = INT2PTR(DIR *, SvIVX(*dir_psv));
1566 dfd = my_dirfd(dir);
1567#endif
e0d4aead
TC		 1568
1569 orig_pv = SvPVX(*orig_psv);
e0d4aead
TC		 1570 mode = SvUV(*mode_psv);
1571
1572 if ((mode & (S_ISUID|S_ISGID)) != 0
1573 && (fd = PerlIO_fileno(IoIFP(io))) >= 0) {
1574 (void)PerlIO_flush(IoIFP(io));
1575#ifdef HAS_FCHMOD
1576 (void)fchmod(fd, mode);
1577#else
1578 (void)PerlLIO_chmod(orig_pv, mode);
1579#endif
1580 }
1581
1582 retval = io_close(io, NULL, not_implicit, FALSE);
1583
05df5c88
TC		 1584 if (SvIV(*pid_psv) != (IV)PerlProc_getpid()) {
1585 /* this is a child process, don't duplicate our rename() etc
1586 processing below */
1587 goto freext;
1588 }
1589
e0d4aead
TC		 1590 if (retval) {
1591#if defined(DOSISH) || defined(__CYGWIN__)
1592 if (PL_argvgv && GvIOp(PL_argvgv)
1593 && IoIFP(GvIOp(PL_argvgv))
1594 && (IoFLAGS(GvIOp(PL_argvgv)) & (IOf_ARGV|IOf_START)) == IOf_ARGV) {
1595 do_close(PL_argvgv, FALSE);
1596 }
1597#endif
184f90dc 1598#ifndef ARGV_USE_ATFUNCTIONS
848643a9 1599 if (!dir_unchanged(orig_pv, mg))
184f90dc
TC		 1600 goto abort_inplace;
1601#endif
e0d4aead
TC		 1602 if (back_psv && *back_psv) {
1603#if defined(HAS_LINK) && !defined(DOSISH) && !defined(__CYGWIN__) && defined(HAS_RENAME)
733612e0
TC		 1604 if (
1605# ifdef ARGV_USE_ATFUNCTIONS
184f90dc
TC		 1606 linkat(dfd, orig_pv, dfd, SvPVX(*back_psv), 0) < 0 &&
1607 !(UNLIKELY(NotSupported(errno)) &&
848643a9 1608 dir_unchanged(orig_pv, mg) &&
184f90dc 1609 link(orig_pv, SvPVX(*back_psv)) == 0)
733612e0
TC		 1610# else
1611 link(orig_pv, SvPVX(*back_psv)) < 0
1612# endif
1613 )
e0d4aead
TC		 1614#endif
1615 {
1616#ifdef HAS_RENAME
733612e0
TC		 1617 if (
1618# ifdef ARGV_USE_ATFUNCTIONS
184f90dc
TC		 1619 S_my_renameat(dfd, orig_pv, dfd, SvPVX(*back_psv)) < 0 &&
1620 !(UNLIKELY(NotSupported(errno)) &&
848643a9 1621 dir_unchanged(orig_pv, mg) &&
184f90dc 1622 PerlLIO_rename(orig_pv, SvPVX(*back_psv)) == 0)
733612e0
TC		 1623# else
1624 PerlLIO_rename(orig_pv, SvPVX(*back_psv)) < 0
1625# endif
1626 ) {
e0d4aead 1627 if (!not_implicit) {
83419aa9 1628# ifdef ARGV_USE_ATFUNCTIONS
184f90dc
TC		 1629 if (unlinkat(dfd, SvPVX_const(*temp_psv), 0) < 0 &&
1630 UNLIKELY(NotSupported(errno)) &&
848643a9 1631 dir_unchanged(orig_pv, mg))
184f90dc 1632 (void)UNLINK(SvPVX_const(*temp_psv));
83419aa9
TC		 1633# else
1634 UNLINK(SvPVX(*temp_psv));
1635# endif
e0d4aead
TC		 1636 Perl_croak(aTHX_ "Can't rename %s to %s: %s, skipping file",
1637 SvPVX(*orig_psv), SvPVX(*back_psv), Strerror(errno));
1638 }
1639 /* should we warn here? */
1640 goto abort_inplace;
1641 }
1642#else
1643 (void)UNLINK(SvPVX(*back_psv));
1644 if (link(orig_pv, SvPVX(*back_psv))) {
1645 if (!not_implicit) {
1646 Perl_croak(aTHX_ "Can't rename %s to %s: %s, skipping file",
1647 SvPVX(*orig_psv), SvPVX(*back_psv), Strerror(errno));
1648 }
1649 goto abort_inplace;
1650 }
1651 /* we need to use link() to get the temp into place too, and linK()
1652 fails if the new link name exists */
1653 (void)UNLINK(orig_pv);
1654#endif
1655 }
1656 }
1657#if defined(DOSISH) || defined(__CYGWIN__) || !defined(HAS_RENAME)
1658 else {
1659 UNLINK(orig_pv);
1660 }
1661#endif
1662 if (
4009c3ff
AC		 1663#if !defined(HAS_RENAME)
1664 link(SvPVX(*temp_psv), orig_pv) < 0
1665#elif defined(ARGV_USE_ATFUNCTIONS)
184f90dc
TC		 1666 S_my_renameat(dfd, SvPVX(*temp_psv), dfd, orig_pv) < 0 &&
1667 !(UNLIKELY(NotSupported(errno)) &&
848643a9 1668 dir_unchanged(orig_pv, mg) &&
184f90dc 1669 PerlLIO_rename(SvPVX(*temp_psv), orig_pv) == 0)
e0d4aead 1670#else
4009c3ff 1671 PerlLIO_rename(SvPVX(*temp_psv), orig_pv) < 0
e0d4aead
TC		 1672#endif
1673 ) {
1674 if (!not_implicit) {
dddabd86 1675#ifdef ARGV_USE_ATFUNCTIONS
184f90dc
TC		 1676 if (unlinkat(dfd, SvPVX_const(*temp_psv), 0) < 0 &&
1677 NotSupported(errno))
1678 UNLINK(SvPVX(*temp_psv));
dddabd86
TC		 1679#else
1680 UNLINK(SvPVX(*temp_psv));
1681#endif
3c67ad9b
TC		 1682 /* diag_listed_as: Cannot complete in-place edit of %s: %s */
1683 Perl_croak(aTHX_ "Cannot complete in-place edit of %s: failed to rename work file '%s' to '%s': %s",
1684 orig_pv, SvPVX(*temp_psv), orig_pv, Strerror(errno));
e0d4aead
TC		 1685 }
1686 abort_inplace:
1687 UNLINK(SvPVX_const(*temp_psv));
1688 retval = FALSE;
1689 }
1690#ifndef HAS_RENAME
1691 UNLINK(SvPVX(*temp_psv));
1692#endif
1693 }
1694 else {
733612e0 1695#ifdef ARGV_USE_ATFUNCTIONS
184f90dc
TC		 1696 if (unlinkat(dfd, SvPVX_const(*temp_psv), 0) &&
1697 NotSupported(errno))
1698 UNLINK(SvPVX_const(*temp_psv));
1699
733612e0 1700#else
e0d4aead 1701 UNLINK(SvPVX_const(*temp_psv));
733612e0 1702#endif
e0d4aead
TC		 1703 if (!not_implicit) {
1704 Perl_croak(aTHX_ "Failed to close in-place work file %s: %s",
1705 SvPVX(*temp_psv), Strerror(errno));
1706 }
1707 }
404395d2
TC		 1708 freext:
1709 ;
1710 }
1711 return retval;
1712}
1713
1714/* explicit renamed to avoid C++ conflict -- kja */
1715bool
1716Perl_do_close(pTHX_ GV *gv, bool not_implicit)
1717{
1718 bool retval;
1719 IO *io;
1720 MAGIC *mg;
1721
1722 if (!gv)
1723 gv = PL_argvgv;
1724 if (!gv || !isGV_with_GP(gv)) {
1725 if (not_implicit)
1726 SETERRNO(EBADF,SS_IVCHAN);
1727 return FALSE;
1728 }
1729 io = GvIO(gv);
1730 if (!io) { /* never opened */
1731 if (not_implicit) {
1732 report_evil_fh(gv);
1733 SETERRNO(EBADF,SS_IVCHAN);
1734 }
1735 return FALSE;
1736 }
1737 if ((mg = mg_findext((SV*)io, PERL_MAGIC_uvar, &argvout_vtbl))
1738 && mg->mg_obj) {
1739 retval = argvout_final(mg, io, not_implicit);
e0d4aead
TC		 1740 mg_freeext((SV*)io, PERL_MAGIC_uvar, &argvout_vtbl);
1741 }
1742 else {
1743 retval = io_close(io, NULL, not_implicit, FALSE);
1744 }
517844ec 1745 if (not_implicit) {
1193dd27
IZ		 1746 IoLINES(io) = 0;
1747 IoPAGE(io) = 0;
1748 IoLINES_LEFT(io) = IoPAGE_LEN(io);
1749 }
50952442 1750 IoTYPE(io) = IoTYPE_CLOSED;
1193dd27
IZ		 1751 return retval;
1752}
1753
1754bool
96d7c888 1755Perl_io_close(pTHX_ IO *io, GV *gv, bool not_implicit, bool warn_on_fail)
1193dd27
IZ		 1756{
1757 bool retval = FALSE;
1193dd27 1758
7918f24d
NC		 1759 PERL_ARGS_ASSERT_IO_CLOSE;
1760
8990e307 1761 if (IoIFP(io)) {
50952442 1762 if (IoTYPE(io) == IoTYPE_PIPE) {
4373e329 1763 const int status = PerlProc_pclose(IoIFP(io));
f2b5be74 1764 if (not_implicit) {
37038d91 1765 STATUS_NATIVE_CHILD_SET(status);
e5218da5 1766 retval = (STATUS_UNIX == 0);
f2b5be74
GS		 1767 }
1768 else {
1769 retval = (status != -1);
1770 }
a687059c 1771 }
50952442 1772 else if (IoTYPE(io) == IoTYPE_STD)
a687059c
LW		 1773 retval = TRUE;
1774 else {
8990e307 1775 if (IoOFP(io) && IoOFP(io) != IoIFP(io)) { /* a socket */
0bcc34c2 1776 const bool prev_err = PerlIO_error(IoOFP(io));
f4725fad
FC		 1777#ifdef USE_PERLIO
1778 if (prev_err)
1779 PerlIO_restore_errno(IoOFP(io));
1780#endif
e199e3be 1781 retval = (PerlIO_close(IoOFP(io)) != EOF && !prev_err);
760ac839 1782 PerlIO_close(IoIFP(io)); /* clear stdio, fd already closed */
c2ab57d4 1783 }
e199e3be 1784 else {
0bcc34c2 1785 const bool prev_err = PerlIO_error(IoIFP(io));
f4725fad
FC		 1786#ifdef USE_PERLIO
1787 if (prev_err)
1788 PerlIO_restore_errno(IoIFP(io));
1789#endif
e199e3be
RGS		 1790 retval = (PerlIO_close(IoIFP(io)) != EOF && !prev_err);
1791 }
a687059c 1792 }
4608196e 1793 IoOFP(io) = IoIFP(io) = NULL;
96d7c888
FC		 1794
1795 if (warn_on_fail && !retval) {
1796 if (gv)
1797 Perl_ck_warner_d(aTHX_ packWARN(WARN_IO),
1798 "Warning: unable to close filehandle %"
147e3846 1799 HEKf " properly: %" SVf,
ac892e4a
DM		 1800 HEKfARG(GvNAME_HEK(gv)),
1801 SVfARG(get_sv("!",GV_ADD)));
96d7c888
FC		 1802 else
1803 Perl_ck_warner_d(aTHX_ packWARN(WARN_IO),
1804 "Warning: unable to close filehandle "
147e3846 1805 "properly: %" SVf,
ac892e4a 1806 SVfARG(get_sv("!",GV_ADD)));
96d7c888 1807 }
79072805 1808 }
f2b5be74 1809 else if (not_implicit) {
93189314 1810 SETERRNO(EBADF,SS_IVCHAN);
20408e3c 1811 }
1193dd27 1812
a687059c
LW		 1813 return retval;
1814}
1815
1816bool
864dbfa3 1817Perl_do_eof(pTHX_ GV *gv)
a687059c 1818{
eb578fdb 1819 IO * const io = GvIO(gv);
a687059c 1820
7918f24d
NC		 1821 PERL_ARGS_ASSERT_DO_EOF;
1822
79072805 1823 if (!io)
a687059c 1824 return TRUE;
7716c5c5 1825 else if (IoTYPE(io) == IoTYPE_WRONLY)
a5390457 1826 report_wrongway_fh(gv, '>');
a687059c 1827
8990e307 1828 while (IoIFP(io)) {
760ac839 1829 if (PerlIO_has_cntptr(IoIFP(io))) { /* (the code works without this) */
a20bf0c3 1830 if (PerlIO_get_cnt(IoIFP(io)) > 0) /* cheat a little, since */
760ac839
LW		 1831 return FALSE; /* this is the most usual case */
1832 }
a687059c 1833
79852593
NC		 1834 {
1835 /* getc and ungetc can stomp on errno */
4ee39169 1836 dSAVE_ERRNO;
79852593
NC		 1837 const int ch = PerlIO_getc(IoIFP(io));
1838 if (ch != EOF) {
1839 (void)PerlIO_ungetc(IoIFP(io),ch);
4ee39169 1840 RESTORE_ERRNO;
79852593
NC		 1841 return FALSE;
1842 }
4ee39169 1843 RESTORE_ERRNO;
a687059c 1844 }
fab3f3a7 1845
760ac839 1846 if (PerlIO_has_cntptr(IoIFP(io)) && PerlIO_canset_cnt(IoIFP(io))) {
a20bf0c3
JH		 1847 if (PerlIO_get_cnt(IoIFP(io)) < -1)
1848 PerlIO_set_cnt(IoIFP(io),-1);
760ac839 1849 }
533c011a 1850 if (PL_op->op_flags & OPf_SPECIAL) { /* not necessarily a real EOF yet? */
157fb5a1 1851 if (gv != PL_argvgv || !nextargv(gv, FALSE)) /* get another fp handy */
a687059c
LW		 1852 return TRUE;
1853 }
1854 else
1855 return TRUE; /* normal fp, definitely end of file */
1856 }
1857 return TRUE;
1858}
1859
5ff3f7a4 1860Off_t
864dbfa3 1861Perl_do_tell(pTHX_ GV *gv)
a687059c 1862{
9c9f25b8 1863 IO *const io = GvIO(gv);
eb578fdb 1864 PerlIO *fp;
a687059c 1865
7918f24d
NC		 1866 PERL_ARGS_ASSERT_DO_TELL;
1867
9c9f25b8 1868 if (io && (fp = IoIFP(io))) {
8903cb82 1869 return PerlIO_tell(fp);
96e4d5b1 1870 }
51087808 1871 report_evil_fh(gv);
93189314 1872 SETERRNO(EBADF,RMS_IFI);
5ff3f7a4 1873 return (Off_t)-1;
a687059c
LW		 1874}
1875
1876bool
864dbfa3 1877Perl_do_seek(pTHX_ GV *gv, Off_t pos, int whence)
a687059c 1878{
9c9f25b8 1879 IO *const io = GvIO(gv);
eb578fdb 1880 PerlIO *fp;
a687059c 1881
9c9f25b8 1882 if (io && (fp = IoIFP(io))) {
8903cb82 1883 return PerlIO_seek(fp, pos, whence) >= 0;
137443ea 1884 }
51087808 1885 report_evil_fh(gv);
93189314 1886 SETERRNO(EBADF,RMS_IFI);
a687059c
LW		 1887 return FALSE;
1888}
1889
97cc44eb 1890Off_t
864dbfa3 1891Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence)
8903cb82 1892{
9c9f25b8 1893 IO *const io = GvIO(gv);
eb578fdb 1894 PerlIO *fp;
8903cb82 1895
7918f24d
NC		 1896 PERL_ARGS_ASSERT_DO_SYSSEEK;
1897
375ed12a
JH		 1898 if (io && (fp = IoIFP(io))) {
1899 int fd = PerlIO_fileno(fp);
07bd88da
JH		 1900 if (fd < 0 || (whence == SEEK_SET && pos < 0)) {
1901 SETERRNO(EINVAL,LIB_INVARG);
1902 return -1;
1903 } else {
375ed12a
JH		 1904 return PerlLIO_lseek(fd, pos, whence);
1905 }
1906 }
51087808 1907 report_evil_fh(gv);
93189314 1908 SETERRNO(EBADF,RMS_IFI);
d9b3e12d 1909 return (Off_t)-1;
8903cb82 1910}
1911
6ff81951 1912int
a79b25b7 1913Perl_mode_from_discipline(pTHX_ const char *s, STRLEN len)
16fe6d59
GS		 1914{
1915 int mode = O_BINARY;
81611534 1916 PERL_UNUSED_CONTEXT;
a79b25b7 1917 if (s) {
16fe6d59
GS		 1918 while (*s) {
1919 if (*s == ':') {
1920 switch (s[1]) {
1921 case 'r':
e963d6d2 1922 if (s[2] == 'a' && s[3] == 'w'
16fe6d59
GS		 1923 && (!s[4] || s[4] == ':' || isSPACE(s[4])))
1924 {
1925 mode = O_BINARY;
1926 s += 4;
1927 len -= 4;
1928 break;
1929 }
924ba076 1930 /* FALLTHROUGH */
16fe6d59 1931 case 'c':
e963d6d2 1932 if (s[2] == 'r' && s[3] == 'l' && s[4] == 'f'
16fe6d59
GS		 1933 && (!s[5] || s[5] == ':' || isSPACE(s[5])))
1934 {
1935 mode = O_TEXT;
1936 s += 5;
1937 len -= 5;
1938 break;
1939 }
924ba076 1940 /* FALLTHROUGH */
16fe6d59
GS		 1941 default:
1942 goto fail_discipline;
1943 }
1944 }
1945 else if (isSPACE(*s)) {
1946 ++s;
1947 --len;
1948 }
1949 else {
4373e329 1950 const char *end;
7b52d656 1951 fail_discipline:
9a73c0b8 1952 end = (char *) memchr(s+1, ':', len);
16fe6d59
GS		 1953 if (!end)
1954 end = s+len;
60382766 1955#ifndef PERLIO_LAYERS
363c40c4 1956 Perl_croak(aTHX_ "IO layers (like '%.*s') unavailable", end-s, s);
60382766 1957#else
18a33fb5 1958 len -= end-s;
60382766
NIS		 1959 s = end;
1960#endif
16fe6d59
GS		 1961 }
1962 }
1963 }
1964 return mode;
1965}
1966
58e24eff 1967#if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE)
27da23d5
JH		 1968I32
1969my_chsize(int fd, Off_t length)
6eb13c3b 1970{
58e24eff
SH		 1971#ifdef F_FREESP
1972 /* code courtesy of William Kucharski */
1973#define HAS_CHSIZE
1974
c623ac67 1975 Stat_t filebuf;
6eb13c3b 1976
3028581b 1977 if (PerlLIO_fstat(fd, &filebuf) < 0)
6eb13c3b
LW		 1978 return -1;
1979
1980 if (filebuf.st_size < length) {
1981
1982 /* extend file length */
1983
3028581b 1984 if ((PerlLIO_lseek(fd, (length - 1), 0)) < 0)
6eb13c3b
LW		 1985 return -1;
1986
1987 /* write a "0" byte */
1988
3028581b 1989 if ((PerlLIO_write(fd, "", 1)) != 1)
6eb13c3b
LW		 1990 return -1;
1991 }
1992 else {
1993 /* truncate length */
35da51f7 1994 struct flock fl;
6eb13c3b
LW		 1995 fl.l_whence = 0;
1996 fl.l_len = 0;
1997 fl.l_start = length;
a0d0e21e 1998 fl.l_type = F_WRLCK; /* write lock on file space */
6eb13c3b
LW		 1999
2000 /*
a0d0e21e 2001 * This relies on the UNDOCUMENTED F_FREESP argument to
6eb13c3b
LW		 2002 * fcntl(2), which truncates the file so that it ends at the
2003 * position indicated by fl.l_start.
2004 *
2005 * Will minor miracles never cease?
2006 */
2007
a0d0e21e 2008 if (fcntl(fd, F_FREESP, &fl) < 0)
6eb13c3b
LW		 2009 return -1;
2010
2011 }
6eb13c3b 2012 return 0;
58e24eff 2013#else
27da23d5 2014 Perl_croak_nocontext("truncate not implemented");
a0d0e21e 2015#endif /* F_FREESP */
27da23d5 2016 return -1;
58e24eff
SH		 2017}
2018#endif /* !HAS_TRUNCATE && !HAS_CHSIZE */
ff8e2863 2019
a687059c 2020bool
5aaab254 2021Perl_do_print(pTHX_ SV *sv, PerlIO *fp)
a687059c 2022{
7918f24d
NC		 2023 PERL_ARGS_ASSERT_DO_PRINT;
2024
79072805
LW		 2025 /* assuming fp is checked earlier */
2026 if (!sv)
2027 return TRUE;
e9950d3b
NC		 2028 if (SvTYPE(sv) == SVt_IV && SvIOK(sv)) {
2029 assert(!SvGMAGICAL(sv));
2030 if (SvIsUV(sv))
147e3846 2031 PerlIO_printf(fp, "%" UVuf, (UV)SvUVX(sv));
e9950d3b 2032 else
147e3846 2033 PerlIO_printf(fp, "%" IVdf, (IV)SvIVX(sv));
e9950d3b
NC		 2034 return !PerlIO_error(fp);
2035 }
2036 else {
2037 STRLEN len;
676f44e7 2038 /* Do this first to trigger any overloading. */
e9950d3b
NC		 2039 const char *tmps = SvPV_const(sv, len);
2040 U8 *tmpbuf = NULL;
2041 bool happy = TRUE;
2042
d791f93f
KW		 2043 if (PerlIO_isutf8(fp)) { /* If the stream is utf8 ... */
2044 if (!SvUTF8(sv)) { /* Convert to utf8 if necessary */
676f44e7
NC		 2045 /* We don't modify the original scalar. */
2046 tmpbuf = bytes_to_utf8((const U8*) tmps, &len);
2047 tmps = (char *) tmpbuf;
2048 }
a099aed4 2049 else if (ckWARN4_d(WARN_UTF8, WARN_SURROGATE, WARN_NON_UNICODE, WARN_NONCHAR)) {
0876b9a0
KW		 2050 (void) check_utf8_print((const U8*) tmps, len);
2051 }
d791f93f
KW		 2052 } /* else stream isn't utf8 */
2053 else if (DO_UTF8(sv)) { /* But if is utf8 internally, attempt to
2054 convert to bytes */
676f44e7
NC		 2055 STRLEN tmplen = len;
2056 bool utf8 = TRUE;
35da51f7 2057 U8 * const result = bytes_from_utf8((const U8*) tmps, &tmplen, &utf8);
676f44e7 2058 if (!utf8) {
d791f93f
KW		 2059
2060 /* Here, succeeded in downgrading from utf8. Set up to below
2061 * output the converted value */
676f44e7
NC		 2062 tmpbuf = result;
2063 tmps = (char *) tmpbuf;
2064 len = tmplen;
2065 }
d791f93f
KW		 2066 else { /* Non-utf8 output stream, but string only representable in
2067 utf8 */
676f44e7 2068 assert((char *)result == tmps);
9b387841 2069 Perl_ck_warner_d(aTHX_ packWARN(WARN_UTF8),
21630838
FC		 2070 "Wide character in %s",
2071 PL_op ? OP_DESC(PL_op) : "print"
2072 );
0876b9a0
KW		 2073 /* Could also check that isn't one of the things to avoid
2074 * in utf8 by using check_utf8_print(), but not doing so,
2075 * since the stream isn't a UTF8 stream */
ae798467
NIS		 2076 }
2077 }
e9950d3b
NC		 2078 /* To detect whether the process is about to overstep its
2079 * filesize limit we would need getrlimit(). We could then
2080 * also transparently raise the limit with setrlimit() --
2081 * but only until the system hard limit/the filesystem limit,
2082 * at which we would get EPERM. Note that when using buffered
2083 * io the write failure can be delayed until the flush/close. --jhi */
2084 if (len && (PerlIO_write(fp,tmps,len) == 0))
2085 happy = FALSE;
2086 Safefree(tmpbuf);
2087 return happy ? !PerlIO_error(fp) : FALSE;
ff8e2863 2088 }
a687059c
LW		 2089}
2090
79072805 2091I32
0d7d409d 2092Perl_my_stat_flags(pTHX_ const U32 flags)
a687059c 2093{
39644a26 2094 dSP;
79072805 2095 IO *io;
2dd78f96 2096 GV* gv;
79072805 2097
533c011a 2098 if (PL_op->op_flags & OPf_REF) {
2dd78f96 2099 gv = cGVOP_gv;
748a9306 2100 do_fstat:
97c8f3e6
Z		 2101 if (gv == PL_defgv) {
2102 if (PL_laststatval < 0)
2103 SETERRNO(EBADF,RMS_IFI);
5228a96c 2104 return PL_laststatval;
97c8f3e6 2105 }
2dd78f96 2106 io = GvIO(gv);
ad02613c 2107 do_fstat_have_io:
5228a96c 2108 PL_laststype = OP_STAT;
bd5f6c01 2109 PL_statgv = gv ? gv : (GV *)io;
8062ff11 2110 SvPVCLEAR(PL_statname);
77616968 2111 if (io) {
5228a96c 2112 if (IoIFP(io)) {
375ed12a 2113 int fd = PerlIO_fileno(IoIFP(io));
77616968
JH		 2114 if (fd < 0) {
2115 /* E.g. PerlIO::scalar has no real fd. */
97c8f3e6 2116 SETERRNO(EBADF,RMS_IFI);
77616968
JH		 2117 return (PL_laststatval = -1);
2118 } else {
375ed12a
JH		 2119 return (PL_laststatval = PerlLIO_fstat(fd, &PL_statcache));
2120 }
5228a96c 2121 } else if (IoDIRP(io)) {
3497a01f 2122 return (PL_laststatval = PerlLIO_fstat(my_dirfd(IoDIRP(io)), &PL_statcache));
5228a96c 2123 }
5228a96c 2124 }
3888144c
FC		 2125 PL_laststatval = -1;
2126 report_evil_fh(gv);
97c8f3e6 2127 SETERRNO(EBADF,RMS_IFI);
3888144c 2128 return -1;
a687059c 2129 }
d2c4d2d1 2130 else if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
8db8f6b6
FC		 2131 == OPpFT_STACKED)
2132 return PL_laststatval;
d2c4d2d1
FC		 2133 else {
2134 SV* const sv = TOPs;
a155eb05 2135 const char *s, *d;
4ecd490c 2136 STRLEN len;
094a3eec 2137 if ((gv = MAYBE_DEREF_GV_flags(sv,flags))) {
748a9306
LW		 2138 goto do_fstat;
2139 }
ad02613c 2140 else if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVIO) {
a45c7426 2141 io = MUTABLE_IO(SvRV(sv));
7f39519f 2142 gv = NULL;
ad02613c
SP		 2143 goto do_fstat_have_io;
2144 }
748a9306 2145
0d7d409d 2146 s = SvPV_flags_const(sv, len, flags);
a0714e2c 2147 PL_statgv = NULL;
4ecd490c 2148 sv_setpvn(PL_statname, s, len);
a155eb05 2149 d = SvPVX_const(PL_statname); /* s now NUL-terminated */
3280af22 2150 PL_laststype = OP_STAT;
a155eb05
TC		 2151 if (!IS_SAFE_PATHNAME(s, len, OP_NAME(PL_op))) {
2152 PL_laststatval = -1;
2153 }
2154 else {
2155 PL_laststatval = PerlLIO_stat(d, &PL_statcache);
2156 }
7cb3f959 2157 if (PL_laststatval < 0 && ckWARN(WARN_NEWLINE) && should_warn_nl(s)) {
7347ee54 2158 GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral); /* PL_warn_nl is constant */
9014280d 2159 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "stat");
7347ee54 2160 GCC_DIAG_RESTORE_STMT;
5d37acd6 2161 }
3280af22 2162 return PL_laststatval;
a687059c
LW		 2163 }
2164}
2165
fbb0b3b3 2166
79072805 2167I32
0d7d409d 2168Perl_my_lstat_flags(pTHX_ const U32 flags)
c623bd54 2169{
a1894d81 2170 static const char* const no_prev_lstat = "The stat preceding -l _ wasn't an lstat";
39644a26 2171 dSP;
b16276bb 2172 const char *file;
a155eb05 2173 STRLEN len;
cd22fad3 2174 SV* const sv = TOPs;
5840701a 2175 bool isio = FALSE;
533c011a 2176 if (PL_op->op_flags & OPf_REF) {
638eceb6 2177 if (cGVOP_gv == PL_defgv) {
3280af22 2178 if (PL_laststype != OP_LSTAT)
0157ef98 2179 Perl_croak(aTHX_ "%s", no_prev_lstat);
97c8f3e6
Z		 2180 if (PL_laststatval < 0)
2181 SETERRNO(EBADF,RMS_IFI);
3280af22 2182 return PL_laststatval;
fe14fcc3 2183 }
31b139ba 2184 PL_laststatval = -1;
5d3e98de 2185 if (ckWARN(WARN_IO)) {
5840701a 2186 /* diag_listed_as: Use of -l on filehandle%s */
d0c0e7dd 2187 Perl_warner(aTHX_ packWARN(WARN_IO),
147e3846 2188 "Use of -l on filehandle %" HEKf,
d0c0e7dd 2189 HEKfARG(GvENAME_HEK(cGVOP_gv)));
5d3e98de 2190 }
97c8f3e6 2191 SETERRNO(EBADF,RMS_IFI);
31b139ba 2192 return -1;
fe14fcc3 2193 }
8db8f6b6
FC		 2194 if ((PL_op->op_private & (OPpFT_STACKED|OPpFT_AFTER_t))
2195 == OPpFT_STACKED) {
1f26655e 2196 if (PL_laststype != OP_LSTAT)
0157ef98 2197 Perl_croak(aTHX_ "%s", no_prev_lstat);
1f26655e 2198 return PL_laststatval;
cd22fad3 2199 }
c623bd54 2200
3280af22 2201 PL_laststype = OP_LSTAT;
a0714e2c 2202 PL_statgv = NULL;
5840701a
FC		 2203 if ( ( (SvROK(sv) && ( isGV_with_GP(SvRV(sv))
2204 || (isio = SvTYPE(SvRV(sv)) == SVt_PVIO) )
2205 )
2206 || isGV_with_GP(sv)
2207 )
2208 && ckWARN(WARN_IO)) {
2209 if (isio)
2210 /* diag_listed_as: Use of -l on filehandle%s */
2211 Perl_warner(aTHX_ packWARN(WARN_IO),
2212 "Use of -l on filehandle");
2213 else
2214 /* diag_listed_as: Use of -l on filehandle%s */
2215 Perl_warner(aTHX_ packWARN(WARN_IO),
147e3846 2216 "Use of -l on filehandle %" HEKf,
10bafe90
BF		 2217 HEKfARG(GvENAME_HEK((const GV *)
2218 (SvROK(sv) ? SvRV(sv) : sv))));
cd22fad3 2219 }
a155eb05 2220 file = SvPV_flags_const(sv, len, flags);
b16276bb 2221 sv_setpv(PL_statname,file);
a155eb05
TC		 2222 if (!IS_SAFE_PATHNAME(file, len, OP_NAME(PL_op))) {
2223 PL_laststatval = -1;
2224 }
2225 else {
2226 PL_laststatval = PerlLIO_lstat(file,&PL_statcache);
2227 }
7cb3f959 2228 if (PL_laststatval < 0 && ckWARN(WARN_NEWLINE) && should_warn_nl(file)) {
7347ee54 2229 GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral); /* PL_warn_nl is constant */
5d37acd6 2230 Perl_warner(aTHX_ packWARN(WARN_NEWLINE), PL_warn_nl, "lstat");
7347ee54 2231 GCC_DIAG_RESTORE_STMT;
5d37acd6 2232 }
3280af22 2233 return PL_laststatval;
c623bd54
LW		 2234}
2235
a0f2c8ec
JD		 2236static void
2237S_exec_failed(pTHX_ const char *cmd, int fd, int do_report)
2238{
2239 const int e = errno;
7918f24d 2240 PERL_ARGS_ASSERT_EXEC_FAILED;
738ab09f
AB		 2241
2242 if (ckWARN(WARN_EXEC))
2243 Perl_warner(aTHX_ packWARN(WARN_EXEC), "Can't exec \"%s\": %s",
2244 cmd, Strerror(e));
a0f2c8ec 2245 if (do_report) {
b469f1e0
JH		 2246 /* XXX silently ignore failures */
2247 PERL_UNUSED_RESULT(PerlLIO_write(fd, (void*)&e, sizeof(int)));
a0f2c8ec
JD		 2248 PerlLIO_close(fd);
2249 }
2250}
2251
738ab09f 2252bool
5aaab254 2253Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp,
2aa1486d 2254 int fd, int do_report)
d5a9bfb0 2255{
27da23d5 2256 dVAR;
7918f24d 2257 PERL_ARGS_ASSERT_DO_AEXEC5;
e37778c2 2258#if defined(__SYMBIAN32__) || defined(__LIBCATAMOUNT__)
cd39f2b6
JH		 2259 Perl_croak(aTHX_ "exec? I'm not *that* kind of operating system");
2260#else
2fcab330 2261 assert(sp >= mark);
282fc0b3 2262 ENTER;
2fcab330 2263 {
282fc0b3 2264 const char **argv, **a;
6136c704 2265 const char *tmps = NULL;
282fc0b3
Z		 2266 Newx(argv, sp - mark + 1, const char*);
2267 SAVEFREEPV(argv);
2268 a = argv;
890ce7af 2269
79072805 2270 while (++mark <= sp) {
282fc0b3
Z		 2271 if (*mark) {
2272 char *arg = savepv(SvPV_nolen_const(*mark));
2273 SAVEFREEPV(arg);
2274 *a++ = arg;
2275 } else
a687059c
LW		 2276 *a++ = "";
2277 }
6136c704 2278 *a = NULL;
282fc0b3
Z		 2279 if (really) {
2280 tmps = savepv(SvPV_nolen_const(really));
2281 SAVEFREEPV(tmps);
2282 }
2283 if ((!really && argv[0] && *argv[0] != '/') ||
91b2752f 2284 (really && *tmps != '/')) /* will execvp use PATH? */
79072805 2285 TAINT_ENV(); /* testing IFS here is overkill, probably */
b35112e7 2286 PERL_FPU_PRE_EXEC
839a9f02 2287 if (really && *tmps) {
282fc0b3
Z		 2288 PerlProc_execvp(tmps,EXEC_ARGV_CAST(argv));
2289 } else if (argv[0]) {
2290 PerlProc_execvp(argv[0],EXEC_ARGV_CAST(argv));
2fcab330
DIM		 2291 } else {
2292 SETERRNO(ENOENT,RMS_FNF);
2293 }
b35112e7 2294 PERL_FPU_POST_EXEC
282fc0b3 2295 S_exec_failed(aTHX_ (really ? tmps : argv[0] ? argv[0] : ""), fd, do_report);
a687059c 2296 }
282fc0b3 2297 LEAVE;
cd39f2b6 2298#endif
738ab09f 2299 return FALSE;
a687059c
LW		 2300}
2301
9555a685 2302#ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION
e446cec8 2303
738ab09f 2304bool
2fbb330f 2305Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report)
e446cec8 2306{
27da23d5 2307 dVAR;
282fc0b3 2308 const char **argv, **a;
eb578fdb 2309 char *s;
15db3ae2 2310 char *buf;
2fbb330f 2311 char *cmd;
2fbb330f 2312 /* Make a copy so we can change it */
6fca0082 2313 const Size_t cmdlen = strlen(incmd) + 1;
7918f24d
NC		 2314
2315 PERL_ARGS_ASSERT_DO_EXEC3;
2316
282fc0b3 2317 ENTER;
15db3ae2 2318 Newx(buf, cmdlen, char);
282fc0b3 2319 SAVEFREEPV(buf);
15db3ae2 2320 cmd = buf;
cfff9797 2321 memcpy(cmd, incmd, cmdlen);
a687059c 2322
748a9306
LW		 2323 while (*cmd && isSPACE(*cmd))
2324 cmd++;
2325
a687059c
LW		 2326 /* save an extra exec if possible */
2327
bf38876a 2328#ifdef CSH
d05c1ba0 2329 {
0c19750d 2330 char flags[PERL_FLAGS_MAX];
d05c1ba0 2331 if (strnEQ(cmd,PL_cshname,PL_cshlen) &&
c8b388b0 2332 strBEGINs(cmd+PL_cshlen," -c")) {
28f0d0ec 2333 my_strlcpy(flags, "-c", PERL_FLAGS_MAX);
d05c1ba0
JH		 2334 s = cmd+PL_cshlen+3;
2335 if (*s == 'f') {
2336 s++;
28f0d0ec 2337 my_strlcat(flags, "f", PERL_FLAGS_MAX - 2);
d05c1ba0
JH		 2338 }
2339 if (*s == ' ')
2340 s++;
2341 if (*s++ == '\'') {
0bcc34c2 2342 char * const ncmd = s;
d05c1ba0
JH		 2343
2344 while (*s)
2345 s++;
2346 if (s[-1] == '\n')
2347 *--s = '\0';
2348 if (s[-1] == '\'') {
2349 *--s = '\0';
b35112e7 2350 PERL_FPU_PRE_EXEC
738ab09f 2351 PerlProc_execl(PL_cshname, "csh", flags, ncmd, (char*)NULL);
b35112e7 2352 PERL_FPU_POST_EXEC
d05c1ba0 2353 *s = '\'';
a0f2c8ec 2354 S_exec_failed(aTHX_ PL_cshname, fd, do_report);
282fc0b3 2355 goto leave;
d05c1ba0
JH		 2356 }
2357 }
a687059c
LW		 2358 }
2359 }
bf38876a 2360#endif /* CSH */
a687059c
LW		 2361
2362 /* see if there are shell metacharacters in it */
2363
748a9306
LW		 2364 if (*cmd == '.' && isSPACE(cmd[1]))
2365 goto doshell;
2366
c8b388b0 2367 if (strBEGINs(cmd,"exec") && isSPACE(cmd[4]))
748a9306
LW		 2368 goto doshell;
2369
294b3b39 2370 s = cmd;
0eb30aeb 2371 while (isWORDCHAR(*s))
294b3b39 2372 s++; /* catch VAR=val gizmo */
63f2c1e1
LW		 2373 if (*s == '=')
2374 goto doshell;
748a9306 2375
a687059c 2376 for (s = cmd; *s; s++) {
d05c1ba0
JH		 2377 if (*s != ' ' && !isALPHA(*s) &&
2378 strchr("$&*(){}[]'\";\\|?<>~`\n",*s)) {
a687059c
LW		 2379 if (*s == '\n' && !s[1]) {
2380 *s = '\0';
2381 break;
2382 }
603a98b0
IZ		 2383 /* handle the 2>&1 construct at the end */
2384 if (*s == '>' && s[1] == '&' && s[2] == '1'
2385 && s > cmd + 1 && s[-1] == '2' && isSPACE(s[-2])
2386 && (!s[3] || isSPACE(s[3])))
2387 {
6867be6d 2388 const char *t = s + 3;
603a98b0
IZ		 2389
2390 while (*t && isSPACE(*t))
2391 ++t;
943bbd07 2392 if (!*t && (PerlLIO_dup2(1,2) != -1)) {
603a98b0
IZ		 2393 s[-2] = '\0';
2394 break;
2395 }
2396 }
a687059c 2397 doshell:
b35112e7 2398 PERL_FPU_PRE_EXEC
738ab09f 2399 PerlProc_execl(PL_sh_path, "sh", "-c", cmd, (char *)NULL);
b35112e7 2400 PERL_FPU_POST_EXEC
a0f2c8ec 2401 S_exec_failed(aTHX_ PL_sh_path, fd, do_report);
282fc0b3 2402 goto leave;
a687059c
LW		 2403 }
2404 }
748a9306 2405
282fc0b3
Z		 2406 Newx(argv, (s - cmd) / 2 + 2, const char*);
2407 SAVEFREEPV(argv);
2408 cmd = savepvn(cmd, s-cmd);
2409 SAVEFREEPV(cmd);
2410 a = argv;
2411 for (s = cmd; *s;) {
294b3b39
AL		 2412 while (isSPACE(*s))
2413 s++;
a687059c
LW		 2414 if (*s)
2415 *(a++) = s;
294b3b39
AL		 2416 while (*s && !isSPACE(*s))
2417 s++;
a687059c
LW		 2418 if (*s)
2419 *s++ = '\0';
2420 }
6136c704 2421 *a = NULL;
282fc0b3 2422 if (argv[0]) {
b35112e7 2423 PERL_FPU_PRE_EXEC
282fc0b3 2424 PerlProc_execvp(argv[0],EXEC_ARGV_CAST(argv));
b35112e7 2425 PERL_FPU_POST_EXEC
282fc0b3 2426 if (errno == ENOEXEC) /* for system V NIH syndrome */
a687059c 2427 goto doshell;
282fc0b3 2428 S_exec_failed(aTHX_ argv[0], fd, do_report);
a687059c 2429 }
282fc0b3
Z		 2430leave:
2431 LEAVE;
738ab09f 2432 return FALSE;
a687059c
LW		 2433}
2434
6890e559 2435#endif /* OS2 || WIN32 */
760ac839 2436
79072805 2437I32
5aaab254 2438Perl_apply(pTHX_ I32 type, SV **mark, SV **sp)
a687059c 2439{
eb578fdb
KW		 2440 I32 val;
2441 I32 tot = 0;
4634a855 2442 const char *const what = PL_op_name[type];
5c144d81 2443 const char *s;
84c7b88c 2444 STRLEN len;
890ce7af 2445 SV ** const oldmark = mark;
885b4b39 2446 bool killgp = FALSE;
a687059c 2447
7918f24d
NC		 2448 PERL_ARGS_ASSERT_APPLY;
2449
9a9b5ec9
DM		 2450 PERL_UNUSED_VAR(what); /* may not be used depending on compile options */
2451
1444765e
NC		 2452 /* Doing this ahead of the switch statement preserves the old behaviour,
2453 where attempting to use kill as a taint test test would fail on
2454 platforms where kill was not defined. */
2455#ifndef HAS_KILL
2456 if (type == OP_KILL)
4634a855 2457 Perl_die(aTHX_ PL_no_func, what);
1444765e
NC		 2458#endif
2459#ifndef HAS_CHOWN
2460 if (type == OP_CHOWN)
4634a855 2461 Perl_die(aTHX_ PL_no_func, what);
1444765e
NC		 2462#endif
2463
2464
20408e3c 2465#define APPLY_TAINT_PROPER() \
3280af22 2466 STMT_START { \
284167a5 2467 if (TAINT_get) { TAINT_PROPER(what); } \
873ef191 2468 } STMT_END
20408e3c
GS		 2469
2470 /* This is a first heuristic; it doesn't catch tainting magic. */
284167a5 2471 if (TAINTING_get) {
463ee0b2 2472 while (++mark <= sp) {
bbce6d69 2473 if (SvTAINTED(*mark)) {
2474 TAINT;
2475 break;
2476 }
463ee0b2
LW		 2477 }
2478 mark = oldmark;
2479 }
a687059c 2480 switch (type) {
79072805 2481 case OP_CHMOD:
20408e3c 2482 APPLY_TAINT_PROPER();
79072805 2483 if (++mark <= sp) {
4ea561bc 2484 val = SvIV(*mark);
20408e3c
GS		 2485 APPLY_TAINT_PROPER();
2486 tot = sp - mark;
79072805 2487 while (++mark <= sp) {
c4aca7d0 2488 GV* gv;
2ea1cce7 2489 if ((gv = MAYBE_DEREF_GV(*mark))) {
c4aca7d0
GA		 2490 if (GvIO(gv) && IoIFP(GvIOp(gv))) {
2491#ifdef HAS_FCHMOD
375ed12a 2492 int fd = PerlIO_fileno(IoIFP(GvIOn(gv)));
c4aca7d0 2493 APPLY_TAINT_PROPER();
375ed12a
JH		 2494 if (fd < 0) {
2495 SETERRNO(EBADF,RMS_IFI);
2496 tot--;
2497 } else if (fchmod(fd, val))
2498 tot--;
c4aca7d0 2499#else
b9c6780e 2500 Perl_die(aTHX_ PL_no_func, "fchmod");
c4aca7d0
GA		 2501#endif
2502 }
2503 else {
8334cae6 2504 SETERRNO(EBADF,RMS_IFI);
c4aca7d0
GA		 2505 tot--;
2506 }
2507 }
c4aca7d0 2508 else {
41188aa0 2509 const char *name = SvPV_nomg_const(*mark, len);
c4aca7d0 2510 APPLY_TAINT_PROPER();
41188aa0 2511 if (!IS_SAFE_PATHNAME(name, len, "chmod") ||
c8028aa6
TC		 2512 PerlLIO_chmod(name, val)) {
2513 tot--;
2514 }
c4aca7d0 2515 }
a687059c
LW		 2516 }
2517 }
2518 break;
fe14fcc3 2519#ifdef HAS_CHOWN
79072805 2520 case OP_CHOWN:
20408e3c 2521 APPLY_TAINT_PROPER();
79072805 2522 if (sp - mark > 2) {
eb578fdb 2523 I32 val2;
463ee0b2
LW		 2524 val = SvIVx(*++mark);
2525 val2 = SvIVx(*++mark);
20408e3c 2526 APPLY_TAINT_PROPER();
a0d0e21e 2527 tot = sp - mark;
79072805 2528 while (++mark <= sp) {
c4aca7d0 2529 GV* gv;
2ea1cce7 2530 if ((gv = MAYBE_DEREF_GV(*mark))) {
c4aca7d0
GA		 2531 if (GvIO(gv) && IoIFP(GvIOp(gv))) {
2532#ifdef HAS_FCHOWN
375ed12a 2533 int fd = PerlIO_fileno(IoIFP(GvIOn(gv)));
c4aca7d0 2534 APPLY_TAINT_PROPER();
375ed12a 2535 if (fd < 0) {
dd1dbff0 2536 SETERRNO(EBADF,RMS_IFI);
f95ba548 2537 tot--;
375ed12a 2538 } else if (fchown(fd, val, val2))
c4aca7d0
GA		 2539 tot--;
2540#else
b9c6780e 2541 Perl_die(aTHX_ PL_no_func, "fchown");
c4aca7d0
GA		 2542#endif
2543 }
2544 else {
8334cae6 2545 SETERRNO(EBADF,RMS_IFI);
c4aca7d0
GA		 2546 tot--;
2547 }
2548 }
c4aca7d0 2549 else {
41188aa0 2550 const char *name = SvPV_nomg_const(*mark, len);
c4aca7d0 2551 APPLY_TAINT_PROPER();
41188aa0 2552 if (!IS_SAFE_PATHNAME(name, len, "chown") ||
c8028aa6 2553 PerlLIO_chown(name, val, val2)) {
c4aca7d0 2554 tot--;
c8028aa6 2555 }
c4aca7d0 2556 }
a687059c
LW		 2557 }
2558 }
2559 break;
b1248f16 2560#endif
a1d180c4 2561/*
dd64f1c3
AD		 2562XXX Should we make lchown() directly available from perl?
2563For now, we'll let Configure test for HAS_LCHOWN, but do
2564nothing in the core.
2565 --AD 5/1998
2566*/
fe14fcc3 2567#ifdef HAS_KILL
79072805 2568 case OP_KILL:
20408e3c 2569 APPLY_TAINT_PROPER();
55497cff 2570 if (mark == sp)
2571 break;
84c7b88c 2572 s = SvPVx_const(*++mark, len);
c2fd40cb
DM		 2573 if (*s == '-' && isALPHA(s[1]))
2574 {
2575 s++;
2576 len--;
885b4b39 2577 killgp = TRUE;
c2fd40cb 2578 }
e02bfb16 2579 if (isALPHA(*s)) {
84c7b88c 2580 if (*s == 'S' && s[1] == 'I' && s[2] == 'G') {
79072805 2581 s += 3;
84c7b88c
BF		 2582 len -= 3;
2583 }
2584 if ((val = whichsig_pvn(s, len)) < 0)
147e3846
KW		 2585 Perl_croak(aTHX_ "Unrecognized signal name \"%" SVf "\"",
2586 SVfARG(*mark));
79072805
LW		 2587 }
2588 else
c2fd40cb 2589 {
4ea561bc 2590 val = SvIV(*mark);
c2fd40cb
DM		 2591 if (val < 0)
2592 {
885b4b39 2593 killgp = TRUE;
c2fd40cb
DM		 2594 val = -val;
2595 }
2596 }
20408e3c
GS		 2597 APPLY_TAINT_PROPER();
2598 tot = sp - mark;
fbcd93f0 2599
c2fd40cb 2600 while (++mark <= sp) {
60082291 2601 Pid_t proc;
c2fd40cb 2602 SvGETMAGIC(*mark);
60082291 2603 if (!(SvNIOK(*mark) || looks_like_number(*mark)))
c2fd40cb
DM		 2604 Perl_croak(aTHX_ "Can't kill a non-numeric process ID");
2605 proc = SvIV_nomg(*mark);
c2fd40cb 2606 APPLY_TAINT_PROPER();
111f73b5
DM		 2607#ifdef HAS_KILLPG
2608 /* use killpg in preference, as the killpg() wrapper for Win32
2609 * understands process groups, but the kill() wrapper doesn't */
2610 if (killgp ? PerlProc_killpg(proc, val)
2611 : PerlProc_kill(proc, val))
2612#else
2613 if (PerlProc_kill(killgp ? -proc: proc, val))
2614#endif
c2fd40cb 2615 tot--;
a687059c 2616 }
8165faea 2617 PERL_ASYNC_CHECK();
a687059c 2618 break;
b1248f16 2619#endif
79072805 2620 case OP_UNLINK:
20408e3c 2621 APPLY_TAINT_PROPER();
79072805
LW		 2622 tot = sp - mark;
2623 while (++mark <= sp) {
41188aa0 2624 s = SvPV_const(*mark, len);
20408e3c 2625 APPLY_TAINT_PROPER();
41188aa0 2626 if (!IS_SAFE_PATHNAME(s, len, "unlink")) {
c8028aa6
TC		 2627 tot--;
2628 }
f0d85c30 2629 else if (PL_unsafe) {
b8ffc8df 2630 if (UNLINK(s))
5cdd1fc2 2631 {
a687059c 2632 tot--;
5cdd1fc2
AB		 2633 }
2634#if defined(__amigaos4__) && defined(NEWLIB)
2635 else
2636 {
2637 /* Under AmigaOS4 unlink only 'fails' if the
2638 * filename is invalid. It may not remove the file
2639 * if it's locked, so check if it's still around. */
2640 if ((access(s,F_OK) != -1))
2641 {
2642 tot--;
2643 }
2644 }
2645#endif
a687059c
LW		 2646 }
2647 else { /* don't let root wipe out directories without -U */
45a23732
DD		 2648 Stat_t statbuf;
2649 if (PerlLIO_lstat(s, &statbuf) < 0)
1dcae8b8 2650 tot--;
45a23732 2651 else if (S_ISDIR(statbuf.st_mode)) {
cd52bc19 2652 SETERRNO(EISDIR, SS_NOPRIV);
45a23732 2653 tot--;
1dcae8b8 2654 }
a687059c 2655 else {
b8ffc8df 2656 if (UNLINK(s))
5cdd1fc2
AB		 2657 {
2658 tot--;
2659 }
2660#if defined(__amigaos4__) && defined(NEWLIB)
2661 else
2662 {
2663 /* Under AmigaOS4 unlink only 'fails' if the filename is invalid */
2664 /* It may not remove the file if it's Locked, so check if it's still */
2665 /* arround */
2666 if((access(s,F_OK) != -1))
2667 {
2668 tot--;
2669 }
2670 }
2671#endif
a687059c
LW		 2672 }
2673 }
2674 }
2675 break;
e96b369d 2676#if defined(HAS_UTIME) || defined(HAS_FUTIMES)
79072805 2677 case OP_UTIME:
20408e3c 2678 APPLY_TAINT_PROPER();
79072805 2679 if (sp - mark > 2) {
e96b369d
GA		 2680#if defined(HAS_FUTIMES)
2681 struct timeval utbuf[2];
2682 void *utbufp = utbuf;
2683#elif defined(I_UTIME) || defined(VMS)
663a0e37 2684 struct utimbuf utbuf;
07409e01 2685 struct utimbuf *utbufp = &utbuf;
663a0e37 2686#else
a687059c 2687 struct {
dd2821f6
GS		 2688 Time_t actime;
2689 Time_t modtime;
a687059c 2690 } utbuf;
07409e01 2691 void *utbufp = &utbuf;
663a0e37 2692#endif
a687059c 2693
0bcc34c2
AL		 2694 SV* const accessed = *++mark;
2695 SV* const modified = *++mark;
c6f7b413 2696
6ec06612
SB		 2697 /* Be like C, and if both times are undefined, let the C
2698 * library figure out what to do. This usually means
2699 * "current time". */
c6f7b413
RS		 2700
2701 if ( accessed == &PL_sv_undef && modified == &PL_sv_undef )
6ec06612
SB		 2702 utbufp = NULL;
2703 else {
2704 Zero(&utbuf, sizeof utbuf, char);
e96b369d 2705#ifdef HAS_FUTIMES
4ea561bc 2706 utbuf[0].tv_sec = (long)SvIV(accessed); /* time accessed */
e96b369d 2707 utbuf[0].tv_usec = 0;
4ea561bc 2708 utbuf[1].tv_sec = (long)SvIV(modified); /* time modified */
e96b369d
GA		 2709 utbuf[1].tv_usec = 0;
2710#elif defined(BIG_TIME)
4ea561bc
NC		 2711 utbuf.actime = (Time_t)SvNV(accessed); /* time accessed */
2712 utbuf.modtime = (Time_t)SvNV(modified); /* time modified */
517844ec 2713#else
4ea561bc
NC		 2714 utbuf.actime = (Time_t)SvIV(accessed); /* time accessed */
2715 utbuf.modtime = (Time_t)SvIV(modified); /* time modified */
517844ec 2716#endif
6ec06612 2717 }
4373e329 2718 APPLY_TAINT_PROPER();
79072805
LW		 2719 tot = sp - mark;
2720 while (++mark <= sp) {
e96b369d 2721 GV* gv;
64617da9 2722 if ((gv = MAYBE_DEREF_GV(*mark))) {
e96b369d
GA		 2723 if (GvIO(gv) && IoIFP(GvIOp(gv))) {
2724#ifdef HAS_FUTIMES
375ed12a 2725 int fd = PerlIO_fileno(IoIFP(GvIOn(gv)));
e96b369d 2726 APPLY_TAINT_PROPER();
375ed12a
JH		 2727 if (fd < 0) {
2728 SETERRNO(EBADF,RMS_IFI);
2729 tot--;
2730 } else if (futimes(fd, (struct timeval *) utbufp))
e96b369d
GA		 2731 tot--;
2732#else
2733 Perl_die(aTHX_ PL_no_func, "futimes");
2734#endif
2735 }
2736 else {
2737 tot--;
2738 }
2739 }
e96b369d 2740 else {
41188aa0 2741 const char * const name = SvPV_nomg_const(*mark, len);
e96b369d 2742 APPLY_TAINT_PROPER();
41188aa0 2743 if (!IS_SAFE_PATHNAME(name, len, "utime")) {
c8028aa6
TC		 2744 tot--;
2745 }
2746 else
e96b369d 2747#ifdef HAS_FUTIMES
8b7231d9 2748 if (utimes(name, (struct timeval *)utbufp))
e96b369d
GA		 2749#else
2750 if (PerlLIO_utime(name, utbufp))
2751#endif
2752 tot--;
2753 }
2754
a687059c 2755 }
a687059c
LW		 2756 }
2757 else
79072805 2758 tot = 0;
a687059c 2759 break;
a0d0e21e 2760#endif
a687059c
LW		 2761 }
2762 return tot;
20408e3c 2763
20408e3c 2764#undef APPLY_TAINT_PROPER
a687059c
LW		 2765}
2766
bd93adf5 2767/* Do the permissions in *statbufp allow some operation? */
a0d0e21e 2768#ifndef VMS /* VMS' cando is in vms.c */
7f4774ae 2769bool
5aaab254 2770Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp)
ae1951c1
NC		 2771/* effective is a flag, true for EUID, or for checking if the effective gid
2772 * is in the list of groups returned from getgroups().
2773 */
a687059c 2774{
7918f24d 2775 PERL_ARGS_ASSERT_CANDO;
81611534 2776 PERL_UNUSED_CONTEXT;
7918f24d 2777
bee1dbe2 2778#ifdef DOSISH
fe14fcc3
LW		 2779 /* [Comments and code from Len Reed]
2780 * MS-DOS "user" is similar to UNIX's "superuser," but can't write
2781 * to write-protected files. The execute permission bit is set
486ec47a 2782 * by the Microsoft C library stat() function for the following:
fe14fcc3
LW		 2783 * .exe files
2784 * .com files
2785 * .bat files
2786 * directories
2787 * All files and directories are readable.
2788 * Directories and special files, e.g. "CON", cannot be
2789 * write-protected.
2790 * [Comment by Tom Dinger -- a directory can have the write-protect
2791 * bit set in the file system, but DOS permits changes to
2792 * the directory anyway. In addition, all bets are off
2793 * here for networked software, such as Novell and
2794 * Sun's PC-NFS.]
2795 */
2796
bee1dbe2
LW		 2797 /* Atari stat() does pretty much the same thing. we set x_bit_set_in_stat
2798 * too so it will actually look into the files for magic numbers
2799 */
8298454c 2800 return cBOOL(mode & statbufp->st_mode);
fe14fcc3 2801
55497cff 2802#else /* ! DOSISH */
b595cd4b
RU		 2803# ifdef __CYGWIN__
2804 if (ingroup(544,effective)) { /* member of Administrators */
2805# else
985213f2 2806 if ((effective ? PerlProc_geteuid() : PerlProc_getuid()) == 0) { /* root is special */
b595cd4b 2807# endif
7f4774ae 2808 if (mode == S_IXUSR) {
c623bd54 2809 if (statbufp->st_mode & 0111 || S_ISDIR(statbufp->st_mode))
a687059c
LW		 2810 return TRUE;
2811 }
2812 else
2813 return TRUE; /* root reads and writes anything */
2814 return FALSE;
2815 }
985213f2 2816 if (statbufp->st_uid == (effective ? PerlProc_geteuid() : PerlProc_getuid()) ) {
7f4774ae 2817 if (statbufp->st_mode & mode)
a687059c
LW		 2818 return TRUE; /* ok as "user" */
2819 }
d8eceb89 2820 else if (ingroup(statbufp->st_gid,effective)) {
7f4774ae 2821 if (statbufp->st_mode & mode >> 3)
a687059c
LW		 2822 return TRUE; /* ok as "group" */
2823 }
7f4774ae 2824 else if (statbufp->st_mode & mode >> 6)
a687059c
LW		 2825 return TRUE; /* ok as "other" */
2826 return FALSE;
55497cff 2827#endif /* ! DOSISH */
a687059c 2828}
a0d0e21e 2829#endif /* ! VMS */
a687059c 2830
1f676739 2831static bool
0da8eb3a 2832S_ingroup(pTHX_ Gid_t testgid, bool effective)
a687059c 2833{
81611534
JH		 2834#ifndef PERL_IMPLICIT_SYS
2835 /* PERL_IMPLICIT_SYS like Win32: getegid() etc. require the context. */
2836 PERL_UNUSED_CONTEXT;
2837#endif
985213f2 2838 if (testgid == (effective ? PerlProc_getegid() : PerlProc_getgid()))
a687059c 2839 return TRUE;
fe14fcc3 2840#ifdef HAS_GETGROUPS
a687059c 2841 {
331b57bc 2842 Groups_t *gary = NULL;
79072805 2843 I32 anum;
331b57bc 2844 bool rc = FALSE;
a687059c 2845
331b57bc 2846 anum = getgroups(0, gary);
375ed12a
JH		 2847 if (anum > 0) {
2848 Newx(gary, anum, Groups_t);
2849 anum = getgroups(anum, gary);
2850 while (--anum >= 0)
2851 if (gary[anum] == testgid) {
2852 rc = TRUE;
2853 break;
2854 }
331b57bc 2855
375ed12a
JH		 2856 Safefree(gary);
2857 }
331b57bc 2858 return rc;
a687059c 2859 }
c685562b 2860#else
a687059c 2861 return FALSE;
cd39f2b6 2862#endif
a687059c 2863}
c2ab57d4 2864
fe14fcc3 2865#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
c2ab57d4 2866
79072805 2867I32
864dbfa3 2868Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp)
c2ab57d4 2869{
0bcc34c2 2870 const key_t key = (key_t)SvNVx(*++mark);
c3312966 2871 SV *nsv = optype == OP_MSGGET ? NULL : *++mark;
6867be6d 2872 const I32 flags = SvIVx(*++mark);
294a48e9 2873
7918f24d 2874 PERL_ARGS_ASSERT_DO_IPCGET;
294a48e9 2875 PERL_UNUSED_ARG(sp);
c2ab57d4 2876
748a9306 2877 SETERRNO(0,0);
c2ab57d4
LW		 2878 switch (optype)
2879 {
fe14fcc3 2880#ifdef HAS_MSG
79072805 2881 case OP_MSGGET:
c2ab57d4 2882 return msgget(key, flags);
e5d73d77 2883#endif
fe14fcc3 2884#ifdef HAS_SEM
79072805 2885 case OP_SEMGET:
c3312966 2886 return semget(key, (int) SvIV(nsv), flags);
e5d73d77 2887#endif
fe14fcc3 2888#ifdef HAS_SHM
79072805 2889 case OP_SHMGET:
c3312966 2890 return shmget(key, (size_t) SvUV(nsv), flags);
e5d73d77 2891#endif
fe14fcc3 2892#if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
e5d73d77 2893 default:
fe13d51d 2894 /* diag_listed_as: msg%s not implemented */
cea2e8a9 2895 Perl_croak(aTHX_ "%s not implemented", PL_op_desc[optype]);
e5d73d77 2896#endif
c2ab57d4
LW		 2897 }
2898 return -1; /* should never happen */
2899}
2900
79072805 2901I32
864dbfa3 2902Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp)
c2ab57d4 2903{
c2ab57d4 2904 char *a;
a0d0e21e 2905 I32 ret = -1;
6867be6d 2906 const I32 id = SvIVx(*++mark);
95b63a38 2907#ifdef Semctl
6867be6d 2908 const I32 n = (optype == OP_SEMCTL) ? SvIVx(*++mark) : 0;
95b63a38 2909#endif
6867be6d 2910 const I32 cmd = SvIVx(*++mark);
0bcc34c2
AL		 2911 SV * const astr = *++mark;
2912 STRLEN infosize = 0;
2913 I32 getinfo = (cmd == IPC_STAT);
c2ab57d4 2914
7918f24d 2915 PERL_ARGS_ASSERT_DO_IPCCTL;
0bcc34c2 2916 PERL_UNUSED_ARG(sp);
c2ab57d4
LW		 2917
2918 switch (optype)
2919 {
fe14fcc3 2920#ifdef HAS_MSG
79072805 2921 case OP_MSGCTL:
c2ab57d4
LW		 2922 if (cmd == IPC_STAT || cmd == IPC_SET)
2923 infosize = sizeof(struct msqid_ds);
2924 break;
e5d73d77 2925#endif
fe14fcc3 2926#ifdef HAS_SHM
79072805 2927 case OP_SHMCTL:
c2ab57d4
LW		 2928 if (cmd == IPC_STAT || cmd == IPC_SET)
2929 infosize = sizeof(struct shmid_ds);
2930 break;
e5d73d77 2931#endif
fe14fcc3 2932#ifdef HAS_SEM
79072805 2933 case OP_SEMCTL:
39398f3f 2934#ifdef Semctl
c2ab57d4
LW		 2935 if (cmd == IPC_STAT || cmd == IPC_SET)
2936 infosize = sizeof(struct semid_ds);
2937 else if (cmd == GETALL || cmd == SETALL)
2938 {
8e591e46 2939 struct semid_ds semds;
bd89102f 2940 union semun semun;
e6f0bdd6
GS		 2941#ifdef EXTRA_F_IN_SEMUN_BUF
2942 semun.buff = &semds;
2943#else
84902520 2944 semun.buf = &semds;
e6f0bdd6 2945#endif
c2ab57d4 2946 getinfo = (cmd == GETALL);
9b89d93d
GB		 2947 if (Semctl(id, 0, IPC_STAT, semun) == -1)
2948 return -1;
6e21c824
LW		 2949 infosize = semds.sem_nsems * sizeof(short);
2950 /* "short" is technically wrong but much more portable
2951 than guessing about u_?short(_t)? */
c2ab57d4 2952 }
39398f3f 2953#else
fe13d51d 2954 /* diag_listed_as: sem%s not implemented */
cea2e8a9 2955 Perl_croak(aTHX_ "%s not implemented", PL_op_desc[optype]);
39398f3f 2956#endif
c2ab57d4 2957 break;
e5d73d77 2958#endif
fe14fcc3 2959#if !defined(HAS_MSG) || !defined(HAS_SEM) || !defined(HAS_SHM)
e5d73d77 2960 default:
fe13d51d 2961 /* diag_listed_as: shm%s not implemented */
cea2e8a9 2962 Perl_croak(aTHX_ "%s not implemented", PL_op_desc[optype]);
e5d73d77 2963#endif
c2ab57d4
LW		 2964 }
2965
2966 if (infosize)
2967 {
2968 if (getinfo)
2969 {
93524f2b 2970 SvPV_force_nolen(astr);
a0d0e21e 2971 a = SvGROW(astr, infosize+1);
c2ab57d4
LW		 2972 }
2973 else
2974 {
93524f2b 2975 STRLEN len;
463ee0b2
LW		 2976 a = SvPV(astr, len);
2977 if (len != infosize)
cea2e8a9 2978 Perl_croak(aTHX_ "Bad arg length for %s, is %lu, should be %ld",
4ec43091
JH		 2979 PL_op_desc[optype],
2980 (unsigned long)len,
2981 (long)infosize);
c2ab57d4
LW		 2982 }
2983 }
2984 else
2985 {
0bcc34c2 2986 const IV i = SvIV(astr);
56431972 2987 a = INT2PTR(char *,i); /* ouch */
c2ab57d4 2988 }
748a9306 2989 SETERRNO(0,0);
c2ab57d4
LW		 2990 switch (optype)
2991 {
fe14fcc3 2992#ifdef HAS_MSG
79072805 2993 case OP_MSGCTL:
bee1dbe2 2994 ret = msgctl(id, cmd, (struct msqid_ds *)a);
c2ab57d4 2995 break;
e5d73d77 2996#endif
fe14fcc3 2997#ifdef HAS_SEM
bd89102f 2998 case OP_SEMCTL: {
39398f3f 2999#ifdef Semctl
bd89102f
AD		 3000 union semun unsemds;
3001
64d76282
BC		 3002 if(cmd == SETVAL) {
3003 unsemds.val = PTR2nat(a);
3004 }
3005 else {
e6f0bdd6 3006#ifdef EXTRA_F_IN_SEMUN_BUF
64d76282 3007 unsemds.buff = (struct semid_ds *)a;
e6f0bdd6 3008#else
64d76282 3009 unsemds.buf = (struct semid_ds *)a;
e6f0bdd6 3010#endif
64d76282 3011 }
bd89102f 3012 ret = Semctl(id, n, cmd, unsemds);
39398f3f 3013#else
fe13d51d 3014 /* diag_listed_as: sem%s not implemented */
cea2e8a9 3015 Perl_croak(aTHX_ "%s not implemented", PL_op_desc[optype]);
39398f3f 3016#endif
bd89102f 3017 }
c2ab57d4 3018 break;
e5d73d77 3019#endif
fe14fcc3 3020#ifdef HAS_SHM
79072805 3021 case OP_SHMCTL:
bee1dbe2 3022 ret = shmctl(id, cmd, (struct shmid_ds *)a);
c2ab57d4 3023 break;
e5d73d77 3024#endif
c2ab57d4
LW		 3025 }
3026 if (getinfo && ret >= 0) {
79072805
LW		 3027 SvCUR_set(astr, infosize);
3028 *SvEND(astr) = '\0';
a0d0e21e 3029 SvSETMAGIC(astr);
c2ab57d4
LW		 3030 }
3031 return ret;
3032}
3033
79072805 3034I32
864dbfa3 3035Perl_do_msgsnd(pTHX_ SV **mark, SV **sp)
c2ab57d4 3036{
fe14fcc3 3037#ifdef HAS_MSG
463ee0b2 3038 STRLEN len;
6867be6d 3039 const I32 id = SvIVx(*++mark);
0bcc34c2
AL		 3040 SV * const mstr = *++mark;
3041 const I32 flags = SvIVx(*++mark);
3042 const char * const mbuf = SvPV_const(mstr, len);
3043 const I32 msize = len - sizeof(long);
3044
7918f24d 3045 PERL_ARGS_ASSERT_DO_MSGSND;
890ce7af 3046 PERL_UNUSED_ARG(sp);
c2ab57d4 3047
0bcc34c2 3048 if (msize < 0)
cea2e8a9 3049 Perl_croak(aTHX_ "Arg too short for msgsnd");
748a9306 3050 SETERRNO(0,0);
681fb693
JH		 3051 if (id >= 0 && flags >= 0) {
3052 return msgsnd(id, (struct msgbuf *)mbuf, msize, flags);
3053 } else {
3054 SETERRNO(EINVAL,LIB_INVARG);
3055 return -1;
3056 }
e5d73d77 3057#else
2d51fa4d
RGS		 3058 PERL_UNUSED_ARG(sp);
3059 PERL_UNUSED_ARG(mark);
fe13d51d 3060 /* diag_listed_as: msg%s not implemented */
cea2e8a9 3061 Perl_croak(aTHX_ "msgsnd not implemented");
7c522378 3062 return -1;
e5d73d77 3063#endif
c2ab57d4
LW		 3064}
3065
79072805 3066I32
864dbfa3 3067Perl_do_msgrcv(pTHX_ SV **mark, SV **sp)
c2ab57d4 3068{
fe14fcc3 3069#ifdef HAS_MSG
c2ab57d4
LW		 3070 char *mbuf;
3071 long mtype;
6867be6d 3072 I32 msize, flags, ret;
6867be6d 3073 const I32 id = SvIVx(*++mark);
0bcc34c2 3074 SV * const mstr = *++mark;
7918f24d
NC		 3075
3076 PERL_ARGS_ASSERT_DO_MSGRCV;
890ce7af 3077 PERL_UNUSED_ARG(sp);
79072805 3078
c2e66d9e
GS		 3079 /* suppress warning when reading into undef var --jhi */
3080 if (! SvOK(mstr))
8062ff11 3081 SvPVCLEAR(mstr);
463ee0b2
LW		 3082 msize = SvIVx(*++mark);
3083 mtype = (long)SvIVx(*++mark);
3084 flags = SvIVx(*++mark);
93524f2b 3085 SvPV_force_nolen(mstr);
a0d0e21e 3086 mbuf = SvGROW(mstr, sizeof(long)+msize+1);
a1d180c4 3087
748a9306 3088 SETERRNO(0,0);
d2607e1e
JH		 3089 if (id >= 0 && msize >= 0 && flags >= 0) {
3090 ret = msgrcv(id, (struct msgbuf *)mbuf, msize, mtype, flags);
3091 } else {
3092 SETERRNO(EINVAL,LIB_INVARG);
3093 ret = -1;
3094 }
c2ab57d4 3095 if (ret >= 0) {
79072805
LW		 3096 SvCUR_set(mstr, sizeof(long)+ret);
3097 *SvEND(mstr) = '\0';
41d6edb2
JH		 3098 /* who knows who has been playing with this message? */
3099 SvTAINTED_on(mstr);
c2ab57d4
LW		 3100 }
3101 return ret;
e5d73d77 3102#else
2d51fa4d
RGS		 3103 PERL_UNUSED_ARG(sp);
3104 PERL_UNUSED_ARG(mark);
fe13d51d 3105 /* diag_listed_as: msg%s not implemented */
cea2e8a9 3106 Perl_croak(aTHX_ "msgrcv not implemented");
7c522378 3107 return -1;
e5d73d77 3108#endif
c2ab57d4
LW		 3109}
3110
79072805 3111I32
864dbfa3 3112Perl_do_semop(pTHX_ SV **mark, SV **sp)
c2ab57d4 3113{
fe14fcc3 3114#ifdef HAS_SEM
463ee0b2 3115 STRLEN opsize;
6867be6d 3116 const I32 id = SvIVx(*++mark);
0bcc34c2
AL		 3117 SV * const opstr = *++mark;
3118 const char * const opbuf = SvPV_const(opstr, opsize);
7918f24d
NC		 3119
3120 PERL_ARGS_ASSERT_DO_SEMOP;
890ce7af 3121 PERL_UNUSED_ARG(sp);
c2ab57d4 3122
248ff010
NC		 3123 if (opsize < 3 * SHORTSIZE
3124 || (opsize % (3 * SHORTSIZE))) {
93189314 3125 SETERRNO(EINVAL,LIB_INVARG);
c2ab57d4
LW		 3126 return -1;
3127 }
748a9306 3128 SETERRNO(0,0);
248ff010
NC		 3129 /* We can't assume that sizeof(struct sembuf) == 3 * sizeof(short). */
3130 {
6867be6d 3131 const int nsops = opsize / (3 * sizeof (short));
248ff010 3132 int i = nsops;
0bcc34c2 3133 short * const ops = (short *) opbuf;
248ff010
NC		 3134 short *o = ops;
3135 struct sembuf *temps, *t;
3136 I32 result;
3137
a02a5408 3138 Newx (temps, nsops, struct sembuf);
248ff010
NC		 3139 t = temps;
3140 while (i--) {
3141 t->sem_num = *o++;
3142 t->sem_op = *o++;
3143 t->sem_flg = *o++;
3144 t++;
3145 }
3146 result = semop(id, temps, nsops);
248ff010
NC		 3147 Safefree(temps);
3148 return result;
3149 }
e5d73d77 3150#else
fe13d51d 3151 /* diag_listed_as: sem%s not implemented */
cea2e8a9 3152 Perl_croak(aTHX_ "semop not implemented");
e5d73d77 3153#endif
c2ab57d4
LW		 3154}
3155
79072805 3156I32
864dbfa3 3157Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp)
c2ab57d4 3158{
fe14fcc3 3159#ifdef HAS_SHM
4373e329 3160 char *shm;
c2ab57d4 3161 struct shmid_ds shmds;
6867be6d 3162 const I32 id = SvIVx(*++mark);
0bcc34c2
AL		 3163 SV * const mstr = *++mark;
3164 const I32 mpos = SvIVx(*++mark);
3165 const I32 msize = SvIVx(*++mark);
7918f24d
NC		 3166
3167 PERL_ARGS_ASSERT_DO_SHMIO;
890ce7af 3168 PERL_UNUSED_ARG(sp);
c2ab57d4 3169
748a9306 3170 SETERRNO(0,0);
c2ab57d4
LW		 3171 if (shmctl(id, IPC_STAT, &shmds) == -1)
3172 return -1;
7f39519f
NC		 3173 if (mpos < 0 || msize < 0
3174 || (size_t)mpos + msize > (size_t)shmds.shm_segsz) {
93189314 3175 SETERRNO(EFAULT,SS_ACCVIO); /* can't do as caller requested */
c2ab57d4
LW		 3176 return -1;
3177 }
568fc267
JH		 3178 if (id >= 0) {
3179 shm = (char *)shmat(id, NULL, (optype == OP_SHMREAD) ? SHM_RDONLY : 0);
3180 } else {
3181 SETERRNO(EINVAL,LIB_INVARG);
3182 return -1;
3183 }
c2ab57d4
LW		 3184 if (shm == (char *)-1) /* I hate System V IPC, I really do */
3185 return -1;
79072805 3186 if (optype == OP_SHMREAD) {
c8ae91a8 3187 char *mbuf;
9f538c04 3188 /* suppress warning when reading into undef var (tchrist 3/Mar/00) */
b399897d
CS		 3189 SvGETMAGIC(mstr);
3190 SvUPGRADE(mstr, SVt_PV);
9f538c04 3191 if (! SvOK(mstr))
8062ff11 3192 SvPVCLEAR(mstr);
af8ff727 3193 SvPOK_only(mstr);
bb7a0f54 3194 mbuf = SvGROW(mstr, (STRLEN)msize+1);
a0d0e21e 3195
bee1dbe2 3196 Copy(shm + mpos, mbuf, msize, char);
79072805
LW		 3197 SvCUR_set(mstr, msize);
3198 *SvEND(mstr) = '\0';
a0d0e21e 3199 SvSETMAGIC(mstr);
d929ce6f
JH		 3200 /* who knows who has been playing with this shared memory? */
3201 SvTAINTED_on(mstr);
c2ab57d4
LW		 3202 }
3203 else {
93524f2b 3204 STRLEN len;
c2ab57d4 3205
93524f2b 3206 const char *mbuf = SvPV_const(mstr, len);
027aa12d 3207 const I32 n = ((I32)len > msize) ? msize : (I32)len;
bee1dbe2 3208 Copy(mbuf, shm + mpos, n, char);
c2ab57d4 3209 if (n < msize)
bee1dbe2 3210 memzero(shm + mpos + n, msize - n);
c2ab57d4
LW		 3211 }
3212 return shmdt(shm);
e5d73d77 3213#else
fe13d51d 3214 /* diag_listed_as: shm%s not implemented */
cea2e8a9 3215 Perl_croak(aTHX_ "shm I/O not implemented");
7c522378 3216 return -1;
e5d73d77 3217#endif
c2ab57d4
LW		 3218}
3219
fe14fcc3 3220#endif /* SYSV IPC */
4e35701f 3221
0d44d22b 3222/*
ccfc67b7
JH		 3223=head1 IO Functions
3224
0d44d22b
NC		 3225=for apidoc start_glob
3226
3227Function called by C<do_readline> to spawn a glob (or do the glob inside
154e47c8 3228perl on VMS). This code used to be inline, but now perl uses C<File::Glob>
25047fde
KW		 3229this glob starter is only used by miniperl during the build process,
3230or when PERL_EXTERNAL_GLOB is defined.
75af9d73 3231Moving it away shrinks F<pp_hot.c>; shrinking F<pp_hot.c> helps speed perl up.
fab3f3a7 3232
0d44d22b
NC		 3233=cut
3234*/
3235
3236PerlIO *
3237Perl_start_glob (pTHX_ SV *tmpglob, IO *io)
3238{
561b68a9 3239 SV * const tmpcmd = newSV(0);
0d44d22b 3240 PerlIO *fp;
41188aa0
TC		 3241 STRLEN len;
3242 const char *s = SvPV(tmpglob, len);
7918f24d
NC		 3243
3244 PERL_ARGS_ASSERT_START_GLOB;
3245
41188aa0 3246 if (!IS_SAFE_SYSCALL(s, len, "pattern", "glob"))
c8028aa6
TC		 3247 return NULL;
3248
0d44d22b
NC		 3249 ENTER;
3250 SAVEFREESV(tmpcmd);
3251#ifdef VMS /* expand the wildcards right here, rather than opening a pipe, */
3252 /* since spawning off a process is a real performance hit */
dca5a913 3253
1cc9774b
CB		 3254PerlIO *
3255Perl_vms_start_glob
3256 (pTHX_ SV *tmpglob,
3257 IO *io);
3258
49a7a762 3259 fp = Perl_vms_start_glob(aTHX_ tmpglob, io);
dca5a913 3260
0d44d22b 3261#else /* !VMS */
4009c3ff
AC		 3262# ifdef DOSISH
3263# if defined(OS2)
0d44d22b
NC		 3264 sv_setpv(tmpcmd, "for a in ");
3265 sv_catsv(tmpcmd, tmpglob);
f8db7d5b 3266 sv_catpvs(tmpcmd, "; do echo \"$a\\0\\c\"; done |");
4009c3ff 3267# elif defined(DJGPP)
0d44d22b
NC		 3268 sv_setpv(tmpcmd, "/dev/dosglob/"); /* File System Extension */
3269 sv_catsv(tmpcmd, tmpglob);
4009c3ff 3270# else
0d44d22b
NC		 3271 sv_setpv(tmpcmd, "perlglob ");
3272 sv_catsv(tmpcmd, tmpglob);
f8db7d5b 3273 sv_catpvs(tmpcmd, " |");
4009c3ff
AC		 3274# endif
3275# elif defined(CSH)
0d44d22b 3276 sv_setpvn(tmpcmd, PL_cshname, PL_cshlen);
f8db7d5b 3277 sv_catpvs(tmpcmd, " -cf 'set nonomatch; glob ");
0d44d22b 3278 sv_catsv(tmpcmd, tmpglob);
f8db7d5b 3279 sv_catpvs(tmpcmd, "' 2>/dev/null |");
4009c3ff 3280# else
0d44d22b
NC		 3281 sv_setpv(tmpcmd, "echo ");
3282 sv_catsv(tmpcmd, tmpglob);
f8db7d5b 3283 sv_catpvs(tmpcmd, "|tr -s ' \t\f\r' '\\n\\n\\n\\n'|");
4009c3ff 3284# endif /* !DOSISH && !CSH */
93b2dae1 3285 {
acffc8af
FC		 3286 SV ** const svp = hv_fetchs(GvHVn(PL_envgv), "LS_COLORS", 0);
3287 if (svp && *svp)
3288 save_helem_flags(GvHV(PL_envgv),
3289 newSVpvs_flags("LS_COLORS", SVs_TEMP), svp,
3290 SAVEf_SETMAGIC);
93b2dae1 3291 }
d5eb9a46
NC		 3292 (void)do_open6(PL_last_in_gv, SvPVX_const(tmpcmd), SvCUR(tmpcmd),
3293 NULL, NULL, 0);
0d44d22b
NC		 3294 fp = IoIFP(io);
3295#endif /* !VMS */
3296 LEAVE;
de7dabb6
TC		 3297
3298 if (!fp && ckWARN(WARN_GLOB)) {
3299 Perl_warner(aTHX_ packWARN(WARN_GLOB), "glob failed (can't start child: %s)",
3300 Strerror(errno));
3301 }
3302
0d44d22b
NC		 3303 return fp;
3304}
66610fdd
RGS		 3305
3306/*
14d04a33 3307 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3308 */
Unnamed repository; edit this file 'description' to name the repository.