1 /* $OpenBSD: nchan.c,v 1.62 2008/11/07 18:50:18 stevesk Exp $ */
3 * Copyright (c) 1999, 2000, 2001, 2002 Markus Friedl. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
28 #include <sys/types.h>
29 #include <sys/socket.h>
35 #include "openbsd-compat/sys-queue.h"
45 * SSH Protocol 1.5 aka New Channel Protocol
46 * Thanks to Martina, Axel and everyone who left Erlangen, leaving me bored.
47 * Written by Markus Friedl in October 1999
49 * Protocol versions 1.3 and 1.5 differ in the handshake protocol used for the
50 * tear down of channels:
52 * 1.3: strict request-ack-protocol:
56 * 1.5: uses variations of:
61 * i.e. both sides have to close the channel
63 * 2.0: the EOF messages are optional
65 * See the debugging output from 'ssh -v' and 'sshd -d' of
66 * ssh-1.2.27 as an example.
70 /* functions manipulating channel states */
72 * EVENTS update channel input/output states execute ACTIONS
75 * ACTIONS: should never update the channel states
77 static void chan_send_ieof1(Channel *);
78 static void chan_send_oclose1(Channel *);
79 static void chan_send_close2(Channel *);
80 static void chan_send_eof2(Channel *);
81 static void chan_send_eow2(Channel *);
84 static void chan_shutdown_write(Channel *);
85 static void chan_shutdown_read(Channel *);
87 static char *ostates[] = { "open", "drain", "wait_ieof", "closed" };
88 static char *istates[] = { "open", "drain", "wait_oclose", "closed" };
91 chan_set_istate(Channel *c, u_int next)
93 if (c->istate > CHAN_INPUT_CLOSED || next > CHAN_INPUT_CLOSED)
94 fatal("chan_set_istate: bad state %d -> %d", c->istate, next);
95 debug2("channel %d: input %s -> %s", c->self, istates[c->istate],
100 chan_set_ostate(Channel *c, u_int next)
102 if (c->ostate > CHAN_OUTPUT_CLOSED || next > CHAN_OUTPUT_CLOSED)
103 fatal("chan_set_ostate: bad state %d -> %d", c->ostate, next);
104 debug2("channel %d: output %s -> %s", c->self, ostates[c->ostate],
110 * SSH1 specific implementation of event functions
114 chan_rcvd_oclose1(Channel *c)
116 debug2("channel %d: rcvd oclose", c->self);
118 case CHAN_INPUT_WAIT_OCLOSE:
119 chan_set_istate(c, CHAN_INPUT_CLOSED);
121 case CHAN_INPUT_OPEN:
122 chan_shutdown_read(c);
124 chan_set_istate(c, CHAN_INPUT_CLOSED);
126 case CHAN_INPUT_WAIT_DRAIN:
127 /* both local read_failed and remote write_failed */
129 chan_set_istate(c, CHAN_INPUT_CLOSED);
132 error("channel %d: protocol error: rcvd_oclose for istate %d",
138 chan_read_failed(Channel *c)
140 debug2("channel %d: read failed", c->self);
142 case CHAN_INPUT_OPEN:
143 chan_shutdown_read(c);
144 chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN);
147 error("channel %d: chan_read_failed for istate %d",
153 chan_ibuf_empty(Channel *c)
155 debug2("channel %d: ibuf empty", c->self);
156 if (buffer_len(&c->input)) {
157 error("channel %d: chan_ibuf_empty for non empty buffer",
162 case CHAN_INPUT_WAIT_DRAIN:
164 if (!(c->flags & CHAN_CLOSE_SENT))
166 chan_set_istate(c, CHAN_INPUT_CLOSED);
169 chan_set_istate(c, CHAN_INPUT_WAIT_OCLOSE);
173 error("channel %d: chan_ibuf_empty for istate %d",
179 chan_rcvd_ieof1(Channel *c)
181 debug2("channel %d: rcvd ieof", c->self);
183 case CHAN_OUTPUT_OPEN:
184 chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
186 case CHAN_OUTPUT_WAIT_IEOF:
187 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
190 error("channel %d: protocol error: rcvd_ieof for ostate %d",
196 chan_write_failed1(Channel *c)
198 debug2("channel %d: write failed", c->self);
200 case CHAN_OUTPUT_OPEN:
201 chan_shutdown_write(c);
202 chan_send_oclose1(c);
203 chan_set_ostate(c, CHAN_OUTPUT_WAIT_IEOF);
205 case CHAN_OUTPUT_WAIT_DRAIN:
206 chan_shutdown_write(c);
207 chan_send_oclose1(c);
208 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
211 error("channel %d: chan_write_failed for ostate %d",
217 chan_obuf_empty(Channel *c)
219 debug2("channel %d: obuf empty", c->self);
220 if (buffer_len(&c->output)) {
221 error("channel %d: chan_obuf_empty for non empty buffer",
226 case CHAN_OUTPUT_WAIT_DRAIN:
227 chan_shutdown_write(c);
229 chan_send_oclose1(c);
230 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
233 error("channel %d: internal error: obuf_empty for ostate %d",
239 chan_send_ieof1(Channel *c)
241 debug2("channel %d: send ieof", c->self);
243 case CHAN_INPUT_OPEN:
244 case CHAN_INPUT_WAIT_DRAIN:
245 packet_start(SSH_MSG_CHANNEL_INPUT_EOF);
246 packet_put_int(c->remote_id);
250 error("channel %d: cannot send ieof for istate %d",
256 chan_send_oclose1(Channel *c)
258 debug2("channel %d: send oclose", c->self);
260 case CHAN_OUTPUT_OPEN:
261 case CHAN_OUTPUT_WAIT_DRAIN:
262 buffer_clear(&c->output);
263 packet_start(SSH_MSG_CHANNEL_OUTPUT_CLOSE);
264 packet_put_int(c->remote_id);
268 error("channel %d: cannot send oclose for ostate %d",
278 chan_rcvd_close2(Channel *c)
280 debug2("channel %d: rcvd close", c->self);
281 if (c->flags & CHAN_CLOSE_RCVD)
282 error("channel %d: protocol error: close rcvd twice", c->self);
283 c->flags |= CHAN_CLOSE_RCVD;
284 if (c->type == SSH_CHANNEL_LARVAL) {
285 /* tear down larval channels immediately */
286 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
287 chan_set_istate(c, CHAN_INPUT_CLOSED);
291 case CHAN_OUTPUT_OPEN:
293 * wait until a data from the channel is consumed if a CLOSE
296 chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
300 case CHAN_INPUT_OPEN:
301 chan_shutdown_read(c);
302 chan_set_istate(c, CHAN_INPUT_CLOSED);
304 case CHAN_INPUT_WAIT_DRAIN:
306 chan_set_istate(c, CHAN_INPUT_CLOSED);
311 chan_rcvd_eow(Channel *c)
313 debug2("channel %d: rcvd eow", c->self);
315 case CHAN_INPUT_OPEN:
316 chan_shutdown_read(c);
317 chan_set_istate(c, CHAN_INPUT_CLOSED);
322 chan_rcvd_eof2(Channel *c)
324 debug2("channel %d: rcvd eof", c->self);
325 c->flags |= CHAN_EOF_RCVD;
326 if (c->ostate == CHAN_OUTPUT_OPEN)
327 chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN);
330 chan_write_failed2(Channel *c)
332 debug2("channel %d: write failed", c->self);
334 case CHAN_OUTPUT_OPEN:
335 case CHAN_OUTPUT_WAIT_DRAIN:
336 chan_shutdown_write(c);
337 if (strcmp(c->ctype, "session") == 0)
339 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
342 error("channel %d: chan_write_failed for ostate %d",
348 chan_send_eof2(Channel *c)
350 debug2("channel %d: send eof", c->self);
352 case CHAN_INPUT_WAIT_DRAIN:
353 packet_start(SSH2_MSG_CHANNEL_EOF);
354 packet_put_int(c->remote_id);
356 c->flags |= CHAN_EOF_SENT;
359 error("channel %d: cannot send eof for istate %d",
365 chan_send_close2(Channel *c)
367 debug2("channel %d: send close", c->self);
368 if (c->ostate != CHAN_OUTPUT_CLOSED ||
369 c->istate != CHAN_INPUT_CLOSED) {
370 error("channel %d: cannot send close for istate/ostate %d/%d",
371 c->self, c->istate, c->ostate);
372 } else if (c->flags & CHAN_CLOSE_SENT) {
373 error("channel %d: already sent close", c->self);
375 packet_start(SSH2_MSG_CHANNEL_CLOSE);
376 packet_put_int(c->remote_id);
378 c->flags |= CHAN_CLOSE_SENT;
382 chan_send_eow2(Channel *c)
384 debug2("channel %d: send eow", c->self);
385 if (c->ostate == CHAN_OUTPUT_CLOSED) {
386 error("channel %d: must not sent eow on closed output",
390 if (!(datafellows & SSH_NEW_OPENSSH))
392 packet_start(SSH2_MSG_CHANNEL_REQUEST);
393 packet_put_int(c->remote_id);
394 packet_put_cstring("eow@openssh.com");
402 chan_rcvd_ieof(Channel *c)
408 if (c->ostate == CHAN_OUTPUT_WAIT_DRAIN &&
409 buffer_len(&c->output) == 0 &&
410 !CHANNEL_EFD_OUTPUT_ACTIVE(c))
414 chan_rcvd_oclose(Channel *c)
419 chan_rcvd_oclose1(c);
422 chan_write_failed(Channel *c)
425 chan_write_failed2(c);
427 chan_write_failed1(c);
431 chan_mark_dead(Channel *c)
433 c->type = SSH_CHANNEL_ZOMBIE;
437 chan_is_dead(Channel *c, int do_send)
439 if (c->type == SSH_CHANNEL_ZOMBIE) {
440 debug2("channel %d: zombie", c->self);
443 if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED)
446 debug2("channel %d: is dead", c->self);
449 if ((datafellows & SSH_BUG_EXTEOF) &&
450 c->extended_usage == CHAN_EXTENDED_WRITE &&
452 buffer_len(&c->extended) > 0) {
453 debug2("channel %d: active efd: %d len %d",
454 c->self, c->efd, buffer_len(&c->extended));
457 if (!(c->flags & CHAN_CLOSE_SENT)) {
461 /* channel would be dead if we sent a close */
462 if (c->flags & CHAN_CLOSE_RCVD) {
463 debug2("channel %d: almost dead",
469 if ((c->flags & CHAN_CLOSE_SENT) &&
470 (c->flags & CHAN_CLOSE_RCVD)) {
471 debug2("channel %d: is dead", c->self);
479 chan_shutdown_write(Channel *c)
481 buffer_clear(&c->output);
482 if (compat20 && c->type == SSH_CHANNEL_LARVAL)
484 /* shutdown failure is allowed if write failed already */
485 debug2("channel %d: close_write", c->self);
487 if (shutdown(c->sock, SHUT_WR) < 0)
488 debug2("channel %d: chan_shutdown_write: "
489 "shutdown() failed for fd %d: %.100s",
490 c->self, c->sock, strerror(errno));
492 if (channel_close_fd(&c->wfd) < 0)
493 logit("channel %d: chan_shutdown_write: "
494 "close() failed for fd %d: %.100s",
495 c->self, c->wfd, strerror(errno));
499 chan_shutdown_read(Channel *c)
501 if (compat20 && c->type == SSH_CHANNEL_LARVAL)
503 debug2("channel %d: close_read", c->self);
506 * shutdown(sock, SHUT_READ) may return ENOTCONN if the
507 * write side has been closed already. (bug on Linux)
508 * HP-UX may return ENOTCONN also.
510 if (shutdown(c->sock, SHUT_RD) < 0
511 && errno != ENOTCONN)
512 error("channel %d: chan_shutdown_read: "
513 "shutdown() failed for fd %d [i%d o%d]: %.100s",
514 c->self, c->sock, c->istate, c->ostate,
517 if (channel_close_fd(&c->rfd) < 0)
518 logit("channel %d: chan_shutdown_read: "
519 "close() failed for fd %d: %.100s",
520 c->self, c->rfd, strerror(errno));