This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch camel-4.18.x
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/camel-4.18.x by this push:
     new 4f99fe87d9a4 [backport camel-4.18.x] CAMEL-27054: camel-ftp - refuse a 
file or directory name with a carriage return or line feed (#30425)
4f99fe87d9a4 is described below

commit 4f99fe87d9a4685fbd88fc13e632fb8cf5445a3d
Author: Claus Ibsen <[email protected]>
AuthorDate: Thu Nov 19 17:47:09 2026 +0100

    [backport camel-4.18.x] CAMEL-27054: camel-ftp - refuse a file or directory 
name with a carriage return or line feed (#30425)
    
    FtpOperations (also used by ftps) checks every remote file or directory name
    before it sends a command for it, and refuses a name with a carriage return 
or a
    line feed with a GenericFileOperationFailedException. Nothing is sent to the
    server for it. siteCommand is unchanged.
    
    Backport of #30211 to camel-4.18.x. The FakeFtpServer test helper (from
    CAMEL-26999/CAMEL-27000, not on this branch) comes along with the tests. The
    upgrade guide note for this release is on main.
    The new tests use camel-test-junit5 on this branch.
    
    (cherry picked from commit 9d7c28bb470242877e4109e1453830565f3847ac)
    
    Co-Authored-By: Claude Opus 5.5 <[email protected]>
    Signed-off-by: Claus Ibsen <[email protected]>
---
 .../camel-ftp/src/main/docs/ftp-component.adoc     |   7 +
 .../camel/component/file/remote/FtpOperations.java |  32 ++
 .../camel/component/file/remote/FakeFtpServer.java | 402 +++++++++++++++++++++
 .../remote/FtpProducerFileNameLineBreakTest.java   | 154 ++++++++
 .../FtpProducerFileNameLineBreakIT.java            |  87 +++++
 5 files changed, 682 insertions(+)

diff --git a/components/camel-ftp/src/main/docs/ftp-component.adoc 
b/components/camel-ftp/src/main/docs/ftp-component.adoc
index 67b217e73d0f..e5f93d131972 100644
--- a/components/camel-ftp/src/main/docs/ftp-component.adoc
+++ b/components/camel-ftp/src/main/docs/ftp-component.adoc
@@ -184,6 +184,13 @@ It is only a single endpoint that does not support 
concurrent consumers.
 
 The FTP producer does *not* have this issue, it supports concurrency.
 
+=== 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 0b942b47248a..9d1955afd3c7 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
@@ -324,6 +324,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;
@@ -364,6 +365,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);
@@ -376,6 +379,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 {
@@ -407,6 +411,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);
@@ -674,6 +679,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);
@@ -816,6 +823,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);
@@ -829,6 +837,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);
         }
@@ -861,6 +870,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) {
@@ -890,6 +900,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
@@ -978,6 +989,7 @@ public class FtpOperations implements 
RemoteFileOperations<FTPFile> {
         if (org.apache.camel.util.ObjectHelper.isEmpty(path)) {
             path = ".";
         }
+        checkName(path);
 
         try {
             return client.listFiles(path);
@@ -1007,6 +1019,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
new file mode 100644
index 000000000000..19a0028cf9db
--- /dev/null
+++ 
b/components/camel-ftp/src/test/java/org/apache/camel/component/file/remote/FakeFtpServer.java
@@ -0,0 +1,402 @@
+/*
+ * 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.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Predicate;
+
+/**
+ * A minimal in-memory FTP server (passive mode only) that can stop answering 
on a connection that stays open, as a
+ * server that hangs, or a network path that is lost without closing the 
connection, does.
+ * <p>
+ * It serves the commands the ftp client sends with the default options and 
{@code passiveMode=true}: login, SYST, TYPE,
+ * PWD, CWD, CDUP, MKD, NOOP, PASV, LIST, NLST, RETR, STOR, DELE, RNFR/RNTO, 
SIZE, MDTM and QUIT. A silent connection
+ * keeps reading and records every command it receives, but never answers 
again. New connections are served normally, so
+ * a client that opens a new connection recovers.
+ */
+final class FakeFtpServer implements Closeable {
+
+    /** How the server stops answering when the trigger command arrives. */
+    enum Stall {
+        /** The trigger command gets no reply: the client waits for the reply 
on the control connection. */
+        BEFORE_REPLY,
+        /**
+         * The trigger RETR gets its 150 reply and half of the file on the 
data connection, then nothing more on either
+         * connection: the client waits on the data connection.
+         */
+        MID_TRANSFER
+    }
+
+    private final ServerSocket serverSocket;
+    private final ExecutorService executor = Executors.newCachedThreadPool(r 
-> {
+        Thread t = new Thread(r, "fake-ftp-server");
+        t.setDaemon(true);
+        return t;
+    });
+    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;
+    private volatile boolean closed;
+
+    FakeFtpServer() throws IOException {
+        serverSocket = new ServerSocket(0, 50, 
InetAddress.getLoopbackAddress());
+        directories.add("/");
+        executor.execute(this::acceptLoop);
+    }
+
+    int port() {
+        return serverSocket.getLocalPort();
+    }
+
+    void addFile(String path, byte[] content) {
+        String file = normalize(path);
+        String parent = parentOf(file);
+        while (!parent.equals("/")) {
+            directories.add(parent);
+            parent = parentOf(parent);
+        }
+        files.put(file, content);
+    }
+
+    Map<String, byte[]> files() {
+        return files;
+    }
+
+    /**
+     * The first connection that receives a command matching {@code command} 
stops answering, from that command on.
+     */
+    void stallOn(Predicate<String> command, Stall how) {
+        this.stall = how;
+        this.trigger = command;
+    }
+
+    /** Every open connection stops answering from now on. New connections are 
served. */
+    void silenceOpenConnections() {
+        connections.forEach(c -> c.silent = true);
+    }
+
+    /** The commands the client sent on a connection after that connection 
stopped answering. */
+    List<String> commandsOnSilentConnections() {
+        List<String> answer = new ArrayList<>();
+        connections.forEach(c -> answer.addAll(c.unanswered));
+        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();
+    }
+
+    /** How many connections that stopped answering the client has not closed. 
*/
+    long silentConnectionsOpen() {
+        return connections.stream().filter(c -> c.silent && !c.ended).count();
+    }
+
+    @Override
+    public void close() throws IOException {
+        closed = true;
+        serverSocket.close();
+        for (Connection c : connections) {
+            c.close();
+        }
+        executor.shutdownNow();
+    }
+
+    private void acceptLoop() {
+        while (!closed) {
+            try {
+                Socket socket = serverSocket.accept();
+                Connection c = new Connection(socket, 
connectionIds.incrementAndGet());
+                connections.add(c);
+                executor.execute(c);
+            } catch (IOException e) {
+                // closed
+                return;
+            }
+        }
+    }
+
+    private final class Connection implements Runnable {
+
+        private final Socket socket;
+        private final int id;
+        private final List<String> unanswered = new CopyOnWriteArrayList<>();
+        private volatile boolean silent;
+        private volatile boolean ended;
+        private ServerSocket passive;
+        // a data connection left open by a stalled transfer
+        private Socket stalledData;
+        private OutputStream out;
+        private String cwd = "/";
+        private String renameFrom;
+
+        Connection(Socket socket, int id) {
+            this.socket = socket;
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            try {
+                BufferedReader in = new BufferedReader(
+                        new InputStreamReader(socket.getInputStream(), 
StandardCharsets.UTF_8));
+                out = socket.getOutputStream();
+                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
+                        trigger = null;
+                        if (stall == Stall.MID_TRANSFER && 
line.startsWith("RETR ")) {
+                            startTransferThenStall(line.substring(5).trim());
+                        }
+                        silent = true;
+                        continue;
+                    }
+                    if (silent) {
+                        unanswered.add(line);
+                        continue;
+                    }
+                    if (!handle(line)) {
+                        break;
+                    }
+                }
+            } catch (IOException e) {
+                // the client or the test closed the connection
+            } finally {
+                ended = true;
+                close();
+            }
+        }
+
+        private boolean handle(String line) throws IOException {
+            int space = line.indexOf(' ');
+            String cmd = (space < 0 ? line : line.substring(0, 
space)).toUpperCase();
+            String arg = space < 0 ? "" : line.substring(space + 1).trim();
+            switch (cmd) {
+                case "USER" -> reply("331 Password required");
+                case "PASS" -> reply("230 Logged in");
+                case "SYST" -> reply("215 UNIX Type: L8");
+                case "TYPE", "MODE", "STRU", "OPTS", "SITE", "NOOP" -> 
reply("200 OK");
+                case "PWD", "XPWD" -> reply("257 \"" + cwd + "\" is the 
current directory");
+                case "CWD" -> {
+                    String dir = resolve(arg);
+                    if (directories.contains(dir)) {
+                        cwd = dir;
+                        reply("250 OK");
+                    } else {
+                        reply("550 No such directory");
+                    }
+                }
+                case "CDUP" -> {
+                    cwd = parentOf(cwd);
+                    reply("250 OK");
+                }
+                case "MKD" -> {
+                    directories.add(resolve(arg));
+                    reply("257 \"" + resolve(arg) + "\" created");
+                }
+                case "PASV" -> {
+                    closePassive();
+                    passive = new ServerSocket(0, 1, 
InetAddress.getLoopbackAddress());
+                    passive.setSoTimeout(10000);
+                    int p = passive.getLocalPort();
+                    reply("227 Entering Passive Mode (127,0,0,1," + (p >> 8) + 
"," + (p & 0xff) + ")");
+                }
+                case "LIST", "NLST" -> list(cmd, arg);
+                case "RETR" -> retrieve(arg);
+                case "STOR" -> store(arg);
+                case "DELE" -> reply(files.remove(resolve(arg)) != null ? "250 
Deleted" : "550 No such file");
+                case "RNFR" -> {
+                    renameFrom = resolve(arg);
+                    reply(files.containsKey(renameFrom) ? "350 Ready for RNTO" 
: "550 No such file");
+                }
+                case "RNTO" -> {
+                    byte[] data = renameFrom != null ? 
files.remove(renameFrom) : null;
+                    if (data != null) {
+                        addFile(resolve(arg), data);
+                        reply("250 Renamed");
+                    } else {
+                        reply("550 No such file");
+                    }
+                }
+                case "SIZE" -> {
+                    byte[] data = files.get(resolve(arg));
+                    reply(data != null ? "213 " + data.length : "550 No such 
file");
+                }
+                case "MDTM" -> reply(files.containsKey(resolve(arg)) ? "213 
20250101000000" : "550 No such file");
+                case "QUIT" -> {
+                    reply("221 Bye");
+                    return false;
+                }
+                default -> reply("502 Command not implemented");
+            }
+            return true;
+        }
+
+        private void list(String cmd, String arg) throws IOException {
+            String dir = cwd;
+            for (String token : arg.split(" ")) {
+                if (!token.isEmpty() && !token.startsWith("-")) {
+                    dir = resolve(token);
+                }
+            }
+            StringBuilder listing = new StringBuilder();
+            for (Map.Entry<String, byte[]> e : new 
TreeMap<>(files).entrySet()) {
+                if (parentOf(e.getKey()).equals(dir)) {
+                    String name = 
e.getKey().substring(e.getKey().lastIndexOf('/') + 1);
+                    if (cmd.equals("NLST")) {
+                        listing.append(name).append("\r\n");
+                    } else {
+                        listing.append("-rw-r--r-- 1 camel camel 
").append(e.getValue().length)
+                                .append(" Jan 01  2025 
").append(name).append("\r\n");
+                    }
+                }
+            }
+            transfer(listing.toString().getBytes(StandardCharsets.UTF_8));
+        }
+
+        private void retrieve(String arg) throws IOException {
+            byte[] data = files.get(resolve(arg));
+            if (data == null) {
+                reply("550 No such file");
+                return;
+            }
+            transfer(data);
+        }
+
+        private void transfer(byte[] data) throws IOException {
+            reply("150 Opening data connection");
+            try (Socket d = passive.accept(); OutputStream o = 
d.getOutputStream()) {
+                o.write(data);
+            } finally {
+                closePassive();
+            }
+            reply("226 Transfer complete");
+        }
+
+        private void startTransferThenStall(String arg) throws IOException {
+            byte[] data = files.get(resolve(arg));
+            reply("150 Opening data connection");
+            stalledData = passive.accept();
+            OutputStream o = stalledData.getOutputStream();
+            o.write(data, 0, data.length / 2);
+            o.flush();
+            // the rest of the file and the 226 reply never come, and the data 
connection stays open
+        }
+
+        private void store(String arg) throws IOException {
+            reply("150 Opening data connection");
+            ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            try (Socket d = passive.accept(); InputStream i = 
d.getInputStream()) {
+                i.transferTo(bos);
+            } finally {
+                closePassive();
+            }
+            addFile(resolve(arg), bos.toByteArray());
+            reply("226 Transfer complete");
+        }
+
+        private String resolve(String path) {
+            if (path.isEmpty()) {
+                return cwd;
+            }
+            return normalize(path.startsWith("/") ? path : cwd + "/" + path);
+        }
+
+        private void reply(String line) throws IOException {
+            out.write((line + "\r\n").getBytes(StandardCharsets.UTF_8));
+            out.flush();
+        }
+
+        private void closePassive() {
+            if (passive != null) {
+                try {
+                    passive.close();
+                } catch (IOException e) {
+                    // ignore
+                }
+                passive = null;
+            }
+        }
+
+        void close() {
+            closePassive();
+            try {
+                if (stalledData != null) {
+                    stalledData.close();
+                }
+                socket.close();
+            } catch (IOException e) {
+                // ignore
+            }
+        }
+    }
+
+    static String normalize(String path) {
+        List<String> parts = new ArrayList<>();
+        for (String p : path.split("/")) {
+            if (p.isEmpty() || p.equals(".")) {
+                continue;
+            }
+            if (p.equals("..")) {
+                if (!parts.isEmpty()) {
+                    parts.remove(parts.size() - 1);
+                }
+            } else {
+                parts.add(p);
+            }
+        }
+        return "/" + String.join("/", parts);
+    }
+
+    static String parentOf(String path) {
+        int i = path.lastIndexOf('/');
+        return i <= 0 ? "/" : path.substring(0, i);
+    }
+}
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..db312964d7a8
--- /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.junit5.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.junit5.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..483e90ee0b03
--- /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.junit5.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());
+            }
+        };
+    }
+}

Reply via email to