nchan.c revision 1.62 
1/* $OpenBSD: nchan.c,v 1.62 2008/11/07 18:50:18 stevesk Exp $ */
2/*
3 * Copyright (c) 1999, 2000, 2001, 2002 Markus Friedl.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include <sys/types.h>
27#include <sys/socket.h>
28#include <sys/queue.h>
29
30#include <errno.h>
31#include <string.h>
32#include <stdarg.h>
33
34#include "ssh1.h"
35#include "ssh2.h"
36#include "buffer.h"
37#include "packet.h"
38#include "channels.h"
39#include "compat.h"
40#include "log.h"
41
42/*
43 * SSH Protocol 1.5 aka New Channel Protocol
44 * Thanks to Martina, Axel and everyone who left Erlangen, leaving me bored.
45 * Written by Markus Friedl in October 1999
46 *
47 * Protocol versions 1.3 and 1.5 differ in the handshake protocol used for the
48 * tear down of channels:
49 *
50 * 1.3:	strict request-ack-protocol:
51 *	CLOSE	->
52 *		<-  CLOSE_CONFIRM
53 *
54 * 1.5:	uses variations of:
55 *	IEOF	->
56 *		<-  OCLOSE
57 *		<-  IEOF
58 *	OCLOSE	->
59 *	i.e. both sides have to close the channel
60 *
61 * 2.0: the EOF messages are optional
62 *
63 * See the debugging output from 'ssh -v' and 'sshd -d' of
64 * ssh-1.2.27 as an example.
65 *
66 */
67
68/* functions manipulating channel states */
69/*
70 * EVENTS update channel input/output states execute ACTIONS
71 */
72/*
73 * ACTIONS: should never update the channel states
74 */
75static void	chan_send_ieof1(Channel *);
76static void	chan_send_oclose1(Channel *);
77static void	chan_send_close2(Channel *);
78static void	chan_send_eof2(Channel *);
79static void	chan_send_eow2(Channel *);
80
81/* helper */
82static void	chan_shutdown_write(Channel *);
83static void	chan_shutdown_read(Channel *);
84
85static char *ostates[] = { "open", "drain", "wait_ieof", "closed" };
86static char *istates[] = { "open", "drain", "wait_oclose", "closed" };
87
88static void
89chan_set_istate(Channel *c, u_int next)
90{
91	if (c->istate > CHAN_INPUT_CLOSED || next > CHAN_INPUT_CLOSED)
92		fatal("chan_set_istate: bad state %d -> %d", c->istate, next);
93	debug2("channel %d: input %s -> %s", c->self, istates[c->istate],
94	    istates[next]);
95	c->istate = next;
96}
97static void
98chan_set_ostate(Channel *c, u_int next)
99{
100	if (c->ostate > CHAN_OUTPUT_CLOSED || next > CHAN_OUTPUT_CLOSED)
101		fatal("chan_set_ostate: bad state %d -> %d", c->ostate, next);
102	debug2("channel %d: output %s -> %s", c->self, ostates[c->ostate],
103	    ostates[next]);
104	c->ostate = next;
105}
106
107/*
108 * SSH1 specific implementation of event functions
109 */
110
111static void
112chan_rcvd_oclose1(Channel *c)
113{
114	debug2("channel %d: rcvd oclose", c->self);
115	switch (c->istate) {
116	case CHAN_INPUT_WAIT_OCLOSE:
117		chan_set_istate(c, CHAN_INPUT_CLOSED);
118		break;
119	case CHAN_INPUT_OPEN:
120		chan_shutdown_read(c);
121		chan_send_ieof1(c);
122		chan_set_istate(c, CHAN_INPUT_CLOSED);
123		break;
124	case CHAN_INPUT_WAIT_DRAIN:
125		/* both local read_failed and remote write_failed  */
126		chan_send_ieof1(c);
127		chan_set_istate(c, CHAN_INPUT_CLOSED);
128		break;
129	default:
130		error("channel %d: protocol error: rcvd_oclose for istate %d",
131		    c->self, c->istate);
132		return;
133	}
134}
135void
136chan_read_failed(Channel *c)
137{
138	debug2("channel %d: read failed", c->self);
139	switch (c->istate) {
140	case CHAN_INPUT_OPEN:
141		chan_shutdown_read(c);
142		chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN);
143		break;
144	default:
145		error("channel %d: chan_read_failed for istate %d",
146		    c->self, c->istate);
147		break;
148	}
149}
150void
151chan_ibuf_empty(Channel *c)
152{
153	debug2("channel %d: ibuf empty", c->self);
154	if (buffer_len(&c->input)) {
155		error("channel %d: chan_ibuf_empty for non empty buffer",
156		    c->self);
157		return;
158	}
159	switch (c->istate) {
160	case CHAN_INPUT_WAIT_DRAIN:
161		if (compat20) {
162			if (!(c->flags & CHAN_CLOSE_SENT))
163				chan_send_eof2(c);
164			chan_set_istate(c, CHAN_INPUT_CLOSED);
165		} else {
166			chan_send_ieof1(c);
167			chan_set_istate(c, CHAN_INPUT_WAIT_OCLOSE);
168		}
169		break;
170	default:
171		error("channel %d: chan_ibuf_empty for istate %d",
172		    c->self, c->istate);
173		break;
174	}
175}
176static void
177chan_rcvd_ieof1(Channel *c)
178{
179	debug2("channel %d: rcvd ieof", c->self);
180	switch (c->ostate) {
181	case CHAN_OUTPUT_OPEN:
182		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
183		break;
184	case CHAN_OUTPUT_WAIT_IEOF:
185		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
186		break;
187	default:
188		error("channel %d: protocol error: rcvd_ieof for ostate %d",
189		    c->self, c->ostate);
190		break;
191	}
192}
193static void
194chan_write_failed1(Channel *c)
195{
196	debug2("channel %d: write failed", c->self);
197	switch (c->ostate) {
198	case CHAN_OUTPUT_OPEN:
199		chan_shutdown_write(c);
200		chan_send_oclose1(c);
201		chan_set_ostate(c, CHAN_OUTPUT_WAIT_IEOF);
202		break;
203	case CHAN_OUTPUT_WAIT_DRAIN:
204		chan_shutdown_write(c);
205		chan_send_oclose1(c);
206		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
207		break;
208	default:
209		error("channel %d: chan_write_failed for ostate %d",
210		    c->self, c->ostate);
211		break;
212	}
213}
214void
215chan_obuf_empty(Channel *c)
216{
217	debug2("channel %d: obuf empty", c->self);
218	if (buffer_len(&c->output)) {
219		error("channel %d: chan_obuf_empty for non empty buffer",
220		    c->self);
221		return;
222	}
223	switch (c->ostate) {
224	case CHAN_OUTPUT_WAIT_DRAIN:
225		chan_shutdown_write(c);
226		if (!compat20)
227			chan_send_oclose1(c);
228		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
229		break;
230	default:
231		error("channel %d: internal error: obuf_empty for ostate %d",
232		    c->self, c->ostate);
233		break;
234	}
235}
236static void
237chan_send_ieof1(Channel *c)
238{
239	debug2("channel %d: send ieof", c->self);
240	switch (c->istate) {
241	case CHAN_INPUT_OPEN:
242	case CHAN_INPUT_WAIT_DRAIN:
243		packet_start(SSH_MSG_CHANNEL_INPUT_EOF);
244		packet_put_int(c->remote_id);
245		packet_send();
246		break;
247	default:
248		error("channel %d: cannot send ieof for istate %d",
249		    c->self, c->istate);
250		break;
251	}
252}
253static void
254chan_send_oclose1(Channel *c)
255{
256	debug2("channel %d: send oclose", c->self);
257	switch (c->ostate) {
258	case CHAN_OUTPUT_OPEN:
259	case CHAN_OUTPUT_WAIT_DRAIN:
260		buffer_clear(&c->output);
261		packet_start(SSH_MSG_CHANNEL_OUTPUT_CLOSE);
262		packet_put_int(c->remote_id);
263		packet_send();
264		break;
265	default:
266		error("channel %d: cannot send oclose for ostate %d",
267		    c->self, c->ostate);
268		break;
269	}
270}
271
272/*
273 * the same for SSH2
274 */
275static void
276chan_rcvd_close2(Channel *c)
277{
278	debug2("channel %d: rcvd close", c->self);
279	if (c->flags & CHAN_CLOSE_RCVD)
280		error("channel %d: protocol error: close rcvd twice", c->self);
281	c->flags |= CHAN_CLOSE_RCVD;
282	if (c->type == SSH_CHANNEL_LARVAL) {
283		/* tear down larval channels immediately */
284		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
285		chan_set_istate(c, CHAN_INPUT_CLOSED);
286		return;
287	}
288	switch (c->ostate) {
289	case CHAN_OUTPUT_OPEN:
290		/*
291		 * wait until a data from the channel is consumed if a CLOSE
292		 * is received
293		 */
294		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
295		break;
296	}
297	switch (c->istate) {
298	case CHAN_INPUT_OPEN:
299		chan_shutdown_read(c);
300		chan_set_istate(c, CHAN_INPUT_CLOSED);
301		break;
302	case CHAN_INPUT_WAIT_DRAIN:
303		chan_send_eof2(c);
304		chan_set_istate(c, CHAN_INPUT_CLOSED);
305		break;
306	}
307}
308void
309chan_rcvd_eow(Channel *c)
310{
311	debug2("channel %d: rcvd eow", c->self);
312	switch (c->istate) {
313	case CHAN_INPUT_OPEN:
314		chan_shutdown_read(c);
315		chan_set_istate(c, CHAN_INPUT_CLOSED);
316		break;
317	}
318}
319static void
320chan_rcvd_eof2(Channel *c)
321{
322	debug2("channel %d: rcvd eof", c->self);
323	c->flags |= CHAN_EOF_RCVD;
324	if (c->ostate == CHAN_OUTPUT_OPEN)
325		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
326}
327static void
328chan_write_failed2(Channel *c)
329{
330	debug2("channel %d: write failed", c->self);
331	switch (c->ostate) {
332	case CHAN_OUTPUT_OPEN:
333	case CHAN_OUTPUT_WAIT_DRAIN:
334		chan_shutdown_write(c);
335		if (strcmp(c->ctype, "session") == 0)
336			chan_send_eow2(c);
337		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
338		break;
339	default:
340		error("channel %d: chan_write_failed for ostate %d",
341		    c->self, c->ostate);
342		break;
343	}
344}
345static void
346chan_send_eof2(Channel *c)
347{
348	debug2("channel %d: send eof", c->self);
349	switch (c->istate) {
350	case CHAN_INPUT_WAIT_DRAIN:
351		packet_start(SSH2_MSG_CHANNEL_EOF);
352		packet_put_int(c->remote_id);
353		packet_send();
354		c->flags |= CHAN_EOF_SENT;
355		break;
356	default:
357		error("channel %d: cannot send eof for istate %d",
358		    c->self, c->istate);
359		break;
360	}
361}
362static void
363chan_send_close2(Channel *c)
364{
365	debug2("channel %d: send close", c->self);
366	if (c->ostate != CHAN_OUTPUT_CLOSED ||
367	    c->istate != CHAN_INPUT_CLOSED) {
368		error("channel %d: cannot send close for istate/ostate %d/%d",
369		    c->self, c->istate, c->ostate);
370	} else if (c->flags & CHAN_CLOSE_SENT) {
371		error("channel %d: already sent close", c->self);
372	} else {
373		packet_start(SSH2_MSG_CHANNEL_CLOSE);
374		packet_put_int(c->remote_id);
375		packet_send();
376		c->flags |= CHAN_CLOSE_SENT;
377	}
378}
379static void
380chan_send_eow2(Channel *c)
381{
382	debug2("channel %d: send eow", c->self);
383	if (c->ostate == CHAN_OUTPUT_CLOSED) {
384		error("channel %d: must not sent eow on closed output",
385		    c->self);
386		return;
387	}
388	if (!(datafellows & SSH_NEW_OPENSSH))
389		return;
390	packet_start(SSH2_MSG_CHANNEL_REQUEST);
391	packet_put_int(c->remote_id);
392	packet_put_cstring("eow@openssh.com");
393	packet_put_char(0);
394	packet_send();
395}
396
397/* shared */
398
399void
400chan_rcvd_ieof(Channel *c)
401{
402	if (compat20)
403		chan_rcvd_eof2(c);
404	else
405		chan_rcvd_ieof1(c);
406	if (c->ostate == CHAN_OUTPUT_WAIT_DRAIN &&
407	    buffer_len(&c->output) == 0 &&
408	    !CHANNEL_EFD_OUTPUT_ACTIVE(c))
409		chan_obuf_empty(c);
410}
411void
412chan_rcvd_oclose(Channel *c)
413{
414	if (compat20)
415		chan_rcvd_close2(c);
416	else
417		chan_rcvd_oclose1(c);
418}
419void
420chan_write_failed(Channel *c)
421{
422	if (compat20)
423		chan_write_failed2(c);
424	else
425		chan_write_failed1(c);
426}
427
428void
429chan_mark_dead(Channel *c)
430{
431	c->type = SSH_CHANNEL_ZOMBIE;
432}
433
434int
435chan_is_dead(Channel *c, int do_send)
436{
437	if (c->type == SSH_CHANNEL_ZOMBIE) {
438		debug2("channel %d: zombie", c->self);
439		return 1;
440	}
441	if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED)
442		return 0;
443	if (!compat20) {
444		debug2("channel %d: is dead", c->self);
445		return 1;
446	}
447	if ((datafellows & SSH_BUG_EXTEOF) &&
448	    c->extended_usage == CHAN_EXTENDED_WRITE &&
449	    c->efd != -1 &&
450	    buffer_len(&c->extended) > 0) {
451		debug2("channel %d: active efd: %d len %d",
452		    c->self, c->efd, buffer_len(&c->extended));
453		return 0;
454	}
455	if (!(c->flags & CHAN_CLOSE_SENT)) {
456		if (do_send) {
457			chan_send_close2(c);
458		} else {
459			/* channel would be dead if we sent a close */
460			if (c->flags & CHAN_CLOSE_RCVD) {
461				debug2("channel %d: almost dead",
462				    c->self);
463				return 1;
464			}
465		}
466	}
467	if ((c->flags & CHAN_CLOSE_SENT) &&
468	    (c->flags & CHAN_CLOSE_RCVD)) {
469		debug2("channel %d: is dead", c->self);
470		return 1;
471	}
472	return 0;
473}
474
475/* helper */
476static void
477chan_shutdown_write(Channel *c)
478{
479	buffer_clear(&c->output);
480	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
481		return;
482	/* shutdown failure is allowed if write failed already */
483	debug2("channel %d: close_write", c->self);
484	if (c->sock != -1) {
485		if (shutdown(c->sock, SHUT_WR) < 0)
486			debug2("channel %d: chan_shutdown_write: "
487			    "shutdown() failed for fd %d: %.100s",
488			    c->self, c->sock, strerror(errno));
489	} else {
490		if (channel_close_fd(&c->wfd) < 0)
491			logit("channel %d: chan_shutdown_write: "
492			    "close() failed for fd %d: %.100s",
493			    c->self, c->wfd, strerror(errno));
494	}
495}
496static void
497chan_shutdown_read(Channel *c)
498{
499	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
500		return;
501	debug2("channel %d: close_read", c->self);
502	if (c->sock != -1) {
503		if (shutdown(c->sock, SHUT_RD) < 0)
504			error("channel %d: chan_shutdown_read: "
505			    "shutdown() failed for fd %d [i%d o%d]: %.100s",
506			    c->self, c->sock, c->istate, c->ostate,
507			    strerror(errno));
508	} else {
509		if (channel_close_fd(&c->rfd) < 0)
510			logit("channel %d: chan_shutdown_read: "
511			    "close() failed for fd %d: %.100s",
512			    c->self, c->rfd, strerror(errno));
513	}
514}
515