VSOCK feature branch

include/multipass/ssh/libssh_wrapper.h

@@ -83,6 +83,7 @@ class Libssh : public Singleton<Libssh>
                                            int* core_dumped) const;
 
     // --- channel callbacks ---------------------------------------------------
+    virtual void ssh_callbacks_initialize(ssh_channel_callbacks callbacks) const;
     virtual int ssh_add_channel_callbacks(ssh_channel channel, ssh_channel_callbacks cb) const;
     virtual int ssh_remove_channel_callbacks(ssh_channel channel, ssh_channel_callbacks cb) const;
 

include/multipass/ssh/plain_sftp_session.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+#include <multipass/private_pass_provider.h>
+#include <multipass/ssh/plain_ssh_process.h>
+#include <multipass/ssh/plain_ssh_session.h>
+#include <multipass/sshfs_mount/sftp_session.h>
+
+#include <libssh/sftp.h> // TODO@sftp avoid this include (need to go through MP_LIBSSH)
+
+namespace multipass
+{
+
+/**
+ * A concrete SftpSession backed by an SSHFS mount: it serves the SFTP protocol over an SSH
+ * session to a remote sshfs client, which mounts it on the guest.
+ */
+class PlainSftpSession : public SftpSession, public PrivatePassProvider<PlainSftpSession>
+{
+public:
+    PlainSftpSession(PlainSSHSession&& ssh_session_obj, const std::string& sshfs_cmd);
+    PlainSftpSession(const PlainSftpSession&) = delete;
+    PlainSftpSession& operator=(const PlainSftpSession&) = delete;
+
+    // TODO@sftp Make class final before enabling these
+    PlainSftpSession(PlainSftpSession&&) = delete;
+    PlainSftpSession& operator=(PlainSftpSession&&) = delete;
+
+private:
+    // TODO@sftp avoid mentioning sftp_server_free here (need to go through MP_LIBSSH)
+    using RawSftpSessionUptr = std::unique_ptr<sftp_session_struct, decltype(sftp_server_free)*>;
+
+    static RawSftpSessionUptr make_raw_sftp_session(ssh_session raw_session, ssh_channel channel);
+
+    PlainSSHSession plain_ssh_session;
+    std::unique_ptr<PlainSSHProcess> sshfs_process;
+    RawSftpSessionUptr raw_sftp_session;
+};
+} // namespace multipass

include/multipass/ssh/plain_ssh_process.h

@@ -19,6 +19,8 @@
 
 #include <multipass/ssh/ssh_process.h>
 
+#include <multipass/private_pass_provider.h>
+
 #include <libssh/libssh.h>
 
 #include <exception>
@@ -28,12 +30,14 @@
 
 namespace multipass
 {
+class PlainSftpSession;
+
 class PlainSSHProcess : public SSHProcess
 {
 public:
     using ChannelUPtr = std::unique_ptr<ssh_channel_struct, void (*)(ssh_channel)>;
 
-    PlainSSHProcess(ssh_session_struct& ssh_session,
+    PlainSSHProcess(ssh_session_struct& raw_session,
                     const std::string& cmd,
                     std::unique_lock<std::mutex> session_lock);
 
@@ -56,6 +60,12 @@ class PlainSSHProcess : public SSHProcess
     std::string read_std_error() override;
     const std::string& get_cmd() const override;
 
+public: // but restricted
+    // Obtain a non-owning libssh channel handle.
+    // The caller adopts thread-safety responsibility for the channel with respect to this
+    // SSHProcess and the SSHSession it belongs to.
+    ssh_channel borrow_channel(const PrivatePassProvider<PlainSftpSession>::PrivatePass&);
+
 private:
     enum class StreamType
     {
@@ -70,7 +80,7 @@ class PlainSSHProcess : public SSHProcess
                                    // ensure thread safety
 
     std::unique_lock<std::mutex> session_lock; // do not attempt to re-lock, as this is moved from
-    ssh_session session;
+    ssh_session raw_session;
     std::string cmd;
     ChannelUPtr channel;
     std::variant<std::monostate, int, std::exception_ptr> exit_result;

include/multipass/ssh/plain_ssh_session.h

@@ -17,9 +17,10 @@
 
 #pragma once
 
-#include <multipass/ssh/plain_ssh_process.h>
 #include <multipass/ssh/ssh_session.h>
 
+#include <multipass/private_pass_provider.h>
+
 #include <libssh/libssh.h>
 
 #include <memory>
@@ -29,7 +30,10 @@
 namespace multipass
 {
 class SSHKeyProvider;
-class PlainSSHSession : public SSHSession
+class PlainSftpSession;
+class PlainSSHProcess;
+
+class PlainSSHSession final : public SSHSession // final to prevent chopping on move
 {
 public:
     PlainSSHSession(const std::string& host,
@@ -49,10 +53,21 @@ class PlainSSHSession : public SSHSession
 
     /**
      * @copydoc SSHSession::exec
+     *
+     * The dynamic type is always a PlainSSHProcess; see exec_plain to obtain it statically.
      */
     [[nodiscard]] std::unique_ptr<SSHProcess> exec(const std::string& cmd,
                                                    bool whisper = false) override;
 
+    /**
+     * TODO@sftp can we copydoc? partially
+     * Like exec, but statically typed to the concrete PlainSSHProcess this session produces.
+     */
+    [[nodiscard]] std::unique_ptr<PlainSSHProcess> exec_plain(const std::string& cmd,
+                                                              bool whisper = false);
+
+    std::unique_ptr<SftpSession> make_sftp_session(const std::string& sshfs_cmd) && override;
+
     /**
      * @copydoc SSHSession::is_connected
      */
@@ -63,15 +78,25 @@ class PlainSSHSession : public SSHSession
      */
     [[nodiscard]] bool is_moved() const override;
 
-    operator ssh_session() override;
+    operator ssh_session() override; // TODO@sftp remove
     void force_shutdown() override; // TODO@sftp this should not be public
 
+public: // but restricted
+    /**
+     * Obtain a non-owning libssh session handle.
+     * The caller adopts thread-safety responsibility for the underlying session with respect to
+     * this SSHSession
+     *
+     * @pre !this->is_moved()
+     */
+    ssh_session borrow_session(const PrivatePassProvider<PlainSftpSession>::PrivatePass&) const;
+
 private:
     PlainSSHSession(PlainSSHSession&&, std::unique_lock<std::mutex> lock);
 
     void set_option(ssh_options_e type, const void* value);
 
-    std::unique_ptr<ssh_session_struct, void (*)(ssh_session)> session;
+    std::unique_ptr<ssh_session_struct, void (*)(ssh_session)> raw_session;
     mutable std::mutex mut;
 };
 } // namespace multipass

include/multipass/ssh/sftp_client.h

@@ -51,7 +51,7 @@ class SFTPClient
                int port,
                const std::string& username,
                const std::string& priv_key_blob);
-    SFTPClient(SSHSessionUPtr ssh_session);
+    SFTPClient(SSHSessionUPtr ssh_session_obj);
 
     virtual bool is_remote_dir(const fs::path& path);
     virtual bool push(const fs::path& source_path, const fs::path& target_path, Flags flags = {});
@@ -69,7 +69,7 @@ class SFTPClient
     void do_push_file(std::istream& source, const fs::path& target_path);
     void do_pull_file(const fs::path& source_path, std::ostream& target);
 
-    SSHSessionUPtr ssh_session;
+    SSHSessionUPtr ssh_session_obj;
     SFTPSessionUPtr sftp;
 };
 

include/multipass/ssh/ssh_client.h

@@ -42,7 +42,7 @@ class SSHClient
               const std::string& username,
               const std::string& priv_key_blob,
               ConsoleCreator console_creator);
-    SSHClient(SSHSessionUPtr ssh_session, ConsoleCreator console_creator);
+    SSHClient(SSHSessionUPtr ssh_session_obj, ConsoleCreator console_creator);
 
     int exec(const std::vector<std::vector<std::string>>& args_list);
     int connect();
@@ -52,7 +52,7 @@ class SSHClient
     int exec_string(const std::string& cmd_line);
     int get_ssh_exit_code();
 
-    SSHSessionUPtr ssh_session;
+    SSHSessionUPtr ssh_session_obj;
     ChannelUPtr channel;
     Console::UPtr console;
 };

include/multipass/ssh/ssh_session.h

@@ -26,11 +26,17 @@
 
 namespace multipass
 {
+class SftpSession;
+
 class SSHSession
 {
 public:
     virtual ~SSHSession() = default;
 
+    // Non-copyable (but movable by descendants, see below)
+    SSHSession(const SSHSession&) = delete;
+    SSHSession& operator=(const SSHSession&) = delete;
+
     /**
      * Execute a command in this SSH session.
      *
@@ -49,6 +55,8 @@ class SSHSession
     [[nodiscard]] virtual std::unique_ptr<SSHProcess> exec(const std::string& cmd,
                                                            bool whisper = false) = 0;
 
+    virtual std::unique_ptr<SftpSession> make_sftp_session(const std::string& sshfs_cmd) && = 0;
+
     /**
      * @return Whether this object represents a session that is currently connected
      */
@@ -65,9 +73,6 @@ class SSHSession
 
 protected:
     SSHSession() = default;
-
-    SSHSession(const SSHSession&) = delete;
-    SSHSession& operator=(const SSHSession&) = delete;
     SSHSession(SSHSession&&) = default;
     SSHSession& operator=(SSHSession&&) = default;
 };

include/multipass/sshfs_mount/sftp_session.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#pragma once
+
+namespace multipass
+{
+/**
+ * A server-side SFTP session.
+ */
+class SftpSession
+{
+public:
+    virtual ~SftpSession() = default;
+
+    // No copies
+    SftpSession(const SftpSession&) = delete;
+    SftpSession& operator=(const SftpSession&) = delete;
+
+protected:
+    SftpSession() = default;
+};
+} // namespace multipass

src/ssh/CMakeLists.txt

@@ -36,10 +36,14 @@ function(add_ssh_target TARGET_NAME LIBSSH_TARGET)
   add_library(${TARGET_NAME} STATIC
     libssh_scope_guard.cpp
     openssh_key_provider.cpp
+    plain_sftp_session.cpp
     plain_ssh_process.cpp
     plain_ssh_session.cpp
     ssh_client_key_provider.cpp)
 
+  # TODO@sftp move remaining bits to MP_LIBSSH, then this should not be necessary
+  target_compile_definitions(${TARGET_NAME} PRIVATE WITH_SERVER)
+
   target_link_libraries(${TARGET_NAME}
     ${LIBSSH_TARGET}
     fmt::fmt-header-only
@@ -60,6 +64,8 @@ function(add_sftp_client_target TARGET_NAME LIBSSH_TARGET)
     sftp_utils.cpp
     plain_ssh_session.cpp)
 
+  target_compile_definitions(${TARGET_NAME} PRIVATE WITH_SERVER)
+
   target_link_libraries(${TARGET_NAME}
     ${LIBSSH_TARGET}
     fmt::fmt-header-only
@@ -78,6 +84,8 @@ function(add_ssh_client_target TARGET_NAME LIBSSH_TARGET)
     ssh_client.cpp
     plain_ssh_session.cpp)
 
+  target_compile_definitions(${TARGET_NAME} PRIVATE WITH_SERVER)
+
   target_link_libraries(${TARGET_NAME}
     ${LIBSSH_TARGET}
     console

src/ssh/libssh_wrapper.cpp

@@ -185,6 +185,11 @@ int mp::Libssh::ssh_channel_get_exit_state(ssh_channel channel,
 }
 
 // --- channel callbacks ------------------------------------------------------
+void mp::Libssh::ssh_callbacks_initialize(ssh_channel_callbacks callbacks) const
+{
+    ssh_callbacks_init(callbacks);
+}
+
 int mp::Libssh::ssh_add_channel_callbacks(ssh_channel channel, ssh_channel_callbacks cb) const
 {
     return ::ssh_add_channel_callbacks(channel, cb);