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
1747                              " DEBUG_LEAKING_SCALARS"
1748 #  endif
1749 #  ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
1750                              " DEBUG_LEAKING_SCALARS_FORK_DUMP"
1751 #  endif
1752 #  ifdef FAKE_THREADS
1753                              " FAKE_THREADS"
1754 #  endif
1755 #  ifdef MULTIPLICITY
1756                              " MULTIPLICITY"
1757 #  endif
1758 #  ifdef MYMALLOC
1759                              " MYMALLOC"
1760 #  endif
1761 #  ifdef PERL_DONT_CREATE_GVSV
1762                              " PERL_DONT_CREATE_GVSV"
1763 #  endif
1764 #  ifdef PERL_GLOBAL_STRUCT
1765                              " PERL_GLOBAL_STRUCT"
1766 #  endif
1767 #  ifdef PERL_IMPLICIT_CONTEXT
1768                              " PERL_IMPLICIT_CONTEXT"
1769 #  endif
1770 #  ifdef PERL_IMPLICIT_SYS
1771                              " PERL_IMPLICIT_SYS"
1772 #  endif
1773 #  ifdef PERL_MALLOC_WRAP
1774                              " PERL_MALLOC_WRAP"
1775 #  endif
1776 #  ifdef PERL_NEED_APPCTX
1777                              " PERL_NEED_APPCTX"
1778 #  endif
1779 #  ifdef PERL_NEED_TIMESBASE
1780                              " PERL_NEED_TIMESBASE"
1781 #  endif
1782 #  ifdef PERL_OLD_COPY_ON_WRITE
1783                              " PERL_OLD_COPY_ON_WRITE"
1784 #  endif
1785 #  ifdef PERL_USE_SAFE_PUTENV
1786                              " PERL_USE_SAFE_PUTENV"
1787 #  endif
1788 #ifdef PERL_USES_PL_PIDSTATUS
1789                              " PERL_USES_PL_PIDSTATUS"
1790 #endif
1791 #  ifdef PL_OP_SLAB_ALLOC
1792                              " PL_OP_SLAB_ALLOC"
1793 #  endif
1794 #  ifdef SPRINTF_RETURNS_STRLEN
1795                              " SPRINTF_RETURNS_STRLEN"
1796 #  endif
1797 #  ifdef THREADS_HAVE_PIDS
1798                              " THREADS_HAVE_PIDS"
1799 #  endif
1800 #  ifdef USE_5005THREADS
1801                              " USE_5005THREADS"
1802 #  endif
1803 #  ifdef USE_64_BIT_ALL
1804                              " USE_64_BIT_ALL"
1805 #  endif
1806 #  ifdef USE_64_BIT_INT
1807                              " USE_64_BIT_INT"
1808 #  endif
1809 #  ifdef USE_ITHREADS
1810                              " USE_ITHREADS"
1811 #  endif
1812 #  ifdef USE_LARGE_FILES
1813                              " USE_LARGE_FILES"
1814 #  endif
1815 #  ifdef USE_LONG_DOUBLE
1816                              " USE_LONG_DOUBLE"
1817 #  endif
1818 #  ifdef USE_PERLIO
1819                              " USE_PERLIO"
1820 #  endif
1821 #  ifdef USE_REENTRANT_API
1822                              " USE_REENTRANT_API"
1823 #  endif
1824 #  ifdef USE_SFIO
1825                              " USE_SFIO"
1826 #  endif
1827 #  ifdef USE_SITECUSTOMIZE
1828                              " USE_SITECUSTOMIZE"
1829 #  endif
1830 #  ifdef USE_SOCKS
1831                              " USE_SOCKS"
1832 #  endif
1833                              );
1834
1835                     while (SvCUR(opts_prog) > opts+76) {
1836                         /* find last space after "options: " and before col 76
1837                          */
1838
1839                         const char *space;
1840                         char * const pv = SvPV_nolen(opts_prog);
1841                         const char c = pv[opts+76];
1842                         pv[opts+76] = '\0';
1843                         space = strrchr(pv+opts+26, ' ');
1844                         pv[opts+76] = c;
1845                         if (!space) break; /* "Can't happen" */
1846
1847                         /* break the line before that space */
1848
1849                         opts = space - pv;
1850                         sv_insert(opts_prog, opts, 0,
1851                                   "\\n                       ", 25);
1852                     }
1853
1854                     sv_catpv(opts_prog,"\\n\",");
1855
1856 #if defined(LOCAL_PATCH_COUNT)
1857                     if (LOCAL_PATCH_COUNT > 0) {
1858                         int i;
1859                         sv_catpv(opts_prog,
1860                                  "\"  Locally applied patches:\\n\",");
1861                         for (i = 1; i <= LOCAL_PATCH_COUNT; i++) {
1862                             if (PL_localpatches[i])
1863                                 Perl_sv_catpvf(aTHX_ opts_prog,"q%c\t%s\n%c,",
1864                                                0, PL_localpatches[i], 0);
1865                         }
1866                     }
1867 #endif
1868                     Perl_sv_catpvf(aTHX_ opts_prog,
1869                                    "\"  Built under %s\\n\"",OSNAME);
1870 #ifdef __DATE__
1871 #  ifdef __TIME__
1872                     Perl_sv_catpvf(aTHX_ opts_prog,
1873                                    ",\"  Compiled at %s %s\\n\"",__DATE__,
1874                                    __TIME__);
1875 #  else
1876                     Perl_sv_catpvf(aTHX_ opts_prog,",\"  Compiled on %s\\n\"",
1877                                    __DATE__);
1878 #  endif
1879 #endif
1880                     sv_catpv(opts_prog, "; $\"=\"\\n    \"; "
1881                              "@env = map { \"$_=\\\"$ENV{$_}\\\"\" } "
1882                              "sort grep {/^PERL/} keys %ENV; ");
1883 #ifdef __CYGWIN__
1884                     sv_catpv(opts_prog,
1885                              "push @env, \"CYGWIN=\\\"$ENV{CYGWIN}\\\"\";");
1886 #endif
1887                     sv_catpv(opts_prog,
1888                              "print \"  \\%ENV:\\n    @env\\n\" if @env;"
1889                              "print \"  \\@INC:\\n    @INC\\n\";");
1890                 }
1891                 else {
1892                     ++s;
1893                     opts_prog = Perl_newSVpvf(aTHX_
1894                                               "Config::config_vars(qw%c%s%c)",
1895                                               0, s, 0);
1896                     s += strlen(s);
1897                 }
1898                 av_push(PL_preambleav, opts_prog);
1899                 /* don't look for script or read stdin */
1900                 scriptname = BIT_BUCKET;
1901                 goto reswitch;
1902             }
1903         case 'x':
1904             PL_doextract = TRUE;
1905             s++;
1906             if (*s)
1907                 cddir = s;
1908             break;
1909         case 0:
1910             break;
1911         case '-':
1912             if (!*++s || isSPACE(*s)) {
1913                 argc--,argv++;
1914                 goto switch_end;
1915             }
1916             /* catch use of gnu style long options */
1917             if (strEQ(s, "version")) {
1918                 s = (char *)"v";
1919                 goto reswitch;
1920             }
1921             if (strEQ(s, "help")) {
1922                 s = (char *)"h";
1923                 goto reswitch;
1924             }
1925             s--;
1926             /* FALL THROUGH */
1927         default:
1928             Perl_croak(aTHX_ "Unrecognized switch: -%s  (-h will show valid options)",s);
1929         }
1930     }
1931   switch_end:
1932
1933     if (
1934 #ifndef SECURE_INTERNAL_GETENV
1935         !PL_tainting &&
1936 #endif
1937         (s = PerlEnv_getenv("PERL5OPT")))
1938     {
1939         const char *popt = s;
1940         while (isSPACE(*s))
1941             s++;
1942         if (*s == '-' && *(s+1) == 'T') {
1943             CHECK_MALLOC_TOO_LATE_FOR('T');
1944             PL_tainting = TRUE;
1945             PL_taint_warn = FALSE;
1946         }
1947         else {
1948             char *popt_copy = Nullch;
1949             while (s && *s) {
1950                 char *d;
1951                 while (isSPACE(*s))
1952                     s++;
1953                 if (*s == '-') {
1954                     s++;
1955                     if (isSPACE(*s))
1956                         continue;
1957                 }
1958                 d = s;
1959                 if (!*s)
1960                     break;
1961                 if (!strchr("CDIMUdmtwA", *s))
1962                     Perl_croak(aTHX_ "Illegal switch in PERL5OPT: -%c", *s);
1963                 while (++s && *s) {
1964                     if (isSPACE(*s)) {
1965                         if (!popt_copy) {
1966                             popt_copy = SvPVX(sv_2mortal(newSVpv(popt,0)));
1967                             s = popt_copy + (s - popt);
1968                             d = popt_copy + (d - popt);
1969                         }
1970                         *s++ = '\0';
1971                         break;
1972                     }
1973                 }
1974                 if (*d == 't') {
1975                     if( !PL_tainting ) {
1976                         PL_taint_warn = TRUE;
1977                         PL_tainting = TRUE;
1978                     }
1979                 } else {
1980                     moreswitches(d);
1981                 }
1982             }
1983         }
1984     }
1985
1986 #ifdef USE_SITECUSTOMIZE
1987     if (!minus_f) {
1988         if (!PL_preambleav)
1989             PL_preambleav = newAV();
1990         av_unshift(PL_preambleav, 1);
1991         (void)av_store(PL_preambleav, 0, Perl_newSVpvf(aTHX_ "BEGIN { do '%s/sitecustomize.pl' }", SITELIB_EXP));
1992     }
1993 #endif
1994
1995     if (PL_taint_warn && PL_dowarn != G_WARN_ALL_OFF) {
1996        PL_compiling.cop_warnings = newSVpvn(WARN_TAINTstring, WARNsize);
1997     }
1998
1999     if (!scriptname)
2000         scriptname = argv[0];
2001     if (PL_e_script) {
2002         argc++,argv--;
2003         scriptname = BIT_BUCKET;        /* don't look for script or read stdin */
2004     }
2005     else if (scriptname == Nullch) {
2006 #ifdef MSDOS
2007         if ( PerlLIO_isatty(PerlIO_fileno(PerlIO_stdin())) )
2008             moreswitches("h");
2009 #endif
2010         scriptname = "-";
2011     }
2012
2013     /* Set $^X early so that it can be used for relocatable paths in @INC  */
2014     assert (!PL_tainted);
2015     TAINT;
2016     S_set_caret_X(aTHX);
2017     TAINT_NOT;
2018     init_perllib();
2019
2020     open_script(scriptname,dosearch,sv);
2021
2022     validate_suid(validarg, scriptname);
2023
2024 #ifndef PERL_MICRO
2025 #if defined(SIGCHLD) || defined(SIGCLD)
2026     {
2027 #ifndef SIGCHLD
2028 #  define SIGCHLD SIGCLD
2029 #endif
2030         Sighandler_t sigstate = rsignal_state(SIGCHLD);
2031         if (sigstate == (Sighandler_t) SIG_IGN) {
2032             if (ckWARN(WARN_SIGNAL))
2033                 Perl_warner(aTHX_ packWARN(WARN_SIGNAL),
2034                             "Can't ignore signal CHLD, forcing to default");
2035             (void)rsignal(SIGCHLD, (Sighandler_t)SIG_DFL);
2036         }
2037     }
2038 #endif
2039 #endif
2040
2041 #ifdef MACOS_TRADITIONAL
2042     if (PL_doextract || gMacPerl_AlwaysExtract) {
2043 #else
2044     if (PL_doextract) {
2045 #endif
2046         find_beginning();
2047         if (cddir && PerlDir_chdir( (char *)cddir ) < 0)
2048             Perl_croak(aTHX_ "Can't chdir to %s",cddir);
2049
2050     }
2051
2052     PL_main_cv = PL_compcv = (CV*)NEWSV(1104,0);
2053     sv_upgrade((SV *)PL_compcv, SVt_PVCV);
2054     CvUNIQUE_on(PL_compcv);
2055
2056     CvPADLIST(PL_compcv) = pad_new(0);
2057 #ifdef USE_5005THREADS
2058     CvOWNER(PL_compcv) = 0;
2059     Newx(CvMUTEXP(PL_compcv), 1, perl_mutex);
2060     MUTEX_INIT(CvMUTEXP(PL_compcv));
2061 #endif /* USE_5005THREADS */
2062
2063     boot_core_PerlIO();
2064     boot_core_UNIVERSAL();
2065     boot_core_xsutils();
2066
2067     if (xsinit)
2068         (*xsinit)(aTHX);        /* in case linked C routines want magical variables */
2069 #ifndef PERL_MICRO
2070 #if defined(VMS) || defined(WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(EPOC) || defined(SYMBIAN)
2071     init_os_extras();
2072 #endif
2073 #endif
2074
2075 #ifdef USE_SOCKS
2076 #   ifdef HAS_SOCKS5_INIT
2077     socks5_init(argv[0]);
2078 #   else
2079     SOCKSinit(argv[0]);
2080 #   endif
2081 #endif
2082
2083     init_predump_symbols();
2084     /* init_postdump_symbols not currently designed to be called */
2085     /* more than once (ENV isn't cleared first, for example)     */
2086     /* But running with -u leaves %ENV & @ARGV undefined!    XXX */
2087     if (!PL_do_undump)
2088         init_postdump_symbols(argc,argv,env);
2089
2090     /* PL_unicode is turned on by -C, or by $ENV{PERL_UNICODE},
2091      * or explicitly in some platforms.
2092      * locale.c:Perl_init_i18nl10n() if the environment
2093      * look like the user wants to use UTF-8. */
2094 #if defined(__SYMBIAN32__)
2095     PL_unicode = PERL_UNICODE_STD_FLAG; /* See PERL_SYMBIAN_CONSOLE_UTF8. */
2096 #endif
2097     if (PL_unicode) {
2098          /* Requires init_predump_symbols(). */
2099          if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
2100               IO* io;
2101               PerlIO* fp;
2102               SV* sv;
2103
2104               /* Turn on UTF-8-ness on STDIN, STDOUT, STDERR
2105                * and the default open disciplines. */
2106               if ((PL_unicode & PERL_UNICODE_STDIN_FLAG) &&
2107                   PL_stdingv  && (io = GvIO(PL_stdingv)) &&
2108                   (fp = IoIFP(io)))
2109                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2110               if ((PL_unicode & PERL_UNICODE_STDOUT_FLAG) &&
2111                   PL_defoutgv && (io = GvIO(PL_defoutgv)) &&
2112                   (fp = IoOFP(io)))
2113                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2114               if ((PL_unicode & PERL_UNICODE_STDERR_FLAG) &&
2115                   PL_stderrgv && (io = GvIO(PL_stderrgv)) &&
2116                   (fp = IoOFP(io)))
2117                    PerlIO_binmode(aTHX_ fp, IoTYPE(io), 0, ":utf8");
2118               if ((PL_unicode & PERL_UNICODE_INOUT_FLAG) &&
2119                   (sv = GvSV(gv_fetchpv("\017PEN", TRUE, SVt_PV)))) {
2120                    U32 in  = PL_unicode & PERL_UNICODE_IN_FLAG;
2121                    U32 out = PL_unicode & PERL_UNICODE_OUT_FLAG;
2122                    if (in) {
2123                         if (out)
2124                              sv_setpvn(sv, ":utf8\0:utf8", 11);
2125                         else
2126                              sv_setpvn(sv, ":utf8\0", 6);
2127                    }
2128                    else if (out)
2129                         sv_setpvn(sv, "\0:utf8", 6);
2130                    SvSETMAGIC(sv);
2131               }
2132          }
2133     }
2134
2135     if ((s = PerlEnv_getenv("PERL_SIGNALS"))) {
2136          if (strEQ(s, "unsafe"))
2137               PL_signals |=  PERL_SIGNALS_UNSAFE_FLAG;
2138          else if (strEQ(s, "safe"))
2139               PL_signals &= ~PERL_SIGNALS_UNSAFE_FLAG;
2140          else
2141               Perl_croak(aTHX_ "PERL_SIGNALS illegal: \"%s\"", s);
2142     }
2143
2144     init_lexer();
2145
2146     /* now parse the script */
2147
2148     SETERRNO(0,SS_NORMAL);
2149     PL_error_count = 0;
2150 #ifdef MACOS_TRADITIONAL
2151     if (gMacPerl_SyntaxError = (yyparse() || PL_error_count)) {
2152         if (PL_minus_c)
2153             Perl_croak(aTHX_ "%s had compilation errors.\n", MacPerl_MPWFileName(PL_origfilename));
2154         else {
2155             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
2156                        MacPerl_MPWFileName(PL_origfilename));
2157         }
2158     }
2159 #else
2160     if (yyparse() || PL_error_count) {
2161         if (PL_minus_c)
2162             Perl_croak(aTHX_ "%s had compilation errors.\n", PL_origfilename);
2163         else {
2164             Perl_croak(aTHX_ "Execution of %s aborted due to compilation errors.\n",
2165                        PL_origfilename);
2166         }
2167     }
2168 #endif
2169     CopLINE_set(PL_curcop, 0);
2170     PL_curstash = PL_defstash;
2171     PL_preprocess = FALSE;
2172     if (PL_e_script) {
2173         SvREFCNT_dec(PL_e_script);
2174         PL_e_script = Nullsv;
2175     }
2176
2177     if (PL_do_undump)
2178         my_unexec();
2179
2180     if (isWARN_ONCE) {
2181         SAVECOPFILE(PL_curcop);
2182         SAVECOPLINE(PL_curcop);
2183         gv_check(PL_defstash);
2184     }
2185
2186     LEAVE;
2187     FREETMPS;
2188
2189 #ifdef MYMALLOC
2190     if ((s=PerlEnv_getenv("PERL_DEBUG_MSTATS")) && atoi(s) >= 2)
2191         dump_mstats("after compilation:");
2192 #endif
2193
2194     ENTER;
2195     PL_restartop = 0;
2196     return NULL;
2197 }
2198
2199 /*
2200 =for apidoc perl_run
2201
2202 Tells a Perl interpreter to run.  See L<perlembed>.
2203
2204 =cut
2205 */
2206
2207 int
2208 perl_run(pTHXx)
2209 {
2210     I32 oldscope;
2211     int ret = 0;
2212     dJMPENV;
2213
2214     PERL_UNUSED_ARG(my_perl);
2215
2216     oldscope = PL_scopestack_ix;
2217 #ifdef VMS
2218     VMSISH_HUSHED = 0;
2219 #endif
2220
2221     JMPENV_PUSH(ret);
2222     switch (ret) {
2223     case 1:
2224         cxstack_ix = -1;                /* start context stack again */
2225         goto redo_body;
2226     case 0:                             /* normal completion */
2227  redo_body:
2228         run_body(oldscope);
2229         /* FALL THROUGH */
2230     case 2:                             /* my_exit() */
2231         while (PL_scopestack_ix > oldscope)
2232             LEAVE;
2233         FREETMPS;
2234         PL_curstash = PL_defstash;
2235         if (!(PL_exit_flags & PERL_EXIT_DESTRUCT_END) &&
2236             PL_endav && !PL_minus_c)
2237             call_list(oldscope, PL_endav);
2238 #ifdef MYMALLOC
2239         if (PerlEnv_getenv("PERL_DEBUG_MSTATS"))
2240             dump_mstats("after execution:  ");
2241 #endif
2242         ret = STATUS_EXIT;
2243         break;
2244     case 3:
2245         if (PL_restartop) {
2246             POPSTACK_TO(PL_mainstack);
2247             goto redo_body;
2248         }
2249         PerlIO_printf(Perl_error_log, "panic: restartop\n");
2250         FREETMPS;
2251         ret = 1;
2252         break;
2253     }
2254
2255     JMPENV_POP;
2256     return ret;
2257 }
2258
2259
2260 STATIC void
2261 S_run_body(pTHX_ I32 oldscope)
2262 {
2263     DEBUG_r(PerlIO_printf(Perl_debug_log, "%s $` $& $' support.\n",
2264                     PL_sawampersand ? "Enabling" : "Omitting"));
2265
2266     if (!PL_restartop) {
2267         DEBUG_x(dump_all());
2268 #ifdef DEBUGGING
2269         if (!DEBUG_q_TEST)
2270           PERL_DEBUG(PerlIO_printf(Perl_debug_log, "\nEXECUTING...\n\n"));
2271 #endif
2272         DEBUG_S(PerlIO_printf(Perl_debug_log, "main thread is 0x%"UVxf"\n",
2273                               PTR2UV(thr)));
2274
2275         if (PL_minus_c) {
2276 #ifdef MACOS_TRADITIONAL
2277             PerlIO_printf(Perl_error_log, "%s%s syntax OK\n",
2278                 (gMacPerl_ErrorFormat ? "# " : ""),
2279                 MacPerl_MPWFileName(PL_origfilename));
2280 #else
2281             PerlIO_printf(Perl_error_log, "%s syntax OK\n", PL_origfilename);
2282 #endif
2283             my_exit(0);
2284         }
2285         if (PERLDB_SINGLE && PL_DBsingle)
2286             sv_setiv(PL_DBsingle, 1);
2287         if (PL_initav)
2288             call_list(oldscope, PL_initav);
2289     }
2290
2291     /* do it */
2292
2293     if (PL_restartop) {
2294         PL_op = PL_restartop;
2295         PL_restartop = 0;
2296         CALLRUNOPS(aTHX);
2297     }
2298     else if (PL_main_start) {
2299         CvDEPTH(PL_main_cv) = 1;
2300         PL_op = PL_main_start;
2301         CALLRUNOPS(aTHX);
2302     }
2303     my_exit(0);
2304     /* NOTREACHED */
2305 }
2306
2307 /*
2308 =head1 SV Manipulation Functions
2309
2310 =for apidoc p||get_sv
2311
2312 Returns the SV of the specified Perl scalar.  If C<create> is set and the
2313 Perl variable does not exist then it will be created.  If C<create> is not
2314 set and the variable does not exist then NULL is returned.
2315
2316 =cut
2317 */
2318
2319 SV*
2320 Perl_get_sv(pTHX_ const char *name, I32 create)
2321 {
2322     GV *gv;
2323 #ifdef USE_5005THREADS
2324     if (name[1] == '\0' && !isALPHA(name[0])) {
2325         PADOFFSET tmp = find_threadsv(name);
2326         if (tmp != NOT_IN_PAD)
2327             return THREADSV(tmp);
2328     }
2329 #endif /* USE_5005THREADS */
2330     gv = gv_fetchpv(name, create, SVt_PV);
2331     if (gv)
2332         return GvSV(gv);
2333     return Nullsv;
2334 }
2335
2336 /*
2337 =head1 Array Manipulation Functions
2338
2339 =for apidoc p||get_av
2340
2341 Returns the AV of the specified Perl array.  If C<create> is set and the
2342 Perl variable does not exist then it will be created.  If C<create> is not
2343 set and the variable does not exist then NULL is returned.
2344
2345 =cut
2346 */
2347
2348 AV*
2349 Perl_get_av(pTHX_ const char *name, I32 create)
2350 {
2351     GV* const gv = gv_fetchpv(name, create, SVt_PVAV);
2352     if (create)
2353         return GvAVn(gv);
2354     if (gv)
2355         return GvAV(gv);
2356     return Nullav;
2357 }
2358
2359 /*
2360 =head1 Hash Manipulation Functions
2361
2362 =for apidoc p||get_hv
2363
2364 Returns the HV of the specified Perl hash.  If C<create> is set and the
2365 Perl variable does not exist then it will be created.  If C<create> is not
2366 set and the variable does not exist then NULL is returned.
2367
2368 =cut
2369 */
2370
2371 HV*
2372 Perl_get_hv(pTHX_ const char *name, I32 create)
2373 {
2374     GV* const gv = gv_fetchpv(name, create, SVt_PVHV);
2375     if (create)
2376         return GvHVn(gv);
2377     if (gv)
2378         return GvHV(gv);
2379     return Nullhv;
2380 }
2381
2382 /*
2383 =head1 CV Manipulation Functions
2384
2385 =for apidoc p||get_cv
2386
2387 Returns the CV of the specified Perl subroutine.  If C<create> is set and
2388 the Perl subroutine does not exist then it will be declared (which has the
2389 same effect as saying C<sub name;>).  If C<create> is not set and the
2390 subroutine does not exist then NULL is returned.
2391
2392 =cut
2393 */
2394
2395 CV*
2396 Perl_get_cv(pTHX_ const char *name, I32 create)
2397 {
2398     GV* const gv = gv_fetchpv(name, create, SVt_PVCV);
2399     /* XXX unsafe for threads if eval_owner isn't held */
2400     /* XXX this is probably not what they think they're getting.
2401      * It has the same effect as "sub name;", i.e. just a forward
2402      * declaration! */
2403     if (create && !GvCVu(gv))
2404         return newSUB(start_subparse(FALSE, 0),
2405                       newSVOP(OP_CONST, 0, newSVpv(name,0)),
2406                       Nullop,
2407                       Nullop);
2408     if (gv)
2409         return GvCVu(gv);
2410     return Nullcv;
2411 }
2412
2413 /* Be sure to refetch the stack pointer after calling these routines. */
2414
2415 /*
2416
2417 =head1 Callback Functions
2418
2419 =for apidoc p||call_argv
2420
2421 Performs a callback to the specified Perl sub.  See L<perlcall>.
2422
2423 =cut
2424 */
2425
2426 I32
2427 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, register char **argv)
2428
2429                         /* See G_* flags in cop.h */
2430                         /* null terminated arg list */
2431 {
2432     dSP;
2433
2434     PUSHMARK(SP);
2435     if (argv) {
2436         while (*argv) {
2437             XPUSHs(sv_2mortal(newSVpv(*argv,0)));
2438             argv++;
2439         }
2440         PUTBACK;
2441     }
2442     return call_pv(sub_name, flags);
2443 }
2444
2445 /*
2446 =for apidoc p||call_pv
2447
2448 Performs a callback to the specified Perl sub.  See L<perlcall>.
2449
2450 =cut
2451 */
2452
2453 I32
2454 Perl_call_pv(pTHX_ const char *sub_name, I32 flags)
2455                         /* name of the subroutine */
2456                         /* See G_* flags in cop.h */
2457 {
2458     return call_sv((SV*)get_cv(sub_name, TRUE), flags);
2459 }
2460
2461 /*
2462 =for apidoc p||call_method
2463
2464 Performs a callback to the specified Perl method.  The blessed object must
2465 be on the stack.  See L<perlcall>.
2466
2467 =cut
2468 */
2469
2470 I32
2471 Perl_call_method(pTHX_ const char *methname, I32 flags)
2472                         /* name of the subroutine */
2473                         /* See G_* flags in cop.h */
2474 {
2475     return call_sv(sv_2mortal(newSVpv(methname,0)), flags | G_METHOD);
2476 }
2477
2478 /* May be called with any of a CV, a GV, or an SV containing the name. */
2479 /*
2480 =for apidoc p||call_sv
2481
2482 Performs a callback to the Perl sub whose name is in the SV.  See
2483 L<perlcall>.
2484
2485 =cut
2486 */
2487
2488 I32
2489 Perl_call_sv(pTHX_ SV *sv, I32 flags)
2490                         /* See G_* flags in cop.h */
2491 {
2492     dVAR; dSP;
2493     LOGOP myop;         /* fake syntax tree node */
2494     UNOP method_op;
2495     I32 oldmark;
2496     volatile I32 retval = 0;
2497     I32 oldscope;
2498     bool oldcatch = CATCH_GET;
2499     int ret;
2500     OP* const oldop = PL_op;
2501     dJMPENV;
2502
2503     if (flags & G_DISCARD) {
2504         ENTER;
2505         SAVETMPS;
2506     }
2507
2508     Zero(&myop, 1, LOGOP);
2509     myop.op_next = Nullop;
2510     if (!(flags & G_NOARGS))
2511         myop.op_flags |= OPf_STACKED;
2512     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2513                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2514                       OPf_WANT_SCALAR);
2515     SAVEOP();
2516     PL_op = (OP*)&myop;
2517
2518     EXTEND(PL_stack_sp, 1);
2519     *++PL_stack_sp = sv;
2520     oldmark = TOPMARK;
2521     oldscope = PL_scopestack_ix;
2522
2523     if (PERLDB_SUB && PL_curstash != PL_debstash
2524            /* Handle first BEGIN of -d. */
2525           && (PL_DBcv || (PL_DBcv = GvCV(PL_DBsub)))
2526            /* Try harder, since this may have been a sighandler, thus
2527             * curstash may be meaningless. */
2528           && (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
2529           && !(flags & G_NODEBUG))
2530         PL_op->op_private |= OPpENTERSUB_DB;
2531
2532     if (flags & G_METHOD) {
2533         Zero(&method_op, 1, UNOP);
2534         method_op.op_next = PL_op;
2535         method_op.op_ppaddr = PL_ppaddr[OP_METHOD];
2536         myop.op_ppaddr = PL_ppaddr[OP_ENTERSUB];
2537         PL_op = (OP*)&method_op;
2538     }
2539
2540     if (!(flags & G_EVAL)) {
2541         CATCH_SET(TRUE);
2542         call_body((OP*)&myop, FALSE);
2543         retval = PL_stack_sp - (PL_stack_base + oldmark);
2544         CATCH_SET(oldcatch);
2545     }
2546     else {
2547         myop.op_other = (OP*)&myop;
2548         PL_markstack_ptr--;
2549         /* we're trying to emulate pp_entertry() here */
2550         {
2551             register PERL_CONTEXT *cx;
2552             const I32 gimme = GIMME_V;
2553
2554             ENTER;
2555             SAVETMPS;
2556
2557             PUSHBLOCK(cx, (CXt_EVAL|CXp_TRYBLOCK), PL_stack_sp);
2558             PUSHEVAL(cx, 0, 0);
2559             PL_eval_root = PL_op;             /* Only needed so that goto works right. */
2560
2561             PL_in_eval = EVAL_INEVAL;
2562             if (flags & G_KEEPERR)
2563                 PL_in_eval |= EVAL_KEEPERR;
2564             else
2565                 sv_setpvn(ERRSV,"",0);
2566         }
2567         PL_markstack_ptr++;
2568
2569         JMPENV_PUSH(ret);
2570         switch (ret) {
2571         case 0:
2572  redo_body:
2573             call_body((OP*)&myop, FALSE);
2574             retval = PL_stack_sp - (PL_stack_base + oldmark);
2575             if (!(flags & G_KEEPERR))
2576                 sv_setpvn(ERRSV,"",0);
2577             break;
2578         case 1:
2579             STATUS_ALL_FAILURE;
2580             /* FALL THROUGH */
2581         case 2:
2582             /* my_exit() was called */
2583             PL_curstash = PL_defstash;
2584             FREETMPS;
2585             JMPENV_POP;
2586             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2587                 Perl_croak(aTHX_ "Callback called exit");
2588             my_exit_jump();
2589             /* NOTREACHED */
2590         case 3:
2591             if (PL_restartop) {
2592                 PL_op = PL_restartop;
2593                 PL_restartop = 0;
2594                 goto redo_body;
2595             }
2596             PL_stack_sp = PL_stack_base + oldmark;
2597             if (flags & G_ARRAY)
2598                 retval = 0;
2599             else {
2600                 retval = 1;
2601                 *++PL_stack_sp = &PL_sv_undef;
2602             }
2603             break;
2604         }
2605
2606         if (PL_scopestack_ix > oldscope) {
2607             SV **newsp;
2608             PMOP *newpm;
2609             I32 gimme;
2610             register PERL_CONTEXT *cx;
2611             I32 optype;
2612
2613             POPBLOCK(cx,newpm);
2614             POPEVAL(cx);
2615             PL_curpm = newpm;
2616             LEAVE;
2617             PERL_UNUSED_VAR(newsp);
2618             PERL_UNUSED_VAR(gimme);
2619             PERL_UNUSED_VAR(optype);
2620         }
2621         JMPENV_POP;
2622     }
2623
2624     if (flags & G_DISCARD) {
2625         PL_stack_sp = PL_stack_base + oldmark;
2626         retval = 0;
2627         FREETMPS;
2628         LEAVE;
2629     }
2630     PL_op = oldop;
2631     return retval;
2632 }
2633
2634 STATIC void
2635 S_call_body(pTHX_ const OP *myop, bool is_eval)
2636 {
2637     if (PL_op == myop) {
2638         if (is_eval)
2639             PL_op = Perl_pp_entereval(aTHX);    /* this doesn't do a POPMARK */
2640         else
2641             PL_op = Perl_pp_entersub(aTHX);     /* this does */
2642     }
2643     if (PL_op)
2644         CALLRUNOPS(aTHX);
2645 }
2646
2647 /* Eval a string. The G_EVAL flag is always assumed. */
2648
2649 /*
2650 =for apidoc p||eval_sv
2651
2652 Tells Perl to C<eval> the string in the SV.
2653
2654 =cut
2655 */
2656
2657 I32
2658 Perl_eval_sv(pTHX_ SV *sv, I32 flags)
2659
2660                         /* See G_* flags in cop.h */
2661 {
2662     dSP;
2663     UNOP myop;          /* fake syntax tree node */
2664     volatile I32 oldmark = SP - PL_stack_base;
2665     volatile I32 retval = 0;
2666     int ret;
2667     OP* const oldop = PL_op;
2668     dJMPENV;
2669
2670     if (flags & G_DISCARD) {
2671         ENTER;
2672         SAVETMPS;
2673     }
2674
2675     SAVEOP();
2676     PL_op = (OP*)&myop;
2677     Zero(PL_op, 1, UNOP);
2678     EXTEND(PL_stack_sp, 1);
2679     *++PL_stack_sp = sv;
2680
2681     if (!(flags & G_NOARGS))
2682         myop.op_flags = OPf_STACKED;
2683     myop.op_next = Nullop;
2684     myop.op_type = OP_ENTEREVAL;
2685     myop.op_flags |= ((flags & G_VOID) ? OPf_WANT_VOID :
2686                       (flags & G_ARRAY) ? OPf_WANT_LIST :
2687                       OPf_WANT_SCALAR);
2688     if (flags & G_KEEPERR)
2689         myop.op_flags |= OPf_SPECIAL;
2690
2691     /* fail now; otherwise we could fail after the JMPENV_PUSH but
2692      * before a PUSHEVAL, which corrupts the stack after a croak */
2693     TAINT_PROPER("eval_sv()");
2694
2695     JMPENV_PUSH(ret);
2696     switch (ret) {
2697     case 0:
2698  redo_body:
2699         call_body((OP*)&myop,TRUE);
2700         retval = PL_stack_sp - (PL_stack_base + oldmark);
2701         if (!(flags & G_KEEPERR))
2702             sv_setpvn(ERRSV,"",0);
2703         break;
2704     case 1:
2705         STATUS_ALL_FAILURE;
2706         /* FALL THROUGH */
2707     case 2:
2708         /* my_exit() was called */
2709         PL_curstash = PL_defstash;
2710         FREETMPS;
2711         JMPENV_POP;
2712         if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED))
2713             Perl_croak(aTHX_ "Callback called exit");
2714         my_exit_jump();
2715         /* NOTREACHED */
2716     case 3:
2717         if (PL_restartop) {
2718             PL_op = PL_restartop;
2719             PL_restartop = 0;
2720             goto redo_body;
2721         }
2722         PL_stack_sp = PL_stack_base + oldmark;
2723         if (flags & G_ARRAY)
2724             retval = 0;
2725         else {
2726             retval = 1;
2727             *++PL_stack_sp = &PL_sv_undef;
2728         }
2729         break;
2730     }
2731
2732     JMPENV_POP;
2733     if (flags & G_DISCARD) {
2734         PL_stack_sp = PL_stack_base + oldmark;
2735         retval = 0;
2736         FREETMPS;
2737         LEAVE;
2738     }
2739     PL_op = oldop;
2740     return retval;
2741 }
2742
2743 /*
2744 =for apidoc p||eval_pv
2745
2746 Tells Perl to C<eval> the given string and return an SV* result.
2747
2748 =cut
2749 */
2750
2751 SV*
2752 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error)
2753 {
2754     dSP;
2755     SV* sv = newSVpv(p, 0);
2756
2757     eval_sv(sv, G_SCALAR);
2758     SvREFCNT_dec(sv);
2759
2760     SPAGAIN;
2761     sv = POPs;
2762     PUTBACK;
2763
2764     if (croak_on_error && SvTRUE(ERRSV)) {
2765         Perl_croak(aTHX_ SvPVx_nolen_const(ERRSV));
2766     }
2767
2768     return sv;
2769 }
2770
2771 /* Require a module. */
2772
2773 /*
2774 =head1 Embedding Functions
2775
2776 =for apidoc p||require_pv
2777
2778 Tells Perl to C<require> the file named by the string argument.  It is
2779 analogous to the Perl code C<eval "require '$file'">.  It's even
2780 implemented that way; consider using load_module instead.
2781
2782 =cut */
2783
2784 void
2785 Perl_require_pv(pTHX_ const char *pv)
2786 {
2787     SV* sv;
2788     dSP;
2789     PUSHSTACKi(PERLSI_REQUIRE);
2790     PUTBACK;
2791     sv = Perl_newSVpvf(aTHX_ "require q%c%s%c", 0, pv, 0);
2792     eval_sv(sv_2mortal(sv), G_DISCARD);
2793     SPAGAIN;
2794     POPSTACK;
2795 }
2796
2797 void
2798 Perl_magicname(pTHX_ const char *sym, const char *name, I32 namlen)
2799 {
2800     register GV * const gv = gv_fetchpv(sym,TRUE, SVt_PV);
2801
2802     if (gv)
2803         sv_magic(GvSV(gv), (SV*)gv, PERL_MAGIC_sv, name, namlen);
2804 }
2805
2806 STATIC void
2807 S_usage(pTHX_ const char *name)         /* XXX move this out into a module ? */
2808 {
2809     /* This message really ought to be max 23 lines.
2810      * Removed -h because the user already knows that option. Others? */
2811
2812     static const char * const usage_msg[] = {
2813 "-0[octal]         specify record separator (\\0, if no argument)",
2814 "-A[mod][=pattern] activate all/given assertions",
2815 "-a                autosplit mode with -n or -p (splits $_ into @F)",
2816 "-C[number/list]   enables the listed Unicode features",
2817 "-c                check syntax only (runs BEGIN and CHECK blocks)",
2818 "-d[:debugger]     run program under debugger",
2819 "-D[number/list]   set debugging flags (argument is a bit mask or alphabets)",
2820 "-e program        one line of program (several -e's allowed, omit programfile)",
2821 "-f                don't do $sitelib/sitecustomize.pl at startup",
2822 "-F/pattern/       split() pattern for -a switch (//'s are optional)",
2823 "-i[extension]     edit <> files in place (makes backup if extension supplied)",
2824 "-Idirectory       specify @INC/#include directory (several -I's allowed)",
2825 "-l[octal]         enable line ending processing, specifies line terminator",
2826 "-[mM][-]module    execute \"use/no module...\" before executing program",
2827 "-n                assume \"while (<>) { ... }\" loop around program",
2828 "-p                assume loop like -n but print line also, like sed",
2829 "-P                run program through C preprocessor before compilation",
2830 "-s                enable rudimentary parsing for switches after programfile",
2831 "-S                look for programfile using PATH environment variable",
2832 "-t                enable tainting warnings",
2833 "-T                enable tainting checks",
2834 "-u                dump core after parsing program",
2835 "-U                allow unsafe operations",
2836 "-v                print version, subversion (includes VERY IMPORTANT perl info)",
2837 "-V[:variable]     print configuration summary (or a single Config.pm variable)",
2838 "-w                enable many useful warnings (RECOMMENDED)",
2839 "-W                enable all warnings",
2840 "-x[directory]     strip off text before #!perl line and perhaps cd to directory",
2841 "-X                disable all warnings",
2842 "\n",
2843 NULL
2844 };
2845     const char * const *p = usage_msg;
2846
2847     PerlIO_printf(PerlIO_stdout(),
2848                   "\nUsage: %s [switches] [--] [programfile] [arguments]",
2849                   name);
2850     while (*p)
2851         PerlIO_printf(PerlIO_stdout(), "\n  %s", *p++);
2852 }
2853
2854 /* convert a string of -D options (or digits) into an int.
2855  * sets *s to point to the char after the options */
2856
2857 #ifdef DEBUGGING
2858 int
2859 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
2860 {
2861     static const char * const usage_msgd[] = {
2862       " Debugging flag values: (see also -d)",
2863       "  p  Tokenizing and parsing (with v, displays parse stack)",
2864       "  s  Stack snapshots (with v, displays all stacks)",
2865       "  l  Context (loop) stack processing",
2866       "  t  Trace execution",
2867       "  o  Method and overloading resolution",
2868       "  c  String/numeric conversions",
2869       "  P  Print profiling info, preprocessor command for -P, source file input state",
2870       "  m  Memory allocation",
2871       "  f  Format processing",
2872       "  r  Regular expression parsing and execution",
2873       "  x  Syntax tree dump",
2874       "  u  Tainting checks",
2875       "  H  Hash dump -- usurps values()",
2876       "  X  Scratchpad allocation",
2877       "  D  Cleaning up",
2878       "  S  Thread synchronization",
2879       "  T  Tokenising",
2880       "  R  Include reference counts of dumped variables (eg when using -Ds)",
2881       "  J  Do not s,t,P-debug (Jump over) opcodes within package DB",
2882       "  v  Verbose: use in conjunction with other flags",
2883       "  C  Copy On Write",
2884       "  A  Consistency checks on internal structures",
2885       "  q  quiet - currently only suppresses the 'EXECUTING' message",
2886       NULL
2887     };
2888     int i = 0;
2889     if (isALPHA(**s)) {
2890         /* if adding extra options, remember to update DEBUG_MASK */
2891         static const char debopts[] = "psltocPmfrxu HXDSTRJvCAq";
2892
2893         for (; isALNUM(**s); (*s)++) {
2894             const char * const d = strchr(debopts,**s);
2895             if (d)
2896                 i |= 1 << (d - debopts);
2897             else if (ckWARN_d(WARN_DEBUGGING))
2898                 Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2899                     "invalid option -D%c, use -D'' to see choices\n", **s);
2900         }
2901     }
2902     else if (isDIGIT(**s)) {
2903         i = atoi(*s);
2904         for (; isALNUM(**s); (*s)++) ;
2905     }
2906     else if (givehelp) {
2907       const char *const *p = usage_msgd;
2908       while (*p) PerlIO_printf(PerlIO_stdout(), "%s\n", *p++);
2909     }
2910 #  ifdef EBCDIC
2911     if ((i & DEBUG_p_FLAG) && ckWARN_d(WARN_DEBUGGING))
2912         Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
2913                 "-Dp not implemented on this platform\n");
2914 #  endif
2915     return i;
2916 }
2917 #endif
2918
2919 /* This routine handles any switches that can be given during run */
2920
2921 char *
2922 Perl_moreswitches(pTHX_ char *s)
2923 {
2924     dVAR;
2925     UV rschar;
2926
2927     switch (*s) {
2928     case '0':
2929     {
2930          I32 flags = 0;
2931          STRLEN numlen;
2932
2933          SvREFCNT_dec(PL_rs);
2934          if (s[1] == 'x' && s[2]) {
2935               const char *e = s+=2;
2936               U8 *tmps;
2937
2938               while (*e)
2939                 e++;
2940               numlen = e - s;
2941               flags = PERL_SCAN_SILENT_ILLDIGIT;
2942               rschar = (U32)grok_hex(s, &numlen, &flags, NULL);
2943               if (s + numlen < e) {
2944                    rschar = 0; /* Grandfather -0xFOO as -0 -xFOO. */
2945                    numlen = 0;
2946                    s--;
2947               }
2948               PL_rs = newSVpvn("", 0);
2949               SvGROW(PL_rs, (STRLEN)(UNISKIP(rschar) + 1));
2950               tmps = (U8*)SvPVX(PL_rs);
2951               uvchr_to_utf8(tmps, rschar);
2952               SvCUR_set(PL_rs, UNISKIP(rschar));
2953               SvUTF8_on(PL_rs);
2954          }
2955          else {
2956               numlen = 4;
2957               rschar = (U32)grok_oct(s, &numlen, &flags, NULL);
2958               if (rschar & ~((U8)~0))
2959                    PL_rs = &PL_sv_undef;
2960               else if (!rschar && numlen >= 2)
2961                    PL_rs = newSVpvn("", 0);
2962               else {
2963                    char ch = (char)rschar;
2964                    PL_rs = newSVpvn(&ch, 1);
2965               }
2966          }
2967          sv_setsv(get_sv("/", TRUE), PL_rs);
2968          return s + numlen;
2969     }
2970     case 'C':
2971         s++;
2972         PL_unicode = parse_unicode_opts( (const char **)&s );
2973         return s;
2974     case 'F':
2975         PL_minus_F = TRUE;
2976         PL_splitstr = ++s;
2977         while (*s && !isSPACE(*s)) ++s;
2978         *s = '\0';
2979         PL_splitstr = savepv(PL_splitstr);
2980         return s;
2981     case 'a':
2982         PL_minus_a = TRUE;
2983         s++;
2984         return s;
2985     case 'c':
2986         PL_minus_c = TRUE;
2987         s++;
2988         return s;
2989     case 'd':
2990         forbid_setid("-d");
2991         s++;
2992
2993         /* -dt indicates to the debugger that threads will be used */
2994         if (*s == 't' && !isALNUM(s[1])) {
2995             ++s;
2996             my_setenv("PERL5DB_THREADED", "1");
2997         }
2998
2999         /* The following permits -d:Mod to accepts arguments following an =
3000            in the fashion that -MSome::Mod does. */
3001         if (*s == ':' || *s == '=') {
3002             const char *start;
3003             SV * const sv = newSVpv("use Devel::", 0);
3004             start = ++s;
3005             /* We now allow -d:Module=Foo,Bar */
3006             while(isALNUM(*s) || *s==':') ++s;
3007             if (*s != '=')
3008                 sv_catpv(sv, start);
3009             else {
3010                 sv_catpvn(sv, start, s-start);
3011                 Perl_sv_catpvf(aTHX_ sv, " split(/,/,q%c%s%c)", 0, ++s, 0);
3012             }
3013             s += strlen(s);
3014             my_setenv("PERL5DB", SvPV_nolen_const(sv));
3015         }
3016         if (!PL_perldb) {
3017             PL_perldb = PERLDB_ALL;
3018             init_debugger();
3019         }
3020         return s;
3021     case 'D':
3022     {
3023 #ifdef DEBUGGING
3024         forbid_setid("-D");
3025         s++;
3026         PL_debug = get_debug_opts( (const char **)&s, 1) | DEBUG_TOP_FLAG;
3027 #else /* !DEBUGGING */
3028         if (ckWARN_d(WARN_DEBUGGING))
3029             Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
3030                    "Recompile perl with -DDEBUGGING to use -D switch (did you mean -d ?)\n");
3031         for (s++; isALNUM(*s); s++) ;
3032 #endif
3033         return s;
3034     }
3035     case 'h':
3036         usage(PL_origargv[0]);
3037         my_exit(0);
3038     case 'i':
3039         Safefree(PL_inplace);
3040 #if defined(__CYGWIN__) /* do backup extension automagically */
3041         if (*(s+1) == '\0') {
3042         PL_inplace = savepv(".bak");
3043         return s+1;
3044         }
3045 #endif /* __CYGWIN__ */
3046         PL_inplace = savepv(s+1);
3047         for (s = PL_inplace; *s && !isSPACE(*s); s++)
3048             ;
3049         if (*s) {
3050             *s++ = '\0';
3051             if (*s == '-')      /* Additional switches on #! line. */
3052                 s++;
3053         }
3054         return s;
3055     case 'I':   /* -I handled both here and in parse_body() */
3056         forbid_setid("-I");
3057         ++s;
3058         while (*s && isSPACE(*s))
3059             ++s;
3060         if (*s) {
3061             char *e, *p;
3062             p = s;
3063             /* ignore trailing spaces (possibly followed by other switches) */
3064             do {
3065                 for (e = p; *e && !isSPACE(*e); e++) ;
3066                 p = e;
3067                 while (isSPACE(*p))
3068                     p++;
3069             } while (*p && *p != '-');
3070             e = savepvn(s, e-s);
3071             incpush(e, TRUE, TRUE, FALSE, FALSE);
3072             Safefree(e);
3073             s = p;
3074             if (*s == '-')
3075                 s++;
3076         }
3077         else
3078             Perl_croak(aTHX_ "No directory specified for -I");
3079         return s;
3080     case 'l':
3081         PL_minus_l = TRUE;
3082         s++;
3083         if (PL_ors_sv) {
3084             SvREFCNT_dec(PL_ors_sv);
3085             PL_ors_sv = Nullsv;
3086         }
3087         if (isDIGIT(*s)) {
3088             I32 flags = 0;
3089             STRLEN numlen;
3090             PL_ors_sv = newSVpvn("\n",1);
3091             numlen = 3 + (*s == '0');
3092             *SvPVX(PL_ors_sv) = (char)grok_oct(s, &numlen, &flags, NULL);
3093             s += numlen;
3094         }
3095         else {
3096             if (RsPARA(PL_rs)) {
3097                 PL_ors_sv = newSVpvn("\n\n",2);
3098             }
3099             else {
3100                 PL_ors_sv = newSVsv(PL_rs);
3101             }
3102         }
3103         return s;
3104     case 'A':
3105         forbid_setid("-A");
3106         if (!PL_preambleav)
3107             PL_preambleav = newAV();
3108         s++;
3109         {
3110             char * const start = s;
3111             SV * const sv = newSVpv("use assertions::activate", 24);
3112             while(isALNUM(*s) || *s == ':') ++s;
3113             if (s != start) {
3114                 sv_catpvn(sv, "::", 2);
3115                 sv_catpvn(sv, start, s-start);
3116             }
3117             if (*s == '=') {
3118                 Perl_sv_catpvf(aTHX_ sv, " split(/,/,q%c%s%c)", 0, ++s, 0);
3119                 s+=strlen(s);
3120             }
3121             else if (*s != '\0') {
3122                 Perl_croak(aTHX_ "Can't use '%c' after -A%.*s", *s, (int)(s-start), start);
3123             }
3124             av_push(PL_preambleav, sv);
3125             return s;
3126         }
3127     case 'M':
3128         forbid_setid("-M");     /* XXX ? */
3129         /* FALL THROUGH */
3130     case 'm':
3131         forbid_setid("-m");     /* XXX ? */
3132         if (*++s) {
3133             char *start;
3134             SV *sv;
3135             const char *use = "use ";
3136             /* -M-foo == 'no foo'       */
3137             /* Leading space on " no " is deliberate, to make both
3138                possibilities the same length.  */
3139             if (*s == '-') { use = " no "; ++s; }
3140             sv = newSVpvn(use,4);
3141             start = s;
3142             /* We allow -M'Module qw(Foo Bar)'  */
3143             while(isALNUM(*s) || *s==':') ++s;
3144             if (*s != '=') {
3145                 sv_catpv(sv, start);
3146                 if (*(start-1) == 'm') {
3147                     if (*s != '\0')
3148                         Perl_croak(aTHX_ "Can't use '%c' after -mname", *s);
3149                     sv_catpv( sv, " ()");
3150                 }
3151             } else {
3152                 if (s == start)
3153                     Perl_croak(aTHX_ "Module name required with -%c option",
3154                                s[-1]);
3155                 sv_catpvn(sv, start, s-start);
3156                 sv_catpv(sv, " split(/,/,q");
3157                 sv_catpvn(sv, "\0)", 1);        /* Use NUL as q//-delimiter. */
3158                 sv_catpv(sv, ++s);
3159                 sv_catpvn(sv,  "\0)", 2);
3160             }
3161             s += strlen(s);
3162             if (!PL_preambleav)
3163                 PL_preambleav = newAV();
3164             av_push(PL_preambleav, sv);
3165         }
3166         else
3167             Perl_croak(aTHX_ "Missing argument to -%c", *(s-1));
3168         return s;
3169     case 'n':
3170         PL_minus_n = TRUE;
3171         s++;
3172         return s;
3173     case 'p':
3174         PL_minus_p = TRUE;
3175         s++;
3176         return s;
3177     case 's':
3178         forbid_setid("-s");
3179         PL_doswitches = TRUE;
3180         s++;
3181         return s;
3182     case 't':
3183         if (!PL_tainting)
3184             TOO_LATE_FOR('t');
3185         s++;
3186         return s;
3187     case 'T':
3188         if (!PL_tainting)
3189             TOO_LATE_FOR('T');
3190         s++;
3191         return s;
3192     case 'u':
3193 #ifdef MACOS_TRADITIONAL
3194         Perl_croak(aTHX_ "Believe me, you don't want to use \"-u\" on a Macintosh");
3195 #endif
3196         PL_do_undump = TRUE;
3197         s++;
3198         return s;
3199     case 'U':
3200         PL_unsafe = TRUE;
3201         s++;
3202         return s;
3203     case 'v':
3204         if (!sv_derived_from(PL_patchlevel, "version"))
3205                 (void *)upg_version(PL_patchlevel);
3206 #if !defined(DGUX)
3207         PerlIO_printf(PerlIO_stdout(),
3208                 Perl_form(aTHX_ "\nThis is perl, %"SVf" built for %s",
3209                     vstringify(PL_patchlevel),
3210                     ARCHNAME));
3211 #else /* DGUX */
3212 /* Adjust verbose output as in the perl that ships with the DG/UX OS from EMC */
3213         PerlIO_printf(PerlIO_stdout(),
3214                 Perl_form(aTHX_ "\nThis is perl, %"SVf"\n",
3215                     vstringify(PL_patchlevel)));
3216         PerlIO_printf(PerlIO_stdout(),
3217                         Perl_form(aTHX_ "        built under %s at %s %s\n",
3218                                         OSNAME, __DATE__, __TIME__));
3219         PerlIO_printf(PerlIO_stdout(),
3220                         Perl_form(aTHX_ "        OS Specific Release: %s\n",
3221                                         OSVERS));
3222 #endif /* !DGUX */
3223
3224 #if defined(LOCAL_PATCH_COUNT)
3225         if (LOCAL_PATCH_COUNT > 0)
3226             PerlIO_printf(PerlIO_stdout(),
3227                           "\n(with %d registered patch%s, "
3228                           "see perl -V for more detail)",
3229                           (int)LOCAL_PATCH_COUNT,
3230                           (LOCAL_PATCH_COUNT!=1) ? "es" : "");
3231 #endif
3232
3233         PerlIO_printf(PerlIO_stdout(),
3234                       "\n\nCopyright 1987-2005, Larry Wall\n");
3235 #ifdef MACOS_TRADITIONAL
3236         PerlIO_printf(PerlIO_stdout(),
3237                       "\nMac OS port Copyright 1991-2002, Matthias Neeracher;\n"
3238                       "maintained by Chris Nandor\n");
3239 #endif
3240 #ifdef MSDOS
3241         PerlIO_printf(PerlIO_stdout(),
3242                       "\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
3243 #endif
3244 #ifdef DJGPP
3245         PerlIO_printf(PerlIO_stdout(),
3246                       "djgpp v2 port (jpl5003c) by Hirofumi Watanabe, 1996\n"
3247                       "djgpp v2 port (perl5004+) by Laszlo Molnar, 1997-1999\n");
3248 #endif
3249 #ifdef OS2
3250         PerlIO_printf(PerlIO_stdout(),
3251                       "\n\nOS/2 port Copyright (c) 1990, 1991, Raymond Chen, Kai Uwe Rommel\n"
3252                       "Version 5 port Copyright (c) 1994-2002, Andreas Kaiser, Ilya Zakharevich\n");
3253 #endif
3254 #ifdef atarist
3255         PerlIO_printf(PerlIO_stdout(),
3256                       "atariST series port, ++jrb  bammi@cadence.com\n");
3257 #endif
3258 #ifdef __BEOS__
3259         PerlIO_printf(PerlIO_stdout(),
3260                       "BeOS port Copyright Tom Spindler, 1997-1999\n");
3261 #endif
3262 #ifdef MPE
3263         PerlIO_printf(PerlIO_stdout(),
3264                       "MPE/iX port Copyright by Mark Klein and Mark Bixby, 1996-2003\n");
3265 #endif
3266 #ifdef OEMVS
3267         PerlIO_printf(PerlIO_stdout(),
3268                       "MVS (OS390) port by Mortice Kern Systems, 1997-1999\n");
3269 #endif
3270 #ifdef __VOS__
3271         PerlIO_printf(PerlIO_stdout(),
3272                       "Stratus VOS port by Paul.Green@stratus.com, 1997-2002\n");
3273 #endif
3274 #ifdef __OPEN_VM
3275         PerlIO_printf(PerlIO_stdout(),
3276                       "VM/ESA port by Neale Ferguson, 1998-1999\n");
3277 #endif
3278 #ifdef POSIX_BC
3279         PerlIO_printf(PerlIO_stdout(),
3280                       "BS2000 (POSIX) port by Start Amadeus GmbH, 1998-1999\n");
3281 #endif
3282 #ifdef __MINT__
3283         PerlIO_printf(PerlIO_stdout(),
3284                       "MiNT port by Guido Flohr, 1997-1999\n");
3285 #endif
3286 #ifdef EPOC
3287         PerlIO_printf(PerlIO_stdout(),
3288                       "EPOC port by Olaf Flebbe, 1999-2002\n");
3289 #endif
3290 #ifdef UNDER_CE
3291         PerlIO_printf(PerlIO_stdout(),"WINCE port by Rainer Keuchel, 2001-2002\n");
3292         PerlIO_printf(PerlIO_stdout(),"Built on " __DATE__ " " __TIME__ "\n\n");
3293         wce_hitreturn();
3294 #endif
3295 #ifdef __SYMBIAN32__
3296         PerlIO_printf(PerlIO_stdout(),
3297                       "Symbian port by Nokia, 2004-2005\n");
3298 #endif
3299 #ifdef BINARY_BUILD_NOTICE
3300         BINARY_BUILD_NOTICE;
3301 #endif
3302         PerlIO_printf(PerlIO_stdout(),
3303                       "\n\
3304 Perl may be copied only under the terms of either the Artistic License or the\n\
3305 GNU General Public License, which may be found in the Perl 5 source kit.\n\n\
3306 Complete documentation for Perl, including FAQ lists, should be found on\n\
3307 this system using \"man perl\" or \"perldoc perl\".  If you have access to the\n\
3308 Internet, point your browser at http://www.perl.org/, the Perl Home Page.\n\n");
3309         my_exit(0);
3310     case 'w':
3311         if (! (PL_dowarn & G_WARN_ALL_MASK))
3312             PL_dowarn |= G_WARN_ON;
3313         s++;
3314         return s;
3315     case 'W':
3316         PL_dowarn = G_WARN_ALL_ON|G_WARN_ON;
3317         if (!specialWARN(PL_compiling.cop_warnings))
3318             SvREFCNT_dec(PL_compiling.cop_warnings);
3319         PL_compiling.cop_warnings = pWARN_ALL ;
3320         s++;
3321         return s;
3322     case 'X':
3323         PL_dowarn = G_WARN_ALL_OFF;
3324         if (!specialWARN(PL_compiling.cop_warnings))
3325             SvREFCNT_dec(PL_compiling.cop_warnings);
3326         PL_compiling.cop_warnings = pWARN_NONE ;
3327         s++;
3328         return s;
3329     case '*':
3330     case ' ':
3331         if (s[1] == '-')        /* Additional switches on #! line. */
3332             return s+2;
3333         break;
3334     case '-':
3335     case 0:
3336 #if defined(WIN32) || !defined(PERL_STRICT_CR)
3337     case '\r':
3338 #endif
3339     case '\n':
3340     case '\t':
3341         break;
3342 #ifdef ALTERNATE_SHEBANG
3343     case 'S':                   /* OS/2 needs -S on "extproc" line. */
3344         break;
3345 #endif
3346     case 'P':
3347         if (PL_preprocess)
3348             return s+1;
3349         /* FALL THROUGH */
3350     default:
3351         Perl_croak(aTHX_ "Can't emulate -%.1s on #! line",s);
3352     }
3353     return Nullch;
3354 }
3355
3356 /* compliments of Tom Christiansen */
3357
3358 /* unexec() can be found in the Gnu emacs distribution */
3359 /* Known to work with -DUNEXEC and using unexelf.c from GNU emacs-20.2 */
3360
3361 void
3362 Perl_my_unexec(pTHX)
3363 {
3364 #ifdef UNEXEC
3365     SV*    prog;
3366     SV*    file;
3367     int    status = 1;
3368     extern int etext;
3369
3370     prog = newSVpv(BIN_EXP, 0);
3371     sv_catpv(prog, "/perl");
3372     file = newSVpv(PL_origfilename, 0);
3373     sv_catpv(file, ".perldump");
3374
3375     unexec(SvPVX(file), SvPVX(prog), &etext, sbrk(0), 0);
3376     /* unexec prints msg to stderr in case of failure */
3377     PerlProc_exit(status);
3378 #else
3379 #  ifdef VMS
3380 #    include <lib$routines.h>
3381      lib$signal(SS$_DEBUG);  /* ssdef.h #included from vmsish.h */
3382 #  else
3383     ABORT();            /* for use with undump */
3384 #  endif
3385 #endif
3386 }
3387
3388 /* initialize curinterp */
3389 STATIC void
3390 S_init_interp(pTHX)
3391 {
3392
3393 #ifdef MULTIPLICITY
3394 #  define PERLVAR(var,type)
3395 #  define PERLVARA(var,n,type)
3396 #  if defined(PERL_IMPLICIT_CONTEXT)
3397 #    if defined(USE_5005THREADS)
3398 #      define PERLVARI(var,type,init)           PERL_GET_INTERP->var = init;
3399 #      define PERLVARIC(var,type,init)          PERL_GET_INTERP->var = init;
3400 #    else /* !USE_5005THREADS */
3401 #      define PERLVARI(var,type,init)           aTHX->var = init;
3402 #      define PERLVARIC(var,type,init)  aTHX->var = init;
3403 #    endif /* USE_5005THREADS */
3404 #  else
3405 #    define PERLVARI(var,type,init)     PERL_GET_INTERP->var = init;
3406 #    define PERLVARIC(var,type,init)    PERL_GET_INTERP->var = init;
3407 #  endif
3408 #  include "intrpvar.h"
3409 #  ifndef USE_5005THREADS
3410 #    include "thrdvar.h"
3411 #  endif
3412 #  undef PERLVAR
3413 #  undef PERLVARA
3414 #  undef PERLVARI
3415 #  undef PERLVARIC
3416 #else
3417 #  define PERLVAR(var,type)
3418 #  define PERLVARA(var,n,type)
3419 #  define PERLVARI(var,type,init)       PL_##var = init;
3420 #  define PERLVARIC(var,type,init)      PL_##var = init;
3421 #  include "intrpvar.h"
3422 #  ifndef USE_5005THREADS
3423 #    include "thrdvar.h"
3424 #  endif
3425 #  undef PERLVAR
3426 #  undef PERLVARA
3427 #  undef PERLVARI
3428 #  undef PERLVARIC
3429 #endif
3430
3431 }
3432
3433 STATIC void
3434 S_init_main_stash(pTHX)
3435 {
3436     GV *gv;
3437
3438     PL_curstash = PL_defstash = newHV();
3439     PL_curstname = newSVpvn("main",4);
3440     gv = gv_fetchpv("main::",TRUE, SVt_PVHV);
3441     SvREFCNT_dec(GvHV(gv));
3442     GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash);
3443     SvREADONLY_on(gv);
3444     hv_name_set(PL_defstash, "main", 4, 0);
3445     PL_incgv = gv_HVadd(gv_AVadd(gv_fetchpv("INC",TRUE, SVt_PVAV)));
3446     SvREFCNT_inc(PL_incgv); /* Don't allow it to be freed */
3447     GvMULTI_on(PL_incgv);
3448     PL_hintgv = gv_fetchpv("\010",TRUE, SVt_PV); /* ^H */
3449     GvMULTI_on(PL_hintgv);
3450     PL_defgv = gv_fetchpv("_",TRUE, SVt_PVAV);
3451     SvREFCNT_inc(PL_defgv);
3452     PL_errgv = gv_HVadd(gv_fetchpv("@", TRUE, SVt_PV));
3453     SvREFCNT_inc(PL_errgv);
3454     GvMULTI_on(PL_errgv);
3455     PL_replgv = gv_fetchpv("\022", TRUE, SVt_PV); /* ^R */
3456     GvMULTI_on(PL_replgv);
3457     (void)Perl_form(aTHX_ "%240s","");  /* Preallocate temp - for immediate signals. */
3458 #ifdef PERL_DONT_CREATE_GVSV
3459     gv_SVadd(PL_errgv);
3460 #endif
3461     sv_grow(ERRSV, 240);        /* Preallocate - for immediate signals. */
3462     sv_setpvn(ERRSV, "", 0);
3463     PL_curstash = PL_defstash;
3464     CopSTASH_set(&PL_compiling, PL_defstash);
3465     PL_debstash = GvHV(gv_fetchpv("DB::", GV_ADDMULTI, SVt_PVHV));
3466     PL_globalstash = GvHV(gv_fetchpv("CORE::GLOBAL::", GV_ADDMULTI, SVt_PVHV));
3467     /* We must init $/ before switches are processed. */
3468     sv_setpvn(get_sv("/", TRUE), "\n", 1);
3469 }
3470
3471 /* PSz 18 Nov 03  fdscript now global but do not change prototype */
3472 STATIC void
3473 S_open_script(pTHX_ const char *scriptname, bool dosearch, SV *sv)
3474 {
3475 #ifndef IAMSUID
3476     const char *quote;
3477     const char *code;
3478     const char *cpp_discard_flag;
3479     const char *perl;
3480 #endif
3481     dVAR;
3482
3483     PL_fdscript = -1;
3484     PL_suidscript = -1;
3485
3486     if (PL_e_script) {
3487         PL_origfilename = savepvn("-e", 2);
3488     }
3489     else {
3490         /* if find_script() returns, it returns a malloc()-ed value */
3491         scriptname = PL_origfilename = find_script(scriptname, dosearch, NULL, 1);
3492
3493         if (strnEQ(scriptname, "/dev/fd/", 8) && isDIGIT(scriptname[8]) ) {
3494             const char *s = scriptname + 8;
3495             PL_fdscript = atoi(s);
3496             while (isDIGIT(*s))
3497                 s++;
3498             if (*s) {
3499                 /* PSz 18 Feb 04
3500                  * Tell apart "normal" usage of fdscript, e.g.
3501                  * with bash on FreeBSD:
3502                  *   perl <( echo '#!perl -DA'; echo 'print "$0\n"')
3503                  * from usage in suidperl.
3504                  * Does any "normal" usage leave garbage after the number???
3505                  * Is it a mistake to use a similar /dev/fd/ construct for
3506                  * suidperl?
3507                  */
3508                 PL_suidscript = 1;
3509                 /* PSz 20 Feb 04
3510                  * Be supersafe and do some sanity-checks.
3511                  * Still, can we be sure we got the right thing?
3512                  */
3513                 if (*s != '/') {
3514                     Perl_croak(aTHX_ "Wrong syntax (suid) fd script name \"%s\"\n", s);
3515                 }
3516                 if (! *(s+1)) {
3517                     Perl_croak(aTHX_ "Missing (suid) fd script name\n");
3518                 }
3519                 scriptname = savepv(s + 1);
3520                 Safefree(PL_origfilename);
3521                 PL_origfilename = (char *)scriptname;
3522             }
3523         }
3524     }
3525
3526     CopFILE_free(PL_curcop);
3527     CopFILE_set(PL_curcop, PL_origfilename);
3528     if (*PL_origfilename == '-' && PL_origfilename[1] == '\0')
3529         scriptname = (char *)"";
3530     if (PL_fdscript >= 0) {
3531         PL_rsfp = PerlIO_fdopen(PL_fdscript,PERL_SCRIPT_MODE);
3532 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3533             if (PL_rsfp)
3534                 /* ensure close-on-exec */
3535                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3536 #       endif
3537     }
3538 #ifdef IAMSUID
3539     else {
3540         Perl_croak(aTHX_ "sperl needs fd script\n"
3541                    "You should not call sperl directly; do you need to "
3542                    "change a #! line\nfrom sperl to perl?\n");
3543
3544 /* PSz 11 Nov 03
3545  * Do not open (or do other fancy stuff) while setuid.
3546  * Perl does the open, and hands script to suidperl on a fd;
3547  * suidperl only does some checks, sets up UIDs and re-execs
3548  * perl with that fd as it has always done.
3549  */
3550     }
3551     if (PL_suidscript != 1) {
3552         Perl_croak(aTHX_ "suidperl needs (suid) fd script\n");
3553     }
3554 #else /* IAMSUID */
3555     else if (PL_preprocess) {
3556         const char * const cpp_cfg = CPPSTDIN;
3557         SV * const cpp = newSVpvn("",0);
3558         SV * const cmd = NEWSV(0,0);
3559
3560         if (cpp_cfg[0] == 0) /* PERL_MICRO? */
3561              Perl_croak(aTHX_ "Can't run with cpp -P with CPPSTDIN undefined");
3562         if (strEQ(cpp_cfg, "cppstdin"))
3563             Perl_sv_catpvf(aTHX_ cpp, "%s/", BIN_EXP);
3564         sv_catpv(cpp, cpp_cfg);
3565
3566 #       ifndef VMS
3567             sv_catpvn(sv, "-I", 2);
3568             sv_catpv(sv,PRIVLIB_EXP);
3569 #       endif
3570
3571         DEBUG_P(PerlIO_printf(Perl_debug_log,
3572                               "PL_preprocess: scriptname=\"%s\", cpp=\"%s\", sv=\"%s\", CPPMINUS=\"%s\"\n",
3573                               scriptname, SvPVX_const (cpp), SvPVX_const (sv),
3574                               CPPMINUS));
3575
3576 #       if defined(MSDOS) || defined(WIN32) || defined(VMS)
3577             quote = "\"";
3578 #       else
3579             quote = "'";
3580 #       endif
3581
3582 #       ifdef VMS
3583             cpp_discard_flag = "";
3584 #       else
3585             cpp_discard_flag = "-C";
3586 #       endif
3587
3588 #       ifdef OS2
3589             perl = os2_execname(aTHX);
3590 #       else
3591             perl = PL_origargv[0];
3592 #       endif
3593
3594
3595         /* This strips off Perl comments which might interfere with
3596            the C pre-processor, including #!.  #line directives are
3597            deliberately stripped to avoid confusion with Perl's version
3598            of #line.  FWP played some golf with it so it will fit
3599            into VMS's 255 character buffer.
3600         */
3601         if( PL_doextract )
3602             code = "(1../^#!.*perl/i)|/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3603         else
3604             code = "/^\\s*#(?!\\s*((ifn?|un)def|(el|end)?if|define|include|else|error|pragma)\\b)/||!($|=1)||print";
3605
3606         Perl_sv_setpvf(aTHX_ cmd, "\
3607 %s -ne%s%s%s %s | %"SVf" %s %"SVf" %s",
3608                        perl, quote, code, quote, scriptname, cpp,
3609                        cpp_discard_flag, sv, CPPMINUS);
3610
3611         PL_doextract = FALSE;
3612
3613         DEBUG_P(PerlIO_printf(Perl_debug_log,
3614                               "PL_preprocess: cmd=\"%s\"\n",
3615                               SvPVX_const(cmd)));
3616
3617         PL_rsfp = PerlProc_popen((char *)SvPVX_const(cmd), (char *)"r");
3618         SvREFCNT_dec(cmd);
3619         SvREFCNT_dec(cpp);
3620     }
3621     else if (!*scriptname) {
3622         forbid_setid("program input from stdin");
3623         PL_rsfp = PerlIO_stdin();
3624     }
3625     else {
3626         PL_rsfp = PerlIO_open(scriptname,PERL_SCRIPT_MODE);
3627 #       if defined(HAS_FCNTL) && defined(F_SETFD)
3628             if (PL_rsfp)
3629                 /* ensure close-on-exec */
3630                 fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,1);
3631 #       endif
3632     }
3633 #endif /* IAMSUID */
3634     if (!PL_rsfp) {
3635         /* PSz 16 Sep 03  Keep neat error message */
3636         if (PL_e_script)
3637             Perl_croak(aTHX_ "Can't open "BIT_BUCKET": %s\n", Strerror(errno));
3638         else
3639             Perl_croak(aTHX_ "Can't open perl script \"%s\": %s\n",
3640                     CopFILE(PL_curcop), Strerror(errno));
3641     }
3642 }
3643
3644 /* Mention
3645  * I_SYSSTATVFS HAS_FSTATVFS
3646  * I_SYSMOUNT
3647  * I_STATFS     HAS_FSTATFS     HAS_GETFSSTAT
3648  * I_MNTENT     HAS_GETMNTENT   HAS_HASMNTOPT
3649  * here so that metaconfig picks them up. */
3650
3651 #ifdef IAMSUID
3652 STATIC int
3653 S_fd_on_nosuid_fs(pTHX_ int fd)
3654 {
3655 /* PSz 27 Feb 04
3656  * We used to do this as "plain" user (after swapping UIDs with setreuid);
3657  * but is needed also on machines without setreuid.
3658  * Seems safe enough to run as root.
3659  */
3660     int check_okay = 0; /* able to do all the required sys/libcalls */
3661     int on_nosuid  = 0; /* the fd is on a nosuid fs */
3662     /* PSz 12 Nov 03
3663      * Need to check noexec also: nosuid might not be set, the average
3664      * sysadmin would say that nosuid is irrelevant once he sets noexec.
3665      */
3666     int on_noexec  = 0; /* the fd is on a noexec fs */
3667
3668 /*
3669  * Preferred order: fstatvfs(), fstatfs(), ustat()+getmnt(), getmntent().
3670  * fstatvfs() is UNIX98.
3671  * fstatfs() is 4.3 BSD.
3672  * ustat()+getmnt() is pre-4.3 BSD.
3673  * getmntent() is O(number-of-mounted-filesystems) and can hang on
3674  * an irrelevant filesystem while trying to reach the right one.
3675  */
3676
3677 #undef FD_ON_NOSUID_CHECK_OKAY  /* found the syscalls to do the check? */
3678
3679 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3680         defined(HAS_FSTATVFS)
3681 #   define FD_ON_NOSUID_CHECK_OKAY
3682     struct statvfs stfs;
3683
3684     check_okay = fstatvfs(fd, &stfs) == 0;
3685     on_nosuid  = check_okay && (stfs.f_flag  & ST_NOSUID);
3686 #ifdef ST_NOEXEC
3687     /* ST_NOEXEC certainly absent on AIX 5.1, and doesn't seem to be documented
3688        on platforms where it is present.  */
3689     on_noexec  = check_okay && (stfs.f_flag  & ST_NOEXEC);
3690 #endif
3691 #   endif /* fstatvfs */
3692
3693 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3694         defined(PERL_MOUNT_NOSUID)      && \
3695         defined(PERL_MOUNT_NOEXEC)      && \
3696         defined(HAS_FSTATFS)            && \
3697         defined(HAS_STRUCT_STATFS)      && \
3698         defined(HAS_STRUCT_STATFS_F_FLAGS)
3699 #   define FD_ON_NOSUID_CHECK_OKAY
3700     struct statfs  stfs;
3701
3702     check_okay = fstatfs(fd, &stfs)  == 0;
3703     on_nosuid  = check_okay && (stfs.f_flags & PERL_MOUNT_NOSUID);
3704     on_noexec  = check_okay && (stfs.f_flags & PERL_MOUNT_NOEXEC);
3705 #   endif /* fstatfs */
3706
3707 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3708         defined(PERL_MOUNT_NOSUID)      && \
3709         defined(PERL_MOUNT_NOEXEC)      && \
3710         defined(HAS_FSTAT)              && \
3711         defined(HAS_USTAT)              && \
3712         defined(HAS_GETMNT)             && \
3713         defined(HAS_STRUCT_FS_DATA)     && \
3714         defined(NOSTAT_ONE)
3715 #   define FD_ON_NOSUID_CHECK_OKAY
3716     Stat_t fdst;
3717
3718     if (fstat(fd, &fdst) == 0) {
3719         struct ustat us;
3720         if (ustat(fdst.st_dev, &us) == 0) {
3721             struct fs_data fsd;
3722             /* NOSTAT_ONE here because we're not examining fields which
3723              * vary between that case and STAT_ONE. */
3724             if (getmnt((int*)0, &fsd, (int)0, NOSTAT_ONE, us.f_fname) == 0) {
3725                 size_t cmplen = sizeof(us.f_fname);
3726                 if (sizeof(fsd.fd_req.path) < cmplen)
3727                     cmplen = sizeof(fsd.fd_req.path);
3728                 if (strnEQ(fsd.fd_req.path, us.f_fname, cmplen) &&
3729                     fdst.st_dev == fsd.fd_req.dev) {
3730                     check_okay = 1;
3731                     on_nosuid = fsd.fd_req.flags & PERL_MOUNT_NOSUID;
3732                     on_noexec = fsd.fd_req.flags & PERL_MOUNT_NOEXEC;
3733                 }
3734             }
3735         }
3736     }
3737 #   endif /* fstat+ustat+getmnt */
3738
3739 #   if !defined(FD_ON_NOSUID_CHECK_OKAY) && \
3740         defined(HAS_GETMNTENT)          && \
3741         defined(HAS_HASMNTOPT)          && \
3742         defined(MNTOPT_NOSUID)          && \
3743         defined(MNTOPT_NOEXEC)
3744 #   define FD_ON_NOSUID_CHECK_OKAY
3745     FILE                *mtab = fopen("/etc/mtab", "r");
3746     struct mntent       *entry;
3747     Stat_t              stb, fsb;
3748
3749     if (mtab && (fstat(fd, &stb) == 0)) {
3750         while (entry = getmntent(mtab)) {
3751             if (stat(entry->mnt_dir, &fsb) == 0
3752                 && fsb.st_dev == stb.st_dev)
3753             {
3754                 /* found the filesystem */
3755                 check_okay = 1;
3756                 if (hasmntopt(entry, MNTOPT_NOSUID))
3757                     on_nosuid = 1;
3758                 if (hasmntopt(entry, MNTOPT_NOEXEC))
3759                     on_noexec = 1;
3760                 break;
3761             } /* A single fs may well fail its stat(). */
3762         }
3763     }
3764     if (mtab)
3765         fclose(mtab);
3766 #   endif /* getmntent+hasmntopt */
3767
3768     if (!check_okay)
3769         Perl_croak(aTHX_ "Can't check filesystem of script \"%s\" for nosuid/noexec", PL_origfilename);
3770     if (on_nosuid)
3771         Perl_croak(aTHX_ "Setuid script \"%s\" on nosuid filesystem", PL_origfilename);
3772     if (on_noexec)
3773         Perl_croak(aTHX_ "Setuid script \"%s\" on noexec filesystem", PL_origfilename);
3774     return ((!check_okay) || on_nosuid || on_noexec);
3775 }
3776 #endif /* IAMSUID */
3777
3778 STATIC void
3779 S_validate_suid(pTHX_ const char *validarg, const char *scriptname)
3780 {
3781     dVAR;
3782 #ifdef IAMSUID
3783     /* int which; */
3784 #endif /* IAMSUID */
3785
3786     /* do we need to emulate setuid on scripts? */
3787
3788     /* This code is for those BSD systems that have setuid #! scripts disabled
3789      * in the kernel because of a security problem.  Merely defining DOSUID
3790      * in perl will not fix that problem, but if you have disabled setuid
3791      * scripts in the kernel, this will attempt to emulate setuid and setgid
3792      * on scripts that have those now-otherwise-useless bits set.  The setuid
3793      * root version must be called suidperl or sperlN.NNN.  If regular perl
3794      * discovers that it has opened a setuid script, it calls suidperl with
3795      * the same argv that it had.  If suidperl finds that the script it has
3796      * just opened is NOT setuid root, it sets the effective uid back to the
3797      * uid.  We don't just make perl setuid root because that loses the
3798      * effective uid we had before invoking perl, if it was different from the
3799      * uid.
3800      * PSz 27 Feb 04
3801      * Description/comments above do not match current workings:
3802      *   suidperl must be hardlinked to sperlN.NNN (that is what we exec);
3803      *   suidperl called with script open and name changed to /dev/fd/N/X;
3804      *   suidperl croaks if script is not setuid;
3805      *   making perl setuid would be a huge security risk (and yes, that
3806      *     would lose any euid we might have had).
3807      *
3808      * DOSUID must be defined in both perl and suidperl, and IAMSUID must
3809      * be defined in suidperl only.  suidperl must be setuid root.  The
3810      * Configure script will set this up for you if you want it.
3811      */
3812
3813 #ifdef DOSUID
3814     const char *s, *s2;
3815
3816     if (PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf) < 0)  /* normal stat is insecure */
3817         Perl_croak(aTHX_ "Can't stat script \"%s\"",PL_origfilename);
3818     if (PL_statbuf.st_mode & (S_ISUID|S_ISGID)) {
3819         I32 len;
3820         const char *linestr;
3821         const char *s_end;
3822
3823 #ifdef IAMSUID
3824         if (PL_fdscript < 0 || PL_suidscript != 1)
3825             Perl_croak(aTHX_ "Need (suid) fdscript in suidperl\n");     /* We already checked this */
3826         /* PSz 11 Nov 03
3827          * Since the script is opened by perl, not suidperl, some of these
3828          * checks are superfluous. Leaving them in probably does not lower
3829          * security(?!).
3830          */
3831         /* PSz 27 Feb 04
3832          * Do checks even for systems with no HAS_SETREUID.
3833          * We used to swap, then re-swap UIDs with
3834 #ifdef HAS_SETREUID
3835             if (setreuid(PL_euid,PL_uid) < 0
3836                 || PerlProc_getuid() != PL_euid || PerlProc_geteuid() != PL_uid)
3837                 Perl_croak(aTHX_ "Can't swap uid and euid");
3838 #endif
3839 #ifdef HAS_SETREUID
3840             if (setreuid(PL_uid,PL_euid) < 0
3841                 || PerlProc_getuid() != PL_uid || PerlProc_geteuid() != PL_euid)
3842                 Perl_croak(aTHX_ "Can't reswap uid and euid");
3843 #endif
3844          */
3845
3846         /* On this access check to make sure the directories are readable,
3847          * there is actually a small window that the user could use to make
3848          * filename point to an accessible directory.  So there is a faint
3849          * chance that someone could execute a setuid script down in a
3850          * non-accessible directory.  I don't know what to do about that.
3851          * But I don't think it's too important.  The manual lies when
3852          * it says access() is useful in setuid programs.
3853          *
3854          * So, access() is pretty useless... but not harmful... do anyway.
3855          */
3856         if (PerlLIO_access(CopFILE(PL_curcop),1)) { /*double check*/
3857             Perl_croak(aTHX_ "Can't access() script\n");
3858         }
3859
3860         /* If we can swap euid and uid, then we can determine access rights
3861          * with a simple stat of the file, and then compare device and
3862          * inode to make sure we did stat() on the same file we opened.
3863          * Then we just have to make sure he or she can execute it.
3864          *
3865          * PSz 24 Feb 04
3866          * As the script is opened by perl, not suidperl, we do not need to
3867          * care much about access rights.
3868          *
3869          * The 'script changed' check is needed, or we can get lied to
3870          * about $0 with e.g.
3871          *  suidperl /dev/fd/4//bin/x 4<setuidscript
3872          * Without HAS_SETREUID, is it safe to stat() as root?
3873          *
3874          * Are there any operating systems that pass /dev/fd/xxx for setuid
3875          * scripts, as suggested/described in perlsec(1)? Surely they do not
3876          * pass the script name as we do, so the "script changed" test would
3877          * fail for them... but we never get here with
3878          * SETUID_SCRIPTS_ARE_SECURE_NOW defined.
3879          *
3880          * This is one place where we must "lie" about return status: not
3881          * say if the stat() failed. We are doing this as root, and could
3882          * be tricked into reporting existence or not of files that the
3883          * "plain" user cannot even see.
3884          */
3885         {
3886             Stat_t tmpstatbuf;
3887             if (PerlLIO_stat(CopFILE(PL_curcop),&tmpstatbuf) < 0 ||
3888                 tmpstatbuf.st_dev != PL_statbuf.st_dev ||
3889                 tmpstatbuf.st_ino != PL_statbuf.st_ino) {
3890                 Perl_croak(aTHX_ "Setuid script changed\n");
3891             }
3892
3893         }
3894         if (!cando(S_IXUSR,FALSE,&PL_statbuf))          /* can real uid exec? */
3895             Perl_croak(aTHX_ "Real UID cannot exec script\n");
3896
3897         /* PSz 27 Feb 04
3898          * We used to do this check as the "plain" user (after swapping
3899          * UIDs). But the check for nosuid and noexec filesystem is needed,
3900          * and should be done even without HAS_SETREUID. (Maybe those
3901          * operating systems do not have such mount options anyway...)
3902          * Seems safe enough to do as root.
3903          */
3904 #if !defined(NO_NOSUID_CHECK)
3905         if (fd_on_nosuid_fs(PerlIO_fileno(PL_rsfp))) {
3906             Perl_croak(aTHX_ "Setuid script on nosuid or noexec filesystem\n");
3907         }
3908 #endif
3909 #endif /* IAMSUID */
3910
3911         if (!S_ISREG(PL_statbuf.st_mode)) {
3912             Perl_croak(aTHX_ "Setuid script not plain file\n");
3913         }
3914         if (PL_statbuf.st_mode & S_IWOTH)
3915             Perl_croak(aTHX_ "Setuid/gid script is writable by world");
3916         PL_doswitches = FALSE;          /* -s is insecure in suid */
3917         /* PSz 13 Nov 03  But -s was caught elsewhere ... so unsetting it here is useless(?!) */
3918         CopLINE_inc(PL_curcop);
3919         linestr = SvPV_nolen_const(PL_linestr);
3920         if (sv_gets(PL_linestr, PL_rsfp, 0) == Nullch ||
3921           strnNE(linestr,"#!",2) )      /* required even on Sys V */
3922             Perl_croak(aTHX_ "No #! line");
3923         linestr+=2;
3924         s = linestr;
3925         /* PSz 27 Feb 04 */
3926         /* Sanity check on line length */
3927         s_end = s + strlen(s);
3928         if (s_end == s || (s_end - s) > 4000)
3929             Perl_croak(aTHX_ "Very long #! line");
3930         /* Allow more than a single space after #! */
3931         while (isSPACE(*s)) s++;
3932         /* Sanity check on buffer end */
3933         while ((*s) && !isSPACE(*s)) s++;
3934         for (s2 = s;  (s2 > linestr &&
3935                        (isDIGIT(s2[-1]) || s2[-1] == '.' || s2[-1] == '_'
3936                         || s2[-1] == '-'));  s2--) ;
3937         /* Sanity check on buffer start */
3938         if ( (s2-4 < linestr || strnNE(s2-4,"perl",4)) &&
3939               (s-9 < linestr || strnNE(s-9,"perl",4)) )
3940             Perl_croak(aTHX_ "Not a perl script");
3941         while (*s == ' ' || *s == '\t') s++;
3942         /*
3943          * #! arg must be what we saw above.  They can invoke it by
3944          * mentioning suidperl explicitly, but they may not add any strange
3945          * arguments beyond what #! says if they do invoke suidperl that way.
3946          */
3947         /*
3948          * The way validarg was set up, we rely on the kernel to start
3949          * scripts with argv[1] set to contain all #! line switches (the
3950          * whole line).
3951          */
3952         /*
3953          * Check that we got all the arguments listed in the #! line (not
3954          * just that there are no extraneous arguments). Might not matter
3955          * much, as switches from #! line seem to be acted upon (also), and
3956          * so may be checked and trapped in perl. But, security checks must
3957          * be done in suidperl and not deferred to perl. Note that suidperl
3958          * does not get around to parsing (and checking) the switches on
3959          * the #! line (but execs perl sooner).
3960          * Allow (require) a trailing newline (which may be of two
3961          * characters on some architectures?) (but no other trailing
3962          * whitespace).
3963          */
3964         len = strlen(validarg);
3965         if (strEQ(validarg," PHOOEY ") ||
3966             strnNE(s,validarg,len) || !isSPACE(s[len]) ||
3967             !((s_end - s) == len+1
3968               || ((s_end - s) == len+2 && isSPACE(s[len+1]))))
3969             Perl_croak(aTHX_ "Args must match #! line");
3970
3971 #ifndef IAMSUID
3972         if (PL_fdscript < 0 &&
3973             PL_euid != PL_uid && (PL_statbuf.st_mode & S_ISUID) &&
3974             PL_euid == PL_statbuf.st_uid)
3975             if (!PL_do_undump)
3976                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
3977 FIX YOUR KERNEL, OR PUT A C WRAPPER AROUND THIS SCRIPT!\n");
3978 #endif /* IAMSUID */
3979
3980         if (PL_fdscript < 0 &&
3981             PL_euid) {  /* oops, we're not the setuid root perl */
3982             /* PSz 18 Feb 04
3983              * When root runs a setuid script, we do not go through the same
3984              * steps of execing sperl and then perl with fd scripts, but
3985              * simply set up UIDs within the same perl invocation; so do
3986              * not have the same checks (on options, whatever) that we have
3987              * for plain users. No problem really: would have to be a script
3988              * that does not actually work for plain users; and if root is
3989              * foolish and can be persuaded to run such an unsafe script, he
3990              * might run also non-setuid ones, and deserves what he gets.
3991              *
3992              * Or, we might drop the PL_euid check above (and rely just on
3993              * PL_fdscript to avoid loops), and do the execs
3994              * even for root.
3995              */
3996 #ifndef IAMSUID
3997             int which;
3998             /* PSz 11 Nov 03
3999              * Pass fd script to suidperl.
4000              * Exec suidperl, substituting fd script for scriptname.
4001              * Pass script name as "subdir" of fd, which perl will grok;
4002              * in fact will use that to distinguish this from "normal"
4003              * usage, see comments above.
4004              */
4005             PerlIO_rewind(PL_rsfp);
4006             PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
4007             /* PSz 27 Feb 04  Sanity checks on scriptname */
4008             if ((!scriptname) || (!*scriptname) ) {
4009                 Perl_croak(aTHX_ "No setuid script name\n");
4010             }
4011             if (*scriptname == '-') {
4012                 Perl_croak(aTHX_ "Setuid script name may not begin with dash\n");
4013                 /* Or we might confuse it with an option when replacing
4014                  * name in argument list, below (though we do pointer, not
4015                  * string, comparisons).
4016                  */
4017             }
4018             for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;
4019             if (!PL_origargv[which]) {
4020                 Perl_croak(aTHX_ "Can't change argv to have fd script\n");
4021             }
4022             PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",
4023                                           PerlIO_fileno(PL_rsfp), PL_origargv[which]));
4024 #if defined(HAS_FCNTL) && defined(F_SETFD)
4025             fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
4026 #endif
4027             PERL_FPU_PRE_EXEC
4028             PerlProc_execv(Perl_form(aTHX_ "%s/sperl"PERL_FS_VER_FMT, BIN_EXP,
4029                                      (int)PERL_REVISION, (int)PERL_VERSION,
4030                                      (int)PERL_SUBVERSION), PL_origargv);
4031             PERL_FPU_POST_EXEC
4032 #endif /* IAMSUID */
4033             Perl_croak(aTHX_ "Can't do setuid (cannot exec sperl)\n");
4034         }
4035
4036         if (PL_statbuf.st_mode & S_ISGID && PL_statbuf.st_gid != PL_egid) {
4037 /* PSz 26 Feb 04
4038  * This seems back to front: we try HAS_SETEGID first; if not available
4039  * then try HAS_SETREGID; as a last chance we try HAS_SETRESGID. May be OK
4040  * in the sense that we only want to set EGID; but are there any machines
4041  * with either of the latter, but not the former? Same with UID, later.
4042  */
4043 #ifdef HAS_SETEGID
4044             (void)setegid(PL_statbuf.st_gid);
4045 #else
4046 #ifdef HAS_SETREGID
4047            (void)setregid((Gid_t)-1,PL_statbuf.st_gid);
4048 #else
4049 #ifdef HAS_SETRESGID
4050            (void)setresgid((Gid_t)-1,PL_statbuf.st_gid,(Gid_t)-1);
4051 #else
4052             PerlProc_setgid(PL_statbuf.st_gid);
4053 #endif
4054 #endif
4055 #endif
4056             if (PerlProc_getegid() != PL_statbuf.st_gid)
4057                 Perl_croak(aTHX_ "Can't do setegid!\n");
4058         }
4059         if (PL_statbuf.st_mode & S_ISUID) {
4060             if (PL_statbuf.st_uid != PL_euid)
4061 #ifdef HAS_SETEUID
4062                 (void)seteuid(PL_statbuf.st_uid);       /* all that for this */
4063 #else
4064 #ifdef HAS_SETREUID
4065                 (void)setreuid((Uid_t)-1,PL_statbuf.st_uid);
4066 #else
4067 #ifdef HAS_SETRESUID
4068                 (void)setresuid((Uid_t)-1,PL_statbuf.st_uid,(Uid_t)-1);
4069 #else
4070                 PerlProc_setuid(PL_statbuf.st_uid);
4071 #endif
4072 #endif
4073 #endif
4074             if (PerlProc_geteuid() != PL_statbuf.st_uid)
4075                 Perl_croak(aTHX_ "Can't do seteuid!\n");
4076         }
4077         else if (PL_uid) {                      /* oops, mustn't run as root */
4078 #ifdef HAS_SETEUID
4079           (void)seteuid((Uid_t)PL_uid);
4080 #else
4081 #ifdef HAS_SETREUID
4082           (void)setreuid((Uid_t)-1,(Uid_t)PL_uid);
4083 #else
4084 #ifdef HAS_SETRESUID
4085           (void)setresuid((Uid_t)-1,(Uid_t)PL_uid,(Uid_t)-1);
4086 #else
4087           PerlProc_setuid((Uid_t)PL_uid);
4088 #endif
4089 #endif
4090 #endif
4091             if (PerlProc_geteuid() != PL_uid)
4092                 Perl_croak(aTHX_ "Can't do seteuid!\n");
4093         }
4094         init_ids();
4095         if (!cando(S_IXUSR,TRUE,&PL_statbuf))
4096             Perl_croak(aTHX_ "Effective UID cannot exec script\n");     /* they can't do this */
4097     }
4098 #ifdef IAMSUID
4099     else if (PL_preprocess)     /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
4100         Perl_croak(aTHX_ "-P not allowed for setuid/setgid script\n");
4101     else if (PL_fdscript < 0 || PL_suidscript != 1)
4102         /* PSz 13 Nov 03  Caught elsewhere, useless(?!) here */
4103         Perl_croak(aTHX_ "(suid) fdscript needed in suidperl\n");
4104     else {
4105 /* PSz 16 Sep 03  Keep neat error message */
4106         Perl_croak(aTHX_ "Script is not setuid/setgid in suidperl\n");
4107     }
4108
4109     /* We absolutely must clear out any saved ids here, so we */
4110     /* exec the real perl, substituting fd script for scriptname. */
4111     /* (We pass script name as "subdir" of fd, which perl will grok.) */
4112     /*
4113      * It might be thought that using setresgid and/or setresuid (changed to
4114      * set the saved IDs) above might obviate the need to exec, and we could
4115      * go on to "do the perl thing".
4116      *
4117      * Is there such a thing as "saved GID", and is that set for setuid (but
4118      * not setgid) execution like suidperl? Without exec, it would not be
4119      * cleared for setuid (but not setgid) scripts (or might need a dummy
4120      * setresgid).
4121      *
4122      * We need suidperl to do the exact same argument checking that perl
4123      * does. Thus it cannot be very small; while it could be significantly
4124      * smaller, it is safer (simpler?) to make it essentially the same
4125      * binary as perl (but they are not identical). - Maybe could defer that
4126      * check to the invoked perl, and suidperl be a tiny wrapper instead;
4127      * but prefer to do thorough checks in suidperl itself. Such deferral
4128      * would make suidperl security rely on perl, a design no-no.
4129      *
4130      * Setuid things should be short and simple, thus easy to understand and
4131      * verify. They should do their "own thing", without influence by
4132      * attackers. It may help if their internal execution flow is fixed,
4133      * regardless of platform: it may be best to exec anyway.
4134      *
4135      * Suidperl should at least be conceptually simple: a wrapper only,
4136      * never to do any real perl. Maybe we should put
4137      * #ifdef IAMSUID
4138      *         Perl_croak(aTHX_ "Suidperl should never do real perl\n");
4139      * #endif
4140      * into the perly bits.
4141      */
4142     PerlIO_rewind(PL_rsfp);
4143     PerlLIO_lseek(PerlIO_fileno(PL_rsfp),(Off_t)0,0);  /* just in case rewind didn't */
4144     /* PSz 11 Nov 03
4145      * Keep original arguments: suidperl already has fd script.
4146      */
4147 /*  for (which = 1; PL_origargv[which] && PL_origargv[which] != scriptname; which++) ;  */
4148 /*  if (!PL_origargv[which]) {                                          */
4149 /*      errno = EPERM;                                                  */
4150 /*      Perl_croak(aTHX_ "Permission denied\n");                        */
4151 /*  }                                                                   */
4152 /*  PL_origargv[which] = savepv(Perl_form(aTHX_ "/dev/fd/%d/%s",        */
4153 /*                                PerlIO_fileno(PL_rsfp), PL_origargv[which])); */
4154 #if defined(HAS_FCNTL) && defined(F_SETFD)
4155     fcntl(PerlIO_fileno(PL_rsfp),F_SETFD,0);    /* ensure no close-on-exec */
4156 #endif
4157     PERL_FPU_PRE_EXEC
4158     PerlProc_execv(Perl_form(aTHX_ "%s/perl"PERL_FS_VER_FMT, BIN_EXP,
4159                              (int)PERL_REVISION, (int)PERL_VERSION,
4160                              (int)PERL_SUBVERSION), PL_origargv);/* try again */
4161     PERL_FPU_POST_EXEC
4162     Perl_croak(aTHX_ "Can't do setuid (suidperl cannot exec perl)\n");
4163 #endif /* IAMSUID */
4164 #else /* !DOSUID */
4165     if (PL_euid != PL_uid || PL_egid != PL_gid) {       /* (suidperl doesn't exist, in fact) */
4166 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
4167         PerlLIO_fstat(PerlIO_fileno(PL_rsfp),&PL_statbuf);      /* may be either wrapped or real suid */
4168         if ((PL_euid != PL_uid && PL_euid == PL_statbuf.st_uid && PL_statbuf.st_mode & S_ISUID)
4169             ||
4170             (PL_egid != PL_gid && PL_egid == PL_statbuf.st_gid && PL_statbuf.st_mode & S_ISGID)
4171            )
4172             if (!PL_do_undump)
4173                 Perl_croak(aTHX_ "YOU HAVEN'T DISABLED SET-ID SCRIPTS IN THE KERNEL YET!\n\
4174 FIX YOUR KERNEL, PUT A C WRAPPER AROUND THIS SCRIPT, OR USE -u AND UNDUMP!\n");
4175 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
4176         /* not set-id, must be wrapped */
4177     }
4178 #endif /* DOSUID */
4179     (void)validarg;
4180     (void)scriptname;
4181 }
4182
4183 STATIC void
4184 S_find_beginning(pTHX)
4185 {
4186     register char *s;
4187     register const char *s2;
4188 #ifdef MACOS_TRADITIONAL
4189     int maclines = 0;
4190 #endif
4191
4192     /* skip forward in input to the real script? */
4193
4194     forbid_setid("-x");
4195 #ifdef MACOS_TRADITIONAL
4196     /* Since the Mac OS does not honor #! arguments for us, we do it ourselves */
4197
4198     while (PL_doextract || gMacPerl_AlwaysExtract) {
4199         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch) {
4200             if (!gMacPerl_AlwaysExtract)
4201                 Perl_croak(aTHX_ "No Perl script found in input\n");
4202
4203             if (PL_doextract)                   /* require explicit override ? */
4204                 if (!OverrideExtract(PL_origfilename))
4205                     Perl_croak(aTHX_ "User aborted script\n");
4206                 else
4207                     PL_doextract = FALSE;
4208
4209             /* Pater peccavi, file does not have #! */
4210             PerlIO_rewind(PL_rsfp);
4211
4212             break;
4213         }
4214 #else
4215     while (PL_doextract) {
4216         if ((s = sv_gets(PL_linestr, PL_rsfp, 0)) == Nullch)
4217             Perl_croak(aTHX_ "No Perl script found in input\n");
4218 #endif
4219         s2 = s;
4220         if (*s == '#' && s[1] == '!' && ((s = instr(s,"perl")) || (s = instr(s2,"PERL")))) {
4221             PerlIO_ungetc(PL_rsfp, '\n');               /* to keep line count right */
4222             PL_doextract = FALSE;
4223             while (*s && !(isSPACE (*s) || *s == '#')) s++;
4224             s2 = s;
4225             while (*s == ' ' || *s == '\t') s++;
4226             if (*s++ == '-') {
4227                 while (isDIGIT(s2[-1]) || s2[-1] == '-' || s2[-1] == '.'
4228                        || s2[-1] == '_') s2--;
4229                 if (strnEQ(s2-4,"perl",4))
4230                     while ((s = moreswitches(s)))
4231                         ;
4232             }
4233 #ifdef MACOS_TRADITIONAL
4234             /* We are always searching for the #!perl line in MacPerl,
4235              * so if we find it, still keep the line count correct
4236              * by counting lines we already skipped over
4237              */
4238             for (; maclines > 0 ; maclines--)
4239                 PerlIO_ungetc(PL_rsfp, '\n');
4240
4241             break;
4242
4243         /* gMacPerl_AlwaysExtract is false in MPW tool */
4244         } else if (gMacPerl_AlwaysExtract) {
4245             ++maclines;
4246 #endif
4247         }
4248     }
4249 }
4250
4251
4252 STATIC void
4253 S_init_ids(pTHX)
4254 {
4255     PL_uid = PerlProc_getuid();
4256     PL_euid = PerlProc_geteuid();
4257     PL_gid = PerlProc_getgid();
4258     PL_egid = PerlProc_getegid();
4259 #ifdef VMS
4260     PL_uid |= PL_gid << 16;
4261     PL_euid |= PL_egid << 16;
4262 #endif
4263     /* Should not happen: */
4264     CHECK_MALLOC_TAINT(PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
4265     PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
4266     /* BUG */
4267     /* PSz 27 Feb 04
4268      * Should go by suidscript, not uid!=euid: why disallow
4269      * system("ls") in scripts run from setuid things?
4270      * Or, is this run before we check arguments and set suidscript?
4271      * What about SETUID_SCRIPTS_ARE_SECURE_NOW: could we use fdscript then?
4272      * (We never have suidscript, can we be sure to have fdscript?)
4273      * Or must then go by UID checks? See comments in forbid_setid also.
4274      */
4275 }
4276
4277 /* This is used very early in the lifetime of the program,
4278  * before even the options are parsed, so PL_tainting has
4279  * not been initialized properly.  */
4280 bool
4281 Perl_doing_taint(int argc, char *argv[], char *envp[])
4282 {
4283 #ifndef PERL_IMPLICIT_SYS
4284     /* If we have PERL_IMPLICIT_SYS we can't call getuid() et alia
4285      * before we have an interpreter-- and the whole point of this
4286      * function is to be called at such an early stage.  If you are on
4287      * a system with PERL_IMPLICIT_SYS but you do have a concept of
4288      * "tainted because running with altered effective ids', you'll
4289      * have to add your own checks somewhere in here.  The two most
4290      * known samples of 'implicitness' are Win32 and NetWare, neither
4291      * of which has much of concept of 'uids'. */
4292     int uid  = PerlProc_getuid();
4293     int euid = PerlProc_geteuid();
4294     int gid  = PerlProc_getgid();
4295     int egid = PerlProc_getegid();
4296     (void)envp;
4297
4298 #ifdef VMS
4299     uid  |=  gid << 16;
4300     euid |= egid << 16;
4301 #endif
4302     if (uid && (euid != uid || egid != gid))
4303         return 1;
4304 #endif /* !PERL_IMPLICIT_SYS */
4305     /* This is a really primitive check; environment gets ignored only
4306      * if -T are the first chars together; otherwise one gets
4307      *  "Too late" message. */
4308     if ( argc > 1 && argv[1][0] == '-'
4309          && (argv[1][1] == 't' || argv[1][1] == 'T') )
4310         return 1;
4311     return 0;
4312 }
4313
4314 STATIC void
4315 S_forbid_setid(pTHX_ const char *s)
4316 {
4317 #ifdef SETUID_SCRIPTS_ARE_SECURE_NOW
4318     if (PL_euid != PL_uid)
4319         Perl_croak(aTHX_ "No %s allowed while running setuid", s);
4320     if (PL_egid != PL_gid)
4321         Perl_croak(aTHX_ "No %s allowed while running setgid", s);
4322 #endif /* SETUID_SCRIPTS_ARE_SECURE_NOW */
4323     /* PSz 29 Feb 04
4324      * Checks for UID/GID above "wrong": why disallow
4325      *   perl -e 'print "Hello\n"'
4326      * from within setuid things?? Simply drop them: replaced by
4327      * fdscript/suidscript and #ifdef IAMSUID checks below.
4328      *
4329      * This may be too late for command-line switches. Will catch those on
4330      * the #! line, after finding the script name and setting up
4331      * fdscript/suidscript. Note that suidperl does not get around to
4332      * parsing (and checking) the switches on the #! line, but checks that
4333      * the two sets are identical.
4334      *
4335      * With SETUID_SCRIPTS_ARE_SECURE_NOW, could we use fdscript, also or
4336      * instead, or would that be "too late"? (We never have suidscript, can
4337      * we be sure to have fdscript?)
4338      *
4339      * Catch things with suidscript (in descendant of suidperl), even with
4340      * right UID/GID. Was already checked in suidperl, with #ifdef IAMSUID,
4341      * below; but I am paranoid.
4342      *
4343      * Also see comments about root running a setuid script, elsewhere.
4344      */
4345     if (PL_suidscript >= 0)
4346         Perl_croak(aTHX_ "No %s allowed with (suid) fdscript", s);
4347 #ifdef IAMSUID
4348     /* PSz 11 Nov 03  Catch it in suidperl, always! */
4349     Perl_croak(aTHX_ "No %s allowed in suidperl", s);
4350 #endif /* IAMSUID */
4351 }
4352
4353 void
4354 Perl_init_debugger(pTHX)
4355 {
4356     HV * const ostash = PL_curstash;
4357
4358     PL_curstash = PL_debstash;
4359     PL_dbargs = GvAV(gv_AVadd((gv_fetchpv("DB::args", GV_ADDMULTI, SVt_PVAV))));
4360     AvREAL_off(PL_dbargs);
4361     PL_DBgv = gv_fetchpv("DB::DB", GV_ADDMULTI, SVt_PVGV);
4362     PL_DBline = gv_fetchpv("DB::dbline", GV_ADDMULTI, SVt_PVAV);
4363     PL_DBsub = gv_HVadd(gv_fetchpv("DB::sub", GV_ADDMULTI, SVt_PVHV));
4364     PL_DBsingle = GvSV((gv_fetchpv("DB::single", GV_ADDMULTI, SVt_PV)));
4365     sv_setiv(PL_DBsingle, 0);
4366     PL_DBtrace = GvSV((gv_fetchpv("DB::trace", GV_ADDMULTI, SVt_PV)));
4367     sv_setiv(PL_DBtrace, 0);
4368     PL_DBsignal = GvSV((gv_fetchpv("DB::signal", GV_ADDMULTI, SVt_PV)));
4369     sv_setiv(PL_DBsignal, 0);
4370     PL_DBassertion = GvSV((gv_fetchpv("DB::assertion", GV_ADDMULTI, SVt_PV)));
4371     sv_setiv(PL_DBassertion, 0);
4372     PL_curstash = ostash;
4373 }
4374
4375 #ifndef STRESS_REALLOC
4376 #define REASONABLE(size) (size)
4377 #else
4378 #define REASONABLE(size) (1) /* unreasonable */
4379 #endif
4380
4381 void
4382 Perl_init_stacks(pTHX)
4383 {
4384     /* start with 128-item stack and 8K cxstack */
4385     PL_curstackinfo = new_stackinfo(REASONABLE(128),
4386                                  REASONABLE(8192/sizeof(PERL_CONTEXT) - 1));
4387     PL_curstackinfo->si_type = PERLSI_MAIN;
4388     PL_curstack = PL_curstackinfo->si_stack;
4389     PL_mainstack = PL_curstack;         /* remember in case we switch stacks */
4390
4391     PL_stack_base = AvARRAY(PL_curstack);
4392     PL_stack_sp = PL_stack_base;
4393     PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
4394
4395     Newx(PL_tmps_stack,REASONABLE(128),SV*);
4396     PL_tmps_floor = -1;
4397     PL_tmps_ix = -1;
4398     PL_tmps_max = REASONABLE(128);
4399
4400     Newx(PL_markstack,REASONABLE(32),I32);
4401     PL_markstack_ptr = PL_markstack;
4402     PL_markstack_max = PL_markstack + REASONABLE(32);
4403
4404     SET_MARK_OFFSET;
4405
4406     Newx(PL_scopestack,REASONABLE(32),I32);
4407     PL_scopestack_ix = 0;
4408     PL_scopestack_max = REASONABLE(32);
4409
4410     Newx(PL_savestack,REASONABLE(128),ANY);
4411     PL_savestack_ix = 0;
4412     PL_savestack_max = REASONABLE(128);
4413 }
4414
4415 #undef REASONABLE
4416
4417 STATIC void
4418 S_nuke_stacks(pTHX)
4419 {
4420     while (PL_curstackinfo->si_next)
4421         PL_curstackinfo = PL_curstackinfo->si_next;
4422     while (PL_curstackinfo) {
4423         PERL_SI *p = PL_curstackinfo->si_prev;
4424         /* curstackinfo->si_stack got nuked by sv_free_arenas() */
4425         Safefree(PL_curstackinfo->si_cxstack);
4426         Safefree(PL_curstackinfo);
4427         PL_curstackinfo = p;
4428     }
4429     Safefree(PL_tmps_stack);
4430     Safefree(PL_markstack);
4431     Safefree(PL_scopestack);
4432     Safefree(PL_savestack);
4433 }
4434
4435 STATIC void
4436 S_init_lexer(pTHX)
4437 {
4438     PerlIO *tmpfp;
4439     tmpfp = PL_rsfp;
4440     PL_rsfp = Nullfp;
4441     lex_start(PL_linestr);
4442     PL_rsfp = tmpfp;
4443     PL_subname = newSVpvn("main",4);
4444 }
4445
4446 STATIC void
4447 S_init_predump_symbols(pTHX)
4448 {
4449     GV *tmpgv;
4450     IO *io;
4451
4452     sv_setpvn(get_sv("\"", TRUE), " ", 1);
4453     PL_stdingv = gv_fetchpv("STDIN",TRUE, SVt_PVIO);
4454     GvMULTI_on(PL_stdingv);
4455     io = GvIOp(PL_stdingv);
4456     IoTYPE(io) = IoTYPE_RDONLY;
4457     IoIFP(io) = PerlIO_stdin();
4458     tmpgv = gv_fetchpv("stdin",TRUE, SVt_PV);
4459     GvMULTI_on(tmpgv);
4460     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4461
4462     tmpgv = gv_fetchpv("STDOUT",TRUE, SVt_PVIO);
4463     GvMULTI_on(tmpgv);
4464     io = GvIOp(tmpgv);
4465     IoTYPE(io) = IoTYPE_WRONLY;
4466     IoOFP(io) = IoIFP(io) = PerlIO_stdout();
4467     setdefout(tmpgv);
4468     tmpgv = gv_fetchpv("stdout",TRUE, SVt_PV);
4469     GvMULTI_on(tmpgv);
4470     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4471
4472     PL_stderrgv = gv_fetchpv("STDERR",TRUE, SVt_PVIO);
4473     GvMULTI_on(PL_stderrgv);
4474     io = GvIOp(PL_stderrgv);
4475     IoTYPE(io) = IoTYPE_WRONLY;
4476     IoOFP(io) = IoIFP(io) = PerlIO_stderr();
4477     tmpgv = gv_fetchpv("stderr",TRUE, SVt_PV);
4478     GvMULTI_on(tmpgv);
4479     GvIOp(tmpgv) = (IO*)SvREFCNT_inc(io);
4480
4481     PL_statname = NEWSV(66,0);          /* last filename we did stat on */
4482
4483     Safefree(PL_osname);
4484     PL_osname = savepv(OSNAME);
4485 }
4486
4487 void
4488 Perl_init_argv_symbols(pTHX_ register int argc, register char **argv)
4489 {
4490     argc--,argv++;      /* skip name of script */
4491     if (PL_doswitches) {
4492         for (; argc > 0 && **argv == '-'; argc--,argv++) {
4493             char *s;
4494             if (!argv[0][1])
4495                 break;
4496             if (argv[0][1] == '-' && !argv[0][2]) {
4497                 argc--,argv++;
4498                 break;
4499             }
4500             if ((s = strchr(argv[0], '='))) {
4501                 *s++ = '\0';
4502                 sv_setpv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),s);
4503             }
4504             else
4505                 sv_setiv(GvSV(gv_fetchpv(argv[0]+1,TRUE, SVt_PV)),1);
4506         }
4507     }
4508     if ((PL_argvgv = gv_fetchpv("ARGV",TRUE, SVt_PVAV))) {
4509         GvMULTI_on(PL_argvgv);
4510         (void)gv_AVadd(PL_argvgv);
4511         av_clear(GvAVn(PL_argvgv));
4512         for (; argc > 0; argc--,argv++) {
4513             SV * const sv = newSVpv(argv[0],0);
4514             av_push(GvAVn(PL_argvgv),sv);
4515             if (!(PL_unicode & PERL_UNICODE_LOCALE_FLAG) || PL_utf8locale) {
4516                  if (PL_unicode & PERL_UNICODE_ARGV_FLAG)
4517                       SvUTF8_on(sv);
4518             }
4519             if (PL_unicode & PERL_UNICODE_WIDESYSCALLS_FLAG) /* Sarathy? */
4520                  (void)sv_utf8_decode(sv);
4521         }
4522     }
4523 }
4524
4525 STATIC void
4526 S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register char **env)
4527 {
4528     dVAR;
4529     GV* tmpgv;
4530
4531     PL_toptarget = NEWSV(0,0);
4532     sv_upgrade(PL_toptarget, SVt_PVFM);
4533     sv_setpvn(PL_toptarget, "", 0);
4534     PL_bodytarget = NEWSV(0,0);
4535     sv_upgrade(PL_bodytarget, SVt_PVFM);
4536     sv_setpvn(PL_bodytarget, "", 0);
4537     PL_formtarget = PL_bodytarget;
4538
4539     TAINT;
4540
4541     init_argv_symbols(argc,argv);
4542
4543     if ((tmpgv = gv_fetchpv("0",TRUE, SVt_PV))) {
4544 #ifdef MACOS_TRADITIONAL
4545         /* $0 is not majick on a Mac */
4546         sv_setpv(GvSV(tmpgv),MacPerl_MPWFileName(PL_origfilename));
4547 #else
4548         sv_setpv(GvSV(tmpgv),PL_origfilename);
4549         magicname("0", "0", 1);
4550 #endif
4551     }
4552     if ((PL_envgv = gv_fetchpv("ENV",TRUE, SVt_PVHV))) {
4553         HV *hv;
4554         GvMULTI_on(PL_envgv);
4555         hv = GvHVn(PL_envgv);
4556         hv_magic(hv, Nullgv, PERL_MAGIC_env);
4557 #ifndef PERL_MICRO
4558 #ifdef USE_ENVIRON_ARRAY
4559         /* Note that if the supplied env parameter is actually a copy
4560            of the global environ then it may now point to free'd memory
4561            if the environment has been modified since. To avoid this
4562            problem we treat env==NULL as meaning 'use the default'
4563         */
4564         if (!env)
4565             env = environ;
4566         if (env != environ
4567 #  ifdef USE_ITHREADS
4568             && PL_curinterp == aTHX
4569 #  endif
4570            )
4571         {
4572             environ[0] = Nullch;
4573         }
4574         if (env) {
4575           char** origenv = environ;
4576           char *s;
4577           SV *sv;
4578           for (; *env; env++) {
4579             if (!(s = strchr(*env,'=')) || s == *env)
4580                 continue;
4581 #if defined(MSDOS) && !defined(DJGPP)
4582             *s = '\0';
4583             (void)strupr(*env);
4584             *s = '=';
4585 #endif
4586             sv = newSVpv(s+1, 0);
4587             (void)hv_store(hv, *env, s - *env, sv, 0);
4588             if (env != environ)
4589                 mg_set(sv);
4590             if (origenv != environ) {
4591               /* realloc has shifted us */
4592               env = (env - origenv) + environ;
4593               origenv = environ;
4594             }
4595           }
4596       }
4597 #endif /* USE_ENVIRON_ARRAY */
4598 #endif /* !PERL_MICRO */
4599     }
4600     TAINT_NOT;
4601     if ((tmpgv = gv_fetchpv("$",TRUE, SVt_PV))) {
4602         SvREADONLY_off(GvSV(tmpgv));
4603         sv_setiv(GvSV(tmpgv), (IV)PerlProc_getpid());
4604         SvREADONLY_on(GvSV(tmpgv));
4605     }
4606 #ifdef THREADS_HAVE_PIDS
4607     PL_ppid = (IV)getppid();
4608 #endif
4609
4610     /* touch @F array to prevent spurious warnings 20020415 MJD */
4611     if (PL_minus_a) {
4612       (void) get_av("main::F", TRUE | GV_ADDMULTI);
4613     }
4614     /* touch @- and @+ arrays to prevent spurious warnings 20020415 MJD */
4615     (void) get_av("main::-", TRUE | GV_ADDMULTI);
4616     (void) get_av("main::+", TRUE | GV_ADDMULTI);
4617 }
4618
4619 STATIC void
4620 S_init_perllib(pTHX)
4621 {
4622     char *s;
4623     if (!PL_tainting) {
4624 #ifndef VMS
4625         s = PerlEnv_getenv("PERL5LIB");
4626 /*
4627  * It isn't possible to delete an environment variable with
4628  * PERL_USE_SAFE_PUTENV set unless unsetenv() is also available, so in that
4629  * case we treat PERL5LIB as undefined if it has a zero-length value.
4630  */
4631 #if defined(PERL_USE_SAFE_PUTENV) && ! defined(HAS_UNSETENV)
4632         if (s && *s != '\0')
4633 #else
4634         if (s)
4635 #endif
4636             incpush(s, TRUE, TRUE, TRUE, FALSE);
4637         else
4638             incpush(PerlEnv_getenv("PERLLIB"), FALSE, FALSE, TRUE, FALSE);
4639 #else /* VMS */
4640         /* Treat PERL5?LIB as a possible search list logical name -- the
4641          * "natural" VMS idiom for a Unix path string.  We allow each
4642          * element to be a set of |-separated directories for compatibility.
4643          */
4644         char buf[256];
4645         int idx = 0;
4646         if (my_trnlnm("PERL5LIB",buf,0))
4647             do { incpush(buf,TRUE,TRUE,TRUE,FALSE); } while (my_trnlnm("PERL5LIB",buf,++idx));
4648         else
4649             while (my_trnlnm("PERLLIB",buf,idx++)) incpush(buf,FALSE,FALSE,TRUE,FALSE);
4650 #endif /* VMS */
4651     }
4652
4653 /* Use the ~-expanded versions of APPLLIB (undocumented),
4654     ARCHLIB PRIVLIB SITEARCH SITELIB VENDORARCH and VENDORLIB
4655 */
4656 #ifdef APPLLIB_EXP
4657     incpush(APPLLIB_EXP, TRUE, TRUE, TRUE, TRUE);
4658 #endif
4659
4660 #ifdef ARCHLIB_EXP
4661     incpush(ARCHLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4662 #endif
4663 #ifdef MACOS_TRADITIONAL
4664     {
4665         Stat_t tmpstatbuf;
4666         SV * privdir = NEWSV(55, 0);
4667         char * macperl = PerlEnv_getenv("MACPERL");
4668
4669         if (!macperl)
4670             macperl = "";
4671
4672         Perl_sv_setpvf(aTHX_ privdir, "%slib:", macperl);
4673         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4674             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4675         Perl_sv_setpvf(aTHX_ privdir, "%ssite_perl:", macperl);
4676         if (PerlLIO_stat(SvPVX(privdir), &tmpstatbuf) >= 0 && S_ISDIR(tmpstatbuf.st_mode))
4677             incpush(SvPVX(privdir), TRUE, FALSE, TRUE, FALSE);
4678
4679         SvREFCNT_dec(privdir);
4680     }
4681     if (!PL_tainting)
4682         incpush(":", FALSE, FALSE, TRUE, FALSE);
4683 #else
4684 #ifndef PRIVLIB_EXP
4685 #  define PRIVLIB_EXP "/usr/local/lib/perl5:/usr/local/lib/perl"
4686 #endif
4687 #if defined(WIN32)
4688     incpush(PRIVLIB_EXP, TRUE, FALSE, TRUE, TRUE);
4689 #else
4690     incpush(PRIVLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4691 #endif
4692
4693 #ifdef SITEARCH_EXP
4694     /* sitearch is always relative to sitelib on Windows for
4695      * DLL-based path intuition to work correctly */
4696 #  if !defined(WIN32)
4697     incpush(SITEARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4698 #  endif
4699 #endif
4700
4701 #ifdef SITELIB_EXP
4702 #  if defined(WIN32)
4703     /* this picks up sitearch as well */
4704     incpush(SITELIB_EXP, TRUE, FALSE, TRUE, TRUE);
4705 #  else
4706     incpush(SITELIB_EXP, FALSE, FALSE, TRUE, TRUE);
4707 #  endif
4708 #endif
4709
4710 #ifdef SITELIB_STEM /* Search for version-specific dirs below here */
4711     incpush(SITELIB_STEM, FALSE, TRUE, TRUE, TRUE);
4712 #endif
4713
4714 #ifdef PERL_VENDORARCH_EXP
4715     /* vendorarch is always relative to vendorlib on Windows for
4716      * DLL-based path intuition to work correctly */
4717 #  if !defined(WIN32)
4718     incpush(PERL_VENDORARCH_EXP, FALSE, FALSE, TRUE, TRUE);
4719 #  endif
4720 #endif
4721
4722 #ifdef PERL_VENDORLIB_EXP
4723 #  if defined(WIN32)
4724     incpush(PERL_VENDORLIB_EXP, TRUE, FALSE, TRUE, TRUE);       /* this picks up vendorarch as well */
4725 #  else
4726     incpush(PERL_VENDORLIB_EXP, FALSE, FALSE, TRUE, TRUE);
4727 #  endif
4728 #endif
4729
4730 #ifdef PERL_VENDORLIB_STEM /* Search for version-specific dirs below here */
4731     incpush(PERL_VENDORLIB_STEM, FALSE, TRUE, TRUE, TRUE);
4732 #endif
4733
4734 #ifdef PERL_OTHERLIBDIRS
4735     incpush(PERL_OTHERLIBDIRS, TRUE, TRUE, TRUE, TRUE);
4736 #endif
4737
4738     if (!PL_tainting)
4739         incpush(".", FALSE, FALSE, TRUE, FALSE);
4740 #endif /* MACOS_TRADITIONAL */
4741 }
4742
4743 #if defined(DOSISH) || defined(EPOC) || defined(__SYMBIAN32__)
4744 #    define PERLLIB_SEP ';'
4745 #else
4746 #  if defined(VMS)
4747 #    define PERLLIB_SEP '|'
4748 #  else
4749 #    if defined(MACOS_TRADITIONAL)
4750 #      define PERLLIB_SEP ','
4751 #    else
4752 #      define PERLLIB_SEP ':'
4753 #    endif
4754 #  endif
4755 #endif
4756 #ifndef PERLLIB_MANGLE
4757 #  define PERLLIB_MANGLE(s,n) (s)
4758 #endif
4759
4760 /* Push a directory onto @INC if it exists.
4761    Generate a new SV if we do this, to save needing to copy the SV we push
4762    onto @INC  */
4763 STATIC SV *
4764 S_incpush_if_exists(pTHX_ SV *dir)
4765 {
4766     Stat_t tmpstatbuf;
4767     if (PerlLIO_stat(SvPVX_const(dir), &tmpstatbuf) >= 0 &&
4768         S_ISDIR(tmpstatbuf.st_mode)) {
4769         av_push(GvAVn(PL_incgv), dir);
4770         dir = NEWSV(0,0);
4771     }
4772     return dir;
4773 }
4774
4775 STATIC void
4776 S_incpush(pTHX_ const char *dir, bool addsubdirs, bool addoldvers, bool usesep,
4777           bool canrelocate)
4778 {
4779     SV *subdir = Nullsv;
4780     const char *p = dir;
4781
4782     if (!p || !*p)
4783         return;
4784
4785     if (addsubdirs || addoldvers) {
4786         subdir = NEWSV(0,0);
4787     }
4788
4789     /* Break at all separators */
4790     while (p && *p) {
4791         SV *libdir = NEWSV(55,0);
4792         const char *s;
4793
4794         /* skip any consecutive separators */
4795         if (usesep) {
4796             while ( *p == PERLLIB_SEP ) {
4797                 /* Uncomment the next line for PATH semantics */
4798                 /* av_push(GvAVn(PL_incgv), newSVpvn(".", 1)); */
4799                 p++;
4800             }
4801         }
4802
4803         if ( usesep && (s = strchr(p, PERLLIB_SEP)) != Nullch ) {
4804             sv_setpvn(libdir, PERLLIB_MANGLE(p, (STRLEN)(s - p)),
4805                       (STRLEN)(s - p));
4806             p = s + 1;
4807         }
4808         else {
4809             sv_setpv(libdir, PERLLIB_MANGLE(p, 0));
4810             p = Nullch; /* break out */
4811         }
4812 #ifdef MACOS_TRADITIONAL
4813         if (!strchr(SvPVX(libdir), ':')) {
4814             char buf[256];
4815
4816             sv_setpv(libdir, MacPerl_CanonDir(SvPVX(libdir), buf, 0));
4817         }
4818         if (SvPVX(libdir)[SvCUR(libdir)-1] != ':')
4819             sv_catpv(libdir, ":");
4820 #endif
4821
4822         /* Do the if() outside the #ifdef to avoid warnings about an unused
4823            parameter.  */
4824         if (canrelocate) {
4825 #ifdef PERL_RELOCATABLE_INC
4826         /*
4827          * Relocatable include entries are marked with a leading .../
4828          *
4829          * The algorithm is
4830          * 0: Remove that leading ".../"
4831          * 1: Remove trailing executable name (anything after the last '/')
4832          *    from the perl path to give a perl prefix
4833          * Then
4834          * While the @INC element starts "../" and the prefix ends with a real
4835          * directory (ie not . or ..) chop that real directory off the prefix
4836          * and the leading "../" from the @INC element. ie a logical "../"
4837          * cleanup
4838          * Finally concatenate the prefix and the remainder of the @INC element
4839          * The intent is that /usr/local/bin/perl and .../../lib/perl5
4840          * generates /usr/local/lib/perl5
4841          */
4842             const char *libpath = SvPVX(libdir);
4843             STRLEN libpath_len = SvCUR(libdir);
4844             if (libpath_len >= 4 && memEQ (libpath, ".../", 4)) {
4845                 /* Game on!  */
4846                 SV * const caret_X = get_sv("\030", 0);
4847                 /* Going to use the SV just as a scratch buffer holding a C
4848                    string:  */
4849                 SV *prefix_sv;
4850                 char *prefix;
4851                 char *lastslash;
4852
4853                 /* $^X is *the* source of taint if tainting is on, hence
4854                    SvPOK() won't be true.  */
4855                 assert(caret_X);
4856                 assert(SvPOKp(caret_X));
4857                 prefix_sv = newSVpvn(SvPVX(caret_X), SvCUR(caret_X));
4858                 /* Firstly take off the leading .../
4859                    If all else fail we'll do the paths relative to the current
4860                    directory.  */
4861                 sv_chop(libdir, libpath + 4);
4862                 /* Don't use SvPV as we're intentionally bypassing taining,
4863                    mortal copies that the mg_get of tainting creates, and
4864                    corruption that seems to come via the save stack.
4865                    I guess that the save stack isn't correctly set up yet.  */
4866                 libpath = SvPVX(libdir);
4867                 libpath_len = SvCUR(libdir);
4868
4869                 /* This would work more efficiently with memrchr, but as it's
4870                    only a GNU extension we'd need to probe for it and
4871                    implement our own. Not hard, but maybe not worth it?  */
4872
4873                 prefix = SvPVX(prefix_sv);
4874                 lastslash = strrchr(prefix, '/');
4875
4876                 /* First time in with the *lastslash = '\0' we just wipe off
4877                    the trailing /perl from (say) /usr/foo/bin/perl
4878                 */
4879                 if (lastslash) {
4880                     SV *tempsv;
4881                     while ((*lastslash = '\0'), /* Do that, come what may.  */
4882                            (libpath_len >= 3 && memEQ(libpath, "../", 3)
4883                             && (lastslash = strrchr(prefix, '/')))) {
4884                         if (lastslash[1] == '\0'
4885                             || (lastslash[1] == '.'
4886                                 && (lastslash[2] == '/' /* ends "/."  */
4887                                     || (lastslash[2] == '/'
4888                                         && lastslash[3] == '/' /* or "/.."  */
4889                                         )))) {
4890                             /* Prefix ends "/" or "/." or "/..", any of which
4891                                are fishy, so don't do any more logical cleanup.
4892                             */
4893                             break;
4894                         }
4895                         /* Remove leading "../" from path  */
4896                         libpath += 3;
4897                         libpath_len -= 3;
4898                         /* Next iteration round the loop removes the last
4899                            directory name from prefix by writing a '\0' in
4900                            the while clause.  */
4901                     }
4902                     /* prefix has been terminated with a '\0' to the correct
4903                        length. libpath points somewhere into the libdir SV.
4904                        We need to join the 2 with '/' and drop the result into
4905                        libdir.  */
4906                     tempsv = Perl_newSVpvf(aTHX_ "%s/%s", prefix, libpath);
4907                     SvREFCNT_dec(libdir);
4908                     /* And this is the new libdir.  */
4909                     libdir = tempsv;
4910                     if (PL_tainting &&
4911                         (PL_uid != PL_euid || PL_gid != PL_egid)) {
4912                         /* Need to taint reloccated paths if running set ID  */
4913                         SvTAINTED_on(libdir);
4914                     }
4915                 }
4916                 SvREFCNT_dec(prefix_sv);
4917             }
4918 #endif
4919         }
4920         /*
4921          * BEFORE pushing libdir onto @INC we may first push version- and
4922          * archname-specific sub-directories.
4923          */
4924         if (addsubdirs || addoldvers) {
4925 #ifdef PERL_INC_VERSION_LIST
4926             /* Configure terminates PERL_INC_VERSION_LIST with a NULL */
4927             const char * const incverlist[] = { PERL_INC_VERSION_LIST };
4928             const char * const *incver;
4929 #endif
4930 #ifdef VMS
4931             char *unix;
4932             STRLEN len;
4933
4934             if ((unix = tounixspec_ts(SvPV(libdir,len),Nullch)) != Nullch) {
4935                 len = strlen(unix);
4936                 while (unix[len-1] == '/') len--;  /* Cosmetic */
4937                 sv_usepvn(libdir,unix,len);
4938             }
4939             else
4940                 PerlIO_printf(Perl_error_log,
4941                               "Failed to unixify @INC element \"%s\"\n",
4942                               SvPV(libdir,len));
4943 #endif
4944             if (addsubdirs) {
4945 #ifdef MACOS_TRADITIONAL
4946 #define PERL_AV_SUFFIX_FMT      ""
4947 #define PERL_ARCH_FMT           "%s:"
4948 #define PERL_ARCH_FMT_PATH      PERL_FS_VER_FMT PERL_AV_SUFFIX_FMT
4949 #else
4950 #define PERL_AV_SUFFIX_FMT      "/"
4951 #define PERL_ARCH_FMT           "/%s"
4952 #define PERL_ARCH_FMT_PATH      PERL_AV_SUFFIX_FMT PERL_FS_VER_FMT
4953 #endif
4954                 /* .../version/archname if -d .../version/archname */
4955                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH PERL_ARCH_FMT,
4956                                 libdir,
4957                                (int)PERL_REVISION, (int)PERL_VERSION,
4958                                (int)PERL_SUBVERSION, ARCHNAME);
4959                 subdir = S_incpush_if_exists(aTHX_ subdir);
4960
4961                 /* .../version if -d .../version */
4962                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT_PATH, libdir,
4963                                (int)PERL_REVISION, (int)PERL_VERSION,
4964                                (int)PERL_SUBVERSION);
4965                 subdir = S_incpush_if_exists(aTHX_ subdir);
4966
4967                 /* .../archname if -d .../archname */
4968                 Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, ARCHNAME);
4969                 subdir = S_incpush_if_exists(aTHX_ subdir);
4970
4971             }
4972
4973 #ifdef PERL_INC_VERSION_LIST
4974             if (addoldvers) {
4975                 for (incver = incverlist; *incver; incver++) {
4976                     /* .../xxx if -d .../xxx */
4977                     Perl_sv_setpvf(aTHX_ subdir, "%"SVf PERL_ARCH_FMT, libdir, *incver);
4978                     subdir = S_incpush_if_exists(aTHX_ subdir);
4979                 }
4980             }
4981 #endif
4982         }
4983
4984         /* finally push this lib directory on the end of @INC */
4985         av_push(GvAVn(PL_incgv), libdir);
4986     }
4987     if (subdir) {
4988         assert (SvREFCNT(subdir) == 1);
4989         SvREFCNT_dec(subdir);
4990     }
4991 }
4992
4993 #ifdef USE_5005THREADS
4994 STATIC struct perl_thread *
4995 S_init_main_thread(pTHX)
4996 {
4997 #if !defined(PERL_IMPLICIT_CONTEXT)
4998     struct perl_thread *thr;
4999 #endif
5000     XPV *xpv;
5001
5002     Newxz(thr, 1, struct perl_thread);
5003     PL_curcop = &PL_compiling;
5004     thr->interp = PERL_GET_INTERP;
5005     thr->cvcache = newHV();
5006     thr->threadsv = newAV();
5007     /* thr->threadsvp is set when find_threadsv is called */
5008     thr->specific = newAV();
5009     thr->flags = THRf_R_JOINABLE;
5010     MUTEX_INIT(&thr->mutex);
5011     /* Handcraft thrsv similarly to mess_sv */
5012     Newx(PL_thrsv, 1, SV);
5013     Newxz(xpv, 1, XPV);
5014     SvFLAGS(PL_thrsv) = SVt_PV;
5015     SvANY(PL_thrsv) = (void*)xpv;
5016     SvREFCNT(PL_thrsv) = 1 << 30;       /* practically infinite */
5017     SvPV_set(PL_thrsvr, (char*)thr);
5018     SvCUR_set(PL_thrsv, sizeof(thr));
5019     SvLEN_set(PL_thrsv, sizeof(thr));
5020     *SvEND(PL_thrsv) = '\0';    /* in the trailing_nul field */
5021     thr->oursv = PL_thrsv;
5022     PL_chopset = " \n-";
5023     PL_dumpindent = 4;
5024
5025     MUTEX_LOCK(&PL_threads_mutex);
5026     PL_nthreads++;
5027     thr->tid = 0;
5028     thr->next = thr;
5029     thr->prev = thr;
5030     thr->thr_done = 0;
5031     MUTEX_UNLOCK(&PL_threads_mutex);
5032
5033 #ifdef HAVE_THREAD_INTERN
5034     Perl_init_thread_intern(thr);
5035 #endif
5036
5037 #ifdef SET_THREAD_SELF
5038     SET_THREAD_SELF(thr);
5039 #else
5040     thr->self = pthread_self();
5041 #endif /* SET_THREAD_SELF */
5042     PERL_SET_THX(thr);
5043
5044     /*
5045      * These must come after the thread self setting
5046      * because sv_setpvn does SvTAINT and the taint
5047      * fields thread selfness being set.
5048      */
5049     PL_toptarget = NEWSV(0,0);
5050     sv_upgrade(PL_toptarget, SVt_PVFM);
5051     sv_setpvn(PL_toptarget, "", 0);
5052     PL_bodytarget = NEWSV(0,0);
5053     sv_upgrade(PL_bodytarget, SVt_PVFM);
5054     sv_setpvn(PL_bodytarget, "", 0);
5055     PL_formtarget = PL_bodytarget;
5056     thr->errsv = newSVpvn("", 0);
5057     (void) find_threadsv("@");  /* Ensure $@ is initialised early */
5058
5059     PL_maxscream = -1;
5060     PL_peepp = MEMBER_TO_FPTR(Perl_peep);
5061     PL_regcompp = MEMBER_TO_FPTR(Perl_pregcomp);
5062     PL_regexecp = MEMBER_TO_FPTR(Perl_regexec_flags);
5063     PL_regint_start = MEMBER_TO_FPTR(Perl_re_intuit_start);
5064     PL_regint_string = MEMBER_TO_FPTR(Perl_re_intuit_string);
5065     PL_regfree = MEMBER_TO_FPTR(Perl_pregfree);
5066     PL_regindent = 0;
5067     PL_reginterp_cnt = 0;
5068
5069     return thr;
5070 }
5071 #endif /* USE_5005THREADS */
5072
5073 void
5074 Perl_call_list(pTHX_ I32 oldscope, AV *paramList)
5075 {
5076     dVAR;
5077     SV *atsv;
5078     const line_t oldline = CopLINE(PL_curcop);
5079     CV *cv;
5080     STRLEN len;
5081     int ret;
5082     dJMPENV;
5083
5084     while (av_len(paramList) >= 0) {
5085         cv = (CV*)av_shift(paramList);
5086         if (PL_savebegin) {
5087             if (paramList == PL_beginav) {
5088                 /* save PL_beginav for compiler */
5089                 if (! PL_beginav_save)
5090                     PL_beginav_save = newAV();
5091                 av_push(PL_beginav_save, (SV*)cv);
5092             }
5093             else if (paramList == PL_checkav) {
5094                 /* save PL_checkav for compiler */
5095                 if (! PL_checkav_save)
5096                     PL_checkav_save = newAV();
5097                 av_push(PL_checkav_save, (SV*)cv);
5098             }
5099         } else {
5100             SAVEFREESV(cv);
5101         }
5102         JMPENV_PUSH(ret);
5103         switch (ret) {
5104         case 0:
5105             call_list_body(cv);
5106             atsv = ERRSV;
5107             (void)SvPV_const(atsv, len);
5108             if (len) {
5109                 PL_curcop = &PL_compiling;
5110                 CopLINE_set(PL_curcop, oldline);
5111                 if (paramList == PL_beginav)
5112                     sv_catpv(atsv, "BEGIN failed--compilation aborted");
5113                 else
5114                     Perl_sv_catpvf(aTHX_ atsv,
5115                                    "%s failed--call queue aborted",
5116                                    paramList == PL_checkav ? "CHECK"
5117                                    : paramList == PL_initav ? "INIT"
5118                                    : "END");
5119                 while (PL_scopestack_ix > oldscope)
5120                     LEAVE;
5121                 JMPENV_POP;
5122                 Perl_croak(aTHX_ "%"SVf"", atsv);
5123             }
5124             break;
5125         case 1:
5126             STATUS_ALL_FAILURE;
5127             /* FALL THROUGH */
5128         case 2:
5129             /* my_exit() was called */
5130             while (PL_scopestack_ix > oldscope)
5131                 LEAVE;
5132             FREETMPS;
5133             PL_curstash = PL_defstash;
5134             PL_curcop = &PL_compiling;
5135             CopLINE_set(PL_curcop, oldline);
5136             JMPENV_POP;
5137             if (PL_statusvalue && !(PL_exit_flags & PERL_EXIT_EXPECTED)) {
5138                 if (paramList == PL_beginav)
5139                     Perl_croak(aTHX_ "BEGIN failed--compilation aborted");
5140                 else
5141                     Perl_croak(aTHX_ "%s failed--call queue aborted",
5142                                paramList == PL_checkav ? "CHECK"
5143                                : paramList == PL_initav ? "INIT"
5144                                : "END");
5145             }
5146             my_exit_jump();
5147             /* NOTREACHED */
5148         case 3:
5149             if (PL_restartop) {
5150                 PL_curcop = &PL_compiling;
5151                 CopLINE_set(PL_curcop, oldline);
5152                 JMPENV_JUMP(3);
5153             }
5154             PerlIO_printf(Perl_error_log, "panic: restartop\n");
5155             FREETMPS;
5156             break;
5157         }
5158         JMPENV_POP;
5159     }
5160 }
5161
5162 STATIC void *
5163 S_call_list_body(pTHX_ CV *cv)
5164 {
5165     PUSHMARK(PL_stack_sp);
5166     call_sv((SV*)cv, G_EVAL|G_DISCARD);
5167     return NULL;
5168 }
5169
5170 void
5171 Perl_my_exit(pTHX_ U32 status)
5172 {
5173     DEBUG_S(PerlIO_printf(Perl_debug_log, "my_exit: thread %p, status %lu\n",
5174                           thr, (unsigned long) status));
5175     switch (status) {
5176     case 0:
5177         STATUS_ALL_SUCCESS;
5178         break;
5179     case 1:
5180         STATUS_ALL_FAILURE;
5181         break;
5182     default:
5183         STATUS_EXIT_SET(status);
5184         break;
5185     }
5186     my_exit_jump();
5187 }
5188
5189 void
5190 Perl_my_failure_exit(pTHX)
5191 {
5192 #ifdef VMS
5193      /* We have been called to fall on our sword.  The desired exit code
5194       * should be already set in STATUS_UNIX, but could be shifted over
5195       * by 8 bits.  STATUS_UNIX_EXIT_SET will handle the cases where a
5196       * that code is set.
5197       *
5198       * If an error code has not been set, then force the issue.
5199       */
5200     if (MY_POSIX_EXIT) {
5201
5202         /* In POSIX_EXIT mode follow Perl documentations and use 255 for
5203          * the exit code when there isn't an error.
5204          */
5205
5206         if (STATUS_UNIX == 0)
5207             STATUS_UNIX_EXIT_SET(255);
5208         else {
5209             STATUS_UNIX_EXIT_SET(STATUS_UNIX);
5210
5211             /* The exit code could have been set by $? or vmsish which
5212              * means that it may not be fatal.  So convert
5213              * success/warning codes to fatal.
5214              */
5215             if ((STATUS_NATIVE & (STS$K_SEVERE|STS$K_ERROR)) == 0)
5216                 STATUS_UNIX_EXIT_SET(255);
5217         }
5218     }
5219     else {
5220         /* Traditionally Perl on VMS always expects a Fatal Error. */
5221         if (vaxc$errno & 1) {
5222
5223             /* So force success status to failure */
5224             if (STATUS_NATIVE & 1)
5225                 STATUS_ALL_FAILURE;
5226         }
5227         else {
5228             if (!vaxc$errno) {
5229                 STATUS_UNIX = EINTR; /* In case something cares */
5230                 STATUS_ALL_FAILURE;
5231             }
5232             else {
5233                 int severity;
5234                 STATUS_NATIVE = vaxc$errno; /* Should already be this */
5235
5236                 /* Encode the severity code */
5237                 severity = STATUS_NATIVE & STS$M_SEVERITY;
5238                 STATUS_UNIX = (severity ? severity : 1) << 8;
5239
5240                 /* Perl expects this to be a fatal error */
5241                 if (severity != STS$K_SEVERE)
5242                     STATUS_ALL_FAILURE;
5243             }
5244         }
5245     }
5246
5247 #else
5248     int exitstatus;
5249     if (errno & 255)
5250         STATUS_UNIX_SET(errno);
5251     else {
5252         exitstatus = STATUS_UNIX >> 8;
5253         if (exitstatus & 255)
5254             STATUS_UNIX_SET(exitstatus);
5255         else
5256             STATUS_UNIX_SET(255);
5257     }
5258 #endif
5259     my_exit_jump();
5260 }
5261
5262 STATIC void
5263 S_my_exit_jump(pTHX)
5264 {
5265     dVAR;
5266     register PERL_CONTEXT *cx;
5267     I32 gimme;
5268     SV **newsp;
5269
5270     if (PL_e_script) {
5271         SvREFCNT_dec(PL_e_script);
5272         PL_e_script = Nullsv;
5273     }
5274
5275     POPSTACK_TO(PL_mainstack);
5276     if (cxstack_ix >= 0) {
5277         if (cxstack_ix > 0)
5278             dounwind(0);
5279         POPBLOCK(cx,PL_curpm);
5280         LEAVE;
5281     }
5282
5283     JMPENV_JUMP(2);
5284     PERL_UNUSED_VAR(gimme);
5285     PERL_UNUSED_VAR(newsp);
5286 }
5287
5288 static I32
5289 read_e_script(pTHX_ int idx, SV *buf_sv, int maxlen)
5290 {
5291     const char * const p  = SvPVX_const(PL_e_script);
5292     const char *nl = strchr(p, '\n');
5293
5294     PERL_UNUSED_ARG(idx);
5295     PERL_UNUSED_ARG(maxlen);
5296
5297     nl = (nl) ? nl+1 : SvEND(PL_e_script);
5298     if (nl-p == 0) {
5299         filter_del(read_e_script);
5300         return 0;
5301     }
5302     sv_catpvn(buf_sv, p, nl-p);
5303     sv_chop(PL_e_script, nl);
5304     return 1;
5305 }
5306
5307 /*
5308  * Local variables:
5309  * c-indentation-style: bsd
5310  * c-basic-offset: 4
5311  * indent-tabs-mode: t
5312  * End:
5313  *
5314  * ex: set ts=8 sts=4 sw=4 noet:
5315  */