home *** CD-ROM | disk | FTP | other *** search
- NAME
- perlrun - how to execute the Perl interpreter
-
- SYNOPSIS
- perl [ -sTuU ] [ -hv ] [ -V[:*configvar*] ] [ -cw ] [
- -d[:*debugger*] ] [ -D[*number/list*] ] [ -pna ] [ -F*pattern* ]
- [ -l[*octal*] ] [ -0[*octal*] ] [ -I*dir* ] [ -m[-]*module* ] [
- -M[-]*'module...'* ] [ -P ] [ -S ] [ -x[*dir*] ] [
- -i[*extension*] ] [ -e *'command'* ] [ -- ] [ *programfile* ] [
- *argument* ]...
-
- DESCRIPTION
- Upon startup, Perl looks for your script in one of the following
- places:
-
- 1. Specified line by line via -e switches on the command line.
-
- 2. Contained in the file specified by the first filename on the
- command line. (Note that systems supporting the #! notation
- invoke interpreters this way. See the Location of Perl
- manpage.)
-
- 3. Passed in implicitly via standard input. This works only if
- there are no filename arguments--to pass arguments to a
- STDIN script you must explicitly specify a "-" for the
- script name.
-
-
- With methods 2 and 3, Perl starts parsing the input file from
- the beginning, unless you've specified a -x switch, in which
- case it scans for the first line starting with #! and containing
- the word "perl", and starts there instead. This is useful for
- running a script embedded in a larger message. (In this case you
- would indicate the end of the script using the `__END__' token.)
-
- The #! line is always examined for switches as the line is being
- parsed. Thus, if you're on a machine that allows only one
- argument with the #! line, or worse, doesn't even recognize the
- #! line, you still can get consistent switch behavior regardless
- of how Perl was invoked, even if -x was used to find the
- beginning of the script.
-
- Because many operating systems silently chop off kernel
- interpretation of the #! line after 32 characters, some switches
- may be passed in on the command line, and some may not; you
- could even get a "-" without its letter, if you're not careful.
- You probably want to make sure that all your switches fall
- either before or after that 32 character boundary. Most switches
- don't actually care if they're processed redundantly, but
- getting a - instead of a complete switch could cause Perl to try
- to execute standard input instead of your script. And a partial
- -I switch could also cause odd results.
-
- Some switches do care if they are processed twice, for instance
- combinations of -l and -0. Either put all the switches after the
- 32 character boundary (if applicable), or replace the use of -
- 0*digits* by `BEGIN{ $/ = "\0digits"; }'.
-
- Parsing of the #! switches starts wherever "perl" is mentioned
- in the line. The sequences "-*" and "- " are specifically
- ignored so that you could, if you were so inclined, say
-
- #!/bin/sh -- # -*- perl -*- -p
- eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
- if $running_under_some_shell;
-
-
- to let Perl see the -p switch.
-
- If the #! line does not contain the word "perl", the program
- named after the #! is executed instead of the Perl interpreter.
- This is slightly bizarre, but it helps people on machines that
- don't do #!, because they can tell a program that their SHELL is
- /usr/bin/perl, and Perl will then dispatch the program to the
- correct interpreter for them.
-
- After locating your script, Perl compiles the entire script to
- an internal form. If there are any compilation errors, execution
- of the script is not attempted. (This is unlike the typical
- shell script, which might run part-way through before finding a
- syntax error.)
-
- If the script is syntactically correct, it is executed. If the
- script runs off the end without hitting an exit() or die()
- operator, an implicit `exit(0)' is provided to indicate
- successful completion.
-
- #! and quoting on non-Unix systems
-
- Unix's #! technique can be simulated on other systems:
-
- OS/2
- Put
-
- extproc perl -S -your_switches
-
-
- as the first line in `*.cmd' file (`-S' due to a bug in
- cmd.exe's `extproc' handling).
-
- MS-DOS
- Create a batch file to run your script, and codify it in
- `ALTERNATIVE_SHEBANG' (see the dosish.h file in the source
- distribution for more information).
-
- Win95/NT
- The Win95/NT installation, when using the Activeware port of
- Perl, will modify the Registry to associate the .pl
- extension with the perl interpreter. If you install another
- port of Perl, including the one in the Win32 directory of
- the Perl distribution, then you'll have to modify the
- Registry yourself. Note that this means you can no longer
- tell the difference between an executable Perl program and a
- Perl library file.
-
- Macintosh
- Macintosh perl scripts will have the appropriate Creator and
- Type, so that double-clicking them will invoke the perl
- application.
-
- VMS Put
-
- $ perl -mysw 'f$env("procedure")' 'p1' 'p2' 'p3' 'p4' 'p5' 'p6' 'p7' 'p8' !
- $ exit++ + ++$status != 0 and $exit = $status = undef;
-
-
- at the top of your script, where `-mysw' are any command
- line switches you want to pass to Perl. You can now invoke
- the script directly, by saying `perl script', or as a DCL
- procedure, by saying `@script' (or implicitly via DCL$PATH
- by just using the name of the script).
-
- This incantation is a bit much to remember, but Perl will
- display it for you if you say `perl "-V:startperl"'.
-
-
- Command-interpreters on non-Unix systems have rather different
- ideas on quoting than Unix shells. You'll need to learn the
- special characters in your command-interpreter (`*', `\' and `"'
- are common) and how to protect whitespace and these characters
- to run one-liners (see `-e' below).
-
- On some systems, you may have to change single-quotes to double
- ones, which you must *NOT* do on Unix or Plan9 systems. You
- might also have to change a single % to a %%.
-
- For example:
-
- # Unix
- perl -e 'print "Hello world\n"'
-
- # MS-DOS, etc.
- perl -e "print \"Hello world\n\""
-
- # Macintosh
- print "Hello world\n"
- (then Run "Myscript" or Shift-Command-R)
-
- # VMS
- perl -e "print ""Hello world\n"""
-
-
- The problem is that none of this is reliable: it depends on the
- command and it is entirely possible neither works. If 4DOS was
- the command shell, this would probably work better:
-
- perl -e "print <Ctrl-x>"Hello world\n<Ctrl-x>""
-
-
- CMD.EXE in Windows NT slipped a lot of standard Unix
- functionality in when nobody was looking, but just try to find
- documentation for its quoting rules.
-
- Under the Macintosh, it depends which environment you are using.
- The MacPerl shell, or MPW, is much like Unix shells in its
- support for several quoting variants, except that it makes free
- use of the Macintosh's non-ASCII characters as control
- characters.
-
- There is no general solution to all of this. It's just a mess.
-
- Location of Perl
-
- It may seem obvious to say, but Perl is useful only when users
- can easily find it. When possible, it's good for both
- /usr/bin/perl and /usr/local/bin/perl to be symlinks to the
- actual binary. If that can't be done, system administrators are
- strongly encouraged to put (symlinks to) perl and its
- accompanying utilities, such as perldoc, into a directory
- typically found along a user's PATH, or in another obvious and
- convenient place.
-
- In this documentation, `#!/usr/bin/perl' on the first line of
- the script will stand in for whatever method works on your
- system.
-
- Switches
-
- A single-character switch may be combined with the following
- switch, if any.
-
- #!/usr/bin/perl -spi.bak # same as -s -p -i.bak
-
-
- Switches include:
-
- -0[*digits*]
- specifies the input record separator (`$/') as an octal
- number. If there are no digits, the null character is the
- separator. Other switches may precede or follow the digits.
- For example, if you have a version of find which can print
- filenames terminated by the null character, you can say
- this:
-
- find . -name '*.bak' -print0 | perl -n0e unlink
-
-
- The special value 00 will cause Perl to slurp files in
- paragraph mode. The value 0777 will cause Perl to slurp
- files whole because there is no legal character with that
- value.
-
- -a turns on autosplit mode when used with a -n or -p. An implicit
- split command to the @F array is done as the first thing
- inside the implicit while loop produced by the -n or -p.
-
- perl -ane 'print pop(@F), "\n";'
-
-
- is equivalent to
-
- while (<>) {
- @F = split(' ');
- print pop(@F), "\n";
- }
-
-
- An alternate delimiter may be specified using -F.
-
- -c causes Perl to check the syntax of the script and then exit
- without executing it. Actually, it *will* execute `BEGIN',
- `END', and `use' blocks, because these are considered as
- occurring outside the execution of your program.
-
- -d runs the script under the Perl debugger. See the perldebug
- manpage.
-
- -d:*foo*
- runs the script under the control of a debugging or tracing
- module installed as Devel::foo. E.g., -d:DProf executes the
- script using the Devel::DProf profiler. See the perldebug
- manpage.
-
- -D*letters*
-
- -D*number*
- sets debugging flags. To watch how it executes your script,
- use -Dtls. (This works only if debugging is compiled into
- your Perl.) Another nice value is -Dx, which lists your
- compiled syntax tree. And -Dr displays compiled regular
- expressions. As an alternative, specify a number instead of
- list of letters (e.g., -D14 is equivalent to -Dtls):
-
- 1 p Tokenizing and parsing
- 2 s Stack snapshots
- 4 l Context (loop) stack processing
- 8 t Trace execution
- 16 o Method and overloading resolution
- 32 c String/numeric conversions
- 64 P Print preprocessor command for -P
- 128 m Memory allocation
- 256 f Format processing
- 512 r Regular expression parsing and execution
- 1024 x Syntax tree dump
- 2048 u Tainting checks
- 4096 L Memory leaks (needs C<-DLEAKTEST> when compiling Perl)
- 8192 H Hash dump -- usurps values()
- 16384 X Scratchpad allocation
- 32768 D Cleaning up
- 65536 S Thread synchronization
-
-
- All these flags require `-DDEBUGGING' when you compile the
- Perl executable. This flag is automatically set if you
- include `-g' option when `Configure' asks you about
- optimizer/debugger flags.
-
- -e *commandline*
- may be used to enter one line of script. If -e is given,
- Perl will not look for a script filename in the argument
- list. Multiple -e commands may be given to build up a
- multi-line script. Make sure to use semicolons where you
- would in a normal program.
-
- -F*pattern*
- specifies the pattern to split on if -a is also in effect.
- The pattern may be surrounded by `//', `""', or `''',
- otherwise it will be put in single quotes.
-
- -h prints a summary of the options.
-
- -i[*extension*]
- specifies that files processed by the `<>' construct are to
- be edited in-place. It does this by renaming the input
- file, opening the output file by the original name, and
- selecting that output file as the default for print()
- statements. The extension, if supplied, is used to modify
- the name of the old file to make a backup copy, following
- these rules:
-
- If no extension is supplied, no backup is made and the
- current file is overwritten.
-
- If the extension doesn't contain a `*' then it is appended
- to the end of the current filename as a suffix.
-
- If the extension does contain one or more `*' characters,
- then each `*' is replaced with the current filename. In
- perl terms you could think of this as:
-
- ($backup = $extension) =~ s/\*/$file_name/g;
-
-
- This allows you to add a prefix to the backup file, instead
- of (or in addition to) a suffix:
-
- $ perl -pi'bak_*' -e 's/bar/baz/' fileA # backup to 'bak_fileA'
-
-
- Or even to place backup copies of the original files into
- another directory (provided the directory already exists):
-
- $ perl -pi'old/*.bak' -e 's/bar/baz/' fileA # backup to 'old/fileA.bak'
-
-
- These sets of one-liners are equivalent:
-
- $ perl -pi -e 's/bar/baz/' fileA # overwrite current file
- $ perl -pi'*' -e 's/bar/baz/' fileA # overwrite current file
-
- $ perl -pi'.bak' -e 's/bar/baz/' fileA # backup to 'fileA.bak'
- $ perl -pi'*.bak' -e 's/bar/baz/' fileA # backup to 'fileA.bak'
-
-
- From the shell, saying
-
- $ perl -p -i.bak -e "s/foo/bar/; ... "
-
-
- is the same as using the script:
-
- #!/usr/bin/perl -pi.bak
- s/foo/bar/;
-
-
- which is equivalent to
-
- #!/usr/bin/perl
- $extension = '.bak';
- while (<>) {
- if ($ARGV ne $oldargv) {
- if ($extension !~ /\*/) {
- $backup = $ARGV . $extension;
- }
- else {
- ($backup = $extension) =~ s/\*/$ARGV/g;
- }
- rename($ARGV, $backup);
- open(ARGVOUT, ">$ARGV");
- select(ARGVOUT);
- $oldargv = $ARGV;
- }
- s/foo/bar/;
- }
- continue {
- print; # this prints to original filename
- }
- select(STDOUT);
-
-
- except that the -i form doesn't need to compare $ARGV to
- $oldargv to know when the filename has changed. It does,
- however, use ARGVOUT for the selected filehandle. Note that
- STDOUT is restored as the default output filehandle after
- the loop.
-
- As shown above, Perl creates the backup file whether or not
- any output is actually changed. So this is just a fancy way
- to copy files:
-
- $ perl -p -i'/some/file/path/*' -e 1 file1 file2 file3...
- or
- $ perl -p -i'.bak' -e 1 file1 file2 file3...
-
-
- You can use `eof' without parentheses to locate the end of
- each input file, in case you want to append to each file,
- or reset line numbering (see example in the "eof" entry in
- the perlfunc manpage).
-
- If, for a given file, Perl is unable to create the backup
- file as specified in the extension then it will skip that
- file and continue on with the next one (if it exists).
-
- For a discussion of issues surrounding file permissions and
- `-i', see the "Why does Perl let me delete read-only files?
- Why does -i clobber protected files? Isn't this a bug in
- Perl?" entry in the perlfaq5 manpage.
-
- You cannot use -i to create directories or to strip
- extensions from files.
-
- Perl does not expand `~', so don't do that.
-
- Finally, note that the -i switch does not impede execution
- when no files are given on the command line. In this case,
- no backup is made (the original file cannot, of course, be
- determined) and processing proceeds from STDIN to STDOUT as
- might be expected.
-
- -I*directory*
- Directories specified by -I are prepended to the search
- path for modules (`@INC'), and also tells the C
- preprocessor where to search for include files. The C
- preprocessor is invoked with -P; by default it searches
- /usr/include and /usr/lib/perl.
-
- -l[*octnum*]
- enables automatic line-ending processing. It has two
- effects: first, it automatically chomps "`$/'" (the input
- record separator) when used with -n or -p, and second, it
- assigns "`$\'" (the output record separator) to have the
- value of *octnum* so that any print statements will have
- that separator added back on. If *octnum* is omitted, sets
- "`$\'" to the current value of "`$/'". For instance, to
- trim lines to 80 columns:
-
- perl -lpe 'substr($_, 80) = ""'
-
-
- Note that the assignment `$\ = $/' is done when the switch
- is processed, so the input record separator can be
- different than the output record separator if the -l switch
- is followed by a -0 switch:
-
- gnufind / -print0 | perl -ln0e 'print "found $_" if -p'
-
-
- This sets `$\' to newline and then sets `$/' to the null
- character.
-
- -m[-]*module*
-
- -M[-]*module*
-
- -M[-]*'module ...'*
-
- -[mM][-]*module=arg[,arg]...*
- `-m'*module* executes `use' *module* `();' before executing
- your script.
-
- `-M'*module* executes `use' *module* `;' before executing
- your script. You can use quotes to add extra code after the
- module name, e.g., `-M'module qw(foo bar)''.
-
- If the first character after the `-M' or `-m' is a dash (`-
- ') then the 'use' is replaced with 'no'.
-
- A little builtin syntactic sugar means you can also say `-
- mmodule=foo,bar' or `-Mmodule=foo,bar' as a shortcut for `-
- M'module qw(foo bar)''. This avoids the need to use quotes
- when importing symbols. The actual code generated by `-
- Mmodule=foo,bar' is `use module split(/,/,q{foo,bar})'.
- Note that the `=' form removes the distinction between `-m'
- and `-M'.
-
- -n causes Perl to assume the following loop around your script,
- which makes it iterate over filename arguments somewhat
- like sed -n or awk:
-
- while (<>) {
- ... # your script goes here
- }
-
-
- Note that the lines are not printed by default. See -p to
- have lines printed. If a file named by an argument cannot
- be opened for some reason, Perl warns you about it, and
- moves on to the next file.
-
- Here is an efficient way to delete all files older than a
- week:
-
- find . -mtime +7 -print | perl -nle 'unlink;'
-
-
- This is faster than using the `-exec' switch of find
- because you don't have to start a process on every filename
- found.
-
- `BEGIN' and `END' blocks may be used to capture control
- before or after the implicit loop, just as in awk.
-
- -p causes Perl to assume the following loop around your script,
- which makes it iterate over filename arguments somewhat
- like sed:
-
- while (<>) {
- ... # your script goes here
- } continue {
- print or die "-p destination: $!\n";
- }
-
-
- If a file named by an argument cannot be opened for some
- reason, Perl warns you about it, and moves on to the next
- file. Note that the lines are printed automatically. An
- error occurring during printing is treated as fatal. To
- suppress printing use the -n switch. A -p overrides a -n
- switch.
-
- `BEGIN' and `END' blocks may be used to capture control
- before or after the implicit loop, just as in awk.
-
- -P causes your script to be run through the C preprocessor before
- compilation by Perl. (Because both comments and cpp
- directives begin with the # character, you should avoid
- starting comments with any words recognized by the C
- preprocessor such as "if", "else", or "define".)
-
- -s enables some rudimentary switch parsing for switches on the
- command line after the script name but before any filename
- arguments (or before a --). Any switch found there is
- removed from @ARGV and sets the corresponding variable in
- the Perl script. The following script prints "true" if and
- only if the script is invoked with a -xyz switch.
-
- #!/usr/bin/perl -s
- if ($xyz) { print "true\n"; }
-
-
- -S makes Perl use the PATH environment variable to search for the
- script (unless the name of the script contains directory
- separators). On some platforms, this also makes Perl append
- suffixes to the filename while searching for it. For
- example, on Win32 platforms, the ".bat" and ".cmd" suffixes
- are appended if a lookup for the original name fails, and
- if the name does not already end in one of those suffixes.
- If your Perl was compiled with DEBUGGING turned on, using
- the -Dp switch to Perl shows how the search progresses.
-
- If the filename supplied contains directory separators
- (i.e. it is an absolute or relative pathname), and if the
- file is not found, platforms that append file extensions
- will do so and try to look for the file with those
- extensions added, one by one.
-
- On DOS-like platforms, if the script does not contain
- directory separators, it will first be searched for in the
- current directory before being searched for on the PATH. On
- Unix platforms, the script will be searched for strictly on
- the PATH.
-
- Typically this is used to emulate #! startup on platforms
- that don't support #!. This example works on many platforms
- that have a shell compatible with Bourne shell:
-
- #!/usr/bin/perl
- eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
- if $running_under_some_shell;
-
-
- The system ignores the first line and feeds the script to
- /bin/sh, which proceeds to try to execute the Perl script
- as a shell script. The shell executes the second line as a
- normal shell command, and thus starts up the Perl
- interpreter. On some systems $0 doesn't always contain the
- full pathname, so the -S tells Perl to search for the
- script if necessary. After Perl locates the script, it
- parses the lines and ignores them because the variable
- $running_under_some_shell is never true. If the script will
- be interpreted by csh, you will need to replace `${1+"$@"}'
- with `$*', even though that doesn't understand embedded
- spaces (and such) in the argument list. To start up sh
- rather than csh, some systems may have to replace the #!
- line with a line containing just a colon, which will be
- politely ignored by Perl. Other systems can't control that,
- and need a totally devious construct that will work under
- any of csh, sh, or Perl, such as the following:
-
- eval '(exit $?0)' && eval 'exec /usr/bin/perl -wS $0 ${1+"$@"}'
- & eval 'exec /usr/bin/perl -wS $0 $argv:q'
- if $running_under_some_shell;
-
-
- -T forces "taint" checks to be turned on so you can test them.
- Ordinarily these checks are done only when running setuid
- or setgid. It's a good idea to turn them on explicitly for
- programs run on another's behalf, such as CGI programs. See
- the perlsec manpage. Note that (for security reasons) this
- option must be seen by Perl quite early; usually this means
- it must appear early on the command line or in the #! line
- (for systems which support that).
-
- -u causes Perl to dump core after compiling your script. You can
- then in theory take this core dump and turn it into an
- executable file by using the undump program (not supplied).
- This speeds startup at the expense of some disk space
- (which you can minimize by stripping the executable).
- (Still, a "hello world" executable comes out to about 200K
- on my machine.) If you want to execute a portion of your
- script before dumping, use the dump() operator instead.
- Note: availability of undump is platform specific and may
- not be available for a specific port of Perl. It has been
- superseded by the new perl-to-C compiler, which is more
- portable, even though it's still only considered beta.
-
- -U allows Perl to do unsafe operations. Currently the only
- "unsafe" operations are the unlinking of directories while
- running as superuser, and running setuid programs with
- fatal taint checks turned into warnings. Note that the -w
- switch (or the `$^W' variable) must be used along with this
- option to actually generate the taint-check warnings.
-
- -v prints the version and patchlevel of your Perl executable.
-
- -V prints summary of the major perl configuration values and the
- current value of @INC.
-
- -V:*name*
- Prints to STDOUT the value of the named configuration
- variable.
-
- -w prints warnings about variable names that are mentioned only
- once, and scalar variables that are used before being set.
- Also warns about redefined subroutines, and references to
- undefined filehandles or filehandles opened read-only that
- you are attempting to write on. Also warns you if you use
- values as a number that doesn't look like numbers, using an
- array as though it were a scalar, if your subroutines
- recurse more than 100 deep, and innumerable other things.
-
- You can disable specific warnings using `__WARN__' hooks,
- as described in the perlvar manpage and the "warn" entry in
- the perlfunc manpage. See also the perldiag manpage and the
- perltrap manpage.
-
- -x *directory*
- tells Perl that the script is embedded in a message.
- Leading garbage will be discarded until the first line that
- starts with #! and contains the string "perl". Any
- meaningful switches on that line will be applied. If a
- directory name is specified, Perl will switch to that
- directory before running the script. The -x switch controls
- only the disposal of leading garbage. The script must be
- terminated with `__END__' if there is trailing garbage to
- be ignored (the script can process any or all of the
- trailing garbage via the DATA filehandle if desired).
-
-
- ENVIRONMENT
- HOME Used if chdir has no argument.
-
- LOGDIR Used if chdir has no argument and HOME is not set.
-
- PATH Used in executing subprocesses, and in finding the
- script if -S is used.
-
- PERL5LIB A colon-separated list of directories in which to look
- for Perl library files before looking in the
- standard library and the current directory. If
- PERL5LIB is not defined, PERLLIB is used. When
- running taint checks (because the script was running
- setuid or setgid, or the -T switch was used),
- neither variable is used. The script should instead
- say
-
- use lib "/my/directory";
-
-
- PERL5OPT Command-line options (switches). Switches in this
- variable are taken as if they were on every Perl
- command line. Only the -[DIMUdmw] switches are
- allowed. When running taint checks (because the
- script was running setuid or setgid, or the -T
- switch was used), this variable is ignored. If
- PERL5OPT begins with -T, tainting will be enabled,
- and any subsequent options ignored.
-
- PERLLIB A colon-separated list of directories in which to look
- for Perl library files before looking in the
- standard library and the current directory. If
- PERL5LIB is defined, PERLLIB is not used.
-
- PERL5DB The command used to load the debugger code. The default
- is:
-
- BEGIN { require 'perl5db.pl' }
-
-
- PERL5SHELL (specific to WIN32 port)
- May be set to an alternative shell that perl must
- use internally for executing "backtick" commands or
- system(). Default is `cmd.exe /x/c' on WindowsNT and
- `command.com /c' on Windows95. The value is
- considered to be space delimited. Precede any
- character that needs to be protected (like a space
- or backslash) with a backslash.
-
- Note that Perl doesn't use COMSPEC for this purpose
- because COMSPEC has a high degree of variability
- among users, leading to portability concerns.
- Besides, perl can use a shell that may not be fit
- for interactive use, and setting COMSPEC to such a
- shell may interfere with the proper functioning of
- other programs (which usually look in COMSPEC to
- find a shell fit for interactive use).
-
- PERL_DEBUG_MSTATS
- Relevant only if perl is compiled with the malloc
- included with the perl distribution (that is, if
- `perl -V:d_mymalloc' is 'define'). If set, this
- causes memory statistics to be dumped after
- execution. If set to an integer greater than one,
- also causes memory statistics to be dumped after
- compilation.
-
- PERL_DESTRUCT_LEVEL
- Relevant only if your perl executable was built with
- -DDEBUGGING, this controls the behavior of global
- destruction of objects and other references.
-
-
- Perl also has environment variables that control how Perl
- handles data specific to particular natural languages. See the
- perllocale manpage.
-
- Apart from these, Perl uses no other environment variables,
- except to make them available to the script being executed, and
- to child processes. However, scripts running setuid would do
- well to execute the following lines before doing anything else,
- just to keep people honest:
-
- $ENV{PATH} = '/bin:/usr/bin'; # or whatever you need
- $ENV{SHELL} = '/bin/sh' if exists $ENV{SHELL};
- delete @ENV{qw(IFS CDPATH ENV BASH_ENV)};
-
-