[BACK]Return to nchan.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/nchan.c between version 1.12 and 1.13

version 1.12, 2000/03/28 20:34:14 version 1.13, 2000/04/03 07:07:15
Line 37 
Line 37 
 #include "channels.h"  #include "channels.h"
 #include "nchan.h"  #include "nchan.h"
   
 static void chan_send_ieof(Channel *c);  #include "ssh2.h"
 static void chan_send_oclose(Channel *c);  #include "compat.h"
 static void chan_shutdown_write(Channel *c);  
 static void chan_shutdown_read(Channel *c);  
   
   /* functions manipulating channel states */
 /*  /*
  * 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) */  /* events concerning the INPUT from socket for channel (istate) */
 void  chan_event_fn *chan_rcvd_oclose                 = NULL;
 chan_rcvd_oclose(Channel *c)  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
    */
   static void     chan_send_ieof1(Channel *c);
   static void     chan_send_oclose1(Channel *c);
   static void     chan_send_close2(Channel *c);
   static void     chan_send_eof2(Channel *c);
   
   /* channel cleanup */
   chan_event_fn *chan_delete_if_full_closed       = NULL;
   
   /* helper */
   static void     chan_shutdown_write(Channel *c);
   static void     chan_shutdown_read(Channel *c);
   
   /*
    * SSH1 specific implementation of event functions
    */
   
   static void
   chan_rcvd_oclose1(Channel *c)
 {  {
           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 -> INPUT_CLOSED [rcvd OCLOSE]", c->self);                  debug("channel %d: input wait_oclose -> closed", c->self);
                 c->istate = CHAN_INPUT_CLOSED;                  c->istate = CHAN_INPUT_CLOSED;
                 break;                  break;
         case CHAN_INPUT_OPEN:          case CHAN_INPUT_OPEN:
                 debug("channel %d: INPUT_OPEN -> INPUT_CLOSED [rvcd OCLOSE, send IEOF]", c->self);                  debug("channel %d: input open -> closed", c->self);
                 chan_shutdown_read(c);                  chan_shutdown_read(c);
                 chan_send_ieof(c);                  chan_send_ieof1(c);
                 c->istate = CHAN_INPUT_CLOSED;                  c->istate = 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_WAIT_DRAIN -> INPUT_CLOSED [rvcd OCLOSE, send IEOF]", c->self);                  log("channel %d: input drain -> closed", c->self);
                 debug("channel %d: INPUT_WAIT_DRAIN -> INPUT_CLOSED [rvcd OCLOSE, send IEOF]", c->self);                  chan_send_ieof1(c);
                 chan_send_ieof(c);  
                 c->istate = CHAN_INPUT_CLOSED;                  c->istate = CHAN_INPUT_CLOSED;
                 break;                  break;
         default:          default:
                 error("protocol error: chan_rcvd_oclose %d for istate %d", c->self, c->istate);                  error("channel %d: protocol error: chan_rcvd_oclose for istate %d",
                       c->self, c->istate);
                 return;                  return;
         }          }
 }  }
 void  static void
 chan_read_failed(Channel *c)  chan_read_failed_12(Channel *c)
 {  {
           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 -> INPUT_WAIT_DRAIN [read failed]", 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;
                 break;                  break;
         default:          default:
                 error("internal error: we do not read, but chan_read_failed %d for istate %d",                  error("channel %d: internal error: we do not read, but chan_read_failed for istate %d",
                       c->self, c->istate);                      c->self, c->istate);
                 break;                  break;
         }          }
 }  }
 void  static void
 chan_ibuf_empty(Channel *c)  chan_ibuf_empty1(Channel *c)
 {  {
           debug("channel %d: ibuf empty", c->self);
         if (buffer_len(&c->input)) {          if (buffer_len(&c->input)) {
                 error("internal error: chan_ibuf_empty %d for non empty buffer", c->self);                  error("channel %d: internal error: chan_ibuf_empty for non empty buffer",
                       c->self);
                 return;                  return;
         }          }
         switch (c->istate) {          switch (c->istate) {
         case CHAN_INPUT_WAIT_DRAIN:          case CHAN_INPUT_WAIT_DRAIN:
                 debug("channel %d: INPUT_WAIT_DRAIN -> INPUT_WAIT_OCLOSE [inbuf empty, send IEOF]", c->self);                  debug("channel %d: input drain -> wait_oclose", c->self);
                 chan_send_ieof(c);                  chan_send_ieof1(c);
                 c->istate = CHAN_INPUT_WAIT_OCLOSE;                  c->istate = CHAN_INPUT_WAIT_OCLOSE;
                 break;                  break;
         default:          default:
                 error("internal error: chan_ibuf_empty %d for istate %d", c->self, c->istate);                  error("channel %d: internal error: chan_ibuf_empty for istate %d",
                       c->self, c->istate);
                 break;                  break;
         }          }
 }  }
   static void
 /* events concerning the OUTPUT from channel for socket (ostate) */  chan_rcvd_ieof1(Channel *c)
 void  
 chan_rcvd_ieof(Channel *c)  
 {  {
           debug("channel %d: rcvd ieof", c->self);
         switch (c->ostate) {          switch (c->ostate) {
         case CHAN_OUTPUT_OPEN:          case CHAN_OUTPUT_OPEN:
                 debug("channel %d: OUTPUT_OPEN -> OUTPUT_WAIT_DRAIN [rvcd IEOF]", c->self);                  debug("channel %d: output open -> drain", c->self);
                 c->ostate = 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 -> OUTPUT_CLOSED [rvcd IEOF]", c->self);                  debug("channel %d: output wait_ieof -> closed", c->self);
                 c->ostate = CHAN_OUTPUT_CLOSED;                  c->ostate = CHAN_OUTPUT_CLOSED;
                 break;                  break;
         default:          default:
                 error("protocol error: chan_rcvd_ieof %d for ostate %d", c->self, c->ostate);                  error("channel %d: protocol error: chan_rcvd_ieof for ostate %d",
                       c->self, c->ostate);
                 break;                  break;
         }          }
 }  }
 void  static void
 chan_write_failed(Channel *c)  chan_write_failed1(Channel *c)
 {  {
           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 -> OUTPUT_WAIT_IEOF [write failed]", c->self);                  debug("channel %d: output open -> wait_ieof", c->self);
                 chan_send_oclose(c);                  chan_send_oclose1(c);
                 c->ostate = CHAN_OUTPUT_WAIT_IEOF;                  c->ostate = CHAN_OUTPUT_WAIT_IEOF;
                 break;                  break;
         case CHAN_OUTPUT_WAIT_DRAIN:          case CHAN_OUTPUT_WAIT_DRAIN:
                 debug("channel %d: OUTPUT_WAIT_DRAIN -> OUTPUT_CLOSED [write failed]", c->self);                  debug("channel %d: output wait_drain -> closed", c->self);
                 chan_send_oclose(c);                  chan_send_oclose1(c);
                 c->ostate = CHAN_OUTPUT_CLOSED;                  c->ostate = CHAN_OUTPUT_CLOSED;
                 break;                  break;
         default:          default:
                 error("internal error: chan_write_failed %d for ostate %d", c->self, c->ostate);                  error("channel %d: internal error: chan_write_failed for ostate %d",
                       c->self, c->ostate);
                 break;                  break;
         }          }
 }  }
 void  static void
 chan_obuf_empty(Channel *c)  chan_obuf_empty1(Channel *c)
 {  {
           debug("channel %d: obuf empty", c->self);
         if (buffer_len(&c->output)) {          if (buffer_len(&c->output)) {
                 debug("internal error: chan_obuf_empty %d for non empty buffer", c->self);                  error("channel %d: internal error: chan_obuf_empty for non empty buffer",
                       c->self);
                 return;                  return;
         }          }
         switch (c->ostate) {          switch (c->ostate) {
         case CHAN_OUTPUT_WAIT_DRAIN:          case CHAN_OUTPUT_WAIT_DRAIN:
                 debug("channel %d: OUTPUT_WAIT_DRAIN -> OUTPUT_CLOSED [obuf empty, send OCLOSE]", c->self);                  debug("channel %d: output drain -> closed", c->self);
                 chan_send_oclose(c);                  chan_send_oclose1(c);
                 c->ostate = CHAN_OUTPUT_CLOSED;                  c->ostate = CHAN_OUTPUT_CLOSED;
                 break;                  break;
         default:          default:
                 error("internal error: chan_obuf_empty %d for ostate %d", c->self, c->ostate);                  error("channel %d: internal error: chan_obuf_empty for ostate %d",
                       c->self, c->ostate);
                 break;                  break;
         }          }
 }  }
   
 /*  
  * ACTIONS: should never update the channel states: c->istate or c->ostate  
  */  
 static void  static void
 chan_send_ieof(Channel *c)  chan_send_ieof1(Channel *c)
 {  {
           debug("channel %d: send ieof", c->self);
         switch (c->istate) {          switch (c->istate) {
         case CHAN_INPUT_OPEN:          case CHAN_INPUT_OPEN:
         case CHAN_INPUT_WAIT_DRAIN:          case CHAN_INPUT_WAIT_DRAIN:
Line 177 
Line 208 
                 packet_send();                  packet_send();
                 break;                  break;
         default:          default:
                 error("internal error: channel %d: cannot send IEOF for istate %d", c->self, c->istate);                  error("channel %d: internal error: cannot send ieof for istate %d",
                       c->self, c->istate);
                 break;                  break;
         }          }
 }  }
 static void  static void
 chan_send_oclose(Channel *c)  chan_send_oclose1(Channel *c)
 {  {
           debug("channel %d: send oclose", c->self);
         switch (c->ostate) {          switch (c->ostate) {
         case CHAN_OUTPUT_OPEN:          case CHAN_OUTPUT_OPEN:
         case CHAN_OUTPUT_WAIT_DRAIN:          case CHAN_OUTPUT_WAIT_DRAIN:
Line 194 
Line 227 
                 packet_send();                  packet_send();
                 break;                  break;
         default:          default:
                 error("internal error: channel %d: cannot send OCLOSE for ostate %d", c->self, c->istate);                  error("channel %d: internal error: cannot send oclose for ostate %d",
                        c->self, c->ostate);
                 break;                  break;
         }          }
 }  }
   static void
   chan_delete_if_full_closed1(Channel *c)
   {
           if (c->istate == CHAN_INPUT_CLOSED && c->ostate == CHAN_OUTPUT_CLOSED) {
                   debug("channel %d: full closed", c->self);
                   channel_free(c->self);
           }
   }
   
 /* helper */  /*
    * the same for SSH2
    */
 static void  static void
 chan_shutdown_write(Channel *c)  chan_rcvd_oclose2(Channel *c)
 {  {
         /* shutdown failure is allowed if write failed already */          debug("channel %d: rcvd close", c->self);
         debug("channel %d: shutdown_write", c->self);          if (c->flags & CHAN_CLOSE_RCVD)
         if (shutdown(c->sock, SHUT_WR) < 0)                  error("channel %d: protocol error: close rcvd twice", c->self);
                 debug("chan_shutdown_write failed for #%d/fd%d: %.100s",          c->flags |= CHAN_CLOSE_RCVD;
                       c->self, c->sock, strerror(errno));          if (c->type == SSH_CHANNEL_LARVAL) {
                   /* tear down larval channels immediately */
                   c->ostate = CHAN_OUTPUT_CLOSED;
                   c->istate = 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 */
                   debug("channel %d: output open -> drain", c->self);
                   c->ostate = CHAN_OUTPUT_WAIT_DRAIN;
                   break;
           }
           switch (c->istate) {
           case CHAN_INPUT_OPEN:
                   debug("channel %d: input open -> closed", c->self);
                   chan_shutdown_read(c);
                   break;
           case CHAN_INPUT_WAIT_DRAIN:
                   debug("channel %d: input drain -> closed", c->self);
                   chan_send_eof2(c);
                   break;
           }
           c->istate = CHAN_INPUT_CLOSED;
 }  }
 static void  static void
 chan_shutdown_read(Channel *c)  chan_ibuf_empty2(Channel *c)
 {  {
         debug("channel %d: shutdown_read", c->self);          debug("channel %d: ibuf empty", c->self);
         if (shutdown(c->sock, SHUT_RD) < 0)          if (buffer_len(&c->input)) {
                 error("chan_shutdown_read failed for #%d/fd%d [i%d o%d]: %.100s",                  error("channel %d: internal error: chan_ibuf_empty for non empty buffer",
                       c->self, c->sock, c->istate, c->ostate, strerror(errno));                       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: internal error: chan_ibuf_empty for istate %d",
                        c->self, c->istate);
                   break;
           }
 }  }
 void  static void
 chan_delete_if_full_closed(Channel *c)  chan_rcvd_ieof2(Channel *c)
 {  {
           debug("channel %d: rcvd eof", c->self);
           if (c->ostate == CHAN_OUTPUT_OPEN) {
                   debug("channel %d: output open -> drain", c->self);
                   c->ostate = CHAN_OUTPUT_WAIT_DRAIN;
           }
   }
   static void
   chan_write_failed2(Channel *c)
   {
           debug("channel %d: write failed", c->self);
           switch (c->ostate) {
           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:
                   debug("channel %d: output drain -> closed", c->self);
                   chan_shutdown_write(c);
                   c->ostate = CHAN_OUTPUT_CLOSED;
                   break;
           default:
                   error("channel %d: internal error: chan_write_failed for ostate %d",
                       c->self, c->ostate);
                   break;
           }
   }
   static void
   chan_obuf_empty2(Channel *c)
   {
           debug("channel %d: obuf empty", c->self);
           if (buffer_len(&c->output)) {
                   error("internal error: chan_obuf_empty %d 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: internal error: chan_obuf_empty for ostate %d",
                       c->self, c->ostate);
                   break;
           }
   }
   static void
   chan_send_eof2(Channel *c)
   {
           debug("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();
                   break;
           default:
                   error("channel %d: internal error: cannot send eof for istate %d",
                       c->self, c->istate);
                   break;
           }
   }
   static void
   chan_send_close2(Channel *c)
   {
           debug("channel %d: send close", c->self);
           if (c->ostate != CHAN_OUTPUT_CLOSED ||
               c->istate != CHAN_INPUT_CLOSED) {
                   error("channel %d: internal error: cannot send close for istate/ostate %d/%d",
                       c->self, c->istate, c->ostate);
           } else if (c->flags & CHAN_CLOSE_SENT) {
                   error("channel %d: internal error: 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;
           }
   }
   static void
   chan_delete_if_full_closed2(Channel *c)
   {
         if (c->istate == CHAN_INPUT_CLOSED && c->ostate == CHAN_OUTPUT_CLOSED) {          if (c->istate == CHAN_INPUT_CLOSED && c->ostate == CHAN_OUTPUT_CLOSED) {
                 debug("channel %d: full closed", c->self);                  if (!(c->flags & CHAN_CLOSE_SENT)) {
                 channel_free(c->self);                          chan_send_close2(c);
                   }
                   if ((c->flags & CHAN_CLOSE_SENT) &&
                       (c->flags & CHAN_CLOSE_RCVD)) {
                           debug("channel %d: full closed2", c->self);
                           channel_free(c->self);
                   }
         }          }
 }  }
   
   /* shared */
 void  void
 chan_init_iostates(Channel *c)  chan_init_iostates(Channel *c)
 {  {
         c->ostate = CHAN_OUTPUT_OPEN;          c->ostate = CHAN_OUTPUT_OPEN;
         c->istate = CHAN_INPUT_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;
   
                   chan_delete_if_full_closed      = chan_delete_if_full_closed2;
           } 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;
   
                   chan_delete_if_full_closed      = chan_delete_if_full_closed1;
           }
   }
   
   /* helper */
   static void
   chan_shutdown_write(Channel *c)
   {
           buffer_consume(&c->output, buffer_len(&c->output));
           if (compat20 && c->type == SSH_CHANNEL_LARVAL)
                   return;
           /* shutdown failure is allowed if write failed already */
           debug("channel %d: close_write", c->self);
           if (c->sock != -1) {
                   if (shutdown(c->sock, SHUT_WR) < 0)
                           debug("channel %d: chan_shutdown_write: shutdown() failed for fd%d: %.100s",
                               c->self, c->sock, strerror(errno));
           } else {
                   if (close(c->wfd) < 0)
                           log("channel %d: chan_shutdown_write: close() failed for fd%d: %.100s",
                               c->self, c->wfd, strerror(errno));
                   c->wfd = -1;
           }
   }
   static void
   chan_shutdown_read(Channel *c)
   {
           if (compat20 && c->type == SSH_CHANNEL_LARVAL)
                   return;
           debug("channel %d: close_read", c->self);
           if (c->sock != -1) {
                   if (shutdown(c->sock, SHUT_RD) < 0)
                           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 (close(c->rfd) < 0)
                           log("channel %d: chan_shutdown_read: close() failed for fd%d: %.100s",
                               c->self, c->rfd, strerror(errno));
                   c->rfd = -1;
           }
 }  }
Legend:
Removed from v.1.12  
changed lines
  Added in v.1.13