ssh_server_channel(3erl) Erlang Module Definition ssh_server_channel(3erl)
NAME
ssh_server_channel - -behaviour(ssh_server_channel). (Replaces ssh_dae-
mon_channel)
DESCRIPTION
Note:
This module replaces ssh_daemon_channel.
The old module is still available for compatibility, but should not be
used for new programs. The old module will not be maintained except for
some error corrections
SSH services (clients and servers) are implemented as channels that are
multiplexed over an SSH connection and communicates over the SSH Con-
nection Protocol. This module provides a callback API that takes care
of generic channel aspects for daemons, such as flow control and close
messages. It lets the callback functions take care of the service (ap-
plication) specific parts. This behavior also ensures that the channel
process honors the principal of an OTP-process so that it can be part
of a supervisor tree. This is a requirement of channel processes imple-
menting a subsystem that will be added to the ssh applications supervi-
sor tree.
Note:
When implementing a client subsystem handler, use -behav-
iour(ssh_client_channel) instead.
CALLBACK FUNCTIONS
The following functions are to be exported from a ssh_server_channel
callback module.
EXPORTS
Module:init(Args) -> {ok, State} | {ok, State, timeout()} | {stop, Rea-
son}
Types:
Args = term()
Last argument to start_link/4.
State = term()
Reason = term()
Makes necessary initializations and returns the initial channel
state if the initializations succeed.
The time-out values that can be returned have the same semantics
as in a gen_server. If the time-out occurs, handle_msg/2 is
called as handle_msg(timeout, State).
Module:handle_msg(Msg, State) -> {ok, State} | {stop, ChannelId, State}
Types:
Msg = timeout | term()
ChannelId = ssh:channel_id()
State = term()
Handles other messages than SSH Connection Protocol, call, or
cast messages sent to the channel.
Possible Erlang 'EXIT' messages is to be handled by this func-
tion and all channels are to handle the following message.
{ssh_channel_up, ssh:channel_id(), ssh:connection_ref()}:
This is the first message that the channel receives. This is
especially useful if the server wants to send a message to
the client without first receiving a message from it. If the
message is not useful for your particular scenario, ignore
it by immediately returning {ok, State}.
Module:handle_ssh_msg(Msg, State) -> {ok, State} | {stop, ChannelId,
State}
Types:
Msg = ssh_connection:event()
ChannelId = ssh:channel_id()
State = term()
Handles SSH Connection Protocol messages that may need service-
specific attention. For details, see ssh_connection:event().
The following message is taken care of by the ssh_server_channel
behavior.
{closed, ssh:channel_id()}:
The channel behavior sends a close message to the other
side, if such a message has not already been sent. Then it
terminates the channel with reason normal.
Module:terminate(Reason, State) -> _
Types:
Reason = term()
State = term()
This function is called by a channel process when it is about to
terminate. Before this function is called, ssh_connec-
tion:close/2 is called, if it has not been called earlier. This
function does any necessary cleaning up. When it returns, the
channel process terminates with reason Reason. The return value
is ignored.
Ericsson AB ssh 4.10 ssh_server_channel(3erl)