channels.h 11.3 KB
Newer Older
1
/* $OpenBSD: channels.h,v 1.113 2013/06/07 15:37:52 dtucker Exp $ */
2

3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Author: Tatu Ylonen <ylo@cs.hut.fi>
 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 *                    All rights reserved
 *
 * As far as I am concerned, the code I have written for this software
 * can be used freely for any purpose.  Any derived versions of this
 * software must be clearly marked as such, and if the derived work is
 * incompatible with the protocol description in the RFC file, it must be
 * called by a name other than "ssh" or "Secure Shell".
 */
/*
15
 * Copyright (c) 1999, 2000, 2001, 2002 Markus Friedl.  All rights reserved.
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
Damien Miller's avatar
Damien Miller committed
37

38 39
#ifndef CHANNEL_H
#define CHANNEL_H
Damien Miller's avatar
Damien Miller committed
40 41

/* Definitions for channel types. */
42
#define SSH_CHANNEL_X11_LISTENER	1	/* Listening for inet X11 conn. */
43 44 45
#define SSH_CHANNEL_PORT_LISTENER	2	/* Listening on a port. */
#define SSH_CHANNEL_OPENING		3	/* waiting for confirmation */
#define SSH_CHANNEL_OPEN		4	/* normal open two-way channel */
46
#define SSH_CHANNEL_CLOSED		5	/* waiting for close confirmation */
47 48 49 50 51
#define SSH_CHANNEL_AUTH_SOCKET		6	/* authentication socket */
#define SSH_CHANNEL_X11_OPEN		7	/* reading first X11 packet */
#define SSH_CHANNEL_INPUT_DRAINING	8	/* sending remaining data to conn */
#define SSH_CHANNEL_OUTPUT_DRAINING	9	/* sending remaining data to app */
#define SSH_CHANNEL_LARVAL		10	/* larval session */
52
#define SSH_CHANNEL_RPORT_LISTENER	11	/* Listening to a R-style port  */
Ben Lindstrom's avatar
Ben Lindstrom committed
53
#define SSH_CHANNEL_CONNECTING		12
54
#define SSH_CHANNEL_DYNAMIC		13
55
#define SSH_CHANNEL_ZOMBIE		14	/* Almost dead. */
56 57
#define SSH_CHANNEL_MUX_LISTENER	15	/* Listener for mux conn. */
#define SSH_CHANNEL_MUX_CLIENT		16	/* Conn. to mux slave */
58 59
#define SSH_CHANNEL_ABANDONED		17	/* Abandoned session, eg mux */
#define SSH_CHANNEL_MAX_TYPE		18
Damien Miller's avatar
Damien Miller committed
60

61 62
#define CHANNEL_CANCEL_PORT_STATIC	-1

63 64 65
struct Channel;
typedef struct Channel Channel;

66
typedef void channel_open_fn(int, int, void *);
67
typedef void channel_callback_fn(int, void *);
68
typedef int channel_infilter_fn(struct Channel *, char *, int);
69
typedef void channel_filter_cleanup_fn(int, void *);
70
typedef u_char *channel_outfilter_fn(struct Channel *, u_char **, u_int *);
Damien Miller's avatar
Damien Miller committed
71

72 73 74 75 76 77 78 79 80 81 82
/* Channel success/failure callbacks */
typedef void channel_confirm_cb(int, struct Channel *, void *);
typedef void channel_confirm_abandon_cb(struct Channel *, void *);
struct channel_confirm {
	TAILQ_ENTRY(channel_confirm) entry;
	channel_confirm_cb *cb;
	channel_confirm_abandon_cb *abandon_cb;
	void *ctx;
};
TAILQ_HEAD(channel_confirms, channel_confirm);

83 84 85 86 87 88 89
/* Context for non-blocking connects */
struct channel_connect {
	char *host;
	int port;
	struct addrinfo *ai, *aitop;
};

90 91 92
/* Callbacks for mux channels back into client-specific code */
typedef int mux_callback_fn(struct Channel *);

93
struct Channel {
94 95 96
	int     type;		/* channel type/state */
	int     self;		/* my own channel identifier */
	int     remote_id;	/* channel identifier for remote peer */
97 98
	u_int   istate;		/* input from channel (state of receive half) */
	u_int   ostate;		/* output to channel  (state of transmit half) */
Damien Miller's avatar
Damien Miller committed
99
	int     flags;		/* close sent/rcvd */
100 101 102 103
	int     rfd;		/* read fd */
	int     wfd;		/* write fd */
	int     efd;		/* extended fd */
	int     sock;		/* sock fd */
104
	int     ctl_chan;	/* control channel (multiplexed connections) */
Damien Miller's avatar
Damien Miller committed
105
	int     isatty;		/* rfd is a tty */
106
#ifdef _AIX
107
	int     wfd_isatty;	/* wfd is a tty */
108
#endif
109
	int	client_tty;	/* (client) TTY has been requested */
110
	int     force_drain;	/* force close on iEOF */
111
	time_t	notbefore;	/* Pause IO until deadline (time_t) */
112 113 114 115
	int     delayed;	/* post-select handlers for newly created
				 * channels are delayed until the first call
				 * to a matching pre-select handler. 
				 * this way post-select handlers are not
116
				 * accidentally called if a FD gets reused */
117 118 119 120
	Buffer  input;		/* data read from socket, to be sent over
				 * encrypted connection */
	Buffer  output;		/* data received over encrypted connection for
				 * send on socket */
121
	Buffer  extended;
122
	char    *path;
123
		/* path for unix domain sockets, or host name for forwards */
124
	int     listening_port;	/* port being listened for forwards */
125
	char   *listening_addr;	/* addr being listened for forwards */
126 127
	int     host_port;	/* remote port to connect for forwards */
	char   *remote_name;	/* remote hostname */
128

129 130 131 132 133 134
	u_int	remote_window;
	u_int	remote_maxpacket;
	u_int	local_window;
	u_int	local_window_max;
	u_int	local_consumed;
	u_int	local_maxpacket;
135
	int     extended_usage;
136
	int	single_connection;
137 138 139

	char   *ctype;		/* type */

140
	/* callback */
141
	channel_open_fn		*open_confirm;
142
	void			*open_confirm_ctx;
143 144
	channel_callback_fn	*detach_user;
	int			detach_close;
145
	struct channel_confirms	status_confirms;
146 147

	/* filter */
148 149
	channel_infilter_fn	*input_filter;
	channel_outfilter_fn	*output_filter;
150
	void			*filter_ctx;
151
	channel_filter_cleanup_fn *filter_cleanup;
152

153 154 155 156 157
	/* keep boundaries */
	int     		datagram;

	/* non-blocking connect */
	struct channel_connect	connect_ctx;
158 159 160 161

	/* multiplexing protocol hook, called for each packet received */
	mux_callback_fn		*mux_rcb;
	void			*mux_ctx;
162
	int			mux_pause;
163
};
164 165 166 167 168

#define CHAN_EXTENDED_IGNORE		0
#define CHAN_EXTENDED_READ		1
#define CHAN_EXTENDED_WRITE		2

169
/* default window/packet sizes for tcp/x11-fwd-channel */
170
#define CHAN_SES_PACKET_DEFAULT	(32*1024)
171
#define CHAN_SES_WINDOW_DEFAULT	(64*CHAN_SES_PACKET_DEFAULT)
172
#define CHAN_TCP_PACKET_DEFAULT	(32*1024)
173
#define CHAN_TCP_WINDOW_DEFAULT	(64*CHAN_TCP_PACKET_DEFAULT)
174 175
#define CHAN_X11_PACKET_DEFAULT	(16*1024)
#define CHAN_X11_WINDOW_DEFAULT	(4*CHAN_X11_PACKET_DEFAULT)
176

177
/* possible input states */
178 179 180 181
#define CHAN_INPUT_OPEN			0
#define CHAN_INPUT_WAIT_DRAIN		1
#define CHAN_INPUT_WAIT_OCLOSE		2
#define CHAN_INPUT_CLOSED		3
182

183
/* possible output states */
184 185 186 187
#define CHAN_OUTPUT_OPEN		0
#define CHAN_OUTPUT_WAIT_DRAIN		1
#define CHAN_OUTPUT_WAIT_IEOF		2
#define CHAN_OUTPUT_CLOSED		3
188 189 190

#define CHAN_CLOSE_SENT			0x01
#define CHAN_CLOSE_RCVD			0x02
191 192
#define CHAN_EOF_SENT			0x04
#define CHAN_EOF_RCVD			0x08
193
#define CHAN_LOCAL			0x10
194

195 196
#define CHAN_RBUF	16*1024

197 198 199 200 201 202 203
/* check whether 'efd' is still in use */
#define CHANNEL_EFD_INPUT_ACTIVE(c) \
	(compat20 && c->extended_usage == CHAN_EXTENDED_READ && \
	(c->efd != -1 || \
	buffer_len(&c->extended) > 0))
#define CHANNEL_EFD_OUTPUT_ACTIVE(c) \
	(compat20 && c->extended_usage == CHAN_EXTENDED_WRITE && \
204
	c->efd != -1 && (!(c->flags & (CHAN_EOF_RCVD|CHAN_CLOSE_RCVD)) || \
205
	buffer_len(&c->extended) > 0))
206 207 208

/* channel management */

209
Channel	*channel_by_id(int);
210
Channel	*channel_lookup(int);
211
Channel *channel_new(char *, int, int, int, int, u_int, u_int, int, char *, int);
212
void	 channel_set_fds(int, int, int, int, int, int, int, u_int);
213 214 215
void	 channel_free(Channel *);
void	 channel_free_all(void);
void	 channel_stop_listening(void);
216 217 218

void	 channel_send_open(int);
void	 channel_request_start(int, char *, int);
219
void	 channel_register_cleanup(int, channel_callback_fn *, int);
220
void	 channel_register_open_confirm(int, channel_open_fn *, void *);
221
void	 channel_register_filter(int, channel_infilter_fn *,
222
    channel_outfilter_fn *, channel_filter_cleanup_fn *, void *);
223 224
void	 channel_register_status_confirm(int, channel_confirm_cb *,
    channel_confirm_abandon_cb *, void *);
225
void	 channel_cancel_cleanup(int);
226
int	 channel_close_fd(int *);
227
void	 channel_send_window_changes(void);
228

229
/* protocol handler */
230

231 232 233 234 235 236 237 238 239 240
void	 channel_input_close(int, u_int32_t, void *);
void	 channel_input_close_confirmation(int, u_int32_t, void *);
void	 channel_input_data(int, u_int32_t, void *);
void	 channel_input_extended_data(int, u_int32_t, void *);
void	 channel_input_ieof(int, u_int32_t, void *);
void	 channel_input_oclose(int, u_int32_t, void *);
void	 channel_input_open_confirmation(int, u_int32_t, void *);
void	 channel_input_open_failure(int, u_int32_t, void *);
void	 channel_input_port_open(int, u_int32_t, void *);
void	 channel_input_window_adjust(int, u_int32_t, void *);
241
void	 channel_input_status_confirm(int, u_int32_t, void *);
242

243
/* file descriptor handling (read/write) */
244

245 246
void	 channel_prepare_select(fd_set **, fd_set **, int *, u_int*,
	     time_t*, int);
247 248
void     channel_after_select(fd_set *, fd_set *);
void     channel_output_poll(void);
249

250 251 252 253 254
int      channel_not_very_much_buffered_data(void);
void     channel_close_all(void);
int      channel_still_open(void);
char	*channel_open_message(void);
int	 channel_find_open(void);
255

256 257
/* tcp forwarding */
void	 channel_set_af(int af);
258 259
void     channel_permit_all_opens(void);
void	 channel_add_permitted_opens(char *, int);
260
int	 channel_add_adm_permitted_opens(char *, int);
261
void	 channel_disable_adm_local_opens(void);
262
void	 channel_update_permitted_opens(int, int);
263
void	 channel_clear_permitted_opens(void);
264
void	 channel_clear_adm_permitted_opens(void);
265
void 	 channel_print_adm_permitted_opens(void);
266
int      channel_input_port_forward_request(int, int);
267
Channel	*channel_connect_to(const char *, u_short, char *, char *);
268
Channel	*channel_connect_stdio_fwd(const char*, u_short, int, int);
269
Channel	*channel_connect_by_listen_address(u_short, char *, char *);
270
int	 channel_request_remote_forwarding(const char *, u_short,
271 272 273
	     const char *, u_short);
int	 channel_setup_local_fwd_listener(const char *, u_short,
	     const char *, u_short, int);
274
int	 channel_request_rforward_cancel(const char *host, u_short port);
275
int	 channel_setup_remote_fwd_listener(const char *, u_short, int *, int);
276
int	 channel_cancel_rport_listener(const char *, u_short);
277
int	 channel_cancel_lport_listener(const char *, u_short, int, int);
278
int	 permitopen_port(const char *);
279

280
/* x11 forwarding */
281

282
int	 x11_connect_display(void);
283
int	 x11_create_display_inet(int, int, int, u_int *, int **);
284
void     x11_input_open(int, u_int32_t, void *);
285
void	 x11_request_forwarding_with_spoofing(int, const char *, const char *,
286
	     const char *, int);
287
void	 deny_input_open(int, u_int32_t, void *);
288

289
/* agent forwarding */
290

291
void	 auth_request_forwarding(void);
292

293
/* channel close */
Damien Miller's avatar
Damien Miller committed
294

295
int	 chan_is_dead(Channel *, int);
296 297
void	 chan_mark_dead(Channel *);

298
/* channel events */
299

300
void	 chan_rcvd_oclose(Channel *);
301
void	 chan_rcvd_eow(Channel *);	/* SSH2-only */
302 303
void	 chan_read_failed(Channel *);
void	 chan_ibuf_empty(Channel *);
304

305 306 307
void	 chan_rcvd_ieof(Channel *);
void	 chan_write_failed(Channel *);
void	 chan_obuf_empty(Channel *);
308

Damien Miller's avatar
Damien Miller committed
309
#endif