This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch fix/CAMEL-27054 in repository https://gitbox.apache.org/repos/asf/camel.git
commit af1b9127d88c9164d4ca6486353121b6083a7a8c Author: Claus Ibsen <[email protected]> AuthorDate: Mon Nov 16 14:45:31 2026 +0100 CAMEL-27054: camel-ftp - refuse a file or directory name with a carriage return or line feed The ftp and ftps file operations now refuse a remote file or directory name with a carriage return or a line feed before any command is sent for it, as the FTP control connection sends one command per line. Co-Authored-By: Claude Opus 5.5 <[email protected]> Signed-off-by: Claus Ibsen <[email protected]> --- .../apache/camel/catalog/docs/ftp-component.adoc | 7 + .../camel-ftp/src/main/docs/ftp-component.adoc | 7 + .../camel/component/file/remote/FtpOperations.java | 32 +++++ .../camel/component/file/remote/FakeFtpServer.java | 7 + .../remote/FtpProducerFileNameLineBreakTest.java | 154 +++++++++++++++++++++ .../FtpProducerFileNameLineBreakIT.java | 87 ++++++++++++ .../ROOT/pages/camel-4x-upgrade-guide-4_18.adoc | 12 ++ .../ROOT/pages/camel-4x-upgrade-guide-4_22.adoc | 12 ++ .../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc | 12 ++ 9 files changed, 330 insertions(+) diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/ftp-component.adoc b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/ftp-component.adoc index 702cbf71401e..294010afe951 100644 --- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/ftp-component.adoc +++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/ftp-component.adoc @@ -268,6 +268,13 @@ wait on that connection again: * When disconnecting, for example when the consumer or the producer stops, the client sends `QUIT` and waits at most 2 seconds (`soTimeout` when it is shorter) for its reply. +=== File and directory names with a line break + +The FTP control connection sends one command per line, so a remote file or directory name with a carriage return or +a line feed cannot be sent as the argument of one command. The `ftp` and `ftps` components refuse such a name with a +`GenericFileOperationFailedException` before they send any command for it, for example when the producer writes a file +whose `CamelFileName` header has a line break. Remove or replace these characters in the name before the producer. + [[FTP-DefaultWhenConsumingFiles]] === Default when consuming files diff --git a/components/camel-ftp/src/main/docs/ftp-component.adoc b/components/camel-ftp/src/main/docs/ftp-component.adoc index 702cbf71401e..294010afe951 100644 --- a/components/camel-ftp/src/main/docs/ftp-component.adoc +++ b/components/camel-ftp/src/main/docs/ftp-component.adoc @@ -268,6 +268,13 @@ wait on that connection again: * When disconnecting, for example when the consumer or the producer stops, the client sends `QUIT` and waits at most 2 seconds (`soTimeout` when it is shorter) for its reply. +=== File and directory names with a line break + +The FTP control connection sends one command per line, so a remote file or directory name with a carriage return or +a line feed cannot be sent as the argument of one command. The `ftp` and `ftps` components refuse such a name with a +`GenericFileOperationFailedException` before they send any command for it, for example when the producer writes a file +whose `CamelFileName` header has a line break. Remove or replace these characters in the name before the producer. + [[FTP-DefaultWhenConsumingFiles]] === Default when consuming files diff --git a/components/camel-ftp/src/main/java/org/apache/camel/component/file/remote/FtpOperations.java b/components/camel-ftp/src/main/java/org/apache/camel/component/file/remote/FtpOperations.java index fe5f3d9b0e3e..19a07b2f5bbf 100644 --- a/components/camel-ftp/src/main/java/org/apache/camel/component/file/remote/FtpOperations.java +++ b/components/camel-ftp/src/main/java/org/apache/camel/component/file/remote/FtpOperations.java @@ -374,6 +374,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { @Override public boolean deleteFile(String name) throws GenericFileOperationFailedException { log.debug("Deleting file: {}", name); + checkName(name); boolean result; String target = name; @@ -414,6 +415,8 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { @Override public boolean renameFile(String from, String to) throws GenericFileOperationFailedException { log.debug("Renaming file: {} to: {}", from, to); + checkName(from); + checkName(to); try { reconnectIfNecessary(null); return client.rename(from, to); @@ -426,6 +429,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { public boolean buildDirectory(String directory, boolean absolute) throws GenericFileOperationFailedException { // must normalize directory first directory = endpoint.getConfiguration().normalizePath(directory); + checkName(directory); log.trace("buildDirectory({})", directory); try { @@ -457,6 +461,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { @Override public boolean retrieveFile(String name, Exchange exchange, long size) throws GenericFileOperationFailedException { + checkName(name); // store the name of the file to download on the listener clientActivityListener.setDownload(true); clientActivityListener.setRemoteFileName(name); @@ -742,6 +747,8 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { public boolean storeFile(String name, Exchange exchange, long size) throws GenericFileOperationFailedException { // must normalize name first name = endpoint.getConfiguration().normalizePath(name); + // before the listener and the client, so nothing is sent for a name that is refused + checkName(name); // store the name of the file to upload on the listener clientActivityListener.setDownload(false); @@ -884,6 +891,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { @Override public boolean storeFileDirectly(String name, String payload) throws GenericFileOperationFailedException { + checkName(name); ByteArrayInputStream bis = new ByteArrayInputStream(payload.getBytes()); try { return client.storeFile(name, bis); @@ -897,6 +905,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { @Override public boolean existsFile(String name) throws GenericFileOperationFailedException { log.trace("existsFile({})", name); + checkName(name); if (endpoint.isFastExistsCheck()) { return fastExistsFile(name); } @@ -929,6 +938,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { protected boolean fastExistsFile(String name) throws GenericFileOperationFailedException { log.trace("fastExistsFile({})", name); + checkName(name); try { String[] names = client.listNames(name); if (names == null) { @@ -958,6 +968,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { if (org.apache.camel.util.ObjectHelper.isEmpty(path)) { return; } + checkName(path); // must compact path so FTP server can traverse correctly // use the ftp utils implementation of the compact path @@ -1045,6 +1056,7 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { if (org.apache.camel.util.ObjectHelper.isEmpty(path)) { path = "."; } + checkName(path); try { return checkListing(client.listFiles(path), "directory: " + path); @@ -1096,6 +1108,26 @@ public class FtpOperations implements RemoteFileOperations<FTPFile> { } } + /** + * The FTP control connection sends one command per line, so a file or directory name with a carriage return or a + * line feed cannot be sent as the argument of a single command. Such a name is refused before any command is sent. + * The message gives the character and its index, not the name. + */ + private static void checkName(String name) { + if (name == null) { + return; + } + for (int i = 0; i < name.length(); i++) { + char ch = name.charAt(i); + if (ch == '\r' || ch == '\n') { + throw new GenericFileOperationFailedException( + String.format("Cannot use the file or directory name: it has the character U+%04X at index %d, and a" + + " carriage return or a line feed cannot be sent in an FTP command", + (int) ch, i)); + } + } + } + protected FTPClient getFtpClient() { return client; } diff --git a/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FakeFtpServer.java b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FakeFtpServer.java index c84710caac1a..19a0028cf9db 100644 --- a/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FakeFtpServer.java +++ b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FakeFtpServer.java @@ -70,6 +70,7 @@ final class FakeFtpServer implements Closeable { private final Map<String, byte[]> files = new ConcurrentHashMap<>(); private final Set<String> directories = ConcurrentHashMap.newKeySet(); private final List<Connection> connections = new CopyOnWriteArrayList<>(); + private final List<String> commands = new CopyOnWriteArrayList<>(); private final AtomicInteger connectionIds = new AtomicInteger(); private volatile Predicate<String> trigger; private volatile Stall stall = Stall.BEFORE_REPLY; @@ -119,6 +120,11 @@ final class FakeFtpServer implements Closeable { return answer; } + /** Every command line the server received, on any connection, in the order received. */ + List<String> commands() { + return commands; + } + /** How many control connections the client has opened so far. */ int connectionsOpened() { return connectionIds.get(); @@ -181,6 +187,7 @@ final class FakeFtpServer implements Closeable { reply("220 fake FTP server ready (connection " + id + ")"); String line; while ((line = in.readLine()) != null) { + commands.add(line); Predicate<String> t = trigger; if (!silent && t != null && t.test(line)) { // one shot: only the first matching connection stalls diff --git a/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FtpProducerFileNameLineBreakTest.java b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FtpProducerFileNameLineBreakTest.java new file mode 100644 index 000000000000..4ffe7bda3e56 --- /dev/null +++ b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FtpProducerFileNameLineBreakTest.java @@ -0,0 +1,154 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.file.remote; + +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.Set; + +import org.apache.camel.CamelExecutionException; +import org.apache.camel.Exchange; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.file.GenericFileOperationFailedException; +import org.apache.camel.test.junit6.CamelTestSupport; +import org.apache.commons.net.ftp.FTPFile; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.apache.camel.test.junit6.TestSupport.assertIsInstanceOf; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The FTP control connection sends one command per line, so the ftp producer and the ftp operations refuse a file or + * directory name with a carriage return or a line feed, and send nothing to the server for it. + */ +public class FtpProducerFileNameLineBreakTest extends CamelTestSupport { + + private static final String EXISTING = "/outbox/existing.txt"; + + private FakeFtpServer server; + + @BeforeEach + void startServer() throws Exception { + server = new FakeFtpServer(); + server.addFile(EXISTING, "existing".getBytes(StandardCharsets.UTF_8)); + } + + @AfterEach + void stopServer() throws Exception { + server.close(); + } + + private String ftpUri(String options) { + String uri = "ftp://[email protected]:" + server.port() + + "/outbox?password=secret&passiveMode=true&soTimeout=5000&timeout=5000"; + return options.isEmpty() ? uri : uri + "&" + options; + } + + private void addRoute(String options) throws Exception { + context.addRoutes(new RouteBuilder() { + @Override + public void configure() { + from("direct:upload").to(ftpUri(options)); + } + }); + } + + @ParameterizedTest + @ValueSource(strings = { + "before\nafter.txt", "before\rafter.txt", "before\r\nafter.txt", "before\r\nafter/hello.txt", + "sub/before\nafter.txt" }) + void fileNameWithLineBreakIsRefused(String name) throws Exception { + addRoute(""); + + assertRefused(name); + } + + @ParameterizedTest + @ValueSource(strings = { + "stepwise=false", "tempFileName=${file:name}.tmp", "tempPrefix=tmp-", "fileExist=Move&moveExisting=old", + "fileExist=Append", "fileExist=Fail", "fileExist=Ignore&fastExistsCheck=true", "chmod=640", + "doneFileName=${file:name}.done" }) + void fileNameWithLineBreakIsRefusedWithOption(String options) throws Exception { + addRoute(options); + + assertRefused("before\r\nafter.txt"); + } + + @Test + void plainFileNameIsStored() throws Exception { + addRoute("tempFileName=${file:name}.tmp&doneFileName=${file:name}.done&chmod=640"); + + template.sendBodyAndHeader("direct:upload", "hello", Exchange.FILE_NAME, "hello.txt"); + + assertEquals("hello", new String(server.files().get("/outbox/hello.txt"), StandardCharsets.UTF_8)); + assertTrue(server.files().containsKey("/outbox/hello.txt.done")); + } + + @Test + void operationsRefuseNameWithLineBreak() throws Exception { + FtpEndpoint<FTPFile> endpoint = context.getEndpoint(ftpUri(""), FtpEndpoint.class); + RemoteFileOperations<FTPFile> operations = endpoint.createRemoteFileOperations(); + operations.connect(endpoint.getConfiguration(), null); + Exchange exchange = endpoint.createExchange(); + String name = "before\nafter.txt"; + try { + List<Executable> calls = List.of( + () -> operations.deleteFile(name), + () -> operations.renameFile("existing.txt", name), + () -> operations.renameFile(name, "renamed.txt"), + () -> operations.buildDirectory(name, false), + () -> operations.existsFile(name), + () -> operations.changeCurrentDirectory(name), + () -> operations.listFiles(name), + () -> operations.storeFileDirectly(name, "hello"), + () -> operations.retrieveFile(name, exchange, 5)); + for (Executable call : calls) { + GenericFileOperationFailedException e = assertThrows(GenericFileOperationFailedException.class, call); + assertTrue(e.getMessage().contains("U+000A at index 6"), e.getMessage()); + } + } finally { + operations.disconnect(); + } + + assertNothingSentFor(); + } + + private void assertRefused(String name) { + CamelExecutionException e = assertThrows(CamelExecutionException.class, + () -> template.sendBodyAndHeader("direct:upload", "hello", Exchange.FILE_NAME, name)); + GenericFileOperationFailedException cause = assertIsInstanceOf(GenericFileOperationFailedException.class, e.getCause()); + assertTrue(cause.getMessage().contains("a carriage return or a line feed cannot be sent in an FTP command"), + cause.getMessage()); + + assertNothingSentFor(); + assertEquals(Set.of(EXISTING), server.files().keySet()); + } + + private void assertNothingSentFor() { + List<String> sent = server.commands().stream() + .filter(command -> command.contains("before") || command.contains("after")) + .toList(); + assertEquals(List.of(), sent, "Commands received for the refused name: " + server.commands()); + } +} diff --git a/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/integration/FtpProducerFileNameLineBreakIT.java b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/integration/FtpProducerFileNameLineBreakIT.java new file mode 100644 index 000000000000..1196f2bbd12a --- /dev/null +++ b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/integration/FtpProducerFileNameLineBreakIT.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.camel.component.file.remote.integration; + +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.stream.Stream; + +import org.apache.camel.CamelExecutionException; +import org.apache.camel.Exchange; +import org.apache.camel.builder.RouteBuilder; +import org.apache.camel.component.file.GenericFileOperationFailedException; +import org.junit.jupiter.api.Test; + +import static org.apache.camel.test.junit6.TestSupport.assertIsInstanceOf; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * The ftp producer refuses a file or directory name with a carriage return or a line feed, as the FTP control + * connection sends one command per line, and the server gets no file or directory for it. + */ +public class FtpProducerFileNameLineBreakIT extends FtpServerTestSupport { + + private String getFtpUrl() { + return "ftp://admin@localhost:{{ftp.server.port}}/upload/linebreak?password=admin"; + } + + @Test + public void testFileNameWithLineBreakIsRefused() throws Exception { + CamelExecutionException e = assertThrows(CamelExecutionException.class, + () -> template.sendBodyAndHeader("direct:start", "Hello World", Exchange.FILE_NAME, "before\r\nafter.txt")); + GenericFileOperationFailedException cause = assertIsInstanceOf(GenericFileOperationFailedException.class, e.getCause()); + assertTrue(cause.getMessage().contains("the character U+000D"), cause.getMessage()); + + assertEquals(List.of(), serverEntriesNamed("before", "after")); + } + + @Test + public void testDirectoryNameWithLineBreakIsRefused() throws Exception { + CamelExecutionException e = assertThrows(CamelExecutionException.class, + () -> template.sendBodyAndHeader("direct:start", "Hello World", Exchange.FILE_NAME, "before\nafter/hello.txt")); + assertIsInstanceOf(GenericFileOperationFailedException.class, e.getCause()); + + assertEquals(List.of(), serverEntriesNamed("before", "after")); + } + + @Test + public void testPlainFileNameIsStored() throws Exception { + template.sendBodyAndHeader("direct:start", "Hello World", Exchange.FILE_NAME, "hello.txt"); + + assertEquals("Hello World", Files.readString(service.ftpFile("upload/linebreak/hello.txt"))); + } + + private List<Path> serverEntriesNamed(String... parts) throws Exception { + try (Stream<Path> entries = Files.walk(service.getFtpRootDir())) { + return entries.filter(p -> Stream.of(parts).anyMatch(part -> p.getFileName().toString().contains(part))) + .toList(); + } + } + + @Override + protected RouteBuilder createRouteBuilder() { + return new RouteBuilder() { + @Override + public void configure() { + from("direct:start").to(getFtpUrl()); + } + }; + } +} diff --git a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_18.adoc b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_18.adoc index 4bbc681f44c7..a3a9d1f2fd70 100644 --- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_18.adoc +++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_18.adoc @@ -93,6 +93,18 @@ wildcard to select a file, use the real name of the file in the producer, and th consumer that lists the directory instead of a wildcard in `fileName` with `useList=false`. See the xref:components::sftp-component.adoc[SFTP component]. +=== camel-ftp - ftp and ftps refuse a file or directory name with a carriage return or a line feed + +The `ftp` and `ftps` components now refuse a remote file or directory name with a carriage return or a line feed, with +a `GenericFileOperationFailedException`, before they send any command to the server for it. This applies to the name +the producer writes (the `CamelFileName` header, `tempFileName`, `doneFileName` and `moveExisting`), to the directories +it creates or changes to, and to the names the consumer retrieves, deletes, renames or lists. + +The FTP control connection sends one command per line, so such a name cannot be sent as one command. Before, the server +got the name cut at the line break: the operation failed or acted on another file, and the replies of the later +commands on that connection could get out of step. Remove or replace these characters in the name before the producer. +The `sftp` component is not affected. See the xref:components::ftp-component.adoc[FTP component]. + === camel-file - jailStartingDirectory resolves symbolic links With `jailStartingDirectory` enabled (the default), the file consumer and producer now resolve symbolic links when diff --git a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_22.adoc b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_22.adoc index 2b1de60e6ac8..906ef31cdef4 100644 --- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_22.adoc +++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_22.adoc @@ -114,6 +114,18 @@ wildcard to select a file, use the real name of the file in the producer, and th consumer that lists the directory instead of a wildcard in `fileName` with `useList=false`. See the xref:components::sftp-component.adoc[SFTP component]. +=== camel-ftp - ftp and ftps refuse a file or directory name with a carriage return or a line feed + +The `ftp` and `ftps` components now refuse a remote file or directory name with a carriage return or a line feed, with +a `GenericFileOperationFailedException`, before they send any command to the server for it. This applies to the name +the producer writes (the `CamelFileName` header, `tempFileName`, `doneFileName` and `moveExisting`), to the directories +it creates or changes to, and to the names the consumer retrieves, deletes, renames or lists. + +The FTP control connection sends one command per line, so such a name cannot be sent as one command. Before, the server +got the name cut at the line break: the operation failed or acted on another file, and the replies of the later +commands on that connection could get out of step. Remove or replace these characters in the name before the producer. +The `sftp` component is not affected. See the xref:components::ftp-component.adoc[FTP component]. + === camel-file - the consumer skips a file it would move through a symbolic link resolving outside the starting directory With `jailStartingDirectory` enabled (the default), the file consumer now resolves symbolic links on the targets of diff --git a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc index 2eb785749a2b..9cd3f57d1b00 100644 --- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc +++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc @@ -413,6 +413,18 @@ the `include` or `antInclude` option. See the xref:components::sftp-component.adoc[SFTP component]. +=== camel-ftp - ftp and ftps refuse a file or directory name with a carriage return or a line feed + +The `ftp` and `ftps` components now refuse a remote file or directory name with a carriage return or a line feed, with +a `GenericFileOperationFailedException`, before they send any command to the server for it. This applies to the name +the producer writes (the `CamelFileName` header, `tempFileName`, `doneFileName` and `moveExisting`), to the directories +it creates or changes to, and to the names the consumer retrieves, deletes, renames or lists. + +The FTP control connection sends one command per line, so such a name cannot be sent as one command. Before, the server +got the name cut at the line break: the operation failed or acted on another file, and the replies of the later +commands on that connection could get out of step. Remove or replace these characters in the name before the producer. +The `sftp` component is not affected. See the xref:components::ftp-component.adoc[FTP component]. + === camel-ftp - a directory listing the server refuses fails the poll The `ftp` and `ftps` consumers now fail the poll when the server refuses the listing of a directory, for example the
