version 1.32, 2001/10/10 22:18:47 |
version 1.32.2.3, 2002/06/22 07:23:17 |
|
|
/* |
/* |
* Copyright (c) 1999, 2000, 2001 Markus Friedl. All rights reserved. |
* Copyright (c) 1999, 2000, 2001, 2002 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 |
|
|
/* |
/* |
* EVENTS update channel input/output states execute ACTIONS |
* EVENTS update channel input/output states execute ACTIONS |
*/ |
*/ |
/* events concerning the INPUT from socket for channel (istate) */ |
|
chan_event_fn *chan_rcvd_oclose = NULL; |
|
chan_event_fn *chan_read_failed = NULL; |
|
chan_event_fn *chan_ibuf_empty = NULL; |
|
/* events concerning the OUTPUT from channel for socket (ostate) */ |
|
chan_event_fn *chan_rcvd_ieof = NULL; |
|
chan_event_fn *chan_write_failed = NULL; |
|
chan_event_fn *chan_obuf_empty = NULL; |
|
/* |
/* |
* ACTIONS: should never update the channel states |
* ACTIONS: should never update the channel states |
*/ |
*/ |
|
|
static void chan_shutdown_write(Channel *); |
static void chan_shutdown_write(Channel *); |
static void chan_shutdown_read(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); |
|
debug("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); |
|
debug("channel %d: output %s -> %s", c->self, ostates[c->ostate], |
|
ostates[next]); |
|
c->ostate = next; |
|
} |
|
|
/* |
/* |
* SSH1 specific implementation of event functions |
* SSH1 specific implementation of event functions |
*/ |
*/ |
|
|
debug("channel %d: rcvd oclose", c->self); |
debug("channel %d: rcvd oclose", c->self); |
switch (c->istate) { |
switch (c->istate) { |
case CHAN_INPUT_WAIT_OCLOSE: |
case CHAN_INPUT_WAIT_OCLOSE: |
debug("channel %d: input wait_oclose -> closed", c->self); |
chan_set_istate(c, CHAN_INPUT_CLOSED); |
c->istate = CHAN_INPUT_CLOSED; |
|
break; |
break; |
case CHAN_INPUT_OPEN: |
case CHAN_INPUT_OPEN: |
debug("channel %d: input open -> closed", c->self); |
|
chan_shutdown_read(c); |
chan_shutdown_read(c); |
chan_send_ieof1(c); |
chan_send_ieof1(c); |
c->istate = CHAN_INPUT_CLOSED; |
chan_set_istate(c, CHAN_INPUT_CLOSED); |
break; |
break; |
case CHAN_INPUT_WAIT_DRAIN: |
case CHAN_INPUT_WAIT_DRAIN: |
/* both local read_failed and remote write_failed */ |
/* both local read_failed and remote write_failed */ |
log("channel %d: input drain -> closed", c->self); |
|
chan_send_ieof1(c); |
chan_send_ieof1(c); |
c->istate = CHAN_INPUT_CLOSED; |
chan_set_istate(c, CHAN_INPUT_CLOSED); |
break; |
break; |
default: |
default: |
error("channel %d: protocol error: rcvd_oclose for istate %d", |
error("channel %d: protocol error: rcvd_oclose for istate %d", |
|
|
return; |
return; |
} |
} |
} |
} |
static void |
void |
chan_read_failed_12(Channel *c) |
chan_read_failed(Channel *c) |
{ |
{ |
debug("channel %d: read failed", c->self); |
debug("channel %d: read failed", c->self); |
switch (c->istate) { |
switch (c->istate) { |
case CHAN_INPUT_OPEN: |
case CHAN_INPUT_OPEN: |
debug("channel %d: input open -> drain", c->self); |
|
chan_shutdown_read(c); |
chan_shutdown_read(c); |
c->istate = CHAN_INPUT_WAIT_DRAIN; |
chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN); |
#if 0 |
|
if (buffer_len(&c->input) == 0) { |
|
debug("channel %d: input: no drain shortcut", c->self); |
|
chan_ibuf_empty(c); |
|
} |
|
#endif |
|
break; |
break; |
default: |
default: |
error("channel %d: chan_read_failed for istate %d", |
error("channel %d: chan_read_failed for istate %d", |
|
|
break; |
break; |
} |
} |
} |
} |
static void |
void |
chan_ibuf_empty1(Channel *c) |
chan_ibuf_empty(Channel *c) |
{ |
{ |
debug("channel %d: ibuf empty", c->self); |
debug("channel %d: ibuf empty", c->self); |
if (buffer_len(&c->input)) { |
if (buffer_len(&c->input)) { |
|
|
} |
} |
switch (c->istate) { |
switch (c->istate) { |
case CHAN_INPUT_WAIT_DRAIN: |
case CHAN_INPUT_WAIT_DRAIN: |
debug("channel %d: input drain -> wait_oclose", c->self); |
if (compat20) { |
chan_send_ieof1(c); |
if (!(c->flags & CHAN_CLOSE_SENT)) |
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
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; |
break; |
default: |
default: |
error("channel %d: chan_ibuf_empty for istate %d", |
error("channel %d: chan_ibuf_empty for istate %d", |
|
|
chan_rcvd_ieof1(Channel *c) |
chan_rcvd_ieof1(Channel *c) |
{ |
{ |
debug("channel %d: rcvd ieof", c->self); |
debug("channel %d: rcvd ieof", c->self); |
if (c->type != SSH_CHANNEL_OPEN) { |
|
debug("channel %d: non-open", c->self); |
|
if (c->istate == CHAN_INPUT_OPEN) { |
|
debug("channel %d: non-open: input open -> wait_oclose", |
|
c->self); |
|
chan_shutdown_read(c); |
|
chan_send_ieof1(c); |
|
c->istate = CHAN_INPUT_WAIT_OCLOSE; |
|
} else { |
|
error("channel %d: non-open: istate %d != open", |
|
c->self, c->istate); |
|
} |
|
if (c->ostate == CHAN_OUTPUT_OPEN) { |
|
debug("channel %d: non-open: output open -> closed", |
|
c->self); |
|
chan_send_oclose1(c); |
|
c->ostate = CHAN_OUTPUT_CLOSED; |
|
} else { |
|
error("channel %d: non-open: ostate %d != open", |
|
c->self, c->ostate); |
|
} |
|
return; |
|
} |
|
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_OPEN: |
debug("channel %d: output open -> drain", c->self); |
chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN); |
c->ostate = CHAN_OUTPUT_WAIT_DRAIN; |
|
break; |
break; |
case CHAN_OUTPUT_WAIT_IEOF: |
case CHAN_OUTPUT_WAIT_IEOF: |
debug("channel %d: output wait_ieof -> closed", c->self); |
chan_set_ostate(c, CHAN_OUTPUT_CLOSED); |
c->ostate = CHAN_OUTPUT_CLOSED; |
|
break; |
break; |
default: |
default: |
error("channel %d: protocol error: rcvd_ieof for ostate %d", |
error("channel %d: protocol error: rcvd_ieof for ostate %d", |
|
|
debug("channel %d: write failed", c->self); |
debug("channel %d: write failed", c->self); |
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_OPEN: |
debug("channel %d: output open -> wait_ieof", c->self); |
chan_shutdown_write(c); |
chan_send_oclose1(c); |
chan_send_oclose1(c); |
c->ostate = CHAN_OUTPUT_WAIT_IEOF; |
chan_set_ostate(c, CHAN_OUTPUT_WAIT_IEOF); |
break; |
break; |
case CHAN_OUTPUT_WAIT_DRAIN: |
case CHAN_OUTPUT_WAIT_DRAIN: |
debug("channel %d: output wait_drain -> closed", c->self); |
chan_shutdown_write(c); |
chan_send_oclose1(c); |
chan_send_oclose1(c); |
c->ostate = CHAN_OUTPUT_CLOSED; |
chan_set_ostate(c, CHAN_OUTPUT_CLOSED); |
break; |
break; |
default: |
default: |
error("channel %d: chan_write_failed for ostate %d", |
error("channel %d: chan_write_failed for ostate %d", |
|
|
break; |
break; |
} |
} |
} |
} |
static void |
void |
chan_obuf_empty1(Channel *c) |
chan_obuf_empty(Channel *c) |
{ |
{ |
debug("channel %d: obuf empty", c->self); |
debug("channel %d: obuf empty", c->self); |
if (buffer_len(&c->output)) { |
if (buffer_len(&c->output)) { |
|
|
} |
} |
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_WAIT_DRAIN: |
case CHAN_OUTPUT_WAIT_DRAIN: |
debug("channel %d: output drain -> closed", c->self); |
chan_shutdown_write(c); |
chan_send_oclose1(c); |
if (!compat20) |
c->ostate = CHAN_OUTPUT_CLOSED; |
chan_send_oclose1(c); |
|
chan_set_ostate(c, CHAN_OUTPUT_CLOSED); |
break; |
break; |
default: |
default: |
error("channel %d: internal error: obuf_empty for ostate %d", |
error("channel %d: internal error: obuf_empty for ostate %d", |
|
|
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_WAIT_DRAIN: |
case CHAN_OUTPUT_WAIT_DRAIN: |
chan_shutdown_write(c); |
buffer_clear(&c->output); |
buffer_consume(&c->output, buffer_len(&c->output)); |
|
packet_start(SSH_MSG_CHANNEL_OUTPUT_CLOSE); |
packet_start(SSH_MSG_CHANNEL_OUTPUT_CLOSE); |
packet_put_int(c->remote_id); |
packet_put_int(c->remote_id); |
packet_send(); |
packet_send(); |
break; |
break; |
default: |
default: |
error("channel %d: 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; |
} |
} |
} |
} |
|
|
* the same for SSH2 |
* the same for SSH2 |
*/ |
*/ |
static void |
static void |
chan_rcvd_oclose2(Channel *c) |
chan_rcvd_close2(Channel *c) |
{ |
{ |
debug("channel %d: rcvd close", c->self); |
debug("channel %d: rcvd close", c->self); |
if (c->flags & CHAN_CLOSE_RCVD) |
if (c->flags & CHAN_CLOSE_RCVD) |
|
|
c->flags |= CHAN_CLOSE_RCVD; |
c->flags |= CHAN_CLOSE_RCVD; |
if (c->type == SSH_CHANNEL_LARVAL) { |
if (c->type == SSH_CHANNEL_LARVAL) { |
/* tear down larval channels immediately */ |
/* tear down larval channels immediately */ |
c->ostate = CHAN_OUTPUT_CLOSED; |
chan_set_ostate(c, CHAN_OUTPUT_CLOSED); |
c->istate = CHAN_INPUT_CLOSED; |
chan_set_istate(c, CHAN_INPUT_CLOSED); |
return; |
return; |
} |
} |
switch (c->ostate) { |
switch (c->ostate) { |
|
|
* wait until a data from the channel is consumed if a CLOSE |
* wait until a data from the channel is consumed if a CLOSE |
* is received |
* is received |
*/ |
*/ |
debug("channel %d: output open -> drain", c->self); |
chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN); |
c->ostate = CHAN_OUTPUT_WAIT_DRAIN; |
|
break; |
break; |
} |
} |
switch (c->istate) { |
switch (c->istate) { |
case CHAN_INPUT_OPEN: |
case CHAN_INPUT_OPEN: |
debug("channel %d: input open -> closed", c->self); |
|
chan_shutdown_read(c); |
chan_shutdown_read(c); |
|
chan_set_istate(c, CHAN_INPUT_CLOSED); |
break; |
break; |
case CHAN_INPUT_WAIT_DRAIN: |
case CHAN_INPUT_WAIT_DRAIN: |
debug("channel %d: input drain -> closed", c->self); |
|
chan_send_eof2(c); |
chan_send_eof2(c); |
|
chan_set_istate(c, CHAN_INPUT_CLOSED); |
break; |
break; |
} |
} |
c->istate = CHAN_INPUT_CLOSED; |
|
} |
} |
static void |
static void |
chan_ibuf_empty2(Channel *c) |
chan_rcvd_eof2(Channel *c) |
{ |
{ |
debug("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: |
|
debug("channel %d: input drain -> closed", c->self); |
|
if (!(c->flags & CHAN_CLOSE_SENT)) |
|
chan_send_eof2(c); |
|
c->istate = CHAN_INPUT_CLOSED; |
|
break; |
|
default: |
|
error("channel %d: chan_ibuf_empty for istate %d", |
|
c->self, c->istate); |
|
break; |
|
} |
|
} |
|
static void |
|
chan_rcvd_ieof2(Channel *c) |
|
{ |
|
debug("channel %d: rcvd eof", c->self); |
debug("channel %d: rcvd eof", c->self); |
if (c->ostate == CHAN_OUTPUT_OPEN) { |
c->flags |= CHAN_EOF_RCVD; |
debug("channel %d: output open -> drain", c->self); |
if (c->ostate == CHAN_OUTPUT_OPEN) |
c->ostate = CHAN_OUTPUT_WAIT_DRAIN; |
chan_set_ostate(c, CHAN_OUTPUT_WAIT_DRAIN); |
} |
|
} |
} |
static void |
static void |
chan_write_failed2(Channel *c) |
chan_write_failed2(Channel *c) |
|
|
debug("channel %d: write failed", c->self); |
debug("channel %d: write failed", c->self); |
switch (c->ostate) { |
switch (c->ostate) { |
case CHAN_OUTPUT_OPEN: |
case CHAN_OUTPUT_OPEN: |
debug("channel %d: output open -> closed", c->self); |
|
chan_shutdown_write(c); /* ?? */ |
|
c->ostate = CHAN_OUTPUT_CLOSED; |
|
break; |
|
case CHAN_OUTPUT_WAIT_DRAIN: |
case CHAN_OUTPUT_WAIT_DRAIN: |
debug("channel %d: output drain -> closed", c->self); |
|
chan_shutdown_write(c); |
chan_shutdown_write(c); |
c->ostate = CHAN_OUTPUT_CLOSED; |
chan_set_ostate(c, CHAN_OUTPUT_CLOSED); |
break; |
break; |
default: |
default: |
error("channel %d: chan_write_failed for ostate %d", |
error("channel %d: chan_write_failed for ostate %d", |
|
|
} |
} |
} |
} |
static void |
static void |
chan_obuf_empty2(Channel *c) |
|
{ |
|
debug("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: |
|
debug("channel %d: output drain -> closed", c->self); |
|
chan_shutdown_write(c); |
|
c->ostate = CHAN_OUTPUT_CLOSED; |
|
break; |
|
default: |
|
error("channel %d: chan_obuf_empty for ostate %d", |
|
c->self, c->ostate); |
|
break; |
|
} |
|
} |
|
static void |
|
chan_send_eof2(Channel *c) |
chan_send_eof2(Channel *c) |
{ |
{ |
debug("channel %d: send eof", c->self); |
debug("channel %d: send eof", c->self); |
|
|
packet_start(SSH2_MSG_CHANNEL_EOF); |
packet_start(SSH2_MSG_CHANNEL_EOF); |
packet_put_int(c->remote_id); |
packet_put_int(c->remote_id); |
packet_send(); |
packet_send(); |
|
c->flags |= CHAN_EOF_SENT; |
break; |
break; |
default: |
default: |
error("channel %d: cannot send eof for istate %d", |
error("channel %d: cannot send eof for istate %d", |
|
|
/* shared */ |
/* shared */ |
|
|
void |
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) |
chan_mark_dead(Channel *c) |
{ |
{ |
c->type = SSH_CHANNEL_ZOMBIE; |
c->type = SSH_CHANNEL_ZOMBIE; |
|
|
debug("channel %d: is dead", c->self); |
debug("channel %d: is dead", c->self); |
return 1; |
return 1; |
} |
} |
/* |
if ((datafellows & SSH_BUG_EXTEOF) && |
* we have to delay the close message if the efd (for stderr) is |
c->extended_usage == CHAN_EXTENDED_WRITE && |
* still active |
c->efd != -1 && |
*/ |
buffer_len(&c->extended) > 0) { |
if (((c->extended_usage != CHAN_EXTENDED_IGNORE) && |
debug2("channel %d: active efd: %d len %d", |
buffer_len(&c->extended) > 0) |
c->self, c->efd, buffer_len(&c->extended)); |
#if 0 |
return 0; |
|| ((c->extended_usage == CHAN_EXTENDED_READ) && |
} |
c->efd != -1) |
if (!(c->flags & CHAN_CLOSE_SENT)) { |
#endif |
if (send) { |
) { |
chan_send_close2(c); |
debug2("channel %d: active efd: %d len %d type %s", |
} else { |
c->self, c->efd, buffer_len(&c->extended), |
/* channel would be dead if we sent a close */ |
c->extended_usage==CHAN_EXTENDED_READ ? |
if (c->flags & CHAN_CLOSE_RCVD) { |
"read": "write"); |
debug("channel %d: almost dead", |
} else { |
c->self); |
if (!(c->flags & CHAN_CLOSE_SENT)) { |
return 1; |
if (send) { |
|
chan_send_close2(c); |
|
} else { |
|
/* channel would be dead if we sent a close */ |
|
if (c->flags & CHAN_CLOSE_RCVD) { |
|
debug("channel %d: almost dead", |
|
c->self); |
|
return 1; |
|
} |
|
} |
} |
} |
} |
if ((c->flags & CHAN_CLOSE_SENT) && |
|
(c->flags & CHAN_CLOSE_RCVD)) { |
|
debug("channel %d: is dead", c->self); |
|
return 1; |
|
} |
|
} |
} |
|
if ((c->flags & CHAN_CLOSE_SENT) && |
|
(c->flags & CHAN_CLOSE_RCVD)) { |
|
debug("channel %d: is dead", c->self); |
|
return 1; |
|
} |
return 0; |
return 0; |
} |
} |
|
|
void |
|
chan_init_iostates(Channel *c) |
|
{ |
|
c->ostate = CHAN_OUTPUT_OPEN; |
|
c->istate = CHAN_INPUT_OPEN; |
|
c->flags = 0; |
|
} |
|
|
|
/* init */ |
|
void |
|
chan_init(void) |
|
{ |
|
if (compat20) { |
|
chan_rcvd_oclose = chan_rcvd_oclose2; |
|
chan_read_failed = chan_read_failed_12; |
|
chan_ibuf_empty = chan_ibuf_empty2; |
|
|
|
chan_rcvd_ieof = chan_rcvd_ieof2; |
|
chan_write_failed = chan_write_failed2; |
|
chan_obuf_empty = chan_obuf_empty2; |
|
} else { |
|
chan_rcvd_oclose = chan_rcvd_oclose1; |
|
chan_read_failed = chan_read_failed_12; |
|
chan_ibuf_empty = chan_ibuf_empty1; |
|
|
|
chan_rcvd_ieof = chan_rcvd_ieof1; |
|
chan_write_failed = chan_write_failed1; |
|
chan_obuf_empty = chan_obuf_empty1; |
|
} |
|
} |
|
|
|
/* helper */ |
/* helper */ |
static void |
static void |
chan_shutdown_write(Channel *c) |
chan_shutdown_write(Channel *c) |
{ |
{ |
buffer_consume(&c->output, buffer_len(&c->output)); |
buffer_clear(&c->output); |
if (compat20 && c->type == SSH_CHANNEL_LARVAL) |
if (compat20 && c->type == SSH_CHANNEL_LARVAL) |
return; |
return; |
/* shutdown failure is allowed if write failed already */ |
/* shutdown failure is allowed if write failed already */ |