Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
ssh_server_channel(3)	   Erlang Module Definition	 ssh_server_channel(3)

       ssh_server_channel - -behaviour(ssh_server_channel). (Replaces ssh_dae-

       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.

       When   implementing   a	 client	  subsystem   handler,	 use   -behav-
       iour(ssh_client_channel)	instead.

       The following functions are to be exported  from	 a  ssh_server_channel
       callback	module.

       Module:init(Args) -> {ok, State}	| {ok, State, timeout()} | {stop, Rea-


		 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}


		 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,


		 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

		{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) -> _


		 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.7.4		 ssh_server_channel(3)


Want to link to this manual page? Use this URL:

home | help