This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
delete thrdvar.h and move its contents to intrpvar.h
[perl5.git] / perl.c
1 /*    perl.c
2  *
3  *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4  *    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  */
10
11 /*
12  * "A ship then new they built for him/of mithril and of elven glass" --Bilbo
13  */
14
15 /* This file contains the top-level functions that are used to create, use
16  * and destroy a perl interpreter, plus the functions used by XS code to
17  * call back into perl. Note that it does not contain the actual main()
18  * function of the interpreter; that can be found in perlmain.c
19  */
20
21 /* PSz 12 Nov 03
22  * 
23  * Be proud that perl(1) may proclaim:
24  *   Setuid Perl scripts are safer than C programs ...
25  * Do not abandon (deprecate) suidperl. Do not advocate C wrappers.
26  * 
27  * The flow was: perl starts, notices script is suid, execs suidperl with same
28  * arguments; suidperl opens script, checks many things, sets itself with
29  * right UID, execs perl with similar arguments but with script pre-opened on
30  * /dev/fd/xxx; perl checks script is as should be and does work. This was
31  * insecure: see perlsec(1) for many problems with this approach.
32  * 
33  * The "correct" flow should be: perl starts, opens script and notices it is
34  * suid, checks many things, execs suidperl with similar arguments but with
35  * script on /dev/fd/xxx; suidperl checks script and /dev/fd/xxx object are
36  * same, checks arguments match #! line, sets itself with right UID, execs
37  * perl with same arguments; perl checks many things and does work.
38  * 
39  * (Opening the script in perl instead of suidperl, we "lose" scripts that
40  * are readable to the target UID but not to the invoker. Where did
41  * unreadable scripts work anyway?)
42  * 
43  * For now, suidperl and perl are pretty much the same large and cumbersome
44  * program, so suidperl can check its argument list (see comments elsewhere).
45  * 
46  * References:
47  * Original bug report:
48  *   http://bugs.perl.org/index.html?req=bug_id&bug_id=20010322.218
49  *   http://rt.perl.org/rt2/Ticket/Display.html?id=6511
50  * Comments and discussion with Debian:
51  *   http://bugs.debian.org/203426
52  *   http://bugs.debian.org/220486
53  * Debian Security Advisory DSA 431-1 (does not fully fix problem):
54  *   http://www.debian.org/security/2004/dsa-431
55  * CVE candidate:
56  *   http://cve.mitre.org/cgi-bin/cvename.cgi?name=CAN-2003-0618
57  * Previous versions of this patch sent to perl5-porters:
58  *   http://www.mail-archive.com/perl5-porters@perl.org/msg71953.html
59  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75245.html
60  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75563.html
61  *   http://www.mail-archive.com/perl5-porters@perl.org/msg75635.html
62  * 
63 Paul Szabo - psz@maths.usyd.edu.au  http://www.maths.usyd.edu.au:8000/u/psz/
64 School of Mathematics and Statistics  University of Sydney   2006  Australia
65  * 
66  */
67 /* PSz 13 Nov 03
68  * Use truthful, neat, specific error messages.
69  * Cannot always hide the truth; security must not depend on doing so.
70  */
71
72 /* PSz 18 Feb 04
73  * Use global(?), thread-local fdscript for easier checks.
74  * (I do not understand how we could possibly get a thread race:
75  * do not all threads go through the same initialization? Or in
76  * fact, are not threads started only after we get the script and
77  * so know what to do? Oh well, make things super-safe...)
78  */
79
80 #include "EXTERN.h"
81 #define PERL_IN_PERL_C
82 #include "perl.h"
83 #include "patchlevel.h"                 /* for local_patches */
84
85 #ifdef NETWARE
86 #include "nwutil.h"     
87 char *nw_get_sitelib(const char *pl);
88 #endif
89
90 /* XXX If this causes problems, set i_unistd=undef in the hint file.  */
91 #ifdef I_UNISTD
92 #include <unistd.h>
93 #endif
94
95 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
96 #  ifdef I_SYS_WAIT
97 #   include <sys/wait.h>
98 #  endif
99 #  ifdef I_SYSUIO
100 #    include <sys/uio.h>
101 #  endif
102
103 union control_un {
104   struct cmsghdr cm;
105   char control[CMSG_SPACE(sizeof(int))];
106 };
107
108 #endif
109
110 #ifdef __BEOS__
111 #  define HZ 1000000
112 #endif
113
114 #ifndef HZ
115 #  ifdef CLK_TCK
116 #    define HZ CLK_TCK
117 #  else
118 #    define HZ 60
119 #  endif
120 #endif
121
122 #if !defined(STANDARD_C) && !defined(HAS_GETENV_PROTOTYPE) && !defined(PERL_MICRO)
123 char *getenv (char *); /* Usually in <stdlib.h> */
124 #endif
125
126 static I32 read_e_script(pTHX_ int idx, SV *buf_sv, int maxlen);
127
128 #ifdef IAMSUID
129 #ifndef DOSUID
130 #define DOSUID
131 #endif
132 #endif /* IAMSUID */
133
134 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
135 #ifdef DOSUID
136 #undef DOSUID
137 #endif
138 #endif
139
140 #define CALL_BODY_EVAL(myop) \
141     if (PL_op == (myop)) \
142         PL_op = Perl_pp_entereval(aTHX); \
143     if (PL_op) \
144         CALLRUNOPS(aTHX);
145
146 #define CALL_BODY_SUB(myop) \
147     if (PL_op == (myop)) \
148         PL_op = Perl_pp_entersub(aTHX); \
149     if (PL_op) \
150         CALLRUNOPS(aTHX);
151
152 #define CALL_LIST_BODY(cv) \
153     PUSHMARK(PL_stack_sp); \
154     call_sv((SV*)(cv), G_EVAL|G_DISCARD);
155
156 static void
157 S_init_tls_and_interp(PerlInterpreter *my_perl)
158 {
159     dVAR;
160     if (!PL_curinterp) {                        
161         PERL_SET_INTERP(my_perl);
162 #if defined(USE_ITHREADS)
163         INIT_THREADS;
164         ALLOC_THREAD_KEY;
165         PERL_SET_THX(my_perl);
166         OP_REFCNT_INIT;
167         HINTS_REFCNT_INIT;
168         MUTEX_INIT(&PL_dollarzero_mutex);
169 #  endif
170 #ifdef PERL_IMPLICIT_CONTEXT
171         MUTEX_INIT(&PL_my_ctx_mutex);
172 #  endif
173     }
174 #if defined(USE_ITHREADS)
175     else
176 #else
177     /* This always happens for non-ithreads  */
178 #endif
179     {
180         PERL_SET_THX(my_perl);
181     }
182 }
183
184 #ifdef PERL_IMPLICIT_SYS
185 PerlInterpreter *
186 perl_alloc_using(struct IPerlMem* ipM, struct IPerlMem* ipMS,
187                  struct IPerlMem* ipMP, struct IPerlEnv* ipE,
188                  struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
189                  struct IPerlDir* ipD, struct IPerlSock* ipS,
190                  struct IPerlProc* ipP)
191 {
192     PerlInterpreter *my_perl;
193     /* Newx() needs interpreter, so call malloc() instead */
194     my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
195     S_init_tls_and_interp(my_perl);
196     Zero(my_perl, 1, PerlInterpreter);
197     PL_Mem = ipM;
198     PL_MemShared = ipMS;
199     PL_MemParse = ipMP;
200     PL_Env = ipE;
201     PL_StdIO = ipStd;
202     PL_LIO = ipLIO;
203     PL_Dir = ipD;
204     PL_Sock = ipS;
205     PL_Proc = ipP;
206     INIT_TRACK_MEMPOOL(PL_memory_debug_header, my_perl);
207
208     return my_perl;
209 }
210 #else
211
212 /*
213 =head1 Embedding Functions
214
215 =for apidoc perl_alloc
216
217 Allocates a new Perl interpreter.  See L<perlembed>.
218
219 =cut
220 */
221
222 PerlInterpreter *
223 perl_alloc(void)
224 {
225     PerlInterpreter *my_perl;
226
227     /* Newx() needs interpreter, so call malloc() instead */
228     my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
229
230     S_init_tls_and_interp(my_perl);
231 #ifndef PERL_TRACK_MEMPOOL
232     return (PerlInterpreter *) ZeroD(my_perl, 1, PerlInterpreter);
233 #else
234     Zero(my_perl, 1, PerlInterpreter);
235     INIT_TRACK_MEMPOOL(PL_memory_debug_header, my_perl);
236     return my_perl;
237 #endif
238 }
239 #endif /* PERL_IMPLICIT_SYS */
240
241 /*
242 =for apidoc perl_construct
243
244 Initializes a new Perl interpreter.  See L<perlembed>.
245
246 =cut
247 */
248
249 void
250 perl_construct(pTHXx)
251 {
252     dVAR;
253     PERL_UNUSED_ARG(my_perl);
254 #ifdef MULTIPLICITY
255     init_interp();
256     PL_perl_destruct_level = 1;
257 #else
258    if (PL_perl_destruct_level > 0)
259        init_interp();
260 #endif
261     PL_curcop = &PL_compiling;  /* needed by ckWARN, right away */
262
263     /* set read-only and try to insure than we wont see REFCNT==0
264        very often */
265
266     SvREADONLY_on(&PL_sv_undef);
267     SvREFCNT(&PL_sv_undef) = (~(U32)0)/2;
268
269     sv_setpv(&PL_sv_no,PL_No);
270     /* value lookup in void context - happens to have the side effect
271        of caching the numeric forms.  */
272     SvIV(&PL_sv_no);
273     SvNV(&PL_sv_no);
274     SvREADONLY_on(&PL_sv_no);
275     SvREFCNT(&PL_sv_no) = (~(U32)0)/2;
276
277     sv_setpv(&PL_sv_yes,PL_Yes);
278     SvIV(&PL_sv_yes);
279     SvNV(&PL_sv_yes);
280     SvREADONLY_on(&PL_sv_yes);
281     SvREFCNT(&PL_sv_yes) = (~(U32)0)/2;
282
283     SvREADONLY_on(&PL_sv_placeholder);
284     SvREFCNT(&PL_sv_placeholder) = (~(U32)0)/2;
285
286     PL_sighandlerp = (Sighandler_t) Perl_sighandler;
287 #ifdef PERL_USES_PL_PIDSTATUS
288     PL_pidstatus = newHV();
289 #endif
290
291     PL_rs = newSVpvs("\n");
292
293     init_stacks();
294
295     init_ids();
296
297     JMPENV_BOOTSTRAP;
298     STATUS_ALL_SUCCESS;
299
300     init_i18nl10n(1);
301     SET_NUMERIC_STANDARD();
302
303 #if defined(LOCAL_PATCH_COUNT)
304     PL_localpatches = local_patches;    /* For possible -v */
305 #endif
306
307 #ifdef HAVE_INTERP_INTERN
308     sys_intern_init();
309 #endif
310
311     PerlIO_init(aTHX);                  /* Hook to IO system */
312
313     PL_fdpid = newAV();                 /* for remembering popen pids by fd */
314     PL_modglobal = newHV();             /* pointers to per-interpreter module globals */
315     PL_errors = newSVpvs("");
316     sv_setpvn(PERL_DEBUG_PAD(0), "", 0);        /* For regex debugging. */
317     sv_setpvn(PERL_DEBUG_PAD(1), "", 0);        /* ext/re needs these */
318     sv_setpvn(PERL_DEBUG_PAD(2), "", 0);        /* even without DEBUGGING. */
319 #ifdef USE_ITHREADS
320     /* First entry is an array of empty elements */
321     Perl_av_create_and_push(aTHX_ &PL_regex_padav,(SV*)newAV());
322     PL_regex_pad = AvARRAY(PL_regex_padav);
323 #endif
324 #ifdef USE_REENTRANT_API
325     Perl_reentrant_init(aTHX);
326 #endif
327
328     /* Note that strtab is a rather special HV.  Assumptions are made
329        about not iterating on it, and not adding tie magic to it.
330        It is properly deallocated in perl_destruct() */
331     PL_strtab = newHV();
332
333     HvSHAREKEYS_off(PL_strtab);                 /* mandatory */
334     hv_ksplit(PL_strtab, 512);
335
336 #if defined(__DYNAMIC__) && (defined(NeXT) || defined(__NeXT__))
337     _dyld_lookup_and_bind
338         ("__environ", (unsigned long *) &environ_pointer, NULL);
339 #endif /* environ */
340
341 #ifndef PERL_MICRO
342 #   ifdef  USE_ENVIRON_ARRAY
343     PL_origenviron = environ;
344 #   endif
345 #endif
346
347     /* Use sysconf(_SC_CLK_TCK) if available, if not
348      * available or if the sysconf() fails, use the HZ.
349      * BeOS has those, but returns the wrong value.
350      * The HZ if not originally defined has been by now
351      * been defined as CLK_TCK, if available. */
352 #if defined(HAS_SYSCONF) && defined(_SC_CLK_TCK) && !defined(__BEOS__)
353     PL_clocktick = sysconf(_SC_CLK_TCK);
354     if (PL_clocktick <= 0)
355 #endif
356          PL_clocktick = HZ;
357
358     PL_stashcache = newHV();
359
360     PL_patchlevel = Perl_newSVpvf(aTHX_ "v%d.%d.%d", (int)PERL_REVISION,
361                                   (int)PERL_VERSION, (int)PERL_SUBVERSION);
362
363 #ifdef HAS_MMAP
364     if (!PL_mmap_page_size) {
365 #if defined(HAS_SYSCONF) && (defined(_SC_PAGESIZE) || defined(_SC_MMAP_PAGE_SIZE))
366       {
367         SETERRNO(0, SS_NORMAL);
368 #   ifdef _SC_PAGESIZE
369         PL_mmap_page_size = sysconf(_SC_PAGESIZE);
370 #   else
371         PL_mmap_page_size = sysconf(_SC_MMAP_PAGE_SIZE);
372 #   endif
373         if ((long) PL_mmap_page_size < 0) {
374           if (errno) {
375             SV * const error = ERRSV;
376             SvUPGRADE(error, SVt_PV);
377             Perl_croak(aTHX_ "panic: sysconf: %s", SvPV_nolen_const(error));
378           }
379           else
380             Perl_croak(aTHX_ "panic: sysconf: pagesize unknown");
381         }
382       }
383 #else
384 #   ifdef HAS_GETPAGESIZE
385       PL_mmap_page_size = getpagesize();
386 #   else
387 #       if defined(I_SYS_PARAM) && defined(PAGESIZE)
388       PL_mmap_page_size = PAGESIZE;       /* compiletime, bad */
389 #       endif
390 #   endif
391 #endif
392       if (PL_mmap_page_size <= 0)
393         Perl_croak(aTHX_ "panic: bad pagesize %" IVdf,
394                    (IV) PL_mmap_page_size);
395     }
396 #endif /* HAS_MMAP */
397
398 #if defined(HAS_TIMES) && defined(PERL_NEED_TIMESBASE)
399     PL_timesbase.tms_utime  = 0;
400     PL_timesbase.tms_stime  = 0;
401     PL_timesbase.tms_cutime = 0;
402     PL_timesbase.tms_cstime = 0;
403 #endif
404
405     ENTER;
406 }
407
408 /*
409 =for apidoc nothreadhook
410
411 Stub that provides thread hook for perl_destruct when there are
412 no threads.
413
414 =cut
415 */
416
417 int
418 Perl_nothreadhook(pTHX)
419 {
420     PERL_UNUSED_CONTEXT;
421     return 0;
422 }
423
424 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
425 void
426 Perl_dump_sv_child(pTHX_ SV *sv)
427 {
428     ssize_t got;
429     const int sock = PL_dumper_fd;
430     const int debug_fd = PerlIO_fileno(Perl_debug_log);
431     union control_un control;
432     struct msghdr msg;
433     struct iovec vec[2];
434     struct cmsghdr *cmptr;
435     int returned_errno;
436     unsigned char buffer[256];
437
438     if(sock == -1 || debug_fd == -1)
439         return;
440
441     PerlIO_flush(Perl_debug_log);
442
443     /* All these shenanigans are to pass a file descriptor over to our child for
444        it to dump out to.  We can't let it hold open the file descriptor when it
445        forks, as the file descriptor it will dump to can turn out to be one end
446        of pipe that some other process will wait on for EOF. (So as it would
447        be open, the wait would be forever.)  */
448
449     msg.msg_control = control.control;
450     msg.msg_controllen = sizeof(control.control);
451     /* We're a connected socket so we don't need a destination  */
452     msg.msg_name = NULL;
453     msg.msg_namelen = 0;
454     msg.msg_iov = vec;
455     msg.msg_iovlen = 1;
456
457     cmptr = CMSG_FIRSTHDR(&msg);
458     cmptr->cmsg_len = CMSG_LEN(sizeof(int));
459     cmptr->cmsg_level = SOL_SOCKET;
460     cmptr->cmsg_type = SCM_RIGHTS;
461     *((int *)CMSG_DATA(cmptr)) = 1;
462
463     vec[0].iov_base = (void*)&sv;
464     vec[0].iov_len = sizeof(sv);
465     got = sendmsg(sock, &msg, 0);
466
467     if(got < 0) {
468         perror("Debug leaking scalars parent sendmsg failed");
469         abort();
470     }
471     if(got < sizeof(sv)) {
472         perror("Debug leaking scalars parent short sendmsg");
473         abort();
474     }
475
476     /* Return protocol is
477        int:             errno value
478        unsigned char:   length of location string (0 for empty)
479        unsigned char*:  string (not terminated)
480     */
481     vec[0].iov_base = (void*)&returned_errno;
482     vec[0].iov_len = sizeof(returned_errno);
483     vec[1].iov_base = buffer;
484     vec[1].iov_len = 1;
485
486     got = readv(sock, vec, 2);
487
488     if(got < 0) {
489         perror("Debug leaking scalars parent read failed");
490         PerlIO_flush(PerlIO_stderr());
491         abort();
492     }
493     if(got < sizeof(returned_errno) + 1) {
494         perror("Debug leaking scalars parent short read");
495         PerlIO_flush(PerlIO_stderr());
496         abort();
497     }
498
499     if (*buffer) {
500         got = read(sock, buffer + 1, *buffer);
501         if(got < 0) {
502             perror("Debug leaking scalars parent read 2 failed");
503             PerlIO_flush(PerlIO_stderr());
504             abort();
505         }
506
507         if(got < *buffer) {
508             perror("Debug leaking scalars parent short read 2");
509             PerlIO_flush(PerlIO_stderr());
510             abort();
511         }
512     }
513
514     if (returned_errno || *buffer) {
515         Perl_warn(aTHX_ "Debug leaking scalars child failed%s%.*s with errno"
516                   " %d: %s", (*buffer ? " at " : ""), (int) *buffer, buffer + 1,
517                   returned_errno, strerror(returned_errno));
518     }
519 }
520 #endif
521
522 /*
523 =for apidoc perl_destruct
524
525 Shuts down a Perl interpreter.  See L<perlembed>.
526
527 =cut
528 */
529
530 int
531 perl_destruct(pTHXx)
532 {
533     dVAR;
534     VOL int destruct_level;  /* 0=none, 1=full, 2=full with checks */
535     HV *hv;
536 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
537     pid_t child;
538 #endif
539
540     PERL_UNUSED_ARG(my_perl);
541
542     /* wait for all pseudo-forked children to finish */
543     PERL_WAIT_FOR_CHILDREN;
544
545     destruct_level = PL_perl_destruct_level;
546 #ifdef DEBUGGING
547     {
548         const char * const s = PerlEnv_getenv("PERL_DESTRUCT_LEVEL");
549         if (s) {
550             const int i = atoi(s);
551             if (destruct_level < i)
552                 destruct_level = i;
553         }
554     }
555 #endif
556
557     if (PL_exit_flags & PERL_EXIT_DESTRUCT_END) {
558         dJMPENV;
559         int x = 0;
560
561         JMPENV_PUSH(x);
562         PERL_UNUSED_VAR(x);
563         if (PL_endav && !PL_minus_c)
564             call_list(PL_scopestack_ix, PL_endav);
565         JMPENV_POP;
566     }
567     LEAVE;
568     FREETMPS;
569
570     /* Need to flush since END blocks can produce output */
571     my_fflush_all();
572
573     if (CALL_FPTR(PL_threadhook)(aTHX)) {
574         /* Threads hook has vetoed further cleanup */
575         PL_veto_cleanup = TRUE;
576         return STATUS_EXIT;
577     }
578
579 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
580     if (destruct_level != 0) {
581         /* Fork here to create a child. Our child's job is to preserve the
582            state of scalars prior to destruction, so that we can instruct it
583            to dump any scalars that we later find have leaked.
584            There's no subtlety in this code - it assumes POSIX, and it doesn't
585            fail gracefully  */
586         int fd[2];
587
588         if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd)) {
589             perror("Debug leaking scalars socketpair failed");
590             abort();
591         }
592
593         child = fork();
594         if(child == -1) {
595             perror("Debug leaking scalars fork failed");
596             abort();
597         }
598         if (!child) {
599             /* We are the child */
600             const int sock = fd[1];
601             const int debug_fd = PerlIO_fileno(Perl_debug_log);
602             int f;
603             const char *where;
604             /* Our success message is an integer 0, and a char 0  */
605             static const char success[sizeof(int) + 1];
606
607             close(fd[0]);
608
609             /* We need to close all other file descriptors otherwise we end up
610                with interesting hangs, where the parent closes its end of a
611                pipe, and sits waiting for (another) child to terminate. Only
612                that child never terminates, because it never gets EOF, because
613                we also have the far end of the pipe open.  We even need to
614                close the debugging fd, because sometimes it happens to be one
615                end of a pipe, and a process is waiting on the other end for
616                EOF. Normally it would be closed at some point earlier in
617                destruction, but if we happen to cause the pipe to remain open,
618                EOF never occurs, and we get an infinite hang. Hence all the
619                games to pass in a file descriptor if it's actually needed.  */
620
621             f = sysconf(_SC_OPEN_MAX);
622             if(f < 0) {
623                 where = "sysconf failed";
624                 goto abort;
625             }
626             while (f--) {
627                 if (f == sock)
628                     continue;
629                 close(f);
630             }
631
632             while (1) {
633                 SV *target;
634                 union control_un control;
635                 struct msghdr msg;
636                 struct iovec vec[1];
637                 struct cmsghdr *cmptr;
638                 ssize_t got;
639                 int got_fd;
640
641                 msg.msg_control = control.control;
642                 msg.msg_controllen = sizeof(control.control);
643                 /* We're a connected socket so we don't need a source  */
644                 msg.msg_name = NULL;
645                 msg.msg_namelen = 0;
646                 msg.msg_iov = vec;
647                 msg.msg_iovlen = sizeof(vec)/sizeof(vec[0]);
648
649                 vec[0].iov_base = (void*)&target;
650                 vec[0].iov_len = sizeof(target);
651       
652                 got = recvmsg(sock, &msg, 0);
653
654                 if(got == 0)
655                     break;
656                 if(got < 0) {
657                     where = "recv failed";
658                     goto abort;
659                 }
660                 if(got < sizeof(target)) {
661                     where = "short recv";
662                     goto abort;
663                 }
664
665                 if(!(cmptr = CMSG_FIRSTHDR(&msg))) {
666                     where = "no cmsg";
667                     goto abort;
668                 }
669                 if(cmptr->cmsg_len != CMSG_LEN(sizeof(int))) {
670                     where = "wrong cmsg_len";
671                     goto abort;
672                 }
673                 if(cmptr->cmsg_level != SOL_SOCKET) {
674                     where = "wrong cmsg_level";
675                     goto abort;
676                 }
677                 if(cmptr->cmsg_type != SCM_RIGHTS) {
678                     where = "wrong cmsg_type";
679                     goto abort;
680                 }
681
682                 got_fd = *(int*)CMSG_DATA(cmptr);
683                 /* For our last little bit of trickery, put the file descriptor
684                    back into Perl_debug_log, as if we never actually closed it
685                 */
686                 if(got_fd != debug_fd) {
687                     if (dup2(got_fd, debug_fd) == -1) {
688                         where = "dup2";
689                         goto abort;
690                     }
691                 }
692                 sv_dump(target);
693
694                 PerlIO_flush(Perl_debug_log);
695
696                 got = write(sock, &success, sizeof(success));
697
698                 if(got < 0) {
699                     where = "write failed";
700                     goto abort;
701                 }
702                 if(got < sizeof(success)) {
703                     where = "short write";
704                     goto abort;
705                 }
706             }
707             _exit(0);
708         abort:
709             {
710                 int send_errno = errno;
711                 unsigned char length = (unsigned char) strlen(where);
712                 struct iovec failure[3] = {
713                     {(void*)&send_errno, sizeof(send_errno)},
714                     {&length, 1},
715                     {(void*)where, length}
716                 };
717                 int got = writev(sock, failure, 3);
718                 /* Bad news travels fast. Faster than data. We'll get a SIGPIPE
719                    in the parent if we try to read from the socketpair after the
720                    child has exited, even if there was data to read.
721                    So sleep a bit to give the parent a fighting chance of
722                    reading the data.  */
723                 sleep(2);
724                 _exit((got == -1) ? errno : 0);
725             }
726             /* End of child.  */
727         }
728         PL_dumper_fd = fd[0];
729         close(fd[1]);
730     }
731 #endif
732     
733     /* We must account for everything.  */
734
735     /* Destroy the main CV and syntax tree */
736     /* Do this now, because destroying ops can cause new SVs to be generated
737        in Perl_pad_swipe, and when running with -DDEBUG_LEAKING_SCALARS they
738        PL_curcop to point to a valid op from which the filename structure
739        member is copied.  */
740     PL_curcop = &PL_compiling;
741     if (PL_main_root) {
742         /* ensure comppad/curpad to refer to main's pad */
743         if (CvPADLIST(PL_main_cv)) {
744             PAD_SET_CUR_NOSAVE(CvPADLIST(PL_main_cv), 1);
745         }
746         op_free(PL_main_root);
747         PL_main_root = NULL;
748     }
749     PL_main_start = NULL;
750     SvREFCNT_dec(PL_main_cv);
751     PL_main_cv = NULL;
752     PL_dirty = TRUE;
753
754     /* Tell PerlIO we are about to tear things apart in case
755        we have layers which are using resources that should
756        be cleaned up now.
757      */
758
759     PerlIO_destruct(aTHX);
760
761     if (PL_sv_objcount) {
762         /*
763          * Try to destruct global references.  We do this first so that the
764          * destructors and destructees still exist.  Some sv's might remain.
765          * Non-referenced objects are on their own.
766          */
767         sv_clean_objs();
768         PL_sv_objcount = 0;
769         if (PL_defoutgv && !SvREFCNT(PL_defoutgv))
770             PL_defoutgv = NULL; /* may have been freed */
771     }
772
773     /* unhook hooks which will soon be, or use, destroyed data */
774     SvREFCNT_dec(PL_warnhook);
775     PL_warnhook = NULL;
776     SvREFCNT_dec(PL_diehook);
777     PL_diehook = NULL;
778
779     /* call exit list functions */
780     while (PL_exitlistlen-- > 0)
781         PL_exitlist[PL_exitlistlen].fn(aTHX_ PL_exitlist[PL_exitlistlen].ptr);
782
783     Safefree(PL_exitlist);
784
785     PL_exitlist = NULL;
786     PL_exitlistlen = 0;
787
788     /* jettison our possibly duplicated environment */
789     /* if PERL_USE_SAFE_PUTENV is defined environ will not have been copied
790      * so we certainly shouldn't free it here
791      */
792 #ifndef PERL_MICRO
793 #if defined(USE_ENVIRON_ARRAY) && !defined(PERL_USE_SAFE_PUTENV)
794     if (environ != PL_origenviron && !PL_use_safe_putenv
795 #ifdef USE_ITHREADS
796         /* only main thread can free environ[0] contents */
797         && PL_curinterp == aTHX
798 #endif
799         )
800     {
801         I32 i;
802
803         for (i = 0; environ[i]; i++)
804             safesysfree(environ[i]);
805
806         /* Must use safesysfree() when working with environ. */
807         safesysfree(environ);           
808
809         environ = PL_origenviron;
810     }
811 #endif
812 #endif /* !PERL_MICRO */
813
814     if (destruct_level == 0) {
815
816         DEBUG_P(debprofdump());
817
818 #if defined(PERLIO_LAYERS)
819         /* No more IO - including error messages ! */
820         PerlIO_cleanup(aTHX);
821 #endif
822
823         CopFILE_free(&PL_compiling);
824         CopSTASH_free(&PL_compiling);
825
826         /* The exit() function will do everything that needs doing. */
827         return STATUS_EXIT;
828     }
829
830     /* reset so print() ends up where we expect */
831     setdefout(NULL);
832
833 #ifdef USE_ITHREADS
834     /* the syntax tree is shared between clones
835      * so op_free(PL_main_root) only ReREFCNT_dec's
836      * REGEXPs in the parent interpreter
837      * we need to manually ReREFCNT_dec for the clones
838      */
839     {
840         I32 i = AvFILLp(PL_regex_padav) + 1;
841         SV * const * const ary = AvARRAY(PL_regex_padav);
842
843         while (i) {
844             SV * const resv = ary[--i];
845
846             if (SvFLAGS(resv) & SVf_BREAK) {
847                 /* this is PL_reg_curpm, already freed
848                  * flag is set in regexec.c:S_regtry
849                  */
850                 SvFLAGS(resv) &= ~SVf_BREAK;
851             }
852             else if(SvREPADTMP(resv)) {
853               SvREPADTMP_off(resv);
854             }
855             else if(SvIOKp(resv)) {
856                 REGEXP *re = INT2PTR(REGEXP *,SvIVX(resv));
857                 ReREFCNT_dec(re);
858             }
859         }
860     }
861     SvREFCNT_dec(PL_regex_padav);
862     PL_regex_padav = NULL;
863     PL_regex_pad = NULL;
864 #endif
865
866     SvREFCNT_dec((SV*) PL_stashcache);
867     PL_stashcache = NULL;
868
869     /* loosen bonds of global variables */
870
871     /* XXX can PL_parser still be non-null here? */
872     if(PL_parser && PL_parser->rsfp) {
873         (void)PerlIO_close(PL_parser->rsfp);
874         PL_parser->rsfp = NULL;
875     }
876
877     if (PL_minus_F) {
878         Safefree(PL_splitstr);
879         PL_splitstr = NULL;
880     }
881
882     /* switches */
883     PL_preprocess   = FALSE;
884     PL_minus_n      = FALSE;
885     PL_minus_p      = FALSE;
886     PL_minus_l      = FALSE;
887     PL_minus_a      = FALSE;
888     PL_minus_F      = FALSE;
889     PL_doswitches   = FALSE;
890     PL_dowarn       = G_WARN_OFF;
891     PL_doextract    = FALSE;
892     PL_sawampersand = FALSE;    /* must save all match strings */
893     PL_unsafe       = FALSE;
894
895     Safefree(PL_inplace);
896     PL_inplace = NULL;
897     SvREFCNT_dec(PL_patchlevel);
898
899     if (PL_e_script) {
900         SvREFCNT_dec(PL_e_script);
901         PL_e_script = NULL;
902     }
903
904     PL_perldb = 0;
905
906     /* magical thingies */
907
908     SvREFCNT_dec(PL_ofs_sv);    /* $, */
909     PL_ofs_sv = NULL;
910
911     SvREFCNT_dec(PL_ors_sv);    /* $\ */
912     PL_ors_sv = NULL;
913
914     SvREFCNT_dec(PL_rs);        /* $/ */
915     PL_rs = NULL;
916
917     Safefree(PL_osname);        /* $^O */
918     PL_osname = NULL;
919
920     SvREFCNT_dec(PL_statname);
921     PL_statname = NULL;
922     PL_statgv = NULL;
923
924     /* defgv, aka *_ should be taken care of elsewhere */
925
926     /* clean up after study() */
927     SvREFCNT_dec(PL_lastscream);
928     PL_lastscream = NULL;
929     Safefree(PL_screamfirst);
930     PL_screamfirst = 0;
931     Safefree(PL_screamnext);
932     PL_screamnext  = 0;
933
934     /* float buffer */
935     Safefree(PL_efloatbuf);
936     PL_efloatbuf = NULL;
937     PL_efloatsize = 0;
938
939     /* startup and shutdown function lists */
940     SvREFCNT_dec(PL_beginav);
941     SvREFCNT_dec(PL_beginav_save);
942     SvREFCNT_dec(PL_endav);
943     SvREFCNT_dec(PL_checkav);
944     SvREFCNT_dec(PL_checkav_save);
945     SvREFCNT_dec(PL_unitcheckav);
946     SvREFCNT_dec(PL_unitcheckav_save);
947     SvREFCNT_dec(PL_initav);
948     PL_beginav = NULL;
949     PL_beginav_save = NULL;
950     PL_endav = NULL;
951     PL_checkav = NULL;
952     PL_checkav_save = NULL;
953     PL_unitcheckav = NULL;
954     PL_unitcheckav_save = NULL;
955     PL_initav = NULL;
956
957     /* shortcuts just get cleared */
958     PL_envgv = NULL;
959     PL_incgv = NULL;
960     PL_hintgv = NULL;
961     PL_errgv = NULL;
962     PL_argvgv = NULL;
963     PL_argvoutgv = NULL;
964     PL_stdingv = NULL;
965     PL_stderrgv = NULL;
966     PL_last_in_gv = NULL;
967     PL_replgv = NULL;
968     PL_DBgv = NULL;
969     PL_DBline = NULL;
970     PL_DBsub = NULL;
971     PL_DBsingle = NULL;
972     PL_DBtrace = NULL;
973     PL_DBsignal = NULL;
974     PL_DBassertion = NULL;
975     PL_DBcv = NULL;
976     PL_dbargs = NULL;
977     PL_debstash = NULL;
978
979     SvREFCNT_dec(PL_argvout_stack);
980     PL_argvout_stack = NULL;
981
982     SvREFCNT_dec(PL_modglobal);
983     PL_modglobal = NULL;
984     SvREFCNT_dec(PL_preambleav);
985     PL_preambleav = NULL;
986     SvREFCNT_dec(PL_subname);
987     PL_subname = NULL;
988 #ifdef PERL_USES_PL_PIDSTATUS
989     SvREFCNT_dec(PL_pidstatus);
990     PL_pidstatus = NULL;
991 #endif
992     SvREFCNT_dec(PL_toptarget);
993     PL_toptarget = NULL;
994     SvREFCNT_dec(PL_bodytarget);
995     PL_bodytarget = NULL;
996     PL_formtarget = NULL;
997
998     /* free locale stuff */
999 #ifdef USE_LOCALE_COLLATE
1000     Safefree(PL_collation_name);
1001     PL_collation_name = NULL;
1002 #endif
1003
1004 #ifdef USE_LOCALE_NUMERIC
1005     Safefree(PL_numeric_name);
1006     PL_numeric_name = NULL;
1007     SvREFCNT_dec(PL_numeric_radix_sv);
1008     PL_numeric_radix_sv = NULL;
1009 #endif
1010
1011     /* clear utf8 character classes */
1012     SvREFCNT_dec(PL_utf8_alnum);
1013     SvREFCNT_dec(PL_utf8_alnumc);
1014     SvREFCNT_dec(PL_utf8_ascii);
1015     SvREFCNT_dec(PL_utf8_alpha);
1016     SvREFCNT_dec(PL_utf8_space);
1017     SvREFCNT_dec(PL_utf8_cntrl);
1018     SvREFCNT_dec(PL_utf8_graph);
1019     SvREFCNT_dec(PL_utf8_digit);
1020     SvREFCNT_dec(PL_utf8_upper);
1021     SvREFCNT_dec(PL_utf8_lower);
1022     SvREFCNT_dec(PL_utf8_print);
1023     SvREFCNT_dec(PL_utf8_punct);
1024     SvREFCNT_dec(PL_utf8_xdigit);
1025     SvREFCNT_dec(PL_utf8_mark);
1026     SvREFCNT_dec(PL_utf8_toupper);
1027     SvREFCNT_dec(PL_utf8_totitle);
1028     SvREFCNT_dec(PL_utf8_tolower);
1029     SvREFCNT_dec(PL_utf8_tofold);
1030     SvREFCNT_dec(PL_utf8_idstart);
1031     SvREFCNT_dec(PL_utf8_idcont);
1032     PL_utf8_alnum       = NULL;
1033     PL_utf8_alnumc      = NULL;
1034     PL_utf8_ascii       = NULL;
1035     PL_utf8_alpha       = NULL;
1036     PL_utf8_space       = NULL;
1037     PL_utf8_cntrl       = NULL;
1038     PL_utf8_graph       = NULL;
1039     PL_utf8_digit       = NULL;
1040     PL_utf8_upper       = NULL;
1041     PL_utf8_lower       = NULL;
1042     PL_utf8_print       = NULL;
1043     PL_utf8_punct       = NULL;
1044     PL_utf8_xdigit      = NULL;
1045     PL_utf8_mark        = NULL;
1046     PL_utf8_toupper     = NULL;
1047     PL_utf8_totitle     = NULL;
1048     PL_utf8_tolower     = NULL;
1049     PL_utf8_tofold      = NULL;
1050     PL_utf8_idstart     = NULL;
1051     PL_utf8_idcont      = NULL;
1052
1053     if (!specialWARN(PL_compiling.cop_warnings))
1054         PerlMemShared_free(PL_compiling.cop_warnings);
1055     PL_compiling.cop_warnings = NULL;
1056     Perl_refcounted_he_free(aTHX_ PL_compiling.cop_hints_hash);
1057     PL_compiling.cop_hints_hash = NULL;
1058     CopFILE_free(&PL_compiling);
1059     CopSTASH_free(&PL_compiling);
1060
1061     /* Prepare to destruct main symbol table.  */
1062
1063     hv = PL_defstash;
1064     PL_defstash = 0;
1065     SvREFCNT_dec(hv);
1066     SvREFCNT_dec(PL_curstname);
1067     PL_curstname = NULL;
1068
1069     /* clear queued errors */
1070     SvREFCNT_dec(PL_errors);
1071     PL_errors = NULL;
1072
1073     SvREFCNT_dec(PL_isarev);
1074
1075     FREETMPS;
1076     if (destruct_level >= 2 && ckWARN_d(WARN_INTERNAL)) {
1077         if (PL_scopestack_ix != 0)
1078             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
1079                  "Unbalanced scopes: %ld more ENTERs than LEAVEs\n",
1080                  (long)PL_scopestack_ix);
1081         if (PL_savestack_ix != 0)
1082             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
1083                  "Unbalanced saves: %ld more saves than restores\n",
1084                  (long)PL_savestack_ix);
1085         if (PL_tmps_floor != -1)
1086             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Unbalanced tmps: %ld more allocs than frees\n",
1087                  (long)PL_tmps_floor + 1);
1088         if (cxstack_ix != -1)
1089             Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Unbalanced context: %ld more PUSHes than POPs\n",
1090                  (long)cxstack_ix + 1);
1091     }
1092
1093     /* Now absolutely destruct everything, somehow or other, loops or no. */
1094     SvFLAGS(PL_fdpid) |= SVTYPEMASK;            /* don't clean out pid table now */
1095     SvFLAGS(PL_strtab) |= SVTYPEMASK;           /* don't clean out strtab now */
1096
1097     /* the 2 is for PL_fdpid and PL_strtab */
1098     while (PL_sv_count > 2 && sv_clean_all())
1099         ;
1100
1101     SvFLAGS(PL_fdpid) &= ~SVTYPEMASK;
1102     SvFLAGS(PL_fdpid) |= SVt_PVAV;
1103     SvFLAGS(PL_strtab) &= ~SVTYPEMASK;
1104     SvFLAGS(PL_strtab) |= SVt_PVHV;
1105
1106     AvREAL_off(PL_fdpid);               /* no surviving entries */
1107     SvREFCNT_dec(PL_fdpid);             /* needed in io_close() */
1108     PL_fdpid = NULL;
1109
1110 #ifdef HAVE_INTERP_INTERN
1111     sys_intern_clear();
1112 #endif
1113
1114     /* Destruct the global string table. */
1115     {
1116         /* Yell and reset the HeVAL() slots that are still holding refcounts,
1117          * so that sv_free() won't fail on them.
1118          * Now that the global string table is using a single hunk of memory
1119          * for both HE and HEK, we either need to explicitly unshare it the
1120          * correct way, or actually free things here.
1121          */
1122         I32 riter = 0;
1123         const I32 max = HvMAX(PL_strtab);
1124         HE * const * const array = HvARRAY(PL_strtab);
1125         HE *hent = array[0];
1126
1127         for (;;) {
1128             if (hent && ckWARN_d(WARN_INTERNAL)) {
1129                 HE * const next = HeNEXT(hent);
1130                 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
1131                      "Unbalanced string table refcount: (%ld) for \"%s\"",
1132                      (long)hent->he_valu.hent_refcount, HeKEY(hent));
1133                 Safefree(hent);
1134                 hent = next;
1135             }
1136             if (!hent) {
1137                 if (++riter > max)
1138                     break;
1139                 hent = array[riter];
1140             }
1141         }
1142
1143         Safefree(array);
1144         HvARRAY(PL_strtab) = 0;
1145         HvTOTALKEYS(PL_strtab) = 0;
1146         HvFILL(PL_strtab) = 0;
1147     }
1148     SvREFCNT_dec(PL_strtab);
1149
1150 #ifdef USE_ITHREADS
1151     /* free the pointer tables used for cloning */
1152     ptr_table_free(PL_ptr_table);
1153     PL_ptr_table = (PTR_TBL_t*)NULL;
1154 #endif
1155
1156     /* free special SVs */
1157
1158     SvREFCNT(&PL_sv_yes) = 0;
1159     sv_clear(&PL_sv_yes);
1160     SvANY(&PL_sv_yes) = NULL;
1161     SvFLAGS(&PL_sv_yes) = 0;
1162
1163     SvREFCNT(&PL_sv_no) = 0;
1164     sv_clear(&PL_sv_no);
1165     SvANY(&PL_sv_no) = NULL;
1166     SvFLAGS(&PL_sv_no) = 0;
1167
1168     {
1169         int i;
1170         for (i=0; i<=2; i++) {
1171             SvREFCNT(PERL_DEBUG_PAD(i)) = 0;
1172             sv_clear(PERL_DEBUG_PAD(i));
1173             SvANY(PERL_DEBUG_PAD(i)) = NULL;
1174             SvFLAGS(PERL_DEBUG_PAD(i)) = 0;
1175         }
1176     }
1177
1178     if (PL_sv_count != 0 && ckWARN_d(WARN_INTERNAL))
1179         Perl_warner(aTHX_ packWARN(WARN_INTERNAL),"Scalars leaked: %ld\n", (long)PL_sv_count);
1180
1181 #ifdef DEBUG_LEAKING_SCALARS
1182     if (PL_sv_count != 0) {
1183         SV* sva;
1184         SV* sv;
1185         register SV* svend;
1186
1187         for (sva = PL_sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
1188             svend = &sva[SvREFCNT(sva)];
1189             for (sv = sva + 1; sv < svend; ++sv) {
1190                 if (SvTYPE(sv) != SVTYPEMASK) {
1191                     PerlIO_printf(Perl_debug_log, "leaked: sv=0x%p"
1192                         " flags=0x%"UVxf
1193                         " refcnt=%"UVuf pTHX__FORMAT "\n"
1194                         "\tallocated at %s:%d %s %s%s\n",
1195                         (void*)sv, sv->sv_flags, sv->sv_refcnt pTHX__VALUE,
1196                         sv->sv_debug_file ? sv->sv_debug_file : "(unknown)",
1197                         sv->sv_debug_line,
1198                         sv->sv_debug_inpad ? "for" : "by",
1199                         sv->sv_debug_optype ?
1200                             PL_op_name[sv->sv_debug_optype]: "(none)",
1201                         sv->sv_debug_cloned ? " (cloned)" : ""
1202                     );
1203 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
1204                     Perl_dump_sv_child(aTHX_ sv);
1205 #endif
1206                 }
1207             }
1208         }
1209     }
1210 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
1211     {
1212         int status;
1213         fd_set rset;
1214         /* Wait for up to 4 seconds for child to terminate.
1215            This seems to be the least effort way of timing out on reaping
1216            its exit status.  */
1217         struct timeval waitfor = {4, 0};
1218         int sock = PL_dumper_fd;
1219
1220         shutdown(sock, 1);
1221         FD_ZERO(&rset);
1222         FD_SET(sock, &rset);
1223         select(sock + 1, &rset, NULL, NULL, &waitfor);
1224         waitpid(child, &status, WNOHANG);
1225         close(sock);
1226     }
1227 #endif
1228 #endif
1229     PL_sv_count = 0;
1230
1231 #ifdef PERL_DEBUG_READONLY_OPS
1232     free(PL_slabs);
1233     PL_slabs = NULL;
1234     PL_slab_count = 0;
1235 #endif
1236
1237 #if defined(PERLIO_LAYERS)
1238     /* No more IO - including error messages ! */
1239     PerlIO_cleanup(aTHX);
1240 #endif
1241
1242     /* sv_undef needs to stay immortal until after PerlIO_cleanup
1243        as currently layers use it rather than NULL as a marker
1244        for no arg - and will try and SvREFCNT_dec it.
1245      */
1246     SvREFCNT(&PL_sv_undef) = 0;
1247     SvREADONLY_off(&PL_sv_undef);
1248
1249     Safefree(PL_origfilename);
1250     PL_origfilename = NULL;
1251     Safefree(PL_reg_start_tmp);
1252     PL_reg_start_tmp = (char**)NULL;
1253     PL_reg_start_tmpl = 0;
1254     Safefree(PL_reg_curpm);
1255     Safefree(PL_reg_poscache);
1256     free_tied_hv_pool();
1257     Safefree(PL_op_mask);
1258     Safefree(PL_psig_ptr);
1259     PL_psig_ptr = (SV**)NULL;
1260     Safefree(PL_psig_name);
1261     PL_psig_name = (SV**)NULL;
1262     Safefree(PL_bitcount);
1263     PL_bitcount = NULL;
1264     Safefree(PL_psig_pend);
1265     PL_psig_pend = (int*)NULL;
1266     PL_formfeed = NULL;
1267     nuke_stacks();
1268     PL_tainting = FALSE;
1269     PL_taint_warn = FALSE;
1270     PL_hints = 0;               /* Reset hints. Should hints be per-interpreter ? */
1271     PL_debug = 0;
1272
1273     DEBUG_P(debprofdump());
1274
1275 #ifdef USE_REENTRANT_API
1276     Perl_reentrant_free(aTHX);
1277 #endif
1278
1279     sv_free_arenas();
1280
1281     while (PL_regmatch_slab) {
1282         regmatch_slab  *s = PL_regmatch_slab;
1283         PL_regmatch_slab = PL_regmatch_slab->next;
1284         Safefree(s);
1285     }
1286
1287     /* As the absolutely last thing, free the non-arena SV for mess() */
1288
1289     if (PL_mess_sv) {
1290         /* we know that type == SVt_PVMG */
1291
1292         /* it could have accumulated taint magic */
1293         MAGIC* mg;
1294         MAGIC* moremagic;
1295         for (mg = SvMAGIC(PL_mess_sv); mg; mg = moremagic) {
1296             moremagic = mg->mg_moremagic;
1297             if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global
1298                 && mg->mg_len >= 0)
1299                 Safefree(mg->mg_ptr);
1300             Safefree(mg);
1301         }
1302
1303         /* we know that type >= SVt_PV */
1304         SvPV_free(PL_mess_sv);
1305         Safefree(SvANY(PL_mess_sv));
1306         Safefree(PL_mess_sv);
1307         PL_mess_sv = NULL;
1308     }
1309     return STATUS_EXIT;
1310 }
1311
1312 /*
1313 =for apidoc perl_free
1314
1315 Releases a Perl interpreter.  See L<perlembed>.
1316
1317 =cut
1318 */
1319
1320 void
1321 perl_free(pTHXx)
1322 {
1323     dVAR;
1324
1325     if (PL_veto_cleanup)
1326         return;
1327
1328 #ifdef PERL_TRACK_MEMPOOL
1329     {
1330         /*
1331          * Don't free thread memory if PERL_DESTRUCT_LEVEL is set to a non-zero
1332          * value as we're probably hunting memory leaks then
1333          */
1334         const char * const s = PerlEnv_getenv("PERL_DESTRUCT_LEVEL");
1335         if (!s || atoi(s) == 0) {
1336             /* Emulate the PerlHost behaviour of free()ing all memory allocated in this
1337                thread at thread exit.  */
1338             while(aTHXx->Imemory_debug_header.next != &(aTHXx->Imemory_debug_header))
1339                 safesysfree(sTHX + (char *)(aTHXx->Imemory_debug_header.next));
1340         }
1341     }
1342 #endif
1343
1344 #if defined(WIN32) || defined(NETWARE)
1345 #  if defined(PERL_IMPLICIT_SYS)
1346     {
1347 #    ifdef NETWARE
1348         void *host = nw_internal_host;
1349 #    else
1350         void *host = w32_internal_host;
1351 #    endif
1352         PerlMem_free(aTHXx);
1353 #    ifdef NETWARE
1354         nw_delete_internal_host(host);
1355 #    else
1356         win32_delete_internal_host(host);
1357 #    endif
1358     }
1359 #  else
1360     PerlMem_free(aTHXx);
1361 #  endif
1362 #else
1363     PerlMem_free(aTHXx);
1364 #endif
1365 }
1366
1367 #if defined(USE_ITHREADS)
1368 /* provide destructors to clean up the thread key when libperl is unloaded */
1369 #ifndef WIN32 /* handled during DLL_PROCESS_DETACH in win32/perllib.c */
1370
1371 #if defined(__hpux) && !(defined(__ux_version) && __ux_version <= 1020) && !defined(__GNUC__)
1372 #pragma fini "perl_fini"
1373 #elif defined(__sun) && !defined(__GNUC__)
1374 #pragma fini (perl_fini)
1375 #endif
1376
1377 static void
1378 #if defined(__GNUC__)
1379 __attribute__((destructor))
1380 #endif
1381 perl_fini(void)
1382 {
1383     dVAR;
1384     if (PL_curinterp  && !PL_veto_cleanup)
1385         FREE_THREAD_KEY;
1386 }
1387
1388 #endif /* WIN32 */
1389 #endif /* THREADS */
1390
1391 void
1392 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr)
1393 {
1394     dVAR;
1395     Renew(PL_exitlist, PL_exitlistlen+1, PerlExitListEntry);
1396     PL_exitlist[PL_exitlistlen].fn = fn;
1397     PL_exitlist[PL_exitlistlen].ptr = ptr;
1398     ++PL_exitlistlen;
1399 }
1400
1401 #ifdef HAS_PROCSELFEXE
1402 /* This is a function so that we don't hold on to MAXPATHLEN
1403    bytes of stack longer than necessary
1404  */
1405 STATIC void
1406 S_procself_val(pTHX_ SV *sv, const char *arg0)
1407 {
1408     char buf[MAXPATHLEN];
1409     int len = readlink(PROCSELFEXE_PATH, buf, sizeof(buf) - 1);
1410
1411     /* On Playstation2 Linux V1.0 (kernel 2.2.1) readlink(/proc/self/exe)
1412        includes a spurious NUL which will cause $^X to fail in system
1413        or backticks (this will prevent extensions from being built and
1414        many tests from working). readlink is not meant to add a NUL.
1415        Normal readlink works fine.
1416      */
1417     if (len > 0 && buf[len-1] == '\0') {
1418       len--;
1419     }
1420
1421     /* FreeBSD's implementation is acknowledged to be imperfect, sometimes
1422        returning the text "unknown" from the readlink rather than the path
1423        to the executable (or returning an error from the readlink).  Any valid
1424        path has a '/' in it somewhere, so use that to validate the result.
1425        See http://www.freebsd.org/cgi/query-pr.cgi?pr=35703
1426     */
1427     if (len > 0 && memchr(buf, '/', len)) {
1428         sv_setpvn(sv,buf,len);
1429     }
1430     else {
1431         sv_setpv(sv,arg0);
1432     }
1433 }
1434 #endif /* HAS_PROCSELFEXE */
1435
1436 STATIC void
1437 S_set_caret_X(pTHX) {
1438     dVAR;
1439     GV* tmpgv = gv_fetchpvs("\030", GV_ADD|GV_NOTQUAL, SVt_PV); /* $^X */
1440     if (tmpgv) {
1441 #ifdef HAS_PROCSELFEXE
1442         S_procself_val(aTHX_ GvSV(tmpgv), PL_origargv[0]);
1443 #else
1444 #ifdef OS2
1445         sv_setpv(GvSVn(tmpgv), os2_execname(aTHX));
1446 #else
1447         sv_setpv(GvSVn(tmpgv),PL_origargv[0]);
1448 #endif
1449 #endif
1450     }
1451 }
1452
1453 /*
1454 =for apidoc perl_parse
1455
1456 Tells a Perl interpreter to parse a Perl script.  See L<perlembed>.
1457
1458 =cut
1459 */
1460
1461 int
1462 perl_parse(pTHXx_ XSINIT_t xsinit, int argc, char **argv, char **env)
1463 {
1464     dVAR;
1465     I32 oldscope;
1466     int ret;
1467     dJMPENV;
1468
1469     PERL_UNUSED_ARG(my_perl);
1470
1471 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
1472 #ifdef IAMSUID
1473 #undef IAMSUID
1474     Perl_croak(aTHX_ "suidperl is no longer needed since the kernel can now execute\n\
1475 setuid perl scripts securely.\n");
1476 #endif /* IAMSUID */
1477 #endif
1478
1479 #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT)
1480     /* [perl #22371] Algorimic Complexity Attack on Perl 5.6.1, 5.8.0
1481      * This MUST be done before any hash stores or fetches take place.
1482      * If you set PL_rehash_seed (and assumedly also PL_rehash_seed_set)
1483      * yourself, it is your responsibility to provide a good random seed!
1484      * You can also define PERL_HASH_SEED in compile time, see hv.h. */
1485     if (!PL_rehash_seed_set)
1486          PL_rehash_seed = get_hash_seed();
1487     {
1488         const char * const s = PerlEnv_getenv("PERL_HASH_SEED_DEBUG");
1489
1490         if (s && (atoi(s) == 1))
1491             PerlIO_printf(Perl_debug_log, "HASH_SEED = %"UVuf"\n", PL_rehash_seed);
1492     }
1493 #endif /* #if defined(USE_HASH_SEED) || defined(USE_HASH_SEED_EXPLICIT) */
1494
1495     PL_origargc = argc;
1496     PL_origargv = argv;
1497
1498     if (PL_origalen != 0) {
1499         PL_origalen = 1; /* don't use old PL_origalen if perl_parse() is called again */
1500     }
1501     else {
1502         /* Set PL_origalen be the sum of the contiguous argv[]
1503          * elements plus the size of the env in case that it is
1504          * contiguous with the argv[].  This is used in mg.c:Perl_magic_set()
1505          * as the maximum modifiable length of $0.  In the worst case
1506          * the area we are able to modify is limited to the size of
1507          * the original argv[0].  (See below for 'contiguous', though.)
1508          * --jhi */
1509          const char *s = NULL;
1510          int i;
1511          const UV mask =
1512            ~(UV)(PTRSIZE == 4 ? 3 : PTRSIZE == 8 ? 7 : PTRSIZE == 16 ? 15 : 0);
1513          /* Do the mask check only if the args seem like aligned. */
1514          const UV aligned =
1515            (mask < ~(UV)0) && ((PTR2UV(argv[0]) & mask) == PTR2UV(argv[0]));
1516
1517          /* See if all the arguments are contiguous in memory.  Note
1518           * that 'contiguous' is a loose term because some platforms
1519           * align the argv[] and the envp[].  If the arguments look
1520           * like non-aligned, assume that they are 'strictly' or
1521           * 'traditionally' contiguous.  If the arguments look like
1522           * aligned, we just check that they are within aligned
1523           * PTRSIZE bytes.  As long as no system has something bizarre
1524           * like the argv[] interleaved with some other data, we are
1525           * fine.  (Did I just evoke Murphy's Law?)  --jhi */
1526          if (PL_origargv && PL_origargc >= 1 && (s = PL_origargv[0])) {
1527               while (*s) s++;
1528               for (i = 1; i < PL_origargc; i++) {
1529                    if ((PL_origargv[i] == s + 1
1530 #ifdef OS2
1531                         || PL_origargv[i] == s + 2
1532 #endif 
1533                             )
1534                        ||
1535                        (aligned &&
1536                         (PL_origargv[i] >  s &&
1537                          PL_origargv[i] <=
1538                          INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1539                         )
1540                    {
1541                         s = PL_origargv[i];
1542                         while (*s) s++;
1543                    }
1544                    else
1545                         break;
1546               }
1547          }
1548
1549 #ifndef PERL_USE_SAFE_PUTENV
1550          /* Can we grab env area too to be used as the area for $0? */
1551          if (s && PL_origenviron && !PL_use_safe_putenv) {
1552               if ((PL_origenviron[0] == s + 1)
1553                   ||
1554                   (aligned &&
1555                    (PL_origenviron[0] >  s &&
1556                     PL_origenviron[0] <=
1557                     INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1558                  )
1559               {
1560 #ifndef OS2             /* ENVIRON is read by the kernel too. */
1561                    s = PL_origenviron[0];
1562                    while (*s) s++;
1563 #endif
1564                    my_setenv("NoNe  SuCh", NULL);
1565                    /* Force copy of environment. */
1566                    for (i = 1; PL_origenviron[i]; i++) {
1567                         if (PL_origenviron[i] == s + 1
1568                             ||
1569                             (aligned &&
1570                              (PL_origenviron[i] >  s &&
1571                               PL_origenviron[i] <=
1572                               INT2PTR(char *, PTR2UV(s + PTRSIZE) & mask)))
1573                            )
1574                         {
1575                              s = PL_origenviron[i];
1576                              while (*s) s++;
1577                         }
1578                         else
1579                              break;
1580                    }
1581               }
1582          }
1583 #endif /* !defined(PERL_USE_SAFE_PUTENV) */
1584
1585          PL_origalen = s ? s - PL_origargv[0] + 1 : 0;
1586     }
1587
1588     if (PL_do_undump) {
1589
1590         /* Come here if running an undumped a.out. */
1591
1592         PL_origfilename = savepv(argv[0]);
1593         PL_do_undump = FALSE;
1594         cxstack_ix = -1;                /* start label stack again */
1595         init_ids();
1596         assert (!PL_tainted);
1597         TAINT;
1598         S_set_caret_X(aTHX);
1599         TAINT_NOT;
1600         init_postdump_symbols(argc,argv,env);
1601         return 0;
1602     }
1603
1604     if (PL_main_root) {
1605         op_free(PL_main_root);
1606         PL_main_root = NULL;
1607     }
1608     PL_main_start = NULL;
1609     SvREFCNT_dec(PL_main_cv);
1610     PL_main_cv = NULL;
1611
1612     time(&PL_basetime);
1613     oldscope = PL_scopestack_ix;
1614     PL_dowarn = G_WARN_OFF;
1615
1616     JMPENV_PUSH(ret);
1617     switch (ret) {
1618     case 0:
1619         parse_body(env,xsinit);
1620         if (PL_unitcheckav)
1621             call_list(oldscope, PL_unitcheckav);
1622         if (PL_checkav)
1623             call_list(oldscope, PL_checkav);
1624         ret = 0;
1625         break;
1626     case 1:
1627         STATUS_ALL_FAILURE;
1628         /* FALL THROUGH */
1629     case 2:
1630         /* my_exit() was called */
1631         while (PL_scopestack_ix > oldscope)
1632             LEAVE;
1633         FREETMPS;
1634         PL_curstash = PL_defstash;
1635         if (PL_unitcheckav)
1636             call_list(oldscope, PL_unitcheckav);
1637         if (PL_checkav)
1638             call_list(oldscope, PL_checkav);
1639         ret = STATUS_EXIT;
1640         break;
1641     case 3:
1642         PerlIO_printf(Perl_error_log, "panic: top_env\n");
1643         ret = 1;
1644         break;
1645     }
1646     JMPENV_POP;
1647     return ret;
1648 }
1649
1650 STATIC void *
1651 S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
1652 {
1653     dVAR;
1654     PerlIO *rsfp;
1655     int argc = PL_origargc;
1656     char **argv = PL_origargv;
1657     const char *scriptname = NULL;
1658     VOL bool dosearch = FALSE;
1659     const char *validarg = "";
1660     register SV *sv;
1661     register char *s, c;
1662     const char *cddir = NULL;
1663 #ifdef USE_SITECUSTOMIZE
1664     bool minus_f = FALSE;
1665 #endif
1666     SV *linestr_sv = newSV_type(SVt_PVIV);
1667     bool add_read_e_script = FALSE;
1668
1669     SvGROW(linestr_sv, 80);
1670     sv_setpvn(linestr_sv,"",0);
1671
1672     sv = newSVpvs("");          /* first used for -I flags */
1673     SAVEFREESV(sv);
1674     init_main_stash();
1675
1676     for (argc--,argv++; argc > 0; argc--,argv++) {
1677         if (argv[0][0] != '-' || !argv[0][1])
1678             break;
1679 #ifdef DOSUID
1680     if (*validarg)
1681         validarg = " PHOOEY ";
1682     else
1683         validarg = argv[0];
1684     /*
1685      * Can we rely on the kernel to start scripts with argv[1] set to
1686      * contain all #! line switches (the whole line)? (argv[0] is set to
1687      * the interpreter name, argv[2] to the script name; argv[3] and
1688      * above may contain other arguments.)
1689      */
1690 #endif
1691         s = argv[0]+1;
1692       reswitch:
1693         switch ((c = *s)) {
1694         case 'C':
1695 #ifndef PERL_STRICT_CR
1696         case '\r':
1697 #endif
1698         case ' ':
1699         case '0':
1700         case 'F':
1701         case 'a':
1702         case 'c':
1703         case 'd':
1704         case 'D':
1705         case 'h':
1706         case 'i':
1707         case 'l':
1708         case 'M':
1709         case 'm':
1710         case 'n':
1711         case 'p':
1712         case 's':
1713         case 'u':
1714         case 'U':
1715         case 'v':
1716         case 'W':
1717         case 'X':
1718         case 'w':
1719         case 'A':
1720             if ((s = moreswitches(s)))
1721                 goto reswitch;
1722             break;
1723
1724         case 't':
1725             CHECK_MALLOC_TOO_LATE_FOR('t');
1726             if( !PL_tainting ) {
1727                  PL_taint_warn = TRUE;
1728                  PL_tainting = TRUE;
1729             }
1730             s++;
1731             goto reswitch;
1732         case 'T':
1733             CHECK_MALLOC_TOO_LATE_FOR('T');
1734             PL_tainting = TRUE;
1735             PL_taint_warn = FALSE;
1736             s++;
1737             goto reswitch;
1738
1739         case 'E':
1740             PL_minus_E = TRUE;
1741             /* FALL THROUGH */
1742         case 'e':
1743 #ifdef MACOS_TRADITIONAL
1744             /* ignore -e for Dev:Pseudo argument */
1745             if (argv[1] && !strcmp(argv[1], "Dev:Pseudo"))
1746                 break;
1747 #endif
1748             forbid_setid('e', -1);
1749             if (!PL_e_script) {
1750                 PL_e_script = newSVpvs("");
1751                 add_read_e_script = TRUE;
1752             }
1753             if (*++s)
1754                 sv_catpv(PL_e_script, s);
1755             else if (argv[1]) {
1756                 sv_catpv(PL_e_script, argv[1]);
1757                 argc--,argv++;
1758             }
1759             else
1760                 Perl_croak(aTHX_ "No code specified for -%c", c);
1761             sv_catpvs(PL_e_script, "\n");
1762             break;
1763
1764         case 'f':
1765 #ifdef USE_SITECUSTOMIZE
1766             minus_f = TRUE;
1767 #endif
1768             s++;
1769             goto reswitch;
1770
1771         case 'I':       /* -I handled both here and in moreswitches() */
1772             forbid_setid('I', -1);
1773             if (!*++s && (s=argv[1]) != NULL) {
1774                 argc--,argv++;
1775             }
1776             if (s && *s) {
1777                 STRLEN len = strlen(s);
1778                 const char * const p = savepvn(s, len);
1779                 incpush(p, TRUE, TRUE, FALSE, FALSE);
1780                 sv_catpvs(sv, "-I");
1781                 sv_catpvn(sv, p, len);
1782                 sv_catpvs(sv, " ");
1783                 Safefree(p);
1784             }
1785             else
1786                 Perl_croak(aTHX_ "No directory specified for -I");
1787             break;
1788         case 'P':
1789             forbid_setid('P', -1);
1790             PL_preprocess = TRUE;
1791             s++;
1792             goto reswitch;
1793         case 'S':
1794             forbid_setid('S', -1);
1795             dosearch = TRUE;
1796             s++;
1797             goto reswitch;
1798         case 'V':
1799             {
1800                 SV *opts_prog;
1801
1802                 Perl_av_create_and_push(aTHX_ &PL_preambleav, newSVpvs("use Config;"));
1803                 if (*++s != ':')  {
1804                     STRLEN opts;
1805                 
1806                     opts_prog = newSVpvs("print Config::myconfig(),");
1807 #ifdef VMS
1808                     sv_catpvs(opts_prog,"\"\\nCharacteristics of this PERLSHR image: \\n\",");
1809 #else
1810                     sv_catpvs(opts_prog,"\"\\nCharacteristics of this binary (from libperl): \\n\",");
1811 #endif
1812                     opts = SvCUR(opts_prog);
1813
1814                     Perl_sv_catpv(aTHX_ opts_prog,"\"  Compile-time options:"
1815 #  ifdef DEBUGGING
1816                              " DEBUGGING"
1817 #  endif
1818 #  ifdef DEBUG_LEAKING_SCALARS
1819                              " DEBUG_LEAKING_SCALARS"
1820 #  endif
1821 #  ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
1822                              " DEBUG_LEAKING_SCALARS_FORK_DUMP"
1823 #  endif
1824 #  ifdef FAKE_THREADS
1825                              " FAKE_THREADS"
1826 #  endif
1827 #  ifdef MULTIPLICITY
1828                              " MULTIPLICITY"
1829 #  endif
1830 #  ifdef MYMALLOC
1831                              " MYMALLOC"
1832 #  endif
1833 #  ifdef NO_MATHOMS
1834                             " NO_MATHOMS"
1835 #  endif
1836 #  ifdef PERL_DEBUG_READONLY_OPS
1837                              " PERL_DEBUG_READONLY_OPS"
1838 #  endif
1839 #  ifdef PERL_DONT_CREATE_GVSV
1840                              " PERL_DONT_CREATE_GVSV"
1841 #  endif
1842 #  ifdef PERL_GLOBAL_STRUCT
1843                              " PERL_GLOBAL_STRUCT"
1844 #  endif
1845 #  ifdef PERL_IMPLICIT_CONTEXT
1846                              " PERL_IMPLICIT_CONTEXT"
1847 #  endif
1848 #  ifdef PERL_IMPLICIT_SYS
1849                              " PERL_IMPLICIT_SYS"
1850 #  endif
1851 #  ifdef PERL_MAD
1852                              " PERL_MAD"
1853 #  endif
1854 #  ifdef PERL_MALLOC_WRAP
1855                              " PERL_MALLOC_WRAP"
1856 #  endif
1857 #  ifdef PERL_MEM_LOG
1858                              " PERL_MEM_LOG"
1859 #  endif
1860 #  ifdef PERL_MEM_LOG_ENV
1861                              " PERL_MEM_LOG_ENV"
1862 #  endif
1863 #  ifdef PERL_MEM_LOG_ENV_FD
1864                              " PERL_MEM_LOG_ENV_FD"
1865 #  endif
1866 #  ifdef PERL_MEM_LOG_STDERR
1867                              " PERL_MEM_LOG_STDERR"
1868 #  endif
1869 #  ifdef PERL_MEM_LOG_TIMESTAMP
1870                              " PERL_MEM_LOG_TIMESTAMP"
1871 #  endif
1872 #  ifdef PERL_NEED_APPCTX
1873                              " PERL_NEED_APPCTX"
1874 #  endif
1875 #  ifdef PERL_NEED_TIMESBASE
1876                              " PERL_NEED_TIMESBASE"
1877 #  endif
1878 #  ifdef PERL_OLD_COPY_ON_WRITE
1879                              " PERL_OLD_COPY_ON_WRITE"
1880 #  endif
1881 #  ifdef PERL_POISON
1882                              " PERL_POISON"
1883 #  endif
1884 #  ifdef PERL_TRACK_MEMPOOL
1885                              " PERL_TRACK_MEMPOOL"
1886 #  endif
1887 #  ifdef PERL_USE_SAFE_PUTENV
1888                              " PERL_USE_SAFE_PUTENV"
1889 #  endif
1890 #  ifdef PERL_USES_PL_PIDSTATUS
1891                              " PERL_USES_PL_PIDSTATUS"
1892 #  endif
1893 #  ifdef PL_OP_SLAB_ALLOC
1894                              " PL_OP_SLAB_ALLOC"
1895 #  endif
1896 #  ifdef THREADS_HAVE_PIDS
1897                              " THREADS_HAVE_PIDS"
1898 #  endif
1899 #  ifdef USE_64_BIT_ALL
1900                              " USE_64_BIT_ALL"
1901 #  endif
1902 #  ifdef USE_64_BIT_INT
1903                              " USE_64_BIT_INT"
1904 #  endif
1905 #  ifdef USE_ITHREADS
1906                              " USE_ITHREADS"
1907 #  endif
1908 #  ifdef USE_LARGE_FILES
1909                              " USE_LARGE_FILES"
1910 #  endif
1911 #  ifdef USE_LONG_DOUBLE
1912                              " USE_LONG_DOUBLE"
1913 #  endif
1914 #  ifdef USE_PERLIO
1915                              " USE_PERLIO"
1916 #  endif
1917 #  ifdef USE_REENTRANT_API
1918                              " USE_REENTRANT_API"
1919 #  endif
1920 #  ifdef USE_SFIO
1921                              " USE_SFIO"
1922 #  endif
1923 #  ifdef USE_SITECUSTOMIZE
1924                              " USE_SITECUSTOMIZE"
1925 #  endif               
1926 #  ifdef USE_SOCKS
1927                              " USE_SOCKS"
1928 #  endif
1929                              );
1930
1931                     while (SvCUR(opts_prog) > opts+76) {
1932                         /* find last space after "options: " and before col 76
1933                          */
1934
1935                         const char *space;
1936                         char * const pv = SvPV_nolen(opts_prog);
1937                         const char c = pv[opts+76];
1938                         pv[opts+76] = '\0';
1939                         space = strrchr(pv+opts+26, ' ');
1940                         pv[opts+76] = c;
1941                         if (!space) break; /* "Can't happen" */
1942
1943                         /* break the line before that space */
1944
1945                         opts = space - pv;
1946                         Perl_sv_insert(aTHX_ opts_prog, opts, 0,
1947                                   STR_WITH_LEN("\\n                       "));
1948                     }
1949
1950                     sv_catpvs(opts_prog,"\\n\",");
1951
1952 #if defined(LOCAL_PATCH_COUNT)
1953                     if (LOCAL_PATCH_COUNT > 0) {
1954                         int i;
1955                         sv_catpvs(opts_prog,
1956                                  "\"  Locally applied patches:\\n\",");
1957                         for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
1958                             if (PL_localpatches[i])
1959                                 Perl_sv_catpvf(aTHX_ opts_prog,"q%c\t%s\n%c,",
1960                                                0, PL_localpatches[i], 0);
1961                         }
1962                     }
1963 #endif
1964                     Perl_sv_catpvf(aTHX_ opts_prog,
1965                                    "\"  Built under %s\\n\"",OSNAME);
1966 #ifdef __DATE__
1967 #  ifdef __TIME__
1968                     Perl_sv_catpvf(aTHX_ opts_prog,
1969                                    ",\"  Compiled at %s %s\\n\"",__DATE__,
1970                                    __TIME__);
1971 #  else
1972                     Perl_sv_catpvf(aTHX_ opts_prog,",\"  Compiled on %s\\n\"",
1973                                    __DATE__);
1974 #  endif
1975 #endif
1976                     sv_catpvs(opts_prog, "; $\"=\"\\n    \"; "
1977                              "@env = map { \"$_=\\\"$ENV{$_}\\\"\" } "
1978                              "sort grep {/^PERL/} keys %ENV; ");
1979 #ifdef __CYGWIN__
1980                     sv_catpvs(opts_prog,
1981                              "push @env, \"CYGWIN=\\\"$ENV{CYGWIN}\\\"\";");
1982 #endif
1983                     sv_catpvs(opts_prog, 
1984                              "print \"  \\%ENV:\\n    @env\\n\" if @env;"
1985                              "print \"  \\@INC:\\n    @INC\\n\";");
1986                 }
1987                 else {
1988                     ++s;
1989                     opts_prog = Perl_newSVpvf(aTHX_
1990                                               "Config::config_vars(qw%c%s%c)",
1991                                               0, s, 0);
1992                     s += strlen(s);
1993                 }
1994                 av_push(PL_preambleav, opts_prog);
1995                 /* don't look for script or read stdin */
1996                 scriptname = BIT_BUCKET;
1997                 goto reswitch;
1998             }
1999         case 'x':
2000             PL_doextract = TRUE;
2001             s++;
2002             if (*s)
2003                 cddir = s;
2004             break;
2005         case 0:
2006             break;
2007         case '-':
2008             if (!*++s || isSPACE(*s)) {
2009                 argc--,argv++;
2010                 goto switch_end;
2011             }
2012             /* catch use of gnu style long options */
2013             if (strEQ(s, "version")) {
2014                 s = (char *)"v";
2015                 goto reswitch;
2016             }
2017             if (strEQ(s, "help")) {
2018                 s = (char *)"h";
2019                 goto reswitch;
2020             }
2021             s--;
2022             /* FALL THROUGH */
2023         default:
2024             Perl_croak(aTHX_ "Unrecognized switch: -%s  (-h will show valid options)",s);
2025         }
2026     }
2027   switch_end:
2028
2029     if (
2030 #ifndef SECURE_INTERNAL_GETENV
2031         !PL_tainting &&
2032 #endif
2033         (s = PerlEnv_getenv("PERL5OPT")))
2034     {
2035         const char *popt = s;
2036         while (isSPACE(*s))
2037             s++;
2038         if (*s == '-' && *(s+1) == 'T') {
2039             CHECK_MALLOC_TOO_LATE_FOR('T');
2040             PL_tainting = TRUE;
2041             PL_taint_warn = FALSE;
2042         }
2043         else {
2044             char *popt_copy = NULL;
2045             while (s && *s) {
2046                 char *d;
2047                 while (isSPACE(*s))
2048                     s++;
2049                 if (*s == '-') {
2050                     s++;
2051                     if (isSPACE(*s))
2052                         continue;
2053                 }
2054                 d = s;
2055                 if (!*s)
2056                     break;
2057                 if (!strchr("CDIMUdmtwA", *s))
2058                     Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
2059                 while (++s && *s) {
2060                     if (isSPACE(*s)) {
2061                         if (!popt_copy) {
2062                             popt_copy = SvPVX(sv_2mortal(newSVpv(popt,0)));
2063                             s = popt_copy + (s - popt);
2064                             d = popt_copy + (d - popt);
2065                         }
2066                         *s++ = '\0';
2067                         break;
2068                     }
2069                 }
2070                 if (*d == 't') {
2071                     if( !PL_tainting ) {
2072                         PL_taint_warn = TRUE;
2073                         PL_tainting = TRUE;
2074                     }
2075                 } else {
2076                     moreswitches(d);
2077                 }
2078             }
2079         }
2080     }
2081
2082 #ifdef USE_SITECUSTOMIZE
2083     if (!minus_f) {
2084         (void)Perl_av_create_and_unshift_one(aTHX_ &PL_preambleav,
2085                                              Perl_newSVpvf(aTHX_ "BEGIN { do '%s/sitecustomize.pl' }", SITELIB_EXP));
2086     }
2087 #endif
2088
2089     if (!scriptname)
2090         scriptname = argv[0];
2091     if (PL_e_script) {
2092         argc++,argv--;
2093         scriptname = BIT_BUCKET;        /* don't look for script or read stdin */
2094     }
2095     else if (scriptname == NULL) {
2096 #ifdef MSDOS
2097         if ( PerlLIO_isatty(PerlIO_fileno(PerlIO_stdin())) )
2098             moreswitches("h");
2099 #endif
2100         scriptname = "-";
2101     }
2102
2103     /* Set $^X early so that it can be used for relocatable paths in @INC  */
2104     assert (!PL_tainted);
2105     TAINT;
2106     S_set_caret_X(aTHX);
2107     TAINT_NOT;
2108     init_perllib();
2109
2110     {
2111         int suidscript;
2112         const int fdscript
2113             = open_script(scriptname, dosearch, sv, &suidscript, &rsfp);
2114
2115         validate_suid(validarg, scriptname, fdscript, suidscript,
2116                 linestr_sv, rsfp);
2117
2118 #ifndef PERL_MICRO
2119 #  if defined(SIGCHLD) || defined(SIGCLD)
2120         {
2121 #  ifndef SIGCHLD
2122 #    define SIGCHLD SIGCLD
2123 #  endif
2124             Sighandler_t sigstate = rsignal_state(SIGCHLD);
2125             if (sigstate == (Sighandler_t) SIG_IGN) {
2126                 if (ckWARN(WARN_SIGNAL))
2127                     Perl_warner(aTHX_ packWARN(WARN_SIGNAL),
2128                                 "Can't ignore signal CHLD, forcing to default");
2129                 (void)rsignal(SIGCHLD, (Sighandler_t)SIG_DFL);
2130             }
2131         }
2132 #  endif
2133 #endif
2134
2135         if (PL_doextract
2136 #ifdef MACOS_TRADITIONAL
2137             || gMacPerl_AlwaysExtract
2138 #endif
2139             ) {
2140
2141             /* This will croak if suidscript is >= 0, as -x cannot be used with
2142                setuid scripts.  */
2143             forbid_setid('x', suidscript);
2144             /* Hence you can't get here if suidscript >= 0  */
2145
2146             find_beginning(linestr_sv, rsfp);
2147             if (cddir && PerlDir_chdir( (char *)cddir ) < 0)
2148                 Perl_croak(aTHX_ "Can't chdir to %s",cddir);
2149         }
2150     }
2151
2152     PL_main_cv = PL_compcv = (CV*)newSV_type(SVt_PVCV);
2153     CvUNIQUE_on(PL_compcv);
2154
2155     CvPADLIST(PL_compcv) = pad_new(0);
2156
2157     PL_isarev = newHV();
2158
2159     boot_core_PerlIO();
2160     boot_core_UNIVERSAL();
2161     boot_core_xsutils();
2162     boot_core_mro();
2163
2164     if (xsinit)
2165         (*xsinit)(aTHX);        /* in case linked C routines want magical variables */
2166 #ifndef PERL_MICRO
2167 #if defined(VMS) || defined(WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(EPOC) || defined(SYMBIAN)
2168     init_os_extras();
2169 #endif
2170 #endif
2171
2172 #ifdef USE_SOCKS
2173 #   ifdef HAS_SOCKS5_INIT
2174     socks5_init(argv[0]);
2175 #   else
2176     SOCKSinit(argv[0]);
2177 #   endif
2178 #endif
2179
2180     init_predump_symbols();
2181     /* init_postdump_symbols not currently designed to be called */
2182     /* more than once (ENV isn't cleared first, for example)     */
2183     /* But running with -u leaves %ENV & @ARGV undefined!    XXX */
2184     if (!PL_do_undump)
2185         init_postdump_symbols(argc,argv,env);
2186
2187     /* PL_unicode is turned on by -C, or by $ENV{PERL_UNICODE},
2188      * or explicitly in some platforms.
2189      * locale.c:Perl_init_i18nl10n() if the environment
2190      * look like the user wants to use UTF-8. */
2191 #if defined(__SYMBIAN32__)
2192     PL_unicode = PERL_UNICODE_STD_FLAG; /* See PERL_SYMBIAN_CONSOLE_UTF8. */
2193 #endif
2194     if (PL_unicode) {
2195          /* Requires init_predump_symbols(). */
2196          if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
2197               IO* io;
2198               PerlIO* fp;
2199               SV* sv;
2200
2201               /* Turn on UTF-8-ness on STDIN, STDOUT, STDERR
2202                * and the default open disciplines. */
2203               if ((PL_unicode & PERL_UNICODE_STDIN_FLAG) &&
2204                   PL_stdingv  && (io = GvIO(PL_stdingv)) &&
2205                   (fp = IoIFP(io)))
2206                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2207               if ((PL_unicode & PERL_UNICODE_STDOUT_FLAG) &&
2208                   PL_defoutgv && (io = GvIO(PL_defoutgv)) &&
2209                   (fp = IoOFP(io)))
2210                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2211               if ((PL_unicode & PERL_UNICODE_STDERR_FLAG) &&
2212                   PL_stderrgv && (io = GvIO(PL_stderrgv)) &&
2213                   (fp = IoOFP(io)))
2214                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2215               if ((PL_unicode & PERL_UNICODE_INOUT_FLAG) &&
2216                   (sv = GvSV(gv_fetchpvs("\017PEN", GV_ADD|GV_NOTQUAL,
2217                                          SVt_PV)))) {
2218                    U32 in  = PL_unicode & PERL_UNICODE_IN_FLAG;
2219                    U32 out = PL_unicode & PERL_UNICODE_OUT_FLAG;
2220                    if (in) {
2221                         if (out)
2222                              sv_setpvn(sv, ":utf8\0:utf8", 11);
2223                         else
2224                              sv_setpvn(sv, ":utf8\0", 6);
2225                    }
2226                    else if (out)
2227                         sv_setpvn(sv, "\0:utf8", 6);
2228                    SvSETMAGIC(sv);
2229               }
2230          }
2231     }
2232
2233     if ((s = PerlEnv_getenv("PERL_SIGNALS"))) {
2234          if (strEQ(s, "unsafe"))
2235               PL_signals |=  PERL_SIGNALS_UNSAFE_FLAG;
2236          else if (strEQ(s, "safe"))
2237               PL_signals &= ~PERL_SIGNALS_UNSAFE_FLAG;
2238          else
2239               Perl_croak(aTHX_ "PERL_SIGNALS illegal: \"%s\"", s);
2240     }
2241
2242 #ifdef PERL_MAD
2243     if ((s = PerlEnv_getenv("PERL_XMLDUMP"))) {
2244         PL_madskills = 1;
2245         PL_minus_c = 1;
2246         if (!s || !s[0])
2247             PL_xmlfp = PerlIO_stdout();
2248         else {
2249             PL_xmlfp = PerlIO_open(s, "w");
2250             if (!PL_xmlfp)
2251                 Perl_croak(aTHX_ "Can't open %s", s);
2252         }
2253         my_setenv("PERL_XMLDUMP", Nullch);      /* hide from subprocs */
2254     }
2255     if ((s = PerlEnv_getenv("PERL_MADSKILLS"))) {
2256         PL_madskills = atoi(s);
2257         my_setenv("PERL_MADSKILLS", Nullch);    /* hide from subprocs */
2258     }
2259 #endif
2260
2261     lex_start(linestr_sv, rsfp, TRUE);
2262     PL_subname = newSVpvs("main");
2263
2264     if (add_read_e_script)
2265         filter_add(read_e_script, NULL);
2266
2267     /* now parse the script */
2268
2269     SETERRNO(0,SS_NORMAL);
2270     PL_error_count = 0;
2271 #ifdef MACOS_TRADITIONAL
2272     if (gMacPerl_SyntaxError = (yyparse() || PL_error_count)) {
2273         if (PL_minus_c)
2274             Perl_croak(aTHX_ "%s had compilation errors.\n", MacPerl_MPWFileName(PL_origfilename));
2275         else {
2276             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
2277                        MacPerl_MPWFileName(PL_origfilename));
2278         }
2279     }
2280 #else
2281     if (yyparse() || PL_error_count) {
2282         if (PL_minus_c)
2283             Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
2284         else {
2285             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
2286                        PL_origfilename);
2287         }
2288     }
2289 #endif
2290     CopLINE_set(PL_curcop, 0);
2291     PL_curstash = PL_defstash;
2292     PL_preprocess = FALSE;
2293     if (PL_e_script) {
2294         SvREFCNT_dec(PL_e_script);
2295         PL_e_script = NULL;
2296     }
2297
2298     if (PL_do_undump)
2299         my_unexec();
2300
2301     if (isWARN_ONCE) {
2302         SAVECOPFILE(PL_curcop);
2303         SAVECOPLINE(PL_curcop);
2304         gv_check(PL_defstash);
2305     }
2306
2307     LEAVE;
2308     FREETMPS;
2309
2310 #ifdef MYMALLOC
2311     if ((s=PerlEnv_getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
2312         dump_mstats("after compilation:");
2313 #endif
2314
2315     ENTER;
2316     PL_restartop = 0;
2317     return NULL;
2318 }
2319
2320 /*
2321 =for apidoc perl_run
2322
2323 Tells a Perl interpreter to run.  See L<perlembed>.
2324
2325 =cut
2326 */
2327
2328 int
2329 perl_run(pTHXx)
2330 {
2331     dVAR;
2332     I32 oldscope;
2333     int ret = 0;
2334     dJMPENV;
2335
2336     PERL_UNUSED_ARG(my_perl);
2337
2338     oldscope = PL_scopestack_ix;
2339 #ifdef VMS
2340     VMSISH_HUSHED = 0;
2341 #endif
2342
2343     JMPENV_PUSH(ret);
2344     switch (ret) {
2345     case 1:
2346         cxstack_ix = -1;                /* start context stack again */
2347         goto redo_body;
2348     case 0:                             /* normal completion */
2349  redo_body:
2350         run_body(oldscope);
2351         /* FALL THROUGH */
2352     case 2:                             /* my_exit() */
2353         while (PL_scopestack_ix > oldscope)
2354             LEAVE;
2355         FREETMPS;
2356         PL_curstash = PL_defstash;
2357         if (!(PL_exit_flags & PERL_EXIT_DESTRUCT_END) &&
2358             PL_endav && !PL_minus_c)
2359             call_list(oldscope, PL_endav);
2360 #ifdef MYMALLOC
2361         if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
2362             dump_mstats("after execution:  ");
2363 #endif
2364         ret = STATUS_EXIT;
2365         break;
2366     case 3:
2367         if (PL_restartop) {
2368             POPSTACK_TO(PL_mainstack);
2369             goto redo_body;
2370         }
2371         PerlIO_printf(Perl_error_log, "panic: restartop\n");
2372         FREETMPS;
2373         ret = 1;
2374         break;
2375     }
2376
2377     JMPENV_POP;
2378     return ret;
2379 }
2380
2381 STATIC void
2382 S_run_body(pTHX_ I32 oldscope)
2383 {
2384     dVAR;
2385     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
2386                     PL_sawampersand ? "Enabling" : "Omitting"));
2387
2388     if (!PL_restartop) {
2389 #ifdef PERL_MAD
2390         if (PL_xmlfp) {
2391             xmldump_all();
2392             exit(0);    /* less likely to core dump than my_exit(0) */
2393         }
2394 #endif
2395         DEBUG_x(dump_all());
2396 #ifdef DEBUGGING
2397         if (!DEBUG_q_TEST)
2398           PERL_DEBUG(PerlIO_printf(Perl_debug_log, "\nEXECUTING...\n\n"));
2399 #endif
2400         DEBUG_S(PerlIO_printf(Perl_debug_log, "main thread is 0x%"UVxf"\n",
2401                               PTR2UV(thr)));
2402
2403         if (PL_minus_c) {
2404 #ifdef MACOS_TRADITIONAL
2405             PerlIO_printf(Perl_error_log, "%s%s syntax OK\n",
2406                 (gMacPerl_ErrorFormat ? "# " : ""),
2407                 MacPerl_MPWFileName(PL_origfilename));
2408 #else
2409             PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
2410 #endif
2411             my_exit(0);
2412         }
2413         if (PERLDB_SINGLE && PL_DBsingle)
2414             sv_setiv(PL_DBsingle, 1);
2415         if (PL_initav)
2416             call_list(oldscope, PL_initav);
2417 #ifdef PERL_DEBUG_READONLY_OPS
2418         Perl_pending_Slabs_to_ro(aTHX);
2419 #endif
2420     }
2421
2422     /* do it */
2423
2424     if (PL_restartop) {
2425         PL_op = PL_restartop;
2426         PL_restartop = 0;
2427         CALLRUNOPS(aTHX);
2428     }
2429     else if (PL_main_start) {
2430         CvDEPTH(PL_main_cv) = 1;
2431         PL_op = PL_main_start;
2432         CALLRUNOPS(aTHX);
2433     }
2434     my_exit(0);
2435     /* NOTREACHED */
2436 }
2437
2438 /*
2439 =head1 SV Manipulation Functions
2440
2441 =for apidoc p||get_sv
2442
2443 Returns the SV of the specified Perl scalar.  If C<create> is set and the
2444 Perl variable does not exist then it will be created.  If C<create> is not
2445 set and the variable does not exist then NULL is returned.
2446
2447 =cut
2448 */
2449
2450 SV*
2451 Perl_get_sv(pTHX_ const char *name, I32 create)
2452 {
2453     GV *gv;
2454     gv = gv_fetchpv(name, create, SVt_PV);
2455     if (gv)
2456         return GvSV(gv);
2457     return NULL;
2458 }
2459
2460 /*
2461 =head1 Array Manipulation Functions
2462
2463 =for apidoc p||get_av
2464
2465 Returns the AV of the specified Perl array.  If C<create> is set and the
2466 Perl variable does not exist then it will be created.  If C<create> is not
2467 set and the variable does not exist then NULL is returned.
2468
2469 =cut
2470 */
2471
2472 AV*
2473 Perl_get_av(pTHX_ const char *name, I32 create)
2474 {
2475     GV* const gv = gv_fetchpv(name, create, SVt_PVAV);
2476     if (create)
2477         return GvAVn(gv);
2478     if (gv)
2479         return GvAV(gv);
2480     return NULL;
2481 }
2482
2483 /*
2484 =head1 Hash Manipulation Functions
2485
2486 =for apidoc p||get_hv
2487
2488 Returns the HV of the specified Perl hash.  If C<create> is set and the
2489 Perl variable does not exist then it will be created.  If C<create> is not
2490 set and the variable does not exist then NULL is returned.
2491
2492 =cut
2493 */
2494
2495 HV*
2496 Perl_get_hv(pTHX_ const char *name, I32 create)
2497 {
2498     GV* const gv = gv_fetchpv(name, create, SVt_PVHV);
2499     if (create)
2500         return GvHVn(gv);
2501     if (gv)
2502         return GvHV(gv);
2503     return NULL;
2504 }
2505
2506 /*
2507 =head1 CV Manipulation Functions
2508
2509 =for apidoc p||get_cvn_flags
2510
2511 Returns the CV of the specified Perl subroutine.  C<flags> are passed to
2512 C<gv_fetchpvn_flags>. If C<GV_ADD> is set and the Perl subroutine does not
2513 exist then it will be declared (which has the same effect as saying
2514 C<sub name;>).  If C<GV_ADD> is not set and the subroutine does not exist
2515 then NULL is returned.
2516
2517 =for apidoc p||get_cv
2518
2519 Uses C<strlen> to get the length of C<name>, then calls C<get_cvn_flags>.
2520
2521 =cut
2522 */
2523
2524 CV*
2525 Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags)
2526 {
2527     GV* const gv = gv_fetchpvn_flags(name, len, flags, SVt_PVCV);
2528     /* XXX this is probably not what they think they're getting.
2529      * It has the same effect as "sub name;", i.e. just a forward
2530      * declaration! */
2531     if ((flags & ~GV_NOADD_MASK) && !GvCVu(gv)) {
2532         SV *const sv = newSVpvn(name,len);
2533         SvFLAGS(sv) |= flags & SVf_UTF8;
2534         return newSUB(start_subparse(FALSE, 0),
2535                       newSVOP(OP_CONST, 0, sv),
2536                       NULL, NULL);
2537     }
2538     if (gv)
2539         return GvCVu(gv);
2540     return NULL;
2541 }
2542
2543 CV*
2544 Perl_get_cv(pTHX_ const char *name, I32 flags)
2545 {
2546     return get_cvn_flags(name, strlen(name), flags);
2547 }
2548
2549 /* Be sure to refetch the stack pointer after calling these routines. */
2550
2551 /*
2552
2553 =head1 Callback Functions
2554
2555 =for apidoc p||call_argv
2556
2557 Performs a callback to the specified Perl sub.  See L<perlcall>.
2558
2559 =cut
2560 */
2561
2562 I32
2563 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
2564
2565                         /* See G_* flags in cop.h */
2566                         /* null terminated arg list */
2567 {
2568     dVAR;
2569     dSP;
2570
2571     PUSHMARK(SP);
2572     if (argv) {
2573         while (*argv) {
2574             XPUSHs(sv_2mortal(newSVpv(*argv,0)));
2575             argv++;
2576         }
2577         PUTBACK;
2578     }
2579     return call_pv(sub_name, flags);
2580 }
2581
2582 /*
2583 =for apidoc p||call_pv
2584
2585 Performs a callback to the specified Perl sub.  See L<perlcall>.
2586
2587 =cut
2588 */
2589
2590 I32
2591 Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
2592                         /* name of the subroutine */
2593                         /* See G_* flags in cop.h */
2594 {
2595     return call_sv((SV*)get_cv(sub_name, TRUE), flags);
2596 }
2597
2598 /*
2599 =for apidoc p||call_method
2600
2601 Performs a callback to the specified Perl method.  The blessed object must
2602 be on the stack.  See L<perlcall>.
2603
2604 =cut
2605 */
2606
2607 I32
2608 Perl_call_method(pTHX_ const char *methname, I32 flags)
2609                         /* name of the subroutine */
2610                         /* See G_* flags in cop.h */
2611 {
2612     return call_sv(sv_2mortal(newSVpv(methname,0)), flags | G_METHOD);
2613 }
2614
2615 /* May be called with any of a CV, a GV, or an SV containing the name. */
2616 /*
2617 =for apidoc p||call_sv
2618
2619 Performs a callback to the Perl sub whose name is in the SV.  See
2620 L<perlcall>.
2621
2622 =cut
2623 */
2624
2625 I32
2626 Perl_call_sv(pTHX_ SV *sv, I32 flags)
2627                         /* See G_* flags in cop.h */
2628 {
2629     dVAR; dSP;
2630     LOGOP myop;         /* fake syntax tree node */
2631     UNOP method_op;
2632     I32 oldmark;
2633     VOL I32 retval = 0;
2634     I32 oldscope;
2635     bool oldcatch = CATCH_GET;
2636     int ret;
2637     OP* const oldop = PL_op;
2638     dJMPENV;
2639
2640     if (flags & G_DISCARD) {
2641         ENTER;
2642         SAVETMPS;
2643     }
2644
2645     Zero(&myop, 1, LOGOP);
2646     myop.op_next = NULL;
2647     if (!(flags & G_NOARGS))
2648         myop.op_flags |= OPf_STACKED;
2649     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2650                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2651                       OPf_WANT_SCALAR);
2652     SAVEOP();
2653     PL_op = (OP*)&myop;
2654
2655     EXTEND(PL_stack_sp, 1);
2656     *++PL_stack_sp = sv;
2657     oldmark = TOPMARK;
2658     oldscope = PL_scopestack_ix;
2659
2660     if (PERLDB_SUB && PL_curstash != PL_debstash
2661            /* Handle first BEGIN of -d. */
2662           && (PL_DBcv || (PL_DBcv = GvCV(PL_DBsub)))
2663            /* Try harder, since this may have been a sighandler, thus
2664             * curstash may be meaningless. */
2665           && (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
2666           && !(flags & G_NODEBUG))
2667         PL_op->op_private |= OPpENTERSUB_DB;
2668
2669     if (flags & G_METHOD) {
2670         Zero(&method_op, 1, UNOP);
2671         method_op.op_next = PL_op;
2672         method_op.op_ppaddr = PL_ppaddr[OP_METHOD];
2673         myop.op_ppaddr = PL_ppaddr[OP_ENTERSUB];
2674         PL_op = (OP*)&method_op;
2675     }
2676
2677     if (!(flags & G_EVAL)) {
2678         CATCH_SET(TRUE);
2679         CALL_BODY_SUB((OP*)&myop);
2680         retval = PL_stack_sp - (PL_stack_base + oldmark);
2681         CATCH_SET(oldcatch);
2682     }
2683     else {
2684         myop.op_other = (OP*)&myop;
2685         PL_markstack_ptr--;
2686         create_eval_scope(flags|G_FAKINGEVAL);
2687         PL_markstack_ptr++;
2688
2689         JMPENV_PUSH(ret);
2690
2691         switch (ret) {
2692         case 0:
2693  redo_body:
2694             CALL_BODY_SUB((OP*)&myop);
2695             retval = PL_stack_sp - (PL_stack_base + oldmark);
2696             if (!(flags & G_KEEPERR))
2697                 sv_setpvn(ERRSV,"",0);
2698             break;
2699         case 1:
2700             STATUS_ALL_FAILURE;
2701             /* FALL THROUGH */
2702         case 2:
2703             /* my_exit() was called */
2704             PL_curstash = PL_defstash;
2705             FREETMPS;
2706             JMPENV_POP;
2707             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2708                 Perl_croak(aTHX_ "Callback called exit");
2709             my_exit_jump();
2710             /* NOTREACHED */
2711         case 3:
2712             if (PL_restartop) {
2713                 PL_op = PL_restartop;
2714                 PL_restartop = 0;
2715                 goto redo_body;
2716             }
2717             PL_stack_sp = PL_stack_base + oldmark;
2718             if (flags & G_ARRAY)
2719                 retval = 0;
2720             else {
2721                 retval = 1;
2722                 *++PL_stack_sp = &PL_sv_undef;
2723             }
2724             break;
2725         }
2726
2727         if (PL_scopestack_ix > oldscope)
2728             delete_eval_scope();
2729         JMPENV_POP;
2730     }
2731
2732     if (flags & G_DISCARD) {
2733         PL_stack_sp = PL_stack_base + oldmark;
2734         retval = 0;
2735         FREETMPS;
2736         LEAVE;
2737     }
2738     PL_op = oldop;
2739     return retval;
2740 }
2741
2742 /* Eval a string. The G_EVAL flag is always assumed. */
2743
2744 /*
2745 =for apidoc p||eval_sv
2746
2747 Tells Perl to C<eval> the string in the SV.
2748
2749 =cut
2750 */
2751
2752 I32
2753 Perl_eval_sv(pTHX_ SV *sv, I32 flags)
2754
2755                         /* See G_* flags in cop.h */
2756 {
2757     dVAR;
2758     dSP;
2759     UNOP myop;          /* fake syntax tree node */
2760     VOL I32 oldmark = SP - PL_stack_base;
2761     VOL I32 retval = 0;
2762     int ret;
2763     OP* const oldop = PL_op;
2764     dJMPENV;
2765
2766     if (flags & G_DISCARD) {
2767         ENTER;
2768         SAVETMPS;
2769     }
2770
2771     SAVEOP();
2772     PL_op = (OP*)&myop;
2773     Zero(PL_op, 1, UNOP);
2774     EXTEND(PL_stack_sp, 1);
2775     *++PL_stack_sp = sv;
2776
2777     if (!(flags & G_NOARGS))
2778         myop.op_flags = OPf_STACKED;
2779     myop.op_next = NULL;
2780     myop.op_type = OP_ENTEREVAL;
2781     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2782                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2783                       OPf_WANT_SCALAR);
2784     if (flags & G_KEEPERR)
2785         myop.op_flags |= OPf_SPECIAL;
2786
2787     /* fail now; otherwise we could fail after the JMPENV_PUSH but
2788      * before a PUSHEVAL, which corrupts the stack after a croak */
2789     TAINT_PROPER("eval_sv()");
2790
2791     JMPENV_PUSH(ret);
2792     switch (ret) {
2793     case 0:
2794  redo_body:
2795         CALL_BODY_EVAL((OP*)&myop);
2796         retval = PL_stack_sp - (PL_stack_base + oldmark);
2797         if (!(flags & G_KEEPERR))
2798             sv_setpvn(ERRSV,"",0);
2799         break;
2800     case 1:
2801         STATUS_ALL_FAILURE;
2802         /* FALL THROUGH */
2803     case 2:
2804         /* my_exit() was called */
2805         PL_curstash = PL_defstash;
2806         FREETMPS;
2807         JMPENV_POP;
2808         if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2809             Perl_croak(aTHX_ "Callback called exit");
2810         my_exit_jump();
2811         /* NOTREACHED */
2812     case 3:
2813         if (PL_restartop) {
2814             PL_op = PL_restartop;
2815             PL_restartop = 0;
2816             goto redo_body;
2817         }
2818         PL_stack_sp = PL_stack_base + oldmark;
2819         if (flags & G_ARRAY)
2820             retval = 0;
2821         else {
2822             retval = 1;
2823             *++PL_stack_sp = &PL_sv_undef;
2824         }
2825         break;
2826     }
2827
2828     JMPENV_POP;
2829     if (flags & G_DISCARD) {
2830         PL_stack_sp = PL_stack_base + oldmark;
2831         retval = 0;
2832         FREETMPS;
2833         LEAVE;
2834     }
2835     PL_op = oldop;
2836     return retval;
2837 }
2838
2839 /*
2840 =for apidoc p||eval_pv
2841
2842 Tells Perl to C<eval> the given string and return an SV* result.
2843
2844 =cut
2845 */
2846
2847 SV*
2848 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
2849 {
2850     dVAR;
2851     dSP;
2852     SV* sv = newSVpv(p, 0);
2853
2854     eval_sv(sv, G_SCALAR);
2855     SvREFCNT_dec(sv);
2856
2857     SPAGAIN;
2858     sv = POPs;
2859     PUTBACK;
2860
2861     if (croak_on_error && SvTRUE(ERRSV)) {
2862         Perl_croak(aTHX_ SvPVx_nolen_const(ERRSV));
2863     }
2864
2865     return sv;
2866 }
2867
2868 /* Require a module. */
2869
2870 /*
2871 =head1 Embedding Functions
2872
2873 =for apidoc p||require_pv
2874
2875 Tells Perl to C<require> the file named by the string argument.  It is
2876 analogous to the Perl code C<eval "require '$file'">.  It's even
2877 implemented that way; consider using load_module instead.
2878
2879 =cut */
2880
2881 void
2882 Perl_require_pv(pTHX_ const char *pv)
2883 {
2884     dVAR;
2885     dSP;
2886     SV* sv;
2887     PUSHSTACKi(PERLSI_REQUIRE);
2888     PUTBACK;
2889     sv = Perl_newSVpvf(aTHX_ "require q%c%s%c", 0, pv, 0);
2890     eval_sv(sv_2mortal(sv), G_DISCARD);
2891     SPAGAIN;
2892     POPSTACK;
2893 }
2894
2895 void
2896 Perl_magicname(pTHX_ const char *sym, const char *name, I32 namlen)
2897 {
2898     register GV * const gv = gv_fetchpv(sym, GV_ADD, SVt_PV);
2899
2900     if (gv)
2901         sv_magic(GvSV(gv), (SV*)gv, PERL_MAGIC_sv, name, namlen);
2902 }
2903
2904 STATIC void
2905 S_usage(pTHX_ const char *name)         /* XXX move this out into a module ? */
2906 {
2907     /* This message really ought to be max 23 lines.
2908      * Removed -h because the user already knows that option. Others? */
2909
2910     static const char * const usage_msg[] = {
2911 "-0[octal]         specify record separator (\\0, if no argument)",
2912 "-A[mod][=pattern] activate all/given assertions",
2913 "-a                autosplit mode with -n or -p (splits $_ into @F)",
2914 "-C[number/list]   enables the listed Unicode features",
2915 "-c                check syntax only (runs BEGIN and CHECK blocks)",
2916 "-d[:debugger]     run program under debugger",
2917 "-D[number/list]   set debugging flags (argument is a bit mask or alphabets)",
2918 "-e program        one line of program (several -e's allowed, omit programfile)",
2919 "-E program        like -e, but enables all optional features",
2920 "-f                don't do $sitelib/sitecustomize.pl at startup",
2921 "-F/pattern/       split() pattern for -a switch (//'s are optional)",
2922 "-i[extension]     edit <> files in place (makes backup if extension supplied)",
2923 "-Idirectory       specify @INC/#include directory (several -I's allowed)",
2924 "-l[octal]         enable line ending processing, specifies line terminator",
2925 "-[mM][-]module    execute \"use/no module...\" before executing program",
2926 "-n                assume \"while (<>) { ... }\" loop around program",
2927 "-p                assume loop like -n but print line also, like sed",
2928 "-P                run program through C preprocessor before compilation",
2929 "-s                enable rudimentary parsing for switches after programfile",
2930 "-S                look for programfile using PATH environment variable",
2931 "-t                enable tainting warnings",
2932 "-T                enable tainting checks",
2933 "-u                dump core after parsing program",
2934 "-U                allow unsafe operations",
2935 "-v                print version, subversion (includes VERY IMPORTANT perl info)",
2936 "-V[:variable]     print configuration summary (or a single Config.pm variable)",
2937 "-w                enable many useful warnings (RECOMMENDED)",
2938 "-W                enable all warnings",
2939 "-x[directory]     strip off text before #!perl line and perhaps cd to directory",
2940 "-X                disable all warnings",
2941 "\n",
2942 NULL
2943 };
2944     const char * const *p = usage_msg;
2945
2946     PerlIO_printf(PerlIO_stdout(),
2947                   "\nUsage: %s [switches] [--] [programfile] [arguments]",
2948                   name);
2949     while (*p)
2950         PerlIO_printf(PerlIO_stdout(), "\n  %s", *p++);
2951 }
2952
2953 /* convert a string of -D options (or digits) into an int.
2954  * sets *s to point to the char after the options */
2955
2956 #ifdef DEBUGGING
2957 int
2958 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
2959 {
2960     static const char * const usage_msgd[] = {
2961       " Debugging flag values: (see also -d)",
2962       "  p  Tokenizing and parsing (with v, displays parse stack)",
2963       "  s  Stack snapshots (with v, displays all stacks)",
2964       "  l  Context (loop) stack processing",
2965       "  t  Trace execution",
2966       "  o  Method and overloading resolution",
2967       "  c  String/numeric conversions",
2968       "  P  Print profiling info, preprocessor command for -P, source file input state",
2969       "  m  Memory allocation",
2970       "  f  Format processing",
2971       "  r  Regular expression parsing and execution",
2972       "  x  Syntax tree dump",
2973       "  u  Tainting checks",
2974       "  H  Hash dump -- usurps values()",
2975       "  X  Scratchpad allocation",
2976       "  D  Cleaning up",
2977       "  S  Thread synchronization",
2978       "  T  Tokenising",
2979       "  R  Include reference counts of dumped variables (eg when using -Ds)",
2980       "  J  Do not s,t,P-debug (Jump over) opcodes within package DB",
2981       "  v  Verbose: use in conjunction with other flags",
2982       "  C  Copy On Write",
2983       "  A  Consistency checks on internal structures",
2984       "  q  quiet - currently only suppresses the 'EXECUTING' message",
2985       NULL
2986     };
2987     int i = 0;
2988     if (isALPHA(**s)) {
2989         /* if adding extra options, remember to update DEBUG_MASK */
2990         static const char debopts[] = "psltocPmfrxuUHXDSTRJvCAq";
2991
2992         for (; isALNUM(**s); (*s)++) {
2993             const char * const d = strchr(debopts,**s);
2994             if (d)
2995                 i |= 1 << (d - debopts);
2996             else if (ckWARN_d(WARN_DEBUGGING))
2997                 Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2998                     "invalid option -D%c, use -D'' to see choices\n", **s);
2999         }
3000     }
3001     else if (isDIGIT(**s)) {
3002         i = atoi(*s);
3003         for (; isALNUM(**s); (*s)++) ;
3004     }
3005     else if (givehelp) {
3006       const char *const *p = usage_msgd;
3007       while (*p) PerlIO_printf(PerlIO_stdout(), "%s\n", *p++);
3008     }
3009 #  ifdef EBCDIC
3010     if ((i & DEBUG_p_FLAG) && ckWARN_d(WARN_DEBUGGING))
3011         Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
3012                 "-Dp not implemented on this platform\n");
3013 #  endif
3014     return i;
3015 }
3016 #endif
3017
3018 /* This routine handles any switches that can be given during run */
3019
3020 char *
3021 Perl_moreswitches(pTHX_ char *s)
3022 {
3023     dVAR;
3024     UV rschar;
3025
3026     switch (*s) {
3027     case '0':
3028     {
3029          I32 flags = 0;
3030          STRLEN numlen;
3031
3032          SvREFCNT_dec(PL_rs);
3033          if (s[1] == 'x' && s[2]) {
3034               const char *e = s+=2;
3035               U8 *tmps;
3036
3037               while (*e)
3038                 e++;
3039               numlen = e - s;
3040               flags = PERL_SCAN_SILENT_ILLDIGIT;
3041               rschar = (U32)grok_hex(s, &numlen, &flags, NULL);
3042               if (s + numlen < e) {
3043                    rschar = 0; /* Grandfather -0xFOO as -0 -xFOO. */
3044                    numlen = 0;
3045                    s--;
3046               }
3047               PL_rs = newSVpvs("");
3048               SvGROW(PL_rs, (STRLEN)(UNISKIP(rschar) + 1));
3049               tmps = (U8*)SvPVX(PL_rs);
3050               uvchr_to_utf8(tmps, rschar);
3051               SvCUR_set(PL_rs, UNISKIP(rschar));
3052               SvUTF8_on(PL_rs);
3053          }
3054          else {
3055               numlen = 4;
3056               rschar = (U32)grok_oct(s, &numlen, &flags, NULL);
3057               if (rschar & ~((U8)~0))
3058                    PL_rs = &PL_sv_undef;
3059               else if (!rschar && numlen >= 2)
3060                    PL_rs = newSVpvs("");
3061               else {
3062                    char ch = (char)rschar;
3063                    PL_rs = newSVpvn(&ch, 1);
3064               }
3065          }
3066          sv_setsv(get_sv("/", TRUE), PL_rs);
3067          return s + numlen;
3068     }
3069     case 'C':
3070         s++;
3071         PL_unicode = parse_unicode_opts( (const char **)&s );
3072         if (PL_unicode & PERL_UNICODE_UTF8CACHEASSERT_FLAG)
3073             PL_utf8cache = -1;
3074         return s;
3075     case 'F':
3076         PL_minus_F = TRUE;
3077         PL_splitstr = ++s;
3078         while (*s && !isSPACE(*s)) ++s;
3079         PL_splitstr = savepvn(PL_splitstr, s - PL_splitstr);
3080         return s;
3081     case 'a':
3082         PL_minus_a = TRUE;
3083         s++;
3084         return s;
3085     case 'c':
3086         PL_minus_c = TRUE;
3087         s++;
3088         return s;
3089     case 'd':
3090         forbid_setid('d', -1);
3091         s++;
3092
3093         /* -dt indicates to the debugger that threads will be used */
3094         if (*s == 't' && !isALNUM(s[1])) {
3095             ++s;
3096             my_setenv("PERL5DB_THREADED", "1");
3097         }
3098
3099         /* The following permits -d:Mod to accepts arguments following an =
3100            in the fashion that -MSome::Mod does. */
3101         if (*s == ':' || *s == '=') {
3102             const char *start;
3103             SV * const sv = newSVpvs("use Devel::");
3104             start = ++s;
3105             /* We now allow -d:Module=Foo,Bar */
3106             while(isALNUM(*s) || *s==':') ++s;
3107             if (*s != '=')
3108                 sv_catpv(sv, start);
3109             else {
3110                 sv_catpvn(sv, start, s-start);
3111                 /* Don't use NUL as q// delimiter here, this string goes in the
3112                  * environment. */
3113                 Perl_sv_catpvf(aTHX_ sv, " split(/,/,q{%s});", ++s);
3114             }
3115             s += strlen(s);
3116             my_setenv("PERL5DB", SvPV_nolen_const(sv));
3117         }
3118         if (!PL_perldb) {
3119             PL_perldb = PERLDB_ALL;
3120             init_debugger();
3121         }
3122         return s;
3123     case 'D':
3124     {   
3125 #ifdef DEBUGGING
3126         forbid_setid('D', -1);
3127         s++;
3128         PL_debug = get_debug_opts( (const char **)&s, 1) | DEBUG_TOP_FLAG;
3129 #else /* !DEBUGGING */
3130         if (ckWARN_d(WARN_DEBUGGING))
3131             Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
3132                    "Recompile perl with -DDEBUGGING to use -D switch (did you mean -d ?)\n");
3133         for (s++; isALNUM(*s); s++) ;
3134 #endif
3135         return s;
3136     }   
3137     case 'h':
3138         usage(PL_origargv[0]);
3139         my_exit(0);
3140     case 'i':
3141         Safefree(PL_inplace);
3142 #if defined(__CYGWIN__) /* do backup extension automagically */
3143         if (*(s+1) == '\0') {
3144         PL_inplace = savepvs(".bak");
3145         return s+1;
3146         }
3147 #endif /* __CYGWIN__ */
3148         {
3149             const char * const start = ++s;
3150             while (*s && !isSPACE(*s))
3151                 ++s;
3152
3153             PL_inplace = savepvn(start, s - start);
3154         }
3155         if (*s) {
3156             ++s;
3157             if (*s == '-')      /* Additional switches on #! line. */
3158                 s++;
3159         }
3160         return s;
3161     case 'I':   /* -I handled both here and in parse_body() */
3162         forbid_setid('I', -1);
3163         ++s;
3164         while (*s && isSPACE(*s))
3165             ++s;
3166         if (*s) {
3167             char *e, *p;
3168             p = s;
3169             /* ignore trailing spaces (possibly followed by other switches) */
3170             do {
3171                 for (e = p; *e && !isSPACE(*e); e++) ;
3172                 p = e;
3173                 while (isSPACE(*p))
3174                     p++;
3175             } while (*p && *p != '-');
3176             e = savepvn(s, e-s);
3177             incpush(e, TRUE, TRUE, FALSE, FALSE);
3178             Safefree(e);
3179             s = p;
3180             if (*s == '-')
3181                 s++;
3182         }
3183         else
3184             Perl_croak(aTHX_ "No directory specified for -I");
3185         return s;
3186     case 'l':
3187         PL_minus_l = TRUE;
3188         s++;
3189         if (PL_ors_sv) {
3190             SvREFCNT_dec(PL_ors_sv);
3191             PL_ors_sv = NULL;
3192         }
3193         if (isDIGIT(*s)) {
3194             I32 flags = 0;
3195             STRLEN numlen;
3196             PL_ors_sv = newSVpvs("\n");
3197             numlen = 3 + (*s == '0');
3198             *SvPVX(PL_ors_sv) = (char)grok_oct(s, &numlen, &flags, NULL);
3199             s += numlen;
3200         }
3201         else {
3202             if (RsPARA(PL_rs)) {
3203                 PL_ors_sv = newSVpvs("\n\n");
3204             }
3205             else {
3206                 PL_ors_sv = newSVsv(PL_rs);
3207             }
3208         }
3209         return s;
3210     case 'A':
3211         forbid_setid('A', -1);
3212         s++;
3213         {
3214             char * const start = s;
3215             SV * const sv = newSVpvs("use assertions::activate");
3216             while(isALNUM(*s) || *s == ':') ++s;
3217             if (s != start) {
3218                 sv_catpvs(sv, "::");
3219                 sv_catpvn(sv, start, s-start);
3220             }
3221             if (*s == '=') {
3222                 Perl_sv_catpvf(aTHX_ sv, " split(/,/,q%c%s%c)", 0, ++s, 0);
3223                 s+=strlen(s);
3224             }
3225             else if (*s != '\0') {
3226                 Perl_croak(aTHX_ "Can't use '%c' after -A%.*s", *s, (int)(s-start), start);
3227             }
3228             Perl_av_create_and_push(aTHX_ &PL_preambleav, sv);
3229             return s;
3230         }
3231     case 'M':
3232         forbid_setid('M', -1);  /* XXX ? */
3233         /* FALL THROUGH */
3234     case 'm':
3235         forbid_setid('m', -1);  /* XXX ? */
3236         if (*++s) {
3237             char *start;
3238             SV *sv;
3239             const char *use = "use ";
3240             /* -M-foo == 'no foo'       */
3241             /* Leading space on " no " is deliberate, to make both
3242                possibilities the same length.  */
3243             if (*s == '-') { use = " no "; ++s; }
3244             sv = newSVpvn(use,4);
3245             start = s;
3246             /* We allow -M'Module qw(Foo Bar)'  */
3247             while(isALNUM(*s) || *s==':') ++s;
3248             if (*s != '=') {
3249                 sv_catpv(sv, start);
3250                 if (*(start-1) == 'm') {
3251                     if (*s != '\0')
3252                         Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
3253                     sv_catpvs( sv, " ()");
3254                 }
3255             } else {
3256                 if (s == start)
3257                     Perl_croak(aTHX_ "Module name required with -%c option",
3258                                s[-1]);
3259                 sv_catpvn(sv, start, s-start);
3260                 sv_catpvs(sv, " split(/,/,q");
3261                 sv_catpvs(sv, "\0");        /* Use NUL as q//-delimiter. */
3262                 sv_catpv(sv, ++s);
3263                 sv_catpvs(sv,  "\0)");
3264             }
3265             s += strlen(s);
3266             Perl_av_create_and_push(aTHX_ &PL_preambleav, sv);
3267         }
3268         else
3269             Perl_croak(aTHX_ "Missing argument to -%c", *(s-1));
3270         return s;
3271     case 'n':
3272         PL_minus_n = TRUE;
3273         s++;
3274         return s;
3275     case 'p':
3276         PL_minus_p = TRUE;
3277         s++;
3278         return s;
3279     case 's':
3280         forbid_setid('s', -1);
3281         PL_doswitches = TRUE;
3282         s++;
3283         return s;
3284     case 't':
3285         if (!PL_tainting)
3286             TOO_LATE_FOR('t');
3287         s++;
3288         return s;
3289     case 'T':
3290         if (!PL_tainting)
3291             TOO_LATE_FOR('T');
3292         s++;
3293         return s;
3294     case 'u':
3295 #ifdef MACOS_TRADITIONAL
3296         Perl_croak(aTHX_ "Believe me, you don't want to use \"-u\" on a Macintosh");
3297 #endif
3298         PL_do_undump = TRUE;
3299         s++;
3300         return s;
3301     case 'U':
3302         PL_unsafe = TRUE;
3303         s++;
3304         return s;
3305     case 'v':
3306         if (!sv_derived_from(PL_patchlevel, "version"))
3307             upg_version(PL_patchlevel, TRUE);
3308 #if !defined(DGUX)
3309         PerlIO_printf(PerlIO_stdout(),
3310                 Perl_form(aTHX_ "\nThis is perl, %"SVf
3311 #ifdef PERL_PATCHNUM
3312                           " DEVEL" STRINGIFY(PERL_PATCHNUM)
3313 #endif
3314                           " built for %s",
3315                           SVfARG(vstringify(PL_patchlevel)),
3316                           ARCHNAME));
3317 #else /* DGUX */
3318 /* Adjust verbose output as in the perl that ships with the DG/UX OS from EMC */
3319         PerlIO_printf(PerlIO_stdout(),
3320                 Perl_form(aTHX_ "\nThis is perl, %"SVf"\n",
3321                     SVfARG(vstringify(PL_patchlevel))));
3322         PerlIO_printf(PerlIO_stdout(),
3323                         Perl_form(aTHX_ "        built under %s at %s %s\n",
3324                                         OSNAME, __DATE__, __TIME__));
3325         PerlIO_printf(PerlIO_stdout(),
3326                         Perl_form(aTHX_ "        OS Specific Release: %s\n",
3327                                         OSVERS));
3328 #endif /* !DGUX */
3329
3330 #if defined(LOCAL_PATCH_COUNT)
3331         if (LOCAL_PATCH_COUNT > 0)
3332             PerlIO_printf(PerlIO_stdout(),
3333                           "\n(with %d registered patch%s, "
3334                           "see perl -V for more detail)",
3335                           LOCAL_PATCH_COUNT,
3336                           (LOCAL_PATCH_COUNT!=1) ? "es" : "");
3337 #endif
3338
3339         PerlIO_printf(PerlIO_stdout(),
3340                       "\n\nCopyright 1987-2007, Larry Wall\n");
3341 #ifdef MACOS_TRADITIONAL
3342         PerlIO_printf(PerlIO_stdout(),
3343                       "\nMac OS port Copyright 1991-2002, Matthias Neeracher;\n"
3344                       "maintained by Chris Nandor\n");
3345 #endif
3346 #ifdef MSDOS
3347         PerlIO_printf(PerlIO_stdout(),
3348                       "\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
3349 #endif
3350 #ifdef DJGPP
3351         PerlIO_printf(PerlIO_stdout(),
3352                       "djgpp v2 port (jpl5003c) by Hirofumi Watanabe, 1996\n"
3353                       "djgpp v2 port (perl5004+) by Laszlo Molnar, 1997-1999\n");
3354 #endif
3355 #ifdef OS2
3356         PerlIO_printf(PerlIO_stdout(),
3357                       "\n\nOS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
3358                       "Version 5 port Copyright (c) 1994-2002, Andreas Kaiser, Ilya Zakharevich\n");
3359 #endif
3360 #ifdef atarist
3361         PerlIO_printf(PerlIO_stdout(),
3362                       "atariST series port, ++jrb  bammi@cadence.com\n");
3363 #endif
3364 #ifdef __BEOS__
3365         PerlIO_printf(PerlIO_stdout(),
3366                       "BeOS port Copyright Tom Spindler, 1997-1999\n");
3367 #endif
3368 #ifdef MPE
3369         PerlIO_printf(PerlIO_stdout(),
3370                       "MPE/iX port Copyright by Mark Klein and Mark Bixby, 1996-2003\n");
3371 #endif
3372 #ifdef OEMVS
3373         PerlIO_printf(PerlIO_stdout(),
3374                       "MVS (OS390) port by Mortice Kern Systems, 1997-1999\n");
3375 #endif
3376 #ifdef __VOS__
3377         PerlIO_printf(PerlIO_stdout(),
3378                       "Stratus VOS port by Paul.Green@stratus.com, 1997-2002\n");
3379 #endif
3380 #ifdef __OPEN_VM
3381         PerlIO_printf(PerlIO_stdout(),
3382                       "VM/ESA port by Neale Ferguson, 1998-1999\n");
3383 #endif
3384 #ifdef POSIX_BC
3385         PerlIO_printf(PerlIO_stdout(),
3386                       "BS2000 (POSIX) port by Start Amadeus GmbH, 1998-1999\n");
3387 #endif
3388 #ifdef __MINT__
3389         PerlIO_printf(PerlIO_stdout(),
3390                       "MiNT port by Guido Flohr, 1997-1999\n");
3391 #endif
3392 #ifdef EPOC
3393         PerlIO_printf(PerlIO_stdout(),
3394                       "EPOC port by Olaf Flebbe, 1999-2002\n");
3395 #endif
3396 #ifdef UNDER_CE
3397         PerlIO_printf(PerlIO_stdout(),"WINCE port by Rainer Keuchel, 2001-2002\n");
3398         PerlIO_printf(PerlIO_stdout(),"Built on " __DATE__ " " __TIME__ "\n\n");
3399         wce_hitreturn();
3400 #endif
3401 #ifdef __SYMBIAN32__
3402         PerlIO_printf(PerlIO_stdout(),
3403                       "Symbian port by Nokia, 2004-2005\n");
3404 #endif
3405 #ifdef BINARY_BUILD_NOTICE
3406         BINARY_BUILD_NOTICE;
3407 #endif
3408         PerlIO_printf(PerlIO_stdout(),
3409                       "\n\
3410 Perl may be copied only under the terms of either the Artistic License or the\n\
3411 GNU General Public License, which may be found in the Perl 5 source kit.\n\n\
3412 Complete documentation for Perl, including FAQ lists, should be found on\n\
3413 this system using \"man perl\" or \"perldoc perl\".  If you have access to the\n\
3414 Internet, point your browser at http://www.perl.org/, the Perl Home Page.\n\n");
3415         my_exit(0);
3416     case 'w':
3417         if (! (PL_dowarn & G_WARN_ALL_MASK)) {
3418             PL_dowarn |= G_WARN_ON;
3419         }
3420         s++;
3421         return s;
3422     case 'W':
3423         PL_dowarn = G_WARN_ALL_ON|G_WARN_ON;
3424         if (!specialWARN(PL_compiling.cop_warnings))
3425             PerlMemShared_free(PL_compiling.cop_warnings);
3426         PL_compiling.cop_warnings = pWARN_ALL ;
3427         s++;
3428         return s;
3429     case 'X':
3430         PL_dowarn = G_WARN_ALL_OFF;
3431         if (!specialWARN(PL_compiling.cop_warnings))
3432             PerlMemShared_free(PL_compiling.cop_warnings);
3433         PL_compiling.cop_warnings = pWARN_NONE ;
3434         s++;
3435         return s;
3436     case '*':
3437     case ' ':
3438         if (s[1] == '-')        /* Additional switches on #! line. */
3439             return s+2;
3440         break;
3441     case '-':
3442     case 0:
3443 #if defined(WIN32) || !defined(PERL_STRICT_CR)
3444     case '\r':
3445 #endif
3446     case '\n':
3447     case '\t':
3448         break;
3449 #ifdef ALTERNATE_SHEBANG
3450     case 'S':                   /* OS/2 needs -S on "extproc" line. */
3451         break;
3452 #endif
3453     case 'P':
3454         if (PL_preprocess)
3455             return s+1;
3456         /* FALL THROUGH */
3457     default:
3458         Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
3459     }
3460     return NULL;
3461 }
3462
3463 /* compliments of Tom Christiansen */
3464
3465 /* unexec() can be found in the Gnu emacs distribution */
3466 /* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
3467
3468 void
3469 Perl_my_unexec(pTHX)
3470 {
3471     PERL_UNUSED_CONTEXT;
3472 #ifdef UNEXEC
3473     SV *    prog = newSVpv(BIN_EXP, 0);
3474     SV *    file = newSVpv(PL_origfilename, 0);
3475     int    status = 1;
3476     extern int etext;
3477
3478     sv_catpvs(prog, "/perl");
3479     sv_catpvs(file, ".perldump");
3480
3481     unexec(SvPVX(file), SvPVX(prog), &etext, sbrk(0), 0);
3482     /* unexec prints msg to stderr in case of failure */
3483     PerlProc_exit(status);
3484 #else
3485 #  ifdef VMS
3486 #    include <lib$routines.h>
3487      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
3488 #  elif defined(WIN32) || defined(__CYGWIN__)
3489     Perl_croak(aTHX_ "dump is not supported");
3490 #  else
3491     ABORT();            /* for use with undump */
3492 #  endif
3493 #endif
3494 }
3495
3496 /* initialize curinterp */
3497 STATIC void
3498 S_init_interp(pTHX)
3499 {
3500     dVAR;
3501 #ifdef MULTIPLICITY
3502 #  define PERLVAR(var,type)
3503 #  define PERLVARA(var,n,type)
3504 #  if defined(PERL_IMPLICIT_CONTEXT)
3505 #    define PERLVARI(var,type,init)             aTHX->var = init;
3506 #    define PERLVARIC(var,type,init)    aTHX->var = init;
3507 #  else
3508 #    define PERLVARI(var,type,init)     PERL_GET_INTERP->var = init;
3509 #    define PERLVARIC(var,type,init)    PERL_GET_INTERP->var = init;
3510 #  endif
3511 #  include "intrpvar.h"
3512 #  undef PERLVAR
3513 #  undef PERLVARA
3514 #  undef PERLVARI
3515 #  undef PERLVARIC
3516 #else
3517 #  define PERLVAR(var,type)
3518 #  define PERLVARA(var,n,type)
3519 #  define PERLVARI(var,type,init)       PL_##var = init;
3520 #  define PERLVARIC(var,type,init)      PL_##var = init;
3521 #  include "intrpvar.h"
3522 #  undef PERLVAR
3523 #  undef PERLVARA
3524 #  undef PERLVARI
3525 #  undef PERLVARIC
3526 #endif
3527
3528     /* As these are inside a structure, PERLVARI isn't capable of initialising
3529        them  */
3530     PL_reg_oldcurpm = PL_reg_curpm = NULL;
3531     PL_reg_poscache = PL_reg_starttry = NULL;
3532 }
3533
3534 STATIC void
3535 S_init_main_stash(pTHX)
3536 {
3537     dVAR;
3538     GV *gv;
3539
3540     PL_curstash = PL_defstash = newHV();
3541     /* We know that the string "main" will be in the global shared string
3542        table, so it's a small saving to use it rather than allocate another
3543        8 bytes.  */
3544     PL_curstname = newSVpvs_share("main");
3545     gv = gv_fetchpvs("main::", GV_ADD|GV_NOTQUAL, SVt_PVHV);
3546     /* If we hadn't caused another reference to "main" to be in the shared
3547        string table above, then it would be worth reordering these two,
3548        because otherwise all we do is delete "main" from it as a consequence
3549        of the SvREFCNT_dec, only to add it again with hv_name_set */
3550     SvREFCNT_dec(GvHV(gv));
3551     hv_name_set(PL_defstash, "main", 4, 0);
3552     GvHV(gv) = (HV*)SvREFCNT_inc_simple(PL_defstash);
3553     SvREADONLY_on(gv);
3554     PL_incgv = gv_HVadd(gv_AVadd(gv_fetchpvs("INC", GV_ADD|GV_NOTQUAL,
3555                                              SVt_PVAV)));
3556     SvREFCNT_inc_simple_void(PL_incgv); /* Don't allow it to be freed */
3557     GvMULTI_on(PL_incgv);
3558     PL_hintgv = gv_fetchpvs("\010", GV_ADD|GV_NOTQUAL, SVt_PV); /* ^H */
3559     GvMULTI_on(PL_hintgv);
3560     PL_defgv = gv_fetchpvs("_", GV_ADD|GV_NOTQUAL, SVt_PVAV);
3561     SvREFCNT_inc_simple_void(PL_defgv);
3562     PL_errgv = gv_HVadd(gv_fetchpvs("@", GV_ADD|GV_NOTQUAL, SVt_PV));
3563     SvREFCNT_inc_simple_void(PL_errgv);
3564     GvMULTI_on(PL_errgv);
3565     PL_replgv = gv_fetchpvs("\022", GV_ADD|GV_NOTQUAL, SVt_PV); /* ^R */
3566     GvMULTI_on(PL_replgv);
3567     (void)Perl_form(aTHX_ "%240s","");  /* Preallocate temp - for immediate signals. */
3568 #ifdef PERL_DONT_CREATE_GVSV
3569     gv_SVadd(PL_errgv);
3570 #endif
3571     sv_grow(ERRSV, 240);        /* Preallocate - for immediate signals. */
3572     sv_setpvn(ERRSV, "", 0);
3573     PL_curstash = PL_defstash;
3574     CopSTASH_set(&PL_compiling, PL_defstash);
3575     PL_debstash = GvHV(gv_fetchpvs("DB::", GV_ADDMULTI, SVt_PVHV));
3576     PL_globalstash = GvHV(gv_fetchpvs("CORE::GLOBAL::", GV_ADDMULTI,
3577                                       SVt_PVHV));
3578     /* We must init $/ before switches are processed. */
3579     sv_setpvn(get_sv("/", TRUE), "\n", 1);
3580 }
3581
3582 STATIC int
3583 S_open_script(pTHX_ const char *scriptname, bool dosearch, SV *sv,
3584               int *suidscript, PerlIO **rsfpp)
3585 {
3586 #ifndef IAMSUID
3587     const char *quote;
3588     const char *code;
3589     const char *cpp_discard_flag;
3590     const char *perl;
3591 #endif
3592     int fdscript = -1;
3593     dVAR;
3594
3595     *suidscript = -1;
3596
3597     if (PL_e_script) {
3598         PL_origfilename = savepvs("-e");
3599     }
3600     else {
3601         /* if find_script() returns, it returns a malloc()-ed value */
3602         scriptname = PL_origfilename = find_script(scriptname, dosearch, NULL, 1);
3603
3604         if (strnEQ(scriptname, "/dev/fd/", 8) && isDIGIT(scriptname[8]) ) {
3605             const char *s = scriptname + 8;
3606             fdscript = atoi(s);
3607             while (isDIGIT(*s))
3608                 s++;
3609             if (*s) {
3610                 /* PSz 18 Feb 04
3611                  * Tell apart "normal" usage of fdscript, e.g.
3612                  * with bash on FreeBSD:
3613                  *   perl <( echo '#!perl -DA'; echo 'print "$0\n"')
3614                  * from usage in suidperl.
3615                  * Does any "normal" usage leave garbage after the number???
3616                  * Is it a mistake to use a similar /dev/fd/ construct for
3617                  * suidperl?
3618                  */
3619                 *suidscript = 1;
3620                 /* PSz 20 Feb 04  
3621                  * Be supersafe and do some sanity-checks.
3622                  * Still, can we be sure we got the right thing?
3623                  */
3624                 if (*s != '/') {
3625                     Perl_croak(aTHX_ "Wrong syntax (suid) fd script name \"%s\"\n", s);
3626                 }
3627                 if (! *(s+1)) {
3628                     Perl_croak(aTHX_ "Missing (suid) fd script name\n");
3629                 }
3630                 scriptname = savepv(s + 1);
3631                 Safefree(PL_origfilename);
3632                 PL_origfilename = (char *)scriptname;
3633             }
3634         }
3635     }
3636
3637     CopFILE_free(PL_curcop);
3638     CopFILE_set(PL_curcop, PL_origfilename);
3639     if (*PL_origfilename == '-' && PL_origfilename[1] == '\0')
3640         scriptname = (char *)"";
3641     if (fdscript >= 0) {
3642         *rsfpp = PerlIO_fdopen(fdscript,PERL_SCRIPT_MODE);
3643 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3644             if (*rsfpp)
3645                 /* ensure close-on-exec */
3646                 fcntl(PerlIO_fileno(*rsfpp),F_SETFD,1);
3647 #       endif
3648     }
3649 #ifdef IAMSUID
3650     else {
3651         Perl_croak(aTHX_ "sperl needs fd script\n"
3652                    "You should not call sperl directly; do you need to "
3653                    "change a #! line\nfrom sperl to perl?\n");
3654
3655 /* PSz 11 Nov 03
3656  * Do not open (or do other fancy stuff) while setuid.
3657  * Perl does the open, and hands script to suidperl on a fd;
3658  * suidperl only does some checks, sets up UIDs and re-execs
3659  * perl with that fd as it has always done.
3660  */
3661     }
3662     if (*suidscript != 1) {
3663         Perl_croak(aTHX_ "suidperl needs (suid) fd script\n");
3664     }
3665 #else /* IAMSUID */
3666     else if (PL_preprocess) {
3667         const char * const cpp_cfg = CPPSTDIN;
3668         SV * const cpp = newSVpvs("");
3669         SV * const cmd = newSV(0);
3670
3671         if (cpp_cfg[0] == 0) /* PERL_MICRO? */
3672              Perl_croak(aTHX_ "Can't run with cpp -P with CPPSTDIN undefined");
3673         if (strEQ(cpp_cfg, "cppstdin"))
3674             Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
3675         sv_catpv(cpp, cpp_cfg);
3676
3677 #       ifndef VMS
3678             sv_catpvs(sv, "-I");
3679             sv_catpv(sv,PRIVLIB_EXP);
3680 #       endif
3681
3682         DEBUG_P(PerlIO_printf(Perl_debug_log,
3683                               "PL_preprocess: scriptname=\"%s\", cpp=\"%s\", sv=\"%s\", CPPMINUS=\"%s\"\n",
3684                               scriptname, SvPVX_const (cpp), SvPVX_const (sv),
3685                               CPPMINUS));
3686
3687 #       if defined(MSDOS) || defined(WIN32) || defined(VMS)
3688             quote = "\"";
3689 #       else
3690             quote = "'";
3691 #       endif
3692
3693 #       ifdef VMS
3694             cpp_discard_flag = "";
3695 #       else
3696             cpp_discard_flag = "-C";
3697 #       endif
3698
3699 #       ifdef OS2
3700             perl = os2_execname(aTHX);
3701 #       else
3702             perl = PL_origargv[0];
3703 #       endif
3704
3705
3706         /* This strips off Perl comments which might interfere with
3707            the C pre-processor, including #!.  #line directives are
3708            deliberately stripped to avoid confusion with Perl's version
3709            of #line.  FWP played some golf with it so it will fit
3710            into VMS's 255 character buffer.
3711         */
3712         if( PL_doextract )
3713             code = "(1../^#!.*perl/i)|/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3714         else
3715             code = "/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3716
3717         Perl_sv_setpvf(aTHX_ cmd, "\
3718 %s -ne%s%s%s %s | %"SVf" %s %"SVf" %s",
3719                        perl, quote, code, quote, scriptname, SVfARG(cpp),
3720                        cpp_discard_flag, SVfARG(sv), CPPMINUS);
3721
3722         PL_doextract = FALSE;
3723
3724         DEBUG_P(PerlIO_printf(Perl_debug_log,
3725                               "PL_preprocess: cmd=\"%s\"\n",
3726                               SvPVX_const(cmd)));
3727
3728         *rsfpp = PerlProc_popen((char *)SvPVX_const(cmd), (char *)"r");
3729         SvREFCNT_dec(cmd);
3730         SvREFCNT_dec(cpp);
3731     }
3732     else if (!*scriptname) {
3733         forbid_setid(0, *suidscript);
3734         *rsfpp = PerlIO_stdin();
3735     }
3736     else {
3737         *rsfpp = PerlIO_open(scriptname,PERL_SCRIPT_MODE);
3738 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3739             if (*rsfpp)
3740                 /* ensure close-on-exec */
3741                 fcntl(PerlIO_fileno(*rsfpp),F_SETFD,1);
3742 #       endif
3743     }
3744 #endif /* IAMSUID */
3745     if (!*rsfpp) {
3746         /* PSz 16 Sep 03  Keep neat error message */
3747         if (PL_e_script)
3748             Perl_croak(aTHX_ "Can't open "BIT_BUCKET": %s\n", Strerror(errno));
3749         else
3750             Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
3751                     CopFILE(PL_curcop), Strerror(errno));
3752     }
3753     return fdscript;
3754 }
3755
3756 /* Mention
3757  * I_SYSSTATVFS HAS_FSTATVFS
3758  * I_SYSMOUNT
3759  * I_STATFS     HAS_FSTATFS     HAS_GETFSSTAT
3760  * I_MNTENT     HAS_GETMNTENT   HAS_HASMNTOPT
3761  * here so that metaconfig picks them up. */
3762
3763 #ifdef IAMSUID
3764 STATIC int
3765 S_fd_on_nosuid_fs(pTHX_ int fd)
3766 {
3767 /* PSz 27 Feb 04
3768  * We used to do this as "plain" user (after swapping UIDs with setreuid);
3769  * but is needed also on machines without setreuid.
3770  * Seems safe enough to run as root.
3771  */
3772     int check_okay = 0; /* able to do all the required sys/libcalls */
3773     int on_nosuid  = 0; /* the fd is on a nosuid fs */
3774     /* PSz 12 Nov 03
3775      * Need to check noexec also: nosuid might not be set, the average
3776      * sysadmin would say that nosuid is irrelevant once he sets noexec.
3777      */
3778     int on_noexec  = 0; /* the fd is on a noexec fs */
3779
3780 /*
3781  * Preferred order: fstatvfs(), fstatfs(), ustat()+getmnt(), getmntent().
3782  * fstatvfs() is UNIX98.
3783  * fstatfs() is 4.3 BSD.
3784  * ustat()+getmnt() is pre-4.3 BSD.
3785  * getmntent() is O(number-of-mounted-filesystems) and can hang on
3786  * an irrelevant filesystem while trying to reach the right one.
3787  */
3788
3789 #undef FD_ON_NOSUID_CHECK_OKAY  /* found the syscalls to do the check? */
3790
3791 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3792         defined(HAS_FSTATVFS)
3793 #   define FD_ON_NOSUID_CHECK_OKAY
3794     struct statvfs stfs;
3795
3796     check_okay = fstatvfs(fd, &stfs) == 0;
3797     on_nosuid  = check_okay && (stfs.f_flag  & ST_NOSUID);
3798 #ifdef ST_NOEXEC
3799     /* ST_NOEXEC certainly absent on AIX 5.1, and doesn't seem to be documented
3800        on platforms where it is present.  */
3801     on_noexec  = check_okay && (stfs.f_flag  & ST_NOEXEC);
3802 #endif
3803 #   endif /* fstatvfs */
3804
3805 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3806         defined(PERL_MOUNT_NOSUID)      && \
3807         defined(PERL_MOUNT_NOEXEC)      && \
3808         defined(HAS_FSTATFS)            && \
3809         defined(HAS_STRUCT_STATFS)      && \
3810         defined(HAS_STRUCT_STATFS_F_FLAGS)
3811 #   define FD_ON_NOSUID_CHECK_OKAY
3812     struct statfs  stfs;
3813
3814     check_okay = fstatfs(fd, &stfs)  == 0;
3815     on_nosuid  = check_okay && (stfs.f_flags & PERL_MOUNT_NOSUID);
3816     on_noexec  = check_okay && (stfs.f_flags & PERL_MOUNT_NOEXEC);
3817 #   endif /* fstatfs */
3818
3819 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3820         defined(PERL_MOUNT_NOSUID)      && \
3821         defined(PERL_MOUNT_NOEXEC)      && \
3822         defined(HAS_FSTAT)              && \
3823         defined(HAS_USTAT)              && \
3824         defined(HAS_GETMNT)             && \
3825         defined(HAS_STRUCT_FS_DATA)     && \
3826         defined(NOSTAT_ONE)
3827 #   define FD_ON_NOSUID_CHECK_OKAY
3828     Stat_t fdst;
3829
3830     if (fstat(fd, &fdst) == 0) {
3831         struct ustat us;
3832         if (ustat(fdst.st_dev, &us) == 0) {
3833             struct fs_data fsd;
3834             /* NOSTAT_ONE here because we're not examining fields which
3835              * vary between that case and STAT_ONE. */
3836             if (getmnt((int*)0, &fsd, (int)0, NOSTAT_ONE, us.f_fname) == 0) {
3837                 size_t cmplen = sizeof(us.f_fname);
3838                 if (sizeof(fsd.fd_req.path) < cmplen)
3839                     cmplen = sizeof(fsd.fd_req.path);
3840                 if (strnEQ(fsd.fd_req.path, us.f_fname, cmplen) &&
3841                     fdst.st_dev == fsd.fd_req.dev) {
3842                     check_okay = 1;
3843                     on_nosuid = fsd.fd_req.flags & PERL_MOUNT_NOSUID;
3844                     on_noexec = fsd.fd_req.flags & PERL_MOUNT_NOEXEC;
3845                 }
3846             }
3847         }
3848     }
3849 #   endif /* fstat+ustat+getmnt */
3850
3851 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3852         defined(HAS_GETMNTENT)          && \
3853         defined(HAS_HASMNTOPT)          && \
3854         defined(MNTOPT_NOSUID)          && \
3855         defined(MNTOPT_NOEXEC)
3856 #   define FD_ON_NOSUID_CHECK_OKAY
3857     FILE                *mtab = fopen("/etc/mtab", "r");
3858     struct mntent       *entry;
3859     Stat_t              stb, fsb;
3860
3861     if (mtab && (fstat(fd, &stb) == 0)) {
3862         while (entry = getmntent(mtab)) {
3863             if (stat(entry->mnt_dir, &fsb) == 0
3864                 && fsb.st_dev == stb.st_dev)
3865             {
3866                 /* found the filesystem */
3867                 check_okay = 1;
3868                 if (hasmntopt(entry, MNTOPT_NOSUID))
3869                     on_nosuid = 1;
3870                 if (hasmntopt(entry, MNTOPT_NOEXEC))
3871                     on_noexec = 1;
3872                 break;
3873             } /* A single fs may well fail its stat(). */
3874         }
3875     }
3876     if (mtab)
3877         fclose(mtab);
3878 #   endif /* getmntent+hasmntopt */
3879
3880     if (!check_okay)
3881         Perl_croak(aTHX_ "Can't check filesystem of script \"%s\" for nosuid/noexec", PL_origfilename);
3882     if (on_nosuid)
3883         Perl_croak(aTHX_ "Setuid script \"%s\" on nosuid filesystem", PL_origfilename);
3884     if (on_noexec)
3885         Perl_croak(aTHX_ "Setuid script \"%s\" on noexec filesystem", PL_origfilename);
3886     return ((!check_okay) || on_nosuid || on_noexec);
3887 }
3888 #endif /* IAMSUID */
3889
3890 STATIC void
3891 S_validate_suid(pTHX_ const char *validarg, const char *scriptname,
3892                 int fdscript, int suidscript, SV *linestr_sv, PerlIO *rsfp)
3893 {
3894     dVAR;
3895 #ifdef IAMSUID
3896     /* int which; */
3897 #endif /* IAMSUID */
3898
3899     /* do we need to emulate setuid on scripts? */
3900
3901     /* This code is for those BSD systems that have setuid #! scripts disabled
3902      * in the kernel because of a security problem.  Merely defining DOSUID
3903      * in perl will not fix that problem, but if you have disabled setuid
3904      * scripts in the kernel, this will attempt to emulate setuid and setgid
3905      * on scripts that have those now-otherwise-useless bits set.  The setuid
3906      * root version must be called suidperl or sperlN.NNN.  If regular perl
3907      * discovers that it has opened a setuid script, it calls suidperl with
3908      * the same argv that it had.  If suidperl finds that the script it has
3909      * just opened is NOT setuid root, it sets the effective uid back to the
3910      * uid.  We don't just make perl setuid root because that loses the
3911      * effective uid we had before invoking perl, if it was different from the
3912      * uid.
3913      * PSz 27 Feb 04
3914      * Description/comments above do not match current workings:
3915      *   suidperl must be hardlinked to sperlN.NNN (that is what we exec);
3916      *   suidperl called with script open and name changed to /dev/fd/N/X;
3917      *   suidperl croaks if script is not setuid;
3918      *   making perl setuid would be a huge security risk (and yes, that
3919      *     would lose any euid we might have had).
3920      *
3921      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
3922      * be defined in suidperl only.  suidperl must be setuid root.  The
3923      * Configure script will set this up for you if you want it.
3924      */
3925
3926 #ifdef DOSUID
3927     const char *s, *s2;
3928
3929     if (PerlLIO_fstat(PerlIO_fileno(rsfp),&PL_statbuf) < 0)     /* normal stat is insecure */
3930         Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
3931     if (PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
3932         I32 len;
3933         const char *linestr;
3934         const char *s_end;
3935
3936 #ifdef IAMSUID
3937         if (fdscript < 0 || suidscript != 1)
3938             Perl_croak(aTHX_ "Need (suid) fdscript in suidperl\n");     /* We already checked this */
3939         /* PSz 11 Nov 03
3940          * Since the script is opened by perl, not suidperl, some of these
3941          * checks are superfluous. Leaving them in probably does not lower
3942          * security(?!).
3943          */
3944         /* PSz 27 Feb 04
3945          * Do checks even for systems with no HAS_SETREUID.
3946          * We used to swap, then re-swap UIDs with
3947 #ifdef HAS_SETREUID
3948             if (setreuid(PL_euid,PL_uid) < 0
3949                 || PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
3950                 Perl_croak(aTHX_ "Can't swap uid and euid");
3951 #endif
3952 #ifdef HAS_SETREUID
3953             if (setreuid(PL_uid,PL_euid) < 0
3954                 || PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
3955                 Perl_croak(aTHX_ "Can't reswap uid and euid");
3956 #endif
3957          */
3958
3959         /* On this access check to make sure the directories are readable,
3960          * there is actually a small window that the user could use to make
3961          * filename point to an accessible directory.  So there is a faint
3962          * chance that someone could execute a setuid script down in a
3963          * non-accessible directory.  I don't know what to do about that.
3964          * But I don't think it's too important.  The manual lies when
3965          * it says access() is useful in setuid programs.
3966          * 
3967          * So, access() is pretty useless... but not harmful... do anyway.
3968          */
3969         if (PerlLIO_access(CopFILE(PL_curcop),1)) { /*double check*/
3970             Perl_croak(aTHX_ "Can't access() script\n");
3971         }
3972
3973         /* If we can swap euid and uid, then we can determine access rights
3974          * with a simple stat of the file, and then compare device and
3975          * inode to make sure we did stat() on the same file we opened.
3976          * Then we just have to make sure he or she can execute it.
3977          * 
3978          * PSz 24 Feb 04
3979          * As the script is opened by perl, not suidperl, we do not need to
3980          * care much about access rights.
3981          * 
3982          * The 'script changed' check is needed, or we can get lied to
3983          * about $0 with e.g.
3984          *  suidperl /dev/fd/4//bin/x 4<setuidscript
3985          * Without HAS_SETREUID, is it safe to stat() as root?
3986          * 
3987          * Are there any operating systems that pass /dev/fd/xxx for setuid
3988          * scripts, as suggested/described in perlsec(1)? Surely they do not
3989          * pass the script name as we do, so the "script changed" test would
3990          * fail for them... but we never get here with
3991          * SETUID_SCRIPTS_ARE_SECURE_NOW defined.
3992          * 
3993          * This is one place where we must "lie" about return status: not
3994          * say if the stat() failed. We are doing this as root, and could
3995          * be tricked into reporting existence or not of files that the
3996          * "plain" user cannot even see.
3997          */
3998         {
3999             Stat_t tmpstatbuf;
4000             if (PerlLIO_stat(CopFILE(PL_curcop),&tmpstatbuf) < 0 ||
4001                 tmpstatbuf.st_dev != PL_statbuf.st_dev ||
4002                 tmpstatbuf.st_ino != PL_statbuf.st_ino) {
4003                 Perl_croak(aTHX_ "Setuid script changed\n");
4004             }
4005
4006         }
4007         if (!cando(S_IXUSR,FALSE,&PL_statbuf))          /* can real uid exec? */
4008             Perl_croak(aTHX_ "Real UID cannot exec script\n");
4009
4010         /* PSz 27 Feb 04
4011          * We used to do this check as the "plain" user (after swapping
4012          * UIDs). But the check for nosuid and noexec filesystem is needed,
4013          * and should be done even without HAS_SETREUID. (Maybe those
4014          * operating systems do not have such mount options anyway...)
4015          * Seems safe enough to do as root.
4016          */
4017 #if !defined(NO_NOSUID_CHECK)
4018         if (fd_on_nosuid_fs(PerlIO_fileno(rsfp))) {
4019             Perl_croak(aTHX_ "Setuid script on nosuid or noexec filesystem\n");
4020         }
4021 #endif
4022 #endif /* IAMSUID */
4023
4024         if (!S_ISREG(PL_statbuf.st_mode)) {
4025             Perl_croak(aTHX_ "Setuid script not plain file\n");
4026         }
4027         if (PL_statbuf.st_mode & S_IWOTH)
4028             Perl_croak(aTHX_ "Setuid/gid script is writable by world");
4029         PL_doswitches = FALSE;          /* -s is insecure in suid */
4030         /* PSz 13 Nov 03  But -s was caught elsewhere ... so unsetting it here is useless(?!) */
4031         CopLINE_inc(PL_curcop);
4032         if (sv_gets(linestr_sv, rsfp, 0) == NULL)
4033             Perl_croak(aTHX_ "No #! line");
4034         linestr = SvPV_nolen_const(linestr_sv);
4035         /* required even on Sys V */
4036         if (!*linestr || !linestr[1] || strnNE(linestr,"#!",2))
4037             Perl_croak(aTHX_ "No #! line");
4038         linestr += 2;
4039         s = linestr;
4040         /* PSz 27 Feb 04 */
4041         /* Sanity check on line length */
4042         s_end = s + strlen(s);
4043         if (s_end == s || (s_end - s) > 4000)
4044             Perl_croak(aTHX_ "Very long #! line");
4045         /* Allow more than a single space after #! */
4046         while (isSPACE(*s)) s++;
4047         /* Sanity check on buffer end */
4048         while ((*s) && !isSPACE(*s)) s++;
4049         for (s2 = s;  (s2 > linestr &&
4050                        (isDIGIT(s2[-1]) || s2[-1] == '.' || s2[-1] == '_'
4051                         || s2[-1] == '-'));  s2--) ;
4052         /* Sanity check on buffer start */
4053         if ( (s2-4 < linestr || strnNE(s2-4,"perl",4)) &&
4054               (s-9 < linestr || strnNE(s-9,"perl",4)) )
4055             Perl_croak(aTHX_ "Not a perl script");
4056         while (*s == ' ' || *s == '\t') s++;
4057         /*
4058          * #! arg must be what we saw above.  They can invoke it by
4059          * mentioning suidperl explicitly, but they may not add any strange
4060          * arguments beyond what #! says if they do invoke suidperl that way.
4061          */
4062         /*
4063          * The way validarg was set up, we rely on the kernel to start
4064          * scripts with argv[1] set to contain all #! line switches (the
4065          * whole line).
4066          */
4067         /*
4068          * Check that we got all the arguments listed in the #! line (not
4069          * just that there are no extraneous arguments). Might not matter
4070          * much, as switches from #! line seem to be acted upon (also), and
4071          * so may be checked and trapped in perl. But, security checks must
4072          * be done in suidperl and not deferred to perl. Note that suidperl
4073          * does not get around to parsing (and checking) the switches on
4074          * the #! line (but execs perl sooner).
4075          * Allow (require) a trailing newline (which may be of two
4076          * characters on some architectures?) (but no other trailing
4077          * whitespace).
4078          */
4079         len = strlen(validarg);
4080         if (strEQ(validarg," PHOOEY ") ||
4081             strnNE(s,validarg,len) || !isSPACE(s[len]) ||
4082             !((s_end - s) == len+1
4083               || ((s_end - s) == len+2 && isSPACE(s[len+1]))))
4084             Perl_croak(aTHX_ "Args must match #! line");
4085
4086 #ifndef IAMSUID
4087         if (fdscript < 0 &&
4088             PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
4089             PL_euid == PL_statbuf.st_uid)
4090             if (!PL_do_undump)
4091                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
4092 FIX YOUR KERNEL, OR PUT A C WRAPPER AROUND THIS SCRIPT!\n");
4093 #endif /* IAMSUID */
4094
4095         if (fdscript < 0 &&
4096             PL_euid) {  /* oops, we're not the setuid root perl */
4097             /* PSz 18 Feb 04
4098              * When root runs a setuid script, we do not go through the same
4099              * steps of execing sperl and then perl with fd scripts, but
4100              * simply set up UIDs within the same perl invocation; so do
4101              * not have the same checks (on options, whatever) that we have
4102              * for plain users. No problem really: would have to be a script
4103              * that does not actually work for plain users; and if root is
4104              * foolish and can be persuaded to run such an unsafe script, he
4105              * might run also non-setuid ones, and deserves what he gets.
4106              * 
4107              * Or, we might drop the PL_euid check above (and rely just on
4108              * fdscript to avoid loops), and do the execs
4109              * even for root.
4110              */
4111 #ifndef IAMSUID
4112             int which;
4113             /* PSz 11 Nov 03
4114              * Pass fd script to suidperl.
4115              * Exec suidperl, substituting fd script for scriptname.
4116              * Pass script name as "subdir" of fd, which perl will grok;
4117              * in fact will use that to distinguish this from "normal"
4118              * usage, see comments above.
4119              */
4120             PerlIO_rewind(rsfp);
4121             PerlLIO_lseek(PerlIO_fileno(rsfp),(Off_t)0,0);  /* just in case rewind didn't */
4122             /* PSz 27 Feb 04  Sanity checks on scriptname */
4123             if ((!scriptname) || (!*scriptname) ) {
4124                 Perl_croak(aTHX_ "No setuid script name\n");
4125             }
4126             if (*scriptname == '-') {
4127                 Perl_croak(aTHX_ "Setuid script name may not begin with dash\n");
4128                 /* Or we might confuse it with an option when replacing
4129                  * name in argument list, below (though we do pointer, not
4130                  * string, comparisons).
4131                  */
4132             }
4133             for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
4134             if (!PL_origargv[which]) {
4135                 Perl_croak(aTHX_ "Can't change argv to have fd script\n");
4136             }
4137             PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
4138                                           PerlIO_fileno(rsfp), PL_origargv[which]));
4139 #if defined(HAS_FCNTL) && defined(F_SETFD)
4140             fcntl(PerlIO_fileno(rsfp),F_SETFD,0);       /* ensure no close-on-exec */
4141 #endif
4142             PERL_FPU_PRE_EXEC
4143             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
4144                                      (int)PERL_REVISION, (int)PERL_VERSION,
4145                                      (int)PERL_SUBVERSION), PL_origargv);
4146             PERL_FPU_POST_EXEC
4147 #endif /* IAMSUID */
4148             Perl_croak(aTHX_ "Can't do setuid (cannot exec sperl)\n");
4149         }
4150
4151         if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
4152 /* PSz 26 Feb 04
4153  * This seems back to front: we try HAS_SETEGID first; if not available
4154  * then try HAS_SETREGID; as a last chance we try HAS_SETRESGID. May be OK
4155  * in the sense that we only want to set EGID; but are there any machines
4156  * with either of the latter, but not the former? Same with UID, later.
4157  */
4158 #ifdef HAS_SETEGID
4159             (void)setegid(PL_statbuf.st_gid);
4160 #else
4161 #ifdef HAS_SETREGID
4162            (void)setregid((Gid_t)-1,PL_statbuf.st_gid);
4163 #else
4164 #ifdef HAS_SETRESGID
4165            (void)setresgid((Gid_t)-1,PL_statbuf.st_gid,(Gid_t)-1);
4166 #else
4167             PerlProc_setgid(PL_statbuf.st_gid);
4168 #endif
4169 #endif
4170 #endif
4171             if (PerlProc_getegid() != PL_statbuf.st_gid)
4172                 Perl_croak(aTHX_ "Can't do setegid!\n");
4173         }
4174         if (PL_statbuf.st_mode & S_ISUID) {
4175             if (PL_statbuf.st_uid != PL_euid)
4176 #ifdef HAS_SETEUID
4177                 (void)seteuid(PL_statbuf.st_uid);       /* all that for this */
4178 #else
4179 #ifdef HAS_SETREUID
4180                 (void)setreuid((Uid_t)-1,PL_statbuf.st_uid);
4181 #else
4182 #ifdef HAS_SETRESUID
4183                 (void)setresuid((Uid_t)-1,PL_statbuf.st_uid,(Uid_t)-1);
4184 #else
4185                 PerlProc_setuid(PL_statbuf.st_uid);
4186 #endif
4187 #endif
4188 #endif
4189             if (PerlProc_geteuid() != PL_statbuf.st_uid)
4190                 Perl_croak(aTHX_ "Can't do seteuid!\n");
4191         }
4192         else if (PL_uid) {                      /* oops, mustn't run as root */
4193 #ifdef HAS_SETEUID
4194           (void)seteuid((Uid_t)PL_uid);
4195 #else
4196 #ifdef HAS_SETREUID
4197           (void)setreuid((Uid_t)-1,(Uid_t)PL_uid);
4198 #else
4199 #ifdef HAS_SETRESUID
4200           (void)setresuid((Uid_t)-1,(Uid_t)PL_uid,(Uid_t)-1);
4201 #else
4202           PerlProc_setuid((Uid_t)PL_uid);
4203 #endif
4204 #endif
4205 #endif
4206             if (PerlProc_geteuid() != PL_uid)
4207                 Perl_croak(aTHX_ "Can't do seteuid!\n");
4208         }
4209         init_ids();
4210         if (!cando(S_IXUSR,TRUE,&PL_statbuf))
4211             Perl_croak(aTHX_ "Effective UID cannot exec script\n");     /* they can't do this */
4212     }
4213 #ifdef IAMSUID
4214     else if (PL_preprocess)     /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
4215         Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
4216     else if (fdscript < 0 || suidscript != 1)
4217         /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
4218         Perl_croak(aTHX_ "(suid) fdscript needed in suidperl\n");
4219     else {
4220 /* PSz 16 Sep 03  Keep neat error message */
4221         Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
4222     }
4223
4224     /* We absolutely must clear out any saved ids here, so we */
4225     /* exec the real perl, substituting fd script for scriptname. */
4226     /* (We pass script name as "subdir" of fd, which perl will grok.) */
4227     /* 
4228      * It might be thought that using setresgid and/or setresuid (changed to
4229      * set the saved IDs) above might obviate the need to exec, and we could
4230      * go on to "do the perl thing".
4231      * 
4232      * Is there such a thing as "saved GID", and is that set for setuid (but
4233      * not setgid) execution like suidperl? Without exec, it would not be
4234      * cleared for setuid (but not setgid) scripts (or might need a dummy
4235      * setresgid).
4236      * 
4237      * We need suidperl to do the exact same argument checking that perl
4238      * does. Thus it cannot be very small; while it could be significantly
4239      * smaller, it is safer (simpler?) to make it essentially the same
4240      * binary as perl (but they are not identical). - Maybe could defer that
4241      * check to the invoked perl, and suidperl be a tiny wrapper instead;
4242      * but prefer to do thorough checks in suidperl itself. Such deferral
4243      * would make suidperl security rely on perl, a design no-no.
4244      * 
4245      * Setuid things should be short and simple, thus easy to understand and
4246      * verify. They should do their "own thing", without influence by
4247      * attackers. It may help if their internal execution flow is fixed,
4248      * regardless of platform: it may be best to exec anyway.
4249      * 
4250      * Suidperl should at least be conceptually simple: a wrapper only,
4251      * never to do any real perl. Maybe we should put
4252      * #ifdef IAMSUID
4253      *         Perl_croak(aTHX_ "Suidperl should never do real perl\n");
4254      * #endif
4255      * into the perly bits.
4256      */
4257     PerlIO_rewind(rsfp);
4258     PerlLIO_lseek(PerlIO_fileno(rsfp),(Off_t)0,0);  /* just in case rewind didn't */
4259     /* PSz 11 Nov 03
4260      * Keep original arguments: suidperl already has fd script.
4261      */
4262 /*  for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;  */
4263 /*  if (!PL_origargv[which]) {                                          */
4264 /*      errno = EPERM;                                                  */
4265 /*      Perl_croak(aTHX_ "Permission denied\n");                        */
4266 /*  }                                                                   */
4267 /*  PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",        */
4268 /*                                PerlIO_fileno(rsfp), PL_origargv[which]));    */
4269 #if defined(HAS_FCNTL) && defined(F_SETFD)
4270     fcntl(PerlIO_fileno(rsfp),F_SETFD,0);       /* ensure no close-on-exec */
4271 #endif
4272     PERL_FPU_PRE_EXEC
4273     PerlProc_execv(Perl_form(aTHX_ "%s/perl"PERL_FS_VER_FMT, BIN_EXP,
4274                              (int)PERL_REVISION, (int)PERL_VERSION,
4275                              (int)PERL_SUBVERSION), PL_origargv);/* try again */
4276     PERL_FPU_POST_EXEC
4277     Perl_croak(aTHX_ "Can't do setuid (suidperl cannot exec perl)\n");
4278 #endif /* IAMSUID */
4279 #else /* !DOSUID */
4280     PERL_UNUSED_ARG(fdscript);
4281     PERL_UNUSED_ARG(suidscript);
4282     if (PL_euid != PL_uid || PL_egid != PL_gid) {       /* (suidperl doesn't exist, in fact) */
4283 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
4284         PerlLIO_fstat(PerlIO_fileno(rsfp),&PL_statbuf); /* may be either wrapped or real suid */
4285         if ((PL_euid != PL_uid && PL_euid == PL_statbuf.st_uid && PL_statbuf.st_mode & S_ISUID)
4286             ||
4287             (PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
4288            )
4289             if (!PL_do_undump)
4290                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
4291 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
4292 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
4293         /* not set-id, must be wrapped */
4294     }
4295 #endif /* DOSUID */
4296     PERL_UNUSED_ARG(validarg);
4297     PERL_UNUSED_ARG(scriptname);
4298     PERL_UNUSED_ARG(linestr_sv);
4299 }
4300
4301 STATIC void
4302 S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp)
4303 {
4304     dVAR;
4305     register char *s;
4306     register const char *s2;
4307 #ifdef MACOS_TRADITIONAL
4308     int maclines = 0;
4309 #endif
4310
4311     /* skip forward in input to the real script? */
4312
4313 #ifdef MACOS_TRADITIONAL
4314     /* Since the Mac OS does not honor #! arguments for us, we do it ourselves */
4315
4316     while (PL_doextract || gMacPerl_AlwaysExtract) {
4317         if ((s = sv_gets(linestr_sv, rsfp, 0)) == NULL) {
4318             if (!gMacPerl_AlwaysExtract)
4319                 Perl_croak(aTHX_ "No Perl script found in input\n");
4320
4321             if (PL_doextract)                   /* require explicit override ? */
4322                 if (!OverrideExtract(PL_origfilename))
4323                     Perl_croak(aTHX_ "User aborted script\n");
4324                 else
4325                     PL_doextract = FALSE;
4326
4327             /* Pater peccavi, file does not have #! */
4328             PerlIO_rewind(rsfp);
4329
4330             break;
4331         }
4332 #else
4333     while (PL_doextract) {
4334         if ((s = sv_gets(linestr_sv, rsfp, 0)) == NULL)
4335             Perl_croak(aTHX_ "No Perl script found in input\n");
4336 #endif
4337         s2 = s;
4338         if (*s == '#' && s[1] == '!' && ((s = instr(s,"perl")) || (s = instr(s2,"PERL")))) {
4339             PerlIO_ungetc(rsfp, '\n');          /* to keep line count right */
4340             PL_doextract = FALSE;
4341             while (*s && !(isSPACE (*s) || *s == '#')) s++;
4342             s2 = s;
4343             while (*s == ' ' || *s == '\t') s++;
4344             if (*s++ == '-') {
4345                 while (isDIGIT(s2[-1]) || s2[-1] == '-' || s2[-1] == '.'
4346                        || s2[-1] == '_') s2--;
4347                 if (strnEQ(s2-4,"perl",4))
4348                     while ((s = moreswitches(s)))
4349                         ;
4350             }
4351 #ifdef MACOS_TRADITIONAL
4352             /* We are always searching for the #!perl line in MacPerl,
4353              * so if we find it, still keep the line count correct
4354              * by counting lines we already skipped over
4355              */
4356             for (; maclines > 0 ; maclines--)
4357                 PerlIO_ungetc(rsfp, '\n');
4358
4359             break;
4360
4361         /* gMacPerl_AlwaysExtract is false in MPW tool */
4362         } else if (gMacPerl_AlwaysExtract) {
4363             ++maclines;
4364 #endif
4365         }
4366     }
4367 }
4368
4369
4370 STATIC void
4371 S_init_ids(pTHX)
4372 {
4373     dVAR;
4374     PL_uid = PerlProc_getuid();
4375     PL_euid = PerlProc_geteuid();
4376     PL_gid = PerlProc_getgid();
4377     PL_egid = PerlProc_getegid();
4378 #ifdef VMS
4379     PL_uid |= PL_gid << 16;
4380     PL_euid |= PL_egid << 16;
4381 #endif
4382     /* Should not happen: */
4383     CHECK_MALLOC_TAINT(PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
4384     PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
4385     /* BUG */
4386     /* PSz 27 Feb 04
4387      * Should go by suidscript, not uid!=euid: why disallow
4388      * system("ls") in scripts run from setuid things?
4389      * Or, is this run before we check arguments and set suidscript?
4390      * What about SETUID_SCRIPTS_ARE_SECURE_NOW: could we use fdscript then?
4391      * (We never have suidscript, can we be sure to have fdscript?)
4392      * Or must then go by UID checks? See comments in forbid_setid also.
4393      */
4394 }
4395
4396 /* This is used very early in the lifetime of the program,
4397  * before even the options are parsed, so PL_tainting has
4398  * not been initialized properly.  */
4399 bool
4400 Perl_doing_taint(int argc, char *argv[], char *envp[])
4401 {
4402 #ifndef PERL_IMPLICIT_SYS
4403     /* If we have PERL_IMPLICIT_SYS we can't call getuid() et alia
4404      * before we have an interpreter-- and the whole point of this
4405      * function is to be called at such an early stage.  If you are on
4406      * a system with PERL_IMPLICIT_SYS but you do have a concept of
4407      * "tainted because running with altered effective ids', you'll
4408      * have to add your own checks somewhere in here.  The two most
4409      * known samples of 'implicitness' are Win32 and NetWare, neither
4410      * of which has much of concept of 'uids'. */
4411     int uid  = PerlProc_getuid();
4412     int euid = PerlProc_geteuid();
4413     int gid  = PerlProc_getgid();
4414     int egid = PerlProc_getegid();
4415     (void)envp;
4416
4417 #ifdef VMS
4418     uid  |=  gid << 16;
4419     euid |= egid << 16;
4420 #endif
4421     if (uid && (euid != uid || egid != gid))
4422         return 1;
4423 #endif /* !PERL_IMPLICIT_SYS */
4424     /* This is a really primitive check; environment gets ignored only
4425      * if -T are the first chars together; otherwise one gets
4426      *  "Too late" message. */
4427     if ( argc > 1 && argv[1][0] == '-'
4428          && (argv[1][1] == 't' || argv[1][1] == 'T') )
4429         return 1;
4430     return 0;
4431 }
4432
4433 /* Passing the flag as a single char rather than a string is a slight space
4434    optimisation.  The only message that isn't /^-.$/ is
4435    "program input from stdin", which is substituted in place of '\0', which
4436    could never be a command line flag.  */
4437 STATIC void
4438 S_forbid_setid(pTHX_ const char flag, const int suidscript)
4439 {
4440     dVAR;
4441     char string[3] = "-x";
4442     const char *message = "program input from stdin";
4443
4444     if (flag) {
4445         string[1] = flag;
4446         message = string;
4447     }
4448
4449 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
4450     if (PL_euid != PL_uid)
4451         Perl_croak(aTHX_ "No %s allowed while running setuid", message);
4452     if (PL_egid != PL_gid)
4453         Perl_croak(aTHX_ "No %s allowed while running setgid", message);
4454 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
4455     /* PSz 29 Feb 04
4456      * Checks for UID/GID above "wrong": why disallow
4457      *   perl -e 'print "Hello\n"'
4458      * from within setuid things?? Simply drop them: replaced by
4459      * fdscript/suidscript and #ifdef IAMSUID checks below.
4460      * 
4461      * This may be too late for command-line switches. Will catch those on
4462      * the #! line, after finding the script name and setting up
4463      * fdscript/suidscript. Note that suidperl does not get around to
4464      * parsing (and checking) the switches on the #! line, but checks that
4465      * the two sets are identical.
4466      * 
4467      * With SETUID_SCRIPTS_ARE_SECURE_NOW, could we use fdscript, also or
4468      * instead, or would that be "too late"? (We never have suidscript, can
4469      * we be sure to have fdscript?)
4470      * 
4471      * Catch things with suidscript (in descendant of suidperl), even with
4472      * right UID/GID. Was already checked in suidperl, with #ifdef IAMSUID,
4473      * below; but I am paranoid.
4474      * 
4475      * Also see comments about root running a setuid script, elsewhere.
4476      */
4477     if (suidscript >= 0)
4478         Perl_croak(aTHX_ "No %s allowed with (suid) fdscript", message);
4479 #ifdef IAMSUID
4480     /* PSz 11 Nov 03  Catch it in suidperl, always! */
4481     Perl_croak(aTHX_ "No %s allowed in suidperl", message);
4482 #endif /* IAMSUID */
4483 }
4484
4485 void
4486 Perl_init_debugger(pTHX)
4487 {
4488     dVAR;
4489     HV * const ostash = PL_curstash;
4490
4491     PL_curstash = PL_debstash;
4492     PL_dbargs = GvAV(gv_AVadd((gv_fetchpvs("DB::args", GV_ADDMULTI,
4493                                            SVt_PVAV))));
4494     AvREAL_off(PL_dbargs);
4495     PL_DBgv = gv_fetchpvs("DB::DB", GV_ADDMULTI, SVt_PVGV);
4496     PL_DBline = gv_fetchpvs("DB::dbline", GV_ADDMULTI, SVt_PVAV);
4497     PL_DBsub = gv_HVadd(gv_fetchpvs("DB::sub", GV_ADDMULTI, SVt_PVHV));
4498     PL_DBsingle = GvSV((gv_fetchpvs("DB::single", GV_ADDMULTI, SVt_PV)));
4499     sv_setiv(PL_DBsingle, 0);
4500     PL_DBtrace = GvSV((gv_fetchpvs("DB::trace", GV_ADDMULTI, SVt_PV)));
4501     sv_setiv(PL_DBtrace, 0);
4502     PL_DBsignal = GvSV((gv_fetchpvs("DB::signal", GV_ADDMULTI, SVt_PV)));
4503     sv_setiv(PL_DBsignal, 0);
4504     PL_DBassertion = GvSV((gv_fetchpvs("DB::assertion", GV_ADDMULTI, SVt_PV)));
4505     sv_setiv(PL_DBassertion, 0);
4506     PL_curstash = ostash;
4507 }
4508
4509 #ifndef STRESS_REALLOC
4510 #define REASONABLE(size) (size)
4511 #else
4512 #define REASONABLE(size) (1) /* unreasonable */
4513 #endif
4514
4515 void
4516 Perl_init_stacks(pTHX)
4517 {
4518     dVAR;
4519     /* start with 128-item stack and 8K cxstack */
4520     PL_curstackinfo = new_stackinfo(REASONABLE(128),
4521                                  REASONABLE(8192/sizeof(PERL_CONTEXT) - 1));
4522     PL_curstackinfo->si_type = PERLSI_MAIN;
4523     PL_curstack = PL_curstackinfo->si_stack;
4524     PL_mainstack = PL_curstack;         /* remember in case we switch stacks */
4525
4526     PL_stack_base = AvARRAY(PL_curstack);
4527     PL_stack_sp = PL_stack_base;
4528     PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
4529
4530     Newx(PL_tmps_stack,REASONABLE(128),SV*);
4531     PL_tmps_floor = -1;
4532     PL_tmps_ix = -1;
4533     PL_tmps_max = REASONABLE(128);
4534
4535     Newx(PL_markstack,REASONABLE(32),I32);
4536     PL_markstack_ptr = PL_markstack;
4537     PL_markstack_max = PL_markstack + REASONABLE(32);
4538
4539     SET_MARK_OFFSET;
4540
4541     Newx(PL_scopestack,REASONABLE(32),I32);
4542     PL_scopestack_ix = 0;
4543     PL_scopestack_max = REASONABLE(32);
4544
4545     Newx(PL_savestack,REASONABLE(128),ANY);
4546     PL_savestack_ix = 0;
4547     PL_savestack_max = REASONABLE(128);
4548 }
4549
4550 #undef REASONABLE
4551
4552 STATIC void
4553 S_nuke_stacks(pTHX)
4554 {
4555     dVAR;
4556     while (PL_curstackinfo->si_next)
4557         PL_curstackinfo = PL_curstackinfo->si_next;
4558     while (PL_curstackinfo) {
4559         PERL_SI *p = PL_curstackinfo->si_prev;
4560         /* curstackinfo->si_stack got nuked by sv_free_arenas() */
4561         Safefree(PL_curstackinfo->si_cxstack);
4562         Safefree(PL_curstackinfo);
4563         PL_curstackinfo = p;
4564     }
4565     Safefree(PL_tmps_stack);
4566     Safefree(PL_markstack);
4567     Safefree(PL_scopestack);
4568     Safefree(PL_savestack);
4569 }
4570
4571
4572 STATIC void
4573 S_init_predump_symbols(pTHX)
4574 {
4575     dVAR;
4576     GV *tmpgv;
4577     IO *io;
4578
4579     sv_setpvn(get_sv("\"", TRUE), " ", 1);
4580     PL_stdingv = gv_fetchpvs("STDIN", GV_ADD|GV_NOTQUAL, SVt_PVIO);
4581     GvMULTI_on(PL_stdingv);
4582     io = GvIOp(PL_stdingv);
4583     IoTYPE(io) = IoTYPE_RDONLY;
4584     IoIFP(io) = PerlIO_stdin();
4585     tmpgv = gv_fetchpvs("stdin", GV_ADD|GV_NOTQUAL, SVt_PV);
4586     GvMULTI_on(tmpgv);
4587     GvIOp(tmpgv) = (IO*)SvREFCNT_inc_simple(io);
4588
4589     tmpgv = gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVIO);
4590     GvMULTI_on(tmpgv);
4591     io = GvIOp(tmpgv);
4592     IoTYPE(io) = IoTYPE_WRONLY;
4593     IoOFP(io) = IoIFP(io) = PerlIO_stdout();
4594     setdefout(tmpgv);
4595     tmpgv = gv_fetchpvs("stdout", GV_ADD|GV_NOTQUAL, SVt_PV);
4596     GvMULTI_on(tmpgv);
4597     GvIOp(tmpgv) = (IO*)SvREFCNT_inc_simple(io);
4598
4599     PL_stderrgv = gv_fetchpvs("STDERR", GV_ADD|GV_NOTQUAL, SVt_PVIO);
4600     GvMULTI_on(PL_stderrgv);
4601     io = GvIOp(PL_stderrgv);
4602     IoTYPE(io) = IoTYPE_WRONLY;
4603     IoOFP(io) = IoIFP(io) = PerlIO_stderr();
4604     tmpgv = gv_fetchpvs("stderr", GV_ADD|GV_NOTQUAL, SVt_PV);
4605     GvMULTI_on(tmpgv);
4606     GvIOp(tmpgv) = (IO*)SvREFCNT_inc_simple(io);
4607
4608     PL_statname = newSV(0);             /* last filename we did stat on */
4609
4610     Safefree(PL_osname);
4611     PL_osname = savepv(OSNAME);
4612 }
4613
4614 void
4615 Perl_init_argv_symbols(pTHX_ register int argc, register char **argv)
4616 {
4617     dVAR;
4618     argc--,argv++;      /* skip name of script */
4619     if (PL_doswitches) {
4620         for (; argc > 0 && **argv == '-'; argc--,argv++) {
4621             char *s;
4622             if (!argv[0][1])
4623                 break;
4624             if (argv[0][1] == '-' && !argv[0][2]) {
4625                 argc--,argv++;
4626                 break;
4627             }
4628             if ((s = strchr(argv[0], '='))) {
4629                 const char *const start_name = argv[0] + 1;
4630                 sv_setpv(GvSV(gv_fetchpvn_flags(start_name, s - start_name,
4631                                                 TRUE, SVt_PV)), s + 1);
4632             }
4633             else
4634                 sv_setiv(GvSV(gv_fetchpv(argv[0]+1, GV_ADD, SVt_PV)),1);
4635         }
4636     }
4637     if ((PL_argvgv = gv_fetchpvs("ARGV", GV_ADD|GV_NOTQUAL, SVt_PVAV))) {
4638         GvMULTI_on(PL_argvgv);
4639         (void)gv_AVadd(PL_argvgv);
4640         av_clear(GvAVn(PL_argvgv));
4641         for (; argc > 0; argc--,argv++) {
4642             SV * const sv = newSVpv(argv[0],0);
4643             av_push(GvAVn(PL_argvgv),sv);
4644             if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
4645                  if (PL_unicode & PERL_UNICODE_ARGV_FLAG)
4646                       SvUTF8_on(sv);
4647             }
4648             if (PL_unicode & PERL_UNICODE_WIDESYSCALLS_FLAG) /* Sarathy? */
4649                  (void)sv_utf8_decode(sv);
4650         }
4651     }
4652 }
4653
4654 STATIC void
4655 S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
4656 {
4657     dVAR;
4658     GV* tmpgv;
4659
4660     PL_toptarget = newSV_type(SVt_PVFM);
4661     sv_setpvn(PL_toptarget, "", 0);
4662     PL_bodytarget = newSV_type(SVt_PVFM);
4663     sv_setpvn(PL_bodytarget, "", 0);
4664     PL_formtarget = PL_bodytarget;
4665
4666     TAINT;
4667
4668     init_argv_symbols(argc,argv);
4669
4670     if ((tmpgv = gv_fetchpvs("0", GV_ADD|GV_NOTQUAL, SVt_PV))) {
4671 #ifdef MACOS_TRADITIONAL
4672         /* $0 is not majick on a Mac */
4673         sv_setpv(GvSV(tmpgv),MacPerl_MPWFileName(PL_origfilename));
4674 #else
4675         sv_setpv(GvSV(tmpgv),PL_origfilename);
4676         magicname("0", "0", 1);
4677 #endif
4678     }
4679     if ((PL_envgv = gv_fetchpvs("ENV", GV_ADD|GV_NOTQUAL, SVt_PVHV))) {
4680         HV *hv;
4681         bool env_is_not_environ;
4682         GvMULTI_on(PL_envgv);
4683         hv = GvHVn(PL_envgv);
4684         hv_magic(hv, NULL, PERL_MAGIC_env);
4685 #ifndef PERL_MICRO
4686 #ifdef USE_ENVIRON_ARRAY
4687         /* Note that if the supplied env parameter is actually a copy
4688            of the global environ then it may now point to free'd memory
4689            if the environment has been modified since. To avoid this
4690            problem we treat env==NULL as meaning 'use the default'
4691         */
4692         if (!env)
4693             env = environ;
4694         env_is_not_environ = env != environ;
4695         if (env_is_not_environ
4696 #  ifdef USE_ITHREADS
4697             && PL_curinterp == aTHX
4698 #  endif
4699            )
4700         {
4701             environ[0] = NULL;
4702         }
4703         if (env) {
4704           char *s;
4705           SV *sv;
4706           for (; *env; env++) {
4707             if (!(s = strchr(*env,'=')) || s == *env)
4708                 continue;
4709 #if defined(MSDOS) && !defined(DJGPP)
4710             *s = '\0';
4711             (void)strupr(*env);
4712             *s = '=';
4713 #endif
4714             sv = newSVpv(s+1, 0);
4715             (void)hv_store(hv, *env, s - *env, sv, 0);
4716             if (env_is_not_environ)
4717                 mg_set(sv);
4718           }
4719       }
4720 #endif /* USE_ENVIRON_ARRAY */
4721 #endif /* !PERL_MICRO */
4722     }
4723     TAINT_NOT;
4724     if ((tmpgv = gv_fetchpvs("$", GV_ADD|GV_NOTQUAL, SVt_PV))) {
4725         SvREADONLY_off(GvSV(tmpgv));
4726         sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid());
4727         SvREADONLY_on(GvSV(tmpgv));
4728     }
4729 #ifdef THREADS_HAVE_PIDS
4730     PL_ppid = (IV)getppid();
4731 #endif
4732
4733     /* touch @F array to prevent spurious warnings 20020415 MJD */
4734     if (PL_minus_a) {
4735       (void) get_av("main::F", TRUE | GV_ADDMULTI);
4736     }
4737 }
4738
4739 STATIC void
4740 S_init_perllib(pTHX)
4741 {
4742     dVAR;
4743     char *s;
4744     if (!PL_tainting) {
4745 #ifndef VMS
4746         s = PerlEnv_getenv("PERL5LIB");
4747 /*
4748  * It isn't possible to delete an environment variable with
4749  * PERL_USE_SAFE_PUTENV set unless unsetenv() is also available, so in that
4750  * case we treat PERL5LIB as undefined if it has a zero-length value.
4751  */
4752 #if defined(PERL_USE_SAFE_PUTENV) && ! defined(HAS_UNSETENV)
4753         if (s && *s != '\0')
4754 #else
4755         if (s)
4756 #endif
4757             incpush(s, TRUE, TRUE, TRUE, FALSE);
4758         else
4759             incpush(PerlEnv_getenv("PERLLIB"), FALSE, FALSE, TRUE, FALSE);
4760 #else /* VMS */
4761         /* Treat PERL5?LIB as a possible search list logical name -- the
4762          * "natural" VMS idiom for a Unix path string.  We allow each
4763          * element to be a set of |-separated directories for compatibility.
4764          */
4765         char buf[256];
4766         int idx = 0;
4767         if (my_trnlnm("PERL5LIB",buf,0))
4768             do { incpush(buf,TRUE,TRUE,TRUE,FALSE); } while (my_trnlnm("PERL5LIB",buf,++idx));