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

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

version 1.34, 2001/05/30 12:55:10 version 1.35, 2001/05/31 10:30:15
Line 34 
Line 34 
  */   */
 /* RCSID("$OpenBSD$"); */  /* RCSID("$OpenBSD$"); */
   
 #ifndef CHANNELS_H  #ifndef CHANNEL_H
 #define CHANNELS_H  #define CHANNEL_H
   
 #include "buffer.h"  #include "buffer.h"
   
Line 124 
Line 124 
 #define CHAN_X11_WINDOW_DEFAULT (4*1024)  #define CHAN_X11_WINDOW_DEFAULT (4*1024)
 #define CHAN_X11_PACKET_DEFAULT (CHAN_X11_WINDOW_DEFAULT/2)  #define CHAN_X11_PACKET_DEFAULT (CHAN_X11_WINDOW_DEFAULT/2)
   
   /* possible input states */
   #define CHAN_INPUT_OPEN                 0x01
   #define CHAN_INPUT_WAIT_DRAIN           0x02
   #define CHAN_INPUT_WAIT_OCLOSE          0x04
   #define CHAN_INPUT_CLOSED               0x08
   
 void    channel_open(int id);  /* possible output states */
   #define CHAN_OUTPUT_OPEN                0x10
   #define CHAN_OUTPUT_WAIT_DRAIN          0x20
   #define CHAN_OUTPUT_WAIT_IEOF           0x40
   #define CHAN_OUTPUT_CLOSED              0x80
   
   #define CHAN_CLOSE_SENT                 0x01
   #define CHAN_CLOSE_RCVD                 0x02
   
   
   /* channel management */
   
   Channel *channel_lookup(int id);
   Channel *
   channel_new(char *ctype, int type, int rfd, int wfd, int efd,
       int window, int maxpack, int extusage, char *remote_name, int nonblock);
   void
   channel_set_fds(int id, int rfd, int wfd, int efd,
       int extusage, int nonblock);
   void    channel_free(Channel *c);
   
   void    channel_send_open(int id);
 void    channel_request(int id, char *service, int wantconfirm);  void    channel_request(int id, char *service, int wantconfirm);
 void    channel_request_start(int id, char *service, int wantconfirm);  void    channel_request_start(int id, char *service, int wantconfirm);
 void    channel_register_callback(int id, int mtype, channel_callback_fn *fn, void *arg);  void    channel_register_callback(int id, int mtype, channel_callback_fn *fn, void *arg);
 void    channel_register_cleanup(int id, channel_callback_fn *fn);  void    channel_register_cleanup(int id, channel_callback_fn *fn);
 void    channel_register_filter(int id, channel_filter_fn *fn);  void    channel_register_filter(int id, channel_filter_fn *fn);
 void    channel_cancel_cleanup(int id);  void    channel_cancel_cleanup(int id);
 Channel *channel_lookup(int id);  
   
 void  /* protocol handler */
 channel_set_fds(int id, int rfd, int wfd, int efd,  
     int extusage, int nonblock);  
   
 void    deny_input_open(int type, int plen, void *ctxt);  
   
 void    channel_input_channel_request(int type, int plen, void *ctxt);  void    channel_input_channel_request(int type, int plen, void *ctxt);
 void    channel_input_close(int type, int plen, void *ctxt);  void    channel_input_close(int type, int plen, void *ctxt);
 void    channel_input_close_confirmation(int type, int plen, void *ctxt);  void    channel_input_close_confirmation(int type, int plen, void *ctxt);
Line 152 
Line 173 
 void    channel_input_port_open(int type, int plen, void *ctxt);  void    channel_input_port_open(int type, int plen, void *ctxt);
 void    channel_input_window_adjust(int type, int plen, void *ctxt);  void    channel_input_window_adjust(int type, int plen, void *ctxt);
   
 /* Sets specific protocol options. */  /* file descriptor handling (read/write) */
 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.  
  */  
 Channel *  
 channel_new(char *ctype, int type, int rfd, int wfd, int efd,  
     int window, int maxpack, int extended_usage, char *remote_name,  
     int nonblock);  
   
 /* Free the channel and close its socket. */  
 void    channel_free(Channel *c);  
   
 /*  
  * Allocate/update select bitmasks and add any bits relevant to channels in  
  * select bitmasks.  
  */  
 void  void
 channel_prepare_select(fd_set **readsetp, fd_set **writesetp, int *maxfdp,  channel_prepare_select(fd_set **readsetp, fd_set **writesetp, int *maxfdp,
     int rekeying);      int rekeying);
   
 /*  
  * After select, perform any appropriate operations for channels which have  
  * events pending.  
  */  
 void    channel_after_select(fd_set * readset, fd_set * writeset);  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);  void    channel_output_poll(void);
   
 /* Returns true if no channel has too much buffered data. */  
 int     channel_not_very_much_buffered_data(void);  int     channel_not_very_much_buffered_data(void);
   
 /* This closes any sockets that are listening for connections; this removes  
    any unix domain sockets. */  
 void    channel_stop_listening(void);  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);  void    channel_close_all(void);
   
 /* Returns true if there is still an open channel over the connection. */  
 int     channel_still_open(void);  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);  char   *channel_open_message(void);
   int     channel_find_open(void);
   
 /*  /* channel_tcpfwd.c */
  * Initiate forwarding of connections to local port "port" through the secure  
  * channel to host:port from remote side.  
  */  
 int  int
 channel_request_local_forwarding(u_short listen_port,  channel_request_local_forwarding(u_short listen_port,
     const char *host_to_connect, u_short port_to_connect, int gateway_ports);      const char *host_to_connect, u_short port_to_connect, int gateway_ports);
Line 219 
Line 196 
 channel_request_forwarding(const char *listen_address, u_short listen_port,  channel_request_forwarding(const char *listen_address, u_short listen_port,
     const char *host_to_connect, u_short port_to_connect, int gateway_ports,      const char *host_to_connect, u_short port_to_connect, int gateway_ports,
     int remote_fwd);      int remote_fwd);
   
 /*  
  * 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  void
 channel_request_remote_forwarding(u_short port, const char *host,  channel_request_remote_forwarding(u_short port, const char *host,
     u_short remote_port);      u_short remote_port);
   
 /*  
  * Permits opening to any host/port if permitted_opens[] is empty.  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);  void    channel_permit_all_opens(void);
   
 /* Add host/port to list of allowed targets for port forwarding */  
 void    channel_add_permitted_opens(char *host, int port);  void    channel_add_permitted_opens(char *host, int port);
   
 /* Flush list */  
 void    channel_clear_permitted_opens(void);  void    channel_clear_permitted_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, int gateway_ports);  void    channel_input_port_forward_request(int is_root, int gateway_ports);
   int     channel_connect_to(const char *host, u_short host_port);
   int     channel_connect_by_listen_adress(u_short listen_port);
   
 /*  /* x11 forwarding */
  * 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);  
   
 /*  int     x11_connect_display(void);
  * Creates an internet domain socket for listening for X11 connections.  //int   x11_check_cookie(Buffer *b);
  * Returns a suitable value for the DISPLAY variable, or NULL if an error  char   *x11_create_display(int screen);
  * occurs.  
  */  
 char   *x11_create_display_inet(int screen, int x11_display_offset);  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 type, int plen, void *ctxt);  void    x11_input_open(int type, int plen, void *ctxt);
   
 /*  
  * Requests forwarding of X11 connections.  This should be called on the  
  * client only.  
  */  
 void    x11_request_forwarding(void);  void    x11_request_forwarding(void);
   
 /*  
  * Requests forwarding for X11 connections, with authentication spoofing.  
  * This should be called in the client only.  
  */  
 void  void
 x11_request_forwarding_with_spoofing(int client_session_id,  x11_request_forwarding_with_spoofing(int client_session_id,
     const char *proto, const char *data);      const char *proto, const char *data);
   void    deny_input_open(int type, int plen, void *ctxt);
   
 /* Sends a message to the server to request authentication fd forwarding. */  /* agent forwarding */
 void    auth_request_forwarding(void);  
   
 /*  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);  char   *auth_get_socket_name(void);
   
 /*  
  * This is called to process SSH_CMSG_AGENT_REQUEST_FORWARDING on the server.  
  * This starts forwarding authentication requests.  
  */  
 int     auth_input_request_forwarding(struct passwd * pw);  int     auth_input_request_forwarding(struct passwd * pw);
   
 /* This is called to process an SSH_SMSG_AGENT_OPEN message. */  
 void    auth_input_open_request(int type, int plen, void *ctxt);  void    auth_input_open_request(int type, int plen, void *ctxt);
   
 /* XXX */  /* channel close */
 int     channel_connect_to(const char *host, u_short host_port);  
 int     channel_connect_by_listen_adress(u_short listen_port);  
 int     x11_connect_display(void);  
   
 int     channel_find_open(void);  typedef void    chan_event_fn(Channel * c);
   
   /* for the input state */
   extern chan_event_fn    *chan_rcvd_oclose;
   extern chan_event_fn    *chan_read_failed;
   extern chan_event_fn    *chan_ibuf_empty;
   
   /* for the output state */
   extern chan_event_fn    *chan_rcvd_ieof;
   extern chan_event_fn    *chan_write_failed;
   extern chan_event_fn    *chan_obuf_empty;
   
   int     chan_is_dead(Channel * c);
   void    chan_mark_dead(Channel * c);
   void    chan_init_iostates(Channel * c);
   void    chan_init(void);
   
 #endif  #endif
Legend:
Removed from v.1.34  
changed lines
  Added in v.1.35