perl.c

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