[VFS] Fix verifyRootDirectory() to preserve FTP working directory

Add FtpClient.isDirectory() with PWD save/restore in FTPClientWrapper.
Update verifyRootDirectory() to use isDirectory() instead of
changeDirectory(), which left the working directory changed as a side
effect.

On non-chroot FTP servers with userDirIsRoot=true, the connection starts
at the user's home directory (e.g., /home/ftpuser). verifyRootDirectory()
CWDs to "/" which on non-chroot servers goes to the actual server root,
not the user's home. All subsequent VFS operations use relative paths
that resolve against the working directory, so they would break.

The isDirectory() method follows the same save/restore pattern used by
the VFS-307 fallback in FTPClientWrapper.listFilesInDirectory().

Author: ilang

commons-vfs2/src/main/java/org/apache/commons/vfs2/provider/ftp/FTPClientWrapper.java

@@ -75,6 +75,28 @@ public boolean changeDirectory(final String relPath) throws IOException {
         }
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public boolean isDirectory(final String relPath) throws IOException {
+        try {
+            return isDirectoryWithCwd(relPath);
+        } catch (final IOException e) {
+            disconnect();
+            return isDirectoryWithCwd(relPath);
+        }
+    }
+
+    private boolean isDirectoryWithCwd(final String relPath) throws IOException {
+        final String saved = getFtpClient().printWorkingDirectory();
+        try {
+            return getFtpClient().changeWorkingDirectory(relPath);
+        } finally {
+            if (saved != null) {
+                getFtpClient().changeWorkingDirectory(saved);
+            }
+        }
+    }
+
     @Override
     public boolean abort() throws IOException {
         try {

commons-vfs2/src/main/java/org/apache/commons/vfs2/provider/ftp/FtpClient.java

@@ -70,6 +70,20 @@ default boolean changeDirectory(String relPath) throws IOException {
         return false;
     }
 
+    /**
+     * Tests whether a remote path is an existing directory by attempting to CWD into it.
+     * Implementations must save and restore the working directory to avoid side effects
+     * on subsequent operations that use relative paths.
+     *
+     * @param relPath The pathname to test.
+     * @return true if the path is an existing directory, false otherwise.
+     * @throws IOException If an I/O error occurs.
+     * @since 2.10.1
+     */
+    default boolean isDirectory(String relPath) throws IOException {
+        return false;
+    }
+
     /**
      * Deletes a file on the FTP server.
      *

commons-vfs2/src/main/java/org/apache/commons/vfs2/provider/ftp/FtpFileObject.java

@@ -651,7 +651,7 @@ private void setFTPFile(final boolean flush) throws IOException {
     private FTPFile verifyRootDirectory() throws IOException {
         final FtpClient client = getAbstractFileSystem().getClient();
         try {
-            if (client.changeDirectory(relPath != null ? relPath : "/")) {
+            if (client.isDirectory(relPath != null ? relPath : "/")) {
                 final FTPFile result = new FTPFile();
                 result.setType(FTPFile.DIRECTORY_TYPE);
                 return result;

commons-vfs2/src/test/java/org/apache/commons/vfs2/provider/ftp/FtpRootExistsOnDisconnectTest.java

@@ -16,8 +16,10 @@
  */
 package org.apache.commons.vfs2.provider.ftp;
 
+import java.io.File;
 import java.time.Duration;
 
+import org.apache.commons.net.ftp.FTPClient;
 import org.apache.commons.vfs2.FileObject;
 import org.apache.commons.vfs2.FileSystemException;
 import org.apache.commons.vfs2.FileSystemOptions;
@@ -105,4 +107,78 @@ public void testRootExistsFailsWhenConnectionDropped() throws Exception {
                 "exists() must throw FileSystemException after FTP connection is lost");
         }
     }
+
+    /**
+     * Tests that {@link FTPClientWrapper#isDirectory(String)} preserves the FTP working directory.
+     * <p>
+     * <b>Background:</b> {@code verifyRootDirectory()} in {@link FtpFileObject} uses CWD to
+     * check if the root directory exists. It passes {@code "/"} as the path. With
+     * {@code userDirIsRoot=true}, the FTP factory skips the initial CWD, leaving the connection
+     * at the user's home directory (e.g., {@code /home/ftpuser}). When
+     * {@code verifyRootDirectory()} then CWDs to {@code "/"}, the working directory changes to
+     * the actual server root on non-chroot FTP servers (e.g., vsftpd without
+     * {@code chroot_local_user}). All subsequent VFS operations use relative paths that resolve
+     * against the working directory, so they would resolve against {@code "/"} instead of
+     * {@code /home/ftpuser}, breaking file access.
+     * </p>
+     * <p>
+     * <b>Why this is tested at the wrapper level instead of end-to-end through VFS:</b>
+     * The embedded Apache MINA FTP server always chroots users to their home directory.
+     * Within the chroot, {@code "/"} IS the user's home directory, so CWD {@code "/"} at the
+     * VFS level is effectively a no-op — the working directory does not change to a different
+     * location. This makes it impossible to reproduce the bug through the VFS API with MINA.
+     * </p>
+     * <p>
+     * To work around this limitation, we test directly at the {@link FTPClientWrapper} level:
+     * we manually CWD into a subdirectory within the chroot (e.g., {@code /cwdPreserveTest}),
+     * then call {@code isDirectory("/")}. Even within MINA's chroot, CWD from
+     * {@code /cwdPreserveTest} to {@code /} is a real directory change that we can detect.
+     * This simulates the same pattern that would occur on a non-chroot server when
+     * {@code verifyRootDirectory()} CWDs from the user's home to the server root.
+     * </p>
+     */
+    @Test
+    public void testIsDirectoryPreservesWorkingDirectory() throws Exception {
+        // Create a subdirectory to CWD into.
+        final File testDir = new File(VfsTestUtils.getTestDirectory());
+        final File subDir = new File(testDir, "cwdPreserveTest");
+        subDir.mkdirs();
+        try (final DefaultFileSystemManager manager = new DefaultFileSystemManager()) {
+            manager.addProvider("ftp", new FtpFileProvider());
+            manager.init();
+            final FileObject root = manager.resolveFile(FtpProviderTest.getConnectionUri(), createOptions());
+
+            // Get the FTPClientWrapper from the VFS filesystem.
+            final FtpFileSystem ftpFs = (FtpFileSystem) root.getFileSystem();
+            final FTPClientWrapper wrapper = (FTPClientWrapper) ftpFs.getClient();
+            final FTPClient rawClient = wrapper.getFtpClient();
+
+            try {
+                // Move into a subdirectory so we can detect if CWD "/" changes the position.
+                // This simulates a non-chroot server where the user's home (/home/ftpuser)
+                // differs from the server root (/).
+                rawClient.changeWorkingDirectory("/cwdPreserveTest");
+                final String before = rawClient.printWorkingDirectory();
+                Assertions.assertEquals("/cwdPreserveTest", before,
+                    "Precondition: should be in /cwdPreserveTest");
+
+                // isDirectory() checks existence via CWD but must save and restore the
+                // working directory. This is what verifyRootDirectory() uses to avoid
+                // the CWD side effect that would break subsequent relative path operations.
+                final boolean isDirResult = wrapper.isDirectory("/");
+                final String after = rawClient.printWorkingDirectory();
+
+                Assertions.assertTrue(isDirResult, "'/' should be recognized as a directory");
+                Assertions.assertEquals("/cwdPreserveTest", after,
+                    "isDirectory() must preserve the working directory — " +
+                    "without this, verifyRootDirectory() on non-chroot FTP servers would leave " +
+                    "the connection at '/' instead of the original position, breaking all " +
+                    "subsequent operations that use relative paths");
+            } finally {
+                ftpFs.putClient(wrapper);
+            }
+        } finally {
+            subDir.delete();
+        }
+    }
 }