version 1.19.2.4, 2001/05/07 21:09:31 |
version 1.19.2.5, 2001/09/27 00:15:42 |
|
|
/* |
/* |
* Copyright (c) 1999 Markus Friedl. All rights reserved. |
* Copyright (c) 1999, 2000, 2001 Markus Friedl. All rights reserved. |
* |
* |
* Redistribution and use in source and binary forms, with or without |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* modification, are permitted provided that the following conditions |
|
|
#include "buffer.h" |
#include "buffer.h" |
#include "packet.h" |
#include "packet.h" |
#include "channels.h" |
#include "channels.h" |
#include "nchan.h" |
|
#include "compat.h" |
#include "compat.h" |
#include "log.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 */ |
/* functions manipulating channel states */ |
/* |
/* |
* EVENTS update channel input/output states execute ACTIONS |
* EVENTS update channel input/output states execute ACTIONS |
|
|
/* |
/* |
* ACTIONS: should never update the channel states |
* ACTIONS: should never update the channel states |
*/ |
*/ |
static void chan_send_ieof1(Channel *c); |
static void chan_send_ieof1(Channel *); |
static void chan_send_oclose1(Channel *c); |
static void chan_send_oclose1(Channel *); |
static void chan_send_close2(Channel *c); |
static void chan_send_close2(Channel *); |
static void chan_send_eof2(Channel *c); |
static void chan_send_eof2(Channel *); |
|
|
/* helper */ |
/* helper */ |
static void chan_shutdown_write(Channel *c); |
static void chan_shutdown_write(Channel *); |
static void chan_shutdown_read(Channel *c); |
static void chan_shutdown_read(Channel *); |
|
|
/* |
/* |
* SSH1 specific implementation of event functions |
* SSH1 specific implementation of event functions |
|
|
c->istate = CHAN_INPUT_CLOSED; |
c->istate = CHAN_INPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: protocol error: chan_rcvd_oclose for istate %d", |
error("channel %d: protocol error: rcvd_oclose for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
return; |
return; |
} |
} |
|
|
debug("channel %d: input open -> drain", c->self); |
debug("channel %d: input open -> drain", c->self); |
chan_shutdown_read(c); |
chan_shutdown_read(c); |
c->istate = CHAN_INPUT_WAIT_DRAIN; |
c->istate = CHAN_INPUT_WAIT_DRAIN; |
|
#if 0 |
if (buffer_len(&c->input) == 0) { |
if (buffer_len(&c->input) == 0) { |
debug("channel %d: input: no drain shortcut", c->self); |
debug("channel %d: input: no drain shortcut", c->self); |
chan_ibuf_empty(c); |
chan_ibuf_empty(c); |
} |
} |
|
#endif |
break; |
break; |
default: |
default: |
error("channel %d: internal error: we do not read, but chan_read_failed for istate %d", |
error("channel %d: chan_read_failed for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
break; |
break; |
} |
} |
|
|
{ |
{ |
debug("channel %d: ibuf empty", c->self); |
debug("channel %d: ibuf empty", c->self); |
if (buffer_len(&c->input)) { |
if (buffer_len(&c->input)) { |
error("channel %d: internal error: chan_ibuf_empty for non empty buffer", |
error("channel %d: chan_ibuf_empty for non empty buffer", |
c->self); |
c->self); |
return; |
return; |
} |
} |
|
|
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_ibuf_empty for istate %d", |
error("channel %d: chan_ibuf_empty for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
break; |
break; |
} |
} |
|
|
if (c->type != SSH_CHANNEL_OPEN) { |
if (c->type != SSH_CHANNEL_OPEN) { |
debug("channel %d: non-open", c->self); |
debug("channel %d: non-open", c->self); |
if (c->istate == CHAN_INPUT_OPEN) { |
if (c->istate == CHAN_INPUT_OPEN) { |
debug("channel %d: non-open: input open -> wait_oclose", c->self); |
debug("channel %d: non-open: input open -> wait_oclose", |
|
c->self); |
chan_shutdown_read(c); |
chan_shutdown_read(c); |
chan_send_ieof1(c); |
chan_send_ieof1(c); |
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
} else { |
} else { |
error("channel %d: istate %d != open", c->self, c->istate); |
error("channel %d: non-open: istate %d != open", |
|
c->self, c->istate); |
} |
} |
if (c->ostate == CHAN_OUTPUT_OPEN) { |
if (c->ostate == CHAN_OUTPUT_OPEN) { |
debug("channel %d: non-open: output open -> closed", c->self); |
debug("channel %d: non-open: output open -> closed", |
|
c->self); |
chan_send_oclose1(c); |
chan_send_oclose1(c); |
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
} else { |
} else { |
error("channel %d: ostate %d != open", c->self, c->ostate); |
error("channel %d: non-open: ostate %d != open", |
|
c->self, c->ostate); |
} |
} |
return; |
return; |
} |
} |
|
|
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: protocol error: chan_rcvd_ieof for ostate %d", |
error("channel %d: protocol error: rcvd_ieof for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_write_failed for ostate %d", |
error("channel %d: chan_write_failed for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
{ |
{ |
debug("channel %d: obuf empty", c->self); |
debug("channel %d: obuf empty", c->self); |
if (buffer_len(&c->output)) { |
if (buffer_len(&c->output)) { |
error("channel %d: internal error: chan_obuf_empty for non empty buffer", |
error("channel %d: chan_obuf_empty for non empty buffer", |
c->self); |
c->self); |
return; |
return; |
} |
} |
|
|
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_obuf_empty for ostate %d", |
error("channel %d: internal error: obuf_empty for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
packet_send(); |
packet_send(); |
break; |
break; |
default: |
default: |
error("channel %d: internal error: cannot send ieof for istate %d", |
error("channel %d: cannot send ieof for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
break; |
break; |
} |
} |
|
|
packet_send(); |
packet_send(); |
break; |
break; |
default: |
default: |
error("channel %d: internal error: cannot send oclose for ostate %d", |
error("channel %d: cannot send oclose for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
} |
} |
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_OPEN: |
/* wait until a data from the channel is consumed if a CLOSE is received */ |
/* |
|
* wait until a data from the channel is consumed if a CLOSE |
|
* is received |
|
*/ |
debug("channel %d: output open -> drain", c->self); |
debug("channel %d: output open -> drain", c->self); |
c->ostate = CHAN_OUTPUT_WAIT_DRAIN; |
c->ostate = CHAN_OUTPUT_WAIT_DRAIN; |
break; |
break; |
|
|
{ |
{ |
debug("channel %d: ibuf empty", c->self); |
debug("channel %d: ibuf empty", c->self); |
if (buffer_len(&c->input)) { |
if (buffer_len(&c->input)) { |
error("channel %d: internal error: chan_ibuf_empty for non empty buffer", |
error("channel %d: chan_ibuf_empty for non empty buffer", |
c->self); |
c->self); |
return; |
return; |
} |
} |
|
|
c->istate = CHAN_INPUT_CLOSED; |
c->istate = CHAN_INPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_ibuf_empty for istate %d", |
error("channel %d: chan_ibuf_empty for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
break; |
break; |
} |
} |
|
|
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_write_failed for ostate %d", |
error("channel %d: chan_write_failed for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
{ |
{ |
debug("channel %d: obuf empty", c->self); |
debug("channel %d: obuf empty", c->self); |
if (buffer_len(&c->output)) { |
if (buffer_len(&c->output)) { |
error("internal error: chan_obuf_empty %d for non empty buffer", |
error("channel %d: chan_obuf_empty for non empty buffer", |
c->self); |
c->self); |
return; |
return; |
} |
} |
|
|
c->ostate = CHAN_OUTPUT_CLOSED; |
c->ostate = CHAN_OUTPUT_CLOSED; |
break; |
break; |
default: |
default: |
error("channel %d: internal error: chan_obuf_empty for ostate %d", |
error("channel %d: chan_obuf_empty for ostate %d", |
c->self, c->ostate); |
c->self, c->ostate); |
break; |
break; |
} |
} |
|
|
packet_send(); |
packet_send(); |
break; |
break; |
default: |
default: |
error("channel %d: internal error: cannot send eof for istate %d", |
error("channel %d: cannot send eof for istate %d", |
c->self, c->istate); |
c->self, c->istate); |
break; |
break; |
} |
} |
|
|
debug("channel %d: send close", c->self); |
debug("channel %d: send close", c->self); |
if (c->ostate != CHAN_OUTPUT_CLOSED || |
if (c->ostate != CHAN_OUTPUT_CLOSED || |
c->istate != CHAN_INPUT_CLOSED) { |
c->istate != CHAN_INPUT_CLOSED) { |
error("channel %d: internal error: cannot send close for istate/ostate %d/%d", |
error("channel %d: cannot send close for istate/ostate %d/%d", |
c->self, c->istate, c->ostate); |
c->self, c->istate, c->ostate); |
} else if (c->flags & CHAN_CLOSE_SENT) { |
} else if (c->flags & CHAN_CLOSE_SENT) { |
error("channel %d: internal error: already sent close", c->self); |
error("channel %d: already sent close", c->self); |
} else { |
} else { |
packet_start(SSH2_MSG_CHANNEL_CLOSE); |
packet_start(SSH2_MSG_CHANNEL_CLOSE); |
packet_put_int(c->remote_id); |
packet_put_int(c->remote_id); |
|
|
|
|
/* shared */ |
/* shared */ |
|
|
|
void |
|
chan_mark_dead(Channel *c) |
|
{ |
|
c->type = SSH_CHANNEL_ZOMBIE; |
|
} |
|
|
int |
int |
chan_is_dead(Channel *c) |
chan_is_dead(Channel *c) |
{ |
{ |
|
if (c->type == SSH_CHANNEL_ZOMBIE) { |
|
debug("channel %d: zombie", c->self); |
|
return 1; |
|
} |
if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED) |
if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED) |
return 0; |
return 0; |
if (!compat20) { |
if (!compat20) { |
|
|
debug("channel %d: close_write", c->self); |
debug("channel %d: close_write", c->self); |
if (c->sock != -1) { |
if (c->sock != -1) { |
if (shutdown(c->sock, SHUT_WR) < 0) |
if (shutdown(c->sock, SHUT_WR) < 0) |
debug("channel %d: chan_shutdown_write: shutdown() failed for fd%d: %.100s", |
debug("channel %d: chan_shutdown_write: " |
|
"shutdown() failed for fd%d: %.100s", |
c->self, c->sock, strerror(errno)); |
c->self, c->sock, strerror(errno)); |
} else { |
} else { |
if (close(c->wfd) < 0) |
if (channel_close_fd(&c->wfd) < 0) |
log("channel %d: chan_shutdown_write: close() failed for fd%d: %.100s", |
log("channel %d: chan_shutdown_write: " |
|
"close() failed for fd%d: %.100s", |
c->self, c->wfd, strerror(errno)); |
c->self, c->wfd, strerror(errno)); |
c->wfd = -1; |
|
} |
} |
} |
} |
static void |
static void |
|
|
debug("channel %d: close_read", c->self); |
debug("channel %d: close_read", c->self); |
if (c->sock != -1) { |
if (c->sock != -1) { |
if (shutdown(c->sock, SHUT_RD) < 0) |
if (shutdown(c->sock, SHUT_RD) < 0) |
error("channel %d: chan_shutdown_read: shutdown() failed for fd%d [i%d o%d]: %.100s", |
error("channel %d: chan_shutdown_read: " |
c->self, c->sock, c->istate, c->ostate, strerror(errno)); |
"shutdown() failed for fd%d [i%d o%d]: %.100s", |
|
c->self, c->sock, c->istate, c->ostate, |
|
strerror(errno)); |
} else { |
} else { |
if (close(c->rfd) < 0) |
if (channel_close_fd(&c->rfd) < 0) |
log("channel %d: chan_shutdown_read: close() failed for fd%d: %.100s", |
log("channel %d: chan_shutdown_read: " |
|
"close() failed for fd%d: %.100s", |
c->self, c->rfd, strerror(errno)); |
c->self, c->rfd, strerror(errno)); |
c->rfd = -1; |
|
} |
} |
} |
} |