channels.h

   1 /* RCSID("$Id$"); */
   2
   3 #ifndef CHANNELS_H
   4 #define CHANNELS_H
   5
   6 /* Definitions for channel types. */
   7 #define SSH_CHANNEL_FREE                0       /* This channel is free (unused). */
   8 #define SSH_CHANNEL_X11_LISTENER        1       /* Listening for inet X11 conn. */
   9 #define SSH_CHANNEL_PORT_LISTENER       2       /* Listening on a port. */
  10 #define SSH_CHANNEL_OPENING             3       /* waiting for confirmation */
  11 #define SSH_CHANNEL_OPEN                4       /* normal open two-way channel */
  12 #define SSH_CHANNEL_CLOSED              5       /* waiting for close confirmation */
  13 #define SSH_CHANNEL_AUTH_SOCKET         6       /* authentication socket */
  14 #define SSH_CHANNEL_X11_OPEN            7       /* reading first X11 packet */
  15 #define SSH_CHANNEL_INPUT_DRAINING      8       /* sending remaining data to conn */
  16 #define SSH_CHANNEL_OUTPUT_DRAINING     9       /* sending remaining data to app */
  17 #define SSH_CHANNEL_LARVAL              10      /* larval session */
  18 #define SSH_CHANNEL_MAX_TYPE            11
  19
  20 /*
  21  * Data structure for channel data.  This is iniailized in channel_allocate
  22  * and cleared in channel_free.
  23  */
  24 typedef void channel_callback_fn(int id, void *arg);
  25
  26 typedef struct Channel {
  27         int     type;           /* channel type/state */
  28         int     self;           /* my own channel identifier */
  29         int     remote_id;      /* channel identifier for remote peer */
  30         /* peer can be reached over encrypted connection, via packet-sent */
  31         int     istate;         /* input from channel (state of receive half) */
  32         int     ostate;         /* output to channel  (state of transmit half) */
  33         int     rfd;            /* read fd */
  34         int     wfd;            /* write fd */
  35         int     efd;            /* extended fd */
  36         int     sock;           /* sock fd */
  37         Buffer  input;          /* data read from socket, to be sent over
  38                                  * encrypted connection */
  39         Buffer  output;         /* data received over encrypted connection for
  40                                  * send on socket */
  41         Buffer  extended;
  42         char    path[200];      /* path for unix domain sockets, or host name
  43                                  * for forwards */
  44         int     listening_port; /* port being listened for forwards */
  45         int     host_port;      /* remote port to connect for forwards */
  46         char   *remote_name;    /* remote hostname */
  47
  48         int     remote_window;
  49         int     remote_maxpacket;
  50         int     local_window;
  51         int     local_window_max;
  52         int     local_consumed;
  53         int     local_maxpacket;
  54         int     extended_usage;
  55
  56         char   *ctype;          /* type */
  57
  58         // callback
  59         channel_callback_fn     *cb_fn;
  60         void    *cb_arg;
  61         int     cb_event;
  62         channel_callback_fn     *dettach_user;
  63 }       Channel;
  64
  65 #define CHAN_EXTENDED_IGNORE            0
  66 #define CHAN_EXTENDED_READ              1
  67 #define CHAN_EXTENDED_WRITE             2
  68
  69 void    channel_open(int id);
  70 Channel *channel_lookup(int id);
  71
  72 int
  73 channel_new(char *ctype, int type, int rfd, int wfd, int efd,
  74     int window, int maxpack, int extended_usage, char *remote_name);
  75
  76 void    channel_input_close(int type, int plen);
  77 void    channel_input_close_confirmation(int type, int plen);
  78 void    channel_input_data(int type, int plen);
  79 void    channel_input_ieof(int type, int plen);
  80 void    channel_input_oclose(int type, int plen);
  81 void    channel_input_open_confirmation(int type, int plen);
  82 void    channel_input_open_failure(int type, int plen);
  83 void    channel_input_port_open(int type, int plen);
  84 void    channel_input_open(int type, int plen);
  85
  86 /* Sets specific protocol options. */
  87 void    channel_set_options(int hostname_in_open);
  88
  89 /*
  90  * Allocate a new channel object and set its type and socket.  Remote_name
  91  * must have been allocated with xmalloc; this will free it when the channel
  92  * is freed.
  93  */
  94 int     channel_allocate(int type, int sock, char *remote_name);
  95
  96 /* Free the channel and close its socket. */
  97 void    channel_free(int channel);
  98
  99 /* Add any bits relevant to channels in select bitmasks. */
 100 void    channel_prepare_select(fd_set * readset, fd_set * writeset);
 101
 102 /*
 103  * After select, perform any appropriate operations for channels which have
 104  * events pending.
 105  */
 106 void    channel_after_select(fd_set * readset, fd_set * writeset);
 107
 108 /* If there is data to send to the connection, send some of it now. */
 109 void    channel_output_poll(void);
 110
 111 /* Returns true if no channel has too much buffered data. */
 112 int     channel_not_very_much_buffered_data(void);
 113
 114 /* This closes any sockets that are listening for connections; this removes
 115    any unix domain sockets. */
 116 void    channel_stop_listening(void);
 117
 118 /*
 119  * Closes the sockets of all channels.  This is used to close extra file
 120  * descriptors after a fork.
 121  */
 122 void    channel_close_all(void);
 123
 124 /* Returns the maximum file descriptor number used by the channels. */
 125 int     channel_max_fd(void);
 126
 127 /* Returns true if there is still an open channel over the connection. */
 128 int     channel_still_open(void);
 129
 130 /*
 131  * Returns a string containing a list of all open channels.  The list is
 132  * suitable for displaying to the user.  It uses crlf instead of newlines.
 133  * The caller should free the string with xfree.
 134  */
 135 char   *channel_open_message(void);
 136
 137 /*
 138  * Initiate forwarding of connections to local port "port" through the secure
 139  * channel to host:port from remote side.  This never returns if there was an
 140  * error.
 141  */
 142 void
 143 channel_request_local_forwarding(u_short port, const char *host,
 144     u_short remote_port, int gateway_ports);
 145
 146 /*
 147  * Initiate forwarding of connections to port "port" on remote host through
 148  * the secure channel to host:port from local side.  This never returns if
 149  * there was an error.  This registers that open requests for that port are
 150  * permitted.
 151  */
 152 void
 153 channel_request_remote_forwarding(u_short port, const char *host,
 154     u_short remote_port);
 155
 156 /*
 157  * Permits opening to any host/port in SSH_MSG_PORT_OPEN.  This is usually
 158  * called by the server, because the user could connect to any port anyway,
 159  * and the server has no way to know but to trust the client anyway.
 160  */
 161 void    channel_permit_all_opens(void);
 162
 163 /*
 164  * This is called after receiving CHANNEL_FORWARDING_REQUEST.  This initates
 165  * listening for the port, and sends back a success reply (or disconnect
 166  * message if there was an error).  This never returns if there was an error.
 167  */
 168 void    channel_input_port_forward_request(int is_root);
 169
 170 /*
 171  * Creates a port for X11 connections, and starts listening for it. Returns
 172  * the display name, or NULL if an error was encountered.
 173  */
 174 char   *x11_create_display(int screen);
 175
 176 /*
 177  * Creates an internet domain socket for listening for X11 connections.
 178  * Returns a suitable value for the DISPLAY variable, or NULL if an error
 179  * occurs.
 180  */
 181 char   *x11_create_display_inet(int screen, int x11_display_offset);
 182
 183 /*
 184  * This is called when SSH_SMSG_X11_OPEN is received.  The packet contains
 185  * the remote channel number.  We should do whatever we want, and respond
 186  * with either SSH_MSG_OPEN_CONFIRMATION or SSH_MSG_OPEN_FAILURE.
 187  */
 188 void    x11_input_open(int type, int plen);
 189
 190 /*
 191  * Requests forwarding of X11 connections.  This should be called on the
 192  * client only.
 193  */
 194 void    x11_request_forwarding(void);
 195
 196 /*
 197  * Requests forwarding for X11 connections, with authentication spoofing.
 198  * This should be called in the client only.
 199  */
 200 void    x11_request_forwarding_with_spoofing(const char *proto, const char *data);
 201
 202 /* Sends a message to the server to request authentication fd forwarding. */
 203 void    auth_request_forwarding(void);
 204
 205 /*
 206  * Returns the name of the forwarded authentication socket.  Returns NULL if
 207  * there is no forwarded authentication socket.  The returned value points to
 208  * a static buffer.
 209  */
 210 char   *auth_get_socket_name(void);
 211
 212 /*
 213  * This if called to process SSH_CMSG_AGENT_REQUEST_FORWARDING on the server.
 214  * This starts forwarding authentication requests.
 215  */
 216 void    auth_input_request_forwarding(struct passwd * pw);
 217
 218 /* This is called to process an SSH_SMSG_AGENT_OPEN message. */
 219 void    auth_input_open_request(int type, int plen);
 220
 221 #endif