SSH module

.gitignore

@@ -0,0 +1,5 @@
+.acton.lock
+.build
+out
+zig-cache
+zig-out

src/ssh.act

@@ -1,32 +1,45 @@
 import net
-import testing
+
 
 def version() -> str:
-    """Get the libssh version"""
+    """Get the acton-ssh version"""
     NotImplemented
 
-def _test_version():
-    testing.assertEqual("0.11.0", version())
 
 actor Client(cap: net.TCPConnectCap,
              host: str,
              username: str,
              on_connect: action(Client) -> None,
              on_close: action(Client, str) -> None,
              key: ?str=None,
-             password: ?str=None,
+             password: str,
              port: u16=22,
+             subsystem: str
              ):
     """SSH Client"""
 
+    proc def _pin_affinity() -> None:
+        NotImplemented
+    _pin_affinity()
+
     # haha, this is really a pointer :P
     var _ssh_session: u64 = 0
 
+    def get_ssh_session():
+        return _ssh_session
+
+    def get_password() -> str:
+        return password
+
+    def get_subsystem() -> str:
+        return subsystem
+
     proc def _init() -> None:
         """Initialize the SSH client"""
         NotImplemented
     _init()
-    print("SSH Client connected")
+
+    # print("SSH Client connected")
 
 #    action def close(on_close: action(TLSConnection) -> None) -> None:
 #        """Close the connection"""
@@ -37,33 +50,81 @@ actor Client(cap: net.TCPConnectCap,
 #
 #    def _connect(c):
 #        NotImplemented
-#
+
+    proc def disconnect() -> None:
+        """Disconnect the SSH client"""
+        NotImplemented
+
 
 # TODO: implement support for channels
 # AFAIK, all things over ssh are done via channels, so need some channel
 # primitive, maybe an actor per channel that then multiplexes into the Client
 # session? Prolly need some higher level wrappers for common things like
 # starting a shell or running a single command. SFTP / SCP would be nice too,
 # but for sometime in the future. Custom subsystems need to be supported too.
+actor Channel(client: Client):
+    """SSH Channel"""
+
+    var _ssh_channel: u64 = 0
+    var _ssh_session: u64 = client.get_ssh_session()
+    var _password: str = client.get_password()
+    var _subsystem: str = client.get_subsystem()
+    var payload = None
+
+    proc def _pin_affinity() -> None:
+        NotImplemented
+    _pin_affinity()
 
+    proc def _init() -> None:
+        """Initialize the SSH Channel"""
+        NotImplemented
+    _init()
 
+    # print("SSH Channel created")
+
+    def setPayload(p: str):
+        payload = p
+
+    def getPayload():
+        return payload
+
+    def sendNCPayload() -> str:
+        """Send payload"""
+        NotImplemented
 
 
 actor main(env):
     def on_connect(client: Client):
-        print("Connected")
+        # print("Client connected")
+        return
 
     def on_close(client: Client, error: str):
-        print("Error", error)
+        # print("Connection closed", error)
+        return
 
-    print(version())
     c = Client(
         net.TCPConnectCap(net.TCPCap(net.NetCap(env.cap))),
         "localhost",
         "foo",
         on_connect,
         on_close,
         password="bar",
-        port=2223,
+        port=830,
+        subsystem="netconf",
     )
+
+    cc = Channel(c)
+
+    # get netconf server's capabilities
+    cc.setPayload('<?xml version="1.0"?><rpc xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"message-id="101"><get-config><source><running/></source></get-config></rpc>]]>]]>')
+    print("\n\npayload 1:\n", cc.getPayload(), "\n\npayload 1 end")
+    print("\nNC response 1:\n", cc.sendNCPayload(), "\n\nNC response 1 end \n\n")
+
+    # TODO do this in disconnect(): gracefully close a channel
+    cc.setPayload('<rpc message-id="101" xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"><close-session/></rpc>]]>]]>')
+    print("\n\npayload 2:\n", cc.getPayload(), "\n\npayload 2 end")
+    print("\nNC response 2:\n", cc.sendNCPayload(), "\n\nNC response 2 end \n\n")
+
+    c.disconnect()
+
     env.exit(0)