Provided by: erlang-manpages_16.b.3-dfsg-1ubuntu2.2_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)