perl.c

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