You're not really doing this recursively. It looks like your loop will only descend one level. File::Find is the canonical way to walk a directory tree.

If you modify this to recurse by defining a sub which calls itself on seeing a directory, be careful to not clobber the newDIR global handle. You can do that by either localizing the global handle or else using lexical handles.

I gotta complain about the idea that File::Find is the canonical way to traverse a directory. File::Find calls a subroutine of your choice on each file it traverses, but if you want to save the results from processing those files, you have to save them in a global variable, because there's no way to capture the return values from your subroutine. Not to mention there are a lot of things that are hard to do with it. Try to use File::Find just to construct a hash with the directory structure. You can do it, but you'll have to parse the full path to the file and traverse your hash structure to insert each element, using about 10 times as much code as just saying push(@{$hash{$dir}, $file). File::Find is hard to use and leads to bad code. I never use it anymore except for the simplest of tasks.

you have to save them in a global variable, because there's no way to capture the return values from your subroutine

That's not quite true; you can save the results in any lexical variable in scope of the sub.

I reckon we are the only monastery ever to have a dungeon stuffed with 16,000 zombies.

I gotta complain about the idea that File::Find is the canonical way to traverse a directory ... I use it ...

That argument could be made in 2005 that File::Find probably is canonical ... you could also make that argument today :)

I prefer File::Find::Rule

Next, you've fallen prey to the "readdir() returns unqualified names" problem. readdir() is only returning the name of the entries in the directory -- you must prepend the PATH to those names:

my $dir = ...;

opendir my $dh, $dir or die "can't read $dir: $!";
while (defined(my $name = readdir $dh)) {
  my $file = "$dir/$name"; # XXX <-- here
  if (-d $file) { ... }
}
closedir $dh;
[download]

Lastly, your code only goes one level down. To get indefinite depth, you'll need a recursive solution, but you should consider the File::Find module which does this for you.

To get indefinite depth, you'll need a recursive solution

Not quite. You simply need a stack. Recursion is just one way of obtaining a stack. What follows is another:

my @to_visit = $base_dir;

while (@to_visit) {
   my $dir = pop(@to_visit);

   opendir(my $dh, $dir) or ...;

   my $file;
   while(defined($file = readdir($dh))) {
      next if $file eq '.';
      next if $file eq '..';

      # Should use File::Spec.
      $file = "$dir/$file";

      if (-d $file) {
         push(@to_visit, $file);
      } else {
         ...
      }
   }
}
[download]

Substitute pop with shift if you want to process the tree breadth first.

While you should really use a module for this, I will answer the question: Your code is not recursive - it descends only one level, and a correct solution would allow for any number. Here is an example that does what you want. Note that symbolic links to directories are not followed.

#! /usr/bin/perl

use strict;
use warnings;

sub list
{
  my ($dir) = @_;
  return unless -d $dir;

  my @files;
  if (opendir my $dh, $dir)
  {
    # Capture entries first, so we don't descend with an
    # open dir handle.
    my @list;
    my $file;
    while ($file = readdir $dh)
    {
      push @list, $file;
    }
    closedir $dh;

    for $file (@list)
    {
      # Unix file system considerations.
      next if $file eq '.' || $file eq '..';

      # Swap these two lines to follow symbolic links into
      # directories.  Handles circular links by entering an
      # infinite loop.
      push @files, "$dir/$file"        if -f "$dir/$file";
      push @files, list ("$dir/$file") if -d "$dir/$file";
    }
  }

  return @files;
}

print "file=", $_, "\n" for list ("D:");
exit 0;
[download]

use File::Find;

$start_dir = shift || '.';

find( sub{
            -f $_ and push @files, $File::Find::name;
            -d $_ and push @dirs,  $File::Find::name;
}, $start_dir );
[download]

I know you've already had several answers, but you might wish to check out this article by merlyn