NAME

       ssh_server_channel - -behaviour(ssh_server_channel). (Replaces ssh_daemon_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 Connection 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 (application) 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 implementing a  subsystem  that  will  be  added  to  the  ssh
       applications supervisor tree.

   Note:
       When implementing a client subsystem handler, use -behaviour(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, Reason}

              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 function 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_connection: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.15.3.1                          ssh_server_channel(3erl)