[BACK]Return to ssh.h CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/ssh.h between version 1.34 and 1.35

version 1.34, 2000/03/23 22:15:33 version 1.35, 2000/03/28 20:31:29
Line 461 
Line 461 
 /* Removes a cleanup function to be called at fatal(). */  /* Removes a cleanup function to be called at fatal(). */
 void    fatal_remove_cleanup(void (*proc) (void *context), void *context);  void    fatal_remove_cleanup(void (*proc) (void *context), void *context);
   
 /*---------------- definitions for channels ------------------*/  
   
 /* Sets specific protocol options. */  
 void    channel_set_options(int hostname_in_open);  
   
 /*  
  * Allocate a new channel object and set its type and socket.  Remote_name  
  * must have been allocated with xmalloc; this will free it when the channel  
  * is freed.  
  */  
 int     channel_allocate(int type, int sock, char *remote_name);  
   
 /* Free the channel and close its socket. */  
 void    channel_free(int channel);  
   
 /* Add any bits relevant to channels in select bitmasks. */  
 void    channel_prepare_select(fd_set * readset, fd_set * writeset);  
   
 /*  
  * After select, perform any appropriate operations for channels which have  
  * events pending.  
  */  
 void    channel_after_select(fd_set * readset, fd_set * writeset);  
   
 /* If there is data to send to the connection, send some of it now. */  
 void    channel_output_poll(void);  
   
 /*  
  * This is called when a packet of type CHANNEL_DATA has just been received.  
  * The message type has already been consumed, but channel number and data is  
  * still there.  
  */  
 void    channel_input_data(int payload_len);  
   
 /* Returns true if no channel has too much buffered data. */  
 int     channel_not_very_much_buffered_data(void);  
   
 /* This is called after receiving CHANNEL_CLOSE. */  
 void    channel_input_close(void);  
   
 /* This is called after receiving CHANNEL_CLOSE_CONFIRMATION. */  
 void    channel_input_close_confirmation(void);  
   
 /* This is called after receiving CHANNEL_OPEN_CONFIRMATION. */  
 void    channel_input_open_confirmation(void);  
   
 /* This is called after receiving CHANNEL_OPEN_FAILURE from the other side. */  
 void    channel_input_open_failure(void);  
   
 /* This closes any sockets that are listening for connections; this removes  
    any unix domain sockets. */  
 void    channel_stop_listening(void);  
   
 /*  
  * Closes the sockets of all channels.  This is used to close extra file  
  * descriptors after a fork.  
  */  
 void    channel_close_all(void);  
   
 /* Returns the maximum file descriptor number used by the channels. */  
 int     channel_max_fd(void);  
   
 /* Returns true if there is still an open channel over the connection. */  
 int     channel_still_open(void);  
   
 /*  
  * Returns a string containing a list of all open channels.  The list is  
  * suitable for displaying to the user.  It uses crlf instead of newlines.  
  * The caller should free the string with xfree.  
  */  
 char   *channel_open_message(void);  
   
 /*  
  * Initiate forwarding of connections to local port "port" through the secure  
  * channel to host:port from remote side.  This never returns if there was an  
  * error.  
  */  
 void  
 channel_request_local_forwarding(u_short port, const char *host,  
     u_short remote_port, int gateway_ports);  
   
 /*  
  * Initiate forwarding of connections to port "port" on remote host through  
  * the secure channel to host:port from local side.  This never returns if  
  * there was an error.  This registers that open requests for that port are  
  * permitted.  
  */  
 void  
 channel_request_remote_forwarding(u_short port, const char *host,  
     u_short remote_port);  
   
 /*  
  * Permits opening to any host/port in SSH_MSG_PORT_OPEN.  This is usually  
  * called by the server, because the user could connect to any port anyway,  
  * and the server has no way to know but to trust the client anyway.  
  */  
 void    channel_permit_all_opens(void);  
   
 /*  
  * This is called after receiving CHANNEL_FORWARDING_REQUEST.  This initates  
  * listening for the port, and sends back a success reply (or disconnect  
  * message if there was an error).  This never returns if there was an error.  
  */  
 void    channel_input_port_forward_request(int is_root);  
   
 /*  
  * This is called after receiving PORT_OPEN message.  This attempts to  
  * connect to the given host:port, and sends back CHANNEL_OPEN_CONFIRMATION  
  * or CHANNEL_OPEN_FAILURE.  
  */  
 void    channel_input_port_open(int payload_len);  
   
 /*  
  * Creates a port for X11 connections, and starts listening for it. Returns  
  * the display name, or NULL if an error was encountered.  
  */  
 char   *x11_create_display(int screen);  
   
 /*  
  * Creates an internet domain socket for listening for X11 connections.  
  * Returns a suitable value for the DISPLAY variable, or NULL if an error  
  * occurs.  
  */  
 char   *x11_create_display_inet(int screen, int x11_display_offset);  
   
 /*  
  * This is called when SSH_SMSG_X11_OPEN is received.  The packet contains  
  * the remote channel number.  We should do whatever we want, and respond  
  * with either SSH_MSG_OPEN_CONFIRMATION or SSH_MSG_OPEN_FAILURE.  
  */  
 void    x11_input_open(int payload_len);  
   
 /*  
  * Requests forwarding of X11 connections.  This should be called on the  
  * client only.  
  */  
 void    x11_request_forwarding(void);  
   
 /*  
  * Requests forwarding for X11 connections, with authentication spoofing.  
  * This should be called in the client only.  
  */  
 void    x11_request_forwarding_with_spoofing(const char *proto, const char *data);  
   
 /* Sends a message to the server to request authentication fd forwarding. */  
 void    auth_request_forwarding(void);  
   
 /*  
  * Returns the name of the forwarded authentication socket.  Returns NULL if  
  * there is no forwarded authentication socket.  The returned value points to  
  * a static buffer.  
  */  
 char   *auth_get_socket_name(void);  
   
 /*  
  * This if called to process SSH_CMSG_AGENT_REQUEST_FORWARDING on the server.  
  * This starts forwarding authentication requests.  
  */  
 void    auth_input_request_forwarding(struct passwd * pw);  
   
 /* This is called to process an SSH_SMSG_AGENT_OPEN message. */  
 void    auth_input_open_request(void);  
   
 /*  
  * Returns true if the given string matches the pattern (which may contain ?  
  * and * as wildcards), and zero if it does not match.  
  */  
 int     match_pattern(const char *s, const char *pattern);  
   
 /*  /*
  * Expands tildes in the file name.  Returns data allocated by xmalloc.   * Expands tildes in the file name.  Returns data allocated by xmalloc.
  * Warning: this calls getpw*.   * Warning: this calls getpw*.
Legend:
Removed from v.1.34  
changed lines
  Added in v.1.35