Provided by: erlang-manpages_16.b.3-dfsg-1ubuntu2_all bug

NAME

       ct_ssh - SSH/SFTP client module.

DESCRIPTION

       SSH/SFTP client module.

       ct_ssh  uses  the  OTP ssh application and more detailed information about e.g. functions,
       types and options can be found in the documentation for this application.

       The Server argument in the SFTP functions should only be used for SFTP sessions that  have
       been  started on existing SSH connections (i.e. when the original connection type is ssh).
       Whenever the connection type is sftp, use the SSH connection reference only.

       The following options are valid for specifying an SSH/SFTP connection (i.e. may be used as
       config elements):

           [{ConnType, Addr},
            {port, Port},
            {user, UserName}
            {password, Pwd}
            {user_dir, String}
            {public_key_alg, PubKeyAlg}
            {connect_timeout, Timeout}
            {key_cb, KeyCallbackMod}]

       ConnType = ssh | sftp.

       Please see ssh(3erl) for other types.

       All timeout parameters in ct_ssh functions are values in milliseconds.

DATA TYPES

         connection() = handle() | target_name() (see module ct):

         handle() = handle() (see module ct_gen_conn):

           Handle for a specific SSH/SFTP connection.

         ssh_sftp_return() = term():

           A return value from an ssh_sftp function.

EXPORTS

       apread(SSH, Handle, Position, Length) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       apread(SSH, Server, Handle, Position, Length) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       apwrite(SSH, Handle, Position, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       apwrite(SSH, Server, Handle, Position, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       aread(SSH, Handle, Len) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       aread(SSH, Server, Handle, Len) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       awrite(SSH, Handle, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       awrite(SSH, Server, Handle, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       close(SSH, Handle) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       close(SSH, Server, Handle) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       connect(KeyOrName) -> {ok, Handle} | {error, Reason}

              Equivalent to connect(KeyOrName, host, []).

       connect(KeyOrName, ConnType) -> {ok, Handle} | {error, Reason}

              Equivalent to connect(KeyOrName, ConnType, []).

       connect(KeyOrName, ConnType, ExtraOpts) -> {ok, Handle} | {error, Reason}

              Types:

                 KeyOrName = Key | Name
                 Key = atom()
                 Name = target_name() (see module ct)
                 ConnType = ssh | sftp | host
                 ExtraOpts = ssh_connect_options()
                 Handle = handle()
                 Reason = term()

              Open an SSH or SFTP connection using the information associated with KeyOrName.

              If  Name (an alias name for Key), is used to identify the connection, this name may
              be used as connection reference for subsequent calls. It's only  possible  to  have
              one  open  connection  at a time associated with Name. If Key is used, the returned
              handle must be used for subsequent calls (multiple connections may be opened  using
              the config data specified by Key). See ct:require/2 for how to create a new Name

              ConnType  will  always  override  the  type  specified  in the address tuple in the
              configuration data (and in ExtraOpts). So it is possible to  for  example  open  an
              sftp  connection  directly  using data originally specifying an ssh connection. The
              value host means the connection type specified by the host option  (either  in  the
              configuration data or in ExtraOpts) will be used.

              ExtraOpts  (optional)  are  extra  SSH  options  to be added to the config data for
              KeyOrName. The extra options will override any existing options with the  same  key
              in the config data. For details on valid SSH options, see the documentation for the
              OTP ssh application.

              See also: ct:require/2.

       del_dir(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       del_dir(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       delete(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       delete(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       disconnect(SSH) -> ok | {error, Reason}

              Types:

                 SSH = connection()
                 Reason = term()

              Close an SSH/SFTP connection.

       exec(SSH, Command) -> {ok, Data} | {error, Reason}

              Equivalent to exec(SSH, Command, DefaultTimeout).

       exec(SSH, Command, Timeout) -> {ok, Data} | {error, Reason}

              Types:

                 SSH = connection()
                 Command = string()
                 Timeout = integer()
                 Data = list()
                 Reason = term()

              Requests server to perform Command. A session channel is opened  automatically  for
              the request. Data is received from the server as a result of the command.

       exec(SSH, ChannelId, Command, Timeout) -> {ok, Data} | {error, Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 Command = string()
                 Timeout = integer()
                 Data = list()
                 Reason = term()

              Requests server to perform Command. A previously opened session channel is used for
              the request. Data is received from the server as a result of the command.

       get_file_info(SSH, Handle) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       get_file_info(SSH, Server, Handle) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       list_dir(SSH, Path) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       list_dir(SSH, Server, Path) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       make_dir(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       make_dir(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       make_symlink(SSH, Name, Target) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       make_symlink(SSH, Server, Name, Target) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       open(SSH, File, Mode) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       open(SSH, Server, File, Mode) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       opendir(SSH, Path) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       opendir(SSH, Server, Path) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       position(SSH, Handle, Location) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       position(SSH, Server, Handle, Location) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       pread(SSH, Handle, Position, Length) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       pread(SSH, Server, Handle, Position, Length) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       pwrite(SSH, Handle, Position, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       pwrite(SSH, Server, Handle, Position, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read(SSH, Handle, Len) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read(SSH, Server, Handle, Len) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_file(SSH, File) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_file(SSH, Server, File) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_file_info(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_file_info(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_link(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_link(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_link_info(SSH, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       read_link_info(SSH, Server, Name) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       receive_response(SSH, ChannelId) -> {ok, Data} | {error, Reason}

              Equivalent to receive_response(SSH, ChannelId, close).

       receive_response(SSH, ChannelId, End) -> {ok, Data} | {error, Reason}

              Equivalent to receive_response(SSH, ChannelId, End, DefaultTimeout).

       receive_response(SSH, ChannelId, End, Timeout) -> {ok, Data} | {timeout, Data}  |  {error,
       Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 End = Fun | close | timeout
                 Timeout = integer()
                 Data = list()
                 Reason = term()

              Receives expected data from server on the specified session channel.

              If  End  == close, data is returned to the caller when the channel is closed by the
              server.  If  a  timeout  occurs  before  this   happens,   the   function   returns
              {timeout,Data}  (where  Data  is  the  data  received so far). If End == timeout, a
              timeout is expected and {ok,Data} is returned both in the case  of  a  timeout  and
              when  the  channel  is  closed.  If  End is a fun, this fun will be called with one
              argument - the data value in a received ssh_cm message (see  ssh_connection(3erl)).
              The  fun  should  return  true  to end the receiving operation (and have the so far
              collected data returned), or false to wait for more data  from  the  server.  (Note
              that  even  if  a  fun  is supplied, the function returns immediately if the server
              closes the channel).

       rename(SSH, OldName, NewName) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       rename(SSH, Server, OldName, NewName) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       send(SSH, ChannelId, Data) -> ok | {error, Reason}

              Equivalent to send(SSH, ChannelId, 0, Data, DefaultTimeout).

       send(SSH, ChannelId, Data, Timeout) -> ok | {error, Reason}

              Equivalent to send(SSH, ChannelId, 0, Data, Timeout).

       send(SSH, ChannelId, Type, Data, Timeout) -> ok | {error, Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 Type = integer()
                 Data = list()
                 Timeout = integer()
                 Reason = term()

              Send data to server on specified session channel.

       send_and_receive(SSH, ChannelId, Data) -> {ok, Data} | {error, Reason}

              Equivalent to send_and_receive(SSH, ChannelId, Data, close).

       send_and_receive(SSH, ChannelId, Data, End) -> {ok, Data} | {error, Reason}

              Equivalent to send_and_receive(SSH, ChannelId, 0, Data, End, DefaultTimeout).

       send_and_receive(SSH, ChannelId, Data, End, Timeout) -> {ok, Data} | {error, Reason}

              Equivalent to send_and_receive(SSH, ChannelId, 0, Data, End, Timeout).

       send_and_receive(SSH, ChannelId, Type, Data, End, Timeout) -> {ok, Data} | {error, Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 Type = integer()
                 Data = list()
                 End = Fun | close | timeout
                 Timeout = integer()
                 Reason = term()

              Send data to server on specified session channel and wait  to  receive  the  server
              response.

              See receive_response/4 for details on the End argument.

       session_close(SSH, ChannelId) -> ok | {error, Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 Reason = term()

              Closes an SSH session channel.

       session_open(SSH) -> {ok, ChannelId} | {error, Reason}

              Equivalent to session_open(SSH, DefaultTimeout).

       session_open(SSH, Timeout) -> {ok, ChannelId} | {error, Reason}

              Types:

                 SSH = connection()
                 Timeout = integer()
                 ChannelId = integer()
                 Reason = term()

              Opens a channel for an SSH session.

       sftp_connect(SSH) -> {ok, Server} | {error, Reason}

              Types:

                 SSH = connection()
                 Server = pid()
                 Reason = term()

              Starts an SFTP session on an already existing SSH connection. Server identifies the
              new session and must be specified whenever SFTP requests are to be sent.

       subsystem(SSH, ChannelId, Subsystem) -> Status | {error, Reason}

              Equivalent to subsystem(SSH, ChannelId, Subsystem, DefaultTimeout).

       subsystem(SSH, ChannelId, Subsystem, Timeout) -> Status | {error, Reason}

              Types:

                 SSH = connection()
                 ChannelId = integer()
                 Subsystem = string()
                 Timeout = integer()
                 Status = success | failure
                 Reason = term()

              Sends a request to execute a predefined subsystem.

       write(SSH, Handle, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       write(SSH, Server, Handle, Data) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       write_file(SSH, File, Iolist) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       write_file(SSH, Server, File, Iolist) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       write_file_info(SSH, Name, Info) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

       write_file_info(SSH, Server, Name, Info) -> Result

              Types:

                 SSH = connection()
                 Result = ssh_sftp_return() | {error, Reason}
                 Reason = term()

              For info and other types, see ssh_sftp(3erl).

AUTHORS

       <>

                                        common_test 1.7.4                            ct_ssh(3erl)