Module Awa_mirage.Make

SSH module given a flow

Parameters

module F : Mirage_flow.S

Signature

type error = [
  1. | `Msg of string
  2. | `Read of F.error
  3. | `Write of F.write_error
]

possible errors: incoming alert, processing failure, or a problem in the underlying flow.

type write_error = [
  1. | `Closed
  2. | error
]

The type for write errors.

we provide the FLOW interface

include Mirage_flow.S with type error := error and type write_error := write_error
val pp_error : error Fmt.t
val pp_write_error : write_error Fmt.t
type flow
val read : flow -> (Cstruct.t Mirage_flow.or_eof, error) Stdlib.result Lwt.t
val write : flow -> Cstruct.t -> (unit, write_error) Stdlib.result Lwt.t
val writev : flow -> Cstruct.t list -> (unit, write_error) Stdlib.result Lwt.t
val shutdown : flow -> [ `read | `read_write | `write ] -> unit Lwt.t
val close : flow -> unit Lwt.t
val client_of_flow : ?authenticator:Awa.Keys.authenticator -> user:string -> [ `Pubkey of Awa.Hostkey.priv | `Password of string ] -> Awa.Ssh.channel_request -> F.flow -> (flow, error) Stdlib.result Lwt.t

client_of_flow ~authenticator ~user key channel_request flow upgrades the existing connection to SSH, mutually authenticates, opens a channel and sends the channel request.

type t
type request =
  1. | Pty_req of {
    1. width : int32;
    2. height : int32;
    3. max_width : int32;
    4. max_height : int32;
    5. term : string;
    }
  2. | Pty_set of {
    1. width : int32;
    2. height : int32;
    3. max_width : int32;
    4. max_height : int32;
    }
  3. | Set_env of {
    1. key : string;
    2. value : string;
    }
  4. | Channel of {
    1. cmd : string;
    2. ic : unit -> Cstruct.t Mirage_flow.or_eof Lwt.t;
    3. oc : Cstruct.t -> unit Lwt.t;
    4. ec : Cstruct.t -> unit Lwt.t;
    }
  5. | Shell of {
    1. ic : unit -> Cstruct.t Mirage_flow.or_eof Lwt.t;
    2. oc : Cstruct.t -> unit Lwt.t;
    3. ec : Cstruct.t -> unit Lwt.t;
    }
type exec_callback = request -> unit Lwt.t
val spawn_server : ?stop:Lwt_switch.t -> Awa.Server.t -> Auth.db -> Awa.Ssh.message list -> F.flow -> exec_callback -> t Lwt.t

spawn_server ?stop server msgs flow callback launches an internal SSH channels handler which can be stopped by stop. This SSH channels handler will call callback for every new channels requested by the client. msgs are the SSH hello given by Awa.Server.make which returns also a Awa.Server.t required here.

A basic usage of spawn_server is:

let ssh_channel_handler _cmd _ic _oc _ec =
  Lwt.return_unit

let tcp_handler flow =
  let server, msgs = Awa.Server.make private_key db in
  SSH.spawn_server server msgs flow ssh_handler >>= fun _t ->
  close flow

NOTE: Even if the ssh_channel_handler is fulfilled, spawn_server continues to handle SSH channels. Only stop can really stop the internal SSH channels handler.