From: "austin (Austin Ziegler)" <noreply@...>
Date: 2022-07-29T13:50:11+00:00
Subject: [ruby-core:109365] [Ruby master Bug#18947] Unexpected Errno::ENAMETOOLONG on Windows

Issue #18947 has been updated by austin (Austin Ziegler).


inversion (Yura Babak) wrote: 
> Pathname and FileUtils work fine for me until there is a folder with a **very long path** (>260 chars).
> 
> ���
> But there is a way in Windows to remove the MAX_PATH limitation.
> You can find a small .reg file in this article:
> https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry

It���s been a long time since I���ve done anything in Windows, but the article you posted indicates that there are *two* conditions that must be met for the long path support to be enabled:

- The registry key `Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem\LongPathsEnabled` must exist and be set to `1`.
- The application manifest must also include the `longPathAware` element.

If Ruby does not have an application manifest (I don���t know whether it does or not) with this element, then long path support is disabled. If the registry key is not set, then long path support is disabled. Thus, even if Ruby were to have an embedded application manifest with this key, then we���d want to have a runtime API so that scripts could determine whether or not they can safely use long paths.

There is a way to handle long paths on Windows whether or not this registry key is enabled: prefix the drive root with `\\?\` (which would be `'\\\\?\\' as `\` is an escape character). It means you can���t work with relative paths and you must always use `\` as the file separator, but it always works and definitely did when I was using Ruby on Windows back in 2004���2011.

----------------------------------------
Bug #18947: Unexpected Errno::ENAMETOOLONG on Windows
https://bugs.ruby-lang.org/issues/18947#change-98508

* Author: inversion (Yura Babak)
* Status: Open
* Priority: Normal
* ruby -v: ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x64-mingw-ucrt]
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
On Windows 10, I am working on a script to copy a complex folder structure.

Pathname and FileUtils work fine for me until there is a folder with a **very long path** (>260 chars).

Normally you cannot access such a folder with Ruby.
The next operations will raise `Errno::ENOENT`
``` ruby
Pathname.new(300_chars_path).children
FileUtils.mkpath(300_chars_path)
```


But there is a way in Windows to remove the MAX_PATH limitation.
You can find a small .reg file in this article:
https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry

After changing this system option, things start to work strangely in Ruby.

This will now raise `Errno::ENAMETOOLONG`:
``` ruby
Pathname.new(300_chars_path).children
```

But at the same time, you can create a folder with such a long path and write-read a file in it
``` ruby
FileUtils.mkpath(300_chars_path)
file = Pathname.new(300_chars_path+'/file.txt')
file.write 'oooooooooo'
puts Pathname.new(300_chars_path+'/file.txt').read
```


So you can work with individual items but attempts to list such folders' content fail (`.children`, `.glob`, `.copy`, etc).
In my case, deep `.glob` is broken for all the parent folders of that deep long-path folder ((

The only way I found for listing is
``` ruby
require 'win32ole'
fso = WIN32OLE.new 'Scripting.FileSystemObject'
for file in fso.GetFolder(300_chars_path).files
    file.name
    file.path.length
end
```

But using this workaround breaks all my code workflow built on top of Pathname and FileUtils ((.

So for me, it looks like some operations with long-path folders are not working just because in Ruby there is a check for the path length and not a real operation problem. And in some places (see .mkpath) there is no such check and all works fine.

Also notice that other applications on Windows have no problems with long-path folders (like Total Commander).

Please consider reviewing if we really need to raise `Errno::ENAMETOOLONG` if the `LongPathsEnabled` option is enabled in the Windows registry.




-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>