Without the public constructor, the class is effectively internal + @discardableResults + configuring queue

.github/workflows/swift.yml

@@ -0,0 +1,19 @@
+name: Swift
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v

Package.swift

@@ -0,0 +1,39 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "SwiftSH",
+    platforms: [
+        .macOS(.v10_15),
+        .iOS(.v13)
+    ],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+	.library(
+	    name: "CSwiftSH",
+	    targets: ["CSwiftSH"]),
+        .library(
+            name: "SwiftSH",
+            targets: ["SwiftSH"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+        .package(name: "CSSH", url: "https://github.com/migueldeicaza/Libssh2Prebuild.git", from: "1.9.0")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+	.target(
+	    name: "CSwiftSH",
+	    dependencies: ["CSSH"]),
+        .target(
+            name: "SwiftSH",
+            dependencies: ["CSSH", "CSwiftSH"]),
+        .testTarget(
+            name: "SwiftSHTests",
+            dependencies: ["SwiftSH"]),
+    ]
+)

README.md

@@ -1,5 +1,19 @@
+
 # SwiftSH
-[![Build Status](https://travis-ci.org/Frugghi/SwiftSH.svg?branch=master)](https://travis-ci.org/Frugghi/SwiftSH)
+
+This is a fork of the original SwiftSH module with a handful of bug
+fixes and changes that I wanted for my SwiftTerm emulator.   The upstream
+package does not seem active.
+
+While Carthage, Pods and other platforms were originally supported, I
+have not attempted to update those, I have now moved to SwiftPM for it,
+which solved various issues for me.
+
+Additionally, this add a callback-based authentication system, that you
+can now use for authenticating using the secure enclave.
+
+# Original Readme
+
 [![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
 [![Pods](https://img.shields.io/cocoapods/v/SwiftSH.svg)](https://cocoapods.org/pods/SwiftSH)
 [![Pod platforms](https://img.shields.io/cocoapods/p/SwiftSH.svg)](https://cocoapods.org/pods/SwiftSH)

SwiftSH/Libssh2.m → Sources/CSwiftSH/Libssh2.m

@@ -22,14 +22,14 @@
 // SOFTWARE.
 //
 
-#import "Libssh2.h"
+#import "libssh2.h"
 
 @import Darwin;
-@import Libssh2;
+@import CSSH;
 @import Foundation;
 
 void trace_callback(LIBSSH2_SESSION *session, void *context, const char *data, size_t length) {
-    NSLog(@"Trace Callback");
+    NSLog(@"Trace Callback %s", data);
 }
 
 ssize_t send_callback(libssh2_socket_t socket, const void *buffer, size_t length, int flags, void **abstract) {
@@ -58,8 +58,8 @@ void disconnect_callback(LIBSSH2_SESSION *session, int reason, const char *messa
     NSLog(@"Libssh2 disconnect");
 }
 
-void libssh2_setup_session_callbacks(void *session) {
-    libssh2_trace(session, 1);
+void libssh2_setup_session_callbacks(void *session, int flags) {
+    libssh2_trace(session, flags);
     libssh2_trace_sethandler(session, nil, &trace_callback);
 
     libssh2_session_callback_set(session, LIBSSH2_CALLBACK_SEND, &send_callback);

SwiftSH/Libssh2.h → Sources/CSwiftSH/include/Libssh2.h

@@ -22,4 +22,4 @@
 // SOFTWARE.
 //
 
-void libssh2_setup_session_callbacks(void *session);
+void libssh2_setup_session_callbacks(void *session, int flags);

SwiftSH/Channel.swift → Sources/SwiftSH/Channel.swift

@@ -22,15 +22,17 @@
 // SOFTWARE.
 //
 
-open class SSHChannel: SSHSession {
+open class SSHChannel {
 
     // MARK: - Public variables
 
     public fileprivate(set) var terminal: Terminal?
+    public fileprivate(set) var channel: SSHLibraryChannel!
 
+    public private(set) var session: SSHSession
+
     // MARK: - Internal variables
 
-    internal var channel: SSHLibraryChannel!
     internal let environment: [Environment]
 
     // MARK: - Initialization
@@ -39,44 +41,53 @@ open class SSHChannel: SSHSession {
         self.environment = environment
         self.terminal = terminal
 
-        try super.init(sshLibrary: sshLibrary, host: host, port: port)
+        self.session = try SSHSession(sshLibrary: sshLibrary, host: host, port: port)
+
+        self.channel = session.session.makeChannel()
+    }
+
+    internal init(sshLibrary: SSHLibrary.Type = Libssh2.self, session: SSHSession, environment: [Environment] = [], terminal: Terminal? = nil) throws {
+        self.environment = environment
+        self.terminal = terminal
+
+        self.session = session
 
-        self.channel = self.session.makeChannel()
+        self.channel = session.session.makeChannel()
     }
 
     // MARK: - Open/Close
 
     internal func open() throws {
-        assert(self.queue.current)
+        assert(session.queue.current)
 
         // Check if we are authenticated
-        guard self.authenticated else {
-            throw SSHError.authenticationFailed
+        guard session.authenticated else {
+            throw SSHError.authenticationFailed(detail: "Open attempted, but we are not authenticated")
         }
 
         // Check if the channel is already open
         guard !self.channel.opened else {
             throw SSHError.Channel.alreadyOpen
         }
 
-        self.log.debug("Opening the channel...")
+        session.log.debug("Opening the channel...")
 
         // Set blocking mode
-        self.session.blocking = true
+        session.session.blocking = true
 
         // Opening the channel
         try self.channel.openChannel()
 
         do {
             // Set the environment's variables
-            self.log.debug("Environment: \(self.environment)")
+            session.log.debug("Environment: \(self.environment)")
             for variable in self.environment {
                 try self.channel.setEnvironment(variable)
             }
 
             // Request the pseudo terminal
             if let terminal = self.terminal {
-                self.log.debug("\(terminal) pseudo terminal requested")
+                session.log.debug("\(terminal) pseudo terminal requested")
                 try self.channel.requestPseudoTerminal(terminal)
             }
         } catch {
@@ -86,41 +97,42 @@ open class SSHChannel: SSHSession {
     }
 
     internal func close() {
-        assert(self.queue.current)
+        assert(session.queue.current)
 
-        self.log.debug("Closing the channel...")
+        session.log.debug("Closing the channel...")
 
         // Set blocking mode
-        self.session.blocking = true
+        session.session.blocking = true
 
         // Close the channel
         do {
             try self.channel.closeChannel()
         } catch {
-            self.log.error("\(error)")
+            session.log.error("\(error)")
         }
     }
 
-    public override func disconnect(_ completion: (() -> Void)?) {
-        self.queue.async {
+    public func disconnect(_ completion: (() -> Void)?) {
+        session.queue.async {
             self.close()
 
-            super.disconnect(completion)
+            self.session.disconnect(completion)
         }
     }
 
     // MARK: - Terminal
-
+    @discardableResult
     public func setTerminalSize(width: UInt, height: UInt) -> Self {
         self.setTerminalSize(width: width, height: height, completion: nil)
 
         return self
     }
 
     public func setTerminalSize(width: UInt, height: UInt, completion: SSHCompletionBlock?) {
-        self.queue.async(completion: completion) {
+        session.queue.async(completion: completion) {
             guard let terminal = self.terminal else {
-                throw SSHError.badUse
+                throw SSHError.badUse(detail:"Terminal set size attempted, but the terminal has not been created yet"
+                )
             }
 
             // Check if the new size is different from the old one

SwiftSH/Command.swift → Sources/SwiftSH/Command.swift

@@ -21,6 +21,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 //
+import Foundation
 
 public class SSHCommand: SSHChannel {
 
@@ -35,14 +36,18 @@ public class SSHCommand: SSHChannel {
         try super.init(sshLibrary: sshLibrary, host: host, port: port, environment: environment, terminal: terminal)
     }
 
+    public override init(sshLibrary: SSHLibrary.Type = Libssh2.self, session: SSHSession, environment: [Environment] = [], terminal: Terminal? = nil) throws {
+        try super.init(sshLibrary: sshLibrary, session: session, environment: environment, terminal: terminal)
+    }
+
     deinit {
         self.cancelSources()
     }
 
     public override func close() {
         self.cancelSources()
 
-        self.queue.async {
+        session.queue.async {
             super.close()
         }
     }
@@ -63,7 +68,7 @@ public class SSHCommand: SSHChannel {
     private var error: Data?
 
     public func execute(_ command: String, completion: ((String, Data?, Error?) -> Void)?) {
-        self.queue.async(completion: { (error: Error?) in
+        session.queue.async(completion: { (error: Error?) in
             if let error = error {
                 self.close()
 
@@ -79,9 +84,9 @@ public class SSHCommand: SSHChannel {
             try self.open()
 
             // Read the received data
-            self.socketSource = DispatchSource.makeReadSource(fileDescriptor: CFSocketGetNative(self.socket), queue: self.queue.queue)
+            self.socketSource = DispatchSource.makeReadSource(fileDescriptor: CFSocketGetNative(self.session.socket), queue: self.session.queue.queue)
             guard let socketSource = self.socketSource else {
-                throw SSHError.allocation
+                throw SSHError.allocation(detail: "")
             }
 
             socketSource.setEventHandler { [weak self] in
@@ -96,7 +101,7 @@ public class SSHCommand: SSHChannel {
                 }
 
                 // Set non-blocking mode
-                self.session.blocking = false
+                self.session.session.blocking = false
 
                 // Read the result
                 var socketClosed = true
@@ -110,7 +115,7 @@ public class SSHCommand: SSHChannel {
 
                     socketClosed = false
                 } catch let error {
-                    self.log.error("[STD] \(error)")
+                    self.session.log.error("[STD] \(error)")
                 }
 
                 // Read the error
@@ -126,7 +131,7 @@ public class SSHCommand: SSHChannel {
 
                     socketClosed = false
                 } catch let error {
-                    self.log.error("[ERR] \(error)")
+                    self.session.log.error("[ERR] \(error)")
                 }
 
                 // Check if we can return the response
@@ -142,7 +147,7 @@ public class SSHCommand: SSHChannel {
                             error = SSHError.Command.execError(String(data: message, encoding: .utf8), message)
                         }
 
-                        self.queue.callbackQueue.async {
+                        self.session.queue.callbackQueue.async {
                             completion(command, result, error)
                         }
                     }
@@ -153,9 +158,9 @@ public class SSHCommand: SSHChannel {
             }
 
             // Create the timeout handler
-            self.timeoutSource = DispatchSource.makeTimerSource(queue: self.queue.queue)
+            self.timeoutSource = DispatchSource.makeTimerSource(queue: self.session.queue.queue)
             guard let timeoutSource = self.timeoutSource else {
-                throw SSHError.allocation
+                throw SSHError.allocation(detail:"")
             }
 
             timeoutSource.setEventHandler { [weak self] in
@@ -168,21 +173,21 @@ public class SSHCommand: SSHChannel {
                 if let completion = completion {
                     let result = self.response
 
-                    self.queue.callbackQueue.async {
-                        completion(command, result, SSHError.timeout)
+                    self.session.queue.callbackQueue.async {
+                        completion(command, result, SSHError.timeout(detail:"timeout DispatchSource"))
                     }
                 }
             }
-            timeoutSource.schedule(deadline: .now() + self.timeout, repeating: self.timeout, leeway: .seconds(10))
+            timeoutSource.schedule(deadline: .now() + self.session.timeout, repeating: self.session.timeout, leeway: .seconds(10))
 
             // Set blocking mode
-            self.session.blocking = true
+            self.session.session.blocking = true
 
             // Execute the command
             try self.channel.exec(command)
 
             // Set non-blocking mode
-            self.session.blocking = false
+            self.session.session.blocking = false
 
             // Start listening for new data
             timeoutSource.resume()
@@ -205,4 +210,13 @@ public class SSHCommand: SSHChannel {
         }
     }
 
+    public func connect () -> Self {
+        session.connect()
+        return self
+    }
+
+    public func authenticate (_ challenge: AuthenticationChallenge?) -> Self {
+        session.authenticate(challenge)
+        return self
+    }
 }