What is the significance of -T or -w in #!/usr/bin/perl?

Question

I googled about #!/usr/bin/perl, but I could not find any satisfactory answer. I know it’s a pretty basic thing, but still, could explain me what is the significance of #!/usr/bin/perl in Perl? Moreover, what does -w or -T signify in #!/usr/bin/perl? I am a newbie to Perl, so please be patient.

Colyer

#!/usr/bin/perl is called shebang line. -w for warnings.-T for Taint mode. – Oily

-w hasn't been recommended for many years. Since Perl 5.6.0 we've had use warnings which is more powerful and more flexible. – Telethon

Answer 1

The #! is commonly called a "shebang" and it tells the computer how to run a script. You'll also see lots of shell-scripts with #!/bin/sh or #!/bin/bash.

So, /usr/bin/perl is your Perl interpreter and it is run and given the file to execute.

The rest of the line are options for Perl. The "-T" is tainting (it means input is marked as "not trusted" until you check it's format). The "-w" turns warnings on.

You can find out more by running perldoc perlrun (perldoc is Perl's documentation reader, might be installed, might be in its own package).

For scripts you write I would recommend starting them with:

#!/usr/bin/perl
use warnings;
use strict;

This turns on lots of warnings and extra checks - especially useful while you are learning (I'm still learning and I've been using Perl for more than 10 years now).

Archiearchiepiscopacy

Here is a query. When I require another .pl file to a file having #!/usr/bin/perl -T,it throws error.And when I remove -T,it runs.what's the reason ? Thanks. – Colyer

Answer 2

Both -w and -T are sort of "foolproof" flags.

-w is the same as use warning statement in your code, and it's an equivalent of warning option in many compilers. A simplest example would be a warning about using uninitialized variable:

#!/usr/bin/perl -w
print "$A\n";
print "Hello, world!\n";

Will print:

Name "main::A" used only once: possible typo at ./perl-warnings line 3.
Use of uninitialized value $A in concatenation (.) or string at
./perl-warnings line 3.

Hello, world!

The -T flag means that any value that came from the outside world (as opposite to being calculated inside the program) is considered potential threat, and disallows usage of such values in system-related operations, like writing files, executing system command, etc. (That's why Perl would activate the "taint" mode when the script is running under setuid/setgid.)

The "tainted" mode is "enforcing" you to double-check the value inside the script.

E.g., the code:

#!/usr/bin/perl -T
$A = shift;
open FILE, ">$A";
print "$A\n";
close FILE;

Will produce a fatal error (terminating the program):

$ ./perl-tainted jkjk
Insecure dependency in open while running with -T switch at
./perl-tainted line 3.

And that's only because the argument value came from "outside" and was not "double-checked". The "taint" mode is drawing your attention to that fact. Of course, it's easy to fool it, e.g.:

#!/usr/bin/perl -T
$A = shift;
$A = $1 if $A =~ /(^.*$)/;
open FILE, ">$A";
print "$A\n";
close FILE;

In this case everything worked fine. You "fooled" the "taint mode". Well, the assumption is that programer's intentions are to make the program safer, so the programmer wouldn't just work around the error, but would rather take some security measures. One of Perl's nicknames is "the glue and the duct tape of system administrators". It's not unlikely that system administrator would create Perl script for his own needs and would run it with root permissions. Think of this script doing something normal users are not allowed to do... you probably want to double-check things which are not part of the program itself, and you want Perl to remind you about them.

Hope it helps.

Studio

-w is not the same as use warnings;. The pragma is lexically scoped. – Butt

about "-w is the same as use warning". that's not exactly correct. -W turns on warnings everwhere (ignoring $^W or no warnings), -w turns on warnings everwhere except when $^W is set to 0 or no warnings is used. "use warnings" is lexically scoped. – Ichthyo

Answer 3

It's called a shebang. On Unix based systems (OSX, Linux, etc...) that line indicates the path to the language interpreter when the script is run from the command line. In the case of perl /usr/bin/perl is the path to the perl interpreter. If the hashbang is left out the *nix systems won't know how to parse the script when invoked as an executable. It will instead try to interpret the script in whatever shell the user happens to be running (probably bash) and break the script.

http://en.wikipedia.org/wiki/Hashbang

The -W and -T are arguments that controll the way the perl interpreter operates. They are the same arguments that you could invoke when calling perl interpreter directly from the command line.

• -W shows warnings (aka debuging information).
• -T turns on taint / security checking.

Krieger

Answer 4

about Taint Mode(-T):
require and use statements change when taint mode is turned on.
The path to load libraries/modules no longer contains . (the current directory) from its path.

So if you load any libraries or modules relative to the current working directory without explicitly specifying the path, your script will break under taint mode.

For ex: Consider perl_taint_ex.pl

#!/usr/bin/perl -T

require "abc.pl";
print "Done";

would fail like this

D:\perlex>perl perl_taint_ex.pl
"-T" is on the #! line, it must also be used on the command line 
at perl_taint_ex.pl line 1. 

D:\perlex>perl -T perl_taint_ex.pl
Can't locate abc.pl in @INC (@INC contains: C:/Perl/site/lib C:/Perl/lib)
 at perl_taint_ex.pl line 3. 

So when taint mode is on, you must tell the require statement explicitly where to load the library since . is removed during taint mode from the @INC array.

@INC contains a list of valid paths to read library files and modules from.

If taint mode is on, you would simply do the following:

D:\perlex>perl -ID:\perlex -T perl_taint_ex.pl
Done

-ID:\perlex will include directory D:\perlex in @INC.

You can try other ways for adding path to @INC,this is just one example.

Oily

This explanation provides a good explanation of what happens if you don't use the -T parameter correctly from the commandline but specify it in the shebang line of a perl script. Useful. – Ting