![[Ericsson AB]](min_head.gif)
This module implements an SFTP (SSH FTP) client. SFTP is a secure, encrypted file transfer service available for SSH.
The errors returned are from the SFTP server, and are often not posix error codes.
connect(CM) -> {ok, Pid} | {error, Reason}
connect(Host, Options) -> {ok, Pid} | {error, Reason}
connect(Host, Port, Options) -> {ok, Pid} | {error, Reason}
Types:
Host = string()
CM = pid()
Port = integer()
Options = [{Option, Value}]
Option = atom()
Value = term()
Reason = term()
Connects to an SFTP server. A gen_server is started
and returned if connection is successful. This server is used
to perform SFTP commands on the server.
For options, see ssh_cm:connect.
read_file(Server, File) -> {ok, Data} | {error, Reason}
Types:
Server = pid()
File = string()
Data = binary()
Reason = term()
Reads a file from the server, and returns the data in a binary,
like file:read_file/1.
write_file(Server, File, Iolist) -> ok | {error, Reason}
Types:
Server = pid()
File = string()
Data = binary()
Reason = term()
Writes a file to the server, like file:write_file/2.
The file is created if it's not there.
list_dir(Server, Path) -> {ok, Filenames} | {error, Reason}
Types:
Server = pid()
Path = string()
Filenames = [Filename]
Filename = string()
Reason = term()
Lists the given directory on the server, returning the filenames as a list of strings.
open(Server, File, Mode) -> {ok, Handle} | {error, Reason}
Types:
Server = pid()
File = string()
Mode = [Modeflag]
Modeflag = read | write | creat | trunc | append | binary
Handle = term()
Reason = term()
Opens a file on the server, and returns a handle that is used for reading or writing.
opendir(Server, Path) -> {ok, Handle} | {error, Reason}
Types:
Server = pid()
Path = string()
Reason = term()
Opens a handle to a directory on the server, the handle is used for reading directory contents.
close(Server, Handle) -> ok | {error, Reason}
Types:
Server = pid()
Handle = term()
Reason = term()
Closes a handle to an open file or directory on the server.
read(Server, Handle, Len) ->
{ok, Data} | eof | {error, Error}
pread(Server, Handle, Position, Length) ->
{ok, Data} | eof | {error, Error}
Types:
Server = pid()
Handle = term()
Position = integer()
Len = integer()
Data = string() | binary()
Reason = term()
Reads Len bytes from the file referenced by
Handle. Returns {ok, Data}, or eof, or
{error, Reason}. If the file is opened with binary,
Data is a binary, otherwise it is a string.
If the file is read past eof, only the remaining bytes
will be read and returned. If no bytes are read, eof
is returned.
The pread function reads from a specified position,
combining the position and read functions.
aread(Server, Handle, Len) -> {async, N} | {error, Error}
apread(Server, Handle, Position, Length) ->
{async, N} | {error, Error}
Types:
Server = pid()
Handle = term()
Position = integer()
Len = integer()
N = term()
Reason = term()
Reads from an open file, without waiting for the result. If the
handle is valid, the function returns {async, N}, where N
is a term guaranteed to be unique between calls of aread.
The actual data is sent as a message to the calling process. This
message has the form {async_reply, N, Result}, where
Result is the result from the read, either {ok, Data},
or eof, or {error, Error}.
The apread function reads from a specified position,
combining the position and aread functions.
write(Server, Handle, Data) -> ok | {error, Error}
pwrite(Server, Handle, Position, Data) -> ok | {error, Error}
Types:
Server = pid()
Handle = term()
Position = integer()
Data = iolist()
Reason = term()
Write data to the file referenced by Handle.
The file should be opened with write or append
flag. Returns ok if successful and {error, Reason}
otherwise.
Typical error reasons are:
ebadf
enospc
awrite(Server, Handle, Data) -> ok | {error, Error}
apwrite(Server, Handle, Position, Data) ->
ok | {error, Error}
Types:
Server = pid()
Handle = term()
Position = integer()
Len = integer()
Data = binary()
Reason = term()
Writes to an open file, without waiting for the result. If the
handle is valid, the function returns {async, N}, where N
is a term guaranteed to be unique between calls of
awrite. The result of the write operation is sent
as a message to the calling process. This message has the form
{async_reply, N, Result}, where Result is the result
from the write, either ok, or {error, Error}.
The apwrite writes on a specified position, combining
the position and awrite operations.
position(Server, Handle, Location) ->
{ok, NewPosition | {error, Error}
Types:
Server = pid()
Handle = term()
Location = Offset | {bof, Offset} | {cur, Offset}
| {eof, Offset} | bof | cur | eof
Offset = int()
NewPosition = integer()
Reason = term()
Sets the file position of the file referenced by Handle.
Returns {ok, NewPosition (as an absolute offset) if
successful, otherwise {error, Reason}. Location is
one of the following:
Offset
{bof, Offset}.{bof, Offset}
{cur, Offset}
{eof, Offset}
bof | cur | eof
Offset 0.read_file_info(Server, Name) ->
{ok, FileInfo} | {error, Reason}
get_file_info(Server, Handle) ->
{ok, FileInfo} | {error, Reason}
Types:
Server = pid()
Name = string()
Handle = term()
FileInfo = record()
Reason = term()
Returns a file_info record from the file specified by
Name or Handle, like file:read_file_info/2.
read_link_info(Server, Name) ->
{ok, FileInfo} | {error, Reason}
Types:
Server = pid()
Name = string()
Handle = term()
FileInfo = record()
Reason = term()
Returns a file_info record from the symbolic
link specified by Name or Handle, like
file:read_link_info/2.
write_file_info(Server, Name, Info) -> ok | {error, Reason}
Types:
Server = pid()
Name = string()
Info = record()
Reason = term()
Writes file information from a file_info record to the
file specified by Name, like file:write_file_info.
read_link(Server, Name) -> {ok, Target} | {error, Reason}
Types:
Server = pid()
Name = string()
Target = string()
Reason = term()
Read the link target from the symbolic link specified
by name, like file:read_link/1.
make_symlink(Server, Name, Target) ->
ok | {error, Reason}
Types:
Server = pid()
Name = string()
Target = string()
Reason = term()
Creates a symbolic link pointing to Target with the
name Name, like file:make_symlink/2.
rename(Server, OldName, NewName) -> ok | {error, Reason}
Types:
Server = pid()
OldName = string()
NewName = string()
Reason = term()
Renames a file named OldName, and gives it the name
NewName, like file:rename/2
delete(Server, Name) -> ok | {error, Reason}
Types:
Server = pid()
Name = string()
Reason = term()
Deletes the file specified by Name, like
file:delete/1
make_dir(Server, Name) -> ok | {error, Reason}
Types:
Server = pid()
Name = string()
Reason = term()
Creates a directory specified by Name. Name should
be a full path to a new directory. The directory can only be
created in an existing directory.
del_dir(Server, Name) -> ok | {error, Reason}
Types:
Server = pid()
Name = string()
Reason = term()
Deletes a directory specified by Name. The directory
should be empty, and
Types:
Server = pid()
Stops the sftp session, closing the connection. Any
open files on the server will be closed.