X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCwd.pm;h=dca0a2f047bad1b3141a0cd720a6e5d1bbff8471;hb=bc125c03185ff3f765451ef53228eea11c0d525f;hp=e3c45903c3e8e3b447f59a13841dab259487f7e7;hpb=db376a245d40f9f81e37632708a9ad2cfc67ef6a;p=p5sagit%2Fp5-mst-13.2.git diff --git a/lib/Cwd.pm b/lib/Cwd.pm index e3c4590..dca0a2f 100644 --- a/lib/Cwd.pm +++ b/lib/Cwd.pm @@ -1,96 +1,232 @@ package Cwd; -require 5.000; +$VERSION = $VERSION = '2.14'; =head1 NAME -getcwd - get pathname of current working directory +Cwd - get pathname of current working directory =head1 SYNOPSIS use Cwd; - $dir = cwd; + my $dir = getcwd; - use Cwd; - $dir = getcwd; + use Cwd 'abs_path'; + my $abs_path = abs_path($file); - use Cwd; - $dir = fastgetcwd; +=head1 DESCRIPTION - use Cwd 'chdir'; - chdir "/tmp"; - print $ENV{'PWD'}; +This module provides functions for determining the pathname of the +current working directory. It is recommended that getcwd (or another +*cwd() function) be used in I code to ensure portability. - use Cwd 'abs_path'; # aka realpath() - print abs_path($ENV{'PWD'}); +By default, it exports the functions cwd(), getcwd(), fastcwd(), and +fastgetcwd() into the caller's namespace. - use Cwd 'fast_abs_path'; - print fast_abs_path($ENV{'PWD'}); -=head1 DESCRIPTION +=head2 getcwd and friends -The getcwd() function re-implements the getcwd(3) (or getwd(3)) functions -in Perl. - -The abs_path() function takes a single argument and returns the -absolute pathname for that argument. It uses the same algorithm -as getcwd(). (Actually, getcwd() is abs_path(".")) Symbolic links -and relative-path components ("." and "..") are resolved to return -the canonical pathname, just like realpath(3). Also callable as -realpath(). - -The fastcwd() function looks the same as getcwd(), but runs faster. -It's also more dangerous because it might conceivably chdir() you out -of a directory that it can't chdir() you back into. If fastcwd -encounters a problem it will return undef but will probably leave you -in a different directory. For a measure of extra security, if -everything appears to have worked, the fastcwd() function will check -that it leaves you in the same directory that it started in. If it has -changed it will C with the message "Unstable directory path, -current directory changed unexpectedly". That should never happen. - -The fast_abs_path() function looks the same as abs_path(), but runs faster. -And like fastcwd() is more dangerous. - -The cwd() function looks the same as getcwd and fastgetcwd but is -implemented using the most natural and safe form for the current -architecture. For most systems it is identical to `pwd` (but without -the trailing line terminator). - -It is recommended that cwd (or another *cwd() function) is used in -I code to ensure portability. - -If you ask to override your chdir() built-in function, then your PWD -environment variable will be kept up to date. (See -L.) Note that it will only be -kept up to date if all packages which use chdir import it from Cwd. +Each of these functions are called without arguments and return the +absolute path of the current working directory. -=cut +=over 4 + +=item getcwd + + my $cwd = getcwd(); + +Returns the current working directory. + +Re-implements the getcwd(3) (or getwd(3)) functions in Perl. + +=item cwd + + my $cwd = cwd(); + +The cwd() is the most natural form for the current architecture. For +most systems it is identical to `pwd` (but without the trailing line +terminator). + +=item fastcwd + + my $cwd = fastcwd(); + +A more dangerous version of getcwd(), but potentially faster. + +It might conceivably chdir() you out of a directory that it can't +chdir() you back into. If fastcwd encounters a problem it will return +undef but will probably leave you in a different directory. For a +measure of extra security, if everything appears to have worked, the +fastcwd() function will check that it leaves you in the same directory +that it started in. If it has changed it will C with the message +"Unstable directory path, current directory changed +unexpectedly". That should never happen. + +=item fastgetcwd + + my $cwd = fastgetcwd(); + +The fastgetcwd() function is provided as a synonym for cwd(). + +=back + + +=head2 abs_path and friends + +These functions are exported only on request. They each take a single +argument and return the absolute pathname for it. If no argument is +given they'll use the current working directory. + +=over 4 + +=item abs_path + + my $abs_path = abs_path($file); + +Uses the same algorithm as getcwd(). Symbolic links and relative-path +components ("." and "..") are resolved to return the canonical +pathname, just like realpath(3). + +=item realpath + + my $abs_path = realpath($file); + +A synonym for abs_path(). + +=item fast_abs_path + + my $abs_path = fast_abs_path($file); + +A more dangerous, but potentially faster version of abs_path. + +=back + +=head2 $ENV{PWD} + +If you ask to override your chdir() built-in function, + + use Cwd qw(chdir); + +then your PWD environment variable will be kept up to date. Note that +it will only be kept up to date if all packages which use chdir import +it from Cwd. + + +=head1 NOTES + +=over 4 + +=item * + +Since the path seperators are different on some operating systems ('/' +on Unix, ':' on MacPerl, etc...) we recommend you use the File::Spec +modules wherever portability is a concern. + +=item * + +Actually, on Mac OS, the C, C and C +functions are all aliases for the C function, which, on Mac OS, +calls `pwd`. Likewise, the C function is an alias for +C. + +=back -## use strict; +=head1 SEE ALSO -use Carp; +L -$VERSION = '2.02'; +=cut + +use strict; +use Exporter; +use vars qw(@ISA @EXPORT @EXPORT_OK); -require Exporter; -@ISA = qw(Exporter); +@ISA = qw/ Exporter /; @EXPORT = qw(cwd getcwd fastcwd fastgetcwd); @EXPORT_OK = qw(chdir abs_path fast_abs_path realpath fast_realpath); +# sys_cwd may keep the builtin command -# The 'natural and safe form' for UNIX (pwd may be setuid root) +# All the functionality of this module may provided by builtins, +# there is no sense to process the rest of the file. +# The best choice may be to have this in BEGIN, but how to return from BEGIN? + +if ($^O eq 'os2') { + local $^W = 0; + + *cwd = defined &sys_cwd ? \&sys_cwd : \&_os2_cwd; + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + + *fast_abs_path = \&sys_abspath if defined &sys_abspath; + *abs_path = \&fast_abs_path; + *realpath = \&fast_abs_path; + *fast_realpath = \&fast_abs_path; + + return 1; +} + +eval { + require XSLoader; + local $^W = 0; + XSLoader::load('Cwd'); +}; + + +# Find the pwd command in the expected locations. We assume these +# are safe. This prevents _backtick_pwd() consulting $ENV{PATH} +# so everything works under taint mode. +my $pwd_cmd; +foreach my $try ('/bin/pwd', + '/usr/bin/pwd', + '/QOpenSys/bin/pwd', # OS/400 PASE. + ) { + + if( -x $try ) { + $pwd_cmd = $try; + last; + } +} +unless ($pwd_cmd) { + # Isn't this wrong? _backtick_pwd() will fail if somenone has + # pwd in their path but it is not /bin/pwd or /usr/bin/pwd? + # See [perl #16774]. --jhi + $pwd_cmd = 'pwd'; +} +# Lazy-load Carp +sub _carp { require Carp; Carp::carp(@_) } +sub _croak { require Carp; Carp::croak(@_) } + +# The 'natural and safe form' for UNIX (pwd may be setuid root) sub _backtick_pwd { - my $cwd; - chop($cwd = `pwd`); + local @ENV{qw(PATH IFS CDPATH ENV BASH_ENV)}; + my $cwd = `$pwd_cmd`; + # Belt-and-suspenders in case someone said "undef $/". + local $/ = "\n"; + # `pwd` may fail e.g. if the disk is full + chomp($cwd) if defined $cwd; $cwd; } # Since some ports may predefine cwd internally (e.g., NT) # we take care not to override an existing definition for cwd(). -*cwd = \&_backtick_pwd unless defined &cwd; +unless(defined &cwd) { + # The pwd command is not available in some chroot(2)'ed environments + if( $^O eq 'MacOS' || (defined $ENV{PATH} && + grep { -x "$_/pwd" } split(':', $ENV{PATH})) ) + { + *cwd = \&_backtick_pwd; + } + else { + *cwd = \&getcwd; + } +} +# set a reasonable (and very safe) default for fastgetcwd, in case it +# isn't redefined later (20001212 rspier) +*fastgetcwd = \&cwd; # By Brandon S. Allbery # @@ -101,6 +237,7 @@ sub getcwd abs_path('.'); } + # By John Bazik # # Usage: $cwd = &fastcwd; @@ -108,9 +245,6 @@ sub getcwd # This is a faster version of getcwd. It's also more dangerous because # you might chdir out of a directory that you can't chdir back into. -# List of metachars taken from do_exec() in doio.c -my $quoted_shell_meta = quotemeta('$&*(){}[]";\\|?<>~`'."'\n"); - sub fastcwd { my($odev, $oino, $cdev, $cino, $tdev, $tino); my(@path, $path); @@ -141,9 +275,9 @@ sub fastcwd { $path = '/' . join('/', @path); if ($^O eq 'apollo') { $path = "/".$path; } # At this point $path may be tainted (if tainting) and chdir would fail. - # To be more useful we untaint it then check that we landed where we started. - $path = $1 if $path =~ /^(.*)$/; # untaint - CORE::chdir($path) || return undef; + # Untaint it then check that we landed where we started. + $path =~ /^(.*)\z/s # untaint + && CORE::chdir($1) or return undef; ($cdev, $cino) = stat('.'); die "Unstable directory path, current directory changed unexpectedly" if $cdev != $orig_cdev || $cino != $orig_cino; @@ -159,7 +293,7 @@ sub fastcwd { my $chdir_init = 0; sub chdir_init { - if ($ENV{'PWD'} and $^O ne 'os2' and $^O ne 'dos') { + if ($ENV{'PWD'} and $^O ne 'os2' and $^O ne 'dos' and $^O ne 'MSWin32') { my($dd,$di) = stat('.'); my($pd,$pi) = stat($ENV{'PWD'}); if (!defined $dd or !defined $pd or $di != $pi or $dd != $pd) { @@ -167,10 +301,12 @@ sub chdir_init { } } else { - $ENV{'PWD'} = cwd(); + my $wd = cwd(); + $wd = Win32::GetFullPathName($wd) if $^O eq 'MSWin32'; + $ENV{'PWD'} = $wd; } # Strip an automounter prefix (where /tmp_mnt/foo/bar == /foo/bar) - if ($ENV{'PWD'} =~ m|(/[^/]+(/[^/]+/[^/]+))(.*)|) { + if ($^O ne 'MSWin32' and $ENV{'PWD'} =~ m|(/[^/]+(/[^/]+/[^/]+))(.*)|s) { my($pd,$pi) = stat($2); my($dd,$di) = stat($1); if (defined $pd and defined $dd and $di == $pi and $dd == $pd) { @@ -181,13 +317,29 @@ sub chdir_init { } sub chdir { - my $newdir = shift || ''; # allow for no arg (chdir to HOME dir) - $newdir =~ s|///*|/|g; + my $newdir = @_ ? shift : ''; # allow for no arg (chdir to HOME dir) + $newdir =~ s|///*|/|g unless $^O eq 'MSWin32'; chdir_init() unless $chdir_init; + my $newpwd; + if ($^O eq 'MSWin32') { + # get the full path name *before* the chdir() + $newpwd = Win32::GetFullPathName($newdir); + } + return 0 unless CORE::chdir $newdir; - if ($^O eq 'VMS') { return $ENV{'PWD'} = $ENV{'DEFAULT'} } - if ($newdir =~ m#^/#) { + if ($^O eq 'VMS') { + return $ENV{'PWD'} = $ENV{'DEFAULT'} + } + elsif ($^O eq 'MacOS') { + return $ENV{'PWD'} = cwd(); + } + elsif ($^O eq 'MSWin32') { + $ENV{'PWD'} = $newpwd; + return 1; + } + + if ($newdir =~ m#^/#s) { $ENV{'PWD'} = $newdir; } else { my @curdir = split(m#/#,$ENV{'PWD'}); @@ -203,18 +355,17 @@ sub chdir { 1; } -# Taken from Cwd.pm It is really getcwd with an optional -# parameter instead of '.' -# -sub abs_path +# In case the XS version doesn't load. +*abs_path = \&_perl_abs_path unless defined &abs_path; +sub _perl_abs_path { my $start = @_ ? shift : '.'; my($dotdots, $cwd, @pst, @cst, $dir, @tst); unless (@cst = stat( $start )) { - carp "stat($start): $!"; + _carp("stat($start): $!"); return ''; } $cwd = ''; @@ -223,14 +374,15 @@ sub abs_path { $dotdots .= '/..'; @pst = @cst; + local *PARENT; unless (opendir(PARENT, $dotdots)) { - carp "opendir($dotdots): $!"; + _carp("opendir($dotdots): $!"); return ''; } unless (@cst = stat($dotdots)) { - carp "stat($dotdots): $!"; + _carp("stat($dotdots): $!"); closedir(PARENT); return ''; } @@ -244,7 +396,7 @@ sub abs_path { unless (defined ($dir = readdir(PARENT))) { - carp "readdir($dotdots): $!"; + _carp("readdir($dotdots): $!"); closedir(PARENT); return ''; } @@ -260,16 +412,29 @@ sub abs_path $cwd; } + # added function alias for those of us more # used to the libc function. --tchrist 27-Jan-00 *realpath = \&abs_path; +my $Curdir; sub fast_abs_path { my $cwd = getcwd(); - my $path = shift || '.'; - CORE::chdir($path) || croak "Cannot chdir to $path:$!"; + require File::Spec; + my $path = @_ ? shift : ($Curdir ||= File::Spec->curdir); + + # Detaint else we'll explode in taint mode. This is safe because + # we're not doing anything dangerous with it. + ($path) = $path =~ /(.*)/; + ($cwd) = $cwd =~ /(.*)/; + + if (!CORE::chdir($path)) { + _croak("Cannot chdir to $path: $!"); + } my $realpath = getcwd(); - CORE::chdir($cwd) || croak "Cannot chdir back to $cwd:$!"; + if (! ((-d $cwd) && (CORE::chdir($cwd)))) { + _croak("Cannot chdir back to $cwd: $!"); + } $realpath; } @@ -295,13 +460,16 @@ sub _vms_cwd { sub _vms_abs_path { return $ENV{'DEFAULT'} unless @_; my $path = VMS::Filespec::pathify($_[0]); - croak("Invalid path name $_[0]") unless defined $path; + if (! defined $path) + { + _croak("Invalid path name $_[0]") + } return VMS::Filespec::rmsexpand($path); } sub _os2_cwd { $ENV{'PWD'} = `cmd /c cd`; - chop $ENV{'PWD'}; + chomp $ENV{'PWD'}; $ENV{'PWD'} =~ s:\\:/:g ; return $ENV{'PWD'}; } @@ -320,7 +488,7 @@ sub _win32_cwd { sub _dos_cwd { if (!defined &Dos::GetCwd) { $ENV{'PWD'} = `command /c cd`; - chop $ENV{'PWD'}; + chomp $ENV{'PWD'}; $ENV{'PWD'} =~ s:\\:/:g ; } else { $ENV{'PWD'} = Dos::GetCwd(); @@ -329,18 +497,34 @@ sub _dos_cwd { } sub _qnx_cwd { + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; $ENV{'PWD'} = `/usr/bin/fullpath -t`; - chop $ENV{'PWD'}; + chomp $ENV{'PWD'}; return $ENV{'PWD'}; } sub _qnx_abs_path { - my $path = shift || '.'; - my $realpath=`/usr/bin/fullpath -t $path`; - chop $realpath; + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; + my $path = @_ ? shift : '.'; + local *REALPATH; + + open(REALPATH, '-|', '/usr/bin/fullpath', '-t', $path) or + die "Can't open /usr/bin/fullpath: $!"; + my $realpath = ; + close REALPATH; + chomp $realpath; return $realpath; } +sub _epoc_cwd { + $ENV{'PWD'} = EPOC::getcwd(); + return $ENV{'PWD'}; +} + { no warnings; # assignments trigger 'subroutine redefined' warning @@ -359,14 +543,7 @@ sub _qnx_abs_path { *fastcwd = \&_NT_cwd; *fastgetcwd = \&_NT_cwd; *abs_path = \&fast_abs_path; - } - elsif ($^O eq 'os2') { - # sys_cwd may keep the builtin command - *cwd = defined &sys_cwd ? \&sys_cwd : \&_os2_cwd; - *getcwd = \&cwd; - *fastgetcwd = \&cwd; - *fastcwd = \&cwd; - *abs_path = \&fast_abs_path; + *realpath = \&fast_abs_path; } elsif ($^O eq 'dos') { *cwd = \&_dos_cwd; @@ -375,7 +552,7 @@ sub _qnx_abs_path { *fastcwd = \&_dos_cwd; *abs_path = \&fast_abs_path; } - elsif ($^O eq 'qnx') { + elsif ($^O =~ m/^(?:qnx|nto)$/ ) { *cwd = \&_qnx_cwd; *getcwd = \&_qnx_cwd; *fastgetcwd = \&_qnx_cwd; @@ -388,16 +565,22 @@ sub _qnx_abs_path { *fastgetcwd = \&cwd; *fastcwd = \&cwd; *abs_path = \&fast_abs_path; + *realpath = \&abs_path; + } + elsif ($^O eq 'epoc') { + *cwd = \&_epoc_cwd; + *getcwd = \&_epoc_cwd; + *fastgetcwd = \&_epoc_cwd; + *fastcwd = \&_epoc_cwd; + *abs_path = \&fast_abs_path; + } + elsif ($^O eq 'MacOS') { + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + *abs_path = \&fast_abs_path; } } -# package main; eval join('',) || die $@; # quick test 1; - -__END__ -BEGIN { import Cwd qw(:DEFAULT chdir); } -print join("\n", cwd, getcwd, fastcwd, ""); -chdir('..'); -print join("\n", cwd, getcwd, fastcwd, ""); -print "$ENV{PWD}\n";