Update libssh to 0.11.1

3rd-party/libssh/CMakeLists.txt

@@ -59,7 +59,7 @@ file(STRINGS libssh/CMakeLists.txt libssh_VERSION REGEX "^project\\(libssh")
 file(STRINGS libssh/CMakeLists.txt LIBRARY_VERSION REGEX "^set\\(LIBRARY_VERSION")
 file(STRINGS libssh/CMakeLists.txt LIBRARY_SOVERSION REGEX "^set\\(LIBRARY_SOVERSION")
 
-string(REGEX MATCH "^project\\(libssh VERSION ([0-9]+)\\.([0-9]+)\\.([0-9]+) LANGUAGES C\\)$"
+string(REGEX MATCH "^project\\(libssh VERSION ([0-9]+)\\.([0-9]+)\\.([0-9]+) LANGUAGES C CXX\\)$"
   libssh_VERSION "${libssh_VERSION}")
 if (NOT libssh_VERSION)
     message(FATAL_ERROR "unable to find libssh project version")

3rd-party/submodule_info.md

@@ -12,7 +12,7 @@ Version: 1.52.1 (+[our patches](https://github.com/CanonicalLtd/grpc/compare/v1.
 <https://github.com/grpc/grpc/releases>
 
 ### libssh
-Version: 0.10.6 (+[our patches](https://github.com/canonical/libssh/compare/libssh-0.10.6...multipass)) |
+Version: 0.11.1 (+[our patches](https://github.com/canonical/libssh/compare/libssh-0.11.1...multipass)) |
 <https://github.com/canonical/libssh.git> |
 <https://www.libssh.org/>
 

include/multipass/platform.h

@@ -91,7 +91,11 @@ std::unique_ptr<Process> make_sshfs_server_process(const SSHFSServerConfig& conf
 std::unique_ptr<Process> make_process(std::unique_ptr<ProcessSpec>&& process_spec);
 int symlink_attr_from(const char* path, sftp_attributes_struct* attr);
 
-std::function<int()> make_quit_watchdog(); // call while single-threaded; call result later, in dedicated thread
+// Creates a function that will wait for signals or until the passed function returns false.
+// The passed function is checked every `period` milliseconds.
+// If a signal is received the optional contains it, otherwise the optional is empty.
+std::function<std::optional<int>(const std::function<bool()>&)> make_quit_watchdog(
+    const std::chrono::milliseconds& period); // call while single-threaded; call result later, in dedicated thread
 
 std::string reinterpret_interface_id(const std::string& ux_id); // give platforms a chance to reinterpret network IDs
 

include/multipass/platform_unix.h

@@ -22,12 +22,25 @@
 
 #include <signal.h>
 
-namespace multipass
+#include "singleton.h"
+
+#define MP_POSIX_SIGNAL multipass::platform::SignalWrapper::instance()
+
+namespace multipass::platform
 {
-namespace platform
+
+class SignalWrapper : public Singleton<SignalWrapper>
 {
+public:
+    SignalWrapper(const PrivatePass&) noexcept;
+
+    virtual int mask_signals(int how, const sigset_t* sigset, sigset_t* old_set = nullptr) const;
+    virtual int send(pthread_t target, int signal) const;
+    virtual int wait(const sigset_t& sigset, int& got) const;
+};
+
 sigset_t make_sigset(const std::vector<int>& sigs);
 sigset_t make_and_block_signals(const std::vector<int>& sigs);
-} // namespace platform
-}
+
+} // namespace multipass::platform
 #endif // MULTIPASS_PLATFORM_UNIX_H

include/multipass/ssh/ssh_session.h

@@ -33,11 +33,7 @@ class SSHKeyProvider;
 class SSHSession
 {
 public:
-    SSHSession(const std::string& host,
-               int port,
-               const std::string& ssh_username,
-               const SSHKeyProvider& key_provider,
-               const std::chrono::milliseconds timeout = std::chrono::seconds(20));
+    SSHSession(const std::string& host, int port, const std::string& ssh_username, const SSHKeyProvider& key_provider);
 
     // just being explicit (unique_ptr member already caused these to be deleted)
     SSHSession(const SSHSession&) = delete;

src/platform/console/unix_console.cpp

@@ -71,13 +71,14 @@
 
     if (term->is_live())
     {
-        setup_console();
-
         const char* term_type = std::getenv("TERM");
         term_type = (term_type == nullptr) ? "xterm" : term_type;
 
         update_local_pty_size(term->cout_fd());
         ssh_channel_request_pty_size(channel, term_type, local_pty_size.columns, local_pty_size.rows);
+
+        // set stdin to Raw Mode after libssh inherits sane settings from stdin.
+        setup_console();
     }
 }
 

src/platform/platform_unix.cpp

@@ -17,6 +17,7 @@
 #include <multipass/format.h>
 #include <multipass/platform.h>
 #include <multipass/platform_unix.h>
+#include <multipass/timer.h>
 #include <multipass/utils.h>
 
 #include <grp.h>
@@ -157,6 +158,25 @@
     return 0;
 }
 
+mp::platform::SignalWrapper::SignalWrapper(const PrivatePass& pass) noexcept : Singleton(pass)
+{
+}
+
+int mp::platform::SignalWrapper::mask_signals(int how, const sigset_t* sigset, sigset_t* old_set) const
+{
+    return pthread_sigmask(how, sigset, old_set);
+}
+
+int mp::platform::SignalWrapper::send(pthread_t target, int signal) const
+{
+    return pthread_kill(target, signal);
+}
+
+int mp::platform::SignalWrapper::wait(const sigset_t& sigset, int& got) const
+{
+    return sigwait(std::addressof(sigset), std::addressof(got));
+}
+
 sigset_t mp::platform::make_sigset(const std::vector<int>& sigs)
 {
     sigset_t sigset;
@@ -171,15 +191,38 @@
 sigset_t mp::platform::make_and_block_signals(const std::vector<int>& sigs)
 {
     auto sigset{make_sigset(sigs)};
-    pthread_sigmask(SIG_BLOCK, &sigset, nullptr);
+    MP_POSIX_SIGNAL.mask_signals(SIG_BLOCK, &sigset, nullptr);
     return sigset;
 }
 
-std::function<int()> mp::platform::make_quit_watchdog()
+template <class Rep, class Period>
+timespec make_timespec(std::chrono::duration<Rep, Period> duration)
+{
+    const auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+    return timespec{seconds.count(), std::chrono::duration_cast<std::chrono::nanoseconds>(duration - seconds).count()};
+}
+
+std::function<std::optional<int>(const std::function<bool()>&)> mp::platform::make_quit_watchdog(
+    const std::chrono::milliseconds& period)
 {
-    return [sigset = make_and_block_signals({SIGQUIT, SIGTERM, SIGHUP})]() {
-        int sig = -1;
-        sigwait(&sigset, &sig);
-        return sig;
+    return [sigset = make_and_block_signals({SIGQUIT, SIGTERM, SIGHUP, SIGUSR2}),
+            period](const std::function<bool()>& condition) -> std::optional<int> {
+        // create a timer to periodically send SIGUSR2
+        utils::Timer signal_generator{period, [signalee = pthread_self()] { MP_POSIX_SIGNAL.send(signalee, SIGUSR2); }};
+
+        // wait on signals and condition
+        int latest_signal = SIGUSR2;
+        while (latest_signal == SIGUSR2 && condition())
+        {
+            signal_generator.start();
+
+            // can't use sigtimedwait since macOS doesn't support it
+            MP_POSIX_SIGNAL.wait(sigset, latest_signal);
+        }
+
+        signal_generator.stop();
+
+        // if `latest_signal` is SIGUSR2 then we know `condition()` is false
+        return latest_signal == SIGUSR2 ? std::nullopt : std::make_optional(latest_signal);
     };
 }

src/ssh/ssh_session.cpp

@@ -33,14 +33,13 @@ namespace mpl = multipass::logging;
 mp::SSHSession::SSHSession(const std::string& host,
                            int port,
                            const std::string& username,
-                           const SSHKeyProvider& key_provider,
-                           const std::chrono::milliseconds timeout)
+                           const SSHKeyProvider& key_provider)
     : session{ssh_new(), ssh_free}, mut{}
 {
     if (session == nullptr)
         throw mp::SSHException("could not allocate ssh session");
 
-    const long timeout_secs = std::chrono::duration_cast<std::chrono::seconds>(timeout).count();
+    const long timeout_secs = std::numeric_limits<long>::max();
     const int nodelay{1};
     auto ssh_dir = QDir(MP_STDPATHS.writableLocation(StandardPaths::AppConfigLocation)).filePath("ssh").toStdString();
 

src/sshfs_mount/sshfs_mount.cpp

@@ -151,21 +151,29 @@
 
 } // namespace
 
-mp::SshfsMount::SshfsMount(SSHSession&& session, const std::string& source, const std::string& target,
-                           const mp::id_mappings& gid_mappings, const mp::id_mappings& uid_mappings)
+mp::SshfsMount::SshfsMount(SSHSession&& session,
+                           const std::string& source,
+                           const std::string& target,
+                           const mp::id_mappings& gid_mappings,
+                           const mp::id_mappings& uid_mappings)
     : sftp_server{make_sftp_server(std::move(session), source, target, gid_mappings, uid_mappings)},
-      sftp_thread{[this]() {
+      sftp_thread{[this] {
+          state.store(State::Running, std::memory_order_release);
+
           mp::top_catch_all(category, [this] {
               std::cout << "Connected" << std::endl;
               sftp_server->run();
               std::cout << "Stopped" << std::endl;
           });
+
+          state.store(State::Stopped, std::memory_order_release);
       }}
 {
 }
 
 mp::SshfsMount::~SshfsMount()
 {
+    state.store(State::Stopped, std::memory_order_release);
     stop();
 }
 
@@ -175,3 +183,8 @@
     if (sftp_thread.joinable())
         sftp_thread.join();
 }
+
+bool mp::SshfsMount::alive() const
+{
+    return state.load(std::memory_order_acquire) != State::Stopped;
+}

src/sshfs_mount/sshfs_mount.h

@@ -38,7 +38,17 @@ class SshfsMount
 
     void stop();
 
+    [[nodiscard]] bool alive() const;
+
 private:
+    enum class State
+    {
+        Unstarted,
+        Running,
+        Stopped
+    };
+
+    std::atomic<State> state{State::Unstarted};
     // sftp_server Doesn't need to be a pointer, but done for now to avoid bringing sftp.h
     // which has an error with -pedantic.
     std::unique_ptr<SftpServer> sftp_server;

src/sshfs_mount/sshfs_server.cpp

@@ -105,17 +105,22 @@ int main(int argc, char* argv[])
 
     try
     {
-        auto watchdog = mpp::make_quit_watchdog(); // called while there is only one thread
+        auto watchdog =
+            mpp::make_quit_watchdog(std::chrono::milliseconds{500}); // called while there is only one thread
 
         mp::SSHSession session{host, port, username, mp::SSHClientKeyProvider{priv_key_blob}};
         mp::SshfsMount sshfs_mount(std::move(session), source_path, target_path, gid_mappings, uid_mappings);
 
         // ssh lives on its own thread, use this thread to listen for quit signal
-        if (int sig = watchdog())
-            cout << "Received signal " << sig << ". Stopping" << endl;
+        auto sig = watchdog([&sshfs_mount] { return sshfs_mount.alive(); });
+
+        if (sig.has_value())
+            cout << "Received signal " << *sig << ". Stopping" << endl;
+        else
+            cerr << "SFTP server thread stopped unexpectedly." << endl;
 
         sshfs_mount.stop();
-        exit(0);
+        exit(sig.has_value() ? EXIT_SUCCESS : EXIT_FAILURE);
     }
     catch (const mp::SSHFSMissingError&)
     {

tests/unix/mock_signal_wrapper.h

@@ -0,0 +1,42 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MULTIPASS_MOCK_SIGNAL_WRAPPER_H
+#define MULTIPASS_MOCK_SIGNAL_WRAPPER_H
+
+#include "../common.h"
+#include "../mock_singleton_helpers.h"
+
+#include <multipass/platform_unix.h>
+
+namespace multipass::test
+{
+
+class MockSignalWrapper : public platform::SignalWrapper
+{
+public:
+    using SignalWrapper::SignalWrapper;
+
+    MOCK_METHOD(int, mask_signals, (int, const sigset_t*, sigset_t*), (const, override));
+    MOCK_METHOD(int, send, (pthread_t, int), (const, override));
+    MOCK_METHOD(int, wait, (const sigset_t&, int&), (const, override));
+
+    MP_MOCK_SINGLETON_BOILERPLATE(MockSignalWrapper, platform::SignalWrapper);
+};
+
+} // namespace multipass::test
+
+#endif // MULTIPASS_MOCK_SIGNAL_WRAPPER_H