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