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.