util

-module(ssh_tunnel).
-doc """
Module for creating SSH tunnels using `ssh`.
[https://github.com/drowzy/ssh_tunnel]

It provides functions to create forwarded ssh channels, similair to how other
channels can be created using `ssh_connection`. There are two type of channels
supported
* `directtcp-ip` - Forwards a port from the client machine to the remote
  machine.
This is the same as `ssh -nNT -L 8080:forward.example.com:9000
user@sshserver.example.com`
* `direct-streamlocal` - Forwards to a unix domain socket.
This is the same as `ssh -nNT -L 8080:/var/lib/mysql/mysql.sock
user@sshserver.example.com` When using `direct_tcpip/3` or
`direct_stream_local/2` directly there will not be any local port or socket
bound, this can either be done using `ssh_tunnel` or by manually sending data
with `ssh_connection:send/3`. Although `connect/3` can be used to connect to the
remote host, other methods are supported. One can use
[SSHex](https://github.com/rubencaro/sshex), `ssh:connect/3` for instance.

## Tunnels Tunnels are on-demand TCP servers and are bound listeners to either a
port or a path. The tunnel will handle relaying TCP messages to the ssh
connection and back.

## Examples
```
  {ok, SshRef} = ssh_tunnel:connect("sshserver.example.com", 22, []),
  {ok, Pid}    = ssh_tunnel:start_tunnel(Pid, {tcpip, {8080, {"192.168.90.15", 80}}}),
  % Send a TCP message for instance HTTP
  Resp = HTTPoison.get!("127.0.0.1:8080"),
  io:format("Received body: ~p\n", [Resp])
```
""".

-export([start_tunnel/3]).
-export([connect/0, connect/3, direct_tcpip/3, direct_stream_local/2, open_channel/6]).

-define(DIRECT_TCPIP, "direct-tcpip").
-define(STREAM_LOCAL, "direct-streamlocal@openssh.com").

-define(INI_WINDOW_SIZE, 1024 * 1024).
-define(MAX_PACKET_SIZE, 32 * 1024).

-type location() :: {string(), integer()}.

connect() -> connect({127,0,0,1}, 22, []).

-doc """
Create a connetion to a remote host with the provided options. This function is
mostly used as convenience wrapper around `ssh:connect/3` and does not support
all options. returns: `{ok, Connection}` or `{error, Reason}`.
[https://manpages.debian.org/stretch/erlang-manpages/ssh.3erl.en.html]
""".
-spec connect(list()|tuple(), integer(), list()) -> {ok, pid()} | {error, term()}.
connect(Host, Port, Opts) when (is_list(Host) orelse is_tuple(Host)), is_integer(Port), is_list(Opts) ->
  Config = defaults(Opts),
  ssh:connect(Host, Port, Config).

-doc """
Starts a SSHTunnel.Tunnel process. The tunnel will listen to either a local port
or local path and handle passing messages between the TCP client and ssh
connection. ## Examples {ok, SSH} = ssh_tunnel:connect("sshserver.example.com",
22), {ok, Pid} = ssh_tunnel:start_tunnel(Pid, tcp, {8080, {"192.168.90.15",
80}}) # Send a TCP message %HTTPoison.Response{body: body} =
HTTPoison.get!("127.0.0.1:8080") IO.puts("Received body: #{body})
""".
-spec start_tunnel(pid(), tcp|local, tuple()|integer()) -> {ok, pid()} | {error, term()}.
start_tunnel(Pid, Transport, To) when (is_tuple(To) orelse is_integer(To))
                                    , (Transport==tcp orelse Transport==local) ->
  case {Transport, To} of
    {tcp, ToPort} when is_integer(ToPort) ->
      direct_tcpip(Pid, {"localhost", ToPort}, {"localhost", ToPort});
    {tcp, {From, To}} when is_integer(From), is_integer(To) ->
      direct_tcpip(Pid, {"localhost", From}, {"localhost", To});
    {tcp, {From, {ToHost, ToPort}=To}} when is_integer(From), is_list(ToHost), is_integer(ToPort) ->
      direct_tcpip(Pid, {"localhost", From}, To);
    {tcp, {From, {ToHost, ToPort}=To}} when is_integer(From), is_list(ToHost), is_integer(ToPort) ->
      direct_tcpip(Pid, {"localhost", From}, To);
    {tcp, {{FromHost, FromPort}=From, {ToHost, ToPort}=To}} when is_list(FromHost), is_integer(FromPort), is_list(ToHost), is_integer(ToPort) ->
      direct_tcpip(Pid, From, To);
    {local, To} when is_list(To) ->
      direct_stream_local(Pid, To)
  end.

-doc """
Creates a ssh directtcp-ip forwarded channel to a remote port. The returned
channel together with a ssh connection reference (returned from `ssh:connect/4`)
can be used to send messages with `ssh_connection:send/3` returns: `{ok,
channel}` or `{error, reason}`. ## Examples: msg = "GET / HTTP/1.1\r\nHost:
localhost:8080\r\nUser-Agent: curl/7.47.0\r\nAccept: */*\r\n\r\n" {ok, Pid} =
ssh_tunnel:connect("192.168.1.10", 22), {ok, Ch} = ssh_tunnel:direct_tcpip(Pid,
{"127.0.0.1", 8080}, {"192.168.1.10", 80}), ok = ssh_connection:send(Pid, Ch,
Msg), recieve do {ssh_cm, _, {data, Channel, _, Data}} -> io:format("Data:
~p\n", [Data]) end
""".
-spec direct_tcpip(pid(), From::location(), To::location()) -> {ok, integer()} | {error, term()}.
direct_tcpip(Pid, {OrigHost, OrigPort} = _From, {RemHost, RemPort} = _To) when is_pid(Pid) ->
  LocH   = list_to_binary(OrigHost),
  RemH   = list_to_binary(RemHost),
  RemLen = byte_size(RemH),
  LocLen = byte_size(LocH),
  Msg    = <<RemLen:32,RemH/binary,RemPort:32, LocLen:32,LocH/binary,OrigPort:32>>,
  open_channel(Pid, ?DIRECT_TCPIP, Msg, ?INI_WINDOW_SIZE, ?MAX_PACKET_SIZE, infinity).

-doc """
Creates a ssh stream local-forward channel to a remote unix domain socket. It
sends the request that the server make a connection to its local Unix domain
socket. The returned channel together with a ssh connection reference (returned
from `ssh:connect/4`) can be used to send messages with `ssh_connection:send/3`.
returns: `{ok, Channel}` or `{error, Reason}`. Ex:
```
msg = "GET /images/json HTTP/1.1\r\nHost: /var/run/docker.sock\r\nAccept: */*\r\n\r\n"
{ok, Pid} = ssh_tunnel:connect("192.168.90.15", 22),
{ok, Ch}  = ssh_tunnel:direct_stream_local(Pid, "/var/run/docker.sock"),
ok = ssh_connection:send(Pid, Ch, Msg)
```
""".
-spec direct_stream_local(pid(), string()) -> {ok, integer()} | {error, term()}.
direct_stream_local(Pid, SocketPath) when is_pid(Pid), is_list(SocketPath) ->
  SPath = list_to_binary(SocketPath),
  Msg   = <<(byte_size(SPath)):32/integer, SPath/binary, 0:32, 0:32>>,
  open_channel(Pid, ?STREAM_LOCAL, Msg, ?INI_WINDOW_SIZE, ?MAX_PACKET_SIZE, infinity).

open_channel(Pid, Type, Msg, WindowSize, MaxPktSz, Timeout) ->
  case ssh_connection_handler:open_channel(Pid,Type,Msg,WindowSize,MaxPktSz,Timeout) of
    {open, Ch}                  -> {ok, Ch};
    {open_error, _, Reason, _}  -> {error, to_string(Reason)};
    {error, Reason}             -> {error, inet:format_error(Reason)}
  end.

defaults(Opts) ->
  [
    {user_interaction, false},
    {silently_accept_hosts, true} |
    Opts
  ].

to_string(A) when is_atom(A)   -> atom_to_list(A);
to_string(B) when is_binary(B) -> binary_to_list(B);
to_string(B) when is_list(B)   -> B.