The character sets of filesystems are one of the (few) blind spots in Perls support for character sets. Perl (and Unix, go figure) consider a filename to be a null-terminated sequence of bytes without further encoding and Perl normally uses the byte-oriented APIs. Windows likely treats the file as UTF-16 or as some other charset, so there will be an API mismatch when you input the filename to your Perl script and it then turns over that name to the byte-oriented APIs.

You can try to transcode the filename using Encode or you can resort to using the 8.3 filenames (if they are enabled for the filesystem/partition in question). You can also try to use the "wide" API (OpenFileW instead of the Perl default OpenFileA) which accepts UTF-16 strings (I believe). The drawback of the wide APIs is, that the rest of Perl, like filehandles, does not know what to do with the results you get back from them.

The most likely successful approach is to use pattern matching and readdir to find the files that interest you(r program). Hopefully the byte-oriented results of readdir() will still work when passed to open().

Update: cdarke points out that OpenFile* are for 16-bit compatibility only. CreateFile* are the way to do it under the newer versions. tye's and demerphq's Win32API::File provide the functions to use those calls and the functions even return Perl filehandles!

I've no idea what does it actually says, but the ActiveState PerlJP page might assist you with your issues.

#!/usr/bin/perl

use strict;
use warnings;

(@ARGV == 1 and -d $ARGV[0]) or die "Usage:  $0 pathname\n";

my $dir = shift;
opendir( DIR, $dir ) or die "$dir: $!";
while ( $_ = readdir DIR ) {
    next if ( /^\.\.?$/ );
    print join( " ", map { sprintf( " %02x", ord($_)) } split //, $_ )
+;
    if ( -f ) {
        open( I, $_ ) or do { warn "$_: $!"; next };
        my $sum = 0;
        $sum += length() while (<I>);
        close I;
        printf( " : %d bytes (%d read)\n", -s _, $sum );
    }
    elsif ( -d _ ) {
        print " : directory\n";
    }
    else {
        print " : not sure what this is\n"
    }
}
[download]

You might also want to take a bunch of these odd-ball file names (as fetched by readdir) and concatenate them (with spaces between them) into a single long string, and pass that to the "guess_encoding" function provided by Encode::Guess -- if the characters really are non-unicode Asian or some form of unicode, there's a good chance it'll give you a correct answer, which you can then use with Encode's "decode" function, to turn the strings into perl-internal utf8 (in case that's helpful for anything).

Ok, found this this which works for readdir functionality.

    use Win32::OLE qw(in); 
    use Encode;      
    Win32::OLE->Option(CP => Win32::OLE::CP_UTF8); 

#Input: -dir to read files from
#Output: -array ref with files
sub ReadDirWithWin32OLE {
    my $dir = shift;
        #backslashes only in dir
    $dir=~s-\/-\\-g;
        #remove last backslash
    $dir=~s-\\\s*$--;
    if (not -e $dir) {
        warn "dir ($dir) does not exist";
        return;
    }
    
    my $fso = Win32::OLE->new("Scripting.FileSystemObject"); 
        #won't work if $dir contains unicode chars :(
    my $folder = $fso->GetFolder($dir); 
    if (!$folder) {
        warn "Problem creating Win32::OLE (folder) object";
        return;
    }
    my @filesFound = ();
    foreach my $file (in $folder->Files) { 
        my $shortFilename = $file->ShortName;
        #my $shortFilename = $file->Name;

        $shortFilename = $dir . "\\" . $shortFilename; 
        if (-e $shortFilename) {
            print "\nFile Found", $shortFilename;
            push @filesFound, $shortFilename;
        }
        else {
            print "\nFILE NOT FOUND!! (this should not happen):", $sho
+rtFilename;
        }
    }
    return \@filesFound;
}
[download]

Filenames examples:
file1_刚形变.txt
file2_ מדהימה .txt

BUT...:
1)If directory path ($dir) contains weird unicode chars it won't work?!
2)We're forced to use short filenames?! The Win32API::File trick, as mentioned by Corion, used here, didn't seem to work with "weird file2" (see above)?!
3)Still no way to open specific files with unicode chars if drag and dropped into a perl/tk window (but that is maybe whole different topic?).

@graff:
readdir gives us the ? char (ascii 63) instead of *any* weird unicode char.

use Win32::OLE qw(in); 
use Devel::Peek;

#CP_UTF8 is very important as it translates between Perl strings and U
+nicode strings used by the OLE interface

Win32::OLE->Option(CP => Win32::OLE::CP_UTF8);   

$obj = Win32::OLE->new('Scripting.FileSystemObject');

$folder = $obj->GetFolder(".");

$collection= $folder->{Files};

mkdir ("c:\\newfolder")||die;

foreach $value (in $collection) {
    $filename= %$value->{Name};
    next if ($filename !~ /.txt/);
    Dump("$filename");  #check if the utf8 flag is on
    $file=$obj->GetFile("$filename");  
    $file->Move("c:\\newfolder\\$filename");
    print (Win32::OLE->LastError() || "success\n\n");
}
[download]

Thanks for your tip, was searching the same question online and find this page.
To the above code, I get $file->Move work with CJK filename, the problem I have here is if $path is a path contain utf8 $folder = $obj->GetFolder($path);
does not seems to work, while if it is in Big5 it works then...

Any suggestion? Thanks!

Can you be more specific? Maybe provide a code sample and point out where the actual problem is?

Try the following script which just gets all subdirectories and prints their name out.
Does it work for the directory in question?

use Win32::OLE qw(in); 
Win32::OLE->Option(CP => Win32::OLE::CP_UTF8);   

$obj = Win32::OLE->new('Scripting.FileSystemObject');
$folder = $obj->GetFolder(".");
$collection= $folder->{SubFolders};

foreach  $value (in $collection) {
     $foldername= %$value->{Name};
     $folder=$obj->GetFolder("$foldername");
    print (Win32::FormatMessage(Win32::OLE->LastError())|| "$foldernam
+e");
}
[download]