[gssapi-openssh.git] / openssh / nchan.c

/* $OpenBSD: nchan.c,v 1.57 2006/08/03 03:34:42 deraadt Exp $ */
/*
 * Copyright (c) 1999, 2000, 2001, 2002 Markus Friedl.  All rights reserved.
 *
 * 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.
 */

#include "includes.h"

#include <sys/types.h>
#include <sys/socket.h>

#include <errno.h>
#include <string.h>
#include <stdarg.h>

#include "ssh1.h"
#include "ssh2.h"
#include "buffer.h"
#include "packet.h"
#include "channels.h"
#include "compat.h"
#include "log.h"

/*
 * SSH Protocol 1.5 aka New Channel Protocol
 * Thanks to Martina, Axel and everyone who left Erlangen, leaving me bored.
 * Written by Markus Friedl in October 1999
 *
 * Protocol versions 1.3 and 1.5 differ in the handshake protocol used for the
 * tear down of channels:
 *
 * 1.3:	strict request-ack-protocol:
 *	CLOSE	->
 *		<-  CLOSE_CONFIRM
 *
 * 1.5:	uses variations of:
 *	IEOF	->
 *		<-  OCLOSE
 *		<-  IEOF
 *	OCLOSE	->
 *	i.e. both sides have to close the channel
 *
 * 2.0: the EOF messages are optional
 *
 * See the debugging output from 'ssh -v' and 'sshd -d' of
 * ssh-1.2.27 as an example.
 *
 */

/* functions manipulating channel states */
/*
 * EVENTS update channel input/output states execute ACTIONS
 */
/*
 * ACTIONS: should never update the channel states
 */
static void	chan_send_ieof1(Channel *);
static void	chan_send_oclose1(Channel *);
static void	chan_send_close2(Channel *);
static void	chan_send_eof2(Channel *);

/* helper */
static void	chan_shutdown_write(Channel *);
static void	chan_shutdown_read(Channel *);

static char *ostates[] = { "open", "drain", "wait_ieof", "closed" };
static char *istates[] = { "open", "drain", "wait_oclose", "closed" };

static void
chan_set_istate(Channel *c, u_int next)
{
	if (c->istate > CHAN_INPUT_CLOSED || next > CHAN_INPUT_CLOSED)
		fatal("chan_set_istate: bad state %d -> %d", c->istate, next);
	debug2("channel %d: input %s -> %s", c->self, istates[c->istate],
	    istates[next]);
	c->istate = next;
}
static void
chan_set_ostate(Channel *c, u_int next)
{
	if (c->ostate > CHAN_OUTPUT_CLOSED || next > CHAN_OUTPUT_CLOSED)
		fatal("chan_set_ostate: bad state %d -> %d", c->ostate, next);
	debug2("channel %d: output %s -> %s", c->self, ostates[c->ostate],
	    ostates[next]);
	c->ostate = next;
}

/*
 * SSH1 specific implementation of event functions
 */

static void
chan_rcvd_oclose1(Channel *c)
{
	debug2("channel %d: rcvd oclose", c->self);
	switch (c->istate) {
	case CHAN_INPUT_WAIT_OCLOSE:
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		break;
	case CHAN_INPUT_OPEN:
		chan_shutdown_read(c);
		chan_send_ieof1(c);
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		break;
	case CHAN_INPUT_WAIT_DRAIN:
		/* both local read_failed and remote write_failed  */
		chan_send_ieof1(c);
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		break;
	default:
		error("channel %d: protocol error: rcvd_oclose for istate %d",
		    c->self, c->istate);
		return;
	}
}
void
chan_read_failed(Channel *c)
{
	debug2("channel %d: read failed", c->self);
	switch (c->istate) {
	case CHAN_INPUT_OPEN:
		chan_shutdown_read(c);
		chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN);
		break;
	default:
		error("channel %d: chan_read_failed for istate %d",
		    c->self, c->istate);
		break;
	}
}
void
chan_ibuf_empty(Channel *c)
{
	debug2("channel %d: ibuf empty", c->self);
	if (buffer_len(&c->input)) {
		error("channel %d: chan_ibuf_empty for non empty buffer",
		    c->self);
		return;
	}
	switch (c->istate) {
	case CHAN_INPUT_WAIT_DRAIN:
		if (compat20) {
			if (!(c->flags & CHAN_CLOSE_SENT))
				chan_send_eof2(c);
			chan_set_istate(c, CHAN_INPUT_CLOSED);
		} else {
			chan_send_ieof1(c);
			chan_set_istate(c, CHAN_INPUT_WAIT_OCLOSE);
		}
		break;
	default:
		error("channel %d: chan_ibuf_empty for istate %d",
		    c->self, c->istate);
		break;
	}
}
static void
chan_rcvd_ieof1(Channel *c)
{
	debug2("channel %d: rcvd ieof", c->self);
	switch (c->ostate) {
	case CHAN_OUTPUT_OPEN:
		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
		break;
	case CHAN_OUTPUT_WAIT_IEOF:
		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
		break;
	default:
		error("channel %d: protocol error: rcvd_ieof for ostate %d",
		    c->self, c->ostate);
		break;
	}
}
static void
chan_write_failed1(Channel *c)
{
	debug2("channel %d: write failed", c->self);
	switch (c->ostate) {
	case CHAN_OUTPUT_OPEN:
		chan_shutdown_write(c);
		chan_send_oclose1(c);
		chan_set_ostate(c, CHAN_OUTPUT_WAIT_IEOF);
		break;
	case CHAN_OUTPUT_WAIT_DRAIN:
		chan_shutdown_write(c);
		chan_send_oclose1(c);
		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
		break;
	default:
		error("channel %d: chan_write_failed for ostate %d",
		    c->self, c->ostate);
		break;
	}
}
void
chan_obuf_empty(Channel *c)
{
	debug2("channel %d: obuf empty", c->self);
	if (buffer_len(&c->output)) {
		error("channel %d: chan_obuf_empty for non empty buffer",
		    c->self);
		return;
	}
	switch (c->ostate) {
	case CHAN_OUTPUT_WAIT_DRAIN:
		chan_shutdown_write(c);
		if (!compat20)
			chan_send_oclose1(c);
		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
		break;
	default:
		error("channel %d: internal error: obuf_empty for ostate %d",
		    c->self, c->ostate);
		break;
	}
}
static void
chan_send_ieof1(Channel *c)
{
	debug2("channel %d: send ieof", c->self);
	switch (c->istate) {
	case CHAN_INPUT_OPEN:
	case CHAN_INPUT_WAIT_DRAIN:
		packet_start(SSH_MSG_CHANNEL_INPUT_EOF);
		packet_put_int(c->remote_id);
		packet_send();
		break;
	default:
		error("channel %d: cannot send ieof for istate %d",
		    c->self, c->istate);
		break;
	}
}
static void
chan_send_oclose1(Channel *c)
{
	debug2("channel %d: send oclose", c->self);
	switch (c->ostate) {
	case CHAN_OUTPUT_OPEN:
	case CHAN_OUTPUT_WAIT_DRAIN:
		buffer_clear(&c->output);
		packet_start(SSH_MSG_CHANNEL_OUTPUT_CLOSE);
		packet_put_int(c->remote_id);
		packet_send();
		break;
	default:
		error("channel %d: cannot send oclose for ostate %d",
		    c->self, c->ostate);
		break;
	}
}

/*
 * the same for SSH2
 */
static void
chan_rcvd_close2(Channel *c)
{
	debug2("channel %d: rcvd close", c->self);
	if (c->flags & CHAN_CLOSE_RCVD)
		error("channel %d: protocol error: close rcvd twice", c->self);
	c->flags |= CHAN_CLOSE_RCVD;
	if (c->type == SSH_CHANNEL_LARVAL) {
		/* tear down larval channels immediately */
		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		return;
	}
	switch (c->ostate) {
	case CHAN_OUTPUT_OPEN:
		/*
		 * wait until a data from the channel is consumed if a CLOSE
		 * is received
		 */
		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
		break;
	}
	switch (c->istate) {
	case CHAN_INPUT_OPEN:
		chan_shutdown_read(c);
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		break;
	case CHAN_INPUT_WAIT_DRAIN:
		chan_send_eof2(c);
		chan_set_istate(c, CHAN_INPUT_CLOSED);
		break;
	}
}
static void
chan_rcvd_eof2(Channel *c)
{
	debug2("channel %d: rcvd eof", c->self);
	c->flags |= CHAN_EOF_RCVD;
	if (c->ostate == CHAN_OUTPUT_OPEN)
		chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
}
static void
chan_write_failed2(Channel *c)
{
	debug2("channel %d: write failed", c->self);
	switch (c->ostate) {
	case CHAN_OUTPUT_OPEN:
	case CHAN_OUTPUT_WAIT_DRAIN:
		chan_shutdown_write(c);
		chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
		break;
	default:
		error("channel %d: chan_write_failed for ostate %d",
		    c->self, c->ostate);
		break;
	}
}
static void
chan_send_eof2(Channel *c)
{
	debug2("channel %d: send eof", c->self);
	switch (c->istate) {
	case CHAN_INPUT_WAIT_DRAIN:
		packet_start(SSH2_MSG_CHANNEL_EOF);
		packet_put_int(c->remote_id);
		packet_send();
		c->flags |= CHAN_EOF_SENT;
		break;
	default:
		error("channel %d: cannot send eof for istate %d",
		    c->self, c->istate);
		break;
	}
}
static void
chan_send_close2(Channel *c)
{
	debug2("channel %d: send close", c->self);
	if (c->ostate != CHAN_OUTPUT_CLOSED ||
	    c->istate != CHAN_INPUT_CLOSED) {
		error("channel %d: cannot send close for istate/ostate %d/%d",
		    c->self, c->istate, c->ostate);
	} else if (c->flags & CHAN_CLOSE_SENT) {
		error("channel %d: already sent close", c->self);
	} else {
		packet_start(SSH2_MSG_CHANNEL_CLOSE);
		packet_put_int(c->remote_id);
		packet_send();
		c->flags |= CHAN_CLOSE_SENT;
	}
}

/* shared */

void
chan_rcvd_ieof(Channel *c)
{
	if (compat20)
		chan_rcvd_eof2(c);
	else
		chan_rcvd_ieof1(c);
	if (c->ostate == CHAN_OUTPUT_WAIT_DRAIN &&
	    buffer_len(&c->output) == 0 &&
	    !CHANNEL_EFD_OUTPUT_ACTIVE(c))
		chan_obuf_empty(c);
}
void
chan_rcvd_oclose(Channel *c)
{
	if (compat20)
		chan_rcvd_close2(c);
	else
		chan_rcvd_oclose1(c);
}
void
chan_write_failed(Channel *c)
{
	if (compat20)
		chan_write_failed2(c);
	else
		chan_write_failed1(c);
}

void
chan_mark_dead(Channel *c)
{
	c->type = SSH_CHANNEL_ZOMBIE;
}

int
chan_is_dead(Channel *c, int do_send)
{
	if (c->type == SSH_CHANNEL_ZOMBIE) {
		debug2("channel %d: zombie", c->self);
		return 1;
	}
	if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED)
		return 0;
	if (!compat20) {
		debug2("channel %d: is dead", c->self);
		return 1;
	}
	if ((datafellows & SSH_BUG_EXTEOF) &&
	    c->extended_usage == CHAN_EXTENDED_WRITE &&
	    c->efd != -1 &&
	    buffer_len(&c->extended) > 0) {
		debug2("channel %d: active efd: %d len %d",
		    c->self, c->efd, buffer_len(&c->extended));
		return 0;
	}
	if (!(c->flags & CHAN_CLOSE_SENT)) {
		if (do_send) {
			chan_send_close2(c);
		} else {
			/* channel would be dead if we sent a close */
			if (c->flags & CHAN_CLOSE_RCVD) {
				debug2("channel %d: almost dead",
				    c->self);
				return 1;
			}
		}
	}
	if ((c->flags & CHAN_CLOSE_SENT) &&
	    (c->flags & CHAN_CLOSE_RCVD)) {
		debug2("channel %d: is dead", c->self);
		return 1;
	}
	return 0;
}

/* helper */
static void
chan_shutdown_write(Channel *c)
{
	buffer_clear(&c->output);
	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
		return;
	/* shutdown failure is allowed if write failed already */
	debug2("channel %d: close_write", c->self);
	if (c->sock != -1) {
		if (shutdown(c->sock, SHUT_WR) < 0)
			debug2("channel %d: chan_shutdown_write: "
			    "shutdown() failed for fd%d: %.100s",
			    c->self, c->sock, strerror(errno));
	} else {
		if (channel_close_fd(&c->wfd) < 0)
			logit("channel %d: chan_shutdown_write: "
			    "close() failed for fd%d: %.100s",
			    c->self, c->wfd, strerror(errno));
	}
}
static void
chan_shutdown_read(Channel *c)
{
	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
		return;
	debug2("channel %d: close_read", c->self);
	if (c->sock != -1) {
		/*
		 * shutdown(sock, SHUT_READ) may return ENOTCONN if the
		 * write side has been closed already. (bug on Linux)
		 * HP-UX may return ENOTCONN also.
		 */
		if (shutdown(c->sock, SHUT_RD) < 0
		    && errno != ENOTCONN)
			error("channel %d: chan_shutdown_read: "
			    "shutdown() failed for fd%d [i%d o%d]: %.100s",
			    c->self, c->sock, c->istate, c->ostate,
			    strerror(errno));
	} else {
		if (channel_close_fd(&c->rfd) < 0)
			logit("channel %d: chan_shutdown_read: "
			    "close() failed for fd%d: %.100s",
			    c->self, c->rfd, strerror(errno));
	}
}
Commit	Line	Data
9108f8d9	1	/* $OpenBSD: nchan.c,v 1.57 2006/08/03 03:34:42 deraadt Exp $ */
3c0ef626	2	/*
e9a17296	3	* Copyright (c) 1999, 2000, 2001, 2002 Markus Friedl. All rights reserved.
3c0ef626	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 "includes.h"
9108f8d9	27
	28	#include <sys/types.h>
	29	#include <sys/socket.h>
	30
	31	#include <errno.h>
	32	#include <string.h>
	33	#include <stdarg.h>
3c0ef626	34
	35	#include "ssh1.h"
	36	#include "ssh2.h"
	37	#include "buffer.h"
	38	#include "packet.h"
	39	#include "channels.h"
	40	#include "compat.h"
	41	#include "log.h"
	42
	43	/*
	44	* SSH Protocol 1.5 aka New Channel Protocol
	45	* Thanks to Martina, Axel and everyone who left Erlangen, leaving me bored.
	46	* Written by Markus Friedl in October 1999
	47	*
	48	* Protocol versions 1.3 and 1.5 differ in the handshake protocol used for the
	49	* tear down of channels:
	50	*
	51	* 1.3: strict request-ack-protocol:
c9f39d2c	52	* CLOSE ->
c9f39d2c	53	* <- CLOSE_CONFIRM
3c0ef626	54	*
3c0ef626	55	* 1.5: uses variations of:
c9f39d2c	56	* IEOF ->
	57	* <- OCLOSE
	58	* <- IEOF
	59	* OCLOSE ->
	60	* i.e. both sides have to close the channel
3c0ef626	61	*
	62	* 2.0: the EOF messages are optional
	63	*
	64	* See the debugging output from 'ssh -v' and 'sshd -d' of
	65	* ssh-1.2.27 as an example.
	66	*
	67	*/
	68
	69	/* functions manipulating channel states */
	70	/*
	71	* EVENTS update channel input/output states execute ACTIONS
	72	*/
3c0ef626	73	/*
	74	* ACTIONS: should never update the channel states
	75	*/
	76	static void chan_send_ieof1(Channel *);
	77	static void chan_send_oclose1(Channel *);
	78	static void chan_send_close2(Channel *);
	79	static void chan_send_eof2(Channel *);
	80
	81	/* helper */
	82	static void chan_shutdown_write(Channel *);
	83	static void chan_shutdown_read(Channel *);
	84
e9a17296	85	static char *ostates[] = { "open", "drain", "wait_ieof", "closed" };
	86	static char *istates[] = { "open", "drain", "wait_oclose", "closed" };
	87
	88	static void
	89	chan_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);
0fff78ff	93	debug2("channel %d: input %s -> %s", c->self, istates[c->istate],
e9a17296	94	istates[next]);
	95	c->istate = next;
	96	}
	97	static void
	98	chan_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);
0fff78ff	102	debug2("channel %d: output %s -> %s", c->self, ostates[c->ostate],
e9a17296	103	ostates[next]);
	104	c->ostate = next;
	105	}
	106
3c0ef626	107	/*
	108	* SSH1 specific implementation of event functions
	109	*/
	110
	111	static void
	112	chan_rcvd_oclose1(Channel *c)
	113	{
0fff78ff	114	debug2("channel %d: rcvd oclose", c->self);
3c0ef626	115	switch (c->istate) {
3c0ef626	116	case CHAN_INPUT_WAIT_OCLOSE:
e9a17296	117	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	118	break;
3c0ef626	119	case CHAN_INPUT_OPEN:
3c0ef626	120	chan_shutdown_read(c);
3c0ef626	121	chan_send_ieof1(c);
e9a17296	122	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	123	break;
	124	case CHAN_INPUT_WAIT_DRAIN:
	125	/* both local read_failed and remote write_failed */
3c0ef626	126	chan_send_ieof1(c);
e9a17296	127	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	128	break;
	129	default:
	130	error("channel %d: protocol error: rcvd_oclose for istate %d",
	131	c->self, c->istate);
	132	return;
	133	}
	134	}
e9a17296	135	void
e9a17296	136	chan_read_failed(Channel *c)
3c0ef626	137	{
0fff78ff	138	debug2("channel %d: read failed", c->self);
3c0ef626	139	switch (c->istate) {
3c0ef626	140	case CHAN_INPUT_OPEN:
3c0ef626	141	chan_shutdown_read(c);
e9a17296	142	chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN);
3c0ef626	143	break;
	144	default:
	145	error("channel %d: chan_read_failed for istate %d",
	146	c->self, c->istate);
	147	break;
	148	}
	149	}
e9a17296	150	void
e9a17296	151	chan_ibuf_empty(Channel *c)
3c0ef626	152	{
0fff78ff	153	debug2("channel %d: ibuf empty", c->self);
3c0ef626	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:
e9a17296	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	}
3c0ef626	169	break;
	170	default:
	171	error("channel %d: chan_ibuf_empty for istate %d",
	172	c->self, c->istate);
	173	break;
	174	}
	175	}
	176	static void
	177	chan_rcvd_ieof1(Channel *c)
	178	{
0fff78ff	179	debug2("channel %d: rcvd ieof", c->self);
3c0ef626	180	switch (c->ostate) {
3c0ef626	181	case CHAN_OUTPUT_OPEN:
e9a17296	182	chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
3c0ef626	183	break;
3c0ef626	184	case CHAN_OUTPUT_WAIT_IEOF:
e9a17296	185	chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
3c0ef626	186	break;
	187	default:
	188	error("channel %d: protocol error: rcvd_ieof for ostate %d",
	189	c->self, c->ostate);
	190	break;
	191	}
	192	}
	193	static void
	194	chan_write_failed1(Channel *c)
	195	{
0fff78ff	196	debug2("channel %d: write failed", c->self);
3c0ef626	197	switch (c->ostate) {
3c0ef626	198	case CHAN_OUTPUT_OPEN:
e9a17296	199	chan_shutdown_write(c);
3c0ef626	200	chan_send_oclose1(c);
e9a17296	201	chan_set_ostate(c, CHAN_OUTPUT_WAIT_IEOF);
3c0ef626	202	break;
3c0ef626	203	case CHAN_OUTPUT_WAIT_DRAIN:
e9a17296	204	chan_shutdown_write(c);
3c0ef626	205	chan_send_oclose1(c);
e9a17296	206	chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
3c0ef626	207	break;
	208	default:
	209	error("channel %d: chan_write_failed for ostate %d",
	210	c->self, c->ostate);
	211	break;
	212	}
	213	}
e9a17296	214	void
e9a17296	215	chan_obuf_empty(Channel *c)
3c0ef626	216	{
0fff78ff	217	debug2("channel %d: obuf empty", c->self);
3c0ef626	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:
e9a17296	225	chan_shutdown_write(c);
	226	if (!compat20)
	227	chan_send_oclose1(c);
	228	chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
3c0ef626	229	break;
	230	default:
	231	error("channel %d: internal error: obuf_empty for ostate %d",
	232	c->self, c->ostate);
	233	break;
	234	}
	235	}
	236	static void
	237	chan_send_ieof1(Channel *c)
	238	{
0fff78ff	239	debug2("channel %d: send ieof", c->self);
3c0ef626	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	}
	253	static void
	254	chan_send_oclose1(Channel *c)
	255	{
0fff78ff	256	debug2("channel %d: send oclose", c->self);
3c0ef626	257	switch (c->ostate) {
	258	case CHAN_OUTPUT_OPEN:
	259	case CHAN_OUTPUT_WAIT_DRAIN:
e9a17296	260	buffer_clear(&c->output);
3c0ef626	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",
e9a17296	267	c->self, c->ostate);
3c0ef626	268	break;
	269	}
	270	}
	271
	272	/*
	273	* the same for SSH2
	274	*/
	275	static void
e9a17296	276	chan_rcvd_close2(Channel *c)
3c0ef626	277	{
0fff78ff	278	debug2("channel %d: rcvd close", c->self);
3c0ef626	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 */
e9a17296	284	chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
e9a17296	285	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	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	*/
e9a17296	294	chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
3c0ef626	295	break;
	296	}
	297	switch (c->istate) {
	298	case CHAN_INPUT_OPEN:
3c0ef626	299	chan_shutdown_read(c);
e9a17296	300	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	301	break;
3c0ef626	302	case CHAN_INPUT_WAIT_DRAIN:
3c0ef626	303	chan_send_eof2(c);
e9a17296	304	chan_set_istate(c, CHAN_INPUT_CLOSED);
3c0ef626	305	break;
	306	}
	307	}
	308	static void
e9a17296	309	chan_rcvd_eof2(Channel *c)
3c0ef626	310	{
0fff78ff	311	debug2("channel %d: rcvd eof", c->self);
700318f3	312	c->flags \|= CHAN_EOF_RCVD;
e9a17296	313	if (c->ostate == CHAN_OUTPUT_OPEN)
e9a17296	314	chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
3c0ef626	315	}
	316	static void
	317	chan_write_failed2(Channel *c)
	318	{
0fff78ff	319	debug2("channel %d: write failed", c->self);
3c0ef626	320	switch (c->ostate) {
3c0ef626	321	case CHAN_OUTPUT_OPEN:
3c0ef626	322	case CHAN_OUTPUT_WAIT_DRAIN:
3c0ef626	323	chan_shutdown_write(c);
e9a17296	324	chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
3c0ef626	325	break;
	326	default:
	327	error("channel %d: chan_write_failed for ostate %d",
	328	c->self, c->ostate);
	329	break;
	330	}
	331	}
	332	static void
3c0ef626	333	chan_send_eof2(Channel *c)
3c0ef626	334	{
0fff78ff	335	debug2("channel %d: send eof", c->self);
3c0ef626	336	switch (c->istate) {
	337	case CHAN_INPUT_WAIT_DRAIN:
	338	packet_start(SSH2_MSG_CHANNEL_EOF);
	339	packet_put_int(c->remote_id);
	340	packet_send();
700318f3	341	c->flags \|= CHAN_EOF_SENT;
3c0ef626	342	break;
	343	default:
	344	error("channel %d: cannot send eof for istate %d",
	345	c->self, c->istate);
	346	break;
	347	}
	348	}
	349	static void
	350	chan_send_close2(Channel *c)
	351	{
0fff78ff	352	debug2("channel %d: send close", c->self);
3c0ef626	353	if (c->ostate != CHAN_OUTPUT_CLOSED \|\|
	354	c->istate != CHAN_INPUT_CLOSED) {
	355	error("channel %d: cannot send close for istate/ostate %d/%d",
	356	c->self, c->istate, c->ostate);
	357	} else if (c->flags & CHAN_CLOSE_SENT) {
	358	error("channel %d: already sent close", c->self);
	359	} else {
	360	packet_start(SSH2_MSG_CHANNEL_CLOSE);
	361	packet_put_int(c->remote_id);
	362	packet_send();
	363	c->flags \|= CHAN_CLOSE_SENT;
	364	}
	365	}
	366
	367	/* shared */
	368
e9a17296	369	void
	370	chan_rcvd_ieof(Channel *c)
	371	{
	372	if (compat20)
	373	chan_rcvd_eof2(c);
	374	else
	375	chan_rcvd_ieof1(c);
	376	if (c->ostate == CHAN_OUTPUT_WAIT_DRAIN &&
f5799ae1	377	buffer_len(&c->output) == 0 &&
700318f3	378	!CHANNEL_EFD_OUTPUT_ACTIVE(c))
e9a17296	379	chan_obuf_empty(c);
	380	}
	381	void
	382	chan_rcvd_oclose(Channel *c)
	383	{
	384	if (compat20)
	385	chan_rcvd_close2(c);
	386	else
	387	chan_rcvd_oclose1(c);
	388	}
	389	void
	390	chan_write_failed(Channel *c)
	391	{
	392	if (compat20)
	393	chan_write_failed2(c);
	394	else
	395	chan_write_failed1(c);
	396	}
	397
3c0ef626	398	void
	399	chan_mark_dead(Channel *c)
	400	{
	401	c->type = SSH_CHANNEL_ZOMBIE;
	402	}
	403
	404	int
c9f39d2c	405	chan_is_dead(Channel *c, int do_send)
3c0ef626	406	{
3c0ef626	407	if (c->type == SSH_CHANNEL_ZOMBIE) {
0fff78ff	408	debug2("channel %d: zombie", c->self);
3c0ef626	409	return 1;
	410	}
	411	if (c->istate != CHAN_INPUT_CLOSED \|\| c->ostate != CHAN_OUTPUT_CLOSED)
	412	return 0;
	413	if (!compat20) {
0fff78ff	414	debug2("channel %d: is dead", c->self);
3c0ef626	415	return 1;
3c0ef626	416	}
700318f3	417	if ((datafellows & SSH_BUG_EXTEOF) &&
	418	c->extended_usage == CHAN_EXTENDED_WRITE &&
	419	c->efd != -1 &&
	420	buffer_len(&c->extended) > 0) {
f5799ae1	421	debug2("channel %d: active efd: %d len %d",
f5799ae1	422	c->self, c->efd, buffer_len(&c->extended));
700318f3	423	return 0;
	424	}
	425	if (!(c->flags & CHAN_CLOSE_SENT)) {
c9f39d2c	426	if (do_send) {
700318f3	427	chan_send_close2(c);
	428	} else {
	429	/* channel would be dead if we sent a close */
	430	if (c->flags & CHAN_CLOSE_RCVD) {
0fff78ff	431	debug2("channel %d: almost dead",
700318f3	432	c->self);
700318f3	433	return 1;
3c0ef626	434	}
3c0ef626	435	}
700318f3	436	}
	437	if ((c->flags & CHAN_CLOSE_SENT) &&
	438	(c->flags & CHAN_CLOSE_RCVD)) {
0fff78ff	439	debug2("channel %d: is dead", c->self);
700318f3	440	return 1;
3c0ef626	441	}
	442	return 0;
	443	}
	444
3c0ef626	445	/* helper */
	446	static void
	447	chan_shutdown_write(Channel *c)
	448	{
e9a17296	449	buffer_clear(&c->output);
3c0ef626	450	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
	451	return;
	452	/* shutdown failure is allowed if write failed already */
0fff78ff	453	debug2("channel %d: close_write", c->self);
3c0ef626	454	if (c->sock != -1) {
3c0ef626	455	if (shutdown(c->sock, SHUT_WR) < 0)
0fff78ff	456	debug2("channel %d: chan_shutdown_write: "
3c0ef626	457	"shutdown() failed for fd%d: %.100s",
	458	c->self, c->sock, strerror(errno));
	459	} else {
	460	if (channel_close_fd(&c->wfd) < 0)
0fff78ff	461	logit("channel %d: chan_shutdown_write: "
3c0ef626	462	"close() failed for fd%d: %.100s",
	463	c->self, c->wfd, strerror(errno));
	464	}
	465	}
	466	static void
	467	chan_shutdown_read(Channel *c)
	468	{
	469	if (compat20 && c->type == SSH_CHANNEL_LARVAL)
	470	return;
0fff78ff	471	debug2("channel %d: close_read", c->self);
3c0ef626	472	if (c->sock != -1) {
	473	/*
	474	* shutdown(sock, SHUT_READ) may return ENOTCONN if the
	475	* write side has been closed already. (bug on Linux)
	476	* HP-UX may return ENOTCONN also.
	477	*/
	478	if (shutdown(c->sock, SHUT_RD) < 0
	479	&& errno != ENOTCONN)
	480	error("channel %d: chan_shutdown_read: "
	481	"shutdown() failed for fd%d [i%d o%d]: %.100s",
	482	c->self, c->sock, c->istate, c->ostate,
	483	strerror(errno));
	484	} else {
	485	if (channel_close_fd(&c->rfd) < 0)
0fff78ff	486	logit("channel %d: chan_shutdown_read: "
3c0ef626	487	"close() failed for fd%d: %.100s",
	488	c->self, c->rfd, strerror(errno));
	489	}
	490	}