The problem is that (in *ix) the long path "/var/log/../../home/poletti/../../etc/passwd" does not necessarily compact to "/etc/passwd". For example, if "/home/poletti" was a symbolic link to "/drive2/home/poletti", the long path would compact to "/drive2/etc/passwd". That's why canonpath does not eliminate "segment/../" in *ix.

Update: Here's some code that does the trick, ignoring symbolic links:

use File::Spec::Unix ();

sub remove_dot_dot {
   local $_ = $_[0];
   $_ = File::Spec::Unix->canonpath($_);
   1 while s#[^/]+/\.\./##g;
   s#/[^/]+/\.\.$#/#g;
   s#^[^/]+/\.\.$#.#g;
   return $_;
}
[download]

Tests:

Update2: I got confused and thought ../foo/bar should give bar. Fixed.

The following solution is not perfect, but works for me most of the time (the version below assumes that $path points to a subdir, but it can easily be adapted to the general case in which $path can also point to a file):

sub cleanpath {
  my $path;
  use Cwd;
  my $cwd = cwd;
  chdir $path or die "Can't chdir to $path: $!\n";
  my $cleanpath = cwd;
  chdir $cwd or die "Can't return to $cwd$ $!\n";
  return $cleanpath;
}
[download]

Basically, in Unix, if a symbolic links render the path notation ambiguous; in the simplest terms, if foo points to some (non-symbolic) directory bar, then the formal expression foo/.. is ambiguous, because it can be interpreted as either the parent of foo or the parent of bar. (In fact, even foo/. is ambiguous.) The definition of "cleaning up a path" hinges on how you want to resolve this ambiguity. There are uses for both forms of clean-up.

Well, if you're not worried about portablity:

!/usr/bin/perl

use strict;
use warnings;

my $somepath = "/var/log/../../home/poletti/../../etc/passwd";
my( @true );

foreach( split( /\//, $somepath ) ) {
    $_ eq ".." ? pop( @true ) : push( @true, $_ );
}
print join( '/', @true ), "\n";
[download]

Let the golf begin

1while s#[^/]+/..(/|$)##
[download]

ikegami's remarks still apply.

---

Caution: Contents may have been coded under pressure.

aye, works great (if you canonise first)

sub remove_dot_dot_roy_edited {
   local $_ = $_[0];
   $_ = File::Spec::Unix->canonpath($_);
   1while s#[^/]+/..(/|$)##;
   return length($_) ? $_ : '.';
}
[download]

While that works for

/foo/../bar          -> /bar
foo/../bar           -> bar
/foo/bar/../../moo   -> /moo
/var/log/../../home/poletti/../../etc/passwd -> /etc/passwd
[download]

it doesn't work for

/foo/..              ->           <- Should be /
foo/..               ->           <- Should be . (?)
..                   ->           <- Should be ..
../foo               -> foo       <- Should be ../foo
../foo/bar           -> foo/bar   <- Should be ../foo/bar
foo/bar/../..        ->           <- Should be . (?)
/foo/bar/../..       ->           <- Should be /
[download]

This breaks in the case depicted by ikegami, but can be adjusted to cope with the portability problem:

#!/usr/bin/perl

use strict;
use warnings;
use File::Spec;

my $somepath = "/var/log/../../home/poletti/../../etc/rc.d";

my @true;
$somepath = "/../../../";
# Let's pretend $somepath is a directory... or is it? :)
/^\.\./ ? pop( @true ) : push( @true, $_ )
  foreach( File::Spec->splitdir($somepath) );
print File::Spec->catdir(@true), "\n";
[download]

Flavio (perl -e "print(scalar(reverse('ti.xittelop@oivalf')))")

Don't fool yourself.

/foo/..              -> /            <- Fixed
/foo/../bar          -> /bar         <- Still works
foo/..               ->              <- Should be . (?)
foo/../bar           -> bar          <- Still works
..                   ->              <- Should be ..
../foo               -> foo          <- Should be ../foo
../foo/bar           -> foo/bar      <- Should be ../foo/bar
foo/bar/../..        ->              <- Should be . (?)
/foo/bar/../..       -> /            <- Fixed
/foo/bar/../../moo   -> /moo         <- Still works
{...}/etc/passwd     -> /etc/passwd  <- Still works
[download]

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

use Cwd 'abs_path';

my $somepath = "/var/log/../../home/poletti/../../etc/passwd";

print "starting path: [$somepath]\n";
print "abs_path     : [", abs_path($somepath), "]\n"

__END__
starting path: [/var/log/../../home/poletti/../../etc/passwd]
abs_path     : [/etc/passwd]
[download]

       abs_path
             my $abs_path = abs_path($file);

           Uses the same algorithm as getcwd().  Symbolic links and re
+lative-
           path components ("." and "..") are resolved to return the c
+anonical
           pathname, just like realpath(3).
[download]